Download

Download this file as Jupyter notebook: SMU_examples.ipynb.

SMU examples#

Initialization and Definitions:#

[2]:

import keysight.qcs as qcs
from keysight.qcs.channels.supported_instruments import InstrumentEnum

# Channel definitions
control_channels = qcs.Channels(0, "xy_pulse")
readout_channels = qcs.Channels(0, "readout_pulse", absolute_phase=True)
digitizer_channels = qcs.Channels(0, "readout_acquisition", absolute_phase=True)
ancilla_channels = qcs.Channels(1, "readout_acquisition", absolute_phase=True)
smu_channel = qcs.Channels(0, "smu_channel", True)

awg_1x6x1 = qcs.Address(chassis=1, slot=6, channel=1)
awg_1x6x2 = qcs.Address(chassis=1, slot=6, channel=2)
awg_1x6x3 = qcs.Address(chassis=1, slot=6, channel=3)
awgs = [awg_1x6x1, awg_1x6x2]

dig_1x18x1 = qcs.Address(1, 18, 1)
dig_1x18x2 = qcs.Address(1, 18, 2)
dig_1x18x3 = qcs.Address(1, 18, 3)
digs = [dig_1x18x1, dig_1x18x2]

dc_1x17x1 = qcs.Address(1, 17, 1)
dc_1x17x2 = qcs.Address(1, 17, 2)
dc_1x17x3 = qcs.Address(1, 17, 3)
dcs = [dc_1x17x1, dc_1x17x2]

smu_1x12x1 = qcs.Address(1, 12, 1)
smus = [smu_1x12x1]

# Channel Mapper creation
mapper = qcs.ChannelMapper(
    "127.0.0.1"
)  # Update with target system ip here if running on different target

# specify the mapping between virtual and physical channels
mapper.add_channel_mapping(control_channels, awgs[0], InstrumentEnum.M5300AWG)
mapper.add_channel_mapping(readout_channels, awgs[1], InstrumentEnum.M5300AWG)
mapper.add_channel_mapping(ancilla_channels, digs[0], InstrumentEnum.M5200Digitizer)
mapper.add_channel_mapping(digitizer_channels, digs[1], InstrumentEnum.M5200Digitizer)
mapper.add_channel_mapping(smu_channel, smus[0], InstrumentEnum.M960XSMU)

mapper.add_downconverters(digs, dcs)

# set the LO frequency of the AWG and downconverter channels
mapper.set_lo_frequencies(awgs + dcs, 5e9)
mapper.set_delays(digs, 0)

# set the following to True when connected to hardware
run_on_hw = False

Set Current to 0A:#

[3]:

if run_on_hw:
    backend = qcs.HclBackend(channel_mapper=mapper)
    address = qcs.Address(chassis=1, slot=12, channel=1)

    backend.set_smu_current(address, constant_current=0)

    current_value = backend.get_smu_current(address)
    print(current_value)
else:
    # Set run_on_hw = True for running on hardware
    pass

Setting of Current on a single SMU port without ramping rate:#

[4]:

if run_on_hw:
    backend = qcs.HclBackend(channel_mapper=mapper)
    address = qcs.Address(chassis=1, slot=12, channel=1)

    backend.set_smu_current(address, constant_current=0)

    # Turn on below line only if external device is connected
    # backend.set_smu_current(address, constant_current=1e-6)

    current_value = backend.get_smu_current(address)
    print(current_value)
else:
    # Set run_on_hw = True for running on hardware
    pass

Setting of Current on a single SMU port with ramping rate:#

[5]:

if run_on_hw:
    backend = qcs.HclBackend(channel_mapper=mapper)
    address = qcs.Address(chassis=1, slot=12, channel=1)

    backend.set_smu_current(address, constant_current=0, ramping_rate=2e-6)

    # Turn on below line only if external device is connected
    # backend.set_smu_current(address, constant_current=1.5e-6, ramping_rate=2e-6)

    current_value = backend.get_smu_current(address)
    print(current_value)
else:
    # Set run_on_hw = True for running on hardware
    pass

Setting of Current on multiple SMU ports without ramping rate:#

[6]:

if run_on_hw:
    backend = qcs.HclBackend(channel_mapper=mapper)
    address_1 = qcs.Address(chassis=1, slot=12, channel=1)
    address_2 = qcs.Address(chassis=1, slot=12, channel=2)
    addresses = [address_1, address_2]

    backend.set_smu_current(addresses, constant_current=[0, 0])

    # Turn on below line only if external device is connected
    # backend.set_smu_current(addresses, constant_current=[1.1e-9, 1.2e-9])

    current_value = backend.get_smu_current(addresses)
    print(current_value)
else:
    # Set run_on_hw = True for running on hardware
    pass

Setting of Current on multiple SMU ports with ramping rate:#

[7]:

if run_on_hw:
    backend = qcs.HclBackend(channel_mapper=mapper)
    address_1 = qcs.Address(chassis=1, slot=12, channel=1)
    address_2 = qcs.Address(chassis=1, slot=12, channel=2)
    addresses = [address_1, address_2]

    backend.set_smu_current(
        addresses, constant_current=[0, 0], ramping_rate=[2e-6, 3e-6]
    )

    # Turn on below line only if external device is connected
    # backend.set_smu_current(addresses, constant_current=[1e-10, 1.5e-10],
    # ramping_rate=[2e-6, 3e-6])

    current_value = backend.get_smu_current(addresses)
    print(current_value)
else:
    # Set run_on_hw = True for running on hardware
    pass

Getting of Current on a single SMU port:#

[8]:

if run_on_hw:
    backend = qcs.HclBackend(channel_mapper=mapper)
    address = qcs.Address(chassis=1, slot=12, channel=1)
    current_value = backend.get_smu_current(address)
    print(current_value)
else:
    # Set run_on_hw = True for running on hardware
    pass

Setting of Voltage on a single SMU port without ramping rate:#

[9]:

if run_on_hw:
    backend = qcs.HclBackend(channel_mapper=mapper)
    address = qcs.Address(chassis=1, slot=12, channel=1)

    backend.set_smu_voltage(address, constant_voltage=0)

    backend.set_smu_voltage(address, constant_voltage=1.11)

    voltage_value = backend.get_smu_voltage(address)
    print(voltage_value)
else:
    # Set run_on_hw = True for running on hardware
    pass

Setting of Voltage on a single SMU port with ramping rate:#

[10]:

if run_on_hw:
    # Define Backend and SMU Port address
    backend = qcs.HclBackend(channel_mapper=mapper)
    address = qcs.Address(chassis=1, slot=12, channel=1)
    # Set Voltage to 0V (Optional)
    backend.set_smu_voltage(address, constant_voltage=0)
    # Set User Defined Voltage to SMU Port
    backend.set_smu_voltage(address, constant_voltage=2.0, ramping_rate=2.0)
    # Read Voltage from SMU Port
    voltage_value = backend.get_smu_voltage(address)
    print(voltage_value)
else:
    # Set run_on_hw = True for running on hardware
    pass

Setting of Voltage on multiple SMU ports without ramping rate:#

[11]:

# Define Backend and SMU Port addresses
if run_on_hw:
    backend = qcs.HclBackend(channel_mapper=mapper)
    address_1 = qcs.Address(chassis=1, slot=12, channel=1)
    address_2 = qcs.Address(chassis=1, slot=12, channel=2)
    addresses = [address_1, address_2]
    # Set voltage to 0V (Optional)
    backend.set_smu_voltage(address_1, constant_voltage=0)
    backend.set_smu_voltage(address_2, constant_voltage=0)

    # Set User Defined Voltages to SMU Ports
    backend.set_smu_voltage(addresses, constant_voltage=[1.1, 1.2])
    # Read Voltage from SMU Ports
    voltage_value = backend.get_smu_voltage(addresses)
    print(voltage_value)
else:
    # Set run_on_hw = True for running on hardware
    pass

Setting of Voltage on multiple SMU ports with ramping rate:#

[12]:

if run_on_hw:
    backend = qcs.HclBackend(channel_mapper=mapper)
    address_1 = qcs.Address(chassis=1, slot=12, channel=1)
    address_2 = qcs.Address(chassis=1, slot=12, channel=2)

    backend.set_smu_voltage(address_1, constant_voltage=0)
    backend.set_smu_voltage(address_2, constant_voltage=0)

    addresses = [address_1, address_2]
    backend.set_smu_voltage(
        addresses, constant_voltage=[2.77, 3.77], ramping_rate=[10, 5]
    )
    voltage_value = backend.get_smu_voltage(addresses)
    print(voltage_value)
else:
    # Set run_on_hw = True for running on hardware
    pass

Getting of Voltage on a single SMU port:#

[13]:

if run_on_hw:
    backend = qcs.HclBackend(channel_mapper=mapper)
    address = qcs.Address(chassis=1, slot=12, channel=1)
    voltage_value = backend.get_smu_voltage(address)
    print(voltage_value)
else:
    # Set run_on_hw = True for running on hardware
    pass

Pre-Program Operation for Current:#

[14]:

program = qcs.Program()
gauss = qcs.RFWaveform(
    duration=80e-9,
    envelope=qcs.GaussianEnvelope(num_sigma=4),
    amplitude=1,
    rf_frequency=5.1e9,
)
program.add_waveform(gauss, control_channels)

target_pre_current = qcs.Scalar("target_pre_current", value=1e-7, dtype=float)
ramp_rate = qcs.Scalar("ramp_rate", value=1e-6, dtype=float)
set_pre_current = qcs.SetCurrent(smu_channel, target_pre_current, ramp_rate)

program.add_pre_program_operation(set_pre_current)
program.n_shots(1000)

program.draw()
Program
Pre-program operations
SetCurrent None constant_current -Scalar(name=target_pre_current, value=0, dtype=float, unit=none) ramping_rate - Scalar(name=ramp_rate, value=0, dtype=float, unit=none)
Sweep Details:
Repetitions Repeat with 1000 repetitions
(HW)Repeat(1000)
keysight-logo-svg
Program Body
Program
Duration 80 ns
Layers 1
Targets 1
Layer #0
Layer #0
Duration 80 ns
xy_pulse 0
RFWaveform on ('xy_pulse', 0)

Parameters
Duration Scalar(name=_implicit, value=80 ns, dtype=float, unit=s)
Amplitude 1
Frequency 5.1 GHz
Envelope GaussianEnvelope(4.0)
Instantaneous Phase 0 rad
Post-phase 0 rad

Post-Program Operation for Current:#

[15]:

program = qcs.Program()
gauss = qcs.RFWaveform(
    duration=80e-9,
    envelope=qcs.GaussianEnvelope(num_sigma=4),
    amplitude=1,
    rf_frequency=5.1e9,
)
program.add_waveform(gauss, control_channels)

target_post_current = qcs.Scalar("target_post_current", value=-1e-7, dtype=float)
ramp_rate = qcs.Scalar("ramp_rate", value=1e-6, dtype=float)
set_post_current = qcs.SetCurrent(smu_channel, target_post_current, ramp_rate)

program.n_shots(1000)
program.add_post_program_operation(set_post_current)

program.draw()
Program
Sweep Details:
Repetitions Repeat with 1000 repetitions
(HW)Repeat(1000)
keysight-logo-svg
Program Body
Program
Duration 80 ns
Layers 1
Targets 1
Layer #0
Layer #0
Duration 80 ns
xy_pulse 0
RFWaveform on ('xy_pulse', 0)

Parameters
Duration Scalar(name=_implicit, value=80 ns, dtype=float, unit=s)
Amplitude 1
Frequency 5.1 GHz
Envelope GaussianEnvelope(4.0)
Instantaneous Phase 0 rad
Post-phase 0 rad
Post-program operations
SetCurrent None constant_current -Scalar(name=target_post_current, value=-0, dtype=float, unit=none) ramping_rate - Scalar(name=ramp_rate, value=0, dtype=float, unit=none)

Sweep Operation for Current:#

[16]:

program = qcs.Program()
gauss = qcs.RFWaveform(
    duration=80e-9,
    envelope=qcs.GaussianEnvelope(num_sigma=4),
    amplitude=1,
    rf_frequency=5.1e9,
)
program.add_waveform(gauss, control_channels)

target_current = qcs.Scalar("target_current", dtype=float)
current_sweep = qcs.Array("current_sweep", value=[0.8e-7, 0.5e-7, 0.2e-7], dtype=float)
ramp_rate = qcs.Scalar("ramp_rate", value=1e-6, dtype=float)
set_current = qcs.SetCurrent(smu_channel, target_current, ramp_rate)

program.n_shots(1000)
program.sweep(current_sweep, target_current, pre_iterate_operation_list=[set_current])

program.draw()
Program
Sweep Details:
Repetitions Sweep with 3 repetitions
Associations
target_current Array(name=current_sweep, shape=(3,), dtype=float, unit=none, value=[0, 0, 0])
Pre-iterate operation
SetCurrent None constant_current -Scalar(name=target_current, value=None, dtype=float, unit=none) ramping_rate - Scalar(name=ramp_rate, value=0, dtype=float, unit=none)
(SW)Sweep_target_current
Sweep Details:
Repetitions Repeat with 1000 repetitions
(HW)Repeat(1000)
keysight-logo-svg
Program Body
Program
Duration 80 ns
Layers 1
Targets 1
Layer #0
Layer #0
Duration 80 ns
xy_pulse 0
RFWaveform on ('xy_pulse', 0)

Parameters
Duration Scalar(name=_implicit, value=80 ns, dtype=float, unit=s)
Amplitude 1
Frequency 5.1 GHz
Envelope GaussianEnvelope(4.0)
Instantaneous Phase 0 rad
Post-phase 0 rad

Pre-Program Operation for Voltage:#

[17]:

program = qcs.Program()
gauss = qcs.RFWaveform(
    duration=80e-9,
    envelope=qcs.GaussianEnvelope(num_sigma=4),
    amplitude=1,
    rf_frequency=5.1e9,
)
program.add_waveform(gauss, control_channels)

target_pre_voltage = qcs.Scalar("target_pre_voltage", value=1.8, dtype=float)
ramp_rate = qcs.Scalar("ramp_rate", value=2.0, dtype=float)

set_pre_voltage = qcs.SetVoltage(smu_channel, target_pre_voltage, ramp_rate)

program.add_pre_program_operation(set_pre_voltage)
program.n_shots(1000)

program.draw()
Program
Pre-program operations
SetVoltage None constant_voltage -Scalar(name=target_pre_voltage, value=1.8, dtype=float, unit=none) ramping_rate - Scalar(name=ramp_rate, value=2, dtype=float, unit=none)
Sweep Details:
Repetitions Repeat with 1000 repetitions
(HW)Repeat(1000)
keysight-logo-svg
Program Body
Program
Duration 80 ns
Layers 1
Targets 1
Layer #0
Layer #0
Duration 80 ns
xy_pulse 0
RFWaveform on ('xy_pulse', 0)

Parameters
Duration Scalar(name=_implicit, value=80 ns, dtype=float, unit=s)
Amplitude 1
Frequency 5.1 GHz
Envelope GaussianEnvelope(4.0)
Instantaneous Phase 0 rad
Post-phase 0 rad

Post-Program Operation for Voltage:#

[18]:

program = qcs.Program()
gauss = qcs.RFWaveform(
    duration=80e-9,
    envelope=qcs.GaussianEnvelope(num_sigma=4),
    amplitude=1,
    rf_frequency=5.1e9,
)
program.add_waveform(gauss, control_channels)

target_post_voltage = qcs.Scalar("target_post_voltage", value=-3.66, dtype=float)
ramp_rate = qcs.Scalar("ramp_rate", value=5.0, dtype=float)

set_post_voltage = qcs.SetVoltage(smu_channel, target_post_voltage, ramp_rate)

program.n_shots(1000)
program.add_post_program_operation(set_post_voltage)

program.draw()
Program
Sweep Details:
Repetitions Repeat with 1000 repetitions
(HW)Repeat(1000)
keysight-logo-svg
Program Body
Program
Duration 80 ns
Layers 1
Targets 1
Layer #0
Layer #0
Duration 80 ns
xy_pulse 0
RFWaveform on ('xy_pulse', 0)

Parameters
Duration Scalar(name=_implicit, value=80 ns, dtype=float, unit=s)
Amplitude 1
Frequency 5.1 GHz
Envelope GaussianEnvelope(4.0)
Instantaneous Phase 0 rad
Post-phase 0 rad
Post-program operations
SetVoltage None constant_voltage -Scalar(name=target_post_voltage, value=-3.66, dtype=float, unit=none) ramping_rate - Scalar(name=ramp_rate, value=5, dtype=float, unit=none)

Sweep Operation for Voltage:#

[19]:

program = qcs.Program()
gauss = qcs.RFWaveform(
    duration=80e-9,
    envelope=qcs.GaussianEnvelope(num_sigma=4),
    amplitude=1,
    rf_frequency=5.1e9,
)
program.add_waveform(gauss, control_channels)

target_voltage = qcs.Scalar("target_voltage", dtype=float)
voltage_sweep = qcs.Array(
    "voltage_sweep", value=[0.88, 0.77, 0.66, 0.55, 0.44], dtype=float
)
ramp_rate = qcs.Scalar("ramp_rate", value=1.0, dtype=float)

set_voltage = qcs.SetVoltage(smu_channel, target_voltage, ramp_rate)

program.n_shots(1000)
program.sweep(voltage_sweep, target_voltage, pre_iterate_operation_list=[set_voltage])

program.draw()
Program
Sweep Details:
Repetitions Sweep with 5 repetitions
Associations
target_voltage Array(name=voltage_sweep, shape=(5,), dtype=float, unit=none, value=[0.88, 0.77, 0.66, 0.55, 0.44])
Pre-iterate operation
SetVoltage None constant_voltage -Scalar(name=target_voltage, value=None, dtype=float, unit=none) ramping_rate - Scalar(name=ramp_rate, value=1, dtype=float, unit=none)
(SW)Sweep_target_voltage
Sweep Details:
Repetitions Repeat with 1000 repetitions
(HW)Repeat(1000)
keysight-logo-svg
Program Body
Program
Duration 80 ns
Layers 1
Targets 1
Layer #0
Layer #0
Duration 80 ns
xy_pulse 0
RFWaveform on ('xy_pulse', 0)

Parameters
Duration Scalar(name=_implicit, value=80 ns, dtype=float, unit=s)
Amplitude 1
Frequency 5.1 GHz
Envelope GaussianEnvelope(4.0)
Instantaneous Phase 0 rad
Post-phase 0 rad

Download

Download this file as Jupyter notebook: SMU_examples.ipynb.