Galil Drivers

Classes:

`GalilDMC4133Arm`(controller)	Module to control probe arm. It is assumed that the chip to be probed has one or more rows with each row having one or more pads. Design of the chip to be probed should resemble the following::.
`GalilDMC4133Controller`(name, address, **kwargs)	Driver for Galil DMC-4133 Controller
`GalilDMC4133Motor`(parent, name, **kwargs)	Class to control a single motor (independent of possible other motors)
`GalilDMC4133VectorMode`(parent, name, **kwargs)	Class to control motors in vector mode

class qcodes.instrument_drivers.Galil.GalilDMC4133Arm(controller: GalilDMC4133Controller)[source]

Bases: object

Module to control probe arm. It is assumed that the chip to be probed has one or more rows with each row having one or more pads. Design of the chip to be probed should resemble the following:

|--------------------------|
|--------------------------|
|--------------------------|
|--------------------------|
|--------------------------|

Needle head for the arm in assumed to have rows of needles which is a divisor of the number of rows in the chip and number of needles in each row of the needle head is a divisor for the number of pads in each row of the chip.

Initializes the arm class

Parameters:: controller – an instance of DMC4133Controller

Attributes:

`current_row`
`current_pad`
`left_bottom_position`
`left_top_position`
`right_top_position`
`arm_pick_up_distance`
`speed`
`acceleration`
`deceleration`

Methods:

`set_arm_kinematics`([speed, acceleration, ...])	sets the arm kinematics values for speed, acceleration and deceleration in micro meters/sec and micro meters/sec^2 respectively
`set_pick_up_distance`([distance])	sets pick up distance in micrometers for the arm
`set_left_bottom_position`()
`set_left_top_position`()
`set_right_top_position`()
`move_motor_a_by`(distance)	Moves motor A by distance given in micro meters
`move_motor_b_by`(distance)	Moves motor B by distance given in micro meters
`move_motor_c_by`(distance)	Moves motor B by distance given in micro meters
`move_towards_left_bottom_position`()
`move_to_next_row`()
`move_to_begin_row_pad_from_end_row_last_pad`()
`move_to_row`(num)
`move_to_pad`(num)
`set_motor_a_forward_limit`()
`set_motor_a_reverse_limit`()
`set_motor_b_forward_limit`()
`set_motor_b_reverse_limit`()
`set_motor_c_forward_limit`()
`set_motor_c_reverse_limit`()

property current_row: int | None

property current_pad: int | None

property left_bottom_position: tuple[int, int, int] | None

property left_top_position: tuple[int, int, int] | None

property right_top_position: tuple[int, int, int] | None

property arm_pick_up_distance: int

property speed: int

property acceleration: int

property deceleration: int

set_arm_kinematics(speed: int = 100, acceleration: int = 2048, deceleration: int = 2048) → None[source]: sets the arm kinematics values for speed, acceleration and deceleration in micro meters/sec and micro meters/sec^2 respectively

set_pick_up_distance(distance: float = 3000) → None[source]: sets pick up distance in micrometers for the arm

set_left_bottom_position() → None[source]

set_left_top_position() → None[source]

set_right_top_position() → None[source]

move_motor_a_by(distance: float) → None[source]: Moves motor A by distance given in micro meters

move_motor_b_by(distance: float) → None[source]: Moves motor B by distance given in micro meters

move_motor_c_by(distance: float) → None[source]: Moves motor B by distance given in micro meters

move_towards_left_bottom_position() → None[source]

move_to_next_row() → None[source]

move_to_begin_row_pad_from_end_row_last_pad() → None[source]

move_to_row(num: int) → None[source]

move_to_pad(num: int) → None[source]

set_motor_a_forward_limit() → None[source]

set_motor_a_reverse_limit() → None[source]

set_motor_b_forward_limit() → None[source]

set_motor_b_reverse_limit() → None[source]

set_motor_c_forward_limit() → None[source]

set_motor_c_reverse_limit() → None[source]

class qcodes.instrument_drivers.Galil.GalilDMC4133Controller(name: str, address: str, **kwargs: Any)[source]

Bases: GalilMotionController

Driver for Galil DMC-4133 Controller

Initializes the DMC4133Controller class

Parameters:

name – name for the instance
address – address of the controller burned in
**kwargs – kwargs are forwarded to base class.

Methods:

`end_program`()	ends the program
`define_position_as_origin`()	defines current motors position as origin
`tell_error`()	reads error
`stop`()	stop the motion of all motors
`abort`()	aborts motion and the program operation
`motors_off`()	turn all motors off
`begin_motors`()	begin motion of all motors simultaneously
`wait_till_motion_complete`()	this method waits for the motion on all motors to complete
`__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)	Asks/Reads data from Galil motion controller
`call`(func_name, *args)	Shortcut for calling a function from its name.
`close`()	Close connection to the instrument
`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`()	Get Galil motion controller hardware information
`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.
`motion_complete`(axes)	Wait for motion to complete for given axes, e.g. `"A"` for axis A, `"ABC"` for axes A, B, and C.
`open`()	Open connection to Galil motion controller.
`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).
`timeout`(val)	Sets timeout for the instrument
`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)	Write for Galil motion controller

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()`.

end_program() → None[source]: ends the program

define_position_as_origin() → None[source]: defines current motors position as origin

tell_error() → str[source]: reads error

stop() → None[source]: stop the motion of all motors

abort() → None[source]: aborts motion and the program operation

motors_off() → None[source]: turn all motors off

begin_motors() → None[source]: begin motion of all motors simultaneously

wait_till_motion_complete() → None[source]: this method waits for the motion on all motors to complete

__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: Asks/Reads data from Galil motion controller

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: Close connection to the instrument

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]: Get Galil motion controller hardware information

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.

motion_complete(axes: str) → None: Wait for motion to complete for given axes, e.g. "A" for axis A, "ABC" for axes A, B, and C

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.

open() → None: Open connection to Galil motion controller. This method assumes that the initial mapping of Galil motion controller’s hardware’s to an IP address is done using GDK and the IP address is burned in. This applies that Motion controller no more requests for an IP address and a connection to the Motion controller can be done by the IP address burned in.

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

timeout(val: int) → None

Sets timeout for the instrument

Parameters:: val – time in milliseconds. -1 disables the timeout

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: Write for Galil motion controller

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.Galil.GalilDMC4133Motor(parent: GalilDMC4133Controller, name: str, **kwargs: Any)[source]

Bases: InstrumentChannel

Class to control a single motor (independent of possible other motors)

Initializes individual motor submodules

Parameters:

parent – an instance of DMC4133Controller
name – name of the motor to be controlled
**kwargs – kwargs are forwarded to base class.

Methods:

`off`()	turns motor off
`on_off_status`()	tells motor on off status
`servo_here`()	servo at the motor
`begin`()	begins motion of the motor (returns immediately)
`is_in_motion`()	checks if the motor is in motion or not.
`wait_till_motor_motion_complete`()	wait for motion on the motor to complete
`error_magnitude`()	gives the magnitude of error, in quadrature counts, for this motor a count is directly proportional to the micro-stepping resolution of the stepper drive.
`__getitem__`(key)	Delegate instrument['name'] to parameter or function 'name'.
`__getstate__`()	Prevent pickling instruments, and give a nice error message.
`__repr__`()	Custom repr to give parent information
`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)
`ask_raw`(cmd)
`call`(func_name, *args)	Shortcut for calling a function from its 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.
`invalidate_cache`()	Invalidate the cache of all parameters on the instrument.
`load_metadata`(metadata)	Load metadata into this classes metadata dictionary.
`print_readable_snapshot`([update, max_chars])	Prints a readable version of the snapshot.
`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_raw`(cmd)

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()`.

off() → None[source]: turns motor off

on_off_status() → str[source]: tells motor on off status

servo_here() → None[source]: servo at the motor

begin() → None[source]: begins motion of the motor (returns immediately)

is_in_motion() → int[source]: checks if the motor is in motion or not. return 1, if motor is in motion otherwise 0

wait_till_motor_motion_complete() → None[source]: wait for motion on the motor to complete

error_magnitude() → float[source]: gives the magnitude of error, in quadrature counts, for this motor a count is directly proportional to the micro-stepping resolution of the stepper drive.

__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: Custom repr to give parent information

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

ask_raw(cmd: str) → str

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.

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.

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.

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.

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: 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.

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_raw(cmd: str) → None

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.Galil.GalilDMC4133VectorMode(parent: GalilDMC4133Controller, name: str, **kwargs: Any)[source]

Bases: InstrumentChannel

Class to control motors in vector mode

Initializes the vector mode submodule for the controller

Parameters:

parent – an instance of DMC4133Controller
name – name of the vector mode plane
**kwargs – kwargs are forwarded to base class.

Methods:

`activate`()	activate plane of motion
`vector_position`(first_coord, second_coord)	sets the final vector position for the motion considering current position as the origin
`vector_seq_end`()	indicates to the controller that the end of the vector is coming up.
`begin_seq`()	begins motion of the motor
`after_seq_motion`()	wait till motion ends
`clear_sequence`(coord_sys)	clears vectors specified in the given coordinate system
`__getitem__`(key)	Delegate instrument['name'] to parameter or function 'name'.
`__getstate__`()	Prevent pickling instruments, and give a nice error message.
`__repr__`()	Custom repr to give parent information
`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)
`ask_raw`(cmd)
`call`(func_name, *args)	Shortcut for calling a function from its 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.
`invalidate_cache`()	Invalidate the cache of all parameters on the instrument.
`load_metadata`(metadata)	Load metadata into this classes metadata dictionary.
`print_readable_snapshot`([update, max_chars])	Prints a readable version of the snapshot.
`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_raw`(cmd)

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()`.

activate() → None[source]: activate plane of motion

vector_position(first_coord: int, second_coord: int) → None[source]: sets the final vector position for the motion considering current position as the origin

vector_seq_end() → None[source]: indicates to the controller that the end of the vector is coming up. is required to exit the vector mode gracefully

begin_seq() → None[source]: begins motion of the motor

after_seq_motion() → None[source]: wait till motion ends

clear_sequence(coord_sys: str) → None[source]: clears vectors specified in the given coordinate system

__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: Custom repr to give parent information

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

ask_raw(cmd: str) → str

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.

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.

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.

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.

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: 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.

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_raw(cmd: str) → None

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] = {}