From fff02bc9bb3c7dffa3fda52eda6696fe265b1d5b Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Thu, 14 Oct 2021 20:46:26 +0900
Subject: [PATCH 01/14] analysis class migration

---
 qiskit_experiments/curve_analysis/__init__.py |   4 +
 .../curve_analysis/curve_analysis.py          |   5 +
 .../standard_analysis/__init__.py             |   3 +-
 .../curve_analysis/standard_analysis/decay.py |  97 +++++++
 .../standard_analysis/oscillation.py          | 142 ++++++++++
 .../visualization/fit_result_plotters.py      |   4 +-
 .../library/characterization/t1.py            |  34 ++-
 .../library/characterization/t1_analysis.py   | 195 +-------------
 .../library/characterization/t2ramsey.py      |  42 ++-
 .../characterization/t2ramsey_analysis.py     | 252 ++----------------
 test/test_t1.py                               |  32 ++-
 test/test_t2ramsey.py                         | 128 +++++----
 12 files changed, 422 insertions(+), 516 deletions(-)
 create mode 100644 qiskit_experiments/curve_analysis/standard_analysis/decay.py

diff --git a/qiskit_experiments/curve_analysis/__init__.py b/qiskit_experiments/curve_analysis/__init__.py
index 8efab81e26..5573c85b93 100644
--- a/qiskit_experiments/curve_analysis/__init__.py
+++ b/qiskit_experiments/curve_analysis/__init__.py
@@ -44,6 +44,8 @@
     :toctree: ../stubs/
     :template: autosummary/analysis.rst
 
+    DecayAnalysis
+    DumpedOscillationAnalysis
     OscillationAnalysis
     ResonanceAnalysis
     ErrorAmplificationAnalysis
@@ -114,6 +116,8 @@
 
 # standard analysis
 from .standard_analysis import (
+    DecayAnalysis,
+    DumpedOscillationAnalysis,
     OscillationAnalysis,
     ResonanceAnalysis,
     ErrorAmplificationAnalysis,
diff --git a/qiskit_experiments/curve_analysis/curve_analysis.py b/qiskit_experiments/curve_analysis/curve_analysis.py
index c31277304a..17de1fbf9e 100644
--- a/qiskit_experiments/curve_analysis/curve_analysis.py
+++ b/qiskit_experiments/curve_analysis/curve_analysis.py
@@ -342,6 +342,8 @@ def _default_options(cls) -> Options:
             style (PlotterStyle): An instance of
                 :py:class:`~qiskit_experiments.curve_analysis.visualization.style.PlotterStyle`
                 that contains a set of configurations to create a fit plot.
+            extra (Dict[str, Any]): A dictionary that is appended to all database entries
+                as an extra information.
         """
         options = super()._default_options()
 
@@ -361,6 +363,7 @@ def _default_options(cls) -> Options:
         options.return_data_points = False
         options.curve_plotter = "mpl_single_canvas"
         options.style = PlotterStyle()
+        options.extra = dict()
 
         # automatically populate initial guess and boundary
         fit_params = cls._fit_params()
@@ -985,6 +988,7 @@ def _run_analysis(
                         "dof": fit_result.dof,
                         "covariance_mat": fit_result.pcov,
                         "fit_models": fit_models,
+                        **self._get_option("extra"),
                     },
                 )
             )
@@ -1006,6 +1010,7 @@ def _run_analysis(
                         value=fit_result.fitval(p_name, unit),
                         chisq=fit_result.reduced_chisq,
                         quality=quality,
+                        extra=self._get_option("extra"),
                     )
                     analysis_results.append(result_entry)
 
diff --git a/qiskit_experiments/curve_analysis/standard_analysis/__init__.py b/qiskit_experiments/curve_analysis/standard_analysis/__init__.py
index a5e2a82b68..769136bf02 100644
--- a/qiskit_experiments/curve_analysis/standard_analysis/__init__.py
+++ b/qiskit_experiments/curve_analysis/standard_analysis/__init__.py
@@ -12,6 +12,7 @@
 
 """Standard curve analysis library."""
 
-from .oscillation import OscillationAnalysis
+from .oscillation import OscillationAnalysis, DumpedOscillationAnalysis
 from .resonance import ResonanceAnalysis
 from .error_amplification_analysis import ErrorAmplificationAnalysis
+from .decay import DecayAnalysis
diff --git a/qiskit_experiments/curve_analysis/standard_analysis/decay.py b/qiskit_experiments/curve_analysis/standard_analysis/decay.py
new file mode 100644
index 0000000000..9466d40729
--- /dev/null
+++ b/qiskit_experiments/curve_analysis/standard_analysis/decay.py
@@ -0,0 +1,97 @@
+# 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.
+"""Decay analysis class."""
+
+from typing import List, Union
+
+import qiskit_experiments.curve_analysis as curve
+
+
+class DecayAnalysis(curve.CurveAnalysis):
+    r"""A class to analyze general exponential decay curve.
+    # section: fit_model
+        The fit is based on the following decay function.
+        .. math::
+            F(x) = {\rm amp} \cdot e^{-x/\tau} + {\rm base}
+    # section: fit_parameters
+       defpar \rm amp:
+           desc: Height of the decay curve.
+           init_guess: Determined by :py:func:`~qiskit_experiments.curve_analysis.guess.min_height`.
+           bounds: None
+       defpar \rm base:
+           desc: Base line of the decay curve.
+           init_guess: Determined by the difference of minimum and maximum points.
+           bounds: None
+       defpar \tau:
+           desc: This is the fit parameter of main interest.
+           init_guess: Determined by :py:func:`~qiskit_experiments.curve_analysis.guess.exp_decay`.
+           bounds: None
+    """
+
+    __series__ = [
+        curve.SeriesDef(
+            fit_func=lambda x, amp, base, tau: curve.fit_function.exponential_decay(
+                x, amp=amp, lamb=1/tau, baseline=base,
+            ),
+            plot_color="blue",
+            model_description=r"amp \exp(-x/tau) + base",
+            plot_fit_uncertainty=True,
+        )
+    ]
+
+    def _generate_fit_guesses(
+            self, user_opt: curve.FitOptions
+    ) -> Union[curve.FitOptions, List[curve.FitOptions]]:
+        """Compute the initial guesses.
+        Args:
+            user_opt: Fit options filled with user provided guess and bounds.
+        Returns:
+            List of fit options that are passed to the fitter function.
+        """
+        curve_data = self._data()
+
+        user_opt.p0.set_if_empty(base=curve.guess.min_height(curve_data.y)[0])
+
+        user_opt.p0.set_if_empty(
+            tau=-1/curve.guess.exp_decay(curve_data.x, curve_data.y),
+            amp=curve.guess.max_height(curve_data.y)[0] - user_opt.p0["base"],
+        )
+
+        return user_opt
+
+    def _evaluate_quality(self, fit_data: curve.FitData) -> Union[str, None]:
+        """Algorithmic criteria for whether the fit is good or bad.
+        A good fit has:
+            - a reduced chi-squared lower than three
+            - absolute amp is within [0.9, 1.1]
+            - base is less than 0.1
+            - amp error is less than 0.1
+            - tau error is less than its value
+            - base error is less than 0.1
+        """
+        amp = fit_data.fitval("amp")
+        tau = fit_data.fitval("tau")
+        base = fit_data.fitval("base")
+
+        criteria = [
+            fit_data.reduced_chisq < 3,
+            abs(amp.value - 1.0) < 0.1,
+            abs(base.value) < 0.1,
+            amp.stderr is None or amp.stderr < 0.1,
+            tau.stderr is None or tau.stderr < tau.value,
+            base.stderr is None or base.stderr < 0.1,
+        ]
+
+        if all(criteria):
+            return "good"
+
+        return "bad"
diff --git a/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py b/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py
index 629568e1eb..ea0225cded 100644
--- a/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py
+++ b/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py
@@ -123,3 +123,145 @@ def _evaluate_quality(self, fit_data: curve.FitData) -> Union[str, None]:
             return "good"
 
         return "bad"
+
+
+class DumpedOscillationAnalysis(curve.CurveAnalysis):
+    r"""A class to analyze general exponential decay curve with sinusoidal oscillation.
+
+    # section: fit_model
+        This class is based on te fit model of sinusoidal signal with exponential decay.
+        This model is often used for the oscillation signal in the dissipative system.
+
+        .. math::
+
+            F(x) = {\rm amp} \cdot e^{-x/\tau}
+                \cos(2\pi \cdot {\rm freq} \cdot t + \phi) + {\rm base}
+
+    # section: fit_parameters
+
+        defpar \rm amp:
+            desc: Amplitude. Height of the decay curve.
+            init_guess: 0.5
+            bounds: [0, 1.5],
+
+        defpar \rm base:
+            desc: Offset. Base line of the decay curve.
+            init_guess: Determined by :py:func:`~qiskit_experiments.curve_analysis.\
+                guess.constant_sinusoidal_offset`
+            bounds: [0, 1.5]
+
+        defpar \tau:
+            desc: Represents the rate of decay.
+            init_guess: Determined by :py:func:`~qiskit_experiments.curve_analysis.\
+                guess.oscillation_exp_decay`
+            bounds: [0, None]
+
+        defpar \rm freq:
+            desc: Oscillation frequency.
+            init_guess: Determined by :py:func:`~qiskit_experiments.curve_analysis.guess.frequency`
+            bounds: [0, 10 freq]
+
+        defpar \phi:
+            desc: Phase. Relative shift of the sinusoidal function from the origin.
+            init_guess: Set multiple guesses within [-pi, pi]
+            bounds: [-pi, pi]
+    """
+
+    __series__ = [
+        curve.SeriesDef(
+            fit_func=lambda x, amp, base, tau, freq, phi: curve.fit_function.cos_decay(
+                x, amp=amp, tau=tau, freq=freq, phase=phi, baseline=base,
+            ),
+            plot_color="blue",
+            model_description=r"amp \exp(-x/tau) \cos(2pi freq x + phi) + base",
+        )
+    ]
+
+    def _generate_fit_guesses(
+            self, user_opt: curve.FitOptions
+    ) -> Union[curve.FitOptions, List[curve.FitOptions]]:
+        """Compute the initial guesses.
+
+        Args:
+            user_opt: Fit options filled with user provided guess and bounds.
+
+        Returns:
+            List of fit options that are passed to the fitter function.
+        """
+        curve_data = self._data()
+
+        user_opt.p0.set_if_empty(
+            amp=0.5,
+            base=curve.guess.constant_sinusoidal_offset(curve_data.y),
+        )
+
+        # frequency resolution of this scan
+        df = 1 / ((curve_data.x[1] - curve_data.x[0]) * len(curve_data.x))
+
+        if user_opt.p0["freq"] is not None:
+            # If freq guess is provided
+            freq_guess = user_opt.p0["freq"]
+
+            freqs = [freq_guess]
+        else:
+            freq_guess = curve.guess.frequency(curve_data.x, curve_data.y - user_opt.p0["base"])
+
+            # The FFT might be up to 1/2 bin off
+            if freq_guess > df:
+                freqs = [freq_guess - df, freq_guess, freq_guess + df]
+            else:
+                freqs = [0.0, freq_guess]
+
+        # Set guess for decay parameter based on estimated frequency
+        if freq_guess > df:
+            user_opt.p0.set_if_empty(
+                tau=-1/curve.guess.oscillation_exp_decay(
+                    curve_data.x, curve_data.y - user_opt.p0["base"], freq_guess=freq_guess
+                )
+            )
+        else:
+            # Very low frequency. Assume standard exponential decay
+            user_opt.p0.set_if_empty(tau=-1/curve.guess.exp_decay(curve_data.x, curve_data.y))
+
+        user_opt.bounds.set_if_empty(
+            amp=[0, 1.5],
+            base=[0, 1.5],
+            tau=(0, np.inf),
+            freq=(0, 10 * freq_guess),
+            phi=(-np.pi, np.pi),
+        )
+
+        # more robust estimation
+        options = []
+        for freq in freqs:
+            for phi in np.linspace(-np.pi, np.pi, 5)[:-1]:
+                new_opt = user_opt.copy()
+                new_opt.p0.set_if_empty(freq=freq, phi=phi)
+                options.append(new_opt)
+
+        return options
+
+    def _evaluate_quality(self, fit_data: curve.FitData) -> Union[str, None]:
+        """Algorithmic criteria for whether the fit is good or bad.
+
+        A good fit has:
+            - a reduced chi-squared lower than three
+            - relative error of amp is less than 10 percent
+            - relative error of tau is less than 10 percent
+            - relative error of freq is less than 10 percent
+        """
+        amp = fit_data.fitval("amp")
+        tau = fit_data.fitval("tau")
+        freq = fit_data.fitval("freq")
+
+        criteria = [
+            fit_data.reduced_chisq < 3,
+            amp.stderr is None or amp.stderr < 0.1 * amp.value,
+            tau.stderr is None or tau.stderr < 0.1 * tau.value,
+            freq.stderr is None or freq.stderr < 0.1 * freq.value,
+        ]
+
+        if all(criteria):
+            return "good"
+
+        return "bad"
diff --git a/qiskit_experiments/curve_analysis/visualization/fit_result_plotters.py b/qiskit_experiments/curve_analysis/visualization/fit_result_plotters.py
index 486b4ee3d1..5f1114b302 100644
--- a/qiskit_experiments/curve_analysis/visualization/fit_result_plotters.py
+++ b/qiskit_experiments/curve_analysis/visualization/fit_result_plotters.py
@@ -411,7 +411,9 @@ def format_val(float_val: float) -> str:
                 val, val_prefix = detach_prefix(fitval.value, decimal=3)
                 val_unit = val_prefix + fitval.unit
                 value_repr = f"{val: .3g}"
-                if fitval.stderr is not None:
+
+                # write error bar if it is finite value
+                if fitval.stderr is not None and not np.isinf(fitval.stderr):
                     # with stderr
                     err, err_prefix = detach_prefix(fitval.stderr, decimal=3)
                     err_unit = err_prefix + fitval.unit
diff --git a/qiskit_experiments/library/characterization/t1.py b/qiskit_experiments/library/characterization/t1.py
index d03b9761c1..5415352d30 100644
--- a/qiskit_experiments/library/characterization/t1.py
+++ b/qiskit_experiments/library/characterization/t1.py
@@ -16,6 +16,7 @@
 from typing import List, Optional, Union
 import numpy as np
 
+from qiskit.utils import apply_prefix
 from qiskit.providers import Backend
 from qiskit.circuit import QuantumCircuit
 
@@ -100,21 +101,41 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
             The experiment circuits
 
         Raises:
-            AttributeError: if unit is dt but dt parameter is missing in the backend configuration
+            AttributeError: if unit is `dt`, but `dt` parameter
+                is missing in the backend configuration.
         """
+        conversion_factor = 1
         if self.experiment_options.unit == "dt":
             try:
-                dt_factor = getattr(backend.configuration(), "dt")
+                dt_factor = getattr(backend._configuration, "dt")
+                conversion_factor = dt_factor
             except AttributeError as no_dt:
                 raise AttributeError("Dt parameter is missing in backend configuration") from no_dt
+        elif self.experiment_options.unit != "s":
+            conversion_factor = apply_prefix(1, self.experiment_options.unit)
+
+        # override init guess with correct unit
+        # TODO be moved to pre-analysis
+        user_p0 = self.analysis_options.p0
+        if user_p0.get("tau", None) is not None:
+            user_p0["tau"] *= conversion_factor
+
+        self.set_analysis_options(
+            p0=user_p0,
+            extra={
+                "conversion_factor": conversion_factor,
+                "unit": self.experiment_options.unit,
+            },
+        )
 
         circuits = []
+        for delay in conversion_factor * np.asarray(self.experiment_options.delays, dtype=float):
+            delay = np.round(delay, decimals=10)
 
-        for delay in self.experiment_options.delays:
             circ = QuantumCircuit(1, 1)
             circ.x(0)
             circ.barrier(0)
-            circ.delay(delay, 0, self.experiment_options.unit)
+            circ.delay(delay, 0, "s")
             circ.barrier(0)
             circ.measure(0, 0)
 
@@ -122,12 +143,9 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
                 "experiment_type": self._type,
                 "qubit": self.physical_qubits[0],
                 "xval": delay,
-                "unit": self.experiment_options.unit,
+                "unit": "s",
             }
 
-            if self.experiment_options.unit == "dt":
-                circ.metadata["dt_factor"] = dt_factor
-
             circuits.append(circ)
 
         return circuits
diff --git a/qiskit_experiments/library/characterization/t1_analysis.py b/qiskit_experiments/library/characterization/t1_analysis.py
index f5a8a2e758..aafa580d4c 100644
--- a/qiskit_experiments/library/characterization/t1_analysis.py
+++ b/qiskit_experiments/library/characterization/t1_analysis.py
@@ -13,201 +13,26 @@
 T1 Analysis class.
 """
 
+from qiskit_experiments.curve_analysis import DecayAnalysis, ParameterRepr
 
-from typing import Tuple, List
-import dataclasses
-import numpy as np
+from qiskit_experiments.framework import Options
 
-from qiskit.utils import apply_prefix
 
-from qiskit_experiments.framework import BaseAnalysis, AnalysisResultData, FitVal, Options
-from qiskit_experiments.curve_analysis import plot_curve_fit, plot_errorbar, curve_fit
-from qiskit_experiments.curve_analysis.curve_fit import (
-    process_curve_data,
-)
-from qiskit_experiments.curve_analysis.data_processing import level2_probability
-
-
-class T1Analysis(BaseAnalysis):
+class T1Analysis(DecayAnalysis):
     r"""A class to analyze T1 experiments.
 
-    # section: fit_model
-        The fit is based on the following decay function.
-
-        .. math::
-
-            F(x) = a e^{-x/t1} + b
-
-    # section: fit_parameters
-       defpar a:
-           desc: Height of the decay curve.
-           init_guess: Determined by :math:`(y_0 - b)`.
-
-       defpar b:
-           desc: Base line of the decay curve.
-           init_guess: Determined by the last :math:`y`.
+    # section: see_also
+        qiskit_experiments.curve_analysis.standard_analysis.decay.DecayAnalysis
 
-       defpar t1:
-           desc: This is the fit parameter of main interest.
-           init_guess: Determined by the mean of the data points.
     """
 
     @classmethod
     def _default_options(cls) -> Options:
-        """Default analysis options
-        Analysis Options:
-            t1_guess (float): Initial guess of T1.
-            amplitude_guess (float): Initial guess of the amplitude.
-            offset_guess (float): Initial guess of the offset.
-        """
+        """Default analysis options."""
         options = super()._default_options()
-
-        options.t1_guess = None
-        options.amplitude_guess = None
-        options.offset_guess = None
+        options.xlabel = "Delay"
+        options.ylabel = "P(1)"
+        options.xval_unit = "s"
+        options.result_parameters = [ParameterRepr("tau", "T1", "s")]
 
         return options
-
-    # pylint: disable=arguments-differ
-    def _run_analysis(
-        self,
-        experiment_data,
-        t1_guess=None,
-        amplitude_guess=None,
-        offset_guess=None,
-        plot=True,
-        ax=None,
-    ) -> Tuple[List[AnalysisResultData], List["matplotlib.figure.Figure"]]:
-        """
-        Calculate T1
-
-        Args:
-            experiment_data (ExperimentData): the experiment data to analyze
-            t1_guess (float): Optional, an initial guess of T1
-            amplitude_guess (float): Optional, an initial guess of the coefficient
-                                     of the exponent
-            offset_guess (float): Optional, an initial guess of the offset
-            plot (bool): Generator plot of exponential fit.
-            ax (AxesSubplot): Optional, axes to add figure to.
-
-        Returns:
-            The analysis result with the estimated T1
-
-        Raises:
-            AnalysisError: if the analysis fails.
-        """
-        data = experiment_data.data()
-        unit = data[0]["metadata"]["unit"]
-        conversion_factor = data[0]["metadata"].get("dt_factor", None)
-        qubit = data[0]["metadata"]["qubit"]
-
-        if conversion_factor is None:
-            conversion_factor = 1 if unit == "s" else apply_prefix(1, unit)
-
-        xdata, ydata, sigma = process_curve_data(data, lambda datum: level2_probability(datum, "1"))
-        xdata *= conversion_factor
-
-        if t1_guess is None:
-            t1_guess = np.mean(xdata)
-        else:
-            t1_guess = t1_guess * conversion_factor
-        if offset_guess is None:
-            offset_guess = ydata[-1]
-        if amplitude_guess is None:
-            amplitude_guess = ydata[0] - offset_guess
-
-        # Perform fit
-        def fit_fun(x, a, tau, c):
-            return a * np.exp(-x / tau) + c
-
-        init = {"a": amplitude_guess, "tau": t1_guess, "c": offset_guess}
-        fit_result = curve_fit(fit_fun, xdata, ydata, init, sigma=sigma)
-        fit_result = dataclasses.asdict(fit_result)
-        fit_result["circuit_unit"] = unit
-        if unit == "dt":
-            fit_result["dt"] = conversion_factor
-
-        # Construct analysis result
-        name = "T1"
-        unit = "s"
-        value = FitVal(fit_result["popt"][1], fit_result["popt_err"][1], unit="s")
-        chisq = fit_result["reduced_chisq"]
-        quality = self._fit_quality(
-            fit_result["popt"], fit_result["popt_err"], fit_result["reduced_chisq"]
-        )
-        analysis_results = [
-            AnalysisResultData(
-                name,
-                value,
-                chisq=chisq,
-                quality=quality,
-                extra=fit_result,
-            )
-        ]
-
-        # Generate fit plot
-        figures = []
-        if plot:
-            ax = plot_curve_fit(fit_fun, fit_result, ax=ax, fit_uncertainty=True)
-            ax = plot_errorbar(xdata, ydata, sigma, ax=ax)
-            self._format_plot(ax, fit_result, qubit=qubit)
-            figures.append(ax.get_figure())
-
-        return analysis_results, figures
-
-    @staticmethod
-    def _fit_quality(fit_out, fit_err, reduced_chisq):
-        # pylint: disable = too-many-boolean-expressions
-        if (
-            abs(fit_out[0] - 1.0) < 0.1
-            and abs(fit_out[2]) < 0.1
-            and reduced_chisq < 3
-            and (fit_err[0] is None or fit_err[0] < 0.1)
-            and (fit_err[1] is None or fit_err[1] < fit_out[1])
-            and (fit_err[2] is None or fit_err[2] < 0.1)
-        ):
-            return "good"
-        else:
-            return "bad"
-
-    @classmethod
-    def _format_plot(cls, ax, analysis_result, qubit=None, add_label=True):
-        """Format curve fit plot"""
-        # Formatting
-        ax.tick_params(labelsize=14)
-        if qubit is not None:
-            ax.set_title(f"Qubit {qubit}", fontsize=16)
-        ax.set_xlabel("Delay (s)", fontsize=16)
-        ax.ticklabel_format(axis="x", style="sci", scilimits=(-3, 3))
-        ax.set_ylabel("P(1)", fontsize=16)
-        ax.grid(True)
-
-        if add_label:
-            t1 = analysis_result["popt"][1]
-            t1_err = analysis_result["popt_err"][1]
-            # Convert T1 to time unit for pretty printing
-            if t1 < 1e-7:
-                scale = 1e9
-                unit = "ns"
-            elif t1 < 1e-4:
-                scale = 1e6
-                unit = "μs"
-            elif t1 < 0.1:
-                scale = 1e3
-                unit = "ms"
-            else:
-                scale = 1
-                unit = "s"
-            box_text = "$T_1$ = {:.2f} \u00B1 {:.2f} {}".format(t1 * scale, t1_err * scale, unit)
-            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
diff --git a/qiskit_experiments/library/characterization/t2ramsey.py b/qiskit_experiments/library/characterization/t2ramsey.py
index abb93d486f..8dc9be4931 100644
--- a/qiskit_experiments/library/characterization/t2ramsey.py
+++ b/qiskit_experiments/library/characterization/t2ramsey.py
@@ -21,8 +21,9 @@
 from qiskit.utils import apply_prefix
 from qiskit.providers import Backend
 from qiskit.circuit import QuantumCircuit
+
 from qiskit_experiments.framework import BaseExperiment, Options
-from .t2ramsey_analysis import T2RamseyAnalysis
+from qiskit_experiments.library.characterization.t2ramsey_analysis import T2RamseyAnalysis
 
 
 class T2Ramsey(BaseExperiment):
@@ -94,8 +95,8 @@ def __init__(
             unit: Optional, time unit of `delays`.
                 Supported units: 's', 'ms', 'us', 'ns', 'ps', 'dt'. The unit is
                 used for both T2Ramsey and for the frequency.
-            osc_freq: the oscillation frequency induced by the user. \
-            The frequency is given in Hz.
+            osc_freq: the oscillation frequency induced by the user.
+                The frequency is given in Hz.
 
         """
 
@@ -115,7 +116,8 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
             The experiment circuits
 
         Raises:
-            AttributeError: if unit is 'dt', but 'dt' parameter is missing in the backend configuration.
+            AttributeError: if unit is `dt`, but `dt` parameter
+                is missing in the backend configuration.
         """
         conversion_factor = 1
         if self.experiment_options.unit == "dt":
@@ -127,14 +129,32 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
         elif self.experiment_options.unit != "s":
             conversion_factor = apply_prefix(1, self.experiment_options.unit)
 
+        # override init guess with correct unit
+        # TODO be moved to pre-analysis
+        user_p0 = self.analysis_options.p0
+        if user_p0.get("tau", None) is not None:
+            user_p0["tau"] *= conversion_factor
+        if user_p0.get("freq", None) is None:
+            user_p0["freq"] = self.experiment_options.osc_freq
+
+        self.set_analysis_options(
+            p0=user_p0,
+            extra={
+                "osc_freq": self.experiment_options.osc_freq,
+                "conversion_factor": conversion_factor,
+                "unit": self.experiment_options.unit,
+            },
+        )
+
         circuits = []
-        for delay in self.experiment_options.delays:
+        for delay in conversion_factor * np.asarray(self.experiment_options.delays, dtype=float):
+            delay = np.round(delay, decimals=10)
+
+            rotation_angle = 2 * np.pi * self.experiment_options.osc_freq * delay
+
             circ = qiskit.QuantumCircuit(1, 1)
             circ.h(0)
-            circ.delay(delay, 0, self.experiment_options.unit)
-            rotation_angle = (
-                2 * np.pi * self.experiment_options.osc_freq * conversion_factor * delay
-            )
+            circ.delay(delay, 0, "s")
             circ.rz(rotation_angle, 0)
             circ.barrier(0)
             circ.h(0)
@@ -146,10 +166,8 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
                 "qubit": self.physical_qubits[0],
                 "osc_freq": self.experiment_options.osc_freq,
                 "xval": delay,
-                "unit": self.experiment_options.unit,
+                "unit": "s",
             }
-            if self.experiment_options.unit == "dt":
-                circ.metadata["dt_factor"] = dt_factor
 
             circuits.append(circ)
 
diff --git a/qiskit_experiments/library/characterization/t2ramsey_analysis.py b/qiskit_experiments/library/characterization/t2ramsey_analysis.py
index 081fde1e21..64b7aeb5cb 100644
--- a/qiskit_experiments/library/characterization/t2ramsey_analysis.py
+++ b/qiskit_experiments/library/characterization/t2ramsey_analysis.py
@@ -13,249 +13,33 @@
 T2Ramsey Experiment class.
 """
 
-from typing import List, Optional, Tuple, Dict
-import dataclasses
-import numpy as np
+from qiskit_experiments.curve_analysis import DumpedOscillationAnalysis, ParameterRepr
+from qiskit_experiments.data_processing import DataProcessor, Probability
 
-from qiskit.utils import apply_prefix
-from qiskit_experiments.framework import (
-    BaseAnalysis,
-    Options,
-    ExperimentData,
-    AnalysisResultData,
-    FitVal,
-)
-from qiskit_experiments.curve_analysis import curve_fit, plot_curve_fit, plot_errorbar, plot_scatter
-from qiskit_experiments.curve_analysis.curve_fit import process_curve_data
-from qiskit_experiments.curve_analysis.data_processing import level2_probability
+from qiskit_experiments.framework import Options
 
 
-# pylint: disable = invalid-name
-class T2RamseyAnalysis(BaseAnalysis):
-    r"""
-    T2 Ramsey result analysis class.
+class T2RamseyAnalysis(DumpedOscillationAnalysis):
+    """T2 Ramsey result analysis class.
 
-    # section: fit_model
-        This class is used to analyze the results of a T2 Ramsey experiment.
-        The probability of measuring :math:`|+\rangle` state is assumed to be of the form
-
-        .. math::
-
-            f(t) = a\mathrm{e}^{-t / T_2^*}\cos(2\pi f t + \phi) + b
-
-    # section: fit_parameters
-
-        defpar a:
-            desc: Amplitude. Height of the decay curve.
-            init_guess: 0.5
-            bounds: [-0.5, 1.5]
-
-        defpar b:
-            desc: Offset. Base line of the decay curve.
-            init_guess: 0.5
-            bounds: [-0.5, 1.5]
-
-        defpar \phi:
-            desc: Shift. Relative shift of the graph from the origin.
-            init_guess: 0.0
-            bounds: [-np.pi, np.pi]
-
-        defpar T_2^*:
-            desc: Represents the rate of decay.
-            init_guess: the mean of the input delays.
-            bounds: [0, np.inf]
-
-        defpar f:
-            desc: Frequency. Represents the difference in frequency between
-                the user guess and the actual frequency of the qubit.
-            init_guess: input osc_freq.
-            bounds: [0.1 * f, 10 * f]
+    # section: see_also
+        qiskit_experiments.curve_analysis.standard_analysis.oscillation.DumpedOscillationAnalysis
 
     """
 
     @classmethod
     def _default_options(cls) -> Options:
-        r"""Default analysis options.
-
-        Analysis Options:
-            user_p0 (List[Float]): user guesses for the fit parameters
-                :math:`(a, b, f, \phi, T_2^*)`.
-            user_bounds (Tuple[List[float], List[float]]): Lower and upper bounds
-                for the fit parameters.
-            plot (bool): Create a graph if and only if True.
-        """
+        """Default analysis options."""
         options = super()._default_options()
-
-        options.user_p0 = None
-        options.user_bounds = None
-
-        return options
-
-    # pylint: disable=arguments-differ, unused-argument
-    def _run_analysis(
-        self,
-        experiment_data: ExperimentData,
-        user_p0: Optional[Dict[str, float]] = None,
-        user_bounds: Optional[Tuple[List[float], List[float]]] = None,
-        plot: bool = False,
-        ax: Optional["AxesSubplot"] = None,
-        **kwargs,
-    ) -> Tuple[List[AnalysisResultData], List["matplotlib.figure.Figure"]]:
-        r"""Calculate T2Ramsey experiment.
-
-        Args:
-            experiment_data (ExperimentData): the experiment data to analyze
-            user_p0: contains initial values given by the user, for the
-            fit parameters :math:`(a, t2ramsey, f, \phi, b)`
-            user_bounds: lower and upper bounds on the parameters in p0,
-                         given by the user.
-                         The first tuple is the lower bounds,
-                         The second tuple is the upper bounds.
-                         For both params, the order is :math:`a, t2ramsey, f, \phi, b`.
-            plot: if True, create the plot, otherwise, do not create the plot.
-            ax: the plot object
-            **kwargs: additional parameters for curve fit.
-
-        Returns:
-            The analysis result with the estimated :math:`t2ramsey` and 'f' (frequency)
-            The graph of the function.
-        """
-
-        def osc_fit_fun(x, a, t2ramsey, f, phi, c):
-            """Decay cosine fit function"""
-            return a * np.exp(-x / t2ramsey) * np.cos(2 * np.pi * f * x + phi) + c
-
-        def _format_plot(ax, unit, fit_result, conversion_factor):
-            """Format curve fit plot"""
-            # Formatting
-            ax.tick_params(labelsize=14)
-            ax.set_xlabel("Delay (s)", fontsize=12)
-            ax.ticklabel_format(axis="x", style="sci", scilimits=(0, 0))
-            ax.set_ylabel("Probability of measuring 0", fontsize=12)
-            t2ramsey = fit_result["popt"][1] / conversion_factor
-            t2_err = fit_result["popt_err"][1] / conversion_factor
-            box_text = "$T_2Ramsey$ = {:.2f} \u00B1 {:.2f} {}".format(t2ramsey, t2_err, unit)
-            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=12,
-                bbox=bbox_props,
-                transform=ax.transAxes,
-            )
-            return ax
-
-        # implementation of  _run_analysis
-
-        data = experiment_data.data()
-        circ_metadata = data[0]["metadata"]
-        unit = circ_metadata["unit"]
-        conversion_factor = circ_metadata.get("dt_factor", None)
-        osc_freq = circ_metadata.get("osc_freq", None)
-        if conversion_factor is None:
-            conversion_factor = 1 if unit in ("s", "dt") else apply_prefix(1, unit)
-
-        xdata, ydata, sigma = process_curve_data(data, lambda datum: level2_probability(datum, "0"))
-
-        t2ramsey_estimate = np.mean(xdata)
-        p0, bounds = self._t2ramsey_default_params(
-            conversion_factor, user_p0, user_bounds, t2ramsey_estimate, osc_freq
-        )
-        xdata *= conversion_factor
-        fit_result = curve_fit(
-            osc_fit_fun, xdata, ydata, p0=list(p0.values()), sigma=sigma, bounds=bounds
-        )
-        fit_result = dataclasses.asdict(fit_result)
-        fit_result["circuit_unit"] = unit
-        if osc_freq is not None:
-            fit_result["osc_freq"] = osc_freq
-        if unit == "dt":
-            fit_result["dt"] = conversion_factor
-        quality = self._fit_quality(
-            fit_result["popt"], fit_result["popt_err"], fit_result["reduced_chisq"]
-        )
-        chisq = fit_result["reduced_chisq"]
-
-        if plot:
-            ax = plot_curve_fit(osc_fit_fun, fit_result, ax=ax)
-            ax = plot_scatter(xdata, ydata, ax=ax)
-            ax = plot_errorbar(xdata, ydata, sigma, ax=ax)
-            _format_plot(ax, unit, fit_result, conversion_factor)
-            figures = [ax.get_figure()]
-        else:
-            figures = None
-
-        # Output unit is 'sec', regardless of the unit used in the input
-        result_t2star = AnalysisResultData(
-            "T2star",
-            value=FitVal(fit_result["popt"][1], fit_result["popt_err"][1], "s"),
-            quality=quality,
-            chisq=chisq,
-            extra=fit_result,
+        options.data_processor = DataProcessor(
+            input_key="counts", data_actions=[Probability(outcome="0")]
         )
-        result_freq = AnalysisResultData(
-            "Frequency",
-            value=FitVal(fit_result["popt"][2], fit_result["popt_err"][2], "Hz"),
-            quality=quality,
-            chisq=chisq,
-            extra=fit_result,
-        )
-
-        return [result_t2star, result_freq], figures
+        options.xlabel = "Delay"
+        options.ylabel = "P(0)"
+        options.xval_unit = "s"
+        options.result_parameters = [
+            ParameterRepr("freq", "Frequency", "Hz"),
+            ParameterRepr("tau", "T2star", "s"),
+        ]
 
-    def _t2ramsey_default_params(
-        self,
-        conversion_factor,
-        user_p0=None,
-        user_bounds=None,
-        t2ramsey_input=None,
-        freq_input=None,
-    ) -> Tuple[List[float], Tuple[List[float]]]:
-        """Default fit parameters for oscillation data.
-
-        Note that :math:`T_2^*` unit is converted to 'sec' and 'f' unit is
-        converted to Hz, so the output will be given in 'sec' and 'Hz'.
-        """
-        if user_p0 is None:
-            a = 0.5
-            t2ramsey = t2ramsey_input * conversion_factor
-            f = freq_input
-            phi = 0.0
-            b = 0.5
-        else:
-            a = user_p0["A"]
-            t2ramsey = user_p0["T2star"] * conversion_factor
-            f = user_p0["f"]
-            phi = user_p0["phi"]
-            b = user_p0["B"]
-        p0 = {"a_guess": a, "T2star": t2ramsey, "f_guess": f, "phi_guess": phi, "b_guess": b}
-
-        if user_bounds is None:
-            a_bounds = [-0.5, 1.5]
-            t2ramsey_bounds = [0, np.inf]
-            f_bounds = [0.1 * f, 10 * f]
-            phi_bounds = [-np.pi, np.pi]
-            b_bounds = [-0.5, 1.5]
-            bounds = [
-                [a_bounds[i], t2ramsey_bounds[i], f_bounds[i], phi_bounds[i], b_bounds[i]]
-                for i in range(2)
-            ]
-        else:
-            bounds = user_bounds
-        return p0, bounds
-
-    @staticmethod
-    def _fit_quality(fit_out, fit_err, reduced_chisq):
-        # pylint: disable = too-many-boolean-expressions
-        if (
-            (reduced_chisq < 3)
-            and (fit_err[0] is None or fit_err[0] < 0.1 * fit_out[0])
-            and (fit_err[1] is None or fit_err[1] < 0.1 * fit_out[1])
-            and (fit_err[2] is None or fit_err[2] < 0.1 * fit_out[2])
-        ):
-            return "good"
-        else:
-            return "bad"
+        return options
diff --git a/test/test_t1.py b/test/test_t1.py
index 649dac95f6..2f851a04dc 100644
--- a/test/test_t1.py
+++ b/test/test_t1.py
@@ -34,7 +34,7 @@ def test_t1_end2end(self):
 
         t1 = 25e-6
         backend = T1Backend(
-            [t1 / dt_factor],
+            [t1],
             initial_prob1=[0.02],
             readout0to1=[0.02],
             readout1to0=[0.02],
@@ -50,10 +50,10 @@ def test_t1_end2end(self):
         )
 
         exp = T1(0, delays, unit="dt")
-        exp.set_analysis_options(amplitude_guess=1, t1_guess=t1 / dt_factor, offset_guess=0)
+        exp.set_analysis_options(p0={"amp": 1, "tau": t1/dt_factor, "base": 0})
         exp_data = exp.run(backend, shots=10000)
         exp_data.block_for_results()  # Wait for analysis to finish.
-        res = exp_data.analysis_results(0)
+        res = exp_data.analysis_results("T1")
         fitval = res.value
         self.assertEqual(res.quality, "good")
         self.assertAlmostEqual(fitval.value, t1, delta=3)
@@ -74,7 +74,7 @@ def test_t1_parallel(self):
         res.block_for_results()
 
         for i in range(2):
-            sub_res = res.component_experiment_data(i).analysis_results(0)
+            sub_res = res.component_experiment_data(i).analysis_results("T1")
             self.assertEqual(sub_res.quality, "good")
             self.assertAlmostEqual(sub_res.value.value, t1[i], delta=3)
 
@@ -88,9 +88,9 @@ def test_t1_parallel_different_analysis_options(self):
         delays = list(range(1, 40, 3))
 
         exp0 = T1(0, delays)
-        exp0.set_analysis_options(t1_guess=30)
+        exp0.set_analysis_options(p0={"tau": 30})
         exp1 = T1(1, delays)
-        exp1.set_analysis_options(t1_guess=1000000)
+        exp1.set_analysis_options(p0={"tau": 1000000})
 
         par_exp = ParallelExperiment([exp0, exp1])
         res = par_exp.run(T1Backend([t1, t1]))
@@ -98,7 +98,7 @@ def test_t1_parallel_different_analysis_options(self):
 
         sub_res = []
         for i in range(2):
-            sub_res.append(res.component_experiment_data(i).analysis_results(0))
+            sub_res.append(res.component_experiment_data(i).analysis_results("T1"))
 
         self.assertEqual(sub_res[0].quality, "good")
         self.assertAlmostEqual(sub_res[0].value.value, t1, delta=3)
@@ -117,16 +117,15 @@ def test_t1_analysis(self):
                 {
                     "counts": {"0": count0, "1": 10000 - count0},
                     "metadata": {
-                        "xval": 3 * i + 1,
+                        "xval": (3 * i + 1) * 1e-9,
                         "experiment_type": "T1",
                         "qubit": 0,
-                        "unit": "ns",
-                        "dt_factor_in_sec": None,
+                        "unit": "s",
                     },
                 }
             )
 
-        res = T1Analysis()._run_analysis(data)[0][0]
+        res = T1Analysis()._run_analysis(data)[0][1]
         self.assertEqual(res.quality, "good")
         self.assertAlmostEqual(res.value.value, 25e-9, delta=3)
 
@@ -147,8 +146,8 @@ def test_t1_metadata(self):
                 {
                     "experiment_type": "T1",
                     "qubit": 0,
-                    "xval": delay,
-                    "unit": "ms",
+                    "xval": delay / 1000,
+                    "unit": "s",
                 },
             )
 
@@ -164,14 +163,13 @@ def test_t1_low_quality(self):
                 {
                     "counts": {"0": 10, "1": 10},
                     "metadata": {
-                        "xval": i,
+                        "xval": i * 1e-9,
                         "experiment_type": "T1",
                         "qubit": 0,
-                        "unit": "ns",
-                        "dt_factor_in_sec": None,
+                        "unit": "s",
                     },
                 }
             )
 
-        res = T1Analysis()._run_analysis(data)[0][0]
+        res = T1Analysis()._run_analysis(data)[0][1]
         self.assertEqual(res.quality, "bad")
diff --git a/test/test_t2ramsey.py b/test/test_t2ramsey.py
index 987457a2d6..e1509a2577 100644
--- a/test/test_t2ramsey.py
+++ b/test/test_t2ramsey.py
@@ -30,12 +30,17 @@ def test_t2ramsey_run_end2end(self):
         """
         for unit in ["s", "ms", "us", "ns", "dt"]:
             if unit in ("s", "dt"):
-                dt_factor = 1
+                conversion_factor = 1
             else:
-                dt_factor = apply_prefix(1, unit)
-            osc_freq = 0.1 / dt_factor
+                conversion_factor = apply_prefix(1, unit)
+
+            # scale t2star and frequency
+            osc_freq = 0.1 / conversion_factor
             estimated_t2ramsey = 20
+
+            # induce error
             estimated_freq = osc_freq * 1.001
+
             # Set up the circuits
             qubit = 0
             if unit == "dt":  # dt requires integer values for delay
@@ -47,43 +52,47 @@ def test_t2ramsey_run_end2end(self):
                 )
             exp = T2Ramsey(qubit, delays, unit=unit, osc_freq=osc_freq)
             default_p0 = {
-                "A": 0.5,
-                "T2star": estimated_t2ramsey,
-                "f": estimated_freq,
+                "amp": 0.5,
+                "tau": estimated_t2ramsey,
+                "freq": estimated_freq,
                 "phi": 0,
-                "B": 0.5,
+                "base": 0.5,
             }
-            for user_p0 in [default_p0, None]:
-                exp.set_analysis_options(user_p0=user_p0, plot=True)
-                backend = T2RamseyBackend(
-                    p0={
-                        "A": [0.5],
-                        "T2star": [estimated_t2ramsey],
-                        "f": [estimated_freq],
-                        "phi": [0.0],
-                        "B": [0.5],
-                    },
-                    initial_prob_plus=[0.0],
-                    readout0to1=[0.02],
-                    readout1to0=[0.02],
-                    conversion_factor=dt_factor,
-                )
-
-            expdata = exp.run(backend=backend, shots=2000)
-            expdata.block_for_results()  # Wait for job/analysis to finish.
-            result = expdata.analysis_results()
-            self.assertAlmostEqual(
-                result[0].value.value,
-                estimated_t2ramsey * dt_factor,
-                delta=TestT2Ramsey.__tolerance__ * result[0].value.value,
-            )
-            self.assertAlmostEqual(
-                result[1].value.value,
-                estimated_freq,
-                delta=TestT2Ramsey.__tolerance__ * result[1].value.value,
+            backend = T2RamseyBackend(
+                p0={
+                    "A": [0.5],
+                    "T2star": [estimated_t2ramsey],
+                    "f": [estimated_freq],
+                    "phi": [0.0],
+                    "B": [0.5],
+                },
+                initial_prob_plus=[0.0],
+                readout0to1=[0.02],
+                readout1to0=[0.02],
+                conversion_factor=conversion_factor,
             )
-            for res in result:
-                self.assertEqual(res.quality, "good", "Result quality bad for unit " + str(unit))
+            for user_p0 in [default_p0, dict()]:
+                exp.set_analysis_options(p0=user_p0)
+                expdata = exp.run(backend=backend, shots=2000)
+                expdata.block_for_results()  # Wait for job/analysis to finish.
+                result = expdata.analysis_results("T2star")
+                self.assertAlmostEqual(
+                    result.value.value,
+                    estimated_t2ramsey * conversion_factor,
+                    delta=TestT2Ramsey.__tolerance__ * result.value.value,
+                )
+                self.assertEqual(
+                    result.quality, "good", "Result quality bad for unit " + str(unit)
+                )
+                result = expdata.analysis_results("Frequency")
+                self.assertAlmostEqual(
+                    result.value.value,
+                    estimated_freq,
+                    delta=TestT2Ramsey.__tolerance__ * result.value.value,
+                )
+                self.assertEqual(
+                    result.quality, "good", "Result quality bad for unit " + str(unit)
+                )
 
     def test_t2ramsey_parallel(self):
         """
@@ -112,23 +121,24 @@ def test_t2ramsey_parallel(self):
         expdata.block_for_results()
 
         for i in range(2):
-            sub_res = expdata.component_experiment_data(i).analysis_results()
+            res_t2star = expdata.component_experiment_data(i).analysis_results("T2star")
             self.assertAlmostEqual(
-                sub_res[0].value.value,
+                res_t2star.value.value,
                 t2ramsey[i],
-                delta=TestT2Ramsey.__tolerance__ * sub_res[0].value.value,
+                delta=TestT2Ramsey.__tolerance__ * res_t2star.value.value,
+            )
+            self.assertEqual(
+                res_t2star.quality, "good", "Result quality bad for experiment on qubit " + str(i)
             )
+            res_freq = expdata.component_experiment_data(i).analysis_results("Frequency")
             self.assertAlmostEqual(
-                sub_res[1].value.value,
+                res_freq.value.value,
                 estimated_freq[i],
-                delta=TestT2Ramsey.__tolerance__ * sub_res[1].value.value,
+                delta=TestT2Ramsey.__tolerance__ * res_freq.value.value,
+            )
+            self.assertEqual(
+                res_freq.quality, "good", "Result quality bad for experiment on qubit " + str(i)
             )
-            for res in sub_res:
-                self.assertEqual(
-                    res.quality,
-                    "good",
-                    "Result quality bad for experiment on qubit " + str(i),
-                )
 
     def test_t2ramsey_concat_2_experiments(self):
         """
@@ -150,7 +160,7 @@ def test_t2ramsey_concat_2_experiments(self):
             "phi": 0,
             "B": 0.5,
         }
-        exp0.set_analysis_options(user_p0=default_p0)
+        exp0.set_analysis_options(p0=default_p0)
         backend = T2RamseyBackend(
             p0={
                 "A": [0.5],
@@ -162,31 +172,33 @@ def test_t2ramsey_concat_2_experiments(self):
             initial_prob_plus=[0.0],
             readout0to1=[0.02],
             readout1to0=[0.02],
-            conversion_factor=1,
         )
 
         # run circuits
         expdata0 = exp0.run(backend=backend, shots=1000)
         expdata0.block_for_results()
-        results0 = expdata0.analysis_results()
+
+        res_t2star_0 = expdata0.analysis_results("T2star")
 
         # second experiment
         delays1 = list(range(2, 65, 2))
         exp1 = T2Ramsey(qubit, delays1, unit=unit)
-        exp1.set_analysis_options(user_p0=default_p0)
+        exp1.set_analysis_options(p0=default_p0)
         expdata1 = exp1.run(backend=backend, experiment_data=expdata0, shots=1000)
         expdata1.block_for_results()
-        results1 = expdata1.analysis_results()
+
+        res_t2star_1 = expdata1.analysis_results("T2star")
+        res_freq_1 = expdata1.analysis_results("Frequency")
 
         self.assertAlmostEqual(
-            results1[0].value.value,
+            res_t2star_1.value.value,
             estimated_t2ramsey,
-            delta=TestT2Ramsey.__tolerance__ * results1[0].value.value,
+            delta=TestT2Ramsey.__tolerance__ * res_t2star_1.value.value,
         )
         self.assertAlmostEqual(
-            results1[1].value.value,
+            res_freq_1.value.value,
             estimated_freq,
-            delta=TestT2Ramsey.__tolerance__ * results1[0].value.value,
+            delta=TestT2Ramsey.__tolerance__ * res_freq_1.value.value,
         )
-        self.assertLessEqual(results1[0].value.stderr, results0[0].value.stderr)
+        self.assertLessEqual(res_t2star_1.value.stderr, res_t2star_0.value.stderr)
         self.assertEqual(len(expdata1.data()), len(delays0) + len(delays1))

From aeb56202b168eb3b835b9149ab116677f05e242b Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 15 Oct 2021 03:44:24 +0900
Subject: [PATCH 02/14] fix t1 test

---
 qiskit_experiments/curve_analysis/curve_analysis.py | 5 ++++-
 test/test_t1.py                                     | 5 ++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/qiskit_experiments/curve_analysis/curve_analysis.py b/qiskit_experiments/curve_analysis/curve_analysis.py
index 17de1fbf9e..686a7afecb 100644
--- a/qiskit_experiments/curve_analysis/curve_analysis.py
+++ b/qiskit_experiments/curve_analysis/curve_analysis.py
@@ -846,7 +846,10 @@ def _run_analysis(
         # Pop arguments that are not given to the fitter,
         # and update class attributes with the arguments that are given to the fitter
         # (arguments that have matching attributes in the class)
-        extra_options = self._arg_parse(**options)
+        analysis_options = self._default_options().__dict__
+        analysis_options.update(options)
+
+        extra_options = self._arg_parse(**analysis_options)
 
         # Update all fit functions in the series definitions if fixed parameter is defined.
         # Fixed parameters should be provided by the analysis options.
diff --git a/test/test_t1.py b/test/test_t1.py
index 2f851a04dc..38e3100f09 100644
--- a/test/test_t1.py
+++ b/test/test_t1.py
@@ -50,7 +50,7 @@ def test_t1_end2end(self):
         )
 
         exp = T1(0, delays, unit="dt")
-        exp.set_analysis_options(p0={"amp": 1, "tau": t1/dt_factor, "base": 0})
+        exp.set_analysis_options(p0={"amp": 1, "tau": t1 / dt_factor, "base": 0})
         exp_data = exp.run(backend, shots=10000)
         exp_data.block_for_results()  # Wait for analysis to finish.
         res = exp_data.analysis_results("T1")
@@ -110,6 +110,8 @@ def test_t1_analysis(self):
         """
 
         data = ExperimentData()
+        data._metadata = {"job_metadata": [{"run_options": {"meas_level": 2}}]}
+
         numbers = [750, 1800, 2750, 3550, 4250, 4850, 5450, 5900, 6400, 6800, 7000, 7350, 7700]
 
         for i, count0 in enumerate(numbers):
@@ -157,6 +159,7 @@ def test_t1_low_quality(self):
         """
 
         data = ExperimentData()
+        data._metadata = {"job_metadata": [{"run_options": {"meas_level": 2}}]}
 
         for i in range(10):
             data.add_data(

From d28dcd24a16b9139892b94a7420c1dede2e3fa83 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 15 Oct 2021 03:44:31 +0900
Subject: [PATCH 03/14] black

---
 .../curve_analysis/standard_analysis/decay.py      |  9 ++++++---
 .../standard_analysis/oscillation.py               | 14 ++++++++++----
 test/test_t2ramsey.py                              |  8 ++------
 3 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/qiskit_experiments/curve_analysis/standard_analysis/decay.py b/qiskit_experiments/curve_analysis/standard_analysis/decay.py
index 9466d40729..c209db0fa3 100644
--- a/qiskit_experiments/curve_analysis/standard_analysis/decay.py
+++ b/qiskit_experiments/curve_analysis/standard_analysis/decay.py
@@ -40,7 +40,10 @@ class DecayAnalysis(curve.CurveAnalysis):
     __series__ = [
         curve.SeriesDef(
             fit_func=lambda x, amp, base, tau: curve.fit_function.exponential_decay(
-                x, amp=amp, lamb=1/tau, baseline=base,
+                x,
+                amp=amp,
+                lamb=1 / tau,
+                baseline=base,
             ),
             plot_color="blue",
             model_description=r"amp \exp(-x/tau) + base",
@@ -49,7 +52,7 @@ class DecayAnalysis(curve.CurveAnalysis):
     ]
 
     def _generate_fit_guesses(
-            self, user_opt: curve.FitOptions
+        self, user_opt: curve.FitOptions
     ) -> Union[curve.FitOptions, List[curve.FitOptions]]:
         """Compute the initial guesses.
         Args:
@@ -62,7 +65,7 @@ def _generate_fit_guesses(
         user_opt.p0.set_if_empty(base=curve.guess.min_height(curve_data.y)[0])
 
         user_opt.p0.set_if_empty(
-            tau=-1/curve.guess.exp_decay(curve_data.x, curve_data.y),
+            tau=-1 / curve.guess.exp_decay(curve_data.x, curve_data.y),
             amp=curve.guess.max_height(curve_data.y)[0] - user_opt.p0["base"],
         )
 
diff --git a/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py b/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py
index ea0225cded..de816f862a 100644
--- a/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py
+++ b/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py
@@ -170,7 +170,12 @@ class DumpedOscillationAnalysis(curve.CurveAnalysis):
     __series__ = [
         curve.SeriesDef(
             fit_func=lambda x, amp, base, tau, freq, phi: curve.fit_function.cos_decay(
-                x, amp=amp, tau=tau, freq=freq, phase=phi, baseline=base,
+                x,
+                amp=amp,
+                tau=tau,
+                freq=freq,
+                phase=phi,
+                baseline=base,
             ),
             plot_color="blue",
             model_description=r"amp \exp(-x/tau) \cos(2pi freq x + phi) + base",
@@ -178,7 +183,7 @@ class DumpedOscillationAnalysis(curve.CurveAnalysis):
     ]
 
     def _generate_fit_guesses(
-            self, user_opt: curve.FitOptions
+        self, user_opt: curve.FitOptions
     ) -> Union[curve.FitOptions, List[curve.FitOptions]]:
         """Compute the initial guesses.
 
@@ -215,13 +220,14 @@ def _generate_fit_guesses(
         # Set guess for decay parameter based on estimated frequency
         if freq_guess > df:
             user_opt.p0.set_if_empty(
-                tau=-1/curve.guess.oscillation_exp_decay(
+                tau=-1
+                / curve.guess.oscillation_exp_decay(
                     curve_data.x, curve_data.y - user_opt.p0["base"], freq_guess=freq_guess
                 )
             )
         else:
             # Very low frequency. Assume standard exponential decay
-            user_opt.p0.set_if_empty(tau=-1/curve.guess.exp_decay(curve_data.x, curve_data.y))
+            user_opt.p0.set_if_empty(tau=-1 / curve.guess.exp_decay(curve_data.x, curve_data.y))
 
         user_opt.bounds.set_if_empty(
             amp=[0, 1.5],
diff --git a/test/test_t2ramsey.py b/test/test_t2ramsey.py
index e1509a2577..17dabb1691 100644
--- a/test/test_t2ramsey.py
+++ b/test/test_t2ramsey.py
@@ -81,18 +81,14 @@ def test_t2ramsey_run_end2end(self):
                     estimated_t2ramsey * conversion_factor,
                     delta=TestT2Ramsey.__tolerance__ * result.value.value,
                 )
-                self.assertEqual(
-                    result.quality, "good", "Result quality bad for unit " + str(unit)
-                )
+                self.assertEqual(result.quality, "good", "Result quality bad for unit " + str(unit))
                 result = expdata.analysis_results("Frequency")
                 self.assertAlmostEqual(
                     result.value.value,
                     estimated_freq,
                     delta=TestT2Ramsey.__tolerance__ * result.value.value,
                 )
-                self.assertEqual(
-                    result.quality, "good", "Result quality bad for unit " + str(unit)
-                )
+                self.assertEqual(result.quality, "good", "Result quality bad for unit " + str(unit))
 
     def test_t2ramsey_parallel(self):
         """

From 4e26a54eadcad57e095a052fd5d473a0210062dc Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 15 Oct 2021 04:21:18 +0900
Subject: [PATCH 04/14] fix conversion factor handling

---
 .../library/characterization/t1.py            |  7 -----
 .../library/characterization/t1_analysis.py   | 19 +++++++++++--
 .../library/characterization/t2ramsey.py      | 28 +++++++++++++------
 .../characterization/t2ramsey_analysis.py     | 21 +++++++++++---
 4 files changed, 52 insertions(+), 23 deletions(-)

diff --git a/qiskit_experiments/library/characterization/t1.py b/qiskit_experiments/library/characterization/t1.py
index 5415352d30..c645bce9fa 100644
--- a/qiskit_experiments/library/characterization/t1.py
+++ b/qiskit_experiments/library/characterization/t1.py
@@ -114,14 +114,7 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
         elif self.experiment_options.unit != "s":
             conversion_factor = apply_prefix(1, self.experiment_options.unit)
 
-        # override init guess with correct unit
-        # TODO be moved to pre-analysis
-        user_p0 = self.analysis_options.p0
-        if user_p0.get("tau", None) is not None:
-            user_p0["tau"] *= conversion_factor
-
         self.set_analysis_options(
-            p0=user_p0,
             extra={
                 "conversion_factor": conversion_factor,
                 "unit": self.experiment_options.unit,
diff --git a/qiskit_experiments/library/characterization/t1_analysis.py b/qiskit_experiments/library/characterization/t1_analysis.py
index aafa580d4c..301f2bdc85 100644
--- a/qiskit_experiments/library/characterization/t1_analysis.py
+++ b/qiskit_experiments/library/characterization/t1_analysis.py
@@ -12,13 +12,14 @@
 """
 T1 Analysis class.
 """
+from typing import Union, List
 
-from qiskit_experiments.curve_analysis import DecayAnalysis, ParameterRepr
+import qiskit_experiments.curve_analysis as curve
 
 from qiskit_experiments.framework import Options
 
 
-class T1Analysis(DecayAnalysis):
+class T1Analysis(curve.DecayAnalysis):
     r"""A class to analyze T1 experiments.
 
     # section: see_also
@@ -33,6 +34,18 @@ def _default_options(cls) -> Options:
         options.xlabel = "Delay"
         options.ylabel = "P(1)"
         options.xval_unit = "s"
-        options.result_parameters = [ParameterRepr("tau", "T1", "s")]
+        options.result_parameters = [curve.ParameterRepr("tau", "T1", "s")]
 
         return options
+
+    def _generate_fit_guesses(
+        self, user_opt: curve.FitOptions
+    ) -> Union[curve.FitOptions, List[curve.FitOptions]]:
+        """Apply conversion factor to tau."""
+
+        extra = self._get_option("extra")
+
+        conversion_factor = extra.get("conversion_factor", 1)
+        user_opt.p0["tau"] *= conversion_factor
+
+        return super()._generate_fit_guesses(user_opt)
diff --git a/qiskit_experiments/library/characterization/t2ramsey.py b/qiskit_experiments/library/characterization/t2ramsey.py
index 8dc9be4931..1580551094 100644
--- a/qiskit_experiments/library/characterization/t2ramsey.py
+++ b/qiskit_experiments/library/characterization/t2ramsey.py
@@ -103,6 +103,25 @@ def __init__(
         super().__init__([qubit])
         self.set_experiment_options(delays=delays, unit=unit, osc_freq=osc_freq)
 
+    def set_experiment_options(self, **fields):
+        """Set the experiment options.
+
+        Args:
+            fields: The fields to update the options
+
+        Raises:
+            AttributeError: If the field passed in is not a supported options
+        """
+        super().set_experiment_options(**fields)
+
+        # set frequency guess from experiment configuration
+        if "osc_freq" in fields:
+            user_p0 = self.analysis_options.p0
+            if user_p0.get("freq", None) is None:
+                user_p0["freq"] = fields["freq"]
+
+            self.set_analysis_options(p0=user_p0)
+
     def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
         """Return a list of experiment circuits.
 
@@ -129,16 +148,7 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
         elif self.experiment_options.unit != "s":
             conversion_factor = apply_prefix(1, self.experiment_options.unit)
 
-        # override init guess with correct unit
-        # TODO be moved to pre-analysis
-        user_p0 = self.analysis_options.p0
-        if user_p0.get("tau", None) is not None:
-            user_p0["tau"] *= conversion_factor
-        if user_p0.get("freq", None) is None:
-            user_p0["freq"] = self.experiment_options.osc_freq
-
         self.set_analysis_options(
-            p0=user_p0,
             extra={
                 "osc_freq": self.experiment_options.osc_freq,
                 "conversion_factor": conversion_factor,
diff --git a/qiskit_experiments/library/characterization/t2ramsey_analysis.py b/qiskit_experiments/library/characterization/t2ramsey_analysis.py
index 64b7aeb5cb..049e24e497 100644
--- a/qiskit_experiments/library/characterization/t2ramsey_analysis.py
+++ b/qiskit_experiments/library/characterization/t2ramsey_analysis.py
@@ -12,14 +12,16 @@
 """
 T2Ramsey Experiment class.
 """
+from typing import Union, List
 
-from qiskit_experiments.curve_analysis import DumpedOscillationAnalysis, ParameterRepr
 from qiskit_experiments.data_processing import DataProcessor, Probability
+import qiskit_experiments.curve_analysis as curve
+
 
 from qiskit_experiments.framework import Options
 
 
-class T2RamseyAnalysis(DumpedOscillationAnalysis):
+class T2RamseyAnalysis(curve.DumpedOscillationAnalysis):
     """T2 Ramsey result analysis class.
 
     # section: see_also
@@ -38,8 +40,19 @@ def _default_options(cls) -> Options:
         options.ylabel = "P(0)"
         options.xval_unit = "s"
         options.result_parameters = [
-            ParameterRepr("freq", "Frequency", "Hz"),
-            ParameterRepr("tau", "T2star", "s"),
+            curve.ParameterRepr("freq", "Frequency", "Hz"),
+            curve.ParameterRepr("tau", "T2star", "s"),
         ]
 
         return options
+
+    def _generate_fit_guesses(
+        self, user_opt: curve.FitOptions
+    ) -> Union[curve.FitOptions, List[curve.FitOptions]]:
+        """Apply conversion factor to tau."""
+        extra = self._get_option("extra")
+
+        conversion_factor = extra.get("conversion_factor", 1)
+        user_opt.p0["tau"] *= conversion_factor
+
+        return super()._generate_fit_guesses(user_opt)

From a07af9b6a45bc6eea5c0731b901aa4f15774d5f1 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 15 Oct 2021 04:21:28 +0900
Subject: [PATCH 05/14] update tutorials

---
 docs/tutorials/t1.ipynb                       |  77 ++++++----
 .../tutorials/t2ramsey_characterization.ipynb | 134 ++++++++++--------
 2 files changed, 124 insertions(+), 87 deletions(-)

diff --git a/docs/tutorials/t1.ipynb b/docs/tutorials/t1.ipynb
index ccd2352b3c..94d8b902fb 100644
--- a/docs/tutorials/t1.ipynb
+++ b/docs/tutorials/t1.ipynb
@@ -27,9 +27,9 @@
    "outputs": [
     {
      "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": {},
@@ -39,12 +39,20 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      "DbAnalysisResultV1\n",
+      "- name: @Parameters_T1Analysis\n",
+      "- value: [9.63204562e-01 3.85656114e-02 2.36038969e-05] ± [3.51598772e-02 3.79968650e-02 1.80172646e-06]\n",
+      "- χ²: 0.42688945155332503\n",
+      "- quality: good\n",
+      "- extra: <6 items>\n",
+      "- device_components: ['Q0']\n",
+      "- verified: False\n",
       "DbAnalysisResultV1\n",
       "- name: T1\n",
-      "- value: 2.360389446679917e-05 ± 1.8017434376082348e-06 s\n",
-      "- χ²: 0.4268894515534609\n",
+      "- value: 2.3603896939582557e-05 ± 1.801726464426719e-06 s\n",
+      "- χ²: 0.42688945155332503\n",
       "- quality: good\n",
-      "- extra: <9 items>\n",
+      "- extra: <2 items>\n",
       "- device_components: ['Q0']\n",
       "- verified: False\n"
      ]
@@ -96,17 +104,7 @@
     {
      "data": {
       "text/plain": [
-       "{'popt': array([9.63204516e-01, 2.36038945e-05, 3.85656630e-02]),\n",
-       " 'popt_keys': ['a', 'tau', 'c'],\n",
-       " 'popt_err': array([3.51602499e-02, 1.80174344e-06, 3.79972358e-02]),\n",
-       " 'pcov': array([[ 1.23624317e-03,  5.95164706e-08, -1.31594867e-03],\n",
-       "        [ 5.95164706e-08,  3.24627941e-12, -6.68005020e-08],\n",
-       "        [-1.31594867e-03, -6.68005020e-08,  1.44378993e-03]]),\n",
-       " 'reduced_chisq': 0.4268894515534609,\n",
-       " 'dof': 10,\n",
-       " 'x_range': (1e-06, 3.7e-05),\n",
-       " 'y_range': (0.247, 0.96),\n",
-       " 'circuit_unit': 'us'}"
+       "{'conversion_factor': 1e-06, 'unit': 'us'}"
       ]
      },
      "execution_count": 2,
@@ -149,7 +147,7 @@
       "- verified: False\n",
       "\n",
       "extra:\n",
-      "{'experiment_types': ['T1', 'T1'], 'experiment_ids': ['4310951d-2d55-4c63-a136-514141c10df4', '079ad7b5-94d0-4b14-8de3-fb90963877b7']}\n"
+      "{'experiment_types': ['T1', 'T1'], 'experiment_ids': ['986c2e8b-07a9-4418-afba-9ff39c4fbc54', 'cb8d1988-9e12-4f69-9126-c39b50dfcb25']}\n"
      ]
     }
    ],
@@ -196,9 +194,9 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEhCAYAAACDefxEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABG+ElEQVR4nO3dd3yUZbbA8d+ZSSaF0FvoBL1rLwiKsJagoosKimK7irJNbFfXctd1m3UtW7y6oiu6roXdFRUbrhWV6NoFwba6qxJA6UgNhASTc/84eckQUybJ1OR8P5/5xLz1mSG+Z57nPEVUFeeccy4WoVQXwDnnXObwoOGccy5mHjScc87FzIOGc865mHnQcM45FzMPGs4552LmQcO5KCJypIg8KyJfi8hWEfm3iNwoIl1acc0SEXkthuOuEhGN+r1Lzbb9mnGvPUTkBREpq3kP94pIt5aW3bm6PGg4V0NEfg48D2wFfgQcBUwDvg+8IyL9ElyEPwMjo37vAlwJxBQ0RKQvUALkAROB84EjgH+IiP+/7uIiK9UFcC4diMho4DrgFlW9OGrXKyLyODAPuBc4MlFlUNWvgK9acYn/BbKBcaq6HkBElgGvAMcDj7WyiM55TcO5Gj8F1gJX1N2hqqXAjcCYoKlIRAaLiIrI5OhjRaS4Zntx3euIyHEi8pGIVIjIpyJycp3925unRGQwUFqz6+6aa37rfnWMB54OAkZN2V8FlgDHNfbmnYuVBw3X7olIFnAoMFtVtzZw2Kyan0e08DY7A38E/gCcAHwOzKip4dRnec1xADdgzVYjgafrO1hE8oAi4KN6dn8M7N7Ccju3A2+ecg66Y3mARY0cE+wb1MJ79AZGqupbACLyHPYwvwY4uO7BqlohIvNrfl0YnNeIroAA6+rZtxbYpYXldm4HXtNwrnmqW3jel9EPflWtAh4BDvAktcsk/sfqHHwNlAODGzkm2Le0hfdY2cC2CNCzhdeMth5QrMZRVzestuFcq3nQcO2eqn4DvIolunMbOGx8zc9Xan4GuY9IneO6N3B+7wa2VQKrYyxqg1R1C9aEtkc9u3cH/tXaezgHHjScC/wOe+BfX3eHiBQBlwMLVPXNms0rgQpgzzqHH9PA9QeIyIFR1wwDJwHvqGpDTV4VNT/zYnoHlqw/RkQ6R93nICwPM6vBs5xrBk+EOweo6ksiciVwdU131wewpPJ+wM+wL1inRh2vIvIQ8EMR+Q/wbyxgFDdwi5XAQzX3WA2cC3yn5mdDVmJNZ6eKyAfAZqBUVb9u4PjfAWcAs0TkBqAz8FvgbeDxRj8A52LkNQ3naqjqNcBYoAM2kK8EuBkb57CXqv67zikXYQPmrgIeAnKB/2ng8p/X7Lus5pz/Ak5T1TmNlKcaG5neFXgReBcY18jxS4HRWJPXo8CdwBzgmEZqM841i/hyr841TET+CkwADo+h26tzbZ4HDecaISIR4AVgL+AgVf0kxUVyLqU8aDjnnIuZ5zScc87FzIOGc865mLXpLrc9evTQwYMH17tv8+bNdOjQIbkFauP8M40v/zzjzz/T2MybN2+NqtY7U0GbDhqDBw9m7ty59e4rKSmhuLg4uQVq4/wzjS//POPPP9PYiMjihvZ585RzzrmYedBwzjkXMw8azjnnYuZBwznnXMw8aDjnnIuZBw3nnHMx86DhnHMuZm16nIZrPwYPHszixQ12LXcu7gYNGsSiRYtSXYyk86DRgIoKqKyEjh1TXRIXi8WLF+OTb7pkEpFUFyElvHmqAdu2weLFsG5dqkvinHPpw4NGI7KyYOVKWLs21SVxzrn04M1TjQiFoEMHWLUKqquhe3dopzVS55wDvKbRJBHLa6xZY8HDm82dc+2ZB40YiECnTrB+PaxYYbUO55xrjzxoNEPHjrBpEyxf7oEjE7zwwguISKOvBx54IGnlueGGG9h///3p1KkTPXv2ZNy4cXz00Uc7HHPVVVd9q4yFhYUNXnPw4MH1vq9jjjmmWfdNhJbe94477qCoqIjc3FyGDRvGP//5zx3233777ey999506tSJTp06MXLkSJ5++ulEvQ1XR9KDhogcIiKzRGSpiKiITI7hnL1E5BURKa8579eSov5uBQWwZQssXQpVVakogYvVwQcfzPLly7e/BgwYwKWXXrrDtlNPPTVp5SkpKeG8887jjTfe4OWXXyYrK4sjjjiCtXV6Wuyyyy47lPHDDz9s8JrvvvvuDse+9957iAgnn3xys+/blMmTJ3PVVVfF/f1Ge+ihh7jooov4+c9/zvz58xk1ahRjx45lyZIl24/p378/N910E++99x5z587lsMMO4/jjj+eDDz5o1vtxLaSqSX0BRwPXAxOBLcDkJo7vBKwAHgb2rDlvE3BpU/caNmyYNmTOnDkN7lNV3bRJ9d//Vl26tP7X55+rlpaqVlY2epl2panPNJHsT7lh69evVxHRxx57LEklatqmTZs0FArprFmztm+78sordY899mjxNa+77jrt3LmzbtmypVn3jcVZZ52lV155ZYvLFst9DzjgAP3Rj360w7add95Zf/aznzV67a5du+qdd97Z6DGHHnqonn/++TtsO+uss/SYY45RVdVXXnlFR4wYoR06dNBOnTrp/vvvrx9++GGD12vqby6TAXO1gedq0msaqvqMqv5cVWcCsTTynA7kA2ep6kc1590EXJKq2gZAXp7VNL780gYBuvT23nvvBV8kWnyN66+/noKCgkZfdZtSGrNp0yaqq6vp2rXrDtsXLlxI3759KSoq4tRTT2XhwoUxXU9VueeeezjjjDPIy8tr9n0Tran7VlZWMm/ePI488sgdth955JG88cYb9Z5TVVXFjBkzKCsrY9SoUS0u2zfffMNxxx3HQQcdxPvvv8/bb7/NT37yE8LhcIuv2VZlQpfbkcA/VbU8atvzwLXAYKA0+mARORs4G6B3796UlJTUe9GysrIG94HlLLZts263jVGFzz6DSMS74zb1mabSvHnz6NGjBwMHDtxh+4QJEygpKeHwww9n5syZjV7jnHPO2aHZpz79+vWLuUwXXXQR++67LyNHjty+bcSIEdx3333suuuurFq1iuuuu45Ro0bx8ccf071790avN3v2bEpLS/nxj3/c7PvW5/rrr+f666/f/ntFRQUiwu9///vt25599lkOPvjgRq8T633XrFlDVVUVvXv33mF77969efHFF3fY9uGHHzJy5Ei2bt1KQUEBjz/+OHvttVdM5ajPxo0bWb9+PePGjWOnnXYCYNddd23yvHT9e0+kTAgahcBXdbatjNq3Q9BQ1buAuwCGDx+uDa0H3NRawWVlsGyZ5TCaUllp044MGAD5+U0f31al8/rL7733HkOHDv3W9osuuogf/OAH3H///U1eo1u3bnTr1i0u5bnkkkt47bXXeO2113b4Njt27NgdjjvwwAMZMmQI999/P5dcckmj17z77rvZf//92WeffZp93/rUDZKXX345/fr148ILL9y+LdYg2Zz7xmKXXXZhwYIFbNiwgZkzZ3LWWWdRUlLCnnvu2aLrdevWjcmTJ3PUUUdx+OGHc/jhhzNx4sRvfcmoK13/3hPJe0/FQSRizVVLlljvKpd+3nvvvXqbpoqLi+kY4wRj8Wqeuvjii3nwwQd5+eWXGTJkSKPHFhQUsMcee/DZZ581etyqVat48sknG61lNOe+YA/SnXfeefurY8eO39rWWDNYc+/bo0cPwuEwK1eu3GH7ypUrv9WDLBKJsPPOOzNs2DBuuOEG9t13X/7v//6vybLUVRXVm+Xee+/l7bff5pBDDmHWrFnssssuPP/8882+ZluXCTWNFUDvOtt6R+1LC1lZNnp86VLo3RuS3FzsGlFWVsZ//vMf9ttvv1ZdJx7NUxdddBEPPfQQc+bMian5Y+vWrXz66aeMHj260ePuu+8+cnJyOO200+Jy33hpzn0jkQjDhg1j9uzZnHTSSdu3z549mxNPPLHRc6urq6moqGiyPHUD0sKFC3fIseyzzz7ss88+XH755YwdO5b777+fo446qsnrtieZEDTeBG4SkVxV3VqzbQywDFiUslLVIxy25qyVKy1J7tOOpIf58+ejqq0OGq1tnjr//POZPn06TzzxBF27dmXFCvvOE9RSAC677DLGjRvHwIEDWbVqFddeey2bN2/mrLPO2n6dqVOnMnXqVD799FPAEuB//vOfOfXUU7dfp7n3rU9ZWRllZWXbf7/xxhsBtp8P9plEIpEWv9+67+WSSy5h0qRJHHDAAXz3u9/lzjvvZNmyZZxzzjnbr/uzn/2MY445hgEDBrBp0yb+/ve/U1JSEtNYjX/84x888sgjDBs2jKeeeoo333yTvffem1deeYVnn32W8ePH069fPxYuXMgHH3zAueee2+Q1252GulUl6gUUAPvWvLYAv67574E1+28AXoo6vjNWo5iBdbk9AdhIirvcNvb66ivVTz9VXb5ctaqq0du0Kena5faWW27Rzp07a3V1db3758yZoyeeeGKiirYdUO8ruhvrKaecon369NHs7Gzt27evnnDCCfrxxx/vcJ0rr7xyh/f78ssvK6Bvv/12i+9bn+A+jb0a+zeP5b5134uq6u23366DBg3SSCSi++23n77yyis77D/rrLN04MCBGolEtGfPnnr44Yfrc8891+h7UbUutyeccIKOHDlSI5GIHnLIIXrvvfdqhw4ddPLkyTphwgTt27evRiIRHTBggP7v//6vVjbSp76xv7lMRyNdbkWTPJmSiBQDc+rZdb+qThaR+4BiVR0cdc5ewO3AAcA64E7gGm2i8MOHD9e5c+fWuy+eifCGbN4MubnQt6/VQtq6VCbCRaTF62mUlJQwderUJntPucxWXFzMnnvuydSpU+Nyvdb8zaU7EZmnqsPr25f05ilVLQEabLRR1cn1bPsQOCRxpfq2Vx9ewR75pYR2LaK6V8PTODSmQwcbPf7ll9CvH2Rnx7mQrtWOOOII3n//fTZv3kz//v155JFHmuyK6lx7lgk5jaSbddJ0jpg5BUTIzVE23DSN8omTWnSt/HwoL7eeVf37Q05OnAvrWqVu/3/nXOM8aNS1YgXHzJpCmHJrgd0KnS+fQsUhY1pc48jLs7Ecixdb4GjPYzmcS5X2OBAvEXycRl2lpYRzd2xHKq+KIItKGzghNpGI5TeWLIGNG1t1KeecSxkPGnUVFdn8IVFkWyU/v7uIb75p3aWzsiyxvmyZLerURnNozrk2zINGXYWFMG0ampdHVUFnvonkcWFkGn95ppDzzmv95IShkK3L8fXXvqCTcy7zeE6jPpMmsWXUGL6eW0pklyLGLynk4TPg6actaNx5pzU1tVSwhOymTfDNN9Cnj9VCnHMu3XlNowHau5CtQ0dS3auQ4cPh4YehSxeYPRu+/33rSttaBQUWhJYssQkPnXMu3fn32xjtvTc88gicdhq8+iqcfjrcf7+tHd4aeXkWMLxnVesMGjSIFC6v4tqhQYMGpboIKeE1jWbYfXd49FFrTnrnHTjlFGjmipn1ysmx5q4vv4QNG1p/vfZo0aJFSZ8SJ9GvOXPmpLwMbe0Vz8900aJFqf6zTwkPGs20887w+OMwaBB88AFMnGgTFLZWMEvusmWwerX3rHLOpScPGi0wYAA89hj813/Bv/8NEyZYXqK1QiFr7lq71oJH1FT/zjmXFjxotFBhoQWOffaxfMSECfCf/7T+ukHPqmDqEV9/3DmXTjxotEK3bvDQQzBypI25OOEEWLAgPtfOz7cmqsWL49NTyznn4sGDRit17AjTp8Phh8O6dXDyyRDDip8xyc21JPmSJbB+fXyu6ZxzreFBIw7y8uCee6ymsXkznHkmPPtsfK4dTD2yYoUl3H0EuXMulTxoxEl2Ntx6K/zgB5aHOPts+Pvf43PtIEG+YYOtQd7aObCcc66lPGjEUSgE11wDl15qNYL//V/44x/j1302GEG+eDFs3dr08c45F28eNOJMBC65BK6/3v77ppvgyivrb1bqPn4UPY4aSmjVipivn5dnS8cuXuxTrDvnks+DRoKcdRb86U+2jsY998B55+04v1TezOlE5r9N9icf0mvkEPJmTo/52pGI9a7ygYDOuWTzoJFA48ZZz6qCAnjqKTjjDKsdhFatoPPlU5DqaqSqitDWcjpfPqVZNY5w2HpurVsHX33leQ7nXHJ40GhAJGLNS60dXHfQQTZfVa9e8MYbcOKJsGFBqWXOo2VHCC9p3uqAIp7ncM4llweNBkQiMHCgLeLX2sCx557w5JMwZAj8619w6hVFaOWOqwOyrZKqgUUtun50nsMnPHTOJZIHjUbk5Ng8U5WV31oBttkGDrTAMWwYLFhRyLmhaXwTyaO6Y2eqc/PYcNM0qnsVtvj6kYhNeLh8uY/ncM4ljgeNJuTm2gO/oqL1gSOYduSoo+Du8knsxEKePOdZVr25kPKJk1pd1ujxHF9+2fryOudcXR40YhDPwJGXB3ffbb2rllQWcsLvRnLHY4Vx7QFVUGAz5C5aZCPUnXMuXjxoxCiegSMcht/8Bn75S/v92mvtv+M5FXr0vFVff+3dcp1z8eFBoxniGThE4Nxz4Y47LB9x3302BUk8awZZWdZctXq1Tz/inIsPDxrNFB044rHWxXHHwYwZ0KULvPiiTXq4IvbhGk0SscARrENeXh6/azvn2h8PGi0QBI54dMcFGDECZs2CwYPho4/g2GPh449bf91oeXlW81iyxAYEenOVc64lPGi0ULwDx0472ajx4cOt2+yECVbziKfsbOuWu3KlTUHizVXOuebyoNEKOTkWOL75Zsd5pVoq6JJ7/PGW2/j+9+Evf2n9daMF3XK3bvXmKudc83nQaKUgcFRXxydw5ObC1Kk2U251NfzqV3DFFfEfcxE0Vy1e7M1VzrnYpSRoiMh5IlIqIltFZJ6IHNzE8f8tIgtEZIuIrBCRv4pIy4dPx1kkYiPHq6vjM/+TiK3JMXWqBaUHHoBJk+K/5Gt2to3p8OYq51yskh40ROQU4FbgemAo8AbwrIgMbOD47wLTgfuBPYDjgd2BvyWjvLEK5qqC+DX5TJgADz8MPXrYuuPjx8PChfG5diBoriov9+Yq51zTUlHTuAS4T1XvVtVPVPV/gOXAuQ0cPxL4SlX/T1VLVfUt4DZgRJLKG7PsbKtxhELxe/gOHw5PPw277QZffGE9q159NT7XjpafX9tctXatN1c55+qX1KAhIhFgGPBCnV0vAKMaOO11oI+IjBPTAzgVeCZxJW25IHBkZcUvcPTvD088AUceafNKnXGGJcjj/WDPzrY1OlavtjU6fO4q51xdokn8SikifYGlwKGq+mrU9l8Dp6vqLg2cdwJwH5AHZAGzgeNU9VuPZRE5GzgboHfv3sNmzJhRb1nKysooKCho1ftpyrZtlucIxSk0V1fDffcVMWPGIADGjl3GBRd8RnZ2/P8Ng1lys7NjL38yPtP2xD/P+PPPNDajR4+ep6rD69uX9kFDRHbHgsQtwPNAH+B3wAJVPbOx+w0fPlznzp1b776SkhKKi4tb9kZiVF1tYy42b7aEc7w8/jhcdpkl3fff3yZA7NkzftcPVFVZ2bt2tbxKONz48cn4TNsT/zzjzz/T2IhIg0Ej2TmNNUAV0LvO9t5AQ5NnXAG8o6q/U9UPVPV54Dxgkoj0T1xRWy8Ugj59rMln06b4XXfCBHjsMSgshHffhbFj4YMP4nf9QDhsSfKNG31lQOecSWrQUNVKYB4wps6uMVgvqvrkY4EmWvB72o8zCYXs4d6liz1841Wx22cfePZZW9QpGEH+6KPxuXZdHTrY+1i0yMd0ONfepeKhezMwWUR+JCK7icitQF/gTgAReUBEHog6/ingOBE5V0SG1HTB/SPwnqouSXrpW0DE1gjv0cNqHPF66PbqBY88Av/931YLuPBCuPrqxIy3iESsiW3VKk+SO9eeJT1oqOpDwE+AXwILgIOAo1V1cc0hA2tewfH3Yd10LwA+AmYC/wGOS1aZ40HEgkavXlbjiNdyrDk58Nvfwg03WI+tu+6yIPL11/G5frRQyJraKiuhtDS+TW7OucyQkuYdVb1DVQerao6qDotOiqtqsaoW1zn+NlXdQ1XzVbWPqp6uql8lveBx0K0b9OsHZWXxW3RJBM4802odPXvC668nLs8BNgVJXp6t0bF8eXwXj3LOpbe0zwm0RZ062diLLVvi28xzwAGW59hvP3ugH3+8TYCYCEGSfPNmy3Vs2ZKY+zjn0osHjRQpKIjvYk6BPn1g5kwbAFhRYRMf/vSn8ZlMsT75+TaWY8kSy6XEq9nNOZeePGikUF4eDBpkzTvx7M6akwM33QR/+IP999/+ZisCLl0av3tEy8qyXEdVldU6vGuuc22XB40UC6ZWF4n/ZIGnngpPPmnTmixYAEcdBSUl8b1HQMQS5UHX3DVrvNbhXFvkQSMNZGdb4IhELEEeT8W/GMW8DgdxwqgVrFtnzVY335y4B3okYrWOtWutycprHc61LR400kQ4bL2qgtHj8RjLkTdzOpH5b9Pjs7d45L0h/H3sdMCarc44IzHdcsFqHQUF9h4WLbIA4rUO59oGDxppJBg93q2bBY7WPGhDq1bQ+fIpSHU1UlVFaGs5p8yZwqO3r6BrV3jlFZs1991341f+unJyLAiuWWO1jkQl451zyeNBI82I2FiL3r1bN5YjvKTU2r2iZUc4qF8pzz9v63SsWAETJ8KddyZuapDoWkdpqdc6nMt0HjTSVNeurRvLUTWw6NsnbqukamAR/fpZt9wpU6yb7LXXwve/b/NKJUrdWofnOpzLTB400lhBgXXJ3bat+Q/Z6l6FbLhpGhoKoeEw1bl5bLhpGtW9bGn17Gz49a9tMafOnWH2bGuuamAm+biom+vwHlbOZR4PGmkuN9cCR0u65JZPnMTKeUtZ89g/WfXmQsonTvrWMUcdBc8/D0OHwrJlNp7j9tsT+zAPah1r11rw8HXJncscHjQyQGu65Fb3KmTb8JHbaxj1GTDA1uc4+2zLoVx/PUyaZDWBRAlqHaGQrdWxerXPYeVcJvCgkSGCLrmdO8d3ltxAJAJXXgn332/5lJISGDMGXn21yVNbfd+OHWH9ep/DyrlM4EEjg4RC1quqtT2rGnPEEZbfGDnS1s747/+2mkci188QsYWesrIsSb58eWLWBHHOtZ4HjQwU3bMqnpMdBvr0sdlxL7vMHui3324rAy5aFP97RcvOrp05t7Q0visdOufiw4NGhioogMGDrZkqEYnkcBguvtiWkO3bF+bPt95VjzyS+Ad5fr51AFi+3FYJTERgdM61jAeNDBZMdpiIOasCBxxgzVXHHms1gJ/8BC64ADZsSMz9AuGw5Tq2bfNBgc6lEw8aGS4rK7EJcoAuXWzU+M03Wy3giScsSf7WW/G/V125uZbvWLPGu+c6lw48aLQBoZCtPR4kyBORRBaBU06B556DffaxtTkmTrS1yRPdfBQK7dg9d+VKT5Q7lyoeNNoIEUuQB6sBJmqajp12sjU6LrzQ7jl1KowfD+vGnMSIc39MaNWKxNwYa4br1Mkmc/REuXOp4UGjjcnPtxHkoVDixjxkZ8Pll9v8VQMGwD4fTqfoX08TWfglvUYOIW/m9MTcuEZ0otznsXIuuTxotEGRiD3M8/PjtzZHfUaMgJf/voI/h6eQTzm5WkFoazmdfzoloTUOqE2UV1dbrmPVKh9R7lwyeNBoo8JhG2/Rs6c14yQqB9B5bSnZ+TtOwb6pIsJr00uT0nQUzGO1YYM3WTmXDB402jARW9Bp4EBrwknEIkj1TcGeTSUX3FzE2WcnbnXAaMGI8pwcm3TRm6ycSxwPGu1Ahw42EFDExlrEU/QU7NWhENW5eZScOo3NBYU88wyMHg3PPBPfezYkHLZEedBk5b2snIs/DxrtRJDnKCho/VKydQVTsM+9+Y+senMh+/5hEi+9BN/9rtU0fvxjGxC4dm387tmYoMkq6GW1YYM3WTkXLx402pFw2NYg79XLahzxnISwulchG3bfY/sU7P37w4wZcN11kJcHjz8Ohx1ma3ckg0htL6uVK30GXefiJeagISIRETlVRO4TkU9FZKOIVIrIchEpEZGrRWT3RBbWtV70eI5t2xI7wjoUsmVkX3zRelqtXg0/+EFyax3hsNWuRCzXsWyZz2XlXGs0GTREJF9ErgSWAn8FhgHvAHcDvwUeB8qBC4APReQVEflu4ors4iEvz/IckUhiu+WC3WfmTLjmGvvm//jjlut4+unE3bOuYGBgebk1Wa1Z4110nWuJWGoaC4HjgV8DvVV1L1U9U1UvVdVfqup5qjpWVbsDhwD/Ap4XkSmJK7aLh6wsa0bq3t0CRyKTxqEQ/PCH8NJLtlbHmjW2UuDZZ1sNJFny8qzmsXatd9F1riViCRpTVHWoqv5JVRvtQKmqr6vqucBOwIJ4FNAllgj06GFJ8oqKxE8IOHgwPPww/OY3lnN4+mkoLk7OlOuBYKnZnBwbVb54sU+E6Fysmgwaqvpkcy+qqitV9e2WFcmlQtAtNyvLJj1M5AM8FILJk2HOHAsY69fblOtnnAFffpm4+9YVjCoHy3csXer5Duea4r2n3HbZ2Vbj6No18c1VYE1jf/0r3HKLTb9eUmK5jrvvTm6+IVinfOtWa7JavdrHdzjXkLgFDREZJiJ/ifHY80SkVES2isg8ETm4ieMjInJNzTkVIrJERC6MT8ldtFDIph7p3z85zVUicNJJFjDGj7f7XXWV/ffHHyf23nUF+Y5gSpJ163zhJ+fqimdNYzBwVlMHicgpwK3A9cBQ4A3gWREZ2MhpM4DvAWcDuwAnAR+0sryuEcFystnZie9dBRao/vQnuPdeG0uyYAGMHQvXX5/cfEMwviMvz2ocpaXJef/OZYpUNE9dAtynqner6ieq+j/AcuDc+g4WkSOBw4GjVXW2qi5S1bdVtSR5RW6fguaqZPSuChx5pNU6fvAD+5Z/++02KHDOnMTfO1qw8FN2to3tWLzYBwc6B7GN06iK5QU8HMO1Itg4jxfq7HoBGNXAaccD7wKXiMhXIvKZiPxRRAqaup9rvaB31cCBliROxoOzY0e49lqYNQt2282S1GecAVfuORM57NCET7seLStrx2T5l1/6ZIiufRNtot4tIhXYQ7up73q7ARNUNdzItfpigwQPVdVXo7b/GjhdVXep55zngGLgJeAaoAtwG/CBqk6s5/izsWYsevfuPWzGjBn1lqWsrIyCAo87zbVtmyWpw/X8K2/dWkZubnw/02++ER57rD/f3Psat1edyzayyQtX8slPLmbVUUfG9V6xULUaUDhsAUUkcffyv9H48880NqNHj56nqsPr2xdL0JgLLFbVE5s47kTg4QQEjReAg4FCVd1Qs+1I4PmabSsbut/w4cN17ty59e4rKSmhuLi4sbfk6qFqXWRXrbJeRzk5tfs+/riEPfYojvs9Q6tW0PPAIYQrapMbWyWP16cvZLfRhXG/XyzKy625rmtXe2VnN31Oc/nfaPz5ZxobEWkwaMSS05gH1HtyffdqYv8aoAroXWd7b6ChNoflwNIgYNT4pOZnY8lzlwDB3FWDB9vviR7TARBeUopEdnwqb9UIvzqjlCuusCCWbEFPq40bYeFCG+Hu3XRdexBL0Pgj8KsYjnsGKGrsAFWtxILQmDq7xmC9qOrzOtC3Tg7jOzU/F8dQLpcAOTm2FnmXLolPkte30FN+uJIl4SIeeAAOPhgeeij53WODnlYFBdY9N+im63NaubYslhHhH6vqAzEcV66qsTzEbwYmi8iPRGQ3EbkV6AvcCSAiD4hI9P3+DnwN3Csie9RMhngrMFNVV8VwP5cgoZBNsz5ggCXJE/XQjl7oScNhqnPz2HzzNKbPLuTAA20eqUsugeOPhw8/TEwZGhOsHBjdTXf9eh/j4dqmpHe5VdWHgJ8Av8TmpzoI604bBJyBRDU7qWoZcATQGUvIPwy8AvwgaYV2jQqmIAmFrLkmEd+0yydOonLoCLbtther3lxI+cRJ7LKLzZ77xz9a8Jo3z8Z2XHGFfeNPtqCbbk6O5XyCBaA8eLi2JJYutyc096Ii0kdEDmxov6reoaqDVTVHVYdFJ8VVtVhVi+sc/29VPVJV81W1n6qer6qbmlsulzhZWZYM7tvXksSJ6Jb69aw3WPP8/O0LPYF9yz/xRHj1VVshMBSCBx6Agw6yn6loKgrW8IhEYMWK2tl0PXi4tiCWmsZtIrJARM4RkW6NHSgiB4vIXcDnwN5xKaHLKJ067TiSPFkPyo4dbfqRF16AUaOseeiKK+Doo+Gdd5JThrqCCREjEZtNd9EiDx4u88USNP4LeAwbI7FSRD4QkekicrOI3CAid4rICyKyFiipOX6Mqt6VuGK7dBaJ2NxVwbKyFRXJu/euu9rU63feabWejz6CCRPgvPNsFttUCIJHVpYHD5f5YkmEb1HVa4D+wBlY76dhWE7hYmAcEMaS03uo6mhVbagnlGsnorvmiiSna270vceNsyariy+21QKffBIOOQRuvjl1a2cEo8s9eLhMFnMivKa77EvAuaq6u6p2UdXcmhzD4ap6tap+mriiukyUk2NTkPToYc1Vyax15OXBZZfBK6/AscdanuUPf7Auuo8/nrpJCKODx4oVHjxcZoklER4WkatEZB2wEtgoIo+KSJeEl861CaEQdOuWmloHWFPZtGnw6KOw5572Lf+CC6w28u67yStHXVlZljAPah7e28plglhqGudg64PPB34PPAkcB/xfAsvl2qDc3NTVOgAOPBCeeQZ+/3ubin3+fBvbce65yV0xsK6g5hGJwMqVtcHDuXQUS9D4MXC3qh6mqper6knA+cAZNbPWOhezVNc6wmE47TR47TW46CILZLNmWb7juutS+7CO7qq7cqUFVR9h7tJNLEFjCPBInW0PYcnvQXEvkWsXomsdZWXJn268oAB++lNLlp9wgo1o/9Of4MS9/kPJsEuoWpq86dfrCoJHKGQjzH1uK5dOYgkaBcDGOtuCgXUd41sc155E1zrC4eSO6wj06we33WbNVlftNJ25Vfty9Ip76DFiCJ/+YnrKV+wrKLCE/vr18MUXNtK8sjK1ZXLtW1aMx/UTkSFRv4ejtq+PPlBVF8ajYK79CHpYbdhgzTJZWfagTKahfVZw1NIphCgnn3JQOPC+KRw3dwznXFXIyJHJLU+0UMgmRlS1Xlbr1tkgym7ddpya3rlkiDVozGxg+xP1bGtwPQ3nGiJiM+bm51uTzMaNNqdVfYs9JUJ4SakNY99aO4hjm0Qo+6iUiRMLOfxwG2G+227JKU99gll1VW0FxeAz6t7dmvsSuSCUc4FYgsb3E14K52pEIjaSu6zMah1gD8pEq2/69Y45lYz9fhEfPgAvvQQvv2z5j8sus5pRqojU1sQqKmwZ2pwc6xGWn+/BwyVWk0FDVe9PRkGcC4hYF9S8PPj6a2uOyctLzOp4gWD69S4XTwYRNDvChpum8aOJhRx/Dtx6K0yfbmM9Zs2yNcsvusge1KmUk2Ovykr46iv7jLp3t1xIsmpprn1J+tTozsUqKwt697Zv9VVVie+eW9/062A9vK691npanXii9WK6914YORJuvDE9xlREIhZos7OthrZwoQXcOpUn51rNg4ZLe/n51sMq6J6byLmj6pt+PTBwoK3dMXs2HHmkleO22yx4/PGPNjljqgXddfPyalcTXLEi+QMpXdvlQcNlhKB7blGRfaveuDF14xZ2281qGrNm2TTsGzbATTfZf991V+omRIwW9Ljq0MGC2aJFlvvYvDl1c265tsGDhssowbTr/fpZO34qH4LDhsEjj8CMGTB0qA3Au/pqWwDqvvvS49t9kDTv2NGa+L76qnaaEh9p7lrCg4bLOEGivKjIuulu2pT8EeXRDj4YnnrKAsWee1pz0C9+Ubt6YH2D8bqPH0WPo4YSWpW8kec5ObWz6wZ5jzVrfLCgax4PGi5jhcPWe6moyB6Emzal7tuzCIwZA889B3ffbYtBLVtmYzsOOgj++tfah3PezOlE5r9N9icf0mvkEPJmTk9qWYPZdYOR5gsX2gJVW7Z405VrmgcNl/FycmDAABvfUVGR2iYrEVtidvZsm8vqO9+xB/Lll1vweOyOFXS+fApSXY1UVRHaWk7ny6cktcYRCPIenTrZ5/bll7XrmXvTlWuIBw3XJkQ3WXXtmvheVk0JhWD8eHjxRbjjDviv/7Lg8bfflFJWUWfASXbERqSnUG7ujgtDLVxoI/PTIS/j0osHDdemhMPWNbeoyGogmzaldqxCOAzHHWcjyu+4A8I7FZGldQq0rdJGpKeBoOkqP9+S5d7rytXlQcO1SUEvq/79awcGpnJFvCB4zCgp5K3vT2MruaynM1vI4/zwNG57pJBNm5q+TrIE81xF97pauNDGfviAwfbNg4Zr0zp0sIGBPXtaojfVyd5QCHa9bhLsN5T5A8czfo+F3Ll5EtdfDyNGwO9+B2vXpq589Ql6XUUi1ttq4UJL8qf6s3SpEesst85lrFDI8hwdO9rUGuvX23QbubmpK9Pap95gF+B+telJbr0V3n4bbrnF1jM/4wwoLk6vec/DYQvCYF2clyyxQBJ8tln+NGkXvKbh2o1gLqvBgy1obNyY+qYWETj0UHjsMXsddpgl8O++G846awSXXgqff57aMtYnN9d6XWVnW8L8iy+s9lFe7rWPts6Dhmt3gi66AwZYe30qx3dEGzHCZtJ9/nkYNw6qq4UZM6C4GH78Y3jvvVSX8NuCua4KCmprH6WlnvtoyzxouHarQwfrZVVYmPrxHdH23BPuvBPuuecdTj/dvs0/84wFkokTrRtvKpP69RGp7babne25j7bMg4Zr10Sgc+cdx3eky0OuX79yfvtbeOstuOACeyC/+SacdRYcfjg89FB6jqMIch8dO1rt48sva6dq9ylLMp8HDeeoHd8xZIg97FI9ODBa7942Hcm778KvfmU1o//8By65BA480KZlX7cu1aWsX1D7yMmxXmGlpdaElS5Ngq75PGg4FyU7uzZZnptryfJ0+TbfsSOcc47VNm691aZoX7XKpmXff3+bJHHhwlSXsn6hUG3to7ramq0WLrTR5548zyweNJyrR06OTb8+aJA98NKhp1UgErHcxuzZ8OCDligvL7dZdg85BCZPhtdfh27jkj+TbiyCVQbz8y2PFJ089+ar9OdBw7lG5OXZin0DBtg35E2bUrf4U10iFiT+9jebpuS00+yBPHs2zDp5Orw3H/34k5TMpBuL6LU+srMt5xE0X/mkiekrJUFDRM4TkVIR2Soi80Tk4BjPO0hEvhGRjxJdRucCIrUjy/v2taCRbm3yu+4Kv/89vPMOXDllBXcxhVy2kqMVhLaW0+HSKaz5KL1qHNHC4dppS6qrrdnqiy/sZ7p0THAm6UFDRE4BbgWuB4YCbwDPisjAJs7rCjwAvJTwQjpXj2Am3cGDoU8fa0opK0uv4NGjB5x/dCmRjjvOpLvlmwjnH13K+efD3Lnp/RCORGzcR4cOFjC+/NIGOK5ZY72x0rns7UEqahqXAPep6t2q+omq/g+wHDi3ifPuAe4H3kx0AZ1rTChko6GLiqBXL0uUp3pCxGhVA4uQOgmYvFAlX1QX8cQTNnHi0UfDww+ndsXDpkSP/QgWjFq82PMfqSaaxLAtIhFgC3Caqj4Stf12YE9VPbSB884DTgcOAX4FTFTVPRs49mzgbIDevXsPmzFjRr1lKSsro6CgoBXvxtXVnj/TqqraXEcoTl/Ftm4tIze3ZZ9n4ewX2PP3N6IiaFY2/7roEt7fexz/+Ec/nnmmD5s2WU2kU6dtjB27nGOOWUZhYRpHkDqCAC1iTVvhcGzntee/0eYYPXr0PFUdXt++ZAeNvsBS4FBVfTVq+6+B01V1l3rO2Qt4EThQVUtF5CoaCRrRhg8frnPnzq13X0lJCcXFxS16H65+7f0zraqyNSi+/tqaUPLzWxdAPv64hD32KG7x+aFVKwgvKaVqYBHVvQq3by8vh1mz4N574cMPbZuIDRg880zrjRXrQ7j7+FFIRTlrpz+7wz2SZds2q+mpWm2ka1f73Bsqf3v/G42ViDQYNNK695SI5AAPAZepamqXNnOuCeEwdOtmAwR79LCHcyqbrap7FbJt+MhvPczz8uCUU+DZZy14nHCC9V568UULGgcdBFOnWg6hMale6xys3AUFtQn05cst/7F0afrlm9qKZAeNNUAV0LvO9t5AfV07+gC7AffW9Jr6Bvg1sEfN70cmtLTOtUB08OjZM/XBoyEiMGwY3HabJcd//nPrWrxkCdxwAwwfDuedB2+88e3kc2hV+qx1HggS6B07Wr5j6dLa2Xc3b/YAEi9JDRqqWgnMA8bU2TUG60VV11JgL2DfqNedwOc1/13fOc6lhXDYmkuC4LF1a/p+++3eHc4/3wYFTp8ORx5p5XzySTjpJJu+fdq02gWiwktK7Wt+tDRY6zwQLBzVoYN97l99ZQFk2zYLIOkWwDNJKpZNuRmYLiLvAK8D5wB9sWCAiDwAoKpnquo2YIcxGSKyCqhQVR+r4TJCEDw6dbLxHWvW2EMrLy/23EGyhMO2psdhh9k39QcftNcXX8A118CNN8LYsfCDY4o4tu4Q+TRa6zwQ9MDKzbXakqoFkGBak86dbV+6/Tuks6TnNFT1IeAnwC+BBcBBwNGqurjmkIE1L+falHAYunSxmkfv3taEkk4jzOvq1w8uu8xWFLznHgsk27ZZ7eO4swu5tMM0tkk2VaEsqnPz2HDTtJQkw2MlUjvWJj9/xxrIsmXpWwtMNylZoFFV7wDuaGBfcRPnXgVcFfdCOZckoZB9w+3Y0ZpKVq+2vEdOjrXLp5usLPje9+y1dCnMmGG1j1uWT+JBxrCzfk6/A3bmex0LOWzbt1ut0lHdGsjWrRbARSygdOli+3wJ22/zj8S5FAmFLHAUFNjI59Wr7cEViVgASUf9+sGll8JPfgKvvAIPPljICy8U8s2r8PCrlrs58UTrnfWd76S6tLGJDiBgXXiXLbP/zs21AJKXlxnBMBk8aDiXYsHcVkGTyddfW/CorrZvwSKpLuG3Rec+Vq+GRx+1Gshnn9mqg3feCUOHwsknw/jx9uDNFDk5tUG7stLmv1K1bZ07279TJJKe/y7JkNbjNJxrT4JZX/v3tynZw+H0WkmwIT172jofc+bYuI/TT7ca1Pz5tnjUfvvZ/pdeSt/8TUOiu/GGQtaJYdEim8pkzZr2uRaI1zScS0NBe/qQITbKPOjqmo49rgLBuI9hw+Dqq23w4MMPw2uvwVNP2atnT5gwwdYD2WOPVJe4ebKyanMcVVU2F9bXX9c2M3bs2D56YnnQcC6NZWfb6PKuXW2NibVr7dt6bm56t7Hn5dlI8xNOsOT5o4/CI4/Yan133WWv3Xaz4HH88baEbSYJpnIHq2ls3mzBPUikd+pk/0bp2LGhtbx5yrkMEIz1KCqyNT1ULe+RzrPUBvr1gwsvhFdftdrGmWdajuOTT+Daa22p2lNPtVpJWVn91+g+sZjuE4uTWeyYRS8mVVBgQX3FCmvCWrjQAn1bmtLdg4ZzGSRoChk0yFYUzMmx4JHueQ+wh+t++9kUJfPn29iPo4+2Jp9//hMuvhj22cfyH88/X2fq88pKZNOGtFu6tj7ReZCsLAsaixfbnFjLl1tgzLTcTjRvnnIuAwXfbvv1s4dr0HQFmTG+IBKpHfuxfj08/TQ89hi89VZt/qNLFwsqF3adTp/5b4MIvUYOYcNN0yifOCnVbyEm0XkQVUucb9xo/345OdaMlWm9sdL8T8s515RIpDbvUVZmydny8vQe7xGtSxfrcXX66Zb/eOIJePxxa7566e8ruJspCDZZlFTZxIgVh4xJ69Hn9ak7HmTbttopZcLh2tpJTk56B31vnnKujQiHbRxBUZHNVpudXdt0lSkT9PXrZxMnvvgivPwyXH5SKd/Ijhn/sooI068p5YMP0r9JrjHZ2TY+J+h1tXmzTWuycKF16123Lj1zIWkcz5xzLRH04MnPr226WrfOHj6Z0HQV2GUX2O3nRRQ8tQ2iEv5ZWskfHi9i5eO2Xvuxx8K4cdaFN1OaeOoKhay5MfDNN7W1kGByxaAWkuoeWV7TcK4NC5quhgyxbq1VVVb7yJRBadW9Ctlw0zQ0FELDYapz8/j4wmmMnVxIz572jXzqVDjqKFs86oYbbDXCTHhvjcnKqg0U+fk2tcny5bU9slavthpkKiZYzJDvHM651giHLenasaM9gNavrx1XkM4DBgHKJ06i4pAx25eu7derkN9gU7W//bYlzZ95pjaATJ1qvcvGjrVE+tCh8Vu3PRWCpHmQn6qq+nbHh2BcSE5O4t+rBw3n2pEgGVtYaDWQzZstcb5li7Wx5+SkZxNPda/CbyW+w2EYNcpe111nAeTppy2ALF5cOwdWnz4WQMaOhYKCNHxzzRQO79iUFZ1QD5omO3a0YxLRlOVBw7l2KivLEuedOlnCdd262unBMyn3ATsGkGuuseVrgwCyfDn85S/26tx5JGPHWlffgw+u7cmUybKza2cHULUgsnKlBYzBg+N/vwz6s3DOJULQRJWXZwnYoPZRXm6BIzc3PWsfDQmHYcQIe111FSxYAM89Z0Fk0aIIM2bYjLwdOsDo0ZYPOeywzJqJtyEiFiyysuoMjowjDxrOue3q1j42bLD2c7Cmq3Se76o+oZCNQt9vP5tx9+mn3+Wzz/bnuefgo4/gH/+wV1YWjMt9npMKnmPXv1xO730yawxIMnnQcM59S3Tto2dPq32sXWvNV+Gw1T4yLbksAkVFmzn2WJuy5KuvbLqS556Dnd+czp/KplBZlk3k6Glc3WcaFSdPYswYm9ok095rInnQcM41Kuh51amT9bzatMnyH9XVmTPqvD79+8MPfwg/HreCXgdOIVRRTj7lAFy5fApDbh3DrbcW0qsXHH44jBljeZBgdtv2yoOGcy5mQdfPbt0s57F+fe3MtJmWPA+El5RCJBsqyrdvy8qLcMHoUv60oJBly2xN9AcftPc+cqQFkcMPt6697U0G/hM751ItGKXcoUNt8nztWgskmdZ8VTWwyLocRcnSSn70myK+39PmwJo9214LFkBJib1+9SvYeWdLoo8ebYn3TK11NYcHDedcqwTJ886da5uvNmywYJIJva+CUeddLp4MImh2hA03TaO6VyEC7L67vS66yMZDvPyyLV376qs23fnnn9uiUvn5Nip99Gh7DRhQ//26jx+FVJSzdvqzGTfpInjQcM7FUdB81b17be+rTZts/EAweDAdlU+cRP4Df2ryYd6jB5x8sr22bYN58yyAzJljNZIXXrAXWC2kuNheBx5Y07Fg5nQiGTrNe8CDhnMu7ur2vqo7eDAdu+9+PeuNZh2fnW3B4MAD4Re/gGXLLHiUlNiiUkEt5M9/ttrW2KEreOjdKUh1Zk/z7kHDOZdQ4fCO+Y8tW2oT6EEAycQEel19+9auCxLUQoL8x4cfwvI3S9lMNl2oTbhvI8LG90spGONBwznnviUrq7b77rZtFkCCGkgo1HYCSHQt5Gc/s1zI3H8UkffrbRA1M23V1koOmVxEt90sH3LIIZZQ79AhdWVvShv453HOZaLs7NoEemWl9cBat856YLWlAAKWC/ne5EK2FEwjcvFkqgijoSxu2XkaGxYVsvITy4ncfbe95/32szEhBx0E++6b+jU0orWRfxLnXCaLROzVtav1wApqIG0tgNSd5n1yr0JOq7AJFv/5T3jtNXj/fXjnHXv94Q+WFxoxAr77XXvtuWdqp7JvA/8Mzrm2JOiB1VYDSN1p3nNyagMCWI+zt96yIPL66/Cf/9TmRsCa9kaMqJ3Vd/fdkzsmJoM/eudcWxcdQIImrPXrawNIJJJ+vbBaq3Nnm3n3qKPs91WrLHi88Ya9Fi2qHWwYHD9ihOVPRo60ZW97HT8KtpbDS8/a4ilx5EHDOZcRopuwKistcER34w32tzW9esGECfYCWLrUgsebb9rPL7/ccXzIj3KmM7XiPVQEHTIEmTYNJsVvLIgHDedcxgkCROfO1gurvNymcN+0yfan8yqErdWvH5x0kr3AZut98017ffH6Cm79ago5VIAC5cCUKTbbYpxqHCmZHUZEzhORUhHZKiLzROTgRo49QUReEJHVIrJJRN4WkfHJLK9zLn1lZ1s7f//+Ngq7f38bTLd5swWR8nKbkbet6t/fAsjNN8Mzt5cS6VCnvS4SgdLSuN0v6UFDRE4BbgWuB4YCbwDPisjABk45FHgZOKbm+GeAxxsLNM659ikYSNi3rwWQAQNsveytWy2AVFfbAMO2qmpgEaGqHSdfpLISiorido9U1DQuAe5T1btV9RNV/R9gOXBufQer6kWqeqOqvqOqn6vq1cA84PjkFdk5l2lCIZtEsFcv2GknWy87K8sCx6ZNNiK9osLmxWorgskXNRRCw2HrrzttWlyT4UnNaYhIBBgG/L7OrheAUc24VEdgXbzK5Zxr24LpSsJhCx7btlntY+NGa8ZStYASiaR2DEQ8lE+cRPlBY9CFpfQ7qCjuvadEkxhmRaQvsBQ4VFVfjdr+a+B0Vd0lhmucD9wI7Kmqi+vZfzZwNkDv3r2HzZgxo97rlJWVUVBQ0KL34ernn2l8+ecZfw19pqpQVWW1kOCRKJLZiXTVlvcmGz169DxVHV7fvozqPSUiJwK/A06pL2AAqOpdwF0Aw4cP1+Li4nqvVVJSQkP7XMv4Zxpf/nnGXyyfaWVlbS1ky5bMrIVUV9v7GDIk/tdOdtBYg03X1bvO9t7AisZOFJGJwAPAmar6VGKK55xr74LuvJ062cN361YLHkEQiT4mk2siLZXUoKGqlSIyDxgDPBK1awzwaEPnicjJwP3AWao6M7GldM45EyTT8/Nt0sEgF7JpU20uJBhY2NZGpjckFc1TNwPTReQd4HXgHKAvcCeAiDwAoKpn1vx+KjAduAx4VUSCrE6lqq5Nctmdc+1Ydra9Ona0gFFRYeNAgt5YmdiU1VxJDxqq+pCIdAd+CfQBPgKOjspR1B2vcQ5WzltqXoFXgOJEltU55xoiYoMIc3NtapOqqtoJFqObsrKyrOdWMicVTKSUJMJV9Q7gjgb2FTf2u3POpaNw+NtNWRUV1oxVVmZBJVgrPRLJ3CCSUb2nnHMuUwRNWQUF0Lu39WaqrLQAEgQRkdrmrEwJIh40nHMuCYIeVwUFVuMIaiJlZVYbyZQg4kHDOeeSLHoq9yCpXjeIBJMshsPplRPxoOGccynWUBAJFp7avLl2osVw2Jq9UrV6oQcN55xLM9FBJJj1JAgiW7ZYbaS83LaHQrX5k2QMNvSg4ZxzGSAIDB06QM+elgMJpjwJmrSCwYbhcOICiAcN55zLQMHM53l5Nk5E1YJI0M03UTkQDxrOOdcGBNO/5+TYvFmJkib5eOecc5nAg4ZzzrmYedBwzjkXMw8azjnnYuZBwznnXMw8aDjnnIuZBw3nnHMx86DhnHMuZqKqqS5DwojIamBxA7t7AGuSWJz2wD/T+PLPM/78M43NIFXtWd+ONh00GiMic1V1eKrL0Zb4Zxpf/nnGn3+mrefNU84552LmQcM551zM2nPQuCvVBWiD/DONL/88488/01ZqtzkN55xzzdeeaxrOOeeayYOGc865mHnQcM45F7N2GTRE5DwRKRWRrSIyT0QOTnWZMpWIHCIis0RkqYioiExOdZkymYhcISLvishGEVktIk+JyJ6pLlemEpHzReSDms9zo4i8KSLHpLpcmazdBQ0ROQW4FbgeGAq8ATwrIgNTWrDMVQB8BFwElKe4LG1BMXAHMAo4DPgGeFFEuqWyUBnsK+ByYD9gOPAy8ISI7J3SUmWwdtd7SkTeBj5Q1R9HbfsMmKmqV6SuZJlPRMqAC1T1vlSXpa0QkQJgA3C8qj6V6vK0BSKyFrhCVaeluiyZqF3VNEQkAgwDXqiz6wXsm51z6aYj9v/pulQXJNOJSFhETsVqx2+kujyZKivVBUiyHkAYWFln+0rgiOQXx7km3QosAN5McTkylojshX1+uUAZMEFVP0xtqTJXewsazmUMEbkZOAg4SFWrUl2eDPZvYF+gMzARuF9EilX1o5SWKkO1t6CxBqgCetfZ3htYkfziOFc/Efk/4FRgtKouTHV5MpmqVgKf1/w6T0T2By4Gfpi6UmWudpXTqPnjmQeMqbNrDN7G6dKEiNwKnAYcpqqfpro8bVAIyEl1ITJVe6tpANwMTBeRd4DXgXOAvsCdKS1Vhqrp3bNzza8hYKCI7AusVdUlKStYhhKR24FJwPHAOhEprNlVpqplKStYhhKRG4GngS+xTgX/jXVr9rEaLdTuutyCDe4Dfgr0wcYYXKyqr6a2VJlJRIqBOfXsul9VJye1MG2AiDT0P+TVqnpVMsvSFojIfcBooBDruvwB8DtVfT6V5cpk7TJoOOeca5l2ldNwzjnXOh40nHPOxcyDhnPOuZh50HDOORczDxrOOedi5kHDOecyhIj8RURWiUhcpkARkSoRWVDzmhXLOR40XLsiIpNrFosKXptFZJGIPC4iJ4uItPC6xTXXK45viWO69wkislJE8ptxzhMickciy+US4j7ge3G8Xrmq7lvzGh/LCR40XHt1EjASOBr4FVABPAjMFpG8VBasOUQkC7gBG7C2pRmnXg38WES+k5iSuUSoGYS8NnqbiOwkIs/VrEL6TxHZNZFl8KDh2qsFqvqWqr6iqtNV9VTgZGy1vN+muGzNcRwwGPhLc05S1fnAfOAn8S+SS7K7gP9R1WHAZdjKj7HKFZG5IvKWiBwfywkeNJyroaqPAk9i38C3N/WISL6I3FSzrnxlzc9fiEij//+IyJEi8oyILBeRLSLykYhcKiLhqGOeEpH59ZxbJCLVInJOE8X+EfCcqtb99nmRiHwiIuUisq7mwTChzrkzgNMzqWbldlQz99so4BERWQBMw6ZHCpotP6rnFT2FyiBVHY7NyXWLiOzU1D3b44SFzjXmGWyywOHAqzXNP88DuwPXAh8CB2JNWt2ASxu51hDgJeA2YGvNNa8CegI/qznmT8DTInKAqr4Tde7ZwGbgbw1dXERysMn3flVn++nAH4BrgH8CecDeNeWN9irQCWume7mR9+HSVwhYr6r71t2hqo8BjzV2sqourfm5UERKgKHAF42d40HDuR0FM/P2qfl5GrYQ0qFRk1q+VJMvv1JEblLVVfVdSFW3z5xck2D/JxABLhORn6tqNfAcsBCYArxTc2w28H3gb6q6qZGy7outRvd+ne0jgQ9U9Zqobc/Uc/77QDUWBD1oZCBV3VhT8z1JVR+p+TvbW1Xr/k18i4h0BbaoaoWI9AC+SwxNs9485dyOgt5TwUye3wMWA2+ISFbwwtaVz8YeuPVfSKSPiEwTkcVAJbANuA7oAvQCqAkc04BTRaRzzanHYwuDTWuirH1rfq6us/1dYF8RuU1EjmioV5WqbsNmfu1b336XfkTkQWzp2l1E5CsR+SFwOvBDEXkf+BjLc8ViN2BuzXlzgBtV9V9NneQ1Ded2NKDm5/Kan72AQdgDvz7d69tYk++YhT2QrwI+BcqxgPALrIYQuAdrSpoETMXWeHmnJlndmOAaFXW2P1Cz74fAecA2EXkGuERVF9U5thxrvnIZQFVPa2BXs7vhquobwF7NPc+DhnM7OgbLP8yr+f1roBTrWVWfRQ1s3wnLYUxS1b8GG0VkXN0DVfVrEXkYmFKTpByNJbib8nXNz651rqdYLWVaTRPEkViO4yFgRJ1rdMOWQXYuJh40nKshIicC44Fbo8Y8PAeciK2c15ylV4Mmoe01lJpcxekNHH8H1uzwZ6zJaEYM9wjKM4QGlitW1XXAQyIyAsubbFezKmAu8O8Y7uUc4EHDtV/71iT/IsBA4FhswN9s4Iqo4/6GJaVfEpE/YMnjCFaTGA8c38Cguk+wXMhvRKQKCx4XN1QYVX2rpuvtIcBtsQzUU9UlNfmSA4Do2sxdwCYsCK0CvoM1fb1Q5xJBrcNXrXQx86Dh2qtHan5uxR6s7wGnAjM1ajlLVd0mIkdhXWTPBoqwrrBfYGtPV9Z3cVWtrBksNRXLMazFBuAtAe5upExDaToBHu0hLNhdGLXtdSzQTQI6A8uwoHJlnXOPBeap6ufNuJ9r53y5V+fShIi8DlSr6sHNOGcnrHmpWFVfa8Z5uViy/zJVvafZhXXtltc0nEuhmgF6+wFHYCN7Y+0uCYCqfiEi92I1oWObceoUrIZ1f3Pu55wHDedSqw+WxF4PXK+qMU1PXcevsJ5X+c2YtLACmKyq37Tgfq4d8+Yp55xzMfMR4c4552LmQcM551zMPGg455yLmQcN55xzMfOg4ZxzLmb/D3UixXCAVPwqAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 576x360 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -208,12 +206,20 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      "DbAnalysisResultV1\n",
+      "- name: @Parameters_T1Analysis\n",
+      "- value: [ 1.02069125e+00 -2.05444310e-02  2.57220669e-05] ± [4.04834182e-02 4.34792182e-02 2.03208585e-06]\n",
+      "- χ²: 1.0169078141303014\n",
+      "- quality: good\n",
+      "- extra: <6 items>\n",
+      "- device_components: ['Q0']\n",
+      "- verified: False\n",
       "DbAnalysisResultV1\n",
       "- name: T1\n",
-      "- value: 2.572206565733485e-05 ± 2.032089265168276e-06 s\n",
-      "- χ²: 1.0169078141302248\n",
+      "- value: 2.5722066915986907e-05 ± 2.0320858539312554e-06 s\n",
+      "- χ²: 1.0169078141303014\n",
       "- quality: good\n",
-      "- extra: <9 items>\n",
+      "- extra: <2 items>\n",
       "- device_components: ['Q0']\n",
       "- verified: False\n",
       "Component experiment 1\n"
@@ -221,9 +227,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": {},
@@ -233,12 +239,20 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      "DbAnalysisResultV1\n",
+      "- name: @Parameters_T1Analysis\n",
+      "- value: [ 1.03209563e+00 -3.59964792e-02  2.66409064e-05] ± [4.33114482e-02 4.62732486e-02 2.17003133e-06]\n",
+      "- χ²: 0.4158430197604509\n",
+      "- quality: good\n",
+      "- extra: <6 items>\n",
+      "- device_components: ['Q1']\n",
+      "- verified: False\n",
       "DbAnalysisResultV1\n",
       "- name: T1\n",
-      "- value: 2.6640906531746692e-05 ± 2.170039108417077e-06 s\n",
-      "- χ²: 0.4158430197604502\n",
+      "- value: 2.6640906423457507e-05 ± 2.170031331762244e-06 s\n",
+      "- χ²: 0.4158430197604509\n",
       "- quality: good\n",
-      "- extra: <9 items>\n",
+      "- extra: <2 items>\n",
       "- device_components: ['Q1']\n",
       "- verified: False\n"
      ]
@@ -276,6 +290,13 @@
     "import qiskit.tools.jupyter\n",
     "%qiskit_copyright"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -297,7 +318,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.5"
+   "version": "3.8.11"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorials/t2ramsey_characterization.ipynb b/docs/tutorials/t2ramsey_characterization.ipynb
index 77c309d9ed..1c104ef36d 100644
--- a/docs/tutorials/t2ramsey_characterization.ipynb
+++ b/docs/tutorials/t2ramsey_characterization.ipynb
@@ -69,11 +69,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "     ┌───┐┌──────────────┐┌─────────────┐ ░ ┌───┐ ░ ┌─┐\n",
-      "q_0: ┤ H ├┤ Delay(1[us]) ├┤ Rz(200000π) ├─░─┤ H ├─░─┤M├\n",
-      "     └───┘└──────────────┘└─────────────┘ ░ └───┘ ░ └╥┘\n",
-      "c: 1/════════════════════════════════════════════════╩═\n",
-      "                                                     0 \n"
+      "     ┌───┐┌─────────────────┐┌─────────┐ ░ ┌───┐ ░ ┌─┐\n",
+      "  q: ┤ H ├┤ Delay(1e-06[s]) ├┤ Rz(π/5) ├─░─┤ H ├─░─┤M├\n",
+      "     └───┘└─────────────────┘└─────────┘ ░ └───┘ ░ └╥┘\n",
+      "c: 1/═══════════════════════════════════════════════╩═\n",
+      "                                                    0 \n"
      ]
     }
    ],
@@ -131,14 +131,14 @@
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {
-    "scrolled": true
+    "scrolled": false
    },
    "outputs": [
     {
      "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": {},
@@ -146,7 +146,6 @@
     }
    ],
    "source": [
-    "exp1.set_analysis_options(user_p0=None, plot=True)\n",
     "expdata1 = exp1.run(backend=backend, shots=2000)\n",
     "expdata1.block_for_results()  # Wait for job/analysis to finish.\n",
     "\n",
@@ -164,19 +163,29 @@
      "output_type": "stream",
      "text": [
       "DbAnalysisResultV1\n",
-      "- name: T2star\n",
-      "- value: 2.027231210602027e-05 ± 4.4583366998900174e-07 s\n",
-      "- χ²: 0.9281938934057216\n",
+      "- name: @Parameters_T2RamseyAnalysis\n",
+      "- value: [ 4.76853786e-01  5.00930094e-01  2.02722755e-05  1.00413939e+05\n",
+      " -2.33402035e-02] ± [6.26767628e-03 1.53844445e-03 4.45832655e-07 1.79698987e+02\n",
+      " 1.45956076e-02]\n",
+      "- χ²: 0.9281938922841412\n",
       "- quality: good\n",
-      "- extra: <10 items>\n",
+      "- extra: <7 items>\n",
       "- device_components: ['Q0']\n",
       "- verified: False\n",
       "DbAnalysisResultV1\n",
       "- name: Frequency\n",
-      "- value: 100413.93591315173 ± 179.69873497369704 Hz\n",
-      "- χ²: 0.9281938934057216\n",
+      "- value: 100413.93918880865 ± 179.69898684575085 Hz\n",
+      "- χ²: 0.9281938922841412\n",
+      "- quality: good\n",
+      "- extra: <3 items>\n",
+      "- device_components: ['Q0']\n",
+      "- verified: False\n",
+      "DbAnalysisResultV1\n",
+      "- name: T2star\n",
+      "- value: 2.027227548100963e-05 ± 4.4583265477701647e-07 s\n",
+      "- χ²: 0.9281938922841412\n",
       "- quality: good\n",
-      "- extra: <10 items>\n",
+      "- extra: <3 items>\n",
       "- device_components: ['Q0']\n",
       "- verified: False\n"
      ]
@@ -203,27 +212,7 @@
     {
      "data": {
       "text/plain": [
-       "{'popt': array([ 4.76853421e-01,  2.02723121e-05,  1.00413936e+05, -2.33401107e-02,\n",
-       "         5.00930099e-01]),\n",
-       " 'popt_keys': None,\n",
-       " 'popt_err': array([6.26767132e-03, 4.45833670e-07, 1.79698735e+02, 1.45956068e-02,\n",
-       "        1.53844443e-03]),\n",
-       " 'pcov': array([[ 3.92837038e-05, -2.05184246e-09, -1.92069788e-01,\n",
-       "          2.19746381e-05,  6.57706755e-07],\n",
-       "        [-2.05184246e-09,  1.98767661e-13,  9.05968377e-06,\n",
-       "         -1.07460873e-09, -1.68817850e-11],\n",
-       "        [-1.92069788e-01,  9.05968377e-06,  3.22916354e+04,\n",
-       "         -1.92846313e+00, -4.81464977e-02],\n",
-       "        [ 2.19746381e-05, -1.07460873e-09, -1.92846313e+00,\n",
-       "          2.13031739e-04,  4.85062481e-06],\n",
-       "        [ 6.57706755e-07, -1.68817850e-11, -4.81464977e-02,\n",
-       "          4.85062481e-06,  2.36681126e-06]]),\n",
-       " 'reduced_chisq': 0.9281938934057216,\n",
-       " 'dof': 44,\n",
-       " 'x_range': (1e-06, 4.9e-05),\n",
-       " 'y_range': (0.1225, 0.873),\n",
-       " 'circuit_unit': 'us',\n",
-       " 'osc_freq': 100000.0}"
+       "{'osc_freq': 100000.0, 'conversion_factor': 1e-06, 'unit': 'us'}"
       ]
      },
      "execution_count": 7,
@@ -250,9 +239,9 @@
    "outputs": [
     {
      "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": {},
@@ -269,7 +258,7 @@
     "    \"B\": 0.5\n",
     "        }\n",
     "exp_with_p0 = T2Ramsey(qubit, delays, unit=unit, osc_freq=1e5)\n",
-    "exp_with_p0.set_analysis_options(user_p0=user_p0, plot=True)\n",
+    "exp_with_p0.set_analysis_options(p0=user_p0)\n",
     "expdata_with_p0 = exp_with_p0.run(backend=backend, shots=2000)\n",
     "expdata_with_p0.block_for_results()\n",
     "\n",
@@ -287,19 +276,29 @@
      "output_type": "stream",
      "text": [
       "DbAnalysisResultV1\n",
-      "- name: T2star\n",
-      "- value: 2.030276656575635e-05 ± 4.4934671946258713e-07 s\n",
-      "- χ²: 1.1491113848575452\n",
+      "- name: @Parameters_T2RamseyAnalysis\n",
+      "- value: [ 4.76064607e-01  4.98829631e-01  2.03027695e-05  1.00060414e+05\n",
+      " -5.01475102e-03] ± [6.33491797e-03 1.53907121e-03 4.49346803e-07 1.79106191e+02\n",
+      " 1.45280767e-02]\n",
+      "- χ²: 1.149111384943867\n",
       "- quality: good\n",
-      "- extra: <10 items>\n",
+      "- extra: <7 items>\n",
       "- device_components: ['Q0']\n",
       "- verified: False\n",
       "DbAnalysisResultV1\n",
       "- name: Frequency\n",
-      "- value: 100060.41427484511 ± 179.10621179292593 Hz\n",
-      "- χ²: 1.1491113848575452\n",
+      "- value: 100060.4136174409 ± 179.10619067981733 Hz\n",
+      "- χ²: 1.149111384943867\n",
+      "- quality: good\n",
+      "- extra: <3 items>\n",
+      "- device_components: ['Q0']\n",
+      "- verified: False\n",
+      "DbAnalysisResultV1\n",
+      "- name: T2star\n",
+      "- value: 2.0302769508297885e-05 ± 4.493468025219883e-07 s\n",
+      "- χ²: 1.149111384943867\n",
       "- quality: good\n",
-      "- extra: <10 items>\n",
+      "- extra: <3 items>\n",
       "- device_components: ['Q0']\n",
       "- verified: False\n"
      ]
@@ -349,9 +348,9 @@
    "outputs": [
     {
      "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": {},
@@ -380,8 +379,8 @@
     "    \"f\": 110000,\n",
     "    \"phi\": 0,\n",
     "    \"B\": 0.5\n",
-    "        }\n",
-    "exp_in_ns.set_analysis_options(user_p0=user_p0_ns, plot=True)\n",
+    "}\n",
+    "exp_in_ns.set_analysis_options(p0=user_p0_ns)\n",
     "\n",
     "# Run experiment\n",
     "expdata_in_ns = exp_in_ns.run(backend=backend_in_ns, shots=2000).block_for_results()\n",
@@ -400,19 +399,29 @@
      "output_type": "stream",
      "text": [
       "DbAnalysisResultV1\n",
-      "- name: T2star\n",
-      "- value: 2.0278449809859954e-05 ± 4.461688131357524e-07 s\n",
-      "- χ²: 0.9253828449213184\n",
+      "- name: @Parameters_T2RamseyAnalysis\n",
+      "- value: [ 4.76712979e-01  5.00813496e-01  2.02784645e-05  1.00324830e+05\n",
+      " -2.43792156e-02] ± [6.26740350e-03 1.53845079e-03 4.46169219e-07 1.79670346e+02\n",
+      " 1.46040880e-02]\n",
+      "- χ²: 0.9253828453697149\n",
       "- quality: good\n",
-      "- extra: <10 items>\n",
+      "- extra: <7 items>\n",
       "- device_components: ['Q0']\n",
       "- verified: False\n",
       "DbAnalysisResultV1\n",
       "- name: Frequency\n",
-      "- value: 100324.82884946911 ± 179.67044058275803 Hz\n",
-      "- χ²: 0.9253828449213184\n",
+      "- value: 100324.83020509838 ± 179.6703463847266 Hz\n",
+      "- χ²: 0.9253828453697149\n",
       "- quality: good\n",
-      "- extra: <10 items>\n",
+      "- extra: <3 items>\n",
+      "- device_components: ['Q0']\n",
+      "- verified: False\n",
+      "DbAnalysisResultV1\n",
+      "- name: T2star\n",
+      "- value: 2.027846450681849e-05 ± 4.4616921869278804e-07 s\n",
+      "- χ²: 0.9253828453697149\n",
+      "- quality: good\n",
+      "- extra: <3 items>\n",
       "- device_components: ['Q0']\n",
       "- verified: False\n"
      ]
@@ -446,6 +455,13 @@
     "import qiskit.tools.jupyter\n",
     "%qiskit_copyright"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -464,7 +480,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.10"
+   "version": "3.8.11"
   }
  },
  "nbformat": 4,

From adda4d2b7a420674231f0a7f7b37b960061df5de Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 15 Oct 2021 04:48:22 +0900
Subject: [PATCH 06/14] bug fix

---
 qiskit_experiments/library/characterization/t1_analysis.py     | 3 ++-
 qiskit_experiments/library/characterization/t2ramsey.py        | 2 +-
 .../library/characterization/t2ramsey_analysis.py              | 3 ++-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/qiskit_experiments/library/characterization/t1_analysis.py b/qiskit_experiments/library/characterization/t1_analysis.py
index 301f2bdc85..dc5ffc990b 100644
--- a/qiskit_experiments/library/characterization/t1_analysis.py
+++ b/qiskit_experiments/library/characterization/t1_analysis.py
@@ -46,6 +46,7 @@ def _generate_fit_guesses(
         extra = self._get_option("extra")
 
         conversion_factor = extra.get("conversion_factor", 1)
-        user_opt.p0["tau"] *= conversion_factor
+        if user_opt.p0["tau"] is not None:
+            user_opt.p0["tau"] *= conversion_factor
 
         return super()._generate_fit_guesses(user_opt)
diff --git a/qiskit_experiments/library/characterization/t2ramsey.py b/qiskit_experiments/library/characterization/t2ramsey.py
index 1580551094..4c0b437e86 100644
--- a/qiskit_experiments/library/characterization/t2ramsey.py
+++ b/qiskit_experiments/library/characterization/t2ramsey.py
@@ -118,7 +118,7 @@ def set_experiment_options(self, **fields):
         if "osc_freq" in fields:
             user_p0 = self.analysis_options.p0
             if user_p0.get("freq", None) is None:
-                user_p0["freq"] = fields["freq"]
+                user_p0["freq"] = fields["osc_freq"]
 
             self.set_analysis_options(p0=user_p0)
 
diff --git a/qiskit_experiments/library/characterization/t2ramsey_analysis.py b/qiskit_experiments/library/characterization/t2ramsey_analysis.py
index 049e24e497..fa4ffb5667 100644
--- a/qiskit_experiments/library/characterization/t2ramsey_analysis.py
+++ b/qiskit_experiments/library/characterization/t2ramsey_analysis.py
@@ -53,6 +53,7 @@ def _generate_fit_guesses(
         extra = self._get_option("extra")
 
         conversion_factor = extra.get("conversion_factor", 1)
-        user_opt.p0["tau"] *= conversion_factor
+        if user_opt.p0["tau"] is not None:
+            user_opt.p0["tau"] *= conversion_factor
 
         return super()._generate_fit_guesses(user_opt)

From fdb37df56f83dadaa75e7ead2d968a7e2a884510 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 15 Oct 2021 05:02:57 +0900
Subject: [PATCH 07/14] documentation fix

---
 .../curve_analysis/standard_analysis/decay.py | 23 ++++++++++++++-----
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/qiskit_experiments/curve_analysis/standard_analysis/decay.py b/qiskit_experiments/curve_analysis/standard_analysis/decay.py
index c209db0fa3..1986c284c5 100644
--- a/qiskit_experiments/curve_analysis/standard_analysis/decay.py
+++ b/qiskit_experiments/curve_analysis/standard_analysis/decay.py
@@ -18,23 +18,31 @@
 
 class DecayAnalysis(curve.CurveAnalysis):
     r"""A class to analyze general exponential decay curve.
+
     # section: fit_model
-        The fit is based on the following decay function.
-        .. math::
-            F(x) = {\rm amp} \cdot e^{-x/\tau} + {\rm base}
+
+    The fit is based on the following decay function.
+
+    .. math::
+        F(x) = {\rm amp} \cdot e^{-x/\tau} + {\rm base}
+
     # section: fit_parameters
-       defpar \rm amp:
+
+        defpar \rm amp:
            desc: Height of the decay curve.
            init_guess: Determined by :py:func:`~qiskit_experiments.curve_analysis.guess.min_height`.
            bounds: None
-       defpar \rm base:
+
+        defpar \rm base:
            desc: Base line of the decay curve.
            init_guess: Determined by the difference of minimum and maximum points.
            bounds: None
-       defpar \tau:
+
+        defpar \tau:
            desc: This is the fit parameter of main interest.
            init_guess: Determined by :py:func:`~qiskit_experiments.curve_analysis.guess.exp_decay`.
            bounds: None
+
     """
 
     __series__ = [
@@ -55,8 +63,10 @@ def _generate_fit_guesses(
         self, user_opt: curve.FitOptions
     ) -> Union[curve.FitOptions, List[curve.FitOptions]]:
         """Compute the initial guesses.
+
         Args:
             user_opt: Fit options filled with user provided guess and bounds.
+
         Returns:
             List of fit options that are passed to the fitter function.
         """
@@ -73,6 +83,7 @@ def _generate_fit_guesses(
 
     def _evaluate_quality(self, fit_data: curve.FitData) -> Union[str, None]:
         """Algorithmic criteria for whether the fit is good or bad.
+
         A good fit has:
             - a reduced chi-squared lower than three
             - absolute amp is within [0.9, 1.1]

From 64a47402062d364d4995d589da8801e08d2e77f9 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 22 Oct 2021 21:53:26 +0900
Subject: [PATCH 08/14] move some evaluation criteria from common analysis

---
 .../curve_analysis/standard_analysis/decay.py | 10 -------
 .../standard_analysis/oscillation.py          | 11 +++----
 .../library/characterization/t1_analysis.py   | 29 +++++++++++++++++++
 .../characterization/t2ramsey_analysis.py     | 25 ++++++++++++++++
 4 files changed, 58 insertions(+), 17 deletions(-)

diff --git a/qiskit_experiments/curve_analysis/standard_analysis/decay.py b/qiskit_experiments/curve_analysis/standard_analysis/decay.py
index 1986c284c5..589c516bf0 100644
--- a/qiskit_experiments/curve_analysis/standard_analysis/decay.py
+++ b/qiskit_experiments/curve_analysis/standard_analysis/decay.py
@@ -86,23 +86,13 @@ def _evaluate_quality(self, fit_data: curve.FitData) -> Union[str, None]:
 
         A good fit has:
             - a reduced chi-squared lower than three
-            - absolute amp is within [0.9, 1.1]
-            - base is less than 0.1
-            - amp error is less than 0.1
             - tau error is less than its value
-            - base error is less than 0.1
         """
-        amp = fit_data.fitval("amp")
         tau = fit_data.fitval("tau")
-        base = fit_data.fitval("base")
 
         criteria = [
             fit_data.reduced_chisq < 3,
-            abs(amp.value - 1.0) < 0.1,
-            abs(base.value) < 0.1,
-            amp.stderr is None or amp.stderr < 0.1,
             tau.stderr is None or tau.stderr < tau.value,
-            base.stderr is None or base.stderr < 0.1,
         ]
 
         if all(criteria):
diff --git a/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py b/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py
index de816f862a..28607d2433 100644
--- a/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py
+++ b/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py
@@ -252,19 +252,16 @@ def _evaluate_quality(self, fit_data: curve.FitData) -> Union[str, None]:
 
         A good fit has:
             - a reduced chi-squared lower than three
-            - relative error of amp is less than 10 percent
-            - relative error of tau is less than 10 percent
-            - relative error of freq is less than 10 percent
+            - relative error of tau is less than its value
+            - relative error of freq is less than its value
         """
-        amp = fit_data.fitval("amp")
         tau = fit_data.fitval("tau")
         freq = fit_data.fitval("freq")
 
         criteria = [
             fit_data.reduced_chisq < 3,
-            amp.stderr is None or amp.stderr < 0.1 * amp.value,
-            tau.stderr is None or tau.stderr < 0.1 * tau.value,
-            freq.stderr is None or freq.stderr < 0.1 * freq.value,
+            tau.stderr is None or tau.stderr < tau.value,
+            freq.stderr is None or freq.stderr < freq.value,
         ]
 
         if all(criteria):
diff --git a/qiskit_experiments/library/characterization/t1_analysis.py b/qiskit_experiments/library/characterization/t1_analysis.py
index dc5ffc990b..00e0e19417 100644
--- a/qiskit_experiments/library/characterization/t1_analysis.py
+++ b/qiskit_experiments/library/characterization/t1_analysis.py
@@ -50,3 +50,32 @@ def _generate_fit_guesses(
             user_opt.p0["tau"] *= conversion_factor
 
         return super()._generate_fit_guesses(user_opt)
+
+    def _evaluate_quality(self, fit_data: curve.FitData) -> Union[str, None]:
+        """Algorithmic criteria for whether the fit is good or bad.
+
+        A good fit has:
+            - a reduced chi-squared lower than three
+            - absolute amp is within [0.9, 1.1]
+            - base is less than 0.1
+            - amp error is less than 0.1
+            - tau error is less than its value
+            - base error is less than 0.1
+        """
+        amp = fit_data.fitval("amp")
+        tau = fit_data.fitval("tau")
+        base = fit_data.fitval("base")
+
+        criteria = [
+            fit_data.reduced_chisq < 3,
+            abs(amp.value - 1.0) < 0.1,
+            abs(base.value) < 0.1,
+            amp.stderr is None or amp.stderr < 0.1,
+            tau.stderr is None or tau.stderr < tau.value,
+            base.stderr is None or base.stderr < 0.1,
+        ]
+
+        if all(criteria):
+            return "good"
+
+        return "bad"
diff --git a/qiskit_experiments/library/characterization/t2ramsey_analysis.py b/qiskit_experiments/library/characterization/t2ramsey_analysis.py
index fa4ffb5667..eba9c031b6 100644
--- a/qiskit_experiments/library/characterization/t2ramsey_analysis.py
+++ b/qiskit_experiments/library/characterization/t2ramsey_analysis.py
@@ -57,3 +57,28 @@ def _generate_fit_guesses(
             user_opt.p0["tau"] *= conversion_factor
 
         return super()._generate_fit_guesses(user_opt)
+
+    def _evaluate_quality(self, fit_data: curve.FitData) -> Union[str, None]:
+        """Algorithmic criteria for whether the fit is good or bad.
+
+        A good fit has:
+            - a reduced chi-squared lower than three
+            - relative error of amp is less than 10 percent
+            - relative error of tau is less than 10 percent
+            - relative error of freq is less than 10 percent
+        """
+        amp = fit_data.fitval("amp")
+        tau = fit_data.fitval("tau")
+        freq = fit_data.fitval("freq")
+
+        criteria = [
+            fit_data.reduced_chisq < 3,
+            amp.stderr is None or amp.stderr < 0.1 * amp.value,
+            tau.stderr is None or tau.stderr < 0.1 * tau.value,
+            freq.stderr is None or freq.stderr < 0.1 * freq.value,
+        ]
+
+        if all(criteria):
+            return "good"
+
+        return "bad"

From b723aadbf4bc7c815e6cd3ad27c77fa3fe9033c7 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 22 Oct 2021 21:55:37 +0900
Subject: [PATCH 09/14] remove conversion factor and unit from result metadata

---
 qiskit_experiments/library/characterization/t1.py       | 7 -------
 qiskit_experiments/library/characterization/t2ramsey.py | 2 --
 2 files changed, 9 deletions(-)

diff --git a/qiskit_experiments/library/characterization/t1.py b/qiskit_experiments/library/characterization/t1.py
index c645bce9fa..c32b95670f 100644
--- a/qiskit_experiments/library/characterization/t1.py
+++ b/qiskit_experiments/library/characterization/t1.py
@@ -114,13 +114,6 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
         elif self.experiment_options.unit != "s":
             conversion_factor = apply_prefix(1, self.experiment_options.unit)
 
-        self.set_analysis_options(
-            extra={
-                "conversion_factor": conversion_factor,
-                "unit": self.experiment_options.unit,
-            },
-        )
-
         circuits = []
         for delay in conversion_factor * np.asarray(self.experiment_options.delays, dtype=float):
             delay = np.round(delay, decimals=10)
diff --git a/qiskit_experiments/library/characterization/t2ramsey.py b/qiskit_experiments/library/characterization/t2ramsey.py
index 4c0b437e86..4cc022cabb 100644
--- a/qiskit_experiments/library/characterization/t2ramsey.py
+++ b/qiskit_experiments/library/characterization/t2ramsey.py
@@ -151,8 +151,6 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
         self.set_analysis_options(
             extra={
                 "osc_freq": self.experiment_options.osc_freq,
-                "conversion_factor": conversion_factor,
-                "unit": self.experiment_options.unit,
             },
         )
 

From b29a1e5ffae8e023b0eb055848b438b2223e554a Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Fri, 22 Oct 2021 22:49:56 +0900
Subject: [PATCH 10/14] keep conversion factor

---
 qiskit_experiments/library/characterization/t1.py            | 2 ++
 qiskit_experiments/library/characterization/t1_analysis.py   | 5 ++---
 qiskit_experiments/library/characterization/t2ramsey.py      | 5 ++---
 .../library/characterization/t2ramsey_analysis.py            | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/qiskit_experiments/library/characterization/t1.py b/qiskit_experiments/library/characterization/t1.py
index c32b95670f..31768ac9f1 100644
--- a/qiskit_experiments/library/characterization/t1.py
+++ b/qiskit_experiments/library/characterization/t1.py
@@ -114,6 +114,8 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
         elif self.experiment_options.unit != "s":
             conversion_factor = apply_prefix(1, self.experiment_options.unit)
 
+        self.set_analysis_options(conversion_factor=conversion_factor)
+
         circuits = []
         for delay in conversion_factor * np.asarray(self.experiment_options.delays, dtype=float):
             delay = np.round(delay, decimals=10)
diff --git a/qiskit_experiments/library/characterization/t1_analysis.py b/qiskit_experiments/library/characterization/t1_analysis.py
index 00e0e19417..131571e8f9 100644
--- a/qiskit_experiments/library/characterization/t1_analysis.py
+++ b/qiskit_experiments/library/characterization/t1_analysis.py
@@ -35,6 +35,7 @@ def _default_options(cls) -> Options:
         options.ylabel = "P(1)"
         options.xval_unit = "s"
         options.result_parameters = [curve.ParameterRepr("tau", "T1", "s")]
+        options.conversion_factor = None
 
         return options
 
@@ -42,10 +43,8 @@ def _generate_fit_guesses(
         self, user_opt: curve.FitOptions
     ) -> Union[curve.FitOptions, List[curve.FitOptions]]:
         """Apply conversion factor to tau."""
+        conversion_factor = self._get_option("conversion_factor")
 
-        extra = self._get_option("extra")
-
-        conversion_factor = extra.get("conversion_factor", 1)
         if user_opt.p0["tau"] is not None:
             user_opt.p0["tau"] *= conversion_factor
 
diff --git a/qiskit_experiments/library/characterization/t2ramsey.py b/qiskit_experiments/library/characterization/t2ramsey.py
index 4cc022cabb..bfd5c7aebf 100644
--- a/qiskit_experiments/library/characterization/t2ramsey.py
+++ b/qiskit_experiments/library/characterization/t2ramsey.py
@@ -149,9 +149,8 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
             conversion_factor = apply_prefix(1, self.experiment_options.unit)
 
         self.set_analysis_options(
-            extra={
-                "osc_freq": self.experiment_options.osc_freq,
-            },
+            extra={"osc_freq": self.experiment_options.osc_freq},
+            conversion_factor=conversion_factor,
         )
 
         circuits = []
diff --git a/qiskit_experiments/library/characterization/t2ramsey_analysis.py b/qiskit_experiments/library/characterization/t2ramsey_analysis.py
index eba9c031b6..358c7b3ef7 100644
--- a/qiskit_experiments/library/characterization/t2ramsey_analysis.py
+++ b/qiskit_experiments/library/characterization/t2ramsey_analysis.py
@@ -43,6 +43,7 @@ def _default_options(cls) -> Options:
             curve.ParameterRepr("freq", "Frequency", "Hz"),
             curve.ParameterRepr("tau", "T2star", "s"),
         ]
+        options.conversion_factor = None
 
         return options
 
@@ -50,9 +51,8 @@ def _generate_fit_guesses(
         self, user_opt: curve.FitOptions
     ) -> Union[curve.FitOptions, List[curve.FitOptions]]:
         """Apply conversion factor to tau."""
-        extra = self._get_option("extra")
+        conversion_factor = self._get_option("conversion_factor")
 
-        conversion_factor = extra.get("conversion_factor", 1)
         if user_opt.p0["tau"] is not None:
             user_opt.p0["tau"] *= conversion_factor
 

From eb26249bdf66a38e2094f8c0243a339dbab362e1 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Mon, 1 Nov 2021 16:14:29 +0900
Subject: [PATCH 11/14] remove osc_freq from initial guess

---
 .../library/characterization/t2ramsey.py      | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/qiskit_experiments/library/characterization/t2ramsey.py b/qiskit_experiments/library/characterization/t2ramsey.py
index bfd5c7aebf..b57493b3fb 100644
--- a/qiskit_experiments/library/characterization/t2ramsey.py
+++ b/qiskit_experiments/library/characterization/t2ramsey.py
@@ -103,25 +103,6 @@ def __init__(
         super().__init__([qubit])
         self.set_experiment_options(delays=delays, unit=unit, osc_freq=osc_freq)
 
-    def set_experiment_options(self, **fields):
-        """Set the experiment options.
-
-        Args:
-            fields: The fields to update the options
-
-        Raises:
-            AttributeError: If the field passed in is not a supported options
-        """
-        super().set_experiment_options(**fields)
-
-        # set frequency guess from experiment configuration
-        if "osc_freq" in fields:
-            user_p0 = self.analysis_options.p0
-            if user_p0.get("freq", None) is None:
-                user_p0["freq"] = fields["osc_freq"]
-
-            self.set_analysis_options(p0=user_p0)
-
     def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
         """Return a list of experiment circuits.
 

From cd9b9cc57e9d4335aa3dedc6eb0bf1d3f4a27124 Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Mon, 1 Nov 2021 16:57:07 +0900
Subject: [PATCH 12/14] update conversion factor logic for init guess

---
 .../library/characterization/t1.py            | 32 ++++++++++-------
 .../library/characterization/t1_analysis.py   |  3 +-
 .../library/characterization/t2ramsey.py      | 36 ++++++++++---------
 .../characterization/t2ramsey_analysis.py     |  3 +-
 test/test_t1.py                               | 24 +++++++++++--
 5 files changed, 62 insertions(+), 36 deletions(-)

diff --git a/qiskit_experiments/library/characterization/t1.py b/qiskit_experiments/library/characterization/t1.py
index 9eb686ad73..7f32bf7a39 100644
--- a/qiskit_experiments/library/characterization/t1.py
+++ b/qiskit_experiments/library/characterization/t1.py
@@ -62,6 +62,7 @@ def _default_experiment_options(cls) -> Options:
 
         options.delays = None
         options.unit = "s"
+        options.conversion_factor = None
 
         return options
 
@@ -107,6 +108,19 @@ def _set_backend(self, backend: Backend):
                 timing_constraints=timing_constraints, scheduling_method=scheduling_method
             )
 
+        # Set conversion factor
+        if self.experiment_options.unit == "dt":
+            try:
+                dt_factor = getattr(self.backend.configuration(), "dt")
+                conversion_factor = dt_factor
+            except AttributeError as no_dt:
+                raise AttributeError("Dt parameter is missing in backend configuration") from no_dt
+        elif self.experiment_options.unit != "s":
+            conversion_factor = apply_prefix(1, self.experiment_options.unit)
+        else:
+            conversion_factor = 1
+        self.set_experiment_options(conversion_factor=conversion_factor)
+
     def circuits(self) -> List[QuantumCircuit]:
         """
         Return a list of experiment circuits
@@ -115,23 +129,15 @@ def circuits(self) -> List[QuantumCircuit]:
             The experiment circuits
 
         Raises:
-            AttributeError: if unit is `dt`, but `dt` parameter
-                is missing in the backend configuration.
+            AttributeError: When conversion factor is not set.
         """
-        conversion_factor = 1
-        if self.experiment_options.unit == "dt":
-            try:
-                dt_factor = getattr(self.backend.configuration(), "dt")
-                conversion_factor = dt_factor
-            except AttributeError as no_dt:
-                raise AttributeError("Dt parameter is missing in backend configuration") from no_dt
-        elif self.experiment_options.unit != "s":
-            conversion_factor = apply_prefix(1, self.experiment_options.unit)
+        prefactor = self.experiment_options.conversion_factor
 
-        self.set_analysis_options(conversion_factor=conversion_factor)
+        if prefactor is None:
+            raise ValueError("Conversion factor is not set.")
 
         circuits = []
-        for delay in conversion_factor * np.asarray(self.experiment_options.delays, dtype=float):
+        for delay in prefactor * np.asarray(self.experiment_options.delays, dtype=float):
             delay = np.round(delay, decimals=10)
 
             circ = QuantumCircuit(1, 1)
diff --git a/qiskit_experiments/library/characterization/t1_analysis.py b/qiskit_experiments/library/characterization/t1_analysis.py
index 131571e8f9..5b081f3086 100644
--- a/qiskit_experiments/library/characterization/t1_analysis.py
+++ b/qiskit_experiments/library/characterization/t1_analysis.py
@@ -35,7 +35,6 @@ def _default_options(cls) -> Options:
         options.ylabel = "P(1)"
         options.xval_unit = "s"
         options.result_parameters = [curve.ParameterRepr("tau", "T1", "s")]
-        options.conversion_factor = None
 
         return options
 
@@ -43,7 +42,7 @@ def _generate_fit_guesses(
         self, user_opt: curve.FitOptions
     ) -> Union[curve.FitOptions, List[curve.FitOptions]]:
         """Apply conversion factor to tau."""
-        conversion_factor = self._get_option("conversion_factor")
+        conversion_factor = self._experiment_options()["conversion_factor"]
 
         if user_opt.p0["tau"] is not None:
             user_opt.p0["tau"] *= conversion_factor
diff --git a/qiskit_experiments/library/characterization/t2ramsey.py b/qiskit_experiments/library/characterization/t2ramsey.py
index 6356ee8122..54bb6c8743 100644
--- a/qiskit_experiments/library/characterization/t2ramsey.py
+++ b/qiskit_experiments/library/characterization/t2ramsey.py
@@ -75,6 +75,7 @@ def _default_experiment_options(cls) -> Options:
 
         options.delays = None
         options.unit = "s"
+        options.conversion_factor = None
         options.osc_freq = 0.0
 
         return options
@@ -101,7 +102,6 @@ def __init__(
                 The frequency is given in Hz.
 
         """
-
         super().__init__([qubit], backend=backend)
         self.set_experiment_options(delays=delays, unit=unit, osc_freq=osc_freq)
 
@@ -118,6 +118,19 @@ def _set_backend(self, backend: Backend):
                 timing_constraints=timing_constraints, scheduling_method=scheduling_method
             )
 
+        # Set conversion factor
+        if self.experiment_options.unit == "dt":
+            try:
+                dt_factor = getattr(self.backend.configuration(), "dt")
+                conversion_factor = dt_factor
+            except AttributeError as no_dt:
+                raise AttributeError("Dt parameter is missing in backend configuration") from no_dt
+        elif self.experiment_options.unit != "s":
+            conversion_factor = apply_prefix(1, self.experiment_options.unit)
+        else:
+            conversion_factor = 1
+        self.set_experiment_options(conversion_factor=conversion_factor)
+
     def circuits(self) -> List[QuantumCircuit]:
         """Return a list of experiment circuits.
 
@@ -128,26 +141,15 @@ def circuits(self) -> List[QuantumCircuit]:
             The experiment circuits
 
         Raises:
-            AttributeError: if unit is `dt`, but `dt` parameter
-                is missing in the backend configuration.
+            AttributeError: When conversion factor is not set.
         """
-        conversion_factor = 1
-        if self.experiment_options.unit == "dt":
-            try:
-                dt_factor = getattr(self.backend.configuration(), "dt")
-                conversion_factor = dt_factor
-            except AttributeError as no_dt:
-                raise AttributeError("Dt parameter is missing in backend configuration") from no_dt
-        elif self.experiment_options.unit != "s":
-            conversion_factor = apply_prefix(1, self.experiment_options.unit)
+        prefactor = self.experiment_options.conversion_factor
 
-        self.set_analysis_options(
-            extra={"osc_freq": self.experiment_options.osc_freq},
-            conversion_factor=conversion_factor,
-        )
+        if prefactor is None:
+            raise ValueError("Conversion factor is not set.")
 
         circuits = []
-        for delay in conversion_factor * np.asarray(self.experiment_options.delays, dtype=float):
+        for delay in prefactor * np.asarray(self.experiment_options.delays, dtype=float):
             delay = np.round(delay, decimals=10)
 
             rotation_angle = 2 * np.pi * self.experiment_options.osc_freq * delay
diff --git a/qiskit_experiments/library/characterization/t2ramsey_analysis.py b/qiskit_experiments/library/characterization/t2ramsey_analysis.py
index 358c7b3ef7..09b918989d 100644
--- a/qiskit_experiments/library/characterization/t2ramsey_analysis.py
+++ b/qiskit_experiments/library/characterization/t2ramsey_analysis.py
@@ -43,7 +43,6 @@ def _default_options(cls) -> Options:
             curve.ParameterRepr("freq", "Frequency", "Hz"),
             curve.ParameterRepr("tau", "T2star", "s"),
         ]
-        options.conversion_factor = None
 
         return options
 
@@ -51,7 +50,7 @@ def _generate_fit_guesses(
         self, user_opt: curve.FitOptions
     ) -> Union[curve.FitOptions, List[curve.FitOptions]]:
         """Apply conversion factor to tau."""
-        conversion_factor = self._get_option("conversion_factor")
+        conversion_factor = self._experiment_options()["conversion_factor"]
 
         if user_opt.p0["tau"] is not None:
             user_opt.p0["tau"] *= conversion_factor
diff --git a/test/test_t1.py b/test/test_t1.py
index 2e73675ac1..b3cdf6bf02 100644
--- a/test/test_t1.py
+++ b/test/test_t1.py
@@ -110,7 +110,15 @@ def test_t1_analysis(self):
         """
 
         data = ExperimentData()
-        data._metadata = {"job_metadata": [{"run_options": {"meas_level": 2}}]}
+        data._metadata = {
+            "job_metadata": [
+                {
+                    "run_options": {"meas_level": 2},
+                    # TODO remove this, issue #456
+                    "experiment_options": {"conversion_factor": 1, "unit": "s"},
+                },
+            ]
+        }
 
         numbers = [750, 1800, 2750, 3550, 4250, 4850, 5450, 5900, 6400, 6800, 7000, 7350, 7700]
 
@@ -138,6 +146,10 @@ def test_t1_metadata(self):
 
         delays = list(range(1, 40, 3))
         exp = T1(0, delays, unit="ms")
+
+        # TODO remove this, issue #456
+        exp.set_experiment_options(conversion_factor=1/1000)
+
         circs = exp.circuits()
 
         self.assertEqual(len(circs), len(delays))
@@ -159,7 +171,15 @@ def test_t1_low_quality(self):
         """
 
         data = ExperimentData()
-        data._metadata = {"job_metadata": [{"run_options": {"meas_level": 2}}]}
+        data._metadata = {
+            "job_metadata": [
+                {
+                    "run_options": {"meas_level": 2},
+                    # TODO remove this, issue #456
+                    "experiment_options": {"conversion_factor": 1, "unit": "s"},
+                },
+            ]
+        }
 
         for i in range(10):
             data.add_data(

From 06bf91d858b710465bd574a122e130562657b4fc Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Mon, 1 Nov 2021 17:00:22 +0900
Subject: [PATCH 13/14] lint

---
 qiskit_experiments/library/characterization/t1.py       | 2 +-
 qiskit_experiments/library/characterization/t2ramsey.py | 2 +-
 test/test_t1.py                                         | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/qiskit_experiments/library/characterization/t1.py b/qiskit_experiments/library/characterization/t1.py
index 7f32bf7a39..a35a05e81a 100644
--- a/qiskit_experiments/library/characterization/t1.py
+++ b/qiskit_experiments/library/characterization/t1.py
@@ -129,7 +129,7 @@ def circuits(self) -> List[QuantumCircuit]:
             The experiment circuits
 
         Raises:
-            AttributeError: When conversion factor is not set.
+            ValueError: When conversion factor is not set.
         """
         prefactor = self.experiment_options.conversion_factor
 
diff --git a/qiskit_experiments/library/characterization/t2ramsey.py b/qiskit_experiments/library/characterization/t2ramsey.py
index 54bb6c8743..aa24295dfd 100644
--- a/qiskit_experiments/library/characterization/t2ramsey.py
+++ b/qiskit_experiments/library/characterization/t2ramsey.py
@@ -141,7 +141,7 @@ def circuits(self) -> List[QuantumCircuit]:
             The experiment circuits
 
         Raises:
-            AttributeError: When conversion factor is not set.
+            ValueError: When conversion factor is not set.
         """
         prefactor = self.experiment_options.conversion_factor
 
diff --git a/test/test_t1.py b/test/test_t1.py
index b3cdf6bf02..6b78e56b55 100644
--- a/test/test_t1.py
+++ b/test/test_t1.py
@@ -148,7 +148,7 @@ def test_t1_metadata(self):
         exp = T1(0, delays, unit="ms")
 
         # TODO remove this, issue #456
-        exp.set_experiment_options(conversion_factor=1/1000)
+        exp.set_experiment_options(conversion_factor=1 / 1000)
 
         circs = exp.circuits()
 

From 117f1bd74f42b17ba16604df56901f312b9b0fcd Mon Sep 17 00:00:00 2001
From: knzwnao <knzwnao@jp.ibm.com>
Date: Tue, 2 Nov 2021 11:33:59 +0900
Subject: [PATCH 14/14] typo fix

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

diff --git a/qiskit_experiments/curve_analysis/curve_analysis.py b/qiskit_experiments/curve_analysis/curve_analysis.py
index 9e16cb3be7..28468eac0e 100644
--- a/qiskit_experiments/curve_analysis/curve_analysis.py
+++ b/qiskit_experiments/curve_analysis/curve_analysis.py
@@ -343,7 +343,7 @@ def _default_options(cls) -> Options:
                 :py:class:`~qiskit_experiments.curve_analysis.visualization.style.PlotterStyle`
                 that contains a set of configurations to create a fit plot.
             extra (Dict[str, Any]): A dictionary that is appended to all database entries
-                as an extra information.
+                as extra information.
         """
         options = super()._default_options()
 
diff --git a/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py b/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py
index 28607d2433..b78c90eb48 100644
--- a/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py
+++ b/qiskit_experiments/curve_analysis/standard_analysis/oscillation.py
@@ -129,7 +129,7 @@ class DumpedOscillationAnalysis(curve.CurveAnalysis):
     r"""A class to analyze general exponential decay curve with sinusoidal oscillation.
 
     # section: fit_model
-        This class is based on te fit model of sinusoidal signal with exponential decay.
+        This class is based on the fit model of sinusoidal signal with exponential decay.
         This model is often used for the oscillation signal in the dissipative system.
 
         .. math::