Simply analysis options

* Remove `set_options` from `BaseAnalysis`
* Add `run_analysis` method to `BaseExperiment` that uses experiment `analysis_options`.
* Rename `backend_options` to `run_options`

Author: chriseclectic

qiskit_experiments/base_analysis.py

@@ -24,56 +24,34 @@
 
 
 class BaseAnalysis(ABC):
-    """Base Analysis class for analyzing Experiment data."""
+    """Base Analysis class for analyzing Experiment data.
+
+    When designing Analysis subclasses default values for any kwarg
+    analysis options of the `run` method should be set by overriding
+    the `_default_options` class method. When calling `run` these
+    default values will combined with all other option kwargs in the
+    run method and passed to the `_run_analysis` function.
+    """
 
     # Expected experiment data container for analysis
     __experiment_data__ = ExperimentData
 
-    def __init__(self, **options):
-        """Initialize a base analysis class
-
-        Args:
-            options: kwarg options for analysis.
-        """
-        self._options = self._default_options()
-        self.set_options(**options)
-
     @classmethod
     def _default_options(cls) -> Options:
         return Options()
 
-    def set_options(self, **fields):
-        """Set the analysis options.
-
-        Args:
-            fields: The fields to update the options
-        """
-        self._options.update_options(**fields)
-
-    @property
-    def options(self) -> Options:
-        """Return the analysis options.
-
-        The options of an analysis class are used to provide kwarg values for
-        the :meth:`run` method.
-        """
-        return self._options
-
-    def run(self,
-            experiment_data: ExperimentData,
-            save: bool = True,
-            return_figures: bool = False,
-            **options):
-        """Run analysis and update stored ExperimentData with analysis result.
+    def run(self, experiment_data, save=True, return_figures=False, **options):
+        """Run analysis and update ExperimentData with analysis result.
 
         Args:
-            experiment_data: the experiment data to analyze.
-            save: if True save analysis results and figures to the
-                  :class:`ExperimentData`.
-            return_figures: if true return a pair of ``(analysis_results, figures)``,
-                            otherwise return only analysis_results.
-            options: additional analysis options. Any values set here will
-                     override the value from :meth:`options` for the current run.
+            experiment_data (ExperimentData): the experiment data to analyze.
+            save (bool): if True save analysis results and figures to the
+                         :class:`ExperimentData`.
+            return_figures (bool): if true return a pair of
+                                   ``(analysis_results, figures)``,
+                                    otherwise return only analysis_results.
+            options: additional analysis options. See class documentation for
+                     supported options.
 
         Returns:
             AnalysisResult: the output of the analysis that produces a
@@ -93,9 +71,8 @@ def run(self,
                 f"Invalid experiment data type, expected {self.__experiment_data__.__name__}"
                 f" but received {type(experiment_data).__name__}"
             )
-
-        # Get runtime analysis options
-        analysis_options = copy.copy(self.options)
+        # Get analysis options
+        analysis_options = self._default_options()
         analysis_options.update_options(**options)
         analysis_options = analysis_options.__dict__
 

qiskit_experiments/base_experiment.py

@@ -48,14 +48,13 @@ class BaseExperiment(ABC):
     # ExperimentData class for experiment
     __experiment_data__ = ExperimentData
 
-    def __init__(self, qubits: Iterable[int], experiment_type: Optional[str] = None, **options):
+    def __init__(self, qubits: Iterable[int], experiment_type: Optional[str] = None):
         """Initialize the experiment object.
 
         Args:
             qubits: the number of qubits or list of physical qubits for
                     the experiment.
             experiment_type: Optional, the experiment type string.
-            options: kwarg options for experiment circuits.
 
         Raises:
             QiskitError: if qubits is a list and contains duplicates.
@@ -76,11 +75,8 @@ def __init__(self, qubits: Iterable[int], experiment_type: Optional[str] = None,
 
         # Experiment options
         self._options = self._default_options()
-        self.set_options(**options)
-
-        # Execution and analysis options
         self._transpile_options = self._default_transpile_options()
-        self._backend_options = self._default_backend_options()
+        self._run_options = self._default_run_options()
         self._analysis_options = self._default_analysis_options()
 
         # Set initial layout from qubits
@@ -91,7 +87,7 @@ def run(
         backend: Backend,
         analysis: bool = True,
         experiment_data: Optional[ExperimentData] = None,
-        **kwargs,
+        **run_options,
     ) -> ExperimentData:
         """Run an experiment and perform analysis.
 
@@ -101,7 +97,7 @@ def run(
             experiment_data: Optional, add results to existing
                 experiment data. If None a new ExperimentData object will be
                 returned.
-            kwargs: runtime keyword arguments for backend.run.
+            run_options: backend runtime options used for circuit execution.
 
         Returns:
             The experiment data object.
@@ -116,27 +112,61 @@ def run(
         )
 
         # Run circuits on backend
-        run_options = copy.copy(self.backend_options)
-        run_options.update_options(**kwargs)
-        run_options = run_options.__dict__
+        run_opts = copy.copy(self.run_options)
+        run_opts.update_options(**run_options)
+        run_opts = run_opts.__dict__
 
         if isinstance(backend, LegacyBackend):
-            qobj = assemble(circuits, backend=backend, **run_options)
+            qobj = assemble(circuits, backend=backend, **run_opts)
             job = backend.run(qobj)
         else:
-            job = backend.run(circuits, **run_options)
+            job = backend.run(circuits, **run_opts)
 
         # Add Job to ExperimentData
         experiment_data.add_data(job)
 
         # Queue analysis of data for when job is finished
         if analysis and self.__analysis_class__ is not None:
-            # pylint: disable = not-callable
-            self.analysis(**self.analysis_options.__dict__).run(experiment_data)
+            self.run_analysis(experiment_data)
 
         # Return the ExperimentData future
         return experiment_data
 
+    def run_analysis(
+        self, experiment_data, save=True, return_figures=False, **options
+    ) -> ExperimentData:
+        """Run analysis and update ExperimentData with analysis result.
+
+        Args:
+            experiment_data (ExperimentData): the experiment data to analyze.
+            save (bool): if True save analysis results and figures to the
+                         :class:`ExperimentData`.
+            return_figures (bool): if true return a pair of
+                                   ``(analysis_results, figures)``,
+                                    otherwise return only analysis_results.
+            options: additional analysis options. Any values set here will
+                     override the value from :meth:`analysis_options`
+                     for the current run.
+
+        Returns:
+            The updated experiment data containing the analysis results and figures.
+
+        Raises:
+            QiskitError: if experiment_data container is not valid for analysis.
+        """
+        if self.__analysis_class__ is None:
+            raise QiskitError(f"Experiment {self._type} does not have a default Analysis class")
+
+        # 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_class__()
+        analysis.run(experiment_data, **analysis_options)
+        return experiment_data
+
     @property
     def num_qubits(self) -> int:
         """Return the number of qubits for this experiment."""
@@ -148,12 +178,12 @@ def physical_qubits(self) -> Tuple[int]:
         return self._physical_qubits
 
     @classmethod
-    def analysis(cls, **analysis_options) -> "BaseAnalysis":
+    def analysis(cls, **kwargs) -> "BaseAnalysis":
         """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__(**analysis_options)
+        return cls.__analysis_class__(**kwargs)
 
     @abstractmethod
     def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
@@ -248,22 +278,22 @@ def set_transpile_options(self, **fields):
         self._transpile_options.update_options(**fields)
 
     @classmethod
-    def _default_backend_options(cls) -> Options:
-        """Default backend options for running experiment"""
+    def _default_run_options(cls) -> Options:
+        """Default options values for the experiment :meth:`run` method."""
         return Options()
 
     @property
-    def backend_options(self) -> Options:
-        """Return the backend options for the :meth:`run` method."""
-        return self._backend_options
+    def run_options(self) -> Options:
+        """Return options values for the experiment :meth:`run` method."""
+        return self._run_options
 
-    def set_backend_options(self, **fields):
-        """Set the backend options for the :meth:`run` method.
+    def set_run_options(self, **fields):
+        """Set options values for the experiment  :meth:`run` method.
 
         Args:
             fields: The fields to update the options
         """
-        self._backend_options.update_options(**fields)
+        self._run_options.update_options(**fields)
 
     @classmethod
     def _default_analysis_options(cls) -> Options:
@@ -273,7 +303,7 @@ def _default_analysis_options(cls) -> Options:
         # from the Analysis subclass `_default_options` values.
         if cls.__analysis_class__:
             return cls.__analysis_class__._default_options()
-        return None
+        return Options()
 
     @property
     def analysis_options(self) -> Options:

qiskit_experiments/characterization/t1_experiment.py

@@ -230,7 +230,12 @@ def __init__(
         """
         if len(delays) < 3:
             raise ValueError("T1 experiment: number of delays must be at least 3")
-        super().__init__([qubit], delays=delays, unit=unit)
+
+        # Initialize base experiment
+        super().__init__([qubit])
+
+        # Set experiment options
+        self.set_options(delays=delays, unit=unit)
 
     def circuits(self, backend: Optional["Backend"] = None) -> List[QuantumCircuit]:
         """

qiskit_experiments/composite/composite_analysis.py

@@ -47,7 +47,7 @@ def _run_analysis(self, experiment_data: CompositeExperimentData, **options):
         for expr, expr_data in zip(
             experiment_data._experiment._experiments, experiment_data._composite_expdata
         ):
-            expr.analysis(**expr.analysis_options.__dict__).run(expr_data, **options)
+            expr.run_analysis(expr_data, **options)
 
         # Add sub-experiment metadata as result of batch experiment
         # Note: if Analysis results had ID's these should be included here

qiskit_experiments/randomized_benchmarking/rb_experiment.py

@@ -28,7 +28,7 @@
 
 class RBExperiment(BaseExperiment):
     """RB Experiment class.
-    
+
     Experiment Options:
         lengths: A list of RB sequences lengths.
         num_samples: number of samples to generate for each sequence length.
@@ -59,12 +59,18 @@ def __init__(
                            sequences are constructed by appending additional
                            Clifford samples to shorter sequences.
         """
+        # Initialize base experiment
+        super().__init__(qubits)
+
+        # Set configurable options
+        self.set_options(lengths=list(lengths), num_samples=num_samples)
+
+        # Set fixed options
+        self._full_sampling = full_sampling
         if not isinstance(seed, Generator):
             self._rng = default_rng(seed=seed)
         else:
             self._rng = seed
-        self._full_sampling = full_sampling
-        super().__init__(qubits, lenghs=list(lengths), num_samples=num_samples)
 
     @classmethod
     def _default_options(cls):