docs/Demo_SSV2stab.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Special method `SSV2stab` for large, mildly stiff problems\n",
    "\n",
    "`SSV2stab` is based on the stabilized Runge-Kutta-Chebyshev method of [Sommeijer, Shampine and Verwer](https://doi.org/10.1016/S0377-0427(97)00219-7). It is similar to the Fortran code [RKC](https://www.netlib.org/ode/), but translated to Python and adapted to Scipy's solve_ivp.\n",
    "\n",
    "Stiff problems cannot be solved efficiently by explicit methods. In many relevant cases, stiffness is caused by a negative real pole far from the origin. Very small steps are needed with an explicit method to keep this pole inside the stability region. The trick of the `SSV2stab` is that it has a variable number of stages per step. The stability region stretches quadratically along the negative real axis with the number of stages. Therefore, it is more efficient to include more stages than to take smaller steps. Step size is also variable such that accuracy can be controlled.\n",
    "\n",
    "This explicit method has a fixed order of 2. This is appropriate because the order of the spatial discretization is typically limited too. It is not useful to have a very low error due to time discretization if the error due to space discretization is much larger. Therefore, relatively coarse steps are OK and a low order method is efficient for this.\n",
    "\n",
    "So why not just use an implicit method like `BDF`? Implicit methods need to solve linear systems with the Jacobian of the ODE. This is costly if the system is large, even though very good sparse methods are available. Therefore, implicit methods need to take larger steps to compensate for the extra cost per step, to be competitive. Although implicit method remain stable, they do loose accuracy with larger step size. So step size is typically limited by accuracy and explicit methods can be more efficient.\n",
    "\n",
    "There are limits to this of course. The problem could be too stiff and that stiffness could be negligible for the solution. If this is the case, or if the problem is small, an implicit method would probably work better.\n",
    "\n",
    "One more remark before the demonstration of the method: the constraints of scipy's `solve_ivp` do not favor large problems. The complete solution is kept in memory. Writing previous time steps to disk is not possible. Further development to overcome this and perhaps with numba to improve performance may be needed to make this method really useful for the case it was designed for by Sommeijer. Though then it may be easier to just use the original Fortran code instead.\n",
    "\n",
    "This notebook needs more memory and calculation time than usual.\n",
    "\n",
    "## Combustion problem\n",
    "\n",
    "The problems from the [paper](https://doi.org/10.1016/S0377-0427(97)00219-7) are reproduced. We start with the second one, a combustion problem with concentration $c$ and temperature $T$ fields PDEs:\n",
    "\n",
    "$$ \\dot{c} = \\Delta c - D c e^{-\\delta / T}, \\qquad L \\dot{T} = \\Delta T - \\alpha D c e^{-\\delta / T} $$\n",
    "\n",
    "The model geometry is the unit cube and spatial discretization is done with finite differences with 40 points in each direction. This results in $ 2 \\times 40^3 = 128000 $ degrees of freedom and equations.\n",
    "\n",
    "Initially both fields equal 1. Dirichlet boundary conditions are applied at $x, y, z = 1$ and Neumann boundary conditions at $x, y, z = 0$, to model symmetry.\n",
    "\n",
    "This problem is coded with array operations and 3D arrays with extra nodes to apply the boundary conditions. The discretization along one direction looks like: \n",
    "\n",
    "$$ \\times-|-\\times--\\times--\\times--\\times--|\\times $$\n",
    "\n",
    "with nodes $\\times$ and boundaries $|$. The Neumann boundary at the left is halfway the nodes and the Dirichlet boundary at the right is at the last node. Only the $N=4$ nodes between the boundaries are degrees of freedom for the discretized ODE. The spacing between the nodes is $h=1/(N+0.5)$. For the actual problem we will use N=40, as mentioned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "L = 0.9                                     # Lewis Number\n",
    "alpha = 1.                                  # heat release\n",
    "delta = 20.                                 # activation energy\n",
    "R = 5.                                      # reaction rate\n",
    "D = R * np.exp(delta) / (alpha * delta)     # Damkohler number\n",
    "args = (L, alpha, delta, D)\n",
    "\n",
    "N = 40\n",
    "\n",
    "# expanded work arrays\n",
    "_c = np.ones((N+2, N+2, N+2))\n",
    "_T = np.ones((N+2, N+2, N+2))\n",
    "\n",
    "def Lap(A, h):\n",
    "    \"\"\"Return Laplacian from finite differences\"\"\"\n",
    "    lap = (1. / h**2) * (-6 * A[1:-1, 1:-1, 1:-1] +\n",
    "           A[:-2, 1:-1, 1:-1] + A[2:, 1:-1, 1:-1] + \n",
    "           A[1:-1, :-2, 1:-1] + A[1:-1, 2:, 1:-1] + \n",
    "           A[1:-1, 1:-1, :-2] + A[1:-1, 1:-1, 2:] )\n",
    "    return lap\n",
    "\n",
    "def fun(t, y, L, alpha, delta, D, _c=_c, _T=_T, N=N):\n",
    "    c = y[:N**3].reshape(N, N, N)\n",
    "    T = y[N**3:].reshape(N, N, N)\n",
    "    \n",
    "    # fill work arrays with current solution\n",
    "    _c[1:-1, 1:-1, 1:-1] = c\n",
    "    _T[1:-1, 1:-1, 1:-1] = T\n",
    "    \n",
    "    # Neumann BCs\n",
    "    _c[0, :, :] = _c[1, :, :]\n",
    "    _c[:, 0, :] = _c[:, 1, :]\n",
    "    _c[:, :, 0] = _c[:, :, 1]\n",
    "    _T[0, :, :] = _T[1, :, :]\n",
    "    _T[:, 0, :] = _T[:, 1, :]\n",
    "    _T[:, :, 0] = _T[:, :, 1]\n",
    "    # (Dirichlet BCs are constant)\n",
    "    \n",
    "    Dce = D * c * np.exp(-delta / T)\n",
    "    h = 1. / (N + 0.5)\n",
    "    \n",
    "    # ODEs from discretized PDEs\n",
    "    dc = Lap(_c, h) - Dce\n",
    "    dT = (Lap(_T, h) + alpha * Dce)/L\n",
    "    \n",
    "    return np.concatenate([dc.reshape(-1),\n",
    "                           dT.reshape(-1)])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first solve will be for a slightly longer interval than in the paper to show the boundary layers at the end of the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.integrate import solve_ivp\n",
    "from extensisq import SSV2stab\n",
    "\n",
    "t_span = [0, 0.33]      # boundary layers at 0.33, not at 0.3\n",
    "y0 = np.ones(2*N**3)\n",
    "tol = 1e-4\n",
    "t_eval = [0.2, 0.25, 0.3, 0.31, 0.32, 0.33]\n",
    "\n",
    "sol = solve_ivp(fun, t_span, y0, method=SSV2stab, rtol=tol, atol=tol, \n",
    "                args=args, t_eval=t_eval)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output times in `t_eval` are chosen to show the evolution of the solution. Notice that the steps are more concentrated near the end. In the first few steps, the temperature increases, then combustions occurs at the origin. A sharp front travels quickly to the Dirichlet boundaries. Finally a steady state develops with boundary layers. This is the temperature field in the $x=0$ plane (and without the boundary nodes):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x600 with 7 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "levels = np.linspace(1, 2.1, 12)\n",
    "fig, axs = plt.subplots(2, 3, figsize=(9,6))\n",
    "for t, s, ax in zip(t_eval, sol.y.T, axs.flatten()):\n",
    "    M = s[N**3:].reshape(N, N, N)[0,:,:]\n",
    "    ct = ax.contourf(M, levels=levels, cmap='inferno')\n",
    "    # ax.colorbar(ticks=levels, label='temperature')\n",
    "    ax.set_xticks([])\n",
    "    ax.set_yticks([])\n",
    "    ax.set_title(f'time: {t}')\n",
    "\n",
    "cax = plt.axes([0.15, 0, 0.72, 0.02])\n",
    "plt.colorbar(ct, cax=cax, label='temperature field', orientation='horizontal',\n",
    "             ticks=levels)\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see boundary layer develop after $t=0.32$. The paper mentions that there are already boundary layers at $t=0.3$. So is the problem modelled correctly, and does `SSV2stab` work well? To find out, I will repeat the calculations of the paper.\n",
    "\n",
    "First calculate an accurate reference solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "t_span = [0, 0.30]      # reduce to interval from paper\n",
    "\n",
    "tol = 1e-8\n",
    "ref = solve_ivp(fun, t_span, y0, method=SSV2stab, rtol=tol, atol=tol, \n",
    "                args=args, t_eval=[0.3]).y[:,-1]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now solve for a range of tolerances:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Tol\tError\t Steps \tf-evals\taverage\tf-sigma\t CPU\ts-max\n",
      "1e-04\t0.54\t 51 (1)\t  525\t 10.3 \t  21\t 4.2\t 36\n",
      "1e-05\t0.18\t124 (0)\t  781\t  6.3 \t  27\t 8.3\t 29\n",
      "1e-06\t0.037\t270 (0)\t 1270\t  4.7 \t  39\t10.0\t 20\n",
      "1e-07\t0.0068\t581 (0)\t 2147\t  3.7 \t  65\t13.8\t 14\n"
     ]
    }
   ],
   "source": [
    "from extensisq.sommeijer import maxm, NFS, nfesig\n",
    "from time import perf_counter\n",
    "\n",
    "# now solve for a range of tolerances:\n",
    "tols = np.logspace(-4, -7, 4)\n",
    "\n",
    "print(' Tol\\tError\\t Steps \\tf-evals\\taverage\\tf-sigma\\t CPU\\ts-max')\n",
    "for tol in tols:\n",
    "    timer = perf_counter()\n",
    "    sol = solve_ivp(fun, t_span, y0, method=SSV2stab, rtol=tol, atol=tol, \n",
    "                    args=args)\n",
    "    cpu = perf_counter() - timer\n",
    "    err = np.abs(sol.y[:, -1] - ref).max()\n",
    "    nfs = NFS[()]\n",
    "    nsteps = sol.t.size - 1 + nfs\n",
    "    nfev = sol.nfev\n",
    "    avg = nfev/nsteps\n",
    "    print(f'{tol:.0e}\\t{err:.2g}\\t{nsteps:>3} ({NFS[()]})\\t {nfev:>4}\\t'\n",
    "          f' {avg:>4.1f} \\t  {nfesig}\\t{cpu:>4.1f}\\t {maxm[()]}')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The table shows for the different tolerances: the max error, the number of steps (failed steps in parenthesis), the number of function evaluations for the steps, the average number of evaluations per step, the number of function evaluations that were used for detection of the spectral radius the cpu time and the maximum number of stages per step.\n",
    "\n",
    "The results show that higher accuracy results in more steps, but also in fewer evaluations per step. This is expected, because the stability region scales with step size. So the total cost of the integration increases with higher accuracy, but the cost per step reduces. The number of function evaluations to estimate the spectral radius (f-sigma) increases though. Apparently the spectral radius is estimated more often. (The code estimates it after each failed step and after 25 successful steps.)\n",
    "\n",
    "Comparing this to Table 3 in the [paper](https://doi.org/10.1016/S0377-0427(97)00219-7), we see that only the CPU column, and the error for stricter tolerances are different. Furthermore, the maximum number of stages (last column) conforms to the maximum in Figure 2 of the paper (20 for tolerance 1e-6). This is quite strong evidence that the method works as it should, despite the late appearance of the boundary conditions in the solution observed earlier.\n",
    "\n",
    "## Heat transfer problem\n",
    "\n",
    "The other problem from the paper is a linear heat transfer problem. This problem is repeated as well, because it shows some special arguments that make the solver more efficient in some cases:\n",
    "* 'rho_jac': The user can supply a function f(t, y) that returns the spectral radius as a float, or a conservative estimate of it. This saves on functions evaluations to estimate it (column 'f-sigma' above).\n",
    "* 'const_jac': Let the method know when the Jacobian, and therefore the spectral radius, is constant. This is True for linear problems by definition. When rho_jac is defined, it is called each step if const_jac is False.\n",
    "\n",
    "This problem has Dirichlet boundary conditions all around. Therefore the grid looks like:\n",
    "$$ \\times|--\\times--\\times--\\times--\\times--|\\times $$\n",
    "And the node spacing is $h=1/(N+1)$. The problem is solved in a similar way as before.\n",
    "\n",
    "Solution is the analytic solution of the *continuous* problem.\n",
    "\n",
    "New is the rho_jac function that estimates the spectral radius using [Gershgorin circle theorem](https://en.wikipedia.org/wiki/Gershgorin_circle_theorem). The cost of evaluation this function is clearly negligible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(x, y, z, t):\n",
    "    \"\"\"solution of the continuous problem\"\"\"\n",
    "    return np.tanh(5*x + 10*y + 7.5*z - (2.5 + 5*t))\n",
    "\n",
    "def f(x, y, z, t):\n",
    "    \"\"\"heat source\"\"\"\n",
    "    s = solution(x, y, z, t)\n",
    "    return 362.5*(s - s**3) + 5*s**2 - 5\n",
    "\n",
    "N = 39\n",
    "x = np.linspace(0., 1., N+2)\n",
    "y = np.linspace(0., 1., N+2)\n",
    "z = np.linspace(0., 1., N+2)\n",
    "X, Y, Z = np.meshgrid(x, y, z)\n",
    "Twork = solution(X, Y, Z, 0)\n",
    "y0 = Twork[1:-1, 1:-1, 1:-1].copy().reshape(-1)\n",
    "\n",
    "def fun(t, y, work=Twork, X=X, Y=Y, Z=Z, N=N):\n",
    "    \"\"\"derivative function\"\"\"\n",
    "    \n",
    "    # apply BCs all around (Dirichlet only)\n",
    "    work[0,:,:] = solution(X[0,:,:], Y[0,:,:], Z[0,:,:], t)\n",
    "    work[-1,:,:] = solution(X[-1,:,:], Y[-1,:,:], Z[-1,:,:], t)\n",
    "    work[:,0,:] = solution(X[:,0,:], Y[:,0,:], Z[:,0,:], t)\n",
    "    work[:,-1,:] = solution(X[:,-1,:], Y[:,-1,:], Z[:,-1,:], t)\n",
    "    work[:,:,0] = solution(X[:,:,0], Y[:,:,0], Z[:,:,0], t)\n",
    "    work[:,:,-1] = solution(X[:,:,-1], Y[:,:,-1], Z[:,:,-1], t)\n",
    "    \n",
    "    # insert current values of dofs\n",
    "    work[1:-1, 1:-1, 1:-1] = y.reshape(N, N, N)\n",
    "    \n",
    "    # calculate derivative\n",
    "    h = 1./(N + 1.)\n",
    "    dy = Lap(Twork, h) + f(X, Y, Z, t)[1:-1, 1:-1, 1:-1]\n",
    "    \n",
    "    return dy.reshape(-1)\n",
    "\n",
    "def rho_jac(t, y, N=N):\n",
    "    \"\"\"spectral radius estimate\"\"\"\n",
    "    h = 1./(N + 1.)\n",
    "    return 12 / h**2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We again need a reference solution of the discrete problem with the $N$ value that we use. This is needed because it is not the same as the know analytic continuous solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "tol = 1e-8\n",
    "t_span = (0, 0.7)\n",
    "\n",
    "ref = solve_ivp(fun, t_span, y0, method=SSV2stab, rtol=tol, atol=tol,\n",
    "                const_jac=True, rho_jac=rho_jac, t_eval=[0.7]).y[:,-1]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we solve for a range of tolerances and create a table that compares the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Tol\t Error\t Steps \tf-evals\taverage\tf-sigma\t CPU\ts-max\terror-c\n",
      "1e-01\t8.9e-03\t  6 (1)\t  402\t 67.0 \t  0\t 2.8\t 132\t 0.011 \n",
      "1e-02\t1.7e-03\t 15 (4)\t  729\t 48.6 \t  0\t 5.4\t 85\t 0.0043\n",
      "1e-03\t3.7e-04\t 27 (2)\t  786\t 29.1 \t  0\t 8.5\t 40\t 0.0037\n",
      "1e-04\t3.9e-05\t 57 (0)\t 1087\t 19.1 \t  0\t15.3\t 26\t 0.0036\n",
      "1e-05\t4.3e-06\t129 (1)\t 1682\t 13.0 \t  0\t24.3\t 20\t 0.0036\n",
      "1e-06\t6.5e-07\t262 (0)\t 2445\t  9.3 \t  0\t22.2\t 12\t 0.0036\n"
     ]
    }
   ],
   "source": [
    "# now solve for a range of tolerances:\n",
    "tols = np.logspace(-1, -6, 6)\n",
    "solc = solution(X, Y, Z, 0.7)[1:-1,1:-1,1:-1].reshape(-1)\n",
    "\n",
    "print(' Tol\\t Error\\t Steps \\tf-evals\\taverage\\tf-sigma\\t CPU\\ts-max\\terror-c')\n",
    "for tol in tols:\n",
    "    timer = perf_counter()\n",
    "    sol = solve_ivp(fun, t_span, y0, method=SSV2stab, rtol=tol, atol=tol, \n",
    "                    const_jac=True, rho_jac=rho_jac, dense_output=True)\n",
    "    cpu = perf_counter() - timer\n",
    "    err = np.abs(sol.y[:, -1] - ref).max()\n",
    "    nfs = NFS[()]\n",
    "    nsteps = sol.t.size - 1 + nfs\n",
    "    nfev = sol.nfev\n",
    "    avg = nfev/nsteps\n",
    "    err2 = np.abs(sol.y[:, -1] - solc).max()\n",
    "    print(f'{tol:.0e}\\t{err:6.1e}\\t{nsteps:>3} ({NFS[()]})\\t {nfev:>4}\\t'\n",
    "          f' {avg:>4.1f} \\t  {nfesig}\\t{cpu:>4.1f}\\t {maxm[()]}\\t {err2:<6.2}')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This table can be compared to Table 1 in the paper. It is identical except for the CPU column. The f-sigma column is added to show that no evaluation are needed for the spectral radius estimate anymore if `rho_jac` is given.\n",
    "\n",
    "The error-c column is also interesting. It is the error with respect to the continuous solution (the 'Error' column is regarding the discrete solution). The error-c plateaus at 0.0036. This drives home the point that was made in the introduction that high accuracy is typically not useful in typical method of lines problems. A tolerance between 1e-2 and 1e-3 seems optimal for this problem with $N=40$. For more accuracy, $N$ should be increased next to lowering `tol`. This results in much higher computational costs, because the number of DOFs scale with $N^3$.\n",
    "\n",
    "## Conclusions\n",
    "\n",
    "`SSV2stab` is an interesting method that stretches the stability domain in order to solve mildly stiff problems explicitly. It is most useful for larger problems such as those discretized PDE's (method of lines). This type of problems is arguably not the best fit for solve_ivp, or even for Python in general, but extensisq's `SSV2stab` may be useful for some experimentation and development nevertheless."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "dev_extensisq",
   "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.10.8"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "833bf39955edf584fc9acac7f908f192d651332122fd4f585265fc62ce0e7fa1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}