{ "cells": [ { "cell_type": "markdown", "id": "0", "metadata": {}, "source": [ "# Simulation & optimal control of a single spin qubit\n", "\n", "In this tutorial, we'll show you, step-by-step, how to simulate the dynamics of a single spin qubit and perform quantum optimal control using `qruise-ml`. \n", "\n", "The tutorial consists of the following:\n", "\n", "1. [Defining the Hamiltonian](#1-defining-the-hamiltonian)\n", " \n", " 1.1. [Physical model](#11-physical-model)\n", "\n", " 1.2. [Time-dependent drive function](#12-time-dependent-drive-function)\n", "\n", " 1.3. [Drive parameters and channels](#13-drive-parameters-and-channels)\n", "\n", " 1.4. [Constructing the Hamiltonian](#14-constructing-the-hamiltonian)\n", "\n", "2. [Defining the quantum simulation problem](#2-defining-the-quantum-simulation-problem)\n", "3. [Starting a session and solving the problem](#3-starting-a-session-and-solving-the-problem)\n", "4. [Plotting the qubit dynamics](#4-plotting-the-qubit-dynamics)\n", "5. [Performing quantum optimal control](#5-performing-quantum-optimal-control)\n", "\n", "\n", "## 1. Defining the Hamiltonian\n", "\n", "### 1.1. Physical model \n", "\n", "The system we are interested in is a single electron in a single quantum dot. With spin qubits, spin-up corresponds to the ground state, i.e. $|0\\rangle = |\\uparrow \\rangle$, and spin-down corresponds to the excited state, i.e., $|1 \\rangle = |\\downarrow \\rangle$.\n", "\n", "Our stationary (time-independent) Hamiltonian, $H_0$ (also known as the drift term), corresponds to the Zeeman interaction between the electron spin and an external static magnetic field:\n", "\n", "$$\n", "H_0 =\\frac{\\gamma}{2} \\vec{B} \\cdot \\vec{\\sigma} .\n", "$$\n", "\n", "Here, $\\vec{B}$ is the external magnetic field vector, and $\\vec{\\sigma} = (\\sigma_x,\\sigma_y,\\sigma_z)$ is the vector of Pauli matrices. The gyromagnetic ratio, $\\gamma$, quantifies the response of an electron to a magnetic field and can be expressed by $\\gamma = \\frac{-g\\mu_B}{\\hbar}$, where $g$ is the $g$-factor ($\\sim 2$ for a free electron), $\\mu_B$ is the Bohr magneton quantifying the magnetic moment of an electron, and $\\hbar$ is the reduced Planck's constant. \n", "\n", "Let's assume we only want to apply our external magnetic field in the $z$-direction, i.e., $B_x=B_y=0$. Our Hamiltonian then simplifies to\n", "\n", "$$\n", "H_0 = \\frac{\\gamma}{2} B_z \\sigma_z.\n", "$$\n", "\n", "Substituting in the eigenvalues of $\\sigma_z$ (±1), we see that the two spin states have an energy (Zeeman) splitting, $\\Delta E$, given by\n", "\n", "$$\n", "\\Delta E = \\frac{\\gamma}{2} B_z (1) - \\frac{\\gamma}{2} B_z (-1) = \\gamma B_z .\n", "$$\n", "\n", "The corresponding qubit transition frequency is\n", "\n", "$$\n", "\\omega_q=\\gamma B_z\n", "$$\n", "\n", "which is also known as the Larmor frequency. This is the frequency at which the spin precesses about the magnetic field. In the simulations that follow, we use $\\gamma = 2.8 \\times 10^{10}~\\mathrm{Hz~T^{-1}}$ and an external magnetic field of $B_z = 0.1~\\mathrm{T}$.\n", "\n", "To manipulate the qubit, we apply a time-dependent drive $c(t)$ that couples to the spin through the $\\sigma_x$ operator. The full Hamiltonian is therefore\n", "\n", "$$\n", "H(t) = \\frac{\\gamma}{2} B_z \\sigma_z + c(t)\\sigma_x.\n", "$$\n", "\n", "The first term determines the natural evolution of the qubit, while the second term drives transitions between the $|0\\rangle$ and $|1\\rangle$ states." ] }, { "cell_type": "markdown", "id": "1", "metadata": {}, "source": [ "### 1.2. Time-dependent drive function\n", "\n", "For the drive, we’ll use a Gaussian pulse modulated by a cosine:\n", "\n", "$$\n", "c(t; \\{a,\\sigma,\\mu,\\omega_d\\}) = \\frac{a}{\\sigma\\sqrt{2\\pi}} \\mathrm{exp}\\left[-\\frac{(t - \\mu)^2}{2\\sigma^2}\\right] \\cos(\\omega_{d}t).\n", "$$\n", "\n", "This is characterised by four parameters:\n", "\n", "(i) $a$, a scalar that adjusts the amplitude of the pulse\n", "\n", "(ii) $\\sigma$, which controls the pulse width\n", "\n", "(iii) $\\mu$, the time at which the pulse reaches its maximum amplitude\n", "\n", "(iv) $\\omega_{d}$, the local oscillator frequency, which is often chosen to match $\\omega_q$.\n", "\n", "In QruiseML, drive functions are defined as annotated Python functions. This means that each input parameter, as well as the function output, must have a type annotation. These annotations must use the types defined in the [`types`](../src/qruise/toolset/types.py) module in QruiseML. Here, we'll set $\\mu=\\frac{t_1}{2}$ and use type `Float64` for all the inputs and the output. " ] }, { "cell_type": "code", "execution_count": 1, "id": "2", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:11:25.379863Z", "iopub.status.busy": "2026-08-20T10:11:25.379036Z", "iopub.status.idle": "2026-08-20T10:11:30.557173Z", "shell.execute_reply": "2026-08-20T10:11:30.556186Z" } }, "outputs": [], "source": [ "import numpy as np\n", "from qruise.toolset.types import Float64\n", "\n", "\n", "def drive(t: Float64, amp: Float64, sigma: Float64, omega_d: Float64) -> Float64:\n", " \"\"\"Envelope: Gaussian pulse modulated by a cosine\"\"\"\n", "\n", " factor = amp / np.sqrt(2 * np.pi) / sigma\n", " gaussian = factor * np.exp(-((t - t1 / 2) ** 2) / (2 * sigma**2))\n", " # Note: mu is set to t1/2\n", " return gaussian * np.cos(omega_d * t)" ] }, { "cell_type": "markdown", "id": "3", "metadata": {}, "source": [ "Now we need to define the time, qubit, and initial drive parameters for the simulation." ] }, { "cell_type": "code", "execution_count": 2, "id": "4", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:11:30.559576Z", "iopub.status.busy": "2026-08-20T10:11:30.559260Z", "iopub.status.idle": "2026-08-20T10:11:30.563275Z", "shell.execute_reply": "2026-08-20T10:11:30.562520Z" } }, "outputs": [], "source": [ "# time parameters\n", "t0 = 0.0 # initial time (s)\n", "t1 = 20e-9 # final time (s)\n", "N = 1000 # number of time points\n", "ts = np.linspace(t0, t1, N) # time array\n", "\n", "# spin qubit parameters\n", "gamma = -2.8024951386169e10 # gyromagnetic ratio of an electron (Hz/T)\n", "Bz = 0.1 # magnetic field strength (T)\n", "omega_q = gamma * Bz # Larmor (qubit) frequency (Hz)\n", "\n", "# drive parameters\n", "amp = 2.0 # amplitude\n", "sigma = 0.2 * t1 # width\n", "omega_d = omega_q # frequency (Hz)" ] }, { "cell_type": "markdown", "id": "5", "metadata": {}, "source": [ "It’s a good idea to check your drive behaves as desired before proceeding, so let’s quickly plot it." ] }, { "cell_type": "code", "execution_count": 3, "id": "6", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:11:30.565248Z", "iopub.status.busy": "2026-08-20T10:11:30.565073Z", "iopub.status.idle": "2026-08-20T10:11:36.924893Z", "shell.execute_reply": "2026-08-20T10:11:36.924117Z" } }, "outputs": [ { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/javascript": [ "(function(root) {\n", " function now() {\n", " return new Date();\n", " }\n", "\n", " const force = true;\n", " const version = '3.9.0'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", " const reloading = false;\n", " const Bokeh = root.Bokeh;\n", " const BK_RE = /^https:\\/\\/cdn\\.bokeh\\.org\\/bokeh\\/(release|dev)\\/bokeh-/;\n", " const PN_RE = /^https:\\/\\/cdn\\.holoviz\\.org\\/panel\\/[^/]+\\/dist\\/panel/i;\n", "\n", " // Set a timeout for this load but only if we are not already initializing\n", " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", " root._bokeh_timeout = Date.now() + 5000;\n", " root._bokeh_failed_load = false;\n", " }\n", "\n", " function run_callbacks() {\n", " try {\n", " root._bokeh_onload_callbacks.forEach(function(callback) {\n", " if (callback != null)\n", " callback();\n", " });\n", " } finally {\n", " delete root._bokeh_onload_callbacks;\n", " }\n", " console.debug(\"Bokeh: all callbacks have finished\");\n", " }\n", "\n", " function load_libs(css_urls, js_urls, js_modules, js_exports, Bokeh, callback) {\n", " if (css_urls == null) css_urls = [];\n", " if (js_urls == null) js_urls = [];\n", " if (js_modules == null) js_modules = [];\n", " if (js_exports == null) js_exports = {};\n", "\n", " root._bokeh_onload_callbacks.push(callback);\n", "\n", " if (root._bokeh_is_loading > 0) {\n", " // Don't load bokeh if it is still initializing\n", " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", " return null;\n", " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", " // There is nothing to load\n", " run_callbacks();\n", " return null;\n", " }\n", "\n", " function on_load() {\n", " root._bokeh_is_loading--;\n", " if (root._bokeh_is_loading === 0) {\n", " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", " run_callbacks()\n", " }\n", " }\n", " window._bokeh_on_load = on_load\n", "\n", " function on_error(e) {\n", " const src_el = e.srcElement\n", " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", " }\n", "\n", " const skip = [];\n", " if (window.requirejs) {\n", " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", " root._bokeh_is_loading = css_urls.length + 0;\n", " } else {\n", " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", " }\n", "\n", " const existing_stylesheets = []\n", " const links = document.getElementsByTagName('link')\n", " for (let i = 0; i < links.length; i++) {\n", " const link = links[i]\n", " if (link.href != null) {\n", " existing_stylesheets.push(link.href)\n", " }\n", " }\n", " for (let i = 0; i < css_urls.length; i++) {\n", " const url = css_urls[i];\n", " const escaped = encodeURI(url)\n", " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", " on_load()\n", " continue;\n", " }\n", " const element = document.createElement(\"link\");\n", " element.onload = on_load;\n", " element.onerror = on_error;\n", " element.rel = \"stylesheet\";\n", " element.type = \"text/css\";\n", " element.href = url;\n", " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", " document.body.appendChild(element);\n", " } var existing_scripts = []\n", " const scripts = document.getElementsByTagName('script')\n", " for (let i = 0; i < scripts.length; i++) {\n", " var script = scripts[i]\n", " if (script.src != null) {\n", " existing_scripts.push(script.src)\n", " }\n", " }\n", " for (let i = 0; i < js_urls.length; i++) {\n", " const url = js_urls[i];\n", " const escaped = encodeURI(url)\n", " const shouldSkip = skip.includes(escaped) || existing_scripts.includes(escaped)\n", " const isBokehOrPanel = BK_RE.test(escaped) || PN_RE.test(escaped)\n", " const missingOrBroken = Bokeh == null || Bokeh.Panel == null || (Bokeh.version != version && !Bokeh.versions?.has(version)) || Bokeh.versions?.get(version)?.Panel == null;\n", " if (shouldSkip && !(isBokehOrPanel && missingOrBroken)) {\n", " if (!window.requirejs) {\n", " on_load();\n", " }\n", " continue;\n", " }\n", " const element = document.createElement('script');\n", " element.onload = on_load;\n", " element.onerror = on_error;\n", " element.async = false;\n", " element.src = url;\n", " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", " document.head.appendChild(element);\n", " }\n", " for (let i = 0; i < js_modules.length; i++) {\n", " const url = js_modules[i];\n", " const escaped = encodeURI(url)\n", " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", " if (!window.requirejs) {\n", " on_load();\n", " }\n", " continue;\n", " }\n", " var element = document.createElement('script');\n", " element.onload = on_load;\n", " element.onerror = on_error;\n", " element.async = false;\n", " element.src = url;\n", " element.type = \"module\";\n", " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", " document.head.appendChild(element);\n", " }\n", " for (const name in js_exports) {\n", " const url = js_exports[name];\n", " const escaped = encodeURI(url)\n", " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", " if (!window.requirejs) {\n", " on_load();\n", " }\n", " continue;\n", " }\n", " var element = document.createElement('script');\n", " element.onerror = on_error;\n", " element.async = false;\n", " element.type = \"module\";\n", " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", " element.textContent = `\n", " import ${name} from \"${url}\"\n", " window.${name} = ${name}\n", " window._bokeh_on_load()\n", " `\n", " document.head.appendChild(element);\n", " }\n", " if (!js_urls.length && !js_modules.length) {\n", " on_load()\n", " }\n", " };\n", "\n", " function inject_raw_css(css) {\n", " const element = document.createElement(\"style\");\n", " element.appendChild(document.createTextNode(css));\n", " document.body.appendChild(element);\n", " }\n", "\n", " const js_urls = [\"https://cdn.holoviz.org/panel/1.8.10/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.9.0.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.9.0.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.9.0.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.9.0.min.js\", \"https://cdn.holoviz.org/panel/1.8.10/dist/panel.min.js\"];\n", " const js_modules = [];\n", " const js_exports = {};\n", " const css_urls = [];\n", " const inline_js = [ function(Bokeh) {\n", " Bokeh.set_log_level(\"info\");\n", " },\n", "function(Bokeh) {} // ensure no trailing comma for IE\n", " ];\n", "\n", " function run_inline_js() {\n", " if ((root.Bokeh !== undefined) || (force === true)) {\n", " for (let i = 0; i < inline_js.length; i++) {\n", " try {\n", " inline_js[i].call(root, root.Bokeh);\n", " } catch(e) {\n", " if (!reloading) {\n", " throw e;\n", " }\n", " }\n", " }\n", " } else if (Date.now() < root._bokeh_timeout) {\n", " setTimeout(run_inline_js, 100);\n", " } else if (!root._bokeh_failed_load) {\n", " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", " root._bokeh_failed_load = true;\n", " }\n", " root._bokeh_is_initializing = false;\n", " }\n", "\n", " function load_or_wait() {\n", " // Implement a backoff loop that tries to ensure we do not load multiple\n", " // versions of Bokeh and its dependencies at the same time.\n", " // In recent versions we use the root._bokeh_is_initializing flag\n", " // to determine whether there is an ongoing attempt to initialize\n", " // bokeh, however for backward compatibility we also try to ensure\n", " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", " // before older versions are fully initialized.\n", " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", " // If the timeout and bokeh was not successfully loaded we reset\n", " // everything and try loading again\n", " root._bokeh_timeout = Date.now() + 5000;\n", " root._bokeh_is_initializing = false;\n", " root._bokeh_onload_callbacks = undefined;\n", " root._bokeh_is_loading = 0;\n", " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", " load_or_wait();\n", " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", " setTimeout(load_or_wait, 100);\n", " } else {\n", " root._bokeh_is_initializing = true;\n", " root._bokeh_onload_callbacks = [];\n", " const bokeh_loaded = Bokeh != null && ((Bokeh.version === version && Bokeh.Panel) || (Bokeh.versions?.has(version) && Bokeh.versions.get(version)?.Panel));\n", " if (!reloading && !bokeh_loaded) {\n", " if (root.Bokeh) {\n", " root.Bokeh = undefined;\n", " }\n", " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", " }\n", " load_libs(css_urls, js_urls, js_modules, js_exports, Bokeh, function() {\n", " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", " run_inline_js();\n", " if (Bokeh != undefined && !reloading) {\n", " const NewBokeh = root.Bokeh;\n", " if (Bokeh.versions === undefined) {\n", " Bokeh.versions = new Map();\n", " }\n", " if (NewBokeh.version !== Bokeh.version) {\n", " Bokeh[NewBokeh.version] = NewBokeh;\n", " Bokeh.versions.set(NewBokeh.version, NewBokeh);\n", " }\n", " root.Bokeh = Bokeh;\n", " }\n", " });\n", " }\n", " }\n", " // Give older versions of the autoload script a head-start to ensure\n", " // they initialize before we start loading newer version.\n", " setTimeout(load_or_wait, 100)\n", "}(window));" ], "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const version = '3.9.0'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n const BK_RE = /^https:\\/\\/cdn\\.bokeh\\.org\\/bokeh\\/(release|dev)\\/bokeh-/;\n const PN_RE = /^https:\\/\\/cdn\\.holoviz\\.org\\/panel\\/[^/]+\\/dist\\/panel/i;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, Bokeh, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n const shouldSkip = skip.includes(escaped) || existing_scripts.includes(escaped)\n const isBokehOrPanel = BK_RE.test(escaped) || PN_RE.test(escaped)\n const missingOrBroken = Bokeh == null || Bokeh.Panel == null || (Bokeh.version != version && !Bokeh.versions?.has(version)) || Bokeh.versions?.get(version)?.Panel == null;\n if (shouldSkip && !(isBokehOrPanel && missingOrBroken)) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.8.10/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.9.0.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.9.0.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.9.0.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.9.0.min.js\", \"https://cdn.holoviz.org/panel/1.8.10/dist/panel.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false;\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true;\n root._bokeh_onload_callbacks = [];\n const bokeh_loaded = Bokeh != null && ((Bokeh.version === version && Bokeh.Panel) || (Bokeh.versions?.has(version) && Bokeh.versions.get(version)?.Panel));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, Bokeh, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n if (Bokeh != undefined && !reloading) {\n const NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh[NewBokeh.version] = NewBokeh;\n Bokeh.versions.set(NewBokeh.version, NewBokeh);\n }\n root.Bokeh = Bokeh;\n }\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/javascript": [ "\n", "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", "}\n", "\n", "\n", " function JupyterCommManager() {\n", " }\n", "\n", " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", " comm_manager.register_target(comm_id, function(comm) {\n", " comm.on_msg(msg_handler);\n", " });\n", " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", " comm.onMsg = msg_handler;\n", " });\n", " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", " var messages = comm.messages[Symbol.asyncIterator]();\n", " function processIteratorResult(result) {\n", " var message = result.value;\n", " var content = {data: message.data, comm_id};\n", " var buffers = []\n", " for (var buffer of message.buffers || []) {\n", " buffers.push(new DataView(buffer))\n", " }\n", " var metadata = message.metadata || {};\n", " var msg = {content, buffers, metadata}\n", " msg_handler(msg);\n", " return messages.next().then(processIteratorResult);\n", " }\n", " return messages.next().then(processIteratorResult);\n", " })\n", " }\n", " }\n", "\n", " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", " if (comm_id in window.PyViz.comms) {\n", " return window.PyViz.comms[comm_id];\n", " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", " if (msg_handler) {\n", " comm.on_msg(msg_handler);\n", " }\n", " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", " let retries = 0;\n", " const open = () => {\n", " if (comm.active) {\n", " comm.open();\n", " } else if (retries > 3) {\n", " console.warn('Comm target never activated')\n", " } else {\n", " retries += 1\n", " setTimeout(open, 500)\n", " }\n", " }\n", " if (comm.active) {\n", " comm.open();\n", " } else {\n", " setTimeout(open, 500)\n", " }\n", " if (msg_handler) {\n", " comm.onMsg = msg_handler;\n", " }\n", " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", " comm_promise.then((comm) => {\n", " window.PyViz.comms[comm_id] = comm;\n", " if (msg_handler) {\n", " var messages = comm.messages[Symbol.asyncIterator]();\n", " function processIteratorResult(result) {\n", " var message = result.value;\n", " var content = {data: message.data};\n", " var metadata = message.metadata || {comm_id};\n", " var msg = {content, metadata}\n", " msg_handler(msg);\n", " return messages.next().then(processIteratorResult);\n", " }\n", " return messages.next().then(processIteratorResult);\n", " }\n", " })\n", " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", " return comm_promise.then((comm) => {\n", " comm.send(data, metadata, buffers, disposeOnDone);\n", " });\n", " };\n", " var comm = {\n", " send: sendClosure\n", " };\n", " }\n", " window.PyViz.comms[comm_id] = comm;\n", " return comm;\n", " }\n", " window.PyViz.comm_manager = new JupyterCommManager();\n", " \n", "\n", "\n", "var JS_MIME_TYPE = 'application/javascript';\n", "var HTML_MIME_TYPE = 'text/html';\n", "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", "var CLASS_NAME = 'output';\n", "\n", "/**\n", " * Render data to the DOM node\n", " */\n", "function render(props, node) {\n", " var div = document.createElement(\"div\");\n", " var script = document.createElement(\"script\");\n", " node.appendChild(div);\n", " node.appendChild(script);\n", "}\n", "\n", "/**\n", " * Handle when a new output is added\n", " */\n", "function handle_add_output(event, handle) {\n", " var output_area = handle.output_area;\n", " var output = handle.output;\n", " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", " return\n", " }\n", " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", " if (id !== undefined) {\n", " var nchildren = toinsert.length;\n", " var html_node = toinsert[nchildren-1].children[0];\n", " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", " var scripts = [];\n", " var nodelist = html_node.querySelectorAll(\"script\");\n", " for (var i in nodelist) {\n", " if (nodelist.hasOwnProperty(i)) {\n", " scripts.push(nodelist[i])\n", " }\n", " }\n", "\n", " scripts.forEach( function (oldScript) {\n", " var newScript = document.createElement(\"script\");\n", " var attrs = [];\n", " var nodemap = oldScript.attributes;\n", " for (var j in nodemap) {\n", " if (nodemap.hasOwnProperty(j)) {\n", " attrs.push(nodemap[j])\n", " }\n", " }\n", " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", " oldScript.parentNode.replaceChild(newScript, oldScript);\n", " });\n", " if (JS_MIME_TYPE in output.data) {\n", " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", " }\n", " output_area._hv_plot_id = id;\n", " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", " window.PyViz.plot_index[id] = Bokeh.index[id];\n", " } else {\n", " window.PyViz.plot_index[id] = null;\n", " }\n", " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", " var bk_div = document.createElement(\"div\");\n", " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", " var script_attrs = bk_div.children[0].attributes;\n", " for (var i = 0; i < script_attrs.length; i++) {\n", " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", " }\n", " // store reference to server id on output_area\n", " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", " }\n", "}\n", "\n", "/**\n", " * Handle when an output is cleared or removed\n", " */\n", "function handle_clear_output(event, handle) {\n", " var id = handle.cell.output_area._hv_plot_id;\n", " var server_id = handle.cell.output_area._bokeh_server_id;\n", " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", " if (server_id !== null) {\n", " comm.send({event_type: 'server_delete', 'id': server_id});\n", " return;\n", " } else if (comm !== null) {\n", " comm.send({event_type: 'delete', 'id': id});\n", " }\n", " delete PyViz.plot_index[id];\n", " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", " var doc = window.Bokeh.index[id].model.document\n", " doc.clear();\n", " const i = window.Bokeh.documents.indexOf(doc);\n", " if (i > -1) {\n", " window.Bokeh.documents.splice(i, 1);\n", " }\n", " }\n", "}\n", "\n", "/**\n", " * Handle kernel restart event\n", " */\n", "function handle_kernel_cleanup(event, handle) {\n", " delete PyViz.comms[\"hv-extension-comm\"];\n", " window.PyViz.plot_index = {}\n", "}\n", "\n", "/**\n", " * Handle update_display_data messages\n", " */\n", "function handle_update_output(event, handle) {\n", " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", " handle_add_output(event, handle)\n", "}\n", "\n", "function register_renderer(events, OutputArea) {\n", " function append_mime(data, metadata, element) {\n", " // create a DOM node to render to\n", " var toinsert = this.create_output_subarea(\n", " metadata,\n", " CLASS_NAME,\n", " EXEC_MIME_TYPE\n", " );\n", " this.keyboard_manager.register_events(toinsert);\n", " // Render to node\n", " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", " render(props, toinsert[0]);\n", " element.append(toinsert);\n", " return toinsert\n", " }\n", "\n", " events.on('output_added.OutputArea', handle_add_output);\n", " events.on('output_updated.OutputArea', handle_update_output);\n", " events.on('clear_output.CodeCell', handle_clear_output);\n", " events.on('delete.Cell', handle_clear_output);\n", " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", "\n", " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", " safe: true,\n", " index: 0\n", " });\n", "}\n", "\n", "if (window.Jupyter !== undefined) {\n", " try {\n", " var events = require('base/js/events');\n", " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", " register_renderer(events, OutputArea);\n", " }\n", " } catch(err) {\n", " }\n", "}\n" ], "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n let retries = 0;\n const open = () => {\n if (comm.active) {\n comm.open();\n } else if (retries > 3) {\n console.warn('Comm target never activated')\n } else {\n retries += 1\n setTimeout(open, 500)\n }\n }\n if (comm.active) {\n comm.open();\n } else {\n setTimeout(open, 500)\n }\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n })\n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ "
\n", "
\n", "
\n", "" ] }, "metadata": { "application/vnd.holoviews_exec.v0+json": { "id": "c19155b8-950b-44dc-99bd-0f60942c8ba4" } }, "output_type": "display_data" }, { "data": {}, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ "
\n", "
\n", "
\n", "" ], "text/plain": [ ":Curve [time] (Amplitude (arb. u.))" ] }, "execution_count": 3, "metadata": { "application/vnd.holoviews_exec.v0+json": { "id": "3142d7fa-a8ff-4639-904d-dbc915dc3f29" } }, "output_type": "execute_result" } ], "source": [ "import xarray as xr\n", "import hvplot.xarray\n", "\n", "xr.DataArray(\n", " drive(ts, amp, sigma, omega_d),\n", " coords={\"time\": (\"time\", ts, {\"units\": \"s\"})},\n", " dims=[\"time\"],\n", " name=\"Amplitude (arb. u.)\",\n", ").hvplot()" ] }, { "cell_type": "markdown", "id": "7", "metadata": {}, "source": [ "As expected, we have a Gaussian pulse modulated by a cosine — great!\n", "\n", "### 1.3. Drive parameters and channels\n", "\n", "Next, we'll organise the drive parameters into a _drive channel_. A drive channel groups together the parameters associated with a particular drive, providing a convenient way to keep related parameters organised. When working with multiple drives, this makes it easy to identify which parameters belong to which drive.\n", "\n", "We use `Parameters` to construct a parameter space from the channel parameters. Each parameter is specified as a tuple of the form `(value, lower_bound, upper_bound)`. If you're only performing a simulation, the bounds can be omitted. However, they are required for optimal control, so we'll include them here." ] }, { "cell_type": "code", "execution_count": 4, "id": "8", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:11:36.927057Z", "iopub.status.busy": "2026-08-20T10:11:36.926858Z", "iopub.status.idle": "2026-08-20T10:11:36.944809Z", "shell.execute_reply": "2026-08-20T10:11:36.943956Z" } }, "outputs": [], "source": [ "from qruise.toolset import Parameters, Drive\n", "\n", "# associate drive parameters with channel and construct parameter space\n", "ps = Parameters(\n", " {\n", " \"d1\": {\n", " # \"parameter name\": (value, lower_bound, upper_bound)\n", " \"amp\": (amp, 1.0, 5.0),\n", " \"sigma\": (sigma, 1e-9, 8e-9),\n", " \"omega_d\": (omega_d, omega_q - 5e8, omega_q + 5e8),\n", " }\n", " }\n", ")" ] }, { "cell_type": "markdown", "id": "9", "metadata": {}, "source": [ "---\n", "\n", "**Note:** When working with multiple drives, drive channels allow different drives to reuse parameter names — such as `amp`, `sigma`, and `omega_d` — without conflicts. In this example, we only have a single drive, but it's good practice to create a drive channel from the outset so it's straightforward to add additional drives later.\n", "\n", "---\n", "\n", "Finally, we use the `Drive` class to associate the drive function with the drive channel, which itself is associated to the relevant parameters:" ] }, { "cell_type": "code", "execution_count": 5, "id": "10", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:11:36.946697Z", "iopub.status.busy": "2026-08-20T10:11:36.946507Z", "iopub.status.idle": "2026-08-20T10:11:37.623356Z", "shell.execute_reply": "2026-08-20T10:11:37.622443Z" } }, "outputs": [], "source": [ "drv1 = Drive(\"d1\", drive)" ] }, { "cell_type": "markdown", "id": "11", "metadata": {}, "source": [ "### 1.4. Constructing the Hamiltonian\n", "\n", "The Hamiltonian is constructed in a similar way to `QuTiP`. We instantiate the `Hamiltonian` class by passing the stationary part, `H0`, together with a list of `(drive, operator)` pairs defining the time-dependent terms:" ] }, { "cell_type": "code", "execution_count": 6, "id": "12", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:11:37.625705Z", "iopub.status.busy": "2026-08-20T10:11:37.625506Z", "iopub.status.idle": "2026-08-20T10:11:37.631289Z", "shell.execute_reply": "2026-08-20T10:11:37.630443Z" } }, "outputs": [], "source": [ "import qutip as qt\n", "from qruise.toolset import Hamiltonian\n", "\n", "# Pauli operators from QuTiP\n", "sx = qt.sigmax()\n", "sz = qt.sigmaz()\n", "\n", "# define Hamiltonian\n", "H = Hamiltonian(omega_q * sz / 2, [(drv1, sx)])" ] }, { "cell_type": "markdown", "id": "13", "metadata": {}, "source": [ "## 2. Defining the quantum simulation problem\n", "\n", "Now that we've defined our Hamiltonian, we can start setting up a quantum simulation problem. In QruiseML, we use the `Problem` class to group together the equations and parameters that govern the system. To instantiate the `Problem`, we need:\n", "\n", "- the equation that governs the dynamics (in this example, we'll use the `\"Schroedinger\"` equation)\n", "- the Hamiltonian (`H`)\n", "- the initial qubit state (`u0`, here the ground state $|0\\rangle$)\n", "- the time interval of the simulation (`t0` to `tfinal`)\n", "- the pulse parameters (`ps`)" ] }, { "cell_type": "code", "execution_count": 7, "id": "14", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:11:37.633237Z", "iopub.status.busy": "2026-08-20T10:11:37.633064Z", "iopub.status.idle": "2026-08-20T10:11:37.640186Z", "shell.execute_reply": "2026-08-20T10:11:37.639375Z" } }, "outputs": [], "source": [ "from qruise.toolset import Problem\n", "\n", "u0 = qt.basis(2, 0) # initial vector state, |0>\n", "\n", "prob = Problem(\"Schroedinger\", H, u0, (t0, t1), ps)" ] }, { "cell_type": "markdown", "id": "15", "metadata": {}, "source": [ "## 3. Starting a session and solving the problem\n", "\n", "The `Problem` object defines the quantum system we want to simulate,\n", "but it does not run the simulation itself. To execute the time evolution, we need to create a `Session`, then use `qsprob_init` to initialise the `Problem` within the session. The session prepares the problem for numerical simulation and manages the solver execution." ] }, { "cell_type": "code", "execution_count": 8, "id": "16", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:11:37.641826Z", "iopub.status.busy": "2026-08-20T10:11:37.641636Z", "iopub.status.idle": "2026-08-20T10:11:49.975411Z", "shell.execute_reply": "2026-08-20T10:11:49.974436Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[juliapkg] Found dependencies: /home/ci/.venv/lib/python3.11/site-packages/juliacall/juliapkg.json\n", "[juliapkg] Found dependencies: /home/ci/.venv/lib/python3.11/site-packages/juliapkg/juliapkg.json\n", "[juliapkg] Locating Julia ~1.9, ^1.10.3\n", "[juliapkg] Using Julia 1.11.6 at /home/ci/.juliaup/bin/julia\n", "[juliapkg] Using Julia project at /__w/qruise-ml/qruise-ml/julia/python_env\n" ] } ], "source": [ "from qruise.toolset.session import Session\n", "\n", "sess = Session()\n", "sess.qsprob_init(prob)" ] }, { "cell_type": "markdown", "id": "17", "metadata": {}, "source": [ "To compute the system time evolution, we use the `Session.evolve` method to solve the quantum simulation problem numerically. \n", "\n", "In the implementation below, `\"Tsit5\"` specifies the ODE algorithm, `reltol`\n", "and `abstol` the numerical tolerances, and `saveat` the times at which the result is stored. Other solver options can also be passed as keyword arguments." ] }, { "cell_type": "code", "execution_count": 9, "id": "18", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:11:49.977775Z", "iopub.status.busy": "2026-08-20T10:11:49.977542Z", "iopub.status.idle": "2026-08-20T10:11:56.825945Z", "shell.execute_reply": "2026-08-20T10:11:56.824616Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "\r", "\u001b[KODE [ ] 0%\r", "\u001b[KODE [########################################] 100%\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 40kB\n",
       "Dimensions:  (time: 1000, row: 2)\n",
       "Coordinates:\n",
       "  * time     (time) float64 8kB 0.0 2.002e-11 4.004e-11 ... 1.998e-08 2e-08\n",
       "Dimensions without coordinates: row\n",
       "Data variables:\n",
       "    qstates  (time, row) complex128 32kB (1+0j) ... (-0.20567110345887604+0.8...
" ], "text/plain": [ " Size: 40kB\n", "Dimensions: (time: 1000, row: 2)\n", "Coordinates:\n", " * time (time) float64 8kB 0.0 2.002e-11 4.004e-11 ... 1.998e-08 2e-08\n", "Dimensions without coordinates: row\n", "Data variables:\n", " qstates (time, row) complex128 32kB (1+0j) ... (-0.20567110345887604+0.8..." ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ds = sess.evolve(\"Tsit5\", reltol=1e-3, abstol=1e-4, saveat=ts)\n", "ds" ] }, { "cell_type": "markdown", "id": "19", "metadata": {}, "source": [ "This returns an `xarray.Dataset` object containing coordinates corresponding to the time axis and quantum-state labels (here, $|0\\rangle$ and $|1\\rangle$), as well as the variable `qstates`, which stores either the state vector or density matrix of the system.\n", "\n", "## 4. Plotting the qubit dynamics\n", "\n", "Let's take a look at the effect of the drive on the qubit populations. Since `xarray.Dataset` supports additional derived variables, we can compute the state populations and store them alongside the original simulation results. We can also rename the `row` dimension to `state` and assign the basis-state labels $|0\\rangle$ and $|1\\rangle$ for clearer indexing and visualisation." ] }, { "cell_type": "code", "execution_count": 10, "id": "20", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:11:56.827678Z", "iopub.status.busy": "2026-08-20T10:11:56.827495Z", "iopub.status.idle": "2026-08-20T10:11:56.832968Z", "shell.execute_reply": "2026-08-20T10:11:56.832160Z" } }, "outputs": [], "source": [ "# calculate population of each state\n", "ds[\"population\"] = np.abs(ds[\"qstates\"]) ** 2\n", "\n", "ds = ds.rename({\"row\": \"state\"}) # rename the dimension \"row\" to \"states\"\n", "ds = ds.assign_coords(state=[r\"|0>\", r\"|1>\"]) # assign labels to the dimensions" ] }, { "cell_type": "markdown", "id": "21", "metadata": {}, "source": [ "`xarray` provides different backends to conveniently plot the result. For example, we can use `hvplot` to plot the population of each state:" ] }, { "cell_type": "code", "execution_count": 11, "id": "22", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:11:56.834545Z", "iopub.status.busy": "2026-08-20T10:11:56.834376Z", "iopub.status.idle": "2026-08-20T10:11:56.972075Z", "shell.execute_reply": "2026-08-20T10:11:56.971370Z" } }, "outputs": [ { "data": {}, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ "
\n", "
\n", "
\n", "" ], "text/plain": [ ":NdOverlay [state]\n", " :Curve [time] (population)" ] }, "execution_count": 11, "metadata": { "application/vnd.holoviews_exec.v0+json": { "id": "9f8d8c80-4af0-40ec-a42f-d787fd1b1d3d" } }, "output_type": "execute_result" } ], "source": [ "# plot populations\n", "ds.hvplot.line(\n", " x=\"time\",\n", " y=\"population\",\n", " by=\"state\",\n", " xlabel=\"time (s)\",\n", " ylabel=\"population (arb. u.)\",\n", ")" ] }, { "cell_type": "markdown", "id": "23", "metadata": {}, "source": [ "Congratulations! You’ve just simulated your first spin qubit.\n", "\n", "## 5. Performing quantum optimal control\n", "\n", "As we can see in the population plot above, the drive pulse does not fully invert the qubit population. If we want to implement an $X$ gate, we need to adjust the pulse parameters so that the qubit is driven from $|0\\rangle$ to $|1\\rangle$ by the end of the simulation. To achieve this, we can perform quantum optimal control. \n", "\n", "For this, we use `QOCProblem`, which is almost identical to `Problem`, but with two additional inputs:\n", "\n", "- the desired (target) qubit state (`ut`, here the excited state $|1\\rangle$), which must be compatible with the type and shape of `u0`\n", "- a loss function, $\\mathcal{L}$, that we want to minimise. Here, we'll use `\"svo\"`, which uses the state vector overlap to compute the infidelity: \n", "\n", "$$\n", "\\mathcal{L} = 1 - \\text{svo} = 1 - |\\braket{u_f(t=t_1)|u_t}|^2 ,\n", "$$\n", "\n", "where $u_f(t=t_1)$ is the simulated qubit state at the final time $t_1$, and $u_t$ is the desired target state. The objective is to optimise the parameters of the drive pulse by minimising $\\mathcal{L}$, bringing the final qubit state as close as possible to the target state.\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "24", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:11:56.973833Z", "iopub.status.busy": "2026-08-20T10:11:56.973634Z", "iopub.status.idle": "2026-08-20T10:11:56.978901Z", "shell.execute_reply": "2026-08-20T10:11:56.977959Z" } }, "outputs": [], "source": [ "from qruise.toolset import QOCProblem\n", "\n", "# define target state\n", "ut = qt.basis(2, 1)\n", "\n", "# define QOCProblem\n", "qocprob = QOCProblem(\n", " \"Schroedinger\", H, u0, (t0, t1), ps, ut, \"svo\"\n", ") # the Quantum Optimal Control problem" ] }, { "cell_type": "markdown", "id": "25", "metadata": {}, "source": [ "The whole workflow now reduces to solving the optimal control problem using our initial guess for the drive parameters. At each step, the system is simulated with the current parameters to obtain the final wavefunction and compute the infidelity with respect to the target state. Based on the resulting gradients, the parameters are updated iteratively until they converge and minimise the loss function.\n", "\n", "Similar to `Problem`, `QOCProblem` defines the optimal control problem we want to solve, but it does not perform the optimisation itself. We first create a `Session`, then use `qocprob_init` to initialise the `QOCProblem` within the session, before calling `Session.optimise` to perform the optimisation. Here, we'll use the `L-BFGS` (limited-memory Broyden–Fletcher–Goldfarb–Shanno) algorithm." ] }, { "cell_type": "code", "execution_count": 13, "id": "26", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:11:56.980546Z", "iopub.status.busy": "2026-08-20T10:11:56.980375Z", "iopub.status.idle": "2026-08-20T10:13:35.720673Z", "shell.execute_reply": "2026-08-20T10:13:35.719928Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "loss: 0.30420622234238104\n", "loss: 0.6352895949387161\n", "loss: 0.005802778138724651\n", "loss: 0.02613618729904643\n", "loss: 0.0016626924216938122\n", "loss: 0.00011674909770675868\n", "loss: 2.0748237039569517e-7\n", "loss: 2.0670808498213233e-7\n" ] } ], "source": [ "# initialise session with QOCProblem\n", "sess.qocprob_init(qocprob)\n", "\n", "# perform optimisation using L-BFGS algorithm\n", "optparams = sess.optimise(\"LBFGS\")" ] }, { "cell_type": "markdown", "id": "27", "metadata": {}, "source": [ "We can see the loss function is progressively reduced as the optimisation converges. Let's now compare the initial values of the parameters with those the optimisation yielded." ] }, { "cell_type": "code", "execution_count": 14, "id": "28", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:13:35.722409Z", "iopub.status.busy": "2026-08-20T10:13:35.722235Z", "iopub.status.idle": "2026-08-20T10:13:35.842691Z", "shell.execute_reply": "2026-08-20T10:13:35.841945Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Initial parameters: 2.0 4e-09 -2802495138.6169\n", "Optimised parameters: 3.1620023558947286 3.59989480878582e-09 -2809284981.8920965\n" ] }, { "data": {}, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ "
\n", "
\n", "
\n", "" ], "text/plain": [ ":NdOverlay [Variable]\n", " :Curve [time] (value)" ] }, "execution_count": 14, "metadata": { "application/vnd.holoviews_exec.v0+json": { "id": "a0a2bbde-a907-4053-ad3a-250d863f2059" } }, "output_type": "execute_result" } ], "source": [ "# create parameter space for optimised parameters\n", "optps = Parameters(optparams)\n", "\n", "# print initial and optimised parameters\n", "print(\"Initial parameters:\", *ps.ps)\n", "print(\"Optimised parameters:\", *optps.ps)\n", "\n", "# create xarray Dataset to store initial and optimised drive parameters\n", "pulse_shapes = xr.Dataset(\n", " {\n", " \"Unoptimised\": (\"time\", drive(ts, *ps.ps)),\n", " \"Optimised\": (\"time\", drive(ts, *optps.ps)),\n", " },\n", " coords={\"time\": ts / 1e-9},\n", ")\n", "\n", "# plot initial and optimised drives\n", "pulse_shapes.hvplot.line(\n", " x=\"time\",\n", " xlabel=\"Time (ns)\",\n", " ylabel=\"Amplitude (arb. u.)\",\n", ")" ] }, { "cell_type": "markdown", "id": "29", "metadata": {}, "source": [ "We can see that the optimisation primarily increases the drive amplitude, while making minor adjustments to the width and frequency. \n", "\n", "To determine whether these changes improve the population inversion, let's simulate the dynamics using the optimised parameters. We then create a new simulation problem, initialise it with `Session.qsprob_init`, and solve it as before." ] }, { "cell_type": "code", "execution_count": 15, "id": "30", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:13:35.844982Z", "iopub.status.busy": "2026-08-20T10:13:35.844766Z", "iopub.status.idle": "2026-08-20T10:13:35.958531Z", "shell.execute_reply": "2026-08-20T10:13:35.957719Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "\r", "\u001b[KODE [ ] 0%\r", "\u001b[KODE [########################################] 100%\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 40kB\n",
       "Dimensions:  (time: 1000, row: 2)\n",
       "Coordinates:\n",
       "  * time     (time) float64 8kB 0.0 2.002e-11 4.004e-11 ... 1.998e-08 2e-08\n",
       "Dimensions without coordinates: row\n",
       "Data variables:\n",
       "    qstates  (time, row) complex128 32kB (1+0j) ... (-0.18048959203517007+0.9...
" ], "text/plain": [ " Size: 40kB\n", "Dimensions: (time: 1000, row: 2)\n", "Coordinates:\n", " * time (time) float64 8kB 0.0 2.002e-11 4.004e-11 ... 1.998e-08 2e-08\n", "Dimensions without coordinates: row\n", "Data variables:\n", " qstates (time, row) complex128 32kB (1+0j) ... (-0.18048959203517007+0.9..." ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# create a new quantum simulation problem with the optimised parameters\n", "optprob = prob.remake(ps=optps)\n", "\n", "# instantiate the new problem with the optimised parameters\n", "sess.qsprob_init(optprob)\n", "\n", "# evolve the system\n", "optds = sess.evolve(\"Tsit5\", saveat=ts)\n", "optds" ] }, { "cell_type": "markdown", "id": "31", "metadata": {}, "source": [ "To compare the dynamics, we calculate the state populations after optimisation and plot them together with the unoptimised populations from earlier." ] }, { "cell_type": "code", "execution_count": 16, "id": "32", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:13:35.960299Z", "iopub.status.busy": "2026-08-20T10:13:35.960127Z", "iopub.status.idle": "2026-08-20T10:13:36.139432Z", "shell.execute_reply": "2026-08-20T10:13:36.138551Z" } }, "outputs": [ { "data": {}, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ "
\n", "
\n", "
\n", "" ], "text/plain": [ ":Overlay\n", " .Curve.Unoptimised_vertical_line_0_mathematical_right_angle_bracket :Curve [time] (population)\n", " .Curve.Unoptimised_vertical_line_1_mathematical_right_angle_bracket :Curve [time] (population)\n", " .Curve.Optimised_vertical_line_0_mathematical_right_angle_bracket :Curve [time] (population)\n", " .Curve.Optimised_vertical_line_1_mathematical_right_angle_bracket :Curve [time] (population)" ] }, "execution_count": 16, "metadata": { "application/vnd.holoviews_exec.v0+json": { "id": "20537dbe-deb4-40a1-9b8e-f60d6e95f001" } }, "output_type": "execute_result" } ], "source": [ "optds[\"population\"] = np.abs(optds[\"qstates\"]) ** 2\n", "\n", "optds = optds.rename({\"row\": \"state\"})\n", "optds = optds.assign_coords(state=[r\"|0>\", r\"|1>\"])\n", "\n", "(\n", " ds[\"population\"].isel(state=0).hvplot.line(label=\"Unoptimised |0⟩\")\n", " * ds[\"population\"].isel(state=1).hvplot.line(label=\"Unoptimised |1⟩\")\n", " * optds[\"population\"].isel(state=0).hvplot.line(label=\"Optimised |0⟩\")\n", " * optds[\"population\"].isel(state=1).hvplot.line(label=\"Optimised |1⟩\")\n", ").opts(\n", " xlabel=\"Time (s)\",\n", " ylabel=\"Population\",\n", " title=\"\",\n", ")" ] }, { "cell_type": "markdown", "id": "33", "metadata": {}, "source": [ "We can see here that the population exchange between the ground and first excited states is almost complete. Our optimisation was successful! \n", "\n", "We can quantify this success by printing the fidelity before and after optimisation:" ] }, { "cell_type": "code", "execution_count": 17, "id": "34", "metadata": { "execution": { "iopub.execute_input": "2026-08-20T10:13:36.141358Z", "iopub.status.busy": "2026-08-20T10:13:36.141163Z", "iopub.status.idle": "2026-08-20T10:13:36.147715Z", "shell.execute_reply": "2026-08-20T10:13:36.146880Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Unoptimised: 69.775021 %\n", "Optimised: 99.999979 %\n" ] } ], "source": [ "def fidelity(uf, ut):\n", " \"\"\"State fidelity between two pure states.\"\"\"\n", "\n", " uf = np.asarray(uf).squeeze()\n", " ut = ut.full().squeeze()\n", "\n", " return np.abs(np.vdot(ut, uf)) ** 2\n", "\n", "\n", "fid_unopt = fidelity(ds[\"qstates\"].isel(time=-1), ut)\n", "fid_opt = fidelity(optds[\"qstates\"].isel(time=-1), ut)\n", "\n", "print(f\"Unoptimised: {100*fid_unopt:.6f} %\")\n", "print(f\"Optimised: {100*fid_opt:.6f} %\")" ] }, { "cell_type": "markdown", "id": "35", "metadata": {}, "source": [ "We can clearly see that our optimisation has significantly enhanced the fidelity!\n", "\n", "Congratulations, you’ve just performed optimal control on a spin qubit! You can now use these methods to start optimising your qubit performance." ] } ], "metadata": { "kernelspec": { "display_name": ".venv (3.11.15)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.16" } }, "nbformat": 4, "nbformat_minor": 5 }