mesoscopy.measurement.parameters

Classes

`CountParameter`(name[, label])	parameter to keep track of how many sweep we make
`Counter`(args, *kwargs)	an instrument to use as counter
`DensityParameter`(name, gates, capacitances)	density parameter for maps at constant density
`DisplacementParameter`(name, gates, capacitances)	displacement parameter for maps at constant density
`LinearParameter`(name, primary_param, ...)	a parameter two fix a linear relation between two parameters as:
`TimestampParameter`(name[, label])	parameter to keep track of time, gives a timestamp

class mesoscopy.measurement.parameters.CountParameter(name: str, label: str = 'counter', **kwargs)

Bases: Parameter

parameter to keep track of how many sweep we make

get_raw(): 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.

reset_count() → None

property abstract: bool | None

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: float | Sized, step: float | None = None) → Sequence[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.

Args:: 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

Args:: value: Value to be added to the parameter.

property instrument: InstrumentBase | None: 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.

Args:: 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) → _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: InstrumentBase | None: 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) → _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: bool | None = 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().

Args:: update: Passed to snapshot_base.
Returns:: Base snapshot.

snapshot_base(update: bool | None = True, params_to_skip_update: Sequence[str] | None = None) → Dict[Any, Any]

State of the 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.

Args:

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: float | None

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: float | None = None, num: int | None = None) → 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.

Args:

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:

SweepFixedValues: Collection of parameter values to be iterated over.

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: InstrumentBase | None

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.

Args:: 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 mesoscopy.measurement.parameters.Counter(*args: Any, **kwargs: Any)

Bases: Instrument

an instrument to use as counter

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.

Args:

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: ~typing.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.

Args:

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

Args:

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[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.

Args:

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.

Args:: cmd: The string to send to the instrument.

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

Shortcut for calling a function from its name.

Args:: func_name: The name of a function of this instrument. *args: any arguments to the function.
Returns:: The return value of the function.

close() → None

Irreversibly stop this instrument and free its resources.

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

classmethod close_all() → None

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

Examples:

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

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

Print a standard message on initial connection to an instrument.

Args:

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: type | None = None) → bool

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

Args:: name: Name of the instrument. instrument_class: The type of instrument you are looking for.

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

Find an existing instrument by name.

Args:

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.

Args:: param_name: The name of a parameter of this instrument.
Returns:: The current value of the parameter.

get_idn() → Dict[str, str | None]

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

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

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

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

classmethod instances() → List[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: 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.

Args:: instr_instance: Instance of an Instrument class or its subclass.

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

Load metadata into this classes metadata dictionary.

Args:: 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: InstrumentBase | None: 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.

Args:

update: If True, update the state by querying the: instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.
max_chars: the maximum number of characters per line. The: readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

classmethod record_instance(instance: Instrument) → None

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

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

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

Args:: instance: Instance to record.
Raises:: KeyError: If another instance with the same name is already present.

classmethod remove_instance(instance: Instrument) → None

Remove a particular instance from the record.

Args:: instance: The instance to remove

property root_instrument: InstrumentBase

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

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

Args:: 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: bool | None = 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().

Args:: update: Passed to snapshot_base.
Returns:: Base snapshot.

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

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

Args:

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:

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

Arguments:

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.

Args:

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.

Args:: 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, '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 mesoscopy.measurement.parameters.TimestampParameter(name: str, label: str = 'timestamp', **kwargs)

Bases: Parameter

parameter to keep track of time, gives a timestamp

get_raw() → float: 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.

property abstract: bool | None

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: float | Sized, step: float | None = None) → Sequence[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.

Args:: 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

Args:: value: Value to be added to the parameter.

property instrument: InstrumentBase | None: 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.

Args:: 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) → _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: InstrumentBase | None: 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) → _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: bool | None = 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().

Args:: update: Passed to snapshot_base.
Returns:: Base snapshot.

snapshot_base(update: bool | None = True, params_to_skip_update: Sequence[str] | None = None) → Dict[Any, Any]

State of the 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.

Args:

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: float | None

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: float | None = None, num: int | None = None) → 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.

Args:

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:

SweepFixedValues: Collection of parameter values to be iterated over.

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: InstrumentBase | None

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.

Args:: 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 mesoscopy.measurement.parameters.DensityParameter(name: str, gates: Tuple[_BaseParameter, _BaseParameter], capacitances: Tuple[float, float], lockD: bool = False, displacement: float = 0, *args, **kwargs)

Bases: Parameter

density parameter for maps at constant density

Args:

gates: tuple[Parameter, Parameter]. the parameter to sweep for top: gate and back gate, respectively.
capacitances: tuple[float, float]. capacitance for top gate and: back gate, respectively, in F/m
lock_D: bool. If true, when we sweep the parameter, it will be done: at the displacement when parameter is initialised. If false, it will follow the density of previous measurement, with possible drifts.

property D

get_raw(): 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.

set_raw(value): 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.

property abstract: bool | None

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: float | Sized, step: float | None = None) → Sequence[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.

Args:: 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

Args:: value: Value to be added to the parameter.

property instrument: InstrumentBase | None: 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.

Args:: 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) → _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: InstrumentBase | None: 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) → _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: bool | None = 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().

Args:: update: Passed to snapshot_base.
Returns:: Base snapshot.

snapshot_base(update: bool | None = True, params_to_skip_update: Sequence[str] | None = None) → Dict[Any, Any]

State of the 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.

Args:

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: float | None

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: float | None = None, num: int | None = None) → 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.

Args:

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:

SweepFixedValues: Collection of parameter values to be iterated over.

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: InstrumentBase | None

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.

Args:: 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 mesoscopy.measurement.parameters.DisplacementParameter(name: str, gates: Tuple[_BaseParameter, _BaseParameter], capacitances: Tuple[float, float], lockn: bool = False, density: float = 0, *args, **kwargs)

Bases: Parameter

displacement parameter for maps at constant density

Args:

gates: tuple[Parameter, Parameter]. the parameter to sweep for top: gate and back gate, respectively.
capacitances: tuple[float, float]. capacitance for top gate and: back gate, respectively, in F/m
lock_n: bool. If true, when we sweep the parameter, it will be done: at the density when parameter is initialised. If false, it will follow the density of previous measurement, with possible drifts

property n

get_raw(): 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.

set_raw(value): 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.

property abstract: bool | None

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: float | Sized, step: float | None = None) → Sequence[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.

Args:: 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

Args:: value: Value to be added to the parameter.

property instrument: InstrumentBase | None: 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.

Args:: 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) → _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: InstrumentBase | None: 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) → _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: bool | None = 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().

Args:: update: Passed to snapshot_base.
Returns:: Base snapshot.

snapshot_base(update: bool | None = True, params_to_skip_update: Sequence[str] | None = None) → Dict[Any, Any]

State of the 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.

Args:

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: float | None

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: float | None = None, num: int | None = None) → 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.

Args:

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:

SweepFixedValues: Collection of parameter values to be iterated over.

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: InstrumentBase | None

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.

Args:: 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 mesoscopy.measurement.parameters.LinearParameter(name: str, primary_param: _BaseParameter, dependent_param: _BaseParameter, m: float, p: float, *args, **kwargs)

Bases: Parameter

a parameter two fix a linear relation between two parameters as:

dependent_param = m * primary_param + p

Args:

primary_param: Parameter to sweep dependent_param: Parameter that will be swept as a function of

primary_param

m: float, coefficient for the linear relation p: float, intercept in the linear relation

get_raw(): 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.

set_raw(value): 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.

property abstract: bool | None

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: float | Sized, step: float | None = None) → Sequence[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.

Args:: 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

Args:: value: Value to be added to the parameter.

property instrument: InstrumentBase | None: 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.

Args:: 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) → _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: InstrumentBase | None: 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) → _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: bool | None = 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().

Args:: update: Passed to snapshot_base.
Returns:: Base snapshot.

snapshot_base(update: bool | None = True, params_to_skip_update: Sequence[str] | None = None) → Dict[Any, Any]

State of the 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.

Args:

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: float | None

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: float | None = None, num: int | None = None) → 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.

Args:

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:

SweepFixedValues: Collection of parameter values to be iterated over.

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: InstrumentBase | None

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.

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