diff --git a/docs/_ext/autodoc_analysis.py b/docs/_ext/autodoc_analysis.py index 73c0cac5a9..ded49695c6 100644 --- a/docs/_ext/autodoc_analysis.py +++ b/docs/_ext/autodoc_analysis.py @@ -26,14 +26,12 @@ class AnalysisDocumenter(ClassDocumenter): """Sphinx extension for the custom documentation of the standard analysis class.""" objtype = "analysis" - directivetype = 'class' + directivetype = "class" priority = 10 + ClassDocumenter.priority option_spec = dict(ClassDocumenter.option_spec) @classmethod - def can_document_member( - cls, member: Any, membername: str, isattr: bool, parent: Any - ) -> bool: + def can_document_member(cls, member: Any, membername: str, isattr: bool, parent: Any) -> bool: return isinstance(member, BaseAnalysis) def add_content(self, more_content: Any, no_docstring: bool = False) -> None: diff --git a/docs/_ext/custom_styles/utils.py b/docs/_ext/custom_styles/utils.py index b25cb3ef3c..f86cd250d7 100644 --- a/docs/_ext/custom_styles/utils.py +++ b/docs/_ext/custom_styles/utils.py @@ -161,7 +161,7 @@ def _generate_analysis_ref( raise Exception(f"Option docstring for analysis_ref is missing.") analysis_ref_lines = [] - for line in lines[analysis_ref_start + 1:]: + for line in lines[analysis_ref_start + 1 :]: # add lines until hitting to next section if line.startswith("# section:"): break @@ -202,6 +202,7 @@ def _format_default_options(defaults: Dict[str, Any], indent: str = "") -> List[ def _check_no_indent(method: Callable) -> Callable: """Check indent of lines and return if this block is correctly indented.""" + def wraps(self, lines: List[str], *args, **kwargs): if all(l.startswith(" ") for l in lines): text_block = "\n".join(lines) diff --git a/docs/conf.py b/docs/conf.py index 44ad860300..fe2987e984 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -25,7 +25,8 @@ # import os import sys -sys.path.insert(0, os.path.abspath('.')) + +sys.path.insert(0, os.path.abspath(".")) sys.path.append(os.path.abspath("./_ext")) """ @@ -33,19 +34,20 @@ """ import os + # Set env flag so that we can doc functions that may otherwise not be loaded # see for example interactive visualizations in qiskit.visualization. -os.environ['QISKIT_DOCS'] = 'TRUE' +os.environ["QISKIT_DOCS"] = "TRUE" # -- Project information ----------------------------------------------------- -project = 'Qiskit Experiments' -copyright = '2021, Qiskit Development Team' # pylint: disable=redefined-builtin -author = 'Qiskit Development Team' +project = "Qiskit Experiments" +copyright = "2021, Qiskit Development Team" # pylint: disable=redefined-builtin +author = "Qiskit Development Team" # The short X.Y version -version = '0.3' +version = "0.3" # The full version, including alpha/beta/rc tags -release = '0.3.0' +release = "0.3.0" rst_prolog = """ .. raw:: html @@ -53,7 +55,9 @@


.. |version| replace:: {0} -""".format(release) +""".format( + release +) nbsphinx_prolog = """ {% set docname = env.doc2path(env.docname, base=None) %} @@ -81,32 +85,31 @@ # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ - 'sphinx.ext.napoleon', - 'sphinx.ext.autodoc', - 'sphinx.ext.autosummary', - 'sphinx.ext.mathjax', - 'sphinx.ext.viewcode', - 'sphinx.ext.extlinks', - 'jupyter_sphinx', - 'sphinx_autodoc_typehints', - 'reno.sphinxext', - 'sphinx_panels', - 'sphinx.ext.intersphinx', - 'nbsphinx', - 'autoref', - 'autodoc_experiment', - 'autodoc_analysis', + "sphinx.ext.napoleon", + "sphinx.ext.autodoc", + "sphinx.ext.autosummary", + "sphinx.ext.mathjax", + "sphinx.ext.viewcode", + "sphinx.ext.extlinks", + "jupyter_sphinx", + "sphinx_autodoc_typehints", + "reno.sphinxext", + "sphinx_panels", + "sphinx.ext.intersphinx", + "nbsphinx", + "autoref", + "autodoc_experiment", + "autodoc_analysis", ] -html_static_path = ['_static'] -templates_path = ['_templates'] -html_css_files = ['style.css', 'custom.css', 'gallery.css'] +html_static_path = ["_static"] +templates_path = ["_templates"] +html_css_files = ["style.css", "custom.css", "gallery.css"] nbsphinx_timeout = 360 -nbsphinx_execute = os.getenv('QISKIT_DOCS_BUILD_TUTORIALS', 'never') -nbsphinx_widgets_path = '' -exclude_patterns = ['_build', '**.ipynb_checkpoints'] -nbsphinx_thumbnails = { -} +nbsphinx_execute = os.getenv("QISKIT_DOCS_BUILD_TUTORIALS", "never") +nbsphinx_widgets_path = "" +exclude_patterns = ["_build", "**.ipynb_checkpoints"] +nbsphinx_thumbnails = {} # ----------------------------------------------------------------------------- @@ -120,7 +123,7 @@ # ----------------------------------------------------------------------------- autodoc_default_options = { - 'inherited-members': None, + "inherited-members": None, } @@ -131,9 +134,7 @@ # A dictionary mapping 'figure', 'table', 'code-block' and 'section' to # strings that are used for format of figure numbers. As a special character, # %s will be replaced to figure number. -numfig_format = { - 'table': 'Table %s' -} +numfig_format = {"table": "Table %s"} # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # @@ -144,10 +145,10 @@ # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. -exclude_patterns = ['_build', '**.ipynb_checkpoints'] +exclude_patterns = ["_build", "**.ipynb_checkpoints"] # The name of the Pygments (syntax highlighting) style to use. -pygments_style = 'colorful' +pygments_style = "colorful" # A boolean that decides whether module names are prepended to all object names # (for object types where a “module” of some kind is defined), e.g. for @@ -158,7 +159,7 @@ # (e.g., if this is set to ['foo.'], then foo.bar is shown under B, not F). # This can be handy if you document a project that consists of a single # package. Works only for the HTML builder currently. -modindex_common_prefix = ['qiskit_experiments.'] +modindex_common_prefix = ["qiskit_experiments."] # -- Configuration for extlinks extension ------------------------------------ # Refer to https://www.sphinx-doc.org/en/master/usage/extensions/extlinks.html @@ -169,20 +170,20 @@ # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # -html_theme = 'qiskit_sphinx_theme' # use the theme in subdir 'theme' +html_theme = "qiskit_sphinx_theme" # use the theme in subdir 'theme' -#html_sidebars = {'**': ['globaltoc.html']} -html_last_updated_fmt = '%Y/%m/%d' +# html_sidebars = {'**': ['globaltoc.html']} +html_last_updated_fmt = "%Y/%m/%d" html_theme_options = { - 'logo_only': True, - 'display_version': True, - 'prev_next_buttons_location': 'bottom', - 'style_external_links': True, + "logo_only": True, + "display_version": True, + "prev_next_buttons_location": "bottom", + "style_external_links": True, } -autoclass_content = 'both' -intersphinx_mapping = {'matplotlib': ('https://matplotlib.org/stable/', None)} +autoclass_content = "both" +intersphinx_mapping = {"matplotlib": ("https://matplotlib.org/stable/", None)} # Current scipy hosted docs are missing the object.inv file so leaving this # commented out until the missing file is added back. # 'scipy': ('https://docs.scipy.org/doc/scipy/reference/', None)} diff --git a/docs/tutorials/t2hahn_characterization.ipynb b/docs/tutorials/t2hahn_characterization.ipynb new file mode 100644 index 0000000000..c1209e8f5d --- /dev/null +++ b/docs/tutorials/t2hahn_characterization.ipynb @@ -0,0 +1,456 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# T2 Hahn Characterization (CPMG)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The purpose of the $T_2$ Hahn Echo experiment is to determine $T_2$ qubit property. \n", + "\n", + "In this experiment, we would like to get a more precise estimate of the qubit's decay time. $T_2$ represents the amount of time required for a single qubit Bloch vector projection on the XY plane, to fall to approximately 37% ($\\frac{1}{e}$) of its initial amplitude.
\n", + "In Ramsey Experiment we were introduced to the term detuning frequency (The difference between the frequency used for the control rotation, and the precise frequency).\n", + "
Hahn Echo experiment and CPMG sequence are experiments to estimate $T_2$ which are robust to the detuning frequency.\n", + "The decay in amplitude causes the probability function to take the following form:
\n", + "$$f(t) = A \\cdot e^{-\\frac{t}{T_2}}+ B$$\n", + "The difference between Hahn Echo and CPMG sequence is that in Hahn Echo experiment, there is only one echo sequence while in CPMG there are multiple echo sequences." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Decoherence Time\n", + "Decoherence time is the time taken for off-diagonal components of the density matrix to fall to approximately 37% ($\\frac{1}{e}$). For $t\\gg T_2$, the qubit statistics behave like a random bit. It gets the value of `0` with probability of $p$ and the value of `1` with probability of $1-p$.\n", + "\n", + "Since the qubit is exposed to other types of noise (like T1), we are using $Rx(\\pi)$ pulses for decoupling and to solve our inaccuracy for the qubit frequency estimation." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit_experiments.library.characterization.t2hahn import T2Hahn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The circuit used for an experiment with $N$ echoes comprises the following components:\n", + "\n", + "  1.$Rx\\left(\\frac{\\pi}{2} \\right)$ gate
\n", + "  2. $N$ times Echo sequence :
\n", + "    (a) $Delay \\left(t_{0} \\right)$ gate
\n", + "    (b) $Rx \\left(\\pi \\right)$ gate
\n", + "    (c) $Delay \\left(t_{0} \\right)$ gate
\n", + "  3. $Rx \\left(\\pm \\frac{\\pi}{2} \\right)$ gate (sign depends on the number of echoes)
\n", + "  4. Measurement gate\n", + "\n", + "The user provides as input a series of delays in seconds. During the delay, we expect the qubit to precess about the z-axis. Because of the echo gate ($Rx(\\pi)$) for each echo, the angle after the delay gates will be $\\theta_{new} = \\theta_{old} + \\pi$. After waiting the same delay time, the angle will be approximately $0$ or $\\pi$. By varying the extension of the delays, we get a series of decaying measurements. We can draw the graph of the resulting function and can analytically extract the desired values." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ┌─────────┐┌───────────────┐┌───────┐┌───────────────┐┌─────────┐┌─┐\n", + " q: ┤ Rx(π/2) ├┤ Delay(0.0[s]) ├┤ Rx(π) ├┤ Delay(0.0[s]) ├┤ Rx(π/2) ├┤M├\n", + " └─────────┘└───────────────┘└───────┘└───────────────┘└─────────┘└╥┘\n", + "c: 1/══════════════════════════════════════════════════════════════════╩═\n", + " 0 \n" + ] + } + ], + "source": [ + "qubit = 0\n", + "conversion_factor = 1e-6 # our delay will be in micro-sec\n", + "delays = list(range(0, 50, 1) )\n", + "delays = [float(_) * conversion_factor for _ in delays]\n", + "number_of_echoes = 1\n", + "\n", + "# Create a T2Hahn experiment. Print the first circuit as an example\n", + "exp1 = T2Hahn(qubit=qubit, delays=delays, num_echoes=number_of_echoes)\n", + "print(exp1.circuits()[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We run the experiment on a simple, simulated backend, tailored specifically for this experiment." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_experiments.test.t2hahn_backend import T2HahnBackend\n", + "\n", + "estimated_t2hahn = 20 * conversion_factor\n", + "# The behavior of the backend is determined by the following parameters\n", + "backend = T2HahnBackend(\n", + " t2hahn=[estimated_t2hahn],\n", + " frequency=[100100],\n", + " initialization_error=[0.0],\n", + " readout0to1=[0.02],\n", + " readout1to0=[0.02],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting graph will have the form:\n", + "$f(t) = A \\cdot e^{-\\frac{t}{T_2}}+ B$\n", + "where *t* is the delay and $T_2$ is the decay factor." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "exp1.analysis.set_options(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", + "# Display the figure\n", + "display(expdata1.figure(0))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DbAnalysisResultV1\n", + "- name: @Parameters_T2HahnAnalysis\n", + "- value: [4.77306456e-01 5.01013038e-01 2.00569581e-05] ± [3.60925695e-03 2.92038248e-03 4.68026484e-07]\n", + "- χ²: 0.9207937705047796\n", + "- quality: good\n", + "- extra: <4 items>\n", + "- device_components: ['Q0']\n", + "- verified: False\n", + "DbAnalysisResultV1\n", + "- name: T2\n", + "- value: 2.0056958094880182e-05 ± 4.6802648351047525e-07 s\n", + "- χ²: 0.9207937705047796\n", + "- quality: good\n", + "- device_components: ['Q0']\n", + "- verified: False\n" + ] + } + ], + "source": [ + "# Print results\n", + "for result in expdata1.analysis_results():\n", + " print(result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2. Providing initial user estimates\n", + "The user can provide initial estimates for the parameters to help the analysis process. In the initial guess, the keys `{amp, tau, base}` correspond to the parameters `{A, T_2, B}` respectively.
\n", + "Because the curve is expected to decay toward $0.5$, the natural choice for parameter $B$ is $0.5$. When there is no $T_2$ error, we would expect that the probability to measure `1` is $100\\%$, therefore we will guess that A is $0.5$. In this experiment, `t2hahn` is the parameter of interest. Good estimate for it is the value computed in previous experiments on this qubit or a similar value computed for other qubits." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgAAAAFGCAYAAAAckScWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABSIklEQVR4nO3dd5xU1f3/8ddnd9kKwiLC7oqAiIJoRAQLYMHYazSCigZBBQS7iL+gIigaYhRRFGzEiC2KkITEEtEoYAFFiRh7+UqTjoCwjbJ7fn+cnW3slGVnZ7a8n4/HfczMvWfuPXNY5n7mVHPOISIiIo1LQrwzICIiIrGnAEBERKQRUgAgIiLSCCkAEBERaYQUAIiIiDRCCgBEREQaoaR4Z6A2tWrVynXo0CGq58zLyyMjIyOq52ysVJbRoXKMHpVl9Kgso6e6Zbl48eKNzrl9wqVr0AFAhw4d+OSTT6J6znnz5tG3b9+onrOxUllGh8oxelSW0aOyjJ7qlqWZLY8kXcybAMzseDP7l5mtMjNnZoMjeM+vzGy+mRWUvG+smVkMsisiItIgxaMPQFPgC+AGoCBcYjPbC3gLWAccWfK+W4CRtZhHERGRBi3mTQDOudeB1wHMbHoEb7kUSAcGOecKgC/MrAsw0swmOc1lLCIiUm31YRRAL+C9kpt/wBwgB+gQlxyJiIjUcxbPH9Bmlgtc65ybHiLNm8BPzrkryu1rBywHejvnFlZKPwwYBtCmTZseL730UlTznJubS9OmTaN6zsZKZRkdKsfoUVlGj8oyeqpblieeeOJi51zPcOka3CgA59yTwJMAPXv2dNHuhaqerdGjsowOlWP0qCyjR2UZPbVVlvWhCWAt0KbSvjbljomIiEg11YcAYCFwnJmlltt3CrAaWBaXHImIiNRz8ZgHoKmZHW5mh5dcv13J63Ylx/9oZm+Xe8tfgXxgupkdama/BUYDGgEgIiKyh+JRA9AT+LRkSwPuKnk+vuR4NnBAILFz7hf8L/4c4BNgKvAAMCl2WYbNm2HaNFizxj9u3hzLq4uIiERXPOYBmAcEncXPOTe4in2fA8fXXq6Ccw7GjoWJEyExEe66C8aNg+uvh1GjYPx40JyEsqfOOecc1qxZU6NzFBYWkpqaGj6hhKWyjJ6alGV2djavvPJKlHMklTW4UQDRNnYsTJoEhYVl+/Ly/OOkkjqIu++Ofb6kYVizZk2N16vYtm0bzZo1i1KOGjeVZfTUpCx79gw7gk2ioD50AoybzZv9L//8/LJ9n3/eqvR5fr4/vmVL7PMmIiJSEwoAQpg1y1f7lzd3brsKrxMTYebMGGZKGjwzC7kNHjyYZcuWceWVV9KxY0dat25Nx44dufXWWykoCLu8RlRt2rSJ6667ji5dupCWlsZ+++3HiBEj+Pnnnyuk27x5MwMHDqR58+Y0b96cgQMHsiVM5Pz3v/+d0047jX322QczY968ebX3QeLoqquuwsyYOHHibscWLVrEKaecQtOmTWnWrBm9e/dm48aNu6UrLCykW7dumFnYGqVt27Zx44030r59e9LS0ujduzcff/xxhTS5ublcd911tG3blrS0NDp37syDDz5Ysw8qdY6aAEJYu7bir3+AFSv2qvA6P9+nE4mW8n0CXn31VYYOHVphX1paGgsXLqSoqIjHHnuM7OxsVq5cybBhw/j555958sknY5bX1atXs2rVKu677z66du3KqlWruPrqqxkwYABvvvlmabpLLrmEFStW8MYbbwAwZMgQBg4cGLKdNy8vj969e/O73/2Oyy67rNY/S6TuvPNOli1bxvTp02t8rlmzZrFo0SJycnJ2O/bRRx9x2mmnccstt/Dggw+SnJzMF198QZMmTXZLO2rUKNq2bcv//ve/sNccMmQI//vf/3jmmWdo27Ytzz//PCeffDJfffUV++67LwAjR47kP//5D8899xz7778/7777LkOHDqVVq1YMHDiwxp9b6gjnXIPdevTo4WriySedy8hwzncFrHrLyPDppPrmzp0b7yzEXbi/0ZkzZzr/3zS4rVu3Ouecmzp1qmvZsmXU8ranXnvtNWdm7pdffnHOOffVV185wL3//vulad577z0HuG+++Sbs+TZs2OCAiP5exo0b5w455JAK+55++mmXkZFR+nrFihXu3HPPdZmZmS4tLc117tzZvfjii865srIMd41BgwaFTRfOsmXLXE5Ojvvqq69c+/bt3f3331/heK9evdxtt90W9jyzZ892Xbt2LS3njz/+OGja/Px8l5iY6GbPnl1h/xFHHOFuv/320teHHHKIGzt2bIU0xx9/vLvmmmuCnjtQ9i+++KLr2LGja9q0qfvNb37jNmzYUJrmf//7n/v1r3/tmjVr5jIyMtxhhx3m3nnnnd3OVdPv7oamut+VwCcugnukmgBC6NcPiopCpykqgv79Y5MfkVC2bt1KZmZmyDQTJkygadOmIbf33nuvxvlISUkhPT0dgIULF9K0aVN69+5dmqZPnz5kZGSwYMGCGl1rT1x99dXk5+czd+5cvvzySx566CFatGgR0zzs2rWLAQMGMGbMGA4++ODdjq9fv56FCxeSnZ3NscceS+vWrTnuuON4++23K6T76aefGDFiBH/9619JS0uL6LpFRUW79c5PS0vj/fffL3197LHH8sorr7By5UoAFixYwJIlSzj99NNDnn/ZsmXMmDGDf/zjH/zjH//g008/5fbbby89fskll5Cdnc2iRYtYsmQJd955p0ZdxJGaAELIzPRD/SZNKmsK2Guv7WzdmgJAejqMHAkx/u4Q2c3y5cuZOHEit912W8h0w4cP58ILLwyZJlANvCe2bNnCHXfcwdChQ0lK8l8va9euLW3HDzAzWrduzdo4tJ8tX76cCy64gG7dugGw//77h0z/wgsvcNVVV5W+3rFjB845Zs2aVbrviSee4NJLL404D+PGjaNVq1aMGDGiyuM//vhjabr777+f7t27M3PmTE477TQWL15Mt27dKCoq4tJLL+Xmm2+mW7duLFu2LOx1mzVrRq9evbjnnns49NBDycrK4sUXX2ThwoV06tSpNN3DDz/MVVddRbt27Ur/HR955BHOPvvskOfftWsX06dPp3nz5mzbto1hw4bx9NNPlx5fvnw5o0aNokuXLgAVrimxpwAgjPEl0xMF5gHo3n0d8+e3IyEBRowoOy4SL+vXr+fss8/mlFNO4aabbgqZtmXLlrRs2bJW8pGbm8s555zDvvvuy3333Vcr14iGG264geHDh/PGG29w0kkncf7559OjR4+g6c8991yOPvro0tcPP/wwq1at4k9/+lPpvjZtKi9XEty8efOYPn06S5YsCZqmuLgY8B0Er7jCL4TavXt35s6dy+OPP85jjz3GhAkTSE5OZuTIkRFfG+C5557jiiuuoG3btiQmJnLEEUcwYMAAFi9eXJrmkUceYcGCBfzrX/+iffv2vPvuu4waNYoOHTqErAVo3749zZs3L32dk5PD+vXrS1+PHDmSIUOG8Mwzz3DSSSdxwQUXlAYDEntqAgjDzI/zX70aHnwQTjttHQDNmsGQIXHOnDR6a9eu5ayzzuLQQw/lueeeq/Aruyq11QSQm5vLmWeeCfiOi+WrdbOystiwYQOu3MzdzjnWr19PVlZWta9VXUWV2vGuvPJKli5dyuWXX853331H7969ufPOO4O+v1mzZnTq1Kl0a9my5W77qjPefd68eaxZs4bs7GySkpJISkpi+fLl/P73v6dt27aAnwgHoGvXrhXe27VrV1asWAHA22+/zTvvvEOTJk1ISkoq/TV9zDHHhKyNOOCAA5g/fz65ubmsXLmSRYsWsXPnTjp27AhAQUEBt956K/fddx/nnHMOhx12GNdeey0XX3xxlSMVyqvcQdHMSoMZ8B0ov/rqK8477zwWLFjAYYcdxl/+8pdIik1qgWoAIpSZCUOHwty5eRx4IHz/PcydCx06gJqwJB7WrFnDiSeeSOfOnXnxxRdLq2pDqY0mgG3btnHGGWfgnOONN97Ybd3yXr16kZuby8KFC0v7ASxcuLC0l3+0rV+/HudcaTAUqE4vr23btgwbNoxhw4bxpz/9icmTJ4cMAqLp6quvpl+/fhX2nXbaaQwYMIChQ4cC0KFDB3Jycvj2228rpPvuu+/41a9+BcDTTz9NXmBWMvyIjNNOO40XXniBPn36hM1HRkYGGRkZbN68mTlz5pTW2uzcuZOdO3eSWGkMdGJiYoWb+Z468MADOfDAA7n++usZMWIEf/7zn0trOSS2FABUk5nv9DdhArzyClxwgQIAib3Vq1fTt29fcnJyuPfeeyuMDd9nn312+/IOiHYTwLZt2zj11FPZunUrs2fPJi8vr/Sm1LJlS5KTkzn44IM5/fTTueqqq0qHKF511VWcffbZdO7cGYBVq1Zx0kkn8cc//pHzzz8f8HMMrFixonS+gB9++IEWLVqQlZUVsuZgw4YNjBs3jkGDBvH111/zxBNPUFBQwH//+1+OOOIIbrjhBs444wwOOuggtm7dyhtvvLHbL+3yCgoK+OWXX0pfDx8+HKBC/4XmzZtH1AkPoHXr1rRu3brCviZNmpCVlVVaHmbGLbfcwrhx4zjssMPo3r07L7/8Mh9++CFTpkwBdu+7EAi8DjjggNKaBIAuXbpw7bXXcu211wIwZ84ciouL6dKlCz/88AO33HILXbp04fLLLwdgr7324oQTTmD06NE0bdqU9u3bM3/+fJ599tkaNe0UFBQwatQo+vfvT4cOHVi3bh3vv/9+heYVibFIhgrU1602hpLMnTvXffONc2bOpaQ4t3ixc0VFUb9Mo6BhgHs+DPDpp592QJXb0qVLaym3u5s7d27QfJT/9920aZO79NJLXbNmzVyzZs3cpZde6jZv3lx6fOnSpQ5wTz/9dNjPOG7cuKD5GTdunOvSpYu77LLLXGpqquvUqZObOXOmy8nJcT179nTOOXfttde6Tp06uZSUFNeqVSt30UUXuZ9++sk5V/UwwFBlHdjK53tPVDUM0Dnn7r33Xrfffvu59PR0d+SRR7q33nor6DkCZVh5GGDlMpsxY4br2LGjS05OdllZWe6aa65xW7ZsqfCeNWvWuMGDB7ucnByXmprqOnfu7O6//35XXFwc9PqVh2Bu3bq1whDM7du3uwEDBrj27du75ORkl52d7YYOHVo6XLQ8DQOsqLaGAZor1y7X0PTs2dPVdJ71yubNm8fxx/elTx/48EO45x648UbIyIjqZRqFefPm0bdv33hnI6569uyptQCi6M4772TWrFl88cUXe/R+lWX01HQtgGh/d9dn1f2uNLPFzrmwCyqoE+AeSEiAiy7yz195RUsDi4hI/aMAYA9dfLFv+//oI/jmG9i5M945EhERiZwCgD3Upg2cdpp/Pns25ObGNTsigm8C2NPqf5HGRgHAHjKDQYP889mz4eef/eoAIiIi9YECgBo47TTYd19YtQreew8KC+OdIxERkcgoAKiBtDQ/DwD4WoByQ4VFRETqNAUANWAGJXNnMGcO/PRT+NUDRURE6gIFADV0yCFw9NGwfbtfM2DcOJg2TUMDRaJp5cqV9O3bl65du3LYYYcxc+bMeGdJpN5TAFBDSUmw117++Suv+CmCb7oJcnLgjjvUMVAkGpKSknjooYf46quvePPNN7nxxhsrzIMvItWnAKCGxo6F99/3z53zW16e7xA4aZI/LtKYDB48OOy68dWVnZ3N4YcfDvjVBVu1asWmTZuieg2RxkYBQA1s3gwTJ0JBQdXH8/P98ZK1TEQahMGDB2Nmu22B9e0nT57M888/D0Dfvn1LF6GJlsWLF1NUVMR+++0X1fNG4tFHH2X//fcnNTWVHj16RLR08po1axg0aBD77LMPqampdO3alfnz55cef/fddzn33HPZd999MTOmT5++R9fetm0bN954I+3btyctLY3evXvz8ccf1+jzSsOmAKAGZs2CIIuulUpMBDVXSkNz8skns2bNmgrboYceCviV8Vq0aFEr1920aROXXXZZ6aqCsTRjxgxuuOEGbrvtNj799FN69+7NGWecwYoVK4K+Z8uWLfTp0wfnHK+99hpff/01jzzySIXVAHNzczn00EOZPHly0BUFI7n2kCFDmDNnDs888wyff/45p556KieffDKrVq2KXiFIwxLJikH1daut1QADxo/3qwKWVf7vvpn5dLI7rQYYnVXPqlrBrjYNGjTInXXWWWGPDxo0KOKVCi+88ELXsmVL9+CDD5bu++qrr1xaWpp78cUXnXPOFRYWuuOOO849++yz0fw4FYQqy6OOOsoNGTKkwr5OnTq50aNHB33Prbfe6nr37h3x9TMyMqpcWTDctfPz811iYqKbPXt2hTRHHHGEu/322yO+fjTV5O9SqwFWVFurAaoGoAaysiA9PXSa9HSfTqSxmTx5Mr169eLyyy8vrSUIVm3/0EMPcckll3DXXXcBsH37dgYMGEC/fv24+OKLcc4xePBgfv3rXzNw4MCw154wYQJNmzYNuUVSfR+wY8cOFi9ezKmnnlph/6mnnsqCBQuCvm/27NkcffTRXHTRRbRu3ZrDDz+cKVOm4KrROziSa+/atYuioiJSU1MrpElLS+P9QCclkUoUANRAv37hx/0XFUH//rHJj0isvPHGGxVupmecccZuaZo3b05ycjLp6elkZWWRlZVFYpA2s+zsbG6++Wa2bNnC8uXLGT16NFu3bmXq1KkAfPDBB8yYMYPZs2dz+OGHc/jhh/P5558Hzd/w4cNZsmRJyK1nz7CrpZbauHEjRUVFtGnTpsL+Nm3asHbt2qDv+/HHH3n00Ufp2LEjc+bM4YYbbmD06NGlnyta127WrBm9evXinnvuYdWqVRQVFfH888+zcOFC1qxZE/G1pHFJincG6rPMTBg1yvf2z8/f/XhaGtx8M9RSc6hI3Bx//PEV2uGDtV1XR4cOHWjRogX33XcfTz75JO+++27pevLHHnssxcXFEZ+rZcuWtGzZssZ5qqni4mJ69uzJH//4RwC6d+/O999/z9SpU6PeOfK5557jiiuuoG3btiQmJnLEEUcwYMAAFi9eHNXrSMOhGoAaGj8eRo70SwNnZFQ8dtllfmIgkYYmPT2dTp06lW777rtvVM7brVs3Hn30UcaMGUOvXr32+DzRbgJo1aoViYmJrFu3rsL+devWkRWijS87O5uuXbtW2HfwwQeH7Di4p9c+4IADmD9/Prm5uaxcuZJFixaxc+dOOnbsGPG1pHFRDUANmfkZAEeO9KMCli+HJ56AjRvhsMP8nADNm8c7lyLxkZycTFE15sd2znHIIYcwZsyYGl13+PDhXHjhhSHTVCdoSU5OpkePHrz11lv0L9em99Zbb3FBYEGQKvTp04dvv/22wr7vvvuO9u3b19q1MzIyyMjIYPPmzcyZM4f77rsv4mtJ46IAIEoyM2HoUCgu9tsf/+gDgtNP9zMFmsU7hyKx16FDBxYtWsSyZcto2rQpLVu2JCGh6orHqVOn8u6779K5c+egfQUiVRtNACNHjmTgwIEcddRR9OnTh8cff5zVq1czfPjw0jRTpkxhypQpfPPNNwDcdNNN9O7dmz/84Q9cdNFFfPrppzz88MNMmDCh9D25ubn88MMPgG8yWLFiBUuWLKFly5a0a9cu4mvPmTOH4uJiunTpwg8//MAtt9xCly5duDywYIlIZZEMFaivW20PAwzmm2+ca9LEDwF85x3n8vOjno0GQcMAG/YwQOec+/bbb90xxxzj0tLSQg4D/PLLL11aWpq75pprXEJCgsvLy6uNrIcVriynTp3q2rdv75KTk90RRxzh5s+fX+H4uHHjnP9aLfPqq6+6ww47zKWkpLgDDzzQTZ482RUXF5cenzt37m7DJQE3aNCgal17xowZrmPHji45OdllZWW5a665xm3ZsmUPSiE6NAwwemprGGDcb9K1ucUrANi+3bmzzvKle911zq1aFfVsNAgKAOpnABBthYWFrlu3bm7AgAEuLy/PJSQkuIULF8YlL/W9LOsSBQDRo3kA6pHkZAgMVZ45008ZvHNnfPMkUleNHj2aX375hccee4z09HQOPPBAJk+eXK2OciJSfQoAasmZZ0KHDrB2LcyfD9u2xTtHInXPm2++yZQpU3j++edpXtJb9vbbb+edd95h0KBBcc6dSMOmAKCWZGTApZf65y++CJs2+c6BIlLm1FNPZefOnfTp06d038CBA1m3bh1z586NY85EGj4FALUkIQEGDfKTAb3/Pnz/fdWTBYmIiMRDXAIAM7vazJaaWaGZLTaz48Kkv8bMvjazAjP71swui1Vea6JdOzjnHP98xgw/N4CIiEhdEPMAwMwuAiYDE4DuwALg32bWLkj6EcCfgPHAIcA4YKqZnRObHO+5lBQYPNg//9vf4OefobAwrlkSEREB4lMDMBKY7pyb5pz72jl3HbAGGBEk/UBgmnPuRefcj865l4Angd/HKL81cuyx0KMH5ObCXXfB2LEwbZofGSAiIhIvMQ0AzCwZ6AG8WenQm0DvIG9LASr/bi4AjjKzJtHNYfSlp0NgQrJXX4X774ebboKcHLjjDnCRrwoqIiISNbGeCrgVkAisq7R/HXBykPfMAa40s78Dn+ADiCFAk5LzVVjr0syGAcPAL5c5b968aOUd8NN2Vuecq1fDKacYH37Yi23bkhkx4lMOOOAXwHcUfPFFHww0RtUty4aosLCQbTUcI1pUVFTjc4insoyempRlYWFho/9uKK+2vivrw1oAdwNZ+L4Chg8WngH+H7DbwDrn3JP4JgJ69uzp+vbtG9XMzJs3j0jPuXkznHFGxXb/xx7rXiFNaiqsWdM4lwyuTlk2VKmpqaVL3u6pbdu21fgc4qkso6cmZZmamtrovxvKq63vylgHABuBIqBNpf1tgLVVvcE5VwBcYWZXlaRbg/+Fvw3YUHtZrblZsyDcmiaJiX62wKFDY5MnqVuys7Pp2bNnjc5RWFhIampqlHLUuKkso6cmZZmdnR3l3EhVYhoAOOd2mNli4BRgZrlDpwB/C/PencBPAGZ2MfCqc65OT62zdm34sf/5+T6dNE6vvPJKjc+hmpToUVlGj8qy7otHE8Ak4DkzWwR8AAwHcoDHAczsWQDn3GUlrw8CjgY+BDLxowgOBer8PKFZWb4TYF5e8DTp6T6diIhILMV8GKBzbgZwIzAGWAIcC5zpnFtekqRdyRaQiL/pfwa8BaQCvZ1zy2KT4z3Xrx8UFYVOU1QE/fvHJj8iIiIBcekE6Jx7FHg0yLG+lV5/jZ8wqN7JzIRRo2DSpKqbAlJT/ZDAxtgBUERE4qs+jAKo18aP948TJ/oOf+WbA045BW64IT75EhGRxk2LAdUyM7j7bj8fwIMP+pkATy6Z8WDrVtiyBXbtimsWRUSkEVINQIxkZpYN9VuyBHr1gvnz4ccfYZ99ymYLFBERiQXVAMRBp05w3nn++Qsv+EWCwnUWFBERiSYFAHGQng6XX+6fB1YJzM2Nb55ERKRxUQAQBwkJcOSRcPzxfprgmTNh40YfCEyb5vsMaMVAERGpTeoDECfNmsGQIfDuuzB9uu8Q+PzzfqRAfr6vJbj+ej+McPx435lQREQkWlQDECdJSXDqqXDYYbBpEzzzjK8NyMvzSwTn5fnXkyb5kQMiIiLRpAAgjlq0gIsv9s937qw6TX6+n0Ngy5ZY5UpERBoDBQBxlJLiH8NV7wdWDBQREYkWBQBxVlDgq/xD0YqBIiISbQoA4qxtW78mQChaMVBERKJNAUCcRbISoFYMFBGRaFMAEGeZmXDzzcFrAdLT/VBArRgoIiLRpACgDrj7brj2Wt/ZLyAtzQcFI0eWrSgoIiISLQoA6gAzuPde+Ne/yoKAoUNh8WIfHGgSIBERiTYFAHVEYiIcdRRceKF/vWqVnzJ4+/b45ktERBomBQB1SPPmcOWVfpbA2bNh9Wo/S6CIiEi0KQCoQ5o0gUMO8UsFFxXBU0/5NQJUCyAiItGmAKCOycz0tQAJCX72v/XrVQsgIiLRpwCgjklJ8QsEnXWWXx/g6adVCyAiItGnAKAOatnSjwIA+OtfYfNm+Pnn+OZJREQaFgUAdVBqKnTv7pcL3r69rC9AYWG8cyYiIg2FAoA6au+9YcQI//z551ULICIi0aUAoI5KS4MjjoDTT/e//KdNg23bVAsgIiLRoQCgDmvVCq6+2s8E+MILsHEjbNgQ71yJiEhDoACgDktLg1/9yo8I2LEDHnkEjj8e2rf3NQKbN8c7hyIiUl8pAKjDzKB1axg+3D9/+WVYvhxWrICbboKcHLjjDnAu3jkVEZH6JineGZDQ0tLgjTf8xEBFRWU3+7w8/zhpkn+8++745E9EROon1QDUcVu2wJ//7G/+VcnPh4kTfToREZFIKQCo42bNKlsiOJjERD9tsIiISKQUANRxa9f6X/mh5Of7dCIiIpFSAFDHZWVBenroNOnpPp2IiEikFADUcf36BW//Dygqgv79Y5MfERFpGBQA1HGZmTBqVPBagNRUP1lQixYxzZaIiNRzCgDqgfHjYeRIf7OvHAicdJJfOXDHjvjkTURE6icFAPWAmR/nv3o1PPQQ3HwznH22P/btt/64FgoSEZHq0ERA9Uhmpv+1X1gI330Hn38OP/wAr77qpwtu0cJPHCQiIhJOXGoAzOxqM1tqZoVmttjMjguT/hIzW2Jm+Wa21syeN7NG2+89NRX22QduuMG/vv9+3xFw3TpNCywiIpGJeQBgZhcBk4EJQHdgAfBvM2sXJH0f4DngGeAQ4DygK/BCLPJbV+29t18quFs3f+P/y1/845QpvrlAiwWJiEgo8agBGAlMd85Nc8597Zy7DlgDjAiSvhfwk3PuQefcUufch8AjwNExym+dlJzsg4Df/96/fvhhv1LgjTfC2LFaLEhEREKLaQBgZslAD+DNSofeBHoHedsHQLaZnWNeK+Bi4PXay2n90LIl9OgBnTrBrl1+JEBxsT+Wl+f7Ckya5AMCERGR8mJdA9AKSATWVdq/DqiyTd85txB/w38B2AFsAAwYVHvZrB+Skvw6ACtWBE+jxYJERKQq5mJYP2xmOcAq4ATn3Lvl9o8FLnXOda7iPV2Bt4CHgDlANnA/sMQ5d1kV6YcBwwDatGnT46WXXorqZ8jNzaVp06ZRPWdNbNwIK1fCP/95APPn78cBB2xm+PDPMCtLk5AA++0HrVrFL59VqWtlWV+pHKNHZRk9KsvoqW5ZnnjiiYudcz3DJnTOxWwDkoFdQP9K+6cC84O85zngH5X2HQs4oG2o6/Xo0cNF29y5c6N+zpoYP945M+d8S3/Vm5lPV9fUtbKsr1SO0aOyjB6VZfRUtyyBT1wE9+SYNgE453YAi4FTKh06BT8aoCrpQOXZ8AOvG/1ERlosSERE9kQ8bqCTgMFmNsTMDjazyUAO8DiAmT1rZs+WS/8K8BszG2FmHUuGBT4M/Nc5F6L1u3HQYkEiIrInYh4AOOdmADcCY4Al+Or8M51zy0uStCvZAumn44cOXgt8AcwCvgN+E6s812XhFgtKS/PrCGixIBERKS8uUwE75x4FHg1yrG8V+x7Bj/2XKowf7x8nTvTrAhQU+NcJCXD55XDNNfHLm4iI1E2Nvg29ISi/WNDdd/ubfpMmfk6AE0+ErVv9cEAREZEABQANSGYmXH89jB7tH8FPAtSkCaxdWzZJkIiIiAKABqZJE79Q0KBB0K4dfP01vPiinylQkwGJiEiAAoAGqHlzyMiAMWP86/vu81MDb9jgpwsWERFRANAAJSRAmzZw7LFw0kmwbRvcdZevHdCSwSIiAgoAGqyMDNhrL78aYGoq/POf8NFHvjNgbm68cyciIvGmAKAB22cfPwPgyJH+9W23+dqBdet8nwAREWm8FAA0YMnJsPfecMkl0KULLFsGI0bA1Knw0EOweXO8cygiIvGiAKCBy8yElBQ49FD/+u23/c1/7FjIyfFNBOoTICLS+MRlJkCJncREmDYNXnut4v7AbIGTJvnHu++Obb5ERCS+VAPQwG3eDA8/XHbDryw/308hrDkCREQaF9UANHCzZvlagFASEmDmTBg61AcMs2b5mQOzsvxqg5mZscmriIjEjgKABm7t2vDrABQUwKpVvj/AxIl+sqDiYj+U8Prr/WqD48f7NQdERKRhqFYAYGbHAKcDxwA5QBqwEfgWmA/Mds6pb3kdkpXllwrOywueJjUV3n8fFi6EwsKy/YH3qJ+AiEjDE1EfADMbZGafAwuAm4B04HvgI2AzcDTwZ2CVmU03s/1rKb9STf36QVFR6DS7dsF77wWvKVA/ARGRhidsAGBm/wPuBV4HegAtnHPHO+cucM79zjl3pnPuYKAlMBRoDXxlZhfVZsYlMpmZvgo/PT10mnD9BBITfT8BERFpGCJpAngKeMI5VxgqkXPuF+AF4AUz6wZkRSF/EgXjx/vH8u37aWm+ZsA5WL8+/Dny831/AhERaRjCBgDOucnVPalz7jPgsz3KkUSdmW+/HzmyrId/ZiYcdRS88w7cemv4c6Sn+/4EIiLSMGgUQCOSmemH+gWsWeP7CLz6KnzwQej3FhVB//61mz8REYmdiCcCMrPzzOxpM/vIzL4v2T4q2XdeLeZRask++/jHBx/00wUHk57u+xG0aBGTbImISAxE0gkw08zeB/4OnIgf9vdhybYR6Av83cw+MDNNGVOPJCVBmzbQrBncf3/Z/sB4//R0P0Rw5MiyfgQiItIwRNIE8ADQDjjBOfdeVQnM7FjgeWAicGX0sie1rVkzv51+Opx5Jrz+Ouy/P/zmN/4X/7BhavsXEWmIImkCOBcYFezmD+Ccex/4PXBelPIlMdSmjf/Vf8890KoV/PijHyVw2WW+93+4eQRERKT+iSQASMFP9hPOFiC5RrmRuEhK8r/y09LKZv277z746it/89+4Mb75ExGR6IskAFgI3G5mzYIlKDl2K36mQKmHmjb1owR69YIrr/SzA15zjT+2eTNs2xbf/ImISHRF0gfgRmAesNzMXgO+oKxGIBM4BDgLKMJ3EpR6qlUryM2FW26BBQvg66/9AkH33++HDKakQLLqeEREGoSwNQDOua+AbsAzQC9gAvB4yTYB6AM8CxzunPuy9rIqtS0xEbKz/eyAU6b4EQAzZvh5ApKSYPVq+Pln6NzZdxScNs3XDoiISP0T0TwAzrk1zrmbnHOdgAxg35KtqXPugJJjq2szoxIb6emw997Qti2MHev3jR4N69b5fgH77gs//ADLlsFNN0FOjq8lcC6u2RYRkWqq9kyAJWsCrKmFvEgdsffefingiy6C+fNhzhw4/3z45RfYvr0snZYLFhGpvyKZCOi31T2pmWWb2TF7liWJt4QE3xSwc6dv/8/J8TUAhUGWg9JywSIi9U8kTQCPmNkSMxtuZi1DJTSz48zsSeAH4LCo5FDiIiXFDw1s0gR+G0EIqOWCRUTql0iaAA4ERgHj8cHA1/iV/jYA2/EjAToCPYHmwLvAKc45DQms5/bay48KSEwMn1bLBYuI1C+RLAecD4w3s3uB84HTgaOBHCAV+Bn4BpgMzHDOfVN72ZVYMvOzBO6zjx8REKwJALRcsIhIfRNxJ0Dn3A4zexv4Z0lHQGkEkpJg8ODwHfy0XLCISP0SSSfARDO708w2A+uArWb2NzNrUeu5kzph333h2mv9VMFVSUvzQwK1XLCISP0RSQ3AcGAsfjbAj/Ht/ecDW4HLay1nUqfcd5+fHvjxx2HHjrJx/02awBVXwNChvhYgkv4CIiISf5GMAhgKTHPO/do593vnXH/gGuB3ZqaJYRuJhAQ/1G/BApgwAY44wu/PzIQhQ/zNf+1aTQgkIlJfRBIAdAQqD/CaASQC7aOeI6mzkpLg4IP9pECzZsExx8D69XDVVf7Ytm1+qmAREan7IgkAmuKr+8sLrA0XdIVAaZjS0qB1az8j4OOP+57/ixb56YCbNvVLB2+t/NciIiJ1TkRrAQD7mlnHwIavFdhtf8mxsMzsajNbamaFZrbYzI4LkXa6mbkqtrwI8y5R1qIFNG/uh/79+c9+0qDnn4fp030QsGYNFBTEO5ciIhJKpAHALOD7cltgrP/sSvu/D3ciM7sIP2fABKA7sAD4t5m1C/KWG4DsStuPwMsR5l2izMzXAjRp4psEHnjA7x83Dv79bzj9dDjwQHjsMa0WKCJSV0UyCiDaPf1HAtOdc9NKXl9nZqcDI4BbKyd2zv0C/BJ4bWZ98DUQA6OcL6mGxES/RsCyZXDOOfDdd/DwwzBsmA8QnIObb4aRI2HUKBg/3u8XEZG6IZKZAJ+J1sVKRg30ACZWOvQm0DvC0wwFvtRUw/GXnOznCFi50r9OSIDi4rKRAIFmAK0WKCJS95iL4bgtM8sBVgEnOOfeLbd/LHCpc65zmPc3xy9FfKtzbnKQNMOAYQBt2rTp8dJLL0Ur+wDk5ubStGnTqJ6zvtuxA774AgoLE5g6tTurVzejY8ctDBv2GUlJ/u/LDLp1qzhPgMoyOlSO0aOyjB6VZfRUtyxPPPHExc65nmETOudituHXD3DA8ZX2jwW+jeD91wCFQMtIrtejRw8XbXPnzo36Oeu7J55wLj3dOf/bv+otPd25J5+s+D6VZXSoHKNHZRk9KsvoqW5ZAp+4CO6RkXYCjJaNQBHQptL+NkAka8kNBf7mnNsU7YzJnlu3Lnyv/4ICWLo0NvkREZHwYhoAOOd2AIuBUyodOgU/GiAoMzsK6AZMC5VOYi8ryw8JDCUtza8oqDkCRETqhljXAABMAgab2RAzO9jMJuObBh4HMLNnzezZKt43DPjeOTcvdlmVSPTr56cCDmXHDrjgAli9GnJzY5MvEREJLuYBgHNuBnAjMAZYAhwLnOmcW16SpF3JVsrMmgEXA3+OWUYlYpmZfqhfqFoA5+D77yEjA1at0kRBIiLxFsk8AFHnnHsUeDTIsb5V7NuGn5JY6qjx4/3jxIn+135xsa/2LyrykwJ9+SUMGgR/+5t/vXKlFg4SEYmnuAQA0vCY+XH+I0f6hYLWrvXTAh97LLRpAyNGwOuvw6WXwuzZfhKhHTv8mgIpKfHOvYhI46MAQKIqMxOGDvXPnfOBwLZt8MgjsGWLX074oov88VGj4JNP/HLCbSqPCxERkVoVj06A0kiY+Rt7WpoPBp56yq8hsHKl37ZsSeIPf4D27eG229QkICISSwoApFYlJPjq/sREmDKl4jDAadO6UVDgmwEeegjGjIlbNkVEGh0FAFLrEhN97/8//xkKC8v2//RTs9LnBQV+VcENG+KQQRGRRkgBgMTE7NkV1wEAaNGisMLrhASYNg127oxdvkREGisFABITa9fuPvZ/+PAlFV4XFPgagJUr/QgBERGpPQoAJCaqmi64VavdawBatfLPFQSIiNQuBQASE5FMF1xcDP/8p0+XkAArVvgOgiIiEn0KACQmwk0XnJLiOwp+/DEMHOj7ASQl+SCgsLDq94iIyJ5TACAxM368nykwNdX/wgcfEKSkwFVXwb//7ZsKPvoIevSA/v0hORmWL9faASIi0aYAQGImMF3w6tXQqZO/uT/0kF8k6OqroUMHv1ZAdrZfMfCzz+Avf/F9AVas0CqCIiLRpABAYi4zE779Fn71Kz9t8H77+cmCcnNhxgz4+WefbudOHzD07AmPPuo7Bv7yS3zzLiLSUGgtAKkTmjWD6dP9PADle/87518/8YR/PWKE7yTYsmVcsiki0mCoBkDqhM2b4eGHg7f1b98Ojz3mRwp8/z0ccIBvMpg2zb9XRESqRwGA1AmzZu0+U2BlO3f65YRPOAGWLfOdA2+6yTcf3HGHFhMSEakONQFInbB2LeTnh0+3ZEnF13l5/nHSJP94993+sW9f/zhvXhQyJyLSAKkGQOqEqmYKrI78fJg4EbZs8U0Ca9b4GgI1EYiIVE0BgNQJkcwUGI4Z/O53vknghx98M4GaCEREqqYAQOqEcDMFJkXQWFVQAHPm+JkDi4v9vrw8/3rSJBg7Nnr5FRGp7xQASJ1R1UyBGRn+9amnQlpa+HPs2lX1/vJNBCIiok6AUocEZgocOdKPCli71vcN6N/fV9/n5NTs/ImJMHOmn3xIRKSxUwAgdU5mZtU36VGjfFV+JKMFqpKf74MKERFRE4DUI1U1EaSl+TUF2rcP//70dF+jICIiCgCkHqm8mFC7dnDbbbBoEbz+eviOgkVFvjlBRETUBCD1UGAxIfBTBK9a5fsIXHMNPP6431dZWhpccUVkHQlFRBoD1QBIvZaS4msCkpP9QkHDh/vn5SUm+j4FN9/s5wb45RfYtAk6d4b999dkQSLSOCkAkHovKQn23dfXDFx1FSxeDPfeC8cc448XFcHXX/t5AtLTYfRoTRYkIqImAGkQEhKgdWvfQXDNGrj4Yhg4EP7zH7jhBnjrLT+XQO/e8OqrFZsJgq0nICLSkKkGQBqUvfbyIwJ27fK/+E8+Gf79b+je3fcVmDkz+JLDmixIRBoTBQDS4KSm+iAgORm2bYP99oO//90vIxxOYLKgcDZvVh8CEanfFABIg5SUBG3bQqtWPghISIAjjwz/vvx834QQ7AbvnO8roD4EIlLfqQ+ANFhmsPfefujfqlXQooXvBBhqJsGUFJg/H/74R9ixwy8qdNNNcP31fiZC8H0FCgvL3qM+BCJSH6kGQBq89HTo0AHOPTf8ksM7d8KCBVWvKPjAA350QbAAQn0IRKQ+UQAgjUKTJnDooXDttaEnAyourvjrvryCguCrDQZE2odARCTeFABIo2EG99/vhwWmpFRcTyAx0R+vaRu+FhwSkfpCAYA0Kma+ff+nn3yzQE4OjBsHn3/u5w2oKS04JCL1hToBSqPUqhX83//59v01a/y+Qw/1tQHB5gmIhBYcEpH6Ii41AGZ2tZktNbNCM1tsZseFSZ9sZuNL3rPdzFaY2fWxyq80XBkZviYgIwOOP76s418wiYl+noGqpKf7kQItWkQ7lyIi0RfzAMDMLgImAxOA7sAC4N9m1i7E214CTgeGAZ2B/sD/ajmr0kgkJUF2NnTtCldeGbqTYK9eMGRIxT4E6ek+KBg5EsaPj02eRURqKh5NACOB6c65aSWvrzOz04ERwK2VE5vZqcBJwAHOuY0lu5fFIqPSuDRrBg895GcQfOwxPySwuNjf3ANzArz/Pqxf75cdHj/e77/qKr/2wP77+z4GIiL1QUxrAMwsGegBvFnp0JtA7yBvOw/4GBhpZj+Z2fdm9rCZNa29nEpj1aQJPPign+WvXTu/yuBdd8EXX8Bzz/nmgu++g8svh27d4B//gCuu8Df+pUv9UsOBZgRNFywidZm5GM5damY5wCrgBOfcu+X2jwUudc51ruI9bwB9gbeB8UAL4BHgf865flWkH4ZvKqBNmzY9Xnrppah+htzcXJo2VewRDfWhLHft8ltCgr/J79iRwMsv78dLL7Vjx45EUlKKuPDCFfTvv5LU1OLSm//GjbBuXdmwwoQE/zwry488iKb6UI71hcoyelSW0VPdsjzxxBMXO+d6hk3onIvZBuQADji+0v6xwLdB3vMmUAA0L7fv1JLztAl1vR49erhomzt3btTP2VjVl7IsKHBu6VLnvvnGuRUrnFu1yrkPP3Tu7LOd87d153JynJsyxbmVK5277jrn0tLKjpXf0tOdGzMmuvmrL+VYH6gso0dlGT3VLUvgExfBPTnWnQA3AkVAm0r72wDBpk9ZA6xyzv1Sbt/XJY+hOg6KREVgdcGsLD9LYH6+X2joiSfgb3/zwwdXr/azDJ5+uu8foCWHRaSui2kA4JzbASwGTql06BT8aICqfADkVGrzP6jkcXl0cyhSNTNo3ty35zdr5lcY3L4djjkGXn/drxOQlQVffuk7D4ai6YJFpC6IxzwAk4DBZjbEzA42s8n4poHHAczsWTN7tlz6vwI/A0+b2SFm1gc/jHCWc259rDMvjVtSErRp4zsDJib6QMA5Pwrg/ffh2GPDnyM/369OKCISTzEPAJxzM4AbgTHAEuBY4EznXODXfDvKVe0753KBk4Hm+NEALwPzgStilmmRSlJTYb/9fIe+XbsgN9fPDXDuuaHnEQi8NzHRDycMV1sgIlJb4jIVsHPuUeDRIMf6VrHvW3zHP5E6w8w3B2Rk+OF/GzfCiSfCHXeEfl9REVxwAWzd6ocGtmgBmZl+/gERkVjRYkAiNZSQ4G/g++/vmwauuCJ0LUBREdx7r7/5N23qmxF+/NGvIrh9e8yyLSKNnAIAkShJSvKLDD30kJ8dsPJ0wU2awEEH+YmCnnsO+vSBm2/2IwiaNfMLEy1d6lcqrMmCRCIikVAAIBJlycl+NsFly/zwwZwcuO02+OwzmDsX3nkHzjvP1wTMmAEnnADDhvkZBvfay08vvHy5f39eXtlkQiIi0aQAQKSWZGX5qv0ff/RTB5v5X/YHHQRTp8Krr/pf/uCHEp55JvTrB++955sGwNcG/Pij72NQVBS/zyIiDY8CAJFalpLiawH239/3Ddi6FSZMgPPP97/wwTcfACxcCIMH+86EL7/s9ycn+2mF/+///MgB9RMQkWhQACASI4FA4Nln4S9/8TfywNoBu3b5x6Qk/+v/hx/g97+Hnj19h8EtW/xog61bfT+BFSvUPCAiNaMAQCSGNm/2/QOCdfLbtcv3Abj/fjj8cH/jf/RR6NULhgyBTz7xAUJxcVnzQFFR6PkE+vb1m4hIeQoARGJo1iw/CVAoiYn+l/1rr8Err/imgsREeOMNGDAAjjvO1yDs3OmbB3bt8oHATz/5WoFArQL4gGPNGt+pUEsSi0h5CgBEYmjtWj8VcCiFhf5mvm4dXH89fPwxjB4N11wD2dl+dMDdd0OPHv74Z5+1ICPDBwSBWoENG/zIg5wc35ywbBncdJN/fccdajoQkTjNBCjSWGVl+TkBAp3/qpKW5ocE9urlb+rFxX6xoaIiP1ywe3d4/nk/pHD2bJg9+3CmToWLLoL+/X2QcOed8PTTPpgICFxz0iT/ePfdtfUpRaQ+UA2ASAz16xd+ON/27fDuuxU7Cebn+9d//rOfT+C55+DNNwPTCBeyYoXvN3D00T4IePJJLUksIqEpABCJocxMGDXK1wJUJS3NzxcQrJmgoAAeewzGjYOzz/ajAm699cPSWQcTEuDDD8tGFQSTkAAvvFCxv4CINC4KAERibPx4GDnSrwoYmCo4I8O/PvFEP1wwlOJieOaZshqChISy502a+PkGwiko8M0MP/xQ1i9BwYBI46IAQCTGzHz7++rV8PjjPiB48EHfW/+YY8J3Ety1K/iwv8JCWLky/JLEiYn+PGlpvm/ATz+VBQN5eZp1UKQxUCdAkTjJzIShQyvui6STYDhJSaHnBQB/83/0UT8ssaDA1zqMHAmnn+6nHTbztRLNm/uaiSR9U4g0OKoBEKlDIukkGM727XDUUcFrAVJS/EiCZs381MLbtsHGjX7YYM+efoVC5/yERKtX+ymIly3zcwhs364hhCINhQIAkTokXCfB5GTfzh9KejoMGuRv5OX7GaSl+Zv/8OFw/PFV1xIUF/sJiA45BK680tcQbNniawQ2bvQTCgXWJFBTgUj9poo9kTpm/Hj/OHGi/xVeXOyr44uK/GRAU6eGruIvKoILL/RDBEeO9DfxNWtg773h5JP9yIHjjgu9qFBRkZ9nYO5cuP12OPBA+PWvfSfFnj19rUFgVsG0NF+bEAgwzHY/X2Aq4nnz9qBARKRWKAAQqWMCnQRHjvSdAnfs8NXz/fv7m3pamp/Mp6rOgunp/n0tWvjXVfUzeOKJ8NMRp6X5YYZ5eX5Ogu+/99sTT/hjvXr5m/oJJ/h+Aiec4IOS4cPht7+Ftm197UOTJr4GYc0a/zmmTfPNHJmZNS8nEakZBQAidVRmJnz77e77K9cQQFkNwciRZceDWb8++CRBAYWF0L69nz54504/HXGgRuDrr+Gdd/xW2R/+APfcA1dcAdddB1OmwFNPlc1oeNNNfvriUaN8PquqLRCR2FAAIFLPlK8hmDXLrw744INlNQThRDLSIDXV/7L/6Sc/xfCuXf7GPWtW2UyFjz22e4ASmHr4ySdhzhxYtapiU0P56YiLinzAYKYmApF4UCdAkXoqUL2fne0fI7n5Q2QjDYqLfRv/CSfAihU+EBg3Do44wq9EeNJJfmRAMEVFflGiYP0M8vN9ELB4MXzxhT//0qW+iUErForEhgIAkUYm3EiD9HQ48kg/SVFhYdkMgQUF/ob+1FNw7bVlowv2VGBxox49/M1/xQrfRJCd7R+3bau4HoKIRJeaAEQaoVAjDUaM8CMNyq8kWF5BAXzwQc2HAO7aBZ9+uvu5wQcf27fDDTf4JoKUFJ+/tDTfsbBJk+r3H4hFM4OaMqQ+UQ2ASCNUfjriTp2gQ4ey6Yg7dw4/SiAhIfx8BDVRWOiDgAkT/KqH55wDZ5zh+xQsXepHJCxfDhs2QG5u+JqCzZv9Z1u+3I9EqI1mhlhcQ2Krb9+yoK4hUgAg0ogFRhosXVrWjyCwOFAogVqD2uQcPPusH03w+ee+v8Cpp8Kdd8I//gFLlsC6dT6IWbbMr2WwdKnP/y+/+NqEHTvgjjsgJ8cfX7bMNy/k5Pj90ZjV0Lnav0Z5Df2mFCvhyrExBHQKAESkgsAogVAyMuC000L3Izj22ODHI11boG3bsr4Gzvkv45degtGj4bzzoFs3OPNM36dh2jR4+20/THHNGr8o0o03wgMPVOzLkJfnX0+aBGPHll2rb1+/QmJ1jR3rzxXJNWqqMdyUYiFUOcY6oIsr51yD3Xr06OGibe7cuVE/Z2OlsoyOaJfjpk3OpaY657/qqt5SU326MWP884QEvz8jw78eM8a5oqLgx8880z8PdY2kJOeaNKn6WGKic3vv7R+D5a9r17LrBttSUpz77jvnli1zrlMn5x5+eK57/HH/2aJZVps31+zfpLg4dFkXF9fs/LWhLv7/jqQcx4xxLj296n/L9HR/PNaqW5bAJy6Ce6RqAESkgkhGCYwa5dMF60dw993+l3uwZY+ffz58J8JQyx4XFfm2/08+8fMNPPQQXHWVH7bYpo3/9f3VV+GbKYqL4eKL4aCD/LDFHTvKRiLceKNf/2DbNt+ccPzx/vzlzZoVvr9EYiLMnBk6TTixrGVoyMKV4y23+I6xwZrA8vP98S1bYpblWqVRACKym1CjBCrPNhhsxsLyxytPRww+iAg2pXFysv/NFWrNg4QEeOUVGDDAr1VwwQVlzQVbtvgZCV98MfTn3LkT/vvfstePPNK9dCTCo4/6+QlGjfKdJleu9OknTIDf/AZat/ZVyOH6S+Tn+34Je2rzZv/vEGxURuCmFFjFsfz00fV52uVoj6iIpBwnT/Z/e6EEArqq/qbrG9UAiMhuQo0SuPvu6EzhO368DybKr1iYkeFf9+rlawBCKSz0N7qWLf2X93HH+WWQn3rK/6o75JDgSyIHs3x589LnO3fC3/7m83LMMb4teNUqPyHS4YfD5Zf7zoYpKaHPmZbmF2LatcvXIFS3A18ktQwJCfC739W83XrzZj8KZP/9g/cxiCRNTdVGX4dIytEs8oAuFuVQ6yJpJ6ivm/oA1G0qy+io7+W4aZNzTz7p3Pjx/nHzZv8Yro9ARoZzTzyxe5tuerp/fc01vo0/1DkqbyNG/Lda6SPZkpOd+/BD5xYtcq5DB+f23de5e+917ptv/Gffts25vDznCgud27lz9/b88eOdMwt/nWD9JSJpt46kbby6/RCC/V1u2uTcQQf5snjyyYr9LWqzr0NNy7F8eZ51Vmz7Y9RWH4C436Rrc1MAULepLKOjIZZjpJ3rRo0K3WHr2GODH09K2n3fxIlzq3VzNwveEbFyuvKvExP9dtJJzk2f7tzrrzu3eLEPCr791rnvv/cdE1etcu6BB4J/hki3cB0RI+n4Vt3OcZX/LuPdAS+SoDI9PXwAkJgY+06CCgD2YFMAULepLKOjoZZjuJvBzTeHDxJSUnyQEOlIhOoGAOnpzv3xj84NGeJvHIEbfVKSv17r1tW7eael+V/GRx3l8zdwoHMjRlQdrFRnC9SWOOfcCSf4LSCSYCslpXqjHU44wbknnpgb9X/PSEdUVFXLEI2gMi0t/L9FNEZ9VFZbAYA6AYpInRSuI+J++4Vv001K8j38V6/2bcBr1/p5Dvr391/XOTk1y2NBgW+rvuUWv67BnDnw88+wzz5w9tm+bb5nz9DnMPPzHWzc6M+3bFnohZb2RF6eX3Rp8WLfrr5rly/X3/wGXnst/LoOgdtbKIHOcf36+TLZvt23jffr54/HogOec76nf/m/mfJLUIfqeJqeXtbBNTW16r+7E0+E+fND90+pT50EFQCISJ1Uednj8jfvFi38sUg7bNXWSIT0dDj4YGjf3t8gunTxN40dO/z7nn8+/M01NdUvrnTppX5o47p1sH69n+Y4sK1fD4sW+Zt3uBtxMFOmwCOPlL3+/e/9ts8+kc38GE5eHjz3nL/ZBsrg1lv961//Orod8IIpP8yvfL7A77/pJv/3FGp0S6i/u0cegX//O/I8hhvJsHlzfEdtKAAQkTot2M07MGNh4Au+KunpPl0wlWsZoOyGcM01flGkUAFAUZGfRyDYSICiouC/egMKC/0v5rw8f/PJyqqY54QEvz8hwc9J8MYbPiDYay+/auOmTTB4cPhRE5UDh8A4+HXrQr8vUgkJsGBB2fwOy5btVfpvM2dO+Hkfdu7060uEC7jatPHPK99cIxnm98ADvqyDBZXlVfV3V52/ucBIhh07ympCAjf3cDUVgUCktikAEJF6qV8//4UZSlGR/3IPpvKvvaZN/XDHwA0hLS18lXHlG0d5kd4wunb1cxkUF/s8l3/ctatsUqSEBP+5y9/sDzjA36imTy9bTbG81FT/3pqu3hhO5UmXpkw5ovR5JNdOSAgfxOzY4f9NXn4Z/u//fPrx431Txpw54WtbEhLghRfgiitg4ED/7x/YAtcuv6/yTTiSv7ldu/yU0jk5wW/u4WoqwP9d1ra4BABmdjVwC5ANfAnc6Jx7L0javsDcKg4d7Jz7prbyKCJ1W2DGwprcoMufa+hQ/2uy/Dj96kyIVJXqBClmcNJJfl8kk98UF5dtDzzgawQmTy7LZ3q6P3evXvDhh1UHBwFJSf76Vf36Tk31N8wdO3wV//btu6dJSNi9n0C7dltZsWKv8B+k3OcJZ+dOuOyyivvGjfObWfjmkfx8P8HThx/6Jp7UVF97k5LiXweel9+Xmlox7cUX+/UoqqppSE+HX/1q9+W0y9/ct22DJ56IbGKnSP52aySSnoLR3ICLgJ3AUOBg4BEgF2gXJH1fwAFdgaxyW2K4a2kUQN2msoyOxlyO0R43HmrseuW5CiIV6dC2UOPjI1X5HJs3Rz7+vU+f3edTSElx7tprnfvhBz9EccQIvy+QJi3Nvz7yyN2vUdWIimBDJpOTnTvlFOfuucfno3y6xER/vXbtnMvOjuyzxGtLTg6fxiz8GhUZGf7fL9zfZTDU4VEAI4HpzrlpJa+vM7PTgRHArSHet945t7HWcyci9Ub5KvzynamqatOtiWD9ECIRrhbhrrv8bH3RaA+ualrmSJohMjJg0CA/tXKocpw61eend2+f5v/9P/jtb/2MiV9+GboTX2CGxwUL/C/54mJfnV9c7GsYbrjBp+vf38+wOGeO7wC5zz5w+un+1njccXveCRJ8Tccdd/jy3L7d/wqv/BjowFjV6+3bK77Oza2Yn0g6SwZu86HUdProSMU0ADCzZKAHMLHSoTeB3mHe/omZpQBfAfc456pqFhCRRijcegTxFG40wx131G57cHWaIVq0CF2OZtCq1e7LJl9yiQ9Wwvn73/3NLxBk3Hqrz1/z5n5/cXHZDfLQQyv+Ln766ciGfQZrykhL850lL77Yv3Zu98Cqqn3lle8XEHh0zpffrl0+QHrssfDlkJgYul9EuM6r0RLrGoBWQCJQud/pOuDkIO9Zg68d+BhIBgYCb5vZCS5IvwERkbqmqlqE6iz0s6c1GtHsKxGta+xJsLZlS+h+DFC23sJHH+1e23LzzXDnnT5d+cAi1OvKzwN9LoI979jRf9ZwNSHhOjuG67waLeZqUp9S3YuZ5QCrgBOcc++W2z8WuNQ51znC87wO7HLOnVvFsWHAMIA2bdr0eOmll6KS94Dc3FyaNm0a1XM2VirL6FA5Rk+sy3LjRr/KYKgOcAkJftKjVq1qdq3Vq33tQ+ArP9BxLyur5hMiVXWNtm1zWb26adSuUZ2yysyEb77xabOz/etwtQfRUFQEn30WuorfzK8kuWFD1Z8lIcEPdSxfXtX9uzzxxBMXO+fCTEFFbDsB4n/B7wL6V9o/FZhfjfOMA74Ol06dAOs2lWV0qByjJ9ZlGUkHPTOfLhqq6iQYbYEOk3/969yoXiPSqXxr4zNVRySdPqO1sFIwRNgJMKbLATvndgCLgVMqHToFWFCNUx2ObxoQEam3Ah30Qolme3Cgr8TSpb45ojaGmQWaOrKzo3uNQDNDsPJKT/fHa33oXBihlrmuPNtgbS63HYl4jAKYBDxnZouAD4DhQA7wOICZPQvgnLus5PWNwDL8fAHJwO+A84ALYpttEZHoisZkRo1JTedliIVwnT7Li3fn1ZgHAM65GWa2NzAGPxHQF8CZzrnlJUnaVXpLMnA/0BYowAcCZznnXo9RlkVEakUsOug1JNW5ucZbTYaOxkpcZgJ0zj0KPBrkWN9Kr+8D7otBtkREYq4+/Kqta+rDzbU+0FoAIiJxVJ9+1UrDogBARKQO0K9aibWYjgIQERGRukEBgIiISCOkAEBERKQRUgAgIiLSCCkAEBERaYQUAIiIiDRCCgBEREQaIQUAIiIijZACABERkUZIAYCIiEgjpABARESkETLnXLzzUGvMbAOwPGzC6mkFbIzyORsrlWV0qByjR2UZPSrL6KluWbZ3zu0TLlGDDgBqg5l94pzrGe98NAQqy+hQOUaPyjJ6VJbRU1tlqSYAERGRRkgBgIiISCOkAKD6nox3BhoQlWV0qByjR2UZPSrL6KmVslQfABERkUZINQAiIiKNkAIAERGRRkgBQDWYWTsze8XM8sxso5k9bGbJ8c5XXWZm3czsRTNbaWYFZvatmf0/M0uolO5XZja/JM0qMxtrZhavfNd1ZtaqpJycmbWqdExlGSEz+52ZLTGzwpL/089WOq6yjICZHWlm/zGzLSXb22Z2VKU0KstKzGyymX1S8ve3LEiasOVmZheY2Vdmtr3k8fxIrp8Uhc/QKJhZIvAa8DNwHLA38AxgwHVxzFpd1wPYAAwEVgBHAdPwf3sTAMxsL+At4F3gSKAL8DSQBzwQ+yzXC08DS4Cc8jtVlpEzs+uBW4FbgA+BNOCgcsdVlhEws6bAG/jvx2Pw34m3A3PMrJ1zbpvKMqgE/H3kV8CplQ9GUm5m1guYAYwD/g78FphpZn2ccx+FvLpzTlsEG3AGUAzsV27f74BCYK94568+bcB9wOJyr0cAW4G0cvvGAKso6aiqrUL53QC8DfwacEArlWW1y7BFyZfoKSHSqCwjK8ueJX+H+5fbt3/Jvp4qy4jKcBSwrIr9Ycut5Ob/VqX3/Qd4Mdx11QQQuV7A1865leX2zQFS8L9yJXJ7AZvLve4FvOecKyi3bw7+122HGOarzjOz7sDvgcvwAWllKsvInAokAm1KqkxXmdk/zKxjuTQqy8h8i6/lu9LMUswsBRiKr/H7siSNynLPRFJuvYA3K71vDtA73MkVAEQuC1hXad9GoKjkmETAzI4ABgOPldtdVdmuK3dMADPLAF4CrnPOrQqSTGUZmY74778xwEjgfKAJMNfM0kvSqCwj4JzbBvQFLgTyS7aL8LUrgRuXynLPRFJuwdKELVcFABIzZtYZ3074kHPub/HOTz30MPC+yi4qEvA3/Oudc2845xYBlwKtgXPimrN6xszSgL/g+1EcA/QBPgX+WRK0Sh2lACBya4E2lfa1wlcjro19duoXM+sCzANecs6NrnS4qrJtU+6YeCcBg81sl5ntwvcDAFhrZn8IPEdlGYk1JY9fBXY4534BVgPtSnapLCNzCXAAcLlz7mPn3Icl+9rha1ZAZbmnIim3YGnClqsCgMgtBA42s7bl9p0CbAcWxydL9YOZdcXf/Gc6526qIslC4DgzSy237xT8l/GyWs9g/XEq0A04vGQbUrK/L752AFSWkfqg5LFzYEdJb/ZsypYQV1lGJh3f4a98n5Tikn2Be4zKcs9EUm4LS/ZRKc2CsGePd+/H+rLhf+l/DrwDdAdOxvfEfCTeeavLG3AIvj3qJXybVOlWLk1zfLT6EnAofhjLVuDmeOe/Lm/4G3/lUQAqy8jLbzbwBb7Kuisws+RLNV1lWa1y7IIfDfUYcHDJ//nngF+AtirLkGXXCR/MT8Lf1A8v2ZIjLTd8Z79dwOiSf4tbgZ3A0WGvH+8CqE8bvkrrVXwnl5/xv7pS4p2vurwBd5bcpHbbKqX7FX6sayG+enYcGh4Urmx3CwBUltUqv2b4OSk24UelvAIcoLLco7I8BXgf2FJSlnOB3irLsOU2L8j3Y4fqlBvQD/gG2AF8Dfw2kutrMSAREZFGSH0AREREGiEFACIiIo2QAgAREZFGSAGAiIhII6QAQEREpBFSACAiItIIKQAQqafMbLCZuXJbnpktK1nV7kIzsz08b9+S8/WNbo5DXrPCZ6mla4wpd42fauMaIvWJAgCR+q8/fknQM4E78NNTvwi8VbJQS33yW/xnqQ1Pl5z79Vo6v0i9khTvDIhIjS1xzv1Q7vVzZjYTP7XtfcB18cnWHvnUObesNk7s/BLKq8xsQ22cX6S+UQ2ASAPk/JLB/wSGllvfHjNLN7M/mdlSM9tR8ni7mYX8LjCzU83sdTNbY2b5ZvaFmd1sZonl0rxiZp9W8d79zazYzIZX93OYWYeSKvvBlfbv1kxhZqeZ2QIz+8XMcs3sWzMbW91rijQWCgBEGq7XgRSgJ4CZJQFz8KsITgbOAP6Mbza4P8y5OuKXH74COAt4Br/Owx/KpXkMONzMjqr03mFAHvDCnn+U0MysI/AvYClwEXAufoEVrUcvEoSaAEQarhUlj9kljwOAY4ETnHPvlux7u6Sv4Dgz+5Nzbn1VJ3LOPR54XtK58D0gGRhlZrc554qBN4AfgauARSVpmwCXAy8457ZF88NVckRJfkY457aW7HunFq8nUu+pBkCk4QqMAgj0qj8dv9b9AjNLCmzAm0AT4JigJzLLNrMnzGw5fsWxncA9QAugNUBJEPAEcLGZNS9563lAm5L9tWlJSZ5eMrN+Zta6lq8nUu8pABBpuPYreVxT8tgaaI+/UZbfFpUc37uqk5T0D/gXcDb+pv9r4EjKqv9TyyV/CkgEBpa8Hg4scs7t1jcgmko6QZ6G/057DlhrZh+a2Qm1eV2R+kxNACIN11n4NcQXl7z+Gd9GfmGQ9MuC7D8A349goHPu+cBOMzunckLn3M9m9jJwlZnNAU7E9zmoqcrfVU2ruPZcYK6ZpQB9gPHAa2bWwTm3MQp5EGlQFACINEBmdgG+I9xk51x+ye43gAuAXOfcN9U4XWAUwc5y528CXBok/aPAQnwHw1+Al6pxrWAOrfQ6aHOFc2478I6ZNcWPhNgfUAAgUokCAJH673Aza4XvBNcOX1XfH3gLuLVcuhfwHfLeNrMHgM9K3nMAPlg4r1ywUN7X+L4DfzCzInwgcFOwzDjnPiwZDng88EiQc1bXEDNbCXyKr424tmT/aWa2Aji15HqvAyuBVvjPvhr4IgrXF2lwFACI1H8zSx4LgfXAf4GLgVnOudJpdZ1zO83sNGA0fmje/vjhef8HvIbv3Lcb59wOMzsPmAI8C2wC/oIfZTAtRJ66E73Ofw8B/YAJwA/4zoUTgBHAf/DBzBnAH/F9HTYB7wOXOucKopQHkQbFyn0/iIhEhZl9ABQ7546LMP1g/FS9nYDlzrldJfs74PstXO6cm17DPBm+g+JTwEnOubY1OZ9IfacaABGJipLOd0cAJwO9gd/swWkCUxrv0UJGYdwO3F3yfFUtnF+kXlEAICLRkg0sALYAE5xz/6rGe1/BDy2sTU/hO0JCkOYOkcZETQAiIiKNkCYCEhERaYQUAIiIiDRCCgBEREQaIQUAIiIijZACABERkUZIAYCIiEgj9P8Bwm/rlZ+6GOMAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "exp_with_p0 = T2Hahn(qubit=qubit, delays=delays, num_echoes=number_of_echoes)\n", + "exp_with_p0.analysis.set_options(p0={\"amp\": 0.5, \"tau\": estimated_t2hahn, \"base\": 0.5})\n", + "expdata_with_p0 = exp_with_p0.run(backend=backend, shots=2000)\n", + "expdata_with_p0.block_for_results()\n", + "\n", + "# Display fit figure\n", + "display(expdata_with_p0.figure(0))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DbAnalysisResultV1\n", + "- name: @Parameters_T2HahnAnalysis\n", + "- value: [4.79645080e-01 5.01025155e-01 2.01217480e-05] ± [3.58419367e-03 2.92444090e-03 4.64978519e-07]\n", + "- χ²: 0.6109365214541765\n", + "- quality: good\n", + "- extra: <4 items>\n", + "- device_components: ['Q0']\n", + "- verified: False\n", + "DbAnalysisResultV1\n", + "- name: T2\n", + "- value: 2.0121748034379643e-05 ± 4.6497851904598897e-07 s\n", + "- χ²: 0.6109365214541765\n", + "- quality: good\n", + "- device_components: ['Q0']\n", + "- verified: False\n" + ] + } + ], + "source": [ + "# Print results\n", + "for result in expdata_with_p0.analysis_results():\n", + " print(result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3. Number of echoes\n", + "The user can provide the number of echoes that the circuit will perform. This will determine the amount of delay and echo gates. As the number of echoes increases, the total time of the circuit will grow. The echoes decrease the effects of $T_{1}$ noise and frequency inaccuracy estimation. Due to that, the Hahn Echo experiment improves our estimate for $T_{2}$. In the following code, we will compare results of the Hahn experiment with `0` echoes and `1` echo. The analysis should fail for the circuit with `0` echoes. In order to see it, we will add frequency to the qubit and see how it affect the estimated $T_2$.
\n", + "The list `delays` is the times provided to each delay gate, not the total delay time." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The first circuit of hahn echo experiment with 0 echoes:\n", + " ┌─────────┐┌───────────────┐┌──────────┐┌─┐\n", + " q: ┤ Rx(π/2) ├┤ Delay(0.0[s]) ├┤ Rx(-π/2) ├┤M├\n", + " └─────────┘└───────────────┘└──────────┘└╥┘\n", + "c: 1/═════════════════════════════════════════╩═\n", + " 0 \n", + "The first circuit of hahn echo experiment with 1 echo:\n", + " ┌─────────┐┌───────────────┐┌───────┐┌───────────────┐┌─────────┐┌─┐\n", + " q: ┤ Rx(π/2) ├┤ Delay(0.0[s]) ├┤ Rx(π) ├┤ Delay(0.0[s]) ├┤ Rx(π/2) ├┤M├\n", + " └─────────┘└───────────────┘└───────┘└───────────────┘└─────────┘└╥┘\n", + "c: 1/══════════════════════════════════════════════════════════════════╩═\n", + " 0 \n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "qubit2 = 0\n", + "# set the desired delays\n", + "conversion_factor = 1e-6\n", + "\n", + "# The delays aren't equally spaced due the behavior of exponential decay curve where the change in the result\n", + "# in earlier times is larger than later times. In addition, since the total delay is 'delay * 2 * num_of_echoes',\n", + "# the construction of the delays for each experiment will be different, such that their total length will be the same.\n", + "\n", + "# Delays for Hahn Echo Experiment with 0 echoes\n", + "delays2 = np.append(\n", + " (np.linspace(0.0, 51.0, num=26)).astype(float),\n", + " (np.linspace(53, 100.0, num=25)).astype(float),\n", + " )\n", + "\n", + "delays2 = [float(_) * conversion_factor for _ in delays2]\n", + "\n", + "# Delays for Hahn Echo Experiment with 1 echo\n", + "delays3 = np.append(\n", + " (np.linspace(0.0, 25.5, num=26)).astype(float),\n", + " (np.linspace(26.5, 50, num=25)).astype(float),\n", + " ) \n", + "delays3 = [float(_) * conversion_factor for _ in delays3]\n", + "\n", + "num_echoes = 1\n", + "estimated_t2hahn2 = 30 * conversion_factor\n", + "\n", + "# Create a T2Hahn experiment with 0 echoes\n", + "exp2_0echoes = T2Hahn(qubit2, delays2, num_echoes=0)\n", + "exp2_0echoes.analysis.set_options(p0={\"amp\": 0.5, \"tau\": estimated_t2hahn2, \"base\": 0.5})\n", + "print(\"The first circuit of hahn echo experiment with 0 echoes:\")\n", + "print(exp2_0echoes.circuits()[0])\n", + "\n", + "# Create a T2Hahn experiment with 1 echo. Print the first circuit as an example\n", + "exp2_1echoes = T2Hahn(qubit2, delays3, num_echoes=num_echoes)\n", + "exp2_1echoes.analysis.set_options(p0={\"amp\": 0.5, \"tau\": estimated_t2hahn2, \"base\": 0.5})\n", + "print(\"The first circuit of hahn echo experiment with 1 echo:\")\n", + "print(exp2_1echoes.circuits()[0])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hahn Echo with 0 echoes:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hahn Echo with 1 echoe:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from qiskit_experiments.test.t2hahn_backend import T2HahnBackend\n", + "\n", + "detuning_frequency = 2 * np.pi * 10000\n", + "\n", + "# The behavior of the backend is determined by the following parameters\n", + "backend2 = T2HahnBackend(\n", + " t2hahn=[estimated_t2hahn2],\n", + " frequency=[detuning_frequency],\n", + " initialization_error=[0.0],\n", + " readout0to1=[0.02],\n", + " readout1to0=[0.02],)\n", + "\n", + "# Analysis for Hahn Echo experiemnt with 0 echoes.\n", + "expdata2_0echoes = exp2_0echoes.run(backend=backend2, shots=2000)\n", + "expdata2_0echoes.block_for_results() # Wait for job/analysis to finish.\n", + "\n", + "# Analysis for Hahn Echo experiemnt with 1 echo\n", + "expdata2_1echoes = exp2_1echoes.run(backend=backend2, shots=2000)\n", + "expdata2_1echoes.block_for_results() # Wait for job/analysis to finish.\n", + "\n", + "# Display the figure\n", + "print(\"Hahn Echo with 0 echoes:\")\n", + "display(expdata2_0echoes.figure(0))\n", + "print(\"Hahn Echo with 1 echoe:\")\n", + "display(expdata2_1echoes.figure(0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that the estimate $T_2$ is different in the two plots. The mock backend for this experiment used $T_{2} = 30[\\mu s]$, which is close to the estimate of the 1 echo experiment." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "

This code is a part of Qiskit

© Copyright IBM 2017, 2022.

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.

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import qiskit.tools.jupyter\n", + "%qiskit_copyright" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/qiskit_experiments/curve_analysis/curve_fit.py b/qiskit_experiments/curve_analysis/curve_fit.py index 26f99476f3..dc597d1028 100644 --- a/qiskit_experiments/curve_analysis/curve_fit.py +++ b/qiskit_experiments/curve_analysis/curve_fit.py @@ -140,7 +140,7 @@ def fit_func(x, *params): yfits = fit_func(xdata, *popt) residues = (yfits - ydata) ** 2 if sigma is not None: - residues = residues / (sigma ** 2) + residues = residues / (sigma**2) reduced_chisq = np.sum(residues) / dof # Compute data range for fit diff --git a/qiskit_experiments/curve_analysis/data_processing.py b/qiskit_experiments/curve_analysis/data_processing.py index 33322aadb5..f07e7f059e 100644 --- a/qiskit_experiments/curve_analysis/data_processing.py +++ b/qiskit_experiments/curve_analysis/data_processing.py @@ -151,7 +151,7 @@ def mean_xy_data( # Compute sample mean and sum of variance with weights based on shots y_means[i] = np.sum(weights * ys) - y_sigmas[i] = np.sqrt(np.sum(weights ** 2 * ss ** 2)) + y_sigmas[i] = np.sqrt(np.sum(weights**2 * ss**2)) y_shots[i] = np.sum(ns) return x_means, y_means, y_sigmas, y_shots diff --git a/qiskit_experiments/curve_analysis/fit_function.py b/qiskit_experiments/curve_analysis/fit_function.py index 0a5cff4b78..691ee1e54b 100644 --- a/qiskit_experiments/curve_analysis/fit_function.py +++ b/qiskit_experiments/curve_analysis/fit_function.py @@ -74,7 +74,7 @@ def gaussian( .. math:: y = {\rm amp} \cdot \exp \left( - (x - x0)^2 / 2 \sigma^2 \right) + {\rm baseline} """ - return amp * np.exp(-((x - x0) ** 2) / (2 * sigma ** 2)) + baseline + return amp * np.exp(-((x - x0) ** 2) / (2 * sigma**2)) + baseline def cos_decay( @@ -123,9 +123,9 @@ def bloch_oscillation_x( where :math:`\omega = \sqrt{p_x^2 + p_y^2 + p_z^2}`. The `p_i` stands for the measured probability in :math:`i \in \left\{ X, Y, Z \right\}` basis. """ - w = np.sqrt(px ** 2 + py ** 2 + pz ** 2) + w = np.sqrt(px**2 + py**2 + pz**2) - return (-pz * px + pz * px * np.cos(w * x) + w * py * np.sin(w * x)) / (w ** 2) + baseline + return (-pz * px + pz * px * np.cos(w * x) + w * py * np.sin(w * x)) / (w**2) + baseline def bloch_oscillation_y( @@ -140,9 +140,9 @@ def bloch_oscillation_y( where :math:`\omega = \sqrt{p_x^2 + p_y^2 + p_z^2}`. The `p_i` stands for the measured probability in :math:`i \in \left\{ X, Y, Z \right\}` basis. """ - w = np.sqrt(px ** 2 + py ** 2 + pz ** 2) + w = np.sqrt(px**2 + py**2 + pz**2) - return (pz * py - pz * py * np.cos(w * x) - w * px * np.sin(w * x)) / (w ** 2) + baseline + return (pz * py - pz * py * np.cos(w * x) - w * px * np.sin(w * x)) / (w**2) + baseline def bloch_oscillation_z( @@ -157,6 +157,6 @@ def bloch_oscillation_z( where :math:`\omega = \sqrt{p_x^2 + p_y^2 + p_z^2}`. The `p_i` stands for the measured probability in :math:`i \in \left\{ X, Y, Z \right\}` basis. """ - w = np.sqrt(px ** 2 + py ** 2 + pz ** 2) + w = np.sqrt(px**2 + py**2 + pz**2) - return (pz ** 2 + (px ** 2 + py ** 2) * np.cos(w * x)) / (w ** 2) + baseline + return (pz**2 + (px**2 + py**2) * np.cos(w * x)) / (w**2) + baseline diff --git a/qiskit_experiments/database_service/db_analysis_result.py b/qiskit_experiments/database_service/db_analysis_result.py index 6a5f8286ba..abeae5e983 100644 --- a/qiskit_experiments/database_service/db_analysis_result.py +++ b/qiskit_experiments/database_service/db_analysis_result.py @@ -169,7 +169,7 @@ def save(self) -> None: if db_value is not None: result_data["value"] = db_value if isinstance(value.stderr, (int, float)): - result_data["variance"] = self._display_format(value.stderr ** 2) + result_data["variance"] = self._display_format(value.stderr**2) if isinstance(value.unit, str): result_data["unit"] = value.unit else: diff --git a/qiskit_experiments/library/calibration/fine_drag_cal.py b/qiskit_experiments/library/calibration/fine_drag_cal.py index 1eefdc2a88..5ce35264a9 100644 --- a/qiskit_experiments/library/calibration/fine_drag_cal.py +++ b/qiskit_experiments/library/calibration/fine_drag_cal.py @@ -138,7 +138,7 @@ def update_calibrations(self, experiment_data: ExperimentData): d_theta = BaseUpdater.get_value(experiment_data, "d_theta", result_index) # See the documentation in fine_drag.py for the derivation of this rule. - d_beta = -np.sqrt(np.pi) * d_theta * sigmas[0] / target_angle ** 2 + d_beta = -np.sqrt(np.pi) * d_theta * sigmas[0] / target_angle**2 old_beta = experiment_data.metadata["cal_param_value"] new_beta = old_beta + d_beta diff --git a/qiskit_experiments/library/characterization/__init__.py b/qiskit_experiments/library/characterization/__init__.py index b845af4d3a..7fc9e63821 100644 --- a/qiskit_experiments/library/characterization/__init__.py +++ b/qiskit_experiments/library/characterization/__init__.py @@ -25,6 +25,7 @@ T1 T2Ramsey + T2Hahn QubitSpectroscopy CrossResonanceHamiltonian EchoedCrossResonanceHamiltonian @@ -52,6 +53,7 @@ T1Analysis T2RamseyAnalysis + T2HahnAnalysis CrossResonanceHamiltonianAnalysis DragCalAnalysis FineHalfAngleAnalysis @@ -69,6 +71,7 @@ RamseyXYAnalysis, T2RamseyAnalysis, T1Analysis, + T2HahnAnalysis, CrossResonanceHamiltonianAnalysis, ReadoutAngleAnalysis, ) @@ -77,6 +80,7 @@ from .qubit_spectroscopy import QubitSpectroscopy from .ef_spectroscopy import EFSpectroscopy from .t2ramsey import T2Ramsey +from .t2hahn import T2Hahn from .cr_hamiltonian import CrossResonanceHamiltonian, EchoedCrossResonanceHamiltonian from .rabi import Rabi, EFRabi from .half_angle import HalfAngle diff --git a/qiskit_experiments/library/characterization/analysis/__init__.py b/qiskit_experiments/library/characterization/analysis/__init__.py index e100871223..3c46ff6964 100644 --- a/qiskit_experiments/library/characterization/analysis/__init__.py +++ b/qiskit_experiments/library/characterization/analysis/__init__.py @@ -19,6 +19,7 @@ from .fine_frequency_analysis import FineFrequencyAnalysis from .ramsey_xy_analysis import RamseyXYAnalysis from .t2ramsey_analysis import T2RamseyAnalysis +from .t2hahn_analysis import T2HahnAnalysis from .t1_analysis import T1Analysis from .cr_hamiltonian_analysis import CrossResonanceHamiltonianAnalysis from .readout_angle_analysis import ReadoutAngleAnalysis diff --git a/qiskit_experiments/library/characterization/analysis/cr_hamiltonian_analysis.py b/qiskit_experiments/library/characterization/analysis/cr_hamiltonian_analysis.py index 919c6a681c..6d4fd713e8 100644 --- a/qiskit_experiments/library/characterization/analysis/cr_hamiltonian_analysis.py +++ b/qiskit_experiments/library/characterization/analysis/cr_hamiltonian_analysis.py @@ -336,7 +336,7 @@ def _extra_database_entry(self, fit_data: curve.FitData) -> List[AnalysisResultD else: coef_val = 0.5 * (p0_val.value + p1_val.value) / (2 * np.pi) - coef_err = 0.5 * np.sqrt(p0_val.stderr ** 2 + p1_val.stderr ** 2) / (2 * np.pi) + coef_err = 0.5 * np.sqrt(p0_val.stderr**2 + p1_val.stderr**2) / (2 * np.pi) extra_entries.append( AnalysisResultData( diff --git a/qiskit_experiments/library/characterization/analysis/t2hahn_analysis.py b/qiskit_experiments/library/characterization/analysis/t2hahn_analysis.py new file mode 100644 index 0000000000..771f9ba6bc --- /dev/null +++ b/qiskit_experiments/library/characterization/analysis/t2hahn_analysis.py @@ -0,0 +1,79 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# 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. +""" +T2 Hahn echo Analysis class. +""" +from typing import Union + +import numpy as np + +import qiskit_experiments.curve_analysis as curve +from qiskit_experiments.data_processing import DataProcessor, Probability + +from qiskit_experiments.framework import Options + + +class T2HahnAnalysis(curve.DecayAnalysis): + r"""A class to analyze T2Hahn experiments. + + # section: see_also + qiskit_experiments.curve_analysis.standard_analysis.decay.DecayAnalysis + + """ + + @classmethod + def _default_options(cls) -> Options: + """Default analysis options.""" + options = super()._default_options() + options.data_processor = DataProcessor( + input_key="counts", data_actions=[Probability(outcome="0")] + ) + options.bounds = { + "amp": (0.0, 1.0), + "tau": (0.0, np.inf), + "base": (0.0, 1.0), + } + options.xlabel = "Delay" + options.ylabel = "P(0)" + options.xval_unit = "s" + options.result_parameters = [curve.ParameterRepr("tau", "T2", "s")] + + 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 + - absolute amp is within [0.4, 0.6] + - base is less is within [0.4, 0.6] + - 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 - 0.5) < 0.1, + abs(base.value - 0.5) < 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/t2hahn.py b/qiskit_experiments/library/characterization/t2hahn.py new file mode 100644 index 0000000000..84e6c28243 --- /dev/null +++ b/qiskit_experiments/library/characterization/t2hahn.py @@ -0,0 +1,193 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# 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. +""" +T2Hahn Echo Experiment class. +""" + +from typing import List, Optional, Union +import numpy as np + +from qiskit import QuantumCircuit, QiskitError +from qiskit.providers.backend import Backend +from qiskit.test.mock import FakeBackend + +from qiskit_experiments.framework import BaseExperiment, Options +from qiskit_experiments.library.characterization.analysis.t2hahn_analysis import T2HahnAnalysis + + +class T2Hahn(BaseExperiment): + r"""T2 Hahn Echo Experiment. + + # section: overview + + This experiment is used to estimate T2 noise of a single qubit. + + See `Qiskit Textbook `_ for a more detailed explanation on + these properties. + + This experiment consists of a series of circuits of the form + + + .. parsed-literal:: + + ┌─────────┐┌──────────┐┌───────┐┌──────────┐┌─────────┐┌─┐ + q_0: ┤ Rx(π/2) ├┤ DELAY(t) ├┤ RX(π) ├┤ DELAY(t) ├┤ RX(π/2) ├┤M├ + └─────────┘└──────────┘└───────┘└──────────┘└─────────┘└╥┘ + c: 1/════════════════════════════════════════════════════════╩═ + 0 + + for each *t* from the specified delay times + and the delays are specified by the user. + The delays that are specified are delay for each delay gate while + the delay in the metadata is the total delay which is delay * (num_echoes +1) + The circuits are run on the device or on a simulator backend. + + # section: tutorial + :doc:`/tutorials/t2hahn_characterization` + + # section: analysis_ref + :py:class:`T2HahnAnalysis` + """ + + @classmethod + def _default_experiment_options(cls) -> Options: + """Default experiment options. + + Experiment Options: + delays (Iterable[float]): Delay times of the experiments. + """ + options = super()._default_experiment_options() + + options.delays = None + options.num_echoes = 1 + return options + + def __init__( + self, + qubit: int, + delays: Union[List[float], np.array], + num_echoes: int = 1, + backend: Optional[Backend] = None, + ): + """ + Initialize the T2 - Hahn Echo class + + Args: + qubit: the qubit whose T2 is to be estimated + delays: Total delay times of the experiments. + backend: Optional, the backend to run the experiment on. + num_echoes: The number of echoes to preform. + backend: Optional, the backend to run the experiment on.. + + Raises: + QiskitError : Error for invalid input. + """ + # Initialize base experiment + super().__init__([qubit], analysis=T2HahnAnalysis(), backend=backend) + + # Set experiment options + self.set_experiment_options(delays=delays, num_echoes=num_echoes) + self._verify_parameters() + + def _verify_parameters(self): + """ + Verify input correctness, raise QiskitError if needed. + + Raises: + QiskitError : Error for invalid input. + """ + if any(delay < 0 for delay in self.experiment_options.delays): + raise QiskitError( + f"The lengths list {self.experiment_options.delays} should only contain " + "non-negative elements." + ) + + def _set_backend(self, backend: Backend): + super()._set_backend(backend) + + # Scheduling parameters + if not self._backend.configuration().simulator and not isinstance(backend, FakeBackend): + timing_constraints = getattr(self.transpile_options, "timing_constraints", {}) + if "acquire_alignment" not in timing_constraints: + timing_constraints["acquire_alignment"] = 16 + scheduling_method = getattr(self.transpile_options, "scheduling_method", "alap") + self.set_transpile_options( + timing_constraints=timing_constraints, scheduling_method=scheduling_method + ) + + def circuits(self) -> List[QuantumCircuit]: + """ + Return a list of experiment circuits. + + Each circuit consists of RX(π/2) followed by a sequence of delay gate, + RX(π) for echo and delay gate again. + The sequence repeats for the number of echoes and terminates with RX(±π/2). + + Returns: + The experiment circuits. + """ + + if self.backend and hasattr(self.backend.configuration(), "dt"): + dt_unit = True + dt_factor = self.backend.configuration().dt + else: + dt_unit = False + + circuits = [] + for delay_gate in np.asarray(self.experiment_options.delays, dtype=float): + if dt_unit: + delay_dt = round(delay_gate / dt_factor) + real_delay_in_sec = delay_dt * dt_factor + else: + real_delay_in_sec = delay_gate + + total_delay = real_delay_in_sec * (self.experiment_options.num_echoes * 2) + + circ = QuantumCircuit(1, 1) + + # First X rotation in 90 degrees + circ.rx(np.pi / 2, 0) # Brings the qubit to the X Axis + for _ in range(self.experiment_options.num_echoes): + if dt_unit: + circ.delay(delay_dt, 0, "dt") + circ.rx(np.pi, 0) + circ.delay(delay_dt, 0, "dt") + else: + circ.delay(delay_gate, 0, "s") + circ.rx(np.pi, 0) + circ.delay(delay_gate, 0, "s") + + # if number of echoes is 0 then just apply the delay gate + if self.experiment_options.num_echoes == 0: + if dt_unit: + total_delay = real_delay_in_sec + circ.delay(delay_dt, 0, "dt") + else: + total_delay = real_delay_in_sec + circ.delay(delay_gate, 0, "s") + + if self.experiment_options.num_echoes % 2 == 1: + circ.rx(np.pi / 2, 0) # X90 again since the num of echoes is odd + else: + circ.rx(-np.pi / 2, 0) # X(-90) again since the num of echoes is even + circ.measure(0, 0) # measure + circ.metadata = { + "experiment_type": self._type, + "qubit": self.physical_qubits[0], + "xval": total_delay, + "unit": "s", + } + + circuits.append(circ) + + return circuits diff --git a/qiskit_experiments/library/mitigation/mitigation_experiment.py b/qiskit_experiments/library/mitigation/mitigation_experiment.py index a5febc3372..3bafa7fc9d 100644 --- a/qiskit_experiments/library/mitigation/mitigation_experiment.py +++ b/qiskit_experiments/library/mitigation/mitigation_experiment.py @@ -92,7 +92,7 @@ def analysis(self): def labels(self) -> List[str]: """Returns the labels dictating the generation of the mitigation circuits""" - return [bin(j)[2:].zfill(self.num_qubits) for j in range(2 ** self.num_qubits)] + return [bin(j)[2:].zfill(self.num_qubits) for j in range(2**self.num_qubits)] class LocalMitigationHelper: diff --git a/qiskit_experiments/library/quantum_volume/qv_analysis.py b/qiskit_experiments/library/quantum_volume/qv_analysis.py index f257937a5a..a536c4d8ae 100644 --- a/qiskit_experiments/library/quantum_volume/qv_analysis.py +++ b/qiskit_experiments/library/quantum_volume/qv_analysis.py @@ -89,7 +89,7 @@ def _calc_ideal_heavy_output(probabilities_vector, depth): # Keys are bit strings and values are probabilities of observing those strings all_output_prob_ideal = { format_spec.format(b): float(np.real(probabilities_vector[b])) - for b in range(2 ** depth) + for b in range(2**depth) } median_probabilities = float(np.real(np.median(probabilities_vector))) @@ -157,7 +157,7 @@ def _calc_confidence_level(z_value): float: confidence level in decimal (not percentage). """ - confidence_level = 0.5 * (1 + math.erf(z_value / 2 ** 0.5)) + confidence_level = 0.5 * (1 + math.erf(z_value / 2**0.5)) return confidence_level @@ -201,7 +201,7 @@ def _calc_quantum_volume(self, heavy_output_prob_exp, depth, trials): warnings.warn("Must use at least 100 trials to consider Quantum Volume as successful.") if mean_hop > threshold and trials >= 100: - quantum_volume = 2 ** depth + quantum_volume = 2**depth success = True hop_result = AnalysisResultData( diff --git a/qiskit_experiments/library/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/library/randomized_benchmarking/interleaved_rb_analysis.py index 0bdfc48d2e..25170b25ce 100644 --- a/qiskit_experiments/library/randomized_benchmarking/interleaved_rb_analysis.py +++ b/qiskit_experiments/library/randomized_benchmarking/interleaved_rb_analysis.py @@ -165,7 +165,7 @@ def _generate_fit_guesses( def _extra_database_entry(self, fit_data: curve.FitData) -> List[AnalysisResultData]: """Calculate EPC.""" - nrb = 2 ** self._num_qubits + nrb = 2**self._num_qubits scale = (nrb - 1) / nrb alpha = fit_data.fitval("alpha") diff --git a/qiskit_experiments/library/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/library/randomized_benchmarking/rb_analysis.py index 4d424e2c6b..9473fed7f0 100644 --- a/qiskit_experiments/library/randomized_benchmarking/rb_analysis.py +++ b/qiskit_experiments/library/randomized_benchmarking/rb_analysis.py @@ -117,7 +117,7 @@ def _initial_guess( opt: curve.FitOptions, x_values: np.ndarray, y_values: np.ndarray, num_qubits: int ) -> curve.FitOptions: """Create initial guess with experiment data.""" - opt.p0.set_if_empty(b=1 / 2 ** num_qubits) + opt.p0.set_if_empty(b=1 / 2**num_qubits) # Use the first two points to guess the decay param dcliff = x_values[1] - x_values[0] @@ -169,7 +169,7 @@ def _extra_database_entry(self, fit_data: curve.FitData) -> List[AnalysisResultD # Calculate EPC alpha = fit_data.fitval("alpha") - scale = (2 ** self._num_qubits - 1) / (2 ** self._num_qubits) + scale = (2**self._num_qubits - 1) / (2**self._num_qubits) epc = FitVal(value=scale * (1 - alpha.value), stderr=scale * alpha.stderr) extra_entries.append( AnalysisResultData( diff --git a/qiskit_experiments/library/tomography/basis/tomography_basis.py b/qiskit_experiments/library/tomography/basis/tomography_basis.py index f346999393..32bbfca5bf 100644 --- a/qiskit_experiments/library/tomography/basis/tomography_basis.py +++ b/qiskit_experiments/library/tomography/basis/tomography_basis.py @@ -79,8 +79,8 @@ def _instruction_povms(instructions: List[Instruction]) -> List[Dict[int, np.nda for inst in instructions: inst_inv = inst.inverse() basis_dict = { - i: DensityMatrix.from_int(i, 2 ** inst.num_qubits).evolve(inst_inv).data - for i in range(2 ** inst.num_qubits) + i: DensityMatrix.from_int(i, 2**inst.num_qubits).evolve(inst_inv).data + for i in range(2**inst.num_qubits) } basis.append(basis_dict) return basis @@ -90,7 +90,7 @@ def _instruction_states(instructions: List[Instruction]) -> List[np.ndarray]: """Construct preparation density matrices from instructions""" states = [] num_qubits = instructions[0].num_qubits - init = DensityMatrix.from_int(0, 2 ** num_qubits) + init = DensityMatrix.from_int(0, 2**num_qubits) for inst in instructions: states.append(init.evolve(inst).data) return states diff --git a/qiskit_experiments/test/t2hahn_backend.py b/qiskit_experiments/test/t2hahn_backend.py new file mode 100644 index 0000000000..8cbe72ecfe --- /dev/null +++ b/qiskit_experiments/test/t2hahn_backend.py @@ -0,0 +1,345 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# 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. +""" +T2HahnBackend class. +Temporary backend to be used for t2hahn experiment +""" + +from typing import List +import numpy as np +from numpy import isclose +from qiskit import QiskitError +from qiskit.providers import BackendV1 +from qiskit.providers.models import QasmBackendConfiguration +from qiskit.result import Result +from qiskit_experiments.framework import Options +from qiskit_experiments.test.utils import FakeJob + +# Fix seed for simulations +SEED = 9000 + + +class T2HahnBackend(BackendV1): + """ + A simple and primitive backend, to be run by the T2Hahn tests + """ + + def __init__( + self, + t2hahn=None, + frequency=None, + initialization_error=None, + readout0to1=None, + readout1to0=None, + ): + """ + Initialize the T2Hahn backend + """ + configuration = QasmBackendConfiguration( + backend_name="T2Hahn_simulator", + backend_version="0", + n_qubits=int(1e6), + basis_gates=["barrier", "rx", "delay", "measure"], + gates=[], + local=True, + simulator=True, + conditional=False, + open_pulse=False, + memory=False, + max_shots=int(1e6), + coupling_map=None, + ) + + self._t2hahn = t2hahn + self._frequency = frequency + self._initialization_error = initialization_error + self._readout0to1 = readout0to1 + self._readout1to0 = readout1to0 + self._rng = np.random.default_rng(seed=SEED) + super().__init__(configuration) + + @classmethod + def _default_options(cls): + """Default options of the test backend.""" + return Options(shots=1024) + + def _qubit_initialization(self, nqubits: int) -> List[dict]: + """ + Initialize the list of qubits state. If initialization error is provided to the backend it will + use it to determine the initialized state. + Args: + nqubits(int): the number of qubits in the circuit. + + Returns: + List[dict]: A list of dictionary which each dictionary contain the qubit state in the format + {"XY plane": (bool), "ZX plane": (bool), "Theta": float} + + Raises: + QiskitError: Raised if initialization_error type isn't 'None'', 'float' or a list of 'float' + with length of number of the qubits. + ValueError: Raised if the initialization error is negative. + """ + qubits_sates = [{} for _ in range(nqubits)] + # Making an array with the initialization error for each qubit. + initialization_error = self._initialization_error + if isinstance(initialization_error, float) or initialization_error is None: + initialization_error_arr = [initialization_error for _ in range(nqubits)] + elif isinstance(initialization_error, list): + if len(initialization_error) == 1: + initialization_error_arr = [initialization_error[0] for _ in range(nqubits)] + elif len(initialization_error) == nqubits: + initialization_error_arr = initialization_error + else: + raise QiskitError( + f"The length of the list {initialization_error} isn't the same as the number " + "of qubits." + ) + else: + raise QiskitError("Initialization error type isn't a list or float") + + for err in initialization_error_arr: + if not isinstance(err, float): + raise QiskitError("Initialization error type isn't a list or float") + if err < 0: + raise ValueError("Initialization error value can't be negative.") + + for qubit in range(nqubits): + if initialization_error_arr[qubit] is not None and ( + self._rng.random() < initialization_error_arr[qubit] + ): + qubits_sates[qubit] = {"XY plane": False, "ZX plane": True, "Theta": np.pi} + else: + qubits_sates[qubit] = { + "XY plane": False, + "ZX plane": True, + "Theta": 0, + } + return qubits_sates + + def _delay_gate(self, qubit_state: dict, delay: float, t2hahn: float, frequency: float) -> dict: + """ + Apply delay gate to the qubit. From the delay time we can calculate the probability + that an error has accrued. + Args: + qubit_state(dict): The state of the qubit before operating the gate. + delay(float): The time in which there are no operation on the qubit. + t2hahn(float): The T2 parameter of the backhand for probability calculation. + frequency(float): The frequency of the qubit for phase calculation. + + Returns: + dict: The state of the qubit after operating the gate. + + Raises: + QiskitError: Raised if the frequency is 'None' or if the qubit isn't in the XY plane. + """ + if frequency is None: + raise QiskitError("Delay gate supported only if the qubit is on the XY plane.") + new_qubit_state = qubit_state + if qubit_state["XY plane"]: + prob_noise = 1 - (np.exp(-delay / t2hahn)) + if self._rng.random() < prob_noise: + if self._rng.random() < 0.5: + new_qubit_state = { + "XY plane": False, + "ZX plane": True, + "Theta": 0, + } + else: + new_qubit_state = { + "XY plane": False, + "ZX plane": True, + "Theta": np.pi, + } + else: + phase = frequency * delay + new_theta = qubit_state["Theta"] + phase + new_theta = new_theta % (2 * np.pi) + new_qubit_state = {"XY plane": True, "ZX plane": False, "Theta": new_theta} + else: + if not isclose(qubit_state["Theta"], np.pi) and not isclose(qubit_state["Theta"], 0): + raise QiskitError("Delay gate supported only if the qubit is on the XY plane.") + return new_qubit_state + + def _rx_gate(self, qubit_state: dict, angle: float) -> dict: + """ + Apply Rx gate. + Args: + qubit_state(dict): The state of the qubit before operating the gate. + angle(float): The angle of the rotation. + + Returns: + dict: The state of the qubit after operating the gate. + + Raises: + QiskitError: if angle is not ±π/2 or ±π. Those are the only supported angles. + """ + + if qubit_state["XY plane"]: + if isclose(angle, np.pi): + new_theta = -qubit_state["Theta"] + new_theta = new_theta % (2 * np.pi) + new_qubit_state = { + "XY plane": True, + "ZX plane": False, + "Theta": new_theta, + } + elif isclose(angle, np.pi / 2): + new_theta = (np.pi / 2) - qubit_state["Theta"] + new_theta = new_theta % (2 * np.pi) + new_qubit_state = { + "XY plane": False, + "ZX plane": True, + "Theta": new_theta, + } + elif isclose(angle, -np.pi / 2): + new_theta = np.abs((-np.pi / 2) - qubit_state["Theta"]) + new_theta = new_theta % (2 * np.pi) + new_qubit_state = { + "XY plane": False, + "ZX plane": True, + "Theta": new_theta, + } + else: + raise QiskitError( + f"Error - the angle {angle} isn't supported. We only support multiplications of pi/2" + ) + else: + if isclose(angle, np.pi): + new_theta = qubit_state["Theta"] + np.pi + new_theta = new_theta % (2 * np.pi) + new_qubit_state = { + "XY plane": False, + "ZX plane": True, + "Theta": new_theta, + } + elif isclose(angle, np.pi / 2): + new_theta = ( + qubit_state["Theta"] + 3 * np.pi / 2 + ) # its theta -pi/2 but we added 2*pi + new_theta = new_theta % (2 * np.pi) + new_qubit_state = { + "XY plane": True, + "ZX plane": False, + "Theta": new_theta, + } + elif isclose(angle, -np.pi / 2): + new_theta = np.pi / 2 - qubit_state["Theta"] + new_theta = new_theta % (2 * np.pi) + new_qubit_state = { + "XY plane": True, + "ZX plane": False, + "Theta": new_theta, + } + else: + raise QiskitError( + f"Error - The angle {angle} isn't supported. We only support multiplication of pi/2" + ) + return new_qubit_state + + def _measurement_gate(self, qubit_state: dict) -> int: + """ + implementing measurement on qubit with read-out error. + Args: + qubit_state(dict): The state of the qubit at the end of the circuit. + + Returns: + int: The result of the measurement after applying read-out error. + """ + # Here we are calculating the probability for measurement result depending on the + # location of the qubit on the Bloch sphere. + if qubit_state["XY plane"]: + meas_res = self._rng.random() < 0.5 + else: + # Since we are not in the XY plane, we need to calculate the probability for + # measuring output. First, we calculate the probability and later we are + # tossing to see if the event did happen. + z_projection = np.cos(qubit_state["Theta"]) + probability = z_projection**2 + if self._rng.random() > probability: + meas_res = self._rng.random() < 0.5 + else: + meas_res = z_projection < 0 + + # Measurement error implementation + if meas_res and self._readout1to0 is not None: + if self._rng.random() < self._readout1to0[0]: + meas_res = 0 + elif not meas_res and self._readout0to1 is not None: + if self._rng.random() < self._readout0to1[0]: + meas_res = 1 + + return meas_res + + # pylint: disable = arguments-differ + def run(self, run_input, **options): + """ + Run the T2Hahn backend + """ + self.options.update_options(**options) + shots = self.options.get("shots") + result = { + "backend_name": "T2Hahn backend", + "backend_version": "0", + "qobj_id": 0, + "job_id": 0, + "success": True, + "results": [], + } + for circ in run_input: + nqubits = circ.num_qubits + qubit_indices = {bit: idx for idx, bit in enumerate(circ.qubits)} + clbit_indices = {bit: idx for idx, bit in enumerate(circ.clbits)} + counts = dict() + + for _ in range(shots): + qubit_state = self._qubit_initialization( + nqubits=nqubits + ) # for parallel need to make an array + clbits = np.zeros(circ.num_clbits, dtype=int) + for op, qargs, cargs in circ.data: + qubit = qubit_indices[qargs[0]] + + # The noise will only be applied if we are in the XY plane. + if op.name == "delay": + delay = op.params[0] + t2hahn = self._t2hahn[qubit] + freq = self._frequency[qubit] + qubit_state[qubit] = self._delay_gate( + qubit_state=qubit_state[qubit], + delay=delay, + t2hahn=t2hahn, + frequency=freq, + ) + elif op.name == "rx": + qubit_state[qubit] = self._rx_gate(qubit_state[qubit], op.params[0]) + elif op.name == "measure": + meas_res = self._measurement_gate(qubit_state[qubit]) + clbit = clbit_indices[cargs[0]] + clbits[clbit] = meas_res + + clstr = "" + for clbit in clbits[::-1]: + clstr = clstr + str(clbit) + + if clstr in counts: + counts[clstr] += 1 + else: + counts[clstr] = 1 + result["results"].append( + { + "shots": shots, + "success": True, + "header": {"metadata": circ.metadata}, + "data": {"counts": counts}, + } + ) + return FakeJob(self, Result.from_dict(result)) diff --git a/releasenotes/notes/t2-hahn-experiment-84fb05d71b5ef250.yaml b/releasenotes/notes/t2-hahn-experiment-84fb05d71b5ef250.yaml new file mode 100644 index 0000000000..4cd2545541 --- /dev/null +++ b/releasenotes/notes/t2-hahn-experiment-84fb05d71b5ef250.yaml @@ -0,0 +1,13 @@ +--- +features: + - | + Adds a :class:`~qiskit.qiskit_experiments.library.characterization.T2Hahn` + class for composing and running Hahn Echo experiment to estimate T2. + - | + Adds a :class:`~qiskit.qiskit_experiments.library.characterization.analysis.T2HahnAnalysis` + class for analyzing experiment data from :class:`~qiskit.qiskit_experiments.library.characterization.T2Hahn`. + - | + Adds a :class:`~qiskit.qiskit_experiments.test.T2HahnBackend` class for testing + which simulates T2 noise statistics. + + diff --git a/test/calibration/experiments/test_fine_drag.py b/test/calibration/experiments/test_fine_drag.py index b552c022dc..33e21ef6b5 100644 --- a/test/calibration/experiments/test_fine_drag.py +++ b/test/calibration/experiments/test_fine_drag.py @@ -133,7 +133,7 @@ def test_update_cals(self): d_theta = exp_data.analysis_results(1).value.value sigma = 40 target_angle = np.pi - new_beta = -np.sqrt(np.pi) * d_theta * sigma / target_angle ** 2 + new_beta = -np.sqrt(np.pi) * d_theta * sigma / target_angle**2 transpile_opts = copy.copy(drag_cal.transpile_options.__dict__) transpile_opts["initial_layout"] = list(drag_cal.physical_qubits) diff --git a/test/curve_analysis/test_guess.py b/test/curve_analysis/test_guess.py index 1692dde7cd..61e44067ef 100644 --- a/test/curve_analysis/test_guess.py +++ b/test/curve_analysis/test_guess.py @@ -134,7 +134,7 @@ def test_linewidth_spect(self, idx, a, fwhm): """Test of linewidth of peaks.""" x = np.linspace(-1, 1, 100) sigma = fwhm / np.sqrt(8 * np.log(2)) - y = a * np.exp(-((x - x[idx]) ** 2) / (2 * sigma ** 2)) + y = a * np.exp(-((x - x[idx]) ** 2) / (2 * sigma**2)) lw_guess = guess.full_width_half_max(x, y, idx) @@ -153,7 +153,7 @@ def test_baseline_spect(self, b0, x0, a, fwhm): """Test of baseline of peaks.""" x = np.linspace(-1, 1, 100) sigma = fwhm / np.sqrt(8 * np.log(2)) - y = a * np.exp(-((x - x0) ** 2) / (2 * sigma ** 2)) + b0 + y = a * np.exp(-((x - x0) ** 2) / (2 * sigma**2)) + b0 b0_guess = guess.constant_spectral_offset(y) diff --git a/test/randomized_benchmarking/test_rb.py b/test/randomized_benchmarking/test_rb.py index 6f7f15374f..d46718118e 100644 --- a/test/randomized_benchmarking/test_rb.py +++ b/test/randomized_benchmarking/test_rb.py @@ -76,7 +76,7 @@ def is_identity(self, circuits: list): circ.remove_final_measurements() # Checking if the matrix representation is the identity matrix self.assertTrue( - matrix_equal(Clifford(circ).to_matrix(), np.identity(2 ** num_qubits)), + matrix_equal(Clifford(circ).to_matrix(), np.identity(2**num_qubits)), "Clifford sequence doesn't result in the identity matrix.", ) diff --git a/test/test_qubit_spectroscopy.py b/test/test_qubit_spectroscopy.py index 514f47258e..61a84a3ae4 100644 --- a/test/test_qubit_spectroscopy.py +++ b/test/test_qubit_spectroscopy.py @@ -47,7 +47,7 @@ def _compute_probability(self, circuit: QuantumCircuit) -> float: """Returns the probability based on the frequency.""" freq_shift = next(iter(circuit.calibrations["Spec"]))[1][0] delta_freq = freq_shift - self._freq_offset - return np.exp(-(delta_freq ** 2) / (2 * self._linewidth ** 2)) + return np.exp(-(delta_freq**2) / (2 * self._linewidth**2)) class TestQubitSpectroscopy(QiskitExperimentsTestCase): diff --git a/test/test_t2hahn.py b/test/test_t2hahn.py new file mode 100644 index 0000000000..3fb3becebd --- /dev/null +++ b/test/test_t2hahn.py @@ -0,0 +1,175 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2021. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Test T2Hahn experiment +""" + +from test.base import QiskitExperimentsTestCase +import numpy as np +from ddt import ddt, data, unpack +from qiskit_experiments.framework import ParallelExperiment +from qiskit_experiments.library.characterization.t2hahn import T2Hahn +from qiskit_experiments.library.characterization import T2HahnAnalysis +from qiskit_experiments.test.t2hahn_backend import T2HahnBackend + + +@ddt +class TestT2Hahn(QiskitExperimentsTestCase): + """Test T2Hahn experiment""" + + __tolerance__ = 0.1 + + @data([0], [1], [2]) + @unpack + def test_t2hahn_run_end2end(self, num_of_echoes: int): + """ + Run the T2Hahn backend with 'num_of_echoes' echoes. + """ + osc_freq = 0.1 + estimated_t2hahn = 20 + # Set up the circuits + qubit = 0 + delays = np.append( + (np.linspace(1.0, 15.0, num=15)).astype(float), + (np.linspace(16.0, 45.0, num=59)).astype(float), + ) + exp = T2Hahn(qubit=qubit, delays=delays, num_echoes=num_of_echoes) + default_p0 = { + "A": 0.5, + "T2": estimated_t2hahn, + "B": 0.5, + } + backend = T2HahnBackend( + t2hahn=[estimated_t2hahn], + frequency=[osc_freq], + initialization_error=[0.0], + readout0to1=[0.02], + readout1to0=[0.02], + ) + + for _ in [default_p0, dict()]: + exp.analysis.set_options( + p0={"amp": 0.5, "tau": estimated_t2hahn, "base": 0.5}, plot=True + ) + expdata = exp.run(backend=backend, shots=1000) + expdata.block_for_results() # Wait for job/analysis to finish. + result = expdata.analysis_results("T2") + fitval = result.value + if num_of_echoes != 0: + self.assertEqual(result.quality, "good") + self.assertAlmostEqual(fitval.value, estimated_t2hahn, delta=3) + + def test_t2hahn_parallel(self): + """ + Test parallel experiments of T2Hahn using a simulator. + """ + t2hahn = [30, 25] + delays = [list(range(1, 60)), list(range(1, 50))] + osc_freq = [0.11, 0.11] + + exp0 = T2Hahn(0, delays[0]) + exp2 = T2Hahn(2, delays[1]) + + exp0.analysis.set_options(p0={"amp": 0.5, "tau": t2hahn[0], "base": 0.5}, plot=True) + exp2.analysis.set_options(p0={"amp": 0.5, "tau": t2hahn[1], "base": 0.5}, plot=True) + + par_exp = ParallelExperiment([exp0, exp2]) + + p0 = { + "A": [0.5, None, 0.5], + "T2": [t2hahn[0], None, t2hahn[1]], + "frequency": [osc_freq[0], None, osc_freq[1]], + "B": [0.5, None, 0.5], + } + + backend = T2HahnBackend( + t2hahn=p0["T2"], + frequency=p0["frequency"], + initialization_error=[0.0], + readout0to1=[0.02], + readout1to0=[0.02], + ) + expdata = par_exp.run(backend=backend, shots=1024).block_for_results() + + for i in range(2): + res_t2 = expdata.child_data(i).analysis_results("T2") + + fitval = res_t2.value + self.assertEqual(res_t2.quality, "good") + self.assertAlmostEqual(fitval.value, t2hahn[i], delta=3) + + def test_t2hahn_concat_2_experiments(self): + """ + Concatenate the data from 2 separate experiments. + """ + estimated_t2hahn = 30 + # First experiment + qubit = 0 + delays0 = list(range(1, 60, 2)) + osc_freq = 0.08 + + exp0 = T2Hahn(qubit, delays0) + exp0.analysis.set_options(p0={"amp": 0.5, "tau": estimated_t2hahn, "base": 0.5}, plot=True) + backend = T2HahnBackend( + t2hahn=[estimated_t2hahn], + frequency=[osc_freq], + initialization_error=[0.0], + readout0to1=[0.02], + readout1to0=[0.02], + ) + + # run circuits + expdata0 = exp0.run(backend=backend, shots=1000) + expdata0.block_for_results() + + res_t2_0 = expdata0.analysis_results("T2") + # second experiment + delays1 = list(range(2, 65, 2)) + exp1 = T2Hahn(qubit, delays1) + exp1.analysis.set_options(p0={"amp": 0.5, "tau": estimated_t2hahn, "base": 0.5}, plot=True) + expdata1 = exp1.run(backend=backend, analysis=None, shots=1000).block_for_results() + expdata1.add_data(expdata0.data()) + exp1.analysis.run(expdata1) + + res_t2_1 = expdata1.analysis_results("T2") + + fitval = res_t2_1.value + self.assertEqual(res_t2_1.quality, "good") + self.assertAlmostEqual(fitval.value, estimated_t2hahn, delta=3) + + self.assertAlmostEqual( + fitval.value, + estimated_t2hahn, + delta=TestT2Hahn.__tolerance__ * res_t2_1.value.value, + ) + + self.assertLessEqual(res_t2_1.value.stderr, res_t2_0.value.stderr) + self.assertEqual(len(expdata1.data()), len(delays0) + len(delays1)) + + def test_experiment_config(self): + """Test converting to and from config works""" + exp = T2Hahn(0, [1, 2, 3, 4, 5]) + loaded_exp = T2Hahn.from_config(exp.config()) + self.assertNotEqual(exp, loaded_exp) + self.assertTrue(self.json_equiv(exp, loaded_exp)) + + def test_roundtrip_serializable(self): + """Test round trip JSON serialization""" + exp = T2Hahn(0, [1, 2, 3, 4, 5]) + self.assertRoundTripSerializable(exp, self.json_equiv) + + def test_analysis_config(self): + """ "Test converting analysis to and from config works""" + analysis = T2HahnAnalysis() + loaded = T2HahnAnalysis.from_config(analysis.config()) + self.assertNotEqual(analysis, loaded) + self.assertEqual(analysis.config(), loaded.config()) diff --git a/test/test_tomography.py b/test/test_tomography.py index 6e7929d94e..11d2d05ebb 100644 --- a/test/test_tomography.py +++ b/test/test_tomography.py @@ -47,7 +47,7 @@ def test_full_qst(self, num_qubits, fitter): backend = AerSimulator(seed_simulator=9000) seed = 1234 f_threshold = 0.95 - target = qi.random_statevector(2 ** num_qubits, seed=seed) + target = qi.random_statevector(2**num_qubits, seed=seed) qstexp = StateTomography(target) if fitter: qstexp.analysis.set_options(fitter=fitter) @@ -128,7 +128,7 @@ def test_exp_circuits_measurement_qubits(self, meas_qubits): tomo_circuits = exp.circuits() # Check correct number of circuits are generated - self.assertEqual(len(tomo_circuits), 3 ** num_meas) + self.assertEqual(len(tomo_circuits), 3**num_meas) # Check circuit metadata is correct for circ in tomo_circuits: @@ -298,7 +298,7 @@ def test_full_qpt(self, num_qubits, fitter): backend = AerSimulator(seed_simulator=9000) seed = 1234 f_threshold = 0.94 - target = qi.random_unitary(2 ** num_qubits, seed=seed) + target = qi.random_unitary(2**num_qubits, seed=seed) qstexp = ProcessTomography(target) if fitter: qstexp.analysis.set_options(fitter=fitter) @@ -335,7 +335,7 @@ def test_exp_measurement_preparation_qubits(self, qubits): tomo_circuits = exp.circuits() # Check correct number of circuits are generated - size = 3 ** num_meas * 4 ** num_meas + size = 3**num_meas * 4**num_meas self.assertEqual(len(tomo_circuits), size) # Check circuit metadata is correct