diff --git a/docs/index.rst b/docs/index.rst index 589fd3d..d7a3709 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -28,6 +28,7 @@ Check out the :doc:`usage` section for further information, including how to :re notebooks/helium_atom notebooks/beryllium_atom notebooks/PCMSolvent + notebooks/harmonic_oscillator_evolution .. toctree:: :maxdepth: 2 diff --git a/docs/notebooks/harmonic_oscillator_evolution.ipynb b/docs/notebooks/harmonic_oscillator_evolution.ipynb new file mode 100644 index 0000000..7aa167b --- /dev/null +++ b/docs/notebooks/harmonic_oscillator_evolution.ipynb @@ -0,0 +1,580 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "26d935ef", + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"Schrödinger equation\"\"\"\n", + "\n", + "__author__ = \"Evgueni Dinvay\"\n", + "__credit__ = [\"Evgueni Dinvay\"]\n", + "\n", + "__date__ = \"2023-11-24\"" + ] + }, + { + "cell_type": "markdown", + "id": "559d1557", + "metadata": {}, + "source": [ + "# The Schrödinger equation\n", + "\n", + "\n", + "\n", + "Here we demonstrate how the multiwavelets machinery can be exploited for time evolution simulations\n", + "of the following one dimensional equation\n", + "\\begin{equation}\n", + "\\label{general_Schrodinger}\n", + " i \\partial_t \\Psi\n", + " =\n", + " \\left( - \\partial_x^2 + V(x) \\right) \\Psi\n", + " ,\n", + "\\end{equation}\n", + "where we restrict ourselves to consideration of a time independent potential $V$.\n", + "This equation is complemented by a given initial wave function $\\Psi(x, 0) = \\Psi_0(x)$.\n", + "A an example, we take a harmonic potential and a gaussian initial wave packet.\n", + "\n", + "\n", + "A common way of numerical treatment of this equation\n", + "is to choose a small time step $t > 0$ and construct the time evolution operator\n", + "\\begin{equation}\n", + "\\label{time_propagation}\n", + " \\Psi(t)\n", + " =\n", + " \\exp\n", + " \\left(\n", + " i t \\partial_x^2 -i t V\n", + " \\right)\n", + " \\Psi_0\n", + "\\end{equation}\n", + "on interval $[0, t]$.\n", + "Then applying it iteratively one can arrive to the solution\n", + "at some given finite time moment,\n", + "thanks to the semigroup property of the propagator.\n", + "As we normally do not have an access to the full collection of eigenfunctions and eigenvalues\n", + "for the Hamiltonian, we have to split the propagator on kinetic\n", + "$\n", + " \\exp\n", + " \\left(\n", + " i t \\partial_x^2\n", + " \\right)\n", + "$\n", + "and potential \n", + "$\n", + " \\exp\n", + " \\left(\n", + " -i t V\n", + " \\right)\n", + "$\n", + "parts.\n", + "Note that the latter is a multiplication operator in the physical space.\n", + "\n", + "\n", + "We will make use of the following fourth order scheme\n", + "\\begin{equation}\n", + " \\exp ( At + Bt )\n", + " =\n", + " \\exp \\left( \\frac t6 B \\right)\n", + " \\exp \\left( \\frac t2 A \\right)\n", + " \\exp \\left( \\frac {2t}3 \\widetilde B \\right)\n", + " \\exp \\left( \\frac t2 A \\right)\n", + " \\exp \\left( \\frac t6 B \\right)\n", + " +\n", + " \\mathcal O \\left( t^5 \\right)\n", + " ,\n", + "\\end{equation}\n", + "where\n", + "\\begin{equation}\n", + "\\label{tildeB}\n", + " \\widetilde B\n", + " =\n", + " B\n", + " +\n", + " \\frac{t^2}{48}\n", + " [ B, [A, B]]\n", + " .\n", + "\\end{equation}\n", + "In the case of $A = i \\partial_x^2$ and $B = -i V$\n", + "this\n", + "$\n", + " \\widetilde B\n", + "$\n", + "turns out to be a multiplication operator containing potential gradient $\\partial_x V(x)$.\n", + "Remarkably,\n", + "this high order scheme requires only two applications\n", + "of the free-particle semigroup operator\n", + "$\n", + " \\exp \\left( it \\partial_x^2 / 2 \\right)\n", + "$\n", + "per time step.\n" + ] + }, + { + "cell_type": "markdown", + "id": "22d1fe8f", + "metadata": {}, + "source": [ + "
\n", + " \n", + " \n", + "
\n", + " To run the selected code cell, hit
Shift + Enter
\n", + "
\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3cf82f2c", + "metadata": {}, + "outputs": [], + "source": [ + "class ChinChenA(object):\n", + " def __init__(self, expA, expB, exp_tildeB):\n", + " self.expA = expA\n", + " self.expB = expB\n", + " self.exp_tildeB = exp_tildeB\n", + " def __call__(self, u):\n", + " u = self.expB(u) # 1/6*dt\n", + " u = self.expA(u) # 1/2*dt\n", + " u = self.exp_tildeB(u) # 2/3*dt\n", + " u = self.expA(u) # 1/2*dt\n", + " u = self.expB(u) # 1/6*dt\n", + " return u " + ] + }, + { + "cell_type": "markdown", + "id": "f4f5c5cf", + "metadata": {}, + "source": [ + "**Constructor Parameters**\n", + "- `expA`: stands for operator $\\exp \\left( \\frac t2 A \\right) = \\exp \\left( i \\frac t2 \\partial_x^2 \\right)$\n", + "- `expB`: stands for operator $\\exp \\left( \\frac t6 B \\right) = \\exp \\left( -i \\frac t6 V \\right)$\n", + "- `exp_tildeB`: stands for operator\n", + "$\\exp \\left( \\frac {2t}3 \\widetilde B \\right) = \\exp \\left( -i \\frac {2t}3 \\widetilde V \\right)$\n", + "with\n", + "$\n", + "\\widetilde V\n", + " =\n", + " V\n", + " -\n", + " \\frac{t^2}{24}\n", + " ( \\partial_x V )^2\n", + "$" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "613c15a6", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from vampyr import vampyr1d as vp1\n", + "from vampyr import LegendreBasis\n", + "\n", + "# Define parameters, final time moment and time step\n", + "x0 = 0.3\n", + "sigma = 0.04\n", + "x1 = 0.5\n", + "V0 = 25000\n", + "N = 10\n", + "t_period = np.pi / np.sqrt(V0)\n", + "time_step = 0.5 * t_period / N\n", + "\n", + "# Set the precision and make the MRA\n", + "precision = 1.0e-5\n", + "finest_scale = 9\n", + "mra = vp1.MultiResolutionAnalysis(vp1.BoundingBox(0), LegendreBasis(5))\n", + "\n", + "# Make the scaling projector\n", + "P = vp1.ScalingProjector(mra, prec = precision)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "487dcca8", + "metadata": {}, + "outputs": [], + "source": [ + "class MultiplicationOperator(object):\n", + " def __init__(self, function):\n", + " self.function = function\n", + " def __call__(self, function):\n", + " return self.function * function" + ] + }, + { + "cell_type": "markdown", + "id": "a47b2264", + "metadata": {}, + "source": [ + "\\begin{equation*}\n", + " U\n", + " =\n", + " U \\left( \\widehat H, t \\right)\n", + " =\n", + " \\exp \\left( -i \\widehat H t \\right)\n", + " =\n", + " \\begin{pmatrix}\n", + " \\cos \\widehat H t\n", + " &\n", + " \\sin \\widehat H t\n", + " \\\\\n", + " - \\sin \\widehat H t\n", + " &\n", + " \\cos \\widehat H t\n", + " \\end{pmatrix}\n", + " =\n", + " \\begin{pmatrix}\n", + " \\Re U\n", + " &\n", + " -\\Im U\n", + " \\\\\n", + " \\Im U\n", + " &\n", + " \\Re U\n", + " \\end{pmatrix}\n", + "\\end{equation*}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "04f44589", + "metadata": {}, + "outputs": [], + "source": [ + "class UnitaryExponentGroup(object):\n", + " def __init__(self, real, imag):\n", + " self.real = real\n", + " self.imag = imag\n", + " def __call__(self, psi):\n", + " u = psi[0]\n", + " v = psi[1]\n", + " res0 = self.real(u) - self.imag(v)\n", + " res1 = self.imag(u) + self.real(v)\n", + " return np.array([ res0, res1 ]) " + ] + }, + { + "cell_type": "markdown", + "id": "d3c709cd", + "metadata": {}, + "source": [ + "The unitary potential semigroup operator\n", + "\\begin{equation*}\n", + " U\n", + " =\n", + " U \\left( V, t \\right)\n", + " =\n", + " \\exp \\left( -i V t \\right)\n", + " \\approx\n", + " \\begin{pmatrix}\n", + " P \\cos (V t)\n", + " &\n", + " P \\sin (V t)\n", + " \\\\\n", + " - P \\sin (V t)\n", + " &\n", + " P \\cos (V t)\n", + " \\end{pmatrix}\n", + " =\n", + " \\begin{pmatrix}\n", + " P \\Re \\exp \\left( -i V t \\right)\n", + " &\n", + " - P \\Im \\exp \\left( -i V t \\right)\n", + " \\\\\n", + " P \\Im \\exp \\left( -i V t \\right)\n", + " &\n", + " P \\Re \\exp \\left( -i V t \\right)\n", + " \\end{pmatrix}\n", + "\\end{equation*}\n", + "which should be understood as a multiplication operator." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "defcebb2", + "metadata": {}, + "outputs": [], + "source": [ + "def create_unitary_potential_operator(P, V, t):\n", + " def real(x):\n", + " return np.cos(V(x) * t)\n", + " real = P(real)\n", + " def imag(x):\n", + " return - np.sin(V(x) * t)\n", + " imag = P(imag)\n", + " real = MultiplicationOperator(real)\n", + " imag = MultiplicationOperator(imag)\n", + " return UnitaryExponentGroup(real, imag)" + ] + }, + { + "cell_type": "markdown", + "id": "f40d5135", + "metadata": {}, + "source": [ + "The Schrodinger free-particle semigroup operator\n", + "\\begin{equation*}\n", + " U\n", + " =\n", + " U \\left( \\widehat T, t \\right)\n", + " =\n", + " U \\left( - \\partial_x^2, t \\right)\n", + " =\n", + " \\exp \\left( it \\partial_x^2 \\right)\n", + " =\n", + " \\begin{pmatrix}\n", + " \\Re \\exp \\left( it \\partial_x^2 \\right)\n", + " &\n", + " - \\Im \\exp \\left( it \\partial_x^2 \\right)\n", + " \\\\\n", + " \\Im \\exp \\left( it \\partial_x^2 \\right)\n", + " &\n", + " \\Re \\exp \\left( it \\partial_x^2 \\right)\n", + " \\end{pmatrix}\n", + "\\end{equation*}" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "50644dd2", + "metadata": {}, + "outputs": [], + "source": [ + "def create_unitary_kinetic_operator(mra, precision, time, finest_scale):\n", + " real = vp1.TimeEvolutionOperator(mra, precision, time, finest_scale, False)\n", + " imag = vp1.TimeEvolutionOperator(mra, precision, time, finest_scale, True)\n", + " return UnitaryExponentGroup(real, imag)" + ] + }, + { + "cell_type": "markdown", + "id": "11845e68", + "metadata": {}, + "source": [ + "It is well known that in the harmonic potential\n", + "$\n", + " V(x) = V_0 (x - x_1)^2\n", + "$\n", + "the density\n", + "$\n", + " \\left| \\Psi(t) \\right|^2\n", + "$\n", + "oscillates with the period\n", + "$\n", + " t_{\\text{period}} = \\pi / \\sqrt{V_0}\n", + " .\n", + "$\n", + "More precisely,\n", + "$\n", + " \\Psi \\left( t_{\\text{period}} \\right) = - \\Psi_0\n", + " .\n", + "$\n", + "This can immediately be seen taking into account that\n", + "the eigenvalues for the Hamiltonian are\n", + "$\n", + " \\sqrt{V_0} ( 2n + 1)\n", + " .\n", + "$\n", + "\n", + "For the time step $t$ the scheme modification potential\n", + "$\n", + " \\widetilde V\n", + " =\n", + " V\n", + " -\n", + " \\frac{t^2}{24}\n", + " ( \\partial_x V )^2\n", + " =\n", + " \\widetilde V_0 (x - x_0)^2\n", + "$\n", + "where\n", + "$\n", + " \\widetilde V_0\n", + " =\n", + " V_0\n", + " -\n", + " \\frac{(tV_0)^2}6\n", + " .\n", + "$" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c6d5c201", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the harmonic potential with its scheme modification\n", + "def V(x):\n", + " return V0 * (x[0] - x1)**2\n", + "def tilde_V(x):\n", + " A = V0 - ( time_step * V0 )**2 / 6.0\n", + " return A * (x[0] - x1)**2\n", + "\n", + "# Define the iteration procedure\n", + "iteratorA = ChinChenA(\n", + " expA = create_unitary_kinetic_operator(mra, precision, time_step / 2, finest_scale),\n", + " expB = create_unitary_potential_operator(P, V, time_step / 6),\n", + " exp_tildeB = create_unitary_potential_operator(P, tilde_V, 2 * time_step / 3)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "2e1bd7d5", + "metadata": {}, + "source": [ + "Let an initial condition be of the form\n", + "\\begin{equation*}\n", + " \\Psi_0(x)\n", + " =\n", + " \\left(\n", + " \\frac 1{2 \\pi \\sigma^2}\n", + " \\right)^{1/4}\n", + " \\exp\n", + " \\left(\n", + " - \\frac {(x - x_0)^2}{4 \\sigma^2}\n", + " \\right)\n", + "\\end{equation*}\n", + "with $x_0 = 0.3$, $p = 0$ and $\\sigma = 0.04$.\n", + "All the parameters are chosen in a way that the solution\n", + "stays localized mainly on the space interval $[0, 1]$." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5caca45d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define the initial wave function\n", + "psi0 = vp1.GaussFunc(\n", + " beta = 1.0 / (4 * sigma**2),alpha = (2 * np.pi * sigma**2)**(-1/4), position = [x0]\n", + ")\n", + "psi0 = np.array([ P(psi0), vp1.FunctionTree(mra).setZero() ])\n", + "\n", + "# Plot the initial density\n", + "x_vec = np.linspace(0, 0.9999, 1000)\n", + "real_psi0_plt = np.array([( psi0[0] * psi0[0] + psi0[1] * psi0[1] )([x]) for x in x_vec ])\n", + "plt.plot(x_vec, real_psi0_plt, '--', color='black')\n", + "\n", + "# Solve the initial value problem and plot the result\n", + "psiA = psi0\n", + "for n in range(N):\n", + " psiA = iteratorA(psiA)\n", + " densityA = psiA[0] * psiA[0] + psiA[1] * psiA[1]\n", + " densityA_plt = np.array([densityA([x]) for x in x_vec ])\n", + " plt.plot(x_vec, densityA_plt , \"black\")\n", + " \n", + "plt.xlabel('x')\n", + "plt.ylabel(r'$| \\Psi(x, t) |^2$')\n", + "plt.title(r'Density time evolution')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4ebf7549", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "L2-norm of real part error: 0.00011595685155302059\n", + "L2-norm of imaginary part error: 9.475768012015029e-05\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Continue solving until t = period \n", + "for n in range(N):\n", + " psiA = iteratorA(psiA)\n", + "\n", + "# Find error at t = period\n", + "per_errorA = psiA + psi0\n", + "\n", + "print( f\"L2-norm of real part error: {per_errorA[0].norm()}\" )\n", + "print( f\"L2-norm of imaginary part error: {per_errorA[1].norm()}\" )\n", + "\n", + "real_psi_plt = np.array([per_errorA[0]([x]) for x in x_vec ])\n", + "plt.plot(x_vec, real_psi_plt , \"blue\", label=r'Re$( \\Psi(x, t_{ \\text{period} }) + \\Psi_0(x) )$')\n", + "\n", + "imag_psi_plt = np.array([per_errorA[1]([x]) for x in x_vec ])\n", + "plt.plot(x_vec, imag_psi_plt , \"orange\", label=r'Im$( \\Psi(x, t_{ \\text{period} }) + \\Psi_0(x) )$')\n", + "\n", + "plt.xlabel('x')\n", + "plt.title(r'Difference with the exact solution at $t = t_{ \\text{period} }$')\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}