Improve calibration experiments

qiskit_experiments/calibration_management/update_library.py

@@ -149,6 +149,7 @@ def update(
         calibrations: BackendCalibrations,
         exp_data: ExperimentData,
         result_index: Optional[int] = None,
+        parameter: str = None,
         group: str = "default",
         fit_parameter: Optional[str] = None,
         **options,
@@ -161,16 +162,21 @@ def update(
             calibrations: The calibrations to update.
             exp_data: The experiment data from which to update.
             result_index: The result index to use which defaults to -1.
+            parameter: The name of the parameter to update. If None is given this will default
+                to :code:`calibrations.__qubit_freq_parameter__`.
             group: The calibrations group to update. Defaults to "default."
             options: Trailing options.
             fit_parameter: The name of the fit parameter in the analysis result. This will default
                 to the class variable :code:`__fit_parameter__` if not given.
 
         """
+        if parameter is None:
+            parameter = calibrations.__qubit_freq_parameter__
+
         super().update(
             calibrations=calibrations,
             exp_data=exp_data,
-            parameter=calibrations.__qubit_freq_parameter__,
+            parameter=parameter,
             schedule=None,
             result_index=result_index,
             group=group,

qiskit_experiments/library/__init__.py

@@ -78,6 +78,7 @@ class instance to manage parameters and pulse schedules.
     :toctree: ../stubs/
     :template: autosummary/experiment.rst
 
+    ~calibration.RoughFrequencyCal
     ~calibration.DragCal
     ~calibration.FineDrag
     ~calibration.FineXDrag
@@ -100,6 +101,7 @@ class instance to manage parameters and pulse schedules.
     FineAmplitude,
     FineXAmplitude,
     FineSXAmplitude,
+    RoughFrequencyCal,
     RamseyXY,
 )
 from .characterization import (

qiskit_experiments/library/calibration/__init__.py

@@ -39,6 +39,7 @@
     :toctree: ../stubs/
     :template: autosummary/experiment.rst
 
+    RoughFrequencyCal
     DragCal
     FineDrag
     FineXDrag
@@ -66,6 +67,7 @@
 See :mod:`qiskit_experiments.calibration_management`.
 """
 
+from .rough_frequency import RoughFrequencyCal
 from .drag import DragCal
 from .fine_drag import FineDrag, FineXDrag, FineSXDrag
 from .rabi import Rabi, EFRabi

qiskit_experiments/library/calibration/rough_frequency.py

@@ -0,0 +1,109 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Calibration version of spectroscopy experiments."""
+
+from typing import Iterable
+
+from qiskit_experiments.library.characterization.qubit_spectroscopy import QubitSpectroscopy
+from qiskit_experiments.library.characterization.ef_spectroscopy import EFSpectroscopy
+from qiskit_experiments.calibration_management.update_library import Frequency
+from qiskit_experiments.calibration_management.backend_calibrations import BackendCalibrations
+from qiskit_experiments.calibration_management.base_calibration_experiment import (
+    BaseCalibrationExperiment,
+)
+
+
+class RoughFrequencyCal(BaseCalibrationExperiment, QubitSpectroscopy):
+    """A calibration experiment that runs QubitSpectroscopy."""
+
+    def __init__(
+        self,
+        qubit: int,
+        calibrations: BackendCalibrations,
+        frequencies: Iterable[float],
+        unit: str = "Hz",
+        auto_update: bool = True,
+        absolute: bool = True,
+    ):
+        """See :class:`QubitSpectroscopy` for detailed documentation.
+
+        Args:
+            qubit: The qubit on which to run spectroscopy.
+            calibrations: If calibrations is given then running the experiment may update the values
+                of the frequencies stored in calibrations.
+            frequencies: The frequencies to scan in the experiment.
+            unit: The unit in which the user specifies the frequencies. Can be one of 'Hz', 'kHz',
+                'MHz', 'GHz'. Internally, all frequencies will be converted to 'Hz'.
+            auto_update: If set to True, which is the default, then the experiment will
+                automatically update the frequency in the calibrations.
+            absolute: Boolean to specify if the frequencies are absolute or relative to the
+                qubit frequency in the backend.
+
+        Raises:
+            QiskitError: if there are less than three frequency shifts or if the unit is not known.
+
+        """
+        super().__init__(
+            calibrations,
+            qubit,
+            frequencies,
+            unit,
+            absolute,
+            updater=Frequency,
+            auto_update=auto_update,
+        )
+
+
+class RoughEFFrequencyCal(BaseCalibrationExperiment, EFSpectroscopy):
+    """A calibration experiment that runs QubitSpectroscopy."""
+
+    __updater__ = Frequency
+
+    # pylint: disable=super-init-not-called
+    def __init__(
+        self,
+        qubit: int,
+        calibrations: BackendCalibrations,
+        frequencies: Iterable[float],
+        unit: str = "Hz",
+        auto_update: bool = True,
+        absolute: bool = True,
+    ):
+        """See :class:`QubitSpectroscopy` for detailed documentation.
+
+        Args:
+            qubit: The qubit on which to run spectroscopy.
+            calibrations: If calibrations is given then running the experiment may update the values
+                of the frequencies stored in calibrations.
+            frequencies: The frequencies to scan in the experiment.
+            unit: The unit in which the user specifies the frequencies. Can be one of 'Hz', 'kHz',
+                'MHz', 'GHz'. Internally, all frequencies will be converted to 'Hz'.
+            auto_update: If set to True, which is the default, then the experiment will
+                automatically update the frequency in the calibrations.
+            absolute: Boolean to specify if the frequencies are absolute or relative to the
+                qubit frequency in the backend.
+
+        Raises:
+            QiskitError: if there are less than three frequency shifts or if the unit is not known.
+
+        """
+        super().__init__(
+            calibrations,
+            qubit,
+            frequencies,
+            unit,
+            absolute,
+            cal_parameter_name="f12",
+            updater=Frequency,
+            auto_update=auto_update,
+        )

qiskit_experiments/library/characterization/qubit_spectroscopy.py

@@ -12,7 +12,7 @@
 
 """Spectroscopy experiment class."""
 
-from typing import List, Optional, Tuple, Union
+from typing import Iterable, Optional, Tuple
 
 import numpy as np
 import qiskit.pulse as pulse
@@ -60,7 +60,16 @@ def _default_run_options(cls) -> Options:
 
     @classmethod
     def _default_experiment_options(cls) -> Options:
-        """Default option values used for the spectroscopy pulse."""
+        """Default option values used for the spectroscopy pulse.
+
+        Experiment Options:
+            amp (float): The amplitude of the spectroscopy pulse. Defaults to 0.1.
+            duration (int): The duration of the spectroscopy pulse. Defaults to 1024 samples.
+            sigma (float): The standard deviation of the flanks of the spectroscopy pulse.
+                Defaults to 256.
+            width (int): The width of the flat-top part of the GaussianSquare pulse.
+                Defaults to 0.
+        """
         options = super()._default_experiment_options()
 
         options.amp = 0.1
@@ -85,8 +94,8 @@ def _default_analysis_options(cls) -> Options:
     def __init__(
         self,
         qubit: int,
-        frequencies: Union[List[float], np.array],
-        unit: Optional[str] = "Hz",
+        frequencies: Iterable[float],
+        unit: str = "Hz",
         absolute: bool = True,
     ):
         """
@@ -101,16 +110,17 @@ def __init__(
         Args:
             qubit: The qubit on which to run spectroscopy.
             frequencies: The frequencies to scan in the experiment.
-            unit: The unit in which the user specifies the frequencies. Can be one
-                of 'Hz', 'kHz', 'MHz', 'GHz'. Internally, all frequencies will be converted
-                to 'Hz'.
+            unit: The unit in which the user specifies the frequencies. Can be one of 'Hz', 'kHz',
+                'MHz', 'GHz'. Internally, all frequencies will be converted to 'Hz'.
             absolute: Boolean to specify if the frequencies are absolute or relative to the
                 qubit frequency in the backend.
 
         Raises:
             QiskitError: if there are less than three frequency shifts or if the unit is not known.
 
         """
+        super().__init__([qubit])
+
         if len(frequencies) < 3:
             raise QiskitError("Spectroscopy requires at least three frequencies.")
 
@@ -119,8 +129,6 @@ def __init__(
         else:
             self._frequencies = [apply_prefix(freq, unit) for freq in frequencies]
 
-        super().__init__([qubit])
-
         self._absolute = absolute
 
         if not self._absolute:

test/calibration/experiments/test_rough_frequency.py

@@ -0,0 +1,67 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Rough frequency calibration tests."""
+
+from test.test_qubit_spectroscopy import SpectroscopyBackend
+
+import numpy as np
+
+from qiskit.test import QiskitTestCase
+from qiskit.test.mock import FakeArmonk
+
+from qiskit_experiments.library import RoughFrequencyCal
+from qiskit_experiments.calibration_management import BackendCalibrations
+from qiskit_experiments.calibration_management.basis_gate_library import FixedFrequencyTransmon
+
+
+class TestRoughFrequency(QiskitTestCase):
+    """Tests for the rough frequency calibration experiment."""
+
+    def test_init(self):
+        """Test that initialization."""
+
+        qubit = 1
+        cals = BackendCalibrations(FakeArmonk())
+        frequencies = [1, 2, 3]
+        unit = "kHz"
+        auto_update = False
+        absolute = False
+
+        freq = RoughFrequencyCal(qubit, cals, frequencies, unit, auto_update, absolute)
+
+        self.assertEqual(freq.physical_qubits, (qubit,))
+        self.assertEqual(freq._frequencies, [1000, 2000, 3000])
+        self.assertEqual(freq._absolute, False)
+        self.assertEqual(freq.auto_update, False)
+
+    def test_update_calibrations(self):
+        """Test that we can properly update an instance of BackendCalibrations."""
+
+        freq01 = FakeArmonk().defaults().qubit_freq_est[0]
+
+        backend = SpectroscopyBackend(freq_offset=5e6, line_width=2e6)
+        backend.defaults().qubit_freq_est = [freq01, freq01]
+
+        library = FixedFrequencyTransmon(basis_gates=["x", "sx"])
+        cals = BackendCalibrations(FakeArmonk(), library=library)
+
+        prev_freq = cals.get_parameter_value(cals.__qubit_freq_parameter__, (0,))
+        self.assertEqual(prev_freq, freq01)
+
+        frequencies = np.linspace(freq01 - 10.0e6, freq01 + 10.0e6, 21)
+
+        RoughFrequencyCal(0, cals, frequencies).run(backend).block_for_results()
+
+        # Check the updated frequency which should be shifted by 5MHz.
+        post_freq = cals.get_parameter_value(cals.__qubit_freq_parameter__, (0,))
+        self.assertTrue(abs(post_freq - freq01 - 5e6) < 1e6)

test/calibration/test_base_calibration_experiment.py

@@ -0,0 +1,47 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Tests for the base class for calibration-type experiments."""
+
+from qiskit.test import QiskitTestCase
+
+from qiskit_experiments.library import QubitSpectroscopy
+from qiskit_experiments.calibration_management.calibrations import Calibrations
+from qiskit_experiments.calibration_management.base_calibration_experiment import (
+    BaseCalibrationExperiment,
+)
+
+
+class TestBaseCalibrationClass(QiskitTestCase):
+    """Tests for base calibration experiment classes."""
+
+    def test_class_order(self):
+        """Test warnings when the BaseCalibrationExperiment is not the first parent."""
+
+        class CorrectOrder(BaseCalibrationExperiment, QubitSpectroscopy):
+            """A class with the correct order should not produce warnings.."""
+
+            def __init__(self):
+                """A dummy class for parent order testing."""
+                super().__init__(Calibrations(), 0, [0, 1, 2])
+
+        CorrectOrder()
+
+        with self.assertWarns(Warning):
+
+            # pylint: disable=unused-variable
+            class WrongOrder(QubitSpectroscopy, BaseCalibrationExperiment):
+                """Merely defining this class is enough to raise the warning."""
+
+                def __init__(self):
+                    """A dummy class for parent order testing."""
+                    super().__init__(Calibrations(), 0, [0, 1, 2])