From ab027ce681854b1e592adba6307523a1ddb16fb2 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 11 May 2021 02:27:08 +0900
Subject: [PATCH 01/74] wip curve fit analysis

---
 qiskit_experiments/analysis/curve_analysis.py | 269 ++++++++++++++++++
 1 file changed, 269 insertions(+)
 create mode 100644 qiskit_experiments/analysis/curve_analysis.py

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
new file mode 100644
index 0000000000..3a412dc4a3
--- /dev/null
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -0,0 +1,269 @@
+# 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.
+"""
+Analysis class for curve fitting.
+"""
+
+from abc import abstractmethod, abstractstaticmethod
+from typing import Any, NamedTuple, Dict, List, Optional, Tuple, Callable
+
+import numpy as np
+import scipy.optimize as opt
+from qiskit.exceptions import QiskitError
+
+from qiskit_experiments.base_analysis import BaseAnalysis
+from qiskit_experiments.data_processing.exceptions import DataProcessorError
+from qiskit_experiments.experiment_data import AnalysisResult, ExperimentData
+
+# Description of data properties for single curve entry
+Series = NamedTuple(
+    "Series",
+    [
+        ("name", str),
+        ("param_names", List[str]),
+        ("fit_func", int),
+        ("filter_kwargs", Optional[Dict[str, Any]]),
+    ],
+)
+
+# Human readable data set for single curve entry
+CurveEntry = NamedTuple(
+    "CurveEntry",
+    [
+        ("curve_name", str),
+        ("x_values", np.ndarray),
+        ("y_values", np.ndarray),
+        ("y_sigmas", np.ndarray)
+    ]
+)
+
+
+class CurveAnalysis(BaseAnalysis):
+
+    #: str: Metadata key representing a scanned value.
+    __x_key__ = ""
+
+    #: List[Series]: List of mapping representing a data series
+    __series__ = None
+
+    #: Callable: Data processor
+    __data_processor__ = None
+
+    #: List[Callable]: A callback function to define the expected curve
+    __fit_funcs__ = None
+
+    #: List[str]: Parameter name list
+    __param_names__ = list()
+
+    # TODO data processor may be initialized with some variables.
+    # For example, if it contains front end discriminator, it may be initialized with
+    # some discrimination line parameters. These parameters cannot be hard-coded here.
+
+    def _run_analysis(self, experiment_data, **options):
+        """Run analysis on circuit data.
+
+        Args:
+            experiment_data (ExperimentData): the experiment data to analyze.
+            options: kwarg options for analysis function.
+
+        Returns:
+            tuple: A pair ``(analysis_results, figures)`` where
+                   ``analysis_results`` may be a single or list of
+                   AnalysisResult objects, and ``figures`` may be
+                   None, a single figure, or a list of figures.
+        """
+        analysis_result = AnalysisResult()
+        figures = list()
+
+        try:
+            curve_data = self._data_processing(experiment_data)
+            # TODO this data should be kept in somewhere in analysis result
+            # however the raw data may be avoided to be saved in remote database
+        except DataProcessorError:
+            analysis_result["success"] = False
+            return analysis_result, figures
+
+        try:
+            fit_data = self._run_fitting(curve_data=curve_data)
+            analysis_result.update(fit_data)
+            analysis_result["success"] = True
+        except Exception:
+            analysis_result["success"] = False
+
+        figures = self._create_figure(curve_data=curve_data, fit_data=analysis_result)
+
+        return analysis_result, figures
+
+    def _data_processing(self, experiment_data: ExperimentData) -> List[CurveEntry]:
+        """Extract curve data from experiment data.
+
+        Args:
+            experiment_data: ExperimentData object to fit parameters.
+
+        Returns:
+            List of ``CurveEntry`` containing x-values, y-values, and y values sigma.
+        """
+        if self.__series__:
+            series = self.__series__
+        else:
+            series = [
+                Series(
+                    name="",
+                    param_names=self.__param_names__,
+                    fit_func=0,
+                    filter_kwargs=None,
+                )
+            ]
+
+        def _is_target_series(datum, **filters):
+            try:
+                return all(datum["metadata"][key] == val for key, val in filters.items())
+            except KeyError:
+                return False
+
+        curve_data = list()
+        for line_attributes in series:
+            if line_attributes.filter_kwargs:
+                # filter data
+                series_data = [
+                    datum
+                    for datum in experiment_data.data
+                    if _is_target_series(datum, **line_attributes.filter_kwargs)
+                ]
+            else:
+                # use data as-is
+                series_data = experiment_data
+            xvals, yvals, sigmas = self.__data_processor__(series_data)
+            # TODO data processor may need calibration.
+            # If we use the level1 data, it may be necessary to calculate principal component
+            # with entire scan data. Otherwise we need to use real or imaginary part.
+
+            curve_data.append(
+                CurveEntry(
+                    curve_name=line_attributes.name,
+                    x_values=xvals,
+                    y_values=yvals,
+                    y_sigmas=sigmas,
+                )
+            )
+
+        return curve_data
+
+    @abstractstaticmethod
+    def _initial_guess(xdata: np.ndarray, ydata: np.ndarray, **kwargs) -> np.ndarray:
+        pass
+
+    @abstractmethod
+    def _run_fitting(self, curve_data: List[CurveEntry]):
+        pass
+
+    @abstractmethod
+    def _create_figure(self, curve_data: List[CurveEntry], fit_data: AnalysisResult):
+        pass
+
+    def _series_fit(self, curve_data: List[CurveEntry], **kwargs):
+        pass
+
+    @staticmethod
+    def _single_curve_fit(
+        func: Callable,
+        xdata: np.ndarray,
+        ydata: np.ndarray,
+        p0: np.ndarray,
+        sigma: Optional[np.ndarray] = None,
+        bounds: Optional[Tuple[np.ndarray, np.ndarray]] = None,
+        **kwargs,
+    ) -> AnalysisResult:
+        r"""Perform a non-linear least squares to fit
+
+        This solves the optimization problem
+
+        .. math::
+            \Theta_{\mbox{opt}} = \arg\min_\Theta \sum_i \sigma_i^{-2} (f(x_i, \Theta) -  y_i)^2
+
+        using ``scipy.optimize.curve_fit``.
+
+        Args:
+            func: a fit function `f(x, *params)`.
+            xdata: a 1D float array of x-data.
+            ydata: a 1D float array of y-data.
+            p0: initial guess for optimization parameters.
+            sigma: Optional, a 1D array of standard deviations in ydata in absolute units.
+            bounds: Optional, lower and upper bounds for optimization parameters.
+            kwargs: additional kwargs for scipy.optimize.curve_fit.
+
+        Returns:
+            result containing ``popt`` the optimal fit parameters,
+            ``popt_err`` the standard error estimates popt,
+            ``pcov`` the covariance matrix for the fit,
+            ``reduced_chisq`` the reduced chi-squared parameter of fit,
+            ``dof`` the degrees of freedom of the fit,
+            ``xrange`` the range of xdata values used for fit.
+
+        Raises:
+            QiskitError: if the number of degrees of freedom of the fit is
+                         less than 1.
+
+        .. note::
+            ``sigma`` is assumed to be specified in the same units as ``ydata``
+            (absolute units). If sigma is instead specified in relative units
+            the `absolute_sigma=False` kwarg of scipy curve_fit must be used.
+            This affects the returned covariance ``pcov`` and error ``popt_err``
+            parameters via ``pcov(absolute_sigma=False) = pcov * reduced_chisq``
+            ``popt_err(absolute_sigma=False) = popt_err * sqrt(reduced_chisq)``.
+        """
+        # Check the degrees of freedom is greater than 0
+        dof = len(ydata) - len(p0)
+        if dof < 1:
+            raise QiskitError(
+                "The number of degrees of freedom of the fit data and model "
+                " (len(ydata) - len(p0)) is less than 1"
+            )
+
+        # Override scipy.curve_fit default for absolute_sigma=True
+        # if sigma is specified.
+        if sigma is not None and "absolute_sigma" not in kwargs:
+            kwargs["absolute_sigma"] = True
+
+        # Run curve fit
+        # pylint: disable = unbalanced-tuple-unpacking
+        try:
+            popt, pcov = opt.curve_fit(
+                f=func, xdata=xdata, ydata=ydata, sigma=sigma, p0=p0, bounds=bounds, **kwargs
+            )
+        except Exception as ex:
+            # TODO do some error handling
+            return AnalysisResult()
+
+        popt_err = np.sqrt(np.diag(pcov))
+
+        # Calculate the reduced chi-squared for fit
+        yfits = func(xdata, *popt)
+        residues = (yfits - ydata) ** 2
+        if sigma is not None:
+            residues = residues / (sigma ** 2)
+        reduced_chisq = np.sum(residues) / dof
+
+        # Compute xdata range for fit
+        xdata_range = [min(xdata), max(xdata)]
+
+        result = {
+            "popt": popt,
+            # "popt_keys": self.__param_names__,
+            "popt_err": popt_err,
+            "pcov": pcov,
+            "reduced_chisq": reduced_chisq,
+            "dof": dof,
+            "xrange": xdata_range,
+        }
+
+        return AnalysisResult(result)

From 6b3502731d3cdee6b8e39090b0ff2148a36f76ea Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 11 May 2021 03:41:07 +0900
Subject: [PATCH 02/74] wip curve fit analysis

---
 qiskit_experiments/analysis/curve_analysis.py | 94 +++++++++++++------
 1 file changed, 67 insertions(+), 27 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 3a412dc4a3..2bd6bc1c1a 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -20,17 +20,20 @@
 import scipy.optimize as opt
 from qiskit.exceptions import QiskitError
 
+from collections import defaultdict
+import functools
+
 from qiskit_experiments.base_analysis import BaseAnalysis
 from qiskit_experiments.data_processing.exceptions import DataProcessorError
 from qiskit_experiments.experiment_data import AnalysisResult, ExperimentData
 
 # Description of data properties for single curve entry
-Series = NamedTuple(
-    "Series",
+SeriesDef = NamedTuple(
+    "SeriesDef",
     [
         ("name", str),
         ("param_names", List[str]),
-        ("fit_func", int),
+        ("fit_func_index", int),
         ("filter_kwargs", Optional[Dict[str, Any]]),
     ],
 )
@@ -42,8 +45,9 @@
         ("curve_name", str),
         ("x_values", np.ndarray),
         ("y_values", np.ndarray),
-        ("y_sigmas", np.ndarray)
-    ]
+        ("y_sigmas", np.ndarray),
+        ("metadata", dict),
+    ],
 )
 
 
@@ -52,7 +56,7 @@ class CurveAnalysis(BaseAnalysis):
     #: str: Metadata key representing a scanned value.
     __x_key__ = ""
 
-    #: List[Series]: List of mapping representing a data series
+    #: List[SeriesDef]: List of mapping representing a data series
     __series__ = None
 
     #: Callable: Data processor
@@ -68,6 +72,14 @@ class CurveAnalysis(BaseAnalysis):
     # For example, if it contains front end discriminator, it may be initialized with
     # some discrimination line parameters. These parameters cannot be hard-coded here.
 
+    @abstractmethod
+    def _run_fitting(self, curve_data: List[CurveEntry]):
+        pass
+
+    @abstractmethod
+    def _create_figure(self, curve_data: List[CurveEntry], fit_data: AnalysisResult):
+        pass
+
     def _run_analysis(self, experiment_data, **options):
         """Run analysis on circuit data.
 
@@ -82,7 +94,6 @@ def _run_analysis(self, experiment_data, **options):
                    None, a single figure, or a list of figures.
         """
         analysis_result = AnalysisResult()
-        figures = list()
 
         try:
             curve_data = self._data_processing(experiment_data)
@@ -90,7 +101,7 @@ def _run_analysis(self, experiment_data, **options):
             # however the raw data may be avoided to be saved in remote database
         except DataProcessorError:
             analysis_result["success"] = False
-            return analysis_result, figures
+            return analysis_result, list()
 
         try:
             fit_data = self._run_fitting(curve_data=curve_data)
@@ -99,6 +110,7 @@ def _run_analysis(self, experiment_data, **options):
         except Exception:
             analysis_result["success"] = False
 
+        analysis_result = self._post_processing(analysis_result)
         figures = self._create_figure(curve_data=curve_data, fit_data=analysis_result)
 
         return analysis_result, figures
@@ -106,6 +118,13 @@ def _run_analysis(self, experiment_data, **options):
     def _data_processing(self, experiment_data: ExperimentData) -> List[CurveEntry]:
         """Extract curve data from experiment data.
 
+        .. notes::
+            The target metadata properties to define each curve entry is described by
+            the class attribute __series__. This method returns the same numbers
+            of curve data entries as one defined in this attribute.
+            The returned CurveData entry contains circuit metadata fields that are
+            common to the entire curve scan, i.e. series-level metadata.
+
         Args:
             experiment_data: ExperimentData object to fit parameters.
 
@@ -116,10 +135,10 @@ def _data_processing(self, experiment_data: ExperimentData) -> List[CurveEntry]:
             series = self.__series__
         else:
             series = [
-                Series(
+                SeriesDef(
                     name="",
                     param_names=self.__param_names__,
-                    fit_func=0,
+                    fit_func_index=0,
                     filter_kwargs=None,
                 )
             ]
@@ -131,13 +150,13 @@ def _is_target_series(datum, **filters):
                 return False
 
         curve_data = list()
-        for line_attributes in series:
-            if line_attributes.filter_kwargs:
+        for curve_properties in series:
+            if curve_properties.filter_kwargs:
                 # filter data
                 series_data = [
                     datum
                     for datum in experiment_data.data
-                    if _is_target_series(datum, **line_attributes.filter_kwargs)
+                    if _is_target_series(datum, **curve_properties.filter_kwargs)
                 ]
             else:
                 # use data as-is
@@ -147,30 +166,51 @@ def _is_target_series(datum, **filters):
             # If we use the level1 data, it may be necessary to calculate principal component
             # with entire scan data. Otherwise we need to use real or imaginary part.
 
+            # Get common metadata fields except for xval and filter args.
+            # These properties are obvious.
+            common_keys = list(
+                functools.reduce(
+                    lambda k1, k2: k1 & k2,
+                    map(lambda d: d.keys(), [datum["metadata"] for datum in series_data]),
+                )
+            )
+            common_keys.remove(self.__x_key__)
+            if curve_properties.filter_kwargs:
+                for key in curve_properties.filter_kwargs:
+                    common_keys.remove(key)
+
+            # Extract common metadata for the curve
+            curve_metadata = defaultdict(set)
+            for datum in series_data:
+                for key in common_keys:
+                    curve_metadata[key].add(datum["metadata"][key])
+
             curve_data.append(
                 CurveEntry(
-                    curve_name=line_attributes.name,
+                    curve_name=curve_properties.name,
                     x_values=xvals,
                     y_values=yvals,
                     y_sigmas=sigmas,
+                    metadata=curve_metadata,
                 )
             )
 
         return curve_data
 
-    @abstractstaticmethod
-    def _initial_guess(xdata: np.ndarray, ydata: np.ndarray, **kwargs) -> np.ndarray:
-        pass
-
-    @abstractmethod
-    def _run_fitting(self, curve_data: List[CurveEntry]):
-        pass
-
-    @abstractmethod
-    def _create_figure(self, curve_data: List[CurveEntry], fit_data: AnalysisResult):
-        pass
-
-    def _series_fit(self, curve_data: List[CurveEntry], **kwargs):
+    @staticmethod
+    def _post_processing(analysis_result: AnalysisResult) -> AnalysisResult:
+        return analysis_result
+
+    def _series_curve_fit(
+            self,
+            curve_data: List[CurveEntry],
+            p0: np.ndarray,
+            weights: Optional[np.ndarray] = None,
+            bounds: Optional[Tuple[np.ndarray, np.ndarray]] = None,
+            **kwargs
+    ):
+
+        # remap parameters
         pass
 
     @staticmethod

From d0e171ff82b9daa2925ab7eff2563e9a4a17e79f Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 11 May 2021 15:25:24 +0900
Subject: [PATCH 03/74] curve_fit complete

---
 qiskit_experiments/analysis/curve_analysis.py | 567 ++++++++++++++----
 1 file changed, 446 insertions(+), 121 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 2bd6bc1c1a..2ceca4ab34 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -12,20 +12,21 @@
 """
 Analysis class for curve fitting.
 """
+# pylint: disable=invalid-name
 
-from abc import abstractmethod, abstractstaticmethod
+import functools
+from abc import abstractmethod
+from collections import defaultdict
 from typing import Any, NamedTuple, Dict, List, Optional, Tuple, Callable
 
 import numpy as np
 import scipy.optimize as opt
 from qiskit.exceptions import QiskitError
 
-from collections import defaultdict
-import functools
-
 from qiskit_experiments.base_analysis import BaseAnalysis
 from qiskit_experiments.data_processing.exceptions import DataProcessorError
 from qiskit_experiments.experiment_data import AnalysisResult, ExperimentData
+from qiskit_experiments.analysis.data_processing import level2_probability
 
 # Description of data properties for single curve entry
 SeriesDef = NamedTuple(
@@ -51,7 +52,222 @@
 )
 
 
+def scipy_curve_fit_wrapper(
+    func: Callable,
+    xdata: np.ndarray,
+    ydata: np.ndarray,
+    p0: np.ndarray,
+    sigma: Optional[np.ndarray] = None,
+    bounds: Optional[Tuple[np.ndarray, np.ndarray]] = None,
+    **kwargs,
+) -> AnalysisResult:
+    r"""A helper function to perform a non-linear least squares to fit
+
+    This solves the optimization problem
+
+    .. math::
+        \Theta_{\mbox{opt}} = \arg\min_\Theta \sum_i \sigma_i^{-2} (f(x_i, \Theta) -  y_i)^2
+
+    using ``scipy.optimize.curve_fit``.
+
+    Args:
+        func: a fit function `f(x, *params)`.
+        xdata: a 1D float array of x-data.
+        ydata: a 1D float array of y-data.
+        p0: initial guess for optimization parameters.
+        sigma: Optional, a 1D array of standard deviations in ydata in absolute units.
+        bounds: Optional, lower and upper bounds for optimization parameters.
+        kwargs: additional kwargs for scipy.optimize.curve_fit.
+
+    Returns:
+        result containing ``popt`` the optimal fit parameters,
+        ``popt_err`` the standard error estimates popt,
+        ``pcov`` the covariance matrix for the fit,
+        ``reduced_chisq`` the reduced chi-squared parameter of fit,
+        ``dof`` the degrees of freedom of the fit,
+        ``xrange`` the range of xdata values used for fit.
+
+    Raises:
+        QiskitError: if the number of degrees of freedom of the fit is
+                     less than 1.
+
+    .. note::
+        ``sigma`` is assumed to be specified in the same units as ``ydata``
+        (absolute units). If sigma is instead specified in relative units
+        the `absolute_sigma=False` kwarg of scipy curve_fit must be used.
+        This affects the returned covariance ``pcov`` and error ``popt_err``
+        parameters via ``pcov(absolute_sigma=False) = pcov * reduced_chisq``
+        ``popt_err(absolute_sigma=False) = popt_err * sqrt(reduced_chisq)``.
+    """
+    # Check the degrees of freedom is greater than 0
+    dof = len(ydata) - len(p0)
+    if dof < 1:
+        raise QiskitError(
+            "The number of degrees of freedom of the fit data and model "
+            " (len(ydata) - len(p0)) is less than 1"
+        )
+
+    # Override scipy.curve_fit default for absolute_sigma=True
+    # if sigma is specified.
+    if sigma is not None and "absolute_sigma" not in kwargs:
+        kwargs["absolute_sigma"] = True
+
+    # Run curve fit
+    # pylint: disable = unbalanced-tuple-unpacking
+    popt, pcov = opt.curve_fit(
+        f=func, xdata=xdata, ydata=ydata, sigma=sigma, p0=p0, bounds=bounds, **kwargs
+    )
+    popt_err = np.sqrt(np.diag(pcov))
+
+    # Calculate the reduced chi-squared for fit
+    yfits = func(xdata, *popt)
+    residues = (yfits - ydata) ** 2
+    if sigma is not None:
+        residues = residues / (sigma ** 2)
+    reduced_chisq = np.sum(residues) / dof
+
+    # Compute xdata range for fit
+    xdata_range = [min(xdata), max(xdata)]
+
+    result = {
+        "popt": popt,
+        "popt_err": popt_err,
+        "pcov": pcov,
+        "reduced_chisq": reduced_chisq,
+        "dof": dof,
+        "xrange": xdata_range,
+    }
+
+    return AnalysisResult(result)
+
+
 class CurveAnalysis(BaseAnalysis):
+    """A base class for curve fit type analysis.
+
+    The subclass can override class attributes to define the behavior of
+    data extraction and fitting. This docstring describes how code developers can
+    create a new curve fit analysis subclass inheriting from this base class.
+
+    Class Attributes:
+
+        __x_key__: String representation of horizontal axis.
+            This should be defined in the circuit metadata for data extraction.
+        __series__: List of curve property definitions. Each element should be
+            defined as SeriesDef entry. This field can be left as None if the
+            analysis is performed for only single line.
+        __data_processor__: A callable to define the data processing procedure
+            to extract curve series. This function should return x-values, y-values, and
+            y-errors in numpy array format.
+        __fit_funcs__: List of callable to fit parameters. This is order sensitive.
+            The list index corresponds to the function index specified by __series__ definition.
+        __param_names__: Name of parameters to fit. This is order sensitive.
+        __base_fitter__: A callable to perform single curve fitting.
+            The function API should conform to the scipy curve fit module.
+
+    Examples:
+
+        T1 experiment
+        =============
+
+        In this type of experiment, the analysis deals with single curve.
+        Thus __series__ is not necessary be assigned.
+
+        .. code-block::
+
+            class AnalysisExample(CurveAnalysis):
+
+                __x_key__ = "delay"
+
+                __fit_funcs__ = [library.exponential]
+
+                __param_names__ = ["a", "tau", "b"]
+
+        IRB experiment
+        ==============
+
+        In this type of experiment, the analysis deals with two curves.
+        We need __series__ definition for each curve.
+        Both curves can be represented by the same exponential function,
+        but with different parameter set. Note that parameters will be partly shared.
+
+        .. code-block::
+
+            class AnalysisExample(CurveAnalysis):
+
+                __x_key__ = "ncliffs"
+
+                __series__ = [
+                    SeriesDef(
+                        name="standard_rb",
+                        param_names=["a", "alpha_std", "b"],
+                        fit_func_index=0,
+                        filter_kwargs={"interleaved": False}
+                    ),
+                    SeriesDef(
+                        name="interleaved_rb",
+                        param_names=["a", "alpha_int", "b"],
+                        fit_func_index=0,
+                        filter_kwargs={"interleaved": True}
+                    )
+                ]
+
+                __fit_funcs__ = [library.exponential]
+
+                __param_names__ = ["a", "alpha_std", "alpha_int", "b"]
+
+        Note that the subclass can optionally override :meth:``_post_processing``.
+        This method takes fit analysis result and calculate new entity with it.
+        EPC calculation can be performed here.
+
+        Ramsey XY experiment
+        ====================
+
+        In this type of experiment, the analysis deals with two curves.
+        We need __series__ definition for each curve.
+        In contrast to the IRB example, this experiment may have two fit functions
+        to represent cosinusoidal (real part) and sinusoidal (imaginary part) oscillation,
+        however the parameters are shared with both functions.
+
+        .. code-block::
+
+            class AnalysisExample(CurveAnalysis):
+
+                __x_key__ = "delays"
+
+                __series__ = [
+                    SeriesDef(
+                        name="x",
+                        param_names=["a", "freq", "phase", "b"],
+                        fit_func_index=0,
+                        filter_kwargs={"pulse": "x"}
+                    ),
+                    SeriesDef(
+                        name="y",
+                        param_names=["a", "freq", "phase", "b"],
+                        fit_func_index=1,
+                        filter_kwargs={"pulse": "y"}
+                    )
+                ]
+
+                __fit_funcs__ = [library.cos, library.sin]
+
+                __param_names__ = ["a", "freq", "phase", "b"]
+
+    .. notes::
+        This class provides several private methods that subclasses can override.
+
+        - _run_fitting: Central method to perform fitting with the provided list of curve data.
+            Subclasses can create initial guess of parameters and override
+            fitter analysis options here.
+            Note that each curve data provides circuit metadata that may be useful to
+            calculate initial guess or apply some coefficient to values.
+
+        - _create_figure: A method to create figures. Subclasses can override this method
+            to create figures. Both raw data and fit analysis is provided.
+
+        - _post_processing: A method to calculate new entity from fit result.
+            This returns fit result as-is by default.
+    """
 
     #: str: Metadata key representing a scanned value.
     __x_key__ = ""
@@ -59,8 +275,14 @@ class CurveAnalysis(BaseAnalysis):
     #: List[SeriesDef]: List of mapping representing a data series
     __series__ = None
 
-    #: Callable: Data processor
-    __data_processor__ = None
+    #: Callable: Data processor. This should return x-values, y-values, y-sigmas.
+    __data_processor__ = level2_probability
+
+    # TODO this should be replaced with preset DataProcessor node.
+
+    # TODO data processor may be initialized with some variables.
+    # For example, if it contains front end discriminator, it may be initialized with
+    # some discrimination line parameters. These parameters cannot be hard-coded here.
 
     #: List[Callable]: A callback function to define the expected curve
     __fit_funcs__ = None
@@ -68,52 +290,52 @@ class CurveAnalysis(BaseAnalysis):
     #: List[str]: Parameter name list
     __param_names__ = list()
 
-    # TODO data processor may be initialized with some variables.
-    # For example, if it contains front end discriminator, it may be initialized with
-    # some discrimination line parameters. These parameters cannot be hard-coded here.
+    # Callable: Default curve fitter. This can be overwritten.
+    __base_fitter__ = scipy_curve_fit_wrapper
 
-    @abstractmethod
-    def _run_fitting(self, curve_data: List[CurveEntry]):
-        pass
+    def _run_fitting(self, curve_data: List[CurveEntry], **options) -> AnalysisResult:
+        """Fit series of curve data.
+
+        Subclass can override this method to return figures.
+        For example, initial guess is not automatically provided by this base class.
+
+        Args:
+            curve_data: List of raw curve data points to fit.
+            **options: Fitting options.
+
+        Returns:
+            Analysis result populated by fit parameters.
+        """
+        return self._series_curve_fit(curve_data=curve_data, **options)
 
     @abstractmethod
     def _create_figure(self, curve_data: List[CurveEntry], fit_data: AnalysisResult):
-        pass
+        """Create new figure with the fit result and raw data.
 
-    def _run_analysis(self, experiment_data, **options):
-        """Run analysis on circuit data.
+        Subclass can override this method to return figures.
 
         Args:
-            experiment_data (ExperimentData): the experiment data to analyze.
-            options: kwarg options for analysis function.
+            curve_data: List of raw curve data points with metadata.
+            fit_data: Analysis result containing fit parameters.
 
         Returns:
-            tuple: A pair ``(analysis_results, figures)`` where
-                   ``analysis_results`` may be a single or list of
-                   AnalysisResult objects, and ``figures`` may be
-                   None, a single figure, or a list of figures.
+            List of figures (format TBD).
         """
-        analysis_result = AnalysisResult()
+        pass
 
-        try:
-            curve_data = self._data_processing(experiment_data)
-            # TODO this data should be kept in somewhere in analysis result
-            # however the raw data may be avoided to be saved in remote database
-        except DataProcessorError:
-            analysis_result["success"] = False
-            return analysis_result, list()
+    @staticmethod
+    def _post_processing(analysis_result: AnalysisResult) -> AnalysisResult:
+        """Calculate new quantity from the fit result.
 
-        try:
-            fit_data = self._run_fitting(curve_data=curve_data)
-            analysis_result.update(fit_data)
-            analysis_result["success"] = True
-        except Exception:
-            analysis_result["success"] = False
+        Subclass can override this method to do post analysis.
 
-        analysis_result = self._post_processing(analysis_result)
-        figures = self._create_figure(curve_data=curve_data, fit_data=analysis_result)
+        Args:
+            analysis_result: Analysis result containing fit result.
 
-        return analysis_result, figures
+        Returns:
+            New AnalysisResult instance containing the result of post analysis.
+        """
+        return analysis_result
 
     def _data_processing(self, experiment_data: ExperimentData) -> List[CurveEntry]:
         """Extract curve data from experiment data.
@@ -136,7 +358,7 @@ def _data_processing(self, experiment_data: ExperimentData) -> List[CurveEntry]:
         else:
             series = [
                 SeriesDef(
-                    name="",
+                    name="fit-curve-0",
                     param_names=self.__param_names__,
                     fit_func_index=0,
                     filter_kwargs=None,
@@ -197,49 +419,34 @@ def _is_target_series(datum, **filters):
 
         return curve_data
 
-    @staticmethod
-    def _post_processing(analysis_result: AnalysisResult) -> AnalysisResult:
-        return analysis_result
-
     def _series_curve_fit(
-            self,
-            curve_data: List[CurveEntry],
-            p0: np.ndarray,
-            weights: Optional[np.ndarray] = None,
-            bounds: Optional[Tuple[np.ndarray, np.ndarray]] = None,
-            **kwargs
-    ):
-
-        # remap parameters
-        pass
-
-    @staticmethod
-    def _single_curve_fit(
-        func: Callable,
-        xdata: np.ndarray,
-        ydata: np.ndarray,
-        p0: np.ndarray,
-        sigma: Optional[np.ndarray] = None,
+        self,
+        curve_data: List[CurveEntry],
+        p0: Optional[np.ndarray] = None,
+        weights: Optional[np.ndarray] = None,
         bounds: Optional[Tuple[np.ndarray, np.ndarray]] = None,
-        **kwargs,
+        **options,
     ) -> AnalysisResult:
-        r"""Perform a non-linear least squares to fit
+        r"""Perform a linearized multi-objective non-linear least squares fit.
 
         This solves the optimization problem
 
         .. math::
-            \Theta_{\mbox{opt}} = \arg\min_\Theta \sum_i \sigma_i^{-2} (f(x_i, \Theta) -  y_i)^2
+            \Theta_{\mbox{opt}} = \arg\min_\Theta \sum_{k} w_k
+                \sum_{i} \sigma_{k, i}^{-2}
+                (f_k(x_{k, i}, \Theta) -  y_{k, i})^2
 
+        for multiple series of :math:`x_k, y_k, \sigma_k` data evaluated using
+        a list of objective functions :math:`[f_k]`
         using ``scipy.optimize.curve_fit``.
 
         Args:
-            func: a fit function `f(x, *params)`.
-            xdata: a 1D float array of x-data.
-            ydata: a 1D float array of y-data.
             p0: initial guess for optimization parameters.
-            sigma: Optional, a 1D array of standard deviations in ydata in absolute units.
-            bounds: Optional, lower and upper bounds for optimization parameters.
-            kwargs: additional kwargs for scipy.optimize.curve_fit.
+            weights: Optional, a 1D float list of weights :math:`w_k` for each
+                     component function :math:`f_k`.
+            bounds: Optional, lower and upper bounds for optimization
+                    parameters.
+            options: additional kwargs for scipy.optimize.curve_fit.
 
         Returns:
             result containing ``popt`` the optimal fit parameters,
@@ -250,60 +457,178 @@ def _single_curve_fit(
             ``xrange`` the range of xdata values used for fit.
 
         Raises:
-            QiskitError: if the number of degrees of freedom of the fit is
-                         less than 1.
-
-        .. note::
-            ``sigma`` is assumed to be specified in the same units as ``ydata``
-            (absolute units). If sigma is instead specified in relative units
-            the `absolute_sigma=False` kwarg of scipy curve_fit must be used.
-            This affects the returned covariance ``pcov`` and error ``popt_err``
-            parameters via ``pcov(absolute_sigma=False) = pcov * reduced_chisq``
-            ``popt_err(absolute_sigma=False) = popt_err * sqrt(reduced_chisq)``.
+            QiskitError:
+                - When number of weights are not identical to the curve_data entries.
         """
-        # Check the degrees of freedom is greater than 0
-        dof = len(ydata) - len(p0)
-        if dof < 1:
-            raise QiskitError(
-                "The number of degrees of freedom of the fit data and model "
-                " (len(ydata) - len(p0)) is less than 1"
-            )
+        num_curves = len(curve_data)
+
+        if weights is None:
+            sig_weights = np.ones(num_curves)
+        else:
+            if len(weights) != num_curves:
+                raise QiskitError(
+                    "weights should be the same length as the curve_data. "
+                    f"{len(weights)} != {num_curves}"
+                )
+            sig_weights = weights
+
+        # Concatenate all curve data
+        flat_xvals = np.empty(0, dtype=float)
+        flat_yvals = np.empty(0, dtype=float)
+        flat_yerrs = np.empty(0, dtype=float)
+        separators = np.empty(num_curves - 1)
+        for idx, (datum, weight) in enumerate(zip(curve_data, sig_weights)):
+            flat_xvals = np.concatenate((flat_xvals, datum.x_values))
+            flat_yvals = np.concatenate((flat_yvals, datum.y_values))
+            if datum.y_sigmas is not None:
+                datum_yerrs = datum.y_sigmas / np.sqrt(weight)
+            else:
+                datum_yerrs = 1 / np.sqrt(weight)
+            flat_yerrs = np.concatenate((flat_yerrs, datum_yerrs))
+            separators[idx] = len(datum.x_values)
+        separators = np.cumsum(separators)[:-1]
+
+        # Define multi-objective function
+        def multi_objective_fit(x, *params):
+            y = []
+            xs = np.split(x, separators)
+            for i, xi in range(num_curves, xs):
+                yi = self._fit_curve(curve_data[i].curve_name, xi, *params)
+                y.append(yi)
+            return np.asarray(y, dtype=float)
+
+        # To make sure argument mapping for user defined fit module.
+        fitter_args = {
+            "func": multi_objective_fit,
+            "xdata": flat_xvals,
+            "ydata": flat_yvals,
+            "p0": p0,
+            "sigma": flat_yerrs,
+            "bounds": bounds
+        }
+        fitter_args.update(options)
+
+        # pylint: disable=redundant-keyword-arg
+        analysis_result = self.__base_fitter__(**fitter_args)
+        analysis_result["popt_keys"] = self.__param_names__
+
+        return analysis_result
+
+    def _fit_curve(
+            self,
+            curve_name: str,
+            xvals: np.ndarray,
+            *params
+    ) -> np.ndarray:
+        """A helper method to run fitting with series definition.
+
+        Fit function is selected based on ``curve_name`` and the parameters list is truncated
+        based on parameter matching between one defined in __series__ and self.__param_names__.
+
+        Examples:
+            Assuming the class has following definition:
+
+            .. code-block::
+
+                self.__series__ = [
+                    Series(name="curve1", param_names=["p1", "p2", "p4"], fit_func_index=0),
+                    Series(name="curve2", param_names=["p1", "p2", "p3"], fit_func_index=1)
+                ]
+
+                self.__fit_funcs__ = [func1, func2]
 
-        # Override scipy.curve_fit default for absolute_sigma=True
-        # if sigma is specified.
-        if sigma is not None and "absolute_sigma" not in kwargs:
-            kwargs["absolute_sigma"] = True
+                self.__param_names__ = ["p1", "p2", "p3", "p4"]
 
-        # Run curve fit
-        # pylint: disable = unbalanced-tuple-unpacking
+            When we call this method with ``curve_name="curve1", params = [0, 1, 2, 3]``,
+            the ``func1`` is called with parameters ``[0, 1, 3]``.
+
+        Args:
+            curve_name: A name of curve. This should be defined in __series__ attribute.
+            xvals: Array of x values.
+            *params: Full fit parameters.
+
+        Returns:
+            Fit y values.
+
+        Raises:
+            QiskitError:
+                - When function parameter is not defined in the class parameter list.
+                - When fit function index is out of range.
+                - When curve information is not defined in class attribute __series__.
+        """
+        for curve_properties in self.__series__:
+            if curve_properties.name == curve_name:
+
+                # remap parameters
+                series_params = curve_properties.param_names
+                mapped_params = []
+                for series_param in series_params:
+                    try:
+                        param_idx = self.__param_names__.index(series_param)
+                    except ValueError as ex:
+                        raise QiskitError(
+                            f"Local function parameter {series_param} is not defined in "
+                            f"this class. {series_param} not in {self.__param_names__}."
+                        ) from ex
+                    mapped_params.append(params[param_idx])
+
+                # find fit function
+                f_index = curve_properties.fit_func_index
+                try:
+                    return self.__fit_funcs__[f_index](xvals, *mapped_params)
+                except IndexError as ex:
+                    raise QiskitError(f"Fit function of index {f_index} is not defined.") from ex
+
+        raise QiskitError(f"A curve {curve_name} is not defined in this class.")
+
+    def _run_analysis(self, experiment_data: ExperimentData, **options):
+        """Run analysis on circuit data.
+
+        Args:
+            experiment_data: the experiment data to analyze.
+            options: kwarg options for analysis function.
+
+        Returns:
+            tuple: A pair ``(analysis_results, figures)`` where
+                   ``analysis_results`` may be a single or list of
+                   AnalysisResult objects, and ``figures`` may be
+                   None, a single figure, or a list of figures.
+        """
+        analysis_result = AnalysisResult()
+
+        # Extract curve entries from experiment data
         try:
-            popt, pcov = opt.curve_fit(
-                f=func, xdata=xdata, ydata=ydata, sigma=sigma, p0=p0, bounds=bounds, **kwargs
-            )
+            curve_data = self._data_processing(experiment_data)
+            analysis_result["raw_data"] = curve_data
+        except DataProcessorError as ex:
+            analysis_result["error_message"] = str(ex)
+            analysis_result["success"] = False
+            return analysis_result, list()
+
+        # Run fitting
+        # pylint: disable=broad-except
+        try:
+            fit_data = self._run_fitting(curve_data=curve_data, **options)
+            analysis_result.update(fit_data)
+            analysis_result["success"] = True
         except Exception as ex:
-            # TODO do some error handling
-            return AnalysisResult()
-
-        popt_err = np.sqrt(np.diag(pcov))
-
-        # Calculate the reduced chi-squared for fit
-        yfits = func(xdata, *popt)
-        residues = (yfits - ydata) ** 2
-        if sigma is not None:
-            residues = residues / (sigma ** 2)
-        reduced_chisq = np.sum(residues) / dof
-
-        # Compute xdata range for fit
-        xdata_range = [min(xdata), max(xdata)]
-
-        result = {
-            "popt": popt,
-            # "popt_keys": self.__param_names__,
-            "popt_err": popt_err,
-            "pcov": pcov,
-            "reduced_chisq": reduced_chisq,
-            "dof": dof,
-            "xrange": xdata_range,
-        }
+            analysis_result["error_message"] = str(ex)
+            analysis_result["success"] = False
+
+        # Post-process analysis data
+        analysis_result = self._post_processing(analysis_result)
 
-        return AnalysisResult(result)
+        # Create figures
+        figures = self._create_figure(curve_data=curve_data, fit_data=analysis_result)
+
+        # Store raw data
+        raw_data = dict()
+        for datum in curve_data:
+            raw_data[datum.curve_name] = {
+                "x_values": datum.x_values,
+                "y_values": datum.y_values,
+                "y_sigmas": datum.y_sigmas,
+            }
+        analysis_result["raw_data"] = raw_data
+
+        return analysis_result, figures

From b34da0d06d5c621a018af185c2204faab97f09cf Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 11 May 2021 23:06:12 +0900
Subject: [PATCH 04/74] - unittest - bug fix - lint

---
 qiskit_experiments/analysis/__init__.py       |   1 +
 qiskit_experiments/analysis/curve_analysis.py | 156 +++++++----
 .../analysis/data_processing.py               |   2 +-
 test/analysis/__init__.py                     |  11 +
 test/analysis/test_curve_fit.py               | 262 ++++++++++++++++++
 5 files changed, 381 insertions(+), 51 deletions(-)
 create mode 100644 test/analysis/__init__.py
 create mode 100644 test/analysis/test_curve_fit.py

diff --git a/qiskit_experiments/analysis/__init__.py b/qiskit_experiments/analysis/__init__.py
index b26812a6d9..a18d6df6f1 100644
--- a/qiskit_experiments/analysis/__init__.py
+++ b/qiskit_experiments/analysis/__init__.py
@@ -13,3 +13,4 @@
 """
 Analysis helper functions
 """
+from qiskit_experiments.analysis.curve_analysis import CurveAnalysis, SeriesDef
diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 2ceca4ab34..6d5619d6cc 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -15,7 +15,6 @@
 # pylint: disable=invalid-name
 
 import functools
-from abc import abstractmethod
 from collections import defaultdict
 from typing import Any, NamedTuple, Dict, List, Optional, Tuple, Callable
 
@@ -23,10 +22,10 @@
 import scipy.optimize as opt
 from qiskit.exceptions import QiskitError
 
+from qiskit_experiments.analysis.data_processing import level2_probability
 from qiskit_experiments.base_analysis import BaseAnalysis
 from qiskit_experiments.data_processing.exceptions import DataProcessorError
 from qiskit_experiments.experiment_data import AnalysisResult, ExperimentData
-from qiskit_experiments.analysis.data_processing import level2_probability
 
 # Description of data properties for single curve entry
 SeriesDef = NamedTuple(
@@ -57,8 +56,8 @@ def scipy_curve_fit_wrapper(
     xdata: np.ndarray,
     ydata: np.ndarray,
     p0: np.ndarray,
-    sigma: Optional[np.ndarray] = None,
-    bounds: Optional[Tuple[np.ndarray, np.ndarray]] = None,
+    sigma: Optional[np.ndarray],
+    bounds: Optional[Tuple[np.ndarray, np.ndarray]],
     **kwargs,
 ) -> AnalysisResult:
     r"""A helper function to perform a non-linear least squares to fit
@@ -155,9 +154,6 @@ class CurveAnalysis(BaseAnalysis):
         __series__: List of curve property definitions. Each element should be
             defined as SeriesDef entry. This field can be left as None if the
             analysis is performed for only single line.
-        __data_processor__: A callable to define the data processing procedure
-            to extract curve series. This function should return x-values, y-values, and
-            y-errors in numpy array format.
         __fit_funcs__: List of callable to fit parameters. This is order sensitive.
             The list index corresponds to the function index specified by __series__ definition.
         __param_names__: Name of parameters to fit. This is order sensitive.
@@ -265,25 +261,20 @@ class AnalysisExample(CurveAnalysis):
         - _create_figure: A method to create figures. Subclasses can override this method
             to create figures. Both raw data and fit analysis is provided.
 
+        - _data_processing: A method to format a list of circuit result into y and yerr values.
+            Subclasses can override this method depending on the expected circuit result format
+            and the output data representation.
+
         - _post_processing: A method to calculate new entity from fit result.
             This returns fit result as-is by default.
     """
 
     #: str: Metadata key representing a scanned value.
-    __x_key__ = ""
+    __x_key__ = "xval"
 
     #: List[SeriesDef]: List of mapping representing a data series
     __series__ = None
 
-    #: Callable: Data processor. This should return x-values, y-values, y-sigmas.
-    __data_processor__ = level2_probability
-
-    # TODO this should be replaced with preset DataProcessor node.
-
-    # TODO data processor may be initialized with some variables.
-    # For example, if it contains front end discriminator, it may be initialized with
-    # some discrimination line parameters. These parameters cannot be hard-coded here.
-
     #: List[Callable]: A callback function to define the expected curve
     __fit_funcs__ = None
 
@@ -308,7 +299,7 @@ def _run_fitting(self, curve_data: List[CurveEntry], **options) -> AnalysisResul
         """
         return self._series_curve_fit(curve_data=curve_data, **options)
 
-    @abstractmethod
+    # pylint: disable = unused-argument, missing-return-type-doc
     def _create_figure(self, curve_data: List[CurveEntry], fit_data: AnalysisResult):
         """Create new figure with the fit result and raw data.
 
@@ -321,7 +312,51 @@ def _create_figure(self, curve_data: List[CurveEntry], fit_data: AnalysisResult)
         Returns:
             List of figures (format TBD).
         """
-        pass
+        # TODO implement default figure. Will wait for Qiskit-terra #5499
+        return list()
+
+    @staticmethod
+    def _data_processing(data: List[Dict[str, Any]]) -> Tuple[np.ndarray, np.ndarray]:
+        """Format x-values, y-values and y-sigmas from list of circuit result entry.
+
+        .. notes::
+            This method receives full data list of a single curve.
+
+            This is sometime convenient for handling level1 (Kerneled) data.
+            The level1 scatter data may spread in the IQ plane, and it may require
+            full experimental results to calculate the principal component to
+            enhance the signal-to-noise ratio of following analysis.
+
+        Args:
+            data: List of circuit result entry.
+
+        Returns:
+            - y_values: Numpy array of formatted y data values.
+            - y_sigmas: Numpy array of formatted y error values.
+        """
+        try:
+            n_qubits = len(data[0]["metadata"]["qubits"])
+        except KeyError:
+            n_qubits = 1
+
+        # TODO data processor may be initialized with some variables.
+        # For example, if it contains front end discriminator, it may be initialized with
+        # some discrimination line parameters. These parameters cannot be hard-coded here.
+
+        y_values = np.zeros(len(data), dtype=float)
+        y_sigmas = np.zeros(len(data), dtype=float)
+        for idx, datum in enumerate(data):
+            # TODO this should be replaced with preset DataProcessor.
+
+            # TODO fix sigma definition
+            # When the count is 100% zero (i.e. simulator), this yields sigma=0.
+            # This crashes scipy fitter when it calculates covariance matrix (zero-div error).
+
+            y_val, y_err = level2_probability(datum, outcome="1" * n_qubits)
+            y_values[idx] = y_val
+            y_sigmas[idx] = y_err
+
+        return y_values, y_sigmas
 
     @staticmethod
     def _post_processing(analysis_result: AnalysisResult) -> AnalysisResult:
@@ -337,7 +372,7 @@ def _post_processing(analysis_result: AnalysisResult) -> AnalysisResult:
         """
         return analysis_result
 
-    def _data_processing(self, experiment_data: ExperimentData) -> List[CurveEntry]:
+    def _extract_curves(self, experiment_data: ExperimentData) -> List[CurveEntry]:
         """Extract curve data from experiment data.
 
         .. notes::
@@ -352,6 +387,10 @@ def _data_processing(self, experiment_data: ExperimentData) -> List[CurveEntry]:
 
         Returns:
             List of ``CurveEntry`` containing x-values, y-values, and y values sigma.
+
+        Raises:
+            QiskitError:
+                - When __x_key__ is not defined in the circuit metadata.
         """
         if self.__series__:
             series = self.__series__
@@ -382,11 +421,19 @@ def _is_target_series(datum, **filters):
                 ]
             else:
                 # use data as-is
-                series_data = experiment_data
-            xvals, yvals, sigmas = self.__data_processor__(series_data)
-            # TODO data processor may need calibration.
-            # If we use the level1 data, it may be necessary to calculate principal component
-            # with entire scan data. Otherwise we need to use real or imaginary part.
+                series_data = experiment_data.data
+
+            # Format x, y, yerr data
+            try:
+                xvals = np.asarray(
+                    [datum["metadata"][self.__x_key__] for datum in series_data],
+                    dtype=float
+                )
+            except KeyError as ex:
+                raise QiskitError(
+                    f"X value key {self.__x_key__} is not defined in circuit metadata."
+                ) from ex
+            yvals, sigmas = self._data_processing(series_data)
 
             # Get common metadata fields except for xval and filter args.
             # These properties are obvious.
@@ -413,7 +460,7 @@ def _is_target_series(datum, **filters):
                     x_values=xvals,
                     y_values=yvals,
                     y_sigmas=sigmas,
-                    metadata=curve_metadata,
+                    metadata=dict(curve_metadata),
                 )
             )
 
@@ -461,7 +508,13 @@ def _series_curve_fit(
                 - When number of weights are not identical to the curve_data entries.
         """
         num_curves = len(curve_data)
+        num_params = len(self.__param_names__)
 
+        # Set initial guess and bounds if they are not provided
+        p0 = p0 or np.zeros(num_params)
+        bounds = bounds or ([-np.inf] * num_params, [np.inf] * num_params)
+
+        # Validate weights
         if weights is None:
             sig_weights = np.ones(num_curves)
         else:
@@ -476,7 +529,8 @@ def _series_curve_fit(
         flat_xvals = np.empty(0, dtype=float)
         flat_yvals = np.empty(0, dtype=float)
         flat_yerrs = np.empty(0, dtype=float)
-        separators = np.empty(num_curves - 1)
+        separators = np.empty(num_curves)
+
         for idx, (datum, weight) in enumerate(zip(curve_data, sig_weights)):
             flat_xvals = np.concatenate((flat_xvals, datum.x_values))
             flat_yvals = np.concatenate((flat_yvals, datum.y_values))
@@ -486,30 +540,26 @@ def _series_curve_fit(
                 datum_yerrs = 1 / np.sqrt(weight)
             flat_yerrs = np.concatenate((flat_yerrs, datum_yerrs))
             separators[idx] = len(datum.x_values)
-        separators = np.cumsum(separators)[:-1]
+        separators = list(map(int, np.cumsum(separators)[:-1]))
 
         # Define multi-objective function
         def multi_objective_fit(x, *params):
-            y = []
-            xs = np.split(x, separators)
-            for i, xi in range(num_curves, xs):
+            y = np.empty(0, dtype=float)
+            xs = np.split(x, separators) if len(separators) > 0 else [x]
+            for i, xi in enumerate(xs):
                 yi = self._fit_curve(curve_data[i].curve_name, xi, *params)
-                y.append(yi)
-            return np.asarray(y, dtype=float)
-
-        # To make sure argument mapping for user defined fit module.
-        fitter_args = {
-            "func": multi_objective_fit,
-            "xdata": flat_xvals,
-            "ydata": flat_yvals,
-            "p0": p0,
-            "sigma": flat_yerrs,
-            "bounds": bounds
-        }
-        fitter_args.update(options)
-
-        # pylint: disable=redundant-keyword-arg
-        analysis_result = self.__base_fitter__(**fitter_args)
+                y = np.concatenate((y, yi))
+            return y
+
+        analysis_result = self.__base_fitter__.__func__(
+            func=multi_objective_fit,
+            xdata=flat_xvals,
+            ydata=flat_yvals,
+            p0=p0,
+            sigma=flat_yerrs,
+            bounds=bounds,
+            **options
+        )
         analysis_result["popt_keys"] = self.__param_names__
 
         return analysis_result
@@ -520,7 +570,7 @@ def _fit_curve(
             xvals: np.ndarray,
             *params
     ) -> np.ndarray:
-        """A helper method to run fitting with series definition.
+        """A helper method to return fit curve for the specific series.
 
         Fit function is selected based on ``curve_name`` and the parameters list is truncated
         based on parameter matching between one defined in __series__ and self.__param_names__.
@@ -556,6 +606,10 @@ def _fit_curve(
                 - When fit function index is out of range.
                 - When curve information is not defined in class attribute __series__.
         """
+        if self.__series__ is None:
+            # only single curve
+            return self.__fit_funcs__[0](xvals, *params)
+
         for curve_properties in self.__series__:
             if curve_properties.name == curve_name:
 
@@ -577,7 +631,9 @@ def _fit_curve(
                 try:
                     return self.__fit_funcs__[f_index](xvals, *mapped_params)
                 except IndexError as ex:
-                    raise QiskitError(f"Fit function of index {f_index} is not defined.") from ex
+                    raise QiskitError(
+                        f"Fit function of index {f_index} is not defined."
+                    ) from ex
 
         raise QiskitError(f"A curve {curve_name} is not defined in this class.")
 
@@ -598,7 +654,7 @@ def _run_analysis(self, experiment_data: ExperimentData, **options):
 
         # Extract curve entries from experiment data
         try:
-            curve_data = self._data_processing(experiment_data)
+            curve_data = self._extract_curves(experiment_data)
             analysis_result["raw_data"] = curve_data
         except DataProcessorError as ex:
             analysis_result["error_message"] = str(ex)
diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index 722f92e07f..ced7735bdb 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -120,7 +120,7 @@ def mean_xy_data(
     raise QiskitError(f"Unsupported method {method}")
 
 
-def level2_probability(data: Dict[str, any], outcome: str) -> Tuple[float]:
+def level2_probability(data: Dict[str, any], outcome: str) -> Tuple[float, float]:
     """Return the outcome probability mean and variance.
 
     Args:
diff --git a/test/analysis/__init__.py b/test/analysis/__init__.py
new file mode 100644
index 0000000000..96c0cf22be
--- /dev/null
+++ b/test/analysis/__init__.py
@@ -0,0 +1,11 @@
+# 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.
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
new file mode 100644
index 0000000000..253abc787b
--- /dev/null
+++ b/test/analysis/test_curve_fit.py
@@ -0,0 +1,262 @@
+# 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.
+
+"""Test curve fitting base class."""
+
+from typing import List, Callable
+
+import numpy as np
+from qiskit.test import QiskitTestCase
+
+from qiskit_experiments import ExperimentData
+from qiskit_experiments.analysis import CurveAnalysis, SeriesDef
+from qiskit_experiments.base_experiment import BaseExperiment
+
+
+class FakeExperiment(BaseExperiment):
+    """A fake experiment class."""
+    def __init__(self):
+        super().__init__(qubits=(0, ), experiment_type="fake_experiment")
+
+    def circuits(self, backend=None, **circuit_options):
+        return []
+
+
+def simulate_output_data(func, xvals, *params, **metadata):
+    """Generate arbitrary fit data."""
+    __shots = 1024
+
+    expected_probs = func(xvals, *params)
+    counts = np.asarray(expected_probs * __shots, dtype=int)
+
+    data = [
+        {
+            "counts": {"0": __shots - count, "1": count},
+            "metadata": dict(
+                xval=xi,
+                qubits=(0,),
+                experiment_type="fake_experiment",
+                **metadata
+            )
+        }
+        for xi, count in zip(xvals, counts)
+    ]
+
+    expdata = ExperimentData(experiment=FakeExperiment())
+    for datum in data:
+        expdata.add_data(datum)
+
+    return expdata
+
+
+def create_new_analysis(
+        x_key: str = "xval",
+        series: List[SeriesDef] = None,
+        fit_funcs: List[Callable] = None,
+        param_names: List[str] = None
+) -> CurveAnalysis:
+    """A helper function to create a mock analysis class instance."""
+    class TestAnalysis(CurveAnalysis):
+        """A mock analysis class to test."""
+        __x_key__ = x_key
+        __series__ = series
+        __fit_funcs__ = fit_funcs
+        __param_names__ = param_names
+
+    return TestAnalysis()
+
+
+class TestCurveAnalysis(QiskitTestCase):
+    """Unittest for curve fit analysis. Assuming several fitting situations."""
+
+    def setUp(self):
+        super().setUp()
+        self.xvalues = np.linspace(0.1, 1, 30)
+
+        # fit functions
+        self.exp_func = lambda x, p0, p1, p2: p0 * np.exp(p1 * x) + p2
+        self.cos_func = lambda x, p0, p1, p2, p3: p0 * np.cos(2 * np.pi * p1 * x + p2) + p3
+        self.sin_func = lambda x, p0, p1, p2, p3: p0 * np.sin(2 * np.pi * p1 * x + p2) + p3
+
+    def test_run_single_curve_analysis(self):
+        """Test analysis for single curve."""
+        analysis = create_new_analysis(
+            fit_funcs=[self.exp_func],
+            param_names=["p0", "p1", "p2"]
+        )
+        ref_p0 = 0.9
+        ref_p1 = -2.5
+        ref_p2 = 0.1
+
+        test_data = simulate_output_data(
+            self.exp_func,
+            self.xvalues,
+            ref_p0,
+            ref_p1,
+            ref_p2
+        )
+        results, _ = analysis._run_analysis(test_data, p0=[ref_p0, ref_p1, ref_p2])
+
+        ref_popt = np.asarray([ref_p0, ref_p1, ref_p2])
+
+        # check result data
+        np.testing.assert_array_almost_equal(results['popt'], ref_popt, decimal=1)
+        self.assertEqual(results['dof'], 27)
+        self.assertListEqual(results['xrange'], [0.1, 1.0])
+        self.assertListEqual(results['popt_keys'], ["p0", "p1", "p2"])
+        self.assertTrue(results['success'])
+
+    def test_run_single_curve_fail(self):
+        """Test analysis returns status when it fails."""
+        analysis = create_new_analysis(
+            fit_funcs=[self.exp_func],
+            param_names=["p0", "p1", "p2"]
+        )
+        ref_p0 = 0.9
+        ref_p1 = -2.5
+        ref_p2 = 0.1
+
+        test_data = simulate_output_data(
+            self.exp_func,
+            self.xvalues,
+            ref_p0,
+            ref_p1,
+            ref_p2
+        )
+
+        # Try to fit with infeasible parameter boundary. This should fail.
+        results, _ = analysis._run_analysis(
+            test_data,
+            p0=[ref_p0, ref_p1, ref_p2],
+            bounds=([-10, -10, -10], [0, 0, 0])
+        )
+
+        self.assertFalse(results['success'])
+
+        ref_result_keys = ["raw_data", "error_message", "success"]
+        self.assertListEqual(list(results.keys()), ref_result_keys)
+
+    def test_run_two_curves_with_same_fitfunc(self):
+        """Test analysis for two curves. Curves shares fit model."""
+        analysis = create_new_analysis(
+            series=[
+                SeriesDef(
+                    name="curve1",
+                    param_names=["p0", "p1", "p3"],
+                    fit_func_index=0,
+                    filter_kwargs={"exp": 0}
+                ),
+                SeriesDef(
+                    name="curve2",
+                    param_names=["p0", "p2", "p3"],
+                    fit_func_index=0,
+                    filter_kwargs={"exp": 1}
+                )
+            ],
+            fit_funcs=[self.exp_func],
+            param_names=["p0", "p1", "p2", "p3"]
+        )
+        ref_p0 = 0.9
+        ref_p1 = -7.
+        ref_p2 = -5.
+        ref_p3 = 0.1
+
+        test_data0 = simulate_output_data(
+            self.exp_func,
+            self.xvalues,
+            ref_p0,
+            ref_p1,
+            ref_p3,
+            exp=0
+        )
+        test_data1 = simulate_output_data(
+            self.exp_func,
+            self.xvalues,
+            ref_p0,
+            ref_p2,
+            ref_p3,
+            exp=1
+        )
+
+        # merge two experiment data
+        for datum in test_data1.data:
+            test_data0.add_data(datum)
+
+        results, _ = analysis._run_analysis(
+            test_data0,
+            p0=[ref_p0, ref_p1, ref_p2, ref_p3]
+        )
+
+        ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
+
+        # check result data
+        np.testing.assert_array_almost_equal(results['popt'], ref_popt, decimal=1)
+        self.assertTrue(results['success'])
+
+    def test_run_two_curves_with_two_fitfuncs(self):
+        """Test analysis for two curves. Curves shares fit parameters."""
+        analysis = create_new_analysis(
+            series=[
+                SeriesDef(
+                    name="curve1",
+                    param_names=["p0", "p1", "p2", "p3"],
+                    fit_func_index=0,
+                    filter_kwargs={"exp": 0}
+                ),
+                SeriesDef(
+                    name="curve2",
+                    param_names=["p0", "p1", "p2", "p3"],
+                    fit_func_index=1,
+                    filter_kwargs={"exp": 1}
+                )
+            ],
+            fit_funcs=[self.cos_func, self.sin_func],
+            param_names=["p0", "p1", "p2", "p3"]
+        )
+        ref_p0 = 0.1
+        ref_p1 = 2
+        ref_p2 = -0.3
+        ref_p3 = 0.5
+
+        test_data0 = simulate_output_data(
+            self.cos_func,
+            self.xvalues,
+            ref_p0,
+            ref_p1,
+            ref_p2,
+            ref_p3,
+            exp=0
+        )
+        test_data1 = simulate_output_data(
+            self.sin_func,
+            self.xvalues,
+            ref_p0,
+            ref_p1,
+            ref_p2,
+            ref_p3,
+            exp=1
+        )
+
+        # merge two experiment data
+        for datum in test_data1.data:
+            test_data0.add_data(datum)
+
+        results, _ = analysis._run_analysis(
+            test_data0,
+            p0=[ref_p0, ref_p1, ref_p2, ref_p3]
+        )
+
+        ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
+
+        # check result data
+        np.testing.assert_array_almost_equal(results['popt'], ref_popt, decimal=1)
+        self.assertTrue(results['success'])

From 94859aff8b97cf1f95201d8bbb47ed5b1128bdd4 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 11 May 2021 23:38:35 +0900
Subject: [PATCH 05/74] black

---
 qiskit_experiments/analysis/curve_analysis.py |  16 +--
 test/analysis/test_curve_fit.py               | 130 ++++++------------
 2 files changed, 44 insertions(+), 102 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 6d5619d6cc..1947b765ed 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -426,8 +426,7 @@ def _is_target_series(datum, **filters):
             # Format x, y, yerr data
             try:
                 xvals = np.asarray(
-                    [datum["metadata"][self.__x_key__] for datum in series_data],
-                    dtype=float
+                    [datum["metadata"][self.__x_key__] for datum in series_data], dtype=float
                 )
             except KeyError as ex:
                 raise QiskitError(
@@ -558,18 +557,13 @@ def multi_objective_fit(x, *params):
             p0=p0,
             sigma=flat_yerrs,
             bounds=bounds,
-            **options
+            **options,
         )
         analysis_result["popt_keys"] = self.__param_names__
 
         return analysis_result
 
-    def _fit_curve(
-            self,
-            curve_name: str,
-            xvals: np.ndarray,
-            *params
-    ) -> np.ndarray:
+    def _fit_curve(self, curve_name: str, xvals: np.ndarray, *params) -> np.ndarray:
         """A helper method to return fit curve for the specific series.
 
         Fit function is selected based on ``curve_name`` and the parameters list is truncated
@@ -631,9 +625,7 @@ def _fit_curve(
                 try:
                     return self.__fit_funcs__[f_index](xvals, *mapped_params)
                 except IndexError as ex:
-                    raise QiskitError(
-                        f"Fit function of index {f_index} is not defined."
-                    ) from ex
+                    raise QiskitError(f"Fit function of index {f_index} is not defined.") from ex
 
         raise QiskitError(f"A curve {curve_name} is not defined in this class.")
 
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index 253abc787b..f1e580b7a8 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -24,8 +24,9 @@
 
 class FakeExperiment(BaseExperiment):
     """A fake experiment class."""
+
     def __init__(self):
-        super().__init__(qubits=(0, ), experiment_type="fake_experiment")
+        super().__init__(qubits=(0,), experiment_type="fake_experiment")
 
     def circuits(self, backend=None, **circuit_options):
         return []
@@ -41,12 +42,7 @@ def simulate_output_data(func, xvals, *params, **metadata):
     data = [
         {
             "counts": {"0": __shots - count, "1": count},
-            "metadata": dict(
-                xval=xi,
-                qubits=(0,),
-                experiment_type="fake_experiment",
-                **metadata
-            )
+            "metadata": dict(xval=xi, qubits=(0,), experiment_type="fake_experiment", **metadata),
         }
         for xi, count in zip(xvals, counts)
     ]
@@ -59,14 +55,16 @@ def simulate_output_data(func, xvals, *params, **metadata):
 
 
 def create_new_analysis(
-        x_key: str = "xval",
-        series: List[SeriesDef] = None,
-        fit_funcs: List[Callable] = None,
-        param_names: List[str] = None
+    x_key: str = "xval",
+    series: List[SeriesDef] = None,
+    fit_funcs: List[Callable] = None,
+    param_names: List[str] = None,
 ) -> CurveAnalysis:
     """A helper function to create a mock analysis class instance."""
+
     class TestAnalysis(CurveAnalysis):
         """A mock analysis class to test."""
+
         __x_key__ = x_key
         __series__ = series
         __fit_funcs__ = fit_funcs
@@ -89,58 +87,38 @@ def setUp(self):
 
     def test_run_single_curve_analysis(self):
         """Test analysis for single curve."""
-        analysis = create_new_analysis(
-            fit_funcs=[self.exp_func],
-            param_names=["p0", "p1", "p2"]
-        )
+        analysis = create_new_analysis(fit_funcs=[self.exp_func], param_names=["p0", "p1", "p2"])
         ref_p0 = 0.9
         ref_p1 = -2.5
         ref_p2 = 0.1
 
-        test_data = simulate_output_data(
-            self.exp_func,
-            self.xvalues,
-            ref_p0,
-            ref_p1,
-            ref_p2
-        )
+        test_data = simulate_output_data(self.exp_func, self.xvalues, ref_p0, ref_p1, ref_p2)
         results, _ = analysis._run_analysis(test_data, p0=[ref_p0, ref_p1, ref_p2])
 
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2])
 
         # check result data
-        np.testing.assert_array_almost_equal(results['popt'], ref_popt, decimal=1)
-        self.assertEqual(results['dof'], 27)
-        self.assertListEqual(results['xrange'], [0.1, 1.0])
-        self.assertListEqual(results['popt_keys'], ["p0", "p1", "p2"])
-        self.assertTrue(results['success'])
+        np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)
+        self.assertEqual(results["dof"], 27)
+        self.assertListEqual(results["xrange"], [0.1, 1.0])
+        self.assertListEqual(results["popt_keys"], ["p0", "p1", "p2"])
+        self.assertTrue(results["success"])
 
     def test_run_single_curve_fail(self):
         """Test analysis returns status when it fails."""
-        analysis = create_new_analysis(
-            fit_funcs=[self.exp_func],
-            param_names=["p0", "p1", "p2"]
-        )
+        analysis = create_new_analysis(fit_funcs=[self.exp_func], param_names=["p0", "p1", "p2"])
         ref_p0 = 0.9
         ref_p1 = -2.5
         ref_p2 = 0.1
 
-        test_data = simulate_output_data(
-            self.exp_func,
-            self.xvalues,
-            ref_p0,
-            ref_p1,
-            ref_p2
-        )
+        test_data = simulate_output_data(self.exp_func, self.xvalues, ref_p0, ref_p1, ref_p2)
 
         # Try to fit with infeasible parameter boundary. This should fail.
         results, _ = analysis._run_analysis(
-            test_data,
-            p0=[ref_p0, ref_p1, ref_p2],
-            bounds=([-10, -10, -10], [0, 0, 0])
+            test_data, p0=[ref_p0, ref_p1, ref_p2], bounds=([-10, -10, -10], [0, 0, 0])
         )
 
-        self.assertFalse(results['success'])
+        self.assertFalse(results["success"])
 
         ref_result_keys = ["raw_data", "error_message", "success"]
         self.assertListEqual(list(results.keys()), ref_result_keys)
@@ -153,54 +131,41 @@ def test_run_two_curves_with_same_fitfunc(self):
                     name="curve1",
                     param_names=["p0", "p1", "p3"],
                     fit_func_index=0,
-                    filter_kwargs={"exp": 0}
+                    filter_kwargs={"exp": 0},
                 ),
                 SeriesDef(
                     name="curve2",
                     param_names=["p0", "p2", "p3"],
                     fit_func_index=0,
-                    filter_kwargs={"exp": 1}
-                )
+                    filter_kwargs={"exp": 1},
+                ),
             ],
             fit_funcs=[self.exp_func],
-            param_names=["p0", "p1", "p2", "p3"]
+            param_names=["p0", "p1", "p2", "p3"],
         )
         ref_p0 = 0.9
-        ref_p1 = -7.
-        ref_p2 = -5.
+        ref_p1 = -7.0
+        ref_p2 = -5.0
         ref_p3 = 0.1
 
         test_data0 = simulate_output_data(
-            self.exp_func,
-            self.xvalues,
-            ref_p0,
-            ref_p1,
-            ref_p3,
-            exp=0
+            self.exp_func, self.xvalues, ref_p0, ref_p1, ref_p3, exp=0
         )
         test_data1 = simulate_output_data(
-            self.exp_func,
-            self.xvalues,
-            ref_p0,
-            ref_p2,
-            ref_p3,
-            exp=1
+            self.exp_func, self.xvalues, ref_p0, ref_p2, ref_p3, exp=1
         )
 
         # merge two experiment data
         for datum in test_data1.data:
             test_data0.add_data(datum)
 
-        results, _ = analysis._run_analysis(
-            test_data0,
-            p0=[ref_p0, ref_p1, ref_p2, ref_p3]
-        )
+        results, _ = analysis._run_analysis(test_data0, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
 
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
 
         # check result data
-        np.testing.assert_array_almost_equal(results['popt'], ref_popt, decimal=1)
-        self.assertTrue(results['success'])
+        np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)
+        self.assertTrue(results["success"])
 
     def test_run_two_curves_with_two_fitfuncs(self):
         """Test analysis for two curves. Curves shares fit parameters."""
@@ -210,17 +175,17 @@ def test_run_two_curves_with_two_fitfuncs(self):
                     name="curve1",
                     param_names=["p0", "p1", "p2", "p3"],
                     fit_func_index=0,
-                    filter_kwargs={"exp": 0}
+                    filter_kwargs={"exp": 0},
                 ),
                 SeriesDef(
                     name="curve2",
                     param_names=["p0", "p1", "p2", "p3"],
                     fit_func_index=1,
-                    filter_kwargs={"exp": 1}
-                )
+                    filter_kwargs={"exp": 1},
+                ),
             ],
             fit_funcs=[self.cos_func, self.sin_func],
-            param_names=["p0", "p1", "p2", "p3"]
+            param_names=["p0", "p1", "p2", "p3"],
         )
         ref_p0 = 0.1
         ref_p1 = 2
@@ -228,35 +193,20 @@ def test_run_two_curves_with_two_fitfuncs(self):
         ref_p3 = 0.5
 
         test_data0 = simulate_output_data(
-            self.cos_func,
-            self.xvalues,
-            ref_p0,
-            ref_p1,
-            ref_p2,
-            ref_p3,
-            exp=0
+            self.cos_func, self.xvalues, ref_p0, ref_p1, ref_p2, ref_p3, exp=0
         )
         test_data1 = simulate_output_data(
-            self.sin_func,
-            self.xvalues,
-            ref_p0,
-            ref_p1,
-            ref_p2,
-            ref_p3,
-            exp=1
+            self.sin_func, self.xvalues, ref_p0, ref_p1, ref_p2, ref_p3, exp=1
         )
 
         # merge two experiment data
         for datum in test_data1.data:
             test_data0.add_data(datum)
 
-        results, _ = analysis._run_analysis(
-            test_data0,
-            p0=[ref_p0, ref_p1, ref_p2, ref_p3]
-        )
+        results, _ = analysis._run_analysis(test_data0, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
 
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
 
         # check result data
-        np.testing.assert_array_almost_equal(results['popt'], ref_popt, decimal=1)
-        self.assertTrue(results['success'])
+        np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)
+        self.assertTrue(results["success"])

From 37d3c1d8b0fcd4fe3a088c0cc722fdc3fe386015 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 11 May 2021 23:43:16 +0900
Subject: [PATCH 06/74] removed redundant code

---
 qiskit_experiments/analysis/curve_analysis.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 1947b765ed..b4e5982b0d 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -647,7 +647,6 @@ def _run_analysis(self, experiment_data: ExperimentData, **options):
         # Extract curve entries from experiment data
         try:
             curve_data = self._extract_curves(experiment_data)
-            analysis_result["raw_data"] = curve_data
         except DataProcessorError as ex:
             analysis_result["error_message"] = str(ex)
             analysis_result["success"] = False

From 2f49726d8c71551e581d2a45ab602623a98e5257 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Wed, 12 May 2021 00:02:26 +0900
Subject: [PATCH 07/74] fix unittest

---
 test/analysis/test_curve_fit.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index f1e580b7a8..7a2229561e 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -121,7 +121,7 @@ def test_run_single_curve_fail(self):
         self.assertFalse(results["success"])
 
         ref_result_keys = ["raw_data", "error_message", "success"]
-        self.assertListEqual(list(results.keys()), ref_result_keys)
+        self.assertSetEqual(set(results.keys()), set(ref_result_keys))
 
     def test_run_two_curves_with_same_fitfunc(self):
         """Test analysis for two curves. Curves shares fit model."""

From 78fbd7a595dc70b0efc7d3f40955271bca1261d2 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Wed, 12 May 2021 00:09:05 +0900
Subject: [PATCH 08/74] fix docstring

---
 qiskit_experiments/analysis/curve_analysis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index b4e5982b0d..8ed2724a3c 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -287,7 +287,7 @@ class AnalysisExample(CurveAnalysis):
     def _run_fitting(self, curve_data: List[CurveEntry], **options) -> AnalysisResult:
         """Fit series of curve data.
 
-        Subclass can override this method to return figures.
+        Subclass can override this method to provide initial guess or fit boundaries.
         For example, initial guess is not automatically provided by this base class.
 
         Args:

From 89aad76eca50cef86780710f68293b549132321b Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Wed, 12 May 2021 00:40:30 +0900
Subject: [PATCH 09/74] fix docstring

---
 qiskit_experiments/analysis/curve_analysis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 8ed2724a3c..e422b14e50 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -317,7 +317,7 @@ def _create_figure(self, curve_data: List[CurveEntry], fit_data: AnalysisResult)
 
     @staticmethod
     def _data_processing(data: List[Dict[str, Any]]) -> Tuple[np.ndarray, np.ndarray]:
-        """Format x-values, y-values and y-sigmas from list of circuit result entry.
+        """Format y-values and y-sigmas from list of circuit result entry.
 
         .. notes::
             This method receives full data list of a single curve.

From 1639af628422e369408bee33a0256acfdd806c75 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Wed, 12 May 2021 21:57:20 +0900
Subject: [PATCH 10/74] wording fix

Co-authored-by: Yael Ben-Haim <yaelbh@il.ibm.com>
---
 qiskit_experiments/analysis/curve_analysis.py | 38 +++++++++----------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index e422b14e50..23f2522992 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -143,7 +143,7 @@ def scipy_curve_fit_wrapper(
 class CurveAnalysis(BaseAnalysis):
     """A base class for curve fit type analysis.
 
-    The subclass can override class attributes to define the behavior of
+    The subclasses can override class attributes to define the behavior of
     data extraction and fitting. This docstring describes how code developers can
     create a new curve fit analysis subclass inheriting from this base class.
 
@@ -154,7 +154,7 @@ class CurveAnalysis(BaseAnalysis):
         __series__: List of curve property definitions. Each element should be
             defined as SeriesDef entry. This field can be left as None if the
             analysis is performed for only single line.
-        __fit_funcs__: List of callable to fit parameters. This is order sensitive.
+        __fit_funcs__: List of callables to fit parameters. This is order sensitive.
             The list index corresponds to the function index specified by __series__ definition.
         __param_names__: Name of parameters to fit. This is order sensitive.
         __base_fitter__: A callable to perform single curve fitting.
@@ -165,8 +165,8 @@ class CurveAnalysis(BaseAnalysis):
         T1 experiment
         =============
 
-        In this type of experiment, the analysis deals with single curve.
-        Thus __series__ is not necessary be assigned.
+        In this type of experiment, the analysis deals with a single curve.
+        Thus __series__ is not necessarily assigned.
 
         .. code-block::
 
@@ -182,9 +182,9 @@ class AnalysisExample(CurveAnalysis):
         ==============
 
         In this type of experiment, the analysis deals with two curves.
-        We need __series__ definition for each curve.
+        We need a __series__ definition for each curve.
         Both curves can be represented by the same exponential function,
-        but with different parameter set. Note that parameters will be partly shared.
+        but with a different parameter set. Note that parameters will be partly shared.
 
         .. code-block::
 
@@ -212,14 +212,14 @@ class AnalysisExample(CurveAnalysis):
                 __param_names__ = ["a", "alpha_std", "alpha_int", "b"]
 
         Note that the subclass can optionally override :meth:``_post_processing``.
-        This method takes fit analysis result and calculate new entity with it.
+        This method takes the fit analysis result and calculates a new entity with it.
         EPC calculation can be performed here.
 
         Ramsey XY experiment
         ====================
 
         In this type of experiment, the analysis deals with two curves.
-        We need __series__ definition for each curve.
+        We need a __series__ definition for each curve.
         In contrast to the IRB example, this experiment may have two fit functions
         to represent cosinusoidal (real part) and sinusoidal (imaginary part) oscillation,
         however the parameters are shared with both functions.
@@ -253,20 +253,20 @@ class AnalysisExample(CurveAnalysis):
         This class provides several private methods that subclasses can override.
 
         - _run_fitting: Central method to perform fitting with the provided list of curve data.
-            Subclasses can create initial guess of parameters and override
+            Subclasses can create initial guesses of parameters and override
             fitter analysis options here.
             Note that each curve data provides circuit metadata that may be useful to
-            calculate initial guess or apply some coefficient to values.
+            calculate initial guesses or apply some coefficients to values.
 
         - _create_figure: A method to create figures. Subclasses can override this method
-            to create figures. Both raw data and fit analysis is provided.
+            to create figures. Both raw data and fit analysis are provided.
 
-        - _data_processing: A method to format a list of circuit result into y and yerr values.
+        - _data_processing: A method to format a list of circuit results into y and yerr values.
             Subclasses can override this method depending on the expected circuit result format
             and the output data representation.
 
-        - _post_processing: A method to calculate new entity from fit result.
-            This returns fit result as-is by default.
+        - _post_processing: A method to calculate a new entity from a fit result.
+            This returns the fit result as-is by default.
     """
 
     #: str: Metadata key representing a scanned value.
@@ -300,8 +300,8 @@ def _run_fitting(self, curve_data: List[CurveEntry], **options) -> AnalysisResul
         return self._series_curve_fit(curve_data=curve_data, **options)
 
     # pylint: disable = unused-argument, missing-return-type-doc
-    def _create_figure(self, curve_data: List[CurveEntry], fit_data: AnalysisResult):
-        """Create new figure with the fit result and raw data.
+    def _create_figures(self, curve_data: List[CurveEntry], fit_data: AnalysisResult):
+        """Create new figures with the fit result and raw data.
 
         Subclass can override this method to return figures.
 
@@ -322,7 +322,7 @@ def _data_processing(data: List[Dict[str, Any]]) -> Tuple[np.ndarray, np.ndarray
         .. notes::
             This method receives full data list of a single curve.
 
-            This is sometime convenient for handling level1 (Kerneled) data.
+            This is sometimes convenient for handling level1 (Kerneled) data.
             The level1 scatter data may spread in the IQ plane, and it may require
             full experimental results to calculate the principal component to
             enhance the signal-to-noise ratio of following analysis.
@@ -362,7 +362,7 @@ def _data_processing(data: List[Dict[str, Any]]) -> Tuple[np.ndarray, np.ndarray
     def _post_processing(analysis_result: AnalysisResult) -> AnalysisResult:
         """Calculate new quantity from the fit result.
 
-        Subclass can override this method to do post analysis.
+        Subclasses can override this method to do post analysis.
 
         Args:
             analysis_result: Analysis result containing fit result.
@@ -666,7 +666,7 @@ def _run_analysis(self, experiment_data: ExperimentData, **options):
         analysis_result = self._post_processing(analysis_result)
 
         # Create figures
-        figures = self._create_figure(curve_data=curve_data, fit_data=analysis_result)
+        figures = self._create_figures(curve_data=curve_data, fit_data=analysis_result)
 
         # Store raw data
         raw_data = dict()

From 52c99eae4faa9b11b0d7eef92a7f05c60406536f Mon Sep 17 00:00:00 2001
From: Naoki Kanazawa <nkanazawa1989@gmail.com>
Date: Thu, 13 May 2021 11:22:27 +0900
Subject: [PATCH 11/74] Update qiskit_experiments/analysis/curve_analysis.py

Co-authored-by: Daniel Egger <38065505+eggerdj@users.noreply.github.com>
---
 qiskit_experiments/analysis/curve_analysis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 23f2522992..37b568f0eb 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -98,7 +98,7 @@ def scipy_curve_fit_wrapper(
         parameters via ``pcov(absolute_sigma=False) = pcov * reduced_chisq``
         ``popt_err(absolute_sigma=False) = popt_err * sqrt(reduced_chisq)``.
     """
-    # Check the degrees of freedom is greater than 0
+    # Check that degrees of freedom is greater than 0
     dof = len(ydata) - len(p0)
     if dof < 1:
         raise QiskitError(

From 0420d1dc673dd9e501f0a2c6aaac93098b49aff9 Mon Sep 17 00:00:00 2001
From: Naoki Kanazawa <nkanazawa1989@gmail.com>
Date: Thu, 13 May 2021 11:22:42 +0900
Subject: [PATCH 12/74] Update qiskit_experiments/analysis/curve_analysis.py

Co-authored-by: Daniel Egger <38065505+eggerdj@users.noreply.github.com>
---
 qiskit_experiments/analysis/curve_analysis.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 37b568f0eb..81725a1d27 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -149,8 +149,7 @@ class CurveAnalysis(BaseAnalysis):
 
     Class Attributes:
 
-        __x_key__: String representation of horizontal axis.
-            This should be defined in the circuit metadata for data extraction.
+        __x_key__: Key in the circuit metadata under which to find the value for the horizontal axis.
         __series__: List of curve property definitions. Each element should be
             defined as SeriesDef entry. This field can be left as None if the
             analysis is performed for only single line.

From a3dd099ab6cdde44f229d5166289d7d059c0e97e Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 13 May 2021 16:00:28 +0900
Subject: [PATCH 13/74] Feedback from eggerdj

- add default data processor
- add data processor calibraiton
- integrate run_fit and series fit
- add data pre-processing (i.e. RB needs to take mean)
- add fitter setup for initial guess and other options
---
 qiskit_experiments/analysis/__init__.py       |   2 +-
 qiskit_experiments/analysis/curve_analysis.py | 308 ++++++++++++------
 test/analysis/test_curve_fit.py               |   7 +-
 3 files changed, 216 insertions(+), 101 deletions(-)

diff --git a/qiskit_experiments/analysis/__init__.py b/qiskit_experiments/analysis/__init__.py
index a18d6df6f1..a1441de94a 100644
--- a/qiskit_experiments/analysis/__init__.py
+++ b/qiskit_experiments/analysis/__init__.py
@@ -13,4 +13,4 @@
 """
 Analysis helper functions
 """
-from qiskit_experiments.analysis.curve_analysis import CurveAnalysis, SeriesDef
+from qiskit_experiments.analysis.curve_analysis import CurveAnalysis, SeriesDef, FitOptions
diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 23f2522992..ee32174f4b 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -16,14 +16,14 @@
 
 import functools
 from collections import defaultdict
-from typing import Any, NamedTuple, Dict, List, Optional, Tuple, Callable
+from typing import Any, NamedTuple, Dict, List, Optional, Tuple, Callable, Union
 
 import numpy as np
 import scipy.optimize as opt
 from qiskit.exceptions import QiskitError
 
-from qiskit_experiments.analysis.data_processing import level2_probability
 from qiskit_experiments.base_analysis import BaseAnalysis
+from qiskit_experiments.data_processing import DataProcessor
 from qiskit_experiments.data_processing.exceptions import DataProcessorError
 from qiskit_experiments.experiment_data import AnalysisResult, ExperimentData
 
@@ -52,7 +52,7 @@
 
 
 def scipy_curve_fit_wrapper(
-    func: Callable,
+    f: Callable,
     xdata: np.ndarray,
     ydata: np.ndarray,
     p0: np.ndarray,
@@ -70,7 +70,7 @@ def scipy_curve_fit_wrapper(
     using ``scipy.optimize.curve_fit``.
 
     Args:
-        func: a fit function `f(x, *params)`.
+        f: a fit function `f(x, *params)`.
         xdata: a 1D float array of x-data.
         ydata: a 1D float array of y-data.
         p0: initial guess for optimization parameters.
@@ -114,12 +114,12 @@ def scipy_curve_fit_wrapper(
     # Run curve fit
     # pylint: disable = unbalanced-tuple-unpacking
     popt, pcov = opt.curve_fit(
-        f=func, xdata=xdata, ydata=ydata, sigma=sigma, p0=p0, bounds=bounds, **kwargs
+        f=f, xdata=xdata, ydata=ydata, sigma=sigma, p0=p0, bounds=bounds, **kwargs
     )
     popt_err = np.sqrt(np.diag(pcov))
 
     # Calculate the reduced chi-squared for fit
-    yfits = func(xdata, *popt)
+    yfits = f(xdata, *popt)
     residues = (yfits - ydata) ** 2
     if sigma is not None:
         residues = residues / (sigma ** 2)
@@ -140,6 +140,40 @@ def scipy_curve_fit_wrapper(
     return AnalysisResult(result)
 
 
+def level2_probability(data: Dict[str, Any], outcome: Optional[str] = None) -> Tuple[float, float]:
+    """Return the outcome probability mean and variance.
+
+    Args:
+        data: A data dict containing count data.
+        outcome: bitstring for desired outcome probability.
+
+    Returns:
+        (p_mean, p_var) of the probability mean and variance estimated from the counts.
+
+    .. note::
+
+        This assumes a binomial distribution where :math:`K` counts
+        of the desired outcome from :math:`N` shots the
+        mean probability is :math:`p = K / N` and the variance is
+        :math:`\\sigma^2 = p (1-p) / N`.
+    """
+    # TODO fix sigma definition
+    # When the count is 100% zero (i.e. simulator), this yields sigma=0.
+    # This crashes scipy fitter when it calculates covariance matrix (zero-div error).
+
+    counts = data["counts"]
+    outcome = outcome or "1" * len(list(counts.keys())[0])
+
+    shots = sum(counts.values())
+    p_mean = counts.get(outcome, 0.0) / shots
+    p_var = p_mean * (1 - p_mean) / shots
+    return p_mean, p_var
+
+
+class FitOptions(dict):
+    """Fit options passed to the fitter function."""
+
+
 class CurveAnalysis(BaseAnalysis):
     """A base class for curve fit type analysis.
 
@@ -151,8 +185,12 @@ class CurveAnalysis(BaseAnalysis):
 
         __x_key__: String representation of horizontal axis.
             This should be defined in the circuit metadata for data extraction.
-        __series__: List of curve property definitions. Each element should be
-            defined as SeriesDef entry. This field can be left as None if the
+        __series__: A set of data points that will be fit to a the same parameters
+            in the fit function. If this analysis contains multiple curves,
+            the same number of series definitions should be listed.
+            Each series definition is SeriesDef element, that may be initialized with
+            `name`, `param_names`, `fit_func_index`, `filter_kwargs`.
+            See the Examples below for details. This field can be left as None if the
             analysis is performed for only single line.
         __fit_funcs__: List of callables to fit parameters. This is order sensitive.
             The list index corresponds to the function index specified by __series__ definition.
@@ -249,24 +287,37 @@ class AnalysisExample(CurveAnalysis):
 
                 __param_names__ = ["a", "freq", "phase", "b"]
 
-    .. notes::
-        This class provides several private methods that subclasses can override.
+    Notes:
+        This CurveAnalysis class provides several private methods that subclasses can override.
+
+        - Customize figure generation:
+            Override :meth:`~self._create_figures`. For example, here you can create
+            arbitrary number of new figures or upgrade the default figure appearance.
+
+        - Customize pre-data processing:
+            Override :meth:`~self._data_pre_processing`. For example, here you can
+            take a mean over y values for the same x value, or apply smoothing to y values.
 
-        - _run_fitting: Central method to perform fitting with the provided list of curve data.
-            Subclasses can create initial guesses of parameters and override
-            fitter analysis options here.
-            Note that each curve data provides circuit metadata that may be useful to
-            calculate initial guesses or apply some coefficients to values.
+        - Customize post-analysis data processing:
+            Override :meth:`~self._post_processing`. For example, here you can
+            calculate new entity from fit values. Such as EPC of RB experiment.
 
-        - _create_figure: A method to create figures. Subclasses can override this method
-            to create figures. Both raw data and fit analysis are provided.
+        - Customize fitting options:
+            Override :meth:`~self._setup_fitting`. For example, here you can
+            calculate initial guess from experiment data and setup fitter options.
 
-        - _data_processing: A method to format a list of circuit results into y and yerr values.
-            Subclasses can override this method depending on the expected circuit result format
-            and the output data representation.
+        - Customize data processor calibration:
+            Override :meth:`~Self._calibrate_data_processor`. This is special subroutine
+            that is only called when a DataProcessor instance is used as the data processor.
+            You can take arbitrary data from experiment result and setup your processor.
 
-        - _post_processing: A method to calculate a new entity from a fit result.
-            This returns the fit result as-is by default.
+        Note that other private methods are not expected to be overridden.
+        If you forcibly override these methods, the behavior of analysis logic is not well tested
+        and we cannot guarantee it works as expected (you may suffer from bugs).
+        Instead, you can open an issue in qiskit-experiment github to upgrade this class
+        with proper unittest framework.
+
+        https://github.com/Qiskit/qiskit-experiments/issues
     """
 
     #: str: Metadata key representing a scanned value.
@@ -284,20 +335,8 @@ class AnalysisExample(CurveAnalysis):
     # Callable: Default curve fitter. This can be overwritten.
     __base_fitter__ = scipy_curve_fit_wrapper
 
-    def _run_fitting(self, curve_data: List[CurveEntry], **options) -> AnalysisResult:
-        """Fit series of curve data.
-
-        Subclass can override this method to provide initial guess or fit boundaries.
-        For example, initial guess is not automatically provided by this base class.
-
-        Args:
-            curve_data: List of raw curve data points to fit.
-            **options: Fitting options.
-
-        Returns:
-            Analysis result populated by fit parameters.
-        """
-        return self._series_curve_fit(curve_data=curve_data, **options)
+    # Union[Callable, DataProcessor]: Data processor to format experiment data.
+    __default_data_processor__ = level2_probability
 
     # pylint: disable = unused-argument, missing-return-type-doc
     def _create_figures(self, curve_data: List[CurveEntry], fit_data: AnalysisResult):
@@ -315,48 +354,81 @@ def _create_figures(self, curve_data: List[CurveEntry], fit_data: AnalysisResult
         # TODO implement default figure. Will wait for Qiskit-terra #5499
         return list()
 
-    @staticmethod
-    def _data_processing(data: List[Dict[str, Any]]) -> Tuple[np.ndarray, np.ndarray]:
-        """Format y-values and y-sigmas from list of circuit result entry.
+    # pylint: disable = unused-argument
+    def _setup_fitting(self, curve_data: List[CurveEntry], **options) -> List[FitOptions]:
+        """Setup initial guesses, fit boundaries and other options passed to optimizer.
+
+        Subclass can override this method to provide proper optimization options.
 
         .. notes::
-            This method receives full data list of a single curve.
+            This method returns list of FitOptions dictionary, and the options are
+            passed to the optimizer as a keyword arguments.
+            This should conform to the API which you specified in __base_fitter__.
+            This defaults to scipy curve_fit. If you create multiple FitOptions dictionaries,
+            fit is performed with each FitOptions and the fit result with the minimum
+            `reduced_chisq` will be returned as a final result.
+
+        Args:
+            curve_data: List of raw curve data points to fit.
+            options: User provided fit options.
 
-            This is sometimes convenient for handling level1 (Kerneled) data.
-            The level1 scatter data may spread in the IQ plane, and it may require
-            full experimental results to calculate the principal component to
-            enhance the signal-to-noise ratio of following analysis.
+        Returns:
+            List of FitOptions that are passed to fitter function.
+        """
+        num_params = len(self.__param_names__)
+
+        # no initial guesses and no boundaries by default
+        fit_option = FitOptions(
+            p0=np.zeros(num_params, dtype=float),
+            bounds=([-np.inf] * num_params, [np.inf] * num_params),
+        )
+        fit_option.update(options)
+
+        return [fit_option]
+
+    # pylint: disable = unused-argument
+    @staticmethod
+    def _calibrate_data_processor(
+        data_processor: DataProcessor, experiment_data: ExperimentData
+    ) -> DataProcessor:
+        """An optional subroutine to perform data processor calibration.
+
+        Subclass can override this method to calibrate data processor instance.
+        This routine is called only when a DataProcessor instance is specified in the
+        class attribute __default_data_processor__.
 
         Args:
-            data: List of circuit result entry.
+            data_processor: Data processor instance to calibrate.
+            experiment_data: Unfiltered experiment data set.
 
         Returns:
-            - y_values: Numpy array of formatted y data values.
-            - y_sigmas: Numpy array of formatted y error values.
+            Calibrated data processor instance.
         """
-        try:
-            n_qubits = len(data[0]["metadata"]["qubits"])
-        except KeyError:
-            n_qubits = 1
+        return data_processor
 
-        # TODO data processor may be initialized with some variables.
-        # For example, if it contains front end discriminator, it may be initialized with
-        # some discrimination line parameters. These parameters cannot be hard-coded here.
+    @staticmethod
+    def _data_pre_processing(
+        x_values: np.ndarray, y_values: np.ndarray, y_sigmas: np.ndarray
+    ) -> Tuple[np.ndarray, ...]:
+        """An optional subroutine to perform data pre-processing.
+
+        Subclasses can override this method to apply pre-precessing to data values to fit.
+        Otherwise the analysis uses extracted data values as-is.
 
-        y_values = np.zeros(len(data), dtype=float)
-        y_sigmas = np.zeros(len(data), dtype=float)
-        for idx, datum in enumerate(data):
-            # TODO this should be replaced with preset DataProcessor.
+        For example,
 
-            # TODO fix sigma definition
-            # When the count is 100% zero (i.e. simulator), this yields sigma=0.
-            # This crashes scipy fitter when it calculates covariance matrix (zero-div error).
+        - Take mean over all y data values with the same x data value
+        - Apply smoothing to y values to deal with noisy observed values
 
-            y_val, y_err = level2_probability(datum, outcome="1" * n_qubits)
-            y_values[idx] = y_val
-            y_sigmas[idx] = y_err
+        Args:
+            x_values: Numpy float array to represent X values.
+            y_values: Numpy float array to represent Y values.
+            y_sigmas: Numpy float array to represent Y errors.
 
-        return y_values, y_sigmas
+        Returns:
+            Numpy array tuple of pre-processed (x_values, y_values, y_sigmas).
+        """
+        return x_values, y_values, y_sigmas
 
     @staticmethod
     def _post_processing(analysis_result: AnalysisResult) -> AnalysisResult:
@@ -372,7 +444,11 @@ def _post_processing(analysis_result: AnalysisResult) -> AnalysisResult:
         """
         return analysis_result
 
-    def _extract_curves(self, experiment_data: ExperimentData) -> List[CurveEntry]:
+    def _extract_curves(
+        self,
+        experiment_data: ExperimentData,
+        data_processor: Union[Callable, DataProcessor],
+    ) -> List[CurveEntry]:
         """Extract curve data from experiment data.
 
         .. notes::
@@ -384,6 +460,9 @@ def _extract_curves(self, experiment_data: ExperimentData) -> List[CurveEntry]:
 
         Args:
             experiment_data: ExperimentData object to fit parameters.
+            data_processor: A callable or DataProcessor instance to format data into numpy array.
+                This should take list of dictionary and returns two tuple of float values
+                that represent a y value and an error of it.
 
         Returns:
             List of ``CurveEntry`` containing x-values, y-values, and y values sigma.
@@ -425,14 +504,19 @@ def _is_target_series(datum, **filters):
 
             # Format x, y, yerr data
             try:
-                xvals = np.asarray(
-                    [datum["metadata"][self.__x_key__] for datum in series_data], dtype=float
-                )
+                xvals = [datum["metadata"][self.__x_key__] for datum in series_data]
             except KeyError as ex:
                 raise QiskitError(
                     f"X value key {self.__x_key__} is not defined in circuit metadata."
                 ) from ex
-            yvals, sigmas = self._data_processing(series_data)
+            yvals, yerrs = zip(*map(data_processor, series_data))
+
+            # Apply data pre-processing
+            prepared_xvals, prepared_yvals, prepared_yerrs = self._data_pre_processing(
+                x_values=np.asarray(xvals, dtype=float),
+                y_values=np.asarray(yvals, dtype=float),
+                y_sigmas=np.asarray(yerrs, dtype=float),
+            )
 
             # Get common metadata fields except for xval and filter args.
             # These properties are obvious.
@@ -456,21 +540,19 @@ def _is_target_series(datum, **filters):
             curve_data.append(
                 CurveEntry(
                     curve_name=curve_properties.name,
-                    x_values=xvals,
-                    y_values=yvals,
-                    y_sigmas=sigmas,
+                    x_values=prepared_xvals,
+                    y_values=prepared_yvals,
+                    y_sigmas=prepared_yerrs,
                     metadata=dict(curve_metadata),
                 )
             )
 
         return curve_data
 
-    def _series_curve_fit(
+    def _run_fitting(
         self,
         curve_data: List[CurveEntry],
-        p0: Optional[np.ndarray] = None,
         weights: Optional[np.ndarray] = None,
-        bounds: Optional[Tuple[np.ndarray, np.ndarray]] = None,
         **options,
     ) -> AnalysisResult:
         r"""Perform a linearized multi-objective non-linear least squares fit.
@@ -487,11 +569,9 @@ def _series_curve_fit(
         using ``scipy.optimize.curve_fit``.
 
         Args:
-            p0: initial guess for optimization parameters.
+            curve_data: A list of curve data to fit.
             weights: Optional, a 1D float list of weights :math:`w_k` for each
                      component function :math:`f_k`.
-            bounds: Optional, lower and upper bounds for optimization
-                    parameters.
             options: additional kwargs for scipy.optimize.curve_fit.
 
         Returns:
@@ -505,13 +585,13 @@ def _series_curve_fit(
         Raises:
             QiskitError:
                 - When number of weights are not identical to the curve_data entries.
+            KeyError:
+                - When fit function doesn't return Chi squared value.
         """
         num_curves = len(curve_data)
-        num_params = len(self.__param_names__)
 
-        # Set initial guess and bounds if they are not provided
-        p0 = p0 or np.zeros(num_params)
-        bounds = bounds or ([-np.inf] * num_params, [np.inf] * num_params)
+        # Setup fitting options
+        fit_options = self._setup_fitting(curve_data, **options)
 
         # Validate weights
         if weights is None:
@@ -550,18 +630,30 @@ def multi_objective_fit(x, *params):
                 y = np.concatenate((y, yi))
             return y
 
-        analysis_result = self.__base_fitter__.__func__(
-            func=multi_objective_fit,
-            xdata=flat_xvals,
-            ydata=flat_yvals,
-            p0=p0,
-            sigma=flat_yerrs,
-            bounds=bounds,
-            **options,
-        )
-        analysis_result["popt_keys"] = self.__param_names__
+        # Try fit with each fit option
+        fit_results = [
+            self.__base_fitter__.__func__(
+                f=multi_objective_fit,
+                xdata=flat_xvals,
+                ydata=flat_yvals,
+                sigma=flat_yerrs,
+                **fit_option
+            )
+            for fit_option in fit_options
+        ]
 
-        return analysis_result
+        # Sort by fit error
+        try:
+            fit_results = sorted(fit_results, key=lambda r: r["reduced_chisq"])
+        except KeyError:
+            raise KeyError(
+                "Returned analysis result does not provide reduced Chi squared value."
+            )
+
+        best_analysis_result = fit_results[0]
+        best_analysis_result["popt_keys"] = self.__param_names__
+
+        return best_analysis_result
 
     def _fit_curve(self, curve_name: str, xvals: np.ndarray, *params) -> np.ndarray:
         """A helper method to return fit curve for the specific series.
@@ -633,8 +725,9 @@ def _run_analysis(self, experiment_data: ExperimentData, **options):
         """Run analysis on circuit data.
 
         Args:
-            experiment_data: the experiment data to analyze.
-            options: kwarg options for analysis function.
+            experiment_data: The experiment data to analyze.
+            options: kwarg options for analysis function. This may contain `data_processor` key
+                as a special argument so that user can override default data processor.
 
         Returns:
             tuple: A pair ``(analysis_results, figures)`` where
@@ -644,9 +737,30 @@ def _run_analysis(self, experiment_data: ExperimentData, **options):
         """
         analysis_result = AnalysisResult()
 
+        # Setup data processor
+        if "data_processor" in options:
+            # Use user provided processor
+            data_processor = options.pop("data_processor")
+        else:
+            # Use default processor
+            if isinstance(self.__default_data_processor__, DataProcessor):
+                # Calibrate default data processor instance
+                try:
+                    data_processor = self._calibrate_data_processor(
+                        data_processor=self.__default_data_processor__,
+                        experiment_data=experiment_data,
+                    )
+                except DataProcessorError as ex:
+                    analysis_result["error_message"] = str(ex)
+                    analysis_result["success"] = False
+                    return analysis_result, list()
+            else:
+                # Callback function
+                data_processor = self.__default_data_processor__.__func__
+
         # Extract curve entries from experiment data
         try:
-            curve_data = self._extract_curves(experiment_data)
+            curve_data = self._extract_curves(experiment_data, data_processor)
         except DataProcessorError as ex:
             analysis_result["error_message"] = str(ex)
             analysis_result["success"] = False
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index 7a2229561e..13dd51b6e9 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -98,11 +98,12 @@ def test_run_single_curve_analysis(self):
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2])
 
         # check result data
+        self.assertTrue(results["success"])
+
         np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)
         self.assertEqual(results["dof"], 27)
         self.assertListEqual(results["xrange"], [0.1, 1.0])
         self.assertListEqual(results["popt_keys"], ["p0", "p1", "p2"])
-        self.assertTrue(results["success"])
 
     def test_run_single_curve_fail(self):
         """Test analysis returns status when it fails."""
@@ -164,8 +165,8 @@ def test_run_two_curves_with_same_fitfunc(self):
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
 
         # check result data
-        np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)
         self.assertTrue(results["success"])
+        np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)
 
     def test_run_two_curves_with_two_fitfuncs(self):
         """Test analysis for two curves. Curves shares fit parameters."""
@@ -208,5 +209,5 @@ def test_run_two_curves_with_two_fitfuncs(self):
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
 
         # check result data
-        np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)
         self.assertTrue(results["success"])
+        np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)

From 1c4913c046f11ac1665b6eca107946e7aa659a54 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 13 May 2021 16:10:42 +0900
Subject: [PATCH 14/74] readd 52c99ea and 0420d1d

---
 qiskit_experiments/analysis/curve_analysis.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index ee32174f4b..faa61d3ed3 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -98,7 +98,7 @@ def scipy_curve_fit_wrapper(
         parameters via ``pcov(absolute_sigma=False) = pcov * reduced_chisq``
         ``popt_err(absolute_sigma=False) = popt_err * sqrt(reduced_chisq)``.
     """
-    # Check the degrees of freedom is greater than 0
+    # Check that degrees of freedom is greater than 0
     dof = len(ydata) - len(p0)
     if dof < 1:
         raise QiskitError(
@@ -183,8 +183,8 @@ class CurveAnalysis(BaseAnalysis):
 
     Class Attributes:
 
-        __x_key__: String representation of horizontal axis.
-            This should be defined in the circuit metadata for data extraction.
+        __x_key__: Key in the circuit metadata under which to find the value for
+            the horizontal axis.
         __series__: A set of data points that will be fit to a the same parameters
             in the fit function. If this analysis contains multiple curves,
             the same number of series definitions should be listed.

From eb29087138544ca2a36c608bd923a28ff76f9116 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 13 May 2021 17:24:27 +0900
Subject: [PATCH 15/74] add fit functions

---
 qiskit_experiments/analysis/curve_analysis.py |  7 +-
 qiskit_experiments/analysis/fit_functions.py  | 47 ++++++++++++
 test/analysis/test_curve_fit.py               | 73 +++++++++++--------
 3 files changed, 91 insertions(+), 36 deletions(-)
 create mode 100644 qiskit_experiments/analysis/fit_functions.py

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index faa61d3ed3..610c544995 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -9,6 +9,7 @@
 # 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.
+
 """
 Analysis class for curve fitting.
 """
@@ -637,7 +638,7 @@ def multi_objective_fit(x, *params):
                 xdata=flat_xvals,
                 ydata=flat_yvals,
                 sigma=flat_yerrs,
-                **fit_option
+                **fit_option,
             )
             for fit_option in fit_options
         ]
@@ -646,9 +647,7 @@ def multi_objective_fit(x, *params):
         try:
             fit_results = sorted(fit_results, key=lambda r: r["reduced_chisq"])
         except KeyError:
-            raise KeyError(
-                "Returned analysis result does not provide reduced Chi squared value."
-            )
+            raise KeyError("Returned analysis result does not provide reduced Chi squared value.")
 
         best_analysis_result = fit_results[0]
         best_analysis_result["popt_keys"] = self.__param_names__
diff --git a/qiskit_experiments/analysis/fit_functions.py b/qiskit_experiments/analysis/fit_functions.py
new file mode 100644
index 0000000000..10e2cbab2e
--- /dev/null
+++ b/qiskit_experiments/analysis/fit_functions.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.
+
+"""
+A library of fit functions.
+"""
+# pylint: disable=invalid-name
+
+import numpy as np
+
+
+def cos(x: np.ndarray, amp: float, freq: float, phase: float, baseline: float) -> np.ndarray:
+    r"""Cosine function.
+
+    .. math::
+        y = {\rm amp} \cos\left(2 \pi {\fm freq} x + {\rm phase}\right) + {\rm baseline}
+    """
+    return amp * np.cos(2 * np.pi * freq * x + phase) + baseline
+
+
+def sin(x: np.ndarray, amp: float, freq: float, phase: float, baseline: float) -> np.ndarray:
+    r"""Sine function.
+
+    .. math::
+        y = {\rm amp} \sin\left(2 \pi {\fm freq} x + {\rm phase}\right) + {\rm baseline}
+    """
+    return amp * np.cos(2 * np.pi * freq * x + phase) + baseline
+
+
+def exponential_decay(
+    x: np.ndarray, amp: float, lamb: float, x0: float, baseline: float
+) -> np.ndarray:
+    r"""Exponential function
+
+    .. math::
+        y = {\rm amp} \exp \left( - \lambda x + {\rm x0} \right) + {\rm baseline}
+    """
+    return amp * np.exp(-lamb * x + x0) + baseline
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index 13dd51b6e9..dbb7b09516 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -19,6 +19,7 @@
 
 from qiskit_experiments import ExperimentData
 from qiskit_experiments.analysis import CurveAnalysis, SeriesDef
+from qiskit_experiments.analysis import fit_functions
 from qiskit_experiments.base_experiment import BaseExperiment
 
 
@@ -80,43 +81,50 @@ def setUp(self):
         super().setUp()
         self.xvalues = np.linspace(0.1, 1, 30)
 
-        # fit functions
-        self.exp_func = lambda x, p0, p1, p2: p0 * np.exp(p1 * x) + p2
-        self.cos_func = lambda x, p0, p1, p2, p3: p0 * np.cos(2 * np.pi * p1 * x + p2) + p3
-        self.sin_func = lambda x, p0, p1, p2, p3: p0 * np.sin(2 * np.pi * p1 * x + p2) + p3
-
     def test_run_single_curve_analysis(self):
         """Test analysis for single curve."""
-        analysis = create_new_analysis(fit_funcs=[self.exp_func], param_names=["p0", "p1", "p2"])
+        analysis = create_new_analysis(
+            fit_funcs=[fit_functions.exponential_decay], param_names=["p0", "p1", "p2", "p3"]
+        )
         ref_p0 = 0.9
-        ref_p1 = -2.5
-        ref_p2 = 0.1
+        ref_p1 = 2.5
+        ref_p2 = 0.0
+        ref_p3 = 0.1
 
-        test_data = simulate_output_data(self.exp_func, self.xvalues, ref_p0, ref_p1, ref_p2)
-        results, _ = analysis._run_analysis(test_data, p0=[ref_p0, ref_p1, ref_p2])
+        test_data = simulate_output_data(
+            fit_functions.exponential_decay, self.xvalues, ref_p0, ref_p1, ref_p2, ref_p3
+        )
+        results, _ = analysis._run_analysis(test_data, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
 
-        ref_popt = np.asarray([ref_p0, ref_p1, ref_p2])
+        ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
 
         # check result data
         self.assertTrue(results["success"])
 
         np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)
-        self.assertEqual(results["dof"], 27)
+        self.assertEqual(results["dof"], 26)
         self.assertListEqual(results["xrange"], [0.1, 1.0])
-        self.assertListEqual(results["popt_keys"], ["p0", "p1", "p2"])
+        self.assertListEqual(results["popt_keys"], ["p0", "p1", "p2", "p3"])
 
     def test_run_single_curve_fail(self):
         """Test analysis returns status when it fails."""
-        analysis = create_new_analysis(fit_funcs=[self.exp_func], param_names=["p0", "p1", "p2"])
+        analysis = create_new_analysis(
+            fit_funcs=[fit_functions.exponential_decay], param_names=["p0", "p1", "p2", "p3"]
+        )
         ref_p0 = 0.9
-        ref_p1 = -2.5
-        ref_p2 = 0.1
+        ref_p1 = 2.5
+        ref_p2 = 0.0
+        ref_p3 = 0.1
 
-        test_data = simulate_output_data(self.exp_func, self.xvalues, ref_p0, ref_p1, ref_p2)
+        test_data = simulate_output_data(
+            fit_functions.exponential_decay, self.xvalues, ref_p0, ref_p1, ref_p2, ref_p3
+        )
 
         # Try to fit with infeasible parameter boundary. This should fail.
         results, _ = analysis._run_analysis(
-            test_data, p0=[ref_p0, ref_p1, ref_p2], bounds=([-10, -10, -10], [0, 0, 0])
+            test_data,
+            p0=[ref_p0, ref_p1, ref_p2, ref_p3],
+            bounds=([-10, -10, -10, -10], [0, 0, 0, 0]),
         )
 
         self.assertFalse(results["success"])
@@ -130,39 +138,40 @@ def test_run_two_curves_with_same_fitfunc(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    param_names=["p0", "p1", "p3"],
+                    param_names=["p0", "p1", "p3", "p4"],
                     fit_func_index=0,
                     filter_kwargs={"exp": 0},
                 ),
                 SeriesDef(
                     name="curve2",
-                    param_names=["p0", "p2", "p3"],
+                    param_names=["p0", "p2", "p3", "p4"],
                     fit_func_index=0,
                     filter_kwargs={"exp": 1},
                 ),
             ],
-            fit_funcs=[self.exp_func],
-            param_names=["p0", "p1", "p2", "p3"],
+            fit_funcs=[fit_functions.exponential_decay],
+            param_names=["p0", "p1", "p2", "p3", "p4"],
         )
         ref_p0 = 0.9
-        ref_p1 = -7.0
-        ref_p2 = -5.0
-        ref_p3 = 0.1
+        ref_p1 = 7.0
+        ref_p2 = 5.0
+        ref_p3 = 0.0
+        ref_p4 = 0.1
 
         test_data0 = simulate_output_data(
-            self.exp_func, self.xvalues, ref_p0, ref_p1, ref_p3, exp=0
+            fit_functions.exponential_decay, self.xvalues, ref_p0, ref_p1, ref_p3, ref_p4, exp=0
         )
         test_data1 = simulate_output_data(
-            self.exp_func, self.xvalues, ref_p0, ref_p2, ref_p3, exp=1
+            fit_functions.exponential_decay, self.xvalues, ref_p0, ref_p2, ref_p3, ref_p4, exp=1
         )
 
         # merge two experiment data
         for datum in test_data1.data:
             test_data0.add_data(datum)
 
-        results, _ = analysis._run_analysis(test_data0, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
+        results, _ = analysis._run_analysis(test_data0, p0=[ref_p0, ref_p1, ref_p2, ref_p3, ref_p4])
 
-        ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
+        ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3, ref_p4])
 
         # check result data
         self.assertTrue(results["success"])
@@ -185,7 +194,7 @@ def test_run_two_curves_with_two_fitfuncs(self):
                     filter_kwargs={"exp": 1},
                 ),
             ],
-            fit_funcs=[self.cos_func, self.sin_func],
+            fit_funcs=[fit_functions.cos, fit_functions.sin],
             param_names=["p0", "p1", "p2", "p3"],
         )
         ref_p0 = 0.1
@@ -194,10 +203,10 @@ def test_run_two_curves_with_two_fitfuncs(self):
         ref_p3 = 0.5
 
         test_data0 = simulate_output_data(
-            self.cos_func, self.xvalues, ref_p0, ref_p1, ref_p2, ref_p3, exp=0
+            fit_functions.cos, self.xvalues, ref_p0, ref_p1, ref_p2, ref_p3, exp=0
         )
         test_data1 = simulate_output_data(
-            self.sin_func, self.xvalues, ref_p0, ref_p1, ref_p2, ref_p3, exp=1
+            fit_functions.sin, self.xvalues, ref_p0, ref_p1, ref_p2, ref_p3, exp=1
         )
 
         # merge two experiment data

From c3ced56977642dbdc6b0d3e1cd647f417b60d5a5 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 13 May 2021 17:28:17 +0900
Subject: [PATCH 16/74] lint

---
 qiskit_experiments/analysis/curve_analysis.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 610c544995..8a7d34eef5 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -646,8 +646,10 @@ def multi_objective_fit(x, *params):
         # Sort by fit error
         try:
             fit_results = sorted(fit_results, key=lambda r: r["reduced_chisq"])
-        except KeyError:
-            raise KeyError("Returned analysis result does not provide reduced Chi squared value.")
+        except KeyError as ex:
+            raise KeyError(
+                "Returned analysis result does not provide reduced Chi squared value."
+            ) from ex
 
         best_analysis_result = fit_results[0]
         best_analysis_result["popt_keys"] = self.__param_names__

From 1a56ee94e77681c913cbb04a76a7a489e7404233 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 14 May 2021 03:31:38 +0900
Subject: [PATCH 17/74] review by eggerdj r2

- change dp calibration logic
- add gaussian function
---
 qiskit_experiments/analysis/__init__.py       |  8 +++++
 qiskit_experiments/analysis/curve_analysis.py | 34 +++++++++----------
 qiskit_experiments/analysis/fit_functions.py  |  9 +++++
 3 files changed, 33 insertions(+), 18 deletions(-)

diff --git a/qiskit_experiments/analysis/__init__.py b/qiskit_experiments/analysis/__init__.py
index a1441de94a..018a426d5b 100644
--- a/qiskit_experiments/analysis/__init__.py
+++ b/qiskit_experiments/analysis/__init__.py
@@ -14,3 +14,11 @@
 Analysis helper functions
 """
 from qiskit_experiments.analysis.curve_analysis import CurveAnalysis, SeriesDef, FitOptions
+
+# fit functions (alphabetical import ordering)
+from qiskit_experiments.analysis.fit_functions import (
+    cos,
+    exponential_decay,
+    gaussian,
+    sin,
+)
diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 8a7d34eef5..fa3f2ccd2e 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -739,25 +739,23 @@ def _run_analysis(self, experiment_data: ExperimentData, **options):
         analysis_result = AnalysisResult()
 
         # Setup data processor
-        if "data_processor" in options:
-            # Use user provided processor
-            data_processor = options.pop("data_processor")
+        data_processor = options.pop("data_processor", self.__default_data_processor__)
+
+        # TODO add ` and not data_processor.trained:`
+        if isinstance(data_processor, DataProcessor):
+            # Qiskit DataProcessor instance. May need calibration.
+            try:
+                data_processor = self._calibrate_data_processor(
+                    data_processor=data_processor,
+                    experiment_data=experiment_data,
+                )
+            except DataProcessorError as ex:
+                analysis_result["error_message"] = str(ex)
+                analysis_result["success"] = False
+                return analysis_result, list()
         else:
-            # Use default processor
-            if isinstance(self.__default_data_processor__, DataProcessor):
-                # Calibrate default data processor instance
-                try:
-                    data_processor = self._calibrate_data_processor(
-                        data_processor=self.__default_data_processor__,
-                        experiment_data=experiment_data,
-                    )
-                except DataProcessorError as ex:
-                    analysis_result["error_message"] = str(ex)
-                    analysis_result["success"] = False
-                    return analysis_result, list()
-            else:
-                # Callback function
-                data_processor = self.__default_data_processor__.__func__
+            # Callback function
+            data_processor = data_processor.__func__
 
         # Extract curve entries from experiment data
         try:
diff --git a/qiskit_experiments/analysis/fit_functions.py b/qiskit_experiments/analysis/fit_functions.py
index 10e2cbab2e..ff9b83345a 100644
--- a/qiskit_experiments/analysis/fit_functions.py
+++ b/qiskit_experiments/analysis/fit_functions.py
@@ -45,3 +45,12 @@ def exponential_decay(
         y = {\rm amp} \exp \left( - \lambda x + {\rm x0} \right) + {\rm baseline}
     """
     return amp * np.exp(-lamb * x + x0) + baseline
+
+
+def gaussian(x: np.ndarray, amp: float, sigma: float, x0: float, baseline: float) -> np.ndarray:
+    r"""Gaussian function
+
+    .. math::
+        y = {\rm amp} \exp \left( - (x - x0)^2 / \sigma^2 \right) + {\rm baseline}
+    """
+    return amp * np.exp(-((x - x0) ** 2) / sigma ** 2) + baseline

From 8de5e37ad97a0556fb5a328e6a28ce5e183e81b5 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 14 May 2021 04:21:13 +0900
Subject: [PATCH 18/74] add data processor keys in metadata

add data processor keys in metadata
---
 qiskit_experiments/analysis/curve_analysis.py | 77 +++++++++++++------
 test/analysis/test_curve_fit.py               | 73 +++++++++++++++++-
 2 files changed, 126 insertions(+), 24 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index fa3f2ccd2e..dd64755431 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -36,6 +36,7 @@
         ("param_names", List[str]),
         ("fit_func_index", int),
         ("filter_kwargs", Optional[Dict[str, Any]]),
+        ("data_option_keys", Optional[List[str]]),
     ],
 )
 
@@ -189,10 +190,20 @@ class CurveAnalysis(BaseAnalysis):
         __series__: A set of data points that will be fit to a the same parameters
             in the fit function. If this analysis contains multiple curves,
             the same number of series definitions should be listed.
-            Each series definition is SeriesDef element, that may be initialized with
-            `name`, `param_names`, `fit_func_index`, `filter_kwargs`.
-            See the Examples below for details. This field can be left as None if the
-            analysis is performed for only single line.
+            Each series definition is SeriesDef element, that may be initialized with::
+
+                name: Name of the curve. This is arbitrary field.
+                param_names: Name of parameters. This is order sensitive. The parameter names
+                    should be involved in __param_names__.
+                fit_func_index: Index of fitting function associated with this curve.
+                    The fitting function should be listed in __fit_funcs__.
+                filter_kwargs: Circuit metadata key and value associated with this curve.
+                    The data points of the curve is extracted from ExperimentData based on
+                    this information.
+                data_option_keys: Circuit metadata keys that are passed to the data processor.
+                    The key should conform to the data processor API.
+
+            See the Examples below for more details.
         __fit_funcs__: List of callables to fit parameters. This is order sensitive.
             The list index corresponds to the function index specified by __series__ definition.
         __param_names__: Name of parameters to fit. This is order sensitive.
@@ -205,7 +216,7 @@ class CurveAnalysis(BaseAnalysis):
         =============
 
         In this type of experiment, the analysis deals with a single curve.
-        Thus __series__ is not necessarily assigned.
+        Thus filter_kwargs is not necessary defined.
 
         .. code-block::
 
@@ -213,6 +224,16 @@ class AnalysisExample(CurveAnalysis):
 
                 __x_key__ = "delay"
 
+                __series__ = [
+                    SeriesDef(
+                        name="t1_decay",
+                        param_names=["a", "tau", "b"],
+                        fit_func_index=0,
+                        filter_kwargs=None,
+                        data_option_keys=["outcome"]
+                    )
+                ]
+
                 __fit_funcs__ = [library.exponential]
 
                 __param_names__ = ["a", "tau", "b"]
@@ -236,13 +257,15 @@ class AnalysisExample(CurveAnalysis):
                         name="standard_rb",
                         param_names=["a", "alpha_std", "b"],
                         fit_func_index=0,
-                        filter_kwargs={"interleaved": False}
+                        filter_kwargs={"interleaved": False},
+                        data_option_keys=["outcome"]
                     ),
                     SeriesDef(
                         name="interleaved_rb",
                         param_names=["a", "alpha_int", "b"],
                         fit_func_index=0,
-                        filter_kwargs={"interleaved": True}
+                        filter_kwargs={"interleaved": True},
+                        data_option_keys=["outcome"]
                     )
                 ]
 
@@ -274,13 +297,15 @@ class AnalysisExample(CurveAnalysis):
                         name="x",
                         param_names=["a", "freq", "phase", "b"],
                         fit_func_index=0,
-                        filter_kwargs={"pulse": "x"}
+                        filter_kwargs={"pulse": "x"},
+                        data_option_keys=["outcome"]
                     ),
                     SeriesDef(
                         name="y",
                         param_names=["a", "freq", "phase", "b"],
                         fit_func_index=1,
-                        filter_kwargs={"pulse": "y"}
+                        filter_kwargs={"pulse": "y"},
+                        data_option_keys=["outcome"]
                     )
                 ]
 
@@ -471,18 +496,12 @@ def _extract_curves(
         Raises:
             QiskitError:
                 - When __x_key__ is not defined in the circuit metadata.
+                - When __series__ is not defined.
+            KeyError:
+                - When circuit metadata doesn't provide required data processor options.
         """
-        if self.__series__:
-            series = self.__series__
-        else:
-            series = [
-                SeriesDef(
-                    name="fit-curve-0",
-                    param_names=self.__param_names__,
-                    fit_func_index=0,
-                    filter_kwargs=None,
-                )
-            ]
+        if self.__series__ is None:
+            raise QiskitError("Curve __series__ is not provided for this analysis.")
 
         def _is_target_series(datum, **filters):
             try:
@@ -491,7 +510,7 @@ def _is_target_series(datum, **filters):
                 return False
 
         curve_data = list()
-        for curve_properties in series:
+        for curve_properties in self.__series__:
             if curve_properties.filter_kwargs:
                 # filter data
                 series_data = [
@@ -510,7 +529,21 @@ def _is_target_series(datum, **filters):
                 raise QiskitError(
                     f"X value key {self.__x_key__} is not defined in circuit metadata."
                 ) from ex
-            yvals, yerrs = zip(*map(data_processor, series_data))
+
+            option_keys = curve_properties.data_option_keys or dict()
+
+            def _data_processing(datum):
+                # A helper function to receive data processor runtime option from metadata
+                try:
+                    # Extract data processor options
+                    dp_options = {key: datum["metadata"][key] for key in option_keys}
+                except KeyError as ex:
+                    raise KeyError(
+                        "Required data processor options are not provided by circuit metadata."
+                    ) from ex
+                return data_processor(datum, **dp_options)
+
+            yvals, yerrs = zip(*map(_data_processing, series_data))
 
             # Apply data pre-processing
             prepared_xvals, prepared_yvals, prepared_yerrs = self._data_pre_processing(
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index dbb7b09516..d94b446a78 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -11,6 +11,7 @@
 # that they have been altered from the originals.
 
 """Test curve fitting base class."""
+# pylint: disable=invalid-name
 
 from typing import List, Callable
 
@@ -84,7 +85,17 @@ def setUp(self):
     def test_run_single_curve_analysis(self):
         """Test analysis for single curve."""
         analysis = create_new_analysis(
-            fit_funcs=[fit_functions.exponential_decay], param_names=["p0", "p1", "p2", "p3"]
+            series=[
+                SeriesDef(
+                    name="curve1",
+                    param_names=["p0", "p1", "p2", "p3"],
+                    fit_func_index=0,
+                    filter_kwargs=None,
+                    data_option_keys=None,
+                )
+            ],
+            fit_funcs=[fit_functions.exponential_decay],
+            param_names=["p0", "p1", "p2", "p3"],
         )
         ref_p0 = 0.9
         ref_p1 = 2.5
@@ -109,7 +120,17 @@ def test_run_single_curve_analysis(self):
     def test_run_single_curve_fail(self):
         """Test analysis returns status when it fails."""
         analysis = create_new_analysis(
-            fit_funcs=[fit_functions.exponential_decay], param_names=["p0", "p1", "p2", "p3"]
+            series=[
+                SeriesDef(
+                    name="curve1",
+                    param_names=["p0", "p1", "p2", "p3"],
+                    fit_func_index=0,
+                    filter_kwargs=None,
+                    data_option_keys=None,
+                )
+            ],
+            fit_funcs=[fit_functions.exponential_decay],
+            param_names=["p0", "p1", "p2", "p3"],
         )
         ref_p0 = 0.9
         ref_p1 = 2.5
@@ -141,12 +162,14 @@ def test_run_two_curves_with_same_fitfunc(self):
                     param_names=["p0", "p1", "p3", "p4"],
                     fit_func_index=0,
                     filter_kwargs={"exp": 0},
+                    data_option_keys=None,
                 ),
                 SeriesDef(
                     name="curve2",
                     param_names=["p0", "p2", "p3", "p4"],
                     fit_func_index=0,
                     filter_kwargs={"exp": 1},
+                    data_option_keys=None,
                 ),
             ],
             fit_funcs=[fit_functions.exponential_decay],
@@ -186,12 +209,14 @@ def test_run_two_curves_with_two_fitfuncs(self):
                     param_names=["p0", "p1", "p2", "p3"],
                     fit_func_index=0,
                     filter_kwargs={"exp": 0},
+                    data_option_keys=None,
                 ),
                 SeriesDef(
                     name="curve2",
                     param_names=["p0", "p1", "p2", "p3"],
                     fit_func_index=1,
                     filter_kwargs={"exp": 1},
+                    data_option_keys=None,
                 ),
             ],
             fit_funcs=[fit_functions.cos, fit_functions.sin],
@@ -220,3 +245,47 @@ def test_run_two_curves_with_two_fitfuncs(self):
         # check result data
         self.assertTrue(results["success"])
         np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)
+
+    def test_fit_with_data_option(self):
+        """Test analysis by passing data processing option to the data processor."""
+
+        def inverted_decay(x, p0, p1, p2, p3):
+            # measure inverse of population
+            return 1 - fit_functions.exponential_decay(x, p0, p1, p2, p3)
+
+        analysis = create_new_analysis(
+            series=[
+                SeriesDef(
+                    name="curve1",
+                    param_names=["p0", "p1", "p2", "p3"],
+                    fit_func_index=0,
+                    filter_kwargs=None,
+                    data_option_keys=["outcome"],
+                )
+            ],
+            fit_funcs=[inverted_decay],
+            param_names=["p0", "p1", "p2", "p3"],
+        )
+        ref_p0 = 0.9
+        ref_p1 = 2.5
+        ref_p2 = 0.0
+        ref_p3 = 0.1
+
+        # tell metadata to count zero
+        test_data = simulate_output_data(
+            fit_functions.exponential_decay,
+            self.xvalues,
+            ref_p0,
+            ref_p1,
+            ref_p2,
+            ref_p3,
+            outcome="0",
+        )
+        results, _ = analysis._run_analysis(test_data, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
+
+        ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
+
+        # check result data
+        self.assertTrue(results["success"])
+
+        np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)

From fc67de71bcb7672e984aacff6ffdcf392060c473 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 14 May 2021 04:49:31 +0900
Subject: [PATCH 19/74] conform to #41

---
 qiskit_experiments/analysis/curve_analysis.py | 27 +++++++-------
 test/analysis/test_curve_fit.py               | 35 +++++++++++--------
 2 files changed, 34 insertions(+), 28 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index dd64755431..6e863ce706 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -515,12 +515,12 @@ def _is_target_series(datum, **filters):
                 # filter data
                 series_data = [
                     datum
-                    for datum in experiment_data.data
+                    for datum in experiment_data.data()
                     if _is_target_series(datum, **curve_properties.filter_kwargs)
                 ]
             else:
                 # use data as-is
-                series_data = experiment_data.data
+                series_data = experiment_data.data()
 
             # Format x, y, yerr data
             try:
@@ -755,19 +755,20 @@ def _fit_curve(self, curve_name: str, xvals: np.ndarray, *params) -> np.ndarray:
 
         raise QiskitError(f"A curve {curve_name} is not defined in this class.")
 
-    def _run_analysis(self, experiment_data: ExperimentData, **options):
+    def _run_analysis(
+        self, data: ExperimentData, **options
+    ) -> Tuple[List[AnalysisResult], List["Figure"]]:
         """Run analysis on circuit data.
 
         Args:
-            experiment_data: The experiment data to analyze.
-            options: kwarg options for analysis function. This may contain `data_processor` key
-                as a special argument so that user can override default data processor.
+            experiment_data: the experiment data to analyze.
+            options: kwarg options for analysis function.
 
         Returns:
             tuple: A pair ``(analysis_results, figures)`` where
                    ``analysis_results`` may be a single or list of
-                   AnalysisResult objects, and ``figures`` may be
-                   None, a single figure, or a list of figures.
+                   AnalysisResult objects, and ``figures`` is a list of any
+                   figures for the experiment.
         """
         analysis_result = AnalysisResult()
 
@@ -780,23 +781,23 @@ def _run_analysis(self, experiment_data: ExperimentData, **options):
             try:
                 data_processor = self._calibrate_data_processor(
                     data_processor=data_processor,
-                    experiment_data=experiment_data,
+                    experiment_data=data,
                 )
             except DataProcessorError as ex:
                 analysis_result["error_message"] = str(ex)
                 analysis_result["success"] = False
-                return analysis_result, list()
+                return [analysis_result], list()
         else:
             # Callback function
             data_processor = data_processor.__func__
 
         # Extract curve entries from experiment data
         try:
-            curve_data = self._extract_curves(experiment_data, data_processor)
+            curve_data = self._extract_curves(data, data_processor)
         except DataProcessorError as ex:
             analysis_result["error_message"] = str(ex)
             analysis_result["success"] = False
-            return analysis_result, list()
+            return [analysis_result], list()
 
         # Run fitting
         # pylint: disable=broad-except
@@ -824,4 +825,4 @@ def _run_analysis(self, experiment_data: ExperimentData, **options):
             }
         analysis_result["raw_data"] = raw_data
 
-        return analysis_result, figures
+        return [analysis_result], figures
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index d94b446a78..057987abe9 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -106,16 +106,17 @@ def test_run_single_curve_analysis(self):
             fit_functions.exponential_decay, self.xvalues, ref_p0, ref_p1, ref_p2, ref_p3
         )
         results, _ = analysis._run_analysis(test_data, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
+        result = results[0]
 
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
 
         # check result data
-        self.assertTrue(results["success"])
+        self.assertTrue(result["success"])
 
-        np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)
-        self.assertEqual(results["dof"], 26)
-        self.assertListEqual(results["xrange"], [0.1, 1.0])
-        self.assertListEqual(results["popt_keys"], ["p0", "p1", "p2", "p3"])
+        np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=1)
+        self.assertEqual(result["dof"], 26)
+        self.assertListEqual(result["xrange"], [0.1, 1.0])
+        self.assertListEqual(result["popt_keys"], ["p0", "p1", "p2", "p3"])
 
     def test_run_single_curve_fail(self):
         """Test analysis returns status when it fails."""
@@ -147,11 +148,12 @@ def test_run_single_curve_fail(self):
             p0=[ref_p0, ref_p1, ref_p2, ref_p3],
             bounds=([-10, -10, -10, -10], [0, 0, 0, 0]),
         )
+        result = results[0]
 
-        self.assertFalse(results["success"])
+        self.assertFalse(result["success"])
 
         ref_result_keys = ["raw_data", "error_message", "success"]
-        self.assertSetEqual(set(results.keys()), set(ref_result_keys))
+        self.assertSetEqual(set(result.keys()), set(ref_result_keys))
 
     def test_run_two_curves_with_same_fitfunc(self):
         """Test analysis for two curves. Curves shares fit model."""
@@ -189,16 +191,17 @@ def test_run_two_curves_with_same_fitfunc(self):
         )
 
         # merge two experiment data
-        for datum in test_data1.data:
+        for datum in test_data1.data():
             test_data0.add_data(datum)
 
         results, _ = analysis._run_analysis(test_data0, p0=[ref_p0, ref_p1, ref_p2, ref_p3, ref_p4])
+        result = results[0]
 
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3, ref_p4])
 
         # check result data
-        self.assertTrue(results["success"])
-        np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)
+        self.assertTrue(result["success"])
+        np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=1)
 
     def test_run_two_curves_with_two_fitfuncs(self):
         """Test analysis for two curves. Curves shares fit parameters."""
@@ -235,16 +238,17 @@ def test_run_two_curves_with_two_fitfuncs(self):
         )
 
         # merge two experiment data
-        for datum in test_data1.data:
+        for datum in test_data1.data():
             test_data0.add_data(datum)
 
         results, _ = analysis._run_analysis(test_data0, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
+        result = results[0]
 
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
 
         # check result data
-        self.assertTrue(results["success"])
-        np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)
+        self.assertTrue(result["success"])
+        np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=1)
 
     def test_fit_with_data_option(self):
         """Test analysis by passing data processing option to the data processor."""
@@ -282,10 +286,11 @@ def inverted_decay(x, p0, p1, p2, p3):
             outcome="0",
         )
         results, _ = analysis._run_analysis(test_data, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
+        result = results[0]
 
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
 
         # check result data
-        self.assertTrue(results["success"])
+        self.assertTrue(result["success"])
 
-        np.testing.assert_array_almost_equal(results["popt"], ref_popt, decimal=1)
+        np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=1)

From 2e771cbea37cecc60b97b4a39bdccd52320b9c2f Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 14 May 2021 13:49:29 +0900
Subject: [PATCH 20/74] feedback from chris1 - more general docstring - add
 default parameter to fit funcs

---
 qiskit_experiments/analysis/curve_analysis.py | 127 +++++++++++-------
 qiskit_experiments/analysis/fit_functions.py  |  31 ++++-
 2 files changed, 107 insertions(+), 51 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 6e863ce706..f498f63868 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -33,7 +33,7 @@
     "SeriesDef",
     [
         ("name", str),
-        ("param_names", List[str]),
+        ("p0_signature", Dict[str, str]),
         ("fit_func_index", int),
         ("filter_kwargs", Optional[Dict[str, Any]]),
         ("data_option_keys", Optional[List[str]]),
@@ -193,8 +193,9 @@ class CurveAnalysis(BaseAnalysis):
             Each series definition is SeriesDef element, that may be initialized with::
 
                 name: Name of the curve. This is arbitrary field.
-                param_names: Name of parameters. This is order sensitive. The parameter names
-                    should be involved in __param_names__.
+                p0_signature: Mapping of parameter name to argument of the fit function
+                    specified by fit_func_index. The parameter names (dict values)
+                    should be defined in __param_names__.
                 fit_func_index: Index of fitting function associated with this curve.
                     The fitting function should be listed in __fit_funcs__.
                 filter_kwargs: Circuit metadata key and value associated with this curve.
@@ -212,8 +213,8 @@ class CurveAnalysis(BaseAnalysis):
 
     Examples:
 
-        T1 experiment
-        =============
+        A fitting for single exponential decay curve
+        ============================================
 
         In this type of experiment, the analysis deals with a single curve.
         Thus filter_kwargs is not necessary defined.
@@ -222,96 +223,132 @@ class CurveAnalysis(BaseAnalysis):
 
             class AnalysisExample(CurveAnalysis):
 
-                __x_key__ = "delay"
+                __x_key__ = "scan_val"
 
                 __series__ = [
                     SeriesDef(
-                        name="t1_decay",
-                        param_names=["a", "tau", "b"],
+                        name="my_experiment1",
+                        p0_signature={"amp": "p0", "lamb": "p1", "baseline": "p2"},
                         fit_func_index=0,
                         filter_kwargs=None,
                         data_option_keys=["outcome"]
-                    )
+                    ),
                 ]
 
-                __fit_funcs__ = [library.exponential]
+                __fit_funcs__ = [fit_functions.exponential_decay]
+
+                __param_names__ = ["p0", "p1", "p2"]
+
+        The signature of fit_functions.exponential may be::
+
+        .. code-block::
+
+            def exponential_decay(x, amp, lamb, base, x0, baseline) -> np.ndarray:
 
-                __param_names__ = ["a", "tau", "b"]
+        The p0_signature key represents a mapping of the fit parameters given by the analysis to
+        the arguments of the fit function. In this example, fit parameter "p0" is substituted
+        in "amp" of the exponential_decay function. Note that the fit function defines a
+        default value for each parameter, thus the default values are used for
+        unspecified parameters here, i.e. "base" and "x0".
 
-        IRB experiment
-        ==============
+
+        A fitting for two exponential decay curve with partly shared parameter
+        ======================================================================
 
         In this type of experiment, the analysis deals with two curves.
-        We need a __series__ definition for each curve.
-        Both curves can be represented by the same exponential function,
-        but with a different parameter set. Note that parameters will be partly shared.
+        We need a __series__ definition for each curve, and filter_kwargs should be
+        properly defined to extract each curve data from the entire experiment data.
 
         .. code-block::
 
             class AnalysisExample(CurveAnalysis):
 
-                __x_key__ = "ncliffs"
+                __x_key__ = "scan_val"
 
                 __series__ = [
                     SeriesDef(
-                        name="standard_rb",
-                        param_names=["a", "alpha_std", "b"],
+                        name="my_experiment1",
+                        p0_signature={"amp": "p0", "lamb": "p1", "baseline": "p3"},
                         fit_func_index=0,
-                        filter_kwargs={"interleaved": False},
+                        filter_kwargs={"my_option1": True},
                         data_option_keys=["outcome"]
                     ),
                     SeriesDef(
-                        name="interleaved_rb",
-                        param_names=["a", "alpha_int", "b"],
+                        name="my_experiment2",
+                        p0_signature={"amp": "p0", "lamb": "p2", "baseline": "p3"},
                         fit_func_index=0,
-                        filter_kwargs={"interleaved": True},
+                        filter_kwargs={"my_option1": False},
                         data_option_keys=["outcome"]
-                    )
+                    ),
                 ]
 
-                __fit_funcs__ = [library.exponential]
+                __fit_funcs__ = [fit_functions.exponential_decay]
 
-                __param_names__ = ["a", "alpha_std", "alpha_int", "b"]
+                __param_names__ = ["p0", "p1", "p2", "p3"]
 
-        Note that the subclass can optionally override :meth:``_post_processing``.
-        This method takes the fit analysis result and calculates a new entity with it.
-        EPC calculation can be performed here.
+        Note that two series share the fit function exponential_decay.
+        However, these series fit two curves with different "lamb" parameters.
+        In total, there are 4 parameters defined in __param_names__.
 
-        Ramsey XY experiment
-        ====================
+        The series 1 (my_experiment1) performs::
 
-        In this type of experiment, the analysis deals with two curves.
-        We need a __series__ definition for each curve.
-        In contrast to the IRB example, this experiment may have two fit functions
-        to represent cosinusoidal (real part) and sinusoidal (imaginary part) oscillation,
-        however the parameters are shared with both functions.
+        .. code-block::
+
+            def exponential_decay(x, amp=p0, lamb=p1, baseline=p3) -> np.ndarray:
+
+        The series 2 (my_experiment1) performs::
+
+        .. code-block::
+
+            def exponential_decay(x, amp=p0, lamb=p2, baseline=p3) -> np.ndarray:
+
+        Thus both curves assume the same "amp" and "baseline".
+        This parameter remapping is managed by the base analysis class behind the scene.
+
+
+        A fitting for two trigonometric curves with the same parameter
+        =============================================================
+
+        In this type of experiment, the analysis deals with two different curves.
+        However the parameters are shared with both functions.
 
         .. code-block::
 
             class AnalysisExample(CurveAnalysis):
 
-                __x_key__ = "delays"
+                __x_key__ = "scan_val"
 
                 __series__ = [
                     SeriesDef(
-                        name="x",
-                        param_names=["a", "freq", "phase", "b"],
+                        name="my_experiment1",
+                        param_names={"amp": "p0", "freq": "p1", "phase": "p3", "baseline": "p4"},
                         fit_func_index=0,
-                        filter_kwargs={"pulse": "x"},
+                        filter_kwargs={"my_option1": "X"},
                         data_option_keys=["outcome"]
                     ),
                     SeriesDef(
-                        name="y",
-                        param_names=["a", "freq", "phase", "b"],
+                        name="my_experiment2",
+                        param_names={"amp": "p0", "freq": "p1", "phase": "p3", "baseline": "p4"},
                         fit_func_index=1,
-                        filter_kwargs={"pulse": "y"},
+                        filter_kwargs={"my_option1": "Y"},
                         data_option_keys=["outcome"]
                     )
                 ]
 
-                __fit_funcs__ = [library.cos, library.sin]
+                __fit_funcs__ = [fit_functions.cos, fit_functions.sin]
+
+                __param_names__ = ["p0", "p1", "p3", "p4"]
+
+        The signature of each fit function may be::
+
+        .. code-block::
+
+            def cos(x, amp, freq, phase, baseline) -> np.ndarray:
+
+            def sin(x, amp, freq, phase, baseline) -> np.ndarray:
 
-                __param_names__ = ["a", "freq", "phase", "b"]
+        Note that series 1 (2) is linked to fit_functions.cos (sin) by the fit_func_index.
+        The parameters are totally shared with two curves.
 
     Notes:
         This CurveAnalysis class provides several private methods that subclasses can override.
diff --git a/qiskit_experiments/analysis/fit_functions.py b/qiskit_experiments/analysis/fit_functions.py
index ff9b83345a..706347b725 100644
--- a/qiskit_experiments/analysis/fit_functions.py
+++ b/qiskit_experiments/analysis/fit_functions.py
@@ -18,7 +18,13 @@
 import numpy as np
 
 
-def cos(x: np.ndarray, amp: float, freq: float, phase: float, baseline: float) -> np.ndarray:
+def cos(
+    x: np.ndarray,
+    amp: float = 1.0,
+    freq: float = 1 / (2 * np.pi),
+    phase: float = 0.0,
+    baseline: float = 0.0,
+) -> np.ndarray:
     r"""Cosine function.
 
     .. math::
@@ -27,7 +33,13 @@ def cos(x: np.ndarray, amp: float, freq: float, phase: float, baseline: float) -
     return amp * np.cos(2 * np.pi * freq * x + phase) + baseline
 
 
-def sin(x: np.ndarray, amp: float, freq: float, phase: float, baseline: float) -> np.ndarray:
+def sin(
+    x: np.ndarray,
+    amp: float = 1.0,
+    freq: float = 1 / (2 * np.pi),
+    phase: float = 0.0,
+    baseline: float = 0.0,
+) -> np.ndarray:
     r"""Sine function.
 
     .. math::
@@ -37,17 +49,24 @@ def sin(x: np.ndarray, amp: float, freq: float, phase: float, baseline: float) -
 
 
 def exponential_decay(
-    x: np.ndarray, amp: float, lamb: float, x0: float, baseline: float
+    x: np.ndarray,
+    amp: float = 1.0,
+    lamb: float = 1.0,
+    base: float = np.e,
+    x0: float = 0.0,
+    baseline: float = 0.0,
 ) -> np.ndarray:
     r"""Exponential function
 
     .. math::
-        y = {\rm amp} \exp \left( - \lambda x + {\rm x0} \right) + {\rm baseline}
+        y = {\rm amp} {\rm base}^{\left( - \lambda x + {\rm x0} \right)} + {\rm baseline}
     """
-    return amp * np.exp(-lamb * x + x0) + baseline
+    return amp * base ** (-lamb * x + x0) + baseline
 
 
-def gaussian(x: np.ndarray, amp: float, sigma: float, x0: float, baseline: float) -> np.ndarray:
+def gaussian(
+    x: np.ndarray, amp: float = 1.0, sigma: float = 1.0, x0: float = 0.0, baseline: float = 0.0
+) -> np.ndarray:
     r"""Gaussian function
 
     .. math::

From b1fc3f38b0a83ca8df4181ff8022196c262b5798 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 14 May 2021 15:18:48 +0900
Subject: [PATCH 21/74] feedback from chris2 - parameter dict handling

---
 qiskit_experiments/analysis/curve_analysis.py | 139 +++++++++++-------
 test/analysis/test_curve_fit.py               |  74 ++++++++--
 2 files changed, 154 insertions(+), 59 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index f498f63868..daeaa5a706 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -57,9 +57,9 @@ def scipy_curve_fit_wrapper(
     f: Callable,
     xdata: np.ndarray,
     ydata: np.ndarray,
-    p0: np.ndarray,
-    sigma: Optional[np.ndarray],
-    bounds: Optional[Tuple[np.ndarray, np.ndarray]],
+    p0: Dict[str, float],
+    sigma: np.ndarray,
+    bounds: Tuple[Dict[str, np.ndarray], Dict[str, np.ndarray]],
     **kwargs,
 ) -> AnalysisResult:
     r"""A helper function to perform a non-linear least squares to fit
@@ -76,8 +76,8 @@ def scipy_curve_fit_wrapper(
         xdata: a 1D float array of x-data.
         ydata: a 1D float array of y-data.
         p0: initial guess for optimization parameters.
-        sigma: Optional, a 1D array of standard deviations in ydata in absolute units.
-        bounds: Optional, lower and upper bounds for optimization parameters.
+        sigma: a 1D array of standard deviations in ydata in absolute units.
+        bounds: lower and upper bounds for optimization parameters.
         kwargs: additional kwargs for scipy.optimize.curve_fit.
 
     Returns:
@@ -100,6 +100,14 @@ def scipy_curve_fit_wrapper(
         parameters via ``pcov(absolute_sigma=False) = pcov * reduced_chisq``
         ``popt_err(absolute_sigma=False) = popt_err * sqrt(reduced_chisq)``.
     """
+    # Format p0 parameters
+    param_keys = list(p0.keys())
+    param_p0 = list(p0.values())
+
+    lower = [bounds[0][key] for key in param_keys]
+    upper = [bounds[1][key] for key in param_keys]
+    param_bounds = (lower, upper)
+
     # Check that degrees of freedom is greater than 0
     dof = len(ydata) - len(p0)
     if dof < 1:
@@ -116,7 +124,7 @@ def scipy_curve_fit_wrapper(
     # Run curve fit
     # pylint: disable = unbalanced-tuple-unpacking
     popt, pcov = opt.curve_fit(
-        f=f, xdata=xdata, ydata=ydata, sigma=sigma, p0=p0, bounds=bounds, **kwargs
+        f=f, xdata=xdata, ydata=ydata, sigma=sigma, p0=param_p0, bounds=param_bounds, **kwargs
     )
     popt_err = np.sqrt(np.diag(pcov))
 
@@ -132,6 +140,7 @@ def scipy_curve_fit_wrapper(
 
     result = {
         "popt": popt,
+        "popt_keys": param_keys,
         "popt_err": popt_err,
         "pcov": pcov,
         "reduced_chisq": reduced_chisq,
@@ -175,6 +184,45 @@ def level2_probability(data: Dict[str, Any], outcome: Optional[str] = None) -> T
 class FitOptions(dict):
     """Fit options passed to the fitter function."""
 
+    def validate(self):
+        """Validate format of fitting options.
+
+        Raises:
+            TypeError:
+                - When parameter is not given by dictionary. Need mapping to parameter name.
+            KeyError:
+                - When necessary options are not fully defined.
+        """
+
+        # Initial guess
+        try:
+            p0 = self["p0"]
+            if not isinstance(p0, dict):
+                raise TypeError(
+                    "Initial guess is not a dictionary. Need parameter name "
+                    "associated with each parameter as a key."
+                )
+        except KeyError as ex:
+            raise KeyError("Initial parameters are not set.") from ex
+
+        # Boundaries
+        try:
+            lb, ub = self["bounds"]
+            if not isinstance(lb, dict) or not isinstance(ub, dict):
+                raise TypeError(
+                    "Parameter boundaries are not a dictionary. Need parameter name "
+                    "associated with each parameter as a key."
+                )
+
+        except KeyError as ex:
+            raise KeyError("Parameter boundaries are not set.") from ex
+
+        except TypeError as ex:
+            raise TypeError(
+                "Parameter boundaries are invalid format. Boundaries should be "
+                "lower and upper values as a tuple of two dictionary."
+            ) from ex
+
 
 class CurveAnalysis(BaseAnalysis):
     """A base class for curve fit type analysis.
@@ -438,14 +486,27 @@ def _setup_fitting(self, curve_data: List[CurveEntry], **options) -> List[FitOpt
         Returns:
             List of FitOptions that are passed to fitter function.
         """
-        num_params = len(self.__param_names__)
 
-        # no initial guesses and no boundaries by default
-        fit_option = FitOptions(
-            p0=np.zeros(num_params, dtype=float),
-            bounds=([-np.inf] * num_params, [np.inf] * num_params),
-        )
-        fit_option.update(options)
+        def _dictionarize(argvar, default_val):
+            if argvar is not None:
+                try:
+                    argvar = list(argvar)
+                    return {name: val for name, val in zip(self.__param_names__, argvar)}
+                except TypeError:
+                    return argvar
+            else:
+                return {pname: default_val for pname in self.__param_names__}
+
+        # Set initial guess
+        usr_p0 = options.pop("p0", None)
+        p0 = _dictionarize(usr_p0, default_val=0.0)
+
+        # Set boundaries
+        usr_lb, usr_ub = options.pop("bounds", (None, None))
+        lb = _dictionarize(usr_lb, default_val=-np.inf)
+        ub = _dictionarize(usr_ub, default_val=np.inf)
+
+        fit_option = FitOptions(p0=p0, bounds=(lb, ub), **options)
 
         return [fit_option]
 
@@ -697,7 +758,7 @@ def multi_objective_fit(x, *params):
             y = np.empty(0, dtype=float)
             xs = np.split(x, separators) if len(separators) > 0 else [x]
             for i, xi in enumerate(xs):
-                yi = self._fit_curve(curve_data[i].curve_name, xi, *params)
+                yi = self._calculate_curve(curve_data[i].curve_name, xi, *params)
                 y = np.concatenate((y, yi))
             return y
 
@@ -726,33 +787,16 @@ def multi_objective_fit(x, *params):
 
         return best_analysis_result
 
-    def _fit_curve(self, curve_name: str, xvals: np.ndarray, *params) -> np.ndarray:
-        """A helper method to return fit curve for the specific series.
-
-        Fit function is selected based on ``curve_name`` and the parameters list is truncated
-        based on parameter matching between one defined in __series__ and self.__param_names__.
+    def _calculate_curve(self, curve_name: str, xvals: np.ndarray, *params: float) -> np.ndarray:
+        """A helper method to manage parameter remapping for each series.
 
-        Examples:
-            Assuming the class has following definition:
-
-            .. code-block::
-
-                self.__series__ = [
-                    Series(name="curve1", param_names=["p1", "p2", "p4"], fit_func_index=0),
-                    Series(name="curve2", param_names=["p1", "p2", "p3"], fit_func_index=1)
-                ]
-
-                self.__fit_funcs__ = [func1, func2]
-
-                self.__param_names__ = ["p1", "p2", "p3", "p4"]
-
-            When we call this method with ``curve_name="curve1", params = [0, 1, 2, 3]``,
-            the ``func1`` is called with parameters ``[0, 1, 3]``.
+        This method calculate curve based on the fit function specified by the
+        fit_func_index in each series definition.
 
         Args:
             curve_name: A name of curve. This should be defined in __series__ attribute.
             xvals: Array of x values.
-            *params: Full fit parameters.
+            params: Full fit parameters specified in __param_names__.
 
         Returns:
             Fit y values.
@@ -763,30 +807,25 @@ def _fit_curve(self, curve_name: str, xvals: np.ndarray, *params) -> np.ndarray:
                 - When fit function index is out of range.
                 - When curve information is not defined in class attribute __series__.
         """
-        if self.__series__ is None:
-            # only single curve
-            return self.__fit_funcs__[0](xvals, *params)
+        named_params = {name: val for name, val in zip(self.__param_names__, params)}
 
         for curve_properties in self.__series__:
             if curve_properties.name == curve_name:
-
                 # remap parameters
-                series_params = curve_properties.param_names
-                mapped_params = []
-                for series_param in series_params:
+                kw_params = {}
+                for key, pname in curve_properties.p0_signature.items():
                     try:
-                        param_idx = self.__param_names__.index(series_param)
-                    except ValueError as ex:
-                        raise QiskitError(
-                            f"Local function parameter {series_param} is not defined in "
-                            f"this class. {series_param} not in {self.__param_names__}."
+                        kw_params[key] = named_params[pname]
+                    except KeyError as ex:
+                        raise KeyError(
+                            f"Series parameter {key} is not found in the fit parameter. "
+                            f"{key} not in {', '.join(named_params.keys())}."
                         ) from ex
-                    mapped_params.append(params[param_idx])
 
                 # find fit function
                 f_index = curve_properties.fit_func_index
                 try:
-                    return self.__fit_funcs__[f_index](xvals, *mapped_params)
+                    return self.__fit_funcs__[f_index](xvals, **kw_params)
                 except IndexError as ex:
                     raise QiskitError(f"Fit function of index {f_index} is not defined.") from ex
 
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index 057987abe9..daf3077434 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -88,7 +88,7 @@ def test_run_single_curve_analysis(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    param_names=["p0", "p1", "p2", "p3"],
+                    p0_signature={"amp": "p0", "lamb": "p1", "x0": "p2", "baseline": "p3"},
                     fit_func_index=0,
                     filter_kwargs=None,
                     data_option_keys=None,
@@ -124,7 +124,7 @@ def test_run_single_curve_fail(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    param_names=["p0", "p1", "p2", "p3"],
+                    p0_signature={"amp": "p0", "lamb": "p1", "x0": "p2", "baseline": "p3"},
                     fit_func_index=0,
                     filter_kwargs=None,
                     data_option_keys=None,
@@ -161,14 +161,14 @@ def test_run_two_curves_with_same_fitfunc(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    param_names=["p0", "p1", "p3", "p4"],
+                    p0_signature={"amp": "p0", "lamb": "p1", "x0": "p3", "baseline": "p4"},
                     fit_func_index=0,
                     filter_kwargs={"exp": 0},
                     data_option_keys=None,
                 ),
                 SeriesDef(
                     name="curve2",
-                    param_names=["p0", "p2", "p3", "p4"],
+                    p0_signature={"amp": "p0", "lamb": "p2", "x0": "p3", "baseline": "p4"},
                     fit_func_index=0,
                     filter_kwargs={"exp": 1},
                     data_option_keys=None,
@@ -209,14 +209,14 @@ def test_run_two_curves_with_two_fitfuncs(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    param_names=["p0", "p1", "p2", "p3"],
+                    p0_signature={"amp": "p0", "freq": "p1", "phase": "p2", "baseline": "p3"},
                     fit_func_index=0,
                     filter_kwargs={"exp": 0},
                     data_option_keys=None,
                 ),
                 SeriesDef(
                     name="curve2",
-                    param_names=["p0", "p1", "p2", "p3"],
+                    p0_signature={"amp": "p0", "freq": "p1", "phase": "p2", "baseline": "p3"},
                     fit_func_index=1,
                     filter_kwargs={"exp": 1},
                     data_option_keys=None,
@@ -253,15 +253,17 @@ def test_run_two_curves_with_two_fitfuncs(self):
     def test_fit_with_data_option(self):
         """Test analysis by passing data processing option to the data processor."""
 
-        def inverted_decay(x, p0, p1, p2, p3):
+        def inverted_decay(x, amp, lamb, x0, baseline):
             # measure inverse of population
-            return 1 - fit_functions.exponential_decay(x, p0, p1, p2, p3)
+            return 1 - fit_functions.exponential_decay(
+                x, amp=amp, lamb=lamb, x0=x0, baseline=baseline
+            )
 
         analysis = create_new_analysis(
             series=[
                 SeriesDef(
                     name="curve1",
-                    param_names=["p0", "p1", "p2", "p3"],
+                    p0_signature={"amp": "p0", "lamb": "p1", "x0": "p2", "baseline": "p3"},
                     fit_func_index=0,
                     filter_kwargs=None,
                     data_option_keys=["outcome"],
@@ -294,3 +296,57 @@ def inverted_decay(x, p0, p1, p2, p3):
         self.assertTrue(result["success"])
 
         np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=1)
+
+    def test_fit_failure_with_wrong_signature(self):
+        """Test if fitting fails when wrong signature is defined."""
+        analysis = create_new_analysis(
+            series=[
+                SeriesDef(
+                    name="curve1",
+                    p0_signature={"not_defined_parameter": "p0"},  # invalid mapping
+                    fit_func_index=0,
+                    filter_kwargs=None,
+                    data_option_keys=None,
+                )
+            ],
+            fit_funcs=[fit_functions.exponential_decay],
+            param_names=["p0"],
+        )
+        ref_p0 = 0.9
+
+        test_data = simulate_output_data(fit_functions.exponential_decay, self.xvalues, ref_p0)
+
+        results, _ = analysis._run_analysis(test_data, p0=[ref_p0])
+        result = results[0]
+
+        self.assertFalse(result["success"])
+
+        ref_result_keys = ["raw_data", "error_message", "success"]
+        self.assertSetEqual(set(result.keys()), set(ref_result_keys))
+
+    def test_fit_failure_with_unclear_parameter(self):
+        """Test if fitting fails when parameter not defined in fit is used.."""
+        analysis = create_new_analysis(
+            series=[
+                SeriesDef(
+                    name="curve1",
+                    p0_signature={"amp": "not_defined_parameter"},  # this parameter is not defined
+                    fit_func_index=0,
+                    filter_kwargs=None,
+                    data_option_keys=None,
+                )
+            ],
+            fit_funcs=[fit_functions.exponential_decay],
+            param_names=["p0"],
+        )
+        ref_p0 = 0.9
+
+        test_data = simulate_output_data(fit_functions.exponential_decay, self.xvalues, ref_p0)
+
+        results, _ = analysis._run_analysis(test_data, p0=[ref_p0])
+        result = results[0]
+
+        self.assertFalse(result["success"])
+
+        ref_result_keys = ["raw_data", "error_message", "success"]
+        self.assertSetEqual(set(result.keys()), set(ref_result_keys))

From a7ec0554357552967749fd4e53b7f29a45984b0b Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 14 May 2021 15:20:36 +0900
Subject: [PATCH 22/74] feedback from chris3 - import path

---
 qiskit_experiments/analysis/__init__.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qiskit_experiments/analysis/__init__.py b/qiskit_experiments/analysis/__init__.py
index 018a426d5b..60d34c02ee 100644
--- a/qiskit_experiments/analysis/__init__.py
+++ b/qiskit_experiments/analysis/__init__.py
@@ -13,10 +13,10 @@
 """
 Analysis helper functions
 """
-from qiskit_experiments.analysis.curve_analysis import CurveAnalysis, SeriesDef, FitOptions
+from .curve_analysis import CurveAnalysis, SeriesDef, FitOptions
 
 # fit functions (alphabetical import ordering)
-from qiskit_experiments.analysis.fit_functions import (
+from .fit_functions import (
     cos,
     exponential_decay,
     gaussian,

From 4ade7429b2a41375da1af9734cfec7588b8b9775 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 14 May 2021 15:41:17 +0900
Subject: [PATCH 23/74] lint

---
 qiskit_experiments/analysis/curve_analysis.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index daeaa5a706..9907e6ebc6 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -491,7 +491,7 @@ def _dictionarize(argvar, default_val):
             if argvar is not None:
                 try:
                     argvar = list(argvar)
-                    return {name: val for name, val in zip(self.__param_names__, argvar)}
+                    return dict(zip(self.__param_names__, argvar))
                 except TypeError:
                     return argvar
             else:
@@ -806,8 +806,9 @@ def _calculate_curve(self, curve_name: str, xvals: np.ndarray, *params: float) -
                 - When function parameter is not defined in the class parameter list.
                 - When fit function index is out of range.
                 - When curve information is not defined in class attribute __series__.
+                - When series parameter is not defined in __param_names__.
         """
-        named_params = {name: val for name, val in zip(self.__param_names__, params)}
+        named_params = dict(zip(self.__param_names__, params))
 
         for curve_properties in self.__series__:
             if curve_properties.name == curve_name:
@@ -817,7 +818,7 @@ def _calculate_curve(self, curve_name: str, xvals: np.ndarray, *params: float) -
                     try:
                         kw_params[key] = named_params[pname]
                     except KeyError as ex:
-                        raise KeyError(
+                        raise QiskitError(
                             f"Series parameter {key} is not found in the fit parameter. "
                             f"{key} not in {', '.join(named_params.keys())}."
                         ) from ex

From 8163c2548f48108b9b27e76291b154518990ec71 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 14 May 2021 15:45:19 +0900
Subject: [PATCH 24/74] add fit option validation

---
 qiskit_experiments/analysis/curve_analysis.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 9907e6ebc6..04c7bb2b07 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -724,6 +724,9 @@ def _run_fitting(
 
         # Setup fitting options
         fit_options = self._setup_fitting(curve_data, **options)
+        for fit_option in fit_options:
+            if isinstance(fit_option, FitOptions):
+                fit_option.validate()
 
         # Validate weights
         if weights is None:

From 5f81337114562be9e66684c7529e1685d30ea5a2 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 14 May 2021 17:35:17 +0900
Subject: [PATCH 25/74] add unittest and integration test

---
 qiskit_experiments/analysis/curve_analysis.py |  29 +-
 test/analysis/test_curve_fit.py               | 248 ++++++++++++++++--
 2 files changed, 246 insertions(+), 31 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 04c7bb2b07..263d61aae1 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -620,6 +620,19 @@ def _is_target_series(datum, **filters):
                 # use data as-is
                 series_data = experiment_data.data()
 
+            if len(series_data) == 0:
+                # no data found
+                curve_data.append(
+                    CurveEntry(
+                        curve_name=curve_properties.name,
+                        x_values=np.empty(0, dtype=float),
+                        y_values=np.empty(0, dtype=float),
+                        y_sigmas=np.empty(0, dtype=float),
+                        metadata=dict(),
+                    )
+                )
+                continue
+
             # Format x, y, yerr data
             try:
                 xvals = [datum["metadata"][self.__x_key__] for datum in series_data]
@@ -650,7 +663,7 @@ def _data_processing(datum):
                 y_sigmas=np.asarray(yerrs, dtype=float),
             )
 
-            # Get common metadata fields except for xval and filter args.
+            # Get common metadata fields except for xval, filter args, data processor args.
             # These properties are obvious.
             common_keys = list(
                 functools.reduce(
@@ -662,6 +675,9 @@ def _data_processing(datum):
             if curve_properties.filter_kwargs:
                 for key in curve_properties.filter_kwargs:
                     common_keys.remove(key)
+            if curve_properties.data_option_keys:
+                for key in curve_properties.data_option_keys:
+                    common_keys.remove(key)
 
             # Extract common metadata for the curve
             curve_metadata = defaultdict(set)
@@ -806,11 +822,18 @@ def _calculate_curve(self, curve_name: str, xvals: np.ndarray, *params: float) -
 
         Raises:
             QiskitError:
+                - When prameter name and paramater value length don't match.
                 - When function parameter is not defined in the class parameter list.
                 - When fit function index is out of range.
                 - When curve information is not defined in class attribute __series__.
                 - When series parameter is not defined in __param_names__.
         """
+        if len(self.__param_names__) != len(params):
+            raise QiskitError(
+                "Length of defined parameter names does not match with "
+                f"supplied parameter values. {', '.join(self.__param_names__)} != {params}."
+            )
+
         named_params = dict(zip(self.__param_names__, params))
 
         for curve_properties in self.__series__:
@@ -822,8 +845,8 @@ def _calculate_curve(self, curve_name: str, xvals: np.ndarray, *params: float) -
                         kw_params[key] = named_params[pname]
                     except KeyError as ex:
                         raise QiskitError(
-                            f"Series parameter {key} is not found in the fit parameter. "
-                            f"{key} not in {', '.join(named_params.keys())}."
+                            f"Series parameter {pname} is not found in the fit parameter. "
+                            f"{pname} not in {', '.join(named_params.keys())}. "
                         ) from ex
 
                 # find fit function
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index daf3077434..0792bfa4d9 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -19,8 +19,8 @@
 from qiskit.test import QiskitTestCase
 
 from qiskit_experiments import ExperimentData
-from qiskit_experiments.analysis import CurveAnalysis, SeriesDef
-from qiskit_experiments.analysis import fit_functions
+from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, fit_functions
+from qiskit_experiments.analysis.curve_analysis import CurveEntry
 from qiskit_experiments.base_experiment import BaseExperiment
 
 
@@ -34,11 +34,11 @@ def circuits(self, backend=None, **circuit_options):
         return []
 
 
-def simulate_output_data(func, xvals, *params, **metadata):
+def simulate_output_data(func, xvals, param_dict, **metadata):
     """Generate arbitrary fit data."""
-    __shots = 1024
+    __shots = 100000
 
-    expected_probs = func(xvals, *params)
+    expected_probs = func(xvals, **param_dict)
     counts = np.asarray(expected_probs * __shots, dtype=int)
 
     data = [
@@ -75,12 +75,180 @@ class TestAnalysis(CurveAnalysis):
     return TestAnalysis()
 
 
-class TestCurveAnalysis(QiskitTestCase):
-    """Unittest for curve fit analysis. Assuming several fitting situations."""
+class TestCurveAnalysisUnit(QiskitTestCase):
+    """Unittest for curve fit analysis."""
 
     def setUp(self):
         super().setUp()
-        self.xvalues = np.linspace(0.1, 1, 30)
+        self.xvalues = np.linspace(1., 5., 10)
+
+        # Description of test setting
+        #
+        # - This model contains three curves, namely, curve1, curve2, curve3
+        # - Each curve can be represented by the same function
+        # - Parameter amp and baseline are shared among all curves
+        # - Each curve has unique lamb
+        # - In total 4 parameters in the fit, namely, p0, p1, p2, p3
+        #
+        self.analysis = create_new_analysis(
+            series=[
+                SeriesDef(
+                    name="curve1",
+                    p0_signature={"amp": "p0", "lamb": "p1", "baseline": "p4"},
+                    fit_func_index=0,
+                    filter_kwargs={"type": 1, "valid": True},
+                    data_option_keys=["outcome"],
+                ),
+                SeriesDef(
+                    name="curve2",
+                    p0_signature={"amp": "p0", "lamb": "p2", "baseline": "p4"},
+                    fit_func_index=0,
+                    filter_kwargs={"type": 2, "valid": True},
+                    data_option_keys=["outcome"],
+                ),
+                SeriesDef(
+                    name="curve3",
+                    p0_signature={"amp": "p0", "lamb": "p3", "baseline": "p4"},
+                    fit_func_index=0,
+                    filter_kwargs={"type": 3, "valid": True},
+                    data_option_keys=["outcome"],
+                )
+            ],
+            fit_funcs=[fit_functions.exponential_decay],
+            param_names=["p0", "p1", "p2", "p3", "p4"],
+        )
+        self.err_decimal = 3
+
+    @staticmethod
+    def data_processor(data, outcome):
+        """A helper method to format input data."""
+        counts = data["counts"]
+        outcome = outcome or "1" * len(list(counts.keys())[0])
+
+        shots = sum(counts.values())
+        p_mean = counts.get(outcome, 0.0) / shots
+        p_var = p_mean * (1 - p_mean) / shots
+
+        return p_mean, p_var
+
+    def test_data_extraction(self):
+        """Test data extraction method."""
+        # data to analyze
+        test_data0 = simulate_output_data(
+            func=fit_functions.exponential_decay,
+            xvals=self.xvalues,
+            param_dict={"amp": 1.},
+            type=1,
+            valid=True,
+            dummy_val="test_val1",
+            outcome="1",
+        )
+
+        # fake data
+        test_data1 = simulate_output_data(
+            func=fit_functions.exponential_decay,
+            xvals=self.xvalues,
+            param_dict={"amp": 1.},
+            type=2,
+            valid=False,
+            dummy_val="test_val2",
+            outcome="1",
+        )
+        # merge two experiment data
+        for datum in test_data1.data():
+            test_data0.add_data(datum)
+
+        curve_entries = self.analysis._extract_curves(test_data0, self.data_processor)
+
+        # check if the module filter off data: valid=False
+        self.assertEqual(len(curve_entries), 3)
+
+        # check name is passed
+        self.assertEqual(curve_entries[0].curve_name, "curve1")
+
+        # check x values
+        np.testing.assert_array_almost_equal(curve_entries[0].x_values, self.xvalues)
+
+        # check y values
+        ref_y = fit_functions.exponential_decay(self.xvalues, amp=1.)
+        np.testing.assert_array_almost_equal(
+            curve_entries[0].y_values, ref_y, decimal=self.err_decimal
+        )
+
+        # check y errors
+        ref_yerr = ref_y * (1 - ref_y) / 1024
+        np.testing.assert_array_almost_equal(
+            curve_entries[0].y_sigmas, ref_yerr, decimal=self.err_decimal
+        )
+
+        # check metadata
+        ref_meta = {
+            "experiment_type": {"fake_experiment"},
+            "qubits": {(0, )},
+            "dummy_val": {"test_val1"}
+        }
+        self.assertDictEqual(curve_entries[0].metadata, ref_meta)
+
+    def test_curve_calculation(self):
+        """Test series curve calculation."""
+        params = [1.0, 0.7, 0.9, 1.1, 0.1]
+
+        y1 = self.analysis._calculate_curve("curve1", self.xvalues, *params)
+        ref_y1 = fit_functions.exponential_decay(self.xvalues, amp=1.0, lamb=0.7, baseline=0.1)
+        np.testing.assert_array_almost_equal(y1, ref_y1, decimal=self.err_decimal)
+
+        y2 = self.analysis._calculate_curve("curve2", self.xvalues, *params)
+        ref_y2 = fit_functions.exponential_decay(self.xvalues, amp=1.0, lamb=0.9, baseline=0.1)
+        np.testing.assert_array_almost_equal(y2, ref_y2, decimal=self.err_decimal)
+
+        y3 = self.analysis._calculate_curve("curve3", self.xvalues, *params)
+        ref_y3 = fit_functions.exponential_decay(self.xvalues, amp=1.0, lamb=1.1, baseline=0.1)
+        np.testing.assert_array_almost_equal(y3, ref_y3, decimal=self.err_decimal)
+
+    def test_default_setup_fitting(self):
+        """Test default behavior of fitter setup."""
+        curve_data = []
+
+        options = self.analysis._setup_fitting(curve_data)
+
+        ref_p0 = {"p0": 0., "p1": 0., "p2": 0., "p3": 0., "p4": 0.}
+        self.assertDictEqual(options[0]["p0"], ref_p0)
+
+        ref_lb = {"p0": -np.inf, "p1": -np.inf, "p2": -np.inf, "p3": -np.inf, "p4": -np.inf}
+        ref_ub = {"p0": np.inf, "p1": np.inf, "p2": np.inf, "p3": np.inf, "p4": np.inf}
+
+        lb, ub = options[0]["bounds"]
+        self.assertDictEqual(lb, ref_lb)
+        self.assertDictEqual(ub, ref_ub)
+
+    def test_default_setup_fitting_with_parameter(self):
+        """Test default behavior of fitter setup when user parameter is provided."""
+        curve_data = []
+
+        options = self.analysis._setup_fitting(
+            curve_data,
+            p0=[1., 2., 3., 4., 5.],
+            bounds=([-1., -2., -3., -4., -5.], [1., 2., 3., 4., 5.])
+        )
+
+        ref_p0 = {"p0": 1., "p1": 2., "p2": 3., "p3": 4., "p4": 5.}
+        self.assertDictEqual(options[0]["p0"], ref_p0)
+
+        ref_lb = {"p0": -1., "p1": -2., "p2": -3., "p3": -4., "p4": -5.}
+        ref_ub = {"p0": 1., "p1": 2., "p2": 3., "p3": 4., "p4": 5.}
+
+        lb, ub = options[0]["bounds"]
+        self.assertDictEqual(lb, ref_lb)
+        self.assertDictEqual(ub, ref_ub)
+
+
+class TestCurveAnalysisIntegration(QiskitTestCase):
+    """Integration test for curve fit analysis through entire analysis.run function."""
+
+    def setUp(self):
+        super().setUp()
+        self.xvalues = np.linspace(0.1, 1, 50)
+        self.err_decimal = 2
 
     def test_run_single_curve_analysis(self):
         """Test analysis for single curve."""
@@ -103,7 +271,9 @@ def test_run_single_curve_analysis(self):
         ref_p3 = 0.1
 
         test_data = simulate_output_data(
-            fit_functions.exponential_decay, self.xvalues, ref_p0, ref_p1, ref_p2, ref_p3
+            func=fit_functions.exponential_decay,
+            xvals=self.xvalues,
+            param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3}
         )
         results, _ = analysis._run_analysis(test_data, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
         result = results[0]
@@ -113,8 +283,8 @@ def test_run_single_curve_analysis(self):
         # check result data
         self.assertTrue(result["success"])
 
-        np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=1)
-        self.assertEqual(result["dof"], 26)
+        np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=self.err_decimal)
+        self.assertEqual(result["dof"], 46)
         self.assertListEqual(result["xrange"], [0.1, 1.0])
         self.assertListEqual(result["popt_keys"], ["p0", "p1", "p2", "p3"])
 
@@ -139,7 +309,9 @@ def test_run_single_curve_fail(self):
         ref_p3 = 0.1
 
         test_data = simulate_output_data(
-            fit_functions.exponential_decay, self.xvalues, ref_p0, ref_p1, ref_p2, ref_p3
+            func=fit_functions.exponential_decay,
+            xvals=self.xvalues,
+            param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3}
         )
 
         # Try to fit with infeasible parameter boundary. This should fail.
@@ -184,10 +356,17 @@ def test_run_two_curves_with_same_fitfunc(self):
         ref_p4 = 0.1
 
         test_data0 = simulate_output_data(
-            fit_functions.exponential_decay, self.xvalues, ref_p0, ref_p1, ref_p3, ref_p4, exp=0
+            func=fit_functions.exponential_decay,
+            xvals=self.xvalues,
+            param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p3, "baseline": ref_p4},
+            exp=0,
         )
+
         test_data1 = simulate_output_data(
-            fit_functions.exponential_decay, self.xvalues, ref_p0, ref_p2, ref_p3, ref_p4, exp=1
+            func=fit_functions.exponential_decay,
+            xvals=self.xvalues,
+            param_dict={"amp": ref_p0, "lamb": ref_p2, "x0": ref_p3, "baseline": ref_p4},
+            exp=1,
         )
 
         # merge two experiment data
@@ -201,7 +380,7 @@ def test_run_two_curves_with_same_fitfunc(self):
 
         # check result data
         self.assertTrue(result["success"])
-        np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=1)
+        np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=self.err_decimal)
 
     def test_run_two_curves_with_two_fitfuncs(self):
         """Test analysis for two curves. Curves shares fit parameters."""
@@ -231,10 +410,17 @@ def test_run_two_curves_with_two_fitfuncs(self):
         ref_p3 = 0.5
 
         test_data0 = simulate_output_data(
-            fit_functions.cos, self.xvalues, ref_p0, ref_p1, ref_p2, ref_p3, exp=0
+            func=fit_functions.cos,
+            xvals=self.xvalues,
+            param_dict={"amp": ref_p0, "freq": ref_p1, "phase": ref_p2, "baseline": ref_p3},
+            exp=0,
         )
+
         test_data1 = simulate_output_data(
-            fit_functions.sin, self.xvalues, ref_p0, ref_p1, ref_p2, ref_p3, exp=1
+            func=fit_functions.sin,
+            xvals=self.xvalues,
+            param_dict={"amp": ref_p0, "freq": ref_p1, "phase": ref_p2, "baseline": ref_p3},
+            exp=1,
         )
 
         # merge two experiment data
@@ -248,7 +434,7 @@ def test_run_two_curves_with_two_fitfuncs(self):
 
         # check result data
         self.assertTrue(result["success"])
-        np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=1)
+        np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=self.err_decimal)
 
     def test_fit_with_data_option(self):
         """Test analysis by passing data processing option to the data processor."""
@@ -279,14 +465,12 @@ def inverted_decay(x, amp, lamb, x0, baseline):
 
         # tell metadata to count zero
         test_data = simulate_output_data(
-            fit_functions.exponential_decay,
-            self.xvalues,
-            ref_p0,
-            ref_p1,
-            ref_p2,
-            ref_p3,
-            outcome="0",
+            func=fit_functions.exponential_decay,
+            xvals=self.xvalues,
+            param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3},
+            outcome="0",  # metadata, label to count
         )
+
         results, _ = analysis._run_analysis(test_data, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
         result = results[0]
 
@@ -295,7 +479,7 @@ def inverted_decay(x, amp, lamb, x0, baseline):
         # check result data
         self.assertTrue(result["success"])
 
-        np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=1)
+        np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=self.err_decimal)
 
     def test_fit_failure_with_wrong_signature(self):
         """Test if fitting fails when wrong signature is defined."""
@@ -314,7 +498,11 @@ def test_fit_failure_with_wrong_signature(self):
         )
         ref_p0 = 0.9
 
-        test_data = simulate_output_data(fit_functions.exponential_decay, self.xvalues, ref_p0)
+        test_data = simulate_output_data(
+            func=fit_functions.cos,
+            xvals=self.xvalues,
+            param_dict={"amp": ref_p0},
+        )
 
         results, _ = analysis._run_analysis(test_data, p0=[ref_p0])
         result = results[0]
@@ -341,7 +529,11 @@ def test_fit_failure_with_unclear_parameter(self):
         )
         ref_p0 = 0.9
 
-        test_data = simulate_output_data(fit_functions.exponential_decay, self.xvalues, ref_p0)
+        test_data = simulate_output_data(
+            func=fit_functions.cos,
+            xvals=self.xvalues,
+            param_dict={"amp": ref_p0},
+        )
 
         results, _ = analysis._run_analysis(test_data, p0=[ref_p0])
         result = results[0]

From bd6c80c0e3b0201b9ec31c1a6bf656aa091210d3 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 14 May 2021 17:41:30 +0900
Subject: [PATCH 26/74] black & lint

---
 test/analysis/test_curve_fit.py | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index 0792bfa4d9..dea3a20be3 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -20,7 +20,6 @@
 
 from qiskit_experiments import ExperimentData
 from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, fit_functions
-from qiskit_experiments.analysis.curve_analysis import CurveEntry
 from qiskit_experiments.base_experiment import BaseExperiment
 
 
@@ -80,7 +79,7 @@ class TestCurveAnalysisUnit(QiskitTestCase):
 
     def setUp(self):
         super().setUp()
-        self.xvalues = np.linspace(1., 5., 10)
+        self.xvalues = np.linspace(1.0, 5.0, 10)
 
         # Description of test setting
         #
@@ -112,7 +111,7 @@ def setUp(self):
                     fit_func_index=0,
                     filter_kwargs={"type": 3, "valid": True},
                     data_option_keys=["outcome"],
-                )
+                ),
             ],
             fit_funcs=[fit_functions.exponential_decay],
             param_names=["p0", "p1", "p2", "p3", "p4"],
@@ -137,7 +136,7 @@ def test_data_extraction(self):
         test_data0 = simulate_output_data(
             func=fit_functions.exponential_decay,
             xvals=self.xvalues,
-            param_dict={"amp": 1.},
+            param_dict={"amp": 1.0},
             type=1,
             valid=True,
             dummy_val="test_val1",
@@ -148,7 +147,7 @@ def test_data_extraction(self):
         test_data1 = simulate_output_data(
             func=fit_functions.exponential_decay,
             xvals=self.xvalues,
-            param_dict={"amp": 1.},
+            param_dict={"amp": 1.0},
             type=2,
             valid=False,
             dummy_val="test_val2",
@@ -170,7 +169,7 @@ def test_data_extraction(self):
         np.testing.assert_array_almost_equal(curve_entries[0].x_values, self.xvalues)
 
         # check y values
-        ref_y = fit_functions.exponential_decay(self.xvalues, amp=1.)
+        ref_y = fit_functions.exponential_decay(self.xvalues, amp=1.0)
         np.testing.assert_array_almost_equal(
             curve_entries[0].y_values, ref_y, decimal=self.err_decimal
         )
@@ -184,8 +183,8 @@ def test_data_extraction(self):
         # check metadata
         ref_meta = {
             "experiment_type": {"fake_experiment"},
-            "qubits": {(0, )},
-            "dummy_val": {"test_val1"}
+            "qubits": {(0,)},
+            "dummy_val": {"test_val1"},
         }
         self.assertDictEqual(curve_entries[0].metadata, ref_meta)
 
@@ -211,7 +210,7 @@ def test_default_setup_fitting(self):
 
         options = self.analysis._setup_fitting(curve_data)
 
-        ref_p0 = {"p0": 0., "p1": 0., "p2": 0., "p3": 0., "p4": 0.}
+        ref_p0 = {"p0": 0.0, "p1": 0.0, "p2": 0.0, "p3": 0.0, "p4": 0.0}
         self.assertDictEqual(options[0]["p0"], ref_p0)
 
         ref_lb = {"p0": -np.inf, "p1": -np.inf, "p2": -np.inf, "p3": -np.inf, "p4": -np.inf}
@@ -227,15 +226,15 @@ def test_default_setup_fitting_with_parameter(self):
 
         options = self.analysis._setup_fitting(
             curve_data,
-            p0=[1., 2., 3., 4., 5.],
-            bounds=([-1., -2., -3., -4., -5.], [1., 2., 3., 4., 5.])
+            p0=[1.0, 2.0, 3.0, 4.0, 5.0],
+            bounds=([-1.0, -2.0, -3.0, -4.0, -5.0], [1.0, 2.0, 3.0, 4.0, 5.0]),
         )
 
-        ref_p0 = {"p0": 1., "p1": 2., "p2": 3., "p3": 4., "p4": 5.}
+        ref_p0 = {"p0": 1.0, "p1": 2.0, "p2": 3.0, "p3": 4.0, "p4": 5.0}
         self.assertDictEqual(options[0]["p0"], ref_p0)
 
-        ref_lb = {"p0": -1., "p1": -2., "p2": -3., "p3": -4., "p4": -5.}
-        ref_ub = {"p0": 1., "p1": 2., "p2": 3., "p3": 4., "p4": 5.}
+        ref_lb = {"p0": -1.0, "p1": -2.0, "p2": -3.0, "p3": -4.0, "p4": -5.0}
+        ref_ub = {"p0": 1.0, "p1": 2.0, "p2": 3.0, "p3": 4.0, "p4": 5.0}
 
         lb, ub = options[0]["bounds"]
         self.assertDictEqual(lb, ref_lb)
@@ -273,7 +272,7 @@ def test_run_single_curve_analysis(self):
         test_data = simulate_output_data(
             func=fit_functions.exponential_decay,
             xvals=self.xvalues,
-            param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3}
+            param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3},
         )
         results, _ = analysis._run_analysis(test_data, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
         result = results[0]
@@ -311,7 +310,7 @@ def test_run_single_curve_fail(self):
         test_data = simulate_output_data(
             func=fit_functions.exponential_decay,
             xvals=self.xvalues,
-            param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3}
+            param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3},
         )
 
         # Try to fit with infeasible parameter boundary. This should fail.

From 3ef172792bf8ffb2cce4529d23d2980f42761b3d Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Sat, 15 May 2021 04:50:03 +0900
Subject: [PATCH 27/74] simplify the analysis class

---
 qiskit_experiments/analysis/curve_analysis.py | 794 +++++-------------
 qiskit_experiments/analysis/curve_fitting.py  |   4 +-
 .../analysis/data_processing.py               |   4 +
 test/analysis/test_curve_fit.py               | 314 ++-----
 4 files changed, 326 insertions(+), 790 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 263d61aae1..27bc32b8f2 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -15,214 +15,33 @@
 """
 # pylint: disable=invalid-name
 
-import functools
-from collections import defaultdict
-from typing import Any, NamedTuple, Dict, List, Optional, Tuple, Callable, Union
+import dataclasses
+import inspect
+from typing import Any, Dict, List, Tuple, Callable, Union
 
 import numpy as np
-import scipy.optimize as opt
 from qiskit.exceptions import QiskitError
 
+from qiskit_experiments.analysis.curve_fitting import multi_curve_fit
+from qiskit_experiments.analysis.data_processing import level2_probability
 from qiskit_experiments.base_analysis import BaseAnalysis
 from qiskit_experiments.data_processing import DataProcessor
 from qiskit_experiments.data_processing.exceptions import DataProcessorError
 from qiskit_experiments.experiment_data import AnalysisResult, ExperimentData
 
-# Description of data properties for single curve entry
-SeriesDef = NamedTuple(
-    "SeriesDef",
-    [
-        ("name", str),
-        ("p0_signature", Dict[str, str]),
-        ("fit_func_index", int),
-        ("filter_kwargs", Optional[Dict[str, Any]]),
-        ("data_option_keys", Optional[List[str]]),
-    ],
-)
-
-# Human readable data set for single curve entry
-CurveEntry = NamedTuple(
-    "CurveEntry",
-    [
-        ("curve_name", str),
-        ("x_values", np.ndarray),
-        ("y_values", np.ndarray),
-        ("y_sigmas", np.ndarray),
-        ("metadata", dict),
-    ],
-)
-
-
-def scipy_curve_fit_wrapper(
-    f: Callable,
-    xdata: np.ndarray,
-    ydata: np.ndarray,
-    p0: Dict[str, float],
-    sigma: np.ndarray,
-    bounds: Tuple[Dict[str, np.ndarray], Dict[str, np.ndarray]],
-    **kwargs,
-) -> AnalysisResult:
-    r"""A helper function to perform a non-linear least squares to fit
-
-    This solves the optimization problem
-
-    .. math::
-        \Theta_{\mbox{opt}} = \arg\min_\Theta \sum_i \sigma_i^{-2} (f(x_i, \Theta) -  y_i)^2
-
-    using ``scipy.optimize.curve_fit``.
-
-    Args:
-        f: a fit function `f(x, *params)`.
-        xdata: a 1D float array of x-data.
-        ydata: a 1D float array of y-data.
-        p0: initial guess for optimization parameters.
-        sigma: a 1D array of standard deviations in ydata in absolute units.
-        bounds: lower and upper bounds for optimization parameters.
-        kwargs: additional kwargs for scipy.optimize.curve_fit.
-
-    Returns:
-        result containing ``popt`` the optimal fit parameters,
-        ``popt_err`` the standard error estimates popt,
-        ``pcov`` the covariance matrix for the fit,
-        ``reduced_chisq`` the reduced chi-squared parameter of fit,
-        ``dof`` the degrees of freedom of the fit,
-        ``xrange`` the range of xdata values used for fit.
-
-    Raises:
-        QiskitError: if the number of degrees of freedom of the fit is
-                     less than 1.
-
-    .. note::
-        ``sigma`` is assumed to be specified in the same units as ``ydata``
-        (absolute units). If sigma is instead specified in relative units
-        the `absolute_sigma=False` kwarg of scipy curve_fit must be used.
-        This affects the returned covariance ``pcov`` and error ``popt_err``
-        parameters via ``pcov(absolute_sigma=False) = pcov * reduced_chisq``
-        ``popt_err(absolute_sigma=False) = popt_err * sqrt(reduced_chisq)``.
-    """
-    # Format p0 parameters
-    param_keys = list(p0.keys())
-    param_p0 = list(p0.values())
-
-    lower = [bounds[0][key] for key in param_keys]
-    upper = [bounds[1][key] for key in param_keys]
-    param_bounds = (lower, upper)
-
-    # Check that degrees of freedom is greater than 0
-    dof = len(ydata) - len(p0)
-    if dof < 1:
-        raise QiskitError(
-            "The number of degrees of freedom of the fit data and model "
-            " (len(ydata) - len(p0)) is less than 1"
-        )
-
-    # Override scipy.curve_fit default for absolute_sigma=True
-    # if sigma is specified.
-    if sigma is not None and "absolute_sigma" not in kwargs:
-        kwargs["absolute_sigma"] = True
-
-    # Run curve fit
-    # pylint: disable = unbalanced-tuple-unpacking
-    popt, pcov = opt.curve_fit(
-        f=f, xdata=xdata, ydata=ydata, sigma=sigma, p0=param_p0, bounds=param_bounds, **kwargs
-    )
-    popt_err = np.sqrt(np.diag(pcov))
-
-    # Calculate the reduced chi-squared for fit
-    yfits = f(xdata, *popt)
-    residues = (yfits - ydata) ** 2
-    if sigma is not None:
-        residues = residues / (sigma ** 2)
-    reduced_chisq = np.sum(residues) / dof
-
-    # Compute xdata range for fit
-    xdata_range = [min(xdata), max(xdata)]
-
-    result = {
-        "popt": popt,
-        "popt_keys": param_keys,
-        "popt_err": popt_err,
-        "pcov": pcov,
-        "reduced_chisq": reduced_chisq,
-        "dof": dof,
-        "xrange": xdata_range,
-    }
-
-    return AnalysisResult(result)
-
-
-def level2_probability(data: Dict[str, Any], outcome: Optional[str] = None) -> Tuple[float, float]:
-    """Return the outcome probability mean and variance.
-
-    Args:
-        data: A data dict containing count data.
-        outcome: bitstring for desired outcome probability.
-
-    Returns:
-        (p_mean, p_var) of the probability mean and variance estimated from the counts.
-
-    .. note::
-
-        This assumes a binomial distribution where :math:`K` counts
-        of the desired outcome from :math:`N` shots the
-        mean probability is :math:`p = K / N` and the variance is
-        :math:`\\sigma^2 = p (1-p) / N`.
-    """
-    # TODO fix sigma definition
-    # When the count is 100% zero (i.e. simulator), this yields sigma=0.
-    # This crashes scipy fitter when it calculates covariance matrix (zero-div error).
 
-    counts = data["counts"]
-    outcome = outcome or "1" * len(list(counts.keys())[0])
+@dataclasses.dataclass
+class SeriesDef:
+    """Description of curve."""
 
-    shots = sum(counts.values())
-    p_mean = counts.get(outcome, 0.0) / shots
-    p_var = p_mean * (1 - p_mean) / shots
-    return p_mean, p_var
+    name: str
+    fit_func: Callable
+    filter_kwargs: Dict[str, Any] = dataclasses.field(default_factory=dict)
 
 
 class FitOptions(dict):
     """Fit options passed to the fitter function."""
 
-    def validate(self):
-        """Validate format of fitting options.
-
-        Raises:
-            TypeError:
-                - When parameter is not given by dictionary. Need mapping to parameter name.
-            KeyError:
-                - When necessary options are not fully defined.
-        """
-
-        # Initial guess
-        try:
-            p0 = self["p0"]
-            if not isinstance(p0, dict):
-                raise TypeError(
-                    "Initial guess is not a dictionary. Need parameter name "
-                    "associated with each parameter as a key."
-                )
-        except KeyError as ex:
-            raise KeyError("Initial parameters are not set.") from ex
-
-        # Boundaries
-        try:
-            lb, ub = self["bounds"]
-            if not isinstance(lb, dict) or not isinstance(ub, dict):
-                raise TypeError(
-                    "Parameter boundaries are not a dictionary. Need parameter name "
-                    "associated with each parameter as a key."
-                )
-
-        except KeyError as ex:
-            raise KeyError("Parameter boundaries are not set.") from ex
-
-        except TypeError as ex:
-            raise TypeError(
-                "Parameter boundaries are invalid format. Boundaries should be "
-                "lower and upper values as a tuple of two dictionary."
-            ) from ex
-
 
 class CurveAnalysis(BaseAnalysis):
     """A base class for curve fit type analysis.
@@ -235,29 +54,22 @@ class CurveAnalysis(BaseAnalysis):
 
         __x_key__: Key in the circuit metadata under which to find the value for
             the horizontal axis.
+        __processing_options__: Circuit metadata keys that are passed to the data processor.
+            The key should conform to the data processor API.
         __series__: A set of data points that will be fit to a the same parameters
             in the fit function. If this analysis contains multiple curves,
             the same number of series definitions should be listed.
             Each series definition is SeriesDef element, that may be initialized with::
 
-                name: Name of the curve. This is arbitrary field.
-                p0_signature: Mapping of parameter name to argument of the fit function
-                    specified by fit_func_index. The parameter names (dict values)
-                    should be defined in __param_names__.
-                fit_func_index: Index of fitting function associated with this curve.
-                    The fitting function should be listed in __fit_funcs__.
+                name: Name of the curve. This is arbitrary data field, but should be unique.
+                fit_func: Callback function to perform fit.
                 filter_kwargs: Circuit metadata key and value associated with this curve.
                     The data points of the curve is extracted from ExperimentData based on
                     this information.
-                data_option_keys: Circuit metadata keys that are passed to the data processor.
-                    The key should conform to the data processor API.
 
             See the Examples below for more details.
-        __fit_funcs__: List of callables to fit parameters. This is order sensitive.
-            The list index corresponds to the function index specified by __series__ definition.
-        __param_names__: Name of parameters to fit. This is order sensitive.
-        __base_fitter__: A callable to perform single curve fitting.
-            The function API should conform to the scipy curve fit module.
+        __base_fitter__: A callable to perform curve fitting.
+        __default_data_processor__: A callable to format y, y error data.
 
     Examples:
 
@@ -276,36 +88,18 @@ class AnalysisExample(CurveAnalysis):
                 __series__ = [
                     SeriesDef(
                         name="my_experiment1",
-                        p0_signature={"amp": "p0", "lamb": "p1", "baseline": "p2"},
-                        fit_func_index=0,
-                        filter_kwargs=None,
-                        data_option_keys=["outcome"]
+                        fit_func=lambda x, p0, p1, p2:
+                            exponential_decay(x, amp=p0, lamb=p1, baseline=p2),
                     ),
                 ]
 
-                __fit_funcs__ = [fit_functions.exponential_decay]
-
-                __param_names__ = ["p0", "p1", "p2"]
-
-        The signature of fit_functions.exponential may be::
-
-        .. code-block::
-
-            def exponential_decay(x, amp, lamb, base, x0, baseline) -> np.ndarray:
-
-        The p0_signature key represents a mapping of the fit parameters given by the analysis to
-        the arguments of the fit function. In this example, fit parameter "p0" is substituted
-        in "amp" of the exponential_decay function. Note that the fit function defines a
-        default value for each parameter, thus the default values are used for
-        unspecified parameters here, i.e. "base" and "x0".
-
 
         A fitting for two exponential decay curve with partly shared parameter
         ======================================================================
 
         In this type of experiment, the analysis deals with two curves.
         We need a __series__ definition for each curve, and filter_kwargs should be
-        properly defined to extract each curve data from the entire experiment data.
+        properly defined to separate each curve series.
 
         .. code-block::
 
@@ -316,43 +110,18 @@ class AnalysisExample(CurveAnalysis):
                 __series__ = [
                     SeriesDef(
                         name="my_experiment1",
-                        p0_signature={"amp": "p0", "lamb": "p1", "baseline": "p3"},
-                        fit_func_index=0,
-                        filter_kwargs={"my_option1": True},
-                        data_option_keys=["outcome"]
+                        fit_func=lambda x, p0, p1, p2, p3:
+                            exponential_decay(x, amp=p0, lamb=p1, baseline=p3),
+                        filter_kwargs={"experiment": 1},
                     ),
                     SeriesDef(
                         name="my_experiment2",
-                        p0_signature={"amp": "p0", "lamb": "p2", "baseline": "p3"},
-                        fit_func_index=0,
-                        filter_kwargs={"my_option1": False},
-                        data_option_keys=["outcome"]
+                        fit_func=lambda x, p0, p1, p2, p3:
+                            exponential_decay(x, amp=p0, lamb=p2, baseline=p3),
+                        filter_kwargs={"experiment": 2},
                     ),
                 ]
 
-                __fit_funcs__ = [fit_functions.exponential_decay]
-
-                __param_names__ = ["p0", "p1", "p2", "p3"]
-
-        Note that two series share the fit function exponential_decay.
-        However, these series fit two curves with different "lamb" parameters.
-        In total, there are 4 parameters defined in __param_names__.
-
-        The series 1 (my_experiment1) performs::
-
-        .. code-block::
-
-            def exponential_decay(x, amp=p0, lamb=p1, baseline=p3) -> np.ndarray:
-
-        The series 2 (my_experiment1) performs::
-
-        .. code-block::
-
-            def exponential_decay(x, amp=p0, lamb=p2, baseline=p3) -> np.ndarray:
-
-        Thus both curves assume the same "amp" and "baseline".
-        This parameter remapping is managed by the base analysis class behind the scene.
-
 
         A fitting for two trigonometric curves with the same parameter
         =============================================================
@@ -369,34 +138,18 @@ class AnalysisExample(CurveAnalysis):
                 __series__ = [
                     SeriesDef(
                         name="my_experiment1",
-                        param_names={"amp": "p0", "freq": "p1", "phase": "p3", "baseline": "p4"},
-                        fit_func_index=0,
-                        filter_kwargs={"my_option1": "X"},
-                        data_option_keys=["outcome"]
+                        fit_func=lambda x, p0, p1, p2, p3:
+                            cos(x, amp=p0, freq=p1, phase=p2, baseline=p3),
+                        filter_kwargs={"experiment": 1},
                     ),
                     SeriesDef(
                         name="my_experiment2",
-                        param_names={"amp": "p0", "freq": "p1", "phase": "p3", "baseline": "p4"},
-                        fit_func_index=1,
-                        filter_kwargs={"my_option1": "Y"},
-                        data_option_keys=["outcome"]
+                        fit_func=lambda x, p0, p1, p2, p3:
+                            sin(x, amp=p0, freq=p1, phase=p2, baseline=p3),
+                        filter_kwargs={"experiment": 2},
                     )
                 ]
 
-                __fit_funcs__ = [fit_functions.cos, fit_functions.sin]
-
-                __param_names__ = ["p0", "p1", "p3", "p4"]
-
-        The signature of each fit function may be::
-
-        .. code-block::
-
-            def cos(x, amp, freq, phase, baseline) -> np.ndarray:
-
-            def sin(x, amp, freq, phase, baseline) -> np.ndarray:
-
-        Note that series 1 (2) is linked to fit_functions.cos (sin) by the fit_func_index.
-        The parameters are totally shared with two curves.
 
     Notes:
         This CurveAnalysis class provides several private methods that subclasses can override.
@@ -434,29 +187,36 @@ def sin(x, amp, freq, phase, baseline) -> np.ndarray:
     #: str: Metadata key representing a scanned value.
     __x_key__ = "xval"
 
+    #: str: Metadata keys specifying data processing options.
+    __processing_options__ = ["outcome"]
+
     #: List[SeriesDef]: List of mapping representing a data series
     __series__ = None
 
-    #: List[Callable]: A callback function to define the expected curve
-    __fit_funcs__ = None
-
-    #: List[str]: Parameter name list
-    __param_names__ = list()
-
     # Callable: Default curve fitter. This can be overwritten.
-    __base_fitter__ = scipy_curve_fit_wrapper
+    __base_fitter__ = multi_curve_fit
 
     # Union[Callable, DataProcessor]: Data processor to format experiment data.
     __default_data_processor__ = level2_probability
 
     # pylint: disable = unused-argument, missing-return-type-doc
-    def _create_figures(self, curve_data: List[CurveEntry], fit_data: AnalysisResult):
+    def _create_figures(
+        self,
+        x_values: np.ndarray,
+        y_values: np.ndarray,
+        y_sigmas: np.ndarray,
+        series: np.ndarray,
+        fit_data: AnalysisResult,
+    ):
         """Create new figures with the fit result and raw data.
 
         Subclass can override this method to return figures.
 
         Args:
-            curve_data: List of raw curve data points with metadata.
+            x_values: Full data set of x values.
+            y_values: Full data set of y values.
+            y_sigmas: Full data set of y sigmas.
+            series: An integer array representing a mapping of data location to series index.
             fit_data: Analysis result containing fit parameters.
 
         Returns:
@@ -466,49 +226,37 @@ def _create_figures(self, curve_data: List[CurveEntry], fit_data: AnalysisResult
         return list()
 
     # pylint: disable = unused-argument
-    def _setup_fitting(self, curve_data: List[CurveEntry], **options) -> List[FitOptions]:
-        """Setup initial guesses, fit boundaries and other options passed to optimizer.
+    def _setup_fitting(
+        self,
+        x_values: np.ndarray,
+        y_values: np.ndarray,
+        y_sigmas: np.ndarray,
+        series: np.ndarray,
+        **options,
+    ) -> List[FitOptions]:
+        """An analysis subroutine that is called to set fitter options.
 
-        Subclass can override this method to provide proper optimization options.
+        This subroutine takes full data array and user-input fit options.
+        Subclasses can override this method to provide own fitter options
+        such as initial guesses.
 
-        .. notes::
-            This method returns list of FitOptions dictionary, and the options are
-            passed to the optimizer as a keyword arguments.
-            This should conform to the API which you specified in __base_fitter__.
-            This defaults to scipy curve_fit. If you create multiple FitOptions dictionaries,
-            fit is performed with each FitOptions and the fit result with the minimum
-            `reduced_chisq` will be returned as a final result.
+        Note that this subroutine can generate multiple fit options.
+        If multiple options are provided, fitter runs multiple times for each fit option,
+        and find the best result measured by the reduced chi-squared value.
 
         Args:
-            curve_data: List of raw curve data points to fit.
+            x_values: Full data set of x values.
+            y_values: Full data set of y values.
+            y_sigmas: Full data set of y sigmas.
+            series: An integer array representing a mapping of data location to series index.
             options: User provided fit options.
 
         Returns:
             List of FitOptions that are passed to fitter function.
         """
+        fit_options = FitOptions(**options)
 
-        def _dictionarize(argvar, default_val):
-            if argvar is not None:
-                try:
-                    argvar = list(argvar)
-                    return dict(zip(self.__param_names__, argvar))
-                except TypeError:
-                    return argvar
-            else:
-                return {pname: default_val for pname in self.__param_names__}
-
-        # Set initial guess
-        usr_p0 = options.pop("p0", None)
-        p0 = _dictionarize(usr_p0, default_val=0.0)
-
-        # Set boundaries
-        usr_lb, usr_ub = options.pop("bounds", (None, None))
-        lb = _dictionarize(usr_lb, default_val=-np.inf)
-        ub = _dictionarize(usr_ub, default_val=np.inf)
-
-        fit_option = FitOptions(p0=p0, bounds=(lb, ub), **options)
-
-        return [fit_option]
+        return [fit_options]
 
     # pylint: disable = unused-argument
     @staticmethod
@@ -572,7 +320,7 @@ def _extract_curves(
         self,
         experiment_data: ExperimentData,
         data_processor: Union[Callable, DataProcessor],
-    ) -> List[CurveEntry]:
+    ) -> Tuple[np.ndarray, ...]:
         """Extract curve data from experiment data.
 
         .. notes::
@@ -594,12 +342,9 @@ def _extract_curves(
         Raises:
             QiskitError:
                 - When __x_key__ is not defined in the circuit metadata.
-                - When __series__ is not defined.
             KeyError:
                 - When circuit metadata doesn't provide required data processor options.
         """
-        if self.__series__ is None:
-            raise QiskitError("Curve __series__ is not provided for this analysis.")
 
         def _is_target_series(datum, **filters):
             try:
@@ -607,256 +352,143 @@ def _is_target_series(datum, **filters):
             except KeyError:
                 return False
 
-        curve_data = list()
-        for curve_properties in self.__series__:
-            if curve_properties.filter_kwargs:
-                # filter data
-                series_data = [
-                    datum
-                    for datum in experiment_data.data()
-                    if _is_target_series(datum, **curve_properties.filter_kwargs)
-                ]
-            else:
-                # use data as-is
-                series_data = experiment_data.data()
-
-            if len(series_data) == 0:
-                # no data found
-                curve_data.append(
-                    CurveEntry(
-                        curve_name=curve_properties.name,
-                        x_values=np.empty(0, dtype=float),
-                        y_values=np.empty(0, dtype=float),
-                        y_sigmas=np.empty(0, dtype=float),
-                        metadata=dict(),
-                    )
-                )
-                continue
+        # Extract X, Y, Y_sigma data
+        data = experiment_data.data()
 
-            # Format x, y, yerr data
+        try:
+            x_values = [datum["metadata"][self.__x_key__] for datum in data]
+        except KeyError as ex:
+            raise QiskitError(
+                f"X value key {self.__x_key__} is not defined in circuit metadata."
+            ) from ex
+
+        def _data_processing(datum):
+            # A helper function to receive data processor runtime option from metadata
             try:
-                xvals = [datum["metadata"][self.__x_key__] for datum in series_data]
+                # Extract data processor options
+                dp_options = {key: datum["metadata"][key] for key in self.__processing_options__}
             except KeyError as ex:
-                raise QiskitError(
-                    f"X value key {self.__x_key__} is not defined in circuit metadata."
+                raise KeyError(
+                    "Required data processor options are not provided by circuit metadata."
                 ) from ex
+            return data_processor(datum, **dp_options)
 
-            option_keys = curve_properties.data_option_keys or dict()
-
-            def _data_processing(datum):
-                # A helper function to receive data processor runtime option from metadata
-                try:
-                    # Extract data processor options
-                    dp_options = {key: datum["metadata"][key] for key in option_keys}
-                except KeyError as ex:
-                    raise KeyError(
-                        "Required data processor options are not provided by circuit metadata."
-                    ) from ex
-                return data_processor(datum, **dp_options)
-
-            yvals, yerrs = zip(*map(_data_processing, series_data))
-
-            # Apply data pre-processing
-            prepared_xvals, prepared_yvals, prepared_yerrs = self._data_pre_processing(
-                x_values=np.asarray(xvals, dtype=float),
-                y_values=np.asarray(yvals, dtype=float),
-                y_sigmas=np.asarray(yerrs, dtype=float),
-            )
-
-            # Get common metadata fields except for xval, filter args, data processor args.
-            # These properties are obvious.
-            common_keys = list(
-                functools.reduce(
-                    lambda k1, k2: k1 & k2,
-                    map(lambda d: d.keys(), [datum["metadata"] for datum in series_data]),
-                )
-            )
-            common_keys.remove(self.__x_key__)
-            if curve_properties.filter_kwargs:
-                for key in curve_properties.filter_kwargs:
-                    common_keys.remove(key)
-            if curve_properties.data_option_keys:
-                for key in curve_properties.data_option_keys:
-                    common_keys.remove(key)
-
-            # Extract common metadata for the curve
-            curve_metadata = defaultdict(set)
-            for datum in series_data:
-                for key in common_keys:
-                    curve_metadata[key].add(datum["metadata"][key])
-
-            curve_data.append(
-                CurveEntry(
-                    curve_name=curve_properties.name,
-                    x_values=prepared_xvals,
-                    y_values=prepared_yvals,
-                    y_sigmas=prepared_yerrs,
-                    metadata=dict(curve_metadata),
-                )
-            )
-
-        return curve_data
+        y_values, y_sigmas = zip(*map(_data_processing, data))
 
-    def _run_fitting(
-        self,
-        curve_data: List[CurveEntry],
-        weights: Optional[np.ndarray] = None,
-        **options,
-    ) -> AnalysisResult:
-        r"""Perform a linearized multi-objective non-linear least squares fit.
+        # Format data
+        x_values, y_values, y_sigmas = self._data_pre_processing(
+            x_values=np.asarray(x_values, dtype=float),
+            y_values=np.asarray(y_values, dtype=float),
+            y_sigmas=np.asarray(y_sigmas, dtype=float),
+        )
 
-        This solves the optimization problem
+        # Find series (invalid data is labeled as -1)
+        series = -1 * np.ones(x_values.size, dtype=int)
+        for idx, series_def in enumerate(self.__series__):
+            data_index = np.asarray(
+                [_is_target_series(datum, **series_def.filter_kwargs) for datum in data], dtype=bool
+            )
+            series[data_index] = idx
 
-        .. math::
-            \Theta_{\mbox{opt}} = \arg\min_\Theta \sum_{k} w_k
-                \sum_{i} \sigma_{k, i}^{-2}
-                (f_k(x_{k, i}, \Theta) -  y_{k, i})^2
+        return x_values, y_values, y_sigmas, series
 
-        for multiple series of :math:`x_k, y_k, \sigma_k` data evaluated using
-        a list of objective functions :math:`[f_k]`
-        using ``scipy.optimize.curve_fit``.
+    def _format_fit_options(self, options: FitOptions) -> FitOptions:
+        """Format fitting option args to dictionary of parameter names.
 
         Args:
-            curve_data: A list of curve data to fit.
-            weights: Optional, a 1D float list of weights :math:`w_k` for each
-                     component function :math:`f_k`.
-            options: additional kwargs for scipy.optimize.curve_fit.
+            options: Generated fit options without tested.
 
         Returns:
-            result containing ``popt`` the optimal fit parameters,
-            ``popt_err`` the standard error estimates popt,
-            ``pcov`` the covariance matrix for the fit,
-            ``reduced_chisq`` the reduced chi-squared parameter of fit,
-            ``dof`` the degrees of freedom of the fit,
-            ``xrange`` the range of xdata values used for fit.
+            Formatted fit options.
 
         Raises:
             QiskitError:
-                - When number of weights are not identical to the curve_data entries.
+                - When fit functions have different signature.
             KeyError:
-                - When fit function doesn't return Chi squared value.
+                - When fit option is dictionary but key doesn't match with parameter names.
+                - When initial guesses are not provided.
+            ValueError:
+                - When fit option is array but length doesn't match with parameter number.
         """
-        num_curves = len(curve_data)
-
-        # Setup fitting options
-        fit_options = self._setup_fitting(curve_data, **options)
-        for fit_option in fit_options:
-            if isinstance(fit_option, FitOptions):
-                fit_option.validate()
-
-        # Validate weights
-        if weights is None:
-            sig_weights = np.ones(num_curves)
-        else:
-            if len(weights) != num_curves:
-                raise QiskitError(
-                    "weights should be the same length as the curve_data. "
-                    f"{len(weights)} != {num_curves}"
-                )
-            sig_weights = weights
-
-        # Concatenate all curve data
-        flat_xvals = np.empty(0, dtype=float)
-        flat_yvals = np.empty(0, dtype=float)
-        flat_yerrs = np.empty(0, dtype=float)
-        separators = np.empty(num_curves)
-
-        for idx, (datum, weight) in enumerate(zip(curve_data, sig_weights)):
-            flat_xvals = np.concatenate((flat_xvals, datum.x_values))
-            flat_yvals = np.concatenate((flat_yvals, datum.y_values))
-            if datum.y_sigmas is not None:
-                datum_yerrs = datum.y_sigmas / np.sqrt(weight)
-            else:
-                datum_yerrs = 1 / np.sqrt(weight)
-            flat_yerrs = np.concatenate((flat_yerrs, datum_yerrs))
-            separators[idx] = len(datum.x_values)
-        separators = list(map(int, np.cumsum(separators)[:-1]))
-
-        # Define multi-objective function
-        def multi_objective_fit(x, *params):
-            y = np.empty(0, dtype=float)
-            xs = np.split(x, separators) if len(separators) > 0 else [x]
-            for i, xi in enumerate(xs):
-                yi = self._calculate_curve(curve_data[i].curve_name, xi, *params)
-                y = np.concatenate((y, yi))
-            return y
-
-        # Try fit with each fit option
-        fit_results = [
-            self.__base_fitter__.__func__(
-                f=multi_objective_fit,
-                xdata=flat_xvals,
-                ydata=flat_yvals,
-                sigma=flat_yerrs,
-                **fit_option,
+        # check fit function signatures
+        fsigs = set()
+        for series_def in self.__series__:
+            fsigs.add(inspect.signature(series_def.fit_func))
+        if len(fsigs) > 1:
+            raise QiskitError(
+                "Fit functions specified in the series definition have "
+                "different function signature. They should receive "
+                "the same parameter set for multi-objective function fit."
             )
-            for fit_option in fit_options
-        ]
+        fit_params = list(list(fsigs)[0].parameters.keys())[1:]
+
+        # Validate dictionaly keys
+        def _check_keys(parameter_name):
+            named_values = options[parameter_name]
+            if not named_values.keys() == set(fit_params):
+                raise KeyError(
+                    f"Fitting option {parameter_name} doesn't have the "
+                    f"expected parameter names {','.join(fit_params)}."
+                )
 
-        # Sort by fit error
-        try:
-            fit_results = sorted(fit_results, key=lambda r: r["reduced_chisq"])
-        except KeyError as ex:
-            raise KeyError(
-                "Returned analysis result does not provide reduced Chi squared value."
-            ) from ex
+        # Convert array into dictionary
+        def _dictionarize(parameter_name):
+            parameter_array = options[parameter_name]
+            if len(parameter_array) != len(fit_params):
+                raise ValueError(
+                    f"Value length of fitting option {parameter_name} doesn't "
+                    "match with the length of expected parameters. "
+                    f"{len(parameter_array)} != {len(fit_params)}."
+                )
+            return dict(zip(fit_params, parameter_array))
 
-        best_analysis_result = fit_results[0]
-        best_analysis_result["popt_keys"] = self.__param_names__
+        if "p0" in options:
+            if isinstance(options["p0"], dict):
+                _check_keys("p0")
+            else:
+                options["p0"] = _dictionarize("p0")
+        else:
+            raise KeyError("Initial guess p0 is not provided to the fitting options.")
 
-        return best_analysis_result
+        if "bounds" in options:
+            if isinstance(options["bounds"], dict):
+                _check_keys("bounds")
+            else:
+                options["bounds"] = _dictionarize("bounds")
+        else:
+            options["bounds"] = dict(zip(fit_params, [(-np.inf, np.inf)] * len(fit_params)))
 
-    def _calculate_curve(self, curve_name: str, xvals: np.ndarray, *params: float) -> np.ndarray:
-        """A helper method to manage parameter remapping for each series.
+        return options
 
-        This method calculate curve based on the fit function specified by the
-        fit_func_index in each series definition.
+    def _subset_data(
+        self,
+        name: str,
+        x_values: np.ndarray,
+        y_values: np.ndarray,
+        y_sigmas: np.ndarray,
+        series: np.ndarray,
+    ) -> Tuple[np.ndarray, ...]:
+        """A helper method to extract reduced set of data.
 
         Args:
-            curve_name: A name of curve. This should be defined in __series__ attribute.
-            xvals: Array of x values.
-            params: Full fit parameters specified in __param_names__.
+            name: Series name to search for.
+            x_values: Full data set of x values.
+            y_values: Full data set of y values.
+            y_sigmas: Full data set of y sigmas.
+            series: An integer array representing a mapping of data location to series index.
 
         Returns:
-            Fit y values.
+            Tuple of x values, y values, y sigmas for the specific series.
 
         Raises:
             QiskitError:
-                - When prameter name and paramater value length don't match.
-                - When function parameter is not defined in the class parameter list.
-                - When fit function index is out of range.
-                - When curve information is not defined in class attribute __series__.
-                - When series parameter is not defined in __param_names__.
+                - When name is not defined in the __series__ definition.
         """
-        if len(self.__param_names__) != len(params):
-            raise QiskitError(
-                "Length of defined parameter names does not match with "
-                f"supplied parameter values. {', '.join(self.__param_names__)} != {params}."
-            )
-
-        named_params = dict(zip(self.__param_names__, params))
-
-        for curve_properties in self.__series__:
-            if curve_properties.name == curve_name:
-                # remap parameters
-                kw_params = {}
-                for key, pname in curve_properties.p0_signature.items():
-                    try:
-                        kw_params[key] = named_params[pname]
-                    except KeyError as ex:
-                        raise QiskitError(
-                            f"Series parameter {pname} is not found in the fit parameter. "
-                            f"{pname} not in {', '.join(named_params.keys())}. "
-                        ) from ex
-
-                # find fit function
-                f_index = curve_properties.fit_func_index
-                try:
-                    return self.__fit_funcs__[f_index](xvals, **kw_params)
-                except IndexError as ex:
-                    raise QiskitError(f"Fit function of index {f_index} is not defined.") from ex
-
-        raise QiskitError(f"A curve {curve_name} is not defined in this class.")
+        for idx, series_def in enumerate(self.__series__):
+            if series_def.name == name:
+                data_index = series == idx
+                return x_values[data_index], y_values[data_index], y_sigmas[data_index]
+        raise QiskitError(f"Specified series {name} is not defined in this analysis.")
 
     def _run_analysis(
         self, data: ExperimentData, **options
@@ -872,10 +504,15 @@ def _run_analysis(
                    ``analysis_results`` may be a single or list of
                    AnalysisResult objects, and ``figures`` is a list of any
                    figures for the experiment.
+
+        Raises:
+
         """
         analysis_result = AnalysisResult()
 
-        # Setup data processor
+        #
+        # 1. Setup data processor
+        #
         data_processor = options.pop("data_processor", self.__default_data_processor__)
 
         # TODO add ` and not data_processor.trained:`
@@ -894,38 +531,73 @@ def _run_analysis(
             # Callback function
             data_processor = data_processor.__func__
 
-        # Extract curve entries from experiment data
+        #
+        # 2. Extract curve entries from experiment data
+        #
+        # pylint: disable=broad-except
         try:
-            curve_data = self._extract_curves(data, data_processor)
-        except DataProcessorError as ex:
+            xdata, ydata, sigma, series = self._extract_curves(data, data_processor)
+        except Exception as ex:
             analysis_result["error_message"] = str(ex)
             analysis_result["success"] = False
             return [analysis_result], list()
 
-        # Run fitting
+        #
+        # 3. Run fitting
+        #
         # pylint: disable=broad-except
         try:
-            fit_data = self._run_fitting(curve_data=curve_data, **options)
-            analysis_result.update(fit_data)
+            # Generate fit options
+            fit_options_set = [
+                self._format_fit_options(fit_options)
+                for fit_options in self._setup_fitting(xdata, ydata, sigma, series, **options)
+            ]
+            fit_results = [
+                self.__base_fitter__.__func__(
+                    funcs=[series_def.fit_func for series_def in self.__series__],
+                    series=series,
+                    xdata=xdata,
+                    ydata=ydata,
+                    sigma=sigma,
+                    **fit_options,
+                )
+                for fit_options in fit_options_set
+            ]
+            # Sort by chi squared value
+            fit_results = sorted(fit_results, key=lambda r: r["reduced_chisq"])
+
+            # Returns best fit result
+            analysis_result = fit_results[0]
             analysis_result["success"] = True
         except Exception as ex:
             analysis_result["error_message"] = str(ex)
             analysis_result["success"] = False
 
-        # Post-process analysis data
+        #
+        # 4. Post-process analysis data
+        #
         analysis_result = self._post_processing(analysis_result)
 
-        # Create figures
-        figures = self._create_figures(curve_data=curve_data, fit_data=analysis_result)
+        #
+        # 5. Create figures
+        #
+        figures = self._create_figures(
+            x_values=xdata, y_values=ydata, y_sigmas=sigma, series=series, fit_data=analysis_result
+        )
 
-        # Store raw data
-        raw_data = dict()
-        for datum in curve_data:
-            raw_data[datum.curve_name] = {
-                "x_values": datum.x_values,
-                "y_values": datum.y_values,
-                "y_sigmas": datum.y_sigmas,
+        #
+        # 6. Save raw data
+        #
+        raw_data_dict = dict()
+        for series_def in self.__series__:
+            sub_xdata, sub_ydata, sub_sigma = self._subset_data(
+                name=series_def.name, x_values=xdata, y_values=ydata, y_sigmas=sigma, series=series
+            )
+            raw_data_dict[series_def.name] = {
+                "xdata": sub_xdata,
+                "ydata": sub_ydata,
+                "sigma": sub_sigma,
             }
-        analysis_result["raw_data"] = raw_data
+        analysis_result["raw_data"] = raw_data_dict
 
         return [analysis_result], figures
diff --git a/qiskit_experiments/analysis/curve_fitting.py b/qiskit_experiments/analysis/curve_fitting.py
index b5717eb7a1..a979f9e828 100644
--- a/qiskit_experiments/analysis/curve_fitting.py
+++ b/qiskit_experiments/analysis/curve_fitting.py
@@ -221,11 +221,11 @@ def multi_curve_fit(
                 wsigma[idxs[i]] = sigma[idxs[i]] / np.sqrt(weights[i])
 
     # Define multi-objective function
-    def f(x, *params):
+    def f(x, *params, **kwargs):
         y = np.zeros(x.size)
         for i in range(num_funcs):
             xi = x[idxs[i]]
-            yi = funcs[i](xi, *params)
+            yi = funcs[i](xi, *params, **kwargs)
             y[idxs[i]] = yi
         return y
 
diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index 94e3361dcb..dafe630a8b 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -177,6 +177,10 @@ def level2_probability(data: Dict[str, any], outcome: str) -> Tuple[float, float
         mean probability is :math:`p = K / N` and the variance is
         :math:`\\sigma^2 = p (1-p) / N`.
     """
+    # TODO fix sigma definition
+    # When the count is 100% zero (i.e. simulator), this yields sigma=0.
+    # This crashes scipy fitter when it calculates covariance matrix (zero-div error).
+
     counts = data["counts"]
     shots = sum(counts.values())
     p_mean = counts.get(outcome, 0.0) / shots
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index dea3a20be3..459b322b37 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -13,13 +13,13 @@
 """Test curve fitting base class."""
 # pylint: disable=invalid-name
 
-from typing import List, Callable
+from typing import List
 
 import numpy as np
 from qiskit.test import QiskitTestCase
 
 from qiskit_experiments import ExperimentData
-from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, fit_functions
+from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, fit_functions, FitOptions
 from qiskit_experiments.base_experiment import BaseExperiment
 
 
@@ -58,8 +58,6 @@ def simulate_output_data(func, xvals, param_dict, **metadata):
 def create_new_analysis(
     x_key: str = "xval",
     series: List[SeriesDef] = None,
-    fit_funcs: List[Callable] = None,
-    param_names: List[str] = None,
 ) -> CurveAnalysis:
     """A helper function to create a mock analysis class instance."""
 
@@ -68,8 +66,6 @@ class TestAnalysis(CurveAnalysis):
 
         __x_key__ = x_key
         __series__ = series
-        __fit_funcs__ = fit_funcs
-        __param_names__ = param_names
 
     return TestAnalysis()
 
@@ -87,34 +83,32 @@ def setUp(self):
         # - Each curve can be represented by the same function
         # - Parameter amp and baseline are shared among all curves
         # - Each curve has unique lamb
-        # - In total 4 parameters in the fit, namely, p0, p1, p2, p3
+        # - In total 5 parameters in the fit, namely, p0, p1, p2, p3
         #
         self.analysis = create_new_analysis(
             series=[
                 SeriesDef(
                     name="curve1",
-                    p0_signature={"amp": "p0", "lamb": "p1", "baseline": "p4"},
-                    fit_func_index=0,
+                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_functions.exponential_decay(
+                        x, amp=p0, lamb=p1, baseline=p4
+                    ),
                     filter_kwargs={"type": 1, "valid": True},
-                    data_option_keys=["outcome"],
                 ),
                 SeriesDef(
                     name="curve2",
-                    p0_signature={"amp": "p0", "lamb": "p2", "baseline": "p4"},
-                    fit_func_index=0,
+                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_functions.exponential_decay(
+                        x, amp=p0, lamb=p2, baseline=p4
+                    ),
                     filter_kwargs={"type": 2, "valid": True},
-                    data_option_keys=["outcome"],
                 ),
                 SeriesDef(
                     name="curve3",
-                    p0_signature={"amp": "p0", "lamb": "p3", "baseline": "p4"},
-                    fit_func_index=0,
+                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_functions.exponential_decay(
+                        x, amp=p0, lamb=p3, baseline=p4
+                    ),
                     filter_kwargs={"type": 3, "valid": True},
-                    data_option_keys=["outcome"],
                 ),
             ],
-            fit_funcs=[fit_functions.exponential_decay],
-            param_names=["p0", "p1", "p2", "p3", "p4"],
         )
         self.err_decimal = 3
 
@@ -139,7 +133,6 @@ def test_data_extraction(self):
             param_dict={"amp": 1.0},
             type=1,
             valid=True,
-            dummy_val="test_val1",
             outcome="1",
         )
 
@@ -147,98 +140,76 @@ def test_data_extraction(self):
         test_data1 = simulate_output_data(
             func=fit_functions.exponential_decay,
             xvals=self.xvalues,
-            param_dict={"amp": 1.0},
+            param_dict={"amp": 0.5},
             type=2,
             valid=False,
-            dummy_val="test_val2",
             outcome="1",
         )
         # merge two experiment data
         for datum in test_data1.data():
             test_data0.add_data(datum)
 
-        curve_entries = self.analysis._extract_curves(test_data0, self.data_processor)
+        xdata, ydata, sigma, series = self.analysis._extract_curves(test_data0, self.data_processor)
 
         # check if the module filter off data: valid=False
-        self.assertEqual(len(curve_entries), 3)
-
-        # check name is passed
-        self.assertEqual(curve_entries[0].curve_name, "curve1")
+        self.assertEqual(len(xdata), 20)
 
         # check x values
-        np.testing.assert_array_almost_equal(curve_entries[0].x_values, self.xvalues)
+        ref_x = np.concatenate((self.xvalues, self.xvalues))
+        np.testing.assert_array_almost_equal(xdata, ref_x)
 
         # check y values
-        ref_y = fit_functions.exponential_decay(self.xvalues, amp=1.0)
-        np.testing.assert_array_almost_equal(
-            curve_entries[0].y_values, ref_y, decimal=self.err_decimal
-        )
-
-        # check y errors
-        ref_yerr = ref_y * (1 - ref_y) / 1024
-        np.testing.assert_array_almost_equal(
-            curve_entries[0].y_sigmas, ref_yerr, decimal=self.err_decimal
+        ref_y = np.concatenate(
+            (
+                fit_functions.exponential_decay(self.xvalues, amp=1.0),
+                fit_functions.exponential_decay(self.xvalues, amp=0.5),
+            )
         )
+        np.testing.assert_array_almost_equal(ydata, ref_y, decimal=self.err_decimal)
 
-        # check metadata
-        ref_meta = {
-            "experiment_type": {"fake_experiment"},
-            "qubits": {(0,)},
-            "dummy_val": {"test_val1"},
-        }
-        self.assertDictEqual(curve_entries[0].metadata, ref_meta)
-
-    def test_curve_calculation(self):
-        """Test series curve calculation."""
-        params = [1.0, 0.7, 0.9, 1.1, 0.1]
-
-        y1 = self.analysis._calculate_curve("curve1", self.xvalues, *params)
-        ref_y1 = fit_functions.exponential_decay(self.xvalues, amp=1.0, lamb=0.7, baseline=0.1)
-        np.testing.assert_array_almost_equal(y1, ref_y1, decimal=self.err_decimal)
-
-        y2 = self.analysis._calculate_curve("curve2", self.xvalues, *params)
-        ref_y2 = fit_functions.exponential_decay(self.xvalues, amp=1.0, lamb=0.9, baseline=0.1)
-        np.testing.assert_array_almost_equal(y2, ref_y2, decimal=self.err_decimal)
-
-        y3 = self.analysis._calculate_curve("curve3", self.xvalues, *params)
-        ref_y3 = fit_functions.exponential_decay(self.xvalues, amp=1.0, lamb=1.1, baseline=0.1)
-        np.testing.assert_array_almost_equal(y3, ref_y3, decimal=self.err_decimal)
-
-    def test_default_setup_fitting(self):
-        """Test default behavior of fitter setup."""
-        curve_data = []
-
-        options = self.analysis._setup_fitting(curve_data)
+        # check series
+        ref_series = np.concatenate((np.zeros(10, dtype=int), -1 * np.ones(10, dtype=int)))
+        self.assertListEqual(list(series), list(ref_series))
 
-        ref_p0 = {"p0": 0.0, "p1": 0.0, "p2": 0.0, "p3": 0.0, "p4": 0.0}
-        self.assertDictEqual(options[0]["p0"], ref_p0)
-
-        ref_lb = {"p0": -np.inf, "p1": -np.inf, "p2": -np.inf, "p3": -np.inf, "p4": -np.inf}
-        ref_ub = {"p0": np.inf, "p1": np.inf, "p2": np.inf, "p3": np.inf, "p4": np.inf}
-
-        lb, ub = options[0]["bounds"]
-        self.assertDictEqual(lb, ref_lb)
-        self.assertDictEqual(ub, ref_ub)
-
-    def test_default_setup_fitting_with_parameter(self):
-        """Test default behavior of fitter setup when user parameter is provided."""
-        curve_data = []
-
-        options = self.analysis._setup_fitting(
-            curve_data,
-            p0=[1.0, 2.0, 3.0, 4.0, 5.0],
-            bounds=([-1.0, -2.0, -3.0, -4.0, -5.0], [1.0, 2.0, 3.0, 4.0, 5.0]),
+        # check y errors
+        ref_yerr = ref_y * (1 - ref_y) / 100000
+        np.testing.assert_array_almost_equal(sigma, ref_yerr, decimal=self.err_decimal)
+
+    def test_get_subset(self):
+        """Test that get subset data from full data array."""
+
+        xdata = np.asarray([1, 2, 3, 4, 5, 6], dtype=float)
+        ydata = np.asarray([1, 2, 3, 4, 5, 6], dtype=float)
+        sigma = np.asarray([1, 2, 3, 4, 5, 6], dtype=float)
+        series = np.asarray([0, 1, 0, 2, 2, -1], dtype=int)
+
+        subx, suby, subs = self.analysis._subset_data("curve1", xdata, ydata, sigma, series)
+        np.testing.assert_array_almost_equal(subx, np.asarray([1, 3], dtype=float))
+        np.testing.assert_array_almost_equal(suby, np.asarray([1, 3], dtype=float))
+        np.testing.assert_array_almost_equal(subs, np.asarray([1, 3], dtype=float))
+
+        subx, suby, subs = self.analysis._subset_data("curve2", xdata, ydata, sigma, series)
+        np.testing.assert_array_almost_equal(subx, np.asarray([2], dtype=float))
+        np.testing.assert_array_almost_equal(suby, np.asarray([2], dtype=float))
+        np.testing.assert_array_almost_equal(subs, np.asarray([2], dtype=float))
+
+        subx, suby, subs = self.analysis._subset_data("curve3", xdata, ydata, sigma, series)
+        np.testing.assert_array_almost_equal(subx, np.asarray([4, 5], dtype=float))
+        np.testing.assert_array_almost_equal(suby, np.asarray([4, 5], dtype=float))
+        np.testing.assert_array_almost_equal(subs, np.asarray([4, 5], dtype=float))
+
+    def test_formatting_options(self):
+        """Test option formatter."""
+        test_options = FitOptions(
+            p0=[0, 1, 2, 3, 4], bounds=[(-1, 1), (-2, 2), (-3, 3), (-4, 4), (-5, 5)]
         )
+        formatted_options = self.analysis._format_fit_options(test_options)
 
-        ref_p0 = {"p0": 1.0, "p1": 2.0, "p2": 3.0, "p3": 4.0, "p4": 5.0}
-        self.assertDictEqual(options[0]["p0"], ref_p0)
-
-        ref_lb = {"p0": -1.0, "p1": -2.0, "p2": -3.0, "p3": -4.0, "p4": -5.0}
-        ref_ub = {"p0": 1.0, "p1": 2.0, "p2": 3.0, "p3": 4.0, "p4": 5.0}
+        ref_p0 = {"p0": 0, "p1": 1, "p2": 2, "p3": 3, "p4": 4}
+        self.assertDictEqual(formatted_options["p0"], ref_p0)
 
-        lb, ub = options[0]["bounds"]
-        self.assertDictEqual(lb, ref_lb)
-        self.assertDictEqual(ub, ref_ub)
+        ref_bounds = {"p0": (-1, 1), "p1": (-2, 2), "p2": (-3, 3), "p3": (-4, 4), "p4": (-5, 5)}
+        self.assertDictEqual(formatted_options["bounds"], ref_bounds)
 
 
 class TestCurveAnalysisIntegration(QiskitTestCase):
@@ -255,14 +226,11 @@ def test_run_single_curve_analysis(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    p0_signature={"amp": "p0", "lamb": "p1", "x0": "p2", "baseline": "p3"},
-                    fit_func_index=0,
-                    filter_kwargs=None,
-                    data_option_keys=None,
+                    fit_func=lambda x, p0, p1, p2, p3: fit_functions.exponential_decay(
+                        x, amp=p0, lamb=p1, x0=p2, baseline=p3
+                    ),
                 )
             ],
-            fit_funcs=[fit_functions.exponential_decay],
-            param_names=["p0", "p1", "p2", "p3"],
         )
         ref_p0 = 0.9
         ref_p1 = 2.5
@@ -273,6 +241,7 @@ def test_run_single_curve_analysis(self):
             func=fit_functions.exponential_decay,
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3},
+            outcome="1",
         )
         results, _ = analysis._run_analysis(test_data, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
         result = results[0]
@@ -293,14 +262,11 @@ def test_run_single_curve_fail(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    p0_signature={"amp": "p0", "lamb": "p1", "x0": "p2", "baseline": "p3"},
-                    fit_func_index=0,
-                    filter_kwargs=None,
-                    data_option_keys=None,
+                    fit_func=lambda x, p0, p1, p2, p3: fit_functions.exponential_decay(
+                        x, amp=p0, lamb=p1, x0=p2, baseline=p3
+                    ),
                 )
             ],
-            fit_funcs=[fit_functions.exponential_decay],
-            param_names=["p0", "p1", "p2", "p3"],
         )
         ref_p0 = 0.9
         ref_p1 = 2.5
@@ -311,6 +277,7 @@ def test_run_single_curve_fail(self):
             func=fit_functions.exponential_decay,
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3},
+            outcome="1",
         )
 
         # Try to fit with infeasible parameter boundary. This should fail.
@@ -332,21 +299,19 @@ def test_run_two_curves_with_same_fitfunc(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    p0_signature={"amp": "p0", "lamb": "p1", "x0": "p3", "baseline": "p4"},
-                    fit_func_index=0,
+                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_functions.exponential_decay(
+                        x, amp=p0, lamb=p1, x0=p3, baseline=p4
+                    ),
                     filter_kwargs={"exp": 0},
-                    data_option_keys=None,
                 ),
                 SeriesDef(
-                    name="curve2",
-                    p0_signature={"amp": "p0", "lamb": "p2", "x0": "p3", "baseline": "p4"},
-                    fit_func_index=0,
+                    name="curve1",
+                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_functions.exponential_decay(
+                        x, amp=p0, lamb=p2, x0=p3, baseline=p4
+                    ),
                     filter_kwargs={"exp": 1},
-                    data_option_keys=None,
                 ),
             ],
-            fit_funcs=[fit_functions.exponential_decay],
-            param_names=["p0", "p1", "p2", "p3", "p4"],
         )
         ref_p0 = 0.9
         ref_p1 = 7.0
@@ -359,6 +324,7 @@ def test_run_two_curves_with_same_fitfunc(self):
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p3, "baseline": ref_p4},
             exp=0,
+            outcome="1",
         )
 
         test_data1 = simulate_output_data(
@@ -366,6 +332,7 @@ def test_run_two_curves_with_same_fitfunc(self):
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "lamb": ref_p2, "x0": ref_p3, "baseline": ref_p4},
             exp=1,
+            outcome="1",
         )
 
         # merge two experiment data
@@ -387,21 +354,19 @@ def test_run_two_curves_with_two_fitfuncs(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    p0_signature={"amp": "p0", "freq": "p1", "phase": "p2", "baseline": "p3"},
-                    fit_func_index=0,
+                    fit_func=lambda x, p0, p1, p2, p3: fit_functions.cos(
+                        x, amp=p0, freq=p1, phase=p2, baseline=p3
+                    ),
                     filter_kwargs={"exp": 0},
-                    data_option_keys=None,
                 ),
                 SeriesDef(
                     name="curve2",
-                    p0_signature={"amp": "p0", "freq": "p1", "phase": "p2", "baseline": "p3"},
-                    fit_func_index=1,
+                    fit_func=lambda x, p0, p1, p2, p3: fit_functions.sin(
+                        x, amp=p0, freq=p1, phase=p2, baseline=p3
+                    ),
                     filter_kwargs={"exp": 1},
-                    data_option_keys=None,
                 ),
             ],
-            fit_funcs=[fit_functions.cos, fit_functions.sin],
-            param_names=["p0", "p1", "p2", "p3"],
         )
         ref_p0 = 0.1
         ref_p1 = 2
@@ -413,6 +378,7 @@ def test_run_two_curves_with_two_fitfuncs(self):
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "freq": ref_p1, "phase": ref_p2, "baseline": ref_p3},
             exp=0,
+            outcome="1",
         )
 
         test_data1 = simulate_output_data(
@@ -420,6 +386,7 @@ def test_run_two_curves_with_two_fitfuncs(self):
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "freq": ref_p1, "phase": ref_p2, "baseline": ref_p3},
             exp=1,
+            outcome="1",
         )
 
         # merge two experiment data
@@ -434,110 +401,3 @@ def test_run_two_curves_with_two_fitfuncs(self):
         # check result data
         self.assertTrue(result["success"])
         np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=self.err_decimal)
-
-    def test_fit_with_data_option(self):
-        """Test analysis by passing data processing option to the data processor."""
-
-        def inverted_decay(x, amp, lamb, x0, baseline):
-            # measure inverse of population
-            return 1 - fit_functions.exponential_decay(
-                x, amp=amp, lamb=lamb, x0=x0, baseline=baseline
-            )
-
-        analysis = create_new_analysis(
-            series=[
-                SeriesDef(
-                    name="curve1",
-                    p0_signature={"amp": "p0", "lamb": "p1", "x0": "p2", "baseline": "p3"},
-                    fit_func_index=0,
-                    filter_kwargs=None,
-                    data_option_keys=["outcome"],
-                )
-            ],
-            fit_funcs=[inverted_decay],
-            param_names=["p0", "p1", "p2", "p3"],
-        )
-        ref_p0 = 0.9
-        ref_p1 = 2.5
-        ref_p2 = 0.0
-        ref_p3 = 0.1
-
-        # tell metadata to count zero
-        test_data = simulate_output_data(
-            func=fit_functions.exponential_decay,
-            xvals=self.xvalues,
-            param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3},
-            outcome="0",  # metadata, label to count
-        )
-
-        results, _ = analysis._run_analysis(test_data, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
-        result = results[0]
-
-        ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
-
-        # check result data
-        self.assertTrue(result["success"])
-
-        np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=self.err_decimal)
-
-    def test_fit_failure_with_wrong_signature(self):
-        """Test if fitting fails when wrong signature is defined."""
-        analysis = create_new_analysis(
-            series=[
-                SeriesDef(
-                    name="curve1",
-                    p0_signature={"not_defined_parameter": "p0"},  # invalid mapping
-                    fit_func_index=0,
-                    filter_kwargs=None,
-                    data_option_keys=None,
-                )
-            ],
-            fit_funcs=[fit_functions.exponential_decay],
-            param_names=["p0"],
-        )
-        ref_p0 = 0.9
-
-        test_data = simulate_output_data(
-            func=fit_functions.cos,
-            xvals=self.xvalues,
-            param_dict={"amp": ref_p0},
-        )
-
-        results, _ = analysis._run_analysis(test_data, p0=[ref_p0])
-        result = results[0]
-
-        self.assertFalse(result["success"])
-
-        ref_result_keys = ["raw_data", "error_message", "success"]
-        self.assertSetEqual(set(result.keys()), set(ref_result_keys))
-
-    def test_fit_failure_with_unclear_parameter(self):
-        """Test if fitting fails when parameter not defined in fit is used.."""
-        analysis = create_new_analysis(
-            series=[
-                SeriesDef(
-                    name="curve1",
-                    p0_signature={"amp": "not_defined_parameter"},  # this parameter is not defined
-                    fit_func_index=0,
-                    filter_kwargs=None,
-                    data_option_keys=None,
-                )
-            ],
-            fit_funcs=[fit_functions.exponential_decay],
-            param_names=["p0"],
-        )
-        ref_p0 = 0.9
-
-        test_data = simulate_output_data(
-            func=fit_functions.cos,
-            xvals=self.xvalues,
-            param_dict={"amp": ref_p0},
-        )
-
-        results, _ = analysis._run_analysis(test_data, p0=[ref_p0])
-        result = results[0]
-
-        self.assertFalse(result["success"])
-
-        ref_result_keys = ["raw_data", "error_message", "success"]
-        self.assertSetEqual(set(result.keys()), set(ref_result_keys))

From 1f64b4236864d28a7682da44e72f2bab2242013e Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Sat, 15 May 2021 05:07:25 +0900
Subject: [PATCH 28/74] misc

---
 qiskit_experiments/analysis/curve_analysis.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 27bc32b8f2..9782846258 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -548,7 +548,7 @@ def _run_analysis(
         # pylint: disable=broad-except
         try:
             # Generate fit options
-            fit_options_set = [
+            fit_options_candidates = [
                 self._format_fit_options(fit_options)
                 for fit_options in self._setup_fitting(xdata, ydata, sigma, series, **options)
             ]
@@ -561,13 +561,13 @@ def _run_analysis(
                     sigma=sigma,
                     **fit_options,
                 )
-                for fit_options in fit_options_set
+                for fit_options in fit_options_candidates
             ]
             # Sort by chi squared value
             fit_results = sorted(fit_results, key=lambda r: r["reduced_chisq"])
 
             # Returns best fit result
-            analysis_result = fit_results[0]
+            analysis_result.update(**fit_results[0])
             analysis_result["success"] = True
         except Exception as ex:
             analysis_result["error_message"] = str(ex)

From 511b41f84d26d45944ec2eb9a451c95ce8700b67 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 18 May 2021 16:13:14 +0900
Subject: [PATCH 29/74] add default figure generation

---
 qiskit_experiments/analysis/curve_analysis.py | 85 ++++++++++++++++---
 qiskit_experiments/analysis/plotting.py       |  2 +
 2 files changed, 76 insertions(+), 11 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 9782846258..03e3fdbfb3 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -17,7 +17,7 @@
 
 import dataclasses
 import inspect
-from typing import Any, Dict, List, Tuple, Callable, Union
+from typing import Any, Dict, List, Tuple, Callable, Union, Optional
 
 import numpy as np
 from qiskit.exceptions import QiskitError
@@ -28,6 +28,7 @@
 from qiskit_experiments.data_processing import DataProcessor
 from qiskit_experiments.data_processing.exceptions import DataProcessorError
 from qiskit_experiments.experiment_data import AnalysisResult, ExperimentData
+from qiskit_experiments.analysis import plotting
 
 
 @dataclasses.dataclass
@@ -37,6 +38,8 @@ class SeriesDef:
     name: str
     fit_func: Callable
     filter_kwargs: Dict[str, Any] = dataclasses.field(default_factory=dict)
+    plot_color: str = "black"
+    plot_symbol: str = "o"
 
 
 class FitOptions(dict):
@@ -66,11 +69,14 @@ class CurveAnalysis(BaseAnalysis):
                 filter_kwargs: Circuit metadata key and value associated with this curve.
                     The data points of the curve is extracted from ExperimentData based on
                     this information.
+                plot_color: String color representation of this series in the plot.
+                plot_symbol: String formatter of the scatter of this series in the plot.
 
             See the Examples below for more details.
         __base_fitter__: A callable to perform curve fitting.
         __default_data_processor__: A callable to format y, y error data.
 
+
     Examples:
 
         A fitting for single exponential decay curve
@@ -113,12 +119,16 @@ class AnalysisExample(CurveAnalysis):
                         fit_func=lambda x, p0, p1, p2, p3:
                             exponential_decay(x, amp=p0, lamb=p1, baseline=p3),
                         filter_kwargs={"experiment": 1},
+                        plot_color="red",
+                        plot_symbpl="^",
                     ),
                     SeriesDef(
                         name="my_experiment2",
                         fit_func=lambda x, p0, p1, p2, p3:
                             exponential_decay(x, amp=p0, lamb=p2, baseline=p3),
                         filter_kwargs={"experiment": 2},
+                        plot_color="blue",
+                        plot_symbpl="o",
                     ),
                 ]
 
@@ -141,12 +151,16 @@ class AnalysisExample(CurveAnalysis):
                         fit_func=lambda x, p0, p1, p2, p3:
                             cos(x, amp=p0, freq=p1, phase=p2, baseline=p3),
                         filter_kwargs={"experiment": 1},
+                        plot_color="red",
+                        plot_symbpl="^",
                     ),
                     SeriesDef(
                         name="my_experiment2",
                         fit_func=lambda x, p0, p1, p2, p3:
                             sin(x, amp=p0, freq=p1, phase=p2, baseline=p3),
                         filter_kwargs={"experiment": 2},
+                        plot_color="blue",
+                        plot_symbpl="o",
                     )
                 ]
 
@@ -193,37 +207,86 @@ class AnalysisExample(CurveAnalysis):
     #: List[SeriesDef]: List of mapping representing a data series
     __series__ = None
 
-    # Callable: Default curve fitter. This can be overwritten.
+    #: Callable: Default curve fitter. This can be overwritten.
     __base_fitter__ = multi_curve_fit
 
-    # Union[Callable, DataProcessor]: Data processor to format experiment data.
+    #: Union[Callable, DataProcessor]: Data processor to format experiment data.
     __default_data_processor__ = level2_probability
 
-    # pylint: disable = unused-argument, missing-return-type-doc
     def _create_figures(
         self,
         x_values: np.ndarray,
         y_values: np.ndarray,
         y_sigmas: np.ndarray,
         series: np.ndarray,
-        fit_data: AnalysisResult,
-    ):
+        analysis_results: AnalysisResult,
+        axis: Optional["AxisSubplot"],
+    ) -> List["Figure"]:
         """Create new figures with the fit result and raw data.
 
-        Subclass can override this method to return figures.
+        Subclass can override this method to create different type of figures.
 
         Args:
             x_values: Full data set of x values.
             y_values: Full data set of y values.
             y_sigmas: Full data set of y sigmas.
             series: An integer array representing a mapping of data location to series index.
-            fit_data: Analysis result containing fit parameters.
+            analysis_results: Analysis result containing fit parameters.
+            axis: User provided axis to draw result.
 
         Returns:
             List of figures (format TBD).
         """
-        # TODO implement default figure. Will wait for Qiskit-terra #5499
-        return list()
+        if plotting and plotting.HAS_MATPLOTLIB:
+
+            if axis is None:
+                figure = plotting.plt.figure()
+                axis = figure.subplots(nrows=1, ncols=1)
+            else:
+                figure = axis.get_figure()
+
+            for series_def in self.__series__:
+                # filter subset data
+                xdata, ydata, sigma = self._subset_data(
+                    name=series_def.name,
+                    x_values=x_values,
+                    y_values=y_values,
+                    y_sigmas=y_sigmas,
+                    series=series,
+                )
+
+                # add fit line
+                plotting.plot_curve_fit(
+                    func=series_def.fit_func,
+                    result=analysis_results,
+                    ax=axis,
+                    color=series_def.plot_color,
+                    zorder=2,
+                )
+
+                # add error bars
+                plotting.plot_errorbar(
+                    xdata=xdata,
+                    ydata=ydata,
+                    sigma=sigma,
+                    ax=axis,
+                    label=series_def.name,
+                    marker=series_def.plot_symbol,
+                    color=series_def.plot_color,
+                    zorder=1,
+                )
+
+                # add raw scatter data points
+                plotting.plot_scatter(xdata=xdata, ydata=ydata, ax=axis, zorder=0)
+
+                # format axis
+                axis.legend()
+                axis.tick_params(labelsize=14)
+                axis.grid(True)
+
+            return [figure]
+        else:
+            return list()
 
     # pylint: disable = unused-argument
     def _setup_fitting(
@@ -582,7 +645,7 @@ def _run_analysis(
         # 5. Create figures
         #
         figures = self._create_figures(
-            x_values=xdata, y_values=ydata, y_sigmas=sigma, series=series, fit_data=analysis_result
+            x_values=xdata, y_values=ydata, y_sigmas=sigma, series=series, analysis_results=analysis_result
         )
 
         #
diff --git a/qiskit_experiments/analysis/plotting.py b/qiskit_experiments/analysis/plotting.py
index 1c13b8ff04..ae572da5c9 100644
--- a/qiskit_experiments/analysis/plotting.py
+++ b/qiskit_experiments/analysis/plotting.py
@@ -141,6 +141,8 @@ def plot_scatter(
         plot_opts["c"] = "grey"
     if "marker" not in plot_opts:
         plot_opts["marker"] = "x"
+    if "alpha" not in plot_opts:
+        plot_opts["alpha"] = 0.8
 
     # Plot data
     ax.scatter(xdata, ydata, **plot_opts)

From 656e8c77a6dd3b4d668d924b91abb63a20105951 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 18 May 2021 16:22:04 +0900
Subject: [PATCH 30/74] lint

---
 qiskit_experiments/analysis/curve_analysis.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 03e3fdbfb3..20f1eb0414 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -573,11 +573,13 @@ def _run_analysis(
         """
         analysis_result = AnalysisResult()
 
+        # pop arguments that are not given to fitter
+        data_processor = options.pop("data_processor", self.__default_data_processor__)
+        axis = options.pop("ax", None)
+
         #
         # 1. Setup data processor
         #
-        data_processor = options.pop("data_processor", self.__default_data_processor__)
-
         # TODO add ` and not data_processor.trained:`
         if isinstance(data_processor, DataProcessor):
             # Qiskit DataProcessor instance. May need calibration.
@@ -645,7 +647,12 @@ def _run_analysis(
         # 5. Create figures
         #
         figures = self._create_figures(
-            x_values=xdata, y_values=ydata, y_sigmas=sigma, series=series, analysis_results=analysis_result
+            x_values=xdata,
+            y_values=ydata,
+            y_sigmas=sigma,
+            series=series,
+            analysis_results=analysis_result,
+            axis=axis,
         )
 
         #

From 588b8fa42e18f7c46aae559c99be511f9802699f Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 18 May 2021 16:22:42 +0900
Subject: [PATCH 31/74] add default value

---
 qiskit_experiments/analysis/curve_analysis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 20f1eb0414..f260c1eae6 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -220,7 +220,7 @@ def _create_figures(
         y_sigmas: np.ndarray,
         series: np.ndarray,
         analysis_results: AnalysisResult,
-        axis: Optional["AxisSubplot"],
+        axis: Optional["AxisSubplot"] = None,
     ) -> List["Figure"]:
         """Create new figures with the fit result and raw data.
 

From bc6138575f9fdad209b9b4874c212b026228b1ad Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Wed, 19 May 2021 11:58:23 +0900
Subject: [PATCH 32/74] fix docstring typo

---
 qiskit_experiments/analysis/curve_analysis.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index f260c1eae6..17fb9ab520 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -120,7 +120,7 @@ class AnalysisExample(CurveAnalysis):
                             exponential_decay(x, amp=p0, lamb=p1, baseline=p3),
                         filter_kwargs={"experiment": 1},
                         plot_color="red",
-                        plot_symbpl="^",
+                        plot_symbol="^",
                     ),
                     SeriesDef(
                         name="my_experiment2",
@@ -128,7 +128,7 @@ class AnalysisExample(CurveAnalysis):
                             exponential_decay(x, amp=p0, lamb=p2, baseline=p3),
                         filter_kwargs={"experiment": 2},
                         plot_color="blue",
-                        plot_symbpl="o",
+                        plot_symbol="o",
                     ),
                 ]
 
@@ -160,7 +160,7 @@ class AnalysisExample(CurveAnalysis):
                             sin(x, amp=p0, freq=p1, phase=p2, baseline=p3),
                         filter_kwargs={"experiment": 2},
                         plot_color="blue",
-                        plot_symbpl="o",
+                        plot_symbol="o",
                     )
                 ]
 

From a68752904611d4be82fe50964f678988aa10ba4f Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 20 May 2021 05:12:12 +0900
Subject: [PATCH 33/74] remove outcome from default processing options

---
 qiskit_experiments/analysis/curve_analysis.py  | 4 ++--
 qiskit_experiments/analysis/data_processing.py | 6 +++++-
 test/analysis/test_curve_fit.py                | 1 +
 3 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 17fb9ab520..d7a6a32bfb 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -152,7 +152,7 @@ class AnalysisExample(CurveAnalysis):
                             cos(x, amp=p0, freq=p1, phase=p2, baseline=p3),
                         filter_kwargs={"experiment": 1},
                         plot_color="red",
-                        plot_symbpl="^",
+                        plot_symbol="^",
                     ),
                     SeriesDef(
                         name="my_experiment2",
@@ -202,7 +202,7 @@ class AnalysisExample(CurveAnalysis):
     __x_key__ = "xval"
 
     #: str: Metadata keys specifying data processing options.
-    __processing_options__ = ["outcome"]
+    __processing_options__ = []
 
     #: List[SeriesDef]: List of mapping representing a data series
     __series__ = None
diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index dafe630a8b..2b5ad09cbf 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -159,7 +159,7 @@ def multi_mean_xy_data(
     )
 
 
-def level2_probability(data: Dict[str, any], outcome: str) -> Tuple[float, float]:
+def level2_probability(data: Dict[str, any], outcome: str = None) -> Tuple[float, float]:
     """Return the outcome probability mean and variance.
 
     Args:
@@ -182,6 +182,10 @@ def level2_probability(data: Dict[str, any], outcome: str) -> Tuple[float, float
     # This crashes scipy fitter when it calculates covariance matrix (zero-div error).
 
     counts = data["counts"]
+
+    if outcome is None:
+        outcome = '1' * len(list(counts.keys())[0])
+
     shots = sum(counts.values())
     p_mean = counts.get(outcome, 0.0) / shots
     p_var = p_mean * (1 - p_mean) / shots
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index 459b322b37..a5fd0df091 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -66,6 +66,7 @@ class TestAnalysis(CurveAnalysis):
 
         __x_key__ = x_key
         __series__ = series
+        __processing_options__ = ["outcome"]
 
     return TestAnalysis()
 

From 39b4555a957ab4b1ede950bb2411c91ef4d034ea Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 20 May 2021 05:20:58 +0900
Subject: [PATCH 34/74] black and lint

---
 qiskit_experiments/analysis/curve_analysis.py  | 2 +-
 qiskit_experiments/analysis/data_processing.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index d7a6a32bfb..4e207643c6 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -240,7 +240,7 @@ def _create_figures(
         if plotting and plotting.HAS_MATPLOTLIB:
 
             if axis is None:
-                figure = plotting.plt.figure()
+                figure = plotting.pyplot.figure()
                 axis = figure.subplots(nrows=1, ncols=1)
             else:
                 figure = axis.get_figure()
diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index 2b5ad09cbf..fd97a4d271 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -184,7 +184,7 @@ def level2_probability(data: Dict[str, any], outcome: str = None) -> Tuple[float
     counts = data["counts"]
 
     if outcome is None:
-        outcome = '1' * len(list(counts.keys())[0])
+        outcome = "1" * len(list(counts.keys())[0])
 
     shots = sum(counts.values())
     p_mean = counts.get(outcome, 0.0) / shots

From 66c70c5d0ce079599eb2c5004512cc628f17307e Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 20 May 2021 05:22:17 +0900
Subject: [PATCH 35/74] add processor training check

---
 qiskit_experiments/analysis/curve_analysis.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 4e207643c6..848a1630df 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -580,8 +580,7 @@ def _run_analysis(
         #
         # 1. Setup data processor
         #
-        # TODO add ` and not data_processor.trained:`
-        if isinstance(data_processor, DataProcessor):
+        if isinstance(data_processor, DataProcessor) and not data_processor.is_trained:
             # Qiskit DataProcessor instance. May need calibration.
             try:
                 data_processor = self._calibrate_data_processor(

From 63704f42614893ab57215c99451bfc5de5aed3b0 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 20 May 2021 11:48:07 +0900
Subject: [PATCH 36/74] fix pre processing routine

---
 qiskit_experiments/analysis/curve_analysis.py | 68 ++++++++++---------
 1 file changed, 36 insertions(+), 32 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 848a1630df..113e2fbe63 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -246,25 +246,19 @@ def _create_figures(
                 figure = axis.get_figure()
 
             for series_def in self.__series__:
-                # filter subset data
-                xdata, ydata, sigma = self._subset_data(
-                    name=series_def.name,
-                    x_values=x_values,
-                    y_values=y_values,
-                    y_sigmas=y_sigmas,
-                    series=series,
-                )
 
-                # add fit line
-                plotting.plot_curve_fit(
-                    func=series_def.fit_func,
-                    result=analysis_results,
-                    ax=axis,
-                    color=series_def.plot_color,
-                    zorder=2,
+                # plot raw data
+
+                xdata, ydata, _ = self._subset_data(
+                    series_def.name, x_values, y_values, y_sigmas, series
                 )
+                plotting.plot_scatter(xdata=xdata, ydata=ydata, ax=axis, zorder=0)
 
-                # add error bars
+                # plot formatted data
+
+                xdata, ydata, sigma = self._subset_data(
+                    series_def.name, *self._pre_processing(x_values, y_values, y_sigmas, series)
+                )
                 plotting.plot_errorbar(
                     xdata=xdata,
                     ydata=ydata,
@@ -276,10 +270,18 @@ def _create_figures(
                     zorder=1,
                 )
 
-                # add raw scatter data points
-                plotting.plot_scatter(xdata=xdata, ydata=ydata, ax=axis, zorder=0)
+                # plot fit curve
+
+                plotting.plot_curve_fit(
+                    func=series_def.fit_func,
+                    result=analysis_results,
+                    ax=axis,
+                    color=series_def.plot_color,
+                    zorder=2,
+                )
 
                 # format axis
+
                 axis.legend()
                 axis.tick_params(labelsize=14)
                 axis.grid(True)
@@ -342,8 +344,8 @@ class attribute __default_data_processor__.
         return data_processor
 
     @staticmethod
-    def _data_pre_processing(
-        x_values: np.ndarray, y_values: np.ndarray, y_sigmas: np.ndarray
+    def _pre_processing(
+        x_values: np.ndarray, y_values: np.ndarray, y_sigmas: np.ndarray, series: np.ndarray
     ) -> Tuple[np.ndarray, ...]:
         """An optional subroutine to perform data pre-processing.
 
@@ -359,11 +361,12 @@ def _data_pre_processing(
             x_values: Numpy float array to represent X values.
             y_values: Numpy float array to represent Y values.
             y_sigmas: Numpy float array to represent Y errors.
+            series: Numpy integer array to represent mapping of data to series.
 
         Returns:
-            Numpy array tuple of pre-processed (x_values, y_values, y_sigmas).
+            Numpy array tuple of pre-processed (x_values, y_values, y_sigmas, series).
         """
-        return x_values, y_values, y_sigmas
+        return x_values, y_values, y_sigmas, series
 
     @staticmethod
     def _post_processing(analysis_result: AnalysisResult) -> AnalysisResult:
@@ -439,11 +442,9 @@ def _data_processing(datum):
         y_values, y_sigmas = zip(*map(_data_processing, data))
 
         # Format data
-        x_values, y_values, y_sigmas = self._data_pre_processing(
-            x_values=np.asarray(x_values, dtype=float),
-            y_values=np.asarray(y_values, dtype=float),
-            y_sigmas=np.asarray(y_sigmas, dtype=float),
-        )
+        x_values = np.asarray(x_values, dtype=float)
+        y_values = np.asarray(y_values, dtype=float)
+        y_sigmas = np.asarray(y_sigmas, dtype=float)
 
         # Find series (invalid data is labeled as -1)
         series = -1 * np.ones(x_values.size, dtype=int)
@@ -611,18 +612,21 @@ def _run_analysis(
         #
         # pylint: disable=broad-except
         try:
+            # format fit data
+            _xdata, _ydata, _sigma, _series = self._pre_processing(xdata, ydata, sigma, series)
+
             # Generate fit options
             fit_options_candidates = [
                 self._format_fit_options(fit_options)
-                for fit_options in self._setup_fitting(xdata, ydata, sigma, series, **options)
+                for fit_options in self._setup_fitting(_xdata, _ydata, _sigma, _series, **options)
             ]
             fit_results = [
                 self.__base_fitter__.__func__(
                     funcs=[series_def.fit_func for series_def in self.__series__],
-                    series=series,
-                    xdata=xdata,
-                    ydata=ydata,
-                    sigma=sigma,
+                    series=_series,
+                    xdata=_xdata,
+                    ydata=_ydata,
+                    sigma=_sigma,
                     **fit_options,
                 )
                 for fit_options in fit_options_candidates

From 0d477fd666b53530d32e0bb0ac6c1ab094792601 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Sun, 23 May 2021 15:05:22 +0900
Subject: [PATCH 37/74] update rb analysis as an example - add num_qubits to
 curve analysis - add label generation to curve analysis

---
 qiskit_experiments/analysis/curve_analysis.py |  66 ++++++-
 .../analysis/data_processing.py               |   2 +-
 .../randomized_benchmarking/rb_analysis.py    | 165 ++++++------------
 3 files changed, 118 insertions(+), 115 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 113e2fbe63..70325a47c3 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -22,13 +22,13 @@
 import numpy as np
 from qiskit.exceptions import QiskitError
 
+from qiskit_experiments.analysis import plotting
 from qiskit_experiments.analysis.curve_fitting import multi_curve_fit
 from qiskit_experiments.analysis.data_processing import level2_probability
 from qiskit_experiments.base_analysis import BaseAnalysis
 from qiskit_experiments.data_processing import DataProcessor
 from qiskit_experiments.data_processing.exceptions import DataProcessorError
 from qiskit_experiments.experiment_data import AnalysisResult, ExperimentData
-from qiskit_experiments.analysis import plotting
 
 
 @dataclasses.dataclass
@@ -75,6 +75,8 @@ class CurveAnalysis(BaseAnalysis):
             See the Examples below for more details.
         __base_fitter__: A callable to perform curve fitting.
         __default_data_processor__: A callable to format y, y error data.
+        __plot_labels__: Dict of parameter names and its representation shows in the
+            result figure as an analysis report.
 
 
     Examples:
@@ -84,6 +86,8 @@ class CurveAnalysis(BaseAnalysis):
 
         In this type of experiment, the analysis deals with a single curve.
         Thus filter_kwargs is not necessary defined.
+        In this example, fit value and error of the parameter ``lamb`` labeled by
+        a Greek lambda symbol are written  in the figure.
 
         .. code-block::
 
@@ -99,6 +103,8 @@ class AnalysisExample(CurveAnalysis):
                     ),
                 ]
 
+                __plot_labels__ = {"lamb": "\u03BB"}
+
 
         A fitting for two exponential decay curve with partly shared parameter
         ======================================================================
@@ -132,6 +138,8 @@ class AnalysisExample(CurveAnalysis):
                     ),
                 ]
 
+                __plot_labels__ = {"lamb": "\u03BB"}
+
 
         A fitting for two trigonometric curves with the same parameter
         =============================================================
@@ -164,6 +172,8 @@ class AnalysisExample(CurveAnalysis):
                     )
                 ]
 
+                __plot_labels__ = {"lamb": "\u03BB"}
+
 
     Notes:
         This CurveAnalysis class provides several private methods that subclasses can override.
@@ -213,6 +223,13 @@ class AnalysisExample(CurveAnalysis):
     #: Union[Callable, DataProcessor]: Data processor to format experiment data.
     __default_data_processor__ = level2_probability
 
+    #: Dict[str, str]: Mapping of fit parameters and representation in the figure label.
+    __plot_labels__ = None
+
+    def __init__(self):
+        """Provide the fields that are commonly used by the experiment analysis."""
+        self.num_qubits = None
+
     def _create_figures(
         self,
         x_values: np.ndarray,
@@ -221,6 +238,7 @@ def _create_figures(
         series: np.ndarray,
         analysis_results: AnalysisResult,
         axis: Optional["AxisSubplot"] = None,
+        add_label: bool = True,
     ) -> List["Figure"]:
         """Create new figures with the fit result and raw data.
 
@@ -233,9 +251,10 @@ def _create_figures(
             series: An integer array representing a mapping of data location to series index.
             analysis_results: Analysis result containing fit parameters.
             axis: User provided axis to draw result.
+            add_label: Set ``True`` to add analysis result label.
 
         Returns:
-            List of figures (format TBD).
+            List of figures.
         """
         if plotting and plotting.HAS_MATPLOTLIB:
 
@@ -282,10 +301,39 @@ def _create_figures(
 
                 # format axis
 
-                axis.legend()
+                if len(self.__series__) > 1:
+                    axis.legend()
                 axis.tick_params(labelsize=14)
                 axis.grid(True)
 
+            # write analysis report
+
+            if add_label:
+                # write fit status in the plot
+                analysis_description = "Analysis Reports:\n"
+                for par_name, label in self.__plot_labels__.items():
+                    try:
+                        # fit value
+                        pind = analysis_results["popt_keys"].index(par_name)
+                        pval = analysis_results["popt"][pind]
+                        perr = analysis_results["popt_err"][pind]
+                    except ValueError:
+                        # maybe post processed value
+                        pval = analysis_results[par_name]
+                        perr = analysis_results[f"{par_name}_err"]
+                    analysis_description += f"  \u25B7 {label} = {pval: .4f} \u00B1 {perr: .4f}\n"
+                chisq = analysis_results["reduced_chisq"]
+                analysis_description += f"Fit \u03C7-squared = {chisq}"
+
+                axis.text(
+                    axis.get_xlim()[0],
+                    axis.get_ylim()[1],
+                    text=analysis_description,
+                    ha="left",
+                    va="bottom",
+                    size=12,
+                )
+
             return [figure]
         else:
             return list()
@@ -343,9 +391,8 @@ class attribute __default_data_processor__.
         """
         return data_processor
 
-    @staticmethod
     def _pre_processing(
-        x_values: np.ndarray, y_values: np.ndarray, y_sigmas: np.ndarray, series: np.ndarray
+        self, x_values: np.ndarray, y_values: np.ndarray, y_sigmas: np.ndarray, series: np.ndarray
     ) -> Tuple[np.ndarray, ...]:
         """An optional subroutine to perform data pre-processing.
 
@@ -368,8 +415,7 @@ def _pre_processing(
         """
         return x_values, y_values, y_sigmas, series
 
-    @staticmethod
-    def _post_processing(analysis_result: AnalysisResult) -> AnalysisResult:
+    def _post_processing(self, analysis_result: AnalysisResult) -> AnalysisResult:
         """Calculate new quantity from the fit result.
 
         Subclasses can override this method to do post analysis.
@@ -577,6 +623,11 @@ def _run_analysis(
         # pop arguments that are not given to fitter
         data_processor = options.pop("data_processor", self.__default_data_processor__)
         axis = options.pop("ax", None)
+        add_label = options.pop("add_label", True)
+
+        # Get common fields
+        # TODO use experiment level metadata once implemented
+        self.num_qubits = len(data.data(0)["metadata"]["qubits"])
 
         #
         # 1. Setup data processor
@@ -656,6 +707,7 @@ def _run_analysis(
             series=series,
             analysis_results=analysis_result,
             axis=axis,
+            add_label=add_label,
         )
 
         #
diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index fd97a4d271..72f356d082 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -48,7 +48,7 @@ def filter_data(data: List[Dict[str, any]], **filters) -> List[Dict[str, any]]:
 
 def mean_xy_data(
     xdata: np.ndarray, ydata: np.ndarray, sigma: Optional[np.ndarray] = None, method: str = "sample"
-) -> Tuple[np.ndarray]:
+) -> Tuple[np.ndarray, ...]:
     r"""Return (x, y_mean, sigma) data.
 
     The mean is taken over all ydata values with the same xdata value using
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index ccf6d5c173..ed27edc104 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -13,124 +13,75 @@
 Standard RB analysis class.
 """
 
-from typing import Optional, List
+from typing import List, Tuple
 
-from qiskit_experiments.base_analysis import BaseAnalysis
-from qiskit_experiments.analysis.curve_fitting import curve_fit, process_curve_data
+import numpy as np
+
+from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, FitOptions, exponential_decay
 from qiskit_experiments.analysis.data_processing import (
-    level2_probability,
     mean_xy_data,
 )
-from qiskit_experiments.analysis.plotting import (
-    HAS_MATPLOTLIB,
-    plot_curve_fit,
-    plot_scatter,
-    plot_errorbar,
-)
+from qiskit_experiments.experiment_data import AnalysisResult
 
 
-class RBAnalysis(BaseAnalysis):
+class RBAnalysis(CurveAnalysis):
     """RB Analysis class."""
 
-    # pylint: disable = arguments-differ, invalid-name
-    def _run_analysis(
+    __x_key__ = "xdata"
+
+    __series__ = [
+        SeriesDef(
+            name="RB curve",
+            fit_func=lambda x, a, alpha, b: exponential_decay(
+                x, amp=a, lamb=-1.0, base=alpha, baseline=b
+            ),
+            plot_color="blue",
+        )
+    ]
+
+    __plot_labels__ = {"alpha": "\u03B1", "EPC": "EPC"}
+
+    def _setup_fitting(
         self,
-        experiment_data: "ExperimentData",
-        p0: Optional[List[float]] = None,
-        plot: bool = True,
-        ax: Optional["AxesSubplot"] = None,
-    ):
-        """Run analysis on circuit data.
-        Args:
-            experiment_data: the experiment data to analyze.
-            p0: Optional, initial parameter values for curve_fit.
-            plot: If True generate a plot of fitted data.
-            ax: Optional, matplotlib axis to add plot to.
-        Returns:
-            tuple: A pair ``(analysis_result, figures)`` where
-                   ``analysis_results`` may be a single or list of
-                   AnalysisResult objects, and ``figures`` may be
-                   None, a single figure, or a list of figures.
-        """
-        data = experiment_data.data()
-        num_qubits = len(data[0]["metadata"]["qubits"])
-
-        # Process data
-        def data_processor(datum):
-            return level2_probability(datum, num_qubits * "0")
-
-        # Raw data for each sample
-        x_raw, y_raw, sigma_raw = process_curve_data(data, data_processor, x_key="xdata")
-
-        # Data averaged over samples
-        xdata, ydata, ydata_sigma = mean_xy_data(x_raw, y_raw, sigma_raw, method="sample")
-
-        # Perform fit
-        def fit_fun(x, a, alpha, b):
-            return a * alpha ** x + b
-
-        p0 = self._p0(xdata, ydata, num_qubits)
-        bounds = {"a": [0, 1], "alpha": [0, 1], "b": [0, 1]}
-        analysis_result = curve_fit(fit_fun, xdata, ydata, p0, ydata_sigma, bounds=bounds)
-
-        # Add EPC data
-        popt = analysis_result["popt"]
-        popt_err = analysis_result["popt_err"]
-        scale = (2 ** num_qubits - 1) / (2 ** num_qubits)
-        analysis_result["EPC"] = scale * (1 - popt[1])
-        analysis_result["EPC_err"] = scale * popt_err[1] / popt[1]
-
-        if plot and HAS_MATPLOTLIB:
-            ax = plot_curve_fit(fit_fun, analysis_result, ax=ax)
-            ax = plot_scatter(x_raw, y_raw, ax=ax)
-            ax = plot_errorbar(xdata, ydata, ydata_sigma, ax=ax)
-            self._format_plot(ax, analysis_result)
-            figures = [ax.get_figure()]
-        else:
-            figures = None
-        return analysis_result, figures
-
-    @staticmethod
-    def _p0(xdata, ydata, num_qubits):
-        """Initial guess for the fitting function"""
-        fit_guess = {"a": 0.95, "alpha": 0.99, "b": 1 / 2 ** num_qubits}
+        x_values: np.ndarray,
+        y_values: np.ndarray,
+        y_sigmas: np.ndarray,
+        series: np.ndarray,
+        **options,
+    ) -> List[FitOptions]:
+        """Fitter options."""
+        fit_guess = {"a": 0.95, "alpha": 0.99, "b": 1 / 2 ** self.num_qubits}
+
         # Use the first two points to guess the decay param
-        dcliff = xdata[1] - xdata[0]
-        dy = (ydata[1] - fit_guess["b"]) / (ydata[0] - fit_guess["b"])
+        dcliff = x_values[1] - x_values[0]
+        dy = (y_values[1] - fit_guess["b"]) / (y_values[0] - fit_guess["b"])
         alpha_guess = dy ** (1 / dcliff)
+
         if alpha_guess < 1.0:
             fit_guess["alpha"] = alpha_guess
 
-        if ydata[0] > fit_guess["b"]:
-            fit_guess["a"] = (ydata[0] - fit_guess["b"]) / fit_guess["alpha"] ** xdata[0]
-
-        return fit_guess
-
-    @classmethod
-    def _format_plot(cls, ax, analysis_result, add_label=True):
-        """Format curve fit plot"""
-        # Formatting
-        ax.tick_params(labelsize=14)
-        ax.set_xlabel("Clifford Length", fontsize=16)
-        ax.set_ylabel("Ground State Population", fontsize=16)
-        ax.grid(True)
-
-        if add_label:
-            alpha = analysis_result["popt"][1]
-            alpha_err = analysis_result["popt_err"][1]
-            epc = analysis_result["EPC"]
-            epc_err = analysis_result["EPC_err"]
-            box_text = "\u03B1:{:.4f} \u00B1 {:.4f}".format(alpha, alpha_err)
-            box_text += "\nEPC: {:.4f} \u00B1 {:.4f}".format(epc, epc_err)
-            bbox_props = dict(boxstyle="square,pad=0.3", fc="white", ec="black", lw=1)
-            ax.text(
-                0.6,
-                0.9,
-                box_text,
-                ha="center",
-                va="center",
-                size=14,
-                bbox=bbox_props,
-                transform=ax.transAxes,
-            )
-        return ax
+        if y_values[0] > fit_guess["b"]:
+            fit_guess["a"] = (y_values[0] - fit_guess["b"]) / fit_guess["alpha"] ** x_values[0]
+
+        fit_options = [
+            FitOptions(p0=fit_guess, bounds={"a": [0.0, 1.0], "alpha": [0.0, 1.0], "b": [0.0, 1.0]})
+        ]
+        return fit_options
+
+    def _pre_processing(
+        self, x_values: np.ndarray, y_values: np.ndarray, y_sigmas: np.ndarray, series: np.ndarray
+    ) -> Tuple[np.ndarray, ...]:
+        """Average over the same x values."""
+        xdata, ydata, sigma = mean_xy_data(x_values, y_values, y_sigmas, method="sample")
+        return xdata, ydata, sigma, series
+
+    def _post_processing(self, analysis_result: AnalysisResult) -> AnalysisResult:
+        """Calculate EPC."""
+        alpha = analysis_result["popt"][1]
+        alpha_err = analysis_result["popt_err"][1]
+
+        scale = (2 ** self.num_qubits - 1) / (2 ** self.num_qubits)
+        analysis_result["EPC"] = scale * (1 - alpha)
+        analysis_result["EPC_err"] = scale * alpha_err / alpha
+
+        return analysis_result

From e7e85e2cf6ec1eb5b78c4d99ffd05b947256bbd9 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Sun, 23 May 2021 16:56:10 +0900
Subject: [PATCH 38/74] post process error handling when fit failed

---
 qiskit_experiments/analysis/curve_analysis.py | 58 +++++++++----------
 qiskit_experiments/experiment_data.py         |  2 +
 .../randomized_benchmarking/rb_analysis.py    | 11 ++--
 3 files changed, 37 insertions(+), 34 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 70325a47c3..3d6bbdf08b 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -57,8 +57,6 @@ class CurveAnalysis(BaseAnalysis):
 
         __x_key__: Key in the circuit metadata under which to find the value for
             the horizontal axis.
-        __processing_options__: Circuit metadata keys that are passed to the data processor.
-            The key should conform to the data processor API.
         __series__: A set of data points that will be fit to a the same parameters
             in the fit function. If this analysis contains multiple curves,
             the same number of series definitions should be listed.
@@ -211,9 +209,6 @@ class AnalysisExample(CurveAnalysis):
     #: str: Metadata key representing a scanned value.
     __x_key__ = "xval"
 
-    #: str: Metadata keys specifying data processing options.
-    __processing_options__ = []
-
     #: List[SeriesDef]: List of mapping representing a data series
     __series__ = None
 
@@ -291,13 +286,14 @@ def _create_figures(
 
                 # plot fit curve
 
-                plotting.plot_curve_fit(
-                    func=series_def.fit_func,
-                    result=analysis_results,
-                    ax=axis,
-                    color=series_def.plot_color,
-                    zorder=2,
-                )
+                if analysis_results["success"]:
+                    plotting.plot_curve_fit(
+                        func=series_def.fit_func,
+                        result=analysis_results,
+                        ax=axis,
+                        color=series_def.plot_color,
+                        zorder=2,
+                    )
 
                 # format axis
 
@@ -308,7 +304,7 @@ def _create_figures(
 
             # write analysis report
 
-            if add_label:
+            if add_label and analysis_results["success"]:
                 # write fit status in the plot
                 analysis_description = "Analysis Reports:\n"
                 for par_name, label in self.__plot_labels__.items():
@@ -323,12 +319,12 @@ def _create_figures(
                         perr = analysis_results[f"{par_name}_err"]
                     analysis_description += f"  \u25B7 {label} = {pval: .4f} \u00B1 {perr: .4f}\n"
                 chisq = analysis_results["reduced_chisq"]
-                analysis_description += f"Fit \u03C7-squared = {chisq}"
+                analysis_description += f"Fit \u03C7-squared = {chisq: .4f}"
 
                 axis.text(
                     axis.get_xlim()[0],
                     axis.get_ylim()[1],
-                    text=analysis_description,
+                    analysis_description,
                     ha="left",
                     va="bottom",
                     size=12,
@@ -391,6 +387,18 @@ class attribute __default_data_processor__.
         """
         return data_processor
 
+    # pylint: disable = unused-argument
+    def _data_processor_options(self, metadata: Dict[str, Any]) -> Dict[str, Any]:
+        """Create callback options passed to the data processor.
+
+        Args:
+            metadata: Metadata attached to the circuit result to process.
+
+        Returns:
+            Options passed to the processor callback. This should conform to the API.
+        """
+        return dict()
+
     def _pre_processing(
         self, x_values: np.ndarray, y_values: np.ndarray, y_sigmas: np.ndarray, series: np.ndarray
     ) -> Tuple[np.ndarray, ...]:
@@ -454,8 +462,6 @@ def _extract_curves(
         Raises:
             QiskitError:
                 - When __x_key__ is not defined in the circuit metadata.
-            KeyError:
-                - When circuit metadata doesn't provide required data processor options.
         """
 
         def _is_target_series(datum, **filters):
@@ -474,18 +480,11 @@ def _is_target_series(datum, **filters):
                 f"X value key {self.__x_key__} is not defined in circuit metadata."
             ) from ex
 
-        def _data_processing(datum):
-            # A helper function to receive data processor runtime option from metadata
-            try:
-                # Extract data processor options
-                dp_options = {key: datum["metadata"][key] for key in self.__processing_options__}
-            except KeyError as ex:
-                raise KeyError(
-                    "Required data processor options are not provided by circuit metadata."
-                ) from ex
-            return data_processor(datum, **dp_options)
+        def configured_data_processor(datum):
+            options = self._data_processor_options(datum["metadata"])
+            return data_processor(datum, **options)
 
-        y_values, y_sigmas = zip(*map(_data_processing, data))
+        y_values, y_sigmas = zip(*map(configured_data_processor, data))
 
         # Format data
         x_values = np.asarray(x_values, dtype=float)
@@ -695,7 +694,8 @@ def _run_analysis(
         #
         # 4. Post-process analysis data
         #
-        analysis_result = self._post_processing(analysis_result)
+        if analysis_result["success"]:
+            analysis_result = self._post_processing(analysis_result)
 
         #
         # 5. Create figures
diff --git a/qiskit_experiments/experiment_data.py b/qiskit_experiments/experiment_data.py
index 13580fffde..95cc7f16d0 100644
--- a/qiskit_experiments/experiment_data.py
+++ b/qiskit_experiments/experiment_data.py
@@ -364,5 +364,7 @@ def __str__(self):
         if n_res:
             ret += "\nLast Analysis Result"
             for key, value in self._analysis_results[-1].items():
+                if key in ("raw_data", "pcov"):
+                    continue
                 ret += f"\n- {key}: {value}"
         return ret
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index ed27edc104..69f17d2853 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -13,7 +13,7 @@
 Standard RB analysis class.
 """
 
-from typing import List, Tuple
+from typing import List, Tuple, Dict, Any
 
 import numpy as np
 
@@ -26,9 +26,6 @@
 
 class RBAnalysis(CurveAnalysis):
     """RB Analysis class."""
-
-    __x_key__ = "xdata"
-
     __series__ = [
         SeriesDef(
             name="RB curve",
@@ -68,12 +65,16 @@ def _setup_fitting(
         ]
         return fit_options
 
+    def _data_processor_options(self, metadata: Dict[str, Any]) -> Dict[str, Any]:
+        """Set outcome label."""
+        return {"outcome": "0" * len(metadata["qubits"])}
+
     def _pre_processing(
         self, x_values: np.ndarray, y_values: np.ndarray, y_sigmas: np.ndarray, series: np.ndarray
     ) -> Tuple[np.ndarray, ...]:
         """Average over the same x values."""
         xdata, ydata, sigma = mean_xy_data(x_values, y_values, y_sigmas, method="sample")
-        return xdata, ydata, sigma, series
+        return xdata, ydata, sigma, np.zeros(len(xdata))
 
     def _post_processing(self, analysis_result: AnalysisResult) -> AnalysisResult:
         """Calculate EPC."""

From b6975e3fb85e61cf0bab606ca62cd199eef4d13f Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Sun, 23 May 2021 17:24:12 +0900
Subject: [PATCH 39/74] add axis label

---
 qiskit_experiments/analysis/curve_analysis.py  | 18 +++++++++++++++++-
 .../randomized_benchmarking/rb_analysis.py     |  6 +++++-
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 3d6bbdf08b..b831cd4758 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -75,6 +75,8 @@ class CurveAnalysis(BaseAnalysis):
         __default_data_processor__: A callable to format y, y error data.
         __plot_labels__: Dict of parameter names and its representation shows in the
             result figure as an analysis report.
+        __plot_xlabel__: Label of x axis of result plot.
+        __plot_ylabel__: Label of y axis of result plot.
 
 
     Examples:
@@ -221,6 +223,12 @@ class AnalysisExample(CurveAnalysis):
     #: Dict[str, str]: Mapping of fit parameters and representation in the figure label.
     __plot_labels__ = None
 
+    #: str: X axis label
+    __plot_xlabel__ = "x value"
+
+    #: str: Y axis label
+    __plot_ylabel__ = "y value"
+
     def __init__(self):
         """Provide the fields that are commonly used by the experiment analysis."""
         self.num_qubits = None
@@ -259,6 +267,9 @@ def _create_figures(
             else:
                 figure = axis.get_figure()
 
+            axis.set_xlabel(self.__plot_xlabel__, fontsize=16)
+            axis.set_ylabel(self.__plot_ylabel__, fontsize=16)
+
             for series_def in self.__series__:
 
                 # plot raw data
@@ -266,7 +277,12 @@ def _create_figures(
                 xdata, ydata, _ = self._subset_data(
                     series_def.name, x_values, y_values, y_sigmas, series
                 )
-                plotting.plot_scatter(xdata=xdata, ydata=ydata, ax=axis, zorder=0)
+                plotting.plot_scatter(
+                    xdata=xdata,
+                    ydata=ydata,
+                    ax=axis,
+                    zorder=0
+                )
 
                 # plot formatted data
 
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index 69f17d2853..4fd6774d3d 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -13,7 +13,7 @@
 Standard RB analysis class.
 """
 
-from typing import List, Tuple, Dict, Any
+from typing import List, Tuple, Dict, Any, Optional
 
 import numpy as np
 
@@ -38,6 +38,10 @@ class RBAnalysis(CurveAnalysis):
 
     __plot_labels__ = {"alpha": "\u03B1", "EPC": "EPC"}
 
+    __plot_xlabel__ = "Clifford Length"
+
+    __plot_ylabel__ = "P(0)"
+
     def _setup_fitting(
         self,
         x_values: np.ndarray,

From 97a0f919efbaacfb2c24f93c5d696e579fdc2175 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Sun, 23 May 2021 17:29:56 +0900
Subject: [PATCH 40/74] update axis formatting

---
 qiskit_experiments/analysis/curve_analysis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index b831cd4758..d9e349594b 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -333,7 +333,7 @@ def _create_figures(
                         # maybe post processed value
                         pval = analysis_results[par_name]
                         perr = analysis_results[f"{par_name}_err"]
-                    analysis_description += f"  \u25B7 {label} = {pval: .4f} \u00B1 {perr: .4f}\n"
+                    analysis_description += f"  \u25B7 {label} = {pval: .3e} \u00B1 {perr: .3e}\n"
                 chisq = analysis_results["reduced_chisq"]
                 analysis_description += f"Fit \u03C7-squared = {chisq: .4f}"
 

From 076d535de80eae43fc4f278a4e07c51d5e1ae104 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 27 May 2021 17:18:52 +0900
Subject: [PATCH 41/74] more integration with new options

---
 qiskit_experiments/analysis/__init__.py       |   2 +-
 qiskit_experiments/analysis/curve_analysis.py | 235 ++++++++----------
 .../randomized_benchmarking/rb_analysis.py    |  48 ++--
 .../randomized_benchmarking/rb_experiment.py  |   1 +
 test/analysis/test_curve_fit.py               |  84 ++++---
 5 files changed, 181 insertions(+), 189 deletions(-)

diff --git a/qiskit_experiments/analysis/__init__.py b/qiskit_experiments/analysis/__init__.py
index fc37892977..9ae6b5fec3 100644
--- a/qiskit_experiments/analysis/__init__.py
+++ b/qiskit_experiments/analysis/__init__.py
@@ -50,7 +50,7 @@
     sin
 
 """
-from .curve_analysis import CurveAnalysis, SeriesDef, FitOptions
+from .curve_analysis import CurveAnalysis, SeriesDef
 
 # fit functions (alphabetical import ordering)
 from .fit_functions import (
diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index d9e349594b..dfb4354645 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -16,11 +16,13 @@
 # pylint: disable=invalid-name
 
 import dataclasses
+import functools
 import inspect
 from typing import Any, Dict, List, Tuple, Callable, Union, Optional
 
 import numpy as np
 from qiskit.exceptions import QiskitError
+from qiskit.providers.options import Options
 
 from qiskit_experiments.analysis import plotting
 from qiskit_experiments.analysis.curve_fitting import multi_curve_fit
@@ -31,7 +33,7 @@
 from qiskit_experiments.experiment_data import AnalysisResult, ExperimentData
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(frozen=True)
 class SeriesDef:
     """Description of curve."""
 
@@ -42,10 +44,6 @@ class SeriesDef:
     plot_symbol: str = "o"
 
 
-class FitOptions(dict):
-    """Fit options passed to the fitter function."""
-
-
 class CurveAnalysis(BaseAnalysis):
     """A base class for curve fit type analysis.
 
@@ -71,9 +69,7 @@ class CurveAnalysis(BaseAnalysis):
                 plot_symbol: String formatter of the scatter of this series in the plot.
 
             See the Examples below for more details.
-        __base_fitter__: A callable to perform curve fitting.
-        __default_data_processor__: A callable to format y, y error data.
-        __plot_labels__: Dict of parameter names and its representation shows in the
+        __fit_label_desc__: Dict of parameter names and its representation shows in the
             result figure as an analysis report.
         __plot_xlabel__: Label of x axis of result plot.
         __plot_ylabel__: Label of y axis of result plot.
@@ -214,14 +210,8 @@ class AnalysisExample(CurveAnalysis):
     #: List[SeriesDef]: List of mapping representing a data series
     __series__ = None
 
-    #: Callable: Default curve fitter. This can be overwritten.
-    __base_fitter__ = multi_curve_fit
-
-    #: Union[Callable, DataProcessor]: Data processor to format experiment data.
-    __default_data_processor__ = level2_probability
-
     #: Dict[str, str]: Mapping of fit parameters and representation in the figure label.
-    __plot_labels__ = None
+    __fit_label_desc__ = None
 
     #: str: X axis label
     __plot_xlabel__ = "x value"
@@ -229,9 +219,24 @@ class AnalysisExample(CurveAnalysis):
     #: str: Y axis label
     __plot_ylabel__ = "y value"
 
-    def __init__(self):
-        """Provide the fields that are commonly used by the experiment analysis."""
-        self.num_qubits = None
+    @classmethod
+    def _default_options(cls):
+        """Return default data processing options.
+
+        Options:
+            plot: Set ``True`` to create figure for fit result.
+            add_label: Set ``True`` to write fit report in the figure.
+            ax: Optional. A matplotlib axis object to draw.
+            base_fitter: A callback function to perform fitting with formatted data.
+            data_processor: A callback function to format experiment data.
+        """
+        return Options(
+            plot=True,
+            add_label=True,
+            ax=None,
+            base_fitter=multi_curve_fit,
+            data_processor=level2_probability,
+        )
 
     def _create_figures(
         self,
@@ -259,7 +264,7 @@ def _create_figures(
         Returns:
             List of figures.
         """
-        if plotting and plotting.HAS_MATPLOTLIB:
+        if plotting.HAS_MATPLOTLIB:
 
             if axis is None:
                 figure = plotting.pyplot.figure()
@@ -277,12 +282,7 @@ def _create_figures(
                 xdata, ydata, _ = self._subset_data(
                     series_def.name, x_values, y_values, y_sigmas, series
                 )
-                plotting.plot_scatter(
-                    xdata=xdata,
-                    ydata=ydata,
-                    ax=axis,
-                    zorder=0
-                )
+                plotting.plot_scatter(xdata=xdata, ydata=ydata, ax=axis, zorder=0)
 
                 # plot formatted data
 
@@ -323,7 +323,7 @@ def _create_figures(
             if add_label and analysis_results["success"]:
                 # write fit status in the plot
                 analysis_description = "Analysis Reports:\n"
-                for par_name, label in self.__plot_labels__.items():
+                for par_name, label in self.__fit_label_desc__.items():
                     try:
                         # fit value
                         pind = analysis_results["popt_keys"].index(par_name)
@@ -358,7 +358,7 @@ def _setup_fitting(
         y_sigmas: np.ndarray,
         series: np.ndarray,
         **options,
-    ) -> List[FitOptions]:
+    ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
         """An analysis subroutine that is called to set fitter options.
 
         This subroutine takes full data array and user-input fit options.
@@ -379,44 +379,15 @@ def _setup_fitting(
         Returns:
             List of FitOptions that are passed to fitter function.
         """
-        fit_options = FitOptions(**options)
-
-        return [fit_options]
-
-    # pylint: disable = unused-argument
-    @staticmethod
-    def _calibrate_data_processor(
-        data_processor: DataProcessor, experiment_data: ExperimentData
-    ) -> DataProcessor:
-        """An optional subroutine to perform data processor calibration.
-
-        Subclass can override this method to calibrate data processor instance.
-        This routine is called only when a DataProcessor instance is specified in the
-        class attribute __default_data_processor__.
-
-        Args:
-            data_processor: Data processor instance to calibrate.
-            experiment_data: Unfiltered experiment data set.
-
-        Returns:
-            Calibrated data processor instance.
-        """
-        return data_processor
-
-    # pylint: disable = unused-argument
-    def _data_processor_options(self, metadata: Dict[str, Any]) -> Dict[str, Any]:
-        """Create callback options passed to the data processor.
-
-        Args:
-            metadata: Metadata attached to the circuit result to process.
-
-        Returns:
-            Options passed to the processor callback. This should conform to the API.
-        """
-        return dict()
+        return options
 
     def _pre_processing(
-        self, x_values: np.ndarray, y_values: np.ndarray, y_sigmas: np.ndarray, series: np.ndarray
+        self,
+        x_values: np.ndarray,
+        y_values: np.ndarray,
+        y_sigmas: np.ndarray,
+        series: np.ndarray,
+        **options,
     ) -> Tuple[np.ndarray, ...]:
         """An optional subroutine to perform data pre-processing.
 
@@ -433,19 +404,21 @@ def _pre_processing(
             y_values: Numpy float array to represent Y values.
             y_sigmas: Numpy float array to represent Y errors.
             series: Numpy integer array to represent mapping of data to series.
+            options: Analysis options.
 
         Returns:
             Numpy array tuple of pre-processed (x_values, y_values, y_sigmas, series).
         """
         return x_values, y_values, y_sigmas, series
 
-    def _post_processing(self, analysis_result: AnalysisResult) -> AnalysisResult:
+    def _post_processing(self, analysis_result: AnalysisResult, **options) -> AnalysisResult:
         """Calculate new quantity from the fit result.
 
         Subclasses can override this method to do post analysis.
 
         Args:
             analysis_result: Analysis result containing fit result.
+            options: Analysis options.
 
         Returns:
             New AnalysisResult instance containing the result of post analysis.
@@ -496,11 +469,7 @@ def _is_target_series(datum, **filters):
                 f"X value key {self.__x_key__} is not defined in circuit metadata."
             ) from ex
 
-        def configured_data_processor(datum):
-            options = self._data_processor_options(datum["metadata"])
-            return data_processor(datum, **options)
-
-        y_values, y_sigmas = zip(*map(configured_data_processor, data))
+        y_values, y_sigmas = zip(*map(data_processor, data))
 
         # Format data
         x_values = np.asarray(x_values, dtype=float)
@@ -517,11 +486,11 @@ def configured_data_processor(datum):
 
         return x_values, y_values, y_sigmas, series
 
-    def _format_fit_options(self, options: FitOptions) -> FitOptions:
+    def _format_fit_options(self, **fitter_options) -> Dict[str, Any]:
         """Format fitting option args to dictionary of parameter names.
 
         Args:
-            options: Generated fit options without tested.
+            fitter_options: Fit options generated by `self._setup_fitting`.
 
         Returns:
             Formatted fit options.
@@ -549,7 +518,7 @@ def _format_fit_options(self, options: FitOptions) -> FitOptions:
 
         # Validate dictionaly keys
         def _check_keys(parameter_name):
-            named_values = options[parameter_name]
+            named_values = fitter_options[parameter_name]
             if not named_values.keys() == set(fit_params):
                 raise KeyError(
                     f"Fitting option {parameter_name} doesn't have the "
@@ -558,7 +527,7 @@ def _check_keys(parameter_name):
 
         # Convert array into dictionary
         def _dictionarize(parameter_name):
-            parameter_array = options[parameter_name]
+            parameter_array = fitter_options[parameter_name]
             if len(parameter_array) != len(fit_params):
                 raise ValueError(
                     f"Value length of fitting option {parameter_name} doesn't "
@@ -567,23 +536,23 @@ def _dictionarize(parameter_name):
                 )
             return dict(zip(fit_params, parameter_array))
 
-        if "p0" in options:
-            if isinstance(options["p0"], dict):
+        if "p0" in fitter_options:
+            if isinstance(fitter_options["p0"], dict):
                 _check_keys("p0")
             else:
-                options["p0"] = _dictionarize("p0")
+                fitter_options["p0"] = _dictionarize("p0")
         else:
             raise KeyError("Initial guess p0 is not provided to the fitting options.")
 
-        if "bounds" in options:
-            if isinstance(options["bounds"], dict):
+        if "bounds" in fitter_options:
+            if isinstance(fitter_options["bounds"], dict):
                 _check_keys("bounds")
             else:
-                options["bounds"] = _dictionarize("bounds")
+                fitter_options["bounds"] = _dictionarize("bounds")
         else:
-            options["bounds"] = dict(zip(fit_params, [(-np.inf, np.inf)] * len(fit_params)))
+            fitter_options["bounds"] = dict(zip(fit_params, [(-np.inf, np.inf)] * len(fit_params)))
 
-        return options
+        return fitter_options
 
     def _subset_data(
         self,
@@ -616,8 +585,8 @@ def _subset_data(
         raise QiskitError(f"Specified series {name} is not defined in this analysis.")
 
     def _run_analysis(
-        self, data: ExperimentData, **options
-    ) -> Tuple[List[AnalysisResult], List["Figure"]]:
+        self, experiment_data: ExperimentData, **options
+    ) -> Tuple[List[AnalysisResult], List["pyplot.Figure"]]:
         """Run analysis on circuit data.
 
         Args:
@@ -629,20 +598,15 @@ def _run_analysis(
                    ``analysis_results`` may be a single or list of
                    AnalysisResult objects, and ``figures`` is a list of any
                    figures for the experiment.
-
-        Raises:
-
         """
         analysis_result = AnalysisResult()
 
         # pop arguments that are not given to fitter
-        data_processor = options.pop("data_processor", self.__default_data_processor__)
-        axis = options.pop("ax", None)
-        add_label = options.pop("add_label", True)
-
-        # Get common fields
-        # TODO use experiment level metadata once implemented
-        self.num_qubits = len(data.data(0)["metadata"]["qubits"])
+        plot = options.pop("plot")
+        add_label = options.pop("add_label")
+        axis = options.pop("ax")
+        data_processor = options.pop("data_processor")
+        base_fitter = options.pop("base_fitter")
 
         #
         # 1. Setup data processor
@@ -650,24 +614,28 @@ def _run_analysis(
         if isinstance(data_processor, DataProcessor) and not data_processor.is_trained:
             # Qiskit DataProcessor instance. May need calibration.
             try:
-                data_processor = self._calibrate_data_processor(
-                    data_processor=data_processor,
-                    experiment_data=data,
-                )
+                data_processor.train(data=experiment_data.data())
             except DataProcessorError as ex:
                 analysis_result["error_message"] = str(ex)
                 analysis_result["success"] = False
                 return [analysis_result], list()
-        else:
-            # Callback function
-            data_processor = data_processor.__func__
+
+        # get data processor options from analysis options
+        processor_options = {
+            key: options[key]
+            for key in inspect.signature(data_processor).parameters.keys()
+            if key in options
+        }
+        configured_data_processor = functools.partial(data_processor, **processor_options)
 
         #
         # 2. Extract curve entries from experiment data
         #
         # pylint: disable=broad-except
         try:
-            xdata, ydata, sigma, series = self._extract_curves(data, data_processor)
+            xdata, ydata, sigma, series = self._extract_curves(
+                experiment_data=experiment_data, data_processor=configured_data_processor
+            )
         except Exception as ex:
             analysis_result["error_message"] = str(ex)
             analysis_result["success"] = False
@@ -679,15 +647,16 @@ def _run_analysis(
         # pylint: disable=broad-except
         try:
             # format fit data
-            _xdata, _ydata, _sigma, _series = self._pre_processing(xdata, ydata, sigma, series)
+            _xdata, _ydata, _sigma, _series = self._pre_processing(
+                x_values=xdata, y_values=ydata, y_sigmas=sigma, series=series, **options
+            )
 
             # Generate fit options
-            fit_options_candidates = [
-                self._format_fit_options(fit_options)
-                for fit_options in self._setup_fitting(_xdata, _ydata, _sigma, _series, **options)
-            ]
-            fit_results = [
-                self.__base_fitter__.__func__(
+            fit_candidates = self._setup_fitting(_xdata, _ydata, _sigma, _series, **options)
+            if isinstance(fit_candidates, dict):
+                # only single initial guess
+                fit_options = self._format_fit_options(**fit_candidates)
+                fit_result = base_fitter(
                     funcs=[series_def.fit_func for series_def in self.__series__],
                     series=_series,
                     xdata=_xdata,
@@ -695,13 +664,26 @@ def _run_analysis(
                     sigma=_sigma,
                     **fit_options,
                 )
-                for fit_options in fit_options_candidates
-            ]
-            # Sort by chi squared value
-            fit_results = sorted(fit_results, key=lambda r: r["reduced_chisq"])
-
-            # Returns best fit result
-            analysis_result.update(**fit_results[0])
+                analysis_result.update(**fit_result)
+            else:
+                # multiple initial guesses
+                fit_options_candidates = [
+                    self._format_fit_options(**fit_options) for fit_options in fit_candidates
+                ]
+                fit_results = [
+                    base_fitter(
+                        funcs=[series_def.fit_func for series_def in self.__series__],
+                        series=_series,
+                        xdata=_xdata,
+                        ydata=_ydata,
+                        sigma=_sigma,
+                        **fit_options,
+                    )
+                    for fit_options in fit_options_candidates
+                ]
+                # Sort by chi squared value
+                fit_results = sorted(fit_results, key=lambda r: r["reduced_chisq"])
+                analysis_result.update(**fit_results[0])
             analysis_result["success"] = True
         except Exception as ex:
             analysis_result["error_message"] = str(ex)
@@ -711,20 +693,23 @@ def _run_analysis(
         # 4. Post-process analysis data
         #
         if analysis_result["success"]:
-            analysis_result = self._post_processing(analysis_result)
+            analysis_result = self._post_processing(analysis_result=analysis_result, **options)
 
         #
         # 5. Create figures
         #
-        figures = self._create_figures(
-            x_values=xdata,
-            y_values=ydata,
-            y_sigmas=sigma,
-            series=series,
-            analysis_results=analysis_result,
-            axis=axis,
-            add_label=add_label,
-        )
+        if plot:
+            figures = self._create_figures(
+                x_values=xdata,
+                y_values=ydata,
+                y_sigmas=sigma,
+                series=series,
+                analysis_results=analysis_result,
+                axis=axis,
+                add_label=add_label,
+            )
+        else:
+            figures = list()
 
         #
         # 6. Save raw data
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index f86175d579..8a4e399e21 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -13,22 +13,18 @@
 Standard RB analysis class.
 """
 
-from typing import List, Tuple, Dict, Any, Optional
+from typing import List, Tuple, Dict, Any, Union
 
-from qiskit.providers.options import Options
-from qiskit_experiments.experiment_data import ExperimentData
-from qiskit_experiments.base_analysis import BaseAnalysis
-from qiskit_experiments.analysis.curve_fitting import curve_fit, process_curve_data
 import numpy as np
 
-from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, FitOptions, exponential_decay
-from qiskit_experiments.analysis.data_processing import mean_xy_data,
-from qiskit_experiments.analysis import plotting
+from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, exponential_decay
+from qiskit_experiments.analysis.data_processing import mean_xy_data
 from qiskit_experiments.experiment_data import AnalysisResult
 
 
 class RBAnalysis(CurveAnalysis):
     """RB Analysis class."""
+
     __series__ = [
         SeriesDef(
             name="RB curve",
@@ -39,20 +35,18 @@ class RBAnalysis(CurveAnalysis):
         )
     ]
 
-    __plot_labels__ = {"alpha": "\u03B1", "EPC": "EPC"}
+    __fit_label_desc__ = {"alpha": "\u03B1", "EPC": "EPC"}
 
     __plot_xlabel__ = "Clifford Length"
 
     __plot_ylabel__ = "P(0)"
 
-
     @classmethod
     def _default_options(cls):
-        return Options(
-            p0=None,
-            plot=True,
-            ax=None,
-        )
+        default_options = super()._default_options()
+        default_options.p0 = None
+
+        return default_options
 
     def _setup_fitting(
         self,
@@ -61,9 +55,9 @@ def _setup_fitting(
         y_sigmas: np.ndarray,
         series: np.ndarray,
         **options,
-    ) -> List[FitOptions]:
+    ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
         """Fitter options."""
-        fit_guess = {"a": 0.95, "alpha": 0.99, "b": 1 / 2 ** self.num_qubits}
+        fit_guess = {"a": 0.95, "alpha": 0.99, "b": 1 / 2 ** options["num_qubits"]}
 
         # Use the first two points to guess the decay param
         dcliff = x_values[1] - x_values[0]
@@ -76,28 +70,26 @@ def _setup_fitting(
         if y_values[0] > fit_guess["b"]:
             fit_guess["a"] = (y_values[0] - fit_guess["b"]) / fit_guess["alpha"] ** x_values[0]
 
-        fit_options = [
-            FitOptions(p0=fit_guess, bounds={"a": [0.0, 1.0], "alpha": [0.0, 1.0], "b": [0.0, 1.0]})
-        ]
-        return fit_options
-
-    def _data_processor_options(self, metadata: Dict[str, Any]) -> Dict[str, Any]:
-        """Set outcome label."""
-        return {"outcome": "0" * len(metadata["qubits"])}
+        return {"p0": fit_guess, "bounds": {"a": [0.0, 1.0], "alpha": [0.0, 1.0], "b": [0.0, 1.0]}}
 
     def _pre_processing(
-        self, x_values: np.ndarray, y_values: np.ndarray, y_sigmas: np.ndarray, series: np.ndarray
+        self,
+        x_values: np.ndarray,
+        y_values: np.ndarray,
+        y_sigmas: np.ndarray,
+        series: np.ndarray,
+        **options,
     ) -> Tuple[np.ndarray, ...]:
         """Average over the same x values."""
         xdata, ydata, sigma = mean_xy_data(x_values, y_values, y_sigmas, method="sample")
         return xdata, ydata, sigma, np.zeros(len(xdata))
 
-    def _post_processing(self, analysis_result: AnalysisResult) -> AnalysisResult:
+    def _post_processing(self, analysis_result: AnalysisResult, **options) -> AnalysisResult:
         """Calculate EPC."""
         alpha = analysis_result["popt"][1]
         alpha_err = analysis_result["popt_err"][1]
 
-        scale = (2 ** self.num_qubits - 1) / (2 ** self.num_qubits)
+        scale = (2 ** options["num_qubits"] - 1) / (2 ** options["num_qubits"])
         analysis_result["EPC"] = scale * (1 - alpha)
         analysis_result["EPC_err"] = scale * alpha_err / alpha
 
diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
index 476b3f7975..63c60d2256 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -65,6 +65,7 @@ def __init__(
 
         # Set configurable options
         self.set_experiment_options(lengths=list(lengths), num_samples=num_samples)
+        self.set_analysis_options(outcome="0" * self.num_qubits, num_qubits=self.num_qubits)
 
         # Set fixed options
         self._full_sampling = full_sampling
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index a5fd0df091..163a054daa 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -19,8 +19,10 @@
 from qiskit.test import QiskitTestCase
 
 from qiskit_experiments import ExperimentData
-from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, fit_functions, FitOptions
+from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, fit_functions
+from qiskit_experiments.analysis.data_processing import level2_probability
 from qiskit_experiments.base_experiment import BaseExperiment
+from qiskit_experiments.analysis.curve_fitting import multi_curve_fit
 
 
 class FakeExperiment(BaseExperiment):
@@ -29,7 +31,7 @@ class FakeExperiment(BaseExperiment):
     def __init__(self):
         super().__init__(qubits=(0,), experiment_type="fake_experiment")
 
-    def circuits(self, backend=None, **circuit_options):
+    def circuits(self, backend=None):
         return []
 
 
@@ -113,18 +115,6 @@ def setUp(self):
         )
         self.err_decimal = 3
 
-    @staticmethod
-    def data_processor(data, outcome):
-        """A helper method to format input data."""
-        counts = data["counts"]
-        outcome = outcome or "1" * len(list(counts.keys())[0])
-
-        shots = sum(counts.values())
-        p_mean = counts.get(outcome, 0.0) / shots
-        p_var = p_mean * (1 - p_mean) / shots
-
-        return p_mean, p_var
-
     def test_data_extraction(self):
         """Test data extraction method."""
         # data to analyze
@@ -134,7 +124,6 @@ def test_data_extraction(self):
             param_dict={"amp": 1.0},
             type=1,
             valid=True,
-            outcome="1",
         )
 
         # fake data
@@ -144,13 +133,12 @@ def test_data_extraction(self):
             param_dict={"amp": 0.5},
             type=2,
             valid=False,
-            outcome="1",
         )
         # merge two experiment data
         for datum in test_data1.data():
             test_data0.add_data(datum)
 
-        xdata, ydata, sigma, series = self.analysis._extract_curves(test_data0, self.data_processor)
+        xdata, ydata, sigma, series = self.analysis._extract_curves(test_data0, level2_probability)
 
         # check if the module filter off data: valid=False
         self.assertEqual(len(xdata), 20)
@@ -201,16 +189,19 @@ def test_get_subset(self):
 
     def test_formatting_options(self):
         """Test option formatter."""
-        test_options = FitOptions(
-            p0=[0, 1, 2, 3, 4], bounds=[(-1, 1), (-2, 2), (-3, 3), (-4, 4), (-5, 5)]
-        )
-        formatted_options = self.analysis._format_fit_options(test_options)
-
-        ref_p0 = {"p0": 0, "p1": 1, "p2": 2, "p3": 3, "p4": 4}
-        self.assertDictEqual(formatted_options["p0"], ref_p0)
+        test_options = {
+            "p0": [0, 1, 2, 3, 4],
+            "bounds": [(-1, 1), (-2, 2), (-3, 3), (-4, 4), (-5, 5)],
+            "other_value": "test",
+        }
+        formatted_options = self.analysis._format_fit_options(**test_options)
 
-        ref_bounds = {"p0": (-1, 1), "p1": (-2, 2), "p2": (-3, 3), "p3": (-4, 4), "p4": (-5, 5)}
-        self.assertDictEqual(formatted_options["bounds"], ref_bounds)
+        ref_options = {
+            "p0": {"p0": 0, "p1": 1, "p2": 2, "p3": 3, "p4": 4},
+            "bounds": {"p0": (-1, 1), "p1": (-2, 2), "p2": (-3, 3), "p3": (-4, 4), "p4": (-5, 5)},
+            "other_value": "test",
+        }
+        self.assertDictEqual(formatted_options, ref_options)
 
 
 class TestCurveAnalysisIntegration(QiskitTestCase):
@@ -242,9 +233,16 @@ def test_run_single_curve_analysis(self):
             func=fit_functions.exponential_decay,
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3},
-            outcome="1",
         )
-        results, _ = analysis._run_analysis(test_data, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
+        results, _ = analysis._run_analysis(
+            test_data,
+            p0=[ref_p0, ref_p1, ref_p2, ref_p3],
+            plot=False,
+            add_label=True,
+            ax=None,
+            data_processor=level2_probability,
+            base_fitter=multi_curve_fit,
+        )
         result = results[0]
 
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
@@ -278,7 +276,6 @@ def test_run_single_curve_fail(self):
             func=fit_functions.exponential_decay,
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3},
-            outcome="1",
         )
 
         # Try to fit with infeasible parameter boundary. This should fail.
@@ -286,6 +283,11 @@ def test_run_single_curve_fail(self):
             test_data,
             p0=[ref_p0, ref_p1, ref_p2, ref_p3],
             bounds=([-10, -10, -10, -10], [0, 0, 0, 0]),
+            plot=False,
+            add_label=True,
+            ax=None,
+            data_processor=level2_probability,
+            base_fitter=multi_curve_fit,
         )
         result = results[0]
 
@@ -325,7 +327,6 @@ def test_run_two_curves_with_same_fitfunc(self):
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p3, "baseline": ref_p4},
             exp=0,
-            outcome="1",
         )
 
         test_data1 = simulate_output_data(
@@ -333,14 +334,21 @@ def test_run_two_curves_with_same_fitfunc(self):
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "lamb": ref_p2, "x0": ref_p3, "baseline": ref_p4},
             exp=1,
-            outcome="1",
         )
 
         # merge two experiment data
         for datum in test_data1.data():
             test_data0.add_data(datum)
 
-        results, _ = analysis._run_analysis(test_data0, p0=[ref_p0, ref_p1, ref_p2, ref_p3, ref_p4])
+        results, _ = analysis._run_analysis(
+            test_data0,
+            p0=[ref_p0, ref_p1, ref_p2, ref_p3, ref_p4],
+            plot=False,
+            add_label=True,
+            ax=None,
+            data_processor=level2_probability,
+            base_fitter=multi_curve_fit,
+        )
         result = results[0]
 
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3, ref_p4])
@@ -379,7 +387,6 @@ def test_run_two_curves_with_two_fitfuncs(self):
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "freq": ref_p1, "phase": ref_p2, "baseline": ref_p3},
             exp=0,
-            outcome="1",
         )
 
         test_data1 = simulate_output_data(
@@ -387,14 +394,21 @@ def test_run_two_curves_with_two_fitfuncs(self):
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "freq": ref_p1, "phase": ref_p2, "baseline": ref_p3},
             exp=1,
-            outcome="1",
         )
 
         # merge two experiment data
         for datum in test_data1.data():
             test_data0.add_data(datum)
 
-        results, _ = analysis._run_analysis(test_data0, p0=[ref_p0, ref_p1, ref_p2, ref_p3])
+        results, _ = analysis._run_analysis(
+            test_data0,
+            p0=[ref_p0, ref_p1, ref_p2, ref_p3],
+            plot=False,
+            add_label=True,
+            ax=None,
+            data_processor=level2_probability,
+            base_fitter=multi_curve_fit,
+        )
         result = results[0]
 
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])

From 62ff987b505e5ac34640e3ac0d4e6e77478852ea Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 27 May 2021 18:03:58 +0900
Subject: [PATCH 42/74] update irb

---
 .../interleaved_rb_analysis.py                | 214 ++++++------------
 .../randomized_benchmarking/rb_analysis.py    |  14 +-
 2 files changed, 82 insertions(+), 146 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index 65c2ae58ff..eaed7c44ae 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -12,18 +12,15 @@
 """
 Interleaved RB analysis class.
 """
-from typing import Optional, List
+from typing import List, Tuple, Dict, Any, Union
+
 import numpy as np
-from qiskit_experiments.analysis.curve_fitting import (
-    process_multi_curve_data,
-    multi_curve_fit,
-)
+
+from qiskit_experiments.analysis import SeriesDef, exponential_decay
 from qiskit_experiments.analysis.data_processing import (
-    level2_probability,
     multi_mean_xy_data,
 )
-from qiskit_experiments.analysis import plotting
-
+from qiskit_experiments.experiment_data import AnalysisResult
 from .rb_analysis import RBAnalysis
 
 
@@ -42,50 +39,74 @@ class InterleavedRBAnalysis(RBAnalysis):
     \frac{2\left(d^{2}-1\right)\left(1-p\right)}{pd^{2}}+\frac{4\sqrt{1-p}\sqrt{d^{2}-1}}{p}
     \end{array}\right.`
     """
-    # pylint: disable=invalid-name
-    def _run_analysis(
+
+    __series__ = {
+        SeriesDef(
+            name="Standard",
+            fit_func=lambda x, a, alpha, alpha_c, b: exponential_decay(
+                x, amp=a, lamb=-1.0, base=alpha, baseline=b
+            ),
+            plot_color="red",
+            plot_symbol=".",
+        ),
+        SeriesDef(
+            name="Interleaved",
+            fit_func=lambda x, a, alpha, alpha_c, b: exponential_decay(
+                x, amp=a, lamb=-1.0, base=alpha * alpha_c, baseline=b
+            ),
+            plot_color="orange",
+            plot_symbol="^",
+        ),
+    }
+
+    __fit_label_desc__ = {"alpha": "\u03B1", "alpha_c": "\u03B1_c", "EPC": "EPC"}
+
+    def _setup_fitting(
         self,
-        experiment_data,
-        p0: Optional[List[float]] = None,
-        plot: bool = True,
-        ax: Optional["matplotlib.axes.Axes"] = None,
-    ):
-
-        data = experiment_data.data()
-        num_qubits = len(data[0]["metadata"]["qubits"])
-
-        # Process data
-        def data_processor(datum):
-            return level2_probability(datum, num_qubits * "0")
-
-        # Raw data for each sample
-        series_raw, x_raw, y_raw, sigma_raw = process_multi_curve_data(data, data_processor)
-
-        # Data averaged over samples
-        series, xdata, ydata, ydata_sigma = multi_mean_xy_data(series_raw, x_raw, y_raw, sigma_raw)
-
-        # pylint: disable = unused-argument
-        def fit_fun_standard(x, a, alpha, alpha_c, b):
-            return a * alpha ** x + b
-
-        def fit_fun_interleaved(x, a, alpha, alpha_c, b):
-            return a * (alpha * alpha_c) ** x + b
-
-        p0 = self._p0_multi(series, xdata, ydata, num_qubits)
-        bounds = {"a": [0, 1], "alpha": [0, 1], "alpha_c": [0, 1], "b": [0, 1]}
-
-        analysis_result = multi_curve_fit(
-            [fit_fun_standard, fit_fun_interleaved],
-            series,
-            xdata,
-            ydata,
-            p0,
-            ydata_sigma,
-            bounds=bounds,
+        x_values: np.ndarray,
+        y_values: np.ndarray,
+        y_sigmas: np.ndarray,
+        series: np.ndarray,
+        **options,
+    ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+        """Fitter options."""
+        std_xdata, std_ydata, _ = self._subset_data(
+            "Standard", x_values, y_sigmas, y_sigmas, series
+        )
+        p0_std = self._initial_guess(std_xdata, std_ydata, options["num_qubits"])
+
+        int_xdata, int_ydata, _ = self._subset_data(
+            "Interleaved", x_values, y_sigmas, y_sigmas, series
         )
+        p0_int = self._initial_guess(int_xdata, int_ydata, options["num_qubits"])
+
+        irb_p0 = {
+            "a": np.mean([p0_std["a"], p0_int["a"]]),
+            "alpha": p0_std["alpha"],
+            "alpha_c": min(p0_int["alpha"] / p0_std["alpha"], 1),
+            "b": np.mean([p0_std["b"], p0_int["b"]]),
+        }
+        irb_bounds = {"a": [0, 1], "alpha": [0, 1], "alpha_c": [0, 1], "b": [0, 1]}
 
+        return {"p0": irb_p0, "bounds": irb_bounds}
+
+    def _pre_processing(
+        self,
+        x_values: np.ndarray,
+        y_values: np.ndarray,
+        y_sigmas: np.ndarray,
+        series: np.ndarray,
+        **options,
+    ) -> Tuple[np.ndarray, ...]:
+        """Average over the same x values."""
+        return multi_mean_xy_data(
+            series=series, xdata=x_values, ydata=y_values, sigma=y_sigmas, method="sample"
+        )
+
+    def _post_processing(self, analysis_result: AnalysisResult, **options) -> AnalysisResult:
+        """Calculate EPC."""
         # Add EPC data
-        nrb = 2 ** num_qubits
+        nrb = 2 ** options["num_qubits"]
         scale = (nrb - 1) / nrb
         _, alpha, alpha_c, _ = analysis_result["popt"]
         _, _, alpha_c_err, _ = analysis_result["popt_err"]
@@ -108,99 +129,4 @@ def fit_fun_interleaved(x, a, alpha, alpha_c, b):
         analysis_result["EPC_systematic_err"] = systematic_err
         analysis_result["EPC_systematic_bounds"] = [max(systematic_err_l, 0), systematic_err_r]
 
-        if plot and plotting.HAS_MATPLOTLIB:
-            ax = plotting.plot_curve_fit(fit_fun_standard, analysis_result, ax=ax, color="blue")
-            ax = plotting.plot_curve_fit(
-                fit_fun_interleaved,
-                analysis_result,
-                ax=ax,
-                color="green",
-            )
-            ax = self._generate_multi_scatter_plot(series_raw, x_raw, y_raw, ax=ax)
-            ax = self._generate_multi_errorbar_plot(series, xdata, ydata, ydata_sigma, ax=ax)
-            self._format_plot(ax, analysis_result)
-            ax.legend(loc="center right")
-            figures = [ax.get_figure()]
-        else:
-            figures = None
-        return analysis_result, figures
-
-    @staticmethod
-    def _generate_multi_scatter_plot(series, xdata, ydata, ax):
-        """Generate scatter plot of raw data"""
-        idx0 = series == 0
-        idx1 = series == 1
-        ax = plotting.plot_scatter(xdata[idx0], ydata[idx0], ax=ax)
-        ax = plotting.plot_scatter(xdata[idx1], ydata[idx1], ax=ax, marker="+", c="darkslategrey")
-        return ax
-
-    @staticmethod
-    def _generate_multi_errorbar_plot(series, xdata, ydata, sigma, ax):
-        """Generate errorbar plot of average data"""
-        idx0 = series == 0
-        idx1 = series == 1
-        ax = plotting.plot_errorbar(
-            xdata[idx0],
-            ydata[idx0],
-            sigma[idx0],
-            ax=ax,
-            label="Standard",
-            marker=".",
-            color="red",
-        )
-        ax = plotting.plot_errorbar(
-            xdata[idx1],
-            ydata[idx1],
-            sigma[idx1],
-            ax=ax,
-            label="Interleaved",
-            marker="^",
-            color="orange",
-        )
-        return ax
-
-    @staticmethod
-    def _p0_multi(series, xdata, ydata, num_qubits):
-        """Initial guess for the fitting function"""
-        std_idx = series == 0
-        p0_std = RBAnalysis._p0(xdata[std_idx], ydata[std_idx], num_qubits)
-        int_idx = series == 1
-        p0_int = RBAnalysis._p0(xdata[int_idx], xdata[int_idx], num_qubits)
-        return {
-            "a": np.mean([p0_std["a"], p0_int["a"]]),
-            "alpha": p0_std["alpha"],
-            "alpha_c": min(p0_int["alpha"] / p0_std["alpha"], 1),
-            "b": np.mean([p0_std["b"], p0_int["b"]]),
-        }
-
-    @classmethod
-    def _format_plot(cls, ax, analysis_result, add_label=True):
-        """Format curve fit plot"""
-        # Formatting
-        ax.tick_params(labelsize=14)
-        ax.set_xlabel("Clifford Length", fontsize=16)
-        ax.set_ylabel("Ground State Population", fontsize=16)
-        ax.grid(True)
-
-        if add_label:
-            alpha = analysis_result["popt"][1]
-            alpha_c = analysis_result["popt"][2]
-            alpha_err = analysis_result["popt_err"][1]
-            alpha_c_err = analysis_result["popt_err"][2]
-            epc = analysis_result["EPC"]
-            epc_err = analysis_result["EPC_err"]
-            box_text = "\u03B1:{:.4f} \u00B1 {:.4f}".format(alpha, alpha_err)
-            box_text += "\n\u03B1_c:{:.4f} \u00B1 {:.4f}".format(alpha_c, alpha_c_err)
-            box_text += "\nEPC: {:.4f} \u00B1 {:.4f}".format(epc, epc_err)
-            bbox_props = dict(boxstyle="square,pad=0.3", fc="white", ec="black", lw=1)
-            ax.text(
-                0.6,
-                0.9,
-                box_text,
-                ha="center",
-                va="center",
-                size=14,
-                bbox=bbox_props,
-                transform=ax.transAxes,
-            )
-        return ax
+        return analysis_result
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index 8a4e399e21..1cc125c376 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -57,7 +57,17 @@ def _setup_fitting(
         **options,
     ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
         """Fitter options."""
-        fit_guess = {"a": 0.95, "alpha": 0.99, "b": 1 / 2 ** options["num_qubits"]}
+        return {
+            "p0": self._initial_guess(x_values, y_values, options["num_qubits"]),
+            "bounds": {"a": [0.0, 1.0], "alpha": [0.0, 1.0], "b": [0.0, 1.0]},
+        }
+
+    @staticmethod
+    def _initial_guess(
+        x_values: np.ndarray, y_values: np.ndarray, num_qubits: int
+    ) -> Dict[str, float]:
+        """Create initial guess with experiment data."""
+        fit_guess = {"a": 0.95, "alpha": 0.99, "b": 1 / 2 ** num_qubits}
 
         # Use the first two points to guess the decay param
         dcliff = x_values[1] - x_values[0]
@@ -70,7 +80,7 @@ def _setup_fitting(
         if y_values[0] > fit_guess["b"]:
             fit_guess["a"] = (y_values[0] - fit_guess["b"]) / fit_guess["alpha"] ** x_values[0]
 
-        return {"p0": fit_guess, "bounds": {"a": [0.0, 1.0], "alpha": [0.0, 1.0], "b": [0.0, 1.0]}}
+        return fit_guess
 
     def _pre_processing(
         self,

From e967f1a502e63a987704fbf5036647fcb25734b5 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 27 May 2021 18:49:34 +0900
Subject: [PATCH 43/74] move class attributes to options

---
 qiskit_experiments/analysis/curve_analysis.py | 107 +++++++-----------
 .../interleaved_rb_analysis.py                |  11 +-
 .../randomized_benchmarking/rb_analysis.py    |  10 +-
 test/analysis/test_curve_fit.py               |  40 ++++---
 4 files changed, 81 insertions(+), 87 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index dfb4354645..43264982ad 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -37,9 +37,9 @@
 class SeriesDef:
     """Description of curve."""
 
-    name: str
     fit_func: Callable
     filter_kwargs: Dict[str, Any] = dataclasses.field(default_factory=dict)
+    name: str = "Series-0"
     plot_color: str = "black"
     plot_symbol: str = "o"
 
@@ -53,26 +53,20 @@ class CurveAnalysis(BaseAnalysis):
 
     Class Attributes:
 
-        __x_key__: Key in the circuit metadata under which to find the value for
-            the horizontal axis.
         __series__: A set of data points that will be fit to a the same parameters
             in the fit function. If this analysis contains multiple curves,
             the same number of series definitions should be listed.
             Each series definition is SeriesDef element, that may be initialized with::
 
-                name: Name of the curve. This is arbitrary data field, but should be unique.
                 fit_func: Callback function to perform fit.
                 filter_kwargs: Circuit metadata key and value associated with this curve.
                     The data points of the curve is extracted from ExperimentData based on
                     this information.
+                name: Name of the curve. This is arbitrary data field, but should be unique.
                 plot_color: String color representation of this series in the plot.
                 plot_symbol: String formatter of the scatter of this series in the plot.
 
             See the Examples below for more details.
-        __fit_label_desc__: Dict of parameter names and its representation shows in the
-            result figure as an analysis report.
-        __plot_xlabel__: Label of x axis of result plot.
-        __plot_ylabel__: Label of y axis of result plot.
 
 
     Examples:
@@ -81,26 +75,19 @@ class CurveAnalysis(BaseAnalysis):
         ============================================
 
         In this type of experiment, the analysis deals with a single curve.
-        Thus filter_kwargs is not necessary defined.
-        In this example, fit value and error of the parameter ``lamb`` labeled by
-        a Greek lambda symbol are written  in the figure.
+        Thus filter_kwargs and series name are not necessary defined.
 
         .. code-block::
 
             class AnalysisExample(CurveAnalysis):
 
-                __x_key__ = "scan_val"
-
                 __series__ = [
                     SeriesDef(
-                        name="my_experiment1",
                         fit_func=lambda x, p0, p1, p2:
                             exponential_decay(x, amp=p0, lamb=p1, baseline=p2),
                     ),
                 ]
 
-                __plot_labels__ = {"lamb": "\u03BB"}
-
 
         A fitting for two exponential decay curve with partly shared parameter
         ======================================================================
@@ -113,8 +100,6 @@ class AnalysisExample(CurveAnalysis):
 
             class AnalysisExample(CurveAnalysis):
 
-                __x_key__ = "scan_val"
-
                 __series__ = [
                     SeriesDef(
                         name="my_experiment1",
@@ -134,8 +119,6 @@ class AnalysisExample(CurveAnalysis):
                     ),
                 ]
 
-                __plot_labels__ = {"lamb": "\u03BB"}
-
 
         A fitting for two trigonometric curves with the same parameter
         =============================================================
@@ -147,8 +130,6 @@ class AnalysisExample(CurveAnalysis):
 
             class AnalysisExample(CurveAnalysis):
 
-                __x_key__ = "scan_val"
-
                 __series__ = [
                     SeriesDef(
                         name="my_experiment1",
@@ -165,11 +146,9 @@ class AnalysisExample(CurveAnalysis):
                         filter_kwargs={"experiment": 2},
                         plot_color="blue",
                         plot_symbol="o",
-                    )
+                    ),
                 ]
 
-                __plot_labels__ = {"lamb": "\u03BB"}
-
 
     Notes:
         This CurveAnalysis class provides several private methods that subclasses can override.
@@ -190,11 +169,6 @@ class AnalysisExample(CurveAnalysis):
             Override :meth:`~self._setup_fitting`. For example, here you can
             calculate initial guess from experiment data and setup fitter options.
 
-        - Customize data processor calibration:
-            Override :meth:`~Self._calibrate_data_processor`. This is special subroutine
-            that is only called when a DataProcessor instance is used as the data processor.
-            You can take arbitrary data from experiment result and setup your processor.
-
         Note that other private methods are not expected to be overridden.
         If you forcibly override these methods, the behavior of analysis logic is not well tested
         and we cannot guarantee it works as expected (you may suffer from bugs).
@@ -204,38 +178,32 @@ class AnalysisExample(CurveAnalysis):
         https://github.com/Qiskit/qiskit-experiments/issues
     """
 
-    #: str: Metadata key representing a scanned value.
-    __x_key__ = "xval"
-
     #: List[SeriesDef]: List of mapping representing a data series
     __series__ = None
 
-    #: Dict[str, str]: Mapping of fit parameters and representation in the figure label.
-    __fit_label_desc__ = None
-
-    #: str: X axis label
-    __plot_xlabel__ = "x value"
-
-    #: str: Y axis label
-    __plot_ylabel__ = "y value"
-
     @classmethod
     def _default_options(cls):
         """Return default data processing options.
 
         Options:
-            plot: Set ``True`` to create figure for fit result.
-            add_label: Set ``True`` to write fit report in the figure.
-            ax: Optional. A matplotlib axis object to draw.
             base_fitter: A callback function to perform fitting with formatted data.
             data_processor: A callback function to format experiment data.
+            x_key: Circuit metadata key representing a scanned value.
+            plot: Set ``True`` to create figure for fit result.
+            ax: Optional. A matplotlib axis object to draw.
+            xlabel: X label of fit result figure.
+            ylabel: Y label of fit result figure.
+            fit_reports: Mapping of fit parameters and representation in the fit report.
         """
         return Options(
-            plot=True,
-            add_label=True,
-            ax=None,
             base_fitter=multi_curve_fit,
             data_processor=level2_probability,
+            x_key="xval",
+            plot=True,
+            ax=None,
+            xlabel="x value",
+            ylabel="y value",
+            fit_reports=None,
         )
 
     def _create_figures(
@@ -246,7 +214,9 @@ def _create_figures(
         series: np.ndarray,
         analysis_results: AnalysisResult,
         axis: Optional["AxisSubplot"] = None,
-        add_label: bool = True,
+        xlabel: str = "x value",
+        ylabel: str = "y value",
+        fit_reports: Optional[Dict[str, str]] = None,
     ) -> List["Figure"]:
         """Create new figures with the fit result and raw data.
 
@@ -259,7 +229,9 @@ def _create_figures(
             series: An integer array representing a mapping of data location to series index.
             analysis_results: Analysis result containing fit parameters.
             axis: User provided axis to draw result.
-            add_label: Set ``True`` to add analysis result label.
+            xlabel: String shown in figure x axis label.
+            ylabel: String shown in figure y axis label.
+            fit_reports: Mapping of fit parameters and representation in the fit report.
 
         Returns:
             List of figures.
@@ -267,13 +239,13 @@ def _create_figures(
         if plotting.HAS_MATPLOTLIB:
 
             if axis is None:
-                figure = plotting.pyplot.figure()
+                figure = plotting.pyplot.figure(figsize=(8, 5))
                 axis = figure.subplots(nrows=1, ncols=1)
             else:
                 figure = axis.get_figure()
 
-            axis.set_xlabel(self.__plot_xlabel__, fontsize=16)
-            axis.set_ylabel(self.__plot_ylabel__, fontsize=16)
+            axis.set_xlabel(xlabel, fontsize=16)
+            axis.set_ylabel(ylabel, fontsize=16)
 
             for series_def in self.__series__:
 
@@ -320,10 +292,10 @@ def _create_figures(
 
             # write analysis report
 
-            if add_label and analysis_results["success"]:
+            if fit_reports and analysis_results["success"]:
                 # write fit status in the plot
                 analysis_description = "Analysis Reports:\n"
-                for par_name, label in self.__fit_label_desc__.items():
+                for par_name, label in fit_reports.items():
                     try:
                         # fit value
                         pind = analysis_results["popt_keys"].index(par_name)
@@ -427,6 +399,7 @@ def _post_processing(self, analysis_result: AnalysisResult, **options) -> Analys
 
     def _extract_curves(
         self,
+        x_key: str,
         experiment_data: ExperimentData,
         data_processor: Union[Callable, DataProcessor],
     ) -> Tuple[np.ndarray, ...]:
@@ -440,6 +413,7 @@ def _extract_curves(
             common to the entire curve scan, i.e. series-level metadata.
 
         Args:
+            x_key: A circuit metadata key to represent scanned value.
             experiment_data: ExperimentData object to fit parameters.
             data_processor: A callable or DataProcessor instance to format data into numpy array.
                 This should take list of dictionary and returns two tuple of float values
@@ -463,11 +437,9 @@ def _is_target_series(datum, **filters):
         data = experiment_data.data()
 
         try:
-            x_values = [datum["metadata"][self.__x_key__] for datum in data]
+            x_values = [datum["metadata"][x_key] for datum in data]
         except KeyError as ex:
-            raise QiskitError(
-                f"X value key {self.__x_key__} is not defined in circuit metadata."
-            ) from ex
+            raise QiskitError(f"X value key {x_key} is not defined in circuit metadata.") from ex
 
         y_values, y_sigmas = zip(*map(data_processor, data))
 
@@ -602,11 +574,14 @@ def _run_analysis(
         analysis_result = AnalysisResult()
 
         # pop arguments that are not given to fitter
+        base_fitter = options.pop("base_fitter")
+        data_processor = options.pop("data_processor")
+        x_key = options.pop("x_key")
         plot = options.pop("plot")
-        add_label = options.pop("add_label")
         axis = options.pop("ax")
-        data_processor = options.pop("data_processor")
-        base_fitter = options.pop("base_fitter")
+        xlabel = options.pop("xlabel")
+        ylabel = options.pop("ylabel")
+        fit_reports = options.pop("fit_reports")
 
         #
         # 1. Setup data processor
@@ -634,7 +609,9 @@ def _run_analysis(
         # pylint: disable=broad-except
         try:
             xdata, ydata, sigma, series = self._extract_curves(
-                experiment_data=experiment_data, data_processor=configured_data_processor
+                x_key=x_key,
+                experiment_data=experiment_data,
+                data_processor=configured_data_processor,
             )
         except Exception as ex:
             analysis_result["error_message"] = str(ex)
@@ -706,7 +683,9 @@ def _run_analysis(
                 series=series,
                 analysis_results=analysis_result,
                 axis=axis,
-                add_label=add_label,
+                xlabel=xlabel,
+                ylabel=ylabel,
+                fit_reports=fit_reports,
             )
         else:
             figures = list()
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index eaed7c44ae..e954c8fcdb 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -40,7 +40,7 @@ class InterleavedRBAnalysis(RBAnalysis):
     \end{array}\right.`
     """
 
-    __series__ = {
+    __series__ = [
         SeriesDef(
             name="Standard",
             fit_func=lambda x, a, alpha, alpha_c, b: exponential_decay(
@@ -57,9 +57,14 @@ class InterleavedRBAnalysis(RBAnalysis):
             plot_color="orange",
             plot_symbol="^",
         ),
-    }
+    ]
 
-    __fit_label_desc__ = {"alpha": "\u03B1", "alpha_c": "\u03B1_c", "EPC": "EPC"}
+    @classmethod
+    def _default_options(cls):
+        default_options = super()._default_options()
+        default_options.fit_reports = {"alpha": "\u03B1", "alpha_c": "\u03B1_c", "EPC": "EPC"}
+
+        return default_options
 
     def _setup_fitting(
         self,
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index 1cc125c376..ead59211f4 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -27,7 +27,6 @@ class RBAnalysis(CurveAnalysis):
 
     __series__ = [
         SeriesDef(
-            name="RB curve",
             fit_func=lambda x, a, alpha, b: exponential_decay(
                 x, amp=a, lamb=-1.0, base=alpha, baseline=b
             ),
@@ -35,16 +34,13 @@ class RBAnalysis(CurveAnalysis):
         )
     ]
 
-    __fit_label_desc__ = {"alpha": "\u03B1", "EPC": "EPC"}
-
-    __plot_xlabel__ = "Clifford Length"
-
-    __plot_ylabel__ = "P(0)"
-
     @classmethod
     def _default_options(cls):
         default_options = super()._default_options()
         default_options.p0 = None
+        default_options.xlabel = "Clifford Length"
+        default_options.ylabel = "P(0)"
+        default_options.fit_reports = {"alpha": "\u03B1", "EPC": "EPC"}
 
         return default_options
 
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index 163a054daa..b97b7131f3 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -138,7 +138,9 @@ def test_data_extraction(self):
         for datum in test_data1.data():
             test_data0.add_data(datum)
 
-        xdata, ydata, sigma, series = self.analysis._extract_curves(test_data0, level2_probability)
+        xdata, ydata, sigma, series = self.analysis._extract_curves(
+            x_key="xval", experiment_data=test_data0, data_processor=level2_probability
+        )
 
         # check if the module filter off data: valid=False
         self.assertEqual(len(xdata), 20)
@@ -237,11 +239,14 @@ def test_run_single_curve_analysis(self):
         results, _ = analysis._run_analysis(
             test_data,
             p0=[ref_p0, ref_p1, ref_p2, ref_p3],
+            base_fitter=multi_curve_fit,
+            data_processor=level2_probability,
+            x_key="xval",
             plot=False,
-            add_label=True,
             ax=None,
-            data_processor=level2_probability,
-            base_fitter=multi_curve_fit,
+            xlabel="x value",
+            ylabel="y value",
+            fit_reports=None,
         )
         result = results[0]
 
@@ -283,11 +288,14 @@ def test_run_single_curve_fail(self):
             test_data,
             p0=[ref_p0, ref_p1, ref_p2, ref_p3],
             bounds=([-10, -10, -10, -10], [0, 0, 0, 0]),
+            base_fitter=multi_curve_fit,
+            data_processor=level2_probability,
+            x_key="xval",
             plot=False,
-            add_label=True,
             ax=None,
-            data_processor=level2_probability,
-            base_fitter=multi_curve_fit,
+            xlabel="x value",
+            ylabel="y value",
+            fit_reports=None,
         )
         result = results[0]
 
@@ -343,11 +351,14 @@ def test_run_two_curves_with_same_fitfunc(self):
         results, _ = analysis._run_analysis(
             test_data0,
             p0=[ref_p0, ref_p1, ref_p2, ref_p3, ref_p4],
+            base_fitter=multi_curve_fit,
+            data_processor=level2_probability,
+            x_key="xval",
             plot=False,
-            add_label=True,
             ax=None,
-            data_processor=level2_probability,
-            base_fitter=multi_curve_fit,
+            xlabel="x value",
+            ylabel="y value",
+            fit_reports=None,
         )
         result = results[0]
 
@@ -403,11 +414,14 @@ def test_run_two_curves_with_two_fitfuncs(self):
         results, _ = analysis._run_analysis(
             test_data0,
             p0=[ref_p0, ref_p1, ref_p2, ref_p3],
+            base_fitter=multi_curve_fit,
+            data_processor=level2_probability,
+            x_key="xval",
             plot=False,
-            add_label=True,
             ax=None,
-            data_processor=level2_probability,
-            base_fitter=multi_curve_fit,
+            xlabel="x value",
+            ylabel="y value",
+            fit_reports=None,
         )
         result = results[0]
 

From 93d30c3dcdbce63ddf2fe508ff581f4511f0254b Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Wed, 2 Jun 2021 16:54:01 +0900
Subject: [PATCH 44/74] review comment from Chris

---
 qiskit_experiments/analysis/__init__.py       | 16 +---
 qiskit_experiments/analysis/curve_analysis.py | 80 +++++++++++++------
 .../analysis/data_processing.py               | 16 ++--
 .../{fit_functions.py => fit_function.py}     |  0
 qiskit_experiments/experiment_data.py         | 14 +++-
 .../interleaved_rb_analysis.py                |  6 +-
 .../randomized_benchmarking/rb_analysis.py    |  4 +-
 .../randomized_benchmarking/rb_experiment.py  |  6 +-
 test/analysis/test_curve_fit.py               | 40 +++++-----
 9 files changed, 109 insertions(+), 73 deletions(-)
 rename qiskit_experiments/analysis/{fit_functions.py => fit_function.py} (100%)

diff --git a/qiskit_experiments/analysis/__init__.py b/qiskit_experiments/analysis/__init__.py
index 9ae6b5fec3..26ca3b6aeb 100644
--- a/qiskit_experiments/analysis/__init__.py
+++ b/qiskit_experiments/analysis/__init__.py
@@ -44,21 +44,13 @@
 .. autosummary::
     :toctree: ../stubs/
 
-    cos
-    exponential_decay
-    gaussian
-    sin
+    fit_function.cos
+    fit_function.exponential_decay
+    fit_function.gaussian
+    fit_function.sin
 
 """
 from .curve_analysis import CurveAnalysis, SeriesDef
 
-# fit functions (alphabetical import ordering)
-from .fit_functions import (
-    cos,
-    exponential_decay,
-    gaussian,
-    sin,
-)
-
 from .curve_fitting import curve_fit, multi_curve_fit, process_curve_data, process_multi_curve_data
 from .plotting import plot_curve_fit, plot_errorbar, plot_scatter
diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 43264982ad..1d5dd3cfd1 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -16,7 +16,6 @@
 # pylint: disable=invalid-name
 
 import dataclasses
-import functools
 import inspect
 from typing import Any, Dict, List, Tuple, Callable, Union, Optional
 
@@ -26,7 +25,7 @@
 
 from qiskit_experiments.analysis import plotting
 from qiskit_experiments.analysis.curve_fitting import multi_curve_fit
-from qiskit_experiments.analysis.data_processing import level2_probability
+from qiskit_experiments.analysis.data_processing import probability
 from qiskit_experiments.base_analysis import BaseAnalysis
 from qiskit_experiments.data_processing import DataProcessor
 from qiskit_experiments.data_processing.exceptions import DataProcessorError
@@ -186,24 +185,56 @@ def _default_options(cls):
         """Return default data processing options.
 
         Options:
-            base_fitter: A callback function to perform fitting with formatted data.
+            curve_fitter: A callback function to perform fitting with formatted data.
+                This function should have signature:
+
+                .. code-block::
+
+                    def curve_fitter(
+                        funcs: List[Callable],
+                        series: ndarray,
+                        xdata: ndarray,
+                        ydata: ndarray,
+                        p0: ndarray,
+                        sigma: Optional[ndarray],
+                        weights: Optional[ndarray],
+                        bounds: Optional[
+                            Union[Dict[str, Tuple[float, float]], Tuple[ndarray, ndarray]]
+                        ],
+                    ) -> AnalysisResult:
+
+                See :func:`~qiskit_experiment.analysis.multi_curve_fit` for example.
             data_processor: A callback function to format experiment data.
+                This function should have signature:
+
+                .. code-block::
+
+                    def data_processor(data: Dict[str, Any]) -> Tuple[float, float]
+
+                This can be a :class:`~qiskit_experiment.data_processing.DataProcessor`
+                instance that defines the `self.__call__` method.
+            p0: Array-like or dictionary of initial parameters.
+            bounds: Array-like or dictionary of (min, max) tuple of fit parameter boundaries.
             x_key: Circuit metadata key representing a scanned value.
             plot: Set ``True`` to create figure for fit result.
             ax: Optional. A matplotlib axis object to draw.
             xlabel: X label of fit result figure.
             ylabel: Y label of fit result figure.
             fit_reports: Mapping of fit parameters and representation in the fit report.
+            return_data_points: Set ``True`` to return formatted XY data.
         """
         return Options(
-            base_fitter=multi_curve_fit,
-            data_processor=level2_probability,
+            curve_fitter=multi_curve_fit,
+            data_processor=probability(outcome="1"),
+            p0=None,
+            bounds=None,
             x_key="xval",
             plot=True,
             ax=None,
             xlabel="x value",
             ylabel="y value",
             fit_reports=None,
+            return_data_points=False,
         )
 
     def _create_figures(
@@ -270,6 +301,7 @@ def _create_figures(
                     marker=series_def.plot_symbol,
                     color=series_def.plot_color,
                     zorder=1,
+                    linestyle="",
                 )
 
                 # plot fit curve
@@ -582,6 +614,7 @@ def _run_analysis(
         xlabel = options.pop("xlabel")
         ylabel = options.pop("ylabel")
         fit_reports = options.pop("fit_reports")
+        return_data_points = options.pop("return_data_points")
 
         #
         # 1. Setup data processor
@@ -595,14 +628,6 @@ def _run_analysis(
                 analysis_result["success"] = False
                 return [analysis_result], list()
 
-        # get data processor options from analysis options
-        processor_options = {
-            key: options[key]
-            for key in inspect.signature(data_processor).parameters.keys()
-            if key in options
-        }
-        configured_data_processor = functools.partial(data_processor, **processor_options)
-
         #
         # 2. Extract curve entries from experiment data
         #
@@ -611,7 +636,7 @@ def _run_analysis(
             xdata, ydata, sigma, series = self._extract_curves(
                 x_key=x_key,
                 experiment_data=experiment_data,
-                data_processor=configured_data_processor,
+                data_processor=data_processor,
             )
         except Exception as ex:
             analysis_result["error_message"] = str(ex)
@@ -693,16 +718,21 @@ def _run_analysis(
         #
         # 6. Save raw data
         #
-        raw_data_dict = dict()
-        for series_def in self.__series__:
-            sub_xdata, sub_ydata, sub_sigma = self._subset_data(
-                name=series_def.name, x_values=xdata, y_values=ydata, y_sigmas=sigma, series=series
-            )
-            raw_data_dict[series_def.name] = {
-                "xdata": sub_xdata,
-                "ydata": sub_ydata,
-                "sigma": sub_sigma,
-            }
-        analysis_result["raw_data"] = raw_data_dict
+        if return_data_points:
+            raw_data_dict = dict()
+            for series_def in self.__series__:
+                sub_xdata, sub_ydata, sub_sigma = self._subset_data(
+                    name=series_def.name,
+                    x_values=xdata,
+                    y_values=ydata,
+                    y_sigmas=sigma,
+                    series=series
+                )
+                raw_data_dict[series_def.name] = {
+                    "xdata": sub_xdata,
+                    "ydata": sub_ydata,
+                    "sigma": sub_sigma,
+                }
+            analysis_result["raw_data"] = raw_data_dict
 
         return [analysis_result], figures
diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index 72f356d082..ca96deb2c2 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -14,7 +14,7 @@
 """
 # pylint: disable = invalid-name
 
-from typing import List, Dict, Tuple, Optional
+from typing import List, Dict, Tuple, Optional, Callable
 import numpy as np
 from qiskit.exceptions import QiskitError
 
@@ -159,7 +159,7 @@ def multi_mean_xy_data(
     )
 
 
-def level2_probability(data: Dict[str, any], outcome: str = None) -> Tuple[float, float]:
+def level2_probability(data: Dict[str, any], outcome) -> Tuple[float, float]:
     """Return the outcome probability mean and variance.
 
     Args:
@@ -180,13 +180,17 @@ def level2_probability(data: Dict[str, any], outcome: str = None) -> Tuple[float
     # TODO fix sigma definition
     # When the count is 100% zero (i.e. simulator), this yields sigma=0.
     # This crashes scipy fitter when it calculates covariance matrix (zero-div error).
-
     counts = data["counts"]
 
-    if outcome is None:
-        outcome = "1" * len(list(counts.keys())[0])
-
     shots = sum(counts.values())
     p_mean = counts.get(outcome, 0.0) / shots
     p_var = p_mean * (1 - p_mean) / shots
     return p_mean, p_var
+
+
+def probability(outcome: str) -> Callable:
+    """Return probability data processor callback used by the analysis classes."""
+    def data_processor(data):
+        return level2_probability(data, outcome)
+
+    return data_processor
diff --git a/qiskit_experiments/analysis/fit_functions.py b/qiskit_experiments/analysis/fit_function.py
similarity index 100%
rename from qiskit_experiments/analysis/fit_functions.py
rename to qiskit_experiments/analysis/fit_function.py
diff --git a/qiskit_experiments/experiment_data.py b/qiskit_experiments/experiment_data.py
index 95cc7f16d0..45a9179463 100644
--- a/qiskit_experiments/experiment_data.py
+++ b/qiskit_experiments/experiment_data.py
@@ -32,6 +32,15 @@
 
 class AnalysisResult(dict):
     """Placeholder class"""
+    __keys_not_shown__ = "pcov", "raw_data"
+
+    def __str__(self):
+        out = ""
+        for key, value in self.items():
+            if key in self.__keys_not_shown__:
+                continue
+            out += f"\n- {key}: {value}"
+        return out
 
 
 class ExperimentData:
@@ -363,8 +372,5 @@ def __str__(self):
         ret += "\n" + line
         if n_res:
             ret += "\nLast Analysis Result"
-            for key, value in self._analysis_results[-1].items():
-                if key in ("raw_data", "pcov"):
-                    continue
-                ret += f"\n- {key}: {value}"
+            ret += str(self._analysis_results[-1])
         return ret
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index e954c8fcdb..c926b42958 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -16,7 +16,7 @@
 
 import numpy as np
 
-from qiskit_experiments.analysis import SeriesDef, exponential_decay
+from qiskit_experiments.analysis import SeriesDef, fit_function
 from qiskit_experiments.analysis.data_processing import (
     multi_mean_xy_data,
 )
@@ -43,7 +43,7 @@ class InterleavedRBAnalysis(RBAnalysis):
     __series__ = [
         SeriesDef(
             name="Standard",
-            fit_func=lambda x, a, alpha, alpha_c, b: exponential_decay(
+            fit_func=lambda x, a, alpha, alpha_c, b: fit_function.exponential_decay(
                 x, amp=a, lamb=-1.0, base=alpha, baseline=b
             ),
             plot_color="red",
@@ -51,7 +51,7 @@ class InterleavedRBAnalysis(RBAnalysis):
         ),
         SeriesDef(
             name="Interleaved",
-            fit_func=lambda x, a, alpha, alpha_c, b: exponential_decay(
+            fit_func=lambda x, a, alpha, alpha_c, b: fit_function.exponential_decay(
                 x, amp=a, lamb=-1.0, base=alpha * alpha_c, baseline=b
             ),
             plot_color="orange",
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index ead59211f4..4a7460be77 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -17,7 +17,7 @@
 
 import numpy as np
 
-from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, exponential_decay
+from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, fit_function
 from qiskit_experiments.analysis.data_processing import mean_xy_data
 from qiskit_experiments.experiment_data import AnalysisResult
 
@@ -27,7 +27,7 @@ class RBAnalysis(CurveAnalysis):
 
     __series__ = [
         SeriesDef(
-            fit_func=lambda x, a, alpha, b: exponential_decay(
+            fit_func=lambda x, a, alpha, b: fit_function.exponential_decay(
                 x, amp=a, lamb=-1.0, base=alpha, baseline=b
             ),
             plot_color="blue",
diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
index 63c60d2256..fb53e68c87 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -23,6 +23,7 @@
 from qiskit.providers.options import Options
 
 from qiskit_experiments.base_experiment import BaseExperiment
+from qiskit_experiments.analysis.data_processing import probability
 from .rb_analysis import RBAnalysis
 from .clifford_utils import CliffordUtils
 
@@ -65,7 +66,10 @@ def __init__(
 
         # Set configurable options
         self.set_experiment_options(lengths=list(lengths), num_samples=num_samples)
-        self.set_analysis_options(outcome="0" * self.num_qubits, num_qubits=self.num_qubits)
+        self.set_analysis_options(
+            data_processor=probability(outcome="0" * self.num_qubits),
+            num_qubits=self.num_qubits,
+        )
 
         # Set fixed options
         self._full_sampling = full_sampling
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index b97b7131f3..876e433f01 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -19,7 +19,7 @@
 from qiskit.test import QiskitTestCase
 
 from qiskit_experiments import ExperimentData
-from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, fit_functions
+from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, fit_function
 from qiskit_experiments.analysis.data_processing import level2_probability
 from qiskit_experiments.base_experiment import BaseExperiment
 from qiskit_experiments.analysis.curve_fitting import multi_curve_fit
@@ -92,21 +92,21 @@ def setUp(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_functions.exponential_decay(
+                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_function.exponential_decay(
                         x, amp=p0, lamb=p1, baseline=p4
                     ),
                     filter_kwargs={"type": 1, "valid": True},
                 ),
                 SeriesDef(
                     name="curve2",
-                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_functions.exponential_decay(
+                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_function.exponential_decay(
                         x, amp=p0, lamb=p2, baseline=p4
                     ),
                     filter_kwargs={"type": 2, "valid": True},
                 ),
                 SeriesDef(
                     name="curve3",
-                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_functions.exponential_decay(
+                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_function.exponential_decay(
                         x, amp=p0, lamb=p3, baseline=p4
                     ),
                     filter_kwargs={"type": 3, "valid": True},
@@ -119,7 +119,7 @@ def test_data_extraction(self):
         """Test data extraction method."""
         # data to analyze
         test_data0 = simulate_output_data(
-            func=fit_functions.exponential_decay,
+            func=fit_function.exponential_decay,
             xvals=self.xvalues,
             param_dict={"amp": 1.0},
             type=1,
@@ -128,7 +128,7 @@ def test_data_extraction(self):
 
         # fake data
         test_data1 = simulate_output_data(
-            func=fit_functions.exponential_decay,
+            func=fit_function.exponential_decay,
             xvals=self.xvalues,
             param_dict={"amp": 0.5},
             type=2,
@@ -152,8 +152,8 @@ def test_data_extraction(self):
         # check y values
         ref_y = np.concatenate(
             (
-                fit_functions.exponential_decay(self.xvalues, amp=1.0),
-                fit_functions.exponential_decay(self.xvalues, amp=0.5),
+                fit_function.exponential_decay(self.xvalues, amp=1.0),
+                fit_function.exponential_decay(self.xvalues, amp=0.5),
             )
         )
         np.testing.assert_array_almost_equal(ydata, ref_y, decimal=self.err_decimal)
@@ -220,7 +220,7 @@ def test_run_single_curve_analysis(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    fit_func=lambda x, p0, p1, p2, p3: fit_functions.exponential_decay(
+                    fit_func=lambda x, p0, p1, p2, p3: fit_function.exponential_decay(
                         x, amp=p0, lamb=p1, x0=p2, baseline=p3
                     ),
                 )
@@ -232,7 +232,7 @@ def test_run_single_curve_analysis(self):
         ref_p3 = 0.1
 
         test_data = simulate_output_data(
-            func=fit_functions.exponential_decay,
+            func=fit_function.exponential_decay,
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3},
         )
@@ -266,7 +266,7 @@ def test_run_single_curve_fail(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    fit_func=lambda x, p0, p1, p2, p3: fit_functions.exponential_decay(
+                    fit_func=lambda x, p0, p1, p2, p3: fit_function.exponential_decay(
                         x, amp=p0, lamb=p1, x0=p2, baseline=p3
                     ),
                 )
@@ -278,7 +278,7 @@ def test_run_single_curve_fail(self):
         ref_p3 = 0.1
 
         test_data = simulate_output_data(
-            func=fit_functions.exponential_decay,
+            func=fit_function.exponential_decay,
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p2, "baseline": ref_p3},
         )
@@ -310,14 +310,14 @@ def test_run_two_curves_with_same_fitfunc(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_functions.exponential_decay(
+                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_function.exponential_decay(
                         x, amp=p0, lamb=p1, x0=p3, baseline=p4
                     ),
                     filter_kwargs={"exp": 0},
                 ),
                 SeriesDef(
                     name="curve1",
-                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_functions.exponential_decay(
+                    fit_func=lambda x, p0, p1, p2, p3, p4: fit_function.exponential_decay(
                         x, amp=p0, lamb=p2, x0=p3, baseline=p4
                     ),
                     filter_kwargs={"exp": 1},
@@ -331,14 +331,14 @@ def test_run_two_curves_with_same_fitfunc(self):
         ref_p4 = 0.1
 
         test_data0 = simulate_output_data(
-            func=fit_functions.exponential_decay,
+            func=fit_function.exponential_decay,
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "lamb": ref_p1, "x0": ref_p3, "baseline": ref_p4},
             exp=0,
         )
 
         test_data1 = simulate_output_data(
-            func=fit_functions.exponential_decay,
+            func=fit_function.exponential_decay,
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "lamb": ref_p2, "x0": ref_p3, "baseline": ref_p4},
             exp=1,
@@ -374,14 +374,14 @@ def test_run_two_curves_with_two_fitfuncs(self):
             series=[
                 SeriesDef(
                     name="curve1",
-                    fit_func=lambda x, p0, p1, p2, p3: fit_functions.cos(
+                    fit_func=lambda x, p0, p1, p2, p3: fit_function.cos(
                         x, amp=p0, freq=p1, phase=p2, baseline=p3
                     ),
                     filter_kwargs={"exp": 0},
                 ),
                 SeriesDef(
                     name="curve2",
-                    fit_func=lambda x, p0, p1, p2, p3: fit_functions.sin(
+                    fit_func=lambda x, p0, p1, p2, p3: fit_function.sin(
                         x, amp=p0, freq=p1, phase=p2, baseline=p3
                     ),
                     filter_kwargs={"exp": 1},
@@ -394,14 +394,14 @@ def test_run_two_curves_with_two_fitfuncs(self):
         ref_p3 = 0.5
 
         test_data0 = simulate_output_data(
-            func=fit_functions.cos,
+            func=fit_function.cos,
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "freq": ref_p1, "phase": ref_p2, "baseline": ref_p3},
             exp=0,
         )
 
         test_data1 = simulate_output_data(
-            func=fit_functions.sin,
+            func=fit_function.sin,
             xvals=self.xvalues,
             param_dict={"amp": ref_p0, "freq": ref_p1, "phase": ref_p2, "baseline": ref_p3},
             exp=1,

From b7652257e6716b711d5e71deb60e00345bf53244 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Wed, 2 Jun 2021 17:47:22 +0900
Subject: [PATCH 45/74] fix bug causes list indices must be ...

---
 qiskit_experiments/base_analysis.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/qiskit_experiments/base_analysis.py b/qiskit_experiments/base_analysis.py
index 6105ca7088..59585da463 100644
--- a/qiskit_experiments/base_analysis.py
+++ b/qiskit_experiments/base_analysis.py
@@ -92,9 +92,8 @@ def run(
         # pylint: disable=broad-except
         try:
             analysis_results, figures = self._run_analysis(experiment_data, **analysis_options)
-            analysis_results["success"] = True
         except Exception as ex:
-            analysis_results = AnalysisResult(success=False, error_message=ex)
+            analysis_results = [AnalysisResult(success=False, error_message=ex)]
             figures = None
 
         # Save to experiment data

From 00519d0bbf39b1e7f08c9c40542f447d38db8769 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Wed, 2 Jun 2021 17:47:53 +0900
Subject: [PATCH 46/74] Analysis result formatting

---
 qiskit_experiments/analysis/curve_analysis.py | 21 ++++++++--------
 qiskit_experiments/analysis/curve_fitting.py  | 25 ++++++++++++++++---
 qiskit_experiments/experiment_data.py         |  2 +-
 .../randomized_benchmarking/rb_analysis.py    |  1 -
 4 files changed, 33 insertions(+), 16 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 1d5dd3cfd1..aed8565eb6 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -24,7 +24,7 @@
 from qiskit.providers.options import Options
 
 from qiskit_experiments.analysis import plotting
-from qiskit_experiments.analysis.curve_fitting import multi_curve_fit
+from qiskit_experiments.analysis.curve_fitting import multi_curve_fit, CurveAnalysisResult
 from qiskit_experiments.analysis.data_processing import probability
 from qiskit_experiments.base_analysis import BaseAnalysis
 from qiskit_experiments.data_processing import DataProcessor
@@ -201,7 +201,7 @@ def curve_fitter(
                         bounds: Optional[
                             Union[Dict[str, Tuple[float, float]], Tuple[ndarray, ndarray]]
                         ],
-                    ) -> AnalysisResult:
+                    ) -> CurveAnalysisResult:
 
                 See :func:`~qiskit_experiment.analysis.multi_curve_fit` for example.
             data_processor: A callback function to format experiment data.
@@ -243,7 +243,7 @@ def _create_figures(
         y_values: np.ndarray,
         y_sigmas: np.ndarray,
         series: np.ndarray,
-        analysis_results: AnalysisResult,
+        analysis_results: CurveAnalysisResult,
         axis: Optional["AxisSubplot"] = None,
         xlabel: str = "x value",
         ylabel: str = "y value",
@@ -415,7 +415,9 @@ def _pre_processing(
         """
         return x_values, y_values, y_sigmas, series
 
-    def _post_processing(self, analysis_result: AnalysisResult, **options) -> AnalysisResult:
+    def _post_processing(
+            self, analysis_result: CurveAnalysisResult, **options
+    ) -> CurveAnalysisResult:
         """Calculate new quantity from the fit result.
 
         Subclasses can override this method to do post analysis.
@@ -425,7 +427,7 @@ def _post_processing(self, analysis_result: AnalysisResult, **options) -> Analys
             options: Analysis options.
 
         Returns:
-            New AnalysisResult instance containing the result of post analysis.
+            New CurveAnalysisResult instance containing the result of post analysis.
         """
         return analysis_result
 
@@ -603,10 +605,10 @@ def _run_analysis(
                    AnalysisResult objects, and ``figures`` is a list of any
                    figures for the experiment.
         """
-        analysis_result = AnalysisResult()
+        analysis_result = CurveAnalysisResult()
 
         # pop arguments that are not given to fitter
-        base_fitter = options.pop("base_fitter")
+        curve_fitter = options.pop("curve_fitter")
         data_processor = options.pop("data_processor")
         x_key = options.pop("x_key")
         plot = options.pop("plot")
@@ -652,13 +654,12 @@ def _run_analysis(
             _xdata, _ydata, _sigma, _series = self._pre_processing(
                 x_values=xdata, y_values=ydata, y_sigmas=sigma, series=series, **options
             )
-
             # Generate fit options
             fit_candidates = self._setup_fitting(_xdata, _ydata, _sigma, _series, **options)
             if isinstance(fit_candidates, dict):
                 # only single initial guess
                 fit_options = self._format_fit_options(**fit_candidates)
-                fit_result = base_fitter(
+                fit_result = curve_fitter(
                     funcs=[series_def.fit_func for series_def in self.__series__],
                     series=_series,
                     xdata=_xdata,
@@ -673,7 +674,7 @@ def _run_analysis(
                     self._format_fit_options(**fit_options) for fit_options in fit_candidates
                 ]
                 fit_results = [
-                    base_fitter(
+                    curve_fitter(
                         funcs=[series_def.fit_func for series_def in self.__series__],
                         series=_series,
                         xdata=_xdata,
diff --git a/qiskit_experiments/analysis/curve_fitting.py b/qiskit_experiments/analysis/curve_fitting.py
index a87ccf58b8..897892a548 100644
--- a/qiskit_experiments/analysis/curve_fitting.py
+++ b/qiskit_experiments/analysis/curve_fitting.py
@@ -19,10 +19,27 @@
 import numpy as np
 import scipy.optimize as opt
 from qiskit.exceptions import QiskitError
-from qiskit_experiments.base_analysis import AnalysisResult
+from qiskit_experiments import AnalysisResult
 from qiskit_experiments.analysis.data_processing import filter_data
 
 
+class CurveAnalysisResult(AnalysisResult):
+    __keys_not_shown__ = "pcov", "raw_data", "popt", "popt_keys", "popt_err"
+
+    def __str__(self):
+        out = ""
+
+        popt_keys = self.get("popt_keys")
+        popt = self.get("popt")
+        popt_err = self.get("popt_err")
+
+        for key, value, error in zip(popt_keys, popt, popt_err):
+            out += f"\n- {key}: {value} \u00B1 {error}"
+        out += super().__str__()
+
+        return out
+
+
 def curve_fit(
     func: Callable,
     xdata: np.ndarray,
@@ -31,7 +48,7 @@ def curve_fit(
     sigma: Optional[np.ndarray] = None,
     bounds: Optional[Union[Dict[str, Tuple[float, float]], Tuple[np.ndarray, np.ndarray]]] = None,
     **kwargs,
-) -> AnalysisResult:
+) -> CurveAnalysisResult:
     r"""Perform a non-linear least squares to fit
 
     This solves the optimization problem
@@ -139,7 +156,7 @@ def fit_func(x, *params):
         "xrange": xdata_range,
     }
 
-    return AnalysisResult(result)
+    return CurveAnalysisResult(result)
 
 
 def multi_curve_fit(
@@ -152,7 +169,7 @@ def multi_curve_fit(
     weights: Optional[np.ndarray] = None,
     bounds: Optional[Union[Dict[str, Tuple[float, float]], Tuple[np.ndarray, np.ndarray]]] = None,
     **kwargs,
-) -> AnalysisResult:
+) -> CurveAnalysisResult:
     r"""Perform a linearized multi-objective non-linear least squares fit.
 
     This solves the optimization problem
diff --git a/qiskit_experiments/experiment_data.py b/qiskit_experiments/experiment_data.py
index 45a9179463..5bec191281 100644
--- a/qiskit_experiments/experiment_data.py
+++ b/qiskit_experiments/experiment_data.py
@@ -32,7 +32,7 @@
 
 class AnalysisResult(dict):
     """Placeholder class"""
-    __keys_not_shown__ = "pcov", "raw_data"
+    __keys_not_shown__ = tuple()
 
     def __str__(self):
         out = ""
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index 4a7460be77..b68cf501f4 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -37,7 +37,6 @@ class RBAnalysis(CurveAnalysis):
     @classmethod
     def _default_options(cls):
         default_options = super()._default_options()
-        default_options.p0 = None
         default_options.xlabel = "Clifford Length"
         default_options.ylabel = "P(0)"
         default_options.fit_reports = {"alpha": "\u03B1", "EPC": "EPC"}

From add125390ac905926f491b3e571148635d18a1fe Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Wed, 2 Jun 2021 17:55:29 +0900
Subject: [PATCH 47/74] update error docstring

---
 qiskit_experiments/analysis/curve_analysis.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index aed8565eb6..bc5892bc61 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -604,6 +604,9 @@ def _run_analysis(
                    ``analysis_results`` may be a single or list of
                    AnalysisResult objects, and ``figures`` is a list of any
                    figures for the experiment.
+
+        Raises:
+            AnalysisError: if the analysis fails.
         """
         analysis_result = CurveAnalysisResult()
 

From 03ddadfc1569e0549055b01c8477e86edd571f66 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 3 Jun 2021 00:37:18 +0900
Subject: [PATCH 48/74] lint

---
 qiskit_experiments/analysis/curve_analysis.py | 111 +++++++++---------
 qiskit_experiments/analysis/curve_fitting.py  |   2 +
 .../analysis/data_processing.py               |   3 +-
 qiskit_experiments/base_analysis.py           |   8 +-
 qiskit_experiments/experiment_data.py         |   1 +
 test/analysis/test_curve_fit.py               |   4 +-
 6 files changed, 69 insertions(+), 60 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index bc5892bc61..a7c7edd5b5 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -30,6 +30,7 @@
 from qiskit_experiments.data_processing import DataProcessor
 from qiskit_experiments.data_processing.exceptions import DataProcessorError
 from qiskit_experiments.experiment_data import AnalysisResult, ExperimentData
+from qiskit_experiments.exceptions import AnalysisError
 
 
 @dataclasses.dataclass(frozen=True)
@@ -267,6 +268,8 @@ def _create_figures(
         Returns:
             List of figures.
         """
+        fit_available = all(key in analysis_results for key in ("popt", "popt_err", "xrange"))
+
         if plotting.HAS_MATPLOTLIB:
 
             if axis is None:
@@ -306,7 +309,7 @@ def _create_figures(
 
                 # plot fit curve
 
-                if analysis_results["success"]:
+                if fit_available:
                     plotting.plot_curve_fit(
                         func=series_def.fit_func,
                         result=analysis_results,
@@ -324,7 +327,7 @@ def _create_figures(
 
             # write analysis report
 
-            if fit_reports and analysis_results["success"]:
+            if fit_reports and fit_available:
                 # write fit status in the plot
                 analysis_description = "Analysis Reports:\n"
                 for par_name, label in fit_reports.items():
@@ -416,7 +419,7 @@ def _pre_processing(
         return x_values, y_values, y_sigmas, series
 
     def _post_processing(
-            self, analysis_result: CurveAnalysisResult, **options
+        self, analysis_result: CurveAnalysisResult, **options
     ) -> CurveAnalysisResult:
         """Calculate new quantity from the fit result.
 
@@ -609,6 +612,7 @@ def _run_analysis(
             AnalysisError: if the analysis fails.
         """
         analysis_result = CurveAnalysisResult()
+        figures = list()
 
         # pop arguments that are not given to fitter
         curve_fitter = options.pop("curve_fitter")
@@ -629,29 +633,27 @@ def _run_analysis(
             try:
                 data_processor.train(data=experiment_data.data())
             except DataProcessorError as ex:
-                analysis_result["error_message"] = str(ex)
-                analysis_result["success"] = False
-                return [analysis_result], list()
+                raise AnalysisError(
+                    f"DataProcessor calibration failed with error message: {str(ex)}."
+                ) from ex
 
         #
         # 2. Extract curve entries from experiment data
         #
-        # pylint: disable=broad-except
         try:
             xdata, ydata, sigma, series = self._extract_curves(
                 x_key=x_key,
                 experiment_data=experiment_data,
                 data_processor=data_processor,
             )
-        except Exception as ex:
-            analysis_result["error_message"] = str(ex)
-            analysis_result["success"] = False
-            return [analysis_result], list()
+        except DataProcessorError as ex:
+            raise AnalysisError(
+                f"Data extraction and formatting failed with error message: {str(ex)}."
+            ) from ex
 
         #
         # 3. Run fitting
         #
-        # pylint: disable=broad-except
         try:
             # format fit data
             _xdata, _ydata, _sigma, _series = self._pre_processing(
@@ -690,53 +692,54 @@ def _run_analysis(
                 # Sort by chi squared value
                 fit_results = sorted(fit_results, key=lambda r: r["reduced_chisq"])
                 analysis_result.update(**fit_results[0])
-            analysis_result["success"] = True
-        except Exception as ex:
+
+        except AnalysisError as ex:
             analysis_result["error_message"] = str(ex)
             analysis_result["success"] = False
 
-        #
-        # 4. Post-process analysis data
-        #
-        if analysis_result["success"]:
-            analysis_result = self._post_processing(analysis_result=analysis_result, **options)
-
-        #
-        # 5. Create figures
-        #
-        if plot:
-            figures = self._create_figures(
-                x_values=xdata,
-                y_values=ydata,
-                y_sigmas=sigma,
-                series=series,
-                analysis_results=analysis_result,
-                axis=axis,
-                xlabel=xlabel,
-                ylabel=ylabel,
-                fit_reports=fit_reports,
-            )
         else:
-            figures = list()
+            #
+            # 4. Post-process analysis data
+            #
+            analysis_result = self._post_processing(analysis_result=analysis_result, **options)
 
-        #
-        # 6. Save raw data
-        #
-        if return_data_points:
-            raw_data_dict = dict()
-            for series_def in self.__series__:
-                sub_xdata, sub_ydata, sub_sigma = self._subset_data(
-                    name=series_def.name,
-                    x_values=xdata,
-                    y_values=ydata,
-                    y_sigmas=sigma,
-                    series=series
+        finally:
+            #
+            # 5. Create figures
+            #
+            if plot:
+                figures.extend(
+                    self._create_figures(
+                        x_values=xdata,
+                        y_values=ydata,
+                        y_sigmas=sigma,
+                        series=series,
+                        analysis_results=analysis_result,
+                        axis=axis,
+                        xlabel=xlabel,
+                        ylabel=ylabel,
+                        fit_reports=fit_reports,
+                    )
                 )
-                raw_data_dict[series_def.name] = {
-                    "xdata": sub_xdata,
-                    "ydata": sub_ydata,
-                    "sigma": sub_sigma,
-                }
-            analysis_result["raw_data"] = raw_data_dict
+
+            #
+            # 6. Optionally store raw data points
+            #
+            if return_data_points:
+                raw_data_dict = dict()
+                for series_def in self.__series__:
+                    sub_xdata, sub_ydata, sub_sigma = self._subset_data(
+                        name=series_def.name,
+                        x_values=xdata,
+                        y_values=ydata,
+                        y_sigmas=sigma,
+                        series=series,
+                    )
+                    raw_data_dict[series_def.name] = {
+                        "xdata": sub_xdata,
+                        "ydata": sub_ydata,
+                        "sigma": sub_sigma,
+                    }
+                analysis_result["raw_data"] = raw_data_dict
 
         return [analysis_result], figures
diff --git a/qiskit_experiments/analysis/curve_fitting.py b/qiskit_experiments/analysis/curve_fitting.py
index e85aab2e71..fa56decba3 100644
--- a/qiskit_experiments/analysis/curve_fitting.py
+++ b/qiskit_experiments/analysis/curve_fitting.py
@@ -24,6 +24,8 @@
 
 
 class CurveAnalysisResult(AnalysisResult):
+    """Analysis data container for curve fit analysis."""
+
     __keys_not_shown__ = "pcov", "raw_data", "popt", "popt_keys", "popt_err"
 
     def __str__(self):
diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index ca96deb2c2..d04095c468 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -159,7 +159,7 @@ def multi_mean_xy_data(
     )
 
 
-def level2_probability(data: Dict[str, any], outcome) -> Tuple[float, float]:
+def level2_probability(data: Dict[str, any], outcome: str) -> Tuple[float, float]:
     """Return the outcome probability mean and variance.
 
     Args:
@@ -190,6 +190,7 @@ def level2_probability(data: Dict[str, any], outcome) -> Tuple[float, float]:
 
 def probability(outcome: str) -> Callable:
     """Return probability data processor callback used by the analysis classes."""
+
     def data_processor(data):
         return level2_probability(data, outcome)
 
diff --git a/qiskit_experiments/base_analysis.py b/qiskit_experiments/base_analysis.py
index a8907ec8e7..f5abc3244c 100644
--- a/qiskit_experiments/base_analysis.py
+++ b/qiskit_experiments/base_analysis.py
@@ -16,11 +16,11 @@
 from abc import ABC, abstractmethod
 from typing import List, Tuple
 
-from qiskit.providers.options import Options
 from qiskit.exceptions import QiskitError
+from qiskit.providers.options import Options
 
-from qiskit_experiments.experiment_data import ExperimentData, AnalysisResult
 from qiskit_experiments.exceptions import AnalysisError
+from qiskit_experiments.experiment_data import ExperimentData, AnalysisResult
 
 
 class BaseAnalysis(ABC):
@@ -87,9 +87,11 @@ def run(
         analysis_options = analysis_options.__dict__
 
         # Run analysis
-        # pylint: disable=broad-except
         try:
             analysis_results, figures = self._run_analysis(experiment_data, **analysis_options)
+            for res in analysis_results:
+                if "success" not in res:
+                    res["success"] = True
         except AnalysisError as ex:
             analysis_results = [AnalysisResult(success=False, error_message=ex)]
             figures = None
diff --git a/qiskit_experiments/experiment_data.py b/qiskit_experiments/experiment_data.py
index 5bec191281..c6569894b0 100644
--- a/qiskit_experiments/experiment_data.py
+++ b/qiskit_experiments/experiment_data.py
@@ -32,6 +32,7 @@
 
 class AnalysisResult(dict):
     """Placeholder class"""
+
     __keys_not_shown__ = tuple()
 
     def __str__(self):
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index 876e433f01..e1492808d9 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -20,9 +20,9 @@
 
 from qiskit_experiments import ExperimentData
 from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, fit_function
+from qiskit_experiments.analysis.curve_fitting import multi_curve_fit
 from qiskit_experiments.analysis.data_processing import level2_probability
 from qiskit_experiments.base_experiment import BaseExperiment
-from qiskit_experiments.analysis.curve_fitting import multi_curve_fit
 
 
 class FakeExperiment(BaseExperiment):
@@ -301,7 +301,7 @@ def test_run_single_curve_fail(self):
 
         self.assertFalse(result["success"])
 
-        ref_result_keys = ["raw_data", "error_message", "success"]
+        ref_result_keys = ["error_message", "success"]
         self.assertSetEqual(set(result.keys()), set(ref_result_keys))
 
     def test_run_two_curves_with_same_fitfunc(self):

From a7ddf5bf1c8ef3a30c06bd83f2c6dc7d224aa27e Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 3 Jun 2021 04:55:23 +0900
Subject: [PATCH 49/74] bug fix - reorder args of protected methods (series
 comes before xvals) - make analysis result list - relevant test fix - add
 filter kwargs to interleaved analysis

---
 qiskit_experiments/analysis/curve_analysis.py | 68 ++++++++++---------
 .../characterization/t1_experiment.py         |  4 +-
 .../characterization/t2star_experiment.py     |  4 +-
 .../composite/composite_analysis.py           |  2 +-
 .../interleaved_rb_analysis.py                | 34 ++++------
 .../interleaved_rb_experiment.py              |  6 +-
 .../randomized_benchmarking/rb_analysis.py    | 11 +--
 .../randomized_benchmarking/rb_experiment.py  |  1 -
 test/analysis/test_curve_fit.py               | 40 +++++------
 test/test_t1.py                               |  6 +-
 10 files changed, 86 insertions(+), 90 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index a7c7edd5b5..b779a81d1e 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -240,10 +240,10 @@ def data_processor(data: Dict[str, Any]) -> Tuple[float, float]
 
     def _create_figures(
         self,
+        series: np.ndarray,
         x_values: np.ndarray,
         y_values: np.ndarray,
         y_sigmas: np.ndarray,
-        series: np.ndarray,
         analysis_results: CurveAnalysisResult,
         axis: Optional["AxisSubplot"] = None,
         xlabel: str = "x value",
@@ -255,10 +255,10 @@ def _create_figures(
         Subclass can override this method to create different type of figures.
 
         Args:
+            series: An integer array representing a mapping of data location to series index.
             x_values: Full data set of x values.
             y_values: Full data set of y values.
             y_sigmas: Full data set of y sigmas.
-            series: An integer array representing a mapping of data location to series index.
             analysis_results: Analysis result containing fit parameters.
             axis: User provided axis to draw result.
             xlabel: String shown in figure x axis label.
@@ -286,14 +286,18 @@ def _create_figures(
                 # plot raw data
 
                 xdata, ydata, _ = self._subset_data(
-                    series_def.name, x_values, y_values, y_sigmas, series
+                    name=series_def.name,
+                    series=series,
+                    x_values=x_values,
+                    y_values=y_values,
+                    y_sigmas=y_sigmas,
                 )
                 plotting.plot_scatter(xdata=xdata, ydata=ydata, ax=axis, zorder=0)
 
                 # plot formatted data
 
                 xdata, ydata, sigma = self._subset_data(
-                    series_def.name, *self._pre_processing(x_values, y_values, y_sigmas, series)
+                    series_def.name, *self._pre_processing(series, x_values, y_values, y_sigmas)
                 )
                 plotting.plot_errorbar(
                     xdata=xdata,
@@ -360,10 +364,10 @@ def _create_figures(
     # pylint: disable = unused-argument
     def _setup_fitting(
         self,
+        series: np.ndarray,
         x_values: np.ndarray,
         y_values: np.ndarray,
         y_sigmas: np.ndarray,
-        series: np.ndarray,
         **options,
     ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
         """An analysis subroutine that is called to set fitter options.
@@ -377,10 +381,10 @@ def _setup_fitting(
         and find the best result measured by the reduced chi-squared value.
 
         Args:
+            series: An integer array representing a mapping of data location to series index.
             x_values: Full data set of x values.
             y_values: Full data set of y values.
             y_sigmas: Full data set of y sigmas.
-            series: An integer array representing a mapping of data location to series index.
             options: User provided fit options.
 
         Returns:
@@ -390,10 +394,10 @@ def _setup_fitting(
 
     def _pre_processing(
         self,
+        series: np.ndarray,
         x_values: np.ndarray,
         y_values: np.ndarray,
         y_sigmas: np.ndarray,
-        series: np.ndarray,
         **options,
     ) -> Tuple[np.ndarray, ...]:
         """An optional subroutine to perform data pre-processing.
@@ -407,16 +411,16 @@ def _pre_processing(
         - Apply smoothing to y values to deal with noisy observed values
 
         Args:
+            series: Numpy integer array to represent mapping of data to series.
             x_values: Numpy float array to represent X values.
             y_values: Numpy float array to represent Y values.
             y_sigmas: Numpy float array to represent Y errors.
-            series: Numpy integer array to represent mapping of data to series.
             options: Analysis options.
 
         Returns:
             Numpy array tuple of pre-processed (x_values, y_values, y_sigmas, series).
         """
-        return x_values, y_values, y_sigmas, series
+        return series, x_values, y_values, y_sigmas
 
     def _post_processing(
         self, analysis_result: CurveAnalysisResult, **options
@@ -457,10 +461,10 @@ def _extract_curves(
                 that represent a y value and an error of it.
 
         Returns:
-            List of ``CurveEntry`` containing x-values, y-values, and y values sigma.
+            Tuple of series, x values, y values, and y sigmas.
 
         Raises:
-            QiskitError:
+            DataProcessorError:
                 - When __x_key__ is not defined in the circuit metadata.
         """
 
@@ -476,7 +480,9 @@ def _is_target_series(datum, **filters):
         try:
             x_values = [datum["metadata"][x_key] for datum in data]
         except KeyError as ex:
-            raise QiskitError(f"X value key {x_key} is not defined in circuit metadata.") from ex
+            raise DataProcessorError(
+                f"X value key {x_key} is not defined in circuit metadata."
+            ) from ex
 
         y_values, y_sigmas = zip(*map(data_processor, data))
 
@@ -493,7 +499,7 @@ def _is_target_series(datum, **filters):
             )
             series[data_index] = idx
 
-        return x_values, y_values, y_sigmas, series
+        return series, x_values, y_values, y_sigmas
 
     def _format_fit_options(self, **fitter_options) -> Dict[str, Any]:
         """Format fitting option args to dictionary of parameter names.
@@ -505,12 +511,10 @@ def _format_fit_options(self, **fitter_options) -> Dict[str, Any]:
             Formatted fit options.
 
         Raises:
-            QiskitError:
+            AnalysisError:
                 - When fit functions have different signature.
-            KeyError:
                 - When fit option is dictionary but key doesn't match with parameter names.
                 - When initial guesses are not provided.
-            ValueError:
                 - When fit option is array but length doesn't match with parameter number.
         """
         # check fit function signatures
@@ -518,7 +522,7 @@ def _format_fit_options(self, **fitter_options) -> Dict[str, Any]:
         for series_def in self.__series__:
             fsigs.add(inspect.signature(series_def.fit_func))
         if len(fsigs) > 1:
-            raise QiskitError(
+            raise AnalysisError(
                 "Fit functions specified in the series definition have "
                 "different function signature. They should receive "
                 "the same parameter set for multi-objective function fit."
@@ -529,8 +533,8 @@ def _format_fit_options(self, **fitter_options) -> Dict[str, Any]:
         def _check_keys(parameter_name):
             named_values = fitter_options[parameter_name]
             if not named_values.keys() == set(fit_params):
-                raise KeyError(
-                    f"Fitting option {parameter_name} doesn't have the "
+                raise AnalysisError(
+                    f"Fitting option `{parameter_name}` doesn't have the "
                     f"expected parameter names {','.join(fit_params)}."
                 )
 
@@ -538,8 +542,8 @@ def _check_keys(parameter_name):
         def _dictionarize(parameter_name):
             parameter_array = fitter_options[parameter_name]
             if len(parameter_array) != len(fit_params):
-                raise ValueError(
-                    f"Value length of fitting option {parameter_name} doesn't "
+                raise AnalysisError(
+                    f"Value length of fitting option `{parameter_name}` doesn't "
                     "match with the length of expected parameters. "
                     f"{len(parameter_array)} != {len(fit_params)}."
                 )
@@ -551,7 +555,7 @@ def _dictionarize(parameter_name):
             else:
                 fitter_options["p0"] = _dictionarize("p0")
         else:
-            raise KeyError("Initial guess p0 is not provided to the fitting options.")
+            raise AnalysisError("Initial guess p0 is not provided to the fitting options.")
 
         if "bounds" in fitter_options:
             if isinstance(fitter_options["bounds"], dict):
@@ -566,32 +570,32 @@ def _dictionarize(parameter_name):
     def _subset_data(
         self,
         name: str,
+        series: np.ndarray,
         x_values: np.ndarray,
         y_values: np.ndarray,
         y_sigmas: np.ndarray,
-        series: np.ndarray,
     ) -> Tuple[np.ndarray, ...]:
         """A helper method to extract reduced set of data.
 
         Args:
             name: Series name to search for.
+            series: An integer array representing a mapping of data location to series index.
             x_values: Full data set of x values.
             y_values: Full data set of y values.
             y_sigmas: Full data set of y sigmas.
-            series: An integer array representing a mapping of data location to series index.
 
         Returns:
             Tuple of x values, y values, y sigmas for the specific series.
 
         Raises:
-            QiskitError:
+            AnalysisError:
                 - When name is not defined in the __series__ definition.
         """
         for idx, series_def in enumerate(self.__series__):
             if series_def.name == name:
                 data_index = series == idx
                 return x_values[data_index], y_values[data_index], y_sigmas[data_index]
-        raise QiskitError(f"Specified series {name} is not defined in this analysis.")
+        raise AnalysisError(f"Specified series {name} is not defined in this analysis.")
 
     def _run_analysis(
         self, experiment_data: ExperimentData, **options
@@ -641,7 +645,7 @@ def _run_analysis(
         # 2. Extract curve entries from experiment data
         #
         try:
-            xdata, ydata, sigma, series = self._extract_curves(
+            series, xdata, ydata, sigma = self._extract_curves(
                 x_key=x_key,
                 experiment_data=experiment_data,
                 data_processor=data_processor,
@@ -656,11 +660,11 @@ def _run_analysis(
         #
         try:
             # format fit data
-            _xdata, _ydata, _sigma, _series = self._pre_processing(
-                x_values=xdata, y_values=ydata, y_sigmas=sigma, series=series, **options
+            _series, _xdata, _ydata, _sigma = self._pre_processing(
+                series=series, x_values=xdata, y_values=ydata, y_sigmas=sigma, **options
             )
             # Generate fit options
-            fit_candidates = self._setup_fitting(_xdata, _ydata, _sigma, _series, **options)
+            fit_candidates = self._setup_fitting(_series, _xdata, _ydata, _sigma, **options)
             if isinstance(fit_candidates, dict):
                 # only single initial guess
                 fit_options = self._format_fit_options(**fit_candidates)
@@ -710,10 +714,10 @@ def _run_analysis(
             if plot:
                 figures.extend(
                     self._create_figures(
+                        series=series,
                         x_values=xdata,
                         y_values=ydata,
                         y_sigmas=sigma,
-                        series=series,
                         analysis_results=analysis_result,
                         axis=axis,
                         xlabel=xlabel,
@@ -730,10 +734,10 @@ def _run_analysis(
                 for series_def in self.__series__:
                     sub_xdata, sub_ydata, sub_sigma = self._subset_data(
                         name=series_def.name,
+                        series=series,
                         x_values=xdata,
                         y_values=ydata,
                         y_sigmas=sigma,
-                        series=series,
                     )
                     raw_data_dict[series_def.name] = {
                         "xdata": sub_xdata,
diff --git a/qiskit_experiments/characterization/t1_experiment.py b/qiskit_experiments/characterization/t1_experiment.py
index 510742cc97..2dd2738c57 100644
--- a/qiskit_experiments/characterization/t1_experiment.py
+++ b/qiskit_experiments/characterization/t1_experiment.py
@@ -69,7 +69,7 @@ def _run_analysis(
         offset_bounds=None,
         plot=True,
         ax=None,
-    ) -> Tuple[AnalysisResult, List["matplotlib.figure.Figure"]]:
+    ) -> Tuple[List[AnalysisResult], List["matplotlib.figure.Figure"]]:
         """
         Calculate T1
 
@@ -153,7 +153,7 @@ def fit_fun(x, a, tau, c):
         else:
             figures = None
 
-        return analysis_result, figures
+        return [analysis_result], figures
 
     @staticmethod
     def _fit_quality(fit_out, fit_err, reduced_chisq):
diff --git a/qiskit_experiments/characterization/t2star_experiment.py b/qiskit_experiments/characterization/t2star_experiment.py
index cc580b8fde..e7f8082847 100644
--- a/qiskit_experiments/characterization/t2star_experiment.py
+++ b/qiskit_experiments/characterization/t2star_experiment.py
@@ -45,7 +45,7 @@ def _run_analysis(
         plot: bool = True,
         ax: Optional["AxesSubplot"] = None,
         **kwargs,
-    ) -> Tuple[AnalysisResult, List["matplotlib.figure.Figure"]]:
+    ) -> Tuple[List[AnalysisResult], List["matplotlib.figure.Figure"]]:
         r"""Calculate T2Star experiment.
 
         The probability of measuring `+` is assumed to be of the form
@@ -127,7 +127,7 @@ def _format_plot(ax, unit):
         analysis_result["fit"]["circuit_unit"] = unit
         if unit == "dt":
             analysis_result["fit"]["dt"] = conversion_factor
-        return analysis_result, figures
+        return [analysis_result], figures
 
     def _t2star_default_params(
         self,
diff --git a/qiskit_experiments/composite/composite_analysis.py b/qiskit_experiments/composite/composite_analysis.py
index 33258c78bd..81bd3124ec 100644
--- a/qiskit_experiments/composite/composite_analysis.py
+++ b/qiskit_experiments/composite/composite_analysis.py
@@ -77,4 +77,4 @@ def _run_analysis(self, experiment_data: CompositeExperimentData, **options):
                 "experiment_qubits": sub_qubits,
             }
         )
-        return analysis_result, None
+        return [analysis_result], None
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index c926b42958..c2c654dc64 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -12,14 +12,11 @@
 """
 Interleaved RB analysis class.
 """
-from typing import List, Tuple, Dict, Any, Union
+from typing import List, Dict, Any, Union
 
 import numpy as np
 
 from qiskit_experiments.analysis import SeriesDef, fit_function
-from qiskit_experiments.analysis.data_processing import (
-    multi_mean_xy_data,
-)
 from qiskit_experiments.experiment_data import AnalysisResult
 from .rb_analysis import RBAnalysis
 
@@ -46,6 +43,7 @@ class InterleavedRBAnalysis(RBAnalysis):
             fit_func=lambda x, a, alpha, alpha_c, b: fit_function.exponential_decay(
                 x, amp=a, lamb=-1.0, base=alpha, baseline=b
             ),
+            filter_kwargs={"interleaved": False},
             plot_color="red",
             plot_symbol=".",
         ),
@@ -54,6 +52,7 @@ class InterleavedRBAnalysis(RBAnalysis):
             fit_func=lambda x, a, alpha, alpha_c, b: fit_function.exponential_decay(
                 x, amp=a, lamb=-1.0, base=alpha * alpha_c, baseline=b
             ),
+            filter_kwargs={"interleaved": True},
             plot_color="orange",
             plot_symbol="^",
         ),
@@ -68,20 +67,28 @@ def _default_options(cls):
 
     def _setup_fitting(
         self,
+        series: np.ndarray,
         x_values: np.ndarray,
         y_values: np.ndarray,
         y_sigmas: np.ndarray,
-        series: np.ndarray,
         **options,
     ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
         """Fitter options."""
         std_xdata, std_ydata, _ = self._subset_data(
-            "Standard", x_values, y_sigmas, y_sigmas, series
+            name="Standard",
+            series=series,
+            x_values=x_values,
+            y_values=y_values,
+            y_sigmas=y_sigmas,
         )
         p0_std = self._initial_guess(std_xdata, std_ydata, options["num_qubits"])
 
         int_xdata, int_ydata, _ = self._subset_data(
-            "Interleaved", x_values, y_sigmas, y_sigmas, series
+            name="Interleaved",
+            series=series,
+            x_values=x_values,
+            y_values=y_values,
+            y_sigmas=y_sigmas,
         )
         p0_int = self._initial_guess(int_xdata, int_ydata, options["num_qubits"])
 
@@ -95,19 +102,6 @@ def _setup_fitting(
 
         return {"p0": irb_p0, "bounds": irb_bounds}
 
-    def _pre_processing(
-        self,
-        x_values: np.ndarray,
-        y_values: np.ndarray,
-        y_sigmas: np.ndarray,
-        series: np.ndarray,
-        **options,
-    ) -> Tuple[np.ndarray, ...]:
-        """Average over the same x values."""
-        return multi_mean_xy_data(
-            series=series, xdata=x_values, ydata=y_values, sigma=y_sigmas, method="sample"
-        )
-
     def _post_processing(self, analysis_result: AnalysisResult, **options) -> AnalysisResult:
         """Calculate EPC."""
         # Add EPC data
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_experiment.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_experiment.py
index 1ac6d1afd1..b2932d994c 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_experiment.py
@@ -66,16 +66,14 @@ def _sample_circuits(self, lengths, seed=None):
             element_lengths = [len(elements)] if self._full_sampling else lengths
             std_circuits = self._generate_circuit(elements, element_lengths)
             for circuit in std_circuits:
-                circuit.metadata["series"] = 0
-                circuit.metadata["series_name"] = "standard"
+                circuit.metadata["interleaved"] = False
             circuits += std_circuits
 
             int_elements = self._interleave(elements)
             int_elements_lengths = [length * 2 for length in element_lengths]
             int_circuits = self._generate_circuit(int_elements, int_elements_lengths)
             for circuit in int_circuits:
-                circuit.metadata["series"] = 1
-                circuit.metadata["series_name"] = "interleaved"
+                circuit.metadata["interleaved"] = True
                 circuit.metadata["xval"] = circuit.metadata["xval"] // 2
             circuits += int_circuits
         return circuits
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index b68cf501f4..36b60a14ca 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -18,7 +18,7 @@
 import numpy as np
 
 from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, fit_function
-from qiskit_experiments.analysis.data_processing import mean_xy_data
+from qiskit_experiments.analysis.data_processing import multi_mean_xy_data
 from qiskit_experiments.experiment_data import AnalysisResult
 
 
@@ -45,10 +45,10 @@ def _default_options(cls):
 
     def _setup_fitting(
         self,
+        series: np.ndarray,
         x_values: np.ndarray,
         y_values: np.ndarray,
         y_sigmas: np.ndarray,
-        series: np.ndarray,
         **options,
     ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
         """Fitter options."""
@@ -79,15 +79,16 @@ def _initial_guess(
 
     def _pre_processing(
         self,
+        series: np.ndarray,
         x_values: np.ndarray,
         y_values: np.ndarray,
         y_sigmas: np.ndarray,
-        series: np.ndarray,
         **options,
     ) -> Tuple[np.ndarray, ...]:
         """Average over the same x values."""
-        xdata, ydata, sigma = mean_xy_data(x_values, y_values, y_sigmas, method="sample")
-        return xdata, ydata, sigma, np.zeros(len(xdata))
+        return multi_mean_xy_data(
+            series=series, xdata=x_values, ydata=y_values, sigma=y_sigmas, method="sample"
+        )
 
     def _post_processing(self, analysis_result: AnalysisResult, **options) -> AnalysisResult:
         """Calculate EPC."""
diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
index 83235376dd..3ab673d7b2 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -159,7 +159,6 @@ def _generate_circuit(
                 rb_circ.metadata = {
                     "experiment_type": self._type,
                     "xval": current_length + 1,
-                    "ylabel": self.num_qubits * "0",
                     "group": "Clifford",
                     "qubits": self.physical_qubits,
                 }
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index e1492808d9..489c1e3248 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -21,7 +21,7 @@
 from qiskit_experiments import ExperimentData
 from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, fit_function
 from qiskit_experiments.analysis.curve_fitting import multi_curve_fit
-from qiskit_experiments.analysis.data_processing import level2_probability
+from qiskit_experiments.analysis.data_processing import probability
 from qiskit_experiments.base_experiment import BaseExperiment
 
 
@@ -138,8 +138,8 @@ def test_data_extraction(self):
         for datum in test_data1.data():
             test_data0.add_data(datum)
 
-        xdata, ydata, sigma, series = self.analysis._extract_curves(
-            x_key="xval", experiment_data=test_data0, data_processor=level2_probability
+        series, xdata, ydata, sigma = self.analysis._extract_curves(
+            x_key="xval", experiment_data=test_data0, data_processor=probability(outcome="1")
         )
 
         # check if the module filter off data: valid=False
@@ -169,22 +169,22 @@ def test_data_extraction(self):
     def test_get_subset(self):
         """Test that get subset data from full data array."""
 
+        series = np.asarray([0, 1, 0, 2, 2, -1], dtype=int)
         xdata = np.asarray([1, 2, 3, 4, 5, 6], dtype=float)
         ydata = np.asarray([1, 2, 3, 4, 5, 6], dtype=float)
         sigma = np.asarray([1, 2, 3, 4, 5, 6], dtype=float)
-        series = np.asarray([0, 1, 0, 2, 2, -1], dtype=int)
 
-        subx, suby, subs = self.analysis._subset_data("curve1", xdata, ydata, sigma, series)
+        subx, suby, subs = self.analysis._subset_data("curve1", series, xdata, ydata, sigma)
         np.testing.assert_array_almost_equal(subx, np.asarray([1, 3], dtype=float))
         np.testing.assert_array_almost_equal(suby, np.asarray([1, 3], dtype=float))
         np.testing.assert_array_almost_equal(subs, np.asarray([1, 3], dtype=float))
 
-        subx, suby, subs = self.analysis._subset_data("curve2", xdata, ydata, sigma, series)
+        subx, suby, subs = self.analysis._subset_data("curve2", series, xdata, ydata, sigma)
         np.testing.assert_array_almost_equal(subx, np.asarray([2], dtype=float))
         np.testing.assert_array_almost_equal(suby, np.asarray([2], dtype=float))
         np.testing.assert_array_almost_equal(subs, np.asarray([2], dtype=float))
 
-        subx, suby, subs = self.analysis._subset_data("curve3", xdata, ydata, sigma, series)
+        subx, suby, subs = self.analysis._subset_data("curve3", series, xdata, ydata, sigma)
         np.testing.assert_array_almost_equal(subx, np.asarray([4, 5], dtype=float))
         np.testing.assert_array_almost_equal(suby, np.asarray([4, 5], dtype=float))
         np.testing.assert_array_almost_equal(subs, np.asarray([4, 5], dtype=float))
@@ -239,22 +239,21 @@ def test_run_single_curve_analysis(self):
         results, _ = analysis._run_analysis(
             test_data,
             p0=[ref_p0, ref_p1, ref_p2, ref_p3],
-            base_fitter=multi_curve_fit,
-            data_processor=level2_probability,
+            curve_fitter=multi_curve_fit,
+            data_processor=probability(outcome="1"),
             x_key="xval",
             plot=False,
             ax=None,
             xlabel="x value",
             ylabel="y value",
             fit_reports=None,
+            return_data_points=False,
         )
         result = results[0]
 
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
 
         # check result data
-        self.assertTrue(result["success"])
-
         np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=self.err_decimal)
         self.assertEqual(result["dof"], 46)
         self.assertListEqual(result["xrange"], [0.1, 1.0])
@@ -287,15 +286,16 @@ def test_run_single_curve_fail(self):
         results, _ = analysis._run_analysis(
             test_data,
             p0=[ref_p0, ref_p1, ref_p2, ref_p3],
-            bounds=([-10, -10, -10, -10], [0, 0, 0, 0]),
-            base_fitter=multi_curve_fit,
-            data_processor=level2_probability,
+            bounds=([-10, 0], [-10, 0], [-10, 0], [-10, 0]),
+            curve_fitter=multi_curve_fit,
+            data_processor=probability(outcome="1"),
             x_key="xval",
             plot=False,
             ax=None,
             xlabel="x value",
             ylabel="y value",
             fit_reports=None,
+            return_data_points=False,
         )
         result = results[0]
 
@@ -351,21 +351,21 @@ def test_run_two_curves_with_same_fitfunc(self):
         results, _ = analysis._run_analysis(
             test_data0,
             p0=[ref_p0, ref_p1, ref_p2, ref_p3, ref_p4],
-            base_fitter=multi_curve_fit,
-            data_processor=level2_probability,
+            curve_fitter=multi_curve_fit,
+            data_processor=probability(outcome="1"),
             x_key="xval",
             plot=False,
             ax=None,
             xlabel="x value",
             ylabel="y value",
             fit_reports=None,
+            return_data_points=False,
         )
         result = results[0]
 
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3, ref_p4])
 
         # check result data
-        self.assertTrue(result["success"])
         np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=self.err_decimal)
 
     def test_run_two_curves_with_two_fitfuncs(self):
@@ -414,19 +414,19 @@ def test_run_two_curves_with_two_fitfuncs(self):
         results, _ = analysis._run_analysis(
             test_data0,
             p0=[ref_p0, ref_p1, ref_p2, ref_p3],
-            base_fitter=multi_curve_fit,
-            data_processor=level2_probability,
+            curve_fitter=multi_curve_fit,
+            data_processor=probability(outcome="1"),
             x_key="xval",
             plot=False,
             ax=None,
             xlabel="x value",
             ylabel="y value",
             fit_reports=None,
+            return_data_points=False,
         )
         result = results[0]
 
         ref_popt = np.asarray([ref_p0, ref_p1, ref_p2, ref_p3])
 
         # check result data
-        self.assertTrue(result["success"])
         np.testing.assert_array_almost_equal(result["popt"], ref_popt, decimal=self.err_decimal)
diff --git a/test/test_t1.py b/test/test_t1.py
index 6ba8c416e3..665e6763cd 100644
--- a/test/test_t1.py
+++ b/test/test_t1.py
@@ -227,8 +227,8 @@ def test_t1_analysis(self):
             )
 
         res = T1Analysis()._run_analysis(data)[0]
-        self.assertEqual(res["quality"], "computer_good")
-        self.assertAlmostEqual(res["value"], 25e-9, delta=3)
+        self.assertEqual(res[0]["quality"], "computer_good")
+        self.assertAlmostEqual(res[0]["value"], 25e-9, delta=3)
 
     def test_t1_metadata(self):
         """
@@ -274,7 +274,7 @@ def test_t1_low_quality(self):
             )
 
         res = T1Analysis()._run_analysis(data)[0]
-        self.assertEqual(res["quality"], "computer_bad")
+        self.assertEqual(res[0]["quality"], "computer_bad")
 
 
 if __name__ == "__main__":

From 2cd91337abeca8016c12e516684355a9d889fb3d Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 3 Jun 2021 05:01:15 +0900
Subject: [PATCH 50/74] lint

---
 docs/tutorials/rb_example.ipynb               | 309 +++++++-----------
 qiskit_experiments/analysis/curve_analysis.py |   3 +-
 2 files changed, 113 insertions(+), 199 deletions(-)

diff --git a/docs/tutorials/rb_example.ipynb b/docs/tutorials/rb_example.ipynb
index 1196fda898..8edbd7ca73 100644
--- a/docs/tutorials/rb_example.ipynb
+++ b/docs/tutorials/rb_example.ipynb
@@ -45,31 +45,28 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: 703b5fd1-80a1-4e52-ab82-48e8f75ecbd9\n",
+      "Experiment ID: c5dd7ef9-9010-4018-b712-9af413ff3ebb\n",
       "Status: DONE\n",
       "Circuits: 140\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- popt: [0.43230292 0.99856134 0.55623197]\n",
-      "- popt_keys: ['a', 'alpha', 'b']\n",
-      "- popt_err: [0.12348736 0.00055429 0.12494436]\n",
-      "- pcov: [[ 1.52491284e-02  6.81301612e-05 -1.54265489e-02]\n",
-      " [ 6.81301612e-05  3.07233728e-07 -6.89998149e-05]\n",
-      " [-1.54265489e-02 -6.89998149e-05  1.56110931e-02]]\n",
-      "- reduced_chisq: 0.1438533698176071\n",
+      "- a: 0.45834121716795917 ± 0.12213198333255153\n",
+      "- alpha: 0.9981278928818351 ± 0.000703818873057736\n",
+      "- b: 0.5283572362051712 ± 0.12348653334949362\n",
+      "- reduced_chisq: 0.027050133485052932\n",
       "- dof: 11\n",
       "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.0007193320210475695\n",
-      "- EPC_err: 0.00027754263239147705\n",
+      "- EPC: 0.0009360535590824393\n",
+      "- EPC_err: 0.00035256948437020514\n",
       "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 576x360 with 1 Axes>"
       ]
      },
      "metadata": {
@@ -109,31 +106,28 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: ff2c526a-a888-45e1-a9bc-3c20c70176ce\n",
+      "Experiment ID: 813ee9fd-282b-40b6-be84-be661add9ca4\n",
       "Status: DONE\n",
       "Circuits: 100\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- popt: [0.70646921 0.97206894 0.26277466]\n",
-      "- popt_keys: ['a', 'alpha', 'b']\n",
-      "- popt_err: [0.01547605 0.00166093 0.00968495]\n",
-      "- pcov: [[ 2.39508071e-04  2.78505493e-07 -7.36601626e-05]\n",
-      " [ 2.78505493e-07  2.75867255e-06 -1.05750604e-05]\n",
-      " [-7.36601626e-05 -1.05750604e-05  9.37981598e-05]]\n",
-      "- reduced_chisq: 0.040350819405537176\n",
+      "- a: 0.7101000847314624 ± 0.01546721965247631\n",
+      "- alpha: 0.970965133698129 ± 0.0019052336560767267\n",
+      "- b: 0.26714473313054565 ± 0.01133624398164095\n",
+      "- reduced_chisq: 0.0408025199263645\n",
       "- dof: 7\n",
       "- xrange: [1.0, 200.0]\n",
-      "- EPC: 0.02094829359579109\n",
-      "- EPC_err: 0.0012814872009544206\n",
+      "- EPC: 0.021776149726403266\n",
+      "- EPC_err: 0.0014716545347155533\n",
       "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf0AAAGACAYAAACncLuXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAByeklEQVR4nO3dd5hcVfnA8e87s72mbxopgAmQBAgbCAkEEooighQpCiqIlICIUgQroj8FVARRwVANRQxNehEEQoAUyIaShEAgjfS+Sbbvzry/P86d7N3JzO5ssjszu/t+nuc+M3PbnDOzO+89554iqooxxhhjOr9AqhNgjDHGmOSwoG+MMcZ0ERb0jTHGmC7Cgr4xxhjTRVjQN8YYY7oIC/rGGGNMF2FBfw+IyA0i8vAenmOKiPyqrdJkjDHGxNNlgr6ITBeRrSKSneq0+KnqZFX9v9YeJyIqIpUiUiEiq0XkVhEJtkcaE0zLvql4b2OMMYnrEkFfRIYAEwAFvp7a1LSpg1S1ADgaOBu4IJlvLiIZyXw/Y4wxe6ZLBH3gu8BsYCpwnn+DiEwVkTtE5AUR2SEic0RkH9/220VkpYhsF5EyEZkQ6w28438Yte4jETlNnNtEZIN3nvkiMtL3/r/znvcSkedFpFxEtojIWyLS4nekqp8D7wAH+977JBH5wDvXTBE50LdtuYj8TEQ+9mo//ikiOb7tF4nI514anhWR/r5tKiI/EJHPgM9EZIa36UOv1uHs3c2HMcaY9tVVfoi/C/zLW74iIiVR278J/AboDnwO/N637T1cMO0BPAI87g+QPg8A3468EJGDgAHAC8CXgaOAYUAxcBawOcY5rgZWAb2BEuDnuNqJZonIfriajM+916OB+4FLgJ7AXcCzUbc2zgW+AuzjpeuX3rHHADd5aewHrACmRb3lqcBY4ABVPcpbd5CqFqjqo83lQ0TuFJE7W8qTMcaYttfpg76IHAkMBh5T1TJgCXBO1G5Pqeq7qtqAuzA4OLJBVR9W1c2q2qCqfwaygeEx3upZYJiIfMl7/R3gUVWtA+qBQmA/QFR1kaqujXGOelygHayq9ar6ljY/OcI8EakEFgHTgUgwvRi4S1XnqGpIVR8AaoHDfcf+XVVXquoW3EXOt7z15wL3q+o8Va0FfgaM826RRNykqltUtTpOuuLmQ1UvU9XLmsmTMcaYdtLpgz6uOv8VVd3kvX6EqCp+YJ3veRVQEHkhIteIyCIR2SYi5biSeq/oN1HVGuBR4NteVfa3gIe8ba8DfwfuADaIyN0iUhQjrX/CldZfEZGlIvLTFvJ2iJfWs3El73xv/WDgaq96vdxL915Af9+xK33PV/i29fdeR/JVgauVGBDn2Fhamw9jjDFJ0KmDvojk4qqpjxaRdSKyDrgSOMirfm/p+AnAtd45uqtqN2AbIHEOeQBXUj4WqFLVWZENqvpXVS0FDsBVp/8k+mBV3aGqV6vq3rgGh1eJyLHNpVGdx4BZwPXe6pXA71W1m2/JU9V/+w7dy/d8ELDGe74Gd9EQ+QzycbcIVvvftoU0tTofxhhj2l+nDvq4e88hXKA92Fv2B97C3edvSSHQAGwEMkTkeiBWCR0AL8iHgT/jlfIBRORQERkrIplAJVDj7deE1/huXxER3MVFKNZ+cdwMXCQifYF7gMnee4qI5IvI10Sk0Lf/D0RkoIj0AH6Bq6UA+DfwPRE52GsDcCMwR1WXN/Pe64G92ygfxhhj2klnD/rnAf9U1S9UdV1kwVW1n5tAl7P/Ai8Di3FV3jW0XLX9IDAK8A/aU4QLxFu982zGVYFH+xLwP6ACV3K/U1XfaOH9AFDV+cAM4CeqOhe4CJfPrbiq9vOjDnkEeAVYimvn8DvvPP8DfgU8CazFNfT7ZgtvfwPwgHcr4azm8iFuMKIpieTJGGNM25Lm24mZ1hKR7wIXq+qRqU5LPCKyHLjQC/DGGGO6iM5e0k8qEckDLgPuTnVajDHGmGgW9NuIiHwFd+9/Pa7q3BhjjEkrVr1vjDHGdBFW0jfGGGO6CAv6xhhjTBdhQd8YY4zpIizodxAiku3N1LfGmxnvTm+wn1j7TvBmvPMvKiLf8LaPFJH/isgmEdmlUYeI9BCRp0SkUkRWiEj0XAWtSbeIyB9EZLO3/MEbtCey/W4R+VREwiJy/u6+TyvTdLmIzBWRWhGZ2sK+zX7uzX1WIjLRy5f/e4geAro16T5Y3EyPVd7jwb5tV3pDHm/30npbAuNQGGO6mC4b9EVkf3HTwHaUz+CnwBhgJG4Y30PwZsaL5k1wUxBZgJNwA+W87O1SDzwGfD/Oe90B1OFmyDsX+IeIjNjNdF+MGxnxIOBA4GTc7H8RH+K6Oc5rzUm9gDp9N9O0BjcY0f0J7NvS597SZ7XG/114kx+1mohkAc/gBn3qjhvy+RlvPbgJnw5R1SIvrQcBV+zOexljOq+OEvDaQwlwBvCwiJzlL322RESOF5GF4ibhuVdEDhKR2e2XVMAFy796s9ttBP4KXJDgsecBT6hqJYCqfqqq9wELo3cUN9b+N4BfqWqFqr6NCyjf8e1zgbhJiLZ6NQaDo88T9d5/VtVVqroaN0Tx+ZGNqnqHqr6GG+0wKVT1P6r6NLGnN44W93NP5LNqjoj0F5EnRWSjiCwTkeaC9EQgA/iLqtaq6l9xc0Ac4+VpiaqWR06NG/Z430TSYYzpOrpy0Ad4E1c6CwP/EpEzWwr+ItIPeAr4MW7muUNwg/E8HWf/QeKb7S7G0pqqc4l6PlBEiltIbz7u4ibREuYwoEFVF/vWfQiM8M53CvBz4HSgN24eg39Hn8RnhHf8LufqQOJ97s1+Vp4+IrLeC+q3ed8HXg3Tc97+A3CTNP3YG+8hlhHAR1FTLX/kfy8ROUdEtgObcCX9u3Yjr8aYTqyrB/3ILHVP4II/uOB/RjPB/wRgkaq+6k07+whwGHGCvjfuf7dmlkQH8nkZ+JGI9BY3qU6kVJjXwnGn44LAmwm+TwGwPWrdNtzkQwCTgZtUdZGqNuAm5Dm4mdJ+gXe8/1wFralZiRCRn0rjVMHPA0dK0+mD20Nzn3tLn9UnuEme+uFK5KXArd62Q4HeqvpbVa1T1aW4+RnizXMQ/TlGvxeq+ohXvT8MmIIbKMoYY3bq8kE/wgv+j+OCfwB4UkROjrFrCbDM9/pDYLGqftLOSfw98D7wATATd5FRT8s/7OcBD0aVEJtTwa4zCRYBO7zng4HbfYF2C670O0BEfu5rsDYlzvmKgIpWpGcnVb05crGEa6fwtv8CqrXnS1Bzn3uzn5U3wdPHqhpW1WW4aZq/4e03GOgfddHyc9zfF1GN/wa19F5+qvoZ7tbNnXuQb2NMJ2RBf1f9gbHAcmI3LluPa0gVsR9u6tiYvOr96Jb0/uXceMf6qWq1ql6uqgO8eeo3A2WqGnfKWhHZC3cv+MFE3sOzGDeN8Jd86w6i8f7/SuCSqNqKXFWdqao3+hqsTfb2X+gdH+tcaa+Fz72lz2qX09H4P7cSWBb1ORaq6one+/ob/33hnfPAqBqSA5t5rwzcDInGGNNIVbvkgguGl/te9wduAW4D9mrmuAG4Kt29cT+sHwLlQEk7p3eAl0YBDscFjS+3cMzPgRkx1guQAxyAC0Q5QLZv+zTcffp84AhcNfIIb9tpwALf62LgzGbSMBlY5Ev/QmCyb3uW9/7v4KYDzgEC7fxZZnjvcxPwkPc8Y3c+9xY+q0m4Er0AewFv4KZ6BgjiLiqvA3K91yOBQ+OkIws3LfOPgGzgcu91lrf9QqCP9/wA73O+NdX/Z7bYYkt6LSlPQMoy7gV9oC/wR+AvwKAEjz0TV+X7iXeh8APv+d7tmN6jcLUPVcCnwLlR218Cfh617hPg+zHONcQL9v5luW97D1w1diXwBXBO1PHfAebjLn5WAvc3k27xPt8t3vJHvDkfvO3TY6RlYpxz/RxXzR1zacVneUOM97zB2xapSh+U4Oce97MCrgJWe8euxLX8L/Rt74+7YFgHbAVmA8c1k+7RQBlQjbtgGO3b9k9cLVSll94/ATmp/j+zxRZb0mvpshPuiMhE4GZgDq5EtCKlCTLGGGPaWVcO+gOATFVdnuq0GGOMMcnQZYO+McYY09VY631jjDGmi7Cgb4wxxnQRFvSNMcaYLsKC/m4QN01tZdQgO9d6224QkXpvXbmIzBSRcb5j+4nIfSKyVkR2iMgnIvKbyJjs7ZTer4nI21561nmTBBU2s///ich8EWkQkRuitv08Kt/V4qaP7eVt7yEij4qbRneTiPxLRKJHkmtN2o/1PqMqEXnDP9yviNwiIp/5Psfv7u77tCI9zU5L3Mxx3/X+bi70rXsp6rOsE5H53rY+IvJvcdPkbhORd0Rk7B6kWyTOFMci0ss7/2bvb2SWiByxu+9ljElfXTboy55PrXuQNh017Y++bY+qm9K2N/A28B/vR7cHMAs3GMs4VS0Ejge60b6jpxXjppLtD+yPG3DmT83s/zluyNgXojdo01H3CoA/ANNVdZO3y+9wIxYOxeWpBNcvvtW8C4n/AL/C9YefCzzq26USNwteMW644dtFZHyC514uIkN2I1ktTUsc672648YYaDJ6nqp+NeqznAk87m0uAN7DjdffAzdh0gsiUrAbaYbmpziuwM0c2Bv33f0BeE5EMnbzvYwxaarLBn32YGrdRKlqPe7Hui/QEzdYyw7g25Gugqq6UlV/pKoftfX7+9LxiKq+rKpVqroVN7FL3JKcqj6gqi8RY1x3P+8z+y5NZ/AbCjytqttVdRtuRkL/THD7icirIrJFRD4VkbOaeYvTgYWq+riq1uAuHg4Skf28dP5aVT9RN7b9HNyMf+Pin27PaTPTEjfjJtzAPJvi7eBdgEzAGzJZVZeq6q2qulZVQ6p6N25UvuG+Y9pkimNVrfHyFcYNphTCBf8ercijMaYD6MpBH3Zjat3WEJFs3A/rSq8kfBzwH21mvPwY52huWt6f7mbSjqJtxr+fAPQBnvStuwM4SUS6eyXcb+BGC4xM8/sqbmbCPrgZ5e4UkQPinL/JtLyqWgksIcbUvCKSi5u5Lq3G9ReRw4AxuFnvmvNd4K1440aIyMG4oP+597rNpzgWkY+AGuBZ4F5V3dBCmo0xHUxXD/qo05qpdSPmRQVg/zzoZ4mbNW0lrnr2NG99T2BtK9PXrZnl5tacC0BEjseV+q5v7bExnAc8oW6K4Yh5uOC02VtCNM72dhJuuN9/qmqDqr6Pu2A4M875W5xO1mcKLpD9N9aJxE185J/RbhDwkW/dOS3ktdVEJIjL++UJXOh9F5ga5zxFuDkCfuPVnkA7THGsqgfiZu47B3dbyhjTyXT5oB/hBf9EptaNOCQqAPuDzWPeuj6qeoyqlnnrN+PmVk8JETkcV8o+Q1UX7+G58nDB+oGoTY/hZp8rxAWQJcDD3rbBwNio4Hsu0FeiZiP09k9oOlkR+RNuspqzNM5oU6r6hTadhvcL4EDfukda+xkk4DLgI1Wd3dxOInIk7hbQEzG25QLPAbNV9SbfpnaZ4tir6v838FMR8c+OaIzpBKyhzq5amlp3T/wPOE1EfpNoFb8vAMZyo6remOB5RuOqbS9Q1dcSOaYFp+ECzfSo9QcDP/Cq4vGCTqTUuBJ4U1WPj3PO6EZqC3G1CXjnysc1DlzoW/cb4KvA0aq6fXcy0o6OBY4WkRO91z2A0SJysKpe7tvvPNxtnybftXd76GlgFY2N7iJWAr9X1X/FeN+ZuJK/X2SK43e91y1NcZyJm0nyw2b2McZ0MFbS94hIfxG5BbgG+IuqXuU1eGpLt+JKWA9EqmFFZICI3CoiB8Y6IKqHQPSSaMAfCbwM/FBVn0tg/0wRycH9fWSISI5XVe13HvBgjJL1e8CFIpLrlVIvBiKNFJ8HhonId7z3yBSRQ0Vk/zhJeQoYKSLf8NJzPa7k/ImXzp/hqqKPU9XNLeXLT1WHxLt/3hyvF0YO7hYG3meTHWf383G9JQ72lrnAb4Bf+M6XC5xFVNW+iGTiSv7VwHkxLhKnAD8TkRHe/sUiEu82CbgGgld5f2/9gasj7ykih4vIkSKS5X1v1+Eaus5p5nzGmI5I02Cqv1Qs7NnUuorrLuaf2vUv3rYbgIebObY/cD9uOtUduOlvfw3ktWNe/4lrrOhP70Lf9inAFN/rqew69ez5vu0DgAZg3xjvNRRXHb0ZVxPwMvAl3/bhuK6AG719XgcObibtx3mfUTWuVmFI1PdQG5Wvn8c5zyCamZaXqClzm0nPkBifzXLf9l2mOPZtmw5cGLXuW8AKfNMNe+uP9s5dFZXOCb592mSKY++9PvT+HrfgGrgeler/UVtssaXtly474Y7Y1LrGGGO6mK4c9G1qXWOMMV1Klw36xhhjTFdjDfmMMcaYLqLLBn2vD/PeqU5HuhCRiSKyKtXpMMYY0346fdAXN7FKtTSdzay/ui5vS719porI71Kd1q5Ampk1L8a+Q7x9qrxjjouz32viZrDLSORYr9vd70RktbgZ7KZHur4ZY0xn1umDvudkbdq/fU2qE9TeYvSrTzlpeda8aP8G3scNX/wL4AkR6R11znNxA8m05tgzcbPKTfDSMQs3zK0xxnRqXSXo78IrGe4rIhfjhoK91qsF2GXwGhF5U9xsZpGBUPp5JcjD45z7fBFZKm6e92VeYEJEguLmgN/kbf+Bv4Tq1Ur4S6Q3iMjDvtePi8g6r3Q6w1869Wor/iEiL4pIJTDJG3DoSRHZ6KXjCt/+ud4xW0XkY9xkNe2t2Vnz/ERkGHAI8GtVrVbVJ3F90r/h26cYN8bBta08dijwtrqZ7EK4YYLjTfpjjDGdRpcN+hHqpiz9F/BHrxYg1nj7x+CGQ73Be30dMENjjKkubqjYvwJfVdVCYDzwgbf5ItykM6NxM6+d0crkvgR8CTdD3Twv3X7nAL/HjXs/EzdIzoe4wXSOBX4sjRMD/Ro3pO0+wFfwDXcbi4j4J6eJXu5s7lifhGfN89YtVVX/OPvRM8PdCPwDN9BRa46dBuwjIsO8ke/Oww0iZIwxnVpXGXv/aRFp8J5PV9VTW3OwqobETeqyVES+hBta9phmDgnjho/9QlXX0jiz3lm4kftWAojITbiRARNNx/2R5yJyA7BVRIq1cea1Z1T1HW/7KKC3qv7W27ZURO7BTWf7Xy8tl6nqFmCLiPyVZmbeUzcD254qwI3E5xdv1rx4M+wNABCRMcARwI+Aga05Fvd9vA18ipsFcCXNf5/GGNMpdJWS/qnaOJvaqbtzAi84voMbP/6tSClfRKb4Ggj+3Cu9no2b+nStiLzgq77ujwswEQmPAujdGrhZRJaIyHbchEAAvXy7+c89GOgvTWe0+zluTPU9SsseSGjWvJb2FZEAbsraH6mbVra173M97nbGXkAObjz818XNHGiMMZ1WVwn6LUl0hKJHgWE0VvOjqpM1agIcVf2vupnk+uHGjb/H230tLtBEDIo6fyXgDzx9fc/PAU7BjUVfjBsDHtyY6rHysRJYpk2n/y1U1ciMby2lpQkRWShNe0D4lynNHesTmektcs5dZs2L2ndvEfHXAkRmhivC3R55VETW4Sb5AVglIhNaOBbc5DePquoqVW1Q1alAd+y+vjGmk7Og76zHTSPakgNx1cFx56IXkRIROcULaJHJYCIzpD0GXCEiA0WkO/DTqMM/AL4pbva56Hv+hd75NuMuDFqaYe9dXKn4Oq/RXlBERopIpMHeY7hZ2rqLyEDgh82dTFVHaPzZ/ia3kJaIZmfNi3q/xbjP49fiZrI7Dff5P4mrqu9P4+x1kQuZUmBOC8eCu0g40/uuAiLyHVwPgM8TzIcxxnRIFvSd+4ADvGrwp2PtICJ9gEuBz/C1II8hAFwFrMHNWHa0dxy4Ev9/cY3K5uG6r/n9Clfy3Yqrcn7Et+1BXBX8auBjYJdGhH5eq/STcEFxGbAJuBdXS4B3/hXetldIQpc1Vd2I++x+j8vjWFwbA2DnrRJ/rcE3cSX6rbjJkc5Q1Y3qrIssNLYTWK+qdc0d6237A+47+AAoB64EvqGq5W2bY2OMSS829n6CROSPuCDyN+AKVZ3UBuccggu6mXHuTRtjjDFtxoJ+AsQNKrMcV408B3c//AxVfX0PzzsEC/rGGGOSxKr3E3MN8J6qzlDVWtxgMI+LyE9SnC5jjDEmYZ26pN+rVy8dMmRIm5yrsrKS/Pz8NjlXqlle0pPlJT1ZXtKT5SW+srKyTaraO9a2Tj04z5AhQ5g7d26bnGv69OlMnDixTc6VapaX9GR5SU+Wl/RkeYlPROKOu2LV+8YYY0wXkfSgLyJHiciz4qY1VRE5P4FjRomb9KbaO+56EZGWjjPGGGNMo1SU9AuABbgx06tb2llEioBXcQPoHOod9xNcX3hjjDHGJCjp9/RV9UXgRXDTwSZwyLm4EejOU9VqYIE3lv1VInKrduaWiMYYY0wb6gj39MfhJrjx1wr8FzcM65CUpMgYY4zpgFLaZU9EKoDLvQlP4u3zCrBKVS/wrRuEG0J2vKrOitr/YtzUt5SUlJROmzatTdJaUVFBQUFBm5wr1Swv6cnykp4sL+nJ8hLfpEmTylR1TKxtna7LnqreDdwNMGbMGG2rbhDWPSQ9WV7Sk+UlPVle0lMy89IRqvfX0TgHfESJb5sxxhhjEtARgv4sYII3FWvE8bhZ7JanJEXGGGNMB5SKfvoFInKwiBzsvf8g7/Ugb/tNIvKa75BHgCpgqjcf/Om4eehT2nLfOg0YY4zpaFJR0h8DvO8tubh53d8Hfutt74ebUx4AVd2GK9n3B+YCdwB/Bm5NVoLLysqorKykoUGpqnIBf9asWZSVlSUrCcYYY8weS0U//elA3NH0VPX8GOvmA0e1X6riU1Vqa2uprq7m7bdnM3To4axaNYuFCxcwcuRIVBUbHNAYY0xH0Ola77c1ESErK4tAIMDChQuZMWMFPXtW0q1bPllZWRbwjTHGdBgdoSFfSqkqS5cupb6+noqKCkKhAJs317B+/XqWLl1q9/aNMcZ0GBb0EzBgwABCIeHtt4fxyitDmDFjf7ZuFQYMGJDqpBljjDEJs+r9FqjCjTfmcOyxvXnhhaNRFTIy6nnzzQnMm/cRzz0HVsNvjDGmI7CSfguuv1753/8ORFVQDQBCQ0MWDQ2Z/O9/B3L99Va9b4wxpmOwoN+MrVvhz38W6uoyY26vq8vkz38WysuTmy5jjDFmd1jQb8YTT0Aw6J5XVMQO/MEgPP54EhNljDHG7CYL+s1Ytw6qqtzzJUu6xdynqsrtZ4wxxqQ7C/rN6NsX8vLc8+HDt8TcJy/P7WeMMcakOwv6zTjjDAiF3POcnFDMfUIhOPPMJCbKGGOM2U0W9JvRvTtcc42Qlxe7hX5urnL55UK3bslNlzHGGLM7LOi34IYbwhx9dBkiSkZGnbdWCQQaOOyw+UyeHE5p+owxxphEWdBvQSAgfP3rcykp2cAJJ/yPgoIKQPjKV17hhBM+oL5eqKtr8TTGGGNMylnQb4GqUlRURCAQZuzYhYwd+zkAK1YMobCwEBGlsjLFiTTGGGMSYEG/BYFAgJycHLKzsykuLuaAA1YDsHz5vmRk5JCbG7DBeYwxxnQIFvQTcNppp+2cXrd37x306rWdqqosevQ4gYwMqKvDqviNMcakPQv6LVBVZs2aRU1NDSNGjOCss85mwgRXn//gg+tRVQIBrIrfGGNM2rOg3wIRITs7m9zcXMaPPxwQzjvPjcbz7rs9ACEnx43Tb4wxxqQzC/oJKC0tJT8/n6wsITMTDjpI6N1b2bAhi48/duPvNzRAbW2qU2qMMcbEZ0G/lYqLXYD/8pcFgP/+160PBKCiIoUJM8YYY1pgQb+V8vPd0Ltf/rJ7/dJL7jE7G7ZtA409eJ8xxhiTchb0Wyk725XqjzgCCgrg449h2TJXxV9fb1X8xhhj0ldKgr6IXCYiy0SkRkTKRGRCC/v/QEQWiUi1iHwqIt9NVlp3TQsUFrrH44936154wT0Gg1bFb4wxJn0lPeiLyNnA7cCNwGhgJvCSiAyKs/+lwB+A3wIjgF8Dd4jIyclJ8a4KC919/ZNOcq8jQT8nx6r4jTHGpK9UlPSvAqaq6j2qukhVfwisBS6Ns/93gHtU9d+qulRVpwF3A9clKb27yMlxgf3oo909/o8+gi++cNX+DQ1QU5OqlBljjDHxJTXoi0gWUAq8ErXpFWB8nMOygegwWg0cJiKZbZvCxASDkJvrHo87zq2LlPYzMlxp3xhjjEk3okmsixaR/sBq4GhVneFbfz1wrqoOj3HMjcD3gZOAubiLhueBEqC/qq6N2v9i4GKAkpKS0mnTprVJ2isqKigoKNj5OhRypfp33unF//3fSIYP387f/jYPgHDYNfhLV9F56cgsL+nJ8pKeLC/pqa3zMmnSpDJVHRNzo6ombQH6AwocFbX+euDTOMfkAvcD9UAD7qLhD955Spp7v9LSUm0rb7zxRpPXtbWqn36q+vnnqrm5qqA6Z47q6tWqn3yiumNHm711m4vOS0dmeUlPlpf0ZHlJT22dF2CuxomLyb6nvwkI4UrpfiXAulgHqGq1ql4A5AFDgEHAcmAHsLG9EtqSrCxXlZ+VBcce69ZFqvizsrCZ94wxxqSdpAZ9Va0DyoDjozYdj2vF39yx9aq6SlVDwDeB51U13D4pTUxxseuXH2nF//zz7jE7203AU1+furQZY4wx0VLRev9W4HwRuVBE9heR23HV/lMARORBEXkwsrOIDBOR74jIl0TkMBGZBowEfp6CtDeRl+fu7R97rGvRP28erF7ttolAVVVq02eMMcb4JT3oq+qjwI+BXwIfAEcCJ6rqCm+XQd4SEcR18/sQeBXIAcar6vLkpDi+nBzXTS8nB445xq178cXGbTbznjHGmHSSkhH5VPVOVR2iqtmqWqq+lvyqOlFVJ/peL1LV0aqap6rFqnqqqn6ainRHE4GiothV/BkZbr0Ny2uMMSZd2Nj7e6iw0FXxH3ecK93PndtYxW8z7xljjEknFvT3UE6Oe8zLaxyo59ln3WNurmvFb8PyGmOMSQcW9PdQIOBK+7W1cNppbt1TTzVua2iA6urUpc8YY4yJsKDfBoqKXHCfNMk9X7gQPvvMbcvMtD77xhhj0oMF/TYQqeLPzoYTT3TPn366cd2OHe6iwBhjjEklC/ptIBh09/Rra+HUU926p5929/JF3FJZmcoUGmOMMRb020y3bm4EvvHjoU8fWL4cPvjAbcvJgS1bUpg4Y4wxBgv6bSZSxR8Mwsknu+eRKv6MDKirsz77xhhjUsuCfhvJyHCBv66usRX/s8+6PvzgLga2b09d+owxxhgL+m2oWzcX9A8+GIYMgQ0bYKY3jVBODmzbBuGUThFkjDGmK7Og34Zycxsb751yilv3zDPuMRBwpf6qqqYj9aiN3GOMMSZJLOi3ocxM10Wvvr6xFf8LL0BNjXv+6afz+d//5u4M9KrKrFmzKCsrS02CjTHGdCkW9NtY9+6uwd6wYTBihLuP/+qrLsCr1vDRR0uYMWP2zoC/YMECamtrrcRvjDGm3WWkOgGdTV5e41j7Z57pRud7/HE4+WQhKyuLgoJcyso+5dNP5wNQUFBAVlYWIpLCVBtjjOkKrKTfxjIz3b39+nrXij8jA6ZPhw0blLq6Omprt7NpU4hwGCoqKtixYwd1dXVW0jfGGNPuLOi3g27dXBV/r15wzDGuAd9TTwmlpaUUFRVQXV3PunXbqKmpobCwkMMPP9xK+sYYY9qdBf12EF3FD/D440pZWRmVlZXk5QXJzu5HTk4OFRUVzJ4920r6xhhj2p3d028HGRmuir+uDo491pX8Fy0SVq4sIj8/H1WltjaToqJCCgry7Z6+McaYpLCSfjuJDNSTnd3Yfe+VV4rZsWMH++23H9/85lkMHXog27dvt3v6xhhjksKCfjvJy2t8Hqninz69O3l5RZSWlpKXJ+y776EUFBSxbt06K+kbY4xpdxb020lGhgv8dXVw0EHwpS8pO3ZkM29eMV/9agVnnqnMm/cBW7bU0LdvXyvpG2OMaXcW9NtRcbEL+iJw5pmuJL948UFUVVWxYcN6li79hIEDRzFu3Dgr6RtjjGl3KQn6InKZiCwTkRoRKRORCS3sf46IfCAiVSKyTkQeFpG+yUrv7oqMxQ9w+ulu/P2ysu6EQi7AZ2SE2X//UurqLOAbY4xpf0kP+iJyNnA7cCMwGpgJvCQig+LsfwTwEPAAMAI4FTgA+Fcy0rsnMjKgoMD12e/XD0aP3k5dnVBRkbtzn5dffp7p099PYSqNMcZ0Fako6V8FTFXVe1R1kar+EFgLXBpn/3HAKlW9TVWXqeps4G/A2CSld49EWvGHw2GGD3cT65SX51NbW8IHH4xgyZJVzJq1iPp6m3PXGGNM+0pqP30RyQJKgVuiNr0CjI9z2DvAjSJyMvA80BP4JvBie6WzLeXmump9VWHz5v6AEgoFWb1aeeKJkaiOYtKkZVRUCN27pzq1xhhjOrNkl/R7AUFgfdT69UDMe/SqOgsX5P8F1AEbAQHOa79ktp1AwDXo+8MfhBkzhuGSDiDU12fS0JDB22/vy69+JVgDfmOMMe1JktlVTET6A6uBo1V1hm/99cC5qjo8xjEHAK8CfwH+C/QD/gR8oKrfjbH/xcDFACUlJaXTpk1rk7RXVFRQUFCwW8fW18P8+a5R38aNufzhD2PJzAzx61/PJCcn5KUbRo1yE/a0tz3JS7qxvKQny0t6srykp7bOy6RJk8pUdUzMjW6e9+QsQBbQAJwZtf4O4M04xzwEPBW17khAgYHNvV9paam2lTfeeGO3j73rLtXc3LC6sB97yc0N6803t1lym7UneUk3lpf0ZHlJT5aX9NTWeQHmapy4mNTqfVWtA8qA46M2HY9rxR9LHhCKWhd53SHGGVi/Hmpqmt+npgZWr3Yt/Y0xxpj2kIqgeStwvohcKCL7i8jtQH9gCoCIPCgiD/r2fw44RUQuFZG9vS58fwXmqeoXSU/9bujbF3Jzm++Ln5srlJTAtm1JSpQxxpguJ+lBX1UfBX4M/BL4AFdVf6KqrvB2GeQtkf2n4rr5XQ4sAJ4AFgOnJCvNe+qMMyDcQo+8UAhOOw3Ky91zY4wxpq2lpHpcVe9U1SGqmq2qpepr1KeqE1V1YtT+f1PVEaqap6r9VPVcVV2V9ITvpu7d4ZprICurIeb2zMwGJk92ffoBtm9PXtqMMcZ0HR3innhncMMNYb761U8IBhsQCQOKiOs5MWzYRq6+2lUF5ObCli0t1wwYY4wxrWVBP0mCwQD/+c8B/P73L1NcvI2iou2MHPmxt7UvgUDA2w8aGqCyMnVpNcYY0zlZ0E+i999/n9Gju1NQUElx8Q6+/OXpFBXVs3ChMHdu4345ObBpU+NkPcYYY0xbsKCfJKrK559/zuzZb3j9JQFq2X//DwCYOrUxwmdmuvH6q6tTklRjjDGdlAX9JAmHw2zatAnVECIQDGYQCAQYNep9RMK88AJs3Ni4f1aWu7dvjDHGtBUL+kkSDAbp27cvPXv2JBgM09AQQkQYMiSTAw/cQH298MgjjftnZ0NFhQ3WY4wxpu1Y0E+iwYMH0717dy666GG+9a2nCIUCFBcXc+aZrtXeQw+5RnwRmZmwdWuKEmuMMabTsaCfJOFwmMWLF7N06VKCwSADBuShmsWKFSsoKvqIoUOVtWvh1Vcbj8nJcX326+tTl25jjDGdhwX9JBERgsEgmZmZZGVlkZMTIjMzk4yMTDIyApznTRQ8dar/GDc1rw3Na4wxpi1Y0E8SEWHfffdlwoQJFBQUEAgoPXtmMHr04QwdOpSzzhJyc+Htt+GzzxqPiwzW0xB7MD9jjDEmYRb0k+iQQw5BpHHindzcekKhAKNGjaK4GE4/3a2/777GY0TcYkPzGmOM2VMW9JNEVZk1axYLFixg5MiRXHTRRYwevT9Ll37KnDlzUVUuvNDt+/jjTbvr5ebC5s02EY8xxpg9Y0E/SUSE7OxsRo4cybhx4xARxo8fR2np3kAOIsKwYTBpEtTUwMMPNx7rjdBrpX1jjDF7xIJ+EpWWlu4M+OAuBI499jBGjBi1c8jdiy92j1OnulH5InJyXGnfJuIxxhizuyzoJ5n/nj5AZqZQXOxK9wATJsB++8H69fDss437BYOuer+iIomJNcYY06lY0E8DxcWNrfNF4KKL3PN77mk66U5enpuIx0r7xhhjdocF/TSQk+PG2o8E/lNPhV69YMECmDWrcb9g0A3UY9PuGmOM2R0W9NOACPTs2VjFn5PDzsF67rmn6b65uW5iHpt21xhjTGtZ0E8T+fku+EeC+Xe/6ybdefVVWLKkcb+MDFfa37HDvdao6B/92hhjjImwoJ8mgkGaNOjr1Qu+8Q13EXD33U33zc119/bfe6+MWbNm7Qz0kbEAysrKkpx6Y4wxHYEF/TTib9AHcMklrvT/2GOuNX+EK+0r5eX1LFiwYGfgjwz+U1tbayV+Y4wxu8hIdQJMo+xsdz+/rs417Nt3X/jqV+HFF+Hee+EXv2jcNzdX2HvvseTmhlmwYAELFiwAaDL4jzHGGONnJf0007Mn1NY2vv7BD9zjgw82nW0vIwMaGoRRo8Y1Od4CvjHGmHhSEvRF5DIRWSYiNSJSJiITmtl3qohojKVTdlzLy3MBPTLO/sEHw5FHukF5Hnig6b65ucp//zuvSb99/z1+Y4wxxi/pQV9EzgZuB24ERgMzgZdEZFCcQ34E9ItalgKPtX9qky8QgB49oLq6cV2ktH/vvY3rVZX335/LokWL2Xvvg7jooosYOXIk8+fPt8BvjDEmplSU9K8CpqrqPaq6SFV/CKwFLo21s6puU9V1kQXYB9gbuCfW/p1BYaF7jMTtCRPgoIPc2PuPPurWiQgbN26kR48chg49FFXh8MMPp7CwkHXr1lkVvzHGmF0kNeiLSBZQCrwStekVYHyCp7kIWKiqM9sybekkIwO6dWvsvifSWNr/xz9cP31VpXfv3lRXV1JW9gHl5crs2bOpqKigb9++VtI3xhizC0lmcBCR/sBq4GhVneFbfz1wrqoOb+H4YlytwM9U9fY4+1wMXAxQUlJSOm3atDZJe0VFBQUFBW1yrkSougZ9waB7HQ7DhRcexqpVeVx77SKOO8714auqqqK6ugZVISMjRF5eLvn5+c2eO9l5aU+Wl/RkeUlPlpf01NZ5mTRpUpmqjom1raN12fs2rnbioXg7qOrdwN0AY8aM0YkTJ7bJG0+fPp22OleiVq50/fazs93rq65yyxNP7M/ll+9PMAjhcJhHHnmE2togeXl1XHnl6QQCzVfgpCIv7cXykp4sL+nJ8pKekpmXZN/T3wSEgJKo9SXAugSOvwh4UlW3tHXC0lHPnq7PfsTpp8OgQbB0KTzzDHz44Yc888wzAGRlhaiszOHhhx9l7ty5KUqxMcaYdJbUoK+qdUAZcHzUpuNxrfjjEpHDgIPoxA34ouXmQmZm4yh9mZnwox+557fdpnz++VJWrlzJPfd8haefPpeCglwWLVrP4sWLCdv8u8YYY6KkovX+rcD5InKhiOwvIrcD/YEpACLyoIg8GOO4i4HPVHV68pKaWiJuDP5Igz5w4/G70r6wcuUh7LXXXoRCITZsWE9d3TZ69tyHIUOGt1jFb4wxputJemRQ1UeBHwO/BD4AjgROVNUV3i6DvGUnESkEvgncm7SEpomCAtd3P1Jw95f2//OfwZx00ilEeucFAsIpp3yNwYNLU5NYY4wxaS0lxUFVvVNVh6hqtqqW+lvyq+pEVZ0Ytf8OVS1Q1T8mPbEpFgi4e/tVVY3rIqX9JUvg9tuXNdn/44/L2L5dmwzuY4wxxoCNvd8hFBW5x0jvysxMuOIK9+KBB3pSVVVMXV0JK1YcwTvvLOC1155n3TrFuuobY4zxs6DfAQSDuw7Ne/rpkJtbx5Yt3Vi3LodVq+C++wZx223f4cUXh1FdDTt2pC7Nxhhj0o8F/Q6iuNjd14+U3m+/XWhoyPS2CiDU1gZpaMhg+vRhTJkibNzYOHGPMcYYY0G/g8jMdIG/pgbKy2HKFKivjz2+fnW1cPfdsHVr0+l4jTHGdG0W9DuQbt1cn/0XXmgcnjeeYBBefx02bnRj9RtjjDEW9DuQ7GzXhW/NGqiubr6VXnW1snGjC/6bNycpgcYYY9KaBf0OpmdP6N7djdbXnNxc6NMH8vLc7QDrwmeMMcaCfgeTk+Na7odCse/nR4RCwkknNR6zfj3Whc8YY7o4C/od0L77wve+B7m5saN4To4yebJr+AeQleWm6d2+PYmJNMYYk3Ys6HdAOTnw058qX/3qWjIyGhAJA+o9woABlVxzTdMLgrw82LChcfIeY4wxXU+rgr6IHC4iN4jIyyLykYh8JiKzRGSqiHxPRLq3V0JNU717w9ChzzN58t307VvLwIFw1llrEAmzdGken3/edP9g0E3gY436jDGm60oo6IvIeSIyHzf97ZVAHvAZMAfYCozFTYaz2rsAGNpO6TWe7OwwublKIFBHdnY5AwbAqFGvMmrUfFQD/O53ux6Tm+v67tu9fWOM6ZpaDPoi8hFwM/AiUAp0U9WjVPUbqvptVT1RVfcHegAXAX2Aj0Xk7PZMeFcXDAa57roLKSrqSUNDA6tXr2Lr1q2ceOLHFBQor70mzJjR9BgR1+2vvt4CvzHGdEWJlPTvA4aq6nWq+r5q7HChqttU9V+qeiJwOFDehuk0MRQUBLnggm81CeCXXnomP/yha9n/29/uOgxvdrYL+Naozxhjup6MlnZQ1dtbe1JV/RD4cLdSZBL23nvv8eqrb3PqqRnk5NSjqtx9990cdtgRDBx4EIsWwWOPwbe+1fS4QMB14cvLc8P7GmOM6Rqs9X4H1dDQwPTp06mv305xcQYXX3wFubm5VFdXM3fuO1x3nSvi//GPUFGx6/HBoGvNb4wxputIOOiLyKki8k8RmeO12v/Me/5PETm1HdNoYsjIyKBbt27k5eXRr18m//73kxQWFpKbm0txcTGnnRZk9GgX2O+4Y9fjc3Pd1LuxLgiMMcZ0Tok05OsuIm8D/wEmAZuA2d6yCZgI/EdE3rEue8l10UUXceWVV5KVFSYvr5b6+gwuvvhizj33XETg1792+911F6xYsevxeXmumt+m3zXGmK4hkZL+n4FBwNGqOkRVv6aq3/GWr6nqUOAoYABwS3sm1jSlqrz77rsA5OfXEQ4L8+a9T6St5aGHuiF7a2sbLwD8MjIgHLa++8YY01UkEvS/Dlyjqm/F20FV3wauA05to3SZFqgqs2bNYsGCBYwcOZJLL/0+o0fvzYIFnzN37tydgf+Xv3Qz8736Kvzvf7ueJy8PtmyxCXmMMaYrSCToZ+MG4GlJOZC1R6kxCRMRsrOzGTlyJOPGjUNE+MpXDmWffYaTlZWNiOu2V1ICV13ljvn1r6GmJvo87v7+2rWu1G+MMabzSiTozwJ+ISKF8Xbwtv0MN2KfSZLS0tKdAR8gK0s47rjR7LvvgU32u+ACGD4cli+HKVN2PU9mphuT36r5jTGmc0sk6P8YOABYISIPich1InKxt1wnIg8Cy719rkrkTUXkMhFZJiI1IlImIhNa2D9LRH7rHVMrIl+IyBWJvFdnFwn4Ed27u9f+UntmJjuH5f3b32D9+uxdzpOf74K+VfMbY0zn1WLQV9WPgYOAB4BxwI3AFG+5ETgCeBA4WFUXtnQ+b3je271jR+NqB14SkUHNHDYNOAG4GBgOnAl81NJ7dUUZGW4ynqqqpuvHj4dTTnHV+//4x767HGfV/MYY0/kl1E9fVdeq6pWqui+Qj2upPwAoUNV9vG1rEnzPq4CpqnqPqi5S1R8Ca4FLY+0sIl8GjgVOVNVXVXW5qs5R1ekJvl+XU1Tkgn/0NLq/+pUr0c+c2Zv//nfX46ya3xhjOrdWj8inqjXeRcBaVW1VZbCIZOEm7XklatMrwPg4h50KvAdcJSKrvEGB/ioiBa1Ne1cRCLgGfNGl/X794Lrr3POf/9wNzhMtUs0ffawxxpiOT+LMn9O4g8jpqvqfVp1UpB8wWFVnR63vD6zG9fmf4Vt/PXCuqg6Pca6XcQMAvQb8FugG/A34SFXPiLH/xbjbAJSUlJROmzatNUmPq6KigoKCjnWdUVfnHv23/UMhuOKKg/nss26ccsoqfvCDz3c5TtUt2bve+k87HfF7icfykp4sL+nJ8hLfpEmTylR1TMyNqtrsggvSHwCTgR4t7DsBuBuoBC6Osb0/oMBRUeuvBz6Nc85XgGqg2Lfuy955SppLT2lpqbaVN954o83OlSzV1aqLFqmuXt10+cc/3tVgUFVE9bnnmm67554X9G9/e1I//TSka9aohkIhffjhh/XJJ59MdXZi6ojfSzyWl/RkeUlPlpf4gLkaJy4mUr3/JdwQvL8F1ovIR14r/ltF5CYRmSIir4jIFmC6t//xqnp3jHNtAkJASdT6EmBdnPdfC6xW1W2+dYu8x+Ya/3V5OTnQrduuVfX77FPJ5MmuNH/ttVBf79aHw2E2btzIihUreOWVp9m6Ncz99z/O0qVLWb9+PWFr4WeMMR1aIq33q1T1t8BA4NtAGe6+/AXAlcDJQBDXIn+Eqk5S1Zj99VW1zjv++KhNxxO/j/87QP+oe/jDvMcYI8obv549XWv86Hh95ZUweDAsWuTG5gfX/e+AAw4gMzOTFStW8M9//p358zcRCGRz4IEH7tI90BhjTMeScEM+L2C/BlyqqgeoajdVzVHVAap6rKr+RlU/SeBUtwLni8iFIrK/iNyOq/afAiAiD3p9/yMeATYD/xSRESJyBO4C4wlVtclhW5CZGbsLX24u3Hyze37bbfD55y7ojxkzhrFjx3pVQQ1AiP33n8S4ceMt6BtjTAeXyCx7QRG5QUS2AuuB7SLypIh02503VNVHcQP+/BLXVuBIXHe8SKl9EL5qe1WtAI4DinGt+B8D3sTVNJgEFBe7LnyRavyIo46Cs85yffevvNI18lNVVq5cuXOfzMwGlixZy5YtzTf4NMYYk/4yEthnMq6h3XRc0N0bOA3YDnxvd95UVe8E7oyzbWKMdZ/iGu+Z3RAIQN++8MUXruTvd8MNMGMGzJsHd90Vpm/fp1mxYgWPPXY2mZlBzj77CdavX8L99z/PD35wEvn5re7laYwxJk0k8gt+EXCPqh6jqtep6pnAD4Bve/3uTQeQl+dK/NHD7BYXwy3ehMi33CIsXZpBZmYmRUWF9OlTwtixY8nKyqShYTtr1sguA/4YY4zpOBIJ+nsDj0etexTXeG9wm6fItJtevXYdpQ9g0iQ45xyorRVeeOE4xowZS2FhIdB4j/+QQw4kEBDWr3et/o0xxnQ8iQT9AlxVvl9kLLe4M++Z9JOZCX36xB5b//rroX9/WLw4j3ffLQVcoz0RobS0lAMPPJDcXKiogPLypCbbGGNMG0nknj7AABHZ2/c66Ftf7t9RVZe2RcJM+ygudiP01dVBlu/mTGEh/PnP8K1vuer+khIlEBAeflgZMOADevbM4MADD6SgANavd2MA5OamLh/GGGNaL9Gg/0Sc9U/HWBeMsc6kiUDAlfhratyjvxfekUcqgwaV88UX3VmzRgHl+uvDhEIHcvzxS7j7bnchkJsLq1e7fv7RDQONMcakr0SC/m610DfpSwS6d3cT7uTlNa6/5RZYt64oshcAtbXuGu711/flllvcCH6R2fjWroWBA92FhDHGmPTXYtBX1QeSkRCTXL16ufvzDQ2uD395OUyZItTVxa6oqa0NMmUKXHKJu0UQub+/ebMb/McYY0z6szJaFxUMNp1+94UXIBhsvll+MKg8/3zj68g0vNujm3kaY4xJSxb0u7CCAigqcn33N2zYtQ9/tMh+ESIu8K9d69oIGGOMSW8W9Lu43r3d8Lu9erXcGj8313X58wsGITvbNeyzgXuMMSa9WdDv4jIz3RC9EydCKNT8hDr19cJJJ+26PtL1b/Xq2GMAGGOMSQ8W9A2Fha4V/ve/r2RlxS+uZ2dr3NJ8bi7U1rrq/+gR+zRqRfRrY4wxyWFB3yDiGvX98IfK+PEfEww2IBIG3EVAINBAUVElFRXCFVfEL80XFLheAFu3Nq4rKytj1qxZOwO9qjJr1izKysraPV/GGGOasqBvANdtb8CAAD/4gXDjjS/Ro8cOunev4KST3uOmm17i739fQffuMH06/O1v8c9TWOhK+zt2uABfW1vLggULdgb+WbNmsWDBAmpra63Eb4wxSZboiHymCygshCOOGMVBB43grrtcM/2xY5dwzjnnEAgE+Nvf4DvfcYP4HHIITJiw6zkiLfrXrIHBg4Vx48YBsGDBAhYsWADAyJEjGTduHCLNtyEwxhjTtqykb5ro1UuZN+/9Jvfly8rKUFUmTWJn9f6ll8IXX8Q+RzDoxuZfudI1/osE/ggL+MYYkxoW9M1Oqsp7781iw4YPyMnJp3fvEoYPH84nn3zC3LlzUVWuvhqOOcbdt//+9+P37c/MdLcMVq1S3nprVpNt/nv8xhhjkseCvtlJRFi3bh09e+YyfXo+Dz7optUtKChg48aNiAjBIPz97zB0KHz8MVx99a6t9SOyspS5c+fxzjvLOOCAkVx00UWMHDmyyT1+Y4wxyWNB3+ykqvTt25eKigoWL55NVpYya9Y8Kisr6d27984gXVwM99/v7t0/8wxMmRL7fCJCUVEmQ4fux5Ah4wBX1T9y5Eiys7Otit8YY5LMGvKZnUSaNrz76KOP2bSpkJEjhzNmzJgmQXrYMLj9drjwQrjxRthvP5g0addzHnjggYTDYaqqhA0boE8f4fDDDydgU/MZY0zS2S+vaWLevHk7S/QZGWGKi6uoqQkyf/78Xfb96lfhxz9ubNj3ySe7nu+jjz6irKyM/HylvBw2blRmz55t/fSNMSYFLOibnVSVmpoa5syZQ0VFBQCh0FYWL36X8vK6mPfgr74aTjrJ9cs/7zzYuLHp+ZYvX868efOYO3cu+fnKa6+9z2uvvc+SJUvsnr4xxiRZSoK+iFwmIstEpEZEykQkRo/vnftOFBGNseyXzDR3Ff4q/EhQLiioJiNDqK3ddf9AAP7yFxg9Glatgu99r2mL/n79+gGuBuGRR/7FokXvUVGRR2HhoPbMhjHGmBiSHvRF5GzgduBGYDQwE3hJRFqKAiOAfr7ls/ZMZ1ckImRnZ3P44YeTn5+PiJCfn8/48WMZOFCorxdCoV2Py82Ff/7Tjd///vtw1VWuyl9EGDNmDIcccgi1tbVs2bKFurpaDj98JEOGjGX7dmvIZ4wxyZSKkv5VwFRVvUdVF6nqD4G1wKUtHLdBVdf5lhjhx+ypQw45BFXdWeIXEVSVsWNH078/VFbG7qLXuzc88IAbf//ZZ+Hmm5tuf+SR03nkkdMBVztQUABr18K2be2dI2OMMRFJDfoikgWUAq9EbXoFGN/C4XNFZK2IvCYiMdqJmz0VGRt/4cKFjBzZ2K9+4cKFzJo1i4ICpWdPF/hj2W8/uOsuNyjPHXfAPfcoc+fOZd68eQQCQkZGBtnZ2cybN49589w9/jVrYPv25ObTGGO6KklmYyoR6Q+sBo5W1Rm+9dcD56rq8BjHDAcmAe8BWcB3gMneOd6Ksf/FwMUAJSUlpdOmTWuTtFdUVFBQUNAm50q15vJSVVWFqpKfn79zXWVlJSJCXl4eAPX1rvo+Xq+7V18t4U9/2h+AH/1oLocdtpzy8h4EAgH69auisrKKzMxMunUrBiAUgqys+Ofb3bx0NJaX9GR5SU+Wl/gmTZpUpqpjYm1L+376qvop8Klv1SwRGQL8BNgl6Kvq3cDdAGPGjNGJEye2STqmT59OW50r1VrKi796P9brhgZYscKNsZ+VtevxI0ZAdjb87ndwxx2H0L17AS+/PBwQnnhCee+998jJyWHEiAMBF/QrK6F/fygqatu8dCSWl/RkeUlPlpfdk+x7+puAEFAStb4EWNeK88wBvtRWiTJNRY+UF/3aTcMLtbXEbNgHMHkyXHQRNDQEuPnmL/HFF651/7/+BZWVTa81g0F3j3/NGrvHb4wx7SmpQV9V64Ay4PioTcfjWvEn6mBc4z+TIjk5rmReURG7YZ8I/PKXyqBBbnCfNWvc5DvXXx/m/PMP5P77exIONx4Yady3Zo2bzMcYY0zbS0X1/q3AQyLyLvAO7v58f2AKgIg8CKCq3/Ve/xhYDizE3dP/NnAq8I3kJttEKyx0rfY3b3bPo916q7BuXbb3ytUW1NYGAXj22b707y9ce23j/oGAO8/69e5CokePds6AMcZ0MUkP+qr6qIj0BH6J62+/ADhRVVd4u0T3188C/gQMBKpxwf9rqvpikpJsmtGzp6vmr6x0E/BElJfDlClKXV0w5nG1tUGmTFEuuUQoLm5cHwn8Gza4Wwe9erlaA2OMMXsuJSPyqeqdqjpEVbNVtdTfkl9VJ6rqRN/rP6rql1Q1V1V7qOoEC/jpQwT69nUN+vwj8b3wAgSDzUfrYFB4/vnY5ywshC1bXKk/HG7jRBtjTBdlY++bPRYMuoZ9IuwcqnfDBqiubr47aFWVsmFD7G2RwL99uxvExwK/McbsOQv6pk1EWvTX17sufX36uOF5myMSu8ufX0EBVFW5lv8NDY3ro8eXsMl7jDGmZRb0TZvJzoa99nJB+oQT4nfni1AVHnzQBfTm5Oe7i4kvvoC6OigrK2PmzJk7A72qMnPmTJuu1xhjWmBB37Sp3FxX4s/IgEsugayshpj7ZWY20KePsmoVfOMbLqC3dF4RWL5cWbRoOXPmzGHmTNfLc+bMmcyZM8em6zXGmBZY0DdtrrDQ9eG/5BI45ZT1ZGQ0IBIGlMzMOjIyGjj11PW8/nrjlLynnQaftTBvYna2ux0QDA6lujqTOXPmsGnTJubMmQPAwIED2z9zxhjTgVnQN+2iuBhKSmDcuA/58Y8fonv3bXTrVsFXvjKLq656iGOOKaNbN/j3v+Gww2DdOhf4P/ig+fNmZQmFhUGys4ewebPQ0NBATU0Nffv2JSsra5fRA40xxjSyoG/aTc+ewogR/ejTpyfFxbX06FHJkUd+wV57FTN48GBEhMJCeOQROOYYNxLfWWfB22/HP6eqEgrVsW3baioqsgiFAtTXh1m7di21tbVWvW+MMc2woG/ajaqydetnVFSsIjs7jz59Sthvv/3YsGEDK1as2Bmgc3Ph/vtdSb+yEr7zHXjppebPHQo1kJVVh6qwbVsh1dUttBo0xhhjQd+0LxEoKqohI6OxNX+sKvjMTPjrX+H8810L/YsvhqlTY5/zk08+AeCxx86ivLw7OTl5lJcXMW/eJ+2TCWOM6STSfmpd03GJCGeeeSazZs2ioGAa27fn8OGHWRxyyCGMGTNml+AfCLjpeHv1gltugV/8wrXq/+Uv3baI4uJiysvLd77OyAgRCjXQ0DCILVvcmP12a98YY3ZlJX3TrkSEww8/fGeJPze3jmHDSuM2uBOBK6+E225z3f7uugsuvRRqahr3UVVqarKpqMijoSHA++/vT11dFtnZ9Wzc6Gbqa4jdU9AYY7o0K+mbdjV37lwWL16MqnoN96p5/fWnKCkZxvjxo+Ied9ZZbkz/iy+G5593rfvvu8+V4p97bj9effVrhEIBQqEA//3veF5++QiOP34JX/+6mwNgxQo3XkBOThIza4wxac5K+qbdhMNhFi9ezPLlyyksLOTCCy+kqKiQ8vJP2bBhMdu2hWmusf1RR8FTT0G/fjB3Lpx4Ilx3nTB9+jAaGjJQdX++9fWZNDRkMH36MG65RcjLc/MBLF/uegRYg35jjHEs6Jt2EwgEGDZsGEOGDKGiooJ7772XiooKhg4dwqGHDqZnzwA7djQflPff383YN3o0rF4NjzyiVFfHvjVQXS1MmaJs2+YG8SkocBP/WHW/McY4FvRNuxozZgzf/OY3m6z75je/yaGHjqF3b9dor6XAX1ICTzwBpaUALU3Xy87pegMBNzpgTY0r9VdW7lFWjDGmw7Ogb9qVqjJ79uwm62bPnu3d43dBv08fF/ibmz43JwcmTgRoenVQVdW0WUp1NbtM15ub60r+K1e6bS1NBGSMMZ2VNeQz7UZVmTVrFgsWLGDkyJGMGzdu52uAcePGISL06OFK6GvXuhn1gsHY5yspgbw8N4tfxO23lzbZJzfXXUREy8hwpf5t26CiwrUTaGnqX2OM6WyspG/ajYiQnZ29M+CLCOPGjWPkyJFkZ2c36bZXXAwDB7qSen197PN97WsQCjWt3t+8uWnkDoWEk06Klx53UREIuNb9mzY1X7tgjDGdjQV9065KS0t3BnxgZ+AvLS3dZd+CAhg0yI3IV1u767m6dYPJk7XJdL1jx67Z+TwQCHPBBUpxcfNpyspypf6tW929/urq3cmZMcZ0PBb0TbuLHoinuZnwcnJg8GDXsC9WML7mGjj22CU7p+s988zFBIMNgBIOB3j5ZZg/P5E0NS31b9xo9/qNMZ2fBX2TdrKyXODPynL33/0t+0Xg61//lMsvv5/u3bcRDIY54YR3+M53HmPAgO0sWyacfDLcc09iVff+Uv+KFdbC3xjTuVnQN2kpGHQj6hUXx27ZX1SkXH75Y/TtW05p6ScMHVrOtdfO4LzzlPp6uOEGOPdc10e/JSLu1kIw6Fr4r10bv12BMcZ0ZCkJ+iJymYgsE5EaESkTkQkJHnekiDSIyIL2TqNJvUDAtdjv29eV+Bsa3K2BQYMGkZWVRU1NDaFQAzU1NWRlZbHvvgO58Ubhvvuge3eYMQOOO86N6pfIqHyZmVBU5HoHLFvmWvrbaH7GmM4k6UFfRM4GbgduBEYDM4GXRGRQC8d1Bx4EXmv3RJq00q1bYwO/ysowy5YtY/v27QSDQTIyMggGg2zfvp1ly5YRDoc54QR4/XUX8Ldtg8svh8mTYcuWxN4vN9d1DVy3zjX083cRNMaYjiwVJf2rgKmqeo+qLlLVHwJrgUtbOO4+4AFgVnsn0KSfvLzIff4AffvuTWFhEeFwmIaGBsLhMEVFRQwdOpSANwdvnz4wdaqbojc/343Sd/TR8MwziZXeI6P5BQKuyn/NGnfRYYwxHVlSg76IZAGlwCtRm14Bxjdz3GVACfC79kudSXeZmTBwoJKdXUs4nEdmZg7BYAbZ2dlkZmZSX1+P+iK6CHzrW/Dqq3DEEa6kf9llcMEF7r59ou9ZWOh6Eixf7vr2Wyt/Y0xHleySfi8gCKyPWr8e6BvrABEZBfwa+Laq2s9tFxcMCn37BujfX8jIKAIgLy+P/Px8srKyYnYHHDwYHn0U/vQnF8BfeQUmTYIHHkg8gOfmuhqDrVth6VJ328AG9jHGdDSiSWypJCL9gdXA0ao6w7f+euBcVR0etX828D5wk6o+5K27AThDVUfGeY+LgYsBSkpKSqdNm9Ymaa+oqKCgoKBNzpVqHT0vlZWVVFdXk5OTSzishEIBamtryM3NIS8vr9ljN23K4q9/Hcbs2b0AGD58Oz/84WKGDatoVRrCYVeTkJHhbgG0hY7+vfhZXtKT5SU9tXVeJk2aVKaqY2JtS3bQzwKqgG+p6uO+9XcAI1X16Kj9hwDLAH95LICbai0EnKiq0bcKdhozZozOnTu3TdI+ffp0JroZXzq8jp6XsrIyamtrGTduHG+++SYHHHA0r732PkVFGYwefWCLx6vCiy/C9de7xnqBAJx3HvzkJ7Q4mp9fQ4Nr5JeTA717u3YHzYw71KKO/r34WV7Sk+UlPbV1XkQkbtBPavW+qtYBZcDxUZuOx7Xij7YaGAUc7FumAJ97z2MdYzq56KF9+/QRTj55NMOHH5hQS3sRN47/m2/CxRe71//8Jxx5JDz8cOJV/hkZroufiGvs98UX1tLfGJPeUtF6/1bgfBG5UET2F5Hbgf64YI6IPCgiDwKoar2qLvAvwAag1nvdujpZ02lE37svKBCGDHH33bdvTyxwFxTAr38NL78MY8e6hn7XXQcnnACzWtFHJNK/Pxx2wX/FChf8rY+/MSbdJD3oq+qjwI+BXwIfAEfiqulXeLsM8hZjWiUjw02Z27+/a22f6EQ6BxwATz4J//iHGwXw44/hjDPgootgyZLE3z872zUUVG0M/pWVFvyNMekjJSPyqeqdqjpEVbNVtdTfqE9VJ6rqxGaOvSFeIz5jwJW6hw5199oTLfW7Mf1dlf8117hjX3zRtfL/2c/chDyJioznD7BqlRvdL9ZQwsYYk2w29r7plDIzXYl/wACoqUn8XntuLlx5Jbzzjhu7XxUefBDGj3cD/WzblngaIsE/GHSD+yxf7o63fv7GmFSxoG86LREXdIcObbzXn+hEOn37wh//CK+9Bl/+srtouO02GDcO/vrX1s3GFxngJzMTNmxw/fw3bbJJfYwxyWdB33R6kXv9gwa5UnZFReJV7cOGuZb9Tz/tSvvbtsEf/gCHHw533unOlahg0F185OY2DvKzZo1re5DIff/o7rXJ7G5rjOkcLOibLiMvD4YMcX3qKysTb+gHcOih8PjjbmS/MWNcS//f/961+r/tttZV+wcCLvgXFrpbD1984e77h8Pxq/7Lysp45513dgZ6VeWdd96hrKws8Tc2xnR5FvRNlxIIuGl3997bXQRs3966iXSOPNKV+v/1L3chUF7u7vUfdhjcdBOsjx5gugU5OS74Z2S46v4lS9wtgJqaxn1Ulblz5/L222/vDPzvvPMOb7/9NnPnzrUSvzEmYRb0TZeUmemq/AcPdq937Ei8gZ0ITJwITz0FTzwBEya4av6//91V+199NSxe3Lr0RIbzzc93aVmxwjX8c+0QlHA4TF1dHW+//TZ33XUXb7/9NnV1dYTDYQv6xpiEWdA3XVpurgv8/fq5En9r7veLuIZ906bBc8/BiSe60vq0aa6r33e+47oAtiYmi7g0FRa65+vWwdKlQr9+hwB51NTUsn79empra8nKymLUqFExJxkyxphYLOibLk+ksW9/797uXn9rB9U55BC45x546y347nddtf3rr8M557hagalTW9fiH1xtREEBFBYKI0ceSk7OvtxzzwXce+/3qK8P0r//AMaPH29B3xiTMAv6xnj89/u7d3el/tYOpzt0qLu3/+67bkjfvn3h88/hF7+A0lL3uGhRa1OmvPLKs2zatByAcDhAeXkxH3ywjfvvf4qaGqveN8YkxoK+MVGCQejVC/bZB7p1273g37MnXHEFzJ4NU6a4hn47drgS/3HHwSmnuN4AifQgCIfDrFu3jlAoRCAgZGcHycsLoVrH559vZenSMEuXum6ArWmUaIzpeizoGxNHRsauwb+ysnXD6WZmwsknu0Z///sfnH++q7KfOxd+/GMYPRquvRbmzYt/UREIBMjPz6e+Po+qqnzKywv4+OPRhEK5dO+eTXFxgIwMN+DPsmWu//+WLVBba+P+G2Oaykh1AoxJd5Hg362b64+/ZYsLprm5rlYgUfvv7/r2//zn8Mwz8Mgj8P77rvvfv/4FgwYdyrnnwmmnueGDGwkffvhlnniiNw0NoCq8+up4VCdwxhkb+fa3hYwMl05wvRA2b3bzBURmAMzPdxMCBewy35guzX4CjElQRoartt97b9fgr7bWVdm3djjd/HzXwO/55+GNN2DyZHdR8cUX+dx0k7sV8I1vuAuBrVvhT3+Cp5/uQ319ANUAINTVZVJfH+Dpp/vwpz81PX9k5L/CQjf+/7ZtbgCgzz93IwBWVNgQwMZ0VVbSN6aVgkHX0K+42FX3b9rkgn9mpmu13xrDhsGvfgU//Sk88MB8yspG8corri3A7NmuViAcVsLh2C30q6uFKVOUSy4Riot33R4IuBoJcLUTNTUu6Ku6C4LiYrfdagGM6Ros6BuzmwIBV5ouKHDBdPNmN5hOMOgCaWuCaGYmjBu3mQsvdBcQL77o2gG8/barzm9OMCg8/7ybFbA5Ik0vShoa3K2KSBuFvDyXn5wcd0FgPQGN6Xws6BuzhyID6gwc6FrPb9/uhucNh13wzMpq3fkKC+Hss93yu9/BP/6hQPwIXFWlbNjQ+gjtbweg6qr8N2xwz0XcLYKCAncRkJlpFwHGdAYW9I1pQ1lZ7v58jx6um9+WLa7kHqlmb20V+tChkJcnVFU1t5fw0EOu+9+xx7rxADJa+Z8t0vQCRdW1WYjMIui/CMjOdhcBdjvAmI7Hgr4x7SAQcAGyoKBp6T8UcgEzOzuxkvPXvga/+lXzJX1Q1q8X7rgD7rjDtdY/8kg45hg4+mjo37/16RdxaczO9t7Buwjwj1QYmSwoO9tdLLT2QsMYk3z2b2pMO/OX/mtqXPCPlKBbqv7v1g0mTxbuvluprt418OfmKt//vjBhArz6qusNsGSJaxPw4otun332gaOOchMDjRvnLgpaK9ZFQEODa8cQDrvXmZmuXUBennsdCrWuS6Mxpv1Z0DcmSQKBxqAYCrlSc3m5q/4XiT+QzjXXKGvWrOGpp0oIhQKoCpmZ9agGOOmk9Vx3XX8CAeHII+E3v3Hd8954wy0zZ7qLgCVL4J//dGkYNQrGj3cXAIcd5krrrSXignxmZuO6cNjd0tixw9VuLFnS9EIgsr9dCBiTOhb0jUmBYNCVuIuKXAO6qio3lW6sGoBAQDj++A/Ya6913H//6YTDAcaNe4+RI5czfHg/AoEmI/kwaBCcd55b6uvhgw/cREAzZrjBgD780C3/+Ie7CDjgABg71l0AHHYY9Omze3kKBBp7B0Rub4RCLk/btjVe1GRmuvYNeXmNtwUyMqyhoOl6VLXJhFnRr9uDBX1jUiwz0/WXz8pyDfeqq5vWAAQCIdav3wCU061bDSUlfZkwYSVbtmxjw4YgoVCIYJzic2YmHHqoW666yl1czJ0L77zjagE++ggWLHDLffe5YwYNco0Bx4xxj/vt17RE3xqR7ot+oZDLY2S8AGi8fZCb29hbICPDHW8XA6YzKisro7a2lnHjxgEu4M+aNYvs7GxKS0vb7X0t6BuTRiJV4EVF7p55TQ1s2xakW7f+1NdncsEFb5CZGUYkgx49elBSUhI34MeSl+fu7x91lHtdXe3G/X/3XZgzxz3/4gu3PPWU2ycnB0aMgIMPdnMFjBrlRiXc3db7weCuVfyRNgLbt7tRCCMiFwM5ObteDOzO+6eiZNUZ2ee4Z1SV2tpaFixYsHPdrFmzWLBgASNHjmzXzzMlQV9ELgN+AvQDFgI/VtW34ux7NHATMBzIA1YA96rqLUlKrjEpkZHR2APgssu+QmVliLvu+he1tZmEQsJZZ51DTk5wZ7/63ZGbC0cc4RZwpfBPPnG1AWVlblm+vPF5REEBjBzZuIwYAV/60u7XCMRqIwCNFwM7drjaD7+MjMYLguxsdyHQ3K2CsrIyampqGD9+PCKCqjJz5kxycnLatWTV2fhLqJHPMRkl1M5ERHaW8BcsWECPHj3YsmULI0eO3Pm5tpekB30RORu4HbgMeNt7fElEDlDVL2IcUgH8FZgPVAFHAHeJSJWq3pmkZBuTUiLK/PlzKCqqQbWGUCjAF1/MZf/9D6Oy0v1ABAJ73nUuGHQBfMQI1yYAXMn7o48a2wN89BGsW9c4VHBEVpYbVnj//aF794Fs2uRuDfTps/sXJfEuBsBdoNTVudqKSA+CyPtELggibSMyMpRZs+axbdsWVOGII8Yzc+ZM3nrrLbp3784hhxxiJdUERJdQx40bl7QSamcjIhx++OFNSvuHH354p7ynfxUwVVXv8V7/UEROAC4Ffha9s6qWAb4yBstE5HRgAmBB33R6kZJU5Ie18Yf2QwoKQowdO466OqG62lWPN7YFaJv+8927u/7+Rx/duG7jRhf858+HhQvh449djUCkfQDsy913u327dYPhw90FwfDhsO++bunbd8/u18e6TRARDrtGjDU17uIgHFY2bsxjy5Yann56ATNmLGfHjq00NATIyAhQUaFkZsrOc9rAQ7FFl1AjASsZJdTOZu7cuSxevLjJumnTpjFs2DDGjBnTbu+b1KAvIllAKRBdNf8KMD7Bc4z29r2hTRNnTJoSEbKzsxkxYsTOH9Zx48ahqmRnZxMMCrm5rqq+Rw8X5GprXQl4x47GBnOBQGOpeU9/m3v3dqP/HXts47odO2DRIrfMnLmaDRsG8Mknrlp+zhy3+BUUuOC/995Nl6FD3bY9EbngiVAV8vLCbN4c4L77ziQUCnLYYe+yzz5LKSwsYM0aafKZBAIu+GdludsL5eVN2xJEHrvixcG8efPQqP6lqsq8efOsej9B4XCYxYsXs2zZMoYOHUqvXr2oq6tj2bJlABxyyCEE2umPS6K/vPYkIv2B1cDRqjrDt/564FxVHd7MsauA3rgLld+o6m/j7HcxcDFASUlJ6bRp09ok7RUVFRTs6S9RmrC8pKfm8lJVVYWqkp+fv3NdZWUlIkJeXl6L51Z1pd/I4tcevy01NRXk5BSgCps3Z7F8eT5ffJHPihV5rFzplm3b4o9K1K1bHf37V9O/fzX9+lXTr18NffvW0K9fNd271+1Wmpcvr2H79sYZh0QUVaGoqIYhQ2JPj+hmJqwgOzv+35jIrktkvf8xHbTF/0tlZSUVXt/SYND1HgEoKCho8vfZ3jr6/355eTn13hzXGRkZNDQ0AJCZmUm3bt326NyTJk0qU9WY1QUdqfX+BKAAOBz4g4gsU9WHondS1buBuwHGjBmjEydObJM3nz59Om11rlSzvKSneHmJV72/ePHi3apWVXX3wuvr3QBBVVXueaQ2IBjc80F0Fi6czogRjXnx3xqI2LIFPv8cli5tuqxYAeXlWZSXZ/Hxx7vOF5ydDQMGwF57uUmOBg50rwcMcEMO9+276yiHf/yjMmVKmNraXTOVnR1i8uQA114b+zOMzotf5GLK3UKIfVHlF6ktiDQ4jCz+mgP/4r+IaAt7+v+iqjz++OMsW7aMrKws8vPzqayspK6ujr333psTTzwxaVX8Hfl/3/8/XVFRwaBBg1i5ciUFBQXtfqsk2UF/ExACSqLWlwDrmjtQVZd5T+eLSAmuen+XoG9MZ9PW91H9Q+pGCkqhkAv8kdsCVVXuMdI4LnIh0Jbj6/fo0TggkF847BoKrlgBy5a5x5UrXTfCFSvcxULkAiFe/nr3hn793EVA9+7w6KMQCsW+iqmtDTJlinLJJW68hNaIfDaJXiBFLgoin3XkoqG5CtfIhVhkiVwkRJ5H2m8099jWsrKydlbxqypZrZ1KsouLNOJbtmwZN9/8Fa666lNqamooKSlp98Z8SQ36qlonImXA8cDjvk3HA0+24lQBILst02ZMOosEfn9L37YsDUSCSE5OY+CLXAjU17sLgMiAOtC2tQLRAgEXrPv3d0MFR6ushFWr3IXAqlVuWbMGVq92y/r1borgDRtcbwOn+c+poQEuvNB1Xezd2y09e7o5E6qr96xbZHTeWntrwn9rxn+x4L9gaCltkYuDujr3GfkvJCJpigyE5F/8tQ1uEb7xjTOYNu3frFixgtraWgAGDx7MGWecYQ35EqSqPPHEE6xfvx6RwM52O+vXr+eJJ57gzDPP7DQlfYBbgYdE5F3gHWAy0B+YAiAiDwKo6ne91z8ElgGfescfBVyDtdw3XUikOtBv1qxZ7VoN6L8QiIzPr+oCT0ND4/DBNTXugiCyXaQxQLXH8Lr5+a4XwPA4LYDq613AX7vWLdOmwfTpzc9UGAoJM2e6UQp3NYGcHFcz0bOnW3r0cEv37o2PkaVbN7cuJ6dt8t7a2oRokQuESG1C5FZO5DZE9Pbmz6W8//4HLFkS4N57zycYDHLOOc+yYoXyzDNlHHroGIJBiXmrIvp2Ray2ELG2+V93Ntu2CTt25NPQEGTOnAPZf/8FDBzYvu+Z9KCvqo+KSE/gl7jBeRYAJ6rqCm+XQVGHBIE/AEOABmAJ8FO8iwRjOrv4XfYa+0onq4Ql0nRegEitQPTFwBdfuH0jfegj+/hLmO013n5mZuM9fnDdGN99V6iqin9MVhaccIIbgnjjRti0yc0guHEjbNgQpqYmwJo1rkYhUVlZ7gKguNg9FhW555GlsLDxsajIPUaWoqK2vWjwB889q4kXiouD5OYWUlWVTygUYNGiURx22GaCwWzq62XnRUXkIiLeRYV/CObo9f51/tf+Goi6Onf7x197Ev28uXX+x1gXF801yNydffzPVWHatBE899xphEJBGhoCPPPMkTz11EROPnkxZ5zRfhc5KWnI5w2qE7OkrqoTo17/BfhLuyfKmDQVqfrz38OP3OPPzs5OiyrV6IuBjAwXQMHdJmhoaFxqahprB2L1JPDfv26LrH3ta/CrX7Wc/ptvjn1Pf8GCGQwZMpHNm117gsjjli1u4KLIY3l508fa2sbbDLsjGHQXAAUF7jE/3z2PPBYUuGGVI68jsxnm5zc+z8trnNwoMuXxngiHlX/+sxdPPTWCUMjd9njxxUN57jnltNPWc+utSiDQfn+P/gsJEfd35q+1CIWa7uN/jDyPtX5P0+QP5on8zf7lL/DCC8NpaGgMwXV17p/nxReH8+tfw//9X9ukL1pHar1vTJdVWlraZLSzSOBPh4DfkkgAz/Za4fgDayjUuDQ0uNJbZIl1URAp5fkvDlr6CLp1g8mTW269X1wc+0QijUF28ODE8x2ZOGnbNve4fXvj47ZtjQMpbd/e9PmOHY3TE5eX7zr88J4IBI7eeSHgX3JyGh+jF/9QxzNmCG+91Y+GhsaGCZHP9Omn+5GdLVx6qbv484+ImJXVdrUW/seOOE1zeTncf79QVxc7/NbWZnDLLXD11e5vt61Z0Demg4gO8B0h4LekpXvVke5w0RcGkcfo2wcijbcR/MuVV8JHHy3krbcO2FlCzc4OEwopRxzxMddcM6rN8xYJqP367d7xtbWu0WJFhbsIqKxsHGypsrJxqapy66qqGl9HHiO9MCI9MurrhYqKxgaZuyd2S8T6+gAPPwwPPxz7qMzMphcBWVmN6yKDRvmfx1oiXRwzM6G8fCj9+jXtWeLfJ7pLZKTBaXS3ycjzQKBxXeS5v9bJPzBTZJ/dqZF64QUIBptvYxIMKo8/Llx0UeLnTZQFfWNM2ooE7eYm8om0bI/0lY91gVBfD1//+ipGjfqQqqoJ5OUNpqpqJfn5bzFkSE+qqkbt/PGOvmBIlUi3yh492u6cH374JkOHHr3zIsB/q6W6uvG1f6mtdY8ffABz5igNDfGDlYjSvbuQleWOi9TaRHqBRMaGaButqHZpZ/7GltEXA9Hrd+yAqqqmn+HrrzdtylZVJaxrthP77rOgb4zp0CLBufkxBIQjj+xDz55b2bHjFSBAOAy5uQXsu29feveWnV0UIz0PIm0QwuHG+Qx2OWuM7m3t3Ud+T2RkKEVFrqFga912G8yc2VKGhAsucDUrfuFw0+Dvv40TvS5ykRZZ538ded7QAKtWLaVHj72pr2/sXupvO+Jf/O1KIs/937d/m3+JbI+8juwbvS4yG6Q3qF6rVVQ0varNy1P69u08XfaMMSapVJW6ujqqqyupqakgPz+fmppKsrLCZGbW0K1b/Nnh1qyBffZp/HGP1Cyo7nrrIRIUogNCIsHff5HQfF/5NvxgWqFPH8jN1V1KqX65uUqfPrtuDwQa2wi0lYULv2DEiL3b7oS7yT8qY3RtU/TfiKpr5Pn1r7sLmoiJE1cyY8ZeO1+HQsKZZ7ZPei3oG2M6vcgIaMuXL2fTpk3U1NQA0Ldv34RGQNuTkQgjgd8/mE708+hhfGMFEf8FR0vidYcLh9nZdTFeN7V4z088EX71q+Y/p1BIOOmkBD6UTqS14ygMHAiTJ4eZMiW8szFfUVHjFUBWVgNXXx2gW7f2ubdkQd8Y0+mpKrNnz2bHjh3k5ORQUFBARUUFO3bsYPbs2e3aE6I92gX4+763tPj3X7nSDS4Eu15k+Nf5L0Yi58jOhu99L8y994ZoaNi1kUVGRj3f+16QYDCw83aIv3FlvL73sV5D8/3cI2mtro6/vbXPd+f17rr22gALFy7kzTf3JxRyfyBZWfWEw3D88fP5v/87pG3eKAYL+saYTk9EyMrKorCwcGdwLygooKCggKysrA7XE2J3q/mDQTdq4O664w7h88/nMn36GK8XhJCZWY+qcPTRZdx++9idQR52/xGaXojEWhcMurYJsbZHDwYUb703QeAu7x39vrFex5LorZxQKMxXv7qMffd9l0cfPZ1gMMzXvvY/9t9/ASNGDED1YESspG+MMbslck+/oqJil1EN6+rqmoyBYOJTDXPKKWWUls7gnnu+TzicwYQJb3HAAQsZOLCAYPBQgknqPJ+R4eZISKV4owy2vC7A5Zd/jSlTplBcvI1gsIGDD36PHj16cPbZZxNox24jFvSNMZ1eRxjVsCMIBoP079+fqqrPueKKOxARVJXc3Fz69++ftICfLna3+l9V+c9/niQUquWCCx6kd+9hbN0KdXV1PPnkk51uwh1jjEm6jjyqYbpQVUpKSli2bBmBQIBgMEgoFCIYDFJSUmI1Jq1UXV3d5O+xOjJzVTuyoG+M6TI646iGybZ69Wrq6+vJz88nPz+fyspK6urqWL16daqT1mGoKvX19YTDYTIzM8nIyCAzM5P6+nrq6+vb9eLJgr4xxphWycrKYuzYsYwfP56ZM2cyZ86cVCepQwkEAuTm5rL33ntT6Q1R2KNHD/Lz88nNzbV7+sYYY1JPRNhnn30YMGAA48ePR0QYP348ADk5OVZz0gqnnXYaM2fOZOHChTvXDRkyZOfn2V4s6BtjjElYrLYRkQsAkxhVZdasWSxcuJCRI0dSV1dH//79WbBgQbu3NUnhdBLGGGM6ImsbsWeie5MAjBs3jpEjR7Z7bxIr6RtjjDFJlqreJFbSN8YYY1IgFTUmFvSNMcaYLsKCvjHGGNNFWNA3xhhjuggL+sYYY0wXYUHfGGOM6SIs6BtjjDFdhAV9Y4wxposQVU11GtqNiGwEVrTR6XoBm9roXKlmeUlPlpf0ZHlJT5aX+Aarau9YGzp10G9LIjJXVcekOh1twfKSniwv6cnykp4sL7vHqveNMcaYLsKCvjHGGNNFWNBP3N2pTkAbsrykJ8tLerK8pCfLy26we/rGGGNMF2ElfWOMMaaLsKBvjDHGdBEW9FsgIpeJyDIRqRGRMhGZkOo0tUREfiYi74nIdhHZKCLPicjIqH2miohGLbNTleZ4ROSGGOlc59su3j5rRKRaRKaLyIhUpjkeEVkeIy8qIi9425vNayqJyFEi8qyIrPbSdX7U9ha/BxHpLiIPicg2b3lIRLolMx9eOuLmRUQyReQPIvKRiFSKyFoReUREBkWdY3qM72paOuXF297i/7mIZIvI30Rkk5fnZ0VkYFIzQkJ5ifW/oyJyh2+flP+uJfj7m7L/Fwv6zRCRs4HbgRuB0cBM4KXoH4A0NBG4ExgPHAM0AP8TkR5R+/0P6OdbTkxiGlvjU5qmc5Rv27XA1cAPgUOBDcCrIlKY7EQm4FCa5uMQQIHHfPs0l9dUKgAWAD8CqmNsT+R7eASX5xO85RDgoXZMczzN5SUPl67fe4+nAHsBL4tIRtS+/6Tpd3VJO6Y5npa+F2j5//wvwDeAbwETgCLgeREJtkN6m9NSXvpFLSd76x+L2i/Vv2sTafn3N3X/L6pqS5wFmAPcE7XuM+CmVKetlfkoAELAyb51U4HnU522BNJ+A7AgzjYB1gK/8K3LBXYAl6Q67Qnk7RdAOZDbUl7TaQEqgPNb8z0A++MucI7w7XOkt254uuQlzj4HeOkc5Vs3Hfh7qr+LlvLS0v85UAzUAef61u0FhIGvpFNeYuxzD/Bpa/Kborw0+f1N9f+LlfTjEJEsoBR4JWrTK7gruI6kEFerszVq/ZEiskFEFovIPSLSJwVpS8TeXjXYMhGZJiJ7e+uHAn3xfUeqWg3MIM2/IxER4PvAw16aI+LlNZ0l8j2Mw/2Qz/Qd9w5QSZp/V7iSL+z6//NNr0p8oYjckqa1S9D8/3kpkEnT724lsIg0/l5EpAD4Ji7wR0u337Xo39+U/r9EV1eZRr2AILA+av164LjkJ2eP3A58AMzyrXsZ+A+wDBgC/A54XURKVbU22QlsxhzgfOAToA/wS2Cmd/+rr7dPrO9oQLISuJuOx/3z+3+04uZVVTcnPYWJS+R76AtsVK/IAqCqKiIbfMenHe/i/8/Ac6q6yrfpEdy8HmuAEcBNwIHAl5OeyOa19H/eF1cKjR73fT1p/L0A5wBZwANR69Pxdy369zel/y8W9Ds5EbkVVy10pKqGIutV1d/oaL6IlOF+xL6G+6dJC6r6kv+11yhnKXAekHYND1vhIuA9Vf0wsqKFvN6a3OQZ7x7+w0A34Ov+barqH0xlvogsBeaIyCGqOi95qWxeR/k/3w0XAc+o6kb/ynTLb7zf31Sy6v34NuGugEui1pcAadGiuiUichuucc4xqrq0uX1VdQ2wCvhSMtK2u1S1AliIS2fke+hQ35FX3XgKsasmd4rKazpL5HtYB/T2bmsAO29x9CENvysv4P8bV3o/NoGalrm434u0/q5i/J+vw9Vo9oraNW3/h0TkYGAMLfz/QGp/15r5/U3p/4sF/ThUtQ4ow1XD+h1P0/ssaUlEbqfxD+6TBPbvhataWtveadsTIpID7IdL5zLcP8DxUdsnkN7f0flALS6oxBWV13SWyPcwC9egaZzvuHFAPmn2XYlIJvAoLuBPUtVEfmRH4YJnWn9XMf7Py4B6mn53A3ENydLqe/G5GPc397+WdkzV71oLv7+p/X9JdcvGdF6As3EtWy/E/RPcjmtcMTjVaWsh3XcA23HdRfr6lgJvewFwi/dHNATXxWQW7oq4MNXpj8rLLcDRuPvfY4HnvbwN9rZfB2wDTgdGAtNw91nTKh++/AiwmKheIYnkNcXpLgAO9pYq4Hrv+aBEvwfgJWC+93c3znv+XDrlBXfL82lgNa6LlP//J9LLYh/vmDHe/8+JuIZv84BgGuUlof9z4B/euuNwXZPfwN2DTpu8+PbJ8/7OfhHn+JT/rtHC72+q/1+S+s/WERfgMmA5rmRWBhyV6jQlkGaNs9zgbc8F/ovrG1qHu+c1Fdgr1WmPkZfIP0Od90P8JHCAb7vgurqtBWqAN4GRqU53M/mZ5H0Xh7U2rylO98Q4f1NTE/0egO64e+TbveVhoFs65cULFvH+f873jt/Ly99m73fhc1yBoEea5SWh/3MgG/ibl58q4LlU/Ba09Dfm7fM9XL/3/jGOT4vftWb+fm7w7ZOy/xebcMcYY4zpIuyevjHGGNNFWNA3xhhjuggL+sYYY0wXYUHfGGOM6SIs6BtjjDFdhAV9Y4wxpouwoG9MCojIOBF5zJtRr05ENovIqyJyXmQecxE5X0RURIb4jlsuIlOjznWyiMwXkRpv/24iEhCRv4jIWhEJi8jT7ZiXId77nt/CfpH87NteadldInKqiFwVY/1EL80dbZItY2KyCXeMSTIR+TFuAp3XcSNzrcANxPFl3Oho5cAzcQ4/DTdQR+RcGcC/cENz/gA3KMkO4AzgR8DVuFHJ0nmWvnRwKm5EOpvYyHRqFvSNSSIROQoXWP6uqldEbX7Gm5UrP97xqvp+1KoBuPm6H1PVGb732d97+hdVDbdBurM1vaZcNsbsBqveNya5rgO2ANfG2qiqS1T1o3gH+6v3ReQG3BDRAPd51dDTRWQ5bohPgJC/6l1E+onIgyKySURqReQjEfl21HtEquGPEpHHRaQcmONtyxORO73bERUi8iwwcDc+h7hE5GIR+dC7XbFJRO4TkR5R+6iI/E5ErhCRZSKyQ0TeFJERUfsFvf3WikiViLwuIvt5x9/g7TMVN33xAG+9ep+hX56I/N1LzyYReVhEurVlvo1JBivpG5Mk3r36ScDTqlrTBqe8F1gAPA78DngBV/WfDVyBm80vMkvXEhHJx43x3R34ObAS+DbwkIjkadM54sHdNvg37lZB5LfiLtxEVL8B3sPNFPZIG+QFABG5GXdL4q/AT3A1Gb8DRorIeG06J/m3gU9xtzGygD/hakv2U9UGb5/feHn9E25WtlLg2ai3/T+gN3Ao8HVvXXStxu24CZDOAYYDf8RNpXvenuTXmGSzoG9M8vTCTQqyoi1OpqqrROQD7+USVZ0d2SYiq719/Osux80rPklVp3urXxKREuB3InJfVFB9QlWv9R0/HBf0fqGqN3urXxGRAmDynubHa7D4E+A3qvpb3/rFwNvAybgZ8CLqgZNUtd7bD9wF0GHATBHpDvwYmKKq13nHvCoidcCfIydR1SUishGo839eUWao6g+95694n8WFInK+2gQmpgOx6n1juo6jgNW+gB/xMK6ke0DU+qeiXo/F/WY8FrV+Whul73jv/P8SkYzIgru1sAOXfr9XIwHfM997HOQ9jsK1j3g86rgndiNtL0S9no+rUSnZjXMZkzJW0jcmeTYD1cDgFL1/D9xUntHW+bb7Re/bz3tcH7U++vXu6uM9fh5ne8+o11uiXkeq5HO8x0h6N0Tttzvpbem9jOkQLOgbkySq2iAi04HjU9QafgvufnS0vr7tftHV1pGLgBJgqW99W5V2I90KvwxsbWZ7oiLp7QMs9K230rnpsqx635jkuhlXYv1jrI0iMlREDmyn934TGCgiR0StPwdXGv64hePnAGHgrKj132yb5PGqd/5Bqjo3xrKsleebD1QCZ0atj34NruSe2/okG9OxWEnfmCRS1RneyG+3isgBwFTgC1yL+mOBC3FBOG63vT0wFdfS/T8i8gtgFXAu7l76JVGN+GKl/VMReQT4rYgEcK33vwyc2Mp0nCAi66LWbVPVV0XkD8DfvYZybwI1wF5eGu9V1TcSfRNV3SoifwF+LiI7cK33DwG+7+3iH7/gY6CHiFwKzAVqVHU+xnQyFvSNSTJV/YuIvAtcCdyCa9W/AxdsLgGea6f3rRSRo3G1DDfjBvX5FPiOqj6c4GkuASqAa3Dd5F7HXaS83Yqk/C3GuoXASFX9uYgswo0u+APcLYaVwGvAZ614j4hfA4IL9FfgaivOB94Btvn2uxc4HLgR6IbrYTFkN97PmLQm1tvEGNOViMgZuBb9R6nqW6lOjzHJZEHfGNNpichY4Gu4En4NbnCen+JqOMZbH3vT1Vj1vjGmM6vA9e//AVCEa7D4GPAzC/imK7KSvjHGGNNFWJc9Y4wxpouwoG+MMcZ0ERb0jTHGmC7Cgr4xxhjTRVjQN8YYY7oIC/rGGGNMF/H/5OVUu6nK8pgAAAAASUVORK5CYII=\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 576x360 with 1 Axes>"
       ]
      },
      "metadata": {
@@ -173,34 +167,31 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: InterleavedRBExperiment\n",
-      "Experiment ID: f180d9c2-4802-42c1-bfd8-ed3370105c89\n",
+      "Experiment ID: 1596b9b3-7805-40eb-b4d8-5b76046cd597\n",
       "Status: DONE\n",
       "Circuits: 280\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- popt: [0.45521149 0.99869098 0.99906658 0.52983366]\n",
-      "- popt_keys: ['a', 'alpha', 'alpha_c', 'b']\n",
-      "- popt_err: [0.04251155 0.00017159 0.00016453 0.04329273]\n",
-      "- pcov: [[ 1.80723211e-03  7.06812871e-06  6.40084436e-06 -1.83883578e-03]\n",
-      " [ 7.06812871e-06  2.94425710e-08  2.40670557e-08 -7.23479207e-06]\n",
-      " [ 6.40084436e-06  2.40670557e-08  2.70685875e-08 -6.53292038e-06]\n",
-      " [-1.83883578e-03 -7.23479207e-06 -6.53292038e-06  1.87426083e-03]]\n",
-      "- reduced_chisq: 0.11377780079833481\n",
+      "- a: 0.45866193425920665 ± 0.05274545942959851\n",
+      "- alpha: 0.998121682066491 ± 0.0003163124671680783\n",
+      "- alpha_c: 0.99898852822204 ± 0.0003108272580212771\n",
+      "- b: 0.5268424448338176 ± 0.053582504822380604\n",
+      "- reduced_chisq: 0.042458924579051045\n",
       "- dof: 24\n",
       "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.0004667115741436856\n",
-      "- EPC_err: 8.226266996891632e-05\n",
-      "- EPC_systematic_err: 0.000842313005943951\n",
-      "- EPC_systematic_bounds: [0, 0.0013090245800876366]\n",
+      "- EPC: 0.0005057358889800079\n",
+      "- EPC_err: 0.00015541362901063855\n",
+      "- EPC_systematic_err: 0.0013725820445290027\n",
+      "- EPC_systematic_bounds: [0, 0.0018783179335090106]\n",
       "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 576x360 with 1 Axes>"
       ]
      },
      "metadata": {
@@ -240,34 +231,31 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: InterleavedRBExperiment\n",
-      "Experiment ID: f7136452-6d21-4f01-863d-080f0b82c29c\n",
+      "Experiment ID: 25b8eddd-3870-4fd1-bfc1-669b8b2936a4\n",
       "Status: DONE\n",
       "Circuits: 200\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- popt: [0.69722312 0.96960905 0.98331924 0.25887581]\n",
-      "- popt_keys: ['a', 'alpha', 'alpha_c', 'b']\n",
-      "- popt_err: [0.01166472 0.00182016 0.00341327 0.00568909]\n",
-      "- pcov: [[ 1.36065800e-04 -1.68564398e-06 -1.45989199e-06 -2.48308105e-05]\n",
-      " [-1.68564398e-06  3.31297578e-06 -1.71071499e-06 -4.66622029e-06]\n",
-      " [-1.45989199e-06 -1.71071499e-06  1.16503800e-05 -3.69833061e-06]\n",
-      " [-2.48308105e-05 -4.66622029e-06 -3.69833061e-06  3.23657136e-05]]\n",
-      "- reduced_chisq: 0.09217768064462115\n",
+      "- a: 0.7025910789890448 ± 0.012666513414869166\n",
+      "- alpha: 0.970612599176899 ± 0.001678935943989779\n",
+      "- alpha_c: 0.9834206895620717 ± 0.0028452724070327264\n",
+      "- b: 0.25733595618059046 ± 0.005070594525149778\n",
+      "- reduced_chisq: 0.1486612902280576\n",
       "- dof: 16\n",
       "- xrange: [1.0, 200.0]\n",
-      "- EPC: 0.012510569516598985\n",
-      "- EPC_err: 0.002559948969898621\n",
-      "- EPC_systematic_err: 0.03307585556038997\n",
-      "- EPC_systematic_bounds: [0, 0.04558642507698896]\n",
+      "- EPC: 0.012434482828446197\n",
+      "- EPC_err: 0.0021339543052745448\n",
+      "- EPC_systematic_err: 0.03164661840620528\n",
+      "- EPC_systematic_bounds: [0, 0.044081101234651476]\n",
       "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 576x360 with 1 Axes>"
       ]
      },
      "metadata": {
@@ -302,29 +290,40 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "---------------------------------------------------\n",
-      "Experiment: ParallelExperiment\n",
-      "Experiment ID: 2aa4c1cf-7575-46f4-b80c-c8dc4658eb00\n",
-      "Status: DONE\n",
-      "Component Experiments: 5\n",
-      "Circuits: 140\n",
-      "Analysis Results: 1\n",
-      "---------------------------------------------------\n",
-      "Last Analysis Result\n",
-      "- experiment_types: ['RBExperiment', 'RBExperiment', 'RBExperiment', 'RBExperiment', 'RBExperiment']\n",
-      "- experiment_ids: ['6ca546fc-b1c2-42b6-904b-b8b1bf465d4b', 'd3414e4d-90f1-4a19-8b44-4da6972e10fb', '8c888438-1d75-483c-9d8f-fdd2b2a34560', 'b686a25a-bfc2-497a-8ce2-afc32648d2f0', '09597176-8112-422b-894f-c95a20dd15e9']\n",
-      "- experiment_qubits: [(0,), (1,), (2,), (3,), (4,)]\n",
-      "- success: True\n"
+     "ename": "KeyError",
+     "evalue": "'num_qubits'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-6-bdba81279b7b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mpar_exp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mqe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomposite\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mParallelExperiment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mpar_expdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpar_exp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;31m# View result\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/base_experiment.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, backend, analysis, experiment_data, **run_options)\u001b[0m\n\u001b[1;32m    123\u001b[0m         \u001b[0;31m# Queue analysis of data for when job is finished\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    124\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0manalysis\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 125\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_analysis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    126\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    127\u001b[0m         \u001b[0;31m# Return the ExperimentData future\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/base_experiment.py\u001b[0m in \u001b[0;36mrun_analysis\u001b[0;34m(self, experiment_data, **options)\u001b[0m\n\u001b[1;32m    150\u001b[0m         \u001b[0;31m# Run analysis\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    151\u001b[0m         \u001b[0manalysis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0manalysis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 152\u001b[0;31m         \u001b[0manalysis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msave\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_figures\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0manalysis_options\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    153\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mexperiment_data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    154\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/base_analysis.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, experiment_data, save, return_figures, **options)\u001b[0m\n\u001b[1;32m     89\u001b[0m         \u001b[0;31m# Run analysis\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     90\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 91\u001b[0;31m             \u001b[0manalysis_results\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigures\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run_analysis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0manalysis_options\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     92\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mres\u001b[0m \u001b[0;32min\u001b[0m \u001b[0manalysis_results\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     93\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;34m\"success\"\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/composite/composite_analysis.py\u001b[0m in \u001b[0;36m_run_analysis\u001b[0;34m(self, experiment_data, **options)\u001b[0m\n\u001b[1;32m     62\u001b[0m             \u001b[0;31m# Run analysis for sub-experiments and add sub-experiment metadata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     63\u001b[0m             \u001b[0mexpdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexperiment_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomponent_experiment_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m             \u001b[0mcomp_exp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomponent_analysis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexpdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m             \u001b[0;31m# Add sub-experiment metadata as result of batch experiment\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/base_analysis.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, experiment_data, save, return_figures, **options)\u001b[0m\n\u001b[1;32m     89\u001b[0m         \u001b[0;31m# Run analysis\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     90\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 91\u001b[0;31m             \u001b[0manalysis_results\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigures\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run_analysis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0manalysis_options\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     92\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mres\u001b[0m \u001b[0;32min\u001b[0m \u001b[0manalysis_results\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     93\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;34m\"success\"\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/analysis/curve_analysis.py\u001b[0m in \u001b[0;36m_run_analysis\u001b[0;34m(self, experiment_data, **options)\u001b[0m\n\u001b[1;32m    665\u001b[0m             )\n\u001b[1;32m    666\u001b[0m             \u001b[0;31m# Generate fit options\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 667\u001b[0;31m             \u001b[0mfit_candidates\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_setup_fitting\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_series\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_xdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_ydata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_sigma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    668\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfit_candidates\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    669\u001b[0m                 \u001b[0;31m# only single initial guess\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/randomized_benchmarking/rb_analysis.py\u001b[0m in \u001b[0;36m_setup_fitting\u001b[0;34m(self, series, x_values, y_values, y_sigmas, **options)\u001b[0m\n\u001b[1;32m     54\u001b[0m         \u001b[0;34m\"\"\"Fitter options.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     55\u001b[0m         return {\n\u001b[0;32m---> 56\u001b[0;31m             \u001b[0;34m\"p0\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_initial_guess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_values\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_values\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"num_qubits\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     57\u001b[0m             \u001b[0;34m\"bounds\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"a\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"alpha\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"b\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     58\u001b[0m         }\n",
+      "\u001b[0;31mKeyError\u001b[0m: 'num_qubits'"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 576x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 576x360 with 1 Axes>"
       ]
      },
      "metadata": {
@@ -334,9 +333,9 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 576x360 with 1 Axes>"
       ]
      },
      "metadata": {
@@ -346,9 +345,9 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 576x360 with 1 Axes>"
       ]
      },
      "metadata": {
@@ -358,9 +357,9 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf0AAAGACAYAAACncLuXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAB5h0lEQVR4nO2dd3hcxdW437Mqq2pbbsLd2IDBuGGLHsAkgSQQY5KQwBeTwC9fqElIA1K+FELypVG+kNACKaYbAgFjSiAFU02xDbiABbjbCMtFMupa7Z7fH3Ov9mqtamm1K+m8zzOPdO/MvXfuSLtn5swpoqoYhmEYhtH/CaW6A4ZhGIZh9A4m9A3DMAxjgGBC3zAMwzAGCCb0DcMwDGOAYELfMAzDMAYIJvQNwzAMY4BgQr8biMhVInJ3N+9xq4j8uKf6ZBiGYRhtMWCEvogsFZEKEQmnui9BVPViVf15V68TERWRGhGpFpHtInK9iGQko4+d7MtBqXi2YRiG0XkGhNAXkYnACYACZ6S2Nz3KTFUtAE4Czga+0psPF5HM3nyeYRiG0T0GhNAHvgy8DCwEzgtWiMhCEblJRB4XkSoReUVEJgfqbxCRrSLyoYisEJETWnuAd/03Es6tEpHPiOP/RKTcu89qEZkWeP4vvN+Hi8hjIlIpIntE5HkR6fBvpKrvAS8CswLP/rSIvOHd6yURmRGo2yQiPxCRtzztx19FJCdQf4GIvOf14VERGR2oUxH5moi8C7wrIs95VW96Woez9/c9DMMwjOQyUL6Ivwzc45VPiEhxQv05wM+AIuA94H8Dda/hhOlQ4F7gb0EBGeAO4Fz/QERmAmOAx4FTgROBQ4DBwBeA3a3c47vANmAEUAz8EKedaBcRORSnyXjPOz4C+AtwETAM+CPwaMLWxgLgE8Bkr18/8q79KPArr4+jgM3AooRHngkcDUxV1RO9czNVtUBV72/vPUTkZhG5uaN3MgzDMHqefi/0ReQjwATgAVVdAawHvpjQ7GFVfVVVm3ATg1l+hareraq7VbVJVa8DwsCUVh71KHCIiBzsHX8JuF9VG4EIUAgcCoiqvq2qZa3cI4ITtBNUNaKqz2v7yRFWikgN8DawFPCF6YXAH1X1FVWNquodQANwTODaG1V1q6ruwU1y/ss7vwD4i6quVNUG4AfAsd4Wic+vVHWPqta10a8230NVL1XVS9t5J8MwDCNJ9Huhj1PnP62qu7zje0lQ8QMfBH6vBQr8AxG5XETeFpG9IlKJW6kPT3yIqtYD9wPneqrs/wLu8ur+A9wI3ASUi8htIjKolb5eg1utPy0iG0Tk+x2822yvr2fjVt753vkJwHc99Xql1+9xwOjAtVsDv28O1I32jv33qsZpJca0cW1rdPU9DMMwjF6gXwt9EcnFqalPEpEPROQD4NvATE/93tH1JwBXevcoUtUhwF5A2rjkDtxK+WNAraou8ytU9feqOgeYilOnX5F4sapWqep3VXUSzuDwOyLysfb6qI4HgGXAT7zTW4H/VdUhgZKnqvcFLh0X+H088L73+/u4SYM/Bvm4LYLtwcd20Kcuv4dhGIaRfPq10MftPUdxgnaWVw4Dnsft83dEIdAE7AQyReQnQGsrdAA8IR8DrsNb5QOIyJEicrSIZAE1QL3XrgWe8d1BIiK4yUW0tXZt8GvgAhE5ALgduNh7pohIvoicLiKFgfZfE5GxIjIU+B+clgLgPuD/icgszwbgl8ArqrqpnWfvACb10HsYhmEYSaK/C/3zgL+q6hZV/cAvOFX7gk64nD0F/AN4B6fyrqdj1fadwHQgGLRnEE4QV3j32Y1TgSdyMPAvoBq3cr9ZVZ/p4HkAqOpq4DngClVdDlyAe88KnKr9/IRL7gWeBjbg7Bx+4d3nX8CPgYeAMpyh3zkdPP4q4A5vK+EL7b2HuGBEt3bmnQzDMIyeRdq3EzO6ioh8GbhQVT+S6r60hYhsAr7qCXjDMAxjgNDfV/q9iojkAZcCt6W6L4ZhGIaRiAn9HkJEPoHb+9+BU50bhmEYRlph6n3DMAzDGCDYSt8wDMMwBggm9A3DMAxjgGBC3zAMwzAGCCb0+wgiEvYy9b3vZca72Qv201b7eSKyxst895KITA3U3eqd90uDiFQF6peKSH2gvrQb/RYR+Y2I7PbKb7ygPX79bSJSKiIxETl/f5/TxT5NFJEnvHH8QERubC9mg4iMEJF7vVDMFSJyT6DutxLPwrhZRH7Yxj2+LC5D4Ve70e+hIvKwiNR4z0rMIeG3+4v3rIP291mGYfRPBqzQF5HDxKWB7Stj8H2gBJiGC+M7Gy8zXiLikv7cA1wMDAGW4LLsZQKo6sVeRrwCVS3AReH7W8Jtvh5o01qCoc5yIS4y4kxgBjAPl/3P502cm+PKrtxUROaKyNL97NPNQDkuKdAs4CSvD23xd1x+hvHASODaQN2fgUNVdRBwHC7o02cT+lqEyzS4dj/763MT0IjLXLgAuEVEDk941kdwAZUMwzD2oa8IvGRQDJwF3C0iXwiuPjtCRE4RkbXeyu9PIjJTRF5OXlcBJyx/72W32wn8HvhKG20/ATyvqi94mQN/g0uYc1JiQy+2/udweQM6hYh8RVwSogoReUpEJrTT/DzgOlXdpqrbcSGKz/crVfUmVf03Ltphb3EgLutivReh8R/A4a01FJFTcXkKrlDVvV7WwNf9elUtVdWawCUxIHGF/Svc32tX8KSnvblWRLaIyA5PA5PbRj/8v9OPVbVaVV/AZXb8UqBNJvAH4BudGQTDMAYeA1noAzyLWzHFgHtE5PMdCX8RGQU8DHwLJ0hn44LxPNJG+/ESyHbXSmlVRdvW4xN+HysigzvZVnBagkQ+h4sv8FzC+V+JyC4ReVFE5gbeZz5u1fpZYAQuj8F9tM3huNW8z5u0IWB7kd8B54hInoiMAT6FE/ytcQxQigszvFtEXhORFpMnEfm+iFQD23CZDu8N1B2F09C0Fnr41zitzSzcRGEM8aRJiRwCNKnqO4FziWP5beA5VV3Vxj0MwxjgDHSh72epexAn/MEJ/7PaEf6fBN5W1X96aWfvBY6iDaHvxf0f0k7pbCCffwDf9PaXDwAu887ntdL2X7jMgnNFJBsnpLPbaHsecKef797je7gEOmNwE5olIuKrjC8GfqWqb3tahF8Cs9pZ7Rfgku747AUKuqJZ8fGEq58q+DHgI9IyfXBneQ4nLD/ECerltPH3A8YCpwLPAAfgNBWLRaQ5vbKq/hqXnGk2LtHSXq+/GbithK+raouEQ977Xwh829PeVOHGsq08BwVef4Ps9Z6LiIzDbZu0NWkwDMMwoe/jCf+/4YR/CHhIROa10rQY2Bg4fhN4R1XXJbmL/wu8DrwBvIQTUhFcBMAWeH05D5dwpwwYDryFE3DNiMh4YC4uSVDw+le89LgNqnoH8CJwmlc9AbghIGj34LQIY0TkhxI3/vNXttW0zEw4CKhOmGR0ClX9tT9ZAj4NvBCcQHXmHp4Nxz9w+/T5uLEpwm2BtEYdsElV/+yp9hfhki4dn9A39dT+dcDPvNOXAqtUtbWtnxG4SdiKwFj+wzuPiDwZGMsF7DuOeMe+AebvgKtVdS+GYRhtYEJ/X0YDRwObaN24bAdOSPgciksd2yqeer+6nbKgrWuDqGqdqn5dVcd4eep3AysSV5CB9g+q6jRVHQb8FJgIvJbQ7EvAi6q6oaPHE98u2ApclKCtyFXVl1T1lwHjv4u99mtxRnw+M+m+QVt3GIozyLvRm9TsBv5KfFKTyCrc+wdpb8KSSdyQ7mPAZ8R5CHyAM/S7TkRuxO3v1wGHB8ZxsGdYiap+KjCW9+AyPWZ6Rpo+wbH8GHBN4FkAy7q4fWQYRn9HVQdkwa1wvx44Ho2zyv4/YFw7143BqVkn4b7g3wQqgeIk93eM10fB7TNvBU5tp/0cIAO3cnwAuLeVNqXAVxLODcEZAuZ477cAqAEO8eo/A6zBCSuAwcDn2+nHxcDbgf6vBS4O1Gd7z3oRlw44BwgleSw34LwhMr33fbi18fHaDsWlJz7PG8+zcNqN4bhJ80W4SaDgtnnKgMsCY3lAoLwEfAcY7NXf4P1tRgb+xp9op9+LcPYT+ThNw97A32FkwrPU+z/JTfVnzYoVK+lTUt6BlL24J/S9L8jf4tSj4zt57edxqvZ13kTha97vk5LY3xNx2odaT1gvSKh/Evhh4PgFnOp3D/BHID+h/bGeMC9MOD8CpxGowk1mXgZOSWjzJWA1bvKzFfhLO/0Wb3z3eOW3eDkfvPqlnoAKlrlt3OuHODV3q6ULYznLe24FbsX9AIFJm3e/EwLHJ3jvW43b/z/BO+9vFezx6t7x+ihtPHcpLqWxf5yD28ff4I3l23gThjauH4rb1qkBtgBfbKetAgel+nNmxYqV9CoDNuGOZ5H+a+AV4HpV3ZzSDhmGYRhGkhnIQn8MkKWqm1LdF8MwDMPoDQas0DcMwzCMgYZZ7xuGYRjGAMGEvmEYhmEMEEzoG4ZhGMYAwYT+fuClLa1JCLJzpVd3lYhEvHOV4tLaHhu4dpSI/FlEykSkSkTWicjPvIQqyervKBF5VFxaXhWRie20HSki93lt93qx949uo+0+KVxF5Osislxcut6FPdD3b3sBZz70nhcO1D0jIju9uje9vAC9grg0tztF5IV22pwjLm3wXhEpF5E7RGSQVxf2/g82e/8Hb4jIpxKu/4K4xEZVIvKWiJzZjf6GvfH70BvP77TR7ife3/Tj+/sswzDSlwEr9KX7qXVnaiA9rar+NlB3v7rIaiNw/vJ/F8dQYBmQCxyrqoXAKbggLslMhxrD+ZN/rhNtC3B++nNwfuF3AI+LSEGwkbSdwvV94BfAX7rTYe8Zn8AF0fkYLvzvJOIhbgG+CYxSl9b2QlzGxFGduO9EEdnUze79BudX3x4vAser6mDiwZx+4dVl4mIcnIQLcPQj4AF/QuZ5l9yNC+YzCLgCuFdERu5nf68CDsaN48nAlSLyyWADcfkVPo8LMGQYRj9kwAp9upFat7OoagQnNA8AhuG+wKuAc31XQVXdqqrf1CRmRlPVHap6M/uG4W2t7QZVvV5Vy1Q1qqq34aLmTfHbSDspXFX176r6CC5M8D6IyKe9Va2vBZnRTnfOA/6sqmtVtQL4OS3T8q5Sl/QHXDCaLFwa3KQiIsfhMhb+tb123t82mE43ipd2V1VrVPUqVd2kqjFVfQyX02GO13YsUKmqT6rjcVxQnsleH0LiEhCtF5f97wFvUtkW5wE/V9UKVX0buJ3AWHrchEu21NjxKBiG0RcZyEIf9iO1blfwVNHnA/6X/8eBv2sb8fLbuEd7aXm/31N9bef5s3BC/73A6f1K4SoiR+A0ABfhJkF/BB4NquwTaC0tb7GIDAvc8zERqccFWVqKi5iXNMRlzrsRF82xQ39XEfmIiOzFTfY+h4v82Fq7Ylz6XD+W/nLgbRE5Q0QyPNV+Ay4XALgJ15k4TcFoXHTBm9q4dxEwinZSHIvI54EGVX2io3cyDKPvkpnqDqQadYEKHhSRh3Ar/3tE5O/AQ9p+EIOVIhIU3mer6lPe718QkU/jVkxrcPHqwQm6LqlOtZPZ45KBt/98F/Az9bK3STyF65z2rm2DC4E/quor3vEdIvJDXIz4Z1tp31paXnDpZHcDqOqnRSQLN6E6rK0JlbjEMzd7hyFcet/KQJMZqrqlE+9wGfCKqq4QkekdNVbVF4DBnrr+Alwo5cS+ZQH3AHeol61RVaMicicudXMO7n/p86pa4112MS53xDbvHlcBW0TkSwHth4+/NZM4ln5a3kJcOOBTOnofwzD6NgN9pd+Mp0LtTGpdn9naMtPcU4G6B7xzI1X1o6q6wju/G7fiSntEJBdYArysqr8KVP2O/U/hOgH4blBbgVPHjxaRBRI3inzSa99aWl6Ip5MF3DaKqj4JnCoiZ7T2YFW9V+MpeGcAWxL+fh0KfBEZjRP6/9P5V25+/nacXcWihHuGcBOrRpz2wD//cVyegrk4TctJwJ88zQu4sXw4MI5v47YPikXk1sBY+vkKYN+x9MfxKuAui05pGP0fE/r70lFq3e7wL1yq1U6Pu7SflveHPdw//5lhXGKXbbhVfZDupHDdCvxvgrDNU9X7VPWegFGkb8XeWlreHerS4bZGMK1tMjgKN2l7y3v3G4CjvLHI6MT1LfrnbSX9GWdf8jnPBsRnFm4LZbm35/8abgvDt6rfCnwqYSxzVHW7ql4cGMtfevYQZbSd4vhjwGWBv+k4nFHh97oyOIZh9AHay8bTnwv7mVrXa9tmBjPcqunuNuqG4iYTdwETvHNjgOtx6uVkvm8OLiWr4ozyctpol4Vb4T8CZLZS324KV5xgywF+5b1njn8foAQnrI7GZd/LB04nIdNf4FmfBD4ApuI8HP4D/NqrOxT4FM4TIgs4F7danp3EMQwnvPs3cYL4gDbaL8DL3IhbmT+Ls+nw62/FZTEsaOXak3AZAGd5x0fgNEWnesffxtkw+P9HI4D57fT9197zi7yxKwM+6dUNS3ivrTgr/n36ZcWKlb5dUt6BlL1491LrKs6SOpja9Xde3VW0IfS9+tE4Y7YPcOrVdcBPgbwkv29i+loN1N0K3Or9fpJXX5vwfie0c9+DAsdXtfKsqwL1n8R5EVR6gudvtCH0vfbfAXbgUs/+FQh75w/zBK6fAvg14DPt3GcB7aTl7ezfPuGe5wMvBI7HB+8F/C9OW1Lj/bwNGObVTfDGpj6hHwsC9/s6zoCyCpd+97uBupA3NqVe/Xrgl+30Nez9333ojed32mm7Cfh4Kj+fVqxYSU4ZsAl3xFLrGoZhGAOMgSz0LbWuYRiGMaAYsELfMAzDMAYaZr1vGIZhGAOEASv0PZe3SanuR7ogInNFZFuq+2EYhmEkj34v9EVkk4jUJfi3j1bnw7zBa7NQRH7R0b2M7iMiHxOXWbBWXJa8Ce20nei1qfWu+XigbpqIPCUiu0Rknz2qVmIaREXkD17dVHGZACu88i8RmZqcNzYMw0gf+r3Q95inLTPivZ/qDiWbTgaL6VVEZDjwd+DHuJgFy4H727nkPuB1nB/5/+DCJY/w6iLAA8B/t3Zh8O+Nc8usw7kHgssEeJbXh+HAoyREyjMMw+iPDBShvw/i5YEXkQtxPtxXeivCJa20fVZcXvPDveNR3urzmDbufb6IbBCXB32jiCzwzmeIyLXe6nSDiHzN60emV78pYTV7lYjcHTj+mxc1ba+IPOf3x6tbKCK3iMgTIlIDnCwio0XkIXF53zeKyGWB9rneNRUi8hZwZHfHtBN8Flirqn9T1XqcT/9METk0saGIHALMBn6qqnWq+hCwGi89sKqWquqfiUeVa4/PAeXA8961leqy2ykuSFBz9jvDMIz+jCXcUb1NXKrUbar6ozaafRSXB/0qXKSy7+FCpL6c2FBE8oHfA0eqaqm4/O5+ytMLgE/joqvVAA91sbtPAl/BRZ77DS5Jy6xA/ReB07xn5OCE3GLgv3CpWv8lIqXq8gT8FBcSdjIuMt6TtIOIrMIFn2mNe1X10k70v0XWPFWtEZH13vl1rbTdoKrBOPstMsN1gfOAOzXBVcWLWV+Am/z+ZD/uaxiG0acYKEL/ERHxM48tVdUzu3Kxuoxn1wAbRORgXLa4j7ZzSQyYJiJbVLWMeGa9L+Ai920FEJFf4SIDdrYff/F/F5dVrUJEBms8+c1iVX3Rq58OjFDVq726DSJyO3AO8JTXl0tVdQ+wR0R+TzuCT1Xby3vfWQqAnQnnmrO9tdI2ManPXlzY4k7j2QycRCvbAKo6xJuknQdYcCbDMPo9A0W9f6bGk5KcuT838ITji8BjwPP+Kl8SMpqpS316Ni71aZmIPB5QX4/GxTX36bSg8bYGfi0i60XkQ+IpWocHmgXvPQGXvS6Y0e6HuOQu3epLN0jMmgcts73tb9v2+BIuVO7G1iq9v9etwJ0iMrKL9zYMw+hTDBSh3xGdjVB0P3AITs3vLkzIaOade0pVT8FlZFsH3O41L8NlMPNJVJfXAHmB4wMCv38RmI/LsjYYmOidlzbeYyuwUVtmYStU1dM62ZcWiMjaVizi/XJre9cGaJE1z1tlT6b1ffm1wCRxud59ZrbRtj2+DNzRQZsQbty7pEUwDMPoa5jQd+wAOuOzPwNn9PVOWw1EpFhE5nsCrQG3Yo151Q/gUpiOFZEi4PsJl78BnCMiWSJSgrMw9yn07rcbJ6B+2UFfXwWqROR7ntFehufm5hvsPQD8QESKRGQs8I32bqaqhyd4QATLxR30xedh3LbH50QkB7edsEpVE/fzUdV3cOPxUxHJEZHP4Mb/IXBpab17ZHvHOeJSAjfj2WqMIW61758/RUSO8MZkEC7LYQUuJ71hGEa/xYS+48/AVE8N/khrDTzV7yXAu3gW5G3gZz97H9iD20++xKu7Hbef/iawEue+FuTHuJVvBfAz4N5A3Z04Ffx24C1cStY2UdUozqBvFrARl6b1TzgtAd79N3t1T+PS4CYVVd2JG7v/xb3j0TgbA6B5qySoNTgHl463Apcc6SzvHuC2L+qIr/zrcBnngpyHS2WbuCUwBOcOuBeXnW4yLs1sfXfezzAMI92x2PudRER+ixNAfwAuU9WTe+CeE3FCN0tVmzpobhiGYRjdwoR+JxAXVGYTzh3uFdx++Fmq+p9u3nciJvQNwzCMXsLU+53jcuA1VX1OVRuAK4G/icgVKe6XYRiGYXSafr3SHz58uE6cOLHH7ldTU0N+fn6P3W8gYmPYM9g4dh8bw+5jY9gz9PQ4rlixYpeqjmitrl8H55k4cSLLly/vsfstXbqUuXPn9tj9BiI2hj2DjWP3sTHsPjaGPUNPj6OItBl3xdT7hmEYhjFAMKFvGIZhGAMEE/qGYRiGMUAwoW8YhmEYAwQT+oZhGIYxQDChbxiGYRgDBBP6hmEYhjFAMKFvGIZhGAOEXhf6InKiiDwqIttFREXk/A7azxWRxSJSJiK1IrJKRL7SS901DMMwjH5DKlb6BcAa4Ju4dKgdcRywGpdbfhpwC3CbiHwxaT00DMMwjH5Ir4fhVdUngCcARGRhJ9r/MuHULSJyMi4v+72tXJJU9u6FvDzIyurtJxuGYRhG9+irsfcHAdt6+6GqsH07ZGRAfj4UFUFuLoTMMsIwDMPoA/Q5oS8inwY+BhyfiudnZkJBATQ0wLZtbgIwZAgUFkI4nIoeGYZhGEbnSGlqXRGpBr6uqgs72f544Enge6p6SxttLgQuBCguLp6zaNGiHuotVFVVk51dsM/KPhZzWoBQyE0KbOXfNtXV1RQUFKS6G30eG8fuY2PYfWwMe4aeHseTTz55haqWtFbXZ1b6IvIRnC3AT9oS+ACqehtwG0BJSYn2ZLrCZ55Zypgxc2nrb9PY6DQAoRAMHgyDBrnVv0iPdaHPY6k4ewYbx+5jY9h9bAx7ht4cxz4h9EXkROBx4Keq+rsUd6dNsrNdUYWqKqiocAZ/RUVuS8CM/wzDMIxU0utCX0QKgIO8wxAwXkRmAXtUdYuI/Ao4SlU/5rWfixP4NwP3isgB3rVRVd3Zm33vLCLOwA+gqQl27YLycjP+MwzDMFJLKkRPCfC6V3KBn3m/X+3VjwImB9qfD+QBlwNlgfJa73S3e2RmOmFfWAiRiDP+W7/eTQQaGlLdO8MwDGMgkQo//aVAm7vcqnp+K8fnt9a2rxEOuxKLQWUl7N7ttgOGDnUTg8w+sdliGIZh9FVMzKSAUMgF+AGn/t+xw/1eUOAMAE39bxiGYSQDE/opxvf7h7jvfygUN/7LyUlt/wzDMIz+gwn9NKI19X9WFgwbZqF/DcMwjO5jQj8NSVT/l5e7iUB+vov+l5dn6n/DMAyj65jQT3MyM+MGfg0N8P77ziWwsNDt/+fkWPAfwzAMo3OY0O9D+Op/VaipcRn/MjPd/n9+vsX+NwzDMNrHhH4fJBj8Jxp1e/87dzqh708AzP3PMAzDSMREQx/HT/MLLvjPjh1OE+Dv/+fmujaGYRiGYUK/H5GVFbfwb2iA7dudVmDQIFdyc23/3zAMYyBjQr+f0tr+f0aGW/0XFFj2P8MwjIGICf1+TnD/P9H/39//z85OaRcNwzCMXsKE/gAi6P8fjcaz//kGgBYAyDAMo39jQn+A0pYBYG5uPACQeQAYhmH0L+xr3WhhANjYCB98YB4AhmEY/RET+kYLsrPje/x+BEBoGQHQQgAbhmH0TUzoG20S9ACoq4MPP2zpAmgTAMMwjL6FCX2jQ0ScgM/JaekCGAq51X9hoeUAMAzD6AuY0De6RKILYFUVVFRYDADDMIy+gAl9Y78JhVpOAPbudTEAMjOdBsAmAIZhGOmFCX2jR0icAPhBgBInAIZhGEbqMKFv9DiJQYCCUQCjUaivNw2AYRhGKjChbySVjIyWE4CmJti82U0ABg2yLQDDMIzepNcdrkTkRBF5VES2i4iKyPkdtM8RkYUiskpEIiKytHd6avQ0GRlOC1BY6IR+ZaWbAGzY4EIC19c77wDDMAwjOaRipV8ArAHu9EpHZAD1wI3AacCQpPXM6DUSNQCVlbBnjztvRoCGYRjJodeFvqo+ATwBICILO9G+BrjYaz8DE/r9juAEIGgEmJHhtgAsDoBhGEbPYHv6RloRNAIMxgHwAwEVFFgkQMMwjP3FhL6RtiS6AfoTAD8UcGGhq7cJgGEYRufod0JfRC4ELgQoLi5m6dKlPXbv6upqNm5cakKmG9TXV7N27dJu3ycWi/8eCsWNBAcK1dXVPfq/PRCxMew+NoY9Q2+OY78T+qp6G3AbQElJic6dO7fH7v3MM0sZM2YuBQU9dssBx9q1Szn88Lk9dj9Vlw0wEnHH+flOC5CX5wID9VeWLl1KT/5vD0RsDLuPjWHP0Jvj2I+/Fo2BQDAZEEBjI3zwgZsM5OS4fAC5ufF0wYZhGAOZXhf6IlIAHOQdhoDxIjIL2KOqW0TkV8BRqvqxwDVTgWxgOFDgtUdV3+jFrht9gOzsuICPRKC83G0FZGVBUZHTAGRnmyeAYRgDk1Ss9EuAZwLHP/PKHcD5wChgcsI1TwATAsevez/tq9tok6wsV8BFAty1y00A/HwA+fkuFsBAsgUwDGNgkwo//aW0I6xV9fxWzk1MXo+MgUBmZnyP388IuGePW/EXFsZjAWRkpLafhmEYycT29I0BR9AVUBVqatwkQMSp/wcNcvW+lsAwDKO/YELfGNCItJwABA0Bw2G3DWB2AIZh9BdM6BuGh4gT9OGwO45EnB2AqtsaGDTI7AAMw+jbmNA3jDYIGgJGo24LYPfufe0A+nM8AMMw+hf2dWUYnSAjo+U2QF0dfPihO87NddsAFg/AMIx0x4S+YXSRxIBAifEAbBvAMIx0xYS+YXSTxG2AykrnDgguK+CgQbYNYBhGemBfQ4bRg2RkxFMDq0J9PVRXmzeAYRjpgQl9w0gS/jaAj+8NEIu5yYG/DWBBgQzD6C1M6BtGLxHcBojFoKoKKirisQL8oEBmDGgYRrIwoW8YKSAYFRBcUKCgMWBhYVwLYMaAhmH0FCb0DSMNCGYHjEadO6CfG8APDZyTY1oAwzC6hwl9w0gzEmMCRCIuNDA4D4DCQqcRiEbNFsAwjK5hQt8w0hiR1rUAkQisX++0AIWF8QRB5hFgGEZ7mNA3jD6ErwUIhVwMgKAtgK8FMI8AwzDawoS+YfRhglqAoEcAuMmBrwUIh00LYBiGCX3D6DckegQE4wL4moHCQjcB8F0HDcMYWJjQN4x+SjAugJ8kqKrKHVuqYMMYmJjQN4wBQGJ0wMRUwX5wIN8t0LYCDKN/YkLfMAYgQbdAaGkQaFsBhtF/MaFvGEYLg8DgVoBqywiB4bB5BRhGX8aEvmEYLWhtK8CPEAiuLpgnwOwBDKPvYELfMIx2SdwKCHoF+GGCCwvNHsAw+gK9PkcXkRNF5FER2S4iKiLnd+Ka6SLyrIjUedf9RMS+WgwjFWRlOVW/r/JvanL2AJs3w3vvQVkZVFc7OwHDMNKLVKz0C4A1wJ1eaRcRGQT8E3gOOBI4FPgrUANcl7xuGobREYlhgn17gA8/dMdZWc4o0LcHyDTdomGklF7/CKrqE8ATACKysBOXLADygPNUtQ5YIyKHAt8RketVVZPWWcMwuoRvD+DbBCRGCczKcvYAeXluomCTAMPoXfrCR+5Y4HlP4Ps8BfwcmAhs7I1OxGKxfY5DZsFkGO2SGCUwMT5AdnbLUMHmGWAYyaUvCP0DgG0J53YE6loIfRG5ELgQoLi4mKVLl3a7A5WVlTQ1KRkZWWzbttRTZe4lI0MYPHhQt+8/kKivr2bt2qWp7kafp7+Mo6orPiJO8IdCyTcIrK6u7pHvh4GMjWHP0Jvj2BeEfpdQ1duA2wBKSkp07ty53bpfNBrjk598haVLS/jNb17g8stPIisrSjQKxx33JvfccwQZGbbi7yxr1y7l8MPnprobfZ7+Oo5NTc4AMBp1Qj8cjkcK7OlwwUuXLqW73w8DHRvDnqE3x7EvSKsPgOKEc8WBuqTy05/Cs8/OoakpC1VBVWhszCQazWTZshlce22ye2AYA4fMzLgLYEGBO7drF2zZ4jwDtmxx9gF1dc5ewDCMrtEXhP4y4AQRCYQL4RTgfWBTMh9cUQHXXSdEIs40ec2aYS3qm5qy+OMfhb17k9kLwxi4BN0DCwrcVkBwErB5c3wSEI2mureGkf6kwk+/QERmicgs7/njvePxXv2vROTfgUvuBWqBhSIyTUQ+C3wfSLrl/oMPtjQsWrhw+j5tMjLgsceS2QvDMHwSJwHgjAK3bIH1690kYM8emwQYRlukYk+/BHgmcPwzr9wBnA+MAib7laq6V0ROAW4ClgMVOP/865Pd0Q8+gNra+PGoUdWUlRW0aFNb6wKTtIeqEowllHhsGMb+EUwfDC5a4J49TvWv6uwAfO8AcxE0jNT46S8F2pR4qnp+K+dWAycmr1etc8ABbn+xpsYdf/vby7nyyrn7tHvzTadiLCra9x6rVq2ioaGBkpISRARVZfny5YTDYWbMmJHcFzCMAUbiJKCpyX02d+1yhoF+sKC8vNT10TBSic172+Gss+Cyy+LHrVsOC//8Jxx9NHz5y3DhhTBypKtRVV5++WV2727i6aeHk5c3kdraTYRCrzFsWCbTp0+3Fb9hJJHMzJarez95UEUFNDTAhg3xSUB2tpsU2EfS6M+Y0G+HoiK4/HL4zW8am435gmRlRZg/P5OdO4Vnn4VbboG//AXOPhsuuQRGj47x1FMzeO21EkKhGJEIZGWNIRa7kCOPXM5XvhIjM9OikRhGbxFMHhQKOSFfVQWVlfFz+fnxsMGWQMjob5jQ74CrrxbKynZx550jEVFAyc5uIhYL8bnP7eHaa4sRgTfegD/8Af7xD7jzTrjnHjjooBDr188hGs1sNiryJw8rVszhuuuE732v4z6YTYBhJIfEDIKxmDMCrKpyx34WwYKC+CTAAnEafRkT+h2ifOUrm5g69SlGjhzNZZdBU9M2Rox4hSOOmAyMBIRZs+DPf4Z33oGbboKHH4bSUgGyWr1rJJLFH/8IF18Mgwe3/XSzCTCM3iMUiucNAGcM2NgIO3bEIwfm5rpJgJ9K2IwDjb6E/bt2gIgQDoc55pgpNDQ0ctRRQn7+RJYv30U4HN5nxX3IIXDDDXDwwXDNNUpTU9sr8owM5bHHhAULWq9XVTZt2kRZWRkAJSUlLF++nJUrVzJq1CizCTCMJONHBQyH4+eCHgLghL7ZBRh9BRP6nWDOnDmoKkuXPgu4iYC/8m6LSKRjP+HOuPvt3buX+vp6Vq5cybp166itraW+vp69FhHIMFJCoodANLqvXUBeXku7ANsSMNIFE/qdJFHAd7TCHjnSqf/q6tpuIwLr1kF1dTzQSBBVJT8/n127dlFTU0N9fT3RaBQRIT8/3/b2DSMNaM0uoKHBufr6WwI5ObYlYKQHNv9MEqef3nFscFXhscfgyCPhl790wYCChEIhJk2aRDRayJ//fD633HI+b745jWi0kEmTJllqX8NIQ0Iht8LPz3eC3g8fvGcPbNvmIgdu2ODsBKqrnc1AcmOLGkYcm28miSFD4OKLhVtvjdLQsK9bXnZ2lE98IoPycnjlFWf8d9tt8JnPwEUXwaGHugx/11wjPP/8+cRiIVSFZ5+dyzPPhHj99bXceWfMMvwZRh+gtS2B6mq3JSDiSm6umyj42oAM8+Y1koAJ/SRy+eXK++9/wMMPFyMSIxLJJCurCdUQ8+fv4PrrRxMKCStXOh//J5+EBx5w5eSTnVX/Cy9MJRqN/5l8l78XX5zKtdfSKZc/MLc/w0gnErcEVJ0d0K5dcQ1hdrabBJiBoNGTmNBPIiKwYMH7jBnzBG+9NZHa2gLy8qo5/PCNnHTSEYiMBmD2bLj9dti40f28/3545hlwuy+tr+Sdy5926PIHPeP2Z5MGw0geIk6wZwdigAUNBFXjBoJ5eaYNMPYf0w0nmbKyMgYNinH00euZN289Rx+9nsJCbXbDC3LggW5v/7XX4BOf6PjeGRnSYYY/VaWhoYHS0lKWL1/eLPBLS0tpaGigM4kKV61a1Xytf8/ly5ezatWqjjtpGMZ+4WsDCgpc0qC8vLg2wE8tHLQNaGgw2wCjY2yln0REhAkTJtDU1EStl66voKCAvLw8JkyY0OZKeehQmD4dnnpKaSc3EXV1Snl5+6tt370QoLS0lNLSUgCmTJnSodshtJw0QDxWQGlpKVOmTLEVv2H0Em1pA6qrIejBG7QNSLQlMAwT+klEVWlsbKS2trZZyPoCs7GxsV2BOXKkm9kHU/smIhJX/bUnd5988knq6+ubn6eqbN26lZ07d3Laaae1+w7dnTQYhpE8WrMNaGpyngLRqPte8PMJ5OU5r4KsLNsWGMiY0E8ifjS/oID0BWhr0fyCnH46/PjH7d8/FhP+9Cd47jn4yldcVsDgF4BrE2PLli3U1NSQnZ3NkCFDqKyspLy8nPz8fGKxWIeuf36/fYEPmMA3jDTETx8cXN3HYlBf7zQCvvo/Kys+EcjKssRCAwkT+klmxowZLVb0nYnmB0GXvxgNDfsK5ezsKCUlGWzY4OL9f//78Otfwxe/COefD2PGuHaqSjgcZvfuJv7yly8Si2Vw1FGvcMgh7zB0aLhTe/r+Hn6Q5cuXm+A3jD6AHzcgGErYNxKsqIgL+5ycli6DmZk2EeiPmNDvBboazc/niisAhFtucWl5VYXs7CYgg0suCXHFFU6V9/jj8Kc/weuvw803w623wic/Cf/933DUURmsWfMpHnxwONFo3Nd/6dKPctZZuwiF2tfzqSpLliyhrKyM2bNnt4j/X1ZWxrx580zwG0Yfo61tgYqKuMtgKOTa+NsCFkmwf2B/wrRGOfnk5QwZspHbb59HKJTDGWdsY+TIV5k1axJQQlaWcOaZcOaZsHKly/T32GPwxBOuDB8Oe/cWt0j84/v6L15cTHExXHll+73Yu3cvkUikxblIJNKl+P/m8mcY6Utr2wLB2AGqrmRmxt0GgwaFRt/BhH4a49sEHHHEgbz6ao5nhNd2hr/Zs1358Y/h7rvhzjvdB7YtD4C6OuHWW5WLLpJ2ff0PPfRQVqxYwcqVKyktLaWmpobMzEwOPfTQTr1HME4AxLcLLD2wYaQvrXkL+PYBVVXuuKHBuQ0GJwJmKJjemJ9+mrNt2za2bt3awkd+69atbNu2rc1rDjgALr8cvvtdyM5uf88+I4N2ff1FhOzsbEaOHMlf/nI6N944l/r6ekaOHEl2dnaXXP58u4CuxgkwDCM98O0D/JwCoZAT8rW1Ll7A5s0t4wdUVblJQkd5SIzew1b6aUwsFqOhoYFt27axePFi5s+fz+LFi9m2bRvjxo3r0PJ+zx6IRNoXyrW1wpYtbdf7bodbtuylujqPWCyDN96Yiuo2xo1r3+0Q9nX5mzAhj82bt5nLn2H0EzIy9l3ZR6Muy2BwBzArK64R8LcSTCPQ+5jQT2NCoVCzoN+6dSs33ngjAOPGjWP+/PkdutqNHAm5uUptbfuC9Y9/dNsA550Hidp2VfjjHwfx9NNfak7688wzJ/Hvf4dYs2Y9c+Z0bOH75JNPUpeQY3jLli2dihNgGEbfo62JQGIgIZsI9D4pUe+LyKUislFE6kVkhYic0EH7r4nI2yJSJyKlIvLl3uprqvEFf5DOCHxwvv7RaPttRJRIBBYtgk99yl1z//3gy+hrrlH+9a9JRKOZqIYAIRLJJhrN5F//msQ117Svno/FYpSXl7N582YqKysBqKysZPPmzZSXlxMzvZ9hDAiCYYX9kpnpNAJlZS60cDDt8Icfuq2Bjr7DjK7R60JfRM4GbgB+CRwBvAQ8KSLj22h/CfAb4GrgcOCnwE0iMq93epxaYrEYixcvbnFu8eLFnRKWvq9/bm7rgjk3V7nsMuG55+CCC1z7N96A73wH5sxxvv+33BIiEmk9jqdL+hOiIyP+wZ6VYGNjI01NTTQ2NrY4bxjGwCQjw8UFCE4EsrLcRGDHjpYTgbIypyWoq3Puhcb+kYqV/neAhap6u6q+rarfAMqAS9po/yXgdlW9T1U3qOoi4Dagk0ll+y6+wN+6dSvjxo3j61//OuPGjWPr1q2dFvxXXAEXXKBkZUURiQFKVlYjWVlRLrhAueIKmDwZrroKli+H66+HI45wH6677nIuO+2RkaHtGgKGQiEmTZrExIkTWbTo8+zZU4SqMnHiRCZNmtQpjYVhGAMHfyKQn99yIlBX13Ii8N57sH27iy1QW4sXyyTVvU9/enVPX0SygTnAtQlVTwPHtXFZGKhPOFcHHCUiWaragVjqu4RCIcLhcIs9fH+PPxwOd0pgqsY4+OBHuPDCMt555xDq6grIza3mkEPe4eCDR6F6JiLuPrm5cPbZrqxe7fz3V63qKOkPlJd3/C6+ar+tY8MwjLZozUYgFoPGRifwgwGFcnLi6Yd9OwGzF44jvekyJS6B/HbgJFV9LnD+J8ACVZ3SyjW/BP4b+DSwHDdpeAwoBkarallC+wuBCwGKi4vnLFq0qMf6X1VVTXZ2AX1tcVpevhPVGOFwuDn2fkNDAyIhRo4c0eZ1e/bA+vUZLF9ezMsvj6asrKC57uCDKzj66PeZMWMX48crQ4e2/fzdu3fT1NRERcVQDjignsbGOlSVzMxMhg0b1pOvOmCor68mJ6eg44ZGm9gYdp90HEM/kFAQP/FQKOR+T7dJQHV1NQUFPTeOJ5988gpVLWmtri9Y7/8cOAC39y/ADuAO4EpgH/22qt6GU/9TUlKic+fO7bGOPPPMUsaMmUsP/m2SjqqycuXdVFZWcvTRRzN16pG89tprrFz5CkOGDGHu3JPadJurrITzzlMaGvatf/fdIt59twhQzj9f+H//Dw46qPXn33XXXbz/fg333HMqP/7x6/z734M48MC3GD06nxNO+Ky57e0Ha9cu5fDD56a6G30aG8Pu01fGsKnJqf99o0BVpwHwwwz7IYZTlW9g6dKl9KSsao/eFvq7gChulR6kGPigtQtUtQ74iohc5LUrw63kq4Cdyetq/0BEOPfcc3nttdd45513eOeddwA4+uijOfLII9sVuPGkP1EaGvb1oxFRVIWFC2HhQjj6aJfw5/TTg3G9hVWrPsGDD46gqQmi0RBPP30cqidw1lk7aW/rwDAMoyfwBXqQaHTf7IN+8CF/eyAz000O+pp2tz169VVUtRFYAZySUHUKbiXf3rURVd2mqlHgHOAxVTV/r04gIhx55JEtznUk8H2++90YJ5/8LpmZTS0MATMzmzj11FIWL45xzjnuQ/LKK/DNb7pQwD/8obMLuOYaeOSRkUQiIc/lDxobs4hEQjzyyEiuuSYZb2wYhtE+GRlOwAcNBnNz3WSgosIZCfoRBjdudEaE/cF7IBXq/euBu0TkVeBF4GJgNHArgIjcCaCqX/aODwGOBl4GinDW/9OA83q9532U7qTGzcgIcdllDcyZcz833XQasViIY499jZKSHRx//DRmzgxRUgI/+xksXgz33eey/d1xhyu+NqA1Ohv73zAMozdoLd8AtIwwqBq3EcjJcROFvqQV6HWhr6r3i8gw4EfAKGANcJqqbvaaJPrrZ+AE/RQgAjwDHKeqm3qnx30bX+CXlpY2h771j4EOBb+qsnnzZkQ+ZNCgWjIzMzjqqPeaz8+YMQMRoaAAFixw5a23XLCf++5jn2iA77xT1OI4I0N47DF3nWEYRjrSmveAn4UwmI5Y1U0YcnNdSbWtQGukxJBPVW8Gbm6jbm7C8du4ID7GfuBn6gvGuvdj4beWqa819u7dS0NDA+edt4T8/HxqaqChoaHN1LpTp8LVV0NhIfzudy1d/m67bWaLtnV1Snl5mnwaDMMwOkl7WoHaWhdRENxEwLcV8CcDvlYgFSGH+4L1vtFNZsyY0SIxji/4OyPwVZWCggJ27dpFk7eR1dTU1Hy+vYQ7o0dDXp5QWxs/V1RUR0VFs5UfIi7hT22tswtIJYnv0lEyIcMwjETa0go0NbmJQEVFfIvAD0TUm0GF0nz3wegpEoVXZ4VZMKJeLBajoqKCWCzWqYh6rcX+/8EPXmlxHIvBAw/ArFnw7W/DsmWpScO5atUqli9f3iKF8fLly1m1alXvd8YwjH6FSNxFsKDAaUELCtzqv6qqd7/zTOgbHTJjxgzGjh3b4tzYsWOZkZiSLwHn8qeEw3HJH5wjZGdH+djHlJISZyTzwANw1llw/PFw3XWwaVMPvkQ7qCoNDQ2UlpY2C37f7qGhoaF5ImAYhtGThEK9r+LvknpfRI4BPgkcg7O4z8X53pcCzwKPqGpFT3fSSB2+AFy5ciXhcNjb069h5cqVQMeGgJdfDqtXr+XZZ6cSizmJn5UVIRYTPvKRt1i4cDqhkIul/eCD8Le/udja11/vylFHuYnApz9N0iz8g3YOpaWlzUaOQTsIwzCM/kCnVvoicp6IrMb50n8byAPeBV4BKnAudX8CtovIQhE5MEn9NVJAWZmLdDx79mwWLFjA7NmzW5xvH+XjH3+dSy65jSFD9pKREePjH3+eSy65jY9//HXAraInT4bvfc/5+t93H3zuc04V9uqrLgfAEUfARRfB0093nARof1i9evU+K3pVZfXq1T3/MMMwjBTR4UpfRFYBI4A7gS8Db2gr+k4RGYyLj78AeEtEzlfV+3u4v0YvIyJMnDiRUaNG7Zf1fygU4txzz+XOO+8kP7+ajIwoU6eupqioiHPPPXcfm4CMDDjxRFd+9St44gm3+n/pJXjsMVeGDYP58+Gzn3W2AN1diKsqGzduZOvWrWRlZTVrM1599VXGjRvH9OnTbbVvGEa/oDPq/T8Df1TVxEx3LVDVvcA9wD0iMhMXL9/oB3TX+n/lypVkBDauRISMjAxWrlzZ7n3y8+Hzn3dl+3Z4+GF46CF45x34y19cOfBApxX4zGdg4sT9ez9VJRaLEfFUCP7vkUiEWCxmVvyGYfQbOlTvq+oNHQn8Vq55U1Wf2v9uGenG/lr/iwhZWVlEo1EWLHiYoUMryMjIIBqNkpWV1en7jBkDX/86/Oc/8I9/wAUXwIgRLjzmtdc647958+Cvf4Vdu7r2br6Hwvjx47nrrjO5+eaPEo1GGT9+fIceCoZhGH0J+zYzkkosFmPjxo1UVVUxbtw4Ro4cybhx46iqqmLjxo3EuuirIgLTp8NVV8Hy5XDvvU7Nn5cHK1fCj37kYv+fe67TClRXd+6+a9euZceOHc3HqsqOHTtYu3Ztl/pnGIaRznTael9EzgTmA1MBP3v6HuAtYLGqPtLTnTP6PqFQiHA4zNixY5k/fz5vv/0c8+fP55FHHiEcDndrFZ2ZCSed5EptrTPy+/vf4dln4ZlnXMnJgVNOcer/uXOdX2wiTU1NVFZWUldXByiZmVnEYjHv2NVnJqboShEWQMgwjO7QGUO+ImAJcBywBVgLvONVDwXmAueJyDLg0+ayZyQyduxYGhoaWtgEjBs3jnBrEng/ycuDM890Zc8eWLLEJQB65RX3+5IlzuXvU59yRoDHHRdPtZmRkcHo0aPZsGEDqtDYGGkWpqNHj25hj5BKVq1aRUNDQ7Mhpe9OGQ6HO4yZYBiGAZ1b6V+HS4Jzkqo+31oDEfkIcDdwLfDfPdc9o68TDHwDTjgHEwAlY6U6dCicd54r27c74f/ww/FEQIsWwfDhzvd//nwoKREmTZrEqFGjWLQo7g1w/PHHk5ubmxYr6VSMo2EY/Y/OCP0zgEvbEvgAqvqCiHwPl0THhL7RTGLgmwkT8ti8eVuvBb4ZMwYuvdSVd991E4BHHnEGgAsXujJqFHz609OIRJ6muvpgVDNYvXoGubnvcdFF5yS1f51FRMjOziY/P7/FOObn55OdnW0C3zCMTtEZoR/GBeDpiEogu6NGxsDDF/z+KhU6juSXDA4+2EUI/O53Yc0aePRRV7Ztg9tvD+GCTboQFM88M5d//1t48cXV3HHHdDIzU6viV1UaGxuprq6mtrYWyKOmpqb5vK30DcPoDJ2xoloG/I+IFLbVwKv7AS5in2G0wN97DhJMbtPb+B4A//M/8PLL8IUvQCjkexEIIDQ1ZRGLZfLcczP4/vczejULVmuICDt27KCqqoqGhgaamppoaGigqqqKHTt2mMA3DKNTdGal/y1gKbBZRB4H1hBf+RcBhwOnA1Hg5J7votGXCSavmTJlCnl5NeTkjGte9ac6tv3evU7l7+cFSCQWC3HfffDCC3DGGS5z4IwZ3Y8C2FWi0Sjbtm2jrq6OBx44m+99bx2x2PvU1dWxbds2otFo2hgcGoaRvnQo9FX1LS/C3pXAPOCLuOUQOF3oJlyI3mtU9f0k9dPoo4gI4XC4eQ//rbee7VIY32Tz+OOdy3K1dSvcdJMr48Y54X/66S4nQG+8QigUYtSoUaxfv96LIKhEo1FEhFGjRlkAIcMwOkWnnI9VtQyXaOfbIpKDW+EDVKpqXbI6Z/QPuhPGN9mUl0NdJ/6Dzz7bWcw/8YSbANx6qyujRsFpp7kJQElJctNkjh49ep8kR3l5eYwePTp5DzUMo1/R5eWBqtaraplXTOAbnWJ/w/gmm5EjXTa/9sjLgzlz4Be/cFEAH34Y/vu/ncAvK4M//9lFBZwzx2UKfO65ns8E6Fvv+7EN/OELh8NpZb3fWqZCwzDShw6Fvoh8tqs3FZFRInLM/nXJMHqP00+HaLT9NtGo8+kHCIXgqKPg6qtd2t8lS+CSS2D8eNi5E+6+G/7rv1z2v29+0+UJ6IwmoSNisRjr16+noqKCUCjUvG1SUVHB+vXruxzOOBmsWrWqhYGmb8+xatWqFPfMMAyfzqz0/yAib4jIxSIytL2GInKCiNwGvAdYiDAj7RkyBC6+uO3Vfm6uqx88eN+6UMjF+f/Rj1zq36eegm99C6ZMgcpKePBBpxGYNg2++lV3XFm5f/0UEWpqasjOzmbQoEIyMzM5+uijyc7OpqamJuUr/WDwIF/w+wacDQ0NtuI3jDShM3v6BwOXA1fjJgBvA28CO4EG3P7+JKAEGAw8B5yiqua+Z/QJrrjC/bz1VqeWj8WcSj8ahQsvjNe3h4gT7tOmufbvvedW+U8+CW+84X4++aTb8z/2WPjkJ+ETn4DObseLCDNnzqShoYFnnnHes+lkEJkYhMn3zuitIEyGYXSOzqTWrVXVq4GxwLnACmAO8BWccd88IAO4AThcVU/uSOCLyKUislFE6kVkhYic0EH7L3rahloR+UBE7haRAzr3iobRPiJw5ZWwYoUyYQKMHeuy+K1cqVx55f5Z5x90kEsF/Pjjbhvg5z936X/Buf/96Edw5JEuF8D//Z8LEdzRYnjGjBlMnjyHHTuESATuvVeYPHlO2sTdDwp+HxP4hpFedNqQT1UbgX8Dl6jqVFUdoqo5qjpGVT+mqj9T1XUd3UdEzsZNEH4JHIEL6POkiIxvo/3xwF3AHbiYAGfiMv3d09m+G0ZHrFq1ivfeW05xsTJ2LHzxi8q77/bMfvSYMfCVr8ADD8Cbb8INNziL/9xcWLUKrr3WZQI87jj4yU/cpCDREFAVLr98B7Nnw+bNSmMjXHWVMnu2O58O2vN0C8JkGMa+dMaQL0NErhKRCmAH8KGIPCQiQ/bzmd8BFqrq7ar6tqp+AygDLmmj/bHANlX9P1XdqKovA38Ajt7P5xtGC1SVTZs2sXLlSqqrqwAnvFauXMmmTZt6VGgVFcFZZ8Htt8Pq1fDXvzrDv+HDYcsW5wlw9tkwc6bTFCxe7AIIXXON8ve/DycSCRGLuZVzba0QiYT4+9+Hc801qRWsvsBft24dU6ZMYcGCBUyZMoV169aZ4DeMNKIzK/2LgZ8Ar+Oy6C0G5gP/19WHiUg2bmvg6YSqp3Gpe1vjRWCUiMwTx3DgHOCJrj7fMNpi1KhRAFRVVVFevoOVK1e2OJ8McnPh1FPdSn/lSpcI6Otfh0MOcYL+4YddoqAZM+D3vxcaGloPAtDQkMGttwp79yatqx0iIrz77rs0NTUxe/ZsRITZs2fT1NTEu+++ayp+w0gTpKMZuIi8AbyiqhcFzl0E3Ajke2r/zj1MZDSwHZem97nA+Z8AC1R1ShvXfRZYCOTijA//CcxvLU6AiFwIXAhQXFw8Z9GiRZ3tXodUVVWTnV2ABT/bf+rrq8nJKUh1N1qltraW6urq5uOCggLy8vJS0pft23NZtmwYr7wyjNWrhzSv7gFGjqzhqKM+YNy4D5k48UMyMpRQyBkFDm3Xvya5VFZW0tjYSHZ2NkOGDNnnON1I5//FvoKNYfeJxaCxsZrCwp4bx5NPPnmFqpa0VtcZof8h8FlV/Vfg3BBgDzBFVd/tbEf2R+iLyFSckP8d8BQwCrgGeENVv9ze80pKSjRxj7E7PPPMUsaMmUuB/Y/vN2vXLuXww+emuhv78Oabb7J+/Xq2bdvWfG7s2LFMnjyZmTNnprBn8KtfwY03dtzu0ktdEqFUEYvFWLx4Mb/5zZEAfPGLf2fcuHHMnz8/LcMEp+v/Yl/CxrD71NTAli1L+djH5vbYPUWkTaHfmU9iAfBhwrkq72ebmffaYBcuMU9xwvli4IM2rvkB8KqqXqOqq1T1KeBS4EsiMraLzzeMfYjFYrz++uts2rQJEaGoqAgRYdOmTbz++uspD3wzfjzk5bWcnJ900pZ92t1yi0sKdMMNLnVwb2+jh0Ih5s+f3+Jcugp8wxiodPbTOEZEJvkF55e/z3mvrk28rYAVwCkJVafQdlrePNxEIYh/bN8mRo8Q3HMOar/SYS/aRQ1s2Y958za0OBaBzExYsQJ++1sXA2DOHLj8cuc2+GHitD0J+Cv9IIsXL075pCkRCxVsDGQ6KzQfBN4NFN8175GE851R9V8PnC8iXxWRw0TkBmA0cCuAiNwpIncG2i8B5ovIJd7E4njg98BKVd13uWMYXSQUCjFr1iwmTpxILBajsrKSWCzGxIkTmTVrVspXqp2JGnjZZbB2LfzlL7BgARxwAOzYAffd5wIMTZ/uvAZuuqlzMQG6SiwW46677mLTpk2Ew2HGjBnDuHHj2LRpE3fddVfaCH4LFWwMdDoTke//9eQDVfV+ERkG/Ai3P78GOE1VN3tNxie0XygihcDXgeuAvcB/gO/1ZL+Mgc2MGTNoaGho3tMXEcaOHZs2gW+uuALKy3fw0EMjaGpyq/68PKWpSTnzzJ1ccUUxIm6F/4lPOKG+di0884wry5fDsmWu/PKXblIwd64rJ5zgJhbdQUQIhUJkZWU1JwUaO3Ys27dvb84VkGp810w/U2FeHs2umaNGjWL69Olp0U/DSCYdCn1VvaOnH6qqNwM3t1E3t5Vzf8D55htGj+Ov9l5//XXC4TD5+fnU1NTw+uuvp1EaYOXss7dwyCHPcvvt88jOhvPP38TIka8ya9YkYCQQ72MwLPA3vuFcAJ97zk0Ali6FDz6ARYtcCYXgiCPg5JPhpJNcjICupggWEWbMmMF7771HXV0tdXW1lJaWMmrUKA466KA0GD+HqhKJRFi5ciVTp47grbdKiUQipuI3BgydWekbRr/HX/3Nnj2bkpKS5hVgYv76VBEMcZuTsxeRJiZMeLHTse0HD4Z581xRdSp+fwLw2mvOFmDFChczYMgQt/qfOxdOPLFz+QFUlc2bN7Nr1y6amqJkZmZQXV1NTU0NWVlZzJgxIy0E/+jRoykrK+MvfzmNK69cR23tZnJzcxnd2SQIhtHHMaFvDHhEhIkTJzJq1KhmAZpOyWx84v3a0Xxuf7QQInD44a58/etQXe2yBD7zDDz7LGze7FIGL1ni2h9yiBP+J57okgW1Fbpg1KhRbNmyhVgsRmOjUldXR1ZWVlIDHHUFEWHOnDls3bq1+ZyqMnLkSObMmZM2f2fDSCYm9A0Dt6evqs1f/Omj1o8Tj20/rvnc8uXLu93PggIXGfDUU93xxo1O+C9d6iYD77zjyp/+BNnZzivAnwRMn95yK6CpKZ/q6nxisQxWrZrGzJnbWn1mKlBVHnvsMbZv3w4c2Xx++/btPPbYY8ybNy+t/t6GkQxM6BuGR+IXfjoJAFVlyZIllJWVkZs7hczMTKZMmdK8BdGTAuvAA105/3xobHQhgp97zpU33ogbBP7mN24r4Pjj4YQThOefP5B//GM2sZigKjzzzEn85z8ZbN26i5KS1I+lqrJlyxYaGxsREUSErKwsGhsb2bJlS4tJX6pJ7Es69c3o25jQN4w+Rm9+92dnwzHHuHLllVBRAS++6CYAzz/vkgQ9/rgrMLzFtZFINgAPPzyc4mLlyitTK7RUlQxPLeHb7UWjLuRHRkZG2hjzrVq1ioaGhmYNjq/hCYfDaeNNYvRdLLhNF4nF9k17ahjJRkSYN28es2fP5ktfepSioj2UlpYye/bsXlVLFxXBpz/tAgAtW+YmAD/9KYRCbQvMhoYMbroJtm/vlS62SUZGBsceeyxFRUWoKqpKNBqlqKiIY489tnlCkEpUlYaGBkpLS5vjCSxfvpzS0lIaGhrSZmJi9F1spd8FRGDcOCgvh6oqyMmBrKxU98oYKPiGaKWlpc3nUm2ANnEi5OdDTo5QW9t2u6Ym4ZhjYNYstx1w/PFQUtJ2wKFkMXPmTCKRSLO2RESYPn16yvMr+ASNSEtLS5v/1p310jCMjjCh30Xy890XXW2ti3hWV+e+uEz4G8nmzTffZMOGluF3Fy9ezKRJk1IqtMrL3eegI1SdfcDKlfCHP8SNAo87zpUjjgAvrk9S8FfNr7zyCi47uBOy7nj/PCGSgS/4g5O7dOmb0fcx9f5+IOKE/4EHwtixTuVfVWVqfyN5xGIxNmzYwNatW8nPz2fo0KHk5+ezdetWNmzYkNIwtyNHdrxiz8uDn/0M7rgDLrrIBQ2KRNwWwXXXwec+B1Onwhe+AL/7Hbz6KjQ09Gw/VZW33nqLSCRCOJxDVlYWEyZMIBKJ8NZbb6WN6jzupREnGDrYMLqDrfS7gYhzd8rPdyt/U/sbySIUChEOhyksLKS6upo9e5Tq6hoKCwsJh8MpzQ9w+unw4x+33yYadbH/Bw+Gj3/cnauogJdfdm6BL70E69Y5G4EXX3T1OTluC+DYY12ZNat7moBQKMSIESMoLCxkxAhndHjmmWfyyCOPkJOTk/IcC9DSS6O1QFHmVmh0FxP6PYC/8vfV/jt3uqxmOTlOhWkY3UVVGTFiBLt27aK2thbIp7a2ltzcXEaMGJFSly4/IdBtt7Wu5s/NdUl/Bg9ueb6oCD71KVcAdu92wv/ll50GoLQUXnjBFXCfpyOOcBOAY46B2bO7bhNw2mmnsWdPjOuvFyIRuO++EJ/61JkMHZp6gW8YvYEJ/R7EF/55ee7Lb+dOt/LPzk7uXqXR//GN+LZt20ZlZSVNTU00NDSkTTS5xIRAsZjskxCoI4YNi4cKBti1ywn/l192Zd26eIwAcNq0WbPg6KPdJKCkBAoL276/KlxzDdx6a4hIxMUguOoq+PGPQ1x8sXuHVC+iRYQJEybQ1NTUwpBvxIgRTJgwIeV/Z6PvY0I/CYg4wT9+vBP+u3Y54Z+V5VYrhtFVVJUVK1ZQU1NDOBwmIyOTcDhMTU0NK1asSANDr5YJgUKhHM44o+2EQJ1h+PCWk4A9e+ITgJdfdvkDXnvNlRtvdImDpk2Do45yE4GjjnL38LnmGqeNCNoK+B4Ht93mfl555X4PQI+gqjQ2NlJTU8Mtt3yUjIwMzj13cfN5C9JjdBcT+kkkUfjv3u2Ef2Zm77sqGX0bESE7O5v8/Hzvix/y8vLIz88nOzs75YIgMSEQ7O1SQqDOMHQonHaaKwCVlU7gv/wyvPIKrF4Nq1a58qc/uTaTJ7sJwOGHwy23uNV9a9TVwa23OiPDxG2I3iSo0YnFlFgsvTQ6PhYxsO9iQr+XyM11lv4NDW7FsndvXPjbZ8XoCH+lV11dzaGHHkpeXg05OeNYt25d2qwAeyohUGcZMgROOcUVcKv2FSvcBODVV51r4Pr1rrTGtm0FLY4zMuCxx2DBgqR0t1MENTqhkBAKZaSZRqdlxEC/zxYxsO9gQr+XCYdh1Ci3f1lZ6SyYMzKc2j8NjIeNNEVECIfDHHrooZSUlPDWW8+mXSbAZCUE6ix5eS4l8AknuONIxK3+X30V7rsP3nuvZfvf/a6kxXFtLQQS8KUEEWHnzp1EIhFCoYxmjU4kEmHnzp0p/zsHIwaCG3M/YuCUKVPSYvJptI8J/RSRne38m4uK3Kq/osIZGuXmtsxaZhg+6ZwJ0Bf469atIy9vCgUFhUyZMoV169YBqQkuk5XlLPxnz3YGfj/9aUvvguHDa9m1q2We4BtvhH/9yxkFlpS44EETJ/aeNi4Wi7Fz504qKioIhTIYMWI4+fn5bNq0iVAoRCwWS6lrYWLEwAkT8ti8eZtFDOxD2NoyxWRlOWOjSZNgxAi351hVBU1Nqe6ZkY6kayZAf4VaUFBAQUEh4PamCwoK0mKFevrpLohWkO9//9UWxyJuwv3223DXXfDNb8JHPgIzZ8L/+39w003OfqAz0Qf3FxGhqKiI7Oxsmpoa2bFjBzt37iQ7O5uioqKUjyPA6tWru3TeSC9spZ8mZGS4Vf/gwVBd7Sz+6+rM3c/oG/hxBNatW0d1dRUFBYWsWLGC6upqxo4dm3K1b2djCVx2mTMEXLECli93ZdcuePppV8DZ4kyd6jQIc+a4Mn58z2gD/MRKr732GnffHTfkO+aYYzjyyCNTLvR99f6KFSu8vuQ12xvMmTMn5X9no2NM6KcZoRAMGuTUkUF3v8xMt+9vnycjHfG9CwoKCjj33MWICOvWKQUFBWnhXQDODx+clb4fMjsvz0ULvPDCuJ/+UUe5Am7LbfPm+CRgxQqnCfC9BBYudO2GDYtvJRxxhIsf0F7MgPZYtWoV27dvR3U0Ik7Qbt++nXA4nBaJgcrKyohEImRlZaHq+heJRCgrK0t11/ocLrRy73pBmNBPU4LufvX1zuhv7143KcjNNaM/I70I+pfX1taSl5dHbW0tIpJG3gXOD//CC1164OxsF5zn059u201PxO3pT5zo8gMA1NTAG28474AVK1zZvRv++U9X/OsOOcRNAPwyZYqbvLeHn2Nh3boyamryUc1k9erp1NY624jp06enPFzw3r17ERHuuGMeV1zxNlCOiLB3796U9quv4XtBHHZY3Ati2bJlhMNh5syZk7TnmtDvA+TkwAEHuNVE0OgvJ6fjLxHD6A2C/uV79uyhwYuAk27+5eBU/cXFzp7GF+RdIT8/nh4Y3Gdxy5Z4BsGVK2HtWhdGuLQUFi1y7XJzYcYMpwWYNctNBMaOTdTeCY8/PpV//nMe0WgIVeFf/zqBf/7zRE45ZT3z56d+HAcNGsTu3buJxWKoKnV1dYgIgwYNSnXX+gxBL4i6uhAjRsCyZctYs2YN06ZNS+okOSUiQ0QuBa4ARgFrgW+p6vNttF0InNdKVa2q5ietk2mIb/RXVOT2/Xfvtn1/Iz3w/curq6sJh8Pk5+dTU1NDdXV12viXJwsRmDDBlc98xp2rr3eC//XX42XzZhdDwMvkC7iJvD8JmDkTnn9e+M9/DqapKb6aj0Rc9q7//Odgrr1WUho1UFWJRqMtsjqqavP5dNDo+KRzAKGgF8SqVe8SCmVRWbmbadOmceyxxya1n70u9EXkbOAG4FLgBe/nkyIyVVW3tHLJN4HvJ5x7EXguqR1NYzIynDpy0CDnWxyM9Gf7/kYqCO7p+19Y+fn5aRMxsLfJyYkb+fns2eO2BfxJwBtvuM/uv//tSpzW1fcNDaGURw0MhUJMmjRpH1V+UVERkyZNSvnWg08wgJCIpGUAIV/wr1oVjx6VbIEPqXHZ+w6wUFVvV9W3VfUbQBlwSWuNVXWvqn7gF2AyMAm4vfe6nJ74CX7Gj3d7jgUFbr+xutoZJxlGb6GqbN68mfLycqZMmcKCBQuYMmUK5eXlbN68Oa1ywSf2pbf6NnQofPSj8N3vwt13u8BBL70EN98MF1zgPsPQfl9iMeUPf3Cf81TgG+01BuIZ+3YbkUgkLf7OQdX58uXLmwV+aWkpDQ0NadFHCAazirNs2bKk969XV/oikg3MAa5NqHoaOK6Tt7kAWKuqL/Vk3/o64bDbpxw2zK369+xxvv7hsKX3NQwffwUIqQ8hG9wWmD/frd6vvbb9VV4kItxyi/NAOOggmD7d2QnMmOGSDeX3wobnunXrqKurIxQKISLk5uZSV1fHunXrmlXWqSQxgJAfPTCdAggFJyIHH3wYw4ZVMXbsKNasWQMkd8UvvTnrEZHRwHbgJFV9LnD+J8ACVZ3SwfWDcVqBH6jqDW20uRC4EKC4uHjOIt+Kpgeorq6moKCg44ZpQizmBL//J04HzVt9fTU5OX1nDNOVdB3H2tpa6uvrm49zcnLIy8tr54rexe/f7t1DGDGiluzsEPX19WnRzz174P339w0i1NQkfPBBPtu2FbJtWyEffFDI1q35RKMtP9AiypgxdRx8cJVXqpk8uZqCgp6N9LV7924ikRh79gxj1KhaampCZGbWkJUVYtiwYT36rO6yZ8+e5t+HDh2awp7sy969H6IaY9CgITQ2VlNYWMCePXsIhUIMGTKkW/c++eSTV6hqqzOwvmb7fS5uS+Kuthqo6m3AbQAlJSU6d+7cHnv40qVL6cn79RYNDc7qv7LSHafS6n/t2qUcfvjc1Dy8H5Gu46iq3HPPPc3HCxZ8Ji1WVj7+Cuu668bx7W+vobb2g7RZAVZWwnnntUz9m0g47OwBwmFYt87FCvCzC65bJ2zblse2bXk880xx8zUTJjgtwPTp7ue0aS765/6gCpdfvoMHHxxONCpcc81z/PCHxxOLhTjrrF1ce21xWtgU+X/nzZu3NZ/LyRmXFn9ncP1bsmQJ77//AVOnjmPECMjKymLjxo2MGzeOk046qd9Y7+8CokBxwvli4INOXH8B8JCq7umwpdFMOOzi/A8b1tLqPyvLTQAMoydobY+yNxPudAbftRDKm8+li0thZ6MG+kZ8vtW/T0ODcxH0AwetXesCCW3e7Mrjj8fbFhc74X/44fGfEyZ0bAR8zTWweHFxizDhjY3Ou2Dx4mKKi0mpdwHEBWpZWRmzZ8+mpKSE5cuXs3LlSsrKypg3b15a/L1HjRpFWVkZb775BrNmDWH79s2ICGPHjk3qc3tV6Ktqo4isAE4B/haoOgV4qL1rReQoYCbwraR1sJ8TtPqvr3f+/lVVTu2fk2OJfoz9J7hH6a+c/WNITcKd1njzzTdZv349QROiRx55hMmTJ6dFtLvEqIGx2L5RA9siHI7v7/tEIi67oD8JWLPGlR07XAl6DRQWuvDChx8eLwcfHF8YVFa6frWliairI+XeBT579+5tYVjoGyCmSwChoN3B1742mtGj11JfX8/cuXP7n8secD1wl4i8inO9uxgYDdwKICJ3AqjqlxOuuxB4V1WX9l5X+ycibtWQm+u+FKqr44Z/5vNv7A9+6t+gqjzdUv/GYjHeeOMN9uzZw7e/DVOmDKW0NI/NmzdTVVWVFtHuEqMGRiIuH0B7UQPbIysLDjvMFZ9YDDZtik8C1q51pbx83zgCGRlO8E+d6gv7lmFjE8nIUB57TFiwoOt97UkGDx5MZWUl3/rWGEKhHXzpS6+jqgxO9WykA3rDxq7Xhb6q3i8iw4Af4YLzrAFOU9XNXpPxideISCFwDnB1r3V0gJCV5YL9DBnifP791X9Ghpvhp4Pxn9E3SOfUvxDPYFdVVcXOnTsZPhx27txJVlZW2mSw8/GjBgI9LkBDIZfVc9IkmDcvfr68HN56Kz4JWLMGNm50tgNehmQSBf6SJZNaHNfVCeXlpBxfdR6NxohGtTk09KhRo1LdNSCuGVu5ciWh0BhEhJycHF7xZlzHHXdcv9nTB0BVbwZubqNubivnqoD0M1XuR/g+//n5Lr1vdbWbANjq3+gK6Zr6F+IZ7JYvX86yZcuIRl0Gu2OPPTatJiepYuRIV4K2ynV1TuC/9RY8/LDTAgS9C559dp81Gv/+t/vOOOwwOPRQGDWqdwOG+XYbW7b4sd5cxMDhw4enjf0GONfHSCRCfn4BWVlZHHHE0Tz//POsWbOG447rrAd71+lr1vtGL5Cd7QKJFBW1XP3b3r9h9A6pyL7WGrm58YRBp5/usggG9/RPPXUjTz99YKCf8YiDPoMHO+F/6KEu6dBhh7mfydK0Bw35ID7xLCsrY8mSJZxxxhlpIfgHDx5MbW1ti3PZ2dkUFRUl9bkm9I02Ca7+/b3/igo3EcjKcqv/NPjsGEanCKpUw+EwmZmZhMNhVq5cCaSPsWHLAELpE0K2Ne+CU0/d3Cz0c3JckKGSEuc14JfKyn1tBQBGj45PBKZMcb8fdJCbaHQHVaWyspLGxkZEQmRmZpCdnU1jYyOVlZVpEYPf1zq99tpr3HlnHZFIhLVr3+Goo47i+OOP73eGfEYfJLj3X1fnPshVVU7oW7Y/o6/gq1SPPvpo8vJqmD17HK+88kraRJMLhpCtrp5CQUFhC6+IVAusRO8CiHsXXHSRqw92T9V5Cfh2AX55910XiOj99+E//4m396MUTpniUhP7PydP7rx7sYgwZMgQqqqqCIXcPbOynFvhkCFDUi7wfZ588kkvLPAEwP3tt2zZQnl5OZ/97GeT9lz7qja6hIj7kOfluf3+mhpn+V9XZ8Z/RvrTmko1Kysrbay6/cRF+fn51NbWUltbS2lpadokLvK9Cy64QJk3T8jOhquugtNPV4YM2bdvIi4t+AEHtLQViEadB8E777hJQGmp+7lxozu/aRM89VS8fSjkchP4k4BDDnFeBa1NBkTE+5uOp6amgGg0xJo1MznqqHKysjJTPobgPEkaGhrYtGkTTU1HA1BRUUF5eTmTJ08mFoslzZPEhL6x32Rmun25wYOd3391tdMARKNm/GekH0FDvtLSUiZMyGPz5m3NAVzSQRioKo2NjVRXVxONRsnIyKCmpqb5fKpX+hDffiguLiErCz772a5vP2RkOIE9eTJ86lPx842NsGGDmwSUlrpJQWmpmwRs2ODKk0/G24dCTjPgTwLcREB54olZLFkykmg0hKqwZMkcHn1U+MxndvDJTyqhUKonTy4Iz/bt21GNNccRyMrKYsKECabeN9KfnBxXhg51q37f+M/U/0Y64bsR+kGDIH328iFueb5161bOOcfFK2togBEjRqSF5Xni9gPQo9sP2dlxo78g9fWwfr2bBLzzjtse8CcDGze6EtcMCC70S5xIxI8aeACjR6c+aqAf1+Lww4+jpiafaDSDFStmc9FFw8jJyTKhb/QdQqG48Z+v/t+9231oTe1vpJp0DxWsqjz22GPs3LmzWc1fU1PDzp07eeyxx1IeQjYYdKm2tpampqYWURiT1becnHiUwCANDW71/+67rqxdC08/HU8ylkhjYwY33ADPP++2Cg46yGkbDjoIxo3rvcWJKjz55DRuuUVpahKi0QyeeOIUnngixJVXhpg9O3lG0ib0jaQRVP83NLiVfyzmfpr1v9HbJIYKzsurISdnXNqFCt67dy/19fWEA/tj9fX1aRVCNl3yF4TDLSMO3nOPE+gJZhv7sHKlK0Gys+HAA90kYNKk+IRg8uSedy/87W9j3HprjEgkLoIjEZcD/ZprXGKDX/zC9vSNPkw4HC/jxsGHH7qi6s5lZ6e6h0Z/JzFU8FtvPZt2oYJVlfz8fHbt2kVTUxMiQlNTE7FYjPz8/LTY03/zzTfZsGEDcGzzucWLFzNp0qSU5y8oL4e6uvZDBYPy+c8Ls2Y57cD69S4/QVlZ3JYgkeHD4xOASZPiP8eP7/p3V2Ul/PGPIRobWxfqjY2ZXHcdXH6585bqaUzoG72Ob/0/YsS++//hsNMCGEYySPdQwaFQiMmTJwOwbdu25nzwEyZMYPLkySnPDRCLxdiwYQNbt24lFPoImZmZ5Ofns3XrVoCU5y8YORJyc6XdlX5ennDkkfuGN66pcROAYHnvPbd9sGuXK4mxBjIy3CJm0iSnJfDDGx94oItD0Fogs8cf7zjAWUYG/O1vcMEFnXvvrmBC30gZGRlQUOBKJGLR/4zeIZ1DBYObmDQ2NrJtWzwX/Lhx41IamMcnFAoxaZKLt//Vr/6DoqJ8Nm2qYdy4cUyaNCnlk5LTT4cf/7j9NtGoS2CUSH7+vlkKwW1JlpW5SYDvQbBhgzveujXuYphIOOw8Cw48sGVZv77j7YfaWvigM8nm9wMT+kZakJUV3/9vbHSzbj/6n/n/GwOFxKiBeXl51NbWplXUwJkzZzJt2jTuu+8+wE2azjjjDDLSYIbeWtTAILm5LoNhV/boQyEYM8aVE09sWVdfD5s3xz0I/AnBxo0uKJHvbdAR69YNbXGcl+diGyQDE/pG2pGd7cqQIc4AsLoa9u513gCZmW4GbRMAo7/ix4z34wf4kwD/fKrx9/SDueofffTRtNjTBxcVsLx8Bw89NIKmJiEWE/LylKYm5cwzd3LFFcU99qycnHgY4USqq+PxBfxJgT8x8HZtmkkU+tEofP7zPdbNFpjQN9IW38c/JweGDYt7AOzd6z4UNgEw+hsiwsSJExk1alTzqj6djA39Pf0tW7Ywfvx4hg4tYtcuac5ol+o9fYdy9tlbOOSQZ7n99nmEQjmcccYmRo58lVmzJgEjad/Qr2coKIBp01xJ5Oc/h7/+NZ68aOrU3bzwwljArfK/853kGPGBCX2jjxCcAAwf7tRq/gQgFrMJgNF/SGdjw1AoRDgcZtCgQVRXV7Nnj1JdXcOgQYMIh8NpIPBbxhLIydkL7GXChBeTHkugK/zoR+77ys9hcMghFeTnu8XMd74DV1+dvGen/i9kGF1ExO3NjRzpfGnHj4fCQreHV1XlfgZzfhtGXyNdjQ1VlREjRpCVlUVtbS2qLkhPVlYWI0aMaFb5p5qg4PdJF4EP8RwGK1fG3f7+7/+cweDPf57c+CUm9I0+jU0ADKP38APz5Ofn09DQQDTaRENDA/n5+WkRJtinrciL6TIp8Rk8WBkxwgn9Cy5wx8nG1PtGv8GfAOTmuhgAfhIgfwsgFHIqtTQwMjaMPomqsmLFCqqrqwmHw2RmZhIOh6murmbFihVpsZpWVZYsWUJZWRm5uVMoLCxkypQpzcaQqQ5l7OMnLgKnkVBVli1bRjgc9iIeJgdb6Rv9En8CMGKEi541frwzjIlEnAagpsZ5AxiG0Xn81L8FBQXk5+cDkJ+fT0FBQVqk/k0kzbrTTMvERVUALFu2jDVr1tDQ0JBUjYSt9I1+T6IXgB8HoLLSqf9DIades0iAhtE+forfmpqaffIXpEvq32AK5fz8RwEXWjedUigHbQ7q6uqIRCKsWfMO06ZN49hjj01qH22lbwwo/FC/Q4fGw2WOHOnqqqrcdkBDQ9tZugxjIJOYvwCcgdyUKVPSwqXQR0SYPXt2i3OzZ89Om/5BMHFRnGOOOSbpfbSVvjGg8QMBDR7s1P319c4GoKbGCX5zBTSMlqSzS6HP448/Tnl5OVkB9d2dd97JyJEjOf3001PYszjxIEfHAU6LsmjRIg455JB9PA96kpR8lYnIpSKyUUTqRWSFiJzQQftsEbnau6ZBRLaIyGW91V9jYJCZ6QJqjBnj7ADGjnXHdXVOA1Bb6/xoDWOgk64uhQDRaJTy8nIqKiqIRCL813/9F5FIhIqKCsrLy4mmwYc4mLgoIyNEVlYWhYWFbNq0iXfeeYdYEl2Oen2lLyJnAzcAlwIveD+fFJGpqrqljcsWAWOBC4F3gWIgtxe6awxQMjJcAo78fKf+b2hwQr+y0v0UiWsJDMNIHzIyMpg9ezYrV67kww8/5KabbkJVKSoqYvbs2WmRIyCYuCgWixGJRKiurmbixIkccsghSQ1ylAr1/neAhap6u3f8DRH5JHAJ8IPExiJyKvAxYLKq7vJOb+qNjhoGtDQEHDrUeQDU1cGHHzoNgG0DGEZ64ScFuummmwCnifjyl7+cFgLfx+/jnj1/Y+TILCor4eyzz056H3v1K0pEsoE5wNMJVU8Dx7Vx2ZnAa8B3RGSbiLwrIr8XkYLk9dQw2iYrCwYNcur/yZNdPu3Cwnho4OpqNzEwDCM1xGIxHn300RbnHn300aSqzbvKm2++uU8f77///n2CCvU00psRikRkNLAdOElVnwuc/wmwQFX3yVUkIv8A5gL/Bq4GhgB/AFap6lmttL8Qtw1AcXHxnEWLFvVY/6urqykosLlGd+jvY6jqAgFFoy09AHpaA1BfX01OTv8dx97AxrD7pOsYVlZW0tjYSHZ2NkOGDNnnOB3w+5SZGSYvL4NIpLG5j0OHDu34Bu1w8sknr1DVVq0B+4L1fghQ4IuquhdARL4OPCUixaq6I9hYVW8DbgMoKSnRuXPn9lhHli5dSk/ebyAykMawqSmeGriqyk0EQiGnKeiuLcDatUs5/PC5PdLPgYqNYfdJ1zF84oknaGhQ5s8/g1AoRCwWY/HixYTD2Rx//NxUdw+IW+/v3l3LoYdmU1Gxi8LCQsaPH59U6/3eFvq7gCjOEC9IMfBBG9eUAdt9ge/xtvdzPLBj30sMI/VkZrriGwM2NsZdAoO2ANnZFhrYMHqS0047jVgs1mwQFwqFmD9/flpkAfTx9/QXLvwb4OwO+t2evqo2AiuAUxKqTgFeauOyF4HRCXv4h3g/N/dsDw0jOfhBgQYPdiGBfVuAQYPioYEtMJBh9ByJAj6dBD7E9/T9LXZV7ZU9/VSo968H7hKRV3EC/WJgNHArgIjcCaCqX/ba3wv8GPiriFyF29O/AXhQVct7teeG0UNkZEBenisjRsS1ANXV8cBAvlughQc2jP5F0E9/5MiJDBs2iKamBjZt2gS46IHJmqT0utBX1ftFZBjwI2AUsAY4TVX9Vfv4hPbVIvJxnPHea0AF8Ajw/V7rtGEkGd/nf9AgJ/AbGuLpgf2tgIwM1yazL1jiGIbRJkE//T17atm9u3/76aOqNwM3t1E3t5VzpcCpSe6WYaQFwbgARUXOANBPElRV5SYDsZj7afYAhtE3mTlzJtOnT+evf32g+dw555yT9G2I9NrkMAxjHzIyXJrg4cNdgqDJk53Kv7CwpT2APxkwDCP9UVVWrFjR4tzLL7+c1LS60Ddc9gzDCJCZ6Vz/Ro50JRJx2wE1NU74NzU5bYHvGZBm9kuGMeBRVZYvX05paSkHH3wYw4ZVMXbsKNasWQOQ1PS6JvQNo4+TleVKQQEUF7utgMZGNwGoro6v/m0SYBjpQTBF8WGHzWbr1mc59thjAZKeotiEvmH0M3yjwIICZwAYibScBESjThPgGwaaTYBh9D5+iuLa2niK4mSu8H1M6BtGPyaYDdCPfuxvB9TWxm0BwAn/rCzzDjCM3iIVKYrt420YA4zgdsDIkfFwwf4koL7etfNDBlucAMPoP5jQN4wBTjBc8IgRcRfBurr4lgC0NA7shQWJYRhJwIS+YRgt8F0Ec3Nh6FBnCNjYGPcQqK2NGweaXYBh9C1M6BuG0S6hUDxY0ODBLY0D/S2B2tp4W39LwLQBhpF+mNA3DKNLJBoHjhwZ3xKor49rA/wYI6YNMIz0wYS+YRjdJrglUFS0rzbAnwj4q39fG2AxAwyjdzGhbxhGj9Oaq2A02jJ6oG8b4CcTysy0bQHDSDYm9A3D6BUyMlzxbQPATQIikZbbArFYPHiQPxEwDKNnMKFvGEbK8NX8eXnOU8DfFohEnMugn08AXJ0/CbAAQoaxf9hHxzCMtCG4LZCf7zILxmKtTwR8Q0GbCBhG57GPiWEYaU0oBOGwKwUFLoBQ4kTAdx308bcGMjPNRsAwgpjQNwyjz5E4EQA3EWhqirsO1ta2dB0MhcxY0DBM6BuG0S8Ihfb1GAjaCPjug3V1boIQizntgD8RsDgCxkDAhL5hGP2WRBuBoiJ3vqkJtm+H4uL49kBdnZskBD0HbHvA6G+Y0DcMY8DhC/PBg+Pug0E7gfr6+GTA3x7wrzOtgNGXMaFvGIZB63YCqk4r4NsK1NXFi1/vxx+wCINGX8CEvmEYRhuIxGMJ5Oa21Ao0NcVtBerqnHagqSl+rW84mJlpkwEjfUiJ0BeRS4ErgFHAWuBbqvp8G23nAs+0UnWYqq5LVh8NwzDaImg0GLQViEbjk4GGBjcR8CcDvm2ATQaMVNLrQl9EzgZuAC4FXvB+PikiU1V1SzuXHg7sCRzvTF4vDcMwuo6v6g9uEUDbk4FoNG48GArFDQjNZsBIFqlY6X8HWKiqt3vH3xCRTwKXAD9o57pyVd2V9N4ZhmH0MB1NBoI2A36MAZ/EyYB5ExjdoVeFvohkA3OAaxOqngaO6+Dy5SISBt4CfqGqran8DcMw+gzByUBwm8C3GfC1A75mINGbwL/etgqMziIa/A9K9sNERgPbgZNU9bnA+Z8AC1R1SivXTAFOBl4DsoEvARd799jHDkBELgQuBCguLp6zaNGiHut/dXU1BcFputFlbAx7BhvH7tOXx1A1Xvz0xK19lYskVzNQX19NTk7fHMN0IRaDxsZqCgt7bhxPPvnkFapa0lpd2lvvq2opUBo4tUxEJuIMAfcR+qp6G3AbQElJic6dO7fH+rJ06VJ68n4DERvDnsHGsfv0tzFM1A74tgONjfGJgT8J6KntgrVrl3L44XN77B0GIjU1sGVL7/0v9rbQ3wVEgeKE88XAB124zyvAOT3VKcMwjL5O0KMgkaDtQFNTfLvAD0kMblLg2w/4kwKzH+h/9KrQV9VGEVkBnAL8LVB1CvBQF241Cyjrwa4ZhmH0W4K2AxCPNwCtTwgaGtyEIBptKfjNhqDvkwr1/vXAXSLyKvAibn9+NHArgIjcCaCqX/aOvwVswvnzZwPnAmcCn+vdbhuGYfQ/OpoQBN0NGxvdhKCx0Z3zkxZBSy2BeRmkL70u9FX1fhEZBvwIF5xnDXCaqm72moxPuCQbuAYYC9ThhP/pqvpEL3XZMAxjQOIL8Na2DGIxl7Ro/PiWXga+62Fw28C3I/ADE1kcgtSREkM+Vb0ZuLmNurkJx78FftsL3TIMwzA6SSjkhHlOTuv1QS1BNOomA/6koL4+7nHgawSCkwL/3kbPk/bW+4ZhGEbfoz0tge9q6E8IolG3bRDcOvBdEBMjFtr2QfcwoW8YhmH0Kr66P6jmLyyM/97apKCxMV6C2wfBeyZODIx9MaFvGIZhpBWtTQoSicXiEwJ/GyE4MfC3EBLvO9AnBib0DcMwjD5HKORKVlbr9b62IDgx8D0QIpG44WFwGyF4X9/GoL9tJZjQNwzDMPodndEWtDYxSNxK8CMa+u2DKZKDWoO+ErfAhL5hGIYxIOnMxAD2nRi4ePkttxT8NMnBiQHENQVBzUEqMaFvGIZhGO3Q0VYCtNQaBCcJ/laCX+rq4hMDVTdx6E1M6BuGYRhGN+ms1sCfHAQnCDt39k4fwYS+YRiGYfQawclBe5qDZNFHTA8MwzAMw+guJvQNwzAMY4BgQt8wDMMwBggm9A3DMAxjgGBC3zAMwzAGCCb0DcMwDGOAYELfMAzDMAYIJvQNwzAMY4BgQt8wDMMwBggm9A3DMAxjgCDqJxHuh4jITmBzD95yOLCrB+83ELEx7BlsHLuPjWH3sTHsGXp6HCeo6ojWKvq10O9pRGS5qpakuh99GRvDnsHGsfvYGHYfG8OeoTfH0dT7hmEYhjFAMKFvGIZhGAMEE/pd47ZUd6AfYGPYM9g4dh8bw+5jY9gz9No42p6+YRiGYQwQbKVvGIZhGAMEE/qGYRiGMUAwod8JRORSEdkoIvUiskJETkh1n9IJETlRRB4Vke0ioiJyfkK9iMhVIvK+iNSJyFIROTyhTZGI3CUie71yl4gM6c33SBUi8gMReU1EPhSRnSKyRESmJbSxMewAEfmaiKzyxvFDEVkmIqcH6m0Mu4j3v6kicmPgnI1jO3hjownlg0B9SsfPhH4HiMjZwA3AL4EjgJeAJ0VkfEo7ll4UAGuAbwJ1rdRfCXwX+AZwJFAO/FNECgNt7gVmA5/0ymzgriT2OZ2YC9wMHAd8FGgC/iUiQwNtbAw7ZhvwPdx7lwD/AR4RkRlevY1hFxCRY4ALgVUJVTaOHVMKjAqU6YG61I6fqlpppwCvALcnnHsX+FWq+5aOBagGzg8cC1AG/E/gXC5QBVzkHR8GKHB8oM1HvHNTUv1OKRjDAiAKzLMx7PZY7gEusjHs8rgNBtYDJwNLgRu98zaOHY/dVcCaNupSPn620m8HEckG5gBPJ1Q9jVuVGR1zIHAAgTFU1TrgOeJjeCxusvBS4LoXgRoG5jgX4rRwFd6xjWEXEZEMETkHN4F6CRvDrnIb8KCqPpNw3saxc0zy1PcbRWSRiEzyzqd8/Ezot89wIAPYkXB+B+4PZ3SMP07tjeEBwE71prQA3u/lDMxxvgF4A1jmHdsYdhIRmS4i1UADcCvwGVVdjY1hpxGRC4CDgB+1Um3j2DGvAOfj1PIX4N75JREZRhqMX2Z3b2AYRs8hItfjVHkfUdVoqvvTBykFZuHU02cBd4jI3BT2p08hIlNw9ksfUdVIqvvTF1HVJ4PHIvIysAE4D3g5JZ0KYCv99tmF21stTjhfDHywb3OjFfxxam8MPwBGiIj4ld7vIxlA4ywi/wf8F/BRVd0QqLIx7CSq2qiq76nqClX9AU5j8m1sDDvLsTgN51oRaRKRJuAk4FLv991eOxvHTqKq1cBa4GDS4P/QhH47qGojsAI4JaHqFFrutxhtsxH3j9o8hiKSA5xAfAyX4fZejw1cdyyQzwAZZxG5gbjAX5dQbWO4/4SAMDaGneURnKX5rEBZDizyfn8HG8cu4Y3PoTgDvtT/H6ba0jHdC3A20Ah8FWdVeQPOyGJCqvuWLsX7B53llVrgJ97v47367wF7gc8C03BfIO8DhYF7PAms9v65j/V+X5Lqd+ul8bsJ+BDnrndAoBQE2tgYdjyOv8Z9eU7ECa5fATHgUzaG3RrXpXjW+zaOnRqva3HakQOBo4HHvM/3hHQYv5QPUF8owKXAJpxx0ArgxFT3KZ0Kzs9cWykLvXrBubGUAfXAs8C0hHsUAXd7H44Pvd+HpPrdemn8Whs7Ba4KtLEx7HgcFwKbvc9pOfAv4BM2ht0e10Shb+PY/nj5QrwR2A48BExNl/GzhDuGYRiGMUCwPX3DMAzDGCCY0DcMwzCMAYIJfcMwDMMYIJjQNwzDMIwBggl9wzAMwxggmNA3DMMwjAGCCX3DSAEicqyIPOBl4moUkd0i8k8ROU9EMrw254uIisjEwHWbRGRhwr3michqEan32g8RkZCI/E5EykQkJiKPJPFdJnrPPb+Ddv77HJSsvuwvInKmiHynlfNzvT5/PBX9MoyexhLuGEYvIyLfAq4H/oOLzrUZF4zjVOAWoBJY3Mbln8EF6/DvlQncgwvP+TVcQJAqXLKZbwLfxYX13L3PnYwgZwIfx/1dDKPfYkLfMHoRETkRJ1huVNXLEqoXe1n28tu6XlVfTzg1BigEHlDV5wLPOcz79XeqGuuBfodVtaG79zEMI7WYet8wepfvAXuAK1urVNX1qrqqrYuD6n0RuQoXHhrgz54aeqmIbMKF+QSIBlXvIjJKRO4UkV0i0iAiq0Tk3IRn+Gr4E0XkbyJSicsRjojkicjN3nZEtYg8Cozdj3FoExG5UETe9LYrdonIn0VkaEIbFZFfiMhlIrJRRKpE5FkROTyhXYbXrkxEakXkPyJyqHf9VV6bhbi0p2O88+qNYZA8EbnR688uEblbRIb05HsbRm9gK33D6CW8vfqTgUdUtb4HbvknYA3wN+AXwOM41X8YuAw4n3imrvUiko+L810E/BDYCpwL3CUieap6W8L97wHuw20V+N8Vf8QlofoZ8BouW9i9PfAuAIjIr3FbEr8HrsBpMn4BTBOR41Q1Gmh+LlCK28bIBq7BaUsOVdUmr83PvHe9BheLfw7waMJjfw6MAI4EzvDOJWo1bsAlTvkiMAX4LS7t9nndeV/D6G1M6BtG7zEcyMXt4XcbVd0mIm94h+tV9WW/TkS2e22C576Oy+l9sqou9U4/KSLFwC9E5M8JQvVBVb0ycP0UnND7H1X9tXf6aREpAC7u7vt4BotXAD9T1asD598BXgDm4VK/+kSAT6tqxGsHbgJ0FPCSiBQB3wJuVdXvedf8U0Qagev8m6jqehHZCTQGxyuB51T1G97vT3tj8VUROV8tgYnRhzD1vmEMHE4EtgcEvs/duJXu1ITzDyccH437zngg4fyiHurfKd797xGRTL/gthaqcP0P8k9f4Hus9n6O935Ox9lH/C3hugf3o2+PJxyvxmlUivfjXoaRMmylbxi9x26gDpiQoucPxaXzTOSDQH2QxLajvJ87Es4nHu8vI72f77VRPyzheE/Csa+Sz/F++v0tT2i3P/3t6FmG0ScwoW8YvYSqNonIUuCUFFnD78HtRydyQKA+SKLa2p8EFAMbAud7arXruxWeClS0U99Z/P6OBNYGztvq3BiwmHrfMHqXX+NWrL9trVJEDhSRGUl69rPAWBE5PuH8F3Gr4bc6uP4VIAZ8IeH8OT3TPf7p3X+8qi5vpWzs4v1WAzXA5xPOJx6DW7nndr3LhtG3sJW+YfQiqvqcF/ntehGZCiwEtuAs6j8GfBUnhNt02+sGC3GW7n8Xkf8BtgELcHvpFyUY8bXW91IRuRe4WkRCOOv9U4HTutiPT4rIBwnn9qrqP0XkN8CNnqHcs0A9MM7r459U9ZnOPkRVK0Tkd8APRaQKZ70/G/hvr0kwfsFbwFARuQRYDtSr6moMo59hQt8wehlV/Z2IvAp8G7gWZ9VfhRM2FwFLkvTcGhE5Cadl+DUuqE8p8CVVvbuTt7kIqAYux7nJ/Qc3SXmhC135Qyvn1gLTVPWHIvI2Lrrg13BbDFuBfwPvduEZPj8FBCfoL8NpK84HXgT2Btr9CTgG+CUwBOdhMXE/nmcYaY2Yt4lhGAMJETkLZ9F/oqo+n+r+GEZvYkLfMIx+i4gcDZyOW+HX44LzfB+n4TjOfOyNgYap9w3D6M9U4/z7vwYMwhksPgD8wAS+MRCxlb5hGIZhDBDMZc8wDMMwBggm9A3DMAxjgGBC3zAMwzAGCCb0DcMwDGOAYELfMAzDMAYIJvQNwzAMY4Dw/wF5C3lB92lNewAAAABJRU5ErkJggg==\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 576x360 with 1 Axes>"
       ]
      },
      "metadata": {
@@ -370,9 +369,9 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 576x360 with 1 Axes>"
       ]
      },
      "metadata": {
@@ -407,133 +406,49 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "---------------------------------------------------\n",
-      "Experiment: RBExperiment\n",
-      "Experiment ID: 6ca546fc-b1c2-42b6-904b-b8b1bf465d4b\n",
-      "Status: DONE\n",
-      "Circuits: 140\n",
-      "Analysis Results: 1\n",
-      "---------------------------------------------------\n",
-      "Last Analysis Result\n",
-      "- popt: [0.46693859 0.99874811 0.51804455]\n",
-      "- popt_keys: ['a', 'alpha', 'b']\n",
-      "- popt_err: [0.13640766 0.00047292 0.13743453]\n",
-      "- pcov: [[ 1.86070504e-02  6.41705166e-05 -1.87442876e-02]\n",
-      " [ 6.41705166e-05  2.23655594e-07 -6.47148737e-05]\n",
-      " [-1.87442876e-02 -6.47148737e-05  1.88882507e-02]]\n",
-      "- reduced_chisq: 0.11803581788941118\n",
-      "- dof: 11\n",
-      "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.0006259460054571786\n",
-      "- EPC_err: 0.00023675759358046116\n",
-      "- success: True \n",
-      "\n",
-      "---------------------------------------------------\n",
-      "Experiment: RBExperiment\n",
-      "Experiment ID: d3414e4d-90f1-4a19-8b44-4da6972e10fb\n",
-      "Status: DONE\n",
-      "Circuits: 140\n",
-      "Analysis Results: 1\n",
-      "---------------------------------------------------\n",
-      "Last Analysis Result\n",
-      "- popt: [0.5002357  0.99904187 0.49014021]\n",
-      "- popt_keys: ['a', 'alpha', 'b']\n",
-      "- popt_err: [0.1822092  0.00043693 0.18345169]\n",
-      "- pcov: [[ 3.32001915e-02  7.93933245e-05 -3.34245179e-02]\n",
-      " [ 7.93933245e-05  1.90904465e-07 -7.99713221e-05]\n",
-      " [-3.34245179e-02 -7.99713221e-05  3.36545220e-02]]\n",
-      "- reduced_chisq: 0.1070511551604703\n",
-      "- dof: 11\n",
-      "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.00047906273060688287\n",
-      "- EPC_err: 0.00021867259321739114\n",
-      "- success: True \n",
-      "\n",
-      "---------------------------------------------------\n",
-      "Experiment: RBExperiment\n",
-      "Experiment ID: 8c888438-1d75-483c-9d8f-fdd2b2a34560\n",
-      "Status: DONE\n",
-      "Circuits: 140\n",
-      "Analysis Results: 1\n",
-      "---------------------------------------------------\n",
-      "Last Analysis Result\n",
-      "- popt: [0.55973516 0.99912126 0.42700616]\n",
-      "- popt_keys: ['a', 'alpha', 'b']\n",
-      "- popt_err: [0.27152143 0.00050462 0.27233487]\n",
-      "- pcov: [[ 7.37238867e-02  1.36774520e-04 -7.39434311e-02]\n",
-      " [ 1.36774520e-04  2.54645379e-07 -1.37208230e-04]\n",
-      " [-7.39434311e-02 -1.37208230e-04  7.41662805e-02]]\n",
-      "- reduced_chisq: 0.12636835483455555\n",
-      "- dof: 11\n",
-      "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.00043937121868359297\n",
-      "- EPC_err: 0.00025253391107906575\n",
-      "- success: True \n",
-      "\n",
-      "---------------------------------------------------\n",
-      "Experiment: RBExperiment\n",
-      "Experiment ID: b686a25a-bfc2-497a-8ce2-afc32648d2f0\n",
-      "Status: DONE\n",
-      "Circuits: 140\n",
-      "Analysis Results: 1\n",
-      "---------------------------------------------------\n",
-      "Last Analysis Result\n",
-      "- popt: [0.48003187 0.99469758 0.51095063]\n",
-      "- popt_keys: ['a', 'alpha', 'b']\n",
-      "- popt_err: [0.01282506 0.0003712  0.01354442]\n",
-      "- pcov: [[ 1.64482244e-04  3.76084285e-06 -1.64591939e-04]\n",
-      " [ 3.76084285e-06  1.37790112e-07 -4.53772965e-06]\n",
-      " [-1.64591939e-04 -4.53772965e-06  1.83451314e-04]]\n",
-      "- reduced_chisq: 0.03699962727664218\n",
-      "- dof: 11\n",
-      "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.0026512122080561418\n",
-      "- EPC_err: 0.00018658983090838707\n",
-      "- success: True \n",
-      "\n",
-      "---------------------------------------------------\n",
-      "Experiment: RBExperiment\n",
-      "Experiment ID: 09597176-8112-422b-894f-c95a20dd15e9\n",
-      "Status: DONE\n",
-      "Circuits: 140\n",
-      "Analysis Results: 1\n",
-      "---------------------------------------------------\n",
-      "Last Analysis Result\n",
-      "- popt: [0.46814847 0.99839983 0.52017324]\n",
-      "- popt_keys: ['a', 'alpha', 'b']\n",
-      "- popt_err: [0.10497103 0.00047757 0.10608133]\n",
-      "- pcov: [[ 1.10189166e-02  4.97107495e-05 -1.11326896e-02]\n",
-      " [ 4.97107495e-05  2.28073402e-07 -5.03167306e-05]\n",
-      " [-1.11326896e-02 -5.03167306e-05  1.12532482e-02]]\n",
-      "- reduced_chisq: 0.043914308686492876\n",
-      "- dof: 11\n",
-      "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.0008000826861901955\n",
-      "- EPC_err: 0.00023916786387579025\n",
-      "- success: True \n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Print sub-experiment data\n",
     "for i in range(par_exp.num_experiments):\n",
     "    print(par_expdata.component_experiment_data(i), '\\n')"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python [conda env:qiskit-dev]",
+   "display_name": "Python 3",
    "language": "python",
-   "name": "conda-env-qiskit-dev-py"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -545,7 +460,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.7"
+   "version": "3.8.0"
   }
  },
  "nbformat": 4,
diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index b779a81d1e..cc608db5b2 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -20,7 +20,6 @@
 from typing import Any, Dict, List, Tuple, Callable, Union, Optional
 
 import numpy as np
-from qiskit.exceptions import QiskitError
 from qiskit.providers.options import Options
 
 from qiskit_experiments.analysis import plotting
@@ -29,8 +28,8 @@
 from qiskit_experiments.base_analysis import BaseAnalysis
 from qiskit_experiments.data_processing import DataProcessor
 from qiskit_experiments.data_processing.exceptions import DataProcessorError
-from qiskit_experiments.experiment_data import AnalysisResult, ExperimentData
 from qiskit_experiments.exceptions import AnalysisError
+from qiskit_experiments.experiment_data import AnalysisResult, ExperimentData
 
 
 @dataclasses.dataclass(frozen=True)

From 0f377750cbe2a1b684cfbf35c5aabfb82e6a56eb Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 3 Jun 2021 05:16:15 +0900
Subject: [PATCH 51/74] fix spect analysis

---
 qiskit_experiments/characterization/qubit_spectroscopy.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/characterization/qubit_spectroscopy.py b/qiskit_experiments/characterization/qubit_spectroscopy.py
index 5aaf3f2480..9502a16586 100644
--- a/qiskit_experiments/characterization/qubit_spectroscopy.py
+++ b/qiskit_experiments/characterization/qubit_spectroscopy.py
@@ -229,7 +229,7 @@ def fit_fun(x, a, sigma, freq, b):
         else:
             figures = None
 
-        return best_fit, figures
+        return [best_fit], figures
 
     @staticmethod
     def _fit_quality(

From dac51d84f3acfec945e6cde0c20067e95844fbe3 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 3 Jun 2021 12:10:46 +0900
Subject: [PATCH 52/74] fix composite analysis to use instance's analysis
 option

---
 qiskit_experiments/composite/composite_analysis.py  | 13 ++++++-------
 .../composite/composite_experiment.py               |  4 ++--
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/qiskit_experiments/composite/composite_analysis.py b/qiskit_experiments/composite/composite_analysis.py
index 81bd3124ec..1c80d2ac5e 100644
--- a/qiskit_experiments/composite/composite_analysis.py
+++ b/qiskit_experiments/composite/composite_analysis.py
@@ -44,12 +44,6 @@ def _run_analysis(self, experiment_data: CompositeExperimentData, **options):
         if not isinstance(experiment_data, CompositeExperimentData):
             raise QiskitError("CompositeAnalysis must be run on CompositeExperimentData.")
 
-        # Run analysis for sub-experiments
-        for expr, expr_data in zip(
-            experiment_data._experiment._experiments, experiment_data._components
-        ):
-            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
         # rather than just the sub-experiment IDs
@@ -61,7 +55,12 @@ def _run_analysis(self, experiment_data: CompositeExperimentData, **options):
         for i in range(comp_exp.num_experiments):
             # Run analysis for sub-experiments and add sub-experiment metadata
             expdata = experiment_data.component_experiment_data(i)
-            comp_exp.component_analysis(i).run(expdata, **options)
+            sub_expriment = comp_exp.component_experiment(i)
+
+            # Reflect sub instance's analysis option
+            analysis_options = sub_expriment.analysis_options.__dict__.copy()
+            analysis_options.update(**options)
+            comp_exp.component_analysis(i).run(expdata, **analysis_options)
 
             # Add sub-experiment metadata as result of batch experiment
             # Note: if Analysis results had ID's these should be included here
diff --git a/qiskit_experiments/composite/composite_experiment.py b/qiskit_experiments/composite/composite_experiment.py
index 70b1583b2d..829390a8fe 100644
--- a/qiskit_experiments/composite/composite_experiment.py
+++ b/qiskit_experiments/composite/composite_experiment.py
@@ -52,6 +52,6 @@ def component_experiment(self, index):
         """Return the component Experiment object"""
         return self._experiments[index]
 
-    def component_analysis(self, index, **analysis_options):
+    def component_analysis(self, index):
         """Return the component experiment Analysis object"""
-        return self.component_experiment(index).analysis(**analysis_options)
+        return self.component_experiment(index).analysis()

From bb506187a0b08a403f74dd573b191967caa279a1 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 3 Jun 2021 15:08:56 +0900
Subject: [PATCH 53/74] adjust curve figure appearance

---
 docs/tutorials/rb_example.ipynb               | 257 +++++++++++-------
 qiskit_experiments/analysis/curve_analysis.py |  48 ++--
 qiskit_experiments/analysis/curve_fitting.py  |  11 +-
 .../interleaved_rb_analysis.py                |   2 +-
 4 files changed, 201 insertions(+), 117 deletions(-)

diff --git a/docs/tutorials/rb_example.ipynb b/docs/tutorials/rb_example.ipynb
index 8edbd7ca73..05a2791767 100644
--- a/docs/tutorials/rb_example.ipynb
+++ b/docs/tutorials/rb_example.ipynb
@@ -45,26 +45,26 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: c5dd7ef9-9010-4018-b712-9af413ff3ebb\n",
+      "Experiment ID: 537fe9ea-f303-472e-9d18-d6573df5d47e\n",
       "Status: DONE\n",
       "Circuits: 140\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- a: 0.45834121716795917 ± 0.12213198333255153\n",
-      "- alpha: 0.9981278928818351 ± 0.000703818873057736\n",
-      "- b: 0.5283572362051712 ± 0.12348653334949362\n",
-      "- reduced_chisq: 0.027050133485052932\n",
+      "- a: 0.5209730101209734 ± 0.04826312242454459\n",
+      "- alpha: 0.9976881555253619 ± 0.0003694564881635104\n",
+      "- b: 0.4631086320972164 ± 0.05062026208437564\n",
+      "- reduced_chisq: 0.15058543331574248\n",
       "- dof: 11\n",
       "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.0009360535590824393\n",
-      "- EPC_err: 0.00035256948437020514\n",
+      "- EPC: 0.0011559222373190292\n",
+      "- EPC_err: 0.000185156296643094\n",
       "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -106,26 +106,26 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: 813ee9fd-282b-40b6-be84-be661add9ca4\n",
+      "Experiment ID: f52de39b-2ea1-40ae-ba97-791bf6c9c64c\n",
       "Status: DONE\n",
       "Circuits: 100\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- a: 0.7101000847314624 ± 0.01546721965247631\n",
-      "- alpha: 0.970965133698129 ± 0.0019052336560767267\n",
-      "- b: 0.26714473313054565 ± 0.01133624398164095\n",
-      "- reduced_chisq: 0.0408025199263645\n",
+      "- a: 0.7036411101911089 ± 0.02037048845690317\n",
+      "- alpha: 0.9687976498434205 ± 0.0017871176594190389\n",
+      "- b: 0.2700379866337794 ± 0.007565437969050169\n",
+      "- reduced_chisq: 0.10317613856705998\n",
       "- dof: 7\n",
       "- xrange: [1.0, 200.0]\n",
-      "- EPC: 0.021776149726403266\n",
-      "- EPC_err: 0.0014716545347155533\n",
+      "- EPC: 0.023401762617434596\n",
+      "- EPC_err: 0.0013835069116661337\n",
       "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -167,29 +167,29 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: InterleavedRBExperiment\n",
-      "Experiment ID: 1596b9b3-7805-40eb-b4d8-5b76046cd597\n",
+      "Experiment ID: 059ee9a2-ba48-4a4c-846d-6db23ed06a1e\n",
       "Status: DONE\n",
       "Circuits: 280\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- a: 0.45866193425920665 ± 0.05274545942959851\n",
-      "- alpha: 0.998121682066491 ± 0.0003163124671680783\n",
-      "- alpha_c: 0.99898852822204 ± 0.0003108272580212771\n",
-      "- b: 0.5268424448338176 ± 0.053582504822380604\n",
-      "- reduced_chisq: 0.042458924579051045\n",
+      "- a: 0.4738525253656051 ± 0.01873726626626984\n",
+      "- alpha: 0.9973203789925847 ± 0.00017666121887353534\n",
+      "- alpha_c: 0.9990879219144225 ± 0.00014224738015991404\n",
+      "- b: 0.511504733853466 ± 0.019256010590676303\n",
+      "- reduced_chisq: 0.10178000905808855\n",
       "- dof: 24\n",
       "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.0005057358889800079\n",
-      "- EPC_err: 0.00015541362901063855\n",
-      "- EPC_systematic_err: 0.0013725820445290027\n",
-      "- EPC_systematic_bounds: [0, 0.0018783179335090106]\n",
+      "- EPC: 0.0004560390427887362\n",
+      "- EPC_err: 7.112369007995702e-05\n",
+      "- EPC_systematic_err: 0.00222358196462652\n",
+      "- EPC_systematic_bounds: [0, 0.002679621007415256]\n",
       "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -231,29 +231,29 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: InterleavedRBExperiment\n",
-      "Experiment ID: 25b8eddd-3870-4fd1-bfc1-669b8b2936a4\n",
+      "Experiment ID: 978e73a0-0de9-498c-9392-e8226a80afe4\n",
       "Status: DONE\n",
       "Circuits: 200\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- a: 0.7025910789890448 ± 0.012666513414869166\n",
-      "- alpha: 0.970612599176899 ± 0.001678935943989779\n",
-      "- alpha_c: 0.9834206895620717 ± 0.0028452724070327264\n",
-      "- b: 0.25733595618059046 ± 0.005070594525149778\n",
-      "- reduced_chisq: 0.1486612902280576\n",
+      "- a: 0.697932170578897 ± 0.015745483076215365\n",
+      "- alpha: 0.9663379925192656 ± 0.002160168350192063\n",
+      "- alpha_c: 0.9850194918855851 ± 0.0030258551826973647\n",
+      "- b: 0.26448283770487785 ± 0.005469945993929648\n",
+      "- reduced_chisq: 0.05902228695924168\n",
       "- dof: 16\n",
       "- xrange: [1.0, 200.0]\n",
-      "- EPC: 0.012434482828446197\n",
-      "- EPC_err: 0.0021339543052745448\n",
-      "- EPC_systematic_err: 0.03164661840620528\n",
-      "- EPC_systematic_bounds: [0, 0.044081101234651476]\n",
+      "- EPC: 0.011235381085811152\n",
+      "- EPC_err: 0.0022693913870230234\n",
+      "- EPC_systematic_err: 0.03925763013529052\n",
+      "- EPC_systematic_bounds: [0, 0.05049301122110167]\n",
       "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -287,29 +287,32 @@
   {
    "cell_type": "code",
    "execution_count": 6,
-   "metadata": {},
+   "metadata": {
+    "scrolled": false
+   },
    "outputs": [
     {
-     "ename": "KeyError",
-     "evalue": "'num_qubits'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-6-bdba81279b7b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mpar_exp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mqe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomposite\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mParallelExperiment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mpar_expdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpar_exp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;31m# View result\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/base_experiment.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, backend, analysis, experiment_data, **run_options)\u001b[0m\n\u001b[1;32m    123\u001b[0m         \u001b[0;31m# Queue analysis of data for when job is finished\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    124\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0manalysis\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 125\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_analysis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    126\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    127\u001b[0m         \u001b[0;31m# Return the ExperimentData future\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/base_experiment.py\u001b[0m in \u001b[0;36mrun_analysis\u001b[0;34m(self, experiment_data, **options)\u001b[0m\n\u001b[1;32m    150\u001b[0m         \u001b[0;31m# Run analysis\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    151\u001b[0m         \u001b[0manalysis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0manalysis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 152\u001b[0;31m         \u001b[0manalysis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msave\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_figures\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0manalysis_options\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    153\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mexperiment_data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    154\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/base_analysis.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, experiment_data, save, return_figures, **options)\u001b[0m\n\u001b[1;32m     89\u001b[0m         \u001b[0;31m# Run analysis\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     90\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 91\u001b[0;31m             \u001b[0manalysis_results\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigures\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run_analysis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0manalysis_options\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     92\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mres\u001b[0m \u001b[0;32min\u001b[0m \u001b[0manalysis_results\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     93\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;34m\"success\"\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/composite/composite_analysis.py\u001b[0m in \u001b[0;36m_run_analysis\u001b[0;34m(self, experiment_data, **options)\u001b[0m\n\u001b[1;32m     62\u001b[0m             \u001b[0;31m# Run analysis for sub-experiments and add sub-experiment metadata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     63\u001b[0m             \u001b[0mexpdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexperiment_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomponent_experiment_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m             \u001b[0mcomp_exp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomponent_analysis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexpdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m             \u001b[0;31m# Add sub-experiment metadata as result of batch experiment\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/base_analysis.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, experiment_data, save, return_figures, **options)\u001b[0m\n\u001b[1;32m     89\u001b[0m         \u001b[0;31m# Run analysis\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     90\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 91\u001b[0;31m             \u001b[0manalysis_results\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigures\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run_analysis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0manalysis_options\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     92\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mres\u001b[0m \u001b[0;32min\u001b[0m \u001b[0manalysis_results\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     93\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;34m\"success\"\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/analysis/curve_analysis.py\u001b[0m in \u001b[0;36m_run_analysis\u001b[0;34m(self, experiment_data, **options)\u001b[0m\n\u001b[1;32m    665\u001b[0m             )\n\u001b[1;32m    666\u001b[0m             \u001b[0;31m# Generate fit options\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 667\u001b[0;31m             \u001b[0mfit_candidates\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_setup_fitting\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_series\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_xdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_ydata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_sigma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    668\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfit_candidates\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    669\u001b[0m                 \u001b[0;31m# only single initial guess\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/qiskit/qiskit-experiments/qiskit_experiments/randomized_benchmarking/rb_analysis.py\u001b[0m in \u001b[0;36m_setup_fitting\u001b[0;34m(self, series, x_values, y_values, y_sigmas, **options)\u001b[0m\n\u001b[1;32m     54\u001b[0m         \u001b[0;34m\"\"\"Fitter options.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     55\u001b[0m         return {\n\u001b[0;32m---> 56\u001b[0;31m             \u001b[0;34m\"p0\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_initial_guess\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_values\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_values\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"num_qubits\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     57\u001b[0m             \u001b[0;34m\"bounds\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"a\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"alpha\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"b\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     58\u001b[0m         }\n",
-      "\u001b[0;31mKeyError\u001b[0m: 'num_qubits'"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "---------------------------------------------------\n",
+      "Experiment: ParallelExperiment\n",
+      "Experiment ID: 3bb98e39-1b6e-4e41-bc79-ba5098b4254f\n",
+      "Status: DONE\n",
+      "Component Experiments: 5\n",
+      "Circuits: 140\n",
+      "Analysis Results: 1\n",
+      "---------------------------------------------------\n",
+      "Last Analysis Result\n",
+      "- experiment_types: ['RBExperiment', 'RBExperiment', 'RBExperiment', 'RBExperiment', 'RBExperiment']\n",
+      "- experiment_ids: ['be8f2f3b-3d53-4464-99e0-69984fbb2237', '80e43c31-faad-42f0-adec-c6a96cd760fc', 'de32fa6f-8db9-4783-ad0f-78e66fa5b66e', 'cd612ce6-c7ec-4379-87f2-1ef7a390a145', 'e4afa8b5-5e90-4688-863f-b0fb99b60c25']\n",
+      "- experiment_qubits: [(0,), (1,), (2,), (3,), (4,)]\n",
+      "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -321,7 +324,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -333,7 +336,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -345,7 +348,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -357,19 +360,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -383,7 +374,7 @@
    "source": [
     "lengths = [1, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450, 500]\n",
     "num_samples = 10\n",
-    "seed1 = 1010\n",
+    "seed = 1010\n",
     "\n",
     "exps = [rb.RBExperiment([i], lengths, num_samples=num_samples, seed=seed + i)\n",
     "        for i in range(5)]\n",
@@ -406,36 +397,112 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "---------------------------------------------------\n",
+      "Experiment: RBExperiment\n",
+      "Experiment ID: be8f2f3b-3d53-4464-99e0-69984fbb2237\n",
+      "Status: DONE\n",
+      "Circuits: 140\n",
+      "Analysis Results: 1\n",
+      "---------------------------------------------------\n",
+      "Last Analysis Result\n",
+      "- a: 0.5005193843435272 ± 0.04440989254995643\n",
+      "- alpha: 0.9974798908775014 ± 0.00036299147771944886\n",
+      "- b: 0.485239839914178 ± 0.045084715621612516\n",
+      "- reduced_chisq: 0.07359811264225856\n",
+      "- dof: 11\n",
+      "- xrange: [1.0, 500.0]\n",
+      "- EPC: 0.0012600545612492797\n",
+      "- EPC_err: 0.00018195428350947435\n",
+      "- success: True \n",
+      "\n",
+      "---------------------------------------------------\n",
+      "Experiment: RBExperiment\n",
+      "Experiment ID: 80e43c31-faad-42f0-adec-c6a96cd760fc\n",
+      "Status: DONE\n",
+      "Circuits: 140\n",
+      "Analysis Results: 1\n",
+      "---------------------------------------------------\n",
+      "Last Analysis Result\n",
+      "- a: 0.4729151274362826 ± 0.0586569701158699\n",
+      "- alpha: 0.9976906217132455 ± 0.0004370644794444831\n",
+      "- b: 0.5184707054269991 ± 0.05975003836406632\n",
+      "- reduced_chisq: 0.11699670616340346\n",
+      "- dof: 11\n",
+      "- xrange: [1.0, 500.0]\n",
+      "- EPC: 0.001154689143377241\n",
+      "- EPC_err: 0.00021903808151165695\n",
+      "- success: True \n",
+      "\n",
+      "---------------------------------------------------\n",
+      "Experiment: RBExperiment\n",
+      "Experiment ID: de32fa6f-8db9-4783-ad0f-78e66fa5b66e\n",
+      "Status: DONE\n",
+      "Circuits: 140\n",
+      "Analysis Results: 1\n",
+      "---------------------------------------------------\n",
+      "Last Analysis Result\n",
+      "- a: 0.4876872464791774 ± 0.04293214674217141\n",
+      "- alpha: 0.9977218699426396 ± 0.0003173007460854797\n",
+      "- b: 0.49930626492685787 ± 0.04376165812301661\n",
+      "- reduced_chisq: 0.07986148340397502\n",
+      "- dof: 11\n",
+      "- xrange: [1.0, 500.0]\n",
+      "- EPC: 0.0011390650286802195\n",
+      "- EPC_err: 0.00015901262448207224\n",
+      "- success: True \n",
+      "\n",
+      "---------------------------------------------------\n",
+      "Experiment: RBExperiment\n",
+      "Experiment ID: cd612ce6-c7ec-4379-87f2-1ef7a390a145\n",
+      "Status: DONE\n",
+      "Circuits: 140\n",
+      "Analysis Results: 1\n",
+      "---------------------------------------------------\n",
+      "Last Analysis Result\n",
+      "- a: 0.48497087640323777 ± 0.008807354322866709\n",
+      "- alpha: 0.9887157842315621 ± 0.0006549364697891019\n",
+      "- b: 0.5061929930128293 ± 0.0066319206049770445\n",
+      "- reduced_chisq: 0.15798909346766063\n",
+      "- dof: 11\n",
+      "- xrange: [1.0, 500.0]\n",
+      "- EPC: 0.005642107884218928\n",
+      "- EPC_err: 0.00033120563069503526\n",
+      "- success: True \n",
+      "\n",
+      "---------------------------------------------------\n",
+      "Experiment: RBExperiment\n",
+      "Experiment ID: e4afa8b5-5e90-4688-863f-b0fb99b60c25\n",
+      "Status: DONE\n",
+      "Circuits: 140\n",
+      "Analysis Results: 1\n",
+      "---------------------------------------------------\n",
+      "Last Analysis Result\n",
+      "- a: 0.4862870470137793 ± 0.026551499859339103\n",
+      "- alpha: 0.9967798184999347 ± 0.00034590875294202597\n",
+      "- b: 0.5000614956081333 ± 0.027624168605153588\n",
+      "- reduced_chisq: 0.15008348329804122\n",
+      "- dof: 11\n",
+      "- xrange: [1.0, 500.0]\n",
+      "- EPC: 0.0016100907500326556\n",
+      "- EPC_err: 0.0001735131202107342\n",
+      "- success: True \n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "# Print sub-experiment data\n",
     "for i in range(par_exp.num_experiments):\n",
     "    print(par_expdata.component_experiment_data(i), '\\n')"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index cc608db5b2..6785b9b925 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -233,6 +233,7 @@ def data_processor(data: Dict[str, Any]) -> Tuple[float, float]
             ax=None,
             xlabel="x value",
             ylabel="y value",
+            ylim=None,
             fit_reports=None,
             return_data_points=False,
         )
@@ -277,9 +278,7 @@ def _create_figures(
             else:
                 figure = axis.get_figure()
 
-            axis.set_xlabel(xlabel, fontsize=16)
-            axis.set_ylabel(ylabel, fontsize=16)
-
+            ymin, ymax = np.inf, -np.inf
             for series_def in self.__series__:
 
                 # plot raw data
@@ -291,6 +290,8 @@ def _create_figures(
                     y_values=y_values,
                     y_sigmas=y_sigmas,
                 )
+                ymin = min(ymin, *ydata)
+                ymax = max(ymax, *ydata)
                 plotting.plot_scatter(xdata=xdata, ydata=ydata, ax=axis, zorder=0)
 
                 # plot formatted data
@@ -321,18 +322,27 @@ def _create_figures(
                         zorder=2,
                     )
 
-                # format axis
+            # format axis
+
+            if len(self.__series__) > 1:
+                axis.legend(loc="center right")
+            axis.set_xlabel(xlabel, fontsize=16)
+            axis.set_ylabel(ylabel, fontsize=16)
+            axis.tick_params(labelsize=14)
+            axis.grid(True)
 
-                if len(self.__series__) > 1:
-                    axis.legend()
-                axis.tick_params(labelsize=14)
-                axis.grid(True)
+            # automatic scaling y axis by actual data point.
+            # note that y axis will be scaled by confidence interval by default.
+            # sometimes we cannot see any data point if variance of parameters is too large.
+
+            height = ymax - ymin
+            axis.set_ylim(ymin - 0.1 * height, ymax + 0.1 * height)
 
             # write analysis report
 
             if fit_reports and fit_available:
                 # write fit status in the plot
-                analysis_description = "Analysis Reports:\n"
+                analysis_description = ""
                 for par_name, label in fit_reports.items():
                     try:
                         # fit value
@@ -343,18 +353,24 @@ def _create_figures(
                         # maybe post processed value
                         pval = analysis_results[par_name]
                         perr = analysis_results[f"{par_name}_err"]
-                    analysis_description += f"  \u25B7 {label} = {pval: .3e} \u00B1 {perr: .3e}\n"
+                    analysis_description += f"{label} = {pval: .3e} \u00B1 {perr: .3e}\n"
                 chisq = analysis_results["reduced_chisq"]
                 analysis_description += f"Fit \u03C7-squared = {chisq: .4f}"
 
-                axis.text(
-                    axis.get_xlim()[0],
-                    axis.get_ylim()[1],
+                report_handler = axis.text(
+                    0.60,
+                    0.95,
                     analysis_description,
-                    ha="left",
-                    va="bottom",
-                    size=12,
+                    ha="center",
+                    va="top",
+                    size=14,
+                    transform=axis.transAxes,
+                )
+                
+                bbox_props = dict(
+                    boxstyle="square, pad=0.3", fc="white", ec="black", lw=1, alpha=0.8
                 )
+                report_handler.set_bbox(bbox_props)
 
             return [figure]
         else:
diff --git a/qiskit_experiments/analysis/curve_fitting.py b/qiskit_experiments/analysis/curve_fitting.py
index fa56decba3..9292fdfc02 100644
--- a/qiskit_experiments/analysis/curve_fitting.py
+++ b/qiskit_experiments/analysis/curve_fitting.py
@@ -31,12 +31,13 @@ class CurveAnalysisResult(AnalysisResult):
     def __str__(self):
         out = ""
 
-        popt_keys = self.get("popt_keys")
-        popt = self.get("popt")
-        popt_err = self.get("popt_err")
+        if self.get("success"):
+            popt_keys = self.get("popt_keys")
+            popt = self.get("popt")
+            popt_err = self.get("popt_err")
 
-        for key, value, error in zip(popt_keys, popt, popt_err):
-            out += f"\n- {key}: {value} \u00B1 {error}"
+            for key, value, error in zip(popt_keys, popt, popt_err):
+                out += f"\n- {key}: {value} \u00B1 {error}"
         out += super().__str__()
 
         return out
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index c2c654dc64..f766380425 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -61,7 +61,7 @@ class InterleavedRBAnalysis(RBAnalysis):
     @classmethod
     def _default_options(cls):
         default_options = super()._default_options()
-        default_options.fit_reports = {"alpha": "\u03B1", "alpha_c": "\u03B1_c", "EPC": "EPC"}
+        default_options.fit_reports = {"alpha": "\u03B1", "alpha_c": "\u03B1$_c$", "EPC": "EPC"}
 
         return default_options
 

From d71eaf17965ca0e773d65882cfb5f9e4666a4297 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 3 Jun 2021 15:13:49 +0900
Subject: [PATCH 54/74] black

---
 qiskit_experiments/analysis/curve_analysis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 6785b9b925..5520e192fa 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -366,7 +366,7 @@ def _create_figures(
                     size=14,
                     transform=axis.transAxes,
                 )
-                
+
                 bbox_props = dict(
                     boxstyle="square, pad=0.3", fc="white", ec="black", lw=1, alpha=0.8
                 )

From 7687c13accbc92dcdffe1e5b8431133f55481ae7 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 4 Jun 2021 14:53:09 +0900
Subject: [PATCH 55/74] update data and option handling

---
 qiskit_experiments/analysis/__init__.py       |   8 +-
 qiskit_experiments/analysis/curve_analysis.py | 253 +++++++++---------
 qiskit_experiments/analysis/fit_function.py   |   4 +-
 .../interleaved_rb_analysis.py                |  66 ++---
 .../randomized_benchmarking/rb_analysis.py    |  53 ++--
 5 files changed, 194 insertions(+), 190 deletions(-)

diff --git a/qiskit_experiments/analysis/__init__.py b/qiskit_experiments/analysis/__init__.py
index 26ca3b6aeb..d00256f4e6 100644
--- a/qiskit_experiments/analysis/__init__.py
+++ b/qiskit_experiments/analysis/__init__.py
@@ -52,5 +52,11 @@
 """
 from .curve_analysis import CurveAnalysis, SeriesDef
 
-from .curve_fitting import curve_fit, multi_curve_fit, process_curve_data, process_multi_curve_data
+from .curve_fitting import (
+    CurveAnalysisResult,
+    curve_fit,
+    multi_curve_fit,
+    process_curve_data,
+    process_multi_curve_data,
+)
 from .plotting import plot_curve_fit, plot_errorbar, plot_scatter
diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 5520e192fa..6dbe00fafe 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -180,6 +180,28 @@ class AnalysisExample(CurveAnalysis):
     #: List[SeriesDef]: List of mapping representing a data series
     __series__ = None
 
+    def __init__(self):
+        """Initialize data fields that are privately accessed by methods."""
+
+        #: Iterable[int]: Array of series index for each data point
+        self.__data_index = None
+
+        #: Iterable[float]: Concatenated x values of all series
+        self.__x_values = None
+
+        #: Iterable[float]: Concatenated y values of all series
+        self.__y_values = None
+
+        #: Iterable[float]: Concatenated y sigmas of all series
+        self.__y_sigmas = None
+
+        #: int: Number of qubit
+        self.__num_qubits = None
+
+        # Add expected options to instance variable so that every method can access to.
+        for key in self._default_options().__dict__.keys():
+            setattr(self, key, None)
+
     @classmethod
     def _default_options(cls):
         """Return default data processing options.
@@ -217,7 +239,7 @@ def data_processor(data: Dict[str, Any]) -> Tuple[float, float]
             bounds: Array-like or dictionary of (min, max) tuple of fit parameter boundaries.
             x_key: Circuit metadata key representing a scanned value.
             plot: Set ``True`` to create figure for fit result.
-            ax: Optional. A matplotlib axis object to draw.
+            axis: Optional. A matplotlib axis object to draw.
             xlabel: X label of fit result figure.
             ylabel: Y label of fit result figure.
             fit_reports: Mapping of fit parameters and representation in the fit report.
@@ -230,7 +252,7 @@ def data_processor(data: Dict[str, Any]) -> Tuple[float, float]
             bounds=None,
             x_key="xval",
             plot=True,
-            ax=None,
+            axis=None,
             xlabel="x value",
             ylabel="y value",
             ylim=None,
@@ -238,32 +260,13 @@ def data_processor(data: Dict[str, Any]) -> Tuple[float, float]
             return_data_points=False,
         )
 
-    def _create_figures(
-        self,
-        series: np.ndarray,
-        x_values: np.ndarray,
-        y_values: np.ndarray,
-        y_sigmas: np.ndarray,
-        analysis_results: CurveAnalysisResult,
-        axis: Optional["AxisSubplot"] = None,
-        xlabel: str = "x value",
-        ylabel: str = "y value",
-        fit_reports: Optional[Dict[str, str]] = None,
-    ) -> List["Figure"]:
+    def _create_figures(self, analysis_results: CurveAnalysisResult) -> List["Figure"]:
         """Create new figures with the fit result and raw data.
 
         Subclass can override this method to create different type of figures.
 
         Args:
-            series: An integer array representing a mapping of data location to series index.
-            x_values: Full data set of x values.
-            y_values: Full data set of y values.
-            y_sigmas: Full data set of y sigmas.
             analysis_results: Analysis result containing fit parameters.
-            axis: User provided axis to draw result.
-            xlabel: String shown in figure x axis label.
-            ylabel: String shown in figure y axis label.
-            fit_reports: Mapping of fit parameters and representation in the fit report.
 
         Returns:
             List of figures.
@@ -272,6 +275,7 @@ def _create_figures(
 
         if plotting.HAS_MATPLOTLIB:
 
+            axis = self._get_option("axis")
             if axis is None:
                 figure = plotting.pyplot.figure(figsize=(8, 5))
                 axis = figure.subplots(nrows=1, ncols=1)
@@ -285,10 +289,10 @@ def _create_figures(
 
                 xdata, ydata, _ = self._subset_data(
                     name=series_def.name,
-                    series=series,
-                    x_values=x_values,
-                    y_values=y_values,
-                    y_sigmas=y_sigmas,
+                    data_index=self.__data_index,
+                    x_values=self.__x_values,
+                    y_values=self.__y_values,
+                    y_sigmas=self.__y_sigmas,
                 )
                 ymin = min(ymin, *ydata)
                 ymax = max(ymax, *ydata)
@@ -296,9 +300,7 @@ def _create_figures(
 
                 # plot formatted data
 
-                xdata, ydata, sigma = self._subset_data(
-                    series_def.name, *self._pre_processing(series, x_values, y_values, y_sigmas)
-                )
+                xdata, ydata, sigma = self._subset_data(series_def.name, *self._pre_processing())
                 plotting.plot_errorbar(
                     xdata=xdata,
                     ydata=ydata,
@@ -326,8 +328,8 @@ def _create_figures(
 
             if len(self.__series__) > 1:
                 axis.legend(loc="center right")
-            axis.set_xlabel(xlabel, fontsize=16)
-            axis.set_ylabel(ylabel, fontsize=16)
+            axis.set_xlabel(self._get_option("xlabel"), fontsize=16)
+            axis.set_ylabel(self._get_option("ylabel"), fontsize=16)
             axis.tick_params(labelsize=14)
             axis.grid(True)
 
@@ -340,6 +342,7 @@ def _create_figures(
 
             # write analysis report
 
+            fit_reports = self._get_option("fit_reports")
             if fit_reports and fit_available:
                 # write fit status in the plot
                 analysis_description = ""
@@ -376,15 +379,7 @@ def _create_figures(
         else:
             return list()
 
-    # pylint: disable = unused-argument
-    def _setup_fitting(
-        self,
-        series: np.ndarray,
-        x_values: np.ndarray,
-        y_values: np.ndarray,
-        y_sigmas: np.ndarray,
-        **options,
-    ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+    def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
         """An analysis subroutine that is called to set fitter options.
 
         This subroutine takes full data array and user-input fit options.
@@ -396,25 +391,14 @@ def _setup_fitting(
         and find the best result measured by the reduced chi-squared value.
 
         Args:
-            series: An integer array representing a mapping of data location to series index.
-            x_values: Full data set of x values.
-            y_values: Full data set of y values.
-            y_sigmas: Full data set of y sigmas.
-            options: User provided fit options.
+            options: User provided extra options that are not defined in default options.
 
         Returns:
             List of FitOptions that are passed to fitter function.
         """
         return options
 
-    def _pre_processing(
-        self,
-        series: np.ndarray,
-        x_values: np.ndarray,
-        y_values: np.ndarray,
-        y_sigmas: np.ndarray,
-        **options,
-    ) -> Tuple[np.ndarray, ...]:
+    def _pre_processing(self) -> Tuple[np.ndarray, ...]:
         """An optional subroutine to perform data pre-processing.
 
         Subclasses can override this method to apply pre-precessing to data values to fit.
@@ -425,28 +409,18 @@ def _pre_processing(
         - Take mean over all y data values with the same x data value
         - Apply smoothing to y values to deal with noisy observed values
 
-        Args:
-            series: Numpy integer array to represent mapping of data to series.
-            x_values: Numpy float array to represent X values.
-            y_values: Numpy float array to represent Y values.
-            y_sigmas: Numpy float array to represent Y errors.
-            options: Analysis options.
-
         Returns:
             Numpy array tuple of pre-processed (x_values, y_values, y_sigmas, series).
         """
-        return series, x_values, y_values, y_sigmas
+        return self.__data_index, self.__x_values, self.__y_values, self.__y_sigmas
 
-    def _post_processing(
-        self, analysis_result: CurveAnalysisResult, **options
-    ) -> CurveAnalysisResult:
+    def _post_processing(self, analysis_result: CurveAnalysisResult) -> CurveAnalysisResult:
         """Calculate new quantity from the fit result.
 
         Subclasses can override this method to do post analysis.
 
         Args:
             analysis_result: Analysis result containing fit result.
-            options: Analysis options.
 
         Returns:
             New CurveAnalysisResult instance containing the result of post analysis.
@@ -454,13 +428,13 @@ def _post_processing(
         return analysis_result
 
     def _extract_curves(
-        self,
-        x_key: str,
-        experiment_data: ExperimentData,
-        data_processor: Union[Callable, DataProcessor],
-    ) -> Tuple[np.ndarray, ...]:
+            self, experiment_data: ExperimentData, data_processor: Union[Callable, DataProcessor]
+    ):
         """Extract curve data from experiment data.
 
+        This method internally populate `self.__x_values`, `self.__y_values`, `self.__y_sigmas`
+        and `self.__data_index` with given `experiment_data`.
+
         .. notes::
             The target metadata properties to define each curve entry is described by
             the class attribute __series__. This method returns the same numbers
@@ -469,20 +443,14 @@ def _extract_curves(
             common to the entire curve scan, i.e. series-level metadata.
 
         Args:
-            x_key: A circuit metadata key to represent scanned value.
             experiment_data: ExperimentData object to fit parameters.
             data_processor: A callable or DataProcessor instance to format data into numpy array.
                 This should take list of dictionary and returns two tuple of float values
                 that represent a y value and an error of it.
-
-        Returns:
-            Tuple of series, x values, y values, and y sigmas.
-
         Raises:
             DataProcessorError:
                 - When __x_key__ is not defined in the circuit metadata.
         """
-
         def _is_target_series(datum, **filters):
             try:
                 return all(datum["metadata"][key] == val for key, val in filters.items())
@@ -492,6 +460,7 @@ def _is_target_series(datum, **filters):
         # Extract X, Y, Y_sigma data
         data = experiment_data.data()
 
+        x_key = self._get_option("x_key")
         try:
             x_values = [datum["metadata"][x_key] for datum in data]
         except KeyError as ex:
@@ -502,19 +471,17 @@ def _is_target_series(datum, **filters):
         y_values, y_sigmas = zip(*map(data_processor, data))
 
         # Format data
-        x_values = np.asarray(x_values, dtype=float)
-        y_values = np.asarray(y_values, dtype=float)
-        y_sigmas = np.asarray(y_sigmas, dtype=float)
+        self.__x_values = np.asarray(x_values, dtype=float)
+        self.__y_values = np.asarray(y_values, dtype=float)
+        self.__y_sigmas = np.asarray(y_sigmas, dtype=float)
 
         # Find series (invalid data is labeled as -1)
-        series = -1 * np.ones(x_values.size, dtype=int)
+        self.__data_index = -1 * np.ones(self.__x_values.size, dtype=int)
         for idx, series_def in enumerate(self.__series__):
             data_index = np.asarray(
                 [_is_target_series(datum, **series_def.filter_kwargs) for datum in data], dtype=bool
             )
-            series[data_index] = idx
-
-        return series, x_values, y_values, y_sigmas
+            self.__data_index[data_index] = idx
 
     def _format_fit_options(self, **fitter_options) -> Dict[str, Any]:
         """Format fitting option args to dictionary of parameter names.
@@ -544,7 +511,7 @@ def _format_fit_options(self, **fitter_options) -> Dict[str, Any]:
             )
         fit_params = list(list(fsigs)[0].parameters.keys())[1:]
 
-        # Validate dictionaly keys
+        # Validate dictionary keys
         def _check_keys(parameter_name):
             named_values = fitter_options[parameter_name]
             if not named_values.keys() == set(fit_params):
@@ -583,18 +550,18 @@ def _dictionarize(parameter_name):
         return fitter_options
 
     def _subset_data(
-        self,
-        name: str,
-        series: np.ndarray,
-        x_values: np.ndarray,
-        y_values: np.ndarray,
-        y_sigmas: np.ndarray,
+            self,
+            name: str,
+            data_index: np.ndarray,
+            x_values: np.ndarray,
+            y_values: np.ndarray,
+            y_sigmas: np.ndarray,
     ) -> Tuple[np.ndarray, ...]:
         """A helper method to extract reduced set of data.
 
         Args:
             name: Series name to search for.
-            series: An integer array representing a mapping of data location to series index.
+            data_index: An integer array representing a mapping of data location to series index.
             x_values: Full data set of x values.
             y_values: Full data set of y values.
             y_sigmas: Full data set of y sigmas.
@@ -608,10 +575,49 @@ def _subset_data(
         """
         for idx, series_def in enumerate(self.__series__):
             if series_def.name == name:
-                data_index = series == idx
-                return x_values[data_index], y_values[data_index], y_sigmas[data_index]
+                sub_x_values = x_values[data_index == idx]
+                sub_y_values = y_values[data_index == idx]
+                sub_y_sigmas = y_sigmas[data_index == idx]
+
+                return sub_x_values, sub_y_values, sub_y_sigmas
+
         raise AnalysisError(f"Specified series {name} is not defined in this analysis.")
 
+    def _arg_parse(self, **options) -> Dict[str, Any]:
+        """Parse input kwargs with predicted input.
+
+        Args:
+            options: User-input keyword argument options.
+
+        Returns:
+            Keyword arguments that not specified in the default options.
+        """
+        extra_options = dict()
+        for key, value in options.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+            else:
+                extra_options[key] = value
+
+        return extra_options
+
+    def _get_option(self, arg_name: str) -> Any:
+        """A helper function to get specified field from the input analysis options.
+
+        Args:
+            arg_name: Name of option.
+
+        Return:
+            Arbitrary object specified by the option name.
+        """
+        try:
+            getattr(self, arg_name)
+        except AttributeError:
+            raise AnalysisError(
+                f"The argument {arg_name} is selected but not defined. "
+                "This key-value pair should be defined in the analysis option."
+            )
+
     def _run_analysis(
         self, experiment_data: ExperimentData, **options
     ) -> Tuple[List[AnalysisResult], List["pyplot.Figure"]]:
@@ -634,19 +640,15 @@ def _run_analysis(
         figures = list()
 
         # pop arguments that are not given to fitter
-        curve_fitter = options.pop("curve_fitter")
-        data_processor = options.pop("data_processor")
-        x_key = options.pop("x_key")
-        plot = options.pop("plot")
-        axis = options.pop("ax")
-        xlabel = options.pop("xlabel")
-        ylabel = options.pop("ylabel")
-        fit_reports = options.pop("fit_reports")
-        return_data_points = options.pop("return_data_points")
+        extra_options = self._arg_parse(**options)
+
+        # TODO update this with experiment metadata PR #67
+        self.__num_qubits = len(experiment_data.data(0)["metadata"]["qubits"])
 
         #
         # 1. Setup data processor
         #
+        data_processor = self._get_option("data_processor")
         if isinstance(data_processor, DataProcessor) and not data_processor.is_trained:
             # Qiskit DataProcessor instance. May need calibration.
             try:
@@ -660,11 +662,7 @@ def _run_analysis(
         # 2. Extract curve entries from experiment data
         #
         try:
-            series, xdata, ydata, sigma = self._extract_curves(
-                x_key=x_key,
-                experiment_data=experiment_data,
-                data_processor=data_processor,
-            )
+            self._extract_curves(experiment_data=experiment_data, data_processor=data_processor)
         except DataProcessorError as ex:
             raise AnalysisError(
                 f"Data extraction and formatting failed with error message: {str(ex)}."
@@ -674,18 +672,19 @@ def _run_analysis(
         # 3. Run fitting
         #
         try:
+            curve_fitter = self._get_option("curve_fitter")
+
             # format fit data
-            _series, _xdata, _ydata, _sigma = self._pre_processing(
-                series=series, x_values=xdata, y_values=ydata, y_sigmas=sigma, **options
-            )
+            _data_index, _xdata, _ydata, _sigma = self._pre_processing()
+
             # Generate fit options
-            fit_candidates = self._setup_fitting(_series, _xdata, _ydata, _sigma, **options)
+            fit_candidates = self._setup_fitting(**extra_options)
             if isinstance(fit_candidates, dict):
                 # only single initial guess
                 fit_options = self._format_fit_options(**fit_candidates)
                 fit_result = curve_fitter(
                     funcs=[series_def.fit_func for series_def in self.__series__],
-                    series=_series,
+                    series=_data_index,
                     xdata=_xdata,
                     ydata=_ydata,
                     sigma=_sigma,
@@ -700,7 +699,7 @@ def _run_analysis(
                 fit_results = [
                     curve_fitter(
                         funcs=[series_def.fit_func for series_def in self.__series__],
-                        series=_series,
+                        series=_data_index,
                         xdata=_xdata,
                         ydata=_ydata,
                         sigma=_sigma,
@@ -720,39 +719,27 @@ def _run_analysis(
             #
             # 4. Post-process analysis data
             #
-            analysis_result = self._post_processing(analysis_result=analysis_result, **options)
+            analysis_result = self._post_processing(analysis_result=analysis_result)
 
         finally:
             #
             # 5. Create figures
             #
-            if plot:
-                figures.extend(
-                    self._create_figures(
-                        series=series,
-                        x_values=xdata,
-                        y_values=ydata,
-                        y_sigmas=sigma,
-                        analysis_results=analysis_result,
-                        axis=axis,
-                        xlabel=xlabel,
-                        ylabel=ylabel,
-                        fit_reports=fit_reports,
-                    )
-                )
+            if self._get_option("plot"):
+                figures.extend(self._create_figures(analysis_results=analysis_result))
 
             #
             # 6. Optionally store raw data points
             #
-            if return_data_points:
+            if self._get_option("return_data_points"):
                 raw_data_dict = dict()
                 for series_def in self.__series__:
                     sub_xdata, sub_ydata, sub_sigma = self._subset_data(
                         name=series_def.name,
-                        series=series,
-                        x_values=xdata,
-                        y_values=ydata,
-                        y_sigmas=sigma,
+                        data_index=self.__data_index,
+                        x_values=self.__x_values,
+                        y_values=self.__y_values,
+                        y_sigmas=self.__y_sigmas,
                     )
                     raw_data_dict[series_def.name] = {
                         "xdata": sub_xdata,
diff --git a/qiskit_experiments/analysis/fit_function.py b/qiskit_experiments/analysis/fit_function.py
index 706347b725..c7f04c0888 100644
--- a/qiskit_experiments/analysis/fit_function.py
+++ b/qiskit_experiments/analysis/fit_function.py
@@ -70,6 +70,6 @@ def gaussian(
     r"""Gaussian function
 
     .. math::
-        y = {\rm amp} \exp \left( - (x - x0)^2 / \sigma^2 \right) + {\rm baseline}
+        y = {\rm amp} \exp \left( - (x - x0)^2 / 2 \sigma^2 \right) + {\rm baseline}
     """
-    return amp * np.exp(-((x - x0) ** 2) / sigma ** 2) + baseline
+    return amp * np.exp(-((x - x0) ** 2) / (2 * sigma ** 2)) + baseline
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index f766380425..c86539f5c6 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -16,8 +16,7 @@
 
 import numpy as np
 
-from qiskit_experiments.analysis import SeriesDef, fit_function
-from qiskit_experiments.experiment_data import AnalysisResult
+from qiskit_experiments.analysis import CurveAnalysisResult, SeriesDef, fit_function
 from .rb_analysis import RBAnalysis
 
 
@@ -61,51 +60,56 @@ class InterleavedRBAnalysis(RBAnalysis):
     @classmethod
     def _default_options(cls):
         default_options = super()._default_options()
+        default_options.p0 = {"a": None, "alpha": None, "alpha_c": None, "b": None}
+        default_options.bounds = {
+            "a": (0., 1.), "alpha": (0., 1.), "alpha_c": (0., 1.), "b": (0., 1.)
+        }
         default_options.fit_reports = {"alpha": "\u03B1", "alpha_c": "\u03B1$_c$", "EPC": "EPC"}
 
         return default_options
 
-    def _setup_fitting(
-        self,
-        series: np.ndarray,
-        x_values: np.ndarray,
-        y_values: np.ndarray,
-        y_sigmas: np.ndarray,
-        **options,
-    ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+    def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
         """Fitter options."""
+        user_p0 = self._get_option("p0")
+        user_bounds = self._get_option("bounds")
+
         std_xdata, std_ydata, _ = self._subset_data(
             name="Standard",
-            series=series,
-            x_values=x_values,
-            y_values=y_values,
-            y_sigmas=y_sigmas,
+            data_index=self.__data_index,
+            x_values=self.__x_values,
+            y_values=self.__y_values,
+            y_sigmas=self.__y_sigmas,
         )
-        p0_std = self._initial_guess(std_xdata, std_ydata, options["num_qubits"])
+        p0_std = self._initial_guess(std_xdata, std_ydata, self.__num_qubits)
 
         int_xdata, int_ydata, _ = self._subset_data(
             name="Interleaved",
-            series=series,
-            x_values=x_values,
-            y_values=y_values,
-            y_sigmas=y_sigmas,
+            data_index=self.__data_index,
+            x_values=self.__x_values,
+            y_values=self.__y_values,
+            y_sigmas=self.__y_sigmas,
         )
-        p0_int = self._initial_guess(int_xdata, int_ydata, options["num_qubits"])
-
-        irb_p0 = {
-            "a": np.mean([p0_std["a"], p0_int["a"]]),
-            "alpha": p0_std["alpha"],
-            "alpha_c": min(p0_int["alpha"] / p0_std["alpha"], 1),
-            "b": np.mean([p0_std["b"], p0_int["b"]]),
+        p0_int = self._initial_guess(int_xdata, int_ydata, self.__num_qubits)
+
+        return {
+            "p0": {
+                "a": user_p0["a"] or np.mean([p0_std["a"], p0_int["a"]]),
+                "alpha": user_p0["alpha"] or p0_std["alpha"],
+                "alpha_c": user_p0["alpha_c"] or min(p0_int["alpha"] / p0_std["alpha"], 1),
+                "b": user_p0["b"] or np.mean([p0_std["b"], p0_int["b"]]),
+            },
+            "bounds": {
+                "a": user_bounds["a"] or (0., 1.),
+                "alpha": user_bounds["alpha"] or (0., 1.),
+                "alpha_c": user_bounds["alpha_c"] or (0., 1.),
+                "b": user_bounds["b"] or (0., 1.),
+            }
         }
-        irb_bounds = {"a": [0, 1], "alpha": [0, 1], "alpha_c": [0, 1], "b": [0, 1]}
-
-        return {"p0": irb_p0, "bounds": irb_bounds}
 
-    def _post_processing(self, analysis_result: AnalysisResult, **options) -> AnalysisResult:
+    def _post_processing(self, analysis_result: CurveAnalysisResult) -> CurveAnalysisResult:
         """Calculate EPC."""
         # Add EPC data
-        nrb = 2 ** options["num_qubits"]
+        nrb = 2 ** self.__num_qubits
         scale = (nrb - 1) / nrb
         _, alpha, alpha_c, _ = analysis_result["popt"]
         _, _, alpha_c_err, _ = analysis_result["popt_err"]
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index 36b60a14ca..09d92ceaee 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -17,9 +17,8 @@
 
 import numpy as np
 
-from qiskit_experiments.analysis import CurveAnalysis, SeriesDef, fit_function
+from qiskit_experiments.analysis import CurveAnalysis, CurveAnalysisResult, SeriesDef, fit_function
 from qiskit_experiments.analysis.data_processing import multi_mean_xy_data
-from qiskit_experiments.experiment_data import AnalysisResult
 
 
 class RBAnalysis(CurveAnalysis):
@@ -37,24 +36,35 @@ class RBAnalysis(CurveAnalysis):
     @classmethod
     def _default_options(cls):
         default_options = super()._default_options()
+        default_options.p0 = {"a": None, "alpha": None, "b": None}
+        default_options.bounds = {"a": (0., 1.), "alpha": (0., 1.), "b": (0., 1.)}
         default_options.xlabel = "Clifford Length"
         default_options.ylabel = "P(0)"
         default_options.fit_reports = {"alpha": "\u03B1", "EPC": "EPC"}
 
         return default_options
 
-    def _setup_fitting(
-        self,
-        series: np.ndarray,
-        x_values: np.ndarray,
-        y_values: np.ndarray,
-        y_sigmas: np.ndarray,
-        **options,
-    ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+    def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
         """Fitter options."""
+        user_p0 = self._get_option("p0")
+        user_bounds = self._get_option("bounds")
+
+        initial_guess = self._initial_guess(
+            self.__x_values,
+            self.__y_values,
+            self.__num_qubits
+        )
         return {
-            "p0": self._initial_guess(x_values, y_values, options["num_qubits"]),
-            "bounds": {"a": [0.0, 1.0], "alpha": [0.0, 1.0], "b": [0.0, 1.0]},
+            "p0": {
+                "a": user_p0["a"] or initial_guess["a"],
+                "alpha": user_p0["alpha"] or initial_guess["alpha"],
+                "b": user_p0["b"] or initial_guess["b"]
+            },
+            "bounds": {
+                "a": user_bounds["a"] or (0., 1.),
+                "alpha": user_bounds["alpha"] or (0., 1.),
+                "b": user_bounds["b"] or (0., 1.)
+            },
         }
 
     @staticmethod
@@ -77,25 +87,22 @@ def _initial_guess(
 
         return fit_guess
 
-    def _pre_processing(
-        self,
-        series: np.ndarray,
-        x_values: np.ndarray,
-        y_values: np.ndarray,
-        y_sigmas: np.ndarray,
-        **options,
-    ) -> Tuple[np.ndarray, ...]:
+    def _pre_processing(self) -> Tuple[np.ndarray, ...]:
         """Average over the same x values."""
         return multi_mean_xy_data(
-            series=series, xdata=x_values, ydata=y_values, sigma=y_sigmas, method="sample"
+            series=self.__data_index,
+            xdata=self.__x_values,
+            ydata=self.__y_values,
+            sigma=self.__y_sigmas,
+            method="sample"
         )
 
-    def _post_processing(self, analysis_result: AnalysisResult, **options) -> AnalysisResult:
+    def _post_processing(self, analysis_result: CurveAnalysisResult) -> CurveAnalysisResult:
         """Calculate EPC."""
         alpha = analysis_result["popt"][1]
         alpha_err = analysis_result["popt_err"][1]
 
-        scale = (2 ** options["num_qubits"] - 1) / (2 ** options["num_qubits"])
+        scale = (2 ** self.__num_qubits - 1) / (2 ** self.__num_qubits)
         analysis_result["EPC"] = scale * (1 - alpha)
         analysis_result["EPC_err"] = scale * alpha_err / alpha
 

From f2ce8427dd766accfb72acbcf97f5b4457954d48 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 4 Jun 2021 23:56:29 +0900
Subject: [PATCH 56/74] - private -> protected member - param list generation
 and validation in new method - all nan sigma handling - zero sigma handling
 in curve fitter - add data extraction utils - allow bounds = None -

---
 qiskit_experiments/analysis/__init__.py       |  11 ++
 qiskit_experiments/analysis/curve_analysis.py | 137 +++++++++++-------
 qiskit_experiments/analysis/curve_fitting.py  |   9 ++
 .../analysis/data_processing.py               |   3 -
 qiskit_experiments/analysis/utils.py          |  72 +++++++++
 .../interleaved_rb_analysis.py                |  40 +++--
 .../randomized_benchmarking/rb_analysis.py    |  34 +++--
 .../randomized_benchmarking/rb_experiment.py  |   5 +-
 test/analysis/test_curve_fit.py               |  84 +++++++----
 9 files changed, 281 insertions(+), 114 deletions(-)
 create mode 100644 qiskit_experiments/analysis/utils.py

diff --git a/qiskit_experiments/analysis/__init__.py b/qiskit_experiments/analysis/__init__.py
index d00256f4e6..719c9c55c2 100644
--- a/qiskit_experiments/analysis/__init__.py
+++ b/qiskit_experiments/analysis/__init__.py
@@ -30,6 +30,7 @@
     process_curve_data
     process_multi_curve_data
 
+
 Plotting
 ========
 .. autosummary::
@@ -39,6 +40,7 @@
     plot_errorbar
     plot_scatter
 
+
 Fit Functions
 =============
 .. autosummary::
@@ -49,6 +51,14 @@
     fit_function.gaussian
     fit_function.sin
 
+
+Utility
+=======
+.. autosummary::
+    :toctree: ../stubs/
+
+    get_opt_error
+    get_opt_value
 """
 from .curve_analysis import CurveAnalysis, SeriesDef
 
@@ -60,3 +70,4 @@
     process_multi_curve_data,
 )
 from .plotting import plot_curve_fit, plot_errorbar, plot_scatter
+from .utils import get_opt_error, get_opt_value
diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 6dbe00fafe..9ff6225e1b 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -17,7 +17,7 @@
 
 import dataclasses
 import inspect
-from typing import Any, Dict, List, Tuple, Callable, Union, Optional
+from typing import Any, Dict, List, Tuple, Callable, Union
 
 import numpy as np
 from qiskit.providers.options import Options
@@ -25,6 +25,7 @@
 from qiskit_experiments.analysis import plotting
 from qiskit_experiments.analysis.curve_fitting import multi_curve_fit, CurveAnalysisResult
 from qiskit_experiments.analysis.data_processing import probability
+from qiskit_experiments.analysis.utils import get_opt_value, get_opt_error
 from qiskit_experiments.base_analysis import BaseAnalysis
 from qiskit_experiments.data_processing import DataProcessor
 from qiskit_experiments.data_processing.exceptions import DataProcessorError
@@ -180,27 +181,49 @@ class AnalysisExample(CurveAnalysis):
     #: List[SeriesDef]: List of mapping representing a data series
     __series__ = None
 
+    def __new__(cls):
+        """Parse series data if all fit functions have the same argument.
+
+        Raises:
+            AnalysisError:
+                - When fit functions have different argument.
+        """
+        obj = object.__new__(cls)
+
+        fsigs = set()
+        for series_def in obj.__series__:
+            fsigs.add(inspect.signature(series_def.fit_func))
+        if len(fsigs) > 1:
+            raise AnalysisError(
+                "Fit functions specified in the series definition have "
+                "different function signature. They should receive "
+                "the same parameter set for multi-objective function fit."
+            )
+        obj.__fit_params = list(list(fsigs)[0].parameters.keys())[1:]
+
+        return obj
+
     def __init__(self):
         """Initialize data fields that are privately accessed by methods."""
 
         #: Iterable[int]: Array of series index for each data point
-        self.__data_index = None
+        self._data_index = None
 
         #: Iterable[float]: Concatenated x values of all series
-        self.__x_values = None
+        self._x_values = None
 
         #: Iterable[float]: Concatenated y values of all series
-        self.__y_values = None
+        self._y_values = None
 
         #: Iterable[float]: Concatenated y sigmas of all series
-        self.__y_sigmas = None
+        self._y_sigmas = None
 
         #: int: Number of qubit
-        self.__num_qubits = None
+        self._num_qubits = None
 
         # Add expected options to instance variable so that every method can access to.
         for key in self._default_options().__dict__.keys():
-            setattr(self, key, None)
+            setattr(self, f"_{key}", None)
 
     @classmethod
     def _default_options(cls):
@@ -253,8 +276,8 @@ def data_processor(data: Dict[str, Any]) -> Tuple[float, float]
             x_key="xval",
             plot=True,
             axis=None,
-            xlabel="x value",
-            ylabel="y value",
+            xlabel=None,
+            ylabel=None,
             ylim=None,
             fit_reports=None,
             return_data_points=False,
@@ -289,10 +312,10 @@ def _create_figures(self, analysis_results: CurveAnalysisResult) -> List["Figure
 
                 xdata, ydata, _ = self._subset_data(
                     name=series_def.name,
-                    data_index=self.__data_index,
-                    x_values=self.__x_values,
-                    y_values=self.__y_values,
-                    y_sigmas=self.__y_sigmas,
+                    data_index=self._data_index,
+                    x_values=self._x_values,
+                    y_values=self._y_values,
+                    y_sigmas=self._y_sigmas,
                 )
                 ymin = min(ymin, *ydata)
                 ymax = max(ymax, *ydata)
@@ -301,6 +324,12 @@ def _create_figures(self, analysis_results: CurveAnalysisResult) -> List["Figure
                 # plot formatted data
 
                 xdata, ydata, sigma = self._subset_data(series_def.name, *self._pre_processing())
+
+                if np.all(np.isnan(sigma)):
+                    sigma = None
+                else:
+                    sigma = np.nan_to_num(sigma)
+
                 plotting.plot_errorbar(
                     xdata=xdata,
                     ydata=ydata,
@@ -349,14 +378,13 @@ def _create_figures(self, analysis_results: CurveAnalysisResult) -> List["Figure
                 for par_name, label in fit_reports.items():
                     try:
                         # fit value
-                        pind = analysis_results["popt_keys"].index(par_name)
-                        pval = analysis_results["popt"][pind]
-                        perr = analysis_results["popt_err"][pind]
+                        pval = get_opt_value(analysis_results, par_name)
+                        perr = get_opt_error(analysis_results, par_name)
                     except ValueError:
                         # maybe post processed value
                         pval = analysis_results[par_name]
                         perr = analysis_results[f"{par_name}_err"]
-                    analysis_description += f"{label} = {pval: .3e} \u00B1 {perr: .3e}\n"
+                    analysis_description += f"{label} = {pval: .3e}\u00B1{perr: .3e}\n"
                 chisq = analysis_results["reduced_chisq"]
                 analysis_description += f"Fit \u03C7-squared = {chisq: .4f}"
 
@@ -396,7 +424,10 @@ def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]
         Returns:
             List of FitOptions that are passed to fitter function.
         """
-        return options
+        fit_options = {"p0": self._get_option("p0"), "bounds": self._get_option("bounds")}
+        fit_options.update(options)
+
+        return fit_options
 
     def _pre_processing(self) -> Tuple[np.ndarray, ...]:
         """An optional subroutine to perform data pre-processing.
@@ -412,7 +443,7 @@ def _pre_processing(self) -> Tuple[np.ndarray, ...]:
         Returns:
             Numpy array tuple of pre-processed (x_values, y_values, y_sigmas, series).
         """
-        return self.__data_index, self.__x_values, self.__y_values, self.__y_sigmas
+        return self._data_index, self._x_values, self._y_values, self._y_sigmas
 
     def _post_processing(self, analysis_result: CurveAnalysisResult) -> CurveAnalysisResult:
         """Calculate new quantity from the fit result.
@@ -471,17 +502,17 @@ def _is_target_series(datum, **filters):
         y_values, y_sigmas = zip(*map(data_processor, data))
 
         # Format data
-        self.__x_values = np.asarray(x_values, dtype=float)
-        self.__y_values = np.asarray(y_values, dtype=float)
-        self.__y_sigmas = np.asarray(y_sigmas, dtype=float)
+        self._x_values = np.asarray(x_values, dtype=float)
+        self._y_values = np.asarray(y_values, dtype=float)
+        self._y_sigmas = np.asarray(y_sigmas, dtype=float)
 
         # Find series (invalid data is labeled as -1)
-        self.__data_index = -1 * np.ones(self.__x_values.size, dtype=int)
+        self._data_index = -1 * np.ones(self._x_values.size, dtype=int)
         for idx, series_def in enumerate(self.__series__):
             data_index = np.asarray(
                 [_is_target_series(datum, **series_def.filter_kwargs) for datum in data], dtype=bool
             )
-            self.__data_index[data_index] = idx
+            self._data_index[data_index] = idx
 
     def _format_fit_options(self, **fitter_options) -> Dict[str, Any]:
         """Format fitting option args to dictionary of parameter names.
@@ -499,53 +530,43 @@ def _format_fit_options(self, **fitter_options) -> Dict[str, Any]:
                 - When initial guesses are not provided.
                 - When fit option is array but length doesn't match with parameter number.
         """
-        # check fit function signatures
-        fsigs = set()
-        for series_def in self.__series__:
-            fsigs.add(inspect.signature(series_def.fit_func))
-        if len(fsigs) > 1:
-            raise AnalysisError(
-                "Fit functions specified in the series definition have "
-                "different function signature. They should receive "
-                "the same parameter set for multi-objective function fit."
-            )
-        fit_params = list(list(fsigs)[0].parameters.keys())[1:]
-
         # Validate dictionary keys
         def _check_keys(parameter_name):
             named_values = fitter_options[parameter_name]
-            if not named_values.keys() == set(fit_params):
+            if not named_values.keys() == set(self.__fit_params):
                 raise AnalysisError(
                     f"Fitting option `{parameter_name}` doesn't have the "
-                    f"expected parameter names {','.join(fit_params)}."
+                    f"expected parameter names {','.join(self.__fit_params)}."
                 )
 
         # Convert array into dictionary
         def _dictionarize(parameter_name):
             parameter_array = fitter_options[parameter_name]
-            if len(parameter_array) != len(fit_params):
+            if len(parameter_array) != len(self.__fit_params):
                 raise AnalysisError(
                     f"Value length of fitting option `{parameter_name}` doesn't "
                     "match with the length of expected parameters. "
-                    f"{len(parameter_array)} != {len(fit_params)}."
+                    f"{len(parameter_array)} != {len(self.__fit_params)}."
                 )
-            return dict(zip(fit_params, parameter_array))
+            return dict(zip(self.__fit_params, parameter_array))
 
-        if "p0" in fitter_options:
+        if fitter_options.get("p0", None):
             if isinstance(fitter_options["p0"], dict):
                 _check_keys("p0")
             else:
                 fitter_options["p0"] = _dictionarize("p0")
         else:
+            # p0 should be defined
             raise AnalysisError("Initial guess p0 is not provided to the fitting options.")
 
-        if "bounds" in fitter_options:
+        if fitter_options.get("bounds", None):
             if isinstance(fitter_options["bounds"], dict):
                 _check_keys("bounds")
             else:
                 fitter_options["bounds"] = _dictionarize("bounds")
         else:
-            fitter_options["bounds"] = dict(zip(fit_params, [(-np.inf, np.inf)] * len(fit_params)))
+            # bounds are optional
+            fitter_options["bounds"] = {par: (-np.inf, np.inf) for par in self.__fit_params}
 
         return fitter_options
 
@@ -594,8 +615,9 @@ def _arg_parse(self, **options) -> Dict[str, Any]:
         """
         extra_options = dict()
         for key, value in options.items():
-            if hasattr(self, key):
-                setattr(self, key, value)
+            private_key = f"_{key}"
+            if hasattr(self, private_key):
+                setattr(self, private_key, value)
             else:
                 extra_options[key] = value
 
@@ -611,7 +633,7 @@ def _get_option(self, arg_name: str) -> Any:
             Arbitrary object specified by the option name.
         """
         try:
-            getattr(self, arg_name)
+            return getattr(self, f"_{arg_name}")
         except AttributeError:
             raise AnalysisError(
                 f"The argument {arg_name} is selected but not defined. "
@@ -643,7 +665,10 @@ def _run_analysis(
         extra_options = self._arg_parse(**options)
 
         # TODO update this with experiment metadata PR #67
-        self.__num_qubits = len(experiment_data.data(0)["metadata"]["qubits"])
+        try:
+            self._num_qubits = len(experiment_data.data(0)["metadata"]["qubits"])
+        except KeyError:
+            pass
 
         #
         # 1. Setup data processor
@@ -674,13 +699,15 @@ def _run_analysis(
         try:
             curve_fitter = self._get_option("curve_fitter")
 
-            # format fit data
+            # Format fit data
             _data_index, _xdata, _ydata, _sigma = self._pre_processing()
 
             # Generate fit options
             fit_candidates = self._setup_fitting(**extra_options)
+
+            # Fit for each fit parameter combination
             if isinstance(fit_candidates, dict):
-                # only single initial guess
+                # Only single initial guess
                 fit_options = self._format_fit_options(**fit_candidates)
                 fit_result = curve_fitter(
                     funcs=[series_def.fit_func for series_def in self.__series__],
@@ -692,7 +719,7 @@ def _run_analysis(
                 )
                 analysis_result.update(**fit_result)
             else:
-                # multiple initial guesses
+                # Multiple initial guesses
                 fit_options_candidates = [
                     self._format_fit_options(**fit_options) for fit_options in fit_candidates
                 ]
@@ -736,10 +763,10 @@ def _run_analysis(
                 for series_def in self.__series__:
                     sub_xdata, sub_ydata, sub_sigma = self._subset_data(
                         name=series_def.name,
-                        data_index=self.__data_index,
-                        x_values=self.__x_values,
-                        y_values=self.__y_values,
-                        y_sigmas=self.__y_sigmas,
+                        data_index=self._data_index,
+                        x_values=self._x_values,
+                        y_values=self._y_values,
+                        y_sigmas=self._y_sigmas,
                     )
                     raw_data_dict[series_def.name] = {
                         "xdata": sub_xdata,
diff --git a/qiskit_experiments/analysis/curve_fitting.py b/qiskit_experiments/analysis/curve_fitting.py
index 9292fdfc02..2f94d55264 100644
--- a/qiskit_experiments/analysis/curve_fitting.py
+++ b/qiskit_experiments/analysis/curve_fitting.py
@@ -125,6 +125,15 @@ def fit_func(x, *params):
             " (len(ydata) - len(p0)) is less than 1"
         )
 
+    # Format non-number sigma values
+    if np.all(np.isnan(sigma)):
+        sigma = None
+    else:
+        sigma = np.nan_to_num(sigma)
+        if np.count_nonzero(sigma) != len(sigma):
+            # Sigma = 0 causes zero division error
+            sigma = None
+
     # Override scipy.curve_fit default for absolute_sigma=True
     # if sigma is specified.
     if sigma is not None and "absolute_sigma" not in kwargs:
diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index d04095c468..b2858d21b9 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -177,9 +177,6 @@ def level2_probability(data: Dict[str, any], outcome: str) -> Tuple[float, float
         mean probability is :math:`p = K / N` and the variance is
         :math:`\\sigma^2 = p (1-p) / N`.
     """
-    # TODO fix sigma definition
-    # When the count is 100% zero (i.e. simulator), this yields sigma=0.
-    # This crashes scipy fitter when it calculates covariance matrix (zero-div error).
     counts = data["counts"]
 
     shots = sum(counts.values())
diff --git a/qiskit_experiments/analysis/utils.py b/qiskit_experiments/analysis/utils.py
new file mode 100644
index 0000000000..7686d872f3
--- /dev/null
+++ b/qiskit_experiments/analysis/utils.py
@@ -0,0 +1,72 @@
+# 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.
+
+"""Analysis utility functions."""
+
+
+from qiskit_experiments.experiment_data import AnalysisResult
+
+
+def get_opt_value(analysis_result: AnalysisResult, param_name: str) -> float:
+    """A helper function to get parameter value from analysis result.
+
+    Args:
+        analysis_result: Analysis result object.
+        param_name: Name of parameter to extract.
+
+    Returns:
+        Parameter value.
+
+    Raises:
+        KeyError:
+            - When analysis result does not contain parameter information.
+        ValueError:
+            - When specified parameter is not defined.
+    """
+    try:
+        index = analysis_result["popt_keys"].index(param_name)
+        return analysis_result["popt"][index]
+    except KeyError:
+        raise KeyError(
+            "Input analysis result has not fit parameter information. "
+            "Please confirm if the fit is successfully completed."
+        )
+    except ValueError:
+        raise ValueError(f"Parameter {param_name} is not defined.")
+
+
+def get_opt_error(analysis_result: AnalysisResult, param_name: str) -> float:
+    """A helper function to get error value from analysis result.
+
+    Args:
+        analysis_result: Analysis result object.
+        param_name: Name of parameter to extract.
+
+    Returns:
+        Parameter error value.
+
+    Raises:
+        KeyError:
+            - When analysis result does not contain parameter information.
+        ValueError:
+            - When specified parameter is not defined.
+    """
+    try:
+        index = analysis_result["popt_keys"].index(param_name)
+        return analysis_result["popt_err"][index]
+    except KeyError:
+        raise KeyError(
+            "Input analysis result has not fit parameter information. "
+            "Please confirm if the fit is successfully completed."
+        )
+    except ValueError:
+        raise ValueError(f"Parameter {param_name} is not defined.")
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index c86539f5c6..6ad234aadf 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -16,7 +16,13 @@
 
 import numpy as np
 
-from qiskit_experiments.analysis import CurveAnalysisResult, SeriesDef, fit_function
+from qiskit_experiments.analysis import (
+    CurveAnalysisResult,
+    SeriesDef,
+    fit_function,
+    get_opt_value,
+    get_opt_error,
+)
 from .rb_analysis import RBAnalysis
 
 
@@ -75,23 +81,23 @@ def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]
 
         std_xdata, std_ydata, _ = self._subset_data(
             name="Standard",
-            data_index=self.__data_index,
-            x_values=self.__x_values,
-            y_values=self.__y_values,
-            y_sigmas=self.__y_sigmas,
+            data_index=self._data_index,
+            x_values=self._x_values,
+            y_values=self._y_values,
+            y_sigmas=self._y_sigmas,
         )
-        p0_std = self._initial_guess(std_xdata, std_ydata, self.__num_qubits)
+        p0_std = self._initial_guess(std_xdata, std_ydata, self._num_qubits)
 
         int_xdata, int_ydata, _ = self._subset_data(
             name="Interleaved",
-            data_index=self.__data_index,
-            x_values=self.__x_values,
-            y_values=self.__y_values,
-            y_sigmas=self.__y_sigmas,
+            data_index=self._data_index,
+            x_values=self._x_values,
+            y_values=self._y_values,
+            y_sigmas=self._y_sigmas,
         )
-        p0_int = self._initial_guess(int_xdata, int_ydata, self.__num_qubits)
+        p0_int = self._initial_guess(int_xdata, int_ydata, self._num_qubits)
 
-        return {
+        fit_option = {
             "p0": {
                 "a": user_p0["a"] or np.mean([p0_std["a"], p0_int["a"]]),
                 "alpha": user_p0["alpha"] or p0_std["alpha"],
@@ -105,14 +111,18 @@ def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]
                 "b": user_bounds["b"] or (0., 1.),
             }
         }
+        fit_option.update(options)
+
+        return fit_option
 
     def _post_processing(self, analysis_result: CurveAnalysisResult) -> CurveAnalysisResult:
         """Calculate EPC."""
         # Add EPC data
-        nrb = 2 ** self.__num_qubits
+        nrb = 2 ** self._num_qubits
         scale = (nrb - 1) / nrb
-        _, alpha, alpha_c, _ = analysis_result["popt"]
-        _, _, alpha_c_err, _ = analysis_result["popt_err"]
+        alpha = get_opt_value(analysis_result, "alpha")
+        alpha_c = get_opt_value(analysis_result, "alpha_c")
+        alpha_c_err = get_opt_error(analysis_result, "alpha_c")
 
         # Calculate epc_est (=r_c^est) - Eq. (4):
         epc_est = scale * (1 - alpha_c)
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index 09d92ceaee..c46987d0d5 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -17,7 +17,14 @@
 
 import numpy as np
 
-from qiskit_experiments.analysis import CurveAnalysis, CurveAnalysisResult, SeriesDef, fit_function
+from qiskit_experiments.analysis import (
+    CurveAnalysis,
+    CurveAnalysisResult,
+    SeriesDef,
+    fit_function,
+    get_opt_value,
+    get_opt_error,
+)
 from qiskit_experiments.analysis.data_processing import multi_mean_xy_data
 
 
@@ -50,11 +57,11 @@ def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]
         user_bounds = self._get_option("bounds")
 
         initial_guess = self._initial_guess(
-            self.__x_values,
-            self.__y_values,
-            self.__num_qubits
+            self._x_values,
+            self._y_values,
+            self._num_qubits
         )
-        return {
+        fit_option = {
             "p0": {
                 "a": user_p0["a"] or initial_guess["a"],
                 "alpha": user_p0["alpha"] or initial_guess["alpha"],
@@ -66,6 +73,9 @@ def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]
                 "b": user_bounds["b"] or (0., 1.)
             },
         }
+        fit_option.update(options)
+
+        return fit_option
 
     @staticmethod
     def _initial_guess(
@@ -90,19 +100,19 @@ def _initial_guess(
     def _pre_processing(self) -> Tuple[np.ndarray, ...]:
         """Average over the same x values."""
         return multi_mean_xy_data(
-            series=self.__data_index,
-            xdata=self.__x_values,
-            ydata=self.__y_values,
-            sigma=self.__y_sigmas,
+            series=self._data_index,
+            xdata=self._x_values,
+            ydata=self._y_values,
+            sigma=self._y_sigmas,
             method="sample"
         )
 
     def _post_processing(self, analysis_result: CurveAnalysisResult) -> CurveAnalysisResult:
         """Calculate EPC."""
-        alpha = analysis_result["popt"][1]
-        alpha_err = analysis_result["popt_err"][1]
+        alpha = get_opt_value(analysis_result, "alpha")
+        alpha_err = get_opt_error(analysis_result, "alpha")
 
-        scale = (2 ** self.__num_qubits - 1) / (2 ** self.__num_qubits)
+        scale = (2 ** self._num_qubits - 1) / (2 ** self._num_qubits)
         analysis_result["EPC"] = scale * (1 - alpha)
         analysis_result["EPC_err"] = scale * alpha_err / alpha
 
diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
index 3ab673d7b2..b253705103 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -67,10 +67,7 @@ def __init__(
 
         # Set configurable options
         self.set_experiment_options(lengths=list(lengths), num_samples=num_samples)
-        self.set_analysis_options(
-            data_processor=probability(outcome="0" * self.num_qubits),
-            num_qubits=self.num_qubits,
-        )
+        self.set_analysis_options(data_processor=probability(outcome="0" * self.num_qubits))
 
         # Set fixed options
         self._full_sampling = full_sampling
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index 489c1e3248..5999598fac 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -23,6 +23,7 @@
 from qiskit_experiments.analysis.curve_fitting import multi_curve_fit
 from qiskit_experiments.analysis.data_processing import probability
 from qiskit_experiments.base_experiment import BaseExperiment
+from qiskit_experiments.exceptions import AnalysisError
 
 
 class FakeExperiment(BaseExperiment):
@@ -57,18 +58,12 @@ def simulate_output_data(func, xvals, param_dict, **metadata):
     return expdata
 
 
-def create_new_analysis(
-    x_key: str = "xval",
-    series: List[SeriesDef] = None,
-) -> CurveAnalysis:
+def create_new_analysis(series: List[SeriesDef]) -> CurveAnalysis:
     """A helper function to create a mock analysis class instance."""
 
     class TestAnalysis(CurveAnalysis):
         """A mock analysis class to test."""
-
-        __x_key__ = x_key
         __series__ = series
-        __processing_options__ = ["outcome"]
 
     return TestAnalysis()
 
@@ -115,8 +110,37 @@ def setUp(self):
         )
         self.err_decimal = 3
 
+    def test_cannot_create_invalid_series_fit(self):
+        """Test we cannot create invalid analysis instance."""
+        invalid_series = [
+            SeriesDef(
+                name="fit1",
+                fit_func=lambda x, p0: fit_function.exponential_decay(x, amp=p0),
+            ),
+            SeriesDef(
+                name="fit2",
+                fit_func=lambda x, p1: fit_function.exponential_decay(x, amp=p1),
+            ),
+        ]
+        with self.assertRaises(AnalysisError):
+            create_new_analysis(series=invalid_series)  # fit1 has param p0 while fit2 has p1
+
+    def test_arg_parse_and_get_option(self):
+        """Test if option parsing works correctly."""
+        user_option = {"x_key": "test_value", "test_key1": "value1", "test_key2": "value2"}
+
+        # argument not defined in default option should be returned as extra option
+        extra_option = self.analysis._arg_parse(**user_option)
+        ref_option = {"test_key1": "value1", "test_key2": "value2"}
+        self.assertDictEqual(extra_option, ref_option)
+
+        # default option value is stored as class variable
+        self.assertEqual(self.analysis._get_option("x_key"), "test_value")
+
     def test_data_extraction(self):
         """Test data extraction method."""
+        self.analysis._arg_parse(x_key="xval")
+
         # data to analyze
         test_data0 = simulate_output_data(
             func=fit_function.exponential_decay,
@@ -138,9 +162,13 @@ def test_data_extraction(self):
         for datum in test_data1.data():
             test_data0.add_data(datum)
 
-        series, xdata, ydata, sigma = self.analysis._extract_curves(
-            x_key="xval", experiment_data=test_data0, data_processor=probability(outcome="1")
+        self.analysis._extract_curves(
+            experiment_data=test_data0, data_processor=probability(outcome="1")
         )
+        xdata = self.analysis._x_values
+        ydata = self.analysis._y_values
+        sigma = self.analysis._y_sigmas
+        d_index = self.analysis._data_index
 
         # check if the module filter off data: valid=False
         self.assertEqual(len(xdata), 20)
@@ -160,7 +188,7 @@ def test_data_extraction(self):
 
         # check series
         ref_series = np.concatenate((np.zeros(10, dtype=int), -1 * np.ones(10, dtype=int)))
-        self.assertListEqual(list(series), list(ref_series))
+        self.assertListEqual(list(d_index), list(ref_series))
 
         # check y errors
         ref_yerr = ref_y * (1 - ref_y) / 100000
@@ -169,22 +197,22 @@ def test_data_extraction(self):
     def test_get_subset(self):
         """Test that get subset data from full data array."""
 
-        series = np.asarray([0, 1, 0, 2, 2, -1], dtype=int)
+        d_index = np.asarray([0, 1, 0, 2, 2, -1], dtype=int)
         xdata = np.asarray([1, 2, 3, 4, 5, 6], dtype=float)
         ydata = np.asarray([1, 2, 3, 4, 5, 6], dtype=float)
         sigma = np.asarray([1, 2, 3, 4, 5, 6], dtype=float)
 
-        subx, suby, subs = self.analysis._subset_data("curve1", series, xdata, ydata, sigma)
+        subx, suby, subs = self.analysis._subset_data("curve1", d_index, xdata, ydata, sigma)
         np.testing.assert_array_almost_equal(subx, np.asarray([1, 3], dtype=float))
         np.testing.assert_array_almost_equal(suby, np.asarray([1, 3], dtype=float))
         np.testing.assert_array_almost_equal(subs, np.asarray([1, 3], dtype=float))
 
-        subx, suby, subs = self.analysis._subset_data("curve2", series, xdata, ydata, sigma)
+        subx, suby, subs = self.analysis._subset_data("curve2", d_index, xdata, ydata, sigma)
         np.testing.assert_array_almost_equal(subx, np.asarray([2], dtype=float))
         np.testing.assert_array_almost_equal(suby, np.asarray([2], dtype=float))
         np.testing.assert_array_almost_equal(subs, np.asarray([2], dtype=float))
 
-        subx, suby, subs = self.analysis._subset_data("curve3", series, xdata, ydata, sigma)
+        subx, suby, subs = self.analysis._subset_data("curve3", d_index, xdata, ydata, sigma)
         np.testing.assert_array_almost_equal(subx, np.asarray([4, 5], dtype=float))
         np.testing.assert_array_almost_equal(suby, np.asarray([4, 5], dtype=float))
         np.testing.assert_array_almost_equal(subs, np.asarray([4, 5], dtype=float))
@@ -205,6 +233,12 @@ def test_formatting_options(self):
         }
         self.assertDictEqual(formatted_options, ref_options)
 
+        test_invalid_options = {
+            "p0": {"invalid_key1": 0, "invalid_key2": 2, "invalid_key3": 3, "invalid:_key4": 4}
+        }
+        with self.assertRaises(AnalysisError):
+            self.analysis._format_fit_options(**test_invalid_options)
+
 
 class TestCurveAnalysisIntegration(QiskitTestCase):
     """Integration test for curve fit analysis through entire analysis.run function."""
@@ -238,12 +272,12 @@ def test_run_single_curve_analysis(self):
         )
         results, _ = analysis._run_analysis(
             test_data,
-            p0=[ref_p0, ref_p1, ref_p2, ref_p3],
+            p0={"p0": ref_p0, "p1": ref_p1, "p2": ref_p2, "p3": ref_p3},
             curve_fitter=multi_curve_fit,
             data_processor=probability(outcome="1"),
             x_key="xval",
             plot=False,
-            ax=None,
+            axis=None,
             xlabel="x value",
             ylabel="y value",
             fit_reports=None,
@@ -285,23 +319,23 @@ def test_run_single_curve_fail(self):
         # Try to fit with infeasible parameter boundary. This should fail.
         results, _ = analysis._run_analysis(
             test_data,
-            p0=[ref_p0, ref_p1, ref_p2, ref_p3],
-            bounds=([-10, 0], [-10, 0], [-10, 0], [-10, 0]),
+            p0={"p0": ref_p0, "p1": ref_p1, "p2": ref_p2, "p3": ref_p3},
+            bounds={"p0": [-10, 0], "p1": [-10, 0], "p2": [-10, 0], "p3": [-10, 0]},
             curve_fitter=multi_curve_fit,
             data_processor=probability(outcome="1"),
             x_key="xval",
             plot=False,
-            ax=None,
+            axis=None,
             xlabel="x value",
             ylabel="y value",
             fit_reports=None,
-            return_data_points=False,
+            return_data_points=True,
         )
         result = results[0]
 
         self.assertFalse(result["success"])
 
-        ref_result_keys = ["error_message", "success"]
+        ref_result_keys = ["error_message", "success", "raw_data"]
         self.assertSetEqual(set(result.keys()), set(ref_result_keys))
 
     def test_run_two_curves_with_same_fitfunc(self):
@@ -350,12 +384,12 @@ def test_run_two_curves_with_same_fitfunc(self):
 
         results, _ = analysis._run_analysis(
             test_data0,
-            p0=[ref_p0, ref_p1, ref_p2, ref_p3, ref_p4],
+            p0={"p0": ref_p0, "p1": ref_p1, "p2": ref_p2, "p3": ref_p3, "p4": ref_p4},
             curve_fitter=multi_curve_fit,
             data_processor=probability(outcome="1"),
             x_key="xval",
             plot=False,
-            ax=None,
+            axis=None,
             xlabel="x value",
             ylabel="y value",
             fit_reports=None,
@@ -413,12 +447,12 @@ def test_run_two_curves_with_two_fitfuncs(self):
 
         results, _ = analysis._run_analysis(
             test_data0,
-            p0=[ref_p0, ref_p1, ref_p2, ref_p3],
+            p0={"p0": ref_p0, "p1": ref_p1, "p2": ref_p2, "p3": ref_p3},
             curve_fitter=multi_curve_fit,
             data_processor=probability(outcome="1"),
             x_key="xval",
             plot=False,
-            ax=None,
+            axis=None,
             xlabel="x value",
             ylabel="y value",
             fit_reports=None,

From 00286694b555b32cc8065bb6048df767b151ba17 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 4 Jun 2021 23:56:50 +0900
Subject: [PATCH 57/74] update spectroscopy

---
 .../characterization/qubit_spectroscopy.py    | 343 ++++++------------
 test/test_qubit_spectroscopy.py               |  29 +-
 2 files changed, 120 insertions(+), 252 deletions(-)

diff --git a/qiskit_experiments/characterization/qubit_spectroscopy.py b/qiskit_experiments/characterization/qubit_spectroscopy.py
index 9502a16586..18a6a4f1fe 100644
--- a/qiskit_experiments/characterization/qubit_spectroscopy.py
+++ b/qiskit_experiments/characterization/qubit_spectroscopy.py
@@ -12,27 +12,30 @@
 
 """Spectroscopy experiment class."""
 
-from typing import List, Optional, Tuple, Union
-import numpy as np
+from typing import List, Dict, Any, Tuple, Union, Optional
 
+import numpy as np
+import qiskit.pulse as pulse
 from qiskit import QuantumCircuit
 from qiskit.circuit import Gate, Parameter
 from qiskit.exceptions import QiskitError
 from qiskit.providers import Backend
-import qiskit.pulse as pulse
-from qiskit.qobj.utils import MeasLevel
 from qiskit.providers.options import Options
+from qiskit.qobj.utils import MeasLevel
 
-from qiskit_experiments.analysis.curve_fitting import curve_fit
-from qiskit_experiments.base_analysis import BaseAnalysis
+from qiskit_experiments.analysis import (
+    CurveAnalysis,
+    CurveAnalysisResult,
+    SeriesDef,
+    fit_function,
+    get_opt_value,
+    get_opt_error,
+)
 from qiskit_experiments.base_experiment import BaseExperiment
-from qiskit_experiments import AnalysisResult
-from qiskit_experiments import ExperimentData
 from qiskit_experiments.data_processing.processor_library import get_to_signal_processor
-from qiskit_experiments.analysis import plotting
 
 
-class SpectroscopyAnalysis(BaseAnalysis):
+class SpectroscopyAnalysis(CurveAnalysis):
     """A class to analyze a spectroscopy experiment.
 
     Analyze a spectroscopy experiment by fitting the data to a Gaussian function.
@@ -45,203 +48,62 @@ class SpectroscopyAnalysis(BaseAnalysis):
     Here, :math:`x` is the frequency. The analysis loops over the initial guesses
     of the width parameter :math:`sigma`. The measured y-data will be rescaled to
     the interval (0,1).
-
-    Analysis options:
-
-        * amp_guess (float): The amplitude of the Gaussian function, i.e. :math:`a`. If not
-            provided, this will default to -1 or 1 depending on the measured values.
-        * sigma_guesses (list of float): The guesses for the standard deviation of the Gaussian
-            distribution. If it is not given this will default to an array of ten  points linearly
-            spaced between zero and width of the x-data.
-        * freq_guess (float): A guess for the frequency of the peak :math:`x0`. If not provided
-            this guess will default to the location of the highest or lowest point of the y-data
-            depending on the y-data.
-        * offset_guess (float): A guess for the magnitude :math:`b` offset of the fit function. If
-            not provided, the initial guess defaults to the median of the y-data.
-        * amp_bounds (tuple of two floats): Bounds on the amplitude of the Gaussian function as a
-            tuple of two floats. The default bounds are (-1, 1).
-        * sigma_bounds (tuple of two floats): Bounds on the standard deviation of the Gaussian
-            function as a tuple of two floats. The default values are (0, frequency range).
-        * freq_bounds (tuple of two floats): Bounds on the center frequency as a tuple of two
-            floats. The default values are (min(frequencies) - df, max(frequencies) - df).
-        * offset_bounds (tuple of two floats): Bounds on the offset of the Gaussian function as a
-            tuple of two floats. The default values are (-2, 2).
     """
 
-    @classmethod
-    def _default_options(cls):
-        return Options(
-            meas_level=MeasLevel.KERNELED,
-            meas_return="single",
-            amp_guess=None,
-            sigma_guesses=None,
-            freq_guess=None,
-            offset_guess=None,
-            amp_bounds=(-1, 1),
-            sigma_bounds=None,
-            freq_bounds=None,
-            offset_bounds=(-2, 2),
-        )
-
-    # pylint: disable=arguments-differ, unused-argument
-    def _run_analysis(
-        self,
-        experiment_data: ExperimentData,
-        data_processor: Optional[callable] = None,
-        amp_guess: Optional[float] = None,
-        sigma_guesses: Optional[List[float]] = None,
-        freq_guess: Optional[float] = None,
-        offset_guess: Optional[float] = None,
-        amp_bounds: Tuple[float, float] = (-1, 1),
-        sigma_bounds: Optional[Tuple[float, float]] = None,
-        freq_bounds: Optional[Tuple[float, float]] = None,
-        offset_bounds: Tuple[float, float] = (-2, 2),
-        plot: bool = True,
-        ax: Optional["AxesSubplot"] = None,
-        **kwargs,
-    ) -> Tuple[AnalysisResult, None]:
-        """Analyze the given data by fitting it to a Gaussian.
-
-        Args:
-            experiment_data: The experiment data to analyze.
-            data_processor: The data processor with which to process the data. If no data
-                processor is given a singular value decomposition of the IQ data will be
-                used for Kerneled data and a conversion from counts to probabilities will
-                be done if Discriminated data was measured.
-            amp_guess: The amplitude of the Gaussian function, i.e. :math:`a`. If not
-                provided, this will default to -1 or 1 depending on the measured values.
-            sigma_guesses: The guesses for the standard deviation of the Gaussian distribution.
-                If it is not given this will default to an array of ten
-                points linearly spaced between zero and width of the x-data.
-            freq_guess: A guess for the frequency of the peak :math:`x0`. If not provided
-                this guess will default to the location of the highest or lowest point of
-                the y-data depending on the y-data.
-            offset_guess: A guess for the magnitude :math:`b` offset of the fit function.
-                If not provided, the initial guess defaults to the median of the y-data.
-            amp_bounds: Bounds on the amplitude of the Gaussian function as a tuple of
-                two floats. The default bounds are (-1, 1).
-            sigma_bounds: Bounds on the standard deviation of the Gaussian function as a tuple
-                of two floats. The default values are (0, frequency range).
-            freq_bounds: Bounds on the center frequency as a tuple of two floats. The default
-                values are (min(frequencies) - df, max(frequencies) - df).
-            offset_bounds: Bounds on the offset of the Gaussian function as a tuple of two floats.
-                The default values are (-2, 2).
-            plot: If True generate a plot of fitted data.
-            ax: Optional, matplotlib axis to add the plot to.
-            kwargs: Trailing unused function parameters.
-
-        Returns:
-            The analysis result with the estimated peak frequency and the plots if a plot was
-            generated.
-
-        Raises:
-            QiskitError:
-                - If the measurement level is not supported.
-                - If the fit fails.
-        """
-
-        meas_level = experiment_data.data(0)["metadata"]["meas_level"]
-        meas_return = experiment_data.data(0)["metadata"]["meas_return"]
-
-        # Pick a data processor.
-        if data_processor is None:
-            data_processor = get_to_signal_processor(meas_level=meas_level, meas_return=meas_return)
-            data_processor.train(experiment_data.data())
-
-        y_sigmas = np.array([data_processor(datum) for datum in experiment_data.data()])
-        min_y, max_y = min(y_sigmas[:, 0]), max(y_sigmas[:, 0])
-        ydata = (y_sigmas[:, 0] - min_y) / (max_y - min_y)
-
-        # Sigmas may be None and fitting will not work if any sigmas are exactly 0.
-        try:
-            sigmas = y_sigmas[:, 1] / (max_y - min_y)
-            if any(sigmas == 0.0):
-                sigmas = None
-
-        except TypeError:
-            sigmas = None
-
-        xdata = np.array([datum["metadata"]["xval"] for datum in experiment_data.data()])
-
-        # Set the default options that depend on the y-data.
-        if not offset_guess:
-            offset_guess = np.median(ydata)
-        if not amp_guess:
-            amp_guess = -1 if offset_guess > 0.5 else 1
-        if not freq_guess:
-            peak_idx = np.argmin(ydata) if offset_guess > 0.5 else np.argmax(ydata)
-            freq_guess = xdata[peak_idx]
-        if not sigma_guesses:
-            sigma_guesses = np.linspace(1e-6, abs(xdata[-1] - xdata[0]), 20)
-        if sigma_bounds is None:
-            sigma_bounds = (0, abs(xdata[-1] - xdata[0]))
-        if freq_bounds is None:
-            dx = xdata[1] - xdata[0]
-            freq_bounds = (xdata[0] - dx, xdata[-1] + dx)
-
-        # Perform fit
-        best_fit = None
-        bounds = {"a": amp_bounds, "sigma": sigma_bounds, "freq": freq_bounds, "b": offset_bounds}
-
-        def fit_fun(x, a, sigma, freq, b):
-            return a * np.exp(-((x - freq) ** 2) / (2 * sigma ** 2)) + b
-
-        for sigma_guess in sigma_guesses:
-            init = {"a": amp_guess, "sigma": sigma_guess, "freq": freq_guess, "b": offset_guess}
-            try:
-                fit_result = curve_fit(fit_fun, xdata, ydata, init, sigmas, bounds)
-
-                if not best_fit:
-                    best_fit = fit_result
-                else:
-                    if fit_result["reduced_chisq"] < best_fit["reduced_chisq"]:
-                        best_fit = fit_result
-
-            except RuntimeError:
-                pass
-
-        if best_fit is None:
-            raise QiskitError("Could not find a fit to the spectroscopy data.")
-
-        best_fit["value"] = best_fit["popt"][2]
-        best_fit["stderr"] = (best_fit["popt_err"][2],)
-        best_fit["unit"] = experiment_data.data(0)["metadata"].get("unit", "Hz")
-        best_fit["label"] = "Spectroscopy"
-        best_fit["xdata"] = xdata
-        best_fit["ydata"] = ydata
-        best_fit["ydata_err"] = sigmas
-        best_fit["quality"] = self._fit_quality(
-            best_fit["popt"][0],
-            best_fit["popt"][1],
-            best_fit["popt"][2],
-            best_fit["popt"][3],
-            best_fit["reduced_chisq"],
-            xdata,
-            ydata,
-            best_fit["popt_err"][1],
+    __series__ = [
+        SeriesDef(
+            fit_func=lambda x, a, sigma, freq, b: fit_function.gaussian(
+                x, amp=a, sigma=sigma, x0=freq, baseline=b
+            ),
+            plot_color="blue",
         )
+    ]
 
-        if plot and plotting.HAS_MATPLOTLIB:
-            ax = plotting.plot_curve_fit(fit_fun, best_fit, ax=ax)
-            ax = plotting.plot_scatter(xdata, ydata, ax=ax)
-            self._format_plot(ax, best_fit)
-            figures = [ax.get_figure()]
-        else:
-            figures = None
-
-        return [best_fit], figures
-
-    @staticmethod
-    def _fit_quality(
-        fit_amp: float,
-        fit_sigma: float,
-        fit_freq: float,
-        fit_offset: float,
-        reduced_chisq: float,
-        xdata: np.array,
-        ydata: np.array,
-        fit_sigma_err: Optional[float] = None,
-    ) -> str:
+    @classmethod
+    def _default_options(cls):
+        default_options = super()._default_options()
+        default_options.p0 = {"a": None, "sigma": None, "freq": None, "b": None}
+        default_options.bounds = {"a": None, "sigma": None, "freq": None, "b": None}
+        default_options.fit_reports = {"freq": "freq"}
+
+        return default_options
+
+    def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+        """Fitter options."""
+        user_p0 = self._get_option("p0")
+        user_bounds = self._get_option("bounds")
+
+        b_guess = np.median(self._y_values)
+        peak_idx = np.argmax(np.abs(self._y_values - b_guess))
+        f_guess = self._x_values[peak_idx]
+        a_guess = self._y_values[peak_idx] - b_guess
+
+        # calculate sigma from FWHM
+        halfmax = self._x_values[np.abs(self._y_values - b_guess) > np.abs(a_guess / 2)]
+        fullwidth = max(halfmax) - min(halfmax)
+        s_guess = fullwidth / np.sqrt(8 * np.log(2))
+
+        max_abs_y = np.max(np.abs(self._y_values))
+
+        fit_option = {
+            "p0": {
+                "a": user_p0["a"] or a_guess,
+                "sigma": user_p0["sigma"] or s_guess,
+                "freq": user_p0["freq"] or f_guess,
+                "b": user_p0["b"] or b_guess,
+            },
+            "bounds": {
+                "a": user_bounds["a"] or (-2 * max_abs_y, 2 * max_abs_y),
+                "sigma": user_bounds["sigma"] or (0., max(self._x_values) - min(self._x_values)),
+                "freq": user_bounds["freq"] or (min(self._x_values), max(self._x_values)),
+                "b": user_bounds["b"] or (-max_abs_y, max_abs_y),
+            },
+        }
+        fit_option.update(options)
+
+        return fit_option
+
+    def _post_processing(self, analysis_result: CurveAnalysisResult) -> CurveAnalysisResult:
         """Algorithmic criteria for whether the fit is good or bad.
 
         A good fit has:
@@ -253,47 +115,35 @@ def _fit_quality(
               square root of the median y-value less the fit offset, greater than a
               threshold of two, and
             - a standard error on the sigma of the Gaussian that is smaller than the sigma.
-
-        Args:
-            fit_amp: Amplitude of the fitted peak.
-            fit_sigma: Standard deviation of the fitted Gaussian.
-            fit_freq: Frequency of the fitted peak.
-            fit_offset: Offset of the fit.
-            reduced_chisq: Reduced chi-squared of the fit.
-            xdata: x-values, i.e. the frequencies.
-            ydata: y-values, i.e. the measured signal.
-            fit_sigma_err: Errors on the standard deviation of the fit.
-
-        Returns:
-            computer_bad or computer_good if the fit passes or fails the criteria, respectively.
         """
-        min_freq = xdata[0]
-        max_freq = xdata[-1]
-        freq_increment = xdata[1] - xdata[0]
+        max_freq = np.max(self._x_values)
+        min_freq = np.min(self._x_values)
+        freq_increment = np.mean(np.diff(self._x_values))
 
-        snr = abs(fit_amp) / np.sqrt(abs(np.median(ydata) - fit_offset))
+        fit_a = get_opt_value(analysis_result, "a")
+        fit_b = get_opt_value(analysis_result, "b")
+        fit_freq = get_opt_value(analysis_result, "freq")
+        fit_sigma = get_opt_value(analysis_result, "sigma")
+        fit_sigma_err = get_opt_error(analysis_result, "sigma")
+
+        snr = abs(fit_a) / np.sqrt(abs(np.median(self._y_values) - fit_b))
         fit_width_ratio = fit_sigma / (max_freq - min_freq)
 
-        # pylint: disable=too-many-boolean-expressions
-        if (
-            min_freq <= fit_freq <= max_freq
-            and 1.5 * freq_increment < fit_sigma
-            and fit_width_ratio < 0.25
-            and reduced_chisq < 3
-            and (fit_sigma_err is None or (fit_sigma_err < fit_sigma))
-            and snr > 2
-        ):
-            return "computer_good"
+        criteria = [
+            min_freq <= fit_freq <= max_freq,
+            1.5 * freq_increment < fit_sigma,
+            fit_width_ratio < 0.25,
+            analysis_result["reduced_chisq"] < 3,
+            (fit_sigma_err is None or fit_sigma_err < fit_sigma),
+            snr > 2
+        ]
+
+        if all(criteria):
+            analysis_result["quality"] = "computer_good"
         else:
-            return "computer_bad"
+            analysis_result["quality"] = "computer_bad"
 
-    @classmethod
-    def _format_plot(cls, ax, analysis_result):
-        """Format curve fit plot."""
-        ax.tick_params(labelsize=14)
-        ax.set_xlabel(f"Frequency ({analysis_result['unit']})", fontsize=16)
-        ax.set_ylabel("Signal [arb. unit.]", fontsize=16)
-        ax.grid(True)
+        return analysis_result
 
 
 class QubitSpectroscopy(BaseExperiment):
@@ -372,10 +222,13 @@ def __init__(
         if unit not in self.__units__:
             raise QiskitError(f"Unsupported unit: {unit}.")
 
+        super().__init__([qubit])
+
         self._frequencies = [freq * self.__units__[unit] for freq in frequencies]
         self._absolute = absolute
-
-        super().__init__([qubit])
+        self.set_analysis_options(
+            xlabel=f"Frequency [{unit}]", ylabel="Signal [arb. unit]"
+        )
 
     def circuits(self, backend: Optional[Backend] = None):
         """Create the circuit for the spectroscopy experiment.
@@ -394,6 +247,14 @@ def circuits(self, backend: Optional[Backend] = None):
                 - If relative frequencies are used but no backend was given.
                 - If the backend configuration does not define dt.
         """
+        # TODO this is temporarily logic. Need update of circuit data and processor logic.
+        self.set_analysis_options(
+            data_processor=get_to_signal_processor(
+                meas_level=self.run_options.meas_level,
+                meas_return=self.run_options.meas_return,
+            )
+        )
+
         if not backend and not self._absolute:
             raise QiskitError("Cannot run spectroscopy relative to qubit without a backend.")
 
@@ -438,8 +299,6 @@ def circuits(self, backend: Optional[Backend] = None):
                 "sigma": self.experiment_options.sigma,
                 "width": self.experiment_options.width,
                 "schedule": str(sched),
-                "meas_level": self.run_options.meas_level,
-                "meas_return": self.run_options.meas_return,
             }
 
             if not self._absolute:
diff --git a/test/test_qubit_spectroscopy.py b/test/test_qubit_spectroscopy.py
index 73e1c2ee45..09b6a04a6f 100644
--- a/test/test_qubit_spectroscopy.py
+++ b/test/test_qubit_spectroscopy.py
@@ -20,6 +20,7 @@
 
 from qiskit_experiments.characterization.qubit_spectroscopy import QubitSpectroscopy
 from qiskit_experiments.test.mock_iq_backend import TestJob, IQTestBackend
+from qiskit_experiments.analysis import get_opt_value
 
 
 class SpectroscopyBackend(IQTestBackend):
@@ -102,7 +103,9 @@ def test_spectroscopy_end2end_classified(self):
         spec.set_run_options(meas_level=MeasLevel.CLASSIFIED)
         result = spec.run(backend).analysis_result(0)
 
-        self.assertTrue(abs(result["value"]) < 1e6)
+        value = get_opt_value(result, "freq")
+
+        self.assertTrue(abs(value) < 1e6)
         self.assertTrue(result["success"])
         self.assertEqual(result["quality"], "computer_good")
 
@@ -113,8 +116,10 @@ def test_spectroscopy_end2end_classified(self):
         spec.set_run_options(meas_level=MeasLevel.CLASSIFIED)
         result = spec.run(backend).analysis_result(0)
 
-        self.assertTrue(result["value"] < 5.1e6)
-        self.assertTrue(result["value"] > 4.9e6)
+        value = get_opt_value(result, "freq")
+
+        self.assertTrue(value < 5.1e6)
+        self.assertTrue(value > 4.9e6)
         self.assertEqual(result["quality"], "computer_good")
 
     def test_spectroscopy_end2end_kerneled(self):
@@ -125,7 +130,9 @@ def test_spectroscopy_end2end_kerneled(self):
         spec = QubitSpectroscopy(3, np.linspace(-10.0, 10.0, 21), unit="MHz")
         result = spec.run(backend).analysis_result(0)
 
-        self.assertTrue(abs(result["value"]) < 1e6)
+        value = get_opt_value(result, "freq")
+
+        self.assertTrue(abs(value) < 1e6)
         self.assertTrue(result["success"])
         self.assertEqual(result["quality"], "computer_good")
 
@@ -135,15 +142,17 @@ def test_spectroscopy_end2end_kerneled(self):
         spec = QubitSpectroscopy(3, np.linspace(-10.0, 10.0, 21), unit="MHz")
         result = spec.run(backend).analysis_result(0)
 
-        self.assertTrue(result["value"] < 5.1e6)
-        self.assertTrue(result["value"] > 4.9e6)
+        value = get_opt_value(result, "freq")
+
+        self.assertTrue(value < 5.1e6)
+        self.assertTrue(value > 4.9e6)
         self.assertEqual(result["quality"], "computer_good")
-        self.assertTrue(result["ydata_err"] is not None)
 
         spec.set_run_options(meas_return="avg")
         result = spec.run(backend).analysis_result(0)
 
-        self.assertTrue(result["value"] < 5.1e6)
-        self.assertTrue(result["value"] > 4.9e6)
+        value = get_opt_value(result, "freq")
+
+        self.assertTrue(value < 5.1e6)
+        self.assertTrue(value > 4.9e6)
         self.assertEqual(result["quality"], "computer_good")
-        self.assertTrue(result["ydata_err"] is None)

From f9cb139ce40a3232a4d5e8718f16ebef8c0c41ef Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Sat, 5 Jun 2021 00:30:49 +0900
Subject: [PATCH 58/74] black & lint

---
 qiskit_experiments/analysis/curve_analysis.py | 30 ++++++++++++-------
 qiskit_experiments/analysis/utils.py          | 16 +++++-----
 .../characterization/qubit_spectroscopy.py    | 10 +++----
 .../interleaved_rb_analysis.py                | 15 ++++++----
 .../randomized_benchmarking/rb_analysis.py    | 18 +++++------
 test/analysis/test_curve_fit.py               |  1 +
 6 files changed, 48 insertions(+), 42 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 9ff6225e1b..a96509235d 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -181,12 +181,15 @@ class AnalysisExample(CurveAnalysis):
     #: List[SeriesDef]: List of mapping representing a data series
     __series__ = None
 
-    def __new__(cls):
+    def __new__(cls) -> "CurveAnalysis":
         """Parse series data if all fit functions have the same argument.
 
         Raises:
             AnalysisError:
                 - When fit functions have different argument.
+
+        Returns:
+            CurveAnalysis instance with validated series definitions.
         """
         obj = object.__new__(cls)
 
@@ -222,7 +225,7 @@ def __init__(self):
         self._num_qubits = None
 
         # Add expected options to instance variable so that every method can access to.
-        for key in self._default_options().__dict__.keys():
+        for key in self._default_options().__dict__:
             setattr(self, f"_{key}", None)
 
     @classmethod
@@ -459,7 +462,7 @@ def _post_processing(self, analysis_result: CurveAnalysisResult) -> CurveAnalysi
         return analysis_result
 
     def _extract_curves(
-            self, experiment_data: ExperimentData, data_processor: Union[Callable, DataProcessor]
+        self, experiment_data: ExperimentData, data_processor: Union[Callable, DataProcessor]
     ):
         """Extract curve data from experiment data.
 
@@ -482,6 +485,7 @@ def _extract_curves(
             DataProcessorError:
                 - When __x_key__ is not defined in the circuit metadata.
         """
+
         def _is_target_series(datum, **filters):
             try:
                 return all(datum["metadata"][key] == val for key, val in filters.items())
@@ -571,12 +575,12 @@ def _dictionarize(parameter_name):
         return fitter_options
 
     def _subset_data(
-            self,
-            name: str,
-            data_index: np.ndarray,
-            x_values: np.ndarray,
-            y_values: np.ndarray,
-            y_sigmas: np.ndarray,
+        self,
+        name: str,
+        data_index: np.ndarray,
+        x_values: np.ndarray,
+        y_values: np.ndarray,
+        y_sigmas: np.ndarray,
     ) -> Tuple[np.ndarray, ...]:
         """A helper method to extract reduced set of data.
 
@@ -631,14 +635,18 @@ def _get_option(self, arg_name: str) -> Any:
 
         Return:
             Arbitrary object specified by the option name.
+
+        Raises:
+            AnalysisError:
+                - When `arg_name` is not found in the analysis options.
         """
         try:
             return getattr(self, f"_{arg_name}")
-        except AttributeError:
+        except AttributeError as ex:
             raise AnalysisError(
                 f"The argument {arg_name} is selected but not defined. "
                 "This key-value pair should be defined in the analysis option."
-            )
+            ) from ex
 
     def _run_analysis(
         self, experiment_data: ExperimentData, **options
diff --git a/qiskit_experiments/analysis/utils.py b/qiskit_experiments/analysis/utils.py
index 7686d872f3..09837306af 100644
--- a/qiskit_experiments/analysis/utils.py
+++ b/qiskit_experiments/analysis/utils.py
@@ -35,13 +35,13 @@ def get_opt_value(analysis_result: AnalysisResult, param_name: str) -> float:
     try:
         index = analysis_result["popt_keys"].index(param_name)
         return analysis_result["popt"][index]
-    except KeyError:
+    except KeyError as ex:
         raise KeyError(
             "Input analysis result has not fit parameter information. "
             "Please confirm if the fit is successfully completed."
-        )
-    except ValueError:
-        raise ValueError(f"Parameter {param_name} is not defined.")
+        ) from ex
+    except ValueError as ex:
+        raise ValueError(f"Parameter {param_name} is not defined.") from ex
 
 
 def get_opt_error(analysis_result: AnalysisResult, param_name: str) -> float:
@@ -63,10 +63,10 @@ def get_opt_error(analysis_result: AnalysisResult, param_name: str) -> float:
     try:
         index = analysis_result["popt_keys"].index(param_name)
         return analysis_result["popt_err"][index]
-    except KeyError:
+    except KeyError as ex:
         raise KeyError(
             "Input analysis result has not fit parameter information. "
             "Please confirm if the fit is successfully completed."
-        )
-    except ValueError:
-        raise ValueError(f"Parameter {param_name} is not defined.")
+        ) from ex
+    except ValueError as ex:
+        raise ValueError(f"Parameter {param_name} is not defined.") from ex
diff --git a/qiskit_experiments/characterization/qubit_spectroscopy.py b/qiskit_experiments/characterization/qubit_spectroscopy.py
index 18a6a4f1fe..ab36bb033b 100644
--- a/qiskit_experiments/characterization/qubit_spectroscopy.py
+++ b/qiskit_experiments/characterization/qubit_spectroscopy.py
@@ -12,7 +12,7 @@
 
 """Spectroscopy experiment class."""
 
-from typing import List, Dict, Any, Tuple, Union, Optional
+from typing import List, Dict, Any, Union, Optional
 
 import numpy as np
 import qiskit.pulse as pulse
@@ -94,7 +94,7 @@ def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]
             },
             "bounds": {
                 "a": user_bounds["a"] or (-2 * max_abs_y, 2 * max_abs_y),
-                "sigma": user_bounds["sigma"] or (0., max(self._x_values) - min(self._x_values)),
+                "sigma": user_bounds["sigma"] or (0.0, max(self._x_values) - min(self._x_values)),
                 "freq": user_bounds["freq"] or (min(self._x_values), max(self._x_values)),
                 "b": user_bounds["b"] or (-max_abs_y, max_abs_y),
             },
@@ -135,7 +135,7 @@ def _post_processing(self, analysis_result: CurveAnalysisResult) -> CurveAnalysi
             fit_width_ratio < 0.25,
             analysis_result["reduced_chisq"] < 3,
             (fit_sigma_err is None or fit_sigma_err < fit_sigma),
-            snr > 2
+            snr > 2,
         ]
 
         if all(criteria):
@@ -226,9 +226,7 @@ def __init__(
 
         self._frequencies = [freq * self.__units__[unit] for freq in frequencies]
         self._absolute = absolute
-        self.set_analysis_options(
-            xlabel=f"Frequency [{unit}]", ylabel="Signal [arb. unit]"
-        )
+        self.set_analysis_options(xlabel=f"Frequency [{unit}]", ylabel="Signal [arb. unit]")
 
     def circuits(self, backend: Optional[Backend] = None):
         """Create the circuit for the spectroscopy experiment.
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index 6ad234aadf..43ff588ee9 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -68,7 +68,10 @@ def _default_options(cls):
         default_options = super()._default_options()
         default_options.p0 = {"a": None, "alpha": None, "alpha_c": None, "b": None}
         default_options.bounds = {
-            "a": (0., 1.), "alpha": (0., 1.), "alpha_c": (0., 1.), "b": (0., 1.)
+            "a": (0.0, 1.0),
+            "alpha": (0.0, 1.0),
+            "alpha_c": (0.0, 1.0),
+            "b": (0.0, 1.0),
         }
         default_options.fit_reports = {"alpha": "\u03B1", "alpha_c": "\u03B1$_c$", "EPC": "EPC"}
 
@@ -105,11 +108,11 @@ def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]
                 "b": user_p0["b"] or np.mean([p0_std["b"], p0_int["b"]]),
             },
             "bounds": {
-                "a": user_bounds["a"] or (0., 1.),
-                "alpha": user_bounds["alpha"] or (0., 1.),
-                "alpha_c": user_bounds["alpha_c"] or (0., 1.),
-                "b": user_bounds["b"] or (0., 1.),
-            }
+                "a": user_bounds["a"] or (0.0, 1.0),
+                "alpha": user_bounds["alpha"] or (0.0, 1.0),
+                "alpha_c": user_bounds["alpha_c"] or (0.0, 1.0),
+                "b": user_bounds["b"] or (0.0, 1.0),
+            },
         }
         fit_option.update(options)
 
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index c46987d0d5..05ebf8bbd4 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -44,7 +44,7 @@ class RBAnalysis(CurveAnalysis):
     def _default_options(cls):
         default_options = super()._default_options()
         default_options.p0 = {"a": None, "alpha": None, "b": None}
-        default_options.bounds = {"a": (0., 1.), "alpha": (0., 1.), "b": (0., 1.)}
+        default_options.bounds = {"a": (0.0, 1.0), "alpha": (0.0, 1.0), "b": (0.0, 1.0)}
         default_options.xlabel = "Clifford Length"
         default_options.ylabel = "P(0)"
         default_options.fit_reports = {"alpha": "\u03B1", "EPC": "EPC"}
@@ -56,21 +56,17 @@ def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]
         user_p0 = self._get_option("p0")
         user_bounds = self._get_option("bounds")
 
-        initial_guess = self._initial_guess(
-            self._x_values,
-            self._y_values,
-            self._num_qubits
-        )
+        initial_guess = self._initial_guess(self._x_values, self._y_values, self._num_qubits)
         fit_option = {
             "p0": {
                 "a": user_p0["a"] or initial_guess["a"],
                 "alpha": user_p0["alpha"] or initial_guess["alpha"],
-                "b": user_p0["b"] or initial_guess["b"]
+                "b": user_p0["b"] or initial_guess["b"],
             },
             "bounds": {
-                "a": user_bounds["a"] or (0., 1.),
-                "alpha": user_bounds["alpha"] or (0., 1.),
-                "b": user_bounds["b"] or (0., 1.)
+                "a": user_bounds["a"] or (0.0, 1.0),
+                "alpha": user_bounds["alpha"] or (0.0, 1.0),
+                "b": user_bounds["b"] or (0.0, 1.0),
             },
         }
         fit_option.update(options)
@@ -104,7 +100,7 @@ def _pre_processing(self) -> Tuple[np.ndarray, ...]:
             xdata=self._x_values,
             ydata=self._y_values,
             sigma=self._y_sigmas,
-            method="sample"
+            method="sample",
         )
 
     def _post_processing(self, analysis_result: CurveAnalysisResult) -> CurveAnalysisResult:
diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index 5999598fac..c3c2cbf473 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -63,6 +63,7 @@ def create_new_analysis(series: List[SeriesDef]) -> CurveAnalysis:
 
     class TestAnalysis(CurveAnalysis):
         """A mock analysis class to test."""
+
         __series__ = series
 
     return TestAnalysis()

From 8c74427a8649c31464c6b783ad97145bd2ee200a Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Sat, 5 Jun 2021 00:31:01 +0900
Subject: [PATCH 59/74] rerun rb notebook

---
 docs/tutorials/rb_example.ipynb | 160 ++++++++++++++++----------------
 1 file changed, 80 insertions(+), 80 deletions(-)

diff --git a/docs/tutorials/rb_example.ipynb b/docs/tutorials/rb_example.ipynb
index 05a2791767..49215a92b8 100644
--- a/docs/tutorials/rb_example.ipynb
+++ b/docs/tutorials/rb_example.ipynb
@@ -45,26 +45,26 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: 537fe9ea-f303-472e-9d18-d6573df5d47e\n",
+      "Experiment ID: 0c479633-2e4c-43d0-a5b2-3e5fd8f1be2b\n",
       "Status: DONE\n",
       "Circuits: 140\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- a: 0.5209730101209734 ± 0.04826312242454459\n",
-      "- alpha: 0.9976881555253619 ± 0.0003694564881635104\n",
-      "- b: 0.4631086320972164 ± 0.05062026208437564\n",
-      "- reduced_chisq: 0.15058543331574248\n",
+      "- a: 0.5057410953300154 ± 0.10138262700893501\n",
+      "- alpha: 0.9984200402977647 ± 0.0004323251144779414\n",
+      "- b: 0.48151217431017457 ± 0.10256902101118483\n",
+      "- reduced_chisq: 0.15614332846029255\n",
       "- dof: 11\n",
       "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.0011559222373190292\n",
-      "- EPC_err: 0.000185156296643094\n",
+      "- EPC: 0.0007899798511176725\n",
+      "- EPC_err: 0.00021650462582311876\n",
       "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -106,26 +106,26 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: f52de39b-2ea1-40ae-ba97-791bf6c9c64c\n",
+      "Experiment ID: 86835545-046c-4a52-9441-f50c8539a872\n",
       "Status: DONE\n",
       "Circuits: 100\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- a: 0.7036411101911089 ± 0.02037048845690317\n",
-      "- alpha: 0.9687976498434205 ± 0.0017871176594190389\n",
-      "- b: 0.2700379866337794 ± 0.007565437969050169\n",
-      "- reduced_chisq: 0.10317613856705998\n",
+      "- a: 0.7086785173869685 ± 0.019061217750847376\n",
+      "- alpha: 0.9682547761398389 ± 0.0016464974131622863\n",
+      "- b: 0.2657588864201139 ± 0.011056874144239694\n",
+      "- reduced_chisq: 0.05584519630538138\n",
       "- dof: 7\n",
       "- xrange: [1.0, 200.0]\n",
-      "- EPC: 0.023401762617434596\n",
-      "- EPC_err: 0.0013835069116661337\n",
+      "- EPC: 0.023808917895120824\n",
+      "- EPC_err: 0.001275359637052149\n",
       "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -167,29 +167,29 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: InterleavedRBExperiment\n",
-      "Experiment ID: 059ee9a2-ba48-4a4c-846d-6db23ed06a1e\n",
+      "Experiment ID: cec37591-f8db-4058-80ae-e73159463a49\n",
       "Status: DONE\n",
       "Circuits: 280\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- a: 0.4738525253656051 ± 0.01873726626626984\n",
-      "- alpha: 0.9973203789925847 ± 0.00017666121887353534\n",
-      "- alpha_c: 0.9990879219144225 ± 0.00014224738015991404\n",
-      "- b: 0.511504733853466 ± 0.019256010590676303\n",
-      "- reduced_chisq: 0.10178000905808855\n",
+      "- a: 0.46376844067308454 ± 0.037320191722696766\n",
+      "- alpha: 0.9982454199503312 ± 0.00021016356120816523\n",
+      "- alpha_c: 0.9990950045114319 ± 0.00014254329271202085\n",
+      "- b: 0.521986011394672 ± 0.03798556417377216\n",
+      "- reduced_chisq: 0.08737266054671106\n",
       "- dof: 24\n",
       "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.0004560390427887362\n",
-      "- EPC_err: 7.112369007995702e-05\n",
-      "- EPC_systematic_err: 0.00222358196462652\n",
-      "- EPC_systematic_bounds: [0, 0.002679621007415256]\n",
+      "- EPC: 0.00045249774428407497\n",
+      "- EPC_err: 7.127164635601042e-05\n",
+      "- EPC_systematic_err: 0.0013020823053846997\n",
+      "- EPC_systematic_bounds: [0, 0.0017545800496687747]\n",
       "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -231,29 +231,29 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: InterleavedRBExperiment\n",
-      "Experiment ID: 978e73a0-0de9-498c-9392-e8226a80afe4\n",
+      "Experiment ID: 3d9e4cc7-4d19-4fb2-aa03-250502c3fc5c\n",
       "Status: DONE\n",
       "Circuits: 200\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- a: 0.697932170578897 ± 0.015745483076215365\n",
-      "- alpha: 0.9663379925192656 ± 0.002160168350192063\n",
-      "- alpha_c: 0.9850194918855851 ± 0.0030258551826973647\n",
-      "- b: 0.26448283770487785 ± 0.005469945993929648\n",
-      "- reduced_chisq: 0.05902228695924168\n",
+      "- a: 0.7018166470616463 ± 0.013842937481811897\n",
+      "- alpha: 0.9674076477807713 ± 0.0019613212271226686\n",
+      "- alpha_c: 0.9839420933451414 ± 0.003139693311241397\n",
+      "- b: 0.2634578645861757 ± 0.005672249419711346\n",
+      "- reduced_chisq: 0.13222172753275133\n",
       "- dof: 16\n",
       "- xrange: [1.0, 200.0]\n",
-      "- EPC: 0.011235381085811152\n",
-      "- EPC_err: 0.0022693913870230234\n",
-      "- EPC_systematic_err: 0.03925763013529052\n",
-      "- EPC_systematic_bounds: [0, 0.05049301122110167]\n",
+      "- EPC: 0.012043429991143967\n",
+      "- EPC_err: 0.002354769983431048\n",
+      "- EPC_systematic_err: 0.03684509833769914\n",
+      "- EPC_systematic_bounds: [0, 0.048888528328843106]\n",
       "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -297,7 +297,7 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: ParallelExperiment\n",
-      "Experiment ID: 3bb98e39-1b6e-4e41-bc79-ba5098b4254f\n",
+      "Experiment ID: 93a23b0a-de1f-47ce-9cf7-ba02ad92d5df\n",
       "Status: DONE\n",
       "Component Experiments: 5\n",
       "Circuits: 140\n",
@@ -305,14 +305,14 @@
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
       "- experiment_types: ['RBExperiment', 'RBExperiment', 'RBExperiment', 'RBExperiment', 'RBExperiment']\n",
-      "- experiment_ids: ['be8f2f3b-3d53-4464-99e0-69984fbb2237', '80e43c31-faad-42f0-adec-c6a96cd760fc', 'de32fa6f-8db9-4783-ad0f-78e66fa5b66e', 'cd612ce6-c7ec-4379-87f2-1ef7a390a145', 'e4afa8b5-5e90-4688-863f-b0fb99b60c25']\n",
+      "- experiment_ids: ['a0fa8768-71cd-40a4-8438-931cdd9b9eea', '48bdf15a-3c8c-4b7f-bdff-87150897fe21', '454d15f5-0455-4d85-abc1-c46f268e0685', 'e7f28773-a077-4bfd-8445-1dd875b56ee7', '08354cff-6a8c-438f-84ee-61d1a2400716']\n",
       "- experiment_qubits: [(0,), (1,), (2,), (3,), (4,)]\n",
       "- success: True\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -324,7 +324,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -336,7 +336,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgUAAAFGCAYAAAD6uOxSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAACOY0lEQVR4nOydd3xTVfvAv0+SNl2MFtpCGS04ioIIbRVBRVAERRA3KCo4QcVXRVHBgb6O94e4UFQUB4IbXIAoIIITRUBkCBVlVqCArM60Tc7vj5OkabrpSMf5fj730+bcc0/OPUnufe4zRSmFwWAwGAwGgyXQEzAYDAaDwVA3MEKBwWAwGAwGwAgFBoPBYDAY3BihwGAwGAwGA2CEAoPBYDAYDG6MUGAwGAwGgwEAW6AnEGhatmypEhISqm28zMwsbLZwrNZqG7JacLn03+BgEAnsXMojKyuL8PDwQE+jXmPWsHow61h1zBpWnZpYw1WrVu1XSkX7tzd6oSAhIYGVK1dW23jffLOMtm37EBFRbUNWG3l54HBAq1bQtGndFQ6WLVtGnz59Aj2Neo1Zw+rBrGPVMWtYdWpiDUVke0ntxnzQiAgOhvBw2LNHb05noGdkMBgMhrqEEQoaGRYLNGkCWVmwbRvk5AR6RgaDwWCoKxihoJESFgY2G2zfDgcOgMl2bTAYDIZG71PQmAkK0oLB3r1ac9CqlW4zGAwGQ+PEaAoaOSLa6TAvT5sTMjMDPSODwWAwBAojFBgACA0Fux3S0rTmwBPCaDAYDIbGgxEKDF5sNu2EeOiQ9jVwOAI9I4PBYDDUJsanwFAEEYiI0ALBtm0QGwvNmtXdnAb1hcGDB7N79+5ae7/c3FxCQkJq7f0aKmYdq05dXMPWrVszb968QE+jTmKEAkOJ2O3a6XDPHu2EGBurNQmGo2P37t3VmiSrPDIyMmjSpEmtvV9Dxaxj1amLa5iSkhLoKdRZjPnAUCoWi3ZCzM3VWoOsrEDPyGAwGAw1Sa0LBSLSW0Tmisg/IqJEZGQFjjlJRL4VkRz3cQ+LFFVoi8ilIvKHiDjcfy+usZNoZISG6myIO3caJ0SDwWBoyARCUxABrAfuAMrNpyciTYHFQDpwivu4ccBYnz49gQ+Bd4Fu7r+zRaRHNc+90eLvhJibG+gZGQwGg6G6qXWhQCm1QCk1QSk1B6jIM+dwIAwYoZRa7z5uEjDWR1twJ7BUKfWEUmqjUuoJYJm73VBNeJwQRbRgcPCgyYRoMBgMDYn64FPQE/heKeWrVVgIxAEJPn0W+R23EOhV47NrhHgKK+3dq/Ma5OcHekaG2mDJkiX06tWLJk2a0KpVK+677z4KCgrKPCY9PZ2RI0cSFxdHWFgY5513Hps3b/bu37ZtGyJS4jZ58uQK96kK3377LcnJyYSEhNCxY0emTZtWZP93333HhRdeSJs2bRARZsyYUeX3PBpmz55NSkoKzZs3Jzw8nG7duvH222+Xe9wdd9xBSkoKISEhlFQm/pFHHil1fffu3QvAH3/8Qd++fYmNjfWu04QJE8jLy6vyeTkcDm6//XZatmxJeHg4F154IWlpaSX23b9/v/dz2L9/f5Xf21Cc+uBP3grw/4ak++zb6v6bXkKfViUNKCI3AzcDxMbGsmzZsuqaK1lZmWzdugxLfRC3qgGXC/74Q0cqVNc5Z2ZmVutnUhfIzc0lIyOj1t7P6XRW6/utW7eOgQMHctddd/Hyyy+ze/du7rzzTnJycnjiiSdKPEYpxeDBg7FYLLz77rs0a9aMqVOncs4557BixQrCw8Np3rx5ESEBYN68edx9992cd955ZGRkVKjP0bJt2zYGDhzI1Vdfzauvvsry5cu5/fbbiYiIYMiQITidTvbu3cvxxx/P5ZdfzqhRo47qs/z++++55ZZbWL9+/VHPNTQ0lLvvvpvjjz8em83GV199xQ033EB4eDgDBgwo9bjc3FyGDh3KSSedxDfffFNs7qNGjeLqq68u0nbdddchIoSGhpKRkUFeXh5Dhw6la9euNGvWjPXr13P77beTnZ3NY489Vua8y/su3nXXXXzxxRe88cYbREVFMWHCBAYOHMh3332H1Wot0veaa66hS5cu7Nq1i8zMTOx2e5nvXRq5ubn16hpTq9dEpVTANiATGFlOn0XAm35t7QEF9HS/zgOu9etzLeAobw7JycmqOlmyZKlKTVXqn38az7Zjh1IbNyq1a5dS+flVX8OlS5dWfZA6xtF+zzIzM9VNN92kmjZtqlq0aKEmTJigMjIyVFhYmNq2bVupxx05cuRop1oi48ePV926dSvSNnfuXBUSElLqe6WmpipArVmzxtvmdDpVdHS0mj59eqnv1a9fP3XuueeWOZ+S+hw6dEjddNNNKjo6WkVERKjevXurX3/9tcxx7r33XnXssccWabvhhhvUaaedppQqvo7h4eHqrbfeKnPMkli6dKmKj4+v9HHl0b17d3X//fdXqO/kyZMrNIcdO3Yoi8Wi3n333TL73XXXXd518jB37lyVlJSk7Ha7SkhIUBMmTFD79+8vdYxDhw6poKAg9c477xR5fxFRX331VZG+zz//vDr77LPVkiVLFKD27dtX7rmURnVf92uamrgmAitVCffE+vA8uweI9WuL9dlXVp89GGocq1WHLmZna1+D7OxAz6jhcP311/PNN9/w9ddf8/777zNlyhTGjBlDp06diI+PL/W4Sy65hIiIiDK3yuBwOIoloAkNDSU3N5dVq1aVegxQ5DiLxYLdbueHH34o8ZgtW7awZMkSbr755lLnUlIfpRQXXHAB//zzD/Pnz+e3336jd+/enH322WUmjVq+fDn9+/cv0jZgwABWrlxJfh22iymlWLJkCampqfTu3btax37jjTeIjIzk0ksvLbXPX3/9xVdffcVZZ53lbVu4cCHDhw9nzJgxbNiwgTfffJM5c+bw6KOPljrOqlWryM/PL/IZtGvXjhNOOIGffvrJ2/bbb78xadIkZs6ciaWxqGEDRH0wHywHJolIiFLK4/N+LrAL2ObT51zA18B4LvATtYjLL1bP5XI1qi9waCgUFMCOHdCihd4a0elXO/v372f27Nm8/fbbnHLKKQBcccUVvPXWW+WqbKdOnVpM9VoVBgwYwHPPPcc777zDsGHDSE9P57///S9AqTfdTp060b59eyZMmMD06dOJiIjgueeeIy0trdRjXn/9daKjoxkyZEipcympz9KlS1mzZg379u0jNDQUgMcee4x58+Yxa9Ys7r333hLH2rNnD/369SvSFhsbS0FBAfv376+08ORhx44dnHjiid7XTqcTh8NRZLyrr766mP9CeRw+fJg2bdrgcDiwWq289NJLnH/++Uc1x5JwOp28+eabXHPNNSWq5nv16sXq1atxOBzcdNNNPPnkk959TzzxBOPGjeO6664D4JhjjmHSpElcffXVTJkyBSkhLeqePXuwWq20bNmySHtsbCx79uhnuqysLIYNG8aLL75ImzZtipmSDNVLrQsFIhIBHOt+aQHai0g34IBSaoeI/A84VSl1jrvPe8BEYIaIPA4cD9wPPOpWgQBMAb4TkfuBz4CLgb7AGbVwSgB88skn/Puvk2bNovn8c2jTxoXIAiIjLQwcOLC2phFwPKGLBw9CRgbExUEdy3Bab/jrr79QStGzZ09vW48ePXjrrbe45JJLyjw2Li6uWrPI9e/fn6effprbbruNkSNHYrfbeeihh/j+++9LFXyDgoL45JNPuOGGG2jRogVWq5V+/fpx/vnnU/jTLaSgoIC33nqLESNGEFRKDe/S+qxatYrs7Gyio6OL9M/NzeXvv/8GqPINuTLExcWxZs0a7+tffvmF++67r4hduGnTppUet0mTJqxZs4bMzEyWLFnC2LFjSUhI4Jxzzin/4Arw1VdfsXPnTm666aYS93/44YdkZGTw+++/M27cOCZNmsT48eMB/RmsWLGCSZMmefu7XC5ycnLYs2cPb731VhEh4o8//qjQnP7zn/9wxhlnlKm5MFQfgdAUpABLfV4/6t7eBkYCrYFjPDuVUodF5FzgJWAlcBB4BnjWp89PIjIMeBz4L/A3MFQp9UuNnokbp9PFrFnHMX9+JyZN+oEXX1QEBblwuc6jX7+/GDDAhdXaeB6ZPaGLeXnanBAdDc2bG61BZfE8qQUHB3vbYmNjiYyMLPIUWhKXXHIJy5cvL7NPZiXrZI8dO5a77rqL3bt3ExkZybZt2xg/fjwdO3Ys9Zjk5GTWrFnD4cOHycvLIzo6mh49epSYZnbevHns2bOHG2+8sdTxSuvjcrmIjY3l+++/L3aM5+bre5P2tLVq1Yr09KI+yunp6dhsNlq2bEnuUSbksNlsHHvssd7XaWlpxdqOBovF4h2jW7dubNy4kSeffLLahILXXnuNXr16lfr9ateuHQAnnngiTqeTG2+8kXHjxmGz2XC5XEycOJHLL7+8yDGZmZlER0czevRorrjiCm97XFwcrVq1wul0sn///iICXXp6OmeeeSago1527tzpjbTwCJSeCJjSHF0NR0etCwVKqWVAqeV1lFIjS2hbB5RpOFM6f8GcKk7vqHjkEQsLFnSioCAIpQSlhLw8vbRLlhzLM89YKEV72aAJDtZRCfv3w5Ej0Lq1rqlgqBgdOnTAYrGwefNm2rdvD8DcuXM5ePAghw8fplmzZqUeW93mAw8iQlxcHADvv/8+7dq1IykpqdzjPHPdvHkzK1euLNH8MX36dM466yyOP/74UscprU9SUhLp6elYLJZShZSSbsg9e/bk008/LdK2ePFiUlJSCAoKOmqhoLZwuVxe342qsmvXLr744gtef/31Cr93QUEBTqcTm81GUlISmzZtKrbOGRkZ2Gw2oqKiiIqKKrIvOTmZoKAgFi9ezFVXXQVoAWrjxo306qUjyhctWlQk9PHXX3/l+uuvZ9myZRx33HFVOWVDCdQHn4I6zcGD8PTTirw8rcr014rm59uYNk0xapRQxjW8weJfdTEmRmsNTNXF8mnevDmXXHIJTz75JD179mTnzp3MmTOHuLg45s2bVyyMzJfqNh8ATJ48mfPOOw+LxcInn3zC//3f//HRRx95hY9//vmHc845h//9739cfLHOMj579mxatmxJfHw869at44477uCiiy4q5ty3Y8cOFi5cyMyZM0t9/7L69OvXj9NPP50hQ4bw1FNP0alTJ/bs2cNXX31Fv379vE+d/owePZqpU6dy5513MmrUKH788UdmzJjB+++/7+2TmZnJX3/9Begb4Y4dO1izZg1RUVFeYc0fp9PJvn37vK87derEzz//7LWTg3bULEuw8+eJJ56gR48edOzYEYfDwYIFC5g1axYvvviit8/UqVOZOnUqmzZt8rb99ddfZGZmsmvXLvLy8rwakxNPPLGIFurNN98kPDy8yNO8h1mzZhESEsJJJ51EcHAwK1euZPz48Vx22WVejdbDDz/MoEGDiI+P54orrsBms7F+/Xp++OEHnn/++RLPqVmzZtxwww3ce++9xMTE0KJFC8aOHUvXrl29vh7+AqAnP0GnTp2K+SIYqoGSQhIa01bV0JTXXlMqPNyltDigVMeOB73/e7awMJd66qnAhw4Getu5U6lNm3QIo8NR+pqakMRC0tPT1UUXXaSioqJUVFSUeuaZZ9SCBQtUXFycmjhxYqnHVXdIolJK9e3bVzVr1kyFhISoHj16qAULFhTZv3XrVgUUCdmbMmWKatu2rQoKClLt27dXDz74oHKU8OE//PDDKjIyUuXk5JT6/uX1OXLkiPrPf/6j2rRpo4KCglTbtm3V0KFD1V9//VXmeS1btkx1795dBQcHq4SEBPXKK68UGXPp0qUKHQJdZBsxYkSpY3rWoqytrONL4v7771fHHnusCgkJUZGRkapnz57qvffeK9Jn4sSJSl/WCznrrLNKfP+tW7d6+7hcLpWQkKBuueWWEt/7vffeU927d1cREREqPDxcnXjiieqJJ55Q2dnZRfotXLhQnXHGGSo0NFQ1adJEJScnq8mTJ5d5Xrm5uWrMmDEqKipKhYaGqkGDBqkdO3aU2t/zeZiQxKpBKSGJokpw+GlMpKSkqKqUtH3sMZg4UaFU6Y++Ioq77xbuuuuo36ZBkZursyC2aqVDGf21BsuWLaNPnz4BmVtNkZKSYkon10PMOladuriGtf17rCo1cU0UkVVKqWLOPcb1q4q0agVhYYWvU1KKp0YIDdVqc4MmJESnSd6926RJNhgMhrqEEQqqyGWXgdNZ+Hro0E3F+hQUwKBBtTipeoDForUEeXmwdat2RGzkSiuDwWAIOEYoqCKRkXD33YqgIO0dW5IDXVyczvpXFv5mnMZi1gkN1dvu3bBrl9EaGAwGQyAxQkE18N//Cv36rcVmy0dEAS6CgvKwWAqw2QrYtk246CL455+Sj1+7di0rV670CgJKKVauXMnatWtr7RwCidWqEx7l5mqtgctltAYGg8EQCExIYrWgGDz4V7p1W0pUVGduvx32799AixbLsdtb8emnF7NxozBoELz1FnTr5nOkUvz+++8cPnwYKHSA+eWXX2jWrBknnXRSielBGyKhodoUk5+vtQYxMTrPgcFgMBhqB6MpqAYsFguxsbF06dKG9u3DGDPGwlNPnUynTq3p1CmEuXOFXr1g71649FL44ovCY5VSOJ1O8vLy+OWXX3j33Xf55ZdfyMvLw+l0NhozggerVfsbeLQGDdnXYOTIkSXWsD/ttNO8fRISErztYWFhdOnShddee63IOHl5eUyePJnu3bsTFhZGVFQUZ599Nq+++mq1JbapCLt37+aqq66iU6dOWK1WRo4cWaHjnnjiCU4//XTCw8NLFID37dvHgAEDiIuLw263065dO2677TavIO3ho48+olu3boSFhREfH8/kyZOLjXU0OBwObr/9dlq2bEl4eDgXXnghaWmF1dwrOr/aoLy1LIlHHnmk2HewVauiVefT09MZOXIkcXFxhIWFcd555xWrQVDeOlWFl19+mQ4dOhASEkJycnKJmStBX0/PP/98RIQ5cwKSy67eY4SCauKSSy5h2LBh3tcWi4UhQ4YwcOBAIiPh3Xdh2DB9s7v5ZnjhBX2zExEiIyOxWCw4HA7S09NxOBxYLBYiIyMbjZbAn8bia9CvXz92795dZFuwYEGRPg8//DC7d+9m7dq1XHTRRYwaNYoPP/wQ0ALBgAEDeOKJJ7juuuv48ccfWbVqFWPGjOGtt94qN9VxdeJwOGjZsiX3338/PXr0qNRxl1xyCXfeeWeJ+y0WCxdffDHz5s3jzz//ZMaMGSxZsqRIfv4vv/ySq666iptvvpn169fz8ssv89xzzzF16tSqnhZ33nknH3/8Me+//z7ff/89R44cYdCgQTjdHsYVmV9F6NOnDzNmzKjSXMtby9JITEws8h1ct26dd59SiosuuojNmzfz2Wef8dtvvxEfH0+/fv3Iysry9itvnY6WDz/8kDvuuIMJEybw22+/0atXL84//3x27NhRrO8zzzzTqIrQ1QglJS9oTFt1J7FYsmSpSk0tOXlPWppSDzyglIhOanTppUr9/bdLffrpL+rOO19TzZv/q5o0OaT69Vuo7rzzNfXpp7+otDRXwJMO1fa2aNHSIq//+kup1FSlDh1SyuWq1o+r1ijpezZixAh1wQUXlHlcfHx8seQvxx13nBo2bJhSSqlJkyYpEVG//vprkT5HjhxRTqdTHT58uIozPzouuOCCSifnmT17drHEO6UxZcoU1apVK+/rK6+8Ul100UVF+rzwwguqbdu2yuXzpZk7d65KSkpSdrtdJSQkqAkTJpSYTMnDzp07VVBQkHrnnXe8bTt27FAior766qsKz68inHXWWUUSP1WFyqzlxIkTVefOnUvdn5qaqgC1Zs0ab5vT6VTR0dFq+vTpSimlDh06VOo6ffLJJ962DRs2qIEDB6qIiAgVHR2thg0bpnbv3l3m/E499VR14403Fmk79thj1f3331+kbcWKFapt27YqPT1dAWr27NmljmmSF5WevMiIVLWICNx6K7z+un4K/vhjrT146612vPjidRw+3JyMjKZ8+20fXnzxOt57r02DVZ1XhtBQnQvCk9fAJw16oyQkJIR8t+rk3XffpV+/fiUWGLJYLGVW4ouIiChzq86SvNXJrl27+OSTTzjrrLO8bQ6HgxC/cpyhoaGkpaWxfft2ABYuXMjw4cMZM2YMGzZs4M0332TOnDlMmDCh1Pdas2YN+fn5RdIyt2vXjhNOOIGffiq5MntJ86vrbNmyhbi4ODp06MCwYcPYsmWLd5/HBOW7vhaLBbvdzg8//ADoComlrdMvv+i6dLt376Z379506dKFFStW8PXXX5OZmcmQIUOKlZ33kJeXx6pVq4qlxe7fv3+R9c/IyOCqq67itddeI8YkhakSRigIAOedB599pgsE/fqrMHduK5xOG0pZACE/Pxin08Znn8UwebKRCqB4XoODBxuGr8FXX31V7GZ83333ldi3oKCAGTNmsG7dOm9VvM2bN3PCCScc1XuvWbOmzK2ihXFqiyuvvJKwsDDatGlDkyZNeOutt7z7BgwYwOeff86iRYtwuVz8+eefPPPMM4C+GYG2t48bN47rrruOY445hr59+zJp0iSmTZtWqu9Oeno6Vqu1WI792NjYInUMyptfSYwePbrI5/79998XaytJRV7d9OjRgxkzZvDVV18xffp09uzZQ69evfj3338BXWOgffv2TJgwgQMHDpCXl8ekSZNIS0vzru2ePXtKXae9e/cC8Morr3DyySczadIkTjjhBLp27crMmTNZsWJFqdkF9+/fj9PpJDY2tti4vus/evRozjvvvDoryNYnTPRBgOjSBd5/H/r2LT1Fcn5+EK++qhg9mkZZTKkkQkN1yOLevdoJsVWr+l15sXfv3sUcB5s3b17k9QMPPMAjjzyCw+EgODiYcePGMWrUKKBq+SyqWsa3tnnuueeYOHEif/75J+PHj+fOO+/k1VdfBeCmm27i77//ZsiQIeTn59O0aVPuuOMOHnnkEa+NedWqVaxYsYJJkyZ5x3S5XOTk5LBnzx7eeustnnzySe++P/74o9rmVxL//e9/ueeee7yvhw8fzqWXXsoll1zibfNUpKxJ/G+kp512Gh07duTtt99m7NixBAUF8cknn3DDDTfQokULrFYr/fr14/zzz6/U92/VqlV89913REREFNv3999/43A4iszl1VdfpW/fvuWOO2vWLH7//fd6lba4LmOEggCyYoVO+ZuTU3ofqxXmz4fhw2tvXnUdi6Uwr8G2bRAdrSsv1kf/orCwsHJvzmPHjuWGG24gLCyM1q1bF3E+Pf7449m4ceNRvXdJF2dfzjzzTL788sujGrsmaNWqFa1ataJTp05ERUVx5pln8uCDD9KuXTtEhEmTJvHkk0+yZ88eoqOjWbJkCYC3lLLL5WLixIlcfvnlxcaOjo5m9OjRRSoExsXFERsbi9PpZP/+/URHR3v3paenF6u8WNb8SiImJqaIqjs0NJSYmJiAC2sRERF07ty5SHRBcnIya9as4fDhw+Tl5REdHU2PHj28ZqtWrVqVuk6nnnoqoNf/ggsu4Omnny72nrGxsdhsNm8FR0+b3W7HarWSnp5epH96ero3QmLJkiX88ccfxb7PQ4cOpWfPnl4Th6FiGKEggOzdq29sZZGTo/uVh8vlKuJ16/+6IRISorUE+/cXag38zMoNghYtWpR6o7jqqqsYP348K1euLOZX4HK5yMzMLNWvwPcCXBKhoaFHNd/awGOD9g+5tFqttGnTBoD333+fnj17em9SSUlJbNq0qdS1jIqKIioqqkhbt27dCAoKYvHixVx11VUApKWlsXHjRnr16lXp+dUHcnNz2bRpU4lP6Z5Sz5s3b2blypU89thjgBYaSlunxx9/HNDr/9FHHxEfH09QKQlISvpskpOTWbx4cRFhbvHixVx66aWANgv5alwATjrpJJ5++mmGDBlS2dNv9BihIIDExEBoqJCdXXqf0FApt5jSggULcDgcDBkyBIvFgsvl4vPPP8dutzNw4MDqnXQdQwQiIrSvwbZt0LIlREXVH62Bw+EoZpu2Wq1FnrbK4s477+SLL77g3HPP5dFHH6V37940a9aMn376iZdeeoknn3yy1OpqNfFE6hE0jhw5gsViYc2aNQQHB3PiiScC8OmnnzJ+/HiWLFnivXnv2LGDAwcOsG3btiJjHHvssURERDB//nz+/fdfkpOTiYiIYMOGDYwbN47TTjvNew779+9n9uzZ9OnTB4fDwVtvvcXs2bP59ttvvXN7+OGHGTRoEPHx8VxxxRXYbDbWr1/PihUreOqpp0o8n2bNmnHDDTdw7733EhMTQ4sWLRg7dixdu3alX79+ABWaX0kcPnyYHB814QcffABQ5PsQHR2Ntbwc6T6Ut5agfQTGjBnDmDFjALjnnnsYPHgw7du3Z+/evTz22GNkZWUxYsQI77izZ8+mZcuWxMfHs27dOu644w4uuugirwNgWevkES5uu+02pk+fztChQ7nvvvuIjo5my5YtfPTRRzzzzDOlVlIcO3Ys11xzDaeeeiqnn34606ZNY9euXYwePRqANm3aeL9LvrRr186rJTJUHCMUBJALLoCHHlJA6bkI8vMVgwaVvt/lcrFv3z4OHDjA559/zpAhQ/j888/Ztm0bUVFRjUJjABAcrLMfHjhQqDXwrV5ZV/n6669p3bp1kbY2bdpUOOmL3W5n8eLFPP/887zxxhvcd999hISEcOyxx3LjjTeW+TRbE3Tv3r3I63nz5hEfH++9SR0+fJjU1FRv9ATom/Xbb79dbIylS5fSp08fQkJCmDZtGhs3bsThcNCuXTsuvvhi7r///iLvNXPmTMaNG4dSip49e7Js2TKv6hq0M+IXX3zBY489xtNPP43NZuP4448vN8nS888/j81mY+jQoeTk5HDOOecwc+ZM7826ovPz54477ihy3iWxdetWEhISyuzjS3lrCZCamsr+/fu9fdLS0rjyyiu9qv/TTjuNn3/+mfj4eG+f3bt3M3bsWNLT02ndujXXXnstDz30UJH3Lm+d4uLi+PHHHxk/fjznnXceubm5tG/fnv79+2MvwzFo6NCh/Pvvvzz++OPs3r2bLl26sGDBgiLzM1QfUhVHpYZASkqKqk4HlW++WUbbtn0ox1zr5amn4OWXC8jPL1k+s1phyhS4+OKSj1dKMXfuXLZu3apjTN2aAhGhQ4cOXHjhhfUuAdKGDcvo3LnPUR+fn6/NLpGR0KIF2OqA6Fvb9dvrYg37+ohZx6pTF9ewtn+PVWXZsmWlavyOFhFZpZQqFsvc8B8h6zhjxzo5/fT1WK0FiLgARVBQPhZLAa1b/4vTCWPGwJNPFi3R7EtcXBwhISG4XC4KCgpwuVyEhITUiudyXSQoSIcvZmRok0JGRsMIXzQYDIaaxggFAcZms3LvvcL9939Is2aHadr0CGef/S3jx3/I66+n8fjjWlvw0kswciT4p1MXEZKSkoqp3+x2O0lJSfVOS1CdhIVpR8R//mnYqZINBoOhugiIUCAit4rIVhHJFZFVInJmOf1vE5GNIpIjIqkicq3f/pEiokrY6oUv+sknn8yoUcMYNWoWt9zyNt26/cGoUcPo1u1krrtO5zOIjIRvvtF+CH/9VXisy+Vi7ty5HDp0iI8+uoKPPhqKiHDo0CHmzp1baqawxoLVqrUGubmwZUvDSXpkMBgMNUGtCwUiMhSYAjwJdAd+Ar4Ukfal9L8FmAT8F+gMTAReEpHBfl2zgda+m1KqnIC/uoHnxu6L7w399NNhwQI44QSdzW/QIFi0SPcTETIzM3E4QsjOjiArqxmbNiXjcISQmZnZqDUFvoSGQni4Du/cvr38UFCDwWBojARCUzAWmKGUmq6U2qiUuh3YDdxSSv9rgOlKqfeVUluUUh8ArwH+uWCVUmqP71Zzp1B9uFwuZs2axbZt22jXrh1jxoyhXbt2bNu2jVmzZnkFg/bt4fPPtaYgIwOuuw6ee077GXz77am88spNHDzYnIMHI/j66zN45ZWb+PbbU81TsQ+epEdKaV+DfftK99NobIwcOZJBgwYFehr1li5duvDII48EehoGQ5WpVaFARIKBZGCR365FQGmxU3bA/7kuBzhVRHwzYISKyHYRSROR+SLSnXqAiGCxWAgKCqJNmzaICG3atCEoKAiLxVLkST88HF59Fe67T8fnP/00nH228PXXx1BQYHOnSxYcDisFBTaWLDmGp582mgJ/7HYtHBw6pIUDn+qvDZqRI0ciIsW2NWvWMGXKFN555x1v3z59+njj2A11l5dffpkOHToQEhJCcnIy33//fbnHfPvttyQnJxMSEkLHjh2ZNm1akf0JCQklfk8uuOACb5+MjAzuvPNO4uPjCQ0NpVevXvz6669FxklPT2fkyJEcf/zxhIWFcd555xXJkmiom9R2sFZLwAqk+7WnA/1KOWYhcIOIfAKsRAsVNwJB7vF2A6nA9cDvQBPgDuBHETlZKVXsWygiNwM3g06luWzZsqqdlQ9ZWZls3bqsUslzkpLakZXVAocjjR9+0PHpp57akfDwMP7449ti/c85B5o0ieJ//zuRv/+2ERPj4LrrVhEdXTxfsgisXatt6/WF3NxMNmxYVivvpRRs3qzXx2bT61UT5ObmkpGRUTODl4DT6Sz2fvn5+fTt27dYrYUWLVp4c1l4jnE6neTl5dXqnANNXl4ewcHBRdpKWseScLlcOByOWl2vjz/+mDvuuINnn32Wnj17Mn36dM4//3xWrFhRamrlbdu2MXDgQK6++mpeffVVli9fzu23305ERIQ3+9/SpUtx+qjQ9uzZQ+/evRk8eLD3/EaOHMn69et55ZVXiIuL48MPP6Rfv36sWLGCuLg4lFIMHjwYi8XCO++8Q2RkJFOnTuWcc85hxYoVhIeH1/wClUFubm61XvdrmszMzNqbb0n1lGtqA+IABfT2a38YSC3lmFDgTSAfKAD+QfsYKCC2lGOswDrghfLmVN11tZcsWapSU5X655/KbWlpLjVp0izvlpbmKveYceOUEnEpfWsreQsLc6mnnqr8fAK5LVq0tNbf86+/lEpNVerAAaVcrmr9Siilar9++5EjR4q1jRgxQl1wwQUl9vfdN2LECOX+fXm3rVu3Fjtm5MiRqmXLluqJJ57wtm3ZskUFBQWpWbNmlTq3jz/+WJ100kkqJCRERUZGqt69e6s9e/Z490+aNEnFxsaq8PBwdc0116iJEyeq+Pj4Ms9j4sSJqnPnzt7XK1asUOeee65q0aKFatKkiTr99NPVTz/9VOQYQE2dOlVdfPHFKiwsTN19991KKaXmzp2rkpKSlN1uV/Hx8WrChAnK4XB4j0tPT1cXXnihCgkJUe3bt1dvvPGG6ty5s5o4cWKp51wTnHrqqerGG28s0nbssceq+++/v9Rj7r33XnXssccWabvhhhvUaaedVuoxjz/+uGrWrJnKzs5WSimVnZ2trFar+uyzz4r0S0pKUg888IBSSqnU1FQFqDVr1ni/i06nU0VHR6vp06dX/CRriNr+PVaVpUuXVvuYwEpVwj2xtn0K9gNOINavPRYo0QdAKZWjlLoeCAMSgPbANiAD2FfKMU60VuG46ph0TaOUKpZIY+XKleVWINO3/bIfbXNypEK1Exo7oaE6hNHjiFhWkaqGzpQpU+jZsyfXXXcdu3fvZvfu3SU+eT777LP873//46GHHiI1NRXQGfUSExO9+e/92bNnD8OGDWPEiBFs3LiR7777jmuuuca7/6OPPuLBBx/k0UcfZfXq1SQmJvLss89W+hwyMjK45ppr+P7771mxYgXdunVj4MCB3nLAHh599FEGDhzIunXruO2221i4cCHDhw9nzJgxbNiwgZdeeok5c+YwYcIE7zEjR47kr7/+4uuvv+azzz5j5syZ3oyNpfH9998XK5Htv/lWaCyPvLw8Vq1a5U0z7KF///789NNPpR63fPnyYscMGDCAlStXFsky6UEpxRtvvMHVV1/trYVRUFCA0+kkxK/QSGhoqLf4kKfmg28fi8WC3W43BYrqOLVqPlBK5YnIKuBcYLbPrnOBj8s5Nh9IAxCRYcB8pVSJ8XaiDfFd0eaEOo1HIEhNTSUxMdGbactzkU1JSSk1giAmBsLCFNnZpQsGoaGKmBjjV1ARPI6IeXlaMIiM1LUU6pPppTy++uqrItXkSqqE2KxZM4KDgwkLC/NWoiuJyMhIbrzxRubMmcPMmTO58soree+99/jkk09KTa29a9cu8vPzueyyy7xpart06eLd//zzzzNixAhvaegHHniApUuX8pdvHG4FOPvss4u8fvHFF/n444/58ssvufrqq73tQ4cO5cYbb/S+HjFiBOPGjeO6664DdCXDSZMmcfXVVzN58mQ2b97Ml19+yQ8//MDpp58OwNtvv11ujv2UlJRyC1D5F2Mqi/379+N0OomNLfp8FRsby9dff13qcXv27PHWbPA9pqCggP379xdLub148WK2bt3KTTfd5G1r0qQJPXv25PHHH6dLly60atWK999/n+XLl3trPXTq1In27dszYcIEnn32Wex2O8899xxpaWns3r27wudpqH0CkQD2WWCWiKwAfgRGo80K0wBEZCaAUupa9+vjgR7Az0AkOnqhC+Ct1iEiE937NwNNgf+ghYLSIhrqDCKC3W73CgQi4q12Z7fbywwp1LUTyh7f6dQhjIaK46mjkJGht5gYLSw0hOjO3r17F/EpqI5KiNdeey3jx49n3bp1nHLKKV7b9Lvvvuu9uQN8+eWX9OrVi379+tGlSxf69+9Pv379uOyyy7wFoDZu3FjkJg3Qs2fPSgsFe/fu5aGHHmLp0qWkp6fjdDrJyclhx44dRfr5V5ZctWoVK1asYNKkSd42l8tFTk4Oe/bsYePGjVgsliI1FeLj48vNHhoaGhrwkshHw/Tp0znllFM4+eSTi7TPmjWL66+/nrZt22K1WklKSuLKK69k1apVAAQFBfHJJ59www03kJCQgNVqpV+/fpx//vnlakANgaXWhQKl1Ici0gJ4EJ1PYD0wUCm13d3FP1+BFS0IJKL9CpYCvZRS23z6NEeHKbYCDgO/of0WVtTQaVQrXbt2RSnlFQA8gkF5OQaaN4fRo+GVVwrIyyvpo1T07QvuaqeGSiCizQlOp86GGB6uhYMy6rbUC8LCwqr95nTRRRcxevRo5s2bV+Qp9cILL6RHjx7e123atMFqtbJo0SJ+/vlnFi1axBtvvMH48eP59ttvi914SsNisRS7sfirvkeMGEF6ejrPPfccCQkJ2O12zjnnHPLy8or083d4c7lcTJw40VumNzMz06tZ8a1cWdn8H99//z3nn39+mX0mTJhQxExRFi1btsRqtZKeXtRnOz09vUztTqtWrUo8xmaz0bJlyyLte/fu5fPPP+ell14qNs4xxxzDt99+S1ZWFkeOHKF169YMHTq0iMYkOTmZNWvWkJaWht1uJzo6mh49ehQTxAx1i4CUilFKvQy8XMq+Pn6vN6KTHJU13l3AXdU1v0Dgf5Gp6EVn3DghPf1fPv64JQUFglKCzZaP02lDKQtffQUPP6w1CqWUMDeUgW9GxK1btTkhMrJhmRRKIjg4uIgHelmEhYVx3HHHISKcc8453vYmTZqUWAhHROjZsyc9e/bk4YcfpnPnznz44YecfPLJnHDCCfz8889cf/313v4///xzkeOjo6OLqeL9X//www+88MIL3jC69PT0Cqmtk5KS2LRpk1dw8i/m06lTJ1wuFytWrPBWoNyxYwe7du0qc9zqNh8EBweTnJzM4sWLvQIMaHX/pZdeWupxPXv25NNPPy3StnjxYlJSUgjyu0DMmDEDu93OlVdeWep44eHhhIeHc/DgQRYuXFhiCepmzZrRpEkTNm/ezMqVK3nssccqepqGAFAH6scZqoZi2LAdtGkzn7feugSlbJx++moSE/8iM/Mc3nwznjfeENauhWnTdElhQ+UJCdFaggMHdP0Jj0mhoZKQkMCKFSvYtm0bERERREVFleonsHjxYlavXk1ERATZ2dmElVGz+ueff+brr79mwIABxMbG8ttvv7Fz505OPPFEQJcTvvbaaznllFPo06cPc+bM4Zdffilywzz77LN56qmnePPNN+nduzeffPIJP/74I23btvX2Of7443nnnXfo0aMHWVlZ3HvvvcXCDUvi4YcfZtCgQcTHx3PFFVfgcDjYunUrK1as4KmnniIxMZHzzjuPUaNG8dprrxEaGsrYsWPLNcPUhPlg7NixXHPNNZx66qmcfvrpTJs2jV27djF69Ghvn2uv1RnhZ86cCcDo0aOZOnUqd955J6NGjeLHH39kxowZvP/++0XGVkrx+uuvM2zYsCI+KB4WLlyIy+WiU6dO/PXXX4wbN45OnTp5fTEAZs+eTcuWLWnRogVbt27ljjvu4KKLLirm6GioW5iCSA2ATZs2ERycQ+vWVhITI7jxxjCCg3Po0OF75szRgsCvv8KAAVCGY3Ixlayx/RVFBCIitMbln38gLU07JTZE7rnnHoKDgznxxBOJjo4uZov35YEHHmDIkCFERUXxySeflDlus2bN+PHHHxk0aBDHHXccd999Nw899JDX+W/o0KE88sgjPPDAA3Tv3p1169YxduzYImMMGDCAiRMn8sADD5CcnMy2bdu49dZbi/R58803yczMJDk5mWHDhnH99deTkJBQ7nkPGDCAL774gqVLl3LqqafSt29f/u///o/27QutmjNmzKBDhw6cffbZDB48mKuuuqpCY1c3Q4cO5fnnn+fxxx+nW7du/PDDDyxYsMDrwAlai+H72XXo0IEFCxbw3Xff0a1bN5544gleeOGFYtqFZcuWsXnz5iIOhr4cPnyYMWPG0KlTJ6699lrOOOMMFi5cWETbsHv3bq699lpSUlL4z3/+wzXXXFNM+DDUPaSxX/hTUlJUddbV/uabZbRt24cShOsaQSnFvHnz2L17N0lJSd7ohdWrV9O6dWsGDx7Mv/8Kt94KP/6o1d7jx2tfBF8Lxdq1a3E4HF5fBk9UhN1up2vXrrVzMm42bFhG5859avU9j4acHCgogBYtICqKMhNW1Xb99tqqYf/pp59y2WWXsXbtWt577z1+/fVXFi3yT1haNZ5++mmmTp1abthfTVBb69iQqYtrWNu/x6qybNky+vTpU61jisgqpVQxBw+jKajniAjx8fHExMSQmprKu+++S2pqKjExMcTHxyMitGypKy2OGaMd5x5/HG68sbAMs1IKh8NBamqqNz+CJyzS4XAYjUEphIZqzcGBA9rfoLGkS/bgcrl46KGHuPLKK+ncuTPXXnstS5Ys4ZVXXmH//v2Bnp7BYDgKjE9BPUcpRV5eHpmZmWRnZxMeHk5WVpa33RPV4NEQJCfDHXfAV1/Bpk26lkKXLsLevXvJz88nNTXVmyMhPz+fvXv3mkqLZeAxKRQUwM6dOkohNlaHNTZ0PALo559/DkBiYiKPPfYYDz30ECtWrOCtt94K8AwNBkNlMZqCeo6IkJycTEREBA6HgwMHDuBwOIiIiCA5ObnYDb1/f/jyS+jcWRcDuvBCeO89F2lpaezalcXSpXF8/fVJLF0ax65dWaSlpXkrNRpKx2bTUQp5eVprsH9/w6/AeM0115Cfn88xxxzjbZswYQL79++vVoHgnnvuCYjpwGBojBhNQT1HKcWqVavIysrCbrcTFhZGdnY2WVlZrFq1qsR8BwkJugzzxInw7rswbpyFuLih7NkTgVIWlBKCgvJZvLg3/fptxi+XjKEMQkN1+umDBwujFGrLv8RgMBiqitEU1HNEhODgYMLDwwkLC0NECAsLIzw8nODg4FJV/6Gh8NRT8NxzYLMpdu1qjsulcxuAkJ8fjNNpY+nS43jmGWM+qAwi2owQFKQTH+3cqQUFg8FgqOsYoaCe4+tT0KlTJ4YPH06nTp3IzMz0+hSURf/+ZafvzcuzMW1aoVOioeLYbDqXgdOpfQ7y841wYDAY6jbGfFDP8dRO6NSpU6VrJwB88YW+eZVQIM2LxQLz58Pw4dU588aD3Q6xsa055ZQUlNJhoWWFL1YHubm5xarYGSqPWceqUxfX0L/wk6EQIxQ0AI62dgLoUsG5uWX3yc3FlF+uIjNmzAO01iAnR5sWYmN1fYWaoCbimhsjZh2rjlnD+oUxHzQQjrZ2QkwMhIaW3TcoSIiJKX8skxGxfKxW7Xgoon0Ndu1quFkRDQZD/cMIBY2cCy4Ap7Psm3denk6TnJNTep+1a9d6Ex8B3gRIa9eurc7pNhiCg7W/QU5O4wlhNBgMdR8jFDRymjeHUaMUQUElOxVYLE6sVsXs2TB4MJRU1t6TEXHTpk1FMiJu2rTJZEQsB/+siEeOGGdEg8EQOIxQYODeey30778Nm62AoKA8wEVQUB42WwHnn7+FBQuEjh1h40Y47zz46KOix3vCIiMiIti0aRPvvvsumzZtIiIiosywSIPGkxXRbtfmhO3by9bKGAwGQ01hHA0NgOKmmw5xwgkzWbu2HdnZEYSFZXLyyTs5/fST6NxZ8eWXwvjx8MkncNdd8MMP8OST+mamlGL79u3sdXsjehIoZWdnY7Va6dq1qxEMKoDVWpgVcft2aNYMWrbUTokGg8FQGxihwADoG3tQUDZdu67HarXidDqx2YK8qv+ICHjhBTjjDHjgAfj4Y1i9Gl55Bbp00ccfPOgiNfVYr1CRmPgXrVoZXXhlCQ7WW3a2NilERUFkpBYaDAaDoSYxQoEBgD179mCz2QgKCipSVGnPnj3ePiIwdCgkJcEtt2hzwuDBMGGCYvny41my5AJcrsI0yUuW9KVfv80MGqSwWsvXFPiGVZb0urHhmzL50CEdKdKkSdnJpgwGg6EqGJ8Cg7f8cmxsLOHh4QCEh4cTGxvrLb/sy3HHwbx5MGKETnr06KMWFi9OxOksLU1y+V8zE71QMp6UyXY77N6ti1hlZwd6VgaDoaFihAKDN1VyVlYWiYmJDB8+nMTERLKyskpNlRwaqn0KpkwBUG5hoDg6TbIqM02yJ3ohNTWVlStXArBy5UpSU1NN9IIbq7VQS7BjB/zzDzgcgZ6VwWBoaBjzgcGbKjkxMbHSqZIdDggJKTsrotVadppk3/dLTU0lPj6M7dvTiszHoPH4G3jyG0RF6c1mfskGg6EaCIimQERuFZGtIpIrIqtE5Mxy+t8mIhtFJEdEUkXk2hL6XCoif4iIw/334po7g4ZH165di9yAPTfqrl27lnnc3r3lP7Hm5JSfJnndunUARcwHvu2GooSGas3BkSOwZYv2O3C5Aj0rg8FQ36l1oUBEhgJTgCeB7sBPwJci0r6U/rcAk4D/Ap2BicBLIjLYp09P4EPgXaCb++9sEelRc2fS8DiaVMkVSZMcElJ2mmSP+WD16tVkZ2ejFGRnZ7N69WpjPigDEV07ISxMZ0Q0yY8MBkNVCYSmYCwwQyk1XSm1USl1O7AbuKWU/tcA05VS7yultiilPgBeA+7z6XMnsFQp9YR7zCeAZe52Qw1SkTTJDofizDJ1QUUx1oLKYbFoZ8TgYO2MuH270RoYDIajo1aFAhEJBpKBRX67FgG9SjnMDvhbrHOAU0XEk9alZwljLixjTEM1UV6aZFC4XMKll8Ly5SX3EBH27dtHdHR0keiH6Oho9u3bZ3wKKojHGRF0AqSdO8uvgGkwGAy+SG2qZkUkDvgHOEsp9Z1P+8PAcKVUYgnHPAncAAwCVqKFivlALBCnlNotInnAjUqpmT7HXYvWMNhLGPNm4GaA2NjY5A8++KDazjEjI5OgoIhGl2hm27ZcjhwJQUShlHj/5uZamDWrG6mpTRFRXHHFDq69dhtBQUW/d9nZ2WRlZfPvv81o1SqX/HztqBAeHkZYTdUXbsDk5mZit0fgcmknRKvVaGCOhszMTCIiIgI9jXqNWcOqUxNr2Ldv31VKqRT/9vrgs/wY0ArteyBAOvA2cC9wVEpSpdRraBMEKSkpqjprfS9btoxjj+1DdrbOAthYKCj4nd9/38aSJaFkZ4cTFpbFOefkkJSUwNVXN+W55+DFF4UPP4znjz/imToVjj1WH+vJSZCaupq33+7JPfdsZN++XQAkJcVz4okmAqGybNiwjM6d+wDa0dPp1FEKzZubSIXKsGzZMqrz+tAYMWtYdWpzDWvbp2A/4EQ/5fsSC+wp3h2UUjlKqeuBMCABaA9sAzKAfe5ueyozZk0TF6dz2GdkNA6nL4+j4JEjO+nWbQNnnrmKbt02cOTIThwOBzab4t57dWrktm1h3ToYMADefluvj8d8EBMTg8WiVSyhoaHExMQY80E1EBqqfQ4OHtTOiCZSwWAwlEatCgVKqTxgFXCu365z0ZqAso7NV0qlKaWcwDBgvlLKc2lbfjRj1hQWC8TGQosW2hu8oV+AlVJs3LiR/Px8EhISGDNmDAkJCeTn57Nx40Zv9MCpp8LixXDJJdrWPWECXHstpKcroqOjSU9Px+VyApCTk0N6ejrR0dEm+qAa8GRGDA2FfftMpILBYCiZQEQfPAuMFJEbReQEEZkCxAHTAERkpoj4+gYcLyLXiMhxInKqiHwAdAEm+Iw5BThbRO4XkU4iMh7oCzxfWyflj4iucNeqldYYOJ2BmknNY7FYiI6OJiEhgSFDhmCxWBgyZAgJCQlER0djsRR+zZo2hRdf1IWUmjeHb76Bfv3g55+bk5MTTEZGGAUFFlav7kROTnDgTqqBYrFos5YnUmHrVsjKMsKBwWDQ1Lp1USn1oYi0AB4EWgPrgYFKqe3uLv75CqzoMMZEIB9YCvRSSm3zGfMnERkGPI7OZ/A3MFQp9UtNnktFiIzUNtxdu3Tmv4ZaBnfgwIG4XC6vAOARDHwFAl8uvBBOOUWXYf7+e+H//u84RI5BKXA6LSxa1IuFC89g48YtpKQY80F144lUyM/XUQqhoZ6cE4GemcFgCCQByWiolHpZKZWglLIrpZJ9IxGUUn2UUn18Xm9USnVXSoUppZoppS5SSqWWMOYcpVQnpVSwUuoEpdQntXQ65dKkCbRvr8PEGnK+en8BoDSBwEPr1vDee3DWWYrC+gkW/v67GXl5QeTnW/n6645MnmweY2uKoCCtvVFK5zdISzNhjAZDY8YURKolQkMhPl5ffHNyAj2busORI/Dzz6ADSzTTpnXz/u9wWJk2jTILKhmqTnCwFg7y8nQlxt279f8Gg6FxYYSCWiQ4WGsMbDZtxzXAF19QLKeDf7CBp6CSoeYJCdHCQXa2rqmQnq5NDAaDoXFghIJaxmaDdu10vvrGErJYFnv3Ftec3Hbb6iKvs7NhT0CCSxsvnoJLGRnaGXH/figoCPSsDAZDTWOEggBgsehcBlFR+qLb0EMWy6Ik57b4+Ay/XsLs2bB5c61Ny0BhwaXwcDh0SGsODhxo2JE0BkNjxwgFAUIEoqN1PoOGHrJYFrqgUvnRBTt36oRH06Y13rUKFL7VGP/9t7BUs/kcDIaGhxEKAkxkpM7yl53dOG23zZvD6NEKu73kO4zd7mT0aMXQoTpy47HH4NJLtUrbULt4qjH6JkA6fLhxa7oMhoaGEQrqAE2a6MiE/PzGGQ52zz1w9tl/YbMVIKLvMEFB+dhsBZx99l888AA8+yzMmKE1K7/+qhMevfmmuSEFAk8CJLtdOyIa4cBgaDgYoaCOEBKiBQOLRWsNGhMicNZZKxgz5k1atXIQHAw33ZTGmDFvcNZZK7zRCOeeC0uWFKZJfughuOIKHV9vqH2s1sLsiHv2FKZONsKBwVB/MUJBHSIoSEcmhIY2vsiEZs2a0aSJi6iofIKCoH///TRpomjWrFmRfpGROk3yG2/oNNLLl8M558Bbb5mbUaDwZEf0CAfbtpm6CgZDfcUIBXUMq1VHJkRGNp7IBBFh8ODBJCcnk5OTTUFBAampqSQnJzN48OASqySedx4sXQoXXaRDGh98UGsNtm2r9ekb3Hg0BzZbYV2FxibcGgz1HSMU1EFEdKhebCxkZjaO+HARISUlhVGjviY6+ggAKSkpZZZNjoqCl16C6dMLtQb9+sHrrzcOYaquYrNpzYGn5ocRDgyG+oMRCuowkZHanJCT0/BTziqlWLlyZZG2lStXVqhs8sCBWmtw8cV6rSZO1H4Hf/9dM/Ms67WhECMcGAz1DyMU1HHCwyEhQT/5NtSaCR6BIDU1lcTERKKiokhMTCQ1NbXCgkFUFEydqn0LPBEK/fvDyy9Xn6Zl7dq1RebjmffatWur5w0aKEY4MBjqD0YoqAfY7bpmQnCwNic0NEQEu91OYmIiKSkpgDYdJCYmYrfbyzQh+NO/P3zzDVx+uY5QeOIJXab5jz+qNkelFA6Ho4ig4hFkHA6H0RhUAI9wYLUa4cBgqKvYAj0BQ8Ww2aBNG5005uBBfXGtxL2yztO1a1eUUl4BwONjUBmBwEPz5vD88zBkCNx3H/z+O5x/Ptx+u97s9srPzzMfgNTUVFJTdfVujyBzNPNsrAQF6a2gQAsHQUE6u2dERMP6ThsM9RGjKahHWCzaATEmRod8NbQ0s/431qreaPv21VqDESP0Dei553TUgp/rQqXm5xEMPBiB4Ogpyaxg8hwYDIHFCAX1DBFtP2/XTic5cjgCPaPqoyac+CIi4Mkn4eOPoWNH+PNPHcb48MOVL19dFWdIQ+n4Cge+eQ6McGAw1D5GKKinRERoB0SlGkYGxJp24jvtNFi8GMaM0RqXN94o1CRUBH9nyOHDh1faGdJQNjZb8TwHJn2ywVC7GKGgHuNxQLTbtQNifb0v+TvxATXixBcSAuPHw4IFcNJJ8M8/cM01WlDYv7/sY/2dIT2mhKNxhjSUjUdzEBysayuYqowGQ+1hhIJ6jscBsXnz+qty9b3BpqamcuDAAe8TeU3Y7Lt0gfnzde2EkBD49FM46yz46KOyBau0tDR27txZRJuxc+dO0tLSqnV+Bo0nQ6LdroU2IxwYDDVPQIQCEblVRLaKSK6IrBKRM8vpf5WIrBGRbBHZIyLviEgrn/0jRUSVsIXU/NkEHo8DYlyc1hjUxxLMte3EZ7PB6NHafHDmmXDoENx1Fwwdqm8+/rhcLhwOB2lpaXz++ee4XC4+//xz0tLScDgcuOqjNFZPsFqLlmzeskULCY0h06fBUNvUulAgIkOBKcCTQHfgJ+BLEWlfSv/TgVnA20Bn4CLgROBdv67ZQGvfTSnVqAoRN2tWWIK5viU6CpQTX3w8vP++DmGMjIQff9Spkl94oWgWSYvFwpAhQ2jRoiMPPdSHzp0zmDevKS1adGTIkCFYLEbpVtN4SjaHhmqNwd9/ayGhPgrBBkNdJRBXsrHADKXUdKXURqXU7cBu4JZS+vcE0pRSzymltiqlfgZeBHr49VNKqT2+W82dQt0lNFTf6Gy2+pPoqDoyGlYFEZ3s6Lvv4LLLdETHpEk6fPHXXz1zhHvv3ccDDwzk0KFmHDnSlG++OZMHHhjIvffuq7f+HPURi0VrDiIitCPili3a96AhReIYDIGiVoUCEQkGkoFFfrsWAb1KOexHoLWIDBZNS2AYsMCvX6iIbBeRNBGZLyLdq3Xy9QhPCeZmzeqHn0F1ZjSsClFRMGWK1hwkJEBqqg5fvPdeeOwxxccftyA/34JSFkDIzw8mP9/Cxx+3YPJkIxXUNiIQFqaFg8xMHcq4a5fOZGkwGI6O2tYUtASsQLpfezrQqnh3UEotRwsB7wJ5wD5AgBE+3VKB64EhwJVALvCjiBxXnZOvT3j8DOpLpcWuXbsW8SHw+Bh07dq11ufSuzd8/TXccYcWsN59F159FfLySk4AmpdnY9o0/dRqqH1EtIasSRNtNtu+HXbu1P8bDY7BUDmkNuOrRSQO+Ac4Syn1nU/7w8BwpVRiCcecCCwGngcWov0FJgNrlFLXlvI+VmANsFQp9Z8S9t8M3AwQGxub/MEHH1TtxHzIzMwkIiKi2sarDlyuQrtrfTB95+ZmEhJSN9Zw+/Ywnn76eFJTmwNw3HEHuOSSzURHF3XasFi0o2dUVAAmWQJ1aQ0DgVJ6E9GmtKP93tfF33N9w6xh1amJNezbt+8qpVSKf3ttCwXBaIfAK5VSs33aXwK6KKXOKuGYWUCEUupin7YzgO+BdkqpEuPBROQtoJVS6vyy5pSSkqL8HdyqwrJly+jTp0+1jVdd5Odr1arDodWtdZkNG5bRuXOfQE/Dy7PPwjPPlN1HBO6+W0cw1AXq2hoGirw8/Z0PCoKWLfV3vzICQl39PdcnzBpWnZpYQxEpUSio1edGpVQesAo412/XuegohJIIA/wjkz2vS5y/aB10V7QDo4H652dQl4iNhbCwsoXn0FBFTEwtTchQYYKDC1Moe7IkmlwHBkPpBEKZ/CwwUkRuFJETRGQKEAdMAxCRmSIy06f/PGCIiNwiIh3dIYovAKuVUjvcx0wUkQHu/d2AN9BCwbRaPK86j8Wib3CtW9fffAaB4IILyr+JFBTAoEG1Mx9D5fHNkuib68D8BgyGotS6UKCU+hC4E3gQbfc/AxiolNru7tLevXn6z0CHMY4B1gNzgD/RToUemgOvARvRkQxtgN5KqRU1diL1GE8+g4KC+pfPIBA0bw6jRimCgkq/gygFH3xgbjJ1HU+WxNBQnbBqyxZdhMmEMxoMmoC4nSmlXlZKJSil7EqpZF+nQ6VUH6VUH7/+LyqlOiulwpRSrZVSw319CZRSdyml4t3jxSilBrijFgyl4MlnEBwMGRnGS7s87r3XQv/+27DZChBxAYqgoDys1gJiYzPJzxf++184/3z45ZdAz9ZQHhZLYThjVpY2K6SlmYgFg6HkGCtDo8Bmg7ZttRp1/359gbRaAz2ruorippsOkZw8h9WrW+NwNMNuP0xS0i6Sko7l8OEUHnpI2LgRLrlEJ0F68EGIjg70vA1l4QlnDA3V+Q127NC1Flq21AmSDIbGRj0IUDPUJCL6xtW2rS7BbNSoJSMi7Nu3j+DgHM44Ywf9+q3njDN2EBycy759++jXT/jmGxg7Vt9U5szRNRXeeKPu54gwaEJCtN+BiK6guWWL9iUxTomGxoQRCgyAvhh26KD/z8oK7FzqIp6CSEeOHCEiIoKrrrqKiIgIjhw54i2IFBqqwxK/+QbOPlubZR5+WKdL/vnnQJ+BoaIEBRU6JRYUGKdEQ+PCCAUGL8HB0L69NiOYsMWiWCwWOnbsSPv27cnMzOS9994jMzOT9u3b07FjxyIFkRISYOZMeOstvZ4bN8Kll8KYMdqprSbxzztSm3lIGhpWq/Y98BRg2rJFhzWaNMqGhowRCgxFsFqhVavCsEXfSoGNnZNPPpkhQ4YUScU8ZMgQTj755GJ9RaB/f601uPturZr+9FNtUnjppZox06xdu7ZIASlPoam1a9dW/5s1InwLMGVn6xoLO3ZojZqRuQwNDSMUGIohosMWExK0tsCELWqUUqxatapI26pVq8p8Gg8N1X4GS5dqM0J2Njz5JJxzjhYYqnNuDofDW1kS8FaedDgcRmNQDXicEps21b+LtDQdtXD4sPE7MDQcKhV9ICKnAecBp6ETDoUC+9EFib4FPlNKHazuSRoCQ0iIDlvcs0fbx8PD60fthJrAv7xzSkqK9zVQpJhTSbRvr50Ov/0WHnoI/v4brrkG+vWDRx4p9Oc4WjwFpABSU1OJjw9j+/Y071xrq9JkYyE4WG9Opy7bvHcvREZqgSE4ONCzMxiOngpd4kVkhIisQ6civgudengz8AtwEOgBvA78IyIzRKSKlzhDXcFq1YV+YmK0urSxOlv5l3f23IQrW975rLN0BcaHHtLq6K+/hr594YkntLmmKqxbt65S7Yaq40mGFBZWmAxp1y6T78BQfylXKBCRtcD/AQuAZKC5Uqq3UupSpdTVSqmBSqkTgCjgJiAG+ENEhtbkxA21h4h+CmrfXntjZ2cHekaBobrKOwcHw+jR8P33MHSoFrRefln7G3z00dE5eHrMB6tXrybLHT6SlZXF6tWrjfmgFhDRgkHTpoX5DrZvNw67hvpHRTQFbwAdlFL3KaV+U6VcXZRSh5VS7yqlBqLNC4eqcZ6GOoAnC2JoaOPNguivEaiKWj4mRldgnD8funfXKui77oILL4SqFu5sjJ9NXcE338Hu3Vp7cOBA49WyGeoX5QoFSqkpSqlKBeEopX5XSi08+mkZ6io2mzYnREdrwcBc6KpO9+4wdy5MmaIjP377DYYM0SGMu3ZVbAyPeSMpKYmwsDD3k2sYSUlJlTJvGKoPT76DkBAtFJiQRkN9oJG6jRmqgghERRUWVWqs5oTqxGLRqZG/+w7+8x+dFdETwvjMMxVbY6UUO3fuLNK2c+dOYzoIML51FrKztVlh2zYtVBvTgqGuUWGhQEQuEpG3ROQXEdns3n5xt11Ug3M01FF8zQnGdlo9hIfDfffpKIVBg/RT5bPPauHg449LX2OXy8WaNWvYvn0706efx8GDUYSHh7N9+3bWrFmDy3w4AccT0ugxLezapbUH//5rNG6GukNFHA0jReQH4BOgLzoE8Wf3th/oA3wiIj+KSGQNztVQB/GYE2JjTbKj6qRdO3j1VfjkE+jaVYeF/uc/MHgw/Ppr8f4iQmRkJEFBQRQU5FFQUMC+ffsICgoiMjLSmA/qGL6mBU+2RBO1YKgLVERT8AzQHjjLXe74AqXUNe7tAqVUB6A30AZ4uiYna6ibeKITPMmOjDmh+ujRA774Ap57Tgtea9bARRfBqFFaDe1BRBg8eDA9evTA5VLeaIQePXowePBgIxTUUTymhSZNCqMWtm7VmjeTEMkQCCoiFFwI3KOU+r60DkqpH4D7gIuqaV6Geogn2VF4uLmoVScWC1xxhQ5hHDtWr/P8+dCnDzz2mM6o5yEjw0JmZjhOp4U1azqTkWHchuoLnqgFm01rhrZs0REppnKpoTapyBXDjk5QVB6HAJPLq5Fjteq6CXFxWmNgPK2rj/BwXUfh++/h8su1qWbaNOjVC15/XXHDDX9y3XUnc+hQM5xOK99805vrrjuZm276E5fL6KTrCzZbYUKkI0e05sBTa8G4hhhqmooIBcuBB0SkSWkd3PvGozMeGgw0bapT91qt2tfA2Emrj7g4eP55+PJL6NlTZ9KbOFFYuPB4CgpsKKV/1vn5QRQU2Pj6645Mnmw+gPqGb0Ik31oLJueBoSapSO2DO4FlwHYR+QJYT6HmIBLoDFwAONGOiAYDoDP3tWunL2L79+sLnK1S1TYMZdG1K8yeDZ99BrffDkoV+g1s29bU+39+fhCvvqqzKDZrFoCJGqqMp9aCy6V/T/v2aVND8+Y6osG4jBiqi3Iv0UqpP0TkZOBeYDBwFeD5CipgGzATmKyUqmCqFUNjwWKBli21QLBrl1Z5h4UFelYNBxFtpgkJKVrNcurUpCL9rFbthzB8eC1P0FCteBwTQZvmdu7UkQyRkYX+CAZDVajQV0gptRtdCOkuEQlBawgADimlTGFdQ7mEhenohPR0bSeNiGi8FRerm717i/tuBAU5yc+3el9nZ+t+hoZDSIjenE6tOdi7V5samjfX7UZ7YDgaKn1ZVkrlKqV2u7ejEghE5FYR2SoiuSKySkTOLKf/VSKyRkSyRWSPiLwjIq38+lwqIn+IiMP99+KjmZuh5vDkNGjdWjtNGa/q6iEmBkJDi/oM3H//L369FGvXmnDRhoinUqMnY6InrPHwYZ1x1GCoDBVJXnRJZQcVkdYiclop+4YCU4Ange5o58QvRaR9Kf1PB2YBb6P9Fy4CTgTe9enTE/jQ3dbN/Xe2iPSo7NwNNYuItmsnJOj/jRNi1bngAnA6iz4WNmvmn0VKWLQITj8dZs0yjmoNEd+MiTab1spt2aLDG01SJENFqYim4EX3U/poEYkqq6OInCkirwF/AaXVkx0LzFBKTVdKbVRK3Q7sBm4ppX9PIE0p9ZxSaqtS6mfgRcD3hn8nsFQp9YR7zCfQzpF3VuD8DAHAbtelmKOiTGGlqtK8uXYitNtLjlez251ceil066ZVzPffD337wrx5gblR+NdiMLUZqh9PWGN4uNbKGe2BoaJURCg4Dp3i+L9AuoisFZFZIvKsiPxPRKaJyCIROYC+ER8HnKuUes1/IBEJBpKBRX67FgG9Snn/H4HWIjJYNC2BYcACnz49SxhzYRljGuoAHidEU1ip6txzj+L009djtRYgooWDoKB8rNYCTj99A88/r5g/X+c16NBB3yBGj9Zahu9LTUtW/axdu5aVK1d6BQGlFCtXrmTt2rW1N4lGREnag7//NtoDQ+lIRaV09w39YuA89FN6HBAC/AtsAr4DPlRKbSpjjDjgH3TK5O982h8GhiulEks57hJgBhCKdo5cDAzx+DSISB5wo1Jqps8x1wLTlVL2Esa7GbgZIDY2NvmDDz6o0BpUhMzMTCIiIqptvMZEfr52msrPzyQkxKxhZfn333/Jy3Nx4EAUcXHZHD4MdnsuwcEWWrRo4e1XUCB89VUr3nkngQMH9M+je/cDXH/9VhITM2p0jtnZ2eTm5hISEkJYWFix13WN3NyG+V30JEES0T4JFkvNOSaaa2LVqYk17Nu37yqlVIp/e4WFAgD3U3qmUuqo8tQdjVAgIieihYDn0U//rYHJwBql1LXuPpUSCnxJSUlRK1euPJrTKZFly5bRp0+fahuvsZGRAT/9tIxjj+1DaGigZ1O/WLNmDb/99huvvNKP++7bxLZta4mKiqJ79+5069atWP/sbHj9dXj5Zb3uAAMH6iqNxx5bM3P8/fff2bJlC1lZWd628PBwOnbsyMknn1wzb1oFNmxYRufOfQI9jRrD6dSRKy5XzeU9MNfEqlMTaygiJQoFFXE0tIrIIyJyEEgHjojIxyLS/CjmsR+d5CjWrz0W2FPKMeOBFUqpyUqptUqphcCtwDUi0tbdZ08lxzTUUZo0KUzUYsoxV46TTz6Zzp07ey/oIkLnzp1LvdmGhenKi8uXw6236jC2BQu0v8Hdd+sMetWJUoq8vDwyMzO9QkFWVhaZmZnk5eUZ34IAYLVqvwNPQaadO7Vz4oEDpuJpY6UiPgWjgYeB39BVED8HhgDPVfbNlFJ5wCrgXL9d51J6iuQwtCDhi+e1Z/7LKzmmoQ4jAm3b6tBFUz+hYnhs8ytWrGDYsDlERR1ERFixYkURG35JREbCAw/ADz/o5EYi8MEHcOaZ8PDDOga+OhARkpOTiYiIwOFwcODAARwOBxERESQnJ5tKjgHGU5DJbod//y2suZCZaYTzxkRFhIKb0Gr4s5VS9ymlLgduA652+xlUlmeBkSJyo4icICJT0P4J0wBEZKaIzPTpPw8YIiK3iEhHd4jiC8BqpdQOd58pwNkicr+IdBKR8eiUy88fxfwMdQDf0EWrVau3zYNk6Sil+OOPP8jPzychIYGYmBgSEhLIz8/njz/+qNBTeOvW8NRT8O23cPHF2sfjjTd0fYX//U/XWKjqHOfPn8/evXux2+1ERkZit9vZu3cv8+fPN5qCOoLFUqg9cLl0JtK//y45SZah4VERoaAjMNuv7UPACsRX9g2VUh+iQwUfBNYAZwADlVKe6vDt3Zun/wx0GOMYdN2FOcCfaG2Fp89P6IiEkcBa4FpgqFLKP4OLoZ4RHKxDF6OjtWBgEh6VjMViISgoiObNm3PhhRcCcOGFF9K8eXOCgoKwVCJ9ZIcOMHUqLFoE556rvdSnTtXCwfPP6yfHqpCfn8+MGYN49dVzUUqRb+JR6yzBwYUVGzMyYPt2bV4woY0Nl4pcKSKAI35tHhflUisnloVS6mWlVIJSyq6USvZ1OlRK9VFK9fHr/6JSqrNSKkwp1VopNVwplebXZ45SqpNSKlgpdYJS6pOjmZuh7iGi8xmYhEelo5TiuOOOw2q1snr1agBWr16N1WrluOOOO6qn8BNPhBkzYO5cbUo4cgQmT9bCwbRpRWstVJTWrVtjs9kQwb0JNpuN1q1bV34wQ61RWmKkXbtMSeeGRkUfH9q4VfcdRaQjWntQrN29z2CoEUJCiiY8Mo5QhYgIKSkpnHDCCaSmpnLgwAFSU1M54YQTSElJqZK9PjlZ+xjMng0pKdoJ7bHHoFcvbV6oqEpZRLDb7SQnJ2O16roM4eHhJCcnY7fbjU9BPcGTGCkiQn/2//yjzQv79xtNXkOgokLBHGCzz+bJRfCZX/vmap6fwVAET8KjhAT9dGK0BoV4BANfqioQ+NKrly7TPGsWnHyytjE//LBOnfz22xW7ISilSPMLa0hLSzP+BPWUkBAtHISGap+Tbdv0ZswL9ZeKVEm8rsZnYTBUkpAQLRgcOKCfUEJCtP2zMeOJQPBl5cqV1SoYiMDZZ+uwxUWLtDlh40aYMAFeegnuuAOuuEKX8/XH5XKxZcsWdu7cicVyBi1btiQ8PJydO3cCcNJJJ1XK98FQd/At6VxQoM0LShU6K7pcpipqfaFcoUAp9XZtTMRgqCwerUF4OOzerbUG4eGNs2SsRyBITU0lMTGRsLAsQkLakZqaClSvxgD0Gg8YoB0RFyyAZ5+F1FS491548UUtHFx2WVHhwGKx0LGjtjA6nU727k0nMzOTdu3a0bFjRyMQNBA85gXQ5oX8fO1/0LSp3uz2xvkbrS+YX6Gh3hMaqrUGjdnXwGOvT0xM9JoQUlJSSExMrFF7vcUCgwbB11/rzIjHHacT4Nxzj3ZOfP/9osWuTj75ZAYPHlwkwdLgwYPrZDZDQ9UJCdHfkZCQwuiFrVvh4EFTBK2uUhHzgcFQ5/HXGmRlaXVmY3oi6dq1K0oprwDg8TGoDQc+iwWGDNECwrx58Nxz8NdfWjh44QW4/Xa4/HJYvHgB27Yd5PDhQbhcFn7++RiOHPmQhIRIBg4cWOPzNAQGiwVv2nKnU5v89u7VbZGR+rfq9j01BBgjFBgaFB6twYEDOiub3d64fA38BYDa9ui3WuGii2Dw4KLCwbhxMGWKIizsJP76qzVKWVBKmD8/hblzT+HMM9fTv78Tm83cGRo6ntTKoLV6u3fr/yMidO0Fj3bBEBjM0hsaHL4lmcFEKAQCj3DwzTfaAfG44yAtTfjzz3a4XDaUsgBCfn4QTqeN5ctP4tlnjUDQ2PAkRwoPL6y94Js90fxuax8jFBgaLJ68Bi1basHAxFDXPh7h4OOPtQNaaTgcVqZN06FshsaHSGHthdDQov4HpjhT7WKEAkODxmIpzIZoseiLjcm+Vvt89VX5ZhyLBebPr535GOouHv+DJk109IqnOJMn/4FxUKxZjFBgaBTY7VprEBurnRCPJkWv4ejZuxdycsrWBefkKD7/3GgLDIX4lnYWKUyvvGOHFvCd/vVzDVXGCAWGRoOIdmTq0KEwRMpcVGqHmBgIDS3P6VH48Ufo0QP+7//0E6LB4CEoSPsfeBIi7d6tnVhN/YXqxQgFhkZHcDDExelSwbm5RmtQG1xwQfkCWFAQnHaaFtZefBFOPVWnUf7nn9qZoy/+aZdNGua6hcdB0VN/IS1NOyju2QPZ2UZAqApGKDA0SkR0drUOHXSM9JEjxlZZkzRvDqNHK4KDS06IHxxcwK23Kj7+GD7/HPr10xf7N97QtRXuvltf9GuDtWvXsnLlSq8g4MkWuXbt2tqZgKHC+DoohoVpjYFvBENOjolgqCxGKDA0amw2rTFo314/yZrwxZrjnntgyJB0bLYCRFyAIigoH5utgCFD0rnnHt0vJUUXWFq0CC68UOfS/+ADOOssGDUK1q+vuTkqpXA4HKSmpnrrSHjSRzscDqMxqMP4lncOC9Mapx07Cis4mhDHimGEAoMBfRHxTZVswherH4tFeO65OGbMWEvz5odp2vQIZ5/9HTNmrOW55+KwWIr6HHTuDK+8At99B1ddpQW4+fN1zYXhw+HHH6v/Iu/JApmYmFikBLUnfbQp71w/8BUQQkK08+r27dpJ0QgIZWOEAoPBjSfpUYcOJnyxJomIcBIRkUWzZhl067aBiIiynQ06dtTVGJcvh5tv1gLcsmW6GuPgwbogU3V+TjVdgtpQu/iGONrtusSzJwfCv/8aAcEfIxQYDH54whdbtdI2yezsQM+oYeCxza9evRqLRQgKsmG321m9enURG35ptG4NEyfCihXaFBEVBb/9BjfdBH36wHvvVY+Gp7QS1MZ0UP/xlHj25EA4eLCogOBwGAHBCAUGQwmIQLNmWmsQHq61BsYRsersdie6b9KkCTExsSQlJRVprwiRkXDXXVo4ePxxaNtW243HjYOePXVa5SNHjm5+SinmzZvH6tWrSUxMJCoqisTERFavXs28efOMYNCAsFqLCwjbthkNghEKDIYy8DgitmtnHBGrioiQkJBAUlISERFNAK2mT0pKIiEhodLq+dBQuO46+OEHmDoVTjhBJ7d58kk45RR47DEdw340mJDExkVJAkJjNTEYocBgqAAeR0RPHQWT2+Do6Nq1K8nJyUBheefk5GS6du161GMGBcHFF8PixfDuu9Crl/6Mpk3TmoM77oCNGys2logQHx9PbGwsd93VjtTUAjZt2kRsbCzx8fHGr6ARUJqA0FicFAMiFIjIrSKyVURyRWSViJxZRt8ZIqJK2LJ8+vQppU+n2jkjQ2PAU0ehQwftd3DkiA6XM1SctWvXsmrVKubM0TkJlFKsWrWqWnIAiGjfgtmztfPhhRdqB8Q5c3Teg6uu0pEMZV3QlVLk5eWRlZWFy6UdILOzs8nKyiIvL89oDBoZvgJCcLB2UvQNc2yIeRBqXSgQkaHAFOBJoDvwE/CliLQv5ZA7gNZ+2xbgoxL6dvbrt7laJ28woC8ObdroLT9fJ0xpaBeGmsA/B4DHoa8mcgCcfLIOZ/zxR7j+em1q+PZbuPJKOPdc+OijkivviQhBQUHk5+fjdCqUUuTm5pKfn09QUJDRFDRiPAJCRERhmOOOHTrV8t69DSeTYiA0BWOBGUqp6UqpjUqp24HdwC0ldVZKHVZK7fFswDFAR2B6Cd33+vZVSpnM9oYaQUQ/PSQkaMe3jAytVjSUjn8OgHfffbfGcwC0b699C379Fe6/X9dg2LhROyqedppOp3zwYGF/l8vF77//zu7d2WRlheN0Wlm37iR2787m999/x9UQrvqGKuMb5ugp9bxzpxYQ9uyp37UYalUoEJFgIBlY5LdrEdCrgsPcBGxQSv1Uwr6VIrJbRJaISN8qTNVgqBBWa2Fug6AgfXEwJoXSCVQOgMhIuP12+PlnePZZ6NRJOyX+3/9pp8QJEzxplIXFi7szbdooDh1qhtNp4euvz2DatFEsXtwdjy+EweDBV0AID9cCQVpaYbGmzMz6VXhNatNGJiJxwD/AWUqp73zaHwaGK6USyzm+GVqrMF4pNcWnPRHoC/wKBAPXAKPd7/N9CePcDNwMEBsbm/zBBx9U9dS8ZGZmEhERUW3jNUbq8xq6XIWhi5YAuvHm5mYSElI31zA7O5tcH7VKSEgIYWFhtToHpWD16kg+/rgdK1dGASCi6NbtX047bScdOx5GBNq2zSQtLcK7PzpaaNWqVqda76nL38WaRqlC06LFoh8iRPRWGWrimti3b99VSqkU//b6JhTcBjwDxCmlDpTTdwFQoJS6sKx+KSkpyj9RSVVYtmwZffr0qbbxGiP1fQ2dTq2S/vdfHdIYGlr7c9iwYRmdO/ep/TcuA48PwaZNm+jUqRMpKSnFXgfCZr9pE7z+Onz8cXE/g//97zvGj+/tfW23K377TWjWrJYnWY+pi9/FQJCXpzeltKNyZKS+NgQHl39sTVwTRaREoaC2n2X2A04g1q89FthTgeNvAj4uTyBw8wtwXOWmZzBUHV+TgolSKERE2LdvHxERESQnJ3vDESMiIti3b1/AnPg6dYKnn9Y+B0FBRR+SHn/8tCKvrVZdf8FgqCyecs9NmmhNwd69Og/Cli11KxdCrQoFSqk8YBVwrt+uc9FRCKUiIqcCJ1Oyg2FJdEObGgyGgBAcrLPttWunhYLMzPrrfFQdKKWIjo4mKyuLVatWecMRs7KyiI6ODni4X3Z2ceEtKyu4WJ+9e2txUoYGSVCQ9j/wzYXgCXUMdCSDLQDv+SwwS0RWAD+ibf9xwDQAEZkJoJS61u+4m4HNSqll/gOKyJ3ANmAD2qfgauAi4NIamL/BUCnCw3WUwuHD+gfvCW1qbPg6GaamppKamgpQZyoQxsRoda5vrYtbbvmNV17p7tNLmD1bF2kaOFBf0A2GquB7PXC5tLPyoUNamxAWRq2bqmrdFUop9SFwJ/AgsAY4AxiolNru7tLevXkRkSbAMOD1UoYNBiYDa4Hv3WNeoJT6pJqnbzAcFRaLtiF27KiFhCNHSo6Tb+jU5QqEF1xQ3Ev8mGMO+/VSbN8Ot96qQxqff14nsTEYqgNPJENEhBYI8vJ0BIPDUXtZVAPiH62UelkplaCUsiulkn2dDpVSfZRSffz6ZyilIpRST5Uy3lNKqeOUUqFKqSil1JlKqQU1fBoGQ6UJCtK1FOLj9euMjPoVrlRV6nIFwubNYfRoCA4u2QEkOLiAW27RtRWOPVbHo0+erEMa//Mf+P332p2voWEjon2SPEEHtWVOMLUPDIYAEBqqBYPWrfVTQGMotOSbwTAxMZHhw4d7ExnVFcFg3Djh0kv/JTjYhcWi5xMWpggOdnHppf/ywAPCiBGwbBm8/77OjpifryMXBg6EQYP0/9VRwtlgCARGKDAYAoQING2qoxSionTSk4ZcaElEsNvtRXwIPBkO7XZ7nTAhiMDTT8eyerUQHy8EB8Mjjwi//SY8/XSsN75cBHr3hhkzdCrlUaO0puG337TW4JRTdGKkf/4J5NkYDJXHCAUGQ4DxhDAmJGg7YkP2N+jatWsRHwKPYFCVKok1QWSkEBurzT3Dh0Pz5qULLPHx8PDDsHKlDm088UQdYvbii9rv4PrrdSGmxhx5Yqg/GKHAYKgjBAcX9TdoqPkN/DUCdUFD4I+/KaMipo3QUF1wadEi+PRTuOgiLfAtXKjbe/eG117TnuUGQ13FCAUGQx3D42/gW4XRPGXWHmvXrmXlypXMmaM45phCX4iKlncWgVNPhZdeghUr4N57tbC3dSs8+igkJ+uCTL/91vD9SAz1DyMUGAx1EE8Vxg4dtGkhO9uUaK4N/Ms7A1Uq7xwTA3fcoQsxvfEGnHWWzlz30UfaKfH88+Hdd/VnazDUBYxQYDDUYXzzGzRrpkMYG7IzYqDxL+984MCBainvbLPBeefBe+/B998XOiauW6c1CcnJ8MADuqxzRXD6xbH6vzYYjhYjFBgM9QCbTT91dugAISFaOGiozoiBpqYTLHXsqB0TV62CF16AlBT9ec6YAf36wYUXwuzZpQt/7733HjNnzvQKAk6nk5kzZ/Lee+9Vy/wMjRsjFBgM9Qi7XfsatHfn/GyozoiBpLYSLIWEwKWXwuefw+LFMGKENhmtWgV33qm1Bw8/rKs4enA6nTgcDg4ePOgVDGbOnMnBgwdxOBxGY2CoMkYoMBjqIb7OiAUFjS8zYk2hlGLevHmsXr2axMREoqKiSExMZPXq1cybN6/GEiydeKLOlLh6tQ5r7NZN18p44w045xwYMgQ+/BDy8qx069aNkJAQDh48yJQpUzh48CAhISF069YNq9VaI/M7Go4mgsMQeIxQYDDUUzzOiAkJ0KqVdmAzzoj1m7AwHb74xRc6lPHaa3Wa25UrYexY6N5dMXVqGw4ebMsHH1zOhx9ejlKKsLAwCgoK6syN1xPB4ZlPZSM4DIEjEFUSDQZDNWKxaCfEiAhdgvXff3UIo1JQB1MA1GlEhMGDB3sjDuLjw9i+PY2kpKRaL9zUpQv873/w0EMwd66OUli9WvjqqxjgQoKC8ggLyyQ3186RI0ewWq11IueDJ4Jjk9vuERamzS+bNm2iU6dOKKXqxDwNJWM0BQZDA8GTGbFjR/2/iVQ4OupaJcewMBg2DObNg4ULCzjllLXY7bnk5wdz+HAU06bdwqef9uejj7aTnx94BxMRITg4mIiICDZt2sSBAwfYtGkTERERBAcHG4GgjmOEAoOhgREUpKMVOnbUN5SMDG1aMFSMulzJsXNnG02bCgUFNsAFKFwuK3/+2YlZsy6mTx8bL74Iu3cHbo5KKfLy8sjKyiI7OxulIDs7m6ysLPLy8urEOhpKxwgFBkMDxTdtclBQw66pUF34V3L0OBrWlUqOkycrfvjhRJxOG/ry7fvUrdi2TRdiOvVU7Y+wYEHtf+YiQnJyMmFhYe6IiAIcDgdhYWEkJycbTUEdxwgFBkMDJyQE2rXTwoGIFg7y8wM9q7qJfyVHoM5Ucjx0CKZNExyO0iIMBJtNl3O2WGDJErjpJh3aOHEi/PFH7cxTKcX8+fPZt28fwcHB2Gw2goOD2bdvH/Pnzw+4YGUoGyMUGAyNhNBQnd+gXTvtiGhyHJRMXa3k+MUXYLWWfUMNDlace64ObXz4YejUCQ4cgNdf18LCeefBm2/qtpomPz8fEXE7vAr5RhKtFxihwGBoRIhAeLgOY/TkOMjMNDkO/KmLlRz37i3fcTQnR/dr0UKnUv76a21CGDFCR6isW6ejGZKStBZh0aKa0Rp5tAFvvz2I/fubFms31F2MUGAwNEL8cxzk5ZkESHWdmBgIDS1bOAkNFWJiCl+LwMknFyZGeuUVOPts/TkvWADXXafTLE+cCOvXV99cRQSbrWjEu81mqxPClaFsjFBgMDRiLBZo2lTXVGjVChwOozmoq1xwQfmfi9Opqy+WREiIrqswaxb8+itMmADHHQf792vzwoABuvbCtGmQnn708xQRBg0aRJMmbTlyJIyCAuGXX46lSZO2DBo0yAgGdZyACAUicquIbBWRXBFZJSJnltF3hoioErYsv35nucfKFZEtIjK65s/EYGgYeBIgdewI0dGFwoHLFeiZGTw0bw6jR0NoaMkq+NBQxejR+nMsj1at4LbbYOlS7aswcqQef+NGeOwxrT24+mr47LPK57pwuRRjx+5mwoTzOHSoGU6nlW++6c2ECecxduxuXC5jQqjL1LpQICJDgSnAk0B34CfgSxFpX8ohdwCt/bYtwEc+Y3YAFrjH6g78D3hRRC6todMwGBoknlLNHTpo4SA31wgHdYmxY5306PE7VmsBIjpPQVBQPlZrAT16/M7YsZVT8YjoOgtPPKHNC6+/rp0RrVYtMNx2m95/113www8V+x48/bTw+eexFBTYUErfYvLzgygosPH557E8/bTRFNRlApHmeCwwQyk13f36dhE5D7gFGO/fWSl1GDjseS0ipwMdgWt8uo0Gdimlbne/3igiPYB7gI+r/xQMhoaN1aqFg6ZNdZTC/v06bXJYmBYcDIHBZrNywQV/cPrpG3jvvavIzxfGjLGSkfE+zZsLNlu3ox7bbofzz9fbgQM6tfKcOfDbb/DRR3pr3RouvhguuQROOKH4GDpsUpGXV/KtJS/PxrRpilGjpEIaDUPtU6tCgYgEA8nA0367FgG9KjjMTcAGpdRPPm093WP4shAYISJBSikTC2MwHAVGOKh7XHXVVTidTpYs0U/c11xjwekcVq0VEqOitElh5Ej46y/45BO97dwJL7+stxNO0MLBkCE6kgU8YZNlawKsVmH+fBg+vNqma6hGavtn3RKwAv5uLOlAq/IOFpFmwBXAdL9drUoZ0+Z+T4PBUAU8woHH5yAnx5gVAom/AFCTJZOPPRbuvRd++gk+/VT7Gnj8D554Anr0gMsu0wWbduyAnJyyfQZychR799bYdCuFKe9cHKnNRRCROOAf4Cyl1Hc+7Q8Dw5VSieUcfxvwDBCnlDrg0/4n8I5S6r8+bb2Bb919d/uNczNwM0BsbGzyBx98UOVz85CZmUlERES1jdcYMWtYdWpjDZ3OwuRHDVVrkJubSUiI+S76k5cn/PprC775Joaff25Jfr7+AlitLk444QDduqVz4on/Ehzsom3bTNLSCtfQYoG4OK2NCCQ5OTnestMesrOzERFCQ0MDOLPi5OTo33N1/s769u27SimV4t9e2z4F+wEnEOvXHgvsqcDxNwEf+woEbvaUMmaB+z2LoJR6DXgNICUlRfXp06cCb10xli1bRnWO1xgxa1h1amsNnU5tVvCUaw4N1VqFhsKGDcvo3LlPoKdRhLVr1+JwOLxZFz31Gux2e61mXezeHW6+WX/+X36ptQg//mhh/fqWrF9fqKC94Ya1vPFG4bzsdsVvvwXWp6BojYtoUlJS3K/TSExM5MQTA1cVsyTWrVtGjx59CA+v+feqVaFAKZUnIquAc4HZPrvOpRyHQBE5FTgZuLOE3cuBi/3azgVWGn8Cg6Hm8PU5yMyEffsapnBQV1BK4XA4SE1NBfC5mekCTkqpWr+ZNW0KQ4fqLT0d7rxT8f33oJSeh69AYLMVMGqUNeBOhr7lsVNTU73r6al5UZcEgtomENEHzwKzRGQF8CM6ciAOmAYgIjMBlFLX+h13M7BZKbWshDGnAWNE5HngVeB0YCRwZfVP32Aw+GO16vj4Jk10ZsT9+7VpITRUl3E2VA91/WYWG6t9C26++U8WLToGp9NCTEwOe/fqR9yCAhsffqjIztYOit2767DIQLBu3ToAryDlMaWvW7cu4HUuAkmtWwKVUh+in/YfBNYAZwADlVLb3V3auzcvItIEGAa8XsqYW4GBQG/3mA8A/1FKmXBEg6EW8SRB6tBBh68VFGghwdTCqT58b2a+fz3tgUYEBg/exO23v0Xz5oe4//6f6dlzOaec8hstWmSRni68/joMHgw9e2pnxXXrdFRLbeHRuKxevZrs7GyUUmRnZ7N69WocDkejdjgMiAyvlHoZeLmUfX1KaMsAyvT2UUp9CyRVx/wMBkPV8KRPbtJEmxX279fCgd0OwcGBnl39xfdmBhAWFua9mSUlJQXEfFAScXFx7Ny5k4iILGw2F6ef/jNBQUGcemoBVmsKc+fqsETfEMeEBC0oDB4MJ55YuxqEurBmdYUG6jNsMBjqAr6Fl9q21W1Hjug0yoaqU1dvZps2bQJg5Mj5xMRkEBISAkBq6iaSkuDRR3X9hY8/1rkQoqNh2zZ48UXo3x9694annoI//qgZDYKIYLfbSUpKItztvRceHk5SUhJ2u73OrmttYIQCg8FQ4/iWbI6P134GGRmVz6vf2KkvN7NmzZqhlMJisaAU7r+KZj4ehhYLnHaaNh+sWqUzJl59tS77vGULTJkC554LZ51VMwLCSSedVKn2xoIRCgwGQ60SGgrt2mnhIDS0UDhoxGbcSlEfbmatW7cm2G0n8sgpwcHBtG7dusT+ViucfjpMmqRrMHzwgc54GBkJf/9dKCD07q37rF9fte9L0ZDERIYPH05iYiKpqamsXLnS+BQYDAZDbRMSopPY5OXpnPkHD+qbQ0hIw02GVFX8b2a+IYlAnYhA8NVmeOYVHh5OYmJihbQZNhuceabennxSZ1KcP1/nQtiyBV54QW/x8bqc9MCBumhTZU7bM0ffqA1PVEdd0rgEAiMUGAyGgBIcDDEx+qnw8GEtHChlch2URH25mZ100kmsXLmyxPbKYLNp7UDv3lpAWL4cFizQAsL27YVOinFxupDTBRfoss8V+d507doVpRSXXabX7OOPpU4IVYHGCAUGg6FOEBQELVtq4eDIEV2pr6BAaw6CggI9u7qD52bmuXl5BIO6cjPz12aEhWUREtKuytoMXw3C449rR0WPBmHXLnjjDb1FR8OAAVqD0LNn2dEu/vOoK2sYSIySzmAw1Ck8WRI7dNBPgC6XiVjwpy7fzPy1GaAFgYqaDyqC1aqdFD3Cwdy5MHo0tG+vs2q+8w5cdZU2K9x+u9YuZGcXH+fgQUV6OqSl6aRLBw/WLV+CQBRsMpoCg8FQJ7FYdDhjRIR2RPz3X+2UaLNp7UEdug8a/KhNbYbFAsnJenvwQdiwQWsPvvwSUlMLyz6HhOhIhvPOg3794Mkn05kzJxqnE1wu4ZFHFA88oLjssr1Mnhwb8O+Xb40L0ALB8uXLsdvtJCcn19j7GqHAYDDUaUQgLExvDof2OTh82Dgl1nUCoc0QgS5d9DZunI5c+OorLSD89hssXKg3EQVEo1Thlyc7WwBhzpwWxMQo7r03cFKBf42LkBD45Zdf+Pvv9XTp0qVGk1SZn5PBYKg32O3QqhV07AjNm2sNQmZmYQlng8GXY46B227TvgcrV+qcCD17akdWX4HAl/x8G9OmacEzUHg0K54wyQMHDvLHH3/QpUsXevbsWaMClhEKDAZDvcPjlNixoy7C46mxkJcX6JkZ6iqtW+vsiRdfrCNbysLphGefDez3yTeyxENNCwRghAKDwVCP8VRn7NBBp1G2WEwyJEPZ7N0Lubll31gLCnTRpq5d4ZZbtE/CwYO1NEE3nigOX5YvX17jzobGp8BgMNR7PGmUw8MhN1cnQzp8WAsJoaHG78BQSEwMhIQocnJKFwxsNkXLlsKePTqyYe5cLYCecorOrHjuudo0UVP4h3WGhGQRE9Oa9evXAjWrMTA/FYPB0KAICdF+B8cco/Po5+ZqvwNTvtkAOsGRy1V2H6sVvvlGZ1N85BGdglkEfv4ZHntMJ1M64wy978cfq/+7VVJYZ48ePejcuXONJ6kyQoHBYGiQ2GwQFaX9Dlq31uYEY1owNG+ucxoEBZXsnRoUlM/o0dosFR8PN92kizWtXauzJ158sR5j61aYPh2uuAJOOkmPOXu2Dp2tzxjzgcFgaNB48h00aaK1BgcP6mRIxrTQeBk3Tvjrr60sXNgBp9OCUkJQUD5KWejffxvjxh1X7JhmzWDIEL0VFOjKjl9/DYsXw+bNMG+e3kSge3c45xydD6Fz58rn1FBKsW3bNnbv3s2DDyZy221gs/3C77//Qtu2bUlKSqoxbYERCgwGQ6MhJERrDVq21FqDAwe0p7ndXnY6XEPDwuVykpS0hPj4Aj788GpCQ5uRnPwrbdr8RosWNlyujljLKKBgs0GPHnp74AFdh2HJEi0kLF+uKz2uXg2TJ+vomLPP1tuZZ2rhtCIopcjPzycjI4P8/AJWrFiBSJ5xNDQYDIbqJihImxaaN9fpb/fvN9kSGxMWi4Xw8HAcjgPcdtuHhIWFkZ2dTW6uk/DwZlgqqT6Kj4frr9dbVhb88IMWEpYsgT174P339WazaWfFc86Bvn0hMbH071pcXBx//72fw4dDKSgQfvjhOHr0+Iu2bdtWwwqUjhEKDAZDo8Vi0WmUIyK0aeHw4cKkNSEhgZ2boeYQEa6++mpWrlzJ8uXLcbgLa/Tq1avK6ZjDw3VBpgEDtO/Khg2wdKl2XFy5UmsSli/XdRvi4rRw0Levdlws1CII06c3Z+HCETidFlwuK4sXn8OiRf1Yu/YvevWqOanVCAUGg8GAFgJCQnTEQlaWdhhzOrWwYAQEw9Hgm3b59tu1P8t332kBYdkyXd3x3Xf15tEi9OkD27a5WLgwgYKCwlt0fr62b82deywPPeTi8cdrxhnGCAUGg8Hgg82mncqaNoVt27RAkJFhHBMbEp48AKtXr8ZutxMeHk5WVharV68Gjr68c3lERhY6K7pcWovgERBWrSrUIujAwMIvWmZmYe3w/PwgnnlGcc892vxV3QTk6y0it4rIVhHJFZFVInJmOf2DReS/7mMcIrJDRP7js3+kiKgSNiPfGwyGo0JECwBxcTqssUULXZApI8OUcW4I7N69G4CkpCSGDx9OUlJSkfaaxmLRoYx33AGffgrr1sGrr2ptgS7YVMijj/Yq8tpq1eGPNUGtawpEZCgwBbgV+MH990sROVEptaOUwz4A2gI3A5uBWMA/e3U2UCTHlFIqtxqnbjAYGim+jok5OTpqwWgP6i8iQkJCAq1bt/ZqBTxJgmo6OVBpNGsGgwbp8MZffy36/laroqCgsC07W2dbrAkCYT4YC8xQSk13v75dRM4DbgHG+3cWkf7AOcAxSqn97uZtJYyrlFI1tEwGg8Ggb/6edMp5eVowOHhQ+x4EB+vQRkP9oGvXrkVKEHsEg0AIBL7ExEBYmHKXctb8978/MGFCb+/rsDBFq1YNIM2xiAQDycAiv12LgF7FjwDgIuBXYKyIpInIZhF5QUQi/PqFish2d5/5ItK9WidvMBgMPgQHa5NCx466GJPVqoWErKzy0+ga6gb+AkCgBQLQaZidzqJtwcFFv1BOJ1x+ec28v9R0IoQibyYSB/wDnKWU+s6n/WFguFIqsYRjvgL6AEuA/wLNgReBtUqpy9x9egLHA78DTYA7gIHAyUqpzSWMeTPaFEFsbGzyBx98UG3nmJmZSUSEv7xiqAxmDauOWcPqobLrqJQWCArcGXRFTM6D3NxMQkLMd7Ey7NkD+/YVpuNu2zaTtDS9hiJaSxAXV7X36Nu37yqlVIp/e32IPrAACrhKKXUYQETGAAtFJFYpla6UWg4s9xwgIj8Ba4Dbgf/4D6iUeg14DSAlJUX16dOn2ia7bNkyqnO8xohZw6pj1rB6ONp1dLm078HBg1pzYLHoKIYykuQ1WDZsWEbnzn0CPY16RadOLm6++U++/vpYnE4Lkyd/x4QJp+NywaBBm5gzpzNWa80o+mvbPWY/4EQ7CvoSC5TmD7Ab+McjELjZ6P7bvqQDlFJOYCVQPIG1wWAw1DAe34O2bbV5oWVLXUnPFGQyVASr1cL06cfz5JNf0bz5YSwWJ/37f8PLL3/Gxx/XnEAAtSwUKKXygFXAuX67zgV+KuWwH4E4Px+C491/t5d0gGjDUFe0QGEwGAwBIyhIx6d36ADt20NYmNYeZGSYcs6G0rFYLFx55UAiIrKwWl0kJ6/lhhsurXQK5kq/b42OXjLPAiNF5EYROUFEpgBxwDQAEZkpIjN9+r8H/Au8JSKdReR0dEjjHKXUXvcxE0VkgIh0FJFuwBtooWBa7Z2WwWAwlI6IDl9s3VprD1q1KiznnJ1tnBMNRXG5XHz++edcddUnREUdAuCDDz7AVcNflFr3KVBKfSgiLYAHgdbAemCgUsrz1N/er3+miPRDOxf+ChwEPgPu9+nWHO0j0Ao4DPwG9FZKrai5MzEYDIajw5M1sVmzwoRIhw6Z0EaDxiMQ7Ny5k3bt2tGyZSR5eS62bfubDz74gGHDhtWYxiAgjoZKqZeBl0vZ16eEtlSgfxnj3QXcVV3zMxgMhtrCbtdbVFShc2JGhtYshIRoAcLQuLBYLNjtdtq1a8eQIUPYsOE7Lr/8cubN+4CQkJAaNSGYr5vBYDDUAXwTIxUUFBZlysnRUQshISZzYmNi4MCBOJ1OrwBgsVgYOnQo1hoOYTFCgcFgMNQxfM0LubmQmVloXggK0pqFxp7/oKGzdu1aHA6HN/2yUopffvkFu91OcnJyjb2vEQoMBoOhDuMp6RwVpQWEQ4cKzQt2uxYSDA0LpRQOh4PU1FRAf/6//PILf/+9ni5duhRJz1zdGKHAYDAY6gEWiw5nDAvTGoOsrEIBoTEnR2qI+BZoSk1NpV27cPbvP0hychd69uxZo+mYjYXKYDAY6hlWKzRtqvMedOhQNDmSCW9sGPgKBh5qWiAAIxQYDAZDvSY4uDA5Unx8YXlnkz2xfqOUYuXKlUXali9fTk3XKzLmA4PBYGgAeEIYQ0J09cacHDhyRAsHShU6KBrqPh6BIDU1lcTEREJCsoiJac369WuBmtUYGKHAYDAYGhgihf4HMTFaQPB1UAwO1puhbiIi2O12EhMTSUlJYf36b+nRowehoS7sdnuNmhCMUGAwGAwNGP/8B9nZJoKhPtC1a9ciUQYiUis+BUYoMBgMhkaCzaYdFJs21Y6J2dmFGRQtFi0gmAyKdQd/AaCmBQIwQoHBYDA0SoKCChMkGQHB4MF85AaDwdDI8RUQ8vJ0DoSDB7UvghEQGhfmYzYYDAaDF48TYmSkERAaI+ajNRgMBkOJ+AoIDkehicEICA0X83EaDAaDoVw8JZ59NQiHDhUKCMHBJoqhIWCEAoPBYDBUCn8TQ05OoZOiCXOs3xihwGAwGAxHjUdA8I1iOHy4UEAwaZbrF0YoMBgMBkO14BvF4EmUtH27FhA8++12LSwY6iZGKDAYDAZDteNJlBQUBMceW1iLIStLaw+sVi0gWExZvjqFEQoMBoPBUKNYrRARoTeXC3JztfbgyBH92iMgWK2BnqnBCAUGg8FgqDUslqLFmhwOyMzUAkJ2tolkCDQBUdyIyK0islVEckVklYicWU7/YBH5r/sYh4jsEJH/+PW5VET+cO//Q0QurtmzMBgMBkNV8JR7btkSOnaEhASIjtbmhYwMLSw4HMZZsTapdU2BiAwFpgC3Aj+4/34pIicqpXaUctgHQFvgZmAzEAuE+ozZE/gQmAh8AlwCzBaR05VSv9TUuRgMBoOh+vDkQmjeXDsq5ubqSIbsbOOHUFsEwnwwFpihlJrufn27iJwH3AKM9+8sIv2Bc4BjlFL73c3b/LrdCSxVSj3hfv2EiPR1t19ZrbM3GAwGQ41jsxX3Q/CYGZxOY2aoKWpV3hKRYCAZWOS3axHQq5TDLgJ+BcaKSJqIbBaRF0QkwqdPzxLGXFjGmAaDwWCoJ3j8EGJi4JhjtJmhZcuiZobcXGNmqA5qW1PQErAC6X7t6UC/Uo7pCJwBOIBLgebAi0AccJm7T6tSxmxV0oAicjPaFEFsbCzLli2rxCmUTWZmZrWO1xgxa1h1zBpWD2Ydq05trKHLpbUHLldhW0MyMTgcmfzyy7JaOaf6EH1gARRwlVLqMICIjAEWikisUspfGCgXpdRrwGsAKSkpqk+fPtU22WXLllGd4zVGzBpWHbOG1YNZx6pTm2vochUWbjp8WGdYFNEmhuDg+ps0ad26ZfTo0Yfw8Jp/r9oWCvYDTrSjoC+xwJ5SjtkN/OMRCNxsdP9tj9YI7KnkmF5WrVq1X0S2l9evErREn6fh6DFrWHXMGlYPZh2rTgDXUAQsol0Ure7nbEVRnUJ9wNUSXOnVPO/4khprVShQSuWJyCrgXGC2z65zgY9LOexH4HIRiVBKZbrbjnf/9dzMl7vHmOw35k8VmFN0BadfIURkpVIqpTrHbGyYNaw6Zg2rB7OOVcesYdWpzTUMhNXlWWCkiNwoIieIyBS0f8A0ABGZKSIzffq/B/wLvCUinUXkdHRI4xyl1F53nynA2SJyv4h0EpHxQF/g+Vo6J4PBYDAY6j217lOglPpQRFoADwKtgfXAQKWU56m/vV//TBHph3Yu/BU4CHwG3O/T5ycRGQY8DvwX+BsYanIUGAwGg8FQcQLiaKiUehl4uZR9fUpoSwX6lzPmHGBOdcyvirwW6Ak0AMwaVh2zhtWDWceqY9aw6tTaGooygZ0Gg8FgMBgIUO0Dg8FgMBgMdQ8jFBgMBoPBYACMUFBtVLbyY2NDRHqLyFwR+UdElIiM9NsvIvKIiOwSkRwRWSYinf36RIrILBE57N5miUjz2jyPQCEi40XkVxE5IiL7RGSeiHTx62PWsBxE5DYRWetexyMislxELvDZb9awkri/m0pEpvq0mXUsA/faKL9tj8/+gK2fEQqqASms/Pgk0B2dH+FLEWlf5oGNiwh0pMkdQE4J++8F7gZuB04B9gKLRaSJT5/3gCTgPPeWBMyqwTnXJfqgnXN7AWcDBcDXIhLl08esYfmkAfehzzsF+Ab4TES6uvebNawEInIaOmX8Wr9dZh3LJxUdgefZTvLZF7j1U0qZrYob8Asw3a9tM/C/QM+tLm5AJjDS57WgM1c+4NMWCmQAo9yvT0CnIjvdp88Z7rbEQJ9TANYwAp0ddLBZwyqv5QFglFnDSq9bM3T4d19gGTDV3W7Wsfy1ewRYX8q+gK6f0RRUETm6yo+GonRAF6/yrqFSKgf4jsI17IkWJnyzVP4IZNE417kJWtN30P3arGElERGr6PwmEeg1MWtYOV5DJ5Fb6tdu1rFidHSbB7aKyAci0tHdHtD1M0JB1Smr8mOJVRoNxfCsU1lr2ArYp9wiMYD7/700znWeAqxBp/gGs4YVRkROEpFMdOXVacDFSql1mDWsMCJyE3AsOgmdP2Ydy+cXYCRa7X8T+px/Ep3YL6DrVx+qJBoMBh9E5Fm0qvAMpZQz0POph6QC3dDq78uAt0WkTwDnU68QkUS0/9QZSqn8QM+nPqKU+tL3tYj8DGwBRgA/B2RSboymoOocTeVHQ1E861TWGu4BokUKi5+6/4+hEa2ziDwHXAmcrZTa4rPLrGEFUUrlKaX+UkqtUkqNR2tc7sKsYUXpidaQbhCRAhEpAM4CbnX//6+7n1nHCqJ0sb8NwHEE+HtohIIqopTKAzyVH32pUJVGAwBb0V9k7xqKSAhwJoVruBxt++3pc1xPIJxGss6ii4d5BIJNfrvNGh49FsCOWcOK8hnaU76bz7YS+MD9/5+YdawU7vXphHYwDOz3MNBemA1hA4YCecCNaK/QKWgnkPhAz62ubO4vcDf3lg087P6/vXv/fcBh4BKgC/oCswto4jPGl8A695e/p/v/eYE+t1pav5eAI+hwxFY+W4RPH7OG5a/j/6EvrgnoG9v/ABdwvlnDKq3rMtzRB2YdK7ReT6O1Kx2AHsB89+87PtDrF/DFaSgbcCuwDe28tAroHeg51aUNHWevSthmuPcLOkxnN5ALfAt08RsjEnjH/eM54v6/eaDPrZbWr6S1U8AjPn3MGpa/jjOA7e7f6V7ga2CAWcMqr6u/UGDWsez18tzk84B/gI+BE+vC+pmCSAaDwWAwGADjU2AwGAwGg8GNEQoMBoPBYDAARigwGAwGg8HgxggFBoPBYDAYACMUGAwGg8FgcGOEAoPBYDAYDIARCgyGOouI9BSRj9yV1PJE5F8RWSwiI0TE6u4zUkSUiCT4HLdNRGb4jTVYRNaJSK67f3MRsYjI8yKyW0RcIvJZDZ5Lgvt9R5bTz3M+x9bUXI4WEblIRMaW0N7HPed+gZiXwVCdmIJIBkMdRETuBJ4FvkFnN9uOTlbSH3gFOAR8XsrhF6OTmXjGsgHvotOf3oZOmJKBLgZ0B3A3Om3qv8VGMvhyEdAP/bkYDA0SIxQYDHUMEemNvvFMVUr9x2/35+4qieGlHa+U+s2vqQ3QBPhIKfWdz/uc4P73eaWUqxrmbVdKOao6jsFgCBzGfGAw1D3uAw4A95a0Uyn1t1JqbWkH+5oPROQRdPptgDfcau5lIrINnUYVwOmr2heR1iIyU0T2i4hDRNaKyNV+7+FR8/cWkdkicghdIx4RCRORl93mjkwRmQu0PYp1KBURuVlEfnebQ/aLyBsiEuXXR4nI4yLyHxHZKiIZIvKtiHT262d199stItki8o2IdHIf/4i7zwx0Wds27nblXkNfwkRkqns++0XkHRFpXp3nbTDUNEZTYDDUIdy+An2Bz5RSudUw5OvAemA28DjwBdq0YAf+A4yksNLa3yISjs6zHglMAHYCVwOzRCRMKfWa3/jvAu+jTRGe68mr6CJhjwK/oqu9vVcN5wKAiPwf2uTxAjAOrQl5HOgiIr2UUk6f7lcDqWgzSTAwGa1t6aSUKnD3edR9rpPRtRCSgbl+b/sYEA2cAlzobvPXikxBF7a5CkgEnkKXVR9RlfM1GGoTIxQYDHWLlkAo2oegyiil0kRkjfvl30qpnz37ROQfdx/ftjHomu59lVLL3M1fikgs8LiIvOF3052jlLrX5/hE9E3xAaXU/7mbF4lIBDC6qufjdqgcBzyqlPqvT/ufwA/AYHRpXw/5wCClVL67H2gB6VTgJxGJBO4Epiml7nMfs1hE8oBnPIMopf4WkX1Anu96+fGdUup29/+L3Gtxo4iMVKbIjKGeYMwHBoPBl97APz4CgYd30E/KJ/q1f+r3ugf6uvKRX/sH1TS/c93jvysiNs+GNl1koOfvy2KPQOBmnftve/ffk9D+GbP9jptzFHP7wu/1OrRGJvYoxjIYAoLRFBgMdYt/gRwgPkDvH4Uu1+rPHp/9vvj3be3+m+7X7v/6aIlx//2rlP0t/F4f8HvtUfmHuP965rvXr9/RzLe89zIY6jxGKDAY6hBKqQIRWQacGyBv/gNoe7g/rXz2++KvFvcICbHAFp/26npa9oRN9gcOlrG/onjmGwNs8Gk3T/eGRokxHxgMdY//Qz/xPlXSThHpICJda+i9vwXaisjpfu1XoZ+m/yjn+F8AF3CFX/uw6pkei93jt1dKrSxh21rJ8dYBWcDlfu3+r0E/+YdWfsoGQ/3BaAoMhjqGUuo7d+a8Z0XkRGAGsAMdEXAOcCP6Jl1qWGIVmIH21P9ERB4A0oDhaFv+KD8nw5Lmnvr/7dyxS1ZhFMfx788/IKJd6A9oaikabIuwtTUIGiSEQGgol8BBFByEGh2jobUxMqJaoi0sotGlTUSDdzsO5wYWDb5BJr7fz3h5uM+z3R/nPuckeQYsJZmiuw+uAbNjnuN6ku+/PdutqpdJVoEnw0W+N8AImB7OuFFVr4+6SVXtJFkHFpPs0d0HF4E7w5LD8xs+A+eS3AU+AqOq+oR0ihgKpBOoqtaTfAAWgDW6K2GP/hjNAS/+0b4/klylqxQr9NCjr8Ctqnp6xNfMAfvAfboNcJMOMe/GOMrjPzzbAi5U1WKSL/R0xnn6F8Y28Ar4NsYePz0CQgeBe3S14zbwHtg9tG4DuAwsA2fpDpHzf7GfdGLFThlJ+lWSm3RHwkxVvf3f55GOi6FA0kRLcgm4QVcIRvTwogd0heSKMwY0Sfx9IGnS7dPzDeaBM/SFyufAQwOBJo2VAkmSBNiSKEmSBoYCSZIEGAokSdLAUCBJkgBDgSRJGhgKJEkSAAd1obkCrwhNwwAAAABJRU5ErkJggg==\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -348,7 +348,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf0AAAFGCAYAAABgwUY+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAACAkUlEQVR4nO3dd3iUVdrA4d+ZSTKplFASQgcFhKBCIhCU5mJFxbaKFVwbdtcuFuxrd1nLIrqKBexYPxsWEKQmgBCaSA+9k15mnu+Pk5nMpIdUyHNf13tl5m1z5hDyvKcbEUEppZRSRz5HfSdAKaWUUnVDg75SSinVSGjQV0oppRoJDfpKKaVUI6FBXymllGokNOgrpZRSjURQfSegNrVs2VI6depUY/fLzMwkIiKixu7XGGke1gzNx+rTPKw+zcOaUdP5mJKSsltEWpV27IgO+p06dSI5ObnG7jdjxgyGDh1aY/drjDQPa4bmY/VpHlaf5mHNqOl8NMZsLOuYVu8rpZRSjYQGfaWUUqqR0KCvlFJKNRIa9JVSSqlGQoO+Ukop1Uho0FdKKaUaCQ36SimlVCNxRI/TV6q+nH322Wzbtq3W7p+Tk0NoaGit3b8x0DysvoaQh23atOHrr7+u1zQcTjToK1ULtm3bVqMTQxWXnp5OVFRUrd2/MdA8rL6GkIeJiYn1+vmHG63eV0oppRoJDfpKKaVUI6FBXymllGokNOgrpZRSjYQG/SrKz6/vFChVN37++WcGDhxIVFQUsbGx3HvvvRQUFJR7zY4dOxgzZgxxcXGEh4dz+umns2bNGt/xvXv3csstt9CjRw/CwsJo3749N9xwA3v27Am4z59//sm5555Ly5YtiYqKYsCAAXz//fc18r1ee+01OnfuTKtWrUhISGDWrFkBxydNmsSwYcNo1qwZxhg2bNhQI59bluuvvx5jDM8//3yF586cOZOEhARCQ0Pp0qULEydODDj+yCOPYIwJ2GJjYwPOKX7cu910003V/i7Lli1jyJAhhIWF0bZtWx577DFEpNRzP/jgA4wxnHXWWdX+XFV5dR70jTGDjTFfGWO2GGPEGDOmEtf0NsbMNMZkF173sDHG1EFyA4jAtm3g8dT1JytVt/744w/OPPNMTjnlFBYvXsxHH33EV199xX333VfmNSLCueeey5o1a/jiiy9YvHgxHTt2ZPjw4WRmZgKwdetWtmzZwrPPPsuyZct4//33+e2337jkkksC7nXWWWeRk5PDzz//zOLFiznppJMYOXIka9eurdb3+uijj7jtttsYN24cs2fPZuDAgZxxxhls2rTJd05WVhannnoqjzzySKXve6gPB59++ikLFiwgLi6uwnPXr1/PmWeeycCBA1m8eDH3338/t9xyC5999lnAed27d2fbtm2+bdmyZQHH/Y9t27bNN9ztoosuqnL6/R08eJBTTjmFmJgYFi5cyIQJE3juued48cUXS5y7bt067r77bgYNGlStz1SHQETqdAPOBJ4CLgSygDEVnN8E2A58DMQXXpcO3FnRZyUkJEhN+uWXXyU1VWTfvhq9baPy66+/1ncS6sSh/u5lZGTItddeK02aNJEWLVrIuHHjJD09XcLDw2XDhg2+8w4ePFhTSS3V/fffL8cff3zAvq+++kpCQ0PL/OzVq1cLIEuWLPHtc7vd0qpVK3njjTfK/Kz/+7//E2OMHDhwQEREdu3aJYD88ssvvnPy8/PF4XDIJ5984tu3fPlyOfPMMyUyMlJatWolo0aNkm3btpX7vfr16yfXXHONiBTl4VFHHSX33XdfiXMXLlwogKxfv77ce4pIpc/zt2HDBomLi5MVK1ZIx44d5bnnniv3/HvuuUeOOuqogH1XX321DBgwwPd+/Pjx0qtXryql45prrpFu3boF7MvNzZV77rlH2rZtK2FhYZKYmCjff/99iWv9fxdee+01iYqKkqysLN++xx9/XOLi4sTj8fj25eXlSb9+/WTy5MkyevRoGTFiRJXSW1xN/52vDzX9dxFIljLiYp2X9EXkWxEZJyKfApUpM18GhAOjRSS18LpngDvqo7TvcMCuXeB21/Unq8bgH//4B7/88gs//fQTH3zwARMmTODmm2+mR48edOzYsczrzjjjDCIjI8vdqiI3N7fEpCthYWHk5OSQkpJS5jVAwHUOhwOXy8Xs2bPL/KyDBw/icrkIDw8HoEWLFhxzzDG89957ZGRk4Ha7mTRpElFRUZx44omALa0OHjyY+Ph4FixYwE8//URGRgYjR47EU0ZVXF5eHikpKZx66qkB+0899VTmzJlTQY7UrIKCAi655BIefPBBjjnmmEpdM3fu3BJpP+2000hOTibfr91x3bp1xMXF0blzZ0aNGsW6devKvGdGRgYffvgh1157bcD+q666ipkzZzJ16lRSU1MZPXo0Z599Nn/88Ue56Rs0aBBhYWEB6du6dWtALcgDDzxAp06dGD16dKW+t6pZh8PkPEnALBHJ9tv3A/A40AlYXxeJ2LPHw+7d8MUX0KoVXHSRh27dtEuEqjm7d+/mk08+4Z133uGEE04AbJXr22+/zeOPP17utW+++SbZ2dnlnlMVp512Gi+99BLvv/8+o0aNYseOHTz22GMAZc402KNHDzp06MC4ceN44403iIyM5KWXXiItLa3Ma/bv389DDz3EtddeS1CQ/XNkjGH69Omcd955NGnSBIfDQXR0NN999x1t2rQB4L///S/HHXcczzzzjO9e7777LtHR0SQnJ9OvX78Sn7V7927cbjcxMTEB+2NiYvjpp5+qlD+9evVi48aNJfZ5yyEdO3Zk+fLlZV4/fvx4WrZsyQ033FDpz9y+fTvDhw8P2BcTE0NBQQG7d++mTZs29O/fn8mTJ9OjRw927tzJE088wcCBA1m+fDktWrQocc+pU6eSl5cXEIDXrl3LBx98wIYNG+jQoQMAN998Mz/99BOvv/46r732Wpnpa9euXYn0eY917tyZH3/8kY8//pglS5ZU+nurmnU4BP1YIK3Yvh1+xwKCvjHmOuA6sL9wM2bMqHYC1q3LYf/+UNq1y6BDhxk4HPDNN9C0aQ5du+o0nlWRkZFRI/8mDV1OTg7p6elVuuaPP/5AROjdu7fv2uOOOw6wQdj/fm63O+B9kyZNaNKkSbn3r0p6kpKSePLJJ7npppsYM2YMLpeLe+65h1mzZpGbm1vmvd577z1uvvlmWrRogdPpZOjQoZxyyil4PJ4S12RkZHDBBRcQGxvLQw895DsuIlx33XU0bdqUH374gdDQUN555x3OP/98ZsyYQVxcHPPnz+e3334rtQYjNTWVffv2ccEFF/j2/fvf/2bw4MGAbbNPT0/35WFubm6p6fP2Q8jIyChx7OOPPw4oXffp04dPP/3U91ASHBxcZh7NmjWLt99+m99//z3gO5eXrwAej6fEOVlZWQFpPOmkk3zHOnfuzAcffMCxxx7LpEmTuPnmm0vcc+LEiYwYMYLQ0FDffX///XdEhJ49ewacm5uby+DBg0lPT6dfv35s3rwZsL8r06ZNo6CggPz8/ID0ZWRk+PJy/fr1jB49mrfeegun00l6ejr5+fkUFBRU+f+Kv5ycnMP+b0qd/l0sq96/LjYgg4rb9H8E3iq2rwMgQFJ519ZEW88DD7glODhXQOT5538V253PbkFBefLAA+5qf0Zjom36ZVu0aJEAsnHjRt++zz//XJo3b17i3OLt6qeffrpERESUux0Kj8cjW7ZskaysLFmxYoUAsmDBggqv279/v+zcuVNEbDv6jTfeGHA8PT1dBg0aJCeddJKkp6cHHPvpp5/EGCP7inWeOeqoo+Txxx/3fd+RI0fKmjVrSmwHDx6UrKysEvtyc3PF6XTKxx9/LCJFeXjjjTfK4MGDS3yH2mrTHz9+vBhjxOl0+jZAHA6HtG3btszrBg0aVCIfP/74YwkKCpK8vLwyrxs6dKiMHTu2xP7FixcLID/++GPA/g8//FCMMbJixYoSeZuWliYitj/CmjVrZPHixb59V1xxhZx55pkB91qwYIEAsm7dOvn1118FCPjehZ25xel0yqpVq8rPuDJom35JlNOmfziU9LcDMcX2xfgdqzX79sELLxjy80NKPV5QEMwLLwh33QXNmtVmSlRj0LlzZxwOB2vWrPFVq3711Vfs27ePAwcO0LRp0zKvrenqfS9jjK9n+QcffED79u3p27dvhdd507pmzRqSk5MDmifS09M544wzEBG+//77EqV1b+nV4QhsPnM4HL72+r59+/Lxxx/TsWNHgoODS03DUUcdVWJfQkIC06dP5+9//7tv3/Tp0wNqBWrbjTfeyIUXXhiw77TTTuOSSy4p0bbuLykpic8//zxg3/Tp00lMTCwzD3Jycli1ahXDhg0rcWzSpEl07ty5RJNBnz59EBG2b99e6nWAr3+J/9z7SUlJ3HvvvQGL8EyfPp24uDg6depE69atS4wkePDBB9m3bx+vvvoqnTt3LvO7qxpU1tNAXWxUrqR/A3AQCPXbNw7YApjyrq3uE+CkSSIRER5fyT4hYVtASR9EwsM9MmlStT6mUdGSfvkuvPBCOfnkkyUzM1NWrVolUVFREhcXJ++9917AebXde19E5Nlnn5WlS5dKamqqPPbYYxIcHCyff/6573haWpp0795dpk2b5tv38ccfyy+//CJr166VL774Qjp27Cjnn39+QLoHDBggPXv2lD///FO2bdvm23Jzc0XE9t5v0aKFnH/++bJkyRJZvXq13HXXXRIUFCQpKSkiIrJlyxZp1aqVnHfeeTJv3jxZu3atTJ8+Xa699tpy8+bDDz+U4OBgeeONN2ThwoVy6623SkRERMDIiG3btsnixYtlypQpAsj//d//yeLFi2XPnj2+c3bu3BmQ9uKbt5ajskrrvX/FFVfIFVdc4Xu/bt06CQ8Pl9tuu01WrFghb7zxhgQHB8unn37qO+fOO++UGTNmyLp162TevHkyYsQIiYqKCvh+IiKZmZnSpEkTeeKJJ0pNz2WXXSYdOnSQTz75RNauXSsLFy6U5557Tj777LOA8/zzev/+/RITEyMXX3yxLFu2TD777DOJioqS559/vszvrb33rbos6ddHoI8Eji/csoCHC193KDz+L+Bnv/ObYkv0H2KH7J1f+BBQ60P2HntMxBhPiUDvvxnjkYceqtbHNCoa9Mu3Y8cOOffccyU6Olqio6PlhRdekG+//Vbi4uJk/PjxvvPqIugPGzZMmjZtKqGhodK/f3/59ttvA46vX79eAHn77bd9+yZMmCDt2rWT4OBg6dChgzz44IO+YC4ivire0jb/342FCxfKqaeeKtHR0RIVFSX9+vWTb775JuDz//zzT7ngggukWbNmEhoaKt26dZObb7454PNK8+qrr0rHjh0lJCRE+vbtKzNnzgw4Pn78+FLT5/89O3bsWOb3AKRjx46Vy2S/+xUP+kOGDJEhQ4YE7JsxY4b06dNHQkJCpFOnTvLf//434PjFF18sbdq0keDgYImLi5Pzzz9fli9fXuLz3nrrLXE6nbJly5ZS05OXlyfjx4+Xzp07S3BwsMTExMjZZ58tycnJAecV/z1cunSpDBo0SFwul8TGxsojjzwSMFyvOA361pEe9IeW8R9lcuHxycCGYtf0Bn4DcoBtwPiKSvlSCyX9tm0Plgj6YWEeeeopkXJ+r5UfDfo1oy6C/pFO87D6GkIeatAvqbygXx/j9GeIiCllG1N4fIyIdCp2zTIRGSwioSLSRkQeLfxiterCCwPH459xRsnRgR4PDB8O1eh8qpRSStUJHWhejubN4a67IDg4D4Du3fcGHA8KymfsWIiJsRP26PS8SimlGjIN+hV49FE466w1BAXl43B4WyIAhCFDNnDXXRAUZGsE9u+vx4QqpZRSFdCgXwFjYNSo5Tz88Ou0bp3HrbdC+/ZZgMHhMHgnAg4Ph927dRU+pZRSDdfhME6/Xhlj6Nq1K+3atSM3N49+/Qynnx7GmWfCb791YccOQ2ysnZPf4YC9e211v1JKKdXQaEm/EhISEkhKSvK9P+44wxlnCLm5Dv7zn6LzwsLshD45OfWQSNXgjRkzptR1zAcMGOA7p1OnTr794eHhxMfHM2nSpID75OXlMWHCBPr06UN4eDjR0dEMGDCA119/3bfoTV2YOXMmAwcOpEWLFoSFhdGjR49KrQkP8MMPP5CUlER4eDjNmjXj5JNPDji+adMmzj77bCIiImjZsiW33noreXl5Aefk5eXx8MMP07lzZ1wuFx06dOA//v8hD9G+ffu44ooraNq0KU2bNuWKK65gv1/b3YoVKxg2bBgxMTG+de3HjRtXIn3V8ccff3DJJZfQvn17wsLC6N69O88++2yZiwl5iQiPPPIIcXFxhIWFMXTo0DLXAMjJyeG4447DGENycrJv/65duzjttNOIi4vD5XLRvn17brrpJg4cOFDt71UT6VPVo0G/koov6HfPPQaHA6ZMgfXrveeAywU7d9oBfUoVN3z48BLrmX/77bcB5zz88MNs27aNpUuXcu6553L99dfz0UcfATbQnXbaaTz//PNcddVV/P7776SkpHDHHXfw9ttvM3fu3Dr7LpGRkdx666389ttvrFixggcffJDx48eXuSCL1xdffMGoUaO44oorWLx4MXPnzuXqq6/2HXe73YwYMYL09HRmzZrFBx98wKeffsqdd94ZcJ9Ro0bx/fffM2nSJFavXs0nn3zCscceW+3vdemll7Jo0SK+//57vv/+exYtWsQVV1zhOx4SEsLo0aP58ccfWb16Nf/+97/53//+x4MPPljmPSdPnszQoUMrnYaUlBRatWrFe++9x/Lly3n00Ud5/PHHefrpp8u97tlnn+WFF17g5ZdfZuHChbRu3ZpTTjml1Lnt77rrrhIL5ICd+fC8887j66+/5s8//2Ty5Mn8/PPP5c4WWFk1kT5VTWWN5TsStpoev/nLL7/KqlUiW7bY7eKL7Vj9c84p2rdli8iqVSINYPhqg9SYx+lXZiKS0iZpOfroo2XUqFEiIvLMM8+IMUZmzJhR4lq32+1bk76+nHfeeb60lqagoEDat28vk8qZxvLbb78VY4xs2rTJt++9994Tl8vl+34//PCDNGnSRHbt2lVuet566y055phjxOVyydFHHy0vvviiuN12vYzSxph71xeYPXu2b9+sWbMEKHdu+H/+858B69oX9/bbb5eYaKeq7r77bunbt2+Zxz0ej8TGxgbMspeVlSWRkZEyceLEgHO/+OIL6dmzp+/7Lly4sNzPnjBhgsTGxgbs+/333+XEE0+UsLAwiYuLk7Fjx5b7+1db6dNx+iXRkMbpH86MgdBQ8Nbi3Xmnff/VV+C/UmRYmC3t6xA+VRNCQ0N9K7pNmTKF4cOHlzr/vcPhKHelvcjIyHK3M844o1rpXLx4MXPmzGHIkCFlnpOSksLmzZsJCQmhb9++xMbGcuqpp7J48WLfOXPnzuWYY46hffv2vn2nnXYaubm5pKSkALa24IQTTuDFF1+kXbt2HH300dx6662+Vd0A3njjDcaNG8djjz3GypUreeGFF3jmmWfKrYmYO3cukZGRDBw40LfvxBNPJCIigjlz5pR6zV9//cX3339f7veuCQcPHqR58+ZlHl+/fj3bt2/n1FNP9e0LCwtj8ODBAWlPS0vjhhtuYOrUqYSFhVX4uVu3bmXatGkB32/ZsmWceuqpnHnmmfzxxx9MmzaNJUuW8I9//KPO06eqRjvyVVGrVrB5M4SEQNu28I9/wGuvwZNPwscf2weDoCDbrr9/P0RH13eKVUNS2gIzN910U8C68F4FBQW8//77LFu2zLfu+po1a6pUTeyvojXMD/UPbLt27di1axcFBQWMHz+esWPHlnnuunXrANuE8cILL9C5c2deffVVhg4dyqpVq2jTpg3bt28vseZ9y5YtcTqdbN++3Xef2bNn43K5+Oyzz9i/fz+33HILW7du5dNPPwXg8ccf59lnn/UtbtO5c2fuu+8+XnvttVKXmQW77nurVq0CmvOMMbRu3dr32V4DBw5k0aJF5Obmcu211/LUU0/5js2aNSvgIcq77Kz/v/24ceMYN25c2RnrZ9GiRUyePJkpU6aUeY43fcXzLiYmhi1btgC26eSyyy7jzjvv5LjjjmPDhg1l3u+SSy7hyy+/JDs7m7POOou3337bd+y5557j4osv5pZbbvEtuPPf//6XPn36sHPnTlq3bl3r6VOHRoN+FYWH25J8bq5tv7/pJtuuP2cOzJgB3kWpwsPthD1RUVDGAliqERo8eHCJjnnNii3R+MADD/DII4+Qm5tLSEgId999N9dffz2Ad1rqQ1LaqnM1YdasWWRkZDBv3jzuvfdeOnfuHNAG7s/bEe2BBx7wBeNJkybx008/8e6773LvvfdW6jM9Hg/GGKZOnepb0e+VV17htNNOY8eOHTgcDjZv3sz111/ve2ACG3y9eXj77bf7+koAAbUElfHRRx+Rnp7OH3/8wd13380zzzzD/fffD0BiYmLAQ9a0adP47LPPAoJ2dCVLBKtXr2bEiBHcfvvt1V4N8KmnniIkJIQ77rijwnNfeuklxo8fz59//sn999/P7bffzuuvvw7YGpu//vorIP+8+bp27VqmT5/u+50F+O6773A6nTWaPnVoNOgfgpYtYdMmG/SbNYNbboEnnrCl/SFDiobvBQXZsfsxMZ6AZUI9Hk+JZUNV4xAeHl5h8L3jjju4+uqrCQ8Pp02bNgGlzm7durFy5cpD+uziNQzFDRo0iO+++67K9/Uuidq7d2927NjBI488UmbQb9OmDQA9e/b07QsKCuLoo49m06ZNAMTGxvL7778HXLd7927cbjexsbG++7Rt2zZgueFjjjkGsD3/vUsTT5w4MaCq3t8DDzzgC9JesbGx7Nq1CxHx5buIsHPnTt9ne3mbH3r27Inb7eaaa67h7rvvJigoiLCwsIB/59atW5fYVxneZXFHjRpVYSc+b/p27Njh+/7e995jP//8M7NmzSqxFO+AAQO4+OKLAx5KYmNjiY2NpUePHkRHRzNo0CAefPBB2rdvj8fj4ZprruHaa68t8XvVtm1b4uPj6d+/f8C+bdu21Wj61KHRoH8IwsPt5i3tX3UVvPUWrFwJn38O3ofxsDD45JMfiYrax+jRf/etB/7hhx8SGhrK+eefX79fRDVILVq0KDM4XHrppdx///0sWrSoRBuyx+MhIyOjzHb92qreL56G8oYNJiQk4HK5WL16NSeddJLvmrVr13LaaacBdl32J554grS0NF/v7enTp+NyuUhISABsO/snn3xCRkaGL+j8+eefgF3rvXXr1sTFxbF27VquvPLKUtPSqlUrX9W0V1JSEhkZGcydO9f3sDB37lwyMzPLfHjwfoeCggLcbjdBQTXzZ3XFihWcfPLJXHTRRbz00ksVnt+5c2diY2OZPn06J5xwAmCHvc2aNYvnnnsOgLfffpvMzEzfNVu3buW0005jypQpnHjiiWXe21tD4/237du3L8uXL6dr164l8tCr+P7aTJ+qgrJ6+B0JW0336vTvYZmVJbJyZVGP/RdflMKV+ETWrrX7Nm92y4QJn8udd74s7703Rdxut0yZMkWefPJJmTJliq8XcWPS2HvvDx8+vNy110vrve8vJydHBg0aJM2aNZMJEybI4sWLZd26dfLZZ59JUlJSnebvf/7zH/n666/lzz//lD///FPefPNNiYqKknvvvdd3zrRp06R79+6Slpbm23fbbbdJ27Zt5fvvv5dVq1bJzTffLE2aNJGtW7eKiO3hHx8fL8OGDZNFixbJ9OnTJS4uTm6++WbfPdLT06Vdu3Zy4YUXSmpqqsyePVt69eolF154oe+cN954Q0JDQ+XFF1+UVatWybJly+Sdd96Rp556SkTKXiHu9NNPl/j4eJkzZ47MmTNH4uPj5ayzzvIdf/fdd+Xjjz+WlStXytq1a+Wjjz6SuLg4ufjii33n5Obmlvh3Lr6lp6eXmbepqanSunVrufjii0tc55WWlibdu3eXadOm+fY9/fTT0qRJE/nss89k2bJlvqV2y/qu3uWR/XvHf/311zJ58mRZtmyZrF+/Xr755hs55phjAkYn/PHHHxIWFib/+Mc/ZNGiRbJmzRr5+uuv5brrrivzO9VU+orT3vsl0ZCW1q3LrTaDvojIxo0i69bZAL9pk8gxx9gcHTeu6GFg82a3PPfcV/LAA8/Lk08+2agDvogGfUpZVrpt27a+cyoK+iI28D/66KNy7LHHSmhoqDRr1kz69+8vEydOrHAt+Zr00ksvSc+ePSU8PFyaNGkiffr0kVdffTXgd/vtt98WQNavX+/bl5eXJ3fffbfExMRIVFSUDBkyRFJSUgLuvXHjRhkxYoSEhYVJdHS03HLLLZKTkxNwzqpVq+SUU07xDRm78cYbSwSPqVOnSp8+fcTlckmzZs3kxBNPlA8++EBEyg76e/fulcsuu0yioqIkKipKLrvsMtm3b1+Je0ZGRkpERIT07NlTnnzyScnKyvKd8+uvv5b6b+2/jR8/vsy8HT9+fJnXeXkD4ttvv+3b5/F4ZPz48RIbGysul0sGDx4sy5YtK/NzSguq06dPlwEDBkjTpk0lNDRUjj76aLnnnntk7969AdcuXLhQ/va3v0lUVJSEh4dLfHy8PPTQQ2V+Vk2lrzgN+iWVF/SNPX5kSkxMlJqcyWnGjBkBPaezs23bvrcW67ff4JJLIDISfv/dtv0DFBR4+Pe/X6d58wM4nR7uu+++RtumXzwPj1SJiYm1OotYenp6mdWqqnI0D6uvIeRhbf9fqws1/XfRGJMiIomlHWuckaeGhIXZtn3vtLuDB8PJJ0NGBrzwgt3n8Xj4+usvASEz07aZfvjhhxVOp6mUUkrVNA361dSqVeDKeg89BE4nvP8+rFrl4csvv2Tz5s107dqGK6+8hbi4rmzYsEEDv1JKqTqnQb+aQkNtdX52tn3frRtcdpmdje/JJx2+BStGjhxJeLiDwYP/TocOnQgNDW20VfxKKaXqh0adGtCyJRQUFL2/807bzv/LLxAZeSYjR47k7393cMklkJ/v4IwzRulwPaWUUnVOg34NcLmgadOi0n7LlnbCHoDHHgO3u2hylYgI2LXLUIOrcCpVrjFjxnDWWWfVdzIOW/Hx8TzyyCP1nQylaoQG/RoSHW1L+97BEFdfDe3b2wl7HnlkMzt2CGlpMHWqMGfOEn7+eWn9JlgdUcaMGYMxpsS2ZMkSJkyYwPvvv+87d+jQoWXOPa8ajtdee43OnTsTGhpKQkICs2bNKvf8bdu2cemll9KjRw+cTidjxowpcc7y5cu58MIL6dKlC8aYUh9m0tPTuf322+nYsSNhYWEMHDiQhQsXBpyzY8cOxowZQ7du3QgPD+f0009nzZo11fm6qo5o0K8hISHQvHlRaT80FB580D4BTJ7cnvXrIS1NePhhD9df35t//cvBgQNH7nBJVfeGDx/Otm3bArb4+HiaNm1aYn7/xibvMKta++ijj7jtttsYN24cixcvZuDAgZxxxhm+qYpLk5ubS8uWLbnvvvsCpsD1l5WVRadOnXjiiSd80ycXd8011/DDDz/wzjvv+FbTGz58uG9RHBHh3HPPZc2aNUydOpXFixfTsWNHhg8fHjCbnmqgyhrAfyRstT05T3F5eSKrVomkpdmJeW65xS3GuMWW/wO34OB8ufFGtxQU1GgSG7zGPDlPTSo+sczo0aNlxIgRpZ7rf6y0CYL8J87xGjNmjLRs2VKefPJJ375169ZJcHCwvPfee2Wm67PPPpPevXtLaGioNG/eXAYPHizbt2/3HX/mmWckJiZGIiIi5IorrpDx48dLx44dy/0e48ePl169evneL1iwQE455RRp0aKFREVFyYknnihz5swJuAaQV155Rc477zwJDw+XO++8U0REvvrqK+nbt6+4XC7p2LGjjBs3LmBCox07dsg555wjoaGh0qFDB/nf//4nvXr1KncindrQr18/ueaaawL2HXXUUXLfffdV6voRI0bI6NGjyz2ntO+VlZUlTqdTvvjii4D9ffv2lQceeEBERFavXi2ALFmyxPd76Ha7pVWrVvLGG29UKn01SSfnKYlyJufRkn4NCg6GFi0gK8suqztpkgOR0rM4Pz+I//3Pwfr1dZtG1bhNmDCBpKQkrrrqKl9tgP+69V4vvvgi//rXv3jooYdYvXo1YJfD7d69O5deemmp996+fTujRo1i9OjRrFy5kt9++y1g4Z2PP/6YBx98kEcffZRFixbRvXt3XnzxxSp/h/T0dK644gpmzZrFggULOP744znzzDPZs2dPwHmPPvooZ555JsuWLeOmm27ihx9+4LLLLuPmm29m+fLlvPrqq3z66acBy9uOGTOGv/76i59++okvvviCd999t8LlXWfNmkVkZGS5m/+yuxXJy8sjJSUlYN15gFNPPTVg3fna4F0/IDQ0NGB/WFgYs2fPBorm3/c/x+GwI5W856iGSxfcqWHNm8O+ffD11+B0CmDKPNfpFKZONdxzj20OUKo6vv/++4AVz0pbNa9p06aEhIQQHh5eYtU4f82bN+eaa67h008/5d133+WSSy5h6tSpTJs2rcyhplu3biU/P58LL7yQjh07ArYTnNe///1vRo8e7Vty9YEHHuDXX3/lr7/+qtL3PPnkkwPev/zyy3z22Wd89913XH755b79F198Mddcc43v/ejRo7n77ru56qqrALvy3TPPPMPll1/Oc889x5o1a/juu++YPXu2b3GXd955hy5dupSbnuLL6JamssvoQtGKgqWtO//TTz9V+j6HIioqyrfgUXx8PLGxsXzwwQfMnTvXtwhUjx496NChA+PGjePFF1/E5XLx0ksvkZaW5ltJTzVcGvRrmNMJrVvD1q1F7ftlyc62NQLbt0OHDnY5XqUO1eDBg5k0aZLvfU2smnfllVdy//33s2zZMk444QRGjhwJwJQpU0qslz5w4ECGDx9OfHy8rx34wgsvpFWrVgCsXLkyIAiDXdWuqkF/586dPPTQQ/z666/s2LEDt9tNdnZ2ifbuxMTAWUhTUlJYsGABzzzzjG+fx+MhOzub7du3s3LlShwOB/369fMd79ixI3FxceWm51CWzG3I3nvvPf7xj3/Qrl07nE4nffv25ZJLLiElJQWA4OBgpk2bxtVXX02nTp1wOp0MHz6cM844AzmCp3U/UmjQrwVRURATY0vv5QX+0FBo0wby8mzwr0JhQKkSwsPDazz4nHvuuYwdO5avv/46oJR5zjnnlFgv3el08uOPPzJv3jx+/PFH/ve//3H//fczc+ZMjjvuuEp9nsPhKBE48v2nvMSW2Hfs2MFLL71Ep06dcLlc/O1vfyvRWS8iIiLgvcfjYfz48fz9738HCFiW1/tgAmBM2bVzpZk1axZnnHFGueeMGzcuoBmhPC1btsTpdLJjx46A/f7rztemrl27MnPmTDIzMzl48CBt2rTh4osvDqjxSEhIYMmSJaSlpeFyuWjVqhX9+/cv8aClGh4N+rXA4YDLL4fHHiv/j4fHYzjrLDt//65ddma/kJA6SqRqtEJCQnC73ZU6Nzw8nKOPPhpjDH/72998+6OiokpdaMUYQ1JSEklJSTz88MP06tWLjz76iOOOO45jjjmGefPm8Y9//MN3/rx58wKub9WqVYmq8uLvZ8+ezX/+8x9GjBgB2GBYmWrlvn37smrVKt+DUfHFYnr06IHH42HBggUMHDgQgE2bNrF169Zy71vT1fshISEkJCQwffp03wMKwPTp07ngggsqfZ/qioiIICIign379vHDDz/w7LPPljinadOmREVFsWbNGpKTk3n88cfrLH3q0GjQryXt28O11wpvvOEhN9dZ4nhIiJuxYx00bWofDIKDbTV/+/ZQxYKGUlXSqVMnFixYwIYNG4iMjCQ6OrrMdvrp06ezaNEiIiMjycrKIjw8vMz7zps3j59++onTTjuNmJgYFi9ezObNm+nZsycAt912G1deeSUnnHACQ4cO5dNPP2X+/PkBAfHkk0/m2Wef5a233mLw4MFMmzaN33//nXbt2vnO6datG++//z79+/cnMzOTe+65h5BKPC0//PDDnHXWWXTs2JGLLrqI3Nxc1q9fz4IFC3j22Wfp3r07p59+Otdffz2TJk0iLCyMO+64o8Jmktqo3r/jjju44oor6NevHyeeeCITJ05k69atjB071nfOlVdeCcC7777r2+d9+Dh48CAOh4MlS5YQEhLi+zfIy8tjxYoVAOTk5LB9+3aWLFlCZGSk7zv88MMPeDweevTowV9//cXdd99Njx49fH0hAD755BNatmxJixYtWL9+Pbfddhvnnntuic6HqgEqq1v/kbDV9ZC94tLTPTJ8+J8SFJRfOHTPI8YUCIi0apUumzZ5ZMsW8W2rVons31+jSW5wdMhezTjUIXsidsjVgAEDJCwsrMwhe14nnHCCjBw5Ujp06FDuUD0RkRUrVsjpp58urVu3lpCQEOnatas888wzAec89dRT0qpVK4mIiJBLLrmkxJA9EfGtt96kSRO54YYb5P777w8YsrdkyRLp16+fhIaGSpcuXeTdd98tMfwMkE8++aREGn/44Qc56aSTJCwsTKKioiQhIUFefvll3/Ht27fL2WefLaGhodKuXTt544036mXInojIq6++Kh07dpSQkBDp27evzJw5M+D4kCFDZMiQIQH7KDYcEwjIX+/69MU3//t89NFH0qVLFwkJCZHY2Fi56aabZH+xP0wTJkyQdu3aSXBwsHTo0EEefPDBgKGPdUmH7JVEOUP2jBzBHS8SExOlJtdZruqaxx6Ph6effo9Nm3KYNu1SXK5IEhKW8d133cnLc/G//3k4/XSH3/l2uF/nzrbkfySq6XWjG6raXuO7LtYx//zzz7nwwgtZunQpU6dOZeHChfz44481+hnPP/88r7zySoXD4mpDQ1gL/nDXEPKwtv+v1YWa/rtojEkRkVI7WGh/8VrkcDjo2rUpXbu2ISUlgvnzDa+8Es/ZZ68CYPx4R0BHP4fD9v7fubNoOl+l6oPH4+Ghhx7ikksuoVevXlx55ZX8/PPP/Pe//2X37t31nTyl1CHSoF/LLr74XK644ixyc21WOxwOnn++N8ccA2lp8PLLgeeHhUFGBqSn10NilSo0ZcoUVq9ezaOPPgpA9+7defzxx3nooYe4++676zl1SqlDpUG/DrRoYRCx1fcAwcGGf/3Lvv7vf2Ht2sDzw8Ntp75iI5WUqjNXXHEF+fn5dO3a1bdv3Lhx7N69m7fffrvGPueuu+6ql6p9pRorDfq1LCUlhYUL59KihZCVZTtOJicn43It5aKL7Bj9++4LrM53OrWaXymlVM2rl6BvjLnRGLPeGJNjjEkxxgyq4PybjDErjTHZxpjVxpgr6yqt1SEi5ObmkpqayooVc3E6hfnzk1m9ejW5ubk8+KDQvDnMmQOffhp4bViYreLXan6llFI1pc6DvjHmYmAC8BTQB5gDfGeM6VDG+TcAzwCPAb2A8cCrxpiz6ybFh847UUl8fDwrVqTy7bdvs2zZOrp3705iYiItWhgeftie++ijsHdv4PUREbBjh1bzK6WUqhn1MTnPHcBkEXmj8P0txpjTgRuA+0s5/wrgDRH5oPD9OmPMCcC9wNe1ntpq8gb+1NRUQkIKcLnyiY9P9E31+fe/wyef2NL+E0+A/6JjTqft0b9jh9C2rfFN2iMiVZ4qVNWtNm3a1OqUpDk5OSVWQlNVo3lYfQ0hD9u0aVOvn3+4qdOgb4wJARKA54sd+hEYWMZlLiCn2L5soJ8xJlhEGnQ5WESYO3cuYGfai4rKYeHCxZx0Uh8cDhvIn34ahg+Hjz6CCy+EgX45sWbNUvbtK+CMM/rQrJnx3c/lcpGQkFBP30pV5Ouva/d5tLHMd1CbNA+rT/Pw8FOnk/MYY+KALcAQEfnNb//DwGUi0r2Ua54CrgbOApKxDw3fADFAnIhsK3b+dcB1ADExMQkffvhhjaXff4GOysrMzCQ7O5uwsDAiIiLIzMwkIyOHkJAwIiOLpjR9//2OvPtuZ9q1y2LixIWEhNh/l6ysLLKzcwgJCaV583CysgLvd7g5lDxUJWk+Vp/mYfVpHtaMms7HYcOGlTk5z+Ew9/7jQCy27d8AO4B3gHsAT/GTRWQSMAnsjHw1+RR6KE+1KSkp5ObmkpSUhDG2pD579lx27YqiR4/eOAun5X/kEfj9d1i7Npyffx7CXXf5vg/Jycmkpq7B6dxH8+aZ9O4d77vf4UZLBjVD87H6NA+rT/OwZtRlPtZ1R77dgBtbSvcXA2wv7QIRyRaRfwDhQCegA7ABSAd21VZCa0pCQkJAgDbGcNJJSQwf3pusrKLzXC547jn7+uWXoXBNDIwxJCYmEhzsIS/PSVZW8GEb8JVSStWvOg36IpIHpACnFDt0CrYkX961+SKSJiJuYBTwjYiUKOk3RMUDtDGGqCgb6P2XAO/fH0aPhoICuOsu+9Nb0gcICSkgPT2MmTPnlVhzXCmllKpIfVTvvwi8Z4xZAPwOjAXigIkAxph3AUTkysL33YD+wDygObb3fzwwus5TXoOMgZgY2LgR/FcFvf9+mD4d/vgD3nxTSEiw4/q9w/zmzk1hzpzVBAUJJ56oJX6llFKVV+fj9EXkI+B24EFgCXAScKaIbCw8pUPh5uXEBvo/gOlAKDBQRDbUTYprT1gYNGtGQDV/VJTtzQ/w3HOGPXuifAHfDv9LoEuXHmRnh2vAV0opVSX10pFPRF4DXivj2NBi71diJ/E5IrVsaWfd83jsmHyAv/0Nzj8fpk2DN9/swUcfSbE+AX3JyDBkZtoJfJRSSqnK0Ln361lQELRuDZmZgfsffRRatIC5c2HKlMBjxthFebZts+3+SimlVGVo0G8AmjSxnfpyc4v2RUfDk0/a148+6mHjRttxz9uxb8WKpRhjp+nVPn1KKaUqQ4N+A2AMxMbaoO8fwM86S+jbdws5OU6GDvXQr5/w1FMb+P33VDZs2EBoqJCeDgcO1F/alVJKHT4Oh8l5GoXQUFu6P3CgqJ1eBEJCdgFx5OU52bJFeOONdng8VzBw4B+cdRZERtrSfmio3ZRSSqmyaEm/AWnRwpb63W77/rnnhJSUXtiJCAEM+fnBuN1BzJt3LM89Jzgctmlg69ai65RSSqnSaNBvQJxOO3Y/MxP274fXX7dBvjT5+cG8/rrhwAE7zt/thl0Nfn5CpZRS9UmDfgMTGWnH6n/+Ob55+cvidMI339jXERH2QeHgwVpPolJKqcOUBv0Gxhho1Qp27oTs7PLPzc6253lFRNhhfP5T+yqllFJeGvQboJAQ6Ny54o55Lpcd4+/ldNprt261k/0opZRS/jToN1BXXllx4M7Ph7POCtznctn92r6vlFKqOA36DVR0NPzznwaXq6zIL7jdxrcEr7+ICNi3T9v3lVJKBdKg34A99RTcdJMDl0swxgMIwcF5uFxCv352GN9tt5Ue3CMjbfu+/yx/SimlGjednKcBMwYuumghQUFrWby4NdnZYUREZJKYuIN+/Xrx0EPHs3QpPPAAvPxy4LXe8ftbtkDHjhWPBFBKKXXk05J+A+Z2u0lOXkBIyDr699/KlCn9GDRoMzk5O1i2bDH//rebsDC7Gt+nn5a8PiTE9gvYuVPn51dKKaVBv0FzOp20adOG2NimNG3q5p13PiYoKIjmzZsTExND9+5OHnvMnjtuHKxfX/Ie4eF2at/9++s06UoppRogDfoN3Pnnn8/YsWOJjMzD4QCPx8GVV17JmWeeCcAll9ge/JmZcPPNpY/Rj4qy8/NnZdVx4pVSSjUoGvQbOBFh/vz5OBxC06ZZ5Oc7SUlZhBTW1xsDzz4LbdvCkiXw3HMl72GMLfFv2WKH8ymllGqcNOg3YCLC3LlzSU1NJT4+nptu+gd9+3Zh2bK/SE5O9gX+pk3h1Vdt573XXoPffit5r6Ag25lvyxaduEcppRorDfoNmDEGl8tFfHw8SUlJGGM4/fQT6NGjG06nC2OM79wTToA77rCvb701cHpeAI/HQ2iorf7ftcu+V0op1bho0G/gEhISfAEfICjIMGJEX4466tgSPfJvvRWSkmxQv/nmoqV2v/32W7788ks8Hg+RkbBnj4c33/yMadOm1fG3UUopVZ806B8G/Ev0AOHhhpYtS3bMczptNX/LlvD77zBhgi3R5+bmsnnzZl/g//nnL1m5cg8HDuRriV8ppRoRDfqHqeho205ffMa9mBg7UY8x8OKLMGeOg5EjR9K+fXs2b97MK6+8wpYtm+ncOZaBA/9OQYH+CiilVGOhf/EPUw4HtGljg37xav7Bg+H22+3+m2+G3bsdnHPOOQHnnHfe2YSEONiypagZQCml1JFNp+E9jIWG2qV1d+2yY/H9/fOfMH8+zJkDo0enM2LE17z++hV4PA6Skhby+usfMnBgL7p1O57t2yEuztYOKKWUOnJp0D/MNW8OGRmQnQ1hYUX7ve37p54qLF0axbJlowAQMfzyyxB++snQv/8iPvjATUaGk927oVWrevoSSiml6oRW7x/mjLHV/G53yWr61q1h8GABBBEHIg7AkJ8fjNsdxIIFfXjhBVPYo99O16uUUurIpUH/CBAcbAN/Zmbg/v374ZtvDFB6vX1BQTCvv244eLBoKV6dqlcppY5cGvSPEFFRdmY+/6D9f/9X8ZK6Tid8843tGBgeDmlppc/fr5RS6vCnQf8I0rq1Dd7e+fV37rRt/eXJzi6avS8oyNYapKVBQUHtplUppVTd06B/BHE6bTV/To4drte6te3hXx7vCAAvl8teu3WrztGvlFJHGg36R5iwMNsLPyMDRoyoOHB7PHZp3uL3yM21y/EWnwNAKaXU4UuD/hGoeXOIiLCl9uuvF4KDy1pPV7j4YqFp05JHIiJsb/7du2s1qUoppeqQBv0jkDEQG2tL6Xfc4eDUUzcQFFRQGPyFoKB8jPEAhvnzHWRklH6fqCg7lG/fPnzL+HoVf6+UUqrh08l5jlBBQXaWvY0bhWuu2U9Cwqfs3t2f8PBOZGWlERWVzJQpZ7F6dRi33w6TJtlOgP6MsUP5fv45laZNMxg+vD/GGESEuXPn4nK5SEhIqJfvp5RSqurqpaRvjLnRGLPeGJNjjEkxxgyq4PxLjTFLjDFZxpjtxpj3jTGxdZXew1V4OLRqZXC7Q+nbtyvjxnXin/80jBvXiaSkTowfv5EmTeC77+D550u/hzGCw5HN3Lkb+fXX+b6An5qaSm5urpb4lVLqMFLnJX1jzMXABOBGYHbhz++MMT1FZFMp558IvAfcBXwBxACvAVOAv9VRsg9bLVpAv369ycnx+JboNcaQkJCAw+EgIgKuuMIuw3vUUXD++YHXG2Po3z8RgN9/X8vKlcsJDnbTq1cvkpKSSiz7q5RSquGqj5L+HcBkEXlDRFaKyC3ANuCGMs5PAtJE5CURWS8i84CXgf51lN7DmjGwdWsKixYtJi/PlspFhJSUFJYuXcqQIfDoo/bcu+6C5OSS91i2bBlOJzgcbvbtiyA/32CMYdGiRXX4TZRSSlVXnQZ9Y0wIkAD8WOzQj8DAMi77HWhjjDnbWC2BUcC3tZfSI4eI4HbnsmvXEubOXYzbLSQnJ7N69Wpf9fxVV8Ho0XaY3tVX28l5/K/Pzc1l0aJF5OVlYIybLVsMv/8+X6v3lVLqMFPXJf2WgBPYUWz/DqDUNnoRmYsN8lOAPGAXdjL50bWXzCOHMYakpCT69j2G7dv/4O23P2b16tV0796dxMREX/X8o4/CoEF2iN6YMZCeHngfb3APDrY/9++PpKBAA75SSh1OTF2W1IwxccAWYIiI/Oa3/2HgMhHpXso1PYHpwL+BH4A2wHPAEhG5spTzrwOuA4iJiUn48MMPayz9GRkZREZG1tj96tru3btxuw0ej6Fly+gSx9PTg7jttr6kpYWTmLiXxx5bRlCQcODAQUQ87Nhhv3vLlgcxxoHD4aBVqyZVSsPhnocNheZj9WkeVp/mYc2o6XwcNmxYiogklnasroN+CJAFXCIin/jtfxWIF5EhpVzzHhApIuf57TsJmAW0F5G04td4JSYmSnJpjdSHaMaMGQwdOrTG7ldX/HvcezyGvXsj6NatG0lJCSU64m3YAGefDXv3wmWXwdNPC9988zWbNm1iypTzcDqdXH75FxQUFBAT05nzzz+Ttm1NieF+ZTlc87Ch0XysPs3D6tM8rBk1nY/GmDKDfp1W74tIHpACnFLs0CnAnDIuCweKrRTve6+TC1XAP+DHx8dz/fXXMHBgZ1asWMv8+ckl2uQ7dYLJk+2c/FOmwKuvCm63m/z8fN+UvAUFBeTn5xMUlEdmprB9u07Xq5RSh4P6CJovAmOMMdcYY44xxkwA4oCJAMaYd40x7/qd/zUw0hhzgzGmS+EQvv8Ai0ob4qcCGWNwuVzEx8f7htgNGTKApKSOiIRiu0cESkiA//zH9vx/+mkHS5Z0xOVqTXp6OHv2hLFoUQ9crtaEhITQpImd0a+iefp1Rj+llKp/dT5OX0Q+Msa0AB7Ets+nAmeKyMbCUzoUO3+yMSYKuBl4ATgA/ALcW3epPrwlJCQgIgHj9IcP78+ePYY9e+x0u8WNGAEPPQSPPQZvvdUHOA4Rg4jhl18G8/PPDs47bwdnnCFERhoOHLAPCa1b25/+UlJSyM3NJSkpCUBn9FNKqXpSL9Pwishr2Al2Sjs2tJR9L2PH5qtDVLzt3hhDixZ2mF5Wlp29r7jrroMvvxT++MNgB11Y+fkhAHz5ZQxxcXDPPfbBYf9+e9w/8HuH/KWmpvqu929u8H8YUUopVbu0TbwR8y7M43DY4F/cgQOwcmXZ1+flBTFxoj0P7Dz9+/bZYX/e2nvvkMH4+HhSU1PZvXu3L+DrjH5KKVW3NOg3ck4ntGsH+flQUBB47P/+D4KCyg/KTqfhm2/sa2OKVuYrLfD704CvlFJ1T4O+IiTEBv6sLPB4ivbv3AnZ2eV3uMvOFnbuLHpfWuD3tuH7mzt3rnbmU0qpOqZL6yrAtunHxsL27TZoezvlhYXZh4GyhIXZ8/z5B34RYc2auSxfbqv08/LyiIuL87Xxa4lfKaXqjpb0lU+zZtC8OWRm2vcjRoC7+AwJxRQUwFlnldzvDfx79xqyssLp1SveV8XvbeN3uVwa8JVSqg5pSV8FaNUK8vIgO9s+BIwda5g40U1urrPU8486ytCkjJl4vYG/ffvjiY4WvHMCeNv4NeArpVTdqlJJ3xgzwBjziDHme2PMUmPMGmPMXGPMZGPMVcaY5rWVUFU3HA6Ii7M/c3LgrruEk0/+i6CgAozxAEJwcD5OZwEOh4cVK+xY/rKa572Bf98+U6ztXwO+UkrVtUoFfWPMaGPMMuxUuf/ETo27BpgP7MOubf8msKXwAaBzLaVX1QGnE9q2tZ368vOFQYPmMXbsJFq2zKRdO7jggmXccMMkrrzyZ4KDhUmT4MUXy75fUeC3zQHaf08ppepHhdX7xpilQCvgXeBK7Op2Jf5sG2OaAmcBlwErjDFjROSjGk6vqiPeHv0bNzro3ft4oqLWEhmZiTGZHH/8ciIiYunatTUDBhhuvNEGfZcLbr657Hs2aWL7CGzfDjExVHqRHqWUUjWjMm36/wNeF5Gc8k4SkQPYNe+nGGOOA2JrIH2qHoWG2qp+j+c4jj22N1lZUwuPGM4991wcDgfHHWcn9rn9dvjXv2zgv/basu/pcEB6uq1FaNNGA79SStWlCv/kisiEigJ+Kdf8ISI/HHqyVEMRFQUxMcLs2X8EVMunpKT4xtlfeCE884zd/8gj8O67Je/jLzLSDgPcsqXi0QFKKaVqjpazVLlEhFWr5rJt21I6duzJZZddRvfu3Vm9ejXJyUVL8152GTzxhL3m/vvhgw/Kv29EhB0lsHlzyZkAlVJK1Y5KD9kzxpwLjAR6AtGFu/cCK4AvReSLmk6cqn/epXkHDDiaLl36kJ5uSExMBCgxzv6qq2xV/+OPw1132Q57l15a9r3DwuzQwE2boH17CA6u7W+jlFKNW4UlfWNMc2PMbGAaMAzYDcwr3HYDQ4FpxpjfdcjekUxo3dqW0MuboW/sWHjwQfv67rthypTCq0W44AJYu7boPdjADzbwl7boj1JKqZpTmZL+C9g17oeIyKzSTjDGnAS8DzwPXF1zyVP1zbs07vLlyzHG0K9fEl9+mcLKlX/Ru/dRpS6Ne8MNdpje44/bZXc3b06jf/+d7NjRh/x8eP99oW3bxbRoEcSxxx5LaKit6t+40Zb4vQ8CSimlalZlgv45wI1lBXwAEZltjLkXeA0N+kcU/xXyUlNTSU1Nxe029OjRl/j4vmVOsjN2rA38jz0GL7/cjldfbYOIDe4PP+zB7T6WU05Zy6RJgsNhCAmxPfk3bbIjBqKi6vJbKqVU41CZjnwu7AQ8FdkPhFQrNapBKr40rtMpnHNOX8CUWyV//fUwaJCtxvd4nIjYB4TcXCcFBUH8/HNXnn++6PygILvwz5YtsH9/LXwRpZRq5CoT9OcCDxhjyix7FR67HztjnzrClLY0bnLyXNq1E9xuW3ovzf79sGBB4L6ffuroe52XF8TEiXDgQNFxp9MO6du2DXbt0tn7lFKqJlWmev92YAaw0Rjzf0AqRSX/5kAvYATgxnb0U0cQb8BPTbVL4yYlJfneA/Ttm8SmTQZjSva+/7//A6czsPr/++8DZ2h2Og3ffGOH/Hk5HHb2vr177XA+nb1PKaVqRoVBX0RWFM6wdw9wNnAp3uXSQIAN2Cl6nxORrbWUTlVPvEP2vAHfv6rf5XIRGmpo396OtzfGVtF77dwJ2dlFq+sBOByCx1P0Pjtb2LmzZL8A73z9GRm2JqFt28B7K6WUqrpK/RkVkW3YhXb+aYwJxZbwAfaLSHZtJU41DAkJCQG99IsvjRsWZnvdb9pkX3uDc+vW9r3/EL8rr0xl8uTevvehofa8skREFI3lb9vWTvOrlFLq0FS50lREckRkW+GmAb+RKN5Lv/h7b+DPzi6aWnfEiJLT7MbH7wl4n5sLw4eX/9lhYbbkv3Fj+XMEKKWUKl9lJuc5v6o3Nca0McYMOLQkqcNVeLhdmS8z0wb7Zs3s0L2QkLLm2bVV/TfcENiZrzQul60V2LTJLtGrlFKq6ipT0n/ZGLPEGDPWGBNd3onGmEHGmEnAX8CxNZJCdViJiAgM/P/8p5vExEU4nQUY4wEgODgPp7OA449fRmysMH8+XHCBXXK3PEFBtmf/jh22v4DHUwdfSCmljiCVadM/GrgLeAz7ALAS+APYBeRi2/e7AIlAU+A34BQR0eF7jVRkpA38aWkQHu5k6NCF9O2bzNSpl+B0ejj11Ll07rycJk2Ec87pzaWXwsqVcM45dtreo48u+94Oh+3gt3+/bRpo00Y7+CmlVGVVZmndLBF5DGgHXA6kAAnAP7Cd+84GnMAEoJeIDNOAr7yBPyvLcN11N9C9eyzXXvserVrtJj7+D7p3j+WGG26gfXvDl19C3752Up5zz4WFC8u/tzH2/t6pe3OqtPCzUko1XpXuyCciecDPwA0i0lNEmolIqIi0FZG/icijIrKq9pKqDjeRkdC2rTBnzhLS07NwuVwEBQXhcrnIzMwkJSUFESE6Gj7+GE491ZbgR42C776r+P5hYXYyn40bIT291r+OUkod9irTkc9pjHnEGLMP2AEcNMZ8ZoxpVuupU4e9qChD27YQEtKE0NBIACIiIoiMjCQkJCRg2N8bb9hJenJy4Npr7fuKZuQLCSmauldn8FNKqfJVpqQ/FngYWIxdRe9LYCTwUi2mSx0hRISgoBxcrl107tyD5s2j6d69O5mZmeTl5fmW2AXbNv/MM3ZlPhF45BG7TG9BWZ3/Czmdtp1/3z7bj6Ci85VSqrGqTNC/FnhDRE4WkXtF5O/ATcDlxhhdYEeVyzujX9++x3DOOX0RgeOOS6R79+64XK5Sxv/DbbfBq6/aUvzkyXDVVXZmvvI/J7CdP1tnkFBKqRIqE/S7AJ8U2/cRtvNex5KnKxUoISGBpKQkwsPtErr5+YZjj03k2GPLHtV57rnw0UfQvDn88ot9v2VLxZ/lnRFw40Zb8q9Kdb8UO7n4e6WUOtxVJuhHAgeL7fN2m9JVz1WlFE3hCx06gNttKux1368ffP01dO5sh/SdeWbFPfvBLvzjHc+/fXvJWQFLk5KSwty5c32B3rvQUEpKSsUXK6XUYaKyvffbGmO6eDds6b/E/sJjSpXL5bKBHyquhu/c2Qb+k06C3bvhootsT/+KeFfqy8yseFifiJCbm0tqaqov8HtXEszNzdUSv1LqiFHZaU0+LWP/F6Xscx5aUlRjEhJiA39amg38YWFln9u8Obz/Pjz6KLz9Nvzzn7B6NYwbZzvxlSc8vKidPzbWPggU60YQsHJgamqqb9lg/5UFlVLqSFCZoH9VradCNUpBQXaRnq1bbUe9yMiyzw0OhieegG7d4KGHYOJEW+X/6qv2oaA8ISH2s7Zts58TE1NyFj9jDAMGDPAFfIABAwZowFdKHVEqDPoi8k5Nf6gx5kbgbqANsBy4XURmlXHuZGB0KYeyRCSiptOm6pbTaZfM3bEDDh60gb+8OHvllXDUUXD99TBzpl3J7803oWfP8j/HW92fnW1L/XFxgbULycnJ/Pnnn74lhEWEDz/8kG7dupGYmFgzX1YppepZlZfWrS5jzMXYKXufAvoAc4DvjDEdyrjkNuzDgf+2DqhEy646HDgctuo9OtrOrFdRE/rAgfD999C7tw3g55wDX31Vuc/y792/d6/9LI/Hw59//smGDRuIiorimmuuISoqig0bNvDnn3/i0ZV9lFJHiDoP+sAdwGQReUNEVorILcA24IbSThaRAyKy3bsBXbEdCd+ouySr2mYMtGplq97T0yvucd+2LXz+uV2dLzsbbrjBtvnn51f8WcHBdjKfXbvsUr0FBQ66detGp06dyMjI4M033yQjI4NOnTrRrVs3HI76+G+ilFI1r07/mhVO5pMA/Fjs0I/AwEre5lpguS7qc2Rq3twG9MzMigN4WBhMmACPPWZL75Mm2d79FS3RC/YhIyrKPlysXw/duiVy8cWjAs4ZNWqUVu0rpY4opi6HIxlj4oAtwBAR+c1v/8PAZSLSvYLrm2JrBe4XkQllnHMdcB1ATExMwocfflhTyScjI4PI8nqbqQpVNg9FbK97Y8pv4/davrwJTzzRiz17XDRrlse4cSs4/vj9lU6X2w25uVnk5WX5Pi8sLIyIiIbZbUR/F6tP87D6NA9rRk3n47Bhw1JEpNQSy+EW9G8CXgDiRGRvRZ+XmJgoycnJ1Ux1kRkzZjB06NAau19jVJU8zMuzQ/pEyh/S57V7N9x0E8yebfsJ3HEH3HprxcP6RITk5GSWLfuLqVNHEB0dxbPP2nH6DXXYnv4uVp/mYfVpHtaMms5HY0yZQb+uGyt3A24gptj+GKASlbJcC3xWmYCvDn8hIdCxo/1Z0dz7AC1bwtSpNtCLwPPPw6WXws6d5V/nXR+gd++jaNIkitxcQ6dOSRxzTHyp6wMopdThqk6DvojkASnAKcUOnYLtxV8mY0w/4Di0A1+j4h3S17SpHdJXUUd6pxPuvRemTIEWLWyp/5RT4Lffyr/u2GOPJTExEWMMQUGQlWWIjU2iR4+EmvsySilVz+qjW/KLwBhjzDXGmGOMMROAOGAigDHmXWPMu6Vcdx2wRkRm1F1SVUPgcNhe/W3a2A5+lVk6d8gQmD7dDu/bvduW+P/1r/I7B+7d62bHDtuk8PnnkJHhZvNmO6mPLterlDoS1HnQF5GPgNuBB4ElwEnAmSKysfCUDoWbjzEmChgFvFlnCVUNTtOmdga/3Nzy59L3iomBDz+EO++0nQFfecWu1rd+feB5InDJJYvo2xc2bhTS0mD8eKFfP7j++kVkZsKGDXYooVJKHc7qZQCyiLwmIp1ExCUiCf6d+kRkqIgMLXZ+uohEisizdZ5Y1aCEh9t2fofDlvor4nTaDn2ffWabCZYsgVNPtcv2evuwPvOMmzlzelNQEITHY9vvs7MNBQVBzJnTm//8x43LZZf23bKlcnMBKKVUQ6SzjqjDTkiILfFHRlaunR/sMr3Tp8PIkZCVZR8ErrvOlvonTXJQUBBc6nUFBcFMmuQgI8NO45uTY685cKDimQOVUqqh0aCvDktOp526NybG9uyvTOm7aVO7QM+//20fGL79Fk4/HaD83vlOp+Gbb+zrsDBb27B9u53NrzLNDEop1VBo0FeHLWPsDH4dO9qgn51duWv+/nf46ScYMMA+MOTmln9NdnbgsD+Hw87m5/HYOfx37ap42mCllGoINOirw15YWNF4/sos2AO2eeDjj+0qfVD+BaGhQuvWJfe7XLbGYP/+oo5+WuWvlGrINOirI0JwMLRrZ8fmp6dXboid0wnPPmuvLY/HA2edVfoxYyAiwt5jyxY73K+imgOllKovGvTVEcMYOyufd1hfZar7mzWDG280BAeX/pQQElLA2LGGpk3Lv09QkO3ol59vS/27d2uVv1Kq4dGgr444ERHQqVPlq/vvuksYPnwtQUEF2Kr+ogtat87gmmsqX2cfGmqr/Pfts738Dx7UKn+lVMOhQV8dkbzV/a1a2cBfXu9+Y+D66w/yz3++R3T0fpo1y6B79/U4nW7S0ppx8snw9deVD97eKn+XC7ZutZ39KlProJRStU2DvjpiGQPR0baTX0FB2YHXGENiYiInnhhPREQmUVEHOPfcr5kwYQX9+wu7dhnGjoWrrrJt9pXldNoqf7CBf9s2ndhHKVW/NOirI563d394uK1ur2xbe7t2OXzyCTz9tB2iN306DB0KEydWLXiHhNjgn5Vlq/y1vV8pVV806KtGISjILtgTF2dL/P6lfhEhOTmZRYsWcdVV/8dNN/2Ky+Vi0aJFLFqUzOWXCzNmwNln2+sefxzOOAOSk6uWhrAwW+2/bx+sW2dn9avMbIJKKVVTNOirRqVJk8BOft6gu23bNgD69u3L5ZdfTt++fQP2x8baEv7770OHDrBypZ3S9447bMm9srzt/aGhdlY/Hd+vlKpLGvRVoxMSYjv5tW5tF+3JzTV06tSJvn37kpiY6Gvj79u3L506dcKYoml6hw2DX36BW2+19/noIxg0CN56q2rL7zqdtskgKMiO79+40Vb/K6VUbdKgrxol7xS+nTrZAJyZaSpd1R4WBvfeCz//DCefbPsJPPSQncd/9uyqpcM7vh/sXP6bNmlPf6VU7dGgrxo1lwvatxfCw7NYtmwtc+ak+Nr4V69eTW5uLlJG3XuXLvDuu7aU3769rfK/+GK45hpbcq8Kb2c/t9tem5ZW+mI+xdNSVtqUUqo0GvRVo+dwGE4/vR+DB3fkr79W87//fczKlavp3r27r7q/LMbAaafBr7/C3XfbWoDvvrO9/P/1L9teXxUulw3+eXk2+G/ZUhT8U1JSmDt3ri/Qiwhz584lJSXlEL+5Uqqx0aCvFHas/pAhA4iOziQqKou8vGB69So/4PsLC4Pbb4dZs+CCC2zQfuUVOPFEmDy56uPzQ0Ntm39Oju3sl5YmHDyYR2pqKnPnzgVg7ty5pKamllsboZRS/jToK0VRqdn2rs+nZct0li9P5sABqVIHvTZt4D//sTP4nXAC7NkDDzwAf/sb/Phj1Xvph4XZkn9uriE2dgAxMX1YvHglu3fvJjU1lfj4eJKSkir9cKKUatw06KtGzxvwvUH02muv5fjje7J9+2LS0uaTmytkZVUtYPftC59/Dm+8YTsLrl1rZ/Q77zxYuLDqaQwLg6ZNDb16JbBnTwQFBQ7y8pwMGDBAA75SqtI06KtGzxiDy+UKKDUnJSXRu3c80dHBdOliiIqy7fNVWTbXGDjzTNve/9hjdkrghQvh3HNhzBhYtapq6fzjjz/44YcvCQ21VQ9790byyitfMmvWIh3nr5SqFA36SgEJCQkB1eTewJ+QkIDTCTExtsRujA3+VZlGNyQErr4a5syx7f7h4XZK3+HD4ZZb7NS8FfF4PCxZsoQNGzYQERFBixbRtGgRwoYNm/j551WsW+cJmGxIKaVKo0FfqULFq8mLvw8NtXP4x8baDnZVrfKPirI9/OfMsSX9oCCYNg2GDLH7t2wpP23NmjUjKCiIHTt2sHfvXnbs2IHL5SAmJgKn07B1q32AOHBA5/ZXSpVOg75SVWAMNG0KnTtzSFX+YJf7ffJJ29N/1Ci7b+pU29P//vtLD/7G2FkD27ZtS25uLgUFBeTm5tK2bVs6depESIhtgggJgR077Nz+u3frqn5KqUAa9JU6BEFBRVX+TqcN/lXp5Q92Qp8XXrBt/ueea69/910b/O+7LzD4iwh5eXns2rWLqVPPZ+/e5ng8Hnbt2kVeXp5vyJ7TCZGRtuOfd2GfrVt1lj+llKVBX6lqCA21wTsuzpaqMzKq3q7etSu8+qqd03/kSBv833vPBv+77w5s8z940EFGRgRut4OlS+M5eLD0/8IOh13YJyrKBvxNm+x4/0NJn1LqyBFU3wlQ6nBnjA2uERG2PX3XLht0w8Lsscrq1g1eew3++U+YMAG++MJW+3/4oV3Wd8+elsybdxVutwO328mvvw7ml18Mq1evJSGh7M8KC7M/8/Nt7YHTaUcSREVBcHC1v75S6jCiJX2laojDYRfx6dLFTqiTnn5o1epHH21n85s5087l73DAl18aZs/uTEFBECL2v21+fjAFBUH8/HNXnn++4qeL4GAb6ENDYe/ewKp/HfKnVOOgQV+pGhYUZJft7dLFlrIPpbMf2Gr/F1+0c/k7HIFR+ZVX+vhe5+UFMXGicOBA5e7rcNhhg95pfjdtKur1X9V+CcXpgkBKNWwa9JWqJSEhtq2/Y0f7IJCebufkr6rFiyE0NLAkv2FD04D3Dofhm2+qfm/vHP9BQbbX/9q1sH37oZX+dUEgpRo+DfpK1TJvZ7/27e379PSqDaXbuROyswMj8MiRawLeZ2cL06bZwH0ogoJsr//ISMjMLCr979tXubSKCLm5ub4FgfynNtYFgZRqOLQjn1J1JDzclvqzsmwgP3jQVv9X1JmudWt7XlZW0b5Bg7bw5ZdH+51lmDcP+ve3nf7+8Q/o06fErSpkTFHHP7fbjvXfudN2Umze3B5zlFJU8M5gCJCamkpqaiqALgikVAOjJX2l6pBdxc+O72/XzgbWikr+I0ZUPMNecLBwyin2vGnT4Kyz7DZt2qH1JwDby9877C8/H9LSiib9yckpWf2/aNGiUtv0Fy1adGgJUErVOA36StUDY2xVeufONvh7PGUH/2bNYOxYQ3Bw6b3sgoMLuPFGw+TJMHcu3HijvWbxYju3/wknwL/+BZs3H3p6Xa6inv/798PGjYHV/yJCTk4O8+fPJyMjA4CMjAzmz59PTk6OVu8r1UBo0FeqHhUv+YvYav/iHf7uuMPNiSem4nQWYIydXSc4OA+ns4ATT0zljjtsVUC7dvDAA5CcDM8+Cz17wp49dghgUhJceSX8+OOh99L37/kfFGRL/evX2z4AWVlO3G5bje8f5LVqX6mGQ9v0lWoAvME/PNz2nN+925b8g4Nt6drpdHDRRRuJj5/D+++Pwul0M2zYTLp1W0PPnm1xOo8LuF9YGFx2GVx6qX0AePdd+OYb+Plnu7VpA5dcYuf+b9v20NIcFGQ3gLw8Q3p6BO3aDWHDhuUEBeUTFhbJccfF43K5NPAr1UDUS0nfGHOjMWa9MSbHGJNijBlUwfkhxpjHCq/JNcZsMsbcWlfpVaquGGMDf4cOdgsJsSX/nBxDUFAw3bvHcu2179Kq1R6OO2453bvHEhwcXGZQNcZW77/8sg3+Dz5oaxW2bbNzAAwYAJdfbh8IDrXtH2w6+/ePJzzcjYiT/fvD2b27Cbt2BdG9e19d9U+pBqLOS/rGmIuBCcCNwOzCn98ZY3qKyKYyLvsQaAdcB6wBYoCwOkiuUvUmLMxW1+fmwr59QmRkDKtXLwSKxsFv3bqV/v37IyIVlqZbtIAbboCxY+3yvu+/D99/bxf8+fVX2zv//PPhoosgPr5qaRURkpOTWb16Nb16dScxMZGFC5NJTV1DdnYQffr0ISrK0LSpt+biEDNFKVUt9VG9fwcwWUTeKHx/izHmdOAG4P7iJxtjTgX+BnQVkd2FuzfURUKVaghcLmjdWsjLW01QUAYFBZE4HME4nSHk5+exefNmEhISKl2FboxdzOfEE+10vJ9/Dh98ACtXwv/+Z7djjoG//90+BLRqVZl7GlwuF926dePppxMBw6efJgJCaGgQkZGGnBy74A/YpgzvA0CQNjIqVWfqtHrfGBMCJAA/Fjv0IzCwjMvOBRYCdxhj0owxa4wx/zHGRNZeSpVqWBwOB1FRofTu3YajjnLidHqIioqmdesuOJ3hOEobPF8J0dFw9dUwfTp8+y2MGWN7/q9cCY89BgkJcMUV9sHAf56A0qSlpbHFbz1gEWHLli2kpaVhjA3wkZE24Ofl2Xn/1661owoOHqzahEXVoVMFq8bM1OUvvDEmDtgCDBGR3/z2PwxcJiLdS7nme2Ao8DPwGNAMeBlYKiIXlnL+ddhmAGJiYhI+/PDDGkt/RkYGkZH6rFEdmofVk5mZSXZ2Nk6nE7fbjcsVRmhohG+53EOM/QHy8gwLFrRg+vRYFiyIxu22Nw0NdXPiibsYNmwnffvuIygo8G/Hnj17KChws39/NEFBQbRosZ/c3DyCgpy0aNGizM8TKRrzb4yt+nc4qrZCYWVlZWUhIkRERPh+FzMzMzHGEB4eXvMfeITT/881o6bzcdiwYSkikljascMh6P8IDAJiReRA4b5TgR8K95U58WhiYqIkJyfXWPpnzJjB0KFDa+x+jZHm4aHxn9Y2Pj6evLw8QkJCfO8TEpJITzfs22cDqMtVM8vm7t0LX31lJ/nxn0K/WTM7adDIkbYzoMMhLFy4kJkz/2Dy5AvweJwMGLCAnj03MGTIcZxwwgmVan4oKLB9GDweG/ybNLG1Ay5X9fsBVJSHOnNg1en/55pR0/lojCkz6Nd1a9puwI3tiOcvBthexjXbgC3egF9oZeHPDsAhzjau1OHD22buDU4zZ870TXvrcrlwuQwul+2Ml5lpg3V6um0vDw099FJzdLSt8h8zBjZsgC++gC+/hD//hClT7NaqFZx5piEj4wS+/DIRtxtEDL/+OoRff/0bIoYTTqhcAvyHAXonLNq3r2h64CZN7M+QkKp/l+JTBUdHR7N3714N+KpRqdOgLyJ5xpgU4BTgE79DpwCflXHZ78DfjTGRIlLYDYhuhT831k5KlWp4EhISAnrpe4OYf7Dylo6bNLFT5R48aGfQg+qX/jt1gttvt9uqVfYB4Ouv7cPAO+8AmMLNys+3kXnSJFubeM89Vfs8h6NoHQCw/QB27rQPA8HBRQsEVaUWoLypghMSEqqWQKUOQ/UxTv9FYIwx5hpjzDHGmAlAHDARwBjzrjHmXb/zpwJ7gLeNMb2MMSdih/x9KiI76zrxStWn4qXR8kqnoaF2sZ6uXSE21lb7p6fbDnnePgCHqkcPuO8+mD0bPv0UnM6ymwmzsw3//a9w4ECZp1RKSEjRWgAhIfa7bN4Mf/1lZwTct88+6JT13XSqYKXqYcieiHxkjGkBPAi0AVKBM0XEW2rvUOz8DGPMcGznvYXAPuAL4L46S7RShzH/0n9urg2W+/fbxXlCQmxJ+VAZYxfhcbnK792flwcXXGBHCpxyCrRseeifCSVrAfLz7SyGHk/R7IZRUTZdISFFzRtlT2KkVfuqcaiXEbIi8hrwWhnHhpaybzVwai0nS6kjnstlt+hoO93vvn1FY+cPtfp/505bmi+fYeVKuOsuG4CPP94G/+HD7foA1Y25wcFFaRexDxnbC3sJORz2ISAy0rB06SqCg0MICbEnR0REkJ+fz4oVKxg4sKxRw0odOXRaDKUaIW8gjIiwPeYzM+0DQHq6PVaVWfNat4awMCErq7ymBuHMMw3798Pvv9sVABcvtosCtWkDJ59st5NOsu301WFM0cMN2NJ/djYcOOAhPb0FaWkZfP75CO65ZyX796/H7c7mqKO64vF4Dnm+A6UOFxr0lWrkgoLs7HhNm9rq/8xMW/2flWUDf2ho+eP/R4yAhx4q/zNE4Ikn7GdkZtq+AD/9ZLdt24pGAgQHQ79+MHQoDBlSM7UA3ocYl8vQrVsce/duxuMRPB7YtSuc4OAmREQczcGDhtBQ2xygsV8dqTToK6V8vCXk5s3tA0BGBhw4YGsDgoLsseIBsVkzGDvWMGmSlFrNHxYmXHednXcfbO3CaafZzeOB5cvtyn+//gqLFtmagN9/hyeftLUIgwfDoEF2iyk+2LcKvMMee/VKIjMzEo/HwerV3bnssuY4HCHs2mV8kwR5Zw/0PgToVMHqSKG/ykqpErzT5oaG2oV6vA8A3g6AxWsA7r7b9o7/7389FBQYRAzBwfmAk2uvNdx9d+nFdYcDeve22+232/kFZs2CmTPttn27HR3w6af2/O7dbRPASSfZSYGaNKn8dxKBd96J4dNPW+B2O3C7nfzyy0B+/tnBhRfu4fnni2oV8vNtWryrAwYHFy19HBJi32ttgDocadBXSpWr+ANATo6tovfWADidEBzs4eijv+D667czZcolQBADBiyka9dVHH10LCLnYkzFUTI62s7yN3KkDdKrV8Nvv9kHgblz7fvVq+2iQA4HHHccDBwISUl2CeHy+gM8+6yHzz6LpqCg6M+edy6Bzz6LpnVrD/fea9Po3zEQbPD3fmeRon4DxWsDdBCAaug06CulKs07M15YWFENgO0DYNizJ5eQEAdt2jhp0iSS66+PYv58j29u+0P5rB497HbddbZHfkpKUfX/okVFHQJffdU+fBx7rH0A6N/fPgR4mxT274fXX3eQn1/6g0d+fjCvv26XHfZe48/pLNmxMT+/qObDP28iIopGQuiDgGpoNOgrpQ5JYA2AoUePUA4edDB7dhQFBYbu3RNYt24LkZEhNTIOPiTEBvSkJDv0LzMTFi60DwBz58LSpUUPAa+9ZtN3zDH2ASA3t+Lg63TCN9/AZZdVLj3FawNE7IPAnj1FDwLe+QTCw4seBIKDK06L/8yLpb2vbw09fapsGvSVUtUmIrRvH8PSpUt56aW5nHBCEjNnLiA39wBt2vQmPV1wOk2NLJzjFRFhe/l71ynJyLAPAfPmwfz5sGQJrFhht9KkpQW2BWRnCzt3HnrgMsY+mPivC+B9ENi7t2imQG/TQHi4fWDyPgh4+wikpKSQm5vrm2LZu1CQy+VqEFMFp6SkkJOT45vXQESYM2cOoaGhDSJ9qnwa9JVS1WaMISQkhCZNmrBs2TJSU1MRETp0iKJLFw8dOhgyM+1aAN6Z+7wBsqYKiJGRMGyY3cCOzV+yxD4AfPUVrF4t+K8N8O9/By5CFhxcvdkJS1PWg0BBge0fsGdP0fe3iyMJe/YU8OefKykoMJx00gDmzStaGbC+S9Qiwtq1a0lLS/PtmzNnDvPnz6ddu3b07dtXS/wNnAZ9pVS1iQh5eXlkZGSQmZlJRESEry2/oCCP0FAhLMzQsqUt+ebk2ImAMjNtCdjhKOoVX1PCwoqaA8aMgT59DHl5Rcdbtsxi9+5w3/u8PMOTT9pOgn362E6Cxx9vf1ZllEBFjCnZNAC2SSA319CpUz/27g1m5sw/mTFjI8HBbnr37kOvXonk5BjfSoT1FVvbtWtHWloa8+fPp0OHDmzatMm3XzV8GvSVUtVmjGHAgAFs2LCB3bt3k5OTA0BsbCwDBgwIKP15A15UlA34eXm2VH7woH0QABvUvB3hakKzZnDDDTBxopvcXNu+cN99C7jrrqEAOJ0e2rZ1sG+fHSb43Xd28+rc2XYSPPbYoiGGNfkgYNNgN5fLMGhQHzZtWoEIeDyGHj0S2bHD5qFI0UOSt0+FN09r+2HAW6MTGxvLhg0bKCgoICcnh06dOhESUjN9N1Tt0qCvlKo2EWHevHmkp6cTGhpKZGQkGRkZpKenM2/evDLXq/fOlhcaaicEsqVd2wSQnm4fBoyxwTAkpHr9Ae6808OiRUuYM+c4PB7bgB4SUoDbDQMH/sGUKX0wxsHatbZZ4I8/ivoFrF9vty+/LLpfx44QH1+09expJw+qbtwTEZKTkwHvdxeWL08mMTHRl4cigcMI/QUHF+WpN8+8tQPVJSLk5uaybds23IW9Fd1uN9u2baNjx4713vygKqZBXylVbd4SYFRUlO+PfmRkJJGRkVUqATqdtoNbeLhdia+gIPAhwNsf4FBqAoyBYcOS6d17Lh98cBlOp4eTT/6NLl1W0LJlMMb0weGAo4+229//bq/Lz7dzAyxbZh8Eli2DlSth40a7/d//FX1GixY2+Hu3Hj3svSrbV8Ab8FetWkWPHj1ITEz0vQd8gd+YsgO52100l4K382BptQPe64OCqv4wlZeXx1tvXcEdd/zpe9/Q6AiD0mnQV0pVm3+bfnx8PElJScydazug5eXlHfIfXG9QioiAVq2KHgKys21vfW9zgMNR8XA4Ywx9+vRh/vz5XHXVW7Rs2Y6ePdMICQmhT58+ZaYvOLioNH/JJXZffj789Zd9AEhNtbUBy5fbjnmzZtnN/zt07WpnE/TOO9C9O3ToUHJWP2MMu3btIjIykoSEBIwxJCQkkJaWxq5duyqVh6XNKQCBtQMHDxYtQ2w/t2iZZf85BrwPBP4fm5qaSk5OKBkZTfB4gli6tD89ey4nNTW1waxU2NBHQNQnDfpKqWrzzmvvDfjGGJKSkgBwuVw1VsLyfwho2dIGsbw8W7LNyLABzTtjXlBQ4OI5xhgSExPZvHkzGzZs8N0zLi4uoOq8MoKD7RwAxxwDF11k94nAli02+K9YYWsDVq60zQLemQS/+qroHqGhcNRR0K2bfQg4+mg46ighOroVf/21mjPOyCAyMor77kshMzOTdu3aVau0Wl7tgPeBICvL5qO3hsDLu+5CUBB8+mk/ZsyIx+12UlDg4KuvhvLFF8M49dSlXHtt/U9G5G2CSE1NBQh4AG0IIyD81UdthAZ9pVSNSEhICPij5Q38tflHzOksmiGweXMbvPLyipoEsrJsqRzA4RCWLElh69ZtAffYtm0bycnJnHDCCdVKqzHQrp3dTjutaH92Nvz5J6xaZQO/9+f27baWoDA2ee9CSEgirVvHs3NnEA5HHk880Zyzz06ke/futZaX5T0QgH0gyM+Hp54SZs7sHTCVcV6eHY84ffqx3Hmn8MgjxldD4N3qcp0C7++dx+MhNTXVF/x79uxZ67+PVeFfGwHUWW2EBn2lVI0p/ge1rv/Aeie+cbmKetcXFHhHCAhr1qwgK0sICorE6QzG4YggOzuHFStWVrm0X1lhYXbY33HHBe4/cMA+DHi3v/6yP7duNaSlhfnOS04+iuRkGD/eNnF07QpdutgRBd6tY0f7ObXF6bRNKf/7nyE/v/SwkZ8fzH//K1x+uR2Z4c/b/OKds8C/6aA2Hgw+//xzcnJy8Hg8OBwOPB4PmzZtYufOnZx//vk190GHqLT5DubOncu8efNqfb4DDfpKqSOaN8CEhRlatMjBmEwGDOiLSD5DhrRh1qxF5OeHkJFhcDgCe7vX5jNL06Z2fYATTija98wzHl591Y3bXdqEBcKuXYZdu+ysg8XFxtoHgE6d7ENAx472dYcOdshidf3f/1Xc4c/phF9+KTmVsbf5ICfH1r643UXNMF7evPd/MAgOLnog8P6s6OHA4/GQk5PD2rVrCQ4OplmzZuzfv59du3bRtWtX34NAfWvbti1paWnMmzcvYL6Dtm3b1urnatBXSjUK3jb97OxsTjxxIDNnzmTEiAE0a+YmNDSMLl2Mb+Igb9OAt23b4SgKQrUVL+yiQKaMgA+26l947TXDjh2wbh1s2GD7DGzaZJsLtm+36xAU17SpDf7t29vN+7pDB9scUZlagp07bVNFebKz7XklUl5B8wFQOCdB0eRN3vfF+T8cePttBAUV7TfG0LZtBzZs2Eh+fj579+7F7XYTFBREhw4dGkT1vjHG1+lx5syZvvkOhgwZwsCBA2s1jRr0lVKNRmn9Dk488UTf+5AQ20mwRYui6XLz84tGDOTkFPUR8M4fUFO1ApUpSQcF2Xn8x4wJ3F9QYDsRbtxoHwI2bLAPAt5hhQcO2JEGy5aVft+WLW3wb9vWbv6v27a1/SVat7YPB95hk6UJC7PnHQpvflaUB/4PB7m5ttkh8OHAsGxZJsHBPXnttQSMgUsu+YwOHeL46699HHusCag18N/q+nmgPprDNOgrpRqVyv6h9Z8uNzzcBj4o6tRWUGAfBLKzbSAUKRoP760ZqMrDgC1Jl39ydrYptSQdFFRUpT94cOAxEdi92z4EbN4c+DMtzT4s7N5ttyVLSv/c0FDbfFC8pL9iRXTAe7cbzjqrgi9aTRU9HIgITmcOmzdvJTNzEG63k8WLe5GRsY5u3eLYtq3sHvL+NTr+8xiU9oBQnQcFb6e9efPmERoaSlBQEKGhocwrbLepzQ6HGvSVUqoK/ANOZOFCfd42a/+HAW8zgUjJa72BxJ8tSQtZWWX/sQ8LE1q3rlowMMZ2AGzVCkrrFO7xwI4dRQ8A/j+3bbOvDx60tQf+CxYBvPXWsX7vBJfL1kLExtrZCWNj7feKibFb69a2k19tFmjdbg9Tp7Zl7twReDwORAwzZw7m11+HkpS0hPPP9xAUVPoTg8cTWIvgrVXw/ht6+yH490fw7wdS2k9jAh8QvD83b7ad+Pr3709+fj5t2rRh/vz5AZ37aoMGfaWUqqbibdbe3uveh4GCArvl5NgtN9fu979++HB46KHyP6c2StIOB7RpYzf/ToX+0tNh61a7TZhwgOTkKEQM3bvvY/XqZtiHAcPBg7BgQfmfFxpa9ADQunXRA0nr1raZwfu+ZUt7blW9+KKD+fOPx+0uCm/5+XZY4fz5x/Piiw7uuaf0ayvTUbA474OBx1P0wAdFDwvFOyza94bg4GOIi+tCmzYJbNgw09fGHxoaqm36Sil1OCr+MOCtGQAbwL0PBPn5dojhtdfCxIn5FBSU7MwXFJTP9dcH0bRpHSXeT1SUnUCoe3cYNqwpe/a4GTLkAGPHLub77+H554ficjnZsaOoQ+H27bYGYedO+9O7ZWcX9TWozOe2aGEfAFq2tK+9W8uWEB1tX0dH2y07GyZOLG9YYRATJ8L111Nj+VjZvgjFhYcLDocwahRcfXXRktC1TYO+UkrVA2+gCLGFUJo2hf/8x5CdvYv33ouhoMCBx2MIDxcKCoTzztvLzTfHkJFR8j7eKubiU+bWBo/Hw2+/fcV1122mVatYjj9+OzNnHmTkyJF06eKgS5eyrxWxsyZ6HwZ27bLbzp122727aN+ePbaGIT3d27RQMZcL8vKE4s0QxVLB668bLr3U9tMID6/7DnzeWQNXr15FRkZ3AN+sgb17967Vmfk06CulVANhDLz5ZhzPPit89plh+3aIjTVceCE0bx4DFFUje2sJ8vKKZiH0tkP78+9YWN2HAo/Hw5dffsnmzZtp3749rVs3p337YDZv3syXX37JyJEjyx0Db4yt7YiMtJMMlUfEDmPcs8du3geCvXuL9u3ZY997t9xcKD/gQ26uYcIEmDDBvg8OtvMYeLemTe3m/7pJE/u+SRO7efdHRBxafnoXqIqMjCQrK5v8/HyWLVtNVFRUrS9RrEFfKaUamOhow7XX+u8pCgLe1fLK4m02KP5QYGclDOxLAEXV05WZAMfhcOByuWjfvj0jR45k5crfGDlyJF9++SUul6tGJ70xxpbEmze3axRURATefBOeflrIySk7aDocQkyMPb5vn+1j4a1dqCqHwz4EREUVPRBERRW9j4wM3OfdIiKEzZth40bDgQMuCgqc/PZbF5KSttCp06EvUFUZGvSVUuoIUlH7ssdT8sHA/+EgJydw3Lu3I5q313lMTHvy8rLxPojYyXDaEnoove5qkDF2OeR//av8YBkcbPj556I2/ZwcO4/B/v12K/764EH7+uDBovfen1lZRedWMbXAcYUbfPZZN+bPb80XXzi45x4HSUla0ldKKVUDvCX54LIm/qOoN7r3wcA7jC0vT/B4cli9eg0FBU6aNoVZsxbx55/r6N69G+npgsNhfA8I/jUHddFu3qwZjB0LkyaVPntgWBhcd11gJ77Q0KIRBVWVn2/7HBw8WLR532dkFL33LgPtPbZhg7BnD3gfnIKDPb4RBi+84MYY4fHHtaSvlFKqDvj3AwhkOOecRFq1yic1NQWHI5p9+9YweHA8/fr1weMxASMSvPMWeB8cyvos/7Hs1X1IuPtu+OuvNfzwQ2fcbjtOPySkAI/HcPLJ67n77qMP7calCA4uGjlQWfv3Q9++gV/u9NPX8+uvHQDIyXHy/PNw5501s2ZCcRr0lVKqgamPddYry7t0bWpqamFpXhgyZECF6fPWHvjXIng7JRbfyntIgKKHgtIeFjweN0lJs+nU6Uc+/PAywsKakpCwgHbtltCmTTgeTxecVR1fV4PsdMuBIwzsewLef/JJ8X4dNUODvlJKNSD+66wbY+psnfXK8qbH39y5cyucOraqE9/4T3pTfPN/QPC+z8uzP8FJkyZxHDiwicsvn4rDYRCB4OAQmjRpQ26uM+CBofjP2laZhYuysuw8B7VBg75SSjUQ3vHbqampgJ2D3Tt+Oz4+vt5L/N6A701PXl4ecXFxAemtqfQd6qQ3brdw/PFRGONh1679OBxBFBS4iY5uSffuzYmOFtxuU+LhoXjtQvEpd4tPvVv8tf/Dg3crjZ1u2ZS7cFF4uCE2tmrfu7I06CulVAPhrToHSE1N9QXT+Pj4Wl2EpbKMMbhcLl96Zs6c6Uuvy+Wq9/QBOJ2GgQP7s3TpYpzOAqCA4GAICcnjb39LxOmsuBnCf8790n56HxD8Ozp6Hx68qzP6839gGDq05LDJ4txuOxKhNmjQV0qpBsS/zdyrIQR8r9KWJ25I6fN4PHz00UccOHCAkJAQmjVrxv79+zlw4AAfffQRo0aNKnc+Ae+h6jb7e+fd939g8G633+7hxRfd5OeXHEIREpLPnXc6adasdtoa6qAFoyRjzI3GmPXGmBxjTIoxZlA55w41xkgpW4+6TLNSStWFstrMpfhUe/WoPtaBryyHw0FoaChNmzalWbNmOBwOmjVrRtOmTQkNDa3RCYTK463udzoprGmw0wSHhsKTT8KQIckEBeVjjG1TCA7OIygon8GDk3n00dpLV52X9I0xFwMTgBuB2YU/vzPG9BSRTeVc2gvY6/f+EOZPUkqphqt4m7l/mz40rBJ/QyUixMbGsnPnTo499lhfHi5dupTY2Nh67xcB4HAYLrxwKSecMJtJk67C6XRz+uk/EB+/ko4dm+JwDKi1z66P6v07gMki8kbh+1uMMacDNwD3l3PdThHZXeupU0qpelK8zdy/jb+htJk3dN489Ab8hpqH8fHx7Nkzk8jIDJxONwkJiwgODiY+Pr5WP7dOg74xJgRIAJ4vduhHYGAFlycbY1zACuAJEfm1FpKolFL1qqG3mR8ODoc89KbvqqveoWXLbuzdi2+IZm0yddlOZIyJA7YAQ0TkN7/9DwOXiUj3Uq7pDgwDFgIhwBXA2MJ7zCrl/OuA6wBiYmISPvzwwxpLf0ZGBpH+C2KrKtM8rBmaj9WneVh9moeHbt++feTm5iIihIaGkpOT46ulaN68ebXuPWzYsBQRSSztWIPvvS8iq4HVfrvmGmM6AXcDJYK+iEwCJgEkJibK0KFDaywtM2bMoCbv1xhpHtYMzcfq0zysPs3DQyMifPLJJ2zYsIGQkBA6dOjAtm3byMvLo0uXLgwZMqTWaiXquvf+bsANFF/aIAaoyvxD84Gam0BZKaWUqmMhISH079+fli1b0r9/f0LKWzO5htRpSV9E8owxKcApwCd+h04BPqvCrY4HttVg0pRSSqk6YYyha9eutG3bloEDBzJz5kwGDrTd2kJDQ2u170F9VO+/CLxnjFkA/I5tn48DJgIYY94FEJErC9/fDmwAlmPb9C8HzgUuqNtkK6WUUjWjtM6GAwcOrPXOhnUe9EXkI2NMC+BBoA2QCpwpIhsLT+lQ7JIQ4DmgHZCNDf4jROTbOkqyUkopVePqY5KjeunIJyKvAa+VcWxosffPAs/WQbKUUkqpI1q9TMOrlFJKqbqnQV8ppZRqJDToK6WUUo2EBn2llFKqkdCgr5RSSjUSGvSVUkqpRkKDvlJKKdVIaNBXSimlGgkN+koppVQjoUFfKaWUaiQ06CullFKNhAZ9pZRSqpHQoK+UUko1Ehr0lVJKqUZCg75SSinVSGjQV0oppRoJIyL1nYZaY4zZBWyswVu2BHbX4P0aI83DmqH5WH2ah9WneVgzajofO4pIq9IOHNFBv6YZY5JFJLG+03E40zysGZqP1ad5WH2ahzWjLvNRq/eVUkqpRkKDvlJKKdVIaNCvmkn1nYAjgOZhzdB8rD7Nw+rTPKwZdZaP2qavlFJKNRJa0ldKKaUaCQ36SimlVCOhQb8SjDE3GmPWG2NyjDEpxphB9Z2mhsQYM9gY85UxZosxRowxY4odN8aYR4wxW40x2caYGcaYXsXOaW6Mec8Yc6Bwe88Y06wuv0d9Mcbcb4xZaIw5aIzZZYz52hgTX+wczcMKGGNuMsYsLczHg8aYucaYEX7HNQ+rqPB3U4wxr/jt03wsR2HeSLFtu9/xes0/DfoVMMZcDEwAngL6AHOA74wxHeo1YQ1LJJAK3AZkl3L8HuBO4BbgBGAnMN0YE+V3zlSgL3B64dYXeK8W09yQDAVeAwYCJwMFwE/GmGi/czQPK5YG3Iv93onAL8AXxphjC49rHlaBMWYAcB2wtNghzceKrQba+G29/Y7Vb/6JiG7lbMB84I1i+9YA/6rvtDXEDcgAxvi9N8A24AG/fWFAOnB94ftjAAFO9DvnpMJ93ev7O9VDHkYCbuBszcNq5+Ve4HrNwyrnW1NgLTAMmAG8Urhf87HivHsESC3jWL3nn5b0y2GMCQESgB+LHfoRWypTFesMxOKXhyKSDfxGUR4mYR8W5vhd9zuQSePM5yhsLdy+wveah1VkjHEaY0ZhH6DmoHlYVZOAT0Xk12L7NR8rp0th9f16Y8yHxpguhfvrPf806JevJeAEdhTbvwP7D6cq5s2n8vIwFtglhY+0AIWvd9I483kCsASYW/he87CSjDG9jTEZQC4wEThPRJaheVhpxphrgaOAB0s5rPlYsfnAGGy1/LXY7zzHGNOCBpB/QdW9gVKq5hhjXsRW5Z0kIu76Ts9haDVwPLZ6+kLgHWPM0HpMz2HFGNMd23/pJBHJr+/0HI5E5Dv/98aYecA6YDQwr14S5UdL+uXbjW1bjSm2PwbYXvJ0VQpvPpWXh9uBVsYY4z1Y+Lo1jSifjTEvAZcAJ4vIOr9DmoeVJCJ5IvKXiKSIyP3YGpN/onlYWUnYGs7lxpgCY0wBMAS4sfD1nsLzNB8rSUQygOXA0TSA30MN+uUQkTwgBTil2KFTCGxvUWVbj/1F9eWhMSYUGERRHs7Ftr0m+V2XBETQSPLZGDOBooC/qthhzcND5wBcaB5W1hfYnubH+23JwIeFr/9E87FKCvOnB7YDX/3/HtZ3T8eGvgEXA3nANdhelROwnSw61nfaGspW+At6fOGWBTxc+LpD4fF7gQPA+UA89g/IViDK7x7fAcsKf7mTCl9/Xd/frY7y71XgIHa4XqzfFul3juZhxfn4NPaPZyds4PoX4AHO0DysVr7OoLD3vuZjpfLreWztSGegP/BN4f/vjg0h/+o9gw6HDbgR2IDtHJQCDK7vNDWkDTvOXErZJhceN9hhLNuAHGAmEF/sHs2B9wv/cxwsfN2svr9bHeVfaXknwCN+52geVpyPk4GNhf9PdwI/AadpHlY7X4sHfc3H8vPLG8TzgC3AZ0DPhpJ/uuCOUkop1Uhom75SSinVSGjQV0oppRoJDfpKKaVUI6FBXymllGokNOgrpZRSjYQGfaWUUqqR0KCvVD0wxiQZYz4uXIkrzxizxxgz3Rgz2hjjLDxnjDFGjDGd/K7bYIyZXOxeZxtjlhljcgrPb2aMcRhj/m2M2WaM8RhjvqjF79Kp8HPHVHCe9/scVVtpOVTGmHONMXeUsn9oYZqH10e6lKppuuCOUnXMGHM78CLwC3Z2ro3YyThOBf4L7Ae+LOPy87CTdXjvFQRMwU7PeRN2QpB07GIztwF3Yqf13FPiTsrfucBw7L+LUkcsDfpK1SFjzGBsYHlFRG4tdvjLwlX2Isq6XkQWF9vVFogCPhaR3/w+55jCl/8WEU8NpNslIrnVvY9Sqn5p9b5SdeteYC9wT2kHRWStiCwt62L/6n1jzCPY6aEB/ldYDT3DGLMBO80ngNu/6t0Y08YY864xZrcxJtcYs9QYc3mxz/BWww82xnxijNmPXSMcY0y4Mea1wuaIDGPMV0C7Q8iHMhljrjPG/FHYXLHbGPM/Y0x0sXPEGPOEMeZWY8x6Y0y6MWamMaZXsfOchedtM8ZkGWN+Mcb0KLz+kcJzJmOXPW1buF8K89BfuDHmlcL07DbGvG+MaVaT31upuqAlfaXqSGFb/TDgCxHJqYFbvgmkAp8ATwD/h636dwG3AmMoWqlrrTEmAjvPd3NgHLAZuBx4zxgTLiKTit1/CvABtqnA+7fidewiVI8CC7GrhU2tge8CgDHmaWyTxH+Au7E1GU8A8caYgSLi9jv9cmA1thkjBHgOW1vSQ0QKCs95tPC7Poediz8B+KrYxz4OtAJOAM4p3Fe8VmMCduGUS4HuwLPYZbdHV+f7KlXXNOgrVXdaAmHYNvxqE5E0Y8ySwrdrRWSe95gxZkvhOf77bsau6T1MRGYU7v7OGBMDPGGM+V+xoPqpiNzjd313bNB7QESeLtz9ozEmEhhb3e9T2GHxbuBREXnMb/+fwGzgbOzSr175wFkikl94HtgHoH7AHGNMc+B2YKKI3Ft4zXRjTB7wgvcmIrLWGLMLyPPPr2J+E5FbCl//WJgX1xhjxoguYKIOI1q9r1TjMRjY4hfwvd7HlnR7Ftv/ebH3/bF/Mz4utv/DGkrfKYX3n2KMCfJu2KaFdGz6/U33BvxCywp/dij82RvbP+KTYtd9eghp+79i75dha1RiDuFeStUbLekrVXf2ANlAx3r6/Gjscp7Fbfc77q/4uW0Kf+4otr/4+0PVuvDnX2Ucb1Hs/d5i771V8qGFP73p3VnsvENJb0WfpdRhQYO+UnVERAqMMTOAU+qpN/xebHt0cbF+x/0Vr7b2PgTEAOv89tdUadc7rPBUYF85xyvLm97WwHK//Vo6V42WVu8rVbeexpZYny3toDGmszHm2Fr67JlAO2PMicX2X4otDa+o4Pr5gAe4qNj+UTWTPKYX3r+DiCSXsq2v4v2WAZnA34vtL/4ebMk9rOpJVurwoiV9peqQiPxWOPPbi8aYnsBkYBO2R/3fgGuwQbjMYXvVMBnb032aMeYBIA24DNuWfn2xTnylpX21MWYq8JgxxoHtvX8qcGYV03G6MWZ7sX0HRGS6MeYZ4JXCjnIzgRygfWEa3xSRXyv7ISKyzxjzb2CcMSYd23u/L3B14Sn+8xesAKKNMTcAyUCOiCxDqSOMBn2l6piI/NsYswD4J/A8tld/OjbYXA98XUufm2mMGYKtZXgaO6nPauAKEXm/kre5HsgA7sIOk/sF+5AyuwpJebmUfcuBeBEZZ4xZiZ1d8CZsE8Nm4GdgTRU+w2s8YLCB/lZsbcUY4HfggN95bwIDgKeAZtgRFp0O4fOUatCMjjZRSjUmxpgLsT36B4vIrPpOj1J1SYO+UuqIZYzpD4zAlvBzsJPz3Iet4RioY+xVY6PV+0qpI1kGdnz/TUATbIfFj4H7NeCrxkhL+koppVQjoUP2lFJKqUZCg75SSinVSGjQV0oppRoJDfpKKaVUI6FBXymllGokNOgrpZRSjcT/A4wrH/NdqXqFAAAAAElFTkSuQmCC\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -360,7 +360,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x360 with 1 Axes>"
       ]
@@ -406,92 +406,92 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: be8f2f3b-3d53-4464-99e0-69984fbb2237\n",
+      "Experiment ID: a0fa8768-71cd-40a4-8438-931cdd9b9eea\n",
       "Status: DONE\n",
       "Circuits: 140\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- a: 0.5005193843435272 ± 0.04440989254995643\n",
-      "- alpha: 0.9974798908775014 ± 0.00036299147771944886\n",
-      "- b: 0.485239839914178 ± 0.045084715621612516\n",
-      "- reduced_chisq: 0.07359811264225856\n",
+      "- a: 0.48179621388397165 ± 0.09442477018477685\n",
+      "- alpha: 0.9982837081083952 ± 0.0004687374781179952\n",
+      "- b: 0.5059960643224992 ± 0.09600953406995398\n",
+      "- reduced_chisq: 0.19535039815566677\n",
       "- dof: 11\n",
       "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.0012600545612492797\n",
-      "- EPC_err: 0.00018195428350947435\n",
+      "- EPC: 0.0008581459458024132\n",
+      "- EPC_err: 0.00023477167578252162\n",
       "- success: True \n",
       "\n",
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: 80e43c31-faad-42f0-adec-c6a96cd760fc\n",
+      "Experiment ID: 48bdf15a-3c8c-4b7f-bdff-87150897fe21\n",
       "Status: DONE\n",
       "Circuits: 140\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- a: 0.4729151274362826 ± 0.0586569701158699\n",
-      "- alpha: 0.9976906217132455 ± 0.0004370644794444831\n",
-      "- b: 0.5184707054269991 ± 0.05975003836406632\n",
-      "- reduced_chisq: 0.11699670616340346\n",
+      "- a: 0.4644044949493171 ± 0.09896602652728038\n",
+      "- alpha: 0.9985514173179291 ± 0.00039834142468434035\n",
+      "- b: 0.5266142231114757 ± 0.09950372547952774\n",
+      "- reduced_chisq: 0.2004720802914708\n",
       "- dof: 11\n",
       "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.001154689143377241\n",
-      "- EPC_err: 0.00021903808151165695\n",
+      "- EPC: 0.0007242913410354657\n",
+      "- EPC_err: 0.00019945964613132802\n",
       "- success: True \n",
       "\n",
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: de32fa6f-8db9-4783-ad0f-78e66fa5b66e\n",
+      "Experiment ID: 454d15f5-0455-4d85-abc1-c46f268e0685\n",
       "Status: DONE\n",
       "Circuits: 140\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- a: 0.4876872464791774 ± 0.04293214674217141\n",
-      "- alpha: 0.9977218699426396 ± 0.0003173007460854797\n",
-      "- b: 0.49930626492685787 ± 0.04376165812301661\n",
-      "- reduced_chisq: 0.07986148340397502\n",
+      "- a: 0.463676502224092 ± 0.10165801492643219\n",
+      "- alpha: 0.9984919545907562 ± 0.00044156271975226197\n",
+      "- b: 0.5239921150635326 ± 0.10277174994074663\n",
+      "- reduced_chisq: 0.07676654927497478\n",
       "- dof: 11\n",
       "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.0011390650286802195\n",
-      "- EPC_err: 0.00015901262448207224\n",
+      "- EPC: 0.0007540227046218817\n",
+      "- EPC_err: 0.00022111481105185354\n",
       "- success: True \n",
       "\n",
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: cd612ce6-c7ec-4379-87f2-1ef7a390a145\n",
+      "Experiment ID: e7f28773-a077-4bfd-8445-1dd875b56ee7\n",
       "Status: DONE\n",
       "Circuits: 140\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- a: 0.48497087640323777 ± 0.008807354322866709\n",
-      "- alpha: 0.9887157842315621 ± 0.0006549364697891019\n",
-      "- b: 0.5061929930128293 ± 0.0066319206049770445\n",
-      "- reduced_chisq: 0.15798909346766063\n",
+      "- a: 0.48244135430423285 ± 0.009481242006547387\n",
+      "- alpha: 0.9927883100023426 ± 0.00040568366270580185\n",
+      "- b: 0.5114197178601058 ± 0.009488345070577987\n",
+      "- reduced_chisq: 0.11986347176123821\n",
       "- dof: 11\n",
       "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.005642107884218928\n",
-      "- EPC_err: 0.00033120563069503526\n",
+      "- EPC: 0.003605844998828711\n",
+      "- EPC_err: 0.0002043152898853355\n",
       "- success: True \n",
       "\n",
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: e4afa8b5-5e90-4688-863f-b0fb99b60c25\n",
+      "Experiment ID: 08354cff-6a8c-438f-84ee-61d1a2400716\n",
       "Status: DONE\n",
       "Circuits: 140\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- a: 0.4862870470137793 ± 0.026551499859339103\n",
-      "- alpha: 0.9967798184999347 ± 0.00034590875294202597\n",
-      "- b: 0.5000614956081333 ± 0.027624168605153588\n",
-      "- reduced_chisq: 0.15008348329804122\n",
+      "- a: 0.4695517787058582 ± 0.04993631327375763\n",
+      "- alpha: 0.9978783659580331 ± 0.0003236755966567879\n",
+      "- b: 0.517213471801888 ± 0.05043149884050479\n",
+      "- reduced_chisq: 0.18823926367791033\n",
       "- dof: 11\n",
       "- xrange: [1.0, 500.0]\n",
-      "- EPC: 0.0016100907500326556\n",
-      "- EPC_err: 0.0001735131202107342\n",
+      "- EPC: 0.001060817020983429\n",
+      "- EPC_err: 0.00016218188894497008\n",
       "- success: True \n",
       "\n"
      ]

From a1be5975553355a1bc80d9b1b0e836f2ff7866e7 Mon Sep 17 00:00:00 2001
From: Naoki Kanazawa <nkanazawa1989@gmail.com>
Date: Mon, 7 Jun 2021 21:06:18 +0900
Subject: [PATCH 60/74] Update qiskit_experiments/analysis/curve_analysis.py

Co-authored-by: Daniel Egger <38065505+eggerdj@users.noreply.github.com>
---
 qiskit_experiments/analysis/curve_analysis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index a96509235d..276e3978cd 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -53,7 +53,7 @@ class CurveAnalysis(BaseAnalysis):
 
     Class Attributes:
 
-        __series__: A set of data points that will be fit to a the same parameters
+        __series__: A set of data points that will be fit to the same parameters
             in the fit function. If this analysis contains multiple curves,
             the same number of series definitions should be listed.
             Each series definition is SeriesDef element, that may be initialized with::

From 1bbc199f43df49ffbbe19aa7bc3ade14c790c629 Mon Sep 17 00:00:00 2001
From: Naoki Kanazawa <nkanazawa1989@gmail.com>
Date: Mon, 7 Jun 2021 21:06:28 +0900
Subject: [PATCH 61/74] Update qiskit_experiments/analysis/curve_analysis.py

Co-authored-by: Daniel Egger <38065505+eggerdj@users.noreply.github.com>
---
 qiskit_experiments/analysis/curve_analysis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 276e3978cd..8f5a35f58b 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -56,7 +56,7 @@ class CurveAnalysis(BaseAnalysis):
         __series__: A set of data points that will be fit to the same parameters
             in the fit function. If this analysis contains multiple curves,
             the same number of series definitions should be listed.
-            Each series definition is SeriesDef element, that may be initialized with::
+            Each series definition is SeriesDef element, that may be initialized with:
 
                 fit_func: Callback function to perform fit.
                 filter_kwargs: Circuit metadata key and value associated with this curve.

From 9f294b07706be62ba9600f42f2d6e5985b320724 Mon Sep 17 00:00:00 2001
From: Naoki Kanazawa <nkanazawa1989@gmail.com>
Date: Mon, 7 Jun 2021 21:06:45 +0900
Subject: [PATCH 62/74] Update qiskit_experiments/analysis/curve_analysis.py

Co-authored-by: Daniel Egger <38065505+eggerdj@users.noreply.github.com>
---
 qiskit_experiments/analysis/curve_analysis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 8f5a35f58b..9cc24d70cb 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -58,7 +58,7 @@ class CurveAnalysis(BaseAnalysis):
             the same number of series definitions should be listed.
             Each series definition is SeriesDef element, that may be initialized with:
 
-                fit_func: Callback function to perform fit.
+                fit_func: The function to which the data will be fit.
                 filter_kwargs: Circuit metadata key and value associated with this curve.
                     The data points of the curve is extracted from ExperimentData based on
                     this information.

From 84491618188a7211275dfade3d01ba5ccd30d4c7 Mon Sep 17 00:00:00 2001
From: Naoki Kanazawa <nkanazawa1989@gmail.com>
Date: Mon, 7 Jun 2021 21:06:58 +0900
Subject: [PATCH 63/74] Update qiskit_experiments/analysis/curve_analysis.py

Co-authored-by: Daniel Egger <38065505+eggerdj@users.noreply.github.com>
---
 qiskit_experiments/analysis/curve_analysis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 9cc24d70cb..ac306b75b5 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -60,7 +60,7 @@ class CurveAnalysis(BaseAnalysis):
 
                 fit_func: The function to which the data will be fit.
                 filter_kwargs: Circuit metadata key and value associated with this curve.
-                    The data points of the curve is extracted from ExperimentData based on
+                    The data points of the curve are extracted from ExperimentData based on
                     this information.
                 name: Name of the curve. This is arbitrary data field, but should be unique.
                 plot_color: String color representation of this series in the plot.

From 0729d6cb6e4349f77f9b2ba7b5af75df72dbd6be Mon Sep 17 00:00:00 2001
From: Naoki Kanazawa <nkanazawa1989@gmail.com>
Date: Mon, 7 Jun 2021 21:07:22 +0900
Subject: [PATCH 64/74] Update qiskit_experiments/analysis/curve_analysis.py

Co-authored-by: Daniel Egger <38065505+eggerdj@users.noreply.github.com>
---
 qiskit_experiments/analysis/curve_analysis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index ac306b75b5..9eb01c204b 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -221,7 +221,7 @@ def __init__(self):
         #: Iterable[float]: Concatenated y sigmas of all series
         self._y_sigmas = None
 
-        #: int: Number of qubit
+        #: int: Number of qubits
         self._num_qubits = None
 
         # Add expected options to instance variable so that every method can access to.

From e3bb02276d3b24c2cbf175b097ffc1a8ea35664b Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Mon, 7 Jun 2021 22:29:51 +0900
Subject: [PATCH 65/74] - more docstring - add y normalization

---
 qiskit_experiments/analysis/curve_analysis.py | 80 ++++++++++++++++---
 qiskit_experiments/analysis/curve_fitting.py  | 30 ++++++-
 .../characterization/qubit_spectroscopy.py    |  8 +-
 .../interleaved_rb_analysis.py                |  5 ++
 .../randomized_benchmarking/rb_analysis.py    |  5 ++
 5 files changed, 115 insertions(+), 13 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 9eb01c204b..0ec3c27f31 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -119,6 +119,10 @@ class AnalysisExample(CurveAnalysis):
                     ),
                 ]
 
+        In this fit model, we have 4 parameters `p0, p1, p2, p3` and both series share
+        `p0` and `p3` as `amp` and `baseline` of the `exponential_decay` fit function.
+        Parameter `p1` (`p2`) is only used by `my_experiment1` (`my_experiment2`).
+        Both series have same fit function in this example.
 
         A fitting for two trigonometric curves with the same parameter
         =============================================================
@@ -149,6 +153,10 @@ class AnalysisExample(CurveAnalysis):
                     ),
                 ]
 
+        In this fit model, we have 4 parameters `p0, p1, p2, p3` and both series share
+        all parameters. However, these series have different fit curves, i.e.
+        `my_experiment1` (`my_experiment2`) uses the `cos` (`sin`) fit function.
+
 
     Notes:
         This CurveAnalysis class provides several private methods that subclasses can override.
@@ -158,7 +166,7 @@ class AnalysisExample(CurveAnalysis):
             arbitrary number of new figures or upgrade the default figure appearance.
 
         - Customize pre-data processing:
-            Override :meth:`~self._data_pre_processing`. For example, here you can
+            Override :meth:`~self._pre_processing`. For example, here you can
             take a mean over y values for the same x value, or apply smoothing to y values.
 
         - Customize post-analysis data processing:
@@ -169,6 +177,8 @@ class AnalysisExample(CurveAnalysis):
             Override :meth:`~self._setup_fitting`. For example, here you can
             calculate initial guess from experiment data and setup fitter options.
 
+        See docstring of each method for more details.
+
         Note that other private methods are not expected to be overridden.
         If you forcibly override these methods, the behavior of analysis logic is not well tested
         and we cannot guarantee it works as expected (you may suffer from bugs).
@@ -261,6 +271,7 @@ def data_processor(data: Dict[str, Any]) -> Tuple[float, float]
 
                 This can be a :class:`~qiskit_experiment.data_processing.DataProcessor`
                 instance that defines the `self.__call__` method.
+            normalization: Set ``True`` to normalize y values within range [-1, 1].
             p0: Array-like or dictionary of initial parameters.
             bounds: Array-like or dictionary of (min, max) tuple of fit parameter boundaries.
             x_key: Circuit metadata key representing a scanned value.
@@ -274,6 +285,7 @@ def data_processor(data: Dict[str, Any]) -> Tuple[float, float]
         return Options(
             curve_fitter=multi_curve_fit,
             data_processor=probability(outcome="1"),
+            normalization=False,
             p0=None,
             bounds=None,
             x_key="xval",
@@ -413,14 +425,50 @@ def _create_figures(self, analysis_results: CurveAnalysisResult) -> List["Figure
     def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
         """An analysis subroutine that is called to set fitter options.
 
-        This subroutine takes full data array and user-input fit options.
         Subclasses can override this method to provide own fitter options
         such as initial guesses.
 
+        To provide initial guesses from raw data, you can access to these data by
+        `self._x_values` and `self._y_values`. If your analysis contains multiple series,
+        you can extract specific x or y values with `self._subset_data` method with
+        the name of series of interest.
+        You can also access to the defined analysis options with `self._get_option` method:
+
+        .. code-block::
+
+            sub_x_vals, sub_y_vals = self._subset_data(
+                name="my_experiment1",
+                data_index: self._data_index,
+                x_values: self._x_values,
+                y_values: self._y_values,
+                y_sigmas: self._y_sigmas,
+            )
+
+            if self._get_option("my_option1") == "abc":
+                p0 = ...
+                bounds = ...
+            else:
+                p0 = ...
+                bounds = ...
+
+            return {"p0": p0, "bounds": bounds}
+
         Note that this subroutine can generate multiple fit options.
         If multiple options are provided, fitter runs multiple times for each fit option,
         and find the best result measured by the reduced chi-squared value.
 
+        .. code-block::
+
+            fit_1 = {"p0": p0_1, "bounds": bounds, "extra_fit_parameter": "option1"}
+            fit_2 = {"p0": p0_2, "bounds": bounds, "extra_fit_parameter": "option2"}
+
+            return [fit_1, fit_2]
+
+        Note that you can also change fitter options (not only initial guesses) in each
+        fit condition. This might be convenient to fit parameter with multiple fit algorithms
+        or different fitting options. By default, this class uses `scipy.curve_fit`
+        as the fitter function. See Scipy API docs for more fitting option details.
+
         Args:
             options: User provided extra options that are not defined in default options.
 
@@ -466,15 +514,18 @@ def _extract_curves(
     ):
         """Extract curve data from experiment data.
 
-        This method internally populate `self.__x_values`, `self.__y_values`, `self.__y_sigmas`
-        and `self.__data_index` with given `experiment_data`.
+        This method internally populate `self._x_values`, `self._y_values`, `self._y_sigmas`
+        and `self._data_index` with given `experiment_data`.
 
         .. notes::
             The target metadata properties to define each curve entry is described by
-            the class attribute __series__. This method returns the same numbers
-            of curve data entries as one defined in this attribute.
-            The returned CurveData entry contains circuit metadata fields that are
-            common to the entire curve scan, i.e. series-level metadata.
+            the class attribute __series__ (see `filter_kwargs`).
+            This function returns concatenated x, y, and sigma values with data index array
+            with the same length as other extracted data.
+            The i-th `self._data_index` value represent the series index of i-th
+            `self._x_values`, `self._y_values`, and `self._y_sigmas`.
+            The helper function `self._subset_data` is available to extract
+            (x values, y values, y sigmas) set of the specific series distinguished by `name`.
 
         Args:
             experiment_data: ExperimentData object to fit parameters.
@@ -483,7 +534,8 @@ def _extract_curves(
                 that represent a y value and an error of it.
         Raises:
             DataProcessorError:
-                - When __x_key__ is not defined in the circuit metadata.
+                - When `x_key` specified in the analysis option is not
+                    defined in the circuit metadata.
         """
 
         def _is_target_series(datum, **filters):
@@ -505,10 +557,16 @@ def _is_target_series(datum, **filters):
 
         y_values, y_sigmas = zip(*map(data_processor, data))
 
+        if self._get_option("normalization"):
+            y_min, y_max = min(y_values), max(y_values)
+            scale = 1 / (y_max - y_min)
+        else:
+            scale = 1.
+
         # Format data
         self._x_values = np.asarray(x_values, dtype=float)
-        self._y_values = np.asarray(y_values, dtype=float)
-        self._y_sigmas = np.asarray(y_sigmas, dtype=float)
+        self._y_values = np.asarray(y_values, dtype=float) * scale
+        self._y_sigmas = np.asarray(y_sigmas, dtype=float) * scale
 
         # Find series (invalid data is labeled as -1)
         self._data_index = -1 * np.ones(self._x_values.size, dtype=int)
diff --git a/qiskit_experiments/analysis/curve_fitting.py b/qiskit_experiments/analysis/curve_fitting.py
index 2f94d55264..c42ee17219 100644
--- a/qiskit_experiments/analysis/curve_fitting.py
+++ b/qiskit_experiments/analysis/curve_fitting.py
@@ -24,7 +24,35 @@
 
 
 class CurveAnalysisResult(AnalysisResult):
-    """Analysis data container for curve fit analysis."""
+    """Analysis data container for curve fit analysis.
+
+    Class Attributes:
+        __keys_not_shown__: Data keys of analysis result which are not directly shown
+            in `__str__` method. By default, `pcov` (covariance matrix),
+            `raw_data` (raw x, y, sigma data points), `popt`, `popt_keys`, and `popt_err`
+            are not displayed. Fit parameters (popt) are formatted to
+
+            .. code-block::
+
+                p0 = 1.2 ± 0.34
+                p1 = 5.6 ± 0.78
+
+            rather showing raw key-value pairs
+
+            .. code-block::
+
+                popt_keys = ["p0", "p1"]
+                popt = [1.2, 5.6]
+                popt_err = [0.34, 0.78]
+
+            The covariance matrix and raw data points are not shown because they output
+            very long string usually doesn't fit in with the summary of the analysis object,
+            i.e. user wants to quickly get the over view of fit values and goodness of fit,
+            such as the chi-squared value and computer evaluated quality.
+
+            However these non-displayed values are still kept and user can access to
+            these values with `result["raw_data"]` and `result["pcov"]` if necessary.
+    """
 
     __keys_not_shown__ = "pcov", "raw_data", "popt", "popt_keys", "popt_err"
 
diff --git a/qiskit_experiments/characterization/qubit_spectroscopy.py b/qiskit_experiments/characterization/qubit_spectroscopy.py
index ab36bb033b..8783a10542 100644
--- a/qiskit_experiments/characterization/qubit_spectroscopy.py
+++ b/qiskit_experiments/characterization/qubit_spectroscopy.py
@@ -61,10 +61,16 @@ class SpectroscopyAnalysis(CurveAnalysis):
 
     @classmethod
     def _default_options(cls):
+        """Return default data processing options.
+
+        See :meth:`~qiskit_experiment.analysis.CurveAnalysis._default_options` for
+        descriptions of analysis options.
+        """
         default_options = super()._default_options()
         default_options.p0 = {"a": None, "sigma": None, "freq": None, "b": None}
         default_options.bounds = {"a": None, "sigma": None, "freq": None, "b": None}
-        default_options.fit_reports = {"freq": "freq"}
+        default_options.fit_reports = {"freq": "frequency"}
+        default_options.normalization = True
 
         return default_options
 
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index 43ff588ee9..e2cf53a64c 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -65,6 +65,11 @@ class InterleavedRBAnalysis(RBAnalysis):
 
     @classmethod
     def _default_options(cls):
+        """Return default data processing options.
+
+        See :meth:`~qiskit_experiment.analysis.CurveAnalysis._default_options` for
+        descriptions of analysis options.
+        """
         default_options = super()._default_options()
         default_options.p0 = {"a": None, "alpha": None, "alpha_c": None, "b": None}
         default_options.bounds = {
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index 05ebf8bbd4..c9b962c6d9 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -42,6 +42,11 @@ class RBAnalysis(CurveAnalysis):
 
     @classmethod
     def _default_options(cls):
+        """Return default data processing options.
+
+        See :meth:`~qiskit_experiment.analysis.CurveAnalysis._default_options` for
+        descriptions of analysis options.
+        """
         default_options = super()._default_options()
         default_options.p0 = {"a": None, "alpha": None, "b": None}
         default_options.bounds = {"a": (0.0, 1.0), "alpha": (0.0, 1.0), "b": (0.0, 1.0)}

From abe5ea446f2d6a59dce52347e577e7b432891c10 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Mon, 7 Jun 2021 23:54:27 +0900
Subject: [PATCH 66/74] black

---
 qiskit_experiments/analysis/curve_analysis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 0ec3c27f31..4e23e141fa 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -561,7 +561,7 @@ def _is_target_series(datum, **filters):
             y_min, y_max = min(y_values), max(y_values)
             scale = 1 / (y_max - y_min)
         else:
-            scale = 1.
+            scale = 1.0
 
         # Format data
         self._x_values = np.asarray(x_values, dtype=float)

From 0e9e89f1fa80298d1491997f784a5bec0b7b0a85 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 8 Jun 2021 01:11:49 +0900
Subject: [PATCH 67/74] add TODO comment

---
 qiskit_experiments/analysis/curve_analysis.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 4e23e141fa..2529f15afc 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -557,6 +557,10 @@ def _is_target_series(datum, **filters):
 
         y_values, y_sigmas = zip(*map(data_processor, data))
 
+        # TODO this should be handled in data processor.
+        # Future data processor may take full sequence of data rather than datum.
+        # The CurveAnalysis can pass series filter_kwargs to the processor
+        # so that it can filter data to extract.
         if self._get_option("normalization"):
             y_min, y_max = min(y_values), max(y_values)
             scale = 1 / (y_max - y_min)

From bc060d758e554a90de346963353ffa117ef6b012 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 8 Jun 2021 01:14:03 +0900
Subject: [PATCH 68/74] add analysis class information to result data

---
 qiskit_experiments/analysis/curve_analysis.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 2529f15afc..267c95bd19 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -729,6 +729,7 @@ def _run_analysis(
             AnalysisError: if the analysis fails.
         """
         analysis_result = CurveAnalysisResult()
+        analysis_result["analysis_type"] = self.__class__.__name__
         figures = list()
 
         # pop arguments that are not given to fitter

From 03bc71bcfc5f38934b70cc4024f16373970c6b65 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 8 Jun 2021 03:19:59 +0900
Subject: [PATCH 69/74] fix unittest

---
 test/analysis/test_curve_fit.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/analysis/test_curve_fit.py b/test/analysis/test_curve_fit.py
index c3c2cbf473..80eb55496b 100644
--- a/test/analysis/test_curve_fit.py
+++ b/test/analysis/test_curve_fit.py
@@ -336,7 +336,7 @@ def test_run_single_curve_fail(self):
 
         self.assertFalse(result["success"])
 
-        ref_result_keys = ["error_message", "success", "raw_data"]
+        ref_result_keys = ["analysis_type", "error_message", "success", "raw_data"]
         self.assertSetEqual(set(result.keys()), set(ref_result_keys))
 
     def test_run_two_curves_with_same_fitfunc(self):

From b416c80ca4ac7846ccf5df13e5cc1eaddecd8fdb Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 8 Jun 2021 03:57:25 +0900
Subject: [PATCH 70/74] update spect analysis docstring

---
 .../characterization/qubit_spectroscopy.py    | 32 +++++++++++++++----
 1 file changed, 25 insertions(+), 7 deletions(-)

diff --git a/qiskit_experiments/characterization/qubit_spectroscopy.py b/qiskit_experiments/characterization/qubit_spectroscopy.py
index 8783a10542..fa6c9175b2 100644
--- a/qiskit_experiments/characterization/qubit_spectroscopy.py
+++ b/qiskit_experiments/characterization/qubit_spectroscopy.py
@@ -38,16 +38,34 @@
 class SpectroscopyAnalysis(CurveAnalysis):
     """A class to analyze a spectroscopy experiment.
 
-    Analyze a spectroscopy experiment by fitting the data to a Gaussian function.
-    The fit function is:
+    Overview:
+        This analysis takes only single series. This series is fit by the Gaussian function.
 
-    .. math::
+    Fit Model:
+        The fit is based on the following Gaussian function.
 
-        a * exp(-(x-x0)**2/(2*sigma**2)) + b
+        .. math::
+
+            a * exp(-(x-freq)**2/(2*sigma**2)) + b
+
+    Fit Parameters:
+        a: Peak height.
+        b: Base line.
+        freq: Center frequency. This is the fit parameter of main interest.
+        sigma: Standard deviation of Gaussian function.
+
+    Initial Guesses:
+        a: The maximum signal value with removed baseline.
+        b: A median value of the signal.
+        freq: A frequency value at the peak (maximum signal).
+        sigma: Calculated from FWHM of peak :math:`w` such that :math:`w / sqrt(8) ln{2}`.
+
+    Bounds:
+        a: [-2, 2] scaled with maximum signal value.
+        b: [-1, 1] scaled with maximum signal value.
+        freq: [min(freq), max(freq)] of frequency scan range.
+        sigma: [0, delta f] where delta f represents frequency scan range.
 
-    Here, :math:`x` is the frequency. The analysis loops over the initial guesses
-    of the width parameter :math:`sigma`. The measured y-data will be rescaled to
-    the interval (0,1).
     """
 
     __series__ = [

From aea9e26b9b0c7e630ead34fdd6d0f3b468ba267d Mon Sep 17 00:00:00 2001
From: Naoki Kanazawa <nkanazawa1989@gmail.com>
Date: Tue, 8 Jun 2021 03:57:55 +0900
Subject: [PATCH 71/74] Update qiskit_experiments/analysis/curve_analysis.py

Co-authored-by: Daniel Egger <38065505+eggerdj@users.noreply.github.com>
---
 qiskit_experiments/analysis/curve_analysis.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 267c95bd19..8ceec06696 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -425,14 +425,14 @@ def _create_figures(self, analysis_results: CurveAnalysisResult) -> List["Figure
     def _setup_fitting(self, **options) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
         """An analysis subroutine that is called to set fitter options.
 
-        Subclasses can override this method to provide own fitter options
+        Subclasses can override this method to provide their own fitter options
         such as initial guesses.
 
-        To provide initial guesses from raw data, you can access to these data by
+        To create initial guesses from the raw data, you can access these data by
         `self._x_values` and `self._y_values`. If your analysis contains multiple series,
-        you can extract specific x or y values with `self._subset_data` method with
-        the name of series of interest.
-        You can also access to the defined analysis options with `self._get_option` method:
+        you can extract specific x or y values with the `self._subset_data` method using
+        the name of the series of interest.
+        You can also access the defined analysis options with the `self._get_option` method:
 
         .. code-block::
 

From 8f20f55a5b599310aae601018a72b1c00264c68f Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 8 Jun 2021 12:54:16 +0900
Subject: [PATCH 72/74] rb analysis class docstring

---
 .../characterization/qubit_spectroscopy.py    |  4 +-
 .../interleaved_rb_analysis.py                | 76 +++++++++++++++----
 .../randomized_benchmarking/rb_analysis.py    | 33 +++++++-
 3 files changed, 97 insertions(+), 16 deletions(-)

diff --git a/qiskit_experiments/characterization/qubit_spectroscopy.py b/qiskit_experiments/characterization/qubit_spectroscopy.py
index fa6c9175b2..d03f16c6db 100644
--- a/qiskit_experiments/characterization/qubit_spectroscopy.py
+++ b/qiskit_experiments/characterization/qubit_spectroscopy.py
@@ -36,7 +36,7 @@
 
 
 class SpectroscopyAnalysis(CurveAnalysis):
-    """A class to analyze a spectroscopy experiment.
+    """A class to analyze spectroscopy experiment.
 
     Overview:
         This analysis takes only single series. This series is fit by the Gaussian function.
@@ -46,7 +46,7 @@ class SpectroscopyAnalysis(CurveAnalysis):
 
         .. math::
 
-            a * exp(-(x-freq)**2/(2*sigma**2)) + b
+            F(x) = a * exp(-(x-freq)**2/(2*sigma**2)) + b
 
     Fit Parameters:
         a: Peak height.
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index e2cf53a64c..acf9c52d90 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -27,19 +27,69 @@
 
 
 class InterleavedRBAnalysis(RBAnalysis):
-    r"""Interleaved RB Analysis class.
-    According to the paper: "Efficient measurement of quantum gate
-    error by interleaved randomized benchmarking" (arXiv:1203.4550)
-
-    The epc estimate is obtained using the equation
-    :math:`r_{\mathcal{C}}^{\text{est}}=
-    \frac{\left(d-1\right)\left(1-p_{\overline{\mathcal{C}}}/p\right)}{d}`
-
-    The error bounds are given by
-    :math:`E=\min\left\{ \begin{array}{c}
-    \frac{\left(d-1\right)\left[\left|p-p_{\overline{\mathcal{C}}}\right|+\left(1-p\right)\right]}{d}\\
-    \frac{2\left(d^{2}-1\right)\left(1-p\right)}{pd^{2}}+\frac{4\sqrt{1-p}\sqrt{d^{2}-1}}{p}
-    \end{array}\right.`
+    r"""A class to analyze interleaved randomized benchmarking experiment.
+
+    Overview:
+        This analysis takes only two series for standard and interleaved RB curve fitting.
+        From the fit :math:`alpha` and :math:`alpha_c` value this analysis estimates
+        the error per Clifford (EPC) of interleaved gate.
+
+        The EPC estimate is obtained using the equation
+
+        .. math::
+
+            r_{\mathcal{C}}^{\text{est}} =
+                \frac{\left(d-1\right)\left(1-p_{\overline{\mathcal{C}}}/p\right)}{d}
+
+        The error bounds are given by
+
+        .. math::
+
+            E = \min\left\{
+                \begin{array}{c}
+                    \frac{\left(d-1\right)\left[
+                        \left|p-p_{\overline{\mathcal{C}}}\right|+\left(1-p\right)
+                    \right]}{d}\\
+                    \frac{2\left(d^{2}-1\right)\left(1-p\right)}{pd^{2}}
+                        +\frac{4\sqrt{1-p}\sqrt{d^{2}-1}}{p}
+                \end{array}
+            \right.
+
+        See the reference[1] for more details.
+
+    Fit Model:
+        The fit is based on the following decay function.
+
+        .. math::
+
+            F1(x) = a * alpha**x + b  (standard RB)
+            F2(x) = a * (alpha_c * alpha)**x + b  (interleaved RB)
+
+    Fit Parameters:
+        a: Height of decay curve.
+        b: Base line.
+        alpha: Depolarizing parameter.
+        alpha_c: Ratio of the depolarizing parameter of interleaved RB to standard RB curve.
+
+    Initial Guesses:
+        a: Determined by the average :math:`a` of the standard and interleaved RB.
+        b: Determined by the average :math:`b` of the standard and interleaved RB.
+            Usually equivalent to :math:`(1/2)**n` where :math:`n` is number of qubit.
+        alpha: Determined by the slope of :math:`(F1(x) - b)**(1/x)` of the first and the
+            second data point of the standard RB.
+        alpha_c: Estimate :math:`alpha' = alpha_c * alpha` from the interleaved RB curve,
+            then divide this by the initial guess of :math:`alpha`.
+
+    Bounds:
+        a: [0, 1]
+        b: [0, 1]
+        alpha: [0, 1]
+        alpha_c: [0, 1]
+
+    References:
+        [1] "Efficient measurement of quantum gate error by interleaved randomized benchmarking"
+            (arXiv:1203.4550).
+
     """
 
     __series__ = [
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index c9b962c6d9..ca085ca995 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -29,7 +29,38 @@
 
 
 class RBAnalysis(CurveAnalysis):
-    """RB Analysis class."""
+    """A class to analyze randomized benchmarking experiment.
+
+    Overview:
+        This analysis takes only single series.
+        This series is fit by the exponential decay function.
+        From the fit :math:`alpha` value this analysis estimates the error per Clifford (EPC).
+
+    Fit Model:
+        The fit is based on the following decay function.
+
+        .. math::
+
+            F(x) = a * alpha**x + b
+
+    Fit Parameters:
+        a: Height of decay curve.
+        b: Base line.
+        alpha: Depolarizing parameter. This is the fit parameter of main interest.
+
+    Initial Guesses:
+        a: Determined by :math:`(F(x[0]) - b) / alpha**x[0]` where :math:`b` and :math:`alpha`
+            are the initial guesses.
+        b: :math:`(1/2)**n` where :math:`n` is number of qubit.
+        alpha: Determined by the slope of :math:`(F(x) - b)**(1/x)` of the first and the
+            second data point. :math:`a` is assumed to be close to 1.
+
+    Bounds:
+        a: [0, 1]
+        b: [0, 1]
+        alpha: [0, 1]
+
+    """
 
     __series__ = [
         SeriesDef(

From 03dafd4488e6b7b2b7b2be49e71e97cc6a36bb21 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 8 Jun 2021 15:49:31 +0900
Subject: [PATCH 73/74] format docstring

---
 .../characterization/qubit_spectroscopy.py    | 46 ++++++------
 .../interleaved_rb_analysis.py                | 74 ++++++++++---------
 .../randomized_benchmarking/rb_analysis.py    | 38 +++++-----
 3 files changed, 81 insertions(+), 77 deletions(-)

diff --git a/qiskit_experiments/characterization/qubit_spectroscopy.py b/qiskit_experiments/characterization/qubit_spectroscopy.py
index d03f16c6db..ef2e5cb3b6 100644
--- a/qiskit_experiments/characterization/qubit_spectroscopy.py
+++ b/qiskit_experiments/characterization/qubit_spectroscopy.py
@@ -36,35 +36,37 @@
 
 
 class SpectroscopyAnalysis(CurveAnalysis):
-    """A class to analyze spectroscopy experiment.
+    r"""A class to analyze spectroscopy experiment.
 
-    Overview:
+    Overview
         This analysis takes only single series. This series is fit by the Gaussian function.
 
-    Fit Model:
+    Fit Model
         The fit is based on the following Gaussian function.
 
         .. math::
 
-            F(x) = a * exp(-(x-freq)**2/(2*sigma**2)) + b
-
-    Fit Parameters:
-        a: Peak height.
-        b: Base line.
-        freq: Center frequency. This is the fit parameter of main interest.
-        sigma: Standard deviation of Gaussian function.
-
-    Initial Guesses:
-        a: The maximum signal value with removed baseline.
-        b: A median value of the signal.
-        freq: A frequency value at the peak (maximum signal).
-        sigma: Calculated from FWHM of peak :math:`w` such that :math:`w / sqrt(8) ln{2}`.
-
-    Bounds:
-        a: [-2, 2] scaled with maximum signal value.
-        b: [-1, 1] scaled with maximum signal value.
-        freq: [min(freq), max(freq)] of frequency scan range.
-        sigma: [0, delta f] where delta f represents frequency scan range.
+            F(x) = a \exp(-(x-f)^2/(2\sigma^2)) + b
+
+    Fit Parameters
+        - :math:`a`: Peak height.
+        - :math:`b`: Base line.
+        - :math:`f`: Center frequency. This is the fit parameter of main interest.
+        - :math:`\sigma`: Standard deviation of Gaussian function.
+
+    Initial Guesses
+        - :math:`a`: The maximum signal value with removed baseline.
+        - :math:`b`: A median value of the signal.
+        - :math:`f`: A frequency value at the peak (maximum signal).
+        - :math:`\sigma`: Calculated from FWHM of peak :math:`w`
+          such that :math:`w / \sqrt{8} \ln{2}`.
+
+    Bounds
+        - :math:`a`: [-2, 2] scaled with maximum signal value.
+        - :math:`b`: [-1, 1] scaled with maximum signal value.
+        - :math:`f`: [min(x), max(x)] of frequency scan range.
+        - :math:`\sigma`: [0, :math:`\Delta x`] where :math:`\Delta x`
+          represents frequency scan range.
 
     """
 
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index acf9c52d90..366b228104 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -29,17 +29,18 @@
 class InterleavedRBAnalysis(RBAnalysis):
     r"""A class to analyze interleaved randomized benchmarking experiment.
 
-    Overview:
+    Overview
         This analysis takes only two series for standard and interleaved RB curve fitting.
-        From the fit :math:`alpha` and :math:`alpha_c` value this analysis estimates
+        From the fit :math:`\alpha` and :math:`\alpha_c` value this analysis estimates
         the error per Clifford (EPC) of interleaved gate.
 
         The EPC estimate is obtained using the equation
 
+
         .. math::
 
             r_{\mathcal{C}}^{\text{est}} =
-                \frac{\left(d-1\right)\left(1-p_{\overline{\mathcal{C}}}/p\right)}{d}
+                \frac{\left(d-1\right)\left(1-\alpha_{\overline{\mathcal{C}}}/\alpha\right)}{d}
 
         The error bounds are given by
 
@@ -47,49 +48,50 @@ class InterleavedRBAnalysis(RBAnalysis):
 
             E = \min\left\{
                 \begin{array}{c}
-                    \frac{\left(d-1\right)\left[
-                        \left|p-p_{\overline{\mathcal{C}}}\right|+\left(1-p\right)
-                    \right]}{d}\\
-                    \frac{2\left(d^{2}-1\right)\left(1-p\right)}{pd^{2}}
-                        +\frac{4\sqrt{1-p}\sqrt{d^{2}-1}}{p}
+                    \frac{\left(d-1\right)\left[\left|\alpha-\alpha_{\overline{\mathcal{C}}}\right|
+                    +\left(1-\alpha\right)\right]}{d} \\
+                    \frac{2\left(d^{2}-1\right)\left(1-\alpha\right)}
+                    {\alpha d^{2}}+\frac{4\sqrt{1-\alpha}\sqrt{d^{2}-1}}{\alpha}
                 \end{array}
             \right.
 
         See the reference[1] for more details.
 
-    Fit Model:
-        The fit is based on the following decay function.
+
+
+    Fit Model
+        The fit is based on the following decay functions.
 
         .. math::
 
-            F1(x) = a * alpha**x + b  (standard RB)
-            F2(x) = a * (alpha_c * alpha)**x + b  (interleaved RB)
-
-    Fit Parameters:
-        a: Height of decay curve.
-        b: Base line.
-        alpha: Depolarizing parameter.
-        alpha_c: Ratio of the depolarizing parameter of interleaved RB to standard RB curve.
-
-    Initial Guesses:
-        a: Determined by the average :math:`a` of the standard and interleaved RB.
-        b: Determined by the average :math:`b` of the standard and interleaved RB.
-            Usually equivalent to :math:`(1/2)**n` where :math:`n` is number of qubit.
-        alpha: Determined by the slope of :math:`(F1(x) - b)**(1/x)` of the first and the
-            second data point of the standard RB.
-        alpha_c: Estimate :math:`alpha' = alpha_c * alpha` from the interleaved RB curve,
-            then divide this by the initial guess of :math:`alpha`.
-
-    Bounds:
-        a: [0, 1]
-        b: [0, 1]
-        alpha: [0, 1]
-        alpha_c: [0, 1]
-
-    References:
+            F_1(x_1) &= a \alpha^{x_1} + b  ... {\rm standard RB} \\
+            F_2(x_2) &= a (\alpha_c \alpha)^{x_2} + b ... {\rm interleaved RB}
+
+    Fit Parameters
+        - :math:`a`: Height of decay curve.
+        - :math:`b`: Base line.
+        - :math:`\alpha`: Depolarizing parameter.
+        - :math:`\alpha_c`: Ratio of the depolarizing parameter of
+          interleaved RB to standard RB curve.
+
+    Initial Guesses
+        - :math:`a`: Determined by the average :math:`a` of the standard and interleaved RB.
+        - :math:`b`: Determined by the average :math:`b` of the standard and interleaved RB.
+          Usually equivalent to :math:`(1/2)**n` where :math:`n` is number of qubit.
+        - :math:`\alpha`: Determined by the slope of :math:`(y_1 - b)**(-x_1)` of the first and the
+          second data point of the standard RB.
+        - :math:`\alpha_c`: Estimate :math:`\alpha' = \alpha_c * \alpha` from the
+          interleaved RB curve, then divide this by the initial guess of :math:`\alpha`.
+
+    Bounds
+        - :math:`a`: [0, 1]
+        - :math:`b`: [0, 1]
+        - :math:`\alpha`: [0, 1]
+        - :math:`\alpha_c`: [0, 1]
+
+    References
         [1] "Efficient measurement of quantum gate error by interleaved randomized benchmarking"
             (arXiv:1203.4550).
-
     """
 
     __series__ = [
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index ca085ca995..9552c40237 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -29,36 +29,36 @@
 
 
 class RBAnalysis(CurveAnalysis):
-    """A class to analyze randomized benchmarking experiment.
+    r"""A class to analyze randomized benchmarking experiment.
 
-    Overview:
+    Overview
         This analysis takes only single series.
         This series is fit by the exponential decay function.
-        From the fit :math:`alpha` value this analysis estimates the error per Clifford (EPC).
+        From the fit :math:`\alpha` value this analysis estimates the error per Clifford (EPC).
 
-    Fit Model:
+    Fit Model
         The fit is based on the following decay function.
 
         .. math::
 
-            F(x) = a * alpha**x + b
+            F(x) = a \alpha^x + b
 
-    Fit Parameters:
-        a: Height of decay curve.
-        b: Base line.
-        alpha: Depolarizing parameter. This is the fit parameter of main interest.
+    Fit Parameters
+        - :math:`a`: Height of decay curve.
+        - :math:`b`:  Base line.
+        - :math:`\alpha`: Depolarizing parameter. This is the fit parameter of main interest.
 
-    Initial Guesses:
-        a: Determined by :math:`(F(x[0]) - b) / alpha**x[0]` where :math:`b` and :math:`alpha`
-            are the initial guesses.
-        b: :math:`(1/2)**n` where :math:`n` is number of qubit.
-        alpha: Determined by the slope of :math:`(F(x) - b)**(1/x)` of the first and the
-            second data point. :math:`a` is assumed to be close to 1.
+    Initial Guesses
+        - :math:`a`: Determined by :math:`(y_0 - b) / \alpha^x_0`
+          where :math:`b` and :math:`\alpha` are initial guesses.
+        - :math:`b`: Determined by :math:`(1/2)^n` where :math:`n` is the number of qubit.
+        - :math:`\alpha`: Determined by the slope of :math:`(y - b)^{-x}` of the first and the
+          second data point.
 
-    Bounds:
-        a: [0, 1]
-        b: [0, 1]
-        alpha: [0, 1]
+    Bounds
+        - :math:`a`: [0, 1]
+        - :math:`b`: [0, 1]
+        - :math:`\alpha`: [0, 1]
 
     """
 

From 871bfbbab1afc470c389ddbac9776607b8536a5e Mon Sep 17 00:00:00 2001
From: Naoki Kanazawa <nkanazawa1989@gmail.com>
Date: Tue, 8 Jun 2021 17:29:01 +0900
Subject: [PATCH 74/74] Update qiskit_experiments/analysis/curve_analysis.py

Co-authored-by: Daniel Egger <38065505+eggerdj@users.noreply.github.com>
---
 qiskit_experiments/analysis/curve_analysis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit_experiments/analysis/curve_analysis.py b/qiskit_experiments/analysis/curve_analysis.py
index 8ceec06696..a73dc95047 100644
--- a/qiskit_experiments/analysis/curve_analysis.py
+++ b/qiskit_experiments/analysis/curve_analysis.py
@@ -240,7 +240,7 @@ def __init__(self):
 
     @classmethod
     def _default_options(cls):
-        """Return default data processing options.
+        """Return default analysis options.
 
         Options:
             curve_fitter: A callback function to perform fitting with formatted data.