Source code for quantify_scheduler.schedules.trace_schedules

# Repository: https://gitlab.com/quantify-os/quantify-scheduler
# Licensed according to the LICENCE file on the main branch
"""Contains various examples of trace schedules."""

import numpy as np

from quantify_scheduler.operations.control_flow_library import Loop
from quantify_scheduler.device_under_test.device_element import DeviceElement
from quantify_scheduler.enums import BinMode
from quantify_scheduler.schedules.schedule import Schedule
from quantify_scheduler.operations.acquisition_library import (
    SSBIntegrationComplex,
    Trace,
)

from quantify_scheduler.operations.gate_library import Measure
from quantify_scheduler.operations.pulse_library import (
    IdlePulse,
    SquarePulse,
    VoltageOffset,
)
from quantify_scheduler.resources import ClockResource


[docs] def trace_schedule( pulse_amp: float, pulse_duration: float, pulse_delay: float, frequency: float, acquisition_delay: float, integration_time: float, port: str, clock: str, init_duration: int = 200e-6, repetitions: int = 1, ) -> Schedule: """ Generate a schedule to perform raw trace acquisition. Parameters ---------- pulse_amp : The amplitude of the pulse in Volt. pulse_duration The duration of the pulse in seconds. pulse_delay The pulse delay in seconds. frequency The frequency of the pulse and of the data acquisition in Hertz. acquisition_delay The start of the data acquisition with respect to the start of the pulse in seconds. integration_time The time in seconds to integrate. port The location on the device where the pulse should be applied. clock The reference clock used to track the pulse frequency. init_duration The relaxation time or dead time. repetitions The amount of times the Schedule will be repeated. Returns ------- : The Raw Trace acquisition Schedule. """ schedule = Schedule("Raw trace acquisition", repetitions) schedule.add_resource(ClockResource(name=clock, freq=frequency)) schedule.add(IdlePulse(duration=init_duration), label="Dead time") pulse = schedule.add( SquarePulse( duration=pulse_duration, amp=pulse_amp, port=port, clock=clock, ), label="trace_pulse", rel_time=pulse_delay, ) schedule.add( Trace( duration=integration_time, port=port, clock=clock, acq_index=0, acq_channel=0, ), ref_op=pulse, ref_pt="start", rel_time=acquisition_delay, label="acquisition", ) return schedule
[docs] def trace_schedule_circuit_layer( qubit_name: str, repetitions: int = 1, ) -> Schedule: """ Generate a simple schedule at circuit layer to perform raw trace acquisition. Parameters ---------- qubit_name Name of a device element. repetitions The amount of times the Schedule will be repeated. Returns ------- : The Raw Trace acquisition Schedule. """ schedule = Schedule("Raw trace acquisition", repetitions) schedule.add(Measure(qubit_name, acq_protocol="Trace")) return schedule
[docs] def two_tone_trace_schedule( qubit_pulse_amp: float, qubit_pulse_duration: float, qubit_pulse_frequency: float, qubit_pulse_port: str, qubit_pulse_clock: str, ro_pulse_amp: float, ro_pulse_duration: float, ro_pulse_delay: float, ro_pulse_port: str, ro_pulse_clock: str, ro_pulse_frequency: float, ro_acquisition_delay: float, ro_integration_time: float, init_duration: float = 200e-6, repetitions: int = 1, ) -> Schedule: """ Generate a schedule for performing a two-tone raw trace acquisition. Parameters ---------- qubit_pulse_amp The amplitude of the pulse in Volt. qubit_pulse_duration The duration of the pulse in seconds. qubit_pulse_frequency The pulse frequency in Hertz. qubit_pulse_port The location on the device where the qubit pulse should be applied. qubit_pulse_clock The reference clock used to track the pulse frequency. ro_pulse_amp The amplitude of the readout pulse in Volt. ro_pulse_duration The duration of the readout pulse in seconds. ro_pulse_delay The time between the end of the pulse and the start of the readout pulse. ro_pulse_port The location on the device where the readout pulse should be applied. ro_pulse_clock The reference clock used to track the readout pulse frequency. ro_pulse_frequency The readout pulse frequency in Hertz. ro_acquisition_delay The start of the data acquisition with respect to the start of the pulse in seconds. ro_integration_time The integration time of the data acquisition in seconds. init_duration : The relaxation time or dead time. repetitions The amount of times the Schedule will be repeated. Returns ------- : The Two-tone Trace acquisition Schedule. """ schedule = Schedule("Two-tone Trace acquisition", repetitions) schedule.add_resource( ClockResource(name=qubit_pulse_clock, freq=qubit_pulse_frequency) ) schedule.add_resource(ClockResource(name=ro_pulse_clock, freq=ro_pulse_frequency)) schedule.add( IdlePulse(duration=init_duration), label="Reset", ) schedule.add( SquarePulse( duration=qubit_pulse_duration, amp=qubit_pulse_amp, port=qubit_pulse_port, clock=qubit_pulse_clock, ), label="qubit_pulse", ) ro_pulse = schedule.add( SquarePulse( duration=ro_pulse_duration, amp=ro_pulse_amp, port=ro_pulse_port, clock=ro_pulse_clock, ), label="readout_pulse", rel_time=ro_pulse_delay, ) schedule.add( Trace( duration=ro_integration_time, port=ro_pulse_port, clock=ro_pulse_clock, acq_index=0, acq_channel=0, ), ref_op=ro_pulse, ref_pt="start", rel_time=ro_acquisition_delay, label="acquisition", ) return schedule
[docs] def long_time_trace( pulse_amp: complex, frequency: float, acquisition_delay: float, integration_time: float, port: str, clock: str, num_points: int, pulse_delay: float = 0, acq_index: int = 0, repetitions: int = 1, ) -> Schedule: """ The function generates a :class:`~Schedule` for a time trace experiment where single side band integration (i.e. ``SSBIntegrationComplex``) is applied repeatedly. Compared to the Trace schedule which returns one point each ns for 16.4 μs (qblox instrument), the long time trace allows the user to customize the integration time and the number of data points in the trace (a minimum of 300 ns (qblox instrument) for the integration time is needed in between two points). The resulting :class:`~Schedule` can be used for quantum experiments involving dynamic processes (charge transition) and time-dependent measurements (Elzerman Readout). Parameters ---------- pulse_amp The amplitude of the pulse in Volt. frequency The frequency of the pulse and of the data acquisition in Hertz. acquisition_delay The start of the data acquisition with respect to the start of the pulse in seconds. integration_time Integration time per point in the trace. A minimum of 300ns is required du to the spacing of acquisition protocols in QbloxInstrument. port The location on the device where the pulse should be applied. clock The reference clock used to track the pulse frequency. num_points Number of points the output long_trace contains. The total time of the long_trace is then nb_pts*integration_time pulse_delay The pulse delay in seconds. acq_index The data register in which the acquisition is stored, by default 0. Describes the "when" information of the measurement, used to label or tag individual measurements in a large circuit. Typically corresponds to the setpoints of a schedule (e.g., tau in a T1 experiment). repetitions The amount of times the Schedule will be repeated. Returns ------- : The custom long Trace acquisition Schedule. """ schedule = Schedule("Long time trace acquisition", repetitions) schedule.add_resource(ClockResource(name=clock, freq=frequency)) pulse_op = VoltageOffset( offset_path_I=np.real(pulse_amp), offset_path_Q=np.imag(pulse_amp), port=port, clock=clock, ) schedule.add(pulse_op) op = SSBIntegrationComplex( port=port, clock=clock, duration=integration_time, acq_channel=0, acq_index=acq_index, bin_mode=BinMode.APPEND, t0=pulse_delay, ) inner = Schedule("inner", repetitions=1) inner.add(op) schedule.add( inner, control_flow=Loop(num_points), rel_time=acquisition_delay, ref_pt="start", ) pulse_op_off = VoltageOffset( offset_path_I=0, offset_path_Q=0, port=port, clock=clock, ) # Here rel_time = 4ns have to be add to order properly with the control flow. # Same think Idle pulse has to be added for loops # This has to be removed in a next version. schedule.add(pulse_op_off, rel_time=4e-9) schedule.add(IdlePulse(duration=4e-9)) return schedule
[docs] def long_time_trace_with_qubit( qubit: DeviceElement, num_points: int, acq_index: int = 0, repetitions: int = 1, ) -> Schedule: """ Generate a simple schedule similar to a circuit layer to perform long trace acquisition. Wrapper function for :func:~quantify_scheduler.schedules.long_time_trace to use with a quantum device element.. Parameters ---------- qubit Device Element. num_points Number of points the output custom_long_trace contains. The total time of the custom_long_trace is then nb_pts*integration_time acq_index : The data register in which the acquisition is stored, by default 0. Describes the "when" information of the measurement, used to label or tag individual measurements in a large circuit. Typically corresponds to the setpoints of a schedule (e.g., tau in a T1 experiment). repetitions The amount of times the Schedule will be repeated. Returns ------- : The custom long Trace acquisition Schedule. """ schedule = long_time_trace( pulse_amp=qubit.measure.pulse_amp(), pulse_delay=0, frequency=qubit.clock_freqs.readout(), acquisition_delay=qubit.measure.acq_delay(), integration_time=qubit.measure.integration_time(), port=qubit.ports.readout(), clock=qubit.name + ".ro", num_points=num_points, acq_index=acq_index, repetitions=repetitions, ) return schedule