From 81fcc103a03aedc362451eacbed717adab3f9dd9 Mon Sep 17 00:00:00 2001 From: pfafflab Date: Thu, 8 Dec 2022 15:28:47 -0600 Subject: [PATCH 1/7] big first merge --- ...guring sweeps and passing parameters.ipynb | 0 .../Introduction to sweeping.ipynb | 0 .../Basic qubit tuning.ipynb | 861 ++++++++++++++++++ .../Instrument control and calibration.ipynb | 604 ++++++++++++ ...Simple OPX setup demo without mixers.ipynb | 390 ++++++++ .../parameter_manager-parameter_manager.json | 98 ++ .../parameter_manager-simple_demo_params.json | 18 + .../opx_examples_and_templates/qmcfg.py | 214 +++++ .../qmcfg_simple_demo.py | 106 +++ labcore/analysis/__init__.py | 0 labcore/analysis/common_fits.py | 114 +++ labcore/analysis/data.py | 151 +++ labcore/analysis/fitting.py | 60 ++ labcore/analysis/resonators.py | 480 ++++++++++ labcore/analysis/single_transmon.py | 91 ++ labcore/opx/__init__.py | 0 labcore/opx/config.py | 311 +++++++ labcore/opx/machines.py | 25 + labcore/opx/mixer.py | 609 +++++++++++++ labcore/opx/sweep.py | 227 +++++ labcore/plotting/basics.py | 502 ++++++++++ labcore/setup/__init__.py | 0 labcore/setup/setup_measurements.py | 131 +++ labcore/setup/setup_notebook_analysis.py | 5 + labcore/setup/setup_opx_measurements.py | 150 +++ labcore/{measurement => sweeping}/__init__.py | 0 labcore/{ => sweeping}/ddh5.py | 6 +- labcore/{measurement => sweeping}/record.py | 0 labcore/{measurement => sweeping}/sweep.py | 4 +- prototyping/configuration.py | 2 +- test/pytest/test_run_and_save.py | 5 +- 31 files changed, 5155 insertions(+), 9 deletions(-) rename doc/examples/{ => Sweeps}/Configuring sweeps and passing parameters.ipynb (100%) rename doc/examples/{ => Sweeps}/Introduction to sweeping.ipynb (100%) create mode 100644 doc/examples/opx_examples_and_templates/Basic qubit tuning.ipynb create mode 100644 doc/examples/opx_examples_and_templates/Instrument control and calibration.ipynb create mode 100644 doc/examples/opx_examples_and_templates/Simple OPX setup demo without mixers.ipynb create mode 100755 doc/examples/opx_examples_and_templates/parameter_manager-parameter_manager.json create mode 100644 doc/examples/opx_examples_and_templates/parameter_manager-simple_demo_params.json create mode 100755 doc/examples/opx_examples_and_templates/qmcfg.py create mode 100755 doc/examples/opx_examples_and_templates/qmcfg_simple_demo.py create mode 100644 labcore/analysis/__init__.py create mode 100644 labcore/analysis/common_fits.py create mode 100644 labcore/analysis/data.py create mode 100644 labcore/analysis/fitting.py create mode 100644 labcore/analysis/resonators.py create mode 100644 labcore/analysis/single_transmon.py create mode 100644 labcore/opx/__init__.py create mode 100644 labcore/opx/config.py create mode 100644 labcore/opx/machines.py create mode 100644 labcore/opx/mixer.py create mode 100644 labcore/opx/sweep.py create mode 100644 labcore/plotting/basics.py create mode 100644 labcore/setup/__init__.py create mode 100644 labcore/setup/setup_measurements.py create mode 100644 labcore/setup/setup_notebook_analysis.py create mode 100644 labcore/setup/setup_opx_measurements.py rename labcore/{measurement => sweeping}/__init__.py (100%) rename labcore/{ => sweeping}/ddh5.py (97%) rename labcore/{measurement => sweeping}/record.py (100%) rename labcore/{measurement => sweeping}/sweep.py (99%) diff --git a/doc/examples/Configuring sweeps and passing parameters.ipynb b/doc/examples/Sweeps/Configuring sweeps and passing parameters.ipynb similarity index 100% rename from doc/examples/Configuring sweeps and passing parameters.ipynb rename to doc/examples/Sweeps/Configuring sweeps and passing parameters.ipynb diff --git a/doc/examples/Introduction to sweeping.ipynb b/doc/examples/Sweeps/Introduction to sweeping.ipynb similarity index 100% rename from doc/examples/Introduction to sweeping.ipynb rename to doc/examples/Sweeps/Introduction to sweeping.ipynb diff --git a/doc/examples/opx_examples_and_templates/Basic qubit tuning.ipynb b/doc/examples/opx_examples_and_templates/Basic qubit tuning.ipynb new file mode 100644 index 0000000..077008a --- /dev/null +++ b/doc/examples/opx_examples_and_templates/Basic qubit tuning.ipynb @@ -0,0 +1,861 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e62be073-e9a5-492c-a8f5-a08defc17f92", + "metadata": { + "tags": [] + }, + "source": [ + "# Init" + ] + }, + { + "cell_type": "markdown", + "id": "0b76e486-1e0c-471c-8b6a-d0bd160d6317", + "metadata": { + "tags": [] + }, + "source": [ + "## Gathering our instruments" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0ef8ed30-c77f-4e98-ab81-483bd96f43fb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2022-12-05 10:22:28.712] [root: INFO] Logging set up for .\n", + "[2022-12-05 10:22:28.714] [instrumentserver.client.core: INFO] Connecting to tcp://localhost:5555\n" + ] + } + ], + "source": [ + "### basic init and get the important instruments\n", + "from importlib import reload\n", + "\n", + "from instrumentserver.client import Client\n", + "from labcore.setup import setup_opx_measurements\n", + "from labcore.setup.setup_opx_measurements import *\n", + "\n", + "instruments = Client()\n", + "params = find_or_create_remote_instrument(instruments, 'parameter_manager')\n", + "\n", + "# make sure you specify the correct IP and port for your OPX system.\n", + "import qmcfg; reload(qmcfg)\n", + "qm_config = qmcfg.QMConfig(params, '128.174.248.249', '80')\n", + "\n", + "# these need to be specified so all measurement code is configured correctly\n", + "setup_opx_measurements.options.instrument_clients = {'instruments': instruments}\n", + "setup_opx_measurements.options.parameters = params\n", + "setup_opx_measurements.options.qm_config = qm_config" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4332a5c2-addb-46d4-b04d-872a182923a5", + "metadata": {}, + "outputs": [], + "source": [ + "readout_generator = find_or_create_remote_instrument(\n", + " cli=instruments,\n", + " ins_name='readout_generator'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "77ae965e-5267-459f-a1de-8d74c0f76b14", + "metadata": {}, + "source": [ + "## Imports and settings that are important for this notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "476bb7bc-ef45-46bb-bcfe-f5e2733b8cc3", + "metadata": {}, + "outputs": [], + "source": [ + "### stuff for measuring\n", + "\n", + "from labcore.measurement import *\n", + "\n", + "from qcuiuc_measurement.opx_msmt import single_transmon\n", + "\n", + "def setup_qubit_measurement_defaults(repetition_delay=500_000):\n", + " # Default readout settings\n", + " single_transmon.options.repetition_delay = repetition_delay\n", + " single_transmon.options.readout_element = 'readout'\n", + " single_transmon.options.readout_pulse = 'readout_short'\n", + " single_transmon.options.readout_integration_weight = None\n", + " single_transmon.options.prepare = single_transmon.prep_by_wait\n", + " single_transmon.options.measure_qubit = single_transmon.measure_full_integration\n", + " \n", + " # FIXME: this is clearly a bug in the single_transmon module\n", + " single_transmon.measure_qubit = single_transmon.measure_full_integration\n", + "\n", + " # Readout generator settings\n", + " readout_generator.power(4.)\n", + " readout_generator.output_status(1)\n", + " readout_generator.frequency(params.readout.LO())\n", + " \n", + "setup_qubit_measurement_defaults()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1a92a2d9-ae1a-4ffc-badf-038a61deaa51", + "metadata": {}, + "outputs": [], + "source": [ + "### basic plotting and analysis setup\n", + "\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from lmfit import Parameter\n", + "\n", + "from labcore.analysis.data import get_data, data_info, DatasetAnalysis\n", + "from labcore.analysis.plotting import setup_plotting, format_ax, add_legend, ppcolormesh, plot_data_and_fit_1d\n", + "from labcore.analysis.resonators import fit_and_plot_resonator_response\n", + "\n", + "from labcore.setup.setup_notebook_analysis import *" + ] + }, + { + "cell_type": "markdown", + "id": "b5cd731b-fcc2-4ff3-89a0-f0756172a429", + "metadata": {}, + "source": [ + "# Basic spectroscopy" + ] + }, + { + "cell_type": "markdown", + "id": "e7cf55a4-3ee5-4dbe-b8db-e639f4290db9", + "metadata": { + "tags": [] + }, + "source": [ + "## Pulsed resonator spectroscopy" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "9b815d88-5117-4a99-a60b-eecc10522f4e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2022-12-05 13:10:56.085] [plottr.data.datadict_storage: INFO] Data location: /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T131056_8b80d684-pulsed_resonator_spec/data.ddh5\n", + "[2022-12-05 13:10:56.146] [qm: INFO] Performing health check\n", + "[2022-12-05 13:10:56.149] [qm: INFO] Health check passed\n", + "[2022-12-05 13:10:56.163] [root: INFO] Integration weights file not found, using flat weights.\n", + "[2022-12-05 13:10:56.170] [qm: INFO] Performing health check\n", + "[2022-12-05 13:10:56.173] [qm: INFO] Health check passed\n", + "[2022-12-05 13:10:56.459] [qm: INFO] Flags: \n", + "[2022-12-05 13:10:56.459] [qm: INFO] Sending program to QOP\n", + "[2022-12-05 13:10:56.537] [qm: INFO] Executing program\n", + "[2022-12-05 13:10:58.381] [labcore.ddh5: INFO] The measurement has finished successfully and all of the data has been saved.\n", + "[2022-12-05 13:10:58.388] [root: INFO] \n", + "==========\n", + "Saved data at /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T131056_8b80d684-pulsed_resonator_spec:\n", + "signal: (100, 800)\n", + " ⌙ repetition: (100, 800)\n", + " ⌙ ssb_frequency: (100, 800)\n", + "=========\n" + ] + } + ], + "source": [ + "setup_qubit_measurement_defaults(repetition_delay=10_000)\n", + "\n", + "single_transmon.options.readout_pulse = 'readout_short'\n", + "single_transmon.measure_qubit = single_transmon.measure_full_integration\n", + "\n", + "measurement = single_transmon.pulsed_resonator_spec(\n", + " start=40e6,\n", + " stop=60e6,\n", + " step=0.025e6,\n", + " n_reps=100,\n", + " collector_options=dict(batchsize=100),\n", + ")\n", + "\n", + "data_loc, _ = run_measurement(sweep=measurement, name='pulsed_resonator_spec')" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "f5ad17d4-fbd8-4608-954f-a21550a99dd4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with DatasetAnalysis(data_loc) as analysis:\n", + " data = analysis.get_data('signal', avg_over='repetition')\n", + " f = data.data_vals('ssb_frequency')\n", + " sig = data.data_vals('signal') \n", + " \n", + " fig = analysis.make_figure('SSB signal', figsize=(3,3))\n", + " \n", + " # first subfig: magnitude\n", + " ax = fig.add_subplot(211)\n", + " ax.plot(f*1e-6, np.abs(sig))\n", + " ax.axvline(params.readout.IF()*1e-6, color='r')\n", + " format_ax(ax, ylabel='magnitude (a.u.)')\n", + " \n", + " ax = fig.add_subplot(212, sharex=ax)\n", + " ax.plot(f*1e-6, np.angle(sig, deg=False))\n", + " ax.axvline(params.readout.IF()*1e-6, color='r')\n", + " format_ax(ax, xlabel='frequency (MHz)', ylabel='phase (rad)')\n", + " \n", + " # this command saves the figures associated with the analysis in the data folder.\n", + " # analysis.save()" + ] + }, + { + "cell_type": "markdown", + "id": "f7d42ec3-57d8-4c6d-8e4b-96406fdc0de9", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "## Pulsed resonator spectroscopy as a function of power" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "196b1bcf-dc0a-4960-baea-ef020eba461c", + "metadata": {}, + "outputs": [], + "source": [ + "setup_qubit_measurement_defaults(repetition_delay=10_000)\n", + "\n", + "single_transmon.options.readout_pulse = 'readout_short'\n", + "single_transmon.measure_qubit = single_transmon.measure_full_integration\n", + "\n", + "measurement = single_transmon.pulsed_resonator_spec(\n", + " start=40e6,\n", + " stop=60e6,\n", + " step=0.025e6,\n", + " n_reps=100,\n", + " collector_options=dict(batchsize=100),\n", + ")\n", + "\n", + "sweep = sweep_parameter(params.readout.short.amp, np.linspace(0.01, 0.05, 10)) \\\n", + " @ measurement\n", + "data_loc, _ = run_measurement(sweep=sweep, name='pulsed_resonator_spec_vs_pwr')" + ] + }, + { + "cell_type": "markdown", + "id": "749f1ff8-8611-4cc5-b2fc-c6a42349e827", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "## Qubit spec (saturation)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "48e6d679-1581-4753-a30b-f6ea62ac2e4a", + "metadata": {}, + "outputs": [], + "source": [ + "setup_qubit_measurement_defaults()\n", + "\n", + "measurement = single_transmon.qubit_ssb_spec_saturation(\n", + " start=50e6,\n", + " stop=150e6,\n", + " step=0.1e6,\n", + " n_reps=100,\n", + " collector_options=dict(batchsize=100)\n", + ")\n", + "\n", + "data_loc, _ = run_measurement(sweep=measurement, name=f'qubit_ssb_saturation_spec')" + ] + }, + { + "cell_type": "markdown", + "id": "6a93fd34-1376-48a0-9dd7-94fe29e97c99", + "metadata": { + "tags": [] + }, + "source": [ + "## Qubit spec (pi)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1172b127-fb2c-457a-8047-61179ce30186", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cec24c6b-045e-4273-902c-b6e5846cf776", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2022-12-05 09:51:38.787] [plottr.data.datadict_storage: INFO] Data location: /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T095138_b465ef56-qubit_ssb_spec_pi/data.ddh5\n", + "[2022-12-05 09:51:38.840] [qm: INFO] Performing health check\n", + "[2022-12-05 09:51:38.843] [qm: INFO] Health check passed\n", + "[2022-12-05 09:51:38.860] [root: INFO] Integration weights file not found, using flat weights.\n", + "[2022-12-05 09:51:38.869] [qm: INFO] Performing health check\n", + "[2022-12-05 09:51:38.872] [qm: INFO] Health check passed\n", + "[2022-12-05 09:51:39.214] [qm: INFO] Flags: \n", + "[2022-12-05 09:51:39.214] [qm: INFO] Sending program to QOP\n", + "[2022-12-05 09:51:39.671] [qm: INFO] Executing program\n", + "[2022-12-05 09:51:44.973] [labcore.ddh5: INFO] The measurement has finished successfully and all of the data has been saved.\n", + "[2022-12-05 09:51:44.977] [root: INFO] \n", + "==========\n", + "Saved data at /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T095138_b465ef56-qubit_ssb_spec_pi:\n", + "signal: (100, 100)\n", + " ⌙ repetition: (100, 100)\n", + " ⌙ ssb_frequency: (100, 100)\n", + "=========\n" + ] + } + ], + "source": [ + "setup_qubit_measurement_defaults()\n", + "\n", + "# automatically try to do spec around the center\n", + "center = params.qubit.IF()\n", + "\n", + "# dynamically make a weaker pipulse to narrow the line\n", + "weaken_by = 5\n", + "amplitude = 1. / weaken_by\n", + "duration = params.qubit.drive.pipulse.nsigmas() * params.qubit.drive.pipulse.sigma() * weaken_by // 4\n", + "\n", + "\n", + "# run the measurement\n", + "measurement = single_transmon.qubit_ssb_spec_pi(\n", + " start=center-5e6,\n", + " stop=center+5e6,\n", + " step=0.1e6,\n", + " amplitude=amplitude,\n", + " duration=duration,\n", + " n_reps=100,\n", + " collector_options=dict(batchsize=100)\n", + ")\n", + "data_loc, _ = run_measurement(sweep=measurement, name='qubit_ssb_spec_pi')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "89470892-1b1b-467b-a756-8ced87ee754f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[Model]]\n", + " Model(model)\n", + "[[Fit Statistics]]\n", + " # fitting method = leastsq\n", + " # function evals = 21\n", + " # data points = 100\n", + " # variables = 4\n", + " chi-square = 6.6390e-11\n", + " reduced chi-square = 6.9156e-13\n", + " Akaike info crit = -2796.06502\n", + " Bayesian info crit = -2785.64434\n", + "[[Variables]]\n", + " x0: 1.7395e+08 +/- 13771.5996 (0.01%) (init = 1.739e+08)\n", + " sigma: 412737.870 +/- 14402.5321 (3.49%) (init = 495000)\n", + " A: -1.3032e-05 +/- 3.8240e-07 (2.93%) (init = -1.179549e-05)\n", + " of: 1.2519e-05 +/- 9.4128e-08 (0.75%) (init = 1.117075e-05)\n", + "[[Correlations]] (unreported correlations are < 0.100)\n", + " C(sigma, A) = 0.493\n", + " C(sigma, of) = 0.293\n", + " C(A, of) = -0.174\n", + "[2022-12-05 10:23:19.903] [root: INFO] updated qubit IF frequency to 173950814.28219295\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from qcuiuc_measurement.analysis.common_fits import Gaussian\n", + "\n", + "with DatasetAnalysis(data_loc) as analysis:\n", + " data = analysis.get_data('signal', avg_over='repetition')\n", + " f = data.data_vals('ssb_frequency')\n", + " sig = data.data_vals('signal').real\n", + " \n", + " fig = analysis.make_figure('Pi spec fit', figsize=(4,3))\n", + " _, fitres = plot_data_and_fit_1d(\n", + " f, sig, fit_class=Gaussian,\n", + " fig=fig, \n", + " initial_guess=True, # enable this if the guess goes wrong to see why...\n", + " xlabel='SSB frequency (Hz)', \n", + " ylabel='signal (a.u.)',\n", + " )\n", + " # TODO: save the fit report to a file as well...\n", + " \n", + " # set the corrected SSB frequency to the parameter manager\n", + " new_f0 = fitres.params['x0'].value\n", + " params.qubit.IF(new_f0)\n", + " logger.info(f'updated qubit IF frequency to {new_f0}')\n", + "\n", + " analysis.save()" + ] + }, + { + "cell_type": "markdown", + "id": "908e250a-bc84-401c-a4bb-3a47c4b6f75d", + "metadata": {}, + "source": [ + "# Qubit tune-up operations" + ] + }, + { + "cell_type": "markdown", + "id": "f1adf923-ebcb-4433-926b-0eb2fbb75563", + "metadata": {}, + "source": [ + "## Power Rabi and pi-pulse calibration" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "2c509795-4fca-4c1a-99f5-5dba99d1bbfc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2022-12-05 16:12:47.530] [plottr.data.datadict_storage: INFO] Data location: /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T161247_f33b2a36-power_rabi/data.ddh5\n", + "[2022-12-05 16:12:47.596] [qm: INFO] Performing health check\n", + "[2022-12-05 16:12:47.598] [qm: INFO] Health check passed\n", + "[2022-12-05 16:12:47.614] [root: INFO] Integration weights file not found, using flat weights.\n", + "[2022-12-05 16:12:47.622] [qm: INFO] Performing health check\n", + "[2022-12-05 16:12:47.624] [qm: INFO] Health check passed\n", + "[2022-12-05 16:12:47.894] [qm: INFO] Flags: \n", + "[2022-12-05 16:12:47.895] [qm: INFO] Sending program to QOP\n", + "[2022-12-05 16:12:47.953] [qm: INFO] Executing program\n", + "[2022-12-05 16:12:50.424] [labcore.ddh5: INFO] The measurement has finished successfully and all of the data has been saved.\n", + "[2022-12-05 16:12:50.434] [root: INFO] \n", + "==========\n", + "Saved data at /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T161247_f33b2a36-power_rabi:\n", + "signal: (100, 38)\n", + " ⌙ repetition: (100, 38)\n", + " ⌙ amplitude: (100, 38)\n", + "=========\n" + ] + } + ], + "source": [ + "setup_qubit_measurement_defaults()\n", + "\n", + "measurement = single_transmon.qubit_power_rabi(\n", + " start=-1.9,\n", + " stop=1.9,\n", + " step=0.1,\n", + " n_reps=100,\n", + " collector_options=dict(batchsize=100)\n", + ")\n", + "data_loc, _ = run_measurement(sweep=measurement, name='power_rabi')" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "a0f7a020-88b1-496b-9036-8f725d393a8b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[Model]]\n", + " Model(model)\n", + "[[Fit Statistics]]\n", + " # fitting method = leastsq\n", + " # function evals = 21\n", + " # data points = 38\n", + " # variables = 3\n", + " chi-square = 1.5934e-11\n", + " reduced chi-square = 4.5527e-13\n", + " Akaike info crit = -1077.00479\n", + " Bayesian info crit = -1072.09203\n", + "[[Variables]]\n", + " A: -6.1758e-06 +/- 1.6145e-07 (2.61%) (init = 6.489716e-06)\n", + " of: 8.7733e-06 +/- 1.1980e-07 (1.37%) (init = 9.115889e-06)\n", + " phi: 0 (fixed)\n", + " f: 0.49792511 +/- 0.00377657 (0.76%) (init = 0.5263158)\n", + "[[Correlations]] (unreported correlations are < 0.100)\n", + " C(of, f) = 0.400\n", + " C(A, f) = 0.158\n", + " C(A, of) = 0.136\n", + "[2022-12-05 16:12:52.581] [root: INFO] updated pi amp from 0.026566260807652134 to 0.026676964555142905\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from qcuiuc_measurement.analysis.common_fits import Cosine\n", + "\n", + "with DatasetAnalysis(data_loc) as analysis:\n", + " data = analysis.get_data('signal', avg_over='repetition')\n", + " amp = data.data_vals('amplitude')\n", + " sig = data.data_vals('signal').real\n", + " \n", + " # fix the phase, since we measure with positive and negative amplitude\n", + " phi = Parameter(name='phi', value=0, vary=False)\n", + " \n", + " fig = analysis.make_figure('Power rabi fit', figsize=(4,3))\n", + " _, fitres = plot_data_and_fit_1d(amp, sig, fit_class=Cosine, \n", + " fig=fig, \n", + " # initial_guess=True, # enable this if the guess goes wrong to see why...\n", + " phi=phi,\n", + " xlabel='amp (a.u.)', \n", + " ylabel='signal (a.u.)',\n", + " )\n", + " # TODO: save the fit report to a file as well...\n", + " \n", + " # calculate correction for the pi-pulse amplitude\n", + " # and set the corrected value to the parameter manager\n", + " old_pi_amp = analysis.load_saved_parameter('qubit.drive.pipulse.amp')\n", + " correction = 0.5 / fitres.params['f'].value\n", + " params.qubit.drive.pipulse.amp(old_pi_amp * correction)\n", + " logger.info(f'updated pi amp from {old_pi_amp} to {old_pi_amp * correction}')\n", + " \n", + " analysis.save()" + ] + }, + { + "cell_type": "markdown", + "id": "a47e06d9-497c-4bc3-b974-5f2b5a1684ac", + "metadata": {}, + "source": [ + "# Qubit characterization" + ] + }, + { + "cell_type": "markdown", + "id": "822daeac-fde6-42cb-9555-8228cd2b0994", + "metadata": {}, + "source": [ + "## Qubit T1" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "48322c9b-ee8c-44f5-abee-ed61719cedce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2022-12-05 10:53:11.457] [plottr.data.datadict_storage: INFO] Data location: /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T105311_4d66ce70-qubit_T1/data.ddh5\n", + "[2022-12-05 10:53:11.509] [qm: INFO] Performing health check\n", + "[2022-12-05 10:53:11.513] [qm: INFO] Health check passed\n", + "[2022-12-05 10:53:11.529] [root: INFO] Integration weights file not found, using flat weights.\n", + "[2022-12-05 10:53:11.540] [qm: INFO] Performing health check\n", + "[2022-12-05 10:53:11.542] [qm: INFO] Health check passed\n", + "[2022-12-05 10:53:11.880] [qm: INFO] Flags: \n", + "[2022-12-05 10:53:11.881] [qm: INFO] Sending program to QOP\n", + "[2022-12-05 10:53:12.288] [qm: INFO] Executing program\n", + "[2022-12-05 10:53:18.074] [labcore.ddh5: INFO] The measurement has finished successfully and all of the data has been saved.\n", + "[2022-12-05 10:53:18.077] [root: INFO] \n", + "==========\n", + "Saved data at /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T105311_4d66ce70-qubit_T1:\n", + "signal: (100, 100)\n", + " ⌙ repetition: (100, 100)\n", + " ⌙ delay: (100, 100)\n", + "=========\n" + ] + } + ], + "source": [ + "setup_qubit_measurement_defaults()\n", + "\n", + "measurement = single_transmon.qubit_T1(\n", + " start=20,\n", + " stop=20+100e3,\n", + " step=1000,\n", + " n_reps=100,\n", + " collector_options=dict(batchsize=100)\n", + ")\n", + "\n", + "data_loc, _ = run_measurement(sweep=measurement, name='qubit_T1')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "9aba6f14-9407-467d-89f2-a5e60fbfe5c2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[Model]]\n", + " Model(model)\n", + "[[Fit Statistics]]\n", + " # fitting method = leastsq\n", + " # function evals = 17\n", + " # data points = 100\n", + " # variables = 3\n", + " chi-square = 7.3283e-11\n", + " reduced chi-square = 7.5549e-13\n", + " Akaike info crit = -2788.18632\n", + " Bayesian info crit = -2780.37081\n", + "[[Variables]]\n", + " A: -1.2255e-05 +/- 3.7303e-07 (3.04%) (init = -1.426641e-05)\n", + " of: 1.2468e-05 +/- 1.7012e-07 (1.36%) (init = 1.259413e-05)\n", + " tau: 19.9773626 +/- 1.33714135 (6.69%) (init = 15.02)\n", + "[[Correlations]] (unreported correlations are < 0.100)\n", + " C(of, tau) = 0.754\n", + " C(A, tau) = 0.380\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from qcuiuc_measurement.analysis.common_fits import ExponentialDecay\n", + "\n", + "with DatasetAnalysis(data_loc) as analysis:\n", + " data = analysis.get_data('signal', avg_over='repetition')\n", + " delay = data.data_vals('delay') * 1e-3\n", + " sig = data.data_vals('signal').real\n", + " \n", + " fig = analysis.make_figure('T1 fit', figsize=(4,3))\n", + " _, fitres = plot_data_and_fit_1d(\n", + " delay, sig, fit_class=ExponentialDecay, \n", + " fig=fig, \n", + " # initial_guess=True, # enable this if the guess goes wrong to see why...\n", + " xlabel='delay (us)', \n", + " ylabel='signal (a.u.)',\n", + " )\n", + " # TODO: save the fit report to a file as well...\n", + " \n", + " analysis.save()" + ] + }, + { + "cell_type": "markdown", + "id": "fca039f0-b320-4893-973e-abacace389e3", + "metadata": {}, + "source": [ + "## Qubit T2" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "a97289ff-eaf4-4e6b-bde5-ae6f11e714b5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2022-12-05 12:42:22.832] [plottr.data.datadict_storage: INFO] Data location: /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T124222_8e532cee-qubit_T2-1_Echo_0.42MHz_detuned/data.ddh5\n", + "[2022-12-05 12:42:22.891] [qm: INFO] Performing health check\n", + "[2022-12-05 12:42:22.894] [qm: INFO] Health check passed\n", + "[2022-12-05 12:42:22.908] [root: INFO] Integration weights file not found, using flat weights.\n", + "[2022-12-05 12:42:22.916] [qm: INFO] Performing health check\n", + "[2022-12-05 12:42:22.920] [qm: INFO] Health check passed\n", + "[2022-12-05 12:42:23.225] [qm: INFO] Flags: \n", + "[2022-12-05 12:42:23.225] [qm: INFO] Sending program to QOP\n", + "[2022-12-05 12:42:23.375] [qm: INFO] Executing program\n", + "[2022-12-05 12:42:29.238] [labcore.ddh5: INFO] The measurement has finished successfully and all of the data has been saved.\n", + "[2022-12-05 12:42:29.241] [root: INFO] \n", + "==========\n", + "Saved data at /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T124222_8e532cee-qubit_T2-1_Echo_0.42MHz_detuned:\n", + "signal: (100, 100)\n", + " ⌙ repetition: (100, 100)\n", + " ⌙ delay: (100, 100)\n", + "=========\n" + ] + } + ], + "source": [ + "setup_qubit_measurement_defaults()\n", + "\n", + "n_echos = 1\n", + "step = 200\n", + "period = 12 * step\n", + "detuning = 1./period * 1e3\n", + "\n", + "measurement = single_transmon.qubit_T2(\n", + " start=20,\n", + " stop=20+(40e3//(n_echos + 1)),\n", + " step=step,\n", + " n_reps=100,\n", + " detuning_MHz=detuning,\n", + " n_echos=n_echos,\n", + " collector_options=dict(batchsize=100)\n", + ")\n", + "\n", + "data_loc, _ = run_measurement(sweep=measurement, name=f'qubit_T2-{n_echos}_Echo_{detuning:.2f}MHz_detuned')" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "f92a22b0-137c-409f-ba5b-b5e7c731a4b7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[Model]]\n", + " Model(model)\n", + "[[Fit Statistics]]\n", + " # fitting method = leastsq\n", + " # function evals = 162\n", + " # data points = 100\n", + " # variables = 5\n", + " chi-square = 8.5925e-11\n", + " reduced chi-square = 9.0447e-13\n", + " Akaike info crit = -2768.27165\n", + " Bayesian info crit = -2755.24580\n", + "[[Variables]]\n", + " A: -6.3807e-06 +/- 3.7114e-07 (5.82%) (init = -6.018747e-06)\n", + " of: 6.2250e-06 +/- 9.5360e-08 (1.53%) (init = 6.170345e-06)\n", + " phi: 88.3274493 +/- 3.47371810 (3.93%) (init = -37.78915)\n", + " f: 0.20879616 +/- 6.9269e-04 (0.33%) (init = 0.35)\n", + " tau: 23.8581666 +/- 2.43607959 (10.21%) (init = 20.04)\n", + "[[Correlations]] (unreported correlations are < 0.100)\n", + " C(phi, f) = -0.760\n", + " C(A, tau) = 0.745\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from qcuiuc_measurement.analysis.common_fits import ExponentiallyDecayingSine\n", + "\n", + "with DatasetAnalysis(data_loc) as analysis:\n", + " data = analysis.get_data('signal', avg_over='repetition')\n", + " delay = data.data_vals('delay') * 1e-3\n", + " sig = data.data_vals('signal').real\n", + " \n", + " fig = analysis.make_figure('T2 fit', figsize=(4,3))\n", + " _, fitres = plot_data_and_fit_1d(\n", + " delay, sig, fit_class=ExponentiallyDecayingSine, \n", + " fig=fig, \n", + " # initial_guess=True, # enable this if the guess goes wrong to see why...\n", + " xlabel='delay (us)', \n", + " ylabel='signal (a.u.)',\n", + " )\n", + " # TODO: save the fit report to a file as well...\n", + " \n", + " analysis.save()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bfd77830-f831-4395-97d2-17dbdeac655e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:qcodes]", + "language": "python", + "name": "conda-env-qcodes-py" + }, + "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.9.15" + }, + "toc-autonumbering": true + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/doc/examples/opx_examples_and_templates/Instrument control and calibration.ipynb b/doc/examples/opx_examples_and_templates/Instrument control and calibration.ipynb new file mode 100644 index 0000000..d2ecd14 --- /dev/null +++ b/doc/examples/opx_examples_and_templates/Instrument control and calibration.ipynb @@ -0,0 +1,604 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2071e4f2-8bf7-4d17-9904-9b1d9945a566", + "metadata": { + "tags": [] + }, + "source": [ + "# Tools" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "333492aa-29f1-440f-8a82-d14e55ef2df6", + "metadata": {}, + "outputs": [], + "source": [ + "import tabulate\n", + "\n", + "def instrument_info_table(instrument, *properties):\n", + " data = [['name', instrument.name]]\n", + " for p in properties:\n", + " data.append([p, instrument.get(p)])\n", + " return tabulate.tabulate(data, tablefmt='html')\n", + " \n", + "signalcore_info = lambda ins: instrument_info_table(\n", + " ins, 'frequency', 'power', 'output_status', 'temperature', 'reference_source',\n", + ") " + ] + }, + { + "cell_type": "markdown", + "id": "2aaf53c1-514b-4f3e-92b5-caa9d49e6ea0", + "metadata": {}, + "source": [ + "# Load instruments" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8d0911ea-8450-44b7-aacf-924e0a64c409", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2022-12-05 13:05:15.953] [root: INFO] Logging set up for .\n", + "[2022-12-05 13:05:15.954] [instrumentserver.client.core: INFO] Connecting to tcp://localhost:5555\n" + ] + } + ], + "source": [ + "### basic init and get the important instruments\n", + "from importlib import reload\n", + "\n", + "from instrumentserver.client import Client\n", + "from labcore.setup import setup_opx_measurements\n", + "from labcore.setup.setup_opx_measurements import *\n", + "\n", + "instruments = Client()\n", + "params = find_or_create_remote_instrument(instruments, 'parameter_manager')\n", + "\n", + "# make sure you specify the correct IP and port for your OPX system.\n", + "import qmcfg; reload(qmcfg)\n", + "qm_config = qmcfg.QMConfig(params, '128.174.248.249', '80')\n", + "\n", + "# these need to be specified so all measurement code is configured correctly\n", + "setup_opx_measurements.options.instrument_clients = {'instruments': instruments}\n", + "setup_opx_measurements.options.parameters = params\n", + "setup_opx_measurements.options.qm_config = qm_config" + ] + }, + { + "cell_type": "markdown", + "id": "5809901c-20c0-4a3f-85cc-c575fdeb11ed", + "metadata": {}, + "source": [ + "## Hardware" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "b0a40755-0e4d-4621-b831-d42bc8ed4a88", + "metadata": {}, + "outputs": [], + "source": [ + "### load spike -- running remotely on a windows laptop\n", + "spike = find_or_create_remote_instrument(\n", + " cli=instruments,\n", + " ins_name='spike',\n", + " ins_class='tfe_hardware.qcodes_instrument_drivers.SignalHound.Spike.Spike',\n", + " address='TCPIP::192.168.1.202::5025::SOCKET'\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ba246b5c-e146-4087-a36f-1d90017cda24", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "c2ba109b-a91c-4553-94dd-1ba510f95907", + "metadata": {}, + "source": [ + "### Generators" + ] + }, + { + "cell_type": "markdown", + "id": "a2d1007e-58f4-4e92-a619-f894a2fb447c", + "metadata": {}, + "source": [ + "#### readout generator" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e28e2105-7900-42ec-a50b-73ed11f30659", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name readout_generator
frequency 7219500000.0
power 4.0
output_status 1
temperature 31.09375
reference_source1
" + ], + "text/plain": [ + "'\\n\\n\\n\\n\\n\\n\\n\\n\\n
name readout_generator
frequency 7219500000.0
power 4.0
output_status 1
temperature 31.09375
reference_source1
'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### the various microwave generators\n", + "readout_generator = find_or_create_remote_instrument(\n", + " cli=instruments,\n", + " ins_name='readout_generator',\n", + " ins_class='tfe_hardware.qcodes_instrument_drivers.SignalCore.SignalCore_sc5511a.SignalCore_SC5511A',\n", + " serial_number='10002615',\n", + ")\n", + "signalcore_info(readout_generator)" + ] + }, + { + "cell_type": "markdown", + "id": "682a13d3-2c60-4291-b25d-d3f3afb4db30", + "metadata": { + "tags": [] + }, + "source": [ + "#### qubit generator" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b81095fe-8b10-432a-bbb0-25b977236503", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "qubit_generator = find_or_create_remote_instrument(\n", + " cli=instruments,\n", + " ins_name='qubit_generator',\n", + " ins_class='tfe_hardware.qcodes_instrument_drivers.SignalCore.SignalCore_sc5511a.SignalCore_SC5511A',\n", + " serial_number='10002613',\n", + ")\n", + "signalcore_info(qubit_generator)" + ] + }, + { + "cell_type": "markdown", + "id": "b89aea8e-517f-486a-b686-1f5d33b9e2d5", + "metadata": { + "tags": [] + }, + "source": [ + "#### TWPA pump generator" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "ffe520cb-057d-426a-8590-5b9699dac392", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name twpa_generator
frequency 8000000000.0
power 3.0
output_status 0
temperature 74.875
reference_source1
" + ], + "text/plain": [ + "'\\n\\n\\n\\n\\n\\n\\n\\n\\n
name twpa_generator
frequency 8000000000.0
power 3.0
output_status 0
temperature 74.875
reference_source1
'" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "twpa_generator = find_or_create_remote_instrument(\n", + " cli=instruments,\n", + " ins_name='twpa_generator',\n", + " ins_class='tfe_hardware.qcodes_instrument_drivers.SignalCore.SignalCore_sc5511a.SignalCore_SC5511A',\n", + " serial_number='1000261D',\n", + ")\n", + "signalcore_info(twpa_generator)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53d6b019-29fa-4606-ad91-14e43320f946", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "e7c1bb13-b31b-45b3-a0bb-2a2f66af108f", + "metadata": {}, + "source": [ + "## Mixer configuration" + ] + }, + { + "cell_type": "markdown", + "id": "6dce04aa-a9dd-4616-8c43-dacbceed7552", + "metadata": {}, + "source": [ + "### readout mixer" + ] + }, + { + "cell_type": "markdown", + "id": "64d6169c-91a2-4468-a2f8-2bbd47c93892", + "metadata": {}, + "source": [ + "#### mixer setup and manual tuning tool\n", + "\n", + "This snipped will create a mixer object that allows us to do most things.\n", + "It'll also run a constant tone and display a simple widget for messing with the mixer settings.\n", + "By looking at the spectrum we can manually tune the mixer with this." + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "922d9b02-6b05-4a0c-a767-f0f1f3ce4848", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2022-12-05 16:04:46.740] [qm: INFO] Performing health check\n", + "[2022-12-05 16:04:46.743] [qm: INFO] Health check passed\n", + "[2022-12-05 16:04:46.759] [root: INFO] Integration weights file not found, using flat weights.\n", + "[2022-12-05 16:04:46.768] [qm: INFO] Performing health check\n", + "[2022-12-05 16:04:46.771] [qm: INFO] Health check passed\n", + "[2022-12-05 16:04:47.026] [qm: INFO] Flags: \n", + "[2022-12-05 16:04:47.026] [qm: INFO] Sending program to QOP\n", + "[2022-12-05 16:04:47.049] [qm: INFO] Executing program\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "44af3af1e4de42fb9a7b3ed24557168a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(VBox(children=(FloatText(value=0.01, description='dc of. step:', step=0.001), HBox(children=(Bu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "readout_mixer = add_mixer_config('readout', analyzer=spike, generator=readout_generator)\n", + "readout_mixer.run_constant_waveform()\n", + "mixer_tuning_tool(readout_mixer)" + ] + }, + { + "cell_type": "markdown", + "id": "1dcba9de-6781-4c41-bb73-108126df40a4", + "metadata": { + "tags": [] + }, + "source": [ + "#### Mixer optimization" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8322c740-85da-45f3-982e-cfb6f766c9ee", + "metadata": {}, + "outputs": [], + "source": [ + "calibrate_mixer(readout_mixer.config)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5f742e06-73e2-4535-8f7c-9fb47edd29e6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "92d642be-9f77-458c-a039-a610872eafac", + "metadata": {}, + "source": [ + "### qubit mixer" + ] + }, + { + "cell_type": "markdown", + "id": "abadecee-7376-420f-910f-3801a66b4770", + "metadata": {}, + "source": [ + "#### mixer setup and manual tuning tool\n", + "\n", + "This snipped will create a mixer object that allows us to do most things.\n", + "It'll also run a constant tone and display a simple widget for messing with the mixer settings.\n", + "By looking at the spectrum we can manually tune the mixer with this." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "31db9ac7-c141-4d42-a7e1-25cb53b77210", + "metadata": {}, + "outputs": [], + "source": [ + "qubit_mixer = add_mixer_config('qubit', analyzer=spike, generator=qubit_generator)\n", + "qubit_mixer.run_constant_waveform()\n", + "mixer_tuning_tool(qubit_mixer)" + ] + }, + { + "cell_type": "markdown", + "id": "25290ee2-eadd-47bd-b8a6-2d61609d0af8", + "metadata": { + "tags": [] + }, + "source": [ + "#### Mixer optimization" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ed9fdac-2331-41a8-b4cf-67af1f535342", + "metadata": {}, + "outputs": [], + "source": [ + "calibrate_mixer(qubit.config)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9087a929-7aee-4600-b151-d32a3b57544d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "31b4dcbb-0c0d-46ed-833d-0c60125ce7bb", + "metadata": { + "tags": [] + }, + "source": [ + "# Test demodulation of readout signal" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "9cfd3116-c8f3-4a0b-9c91-4363e50166de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2022-12-05 16:12:07.738] [plottr.data.datadict_storage: INFO] Data location: /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T161207_db837402-test_through/data.ddh5\n", + "[2022-12-05 16:12:07.795] [qm: INFO] Performing health check\n", + "[2022-12-05 16:12:07.798] [qm: INFO] Health check passed\n", + "[2022-12-05 16:12:07.812] [root: INFO] Integration weights file not found, using flat weights.\n", + "[2022-12-05 16:12:07.820] [qm: INFO] Performing health check\n", + "[2022-12-05 16:12:07.823] [qm: INFO] Health check passed\n", + "[2022-12-05 16:12:08.255] [qm: INFO] Flags: \n", + "[2022-12-05 16:12:08.255] [qm: INFO] Sending program to QOP\n", + "[2022-12-05 16:12:08.517] [qm: INFO] Executing program\n", + "[2022-12-05 16:12:08.788] [labcore.ddh5: INFO] The measurement has finished successfully and all of the data has been saved.\n", + "[2022-12-05 16:12:08.796] [root: INFO] \n", + "==========\n", + "Saved data at /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T161207_db837402-test_through:\n", + "I: (100, 50)\n", + " ⌙ I_time_points: (100, 50)\n", + " ⌙ repetition: (100,)\n", + "Q: (100, 50)\n", + " ⌙ Q_time_points: (100, 50)\n", + " ⌙ repetition: (100,)\n", + "raw_signal: (100, 1000)\n", + " ⌙ raw_signal_time_points: (100, 1000)\n", + " ⌙ repetition: (100,)\n", + "=========\n" + ] + } + ], + "source": [ + "from qm.qua import *\n", + "from labcore.measurement import independent\n", + "from qcuiuc_measurement.opx_tools.sweep import \\\n", + " RecordOPXdata, ComplexOPXData, TimedOPXData\n", + "\n", + "@RecordOPXdata(\n", + " independent('repetition'),\n", + " TimedOPXData('raw_signal', depends_on=['repetition']),\n", + " TimedOPXData('I', depends_on=['repetition']),\n", + " TimedOPXData('Q', depends_on=['repetition']),\n", + ")\n", + "def simple_demod(n_reps=10, rep_delay_ns=0):\n", + " _chunksize = int(20 // 4)\n", + " _n_chunks = params.readout.short.len() // (4 * _chunksize)\n", + " \n", + " with program() as raw_measurement:\n", + " rep_stream = declare_stream()\n", + " raw_stream = declare_stream(adc_trace=True)\n", + " i_stream = declare_stream()\n", + " q_stream = declare_stream()\n", + "\n", + " rep = declare(int)\n", + " I = declare(fixed, size=_n_chunks)\n", + " Q = declare(fixed, size=_n_chunks)\n", + " j = declare(int)\n", + " \n", + " with for_(rep, 0, rep < n_reps, rep + 1):\n", + " measure('readout_short', 'readout', raw_stream, \n", + " demod.sliced(\"readout_short_sliced_cos\", I, _chunksize),\n", + " demod.sliced(\"readout_short_sliced_sin\", Q, _chunksize),)\n", + " \n", + " save(rep, rep_stream)\n", + " \n", + " with for_(j, 0, j < _n_chunks, j + 1):\n", + " save(I[j], i_stream)\n", + " save(Q[j], q_stream)\n", + " \n", + " if rep_delay_ns > 20:\n", + " wait(int(rep_delay_ns)//4)\n", + "\n", + " with stream_processing():\n", + " raw_stream.input1().save_all('raw_signal')\n", + " rep_stream.save_all('repetition')\n", + " i_stream.buffer(_n_chunks).save_all('I')\n", + " q_stream.buffer(_n_chunks).save_all('Q')\n", + " \n", + " return raw_measurement\n", + "\n", + "\n", + "readout_generator.power(4.)\n", + "readout_generator.output_status(1)\n", + "readout_generator.frequency(params.readout.LO())\n", + "\n", + "measurement = simple_demod(\n", + " n_reps=100, \n", + " rep_delay_ns=1e4,\n", + " collector_options=dict(batchsize=10),\n", + ")\n", + "\n", + "data_loc, _ = run_measurement(sweep=measurement, name='test_through')" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "e33e7fb2-7487-4b2a-bfeb-7ea10eb7422a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### using the DatasetAnalysis context helps us to load data easily, and automatically save plots in the right folder.\n", + "\n", + "from qcuiuc_measurement.analysis.data import get_data, data_info, DatasetAnalysis\n", + "from qcuiuc_measurement.analysis.plotting import setup_plotting, format_ax, add_legend, ppcolormesh\n", + "from qcuiuc_measurement.setup_notebook_analysis import *\n", + "\n", + "with DatasetAnalysis(data_loc) as analysis:\n", + " i_data = analysis.get_data('I', avg_over='repetition')\n", + " q_data = analysis.get_data('Q', avg_over='repetition')\n", + " raw_data = analysis.get_data('raw_signal', avg_over=None)\n", + " \n", + " fig = analysis.make_figure('a plot', figsize=(4,2))\n", + " \n", + " # first subfig: plot the raw voltage as a colormap. We set the limits such that 0 is the middle.\n", + " ax = fig.add_subplot(121)\n", + " im = ax.imshow(\n", + " raw_data.data_vals('raw_signal').T, \n", + " interpolation='none',\n", + " cmap='bwr',\n", + " aspect='auto',\n", + " )\n", + " format_ax(ax, xlabel='time (ns)', ylabel='repetition')\n", + " cb = fig.colorbar(im, ax=ax, location='top')\n", + " cb.set_label('ADC signal (a.u.)')\n", + " \n", + " # second subfig: plot one example trace of demodulated I and Q.\n", + " ax = fig.add_subplot(122)\n", + " ax.plot(i_data.data_vals('I_time_points'), i_data.data_vals('I'), '-',\n", + " label='I')\n", + " ax.plot(q_data.data_vals('Q_time_points'), q_data.data_vals('Q'), '-',\n", + " label='Q')\n", + " format_ax(ax, xlabel='time (chunks)', ylabel='demod. signal (a.u.)')\n", + " ax.legend(loc='best')\n", + " \n", + " # this command saves the figures associated with the analysis in the data folder.\n", + " analysis.save()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5994bbdb-5219-4b3a-8c5b-26db576ed80a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:qcodes]", + "language": "python", + "name": "conda-env-qcodes-py" + }, + "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.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/doc/examples/opx_examples_and_templates/Simple OPX setup demo without mixers.ipynb b/doc/examples/opx_examples_and_templates/Simple OPX setup demo without mixers.ipynb new file mode 100644 index 0000000..8ce2185 --- /dev/null +++ b/doc/examples/opx_examples_and_templates/Simple OPX setup demo without mixers.ipynb @@ -0,0 +1,390 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "491887ef-8a6e-47fd-b99d-cbd6da3aef7f", + "metadata": {}, + "source": [ + "# README" + ] + }, + { + "cell_type": "markdown", + "id": "73a77995-e2e2-4631-b445-b29405fa9ad7", + "metadata": {}, + "source": [ + "This notebook is a good starting point for learning how we run our measurements.\n", + "We will setup a 'dry run', i.e., perform a dummy measurement in which we will simply directly measure the output of the OPX.\n", + "\n", + "We assume that one of the DACs of the OPX is directly connected to one of the ADCs.\n", + "\n", + "To use this notebook, you have to do the following things first:\n", + "- make sure you have a valid configuration for the OPX. You'll probably have to read the QUA code a bit and make sure it's all compatible. This notebook comes with one that was used to test this notebook. It makes use of the ParameterManager (see next point). Make sure the config corresponds correctly with your hardware setup.\n", + "- have instrumentserver started, and a ParameterManager instrument instantiated. This notebook comes with pre-saved parameters that were used during testing. They are used in the OPX config.\n", + "\n", + "Once this is done, you should be able to execute the below (some config needed)." + ] + }, + { + "cell_type": "markdown", + "id": "de86362f-ebb8-43a8-8f8c-b213176f507b", + "metadata": { + "tags": [] + }, + "source": [ + "# Initialization" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "cb1cc0c8-cde3-43ec-821f-52a7d9d3f49d", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "65ac0359-bee0-4464-a4e5-573435d89255", + "metadata": { + "tags": [] + }, + "source": [ + "## setup for measurements\n", + "\n", + "This should be the only place where specific settings of your setup need to be declared." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f7070441-19e6-41eb-adb9-ba54c3f1f275", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2022-12-01 18:14:50.673] [root: INFO] Logging set up for .\n", + "[2022-12-01 18:14:50.674] [instrumentserver.client.core: INFO] Connecting to tcp://localhost:5555\n" + ] + } + ], + "source": [ + "### basic measurement setup\n", + "\n", + "from instrumentserver.client import Client\n", + "from labcore.setup import setup_opx_measurements\n", + "from labcore.setup.setup_opx_measurements import *\n", + "\n", + "# get the client to the instrumentserver, with default settings.\n", + "isrvr = Client()\n", + "\n", + "# fill in the name of your parameter manager instrument.\n", + "params = find_or_create_remote_instrument(isrvr, 'simple_demo_params') \n", + "\n", + "# make sure you specify the correct IP and port for your OPX system.\n", + "import qmcfg_simple_demo as qmcfg\n", + "qm_config = qmcfg.QMConfig(params, '128.174.248.249', '80')\n", + "\n", + "# these need to be specified so all measurement code is configured correctly\n", + "setup_opx_measurements.options.instrument_clients = {'instruments': isrvr}\n", + "setup_opx_measurements.options.parameters = params\n", + "setup_opx_measurements.options.qm_config = qm_config" + ] + }, + { + "cell_type": "markdown", + "id": "b2221e64-8eb1-4644-ae7d-6d7d56fb84f4", + "metadata": {}, + "source": [ + "## setup for analysis\n", + "\n", + "we import everything we need below to load data and analyze it." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "66c4054e-f5ee-44cb-beba-11721b05959c", + "metadata": {}, + "outputs": [], + "source": [ + "### basic plotting and analysis setup\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from qcuiuc_measurement.analysis.data import get_data, data_info, DatasetAnalysis\n", + "from qcuiuc_measurement.analysis.plotting import setup_plotting, format_ax, add_legend, ppcolormesh\n", + "\n", + "from qcuiuc_measurement.setup_notebook_analysis import *" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "98d9c0af-3305-45bb-946d-2b7f4eeeed8a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "122fa691-a795-46f6-9c85-57c5cefa9e44", + "metadata": {}, + "source": [ + "# Measurements" + ] + }, + { + "cell_type": "markdown", + "id": "23e5f596-1366-4fc9-9e8e-1be09633fe2b", + "metadata": {}, + "source": [ + "## Raw data example: directly measure the DAC output with the ADC" + ] + }, + { + "cell_type": "markdown", + "id": "88658a24-3c54-4e7e-a665-02e1ac3a0564", + "metadata": {}, + "source": [ + "### Run the measurement" + ] + }, + { + "cell_type": "markdown", + "id": "6c0236d9-81a6-41f8-91ce-84e56d87d933", + "metadata": {}, + "source": [ + "Here, we define the entire measurment in the notebook.\n", + "For measurements that we use regularly in some standard from, the QUA code is often placed into some version controlled module.\n", + "\n", + "Just for illustration and as a basic tutorial, we leave it here in this case.\n", + "\n", + "This measurement is very basic -- we play a readout pulse and directly read it in again.\n", + "We include the raw data. See QM docs for reference.\n", + "\n", + "We make use of our own sweep framework that enables us to hide a lot of technical overhead in the background here.\n", + "It also automatically sets up correctly labeled data." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "d069b637-073c-43df-bfc2-f9e034fc5f59", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2022-12-02 17:16:35.522] [plottr.data.datadict_storage: INFO] Data location: /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-02/2022-12-02T171635_5da67cea-test/data.ddh5\n", + "[2022-12-02 17:16:35.532] [qm: INFO] Performing health check\n", + "[2022-12-02 17:16:35.534] [qm: INFO] Health check passed\n", + "[2022-12-02 17:16:35.540] [root: INFO] Integration weights file not found, using flat weights.\n", + "[2022-12-02 17:16:35.547] [qm: INFO] Performing health check\n", + "[2022-12-02 17:16:35.550] [qm: INFO] Health check passed\n", + "chunksize: 5\n", + "n_chunks: 50\n", + "[2022-12-02 17:16:35.605] [qm: INFO] Flags: \n", + "[2022-12-02 17:16:35.606] [qm: INFO] Sending program to QOP\n", + "[2022-12-02 17:16:35.857] [qm: INFO] Executing program\n", + "[2022-12-02 17:16:36.216] [labcore.ddh5: INFO] The measurement has finished successfully and all of the data has been saved.\n" + ] + } + ], + "source": [ + "from qm.qua import *\n", + "from labcore.measurement import independent\n", + "from qcuiuc_measurement.opx_tools.sweep import \\\n", + " RecordOPXdata, ComplexOPXData, TimedOPXData\n", + "\n", + "@RecordOPXdata(\n", + " independent('repetition'),\n", + " TimedOPXData('raw_signal', depends_on=['repetition']),\n", + " TimedOPXData('I', depends_on=['repetition']),\n", + " TimedOPXData('Q', depends_on=['repetition']),\n", + ")\n", + "def measure_opx_output(n_reps=10, rep_delay_ns=0):\n", + " # this is in units of 4 ns.\n", + " # for the data to look 'good', make sure that you have a chunksize that has an even number of\n", + " # IF periods contained in it.\n", + " _chunksize = int(20 // 4)\n", + " _n_chunks = params.readout.short.len() // (4 * _chunksize)\n", + " \n", + " with program() as raw_measurement:\n", + " rep_stream = declare_stream()\n", + " raw_stream = declare_stream(adc_trace=True)\n", + " i_stream = declare_stream()\n", + " q_stream = declare_stream()\n", + "\n", + " rep = declare(int)\n", + " I = declare(fixed, size=_n_chunks)\n", + " Q = declare(fixed, size=_n_chunks)\n", + " j = declare(int)\n", + " \n", + " with for_(rep, 0, rep < n_reps, rep + 1):\n", + " measure('readout_short', 'readout', raw_stream, \n", + " demod.sliced(\"readout_short_sliced_cos\", I, _chunksize),\n", + " demod.sliced(\"readout_short_sliced_sin\", Q, _chunksize),)\n", + " \n", + " save(rep, rep_stream)\n", + " \n", + " with for_(j, 0, j < _n_chunks, j + 1):\n", + " save(I[j], i_stream)\n", + " save(Q[j], q_stream)\n", + " \n", + " if rep_delay_ns > 20:\n", + " wait(int(rep_delay_ns)//4)\n", + "\n", + " with stream_processing():\n", + " raw_stream.input2().save_all('raw_signal')\n", + " rep_stream.save_all('repetition')\n", + " i_stream.buffer(_n_chunks).save_all('I')\n", + " q_stream.buffer(_n_chunks).save_all('Q')\n", + " \n", + " return raw_measurement\n", + "\n", + "\n", + "measurement = measure_opx_output(n_reps=100,\n", + " rep_delay_ns=1e6, \n", + " collector_options=dict(batchsize=10)\n", + " )\n", + "data_loc, _ = run_measurement(sweep=measurement, name='test')" + ] + }, + { + "cell_type": "markdown", + "id": "c8808475-cfe4-4fe6-90a7-fe92c4213857", + "metadata": {}, + "source": [ + "### Analyse the data" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "77fed77a-e931-4879-8de9-67581696b33a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I: (100, 50)\n", + " ⌙ I_time_points: (100, 50)\n", + " ⌙ repetition: (100,)\n", + "Q: (100, 50)\n", + " ⌙ Q_time_points: (100, 50)\n", + " ⌙ repetition: (100,)\n", + "raw_signal: (100, 1000)\n", + " ⌙ raw_signal_time_points: (100, 1000)\n", + " ⌙ repetition: (100,)\n" + ] + } + ], + "source": [ + "### get some basic information about the data we just wrote\n", + "data_info(data_loc)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "eaa38d47-eefe-4254-aee3-299f686d757f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/pfafflab/Documents/github/measurement-tools/qcuiuc_measurement/analysis/plotting.py:264: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3. Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading']. This will become an error two minor releases later.\n", + " im = ax.pcolormesh(_x, _y, z, cmap=cmap, **kw)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzcAAAGnCAYAAACKKKmwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAB7CAAAewgFu0HU+AACsnElEQVR4nOzdd3gU5doG8Ht302kJkNC7EpCOICBFBEQEEQQRDgooqHQL6BHbERsgTaSIoqCADQ9NKWLBXijnQxAkCCglgJBASEJ6NjvfH5ssO31ms5stuX/XxUUy5Z13ZieQ933mecYiCIIAIiIiIiKiIGf1dweIiIiIiIi8gYMbIiIiIiIKCRzcEBERERFRSODghoiIiIiIQgIHN0REREREFBI4uCEiIiIiopDAwQ0REREREYUEDm6IiIiIiCgkcHBDREREREQhgYMbIiIiIiIKCRzcEBERERFRSODghoiIiIiIQgIHN0REREREFBI4uCEiIiIiopDAwQ0REREREYUEDm6IiIiIiCgkcHBDREREREQhgYMbIiIiIiIKCRzcEBERERFRSODghoiIAtbu3buRmJiIzMxMf3eFvOTMmTNITExEUlKSv7tCRCGIgxsiUrVixQrcfffduP7669GlSxdMmjQJf//9t2ib/Px8vPDCC+jUqRPatWuHqVOn4uLFi671R44cwfTp03HzzTejTZs2uO2227B69WpRG1999RXGjRuHG2+8Ee3bt8fw4cPx448/6vbvyy+/xLhx49CpUyfFX5bOnDmDZ599Frfccgtat26NPn36YPHixSgoKNBte/fu3bjzzjvRsmVL3HLLLdi4caPha1PyC7nWn927dyMlJQXTp0/HrbfeimbNmuGVV16R9aNXr16K+7/wwguubdatW4dRo0ahffv2mgOBjRs3YuDAgWjVqhW6du2KF1980bXuf//7H0aMGIFOnTqhdevWuO2227BmzRrR/kuWLJH1o1+/frrXssSoUaNk+//nP/8xvL8ZFy5cwOOPP45OnTqhTZs2GDRoEA4dOgTg6i/XSn8+//xzn/THqBkzZmDSpElebXPJkiUYNGiQV9ssa6NGjVL8+SAikgrzdweIKHDt3r0bI0aMQKtWrVBUVISFCxdi3Lhx2LZtG2JiYgAAs2bNwvfff49FixahUqVKeOmllzBlyhR8/PHHAIBDhw4hLi4Or776KmrVqoV9+/bhP//5D2w2G+69914AwJ49e9C5c2c88sgjqFy5MjZu3IiJEyfik08+wXXXXafav5ycHLRr1w79+vXDs88+K1v/999/o6ioCM8//zwaNGiAo0eP4rnnnkNubi6efPJJ1XaTk5Mxfvx4jBgxAvPnz8evv/6KZ599FvHx8ejevbvutWnXrh1++uknV3uvvPIKsrKyMHv2bNeyKlWqICUlBXFxcZg4cSLee+89xb6sX78eRUVFru+PHTuG+++/XzSoyM3NRffu3dG9e3csWLBAsZ13330Xq1atwr///W+0adMGOTk5OHv2rGt9TEwM7r33XiQmJiI6Ohr/93//h+effx7R0dEYNmyYa7trr70W7777rut7m82meh2V3H333Xj44Ydd30dHR5va34iMjAz861//QqdOnfD2228jLi4Op06dQuXKlQEAtWrVEn0+gHOAuHLlSvTo0cPr/SEiojIkEBEZdOnSJaFp06bCnj17BEEQhMzMTKFFixbC559/7trm+PHjQtOmTYXffvtNtZ2ZM2cKo0aN0jxW//79hSVLlhjqV3JystC0aVPh8OHDutu+/fbbQq9evTS3mTt3rjBgwADRskcffVQYO3as6j7Sa+PuySefFCZOnKh5zHvvvVd4+eWXNbcRBEF4+eWXhT59+ggOh0O2bteuXULTpk2FjIwM0fL09HShdevWwi+//KLbvrvJkycLjz/+uOv7xYsXC3fccYepNtwZOcdvv/1W6Nu3r9CqVSvh3nvvFTZs2CA6p7S0NOGxxx4TunfvLrRu3VoYMGCAsHnzZlEb8+bNE0aMGGGqb4MGDRKeeuop0bKjR48KDz30kNCuXTuhbdu2wr/+9S/h1KlTrvWffPKJ0K9fP6Fly5bCrbfeKrz//vui/efOnes6l5tvvllYsGCBkJ+fr9qHxYsXC02bNhX92bVrlyAIgnDu3Dnh4YcfFq6//nrhhhtuECZMmCAkJye79t21a5cwdOhQoU2bNsL1118vDB8+XDhz5ozr+rn/2bBhg+HrsmrVKuH2228XWrduLXTv3l147rnnhCtXrmju07RpU+GDDz4Qxo0bJ7Rq1Uro1auXsG3bNtd6pZ/X3bt3C0OHDhVatGghdO3aVZg3b55QWFgoCILz50d6Du7nTkTkjo+lEZFhV65cAeCMOgDOqExhYSFuvPFG1zZNmjRB7dq1sX//fs12YmNjVdc7HA7k5ORobuOpK1euuPqvZv/+/ejSpYtoWbdu3XTPCYBu26VRUFCAzz77DEOHDoXFYjG8388//wyHw4HU1FT0798fPXr0wCOPPIJ//vlHdZ/Dhw9j37596Nixo2j5qVOn0K1bN/Tu3RtPPPEEzp8/b+octmzZgk6dOmHgwIF47bXXkJeX51p37tw5TJkyBTfffDM2b96MYcOGySJRBQUFaNGiBd566y1s3boVw4cPx1NPPSX6bL755hu0bt0ajz32GLp06YLBgwfjk08+Ue3ToUOHkJSUhLvuusu17MKFC7j33nsRERGB1atXY+PGjRg6dCjsdjsA4LPPPsPrr7+Oxx57DNu3b8e0adOwePFibNq0ydVGhQoVMHv2bGzfvh3PPvssNmzYoBqhA4CxY8fitttuQ/fu3fHTTz/hp59+Qrt27VBYWIhx48ahQoUK+OCDD/Dhhx8iJiYG48aNQ0FBAex2OyZPnoyOHTvis88+w7p16zB8+HBYLBb0798fY8eOxbXXXutqs3///gCcj8CNGjVK8/OyWCx45plnsHXrVrz66qvYs2cP5s2bp7kPALz++uu49dZb8emnn2LgwIGYPn06jh8/rrjthQsX8NBDD6FVq1b49NNPMXPmTKxfvx7Lly8HADzzzDNo164d7r77btc51KpVS7cPRFQ+8bE0IjJEEATMnj0b119/PZo2bQoAuHjxIsLDw12P+5SoVq0aUlNTFdv57bffsGPHDrz11luqx1q1ahWys7Nx2223ee8EAJw+fRrvv/8+ZsyYobndxYsXUb16ddGy6tWrIysrC3l5eYiKihKtU7o2vvD111/jypUruPPOO03td+bMGQiCgDfeeAPPPPMMKlWqhEWLFuH+++/Hli1bEB4e7tq2R48eSEtLQ1FREaZMmYK7777bta5NmzaYO3cuGjRogNTUVCxbtgwjR47Eli1bUKFCBd1+3HHHHahTpw6qVauGP//8EwsWLMCJEyewePFiAMBHH32EBg0auD6fxo0b4+jRo3j77bddbdSoUQPjxo1zfT9q1Cj8+OOP+OKLL9C2bVsAzscKP/zwQ9x///148MEH8fvvv+Pll19GREQEBg8eLOvX+vXr0aRJE7Rv39617IMPPkDFihWxcOFC1/Vp1KiRa/2SJUswY8YM9O3bFwBQr149HD9+HB9//LHr83HPnalbty7+/vtvbN++HQ899JDi9alQoQKioqJQUFCA+Ph41/JPP/0UDocDr7zyimtQO3v2bHTs2BG7d+9Gq1atcOXKFdx8882oX78+AOckQ4mYmBjYbDZRmwAQHx8Ph8Oh2JcS9913n+vrevXq4ZFHHsHMmTNFOV9K+vXr53qc8dFHH8Uvv/yC999/HzNnzpRt++GHH6JmzZr4z3/+A4vFgiZNmuDChQuYP38+Jk+ejEqVKiE8PBxRUVGycyAikuLghogMeemll3DkyBF8+OGHutsKgqAYWTh+/DgmTZqE8ePHo2vXror7btu2DUuWLMHSpUtRrVo1AM5Z8ueff961zdtvv40OHTqY6v+FCxfwwAMPoG/fvqIcknbt2rm+HjhwoCjJXnpOABTPy8y1KY0NGzagR48eqFGjhqn9HA4HCgsL8eyzz6Jbt24AgIULF6Jr167YtWuXK48IcP5Sn5OTg/3792PBggVo0KABbr/9dgAQ5aMkJiaiTZs26NmzJz7//HNR1EON+3VPTExEjRo1MHr0aCQnJ6NevXr4+++/0bp1a9E+JQOWEkVFRVixYgW2b9+OlJQUFBQUoKCgQJS7IwgCWrRogWnTpgEArrvuOhw7dgwfffSRbHCTl5eHrVu3ypL4k5KS0KFDB9HAr0ROTg5Onz6NZ555Bs8995xrud1uR8WKFV3f79ixA6tXr8bp06eRk5MjWn/u3DkMGDDAte348eMxYcIExet25MgRnD59WjT4ApzFPE6fPo3u3btjyJAhGDduHDp37oyuXbvitttu071Ppk+frrkeAHbt2oW33noLx48fR1ZWFoqKipCfn4+cnBxX3p0S958rwPk5qlVH++uvv9CuXTvRz9b111+PnJwcnD9/HrVr19btJxFRCQ5uiEjXSy+9hK+//hrvv/++6BeN6tWro7CwEJmZmaLoTVpamizycfz4cYwePRpDhw7F1KlTFY+zfft2PP3001i4cKHoF+5evXqhTZs2ru/N/nJ/4cIFjB49Gq1atZJVXNq8ebPr65JfPKtXry6q+AYAly5dQsWKFREZGSlarnZtvO3s2bP45ZdfsGTJEtP7lsx2X3PNNa5lVatWRVxcnOzRtHr16gFwDj4uXbqEpUuXugY3UpUqVULDhg1x6tQp030CgFatWgEATp48iXr16qkOit2tXLkS7733Hp5++mlX8YNZs2ahsLDQtU18fLzoXAFnJOPLL7+Utbdjxw7k5eXJBj1RUVGqfcnJyQHg/Ozd70sAsFqdT3vv378f06ZNw9SpU9GtWzdUqlQJ27ZtcxVjSEhIEN17Wo8z5uTkoEWLFpg/f75sXdWqVQE4IzklUawdO3bg9ddfx7vvvisbHJpx9uxZPPTQQxgxYgQeeeQRVKlSBf/3f/+HZ555xvV4nhlq17Nk4kBpmZnHL4mIAA5uiEiDIAh46aWX8OWXX+L99993PfJSomXLlggPD8evv/6KW2+9FQBw4sQJnDt3TvRL1bFjxzBmzBgMGjQIjz/+uOKxtm7diqeffhoLFixA7969ResqVqwomhE3o2Rgc91112Hu3LmuXz5LNGjQQLZP27Zt8cMPP4iW/fLLL6Jz0rs23rZx40ZUq1YNPXv2NL1vyYz/iRMnULNmTQBAeno6Ll++rDkgEwRBs2x2dnY2kpOTPX5UqGQm333w9c0334i2OXDggOj7ffv2oXfv3q7Sxg6HAydPnhQ9htW+fXucOHFCtN/JkydRp04dWR82bNiAXr16uQYJJRITE7F582YUFhbKojfVq1dHjRo1kJycjDvuuEPx3Pbt24fatWtj4sSJrmXnzp1zfR0WFqZ474WHh8seFWvRogU+//xzVK1aFZUqVVI8HuCMUF133XUYP348hg8fjq1bt6Jt27aKbRpx6NAhFBUVYcaMGa6fG6Olsvfv3y8aMB44cADNmzdX3Paaa67Bl19+KRrc/vbbb6hQoYJrIsPTcyCi8ocFBYhI1QsvvIDPPvsMCxcuRIUKFZCamorU1FRXEnilSpUwdOhQzJkzB7t27cKhQ4fw1FNPoV27dq6BwLFjxzB69GjceOONGDt2rKuNtLQ013G2bt2KJ598Ek8++STatm3r2qYkSV9Neno6kpKS8NdffwFw/vKelJTkyve5cOECRo0ahZo1a+LJJ59EWlqaq20tI0aMwOnTpzF37lz89ddf+OCDD/D555+L8g/0ro1RSUlJSEpKQnZ2NtLS0pCUlCRLvHY4HNi4cSMGDx6MsDD5nFRqaiqSkpJw+vRpAMDRo0eRlJSE9PR0AM5ckd69e+OVV17Bvn37cPToUcyYMQONGzdGp06dADgfR/vmm29w8uRJnDx5Ehs2bMCqVaswcOBA13FKEsrPnDmDffv2YcqUKbBaraqRHXenT5/GsmXLcOjQIZw5cwY7d+7Ek08+iY4dO6JZs2au637y5Em8+uqr+Pvvv7FlyxZRgj7gHIz+8ssv2LdvH/766y/85z//kUXZxowZgwMHDuDNN9/EqVOnsGXLFnzyyScYOXKkaLtTp05h7969io/U3XPPPbhy5QqmT5+OQ4cO4eTJk9i8ebPrXUZTp07FihUrsGbNGpw4cQJ//vknNmzY4IrMNGjQAP/88w+2bduG06dPY82aNfj66691r1OdOnXw559/4u+//0ZaWhoKCwsxcOBAxMXFYdKkSfjf//6H5ORk7N69Gy+//DLOnz+P5ORkLFiwAL/99hvOnj2Ln376CSdPnkTjxo1dbZ45cwZJSUlIS0tzDVgXLFiAf//736p9adCgAex2O9auXYvk5GRs3rzZVeJdz44dO7B+/XpXTtXvv//uKv0uNXLkSPzzzz945ZVX8Ndff2Hnzp1YsmQJ7r//ftegqk6dOjhw4ADOnDmDtLQ0DnSISJVFUIoHExHBOXutZPbs2RgyZAgA53P/c+bMwbZt21BQUIBu3brh+eefd83Gl+TPSNWpU8c1Sz9q1Cjs2bNHts2dd96JOXPmqPZv48aNeOqpp2TLp0yZgqlTp6quB4A///xTtV3AmWswZ84cHD9+HDVr1sSkSZNc5wwYuzYlZsyYgczMTLzxxhuy7ZXacb82APDTTz9h3Lhx2LFjhyipvYTaNXbvS1ZWFmbNmoWvvvoKVqsVHTt2xDPPPOOqOrV27VqsW7cOZ86cgc1mQ/369TFs2DCMGDHC9QvmY489hr179yI9PR1Vq1bF9ddfj8cee8xQ1Oqff/7BE088gWPHjiEnJwe1atVCnz59MGnSJFFU7ttvv8Xs2bPxzz//oHXr1hgyZAiefvpp7N27F5UrV0Z6ejqeeeYZ/PLLL4iOjsbdd9+Nf/75B1euXBFd32+//RYLFy7EyZMnUbduXdx///2i4giAM+/o008/xbfffiuL6AHOXJd58+bh//7v/2C1WtG8eXPMmTPH9ejeli1bsHLlShw/fhwxMTFo2rQpxowZg1tuuQUAMHfuXGzcuBH5+fno2bMn2rRpg6VLl+J///uf6nVKS0vD448/jt9++w05OTlYs2YNOnXqhNTUVMyfPx/ff/89srOzUaNGDXTp0gVPPvkk8vLy8Pzzz+PAgQNIT09HQkICBg8e7Bp8FhQU4PHHH8evv/6KzMxM130xY8YMnD17FmvXrlXtz3vvvYeVK1ciMzMTHTp0wMCBA/Hkk0+6Pg8lJS9n3blzJ/bu3Yv4+Hg8/vjjriptZ86cQe/evbF582ZXNGfPnj2YO3cujhw5gtjYWAwePBiPPvqoazB/4sQJzJgxA0eOHEFeXh527tyJunXrqvabiMovDm6IiIjIaxITE7Fs2TL06dPH310honKIj6UREREREVFIYEEBIiIqNWm5bne1a9fGtm3byrhHRERUHvGxNCIiKrWsrCxcunRJcV1YWJhipTIiIiJv4+CGiIiIiIhCAnNuiIiIiIgoJHBwQ0REREREIYGDGyIiIiIiCgkc3BARERERUUjg4IaIiIiIiEICBzdERERERBQSOLghIiIiIqKQwMENERERERGFBA5uiIiIiIgoJHBwQ0REREREIYGDGyIiIiIiCgkc3BARERERUUjg4IaIiIiIiEICBzdERERERBQSOLghIiIiIqKQwMENBY01a9YgMTERt99+u+o2iYmJrj/NmzdHx44dcccdd+A///kP9u/fr7rfxYsXMX/+fAwcOBDt2rVDq1at0LdvX7z88ss4efJkqfu+ZMkSJCYmlrodbzHbn6eeegrjxo3zYY+MKywsRJ8+ffDee+/5uytEREQUYML83QEiozZs2AAAOHbsGA4cOIA2bdoobnfrrbdi7NixEAQBWVlZOHbsGDZv3ox169Zh1KhRePbZZ0Xb//777xg/fjwEQcC9996Ltm3bIjw8HCdOnMBnn32GYcOGYe/evaXq+7Bhw9C9e/dSteEvhw8fxubNm/HJJ5/4uysAgPDwcEyePBmzZ8/GoEGDEBcX5+8uERERUYDg4IaCwsGDB3HkyBH07NkT3333HdavX686uKlevTratm3r+r579+4YM2YMnnvuOaxduxaNGzfGyJEjAQBZWVmYNGkSIiMj8fHHH6NmzZqu/Tp16oQRI0Zgx44dpe5/zZo1RW0HkxUrVqB169Zo1aqVv7viMmDAAMyZMwfr1q3DhAkT/N0dIiIiChB8LI2Cwvr16wEA06dPR7t27bBt2zbk5uYa3t9ms+E///kP4uLisHLlStfyTz75BKmpqXjiiSdUBx/9+vXTbDs3NxevvvoqevXqhVatWuGGG27AkCFDsHXrVtc2So+BFRQUYM6cOejatSvatGmDe+65B4cOHUKvXr0wY8YM13YbN25EYmIidu3aheeffx6dOnVCp06dMGXKFFy4cEHU5vbt2zF27Fh069YNrVu3xm233Yb58+cjJyfH8LVyd/HiRXz99de44447RMvz8/MxZ84cDBo0CNdffz1uuOEGDB8+HF9//bWhdqXnWGLUqFEYNWqU7v4RERG47bbb8Mknn0AQBGMnQ0RERCGPgxsKeHl5edi2bRtatWqFpk2bYujQocjOzjYdUYmKisKNN96IM2fO4Pz58wCAn3/+GTabDTfffLPH/Zs9ezY++ugjjB49Gu+88w7mzp2Lfv36IT09XXO/p556CqtXr8aQIUPwxhtvoG/fvpgyZQoyMzMVt3/22WcRHh6OBQsW4PHHH8eePXvwxBNPiLY5efIkevTogVdeeQXvvPMOxowZg88//9zj6MZPP/2EwsJCdO7cWbS8oKAAGRkZGDt2LJYtW4YFCxagffv2mDp1KjZv3uzRscy64YYbcPbsWRw9erRMjkdERESBj4+lUcDbsWMHrly5grvuugsA0L9/f8yaNQvr16/HnXfeaaqt2rVrAwBSUlJQs2ZNnDt3DlWrVkVMTIzH/fvtt9/QtWtX3Hfffa5lPXv21Nzn+PHj2Lp1Kx588EFMnz4dANC1a1dUr14d06ZNU9yne/fuonyhjIwMzJs3D6mpqYiPjwcATJo0ybVeEAS0b98eTZo0wb333osjR46gWbNmps5t//79iIqKQuPGjUXLK1WqhNmzZ7u+LyoqQpcuXZCZmYnVq1dj8ODBpo7jiRYtWgAA9u3bF1DFGoiIiMh/OLihgLdhwwZERUVhwIABAIAKFSqgX79+2LhxI06ePImGDRsabssXjzC1atUKW7Zswfz589G9e3e0adMGUVFRmvvs2bMHAHDbbbeJlt96660IC1P+sezVq5fo+5Jf6M+dO+ca3CQnJ2PRokXYtWsXLl26JDrfv//+2/TgJiUlBVWrVoXFYpGt+/zzz7F69Wr8+eefosfeIiMjTR3DU9WqVQMA2aN5REREVH7xsTQKaKdOncLevXtx0003QRAEZGZmIjMz05UHU1JBzahz584BABISEgA4IzlpaWke56QAzsfFHnzwQXz99dcYPXo0brjhBkyaNEmzhHTJI2vVq1cXLQ8LC0NsbKziPtLlERERAJyP7QFAdnY2Ro4ciQMHDuDRRx/F2rVrsX79eixdulS0nRn5+fmu47j78ssv8eijj6JGjRqYN28e1q1bh/Xr12Po0KHIz883fRxPlPSrrI5HREREgY+RGwpoGzZsgCAI+OKLL/DFF1/I1m/atAmPPvoobDabblt5eXn45ZdfUL9+fVfxgG7duuGnn37Ct99+64oMmRUTE4OHH34YDz/8MC5evIgffvgBCxYswIQJE1TzgkoGKhcvXkSNGjVcy+12u26ujppdu3YhJSUFa9euxQ033OBafuXKFY/aK+nnH3/8IVv+2WefoW7duli0aJEoqrN69WpD7UZERKCgoEC2/PLly4ZLO2dkZAAAS0ETERGRCyM3FLCKioqwadMm1K9fH2vWrJH9GTt2LFJTU/HDDz8YauvFF19Eeno6HnzwQdfyu+66C/Hx8Zg3b57q401ffvml4T5Xr14dQ4YMwYABA3DixAnVim4dO3YE4Kxu5u6LL76A3W43fDx3JYMMaaTl448/9qg9AGjcuDHS09NlAySLxYLw8HDRwCY1NRU7d+401G6dOnXw559/ipadOHECJ06cMNy35ORkAECTJk0M70NEREShjZEbClg//PADUlJS8Pjjj6NTp06y9ddeey3ef/99rF+/XlTt7OLFi9i/fz8EQUB2drbrJZ5HjhzBfffdh7vvvtu1baVKlfDGG29g/PjxGDx4MO655x60a9cO4eHhOHXqFD777DMcOXIEffv2Ve3nsGHD0LNnTyQmJqJKlSr466+/8Omnn6Jdu3aIjo5W3Ofaa6/F7bffjnfffRc2mw2dO3fGsWPH8O6776JSpUqKOS562rVrhypVquD555/HlClTEBYWhi1btsgGEWZ06tQJixcvxoEDB9CtWzfX8p49e+LLL7/EzJkzceutt+L8+fN44403kJCQIHscb8yYMdi7dy8OHz7sWjZo0CA88cQTrv3Pnj2Ld955RzEKc91116Fjx46yqNCBAwdgs9lcA0UiIiIiDm4oYK1fvx7h4eEYOnSo4vqqVavilltuwRdffIGLFy+68ldKHmGzWq2IiYlB7dq10a5dO7zwwguil3uWaN26NbZs2YL33nsPO3bswDvvvIOioiLUqlULnTt3xnPPPafZz86dO+Obb77B6tWrkZubixo1amDw4MG65Zdnz56N+Ph4rF+/Hu+99x6aN2+ORYsW4YEHHkDlypWNXSQ3cXFxeOutt/Dqq6/iiSeeQHR0NHr37o3XXnvNdFW5Eu3bt0edOnWwc+dO0eBm6NChuHTpEj7++GNs2LAB9erVw0MPPYTz58+7cnxKOBwOFBUViZYNHDgQKSkp+Pjjj7Fx40Zce+21mDlzJpYtWybrQ1FRERwOh2z5119/jR49enh0rYiIiCg0WQS+AY8oYOzbtw//+te/MH/+fAwcONDf3QEArFq1Cm+++SZ++OEH3SpwZeX06dPo27cvVq5cia5du/q7O0RERBQgOLgh8pOff/4Zv/32G1q2bInIyEj8+eefWLFiBSpVqoTPPvuszEoq68nPz8dtt92Ge+65B+PGjfN3dwA4X4B6/vx5vPvuu/7uChEREQUQPpZG5CcVK1bEzz//jDVr1iA7OxtxcXHo0aMHpk2bFjADG8D53pq5c+ciKSnJ310B4KwoV/IYHBEREZE7Rm6IiIiIiCgksBQ0ERERERGFBA5uiIiIiIgoJHBwQ0REREREIYGDGyIiIiIiCgkc3BARERERUUjg4IaIiIiIiEICBzdERERERBQSOLghIiIiIqKQwMENecXu3buRmJio+Gf//v2y7f/44w/cd999aNeuHTp06IApU6YgOTlZse21a9eiX79+aNmyJXr16oWlS5eisLDQx2cUWLKzs/HKK6+gW7duaNWqFQYNGoRt27b5u1sBw8z9x3uPiIgodIX5uwMUWqZNm4ZOnTqJll177bWi7//66y+MGjUKzZs3x6JFi5Cfn4/Fixdj5MiR+PTTT1G1alXXtsuXL8frr7+Ohx56CF27dsXBgwexaNEiXLhwAS+99FKZnFMgmDp1Kg4ePIjp06ejYcOG2Lp1K6ZNmwaHw4GBAwf6u3sBQ+/+471HREQU2ji4Ia9q0KAB2rZtq7nN4sWLERERgbfeegsVK1YEALRo0QK33norVq5ciSeeeAIAcPnyZSxfvhx33303pk2bBgDo1KkT7HY7Fi1ahDFjxuCaa67x6fkEgu+//x4///wzFixYgNtvvx0A0LlzZ5w7dw5z585F//79YbPZ/NzLwKB3//HeIyIiCm18LI3KlN1ux3fffYe+ffu6frkEgDp16qBTp074+uuvXct+/PFH5OfnY8iQIaI2hgwZAkEQRNuGsq+++goxMTHo16+faPmQIUOQkpKCAwcO+KlnwYX3HhERUejj4Ia86sUXX8R1112H9u3bY9y4cfjf//4nWn/69Gnk5eUhMTFRtm/Tpk1x6tQp5OfnAwCOHTvmWu4uISEBcXFxrvWh7tixY2jSpAnCwsSB1pJrWF6ugxFa9x/vPSIiotDHx9LIKypVqoTRo0ejU6dOiI2NxalTp7By5UqMHj0ab731Frp37w4ASE9PBwDExsbK2oiNjYUgCMjIyEBCQgLS09MRERGBmJgY2bZVqlRxtRXq0tPTUbduXdnyKlWquNaXd0buP957REREoY+DG5LZvXs3Ro8ebWjbzZs3o3nz5rjuuutw3XXXuZZ36NABt9xyCwYOHIh58+a5BjclLBaLapvu67S2K0+MXq/yysz9x3uPiIgodHFwQzKNGjXCyy+/bGjbWrVqqa6rXLkyevbsiY8//hh5eXmIiopyzZpfvnxZtn16ejosFgsqV64MwDmbnp+fj9zcXERHR4u2zcjIQMuWLQ2eUXCLjY1VjBRkZGQAuBrBITHp/cd7j4iIKPRxcEMyCQkJGDZsmFfaEgQBwNVZ8Pr16yMqKgpHjx6VbXv06FE0aNAAkZGRAK7mOxw9ehRt2rRxbZeamorLly/LSkyHqqZNm2Lr1q2w2+2ivJuSa1heroMn3O8/3ntEREShjwUFyGcyMjLw3XffoXnz5q5fGsPCwnDzzTfjq6++QlZWlmvbc+fOYffu3bjllltcy7p3747IyEhs3LhR1O6mTZtgsVjQp0+fsjkRP+vTpw9ycnLw5ZdfipZv2rQJCQkJol++6Srp/cd7j4iIKPQxckNeMX36dNSqVQstW7ZEXFwcTp06hVWrVuHSpUuYM2eOaNupU6firrvuwoQJE/Dggw+ioKAAixcvRlxcHMaOHevaLjY2FhMnTsTrr7+O2NhY14sUlyxZgmHDhpWb94zcdNNN6Nq1K2bOnImsrCzUr18f27Ztw48//oh58+bxHTcwfv/x3iMiIgptFqHkuQ2iUlixYgW2b9+OM2fOICcnB1WqVMH111+Phx56CK1bt5Ztf+jQIcyfPx/79++HzWZD586d8eSTT6J+/fqybdesWYMPPvgAZ8+eRXx8PIYMGYIJEyYgPDy8LE4tIGRnZ+O1117Djh07kJ6ejsaNG2P8+PEYMGCAv7sWEMzcf7z3iIiIQhcHN0REREREFBKYc0NERERERCGBgxsiIiIiIgoJHNwQEREREVFI4OCGiIiIiIhCAgc3REREREQUEji4ISIiIiKikMDBDRERERERhQQOboiIiIiIKCRwcENERERERCGBgxsiIiIiIgoJHNwQEREREVFI4OCGfC4lJQVLlixBSkqKv7sS9HgtvYvXk4iIKLRwcEM+l5qaiqVLlyI1NdXfXQl6vJbexetJREQUWji4ISIiIiKikMDBDRERERERhQQOboiIiIiIKCSE+bsDwaCgoAB2u93f3QhaDocDDRs2hMPhQE5Ojr+7E9R4Lb2L19M7wsLCEBER4e9uEBERwSIIguDvTgSygoIC7NnzB6KjHf7uChFRQLJarWjRogUHOERE5HeM3Oiw2+2Ijnbgueca4vTpaACAxQJYrc4/7t+X/A3Iv3ffx2JR3sb9e/dt1PZRatsf/dFq21f9KU/nKjs+iucjHA7nH0Fw/g1c/Vr6vfs2WvsIgvI27t8LCsf3Vn+02lZrK1jP1ZP+KLXt5/7kNmqEky+/DLvdzsENERH5HQc3Bp08GY1jx2IAXP0l0/0XUa1l3KZstvFkv5Lf3wRBvK5kmSBcHVyUsFjkA46yPFfZ4Mb9F1it781sY7Fc/bqEw+FcLg32ul9E6S/UZvvj7fPgNmWzDRERUYCw+rsDRERERERE3sDBDRERERERhQQOboiIiIiIKCRwcENERERERCGBgxsiIiIiIgoJHNwQEREREVFI4OCGiIiIiIhCAgc3REREREQUEji4ISIiIiKikMDBDRERERERhQQOboiIiIiIKCRwcENERERERCEhzN8dCBYNG+bCWjwUtFgAqxWy70v+BuTfu+9jsShv4/69+zZq+wRKf7Ta9lV/yuJcLZarX7sTBOcfAHA4lNc5HD689nA7uMNx9YAlHShZ7v69+zZa+7ifmNI+JevdSS9YyUm4L3M/Ca3+CArnJt2mrM5Vrz9lfe3V2vZzf3IbNQIREVGgsAiC0m8rVKKgoAB//PEHHNLfYomICABgtVrRokULRERE+LsrRERUznFwY0BBQQHsdru/u0FEFJDCwsI4sCEiooDAwQ0REREREYUEFhQgIiIiIqKQwMENERERERGFBA5uiIiIiIgoJHBwQ0REREREIYGDGyIiIiIiCgkc3BARERERUUjg4IaIiIiIiEICBzdERERERBQSwvzdASIiovIgKysLb7zxBo4cOYLDhw/j8uXLmDJlCqZOnVqm/di4cSOeeuopxXU//fQT4uPjy7Q/RETexMENERFRGUhPT8cnn3yCZs2aoU+fPvjvf//r1/7Mnj0bjRs3Fi2LjY31T2eIiLyEgxsiIqIyUKdOHezduxcWiwVpaWl+H9xce+21aNWqlV/7QETkbcy5ISIiKgMWiwUWi8XQttu3b8fw4cPRtm1btGvXDuPGjcPhw4d93EMiouDHwQ0REVEAefPNNzFt2jQ0adIEixYtwty5c5GdnY177rkHx48f99pxJkyYgObNm+OGG27AlClTcPToUa+1TUTkL3wsjYiIKED8888/WLJkCe699148++yzruU33ngjbr31VixduhSLFi0q1TGqV6+OCRMmoG3btqhYsSKOHj2KFStWYPjw4fjoo4/QrFmzUp4FEZH/cHBDREQUIH766SfY7XYMGjQIdrvdtTwyMhIdO3bE7t27Xcu0qp5J7d27F5UrVwYA9OjRAz169HCt69ixI2666SYMHDgQr7/+OpYvX+6lsyEiKnsc3BAREQWIixcvAgDuuusuxfVW69Wnydu3b4+XX37ZULtRUVGa6+vWrYvrr78eBw4cMNhTIqLAxMENERFRgIiLiwMALF68GLVr19bctmHDhmjYsKHXji0IgmjwREQUjDi4ISIiChDdunVDWFgYTp8+jVtvvbXMjpucnIx9+/bhxhtvLLNjEhH5Agc3REREZeT7779Hbm4usrOzAQDHjx/Hjh07AAA33XQT6tati4cffhiLFi1CcnIyevTogcqVK+PixYs4ePAgoqOj8fDDD5eqD/fddx86dOiAZs2aoUKFCjh69CjeeecdWCwWPPLII6U+RyIif7IIgiD4uxNERETlQa9evXD27FnFdTt37kTdunUBAF9//TXWrFmDP/74AwUFBYiPj0fLli3xr3/9C126dClVH2bNmoWff/4Z//zzD/Lz81G1alV07twZkyZNQqNGjUrVNhGRv3FwQ0REREREIYGZg0REREREFBI4uCEiIiIiopDAwQ0REREREYUEDm6IiIiIiCgkcHBDREREREQhgYMbIiIiIiIKCXyJpw673Y6MjAxERkbCauVYkIjIncPhQH5+PqpUqYKwMP6XooT/jxARKfPF/yH8n0hHRkYGTp486e9uEBEFtIYNG6JatWr+7kZA4v8jRETavPl/CAc3OiIjIwEACQkNERER7fX2w8KA6M83YvWVIViyBGjTBli5NBeYMgXIyQHmz8ft4+sgNxeYMwfo+M2rwA8/APfdhw8KhuH114FWrdz2ycsD5s7FY/Pr4PvvgfvvB6Y2+wpYsgRo3Ronxr2MqVOB3Fxg7lzg+q+L2xs9GtP3DMe336rvk53t3EepD61bA+8sEfdbsQ+jRinvk5cHzJmDxxbWw48/AmPGqPfb0HWoVQsnH3gZU6YonKvaPjk5zmu3sN7Vfl+3EyUbnnjgFXkffv/d1W+9663Wb9m1k/Yh5+o+a/OGYckShc/cTB92zgF+/NHVh9deK77vRhafq1q/iz8Yvc9Prw87t2qcq8F79QP7cOV7v7gPxR+LZ9e7pA+Sz1x6D63Nc147pX67dcfYz6zKtUt55zNUqgQ4HM4/JQQBsNmcX7sv94eCglykpJx0/VtJciXXpmHDhoiOlv8/kpubi5MnT6qup9DAz7l84OdsTsn18ub/IRzc6Ch5hCAiIhpRUTE+aB+Iyc5GVlYM/vwTqFYNiIkSgDNngKwsICwMJ07EICvL+UtMTFoa8PffQE4OsvIU9snJAaxWnD/vXJeeDsTY7cCJE0CtWrBaY3DihLNpu92tvbw8nDsXg2PHivcpKFDcB/CwDyXtae0TFobz52OQlCTZp0YNUR8cDiDm4kVnH7KykFXgbC8uzq29sDBYLDH46y9n06J9DPTB1e+8PNF1ELWXlgacPi3fR+XaqX1+on679cH1WWRd3SdHqd/F94nhPly+LLp2x44B8fFu56p0vdPSUHLyiv3OygIiIpTvO0l70n6npLidq2SfkustvVcVPz+363D8uOR6u90nap+5Wh8Uf17cPgul633ypMLPS1YWMo3ed8XthYfHICrKeWx3Dofz345Awset1JVcm+joaMTEqP8/oreeQgM/5/KBn7M53vw/hP8bERERSWRnZ+OVV15Bt27d0KpVKwwaNAjbtm3zd7eIiEgHIzeBwG20WuqBq9IzKiXLJOuUjqW0u2qf3DZ2fWm1qj8no/f8jPRAJd8X/y3aXbJOtnvxxiXLHA6F9qVtGni+R/FaqF0grc9CZ3etyyhrRq0BBVar285u2+i2p9aWpFOmro/S5ypZZ+rnwWrVPZaM0j2scH20Din6QnIynv4o6G3LIInvTZ06FQcPHsT06dPRsGFDbN26FdOmTYPD4cDAgQP93T0iIlLBwQ0REZGb77//Hj///DMWLFiA22+/HQDQuXNnnDt3DnPnzkX//v1hK0l6IiKigMLBjZ9JZ2B1Z3RVojBKDcpmdw2EavQ2cTigOLPt+lItGaBkVt1wOMJY31Q3l2xseELfh1PiVqvx9kudJK7VgEKEQynqpdieUqRD0oDoXtDqi1bURKMrqn2QZN2XRXRDLdoj+tbtG4WAo4gsEgTloJDD4SxG4u9iAqHqq6++QkxMDPr16ydaPmTIEEyfPh0HDhxA+/bt/dQ7IiI5QRBwNuUSLqelIjIyChGRUYiMjEB0VDSiIiIQEWaD1WrRawRwFAEOu/OPUOT8XnAU/13k3MZidf0RLBYUCRZYwqNhiwyMHCMOboiIiNwcO3YMTZo0kb1zITEx0bXe14ObIoeAbe/MRIOz21ABOQhDkfOPxYFwFMGGIlggAAAsEJy/b0CAAAtORVyDaiPeQJ0mLX3aRyIKHDvfehw9/1mFuhblWa9CwYZCWABY4IAFgsUCAc7BThgcsBX/G2OWBc7BRKFgw4GqfdFu6gewWP0b2ebgJtjoTf2qzWq77W52ttf9UJqz4aWdRjaTu6KneB9R8EChHbNNa0USZLPukll8b+RflDAz8694LE9vAp38ML28KNV2pd974aIYakIrT0eLTuOmm5TmHxmIYDFq4zvp6emoW7eubHmVKlVc69WkpKQgNTVVtMxR/GHl5uYq7lOy3H393q8+wR3nFgE6E60ubtu1LjyAyx8OQu7YLRDiGhpsgHxN6XOm0OOPz/niuZO4+Z+VsFkE1W3CLeYHLmaEW4rQ/vLn2Pv5e2hx878M7+eL68TBDRERkYTFoj6q0Fq3bt06LF26VLSsYcOGmDVrlu6LPN3X5587ZKifauKKLqJg7SD82fU1FMTUKlVb5F18oWv5UJafc87Rb1BfY2BTllJTU5CUlOTXPnBwE+hKE2ZRaU60idpst0olLWnVMVFUQmvWXa9CV/ECU9W21I6lto/edLpbhS61KlhKFcI86YqR3JBS5YyotC/KAVHevNQMR4e0wojF+SmeVKfTzR9S2Mf0JgYjTro/FwoHUUo9kzbBamm+FRsbqxidycjIAHA1gqNk+PDh6NWrl2iZw+FAQUGBqZd45tWcgPR3/otYQd4PoyLyUtBi75PI/9dGCFXqedwOeQdf7lg++ONzPn9sXZkcR0uRYMH/xXRD1zsnITw83PB+JdfLmzi4ISIictO0aVNs3boVdrtdlHdz9OhRAMC1116rum9CQgISEhJEy3JycpCUlGTqJZ4xMdcAMw4h9eBO5OZkocgSBjtsbn+ssFhssFktCLNZUeQQ8OJnh/Bc+Fq0sp50tWnNPIPoT+4G7tsOVKnjyeUgL+PLHcuHsvycK2YcFX2/MawfBkyah/z8AhTm5yE/Pw+FdjuKihwochShyOFAkb0IRUVFsDscyBdsKHBYUShYUeCwIN9hRRGsiAgLR3h4GCLCwxEREYbwMGdhgjArEGYBbFYgzCLAZhFQsWJl3FC9epmcrx4ObgKdgXJqns66a+5n8N04piMtapsVT0+bin4Ur1CczVaLtLitU1uv+O4brXeySNtyu3almWH3JD/GbOTNcPNGIiAGooaGj+NwGNpeKQqpVTVPcX0p8mcMBgMNNSRKUZLkNkkKwRm53FQKffr0wSeffIIvv/wS/fv3dy3ftGkTEhIS0KZNm7LpSGQlxHcYbHjzo19ZMSrnKXwYMQvXWU9dXXH5JLD6ducApzIfUSMKNRXTxY+BHYtogciq9RHpp/74Gwc3REREbm666SZ07doVM2fORFZWFurXr49t27bhxx9/xLx58wL2HTf14mJwMKcQ9xY8hY8iXkai9czVlWl/Xx3gVKrhv04SkXflpCEm97xo0bmoJn7qTGDg3J+fSat4aeV0SDcw/fy9galwtfe+6FX8MtSW3sYa5yo7tkJ0RGnG3lC+hHubkipr0uOJZtcl0+eyfSSRKOk7T1T7oNZfrfe7qLWjFHmTrJPltii9A0evqljx56cVKTN7P6hubyDPSadpr5FF1zyJihVvqPuZumHUxveWLFmCO+64A4sXL8YDDzyAAwcOYOHChbjjjjv83TVV9ao6n+9PQ2XcU/AMLkY1EG9w6Tjw5TN+6BkR+cwFcfGRfCEc6dEN/dOXAMH/IomIiCQqVKiAZ599Fj/99BMOHTqEzz77DAMGDPB3tzTVi7v6fP9FVMGCWguAateINzr8KVBUWMY9IyKfOX9Q9O1RoQ4iIsvrA2lOHNx4wJuzptJKVkqz/2rH9fRdGorfejJTrBVxKo5aqEWi1CIjorYkM/SK0QWd967oXSPdmXWVd7Uo5a7oHVRtH70cEaV1up+9kX5rRZ2gEPxRqgSmso+xTmpT/WzUroPBMImZaIqp7U1Qi9Lo5oARaahbVZy8/MeVaODejeKNigqAi8fKsFdE5FOSwc1hR0PERATmo7NlhYMbIiKiEFAvTlx2NjktB4hrAEjLQEt+GSKiIHZe/FjaYaEBBzf+7kAw8vo7QYrzC7QiHYaPa/BdGrJvPalwpjXzrzbr7fYuGdlyAxXJZEr5YehWs/KkfUnIQ6+JUkcfJJGMUkcWlXJkTFwHWeTNTIdMdl52HTT2N9wdlaiXJ9dDbR/DVdRUVputlsYcnfKhniRyczmnEFn5dqBmK/GG538vw14Rkc/YC4DUI6JFSY76iIko3/XC+F8eERFRCKgTK39hYHJaDlCjpXghIzdEoSH1COAQ59AlMXLDwY2/SQthaVXcMjT7aiBnQ3HS2WCUwSvvRFHb3g/JBaU+pKEX33hxP6VNDOTCGKIaPoT8RpVSijCa2EdzmQbd6oIK2+oeQqGanGw/g6EQM6fujzYotESF25BQSZxInJyWoxC5OQgIQhn2jIh8QlIp7bQjHlcQg+hyPrgp33ErIiIKKMeOHcO+fftw4cIF5OXlIS4uDtdccw06duyIihUr+rt7Aa9e1RikXMl3fZ98ORe4TjK4yU0DMs8BVeqUce+IyKskUdgkwVn+PSacgxvyIyMzqnqVykTvyjHwML7sXS1ax9FYbmQbQzPrnhzYk3wOhT64dlcsVWeAJ1EOt23cXq0jWq6YPqLWnjdzhfSup4HIoFrOjVYlQD1qkSpvRiQU88DM7mNgvYm0OFcbgRJ5MZvrY1RGRgbWrVuHdevW4dy5cxAUogphYWHo0aMHRo0ahS5duni/EyGiXlw0/u/UZdf3Zy7nALHNgcjKQH7m1Q3PH+TghijYySqlFQ9uIsv3r/fl++yJiMiv1qxZg2XLlgEA+vfvjxtuuAEtWrRA1apVERkZiYyMDCQnJ2P//v3YuXMnxo4dixtvvBH/+c9/0KBBA53Wyx9pUYHktFzniLRGS+D0L1dXnD8IJPYr494RkdcIgnxwUxK54WNp5E9mZkE1n/l3D8foTPOKUgrUKp4ZiT64vVVdLfrghbQKZQr9M9yumfJTeu+W0TpBnetQsk4pQiOL6Kh2QL87Rjb2ZDZeVvFLJzmkNDP+hoJWBu97pX1MRUcUPxwD1CoFBiC16+GLvq9duxZPPfUUBgwYgPDwcNn66tWro3r16mjXrh3uv/9+nD59GsuXL8fnn3+OCRMmeL9DQc79RZ5AceQGcObduA9uLrCoAFFQyzgD5KWLFiVxcAOAgxsiIvKjzz//HGFhxv8rql+/PmbPno2ioiIf9ip41a0qf9eNIAiwKBUVIKLgJSkmkCnE4IxQHQAQHV6+f70PgjnEcsDMOzO8kG9gaPbVbZpb603xqm1p5NGYjoBo8fBt9YoRJwP7mEl7kUZGNK+7yQ9TlGelw8jn7UnxNsNVvNze46TbuMrBDL1fSee9NIpNG6ggqNUZWWU4yXJpE7LokakbSrzalxGgsszxMTOwcWezle+ZSTXSyE12QREu5xTKK6al/Q3kXynDnhGRVyk+kmYBAFSILN//PnJwQ0REFCJqVYmCzWoRLUtOywHimwEWyS88F/4ow54RkVdJXsab5Kjv+rq8P5bGwY2fSfNetKoribZVm4n2lEYUxn25mapopnJ4tKqEKdGbWjZTMU5hnWxmXaffehWwXFEfhQ2l94BSPxWX612o4mNpRd7KaoZetcqWWmhDazODuULS+8+TW8ZwZNJgCTTZj0Ep35dTntx///0YM2aMv7sR8MJsVtSOjRItS76cA4RHAfGJ4o35aBpR8DovfiytpJgAAERHlO/H0sr32RMRUVDYvXu3YolokqsbG+OsklbM9XXNVkDK4asbSmZ+iShI5GUCl0+IFh12NHR9XYGRGyIiosB2+PBhJCUl+bsbQaGetKiAe8U0d4zcEAUnySOlhYINx4Sr762K5uCGAp1WIrTqeg9oJYjrPZ3lcePuih8dMpSornDSpU6KL34ezUilX81rLnnmTfSYm8KOWi+PNJy0r9SoWxa/Xt66J+8BNXzfGfhgzBYt8ITeY3GyR8Ukj7IZemyt+HFR0XVVeCRTt/iFpF9KT8GV1aNqph7Xo4AgLSqQnKYyuLlwGCiyl1GviMhrJJXSjgu1UQBnKX2b1YIIW/n+R7p8nz0REVGIkb7I8+zl4sfSakgGN0X5wKXjZdQrIvIaySOl7vk2MeE2WCwW6R7lSlDl3Bw+fBhLly7F77//jitXrqBWrVq4/fbbMW7cOERHXw3D//HHH5g3bx4OHDgAm82Gzp0748knn0S9evV83kdTLwNU4Mm+hl/2qFSEwGQ54VLP2LrNhsuSxM2EKXxROtmtD2YKJ8jWedI3hQWeflaGt9XZRrEGhFopck/e+Oh2vQ1fAxPMlAaXbatW+EHyjZFbylAIzGBJbOkmZRG98cKPn2GjR4/WXG+xWLB69WrfHDyESB9LO3M5Fw6HAGuFakDlOkDm2asrzx8EEpqVcQ+JqFQkj5QmOdwGN+W8DDQQRJGb48ePY8SIETh79iyefvppvPnmmxgwYADeeOMNTJs2zbXdX3/9hVGjRqGwsBCLFi3CrFmzcPLkSYwcORJpaWl+PAMiItIiCILsz+XLl7Fv3z6cPHmSBQUMkj6WVlDkQMqVfOc3srwbFhUgCipFdiBFnH8oityU80ppQBBFbrZs2YL8/HwsWbIE9es7a3l36dIFqampWLduHTIyMlClShUsXrwYEREReOutt1CxYkUAQIsWLXDrrbdi5cqVeOKJJ3zaT+mMpt7sqpmZacPRBOlylRwC6c5GyupqljM2SBYF0gsLKeVlGMldMbuB2wy6XjTM0Gy2wfLApdhEtqFa/o5e3pb6Rup07zvJCahdU0N9U6EVPRLdqzqdFeW1GKlHrrHecCTVfQeDJbHdmwzF8tBr165VXH7ixAlMmjQJU6ZMKeMeBaf4SpGIDLMi3371Jkm+nIOaVaKAGi2BozuubsyiAkTB5dJxwJ4nWuT+jpvocEZugiZyEx7uTJQqGbCUqFSpEqxWK8LDw2G32/Hdd9+hb9++ou3q1KmDTp064euvvy7TPhMRUek1atQI48aNw7x58/zdlaBgsVhQN05SMU2tqMD5gwAjYkTBQ1JMIDsyAZdR2fV9eX+BJxBEg5vBgwejcuXKmDlzJpKTk5GVlYVvv/0W69atwz333IOYmBicPn0aeXl5SExMlO3ftGlTnDp1Cvn5+WXab6/PrhrJBSjOrXEtV+mE1Spfp1bVSzFq4pUEIbdlOrkmhvIbTO6jlmthOIihU0rKfbVa5EnWB7WIhicJKGqfr2Sdbv6MQgRErXqdUuSiJBhiuCqbVr/NVAo0cs2sVtXrYprWz43WITT66UklO1/xZ5W0OnXq4NixY/7rQJCpK6uY5vauG3c5F4Er58uoV0RUapJHSS9WbCr6PiYyaB7K8pmguQJ169bFxx9/jClTpqBPnz6u5aNGjcIzzzwDAEhPTwcAxMbGyvaPjY2FIAjIyMhAQkKC4jFSUlKQmpoqWuYIxWc/iIiCzJdffqn6bzfJqb7rJq4REFERKMi6uvL8QaByrTLsHRF5TPIo6floyeCGj6UFz+DmzJkzmDhxIqpVq4bFixejatWqOHDgAJYvX46cnBzMmjXLta1WCTytdevWrcPSpUtFyxo2bChq29tMF8DSi5qo5YwoRCSks/WiR/9V8iUMz6AbyOdQmvnXyiUw9S4USfTD7Iyz7J0n0miY6oFxNQIkyXEyVAzOSOKTlE7UxMixRFE8gy82kUX+DOShGK6wptVvtYiTp3k60nvfbbn79oYui2Qfzeut2inlVYGQZ+Pr4z/11FOyZQUFBTh69CiOHz/u85zJUKL6rhur1Zl3k7zr6soLB4Gmfcuwd0TksfPix9LORjURfc/H0oJocLNgwQJkZWVh8+bNiIlx/qPdsWNHxMXF4emnn8bgwYNRvXp1AMDly5dl+6enp8NisaBy5cqydSWGDx+OXr16iZY5HA4UFBR48UyIiEjJ7t27ZcsiIyNRp04dPPTQQxg4cKAfehWcpO+6OVPyrhvA+Wia++CGRQWIgkN6MpCdIlp0MqwxgKt5cywFHUSDm6SkJDRp0sQ1sCnRqpXz+eFjx46hffv2iIqKwtGjR2X7Hz16FA0aNEBkZKTqMRISEmSPPeTk5CApKUllD+/Tmnw2NDGtVDmrJNmheIZasVGdxhUDRmoz6Dr90isiphcFkkYMvFblTSu5oTgKI4tcmQgzSfM6FCMCChED+TfapJuaiRLorpd+jqqhQHPNmtrIYIRGt5qb2kaSBCHFdqSfkeTnyFSk0MA+ij8XIeibb77xdxdChjRy809GLgqLHAi3WZWLChBRYMu9DHw8UrwsvALOoiaAf1yLWAo6iAoKJCQk4Pjx48jOzhYt379/PwCgRo0aCAsLw80334yvvvoKWVlXnyc+d+4cdu/ejVtuuaUsu0xEROQX0pwbhwD8k15cPlY6uLn0F5CfBSIKUHmZwPt3yd9LlXgbsgvF1Q5ZCjqIBjdjxozB5cuXMXbsWGzfvh2//vor3nzzTcyePRvXXHMNevToAQCYOnUqcnNzMWHCBHz//ff46quvMH78eMTFxWHs2LF+PgsVJqIaLmrP77vNOMvyZ7QqOZmtEqbVB62oiltlKkOVuxTakUUMNLqnV+XNTJUsxUOayJHRjajohe0MVAlTqkgmyydxuw6KuSFadPpgpl/uEQul6JLBQmeqPM4PUdlRKfrnOr7JC+lJ3wymNxEBAKpEh6OSpGqSq6hAQnPA4n4TCUDK4bLrHBEZV5ANfHg3cPZ/4uVV6gG3vICcwiLRYubcBNHgpnfv3njvvfdQsWJFzJo1CxMmTMCmTZswYsQIvP/++4iIiAAANGnSBGvXrkVYWBgeeeQRzJgxA/Xr18cHH3yAqlWr+vksiIjIEy1atMB1113n724EDYvFgrpVVYoKhEcD1cUVlmQzwkTkf4W5wEf/Ak7/Kl5eqRYw+lOgSl3k5NtFq1gKOohybgCgc+fO6Ny5s+52LVu2xHvvvef7DpUFtdwM8Sbib9TeU6I1G25mKlghyqJWnU1rX6XjG3kXiqFcCqhfCtXqYqWcDvc06qVWoU6L2dwnvWumds1lkQkD/VJrS6+4nLRjqodUyklSoPl5GDkfpSiN5ILJcm70jqu0jYHzCYRKaf7WoUMHsDS/OfXiopH0T6bre1fkBnA+mpZ65Or3yXuBprfBPTH5Kgtgsbj9DeeLPwWHc3tBcPsbV9twfzmo1QZYbM6/rWHOyJE1TPLH7QdDEJxvYS/Mdfs7H3AUAo4i57EFR/HXRW5/Fy8vWRYW6Sx9HVkJiKwIRBT/bbE62ysqcP4p+RoWICLGOQAMrwCERcgvhyBc3cdhF5+b62/r1WulxeFwnp/kjfPyj8B6tc2Sr63hxcdSOY6jyDnrX5jj/CMIzuthiwRs4Ve/tlic2zrsbn+KrzHg1r7b5692zkoEB1BUWHytC69ec4dd4T4ovj9s4YAtwvm9NwiC89gl11pwuF1Tt+vqfo4iFmd/bOHGPldBcJ5fYZ7kutqvXuuSe7TkWpecd1ik81gWK7BpPHDie3HbFeKB0Z8B1ZxV0nIKJJEbPpYWXIMbIiIqn1avXu3vLgQd1Rd5As7BzcH/Xv3+94+df/zNGub8ZbmobF+4rcoaBoTHOP92DWgKje1ri3AOQIp/UY+yhqGlvQgR3wjOduy5xQOq0ij5pbv4F29buLPNgpzAuYalYbGKr6PaAMq1vdtADHB+Vvb8qwMab7CGX73eVpvbAMU5aIl22HG94AC2eudwItFxzohN/NXIay4fS5Ph4MbPRLPBKhvoVSozlLtRHBJRjbDozB6rRY8UZ/7VIiNqfVM4ju42pZnBNXvtivdRPaTBUJLRiJMqgxXipBuoVkvT6VBJtEB0j5qpkCfZx1TVNrXcluJvSvqlVVFOs38KOUyub1Wui6FbrrhvituauXaSrkq3Ly/V06h0VF/kCciLCgQKhx2AXXezMuOwA/mZ+tspKYlQFI+FrADU67V6SnAOYkJhIKNEKI5sQSeyVZYchc4/KmNcA3Edz0RWAUZtAmq0EC3OKRD/vERzcBM8OTdERERknPxFnm6Rm9rtnI8kEVHgi6gI3LvB+XMrkZMvjtxUYM4NIzcBT2223i0Ko5U3YniGX2dD0SS8J7P4CszmjYj6otBfpfbMVGRzn3KXzeIbKMulV+XNY6W+uBJ6106rCa3EL50qfbL71MTFEUXr3HLHlCKGhqvxSZYZijJK9tGrlqYW0TR66opR2xD36aefYvXq1fj777+Rny+fjS7L944FO+mLPC9m5SO3oMg5sxsdB9z2KvDls0BBEJWBLnlszZXrYRV/b7G65bwU59UUZAH5V6CcT0QUCCxQvT8rJAB3rwbqdZStEgRBVi2NpaA5uCEiogCxc+dOPP3007jzzjtx+PBhDB06FPn5+fjmm2+QkJCA22+/3d9dDCp146Jly86m5+CahErObzrcD7QbdXVwI0qULvlaqWBAybbSQgMWec6DxVJcfMAtcdotP+FqIrskoT0sCgiPAsKir/4dFmksmVuJIDiT6wuyit/pIzjzJkqSt0uS6wUHUJjtLGBQkHP166JCybbFeS7WMIWCBsXnUlRY/Lfz8bS8nCycOX0SdRs2QVSF2OLzcvvjnk/ifp4lxRtEf4qPWfLom3uivjW8uChCBfHfsEgKKOQ79xMcV4sTuCf3W6zKn7/78d3PWXBA9FCW+71gC5PkBpVcO4c80b6o+LGvIru4+EBRgfgelH/I4qIWglCcoO9+nSOdxSIsVpXrqjKTVNJP6fV22N2ul3OQnVtgx98nT6LxNYmIjqkoLpRgsTmvhcX9WtuuFnVwfT5u5125tvM8FBQUOVDkEF8T5txwcBP41CI00Jj9dYs+aM3IezIbrDYTLTuAgalpQ22pNG+ucfkyxcMZqGBmuCqcwmqz11sremSmypt7VEJzU5WonzRqori50s2mlnNTsq3SfaIVKdOLonmYN6ZH8Vo7HMr3ryR6pNcXU8cuB95++23cd999mDZtGtavX4+RI0eiRYsWSE1NxT333IOaNWv6u4tBpUJkGKpViMCl7KtJ68lpuVcHN4DzF63o2LLvXFmzWJxV0iIrApV0tg2LcEa2vMyRk4OM/CTUbtgciInR38EXwqP8c9xyRMjJQd4lC4SqTcx9zlYbYI12Dr4MypVUSgOAmAj+as+cGyIiCggnTpzAjTfeCEvxjG9RkfM/7vj4eEycODF0SvyXIdm7btyLChBRUMtWGtxEMnLDwY2PGJ0dNhKNUWzLQMUvU+88MRgWMtSmzks5VCNHGhfN9LtDDG5oMjXFoxwar1XO0goD6EQz9NZZrZB9MKJIh5E8HUnUwr0BxfwXt/tEto9BWnlO0oiLJ1XpRH1TWKgUyXO//TWPqbWR2dy5EFFUVITw8HBYrVZER0cjNTXVta5WrVpITk72Y++CUz3Jo2muF3kSUdDLLZBXFuR7bji4ISKiAFG3bl2kpKQAAJo1a4Zt27a51n3xxReIj4/3V9eClua7bogoqElf4BlhsyLMxl/t+WCejxidgJbOyCrNBJuqWuXWiNp7RbTa05tBNxwgkLbntqFqNSu1PAZP+yDdR2EDtaiXqz29PrhV/VLrl1ZlL63lWpEtw/kuWjkgOh02HS1Qu7/U7mH5rqbLg+kUNFNsR7ZeLe8HGkFItYiTVeFdUmrH1orO6Jx/WUZylK6BwbQ607p06YJffvkFt99+O0aPHo3HHnsMBw8eRHh4OE6cOIHp06d7/6AhTvNdN0QU1LIlZaD5SJoTBzdERBQQHnvsMRQUOJPfb7vtNthsNmzZsgUWiwUPPPAAhgwZ4uceBh/pu27+yQiglyESUankFoofS+MjaU4c3AQ6tVwBtTJoBipQiWZi9aqBlZKZvBrZ9ip5KaLqXWb7oXW+WqXldPqpk2Zk7Fgm6OY+GQkfaFQ3c/+Y1KINZnKcTN3Deo2bSSYz0kmNvB/VCIU050alMpy00pxewTelfrufrpH7zNu08pq8LSIiAhEREa7v+/bti759+/rmYOVElWhxCdmsfPkz+kQUnKSPpUWzDDQA5twQERGFrAqSx1QK7A7Yi8pZjXGiECUd3LAMtBMHN0RE5DcPPvggDh8+bHj7goICvPvuu/jggw982KvQEa3wy470jeZEFJxyJJFYvsDTiUM8E3zxSIiZ9kRJ8WqP4BR3Uu3RM/fHYtRK/Gr109ATQSWPxxls08iGsmtvMvHctY/Wh6i1TueRNdMJ1mqFA7RKfBto0lBivoGyzkYuq+EiEmqUHnEzedKePDLlSUEKTxkpkOFeiEGv7+4/h6FSHrp69eq466670Lp1awwePBg33HADGjduLNomKysLv//+O3bu3ImtW7eiUqVKmDt3rp96HFyUnsHPLShC5SjlN54TUfCQTlRwcOPEwQ0REfnN7NmzMWrUKKxYsQIvv/wyioqKEBUVhbi4OERGRiIjIwPp6ekQBAG1a9fGhAkTcM8994hyc0idUvUk6aMsRBSccvlYmiJeBRPKOpFX8fh6EYviKV0jAQhD56NWVlrSgDeSzkv+UirPrNpXpXV6J6bWnm4taYVlStfARBK71nEMd0enxLf7ttJIQmmKHKhF69Q+D63PSa3gg/6B1Y8jLRBg+PSMRAXVQl3SQgNG2tMp9KEWUPRHcQFfue6667Bo0SJcunQJP/74Iw4cOICUlBTk5eWhRYsWaNy4MW644QZcf/31sFgs/u5uUImwWWGzWlDkEFzLsllUgCgksKCAMg5uiIgoIFSrVg2DBw/G4MGD/d2VkGGxWBATbsMVtwFNLnNuiEJCToF4oqICBzcAWFAgYJh+ft6TUrnwYLZX6zhuM/9lkcegFj1SivQYaUurTLUsB8Ts7L+4i8odMLyxgXUGt1Wr/uxJu7rROrcEL1PXoLhx1dVaERClyJdbHprW7nqMXivF6KMBRj/60p4HlT/S2Vw+lkYUGuSRG8YsAA5uiIiIQlqFSPEvPLkFfCyNKBTIS0EzcgOUwWNpZ86cweeff45z584hL0/8ZmSLxYJZs2b5uguBz+Ew9O5CQ5P9Oi8yLKmyVKpKS0YqemkcQC9/xlDuipELptMdQ7tKOmsoSqS3jxatD0ctH0cnx8lg8TpxKT0dWtW61PJnPK0mJ29Y5ZwMJinp9kMr6mWwCqBedUGzQTj3SCMjNmRWtKRiWnY+IzdEoUBeUICDG8DHg5vvvvsOU6ZMgcPhQNWqVWXVbZgYSkRE5FvSX3j4nhui0JBdIH3PDR9LA3w8uHnttdfQvn17vPbaa6hWrZovDxXcdKaSRTO2Xpq+dc2867WjVIHKwHtStJI7ZLurnZPZ6mUeUIrE6OXjeNolAwEZ5eUKeS6GU3a0qt3p7qzeKcX2DEZ8jLanF3FSjKIZjKwY3UjWpMHoltr1MRlwVO4DkUnSnBs+lkYUGhi5UebTnJtTp07hwQcf5MCGiIjITypIZnP5WBpRaGApaGU+HdzUrl0bOTk5vjxE+aM3c6w0xVuaCIhkvaH3oijl5JR1FEZyPE9yHAxvrHYMT/ugUZmtZBbfwGtyVBYod0i6mZc+Eu3jaOXQKEWcFDql9ZkbohU2K460iH7kShk59TS6Z2RfIjXS2VyWgiYKDfJS0HwsDfDxY2njx4/HqlWr0KNHD0RHR/vyUEREFISaNWtmOP/SYrHg8OHDPu5R6JGXguZjaUShgJEbZT4d3Bw8eBCXLl3CLbfcgk6dOiEuLk62zbPPPuvLLgQdtdl6LXqz20aOoUdxhlwtj8ZgOTZZmwajUYZmsD190YhO1MTUsYqXG0xrUm9W8mIT2eXVih6pHVDpepu8ZrJIi9mX6EiSSZTuY8UcleK8KNU2vUUp8qb37h7Pmi5p0muvOQomkydPDvjiMv/973/x7LPPIiYmBr/99pu/u2OatBQ033NDFPwEQZBFYZlz4+TTwc3777/v+nrbtm2y9RaLhYMbIqJybOrUqf7ugqYLFy7g1VdfRUJCArKysvzdHY9IS0HnMOeGKOjlFTogCOJlHNw4+XRwc+TIEV82Hzp0pmRNzfx7OvVrZtZdb3bc0ylmg7P40veNmM1lUWXgfTGm2jVTqcxEszJmo3UKkTXD19Sh8k4mpWidpyErE7TynJSiW4qH1KoAJ9/M1Z5WxNTErSbax+h958v8G1ZnE3v++efRoUMHxMbG4osvvvB3dzzCUtBEoUdaBhpgKegSvApERBRQjh49ir/++gv5+fmydYMHDy6zfnz66afYs2cPtm/fjkWLFpXZcb1NVlCAOTdEQU9aBhpg5KZEmQxufv31V/z6669IT09HXFwcOnfujC5dupTFoQOe2ntjTLeh8I0sZ0MnGmO62phWsojaTLlWdMCtA7qz1W55KJKUFIMNaDOcu2IiwmX2PTdaGxqO1kl2VfuMzdyHipvp9EHvvTiy9cWfq95nazh6ohWdUYvCKEUM1drTqDynyUDZO6VIiqmKfib5M2qTm5uLiRMnYteuXbBYLBCKn7lwz8kpq8HNpUuXMGvWLEyfPh01a9Ysk2P6inQ2lzk3RMFP6edY+ghqeeXTwU1BQQEefvhhfP/99xAEAWFhYbDb7VixYgVuuukmLFmyBOHh4b7sAhERBYk33ngDZ8+exfvvv497770XS5cuRYUKFfDRRx/h6NGjZRo9eeGFF9CoUSOMHDnS1H4pKSlITU0VLXMUjxhzc3MV9ylZrra+tGwQR2qy8gr5mgY/8PXnTIGhrD7ntExxDmBUmBV5ecF3b/niOvl0cLNs2TL89NNPmD59OoYMGYKqVasiLS0NmzZtwmuvvYZly5bh0Ucf9WUXAp4018Er71eRLldpXzobrhadMVKZytDMuuICt+XefE+JEr13lOhEe9wPpRTpMJWKpBPB8iQ6YroPZnNk3PZRjLpp5G158tG676MWoZFdUw/DGaJibyZy09Qik4a7ERamfC/o/HyH6jtvdu7ciQcffBDt2rUDANSqVQstWrRAly5dMH36dHz44Yd48cUXTbW5e/dujB492tC2mzdvRvPmzfHFF1/gm2++webNm01Xclu3bh2WLl0qWtawYUPMmjULJ0+e1NxXb72nLp4XP953JScfSUlJPjkW6fPV50yBxdef85EL4p/rCBv4c13Mp4Obbdu2Yfz48XjggQdcy6pWrYpx48YhJycHmzdvLveDGyIicjp79iwaN24Mm80Gi8UimtEbOHAgnnnmGdODm0aNGuHll182tG2tWrWQnZ2NF198EaNGjUJCQgIyMzMBAIWFhQCAzMxMhIWFISYmRrGN4cOHo1evXqJlDocDBQUFaNiwoeI733Jzc3Hy5EnV9aWVUyEd+PGy6/tCwYrmzZt7/TikzdefMwWGsvqc/7FeBHD157pSdERQ/lyXXC9v8ung5vz58+jQoYPiug4dOuCtt97y5eGDhye5Dmrv2dB5X4zqpLRGH9ybLHXeiNo+3k4iKI5+KEYqzJyEW7THvS1XxM1tpl4rv8iw4ja1qnqpdVV0SEmyimKFM4PtK+2jFWjz5GN0XUoj+WF6Deks18otUzq2Vl6PUmRSFAXS65vbfa91HI3dQkqlSpVcj0tVq1YNp06dcv0fYrfbPXqUKiEhAcOGDTO8/ZkzZ3Dx4kWsWrUKq1atkq3v2LEjevfujTfeeEP1eAkJCaJlOTk5SEpKQnR0tOqgCIDuek/FVSoU96ewCNHR0QH/fqFQ5avPmQKLrz/nIos4v6ZCpPqkS3nj08FN1apV8eeffyoWD/jzzz9RtWpVXx6eiIiCSGJiIk6ePIkePXqgU6dOeOutt9CgQQNERERg2bJlaNasmc/7EB8fjzVr1siWr1ixAnv37sXbb7+t+ELqQCatoFTkEFBQ5EBkGJOPiYKVtFoay0Bf5dMr0atXLyxevBi1a9dG3759Xcu//vprLF26FAMHDvTl4YOSmefrVWduPalcpbaRWgUqg1EJU+9qMZMLo9KEdDdTOShKjbgtV4wEmXy/iZHjmOY28y+r3iWJChjO+1HeTL2ralGJ4g2NnJbWNtLcNCP7GMrT0YnW6TEVvTIQjVH6xmoF7JLKvaEYtQGAoUOH4tSpUwCARx99FCNHjsSoUaMAAJUrV8aKFSt83ofIyEh06tRJtnzTpk2w2WyK6wKd0i89uQVFHNwQBbFs2eCGP88lfDq4eeyxx7Bv3z488sgjiI6ORnx8PC5evIicnBw0bdoUjz32mC8PT0REQaR///6ur+vVq4cvvvjCVRa6Xbt2iI2N9V/nglhMpPyXnpyCIsTyCRaioCV9XxUHN1f5dHBTpUoVrF+/Hhs3bsTu3buRnp6O6667Dl26dMHgwYMRERHhy8MHHdNRBqX9FKIJhg9g4GCuJky830WtacPvajHYb68UW9OIHskiQSYjCZ53Sn48tUCJLOdG5ziGg2UmLq7Svp58vHrV6WS5LVpRKpPHc19Qmkpv3oqwSKOGoZpzIxUTEyNLzveXOXPmYM6cOf7uhkdiFN59kcMXeRIFNel7bqL5WJqLz69EREQERowYgREjRvj6UEREFAIuXbqEs2fPIj8/X7auY8eOfuhRcAuzWRFhs6Kg6OoImS/yJApu0p/hCozcuHCY52fuqS2evhm8VO/a8EJ+gakN1d6bo1aSS7KPVmBKdGydzpo4bVFfRDPybh+aXnUzpQ6ozu574X02mtxOXpRapRWt0ztg8QejmOcijYBILr5WHpBoU0n/ZPeC1mchP6zqemnox1SOmlITCgfU/YhL8Q9Caf4t8beUlBT8+9//xu7du2XrBEGAxWLhexw8FBNpQ0EOBzdUejNmzEBmZqZqxUAqG9LoazQHNy5eH9yMHj0azz//PJo0aaL74jSLxYLVq1d7uwtERBSEXnrpJSQlJeHxxx9HYmIiH132ophwG9JxtSQ0H0sjCm7SCQrm3Fzl9cGNIAiKX+ttSyrMTsEq5WWoTD2LZuQ1pqeNRJf0qoh5ROFcXLP53nzJigmyfI5SHM/0rm4REFm0Q6cimSzipNQByXtuTOVGORTezyNpQJavpRWtc/tWK89Jq/KZdD8Dt7q4UU8+W4PlDnVPXZJUY+afgWCN2gDAnj178O9//xtDhw71d1dCjnRWl5GbwFTkEJCeU1Cmx4yNiYDNynceBRuWglbn9Suxdu1axa+JiIi0WCwW1KpVy9/dCEnSX3w4uAk8237/B89/dggXs8p2cFO9YgReuKMlBrTmz14wyWa1NFU+nebeu3cvsrOzFdfl5ORg7969vjw8EREFkX79+uHbb7/1dzdCkvQXH+msL/nfjI2/l/nABgAuZhVgxsbfy/y4VDryyA0HNyV8GsMaPXo01q1bh9atW8vW/f333xg9enS5Sg7VKt+q+iiJ0pspdTbRa7wUT7qp0k2KV3gmSPclkKYOqP6UlcEnhbQpJLMbobqdNx9nK36GTOvxMb0Ed+k+7pt4/DJMLz3W5fq5cXtGzfSTYwY2lD02p1OgwMhx1O5xtVLe5d1tt92G5557DoIg4Oabb1Z8r02LFi3KvmMhQPqLj3TWl4iCC0tBq/PpldDKqbHb7bCWhxc1EBGRIWPGjAEAvP/++/jggw9E61gtrXSkj6UxchN45gxp7dfH0ii4sBS0Oq8PbrKyspCZmen6PjU1FefOnRNtk5eXh02bNqF69erePnxAUxrLqQU4zDSilMxfinds6jNS2lYj4qSYqO42K+9p/6R90JrdV1zn1oCh5HfZxvLvZREQhZNXiywZPqROkr9sH717SLKZodoNBkIRaiXLTVMrJ67TvGopaLVS1WbuR5PhTbU21e5VaTGPUJ0Xmj17tr+7ELKkkRvm3ASeAa1roV/LmiwoQIawFLQ6rw9u3nvvPSxbtgyAMzl0ypQpitsJgoDx48d7+/BERBSk7rzzTn93IWTJBzd8LC0Q2awWVKsY6e9uUBCQl4LmY2klvH4lunbtipiYGAiCgHnz5uHee+9F7dq1RdtERESgadOmuOGGG7x9+KBguKSyp6T5FyYaV8o7UJ0lVooKuC1Xiz7otacXBTI06y2djVfZVi1iIZvFV+qqWihAax8jZZCtVnm5Z412NS+IVjlhnc9P73YxnHOjFgFRukEk3+u9eFO9Q7rdke2nFdkyeyzFzbT2kd6vKjllpf33wRttUHCSPo/PyA1R8CpyCMi3i/8xZ0GBq7w+uGnXrh3atWsHAMjNzcWwYcNQo0YNbx+GiIhCzFNPPaW6zmq1onLlymjVqhX69OnDF3yaxMfSyFvmzJnj7y6Ue7mF8p9fDm6u8mkMS+2RtPJO99l5k1OrWi//k27ovkop+qAUsZD1V2EKXCkqIIo+GHmRocFEAk9mnj2O9qjs6LoOBnNaXLSq3emFKcxU/FI5rFrlM6VG9A5nJm/ENGk0xQhJJMhQpTKl5Sqfg6Frp9Al3X0Uw3Ti3aSbaP2Yawn0qM3u3btdeZthYWGIjY1Feno67HY7KleuDEEQ8O6776JRo0ZYu3ZtucvbLA2WgiYKHTn58sdK+VjaVV6/Eps3b8ZNN92EuLg4bN68WXf7wYMHe7sLREQUhJYsWYIpU6Zg5syZuPXWW2Gz2VBUVIQdO3Zg/vz5eP3112G32zF16lQsXLgQs2bN8neXg4b0Fx+WgiYKXkqRV0ZurvL64GbGjBn45JNPEBcXhxkzZmhua7FYysXgxvQsqyy8Il+sua9GQo/qzK1OhTU1iu0pzZ7rVUtTbcxDWpW6tCqV6YQ+VCu9QWHm32DTnjDcb639DCR+aX1GhiMgWoeT5nRJQkx695esD9KIj0LIynDESSnSqfiNeqOGKraZiAJJo6iBHokxa86cORg7diz69+/vWmaz2TBgwABcvHgRs2fPxkcffYQHH3wQK1eu9GNPgw8jN0ShQzq4sViAyLAQLaPpAa8Pbnbu3In4+HjX10REREYcPHgQkyZNUlzXtGlTvPbaawCAZs2a4fLly2XZtaDHnBui0CGtdlghIgwWC8t5l/D64KZOnTqKX4cSs5EYkykYqjuXusKaTukyvVly1zZ60SS3C6SUc6NYtUrrJLQqtuHqhL10NlxWjEsrIiE5ltrMv2J7ZipnKZyI4YpaWtfdYIUzEYM5PKWOOEmvqXy15vHd/zZxSPH1Vvvs3T5XpXtVNT9Oo0NafTWcY6ewTC0KFEoqVqyIXbt2oUuXLrJ1u3btQsWKFQEA+fn5qFChQll3L6hJH0tjKWii4CWdnOA7bsR8GsPq3bs3jhw5orju6NGj6N27ty8PT0REQeT222/HO++8g9deew1JSUlISUlBUlISFixYgJUrV2LgwIEAgEOHDqFJkyZ+7m1wkf7yw8gNUfCSv+OGgxt3Pi2tcPbsWRQUKL9pNz8/H+fOnfPl4X3Gm7kT0plp3VlfI9EHSduG6ERHRG0aqXxmdppZa2rfatWd3deK0oj6V7yh1vXWq/Km1mdPq4sZZiCKp1axTe/YBgNGhvqmtM7wvWokd0UtgmUwZKKUW6OWD+R+OM1zMPFzqdU3pVVKxdS8+W9QIJk2bRpSU1Px1ltvYcWKFa7lgiBgwIABmDZtGgDnKwe6d+/ur24GJVnOTWERBEHgoyxEQSi3UBx5jQ7n4Mad3+rGJScn87ECIiJyiYiIwIIFCzBp0iTs2bMH6enpiI2NRceOHXHNNde4trvxxhv92MvgVEHyWJogAHmFDj7OQhSEsvPFkZsKkSwD7c7rV2PTpk3YtGmT6/uZM2e6npMukZ+fjyNHjqBjx47ePnzQMjI7LM0hMD0br/Zsf3EEwkgukdn8HqUZedG5Sl/e4Y1jK2zvunZ6Fbyk/TZyUGmlOYU8D6NN6X0AWhEGrWMoFA1TP6xaOEurAZ2T08o1MZx7pdCYkXwd6Ya6Pxcq5yqNnCoyeJPqpL8pdkV6P4eFhWbeDQA0adKEj515mdIgJrvAzsENURCSVjvkY2liXh/c5ObmuqrYWCwWXLlyBYWFhaJtwsPD0b9/f0ydOtXbhyciIiIJpV9+WA6aKDjJCgrwsTQRrw9uRo4ciZEjRwIAevXqhSVLlqBZs2bePky5ZCi/QGkq1y3BRDFSUZp8AbX9lGbDi/+I8l1UohylZrBEnSyHyGDlKtE6h+T9QSo5IYYiFGq5QpLvle4FI3kYsmiZUuNa95Buso/yMqW8EfeKerIcJ51rrhfB0qL7OajkK6lVX9Pa1zCNyKlCwFFxmRIj0Vh/a968OdatW4fWrVujWbNmmjkgFosFhw8fLsPehQ6lX35YVIBK459//sGSJUvwww8/ID09HfHx8ejduzcmT56MuLg4f3cvpOVIcm74WJqYT6/GN99848vmiYgoyE2ePBk1atRwfc0Ed9+wWi2IDrcht/DqgCab5aDJQ8nJyRg+fDgaNmyIhQsXom7dujh27BjmzZuHH3/8EevWrUNsbKy/uxmycvJZClqLz4d6BQUF2LhxI/bs2YPLly/j+eefR8OGDfH1118jMTER9erV83UXAprR2Vfdhaov5IBoalw1kqC2zJPZcLWcCEl1Ma11WsdQy30wmw+ktaMokmCwCpehCmtqfVBZrhYRcn2psEwpOqOXEyTax+BUv+4p6EShFJXcqzrX3HCUSo+Bhgzn9eg1oBYhdfv5NBo4NBqRCfSoDQBMmTLF9TUfVfatmAjx4IaPpQUgRxGQW8YvqI2OA6zmfjl+4YUXEB4ejlWrViEqKgoAULt2bVx33XW45ZZb8Nprr+GFF17wRW8JCqWg+ViaiE8HN2lpaRgzZgyOHTuG6tWr49KlS8jOzgYA7Ny5Ez/99BNmzpzpyy4QEVGQy8/PR2RkpL+7EfSiI2xA9tXv+VhagPljE7D9CSA7tWyPWyEe6D8PaHGnoc3T09Px008/4bHHHnMNbErEx8dj4MCB+PzzzzFz5kxGYn1EWgqaBQXEfDqvN2/ePGRmZmLDhg347rvvIAiCa12nTp2wd+9eXx4+KJiZfdV8zF8hGUMvR0cpKqCWF2G4v3rvfVF7R4lSE1rvPFG4KIarbhnMdxEtM1MNzC0C4p5PopbvIop0KFUQUziI1jXSqrql255GG9IVZi6jKQbPSW253rUTUQqBSD5zg+lbogV611uN6HMN8FJovogKbd++HR988IHr+1OnTqF///5o27YtRo4ciYyMDO8ftByRloPO4WNpgeWzR8p+YAM4j/nZI4Y3P3XqFARBUK1o2KRJE2RkZCAtLc1bPSQJWeSGOTciPh3cfPfdd3j44YfRokUL2ei9Ro0aOH/+vC8PT0REQWTlypXIzc11fT937lxkZmZi9OjR+Pvvv/Hmm2/6sXfBT/pcPiM35AslE9nh4eF+7knokubcMHIj5tPBTVZWFmrXrq24zm63o6iI/7BqVq+SMJTXIm3b6HKD71dRywERLXObvZalrKj1WynvQNK+qX4bfFeL2bwftQ5p5UVpVYeTHV+pPb3okYEolWKVNY1+l0nQwMRBzOTPqEVTDDeudrEMHFvxWxORKNG9b6IKnj/44h45c+YMrr32WgDOR9F++uknPP7443jqqafw6KOPYufOnd4/aDki/QWIg5sAc8frzkfEylqFeOexDapfvz4sFguOHz+uuP7vv/9G1apVUblyZW/1kCSk1dJYClrMp3GsunXrYv/+/ejSpYts3e+//45GjRr58vBERBREcnNzERMTAwA4cOAACgoK0KNHDwDANddcgwsXLvize0FPOrjJ5WNpgaXFnUDzOwK+oEBcXBy6du2KDz/8EPfdd58o7yY1NRVbtmxxvRKEfEP2WFoEH0tz59OrMXDgQLz99tu49tpr0bNnTwDO9xT8/vvvWLNmDSZOnOjLwwcPgw/1G5opleRtKOWCKOaHOBya3dB6v4rWDrL3m6jlyGhFTXT6bZqJSIdH3C6WezsGXqmi3Z7OeiOV7tSCFKI8JoP9MpN/pdgdE8dTq5CndQC1vCS1aJlaO4aUJoxhNmKIwI3mlFZ8fDySkpLQsWNH/Pjjj2jUqBGqVq0KAMjIyJAlL5M50l+Ashm5CTxWG1Chur97oeu5557DiBEjMG7cODz66KOiUtANGzbE5MmT/d3FkCZ7LC2SkRt3Ph3cPPjgg9i3bx+mTJmCKlWqAADGjRuH9PR0dO/eHaNHj/a47f/+97949tlnERMTg99++0207o8//sC8efNw4MAB2Gw2dO7cGU8++WS5LztNRBTI+vbti9deew179+7FDz/8gAcffNC17s8//0T9+vX92LvgJ4/ccHBDnmnYsCHWr1+PpUuX4tFHH8WlS5cgCAL69u2LuXPnIjo62t9dDGnSYiAsBS3m08FNeHg43n77bWzfvh3fffcdLl26hLi4OPTs2RMDBgyA1cPpxwsXLuDVV19FQkICsrKyROv++usvjBo1Cs2bN8eiRYuQn5+PxYsXY+TIkfj0009ds4BBw8Dstu7z+yobGKqyptamFk8rPWmWg1NfZjqIU8p3m6i1oxQ5cW/HUNTL4M+E7rtPSqIBBtuT9s2r+RTFUUFTUSqlfCu9soHu++tsprarbjBS711AxdE6xc3MVPAzkAMXFhbwBdVMe+SRR5CdnY3ffvsNt99+Ox544AHXuu+++w433nijH3sX/OQFBfhYGnmubt26mDNnjuv7xYsX491338WRI0fQrl07P/Ys9Lm/rwrgY2lSPr8aFosFAwYMwIABA7zW5vPPP48OHTogNjYWX3zxhWjd4sWLERERgbfeegsVK1YEALRo0QK33norVq5ciSeeeMJr/SAiIu+JiorCiy++qLjuk08+KePehB55KWhGbsh7Hn74YdSpUwcHDhxAmzZtPJ7AJm0FdgcKiwTRMunERXlXJkO98+fPY+/evUhPT0dcXBw6dOiAmjVretTWp59+ij179mD79u1YtGiRaJ3dbsd3332HQYMGuQY2AFCnTh106tQJX3/9NQc3RERULrEUNPna0KFD/d2FkKf0OGkF5tyI+HRw43A4MGvWLHz00Ueiss82mw0jRozAM888Y2pkf+nSJcyaNQvTp09XHBydPn0aeXl5SExMlK1r2rQpfv7554B+07XepZA+gqL4OJbk8TJRqWmdBO+Sx5oMPyHj9tiVrGiAN8vY6jyGZPgYeo/LKRU7UCkOoNkvlaIJZfEIkVoZbXM7a3/mqtTqTKs95magWIap0zD4PKXao2Ky4hdKTSg8iqh02kaeoNOks6ParRwE7/4kP5KXguZjaUTBRloGGgBiwvlYmjufXo0lS5bg/fffx913343bb78d1atXx8WLF7FlyxZ88MEHqFy5Mh55xPhbcV944QU0atRItcRgeno6ACA2Nla2LjY2FoIgICMjAwkJCYr7p6SkIDVV/HZgB39TICKiEMCCAkTBTyniysfSxHw6uNmwYQNGjx6Np59+2rWscePGuOGGGxAVFYUNGzYYHtx88cUX+Oabb7B582ZYLBbNbbXWa61bt24dli5dKlrWsGFDzJo1y1AfPeHxzL5b6Wbdcs/mmlVcphj8cYtmeHI8QyWiTTRupJS1dGpbLclfFgFRKg4gaUup1LGRF0p6sxCCwarRsgOrRQUNHlY/7GGU243mQYVkQ33wynyF4+pLWL05/2H0fEXFI+TdIlLEUtBEwU86KRFusyAijPlN7nw6uMnIyHC930aqZ8+ehhNEs7Oz8eKLL2LUqFFISEhAZmYmAKCwsBAAkJmZibCwMFfE5vJl+Quw0tPTYbFYNN+YO3z4cPTq1Uu0zOFwoKCgwFA/iYiIAhUjN0TBLztf/FhaNMtAy/h0cNOsWTOcOHFCsXznyZMnce211xpq5/Lly7h48SJWrVqFVatWydZ37NgRvXv3xuLFixEVFYWjR4/Ktjl69CgaNGigmW+TkJAge2QtJycHSUlJhvrpMTPTrQohFKWcGyMzyoZn5I1u696w28y24X3Eh5T1oTS0co8Mcbuual1Sy8lRzIkykt/iAZPvufReH3QaUFytVeLbTG5PCbWXeGrt44M+uK/SjQxKvmHkhXyJpaCJgl8Oy0Dr8ukVeeKJJzB9+nTUqVNHFMH55ptvsGLFCixYsMBQO/Hx8VizZo1s+YoVK7B37168/fbbiIuLQ1hYGG6++WZ89dVXeOKJJ1wV086dO4fdu3fjvvvu88ZpERFRGfvnn38gCAJq167t764ELZaCJgp+0oirNCJLPh7cvPDCC8jPz8fEiRNRoUIFVKtWDZcuXUJ2djZiY2PxwgsvuLa1WCz47LPPFNuJjIxEp06dZMs3bdoEm80mWjd16lTcddddmDBhAh588EEUFBRg8eLFiIuLw9ixY71/kqWkVIFJcZuSzUyUVPNKREASsTBEKSHARHKOpzk30j5otaN6Pmr9VopgqSU+6L3cU3WhRptufVDsh077iudbiheGypbr3CCq1dKkVfVMVC+TtWuwWpouIxE+jRCY+yoz18jMocrj6yP69OkDQRBw+PBhf3claEl/Ccq3O1DkEGCzauexElHgkE5KxLAMtIxPBzexsbGyymVqlcq8pUmTJli7di3mz5+PRx55BDabDZ07d8ayZctQtWpVnx6biIh8Y9CgQRAEQX9DUqVUUSmnwI5KUeF+6A0ReUL6OCnLQMv59IqsXbvWl81jzpw5mDNnjmx5y5Yt8d577/n02N4iDWjoThYrTOPq5haU5MBI9jUzkawXKZDNoCtFTvTaNJhLobZO2gfTKRNu10gWSdCJ0Ci+X8TgO3hc++nlehjIG5H122DOlDTCYCRvRNaHUnx+smsg+dZQyozB+1ttH1FFPaW+uX/jybmaCbfo3FsOBxAWVr5ydHxZtbK8UHo2P7egiIMboiAijdywDLRcOXy4gYiIqPxRejaf5aCJgovssTQObmR8HstKS0vDu+++iz179uDy5ctYtmwZrr32Wnz88cdo3bo1rrvuOl93ISgYnvBVmP3VzYnQioqY7JhajpDWDLp0c8WKY1oV1rRyWJSiFnp98ORdKDqRKNElNlj9ynRVOAPtyiIgBl+GIr2mqnkjWn0rvkaGc6a0Lqgn+UCetCfN+XFvVGmdwehaqSMqZj7rIHfu3DlT27OggOciw6ywWgCH29N9rJhGFFxyJKWgWS1NzqdXJDk5Gf/617+QlZWFZs2aITk52fXOmD///BMHDhzA7NmzfdkFIiIKYL169dJ9MbM7n5fmD2EWiwUxEWHIcvvliO+6IQou8lLQjNxI+XRwM2/ePFSuXBkbNmxAtWrV0LJlS9e666+/HkuWLPHl4cuMYr6Fh7zSjsFKZUqz1abzZDQ2FEVoFHIbzEZTTNF6L41a1TSdmX/3tCWjURqte0PxOqhForTWKeWNlCb3w2DUS6nfehXOdCt/qeyslHMi21dnR8V7QSlaqJVzo8fgyev2WyPnxv3cQyF6M2vWLNfgxm63Y/ny5YiKikL//v1RvXp1pKamYvv27cjLy8OkSZP83NvgFxNhEw1uWA6aKLiwFLQ+nw5udu3ahZkzZ6JGjRooKhJ/GPHx8UhJSfHl4YmIKMANGTLE9fXChQvRpEkTvPXWW7C6DfAmT56Mhx56CKdOnfJHF0OK9BchPpZGFFxk1dL4WJqMTwsK5Ofno0qVKorrcnNzTT2KEMhKM3sq3ddw2oDbrLLuq1aMzIZr5CS4rzK6j+mLYiDHQi0SpNg3rWbNzKC77eOeT6JW3UvpUHqFtUqdU6F7A5hK5/EsP8uTiIVWZESnw4qpLzo3gOJpaeUkKeXcGCDLO9K7+EqJShoRQb20n2C2efNmjBw5UjSwAQCr1YqRI0fi008/9VPPQkc0X+RJFNRYUECfTwc3jRo1wi+//KK4bu/evWjatKkvD09EREEkPT0deXl5iuvy8vKQmZlZxj0KPfLIDQc3RMGEpaD1+XRwM2zYMKxevRqrV69GRkYGAKCwsBA7duzAhx9+iOHDh/vy8EHJcL6C1qyywfwZzWOo5KVYrcqdNPROkVLuo1c1zkxRLr2oiVIjWvkkps/Trfqa4epiem26L9epWCc9mVIHa3RCjoajJsZXy7fxtCJgMVOREOnPn9uHKcvNUvig1SrlGQjChbTrrrsOb7zxBtLS0kTL09LS8MYbb6B58+Z+6lno4GNpRMGNkRt9Pn1Q75577sGRI0cwe/ZsvPrqqwCAkSNHQhAEDBs2DHfeeacvD09EREFkxowZuP/++9G7d2907twZ8fHxSE1Nxa5duwAA7777rp97GPwYuSEKbrnMudHlsyuSl5eHW265BS+88ALuuusufPPNN0hLS0NcXBx69uyJ9u3b++rQAcmjykYGq1YpvRfGyLE0Z4RVQhsOh/KO3ppdLk0FKKX9FKMtapEEpUiGJMFBLdqiFdExHbUoRTKF4c9B0jHR56r0mSscQC3iJLt28iYN9c8rOSUKjXgzEiKLlGlFTQ1EyozmcoWqtm3bYv369Vi6dCn27NmD9PR0xMbG4uabb8bEiRNx7bXX+ruLQU/6ixBLQRMFF+mLdxm5kfPZ4CYqKgr5+fmIjo5GmzZt0KZNG18dioiIQkSTJk3w2muv+bsbIYuRG6LgxlLQ+nw6Pdi5c2f8+uuvvjxE0DCVqyEJD+i9q0XtYGrP9St+60kyiU5belEYrVwY6Qaq3dBJPtHrvixnQ3LN1TpgNKpgZDvZtTM7a1+8j+L1VroX1KIZKi+PMdQdtxCZ3n0n7bcaxTwhSXtaBdJ0oyN6zISOjPzMujWr27TCOZa3YM6JEyfw22+/4eTJk/7uSkiR/iKUzZwboqAhCIIsT44FBeR8+qDehAkTMHXqVERERKBv376Ij4+XlX+OjY31ZReIiCiIfP7555g7dy7Onz/vWlazZk08+eST6NevX5n14/Dhw1i6dCl+//13XLlyBbVq1cLtt9+OcePGITo6usz64W3SUtB8LI0oeOTbHXAI4mUVmHMj49MrUvJytqVLl2LZsmWK2yQlJfmyC8FBOo2rV+nKTFvuDRh4iY6h93OUTD1r5RB4I2fCbfpbVoFK9cDwLPohPabRbb2QIKQUoTAdcSq+RmobKl4zt33UcqkkXS0VxWiYxj2mGj3TCckoRv/MhhC1littYuIiqUWk1PKzrFbArjC5Xpr8NG/wxfG///57TJs2Dddccw2mT5+OhIQEXLhwAZ999hmmTZuG6Oho3HTTTd49qILjx49jxIgRaNSoEZ5++mnExcXhf//7H9544w388ccfWL58uc/74Ct8LI0oeCn9vPKxNDmfDm4mT54cMi/qJCIi31q+fDm6du2KFStWiF7k+cADD+CBBx7A8uXLy2Rws2XLFuTn52PJkiWoX78+AKBLly5ITU3FunXrkJGRofqC6kBXQfKLECM3RMFDqXQ7H0uT8+ngZurUqb5sPiRozZhf3cBJ7R0zuhPMKrk2hnJe1KJIxdPMqjO33pzSVYo+aB2nuN+mgzeSGXSHw619petgcsZfLeKklpdhmFakSivnRlo1TutcFTqmmwNWmgikQVpRPLM5aoba0Vwob8LMOYsCgW73fMnH688ojRJf9OfIkSNYuHChaGADABaLBSNHjsTjjz/u/YMqCA8PBwBUrFhRtLxSpUqwWq2u9cFI+lgac26IgofSZARLQcvxihARUUCwWq0oLCxUXGe328vsSYDBgwdj9erVmDlzJp544gnExcVh7969WLduHe655x7ExMSo7puSkoLU1FTRMkfxSDA3N1dxn5Llauu9ySaIBzPZ+YXIycnx+XGpbD9n8h9ffs6XMrNF30eGWZGfF9z3ky+uEwc3fqY7s2vgXSFmZ1CNpCEoHd+1j5EqZmrUckPUDyk+NtRn5JXePaN3LKW2SvYzdG5aEQu16mFaTXhSnU5rWr84OqOWc6PfIYObqV0wrQp0Bo6teiylvhn8QfA0giS9hgqpZzKi6J9GW0bzndw/6kCL5HhDq1at8M477+Cmm25CVFSUa3lBQQFWrVpVZq8UqFu3Lj7++GNMmTIFffr0cS0fNWoUnnnmGc19161bh6VLl4qWNWzYELNmzdKt/FYWleEuXcgXfZ+Zk8/c1zLGCoDlgy8+5yMp4p/fCKvAn18FHNwQEVFAmDp1Ku677z706dMH/fr1Q/Xq1ZGamoovv/wS6enpWL16tek2d+/ejdGjRxvadvPmzWjevDnOnDmDiRMnolq1ali8eDGqVq2KAwcOYPny5cjJycGsWbNU2xg+fDh69eolWuZwOFBQUICGDRsqVlrLzc3FyZMnVdd7U3ZMOvDjZdf3hQ4rmjdv7tNjklNZfs7kP778nM8gFcDVn9/KMZFB//Nbcr28iYMbP9N53F9OYQPDM9EGpnoNV0vTWqTTIa3AgVYUw9SMu8F9DbepFM3QyymR5AoZupwGE3A8iT54ZaZf60Lq9L00n5/u/VUS/fBBYo/a56d2SLX7wJ3sUulUTJRGa7xxmqUpKugrHTp0wKpVq7BgwQJ88MEHEAQBVqsVrVu3xsKFC9G+fXvTbTZq1Agvv/yyoW1r1aoFAFiwYAGysrKwefNm1yNoHTt2RFxcHJ5++mkMHjwYN9xwg2IbCQkJSEhIEC3LyclBUlISoqOjNR9p01vvDVUrix/7yy0s8vkxSawsPmfyP198zinZ4pybOnExvJcUcHBDREQB44YbbsC6deuQm5uLzMxMVK5cuVSznwkJCRg2bJipfZKSktCkSRPZLw2tWrUCABw7dkx1cBPopJWV7A4BBXYHIsICbKRLRDLJl8X5cfXiOLBRwsENEREFnOjoaL89upOQkIBjx44hOzsbFSpUcC3fv38/AKBGjRp+6Zc3KL3wL7egiIMboiBwOk0yuKnKxxuVcHATQPSe7BGVglZLqlZj8NEmQ4+XleZZFq1iBG5J2kpMleR1K+tsYDN9SqWl3ev0urelclDRCx8NJvOLjmPgRZSy3d0KOKgWFpDSyZBXTGjXfcbQIJVjqz0uKbqmauv0jqdValzaB5XHxdQXuO3sVjrd7I+W9N8GbzxSprW/P0tPl+TYnD17FgUFBbL1zz77rM/7MGbMGEyePBljx47FmDFjEBcXhwMHDuCtt97CNddcgx49evi8D76i9E6M7AI7qsQEb3lrovIiWTq4YeRGEQc3REQUEH788UdMmTIF+fn5iustFkuZDG569+6N9957D2+//TZmzZqFK1euoGbNmhgxYgQeeughRERE+LwPvqL0NnOlt54TUWARBAFnLovLJterysGNEg5u/Mx99lRvMl9UhlktAqKWVK2w3FAxA0/K6+rWxlVfp9VOqWeTS7OzVeWFpUqdkkzPy/YzkPiuGCXS2qf42ikeC4qBDfUoh1YxBqtVuRsGSmJrMXB6isfSbdrIZy4t2W0gQqa1XDHIJokk6nTF7/zVj7lz56J58+aYOXMmmjRp4teXZXbu3BmdO3f22/F9JdxmRbjNgsIiwbVM6cWARBRYUq/kI98u/seZj6Up40O2REQUEJKTkzF58mQ0a9bMrwObUCd9o3l2gV1lSyIKFNJiAhE2K2pUilLZunzj4MbP1F7yp7uTNOfGfZbcw2lXxef4tWbxHSov5NTKYXCLgChFEfS6LsuxMJO84EmSgiRCZvilkQpRETO5UXrbyvJ7lPZxuxf0oi2eBtvU2hN9r5Xb4xZZMhwwUYs4KeXDKISz1KJAepFBQ9fBYP6OGd66lT1VllGcxo0bIysrq+wOWE5JH01j5IYo8CWniR9JqxMXDavV4qfeBDYOboiIKCA8/PDDePPNN3Hx4kV/dyWkSYsKMOeGKPBJiwnUjeMjaWqYcxMIDCcbuG2v++ZAz5idpVU9rFqOipkqYUYO7O2cII3uyCJbWpEJE+dTqoCSJ/khCvvp5TqZbV56LNXIkZkbTmFbtRwj3WUqDVitMHVvefpjp5v7pBNV80a1NKPKMkrUs2dP/PHHH7jlllvQrFkzVKlSRbTeYrFg+fLlZdehECUtB53Dx9KIAp7sHTcsJqCKgxsiIgoIGzduxJIlS2Cz2XDmzBlcuHBBtN5i4SMY3sDIDVHwkT6WxjLQ6ji48TPdWVG1qmgGK10pMRU80Xmvh2p0pni2XimHRy8VQ68PauerVP1NMb9H7wUf7ttLGjAVjVJuWraPt4JZphrRippIKqKpbSaLPmhUjdN6H4yR8xRVChR3VfxNKUKPss/cQMRH6T4xcj5aaUjiL/z7zpmytnTpUtx8882YM2eOLGpD3iPNueHghijwySM3fCxNDXNuiIgoIFy6dAmjRo3iwMbH5AUF+FgaUSCzFznwT0aeaBkjN+o4uPEzI5PE0m01dzCbJyCJIGhFWpQa0qrCpVcBS7fymJEQj0ZYQXY+CmEcWdM6YRS9oI/h8/UkwmYg2iNb50lOjqQKnqGIoYFmZRvphIS07juF7rhuYLXbxszPmm43NSrDmY6y6OQJaf1ohJrmzZvj/Pnz/u5GyJOXgmbkhiiQ/ZORhyKHIFrGnBt1IfpfJBERBZsZM2bgnXfeQVJSkr+7EtL4WBpRcJFWSqsQYUNcDN8FpoY5NwHC9Gyvt6uOSZs1+A4UE03LGtPtqsqBzUZAZNuWYtrb8Ht4PKUVIdJpXPH0lKJrbhEsIzlJaut07wtPK8ZJ8540mlLKuVE8J3PdcfFVVTLD0bVy5rnnnkNaWhqGDBmC+Ph4xWppn332mZ96FzqkBQX4WBpRYFOqlMYCK+o4uCEiooAQGxuL2NhYf3cj5MlLQTNyQxTIZJXS+EiaJg5u/MzjWWEDOxqqsuSrWWO33AND6UGe5NXID2msPbWmPXmviVt+iFaOjOEuuVXhMltNTrSP27taVN8Fo5YzZTihx1i/3A+p1A+13CwjFds86YtXI5HSRj25V5UW6OQdleV7bsrS2rVr/d2FcoGPpREFF1nkhsUENIXgf49ERESkRv6eGz6WRhTIpDk3LAOtjYObQGBwptzMO3FKdlV747rSO2jUqmJ5RG2mXO29PRKeRGG0GK7g5c3p8OLIiGhSX+G66r63Ry8qoLWP1rEM9EFrQ91+a0WPJPvJIk7QuAU9uTd1zslIBMvoYVUjplrXQSVByGRAKCSkpaVhwYIFGD58OPr27Ytjx44BAD7++GMcPnzYz70LDYzcEAWX5Mt8gacZHNwQEVFASE5Oxh133IG1a9fCYrEgOTkZBQUFAIA///yTj615ibQUNAc3RIErt6AIqVfyRcuYc6ONg5tS8Npsqs67ZAwfR+e9IZqz6xq7qzRhvh9am0mSCDw5Z0/2MfyeG4fGm+eln5EkYiGqYqYQXVPNiZF+rxY1kbzfRbMtFaWuLKZ0TY3cNG75QlLuu3kSUDMciVR6J1JxAwZexyPbRzUfRucz0oqqaUZZQ8i8efNQuXJlfPHFF3j//fchCFff63D99ddj3759fuxd6GDkhih4nJHk2wBA3Tg+lqYlRP+LJCKiYLNr1y5MmTIFNWrUkJU5jY+PR0pKip96FlqkgxuWgiYKXNJiAtUqRKBCJOuBaeHgphS8OXtqJOog3cZU5EhhY0P7a1VtMpBLoUXpHSUGd9U/jiTSYvhdLRpRE7031WtFLLSqrKkxVUBO7bMwmDcijXK4R5TMVrsTRQXVSqGpUYnEmYqe6PTP0Pm4LVO7901XmtMhOpaH+T7BLj8/X/ZumxK5ubl8r4OXyB5LKywSRcmIKHBIy0DX5SNpuji4ISKigNCoUSP88ssviuv27t2Lpk2blnGPQpM0ciMIQF5hORlBEwUZWaU0PpKmi4MbP1PNddCbaXabOdaNPkiWiWbkFXIlzEQMVPtgIDIhy7lROYaUyitBFJebnvE2GCIwG7WT9cVAVEer716pJmcojGN4M+V9SlmBzuy94FGbZkM5xfvoRfIMtSfZz5NrHUqGDRuGNWvWYPXq1cjIyAAAFBYWYseOHfjwww8xfPhwP/cwNEhLQQMsB00UqGTvuGHkRhcf2iMiooBwzz334MiRI5g9ezZeffVVAMDIkSMhCAKGDRuGO++80889DA3Sx9IAZ1GBan7oCxFpkz6WxjLQ+ji48TPFKIRkmt9wrofmDvJdHQ7xN2rv1NCqEqa6jc5MtKyvBnIipLuU5HQoRo8MTnXrvvdFJSykFnUyfCy1z9eTSnNaB5P0W/PdNCrbGgpsKEW2TOSNqAUbFftgoEOGj2UivCetdqeVc2M6H85kiFE1FygEvPTSSxg6dCi+++47XLp0CXFxcejZsyfat2/v766FjOhwpcgNK6YRBSJ55IaPpenh4IaIiAJK27Zt0bZtW393I2TZrBZEhVtFeTZ8LI0o8GTkFOJKnvhnk5EbfSE691e2vFHJSHVm2kBVJt2Zf5UpXkOz4ZLcAsOzxUYvimrSDkQV1FSPoTOTbmp2W2fmX7E7JnKFDOVTFIcrPO23LOKkVTXObEcNNyAnS70xEJ1UrZZm4EIavn5u75jxSiRE5501Bncn8jnpo2m5jNwQBRxp1MZiAWrHMnKjh5EbIiLym2bNmpkq8ZyUlOTD3pQfMRE2pGVf/Z6PpREFHmmltFqVoxARxlkwPRzcEBGR30yePFk0uNm4cSOys7PRq1cvVK9eHampqfj2228RExODoUOH+rGnoUVaDjqbj6URBRxp5IbvuDGGgxsv8MYjKEZehil65EjtERwTz9cYLhxglicNufXb1a+S81R7NE+0scHlWpvplPFVTOL29nNExY9r6b2QU+0zFxVbKP7byKXQekTRUAlrpcexFMqPK/VZ4ZCqy6TMFikQ7eP2nKGRss6lfvxUt3qF/uN57rvoPbVZWr5uv8TUqVNdX69atQrVq1fHli1bUKFCBdfyrKws3H///YiKivJ9h8qJaD6WRhTwpJXS6nNwYwhjW0REFBA+/PBDPPDAA6KBDQBUrFgRDzzwAD788EM/9Sz0xEgqpvGxNKLAI6uUxmIChnBw40eunOriyIRW0MXwSxuVysoaTBD3JI+8NDO7agnmnkZHjM56myKpRWy6xK9CU/JvVI6psY8swV6nY4oVrc3cJxptuvdPFN1Sqy2u0ICpQxuMRunWHZCE4vS6qXTtXMv0fibN9k1hmTTS6+uoSllEbaQuXLgAm01ephgAbDYbLl68WMY9Cl0VIqWDGz6WRhRopDk3LANtDAc3REQUEJo0aYL33nsPhYWFouUFBQV499130bhxYz/1LPRIH0tj5IYosAiCgDOXJS/w5GNphjDnJhAUz0RrzcYajkqYyAGRvpRQtrvajLNa7oeRfmhNWavljWjsZioHxAjpDlrRF61ok8JCQzPhkkQHtRLIhiJ8Ro6lxMxLLY3s52Fekif5NF6h8jOhlHskyg/Ta88tv0ctOql075fwRySlrD366KOYPHky+vTpg1tuuQXx8fFITU3FV199hYsXL2LZsmX+7mLI4GNpRIEt9Uo+8u3if/j5WJoxHNwQEVFA6NmzJ9555x289tpr+PDDD+FwOGCxWNC6dWvMnj0bN954o7+7GDJiJI+lsaAAUWCR5ttEhFmRUCnST70JLhzc+JmZGWjD1c10ohZaqRBKs9PuuUBK0R7FtjRm8VWPbzBvRG2h4ZltrQiImaiFUrRJ43B6UTFjB1XYXWm5VsRJr32D+SO6L9bUi1x5Gn4xEjksDb1cISWK4R3lbRSrkGns537/lIfoTZcuXdClSxfk5uYiMzMTlStXRnQ0nzP3NpaCJgps0kppdWOjYbUafydYecbBDRERBZzo6GgOanwohqWgiQKatJgA33FjHAsK+JnRaIxaJTWtaIZeCoTmrLdKlEBptl4xh8BY09pMRh+UIiN6eUlemQnXiZRp5WzoNCljqHKXBs1oi+R7vWsny3HSyUMxFWXxtNKcNxj6AdG+lnr3ldlTUMrH8/VloNAWzZwbooAmLwPNyR6j+N8jERFROcNS0ESB7bSsDDQjN0ZxcONnOsW5RMuVZopNPYevNLtsMnSh9I4Qw/kcRhJTNNaZfReKkb55Ie1DvX8GIhdqn6taRC4sTKFppbwflRwQoxEQ1VU+SPpQi0oaOaxu3o/Cct1bzUjOjcOhWSHP0/tK9o4gmIzaEhnEUtBEgU2ac8NKacZxcENERFTOsBQ0UeAqLHLgnwzpO274WJpRLChQSt6uYGTwxfXquQ9alaSU3t/hSUk1hbZ0Z9AVEnN0owgq23uSf1GK1+6YPZRqzoZaQTEz52NXenJE6TNXOTFDkQ6IPy61/snaMhg5UVrt4a6697jqMpUD6H4WiklPBjkcpv+tcD+M+781zLeh0pJWS7uSV4j9yekosDuQby9Cgd2BIoeguK/VYkFkuBWRYTZEhlkRFe78GwAycgtlf3ILihARZhVtGxluRbitOOosOF9YKAiAQxDgEIAihwOFRQKKHAIKi5x9sTsEVIiwITYmAlWiw1ElJtz5d3Q4HIKAvAIHcguLkFtYhJwCO/IKi2AvEiDA2b7zOM5jWCyAzWKB1Wop/tt5Xrbi7y0WC6wWwGp1/u0QgPxC57XJL75G+YUOFDoEWABYLIAFzm0txQWtnOchwCE4zyMvvwDnz2fjf5nJiImKRJjNijCrBeE2K8JsFkSG2RBVfF2j3K6vpfj4DkFwXaciQUChXUBBkbMf+UUOFNidfwAgzGpxtW+zWhBmtSDPXoQreXZk5hYiM8+OzLxCZOY6/1OpFBWGipFhbn+HIzLcCnuRAHuRA3aHALvD4bqe7p9lyd9hVqvr2ucWFCGnoAg5hUXILywqvgbFn69DcJ1PhEI7EWFWCILz87YXiT//kvvPain+u/jziQyzoUKkDRUiwxATYUPFyDDERITBYgEK7A4UFl+ffLsDBUXO83D/bIqK+1XkuPp9yXp7kQCLxeK6h51/bIgIs8JmtSC3oAi5hXbn+RYUISMrF6fPZeOXy6cRFRHhuh8sFgssAMJsVz8Tq8WCMJvz76KS83U4kJZVAOmPHyM3xnFwQ0REVM7ERIr/+8/Ms2Pwsp/91Jty5vcr/u4BlQnvfc4VI8MQGxPutfZCHef/Sqm0URudglXyZV4MExl4NYmpWW/RPgZyDwxFexQaMXMJ9I6hFdFxOKAaqdCc4ffkPSkKlD4LrUJeilFEg9Ey0bl6kpulFEk0WHVMsR1PcleKL4ChPCvTpeVM7KdxYMXd3Y6j9O+Bl24nIhFp5IaIAlfduGhYLHzHjVEc3BAREZUz9eJiEBXOXwGIgkGf5jX83YWgwsfSAoEnVZnUdleKNKg0oJRTolfxy+y7WgzPNuuUzCpt9SlpFMYwvdwVEy8gUcuNUtvQ1LXTPrTuYa1Wt5VaeSsGOqX2nhstalXCTJFUmtPc38i5ms0rU1huKNfLg/vS4QDCwoxdYm/nBVJoiI6wYdadrfDKtiRcyi6A1QJEhFkRYbMiMtyGiOI8ECX2IgEFRQ7kF5bkn1y9wSJsVlSODkeV6DBXPkxMZBgKi7dz5awUOnMfLHDmTlgscOW5WCyAzWpFeHG+SLjNmdtgtQDZ+UWuXJ703ALkFcpv7uhwG6IjbIgOt7nyGVx5McVfC4Azx6Ikt6I4D6SoOK+lJCfE4XDmuKA4r6MkX6jk6/Dia+TKGyr+GoLgls/j/BuCAzk52YiKjoEAKwodjuKcImdeSUkeT15hEfLc8mfURNisrhwV1x+bM0fHXpw7Yi+6misTGWZFpahwVI525tRUjnL+bbEAWXl2XMm340peIbLy7cjKs6PA7nDl7TjzRK6eb36hA3kl/bUXIa+wCEUOAVHhNsRE2BATEYbo4q+jI2zFn59brkxxFMJ53s5zdv+7JCfF5paTZCu+T0pymQRXfpaAPHsRcvKLkF1gR3a+XZavUiLManHlypS0b7UU579Yr+Zc2dzW2awWCBBcOTsl925+YRHsDgHRETbEFN9zMRFhiAqzwJ6fgwoVKsJqs7nypAQIzl8Ziu85u3uOj0MoPter5xte/Pm2bxCHB7s31rwXSIyDGyIionJoSPu6uLNdHRQ5BITZPI/iCIJzsCMIKE6AL7vHZ/LtRcjMtcNmtSAmwlbmxzcjJycHSUlJaN68OWJi9JPDHQ7ndQXESfQlgzRSJggC8u0OZOU7iyWUDPoibFZYrb6/bmY/Z/I+Dm78THfS1kDJLt0Kawbf21Easj7oVOLydB/RfpIpaQPBENGGWlEqVyBJL9/HcHk7E+9q8fCzMP3xql07T96NU4roo1oeiunLIMnT8bQCm5lj6S33xrGUIi9mojGM2pAWS3G1ptK2ERnmnxyeyDAb4iuFZv6Q1WpBlDU0z82XLBYLosJtiArntSuvQvKB2+zsbLzyyivo1q0bWrVqhUGDBmHbtm3+7hYREREREflQSEZupk6dioMHD2L69Olo2LAhtm7dimnTpsHhcGDgwIH+7p6Iey6IWtqJ6RlotXeRKC3Xi3xoVdtym11Ximi4vytFo0n1g+uVWpMcQCunRek6aFWGcwVQVE5QGs0wkk9jKLXCTP6FQt80c2o8PKxafpHB4IVmv1TXG7wOJorsGVfW5cnUflBM7uJBM0RERCEn5AY333//PX7++WcsWLAAt99+OwCgc+fOOHfuHObOnYv+/fvDZmOokoiIiIgo1ITcPN9XX32FmJgY9OvXT7R8yJAhSElJwYEDB/zUM2XuM61q6RZmZshdDRk9roF3kUj76L5CdXe1vBa1biqFrQwn0egzmyqidn28lh9ioG+GdyxtKTkYvNQGE2dkVfp0+mc42qQQjTMUcTKrtNcVkuiRXkfUkmpMYtSGiIgoBCM3x44dQ5MmTRAWJj61xMRE1/r27dsr7puSkoLU1FTRsqKiIgBAQUGuD3rrLOdqiY5GRXsOEhOBunWBnLy84i9yALsdjRrlIDfX+ctLTtWqQOPGQEwMKoY596lTx22fvDzAbkfNms51sbFATkQE0KgREB8PhyMHjRpBsT21fYqK1Pcx3Qe3fUTnWop+K/YhIcHQPqXuQ/36nvc7wui1891nLroOJfvoXTvD/Vbug9F9ZPddtWqGr8M11/jwM5e0p7RP48bOptX6bbQPhYU5yMuTT3wIgrOsbSAo+bfRwcoFqkquTW6u8v8jJcvV1lNo4OdcPvBzNqfkOnnz/xCLIAgq1cCD06233oq6deti5cqVouUpKSno3r07pk2bhvHjxyvuu2TJEixdulS07MYbb8SUKVN81l8iolDQsGFDVKtWzd/dCEiXLl3CyZMn/d0NIqKA5c3/Q0IucgNo13/XWjd8+HD06tVLtMzhcKBixYqIj4+Hlc99lGt//fUXHn/8ccyfPx9NmjTxd3fIz3g/ODkcDuTn56NKlSr+7krAqlKlCho2bIjIyEjF/0d4L5UP/JzLB37O5vji/5CQG9zExsYiPT1dtjwjIwMANC9eQkICEhISfNU1CnJWqxUnT56E1Wrli7mI94ObihUr+rsLAS0sLExzRpL3UvnAz7l84Odsnrf/Dwm5UETTpk3x119/wW63i5YfPXoUAHDttdf6o1tERERERORjITe46dOnD3JycvDll1+Klm/atAkJCQlo06aNn3pGRERERES+FHKPpd10003o2rUrZs6ciaysLNSvXx/btm3Djz/+iHnz5vEdN0REREREISrkBjeAs+rZa6+9hsWLFyM9PR2NGzfGwoULMWDAAH93jYJYfHw8pkyZgvj4eH93hQIA7wfyFt5L5QM/5/KBn7P/hVwpaCIiIiIiKp9CLueGiIiIiIjKJw5uiIiIiIgoJHBwQ0REREREIYGDGyIiIiIiCgkc3BAB+O9//4vExES0a9dOtu6PP/7Afffdh3bt2qFDhw6YMmUKkpOTFdtZu3Yt+vXrh5YtW6JXr15YunQpCgsLfd19KqXDhw9j0qRJ6NatG9q0aYN+/fph6dKlyM3NFW3He4G8KTs7G6+88gq6deuGVq1aYdCgQdi2bZu/u0Ue+vXXX/HUU0+hX79+aNu2Lbp3746JEyfi0KFDsm3N/FtCgc9bv0OQd7BaGpV7Fy5cwIABAxAdHY2srCz89ttvrnV//fUXhg0bhubNm+Ohhx5Cfn4+Fi9ejIyMDHz66aeoWrWqa9vly5fj9ddfx0MPPYSuXbvi4MGDWLRoEe6880689NJL/jg1MuD48eMYMmQIGjVqhPHjxyMuLg7/+9//sHz5ctx0001Yvnw5AN4L5H1jx47FwYMHMX36dDRs2BBbt27Ff//7X8yfPx8DBw70d/fIpIcffhjp6eno168frrnmGqSlpeHdd9/FoUOH8M4776BLly4AzP1bQoHPW79DkBcJROXc+PHjhfHjxwtPPvmk0LZtW9G6hx9+WOjUqZNw5coV17IzZ84ILVq0EObOnetalpaWJrRq1Up47rnnRPsvX75cSExMFI4dO+bbkyCPLVy4UGjatKlw6tQp0fLnnntOaNq0qZCeni4IAu8F8q7vvvtOaNq0qbBlyxbR8vvvv1/o1q2bYLfb/dQz8tTFixdly7KysoQbb7xRGDNmjGuZ0X9LKDh443cI8i4+lkbl2qeffoo9e/Zg5syZsnV2ux3fffcd+vbti4oVK7qW16lTB506dcLXX3/tWvbjjz8iPz8fQ4YMEbUxZMgQCIIg2pYCS3h4OACIPmMAqFSpEqxWK8LDw3kvkNd99dVXiImJQb9+/UTLhwwZgpSUFBw4cMBPPSNPVatWTbasQoUKaNKkCf755x8A5v5focDnrd8hyLs4uKFy69KlS5g1axamT5+OmjVrytafPn0aeXl5SExMlK1r2rQpTp06hfz8fADAsWPHXMvdJSQkIC4uzrWeAs/gwYNRuXJlzJw5E8nJycjKysK3336LdevW4Z577kFMTAzvBfK6Y8eOoUmTJggLCxMtL7nHeJ+EhitXruDw4cO49tprAZj7f4UCmzd/hyDv4uCGyq0XXngBjRo1wsiRIxXXp6enAwBiY2Nl62JjYyEIAjIyMlzbRkREICYmRrZtlSpVXG1R4Klbty4+/vhjHDt2DH369MH111+PCRMmYPDgwXjmmWcA8F4g70tPT0eVKlVky0uW8T4JDS+88AJyc3MxYcIEAOb+LaHA5s3fIci7wvQ3IQo9X3zxBb755hts3rwZFotFc1ut9e7r9NqhwHTmzBlMnDgR1apVw+LFi1G1alUcOHAAy5cvR05ODmbNmuXalvcCeZPR+4mC06JFi7BlyxY899xzaNmypWgdP/vg5ovfIch7OLihcic7OxsvvvgiRo0ahYSEBGRmZgKAq0xvZmYmwsLCXLMtly9flrWRnp4Oi8WCypUrA3DOwuTn5yM3NxfR0dGibTMyMmT/sVHgWLBgAbKysrB582ZXtKVjx46Ii4vD008/jcGDB6N69eoAeC+Q98TGxipGZ0pmcpWiOhQ8li5diuXLl+Oxxx7Dvffe61pu5v8VCky++B2CvIuDGyp3Ll++jIsXL2LVqlVYtWqVbH3Hjh3Ru3dvLF68GFFRUTh69Khsm6NHj6JBgwaIjIwEcDW/4ujRo2jTpo1ru9TUVFy+fNn1vDUFnqSkJDRp0kT2GFmrVq0AOHMf2rdvz3uBvKpp06bYunUr7Ha7KO+m5B7jfRK8li5diiVLlmDq1Kmux9FK1K9f3/C/JRSYfPE7BHkXc26o3ImPj8eaNWtkf7p164bIyEisWbMGjz76KMLCwnDzzTfjq6++QlZWlmv/c+fOYffu3bjllltcy7p3747IyEhs3LhRdKxNmzbBYrGgT58+ZXZ+ZE5CQgKOHz+O7Oxs0fL9+/cDAGrUqMF7gbyuT58+yMnJwZdffilavmnTJiQkJIgGxhQ8li1bhiVLlmDixImYMmWKbL2Zf0soMPnidwjyLr7Ek6jYjBkz8MUXX8hewHXXXXehRYsWePDBB1FQUIDFixcjPT1d9cWN48ePF724cfDgwXxxYwDbuXMnJk+ejDZt2mDMmDGIi4vDgQMH8NZbb6F27drYtGkTIiIieC+Q140dOxaHDh3C448/jvr162Pbtm345JNPMG/ePNxxxx3+7h6ZtGrVKrz66qvo3r274sCmbdu2AMz9v0LBo7S/Q5D3cHBDVEzpHyYAOHToEObPn4/9+/fDZrOhc+fOePLJJ1G/fn1ZG2vWrMEHH3yAs2fPIj4+HkOGDMGECRNc71KhwLRr1y68/fbb+PPPP3HlyhXUrFkTvXr1wkMPPYS4uDjXdrwXyJuys7Px2muvYceOHUhPT0fjxo0xfvx4DBgwwN9dIw+MGjUKe/bsUV3/559/ur42828JBQdv/A5B3sHBDRERERERhQTm3BARERERUUjg4IaIiIiIiEICBzdERERERBQSOLghIiIiIqKQwMENERERERGFBA5uiIiIiIgoJHBwQ0REREREIYGDGyIiIiIiCgkc3BDp2LdvH5YsWYLMzEzZulGjRmHUqFF+6JW2zZs3o3PnzsjKyvJJ+0888QQmTZrkk7aJiPypPP2b36tXL4wfP95HvdK2ceNGJCYm4uDBg6Vu65577sErr7zihV5RKODghkjHb7/9hqVLlyr+R/f888/j+eef90Ov1OXm5mLhwoV48MEHUbFiRZ8cY+rUqfj+++/x66+/+qR9IiJ/4b/5weeRRx7BRx99hL///tvfXaEAwMENUSlcc801uOaaa/zdDZFNmzYhPT0dw4YN89kx6tevj+7du+Ptt9/22TGIiAJNef03P9DdcMMNaNSoEd59911/d4UCAAc3RBqWLFmCuXPnAgB69+6NxMREJCYmYvfu3QDkjyicOXMGiYmJeOedd7BixQr06tULrVu3xqhRo3DixAkUFhZi/vz56NatG66//npMnjwZly5dkh13+/btGD58ONq2bYt27dph3LhxOHz4sKE+f/TRR7j55ptRuXJl0fLExES8+OKL2Lx5M2677Ta0adMGd9xxB7799lvRdmlpaXjuuedw0003oWXLlujcuTNGjBiBX375RbTdHXfcgV9++QWnT5821C8iokAXSv/mOxwOrF27FoMGDULr1q3RoUMH3H333di5c6esjR9++AF33nknWrdujX79+mH9+vWy65KYmCjbr+TRsjNnzriWlTzqptemkpSUFAwZMgR9+/bFyZMnAQDJycl47LHH0K1bN7Rs2RI33ngjxowZg6SkJNG+d9xxB7Zu3eqzx7EpeIT5uwNEgWzYsGHIyMjA2rVrsXTpUsTHxwOA7szdhx9+iKZNm+I///kPMjMz8eqrr2LChAlo06YNwsLCMGvWLJw7dw6vvvoqnnnmGbz55puufd98800sWrQIQ4YMwcSJE1FYWIiVK1finnvuwX//+1/NY58/fx5Hjx7Fv/71L8X13333HQ4ePIiHH34YMTExeOeddzBlyhTs2LED9erVA+DMpzl8+DAee+wxNGzYEJmZmTh8+DDS09NFbXXq1AmCIOD7778PyGfQiYjMCqV/82fMmIHPPvsMd911Fx5++GGEh4fj/9u7t5Am3zgO4N/91U1r6jxUntJ0MVoeukkW5onKLEhG4boaQpQzguxAYrWuCsTISNPcRZmHi6yszEK8sS4qQiJWIoh2kVA4tbR1kEqZ638Re2lNs2mr8fr9gBe+e97f82wXz8P33fs+6+3txeDgoFO7vr4+nD59GoWFhQgPD0dLSwuMRiPi4uKQmprqzsc3r5ovXryAwWBAREQErl69itDQUABAYWEh7HY7SkpKEBUVBavVimfPnrncNqjRaFBRUYEnT55gw4YNcxo3iQPDDdEvREREIDIyEgCgVqsRExPzW+cFBgaitrYW//33/ctRq9WKsrIyJCQkwGQyCe1evnyJxsZGjI+PQy6XY2hoCNXV1dDr9Thx4oTQLi0tDbm5uaipqUFlZeWM/ZrNZgBAYmLitK9PTEygvr5euC87MTERGRkZ6OjogMFgEGrodDrs3LlTOG/Tpk0utcLCwrBs2TKYzWaGGyISBbHM+U+fPkVbWxv27t2LQ4cOCcczMzNdalitVjQ3NyMqKgoAkJqaiq6uLty9e3fO4cbdmo8fP8b+/fuxfv16nDlzBjKZTKgzMDCA48ePQ6vVCu03b97sUkOtVkMikcBsNjPcLHAMN0QekJWVJSxyAKBUKgEA2dnZTu0cxy0WC1QqFR49egSbzQatVgubzSa0k8lkSE1NFW6NmMmbN28AQLji9TONRuP0wGl4eDjCwsKcruSlpKSgtbUVCoUCaWlpSExMhJ+f37T1wsLCMDIy8ssxERGJnbfN+Q8ePADwfRex2ajVaiGEOPpesWIFLBbLrOf+iZq3b9/GtWvXoNfrUVpaColEIrymUCgQGxuLuro62O12aDQarFq1yumzdvDz80NQUBDXJGK4IfKE4OBgp/8d4WCm4xMTEwCA0dFRAEB+fv60daeb0H/kqOO46vUzhULhckwqlQrnAcC5c+dgMplw48YNVFVVYdGiRcjJyUFJSYlwi4aDTCbD169ffzkmIiKx87Y5/927d/Dx8XGZs6fzO+uCu9yp2d7eDplMBp1O5xRsAEAikaChoQEXLlzApUuXUF5eDoVCgby8PBw8eNBld7j5jpvEgeGGyIuEhIQAAM6fP+901cvd8z98+IClS5fOaQyhoaEwGo0wGo2wWCy4f/8+zp49i7GxMdTV1Tm1ff/+PaKjo+fUDxHRQuepOT80NBRTU1N4+/btnNeCHznC0+TkJKRSqXDcarXOu3ZFRQWqqqqg1+tx+fJlqNVqp9ejo6NRVlYGABgYGEBHRwdqamowOTmJkydPOrX9+PHjtMGKFhbulkY0C8dE/jeuBqWnp8PX1xevXr1CcnLytH+/kpCQAAB/bAezqKgo6PV6pKWluezcY7PZMDw87HXbohIRzYcY5nzHszXNzc1/ZJyOi1h9fX1Ox3/ebXMugoODUV9fD6VSiYKCAjx//nzGtvHx8di3bx9UKpXLmjQyMoKJiQmuScRvbohmo1KpAACNjY3Yvn07fH19ER8f75EfS4uJiUFxcTEqKyvx+vVrZGZmIigoCKOjo+jp6UFAQACKi4tnPD8lJQX+/v7o7u7Gxo0b3e7/06dPKCgowLZt25CQkIDFixejp6cHDx8+RE5OjlPb/v5+fPnyBRqNxu1+iIi8lRjm/LVr10Kr1cJkMmFsbAzZ2dmQSqXo7e1FQECA25vAZGVlQaFQwGg04sCBA/Dx8UFrayuGhobm/N5/JJfLhd07d+3aBZPJhHXr1qGvrw+nTp3Cli1bEBcXBz8/P3R1daG/v1/YBMehu7sbALgmEcMN0Ww0Gg2KiorQ2tqKlpYW2O12NDU1eWwCLSoqglKpRFNTE9rb2zE5OYklS5YgKSlpxi2eHaRSKXJzc3Hv3j0cPnzY7b5lMhlSUlLQ1taGwcFB2Gw2REZGorCwEHv27HFq29nZiZCQEKSnp7vdDxGRtxLLnF9eXo7Vq1fj5s2buHXrFvz9/bFy5UoUFRW5PUa5XI6LFy+irKwMJSUlCAwMhE6nQ0ZGhtMub/Ph7++P2tpaHDlyBAaDAdXV1UhKSkJsbCyuXLmC4eFhAMDy5ctRWlrqEtA6OzuhUqmm/T0eWlgk3759+/avB0FEf05PTw/y8/Nx/fp1rFmzxiN9TE1NIScnB3l5eU7bjBIR0d/1N+Z8bzc+Po6MjAwcO3bM6WcMaGHiMzdEIpOcnIytW7eitrbWY33cuXMHnz9/xu7duz3WBxERze5vzPnerqGhAZGRkdixY8e/Hgp5AYYbIhE6evQokpOTMT4+7pH6drsdFRUVCAoK8kh9IiL6fZ6e872dXC5HeXk5fH35tAXxtjQiIiIiIhIJfnNDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESiwHBDRERERESi8D9E3UJ1S39WZQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### using the DatasetAnalysis context helps us to load data easily, and automatically save plots in the right folder.\n", + "\n", + "with DatasetAnalysis(data_loc) as analysis:\n", + " i_data = analysis.get_data('I', avg_over=None)\n", + " q_data = analysis.get_data('Q', avg_over=None)\n", + " raw_data = analysis.get_data('raw_signal', avg_over=None)\n", + " \n", + " fig = analysis.make_figure('a plot', figsize=(4,2))\n", + " \n", + " # first subfig: plot the raw voltage as a colormap. We set the limits such that 0 is the middle.\n", + " ax = fig.add_subplot(121)\n", + " im = ppcolormesh(ax,\n", + " raw_data.data_vals('raw_signal_time_points'),\n", + " raw_data.data_vals('repetition'),\n", + " raw_data.data_vals('raw_signal'),\n", + " make_grid=False,\n", + " cmap='bwr', \n", + " vmin=-np.abs(raw_data.data_vals('raw_signal')).max(),\n", + " vmax=np.abs(raw_data.data_vals('raw_signal')).max()\n", + " )\n", + " format_ax(ax, xlabel='time (ns)', ylabel='repetition')\n", + " cb = fig.colorbar(im, ax=ax, location='top')\n", + " cb.set_label('ADC signal (a.u.)')\n", + " \n", + " # second subfig: plot one example trace of demodulated I and Q.\n", + " ax = fig.add_subplot(122)\n", + " ax.plot(i_data.data_vals('I_time_points')[:,0], i_data.data_vals('I')[:,0], '-',\n", + " label='I')\n", + " ax.plot(q_data.data_vals('Q_time_points')[:,0], q_data.data_vals('Q')[:,0], '-',\n", + " label='Q')\n", + " format_ax(ax, xlabel='time (chunks)', ylabel='demod. signal (a.u.)')\n", + " ax.legend(loc='best')\n", + " \n", + " # this command saves the figures associated with the analysis in the data folder.\n", + " analysis.save()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79e604d3-759b-4fe2-83bb-31990a667c2e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:qcodes]", + "language": "python", + "name": "conda-env-qcodes-py" + }, + "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.9.15" + }, + "toc-autonumbering": true + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/doc/examples/opx_examples_and_templates/parameter_manager-parameter_manager.json b/doc/examples/opx_examples_and_templates/parameter_manager-parameter_manager.json new file mode 100755 index 0000000..d0fac6f --- /dev/null +++ b/doc/examples/opx_examples_and_templates/parameter_manager-parameter_manager.json @@ -0,0 +1,98 @@ +{ + "parameter_manager.mixers.qubit.imbalance": { + "unit": "", + "value": [ + 0.017258832411374866, + 0.0431687466800213 + ] + }, + "parameter_manager.mixers.qubit.offsets": { + "unit": "", + "value": [ + -0.0043203430482981284, + 0.002425398575564943 + ] + }, + "parameter_manager.mixers.readout.imbalance": { + "unit": "", + "value": [ + -0.10679336142539977, + 0.0759567975997925 + ] + }, + "parameter_manager.mixers.readout.offsets": { + "unit": "", + "value": [ + -0.037305109893088224, + -0.02914601831580512 + ] + }, + "parameter_manager.qubit.IF": { + "unit": "Hz", + "value": 173950814.28219295 + }, + "parameter_manager.qubit.LO": { + "unit": "Hz", + "value": 4795250000.0 + }, + "parameter_manager.qubit.drive.constant_drive.amp": { + "unit": "", + "value": 0.05 + }, + "parameter_manager.qubit.drive.constant_drive.edge_len": { + "unit": "ns", + "value": 1000 + }, + "parameter_manager.qubit.drive.constant_drive.len": { + "unit": "ns", + "value": 10000 + }, + "parameter_manager.qubit.drive.long.amp": { + "unit": "", + "value": 0.01 + }, + "parameter_manager.qubit.drive.long.length": { + "unit": "ns", + "value": 50000 + }, + "parameter_manager.qubit.drive.pipulse.amp": { + "unit": "", + "value": 0.026676964555142905 + }, + "parameter_manager.qubit.drive.pipulse.nsigmas": { + "unit": "", + "value": 6 + }, + "parameter_manager.qubit.drive.pipulse.sigma": { + "unit": "ns", + "value": 50 + }, + "parameter_manager.readout.IF": { + "unit": "Hz", + "value": 50000000.0 + }, + "parameter_manager.readout.LO": { + "unit": "Hz", + "value": 7219000000.0 + }, + "parameter_manager.readout.long.amp": { + "unit": "", + "value": 0.07 + }, + "parameter_manager.readout.long.len": { + "unit": "ns", + "value": 50000 + }, + "parameter_manager.readout.short.amp": { + "unit": "", + "value": 0.03 + }, + "parameter_manager.readout.short.buffer": { + "unit": "ns", + "value": 0 + }, + "parameter_manager.readout.short.len": { + "unit": "ns", + "value": 2000 + } +} \ No newline at end of file diff --git a/doc/examples/opx_examples_and_templates/parameter_manager-simple_demo_params.json b/doc/examples/opx_examples_and_templates/parameter_manager-simple_demo_params.json new file mode 100644 index 0000000..9f8e639 --- /dev/null +++ b/doc/examples/opx_examples_and_templates/parameter_manager-simple_demo_params.json @@ -0,0 +1,18 @@ +{ + "simple_demo_params.readout.IF": { + "unit": "Hz", + "value": 50000000.0 + }, + "simple_demo_params.readout.short.amp": { + "unit": "", + "value": 0.25 + }, + "simple_demo_params.readout.short.buffer": { + "unit": "ns", + "value": 100 + }, + "simple_demo_params.readout.short.len": { + "unit": "ns", + "value": 1000 + } +} \ No newline at end of file diff --git a/doc/examples/opx_examples_and_templates/qmcfg.py b/doc/examples/opx_examples_and_templates/qmcfg.py new file mode 100755 index 0000000..04d24bf --- /dev/null +++ b/doc/examples/opx_examples_and_templates/qmcfg.py @@ -0,0 +1,214 @@ +"""Example config for testing the OPX. + +Author: Wolfgang Pfaff +""" +import numpy as np +import logging + +from labcore.opx.mixer import MixerCalibration +from labcore.opx.config import QMConfig as QMConfig_ + +logger = logging.getLogger(__name__) + + +class QMConfig(QMConfig_): + + def config_(self): + params = self.params # if we make use of the parameter manager... + + cfg = { + 'version': 1, + + # The hardware + 'controllers': { + + 'con2': { + 'type': 'opx1', + 'analog_outputs': { + 1: {'offset': params.mixers.readout.offsets()[0]}, # I + 2: {'offset': params.mixers.readout.offsets()[1]}, # Q + 3: {'offset': params.mixers.qubit.offsets()[0]}, # I + 4: {'offset': params.mixers.qubit.offsets()[1]}, # Q + + }, + 'digital_outputs': { + 1: {}, + }, + 'analog_inputs': { + 1: {'offset': 0.0}, + 2: {'offset': 0.0} + }, + }, + }, + + # The logical elements + 'elements': { + + 'readout': { + 'mixInputs': { + 'I': ('con2', 1), + 'Q': ('con2', 2), + 'lo_frequency': params.readout.LO(), + 'mixer': 'readout_IQ_mixer', + }, + + 'digitalInputs': { + 'readout_trigger': { + 'port': ('con2', 1), + 'delay': 144, + 'buffer': 0, + }, + }, + + 'intermediate_frequency': params.readout.IF(), + + 'operations': { + 'readout_short': 'readout_short_pulse', + 'readout_long': 'readout_long_pulse', + 'constant': 'constant_pulse', + }, + + 'outputs': { + 'out1': ('con2', 1), + }, + + 'time_of_flight': 188 + 28, + 'smearing': 0, + }, + + 'qubit': { + 'mixInputs': { + 'I': ('con2', 3), + 'Q': ('con2', 4), + 'lo_frequency': int(params.qubit.LO()), + 'mixer': 'qubit_IQ_mixer', + }, + 'intermediate_frequency': params.qubit.IF(), + + 'operations': { + 'long_drive': 'long_drive_pulse', + 'pi_pulse': 'pi_pulse', + 'constant': 'constant_pulse', + }, + }, + }, + + # The pulses + 'pulses': { + + 'readout_short_pulse': { + 'operation': 'measurement', + 'length': params.readout.short.len(), + 'waveforms': { + 'I': 'short_readout_wf', + 'Q': 'zero_wf', + }, + # Integration weights added automatically later. + 'digital_marker': 'ON', + }, + + 'readout_long_pulse': { + 'operation': 'measurement', + 'length': params.readout.long.len(), + 'waveforms': { + 'I': 'long_readout_wf', + 'Q': 'zero_wf', + }, + # Integration weights added automatically later. + 'digital_marker': 'ON', + }, + + 'constant_pulse': { + 'operation': 'control', + 'length': 1000, + 'waveforms': { + 'I': 'const_wf', + 'Q': 'zero_wf', + }, + }, + + 'long_drive_pulse': { + 'operation': 'control', + 'length': params.qubit.drive.long.length(), + 'waveforms':{ + 'I': 'long_qubit_drive_wf', + 'Q': 'zero_wf', + }, + 'digital_marker': 'ON', + }, + + 'pi_pulse':{ + 'operation': 'control', + 'length': params.qubit.drive.pipulse.sigma() * params.qubit.drive.pipulse.nsigmas(), + 'waveforms': { + 'I': 'qubit_pi_pulse_wf', + 'Q': 'zero_wf', + }, + }, + + }, + + # the waveforms + 'waveforms': { + 'const_wf': { + 'type': 'constant', + 'sample': 0.25, + }, + 'long_readout_wf': { + 'type': 'constant', + 'sample': params.readout.long.amp(), + }, + 'zero_wf': { + 'type': 'constant', + 'sample': 0.0, + }, + 'short_readout_wf': { + 'type': 'arbitrary', + 'samples': [0.0] * int(params.readout.short.buffer()) + \ + [params.readout.short.amp()] * \ + int(params.readout.short.len() - 2 * params.readout.short.buffer()) + \ + [0.0] * int(params.readout.short.buffer()), + }, + 'long_qubit_drive_wf':{ + 'type': 'constant', + 'sample': params.qubit.drive.long.amp(), + }, + 'qubit_pi_pulse_wf': { + 'type': 'arbitrary', + 'samples': params.qubit.drive.pipulse.amp() * \ + (np.exp(-(np.linspace(1, + params.qubit.drive.pipulse.sigma() * params.qubit.drive.pipulse.nsigmas(), + params.qubit.drive.pipulse.sigma() * params.qubit.drive.pipulse.nsigmas()) - \ + params.qubit.drive.pipulse.sigma() * params.qubit.drive.pipulse.nsigmas()//2)**2 / \ + (2*params.qubit.drive.pipulse.sigma()**2))) + }, + }, + + 'digital_waveforms': { + + 'ON': { + 'samples': [(1, 0)] + }, + + }, + + 'mixers': { + 'readout_IQ_mixer': [ + { + 'intermediate_frequency': int(params.readout.IF()), + 'lo_frequency': int(params.readout.LO()), + 'correction': MixerCalibration.IQ_imbalance_correction( + *params.mixers.readout.imbalance()) + }, + ], + 'qubit_IQ_mixer': [ + { + 'intermediate_frequency': int(params.qubit.IF()), + 'lo_frequency': int(params.qubit.LO()), + 'correction': MixerCalibration.IQ_imbalance_correction( + *params.mixers.qubit.imbalance()) + }, + ], + }, + } + return cfg diff --git a/doc/examples/opx_examples_and_templates/qmcfg_simple_demo.py b/doc/examples/opx_examples_and_templates/qmcfg_simple_demo.py new file mode 100755 index 0000000..6cad159 --- /dev/null +++ b/doc/examples/opx_examples_and_templates/qmcfg_simple_demo.py @@ -0,0 +1,106 @@ +""" +A very basic OPX config +""" + +from labcore.opx.config import QMConfig as QMConfig_ + + +class QMConfig(QMConfig_): + + def config_(self): + + params = self.params + + cfg = { + 'version': 1, + + # The hardware + 'controllers': { + + # edit this part so the hardware connections match your setup + 'con2': { + 'type': 'opx1', + 'analog_outputs': { + 5: {'offset': 0.0}, + }, + 'digital_outputs': { + 1: {}, + }, + 'analog_inputs': { + 2: {'offset': 0.0}, + }, + }, + }, + + # The logical elements + 'elements': { + + 'readout': { + 'singleInput': { + 'port': ('con2', 5), + }, + 'digitalInputs': { + 'readout_trigger': { + 'port': ('con2', 1), + 'delay': 144, + 'buffer': 0, + }, + }, + + 'intermediate_frequency': params.readout.IF(), + + 'operations': { + 'readout_short': 'readout_short_pulse', + }, + + 'outputs': { + 'out1': ('con2', 2), + }, + + 'time_of_flight': 188+28, + 'smearing': 0, + }, + }, + + # The pulses + 'pulses': { + + 'readout_short_pulse': { + 'operation': 'measurement', + 'length': params.readout.short.len(), + 'waveforms': { + 'single': 'box_readout_wf' + }, + 'digital_marker': 'ON', + }, + + }, + + # the waveforms + 'waveforms': { + 'const_wf': { + 'type': 'constant', + 'sample': 0.1, + }, + 'zero_wf': { + 'type': 'constant', + 'sample': 0.0, + }, + 'box_readout_wf': { + 'type': 'arbitrary', + 'samples': [0.0] * params.readout.short.buffer() \ + + [params.readout.short.amp()] * \ + (params.readout.short.len()-2*params.readout.short.buffer()) \ + + [0.0] * params.readout.short.buffer(), + }, + }, + + 'digital_waveforms': { + + 'ON': { + 'samples': [(1, 0)] + }, + + }, + } + return cfg diff --git a/labcore/analysis/__init__.py b/labcore/analysis/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/labcore/analysis/common_fits.py b/labcore/analysis/common_fits.py new file mode 100644 index 0000000..b55466b --- /dev/null +++ b/labcore/analysis/common_fits.py @@ -0,0 +1,114 @@ +import numpy as np + +from plottr.analyzer.fitters.fitter_base import Fit + + +class ExponentialDecay(Fit): + @staticmethod + def model(coordinates, A, of, tau) -> np.ndarray: + """$A * \exp(-x/\tau) + of$""" + return A * np.exp(-coordinates/tau) + of + + @staticmethod + def guess(coordinates, data): + + # offset guess: The mean of the last 10 percent of the data + of = np.mean(data[-data.size//10:]) + + # amplitude guess: difference between max and min. + A = np.abs(np.max(data) - np.min(data)) + if data[0] < data[-1]: + A *= -1 + + # tau guess: pick the point where we reach roughly 1/e + one_over_e_val = of + A/3. + one_over_e_idx = np.argmin(np.abs(data-one_over_e_val)) + tau = coordinates[one_over_e_idx] + + return dict(A=A, of=of, tau=tau) + + +class ExponentiallyDecayingSine(Fit): + @staticmethod + def model(coordinates, A, of, f, phi, tau) -> np.ndarray: + """$A \sin(2*\pi*(f*x + \phi/360)) \exp(-x/\tau) + of$""" + return A * np.sin(2 * np.pi * (f * coordinates + phi/360)) * np.exp(-coordinates/tau) + of + + @staticmethod + def guess(coordinates, data): + """This guess will ignore the first value because since it usually is not relaiable.""" + + # offset guess: The mean of the data + of = np.mean(data) + + # amplitude guess: difference between max and min. + A = np.abs(np.max(data) - np.min(data)) / 2. + if data[0] < data[-1]: + A *= -1 + + # f guess: Maximum of the absolute value of the fourier transform. + fft_data = np.fft.rfft(data)[1:] + fft_coordinates = np.fft.rfftfreq(data.size, coordinates[1] - coordinates[0])[1:] + + # note to confirm, could there be multiple peaks? I am always taking the first one here. + f_max_index = np.argmax(fft_data) + f = fft_coordinates[f_max_index] + + # phi guess + phi = -np.angle(fft_data[f_max_index], deg=True) + + # tau guess: pick the point where we reach roughly 1/e + one_over_e_val = of + A/3. + one_over_e_idx = np.argmin(np.abs(data-one_over_e_val)) + tau = coordinates[one_over_e_idx] + + return dict(A=A, of=of, phi=phi, f=f, tau=tau) + +class Cosine(Fit): + @staticmethod + def model(coordinates, A, of, f, phi) -> np.ndarray: + """$A \sin(2*\pi*(f*x + \phi/360)) + of$""" + return A * np.cos(2 * np.pi * (f * coordinates + phi/360.)) + of + + @staticmethod + def guess(coordinates, data): + """This guess will ignore the first value because since it usually is not relaiable.""" + + # offset guess: The mean of the data + of = np.mean(data) + + # amplitude guess: difference between max and min. + A = np.abs(np.max(data) - np.min(data)) / 2. + + # f guess: Maximum of the absolute value of the fourier transform. + fft_data = np.fft.rfft(data)[1:] + fft_coordinates = np.fft.rfftfreq(data.size, coordinates[1] - coordinates[0])[1:] + + # note to confirm, could there be multiple peaks? I am always taking the first one here. + f_max_index = np.argmax(np.abs(fft_data)) + f = fft_coordinates[f_max_index] + + # phi guess + phi = -np.angle(fft_data[f_max_index], deg=True) + + guess = dict(A=A, of=of, phi=phi, f=f) + + return guess + + +class Gaussian(Fit): + @staticmethod + def model(coordinates, x0, sigma, A, of): + """$A * np.exp(-(x-x_0)^2/(2\sigma^2)) + of""" + return A * np.exp(-(coordinates - x0) ** 2 / (2 * sigma ** 2)) + of + + @staticmethod + def guess(coordinates, data): + # TODO: very crude at the moment, not likely to work well with not-so-nice data. + of = np.mean(data) + dev = data - of + i_max = np.argmax(np.abs(dev)) + x0 = coordinates[i_max] + A = data[i_max] - of + sigma = np.abs((coordinates[-1] - coordinates[0])) / 20 + return dict(x0=x0, sigma=sigma, A=A, of=of) diff --git a/labcore/analysis/data.py b/labcore/analysis/data.py new file mode 100644 index 0000000..eea5182 --- /dev/null +++ b/labcore/analysis/data.py @@ -0,0 +1,151 @@ +"""Tools for more convenient data handling.""" + + +from typing import Union, List, Optional, Type +from types import TracebackType +from pathlib import Path +from datetime import datetime +import json + +from matplotlib.figure import Figure +from matplotlib import pyplot as plt + +from plottr.data.datadict import DataDictBase, datadict_to_meshgrid, MeshgridDataDict +from plottr.data.datadict_storage import datadict_from_hdf5 + + +def data_info(folder: str, fn: str = 'data.ddh5', do_print: bool = True): + fn = Path(folder, fn) + dataset = datadict_from_hdf5(fn) + if do_print: + print(dataset) + else: + return str(dataset) + + +def get_data(folder: Union[str, Path], data_name: Optional[Union[str, List[str]]] = None, fn: str = 'data.ddh5', + mk_grid: bool = True, avg_over: Optional[str] = 'repetition') -> DataDictBase: + + """Get data from disk. + + Parameters + ---------- + folder + the folder containing the data file (a ddh5 file) + data_name + which dependent(s) to extract from the data. + if ``None``, return all data. + fn + the file name + mk_grid + if True, try to automatically place data on grid. + avg_over + if not ``None``, average over this axis if it exists. + + Returns + ------- + the resulting dataset + + """ + fn = Path(folder, fn) + dataset = datadict_from_hdf5(fn) + dataset.add_meta('dataset.folder', str(Path(folder))) + dataset.add_meta('dataset.filepath', str(fn)) + + if data_name is None: + data_name = dataset.dependents() + elif isinstance(data_name, str): + data_name = [data_name] + dataset = dataset.extract(data_name) + + if mk_grid: + dataset = datadict_to_meshgrid(dataset) + + if avg_over is not None and avg_over in dataset.axes() and isinstance(dataset, MeshgridDataDict): + if not dataset.axes_are_compatible(): + raise RuntimeError('When averaging, axes must be compatible.') + + avg_ax_id = dataset.axes(data_name[0]).index(avg_over) + for dn, _ in dataset.data_items(): + dataset[dn]['values'] = dataset[dn]['values'].mean(axis=avg_ax_id) + if avg_over in dataset[dn]['axes']: + dataset[dn]['axes'].pop(avg_ax_id) + del dataset[avg_over] + + dataset.validate() + return dataset + + +class DatasetAnalysis: + + def __init__(self, folder): + self.figure_save_format = ['png', 'pdf'] + self.folder = folder + if not isinstance(self.folder, Path): + self.folder = Path(self.folder) + self.timestamp = str(datetime.now().replace(microsecond=0).isoformat().replace(':', '')) + + self.figures = {} + + def __enter__(self): + return self + + def __exit__(self, exc_type: Optional[Type[BaseException]], + exc_value: Optional[BaseException], + traceback: Optional[TracebackType]) -> None: + pass + + def save(self): + for n, f in self.figures.items(): + self.save_figure(f, n) + + def get_data(self, data_name, *arg, **kw): + return get_data(self.folder, data_name, *arg, **kw) + + def load_saved_parameter(self, parameter_name, + parameter_manager_name='parameter_manager', + file_name='parameters.json'): + fn = Path(self.folder) / file_name + with open(fn, 'r') as f: + data = json.load(f) + + parameter_path = f"{parameter_manager_name}.{parameter_name}" + if parameter_path not in data: + raise ValueError('this parameter was not found in the saved meta data.') + + return data[parameter_path]['value'] + + def make_figure(self, name, *arg, **kwargs): + if name in self.figures: + raise ValueError('figure with that name already exists in this analysis') + fig = plt.figure(*arg, **kwargs) + self.figures[name] = fig + return fig + + def save_figure(self, fig: Figure, name: str): + """save a figure in a standard way to the dataset directory. + + Parameters + ---------- + fig + the figure instance + name + name to give the figure + fmt + file format (defaults to png) + + Returns + ------- + ``None`` + + """ + fmts = self.figure_save_format + if not isinstance(fmts, list): + fmts = [fmts] + + fig.suptitle(f"{self.folder.name}: {name}", fontsize='small') + + for f in fmts: + fn = Path(self.folder, f"{self.timestamp}_{name}.{f}") + fig.savefig(fn) + diff --git a/labcore/analysis/fitting.py b/labcore/analysis/fitting.py new file mode 100644 index 0000000..3e062f1 --- /dev/null +++ b/labcore/analysis/fitting.py @@ -0,0 +1,60 @@ +from typing import Dict, Any, Tuple +import numpy as np + + +def batch_fitting(analysis_class, all_data: Dict[Any, Tuple[np.ndarray, np.ndarray]], **kwargs): + """ fit multiple datafiles of the same analysis class + + Parameters + ---------- + analysis_class + the name of the class of the sweeping + all_data + a dictionary whose values are tuples of coordinates and measured data, each of which corresponds to a data + file, and keys are the labels for the data files + + Returns + ------- + dict + a dictionary whose values are FitResult class objects containing the fit results of the data files, + and keys are the labels for the data files + """ + fit_results = {} + for label in all_data.keys(): + coordinates, data = all_data[label] + fit = analysis_class(coordinates, data) + fit_result = fit.run(**kwargs) + fit_results[label] = fit_result + + return fit_results + + +def params_from_batch_fitting_results(fit_results: dict, params: list[str]) -> Tuple[list[Any], Dict[str, Any]]: + """ extract parameter values and errors from the fit results and resort them into a dictionary whose keys are + the parameter and values are corresponding parameter values and errors + + Parameters + ---------- + fit_results + a dictionary whose values are FitResult class objects containing the fit results of the data files, + and keys are the labels for the data files + params + list of strings corresponding to the names of parameters one wants to look at + + Returns + ------- + dict + a dictionary whose keys are the parameter and values are corresponding parameter values and errors + """ + resorted_dict = {} + for param in params: + resorted_dict[param] = [] + resorted_dict[param +'_error'] = [] + + labels = [] + for label, fit_result in fit_results.items(): + labels.append(label) + for key, values in fit_result.lmfit_result.params.items(): + resorted_dict[key].append(values.value) + resorted_dict[key +'_error'].append(values.stderr) + return labels, resorted_dict diff --git a/labcore/analysis/resonators.py b/labcore/analysis/resonators.py new file mode 100644 index 0000000..ab4bb4b --- /dev/null +++ b/labcore/analysis/resonators.py @@ -0,0 +1,480 @@ +from typing import Dict, Any + +import numpy as np +import scipy +from matplotlib import pyplot as plt +from pathlib import Path + +from plottr.analyzer.fitters.fitter_base import Fit + + +class ReflectionResponse(Fit): + + @staticmethod + def model(coordinates: np.ndarray, A: float, f_0: float, Q_i: float, Q_e: float, phase_offset: float, + phase_slope: float): + """ + Reflection response model derived from input-output theory. For detail, see section 12.2.6 in "Quantum + and Atom Optics" by Daniel Adam Steck + + Parameters + ---------- + coordinates + 1d numpy array containing the frequencies in range of sweeping + A + amplitude correction of the response + f_0 + resonant frequency + Q_i + internal Q (coupling to losses of the cavity) + Q_e + external Q (coupling to output pins) + phase_offset + the offset of phase curve which can be seen at the start and end point of the phase diagram of reflection + response + phase_slope + the slope of phase curve which can be seen at the start and end point of the phase diagram of reflection + response + + Returns + ------- + numpy array + the ideal response calculated with the equation + """ + x = coordinates + s11_ideal = (1j * (1 - x / f_0) + (Q_i - Q_e) / (2 * Q_e * Q_i)) / ( + 1j * (1 - x / f_0) - (Q_i + Q_e) / (2 * Q_e * Q_i)) + correction = A * np.exp(1j * (phase_offset + phase_slope * (x - f_0))) + return s11_ideal * correction + + @staticmethod + def guess(coordinates: np.ndarray, data: np.ndarray): + """ make an initial guess on parameters based on the measured reflection response data and the input-output + theory + + Parameters + ---------- + coordinates + 1d numpy array containing the frequencies in range of sweeping + data + 1d numpy array containing the complex measured reflection response data + + Returns + ------- + dict + a dictionary whose values are the guess on A, f_0, Q_i, Q_e, phase_offset, and phase slope and keys + contain their names + """ + + amp = np.abs(np.concatenate((data[:data.size // 10], data[-data.size // 10:]))).mean() + dip_loc = np.argmax(np.abs(np.abs(data) - amp)) + guess_f_0 = coordinates[dip_loc] + + data = moving_average(data) + depth = amp - np.abs(data[dip_loc]) + width_loc = np.argmin(np.abs(amp - np.abs(data) - depth / 2)) + kappa = 2 * np.abs(coordinates[dip_loc] - coordinates[width_loc]) + guess_Q_tot = guess_f_0 / kappa + # print(guess_Q_tot) + + [slope, _] = np.polyfit(coordinates[:data.size // 10], np.angle(data[:data.size // 10], deg=False), 1) + phase_offset = np.angle(data[0]) + slope * (coordinates[dip_loc] - coordinates[0]) + correction = amp * np.exp(1j * phase_offset) + # print(data[dip_loc]/correction) + guess_Q_e = 2 * guess_Q_tot / (1 - np.abs(data[dip_loc]/correction)) + guess_Q_i = 1 / (1 / guess_Q_tot - 1 / guess_Q_e) + + return dict( + f_0=guess_f_0, + A=amp, + phase_offset=phase_offset, + phase_slope=slope, + Q_i=guess_Q_i, + Q_e=guess_Q_e + ) + + @staticmethod + def nphoton(P_cold_dBm: float, Q_e: float, Q_i: float, f_0: float): + """ calculate the number of photons in the resonator + + Parameters + ---------- + P_cold_dBm + the power (in unit of dBm) injected into the cold resonator, with cable loss taken into account + Q_i + internal Q (coupling to losses of the cavity) + Q_e + external Q (coupling to output pins) + f_0 + resonant frequency + + Returns + ------- + float + the number of photons + """ + P_cold_W = 1e-3 * 10 ** (P_cold_dBm / 10.) + Q_tot = 1 / (1 / Q_e + 1 / Q_i) + photon_number = 2. * P_cold_W * Q_tot ** 2 / (np.pi * scipy.constants.h * f_0 ** 2 * Q_e) + return photon_number + + +class HangerResponseBruno(Fit): + """model from: https://arxiv.org/abs/1502.04082 - pages 6/7.""" + + @staticmethod + def model(coordinates: np.ndarray, A: float, f_0: float, Q_i: float, Q_e_mag: float, theta: float, phase_offset: float, + phase_slope: float, transmission_slope: float): + """A (1 + alpha * (x - f_0)/f_0) (1 - Q_l/|Q_e| exp(i \theta) / (1 + 2i Q_l (x-f_0)/f_0)) exp(i(\phi_v f_0 + + phi_0))""" + + x = coordinates + amp_correction = A * (1 + transmission_slope * (x - f_0)/f_0) + phase_correction = np.exp(1j*(phase_slope * x + phase_offset)) + + if Q_e_mag == 0: + Q_e_mag = 1e-12 + Q_e_complex = Q_e_mag * np.exp(-1j*theta) + Q_c = 1./((1./Q_e_complex).real) + Q_l = 1./(1./Q_c + 1./Q_i) + response = 1 - Q_l / np.abs(Q_e_mag) * np.exp(1j * theta) / (1. + 2j*Q_l*(x-f_0)/f_0) + + return response * amp_correction * phase_correction + + @staticmethod + def guess(coordinates, data) -> Dict[str, Any]: + + amp = np.abs(np.concatenate((data[:data.size // 10], data[-data.size // 10:]))).mean() + dip_loc = np.argmax(np.abs(np.abs(data) - amp)) + guess_f_0 = coordinates[dip_loc] + [guess_transmission_slope, _] = np.polyfit(coordinates[:data.size // 10], np.abs(data[:data.size // 10]), 1) + amp_correction = amp * (1+guess_transmission_slope*(coordinates-guess_f_0)/guess_f_0) + + data = moving_average(data) + depth = amp - np.abs(data[dip_loc]) + width_loc = np.argmin(np.abs(amp - np.abs(data) - depth / 2)) + kappa = 2 * np.abs(coordinates[dip_loc] - coordinates[width_loc]) + guess_Q_l = guess_f_0 / kappa + # print(guess_Q_tot) + + [slope, _] = np.polyfit(coordinates[:data.size // 10], np.angle(data[:data.size // 10], deg=False), 1) + phase_offset = np.angle(data[0], deg=False) - slope * (coordinates[0]-0) + phase_correction = np.exp(1j*(slope * coordinates + phase_offset)) + correction = amp_correction * phase_correction + # print(data[dip_loc]/correction) + + guess_theta = 0.5 # there are deterministic ways of finding it but looking at two symmetric points close to f_r in S21 , but it's kinda unnecessary so I just choose a small value and it works so far + guess_Q_e_mag = np.abs(-guess_Q_l * np.exp(1j*guess_theta) / (data[dip_loc]/correction[dip_loc]-1)) + guess_Q_c = 1 / np.real(1 / (guess_Q_e_mag*np.exp(-1j*guess_theta))) + guess_Q_i = 1 / (1 / guess_Q_l - 1 / guess_Q_c) + + return dict( + A = amp, + f_0 = guess_f_0, + Q_i = guess_Q_i, + Q_e_mag = guess_Q_e_mag, + theta = guess_theta, + phase_offset = phase_offset, + phase_slope = slope, + transmission_slope = guess_transmission_slope, + ) + + + # return dict( + # A = 1, + # f_0 = 1, + # Q_i = 1e6, + # Q_e = 1e6, + # theta = 0, + # phase_offset=0, + # phase_slope=0, + # transmission_slope=0, + # ) + + + @staticmethod + def nphoton(P_cold_dBm: float, Q_e: float, Q_i: float, f_0: float, theta: float): + P_cold_W = 1e-3 * 10 ** (P_cold_dBm / 10.) + Q_e_complex = Q_e * np.exp(-1j*theta) + Q_c = 1./((1/Q_e_complex).real) + Q_l = 1./(1./Q_c + 1./Q_i) + return 2 / (scipy.constants.hbar * (2*np.pi*f_0)**2) * Q_l**2 / Q_c * P_cold_W + + +class TransmissionResponse(Fit): + + @staticmethod + def model(coordinates: np.ndarray, f_0: float, A: float, Q_t: float, Q_e: float, phase_offset: float, + phase_slope: float): + """ + Reflection response model derived from input-output theory. For detail, see section 12.2.6 in "Quantum + and Atom Optics" by Daniel Adam Steck + + Parameters + ---------- + coordinates + 1d numpy array containing the frequencies in range of sweeping + f_0 + resonant frequency + Q_t + total Q + Q_e + geometric mean of the two coupling Qs (coupling to output pins) multiplied with the total attenuation + of the signal path. + phase_offset + the offset of phase curve which can be seen at the start and end point of the phase diagram of reflection + response + phase_slope + the slope of phase curve which can be seen at the start and end point of the phase diagram of reflection + response + + Returns + ------- + numpy array + the ideal response calculated with the equation + """ + x = coordinates + # s21_ideal = (k_e1*k_e2)**0.5 / ( 1j*2*np.pi*(f_0-x) - (k_e1+k_e2+k_i)/2 ) + # s21_ideal = Q_e / (1j*(1-x/f_0)*Q_e**2 - (Q_e2+Q_e1+Q_e1*Q_e2/Q_i)/2) + correction = A * np.exp(1j * (phase_offset + phase_slope * (x - f_0))) + s21 = correction * (1j * Q_e * (1. - x/f_0) - .5 * Q_e / Q_t)**(-1) + return s21 + + @staticmethod + def guess(coordinates: np.ndarray, data: np.ndarray) -> Dict[str, Any]: + """ make an initial guess on parameters based on the measured reflection response data and the input-output + theory + + Parameters + ---------- + coordinates + 1d numpy array containing the frequencies in range of sweeping + data + 1d numpy array containing the complex measured reflection response data + + Returns + ------- + dict + a dictionary whose values are the guess on A, f_0, Q_i, Q_e, phase_offset, and phase slope and keys + contain their names + """ + data = moving_average(data) + + # Average the first and last 10% of the data to get the base amplitude + amp = np.abs(np.concatenate((data[:data.size // 10], data[-data.size // 10:]))).mean() + + # Find the resonance frequency from the max point + dip_loc = np.argmax(np.abs(np.abs(data) - amp)) + guess_f_0 = coordinates[dip_loc] + + # Find the depth to get kappa and from kappa and f_0 estimate Q_t + depth = amp - np.abs(data[dip_loc]) + width_loc = np.argmin(np.abs(amp - np.abs(data) - depth / 2)) + kappa = np.abs(coordinates[dip_loc] - coordinates[width_loc]) + guess_Q_t = guess_f_0 / kappa + + # Use Q_t estimate and the max value to get an estimate for Q_e' + guess_Q_e = -2*guess_Q_t/np.abs(depth) + + # Guess the phase offset and slope + [guess_slope, _] = np.polyfit(coordinates[:data.size // 10], np.angle(data[:data.size // 10], deg=False), 1) + guess_phase = np.angle(data[0]) + guess_slope * (coordinates[dip_loc] - coordinates[0]) + + #print(guess_phase) + + return dict( + A=amp, + f_0=guess_f_0, + Q_t=guess_Q_t, + Q_e=-250, + phase_offset=guess_phase, + phase_slope=guess_slope, + ) + + # @staticmethod + # def nphoton(P_cold_dBm: float, Q_e1: float, Q_e2: float, Q_i: float, f_0: float): + # """ calculate the number of photons in the resonator + # + # Parameters + # ---------- + # P_cold_dBm + # the power (in unit of dBm) injected into the cold resonator, with cable loss taken into account + # Q_i + # internal Q (coupling to losses of the cavity) + # Q_e1 + # input external Q (coupling to input pins) + # Q_e2 + # output external Q (coupling to output pins) + # f_0 + # resonant frequency + # + # Returns + # ------- + # float + # the number of photons + # """ + # P_cold_W = 1e-3 * 10 ** (P_cold_dBm / 10.) + # Q_tot = 1 / (1 / Q_e1 + 1 / Q_e2 + 1 / Q_i) + # photon_number = 2. * P_cold_W * Q_tot ** 2 / (np.pi * scipy.constants.h * f_0 ** 2 * Q_e1) + # return photon_number + + +def moving_average(a): + n = a.size//200*2+1 + ret = np.cumsum(a) + ret[n:] = ret[n:] - ret[:-n] + return np.append(np.append(a[:int((n-1)/2-1)], ret[n - 1:] / n), a[int(-(n-1)/2-1):]) + + +def plot_resonator_response(frequency: np.ndarray, figsize: tuple =(6, 3), f_unit: str = 'Hz', **sparams): + """ plot the magnitude, phase, and polar diagrams of the data, the model with initially guessed parameters, + and the fitted curve + + Parameters + ---------- + coordinates + 1d numpy array containing the frequencies in range of sweeping + figsize + size of the figure. Default is (6,3) + f_unit + the unit of frequency, often in Hz or GHz. Default is Hz + sparams + a dictionary whose values are either a few 1d arrays containing the measured data, values of model with + initially guessed parameters, and values of the fitted curve, or a few dictionaries, each containing one of + them and the corresponding plotting, and keys are their names. + + Returns + ------- + matplotlib.figure + a figure showing the magnitude, phase, and polar diagrams of the data, the model with initially guessed + parameters, and the fitted curve + """ + fig = plt.figure(constrained_layout=True, figsize=figsize) + gs = fig.add_gridspec(2, 2, width_ratios=[2,1]) + mag_ax = fig.add_subplot(gs[0,0]) + phase_ax = fig.add_subplot(gs[1,0], sharex=mag_ax) + circle_ax = fig.add_subplot(gs[:,1], aspect='equal') + + for name, sparam in sparams.items(): + if isinstance(sparam, np.ndarray): + data = sparam + sparam = {} + elif isinstance(sparam, dict): + data = sparam.pop('data') + else: + raise ValueError(f"cannot accept data of type {type(sparam)}") + + mag_ax.plot(frequency, np.abs(data), label=name, **sparam) + phase_ax.plot(frequency, np.angle(data, deg=False), **sparam) + circle_ax.plot(data.real, data.imag, **sparam) + + mag_ax.legend(loc='best', fontsize='x-small') + mag_ax.set_ylabel('Magnitude') + + phase_ax.set_ylabel('Phase (rad)') + phase_ax.set_xlabel(f'Frequency ({f_unit})') + + circle_ax.set_xlabel('Re') + circle_ax.set_ylabel('Im') + + return fig + + +def fit_and_plot_reflection(f_data: np.ndarray, s11_data: np.ndarray, fn=None, **guesses): + """ convenience function which does the fitting and plotting (and saving to local directory if given the address) + in a single call + + Parameters + ---------- + f_data + 1d numpy array containing the frequencies in range of sweeping + s11_data + 1d numpy array containing the complex measured reflection response data + guesses + (optional) manual guesses on fit parameters + + Returns + ------- + matplotlib.figure + a figure showing the magnitude, phase, and polar diagrams of the data, the model with initially guessed + parameters, and the fitted curve + """ + fit = ReflectionResponse(f_data, s11_data) + guess_result = fit.run(dry=True, **guesses) + guess_y = guess_result.eval() + + fit_result = fit.run(**guesses) + print(fit_result.lmfit_result.fit_report()) + + fit_y = fit_result.eval() + + fig = plot_resonator_response(f_data * 1e-9, f_unit='GHz', + data=dict(data=s11_data, lw=0, marker='.'), + guess=dict(data=guess_y, lw=1, dashes=[1, 1]), + fit=dict(data=fit_y)) + + if fn is not None: + with open(Path(fn.parent, 'fit.txt'), 'w') as f: + f.write(fit_result.lmfit_result.fit_report()) + fig.savefig(Path(fn.parent, 'fit.png')) + print('fit result and plot saved') + + return fig + +def fit_and_plot_resonator_response(f_data: np.ndarray, s11_data: np.ndarray, response_type: str = 'transmission', fn=None, **guesses): + """ convenience function which does the fitting and plotting (and saving to local directory if given the address) + in a single call + + Parameters + ---------- + f_data + 1d numpy array containing the frequencies in range of sweeping + s11_data + 1d numpy array containing the complex measured reflection response data + response_type + name of the response that we want to fit. The default is transmission response + guesses + (optional) manual guesses on fit parameters + + Returns + ------- + matplotlib.figure + a figure showing the magnitude, phase, and polar diagrams of the data, the model with initially guessed + parameters, and the fitted curve + """ + if response_type == 'transmission': + fit = TransmissionResponse(f_data, s11_data) + elif response_type == 'hanger': + fit = HangerResponseBruno(f_data, s11_data) + else: + fit = ReflectionResponse(f_data, s11_data) + guess_result = fit.run(dry=True, **guesses) + guess_y = guess_result.eval() + + fit_result = fit.run(**guesses) + print(fit_result.lmfit_result.fit_report()) + + fit_y = fit_result.eval() + + fig = plot_resonator_response(f_data * 1e-9, f_unit='GHz', + data=dict(data=s11_data, lw=0, marker='.'), + guess=dict(data=guess_y, lw=1, dashes=[1, 1]), + fit=dict(data=fit_y)) + print() + print("===========") + print() + if response_type == 'transmission': + print("Kappa total is", round(fit_result.params['f_0'].value / fit_result.params['Q_t'].value * 1e-6, 3), "MHz") + if response_type == 'hanger': + Q_e_mag = fit_result.params['Q_e_mag'].value + theta = fit_result.params['theta'].value + print("for your convenience: Q_c = 1/Re{1/Q_e} = ", 1 / np.real( 1 / (Q_e_mag*np.exp(-1j*theta)) )) + + + if fn is not None: + with open(Path(fn.parent, 'fit.txt'), 'w') as f: + f.write(fit_result.lmfit_result.fit_report()) + fig.savefig(Path(fn.parent, 'fit.png')) + print('fit result and plot saved') + + return fig diff --git a/labcore/analysis/single_transmon.py b/labcore/analysis/single_transmon.py new file mode 100644 index 0000000..4de1fe0 --- /dev/null +++ b/labcore/analysis/single_transmon.py @@ -0,0 +1,91 @@ +from typing import List, Union + +import numpy as np +from numpy import complexfloating, ndarray +from matplotlib import pyplot as plt +from sklearn.cluster import KMeans + +from labcore.plotting.basics import readout_hist + + +def convert_to_probability(signal: List[complexfloating], + initial_centroids: List[List[float]] = None, + return_labels: bool = False, + return_centers: bool = False, + plot_hist: bool = False, color_plot: bool = False) -> Union[ndarray, List[ndarray]]: + """ + Converts IQ data from qubit into state probabilities. + + Analyzes the data from a sweeping, identifies two centers (0 and 1) and assigns each data point to one of them. + After that, calculate the mean of each repetition and returns the probabilities. The assigment of clusters is done + through K-means algorithm. The function cannot identify which cluster is the excited state and which cluster is the + ground state, meaning that the probability might be inverted if initial centroids are not specified. + The repetition axis must be the outermost axis. + + Parameters + ---------- + signal: + Array with the complex data from measurements. All repetitions from the experiment should be here + and the repetition axis should be the outermost. + initial_centroids: + Indicates which center is the ground state and which the excited state. The format is a list containing 2 lists + composed each of 2 floats, e.g.: ``[[-1,0], [1,0]]``, indicating the IQ coordinates of each center. First center + corresponds to the ground state and second center corresponds to excited state. If this argument remains + ``None``, the labels and probabilities might be inverted. + return_labels: + If True, a numpy array will be returned as its second item in the same shape as signal + with 1s and 0s for each element of signal indicating to what cluster that element belongs too. + return_centers: + If True, the function will also return as its third item a list with the two centers of the + clusters (qubit states). Defaults to False. + plot_hist: + If True, the function will plot an IQ histogram. defaults to False. + color_plot: + If True, the function will plot an IQ histogram with a colored scatter plot on top indicating the + state of each point. Defaults to False + + Returns + ------- + Union[ndarray, List[ndarray]] + If return_labels and return_centers are both False, return an ndarray with the probabilities of the qubit to + be on a specific state for each point. The function doesn't know which state is excited and ground so the + probabilities might be inversed. + If either return_labels or return_centers are True, returns a List with the first item being the + probabilities. If return_labels is True, the second item will be an ndarray of the shape of signal consisting + of 0s, or 1s indicating the state of each data point. If return_centers is True, the third item (second if + return_labels is False) will be 2x2 ndarray with the centers of the 2 states. + + """ + ret = [] + signal_flat = signal.flatten() + signal_arr = np.stack([signal_flat.real, signal_flat.imag], axis=1) + + if initial_centroids is not None: + if isinstance(initial_centroids, List): + initial_centroids = np.array(initial_centroids) + + kmeans = KMeans(n_clusters=2, init=initial_centroids) + else: + kmeans = KMeans(n_clusters=2) + + kmeans.fit(signal_arr) + + labels = kmeans.labels_.reshape(signal.shape) + pvals = labels.mean(axis=0) + ret.append(pvals) + + if return_labels: + ret.append(labels) + if return_centers: + ret.append(kmeans.cluster_centers_) + if plot_hist: + fig = readout_hist(signal_flat, 'Histogram') + if color_plot: + fig = readout_hist(signal_flat, 'Sorted Histogram') + plt.scatter(signal_flat.real, signal_flat.imag, c=kmeans.labels_, cmap='bwr') + + if len(ret) == 1: + return ret[0] + else: + return ret + diff --git a/labcore/opx/__init__.py b/labcore/opx/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/labcore/opx/config.py b/labcore/opx/config.py new file mode 100644 index 0000000..fbe9625 --- /dev/null +++ b/labcore/opx/config.py @@ -0,0 +1,311 @@ +import os +import logging +import json +from typing import Dict, Any, Optional + +import numpy as np + +from instrumentserver.helpers import nestedAttributeFromString +from .machines import close_my_qm + +logger = logging.getLogger(__name__) + +class QMConfig: + """ + Base class for a QMConfig class. The purpose of this class is to implement the real time changes of the + parameter manager with the OPX. We do this to always have the most up-to-date parameters from the + parameter manager and integration weights (which depend on the parameters in the parameter manager). + + By default, when a new config is generated this class will close any open QuantumMachines that are using the same + controllers that this config uses. To not do this pass False to close_other_machines in config(). + + The user should still manually write the config dictionary used for the specific physical setup that the + sweeping is going to be performed but a few helper methods are implemented in the base class: two helper + methods to write integration weights and a method that creates and adds the integration weights to the config dict. + + If the constructor is overriden the new constructor should call the super constructor to pass the parameter manager + instance used. + + If the constructor is overriden because the parameter manager is not being used, the method config(self) also needs + to be overriden. + + To have the integration weights added automatically into the config dict, you have to implement config_(self). + config_(self) should return the python dictionary without the integration weights in it. + If this is the case, the already implemented config(self) method will add the integration weights when called and + return the python dictionary with the integration weights added. + + The add_integration_weights will go through the items in the pulses dictionary and add weights to any + pulse that has the following characteristics: + * The key of the pulse starts with the str 'readout'. If the first 7 characters of the key are not 'readout' + that pulse will be ignored. + * It needs to have the string '_pulse', present in its key. anything that comes before '_pulse' is + as the name of the pulse, anything afterwards gets ignored. + e.g. If my pulse name is: 'readout_short_pulse', 'readout_short' is taken as a unique pulse that requires + integration weights. If another pulse exists called: 'readout_short_pulse_something_else' + add_integration_weights will add the same integration weights as it did to 'readout_short'. + This is useful if you have 2 different pules of the same length that need the same integration weights. + * For each unique pulse there needs to be a parameter in the parameter manager with the unique pulse name + followed by len. This is where the length of the pulse will be taken to get the + integration weights. An underscore ('_') in the pulse name will be interpreted as a dot ('.') in the + parameter manager. + e.g. If I have a pulse with name 'readout_short_pulse', the pulse name is 'readout_short' and there should + be a parameter in the parameter manager called: 'readout.short.len' with the pulse length in it. + Any pulse that does not fulfil any of the three requirements will be ignored and will not have + integration weights. + + 3 integration weights will be created for each unique pulse, a flat integration weights + for a full demodulation, flat integration weights for a sliced demodulation and weighted integration weights. + The weights for the weighted integration will be loaded from the calibration files folder. + If no weights are found in the calibration folder for a pulse, flat ones will be used instead. + If old integration weights are found in the file, they will be deleted. + + :param params: The instance of the parameter manager where the length of the pulses are stored. + :param opx_address: The address of the OPX where the config is going to get used. + :param opx_port: The port of the OPX where the config is going to get used. + """ + + def __init__(self, params, opx_address: Optional[str] = None, opx_port: Optional[str] = None) -> None: + self.params = params + self.opx_address = opx_address + self.opx_port = opx_port + + def __call__(self, *args, **kwargs) -> Dict[str, Any]: + return self.config() + + def config(self, close_other_machines: bool=True) -> Dict[str, Any]: + """ + Creates the config dictionary. + + :param close_other_machines: If True, closes any currently open qm in the opx that uses the same controllers + that this config is using. + :returns: The config dictionary. + """ + original = self.config_() + conf_with_weights = self.add_integration_weights(original) + with_random_wf = self.add_random_waveform(conf_with_weights) + if close_other_machines: + if self.opx_port is None or self.opx_address is None: + logger.warning(f'opx_port or opx_adress are empty, cannot close qm.') + else: + close_my_qm(with_random_wf, self.opx_address, self.opx_port) + return with_random_wf + + def config_(self) -> Dict[str, Any]: + raise NotImplementedError + + def add_random_waveform(self, conf): + """ + Adds a random waveform to the config dictionary. This is needed becaouse of a bug in the qm code that does not + close open QuantumMachines if the configuration is exactly the same. + """ + config_dict = conf.copy() + config_dict['waveforms']['randon_wf'] = {'type': 'constant', + 'sample': np.random.rand()} + return config_dict + + def add_integration_weights(self, conf): + """ + Automatically add integration weights to the config dictionary. See module docstring for further explanation on + the rules for this to work. + """ + integration_weights_file = 'calibration_files/integration_weights.json' + + # Changes to True if old integration weights are found + deleted_weights = False + + # Used to not repeat missing file warning + no_file_warning = False + config_dict = conf.copy() + pulses = {} + + if os.path.exists(integration_weights_file): + with open(integration_weights_file) as json_file: + loaded_weights = json.load(json_file) + else: + loaded_weights = None + + # Go throguh pulses and check if they should have integration weights + for key in config_dict['pulses'].keys(): + if key[:7] == 'readout' and '_pulse' in key: + split_key = key.split('_pulse') + pulse = split_key[0] + # str with the name of the length of the pulse in the param manager + param_pulse = pulse.replace('_', '.') + '.len' + if self.params.has_param(param_pulse): + if pulse not in pulses.keys(): + pulse_len = nestedAttributeFromString(self.params, param_pulse)() + + # Using the old integration weights style for the sliced weights because the OPX currently + # raises an exception when using the new ones. + flat = [(0.2, pulse_len)] + flat_sliced = [0.2] * int(pulse_len//4) + empty = [(0.0, pulse_len)] + empty_sliced = [0.0] * int(pulse_len//4) + + pulses[pulse] = {} + pulses[pulse][pulse + '_cos'] = { + 'cosine': flat, + 'sine': empty + } + pulses[pulse][pulse + '_sin'] = { + 'cosine': empty, + 'sine': flat + } + pulses[pulse][pulse + '_sliced_cos'] = { + 'cosine': flat_sliced, + 'sine': empty_sliced + } + pulses[pulse][pulse + '_sliced_sin'] = { + 'cosine': empty_sliced, + 'sine': flat_sliced + } + + # Creating the variables for the weighted integration weights. + # If integrationg weights of the correct length are found on file, they get overwritten with + # the proper loaded weights. + pulse_weight_I = flat + pulse_weight_Q = flat + + pulse_weight_empty = empty + + if loaded_weights is not None: + # Check if the current pulse has loaded integration weights + if any(pulse in weights for weights in loaded_weights): + pulse_weight_I_temp = loaded_weights[pulse + '_I'] + pulse_weight_Q_temp = loaded_weights[pulse + '_Q'] + + I_length = sum(i[1] for i in pulse_weight_I_temp) + Q_length = sum(i[1] for i in pulse_weight_Q_temp) + + # Check that they are the correct length. + if I_length == pulse_len and Q_length == pulse_len: + pulse_weight_I = pulse_weight_I_temp + pulse_weight_Q = pulse_weight_Q_temp + + pulse_weight_empty = [(0.0, 40)] * len(pulse_weight_I) + logging.info(f'Loaded weighted integration weights for {pulse}.') + else: + logging.info(f'Found old integration weights for {pulse}, deleting them from file.') + loaded_weights.pop(pulse + '_I') + loaded_weights.pop(pulse + '_Q') + deleted_weights = True + + else: + logging.info(f'No integration weights found for {pulse}, using flat weights.') + else: + if not no_file_warning: + no_file_warning = True + logging.info('Integration weights file not found, using flat weights.') + + pulses[pulse][pulse + '_weighted_cos'] = { + 'cosine': pulse_weight_I, + 'sine': pulse_weight_empty + } + pulses[pulse][pulse + '_weighted_sin'] = { + 'cosine': pulse_weight_empty, + 'sine': pulse_weight_Q + } + + # Assembling the dictionary that the config dict needs in each pulse for integration weights. + possible_integration_weights_per_pulse = {} # Dictionary with integration weights for this pulse. + for weights in pulses[pulse].keys(): + possible_integration_weights_per_pulse[weights] = weights + config_dict["pulses"][key]['integration_weights'] = possible_integration_weights_per_pulse + + # Assembling the 'integration_weights' dictionary. + integration_weights = {} + for pul, val in pulses.items(): + for integration_name, int_weight in val.items(): + integration_weights[integration_name] = int_weight + + config_dict['integration_weights'] = integration_weights + + + if loaded_weights is not None: + # Check that there are not old integration weights for pulses that don't exists anymore. + delete = [] + for weights in loaded_weights.keys(): + if weights[:-2] not in pulses.keys(): + delete.append(weights) + deleted_weights = True + + for old_weight in delete: + # Delete the weight from the file if these weights are not used. + loaded_weights.pop(old_weight) + + # Delete weights that should be deleted and save the weights without the old ones present. + if deleted_weights: + os.remove(integration_weights_file) + if len(loaded_weights) != 0: + with open(integration_weights_file, 'w') as file: + json.dump(loaded_weights, file) + + + return config_dict + + # The following are helper methods written by Quantum Machines to create integration weights + def _round_to_fixed_point_accuracy(self, x, base=2 ** -15): + """ + Written by Quantum Machines. + """ + + return np.round(base * np.round(np.array(x) / base), 20) + + def convert_full_list_to_list_of_tuples(self, integration_weights, N=100, accuracy=2 ** -15): + """ + Written by Quantum Machines. + + Converts a list of integration weights, in which each sample corresponds to a clock cycle (4ns), to a list + of tuples with the format (weight, time_to_integrate_in_ns). + Can be used to convert between the old format (up to QOP 1.10) to the new format introduced in QOP 1.20. + + :param integration_weights: A list of integration weights. + :param N: Maximum number of tuples to return. The algorithm will first create a list of tuples, + and then if it is + too long, it will run :func:`compress_integration_weights` on them. + :param accuracy: The accuracy at which to calculate the integration weights. Default is 2^-15, which is + the accuracy at which the OPX operates for the integration weights. + :type integration_weights: list[float] + :type N: int + :type accuracy: float + :return: List of tuples representing the integration weights + """ + integration_weights = self._round_to_fixed_point_accuracy(integration_weights, accuracy) + changes_indices = np.where(np.abs(np.diff(integration_weights)) > 0)[0].tolist() + prev_index = -1 + new_integration_weights = [] + for curr_index in (changes_indices + [len(integration_weights) - 1]): + constant_part = (integration_weights[curr_index].tolist(), round(4 * (curr_index - prev_index))) + new_integration_weights.append(constant_part) + prev_index = curr_index + + new_integration_weights = self.compress_integration_weights(new_integration_weights, N=N) + return new_integration_weights + + def compress_integration_weights(self, integration_weights, N=100): + """ + Written by Quantum Machines. + + Compresses the list of tuples with the format (weight, time_to_integrate_in_ns) to one with length < N. + Works by iteratively finding the nearest integration weights and combining them with a weighted average. + + :param integration_weights: The integration_weights to be compressed. + :param N: The maximum list length required. + :return: The compressed list of tuples representing the integration weights. + """ + while len(integration_weights) > N: + diffs = np.abs(np.diff(integration_weights, axis=0)[:, 0]) + min_diff = np.min(diffs) + min_diff_indices = np.where(diffs == min_diff)[0] + integration_weights = np.array(integration_weights) + times1 = integration_weights[min_diff_indices, 1] + times2 = integration_weights[min_diff_indices + 1, 1] + weights1 = integration_weights[min_diff_indices, 0] + weights2 = integration_weights[min_diff_indices + 1, 0] + integration_weights[min_diff_indices, 0] = (weights1 * times1 + weights2 * times2) / (times1 + times2) + integration_weights[min_diff_indices, 1] = times1 + times2 + integration_weights = np.delete(integration_weights, min_diff_indices + 1, 0) + integration_weights = list(zip(integration_weights.T[0].tolist(), + integration_weights.T[1].astype(int).tolist())) + + return integration_weights diff --git a/labcore/opx/machines.py b/labcore/opx/machines.py new file mode 100644 index 0000000..24a4497 --- /dev/null +++ b/labcore/opx/machines.py @@ -0,0 +1,25 @@ +from qm.QuantumMachinesManager import QuantumMachinesManager + + +def close_my_qm(config, host, port): + """ + Helper function that closes any machines that is open in the OPT with host and port that uses any controller that + is present in the passed config. + + Parameters + ---------- + config + Config dictionary from which we are trying to open a QuantumMachine + host + The OPT host ip address + port + The OPT port + + """ + qmm = QuantumMachinesManager(host=host, port=port) + controllers = [con for con in config['controllers'].keys()] + open_qms = [qmm.get_qm(machine_id=machine_id) for machine_id in qmm.list_open_quantum_machines()] + for qm in open_qms: + for con in controllers: + if con in qm.list_controllers(): + qm.close() diff --git a/labcore/opx/mixer.py b/labcore/opx/mixer.py new file mode 100644 index 0000000..c7a2aee --- /dev/null +++ b/labcore/opx/mixer.py @@ -0,0 +1,609 @@ +"""Tools for using (IQ) mixers with the QM OPX. + +Required packages/hardware: +- QM OPX incl python software +- SignalHound USB SA124B + driver (comes with qcodes) +""" +from typing import List, Tuple, Optional, Any, Dict, Callable +from time import sleep +from datetime import datetime + +import numpy as np +from matplotlib import pyplot as plt +from scipy.optimize import minimize + +from tfe_hardware.qcodes_instrument_drivers.SignalHound.Spike import Spike +from tfe_hardware.qcodes_instrument_drivers.SignalCore.SignalCore_sc5511a import SignalCore_SC5511A +from qm import QuantumMachine, QuantumMachinesManager +from qm.qua import * + +from labcore.opx.config import QMConfig + + +class MixerCalibration: + """Class for performing IQ mixer calibration. + + We assume that we control the I and Q with a QM OPX, and monitor the output of the mixer with a + SignalHound spectrum analyzer. + Requires that independently a correctly specified configuration for the OPX is available. + + Parameters + ---------- + lo_frq + LO frequency in Hz + if_frq + IF frequency in Hz (we're taking the absolute) + analyzer + SignalHound qcodes driver instance + qm + Quantum Machine instance (with config applied) + mixer_name + the name of mixer we're tuning, as given in the QM config + element_name + the name of the element thats playing the IQ waveform, as given in the QM config + pulse_name + the name of the (CW) pulse we're playing to tune the mixer, as given in the QM config + """ + + def __init__(self, lo_frq: float, if_frq: float, analyzer: Spike, + qm: QuantumMachine, mixer_name: str, element_name: str, pulse_name: str + ): + + self.lo_frq = lo_frq + self.if_frq = if_frq + self.analyzer = analyzer + self.qm = qm + self.mixer_name = mixer_name + self.element_name = element_name + self.pulse_name = pulse_name + self.do_plot = True + + self.analyzer.mode('ZS') + sleep(0.5) + + def play_wf(self) -> None: + """Play an infinite loop waveform on the OPX. + We're scaling the amplitude of the pulse used by 0.5. + """ + with program() as const_pulse: + with infinite_loop_(): + play(self.pulse_name * amp(0.5), self.element_name) + + _ = self.qm.execute(const_pulse) + + def setup_analyzer(self, f: float) -> None: + """Set up the analyzer to measure at the given frequency `f` and sweep time. + + Signalhound driver is automatically put in zero-span mode when called. + + Parameters + ---------- + f + frequency to measure at, in Hz + mode + set the mode for the spectrum analyzer + """ + self.analyzer.zs_fcenter(f) + sleep(1.0) + + def measure_leakage(self) -> float: + """Measure max. signal power at the LO frequency.""" + # self.setup_analyzer(self.lo_frq) + sleep(0.1) + return self.analyzer.zs_power() + + def measure_upper_sb(self) -> float: + """Measure max. signal power at LO frequency + IF frequency""" + # self.setup_analyzer(self.lo_frq + np.abs(self.if_frq)) + sleep(0.1) + return self.analyzer.zs_power() + + def measure_lower_sb(self) -> float: + """Measure max. signal power at LO frequency - IF frequency""" + # self.setup_analyzer(self.lo_frq - np.abs(self.if_frq)) + sleep(0.1) + return self.analyzer.zs_power() + + @staticmethod + def IQ_imbalance_correction(g, phi) -> List: + """returns in the IQ mixer correction matrix as exepcted by the QM mixer config. + + Parameters + ---------- + g + relative amplitude imbalance between I and Q channels + phi + relative phase imbalance between I and Q channels + """ + c = np.cos(phi) + s = np.sin(phi) + N = 1 / ((1 - g ** 2) * (2 * c ** 2 - 1)) + return [float(N * x) for x in [(1 - g) * c, (1 + g) * s, + (1 - g) * s, (1 + g) * c]] + + def _optimize2d(self, func, initial_guess, initial_ranges, + title='', xtitle='', ytitle='', ztitle='Power', + nm_options=None, maxit=200): + + """ + Performs minimization through Nelder-Mead algorithm. + It starts with an initial simplex (triangle in current 2D case). + The initial simplex is a regular triangle centered around 'initial_guess'. + The 'initial_ranges[0]' (which is side of square for 'scan2D') is the diameter of the circumscribing circle. + + Parameters + ---------- + func + initial_guess + initial_ranges + title + xtitle + ytitle + ztitle + nm_options + maxit + + Returns + ------- + res (coordinates of the found minimum) + + """ + + if nm_options is None: + nm_options = dict() + + x, y, z = [], [], [] + + def cb(vec): + val = func(vec) + x.append(vec[0]) + y.append(vec[1]) + z.append(val) + + print(f'vector: {vec}, result: {val}, iteration: {len(y)}') + + initial_simplex = np.zeros((3, 2)) + initial_simplex[0, :] = initial_guess + np.array([0.0, 2 * initial_ranges[0]/2]) # initial_guess + initial_simplex[1, :] = initial_guess + np.array([-np.round(np.sqrt(3), 2) * initial_ranges[0]/2, -initial_ranges[0]/2]) # initial_guess + np.array([initial_ranges[0], 0.]) + initial_simplex[2, :] = initial_guess + np.array([np.round(np.sqrt(3), 2) * initial_ranges[0]/2, -initial_ranges[0]/2]) # initial_guess + np.array([0., initial_ranges[1]]) + + try: + res = minimize(func, initial_guess, # bounds=((-0.5, 0.5), (-0.5, 0.5)), + method='Nelder-Mead', callback=cb, + options=dict(initial_simplex=initial_simplex, **nm_options, maxiter=maxit)) + + except KeyboardInterrupt: + res = np.array([x[-1], y[-1]]) + print('optimization stopped by user') + + return res + + def _scan2d(self, func, center, ranges, steps, + title='', xtitle='', ytitle='', ztitle='Power'): + + xvals = center[0] + np.linspace(-ranges[0] / 2., ranges[0] / 2., steps) + yvals = center[1] + np.linspace(-ranges[1] / 2., ranges[1] / 2., steps) + xx, yy = np.meshgrid(xvals, yvals, indexing='ij') + zz = np.ones_like(xx) * np.nan + + try: + for k, x in enumerate(xvals): + for l, y in enumerate(yvals): + p = func(np.array([x, y])) + zz[k, l] = p + print(f'{p:5.0f}', end='') + print() + + except KeyboardInterrupt: + print('scan stopped by user.') + + if self.do_plot: + fig, ax = plt.subplots(1, 1, constrained_layout=True) + im = ax.pcolormesh(xx, yy, zz, shading='auto') + cb = fig.colorbar(im, ax=ax, shrink=0.5, pad=0.02) + ax.set_title(title + f" {datetime.now().isoformat()}", fontsize='small') + cb.set_label(ztitle) + ax.set_xlabel(xtitle) + ax.set_ylabel(ytitle) + plt.show() + + min_idx = np.argmin(zz.flatten()) + return np.array([xx.flatten()[min_idx], yy.flatten()[min_idx]], dtype=float) + + def lo_leakage(self, iq_offsets: np.ndarray) -> float: + """Set the I and Q DC offsets and measure the leakage power (in dBm). + + Parameters + ---------- + iq_offsets + array with 2 elements (I and Q offsets), with dtype = float + """ + self.qm.set_output_dc_offset_by_element( + self.element_name, 'I', iq_offsets[0]) + self.qm.set_output_dc_offset_by_element( + self.element_name, 'Q', iq_offsets[1]) + + power = self.measure_leakage() + return power + + def lo_leakage_scan(self, center: np.ndarray = np.array([0., 0.]), + ranges: Tuple = (0.5, 0.5), steps: int = 11) -> np.ndarray: + """Scan the I and Q DC offsets and measure the leakage at each point. + + if `MixerCalibration.do_plot` is `True` (default), then this generates a live plot of this sweeping. + + Parameters + ---------- + center + center coordinate [I_of, Q_of] + ranges + scan range on I and Q + steps + how many steps (will be used for both I and Q) + Returns + ------- + np.ndarray + the I/Q offset coordinate at which the smallest leakage was found + """ + self.setup_analyzer(self.lo_frq) + res = self._scan2d(self.lo_leakage, + center=center, ranges=ranges, steps=steps, + title='Leakage scan', xtitle='I offset', + ytitle='Q offset') + return res + + def optimize_lo_leakage(self, initial_guess: np.ndarray = np.array([0., 0.]), + ranges: Tuple[float, float] = (0.1, 0.1), + nm_options: Optional[Dict[str, Any]] = None): + """Optimize the IQ DC offsets using Nelder-Mead. + + The initial guess and ranges are used to specify the initial simplex + for the NM algorithm. + initial guess is the starting point, and initial ranges are the distances + along the two coordinates for the remaining two vertices of the initial simplex. + + Parameters + ---------- + initial_guess + x0 of the NM algorithm, an array with two elements, for I and Q offset + ranges + distance for I and Q vectors to complete the initial simplex + nm_options + Options to pass to the `scipy.optimize.minimize(method='Nelder-Mead')`. + Will be passed via the `options` dictionary. + """ + + self.setup_analyzer(self.lo_frq) + res = self._optimize2d(self.lo_leakage, + initial_guess, + initial_ranges=ranges, + title='Leakage optimization', + xtitle='I offset', + ytitle='Q offset', + nm_options=nm_options) + return res + + def sb_imbalance(self, imbalance: np.ndarray) -> float: + """Set mixer imbalance and measure the upper SB power. + + Parameters + ---------- + imbalance + values for relative amplitude and phase imbalance + + Returns + ------- + float + upper SB power [dBm] + + """ + mat = self.IQ_imbalance_correction(imbalance[0], imbalance[1]) + self.qm.set_mixer_correction( + self.mixer_name, int(self.if_frq), int(self.lo_frq), + tuple(mat)) + return self.measure_upper_sb() + + def sb_imbalance_scan(self, center: np.ndarray = np.array([0., 0.]), + ranges: Tuple = (0.5, 0.5), steps: int = 11) -> np.ndarray: + """Scan the relative amplitude and phase imbalance and measure the leakage at each point. + + if `MixerCalibration.do_plot` is `True` (default), then this generates a live plot of this sweeping. + + Parameters + ---------- + center + center coordinate [amp imbalance, phase imbalance] + ranges + scan range on the two imbalances + steps + how many steps (will be used for both imbalances) + + Returns + ------- + np.ndarray + the imbalance coordinate at which the smallest leakage was found + """ + self.setup_analyzer(self.lo_frq + np.abs(self.if_frq)) + res = self._scan2d(self.sb_imbalance, + center=center, ranges=ranges, steps=steps, + title='SB imbalance scan', + xtitle='g', ytitle='phi') + return res + + def optimize_sb_imbalance(self, initial_guess: np.ndarray = np.array([0., 0.]), + ranges: Tuple[float, float] = (0.05, 0.05), + nm_options: Optional[Dict[str, Any]] = None) -> np.ndarray: + """Optimize the mixer imbalances using Nelder-Mead. + + The initial guess and ranges are used to specify the initial simplex + for the NM algorithm. + initial guess is the starting point, and initial ranges are the distances + along the two coordinates for the remaining two vertices of the initial simplex. + + Parameters + ---------- + initial_guess + x0 of the NM algorithm, an array with two elements, for rel. amp and phase imbalance + ranges + distance for amp/phase imbalance vectors to complete the initial simplex + nm_options + Options to pass to the `scipy.optimize.minimize(method='Nelder-Mead')`. + Will be passed via the `options` dictionary. + """ + self.setup_analyzer(self.lo_frq + np.abs(self.if_frq)) + res = self._optimize2d(self.sb_imbalance, + initial_guess, + initial_ranges=ranges, + title='SB imbalance optimization', + xtitle='g', + ytitle='phi', + nm_options=nm_options) + return res + + +@dataclass +class MixerConfig: + #: Quantum machines config object + qmconfig: QMConfig + #: OPX address + opx_address: str + #: OPX port + opx_port: str + #: spectrum analyzer + analyzer: Spike + #: the LO for the mixer + generator: SignalCore_SC5511A + #: param that holds the IF + if_param: Callable + #: param holding the dc offsets + offsets_param: Callable + #: param holding the imbalances + imbalances_param: Callable + #: name of the mixer in the opx config + mixer_name: str + #: element we play a constant pulse on + element_name: str + #: name of the pulse we play + pulse_name: str + #: method for calibrating the mixer + calibration_method: str = ' ' + #: power for the generator + generator_power: Optional[float] = None + #: options for scanning-based optimization, offsets + offset_scan_ranges: Tuple[float, float] = (0.01, 0.01) + offset_scan_steps: int = 11 + #: options for scanning-based optimization, imbalances + imbalance_scan_ranges: Tuple[float, float] = (0.01, 0.01) + imbalance_scan_steps: int = 11 + #: param that holds the LO frequency + lo_param: Optional[Callable] = None + #: parameter that holds the frequency + frequency_param: Optional[Callable] = None + # do you want to provide custom initial point? + # (doesn't affect scan2D) + opt2D_of_custom_init: bool = False + opt2D_imb_custom_init: bool = False + # do you want to do a larger scan (typically first calibration) or smaller scan (around already found point)? + # (doesn't affect scan2D) + opt2D_of_dia: str = 'large' + opt2D_imb_dia: str = 'large' + + +def calibrate_mixer(config: MixerConfig, + offset_scan_ranges=None, + offset_scan_steps=None, + imbalance_scan_ranges=None, + imbalance_scan_steps=None, + calibrate_offsets=True, + calibrate_imbalance=True): + """ + Runs the entire mixer calibration for any mixer + """ + print("Ensure that effective path lengths before I and Q of mixer are same.") + print(f"Calibrating {config.mixer_name} by {config.calibration_method}...") + + # TODO: Should be configurable + config.analyzer.zs_ref_level(-20) + config.analyzer.zs_sweep_time(0.01) + config.analyzer.zs_ifbw_auto(0) + config.analyzer.zs_ifbw(1e4) + + # setup the generator frequency and its power + if config.lo_param is not None: + mixer_lo_freq = config.lo_param() + config.generator.frequency(mixer_lo_freq) + elif config.frequency_param is not None: + mixer_lo_freq = config.frequency_param() + config.if_param() + config.generator.frequency(mixer_lo_freq) + else: + mixer_lo_freq = config.generator.frequency() + + # support for both SignalCore and R&S SGS + if hasattr(config.generator, 'output_status'): + config.generator.output_status(1) + elif hasattr(config.generator, 'on'): + config.generator.on() + + if config.generator_power is not None: + config.generator.power(config.generator_power) + + qmm = QuantumMachinesManager.QuantumMachinesManager(host=config.opx_address, port=config.opx_port) + qm = qmm.open_qm(config.qmconfig(), close_other_machines=False) + + try: + # initialize Mixer class object + cal = MixerCalibration(mixer_lo_freq, + config.if_param(), + config.analyzer, qm, + mixer_name=config.mixer_name, + element_name=config.element_name, + pulse_name=config.pulse_name, + ) + + # Call the appropriate calibration functions + # offsets part + if calibrate_offsets: + offsets = config.offsets_param() + cal.play_wf() + if config.calibration_method == 'scanning': + print("\nOffset calibration through: scanning \n") + if offset_scan_steps is None: + offset_scan_steps = config.offset_scan_steps + if offset_scan_ranges is None: + offset_scan_ranges = config.offset_scan_ranges + + print(f'Offsets: {offsets} Ranges: {offset_scan_ranges} \n') + + res_offsets = cal.lo_leakage_scan( + offsets, + ranges=offset_scan_ranges, + steps=offset_scan_steps, + ) + offsets = res_offsets.tolist() + else: + print("\nOffset calibration through: Nelder-Mead optimization \n") + if config.opt2D_of_custom_init is True: + pass + else: + offsets = [0, 0] + + custom_of_range = config.offset_scan_ranges + + if config.opt2D_of_dia == 'large': + custom_of_range = [0.05, 0.05] + elif config.opt2D_of_dia == 'small': + custom_of_range = [0.001, 0.001] + elif config.opt2D_of_dia == 'custom': + pass + + print(f'Offsets: {offsets} Ranges: {custom_of_range} \n') + + # for i in np.arange(1, 4, 1): + res_offsets = cal.optimize_lo_leakage( + offsets, + ranges=custom_of_range, + nm_options=dict(xatol=0.0001, fatol=1.0) + ) + # print(res_offsets) + + if isinstance(res_offsets, np.ndarray): + offsets = res_offsets.tolist() + elif res_offsets.success and res_offsets.nit < 200: + offsets = res_offsets.x.tolist() + # custom_of_range = (0.001, 0.001) + else: + print('Failed to converge. Use different initial values. \n') + return + + print(f'best values for offsets: {offsets} \n') + config.offsets_param(offsets) + print(f'verifying: {cal.lo_leakage(offsets)} \n') + + # imbalances part + if calibrate_imbalance: + imbalances = config.imbalances_param() + cal.play_wf() + if config.calibration_method == 'scanning': + print("\nImbalance calibration through: scanning \n") + if imbalance_scan_steps is None: + imbalance_scan_steps = config.imbalance_scan_steps + if imbalance_scan_ranges is None: + imbalance_scan_ranges = config.imbalance_scan_ranges + + print(f'Imbalances: {imbalances} Ranges: {imbalance_scan_ranges} \n') + + res_imbalances = cal.sb_imbalance_scan( + imbalances, + ranges=imbalance_scan_ranges, + steps=imbalance_scan_steps, + ) + imbalances = res_imbalances.tolist() + else: + print("\nImbalance calibration through: Nelder-Mead optimization \n") + if config.opt2D_imb_custom_init is True: + pass + else: + if config.generator.IDN().get('vendor') == 'Rohde&Schwarz': # type(config.generator).__name__ == 'RohdeSchwarz_SGS100A': + imbalances = [0, 1.57] + else: + imbalances = [0, 0] + + custom_imb_range = config.imbalance_scan_ranges + + if config.opt2D_imb_dia == 'large': + custom_imb_range = [0.05, 0.05] + elif config.opt2D_imb_dia == 'small': + custom_imb_range = [0.001, 0.001] + elif config.opt2D_imb_dia == 'custom': + pass + + # for i in np.arange(1, 4, 1): + + print(f'Imbalances: {imbalances} Ranges: {custom_imb_range} \n') + + res_imbalances = cal.optimize_sb_imbalance( + imbalances, + ranges=custom_imb_range, + nm_options=dict(xatol=0.0001, fatol=1.0) + ) + # print(res_imbalances) + + if isinstance(res_imbalances, np.ndarray): + imbalances = res_imbalances.tolist() + elif res_imbalances.success and res_imbalances.nit < 200: + imbalances = res_imbalances.x.tolist() + # custom_imb_range = (0.001, 0.001) + else: + print('Failed to converge. Use different initial values. \n') + return + + print(f'best values for imbalance: {imbalances} \n') + config.imbalances_param(imbalances) + print(f'verifying: {cal.sb_imbalance(imbalances)} \n') + + finally: + qm.close() + +def mixer_of_step(config: MixerConfig, qm: QuantumMachine, di, dq): + new_i = config.offsets_param()[0] + di + new_q = config.offsets_param()[1] + dq + qm.set_output_dc_offset_by_element(config.element_name, 'I', new_i) + qm.set_output_dc_offset_by_element(config.element_name, 'Q', new_q) + config.offsets_param([new_i, new_q]) + + +def mixer_imb_step(config: MixerConfig, qm: QuantumMachine, dg, dp): + new_g = config.imbalances_param()[0] + dg + new_p = config.imbalances_param()[1] + dp + if config.lo_param is not None: + lof = config.lo_param() + elif config.frequency_param is not None: + lof = config.frequency_param() + config.if_param() + else: + lof = config.generator.frequency() + + qm.set_mixer_correction(config.mixer_name, + int(config.if_param()), + int(lof), + tuple(MixerCalibration.IQ_imbalance_correction(new_g, new_p))) + config.imbalances_param([new_g, new_p]) diff --git a/labcore/opx/sweep.py b/labcore/opx/sweep.py new file mode 100644 index 0000000..f422f00 --- /dev/null +++ b/labcore/opx/sweep.py @@ -0,0 +1,227 @@ +from typing import Dict, Generator, Optional +import numpy as np +from dataclasses import dataclass + +from qm.qua import * +from qm.QuantumMachinesManager import QuantumMachinesManager + +from labcore.sweeping import * +from labcore.sweeping.record import make_data_spec +from labcore.sweeping.sweep import AsyncRecord + +from labcore.opx.config import QMConfig + + +### Options that need to be set by the user for the OPX to work + +# config object that when called returns the config dictionary as expected by the OPX +config: Optional[QMConfig] = None # OPX config dictionary + +# address and port of the OPX we're using +# opx_host: Optional[str] = None +# opx_port: Optional[str] = None + + +@dataclass +class TimedOPXData(DataSpec): + def __post_init__(self): + super().__post_init__() + if self.depends_on is None or len(self.depends_on) == 0: + deps = [] + else: + deps = list(self.depends_on) + self.depends_on = [self.name+'_time_points'] + deps + +@dataclass +class ComplexOPXData(DataSpec): + i_data_stream: str = 'I' + q_data_stream: str = 'Q' + + +class RecordOPXdata(AsyncRecord): + """ + Implementation of AsyncRecord for use with the OPX machine. + """ + + def __init__(self, *specs): + self.communicator = {} + # self.communicator['raw_variables'] = [] + self.user_data = [] + self.specs = [] + for s in specs: + spec = make_data_spec(s) + self.specs.append(spec) + if isinstance(spec, TimedOPXData): + tspec = indep(spec.name + "_time_points") + self.specs.append(tspec) + self.user_data.append(tspec.name) + + def setup(self, fun, *args, **kwargs) -> None: + """ + Establishes connection with the OPX and starts the the sweeping. The config of the OPX is passed through + the module variable global_config. It saves the result handles and saves initial values to the communicator + dictionary. + """ + # Start the sweeping in the OPX. + qmachine_mgr = QuantumMachinesManager(host=config.opx_address, port=config.opx_port) + qmachine = qmachine_mgr.open_qm(config(), close_other_machines=False) + job = qmachine.execute(fun(*args, **kwargs)) + result_handles = job.result_handles + + # Save the result handle and create initial parameters in the communicator used in the collector. + self.communicator['result_handles'] = result_handles + self.communicator['active'] = True + self.communicator['counter'] = 0 + self.communicator['manager'] = qmachine_mgr + self.communicator['qmachine'] = qmachine + self.communicator['qmachine_id'] = qmachine.id + + # FIXME change this such that we make sure that we have enough data on all handles + def _wait_for_data(self, batchsize: int) -> None: + """ + Waits for the opx to have measured more data points than the ones indicated in the batchsize. Also checks that + the OPX is still collecting data, when the OPX is no longer processing, turn communicator['active'] to False to + exhaust the collector. + + :param batchsize: Size of batch. How many data-points is the minimum for the sweep to get in an iteration. + e.g. if 5, _control_progress will keep running until at least 5 new data-points + are available for collection. + """ + + # When ready becomes True, the infinite loop stops. + ready = False + + # Collect necessary values from communicator. + res_handle = self.communicator['result_handles'] + counter = self.communicator['counter'] + + while not ready: + statuses = [] + processing = [] + for name, handle in res_handle: + current_datapoint = handle.count_so_far() + + # Check if the OPX is still processing. + if res_handle.is_processing(): + processing.append(True) + + # Check if enough data-points are available. + if current_datapoint - counter >= batchsize: + statuses.append(True) + else: + statuses.append(False) + + else: + # Once the OPX is done processing turn ready True and turn active False to exhaust the generator. + statuses.append(True) + processing.append(False) + # self.communicator['active'] = False + + if not False in statuses: + ready = True + if not True in processing: + self.communicator['active'] = False + + def cleanup(self): + """ + Functions in charge of cleaning up any software tools that needs cleanup. + + Currently, manually closes the qmachine in the OPT so that simultaneous measurements can occur. + """ + manager = self.communicator['manager'] + qm_id = self.communicator['qmachine_id'] + open_machines = manager.list_open_quantum_machines() + if qm_id in open_machines: + qmachine = manager.get_qm(qm_id) + qmachine.close() + + def collect(self, batchsize: int = 100) -> Generator[Dict, None, None]: + """ + Implementation of collector for the OPX. Collects new data-points from the OPX and yields them in a dictionary + with the names of the recorded variables as keywords and numpy arrays with the values. Raises ValueError if a + stream name inside the QUA program has a different name than a recorded variable and if the amount of recorded + variables and streams are different. + + :param batchsize: Size of batch. How many data-points is the minimum for the sweep to get in an iteration. + e.g. if 5, _control_progress will keep running until at least 5 new data-points + are available for collection. + """ + + # Get the result_handles from the communicator. + result_handle = self.communicator['result_handles'] + try: + while self.communicator['active']: + # Restart values for each iteration. + return_data = {} + counter = self.communicator['counter'] # Previous iteration data-point number. + first = True + available_points = 0 + ds: Optional[DataSpec] = None + + # Make sure that the result_handle is active. + if result_handle is None: + yield None + + # Waits until new data-points are ready to be gathered. + self._wait_for_data(batchsize) + + def get_data_from_handle(name, up_to): + if up_to == counter: + return None + handle = result_handle.get(name) + handle.wait_for_values(up_to) + data = np.squeeze(handle.fetch(slice(counter, up_to))['value']) + return data + + for i, ds in enumerate(self.specs): + if isinstance(ds, ComplexOPXData): + iname = ds.i_data_stream + qname = ds.q_data_stream + if i == 0: + available_points = result_handle.get(iname).count_so_far() + idata = get_data_from_handle(iname, up_to=available_points) + qdata = get_data_from_handle(qname, up_to=available_points) + if (qdata is None or idata is None): + print(f'qdata is: {qdata}') + print(f'idata is: {idata}') + print(f'available points is:{available_points}') + print(f'i is: {i}') + print(f'ds is: {ds}') + print(f'iname is: {iname}') + print(f'qname is: {qdata}') + print(f'am I active: {self.communicator["active"]}') + print(f'counter is: {self.communicator["counter"]}') + + if qdata is not None and idata is not None: + return_data[ds.name] = idata + 1j*qdata + + elif ds.name in self.user_data: + continue + + elif ds.name not in result_handle: + raise RuntimeError(f'{ds.name} specified but cannot be found in result handle.') + + else: + name = ds.name + if i == 0: + available_points = result_handle.get(name).count_so_far() + return_data[name] = get_data_from_handle(name, up_to=available_points) + + if isinstance(ds, TimedOPXData): + data = return_data[ds.name] + if data is not None: + tvals = np.arange(1, data.shape[-1]+1) + if len(data.shape) == 1: + return_data[name + '_time_points'] = tvals + elif len(data.shape) == 2: + return_data[name + '_time_points'] = np.tile(tvals, data.shape[0]).reshape(data.shape[0], -1) + else: + raise NotImplementedError('someone needs to look at data saving ASAP...') + + self.communicator['counter'] = available_points + yield return_data + + finally: + self.cleanup() + + diff --git a/labcore/plotting/basics.py b/labcore/plotting/basics.py new file mode 100644 index 0000000..787750d --- /dev/null +++ b/labcore/plotting/basics.py @@ -0,0 +1,502 @@ +from typing import Tuple, List, Optional, Union +import logging + +import numpy as np +from numpy import ndarray +from numpy import complexfloating +import matplotlib as mpl +from matplotlib import pyplot as plt +from matplotlib.figure import Figure +from matplotlib.axes import Axes +from matplotlib import gridspec, cm, colors, ticker +from matplotlib.colors import rgb2hex +import seaborn as sns + +from plottr.analyzer.fitters.fitter_base import FitResult, Fit + + +default_cmap = cm.viridis + +logger = logging.getLogger(__name__) + +def _fit_and_plot(x: Union[List, Tuple, ndarray], y: Union[List, Tuple, ndarray], + ax: Axes, residual_ax: Optional[Axes] = None, + data_color: str = 'tab:blue', data_label: str = 'data', fit_class: Optional[Fit] = None, + xlabel: str = '', ylabel: str = '', + initial_guess: bool = False, **guesses) -> FitResult: + """ + Helper function that plots and fits the data passed in the axis passed. + + Parameters + ---------- + x: + Array-like. Data for the x-axis. + y: + Array-like. Data for the y-axis. Can be complex. + ax: + The axis where to plot the data. + residual_ax: + axes for plotting the residuals; will only be plotted if axes are supplied. + data_color: + The color of the data line. + fit_class: + plottr Fit class of the intended fit. Defaults to None. + xlabel: + Label for the x-axis. Defaults to ''. + ylabel: + Label for the y-axis. Defaults to ''. + initial_guess: + If True, the initial guess of the fit will also be plotted. Defaults to False. + guesses: + Kwargs for custom initial parameters for fitting. + + Returns + ------- + FitResult + The FitResult of the fitting. + """ + + fit_result = None + line_handles = {} + data_line, = ax.plot(x, y, '.', color=data_color) + line_handles[data_label] = data_line + + if fit_class is not None: + fit = fit_class(x, y) + + if initial_guess: + guess_result = fit.run(dry=True, **guesses) + guess_y = guess_result.eval(coordinates=x) + initial_guess_line, = ax.plot(x, guess_y, '--', color='tab:green') + line_handles['i.g.'] = initial_guess_line + + fit_result = fit.run(**guesses) + fit_y = fit_result.eval() + + lbl = "best fit:" + for key, param in fit_result.params.items(): + lbl += "\n" + f"{key} = {param.value:.2E}" + fit_line, = ax.plot(x, fit_y, color='red') + line_handles[lbl] = fit_line + + add_legend(ax, legend_ref_point='upper left', **line_handles) + # ax.legend(loc='best', fontsize='x-small') + + if residual_ax is not None: + residuals = fit_y - y + residual_ax.plot(x, residuals, '.') + + return fit_result + + +def plot_data_and_fit_1d(x: Union[List, Tuple, ndarray], y: Union[List, Tuple, ndarray], + fit_class: Optional[Fit] = None, + xlabel: str ='', + ylabel: str='', + initial_guess: bool = False, + fig: Optional[Figure] = None, + **guesses) -> Tuple[Figure, FitResult]: + """ + Fits and plots 1 dimensional data. + + If the data passed is complex, two subplots will be created, one with the real data and the other one with the + imaginary data (the y-axis of each plot will be labeled indicating which one is which, as well as the legend). + If a standard plottr fitting class is passed as an argument, the function will fit and return the fit result. + + Parameters + ---------- + x: + Array-like. Data for the x-axis. + y: + Array-like. Data for the y-axis. Can be complex. + fit_class: + plottr Fit class of the intended fit. Defaults to None. + xlabel: + Label for the x-axis. + ylabel: + Label for the y-axis. + initial_guess: + If True, the initial guess of the fit will also be plotted. Defaults to False. + figure: + If a figure is supplied, plots will be generated in that one; otherwise a new figure is created. + guesses: + Kwargs for custom initial parameters for fitting. + + Returns + ------- + Tuple[Figure, FitResult] + The first item of the tuple contains the matplotlib Figure. The second item contains the fit result from the + fitting. If the data is complex, the second item is a List with both fit results in it. + If no fit_class is passed, the second item of the return Tuple is None. + """ + + if fig is None: + fig = plt.figure() + + if any(np.iscomplex(y)): + y_ = y.real + logger.warning('Ignoring imaginary part of the data.') + else: + y_ = y + + ax = fig.add_subplot(211) + rax = fig.add_subplot(212, sharex=ax) + + fit_result = _fit_and_plot(x, y, ax, residual_ax=rax, + data_label='data', fit_class=fit_class, + initial_guess=initial_guess, **guesses) + + format_ax(ax, xlabel=xlabel, ylabel=ylabel) + format_ax(rax, xlabel=xlabel, ylabel=f'{ylabel} residuals') + + if fit_result is not None: + print(fit_result.lmfit_result.fit_report()) + + return fig, fit_result + + +def readout_hist(signal: ndarray, title: Optional[str] = '') -> Figure: + """ + Plots an IQ histogram. + + Parameters + ---------- + signal: + array-like, data in complex form. + title: + The title of the figure. Defaults to ''. + + Returns + ------- + Figure + The matplotlib Figure with the plot. + """ + I = signal.real + Q = signal.imag + lim = max((I**2. + Q**2.)**.5) + fig, ax = plt.subplots(1,1, constrained_layout=True) + fig.suptitle(title, size='small') + ax.set_xlabel('I') + ax.set_ylabel('Q') + ax.axvline(0, color='w') + ax.axhline(0, color='w') + im = ax.hist2d(I, Q, bins=101, range=[[-lim, lim], [-lim, lim]]) + + return fig + + +# tools for prettier plotting +def pplot(ax, x, y, yerr=None, linex=None, liney=None, color=None, fmt='o', + alpha=0.5, mew=0.5, **kw): + + zorder = kw.pop('zorder', 2) + line_dashes = kw.pop('line_dashes', []) + line_lw = kw.pop('line_lw', 2) + line_alpha = kw.pop('line_alpha', 0.5) + line_color = kw.pop('line_color', color) + line_zorder = kw.pop('line_zorder', 1) + line_from_ypts = kw.pop('line_from_ypts', False) + elinewidth = kw.pop('elinewidth', 0.5) + label = kw.pop('label', None) + label_x = kw.pop('label_x', x[-1]) + label_y_ofs = kw.pop('label_y_ofs', 0) + label_kw = kw.pop('label_kw', {}) + fill_color = kw.pop('fill_color', None) + + syms = [] + + if linex is None: + linex = x + + if type(liney) == str: + if liney == 'data': + liney = y + + edge_plot_kws = dict(mfc='None', mew=mew, zorder=zorder) + edge_plot_kws.update(kw) + if colors is not None: + edge_plot_kws['mec'] = color + edge, = ax.plot(x, y, fmt, **edge_plot_kws) + color = edge.get_color() + + # TODO: the z-ordering with this method isn't too great (error bars may + # be hidden behind the line...) + if yerr is not None: + err = ax.errorbar(x, y, yerr=yerr, fmt='none', ecolor=color, capsize=0, + elinewidth=elinewidth, zorder=zorder-1) + empty_symbol_kws = edge_plot_kws.copy() + empty_symbol_kws.update({'mfc': 'w', 'mew': 0, 'zorder': zorder-1}, ) + _ = ax.plot(x, y, fmt, **empty_symbol_kws) + # syms.append(err) + + if liney is None and line_from_ypts: + liney = y.copy() + + if liney is not None: + if line_color is None: + line_color = color + line, = ax.plot(linex, liney, dashes=line_dashes, lw=line_lw, + color=line_color, zorder=line_zorder, alpha=line_alpha) + syms.append(line) + + if fill_color is None: + fill_color = color + + fill, = ax.plot(x, y, fmt, mec='none', mfc=fill_color, alpha=alpha, + zorder=zorder-1, **kw) + + syms.append(fill) + syms.append(edge) + + if label is not None: + label_idx = np.argmin(np.abs(x - label_x)) + ax.annotate(label, (label_x, y[label_idx] + label_y_ofs), + color=color, **label_kw) + + return tuple(syms) + + +def ppcolormesh(ax, x, y, z, cmap=default_cmap, make_grid=True, **kw): + if make_grid: + _x, _y = pcolorgrid(x, y) + else: + _x, _y = x, y + + im = ax.pcolormesh(_x, _y, z, cmap=cmap, **kw) + ax.set_xlim(_x.min(), _x.max()) + ax.set_ylim(_y.min(), _y.max()) + + return im + + +def waterfall(ax, xs, ys, offset=None, style='pplot', **kw): + cmap = kw.pop('cmap', default_cmap) + linex = kw.pop('linex', xs) + liney = kw.pop('liney', None) + draw_baselines = kw.pop('draw_baselines', False) + baseline_kwargs = kw.pop('baseline_kwargs', {}) + + ntraces = ys.shape[0] + if offset is None: + offset = ys.max() - ys.min() + + if 'color' not in kw: + colorseq = get_color_cycle(ntraces, colormap=cmap) + else: + c = kw.pop('color', None) + colorseq = [c for n in range(ntraces)] + + for iy, yvals in enumerate(ys): + x = xs if len(xs.shape) == 1 else xs[iy] + y = yvals + iy * offset + lx = linex if len(linex.shape) == 1 else linex[iy] + ly = None if liney is None else liney[iy] + iy * offset + color = colorseq[iy] + + if draw_baselines: + baseline_opts = dict(color=color, lw=1, dashes=[1, 1]) + for k, v in baseline_kwargs: + baseline_opts[k] = v + ax.axhline(iy * offset, **baseline_opts) + + if style == 'pplot': + pplot(ax, x, y, linex=lx, liney=ly, color=color, **kw) + elif style == 'lines': + ax.plot(x, y, '-', color=color, **kw) + + +def plot_wigner(ax, xs, ys, zs, norm=None, clim=None, **kw): + cmap = kw.pop('cmap', cm.bwr) + xticks = kw.pop('xticks', None) + yticks = kw.pop('yticks', None) + xticklabels = kw.pop('xticklabels', None) + yticklabels = kw.pop('yticklabels', None) + + if norm is None and clim is None: + clim = max(abs(zs.min()), zs.max()) + elif norm is None: + norm = colors.Normalize(vmin=-abs(clim), vmax=abs(clim)) + + im = ppcolormesh(ax, xs, ys, zs, norm=norm, cmap=cmap) + + if xticks is None: + xtick = max(xs) // 1 + xticks = [-xtick, 0, xtick] + if yticks is None: + ytick = max(ys) // 1 + yticks = [-ytick, 0, ytick] + + ax.set_xticks(xticks) + ax.set_yticks(yticks) + + if xticklabels is not None: + ax.set_xticklabels(xticklabels) + if yticklabels is not None: + ax.set_yticklabels(yticklabels) + + return im + + +# some common tools +# ================= + +# color management tools +def get_color_cycle(n, colormap, start=0., stop=1., format='hex'): + if type(colormap) == str: + colormap = getattr(cm, colormap) + + pts = np.linspace(start, stop, n) + if format == 'hex': + colors = [rgb2hex(colormap(pt)) for pt in pts] + return colors + + +# tools for color plots +def centers2edges(arr): + e = (arr[1:] + arr[:-1]) / 2. + e = np.concatenate(([arr[0] - (e[0] - arr[0])], e)) + e = np.concatenate((e, [arr[-1] + (arr[-1] - e[-1])])) + return e + + +def pcolorgrid(xaxis, yaxis): + xedges = centers2edges(xaxis) + yedges = centers2edges(yaxis) + xx, yy = np.meshgrid(xedges, yedges) + return xx, yy + + +# creating and formatting figures +def correctly_sized_figure(widths, heights, margins=0.5, dw=0.2, dh=0.2, make_axes=True): + """ + Create a figure and grid where all dimensions are specified in inches. + Arguments: + widths: list of column widths + heights: list of row heights + margins: either a scalar or a list of four numbers (l, r, t, b) + dw: white space between subplots, horizontal + dh: white space between subplots, vertical + make_axes: bool; if True, create axes on the grid and return, + else return the gridspec. + """ + wsum = sum(widths) + hsum = sum(heights) + nrows = len(heights) + ncols = len(widths) + if type(margins) == list: + l, r, t, b = margins + else: + l = r = t = b = margins + + figw = wsum + (ncols - 1) * dw + l + r + figh = hsum + (nrows - 1) * dh + t + b + + # margins in fraction of the figure + top = 1. - t / figh + bottom = b / figh + left = l / figw + right = 1. - r / figw + + # subplot spacing in fraction of the subplot size + wspace = dw / np.average(widths) + hspace = dh / np.average(heights) + + fig = plt.figure(figsize=(figw, figh)) + gs = gridspec.GridSpec(nrows, ncols, + height_ratios=heights, width_ratios=widths) + gs.update(top=top, bottom=bottom, left=left, right=right, + wspace=wspace, hspace=hspace) + + if make_axes: + axes = [] + for i in range(nrows): + for j in range(ncols): + axes.append(fig.add_subplot(gs[i, j])) + + return fig, axes + + else: + return fig, gs + + +def format_ax(ax, top=False, right=False, xlog=False, ylog=False, + xlabel=None, ylabel=None, xlim=None, ylim=None, xticks=3, yticks=3): + + ax.tick_params(axis='x', which='both', pad=2, + top=top, labeltop=top, bottom=not top, labelbottom=not top) + if top: + ax.xaxis.set_label_position('top') + + ax.tick_params(axis='y', which='both', pad=2, + right=right, labelright=right, left=not right, labelleft=not right) + if right: + ax.yaxis.set_label_position('right') + + if isinstance(xticks, list): + ax.xaxis.set_major_locator(ticker.FixedLocator(xticks)) + if xlim is not None: + ax.set_xlim(xlim) + elif xlim is not None: + ax.xaxis.set_major_locator(ticker.LinearLocator(xticks)) + ax.set_xlim(xlim) + else: + ax.xaxis.set_major_locator(ticker.MaxNLocator(xticks)) + + if isinstance(yticks, list): + ax.yaxis.set_major_locator(ticker.FixedLocator(yticks)) + if ylim is not None: + ax.set_xlim(ylim) + elif ylim is not None: + ax.yaxis.set_major_locator(ticker.LinearLocator(yticks)) + ax.set_ylim(ylim) + else: + ax.yaxis.set_major_locator(ticker.MaxNLocator(yticks)) + + if xlabel is not None: + ax.set_xlabel(xlabel) + if ylabel is not None: + ax.set_ylabel(ylabel) + + ax.xaxis.labelpad = 2 + ax.yaxis.labelpad = 2 + + +def format_right_cax(cax): + format_ax(cax, right=True) + cax.tick_params(axis='x', top='off', bottom='off', labelbottom='off', + labeltop='off') + + +def add_legend(ax, anchor_point=(1, 1), legend_ref_point='lower right', **labels_and_handles): + if len(labels_and_handles) > 0: + handles = [] + labels = [] + for l, h in labels_and_handles.items(): + handles.append(h) + labels.append(l) + ax.legend(handles, labels, bbox_to_anchor=anchor_point, borderpad=0, loc=legend_ref_point) + else: + ax.legend(bbox_to_anchor=anchor_point, borderpad=0, loc=legend_ref_point) + + +def setup_plotting(sns_style='whitegrid', rcparams={}): + # some sensible defaults for sizing, those are for a typical print-plot + mpl.rcParams['figure.constrained_layout.use'] = True + mpl.rcParams['figure.dpi'] = 300 + mpl.rcParams['figure.figsize'] = (3, 2) + mpl.rcParams['font.family'] = 'Arial', 'Helvetica' + mpl.rcParams['font.size'] = 6 + mpl.rcParams['lines.markersize'] = 3 + mpl.rcParams['lines.linewidth'] = 1.5 + mpl.rcParams['axes.linewidth'] = 0.5 + mpl.rcParams['grid.linewidth'] = 0.5 + mpl.rcParams['legend.fontsize'] = 5 + mpl.rcParams['legend.frameon'] = False + mpl.rcParams['xtick.major.width'] = 0.5 + mpl.rcParams['ytick.major.width'] = 0.5 + mpl.rcParams['xtick.major.size'] = 2 + mpl.rcParams['ytick.major.size'] = 2 + mpl.rcParams["mathtext.fontset"] = 'dejavusans' + + sns.set_style(sns_style) + mpl.rcParams.update(rcparams) diff --git a/labcore/setup/__init__.py b/labcore/setup/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/labcore/setup/setup_measurements.py b/labcore/setup/setup_measurements.py new file mode 100644 index 0000000..1cff93c --- /dev/null +++ b/labcore/setup/setup_measurements.py @@ -0,0 +1,131 @@ +import os +import sys +import logging +from typing import Optional, Any, Union, Dict, Tuple +from dataclasses import dataclass +from pathlib import Path + +from instrumentserver.client import Client, ProxyInstrument + +from labcore.ddh5 import run_and_save_sweep +from labcore.measurement import Sweep + +from plottr.data.datadict import DataDict + +from .analysis.data import data_info + + +# constants +WD = os.getcwd() +DATADIR = os.path.join(WD, 'data') + + +@dataclass +class Options: + instrument_clients: Optional[Dict[str, Client]] = None + parameters: Optional[ProxyInstrument] = None + +options = Options() + + +# this function sets up our general logging +def setup_logging() -> logging.Logger: + """Setup logging in a reasonable way. Note: we use the root logger since + our measurements typically run in the console directly and we want + logging to work from scripts that are directly run in the console. + + Returns + ------- + The logger that has been setup. + """ + logger = logging.getLogger() + logger.setLevel(logging.INFO) + + for h in logger.handlers: + logger.removeHandler(h) + del h + + fmt = logging.Formatter( + "%(asctime)s.%(msecs)03d\t| %(name)s\t| %(levelname)s\t| %(message)s", + datefmt='%Y-%m-%d %H:%M:%S', + ) + fh = logging.FileHandler('measurement.log') + fh.setFormatter(fmt) + fh.setLevel(logging.INFO) + logger.addHandler(fh) + + fmt = logging.Formatter( + "[%(asctime)s.%(msecs)03d] [%(name)s: %(levelname)s] %(message)s", + datefmt='%Y-%m-%d %H:%M:%S', + ) + streamHandler = logging.StreamHandler(sys.stdout) + streamHandler.setFormatter(fmt) + streamHandler.setLevel(logging.INFO) + logger.addHandler(streamHandler) + logger.info(f"Logging set up for {logger}.") + return logger + +# Create the logger +logger = setup_logging() + +def find_or_create_remote_instrument(cli: Client, ins_name: str, ins_class: Optional[str]=None, + *args: Any, **kwargs: Any) -> ProxyInstrument: + """Finds or creates an instrument in an instrument server. + + Parameters + ---------- + cli + instance of the client pointing to the instrument server + ins_name + name of the instrument to find or to create + ins_class + the class of the instrument (import path as string) if creating a new instrument + args + will be passed to the instrument creation call + kwargs + will be passed to the instrument creation call + + Returns + ------- + Proxy to the remote instrument + """ + if ins_name in cli.list_instruments(): + return cli.get_instrument(ins_name) + + if ins_class is None: + raise ValueError('Need a class to create a new instrument') + + ins = cli.create_instrument( + instrument_class=ins_class, + name=ins_name, *args, **kwargs) + + return ins + + +def run_measurement(sweep: Sweep, name: str, **kwargs) -> Tuple[Union[str, Path], Optional[DataDict]]: + if options.instrument_clients is None: + raise RuntimeError('it looks like options.instrument_clients is not configured.') + if options.parameters is None: + raise RuntimeError('it looks like options.parameters is not configured.') + + for n, c in options.instrument_clients.items(): + kwargs[n] = c.snapshot + kwargs['parameters'] = options.parameters.toParamDict + + data_location, data = run_and_save_sweep( + sweep=sweep, + data_dir=DATADIR, + name=name, + save_action_kwargs=True, + **kwargs) + + info = data + + logger.info(f""" +========== +Saved data at {data_location}: +{data_info(data_location, do_print=False)} +=========""") + return data_location, data + + diff --git a/labcore/setup/setup_notebook_analysis.py b/labcore/setup/setup_notebook_analysis.py new file mode 100644 index 0000000..eca491e --- /dev/null +++ b/labcore/setup/setup_notebook_analysis.py @@ -0,0 +1,5 @@ + + +from .analysis.plotting import setup_plotting + +setup_plotting(rcparams={'figure.dpi': 200}) diff --git a/labcore/setup/setup_opx_measurements.py b/labcore/setup/setup_opx_measurements.py new file mode 100644 index 0000000..20a1188 --- /dev/null +++ b/labcore/setup/setup_opx_measurements.py @@ -0,0 +1,150 @@ +"""general setup file for OPX measurements. + +Use by importing and then configuring the options object. +""" + +# this is to prevent the OPX logger to also create log messages (results in duplicate messages) +import os +os.environ['QM_DISABLE_STREAMOUTPUT'] = "1" + +from IPython.display import display +import ipywidgets as widgets + +from qm.QuantumMachinesManager import QuantumMachinesManager, QuantumMachine +from qm.qua import * + +from instrumentserver.helpers import nestedAttributeFromString + + + +from labcore.opx.config import QMConfig +from .opx_tools import sweep as qmsweep +from labcore.opx.mixer import MixerConfig, mixer_of_step, mixer_imb_step + +from . import setup_measurements +from .setup_measurements import * + +@dataclass +class Options(setup_measurements.Options): + _qm_config: Optional[QMConfig] = None + + # this is implemented as a property so we automatically set the + # options correctly everywhere else... + @property + def qm_config(self): + return self._qm_config + + @qm_config.setter + def qm_config(self, cfg): + self._qm_config = cfg + qmsweep.config = cfg + +options = Options() +setup_measurements.options = options + +@dataclass +class Mixer: + config: MixerConfig + qm: Optional[QuantumMachine] = None + + def run_constant_waveform(self): + with program() as const_pulse: + with infinite_loop_(): + play('constant', self.config.element_name) + qmm = QuantumMachinesManager(host=self.config.qmconfig.opx_address, + port=self.config.qmconfig.opx_port) + qm = qmm.open_qm(self.config.qmconfig(), close_other_machines=False) + qm.execute(const_pulse) + self.qm = qm + + def step_of(self, di, dq): + if self.qm is None: + raise RuntimeError('No active QuantumMachine.') + mixer_of_step(self.config, self.qm, di, dq) + + def step_imb(self, dg, dp): + if self.qm is None: + raise RuntimeError('No active QuantumMachine.') + mixer_imb_step(self.config, self.qm, dg, dp) + +def add_mixer_config(element_name, analyzer, generator, **config_kwargs): + cfg = MixerConfig( + qmconfig=options.qm_config, + opx_address=options.qm_config.opx_address, + opx_port=options.qm_config.opx_port, + analyzer=analyzer, + generator=generator, + if_param=nestedAttributeFromString(options.parameters, f"{element_name}.IF"), + offsets_param=nestedAttributeFromString(options.parameters, f"mixers.{element_name}.offsets"), + imbalances_param=nestedAttributeFromString(options.parameters, f"mixers.{element_name}.imbalance"), + mixer_name=f'{element_name}_IQ_mixer', + element_name=element_name, + pulse_name='constant', + **config_kwargs + ) + return Mixer( + config=cfg, + ) + + +# A simple graphical mixer tuning tool +def mixer_tuning_tool(mixer): + # widgets for dc offset tuning + of_step = widgets.FloatText(description='dc of. step:', value=0.01, min=0, max=1, step=0.001) + iup_btn = widgets.Button(description='I ^') + idn_btn = widgets.Button(description='I v') + qup_btn = widgets.Button(description='Q ^') + qdn_btn = widgets.Button(description='Q v') + + def on_I_up(b): + mixer.step_of(of_step.value, 0) + + def on_I_dn(b): + mixer.step_of(-of_step.value, 0) + + def on_Q_up(b): + mixer.step_of(0, of_step.value) + + def on_Q_dn(b): + mixer.step_of(0, -of_step.value) + + iup_btn.on_click(on_I_up) + idn_btn.on_click(on_I_dn) + qup_btn.on_click(on_Q_up) + qdn_btn.on_click(on_Q_dn) + + # widgets for imbalance tuning + imb_step = widgets.FloatText(description='imb. step:', value=0.01, min=0, max=1, step=0.001) + gup_btn = widgets.Button(description='g ^') + gdn_btn = widgets.Button(description='g v') + pup_btn = widgets.Button(description='phi ^') + pdn_btn = widgets.Button(description='phi v') + + def on_g_up(b): + mixer.step_imb(imb_step.value, 0) + + def on_g_dn(b): + mixer.step_imb(-imb_step.value, 0) + + def on_p_up(b): + mixer.step_imb(0, imb_step.value) + + def on_p_dn(b): + mixer.step_imb(0, -imb_step.value) + + gup_btn.on_click(on_g_up) + gdn_btn.on_click(on_g_dn) + pup_btn.on_click(on_p_up) + pdn_btn.on_click(on_p_dn) + + # assemble reasonably for display + ofupbox = widgets.HBox([iup_btn, qup_btn]) + ofdnbox = widgets.HBox([idn_btn, qdn_btn]) + ofbox = widgets.VBox([of_step, ofupbox, ofdnbox]) + + imbupbox = widgets.HBox([gup_btn, pup_btn]) + imbdnbox = widgets.HBox([gdn_btn, pdn_btn]) + imbbox = widgets.VBox([imb_step, imbupbox, imbdnbox]) + + box = widgets.HBox([ofbox, imbbox]) + display(box) diff --git a/labcore/measurement/__init__.py b/labcore/sweeping/__init__.py similarity index 100% rename from labcore/measurement/__init__.py rename to labcore/sweeping/__init__.py diff --git a/labcore/ddh5.py b/labcore/sweeping/ddh5.py similarity index 97% rename from labcore/ddh5.py rename to labcore/sweeping/ddh5.py index 64b7fed..e33a2be 100644 --- a/labcore/ddh5.py +++ b/labcore/sweeping/ddh5.py @@ -32,7 +32,7 @@ from plottr.data.datadict import DataDict, is_meta_key from plottr.data.datadict_storage import DDH5Writer -from .measurement.sweep import Sweep +from labcore.sweeping.sweep import Sweep __author__ = 'Wolfgang Pfaff' __license__ = 'MIT' @@ -134,7 +134,7 @@ def run_and_save_sweep(sweep: Sweep, :param archive_files: List of files to copy into a folder called 'archived_files' in the same directory that the data is saved. It should be a list of paths (str), regular expressions are supported. If a folder is passed, it will copy the entire folder and all of its subdirectories and files into the - archived_files folder. If one of the arguments could not be found, a message will be printed and the measurement + archived_files folder. If one of the arguments could not be found, a message will be printed and the sweeping will be performed without the file being archived. An exception is raised if the type is invalid. e.g. archive_files=['*.txt', 'calibration_files', '../test_file.py']. '*.txt' will copy every txt file @@ -228,7 +228,7 @@ def run_and_save_sweep(sweep: Sweep, ret = (dir, data_dict) if return_data else (dir, None) return ret - logger.info('The measurement has finished successfully and all of the data has been saved.') + logger.info('The sweeping has finished successfully and all of the data has been saved.') ret = (dir, data_dict) if return_data else (dir, None) return ret diff --git a/labcore/measurement/record.py b/labcore/sweeping/record.py similarity index 100% rename from labcore/measurement/record.py rename to labcore/sweeping/record.py diff --git a/labcore/measurement/sweep.py b/labcore/sweeping/sweep.py similarity index 99% rename from labcore/measurement/sweep.py rename to labcore/sweeping/sweep.py index 7f157a0..7c93d7b 100644 --- a/labcore/measurement/sweep.py +++ b/labcore/sweeping/sweep.py @@ -546,7 +546,7 @@ class AsyncRecord: """ Base class decorator used to record asynchronous data from instrument. Use the decorator with create_background_sweep function to create Sweeps that collect asynchronous data from - external devices running experiments independently of the measurement PC, + external devices running experiments independently of the sweeping PC, e.i. the measuring happening is not being controlled by a Sweep but instead an external device (e.g. the OPX). Each instrument should have its own custom setup_wrapper (see setup_wrapper docstring for more info), and a custom collector. @@ -592,7 +592,7 @@ def wrap_setup(self, fun: Callable, *args: Any, **kwargs: Any) -> Callable: Setup should accept the \*args and \**kwargs of fun. It should also place any returns from fun in the communicator. setup_wrapper needs to return the wrapped function (setup). - :param fun: The measurement function. In the case of the OPX this would be the function that returns the QUA + :param fun: The sweeping function. In the case of the OPX this would be the function that returns the QUA code with any arguments that it might use. """ self.wrapped_setup = partial(self.setup, fun, *args, **kwargs) diff --git a/prototyping/configuration.py b/prototyping/configuration.py index bc853fc..2d17390 100644 --- a/prototyping/configuration.py +++ b/prototyping/configuration.py @@ -69,7 +69,7 @@ def config(self): 'pulses': { 'box_pulse': { - 'operation': 'measurement', + 'operation': 'sweeping', 'length': self.box_length, 'waveforms': { 'single': 'box_wf' diff --git a/test/pytest/test_run_and_save.py b/test/pytest/test_run_and_save.py index d7e0b5b..f49710b 100644 --- a/test/pytest/test_run_and_save.py +++ b/test/pytest/test_run_and_save.py @@ -12,10 +12,9 @@ import shutil import numpy as np -import pytest -from labcore.measurement import recording, independent, dependent, sweep_parameter -from labcore.ddh5 import run_and_save_sweep +from labcore.sweeping import recording, independent, dependent, sweep_parameter +from labcore.sweeping.ddh5 import run_and_save_sweep class NonJsonObject: From a586633f86fdd3cc2781305b3bbbb5da025a0acd Mon Sep 17 00:00:00 2001 From: pfafflab Date: Thu, 8 Dec 2022 17:58:10 -0600 Subject: [PATCH 2/7] Cleaning up imports and files --- ...guring sweeps and passing parameters.ipynb | 2 +- .../Sweeps/Introduction to sweeping.ipynb | 2 +- ...Simple OPX setup demo without mixers.ipynb | 10 +- .../parameter_manager-simple_demo_params.json | 0 .../qmcfg_simple_demo.py | 0 .../Basic qubit tuning.ipynb | 861 ------------------ .../Instrument control and calibration.ipynb | 604 ------------ .../parameter_manager-parameter_manager.json | 98 -- .../opx_examples_and_templates/qmcfg.py | 214 ----- labcore/analysis/single_transmon.py | 91 -- labcore/opx/mixer.py | 609 ------------- labcore/opx/sweep.py | 2 +- labcore/plotting/__init__.py | 3 + labcore/setup/setup_measurements.py | 6 +- labcore/setup/setup_opx_measurements.py | 2 +- labcore/{sweeping => sweep}/__init__.py | 0 labcore/{sweeping => sweep}/ddh5.py | 0 labcore/{sweeping => sweep}/record.py | 0 labcore/{sweeping => sweep}/sweep.py | 0 19 files changed, 15 insertions(+), 2489 deletions(-) rename doc/examples/{opx_examples_and_templates => opx_demo}/Simple OPX setup demo without mixers.ipynb (99%) rename doc/examples/{opx_examples_and_templates => opx_demo}/parameter_manager-simple_demo_params.json (100%) rename doc/examples/{opx_examples_and_templates => opx_demo}/qmcfg_simple_demo.py (100%) delete mode 100644 doc/examples/opx_examples_and_templates/Basic qubit tuning.ipynb delete mode 100644 doc/examples/opx_examples_and_templates/Instrument control and calibration.ipynb delete mode 100755 doc/examples/opx_examples_and_templates/parameter_manager-parameter_manager.json delete mode 100755 doc/examples/opx_examples_and_templates/qmcfg.py delete mode 100644 labcore/analysis/single_transmon.py delete mode 100644 labcore/opx/mixer.py rename labcore/{sweeping => sweep}/__init__.py (100%) rename labcore/{sweeping => sweep}/ddh5.py (100%) rename labcore/{sweeping => sweep}/record.py (100%) rename labcore/{sweeping => sweep}/sweep.py (100%) diff --git a/doc/examples/Sweeps/Configuring sweeps and passing parameters.ipynb b/doc/examples/Sweeps/Configuring sweeps and passing parameters.ipynb index 7f7519d..fe9393f 100644 --- a/doc/examples/Sweeps/Configuring sweeps and passing parameters.ipynb +++ b/doc/examples/Sweeps/Configuring sweeps and passing parameters.ipynb @@ -34,7 +34,7 @@ "metadata": {}, "outputs": [], "source": [ - "from labcore.measurement import *" + "from labcore.sweep import *" ] }, { diff --git a/doc/examples/Sweeps/Introduction to sweeping.ipynb b/doc/examples/Sweeps/Introduction to sweeping.ipynb index 109307f..e598354 100644 --- a/doc/examples/Sweeps/Introduction to sweeping.ipynb +++ b/doc/examples/Sweeps/Introduction to sweeping.ipynb @@ -33,7 +33,7 @@ "import numpy as np\n", "import qcodes as qc\n", "\n", - "from labcore.measurement import *" + "from labcore.sweep import *" ] }, { diff --git a/doc/examples/opx_examples_and_templates/Simple OPX setup demo without mixers.ipynb b/doc/examples/opx_demo/Simple OPX setup demo without mixers.ipynb similarity index 99% rename from doc/examples/opx_examples_and_templates/Simple OPX setup demo without mixers.ipynb rename to doc/examples/opx_demo/Simple OPX setup demo without mixers.ipynb index 8ce2185..48b78ae 100644 --- a/doc/examples/opx_examples_and_templates/Simple OPX setup demo without mixers.ipynb +++ b/doc/examples/opx_demo/Simple OPX setup demo without mixers.ipynb @@ -116,10 +116,10 @@ "import numpy as np\n", "from matplotlib import pyplot as plt\n", "\n", - "from qcuiuc_measurement.analysis.data import get_data, data_info, DatasetAnalysis\n", - "from qcuiuc_measurement.analysis.plotting import setup_plotting, format_ax, add_legend, ppcolormesh\n", + "from labcore.analysis.data import get_data, data_info, DatasetAnalysis\n", + "from labcore.plotting.basics import setup_plotting, format_ax, add_legend, ppcolormesh\n", "\n", - "from qcuiuc_measurement.setup_notebook_analysis import *" + "from labcore.setup.setup_notebook_analysis import *" ] }, { @@ -200,8 +200,8 @@ ], "source": [ "from qm.qua import *\n", - "from labcore.measurement import independent\n", - "from qcuiuc_measurement.opx_tools.sweep import \\\n", + "from labcore.sweep import independent\n", + "from labcore.opx.sweep import \\\n", " RecordOPXdata, ComplexOPXData, TimedOPXData\n", "\n", "@RecordOPXdata(\n", diff --git a/doc/examples/opx_examples_and_templates/parameter_manager-simple_demo_params.json b/doc/examples/opx_demo/parameter_manager-simple_demo_params.json similarity index 100% rename from doc/examples/opx_examples_and_templates/parameter_manager-simple_demo_params.json rename to doc/examples/opx_demo/parameter_manager-simple_demo_params.json diff --git a/doc/examples/opx_examples_and_templates/qmcfg_simple_demo.py b/doc/examples/opx_demo/qmcfg_simple_demo.py similarity index 100% rename from doc/examples/opx_examples_and_templates/qmcfg_simple_demo.py rename to doc/examples/opx_demo/qmcfg_simple_demo.py diff --git a/doc/examples/opx_examples_and_templates/Basic qubit tuning.ipynb b/doc/examples/opx_examples_and_templates/Basic qubit tuning.ipynb deleted file mode 100644 index 077008a..0000000 --- a/doc/examples/opx_examples_and_templates/Basic qubit tuning.ipynb +++ /dev/null @@ -1,861 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "e62be073-e9a5-492c-a8f5-a08defc17f92", - "metadata": { - "tags": [] - }, - "source": [ - "# Init" - ] - }, - { - "cell_type": "markdown", - "id": "0b76e486-1e0c-471c-8b6a-d0bd160d6317", - "metadata": { - "tags": [] - }, - "source": [ - "## Gathering our instruments" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0ef8ed30-c77f-4e98-ab81-483bd96f43fb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2022-12-05 10:22:28.712] [root: INFO] Logging set up for .\n", - "[2022-12-05 10:22:28.714] [instrumentserver.client.core: INFO] Connecting to tcp://localhost:5555\n" - ] - } - ], - "source": [ - "### basic init and get the important instruments\n", - "from importlib import reload\n", - "\n", - "from instrumentserver.client import Client\n", - "from labcore.setup import setup_opx_measurements\n", - "from labcore.setup.setup_opx_measurements import *\n", - "\n", - "instruments = Client()\n", - "params = find_or_create_remote_instrument(instruments, 'parameter_manager')\n", - "\n", - "# make sure you specify the correct IP and port for your OPX system.\n", - "import qmcfg; reload(qmcfg)\n", - "qm_config = qmcfg.QMConfig(params, '128.174.248.249', '80')\n", - "\n", - "# these need to be specified so all measurement code is configured correctly\n", - "setup_opx_measurements.options.instrument_clients = {'instruments': instruments}\n", - "setup_opx_measurements.options.parameters = params\n", - "setup_opx_measurements.options.qm_config = qm_config" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "4332a5c2-addb-46d4-b04d-872a182923a5", - "metadata": {}, - "outputs": [], - "source": [ - "readout_generator = find_or_create_remote_instrument(\n", - " cli=instruments,\n", - " ins_name='readout_generator'\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "77ae965e-5267-459f-a1de-8d74c0f76b14", - "metadata": {}, - "source": [ - "## Imports and settings that are important for this notebook" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "476bb7bc-ef45-46bb-bcfe-f5e2733b8cc3", - "metadata": {}, - "outputs": [], - "source": [ - "### stuff for measuring\n", - "\n", - "from labcore.measurement import *\n", - "\n", - "from qcuiuc_measurement.opx_msmt import single_transmon\n", - "\n", - "def setup_qubit_measurement_defaults(repetition_delay=500_000):\n", - " # Default readout settings\n", - " single_transmon.options.repetition_delay = repetition_delay\n", - " single_transmon.options.readout_element = 'readout'\n", - " single_transmon.options.readout_pulse = 'readout_short'\n", - " single_transmon.options.readout_integration_weight = None\n", - " single_transmon.options.prepare = single_transmon.prep_by_wait\n", - " single_transmon.options.measure_qubit = single_transmon.measure_full_integration\n", - " \n", - " # FIXME: this is clearly a bug in the single_transmon module\n", - " single_transmon.measure_qubit = single_transmon.measure_full_integration\n", - "\n", - " # Readout generator settings\n", - " readout_generator.power(4.)\n", - " readout_generator.output_status(1)\n", - " readout_generator.frequency(params.readout.LO())\n", - " \n", - "setup_qubit_measurement_defaults()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1a92a2d9-ae1a-4ffc-badf-038a61deaa51", - "metadata": {}, - "outputs": [], - "source": [ - "### basic plotting and analysis setup\n", - "\n", - "import numpy as np\n", - "from matplotlib import pyplot as plt\n", - "\n", - "from lmfit import Parameter\n", - "\n", - "from labcore.analysis.data import get_data, data_info, DatasetAnalysis\n", - "from labcore.analysis.plotting import setup_plotting, format_ax, add_legend, ppcolormesh, plot_data_and_fit_1d\n", - "from labcore.analysis.resonators import fit_and_plot_resonator_response\n", - "\n", - "from labcore.setup.setup_notebook_analysis import *" - ] - }, - { - "cell_type": "markdown", - "id": "b5cd731b-fcc2-4ff3-89a0-f0756172a429", - "metadata": {}, - "source": [ - "# Basic spectroscopy" - ] - }, - { - "cell_type": "markdown", - "id": "e7cf55a4-3ee5-4dbe-b8db-e639f4290db9", - "metadata": { - "tags": [] - }, - "source": [ - "## Pulsed resonator spectroscopy" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "9b815d88-5117-4a99-a60b-eecc10522f4e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2022-12-05 13:10:56.085] [plottr.data.datadict_storage: INFO] Data location: /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T131056_8b80d684-pulsed_resonator_spec/data.ddh5\n", - "[2022-12-05 13:10:56.146] [qm: INFO] Performing health check\n", - "[2022-12-05 13:10:56.149] [qm: INFO] Health check passed\n", - "[2022-12-05 13:10:56.163] [root: INFO] Integration weights file not found, using flat weights.\n", - "[2022-12-05 13:10:56.170] [qm: INFO] Performing health check\n", - "[2022-12-05 13:10:56.173] [qm: INFO] Health check passed\n", - "[2022-12-05 13:10:56.459] [qm: INFO] Flags: \n", - "[2022-12-05 13:10:56.459] [qm: INFO] Sending program to QOP\n", - "[2022-12-05 13:10:56.537] [qm: INFO] Executing program\n", - "[2022-12-05 13:10:58.381] [labcore.ddh5: INFO] The measurement has finished successfully and all of the data has been saved.\n", - "[2022-12-05 13:10:58.388] [root: INFO] \n", - "==========\n", - "Saved data at /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T131056_8b80d684-pulsed_resonator_spec:\n", - "signal: (100, 800)\n", - " ⌙ repetition: (100, 800)\n", - " ⌙ ssb_frequency: (100, 800)\n", - "=========\n" - ] - } - ], - "source": [ - "setup_qubit_measurement_defaults(repetition_delay=10_000)\n", - "\n", - "single_transmon.options.readout_pulse = 'readout_short'\n", - "single_transmon.measure_qubit = single_transmon.measure_full_integration\n", - "\n", - "measurement = single_transmon.pulsed_resonator_spec(\n", - " start=40e6,\n", - " stop=60e6,\n", - " step=0.025e6,\n", - " n_reps=100,\n", - " collector_options=dict(batchsize=100),\n", - ")\n", - "\n", - "data_loc, _ = run_measurement(sweep=measurement, name='pulsed_resonator_spec')" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "id": "f5ad17d4-fbd8-4608-954f-a21550a99dd4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "with DatasetAnalysis(data_loc) as analysis:\n", - " data = analysis.get_data('signal', avg_over='repetition')\n", - " f = data.data_vals('ssb_frequency')\n", - " sig = data.data_vals('signal') \n", - " \n", - " fig = analysis.make_figure('SSB signal', figsize=(3,3))\n", - " \n", - " # first subfig: magnitude\n", - " ax = fig.add_subplot(211)\n", - " ax.plot(f*1e-6, np.abs(sig))\n", - " ax.axvline(params.readout.IF()*1e-6, color='r')\n", - " format_ax(ax, ylabel='magnitude (a.u.)')\n", - " \n", - " ax = fig.add_subplot(212, sharex=ax)\n", - " ax.plot(f*1e-6, np.angle(sig, deg=False))\n", - " ax.axvline(params.readout.IF()*1e-6, color='r')\n", - " format_ax(ax, xlabel='frequency (MHz)', ylabel='phase (rad)')\n", - " \n", - " # this command saves the figures associated with the analysis in the data folder.\n", - " # analysis.save()" - ] - }, - { - "cell_type": "markdown", - "id": "f7d42ec3-57d8-4c6d-8e4b-96406fdc0de9", - "metadata": { - "jp-MarkdownHeadingCollapsed": true, - "tags": [] - }, - "source": [ - "## Pulsed resonator spectroscopy as a function of power" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "196b1bcf-dc0a-4960-baea-ef020eba461c", - "metadata": {}, - "outputs": [], - "source": [ - "setup_qubit_measurement_defaults(repetition_delay=10_000)\n", - "\n", - "single_transmon.options.readout_pulse = 'readout_short'\n", - "single_transmon.measure_qubit = single_transmon.measure_full_integration\n", - "\n", - "measurement = single_transmon.pulsed_resonator_spec(\n", - " start=40e6,\n", - " stop=60e6,\n", - " step=0.025e6,\n", - " n_reps=100,\n", - " collector_options=dict(batchsize=100),\n", - ")\n", - "\n", - "sweep = sweep_parameter(params.readout.short.amp, np.linspace(0.01, 0.05, 10)) \\\n", - " @ measurement\n", - "data_loc, _ = run_measurement(sweep=sweep, name='pulsed_resonator_spec_vs_pwr')" - ] - }, - { - "cell_type": "markdown", - "id": "749f1ff8-8611-4cc5-b2fc-c6a42349e827", - "metadata": { - "jp-MarkdownHeadingCollapsed": true, - "tags": [] - }, - "source": [ - "## Qubit spec (saturation)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "48e6d679-1581-4753-a30b-f6ea62ac2e4a", - "metadata": {}, - "outputs": [], - "source": [ - "setup_qubit_measurement_defaults()\n", - "\n", - "measurement = single_transmon.qubit_ssb_spec_saturation(\n", - " start=50e6,\n", - " stop=150e6,\n", - " step=0.1e6,\n", - " n_reps=100,\n", - " collector_options=dict(batchsize=100)\n", - ")\n", - "\n", - "data_loc, _ = run_measurement(sweep=measurement, name=f'qubit_ssb_saturation_spec')" - ] - }, - { - "cell_type": "markdown", - "id": "6a93fd34-1376-48a0-9dd7-94fe29e97c99", - "metadata": { - "tags": [] - }, - "source": [ - "## Qubit spec (pi)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1172b127-fb2c-457a-8047-61179ce30186", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "cec24c6b-045e-4273-902c-b6e5846cf776", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2022-12-05 09:51:38.787] [plottr.data.datadict_storage: INFO] Data location: /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T095138_b465ef56-qubit_ssb_spec_pi/data.ddh5\n", - "[2022-12-05 09:51:38.840] [qm: INFO] Performing health check\n", - "[2022-12-05 09:51:38.843] [qm: INFO] Health check passed\n", - "[2022-12-05 09:51:38.860] [root: INFO] Integration weights file not found, using flat weights.\n", - "[2022-12-05 09:51:38.869] [qm: INFO] Performing health check\n", - "[2022-12-05 09:51:38.872] [qm: INFO] Health check passed\n", - "[2022-12-05 09:51:39.214] [qm: INFO] Flags: \n", - "[2022-12-05 09:51:39.214] [qm: INFO] Sending program to QOP\n", - "[2022-12-05 09:51:39.671] [qm: INFO] Executing program\n", - "[2022-12-05 09:51:44.973] [labcore.ddh5: INFO] The measurement has finished successfully and all of the data has been saved.\n", - "[2022-12-05 09:51:44.977] [root: INFO] \n", - "==========\n", - "Saved data at /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T095138_b465ef56-qubit_ssb_spec_pi:\n", - "signal: (100, 100)\n", - " ⌙ repetition: (100, 100)\n", - " ⌙ ssb_frequency: (100, 100)\n", - "=========\n" - ] - } - ], - "source": [ - "setup_qubit_measurement_defaults()\n", - "\n", - "# automatically try to do spec around the center\n", - "center = params.qubit.IF()\n", - "\n", - "# dynamically make a weaker pipulse to narrow the line\n", - "weaken_by = 5\n", - "amplitude = 1. / weaken_by\n", - "duration = params.qubit.drive.pipulse.nsigmas() * params.qubit.drive.pipulse.sigma() * weaken_by // 4\n", - "\n", - "\n", - "# run the measurement\n", - "measurement = single_transmon.qubit_ssb_spec_pi(\n", - " start=center-5e6,\n", - " stop=center+5e6,\n", - " step=0.1e6,\n", - " amplitude=amplitude,\n", - " duration=duration,\n", - " n_reps=100,\n", - " collector_options=dict(batchsize=100)\n", - ")\n", - "data_loc, _ = run_measurement(sweep=measurement, name='qubit_ssb_spec_pi')" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "89470892-1b1b-467b-a756-8ced87ee754f", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[Model]]\n", - " Model(model)\n", - "[[Fit Statistics]]\n", - " # fitting method = leastsq\n", - " # function evals = 21\n", - " # data points = 100\n", - " # variables = 4\n", - " chi-square = 6.6390e-11\n", - " reduced chi-square = 6.9156e-13\n", - " Akaike info crit = -2796.06502\n", - " Bayesian info crit = -2785.64434\n", - "[[Variables]]\n", - " x0: 1.7395e+08 +/- 13771.5996 (0.01%) (init = 1.739e+08)\n", - " sigma: 412737.870 +/- 14402.5321 (3.49%) (init = 495000)\n", - " A: -1.3032e-05 +/- 3.8240e-07 (2.93%) (init = -1.179549e-05)\n", - " of: 1.2519e-05 +/- 9.4128e-08 (0.75%) (init = 1.117075e-05)\n", - "[[Correlations]] (unreported correlations are < 0.100)\n", - " C(sigma, A) = 0.493\n", - " C(sigma, of) = 0.293\n", - " C(A, of) = -0.174\n", - "[2022-12-05 10:23:19.903] [root: INFO] updated qubit IF frequency to 173950814.28219295\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from qcuiuc_measurement.analysis.common_fits import Gaussian\n", - "\n", - "with DatasetAnalysis(data_loc) as analysis:\n", - " data = analysis.get_data('signal', avg_over='repetition')\n", - " f = data.data_vals('ssb_frequency')\n", - " sig = data.data_vals('signal').real\n", - " \n", - " fig = analysis.make_figure('Pi spec fit', figsize=(4,3))\n", - " _, fitres = plot_data_and_fit_1d(\n", - " f, sig, fit_class=Gaussian,\n", - " fig=fig, \n", - " initial_guess=True, # enable this if the guess goes wrong to see why...\n", - " xlabel='SSB frequency (Hz)', \n", - " ylabel='signal (a.u.)',\n", - " )\n", - " # TODO: save the fit report to a file as well...\n", - " \n", - " # set the corrected SSB frequency to the parameter manager\n", - " new_f0 = fitres.params['x0'].value\n", - " params.qubit.IF(new_f0)\n", - " logger.info(f'updated qubit IF frequency to {new_f0}')\n", - "\n", - " analysis.save()" - ] - }, - { - "cell_type": "markdown", - "id": "908e250a-bc84-401c-a4bb-3a47c4b6f75d", - "metadata": {}, - "source": [ - "# Qubit tune-up operations" - ] - }, - { - "cell_type": "markdown", - "id": "f1adf923-ebcb-4433-926b-0eb2fbb75563", - "metadata": {}, - "source": [ - "## Power Rabi and pi-pulse calibration" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "id": "2c509795-4fca-4c1a-99f5-5dba99d1bbfc", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2022-12-05 16:12:47.530] [plottr.data.datadict_storage: INFO] Data location: /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T161247_f33b2a36-power_rabi/data.ddh5\n", - "[2022-12-05 16:12:47.596] [qm: INFO] Performing health check\n", - "[2022-12-05 16:12:47.598] [qm: INFO] Health check passed\n", - "[2022-12-05 16:12:47.614] [root: INFO] Integration weights file not found, using flat weights.\n", - "[2022-12-05 16:12:47.622] [qm: INFO] Performing health check\n", - "[2022-12-05 16:12:47.624] [qm: INFO] Health check passed\n", - "[2022-12-05 16:12:47.894] [qm: INFO] Flags: \n", - "[2022-12-05 16:12:47.895] [qm: INFO] Sending program to QOP\n", - "[2022-12-05 16:12:47.953] [qm: INFO] Executing program\n", - "[2022-12-05 16:12:50.424] [labcore.ddh5: INFO] The measurement has finished successfully and all of the data has been saved.\n", - "[2022-12-05 16:12:50.434] [root: INFO] \n", - "==========\n", - "Saved data at /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T161247_f33b2a36-power_rabi:\n", - "signal: (100, 38)\n", - " ⌙ repetition: (100, 38)\n", - " ⌙ amplitude: (100, 38)\n", - "=========\n" - ] - } - ], - "source": [ - "setup_qubit_measurement_defaults()\n", - "\n", - "measurement = single_transmon.qubit_power_rabi(\n", - " start=-1.9,\n", - " stop=1.9,\n", - " step=0.1,\n", - " n_reps=100,\n", - " collector_options=dict(batchsize=100)\n", - ")\n", - "data_loc, _ = run_measurement(sweep=measurement, name='power_rabi')" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "a0f7a020-88b1-496b-9036-8f725d393a8b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[Model]]\n", - " Model(model)\n", - "[[Fit Statistics]]\n", - " # fitting method = leastsq\n", - " # function evals = 21\n", - " # data points = 38\n", - " # variables = 3\n", - " chi-square = 1.5934e-11\n", - " reduced chi-square = 4.5527e-13\n", - " Akaike info crit = -1077.00479\n", - " Bayesian info crit = -1072.09203\n", - "[[Variables]]\n", - " A: -6.1758e-06 +/- 1.6145e-07 (2.61%) (init = 6.489716e-06)\n", - " of: 8.7733e-06 +/- 1.1980e-07 (1.37%) (init = 9.115889e-06)\n", - " phi: 0 (fixed)\n", - " f: 0.49792511 +/- 0.00377657 (0.76%) (init = 0.5263158)\n", - "[[Correlations]] (unreported correlations are < 0.100)\n", - " C(of, f) = 0.400\n", - " C(A, f) = 0.158\n", - " C(A, of) = 0.136\n", - "[2022-12-05 16:12:52.581] [root: INFO] updated pi amp from 0.026566260807652134 to 0.026676964555142905\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from qcuiuc_measurement.analysis.common_fits import Cosine\n", - "\n", - "with DatasetAnalysis(data_loc) as analysis:\n", - " data = analysis.get_data('signal', avg_over='repetition')\n", - " amp = data.data_vals('amplitude')\n", - " sig = data.data_vals('signal').real\n", - " \n", - " # fix the phase, since we measure with positive and negative amplitude\n", - " phi = Parameter(name='phi', value=0, vary=False)\n", - " \n", - " fig = analysis.make_figure('Power rabi fit', figsize=(4,3))\n", - " _, fitres = plot_data_and_fit_1d(amp, sig, fit_class=Cosine, \n", - " fig=fig, \n", - " # initial_guess=True, # enable this if the guess goes wrong to see why...\n", - " phi=phi,\n", - " xlabel='amp (a.u.)', \n", - " ylabel='signal (a.u.)',\n", - " )\n", - " # TODO: save the fit report to a file as well...\n", - " \n", - " # calculate correction for the pi-pulse amplitude\n", - " # and set the corrected value to the parameter manager\n", - " old_pi_amp = analysis.load_saved_parameter('qubit.drive.pipulse.amp')\n", - " correction = 0.5 / fitres.params['f'].value\n", - " params.qubit.drive.pipulse.amp(old_pi_amp * correction)\n", - " logger.info(f'updated pi amp from {old_pi_amp} to {old_pi_amp * correction}')\n", - " \n", - " analysis.save()" - ] - }, - { - "cell_type": "markdown", - "id": "a47e06d9-497c-4bc3-b974-5f2b5a1684ac", - "metadata": {}, - "source": [ - "# Qubit characterization" - ] - }, - { - "cell_type": "markdown", - "id": "822daeac-fde6-42cb-9555-8228cd2b0994", - "metadata": {}, - "source": [ - "## Qubit T1" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "48322c9b-ee8c-44f5-abee-ed61719cedce", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2022-12-05 10:53:11.457] [plottr.data.datadict_storage: INFO] Data location: /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T105311_4d66ce70-qubit_T1/data.ddh5\n", - "[2022-12-05 10:53:11.509] [qm: INFO] Performing health check\n", - "[2022-12-05 10:53:11.513] [qm: INFO] Health check passed\n", - "[2022-12-05 10:53:11.529] [root: INFO] Integration weights file not found, using flat weights.\n", - "[2022-12-05 10:53:11.540] [qm: INFO] Performing health check\n", - "[2022-12-05 10:53:11.542] [qm: INFO] Health check passed\n", - "[2022-12-05 10:53:11.880] [qm: INFO] Flags: \n", - "[2022-12-05 10:53:11.881] [qm: INFO] Sending program to QOP\n", - "[2022-12-05 10:53:12.288] [qm: INFO] Executing program\n", - "[2022-12-05 10:53:18.074] [labcore.ddh5: INFO] The measurement has finished successfully and all of the data has been saved.\n", - "[2022-12-05 10:53:18.077] [root: INFO] \n", - "==========\n", - "Saved data at /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T105311_4d66ce70-qubit_T1:\n", - "signal: (100, 100)\n", - " ⌙ repetition: (100, 100)\n", - " ⌙ delay: (100, 100)\n", - "=========\n" - ] - } - ], - "source": [ - "setup_qubit_measurement_defaults()\n", - "\n", - "measurement = single_transmon.qubit_T1(\n", - " start=20,\n", - " stop=20+100e3,\n", - " step=1000,\n", - " n_reps=100,\n", - " collector_options=dict(batchsize=100)\n", - ")\n", - "\n", - "data_loc, _ = run_measurement(sweep=measurement, name='qubit_T1')" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "9aba6f14-9407-467d-89f2-a5e60fbfe5c2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[Model]]\n", - " Model(model)\n", - "[[Fit Statistics]]\n", - " # fitting method = leastsq\n", - " # function evals = 17\n", - " # data points = 100\n", - " # variables = 3\n", - " chi-square = 7.3283e-11\n", - " reduced chi-square = 7.5549e-13\n", - " Akaike info crit = -2788.18632\n", - " Bayesian info crit = -2780.37081\n", - "[[Variables]]\n", - " A: -1.2255e-05 +/- 3.7303e-07 (3.04%) (init = -1.426641e-05)\n", - " of: 1.2468e-05 +/- 1.7012e-07 (1.36%) (init = 1.259413e-05)\n", - " tau: 19.9773626 +/- 1.33714135 (6.69%) (init = 15.02)\n", - "[[Correlations]] (unreported correlations are < 0.100)\n", - " C(of, tau) = 0.754\n", - " C(A, tau) = 0.380\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from qcuiuc_measurement.analysis.common_fits import ExponentialDecay\n", - "\n", - "with DatasetAnalysis(data_loc) as analysis:\n", - " data = analysis.get_data('signal', avg_over='repetition')\n", - " delay = data.data_vals('delay') * 1e-3\n", - " sig = data.data_vals('signal').real\n", - " \n", - " fig = analysis.make_figure('T1 fit', figsize=(4,3))\n", - " _, fitres = plot_data_and_fit_1d(\n", - " delay, sig, fit_class=ExponentialDecay, \n", - " fig=fig, \n", - " # initial_guess=True, # enable this if the guess goes wrong to see why...\n", - " xlabel='delay (us)', \n", - " ylabel='signal (a.u.)',\n", - " )\n", - " # TODO: save the fit report to a file as well...\n", - " \n", - " analysis.save()" - ] - }, - { - "cell_type": "markdown", - "id": "fca039f0-b320-4893-973e-abacace389e3", - "metadata": {}, - "source": [ - "## Qubit T2" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "a97289ff-eaf4-4e6b-bde5-ae6f11e714b5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2022-12-05 12:42:22.832] [plottr.data.datadict_storage: INFO] Data location: /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T124222_8e532cee-qubit_T2-1_Echo_0.42MHz_detuned/data.ddh5\n", - "[2022-12-05 12:42:22.891] [qm: INFO] Performing health check\n", - "[2022-12-05 12:42:22.894] [qm: INFO] Health check passed\n", - "[2022-12-05 12:42:22.908] [root: INFO] Integration weights file not found, using flat weights.\n", - "[2022-12-05 12:42:22.916] [qm: INFO] Performing health check\n", - "[2022-12-05 12:42:22.920] [qm: INFO] Health check passed\n", - "[2022-12-05 12:42:23.225] [qm: INFO] Flags: \n", - "[2022-12-05 12:42:23.225] [qm: INFO] Sending program to QOP\n", - "[2022-12-05 12:42:23.375] [qm: INFO] Executing program\n", - "[2022-12-05 12:42:29.238] [labcore.ddh5: INFO] The measurement has finished successfully and all of the data has been saved.\n", - "[2022-12-05 12:42:29.241] [root: INFO] \n", - "==========\n", - "Saved data at /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T124222_8e532cee-qubit_T2-1_Echo_0.42MHz_detuned:\n", - "signal: (100, 100)\n", - " ⌙ repetition: (100, 100)\n", - " ⌙ delay: (100, 100)\n", - "=========\n" - ] - } - ], - "source": [ - "setup_qubit_measurement_defaults()\n", - "\n", - "n_echos = 1\n", - "step = 200\n", - "period = 12 * step\n", - "detuning = 1./period * 1e3\n", - "\n", - "measurement = single_transmon.qubit_T2(\n", - " start=20,\n", - " stop=20+(40e3//(n_echos + 1)),\n", - " step=step,\n", - " n_reps=100,\n", - " detuning_MHz=detuning,\n", - " n_echos=n_echos,\n", - " collector_options=dict(batchsize=100)\n", - ")\n", - "\n", - "data_loc, _ = run_measurement(sweep=measurement, name=f'qubit_T2-{n_echos}_Echo_{detuning:.2f}MHz_detuned')" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "f92a22b0-137c-409f-ba5b-b5e7c731a4b7", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[Model]]\n", - " Model(model)\n", - "[[Fit Statistics]]\n", - " # fitting method = leastsq\n", - " # function evals = 162\n", - " # data points = 100\n", - " # variables = 5\n", - " chi-square = 8.5925e-11\n", - " reduced chi-square = 9.0447e-13\n", - " Akaike info crit = -2768.27165\n", - " Bayesian info crit = -2755.24580\n", - "[[Variables]]\n", - " A: -6.3807e-06 +/- 3.7114e-07 (5.82%) (init = -6.018747e-06)\n", - " of: 6.2250e-06 +/- 9.5360e-08 (1.53%) (init = 6.170345e-06)\n", - " phi: 88.3274493 +/- 3.47371810 (3.93%) (init = -37.78915)\n", - " f: 0.20879616 +/- 6.9269e-04 (0.33%) (init = 0.35)\n", - " tau: 23.8581666 +/- 2.43607959 (10.21%) (init = 20.04)\n", - "[[Correlations]] (unreported correlations are < 0.100)\n", - " C(phi, f) = -0.760\n", - " C(A, tau) = 0.745\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from qcuiuc_measurement.analysis.common_fits import ExponentiallyDecayingSine\n", - "\n", - "with DatasetAnalysis(data_loc) as analysis:\n", - " data = analysis.get_data('signal', avg_over='repetition')\n", - " delay = data.data_vals('delay') * 1e-3\n", - " sig = data.data_vals('signal').real\n", - " \n", - " fig = analysis.make_figure('T2 fit', figsize=(4,3))\n", - " _, fitres = plot_data_and_fit_1d(\n", - " delay, sig, fit_class=ExponentiallyDecayingSine, \n", - " fig=fig, \n", - " # initial_guess=True, # enable this if the guess goes wrong to see why...\n", - " xlabel='delay (us)', \n", - " ylabel='signal (a.u.)',\n", - " )\n", - " # TODO: save the fit report to a file as well...\n", - " \n", - " analysis.save()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bfd77830-f831-4395-97d2-17dbdeac655e", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:qcodes]", - "language": "python", - "name": "conda-env-qcodes-py" - }, - "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.9.15" - }, - "toc-autonumbering": true - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/doc/examples/opx_examples_and_templates/Instrument control and calibration.ipynb b/doc/examples/opx_examples_and_templates/Instrument control and calibration.ipynb deleted file mode 100644 index d2ecd14..0000000 --- a/doc/examples/opx_examples_and_templates/Instrument control and calibration.ipynb +++ /dev/null @@ -1,604 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "2071e4f2-8bf7-4d17-9904-9b1d9945a566", - "metadata": { - "tags": [] - }, - "source": [ - "# Tools" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "333492aa-29f1-440f-8a82-d14e55ef2df6", - "metadata": {}, - "outputs": [], - "source": [ - "import tabulate\n", - "\n", - "def instrument_info_table(instrument, *properties):\n", - " data = [['name', instrument.name]]\n", - " for p in properties:\n", - " data.append([p, instrument.get(p)])\n", - " return tabulate.tabulate(data, tablefmt='html')\n", - " \n", - "signalcore_info = lambda ins: instrument_info_table(\n", - " ins, 'frequency', 'power', 'output_status', 'temperature', 'reference_source',\n", - ") " - ] - }, - { - "cell_type": "markdown", - "id": "2aaf53c1-514b-4f3e-92b5-caa9d49e6ea0", - "metadata": {}, - "source": [ - "# Load instruments" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "8d0911ea-8450-44b7-aacf-924e0a64c409", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2022-12-05 13:05:15.953] [root: INFO] Logging set up for .\n", - "[2022-12-05 13:05:15.954] [instrumentserver.client.core: INFO] Connecting to tcp://localhost:5555\n" - ] - } - ], - "source": [ - "### basic init and get the important instruments\n", - "from importlib import reload\n", - "\n", - "from instrumentserver.client import Client\n", - "from labcore.setup import setup_opx_measurements\n", - "from labcore.setup.setup_opx_measurements import *\n", - "\n", - "instruments = Client()\n", - "params = find_or_create_remote_instrument(instruments, 'parameter_manager')\n", - "\n", - "# make sure you specify the correct IP and port for your OPX system.\n", - "import qmcfg; reload(qmcfg)\n", - "qm_config = qmcfg.QMConfig(params, '128.174.248.249', '80')\n", - "\n", - "# these need to be specified so all measurement code is configured correctly\n", - "setup_opx_measurements.options.instrument_clients = {'instruments': instruments}\n", - "setup_opx_measurements.options.parameters = params\n", - "setup_opx_measurements.options.qm_config = qm_config" - ] - }, - { - "cell_type": "markdown", - "id": "5809901c-20c0-4a3f-85cc-c575fdeb11ed", - "metadata": {}, - "source": [ - "## Hardware" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "b0a40755-0e4d-4621-b831-d42bc8ed4a88", - "metadata": {}, - "outputs": [], - "source": [ - "### load spike -- running remotely on a windows laptop\n", - "spike = find_or_create_remote_instrument(\n", - " cli=instruments,\n", - " ins_name='spike',\n", - " ins_class='tfe_hardware.qcodes_instrument_drivers.SignalHound.Spike.Spike',\n", - " address='TCPIP::192.168.1.202::5025::SOCKET'\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ba246b5c-e146-4087-a36f-1d90017cda24", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "c2ba109b-a91c-4553-94dd-1ba510f95907", - "metadata": {}, - "source": [ - "### Generators" - ] - }, - { - "cell_type": "markdown", - "id": "a2d1007e-58f4-4e92-a619-f894a2fb447c", - "metadata": {}, - "source": [ - "#### readout generator" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "e28e2105-7900-42ec-a50b-73ed11f30659", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
name readout_generator
frequency 7219500000.0
power 4.0
output_status 1
temperature 31.09375
reference_source1
" - ], - "text/plain": [ - "'\\n\\n\\n\\n\\n\\n\\n\\n\\n
name readout_generator
frequency 7219500000.0
power 4.0
output_status 1
temperature 31.09375
reference_source1
'" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "### the various microwave generators\n", - "readout_generator = find_or_create_remote_instrument(\n", - " cli=instruments,\n", - " ins_name='readout_generator',\n", - " ins_class='tfe_hardware.qcodes_instrument_drivers.SignalCore.SignalCore_sc5511a.SignalCore_SC5511A',\n", - " serial_number='10002615',\n", - ")\n", - "signalcore_info(readout_generator)" - ] - }, - { - "cell_type": "markdown", - "id": "682a13d3-2c60-4291-b25d-d3f3afb4db30", - "metadata": { - "tags": [] - }, - "source": [ - "#### qubit generator" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b81095fe-8b10-432a-bbb0-25b977236503", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "qubit_generator = find_or_create_remote_instrument(\n", - " cli=instruments,\n", - " ins_name='qubit_generator',\n", - " ins_class='tfe_hardware.qcodes_instrument_drivers.SignalCore.SignalCore_sc5511a.SignalCore_SC5511A',\n", - " serial_number='10002613',\n", - ")\n", - "signalcore_info(qubit_generator)" - ] - }, - { - "cell_type": "markdown", - "id": "b89aea8e-517f-486a-b686-1f5d33b9e2d5", - "metadata": { - "tags": [] - }, - "source": [ - "#### TWPA pump generator" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "id": "ffe520cb-057d-426a-8590-5b9699dac392", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
name twpa_generator
frequency 8000000000.0
power 3.0
output_status 0
temperature 74.875
reference_source1
" - ], - "text/plain": [ - "'\\n\\n\\n\\n\\n\\n\\n\\n\\n
name twpa_generator
frequency 8000000000.0
power 3.0
output_status 0
temperature 74.875
reference_source1
'" - ] - }, - "execution_count": 42, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "twpa_generator = find_or_create_remote_instrument(\n", - " cli=instruments,\n", - " ins_name='twpa_generator',\n", - " ins_class='tfe_hardware.qcodes_instrument_drivers.SignalCore.SignalCore_sc5511a.SignalCore_SC5511A',\n", - " serial_number='1000261D',\n", - ")\n", - "signalcore_info(twpa_generator)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "53d6b019-29fa-4606-ad91-14e43320f946", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "e7c1bb13-b31b-45b3-a0bb-2a2f66af108f", - "metadata": {}, - "source": [ - "## Mixer configuration" - ] - }, - { - "cell_type": "markdown", - "id": "6dce04aa-a9dd-4616-8c43-dacbceed7552", - "metadata": {}, - "source": [ - "### readout mixer" - ] - }, - { - "cell_type": "markdown", - "id": "64d6169c-91a2-4468-a2f8-2bbd47c93892", - "metadata": {}, - "source": [ - "#### mixer setup and manual tuning tool\n", - "\n", - "This snipped will create a mixer object that allows us to do most things.\n", - "It'll also run a constant tone and display a simple widget for messing with the mixer settings.\n", - "By looking at the spectrum we can manually tune the mixer with this." - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "922d9b02-6b05-4a0c-a767-f0f1f3ce4848", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2022-12-05 16:04:46.740] [qm: INFO] Performing health check\n", - "[2022-12-05 16:04:46.743] [qm: INFO] Health check passed\n", - "[2022-12-05 16:04:46.759] [root: INFO] Integration weights file not found, using flat weights.\n", - "[2022-12-05 16:04:46.768] [qm: INFO] Performing health check\n", - "[2022-12-05 16:04:46.771] [qm: INFO] Health check passed\n", - "[2022-12-05 16:04:47.026] [qm: INFO] Flags: \n", - "[2022-12-05 16:04:47.026] [qm: INFO] Sending program to QOP\n", - "[2022-12-05 16:04:47.049] [qm: INFO] Executing program\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "44af3af1e4de42fb9a7b3ed24557168a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(VBox(children=(FloatText(value=0.01, description='dc of. step:', step=0.001), HBox(children=(Bu…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "readout_mixer = add_mixer_config('readout', analyzer=spike, generator=readout_generator)\n", - "readout_mixer.run_constant_waveform()\n", - "mixer_tuning_tool(readout_mixer)" - ] - }, - { - "cell_type": "markdown", - "id": "1dcba9de-6781-4c41-bb73-108126df40a4", - "metadata": { - "tags": [] - }, - "source": [ - "#### Mixer optimization" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8322c740-85da-45f3-982e-cfb6f766c9ee", - "metadata": {}, - "outputs": [], - "source": [ - "calibrate_mixer(readout_mixer.config)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5f742e06-73e2-4535-8f7c-9fb47edd29e6", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "92d642be-9f77-458c-a039-a610872eafac", - "metadata": {}, - "source": [ - "### qubit mixer" - ] - }, - { - "cell_type": "markdown", - "id": "abadecee-7376-420f-910f-3801a66b4770", - "metadata": {}, - "source": [ - "#### mixer setup and manual tuning tool\n", - "\n", - "This snipped will create a mixer object that allows us to do most things.\n", - "It'll also run a constant tone and display a simple widget for messing with the mixer settings.\n", - "By looking at the spectrum we can manually tune the mixer with this." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "31db9ac7-c141-4d42-a7e1-25cb53b77210", - "metadata": {}, - "outputs": [], - "source": [ - "qubit_mixer = add_mixer_config('qubit', analyzer=spike, generator=qubit_generator)\n", - "qubit_mixer.run_constant_waveform()\n", - "mixer_tuning_tool(qubit_mixer)" - ] - }, - { - "cell_type": "markdown", - "id": "25290ee2-eadd-47bd-b8a6-2d61609d0af8", - "metadata": { - "tags": [] - }, - "source": [ - "#### Mixer optimization" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4ed9fdac-2331-41a8-b4cf-67af1f535342", - "metadata": {}, - "outputs": [], - "source": [ - "calibrate_mixer(qubit.config)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9087a929-7aee-4600-b151-d32a3b57544d", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "31b4dcbb-0c0d-46ed-833d-0c60125ce7bb", - "metadata": { - "tags": [] - }, - "source": [ - "# Test demodulation of readout signal" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "id": "9cfd3116-c8f3-4a0b-9c91-4363e50166de", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2022-12-05 16:12:07.738] [plottr.data.datadict_storage: INFO] Data location: /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T161207_db837402-test_through/data.ddh5\n", - "[2022-12-05 16:12:07.795] [qm: INFO] Performing health check\n", - "[2022-12-05 16:12:07.798] [qm: INFO] Health check passed\n", - "[2022-12-05 16:12:07.812] [root: INFO] Integration weights file not found, using flat weights.\n", - "[2022-12-05 16:12:07.820] [qm: INFO] Performing health check\n", - "[2022-12-05 16:12:07.823] [qm: INFO] Health check passed\n", - "[2022-12-05 16:12:08.255] [qm: INFO] Flags: \n", - "[2022-12-05 16:12:08.255] [qm: INFO] Sending program to QOP\n", - "[2022-12-05 16:12:08.517] [qm: INFO] Executing program\n", - "[2022-12-05 16:12:08.788] [labcore.ddh5: INFO] The measurement has finished successfully and all of the data has been saved.\n", - "[2022-12-05 16:12:08.796] [root: INFO] \n", - "==========\n", - "Saved data at /home/pfafflab/Documents/github/measurement-tools/examples/opx_demos/data/2022-12-05/2022-12-05T161207_db837402-test_through:\n", - "I: (100, 50)\n", - " ⌙ I_time_points: (100, 50)\n", - " ⌙ repetition: (100,)\n", - "Q: (100, 50)\n", - " ⌙ Q_time_points: (100, 50)\n", - " ⌙ repetition: (100,)\n", - "raw_signal: (100, 1000)\n", - " ⌙ raw_signal_time_points: (100, 1000)\n", - " ⌙ repetition: (100,)\n", - "=========\n" - ] - } - ], - "source": [ - "from qm.qua import *\n", - "from labcore.measurement import independent\n", - "from qcuiuc_measurement.opx_tools.sweep import \\\n", - " RecordOPXdata, ComplexOPXData, TimedOPXData\n", - "\n", - "@RecordOPXdata(\n", - " independent('repetition'),\n", - " TimedOPXData('raw_signal', depends_on=['repetition']),\n", - " TimedOPXData('I', depends_on=['repetition']),\n", - " TimedOPXData('Q', depends_on=['repetition']),\n", - ")\n", - "def simple_demod(n_reps=10, rep_delay_ns=0):\n", - " _chunksize = int(20 // 4)\n", - " _n_chunks = params.readout.short.len() // (4 * _chunksize)\n", - " \n", - " with program() as raw_measurement:\n", - " rep_stream = declare_stream()\n", - " raw_stream = declare_stream(adc_trace=True)\n", - " i_stream = declare_stream()\n", - " q_stream = declare_stream()\n", - "\n", - " rep = declare(int)\n", - " I = declare(fixed, size=_n_chunks)\n", - " Q = declare(fixed, size=_n_chunks)\n", - " j = declare(int)\n", - " \n", - " with for_(rep, 0, rep < n_reps, rep + 1):\n", - " measure('readout_short', 'readout', raw_stream, \n", - " demod.sliced(\"readout_short_sliced_cos\", I, _chunksize),\n", - " demod.sliced(\"readout_short_sliced_sin\", Q, _chunksize),)\n", - " \n", - " save(rep, rep_stream)\n", - " \n", - " with for_(j, 0, j < _n_chunks, j + 1):\n", - " save(I[j], i_stream)\n", - " save(Q[j], q_stream)\n", - " \n", - " if rep_delay_ns > 20:\n", - " wait(int(rep_delay_ns)//4)\n", - "\n", - " with stream_processing():\n", - " raw_stream.input1().save_all('raw_signal')\n", - " rep_stream.save_all('repetition')\n", - " i_stream.buffer(_n_chunks).save_all('I')\n", - " q_stream.buffer(_n_chunks).save_all('Q')\n", - " \n", - " return raw_measurement\n", - "\n", - "\n", - "readout_generator.power(4.)\n", - "readout_generator.output_status(1)\n", - "readout_generator.frequency(params.readout.LO())\n", - "\n", - "measurement = simple_demod(\n", - " n_reps=100, \n", - " rep_delay_ns=1e4,\n", - " collector_options=dict(batchsize=10),\n", - ")\n", - "\n", - "data_loc, _ = run_measurement(sweep=measurement, name='test_through')" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "id": "e33e7fb2-7487-4b2a-bfeb-7ea10eb7422a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "### using the DatasetAnalysis context helps us to load data easily, and automatically save plots in the right folder.\n", - "\n", - "from qcuiuc_measurement.analysis.data import get_data, data_info, DatasetAnalysis\n", - "from qcuiuc_measurement.analysis.plotting import setup_plotting, format_ax, add_legend, ppcolormesh\n", - "from qcuiuc_measurement.setup_notebook_analysis import *\n", - "\n", - "with DatasetAnalysis(data_loc) as analysis:\n", - " i_data = analysis.get_data('I', avg_over='repetition')\n", - " q_data = analysis.get_data('Q', avg_over='repetition')\n", - " raw_data = analysis.get_data('raw_signal', avg_over=None)\n", - " \n", - " fig = analysis.make_figure('a plot', figsize=(4,2))\n", - " \n", - " # first subfig: plot the raw voltage as a colormap. We set the limits such that 0 is the middle.\n", - " ax = fig.add_subplot(121)\n", - " im = ax.imshow(\n", - " raw_data.data_vals('raw_signal').T, \n", - " interpolation='none',\n", - " cmap='bwr',\n", - " aspect='auto',\n", - " )\n", - " format_ax(ax, xlabel='time (ns)', ylabel='repetition')\n", - " cb = fig.colorbar(im, ax=ax, location='top')\n", - " cb.set_label('ADC signal (a.u.)')\n", - " \n", - " # second subfig: plot one example trace of demodulated I and Q.\n", - " ax = fig.add_subplot(122)\n", - " ax.plot(i_data.data_vals('I_time_points'), i_data.data_vals('I'), '-',\n", - " label='I')\n", - " ax.plot(q_data.data_vals('Q_time_points'), q_data.data_vals('Q'), '-',\n", - " label='Q')\n", - " format_ax(ax, xlabel='time (chunks)', ylabel='demod. signal (a.u.)')\n", - " ax.legend(loc='best')\n", - " \n", - " # this command saves the figures associated with the analysis in the data folder.\n", - " analysis.save()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5994bbdb-5219-4b3a-8c5b-26db576ed80a", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:qcodes]", - "language": "python", - "name": "conda-env-qcodes-py" - }, - "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.9.15" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/doc/examples/opx_examples_and_templates/parameter_manager-parameter_manager.json b/doc/examples/opx_examples_and_templates/parameter_manager-parameter_manager.json deleted file mode 100755 index d0fac6f..0000000 --- a/doc/examples/opx_examples_and_templates/parameter_manager-parameter_manager.json +++ /dev/null @@ -1,98 +0,0 @@ -{ - "parameter_manager.mixers.qubit.imbalance": { - "unit": "", - "value": [ - 0.017258832411374866, - 0.0431687466800213 - ] - }, - "parameter_manager.mixers.qubit.offsets": { - "unit": "", - "value": [ - -0.0043203430482981284, - 0.002425398575564943 - ] - }, - "parameter_manager.mixers.readout.imbalance": { - "unit": "", - "value": [ - -0.10679336142539977, - 0.0759567975997925 - ] - }, - "parameter_manager.mixers.readout.offsets": { - "unit": "", - "value": [ - -0.037305109893088224, - -0.02914601831580512 - ] - }, - "parameter_manager.qubit.IF": { - "unit": "Hz", - "value": 173950814.28219295 - }, - "parameter_manager.qubit.LO": { - "unit": "Hz", - "value": 4795250000.0 - }, - "parameter_manager.qubit.drive.constant_drive.amp": { - "unit": "", - "value": 0.05 - }, - "parameter_manager.qubit.drive.constant_drive.edge_len": { - "unit": "ns", - "value": 1000 - }, - "parameter_manager.qubit.drive.constant_drive.len": { - "unit": "ns", - "value": 10000 - }, - "parameter_manager.qubit.drive.long.amp": { - "unit": "", - "value": 0.01 - }, - "parameter_manager.qubit.drive.long.length": { - "unit": "ns", - "value": 50000 - }, - "parameter_manager.qubit.drive.pipulse.amp": { - "unit": "", - "value": 0.026676964555142905 - }, - "parameter_manager.qubit.drive.pipulse.nsigmas": { - "unit": "", - "value": 6 - }, - "parameter_manager.qubit.drive.pipulse.sigma": { - "unit": "ns", - "value": 50 - }, - "parameter_manager.readout.IF": { - "unit": "Hz", - "value": 50000000.0 - }, - "parameter_manager.readout.LO": { - "unit": "Hz", - "value": 7219000000.0 - }, - "parameter_manager.readout.long.amp": { - "unit": "", - "value": 0.07 - }, - "parameter_manager.readout.long.len": { - "unit": "ns", - "value": 50000 - }, - "parameter_manager.readout.short.amp": { - "unit": "", - "value": 0.03 - }, - "parameter_manager.readout.short.buffer": { - "unit": "ns", - "value": 0 - }, - "parameter_manager.readout.short.len": { - "unit": "ns", - "value": 2000 - } -} \ No newline at end of file diff --git a/doc/examples/opx_examples_and_templates/qmcfg.py b/doc/examples/opx_examples_and_templates/qmcfg.py deleted file mode 100755 index 04d24bf..0000000 --- a/doc/examples/opx_examples_and_templates/qmcfg.py +++ /dev/null @@ -1,214 +0,0 @@ -"""Example config for testing the OPX. - -Author: Wolfgang Pfaff -""" -import numpy as np -import logging - -from labcore.opx.mixer import MixerCalibration -from labcore.opx.config import QMConfig as QMConfig_ - -logger = logging.getLogger(__name__) - - -class QMConfig(QMConfig_): - - def config_(self): - params = self.params # if we make use of the parameter manager... - - cfg = { - 'version': 1, - - # The hardware - 'controllers': { - - 'con2': { - 'type': 'opx1', - 'analog_outputs': { - 1: {'offset': params.mixers.readout.offsets()[0]}, # I - 2: {'offset': params.mixers.readout.offsets()[1]}, # Q - 3: {'offset': params.mixers.qubit.offsets()[0]}, # I - 4: {'offset': params.mixers.qubit.offsets()[1]}, # Q - - }, - 'digital_outputs': { - 1: {}, - }, - 'analog_inputs': { - 1: {'offset': 0.0}, - 2: {'offset': 0.0} - }, - }, - }, - - # The logical elements - 'elements': { - - 'readout': { - 'mixInputs': { - 'I': ('con2', 1), - 'Q': ('con2', 2), - 'lo_frequency': params.readout.LO(), - 'mixer': 'readout_IQ_mixer', - }, - - 'digitalInputs': { - 'readout_trigger': { - 'port': ('con2', 1), - 'delay': 144, - 'buffer': 0, - }, - }, - - 'intermediate_frequency': params.readout.IF(), - - 'operations': { - 'readout_short': 'readout_short_pulse', - 'readout_long': 'readout_long_pulse', - 'constant': 'constant_pulse', - }, - - 'outputs': { - 'out1': ('con2', 1), - }, - - 'time_of_flight': 188 + 28, - 'smearing': 0, - }, - - 'qubit': { - 'mixInputs': { - 'I': ('con2', 3), - 'Q': ('con2', 4), - 'lo_frequency': int(params.qubit.LO()), - 'mixer': 'qubit_IQ_mixer', - }, - 'intermediate_frequency': params.qubit.IF(), - - 'operations': { - 'long_drive': 'long_drive_pulse', - 'pi_pulse': 'pi_pulse', - 'constant': 'constant_pulse', - }, - }, - }, - - # The pulses - 'pulses': { - - 'readout_short_pulse': { - 'operation': 'measurement', - 'length': params.readout.short.len(), - 'waveforms': { - 'I': 'short_readout_wf', - 'Q': 'zero_wf', - }, - # Integration weights added automatically later. - 'digital_marker': 'ON', - }, - - 'readout_long_pulse': { - 'operation': 'measurement', - 'length': params.readout.long.len(), - 'waveforms': { - 'I': 'long_readout_wf', - 'Q': 'zero_wf', - }, - # Integration weights added automatically later. - 'digital_marker': 'ON', - }, - - 'constant_pulse': { - 'operation': 'control', - 'length': 1000, - 'waveforms': { - 'I': 'const_wf', - 'Q': 'zero_wf', - }, - }, - - 'long_drive_pulse': { - 'operation': 'control', - 'length': params.qubit.drive.long.length(), - 'waveforms':{ - 'I': 'long_qubit_drive_wf', - 'Q': 'zero_wf', - }, - 'digital_marker': 'ON', - }, - - 'pi_pulse':{ - 'operation': 'control', - 'length': params.qubit.drive.pipulse.sigma() * params.qubit.drive.pipulse.nsigmas(), - 'waveforms': { - 'I': 'qubit_pi_pulse_wf', - 'Q': 'zero_wf', - }, - }, - - }, - - # the waveforms - 'waveforms': { - 'const_wf': { - 'type': 'constant', - 'sample': 0.25, - }, - 'long_readout_wf': { - 'type': 'constant', - 'sample': params.readout.long.amp(), - }, - 'zero_wf': { - 'type': 'constant', - 'sample': 0.0, - }, - 'short_readout_wf': { - 'type': 'arbitrary', - 'samples': [0.0] * int(params.readout.short.buffer()) + \ - [params.readout.short.amp()] * \ - int(params.readout.short.len() - 2 * params.readout.short.buffer()) + \ - [0.0] * int(params.readout.short.buffer()), - }, - 'long_qubit_drive_wf':{ - 'type': 'constant', - 'sample': params.qubit.drive.long.amp(), - }, - 'qubit_pi_pulse_wf': { - 'type': 'arbitrary', - 'samples': params.qubit.drive.pipulse.amp() * \ - (np.exp(-(np.linspace(1, - params.qubit.drive.pipulse.sigma() * params.qubit.drive.pipulse.nsigmas(), - params.qubit.drive.pipulse.sigma() * params.qubit.drive.pipulse.nsigmas()) - \ - params.qubit.drive.pipulse.sigma() * params.qubit.drive.pipulse.nsigmas()//2)**2 / \ - (2*params.qubit.drive.pipulse.sigma()**2))) - }, - }, - - 'digital_waveforms': { - - 'ON': { - 'samples': [(1, 0)] - }, - - }, - - 'mixers': { - 'readout_IQ_mixer': [ - { - 'intermediate_frequency': int(params.readout.IF()), - 'lo_frequency': int(params.readout.LO()), - 'correction': MixerCalibration.IQ_imbalance_correction( - *params.mixers.readout.imbalance()) - }, - ], - 'qubit_IQ_mixer': [ - { - 'intermediate_frequency': int(params.qubit.IF()), - 'lo_frequency': int(params.qubit.LO()), - 'correction': MixerCalibration.IQ_imbalance_correction( - *params.mixers.qubit.imbalance()) - }, - ], - }, - } - return cfg diff --git a/labcore/analysis/single_transmon.py b/labcore/analysis/single_transmon.py deleted file mode 100644 index 4de1fe0..0000000 --- a/labcore/analysis/single_transmon.py +++ /dev/null @@ -1,91 +0,0 @@ -from typing import List, Union - -import numpy as np -from numpy import complexfloating, ndarray -from matplotlib import pyplot as plt -from sklearn.cluster import KMeans - -from labcore.plotting.basics import readout_hist - - -def convert_to_probability(signal: List[complexfloating], - initial_centroids: List[List[float]] = None, - return_labels: bool = False, - return_centers: bool = False, - plot_hist: bool = False, color_plot: bool = False) -> Union[ndarray, List[ndarray]]: - """ - Converts IQ data from qubit into state probabilities. - - Analyzes the data from a sweeping, identifies two centers (0 and 1) and assigns each data point to one of them. - After that, calculate the mean of each repetition and returns the probabilities. The assigment of clusters is done - through K-means algorithm. The function cannot identify which cluster is the excited state and which cluster is the - ground state, meaning that the probability might be inverted if initial centroids are not specified. - The repetition axis must be the outermost axis. - - Parameters - ---------- - signal: - Array with the complex data from measurements. All repetitions from the experiment should be here - and the repetition axis should be the outermost. - initial_centroids: - Indicates which center is the ground state and which the excited state. The format is a list containing 2 lists - composed each of 2 floats, e.g.: ``[[-1,0], [1,0]]``, indicating the IQ coordinates of each center. First center - corresponds to the ground state and second center corresponds to excited state. If this argument remains - ``None``, the labels and probabilities might be inverted. - return_labels: - If True, a numpy array will be returned as its second item in the same shape as signal - with 1s and 0s for each element of signal indicating to what cluster that element belongs too. - return_centers: - If True, the function will also return as its third item a list with the two centers of the - clusters (qubit states). Defaults to False. - plot_hist: - If True, the function will plot an IQ histogram. defaults to False. - color_plot: - If True, the function will plot an IQ histogram with a colored scatter plot on top indicating the - state of each point. Defaults to False - - Returns - ------- - Union[ndarray, List[ndarray]] - If return_labels and return_centers are both False, return an ndarray with the probabilities of the qubit to - be on a specific state for each point. The function doesn't know which state is excited and ground so the - probabilities might be inversed. - If either return_labels or return_centers are True, returns a List with the first item being the - probabilities. If return_labels is True, the second item will be an ndarray of the shape of signal consisting - of 0s, or 1s indicating the state of each data point. If return_centers is True, the third item (second if - return_labels is False) will be 2x2 ndarray with the centers of the 2 states. - - """ - ret = [] - signal_flat = signal.flatten() - signal_arr = np.stack([signal_flat.real, signal_flat.imag], axis=1) - - if initial_centroids is not None: - if isinstance(initial_centroids, List): - initial_centroids = np.array(initial_centroids) - - kmeans = KMeans(n_clusters=2, init=initial_centroids) - else: - kmeans = KMeans(n_clusters=2) - - kmeans.fit(signal_arr) - - labels = kmeans.labels_.reshape(signal.shape) - pvals = labels.mean(axis=0) - ret.append(pvals) - - if return_labels: - ret.append(labels) - if return_centers: - ret.append(kmeans.cluster_centers_) - if plot_hist: - fig = readout_hist(signal_flat, 'Histogram') - if color_plot: - fig = readout_hist(signal_flat, 'Sorted Histogram') - plt.scatter(signal_flat.real, signal_flat.imag, c=kmeans.labels_, cmap='bwr') - - if len(ret) == 1: - return ret[0] - else: - return ret - diff --git a/labcore/opx/mixer.py b/labcore/opx/mixer.py deleted file mode 100644 index c7a2aee..0000000 --- a/labcore/opx/mixer.py +++ /dev/null @@ -1,609 +0,0 @@ -"""Tools for using (IQ) mixers with the QM OPX. - -Required packages/hardware: -- QM OPX incl python software -- SignalHound USB SA124B + driver (comes with qcodes) -""" -from typing import List, Tuple, Optional, Any, Dict, Callable -from time import sleep -from datetime import datetime - -import numpy as np -from matplotlib import pyplot as plt -from scipy.optimize import minimize - -from tfe_hardware.qcodes_instrument_drivers.SignalHound.Spike import Spike -from tfe_hardware.qcodes_instrument_drivers.SignalCore.SignalCore_sc5511a import SignalCore_SC5511A -from qm import QuantumMachine, QuantumMachinesManager -from qm.qua import * - -from labcore.opx.config import QMConfig - - -class MixerCalibration: - """Class for performing IQ mixer calibration. - - We assume that we control the I and Q with a QM OPX, and monitor the output of the mixer with a - SignalHound spectrum analyzer. - Requires that independently a correctly specified configuration for the OPX is available. - - Parameters - ---------- - lo_frq - LO frequency in Hz - if_frq - IF frequency in Hz (we're taking the absolute) - analyzer - SignalHound qcodes driver instance - qm - Quantum Machine instance (with config applied) - mixer_name - the name of mixer we're tuning, as given in the QM config - element_name - the name of the element thats playing the IQ waveform, as given in the QM config - pulse_name - the name of the (CW) pulse we're playing to tune the mixer, as given in the QM config - """ - - def __init__(self, lo_frq: float, if_frq: float, analyzer: Spike, - qm: QuantumMachine, mixer_name: str, element_name: str, pulse_name: str - ): - - self.lo_frq = lo_frq - self.if_frq = if_frq - self.analyzer = analyzer - self.qm = qm - self.mixer_name = mixer_name - self.element_name = element_name - self.pulse_name = pulse_name - self.do_plot = True - - self.analyzer.mode('ZS') - sleep(0.5) - - def play_wf(self) -> None: - """Play an infinite loop waveform on the OPX. - We're scaling the amplitude of the pulse used by 0.5. - """ - with program() as const_pulse: - with infinite_loop_(): - play(self.pulse_name * amp(0.5), self.element_name) - - _ = self.qm.execute(const_pulse) - - def setup_analyzer(self, f: float) -> None: - """Set up the analyzer to measure at the given frequency `f` and sweep time. - - Signalhound driver is automatically put in zero-span mode when called. - - Parameters - ---------- - f - frequency to measure at, in Hz - mode - set the mode for the spectrum analyzer - """ - self.analyzer.zs_fcenter(f) - sleep(1.0) - - def measure_leakage(self) -> float: - """Measure max. signal power at the LO frequency.""" - # self.setup_analyzer(self.lo_frq) - sleep(0.1) - return self.analyzer.zs_power() - - def measure_upper_sb(self) -> float: - """Measure max. signal power at LO frequency + IF frequency""" - # self.setup_analyzer(self.lo_frq + np.abs(self.if_frq)) - sleep(0.1) - return self.analyzer.zs_power() - - def measure_lower_sb(self) -> float: - """Measure max. signal power at LO frequency - IF frequency""" - # self.setup_analyzer(self.lo_frq - np.abs(self.if_frq)) - sleep(0.1) - return self.analyzer.zs_power() - - @staticmethod - def IQ_imbalance_correction(g, phi) -> List: - """returns in the IQ mixer correction matrix as exepcted by the QM mixer config. - - Parameters - ---------- - g - relative amplitude imbalance between I and Q channels - phi - relative phase imbalance between I and Q channels - """ - c = np.cos(phi) - s = np.sin(phi) - N = 1 / ((1 - g ** 2) * (2 * c ** 2 - 1)) - return [float(N * x) for x in [(1 - g) * c, (1 + g) * s, - (1 - g) * s, (1 + g) * c]] - - def _optimize2d(self, func, initial_guess, initial_ranges, - title='', xtitle='', ytitle='', ztitle='Power', - nm_options=None, maxit=200): - - """ - Performs minimization through Nelder-Mead algorithm. - It starts with an initial simplex (triangle in current 2D case). - The initial simplex is a regular triangle centered around 'initial_guess'. - The 'initial_ranges[0]' (which is side of square for 'scan2D') is the diameter of the circumscribing circle. - - Parameters - ---------- - func - initial_guess - initial_ranges - title - xtitle - ytitle - ztitle - nm_options - maxit - - Returns - ------- - res (coordinates of the found minimum) - - """ - - if nm_options is None: - nm_options = dict() - - x, y, z = [], [], [] - - def cb(vec): - val = func(vec) - x.append(vec[0]) - y.append(vec[1]) - z.append(val) - - print(f'vector: {vec}, result: {val}, iteration: {len(y)}') - - initial_simplex = np.zeros((3, 2)) - initial_simplex[0, :] = initial_guess + np.array([0.0, 2 * initial_ranges[0]/2]) # initial_guess - initial_simplex[1, :] = initial_guess + np.array([-np.round(np.sqrt(3), 2) * initial_ranges[0]/2, -initial_ranges[0]/2]) # initial_guess + np.array([initial_ranges[0], 0.]) - initial_simplex[2, :] = initial_guess + np.array([np.round(np.sqrt(3), 2) * initial_ranges[0]/2, -initial_ranges[0]/2]) # initial_guess + np.array([0., initial_ranges[1]]) - - try: - res = minimize(func, initial_guess, # bounds=((-0.5, 0.5), (-0.5, 0.5)), - method='Nelder-Mead', callback=cb, - options=dict(initial_simplex=initial_simplex, **nm_options, maxiter=maxit)) - - except KeyboardInterrupt: - res = np.array([x[-1], y[-1]]) - print('optimization stopped by user') - - return res - - def _scan2d(self, func, center, ranges, steps, - title='', xtitle='', ytitle='', ztitle='Power'): - - xvals = center[0] + np.linspace(-ranges[0] / 2., ranges[0] / 2., steps) - yvals = center[1] + np.linspace(-ranges[1] / 2., ranges[1] / 2., steps) - xx, yy = np.meshgrid(xvals, yvals, indexing='ij') - zz = np.ones_like(xx) * np.nan - - try: - for k, x in enumerate(xvals): - for l, y in enumerate(yvals): - p = func(np.array([x, y])) - zz[k, l] = p - print(f'{p:5.0f}', end='') - print() - - except KeyboardInterrupt: - print('scan stopped by user.') - - if self.do_plot: - fig, ax = plt.subplots(1, 1, constrained_layout=True) - im = ax.pcolormesh(xx, yy, zz, shading='auto') - cb = fig.colorbar(im, ax=ax, shrink=0.5, pad=0.02) - ax.set_title(title + f" {datetime.now().isoformat()}", fontsize='small') - cb.set_label(ztitle) - ax.set_xlabel(xtitle) - ax.set_ylabel(ytitle) - plt.show() - - min_idx = np.argmin(zz.flatten()) - return np.array([xx.flatten()[min_idx], yy.flatten()[min_idx]], dtype=float) - - def lo_leakage(self, iq_offsets: np.ndarray) -> float: - """Set the I and Q DC offsets and measure the leakage power (in dBm). - - Parameters - ---------- - iq_offsets - array with 2 elements (I and Q offsets), with dtype = float - """ - self.qm.set_output_dc_offset_by_element( - self.element_name, 'I', iq_offsets[0]) - self.qm.set_output_dc_offset_by_element( - self.element_name, 'Q', iq_offsets[1]) - - power = self.measure_leakage() - return power - - def lo_leakage_scan(self, center: np.ndarray = np.array([0., 0.]), - ranges: Tuple = (0.5, 0.5), steps: int = 11) -> np.ndarray: - """Scan the I and Q DC offsets and measure the leakage at each point. - - if `MixerCalibration.do_plot` is `True` (default), then this generates a live plot of this sweeping. - - Parameters - ---------- - center - center coordinate [I_of, Q_of] - ranges - scan range on I and Q - steps - how many steps (will be used for both I and Q) - Returns - ------- - np.ndarray - the I/Q offset coordinate at which the smallest leakage was found - """ - self.setup_analyzer(self.lo_frq) - res = self._scan2d(self.lo_leakage, - center=center, ranges=ranges, steps=steps, - title='Leakage scan', xtitle='I offset', - ytitle='Q offset') - return res - - def optimize_lo_leakage(self, initial_guess: np.ndarray = np.array([0., 0.]), - ranges: Tuple[float, float] = (0.1, 0.1), - nm_options: Optional[Dict[str, Any]] = None): - """Optimize the IQ DC offsets using Nelder-Mead. - - The initial guess and ranges are used to specify the initial simplex - for the NM algorithm. - initial guess is the starting point, and initial ranges are the distances - along the two coordinates for the remaining two vertices of the initial simplex. - - Parameters - ---------- - initial_guess - x0 of the NM algorithm, an array with two elements, for I and Q offset - ranges - distance for I and Q vectors to complete the initial simplex - nm_options - Options to pass to the `scipy.optimize.minimize(method='Nelder-Mead')`. - Will be passed via the `options` dictionary. - """ - - self.setup_analyzer(self.lo_frq) - res = self._optimize2d(self.lo_leakage, - initial_guess, - initial_ranges=ranges, - title='Leakage optimization', - xtitle='I offset', - ytitle='Q offset', - nm_options=nm_options) - return res - - def sb_imbalance(self, imbalance: np.ndarray) -> float: - """Set mixer imbalance and measure the upper SB power. - - Parameters - ---------- - imbalance - values for relative amplitude and phase imbalance - - Returns - ------- - float - upper SB power [dBm] - - """ - mat = self.IQ_imbalance_correction(imbalance[0], imbalance[1]) - self.qm.set_mixer_correction( - self.mixer_name, int(self.if_frq), int(self.lo_frq), - tuple(mat)) - return self.measure_upper_sb() - - def sb_imbalance_scan(self, center: np.ndarray = np.array([0., 0.]), - ranges: Tuple = (0.5, 0.5), steps: int = 11) -> np.ndarray: - """Scan the relative amplitude and phase imbalance and measure the leakage at each point. - - if `MixerCalibration.do_plot` is `True` (default), then this generates a live plot of this sweeping. - - Parameters - ---------- - center - center coordinate [amp imbalance, phase imbalance] - ranges - scan range on the two imbalances - steps - how many steps (will be used for both imbalances) - - Returns - ------- - np.ndarray - the imbalance coordinate at which the smallest leakage was found - """ - self.setup_analyzer(self.lo_frq + np.abs(self.if_frq)) - res = self._scan2d(self.sb_imbalance, - center=center, ranges=ranges, steps=steps, - title='SB imbalance scan', - xtitle='g', ytitle='phi') - return res - - def optimize_sb_imbalance(self, initial_guess: np.ndarray = np.array([0., 0.]), - ranges: Tuple[float, float] = (0.05, 0.05), - nm_options: Optional[Dict[str, Any]] = None) -> np.ndarray: - """Optimize the mixer imbalances using Nelder-Mead. - - The initial guess and ranges are used to specify the initial simplex - for the NM algorithm. - initial guess is the starting point, and initial ranges are the distances - along the two coordinates for the remaining two vertices of the initial simplex. - - Parameters - ---------- - initial_guess - x0 of the NM algorithm, an array with two elements, for rel. amp and phase imbalance - ranges - distance for amp/phase imbalance vectors to complete the initial simplex - nm_options - Options to pass to the `scipy.optimize.minimize(method='Nelder-Mead')`. - Will be passed via the `options` dictionary. - """ - self.setup_analyzer(self.lo_frq + np.abs(self.if_frq)) - res = self._optimize2d(self.sb_imbalance, - initial_guess, - initial_ranges=ranges, - title='SB imbalance optimization', - xtitle='g', - ytitle='phi', - nm_options=nm_options) - return res - - -@dataclass -class MixerConfig: - #: Quantum machines config object - qmconfig: QMConfig - #: OPX address - opx_address: str - #: OPX port - opx_port: str - #: spectrum analyzer - analyzer: Spike - #: the LO for the mixer - generator: SignalCore_SC5511A - #: param that holds the IF - if_param: Callable - #: param holding the dc offsets - offsets_param: Callable - #: param holding the imbalances - imbalances_param: Callable - #: name of the mixer in the opx config - mixer_name: str - #: element we play a constant pulse on - element_name: str - #: name of the pulse we play - pulse_name: str - #: method for calibrating the mixer - calibration_method: str = ' ' - #: power for the generator - generator_power: Optional[float] = None - #: options for scanning-based optimization, offsets - offset_scan_ranges: Tuple[float, float] = (0.01, 0.01) - offset_scan_steps: int = 11 - #: options for scanning-based optimization, imbalances - imbalance_scan_ranges: Tuple[float, float] = (0.01, 0.01) - imbalance_scan_steps: int = 11 - #: param that holds the LO frequency - lo_param: Optional[Callable] = None - #: parameter that holds the frequency - frequency_param: Optional[Callable] = None - # do you want to provide custom initial point? - # (doesn't affect scan2D) - opt2D_of_custom_init: bool = False - opt2D_imb_custom_init: bool = False - # do you want to do a larger scan (typically first calibration) or smaller scan (around already found point)? - # (doesn't affect scan2D) - opt2D_of_dia: str = 'large' - opt2D_imb_dia: str = 'large' - - -def calibrate_mixer(config: MixerConfig, - offset_scan_ranges=None, - offset_scan_steps=None, - imbalance_scan_ranges=None, - imbalance_scan_steps=None, - calibrate_offsets=True, - calibrate_imbalance=True): - """ - Runs the entire mixer calibration for any mixer - """ - print("Ensure that effective path lengths before I and Q of mixer are same.") - print(f"Calibrating {config.mixer_name} by {config.calibration_method}...") - - # TODO: Should be configurable - config.analyzer.zs_ref_level(-20) - config.analyzer.zs_sweep_time(0.01) - config.analyzer.zs_ifbw_auto(0) - config.analyzer.zs_ifbw(1e4) - - # setup the generator frequency and its power - if config.lo_param is not None: - mixer_lo_freq = config.lo_param() - config.generator.frequency(mixer_lo_freq) - elif config.frequency_param is not None: - mixer_lo_freq = config.frequency_param() + config.if_param() - config.generator.frequency(mixer_lo_freq) - else: - mixer_lo_freq = config.generator.frequency() - - # support for both SignalCore and R&S SGS - if hasattr(config.generator, 'output_status'): - config.generator.output_status(1) - elif hasattr(config.generator, 'on'): - config.generator.on() - - if config.generator_power is not None: - config.generator.power(config.generator_power) - - qmm = QuantumMachinesManager.QuantumMachinesManager(host=config.opx_address, port=config.opx_port) - qm = qmm.open_qm(config.qmconfig(), close_other_machines=False) - - try: - # initialize Mixer class object - cal = MixerCalibration(mixer_lo_freq, - config.if_param(), - config.analyzer, qm, - mixer_name=config.mixer_name, - element_name=config.element_name, - pulse_name=config.pulse_name, - ) - - # Call the appropriate calibration functions - # offsets part - if calibrate_offsets: - offsets = config.offsets_param() - cal.play_wf() - if config.calibration_method == 'scanning': - print("\nOffset calibration through: scanning \n") - if offset_scan_steps is None: - offset_scan_steps = config.offset_scan_steps - if offset_scan_ranges is None: - offset_scan_ranges = config.offset_scan_ranges - - print(f'Offsets: {offsets} Ranges: {offset_scan_ranges} \n') - - res_offsets = cal.lo_leakage_scan( - offsets, - ranges=offset_scan_ranges, - steps=offset_scan_steps, - ) - offsets = res_offsets.tolist() - else: - print("\nOffset calibration through: Nelder-Mead optimization \n") - if config.opt2D_of_custom_init is True: - pass - else: - offsets = [0, 0] - - custom_of_range = config.offset_scan_ranges - - if config.opt2D_of_dia == 'large': - custom_of_range = [0.05, 0.05] - elif config.opt2D_of_dia == 'small': - custom_of_range = [0.001, 0.001] - elif config.opt2D_of_dia == 'custom': - pass - - print(f'Offsets: {offsets} Ranges: {custom_of_range} \n') - - # for i in np.arange(1, 4, 1): - res_offsets = cal.optimize_lo_leakage( - offsets, - ranges=custom_of_range, - nm_options=dict(xatol=0.0001, fatol=1.0) - ) - # print(res_offsets) - - if isinstance(res_offsets, np.ndarray): - offsets = res_offsets.tolist() - elif res_offsets.success and res_offsets.nit < 200: - offsets = res_offsets.x.tolist() - # custom_of_range = (0.001, 0.001) - else: - print('Failed to converge. Use different initial values. \n') - return - - print(f'best values for offsets: {offsets} \n') - config.offsets_param(offsets) - print(f'verifying: {cal.lo_leakage(offsets)} \n') - - # imbalances part - if calibrate_imbalance: - imbalances = config.imbalances_param() - cal.play_wf() - if config.calibration_method == 'scanning': - print("\nImbalance calibration through: scanning \n") - if imbalance_scan_steps is None: - imbalance_scan_steps = config.imbalance_scan_steps - if imbalance_scan_ranges is None: - imbalance_scan_ranges = config.imbalance_scan_ranges - - print(f'Imbalances: {imbalances} Ranges: {imbalance_scan_ranges} \n') - - res_imbalances = cal.sb_imbalance_scan( - imbalances, - ranges=imbalance_scan_ranges, - steps=imbalance_scan_steps, - ) - imbalances = res_imbalances.tolist() - else: - print("\nImbalance calibration through: Nelder-Mead optimization \n") - if config.opt2D_imb_custom_init is True: - pass - else: - if config.generator.IDN().get('vendor') == 'Rohde&Schwarz': # type(config.generator).__name__ == 'RohdeSchwarz_SGS100A': - imbalances = [0, 1.57] - else: - imbalances = [0, 0] - - custom_imb_range = config.imbalance_scan_ranges - - if config.opt2D_imb_dia == 'large': - custom_imb_range = [0.05, 0.05] - elif config.opt2D_imb_dia == 'small': - custom_imb_range = [0.001, 0.001] - elif config.opt2D_imb_dia == 'custom': - pass - - # for i in np.arange(1, 4, 1): - - print(f'Imbalances: {imbalances} Ranges: {custom_imb_range} \n') - - res_imbalances = cal.optimize_sb_imbalance( - imbalances, - ranges=custom_imb_range, - nm_options=dict(xatol=0.0001, fatol=1.0) - ) - # print(res_imbalances) - - if isinstance(res_imbalances, np.ndarray): - imbalances = res_imbalances.tolist() - elif res_imbalances.success and res_imbalances.nit < 200: - imbalances = res_imbalances.x.tolist() - # custom_imb_range = (0.001, 0.001) - else: - print('Failed to converge. Use different initial values. \n') - return - - print(f'best values for imbalance: {imbalances} \n') - config.imbalances_param(imbalances) - print(f'verifying: {cal.sb_imbalance(imbalances)} \n') - - finally: - qm.close() - -def mixer_of_step(config: MixerConfig, qm: QuantumMachine, di, dq): - new_i = config.offsets_param()[0] + di - new_q = config.offsets_param()[1] + dq - qm.set_output_dc_offset_by_element(config.element_name, 'I', new_i) - qm.set_output_dc_offset_by_element(config.element_name, 'Q', new_q) - config.offsets_param([new_i, new_q]) - - -def mixer_imb_step(config: MixerConfig, qm: QuantumMachine, dg, dp): - new_g = config.imbalances_param()[0] + dg - new_p = config.imbalances_param()[1] + dp - if config.lo_param is not None: - lof = config.lo_param() - elif config.frequency_param is not None: - lof = config.frequency_param() + config.if_param() - else: - lof = config.generator.frequency() - - qm.set_mixer_correction(config.mixer_name, - int(config.if_param()), - int(lof), - tuple(MixerCalibration.IQ_imbalance_correction(new_g, new_p))) - config.imbalances_param([new_g, new_p]) diff --git a/labcore/opx/sweep.py b/labcore/opx/sweep.py index f422f00..92bfb19 100644 --- a/labcore/opx/sweep.py +++ b/labcore/opx/sweep.py @@ -58,7 +58,7 @@ def __init__(self, *specs): def setup(self, fun, *args, **kwargs) -> None: """ - Establishes connection with the OPX and starts the the sweeping. The config of the OPX is passed through + Establishes connection with the OPX and starts the sweeping. The config of the OPX is passed through the module variable global_config. It saves the result handles and saves initial values to the communicator dictionary. """ diff --git a/labcore/plotting/__init__.py b/labcore/plotting/__init__.py index e69de29..b826f31 100644 --- a/labcore/plotting/__init__.py +++ b/labcore/plotting/__init__.py @@ -0,0 +1,3 @@ + + +# TODO: Add the important things from plotting in this file. \ No newline at end of file diff --git a/labcore/setup/setup_measurements.py b/labcore/setup/setup_measurements.py index 1cff93c..db88df1 100644 --- a/labcore/setup/setup_measurements.py +++ b/labcore/setup/setup_measurements.py @@ -7,12 +7,12 @@ from instrumentserver.client import Client, ProxyInstrument -from labcore.ddh5 import run_and_save_sweep -from labcore.measurement import Sweep +from labcore.sweep.ddh5 import run_and_save_sweep +from labcore.sweep.sweep import Sweep from plottr.data.datadict import DataDict -from .analysis.data import data_info +from labcore.analysis.data import data_info # constants diff --git a/labcore/setup/setup_opx_measurements.py b/labcore/setup/setup_opx_measurements.py index 20a1188..06eda82 100644 --- a/labcore/setup/setup_opx_measurements.py +++ b/labcore/setup/setup_opx_measurements.py @@ -19,7 +19,7 @@ from labcore.opx.config import QMConfig from .opx_tools import sweep as qmsweep -from labcore.opx.mixer import MixerConfig, mixer_of_step, mixer_imb_step +from qcuiuc_measurement.opx_msmt.mixer import MixerConfig, mixer_of_step, mixer_imb_step from . import setup_measurements from .setup_measurements import * diff --git a/labcore/sweeping/__init__.py b/labcore/sweep/__init__.py similarity index 100% rename from labcore/sweeping/__init__.py rename to labcore/sweep/__init__.py diff --git a/labcore/sweeping/ddh5.py b/labcore/sweep/ddh5.py similarity index 100% rename from labcore/sweeping/ddh5.py rename to labcore/sweep/ddh5.py diff --git a/labcore/sweeping/record.py b/labcore/sweep/record.py similarity index 100% rename from labcore/sweeping/record.py rename to labcore/sweep/record.py diff --git a/labcore/sweeping/sweep.py b/labcore/sweep/sweep.py similarity index 100% rename from labcore/sweeping/sweep.py rename to labcore/sweep/sweep.py From 1067d58fe56c081b414a537006d6162f759b2fcd Mon Sep 17 00:00:00 2001 From: pfafflab Date: Thu, 8 Dec 2022 18:28:14 -0600 Subject: [PATCH 3/7] Corrected wrong imports --- labcore/opx/sweep.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/labcore/opx/sweep.py b/labcore/opx/sweep.py index 92bfb19..0a25472 100644 --- a/labcore/opx/sweep.py +++ b/labcore/opx/sweep.py @@ -5,9 +5,9 @@ from qm.qua import * from qm.QuantumMachinesManager import QuantumMachinesManager -from labcore.sweeping import * -from labcore.sweeping.record import make_data_spec -from labcore.sweeping.sweep import AsyncRecord +from labcore.sweep import * +from labcore.sweep.record import make_data_spec +from labcore.sweep.sweep import AsyncRecord from labcore.opx.config import QMConfig From be2f7033dc72f16bb2ca307806cdb4086de5c2f4 Mon Sep 17 00:00:00 2001 From: pfafflab Date: Fri, 9 Dec 2022 11:13:17 -0600 Subject: [PATCH 4/7] wrong import in ddh5 --- labcore/sweep/ddh5.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/labcore/sweep/ddh5.py b/labcore/sweep/ddh5.py index e33a2be..70bcba8 100644 --- a/labcore/sweep/ddh5.py +++ b/labcore/sweep/ddh5.py @@ -32,7 +32,7 @@ from plottr.data.datadict import DataDict, is_meta_key from plottr.data.datadict_storage import DDH5Writer -from labcore.sweeping.sweep import Sweep +from labcore.sweep.sweep import Sweep __author__ = 'Wolfgang Pfaff' __license__ = 'MIT' From aed0f33e84b5db6617a71d6724fd67cd7da5ff59 Mon Sep 17 00:00:00 2001 From: marcosf2 Date: Wed, 31 May 2023 16:41:13 -0500 Subject: [PATCH 5/7] Updated merge --- labcore/analysis/data.py | 38 +- labcore/analysis/fitting.py | 74 +++- labcore/analysis/resonators.py | 480 ----------------------- labcore/opx/config.py | 55 ++- labcore/opx/sweep.py | 56 ++- labcore/plotting/basics.py | 21 +- labcore/setup/setup_measurements.py | 9 +- labcore/setup/setup_notebook_analysis.py | 6 +- labcore/setup/setup_opx_measurements.py | 31 +- 9 files changed, 215 insertions(+), 555 deletions(-) delete mode 100644 labcore/analysis/resonators.py diff --git a/labcore/analysis/data.py b/labcore/analysis/data.py index eea5182..c487763 100644 --- a/labcore/analysis/data.py +++ b/labcore/analysis/data.py @@ -7,8 +7,10 @@ from datetime import datetime import json +import numpy as np from matplotlib.figure import Figure from matplotlib import pyplot as plt +from sklearn.decomposition import PCA from plottr.data.datadict import DataDictBase, datadict_to_meshgrid, MeshgridDataDict from plottr.data.datadict_storage import datadict_from_hdf5 @@ -23,8 +25,14 @@ def data_info(folder: str, fn: str = 'data.ddh5', do_print: bool = True): return str(dataset) -def get_data(folder: Union[str, Path], data_name: Optional[Union[str, List[str]]] = None, fn: str = 'data.ddh5', - mk_grid: bool = True, avg_over: Optional[str] = 'repetition') -> DataDictBase: +def get_data( + folder: Union[str, Path], + data_name: Optional[Union[str, List[str]]] = None, + fn: str = 'data.ddh5', + mk_grid: bool = True, + avg_over: Optional[str] = 'repetition', + rotate_complex: bool = False, + ) -> DataDictBase: """Get data from disk. @@ -41,6 +49,10 @@ def get_data(folder: Union[str, Path], data_name: Optional[Union[str, List[str]] if True, try to automatically place data on grid. avg_over if not ``None``, average over this axis if it exists. + rotate_complex + if True: try to rotate data automatically in IQ to map onto a single + axis and return real data. We use sklearn's PCA tool for that. + this is done after averaging. Returns ------- @@ -62,17 +74,19 @@ def get_data(folder: Union[str, Path], data_name: Optional[Union[str, List[str]] dataset = datadict_to_meshgrid(dataset) if avg_over is not None and avg_over in dataset.axes() and isinstance(dataset, MeshgridDataDict): - if not dataset.axes_are_compatible(): - raise RuntimeError('When averaging, axes must be compatible.') + dataset = dataset.mean(avg_over) + + if rotate_complex: + for d in data_name: + dvals = dataset.data_vals(d) + shp = dvals.shape + if np.iscomplexobj(dvals): + pca = PCA(n_components=1) + newdata = pca.fit_transform( + np.vstack((dvals.real.flatten(), dvals.imag.flatten())).T + ) + dataset[d]['values'] = newdata.reshape(shp) - avg_ax_id = dataset.axes(data_name[0]).index(avg_over) - for dn, _ in dataset.data_items(): - dataset[dn]['values'] = dataset[dn]['values'].mean(axis=avg_ax_id) - if avg_over in dataset[dn]['axes']: - dataset[dn]['axes'].pop(avg_ax_id) - del dataset[avg_over] - - dataset.validate() return dataset diff --git a/labcore/analysis/fitting.py b/labcore/analysis/fitting.py index 3e062f1..d7f2db9 100644 --- a/labcore/analysis/fitting.py +++ b/labcore/analysis/fitting.py @@ -1,6 +1,10 @@ -from typing import Dict, Any, Tuple +from copy import deepcopy +from typing import Type, Optional, Callable, Tuple, Any, Dict import numpy as np +from plottr.data.datadict import DataDict, MeshgridDataDict +from plottr.analyzer.fitters.fitter_base import Fit + def batch_fitting(analysis_class, all_data: Dict[Any, Tuple[np.ndarray, np.ndarray]], **kwargs): """ fit multiple datafiles of the same analysis class @@ -8,7 +12,7 @@ def batch_fitting(analysis_class, all_data: Dict[Any, Tuple[np.ndarray, np.ndarr Parameters ---------- analysis_class - the name of the class of the sweeping + the name of the class of the measurement all_data a dictionary whose values are tuples of coordinates and measured data, each of which corresponds to a data file, and keys are the labels for the data files @@ -49,12 +53,74 @@ def params_from_batch_fitting_results(fit_results: dict, params: list[str]) -> T resorted_dict = {} for param in params: resorted_dict[param] = [] - resorted_dict[param +'_error'] = [] + resorted_dict[param + '_error'] = [] labels = [] for label, fit_result in fit_results.items(): labels.append(label) for key, values in fit_result.lmfit_result.params.items(): resorted_dict[key].append(values.value) - resorted_dict[key +'_error'].append(values.stderr) + resorted_dict[key + '_error'].append(values.stderr) return labels, resorted_dict + + +# FIXME: Docstring incomplete +def iterate_over_slices_1d(data: MeshgridDataDict, slice_ax: str): + slice_idx = data.axes().index(slice_ax) + d2 = data.reorder_axes(**{slice_ax: len(data.axes()) - 1}) + iter_shape = d2.shape()[:-1] + for idx in np.ndindex(iter_shape): + ret = { + '_axis_names': d2.axes()[:-1], + '_axis_idxs': idx, + } + for d in d2.dependents(): + ret[d] = d2.data_vals(d)[idx] + for a in d2.axes(): + ret[a] = d2.data_vals(a)[idx] + yield ret + + +# FIXME: Docstring incomplete +def batch_fit_1d(data: MeshgridDataDict, fit_class: Type[Fit], dep: str, indep: str, cb: Optional[Callable] = None): + # TODO: include option to look at the individual fits? include a multipage pdf, for instance... + # TODO: get back the best fit curves? + + # first: set up a copy of the structure, but omit the axes we fit over. + indep_ax_idx = data.axes().index(indep) + axes = deepcopy(data.axes()) + axes.pop(indep_ax_idx) + result_shape = list(data.shape()) # we also want the shape, up to the axis that'll disappear + result_shape.pop(indep_ax_idx) + result = deepcopy(data.structure(include_meta=False)) + del result[indep] + result[dep]['axes'] = axes + for d in data.dependents(): + del result[d] + + # next: populate ax values. as first-order approximation, simply use the first values along the + # dimension we fit + copy_idx = tuple(slice(None) if i != indep else 0 for i in data.axes()) + for ax in data.axes(): + if ax != indep: + result[ax]['values'] = data[ax]['values'][copy_idx] + + result['_fit_success'] = {'axes': axes, 'values': np.zeros(result_shape).astype(bool)} + for data1d in iterate_over_slices_1d(data, indep): + i = data1d['_axis_idxs'] + x = data1d[indep] + y = data1d[dep] + fit = fit_class(x, y) + fit_result = fit.run() + result['_fit_success']['values'][i] = fit_result.lmfit_result.success + for param_name, param in fit_result.lmfit_result.params.items(): + if param_name not in result: + result[param_name] = {'axes': axes, 'values': np.zeros(result_shape) * np.nan} + result[param_name + '-stderr'] = {'axes': axes, 'values': np.zeros(result_shape) * np.nan} + + if fit_result.lmfit_result.success: + result[param_name]['values'][i] = param.value + result[param_name + '-stderr']['values'][i] = param.stderr + + result.validate() + return result diff --git a/labcore/analysis/resonators.py b/labcore/analysis/resonators.py deleted file mode 100644 index ab4bb4b..0000000 --- a/labcore/analysis/resonators.py +++ /dev/null @@ -1,480 +0,0 @@ -from typing import Dict, Any - -import numpy as np -import scipy -from matplotlib import pyplot as plt -from pathlib import Path - -from plottr.analyzer.fitters.fitter_base import Fit - - -class ReflectionResponse(Fit): - - @staticmethod - def model(coordinates: np.ndarray, A: float, f_0: float, Q_i: float, Q_e: float, phase_offset: float, - phase_slope: float): - """ - Reflection response model derived from input-output theory. For detail, see section 12.2.6 in "Quantum - and Atom Optics" by Daniel Adam Steck - - Parameters - ---------- - coordinates - 1d numpy array containing the frequencies in range of sweeping - A - amplitude correction of the response - f_0 - resonant frequency - Q_i - internal Q (coupling to losses of the cavity) - Q_e - external Q (coupling to output pins) - phase_offset - the offset of phase curve which can be seen at the start and end point of the phase diagram of reflection - response - phase_slope - the slope of phase curve which can be seen at the start and end point of the phase diagram of reflection - response - - Returns - ------- - numpy array - the ideal response calculated with the equation - """ - x = coordinates - s11_ideal = (1j * (1 - x / f_0) + (Q_i - Q_e) / (2 * Q_e * Q_i)) / ( - 1j * (1 - x / f_0) - (Q_i + Q_e) / (2 * Q_e * Q_i)) - correction = A * np.exp(1j * (phase_offset + phase_slope * (x - f_0))) - return s11_ideal * correction - - @staticmethod - def guess(coordinates: np.ndarray, data: np.ndarray): - """ make an initial guess on parameters based on the measured reflection response data and the input-output - theory - - Parameters - ---------- - coordinates - 1d numpy array containing the frequencies in range of sweeping - data - 1d numpy array containing the complex measured reflection response data - - Returns - ------- - dict - a dictionary whose values are the guess on A, f_0, Q_i, Q_e, phase_offset, and phase slope and keys - contain their names - """ - - amp = np.abs(np.concatenate((data[:data.size // 10], data[-data.size // 10:]))).mean() - dip_loc = np.argmax(np.abs(np.abs(data) - amp)) - guess_f_0 = coordinates[dip_loc] - - data = moving_average(data) - depth = amp - np.abs(data[dip_loc]) - width_loc = np.argmin(np.abs(amp - np.abs(data) - depth / 2)) - kappa = 2 * np.abs(coordinates[dip_loc] - coordinates[width_loc]) - guess_Q_tot = guess_f_0 / kappa - # print(guess_Q_tot) - - [slope, _] = np.polyfit(coordinates[:data.size // 10], np.angle(data[:data.size // 10], deg=False), 1) - phase_offset = np.angle(data[0]) + slope * (coordinates[dip_loc] - coordinates[0]) - correction = amp * np.exp(1j * phase_offset) - # print(data[dip_loc]/correction) - guess_Q_e = 2 * guess_Q_tot / (1 - np.abs(data[dip_loc]/correction)) - guess_Q_i = 1 / (1 / guess_Q_tot - 1 / guess_Q_e) - - return dict( - f_0=guess_f_0, - A=amp, - phase_offset=phase_offset, - phase_slope=slope, - Q_i=guess_Q_i, - Q_e=guess_Q_e - ) - - @staticmethod - def nphoton(P_cold_dBm: float, Q_e: float, Q_i: float, f_0: float): - """ calculate the number of photons in the resonator - - Parameters - ---------- - P_cold_dBm - the power (in unit of dBm) injected into the cold resonator, with cable loss taken into account - Q_i - internal Q (coupling to losses of the cavity) - Q_e - external Q (coupling to output pins) - f_0 - resonant frequency - - Returns - ------- - float - the number of photons - """ - P_cold_W = 1e-3 * 10 ** (P_cold_dBm / 10.) - Q_tot = 1 / (1 / Q_e + 1 / Q_i) - photon_number = 2. * P_cold_W * Q_tot ** 2 / (np.pi * scipy.constants.h * f_0 ** 2 * Q_e) - return photon_number - - -class HangerResponseBruno(Fit): - """model from: https://arxiv.org/abs/1502.04082 - pages 6/7.""" - - @staticmethod - def model(coordinates: np.ndarray, A: float, f_0: float, Q_i: float, Q_e_mag: float, theta: float, phase_offset: float, - phase_slope: float, transmission_slope: float): - """A (1 + alpha * (x - f_0)/f_0) (1 - Q_l/|Q_e| exp(i \theta) / (1 + 2i Q_l (x-f_0)/f_0)) exp(i(\phi_v f_0 - + phi_0))""" - - x = coordinates - amp_correction = A * (1 + transmission_slope * (x - f_0)/f_0) - phase_correction = np.exp(1j*(phase_slope * x + phase_offset)) - - if Q_e_mag == 0: - Q_e_mag = 1e-12 - Q_e_complex = Q_e_mag * np.exp(-1j*theta) - Q_c = 1./((1./Q_e_complex).real) - Q_l = 1./(1./Q_c + 1./Q_i) - response = 1 - Q_l / np.abs(Q_e_mag) * np.exp(1j * theta) / (1. + 2j*Q_l*(x-f_0)/f_0) - - return response * amp_correction * phase_correction - - @staticmethod - def guess(coordinates, data) -> Dict[str, Any]: - - amp = np.abs(np.concatenate((data[:data.size // 10], data[-data.size // 10:]))).mean() - dip_loc = np.argmax(np.abs(np.abs(data) - amp)) - guess_f_0 = coordinates[dip_loc] - [guess_transmission_slope, _] = np.polyfit(coordinates[:data.size // 10], np.abs(data[:data.size // 10]), 1) - amp_correction = amp * (1+guess_transmission_slope*(coordinates-guess_f_0)/guess_f_0) - - data = moving_average(data) - depth = amp - np.abs(data[dip_loc]) - width_loc = np.argmin(np.abs(amp - np.abs(data) - depth / 2)) - kappa = 2 * np.abs(coordinates[dip_loc] - coordinates[width_loc]) - guess_Q_l = guess_f_0 / kappa - # print(guess_Q_tot) - - [slope, _] = np.polyfit(coordinates[:data.size // 10], np.angle(data[:data.size // 10], deg=False), 1) - phase_offset = np.angle(data[0], deg=False) - slope * (coordinates[0]-0) - phase_correction = np.exp(1j*(slope * coordinates + phase_offset)) - correction = amp_correction * phase_correction - # print(data[dip_loc]/correction) - - guess_theta = 0.5 # there are deterministic ways of finding it but looking at two symmetric points close to f_r in S21 , but it's kinda unnecessary so I just choose a small value and it works so far - guess_Q_e_mag = np.abs(-guess_Q_l * np.exp(1j*guess_theta) / (data[dip_loc]/correction[dip_loc]-1)) - guess_Q_c = 1 / np.real(1 / (guess_Q_e_mag*np.exp(-1j*guess_theta))) - guess_Q_i = 1 / (1 / guess_Q_l - 1 / guess_Q_c) - - return dict( - A = amp, - f_0 = guess_f_0, - Q_i = guess_Q_i, - Q_e_mag = guess_Q_e_mag, - theta = guess_theta, - phase_offset = phase_offset, - phase_slope = slope, - transmission_slope = guess_transmission_slope, - ) - - - # return dict( - # A = 1, - # f_0 = 1, - # Q_i = 1e6, - # Q_e = 1e6, - # theta = 0, - # phase_offset=0, - # phase_slope=0, - # transmission_slope=0, - # ) - - - @staticmethod - def nphoton(P_cold_dBm: float, Q_e: float, Q_i: float, f_0: float, theta: float): - P_cold_W = 1e-3 * 10 ** (P_cold_dBm / 10.) - Q_e_complex = Q_e * np.exp(-1j*theta) - Q_c = 1./((1/Q_e_complex).real) - Q_l = 1./(1./Q_c + 1./Q_i) - return 2 / (scipy.constants.hbar * (2*np.pi*f_0)**2) * Q_l**2 / Q_c * P_cold_W - - -class TransmissionResponse(Fit): - - @staticmethod - def model(coordinates: np.ndarray, f_0: float, A: float, Q_t: float, Q_e: float, phase_offset: float, - phase_slope: float): - """ - Reflection response model derived from input-output theory. For detail, see section 12.2.6 in "Quantum - and Atom Optics" by Daniel Adam Steck - - Parameters - ---------- - coordinates - 1d numpy array containing the frequencies in range of sweeping - f_0 - resonant frequency - Q_t - total Q - Q_e - geometric mean of the two coupling Qs (coupling to output pins) multiplied with the total attenuation - of the signal path. - phase_offset - the offset of phase curve which can be seen at the start and end point of the phase diagram of reflection - response - phase_slope - the slope of phase curve which can be seen at the start and end point of the phase diagram of reflection - response - - Returns - ------- - numpy array - the ideal response calculated with the equation - """ - x = coordinates - # s21_ideal = (k_e1*k_e2)**0.5 / ( 1j*2*np.pi*(f_0-x) - (k_e1+k_e2+k_i)/2 ) - # s21_ideal = Q_e / (1j*(1-x/f_0)*Q_e**2 - (Q_e2+Q_e1+Q_e1*Q_e2/Q_i)/2) - correction = A * np.exp(1j * (phase_offset + phase_slope * (x - f_0))) - s21 = correction * (1j * Q_e * (1. - x/f_0) - .5 * Q_e / Q_t)**(-1) - return s21 - - @staticmethod - def guess(coordinates: np.ndarray, data: np.ndarray) -> Dict[str, Any]: - """ make an initial guess on parameters based on the measured reflection response data and the input-output - theory - - Parameters - ---------- - coordinates - 1d numpy array containing the frequencies in range of sweeping - data - 1d numpy array containing the complex measured reflection response data - - Returns - ------- - dict - a dictionary whose values are the guess on A, f_0, Q_i, Q_e, phase_offset, and phase slope and keys - contain their names - """ - data = moving_average(data) - - # Average the first and last 10% of the data to get the base amplitude - amp = np.abs(np.concatenate((data[:data.size // 10], data[-data.size // 10:]))).mean() - - # Find the resonance frequency from the max point - dip_loc = np.argmax(np.abs(np.abs(data) - amp)) - guess_f_0 = coordinates[dip_loc] - - # Find the depth to get kappa and from kappa and f_0 estimate Q_t - depth = amp - np.abs(data[dip_loc]) - width_loc = np.argmin(np.abs(amp - np.abs(data) - depth / 2)) - kappa = np.abs(coordinates[dip_loc] - coordinates[width_loc]) - guess_Q_t = guess_f_0 / kappa - - # Use Q_t estimate and the max value to get an estimate for Q_e' - guess_Q_e = -2*guess_Q_t/np.abs(depth) - - # Guess the phase offset and slope - [guess_slope, _] = np.polyfit(coordinates[:data.size // 10], np.angle(data[:data.size // 10], deg=False), 1) - guess_phase = np.angle(data[0]) + guess_slope * (coordinates[dip_loc] - coordinates[0]) - - #print(guess_phase) - - return dict( - A=amp, - f_0=guess_f_0, - Q_t=guess_Q_t, - Q_e=-250, - phase_offset=guess_phase, - phase_slope=guess_slope, - ) - - # @staticmethod - # def nphoton(P_cold_dBm: float, Q_e1: float, Q_e2: float, Q_i: float, f_0: float): - # """ calculate the number of photons in the resonator - # - # Parameters - # ---------- - # P_cold_dBm - # the power (in unit of dBm) injected into the cold resonator, with cable loss taken into account - # Q_i - # internal Q (coupling to losses of the cavity) - # Q_e1 - # input external Q (coupling to input pins) - # Q_e2 - # output external Q (coupling to output pins) - # f_0 - # resonant frequency - # - # Returns - # ------- - # float - # the number of photons - # """ - # P_cold_W = 1e-3 * 10 ** (P_cold_dBm / 10.) - # Q_tot = 1 / (1 / Q_e1 + 1 / Q_e2 + 1 / Q_i) - # photon_number = 2. * P_cold_W * Q_tot ** 2 / (np.pi * scipy.constants.h * f_0 ** 2 * Q_e1) - # return photon_number - - -def moving_average(a): - n = a.size//200*2+1 - ret = np.cumsum(a) - ret[n:] = ret[n:] - ret[:-n] - return np.append(np.append(a[:int((n-1)/2-1)], ret[n - 1:] / n), a[int(-(n-1)/2-1):]) - - -def plot_resonator_response(frequency: np.ndarray, figsize: tuple =(6, 3), f_unit: str = 'Hz', **sparams): - """ plot the magnitude, phase, and polar diagrams of the data, the model with initially guessed parameters, - and the fitted curve - - Parameters - ---------- - coordinates - 1d numpy array containing the frequencies in range of sweeping - figsize - size of the figure. Default is (6,3) - f_unit - the unit of frequency, often in Hz or GHz. Default is Hz - sparams - a dictionary whose values are either a few 1d arrays containing the measured data, values of model with - initially guessed parameters, and values of the fitted curve, or a few dictionaries, each containing one of - them and the corresponding plotting, and keys are their names. - - Returns - ------- - matplotlib.figure - a figure showing the magnitude, phase, and polar diagrams of the data, the model with initially guessed - parameters, and the fitted curve - """ - fig = plt.figure(constrained_layout=True, figsize=figsize) - gs = fig.add_gridspec(2, 2, width_ratios=[2,1]) - mag_ax = fig.add_subplot(gs[0,0]) - phase_ax = fig.add_subplot(gs[1,0], sharex=mag_ax) - circle_ax = fig.add_subplot(gs[:,1], aspect='equal') - - for name, sparam in sparams.items(): - if isinstance(sparam, np.ndarray): - data = sparam - sparam = {} - elif isinstance(sparam, dict): - data = sparam.pop('data') - else: - raise ValueError(f"cannot accept data of type {type(sparam)}") - - mag_ax.plot(frequency, np.abs(data), label=name, **sparam) - phase_ax.plot(frequency, np.angle(data, deg=False), **sparam) - circle_ax.plot(data.real, data.imag, **sparam) - - mag_ax.legend(loc='best', fontsize='x-small') - mag_ax.set_ylabel('Magnitude') - - phase_ax.set_ylabel('Phase (rad)') - phase_ax.set_xlabel(f'Frequency ({f_unit})') - - circle_ax.set_xlabel('Re') - circle_ax.set_ylabel('Im') - - return fig - - -def fit_and_plot_reflection(f_data: np.ndarray, s11_data: np.ndarray, fn=None, **guesses): - """ convenience function which does the fitting and plotting (and saving to local directory if given the address) - in a single call - - Parameters - ---------- - f_data - 1d numpy array containing the frequencies in range of sweeping - s11_data - 1d numpy array containing the complex measured reflection response data - guesses - (optional) manual guesses on fit parameters - - Returns - ------- - matplotlib.figure - a figure showing the magnitude, phase, and polar diagrams of the data, the model with initially guessed - parameters, and the fitted curve - """ - fit = ReflectionResponse(f_data, s11_data) - guess_result = fit.run(dry=True, **guesses) - guess_y = guess_result.eval() - - fit_result = fit.run(**guesses) - print(fit_result.lmfit_result.fit_report()) - - fit_y = fit_result.eval() - - fig = plot_resonator_response(f_data * 1e-9, f_unit='GHz', - data=dict(data=s11_data, lw=0, marker='.'), - guess=dict(data=guess_y, lw=1, dashes=[1, 1]), - fit=dict(data=fit_y)) - - if fn is not None: - with open(Path(fn.parent, 'fit.txt'), 'w') as f: - f.write(fit_result.lmfit_result.fit_report()) - fig.savefig(Path(fn.parent, 'fit.png')) - print('fit result and plot saved') - - return fig - -def fit_and_plot_resonator_response(f_data: np.ndarray, s11_data: np.ndarray, response_type: str = 'transmission', fn=None, **guesses): - """ convenience function which does the fitting and plotting (and saving to local directory if given the address) - in a single call - - Parameters - ---------- - f_data - 1d numpy array containing the frequencies in range of sweeping - s11_data - 1d numpy array containing the complex measured reflection response data - response_type - name of the response that we want to fit. The default is transmission response - guesses - (optional) manual guesses on fit parameters - - Returns - ------- - matplotlib.figure - a figure showing the magnitude, phase, and polar diagrams of the data, the model with initially guessed - parameters, and the fitted curve - """ - if response_type == 'transmission': - fit = TransmissionResponse(f_data, s11_data) - elif response_type == 'hanger': - fit = HangerResponseBruno(f_data, s11_data) - else: - fit = ReflectionResponse(f_data, s11_data) - guess_result = fit.run(dry=True, **guesses) - guess_y = guess_result.eval() - - fit_result = fit.run(**guesses) - print(fit_result.lmfit_result.fit_report()) - - fit_y = fit_result.eval() - - fig = plot_resonator_response(f_data * 1e-9, f_unit='GHz', - data=dict(data=s11_data, lw=0, marker='.'), - guess=dict(data=guess_y, lw=1, dashes=[1, 1]), - fit=dict(data=fit_y)) - print() - print("===========") - print() - if response_type == 'transmission': - print("Kappa total is", round(fit_result.params['f_0'].value / fit_result.params['Q_t'].value * 1e-6, 3), "MHz") - if response_type == 'hanger': - Q_e_mag = fit_result.params['Q_e_mag'].value - theta = fit_result.params['theta'].value - print("for your convenience: Q_c = 1/Re{1/Q_e} = ", 1 / np.real( 1 / (Q_e_mag*np.exp(-1j*theta)) )) - - - if fn is not None: - with open(Path(fn.parent, 'fit.txt'), 'w') as f: - f.write(fit_result.lmfit_result.fit_report()) - fig.savefig(Path(fn.parent, 'fit.png')) - print('fit result and plot saved') - - return fig diff --git a/labcore/opx/config.py b/labcore/opx/config.py index fbe9625..85e4b4c 100644 --- a/labcore/opx/config.py +++ b/labcore/opx/config.py @@ -6,10 +6,12 @@ import numpy as np from instrumentserver.helpers import nestedAttributeFromString -from .machines import close_my_qm +from qcuiuc_measurement.opx_tools.machines import close_my_qm logger = logging.getLogger(__name__) + +# FIXME: Docstring incomplete class QMConfig: """ Base class for a QMConfig class. The purpose of this class is to implement the real time changes of the @@ -20,7 +22,7 @@ class QMConfig: controllers that this config uses. To not do this pass False to close_other_machines in config(). The user should still manually write the config dictionary used for the specific physical setup that the - sweeping is going to be performed but a few helper methods are implemented in the base class: two helper + measurement is going to be performed but a few helper methods are implemented in the base class: two helper methods to write integration weights and a method that creates and adds the integration weights to the config dict. If the constructor is overriden the new constructor should call the super constructor to pass the parameter manager @@ -64,15 +66,17 @@ class QMConfig: :param opx_port: The port of the OPX where the config is going to get used. """ - def __init__(self, params, opx_address: Optional[str] = None, opx_port: Optional[str] = None) -> None: + def __init__(self, params, opx_address: Optional[str] = None, opx_port: Optional[int] = None, + octave=None) -> None: self.params = params self.opx_address = opx_address self.opx_port = opx_port + self.octave = octave def __call__(self, *args, **kwargs) -> Dict[str, Any]: return self.config() - def config(self, close_other_machines: bool=True) -> Dict[str, Any]: + def config(self, close_other_machines: bool = True) -> Dict[str, Any]: """ Creates the config dictionary. @@ -99,8 +103,8 @@ def add_random_waveform(self, conf): close open QuantumMachines if the configuration is exactly the same. """ config_dict = conf.copy() - config_dict['waveforms']['randon_wf'] = {'type': 'constant', - 'sample': np.random.rand()} + config_dict['waveforms']['random_wf'] = {'type': 'constant', + 'sample': np.random.rand() * 0.1} return config_dict def add_integration_weights(self, conf): @@ -126,21 +130,37 @@ def add_integration_weights(self, conf): # Go throguh pulses and check if they should have integration weights for key in config_dict['pulses'].keys(): - if key[:7] == 'readout' and '_pulse' in key: - split_key = key.split('_pulse') - pulse = split_key[0] + if 'readout_' in key and '_pulse' in key: + path_to_param = key.split('_') + readout_pulse_name = '' + + # find the parameter name as it should be in the parameter manager. + # note: it may be nested under something else! + for k in path_to_param: + if k[:5] == 'pulse': + break # found it! continue... + else: + # add all the stuff it's nested in... + if len(readout_pulse_name) > 0: + readout_pulse_name += f'_{k}' + else: + readout_pulse_name += f"{k}" + + pulse = readout_pulse_name # don't ask... too lazy to find all instances. + readout_param_name = readout_pulse_name.replace('_', '.') + len_param_name = readout_param_name + '.len' + # str with the name of the length of the pulse in the param manager - param_pulse = pulse.replace('_', '.') + '.len' - if self.params.has_param(param_pulse): - if pulse not in pulses.keys(): - pulse_len = nestedAttributeFromString(self.params, param_pulse)() + if self.params.has_param(len_param_name): + if readout_pulse_name not in pulses.keys(): + pulse_len = nestedAttributeFromString(self.params, len_param_name)() # Using the old integration weights style for the sliced weights because the OPX currently # raises an exception when using the new ones. flat = [(0.2, pulse_len)] - flat_sliced = [0.2] * int(pulse_len//4) + flat_sliced = [0.2] * int(pulse_len // 4) empty = [(0.0, pulse_len)] - empty_sliced = [0.0] * int(pulse_len//4) + empty_sliced = [0.0] * int(pulse_len // 4) pulses[pulse] = {} pulses[pulse][pulse + '_cos'] = { @@ -220,7 +240,6 @@ def add_integration_weights(self, conf): config_dict['integration_weights'] = integration_weights - if loaded_weights is not None: # Check that there are not old integration weights for pulses that don't exists anymore. delete = [] @@ -240,7 +259,6 @@ def add_integration_weights(self, conf): with open(integration_weights_file, 'w') as file: json.dump(loaded_weights, file) - return config_dict # The following are helper methods written by Quantum Machines to create integration weights @@ -309,3 +327,6 @@ def compress_integration_weights(self, integration_weights, N=100): integration_weights.T[1].astype(int).tolist())) return integration_weights + + def configure_octave(self, qmm, qm): + raise NotImplementedError diff --git a/labcore/opx/sweep.py b/labcore/opx/sweep.py index 0a25472..b701bf1 100644 --- a/labcore/opx/sweep.py +++ b/labcore/opx/sweep.py @@ -1,25 +1,25 @@ -from typing import Dict, Generator, Optional -import numpy as np +from typing import Callable, Dict, Generator, List, Optional +from functools import wraps from dataclasses import dataclass +import time +import logging + +import numpy as np from qm.qua import * from qm.QuantumMachinesManager import QuantumMachinesManager -from labcore.sweep import * -from labcore.sweep.record import make_data_spec -from labcore.sweep.sweep import AsyncRecord - -from labcore.opx.config import QMConfig - +from labcore.measurement import * +from labcore.measurement.record import make_data_spec +from labcore.measurement.sweep import AsyncRecord -### Options that need to be set by the user for the OPX to work +from .config import QMConfig +# --- Options that need to be set by the user for the OPX to work --- # config object that when called returns the config dictionary as expected by the OPX -config: Optional[QMConfig] = None # OPX config dictionary +config: Optional[QMConfig] = None # OPX config dictionary -# address and port of the OPX we're using -# opx_host: Optional[str] = None -# opx_port: Optional[str] = None +logger = logging.getLogger(__name__) @dataclass @@ -30,7 +30,8 @@ def __post_init__(self): deps = [] else: deps = list(self.depends_on) - self.depends_on = [self.name+'_time_points'] + deps + self.depends_on = [self.name + '_time_points'] + deps + @dataclass class ComplexOPXData(DataSpec): @@ -58,12 +59,16 @@ def __init__(self, *specs): def setup(self, fun, *args, **kwargs) -> None: """ - Establishes connection with the OPX and starts the sweeping. The config of the OPX is passed through + Establishes connection with the OPX and starts the measurement. The config of the OPX is passed through the module variable global_config. It saves the result handles and saves initial values to the communicator dictionary. """ - # Start the sweeping in the OPX. - qmachine_mgr = QuantumMachinesManager(host=config.opx_address, port=config.opx_port) + # Start the measurement in the OPX. + qmachine_mgr = QuantumMachinesManager(host=config.opx_address, port=config.opx_port, + octave=config.octave) + qmachine = qmachine_mgr.open_qm(config(), close_other_machines=False) + if config.octave is not None: + config.configure_octave(qmachine_mgr, qmachine) qmachine = qmachine_mgr.open_qm(config(), close_other_machines=False) job = qmachine.execute(fun(*args, **kwargs)) result_handles = job.result_handles @@ -128,12 +133,21 @@ def cleanup(self): Currently, manually closes the qmachine in the OPT so that simultaneous measurements can occur. """ + logger.info('Cleaning up') + manager = self.communicator['manager'] qm_id = self.communicator['qmachine_id'] open_machines = manager.list_open_quantum_machines() + logger.info(f"currently open QMs: {open_machines}") if qm_id in open_machines: qmachine = manager.get_qm(qm_id) qmachine.close() + logger.info(f"QM with ID {qm_id} closed.") + + manager.close() + logger.info(f"QMM closed.") + del self.communicator['qmachine'] + del self.communicator['manager'] def collect(self, batchsize: int = 100) -> Generator[Dict, None, None]: """ @@ -193,7 +207,7 @@ def get_data_from_handle(name, up_to): print(f'counter is: {self.communicator["counter"]}') if qdata is not None and idata is not None: - return_data[ds.name] = idata + 1j*qdata + return_data[ds.name] = idata + 1j * qdata elif ds.name in self.user_data: continue @@ -210,11 +224,12 @@ def get_data_from_handle(name, up_to): if isinstance(ds, TimedOPXData): data = return_data[ds.name] if data is not None: - tvals = np.arange(1, data.shape[-1]+1) + tvals = np.arange(1, data.shape[-1] + 1) if len(data.shape) == 1: return_data[name + '_time_points'] = tvals elif len(data.shape) == 2: - return_data[name + '_time_points'] = np.tile(tvals, data.shape[0]).reshape(data.shape[0], -1) + return_data[name + '_time_points'] = np.tile(tvals, data.shape[0]).reshape( + data.shape[0], -1) else: raise NotImplementedError('someone needs to look at data saving ASAP...') @@ -224,4 +239,3 @@ def get_data_from_handle(name, up_to): finally: self.cleanup() - diff --git a/labcore/plotting/basics.py b/labcore/plotting/basics.py index 787750d..8a9c39f 100644 --- a/labcore/plotting/basics.py +++ b/labcore/plotting/basics.py @@ -15,10 +15,11 @@ from plottr.analyzer.fitters.fitter_base import FitResult, Fit -default_cmap = cm.viridis +# default_cmap = cm.viridis logger = logging.getLogger(__name__) + def _fit_and_plot(x: Union[List, Tuple, ndarray], y: Union[List, Tuple, ndarray], ax: Axes, residual_ax: Optional[Axes] = None, data_color: str = 'tab:blue', data_label: str = 'data', fit_class: Optional[Fit] = None, @@ -133,7 +134,7 @@ def plot_data_and_fit_1d(x: Union[List, Tuple, ndarray], y: Union[List, Tuple, n if fig is None: fig = plt.figure() - if any(np.iscomplex(y)): + if np.iscomplex(y).any(): y_ = y.real logger.warning('Ignoring imaginary part of the data.') else: @@ -256,13 +257,13 @@ def pplot(ax, x, y, yerr=None, linex=None, liney=None, color=None, fmt='o', return tuple(syms) -def ppcolormesh(ax, x, y, z, cmap=default_cmap, make_grid=True, **kw): +def ppcolormesh(ax, x, y, z, make_grid=True, **kw): if make_grid: _x, _y = pcolorgrid(x, y) else: _x, _y = x, y - im = ax.pcolormesh(_x, _y, z, cmap=cmap, **kw) + im = ax.pcolormesh(_x, _y, z, **kw) ax.set_xlim(_x.min(), _x.max()) ax.set_ylim(_y.min(), _y.max()) @@ -270,7 +271,7 @@ def ppcolormesh(ax, x, y, z, cmap=default_cmap, make_grid=True, **kw): def waterfall(ax, xs, ys, offset=None, style='pplot', **kw): - cmap = kw.pop('cmap', default_cmap) + cmap = kw.pop('cmap', mpl.rcParams['image.cmap']) linex = kw.pop('linex', xs) liney = kw.pop('liney', None) draw_baselines = kw.pop('draw_baselines', False) @@ -445,7 +446,7 @@ def format_ax(ax, top=False, right=False, xlog=False, ylog=False, if isinstance(yticks, list): ax.yaxis.set_major_locator(ticker.FixedLocator(yticks)) if ylim is not None: - ax.set_xlim(ylim) + ax.set_ylim(ylim) elif ylim is not None: ax.yaxis.set_major_locator(ticker.LinearLocator(yticks)) ax.set_ylim(ylim) @@ -481,15 +482,20 @@ def add_legend(ax, anchor_point=(1, 1), legend_ref_point='lower right', **labels def setup_plotting(sns_style='whitegrid', rcparams={}): # some sensible defaults for sizing, those are for a typical print-plot + sns.set_style(sns_style) + mpl.rcParams['figure.constrained_layout.use'] = True mpl.rcParams['figure.dpi'] = 300 mpl.rcParams['figure.figsize'] = (3, 2) - mpl.rcParams['font.family'] = 'Arial', 'Helvetica' + # mpl.rcParams['font.family'] = 'Noto Sans Math', 'Arial', 'Helvetica', 'DejaVu Sans' mpl.rcParams['font.size'] = 6 + # mpl.rcParams['lines.marker'] = 'o' mpl.rcParams['lines.markersize'] = 3 mpl.rcParams['lines.linewidth'] = 1.5 mpl.rcParams['axes.linewidth'] = 0.5 + mpl.rcParams['axes.titlesize'] = 'medium' mpl.rcParams['grid.linewidth'] = 0.5 + mpl.rcParams['image.cmap'] = 'RdPu' mpl.rcParams['legend.fontsize'] = 5 mpl.rcParams['legend.frameon'] = False mpl.rcParams['xtick.major.width'] = 0.5 @@ -498,5 +504,4 @@ def setup_plotting(sns_style='whitegrid', rcparams={}): mpl.rcParams['ytick.major.size'] = 2 mpl.rcParams["mathtext.fontset"] = 'dejavusans' - sns.set_style(sns_style) mpl.rcParams.update(rcparams) diff --git a/labcore/setup/setup_measurements.py b/labcore/setup/setup_measurements.py index db88df1..ab8f40e 100644 --- a/labcore/setup/setup_measurements.py +++ b/labcore/setup/setup_measurements.py @@ -1,18 +1,19 @@ import os import sys import logging -from typing import Optional, Any, Union, Dict, Tuple +from typing import Optional, Any, Union, List, Dict, Tuple +from functools import partial from dataclasses import dataclass from pathlib import Path from instrumentserver.client import Client, ProxyInstrument -from labcore.sweep.ddh5 import run_and_save_sweep -from labcore.sweep.sweep import Sweep +from labcore.ddh5 import run_and_save_sweep +from labcore.measurement import Sweep from plottr.data.datadict import DataDict -from labcore.analysis.data import data_info +from .analysis.data import data_info # constants diff --git a/labcore/setup/setup_notebook_analysis.py b/labcore/setup/setup_notebook_analysis.py index eca491e..f7bba18 100644 --- a/labcore/setup/setup_notebook_analysis.py +++ b/labcore/setup/setup_notebook_analysis.py @@ -1,5 +1,7 @@ +import matplotlib as mpl +from matplotlib import pyplot as plt +import seaborn as sns - -from .analysis.plotting import setup_plotting +from .analysis.plotting import setup_plotting, format_ax setup_plotting(rcparams={'figure.dpi': 200}) diff --git a/labcore/setup/setup_opx_measurements.py b/labcore/setup/setup_opx_measurements.py index 06eda82..9f6a3ae 100644 --- a/labcore/setup/setup_opx_measurements.py +++ b/labcore/setup/setup_opx_measurements.py @@ -7,19 +7,29 @@ import os os.environ['QM_DISABLE_STREAMOUTPUT'] = "1" +from typing import Optional, Callable +from dataclasses import dataclass +from functools import partial + from IPython.display import display import ipywidgets as widgets -from qm.QuantumMachinesManager import QuantumMachinesManager, QuantumMachine +# FIXME: only until everyone uses the latest qm packages. +try: + from qm.QuantumMachinesManager import QuantumMachinesManager, QuantumMachine +except: + from qm.QuantumMachinesManager import QuantumMachinesManager + from qm import QuantumMachine + from qm.qua import * from instrumentserver.helpers import nestedAttributeFromString -from labcore.opx.config import QMConfig +from .opx_tools.config import QMConfig from .opx_tools import sweep as qmsweep -from qcuiuc_measurement.opx_msmt.mixer import MixerConfig, mixer_of_step, mixer_imb_step +from .opx_tools.mixer import calibrate_mixer, MixerConfig, mixer_of_step, mixer_imb_step from . import setup_measurements from .setup_measurements import * @@ -67,16 +77,23 @@ def step_imb(self, dg, dp): raise RuntimeError('No active QuantumMachine.') mixer_imb_step(self.config, self.qm, dg, dp) -def add_mixer_config(element_name, analyzer, generator, **config_kwargs): +def add_mixer_config(element_name, analyzer, generator, element_to_param_map=None, **config_kwargs): + """ + FIXME: add docu (@wpfff) + TODO: make sure we document the meaning of `element_to_param_map`. + """ + if element_to_param_map is None: + element_to_param_map = element_name + cfg = MixerConfig( qmconfig=options.qm_config, opx_address=options.qm_config.opx_address, opx_port=options.qm_config.opx_port, analyzer=analyzer, generator=generator, - if_param=nestedAttributeFromString(options.parameters, f"{element_name}.IF"), - offsets_param=nestedAttributeFromString(options.parameters, f"mixers.{element_name}.offsets"), - imbalances_param=nestedAttributeFromString(options.parameters, f"mixers.{element_name}.imbalance"), + if_param=nestedAttributeFromString(options.parameters, f"{element_to_param_map}.IF"), + offsets_param=nestedAttributeFromString(options.parameters, f"mixers.{element_to_param_map}.offsets"), + imbalances_param=nestedAttributeFromString(options.parameters, f"mixers.{element_to_param_map}.imbalance"), mixer_name=f'{element_name}_IQ_mixer', element_name=element_name, pulse_name='constant', From 6953cb3f011ec442d49414a4b33e66ae784e0117 Mon Sep 17 00:00:00 2001 From: marcosf2 Date: Fri, 9 Jun 2023 11:36:27 -0500 Subject: [PATCH 6/7] Update from measurement tools. --- labcore/analysis/data.py | 134 +++++++++++++++++++++++++++++++++---- labcore/plotting/basics.py | 54 ++++++++------- 2 files changed, 151 insertions(+), 37 deletions(-) diff --git a/labcore/analysis/data.py b/labcore/analysis/data.py index c487763..7363420 100644 --- a/labcore/analysis/data.py +++ b/labcore/analysis/data.py @@ -1,21 +1,28 @@ """Tools for more convenient data handling.""" - -from typing import Union, List, Optional, Type +import os +import re +from typing import Union, List, Optional, Type, Any, Dict from types import TracebackType from pathlib import Path from datetime import datetime import json +import logging import numpy as np from matplotlib.figure import Figure from matplotlib import pyplot as plt from sklearn.decomposition import PCA +from plottr.analyzer.base import AnalysisResult +from plottr.analyzer.fitters.fitter_base import FitResult from plottr.data.datadict import DataDictBase, datadict_to_meshgrid, MeshgridDataDict from plottr.data.datadict_storage import datadict_from_hdf5 +logger = logging.getLogger(__name__) + + def data_info(folder: str, fn: str = 'data.ddh5', do_print: bool = True): fn = Path(folder, fn) dataset = datadict_from_hdf5(fn) @@ -25,6 +32,38 @@ def data_info(folder: str, fn: str = 'data.ddh5', do_print: bool = True): return str(dataset) +def timestamp_from_path(p: Path) -> datetime: + """Return a `datetime` timestamp from a standard-formatted path. + Assumes that the path stem has a timestamp that begins in ISO-like format + ``YYYY-mm-ddTHHMMSS``. + """ + timestring = str(p.stem)[:13] + ":" + str(p.stem)[13:15] + ":" + str(p.stem)[15:17] + return datetime.fromisoformat(timestring) + + +def find_data(root, + newer_than: Optional[datetime]=None, + older_than: Optional[datetime]=None, + folder_filter: Optional[str]=None) -> List[Path]: + + folders = [] + for f, dirs, files in os.walk(root): + if 'data.ddh5' in files: + fp = Path(f) + ts = timestamp_from_path(fp) + if newer_than is not None and ts <= newer_than: + continue + if newer_than is not None and ts >= older_than: + continue + if folder_filter is not None: + pattern = re.compile(folder_filter) + if not pattern.match(str(fp.stem)): + continue + + folders.append(fp) + return sorted(folders) + + def get_data( folder: Union[str, Path], data_name: Optional[Union[str, List[str]]] = None, @@ -68,10 +107,10 @@ def get_data( data_name = dataset.dependents() elif isinstance(data_name, str): data_name = [data_name] - dataset = dataset.extract(data_name) + dataset = dataset.extract(data_name, copy=False) if mk_grid: - dataset = datadict_to_meshgrid(dataset) + dataset = datadict_to_meshgrid(dataset, copy=False) if avg_over is not None and avg_over in dataset.axes() and isinstance(dataset, MeshgridDataDict): dataset = dataset.mean(avg_over) @@ -87,6 +126,7 @@ def get_data( ) dataset[d]['values'] = newdata.reshape(shp) + dataset.validate() return dataset @@ -99,7 +139,7 @@ def __init__(self, folder): self.folder = Path(self.folder) self.timestamp = str(datetime.now().replace(microsecond=0).isoformat().replace(':', '')) - self.figures = {} + self.additionals = {} def __enter__(self): return self @@ -109,10 +149,12 @@ def __exit__(self, exc_type: Optional[Type[BaseException]], traceback: Optional[TracebackType]) -> None: pass - def save(self): - for n, f in self.figures.items(): - self.save_figure(f, n) + def _new_file_path(self, name: str, suffix: str = '') -> Path: + if suffix != '': + name = name + '.' + suffix + return Path(self.folder, f"{self.timestamp}_{name}") + # --- loading measurement data --- # def get_data(self, data_name, *arg, **kw): return get_data(self.folder, data_name, *arg, **kw) @@ -129,13 +171,46 @@ def load_saved_parameter(self, parameter_name, return data[parameter_path]['value'] - def make_figure(self, name, *arg, **kwargs): + # --- Adding analysis results --- # + def add(self, **kwargs: Any) -> None: + for k, v in kwargs.items(): + if k in self.additionals: + raise ValueError('element with that name already exists in this analysis.') + self.additionals[k] = v + + def add_figure(self, name, *arg, fig: Optional[None], **kwargs) -> Figure: if name in self.figures: - raise ValueError('figure with that name already exists in this analysis') - fig = plt.figure(*arg, **kwargs) - self.figures[name] = fig + raise ValueError('element with that name already exists in this analysis.') + if fig is None: + fig = plt.figure(*arg, **kwargs) + self.additionals[name] = fig return fig + make_figure = add_figure + + # --- Saving analysis results --- # + def save(self): + for name, element in self.additionals.items(): + if isinstance(element, Figure): + fp = self.save_figure(element, name) + + elif isinstance(element, AnalysisResult): + fp = self.save_add_dict_data(element.params_to_dict(), name+"_params") + if isinstance(element, FitResult): + fp = self.save_add_str(element.lmfit_result.fit_report(), name+"_lmfit_report") + + elif isinstance(element, np.ndarray): + fp = self.save_add_np(element, name) + + elif isinstance(element, dict): + fp = self.save_add_dict_data(element, name) + + elif isinstance(element, str): + fp = self.save_add_str(element, name) + + else: + logger.error(f"additional data '{name}' is not supported for saving!") + def save_figure(self, fig: Figure, name: str): """save a figure in a standard way to the dataset directory. @@ -160,6 +235,37 @@ def save_figure(self, fig: Figure, name: str): fig.suptitle(f"{self.folder.name}: {name}", fontsize='small') for f in fmts: - fn = Path(self.folder, f"{self.timestamp}_{name}.{f}") - fig.savefig(fn) + fp = self._new_file_path(name, f) + fig.savefig(fp) + + return fp + + def save_add_dict_data(self, data: dict, name: str): + fp = self._new_file_path(name, 'json') + # d = dict_arrays_to_list(data) + with open(fp, 'x') as f: + json.dump(data, f, cls=NumpyEncoder) + return fp + + def save_add_str(self, data: str, name: str): + fp = self._new_file_path(name, 'txt') + with open(fp, 'x') as f: + f.write(data) + return fp + + def save_add_np(self, data: np.ndarray, name: str): + fp = self._new_file_path(name, 'json') + with open(fp, 'x') as f: + json.dump({name: data}, f, cls=NumpyEncoder) + + # --- loading (and managing) earlier analysis results --- # + # TBD... + + +# enable saving numpy to json +class NumpyEncoder(json.JSONEncoder): + def default(self, obj): + if isinstance(obj, np.ndarray): + return obj.tolist() + return json.JSONEncoder.default(self, obj) diff --git a/labcore/plotting/basics.py b/labcore/plotting/basics.py index 8a9c39f..e2a343f 100644 --- a/labcore/plotting/basics.py +++ b/labcore/plotting/basics.py @@ -14,7 +14,6 @@ from plottr.analyzer.fitters.fitter_base import FitResult, Fit - # default_cmap = cm.viridis logger = logging.getLogger(__name__) @@ -92,8 +91,8 @@ def _fit_and_plot(x: Union[List, Tuple, ndarray], y: Union[List, Tuple, ndarray] def plot_data_and_fit_1d(x: Union[List, Tuple, ndarray], y: Union[List, Tuple, ndarray], fit_class: Optional[Fit] = None, - xlabel: str ='', - ylabel: str='', + xlabel: str = '', + ylabel: str = '', initial_guess: bool = False, fig: Optional[Figure] = None, **guesses) -> Tuple[Figure, FitResult]: @@ -156,7 +155,8 @@ def plot_data_and_fit_1d(x: Union[List, Tuple, ndarray], y: Union[List, Tuple, n return fig, fit_result -def readout_hist(signal: ndarray, title: Optional[str] = '') -> Figure: +def readout_hist(signal: ndarray, fig_ax: Optional[Tuple[Figure, Axes]] = None, + nbins: int = 41) -> Tuple[Figure, Axes]: """ Plots an IQ histogram. @@ -164,8 +164,6 @@ def readout_hist(signal: ndarray, title: Optional[str] = '') -> Figure: ---------- signal: array-like, data in complex form. - title: - The title of the figure. Defaults to ''. Returns ------- @@ -174,22 +172,33 @@ def readout_hist(signal: ndarray, title: Optional[str] = '') -> Figure: """ I = signal.real Q = signal.imag - lim = max((I**2. + Q**2.)**.5) - fig, ax = plt.subplots(1,1, constrained_layout=True) - fig.suptitle(title, size='small') + lim = max((I ** 2. + Q ** 2.) ** .5) + + if fig_ax is None: + fig, ax = plt.subplots(1, 1) + else: + fig, ax = fig_ax + ax.set_xlabel('I') ax.set_ylabel('Q') - ax.axvline(0, color='w') - ax.axhline(0, color='w') - im = ax.hist2d(I, Q, bins=101, range=[[-lim, lim], [-lim, lim]]) + ax.axvline(0, color='k', lw=0.5, dashes=[2, 2]) + ax.axhline(0, color='k', lw=0.5, dashes=[2, 2]) + _hist, _xe, _ye, im = ax.hist2d(I, Q, bins=nbins, + range=[[-lim, lim], [-lim, lim]]) - return fig + ax.set_aspect('equal') + format_ax(ax, xlabel='I', ylabel='Q') + + cb = fig.colorbar(im, ax=ax, shrink=0.5) + format_right_cb(cb) + cb.ax.set_xlabel('cts', ha='left') + + return fig, ax # tools for prettier plotting def pplot(ax, x, y, yerr=None, linex=None, liney=None, color=None, fmt='o', alpha=0.5, mew=0.5, **kw): - zorder = kw.pop('zorder', 2) line_dashes = kw.pop('line_dashes', []) line_lw = kw.pop('line_lw', 2) @@ -224,9 +233,9 @@ def pplot(ax, x, y, yerr=None, linex=None, liney=None, color=None, fmt='o', # be hidden behind the line...) if yerr is not None: err = ax.errorbar(x, y, yerr=yerr, fmt='none', ecolor=color, capsize=0, - elinewidth=elinewidth, zorder=zorder-1) + elinewidth=elinewidth, zorder=zorder - 1) empty_symbol_kws = edge_plot_kws.copy() - empty_symbol_kws.update({'mfc': 'w', 'mew': 0, 'zorder': zorder-1}, ) + empty_symbol_kws.update({'mfc': 'w', 'mew': 0, 'zorder': zorder - 1}, ) _ = ax.plot(x, y, fmt, **empty_symbol_kws) # syms.append(err) @@ -244,7 +253,7 @@ def pplot(ax, x, y, yerr=None, linex=None, liney=None, color=None, fmt='o', fill_color = color fill, = ax.plot(x, y, fmt, mec='none', mfc=fill_color, alpha=alpha, - zorder=zorder-1, **kw) + zorder=zorder - 1, **kw) syms.append(fill) syms.append(edge) @@ -422,7 +431,6 @@ def correctly_sized_figure(widths, heights, margins=0.5, dw=0.2, dh=0.2, make_ax def format_ax(ax, top=False, right=False, xlog=False, ylog=False, xlabel=None, ylabel=None, xlim=None, ylim=None, xticks=3, yticks=3): - ax.tick_params(axis='x', which='both', pad=2, top=top, labeltop=top, bottom=not top, labelbottom=not top) if top: @@ -462,10 +470,10 @@ def format_ax(ax, top=False, right=False, xlog=False, ylog=False, ax.yaxis.labelpad = 2 -def format_right_cax(cax): - format_ax(cax, right=True) - cax.tick_params(axis='x', top='off', bottom='off', labelbottom='off', - labeltop='off') +def format_right_cb(cb): + cb.outline.set_visible(False) + cb.ax.xaxis.set_visible(True) + cb.ax.xaxis.set_label_position('top') def add_legend(ax, anchor_point=(1, 1), legend_ref_point='lower right', **labels_and_handles): @@ -504,4 +512,4 @@ def setup_plotting(sns_style='whitegrid', rcparams={}): mpl.rcParams['ytick.major.size'] = 2 mpl.rcParams["mathtext.fontset"] = 'dejavusans' - mpl.rcParams.update(rcparams) + mpl.rcParams.update(rcparams) \ No newline at end of file From 1411330c57d63c0ccc6b228d799207f340b7533b Mon Sep 17 00:00:00 2001 From: marcosf2 Date: Fri, 9 Jun 2023 14:01:46 -0500 Subject: [PATCH 7/7] removing old documentation and fixing tests --- prototyping/Developing_opx_labcore.ipynb | 1992 ----------------- prototyping/configuration.py | 139 -- ...configuring sweeps and lazy pointers.ipynb | 463 ---- .../structured_OPX_implementation.ipynb | 772 ------- test/pytest/test_run_and_save.py | 4 +- 5 files changed, 2 insertions(+), 3368 deletions(-) delete mode 100644 prototyping/Developing_opx_labcore.ipynb delete mode 100644 prototyping/configuration.py delete mode 100644 prototyping/configuring sweeps and lazy pointers.ipynb delete mode 100644 prototyping/structured_OPX_implementation.ipynb diff --git a/prototyping/Developing_opx_labcore.ipynb b/prototyping/Developing_opx_labcore.ipynb deleted file mode 100644 index 7e78944..0000000 --- a/prototyping/Developing_opx_labcore.ipynb +++ /dev/null @@ -1,1992 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "7e57fb25-d0f5-43fc-82b1-427506628ebc", - "metadata": {}, - "source": [ - "# Simulated OPX" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "seventh-madrid", - "metadata": {}, - "outputs": [], - "source": [ - "import time\n", - "from functools import wraps\n", - "\n", - "\n", - "from pprint import pprint\n", - "import numpy as np\n", - "import qcodes as qc\n", - "\n", - "from labcore.measurement import *\n", - "\n", - "from configuration import QMConfig\n", - "from qm.qua import *\n", - "from qm.QuantumMachinesManager import QuantumMachinesManager\n", - "\n", - "from plottr.data import datadict_storage as dds, datadict as dd\n", - "\n", - "# global module variable for the config file\n", - "global_config = None\n", - "\n", - "\n", - "# variable used for development\n", - "test_name_counter = 0\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "revolutionary-intersection", - "metadata": {}, - "outputs": [], - "source": [ - "class dummy_opx:\n", - " def __init__(self, shape, sleep, num_lines):\n", - " self.shape = shape \n", - " self.sleep = sleep\n", - " self.num_lines = num_lines\n", - " \n", - " self.processing = True\n", - " self.counter = 0\n", - " \n", - " def is_processing(self):\n", - " return self.processing\n", - " \n", - " \n", - " def get_data(self, batch):\n", - " if self.processing:\n", - " ret = []\n", - " for i in range(len(self.shape)):\n", - " if i == 0:\n", - " ret.append(np.arange(batch))\n", - " else:\n", - " ret.append(np.random.randint(0,10, (batch, self.shape[i])))\n", - " self.counter += batch\n", - " if self.counter >= self.num_lines:\n", - " self.processing = False\n", - " time.sleep(self.sleep)\n", - " return tuple(ret)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "small-botswana", - "metadata": {}, - "outputs": [], - "source": [ - "def start_experiment(): \n", - " print('running the experiment in the OPX (not implemented)')\n", - "\n", - "def conditional_generator(control):\n", - " \"\"\"\n", - " Generator that returns a list of increasing integers as long as the argument control has a boolean\n", - " variable called active that is True. The generator stops when the variable becomes False. \n", - " \"\"\"\n", - " counter_internal = -1\n", - "\n", - " # In the while goes whatever condition needs to be done to stop measuring\n", - " while control.is_processing():\n", - " counter_internal += 1\n", - " yield counter_internal\n", - " \n", - " \n", - "def create_sweep(opx_program, batchsize, num_lines):\n", - " # instantiating necessary objects\n", - " @recording(\n", - " independent('repetition', type='array'),\n", - " dependent('variable', type='array'),\n", - " dependent('independent', depends_on=['repetition','variable'], type='array'))\n", - " def gather_data():\n", - "\n", - " data = 0\n", - " data = result_handle.get_data(batchsize)\n", - " return tuple(data)\n", - " \n", - " # This would instantiate all of the QM stuff and return the reulst handle\n", - " \n", - " result_handle = opx_program((1,10,10), 1, num_lines)\n", - " sweep_param = sweep_parameter('ignore_param', conditional_generator(result_handle), record_as(gather_data))\n", - " sweep = Sweep(once(start_experiment) + sweep_param)\n", - " return(sweep)\n", - "\n", - "def create_structure(sweep):\n", - " data_specs = sweep.get_data_specs()\n", - " data_dict = dd.DataDict()\n", - " for spec in data_specs:\n", - " print(spec)\n", - " depends_on = spec.depends_on\n", - " unit = spec.unit\n", - " name = spec.name\n", - " if name != 'ignore_param':\n", - " if depends_on is None:\n", - " if unit is None:\n", - " data_dict[name] = dict()\n", - " else:\n", - " data_dict[name] = dict(unit = unit)\n", - " else:\n", - " if unit is None:\n", - " data_dict[name] = dict(axes = depends_on[1:])\n", - " else:\n", - " data_dict[name] = dict(axes = depends_on[1:], unit = unit)\n", - "\n", - " print(data_dict)\n", - " data_dict.validate()\n", - " \n", - " return data_dict\n", - "\n", - "def check_none(argument):\n", - " for arg in argument.keys():\n", - " if argument[arg] is not None:\n", - " return False\n", - " return True\n", - "\n", - "def run_sweep(sweep, data_dir, name, prt=True):\n", - " data_dict = create_structure(sweep)\n", - " with dds.DDH5Writer(data_dir, data_dict, name=name) as writer:\n", - " for line in sweep:\n", - " if not check_none(line):\n", - " line.pop('ignore_param')\n", - " if prt:\n", - " print(line)\n", - " writer.add_data(**line)\n", - " print('The measurement has finished and all of the data has been saved.')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "advanced-globe", - "metadata": {}, - "outputs": [], - "source": [ - "#program = dummy_opx((1,1,1,5), 1)\n", - "DATADIR = './data/'\n", - "sweep = create_sweep(dummy_opx, 5, 50)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "dd024f83-da3a-4980-8d84-1e2ce9380c02", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DataSpec(name='ignore_param', depends_on=None, type=, unit='')\n", - "DataSpec(name='repetition', depends_on=None, type=, unit='')\n", - "DataSpec(name='variable', depends_on=['ignore_param'], type=, unit='')\n", - "DataSpec(name='independent', depends_on=['ignore_param', 'repetition', 'variable'], type=, unit='')\n", - "{'repetition': {'unit': ''}, 'variable': {'axes': [], 'unit': ''}, 'independent': {'axes': ['repetition', 'variable'], 'unit': ''}}\n", - "Data location: ./data/2021-07-26\\2021-07-26_0023_test_3\\2021-07-26_0023_test_3.ddh5\n", - "running the experiment in the OPX (not implemented)\n", - "{'repetition': array([0, 1, 2, 3, 4]), 'variable': array([[1, 0, 3, 3, 4, 4, 2, 0, 2, 7],\n", - " [6, 7, 2, 7, 3, 3, 2, 6, 6, 8],\n", - " [3, 7, 1, 7, 3, 2, 1, 5, 3, 6],\n", - " [9, 8, 2, 8, 7, 4, 6, 3, 0, 7],\n", - " [4, 9, 7, 7, 5, 2, 8, 4, 4, 4]]), 'independent': array([[0, 7, 4, 8, 7, 0, 5, 8, 0, 2],\n", - " [1, 1, 6, 0, 9, 8, 6, 4, 5, 3],\n", - " [8, 6, 6, 7, 8, 6, 2, 7, 1, 2],\n", - " [8, 3, 8, 1, 3, 5, 5, 6, 1, 7],\n", - " [3, 0, 4, 3, 0, 1, 3, 4, 9, 5]])}\n", - "{'repetition': array([0, 1, 2, 3, 4]), 'variable': array([[0, 2, 9, 2, 2, 2, 6, 4, 2, 9],\n", - " [0, 9, 6, 5, 4, 4, 3, 5, 9, 6],\n", - " [5, 1, 5, 8, 8, 7, 6, 2, 9, 7],\n", - " [4, 7, 9, 9, 3, 7, 3, 3, 4, 3],\n", - " [0, 8, 4, 3, 1, 0, 4, 3, 5, 3]]), 'independent': array([[2, 5, 8, 3, 6, 2, 7, 3, 5, 9],\n", - " [5, 2, 0, 3, 9, 8, 2, 0, 5, 0],\n", - " [8, 7, 3, 1, 3, 2, 2, 6, 8, 1],\n", - " [4, 0, 6, 6, 4, 5, 6, 2, 3, 3],\n", - " [6, 5, 2, 1, 1, 2, 4, 2, 9, 3]])}\n", - "{'repetition': array([0, 1, 2, 3, 4]), 'variable': array([[0, 5, 5, 7, 6, 9, 2, 2, 6, 8],\n", - " [3, 9, 4, 0, 6, 4, 4, 5, 6, 7],\n", - " [7, 3, 5, 0, 4, 2, 8, 2, 8, 7],\n", - " [4, 1, 4, 4, 3, 8, 1, 4, 8, 6],\n", - " [3, 4, 6, 4, 5, 1, 9, 3, 4, 1]]), 'independent': array([[1, 0, 5, 2, 1, 4, 9, 2, 7, 4],\n", - " [4, 4, 2, 1, 7, 4, 7, 1, 2, 5],\n", - " [8, 3, 8, 0, 6, 9, 7, 8, 8, 5],\n", - " [3, 5, 0, 8, 3, 1, 0, 9, 8, 6],\n", - " [1, 1, 5, 6, 7, 1, 8, 4, 4, 8]])}\n", - "{'repetition': array([0, 1, 2, 3, 4]), 'variable': array([[8, 9, 8, 2, 3, 5, 0, 8, 7, 4],\n", - " [3, 5, 7, 7, 7, 7, 8, 7, 2, 7],\n", - " [8, 3, 7, 0, 1, 7, 1, 9, 5, 6],\n", - " [3, 3, 1, 3, 0, 7, 6, 8, 7, 3],\n", - " [1, 6, 0, 3, 7, 9, 1, 5, 3, 9]]), 'independent': array([[3, 4, 1, 9, 0, 2, 3, 1, 7, 2],\n", - " [1, 6, 1, 8, 8, 2, 0, 5, 4, 2],\n", - " [6, 1, 9, 7, 2, 6, 8, 1, 2, 1],\n", - " [8, 5, 1, 8, 1, 5, 2, 2, 5, 8],\n", - " [1, 5, 9, 1, 1, 1, 6, 8, 9, 3]])}\n", - "{'repetition': array([0, 1, 2, 3, 4]), 'variable': array([[7, 5, 5, 6, 6, 1, 2, 2, 7, 9],\n", - " [5, 6, 8, 1, 5, 7, 0, 2, 2, 9],\n", - " [2, 0, 2, 5, 7, 9, 9, 4, 0, 3],\n", - " [9, 1, 9, 1, 3, 0, 0, 3, 0, 4],\n", - " [9, 7, 1, 7, 9, 5, 0, 7, 6, 2]]), 'independent': array([[6, 8, 9, 9, 8, 9, 4, 8, 6, 2],\n", - " [4, 8, 9, 4, 8, 0, 3, 4, 4, 1],\n", - " [8, 2, 9, 0, 1, 6, 8, 5, 8, 9],\n", - " [0, 2, 9, 7, 4, 8, 4, 5, 7, 1],\n", - " [4, 3, 2, 1, 8, 4, 1, 7, 8, 5]])}\n", - "{'repetition': array([0, 1, 2, 3, 4]), 'variable': array([[1, 3, 7, 5, 7, 6, 8, 2, 7, 3],\n", - " [7, 9, 6, 4, 5, 7, 4, 3, 4, 4],\n", - " [8, 6, 9, 9, 5, 6, 9, 6, 4, 3],\n", - " [4, 9, 9, 1, 1, 5, 5, 9, 5, 1],\n", - " [7, 9, 6, 2, 1, 0, 8, 5, 4, 4]]), 'independent': array([[2, 0, 1, 1, 3, 2, 8, 2, 2, 5],\n", - " [9, 4, 8, 1, 5, 5, 6, 6, 3, 0],\n", - " [9, 4, 2, 8, 8, 5, 7, 1, 1, 0],\n", - " [2, 4, 2, 4, 4, 7, 9, 4, 7, 2],\n", - " [1, 2, 9, 6, 4, 0, 9, 8, 2, 2]])}\n", - "{'repetition': array([0, 1, 2, 3, 4]), 'variable': array([[5, 4, 3, 9, 1, 6, 7, 0, 8, 7],\n", - " [0, 4, 7, 3, 9, 1, 6, 0, 1, 3],\n", - " [4, 3, 7, 6, 4, 4, 0, 7, 9, 0],\n", - " [1, 2, 5, 7, 5, 9, 0, 9, 7, 9],\n", - " [0, 5, 1, 8, 8, 0, 4, 8, 2, 6]]), 'independent': array([[0, 4, 2, 9, 9, 0, 3, 5, 6, 7],\n", - " [2, 9, 5, 6, 4, 7, 8, 6, 2, 2],\n", - " [3, 0, 0, 6, 7, 0, 5, 5, 8, 5],\n", - " [8, 2, 5, 0, 4, 2, 2, 9, 5, 2],\n", - " [6, 7, 6, 6, 3, 0, 5, 3, 1, 1]])}\n", - "{'repetition': array([0, 1, 2, 3, 4]), 'variable': array([[1, 8, 6, 1, 7, 4, 5, 7, 9, 6],\n", - " [8, 6, 3, 7, 5, 6, 6, 1, 5, 2],\n", - " [7, 3, 8, 4, 3, 0, 7, 7, 1, 7],\n", - " [0, 3, 8, 5, 2, 5, 5, 1, 0, 2],\n", - " [8, 0, 0, 8, 2, 0, 9, 5, 4, 2]]), 'independent': array([[5, 5, 7, 7, 8, 4, 1, 2, 5, 9],\n", - " [9, 7, 2, 3, 5, 2, 7, 0, 6, 0],\n", - " [7, 1, 0, 6, 6, 9, 4, 4, 9, 8],\n", - " [3, 4, 9, 5, 1, 4, 6, 9, 6, 9],\n", - " [1, 7, 0, 6, 1, 6, 9, 4, 4, 8]])}\n", - "{'repetition': array([0, 1, 2, 3, 4]), 'variable': array([[5, 9, 1, 0, 4, 9, 9, 3, 2, 3],\n", - " [9, 5, 9, 5, 2, 4, 1, 6, 1, 9],\n", - " [9, 8, 4, 0, 4, 7, 1, 2, 8, 7],\n", - " [9, 0, 5, 3, 0, 7, 3, 8, 4, 5],\n", - " [2, 8, 6, 4, 0, 0, 6, 9, 3, 0]]), 'independent': array([[1, 7, 6, 8, 9, 5, 9, 7, 8, 4],\n", - " [4, 5, 1, 0, 4, 2, 2, 9, 9, 5],\n", - " [2, 0, 7, 7, 0, 4, 5, 3, 3, 1],\n", - " [3, 1, 7, 9, 9, 9, 2, 5, 0, 8],\n", - " [4, 3, 9, 6, 3, 9, 0, 5, 4, 4]])}\n", - "{'repetition': array([0, 1, 2, 3, 4]), 'variable': array([[4, 6, 4, 7, 0, 9, 7, 0, 0, 1],\n", - " [1, 1, 7, 5, 8, 2, 5, 4, 3, 9],\n", - " [1, 4, 2, 7, 6, 4, 0, 6, 9, 9],\n", - " [0, 4, 9, 9, 5, 1, 1, 8, 1, 3],\n", - " [1, 3, 8, 0, 3, 3, 7, 7, 8, 2]]), 'independent': array([[4, 9, 6, 2, 5, 2, 4, 6, 0, 7],\n", - " [6, 5, 4, 1, 0, 8, 3, 4, 8, 6],\n", - " [9, 5, 6, 7, 3, 2, 4, 7, 0, 2],\n", - " [6, 2, 6, 6, 3, 0, 1, 8, 7, 8],\n", - " [3, 0, 2, 2, 6, 0, 7, 8, 6, 5]])}\n", - "The measurement has finished and all of the data has been saved.\n" - ] - } - ], - "source": [ - "run_sweep(sweep, DATADIR, 'test_3')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "129221c9-ca21-4ff8-ab31-0f285d8107f7", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "6a66a5eb-07f2-4cf7-9fac-5490f2c49e47", - "metadata": {}, - "source": [ - "# Real OPX test" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "4e4d303b-a80f-4709-9d00-9208cc354592", - "metadata": {}, - "outputs": [], - "source": [ - "class ResHandleContainer:\n", - " def __init__(self, res_handle=None):\n", - " self.res_handle = res_handle\n", - " self.counter = 0\n", - " self.active = True\n", - " \n", - " def get_res_handle(self):\n", - " return self.res_handle\n", - " \n", - " def set_res_handle(self, res_handle):\n", - " self.res_handle = res_handle \n", - "\n", - "def record_qua_output(*data_specs):\n", - " container_inside = ResHandleContainer()\n", - " \n", - " def qua_function(func):\n", - " def nested_function(**kwarg):\n", - " qmachine_mgr = QuantumMachinesManager()\n", - " qmachine = qmachine_mgr.open_qm(global_config)\n", - " job = qmachine.execute(func(**kwarg))\n", - " result_handle = job.result_handles\n", - " container_inside.set_res_handle(result_handle)\n", - " print(f'the instance of container that I am getting is: {container_inside}')\n", - " return nested_function, container_inside, *data_specs\n", - " return qua_function" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "gothic-barbados", - "metadata": {}, - "outputs": [], - "source": [ - "def create_sweep_opx(opx_program, config, batchsize):\n", - " \n", - " def control_progress(res_handle_in, counter_in, batchsize_in):\n", - " ready = False\n", - " first = True\n", - " print('starting control_progress')\n", - " while not ready:\n", - " for name, handle in res_handle_in:\n", - " current_in = handle.count_so_far()\n", - " \n", - " if res_handle_in.is_processing():\n", - " if current_in - counter_in >= batchsize_in:\n", - " ready = True\n", - " else:\n", - " ready = False\n", - " else:\n", - " ready = True\n", - " container.active = False\n", - " print('I have turned container False')\n", - " \n", - " return ready\n", - " \n", - " @recording(*list(opx_program[2:]))\n", - " def gather_data():\n", - " print('entering gathering data')\n", - "\n", - " result_handle = container.get_res_handle()\n", - " \n", - " # checking if the parameters passed match the parameters in the opx\n", - " data_specs_names = [x.name for x in opx_program[2:]]\n", - " variable_counter = 0\n", - " for name, handle in result_handle:\n", - " print(name)\n", - " if name not in data_specs_names:\n", - " raise ValueError(f'{name} is not a recorded variable')\n", - " else:\n", - " variable_counter += 1\n", - " if variable_counter != len(data_specs_names):\n", - " raise ValueError(f'Number of recorded variables ({variable_counter}) does not match number of variables gathered from the OPX ({len(data_specs_names)})')\n", - " \n", - " \n", - " while container.active:\n", - "\n", - " first = True\n", - " data = {}\n", - " counter = container.counter\n", - " first = True\n", - " current = 0\n", - " \n", - " if result_handle == None:\n", - " yield None\n", - " \n", - " record = control_progress(result_handle, counter, batchsize) \n", - " for name, handle in result_handle:\n", - "\n", - " if first:\n", - " current = handle.count_so_far()\n", - " print(f'getting new current: {current}, my old counter is: {counter}')\n", - " first = False\n", - " if current == counter:\n", - " yield None\n", - " \n", - " \n", - " handle.wait_for_values(current)\n", - " data_temp = np.array(handle.fetch(slice(counter, current))) \n", - " if name[0:4] == 'raw_':\n", - " holding_converting = []\n", - " for i in data_temp:\n", - " i_holder = []\n", - " for j in i:\n", - " converted = j.astype(float)\n", - " i_holder.append(converted)\n", - " holding_converting.append(i_holder)\n", - " if len(holding_converting) == 1:\n", - " converted_data_temp = [np.squeeze(holding_converting)]\n", - " else:\n", - " converted_data_temp = np.squeeze(holding_converting)\n", - " else:\n", - " converted_data_temp = data_temp.astype(float)\n", - " data[name] = converted_data_temp\n", - " container.counter = current\n", - " yield data\n", - " \n", - " my_experiment = opx_program[0]\n", - " print(f'my experiment is: {my_experiment}')\n", - " container = opx_program[1]\n", - "\n", - " sweep = Sweep(once(my_experiment)) + Sweep(gather_data())\n", - "# sweep = Sweep(once(my_qua_experiment)) + Sweep(gather_data)\n", - " return(sweep)\n", - "\n", - "def create_structure(sweep):\n", - " data_specs = sweep.get_data_specs()\n", - " print(f'the data_specs are: {data_specs}')\n", - " data_dict = dd.DataDict()\n", - " for spec in data_specs:\n", - " print(spec)\n", - " depends_on = spec.depends_on\n", - " unit = spec.unit\n", - " name = spec.name\n", - " if depends_on is None:\n", - " if unit is None:\n", - " data_dict[name] = dict()\n", - " else:\n", - " data_dict[name] = dict(unit = unit)\n", - " else:\n", - " if unit is None:\n", - " data_dict[name] = dict(axes = depends_on)\n", - " else:\n", - " data_dict[name] = dict(axes = depends_on, unit = unit)\n", - " \n", - " data_dict.validate()\n", - " print(data_dict)\n", - " return data_dict\n", - "\n", - "def check_none(argument):\n", - " for arg in argument.keys():\n", - " if argument[arg] is not None:\n", - " return False\n", - " return True\n", - "\n", - "def run_sweep(sweep, data_dir, name, prt=False):\n", - " data_dict = create_structure(sweep)\n", - " with dds.DDH5Writer(data_dir, data_dict, name=name) as writer:\n", - " for line in sweep:\n", - " if not check_none(line):\n", - " if prt:\n", - " print(line)\n", - " try:\n", - " writer.add_data(**line)\n", - " except ValueError as e:\n", - " print(line)\n", - " raise e\n", - " \n", - " print('The measurement has finished and all of the data has been saved.')" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "official-award", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# You should be able to pass arguments to my_qua_experiment(n_reps=1_000)\n", - "\n", - "@record_qua_output(\n", - " independent('repetition', type='array'),\n", - " dependent('V', depends_on=['repetition'], type='array'),\n", - " dependent('tracker', depends_on=['repetition'], type='array'))\n", - "# dependent('raw', depends_on=['repetition'], type='array'))\n", - " #qua_raw_dependent('raw', depends_on=['repetition'], type='array'))\n", - "def my_qua_experiment(n_reps=1000):\n", - " with program() as qua_measurement:\n", - " raw_stream = declare_stream(adc_trace=True)\n", - " v_stream = declare_stream()\n", - " tracker_stream = declare_stream()\n", - " i_stream = declare_stream()\n", - "\n", - " i = declare(int)\n", - " v = declare(fixed)\n", - " tracker = declare(int, value=0)\n", - "\n", - " with for_(i, 0, i.qua_function..nested_function at 0x000001F774D2BB80>\n" - ] - } - ], - "source": [ - "DATADIR = './data/'\n", - "config = QMConfig()\n", - "global_config = config.config()\n", - "sweep = create_sweep_opx(my_qua_experiment, config.config(), 5)\n", - "\n", - "sweep.set_action_opts(\n", - " nested_function=dict(n_reps=5),\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "16fbd8e2-3947-4c95-bd61-3a350d4c29d0", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "hydraulic-convergence", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "the data_specs are: (DataSpec(name='repetition', depends_on=None, type=, unit=''), DataSpec(name='V', depends_on=['repetition'], type=, unit=''), DataSpec(name='tracker', depends_on=['repetition'], type=, unit=''))\n", - "DataSpec(name='repetition', depends_on=None, type=, unit='')\n", - "DataSpec(name='V', depends_on=['repetition'], type=, unit='')\n", - "DataSpec(name='tracker', depends_on=['repetition'], type=, unit='')\n", - "{'repetition': {'unit': '', 'axes': [], 'label': '', 'values': array([], dtype=float64)}, 'V': {'axes': ['repetition'], 'unit': '', 'label': '', 'values': array([], dtype=float64)}, 'tracker': {'axes': ['repetition'], 'unit': '', 'label': '', 'values': array([], dtype=float64)}}\n", - "Data location: ./data/2021-07-28\\2021-07-28_0002_OPX test #2\\2021-07-28_0002_OPX test #2.ddh5\n", - "2021-07-28 17:21:38,142 - qm - INFO - Performing health check\n", - "2021-07-28 17:21:38,151 - qm - INFO - Health check passed\n", - "2021-07-28 17:21:38,440 - qm - INFO - Flags: \n", - "2021-07-28 17:21:38,440 - qm - INFO - Executing high level program\n", - "the instance of container that I am getting is: <__main__.ResHandleContainer object at 0x000001F774D21BE0>\n", - "entering gathering data\n", - "repetition\n", - "V\n", - "tracker\n", - "starting control_progress\n", - "getting new current: 5, my old counter is: 0\n", - "starting control_progress\n", - "getting new current: 18, my old counter is: 5\n", - "starting control_progress\n", - "getting new current: 33, my old counter is: 18\n", - "starting control_progress\n", - "getting new current: 46, my old counter is: 33\n", - "starting control_progress\n", - "getting new current: 61, my old counter is: 46\n", - "starting control_progress\n", - "getting new current: 73, my old counter is: 61\n", - "starting control_progress\n", - "getting new current: 89, my old counter is: 73\n", - "starting control_progress\n", - "getting new current: 104, my old counter is: 89\n", - "starting control_progress\n", - "getting new current: 119, my old counter is: 104\n", - "starting control_progress\n", - "getting new current: 134, my old counter is: 119\n", - "starting control_progress\n", - "getting new current: 146, my old counter is: 134\n", - "starting control_progress\n", - "getting new current: 162, my old counter is: 146\n", - "starting control_progress\n", - "getting new current: 177, my old counter is: 162\n", - "starting control_progress\n", - "getting new current: 192, my old counter is: 177\n", - "starting control_progress\n", - "getting new current: 207, my old counter is: 192\n", - "starting control_progress\n", - "getting new current: 219, my old counter is: 207\n", - "starting control_progress\n", - "getting new current: 235, my old counter is: 219\n", - "starting control_progress\n", - "getting new current: 292, my old counter is: 235\n", - "starting control_progress\n", - "getting new current: 307, my old counter is: 292\n", - "starting control_progress\n", - "getting new current: 323, my old counter is: 307\n", - "starting control_progress\n", - "getting new current: 338, my old counter is: 323\n", - "starting control_progress\n", - "getting new current: 353, my old counter is: 338\n", - "starting control_progress\n", - "getting new current: 368, my old counter is: 353\n", - "starting control_progress\n", - "getting new current: 383, my old counter is: 368\n", - "starting control_progress\n", - "getting new current: 398, my old counter is: 383\n", - "starting control_progress\n", - "getting new current: 413, my old counter is: 398\n", - "starting control_progress\n", - "getting new current: 428, my old counter is: 413\n", - "starting control_progress\n", - "getting new current: 441, my old counter is: 428\n", - "starting control_progress\n", - "getting new current: 456, my old counter is: 441\n", - "starting control_progress\n", - "getting new current: 468, my old counter is: 456\n", - "starting control_progress\n", - "getting new current: 483, my old counter is: 468\n", - "starting control_progress\n", - "getting new current: 498, my old counter is: 483\n", - "starting control_progress\n", - "getting new current: 511, my old counter is: 498\n", - "starting control_progress\n", - "getting new current: 526, my old counter is: 511\n", - "starting control_progress\n", - "getting new current: 541, my old counter is: 526\n", - "starting control_progress\n", - "getting new current: 556, my old counter is: 541\n", - "starting control_progress\n", - "getting new current: 571, my old counter is: 556\n", - "starting control_progress\n", - "getting new current: 584, my old counter is: 571\n", - "starting control_progress\n", - "getting new current: 599, my old counter is: 584\n", - "starting control_progress\n", - "getting new current: 614, my old counter is: 599\n", - "starting control_progress\n", - "getting new current: 627, my old counter is: 614\n", - "starting control_progress\n", - "getting new current: 642, my old counter is: 627\n", - "starting control_progress\n", - "getting new current: 657, my old counter is: 642\n", - "starting control_progress\n", - "getting new current: 669, my old counter is: 657\n", - "starting control_progress\n", - "getting new current: 684, my old counter is: 669\n", - "starting control_progress\n", - "getting new current: 699, my old counter is: 684\n", - "starting control_progress\n", - "getting new current: 712, my old counter is: 699\n", - "starting control_progress\n", - "getting new current: 727, my old counter is: 712\n", - "starting control_progress\n", - "getting new current: 742, my old counter is: 727\n", - "starting control_progress\n", - "getting new current: 757, my old counter is: 742\n", - "starting control_progress\n", - "getting new current: 772, my old counter is: 757\n", - "starting control_progress\n", - "getting new current: 787, my old counter is: 772\n", - "starting control_progress\n", - "getting new current: 802, my old counter is: 787\n", - "starting control_progress\n", - "getting new current: 817, my old counter is: 802\n", - "starting control_progress\n", - "getting new current: 832, my old counter is: 817\n", - "starting control_progress\n", - "getting new current: 845, my old counter is: 832\n", - "starting control_progress\n", - "getting new current: 860, my old counter is: 845\n", - "starting control_progress\n", - "getting new current: 875, my old counter is: 860\n", - "starting control_progress\n", - "getting new current: 890, my old counter is: 875\n", - "starting control_progress\n", - "getting new current: 905, my old counter is: 890\n", - "starting control_progress\n", - "getting new current: 920, my old counter is: 905\n", - "starting control_progress\n", - "getting new current: 936, my old counter is: 920\n", - "starting control_progress\n", - "getting new current: 951, my old counter is: 936\n", - "starting control_progress\n", - "getting new current: 966, my old counter is: 951\n", - "starting control_progress\n", - "getting new current: 981, my old counter is: 966\n", - "starting control_progress\n", - "getting new current: 996, my old counter is: 981\n", - "starting control_progress\n", - "I have turned container False\n", - "getting new current: 1000, my old counter is: 996\n", - "The measurement has finished and all of the data has been saved.\n" - ] - } - ], - "source": [ - "test_name_counter += 1\n", - "run_sweep(sweep, DATADIR, f'OPX test #{test_name_counter}', prt=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "moving-industry", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "None\n" - ] - } - ], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "rotary-serial", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "44c14b68-4b6d-4ec5-a55e-f0d482cfc7d5", - "metadata": {}, - "source": [ - "# Structured with base class decorator" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "id": "forced-testament", - "metadata": {}, - "outputs": [], - "source": [ - "class BackgroundRecordingBase:\n", - " \"\"\"\n", - " Base class decorator used to record asynchronous data from instrument. \n", - " Each instrument should have its own custom setup_wrapper (see setup_wrapper docstring for more info), and a custom collector \n", - " \"\"\"\n", - " def __init__(self, *specs):\n", - " \n", - " self.specs = specs \n", - " self.communicator = {}\n", - "\n", - " \n", - " def __call__(self, fun):\n", - " def sweep(**collector_kwargs):\n", - " setup_sweep = once(self.setup_wrapper(fun))\n", - " gather_sweep = Sweep(record_as(self.collector(**collector_kwargs), *self.specs))\n", - " return setup_sweep + gather_sweep\n", - " return sweep\n", - " \n", - " \n", - " \n", - " def setup_wrapper(self, fun):\n", - " \"\"\"\n", - " Wraps the setup function. setup_wrapper should consist of a function wrapped by the decorator @wraps and takes fun as an arugment.\n", - " In this case the wrapped function is setup. \n", - " Setup should accpet the *args and **kwargs of fun. It should also place any returns from fun in the communicator.\n", - " setup_wrapper needs to return the wraped function (setup)\n", - " \"\"\"\n", - " @wraps(fun)\n", - " def setup(*args, **kwargs):\n", - " self.communicator['setup_return'] = fun(*args, **kwargs)\n", - " return None\n", - " \n", - " return setup\n", - " \n", - " def collector(self):\n", - " \"\"\"\n", - " Data gathering function. This function should be a generator that collects data from the instrument.\n", - " All the logic of asynchronous data collection should be here. It should yield data as long as it is \n", - " available and the generator should finish once its experiment is done.\n", - " \"\"\"\n", - " yield None\n", - " \n", - " \n", - "def create_background_sweep(decorated_setup_function, **collector_kwargs):\n", - " sweep = decorated_setup_function(**collector_kwargs)\n", - " return sweep\n" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "likely-childhood", - "metadata": {}, - "outputs": [], - "source": [ - "class RecordOPX(BackgroundRecordingBase):\n", - " def setup_wrapper(self, fun):\n", - " @wraps(fun)\n", - " def setup(*args, **kwargs):\n", - " qmachine_mgr = QuantumMachinesManager()\n", - " qmachine = qmachine_mgr.open_qm(global_config)\n", - " job = qmachine.execute(fun(*args, **kwargs))\n", - " result_handles = job.result_handles\n", - " self.communicator['result_handles'] = result_handles\n", - " self.communicator['active'] = True\n", - " self.communicator['counter'] = 0\n", - " \n", - " return setup\n", - " \n", - " \n", - " def _control_progress(self, batchsize):\n", - " ready = False\n", - " first = True\n", - " res_handle = self.communicator['result_handles']\n", - " counter = self.communicator['counter']\n", - " print('starting control_progress')\n", - " while not ready:\n", - " for name, handle in res_handle:\n", - " current = handle.count_so_far()\n", - " \n", - " if res_handle.is_processing():\n", - " if current - counter >= batchsize:\n", - " ready = True\n", - " else:\n", - " ready = False\n", - " else:\n", - " ready = True\n", - " self.communicator['active'] = False\n", - " print('I have turned container False')\n", - " \n", - " return ready\n", - " \n", - "\n", - " def collector(self, batchsize):\n", - " print('entering gathering data')\n", - "\n", - " result_handle = self.communicator['result_handles']\n", - " \n", - " # checking if the parameters passed match the parameters in the opx\n", - " data_specs_names = [x.name for x in self.specs]\n", - " variable_counter = 0\n", - " for name, handle in result_handle:\n", - " print(name)\n", - " if name not in data_specs_names:\n", - " raise ValueError(f'{name} is not a recorded variable')\n", - " else:\n", - " variable_counter += 1\n", - " if variable_counter != len(data_specs_names):\n", - " raise ValueError(f'Number of recorded variables ({variable_counter}) \\\n", - " does not match number of variables gathered from the OPX ({len(data_specs_names)})')\n", - " \n", - " \n", - " while self.communicator['active']:\n", - "\n", - " first = True\n", - " data = {}\n", - " counter = self.communicator['counter']\n", - " first = True\n", - " current = 0\n", - " \n", - " if result_handle == None:\n", - " yield None\n", - " \n", - " record = self._control_progress(batchsize) \n", - " for name, handle in result_handle:\n", - "\n", - " if first:\n", - " current = handle.count_so_far()\n", - " print(f'getting new current: {current}, my old counter is: {counter}')\n", - " first = False\n", - " if current == counter:\n", - " yield None\n", - " \n", - " \n", - " handle.wait_for_values(current)\n", - " data_temp = np.array(handle.fetch(slice(counter, current))) \n", - " if name[0:4] == 'raw_':\n", - " holding_converting = []\n", - " for i in data_temp:\n", - " i_holder = []\n", - " for j in i:\n", - " converted = j.astype(float)\n", - " i_holder.append(converted)\n", - " holding_converting.append(i_holder)\n", - " if len(holding_converting) == 1:\n", - " converted_data_temp = [np.squeeze(holding_converting)]\n", - " else:\n", - " converted_data_temp = np.squeeze(holding_converting)\n", - " else:\n", - " converted_data_temp = data_temp.astype(float)\n", - " data[name] = converted_data_temp\n", - " self.communicator['counter'] = current\n", - " yield data\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "d4ad51d7-df0b-42f1-961a-c525f990d77c", - "metadata": {}, - "outputs": [], - "source": [ - "@RecordOPX(\n", - " independent('repetition', type='array'),\n", - " dependent('V', depends_on=['repetition'], type='array'),\n", - " dependent('tracker', depends_on=['repetition'], type='array'))\n", - "# dependent('raw', depends_on=['repetition'], type='array'))\n", - " #qua_raw_dependent('raw', depends_on=['repetition'], type='array'))\n", - "def my_qua_experiment_standard(n_reps=1000):\n", - " with program() as qua_measurement:\n", - " raw_stream = declare_stream(adc_trace=True)\n", - " v_stream = declare_stream()\n", - " tracker_stream = declare_stream()\n", - " i_stream = declare_stream()\n", - "\n", - " i = declare(int)\n", - " v = declare(fixed)\n", - " tracker = declare(int, value=0)\n", - "\n", - " with for_(i, 0, i, unit=''), DataSpec(name='V', depends_on=['repetition'], type=, unit=''), DataSpec(name='tracker', depends_on=['repetition'], type=, unit=''))\n", - "DataSpec(name='repetition', depends_on=None, type=, unit='')\n", - "DataSpec(name='V', depends_on=['repetition'], type=, unit='')\n", - "DataSpec(name='tracker', depends_on=['repetition'], type=, unit='')\n", - "{'repetition': {'unit': '', 'axes': [], 'label': '', 'values': array([], dtype=float64)}, 'V': {'axes': ['repetition'], 'unit': '', 'label': '', 'values': array([], dtype=float64)}, 'tracker': {'axes': ['repetition'], 'unit': '', 'label': '', 'values': array([], dtype=float64)}}\n", - "Data location: ./data/2021-07-28\\2021-07-28_0007_OPX test standard #2\\2021-07-28_0007_OPX test standard #2.ddh5\n", - "2021-07-28 18:00:38,816 - qm - INFO - Performing health check\n", - "2021-07-28 18:00:38,818 - qm - INFO - Health check passed\n", - "2021-07-28 18:00:39,098 - qm - INFO - Flags: \n", - "2021-07-28 18:00:39,098 - qm - INFO - Executing high level program\n", - "entering gathering data\n", - "repetition\n", - "V\n", - "tracker\n", - "starting control_progress\n", - "getting new current: 10, my old counter is: 0\n", - "{'repetition': array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]), 'V': array([-0.19585172, -0.19580412, -0.19579314, -0.19579224, -0.19580339,\n", - " -0.19578793, -0.19578588, -0.19579728, -0.195802 , -0.19577818]), 'tracker': array([ 2., 4., 6., 8., 10., 12., 14., 16., 18., 20.])}\n", - "starting control_progress\n", - "getting new current: 26, my old counter is: 10\n", - "{'repetition': array([10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,\n", - " 23., 24., 25.]), 'V': array([-0.19575856, -0.19576599, -0.19574884, -0.19573573, -0.19575905,\n", - " -0.19577549, -0.1958014 , -0.19581931, -0.1957964 , -0.19577985,\n", - " -0.19578252, -0.19574846, -0.19577056, -0.19573121, -0.19577618,\n", - " -0.19577065]), 'tracker': array([22., 24., 26., 28., 30., 32., 34., 36., 38., 40., 42., 44., 46.,\n", - " 48., 50., 52.])}\n", - "starting control_progress\n", - "getting new current: 38, my old counter is: 26\n", - "{'repetition': array([26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37.]), 'V': array([-0.19576492, -0.19576509, -0.19578099, -0.19581264, -0.19577168,\n", - " -0.19577877, -0.19576147, -0.19576344, -0.19576478, -0.19575328,\n", - " -0.19577195, -0.19577415]), 'tracker': array([54., 56., 58., 60., 62., 64., 66., 68., 70., 72., 74., 76.])}\n", - "starting control_progress\n", - "getting new current: 53, my old counter is: 38\n", - "{'repetition': array([38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48., 49., 50.,\n", - " 51., 52.]), 'V': array([-0.19577513, -0.19578515, -0.19581234, -0.19579154, -0.1957913 ,\n", - " -0.19578104, -0.19579247, -0.19577788, -0.19579973, -0.19577529,\n", - " -0.19581063, -0.19576654, -0.19580223, -0.19575444, -0.19576245]), 'tracker': array([ 78., 80., 82., 84., 86., 88., 90., 92., 94., 96., 98.,\n", - " 100., 102., 104., 106.])}\n", - "starting control_progress\n", - "getting new current: 66, my old counter is: 53\n", - "{'repetition': array([53., 54., 55., 56., 57., 58., 59., 60., 61., 62., 63., 64., 65.]), 'V': array([-0.19577051, -0.19577536, -0.19575042, -0.19578873, -0.19577943,\n", - " -0.19576142, -0.19578826, -0.19578732, -0.19576568, -0.19580106,\n", - " -0.19576155, -0.19574936, -0.19580011]), 'tracker': array([108., 110., 112., 114., 116., 118., 120., 122., 124., 126., 128.,\n", - " 130., 132.])}\n", - "starting control_progress\n", - "getting new current: 81, my old counter is: 66\n", - "{'repetition': array([66., 67., 68., 69., 70., 71., 72., 73., 74., 75., 76., 77., 78.,\n", - " 79., 80.]), 'V': array([-0.19578186, -0.19581716, -0.19575651, -0.1957934 , -0.19578069,\n", - " -0.19577493, -0.19573466, -0.19576906, -0.19579173, -0.19577469,\n", - " -0.19577651, -0.1958001 , -0.19579489, -0.19579595, -0.19578649]), 'tracker': array([134., 136., 138., 140., 142., 144., 146., 148., 150., 152., 154.,\n", - " 156., 158., 160., 162.])}\n", - "starting control_progress\n", - "getting new current: 93, my old counter is: 81\n", - "{'repetition': array([81., 82., 83., 84., 85., 86., 87., 88., 89., 90., 91., 92.]), 'V': array([-0.19577065, -0.19580063, -0.19579859, -0.19578066, -0.19579165,\n", - " -0.19580898, -0.19579137, -0.19580229, -0.19576392, -0.19578167,\n", - " -0.19578138, -0.19576528]), 'tracker': array([164., 166., 168., 170., 172., 174., 176., 178., 180., 182., 184.,\n", - " 186.])}\n", - "starting control_progress\n", - "getting new current: 108, my old counter is: 93\n", - "{'repetition': array([ 93., 94., 95., 96., 97., 98., 99., 100., 101., 102., 103.,\n", - " 104., 105., 106., 107.]), 'V': array([-0.19574423, -0.19575272, -0.19578872, -0.19575793, -0.19574488,\n", - " -0.19572311, -0.19571695, -0.1957245 , -0.19574478, -0.19573105,\n", - " -0.19573945, -0.1957643 , -0.19574071, -0.19575833, -0.19572633]), 'tracker': array([188., 190., 192., 194., 196., 198., 200., 202., 204., 206., 208.,\n", - " 210., 212., 214., 216.])}\n", - "starting control_progress\n", - "getting new current: 124, my old counter is: 108\n", - "{'repetition': array([108., 109., 110., 111., 112., 113., 114., 115., 116., 117., 118.,\n", - " 119., 120., 121., 122., 123.]), 'V': array([-0.19576799, -0.19574634, -0.19577346, -0.19576201, -0.19574748,\n", - " -0.19575531, -0.19576957, -0.19576705, -0.19576599, -0.1957365 ,\n", - " -0.19572687, -0.19575964, -0.19576248, -0.19579114, -0.19578372,\n", - " -0.19580027]), 'tracker': array([218., 220., 222., 224., 226., 228., 230., 232., 234., 236., 238.,\n", - " 240., 242., 244., 246., 248.])}\n", - "starting control_progress\n", - "getting new current: 136, my old counter is: 124\n", - "{'repetition': array([124., 125., 126., 127., 128., 129., 130., 131., 132., 133., 134.,\n", - " 135.]), 'V': array([-0.19584877, -0.19580854, -0.19577908, -0.19578501, -0.19581062,\n", - " -0.1958263 , -0.19579604, -0.19575908, -0.19577266, -0.19574304,\n", - " -0.19578607, -0.19578546]), 'tracker': array([250., 252., 254., 256., 258., 260., 262., 264., 266., 268., 270.,\n", - " 272.])}\n", - "starting control_progress\n", - "getting new current: 151, my old counter is: 136\n", - "{'repetition': array([136., 137., 138., 139., 140., 141., 142., 143., 144., 145., 146.,\n", - " 147., 148., 149., 150.]), 'V': array([-0.19578759, -0.19578636, -0.19573835, -0.19578145, -0.19575462,\n", - " -0.19574554, -0.19574277, -0.1957546 , -0.19573143, -0.19571526,\n", - " -0.1957373 , -0.19574432, -0.19573912, -0.19575818, -0.19575404]), 'tracker': array([274., 276., 278., 280., 282., 284., 286., 288., 290., 292., 294.,\n", - " 296., 298., 300., 302.])}\n", - "starting control_progress\n", - "getting new current: 164, my old counter is: 151\n", - "{'repetition': array([151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 161.,\n", - " 162., 163.]), 'V': array([-0.19573422, -0.1957174 , -0.19577619, -0.19578409, -0.1957681 ,\n", - " -0.19573138, -0.19570927, -0.19574173, -0.1957242 , -0.19572704,\n", - " -0.1957668 , -0.19576787, -0.19576233]), 'tracker': array([304., 306., 308., 310., 312., 314., 316., 318., 320., 322., 324.,\n", - " 326., 328.])}\n", - "starting control_progress\n", - "getting new current: 179, my old counter is: 164\n", - "{'repetition': array([164., 165., 166., 167., 168., 169., 170., 171., 172., 173., 174.,\n", - " 175., 176., 177., 178.]), 'V': array([-0.19580268, -0.19577736, -0.19581094, -0.19577114, -0.19575515,\n", - " -0.19577837, -0.19577119, -0.19574293, -0.19578837, -0.19578811,\n", - " -0.1958097 , -0.1957989 , -0.19578547, -0.19576683, -0.19577097]), 'tracker': array([330., 332., 334., 336., 338., 340., 342., 344., 346., 348., 350.,\n", - " 352., 354., 356., 358.])}\n", - "starting control_progress\n", - "getting new current: 194, my old counter is: 179\n", - "{'repetition': array([179., 180., 181., 182., 183., 184., 185., 186., 187., 188., 189.,\n", - " 190., 191., 192., 193.]), 'V': array([-0.19583013, -0.1957763 , -0.19576297, -0.19574791, -0.19577265,\n", - " -0.19573439, -0.19574504, -0.19572585, -0.19575854, -0.19579522,\n", - " -0.19577065, -0.19577944, -0.19571174, -0.19575343, -0.19576964]), 'tracker': array([360., 362., 364., 366., 368., 370., 372., 374., 376., 378., 380.,\n", - " 382., 384., 386., 388.])}\n", - "starting control_progress\n", - "getting new current: 206, my old counter is: 194\n", - "{'repetition': array([194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,\n", - " 205.]), 'V': array([-0.19579013, -0.19576529, -0.19574984, -0.19580515, -0.19581383,\n", - " -0.1958065 , -0.19574804, -0.1957694 , -0.19576592, -0.1958085 ,\n", - " -0.19577842, -0.19578798]), 'tracker': array([390., 392., 394., 396., 398., 400., 402., 404., 406., 408., 410.,\n", - " 412.])}\n", - "starting control_progress\n", - "getting new current: 222, my old counter is: 206\n", - "{'repetition': array([206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,\n", - " 217., 218., 219., 220., 221.]), 'V': array([-0.19578287, -0.19579412, -0.19577356, -0.19578513, -0.19580721,\n", - " -0.1958065 , -0.19579463, -0.19578249, -0.19579004, -0.19575552,\n", - " -0.19574103, -0.19576712, -0.19577198, -0.1957393 , -0.19578011,\n", - " -0.19577125]), 'tracker': array([414., 416., 418., 420., 422., 424., 426., 428., 430., 432., 434.,\n", - " 436., 438., 440., 442., 444.])}\n", - "starting control_progress\n", - "getting new current: 237, my old counter is: 222\n", - "{'repetition': array([222., 223., 224., 225., 226., 227., 228., 229., 230., 231., 232.,\n", - " 233., 234., 235., 236.]), 'V': array([-0.19581062, -0.19577893, -0.19577346, -0.19578392, -0.19577844,\n", - " -0.19576547, -0.19576558, -0.19577171, -0.19579251, -0.19575875,\n", - " -0.19574128, -0.19573756, -0.19577454, -0.19575565, -0.19576393]), 'tracker': array([446., 448., 450., 452., 454., 456., 458., 460., 462., 464., 466.,\n", - " 468., 470., 472., 474.])}\n", - "starting control_progress\n", - "getting new current: 252, my old counter is: 237\n", - "{'repetition': array([237., 238., 239., 240., 241., 242., 243., 244., 245., 246., 247.,\n", - " 248., 249., 250., 251.]), 'V': array([-0.19572202, -0.1957559 , -0.19574336, -0.19578778, -0.19576668,\n", - " -0.19574044, -0.1957992 , -0.19575293, -0.19574615, -0.19571473,\n", - " -0.19575188, -0.19576313, -0.19573705, -0.19573767, -0.19575009]), 'tracker': array([476., 478., 480., 482., 484., 486., 488., 490., 492., 494., 496.,\n", - " 498., 500., 502., 504.])}\n", - "starting control_progress\n", - "getting new current: 267, my old counter is: 252\n", - "{'repetition': array([252., 253., 254., 255., 256., 257., 258., 259., 260., 261., 262.,\n", - " 263., 264., 265., 266.]), 'V': array([-0.19573784, -0.19575049, -0.19576683, -0.19574679, -0.19577286,\n", - " -0.19576406, -0.1958008 , -0.19578627, -0.19582069, -0.19576072,\n", - " -0.19576221, -0.19578667, -0.195796 , -0.19577758, -0.19577562]), 'tracker': array([506., 508., 510., 512., 514., 516., 518., 520., 522., 524., 526.,\n", - " 528., 530., 532., 534.])}\n", - "starting control_progress\n", - "getting new current: 282, my old counter is: 267\n", - "{'repetition': array([267., 268., 269., 270., 271., 272., 273., 274., 275., 276., 277.,\n", - " 278., 279., 280., 281.]), 'V': array([-0.19573303, -0.19575805, -0.19577796, -0.19577616, -0.19572727,\n", - " -0.1957355 , -0.1957087 , -0.19572516, -0.19569132, -0.19574493,\n", - " -0.19571597, -0.19574904, -0.1957286 , -0.19574383, -0.19577252]), 'tracker': array([536., 538., 540., 542., 544., 546., 548., 550., 552., 554., 556.,\n", - " 558., 560., 562., 564.])}\n", - "starting control_progress\n", - "getting new current: 297, my old counter is: 282\n", - "{'repetition': array([282., 283., 284., 285., 286., 287., 288., 289., 290., 291., 292.,\n", - " 293., 294., 295., 296.]), 'V': array([-0.19578329, -0.19576024, -0.1957389 , -0.19574581, -0.19573799,\n", - " -0.19575953, -0.1957468 , -0.19576407, -0.19574384, -0.1957673 ,\n", - " -0.19572521, -0.19574425, -0.19575259, -0.19576729, -0.19578869]), 'tracker': array([566., 568., 570., 572., 574., 576., 578., 580., 582., 584., 586.,\n", - " 588., 590., 592., 594.])}\n", - "starting control_progress\n", - "getting new current: 310, my old counter is: 297\n", - "{'repetition': array([297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307.,\n", - " 308., 309.]), 'V': array([-0.19576481, -0.19578388, -0.19577233, -0.19578935, -0.19578798,\n", - " -0.19575791, -0.19576507, -0.19575607, -0.19578849, -0.19573919,\n", - " -0.19577397, -0.19575109, -0.19575265]), 'tracker': array([596., 598., 600., 602., 604., 606., 608., 610., 612., 614., 616.,\n", - " 618., 620.])}\n", - "starting control_progress\n", - "getting new current: 325, my old counter is: 310\n", - "{'repetition': array([310., 311., 312., 313., 314., 315., 316., 317., 318., 319., 320.,\n", - " 321., 322., 323., 324.]), 'V': array([-0.19577496, -0.19576808, -0.19577524, -0.19577883, -0.1957459 ,\n", - " -0.19574274, -0.19575836, -0.19574157, -0.19576629, -0.19579577,\n", - " -0.19577694, -0.19575644, -0.19575764, -0.19575735, -0.19573052]), 'tracker': array([622., 624., 626., 628., 630., 632., 634., 636., 638., 640., 642.,\n", - " 644., 646., 648., 650.])}\n", - "starting control_progress\n", - "getting new current: 340, my old counter is: 325\n", - "{'repetition': array([325., 326., 327., 328., 329., 330., 331., 332., 333., 334., 335.,\n", - " 336., 337., 338., 339.]), 'V': array([-0.19576511, -0.19579244, -0.19577689, -0.19576769, -0.19576903,\n", - " -0.1957386 , -0.19576965, -0.19575687, -0.19576989, -0.19577232,\n", - " -0.19575012, -0.19575499, -0.19575268, -0.19577586, -0.19574152]), 'tracker': array([652., 654., 656., 658., 660., 662., 664., 666., 668., 670., 672.,\n", - " 674., 676., 678., 680.])}\n", - "starting control_progress\n", - "getting new current: 352, my old counter is: 340\n", - "{'repetition': array([340., 341., 342., 343., 344., 345., 346., 347., 348., 349., 350.,\n", - " 351.]), 'V': array([-0.19578813, -0.19573673, -0.19576361, -0.19580159, -0.19576023,\n", - " -0.1957609 , -0.19577341, -0.19576542, -0.19577366, -0.19579495,\n", - " -0.19580591, -0.1958123 ]), 'tracker': array([682., 684., 686., 688., 690., 692., 694., 696., 698., 700., 702.,\n", - " 704.])}\n", - "starting control_progress\n", - "getting new current: 367, my old counter is: 352\n", - "{'repetition': array([352., 353., 354., 355., 356., 357., 358., 359., 360., 361., 362.,\n", - " 363., 364., 365., 366.]), 'V': array([-0.19579706, -0.19578061, -0.19580985, -0.19576491, -0.19575177,\n", - " -0.19576271, -0.1957955 , -0.19577308, -0.19575274, -0.19575532,\n", - " -0.19573416, -0.1957556 , -0.19577281, -0.1957748 , -0.19578194]), 'tracker': array([706., 708., 710., 712., 714., 716., 718., 720., 722., 724., 726.,\n", - " 728., 730., 732., 734.])}\n", - "starting control_progress\n", - "getting new current: 382, my old counter is: 367\n", - "{'repetition': array([367., 368., 369., 370., 371., 372., 373., 374., 375., 376., 377.,\n", - " 378., 379., 380., 381.]), 'V': array([-0.19579314, -0.19582359, -0.19577048, -0.19577219, -0.19577921,\n", - " -0.19577538, -0.19578233, -0.19577347, -0.1957843 , -0.19575157,\n", - " -0.19576677, -0.1957956 , -0.19577131, -0.19577608, -0.1957648 ]), 'tracker': array([736., 738., 740., 742., 744., 746., 748., 750., 752., 754., 756.,\n", - " 758., 760., 762., 764.])}\n", - "starting control_progress\n", - "getting new current: 398, my old counter is: 382\n", - "{'repetition': array([382., 383., 384., 385., 386., 387., 388., 389., 390., 391., 392.,\n", - " 393., 394., 395., 396., 397.]), 'V': array([-0.19575842, -0.19579078, -0.19577964, -0.19580021, -0.19575571,\n", - " -0.19576613, -0.19577941, -0.19575637, -0.19579144, -0.19570604,\n", - " -0.1957902 , -0.19581091, -0.19573324, -0.195778 , -0.19573765,\n", - " -0.19577699]), 'tracker': array([766., 768., 770., 772., 774., 776., 778., 780., 782., 784., 786.,\n", - " 788., 790., 792., 794., 796.])}\n", - "starting control_progress\n", - "getting new current: 413, my old counter is: 398\n", - "{'repetition': array([398., 399., 400., 401., 402., 403., 404., 405., 406., 407., 408.,\n", - " 409., 410., 411., 412.]), 'V': array([-0.19578019, -0.19578617, -0.1957447 , -0.19578684, -0.19574201,\n", - " -0.19576835, -0.19578174, -0.19576639, -0.19578563, -0.19576271,\n", - " -0.1957708 , -0.19576658, -0.19576205, -0.19576945, -0.19577354]), 'tracker': array([798., 800., 802., 804., 806., 808., 810., 812., 814., 816., 818.,\n", - " 820., 822., 824., 826.])}\n", - "starting control_progress\n", - "getting new current: 428, my old counter is: 413\n", - "{'repetition': array([413., 414., 415., 416., 417., 418., 419., 420., 421., 422., 423.,\n", - " 424., 425., 426., 427.]), 'V': array([-0.19574365, -0.19576992, -0.19578273, -0.19576402, -0.19575398,\n", - " -0.19577694, -0.19577922, -0.19575745, -0.19575531, -0.19575869,\n", - " -0.19575643, -0.19573796, -0.19573836, -0.19576814, -0.19575066]), 'tracker': array([828., 830., 832., 834., 836., 838., 840., 842., 844., 846., 848.,\n", - " 850., 852., 854., 856.])}\n", - "starting control_progress\n", - "getting new current: 443, my old counter is: 428\n", - "{'repetition': array([428., 429., 430., 431., 432., 433., 434., 435., 436., 437., 438.,\n", - " 439., 440., 441., 442.]), 'V': array([-0.19575517, -0.19577063, -0.19577231, -0.19579097, -0.19579511,\n", - " -0.19578572, -0.19578608, -0.19579819, -0.19577247, -0.19578824,\n", - " -0.19577778, -0.19577328, -0.19577415, -0.19576015, -0.19576841]), 'tracker': array([858., 860., 862., 864., 866., 868., 870., 872., 874., 876., 878.,\n", - " 880., 882., 884., 886.])}\n", - "starting control_progress\n", - "getting new current: 458, my old counter is: 443\n", - "{'repetition': array([443., 444., 445., 446., 447., 448., 449., 450., 451., 452., 453.,\n", - " 454., 455., 456., 457.]), 'V': array([-0.19576233, -0.19574028, -0.19576768, -0.19580057, -0.19577585,\n", - " -0.19575762, -0.1957702 , -0.19577461, -0.19577282, -0.19572397,\n", - " -0.19574225, -0.19571669, -0.19575674, -0.19571974, -0.19577206]), 'tracker': array([888., 890., 892., 894., 896., 898., 900., 902., 904., 906., 908.,\n", - " 910., 912., 914., 916.])}\n", - "starting control_progress\n", - "getting new current: 473, my old counter is: 458\n", - "{'repetition': array([458., 459., 460., 461., 462., 463., 464., 465., 466., 467., 468.,\n", - " 469., 470., 471., 472.]), 'V': array([-0.19575988, -0.19576492, -0.19575344, -0.19575002, -0.1957464 ,\n", - " -0.19574878, -0.19577142, -0.19577105, -0.19578417, -0.19573795,\n", - " -0.19573122, -0.19571762, -0.19576555, -0.19575001, -0.19574252]), 'tracker': array([918., 920., 922., 924., 926., 928., 930., 932., 934., 936., 938.,\n", - " 940., 942., 944., 946.])}\n", - "starting control_progress\n", - "getting new current: 488, my old counter is: 473\n", - "{'repetition': array([473., 474., 475., 476., 477., 478., 479., 480., 481., 482., 483.,\n", - " 484., 485., 486., 487.]), 'V': array([-0.19572167, -0.1957374 , -0.19574232, -0.19573629, -0.19574209,\n", - " -0.19572953, -0.19573419, -0.19576821, -0.19576487, -0.19575105,\n", - " -0.19574441, -0.1957302 , -0.1957319 , -0.19573577, -0.19572477]), 'tracker': array([948., 950., 952., 954., 956., 958., 960., 962., 964., 966., 968.,\n", - " 970., 972., 974., 976.])}\n", - "starting control_progress\n", - "getting new current: 503, my old counter is: 488\n", - "{'repetition': array([488., 489., 490., 491., 492., 493., 494., 495., 496., 497., 498.,\n", - " 499., 500., 501., 502.]), 'V': array([-0.19575965, -0.19574095, -0.19577964, -0.19576531, -0.1957581 ,\n", - " -0.19574733, -0.19576078, -0.19575166, -0.19576658, -0.19573462,\n", - " -0.19574659, -0.19572744, -0.1957468 , -0.19571928, -0.19576697]), 'tracker': array([ 978., 980., 982., 984., 986., 988., 990., 992., 994.,\n", - " 996., 998., 1000., 1002., 1004., 1006.])}\n", - "starting control_progress\n", - "getting new current: 516, my old counter is: 503\n", - "{'repetition': array([503., 504., 505., 506., 507., 508., 509., 510., 511., 512., 513.,\n", - " 514., 515.]), 'V': array([-0.19577319, -0.19574289, -0.19573363, -0.19576193, -0.19573025,\n", - " -0.19576148, -0.19573504, -0.19572638, -0.19574499, -0.19574682,\n", - " -0.19577214, -0.19575321, -0.19576225]), 'tracker': array([1008., 1010., 1012., 1014., 1016., 1018., 1020., 1022., 1024.,\n", - " 1026., 1028., 1030., 1032.])}\n", - "starting control_progress\n", - "getting new current: 531, my old counter is: 516\n", - "{'repetition': array([516., 517., 518., 519., 520., 521., 522., 523., 524., 525., 526.,\n", - " 527., 528., 529., 530.]), 'V': array([-0.1957626 , -0.19572385, -0.19574756, -0.19574137, -0.19573744,\n", - " -0.19575919, -0.19574772, -0.19573719, -0.1957392 , -0.19573919,\n", - " -0.19573899, -0.19574278, -0.19573775, -0.19573212, -0.19573404]), 'tracker': array([1034., 1036., 1038., 1040., 1042., 1044., 1046., 1048., 1050.,\n", - " 1052., 1054., 1056., 1058., 1060., 1062.])}\n", - "starting control_progress\n", - "getting new current: 546, my old counter is: 531\n", - "{'repetition': array([531., 532., 533., 534., 535., 536., 537., 538., 539., 540., 541.,\n", - " 542., 543., 544., 545.]), 'V': array([-0.19577264, -0.19574903, -0.19578788, -0.19576212, -0.19579994,\n", - " -0.19576741, -0.19578743, -0.19578701, -0.19578144, -0.19576551,\n", - " -0.19573426, -0.19576523, -0.19573572, -0.19576174, -0.1957588 ]), 'tracker': array([1064., 1066., 1068., 1070., 1072., 1074., 1076., 1078., 1080.,\n", - " 1082., 1084., 1086., 1088., 1090., 1092.])}\n", - "starting control_progress\n", - "getting new current: 561, my old counter is: 546\n", - "{'repetition': array([546., 547., 548., 549., 550., 551., 552., 553., 554., 555., 556.,\n", - " 557., 558., 559., 560.]), 'V': array([-0.19575676, -0.19572942, -0.19576163, -0.19574991, -0.19577293,\n", - " -0.1957659 , -0.19573754, -0.1957569 , -0.19575942, -0.19574101,\n", - " -0.1957352 , -0.19574931, -0.19575657, -0.19575075, -0.19578855]), 'tracker': array([1094., 1096., 1098., 1100., 1102., 1104., 1106., 1108., 1110.,\n", - " 1112., 1114., 1116., 1118., 1120., 1122.])}\n", - "starting control_progress\n", - "getting new current: 574, my old counter is: 561\n", - "{'repetition': array([561., 562., 563., 564., 565., 566., 567., 568., 569., 570., 571.,\n", - " 572., 573.]), 'V': array([-0.19574429, -0.19574675, -0.19574923, -0.19576131, -0.19577216,\n", - " -0.19576826, -0.19576892, -0.19570974, -0.1957396 , -0.19576179,\n", - " -0.19572863, -0.19571857, -0.19574117]), 'tracker': array([1124., 1126., 1128., 1130., 1132., 1134., 1136., 1138., 1140.,\n", - " 1142., 1144., 1146., 1148.])}\n", - "starting control_progress\n", - "getting new current: 589, my old counter is: 574\n", - "{'repetition': array([574., 575., 576., 577., 578., 579., 580., 581., 582., 583., 584.,\n", - " 585., 586., 587., 588.]), 'V': array([-0.19575764, -0.19575445, -0.19572538, -0.19575012, -0.19579348,\n", - " -0.19577249, -0.19577177, -0.19576791, -0.19576452, -0.19576158,\n", - " -0.19578413, -0.19580349, -0.19576159, -0.19575891, -0.19577966]), 'tracker': array([1150., 1152., 1154., 1156., 1158., 1160., 1162., 1164., 1166.,\n", - " 1168., 1170., 1172., 1174., 1176., 1178.])}\n", - "starting control_progress\n", - "getting new current: 604, my old counter is: 589\n", - "{'repetition': array([589., 590., 591., 592., 593., 594., 595., 596., 597., 598., 599.,\n", - " 600., 601., 602., 603.]), 'V': array([-0.19576747, -0.19578961, -0.19579923, -0.19578919, -0.19575879,\n", - " -0.19576924, -0.19575146, -0.19578908, -0.19578736, -0.19579463,\n", - " -0.19579294, -0.19581107, -0.19578658, -0.19578421, -0.19577275]), 'tracker': array([1180., 1182., 1184., 1186., 1188., 1190., 1192., 1194., 1196.,\n", - " 1198., 1200., 1202., 1204., 1206., 1208.])}\n", - "starting control_progress\n", - "getting new current: 619, my old counter is: 604\n", - "{'repetition': array([604., 605., 606., 607., 608., 609., 610., 611., 612., 613., 614.,\n", - " 615., 616., 617., 618.]), 'V': array([-0.1957866 , -0.19576372, -0.19574231, -0.19577928, -0.19577921,\n", - " -0.19579585, -0.19582024, -0.19577373, -0.19580342, -0.19577709,\n", - " -0.19576403, -0.19578641, -0.19573165, -0.19575763, -0.19572283]), 'tracker': array([1210., 1212., 1214., 1216., 1218., 1220., 1222., 1224., 1226.,\n", - " 1228., 1230., 1232., 1234., 1236., 1238.])}\n", - "starting control_progress\n", - "getting new current: 631, my old counter is: 619\n", - "{'repetition': array([619., 620., 621., 622., 623., 624., 625., 626., 627., 628., 629.,\n", - " 630.]), 'V': array([-0.19570861, -0.19576527, -0.1957134 , -0.19573737, -0.19572553,\n", - " -0.19577749, -0.19577896, -0.19573761, -0.19577084, -0.19576516,\n", - " -0.19578893, -0.1957602 ]), 'tracker': array([1240., 1242., 1244., 1246., 1248., 1250., 1252., 1254., 1256.,\n", - " 1258., 1260., 1262.])}\n", - "starting control_progress\n", - "getting new current: 647, my old counter is: 631\n", - "{'repetition': array([631., 632., 633., 634., 635., 636., 637., 638., 639., 640., 641.,\n", - " 642., 643., 644., 645., 646.]), 'V': array([-0.19571034, -0.19574427, -0.19577987, -0.19573187, -0.1957286 ,\n", - " -0.19572173, -0.19571079, -0.19574257, -0.19574926, -0.19572312,\n", - " -0.19570914, -0.19572528, -0.19569168, -0.19573534, -0.19572873,\n", - " -0.19575239]), 'tracker': array([1264., 1266., 1268., 1270., 1272., 1274., 1276., 1278., 1280.,\n", - " 1282., 1284., 1286., 1288., 1290., 1292., 1294.])}\n", - "starting control_progress\n", - "getting new current: 662, my old counter is: 647\n", - "{'repetition': array([647., 648., 649., 650., 651., 652., 653., 654., 655., 656., 657.,\n", - " 658., 659., 660., 661.]), 'V': array([-0.19575501, -0.19574064, -0.19573782, -0.19573177, -0.19573409,\n", - " -0.19572403, -0.19573971, -0.19575436, -0.19572347, -0.1957123 ,\n", - " -0.19572906, -0.19575923, -0.19571871, -0.19573157, -0.19573099]), 'tracker': array([1296., 1298., 1300., 1302., 1304., 1306., 1308., 1310., 1312.,\n", - " 1314., 1316., 1318., 1320., 1322., 1324.])}\n", - "starting control_progress\n", - "getting new current: 677, my old counter is: 662\n", - "{'repetition': array([662., 663., 664., 665., 666., 667., 668., 669., 670., 671., 672.,\n", - " 673., 674., 675., 676.]), 'V': array([-0.19571936, -0.19572929, -0.19571849, -0.19570949, -0.19573601,\n", - " -0.19574103, -0.1957112 , -0.19572997, -0.19573584, -0.19574551,\n", - " -0.1957437 , -0.19574552, -0.19575286, -0.19574619, -0.19573169]), 'tracker': array([1326., 1328., 1330., 1332., 1334., 1336., 1338., 1340., 1342.,\n", - " 1344., 1346., 1348., 1350., 1352., 1354.])}\n", - "starting control_progress\n", - "getting new current: 692, my old counter is: 677\n", - "{'repetition': array([677., 678., 679., 680., 681., 682., 683., 684., 685., 686., 687.,\n", - " 688., 689., 690., 691.]), 'V': array([-0.19575215, -0.19572866, -0.19575182, -0.19573189, -0.19577973,\n", - " -0.19578504, -0.1957748 , -0.19577009, -0.19576898, -0.19575509,\n", - " -0.19573693, -0.19574451, -0.19576193, -0.19576573, -0.1957339 ]), 'tracker': array([1356., 1358., 1360., 1362., 1364., 1366., 1368., 1370., 1372.,\n", - " 1374., 1376., 1378., 1380., 1382., 1384.])}\n", - "starting control_progress\n", - "getting new current: 704, my old counter is: 692\n", - "{'repetition': array([692., 693., 694., 695., 696., 697., 698., 699., 700., 701., 702.,\n", - " 703.]), 'V': array([-0.195753 , -0.19573673, -0.19573615, -0.19572631, -0.19577333,\n", - " -0.19575053, -0.19574484, -0.19577717, -0.19576654, -0.19575455,\n", - " -0.19575886, -0.19576237]), 'tracker': array([1386., 1388., 1390., 1392., 1394., 1396., 1398., 1400., 1402.,\n", - " 1404., 1406., 1408.])}\n", - "starting control_progress\n", - "getting new current: 720, my old counter is: 704\n", - "{'repetition': array([704., 705., 706., 707., 708., 709., 710., 711., 712., 713., 714.,\n", - " 715., 716., 717., 718., 719.]), 'V': array([-0.19576239, -0.19575494, -0.19578413, -0.19575422, -0.1957335 ,\n", - " -0.19576243, -0.19575835, -0.19571444, -0.19573792, -0.19576808,\n", - " -0.1957747 , -0.19571327, -0.19574999, -0.1957387 , -0.19573887,\n", - " -0.19574643]), 'tracker': array([1410., 1412., 1414., 1416., 1418., 1420., 1422., 1424., 1426.,\n", - " 1428., 1430., 1432., 1434., 1436., 1438., 1440.])}\n", - "starting control_progress\n", - "getting new current: 735, my old counter is: 720\n", - "{'repetition': array([720., 721., 722., 723., 724., 725., 726., 727., 728., 729., 730.,\n", - " 731., 732., 733., 734.]), 'V': array([-0.19579647, -0.19578544, -0.19581163, -0.19581464, -0.19580963,\n", - " -0.19578468, -0.19579515, -0.19578819, -0.19575239, -0.195752 ,\n", - " -0.19580071, -0.19576794, -0.19579114, -0.19578077, -0.19580105]), 'tracker': array([1442., 1444., 1446., 1448., 1450., 1452., 1454., 1456., 1458.,\n", - " 1460., 1462., 1464., 1466., 1468., 1470.])}\n", - "starting control_progress\n", - "getting new current: 747, my old counter is: 735\n", - "{'repetition': array([735., 736., 737., 738., 739., 740., 741., 742., 743., 744., 745.,\n", - " 746.]), 'V': array([-0.1957742 , -0.19581393, -0.19579934, -0.19583833, -0.19578037,\n", - " -0.19576357, -0.19579613, -0.19578404, -0.19576786, -0.19578788,\n", - " -0.19571121, -0.19573976]), 'tracker': array([1472., 1474., 1476., 1478., 1480., 1482., 1484., 1486., 1488.,\n", - " 1490., 1492., 1494.])}\n", - "starting control_progress\n", - "getting new current: 762, my old counter is: 747\n", - "{'repetition': array([747., 748., 749., 750., 751., 752., 753., 754., 755., 756., 757.,\n", - " 758., 759., 760., 761.]), 'V': array([-0.19575492, -0.1957792 , -0.19572459, -0.19572974, -0.19572679,\n", - " -0.19573491, -0.19575702, -0.19570345, -0.19573155, -0.19574498,\n", - " -0.19575002, -0.19576356, -0.19576192, -0.19573549, -0.19574732]), 'tracker': array([1496., 1498., 1500., 1502., 1504., 1506., 1508., 1510., 1512.,\n", - " 1514., 1516., 1518., 1520., 1522., 1524.])}\n", - "starting control_progress\n", - "getting new current: 775, my old counter is: 762\n", - "{'repetition': array([762., 763., 764., 765., 766., 767., 768., 769., 770., 771., 772.,\n", - " 773., 774.]), 'V': array([-0.19575006, -0.19577064, -0.19575576, -0.19575593, -0.19582352,\n", - " -0.19579913, -0.19578379, -0.19580873, -0.19572289, -0.19577239,\n", - " -0.19574414, -0.19575055, -0.19575908]), 'tracker': array([1526., 1528., 1530., 1532., 1534., 1536., 1538., 1540., 1542.,\n", - " 1544., 1546., 1548., 1550.])}\n", - "starting control_progress\n", - "getting new current: 790, my old counter is: 775\n", - "{'repetition': array([775., 776., 777., 778., 779., 780., 781., 782., 783., 784., 785.,\n", - " 786., 787., 788., 789.]), 'V': array([-0.19577031, -0.19579513, -0.19578459, -0.19579254, -0.19580233,\n", - " -0.1957849 , -0.19577014, -0.19572259, -0.19576883, -0.19577356,\n", - " -0.1957497 , -0.19577976, -0.19576114, -0.19574616, -0.19573834]), 'tracker': array([1552., 1554., 1556., 1558., 1560., 1562., 1564., 1566., 1568.,\n", - " 1570., 1572., 1574., 1576., 1578., 1580.])}\n", - "starting control_progress\n", - "getting new current: 802, my old counter is: 790\n", - "{'repetition': array([790., 791., 792., 793., 794., 795., 796., 797., 798., 799., 800.,\n", - " 801.]), 'V': array([-0.19569951, -0.19573152, -0.19578028, -0.19574172, -0.19573221,\n", - " -0.19575178, -0.19575303, -0.19573751, -0.19576462, -0.19577368,\n", - " -0.19573763, -0.19573139]), 'tracker': array([1582., 1584., 1586., 1588., 1590., 1592., 1594., 1596., 1598.,\n", - " 1600., 1602., 1604.])}\n", - "starting control_progress\n", - "getting new current: 817, my old counter is: 802\n", - "{'repetition': array([802., 803., 804., 805., 806., 807., 808., 809., 810., 811., 812.,\n", - " 813., 814., 815., 816.]), 'V': array([-0.19578054, -0.19574938, -0.19575801, -0.19579019, -0.19580123,\n", - " -0.19573683, -0.19574995, -0.19576469, -0.19575247, -0.19578248,\n", - " -0.19576091, -0.19574833, -0.19576409, -0.19577764, -0.19572341]), 'tracker': array([1606., 1608., 1610., 1612., 1614., 1616., 1618., 1620., 1622.,\n", - " 1624., 1626., 1628., 1630., 1632., 1634.])}\n", - "starting control_progress\n", - "getting new current: 833, my old counter is: 817\n", - "{'repetition': array([817., 818., 819., 820., 821., 822., 823., 824., 825., 826., 827.,\n", - " 828., 829., 830., 831., 832.]), 'V': array([-0.19572835, -0.19572877, -0.19577347, -0.19574624, -0.19576412,\n", - " -0.19578243, -0.19579901, -0.19576972, -0.19577969, -0.19573486,\n", - " -0.19574424, -0.19576554, -0.19573048, -0.19575347, -0.19575029,\n", - " -0.19574359]), 'tracker': array([1636., 1638., 1640., 1642., 1644., 1646., 1648., 1650., 1652.,\n", - " 1654., 1656., 1658., 1660., 1662., 1664., 1666.])}\n", - "starting control_progress\n", - "getting new current: 845, my old counter is: 833\n", - "{'repetition': array([833., 834., 835., 836., 837., 838., 839., 840., 841., 842., 843.,\n", - " 844.]), 'V': array([-0.19576955, -0.19577743, -0.19578689, -0.19576582, -0.19571972,\n", - " -0.19573686, -0.19574375, -0.19574789, -0.1957743 , -0.19576673,\n", - " -0.19576001, -0.19578537]), 'tracker': array([1668., 1670., 1672., 1674., 1676., 1678., 1680., 1682., 1684.,\n", - " 1686., 1688., 1690.])}\n", - "starting control_progress\n", - "getting new current: 860, my old counter is: 845\n", - "{'repetition': array([845., 846., 847., 848., 849., 850., 851., 852., 853., 854., 855.,\n", - " 856., 857., 858., 859.]), 'V': array([-0.19574061, -0.19576467, -0.19577138, -0.19571992, -0.19577087,\n", - " -0.19571232, -0.19572624, -0.19572648, -0.19572273, -0.19574994,\n", - " -0.19573916, -0.19576792, -0.1957518 , -0.19575615, -0.19575886]), 'tracker': array([1692., 1694., 1696., 1698., 1700., 1702., 1704., 1706., 1708.,\n", - " 1710., 1712., 1714., 1716., 1718., 1720.])}\n", - "starting control_progress\n", - "getting new current: 875, my old counter is: 860\n", - "{'repetition': array([860., 861., 862., 863., 864., 865., 866., 867., 868., 869., 870.,\n", - " 871., 872., 873., 874.]), 'V': array([-0.19577972, -0.19576756, -0.19573357, -0.19577948, -0.19576239,\n", - " -0.1957639 , -0.19579578, -0.19577057, -0.1957942 , -0.19573407,\n", - " -0.19576558, -0.19576694, -0.19576567, -0.19579304, -0.19575641]), 'tracker': array([1722., 1724., 1726., 1728., 1730., 1732., 1734., 1736., 1738.,\n", - " 1740., 1742., 1744., 1746., 1748., 1750.])}\n", - "starting control_progress\n", - "getting new current: 888, my old counter is: 875\n", - "{'repetition': array([875., 876., 877., 878., 879., 880., 881., 882., 883., 884., 885.,\n", - " 886., 887.]), 'V': array([-0.19576488, -0.19574624, -0.19576501, -0.19576481, -0.19576766,\n", - " -0.19579041, -0.1958085 , -0.19579134, -0.19576532, -0.19576516,\n", - " -0.19571576, -0.1957683 , -0.19575299]), 'tracker': array([1752., 1754., 1756., 1758., 1760., 1762., 1764., 1766., 1768.,\n", - " 1770., 1772., 1774., 1776.])}\n", - "starting control_progress\n", - "getting new current: 903, my old counter is: 888\n", - "{'repetition': array([888., 889., 890., 891., 892., 893., 894., 895., 896., 897., 898.,\n", - " 899., 900., 901., 902.]), 'V': array([-0.19575586, -0.19574425, -0.19572629, -0.19574856, -0.19569823,\n", - " -0.19572328, -0.19578272, -0.19570395, -0.1957453 , -0.19571691,\n", - " -0.19577704, -0.19576417, -0.19569682, -0.19572679, -0.19574861]), 'tracker': array([1778., 1780., 1782., 1784., 1786., 1788., 1790., 1792., 1794.,\n", - " 1796., 1798., 1800., 1802., 1804., 1806.])}\n", - "starting control_progress\n", - "getting new current: 918, my old counter is: 903\n", - "{'repetition': array([903., 904., 905., 906., 907., 908., 909., 910., 911., 912., 913.,\n", - " 914., 915., 916., 917.]), 'V': array([-0.19571785, -0.19571098, -0.19575038, -0.1957307 , -0.19571119,\n", - " -0.1957401 , -0.19573142, -0.19572868, -0.19572092, -0.19573402,\n", - " -0.19572985, -0.19574344, -0.1957375 , -0.19572707, -0.19573357]), 'tracker': array([1808., 1810., 1812., 1814., 1816., 1818., 1820., 1822., 1824.,\n", - " 1826., 1828., 1830., 1832., 1834., 1836.])}\n", - "starting control_progress\n", - "getting new current: 933, my old counter is: 918\n", - "{'repetition': array([918., 919., 920., 921., 922., 923., 924., 925., 926., 927., 928.,\n", - " 929., 930., 931., 932.]), 'V': array([-0.19574902, -0.19575946, -0.19575174, -0.1957424 , -0.19574685,\n", - " -0.19571595, -0.19571584, -0.19571168, -0.19571777, -0.19572635,\n", - " -0.19573719, -0.19574953, -0.19570252, -0.19575522, -0.19573407]), 'tracker': array([1838., 1840., 1842., 1844., 1846., 1848., 1850., 1852., 1854.,\n", - " 1856., 1858., 1860., 1862., 1864., 1866.])}\n", - "starting control_progress\n", - "getting new current: 948, my old counter is: 933\n", - "{'repetition': array([933., 934., 935., 936., 937., 938., 939., 940., 941., 942., 943.,\n", - " 944., 945., 946., 947.]), 'V': array([-0.19576511, -0.19574578, -0.19575017, -0.19573961, -0.19575302,\n", - " -0.19577726, -0.19572788, -0.19572851, -0.19574432, -0.19573516,\n", - " -0.19571884, -0.19573231, -0.19575582, -0.19572923, -0.19571621]), 'tracker': array([1868., 1870., 1872., 1874., 1876., 1878., 1880., 1882., 1884.,\n", - " 1886., 1888., 1890., 1892., 1894., 1896.])}\n", - "starting control_progress\n", - "getting new current: 963, my old counter is: 948\n", - "{'repetition': array([948., 949., 950., 951., 952., 953., 954., 955., 956., 957., 958.,\n", - " 959., 960., 961., 962.]), 'V': array([-0.19569742, -0.19570006, -0.19572387, -0.19570903, -0.19572389,\n", - " -0.19569775, -0.19574545, -0.19571875, -0.19576602, -0.1957106 ,\n", - " -0.19573279, -0.19574556, -0.19572769, -0.19573588, -0.19574581]), 'tracker': array([1898., 1900., 1902., 1904., 1906., 1908., 1910., 1912., 1914.,\n", - " 1916., 1918., 1920., 1922., 1924., 1926.])}\n", - "starting control_progress\n", - "getting new current: 976, my old counter is: 963\n", - "{'repetition': array([963., 964., 965., 966., 967., 968., 969., 970., 971., 972., 973.,\n", - " 974., 975.]), 'V': array([-0.19574424, -0.19568617, -0.19570247, -0.19573955, -0.19573638,\n", - " -0.19571823, -0.19574532, -0.1957263 , -0.19574895, -0.19572521,\n", - " -0.19571673, -0.19572715, -0.19574023]), 'tracker': array([1928., 1930., 1932., 1934., 1936., 1938., 1940., 1942., 1944.,\n", - " 1946., 1948., 1950., 1952.])}\n", - "starting control_progress\n", - "getting new current: 991, my old counter is: 976\n", - "{'repetition': array([976., 977., 978., 979., 980., 981., 982., 983., 984., 985., 986.,\n", - " 987., 988., 989., 990.]), 'V': array([-0.1957289 , -0.19574274, -0.19574245, -0.19570962, -0.19571475,\n", - " -0.19571752, -0.19573914, -0.19572211, -0.19572253, -0.19577275,\n", - " -0.19580164, -0.19575809, -0.19576358, -0.19575454, -0.19576885]), 'tracker': array([1954., 1956., 1958., 1960., 1962., 1964., 1966., 1968., 1970.,\n", - " 1972., 1974., 1976., 1978., 1980., 1982.])}\n", - "starting control_progress\n", - "I have turned container False\n", - "I have turned container False\n", - "I have turned container False\n", - "getting new current: 1000, my old counter is: 991\n", - "{'repetition': array([991., 992., 993., 994., 995., 996., 997., 998., 999.]), 'V': array([-0.19577323, -0.19576737, -0.19578125, -0.19574994, -0.19576499,\n", - " -0.19577337, -0.1957357 , -0.1957344 , -0.19568743]), 'tracker': array([1984., 1986., 1988., 1990., 1992., 1994., 1996., 1998., 2000.])}\n", - "The measurement has finished and all of the data has been saved.\n" - ] - } - ], - "source": [ - "run_sweep(sweep, DATADIR, f'OPX test standard #{test_name_counter}', prt=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ed177287-3342-4278-adcb-b0a9194fc301", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f55edb3c-61c3-45db-9da0-b153c9b241dc", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0d720608-fe03-45a9-aab9-2e0ca0fd657c", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f7691482-1c64-46b2-be03-8338d6abbaab", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c25533c9-51d2-4e2e-b1de-2338ecc4801f", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "sensitive-beijing", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2021-07-27 16:40:10,426 - qm - INFO - Performing health check\n", - "2021-07-27 16:40:10,441 - qm - INFO - Health check passed\n", - "2021-07-27 16:40:10,741 - qm - INFO - Flags: \n", - "2021-07-27 16:40:10,741 - qm - INFO - Executing high level program\n", - "\n", - "saving repetition\n", - "the data that comes back has a type of: \n", - "saving V\n", - "the data that comes back has a type of: \n", - "saving tracker\n", - "the data that comes back has a type of: \n", - "[array([ 0, 1, 2, ..., 9997, 9998, 9999], dtype=int64), array([-0.19584275, -0.19584035, -0.19582246, ..., -0.19582816,\n", - " -0.19582617, -0.19583536]), array([ 3, 5, 7, ..., 19997, 19999, 20001], dtype=int64)]\n" - ] - } - ], - "source": [ - "config = QMConfig()\n", - "qmachine_mgr = QuantumMachinesManager()\n", - "qmachine = qmachine_mgr.open_qm(config.config())\n", - "job = qmachine.execute(my_qua_experiment())\n", - "res_handle = job.result_handles\n", - "res_handle.wait_for_all_values()\n", - "data=[]\n", - "print(type(res_handle))\n", - "for name, handle in res_handle:\n", - " handle.wait_for_values(0)\n", - " \n", - " print(f'saving {name}')\n", - " print(f\"the data that comes back has a type of: {type(handle.fetch_all()['value'])}\")\n", - " data.append(np.array(handle.fetch_all()['value']))\n", - "\n", - "print(data)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "stainless-scanner", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "aggressive-expert", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "resident-option", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "gothic-australia", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "instructional-infrastructure", - "metadata": {}, - "outputs": [], - "source": [ - "def gen():\n", - " x = 0\n", - " while x < 5:\n", - " x = np.random.randint(low=0, high=6)\n", - " yield x" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "equal-dairy", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'x': 3, 'a': 5}\n", - "{'x': 0, 'a': 5}\n", - "{'x': 3, 'a': 5}\n", - "{'x': 3, 'a': 5}\n", - "{'x': 3, 'a': 5}\n", - "{'x': 2, 'a': 5}\n", - "{'x': 5, 'a': 5}\n" - ] - } - ], - "source": [ - "sweep = sweep_parameter('x', gen(), record_as(lambda: 5, 'a'))\n", - "for rep in sweep:\n", - " print(rep)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "neutral-electron", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(DataSpec(name='x', depends_on=None, type=, unit=''),\n", - " DataSpec(name='a', depends_on=['x'], type=, unit=''))" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sweep.get_data_specs()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "106144a8-ba5a-42d5-94c7-5b685e1c3f31", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{}\n", - "{}\n", - "{}\n", - "{}\n", - "{}\n" - ] - } - ], - "source": [ - "for data in Sweep(range(5)):\n", - " print(data)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a323ce7d-c3f2-498f-a8b4-9d729f33dab3", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "3affb9a0-2508-437f-9bb6-fcd86b099b11", - "metadata": {}, - "outputs": [], - "source": [ - "def repetitions(repeat):\n", - " def inner_function(func):\n", - " return func\n", - " return inner_function, repeat" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "a70dbd3a-2d68-4678-8a09-2f2dc64fe259", - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "'tuple' object is not callable", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_808/3946660972.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;33m@\u001b[0m\u001b[0mrepetitions\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrepeat\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0mprint_something\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtext\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtext\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mTypeError\u001b[0m: 'tuple' object is not callable" - ] - } - ], - "source": [ - "@repetitions(repeat = 1)\n", - "def print_something(text):\n", - " print(text)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "0971c1bb-d4a4-4340-9711-69713709bc84", - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "'tuple' object is not callable", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_808/1475574347.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint_something\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'this text is being printed'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mTypeError\u001b[0m: 'tuple' object is not callable" - ] - } - ], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e52b62bb-1869-4184-a5b4-8b9d32c452f8", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 120, - "id": "d0d5e118-82cf-4abc-89a0-03f52420a75e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x is: 1 and y is: 5\n", - "9\n", - "x is: 3 and y is: 1\n", - "7\n" - ] - } - ], - "source": [ - "def f(x):\n", - " def g(y):\n", - " print(f'x is: {x} and y is: {y}')\n", - " return y + x + 3 \n", - " return g\n", - "\n", - "nf1 = f(1)\n", - "nf2 = f(3)\n", - "\n", - "print(nf1(5))\n", - "print(nf2(1))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2de500ad-50d1-484c-a190-14ff8c1b1d42", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 142, - "id": "a83d5909-8c34-4a6b-861a-90aebfb0a1b2", - "metadata": {}, - "outputs": [], - "source": [ - "def my_qua_decorator_sim(*data_specs):\n", - " def nested_1(func):\n", - " return func, *data_specs\n", - " return nested_1" - ] - }, - { - "cell_type": "code", - "execution_count": 150, - "id": "7ff7a8d4-2577-4136-9c1b-1de90a6d0ce2", - "metadata": {}, - "outputs": [], - "source": [ - "@my_qua_decorator_sim(\n", - " independent('x', type='array'),\n", - " dependent('y', depends_on=['x'], type='array'))\n", - "def calculation(mult=2, num=5):\n", - " x = [i for i in range(num)]\n", - " y = [i*mult for i in x]\n", - " return np.array(x), np.array(y)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 154, - "id": "344af6aa-a5eb-4840-b4e9-6b0508f1b5da", - "metadata": {}, - "outputs": [], - "source": [ - "def sweep_creation(recorded_function):\n", - " for i in recorded_function:\n", - " print(i)\n", - " @recording(recorded_function[1:])\n", - " def collect():\n", - " counter = 5\n", - " while counter >= 0:\n", - " counter -=1\n", - " yield recorded_function[0]()\n", - " \n", - " \n", - " return Sweep(collect())\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 171, - "id": "0cf4ed08-fede-49fd-8027-073747e46391", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "DataSpec(name='x', depends_on=None, type=, unit='')\n", - "DataSpec(name='y', depends_on=['x'], type=, unit='')\n" - ] - } - ], - "source": [ - "sweep = sweep_creation(calculation)" - ] - }, - { - "cell_type": "code", - "execution_count": 174, - "id": "032a6f34-3d14-4366-95f5-4907cfe3517c", - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "unhashable type: 'DataSpec'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_18236/3880226794.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0msweep\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32mc:\\users\\msmt\\documents\\github\\labcore\\labcore\\measurement\\sweep.py\u001b[0m in \u001b[0;36m__next__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 270\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0m__next__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 271\u001b[0m \u001b[0mret\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 272\u001b[1;33m \u001b[0mnext_point\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpointer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 273\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mproduces_record\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msweep\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpointer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 274\u001b[0m \u001b[0mret\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext_point\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32mc:\\users\\msmt\\documents\\github\\labcore\\labcore\\measurement\\record.py\u001b[0m in \u001b[0;36m__iter__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 204\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0m__iter__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 205\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mval\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0miterable\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 206\u001b[1;33m \u001b[1;32myield\u001b[0m \u001b[0m_to_record\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mval\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata_specs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 207\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 208\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32mc:\\users\\msmt\\documents\\github\\labcore\\labcore\\measurement\\record.py\u001b[0m in \u001b[0;36m_to_record\u001b[1;34m(value, data_specs)\u001b[0m\n\u001b[0;32m 184\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ms\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata_specs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 185\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 186\u001b[1;33m \u001b[0mret\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0ms\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 187\u001b[0m \u001b[1;32mexcept\u001b[0m \u001b[0mIndexError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 188\u001b[0m \u001b[0mret\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0ms\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'DataSpec'" - ] - } - ], - "source": [ - "data = []\n", - "for i in sweep:\n", - " data.append(i)" - ] - }, - { - "cell_type": "code", - "execution_count": 161, - "id": "55764eb2-877e-4628-a38a-d2a6198ee358", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 162, - "id": "47bde0e9-1731-4ba8-bc88-316268b2f1d5", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 163, - "id": "70a1e552-c092-4cf5-a8f4-fa1cccf71ab9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[(array([0, 1, 2, 3, 4]), array([0, 2, 4, 6, 8])),\n", - " (array([0, 1, 2, 3, 4]), array([0, 2, 4, 6, 8])),\n", - " (array([0, 1, 2, 3, 4]), array([0, 2, 4, 6, 8])),\n", - " (array([0, 1, 2, 3, 4]), array([0, 2, 4, 6, 8])),\n", - " (array([0, 1, 2, 3, 4]), array([0, 2, 4, 6, 8]))]" - ] - }, - "execution_count": 163, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e369dcfe-7b9f-4bf8-ad50-aef1909d6359", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:qcodes]", - "language": "python", - "name": "conda-env-qcodes-py" - }, - "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.9.6" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/prototyping/configuration.py b/prototyping/configuration.py deleted file mode 100644 index 2d17390..0000000 --- a/prototyping/configuration.py +++ /dev/null @@ -1,139 +0,0 @@ -"""Example config for testing the OPX. - -Author: Wolfgang Pfaff -""" -import numpy as np - - -class QMConfig: - - def __init__(self): - - # define constants here - # pulse parameters - self.readout_if = int(50e6) - self.box_length = 10000 - self.box_buffer = 100 - self.box_amp = 0.4 - - - - - - def config(self): - - """ - This config file is for an OPX with a cable connecting analog output 1 straight into analog input 1 - """ - - ret = { - 'version': 1, - - # The hardware - 'controllers': { - - 'con1': { - 'type': 'opx1', - 'analog_outputs': { - 1: {'offset': 0.0}, - }, - 'analog_inputs': { - 1: {'offset': 0.0}, - }, - }, - }, - - # The logical elements - 'elements': { - - 'readout': { - - 'singleInput': { - 'port': ('con1', 1), - }, - 'intermediate_frequency': self.readout_if, - 'operations': { - 'box': 'box_pulse', - }, - - 'outputs': { - 'out1': ('con1', 1), - }, - - 'time_of_flight': 180, - 'smearing': 0, - }, - }, - - # The pulses - 'pulses': { - - 'box_pulse': { - 'operation': 'sweeping', - 'length': self.box_length, - 'waveforms': { - 'single': 'box_wf' - }, - 'integration_weights': { - 'box_sin': 'box_sin', - 'box_cos': 'box_cos', - }, - 'digital_marker': 'ON', - - }, - }, - - 'waveforms': { - - 'box_wf': { - 'type': 'arbitrary', - 'samples': [0.0] * int(self.box_buffer) + \ - [self.box_amp] * \ - int(self.box_length - 2 * self.box_buffer) + \ - [0.0] * int(self.box_buffer), - }, - }, - - 'digital_waveforms': { - - 'ON': { - 'samples': [(1, 0)] - }, - }, - - 'integration_weights': { - - 'box_sin': { - 'cosine': [0.0] * int(self.box_length), - 'sine': [1.0] * int(self.box_length), - }, - - 'box_cos': { - 'cosine': [1.0] * int(self.box_length), - 'sine': [0.0] * int(self.box_length), - }, - - }, - - 'mixers': { - # 'readout_IQ_mixer': [ - # { - # 'intermediate_frequency': self.readout_if, - # 'lo_frequency': self.readout_lo_frq, - # 'correction': MixerCalibration.IQ_imbalance_correction( - # *self.readout_mixer_imbalance) - # }, - # ], - # 'qubit_IQ_mixer': [ - # { - # 'intermediate_frequency': self.qubit_if, - # 'lo_frequency': self.qubit_lo_frq, - # 'correction': MixerCalibration.IQ_imbalance_correction( - # *self.qubit_mixer_imbalance) - # }, - # ], - }, - } - - return ret - diff --git a/prototyping/configuring sweeps and lazy pointers.ipynb b/prototyping/configuring sweeps and lazy pointers.ipynb deleted file mode 100644 index f857a0c..0000000 --- a/prototyping/configuring sweeps and lazy pointers.ipynb +++ /dev/null @@ -1,463 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "11efc49c-b674-4883-bdc4-2dd725e30a27", - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "20d83ffd-7219-4523-a5fe-874058fa627f", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "59134b13-524e-4c5f-b3b4-b781d5d768d9", - "metadata": {}, - "outputs": [], - "source": [ - "from labcore.measurement import Sweep, pointer, record_as, indep, sweep_parameter, recording, dep\n", - "from labcore.measurement.sweep import AsyncRecord" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3b96ded0-70fd-4313-b2ea-c4b1396d4597", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "81b67e5f-d4d5-45e0-9b91-aefb32550aa5", - "metadata": {}, - "source": [ - "## configuring sweeps" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "7bed32d6-28d9-4645-954f-4369dcac880d", - "metadata": {}, - "outputs": [], - "source": [ - "@recording('x')\n", - "def measure_random_numbers(mean=0, scale=1., nvals=1):\n", - " return np.random.normal(loc=mean, scale=scale, size=nvals)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "7efba1e7-6de1-44bc-b6b3-623b831b0be4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'a': 0, 'x': array([-1.07520604])}\n", - "{'a': 1, 'x': array([-0.98872233])}\n", - "{'a': 2, 'x': array([1.78346645])}\n" - ] - } - ], - "source": [ - "sweep = sweep_parameter('a', range(3), measure_random_numbers)\n", - "for s in sweep:\n", - " print(s)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "b591b57c-77b5-41a8-8c0d-8cfcd4e5dcc7", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'a': 0, 'x': array([9.50424447])}\n", - "{'a': 1, 'x': array([9.88050777])}\n", - "{'a': 2, 'x': array([10.46168569])}\n" - ] - } - ], - "source": [ - "sweep = sweep_parameter('a', range(3), measure_random_numbers.using(mean=10))\n", - "for s in sweep:\n", - " print(s)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "edf826d1-71dc-4d2a-807e-af0df65437f6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'a': 0, 'x': array([-3.81455827])}\n", - "{'a': 1, 'x': array([-4.34206255])}\n", - "{'a': 2, 'x': array([-5.90485879])}\n" - ] - } - ], - "source": [ - "sweep = sweep_parameter('a', range(3), measure_random_numbers)\n", - "sweep.set_options(\n", - " measure_random_numbers=dict(mean=-5),\n", - ")\n", - "for s in sweep:\n", - " print(s)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "768fb3e2-578f-4fbf-a100-f08996a08994", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'a': 0, 'x': array([11.06953062])}\n", - "{'a': 1, 'x': array([8.74032162])}\n", - "{'a': 2, 'x': array([8.66727255])}\n" - ] - } - ], - "source": [ - "sweep = sweep_parameter('a', range(3), measure_random_numbers.using(mean=10))\n", - "sweep.set_options(\n", - " measure_random_numbers=dict(mean=-5),\n", - ")\n", - "for s in sweep:\n", - " print(s)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b2ec1782-bd8f-4d68-a3bf-e87299a684d8", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "b7122abc-327d-4cf0-b3cb-92f11fca8f0d", - "metadata": {}, - "source": [ - "## Lazy pointer" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "12c69b5b-36e2-47a3-9a71-ee1a5a9b8f29", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "8a3ede5f-9e45-430d-bb15-c9285f1095e5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "doing the first sweep:\n", - "{'x': 0}\n", - "{'x': 1}\n", - "{'x': 2}\n", - "\n", - "trying again:\n" - ] - } - ], - "source": [ - "def a_generator_function(n_vals=3):\n", - " x = 0\n", - " while x < n_vals:\n", - " yield x\n", - " x += 1\n", - "\n", - "sweep = sweep_parameter('x', a_generator_function())\n", - "\n", - "print('doing the first sweep:')\n", - "for s in sweep:\n", - " print(s)\n", - "\n", - "print('\\ntrying again:')\n", - "for s in sweep:\n", - " print(s)" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "id": "c8476262-ed63-4c35-8db9-61bd418c0e25", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "doing the first sweep:\n", - "{'x': 0}\n", - "{'x': 1}\n", - "{'x': 2}\n", - "\n", - "trying again:\n", - "{'x': 0}\n", - "{'x': 1}\n", - "{'x': 2}\n" - ] - } - ], - "source": [ - "@pointer('x')\n", - "def a_generator_function(n_vals=3):\n", - " x = 0\n", - " while x < n_vals:\n", - " yield x\n", - " x += 1\n", - "\n", - "sweep = Sweep(a_generator_function)\n", - "\n", - "print('doing the first sweep:')\n", - "for s in sweep:\n", - " print(s)\n", - "\n", - "print('\\ntrying again:')\n", - "for s in sweep:\n", - " print(s)" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "id": "caaecd8e-ff09-4410-9ab0-c86ac84252d8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "doing the first sweep:\n", - "{'x': 0}\n", - "{'x': 1}\n", - "{'x': 2}\n", - "{'x': 3}\n", - "{'x': 4}\n" - ] - } - ], - "source": [ - "sweep = Sweep(a_generator_function.using(n_vals=5))\n", - "\n", - "print('doing the first sweep:')\n", - "for s in sweep:\n", - " print(s)" - ] - }, - { - "cell_type": "markdown", - "id": "f0bf7c12-dd9e-44f8-b1ae-e26b1dc747ab", - "metadata": {}, - "source": [ - "## Complicated pointer " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "545a0e45-7a8e-4918-b4a0-59a1877cda3c", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a12e9bf1-c1c6-4716-ae02-4c8d7df4ba07", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "c4162cef-dfaf-4a1f-9bc3-315f36d7b6c0", - "metadata": {}, - "source": [ - "## AsyncRecord" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "e0ba58c1-8c9f-4cfc-b69a-57a4ef0be184", - "metadata": {}, - "outputs": [], - "source": [ - "import time" - ] - }, - { - "cell_type": "code", - "execution_count": 132, - "id": "faff1021-6b0a-411e-82cd-3f5657cd0c22", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'interrogation_times': None}\n", - "{'interrogation_times': 1630428893.361867}\n", - "{'interrogation_times': 1630428893.562287}\n", - "{'interrogation_times': 1630428893.7699819}\n", - "{'interrogation_times': 1630428893.9668071}\n", - "{'interrogation_times': 1630428894.16322}\n", - "{'interrogation_times': 1630428894.368414}\n", - "{'interrogation_times': 1630428894.572625}\n", - "{'interrogation_times': 1630428894.7647948}\n", - "{'interrogation_times': 1630428894.965135}\n", - "{'interrogation_times': 1630428895.1685271}\n" - ] - } - ], - "source": [ - "class DummyInstrument:\n", - " \n", - " def __init__(self, intervals):\n", - " self.intervals = intervals\n", - " \n", - " def run(self):\n", - " t0 = time.time()\n", - " for i in self.intervals:\n", - " while time.time()-t0 < i:\n", - " time.sleep(0.01)\n", - " yield time.time()\n", - "\n", - "\n", - "class DelayedGatheringOfTimes(AsyncRecord):\n", - " \n", - " def setup(self, fun, *args, **kwargs):\n", - " self.communicator['time'] = time.time()\n", - " intervals = fun(*args, **kwargs)\n", - " self.communicator['instrument'] = DummyInstrument(intervals)\n", - " \n", - " def collect(self, print_data=False, **kwargs):\n", - " for data in self.communicator['instrument'].run():\n", - " if print_data:\n", - " print('data:', data)\n", - " yield data\n", - " \n", - "\n", - "@DelayedGatheringOfTimes(\n", - " indep('interrogation_times'),\n", - ")\n", - "def equally_spaced_times(wait_time=0.5, points=2):\n", - " return np.arange(points) * wait_time\n", - "\n", - "\n", - "sweep = equally_spaced_times(wait_time=0.2, points=10, collector_options={'print_data': False})\n", - "\n", - "sweep.set_options(\n", - " equally_spaced_times=dict(points=5)\n", - ")\n", - "\n", - "for s in sweep:\n", - " print(s)" - ] - }, - { - "cell_type": "code", - "execution_count": 137, - "id": "16ff2035-2edb-45fd-b2cc-8e0cb969e241", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'points': 1, 'interrogation_times': None}\n", - "{'points': 1, 'interrogation_times': 1630429139.222152}\n", - "{'points': 2, 'interrogation_times': None}\n", - "{'points': 2, 'interrogation_times': 1630429139.2222779}\n", - "{'points': 2, 'interrogation_times': 1630429139.426282}\n", - "{'points': 3, 'interrogation_times': None}\n", - "{'points': 3, 'interrogation_times': 1630429139.427327}\n", - "{'points': 3, 'interrogation_times': 1630429139.631752}\n", - "{'points': 3, 'interrogation_times': 1630429139.8366048}\n", - "{'points': 4, 'interrogation_times': None}\n", - "{'points': 4, 'interrogation_times': 1630429139.837495}\n", - "{'points': 4, 'interrogation_times': 1630429140.047543}\n", - "{'points': 4, 'interrogation_times': 1630429140.24167}\n", - "{'points': 4, 'interrogation_times': 1630429140.441689}\n" - ] - } - ], - "source": [ - "outer_sweep = sweep_parameter('points', range(1,5))\n", - "inner_sweep = equally_spaced_times(wait_time=0.2)\n", - "combined_sweep = outer_sweep @ inner_sweep\n", - "\n", - "for data in combined_sweep:\n", - " print(data)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3a992dba-63e8-4739-ab2b-6f8ad55ce8b0", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:msmt-pyqt5]", - "language": "python", - "name": "conda-env-msmt-pyqt5-py" - }, - "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.9.6" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/prototyping/structured_OPX_implementation.ipynb b/prototyping/structured_OPX_implementation.ipynb deleted file mode 100644 index e40776a..0000000 --- a/prototyping/structured_OPX_implementation.ipynb +++ /dev/null @@ -1,772 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "cb9a503a-e1fb-4a0d-a1e9-523e3de4bb03", - "metadata": {}, - "source": [ - "# Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "fb34ddaf-6790-428a-804d-24da83e0ea9b", - "metadata": {}, - "outputs": [], - "source": [ - "from functools import wraps\n", - "\n", - "import numpy as np\n", - "import qcodes as qc\n", - "\n", - "from itertools import chain\n", - "\n", - "from typing import Callable, Dict, Generator, List\n", - "\n", - "from labcore.measurement import *\n", - "\n", - "from configuration import QMConfig\n", - "from qm.qua import *\n", - "from qm.QuantumMachinesManager import QuantumMachinesManager\n", - "\n", - "from plottr.data import datadict_storage as dds, datadict as dd\n", - "\n", - "# global module variable for the config file\n", - "global_config = None" - ] - }, - { - "cell_type": "markdown", - "id": "f0351e21-a232-4472-8f33-b57452eaf8f8", - "metadata": {}, - "source": [ - "# Base Decorator" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "2d336f11-0893-4ce0-8cff-1be3bfd0847b", - "metadata": {}, - "outputs": [], - "source": [ - "class BackgroundRecordingBase:\n", - " \"\"\"\n", - " Base class decorator used to record asynchronous data from instrument.\n", - " Use the decorator with create_background_sweep function to create Sweeps that collect asynchronous data from\n", - " external devices running experiments independently of the measurement PC,\n", - " e.i. the measuring happening is not being controlled by a Sweep but instead an external device (e.g. the OPX).\n", - " Each instrument should have its own custom setup_wrapper (see setup_wrapper docstring for more info),\n", - " and a custom collector.\n", - " Auxiliary functions for the start_wrapper and collector should also be located in this class.\n", - "\n", - " :param *specs: A list of the DataSpecs to record the data produced.\n", - " \"\"\"\n", - "\n", - " def __init__(self, *specs):\n", - " self.specs = specs\n", - " self.communicator = {}\n", - "\n", - " def __call__(self, fun) -> Callable:\n", - " \"\"\"\n", - " When the decorator is called the experiment function gets wrapped so that it returns an Sweep object composed\n", - " of 2 different Sweeps, the setup sweep and the collector Sweep.\n", - " \"\"\"\n", - "\n", - " def sweep(**collector_kwargs) -> Sweep:\n", - " \"\"\"\n", - " Returns a Sweep comprised of 2 different Sweeps: start_sweep and collector_sweep.\n", - " start_sweep should perform any setup actions as well as starting the actual experiment. This sweep is only\n", - " executed once. collector_sweep is iterated multiple time to collect all the data generated from the\n", - " instrument.\n", - "\n", - " :param collector_kwargs: Any arguments that the collector needs.\n", - " \"\"\"\n", - "\n", - " start_sweep = once(self.start_wrapper(fun))\n", - " collector_sweep = Sweep(record_as(self.collector(**collector_kwargs), *self.specs))\n", - " return start_sweep + collector_sweep\n", - "\n", - " return sweep\n", - "\n", - " def start_wrapper(self, fun: Callable) -> Callable:\n", - " \"\"\"\n", - " Wraps the start function. setup_wrapper should consist of another function inside of it decorated with @wraps\n", - " with fun as its argument.\n", - " In this case the wrapped function is setup.\n", - " Setup should accept the *args and **kwargs of fun. It should also place any returns from fun in the communicator.\n", - " setup_wrapper needs to return the wrapped function (setup)\n", - "\n", - " :param fun: The measurement function. In the case of the OPX this would be the function that returns the QUA\n", - " code with any arguments that it might use.\n", - " \"\"\"\n", - "\n", - " @wraps(fun)\n", - " def start(*args, **kwargs) -> None:\n", - " \"\"\"\n", - " Starts the experiment and saves anything that the collector needs from the startup of the measurement in the\n", - " collector dictionary.\n", - "\n", - " :param args: Any args that fun needs.\n", - " :param kwargs: Any kwargs that fun needs.\n", - " \"\"\"\n", - " self.communicator['setup_return'] = fun(*args, **kwargs)\n", - " return None\n", - "\n", - " return start\n", - "\n", - " def collector(self, **kwargs) -> Generator[Dict, None, None]:\n", - " \"\"\"\n", - " Data collection generator. The generator should contain all the logic of waiting for the asynchronous data.\n", - " Its should yield a dictionary with the name of the of the DataSpecs as keywords and numpy arrays with the values\n", - " collected from the instrument. The generator should exhaust itself once all the data produced by the\n", - " measurement has been generated\n", - "\n", - " :param kwargs: Any kwargs necessary for the specific implementation of the collector.\n", - " \"\"\"\n", - " data = {}\n", - " yield data\n", - "\n", - "\n", - "def create_background_sweep(decorated_measurement_function: Callable, **collector_kwargs) -> Sweep:\n", - " \"\"\"\n", - " Creates the Sweep object from a measurement function decorated with any implementation of BackgroundRecordingBase.\n", - "\n", - " :param decorated_measurement_function: Measurement function decorated with\n", - " a BackgroundRecordingBase class decorator.\n", - " :param collector_kwargs: Any kwargs that the collector needs.\n", - " \"\"\"\n", - " sweep = decorated_measurement_function(**collector_kwargs)\n", - " return sweep\n" - ] - }, - { - "cell_type": "markdown", - "id": "95c79e0a-53f4-48f0-bcfd-d3b4941991ab", - "metadata": {}, - "source": [ - "# Raw Value DataSpec" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "b3256633-08d4-4288-a851-c8fd9432ea60", - "metadata": {}, - "outputs": [], - "source": [ - "def raw_OPX_data(name: str, depends_on: List[str] = [], unit: str = '', type_var: str = 'array'):\n", - " indep_name = f'{name}_time'\n", - " indep = independent(indep_name, unit, type_var)\n", - " depends_on.append(indep_name)\n", - " dep = dependent(name,depends_on, unit, type_var)\n", - " ret = indep, dep, name\n", - "\n", - " return ret\n", - " " - ] - }, - { - "cell_type": "markdown", - "id": "c289479a-e039-413e-b444-d28a8404aea6", - "metadata": {}, - "source": [ - "# Specific OPX Implementation" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "4d12303c-bdc6-4265-a254-8267ff6e8a5d", - "metadata": {}, - "outputs": [], - "source": [ - "class RecordOPX(BackgroundRecordingBase):\n", - " \"\"\"\n", - " Implementation of BackgroundRecordingBase for use with the OPX machine.\n", - " \"\"\"\n", - "\n", - " def __init__(self, *specs):\n", - " self.communicator = {}\n", - " self.communicator['raw_variables'] = []\n", - " self.specs = tuple(self._flatten_and_sort_dataspecs(specs))\n", - " \n", - " def _flatten_and_sort_dataspecs(self, specs):\n", - " ret = []\n", - " if isinstance(specs,tuple):\n", - " for spec in specs:\n", - " if isinstance(spec, record.DataSpec):\n", - " ret.append(spec)\n", - " elif isinstance(spec, str):\n", - " self.communicator['raw_variables'].append(spec)\n", - " elif len(spec) > 1:\n", - " rec_list = self._flatten_and_sort_dataspecs(spec)\n", - " if len(rec_list) > 1:\n", - " for item in rec_list:\n", - " ret.append(item)\n", - " else:\n", - " ret.append(item)\n", - "\n", - " return ret\n", - "\n", - " def start_wrapper(self, fun: Callable) -> Callable:\n", - " \"\"\"\n", - " start_wrapper for the OPX machine. Wraps the startup function.\n", - " Returns the actual startup function to be executed when the sweep is iterated through.\n", - "\n", - " :param fun: Function that returns the QUA program.\n", - " \"\"\"\n", - "\n", - " @wraps(fun)\n", - " def startup(*args, **kwargs) -> None:\n", - " \"\"\"\n", - " Establishes connection with the OPX and starts the the measurement. The config of the OPX is passed through\n", - " the module variable global_config. It saves the result handles and saves initial values to the communicator\n", - " dictionary.\n", - " \"\"\"\n", - " # Start the measurement in the OPX.\n", - " qmachine_mgr = QuantumMachinesManager()\n", - " qmachine = qmachine_mgr.open_qm(global_config)\n", - " job = qmachine.execute(fun(*args, **kwargs))\n", - " result_handles = job.result_handles\n", - "\n", - " # Save the result handle and create initial parameters in the communicator used in the collector.\n", - " self.communicator['result_handles'] = result_handles\n", - " self.communicator['active'] = True\n", - " self.communicator['counter'] = 0\n", - "\n", - " return startup\n", - "\n", - " def _wait_for_data(self, batchsize: int) -> None:\n", - " \"\"\"\n", - " Waits for the opx to have measured more data points than the ones indicated in the batchsize. Also checks that\n", - " the OPX is still collecting data, when the OPX is no longer processing, turn communicator['active'] to False to\n", - " exhaust the collector.\n", - "\n", - " :param batchsize: Size of batch. How many data-points is the minimum for the sweep to get in an iteration.\n", - " e.g. if 5, _control_progress will keep running until at least 5 new data-points\n", - " are available for collection.\n", - " \"\"\"\n", - "\n", - " # When ready becomes True, the infinite loop stops.\n", - " ready = False\n", - "\n", - " # Collect necessary values from communicator.\n", - " res_handle = self.communicator['result_handles']\n", - " counter = self.communicator['counter']\n", - "\n", - " while not ready:\n", - " for name, handle in res_handle:\n", - " \n", - " current_datapoint = handle.count_so_far()\n", - " \n", - " # Check if the OPX is still processing.\n", - " if res_handle.is_processing():\n", - " # Check if enough data-points are available.\n", - " if current_datapoint - counter >= batchsize:\n", - " ready = True\n", - " else:\n", - " ready = False\n", - " else:\n", - " # Once the OPX is done processing turn ready True and turn active False to exhaust the generator.\n", - " ready = True\n", - " self.communicator['active'] = False\n", - "\n", - "\n", - " def collector(self, batchsize: int) -> Generator[Dict, None, None]:\n", - " \"\"\"\n", - " Implementation of collector for the OPX. Collects new data-points from the OPX and yields them in a dictionary\n", - " with the names of the recorded variables as keywords and numpy arrays with the values. Raises ValueError if a\n", - " stream name inside the QUA program has a different name than a recorded variable and if the amount of recorded\n", - " variables and streams are different.\n", - "\n", - " :param batchsize: Size of batch. How many data-points is the minimum for the sweep to get in an iteration.\n", - " e.g. if 5, _control_progress will keep running until at least 5 new data-points\n", - " are available for collection.\n", - " \"\"\"\n", - "\n", - " # Get the result_handles from the communicator.\n", - " result_handle = self.communicator['result_handles']\n", - "\n", - " # Get the names of all variables from the specs.\n", - " data_specs_names = []\n", - " raw_values_count = len(self.communicator['raw_variables'])\n", - "\n", - " data_specs_names = [x.name for x in self.specs]\n", - " variable_counter = 0\n", - " for name, handle in result_handle:\n", - "\n", - " # Check that the stream names are present in the DataSpecs.\n", - " if name not in data_specs_names:\n", - " raise ValueError(f'{name} is not a recorded variable')\n", - " else:\n", - " variable_counter += 1\n", - " \n", - "\n", - " # Check that the number of recorded variables and streams are the same.\n", - " if variable_counter != len(data_specs_names) - raw_values_count:\n", - " raise ValueError(f'Number of recorded variables ({variable_counter}) \\\n", - " does not match number of variables gathered from the OPX ({len(data_specs_names)})')\n", - " \n", - "\n", - " while self.communicator['active']:\n", - " # Restart values for each iteration.\n", - " data = {}\n", - " counter = self.communicator['counter'] # Previous iteration data-point number.\n", - " first = True\n", - " current = 0\n", - " \n", - " # Make sure that the result_handle is active.\n", - " if result_handle is None:\n", - " yield None\n", - "\n", - " # Waits until new data-points are ready to be gathered.\n", - " self._wait_for_data(batchsize)\n", - "\n", - " for name, handle in result_handle:\n", - "\n", - " # To ensure that we get the same number of data-points from every variable only get the current count\n", - " # for the first variable in the stream.\n", - " if first:\n", - " current = handle.count_so_far() # Current data-point number\n", - " first = False\n", - "\n", - " # if the current data-point number is the same as the previous data-point number, no new data\n", - " # has been gathered.\n", - " if current == counter:\n", - " yield None\n", - " break\n", - " \n", - " # Make sure that the OPX has actually measured the current value for all variables and fetch the\n", - " # new data lines.\n", - " handle.wait_for_values(current)\n", - " data_temp = np.array(handle.fetch(slice(counter, current)))\n", - "\n", - " # If the trace is a raw measurement, we need to go through its shape to properly convert it\n", - " if name in self.communicator['raw_variables']:\n", - " holding_converting = []\n", - " for i in data_temp:\n", - " i_holder = []\n", - " for j in i:\n", - " converted = j.astype(float)\n", - " i_holder.append(converted)\n", - " holding_converting.append(i_holder) \n", - " if len(holding_converting) == 1:\n", - " converted_data_temp = [np.squeeze(holding_converting)]\n", - " else:\n", - " converted_data_temp = np.squeeze(holding_converting)\n", - " \n", - " raw_count = []\n", - " for rep in range(len(data['repetition'])):\n", - " raw_count.append(np.arange(len(converted_data_temp[0])))\n", - " data[f'{name}_time'] = raw_count\n", - "\n", - " \n", - " else:\n", - " # data comes from the OPX as numpy.void. Converts array to contain floats instead.\n", - " converted_data_temp = data_temp.astype(float)\n", - " \n", - " \n", - " data[name] = converted_data_temp\n", - " self.communicator['counter'] = current\n", - " yield data" - ] - }, - { - "cell_type": "markdown", - "id": "318494f6-1514-496a-9bc6-3a3b561fdca7", - "metadata": {}, - "source": [ - "# Proposal for Base Running and Saving" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "0957ae77-3012-4d56-bc6a-5170b68fb764", - "metadata": {}, - "outputs": [], - "source": [ - "def _create_datadict_structure(sweep: Sweep) -> dd.DataDict:\n", - " \"\"\"\n", - " Returns a structured DataDict from the DataSpecs of a Sweep.\n", - "\n", - " :param sweep: Sweep object from which the DataDict is created.\n", - " \"\"\"\n", - "\n", - " data_specs = sweep.get_data_specs()\n", - " data_dict = dd.DataDict()\n", - " for spec in data_specs:\n", - "\n", - " depends_on = spec.depends_on\n", - " unit = spec.unit\n", - " name = spec.name\n", - "\n", - " # Checks which fields have information and which ones are None.\n", - " if depends_on is None:\n", - " if unit is None:\n", - " data_dict[name] = dict()\n", - " else:\n", - " data_dict[name] = dict(unit=unit)\n", - " else:\n", - " if unit is None:\n", - " data_dict[name] = dict(axes=depends_on)\n", - " else:\n", - " data_dict[name] = dict(axes=depends_on, unit=unit)\n", - "\n", - " data_dict.validate()\n", - "\n", - " return data_dict\n", - "\n", - "\n", - "def _check_none(line: Dict) -> bool:\n", - " \"\"\"\n", - " Checks if the values in a Dict are all None. Returns True if all values are None, False otherwise.\n", - " \"\"\"\n", - " for arg in line.keys():\n", - " if line[arg] is not None:\n", - " return False\n", - " return True\n", - "\n", - "\n", - "def run_and_save_sweep(sweep: Sweep, data_dir: str, name: str, prt: bool = False) -> None:\n", - " \"\"\"\n", - " Iterates through a sweep, saving the data coming through it into a file called at directory.\n", - "\n", - " :param sweep: Sweep object to iterate through.\n", - " :param data_dir: Directory of file location\n", - " :param name: name of the file\n", - " :param prt: Bool, if True, the function will print every result coming from the sweep. Default, False.\n", - " \"\"\"\n", - " data_dict = _create_datadict_structure(sweep)\n", - " \n", - " # Creates a file even when it fails.\n", - " with dds.DDH5Writer(data_dir, data_dict, name=name) as writer:\n", - " for line in sweep:\n", - " if not _check_none(line):\n", - " if prt:\n", - " print(line)\n", - "\n", - " writer.add_data(**line)\n", - "\n", - " print('The measurement has finished successfully and all of the data has been saved.')" - ] - }, - { - "cell_type": "markdown", - "id": "15453070-6d9b-422a-abe1-b7769abc4d29", - "metadata": {}, - "source": [ - "# QUA experiment with implemented decorator" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "1f24ded1-bd2a-4891-aa7e-85d76d25efc8", - "metadata": {}, - "outputs": [], - "source": [ - "@RecordOPX(\n", - " dependent('tracker', depends_on=['repetition'], type='array'),\n", - " independent('repetition', type='array'),\n", - " raw_OPX_data('data_raw', depends_on=['repetition'], type_var='array'),\n", - " dependent('V', depends_on=['repetition'], type='array'))\n", - "def my_qua_experiment(n_reps=1000):\n", - " with program() as qua_measurement:\n", - " raw_stream = declare_stream(adc_trace=True)\n", - " v_stream = declare_stream()\n", - " tracker_stream = declare_stream()\n", - " i_stream = declare_stream()\n", - "\n", - " i = declare(int)\n", - " v = declare(fixed)\n", - " tracker = declare(int, value=0)\n", - "\n", - " with for_(i, 0, i