Analysis refactor part 2

docs/tutorials/quantum_volume.ipynb

@@ -223,7 +223,7 @@
     "qv_exp.set_experiment_options(trials=60)\n",
     "expdata2 = qv_exp.run(backend, analysis=False).block_for_results()\n",
     "expdata2.add_data(expdata.data())\n",
-    "qv_exp.run_analysis(expdata2).block_for_results()\n",
+    "qv_exp.analysis.run(expdata2).block_for_results()\n",
     "\n",
     "# View result data\n",
     "display(expdata2.figure(0))\n",

docs/tutorials/randomized_benchmarking.ipynb

@@ -181,7 +181,7 @@
     "exp2 = StandardRB(qubits, lengths, num_samples=num_samples, seed=seed)\n",
     "\n",
     "# Use the EPG data of the 1-qubit runs to ensure correct 2-qubit EPG computation\n",
-    "exp2.set_analysis_options(epg_1_qubit=epg_1q)\n",
+    "exp2.analysis.set_options(epg_1_qubit=epg_1q)\n",
     "\n",
     "# Run the 2-qubit experiment\n",
     "expdata2 = exp2.run(backend).block_for_results()\n",

docs/tutorials/state_tomography.ipynb

@@ -300,7 +300,7 @@
     "    import cvxpy\n",
     "    \n",
     "    # Set analysis option for cvxpy fitter\n",
-    "    qstexp1.set_analysis_options(fitter='cvxpy_gaussian_lstsq')\n",
+    "    qstexp1.analysis.set_options(fitter='cvxpy_gaussian_lstsq')\n",
     "    \n",
     "    # Re-run experiment\n",
     "    qstdata2 = qstexp1.run(backend, seed_simulation=100).block_for_results()\n",

docs/tutorials/t2ramsey_characterization.ipynb

@@ -258,7 +258,7 @@
     "    \"B\": 0.5\n",
     "        }\n",
     "exp_with_p0 = T2Ramsey(qubit, delays, unit=unit, osc_freq=1e5)\n",
-    "exp_with_p0.set_analysis_options(p0=user_p0)\n",
+    "exp_with_p0.analysis.set_options(p0=user_p0)\n",
     "expdata_with_p0 = exp_with_p0.run(backend=backend, shots=2000)\n",
     "expdata_with_p0.block_for_results()\n",
     "\n",
@@ -380,7 +380,7 @@
     "    \"phi\": 0,\n",
     "    \"B\": 0.5\n",
     "}\n",
-    "exp_in_ns.set_analysis_options(p0=user_p0_ns)\n",
+    "exp_in_ns.analysis.set_options(p0=user_p0_ns)\n",
     "\n",
     "# Run experiment\n",
     "expdata_in_ns = exp_in_ns.run(backend=backend_in_ns, shots=2000).block_for_results()\n",

qiskit_experiments/calibration_management/base_calibration_experiment.py

@@ -79,9 +79,6 @@ class should be this mixin and the second class should be the characterization
     :mod:`qiskit_experiments.calibration_management.update_library`. See also
     :class:`qiskit_experiments.calibration_management.update_library.BaseUpdater`. If no updater
     is specified the experiment will still run but no update of the calibrations will be performed.
-
-    In addition to the calibration specific requirements, the developer must set the analysis method
-    with the class variable :code:`__analysis_class__` and any default experiment options.
     """
 
     def __init_subclass__(cls, **kwargs):

qiskit_experiments/curve_analysis/standard_analysis/resonance.py

@@ -17,6 +17,7 @@
 import numpy as np
 
 import qiskit_experiments.curve_analysis as curve
+from qiskit_experiments.framework import Options
 
 
 class ResonanceAnalysis(curve.CurveAnalysis):
@@ -67,6 +68,16 @@ class ResonanceAnalysis(curve.CurveAnalysis):
         )
     ]
 
+    @classmethod
+    def _default_options(cls) -> Options:
+        options = super()._default_options()
+        options.result_parameters = [curve.ParameterRepr("freq", "f01", "Hz")]
+        options.normalization = True
+        options.xlabel = "Frequency"
+        options.ylabel = "Signal (arb. units)"
+        options.xval_unit = "Hz"
+        return options
+
     def _generate_fit_guesses(
         self, user_opt: curve.FitOptions
     ) -> Union[curve.FitOptions, List[curve.FitOptions]]:

qiskit_experiments/framework/__init__.py

@@ -151,9 +151,6 @@
   Arguments in the constructor can be overridden so that a subclass can
   be initialized with some experiment configuration.
 
-- Set :attr:`BaseExperiment.__analysis_class__` class attribute to
-  specify the :class:`BaseAnalysis` subclass for analyzing result data.
-
 Optionally the following methods can also be overridden in the subclass to
 allow configuring various experiment and execution options
 

qiskit_experiments/framework/base_experiment.py

@@ -17,6 +17,7 @@
 import copy
 from collections import OrderedDict
 from typing import Sequence, Optional, Tuple, List, Dict, Union, Any
+import warnings
 
 from qiskit import transpile, assemble, QuantumCircuit
 from qiskit.providers import BaseJob
@@ -26,26 +27,18 @@
 from qiskit.qobj.utils import MeasLevel
 from qiskit.providers.options import Options
 from qiskit_experiments.framework.store_init_args import StoreInitArgs
+from qiskit_experiments.framework.base_analysis import BaseAnalysis
 from qiskit_experiments.framework.experiment_data import ExperimentData
 from qiskit_experiments.framework.configs import ExperimentConfig
 
 
 class BaseExperiment(ABC, StoreInitArgs):
-    """Abstract base class for experiments.
-
-    Class Attributes:
-
-        __analysis_class__: Optional, the default Analysis class to use for
-                            data analysis. If None no data analysis will be
-                            done on experiment data (Default: None).
-    """
-
-    # Analysis class for experiment
-    __analysis_class__ = None
+    """Abstract base class for experiments."""
 
     def __init__(
         self,
         qubits: Sequence[int],
+        analysis: Optional[BaseAnalysis] = None,
         backend: Optional[Backend] = None,
         experiment_type: Optional[str] = None,
     ):
@@ -72,14 +65,29 @@ def __init__(
         self._experiment_options = self._default_experiment_options()
         self._transpile_options = self._default_transpile_options()
         self._run_options = self._default_run_options()
-        self._analysis_options = self._default_analysis_options()
 
         # Store keys of non-default options
         self._set_experiment_options = set()
         self._set_transpile_options = set()
         self._set_run_options = set()
         self._set_analysis_options = set()
 
+        # Set analysis
+        self._analysis = None
+        if analysis:
+            self.analysis = analysis
+        # TODO: Hack for backwards compatibility with old base class.
+        # Remove after updating subclasses
+        elif hasattr(self, "__analysis_class__"):
+            warnings.warn(
+                "Defining a default BaseAnalysis class for an experiment using the "
+                "__analysis_class__ attribute is deprecated as of 0.2.0. "
+                "Use the `analysis` kwarg of BaseExperiment.__init__ "
+                "to specify a default analysis class."
+            )
+            analysis_cls = getattr(self, "__analysis_class__")
+            self.analysis = analysis_cls()  # pylint: disable = not-callable
+
         # Set backend
         # This should be called last incase `_set_backend` access any of the
         # attributes created during initialization
@@ -102,6 +110,18 @@ def num_qubits(self) -> int:
         """Return the number of qubits for the experiment."""
         return self._num_qubits
 
+    @property
+    def analysis(self) -> Union[BaseAnalysis, None]:
+        """Return the analysis class for the experiment"""
+        return self._analysis
+
+    @analysis.setter
+    def analysis(self, analysis: Union[BaseAnalysis, None]) -> None:
+        """Set the backend for the experiment"""
+        if not isinstance(analysis, BaseAnalysis):
+            raise TypeError("Input is not a BaseAnalysis subclass.")
+        self._analysis = analysis
+
     @property
     def backend(self) -> Union[Backend, None]:
         """Return the backend for the experiment"""
@@ -110,6 +130,8 @@ def backend(self) -> Union[Backend, None]:
     @backend.setter
     def backend(self, backend: Union[Backend, None]) -> None:
         """Set the backend for the experiment"""
+        if not isinstance(backend, (Backend, BaseBackend)):
+            raise TypeError("Input is not a backend.")
         self._set_backend(backend)
 
     def _set_backend(self, backend: Backend):
@@ -126,15 +148,16 @@ def copy(self) -> "BaseExperiment":
         # need to also copy the Options structures so that if they are
         # updated on the copy they don't effect the original.
         ret = copy.copy(self)
+        if self._analysis:
+            ret._analysis = self._analysis.copy()
+
         ret._experiment_options = copy.copy(self._experiment_options)
         ret._run_options = copy.copy(self._run_options)
         ret._transpile_options = copy.copy(self._transpile_options)
-        ret._analysis_options = copy.copy(self._analysis_options)
 
         ret._set_experiment_options = copy.copy(self._set_experiment_options)
         ret._set_transpile_options = copy.copy(self._set_transpile_options)
         ret._set_run_options = copy.copy(self._set_run_options)
-        ret._set_analysis_options = copy.copy(self._set_analysis_options)
         return ret
 
     def config(self) -> ExperimentConfig:
@@ -222,8 +245,8 @@ def run(
         experiment._add_job_metadata(experiment_data.metadata, jobs, **run_opts)
 
         # Optionally run analysis
-        if analysis and self.__analysis_class__ is not None:
-            return self.run_analysis(experiment_data)
+        if analysis and self._analysis is not None:
+            return self.analysis.run(experiment_data)
         else:
             return experiment_data
 
@@ -238,6 +261,11 @@ def run_analysis(
 
         See :meth:`BaseAnalysis.run` for additional information.
 
+        .. deprecated:: 0.2.0
+            This is replaced by calling ``experiment.analysis.run`` using
+            the :meth:`analysis` property and
+            :meth:`~qiskit_experiments.framework.BaseAnalysis.run` method.
+
         Args:
             experiment_data: the experiment data to analyze.
             replace_results: if True clear any existing analysis results and
@@ -253,14 +281,13 @@ def run_analysis(
         Raises:
             QiskitError: if experiment_data container is not valid for analysis.
         """
-        # Get analysis options
-        analysis_options = copy.copy(self.analysis_options)
-        analysis_options.update_options(**options)
-        analysis_options = analysis_options.__dict__
-
-        # Run analysis
-        analysis = self.analysis()
-        return analysis.run(experiment_data, replace_results=replace_results, **analysis_options)
+        warnings.warn(
+            "`BaseExperiment.run_analysis` is deprecated as of qiskit-experiments"
+            " 0.2.0 and will be removed in the 0.3.0 release."
+            " Use `experiment.analysis.run` instead",
+            DeprecationWarning,
+        )
+        return self.analysis.run(experiment_data, replace_results=replace_results, **options)
 
     def _run_jobs(self, circuits: List[QuantumCircuit], **run_options) -> List[BaseJob]:
         """Run circuits on backend as 1 or more jobs."""
@@ -286,14 +313,6 @@ def _run_jobs(self, circuits: List[QuantumCircuit], **run_options) -> List[BaseJ
             jobs.append(job)
         return jobs
 
-    @classmethod
-    def analysis(cls):
-        """Return the default Analysis class for the experiment."""
-        if cls.__analysis_class__ is None:
-            raise QiskitError(f"Experiment {cls.__name__} does not have a default Analysis class")
-        # pylint: disable = not-callable
-        return cls.__analysis_class__()
-
     @abstractmethod
     def circuits(self) -> List[QuantumCircuit]:
         """Return a list of experiment circuits.
@@ -391,29 +410,41 @@ def set_run_options(self, **fields):
         self._run_options.update_options(**fields)
         self._set_run_options = self._set_run_options.union(fields)
 
-    @classmethod
-    def _default_analysis_options(cls) -> Options:
-        """Default options for analysis of experiment results."""
-        # Experiment subclasses can override this method if they need
-        # to set specific analysis options defaults that are different
-        # from the Analysis subclass `_default_options` values.
-        if cls.__analysis_class__:
-            return cls.__analysis_class__._default_options()
-        return Options()
-
     @property
     def analysis_options(self) -> Options:
-        """Return the analysis options for :meth:`run` analysis."""
-        return self._analysis_options
+        """Return the analysis options for :meth:`run` analysis.
+
+        .. deprecated:: 0.2.0
+            This is replaced by calling ``experiment.analysis.options`` using
+            the :meth:`analysis`and :meth:`~qiskit_experiments.framework.BaseAnalysis.options`
+            properties.
+        """
+        warnings.warn(
+            "`BaseExperiment.analysis_options` is deprecated as of qiskit-experiments"
+            " 0.2.0 and will be removed in the 0.3.0 release."
+            " Use `experiment.analysis.options instead",
+            DeprecationWarning,
+        )
+        return self._analysis.options
 
     def set_analysis_options(self, **fields):
         """Set the analysis options for :meth:`run` method.
 
         Args:
             fields: The fields to update the options
+
+        .. deprecated:: 0.2.0
+            This is replaced by calling ``experiment.analysis.set_options`` using
+            the :meth:`analysis` property and
+            :meth:`~qiskit_experiments.framework.BaseAnalysis.set_options` method.
         """
-        self._analysis_options.update_options(**fields)
-        self._set_analysis_options = self._set_analysis_options.union(fields)
+        warnings.warn(
+            "`BaseExperiment.set_analysis_options` is deprecated as of qiskit-experiments"
+            " 0.2.0 and will be removed in the 0.3.0 release."
+            " Use `experiment.analysis.set_options instead",
+            DeprecationWarning,
+        )
+        self._analysis.options.update_options(**fields)
 
     def _postprocess_transpiled_circuits(self, circuits: List[QuantumCircuit], **run_options):
         """Additional post-processing of transpiled circuits before running on backend"""
@@ -452,15 +483,16 @@ def _add_job_metadata(self, metadata: Dict[str, Any], jobs: BaseJob, **run_optio
             jobs: the job objects.
             run_options: backend run options for the job.
         """
-        metadata["job_metadata"] = [
-            {
-                "job_ids": [job.job_id() for job in jobs],
-                "experiment_options": copy.copy(self.experiment_options.__dict__),
-                "transpile_options": copy.copy(self.transpile_options.__dict__),
-                "analysis_options": copy.copy(self.analysis_options.__dict__),
-                "run_options": copy.copy(run_options),
-            }
-        ]
+        values = {
+            "job_ids": [job.job_id() for job in jobs],
+            "experiment_options": copy.copy(self.experiment_options.__dict__),
+            "transpile_options": copy.copy(self.transpile_options.__dict__),
+            "run_options": copy.copy(run_options),
+        }
+        if self._analysis is not None:
+            values["analysis_options"] = copy.copy(self.analysis.options.__dict__)
+
+        metadata["job_metadata"] = [values]
 
     def __json_encode__(self):
         """Convert to format that can be JSON serialized"""

qiskit_experiments/framework/composite/composite_analysis.py

@@ -83,7 +83,7 @@ def _run_analysis(self, experiment_data: ExperimentData):
             # Run analysis
             # Since copy for replace result is handled at the parent level
             # we always run with replace result on component analysis
-            sub_exp.run_analysis(sub_exp_data, replace_results=True)
+            sub_exp.analysis.run(sub_exp_data, replace_results=True)
 
             # Record the component experiment id and type as an analysis result
             # for evidence analysis has started and to display in the service DB

qiskit_experiments/framework/composite/composite_experiment.py

@@ -24,8 +24,6 @@
 class CompositeExperiment(BaseExperiment):
     """Composite Experiment base class"""
 
-    __analysis_class__ = CompositeAnalysis
-
     def __init__(
         self,
         experiments: List[BaseExperiment],
@@ -43,7 +41,12 @@ def __init__(
         """
         self._experiments = experiments
         self._num_experiments = len(experiments)
-        super().__init__(qubits, backend=backend, experiment_type=experiment_type)
+        super().__init__(
+            qubits,
+            analysis=CompositeAnalysis(),
+            backend=backend,
+            experiment_type=experiment_type,
+        )
 
     @abstractmethod
     def circuits(self):