Harvard Drivers
Classes:
|
The qcodes driver for the Decadac. |
|
A single DAC channel of the DECADAC |
|
A single DAC Slot of the DECADAC |
Exceptions:
- class qcodes.instrument_drivers.Harvard.HarvardDecadac(name: str, address: str, min_val: float | int = -5, max_val: float | int = 5, **kwargs)[source]
Bases:
VisaInstrument
,DacReader
The qcodes driver for the Decadac.
Tested with a Decadac firmware revion number 14081 (Decadac 139).
The message strategy is the following: always keep the queue empty, so that self.visa_handle.ask(XXX) will return the answer to XXX and not some previous event.
Creates an instance of the Decadac instruments
- Parameters:
name – What this instrument is called locally.
address – The address of the DAC. For a serial port this is ASRLn::INSTR where n is replaced with the address set in the VISA control panel. Baud rate and other serial parameters must also be set in the VISA control panel.
min_val – The minimum value in volts that can be output by the DAC. This value should correspond to the DAC code 0.
max_val – The maximum value in volts that can be output by the DAC. This value should correspond to the DAC code 65536.
Classes:
alias of
HarvardDecadacChannel
alias of
HarvardDecadacSlot
Methods:
set_all
(volt)Set all dac channels to a specific voltage.
ramp_all
(volt, ramp_rate)Ramp all dac channels to a specific voltage at the given rate simultaneously.
get_idn
()Attempt to identify the dac.
connect_message
([idn_param, begin_time])Print a connect message, taking into account the lack of a standard
*IDN
on the Harvard DAC__repr__
()Simplified repr giving just the class and name.
write
(cmd)Since all commands are echoed back, we must keep track of responses as well, otherwise commands receive the wrong response.
__del__
()Close the instrument and remove its instance record.
__getitem__
(key)Delegate instrument['name'] to parameter or function 'name'.
Prevent pickling instruments, and give a nice error message.
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 interface to
visa_handle.ask
.call
(func_name, *args)Shortcut for calling a function from its name.
close
()Disconnect and irreversibly tear down the instrument.
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.Clear the buffers of the device
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 all currently defined instances of this instrument class.
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.
set_address
(address)Set the address for this instrument.
set_terminator
(terminator)Change the read terminator to use.
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_raw
(cmd)Low-level interface to
visa_handle.write
.Attributes:
Ancestors in the form of a list of
InstrumentBase
A list of names (strings) of dictionaries which are (or will be) attributes of
self
, whose keys should be treated as attributes ofself
.A list of names (strings) of objects which are (or will be) attributes of
self
, whose attributes should be passed through toself
.Full name of the instrument.
Nicely formatted label of the instrument.
Full name of the instrument
A list of all the parts of the instrument name from
root_instrument()
to the currentInstrumentModule
.A list of attribute names (strings) to not delegate to any other dictionary or object.
The parent instrument.
The topmost parent of this module.
Short name of the instrument.
The VISA resource used by this instrument.
The VISA resource manager used by this instrument.
All the parameters supported by this instrument.
All the functions supported by this instrument.
All the submodules of this instrument such as channel lists or logical groupings of parameters.
All the
InstrumentModule
of this instrument Usually populated viaadd_submodule()
.- DAC_CHANNEL_CLASS
alias of
HarvardDecadacChannel
Methods:__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)Overload ask to set channel prior to operations
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)Overload write to set channel prior to any channel operations.
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 ofself
.delegate_attr_objects
A list of names (strings) of objects which are (or will be) attributes of
self
, whose attributes should be passed through toself
.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 currentInstrumentModule
.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 viaadd_submodule()
.
- DAC_SLOT_CLASS
alias of
HarvardDecadacSlot
Attributes:SLOT_MODE_DEFAULT
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 ofself
.delegate_attr_objects
A list of names (strings) of objects which are (or will be) attributes of
self
, whose attributes should be passed through toself
.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 currentInstrumentModule
.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 viaadd_submodule()
.Methods:
__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)Overload ask to set channel prior to operations
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)Overload write to set channel prior to any channel operations.
write_raw
(cmd)
- set_all(volt: float) None [source]
Set all dac channels to a specific voltage. If channels are set to ramp then the ramps will occur in sequence, not simultaneously.
- Parameters:
volt (float) – The voltage to set all gates to.
- ramp_all(volt, ramp_rate)[source]
Ramp all dac channels to a specific voltage at the given rate simultaneously. Note that the ramps are not synchronized due to communications time and DAC ramps starting as soon as the commands are in.
- get_idn()[source]
Attempt to identify the dac. Since we don’t have standard SCPI commands,
*IDN
will do nothing on this DAC.- Returns:
A dict containing a serial and hardware version
- connect_message(idn_param='IDN', begin_time=None)[source]
Print a connect message, taking into account the lack of a standard
*IDN
on the Harvard DAC
- write(cmd)[source]
Since all commands are echoed back, we must keep track of responses as well, otherwise commands receive the wrong response. Hence all writes must also read a response.
- __getitem__(key: str) Callable[[...], Any] | Parameter
Delegate instrument[‘name’] to parameter or function ‘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 aChannelTuple
.- 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:
- 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 callsuper().ask(new_cmd)
. Subclasses that define a new hardware communication should instead overrideask_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 interface to
visa_handle.ask
.- Parameters:
cmd – The command to send to the instrument.
- Returns:
The instrument’s response.
- Return type:
- 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.
- 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())
- 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 ofself
.
- 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 toself
.
- 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:
- 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:
name – The name of the component to get.
- Returns:
The component with the given name.
- Raises:
KeyError – If the component does not exist.
- 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.
- 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 currentInstrumentModule
.
- 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. IfFalse
, 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 isself
.
- 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.
- set_address(address: str) None
Set the address for this instrument.
- Parameters:
address – The visa resource name to use to connect. The address should be the actual address and just that. If you wish to change the backend for VISA, use the self.visalib attribute (and then call this function).
- set_terminator(terminator: str | None) None
Change the read terminator to use.
- Parameters:
terminator – Character(s) to look for at the end of a read and to end each write command with. eg.
\r\n
. If None the terminator will not be 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 = True, 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 only update if the state is known to be invalid. If False, just use the latest values in memory and never update.
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:
- 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_raw(cmd: str) None
Low-level interface to
visa_handle.write
.- Parameters:
cmd – The command to send to the instrument.
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handle
The VISA resource used by this 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)
- resource_manager = resource_manager
The VISA resource manager used by this instrument.
- class qcodes.instrument_drivers.Harvard.HarvardDecadacChannel(parent, name, channel, min_val=-5, max_val=5)[source]
Bases:
InstrumentChannel
,DacReader
A single DAC channel of the DECADAC
Methods:
write
(cmd)Overload write to set channel prior to any channel operations.
ask
(cmd)Overload ask to set channel prior to operations
__getitem__
(key)Delegate instrument['name'] to parameter or function 'name'.
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_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 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_raw
(cmd)Attributes:
Ancestors in the form of a list of
InstrumentBase
A list of names (strings) of dictionaries which are (or will be) attributes of
self
, whose keys should be treated as attributes ofself
.A list of names (strings) of objects which are (or will be) attributes of
self
, whose attributes should be passed through toself
.Full name of the instrument.
Nicely formatted label of the instrument.
Full name of the instrument
A list of all the parts of the instrument name from
root_instrument()
to the currentInstrumentModule
.A list of attribute names (strings) to not delegate to any other dictionary or object.
The parent instrument.
The topmost parent of this module.
Short name of the instrument.
All the parameters supported by this instrument.
All the functions supported by this instrument.
All the submodules of this instrument such as channel lists or logical groupings of parameters.
All the
InstrumentModule
of this instrument Usually populated viaadd_submodule()
.- write(cmd)[source]
Overload write to set channel prior to any channel operations. Since all commands are echoed back, we must keep track of responses as well, otherwise commands receive the wrong response.
- __getitem__(key: str) Callable[[...], Any] | Parameter
Delegate instrument[‘name’] to parameter or function ‘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 aChannelTuple
.- 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:
- 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.
- 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 ofself
.
- 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 toself
.
- 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:
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.
- 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 currentInstrumentModule
.
- 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. IfFalse
, 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 isself
.
- 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. IfFalse
, 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:
- 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.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)
- exception qcodes.instrument_drivers.Harvard.HarvardDecadacException[source]
Bases:
Exception
- args
- with_traceback()
Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
- class qcodes.instrument_drivers.Harvard.HarvardDecadacSlot(parent, name, slot, min_val=-5, max_val=5)[source]
Bases:
InstrumentChannel
,DacReader
A single DAC Slot of the DECADAC
Attributes:
Ancestors in the form of a list of
InstrumentBase
A list of names (strings) of dictionaries which are (or will be) attributes of
self
, whose keys should be treated as attributes ofself
.A list of names (strings) of objects which are (or will be) attributes of
self
, whose attributes should be passed through toself
.Full name of the instrument.
Nicely formatted label of the instrument.
Full name of the instrument
A list of all the parts of the instrument name from
root_instrument()
to the currentInstrumentModule
.A list of attribute names (strings) to not delegate to any other dictionary or object.
The parent instrument.
The topmost parent of this module.
Short name of the instrument.
All the parameters supported by this instrument.
All the functions supported by this instrument.
All the submodules of this instrument such as channel lists or logical groupings of parameters.
All the
InstrumentModule
of this instrument Usually populated viaadd_submodule()
.Methods:
write
(cmd)Overload write to set channel prior to any channel operations.
ask
(cmd)Overload ask to set channel prior to operations
__getitem__
(key)Delegate instrument['name'] to parameter or function 'name'.
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_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 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_raw
(cmd)- SLOT_MODE_DEFAULT = 'Coarse'
- write(cmd)[source]
Overload write to set channel prior to any channel operations. Since all commands are echoed back, we must keep track of responses as well, otherwise commands receive the wrong response.
- __getitem__(key: str) Callable[[...], Any] | Parameter
Delegate instrument[‘name’] to parameter or function ‘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 aChannelTuple
.- 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:
- 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.
- 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 ofself
.
- 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 toself
.
- 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:
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.
- 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 currentInstrumentModule
.
- 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. IfFalse
, 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 isself
.
- 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. IfFalse
, 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:
- 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.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)