qcodes.instrument_drivers.stanford_research package

Submodules

qcodes.instrument_drivers.stanford_research.SG384 module

class qcodes.instrument_drivers.stanford_research.SG384.SRS_SG384(*args: Any, **kwargs: Any)

Bases: qcodes.instrument.visa.VisaInstrument

This is the code for SG384 RF Signal Generator Status: beta version Includes the essential commands from the manual

__del__() → None

Close the instrument and remove its instance record.

__getitem__(key: str) → Union[Callable[[...], Any], qcodes.instrument.parameter.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. If your case is more complicated, you’re probably better off simply making a new method in your Instrument subclass definition.

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 = <class 'qcodes.instrument.parameter.Parameter'>, **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 instrument.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 parameter.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: Union[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: List[qcodes.instrument.base.InstrumentBase]

Returns a list of instruments, starting from the current instrument and following to the parent instrument and the parents parent instrument until the root instrument is reached.

ask(cmd: str) → str

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

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

Parameters

cmd – The string to send to the instrument.

Returns

response

Raises

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

ask_raw(cmd: str) → str

Low-level interface to visa_handle.ask.

Parameters

cmd – The command to send to the instrument.

Returns

The instrument’s response.

Return type

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.

check_error(ret_code: int) → None

Default error checking, raises an error if return code !=0. Does not differentiate between warnings or specific error messages. Override this function in your driver if you want to add specific error messages.

Parameters

ret_code – A Visa error code. See eg: https://github.com/hgrecco/pyvisa/blob/master/pyvisa/errors.py

Raises

visa.VisaIOError – if ret_code indicates a communication problem.

close() → None

Disconnect and irreversibly tear down 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: Optional[float] = 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: 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: 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.

device_clear() → None

Clear the buffers of the device

static exist(name: str, instrument_class: Optional[type] = 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: Optional[Type[qcodes.instrument.base.T]] = None) → qcodes.instrument.base.T

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

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_idn() → Dict[str, Optional[str]]

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

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

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

Returns

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

classmethod instances() → List[qcodes.instrument.base.Instrument]

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: qcodes.instrument.base.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

Name of the instrument This is equivalent to full_name for backwards compatibility.

property name_parts: List[str]

omit_delegate_attrs: List[str] = []

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

property parent: Optional[qcodes.instrument.base.InstrumentBase]

Returns 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: qcodes.instrument.base.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: qcodes.instrument.base.Instrument) → None

Remove a particular instance from the record.

Parameters

instance – The instance to remove

property root_instrument: qcodes.instrument.base.InstrumentBase

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

Change the read terminator to use.

Parameters

terminator – Character(s) to look for at the end of a read. eg. \r\n.

shared_kwargs = ()

property short_name: str

Short name of the instrument

snapshot(update: Optional[bool] = False) → Dict[Any, 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: Optional[bool] = True, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.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

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

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

Parameters

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

write(cmd: str) → None

Write a command string with NO response to the hardware.

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

Parameters

cmd – The string to send to the instrument.

Raises

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

write_raw(cmd: str) → None

Low-level interface to visa_handle.write.

Parameters

cmd – The command to send to the instrument.

parameters: Dict[str, _BaseParameter] = {}

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, Union['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 instrument_modules of this instrument Usually populated via add_submodule().

qcodes.instrument_drivers.stanford_research.SR560 module

class qcodes.instrument_drivers.stanford_research.SR560.SR560(*args: Any, **kwargs: Any)

Bases: qcodes.instrument.base.Instrument

This is the qcodes driver for the SR 560 Voltage-preamplifier.

This is a virtual driver only and will not talk to your instrument.

Note:

• The cutoff_lo and cutoff_hi parameters will interact with each other on the instrument (hi cannot be <= lo) but this is not managed here, you must ensure yourself that both are correct whenever you change one of them.

• gain has a vernier setting, which does not yield a well-defined output. We restrict this driver to only the predefined gain values.

get_idn() → Dict[str, Optional[str]]

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

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

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

Returns

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

__del__() → None

Close the instrument and remove its instance record.

__getitem__(key: str) → Union[Callable[[...], Any], qcodes.instrument.parameter.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. If your case is more complicated, you’re probably better off simply making a new method in your Instrument subclass definition.

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 = <class 'qcodes.instrument.parameter.Parameter'>, **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 instrument.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 parameter.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: Union[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: List[qcodes.instrument.base.InstrumentBase]

Returns a list of instruments, starting from the current instrument and following to the parent instrument and the parents parent instrument until the root instrument is reached.

ask(cmd: str) → str

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

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

Parameters

cmd – The string to send to the instrument.

Returns

response

Raises

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

ask_raw(cmd: str) → str

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

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

Parameters

cmd – The string to send to the instrument.

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

Shortcut for calling a function from its name.

Parameters

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

• *args – any arguments to the function.

Returns

The return value of the function.

close() → None

Irreversibly stop this instrument and free its resources.

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

classmethod close_all() → None

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

Examples

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

connect_message(idn_param: str = 'IDN', begin_time: Optional[float] = 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: 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: 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: Optional[type] = 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: Optional[Type[qcodes.instrument.base.T]] = None) → qcodes.instrument.base.T

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

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters

param_name – The name of a parameter of this instrument.

Returns

The current value of the parameter.

classmethod instances() → List[qcodes.instrument.base.Instrument]

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: qcodes.instrument.base.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

Name of the instrument This is equivalent to full_name for backwards compatibility.

property name_parts: List[str]

omit_delegate_attrs: List[str] = []

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

property parent: Optional[qcodes.instrument.base.InstrumentBase]

Returns 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: qcodes.instrument.base.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: qcodes.instrument.base.Instrument) → None

Remove a particular instance from the record.

Parameters

instance – The instance to remove

property root_instrument: qcodes.instrument.base.InstrumentBase

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.

shared_kwargs = ()

property short_name: str

Short name of the instrument

snapshot(update: Optional[bool] = False) → Dict[Any, 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: Optional[bool] = False, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

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

Parameters

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

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

Returns

base snapshot

Return type

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

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

Parameters

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

write(cmd: str) → None

Write a command string with NO response to the hardware.

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

Parameters

cmd – The string to send to the instrument.

Raises

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

write_raw(cmd: str) → None

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

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

Parameters

cmd – The string to send to the instrument.

parameters: Dict[str, _BaseParameter] = {}

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, Union['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 instrument_modules of this instrument Usually populated via add_submodule().

class qcodes.instrument_drivers.stanford_research.SR560.VoltageParameter(measured_param: qcodes.instrument.parameter.Parameter, v_amp_ins: qcodes.instrument_drivers.stanford_research.SR560.SR560, name: str = 'volt', snapshot_value: bool = True)

Bases: qcodes.instrument.parameter.MultiParameter

Amplified voltage measurement via an SR560 preamp and a measured voltage.

To be used when you feed a voltage into an SR560, send the SR560’s output voltage to a lockin or other voltage amplifier, and you have the voltage reading from that amplifier as a qcodes parameter.

VoltageParameter.get() returns (voltage_raw, voltage)

Parameters

• measured_param – a gettable parameter returning the voltage read from the SR560 output.

• v_amp_ins –

  an SR560 instance where you manually maintain the present settings of the real SR560 amp.

  Note: it should be possible to use other voltage preamps, if they define parameters gain (V_out / V_in) and invert (bool, output is inverted)

• name – the name of the current output. Default ‘volt’. Also used as the name of the whole parameter.

get_raw() → Tuple[Any, Any]

get_raw is called to perform the actual data acquisition from the instrument. This method should either be overwritten to perform the desired operation or alternatively for Parameter a suitable method is automatically generated if get_cmd is supplied to the parameter constructor. The method is automatically wrapped to provide a get method on the parameter instance.

__str__() → str

Include the instrument name with the Parameter name if possible.

property abstract: Optional[bool]

property full_name: str

Name of the parameter including the name of the instrument and submodule that the parameter may be bound to. The names are separated by underscores, like this: instrument_submodule_parameter.

property full_names: Tuple[str, ...]

Names of the parameter components including the name of the instrument and submodule that the parameter may be bound to. The name parts are separated by underscores, like this: instrument_submodule_parameter

get_ramp_values(value: Union[float, Sized], step: Optional[float] = None) → Sequence[Union[float, Sized]]

Return values to sweep from current value to target value. This method can be overridden to have a custom sweep behaviour. It can even be overridden by a generator.

Parameters

• value – target value

• step – maximum step size

Returns

List of stepped values, including target value.

property gettable: bool

Is it allowed to call get on this parameter?

property instrument: Optional[InstrumentBase]

Return the first instrument that this parameter is bound to. E.g if this is bound to a channel it will return the channel and not the instrument that the channel is bound too. Use root_instrument() to get the real instrument.

property inter_delay: float

Delay time between consecutive set operations. The actual time will not be shorter than this, but may be longer if the underlying set call takes longer.

Typically used in conjunction with step to create an effective ramp rate, but can also be used without a step to enforce a delay between sets.

Getter

Returns the current inter_delay.

Setter

Sets the value of the inter_delay.

Raises

• TypeError – If delay is not int nor float

• ValueError – If delay is negative

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

Load metadata into this classes metadata dictionary.

Parameters

metadata – Metadata to load.

property name: str

Name of the parameter. This is identical to short_name().

property name_parts: List[str]

List of the parts that make up the full name of this parameter

property post_delay: float

Delay time after start of set operation, for each set. The actual time will not be shorter than this, but may be longer if the underlying set call takes longer.

Typically used in conjunction with step to create an effective ramp rate, but can also be used without a step to enforce a delay after every set. One might think of post_delay as how long a set operation is supposed to take. For example, there might be an instrument that needs extra time after setting a parameter although the command for setting the parameter returns quickly.

Getter

Returns the current post_delay.

Setter

Sets the value of the post_delay.

Raises

• TypeError – If delay is not int nor float

• ValueError – If delay is negative

property raw_value: Any

Note that this property will be deprecated soon. Use cache.raw_value instead.

Represents the cached raw value of the parameter.

Getter

Returns the cached raw value of the parameter.

restore_at_exit(allow_changes: bool = True) → qcodes.instrument.parameter._SetParamContext

Use a context manager to restore the value of a parameter after a with block.

By default, the parameter value may be changed inside the block, but this can be prevented with allow_changes=False. This can be useful, for example, for debugging a complex measurement that unintentionally modifies a parameter.

Example

>>> p = Parameter("p", set_cmd=None, get_cmd=None)
>>> p.set(2)
>>> with p.restore_at_exit():
...     p.set(3)
...     print(f"value inside with block: {p.get()}")  # prints 3
>>> print(f"value after with block: {p.get()}")  # prints 2
>>> with p.restore_at_exit(allow_changes=False):
...     p.set(5)  # raises an exception

property root_instrument: Optional[InstrumentBase]

Return the fundamental instrument that this parameter belongs too. E.g if the parameter is bound to a channel this will return the fundamental instrument that that channel belongs to. Use instrument() to get the channel.

set_raw(value: Any) → None

set_raw is called to perform the actual setting of a parameter on the instrument. This method should either be overwritten to perform the desired operation or alternatively for Parameter a suitable method is automatically generated if set_cmd is supplied to the parameter constructor. The method is automatically wrapped to provide a set method on the parameter instance.

set_to(value: Any, allow_changes: bool = False) → qcodes.instrument.parameter._SetParamContext

Use a context manager to temporarily set a parameter to a value. By default, the parameter value cannot be changed inside the context. This may be overridden with allow_changes=True.

Examples

>>> from qcodes import Parameter
>>> p = Parameter("p", set_cmd=None, get_cmd=None)
>>> p.set(2)
>>> with p.set_to(3):
...     print(f"p value in with block {p.get()}")  # prints 3
...     p.set(5)  # raises an exception
>>> print(f"p value outside with block {p.get()}")  # prints 2
>>> with p.set_to(3, allow_changes=True):
...     p.set(5)  # now this works
>>> print(f"value after second block: {p.get()}")  # still prints 2

property setpoint_full_names: Optional[Sequence[Sequence[str]]]

Full names of setpoints including instrument names, if available

property settable: bool

Is it allowed to call set on this parameter?

property short_name: str

Short name of the parameter. This is without the name of the instrument or submodule that the parameter may be bound to. For full name refer to full_name().

property short_names: Tuple[str, ...]

short_names is identical to names i.e. the names of the parameter parts but does not add the instrument name.

It exists for consistency with instruments and other parameters.

snapshot(update: Optional[bool] = False) → Dict[Any, 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: Optional[bool] = True, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

State of the parameter as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.NumpyJSONEncoder supports).

If the parameter has been initiated with snapshot_value=False, the snapshot will NOT include the value and raw_value of the parameter.

Parameters

• update – If True, update the state by calling parameter.get() unless snapshot_get of the parameter is False. If update is None, use the current value from the cache unless the cache is invalid. If False, never call parameter.get().

• params_to_skip_update – No effect but may be passed from superclass

Returns

base snapshot

property snapshot_value: bool

If True the value of the parameter will be included in the snapshot.

property step: Optional[float]

Stepsize that this Parameter uses during set operation. Stepsize must be a positive number or None. If step is a positive number, this is the maximum value change allowed in one hardware call, so a single set can result in many calls to the hardware if the starting value is far from the target. All but the final change will attempt to change by +/- step exactly. If step is None stepping will not be used.

Getter

Returns the current stepsize.

Setter

Sets the value of the step.

Raises

• TypeError – if step is set to not numeric or None

• ValueError – if step is set to negative

• TypeError – if step is set to not integer or None for an integer parameter

• TypeError – if step is set to not a number on None

property underlying_instrument: Optional[InstrumentBase]

Returns an instance of the underlying hardware instrument that this parameter communicates with, per this parameter’s implementation.

This is useful in the case where a parameter does not belongs to an instrument instance that represents a real hardware instrument but actually uses a real hardware instrument in its implementation (e.g. via calls to one or more parameters of that real hardware instrument). This is also useful when a parameter does belong to an instrument instance but that instance does not represent the real hardware instrument that the parameter interacts with: hence root_instrument of the parameter cannot be the hardware_instrument, however underlying_instrument can be implemented to return the hardware_instrument.

By default it returns the root_instrument of the parameter.

validate(value: Any) → None

Validate the value supplied.

Parameters

value – value to validate

Raises

• TypeError – If the value is of the wrong type.

• ValueError – If the value is outside the bounds specified by the validator.

qcodes.instrument_drivers.stanford_research.SR830 module

class qcodes.instrument_drivers.stanford_research.SR830.ChannelBuffer(name: str, instrument: qcodes.instrument_drivers.stanford_research.SR830.SR830, channel: int)

Bases: qcodes.instrument.parameter.ArrayParameter

Parameter class for the two channel buffers

Currently always returns the entire buffer TODO (WilliamHPNielsen): Make it possible to query parts of the buffer. The instrument natively supports this in its TRCL call.

Parameters

• name – The name of the parameter

• instrument – The parent instrument

• channel – The relevant channel (1 or 2). The name should should match this.

prepare_buffer_readout() → None

Function to generate the setpoints for the channel buffer and get the right units

get_raw() → Any

Get command. Returns numpy array

__str__() → str

Include the instrument name with the Parameter name if possible.

property abstract: Optional[bool]

property full_name: str

Name of the parameter including the name of the instrument and submodule that the parameter may be bound to. The names are separated by underscores, like this: instrument_submodule_parameter.

get_ramp_values(value: Union[float, Sized], step: Optional[float] = None) → Sequence[Union[float, Sized]]

Return values to sweep from current value to target value. This method can be overridden to have a custom sweep behaviour. It can even be overridden by a generator.

Parameters

• value – target value

• step – maximum step size

Returns

List of stepped values, including target value.

property gettable: bool

Is it allowed to call get on this parameter?

property instrument: Optional[InstrumentBase]

Return the first instrument that this parameter is bound to. E.g if this is bound to a channel it will return the channel and not the instrument that the channel is bound too. Use root_instrument() to get the real instrument.

property inter_delay: float

Delay time between consecutive set operations. The actual time will not be shorter than this, but may be longer if the underlying set call takes longer.

Typically used in conjunction with step to create an effective ramp rate, but can also be used without a step to enforce a delay between sets.

Getter

Returns the current inter_delay.

Setter

Sets the value of the inter_delay.

Raises

• TypeError – If delay is not int nor float

• ValueError – If delay is negative

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

Load metadata into this classes metadata dictionary.

Parameters

metadata – Metadata to load.

property name: str

Name of the parameter. This is identical to short_name().

property name_parts: List[str]

List of the parts that make up the full name of this parameter

property post_delay: float

Delay time after start of set operation, for each set. The actual time will not be shorter than this, but may be longer if the underlying set call takes longer.

Typically used in conjunction with step to create an effective ramp rate, but can also be used without a step to enforce a delay after every set. One might think of post_delay as how long a set operation is supposed to take. For example, there might be an instrument that needs extra time after setting a parameter although the command for setting the parameter returns quickly.

Getter

Returns the current post_delay.

Setter

Sets the value of the post_delay.

Raises

• TypeError – If delay is not int nor float

• ValueError – If delay is negative

property raw_value: Any

Note that this property will be deprecated soon. Use cache.raw_value instead.

Represents the cached raw value of the parameter.

Getter

Returns the cached raw value of the parameter.

restore_at_exit(allow_changes: bool = True) → qcodes.instrument.parameter._SetParamContext

Use a context manager to restore the value of a parameter after a with block.

By default, the parameter value may be changed inside the block, but this can be prevented with allow_changes=False. This can be useful, for example, for debugging a complex measurement that unintentionally modifies a parameter.

Example

>>> p = Parameter("p", set_cmd=None, get_cmd=None)
>>> p.set(2)
>>> with p.restore_at_exit():
...     p.set(3)
...     print(f"value inside with block: {p.get()}")  # prints 3
>>> print(f"value after with block: {p.get()}")  # prints 2
>>> with p.restore_at_exit(allow_changes=False):
...     p.set(5)  # raises an exception

property root_instrument: Optional[InstrumentBase]

Return the fundamental instrument that this parameter belongs too. E.g if the parameter is bound to a channel this will return the fundamental instrument that that channel belongs to. Use instrument() to get the channel.

set_raw(value: Any) → None

set_raw is called to perform the actual setting of a parameter on the instrument. This method should either be overwritten to perform the desired operation or alternatively for Parameter a suitable method is automatically generated if set_cmd is supplied to the parameter constructor. The method is automatically wrapped to provide a set method on the parameter instance.

set_to(value: Any, allow_changes: bool = False) → qcodes.instrument.parameter._SetParamContext

Use a context manager to temporarily set a parameter to a value. By default, the parameter value cannot be changed inside the context. This may be overridden with allow_changes=True.

Examples

>>> from qcodes import Parameter
>>> p = Parameter("p", set_cmd=None, get_cmd=None)
>>> p.set(2)
>>> with p.set_to(3):
...     print(f"p value in with block {p.get()}")  # prints 3
...     p.set(5)  # raises an exception
>>> print(f"p value outside with block {p.get()}")  # prints 2
>>> with p.set_to(3, allow_changes=True):
...     p.set(5)  # now this works
>>> print(f"value after second block: {p.get()}")  # still prints 2

property setpoint_full_names: Optional[Sequence[str]]

Full names of setpoints including instrument names if available

property settable: bool

Is it allowed to call set on this parameter?

property short_name: str

Short name of the parameter. This is without the name of the instrument or submodule that the parameter may be bound to. For full name refer to full_name().

snapshot(update: Optional[bool] = False) → Dict[Any, 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: Optional[bool] = True, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

State of the parameter as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.NumpyJSONEncoder supports).

If the parameter has been initiated with snapshot_value=False, the snapshot will NOT include the value and raw_value of the parameter.

Parameters

• update – If True, update the state by calling parameter.get() unless snapshot_get of the parameter is False. If update is None, use the current value from the cache unless the cache is invalid. If False, never call parameter.get().

• params_to_skip_update – No effect but may be passed from superclass

Returns

base snapshot

property snapshot_value: bool

If True the value of the parameter will be included in the snapshot.

property step: Optional[float]

Stepsize that this Parameter uses during set operation. Stepsize must be a positive number or None. If step is a positive number, this is the maximum value change allowed in one hardware call, so a single set can result in many calls to the hardware if the starting value is far from the target. All but the final change will attempt to change by +/- step exactly. If step is None stepping will not be used.

Getter

Returns the current stepsize.

Setter

Sets the value of the step.

Raises

• TypeError – if step is set to not numeric or None

• ValueError – if step is set to negative

• TypeError – if step is set to not integer or None for an integer parameter

• TypeError – if step is set to not a number on None

property underlying_instrument: Optional[InstrumentBase]

Returns an instance of the underlying hardware instrument that this parameter communicates with, per this parameter’s implementation.

This is useful in the case where a parameter does not belongs to an instrument instance that represents a real hardware instrument but actually uses a real hardware instrument in its implementation (e.g. via calls to one or more parameters of that real hardware instrument). This is also useful when a parameter does belong to an instrument instance but that instance does not represent the real hardware instrument that the parameter interacts with: hence root_instrument of the parameter cannot be the hardware_instrument, however underlying_instrument can be implemented to return the hardware_instrument.

By default it returns the root_instrument of the parameter.

validate(value: Any) → None

Validate the value supplied.

Parameters

value – value to validate

Raises

• TypeError – If the value is of the wrong type.

• ValueError – If the value is outside the bounds specified by the validator.

class qcodes.instrument_drivers.stanford_research.SR830.ChannelTrace(name: str, channel: int, **kwargs: Any)

Bases: qcodes.instrument.parameter.ParameterWithSetpoints

Parameter class for the two channel buffers

Parameters

• name – The name of the parameter

• channel – The relevant channel (1 or 2). The name should should match this.

update_unit() → None

get_raw() → Any

Get command. Returns numpy array

__getitem__(keys: Any) → qcodes.instrument.sweep_values.SweepFixedValues

Slice a Parameter to get a SweepValues object to iterate over during a sweep

__str__() → str

Include the instrument name with the Parameter name if possible.

property abstract: Optional[bool]

property full_name: str

Name of the parameter including the name of the instrument and submodule that the parameter may be bound to. The names are separated by underscores, like this: instrument_submodule_parameter.

get_ramp_values(value: Union[float, Sized], step: Optional[float] = None) → Sequence[Union[float, Sized]]

Return values to sweep from current value to target value. This method can be overridden to have a custom sweep behaviour. It can even be overridden by a generator.

Parameters

• value – target value

• step – maximum step size

Returns

List of stepped values, including target value.

property gettable: bool

Is it allowed to call get on this parameter?

increment(value: Any) → None

Increment the parameter with a value

Parameters

value – Value to be added to the parameter.

property instrument: Optional[InstrumentBase]

Return the first instrument that this parameter is bound to. E.g if this is bound to a channel it will return the channel and not the instrument that the channel is bound too. Use root_instrument() to get the real instrument.

property inter_delay: float

Delay time between consecutive set operations. The actual time will not be shorter than this, but may be longer if the underlying set call takes longer.

Typically used in conjunction with step to create an effective ramp rate, but can also be used without a step to enforce a delay between sets.

Getter

Returns the current inter_delay.

Setter

Sets the value of the inter_delay.

Raises

• TypeError – If delay is not int nor float

• ValueError – If delay is negative

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

Load metadata into this classes metadata dictionary.

Parameters

metadata – Metadata to load.

property name: str

Name of the parameter. This is identical to short_name().

property name_parts: List[str]

List of the parts that make up the full name of this parameter

property post_delay: float

Delay time after start of set operation, for each set. The actual time will not be shorter than this, but may be longer if the underlying set call takes longer.

Typically used in conjunction with step to create an effective ramp rate, but can also be used without a step to enforce a delay after every set. One might think of post_delay as how long a set operation is supposed to take. For example, there might be an instrument that needs extra time after setting a parameter although the command for setting the parameter returns quickly.

Getter

Returns the current post_delay.

Setter

Sets the value of the post_delay.

Raises

• TypeError – If delay is not int nor float

• ValueError – If delay is negative

property raw_value: Any

Note that this property will be deprecated soon. Use cache.raw_value instead.

Represents the cached raw value of the parameter.

Getter

Returns the cached raw value of the parameter.

restore_at_exit(allow_changes: bool = True) → qcodes.instrument.parameter._SetParamContext

Use a context manager to restore the value of a parameter after a with block.

By default, the parameter value may be changed inside the block, but this can be prevented with allow_changes=False. This can be useful, for example, for debugging a complex measurement that unintentionally modifies a parameter.

Example

>>> p = Parameter("p", set_cmd=None, get_cmd=None)
>>> p.set(2)
>>> with p.restore_at_exit():
...     p.set(3)
...     print(f"value inside with block: {p.get()}")  # prints 3
>>> print(f"value after with block: {p.get()}")  # prints 2
>>> with p.restore_at_exit(allow_changes=False):
...     p.set(5)  # raises an exception

property root_instrument: Optional[InstrumentBase]

Return the fundamental instrument that this parameter belongs too. E.g if the parameter is bound to a channel this will return the fundamental instrument that that channel belongs to. Use instrument() to get the channel.

set_raw(value: Any) → None

set_raw is called to perform the actual setting of a parameter on the instrument. This method should either be overwritten to perform the desired operation or alternatively for Parameter a suitable method is automatically generated if set_cmd is supplied to the parameter constructor. The method is automatically wrapped to provide a set method on the parameter instance.

set_to(value: Any, allow_changes: bool = False) → qcodes.instrument.parameter._SetParamContext

Use a context manager to temporarily set a parameter to a value. By default, the parameter value cannot be changed inside the context. This may be overridden with allow_changes=True.

Examples

>>> from qcodes import Parameter
>>> p = Parameter("p", set_cmd=None, get_cmd=None)
>>> p.set(2)
>>> with p.set_to(3):
...     print(f"p value in with block {p.get()}")  # prints 3
...     p.set(5)  # raises an exception
>>> print(f"p value outside with block {p.get()}")  # prints 2
>>> with p.set_to(3, allow_changes=True):
...     p.set(5)  # now this works
>>> print(f"value after second block: {p.get()}")  # still prints 2

property setpoints: Sequence[qcodes.instrument.parameter._BaseParameter]

Sequence of parameters to use as setpoints for this parameter.

Getter

Returns a list of parameters currently used for setpoints.

Setter

Sets the parameters to be used as setpoints from a sequence. The combined shape of the parameters supplied must be consistent with the data shape of the data returned from get on the parameter.

property settable: bool

Is it allowed to call set on this parameter?

property short_name: str

Short name of the parameter. This is without the name of the instrument or submodule that the parameter may be bound to. For full name refer to full_name().

snapshot(update: Optional[bool] = False) → Dict[Any, 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: Optional[bool] = True, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

State of the parameter as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.NumpyJSONEncoder supports).

If the parameter has been initiated with snapshot_value=False, the snapshot will NOT include the value and raw_value of the parameter.

Parameters

• update – If True, update the state by calling parameter.get() unless snapshot_get of the parameter is False. If update is None, use the current value from the cache unless the cache is invalid. If False, never call parameter.get().

• params_to_skip_update – No effect but may be passed from superclass

Returns

base snapshot

property snapshot_value: bool

If True the value of the parameter will be included in the snapshot.

property step: Optional[float]

Stepsize that this Parameter uses during set operation. Stepsize must be a positive number or None. If step is a positive number, this is the maximum value change allowed in one hardware call, so a single set can result in many calls to the hardware if the starting value is far from the target. All but the final change will attempt to change by +/- step exactly. If step is None stepping will not be used.

Getter

Returns the current stepsize.

Setter

Sets the value of the step.

Raises

• TypeError – if step is set to not numeric or None

• ValueError – if step is set to negative

• TypeError – if step is set to not integer or None for an integer parameter

• TypeError – if step is set to not a number on None

sweep(start: float, stop: float, step: Optional[float] = None, num: Optional[int] = None) → qcodes.instrument.sweep_values.SweepFixedValues

Create a collection of parameter values to be iterated over. Requires start and stop and (step or num) The sign of step is not relevant.

Parameters

• start – The starting value of the sequence.

• stop – The end value of the sequence.

• step – Spacing between values.

• num – Number of values to generate.

Returns

Collection of parameter values to be iterated over.

Return type

SweepFixedValues

Examples

>>> sweep(0, 10, num=5)
 [0.0, 2.5, 5.0, 7.5, 10.0]
>>> sweep(5, 10, step=1)
[5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
>>> sweep(15, 10.5, step=1.5)
>[15.0, 13.5, 12.0, 10.5]

property underlying_instrument: Optional[InstrumentBase]

Returns an instance of the underlying hardware instrument that this parameter communicates with, per this parameter’s implementation.

This is useful in the case where a parameter does not belongs to an instrument instance that represents a real hardware instrument but actually uses a real hardware instrument in its implementation (e.g. via calls to one or more parameters of that real hardware instrument). This is also useful when a parameter does belong to an instrument instance but that instance does not represent the real hardware instrument that the parameter interacts with: hence root_instrument of the parameter cannot be the hardware_instrument, however underlying_instrument can be implemented to return the hardware_instrument.

By default it returns the root_instrument of the parameter.

property unit: str

The unit of measure. Use '' (the empty string) for unitless.

validate(value: Any) → None

Overwrites the standard validate method to also check the the parameter has consistent shape with its setpoints. This only makes sense if the parameter has an Arrays validator

Arguments are passed to the super method

validate_consistent_shape() → None

Verifies that the shape of the Array Validator of the parameter is consistent with the Validator of the Setpoints. This requires that both the setpoints and the actual parameters have validators of type Arrays with a defined shape.

label: str = ()

Label of the data used for plots etc.

class qcodes.instrument_drivers.stanford_research.SR830.GeneratedSetPoints(sweep_array: Iterable[Union[int, float]] = array([0., 0.11111111, 0.22222222, 0.33333333, 0.44444444, 0.55555556, 0.66666667, 0.77777778, 0.88888889, 1.]), *args: Any, **kwargs: Any)

Bases: qcodes.instrument.parameter.Parameter

A parameter that generates a setpoint array from start, stop and num points parameters.

update_units_if_constant_sample_rate() → None

If the buffer is filled at a constant sample rate, update the unit to “s” and label to “Time”; otherwise do nothing

set_raw(value: Iterable[Union[int, float]]) → None

set_raw is called to perform the actual setting of a parameter on the instrument. This method should either be overwritten to perform the desired operation or alternatively for Parameter a suitable method is automatically generated if set_cmd is supplied to the parameter constructor. The method is automatically wrapped to provide a set method on the parameter instance.

get_raw() → Any

get_raw is called to perform the actual data acquisition from the instrument. This method should either be overwritten to perform the desired operation or alternatively for Parameter a suitable method is automatically generated if get_cmd is supplied to the parameter constructor. The method is automatically wrapped to provide a get method on the parameter instance.

__getitem__(keys: Any) → qcodes.instrument.sweep_values.SweepFixedValues

Slice a Parameter to get a SweepValues object to iterate over during a sweep

__str__() → str

Include the instrument name with the Parameter name if possible.

property abstract: Optional[bool]

property full_name: str

Name of the parameter including the name of the instrument and submodule that the parameter may be bound to. The names are separated by underscores, like this: instrument_submodule_parameter.

get_ramp_values(value: Union[float, Sized], step: Optional[float] = None) → Sequence[Union[float, Sized]]

Return values to sweep from current value to target value. This method can be overridden to have a custom sweep behaviour. It can even be overridden by a generator.

Parameters

• value – target value

• step – maximum step size

Returns

List of stepped values, including target value.

property gettable: bool

Is it allowed to call get on this parameter?

increment(value: Any) → None

Increment the parameter with a value

Parameters

value – Value to be added to the parameter.

property instrument: Optional[InstrumentBase]

Return the first instrument that this parameter is bound to. E.g if this is bound to a channel it will return the channel and not the instrument that the channel is bound too. Use root_instrument() to get the real instrument.

property inter_delay: float

Delay time between consecutive set operations. The actual time will not be shorter than this, but may be longer if the underlying set call takes longer.

Typically used in conjunction with step to create an effective ramp rate, but can also be used without a step to enforce a delay between sets.

Getter

Returns the current inter_delay.

Setter

Sets the value of the inter_delay.

Raises

• TypeError – If delay is not int nor float

• ValueError – If delay is negative

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

Load metadata into this classes metadata dictionary.

Parameters

metadata – Metadata to load.

property name: str

Name of the parameter. This is identical to short_name().

property name_parts: List[str]

List of the parts that make up the full name of this parameter

property post_delay: float

Delay time after start of set operation, for each set. The actual time will not be shorter than this, but may be longer if the underlying set call takes longer.

Typically used in conjunction with step to create an effective ramp rate, but can also be used without a step to enforce a delay after every set. One might think of post_delay as how long a set operation is supposed to take. For example, there might be an instrument that needs extra time after setting a parameter although the command for setting the parameter returns quickly.

Getter

Returns the current post_delay.

Setter

Sets the value of the post_delay.

Raises

• TypeError – If delay is not int nor float

• ValueError – If delay is negative

property raw_value: Any

Note that this property will be deprecated soon. Use cache.raw_value instead.

Represents the cached raw value of the parameter.

Getter

Returns the cached raw value of the parameter.

restore_at_exit(allow_changes: bool = True) → qcodes.instrument.parameter._SetParamContext

Use a context manager to restore the value of a parameter after a with block.

By default, the parameter value may be changed inside the block, but this can be prevented with allow_changes=False. This can be useful, for example, for debugging a complex measurement that unintentionally modifies a parameter.

Example

>>> p = Parameter("p", set_cmd=None, get_cmd=None)
>>> p.set(2)
>>> with p.restore_at_exit():
...     p.set(3)
...     print(f"value inside with block: {p.get()}")  # prints 3
>>> print(f"value after with block: {p.get()}")  # prints 2
>>> with p.restore_at_exit(allow_changes=False):
...     p.set(5)  # raises an exception

property root_instrument: Optional[InstrumentBase]

Return the fundamental instrument that this parameter belongs too. E.g if the parameter is bound to a channel this will return the fundamental instrument that that channel belongs to. Use instrument() to get the channel.

set_to(value: Any, allow_changes: bool = False) → qcodes.instrument.parameter._SetParamContext

Use a context manager to temporarily set a parameter to a value. By default, the parameter value cannot be changed inside the context. This may be overridden with allow_changes=True.

Examples

>>> from qcodes import Parameter
>>> p = Parameter("p", set_cmd=None, get_cmd=None)
>>> p.set(2)
>>> with p.set_to(3):
...     print(f"p value in with block {p.get()}")  # prints 3
...     p.set(5)  # raises an exception
>>> print(f"p value outside with block {p.get()}")  # prints 2
>>> with p.set_to(3, allow_changes=True):
...     p.set(5)  # now this works
>>> print(f"value after second block: {p.get()}")  # still prints 2

property settable: bool

Is it allowed to call set on this parameter?

property short_name: str

Short name of the parameter. This is without the name of the instrument or submodule that the parameter may be bound to. For full name refer to full_name().

snapshot(update: Optional[bool] = False) → Dict[Any, 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: Optional[bool] = True, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

State of the parameter as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.NumpyJSONEncoder supports).

If the parameter has been initiated with snapshot_value=False, the snapshot will NOT include the value and raw_value of the parameter.

Parameters

• update – If True, update the state by calling parameter.get() unless snapshot_get of the parameter is False. If update is None, use the current value from the cache unless the cache is invalid. If False, never call parameter.get().

• params_to_skip_update – No effect but may be passed from superclass

Returns

base snapshot

property snapshot_value: bool

If True the value of the parameter will be included in the snapshot.

property step: Optional[float]

Stepsize that this Parameter uses during set operation. Stepsize must be a positive number or None. If step is a positive number, this is the maximum value change allowed in one hardware call, so a single set can result in many calls to the hardware if the starting value is far from the target. All but the final change will attempt to change by +/- step exactly. If step is None stepping will not be used.

Getter

Returns the current stepsize.

Setter

Sets the value of the step.

Raises

• TypeError – if step is set to not numeric or None

• ValueError – if step is set to negative

• TypeError – if step is set to not integer or None for an integer parameter

• TypeError – if step is set to not a number on None

sweep(start: float, stop: float, step: Optional[float] = None, num: Optional[int] = None) → qcodes.instrument.sweep_values.SweepFixedValues

Create a collection of parameter values to be iterated over. Requires start and stop and (step or num) The sign of step is not relevant.

Parameters

• start – The starting value of the sequence.

• stop – The end value of the sequence.

• step – Spacing between values.

• num – Number of values to generate.

Returns

Collection of parameter values to be iterated over.

Return type

SweepFixedValues

Examples

>>> sweep(0, 10, num=5)
 [0.0, 2.5, 5.0, 7.5, 10.0]
>>> sweep(5, 10, step=1)
[5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
>>> sweep(15, 10.5, step=1.5)
>[15.0, 13.5, 12.0, 10.5]

property underlying_instrument: Optional[InstrumentBase]

Returns an instance of the underlying hardware instrument that this parameter communicates with, per this parameter’s implementation.

This is useful in the case where a parameter does not belongs to an instrument instance that represents a real hardware instrument but actually uses a real hardware instrument in its implementation (e.g. via calls to one or more parameters of that real hardware instrument). This is also useful when a parameter does belong to an instrument instance but that instance does not represent the real hardware instrument that the parameter interacts with: hence root_instrument of the parameter cannot be the hardware_instrument, however underlying_instrument can be implemented to return the hardware_instrument.

By default it returns the root_instrument of the parameter.

property unit: str

The unit of measure. Use '' (the empty string) for unitless.

validate(value: Any) → None

Validate the value supplied.

Parameters

value – value to validate

Raises

• TypeError – If the value is of the wrong type.

• ValueError – If the value is outside the bounds specified by the validator.

label: str = ()

Label of the data used for plots etc.

class qcodes.instrument_drivers.stanford_research.SR830.SR830(*args: Any, **kwargs: Any)

Bases: qcodes.instrument.visa.VisaInstrument

This is the qcodes driver for the Stanford Research Systems SR830 Lock-in Amplifier

SNAP_PARAMETERS = {'aux1': '5', 'aux2': '6', 'aux3': '7', 'aux4': '8', 'ch1': '10', 'ch2': '11', 'freq': '9', 'p': '4', 'phase': '4', 'r': '3', 'x': '1', 'y': '2', 'θ': '4'}

snap(*parameters: str) → Tuple[float, ...]

Get between 2 and 6 parameters at a single instant. This provides a coherent snapshot of measured signals. Pick up to 6 from: X, Y, R, θ, the aux inputs 1-4, frequency, or what is currently displayed on channels 1 and 2.

Reading X and Y (or R and θ) gives a coherent snapshot of the signal. Snap is important when the time constant is very short, a time constant less than 100 ms.

Parameters

*parameters – From 2 to 6 strings of names of parameters for which the values are requested. including: ‘x’, ‘y’, ‘r’, ‘p’, ‘phase’ or ‘θ’, ‘aux1’, ‘aux2’, ‘aux3’, ‘aux4’, ‘freq’, ‘ch1’, and ‘ch2’.

Returns

A tuple of floating point values in the same order as requested.

Examples

>>> lockin.snap('x','y') -> tuple(x,y)

>>> lockin.snap('aux1','aux2','freq','phase')
>>> -> tuple(aux1,aux2,freq,phase)

Note

Volts for x, y, r, and aux 1-4 Degrees for θ Hertz for freq Unknown for ch1 and ch2. It will depend on what was set.

• If X,Y,R and θ are all read, then the values of X,Y are recorded approximately 10 µs apart from R,θ. Thus, the values of X and Y may not yield the exact values of R and θ from a single snap.

• The values of the Aux Inputs may have an uncertainty of up to 32 µs.

• The frequency is computed only every other period or 40 ms, whichever is longer.

increment_sensitivity() → bool

Increment the sensitivity setting of the lock-in. This is equivalent to pushing the sensitivity up button on the front panel. This has no effect if the sensitivity is already at the maximum.

Returns

Whether or not the sensitivity was actually changed.

decrement_sensitivity() → bool

Decrement the sensitivity setting of the lock-in. This is equivalent to pushing the sensitivity down button on the front panel. This has no effect if the sensitivity is already at the minimum.

Returns

Whether or not the sensitivity was actually changed.

autorange(max_changes: int = 1) → None

Automatically changes the sensitivity of the instrument according to the R value and defined max_changes.

Parameters

max_changes – Maximum number of steps allowing the function to automatically change the sensitivity (default is 1). The actual number of steps needed to change to the optimal sensitivity may be more or less than this maximum.

set_sweep_parameters(sweep_param: qcodes.instrument.parameter.Parameter, start: float, stop: float, n_points: int = 10, label: Optional[str] = None) → None

__del__() → None

Close the instrument and remove its instance record.

__getitem__(key: str) → Union[Callable[[...], Any], qcodes.instrument.parameter.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. If your case is more complicated, you’re probably better off simply making a new method in your Instrument subclass definition.

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 = <class 'qcodes.instrument.parameter.Parameter'>, **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 instrument.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 parameter.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: Union[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: List[qcodes.instrument.base.InstrumentBase]

Returns a list of instruments, starting from the current instrument and following to the parent instrument and the parents parent instrument until the root instrument is reached.

ask(cmd: str) → str

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

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

Parameters

cmd – The string to send to the instrument.

Returns

response

Raises

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

ask_raw(cmd: str) → str

Low-level interface to visa_handle.ask.

Parameters

cmd – The command to send to the instrument.

Returns

The instrument’s response.

Return type

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.

check_error(ret_code: int) → None

Default error checking, raises an error if return code !=0. Does not differentiate between warnings or specific error messages. Override this function in your driver if you want to add specific error messages.

Parameters

ret_code – A Visa error code. See eg: https://github.com/hgrecco/pyvisa/blob/master/pyvisa/errors.py

Raises

visa.VisaIOError – if ret_code indicates a communication problem.

close() → None

Disconnect and irreversibly tear down 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: Optional[float] = 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: 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: 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.

device_clear() → None

Clear the buffers of the device

static exist(name: str, instrument_class: Optional[type] = 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: Optional[Type[qcodes.instrument.base.T]] = None) → qcodes.instrument.base.T

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

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_idn() → Dict[str, Optional[str]]

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

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

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

Returns

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

classmethod instances() → List[qcodes.instrument.base.Instrument]

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: qcodes.instrument.base.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

Name of the instrument This is equivalent to full_name for backwards compatibility.

property name_parts: List[str]

omit_delegate_attrs: List[str] = []

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

property parent: Optional[qcodes.instrument.base.InstrumentBase]

Returns 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: qcodes.instrument.base.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: qcodes.instrument.base.Instrument) → None

Remove a particular instance from the record.

Parameters

instance – The instance to remove

property root_instrument: qcodes.instrument.base.InstrumentBase

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

Change the read terminator to use.

Parameters

terminator – Character(s) to look for at the end of a read. eg. \r\n.

shared_kwargs = ()

property short_name: str

Short name of the instrument

snapshot(update: Optional[bool] = False) → Dict[Any, 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: Optional[bool] = True, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.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

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

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

Parameters

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

write(cmd: str) → None

Write a command string with NO response to the hardware.

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

Parameters

cmd – The string to send to the instrument.

Raises

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

write_raw(cmd: str) → None

Low-level interface to visa_handle.write.

Parameters

cmd – The command to send to the instrument.

parameters: Dict[str, _BaseParameter] = {}

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, Union['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 instrument_modules of this instrument Usually populated via add_submodule().

qcodes.instrument_drivers.stanford_research.SR860 module

class qcodes.instrument_drivers.stanford_research.SR860.SR860(*args: Any, **kwargs: Any)

Bases: qcodes.instrument_drivers.stanford_research.SR86x.SR86x

The SR860 instrument is almost equal to the SR865, except for the max frequency

PARAMETER_NAMES = {'P': '3', 'R': '2', 'X': '0', 'Xnoise': '8', 'Y': '1', 'Ynoise': '9', 'amplitude': '13', 'aux_in1': '4', 'aux_in2': '5', 'aux_in3': '6', 'aux_in4': '7', 'aux_out1': '10', 'aux_out2': '11', 'frequency': '15', 'frequency_ext': '16', 'phase': '12', 'sine_outdc': '14'}

__del__() → None

Close the instrument and remove its instance record.

__getitem__(key: str) → Union[Callable[[...], Any], qcodes.instrument.parameter.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. If your case is more complicated, you’re probably better off simply making a new method in your Instrument subclass definition.

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 = <class 'qcodes.instrument.parameter.Parameter'>, **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 instrument.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 parameter.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: Union[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: List[qcodes.instrument.base.InstrumentBase]

Returns a list of instruments, starting from the current instrument and following to the parent instrument and the parents parent instrument until the root instrument is reached.

ask(cmd: str) → str

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

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

Parameters

cmd – The string to send to the instrument.

Returns

response

Raises

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

ask_raw(cmd: str) → str

Low-level interface to visa_handle.ask.

Parameters

cmd – The command to send to the instrument.

Returns

The instrument’s response.

Return type

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.

check_error(ret_code: int) → None

Default error checking, raises an error if return code !=0. Does not differentiate between warnings or specific error messages. Override this function in your driver if you want to add specific error messages.

Parameters

ret_code – A Visa error code. See eg: https://github.com/hgrecco/pyvisa/blob/master/pyvisa/errors.py

Raises

visa.VisaIOError – if ret_code indicates a communication problem.

close() → None

Disconnect and irreversibly tear down 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: Optional[float] = 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: 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: 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.

device_clear() → None

Clear the buffers of the device

static exist(name: str, instrument_class: Optional[type] = 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: Optional[Type[qcodes.instrument.base.T]] = None) → qcodes.instrument.base.T

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

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_data_channels_dict(requery_names: bool = False) → Dict[str, float]

Returns a dictionary where the keys are parameter names currently assigned to the data channels, and values are the values of those parameters.

Parameters

requery_names – if False, the currently assigned parameter names will not be queries from the instrument in order to save time on communication, in this case the cached assigned parameter names will be used for the keys of the dicitonary; if True, the assigned parameter names will be queried from the instrument

Returns

a dictionary where keys are names of parameters assigned to the data channels, and values are the values of those parameters

get_data_channels_parameters(query_instrument: bool = True) → Tuple[str, ...]

Convenience method to query a list of parameters which the data channels are currently assigned to.

Parameters

query_instrument – If set to False, the internally cashed names of the parameters will be returned; if True, then the names will be queried through the instrument

Returns

a tuple of 4 strings of parameter names

get_data_channels_values() → Tuple[float, ...]

Queries the current values of the data channels

Returns

tuple of 4 values of the data channels

get_idn() → Dict[str, Optional[str]]

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

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

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

Returns

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

get_values(*parameter_names: str) → Tuple[float, ...]

Get values of 2 or 3 parameters that are measured by the lock-in amplifier. These values are guaranteed to come from the same measurement cycle as opposed to getting values of parameters one by one (for example, by calling sr.X(), and then sr.Y().

Parameters

*parameter_names – 2 or 3 names of parameters for which the values are requested; valid names can be found in PARAMETER_NAMES attribute of the driver class

Returns

a tuple of 2 or 3 floating point values

classmethod instances() → List[qcodes.instrument.base.Instrument]

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: qcodes.instrument.base.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

Name of the instrument This is equivalent to full_name for backwards compatibility.

property name_parts: List[str]

omit_delegate_attrs: List[str] = []

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

property parent: Optional[qcodes.instrument.base.InstrumentBase]

Returns 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: qcodes.instrument.base.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: qcodes.instrument.base.Instrument) → None

Remove a particular instance from the record.

Parameters

instance – The instance to remove

property root_instrument: qcodes.instrument.base.InstrumentBase

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

Change the read terminator to use.

Parameters

terminator – Character(s) to look for at the end of a read. eg. \r\n.

shared_kwargs = ()

property short_name: str

Short name of the instrument

snapshot(update: Optional[bool] = False) → Dict[Any, 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: Optional[bool] = True, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.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

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

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

Parameters

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

write(cmd: str) → None

Write a command string with NO response to the hardware.

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

Parameters

cmd – The string to send to the instrument.

Raises

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

write_raw(cmd: str) → None

Low-level interface to visa_handle.write.

Parameters

cmd – The command to send to the instrument.

parameters: Dict[str, _BaseParameter] = {}

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, Union['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 instrument_modules of this instrument Usually populated via add_submodule().

qcodes.instrument_drivers.stanford_research.SR865 module

class qcodes.instrument_drivers.stanford_research.SR865.SR865(*args: Any, **kwargs: Any)

Bases: qcodes.instrument_drivers.stanford_research.SR86x.SR86x

The SR865 instrument is almost equal to the SR860, except for the max frequency

PARAMETER_NAMES = {'P': '3', 'R': '2', 'X': '0', 'Xnoise': '8', 'Y': '1', 'Ynoise': '9', 'amplitude': '13', 'aux_in1': '4', 'aux_in2': '5', 'aux_in3': '6', 'aux_in4': '7', 'aux_out1': '10', 'aux_out2': '11', 'frequency': '15', 'frequency_ext': '16', 'phase': '12', 'sine_outdc': '14'}

__del__() → None

Close the instrument and remove its instance record.

__getitem__(key: str) → Union[Callable[[...], Any], qcodes.instrument.parameter.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. If your case is more complicated, you’re probably better off simply making a new method in your Instrument subclass definition.

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 = <class 'qcodes.instrument.parameter.Parameter'>, **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 instrument.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 parameter.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: Union[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: List[qcodes.instrument.base.InstrumentBase]

Returns a list of instruments, starting from the current instrument and following to the parent instrument and the parents parent instrument until the root instrument is reached.

ask(cmd: str) → str

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

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

Parameters

cmd – The string to send to the instrument.

Returns

response

Raises

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

ask_raw(cmd: str) → str

Low-level interface to visa_handle.ask.

Parameters

cmd – The command to send to the instrument.

Returns

The instrument’s response.

Return type

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.

check_error(ret_code: int) → None

Default error checking, raises an error if return code !=0. Does not differentiate between warnings or specific error messages. Override this function in your driver if you want to add specific error messages.

Parameters

ret_code – A Visa error code. See eg: https://github.com/hgrecco/pyvisa/blob/master/pyvisa/errors.py

Raises

visa.VisaIOError – if ret_code indicates a communication problem.

close() → None

Disconnect and irreversibly tear down 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: Optional[float] = 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: 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: 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.

device_clear() → None

Clear the buffers of the device

static exist(name: str, instrument_class: Optional[type] = 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: Optional[Type[qcodes.instrument.base.T]] = None) → qcodes.instrument.base.T

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

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_data_channels_dict(requery_names: bool = False) → Dict[str, float]

Returns a dictionary where the keys are parameter names currently assigned to the data channels, and values are the values of those parameters.

Parameters

requery_names – if False, the currently assigned parameter names will not be queries from the instrument in order to save time on communication, in this case the cached assigned parameter names will be used for the keys of the dicitonary; if True, the assigned parameter names will be queried from the instrument

Returns

a dictionary where keys are names of parameters assigned to the data channels, and values are the values of those parameters

get_data_channels_parameters(query_instrument: bool = True) → Tuple[str, ...]

Convenience method to query a list of parameters which the data channels are currently assigned to.

Parameters

query_instrument – If set to False, the internally cashed names of the parameters will be returned; if True, then the names will be queried through the instrument

Returns

a tuple of 4 strings of parameter names

get_data_channels_values() → Tuple[float, ...]

Queries the current values of the data channels

Returns

tuple of 4 values of the data channels

get_idn() → Dict[str, Optional[str]]

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

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

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

Returns

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

get_values(*parameter_names: str) → Tuple[float, ...]

Get values of 2 or 3 parameters that are measured by the lock-in amplifier. These values are guaranteed to come from the same measurement cycle as opposed to getting values of parameters one by one (for example, by calling sr.X(), and then sr.Y().

Parameters

*parameter_names – 2 or 3 names of parameters for which the values are requested; valid names can be found in PARAMETER_NAMES attribute of the driver class

Returns

a tuple of 2 or 3 floating point values

classmethod instances() → List[qcodes.instrument.base.Instrument]

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: qcodes.instrument.base.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

Name of the instrument This is equivalent to full_name for backwards compatibility.

property name_parts: List[str]

omit_delegate_attrs: List[str] = []

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

property parent: Optional[qcodes.instrument.base.InstrumentBase]

Returns 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: qcodes.instrument.base.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: qcodes.instrument.base.Instrument) → None

Remove a particular instance from the record.

Parameters

instance – The instance to remove

property root_instrument: qcodes.instrument.base.InstrumentBase

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

Change the read terminator to use.

Parameters

terminator – Character(s) to look for at the end of a read. eg. \r\n.

shared_kwargs = ()

property short_name: str

Short name of the instrument

snapshot(update: Optional[bool] = False) → Dict[Any, 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: Optional[bool] = True, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.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

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

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

Parameters

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

write(cmd: str) → None

Write a command string with NO response to the hardware.

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

Parameters

cmd – The string to send to the instrument.

Raises

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

write_raw(cmd: str) → None

Low-level interface to visa_handle.write.

Parameters

cmd – The command to send to the instrument.

parameters: Dict[str, _BaseParameter] = {}

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, Union['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 instrument_modules of this instrument Usually populated via add_submodule().

qcodes.instrument_drivers.stanford_research.SR865A module

class qcodes.instrument_drivers.stanford_research.SR865A.SR865A(*args: Any, **kwargs: Any)

Bases: qcodes.instrument_drivers.stanford_research.SR86x.SR86x

The SR865A instrument is almost equal to the SR865, except for the max frequency

PARAMETER_NAMES = {'P': '3', 'R': '2', 'X': '0', 'Xnoise': '8', 'Y': '1', 'Ynoise': '9', 'amplitude': '13', 'aux_in1': '4', 'aux_in2': '5', 'aux_in3': '6', 'aux_in4': '7', 'aux_out1': '10', 'aux_out2': '11', 'frequency': '15', 'frequency_ext': '16', 'phase': '12', 'sine_outdc': '14'}

__del__() → None

Close the instrument and remove its instance record.

__getitem__(key: str) → Union[Callable[[...], Any], qcodes.instrument.parameter.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. If your case is more complicated, you’re probably better off simply making a new method in your Instrument subclass definition.

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 = <class 'qcodes.instrument.parameter.Parameter'>, **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 instrument.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 parameter.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: Union[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: List[qcodes.instrument.base.InstrumentBase]

Returns a list of instruments, starting from the current instrument and following to the parent instrument and the parents parent instrument until the root instrument is reached.

ask(cmd: str) → str

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

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

Parameters

cmd – The string to send to the instrument.

Returns

response

Raises

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

ask_raw(cmd: str) → str

Low-level interface to visa_handle.ask.

Parameters

cmd – The command to send to the instrument.

Returns

The instrument’s response.

Return type

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.

check_error(ret_code: int) → None

Default error checking, raises an error if return code !=0. Does not differentiate between warnings or specific error messages. Override this function in your driver if you want to add specific error messages.

Parameters

ret_code – A Visa error code. See eg: https://github.com/hgrecco/pyvisa/blob/master/pyvisa/errors.py

Raises

visa.VisaIOError – if ret_code indicates a communication problem.

close() → None

Disconnect and irreversibly tear down 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: Optional[float] = 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: 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: 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.

device_clear() → None

Clear the buffers of the device

static exist(name: str, instrument_class: Optional[type] = 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: Optional[Type[qcodes.instrument.base.T]] = None) → qcodes.instrument.base.T

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

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_data_channels_dict(requery_names: bool = False) → Dict[str, float]

Returns a dictionary where the keys are parameter names currently assigned to the data channels, and values are the values of those parameters.

Parameters

requery_names – if False, the currently assigned parameter names will not be queries from the instrument in order to save time on communication, in this case the cached assigned parameter names will be used for the keys of the dicitonary; if True, the assigned parameter names will be queried from the instrument

Returns

a dictionary where keys are names of parameters assigned to the data channels, and values are the values of those parameters

get_data_channels_parameters(query_instrument: bool = True) → Tuple[str, ...]

Convenience method to query a list of parameters which the data channels are currently assigned to.

Parameters

query_instrument – If set to False, the internally cashed names of the parameters will be returned; if True, then the names will be queried through the instrument

Returns

a tuple of 4 strings of parameter names

get_data_channels_values() → Tuple[float, ...]

Queries the current values of the data channels

Returns

tuple of 4 values of the data channels

get_idn() → Dict[str, Optional[str]]

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

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

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

Returns

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

get_values(*parameter_names: str) → Tuple[float, ...]

Get values of 2 or 3 parameters that are measured by the lock-in amplifier. These values are guaranteed to come from the same measurement cycle as opposed to getting values of parameters one by one (for example, by calling sr.X(), and then sr.Y().

Parameters

*parameter_names – 2 or 3 names of parameters for which the values are requested; valid names can be found in PARAMETER_NAMES attribute of the driver class

Returns

a tuple of 2 or 3 floating point values

classmethod instances() → List[qcodes.instrument.base.Instrument]

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: qcodes.instrument.base.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

Name of the instrument This is equivalent to full_name for backwards compatibility.

property name_parts: List[str]

omit_delegate_attrs: List[str] = []

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

property parent: Optional[qcodes.instrument.base.InstrumentBase]

Returns 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: qcodes.instrument.base.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: qcodes.instrument.base.Instrument) → None

Remove a particular instance from the record.

Parameters

instance – The instance to remove

property root_instrument: qcodes.instrument.base.InstrumentBase

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

Change the read terminator to use.

Parameters

terminator – Character(s) to look for at the end of a read. eg. \r\n.

shared_kwargs = ()

property short_name: str

Short name of the instrument

snapshot(update: Optional[bool] = False) → Dict[Any, 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: Optional[bool] = True, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.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

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

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

Parameters

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

write(cmd: str) → None

Write a command string with NO response to the hardware.

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

Parameters

cmd – The string to send to the instrument.

Raises

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

write_raw(cmd: str) → None

Low-level interface to visa_handle.write.

Parameters

cmd – The command to send to the instrument.

parameters: Dict[str, _BaseParameter] = {}

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, Union['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 instrument_modules of this instrument Usually populated via add_submodule().

qcodes.instrument_drivers.stanford_research.SR86x module

class qcodes.instrument_drivers.stanford_research.SR86x.SR86x(*args: Any, **kwargs: Any)

Bases: qcodes.instrument.visa.VisaInstrument

This is the code for Stanford_SR865 Lock-in Amplifier

PARAMETER_NAMES = {'P': '3', 'R': '2', 'X': '0', 'Xnoise': '8', 'Y': '1', 'Ynoise': '9', 'amplitude': '13', 'aux_in1': '4', 'aux_in2': '5', 'aux_in3': '6', 'aux_in4': '7', 'aux_out1': '10', 'aux_out2': '11', 'frequency': '15', 'frequency_ext': '16', 'phase': '12', 'sine_outdc': '14'}

get_values(*parameter_names: str) → Tuple[float, ...]

Get values of 2 or 3 parameters that are measured by the lock-in amplifier. These values are guaranteed to come from the same measurement cycle as opposed to getting values of parameters one by one (for example, by calling sr.X(), and then sr.Y().

Parameters

*parameter_names – 2 or 3 names of parameters for which the values are requested; valid names can be found in PARAMETER_NAMES attribute of the driver class

Returns

a tuple of 2 or 3 floating point values

get_data_channels_values() → Tuple[float, ...]

Queries the current values of the data channels

Returns

tuple of 4 values of the data channels

get_data_channels_parameters(query_instrument: bool = True) → Tuple[str, ...]

Convenience method to query a list of parameters which the data channels are currently assigned to.

Parameters

query_instrument – If set to False, the internally cashed names of the parameters will be returned; if True, then the names will be queried through the instrument

Returns

a tuple of 4 strings of parameter names

get_data_channels_dict(requery_names: bool = False) → Dict[str, float]

Returns a dictionary where the keys are parameter names currently assigned to the data channels, and values are the values of those parameters.

Parameters

requery_names – if False, the currently assigned parameter names will not be queries from the instrument in order to save time on communication, in this case the cached assigned parameter names will be used for the keys of the dicitonary; if True, the assigned parameter names will be queried from the instrument

Returns

a dictionary where keys are names of parameters assigned to the data channels, and values are the values of those parameters

__del__() → None

Close the instrument and remove its instance record.

__getitem__(key: str) → Union[Callable[[...], Any], qcodes.instrument.parameter.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. If your case is more complicated, you’re probably better off simply making a new method in your Instrument subclass definition.

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 = <class 'qcodes.instrument.parameter.Parameter'>, **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 instrument.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 parameter.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: Union[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: List[qcodes.instrument.base.InstrumentBase]

Returns a list of instruments, starting from the current instrument and following to the parent instrument and the parents parent instrument until the root instrument is reached.

ask(cmd: str) → str

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

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

Parameters

cmd – The string to send to the instrument.

Returns

response

Raises

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

ask_raw(cmd: str) → str

Low-level interface to visa_handle.ask.

Parameters

cmd – The command to send to the instrument.

Returns

The instrument’s response.

Return type

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.

check_error(ret_code: int) → None

Default error checking, raises an error if return code !=0. Does not differentiate between warnings or specific error messages. Override this function in your driver if you want to add specific error messages.

Parameters

ret_code – A Visa error code. See eg: https://github.com/hgrecco/pyvisa/blob/master/pyvisa/errors.py

Raises

visa.VisaIOError – if ret_code indicates a communication problem.

close() → None

Disconnect and irreversibly tear down 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: Optional[float] = 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: 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: 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.

device_clear() → None

Clear the buffers of the device

static exist(name: str, instrument_class: Optional[type] = 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: Optional[Type[qcodes.instrument.base.T]] = None) → qcodes.instrument.base.T

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

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_idn() → Dict[str, Optional[str]]

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

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

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

Returns

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

classmethod instances() → List[qcodes.instrument.base.Instrument]

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: qcodes.instrument.base.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

Name of the instrument This is equivalent to full_name for backwards compatibility.

property name_parts: List[str]

omit_delegate_attrs: List[str] = []

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

property parent: Optional[qcodes.instrument.base.InstrumentBase]

Returns 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: qcodes.instrument.base.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: qcodes.instrument.base.Instrument) → None

Remove a particular instance from the record.

Parameters

instance – The instance to remove

property root_instrument: qcodes.instrument.base.InstrumentBase

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

Change the read terminator to use.

Parameters

terminator – Character(s) to look for at the end of a read. eg. \r\n.

shared_kwargs = ()

property short_name: str

Short name of the instrument

snapshot(update: Optional[bool] = False) → Dict[Any, 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: Optional[bool] = True, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.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

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

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

Parameters

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

write(cmd: str) → None

Write a command string with NO response to the hardware.

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

Parameters

cmd – The string to send to the instrument.

Raises

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

write_raw(cmd: str) → None

Low-level interface to visa_handle.write.

Parameters

cmd – The command to send to the instrument.

parameters: Dict[str, _BaseParameter] = {}

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, Union['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 instrument_modules of this instrument Usually populated via add_submodule().

class qcodes.instrument_drivers.stanford_research.SR86x.SR86xBuffer(parent: qcodes.instrument_drivers.stanford_research.SR86x.SR86x, name: str)

Bases: qcodes.instrument.channel.InstrumentChannel

The buffer module for the SR86x driver. This driver has been verified to work with the SR860 and SR865. For reference, please consult the SR860 manual: http://thinksrs.com/downloads/PDFs/Manuals/SR860m.pdf

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

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.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

set_capture_rate_to_maximum() → None

Sets the capture rate to maximum. The maximum capture rate is retrieved from the device, and depends on the current value of the time constant.

start_capture(acquisition_mode: str, trigger_mode: str) → None

Start an acquisition. Please see page 137 of the manual for a detailed explanation.

Parameters

• acquisition_mode – “ONE” | “CONT”

• trigger_mode – “IMM” | “TRIG” | “SAMP”

stop_capture() → None

Stop a capture

set_capture_length_to_fit_samples(sample_count: int) → None

Set the capture length of the buffer to fit the given number of samples.

Parameters

sample_count – Number of samples that the buffer has to fit

wait_until_samples_captured(sample_count: int) → None

Wait until the given number of samples is captured. This function is blocking and has to be used with caution because it does not have a timeout.

Parameters

sample_count – Number of samples that needs to be captured

get_capture_data(sample_count: int) → Dict[str, numpy.ndarray]

Read the given number of samples of the capture data from the buffer.

Parameters

sample_count – number of samples to read from the buffer

Returns

The keys in the dictionary correspond to the captured variables. For instance, if before the capture, the capture config was set as ‘capture_config(“X,Y”)’, then the keys will be “X” and “Y”. The values in the dictionary are numpy arrays of numbers.

capture_one_sample_per_trigger(trigger_count: int, start_triggers_pulsetrain: Callable[[...], Any]) → Dict[str, numpy.ndarray]

Capture one sample per each trigger, and return when the specified number of triggers has been received.

Parameters

• trigger_count – Number of triggers to capture samples for

• start_triggers_pulsetrain – By calling this non-blocking function, the train of trigger pulses should start

Returns

The keys in the dictionary correspond to the captured variables. For instance, if before the capture, the capture config was set as ‘capture_config(“X,Y”)’, then the keys will be “X” and “Y”. The values in the dictionary are numpy arrays of numbers.

capture_samples_after_trigger(sample_count: int, send_trigger: Callable[[...], Any]) → Dict[str, numpy.ndarray]

Capture a number of samples after a trigger has been received. Please refer to page 135 of the manual for details.

Parameters

• sample_count – Number of samples to capture

• send_trigger – By calling this non-blocking function, one trigger should be sent that will initiate the capture

Returns

The keys in the dictionary correspond to the captured variables. For instance, if before the capture, the capture config was set as ‘capture_config(“X,Y”)’, then the keys will be “X” and “Y”. The values in the dictionary are numpy arrays of numbers.

capture_samples(sample_count: int) → Dict[str, numpy.ndarray]

Capture a number of samples at a capture rate, starting immediately. Unlike the “continuous” capture mode, here the buffer does not get overwritten with the new data once the buffer is full.

The function blocks until the required number of samples is acquired, and returns them.

Parameters

sample_count – Number of samples to capture

Returns

The keys in the dictionary correspond to the captured variables. For instance, if before the capture, the capture config was set as ‘capture_config(“X,Y”)’, then the keys will be “X” and “Y”. The values in the dictionary are numpy arrays of numbers.

__getitem__(key: str) → Union[Callable[[...], Any], qcodes.instrument.parameter.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. If your case is more complicated, you’re probably better off simply making a new method in your Instrument subclass definition.

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 = <class 'qcodes.instrument.parameter.Parameter'>, **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 instrument.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 parameter.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: Union[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: List[qcodes.instrument.base.InstrumentBase]

Returns a list of instruments, starting from the current instrument and following to the parent instrument and the parents parent instrument 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: 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: 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

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.

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

Name of the instrument This is equivalent to full_name for backwards compatibility.

property name_parts: List[str]

omit_delegate_attrs: List[str] = []

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

property parent: qcodes.instrument.base.InstrumentBase

Returns 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: qcodes.instrument.base.InstrumentBase

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

snapshot(update: Optional[bool] = False) → Dict[Any, 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.

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

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, Union['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 instrument_modules of this instrument Usually populated via add_submodule().

class qcodes.instrument_drivers.stanford_research.SR86x.SR86xBufferReadout(name: str, instrument: qcodes.instrument_drivers.stanford_research.SR86x.SR86x, **kwargs: Any)

Bases: qcodes.instrument.parameter.ArrayParameter

The parameter array that holds read out data. We need this to be compatible with qcodes.Measure

Parameters

• name – Name of the parameter.

• instrument – The instrument to add this parameter to.

prepare_readout(capture_data: numpy.ndarray) → None

Prepare this parameter for readout.

Parameters

capture_data – The data to capture.

get_raw() → numpy.ndarray

Public method to access the capture data

__str__() → str

Include the instrument name with the Parameter name if possible.

property abstract: Optional[bool]

property full_name: str

Name of the parameter including the name of the instrument and submodule that the parameter may be bound to. The names are separated by underscores, like this: instrument_submodule_parameter.

get_ramp_values(value: Union[float, Sized], step: Optional[float] = None) → Sequence[Union[float, Sized]]

Return values to sweep from current value to target value. This method can be overridden to have a custom sweep behaviour. It can even be overridden by a generator.

Parameters

• value – target value

• step – maximum step size

Returns

List of stepped values, including target value.

property gettable: bool

Is it allowed to call get on this parameter?

property instrument: Optional[InstrumentBase]

Return the first instrument that this parameter is bound to. E.g if this is bound to a channel it will return the channel and not the instrument that the channel is bound too. Use root_instrument() to get the real instrument.

property inter_delay: float

Delay time between consecutive set operations. The actual time will not be shorter than this, but may be longer if the underlying set call takes longer.

Typically used in conjunction with step to create an effective ramp rate, but can also be used without a step to enforce a delay between sets.

Getter

Returns the current inter_delay.

Setter

Sets the value of the inter_delay.

Raises

• TypeError – If delay is not int nor float

• ValueError – If delay is negative

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

Load metadata into this classes metadata dictionary.

Parameters

metadata – Metadata to load.

property name: str

Name of the parameter. This is identical to short_name().

property name_parts: List[str]

List of the parts that make up the full name of this parameter

property post_delay: float

Delay time after start of set operation, for each set. The actual time will not be shorter than this, but may be longer if the underlying set call takes longer.

Typically used in conjunction with step to create an effective ramp rate, but can also be used without a step to enforce a delay after every set. One might think of post_delay as how long a set operation is supposed to take. For example, there might be an instrument that needs extra time after setting a parameter although the command for setting the parameter returns quickly.

Getter

Returns the current post_delay.

Setter

Sets the value of the post_delay.

Raises

• TypeError – If delay is not int nor float

• ValueError – If delay is negative

property raw_value: Any

Note that this property will be deprecated soon. Use cache.raw_value instead.

Represents the cached raw value of the parameter.

Getter

Returns the cached raw value of the parameter.

restore_at_exit(allow_changes: bool = True) → qcodes.instrument.parameter._SetParamContext

Use a context manager to restore the value of a parameter after a with block.

By default, the parameter value may be changed inside the block, but this can be prevented with allow_changes=False. This can be useful, for example, for debugging a complex measurement that unintentionally modifies a parameter.

Example

>>> p = Parameter("p", set_cmd=None, get_cmd=None)
>>> p.set(2)
>>> with p.restore_at_exit():
...     p.set(3)
...     print(f"value inside with block: {p.get()}")  # prints 3
>>> print(f"value after with block: {p.get()}")  # prints 2
>>> with p.restore_at_exit(allow_changes=False):
...     p.set(5)  # raises an exception

property root_instrument: Optional[InstrumentBase]

Return the fundamental instrument that this parameter belongs too. E.g if the parameter is bound to a channel this will return the fundamental instrument that that channel belongs to. Use instrument() to get the channel.

set_raw(value: Any) → None

set_raw is called to perform the actual setting of a parameter on the instrument. This method should either be overwritten to perform the desired operation or alternatively for Parameter a suitable method is automatically generated if set_cmd is supplied to the parameter constructor. The method is automatically wrapped to provide a set method on the parameter instance.

set_to(value: Any, allow_changes: bool = False) → qcodes.instrument.parameter._SetParamContext

Use a context manager to temporarily set a parameter to a value. By default, the parameter value cannot be changed inside the context. This may be overridden with allow_changes=True.

Examples

>>> from qcodes import Parameter
>>> p = Parameter("p", set_cmd=None, get_cmd=None)
>>> p.set(2)
>>> with p.set_to(3):
...     print(f"p value in with block {p.get()}")  # prints 3
...     p.set(5)  # raises an exception
>>> print(f"p value outside with block {p.get()}")  # prints 2
>>> with p.set_to(3, allow_changes=True):
...     p.set(5)  # now this works
>>> print(f"value after second block: {p.get()}")  # still prints 2

property setpoint_full_names: Optional[Sequence[str]]

Full names of setpoints including instrument names if available

property settable: bool

Is it allowed to call set on this parameter?

property short_name: str

Short name of the parameter. This is without the name of the instrument or submodule that the parameter may be bound to. For full name refer to full_name().

snapshot(update: Optional[bool] = False) → Dict[Any, 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: Optional[bool] = True, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

State of the parameter as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.NumpyJSONEncoder supports).

If the parameter has been initiated with snapshot_value=False, the snapshot will NOT include the value and raw_value of the parameter.

Parameters

• update – If True, update the state by calling parameter.get() unless snapshot_get of the parameter is False. If update is None, use the current value from the cache unless the cache is invalid. If False, never call parameter.get().

• params_to_skip_update – No effect but may be passed from superclass

Returns

base snapshot

property snapshot_value: bool

If True the value of the parameter will be included in the snapshot.

property step: Optional[float]

Stepsize that this Parameter uses during set operation. Stepsize must be a positive number or None. If step is a positive number, this is the maximum value change allowed in one hardware call, so a single set can result in many calls to the hardware if the starting value is far from the target. All but the final change will attempt to change by +/- step exactly. If step is None stepping will not be used.

Getter

Returns the current stepsize.

Setter

Sets the value of the step.

Raises

• TypeError – if step is set to not numeric or None

• ValueError – if step is set to negative

• TypeError – if step is set to not integer or None for an integer parameter

• TypeError – if step is set to not a number on None

property underlying_instrument: Optional[InstrumentBase]

Returns an instance of the underlying hardware instrument that this parameter communicates with, per this parameter’s implementation.

This is useful in the case where a parameter does not belongs to an instrument instance that represents a real hardware instrument but actually uses a real hardware instrument in its implementation (e.g. via calls to one or more parameters of that real hardware instrument). This is also useful when a parameter does belong to an instrument instance but that instance does not represent the real hardware instrument that the parameter interacts with: hence root_instrument of the parameter cannot be the hardware_instrument, however underlying_instrument can be implemented to return the hardware_instrument.

By default it returns the root_instrument of the parameter.

validate(value: Any) → None

Validate the value supplied.

Parameters

value – value to validate

Raises

• TypeError – If the value is of the wrong type.

• ValueError – If the value is outside the bounds specified by the validator.

class qcodes.instrument_drivers.stanford_research.SR86x.SR86xDataChannel(parent: qcodes.instrument_drivers.stanford_research.SR86x.SR86x, name: str, cmd_id: str, cmd_id_name: Optional[str] = None, color: Optional[str] = None)

Bases: qcodes.instrument.channel.InstrumentChannel

Implements a data channel of SR86x lock-in amplifier. Parameters that are assigned to these channels get plotted on the display of the instrument. Moreover, there are commands that allow to conveniently retrieve the values of the parameters that are currently assigned to the data channels.

This class relies on the available parameter names that should be mentioned in the lock-in amplifier class in PARAMETER_NAMES attribute.

Parameters

• parent – an instance of SR86x driver

• name – data channel name that is to be used to reference it from the parent

• cmd_id – this ID is used in VISA commands to refer to this data channel, usually is an integer number

• cmd_id_name – this name can also be used in VISA commands along with channel_id; it is not used in this implementation, but is added for reference

• color – every data channel is also referred to by the color with which it is being plotted on the instrument’s screen; added here only for reference

property cmd_id: str

property cmd_id_name: Optional[str]

property color: Optional[str]

__getitem__(key: str) → Union[Callable[[...], Any], qcodes.instrument.parameter.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. If your case is more complicated, you’re probably better off simply making a new method in your Instrument subclass definition.

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 = <class 'qcodes.instrument.parameter.Parameter'>, **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 instrument.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 parameter.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: Union[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: List[qcodes.instrument.base.InstrumentBase]

Returns a list of instruments, starting from the current instrument and following to the parent instrument and the parents parent instrument 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: 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: 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

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.

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

Name of the instrument This is equivalent to full_name for backwards compatibility.

property name_parts: List[str]

omit_delegate_attrs: List[str] = []

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

property parent: qcodes.instrument.base.InstrumentBase

Returns 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: qcodes.instrument.base.InstrumentBase

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

snapshot(update: Optional[bool] = False) → Dict[Any, 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: Optional[bool] = False, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.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, _BaseParameter] = {}

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, Union['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 instrument_modules of this instrument Usually populated via add_submodule().

Module contents