Alazar Tech Drivers

Classes:

AcquisitionController(name, alazar_name, ...)	Compatibility class.
AlazarTechATS9360(name[, dll_path])	This class is the driver for the ATS9360 board it inherits from the ATS base class
AlazarTechATS9373(name[, dll_path])	This class is the driver for the ATS9373 board.
AlazarTechATS9440(name[, dll_path])	This class is the driver for the ATS9440 board it inherits from the ATS base class
AlazarTechATS9870(name[, dll_path])	This class is the driver for the ATS9870 board it inherits from the ATS base class
DemodulationAcquisitionController(name, ...)	This class represents an example acquisition controller.

class qcodes.instrument_drivers.AlazarTech.AcquisitionController(name: str, alazar_name: str, **kwargs: Any)

Bases: Instrument, AcquisitionInterface[Any], Generic[OutputType]

Compatibility class. The methods of AcquisitionController have been extracted. This class is the base class fro AcquisitionInterfaces that are intended to be QCoDeS instruments at the same time.

Parameters:

• name – The name of the AcquisitionController

• alazar_name – The name of the alazar instrument.

• **kwargs – kwargs are forwarded to base class.

Methods:

__class_getitem__(params)	Parameterizes a generic class.
__del__()	Close the instrument and remove its instance record.
__getitem__(key)	Delegate instrument['name'] to parameter or function 'name'.
__getstate__()	Prevent pickling instruments, and give a nice error message.
__repr__()	Simplified repr giving just the class and name.
add_function(name, **kwargs)	Bind one Function to this instrument.
add_parameter(name[, parameter_class])	Bind one Parameter to this instrument.
add_submodule(name, submodule)	Bind one submodule to this instrument.
ask(cmd)	Write a command string to the hardware and return a response.
ask_raw(cmd)	Low level method to write to the hardware and return a response.
buffer_done_callback(buffers_completed)	This method is called when a buffer is completed.
call(func_name, *args)	Shortcut for calling a function from its name.
close()	Irreversibly stop this instrument and free its resources.
close_all()	Try to close all instruments registered in _all_instruments This is handy for use with atexit to ensure that all instruments are closed when a python session is closed.
connect_message([idn_param, begin_time])	Print a standard message on initial connection to an instrument.
exist(name[, instrument_class])	Check if an instrument with a given names exists (i.e. is already instantiated).
find_instrument(name[, instrument_class])	Find an existing instrument by name.
get(param_name)	Shortcut for getting a parameter from its name.
get_component(full_name)	Recursively get a component of the instrument by full_name.
get_idn()	Parse a standard VISA *IDN? response into an ID dict.
handle_buffer(buffer[, buffer_number])	This method should store or process the information that is contained in the buffers obtained during the acquisition.
instances()	Get all currently defined instances of this instrument class.
invalidate_cache()	Invalidate the cache of all parameters on the instrument.
is_valid(instr_instance)	Check if a given instance of an instrument is valid: if an instrument has been closed, its instance is not longer a "valid" instrument.
load_metadata(metadata)	Load metadata into this classes metadata dictionary.
post_acquire()	This method should return any information you want to save from this acquisition.
pre_acquire()	This method is called immediately after 'AlazarStartCapture' is called
pre_start_capture()	Use this method to prepare yourself for the data acquisition The Alazar instrument will call this method right before 'AlazarStartCapture' is called
print_readable_snapshot([update, max_chars])	Prints a readable version of the snapshot.
record_instance(instance)	Record (a weak ref to) an instance in a class's instance list.
remove_instance(instance)	Remove a particular instance from the record.
set(param_name, value)	Shortcut for setting a parameter from its name and new value.
snapshot([update])	Decorate a snapshot dictionary with metadata.
snapshot_base([update, params_to_skip_update])	State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).
validate_status([verbose])	Validate the values of all gettable parameters
write(cmd)	Write a command string with NO response to the hardware.
write_raw(cmd)	Low level method to write a command string to the hardware.

Attributes:

ancestors	Ancestors in the form of a list of InstrumentBase
delegate_attr_dicts	A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.
delegate_attr_objects	A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.
full_name	Full name of the instrument.
label	Nicely formatted label of the instrument.
name	Full name of the instrument
name_parts	A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.
omit_delegate_attrs	A list of attribute names (strings) to not delegate to any other dictionary or object.
parent	The parent instrument.
root_instrument	The topmost parent of this module.
short_name	Short name of the instrument.
parameters	All the parameters supported by this instrument.
functions	All the functions supported by this instrument.
submodules	All the submodules of this instrument such as channel lists or logical groupings of parameters.
instrument_modules	All the InstrumentModule of this instrument Usually populated via add_submodule().

classmethod __class_getitem__(params)

Parameterizes a generic class.

At least, parameterizing a generic class is the main thing this method does. For example, for some generic class Foo, this is called when we do Foo[int] - there, with cls=Foo and params=int.

However, note that this method is also called when defining generic classes in the first place with class Foo(Generic[T]): ….

__del__() → None

Close the instrument and remove its instance record.

__getitem__(key: str) → Callable[..., Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

__repr__() → str

Simplified repr giving just the class and name.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[ParameterBase] | None = None, **kwargs: Any) → None

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

add_submodule(name: str, submodule: InstrumentModule | ChannelTuple) → None

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

Write a command string to the hardware and return a response.

Subclasses that transform cmd should override this method, and in it call super().ask(new_cmd). Subclasses that define a new hardware communication should instead override ask_raw.

Parameters:

cmd – The string to send to the instrument.

Returns:

response

Raises:

Exception – Wraps any underlying exception with extra context, including the command and the instrument.

ask_raw(cmd: str) → str

Low level method to write to the hardware and return a response.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override ask.

Parameters:

cmd – The string to send to the instrument.

buffer_done_callback(buffers_completed: int) → None

This method is called when a buffer is completed. It can be used if you want to implement an event that happens for each buffer. You will probably want to combine this with AUX_IN_TRIGGER_ENABLE to wait before starting capture of the next buffer.

Parameters:

buffers_completed – how many buffers have been completed and copied to local memory at the time of this callback.

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

close() → None

Irreversibly stop this instrument and free its resources.

Subclasses should override this if they have other specific resources to close.

classmethod close_all() → None

Try to close all instruments registered in _all_instruments This is handy for use with atexit to ensure that all instruments are closed when a python session is closed.

Examples

>>> atexit.register(qc.Instrument.close_all())

connect_message(idn_param: str = 'IDN', begin_time: float | None = None) → None

Print a standard message on initial connection to an instrument.

Parameters:

• idn_param – Name of parameter that returns ID dict. Default IDN.

• begin_time – time.time() when init started. Default is self._t0, set at start of Instrument.__init__.

delegate_attr_dicts: ClassVar[list[str]] = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects: ClassVar[list[str]] = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

static exist(name: str, instrument_class: type[Instrument] | None = None) → bool

Check if an instrument with a given names exists (i.e. is already instantiated).

Parameters:

• name – Name of the instrument.

• instrument_class – The type of instrument you are looking for.

classmethod find_instrument(name: str, instrument_class: type[T] | None = None) → T | Instrument

Find an existing instrument by name.

Parameters:

• name – Name of the instrument.

• instrument_class – The type of instrument you are looking for.

Returns:

The instrument found.

Raises:

• KeyError – If no instrument of that name was found, or if its reference is invalid (dead).

• TypeError – If a specific class was requested but a different type was found.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

get_idn() → dict[str, str | None]

Parse a standard VISA *IDN? response into an ID dict.

Even though this is the VISA standard, it applies to various other types as well, such as IPInstruments, so it is included here in the Instrument base class.

Override this if your instrument does not support *IDN? or returns a nonstandard IDN string. This string is supposed to be a comma-separated list of vendor, model, serial, and firmware, but semicolon and colon are also common separators so we accept them here as well.

Returns:

A dict containing vendor, model, serial, and firmware.

handle_buffer(buffer: ndarray, buffer_number: int | None = None) → None

This method should store or process the information that is contained in the buffers obtained during the acquisition.

Parameters:

• buffer – np.array with the data from the Alazar card

• buffer_number – counter for which buffer we are handling

classmethod instances() → list[T]

Get all currently defined instances of this instrument class.

You can use this to get the objects back if you lose track of them, and it’s also used by the test system to find objects to test against.

Returns:

A list of instances.

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

static is_valid(instr_instance: Instrument) → bool

Check if a given instance of an instrument is valid: if an instrument has been closed, its instance is not longer a “valid” instrument.

Parameters:

instr_instance – Instance of an Instrument class or its subclass.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs: ClassVar[list[str]] = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: InstrumentBase | None

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

post_acquire() → OutputType

This method should return any information you want to save from this acquisition. The acquisition method from the Alazar driver will use this data as its own return value

Returns:

this function should return all relevant data that you want to get form the acquisition

pre_acquire() → None

This method is called immediately after ‘AlazarStartCapture’ is called

pre_start_capture() → None

Use this method to prepare yourself for the data acquisition The Alazar instrument will call this method right before ‘AlazarStartCapture’ is called

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

classmethod record_instance(instance: Instrument) → None

Record (a weak ref to) an instance in a class’s instance list.

Also records the instance in list of all instruments, and verifies that there are no other instruments with the same name.

This method is called after initialization of the instrument is completed.

Parameters:

instance – Instance to record.

Raises:

KeyError – If another instance with the same name is already present.

classmethod remove_instance(instance: Instrument) → None

Remove a particular instance from the record.

Parameters:

instance – The instance to remove

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• update – If True, update the state by querying the instrument. If None update the state if known to be invalid. If False, just use the latest values in memory and never update state.

• params_to_skip_update – List of parameter names that will be skipped in update even if update is True. This is useful if you have parameters that are slow to update but can be updated in a different way (as in the qdac). If you want to skip the update of certain parameters in all snapshots, use the snapshot_get attribute of those parameters instead.

Returns:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

Write a command string with NO response to the hardware.

Subclasses that transform cmd should override this method, and in it call super().write(new_cmd). Subclasses that define a new hardware communication should instead override write_raw.

Parameters:

cmd – The string to send to the instrument.

Raises:

Exception – Wraps any underlying exception with extra context, including the command and the instrument.

write_raw(cmd: str) → None

Low level method to write a command string to the hardware.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override write.

Parameters:

cmd – The string to send to the instrument.

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}

class qcodes.instrument_drivers.AlazarTech.AlazarTechATS9360(name: str, dll_path: str = 'C:\\WINDOWS\\System32\\ATSApi.dll', **kwargs: Any)

Bases: AlazarTech_ATS

This class is the driver for the ATS9360 board it inherits from the ATS base class

Attributes:

samples_divisor
ancestors	Ancestors in the form of a list of InstrumentBase
channels
delegate_attr_dicts	A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.
delegate_attr_objects	A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.
dll_path
full_name	Full name of the instrument.
label	Nicely formatted label of the instrument.
name	Full name of the instrument
name_parts	A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.
omit_delegate_attrs	A list of attribute names (strings) to not delegate to any other dictionary or object.
parent	The parent instrument.
root_instrument	The topmost parent of this module.
short_name	Short name of the instrument.
api
parameters	All the parameters supported by this instrument.
functions	All the functions supported by this instrument.
submodules	All the submodules of this instrument such as channel lists or logical groupings of parameters.
instrument_modules	All the InstrumentModule of this instrument Usually populated via add_submodule().

Methods:

__del__()	Close the instrument and remove its instance record.
__getitem__(key)	Delegate instrument['name'] to parameter or function 'name'.
__getstate__()	Prevent pickling instruments, and give a nice error message.
__repr__()	Simplified repr giving just the class and name.
acquire([mode, samples_per_record, ...])	perform a single acquisition with the Alazar board, and set certain parameters to the appropriate values for the parameters, see the ATS-SDK programmer's guide
add_function(name, **kwargs)	Bind one Function to this instrument.
add_parameter(name[, parameter_class])	Bind one Parameter to this instrument.
add_submodule(name, submodule)	Bind one submodule to this instrument.
allocate_and_post_buffer(sample_type, n_bytes)
ask(cmd)	Write a command string to the hardware and return a response.
ask_raw(cmd)	Low level method to write to the hardware and return a response.
call(func_name, *args)	Shortcut for calling a function from its name.
clear_buffers()	This method uncommits all buffers that were committed by the driver.
close()	Irreversibly stop this instrument and free its resources.
close_all()	Try to close all instruments registered in _all_instruments This is handy for use with atexit to ensure that all instruments are closed when a python session is closed.
connect_message([idn_param, begin_time])	Print a standard message on initial connection to an instrument.
exist(name[, instrument_class])	Check if an instrument with a given names exists (i.e. is already instantiated).
find_boards([dll_path])	Find connected Alazar boards
find_instrument(name[, instrument_class])	Find an existing instrument by name.
get(param_name)	Shortcut for getting a parameter from its name.
get_board_info(api, system_id, board_id)	Get the information from a connected Alazar board
get_component(full_name)	Recursively get a component of the instrument by full_name.
get_idn()	This methods gets the most relevant information of this instrument
get_num_channels(byte_rep)	Return the number of channels for a specific channel mask
get_sample_rate([include_decimation])	Obtain the effective sampling rate of the acquisition based on clock speed and decimation
instances()	Get all currently defined instances of this instrument class.
invalidate_cache()	Invalidate the cache of all parameters on the instrument.
is_valid(instr_instance)	Check if a given instance of an instrument is valid: if an instrument has been closed, its instance is not longer a "valid" instrument.
load_metadata(metadata)	Load metadata into this classes metadata dictionary.
print_readable_snapshot([update, max_chars])	Prints a readable version of the snapshot.
record_instance(instance)	Record (a weak ref to) an instance in a class's instance list.
remove_instance(instance)	Remove a particular instance from the record.
set(param_name, value)	Shortcut for setting a parameter from its name and new value.
signal_to_volt(channel, signal)	convert a value from a buffer to an actual value in volts based on the ranges of the channel
snapshot([update])	Decorate a snapshot dictionary with metadata.
snapshot_base([update, params_to_skip_update])	State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).
sync_settings_to_card()	Syncs all parameters to Alazar card
syncing()	Context manager for syncing settings to Alazar card.
validate_status([verbose])	Validate the values of all gettable parameters
write(cmd)	Write a command string with NO response to the hardware.
write_raw(cmd)	Low level method to write a command string to the hardware.

samples_divisor = 128

__del__() → None

Close the instrument and remove its instance record.

__getitem__(key: str) → Callable[..., Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

__repr__() → str

Simplified repr giving just the class and name.

acquire(mode: str | None = None, samples_per_record: int | None = None, records_per_buffer: int | None = None, buffers_per_acquisition: int | None = None, channel_selection: str | None = None, transfer_offset: int | None = None, external_startcapture: str | None = None, enable_record_headers: str | None = None, alloc_buffers: str | None = None, fifo_only_streaming: str | None = None, interleave_samples: str | None = None, get_processed_data: str | None = None, allocated_buffers: int | None = None, buffer_timeout: int | None = None, acquisition_controller: AcquisitionController[OutputType] | None = None) → OutputType

perform a single acquisition with the Alazar board, and set certain parameters to the appropriate values for the parameters, see the ATS-SDK programmer’s guide

Parameters:

• mode

• samples_per_record

• records_per_buffer

• buffers_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

• acquisition_controller – An instance of an acquisition controller that handles the dataflow of an acquisition

Returns:

Whatever is given by acquisition_controller.post_acquire method

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[ParameterBase] | None = None, **kwargs: Any) → None

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

add_submodule(name: str, submodule: InstrumentModule | ChannelTuple) → None

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

allocate_and_post_buffer(sample_type: type[c_ubyte] | type[c_ushort] | type[c_uint] | type[c_int] | type[c_float], n_bytes: int) → Buffer

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

Write a command string to the hardware and return a response.

Subclasses that transform cmd should override this method, and in it call super().ask(new_cmd). Subclasses that define a new hardware communication should instead override ask_raw.

Parameters:

cmd – The string to send to the instrument.

Returns:

response

Raises:

Exception – Wraps any underlying exception with extra context, including the command and the instrument.

ask_raw(cmd: str) → str

Low level method to write to the hardware and return a response.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override ask.

Parameters:

cmd – The string to send to the instrument.

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

channels = 2

clear_buffers() → None

This method uncommits all buffers that were committed by the driver. This method only has to be called when the acquistion crashes, otherwise the driver will uncommit the buffers itself

Returns:

None

close() → None

Irreversibly stop this instrument and free its resources.

Subclasses should override this if they have other specific resources to close.

classmethod close_all() → None

Try to close all instruments registered in _all_instruments This is handy for use with atexit to ensure that all instruments are closed when a python session is closed.

Examples

>>> atexit.register(qc.Instrument.close_all())

connect_message(idn_param: str = 'IDN', begin_time: float | None = None) → None

Print a standard message on initial connection to an instrument.

Parameters:

• idn_param – Name of parameter that returns ID dict. Default IDN.

• begin_time – time.time() when init started. Default is self._t0, set at start of Instrument.__init__.

delegate_attr_dicts: ClassVar[list[str]] = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects: ClassVar[list[str]] = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

dll_path = 'C:\\WINDOWS\\System32\\ATSApi'

static exist(name: str, instrument_class: type[Instrument] | None = None) → bool

Check if an instrument with a given names exists (i.e. is already instantiated).

Parameters:

• name – Name of the instrument.

• instrument_class – The type of instrument you are looking for.

classmethod find_boards(dll_path: str | None = None) → list[dict[str, Any]]

Find connected Alazar boards

Parameters:

dll_path – path to the Alazar API DLL library

Returns:

list of board info dictionaries for each connected board

classmethod find_instrument(name: str, instrument_class: type[T] | None = None) → T | Instrument

Find an existing instrument by name.

Parameters:

• name – Name of the instrument.

• instrument_class – The type of instrument you are looking for.

Returns:

The instrument found.

Raises:

• KeyError – If no instrument of that name was found, or if its reference is invalid (dead).

• TypeError – If a specific class was requested but a different type was found.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

classmethod get_board_info(api: AlazarATSAPI, system_id: int, board_id: int) → dict[str, str | int]

Get the information from a connected Alazar board

Parameters:

• api – An AlazarATSAPI that wraps around the CTypes CDLL

• system_id – id of the Alazar system

• board_id – id of the board within the alazar system

Returns:

Dictionary containing

• system_id

• board_id

• board_kind (as string)

• max_samples

• bits_per_sample

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

get_idn() → dict[str, str | int | None]

This methods gets the most relevant information of this instrument

The firmware version reported should match the version number of downloadable fw files from AlazarTech. But note that the firmware version has often been found to be incorrect for several firmware versions. At the time of writing it is known to be correct for the 9360 (v 21.07) and 9373 (v 30.04) but incorrect for several earlier versions. In Alazar DSO this is reported as FPGA Version.

Returns:

Dictionary containing

• ’firmware’: as string

• ’model’: as string

• ’serial’: board serial number

• ’vendor’: ‘AlazarTech’

• ’CPLD_version’: version of the CPLD

• ’driver_version’: version of the driver dll

• ’SDK_version’: version of the SDK

• ’latest_cal_date’: date of the latest calibration (as string)

• ’memory_size’: size of the memory in samples

• ’asopc_type’: type of asopc (as decimal number)

• ’pcie_link_speed’: the speed of a single pcie link (in GB/s)

• ’pcie_link_width’: number of pcie links

• ’bits_per_sample’: number of bits per one sample

• ’max_samples’: board memory size in samples

static get_num_channels(byte_rep: int) → int

Return the number of channels for a specific channel mask

Each single channel is represented by a bitarray with one non zero entry i.e. powers of two. All multichannel masks can be constructed by summing the single channel ones. However, not all configurations are supported. See table 4 Input Channel Configurations on page 241 of the Alazar SDK manual. This contains the complete mapping for all current Alazar cards. It’s left to the driver to ensure that only the ones supported for a specific card can be selected

get_sample_rate(include_decimation: bool = True) → float

Obtain the effective sampling rate of the acquisition based on clock speed and decimation

Returns:

the number of samples (per channel) per second

classmethod instances() → list[T]

Get all currently defined instances of this instrument class.

You can use this to get the objects back if you lose track of them, and it’s also used by the test system to find objects to test against.

Returns:

A list of instances.

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

static is_valid(instr_instance: Instrument) → bool

Check if a given instance of an instrument is valid: if an instrument has been closed, its instance is not longer a “valid” instrument.

Parameters:

instr_instance – Instance of an Instrument class or its subclass.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs: ClassVar[list[str]] = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: InstrumentBase | None

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

classmethod record_instance(instance: Instrument) → None

Record (a weak ref to) an instance in a class’s instance list.

Also records the instance in list of all instruments, and verifies that there are no other instruments with the same name.

This method is called after initialization of the instrument is completed.

Parameters:

instance – Instance to record.

Raises:

KeyError – If another instance with the same name is already present.

classmethod remove_instance(instance: Instrument) → None

Remove a particular instance from the record.

Parameters:

instance – The instance to remove

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

signal_to_volt(channel: int, signal: float) → float

convert a value from a buffer to an actual value in volts based on the ranges of the channel

Parameters:

• channel – number of the channel where the signal value came from

• signal – the value that needs to be converted

Returns:

the corresponding value in volts

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• update – If True, update the state by querying the instrument. If None update the state if known to be invalid. If False, just use the latest values in memory and never update state.

• params_to_skip_update – List of parameter names that will be skipped in update even if update is True. This is useful if you have parameters that are slow to update but can be updated in a different way (as in the qdac). If you want to skip the update of certain parameters in all snapshots, use the snapshot_get attribute of those parameters instead.

Returns:

base snapshot

Return type:

dict

sync_settings_to_card() → None

Syncs all parameters to Alazar card

syncing() → Iterator[None]

Context manager for syncing settings to Alazar card. It will automatically call sync_settings_to_card at the end of the context.

Example

This is intended to be used around multiple parameter sets to ensure syncing is done exactly once:

with alazar.syncing():
     alazar.trigger_source1('EXTERNAL')
     alazar.trigger_level1(100)

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

Write a command string with NO response to the hardware.

Subclasses that transform cmd should override this method, and in it call super().write(new_cmd). Subclasses that define a new hardware communication should instead override write_raw.

Parameters:

cmd – The string to send to the instrument.

Raises:

Exception – Wraps any underlying exception with extra context, including the command and the instrument.

write_raw(cmd: str) → None

Low level method to write a command string to the hardware.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override write.

Parameters:

cmd – The string to send to the instrument.

api: AlazarATSAPI = api or AlazarATSAPI(dll_path or self.dll_path)

buffer_list: list[Buffer] = []

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}

class qcodes.instrument_drivers.AlazarTech.AlazarTechATS9373(name: str, dll_path: str = 'C:\\WINDOWS\\System32\\ATSApi.dll', **kwargs: Any)

Bases: AlazarTech_ATS

This class is the driver for the ATS9373 board.

Note that this board is very similar to ATS9360. Refer to ATS SDK for details.

Note that channels of this board have 12-bit resolution (see IDN()[‘bits_per_sample’]) which means that the raw data that is returned by the card should be converted to uint16 type with a bit shift by 4 bits. Refer to ATS SDK for more infromation.

Attributes:

samples_divisor
ancestors	Ancestors in the form of a list of InstrumentBase
channels
delegate_attr_dicts	A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.
delegate_attr_objects	A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.
dll_path
full_name	Full name of the instrument.
label	Nicely formatted label of the instrument.
name	Full name of the instrument
name_parts	A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.
omit_delegate_attrs	A list of attribute names (strings) to not delegate to any other dictionary or object.
parent	The parent instrument.
root_instrument	The topmost parent of this module.
short_name	Short name of the instrument.
api
parameters	All the parameters supported by this instrument.
functions	All the functions supported by this instrument.
submodules	All the submodules of this instrument such as channel lists or logical groupings of parameters.
instrument_modules	All the InstrumentModule of this instrument Usually populated via add_submodule().

Methods:

__del__()	Close the instrument and remove its instance record.
__getitem__(key)	Delegate instrument['name'] to parameter or function 'name'.
__getstate__()	Prevent pickling instruments, and give a nice error message.
__repr__()	Simplified repr giving just the class and name.
acquire([mode, samples_per_record, ...])	perform a single acquisition with the Alazar board, and set certain parameters to the appropriate values for the parameters, see the ATS-SDK programmer's guide
add_function(name, **kwargs)	Bind one Function to this instrument.
add_parameter(name[, parameter_class])	Bind one Parameter to this instrument.
add_submodule(name, submodule)	Bind one submodule to this instrument.
allocate_and_post_buffer(sample_type, n_bytes)
ask(cmd)	Write a command string to the hardware and return a response.
ask_raw(cmd)	Low level method to write to the hardware and return a response.
call(func_name, *args)	Shortcut for calling a function from its name.
clear_buffers()	This method uncommits all buffers that were committed by the driver.
close()	Irreversibly stop this instrument and free its resources.
close_all()	Try to close all instruments registered in _all_instruments This is handy for use with atexit to ensure that all instruments are closed when a python session is closed.
connect_message([idn_param, begin_time])	Print a standard message on initial connection to an instrument.
exist(name[, instrument_class])	Check if an instrument with a given names exists (i.e. is already instantiated).
find_boards([dll_path])	Find connected Alazar boards
find_instrument(name[, instrument_class])	Find an existing instrument by name.
get(param_name)	Shortcut for getting a parameter from its name.
get_board_info(api, system_id, board_id)	Get the information from a connected Alazar board
get_component(full_name)	Recursively get a component of the instrument by full_name.
get_idn()	This methods gets the most relevant information of this instrument
get_num_channels(byte_rep)	Return the number of channels for a specific channel mask
get_sample_rate([include_decimation])	Obtain the effective sampling rate of the acquisition based on clock speed and decimation
instances()	Get all currently defined instances of this instrument class.
invalidate_cache()	Invalidate the cache of all parameters on the instrument.
is_valid(instr_instance)	Check if a given instance of an instrument is valid: if an instrument has been closed, its instance is not longer a "valid" instrument.
load_metadata(metadata)	Load metadata into this classes metadata dictionary.
print_readable_snapshot([update, max_chars])	Prints a readable version of the snapshot.
record_instance(instance)	Record (a weak ref to) an instance in a class's instance list.
remove_instance(instance)	Remove a particular instance from the record.
set(param_name, value)	Shortcut for setting a parameter from its name and new value.
signal_to_volt(channel, signal)	convert a value from a buffer to an actual value in volts based on the ranges of the channel
snapshot([update])	Decorate a snapshot dictionary with metadata.
snapshot_base([update, params_to_skip_update])	State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).
sync_settings_to_card()	Syncs all parameters to Alazar card
syncing()	Context manager for syncing settings to Alazar card.
validate_status([verbose])	Validate the values of all gettable parameters
write(cmd)	Write a command string with NO response to the hardware.
write_raw(cmd)	Low level method to write a command string to the hardware.

samples_divisor = 128

__del__() → None

Close the instrument and remove its instance record.

__getitem__(key: str) → Callable[..., Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

__repr__() → str

Simplified repr giving just the class and name.

acquire(mode: str | None = None, samples_per_record: int | None = None, records_per_buffer: int | None = None, buffers_per_acquisition: int | None = None, channel_selection: str | None = None, transfer_offset: int | None = None, external_startcapture: str | None = None, enable_record_headers: str | None = None, alloc_buffers: str | None = None, fifo_only_streaming: str | None = None, interleave_samples: str | None = None, get_processed_data: str | None = None, allocated_buffers: int | None = None, buffer_timeout: int | None = None, acquisition_controller: AcquisitionController[OutputType] | None = None) → OutputType

perform a single acquisition with the Alazar board, and set certain parameters to the appropriate values for the parameters, see the ATS-SDK programmer’s guide

Parameters:

• mode

• samples_per_record

• records_per_buffer

• buffers_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

• acquisition_controller – An instance of an acquisition controller that handles the dataflow of an acquisition

Returns:

Whatever is given by acquisition_controller.post_acquire method

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[ParameterBase] | None = None, **kwargs: Any) → None

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

add_submodule(name: str, submodule: InstrumentModule | ChannelTuple) → None

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

allocate_and_post_buffer(sample_type: type[c_ubyte] | type[c_ushort] | type[c_uint] | type[c_int] | type[c_float], n_bytes: int) → Buffer

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

Write a command string to the hardware and return a response.

Subclasses that transform cmd should override this method, and in it call super().ask(new_cmd). Subclasses that define a new hardware communication should instead override ask_raw.

Parameters:

cmd – The string to send to the instrument.

Returns:

response

Raises:

Exception – Wraps any underlying exception with extra context, including the command and the instrument.

ask_raw(cmd: str) → str

Low level method to write to the hardware and return a response.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override ask.

Parameters:

cmd – The string to send to the instrument.

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

channels = 2

clear_buffers() → None

This method uncommits all buffers that were committed by the driver. This method only has to be called when the acquistion crashes, otherwise the driver will uncommit the buffers itself

Returns:

None

close() → None

Irreversibly stop this instrument and free its resources.

Subclasses should override this if they have other specific resources to close.

classmethod close_all() → None

Try to close all instruments registered in _all_instruments This is handy for use with atexit to ensure that all instruments are closed when a python session is closed.

Examples

>>> atexit.register(qc.Instrument.close_all())

connect_message(idn_param: str = 'IDN', begin_time: float | None = None) → None

Print a standard message on initial connection to an instrument.

Parameters:

• idn_param – Name of parameter that returns ID dict. Default IDN.

• begin_time – time.time() when init started. Default is self._t0, set at start of Instrument.__init__.

delegate_attr_dicts: ClassVar[list[str]] = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects: ClassVar[list[str]] = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

dll_path = 'C:\\WINDOWS\\System32\\ATSApi'

static exist(name: str, instrument_class: type[Instrument] | None = None) → bool

Check if an instrument with a given names exists (i.e. is already instantiated).

Parameters:

• name – Name of the instrument.

• instrument_class – The type of instrument you are looking for.

classmethod find_boards(dll_path: str | None = None) → list[dict[str, Any]]

Find connected Alazar boards

Parameters:

dll_path – path to the Alazar API DLL library

Returns:

list of board info dictionaries for each connected board

classmethod find_instrument(name: str, instrument_class: type[T] | None = None) → T | Instrument

Find an existing instrument by name.

Parameters:

• name – Name of the instrument.

• instrument_class – The type of instrument you are looking for.

Returns:

The instrument found.

Raises:

• KeyError – If no instrument of that name was found, or if its reference is invalid (dead).

• TypeError – If a specific class was requested but a different type was found.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

classmethod get_board_info(api: AlazarATSAPI, system_id: int, board_id: int) → dict[str, str | int]

Get the information from a connected Alazar board

Parameters:

• api – An AlazarATSAPI that wraps around the CTypes CDLL

• system_id – id of the Alazar system

• board_id – id of the board within the alazar system

Returns:

Dictionary containing

• system_id

• board_id

• board_kind (as string)

• max_samples

• bits_per_sample

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

get_idn() → dict[str, str | int | None]

This methods gets the most relevant information of this instrument

The firmware version reported should match the version number of downloadable fw files from AlazarTech. But note that the firmware version has often been found to be incorrect for several firmware versions. At the time of writing it is known to be correct for the 9360 (v 21.07) and 9373 (v 30.04) but incorrect for several earlier versions. In Alazar DSO this is reported as FPGA Version.

Returns:

Dictionary containing

• ’firmware’: as string

• ’model’: as string

• ’serial’: board serial number

• ’vendor’: ‘AlazarTech’

• ’CPLD_version’: version of the CPLD

• ’driver_version’: version of the driver dll

• ’SDK_version’: version of the SDK

• ’latest_cal_date’: date of the latest calibration (as string)

• ’memory_size’: size of the memory in samples

• ’asopc_type’: type of asopc (as decimal number)

• ’pcie_link_speed’: the speed of a single pcie link (in GB/s)

• ’pcie_link_width’: number of pcie links

• ’bits_per_sample’: number of bits per one sample

• ’max_samples’: board memory size in samples

static get_num_channels(byte_rep: int) → int

Return the number of channels for a specific channel mask

Each single channel is represented by a bitarray with one non zero entry i.e. powers of two. All multichannel masks can be constructed by summing the single channel ones. However, not all configurations are supported. See table 4 Input Channel Configurations on page 241 of the Alazar SDK manual. This contains the complete mapping for all current Alazar cards. It’s left to the driver to ensure that only the ones supported for a specific card can be selected

get_sample_rate(include_decimation: bool = True) → float

Obtain the effective sampling rate of the acquisition based on clock speed and decimation

Returns:

the number of samples (per channel) per second

classmethod instances() → list[T]

Get all currently defined instances of this instrument class.

You can use this to get the objects back if you lose track of them, and it’s also used by the test system to find objects to test against.

Returns:

A list of instances.

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

static is_valid(instr_instance: Instrument) → bool

Check if a given instance of an instrument is valid: if an instrument has been closed, its instance is not longer a “valid” instrument.

Parameters:

instr_instance – Instance of an Instrument class or its subclass.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs: ClassVar[list[str]] = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: InstrumentBase | None

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

classmethod record_instance(instance: Instrument) → None

Record (a weak ref to) an instance in a class’s instance list.

Also records the instance in list of all instruments, and verifies that there are no other instruments with the same name.

This method is called after initialization of the instrument is completed.

Parameters:

instance – Instance to record.

Raises:

KeyError – If another instance with the same name is already present.

classmethod remove_instance(instance: Instrument) → None

Remove a particular instance from the record.

Parameters:

instance – The instance to remove

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

signal_to_volt(channel: int, signal: float) → float

convert a value from a buffer to an actual value in volts based on the ranges of the channel

Parameters:

• channel – number of the channel where the signal value came from

• signal – the value that needs to be converted

Returns:

the corresponding value in volts

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• update – If True, update the state by querying the instrument. If None update the state if known to be invalid. If False, just use the latest values in memory and never update state.

• params_to_skip_update – List of parameter names that will be skipped in update even if update is True. This is useful if you have parameters that are slow to update but can be updated in a different way (as in the qdac). If you want to skip the update of certain parameters in all snapshots, use the snapshot_get attribute of those parameters instead.

Returns:

base snapshot

Return type:

dict

sync_settings_to_card() → None

Syncs all parameters to Alazar card

syncing() → Iterator[None]

Context manager for syncing settings to Alazar card. It will automatically call sync_settings_to_card at the end of the context.

Example

This is intended to be used around multiple parameter sets to ensure syncing is done exactly once:

with alazar.syncing():
     alazar.trigger_source1('EXTERNAL')
     alazar.trigger_level1(100)

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

Write a command string with NO response to the hardware.

Subclasses that transform cmd should override this method, and in it call super().write(new_cmd). Subclasses that define a new hardware communication should instead override write_raw.

Parameters:

cmd – The string to send to the instrument.

Raises:

Exception – Wraps any underlying exception with extra context, including the command and the instrument.

write_raw(cmd: str) → None

Low level method to write a command string to the hardware.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override write.

Parameters:

cmd – The string to send to the instrument.

api: AlazarATSAPI = api or AlazarATSAPI(dll_path or self.dll_path)

buffer_list: list[Buffer] = []

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}

class qcodes.instrument_drivers.AlazarTech.AlazarTechATS9440(name: str, dll_path: str = 'C:\\WINDOWS\\System32\\ATSApi.dll', **kwargs: Any)

Bases: AlazarTech_ATS

This class is the driver for the ATS9440 board it inherits from the ATS base class

Attributes:

samples_divisor
channels
ancestors	Ancestors in the form of a list of InstrumentBase
delegate_attr_dicts	A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.
delegate_attr_objects	A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.
dll_path
full_name	Full name of the instrument.
label	Nicely formatted label of the instrument.
name	Full name of the instrument
name_parts	A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.
omit_delegate_attrs	A list of attribute names (strings) to not delegate to any other dictionary or object.
parent	The parent instrument.
root_instrument	The topmost parent of this module.
short_name	Short name of the instrument.
api
parameters	All the parameters supported by this instrument.
functions	All the functions supported by this instrument.
submodules	All the submodules of this instrument such as channel lists or logical groupings of parameters.
instrument_modules	All the InstrumentModule of this instrument Usually populated via add_submodule().

Methods:

__del__()	Close the instrument and remove its instance record.
__getitem__(key)	Delegate instrument['name'] to parameter or function 'name'.
__getstate__()	Prevent pickling instruments, and give a nice error message.
__repr__()	Simplified repr giving just the class and name.
acquire([mode, samples_per_record, ...])	perform a single acquisition with the Alazar board, and set certain parameters to the appropriate values for the parameters, see the ATS-SDK programmer's guide
add_function(name, **kwargs)	Bind one Function to this instrument.
add_parameter(name[, parameter_class])	Bind one Parameter to this instrument.
add_submodule(name, submodule)	Bind one submodule to this instrument.
allocate_and_post_buffer(sample_type, n_bytes)
ask(cmd)	Write a command string to the hardware and return a response.
ask_raw(cmd)	Low level method to write to the hardware and return a response.
call(func_name, *args)	Shortcut for calling a function from its name.
clear_buffers()	This method uncommits all buffers that were committed by the driver.
close()	Irreversibly stop this instrument and free its resources.
close_all()	Try to close all instruments registered in _all_instruments This is handy for use with atexit to ensure that all instruments are closed when a python session is closed.
connect_message([idn_param, begin_time])	Print a standard message on initial connection to an instrument.
exist(name[, instrument_class])	Check if an instrument with a given names exists (i.e. is already instantiated).
find_boards([dll_path])	Find connected Alazar boards
find_instrument(name[, instrument_class])	Find an existing instrument by name.
get(param_name)	Shortcut for getting a parameter from its name.
get_board_info(api, system_id, board_id)	Get the information from a connected Alazar board
get_component(full_name)	Recursively get a component of the instrument by full_name.
get_idn()	This methods gets the most relevant information of this instrument
get_num_channels(byte_rep)	Return the number of channels for a specific channel mask
get_sample_rate([include_decimation])	Obtain the effective sampling rate of the acquisition based on clock speed and decimation
instances()	Get all currently defined instances of this instrument class.
invalidate_cache()	Invalidate the cache of all parameters on the instrument.
is_valid(instr_instance)	Check if a given instance of an instrument is valid: if an instrument has been closed, its instance is not longer a "valid" instrument.
load_metadata(metadata)	Load metadata into this classes metadata dictionary.
print_readable_snapshot([update, max_chars])	Prints a readable version of the snapshot.
record_instance(instance)	Record (a weak ref to) an instance in a class's instance list.
remove_instance(instance)	Remove a particular instance from the record.
set(param_name, value)	Shortcut for setting a parameter from its name and new value.
signal_to_volt(channel, signal)	convert a value from a buffer to an actual value in volts based on the ranges of the channel
snapshot([update])	Decorate a snapshot dictionary with metadata.
snapshot_base([update, params_to_skip_update])	State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).
sync_settings_to_card()	Syncs all parameters to Alazar card
syncing()	Context manager for syncing settings to Alazar card.
validate_status([verbose])	Validate the values of all gettable parameters
write(cmd)	Write a command string with NO response to the hardware.
write_raw(cmd)	Low level method to write a command string to the hardware.

samples_divisor = 32

channels = 4

__del__() → None

Close the instrument and remove its instance record.

__getitem__(key: str) → Callable[..., Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

__repr__() → str

Simplified repr giving just the class and name.

acquire(mode: str | None = None, samples_per_record: int | None = None, records_per_buffer: int | None = None, buffers_per_acquisition: int | None = None, channel_selection: str | None = None, transfer_offset: int | None = None, external_startcapture: str | None = None, enable_record_headers: str | None = None, alloc_buffers: str | None = None, fifo_only_streaming: str | None = None, interleave_samples: str | None = None, get_processed_data: str | None = None, allocated_buffers: int | None = None, buffer_timeout: int | None = None, acquisition_controller: AcquisitionController[OutputType] | None = None) → OutputType

perform a single acquisition with the Alazar board, and set certain parameters to the appropriate values for the parameters, see the ATS-SDK programmer’s guide

Parameters:

• mode

• samples_per_record

• records_per_buffer

• buffers_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

• acquisition_controller – An instance of an acquisition controller that handles the dataflow of an acquisition

Returns:

Whatever is given by acquisition_controller.post_acquire method

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[ParameterBase] | None = None, **kwargs: Any) → None

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

add_submodule(name: str, submodule: InstrumentModule | ChannelTuple) → None

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

allocate_and_post_buffer(sample_type: type[c_ubyte] | type[c_ushort] | type[c_uint] | type[c_int] | type[c_float], n_bytes: int) → Buffer

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

Write a command string to the hardware and return a response.

Subclasses that transform cmd should override this method, and in it call super().ask(new_cmd). Subclasses that define a new hardware communication should instead override ask_raw.

Parameters:

cmd – The string to send to the instrument.

Returns:

response

Raises:

Exception – Wraps any underlying exception with extra context, including the command and the instrument.

ask_raw(cmd: str) → str

Low level method to write to the hardware and return a response.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override ask.

Parameters:

cmd – The string to send to the instrument.

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

clear_buffers() → None

This method uncommits all buffers that were committed by the driver. This method only has to be called when the acquistion crashes, otherwise the driver will uncommit the buffers itself

Returns:

None

close() → None

Irreversibly stop this instrument and free its resources.

Subclasses should override this if they have other specific resources to close.

classmethod close_all() → None

Try to close all instruments registered in _all_instruments This is handy for use with atexit to ensure that all instruments are closed when a python session is closed.

Examples

>>> atexit.register(qc.Instrument.close_all())

connect_message(idn_param: str = 'IDN', begin_time: float | None = None) → None

Print a standard message on initial connection to an instrument.

Parameters:

• idn_param – Name of parameter that returns ID dict. Default IDN.

• begin_time – time.time() when init started. Default is self._t0, set at start of Instrument.__init__.

delegate_attr_dicts: ClassVar[list[str]] = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects: ClassVar[list[str]] = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

dll_path = 'C:\\WINDOWS\\System32\\ATSApi'

static exist(name: str, instrument_class: type[Instrument] | None = None) → bool

Check if an instrument with a given names exists (i.e. is already instantiated).

Parameters:

• name – Name of the instrument.

• instrument_class – The type of instrument you are looking for.

classmethod find_boards(dll_path: str | None = None) → list[dict[str, Any]]

Find connected Alazar boards

Parameters:

dll_path – path to the Alazar API DLL library

Returns:

list of board info dictionaries for each connected board

classmethod find_instrument(name: str, instrument_class: type[T] | None = None) → T | Instrument

Find an existing instrument by name.

Parameters:

• name – Name of the instrument.

• instrument_class – The type of instrument you are looking for.

Returns:

The instrument found.

Raises:

• KeyError – If no instrument of that name was found, or if its reference is invalid (dead).

• TypeError – If a specific class was requested but a different type was found.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

classmethod get_board_info(api: AlazarATSAPI, system_id: int, board_id: int) → dict[str, str | int]

Get the information from a connected Alazar board

Parameters:

• api – An AlazarATSAPI that wraps around the CTypes CDLL

• system_id – id of the Alazar system

• board_id – id of the board within the alazar system

Returns:

Dictionary containing

• system_id

• board_id

• board_kind (as string)

• max_samples

• bits_per_sample

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

get_idn() → dict[str, str | int | None]

This methods gets the most relevant information of this instrument

The firmware version reported should match the version number of downloadable fw files from AlazarTech. But note that the firmware version has often been found to be incorrect for several firmware versions. At the time of writing it is known to be correct for the 9360 (v 21.07) and 9373 (v 30.04) but incorrect for several earlier versions. In Alazar DSO this is reported as FPGA Version.

Returns:

Dictionary containing

• ’firmware’: as string

• ’model’: as string

• ’serial’: board serial number

• ’vendor’: ‘AlazarTech’

• ’CPLD_version’: version of the CPLD

• ’driver_version’: version of the driver dll

• ’SDK_version’: version of the SDK

• ’latest_cal_date’: date of the latest calibration (as string)

• ’memory_size’: size of the memory in samples

• ’asopc_type’: type of asopc (as decimal number)

• ’pcie_link_speed’: the speed of a single pcie link (in GB/s)

• ’pcie_link_width’: number of pcie links

• ’bits_per_sample’: number of bits per one sample

• ’max_samples’: board memory size in samples

static get_num_channels(byte_rep: int) → int

Return the number of channels for a specific channel mask

Each single channel is represented by a bitarray with one non zero entry i.e. powers of two. All multichannel masks can be constructed by summing the single channel ones. However, not all configurations are supported. See table 4 Input Channel Configurations on page 241 of the Alazar SDK manual. This contains the complete mapping for all current Alazar cards. It’s left to the driver to ensure that only the ones supported for a specific card can be selected

get_sample_rate(include_decimation: bool = True) → float

Obtain the effective sampling rate of the acquisition based on clock speed and decimation

Returns:

the number of samples (per channel) per second

classmethod instances() → list[T]

Get all currently defined instances of this instrument class.

You can use this to get the objects back if you lose track of them, and it’s also used by the test system to find objects to test against.

Returns:

A list of instances.

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

static is_valid(instr_instance: Instrument) → bool

Check if a given instance of an instrument is valid: if an instrument has been closed, its instance is not longer a “valid” instrument.

Parameters:

instr_instance – Instance of an Instrument class or its subclass.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs: ClassVar[list[str]] = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: InstrumentBase | None

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

classmethod record_instance(instance: Instrument) → None

Record (a weak ref to) an instance in a class’s instance list.

Also records the instance in list of all instruments, and verifies that there are no other instruments with the same name.

This method is called after initialization of the instrument is completed.

Parameters:

instance – Instance to record.

Raises:

KeyError – If another instance with the same name is already present.

classmethod remove_instance(instance: Instrument) → None

Remove a particular instance from the record.

Parameters:

instance – The instance to remove

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

signal_to_volt(channel: int, signal: float) → float

convert a value from a buffer to an actual value in volts based on the ranges of the channel

Parameters:

• channel – number of the channel where the signal value came from

• signal – the value that needs to be converted

Returns:

the corresponding value in volts

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• update – If True, update the state by querying the instrument. If None update the state if known to be invalid. If False, just use the latest values in memory and never update state.

• params_to_skip_update – List of parameter names that will be skipped in update even if update is True. This is useful if you have parameters that are slow to update but can be updated in a different way (as in the qdac). If you want to skip the update of certain parameters in all snapshots, use the snapshot_get attribute of those parameters instead.

Returns:

base snapshot

Return type:

dict

sync_settings_to_card() → None

Syncs all parameters to Alazar card

syncing() → Iterator[None]

Context manager for syncing settings to Alazar card. It will automatically call sync_settings_to_card at the end of the context.

Example

This is intended to be used around multiple parameter sets to ensure syncing is done exactly once:

with alazar.syncing():
     alazar.trigger_source1('EXTERNAL')
     alazar.trigger_level1(100)

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

Write a command string with NO response to the hardware.

Subclasses that transform cmd should override this method, and in it call super().write(new_cmd). Subclasses that define a new hardware communication should instead override write_raw.

Parameters:

cmd – The string to send to the instrument.

Raises:

Exception – Wraps any underlying exception with extra context, including the command and the instrument.

write_raw(cmd: str) → None

Low level method to write a command string to the hardware.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override write.

Parameters:

cmd – The string to send to the instrument.

api: AlazarATSAPI = api or AlazarATSAPI(dll_path or self.dll_path)

buffer_list: list[Buffer] = []

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}

class qcodes.instrument_drivers.AlazarTech.AlazarTechATS9870(name: str, dll_path: str = 'C:\\WINDOWS\\System32\\ATSApi.dll', **kwargs: Any)

Bases: AlazarTech_ATS

This class is the driver for the ATS9870 board it inherits from the ATS base class

It creates all necessary parameters for the Alazar card

Methods:

__del__()	Close the instrument and remove its instance record.
__getitem__(key)	Delegate instrument['name'] to parameter or function 'name'.
__getstate__()	Prevent pickling instruments, and give a nice error message.
__repr__()	Simplified repr giving just the class and name.
acquire([mode, samples_per_record, ...])	perform a single acquisition with the Alazar board, and set certain parameters to the appropriate values for the parameters, see the ATS-SDK programmer's guide
add_function(name, **kwargs)	Bind one Function to this instrument.
add_parameter(name[, parameter_class])	Bind one Parameter to this instrument.
add_submodule(name, submodule)	Bind one submodule to this instrument.
allocate_and_post_buffer(sample_type, n_bytes)
ask(cmd)	Write a command string to the hardware and return a response.
ask_raw(cmd)	Low level method to write to the hardware and return a response.
call(func_name, *args)	Shortcut for calling a function from its name.
clear_buffers()	This method uncommits all buffers that were committed by the driver.
close()	Irreversibly stop this instrument and free its resources.
close_all()	Try to close all instruments registered in _all_instruments This is handy for use with atexit to ensure that all instruments are closed when a python session is closed.
connect_message([idn_param, begin_time])	Print a standard message on initial connection to an instrument.
exist(name[, instrument_class])	Check if an instrument with a given names exists (i.e. is already instantiated).
find_boards([dll_path])	Find connected Alazar boards
find_instrument(name[, instrument_class])	Find an existing instrument by name.
get(param_name)	Shortcut for getting a parameter from its name.
get_board_info(api, system_id, board_id)	Get the information from a connected Alazar board
get_component(full_name)	Recursively get a component of the instrument by full_name.
get_idn()	This methods gets the most relevant information of this instrument
get_num_channels(byte_rep)	Return the number of channels for a specific channel mask
get_sample_rate([include_decimation])	Obtain the effective sampling rate of the acquisition based on clock speed and decimation
instances()	Get all currently defined instances of this instrument class.
invalidate_cache()	Invalidate the cache of all parameters on the instrument.
is_valid(instr_instance)	Check if a given instance of an instrument is valid: if an instrument has been closed, its instance is not longer a "valid" instrument.
load_metadata(metadata)	Load metadata into this classes metadata dictionary.
print_readable_snapshot([update, max_chars])	Prints a readable version of the snapshot.
record_instance(instance)	Record (a weak ref to) an instance in a class's instance list.
remove_instance(instance)	Remove a particular instance from the record.
set(param_name, value)	Shortcut for setting a parameter from its name and new value.
signal_to_volt(channel, signal)	convert a value from a buffer to an actual value in volts based on the ranges of the channel
snapshot([update])	Decorate a snapshot dictionary with metadata.
snapshot_base([update, params_to_skip_update])	State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).
sync_settings_to_card()	Syncs all parameters to Alazar card
syncing()	Context manager for syncing settings to Alazar card.
validate_status([verbose])	Validate the values of all gettable parameters
write(cmd)	Write a command string with NO response to the hardware.
write_raw(cmd)	Low level method to write a command string to the hardware.

Attributes:

ancestors	Ancestors in the form of a list of InstrumentBase
channels
delegate_attr_dicts	A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.
delegate_attr_objects	A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.
dll_path
full_name	Full name of the instrument.
label	Nicely formatted label of the instrument.
name	Full name of the instrument
name_parts	A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.
omit_delegate_attrs	A list of attribute names (strings) to not delegate to any other dictionary or object.
parent	The parent instrument.
root_instrument	The topmost parent of this module.
short_name	Short name of the instrument.
api
parameters	All the parameters supported by this instrument.
functions	All the functions supported by this instrument.
submodules	All the submodules of this instrument such as channel lists or logical groupings of parameters.
instrument_modules	All the InstrumentModule of this instrument Usually populated via add_submodule().

__del__() → None

Close the instrument and remove its instance record.

__getitem__(key: str) → Callable[..., Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

__repr__() → str

Simplified repr giving just the class and name.

acquire(mode: str | None = None, samples_per_record: int | None = None, records_per_buffer: int | None = None, buffers_per_acquisition: int | None = None, channel_selection: str | None = None, transfer_offset: int | None = None, external_startcapture: str | None = None, enable_record_headers: str | None = None, alloc_buffers: str | None = None, fifo_only_streaming: str | None = None, interleave_samples: str | None = None, get_processed_data: str | None = None, allocated_buffers: int | None = None, buffer_timeout: int | None = None, acquisition_controller: AcquisitionController[OutputType] | None = None) → OutputType

perform a single acquisition with the Alazar board, and set certain parameters to the appropriate values for the parameters, see the ATS-SDK programmer’s guide

Parameters:

• mode

• samples_per_record

• records_per_buffer

• buffers_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

• acquisition_controller – An instance of an acquisition controller that handles the dataflow of an acquisition

Returns:

Whatever is given by acquisition_controller.post_acquire method

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[ParameterBase] | None = None, **kwargs: Any) → None

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

add_submodule(name: str, submodule: InstrumentModule | ChannelTuple) → None

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

allocate_and_post_buffer(sample_type: type[c_ubyte] | type[c_ushort] | type[c_uint] | type[c_int] | type[c_float], n_bytes: int) → Buffer

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

Write a command string to the hardware and return a response.

Subclasses that transform cmd should override this method, and in it call super().ask(new_cmd). Subclasses that define a new hardware communication should instead override ask_raw.

Parameters:

cmd – The string to send to the instrument.

Returns:

response

Raises:

Exception – Wraps any underlying exception with extra context, including the command and the instrument.

ask_raw(cmd: str) → str

Low level method to write to the hardware and return a response.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override ask.

Parameters:

cmd – The string to send to the instrument.

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

channels = 2

clear_buffers() → None

This method uncommits all buffers that were committed by the driver. This method only has to be called when the acquistion crashes, otherwise the driver will uncommit the buffers itself

Returns:

None

close() → None

Irreversibly stop this instrument and free its resources.

Subclasses should override this if they have other specific resources to close.

classmethod close_all() → None

Try to close all instruments registered in _all_instruments This is handy for use with atexit to ensure that all instruments are closed when a python session is closed.

Examples

>>> atexit.register(qc.Instrument.close_all())

connect_message(idn_param: str = 'IDN', begin_time: float | None = None) → None

Print a standard message on initial connection to an instrument.

Parameters:

• idn_param – Name of parameter that returns ID dict. Default IDN.

• begin_time – time.time() when init started. Default is self._t0, set at start of Instrument.__init__.

delegate_attr_dicts: ClassVar[list[str]] = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects: ClassVar[list[str]] = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

dll_path = 'C:\\WINDOWS\\System32\\ATSApi'

static exist(name: str, instrument_class: type[Instrument] | None = None) → bool

Check if an instrument with a given names exists (i.e. is already instantiated).

Parameters:

• name – Name of the instrument.

• instrument_class – The type of instrument you are looking for.

classmethod find_boards(dll_path: str | None = None) → list[dict[str, Any]]

Find connected Alazar boards

Parameters:

dll_path – path to the Alazar API DLL library

Returns:

list of board info dictionaries for each connected board

classmethod find_instrument(name: str, instrument_class: type[T] | None = None) → T | Instrument

Find an existing instrument by name.

Parameters:

• name – Name of the instrument.

• instrument_class – The type of instrument you are looking for.

Returns:

The instrument found.

Raises:

• KeyError – If no instrument of that name was found, or if its reference is invalid (dead).

• TypeError – If a specific class was requested but a different type was found.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

classmethod get_board_info(api: AlazarATSAPI, system_id: int, board_id: int) → dict[str, str | int]

Get the information from a connected Alazar board

Parameters:

• api – An AlazarATSAPI that wraps around the CTypes CDLL

• system_id – id of the Alazar system

• board_id – id of the board within the alazar system

Returns:

Dictionary containing

• system_id

• board_id

• board_kind (as string)

• max_samples

• bits_per_sample

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

get_idn() → dict[str, str | int | None]

This methods gets the most relevant information of this instrument

The firmware version reported should match the version number of downloadable fw files from AlazarTech. But note that the firmware version has often been found to be incorrect for several firmware versions. At the time of writing it is known to be correct for the 9360 (v 21.07) and 9373 (v 30.04) but incorrect for several earlier versions. In Alazar DSO this is reported as FPGA Version.

Returns:

Dictionary containing

• ’firmware’: as string

• ’model’: as string

• ’serial’: board serial number

• ’vendor’: ‘AlazarTech’

• ’CPLD_version’: version of the CPLD

• ’driver_version’: version of the driver dll

• ’SDK_version’: version of the SDK

• ’latest_cal_date’: date of the latest calibration (as string)

• ’memory_size’: size of the memory in samples

• ’asopc_type’: type of asopc (as decimal number)

• ’pcie_link_speed’: the speed of a single pcie link (in GB/s)

• ’pcie_link_width’: number of pcie links

• ’bits_per_sample’: number of bits per one sample

• ’max_samples’: board memory size in samples

static get_num_channels(byte_rep: int) → int

Return the number of channels for a specific channel mask

Each single channel is represented by a bitarray with one non zero entry i.e. powers of two. All multichannel masks can be constructed by summing the single channel ones. However, not all configurations are supported. See table 4 Input Channel Configurations on page 241 of the Alazar SDK manual. This contains the complete mapping for all current Alazar cards. It’s left to the driver to ensure that only the ones supported for a specific card can be selected

get_sample_rate(include_decimation: bool = True) → float

Obtain the effective sampling rate of the acquisition based on clock speed and decimation

Returns:

the number of samples (per channel) per second

classmethod instances() → list[T]

Get all currently defined instances of this instrument class.

You can use this to get the objects back if you lose track of them, and it’s also used by the test system to find objects to test against.

Returns:

A list of instances.

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

static is_valid(instr_instance: Instrument) → bool

Check if a given instance of an instrument is valid: if an instrument has been closed, its instance is not longer a “valid” instrument.

Parameters:

instr_instance – Instance of an Instrument class or its subclass.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs: ClassVar[list[str]] = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: InstrumentBase | None

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

classmethod record_instance(instance: Instrument) → None

Record (a weak ref to) an instance in a class’s instance list.

Also records the instance in list of all instruments, and verifies that there are no other instruments with the same name.

This method is called after initialization of the instrument is completed.

Parameters:

instance – Instance to record.

Raises:

KeyError – If another instance with the same name is already present.

classmethod remove_instance(instance: Instrument) → None

Remove a particular instance from the record.

Parameters:

instance – The instance to remove

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

signal_to_volt(channel: int, signal: float) → float

convert a value from a buffer to an actual value in volts based on the ranges of the channel

Parameters:

• channel – number of the channel where the signal value came from

• signal – the value that needs to be converted

Returns:

the corresponding value in volts

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• update – If True, update the state by querying the instrument. If None update the state if known to be invalid. If False, just use the latest values in memory and never update state.

• params_to_skip_update – List of parameter names that will be skipped in update even if update is True. This is useful if you have parameters that are slow to update but can be updated in a different way (as in the qdac). If you want to skip the update of certain parameters in all snapshots, use the snapshot_get attribute of those parameters instead.

Returns:

base snapshot

Return type:

dict

sync_settings_to_card() → None

Syncs all parameters to Alazar card

syncing() → Iterator[None]

Context manager for syncing settings to Alazar card. It will automatically call sync_settings_to_card at the end of the context.

Example

This is intended to be used around multiple parameter sets to ensure syncing is done exactly once:

with alazar.syncing():
     alazar.trigger_source1('EXTERNAL')
     alazar.trigger_level1(100)

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

Write a command string with NO response to the hardware.

Subclasses that transform cmd should override this method, and in it call super().write(new_cmd). Subclasses that define a new hardware communication should instead override write_raw.

Parameters:

cmd – The string to send to the instrument.

Raises:

Exception – Wraps any underlying exception with extra context, including the command and the instrument.

write_raw(cmd: str) → None

Low level method to write a command string to the hardware.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override write.

Parameters:

cmd – The string to send to the instrument.

api: AlazarATSAPI = api or AlazarATSAPI(dll_path or self.dll_path)

buffer_list: list[Buffer] = []

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}

class qcodes.instrument_drivers.AlazarTech.DemodulationAcquisitionController(name: str, alazar_name: str, demodulation_frequency: float, **kwargs: Any)

Bases: AcquisitionController[float]

This class represents an example acquisition controller. End users will probably want to use something more sophisticated. It will average all buffers and then perform a fourier transform on the resulting average trace for one frequency component. The amplitude of the result of channel_a will be returned.

Parameters:

• name – name for this acquisition_conroller as an instrument

• alazar_name – the name of the alazar instrument such that this controller can communicate with the Alazar

• demodulation_frequency – the selected component for the fourier transform

• **kwargs – kwargs are forwarded to the Instrument base class

• name – The name of the AcquisitionController

• alazar_name – The name of the alazar instrument.

• **kwargs – kwargs are forwarded to base class.

Methods:

update_acquisitionkwargs(**kwargs)	This method must be used to update the kwargs used for the acquisition with the alazar_driver.acquire :param kwargs: :return:
do_acquisition()	this method performs an acquisition, which is the get_cmd for the acquisiion parameter of this instrument :return:
pre_start_capture()	See AcquisitionController
pre_acquire()	See AcquisitionController :return:
handle_buffer(buffer[, buffer_number])	See AcquisitionController :return:
post_acquire()	See AcquisitionController :return:
fit(buf)	the DFT is implemented in this method :param buf: buffer to perform the transform on :return: return amplitude and phase of the resulted transform
__class_getitem__(params)	Parameterizes a generic class.
__del__()	Close the instrument and remove its instance record.
__getitem__(key)	Delegate instrument['name'] to parameter or function 'name'.
__getstate__()	Prevent pickling instruments, and give a nice error message.
__repr__()	Simplified repr giving just the class and name.
add_function(name, **kwargs)	Bind one Function to this instrument.
add_parameter(name[, parameter_class])	Bind one Parameter to this instrument.
add_submodule(name, submodule)	Bind one submodule to this instrument.
ask(cmd)	Write a command string to the hardware and return a response.
ask_raw(cmd)	Low level method to write to the hardware and return a response.
buffer_done_callback(buffers_completed)	This method is called when a buffer is completed.
call(func_name, *args)	Shortcut for calling a function from its name.
close()	Irreversibly stop this instrument and free its resources.
close_all()	Try to close all instruments registered in _all_instruments This is handy for use with atexit to ensure that all instruments are closed when a python session is closed.
connect_message([idn_param, begin_time])	Print a standard message on initial connection to an instrument.
exist(name[, instrument_class])	Check if an instrument with a given names exists (i.e. is already instantiated).
find_instrument(name[, instrument_class])	Find an existing instrument by name.
get(param_name)	Shortcut for getting a parameter from its name.
get_component(full_name)	Recursively get a component of the instrument by full_name.
get_idn()	Parse a standard VISA *IDN? response into an ID dict.
instances()	Get all currently defined instances of this instrument class.
invalidate_cache()	Invalidate the cache of all parameters on the instrument.
is_valid(instr_instance)	Check if a given instance of an instrument is valid: if an instrument has been closed, its instance is not longer a "valid" instrument.
load_metadata(metadata)	Load metadata into this classes metadata dictionary.
print_readable_snapshot([update, max_chars])	Prints a readable version of the snapshot.
record_instance(instance)	Record (a weak ref to) an instance in a class's instance list.
remove_instance(instance)	Remove a particular instance from the record.
set(param_name, value)	Shortcut for setting a parameter from its name and new value.
snapshot([update])	Decorate a snapshot dictionary with metadata.
snapshot_base([update, params_to_skip_update])	State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).
validate_status([verbose])	Validate the values of all gettable parameters
write(cmd)	Write a command string with NO response to the hardware.
write_raw(cmd)	Low level method to write a command string to the hardware.

Attributes:

ancestors	Ancestors in the form of a list of InstrumentBase
delegate_attr_dicts	A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.
delegate_attr_objects	A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.
full_name	Full name of the instrument.
label	Nicely formatted label of the instrument.
name	Full name of the instrument
name_parts	A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.
omit_delegate_attrs	A list of attribute names (strings) to not delegate to any other dictionary or object.
parent	The parent instrument.
root_instrument	The topmost parent of this module.
short_name	Short name of the instrument.
parameters	All the parameters supported by this instrument.
functions	All the functions supported by this instrument.
submodules	All the submodules of this instrument such as channel lists or logical groupings of parameters.
instrument_modules	All the InstrumentModule of this instrument Usually populated via add_submodule().
log
metadata

acquisitionkwargs: dict[str, Any] = {}

cos_list: np.ndarray | None = None

sin_list: np.ndarray | None = None

buffer: np.ndarray | None = None

update_acquisitionkwargs(**kwargs: Any) → None

This method must be used to update the kwargs used for the acquisition with the alazar_driver.acquire :param kwargs: :return:

do_acquisition() → float

this method performs an acquisition, which is the get_cmd for the acquisiion parameter of this instrument :return:

pre_start_capture() → None

See AcquisitionController

pre_acquire() → None

See AcquisitionController :return:

handle_buffer(buffer: ndarray, buffer_number: int | None = None) → None

See AcquisitionController :return:

post_acquire() → float

See AcquisitionController :return:

fit(buf: ndarray) → tuple[float, float]

the DFT is implemented in this method :param buf: buffer to perform the transform on :return: return amplitude and phase of the resulted transform

classmethod __class_getitem__(params)

Parameterizes a generic class.

At least, parameterizing a generic class is the main thing this method does. For example, for some generic class Foo, this is called when we do Foo[int] - there, with cls=Foo and params=int.

However, note that this method is also called when defining generic classes in the first place with class Foo(Generic[T]): ….

__del__() → None

Close the instrument and remove its instance record.

__getitem__(key: str) → Callable[..., Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

__repr__() → str

Simplified repr giving just the class and name.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[ParameterBase] | None = None, **kwargs: Any) → None

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

add_submodule(name: str, submodule: InstrumentModule | ChannelTuple) → None

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

Write a command string to the hardware and return a response.

Subclasses that transform cmd should override this method, and in it call super().ask(new_cmd). Subclasses that define a new hardware communication should instead override ask_raw.

Parameters:

cmd – The string to send to the instrument.

Returns:

response

Raises:

Exception – Wraps any underlying exception with extra context, including the command and the instrument.

ask_raw(cmd: str) → str

Low level method to write to the hardware and return a response.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override ask.

Parameters:

cmd – The string to send to the instrument.

buffer_done_callback(buffers_completed: int) → None

This method is called when a buffer is completed. It can be used if you want to implement an event that happens for each buffer. You will probably want to combine this with AUX_IN_TRIGGER_ENABLE to wait before starting capture of the next buffer.

Parameters:

buffers_completed – how many buffers have been completed and copied to local memory at the time of this callback.

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

close() → None

Irreversibly stop this instrument and free its resources.

Subclasses should override this if they have other specific resources to close.

classmethod close_all() → None

Try to close all instruments registered in _all_instruments This is handy for use with atexit to ensure that all instruments are closed when a python session is closed.

Examples

>>> atexit.register(qc.Instrument.close_all())

connect_message(idn_param: str = 'IDN', begin_time: float | None = None) → None

Print a standard message on initial connection to an instrument.

Parameters:

• idn_param – Name of parameter that returns ID dict. Default IDN.

• begin_time – time.time() when init started. Default is self._t0, set at start of Instrument.__init__.

delegate_attr_dicts: ClassVar[list[str]] = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects: ClassVar[list[str]] = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

static exist(name: str, instrument_class: type[Instrument] | None = None) → bool

Check if an instrument with a given names exists (i.e. is already instantiated).

Parameters:

• name – Name of the instrument.

• instrument_class – The type of instrument you are looking for.

classmethod find_instrument(name: str, instrument_class: type[T] | None = None) → T | Instrument

Find an existing instrument by name.

Parameters:

• name – Name of the instrument.

• instrument_class – The type of instrument you are looking for.

Returns:

The instrument found.

Raises:

• KeyError – If no instrument of that name was found, or if its reference is invalid (dead).

• TypeError – If a specific class was requested but a different type was found.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

get_idn() → dict[str, str | None]

Parse a standard VISA *IDN? response into an ID dict.

Even though this is the VISA standard, it applies to various other types as well, such as IPInstruments, so it is included here in the Instrument base class.

Override this if your instrument does not support *IDN? or returns a nonstandard IDN string. This string is supposed to be a comma-separated list of vendor, model, serial, and firmware, but semicolon and colon are also common separators so we accept them here as well.

Returns:

A dict containing vendor, model, serial, and firmware.

classmethod instances() → list[T]

Get all currently defined instances of this instrument class.

You can use this to get the objects back if you lose track of them, and it’s also used by the test system to find objects to test against.

Returns:

A list of instances.

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

static is_valid(instr_instance: Instrument) → bool

Check if a given instance of an instrument is valid: if an instrument has been closed, its instance is not longer a “valid” instrument.

Parameters:

instr_instance – Instance of an Instrument class or its subclass.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs: ClassVar[list[str]] = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: InstrumentBase | None

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

classmethod record_instance(instance: Instrument) → None

Record (a weak ref to) an instance in a class’s instance list.

Also records the instance in list of all instruments, and verifies that there are no other instruments with the same name.

This method is called after initialization of the instrument is completed.

Parameters:

instance – Instance to record.

Raises:

KeyError – If another instance with the same name is already present.

classmethod remove_instance(instance: Instrument) → None

Remove a particular instance from the record.

Parameters:

instance – The instance to remove

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• update – If True, update the state by querying the instrument. If None update the state if known to be invalid. If False, just use the latest values in memory and never update state.

• params_to_skip_update – List of parameter names that will be skipped in update even if update is True. This is useful if you have parameters that are slow to update but can be updated in a different way (as in the qdac). If you want to skip the update of certain parameters in all snapshots, use the snapshot_get attribute of those parameters instead.

Returns:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

Write a command string with NO response to the hardware.

Subclasses that transform cmd should override this method, and in it call super().write(new_cmd). Subclasses that define a new hardware communication should instead override write_raw.

Parameters:

cmd – The string to send to the instrument.

Raises:

Exception – Wraps any underlying exception with extra context, including the command and the instrument.

write_raw(cmd: str) → None

Low level method to write a command string to the hardware.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override write.

Parameters:

cmd – The string to send to the instrument.

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}