diff --git a/docs/pages/install.rst b/docs/pages/install.rst index 413d551..9a4b9cd 100644 --- a/docs/pages/install.rst +++ b/docs/pages/install.rst @@ -44,7 +44,7 @@ This should give you the following message: .. code-block:: none - '0.4.0' + '0.5.0' Uninstall diff --git a/docs/pages/tutorials/mf_tempo.rst b/docs/pages/tutorials/mf_tempo.rst index c883a6b..1591b09 100644 --- a/docs/pages/tutorials/mf_tempo.rst +++ b/docs/pages/tutorials/mf_tempo.rst @@ -49,7 +49,7 @@ in version **0.3.0** and revised in its current format in **0.4.0.** .. parsed-literal:: - '0.4.0' + '0.5.0' diff --git a/docs/pages/tutorials/parameters.rst b/docs/pages/tutorials/parameters.rst index 61f244c..7730eb0 100644 --- a/docs/pages/tutorials/parameters.rst +++ b/docs/pages/tutorials/parameters.rst @@ -57,7 +57,7 @@ The OQuPy version should be ``>=0.5.0`` .. parsed-literal:: - '0.4.0' + '0.5.0' --------------------------------------------------------------- diff --git a/docs/pages/tutorials/parameters.rst~ b/docs/pages/tutorials/parameters.rst~ index 1cac23c..3d0be0f 100644 --- a/docs/pages/tutorials/parameters.rst~ +++ b/docs/pages/tutorials/parameters.rst~ @@ -57,7 +57,7 @@ The OQuPy version should be ``>=0.5.0`` .. parsed-literal:: - '0.4.0' + '0.5.0' --------------------------------------------------------------- diff --git a/docs/pages/tutorials/pt_gradient/pt_gradient.rst b/docs/pages/tutorials/pt_gradient/pt_gradient.rst index 621a383..b3c52ba 100644 --- a/docs/pages/tutorials/pt_gradient/pt_gradient.rst +++ b/docs/pages/tutorials/pt_gradient/pt_gradient.rst @@ -33,7 +33,7 @@ The OQuPy version should be ``>=v0.5.0`` .. parsed-literal:: - '0.4.0' + '0.5.0' diff --git a/docs/pages/tutorials/pt_tebd.rst b/docs/pages/tutorials/pt_tebd.rst index 761d200..844b14f 100644 --- a/docs/pages/tutorials/pt_tebd.rst +++ b/docs/pages/tutorials/pt_tebd.rst @@ -49,7 +49,7 @@ and check what version of tempo we are using. .. parsed-literal:: - '0.4.0' + '0.5.0' diff --git a/docs/pages/tutorials/pt_tempo.rst b/docs/pages/tutorials/pt_tempo.rst index d47c17a..753f701 100644 --- a/docs/pages/tutorials/pt_tempo.rst +++ b/docs/pages/tutorials/pt_tempo.rst @@ -60,7 +60,7 @@ and check what version of tempo we are using. .. parsed-literal:: - '0.4.0' + '0.5.0' diff --git a/docs/pages/tutorials/quickstart.rst b/docs/pages/tutorials/quickstart.rst index 9910a4c..ac2b955 100644 --- a/docs/pages/tutorials/quickstart.rst +++ b/docs/pages/tutorials/quickstart.rst @@ -52,7 +52,7 @@ and check what version of tempo we are using. .. parsed-literal:: - '0.4.0' + '0.5.0' diff --git a/oqupy/version.py b/oqupy/version.py index df9d9f5..0f886d5 100644 --- a/oqupy/version.py +++ b/oqupy/version.py @@ -13,4 +13,4 @@ This module just defines what version of OQuPy we are currently looking at. """ -__version__ = '0.4.0' +__version__ = '0.5.0' diff --git a/tutorials/mf_tempo.ipynb b/tutorials/mf_tempo.ipynb index 326406b..8f79663 100644 --- a/tutorials/mf_tempo.ipynb +++ b/tutorials/mf_tempo.ipynb @@ -51,7 +51,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Check the current OQuPy version; mean-field functionality was introduced in version **0.3.0** and revised in its current format in **0.4.0.**" + "Check the current OQuPy version; mean-field functionality was introduced in version **0.3.0** and revised in its current format in **0.5.0.**" ] }, { @@ -62,7 +62,7 @@ { "data": { "text/plain": [ - "'0.4.0'" + "'0.5.0'" ] }, "execution_count": 2, diff --git a/tutorials/parameters.ipynb b/tutorials/parameters.ipynb index c9b6cb9..b9243b6 100644 --- a/tutorials/parameters.ipynb +++ b/tutorials/parameters.ipynb @@ -69,7 +69,7 @@ { "data": { "text/plain": [ - "'0.4.0'" + "'0.5.0'" ] }, "execution_count": 2, diff --git a/tutorials/parameters.ipynb~ b/tutorials/parameters.ipynb~ deleted file mode 100644 index 37fd3de..0000000 --- a/tutorials/parameters.ipynb~ +++ /dev/null @@ -1,922 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Computational parameters and convergence\n", - "\n", - "Discussion of the computational parameters in a TEMPO or PT-TEMPO computation and establishing convergence of results\n", - "\n", - "- [launch binder](https://mybinder.org/v2/gh/tempoCollaboration/OQuPy/HEAD?labpath=tutorials%2Fparameters.ipynb) (runs in browser),\n", - "- [download the jupyter file](https://raw.githubusercontent.com/tempoCollaboration/OQuPy/main/tutorials/parameters.ipynb), or\n", - "- read through the text below and code along." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Contents\n", - "\n", - "* [Introduction - numerical exactness and computational parameters](#Introduction---numerical-exactness-and-computational-parameters)\n", - "* [Choosing `tcut`](#Choosing-tcut)\n", - " - [Example - memory effects in a spin boson model](#Example---memory-effects-in-a-spin-boson-model)\n", - " - [Discussion - environment correlations](#Discussion---environment-correlations)\n", - "* [Choosing `dt` and `epsrel`](#Choosing-dt-and-epsrel)\n", - " - [Example - convergence for a spin boson model](#Example---convergence-for-a-spin-boson-model)\n", - " - [Resolving fast system dynamics](#Resolving-fast-system-dynamics)\n", - "* [Further considerations](#Further-considerations)\n", - " - [Additional TempoParameters arguments](#Additional-TempoParameters-arguments)\n", - " - [Bath coupling degeneracies](#Bath-coupling-degeneracies)\n", - "* [PT-TEMPO](#PT-TEMPO)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The following packages will be required" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "sys.path.insert(0,'..')\n", - "\n", - "import oqupy\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "plt.rcParams.update({'font.size': 14.0, 'lines.linewidth':2.50, 'figure.figsize':(8,6)})" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The OQuPy version should be `>=0.5.0`" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'0.4.0'" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "oqupy.__version__" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Introduction - numerical exactness and computational parameters\n", - "The TEMPO and PT-TEMPO methods are numerically exact meaning no approximations are required in their derivation. Instead error only arises in their numerical implementation, and is controlled by a set of computational parameters. The error can, in principle (at least up to machine precision), be made as small as desired by tuning those numerical parameters. In this tutorial we discuss how this is done to derive accurate results with manageable computational costs.\n", - "\n", - "As introduced in the [Quickstart](https://oqupy.readthedocs.io/en/latest/pages/tutorials/quickstart.html) tutorial a TEMPO or PT-TEMPO calculation has three main computational parameters:\n", - "\n", - "1. A memory cut-off `tcut`, which must be long enough to capture non-Markovian effects of the environment\n", - "2. A timestep length `dt`, which must be short enough to avoid Trotter error and provide a sufficient resolution of the system dynamics\n", - "3. A precision `epsrel`, which must be small enough such that the numerical compression (singular value truncation) does not incur physical error\n", - "\n", - "In order to verify the accuracy of a calculation, convergence should be established under all three parameters, under increases of `tcut` and decreases `dt` and `epsrel`. The challenge is that these parameters cannot necessarily be considered in isolation, and a balance must be struck between accuracy and computational cost. The strategy we take is to firstly determine a suitable `tcut` (set physically by properties of the environment) with rough values of `dt` and `epsrel`, then determine convergence under `dt->0,epsrel->0`.\n", - "\n", - "We illustrate convergence using the TEMPO method, but the ideas discussed will also generally apply to a PT-TEMPO computation where one first calculates a process tensor - fixing `tcut`, `dt`, `epsrel` - before calculating the system dynamics (see [PT-TEMPO](#PT-TEMPO)). Note some of the calculations in this tutorial may not be suitable to run in a Binder instance. If you want to run them on your own device, you can either copy the code as you go along or [download the .ipynb file](https://raw.githubusercontent.com/tempoCollaboration/OQuPy/main/tutorials/parameters.ipynb) to run in a local jupyter notebook session. \n", - "Example results for all calculations are embedded in the notebook already, so this is not strictly required." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Choosing tcut\n", - "## Example - memory effects in a spin boson model\n", - "We firstly define a spin-boson model similar to that in the Quickstart tutorial, but with a finite temperature environment and a small additional incoherent dissipation of the spin." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "sigma_x = oqupy.operators.sigma('x')\n", - "sigma_y = oqupy.operators.sigma('y')\n", - "sigma_z = oqupy.operators.sigma('z')\n", - "sigma_m = oqupy.operators.sigma('-')\n", - "\n", - "omega_cutoff = 2.5\n", - "alpha = 0.8\n", - "T = 0.2\n", - "correlations = oqupy.PowerLawSD(alpha=alpha,\n", - " zeta=1,\n", - " cutoff=omega_cutoff,\n", - " cutoff_type='exponential',\n", - " temperature=T)\n", - "bath = oqupy.Bath(0.5 * sigma_z, correlations)\n", - "Omega = 2.0\n", - "Gamma = 0.02\n", - "system = oqupy.System(0.5 * Omega * sigma_x,\n", - " gammas=[Gamma],\n", - " lindblad_operators=[sigma_m], # incoherent dissipation\n", - " )\n", - "\n", - "t_start = 0.0\n", - "t_end = 5.0" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To determine a suitable set of computational parameters for `t_start<=t<=t_end`, a good place to start is with a call to the `guess_tempo_parameters` function:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "../oqupy/tempo.py:865: UserWarning: Estimating TEMPO parameters. No guarantee subsequent dynamics calculations are converged. Please refer to the TEMPO documentation and check convergence by varying the parameters manually.\n", - " warnings.warn(GUESS_WARNING_MSG, UserWarning)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----------------------------------------------\n", - "TempoParameters object: Roughly estimated parameters\n", - " Estimated with 'guess_tempo_parameters()' based on bath correlations.\n", - " dt = 0.125 \n", - " tcut [dkmax] = 2.5 [20] \n", - " epsrel = 6.903e-05 \n", - " add_correlation_time = None \n", - "\n" - ] - } - ], - "source": [ - "guessed_paramsA = oqupy.guess_tempo_parameters(bath=bath,\n", - " start_time=t_start,\n", - " end_time=t_end,\n", - " tolerance=0.01)\n", - "print(guessed_paramsA)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As indicated in the description of this object, the parameters were estimated by analysing the correlations of `bath`, which are discussed further below. \n", - "\n", - "From the suggested parameters, we focus on `tcut` first, assuming the values of `dt` and `epsrel` are reasonable to work with. To do so we compare results at the recommend `tcut` to those calculated at a smaller (`1.25`) and larger (`5.0`) values of this parameter, starting from the spin-up state:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--> TEMPO computation:\n", - "100.0% 40 of 40 [########################################] 00:00:00\n", - "Elapsed time: 0.8s\n", - "--> TEMPO computation:\n", - "100.0% 40 of 40 [########################################] 00:00:01\n", - "Elapsed time: 1.6s\n", - "--> TEMPO computation:\n", - "100.0% 40 of 40 [########################################] 00:00:01\n", - "Elapsed time: 1.9s\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "initial_state = oqupy.operators.spin_dm('z+')\n", - "\n", - "for tcut in [1.25,2.5,5.0]:\n", - " # Create TempoParameters object matching those guessed above, except possibly for tcut\n", - " params = oqupy.TempoParameters(dt=0.125, epsrel=6.9e-06, tcut=tcut)\n", - " dynamics = oqupy.tempo_compute(system=system,\n", - " bath=bath,\n", - " initial_state=initial_state,\n", - " start_time=t_start,\n", - " end_time=t_end,\n", - " parameters=params)\n", - " t, s_z = dynamics.expectations(sigma_z, real=True)\n", - " plt.plot(t, s_z, label=r'${}$'.format(tcut))\n", - "plt.xlabel(r'$t$')\n", - "plt.ylabel(r'$\\langle\\sigma_z\\rangle$')\n", - "plt.legend(title=r'$t_{cut}$')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We see that `tcut=2.5` (orange) does very well, matching `tcut=5.0` (green) until essentially the end of the simulation (the precision `epsrel` could well be causing the small discrepancy). We know `tcut=5.0` should capture the actual result, because `tcut=5.0=t_end` means no memory cutoff was made! In general it is not always necessary to make a finite memory approximation. For example, perhaps one is interested in short-time dynamics only. The memory cutoff can be disable by setting `tcut=None`; be aware computation to long times (i.e. many hundreds of timesteps) may then be infeasible.\n", - "\n", - "The `tcut=1.25` result matches the other two exactly until `t=1.25` (no memory approximation is made before this time), but deviates shorlty after. On the other hand, the cost of using the larger `tcut=2.5` was a longer computation: 1.6s vs 0.8s above. This was a trivial example, but in many real calculations the runtimes will be far longer e.g. minutes or hours. It may be that an intermediary value `1.25<=tcut<=2.5` provides a satisfactory approximation - depending on the desired precision - with a more favourable cost: a TEMPO (or PT-TEMPO) computation scales **linearly** with the number of steps included in the memory cutoff.\n", - "\n", - "### A word of warning\n", - "\n", - "`guess_tempo_parameters` provides a reasonable starting point for many cases, but it is only a guess. You should always verify results using a larger `tcut`, whilst also not discounting smaller `tcut` to reduce the computational requirements. Similar will apply to checking convergence under `dt` and `epsrel`.\n", - "\n", - "Also, note we only inspected the expectations $\\langle \\sigma_z \\rangle$. To be most thorough all unique components of the state matrix should be checked, or at least the expectations of observables you are intending to study. So, if you were interested in the coherences as well as the populations, you would want to add calls to calculate $\\langle \\sigma_x \\rangle$, $\\langle \\sigma_y \\rangle$ above (you can check `tcut=2.5` is still good for the above example)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Discussion - environment correlations\n", - "So what influences the required `tcut`? The physically relevant timescale is that for the decay of correlations in the environment. These can be inspected using `oqupy.helpers.plot_correlations_with_parameters`:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "params = oqupy.TempoParameters(dt=0.125, epsrel=1, tcut=2.5) # N.B. epsrel not used by helper, and tcut only to set plot t-limits\n", - "oqupy.helpers.plot_correlations_with_parameters(bath.correlations, params, ax=ax)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This shows the real and imaginary parts of the bath autocorrelation function, with markers indicating samples of spacing `dt`. We see that correlations have not fully decayed by `t=1.25`, but have - at least by eye - by `t=2.5`. It seems like `tcut` around this value would indeed be a good choice.\n", - "\n", - "The autocorrelation function depends on the properties of the bath: the form the spectral density, the cutoff, and the temperature. These are accounted for by the `guess_tempo_parameters` function, which is really analysing the error in performing integrals of this function. The `tolerance` parameter specifies the maximum absolute error permitted, with an inbuilt default value of `3.9e-3` - passing `tolerance=0.01` made for slightly 'easier' parameters.\n", - "\n", - "Note, however, what is observed in the _system dynamics_ also depends the bath coupling operator and strength (`alpha`), and that these are _not_ taken into account by the guessing function. More generally, the nature of the intrinsic system dynamics (see below) and initial state preparation also has to be considered. \n", - "\n", - "Finally, the guessing function uses specified `start_time` and `end_time` to come up with parameters providing a manageable computation time over a timescale `end_time-start_time`, so make sure to set these to reflect those you actually intend to use in calculations. \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Choosing dt and epsrel\n", - "## Example - convergence for a spin boson model\n", - "Continuing with the previous example, we now investigate changing `dt` at our chosen `tcut=2.5`." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--> TEMPO computation:\n", - "100.0% 80 of 80 [########################################] 00:00:03\n", - "Elapsed time: 3.0s\n", - "--> TEMPO computation:\n", - "100.0% 40 of 40 [########################################] 00:00:00\n", - "Elapsed time: 0.9s\n", - "--> TEMPO computation:\n", - "100.0% 20 of 20 [########################################] 00:00:00\n", - "Elapsed time: 0.3s\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10,8))\n", - "for dt in [0.0625, 0.125, 0.25]:\n", - " params = oqupy.TempoParameters(dt=dt, epsrel=6.9e-05, tcut=2.5)\n", - " dynamics = oqupy.tempo_compute(system=system,\n", - " bath=bath,\n", - " initial_state=initial_state,\n", - " start_time=t_start,\n", - " end_time=t_end,\n", - " parameters=params)\n", - " t, s_z = dynamics.expectations(sigma_z, real=True)\n", - " plt.plot(t, s_z, label=r'${}$'.format(dt))\n", - "plt.xlabel(r'$t$')\n", - "plt.ylabel(r'$\\langle\\sigma_z\\rangle$')\n", - "plt.legend(title=r'$dt$')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "That doesn't look good! If we had just checked `dt=0.25` and `dt=0.125` we may have been happy with the convergence, but a halving of the timestep gave very different results (you can check `dt=0.0625` is even worse).\n", - "\n", - "The catch here is that we used the same precision `epsrel=6.9e-05` for all runs, but `dt=0.125` requires a smaller `epsrel`: halving the timestep _doubles_ the number of steps `dkmax` for which singular value truncations are made in the bath's memory `tcut=dt*dkmax`. \n", - "\n", - "Let's repeat the calculation with a smaller `epsrel` at `dt=0.125`:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--> TEMPO computation:\n", - "100.0% 80 of 80 [########################################] 00:00:04\n", - "Elapsed time: 5.0s\n", - "--> TEMPO computation:\n", - "100.0% 40 of 40 [########################################] 00:00:00\n", - "Elapsed time: 0.9s\n", - "--> TEMPO computation:\n", - "100.0% 20 of 20 [########################################] 00:00:00\n", - "Elapsed time: 0.2s\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "for dt, epsrel in zip([0.0625,0.125, 0.25],[6.9e-06,6.9e-05,6.9e-05]):\n", - " params = oqupy.TempoParameters(dt=dt, epsrel=epsrel, tcut=2.5)\n", - " dynamics = oqupy.tempo_compute(system=system,\n", - " bath=bath,\n", - " initial_state=initial_state,\n", - " start_time=t_start,\n", - " end_time=t_end,\n", - " parameters=params)\n", - " t, s_z = dynamics.expectations(sigma_z, real=True)\n", - " plt.plot(t, s_z, label=r'${}$, ${:.2g}$'.format(dt,epsrel))\n", - "plt.xlabel(r'$t$')\n", - "plt.ylabel(r'$\\langle\\sigma_z\\rangle$')\n", - "plt.legend(title=r'$dt, \\epsilon_{rel}$')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "That looks far better. The lesson here is that one cannot expect to be able to decrease `dt` at fixed `tcut` without also decreasing `epsrel`. A heuristic used by `guess_tempo_parameters`, which you may find useful, is\n", - "$$ \\epsilon_{\\text{r}} = \\text{tol} \\cdot 10^{-p},\\ p=\\log_4 (\\text{dkmax}), $$\n", - "where tol is a target tolerance (e.g. `tolerance=0.01` above) and `dkmax` the number of steps such that `tcut=dt*dkmax`.\n", - "\n", - "Note `TempoParameters` allows the memory cutoff to be specified as the integer `dkmax` rather than float `tcut`, meaning this estimation of `epsrel` doesn't change with `dt`. However, the author prefers working at a constant `tcut` which is set physically by the decay of correlations in the environment; then one only has to worry about the simultaneous convergence of `dt` and `epsrel`.\n", - "\n", - "Comparing the simulation times at `dt=0.0625` between the previous two sets of results, we see the cost of a smaller `epsrel` is a longer computation (5 vs. 3 seconds). The time complexity of the singular value decompositions in the TEMPO tensor network scales with the **third power** of the internal bond dimension, which is directly controlled by the precision, so be aware that decreasing `epsrel` may lead to rapid increase in computation times.\n", - "\n", - "The last results suggest that we may well already have convergence w.r.t `epsrel` at `dt=0.125`. This should be checked: " - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--> TEMPO computation:\n", - "100.0% 20 of 20 [########################################] 00:00:00\n", - "Elapsed time: 0.3s\n", - "--> TEMPO computation:\n", - "100.0% 20 of 20 [########################################] 00:00:00\n", - "Elapsed time: 0.2s\n", - "--> TEMPO computation:\n", - "100.0% 20 of 20 [########################################] 00:00:00\n", - "Elapsed time: 0.2s\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "for epsrel in [6.9e-06,6.9e-05,6.9e-04]:\n", - " params = oqupy.TempoParameters(dt=dt, epsrel=epsrel, tcut=2.5)\n", - " dynamics = oqupy.tempo_compute(system=system,\n", - " bath=bath,\n", - " initial_state=initial_state,\n", - " start_time=t_start,\n", - " end_time=t_end,\n", - " parameters=params)\n", - " t, s_z = dynamics.expectations(sigma_z, real=True)\n", - " plt.plot(t, s_z, label=r'${:.2g}$'.format(epsrel))\n", - "plt.xlabel(r'$t$')\n", - "plt.ylabel(r'$\\langle\\sigma_z\\rangle$')\n", - "plt.legend(title=r'$\\epsilon_{rel}$')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In summary, we may well be happy with the parameters `dt=0.125`, `epsrel=6.9e-05`, `tcut=2.5` for this model (we could probably use a larger `epsrel`, but the computation is so inexpensive in this example it is hardly necessary). \n", - "\n", - "So far we have discussed mainly how the environment - namely the memory length - dictates the parameters. We now look at what influence the system can have." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Resolving fast system dynamics" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the above you may have noticed that the results at `dt=0.125`, while converged, were slightly undersampled. This becomes more noticeable if the scale of the system energies is increased (here by a factor of 4):" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "../oqupy/tempo.py:865: UserWarning: Estimating TEMPO parameters. No guarantee subsequent dynamics calculations are converged. Please refer to the TEMPO documentation and check convergence by varying the parameters manually.\n", - " warnings.warn(GUESS_WARNING_MSG, UserWarning)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----------------------------------------------\n", - "TempoParameters object: Roughly estimated parameters\n", - " Estimated with 'guess_tempo_parameters()' based on bath correlations.\n", - " dt = 0.125 \n", - " tcut [dkmax] = 2.5 [20] \n", - " epsrel = 6.903e-05 \n", - " add_correlation_time = None \n", - "\n", - "--> TEMPO computation:\n", - "100.0% 40 of 40 [########################################] 00:00:03\n", - "Elapsed time: 3.5s\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "Omega = 8.0 # From 2.0\n", - "Gamma = 0.08 # From 0.02\n", - "system = oqupy.System(0.5 * Omega * sigma_x,\n", - " gammas=[Gamma],\n", - " lindblad_operators=[sigma_m])\n", - "params = oqupy.guess_tempo_parameters(bath=bath,\n", - " start_time=t_start,\n", - " end_time=t_end,\n", - " tolerance=0.01)\n", - "print(params)\n", - "dynamics = oqupy.tempo_compute(system=system,\n", - " bath=bath,\n", - " initial_state=initial_state,\n", - " start_time=t_start,\n", - " end_time=t_end,\n", - " parameters=params)\n", - "t, s_z = dynamics.expectations(sigma_z, real=True)\n", - "plt.plot(t, s_z)\n", - "plt.xlabel(r'$t$')\n", - "plt.ylabel(r'$\\langle\\sigma_z\\rangle$')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The call to `guess_tempo_parameters` returned the same set `dt=0.125`, `epsrel=6.9e-05`, `tcut=2.5` as before, because it did not use any information of the system. We can change this, and hopefully resolve the system dynamics on a more appropriate grid, by providing the system as an optional argument:\n", - "\n", - "[Warning: long computation]" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "../oqupy/tempo.py:865: UserWarning: Estimating TEMPO parameters. No guarantee subsequent dynamics calculations are converged. Please refer to the TEMPO documentation and check convergence by varying the parameters manually.\n", - " warnings.warn(GUESS_WARNING_MSG, UserWarning)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----------------------------------------------\n", - "TempoParameters object: Roughly estimated parameters\n", - " Estimated with 'guess_tempo_parameters()' based on bath correlations and system frequencies (limiting).\n", - " dt = 0.03125 \n", - " tcut [dkmax] = 2.5 [80] \n", - " epsrel = 6.903e-06 \n", - " add_correlation_time = None \n", - "\n", - "--> TEMPO computation:\n", - "100.0% 160 of 160 [########################################] 00:01:09\n", - "Elapsed time: 69.5s\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$\\\\langle\\\\sigma_z\\\\rangle$')" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "Omega = 8.0 # From 2.0\n", - "Gamma = 0.08 # From 0.02\n", - "system = oqupy.System(0.5 * Omega * sigma_x,\n", - " gammas=[Gamma],\n", - " lindblad_operators=[sigma_m])\n", - "params = oqupy.guess_tempo_parameters(system=system, # new system argument (optional)\n", - " bath=bath,\n", - " start_time=t_start,\n", - " end_time=t_end,\n", - " tolerance=0.01)\n", - "print(params)\n", - "dynamics = oqupy.tempo_compute(system=system,\n", - " bath=bath,\n", - " initial_state=initial_state,\n", - " start_time=t_start,\n", - " end_time=t_end,\n", - " parameters=params)\n", - "t, s_z = dynamics.expectations(sigma_z, real=True)\n", - "plt.plot(t, s_z)\n", - "plt.xlabel(r'$t$')\n", - "plt.ylabel(r'$\\langle\\sigma_z\\rangle$')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As both `dkmax` increased and `epsrel` decreased to accommodate the smaller `dt=0.03125`, the computation took far longer - over a minute compared to a few seconds at `dt=0.125` (it may now be worth investigating whether a larger `epsrel` can be used).\n", - "\n", - "With a `system` argument, `guess_tempo_parameters` uses the matrix norm of the system Hamiltonian and any Lindblad operators/rates to estimate a suitable timestep on which to resolve the system dynamics. This is compared to the `dt` required to meet the tolerance on error for the bath correlations, and the smaller of the two is returned. The description of the `TempoParameters` object indicates which part was 'limiting' i.e. required the smaller `dt`.\n", - "\n", - "Often it is not necessary to calculate the system dynamics on such a fine grid. For example, if one only needs to calculate the steady-state polarisation. Moreover, the undersampling is easy to spot and adjust by eye. Hence you may choose to not pass a `system` object to `guess_tempo_parameters`. However, note there are cases where not accounting for system frequencies can lead to more physical features being missed, namely when the Hamiltonian or Lindblad operators/rates are (rapidly) _time-dependent._" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### What sets dt, really?" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The main error associated with `dt` is that from the Trotter splitting of the system propagators. In a simple (non-symmetrised) splitting, a basic requirement is\n", - "$$ [H_S(t) , H_E] dt \\ll \\left(H_S(t)+H_E\\right) dt^2. $$\n", - "In words: error arises from non-commutation between the system and bath coupling operator. This simply reflects the fact that in the discretisation of the path integral the splitting is made between the system and environment\n", - "Hamiltonians. In cases where $H_S$ commutes with $H_E$, such as the independent boson model, $dt$ can be arbitrarily large without physical error.\n", - "\n", - "Note `guess_tempo_parameters` does _not_ attempt to estimate the Trotter error, even when both `system` and `bath` objects are specified - another reason to be cautious when using the estimate produced by this function." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Further considerations\n", - "## Additional TempoParameters arguments\n", - "For completeness, there are a few other parameters that can be passed to the `TempoParameters` constructor:\n", - "- `subdiv_limit` and `liouvillian_epsrel`. These control the maximum number of subdivisions and relative error tolerance when integrating a time-dependent system Liouvillian to construct the system propagators. It is unlikely you will need to change them from their default values (`265`, `2**(-26)`)\n", - "- `add_correlation_time`. This allows one to include correlations _beyond_ `tcut` in the final bath tensor at `dkmax` (i.e., have your finite memory cutoff cake and eat it). Doing so may provide better approximations in cases where `tcut` is limited due to computational difficultly. See [[Strathearn2017]](http://dx.doi.org/10.1088/1367-2630/aa8744) for details.\n", - "\n", - "## Bath coupling degeneracies\n", - "The bath tensors in the TEMPO network are nominally $d^2\\times d^2$ matrices, where $d$ is the system Hilbert space dimension. \n", - "If there are degeneracies in the sums or differences of the eigenvalues of the system operator coupling to the environment, it is possible for the dimension of these tensors to be reduced.\n", - "\n", - "Specifying `unique=True` as an argument to `oqupy.tempo_compute`, degeneracy checking is enabled: if a dimensional reduction of the bath tensors is possible, the lower dimensional tensors will be used. We expect this to provide in many cases a significant speed-up without any significant loss of accuracy, although this has not been extensively tested (new in `v0.5.0`).\n", - "\n", - "## Mean-field systems\n", - "For calculating mean-field dynamics, there is an additional requirement on `dt` being small enough so not as to introduce error when integrating the field equation of motion between timesteps (2nd order Runge-Kutta). Common experience is that this is generally satisfied if `dt` is sufficiently small to avoid Trotter error. Still, you will want to at least inspect the field dynamics in addition to the system observables when checking convergence.\n", - "\n", - "Note that, for the purposes of estimating the characteristic frequency of a `SystemWithField` object, `guess_tempo_parameters` uses an arbitrary complex value $\\exp(i \\pi/4)$ for the field variable when evaluating the system Hamiltonian. This may give a poor estimation for situations where the field variable is not of order $1$ in the dynamics." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# PT-TEMPO\n", - "The above considerations for `tcut`, `dt` and `epsrel` all apply to a PT-TEMPO computation, with the following caveats:\n", - "\n", - "1. Convergence for a TEMPO computation does not necessarily imply convergence for a PT-TEMPO computation. This is important as it is often convenient to perform several one-off TEMPO computations to determine a good set of computational parameters to save having to construct many large process tensors. You can still take this approach, but must be sure to check for convergence in the PT-TEMPO computation when you have derived a reasonable set. \n", - "2. Similar to 1., the best possible accuracy of a TEMPO and PT-TEMPO computation may be different. In particular, there may be a trade-off of accuracy for overall reduced computation time when using the PT approach. We note that the error in PT-TEMPO has also been observed ([[FowlerWright2022]](https://doi.org/10.1103/PhysRevLett.129.173001)) to become unstable at very high precisions (small `epsrel`), i.e., there may be a higher floor for how small you can make `epsrel`.\n", - "3. The computational difficultly of constructing the PT may not be monotonic with memory cutoff `dkmax` (or `tcut`). In particular, the computational time may diverge _below_ a certain `dkmax`, a.k.a, the 'dkmax anomaly'. We highlight this counter-intuitive behaviour, which seems to occur at relatively high precisions (small `epsrel`) with short timesteps, because it may lead one to falsely believe the computation of a process tensor is not feasible. See below for a demonstration and the Supplementary Material of [[FowlerWright2022]](https://doi.org/10.1103/PhysRevLett.129.173001) for further discussion." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## The dkmax anomaly \n", - "We consider constructing a process tensor of 250 timesteps for the harmonic environment discussed in the [Mean-Field Dynamics](https://oqupy.readthedocs.io/en/latest/pages/tutorials/mf_tempo.ipynb) tutorial, but with a smaller timestep `dt=1e-3` ps and `epsrel=1e-8` than considered there. Note that the following computations are very demanding." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "alpha = 0.25 # Doesn't affect PT computation\n", - "nu_c = 227.9\n", - "T = 39.3\n", - "start_time = 0.0\n", - "\n", - "dt = 1e-3\n", - "epsrel = 1e-8 \n", - "end_time = 250 * dt # 251 steps starting from t=0.0\n", - "\n", - "correlations = oqupy.PowerLawSD(alpha=alpha,\n", - " zeta=1,\n", - " cutoff=nu_c,\n", - " cutoff_type='gaussian')\n", - "bath = oqupy.Bath(oqupy.operators.sigma(\"z\")/2.0, correlations)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We firstly set `dkmax=250` (or `None`), i.e., make no memory approximation:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--> PT-TEMPO computation:\n", - "100.0% 250 of 250 [########################################] 00:01:37\n", - "Elapsed time: 97.3s\n" - ] - } - ], - "source": [ - "params = oqupy.TempoParameters(dt=dt,\n", - " epsrel=epsrel,\n", - " dkmax=250)\n", - "\n", - "process_tensor = oqupy.pt_tempo_compute(bath=bath,\n", - " start_time=start_time,\n", - " end_time=end_time,\n", - " parameters=params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Including the full memory didn't take too long, just over one and a half minutes on a modern desktop (AMD 6-Core\n", - "processor @4.7GHz, python3.6).\n", - "\n", - "What about if we now make a memory approximation, say only after `dkmax=225` timesteps:" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--> PT-TEMPO computation:\n", - "100.0% 250 of 250 [########################################] 00:08:04\n", - "Elapsed time: 484.6s\n" - ] - } - ], - "source": [ - "params = oqupy.TempoParameters(dt=dt,\n", - " epsrel=epsrel,\n", - " dkmax=225)\n", - "\n", - "process_tensor = oqupy.pt_tempo_compute(bath=bath,\n", - " start_time=start_time,\n", - " end_time=end_time,\n", - " parameters=params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "That was far slower (8 mins)! You can try `dkmax=200` - on my hardware the computation took half an hour; it may not be possible to complete the calculation `dkmax` much below this.\n", - "\n", - "In general, there may exist some `dkmax` value (here close to 250) below which the computational time grows quickly. On the other hand, for longer computations, e.g. a 500 step process tensor, increases of `dkmax` will eventually lead to increasing compute times again, although the dynamics will surely be converged with respect to this parameter well before then.\n", - "\n", - "The take-home message is to not discount that a stalling PT computation may in fact be possible with an increase in the memory length. In these situations one approach is to start with `dkmax=None` and work backwards to find the `dkmax` offering the minimum compute time (before the rapid increase)." - ] - } - ], - "metadata": { - "interpreter": { - "hash": "3306e98808c0871e8a1685f50cc307ae5b4a4a013844b10634a4efe89132c3fe" - }, - "kernelspec": { - "display_name": "oqupyDev", - "language": "python", - "name": "oqupydev" - }, - "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.6.15" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 1, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/tutorials/pt_gradient.ipynb b/tutorials/pt_gradient.ipynb index 16ad658..3d9a3d1 100644 --- a/tutorials/pt_gradient.ipynb +++ b/tutorials/pt_gradient.ipynb @@ -48,7 +48,7 @@ { "data": { "text/plain": [ - "'0.4.0'" + "'0.5.0'" ] }, "execution_count": 2, diff --git a/tutorials/pt_tebd.ipynb b/tutorials/pt_tebd.ipynb index c683041..4321ab8 100644 --- a/tutorials/pt_tebd.ipynb +++ b/tutorials/pt_tebd.ipynb @@ -60,7 +60,7 @@ { "data": { "text/plain": [ - "'0.4.0'" + "'0.5.0'" ] }, "execution_count": 2, diff --git a/tutorials/pt_tempo.ipynb b/tutorials/pt_tempo.ipynb index ed514a8..e742c89 100644 --- a/tutorials/pt_tempo.ipynb +++ b/tutorials/pt_tempo.ipynb @@ -63,7 +63,7 @@ { "data": { "text/plain": [ - "'0.4.0'" + "'0.5.0'" ] }, "execution_count": 2, diff --git a/tutorials/quickstart.ipynb b/tutorials/quickstart.ipynb index c2bc829..a50da99 100644 --- a/tutorials/quickstart.ipynb +++ b/tutorials/quickstart.ipynb @@ -61,7 +61,7 @@ { "data": { "text/plain": [ - "'0.4.0'" + "'0.5.0'" ] }, "execution_count": 2,