Video Mode

CHANGELOG.md

@@ -14,6 +14,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 - External_frameworks/qcodes - Added ``update_qm()`` to update the quantum machine (close and re-open it) in case the config has been updated. 
 - External_frameworks/qcodes - Added ``live_plotting()`` to fetch and plot the OPX results while the program is running.
 - Unit - Added `volts2dBm` and `dBm2volts`.
+- Video_mode - New module to update some pre-defined parameters of a QUA program while fetching data from the OPX. 
 
 ### Changed
 - Unit - `demod2volts` now has a `single_demod` flag to correctly convert the data from single demodulation.

README.md

@@ -21,7 +21,8 @@ It currently has a two-states discriminator for analyzing the ground and excited
 * [Bakery](qualang_tools/bakery/README.md) - This library introduces a new framework for creating arbitrary waveforms and
 storing them in the usual configuration file. It allows defining waveforms in a QUA-like manner while working with 1ns resolution (or higher).
 
-* [External Frameworks](qualang_tools/external_frameworks/qcodes/README.md) - This library introduces drivers for integrating the OPX within external frameworks such as QCoDeS. Please refer to the [examples](./examples) section for more details about how to use these drivers.
+* [External Frameworks](qualang_tools/external_frameworks/qcodes/README.md) - This library introduces drivers for integrating the OPX within external frameworks such as QCoDeS. Please refer to the [examples](./examples/Qcodes_drivers) section for more details about how to use these drivers.
+* [Video Mode](qualang_tools/video_mode/README.md) - This module allows the user to update some pre-defined parameters of a QUA program while fetching data from the OPX for dynamic tuning. Please refer to the [examples](./examples/video_mode) section for more details about how to implement this module.
 
 * Addons:
   * [Calibrations](qualang_tools/addons/calibration/README.md) - This module allows to easily perform most of the standard single qubit calibrations from a single python file.
@@ -61,5 +62,3 @@ Feel like contributing code to this library? We're thrilled! Please follow [this
 ## Usage
 
 Examples for using various tools can be found on the [QUA Libraries Repository](https://github.com/qua-platform/qua-libs).
-
-Examples for using the Baking toolbox, including 1-qubit randomized benchmarking, cross-entropy benchmark (XEB), high sampling rate baking and more can be found [here](https://github.com/qua-platform/qua-libs/tree/main/examples/bakery).

examples/video_mode/PID_example.py

@@ -0,0 +1,186 @@
+from matplotlib import pyplot as plt
+from qm.qua import *
+from qm import QuantumMachinesManager
+from qualang_tools.addons.variables import assign_variables_to_element
+from qualang_tools.results import fetching_tool
+from configuration import *
+from qualang_tools.video_mode.videomode import VideoMode
+
+
+####################
+# Helper functions #
+####################
+def PID_derivation(
+    input_signal, bitshift_scale_factor, gain_P, gain_I, gain_D, alpha, target
+):
+    """
+
+    :param input_signal: Result of the demodulation
+    :param bitshift_scale_factor: Scale factor as 2**bitshift_scale_factor that multiplies the error signal to avoid resolution issues with QUA fixed (3.28)
+    :param gain_P: Proportional gain.
+    :param gain_I: Integral gain.
+    :param gain_D: Derivative gain.
+    :param alpha: Ratio between proportional and integral error: integrator_error = (1.0 - alpha) * integrator_error + alpha * error
+    :param target: Setpoint to which the input signal should stabilize.
+    :return: The total, proportional, integral and derivative errors.
+    """
+    error = declare(fixed)
+    integrator_error = declare(fixed)
+    derivative_error = declare(fixed)
+    old_error = declare(fixed)
+
+    # calculate the error
+    assign(error, (target - input_signal) << bitshift_scale_factor)
+    # calculate the integrator error with exponentially decreasing weights with coefficient alpha
+    assign(integrator_error, (1.0 - alpha) * integrator_error + alpha * error)
+    # calculate the derivative error
+    assign(derivative_error, old_error - error)
+    # save old error to be error
+    assign(old_error, error)
+
+    return (
+        gain_P * error + gain_I * integrator_error + gain_D * derivative_error,
+        error,
+        integrator_error,
+        derivative_error,
+    )
+
+
+###################
+# The QUA program #
+###################
+def PID_prog(vm: VideoMode, PDH_angle: float = 0.0):
+    with program() as prog:
+        # Results variables
+        I = declare(fixed)
+        Q = declare(fixed)
+        single_shot_DC = declare(fixed)
+        single_shot_AC = declare(fixed)
+        dc_offset_1 = declare(fixed)
+        # PID variables
+        vm.declare_variables()
+        # Streams
+        single_shot_st = declare_stream()
+        error_st = declare_stream()
+        integrator_error_st = declare_stream()
+        derivative_error_st = declare_stream()
+        offset_st = declare_stream()
+
+        # Ensure that the results variables are assigned to the measurement elements
+        assign_variables_to_element("detector_DC", single_shot_DC)
+        assign_variables_to_element("detector_AC", I, Q, single_shot_AC)
+
+        with infinite_loop_():
+            # with for_(n, 0, n < N_shots, n + 1):
+            # Update the PID parameters based on the user input.
+            vm.load_parameters()
+            # Ensure that the two digital oscillators will start with the same phase
+            reset_phase("phase_modulator")
+            reset_phase("detector_AC")
+            # Phase angle between the sideband and demodulation in units of 2pi
+            frame_rotation_2pi(PDH_angle, "phase_modulator")
+            # Sync all the elements
+            align()
+            # Play the PDH sideband
+            play("cw", "phase_modulator")
+            # Measure and integrate the signal received by the detector --> DC measurement
+            measure(
+                "readout",
+                "detector_DC",
+                None,
+                integration.full("constant", single_shot_DC, "out1"),
+            )
+            # Measure and demodulate the signal received by the detector --> AC measurement sqrt(I**2 + Q**2)
+            measure(
+                "readout",
+                "detector_AC",
+                None,
+                demod.full("constant", I, "out1"),
+                demod.full("constant", Q, "out1"),
+            )
+            assign(single_shot_AC, I)
+            # PID correction signal
+            correction, error, int_error, der_error = PID_derivation(
+                single_shot_DC, *vm.variables
+            )
+            # Update the DC offset
+            assign(dc_offset_1, dc_offset_1 + correction)
+            # Handle saturation - Make sure that the DAC won't be asked to output more than 0.5V
+            with if_(dc_offset_1 > 0.5 - phase_mod_amplitude):
+                assign(dc_offset_1, 0.5 - phase_mod_amplitude)
+            with if_(dc_offset_1 < -0.5 + phase_mod_amplitude):
+                assign(dc_offset_1, -0.5 + phase_mod_amplitude)
+            # Apply the correction
+            set_dc_offset("filter_cavity_1", "single", dc_offset_1)
+
+            # Save the desired variables
+            save(single_shot_DC, single_shot_st)
+            save(dc_offset_1, offset_st)
+            save(error, error_st)
+            save(der_error, derivative_error_st)
+            save(int_error, integrator_error_st)
+
+            # Wait between each iteration
+            wait(1000)
+
+        with stream_processing():
+            single_shot_st.buffer(1000).save("single_shot")
+            offset_st.buffer(1000).save("offset")
+            error_st.buffer(1000).save("error")
+            integrator_error_st.buffer(1000).save("int_err")
+            derivative_error_st.buffer(1000).save("der_err")
+    return prog
+
+
+if __name__ == "__main__":
+    # Open the Quantum Machine Manager
+    qmm = QuantumMachinesManager(qop_ip, cluster_name=cluster_name)
+    # Open the Quantum Machine
+    qm = qmm.open_qm(config)
+    # Define the parameters to be updated in video mode with their initial value
+    param_dict = {
+        "bitshift_scale_factor": 3,
+        "gain_P": -1e-4,  # The proportional gain
+        "gain_I": 0.0,  # The integration gain
+        "gain_D": 0.0,  # The derivative gain
+        "alpha": 0.0,  # The ratio between integration and proportional error
+        "target": 0.0,  # The target value
+    }
+    # Initialize the video mode
+    video_mode = VideoMode(qm, param_dict)
+    # Get the QUA program
+    qua_prog = PID_prog(video_mode)
+    job = video_mode.execute(qua_prog)
+    # Get the results from the OPX in live mode
+    data_list = ["error", "int_err", "der_err", "single_shot", "offset"]
+    results = fetching_tool(job, data_list, mode="live")
+    # Live plotting
+    fig = plt.figure()
+    while results.is_processing():
+        error, int_err, der_err, single_shot, offset = results.fetch_all()
+        plt.subplot(231)
+        plt.cla()
+        plt.plot(error, "-")
+        plt.title("Error signal [a.u.]")
+        plt.xlabel("Time [μs]")
+        plt.ylabel("Amplitude Error [arb. units]")
+        plt.subplot(232)
+        plt.cla()
+        plt.plot(int_err, "-")
+        plt.title("integration_error signal [a.u.]")
+        plt.xlabel("Time [μs]")
+        plt.subplot(233)
+        plt.cla()
+        plt.plot(der_err, "-")
+        plt.title("derivative_error signal [a.u.]")
+        plt.xlabel("Time [μs]")
+        plt.subplot(234)
+        plt.cla()
+        plt.plot(single_shot)
+        plt.title("Single shot measurement")
+        plt.subplot(235)
+        plt.cla()
+        plt.plot(offset)
+        plt.title("Applied offset [V]")
+        plt.tight_layout()
+        plt.pause(0.1)

examples/video_mode/README.md

@@ -0,0 +1,10 @@
+# Video Mode usage examples
+
+__Package__: https://github.com/qua-platform/py-qua-tools/tree/main/qualang_tools/video_mode
+
+This package contains modules to set the OPX in a video-mode, where pre-defined parameters of the QUA program can be 
+updated while looking at data extracted and plotted in real-time. 
+
+In this example folder, you will find two files:
+* [simple test](user_input_example.py): demonstrating the basic functionalities by updating two OPX output offsets.
+* [PID loop](PID_example.py): showing how to use this framework to calibrate and optimize the parameters of a PID loop.

examples/video_mode/configuration.py

@@ -0,0 +1,172 @@
+from qualang_tools.units import unit
+
+
+######################
+# AUXILIARY FUNCTIONS:
+######################
+u = unit()
+
+######################
+# Network parameters #
+######################
+qop_ip = "127.0.0.1"  # Write the QM router IP address
+cluster_name = "my_cluster"  # Write your cluster_name if version >= QOP220
+qop_port = None  # Write the QOP port if version < QOP220
+
+
+################
+# CONFIGURATION:
+################
+# Phase modulation
+phase_modulation_IF = 5 * u.MHz
+phase_mod_amplitude = 0.1
+phase_mod_len = 10 * u.us
+
+# AOM
+AOM_IF = 0
+const_amplitude = 0.1
+const_len = 100
+
+# Filter cavity
+offset_amplitude = 0.25  # Fixed do not change
+offset_len = 16  # Fixed do not change
+
+# Photo-diode
+readout_len = phase_mod_len
+time_of_flight = 192
+
+
+config = {
+    "version": 1,
+    "controllers": {
+        "con1": {
+            "analog_outputs": {
+                8: {"offset": 0.0},
+                9: {"offset": 0.0},
+                10: {"offset": 0.0},
+            },
+            "digital_outputs": {
+                1: {},
+            },
+            "analog_inputs": {
+                1: {"offset": 0.0},
+                2: {"offset": 0.0},
+            },
+        }
+    },
+    "elements": {
+        "phase_modulator": {
+            "singleInput": {
+                "port": ("con1", 8),
+            },
+            "intermediate_frequency": phase_modulation_IF,
+            "operations": {
+                "cw": "phase_mod_pulse",
+            },
+        },
+        "filter_cavity_1": {
+            "singleInput": {
+                "port": ("con1", 9),
+            },
+            "operations": {
+                "offset": "offset_pulse",
+            },
+            "sticky": {"analog": True, "duration": 60},
+        },
+        "filter_cavity_2": {
+            "singleInput": {
+                "port": ("con1", 10),
+            },
+            "operations": {
+                "offset": "offset_pulse",
+            },
+            "sticky": {"analog": True, "duration": 60},
+        },
+        "detector_DC": {
+            "singleInput": {
+                "port": ("con1", 9),
+            },
+            "operations": {
+                "readout": "DC_readout_pulse",
+            },
+            "outputs": {
+                "out1": ("con1", 1),
+                "out2": ("con1", 2),
+            },
+            "time_of_flight": time_of_flight,
+            "smearing": 0,
+        },
+        "detector_AC": {
+            "singleInput": {
+                "port": ("con1", 9),
+            },
+            "intermediate_frequency": phase_modulation_IF,
+            "operations": {
+                "readout": "AC_readout_pulse",
+            },
+            "outputs": {
+                "out1": ("con1", 1),
+            },
+            "time_of_flight": time_of_flight,
+            "smearing": 0,
+        },
+    },
+    "pulses": {
+        "offset_pulse": {
+            "operation": "control",
+            "length": offset_len,
+            "waveforms": {
+                "single": "offset_wf",
+            },
+        },
+        "phase_mod_pulse": {
+            "operation": "control",
+            "length": phase_mod_len,
+            "waveforms": {
+                "single": "phase_mod_wf",
+            },
+        },
+        "cw_pulse": {
+            "operation": "control",
+            "length": const_len,
+            "waveforms": {
+                "single": "const_wf",
+            },
+        },
+        "DC_readout_pulse": {
+            "operation": "measurement",
+            "length": readout_len,
+            "waveforms": {
+                "single": "zero_wf",
+            },
+            "integration_weights": {
+                "constant": "constant_weights",
+            },
+            "digital_marker": "ON",
+        },
+        "AC_readout_pulse": {
+            "operation": "measurement",
+            "length": readout_len,
+            "waveforms": {
+                "single": "zero_wf",
+            },
+            "integration_weights": {
+                "constant": "constant_weights",
+            },
+            "digital_marker": "ON",
+        },
+    },
+    "waveforms": {
+        "phase_mod_wf": {"type": "constant", "sample": phase_mod_amplitude},
+        "const_wf": {"type": "constant", "sample": const_amplitude},
+        "offset_wf": {"type": "constant", "sample": offset_amplitude},
+        "zero_wf": {"type": "constant", "sample": 0.0},
+    },
+    "digital_waveforms": {"ON": {"samples": [(1, 0)]}},
+    "integration_weights": {
+        "constant_weights": {
+            "cosine": [(1.0, readout_len)],
+            "sine": [(0.0, readout_len)],
+        },
+    },
+}