def __init__(self, name, **kwargs):
super().__init__(name, **kwargs)
channels = [1, 2, 3, 4]
channel_functions = [
'trigger_source', 'trigger_mode', 'clear_waveforms'
]
# functions = ['load_waveforms', 'load_sequence']
# Initialize waveforms and sequences
self._waveforms = [[] for k in channels]
for ch in channels:
for fn in channel_functions:
self.add_parameter('ch{}_{}'.format(ch, fn),
get_cmd=partial(self.print_function,
ch=ch,
function=fn,
mode='get'),
set_cmd=partial(self.print_function,
ch=ch,
function=fn,
mode='set'),
vals=vals.Anything())
self.add_function('ch{}_add_waveform'.format(ch),
call_cmd=partial(self._add_waveform, ch),
args=[vals.Anything()])
self.add_parameter('ch{}_sequence'.format(ch),
parameter_class=ManualParameter,
label='Channel {} Sequence'.format(ch),
initial_value=[],
vals=vals.Anything())
def __init__(self, name, alazar_name, **kwargs):
super().__init__(name, **kwargs)
self._alazar = self.find_instrument(alazar_name)
self._acquisition_settings = {}
functions = ['config', 'acquire']
for function in functions:
self.add_function(function,
call_cmd=partial(self.print_function,
function=function),
args=[vals.Anything()])
self.add_parameter('average_mode',
parameter_class=ManualParameter,
initial_value=None,
vals=vals.Anything())
self.add_parameter(name='acquisition_settings',
get_cmd=lambda: self._acquisition_settings)
self.add_parameter(name='acquisition',
names=['channel_signal'],
shapes=((),),
get_cmd=self._acquisition)
def __init__(self, name, **kwargs):
super().__init__(name, **kwargs)
functions = [
'stop', 'start', 'start_programming', 'stop_programming',
'detect_boards'
]
for function in functions:
self.add_function(function,
call_cmd=partial(self.print_function,
function=function))
functions = ['select_board']
for function in functions:
self.add_function(function,
call_cmd=partial(self.print_function,
function=function),
args=[vals.Anything()])
self.add_parameter('core_clock',
parameter_class=ManualParameter,
initial_value=500)
self.add_parameter('instructions',
parameter_class=ManualParameter,
initial_value=[],
vals=vals.Anything())
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 __init__(self, name, **kwargs):
super().__init__(name, **kwargs)
channels = ['A', 'B', 'C', 'D']
# Obtain a list of all valid ATS configuration settings
self._configuration_settings_names = list(
inspect.signature(self.config).parameters.keys())
# Obtain a list of all valid ATS acquisition settings
self._acquisition_settings_names = list(
inspect.signature(self.acquire).parameters.keys())
self._settings_names = self._acquisition_settings_names + \
self._configuration_settings_names
self._configuration_settings = {}
self._acquisition_settings = {}
self.add_parameter(name='configuration_settings',
get_cmd=lambda: self._configuration_settings)
self.add_parameter(name='acquisition_settings',
get_cmd=lambda: self._acquisition_settings)
for param in [
'clock_source', 'sample_rate', 'clock_edge', 'decimation',
'trigger_operation', 'external_trigger_coupling',
'external_trigger_range', 'trigger_delay', 'timeout_ticks',
'mode', 'sampled_per_record', 'records_per_buffer',
'bufers_per_acquisition', 'channel_selection',
'transfer_offset', 'external_startcapture',
'enable_record_headers', 'alloc_buffers',
'fifo_only_streaming', 'interleave_samples',
'get_processed_data', 'allocated_buffers', 'buffer_timeout'
]:
self.add_parameter(
name=param,
get_cmd=partial(self.get_setting, param),
# set_cmd=partial(self.set_setting, param),
vals=vals.Anything())
for idx in ['1', '2']:
for param in [
'trigger_engine', 'trigger_source', 'trigger_slope',
'trigger_level'
]:
self.add_parameter(
name=param + idx,
get_cmd=partial(self.get_setting, param + idx),
# set_cmd=partial(self.set_setting, param+idx),
vals=vals.Anything())
for idx, ch in enumerate(channels):
for param in ['coupling', 'channel_range', 'impedance']:
self.add_parameter(
name=param + ch,
get_cmd=partial(self.get_setting, param, idx=idx),
# set_cmd=partial(self.set_setting, param),
vals=vals.Anything())
def __init__(self, name, **kwargs):
super().__init__(name=name, **kwargs)
self.add_parameter(name='x_val',
get_cmd=lambda: self.x,
vals=vals.Anything())
self.add_parameter(name='pulse',
parameter_class=ManualParameter,
vals=vals.Anything())
self.add_parameter(name='pulse_sequence',
parameter_class=ManualParameter,
vals=vals.Anything())
def __init__(self,
name,
RF,
LO,
AWG=None,
acquisition_instr=None,
acquisition_instr_controller=None,
single_sideband_demod=False,
**kw):
self.RF = RF
self.common_init(name, LO, AWG, acquisition_instr,
single_sideband_demod, **kw)
self.add_parameter('RF_power',
label='RF power',
unit='dBm',
vals=vals.Numbers(),
set_cmd=self._set_RF_power,
get_cmd=self._get_RF_power)
self.add_parameter('acquisition_instr_controller',
set_cmd=self._set_acquisition_instr_controller,
get_cmd=self._get_acquisition_instr_controller,
vals=vals.Anything())
self.acquisition_instr_controller(acquisition_instr_controller)
self._RF_power = None
def __init__(self, name=None, label=None, unit=None, instrument=None,
value=None, byte_to_value_dict=None, vals=None):
if vals is None:
if byte_to_value_dict is None:
vals = validators.Anything()
else:
# TODO(damazter) (S) test this validator
vals = validators.Enum(*byte_to_value_dict.values())
super().__init__(name=name, label=label, unit=unit, vals=vals,
instrument=instrument)
self.instrument = instrument
self._byte = None
self._uptodate_flag = False
# TODO(damazter) (M) check this block
if byte_to_value_dict is None:
self._byte_to_value_dict = TrivialDictionary()
self._value_to_byte_dict = TrivialDictionary()
else:
self._byte_to_value_dict = byte_to_value_dict
self._value_to_byte_dict = {
v: k for k, v in self._byte_to_value_dict.items()}
self._set(value)
def add_parameter(self, name: str, **kw: Any) -> None:
"""Add a parameter.
:param name: name of the parameter.
if the name contains `.`s, then an element before a dot is interpreted
as a submodule. multiple dots represent nested submodules. I.e., when
we supply ``foo.bar.foo2`` we have a top-level submodule ``foo``,
containing a submodule ``bar``, containing the parameter ``foo2``.
Submodules are generated on demand.
:param kw: Any keyword arguments will be passed on to
qcodes.Instrument.add_parameter, except:
- ``set_cmd`` is always set to ``None``
- ``parameter_class`` is ``qcodes.Parameter``
- ``vals`` defaults to ``qcodes.utils.validators.Anything()``.
:return: None
"""
kw['parameter_class'] = Parameter
if 'vals' not in kw:
kw['vals'] = validators.Anything()
kw['set_cmd'] = None
parent = self._get_parent(name, create_parent=True)
if parent is self:
super().add_parameter(name.split('.')[-1], **kw)
else:
parent.add_parameter(name.split('.')[-1], **kw)
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)
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_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('dict_like',
unit='a.u.',
parameter_class=ManualParameter,
vals=vals.Dict())
self.add_parameter('status',
vals=vals.Anything(),
parameter_class=ManualParameter)
def __init__(self, name=None, label=None, unit=None, instrument=None,
value=None, byte_to_value_dict=None, vals=None):
warnings.warn("AlazarParamater is deprecated. Please replace with "
"Regular parameter or TraceParameter")
if vals is None:
if byte_to_value_dict is None:
vals = validators.Anything()
else:
# TODO(damazter) (S) test this validator
vals = validators.Enum(*byte_to_value_dict.values())
super().__init__(name=name, label=label, unit=unit, vals=vals,
instrument=instrument)
self._byte = None
self._uptodate_flag = False
# TODO(damazter) (M) check this block
if byte_to_value_dict is None:
self._byte_to_value_dict = TrivialDictionary()
self._value_to_byte_dict = TrivialDictionary()
else:
self._byte_to_value_dict = byte_to_value_dict
self._value_to_byte_dict = {
v: k for k, v in self._byte_to_value_dict.items()}
self._set(value)
def __init__(self,
instrument_name: str,
**kwargs):
# TODO: pass along actual instrument instead of name
super().__init__(name=instrument_name + '_interface', **kwargs)
self.instrument = self.find_instrument(name=instrument_name)
self._input_channels = {}
self._output_channels = {}
self._channels = {}
self.pulse_sequence = PulseSequence(allow_untargeted_pulses=False,
allow_pulse_overlap=False)
self.input_pulse_sequence = PulseSequence(
allow_untargeted_pulses=False, allow_pulse_overlap=False)
self.add_parameter('instrument_name',
set_cmd=None,
initial_value=instrument_name,
vals=vals.Anything())
self.add_parameter('is_primary',
set_cmd=None,
initial_value=False,
vals=vals.Bool())
self.pulse_implementations = []
def paramTypeFromVals(vals: validators.Validator) -> Union[ParameterTypes, None]:
if vals is None:
vals = validators.Anything()
for k, v in parameterTypes.items():
if isinstance(vals, v['validatorType']):
return k
return None
def __init__(self, name, board_number=0, **kwargs):
super().__init__(name, **kwargs)
# It seems that the core_clock is not the same as the sampling rate.
# At core_clock(500), the PulseBlaster uses 1 ns per wait duration.
# The wait duration is inversely proportional to the core clock, in contrast to the sampling rate
self.add_parameter('core_clock',
label='Core clock',
unit='MHz',
set_cmd=self.set_core_clock,
vals=vals.Numbers(0, 500))
self.add_parameter('board_number',
set_cmd=None,
initial_value=board_number)
self.add_function('initialize', call_cmd=self.initialize)
self.add_function('detect_boards', call_cmd=self.detect_boards)
self.add_function('select_board',
call_cmd=api.pb_select_board,
args=[vals.Enum(0, 1, 2, 3, 4)])
self.add_function('start_programming', call_cmd=self.start_programming)
self.add_function(
'send_instruction',
call_cmd=self.send_instruction,
args=[vals.Ints(),
vals.Strings(),
vals.Ints(),
vals.Ints()])
self.add_function('stop_programming', call_cmd=self.stop_programming)
self.add_function('start', call_cmd=self.start)
self.add_function('stop', call_cmd=self.stop)
self.add_function('close', call_cmd=self.close)
self.add_function('get_error', call_cmd=api.pb_get_error)
self.add_parameter('instruction_sequence',
set_cmd=None,
initial_value=[],
vals=vals.Anything(),
snapshot_value=False)
self.setup(initialize=True)
def __init__(self, name, UHFQC, **kw):
logging.warning('The UHFQC_LookuptableManagerManager is deprecated')
logging.info(__name__ + ' : Initializing instrument')
super().__init__(name, **kw)
self.UHFQC = UHFQC
self.add_parameter('mixer_QI_amp_ratio',
vals=vals.Numbers(),
parameter_class=ManualParameter,
initial_value=1.0)
self.add_parameter('mixer_IQ_phase_skewness',
vals=vals.Numbers(),
unit='deg',
parameter_class=ManualParameter,
initial_value=0.0)
# These parameters are added for mixer skewness correction.
# They are intended to be renamed such that they can be combined with
# mixer_QI_amp_ratio and mixer_IQ_phase_skewness.
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_apply_predistortion_matrix',
vals=vals.Bool(),
parameter_class=ManualParameter,
initial_value=False)
self.add_parameter('acquisition_delay',
vals=vals.Numbers(),
unit='s',
parameter_class=ManualParameter,
initial_value=270e-9)
self.add_parameter('LutMans',
vals=vals.Anything(),
set_cmd=self._attach_lutmans_to_Lutmanman)
self.add_parameter('sampling_rate',
vals=vals.Numbers(),
unit='Hz',
parameter_class=ManualParameter,
initial_value=1.8e9)
# Set to a default because box is not expected to change
self._voltage_min = -1.0
self._voltage_max = 1.0 - 1.0 / 2**13
def __init__(self, instrument_name, **kwargs):
super().__init__(instrument_name, **kwargs)
# Override untargeted pulse adding (measurement pulses can be added)
self.pulse_sequence.allow_untargeted_pulses = True
# Define instrument channels
# - Two input channels (ch1 and ch2)
# - One input trigger channel (trig_in)
self._acquisition_channels = {
f'ch{k}': Channel(instrument_name=self.instrument_name(),
name=f'ch{k}', id=k, input=True)
for k in [1,2]
}
self._channels = {
**self._acquisition_channels,
'trig_in': Channel(instrument_name=self.instrument_name(),
name='trig_in', input_trigger=True)
}
self.add_parameter(name='acquisition_channels',
set_cmd=None,
initial_value=[],
vals=vals.Anything(),
docstring='Names of acquisition channels '
'[chA, chB, etc.]. Set by the layout')
self.add_parameter(name='samples',
set_cmd=None,
initial_value=1,
docstring='Number of times to acquire the pulse '
'sequence.')
self.add_parameter(name='sample_rate',
set_cmd=None,
initial_value=1,
docstring='Number of times to acquire the pulse '
'sequence.')
# Noise factor used when generating traces
self.noise_factor = 0.6
self.blip_probability = 0.45 # Probability for fake blips during read pulse
self.blip_start = 0.25 # Maximum fraction for blip to start
self.blip_duration = 0.25 # Maximum duration for a blip
self.blip_read_amplitude = 0.3 # Maximum read amplitude
self.pulse_traces = {}
def __init__(self, parent, name, id, channel_api, **kwargs):
super().__init__(parent, name, **kwargs)
self.id = id
self.channel_api = channel_api
self._api = self.parent._api
self.trigger_mode = Parameter(
label=f"Channel {id} trigger mode",
vals=vals.Enum("single", "continuous", "stepped", "burst"),
)
self.trigger_source = Parameter(
label=f"Channel {id} trigger source",
vals=vals.Enum("stop", "start", "event_marker", "dc_trigger_in",
"fp_trigger_in"),
)
self.sampling_rate_prescaler = Parameter(
label=f"Channel {id} sampling rate prescaler",
vals=vals.MultiType(vals.Multiples(2), vals.Enum(1)),
)
self.max_voltage = Parameter(
label="Maximum waveform voltage",
unit="V",
set_cmd=None,
initial_value=6,
vals=vals.Numbers(),
docstring="Maximum waveform voltage. Any waveform added cannot have"
"a voltage higher than this.",
)
self.sequence = Parameter(
label=f"Channel {id} Sequence",
set_cmd=None,
initial_value=[],
vals=vals.Anything(),
log_changes=False,
snapshot_value=False,
) # Can we test for an (int, int) tuple list?
# Keep actual waveforms hidden so they cannot be directly set
# i.e. arbstudio.waveforms = waveform_list # Raises an error
# waveforms should be added via arbstudio.add_waveform
self._waveforms = []
def __init__(self, name, address, **kwargs):
super().__init__(name, address, terminator="\n\r", **kwargs)
self.add_parameter("switch_setting",
get_cmd="SWPORT?",
set_cmd=self._set_switch,
get_parser=dec_to_binstring,
set_parser=binstring_to_dec,
vals=vals.Anything())
# the device sends a single '\n' as a hello, messing everything up...
self.visa_handle.read_termination = "\n"
try:
self.visa_handle.read_raw()
except VisaIOError as e:
print("Minicircuit Switch did not send telnet handshake")
self.visa_handle.read_termination = "\n\r"
def __init__(self, name, address, min_delay=0.03, **kwargs):
super().__init__(name, address, **kwargs)
# The SIM900 has eight channels
self.number_of_channels = 8
# Dictionary with (channel, module) elements
self._modules = {}
self._last_visa_command = None
self.min_delay = min_delay
# Start with empty list of channels. These are
self.add_parameter(
"channels",
initial_value={},
set_cmd=None,
vals=vals.Anything(),
snapshot_value=False,
)
def __init__(self, name, seq_mode='off'):
if seq_mode is 'on':
io_mode = 'AUX_IN_TRIGGER_ENABLE'
io_param = 'TRIG_SLOPE_POSITIVE'
elif seq_mode is 'off':
io_mode = 'AUX_IN_AUXILIARY'
io_param = 'NONE'
else:
raise ValueError('must set seq mode to "on" or '
'"off", received {}'.format(seq_mode))
super().__init__(name=name)
self.config(clock_source='EXTERNAL_CLOCK_10MHz_REF',
sample_rate=500000000,
clock_edge='CLOCK_EDGE_RISING',
decimation=1,
coupling=['DC', 'DC'],
channel_range=[.4, .4],
impedance=[50, 50],
trigger_operation='TRIG_ENGINE_OP_J',
trigger_engine1='TRIG_ENGINE_J',
trigger_source1='EXTERNAL',
trigger_slope1='TRIG_SLOPE_POSITIVE',
trigger_level1=140,
trigger_engine2='TRIG_ENGINE_K',
trigger_source2='DISABLE',
trigger_slope2='TRIG_SLOPE_POSITIVE',
trigger_level2=128,
external_trigger_coupling='DC',
external_trigger_range='ETR_2V5',
trigger_delay=0,
timeout_ticks=0,
aux_io_mode=io_mode,
aux_io_param=io_param
)
self.add_parameter(name='seq_mode',
get_cmd=self._get_seq_mod,
set_cmd=self._set_seq_mode,
vals=vals.Anything()
)
def __init__(self, name, channels, **kwargs):
super().__init__(name, **kwargs)
self.add_parameter(name='channels',
set_cmd=None,
initial_value=channels,
vals=vals.Anything())
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(CBox_driven_transmon, self).__init__(name, **kw)
# Change this when inheriting directly from Transmon instead of
# from CBox driven Transmon.
# Adding instrument parameters
self.add_parameter('LO', parameter_class=InstrumentParameter)
self.add_parameter('cw_source', parameter_class=InstrumentParameter)
self.add_parameter('td_source', parameter_class=InstrumentParameter)
self.add_parameter('IVVI', parameter_class=InstrumentParameter)
self.add_parameter('FluxCtrl', parameter_class=InstrumentParameter)
self.add_parameter('AWG', parameter_class=InstrumentParameter)
self.add_parameter('heterodyne_instr',
parameter_class=InstrumentParameter)
self.add_parameter('LutMan', parameter_class=InstrumentParameter)
self.add_parameter('CBox', parameter_class=InstrumentParameter)
self.add_parameter('MC', parameter_class=InstrumentParameter)
self.add_parameter('RF_RO_source',
parameter_class=InstrumentParameter)
self.add_parameter('mod_amp_cw', label='RO modulation ampl cw',
unit='V', initial_value=0.5,
parameter_class=ManualParameter)
self.add_parameter('RO_power_cw', label='RO power cw',
unit='dBm',
parameter_class=ManualParameter)
self.add_parameter('spec_pow', label='spectroscopy power',
unit='dBm',
parameter_class=ManualParameter)
self.add_parameter('spec_pow_pulsed',
label='pulsed spectroscopy power',
unit='dBm',
parameter_class=ManualParameter)
self.add_parameter('td_source_pow',
label='Time-domain power',
unit='dBm',
parameter_class=ManualParameter)
self.add_parameter('spec_pulse_type', label='Pulsed spec pulse type',
parameter_class=ManualParameter,
initial_value='SquarePulse',
vals=vals.Enum('SquarePulse')) # , SSB_DRAG_pulse))
# we should also implement SSB_DRAG_pulse for pulsed spec
self.add_parameter('spec_pulse_length',
label='Pulsed spec pulse duration',
unit='s',
vals=vals.Numbers(1e-9, 20e-6),
parameter_class=ManualParameter)
self.add_parameter('spec_pulse_marker_channel',
unit='s',
vals=vals.Strings(),
parameter_class=ManualParameter)
self.add_parameter('spec_pulse_depletion_time',
unit='s',
vals=vals.Numbers(1e-9, 50e-6),
parameter_class=ManualParameter)
# Rename f_RO_mod
# Time-domain parameters
self.add_parameter('pulse_I_channel', initial_value='ch1',
vals=vals.Strings(),
parameter_class=ManualParameter)
self.add_parameter('pulse_Q_channel', initial_value='ch2',
vals=vals.Strings(),
parameter_class=ManualParameter)
self.add_parameter('pulse_I_offset', initial_value=0.0,
vals=vals.Numbers(min_value=-0.1, max_value=0.1),
parameter_class=ManualParameter)
self.add_parameter('pulse_Q_offset', initial_value=0.0,
vals=vals.Numbers(min_value=-0.1, max_value=0.1),
parameter_class=ManualParameter)
# readout parameters for time domain
self.add_parameter('RO_acq_averages', initial_value=1024,
vals=vals.Numbers(min_value=0, max_value=1e6),
parameter_class=ManualParameter)
self.add_parameter('RO_acq_integration_length', initial_value=1e-6,
vals=vals.Numbers(
min_value=10e-9, max_value=1000e-6),
parameter_class=ManualParameter)
self.add_parameter('RO_acq_weight_function_I', initial_value=0,
vals=vals.Ints(0, 5),
parameter_class=ManualParameter)
self.add_parameter('RO_acq_weight_function_Q', initial_value=1,
vals=vals.Ints(0, 5),
parameter_class=ManualParameter)
# These parameters are only relevant if using MW_IQmod_pulse type
# RO
self.add_parameter('RO_I_channel', initial_value='ch3',
vals=vals.Strings(),
parameter_class=ManualParameter)
self.add_parameter('RO_Q_channel', initial_value='ch4',
vals=vals.Strings(),
parameter_class=ManualParameter)
self.add_parameter('RO_I_offset', initial_value=0.0,
vals=vals.Numbers(min_value=-0.1, max_value=0.1),
parameter_class=ManualParameter)
self.add_parameter('RO_Q_offset', initial_value=0.0,
vals=vals.Numbers(min_value=-0.1, max_value=0.1),
parameter_class=ManualParameter)
self.add_parameter('RO_pulse_type', initial_value='MW_IQmod_pulse_tek',
vals=vals.Enum('MW_IQmod_pulse_tek',
'MW_IQmod_pulse_UHFQC',
'Gated_MW_RO_pulse'),
parameter_class=ManualParameter)
# Relevant when using a marker channel to gate a MW-RO tone.
self.add_parameter('RO_pulse_marker_channel',
vals=vals.Strings(),
parameter_class=ManualParameter)
self.add_parameter('RO_pulse_power', unit='dBm',
parameter_class=ManualParameter)
self.add_parameter('f_pulse_mod',
initial_value=-100e6,
label='pulse-modulation frequency', unit='Hz',
parameter_class=ManualParameter)
self.add_parameter('f_RO_mod',
label='Readout-modulation frequency', unit='Hz',
initial_value=-2e7,
parameter_class=ManualParameter)
self.add_parameter('amp180',
label='Pi-pulse amplitude', unit='V',
initial_value=.25,
vals=vals.Numbers(min_value=-2.25, max_value=2.25),
parameter_class=ManualParameter)
self.add_parameter('amp90_scale',
label='pulse amplitude scaling factor', unit='',
initial_value=.5,
vals=vals.Numbers(min_value=0, max_value=1.0),
parameter_class=ManualParameter)
self.add_parameter('gauss_sigma', unit='s',
initial_value=10e-9,
parameter_class=ManualParameter)
self.add_parameter('motzoi', label='Motzoi parameter', unit='',
initial_value=0,
parameter_class=ManualParameter)
self.add_parameter('phi_skew', label='IQ phase skewness', unit='deg',
vals=vals.Numbers(-180, 180),
initial_value=0,
parameter_class=ManualParameter)
self.add_parameter('alpha', label='QI amplitude skewness', unit='',
vals=vals.Numbers(.1, 2),
initial_value=1,
parameter_class=ManualParameter)
# Single shot readout specific parameters
self.add_parameter('RO_threshold', unit='dac-value',
initial_value=0,
parameter_class=ManualParameter)
# CBox specific parameter
self.add_parameter('signal_line', parameter_class=ManualParameter,
vals=vals.Enum(0, 1), initial_value=0)
self.add_parameter('acquisition_instr',
set_cmd=self._do_set_acquisition_instr,
get_cmd=self._do_get_acquisition_instr,
vals=vals.Strings())
self.add_parameter('flux_pulse_buffer',
label='Flux pulse buffer', unit='s',
initial_value=0.,
vals=vals.Numbers(min_value=0., max_value=50e-6),
parameter_class=ManualParameter)
self.add_parameter('fluxing_channel', initial_value='ch1',
vals=vals.Strings(),
parameter_class=ManualParameter)
self.add_parameter('fluxing_amp',
label='SWAP resolution', unit='V',
initial_value=.5,
vals=vals.Numbers(min_value=-1., max_value=1.),
parameter_class=ManualParameter)
self.add_parameter('SWAP_amp',
label='SWAP amplitude', unit='V',
initial_value=0.02,
vals=vals.Numbers(min_value=0.02, max_value=4.5),
parameter_class=ManualParameter)
self.add_parameter('SWAP_time',
label='SWAP Time', unit='s',
initial_value=0.,
vals=vals.Numbers(min_value=0., max_value=1e-6),
parameter_class=ManualParameter)
self.add_parameter('flux_dead_time',
label='Time between flux pulse and comp.', unit='s',
initial_value=0.,
vals=vals.Numbers(min_value=0., max_value=50e-6),
parameter_class=ManualParameter)
self.add_parameter('mw_to_flux_delay',
label='time between and mw pulse and start of flux pulse', unit='s',
initial_value=0.,
vals=vals.Numbers(min_value=0., max_value=50e-6),
parameter_class=ManualParameter)
self.add_parameter('dist_dict',
get_cmd=self.get_dist_dict,
set_cmd=self.set_dist_dict,
vals=vals.Anything())
def __init__(self, name, **kw):
t0 = time.time()
super().__init__(name, **kw)
# self._daq = zi.ziDAQServer(address, int(port), 5)
# if device.lower() == 'auto':
# self._device = zi_utils.autoDetect(self._daq)
# else:
# self._device = device
# self._daq.connectDevice(self._device, interface)
# #self._device = zi_utils.autoDetect(self._daq)
# self._awgModule = self._daq.awgModule()
# self._awgModule.set('awgModule/device', self._device)
# self._awgModule.execute()
self.acquisition_paths = []
s_node_pars = []
d_node_pars = []
path = os.path.abspath(__file__)
dir_path = os.path.dirname(path)
self._s_file_name = os.path.join(dir_path, 'zi_parameter_files',
's_node_pars.txt')
self._d_file_name = os.path.join(dir_path, 'zi_parameter_files',
'd_node_pars.txt')
init = True
try:
f = open(self._s_file_name).read()
s_node_pars = json.loads(f)
except Exception:
print("parameter file for gettable parameters {} not found".format(
self._s_file_name))
init = False
try:
f = open(self._d_file_name).read()
d_node_pars = json.loads(f)
except Exception:
print("parameter file for settable parameters {} not found".format(
self._d_file_name))
init = False
self.add_parameter('timeout',
unit='s',
initial_value=10,
parameter_class=ManualParameter)
for parameter in s_node_pars:
parname = parameter[0].replace("/", "_")
if parameter[1] == 'float':
self.add_parameter(parname,
parameter_class=ManualParameter,
vals=vals.Numbers(parameter[2],
parameter[3]))
elif parameter[1] == 'float_small':
self.add_parameter(parname,
parameter_class=ManualParameter,
vals=vals.Numbers(parameter[2],
parameter[3]))
elif parameter[1] == 'int_8bit':
self.add_parameter(parname,
parameter_class=ManualParameter,
vals=vals.Ints(int(parameter[2]),
int(parameter[3])))
elif parameter[1] == 'int':
self.add_parameter(parname,
parameter_class=ManualParameter,
vals=vals.Ints(int(parameter[2]),
int(parameter[3])))
elif parameter[1] == 'int_64':
self.add_parameter(parname,
parameter_class=ManualParameter,
vals=vals.Ints(int(parameter[2]),
int(parameter[3])))
elif parameter[1] == 'bool':
self.add_parameter(parname,
parameter_class=ManualParameter,
vals=vals.Ints(int(parameter[2]),
int(parameter[3])))
else:
print(
"parameter {} type {} from from s_node_pars not recognized"
.format(parname, parameter[1]))
for parameter in d_node_pars:
parname = parameter[0].replace("/", "_")
if parameter[1] == 'float':
self.add_parameter(parname, parameter_class=ManualParameter)
elif parameter[1] == 'vector_g':
self.add_parameter(parname, parameter_class=ManualParameter)
elif parameter[1] == 'vector_s':
self.add_parameter(parname,
parameter_class=ManualParameter,
vals=vals.Anything())
elif parameter[1] == 'vector_gs':
self.add_parameter(parname,
parameter_class=ManualParameter,
vals=vals.Anything())
else:
print("parameter {} type {} from d_node_pars not recognized".
format(parname, parameter[1]))
self.add_parameter('AWG_file',
parameter_class=ManualParameter,
vals=vals.Anything())
# storing an offset correction parameter for all weight functions,
# this allows normalized calibration when performing cross-talk suppressed
# readout
for i in range(5):
self.add_parameter(
"quex_trans_offset_weightfunction_{}".format(i),
unit='', # unit is adc value
label='RO normalization offset',
initial_value=0.0,
parameter_class=ManualParameter)
if init:
self.load_default_settings()
t1 = time.time()
print('Initialized dummy UHFQC', self.name, 'in %.2fs' % (t1 - t0))
def __init__(self,
name,
device='auto',
interface='USB',
address='127.0.0.1',
port=8004,
DIO=True,
nr_integration_channels=9,
**kw):
'''
Input arguments:
name: (str) name of the instrument
server_name: (str) qcodes instrument server
address: (int) the address of the data server e.g. 8006
'''
# self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
# #suggestion W vlothuizen
t0 = time.time()
super().__init__(name, **kw)
self.nr_integration_channels = nr_integration_channels
self.DIO = DIO
self._daq = zi.ziDAQServer(address, int(port), 5)
# self._daq.setDebugLevel(5)
if device.lower() == 'auto':
self._device = zi_utils.autoDetect(self._daq)
else:
self._device = device
self._daq.connectDevice(self._device, interface)
#self._device = zi_utils.autoDetect(self._daq)
self._awgModule = self._daq.awgModule()
self._awgModule.set('awgModule/device', self._device)
self._awgModule.execute()
self.acquisition_paths = []
s_node_pars = []
d_node_pars = []
path = os.path.abspath(__file__)
dir_path = os.path.dirname(path)
self._s_file_name = os.path.join(dir_path, 'zi_parameter_files',
's_node_pars.txt')
self._d_file_name = os.path.join(dir_path, 'zi_parameter_files',
'd_node_pars.txt')
init = True
try:
f = open(self._s_file_name).read()
s_node_pars = json.loads(f)
except:
print("parameter file for gettable parameters {} not found".format(
self._s_file_name))
init = False
try:
f = open(self._d_file_name).read()
d_node_pars = json.loads(f)
except:
print("parameter file for settable parameters {} not found".format(
self._d_file_name))
init = False
self.add_parameter('timeout',
unit='s',
initial_value=30,
parameter_class=ManualParameter)
for parameter in s_node_pars:
parname = parameter[0].replace("/", "_")
parfunc = "/" + self._device + "/" + parameter[0]
if parameter[1] == 'float':
self.add_parameter(
parname,
set_cmd=self._gen_set_func(self.setd, parfunc),
get_cmd=self._gen_get_func(self.getd, parfunc),
vals=vals.Numbers(parameter[2], parameter[3]))
elif parameter[1] == 'float_small':
self.add_parameter(
parname,
set_cmd=self._gen_set_func(self.setd, parfunc),
get_cmd=self._gen_get_func(self.getd, parfunc),
vals=vals.Numbers(parameter[2], parameter[3]))
elif parameter[1] == 'int_8bit':
self.add_parameter(
parname,
set_cmd=self._gen_set_func(self.seti, parfunc),
get_cmd=self._gen_get_func(self.geti, parfunc),
vals=vals.Ints(int(parameter[2]), int(parameter[3])))
elif parameter[1] == 'int':
self.add_parameter(
parname,
set_cmd=self._gen_set_func(self.seti, parfunc),
get_cmd=self._gen_get_func(self.geti, parfunc),
vals=vals.Ints(int(parameter[2]), int(parameter[3])))
elif parameter[1] == 'int_64':
self.add_parameter(
parname,
set_cmd=self._gen_set_func(self.seti, parfunc),
get_cmd=self._gen_get_func(self.geti, parfunc),
vals=vals.Ints(int(parameter[2]), int(parameter[3])))
elif parameter[1] == 'bool':
self.add_parameter(
parname,
set_cmd=self._gen_set_func(self.seti, parfunc),
get_cmd=self._gen_get_func(self.geti, parfunc),
vals=vals.Ints(int(parameter[2]), int(parameter[3])))
else:
print(
"parameter {} type {} from from s_node_pars not recognized"
.format(parname, parameter[1]))
for parameter in d_node_pars:
parname = parameter[0].replace("/", "_")
parfunc = "/" + self._device + "/" + parameter[0]
if parameter[1] == 'float':
self.add_parameter(parname,
get_cmd=self._gen_get_func(
self.getd, parfunc))
elif parameter[1] == 'vector_g':
self.add_parameter(parname,
get_cmd=self._gen_get_func(
self.getv, parfunc))
elif parameter[1] == 'vector_s':
self.add_parameter(parname,
set_cmd=self._gen_set_func(
self.setv, parfunc),
vals=vals.Anything())
elif parameter[1] == 'vector_gs':
self.add_parameter(
parname,
set_cmd=self._gen_set_func(self.setv, parfunc),
get_cmd=self._gen_get_func(self.getv, parfunc),
vals=vals.Anything())
else:
print("parameter {} type {} from d_node_pars not recognized".
format(parname, parameter[1]))
self.add_parameter('AWG_file',
set_cmd=self._do_set_AWG_file,
vals=vals.Anything())
# storing an offset correction parameter for all weight functions,
# this allows normalized calibration when performing cross-talk suppressed
# readout
for i in range(self.nr_integration_channels):
self.add_parameter(
"quex_trans_offset_weightfunction_{}".format(i),
unit='', # unit is adc value
label='RO normalization offset',
initial_value=0.0,
parameter_class=ManualParameter)
if init:
self.load_default_settings()
t1 = time.time()
print('Initialized UHFQC', self._device, 'in %.2fs' % (t1 - t0))
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 __init__(self, name, **kw):
logging.info(__name__ + ' : Initializing instrument')
super().__init__(name, **kw)
logging.warning('The ControlBox_LookuptableManager is deprecated.')
self.add_parameter('CBox',
parameter_class=InstrumentParameter)
self.add_parameter('awg_nr',
vals=vals.Ints(0, 2),
initial_value=0,
parameter_class=ManualParameter)
self.add_parameter('Q_amp180',
unit='V',
vals=vals.Numbers(-1, 1),
parameter_class=ManualParameter,
initial_value=0.1)
self.add_parameter('Q_amp90', unit='V',
vals=vals.Numbers(-1, 1),
parameter_class=ManualParameter,
initial_value=0.05)
self.add_parameter('Q_ampCW', unit='V',
vals=vals.Numbers(-1, 1),
parameter_class=ManualParameter,
initial_value=0.05)
self.add_parameter('Q_block_length', unit='s',
vals=vals.Numbers(1e-9, 640e-9),
parameter_class=ManualParameter,
initial_value=500e-9)
self.add_parameter('Q_motzoi_parameter', vals=vals.Numbers(-2, 2),
parameter_class=ManualParameter,
initial_value=0.0)
self.add_parameter('Q_gauss_width', vals=vals.Numbers(), unit='s',
parameter_class=ManualParameter,
initial_value=10e-9)
self.add_parameter('mixer_QI_amp_ratio', vals=vals.Numbers(),
parameter_class=ManualParameter,
initial_value=1.0)
self.add_parameter('mixer_IQ_phase_skewness', vals=vals.Numbers(),
unit='deg',
parameter_class=ManualParameter,
initial_value=0.0)
self.add_parameter('Q_modulation', vals=vals.Numbers(), unit='Hz',
parameter_class=ManualParameter,
initial_value=20.0e6)
self.add_parameter('Q_Rphi', label='Phase of Rphi pulse',
vals=vals.Numbers(), unit='deg',
parameter_class=ManualParameter,
initial_value=0)
self.add_parameter('sampling_rate', vals=vals.Numbers(), unit='Hz',
parameter_class=ManualParameter,
initial_value=0.2e9)
self.add_parameter('lut_mapping',
parameter_class=ManualParameter,
initial_value=['I', 'X180', 'Y180', 'X90', 'Y90',
'mX90', 'mY90', 'ModBlock'],
vals=vals.Anything())
# These parameters are added for mixer skewness correction.
# They are intended to be renamed such that they can be combined with
# mixer_QI_amp_ratio and mixer_IQ_phase_skewness.
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_apply_predistortion_matrix', vals=vals.Bool(),
parameter_class=ManualParameter,
initial_value=False)
self.add_parameter('M_modulation', vals=vals.Numbers(), unit='Hz',
parameter_class=ManualParameter,
initial_value=20.0e6)
self.add_parameter('M_length', unit='s',
vals=vals.Numbers(1e-9, 640e-9),
parameter_class=ManualParameter,
initial_value=300e-9)
self.add_parameter('M_amp', unit='V',
vals=vals.Numbers(0, 1),
parameter_class=ManualParameter,
initial_value=0.1)
self.add_parameter('M_phi', unit='deg',
parameter_class=ManualParameter,
initial_value=0.0)
self.add_parameter('M_up_length', unit='s',
vals=vals.Numbers(1e-9, 640e-9),
parameter_class=ManualParameter,
initial_value=100.0e-9)
self.add_parameter('M_up_amp', unit='V',
vals=vals.Numbers(0, 1),
parameter_class=ManualParameter,
initial_value=0.1)
self.add_parameter('M_up_phi', unit='deg',
parameter_class=ManualParameter,
initial_value=0.0)
self.add_parameter('M_down_length', unit='s',
vals=vals.Numbers(1e-9, 640e-9),
parameter_class=ManualParameter,
initial_value=200.0e-9)
self.add_parameter('M_down_amp0', unit='V',
vals=vals.Numbers(0, 1),
parameter_class=ManualParameter,
initial_value=0.1)
self.add_parameter('M_down_amp1', unit='V',
vals=vals.Numbers(0, 1),
parameter_class=ManualParameter,
initial_value=0.1)
self.add_parameter('M_down_phi0', unit='deg',
parameter_class=ManualParameter,
initial_value=180.0)
self.add_parameter('M_down_phi1', unit='deg',
parameter_class=ManualParameter,
initial_value=180.0)
self.add_parameter('M0_modulation', vals=vals.Numbers(), unit='Hz',
parameter_class=ManualParameter,
initial_value=20.0e6)
self.add_parameter('M1_modulation', vals=vals.Numbers(), unit='Hz',
parameter_class=ManualParameter,
initial_value=20.0e6)
# Set to a default because box is not expected to change
self._voltage_min = -1.0
self._voltage_max = 1.0-1.0/2**13
def __init__(self,
instrument_name: str,
acquisition_controller_names: List[str] = [],
default_settings={},
**kwargs):
# TODO: Change acquisition_controller_names to acquisition_controllers
super().__init__(instrument_name, **kwargs)
# Override untargeted pulse adding (measurement pulses can be added)
self.pulse_sequence.allow_untargeted_pulses = True
default_settings = {
'channel_range': 2,
'coupling': 'DC',
**default_settings
}
# Define channels
self._acquisition_channels = {
'ch' + idx: Channel(instrument_name=self.instrument_name(),
name='ch' + idx,
id=idx,
input=True)
for idx in ['A', 'B', 'C', 'D']
}
self._aux_channels = {
'aux' + idx: Channel(instrument_name=self.instrument_name(),
name='aux' + idx,
input_TTL=True,
output_TTL=(0, 5))
for idx in ['1', '2']
}
self._channels = {
**self._acquisition_channels,
**self._aux_channels, 'trig_in':
Channel(instrument_name=self.instrument_name(),
name='trig_in',
id='trig_in',
input_trigger=True),
'software_trig_out':
Channel(instrument_name=self.instrument_name(),
name='software_trig_out')
}
self.pulse_implementations = [
SteeredInitializationImplementation(pulse_requirements=[]),
TriggerWaitPulseImplementation(pulse_requirements=[])
]
# Organize acquisition controllers
self.acquisition_controllers = {}
for acquisition_controller_name in acquisition_controller_names:
self.add_acquisition_controller(acquisition_controller_name)
# Obtain a list of all valid ATS configuration settings
self._configuration_settings_names = sorted(
list(inspect.signature(AlazarTech_ATS.config).parameters.keys()))
# Obtain a list of all valid ATS acquisition settings
self._acquisition_settings_names = sorted(
list(inspect.signature(AlazarTech_ATS.acquire).parameters.keys()))
self._settings_names = sorted(self._acquisition_settings_names +
self._configuration_settings_names)
self.add_parameter(name='default_settings',
get_cmd=None,
set_cmd=None,
initial_value=default_settings,
docstring='Default settings to use when setting up '
'ATS for a pulse sequence')
initial_configuration_settings = {
k: v
for k, v in default_settings.items()
if k in self._configuration_settings_names
}
self.add_parameter(
name='configuration_settings',
get_cmd=None,
set_cmd=None,
vals=vals.Dict(allowed_keys=self._configuration_settings_names),
initial_value=initial_configuration_settings)
initial_acquisition_settings = {
k: v
for k, v in default_settings.items()
if k in self._acquisition_settings_names
}
self.add_parameter(
name='acquisition_settings',
get_cmd=None,
set_cmd=None,
vals=vals.Dict(allowed_keys=self._acquisition_settings_names),
initial_value=initial_acquisition_settings)
self.add_parameter(name="acquisition",
parameter_class=ATSAcquisitionParameter)
self.add_parameter(name='default_acquisition_controller',
set_cmd=None,
initial_value='None',
vals=vals.Enum(
None, 'None',
*self.acquisition_controllers.keys()))
self.add_parameter(name='acquisition_controller',
set_cmd=None,
vals=vals.Enum(
'None', *self.acquisition_controllers.keys()))
# Names of acquisition channels [chA, chB, etc.]
self.add_parameter(name='acquisition_channels',
set_cmd=None,
initial_value=[],
vals=vals.Anything(),
docstring='Names of acquisition channels '
'[chA, chB, etc.]. Set by the layout')
self.add_parameter(name='samples',
set_cmd=None,
initial_value=1,
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(name='trigger_channel',
set_cmd=None,
initial_value='trig_in',
vals=vals.Enum('trig_in', 'disable',
*self._acquisition_channels.keys()))
self.add_parameter(name='trigger_slope',
set_cmd=None,
vals=vals.Enum('positive', 'negative'))
self.add_parameter(name='trigger_threshold',
unit='V',
set_cmd=None,
vals=vals.Numbers())
self.add_parameter(
name='sample_rate',
unit='samples/sec',
get_cmd=partial(self.setting, 'sample_rate'),
set_cmd=lambda x: self.default_settings().update(sample_rate=x),
vals=vals.Numbers(),
docstring='Acquisition sampling rate (Hz)')
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.')
self.traces = {}
self.pulse_traces = {}
