This page was generated from docs/examples/driver_examples/QCoDeS example with DelegateInstrument.ipynb. Interactive online version: .

Qcodes example with DelegateInstrument driver

This notebooks explains how to use the DelegateInstrument driver.

About

The goal of the DelegateInstrument driver is to make it easier to combine different parameters together into a new “virtual” instrument. Each parameter on a DelegateInstrument can point to one or more parameters on other instruments in the station.

Usage

The way it’s used is mainly by specifying an entry in the station YAML. For instance, let’s say you want to use a magnetic field coil. The driver has a method set_field(value, block), that by default is set to block=True, which means the field is ramped in a way that blocks further execution until the desired value is reached. However, let’s say you are creating a measurement in which you want the parameter to be set, and while the value is ramping, you want to measure other parameters. This can be done by using DelegateInstrument and specifying a custom setter for the parameter that gets and sets the magnetic field.

By default, each parameter is represented by a DelegateParameter. The DelegateInstrument also supports passing multiple source parameters to a given parameter. In order to do this, simply specify multiple parameters in the dictionary values under the parameters key.

It can also add instrument channels, specified under a separate key channels, shown in the second half of the notebook.

%%writefile example.yaml

instruments:
  field_X:
    type: qcodes.instrument_drivers.mock_instruments.MockField

  field:
    type: qcodes.instrument.delegate.DelegateInstrument
    init:
      parameters:
        X:
          - field_X.field
        ramp_rate:
          - field_X.ramp_rate
        combined:
          - field_X.field
          - field_X.ramp_rate
      set_initial_values_on_load: true
      initial_values:
        ramp_rate: 1.0
      setters:
        X:
          method: field_X.set_field
          block: false

Writing example.yaml

import qcodes as qc
from qcodes.dataset import (
    Measurement,
    initialise_or_create_database_at,
    load_or_create_experiment,
)

Logging hadn't been started.
Activating auto-logging. Current session state plus future input saved.
Filename       : /home/runner/.qcodes/logs/command_history.log
Mode           : append
Output logging : True
Raw input log  : False
Timestamping   : True
State          : active
Qcodes Logfile : /home/runner/.qcodes/logs/241118-9133-qcodes.log

station = qc.Station(config_file="example.yaml")

field_X = station.load_field_X()
field = station.load_field(station=station)

field.X()

0.0

field.X(1.0)

field.X()

6.685654322306316e-05

field.X()

0.0001501917839050293

field.X()

0.00023767550786336263

field.X()

0.00032152732213338214

As you can see, the field is now ramped in the background with the specified ramp rate. Now, let’s try to create a measurement that uses this ability, and ramps the field in the background while measuring:

field.ramp_rate(10.0)
field_X.field(0.0)

field.X()

0.0

import time

initialise_or_create_database_at("delegate_instrument_example.db")
load_or_create_experiment("delegate_instrument_experiment")

meas = Measurement(station=station)
meas.register_parameter(field.X)

with meas.run() as datasaver:
    for B in [0.1, 0.0]:
        field.X(B)
        while field.X() != B:
            datasaver.add_result((field.X, field.X()))
            time.sleep(0.01)
    datasaver.flush_data_to_database()

Starting experimental run with id: 1.

datasaver.dataset.to_pandas_dataframe().plot()

<Axes: >

When specifying multiple source parameters on a given parameter, the grouped parameter will automatically return a namedtuple that returns both values.

field.combined()

combined(field=0.0, ramp_rate=10.0)

We can now also create a custom parameter that does a simple calculation based on the current parameters.

import numpy as np


def calculate_ramp_time(X, ramp_rate):
    """Calculate ramp time in seconds"""
    dfield = np.abs(field.target_field - X)
    return 60.0 * dfield / ramp_rate

field._create_and_add_parameter(
    group_name="ramp_time",
    station=station,
    paths=["field_X.field", "field_X.ramp_rate"],
    formatter=calculate_ramp_time,
)

field.ramp_rate(1.0)
field.target_field = 0.1
field.ramp_time()

np.float64(6.0)

field.X(0.1)

field.ramp_time()

np.float64(5.9959728717803955)

import time

time.sleep(1.0)
field.ramp_time()

np.float64(4.9905736446380615)

import time

time.sleep(1.0)
field.ramp_time()

np.float64(3.9847424030303955)

Devices with channels

The YAML file below specifies the instruments with the channels/parameters we wish to group into a new instrument, here called “device”. The first example simply adds the channel ‘as is’ using self.add_submodule, while the readout parameter is added as a DelegateParameter.

%%writefile example.yaml

instruments:
  lockin:
    type: qcodes.instrument_drivers.mock_instruments.MockLockin

  dac:
    type: qcodes.instrument_drivers.mock_instruments.MockDAC

  device:
    type: qcodes.instrument.delegate.DelegateInstrument
    init:
      parameters:
        readout: lockin.X
      channels:
        gate_1: dac.ch01
      set_initial_values_on_load: true
      initial_values:
        readout: 1e-5
        gate_1.voltage.post_delay: 0.01

Overwriting example.yaml

station = qc.Station(config_file="example.yaml")

lockin = station.load_lockin()
dac = station.load_dac()
device = station.load_device(station=station)

print(device.gate_1)
print(device.gate_1.voltage.post_delay)

<MockDACChannel: dac_ch01 of MockDAC: dac>
0.01

print(device.gate_1.voltage())
device.gate_1.voltage(-0.6)
device.gate_1.voltage()

0.0

-0.6

The second example adds a channel using a custom channel class, which takes the initial channel and its name as input and has a parameter current_valid_ranges.

%%writefile example.yaml

instruments:
  lockin:
    type: qcodes.instrument_drivers.mock_instruments.MockLockin

  dac:
    type: qcodes.instrument_drivers.mock_instruments.MockDAC

  device:
    type: qcodes.instrument.delegate.DelegateInstrument
    init:
      parameters:
        readout: lockin.X
      channels:
        type: qcodes.instrument_drivers.mock_instruments.MockCustomChannel
        gate_1:
          channel: dac.ch01
          current_valid_range: [-0.5, 0]
      set_initial_values_on_load: true
      initial_values:
        readout: 1e-5

Overwriting example.yaml

lockin.close()
dac.close()

station = qc.Station(config_file="example.yaml")
lockin = station.load_lockin()
dac = station.load_dac()

device = station.load_device(station=station)

device.gate_1

<MockCustomChannel: dac_gate_1 of MockDAC: dac>

device.gate_1.voltage(-0.3)

device.gate_1.voltage()

-0.3

The MockCustomChannel has a parameter current_valid_range.

device.gate_1.current_valid_range()

[-0.5, 0]