{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Devito domain specific language: an overview\n",
    "\n",
    "This notebook presents an overview of the Devito symbolic language, used to express and discretise operators, in particular partial differential equations (PDEs).\n",
    "\n",
    "For convenience, we import all Devito modules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from devito import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## From equations to code in a few lines of Python\n",
    "\n",
    "The main objective of this tutorial is to demonstrate how Devito and its [SymPy](http://www.sympy.org/en/index.html)-powered symbolic API can be used to solve partial differential equations using the finite difference method with highly optimized stencils in a few lines of Python. We demonstrate how computational stencils can be derived directly from the equation in an automated fashion and how Devito can be used to generate and execute, at runtime, the desired numerical scheme in the form of optimized C code.\n",
    "\n",
    "\n",
    "## Defining the physical domain\n",
    "\n",
    "Before we can begin creating finite-difference (FD) stencils we will need to give Devito a few details regarding the computational domain within which we wish to solve our problem. For this purpose we create a `Grid` object that stores the physical `extent` (the size) of our domain and knows how many points we want to use in each dimension to discretise our data.\n",
    "\n",
    "<img src=\"figures/grid.png\" style=\"width: 220px;\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Grid[extent=(1.0, 1.0), shape=(5, 6), dimensions=(x, y)]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid = Grid(shape=(5, 6), extent=(1., 1.))\n",
    "grid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions and data\n",
    "\n",
    "To express our equation in symbolic form and discretise it using finite differences, Devito provides a set of `Function` types. A `Function` object:\n",
    "\n",
    "1. Behaves like a `sympy.Function` symbol\n",
    "2. Manages data associated with the symbol\n",
    "\n",
    "To get more information on how to create and use a `Function` object, or any type provided by Devito, we can take a look at the documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    Tensor symbol representing a discrete function in symbolic equations.\n",
      "\n",
      "    A Function carries multi-dimensional data and provides operations to create\n",
      "    finite-differences approximations.\n",
      "\n",
      "    A Function encapsulates space-varying data; for data that also varies in time,\n",
      "    use TimeFunction instead.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    name : str\n",
      "        Name of the symbol.\n",
      "    grid : Grid, optional\n",
      "        Carries shape, dimensions, and dtype of the Function. When grid is not\n",
      "        provided, shape and dimensions must be given. For MPI execution, a\n",
      "        Grid is compulsory.\n",
      "    space_order : int or 3-tuple of ints, optional, default=1\n",
      "        Discretisation order for space derivatives.\n",
      "        `space_order` also impacts the number of points available around a\n",
      "        generic point of interest.  By default, `space_order` points are\n",
      "        available on both sides of a generic point of interest, including those\n",
      "        nearby the grid boundary. Sometimes, fewer points suffice; in other\n",
      "        scenarios, more points are necessary. In such cases, instead of an\n",
      "        integer, one can pass:\n",
      "          * a 3-tuple `(o, lp, rp)` indicating the discretization order\n",
      "            (`o`) as well as the number of points on the left (`lp`) and\n",
      "            right (`rp`) sides of a generic point of interest;\n",
      "          * a 2-tuple `(o, ((lp0, rp0), (lp1, rp1), ...))` indicating the\n",
      "            discretization order (`o`) as well as the number of points on\n",
      "            the left/right sides of a generic point of interest for each\n",
      "            SpaceDimension.\n",
      "    interp_order: int, optional, default=2\n",
      "        Order of the interpolation scheme used to evaluate the Function at\n",
      "        non-grid points (e.g., when using a Function as a parameter to be\n",
      "        evaluated at a staggered location).\n",
      "    shape : tuple of ints, optional\n",
      "        Shape of the domain region in grid points. Only necessary if `grid`\n",
      "        isn't given.\n",
      "    dimensions : tuple of Dimension, optional\n",
      "        Dimensions associated with the object. Only necessary if `grid` isn't\n",
      "        given.\n",
      "    dtype : data-type, optional, default=np.float32\n",
      "        Any object that can be interpreted as a numpy data type.\n",
      "    staggered : Dimension or tuple of Dimension or Stagger, optional, default=None\n",
      "        Define how the Function is staggered.\n",
      "    initializer : callable or any object exposing the buffer interface, default=None\n",
      "        Data initializer. If a callable is provided, data is allocated lazily.\n",
      "    allocator : MemoryAllocator, optional\n",
      "        Controller for memory allocation. To be used, for example, when one wants\n",
      "        to take advantage of the memory hierarchy in a NUMA architecture. Refer to\n",
      "        `default_allocator.__doc__` for more information.\n",
      "    padding : int or tuple of ints, optional\n",
      "        Allocate extra grid points to maximize data access alignment. When a tuple\n",
      "        of ints, one int per Dimension should be provided.\n",
      "\n",
      "    Examples\n",
      "    --------\n",
      "    Creation\n",
      "\n",
      "    >>> from devito import Grid, Function\n",
      "    >>> grid = Grid(shape=(4, 4))\n",
      "    >>> f = Function(name='f', grid=grid)\n",
      "    >>> f\n",
      "    f(x, y)\n",
      "    >>> g = Function(name='g', grid=grid, space_order=2)\n",
      "    >>> g\n",
      "    g(x, y)\n",
      "\n",
      "    First-order derivatives through centered finite-difference approximations\n",
      "\n",
      "    >>> f.dx\n",
      "    Derivative(f(x, y), x)\n",
      "    >>> f.dy\n",
      "    Derivative(f(x, y), y)\n",
      "    >>> g.dx\n",
      "    Derivative(g(x, y), x)\n",
      "    >>> (f + g).dx\n",
      "    Derivative(f(x, y) + g(x, y), x)\n",
      "\n",
      "    First-order derivatives through left/right finite-difference approximations\n",
      "\n",
      "    >>> f.dxl\n",
      "    Derivative(f(x, y), x)\n",
      "\n",
      "    Note that the fact that it's a left-derivative isn't captured in the representation.\n",
      "    However, upon derivative expansion, this becomes clear\n",
      "\n",
      "    >>> f.dxl.evaluate\n",
      "    f(x, y)/h_x - f(x - h_x, y)/h_x\n",
      "    >>> f.dxr\n",
      "    Derivative(f(x, y), x)\n",
      "\n",
      "    Second-order derivative through centered finite-difference approximation\n",
      "\n",
      "    >>> g.dx2\n",
      "    Derivative(g(x, y), (x, 2))\n",
      "\n",
      "    Notes\n",
      "    -----\n",
      "    The parameters must always be given as keyword arguments, since SymPy\n",
      "    uses `*args` to (re-)create the dimension arguments of the symbolic object.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(Function.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, let's create a function $f(x, y)$ and look at the data Devito has associated with it. Please note that it is important to use explicit keywords, such as `name` or `grid` when creating `Function` objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f(x, y)$"
      ],
      "text/plain": [
       "f(x, y)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = Function(name='f', grid=grid)\n",
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Data([[0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, Devito `Function` objects use the spatial dimensions `(x, y)` for 2D grids and `(x, y, z)` for 3D grids. To solve a PDE over several timesteps a time dimension is also required by our symbolic function. For this Devito provides an additional function type, the `TimeFunction`, which incorporates the correct dimension along with some other intricacies needed to create a time stepping scheme."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle g(t, x, y)$"
      ],
      "text/plain": [
       "g(t, x, y)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = TimeFunction(name='g', grid=grid)\n",
    "g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the default time order of a `TimeFunction` is `1`, the shape of `f` is `(2, 5, 6)`, i.e. Devito has allocated two buffers to represent `g(t, x, y)` and `g(t + dt, x, y)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 5, 6)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Derivatives of symbolic functions\n",
    "\n",
    "The functions we have created so far all act as `sympy.Function` objects, which means that we can form symbolic derivative expressions from them. Devito provides a set of shorthand expressions (implemented as Python properties) that allow us to generate finite differences in symbolic form. For example, the property `f.dx` denotes $\\frac{\\partial}{\\partial x} f(x, y)$ - only that Devito has already discretised it with a finite difference expression. There are also a set of shorthand expressions for left (backward) and right (forward) derivatives:\n",
    "\n",
    "| Derivative | Shorthand | Discretised | Stencil |\n",
    "| ---------- |:---------:|:-----------:|:-------:|\n",
    "| $\\frac{\\partial}{\\partial x}f(x, y)$ (right) | `f.dxr` | $\\frac{f(x+h_x,y)}{h_x} - \\frac{f(x,y)}{h_x}$ | <img src=\"figures/stencil_forward.png\" style=\"width: 180px;\"/> |\n",
    "| $\\frac{\\partial}{\\partial x}f(x, y)$ (left) | `f.dxl` | $\\frac{f(x,y)}{h_x} - \\frac{f(x-h_x,y)}{h_x}$ | <img src=\"figures/stencil_backward.png\" style=\"width: 180px;\"/> |\n",
    "\n",
    "A similar set of expressions exist for each spatial dimension defined on our grid, for example `f.dy` and `f.dyl`. Obviously, one can also take derivatives in time of `TimeFunction` objects. For example, to take the first derivative in time of `g` you can simply write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial t} g(t, x, y)$"
      ],
      "text/plain": [
       "Derivative(g(t, x, y), t)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.dt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We may also want to take a look at the stencil Devito will generate based on the chosen discretisation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{g(t, x, y)}{dt} + \\frac{g(t + dt, x, y)}{dt}$"
      ],
      "text/plain": [
       "-g(t, x, y)/dt + g(t + dt, x, y)/dt"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.dt.evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There also exist convenient shortcuts to express the forward and backward stencil points, `g(t+dt, x, y)` and `g(t-dt, x, y)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle g(t + dt, x, y)$"
      ],
      "text/plain": [
       "g(t + dt, x, y)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle g(t - dt, x, y)$"
      ],
      "text/plain": [
       "g(t - dt, x, y)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.backward"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And of course, there's nothing to stop us taking derivatives on these objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial t} g(t + dt, x, y)$"
      ],
      "text/plain": [
       "Derivative(g(t + dt, x, y), t)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.forward.dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial y} g(t + dt, x, y)$"
      ],
      "text/plain": [
       "Derivative(g(t + dt, x, y), y)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.forward.dy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 45-Degree Rotated Finite Differences\n",
    "\n",
    "Rotated finite differences, when applied at a 45-degree angle, harness a unique isotropic discretization strategy for solving partial differential equations (PDEs) on a two-dimensional grid. This approach modifies the traditional finite difference stencil by rotating the coordinate system, specifically by 45 degrees, to better align with the problem's directional sensitivities. The mathematical transformations for this rotation are straightforward yet powerful, given by:\n",
    "\n",
    "$$x' = \\frac{x + y}{\\sqrt{2}}, \\quad y' = \\frac{y - x}{\\sqrt{2}}$$\n",
    "\n",
    "where $(x, y)$ and $(x', y')$ are the original and rotated coordinates, respectively.\n",
    "\n",
    "## Mathematical Definitions\n",
    "\n",
    "The partial derivatives in the rotated system become:\n",
    "\n",
    "$$\\frac{\\partial f}{\\partial x'} \\approx \\frac{f(x'+\\Delta x', y') - f(x'-\\Delta x', y')}{2\\Delta x'}$$\n",
    "$$\\frac{\\partial f}{\\partial y'} \\approx \\frac{f(x', y'+\\Delta y') - f(x', y'-\\Delta y')}{2\\Delta y'}$$\n",
    "\n",
    "Here, $\\Delta x'$ and $\\Delta y'$ represent the grid spacing in the rotated coordinates, which effectively equals the original grid spacing scaled by $\\sqrt{2}$.\n",
    "\n",
    "## Use Case and Advantages\n",
    "\n",
    "The 45-degree rotated finite difference method shines in scenarios where PDEs exhibit significant diagonal features or anisotropic behaviors. Traditional finite difference stencils, aligned with the Cartesian grid, can introduce numerical errors or fail to capture the essence of such phenomena accurately. By rotating the stencil, this method ensures a more symmetric and isotropic treatment of the grid points, leading to enhanced accuracy and stability in numerical simulations.\n",
    "\n",
    "### Advantages Include:\n",
    "\n",
    "- **Reduced Numerical Dispersion:** By capturing diagonal relationships more naturally, this method mitigates the dispersion errors commonly seen in conventional finite difference schemes.\n",
    "- **Enhanced Anisotropy Representation:** It offers a superior framework for simulating physical phenomena where directional dependencies are not aligned with the standard Cartesian axes.\n",
    "- **Improved Accuracy:** The isotropic discretization helps in achieving higher accuracy, especially for problems with inherent diagonal or anisotropic features.\n",
    "\n",
    "The 45-degree rotated finite difference method is a powerful tool for numerical analysts and engineers, providing a nuanced approach to solving complex PDEs with improved fidelity to the physical and geometric intricacies of the underlying problem.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial x} f(x, y)$"
      ],
      "text/plain": [
       "Derivative(f(x, y), x)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.dx45"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(- \\frac{f(x, y)}{2 h_{x}} + \\frac{f(x + h_x, y - h_y)}{2 h_{x}}\\right) + \\left(- \\frac{f(x, y)}{2 h_{x}} + \\frac{f(x + h_x, y + h_y)}{2 h_{x}}\\right)$"
      ],
      "text/plain": [
       "-f(x, y)/(2*h_x) + f(x + h_x, y - h_y)/(2*h_x) - f(x, y)/(2*h_x) + f(x + h_x, y + h_y)/(2*h_x)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.dx45.evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A linear convection operator\n",
    "\n",
    "**Note:** The following example is derived from [step 5](http://nbviewer.ipython.org/github/barbagroup/CFDPython/blob/master/lessons/07_Step_5.ipynb) in the excellent tutorial series [CFD Python: 12 steps to Navier-Stokes](http://lorenabarba.com/blog/cfd-python-12-steps-to-navier-stokes/).\n",
    "\n",
    "In this simple example we will show how to derive a very simple convection operator from a high-level description of the governing equation. We will go through the process of deriving a discretised finite difference formulation of the state update for the field variable $u$, before creating a callable `Operator` object. Luckily, the automation provided by SymPy makes the derivation very nice and easy.\n",
    "\n",
    "The governing equation we want to implement is the linear convection equation:\n",
    "$$\\frac{\\partial u}{\\partial t}+c\\frac{\\partial u}{\\partial x} + c\\frac{\\partial u}{\\partial y} = 0.$$\n",
    "\n",
    "Before we begin, we must define some parameters including the grid, the number of timesteps and the timestep size. We will also initialize our velocity `u` with a smooth field:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": [
     "nbval-ignore-output"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from examples.cfd import init_smooth, plot_field\n",
    "\n",
    "nt = 100  # Number of timesteps\n",
    "dt = 0.2 * 2. / 80  # Timestep size (sigma=0.2)\n",
    "c = 1  # Value for c\n",
    "\n",
    "# Then we create a grid and our function\n",
    "grid = Grid(shape=(81, 81), extent=(2., 2.))\n",
    "u = TimeFunction(name='u', grid=grid)\n",
    "\n",
    "# We can now set the initial condition and plot it\n",
    "init_smooth(field=u.data[0], dx=grid.spacing[0], dy=grid.spacing[1])\n",
    "init_smooth(field=u.data[1], dx=grid.spacing[0], dy=grid.spacing[1])\n",
    "\n",
    "plot_field(u.data[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we wish to discretise our governing equation so that a functional `Operator` can be created from it. We begin by simply writing out the equation as a symbolic expression, while using shorthand expressions for the derivatives provided by the `Function` object. This will create a symbolic object of the dicretised equation.\n",
    "\n",
    "Using the Devito shorthand notation, we can express the governing equations as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial x} u(t, x, y) + \\frac{\\partial}{\\partial y} u(t, x, y) + \\frac{\\partial}{\\partial t} u(t, x, y) = 0$"
      ],
      "text/plain": [
       "Eq(Derivative(u(t, x, y), x) + Derivative(u(t, x, y), y) + Derivative(u(t, x, y), t), 0)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq = Eq(u.dt + c * u.dxl + c * u.dyl)\n",
    "eq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now need to rearrange our equation so that the term $u(t+dt, x, y)$ is on the left-hand side, since it represents the next point in time for our state variable $u$. Devito provides a utility called `solve`, built on top of SymPy's `solve`, to rearrange our equation so that it represents a valid state update for $u$. Here, we use `solve` to create a valid stencil for our update to `u(t+dt, x, y)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle u(t + dt, x, y) = dt \\left(- \\frac{\\partial}{\\partial x} u(t, x, y) - \\frac{\\partial}{\\partial y} u(t, x, y) + \\frac{u(t, x, y)}{dt}\\right)$"
      ],
      "text/plain": [
       "Eq(u(t + dt, x, y), dt*(-Derivative(u(t, x, y), x) - Derivative(u(t, x, y), y) + u(t, x, y)/dt))"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stencil = solve(eq, u.forward)\n",
    "update = Eq(u.forward, stencil)\n",
    "update"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The right-hand side of the 'update' equation should be a stencil of the shape\n",
    "<img src=\"figures/stencil_convection.png\" style=\"width: 160px;\"/>\n",
    "\n",
    "Once we have created this 'update' expression, we can create a Devito `Operator`. This `Operator` will basically behave like a Python function that we can call to apply the created stencil over our associated data, as long as we provide all necessary unknowns. In this case we need to provide the number of timesteps to compute via the keyword `time` and the timestep size via `dt` (both have been defined above):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": [
     "nbval-ignore-output"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Kernel` ran in 0.07 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "op = Operator(update, opt='noop')\n",
    "op(time=nt+1, dt=dt)\n",
    "\n",
    "plot_field(u.data[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the real power of Devito is hidden within `Operator`, it will automatically generate and compile the optimized C code. We can look at this code (noting that this is not a requirement of executing it) via:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "tags": [
     "nbval-ignore-output"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/* Devito generated code for Operator `Kernel` */\n",
      "\n",
      "#define _POSIX_C_SOURCE 200809L\n",
      "#define START(S) struct timeval start_ ## S , end_ ## S ; gettimeofday(&start_ ## S , NULL);\n",
      "#define STOP(S,T) gettimeofday(&end_ ## S, NULL); T->S += (double)(end_ ## S .tv_sec-start_ ## S.tv_sec)+(double)(end_ ## S .tv_usec-start_ ## S .tv_usec)/1000000;\n",
      "\n",
      "#include \"stdlib.h\"\n",
      "#include \"math.h\"\n",
      "#include \"sys/time.h\"\n",
      "#include \"omp.h\"\n",
      "\n",
      "struct dataobj\n",
      "{\n",
      "  void *restrict data;\n",
      "  int * size;\n",
      "  unsigned long nbytes;\n",
      "  unsigned long * npsize;\n",
      "  unsigned long * dsize;\n",
      "  int * hsize;\n",
      "  int * hofs;\n",
      "  int * oofs;\n",
      "  void * dmap;\n",
      "} ;\n",
      "\n",
      "struct profiler\n",
      "{\n",
      "  double section0;\n",
      "} ;\n",
      "\n",
      "\n",
      "int Kernel(struct dataobj *restrict u_vec, const float dt, const float h_x, const float h_y, const int time_M, const int time_m, const int x_M, const int x_m, const int y_M, const int y_m, const int nthreads, struct profiler * timers)\n",
      "{\n",
      "  float (*restrict u)[u_vec->size[1]][u_vec->size[2]] __attribute__ ((aligned (64))) = (float (*)[u_vec->size[1]][u_vec->size[2]]) u_vec->data;\n",
      "\n",
      "  for (int time = time_m, t0 = (time)%(2), t1 = (time + 1)%(2); time <= time_M; time += 1, t0 = (time)%(2), t1 = (time + 1)%(2))\n",
      "  {\n",
      "    START(section0)\n",
      "    #pragma omp parallel num_threads(nthreads)\n",
      "    {\n",
      "      #pragma omp for collapse(2) schedule(dynamic,1)\n",
      "      for (int x = x_m; x <= x_M; x += 1)\n",
      "      {\n",
      "        for (int y = y_m; y <= y_M; y += 1)\n",
      "        {\n",
      "          u[t1][x + 1][y + 1] = dt*(-(-u[t0][x][y + 1]/h_x + u[t0][x + 1][y + 1]/h_x) - (-u[t0][x + 1][y]/h_y + u[t0][x + 1][y + 1]/h_y) + u[t0][x + 1][y + 1]/dt);\n",
      "        }\n",
      "      }\n",
      "    }\n",
      "    STOP(section0,timers)\n",
      "  }\n",
      "\n",
      "  return 0;\n",
      "}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(op.ccode)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Second derivatives and high-order stencils\n",
    "\n",
    "In the above example only a combination of first derivatives was present in the governing equation. However, second (or higher) order derivatives are often present in scientific problems of interest, notably any PDE modeling diffusion. To generate second order derivatives we must give the `devito.Function` object another piece of information: the desired discretisation of the stencil(s).\n",
    "\n",
    "First, lets define a simple second derivative in `x`, for which we need to give $u$ a `space_order` of (at least) `2`. The shorthand for this second derivative is `u.dx2`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u(t, x, y)$"
      ],
      "text/plain": [
       "Derivative(u(t, x, y), (x, 2))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = TimeFunction(name='u', grid=grid, space_order=2)\n",
    "u.dx2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{2.0 u(t, x, y)}{h_{x}^{2}} + \\frac{u(t, x - h_x, y)}{h_{x}^{2}} + \\frac{u(t, x + h_x, y)}{h_{x}^{2}}$"
      ],
      "text/plain": [
       "-2.0*u(t, x, y)/h_x**2 + u(t, x - h_x, y)/h_x**2 + u(t, x + h_x, y)/h_x**2"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.dx2.evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can increase the discretisation arbitrarily if we wish to specify higher order FD stencils:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u(t, x, y)$"
      ],
      "text/plain": [
       "Derivative(u(t, x, y), (x, 2))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = TimeFunction(name='u', grid=grid, space_order=4)\n",
    "u.dx2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{2.5 u(t, x, y)}{h_{x}^{2}} - \\frac{0.0833333333 u(t, x - 2*h_x, y)}{h_{x}^{2}} + \\frac{1.33333333 u(t, x - h_x, y)}{h_{x}^{2}} + \\frac{1.33333333 u(t, x + h_x, y)}{h_{x}^{2}} - \\frac{0.0833333333 u(t, x + 2*h_x, y)}{h_{x}^{2}}$"
      ],
      "text/plain": [
       "-2.5*u(t, x, y)/h_x**2 - 0.0833333333*u(t, x - 2*h_x, y)/h_x**2 + 1.33333333*u(t, x - h_x, y)/h_x**2 + 1.33333333*u(t, x + h_x, y)/h_x**2 - 0.0833333333*u(t, x + 2*h_x, y)/h_x**2"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.dx2.evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To implement the diffusion or wave equations, we must take the Laplacian $\\nabla^2 u$, which is the sum of the second derivatives in all spatial dimensions. For this, Devito also provides a shorthand expression, which means we do not have to hard-code the problem dimension (2D or 3D) in the code. To change the problem dimension we can create another `Grid` object and use this to re-define our `Function`'s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle u(t, x, y, z)$"
      ],
      "text/plain": [
       "u(t, x, y, z)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid_3d = Grid(shape=(5, 6, 7), extent=(1., 1., 1.))\n",
    "\n",
    "u = TimeFunction(name='u', grid=grid_3d, space_order=2)\n",
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can re-define our function `u` with a different `space_order` argument to change the discretisation order of the stencil expression created. For example, we can derive an expression of the 12th-order Laplacian $\\nabla^2 u$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u(t, x, y, z) + \\frac{\\partial^{2}}{\\partial y^{2}} u(t, x, y, z) + \\frac{\\partial^{2}}{\\partial z^{2}} u(t, x, y, z)$"
      ],
      "text/plain": [
       "Derivative(u(t, x, y, z), (x, 2)) + Derivative(u(t, x, y, z), (y, 2)) + Derivative(u(t, x, y, z), (z, 2))"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = TimeFunction(name='u', grid=grid_3d, space_order=12)\n",
    "u.laplace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same expression could also have been generated explicitly via:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u(t, x, y, z) + \\frac{\\partial^{2}}{\\partial y^{2}} u(t, x, y, z) + \\frac{\\partial^{2}}{\\partial z^{2}} u(t, x, y, z)$"
      ],
      "text/plain": [
       "Derivative(u(t, x, y, z), (x, 2)) + Derivative(u(t, x, y, z), (y, 2)) + Derivative(u(t, x, y, z), (z, 2))"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.dx2 + u.dy2 + u.dz2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Derivatives of composite expressions\n",
    "\n",
    "Derivatives of any arbitrary expression can easily be generated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = TimeFunction(name='u', grid=grid, space_order=2)\n",
    "v = TimeFunction(name='v', grid=grid, space_order=2, time_order=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u(t, x, y) + \\frac{\\partial^{2}}{\\partial y^{2}} u(t, x, y) + \\frac{\\partial^{2}}{\\partial t^{2}} v(t, x, y)$"
      ],
      "text/plain": [
       "Derivative(u(t, x, y), (x, 2)) + Derivative(u(t, x, y), (y, 2)) + Derivative(v(t, x, y), (t, 2))"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.dt2 + u.laplace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} \\left(\\frac{\\partial^{2}}{\\partial x^{2}} u(t, x, y) + \\frac{\\partial^{2}}{\\partial y^{2}} u(t, x, y) + \\frac{\\partial^{2}}{\\partial t^{2}} v(t, x, y)\\right)$"
      ],
      "text/plain": [
       "Derivative(Derivative(u(t, x, y), (x, 2)) + Derivative(u(t, x, y), (y, 2)) + Derivative(v(t, x, y), (t, 2)), (x, 2))"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(v.dt2 + u.laplace).dx2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which can, depending on the chosen discretisation, lead to fairly complex stencils: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{2.0 \\left(\\left(- \\frac{2.0 v(t, x, y)}{dt^{2}} + \\frac{v(t - dt, x, y)}{dt^{2}} + \\frac{v(t + dt, x, y)}{dt^{2}}\\right) + \\left(- \\frac{2.0 u(t, x, y)}{h_{x}^{2}} + \\frac{u(t, x - h_x, y)}{h_{x}^{2}} + \\frac{u(t, x + h_x, y)}{h_{x}^{2}}\\right) + \\left(- \\frac{2.0 u(t, x, y)}{h_{y}^{2}} + \\frac{u(t, x, y - h_y)}{h_{y}^{2}} + \\frac{u(t, x, y + h_y)}{h_{y}^{2}}\\right)\\right)}{h_{x}^{2}} + \\frac{\\left(- \\frac{2.0 v(t, x - h_x, y)}{dt^{2}} + \\frac{v(t - dt, x - h_x, y)}{dt^{2}} + \\frac{v(t + dt, x - h_x, y)}{dt^{2}}\\right) + \\left(\\frac{u(t, x, y)}{h_{x}^{2}} + \\frac{u(t, x - 2*h_x, y)}{h_{x}^{2}} - \\frac{2.0 u(t, x - h_x, y)}{h_{x}^{2}}\\right) + \\left(- \\frac{2.0 u(t, x - h_x, y)}{h_{y}^{2}} + \\frac{u(t, x - h_x, y - h_y)}{h_{y}^{2}} + \\frac{u(t, x - h_x, y + h_y)}{h_{y}^{2}}\\right)}{h_{x}^{2}} + \\frac{\\left(- \\frac{2.0 v(t, x + h_x, y)}{dt^{2}} + \\frac{v(t - dt, x + h_x, y)}{dt^{2}} + \\frac{v(t + dt, x + h_x, y)}{dt^{2}}\\right) + \\left(\\frac{u(t, x, y)}{h_{x}^{2}} - \\frac{2.0 u(t, x + h_x, y)}{h_{x}^{2}} + \\frac{u(t, x + 2*h_x, y)}{h_{x}^{2}}\\right) + \\left(- \\frac{2.0 u(t, x + h_x, y)}{h_{y}^{2}} + \\frac{u(t, x + h_x, y - h_y)}{h_{y}^{2}} + \\frac{u(t, x + h_x, y + h_y)}{h_{y}^{2}}\\right)}{h_{x}^{2}}$"
      ],
      "text/plain": [
       "-2.0*(-2.0*v(t, x, y)/dt**2 + v(t - dt, x, y)/dt**2 + v(t + dt, x, y)/dt**2 - 2.0*u(t, x, y)/h_x**2 + u(t, x - h_x, y)/h_x**2 + u(t, x + h_x, y)/h_x**2 - 2.0*u(t, x, y)/h_y**2 + u(t, x, y - h_y)/h_y**2 + u(t, x, y + h_y)/h_y**2)/h_x**2 + (-2.0*v(t, x - h_x, y)/dt**2 + v(t - dt, x - h_x, y)/dt**2 + v(t + dt, x - h_x, y)/dt**2 + u(t, x, y)/h_x**2 + u(t, x - 2*h_x, y)/h_x**2 - 2.0*u(t, x - h_x, y)/h_x**2 - 2.0*u(t, x - h_x, y)/h_y**2 + u(t, x - h_x, y - h_y)/h_y**2 + u(t, x - h_x, y + h_y)/h_y**2)/h_x**2 + (-2.0*v(t, x + h_x, y)/dt**2 + v(t - dt, x + h_x, y)/dt**2 + v(t + dt, x + h_x, y)/dt**2 + u(t, x, y)/h_x**2 - 2.0*u(t, x + h_x, y)/h_x**2 + u(t, x + 2*h_x, y)/h_x**2 - 2.0*u(t, x + h_x, y)/h_y**2 + u(t, x + h_x, y - h_y)/h_y**2 + u(t, x + h_x, y + h_y)/h_y**2)/h_x**2"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(v.dt2 + u.laplace).dx2.evaluate"
   ]
  }
 ],
 "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.11.0rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}