Video Mode

CHANGELOG.md

@@ -27,6 +27,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
 - Eased package dependencies, requires python 3.8 or above

README.md

@@ -22,7 +22,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.
@@ -72,5 +73,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/Qcodes_drivers/advanced-driver/advanced_driver.py

@@ -134,12 +134,8 @@ def __init__(
     def update_readout_parameters(self):
         """Update the config with the readout length and amplitude set with self.readout_pulse_length() and self.readout_pulse_amplitude()."""
         if self.readout_pulse_length() % 4 != 0:
-            raise ValueError(
-                "The readout pulse length must be an integer multiple of 4ns."
-            )
-        self.config["pulses"]["readout_pulse"]["length"] = int(
-            self.readout_pulse_length()
-        )
+            raise ValueError("The readout pulse length must be an integer multiple of 4ns.")
+        self.config["pulses"]["readout_pulse"]["length"] = int(self.readout_pulse_length())
         self.config["integration_weights"]["cosine_weights"]["cosine"] = [
             (1.0, self.config["pulses"]["readout_pulse"]["length"])
         ]
@@ -159,9 +155,7 @@ def update_readout_parameters(self):
             (-1.0, self.config["pulses"]["readout_pulse"]["length"])
         ]
         # update readout pulse amplitude
-        pulse = self.config["elements"][self.readout_element()]["operations"][
-            self.readout_operation()
-        ]
+        pulse = self.config["elements"][self.readout_element()]["operations"][self.readout_operation()]
         wf = self.config["pulses"][pulse]["waveforms"]["I"]
         self.config["waveforms"][wf]["sample"] = self.readout_pulse_amplitude()
         # Open QM
@@ -200,10 +194,7 @@ def measurement_declaration(self):
                 Q1_arr,
                 Q2_arr,
             ]
-        elif (
-            self.acquisition_mode() == "full_integration"
-            or self.acquisition_mode() == "full_demodulation"
-        ):
+        elif self.acquisition_mode() == "full_integration" or self.acquisition_mode() == "full_demodulation":
             I = declare(fixed)
             Q = declare(fixed)
             I_st = declare_stream()
@@ -288,76 +279,49 @@ def stream_results(self):
         """Create the stream processing based on the measurement mode (self.acquisition_mode()) and OPX scan 0d, 1d or 2d (self.opx_scan())"""
         variables = self.measurement_variables
         if self.opx_scan() == "0d":
-            if (
-                self.acquisition_mode() == "full_integration"
-                or self.acquisition_mode() == "full_demodulation"
-            ):
+            if self.acquisition_mode() == "full_integration" or self.acquisition_mode() == "full_demodulation":
                 variables[2].buffer(self.n_avg()).map(FUNCTIONS.average()).save_all("I")
                 variables[3].buffer(self.n_avg()).map(FUNCTIONS.average()).save_all("Q")
             elif self.acquisition_mode() == "raw_adc":
-                variables.input1().buffer(self.n_avg()).map(
-                    FUNCTIONS.average()
-                ).save_all("adc1")
-                variables.input2().buffer(self.n_avg()).map(
-                    FUNCTIONS.average()
-                ).save_all("adc2")
-            elif (
-                self.acquisition_mode() == "sliced_integration"
-                or self.acquisition_mode() == "sliced_demodulation"
-            ):
-                variables[2].buffer(variables[5]).buffer(self.n_avg()).map(
-                    FUNCTIONS.average()
-                ).save_all("I")
-                variables[3].buffer(variables[5]).buffer(self.n_avg()).map(
-                    FUNCTIONS.average()
-                ).save_all("Q")
+                variables.input1().buffer(self.n_avg()).map(FUNCTIONS.average()).save_all("adc1")
+                variables.input2().buffer(self.n_avg()).map(FUNCTIONS.average()).save_all("adc2")
+            elif self.acquisition_mode() == "sliced_integration" or self.acquisition_mode() == "sliced_demodulation":
+                variables[2].buffer(variables[5]).buffer(self.n_avg()).map(FUNCTIONS.average()).save_all("I")
+                variables[3].buffer(variables[5]).buffer(self.n_avg()).map(FUNCTIONS.average()).save_all("Q")
         elif self.opx_scan() == "1d":
-            if (
-                self.acquisition_mode() == "full_integration"
-                or self.acquisition_mode() == "full_demodulation"
-            ):
-                variables[2].buffer(self.axis1_npoints()).buffer(self.n_avg()).map(
+            if self.acquisition_mode() == "full_integration" or self.acquisition_mode() == "full_demodulation":
+                variables[2].buffer(self.axis1_npoints()).buffer(self.n_avg()).map(FUNCTIONS.average()).save_all("I")
+                variables[3].buffer(self.axis1_npoints()).buffer(self.n_avg()).map(FUNCTIONS.average()).save_all("Q")
+            elif self.acquisition_mode() == "raw_adc":
+                variables.buffer(self.axis1_npoints()).input1().buffer(self.n_avg()).map(FUNCTIONS.average()).save_all(
+                    "adc1"
+                )
+                variables.buffer(self.axis1_npoints()).input2().buffer(self.n_avg()).map(FUNCTIONS.average()).save_all(
+                    "adc2"
+                )
+            elif self.acquisition_mode() == "sliced_integration" or self.acquisition_mode() == "sliced_demodulation":
+                variables[2].buffer(variables[5]).buffer(self.axis2_npoints()).buffer(self.n_avg()).map(
                     FUNCTIONS.average()
                 ).save_all("I")
-                variables[3].buffer(self.axis1_npoints()).buffer(self.n_avg()).map(
+                variables[3].buffer(variables[5]).buffer(self.axis2_npoints()).buffer(self.n_avg()).map(
                     FUNCTIONS.average()
                 ).save_all("Q")
-            elif self.acquisition_mode() == "raw_adc":
-                variables.buffer(self.axis1_npoints()).input1().buffer(
-                    self.n_avg()
-                ).map(FUNCTIONS.average()).save_all("adc1")
-                variables.buffer(self.axis1_npoints()).input2().buffer(
-                    self.n_avg()
-                ).map(FUNCTIONS.average()).save_all("adc2")
-            elif (
-                self.acquisition_mode() == "sliced_integration"
-                or self.acquisition_mode() == "sliced_demodulation"
-            ):
-                variables[2].buffer(variables[5]).buffer(self.axis2_npoints()).buffer(
-                    self.n_avg()
-                ).map(FUNCTIONS.average()).save_all("I")
-                variables[3].buffer(variables[5]).buffer(self.axis2_npoints()).buffer(
-                    self.n_avg()
-                ).map(FUNCTIONS.average()).save_all("Q")
         elif self.opx_scan() == "2d":
-            if (
-                self.acquisition_mode() == "full_integration"
-                or self.acquisition_mode() == "full_demodulation"
-            ):
+            if self.acquisition_mode() == "full_integration" or self.acquisition_mode() == "full_demodulation":
                 if self.outer_averaging_loop():
-                    variables[2].buffer(self.axis1_npoints()).buffer(
-                        self.axis2_npoints()
-                    ).buffer(self.n_avg()).map(FUNCTIONS.average()).save_all("I")
-                    variables[3].buffer(self.axis1_npoints()).buffer(
-                        self.axis2_npoints()
-                    ).buffer(self.n_avg()).map(FUNCTIONS.average()).save_all("Q")
-                else:
-                    variables[2].buffer(self.axis1_npoints()).buffer(self.n_avg()).map(
+                    variables[2].buffer(self.axis1_npoints()).buffer(self.axis2_npoints()).buffer(self.n_avg()).map(
                         FUNCTIONS.average()
-                    ).buffer(self.axis2_npoints()).save_all("I")
-                    variables[3].buffer(self.axis1_npoints()).buffer(self.n_avg()).map(
+                    ).save_all("I")
+                    variables[3].buffer(self.axis1_npoints()).buffer(self.axis2_npoints()).buffer(self.n_avg()).map(
                         FUNCTIONS.average()
-                    ).buffer(self.axis2_npoints()).save_all("Q")
+                    ).save_all("Q")
+                else:
+                    variables[2].buffer(self.axis1_npoints()).buffer(self.n_avg()).map(FUNCTIONS.average()).buffer(
+                        self.axis2_npoints()
+                    ).save_all("I")
+                    variables[3].buffer(self.axis1_npoints()).buffer(self.n_avg()).map(FUNCTIONS.average()).buffer(
+                        self.axis2_npoints()
+                    ).save_all("Q")
             else:
                 raise Exception(
                     "It is advises to use 'full_integration' or 'full_demodulation' only for performing 2d scans on the OPX to avoid memory overflow."

examples/Qcodes_drivers/advanced-driver/hello_qcodes_advanced.py

@@ -21,15 +21,11 @@
 qc.config.core.db_location = db_file_path
 initialise_or_create_database_at(db_file_path)
 # Initialize qcodes experiment
-experiment = load_or_create_experiment(
-    experiment_name=exp_name, sample_name=sample_name
-)
+experiment = load_or_create_experiment(experiment_name=exp_name, sample_name=sample_name)
 # Initialize the qcodes station to which instruments will be added
 station = qc.Station()
 # Create the OPX instrument class
-opx_instrument = OPXCustomSequence(
-    config, name="OPX_demo", host="127.0.0.1", cluster_name="my_cluster"
-)
+opx_instrument = OPXCustomSequence(config, name="OPX_demo", host="127.0.0.1", cluster_name="my_cluster")
 # Add the OPX instrument to the qcodes station
 station.add_component(opx_instrument)
 
@@ -142,9 +138,7 @@ def custom_sequence(self):
     opx_instrument.outer_averaging_loop(False)
     opx_instrument.n_avg(n_avg)
     # Axis1 is the most inner loop
-    opx_instrument.set_sweep_parameters(
-        "axis1", pulse_lengths * 4, "ns", "pulse duration"
-    )
+    opx_instrument.set_sweep_parameters("axis1", pulse_lengths * 4, "ns", "pulse duration")
     # Axis2 is the second loop
     opx_instrument.set_sweep_parameters(
         "axis2",

examples/Qcodes_drivers/basic-driver/hello_qcodes.py

@@ -20,9 +20,7 @@
 qc.config.core.db_location = db_file_path
 initialise_or_create_database_at(db_file_path)
 # Initialize qcodes experiment
-experiment = load_or_create_experiment(
-    experiment_name=exp_name, sample_name=sample_name
-)
+experiment = load_or_create_experiment(experiment_name=exp_name, sample_name=sample_name)
 # Initialize the qcodes station to which instruments will be added
 station = qc.Station()
 # Create the OPX instrument class
@@ -204,12 +202,8 @@ def OPX_1d_scan(simulate=False):
                 ramp_to_zero("gate_1")
 
         with stream_processing():
-            I_st.buffer(len(biases)).buffer(n_avg).map(FUNCTIONS.average()).save_all(
-                "I"
-            )
-            Q_st.buffer(len(biases)).buffer(n_avg).map(FUNCTIONS.average()).save_all(
-                "Q"
-            )
+            I_st.buffer(len(biases)).buffer(n_avg).map(FUNCTIONS.average()).save_all("I")
+            Q_st.buffer(len(biases)).buffer(n_avg).map(FUNCTIONS.average()).save_all("Q")
     return prog
 
 
@@ -234,9 +228,7 @@ def OPX_1d_scan(simulate=False):
     do0d(
         opx_instrument.run_exp,
         opx_instrument.resume,
-        opx_instrument.get_measurement_parameter(
-            scale_factor=[("I", 1235, "pA"), ("Q", 1235, "pA")]
-        ),
+        opx_instrument.get_measurement_parameter(scale_factor=[("I", 1235, "pA"), ("Q", 1235, "pA")]),
         opx_instrument.halt,
         do_plot=True,
         exp=experiment,
@@ -368,12 +360,8 @@ def OPX_sliced_scan(simulate=False):
                 ramp_to_zero("gate_1")
 
         with stream_processing():
-            I_st.buffer(nb_of_slices).buffer(len(biases)).buffer(n_avg).map(
-                FUNCTIONS.average()
-            ).save_all("I")
-            Q_st.buffer(nb_of_slices).buffer(len(biases)).buffer(n_avg).map(
-                FUNCTIONS.average()
-            ).save_all("Q")
+            I_st.buffer(nb_of_slices).buffer(len(biases)).buffer(n_avg).map(FUNCTIONS.average()).save_all("I")
+            Q_st.buffer(nb_of_slices).buffer(len(biases)).buffer(n_avg).map(FUNCTIONS.average()).save_all("Q")
     return prog
 
 
@@ -443,12 +431,8 @@ def OPX_reflectometry(simulate=False):
                     save(Q, Q_st)
 
         with stream_processing():
-            I_st.buffer(len(frequencies)).buffer(n_avg).map(
-                FUNCTIONS.average()
-            ).save_all("I")
-            Q_st.buffer(len(frequencies)).buffer(n_avg).map(
-                FUNCTIONS.average()
-            ).save_all("Q")
+            I_st.buffer(len(frequencies)).buffer(n_avg).map(FUNCTIONS.average()).save_all("I")
+            Q_st.buffer(len(frequencies)).buffer(n_avg).map(FUNCTIONS.average()).save_all("Q")
     return prog
 
 
@@ -484,9 +468,7 @@ def OPX_reflectometry(simulate=False):
             # Get the results from the OPX
             data = opx_instrument.get_res()
             # Store the results in the scodes database
-            datasaver.add_result(
-                (VP1, VP1()), (OPX_param, np.array(list(data.values())))
-            )
+            datasaver.add_result((VP1, VP1()), (OPX_param, np.array(list(data.values()))))
         # Halt the OPX program at the end
         opx_instrument.halt()
         # Get the full dataset

examples/Qcodes_drivers/stability-diagram/raster_scan.py

@@ -20,9 +20,7 @@
 qc.config.core.db_location = db_file_path
 initialise_or_create_database_at(db_file_path)
 # Initialize qcodes experiment
-experiment = load_or_create_experiment(
-    experiment_name=exp_name, sample_name=sample_name
-)
+experiment = load_or_create_experiment(experiment_name=exp_name, sample_name=sample_name)
 # Initialize the qcodes station to which instruments will be added
 station = qc.Station()
 # Create the OPX instrument class
@@ -129,12 +127,8 @@ def raster_scan(simulate=False):
                         save(I, I_st)
                         save(Q, Q_st)
         with stream_processing():
-            I_st.buffer(N1).buffer(N2).buffer(n_avg).map(FUNCTIONS.average()).save_all(
-                "I"
-            )
-            Q_st.buffer(N1).buffer(N2).buffer(n_avg).map(FUNCTIONS.average()).save_all(
-                "Q"
-            )
+            I_st.buffer(N1).buffer(N2).buffer(n_avg).map(FUNCTIONS.average()).save_all("I")
+            Q_st.buffer(N1).buffer(N2).buffer(n_avg).map(FUNCTIONS.average()).save_all("Q")
 
     return prog