`quantify_core.measurement`#

Import alias	Maps to
`quantify_core.measurement.MeasurementControl`	`MeasurementControl`
`quantify_core.measurement.grid_setpoints`	`grid_setpoints`
`quantify_core.measurement.Gettable`	`Gettable`
`quantify_core.measurement.Settable`	`Settable`

`types`#

Module containing the core types for use with the MeasurementControl.

class Gettable(obj: Any)[source]#

Defines the Gettable concept, which is considered complete if the given type satisfies the following: This class does not wrap the passed in object but simply verifies and returns it.

attributes
properties
name	identifier
	oneOf	type	string
		type	array
		items	type	string
label	axis descriptor
	oneOf	type	string
		type	array
		items	type	string
unit	unit of measurement
	oneOf	type	string
		type	array
		items	type	string
batched	true if data is processed in batches, false otherwise
	type	boolean
batch_size	When .batched=True, indicates the (maximum) size of the batch of datapoints that this gettable supports. The measurement loop will effectively use the min(settable(s).batch_size, gettable(s).batch_size).
	type	integer

methods
properties
get	get values from this device
	type	object
prepare	called before the acquisition loop
	type	object
finish	called once after the acquisition loop
	type	object

class Settable(obj: Any)[source]#

Defines the Settable concept, which is considered complete if the given type satisfies the following: This class does not wrap the passed in object but simply verifies and returns it.

attributes
properties
name	identifier
	type	string
label	axis descriptor
	type	string
unit	unit of measurement
	type	string
batched	true if data is processed in batches, false otherwise
	type	boolean
batch_size	When .batched=True, indicates the (maximum) size of the batch of datapoints that this settable supports. The measurement loop will effectively use the min(settable(s).batch_size, gettable(s).batch_size).
	type	integer

methods
properties
set	send data to this device
	type	object
prepare	called before the acquisition loop
	type	object
finish	called once after the acquisition loop
	type	object

is_batched(obj)[source]#

Return type:: bool
Returns:: the .batched attribute of the settable/gettable obj, False if not present.

is_object_or_function(checker, instance)[source]#

Checks if an instance is an object/function

Return type:: bool
Returns:: True if the instance is an object or a function, False otherwise

`control`#

Module containing the MeasurementControl.

class MeasurementControl(name)[source]#

Instrument responsible for controlling the data acquisition loop.

MeasurementControl (MC) is based on the notion that every experiment consists of the following steps:

Set some parameter(s) (settable_pars)

Measure some other parameter(s) (gettable_pars)

Store the data.

Example

meas_ctrl.settables(mw_source1.freq)
meas_ctrl.setpoints(np.arange(5e9, 5.2e9, 100e3))
meas_ctrl.gettables(pulsar_QRM.signal)
dataset = meas_ctrl.run(name='Frequency sweep')

MC exists to enforce structure on experiments. Enforcing this structure allows:

Standardization of data storage.

Providing basic real-time visualization.

MC imposes minimal constraints and allows:

Iterative loops, experiments in which setpoints are processed step by step.
Batched loops, experiments in which setpoints are processed in batches.
Adaptive loops, setpoints are determined based on measured values.

See also

Measurement Control How-To

Parameters:: name (str) – name of this instrument.

_curr_setpoint_idx()[source]#

Current position through the sweep

Return type:: int
Returns:: int setpoint_idx

_finish()[source]#

Call finish() on all Settables and Gettables, if finish() exists

Return type:: None

_get_fracdone()[source]#

Returns the fraction of the experiment that is completed.

Return type:: float

_get_max_setpoints()[source]#

The total number of setpoints to examine

Return type:: int

_init(name)[source]#: Initializes MC, such as creating the Dataset, experiment folder and such.

_iterative_set_and_get(setpoints, idx, lazy_set=False)[source]#

Processes one row of setpoints. Sets all settables, gets all gettables, encodes new data in dataset.

If lazy_set==True and any setpoint equals the corresponding previous setpoint, that setpoint is not set in its corresponding settable.

Note

Note: some lines in this function are redundant depending on mode (sweep vs adaptive). Specifically:

in sweep, the x dimensions are already filled

in adaptive, soft_avg is always 1

_prepare_gettables()[source]#

Call prepare() on the Gettable, if prepare() exists

Return type:: None

_prepare_settables()[source]#

Call prepare() on all Settable, if prepare() exists

Return type:: None

classmethod _process_acquired_data(acquired_data, batched, real_imag)[source]#

Reshapes the data as returned from the gettable into the form accepted by the measurement control.

Parameters:

acquired_data (Dataset) – Data that is returned by gettable.
batched (bool) – Parameter to distinct iterative and batched experiment.
real_imag (bool) – If true, the gettable returns I, Q values. Otherwise, magnitude and phase
returned. ((degrees) are)

Return type:

tuple[ndarray[Any, dtype[float64]], ...]

Returns:

: A tuple of data, casted to a historical conventions on data format.

_reset(save_data=True)[source]#: Resets all experiment specific variables for a new run.

_reset_post()[source]#: Resets specific variables that can change before .run().

static _reshape_data(acq_protocol, vals, real_imag)[source]#

Convert an array of complex numbers into two arrays of real numbers.

Return type:: list[ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]]

_safe_write_dataset()[source]#: Uses a lock when writing the file to stay safe for multiprocessing. Locking files are written into a temporary dir to avoid polluting the experiment container.

_update(print_message=None)[source]#: Do any updates to/from external systems, such as saving, plotting, etc.

clear_experiment_data()[source]#: Remove all experiment_data parameters from the experiment_data submodule

get_idn()[source]#

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.

Return type:: dict[str, str | None]
Returns:: A dict containing vendor, model, serial, and firmware.

gettables(gettable_pars)[source]#

Define the parameters to be acquired during the acquisition loop.

The Gettable helper class defines the requirements for a Gettable object.

Parameters:

gettable_pars –

parameter(s) to be get during the acquisition loop, accepts:

list or tuple of multiple Gettable objects
a single Gettable object

measurement_description()[source]#

Return a serializable description of the latest measurement

Users can add additional information to the description manually.

Return type:

Dict[str, Any]

Returns:

: Dictionary with description of the measurement

print_progress(progress_message=None)[source]#

Prints the provided progress_messages or displays tqdm progress bar; and calls the callback specified by on_progress_callback.

NB: if called with no progress message (progress bar is used),: self.pbar attribute should be closed and removed.

Printing and progress bar display can be suppressed with .verbose(False).

run(name='', soft_avg=1, lazy_set=None, save_data=True)[source]#

Starts a data acquisition loop.

Parameters:

name (str (default: '')) – Name of the measurement. It is included in the name of the data files.
soft_avg (int (default: 1)) – Number of software averages to be performed by the measurement control. E.g. if soft_avg=3 the full dataset will be measured 3 times and the measured values will be averaged element-wise, the averaged dataset is then returned.
lazy_set (Optional[bool] (default: None)) –
If True and a setpoint equals the previous setpoint, the .set method of the settable will not be called for that iteration. If this argument is None, the .lazy_set() ManualParameter is used instead (which by default is False).

Warning

This feature is not available yet when running in batched mode.
save_data (bool (default: True)) – If True that the measurement data is stored.

Return type:

Dataset

run_adaptive(name, params, lazy_set=None)[source]#

Starts a data acquisition loop using an adaptive function.

Warning

The functionality of this mode can be complex - it is recommended to read the relevant long form documentation.

Parameters:

name – Name of the measurement. This name is included in the name of the data files.
params – Key value parameters describe the adaptive function to use, and any further parameters for that function.
lazy_set (Optional[bool] (default: None)) – If True and a setpoint equals the previous setpoint, the .set method of the settable will not be called for that iteration. If this argument is None, the .lazy_set() ManualParameter is used instead (which by default is False).

Return type:

Dataset

set_experiment_data(experiment_data, overwrite=True)[source]#

Populates the experiment_data submodule with experiment_data parameters

Parameters:

experiment_data (Dict[str, Any]) –

Dict specifying the names of the experiment_data parameters and their values. Follows the format:

{
    "parameter_name": {
        "value": 10.2
        "label": "parameter label"
        "unit": "Hz"
    }
}

overwrite (bool (default: True)) – If True, clear all previously saved experiment_data parameters and save new ones. If False, keep all previously saved experiment_data parameters and change their values if necessary

setpoints(setpoints)[source]#

Set setpoints that determine values to be set in acquisition loop.

Tip

Use column_stack() to reshape multiple 1D arrays when setting multiple settables.

Parameters:: setpoints (ndarray) – An array that defines the values to loop over in the experiment. The shape of the array has to be either (N,) or (N,1) for a 1D loop; or (N, M) in the case of an MD loop.

setpoints_grid(setpoints)[source]#

Makes a grid from the provided setpoints assuming each array element corresponds to an orthogonal dimension. The resulting gridded points determine values to be set in the acquisition loop.

The gridding is such that the inner most loop corresponds to the batched settable with the smallest .batch_size.

quantify_core.measurement#

types#

control#

`quantify_core.measurement`#

`types`#

`control`#