Spectroscopy and calibrations integration V3

qiskit_experiments/calibration/backend_calibrations.py

@@ -40,19 +40,33 @@ class BackendCalibrations(Calibrations):
     any schedule.
     """
 
+    __qubit_freq_parameter__ = "qubit_lo_freq"
+    __readout_freq_parameter__ = "meas_lo_freq"
+
     def __init__(self, backend: Backend):
         """Setup an instance to manage the calibrations of a backend."""
-        super().__init__(backend.configuration().control_channels)
+        if hasattr(backend.configuration(), "control_channels"):
+            control_channels = backend.configuration().control_channels
+        else:
+            control_channels = None
+
+        super().__init__(control_channels)
 
         # Use the same naming convention as in backend.defaults()
-        self.qubit_freq = Parameter("qubit_lo_freq")
-        self.meas_freq = Parameter("meas_lo_freq")
+        self.qubit_freq = Parameter(self.__qubit_freq_parameter__)
+        self.meas_freq = Parameter(self.__readout_freq_parameter__)
         self._register_parameter(self.qubit_freq, ())
         self._register_parameter(self.meas_freq, ())
 
         self._qubits = set(range(backend.configuration().n_qubits))
         self._backend = backend
 
+        for qubit, freq in enumerate(backend.defaults().qubit_freq_est):
+            self.add_parameter_value(freq, self.qubit_freq, qubit)
+
+        for meas, freq in enumerate(backend.defaults().meas_freq_est):
+            self.add_parameter_value(freq, self.meas_freq, meas)
+
     def _get_frequencies(
         self,
         element: FrequencyElement,
@@ -70,8 +84,9 @@ def _get_frequencies(
 
         freqs = []
         for qubit in self._qubits:
-            if ParameterKey(None, param, (qubit,)) in self._params:
-                freq = self.get_parameter_value(param, (qubit,), None, True, group, cutoff_date)
+            schedule = None  # A qubit frequency is not attached to a schedule.
+            if ParameterKey(param, (qubit,), schedule) in self._params:
+                freq = self.get_parameter_value(param, (qubit,), schedule, True, group, cutoff_date)
             else:
                 if element == FrequencyElement.READOUT:
                     freq = self._backend.defaults().meas_freq_est[qubit]

qiskit_experiments/calibration/calibration_key_types.py

@@ -0,0 +1,23 @@
+# 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.
+
+"""Types used by the calibration module."""
+
+from typing import Union
+from collections import namedtuple
+
+from qiskit.circuit import ParameterExpression
+
+
+ParameterKey = namedtuple("ParameterKey", ["parameter", "qubits", "schedule"])
+ScheduleKey = namedtuple("ScheduleKey", ["schedule", "qubits"])
+ParameterValueType = Union[ParameterExpression, float, int, complex]

qiskit_experiments/calibration/calibrations.py

@@ -13,7 +13,7 @@
 """Class to store and manage the results of calibration experiments."""
 
 import os
-from collections import namedtuple, defaultdict
+from collections import defaultdict
 from datetime import datetime
 from typing import Any, Dict, Set, Tuple, Union, List, Optional
 import csv
@@ -37,10 +37,11 @@
 from qiskit.circuit import Parameter, ParameterExpression
 from qiskit_experiments.calibration.exceptions import CalibrationError
 from qiskit_experiments.calibration.parameter_value import ParameterValue
-
-ParameterKey = namedtuple("ParameterKey", ["parameter", "qubits", "schedule"])
-ScheduleKey = namedtuple("ScheduleKey", ["schedule", "qubits"])
-ParameterValueType = Union[ParameterExpression, float, int, complex]
+from qiskit_experiments.calibration.calibration_key_types import (
+    ParameterKey,
+    ParameterValueType,
+    ScheduleKey,
+)
 
 
 class Calibrations:
@@ -545,7 +546,7 @@ def get_parameter_value(
             raise CalibrationError(msg)
 
         # 5) Return the most recent parameter.
-        return max(candidates, key=lambda x: x.date_time).value
+        return max(enumerate(candidates), key=lambda x: (x[1].date_time, x[0]))[1].value
 
     def get_schedule(
         self,
@@ -1025,7 +1026,7 @@ def _to_tuple(qubits: Union[str, int, Tuple[int, ...]]) -> Tuple[int, ...]:
             CalibrationError: If the given input does not conform to an int or
                 tuple of ints.
         """
-        if not qubits:
+        if qubits is None:
             return tuple()
 
         if isinstance(qubits, str):
@@ -1037,6 +1038,9 @@ def _to_tuple(qubits: Union[str, int, Tuple[int, ...]]) -> Tuple[int, ...]:
         if isinstance(qubits, int):
             return (qubits,)
 
+        if isinstance(qubits, list):
+            return tuple(qubits)
+
         if isinstance(qubits, tuple):
             if all(isinstance(n, int) for n in qubits):
                 return qubits

qiskit_experiments/calibration/experiments/rabi.py

@@ -272,7 +272,7 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
             assigned_circ = circuit.assign_parameters({param: amp}, inplace=False)
             assigned_circ.metadata = {
                 "experiment_type": self._type,
-                "qubit": self.physical_qubits[0],
+                "qubits": (self.physical_qubits[0],),
                 "xval": amp,
                 "unit": "arb. unit",
                 "amplitude": amp,

qiskit_experiments/calibration/update_library.py

@@ -0,0 +1,183 @@
+# 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.
+
+"""A library of experiment calibrations."""
+
+from abc import ABC, abstractmethod
+from datetime import datetime
+from typing import List, Tuple, Union
+import numpy as np
+
+from qiskit.circuit import Parameter
+from qiskit.pulse import ScheduleBlock
+
+from qiskit_experiments.experiment_data import ExperimentData
+from qiskit_experiments.calibration.backend_calibrations import BackendCalibrations
+from qiskit_experiments.calibration.calibrations import Calibrations
+from qiskit_experiments.calibration.parameter_value import ParameterValue
+from qiskit_experiments.calibration.exceptions import CalibrationError
+from qiskit_experiments.calibration.calibration_key_types import ParameterValueType
+
+
+class BaseUpdater(ABC):
+    """A base class to update calibrations."""
+
+    def __init__(self):
+        """Updaters are not meant to be instantiated."""
+        raise CalibrationError(
+            "Calibration updaters are not meant to be instantiated. The intended usage"
+            "is Updater.update(calibrations, exp_data, ...)."
+        )
+
+    @staticmethod
+    def _time_stamp(exp_data: ExperimentData) -> datetime:
+        """Helper method to extract the datetime."""
+        all_times = exp_data.completion_times.values()
+        if all_times:
+            return max(all_times)
+
+        return datetime.now()
+
+    @classmethod
+    def _add_parameter_value(
+        cls,
+        cal: Calibrations,
+        exp_data: ExperimentData,
+        value: ParameterValueType,
+        param: Union[Parameter, str],
+        schedule: Union[ScheduleBlock, str] = None,
+        group: str = "default",
+    ):
+        """Update the calibrations with the given value.
+
+        Args:
+            cal: The Calibrations instance to update.
+            exp_data: The ExperimentData instance that contains the result and the experiment data.
+            value: The value extracted by the subclasses in the :meth:`update` method.
+            param: The name of the parameter, or the parameter instance, which will receive an
+                updated value.
+            schedule: The ScheduleBlock instance or the name of the instance to which the parameter
+                is attached.
+            group: The calibrations group to update.
+        """
+
+        qubits = exp_data.data(0)["metadata"]["qubits"]
+
+        param_value = ParameterValue(
+            value=value,
+            date_time=cls._time_stamp(exp_data),
+            group=group,
+            exp_id=exp_data.experiment_id,
+        )
+
+        cal.add_parameter_value(param_value, param, qubits, schedule)
+
+    @classmethod
+    @abstractmethod
+    def update(cls, calibrations: BackendCalibrations, exp_data: ExperimentData, **options):
+        """Update the calibrations based on the data.
+
+        Child update classes must implement this function. This function defines how the data
+        is extracted from an experiment and then used to update the values of one or more
+        parameters in the calibrations.
+        """
+
+
+class Frequency(BaseUpdater):
+    """Update frequencies."""
+
+    # pylint: disable=arguments-differ
+    @classmethod
+    def update(
+        cls,
+        calibrations: BackendCalibrations,
+        exp_data: ExperimentData,
+        result_index: int = -1,
+        group: str = "default",
+        parameter: str = BackendCalibrations.__qubit_freq_parameter__,
+    ):
+        """Update a qubit frequency from, e.g., QubitSpectroscopy.
+
+        Args:
+            calibrations: The calibrations to update.
+            exp_data: The experiment data from which to update.
+            result_index: The result index to use, defaults to -1.
+            group: The calibrations group to update. Defaults to "default."
+            parameter: The name of the parameter to update. If it is not specified
+                this will default to the qubit frequency.
+
+        Raises:
+            CalibrationError: If the analysis result does not contain a frequency variable.
+        """
+
+        from qiskit_experiments.characterization.qubit_spectroscopy import SpectroscopyAnalysis
+
+        result = exp_data.analysis_result(result_index)
+
+        if "freq" not in result["popt_keys"]:
+            raise CalibrationError(
+                f"{cls.__name__} updates from analysis classes such as "
+                f'{type(SpectroscopyAnalysis.__name__)} which report "freq" in popt.'
+            )
+
+        param = parameter
+        value = result["popt"][result["popt_keys"].index("freq")]
+
+        cls._add_parameter_value(calibrations, exp_data, value, param, schedule=None, group=group)
+
+
+class Amplitude(BaseUpdater):
+    """Update pulse amplitudes."""
+
+    # pylint: disable=arguments-differ
+    @classmethod
+    def update(
+        cls,
+        calibrations: Calibrations,
+        exp_data: ExperimentData,
+        result_index: int = -1,
+        group: str = "default",
+        angles_schedules: List[Tuple[float, str, Union[str, ScheduleBlock]]] = None,
+    ):
+        """Update the amplitude of pulses.
+
+        Args:
+            calibrations: The calibrations to update.
+            exp_data: The experiment data from which to update.
+            result_index: The result index to use, defaults to -1.
+            group: The calibrations group to update. Defaults to "default."
+            angles_schedules: A list of tuples specifying which angle to update for which
+                pulse schedule. Each tuple is of the form: (angle, parameter_name,
+                schedule). Here, angle is the rotation angle for which to extract the amplitude,
+                parameter_name is the name of the parameter whose value is to be updated, and
+                schedule is the schedule or its name that contains the parameter.
+
+        Raises:
+            CalibrationError: If the experiment is not of the supported type.
+        """
+        from qiskit_experiments.calibration.experiments.rabi import Rabi
+
+        if angles_schedules is None:
+            angles_schedules = [(np.pi, "amp", "xp")]
+
+        if isinstance(exp_data.experiment, Rabi):
+            result = exp_data.analysis_result(result_index)
+
+            freq = result["popt"][result["popt_keys"].index("freq")]
+            rate = 2 * np.pi * freq
+
+            for angle, param, schedule in angles_schedules:
+                value = np.round(angle / rate, decimals=8)
+
+                cls._add_parameter_value(calibrations, exp_data, value, param, schedule, group)
+        else:
+            raise CalibrationError(f"{cls.__name__} updates from {type(Rabi.__name__)}.")

qiskit_experiments/characterization/qubit_spectroscopy.py

@@ -316,10 +316,12 @@ def circuits(self, backend: Optional[Backend] = None):
             if not self._absolute:
                 freq += center_freq
 
+            freq = np.round(freq, decimals=3)
+
             assigned_circ = circuit.assign_parameters({freq_param: freq}, inplace=False)
             assigned_circ.metadata = {
                 "experiment_type": self._type,
-                "qubit": self.physical_qubits[0],
+                "qubits": (self.physical_qubits[0],),
                 "xval": freq,
                 "unit": "Hz",
                 "amplitude": self.experiment_options.amp,

qiskit_experiments/experiment_data.py

@@ -17,6 +17,7 @@
 import os
 import uuid
 from collections import OrderedDict
+from datetime import datetime
 
 from qiskit.result import Result
 from qiskit.providers import Backend
@@ -116,6 +117,16 @@ def job_ids(self) -> List[str]:
         """
         return list(self._jobs.keys())
 
+    @property
+    def completion_times(self) -> Dict[str, datetime]:
+        """Returns the completion times of the jobs."""
+        job_times = {}
+        for job_id, job in self._jobs.items():
+            if job is not None and "COMPLETED" in job.time_per_step():
+                job_times[job_id] = job.time_per_step().get("COMPLETED")
+
+        return job_times
+
     @property
     def backend(self) -> Backend:
         """Return backend.