Default measurement for annealing for the first demo implementation.

docs/releases/changelog-dev.md

@@ -2,6 +2,10 @@
 
 ### New features since last release
 
+- Add default measurement to `execute_anneal_program()` method. This method takes now a calibration file and parameters
+to add the dispersive measurement at the end of the annealing schedule.
+  [#778](https://github.com/qilimanjaro-tech/qililab/pull/778)
+
 - Add `__str__` method to qprogram. The string is a readable qprogram.
   [#767](https://github.com/qilimanjaro-tech/qililab/pull/767)
 

src/qililab/platform/platform.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# pylint: disable=too-many-lines
 """Platform class."""
 import ast
 import io
@@ -51,6 +52,7 @@
 from qililab.system_control import ReadoutSystemControl
 from qililab.typings.enums import InstrumentName, Line, Parameter
 from qililab.utils import hash_qpy_sequence
+from qililab.waveforms import IQPair, Square
 
 from .components import Bus, Buses
 
@@ -600,10 +602,16 @@ def __str__(self) -> str:
         """
         return str(YAML().dump(self.to_dict(), io.BytesIO()))
 
-    # TODO: determine default average
     def execute_anneal_program(
-        self, annealing_program_dict: list[dict[str, dict[str, float]]], transpiler: Callable, averages=1
-    ):
+        self,
+        annealing_program_dict: list[dict[str, dict[str, float]]],
+        calibration: Calibration,
+        readout_bus: str,
+        measurement_name: str,
+        transpiler: Callable,
+        averages=1,
+        weights: str | None = None,
+    ) -> QProgramResults:
         """Given an annealing program execute it as a qprogram.
         The annealing program should contain a time ordered list of circuit elements and their corresponging ising coefficients as a dictionary. Example structure:
 
@@ -627,18 +635,27 @@ def execute_anneal_program(
             transpiler (Callable): ising to flux transpiler. The transpiler should take 2 values as arguments (delta, epsilon) and return 2 values (phix, phiz)
             averages (int, optional): Amount of times to run and average the program over. Defaults to 1.
         """
-        annealing_program = AnnealingProgram(self, annealing_program_dict)
-        annealing_program.transpile(transpiler)
-        annealing_waveforms = annealing_program.get_waveforms()
-
-        qp_annealing = QProgram()
-        with qp_annealing.average(averages):
-            for bus, waveform in annealing_waveforms.values():
-                qp_annealing.play(bus=bus.alias, waveform=waveform)
-
-        # TODO: define readout
+        if calibration.has_waveform(bus=readout_bus, name=measurement_name):
+            annealing_program = AnnealingProgram(self, annealing_program_dict)
+            annealing_program.transpile(transpiler)
+            annealing_waveforms = annealing_program.get_waveforms()
+
+            qp_annealing = QProgram()
+            with qp_annealing.average(averages):
+                for bus, waveform in annealing_waveforms.values():
+                    qp_annealing.play(bus=bus.alias, waveform=waveform)
+                qp_annealing.sync()
+                if weights and calibration.has_weights(bus=readout_bus, name=weights):
+                    qp_annealing.measure(bus=readout_bus, waveform=measurement_name, weights=weights)
+                else:
+                    r_duration = calibration.get_waveform(bus=readout_bus, name=measurement_name).get_duration()
+                    weights_shape = Square(amplitude=1, duration=r_duration)
+                    qp_annealing.measure(
+                        bus=readout_bus, waveform=measurement_name, weights=IQPair(I=weights_shape, Q=weights_shape)
+                    )
 
-        self.execute_qprogram(qprogram=qp_annealing)
+            return self.execute_qprogram(qprogram=qp_annealing, calibration=calibration)
+        raise ValueError("The calibrated measurement is not present in the calibration file.")
 
     def execute_qprogram(  # pylint: disable=too-many-locals
         self,

tests/platform/test_platform.py

@@ -24,8 +24,9 @@
 from qililab.instruments.quantum_machines import QuantumMachinesCluster
 from qililab.platform import Bus, Buses, Platform
 from qililab.pulse import Drag, Pulse, PulseEvent, PulseSchedule, Rectangular
-from qililab.qprogram import QProgram
+from qililab.qprogram import Calibration, QProgram
 from qililab.result.qblox_results import QbloxResult
+from qililab.result.qprogram.qprogram_results import QProgramResults
 from qililab.result.qprogram.quantum_machines_measurement_result import QuantumMachinesMeasurementResult
 from qililab.settings import Runcard
 from qililab.settings.gate_event_settings import GateEventSettings
@@ -109,6 +110,23 @@ def fixture_qblox_results():
     ]
 
 
+@pytest.fixture(name="calibration")
+def get_calibration():
+    readout_duration = 2000
+    readout_amplitude = 1.0
+    r_wf_I = Square(amplitude=readout_amplitude, duration=readout_duration)
+    r_wf_Q = Square(amplitude=0.0, duration=readout_duration)
+    readout_waveform = IQPair(I=r_wf_I, Q=r_wf_Q)
+    weights_shape = Square(amplitude=1, duration=readout_duration)
+    weights = IQPair(I=weights_shape, Q=weights_shape)
+
+    calibration = Calibration()
+    calibration.add_waveform(bus="readout_bus", name="readout", waveform=readout_waveform)
+    calibration.add_weights(bus="readout_bus", name="optimal_weights", weights=weights)
+
+    return calibration
+
+
 @pytest.fixture(name="anneal_qprogram")
 def get_anneal_qprogram(runcard):
     platform = Platform(runcard=runcard)
@@ -127,10 +145,19 @@ def get_anneal_qprogram(runcard):
         ),
     }
     averages = 2
+    readout_duration = 2000
+    readout_amplitude = 1.0
+    r_wf_I = Square(amplitude=readout_amplitude, duration=readout_duration)
+    r_wf_Q = Square(amplitude=0.0, duration=readout_duration)
+    readout_waveform = IQPair(I=r_wf_I, Q=r_wf_Q)
+    weights_shape = Square(amplitude=1, duration=readout_duration)
+    weights = IQPair(I=weights_shape, Q=weights_shape)
     qp_anneal = QProgram()
     with qp_anneal.average(averages):
         for bus, waveform in anneal_waveforms.values():
             qp_anneal.play(bus=bus.alias, waveform=waveform)
+        qp_anneal.sync()
+        qp_anneal.measure(bus="readout_bus", waveform=readout_waveform, weights=weights)
     return qp_anneal
 
 
@@ -375,16 +402,53 @@ def _compile_and_assert(self, platform: Platform, program: Circuit | PulseSchedu
             assert all(isinstance(sequence, Sequence) for sequence in sequences_list)
             assert sequences_list[0]._program.duration == 200_000 * 1000 + 4 + 4 + 4
 
-    def test_execute_anneal_program(self, platform: Platform, anneal_qprogram):
+    def test_execute_anneal_program(self, platform: Platform, anneal_qprogram, calibration):
         mock_execute_qprogram = MagicMock()
+        mock_execute_qprogram.return_value = QProgramResults()
         platform.execute_qprogram = mock_execute_qprogram  # type: ignore[method-assign]
         transpiler = MagicMock()
         transpiler.return_value = (1, 2)
-        # with patch(qililab.analog.annealing_program, "AnnealingProgram") as dummy_anneal_program:
-        platform.execute_anneal_program(
-            annealing_program_dict=[{"qubit_0": {"sigma_x": 0.1, "sigma_z": 0.2}}], transpiler=transpiler, averages=2
+
+        results = platform.execute_anneal_program(
+            annealing_program_dict=[{"qubit_0": {"sigma_x": 0.1, "sigma_z": 0.2}}],
+            transpiler=transpiler,
+            averages=2,
+            readout_bus="readout_bus",
+            measurement_name="readout",
+            weights="optimal_weights",
+            calibration=calibration,
+        )
+        qprogram = mock_execute_qprogram.call_args[1]["qprogram"].with_calibration(calibration)
+        assert str(anneal_qprogram) == str(qprogram)
+        assert isinstance(results, QProgramResults)
+
+        results = platform.execute_anneal_program(
+            annealing_program_dict=[{"qubit_0": {"sigma_x": 0.1, "sigma_z": 0.2}}],
+            transpiler=transpiler,
+            averages=2,
+            readout_bus="readout_bus",
+            measurement_name="readout",
+            calibration=calibration,
         )
-        assert str(anneal_qprogram) == str(mock_execute_qprogram.call_args[1]["qprogram"])
+        qprogram = mock_execute_qprogram.call_args[1]["qprogram"].with_calibration(calibration)
+        assert str(anneal_qprogram) == str(qprogram)
+        assert isinstance(results, QProgramResults)
+
+    def test_execute_anneal_program_no_measurement_raises_error(self, platform: Platform, calibration):
+        mock_execute_qprogram = MagicMock()
+        platform.execute_qprogram = mock_execute_qprogram  # type: ignore[method-assign]
+        transpiler = MagicMock()
+        transpiler.return_value = (1, 2)
+        error_string = "The calibrated measurement is not present in the calibration file."
+        with pytest.raises(ValueError, match=error_string):
+            platform.execute_anneal_program(
+                annealing_program_dict=[{"qubit_0": {"sigma_x": 0.1, "sigma_z": 0.2}}],
+                transpiler=transpiler,
+                averages=2,
+                readout_bus="readout_bus",
+                measurement_name="whatever",
+                calibration=calibration,
+            )
 
     def test_execute_qprogram_with_qblox(self, platform: Platform):
         """Test that the execute method compiles the qprogram, calls the buses to run and return the results."""