02_intro_devito-building_propagator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install devito"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2: Introduction to Devito\n",
    "\n",
    "- Devito is a domain specific language (DSL) for formulating partial differential solvers in the form of finite difference operators.\n",
    "- From a users perspective, they formulate the problem in a similar manner to how they would on pen and paper.\n",
    "- Devito then compiles this formulation into c code optimized for the target platform.\n",
    "- A main target application of Devito is producing wave-propagation kernels for use in inversion/imaging frameworks (RTM and FWI).\n",
    "\n",
    "In this notebook we will introduce ourselves to the Devito DSL and then build a wave-propagator.\n",
    "\n",
    "For convenience, we import all Devito modules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from devito import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# From equations to code in a few lines of Python\n",
    "\n",
    "## Goals:\n",
    "\n",
    "- Introduce users to some of the core *Devito* objects including grids (`Grid`), functions (`Function`, `TimeFunction`), equations (`Eq`) and operators (`Operator`)\n",
    "- Illustrate how the DSL can be used to produce a range of finite difference (FD) stencils\n",
    "- Execute a simple operator\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: 320px;\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Grid[extent=(1.0, 1.0), shape=(5, 6), dimensions=(x, y)]"
      ]
     },
     "execution_count": 3,
     "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": 4,
   "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\n",
      "        Discretisation order for space derivatives. Defaults to 1. ``space_order`` also\n",
      "        impacts the number of points available around a generic point of interest.  By\n",
      "        default, ``space_order`` points are available on both sides of a generic point of\n",
      "        interest, including those nearby the grid boundary. Sometimes, fewer points\n",
      "        suffice; in other scenarios, more points are necessary. In such cases, instead of\n",
      "        an integer, one can pass a 3-tuple ``(o, lp, rp)`` indicating the discretization\n",
      "        order (``o``) as well as the number of points on the left (``lp``) and right\n",
      "        (``rp``) sides of a generic point of interest.\n",
      "    shape : tuple of ints, optional\n",
      "        Shape of the domain region in grid points. Only necessary if ``grid`` isn't given.\n",
      "    dimensions : tuple of Dimension, optional\n",
      "        Dimensions associated with the object. Only necessary if ``grid`` isn't given.\n",
      "    dtype : data-type, optional\n",
      "        Any object that can be interpreted as a numpy data type. Defaults\n",
      "        to ``np.float32``.\n",
      "    staggered : Dimension or tuple of Dimension or Stagger, optional\n",
      "        Define how the Function is staggered.\n",
      "    initializer : callable or any object exposing the buffer interface, optional\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",
      "        .. deprecated:: shouldn't be used; padding is now automatically inserted.\n",
      "\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": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f{\\left(x,y \\right)}$"
      ],
      "text/plain": [
       "f(x, y)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = Function(name='f', grid=grid)\n",
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": 6,
     "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": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle g{\\left(t,x,y \\right)}$"
      ],
      "text/plain": [
       "g(t, x, y)"
      ]
     },
     "execution_count": 7,
     "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": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 5, 6)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Forming finite difference schemes\n",
    "\n",
    "Let us start by considering the simple example of 2D linear convection. But first, lets review some basics of finite differences.\n",
    "\n",
    "Recall that the Taylor series of $f(x,t)$ in the spatial dimension takes the form\n",
    "\n",
    "\\begin{equation*}\n",
    " f(x+h,t)=f(x,t)+\\frac{\\partial f}{\\partial x}h+\\frac{1}{2}\\frac{\\partial^2 f}{\\partial x^2}h^2+\\frac{1}{3!}\\frac{\\partial^3 f}{\\partial x^3}h^3+\\frac{1}{4!}\\frac{\\partial^4 f}{\\partial x^4}h^4+\\ldots.\n",
    "\\end{equation*}\n",
    "\n",
    "We can re-arrange the above expansion in the form\n",
    "\n",
    "\\begin{equation*}\n",
    " \\frac{\\partial f}{\\partial x}=\\frac{f(x+h,t)-f(x,t)}{h}-\\frac{1}{h}\\sum_{n=2}^{\\infty}\\frac{1}{n!}\\frac{\\partial^n f}{\\partial x^n}h^n.\n",
    "\\end{equation*}\n",
    "\n",
    "Thus, provided $h$ is small we can say\n",
    "\n",
    "\\begin{equation*}\n",
    " \\frac{\\partial f}{\\partial x}\\approx\\frac{f(x+h,t)-f(x,t)}{h},\n",
    "\\end{equation*}\n",
    "\n",
    "which will have an associated error\n",
    "\n",
    "\\begin{equation*}\n",
    "-\\frac{1}{h}\\sum_{n=2}^{\\infty}\\frac{1}{n!}\\frac{\\partial^n f}{\\partial x^n}h^n\n",
    "\\end{equation*}\n",
    "\n",
    "This is the well known *forward difference* approximation (or the *right* derivative) and is how spatial derivatives are approximated in 'space order' 1 finite difference schemes.\n",
    "\n",
    "We can also write the following Taylor expansion\n",
    "\n",
    "\\begin{equation*}\n",
    " f(x-h,t)=f(x,t)-\\frac{\\partial f}{\\partial x}h+\\frac{1}{2}\\frac{\\partial^2 f}{\\partial x^2}h^2-\\frac{1}{3!}\\frac{\\partial^3 f}{\\partial x^3}h^3+\\frac{1}{4!}\\frac{\\partial^4 f}{\\partial x^4}h^4+\\ldots.\n",
    "\\end{equation*}\n",
    "\n",
    "This leads to the backward difference (or *left* derivative) approximation:\n",
    "\n",
    "\\begin{equation*}\n",
    " \\frac{\\partial f}{\\partial x}\\approx\\frac{f(x,t)-f(x-h,t)}{h}.\n",
    "\\end{equation*}\n",
    "\n",
    "In Devito, these derivatives can be represented via the following symbolic notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial x} f{\\left(x,y \\right)}$"
      ],
      "text/plain": [
       "Derivative(f(x, y), x)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.dxr # Forward difference/right derivative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial x} f{\\left(x,y \\right)}$"
      ],
      "text/plain": [
       "Derivative(f(x, y), x)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.dxl # Backward difference/left derivative"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And to see the actual stencils they represent, we enduce the `evaluate` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{f{\\left(x,y \\right)}}{h_{x}} + \\frac{f{\\left(x + h_{x},y \\right)}}{h_{x}}$"
      ],
      "text/plain": [
       "-f(x, y)/h_x + f(x + h_x, y)/h_x"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.dxr.evaluate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{f{\\left(x,y \\right)}}{h_{x}} - \\frac{f{\\left(x - h_{x},y \\right)}}{h_{x}}$"
      ],
      "text/plain": [
       "f(x, y)/h_x - f(x - h_x, y)/h_x"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.dxl.evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which we see correspond with the expressions derived from the Taylor series above. Note that we also have access to the expression  `f.dx` which, in this particular instance, will produce a stencil equivalent to `f.dxr`. (We'll come back to this shortly when considering higher order stencils)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{f{\\left(x,y \\right)}}{h_{x}} + \\frac{f{\\left(x + h_{x},y \\right)}}{h_{x}}$"
      ],
      "text/plain": [
       "-f(x, y)/h_x + f(x + h_x, y)/h_x"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.dx.evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The functions we created above 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.\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;\"/> |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can form stencils for approximating the derivatives in any other spatial or time dimension in a similar manner.\n",
    "Let us introduce the function $u(x,y,t)$. We have\n",
    "\n",
    "\\begin{equation*}\n",
    " \\frac{\\partial u}{\\partial t}\\approx\\frac{u(x, y, t+\\delta t)-u(x, y, t)}{\\delta t},\n",
    "\\end{equation*}\n",
    "\n",
    "where $\\delta t$ is some small increment in time. This then allows us to create 'time-stepping schemes'. For example, consider the partial differential equation describing 2D linear advection\n",
    "\n",
    "\\begin{equation*}\n",
    " \\frac{\\partial u}{\\partial t}+c\\frac{\\partial u}{\\partial x} + c\\frac{\\partial u}{\\partial y}=0,\n",
    "\\end{equation*}\n",
    "\n",
    "discretizing only the temporal term for the time being we have\n",
    "\n",
    "\\begin{equation*}\n",
    " \\frac{u(x, y, t+\\delta t)-u(x, y, t)}{\\delta t}+c\\left(\\frac{\\partial u}{\\partial x}+\\frac{\\partial u}{\\partial y}\\right)=0,\n",
    "\\end{equation*}\n",
    "\n",
    "which we can re-arrange as\n",
    "\n",
    "\\begin{equation*}\n",
    " u(x, y, t+\\delta t)=u(x, y, t)-\\delta tc\\left(\\frac{\\partial u}{\\partial x}+\\frac{\\partial u}{\\partial y}\\right),\n",
    "\\end{equation*}\n",
    "\n",
    "which is one of the most basic *explicit* time stepping schemes. Now if we approximated our spatial derivative with a backward difference approximation our scheme will become\n",
    "\n",
    "\\begin{equation*}\n",
    " u(x, y, t+\\delta t)=u(x, y, t)-\\delta tc\\left(\\frac{u(x, y, t)-u(x-h, y, t)}{h} +\\frac{u(x, y, t)-u(x, y-h, t)}{h}\\right).\n",
    "\\end{equation*}\n",
    "\n",
    "(Note that here we have assumed an equal grid spacing $h_x=h_y=h$). Then, provided we know the status of our function $u$ at $t=0$ we can use the above scheme to compute the evolution of $u$ forward in time. Lets now implement this scheme in Devito.\n",
    "\n",
    "We first define our grid, the function $u$ and provide an initial condition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1100x700 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "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 formulate our equation and finite difference scheme:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial x} u{\\left(t,x,y \\right)} + \\frac{\\partial}{\\partial y} u{\\left(t,x,y \\right)} + \\frac{\\partial}{\\partial t} u{\\left(t,x,y \\right)} = 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": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq = Eq(u.dt + c * u.dxl + c * u.dyl, 0)\n",
    "eq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle u{\\left(t + dt,x,y \\right)} = dt \\left(- \\frac{\\partial}{\\partial x} u{\\left(t,x,y \\right)} - \\frac{\\partial}{\\partial y} u{\\left(t,x,y \\right)} + \\frac{u{\\left(t,x,y \\right)}}{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": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stencil = solve(eq, u.forward)\n",
    "update = Eq(u.forward, stencil)\n",
    "update"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check our `update` scheme is the same as our pen and paper scheme by `evaluate`ing it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle u{\\left(t + dt,x,y \\right)} = dt \\left(- (\\frac{u{\\left(t,x,y \\right)}}{h_{x}} - \\frac{u{\\left(t,x - h_{x},y \\right)}}{h_{x}}) - \\left(\\frac{u{\\left(t,x,y \\right)}}{h_{y}} - \\frac{u{\\left(t,x,y - h_{y} \\right)}}{h_{y}}\\right) + \\frac{u{\\left(t,x,y \\right)}}{dt}\\right)$"
      ],
      "text/plain": [
       "Eq(u(t + dt, x, y), dt*(-(u(t, x, y)/h_x - u(t, x - h_x, y)/h_x) - (u(t, x, y)/h_y - u(t, x, y - h_y)/h_y) + u(t, x, y)/dt))"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "update.evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we need to create and execute a Devito operator. This is where the *magic* happens: Devito takes our symbolic specification of the boundary value problem and through a number of compilation passes produces c code optimised for the target platform. We'll talk more about `Operator` objects in the following section, for now we'll just utilize it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Kernel` ran in 0.01 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1100x700 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "op = Operator(update)\n",
    "op(time=nt+1, dt=dt)\n",
    "\n",
    "plot_field(u.data[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can view the generated c code via"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#define _POSIX_C_SOURCE 200809L\n",
      "#define START_TIMER(S) struct timeval start_ ## S , end_ ## S ; gettimeofday(&start_ ## S , NULL);\n",
      "#define STOP_TIMER(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 \"xmmintrin.h\"\n",
      "#include \"pmmintrin.h\"\n",
      "\n",
      "struct dataobj\n",
      "{\n",
      "  void *restrict data;\n",
      "  int * size;\n",
      "  int * npsize;\n",
      "  int * dsize;\n",
      "  int * hsize;\n",
      "  int * hofs;\n",
      "  int * oofs;\n",
      "} ;\n",
      "\n",
      "struct profiler\n",
      "{\n",
      "  double section0;\n",
      "} ;\n",
      "\n",
      "\n",
      "int Kernel(const float dt, const float h_x, const float h_y, struct dataobj *restrict u_vec, const int time_M, const int time_m, const int x_M, const int x_m, const int y_M, const int y_m, 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",
      "  /* Flush denormal numbers to zero in hardware */\n",
      "  _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);\n",
      "  _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);\n",
      "\n",
      "  float r0 = 1.0F/h_x;\n",
      "  float r1 = 1.0F/h_y;\n",
      "  float r2 = 1.0F/dt;\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",
      "    /* Begin section0 */\n",
      "    START_TIMER(section0)\n",
      "    for (int x = x_m; x <= x_M; x += 1)\n",
      "    {\n",
      "      #pragma omp simd aligned(u:32)\n",
      "      for (int y = y_m; y <= y_M; y += 1)\n",
      "      {\n",
      "        u[t1][x + 1][y + 1] = dt*(-r0*(-u[t0][x][y + 1]) - r0*u[t0][x + 1][y + 1] - r1*(-u[t0][x + 1][y]) - r1*u[t0][x + 1][y + 1] + r2*u[t0][x + 1][y + 1]);\n",
      "      }\n",
      "    }\n",
      "    STOP_TIMER(section0,timers)\n",
      "    /* End section0 */\n",
      "  }\n",
      "\n",
      "  return 0;\n",
      "}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(op.ccode)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There also exist a range of other convenient shortcuts. For example, the forward and backward stencil points, `g(t+dt, x, y)` and `g(t-dt, x, y)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle g{\\left(t + dt,x,y \\right)}$"
      ],
      "text/plain": [
       "g(t + dt, x, y)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle g{\\left(t - dt,x,y \\right)}$"
      ],
      "text/plain": [
       "g(t - dt, x, y)"
      ]
     },
     "execution_count": 21,
     "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": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial t} g{\\left(t + dt,x,y \\right)}$"
      ],
      "text/plain": [
       "Derivative(g(t + dt, x, y), t)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.forward.dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial y} g{\\left(t + dt,x,y \\right)}$"
      ],
      "text/plain": [
       "Derivative(g(t + dt, x, y), y)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.forward.dy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Second derivatives and high-order stencils\n",
    "\n",
    "The logic for constructing derivatives and finite difference schemes introduced above carries over higher order derivatives and higher order approximations in a straightforward manner. For example, second derivative with respect to $x$ of order two,\n",
    "\n",
    "\\begin{equation*}\n",
    "  \\frac{\\partial^2 f}{\\partial x^2}=\\frac{f(x-h,t)-2f(x,t)+f(x+h,t)+\\mathcal{O}(h^3)}{h^2},\n",
    "\\end{equation*}\n",
    "\n",
    "can be implemented via `f.dx2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = Function(name='f', grid=grid, space_order=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{2.0 f{\\left(x,y \\right)}}{h_{x}^{2}} + \\frac{f{\\left(x - h_{x},y \\right)}}{h_{x}^{2}} + \\frac{f{\\left(x + h_{x},y \\right)}}{h_{x}^{2}}$"
      ],
      "text/plain": [
       "-2.0*f(x, y)/h_x**2 + f(x - h_x, y)/h_x**2 + f(x + h_x, y)/h_x**2"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.dx2.evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And if, for example, we wish to produce fourth order accurate first derivatives\n",
    "\n",
    "\\begin{equation*}\n",
    " \\frac{\\partial f}{\\partial x}=\\frac{\\frac{1}{12}f(x-2h,t)-\\frac{2}{3}f(x-h,t)+\\frac{2}{3}f(x+h,t)-\\frac{1}{12}f(x+2h,t)+\\mathcal{O}(h^5)}{h},\n",
    "\\end{equation*}\n",
    "\n",
    "we can do so in the following manner:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{0.0833333333 f{\\left(x - 2 h_{x},y \\right)}}{h_{x}} - \\frac{0.666666667 f{\\left(x - h_{x},y \\right)}}{h_{x}} + \\frac{0.666666667 f{\\left(x + h_{x},y \\right)}}{h_{x}} - \\frac{0.0833333333 f{\\left(x + 2 h_{x},y \\right)}}{h_{x}}$"
      ],
      "text/plain": [
       "0.0833333333*f(x - 2*h_x, y)/h_x - 0.666666667*f(x - h_x, y)/h_x + 0.666666667*f(x + h_x, y)/h_x - 0.0833333333*f(x + 2*h_x, y)/h_x"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = Function(name='f', grid=grid, space_order=4)\n",
    "f.dx.evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, Devito will produce schemes with the order `space_order` used when defining a `Function`.\n",
    "\n",
    "We can override this by explicitly passing the space order of the desired scheme when creating a symbolic expression for a derivative. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{f{\\left(x,y \\right)}}{h_{x}} + \\frac{f{\\left(x + h_{x},y \\right)}}{h_{x}}$"
      ],
      "text/plain": [
       "-f(x, y)/h_x + f(x + h_x, y)/h_x"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.dx(fd_order=2).evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `fd_order` cannot exceed the `space_order` with which a `Function` was defined."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Time derivatives follow a similar principle, we simply instead pass the desired `time_order` to a function, e.g.,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = TimeFunction(name='g', grid=grid, time_order=2, space_order=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(- \\frac{2.0 g{\\left(t,x,y \\right)}}{dt^{2}} + \\frac{g{\\left(t - dt,x,y \\right)}}{dt^{2}} + \\frac{g{\\left(t + dt,x,y \\right)}}{dt^{2}}\\right) + \\left(\\frac{0.0833333333 g{\\left(t,x,y - 2 h_{y} \\right)}}{h_{y}} - \\frac{0.666666667 g{\\left(t,x,y - h_{y} \\right)}}{h_{y}} + \\frac{0.666666667 g{\\left(t,x,y + h_{y} \\right)}}{h_{y}} - \\frac{0.0833333333 g{\\left(t,x,y + 2 h_{y} \\right)}}{h_{y}}\\right)$"
      ],
      "text/plain": [
       "-2.0*g(t, x, y)/dt**2 + g(t - dt, x, y)/dt**2 + g(t + dt, x, y)/dt**2 + 0.0833333333*g(t, x, y - 2*h_y)/h_y - 0.666666667*g(t, x, y - h_y)/h_y + 0.666666667*g(t, x, y + h_y)/h_y - 0.0833333333*g(t, x, y + 2*h_y)/h_y"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.dt2.evaluate+g.dy.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": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle u{\\left(t,x,y,z \\right)}$"
      ],
      "text/plain": [
       "u(t, x, y, z)"
      ]
     },
     "execution_count": 30,
     "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": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u{\\left(t,x,y,z \\right)} + \\frac{\\partial^{2}}{\\partial y^{2}} u{\\left(t,x,y,z \\right)} + \\frac{\\partial^{2}}{\\partial z^{2}} u{\\left(t,x,y,z \\right)}$"
      ],
      "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": 31,
     "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": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u{\\left(t,x,y,z \\right)} + \\frac{\\partial^{2}}{\\partial y^{2}} u{\\left(t,x,y,z \\right)} + \\frac{\\partial^{2}}{\\partial z^{2}} u{\\left(t,x,y,z \\right)}$"
      ],
      "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": 32,
     "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": 33,
   "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": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u{\\left(t,x,y \\right)} + \\frac{\\partial^{2}}{\\partial y^{2}} u{\\left(t,x,y \\right)} + \\frac{\\partial^{2}}{\\partial t^{2}} v{\\left(t,x,y \\right)}$"
      ],
      "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": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.dt2 + u.laplace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} \\left(\\frac{\\partial^{2}}{\\partial x^{2}} u{\\left(t,x,y \\right)} + \\frac{\\partial^{2}}{\\partial y^{2}} u{\\left(t,x,y \\right)} + \\frac{\\partial^{2}}{\\partial t^{2}} v{\\left(t,x,y \\right)}\\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": 35,
     "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": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{2.0 \\left(\\left(- \\frac{2.0 v{\\left(t,x,y \\right)}}{dt^{2}} + \\frac{v{\\left(t - dt,x,y \\right)}}{dt^{2}} + \\frac{v{\\left(t + dt,x,y \\right)}}{dt^{2}}\\right) + \\left(- \\frac{2.0 u{\\left(t,x,y \\right)}}{h_{x}^{2}} + \\frac{u{\\left(t,x - h_{x},y \\right)}}{h_{x}^{2}} + \\frac{u{\\left(t,x + h_{x},y \\right)}}{h_{x}^{2}}\\right) + \\left(- \\frac{2.0 u{\\left(t,x,y \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x,y - h_{y} \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x,y + h_{y} \\right)}}{h_{y}^{2}}\\right)\\right)}{h_{x}^{2}} + \\frac{\\left(- \\frac{2.0 v{\\left(t,x - h_{x},y \\right)}}{dt^{2}} + \\frac{v{\\left(t - dt,x - h_{x},y \\right)}}{dt^{2}} + \\frac{v{\\left(t + dt,x - h_{x},y \\right)}}{dt^{2}}\\right) + \\left(\\frac{u{\\left(t,x,y \\right)}}{h_{x}^{2}} + \\frac{u{\\left(t,x - 2 h_{x},y \\right)}}{h_{x}^{2}} - \\frac{2.0 u{\\left(t,x - h_{x},y \\right)}}{h_{x}^{2}}\\right) + \\left(- \\frac{2.0 u{\\left(t,x - h_{x},y \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x - h_{x},y - h_{y} \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x - h_{x},y + h_{y} \\right)}}{h_{y}^{2}}\\right)}{h_{x}^{2}} + \\frac{\\left(- \\frac{2.0 v{\\left(t,x + h_{x},y \\right)}}{dt^{2}} + \\frac{v{\\left(t - dt,x + h_{x},y \\right)}}{dt^{2}} + \\frac{v{\\left(t + dt,x + h_{x},y \\right)}}{dt^{2}}\\right) + \\left(\\frac{u{\\left(t,x,y \\right)}}{h_{x}^{2}} - \\frac{2.0 u{\\left(t,x + h_{x},y \\right)}}{h_{x}^{2}} + \\frac{u{\\left(t,x + 2 h_{x},y \\right)}}{h_{x}^{2}}\\right) + \\left(- \\frac{2.0 u{\\left(t,x + h_{x},y \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x + h_{x},y - h_{y} \\right)}}{h_{y}^{2}} + \\frac{u{\\left(t,x + h_{x},y + h_{y} \\right)}}{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": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(v.dt2 + u.laplace).dx2.evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to seismic modelling - 2D acoustic propagator\n",
    "\n",
    "## Goals\n",
    "\n",
    "- Introduce the seismic `Model` class\n",
    "- Introduce 'sources' and 'receivers' (sparse operations)\n",
    "- Build an acoustic forward propagator\n",
    "\n",
    "## Modelling workflow\n",
    "\n",
    "The core process we are aiming to model is a seismic survey, which consists of two main components:\n",
    "\n",
    "- **Source** - A source is positioned at a single or a few physical locations where artificial pressure is injected into the domain we want to model. In the case of land survey, it is usually dynamite blowing up at a given location, or a vibroseis (a vibrating engine generating continuous sound waves). For a marine survey, the source is an air gun sending a bubble of compressed air into the water that will expand and generate a seismic wave.\n",
    "- **Receiver** - A set of microphones or hydrophones are used to measure the resulting wave and create a set of measurements called a *Shot Record*. These measurements are recorded at multiple locations, and usually at the surface of the domain or at the bottom of the ocean in some marine cases.\n",
    "\n",
    "In order to create a numerical model of a seismic survey, we need to solve the wave equation and implement source and receiver interpolation to inject the source and record the seismic wave at sparse point locations in the grid.\n",
    "\n",
    "\n",
    "<img src='./figures/survey-ship-diagram.png' width=400>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The acoustic seismic wave equation\n",
    "The acoustic wave equation for the square slowness $m$, defined as $m=\\frac{1}{c^2}$, where $c$ is the speed of sound in the given physical media, and a source $q$ is given by:\n",
    "\n",
    "\\begin{cases}\n",
    " &m \\frac{\\partial^2 u(\\mathbf{x},t)}{\\partial t^2} - \\nabla^2 u(\\mathbf{x},t) = q \\ \\text{in } \\Omega \\\\\n",
    " &u(\\mathbf{x},0) = 0 \\\\\n",
    " &\\frac{\\partial u(\\mathbf{x},t)}{\\partial t}|_{t=0} = 0 \n",
    "\\end{cases}\n",
    "\n",
    "with the zero initial conditions to guarantee unicity of the solution.\n",
    "The boundary conditions are Dirichlet conditions:\n",
    "\\begin{equation}\n",
    " u(\\mathbf{x},t)|_{\\delta\\Omega} = 0\n",
    "\\end{equation}\n",
    "\n",
    "where $\\delta\\Omega$ is the surface of the boundary of the model $\\Omega$.\n",
    "\n",
    "\n",
    "# Finite domains\n",
    "\n",
    "The last piece of the puzzle is the computational limitation. In the field, the seismic wave propagates in every direction to an ''infinite'' distance. However, solving the wave equation in a mathematically/discrete infinite domain is not feasible. In order to compensate, Absorbing Boundary Conditions (ABC) or Perfectly Matched Layers (PML) are required to mimic an infinite domain. These two methods allow us to approximate an unbounded media by damping and absorbing the waves at the limit of the domain to avoid reflections.\n",
    "\n",
    "The simplest of these methods is the absorbing damping mask. (Note that we will explore the implementation of a more sophisticated boundary condition in the following notebook).The core idea is to extend the physical domain and to add a *sponge mask* in this extension that will absorb the incident waves. The acoustic wave equation with this damping mask can be rewritten as:\n",
    "\n",
    "\\begin{cases} \n",
    " &m \\frac{\\partial^2 u(\\mathbf{x},t)}{\\partial t^2} - \\nabla^2 u(\\mathbf{x},t) + \\eta \\frac{\\partial u(\\mathbf{x},t)}{\\partial t}=q  \\ \\text{in } \\Omega \\\\\n",
    " &u(\\mathbf{x},0) = 0 \\\\\n",
    " &\\frac{\\partial u(\\mathbf{x},t)}{\\partial t}|_{t=0} = 0 \n",
    "\\end{cases}\n",
    "\n",
    "where $\\eta$ is the damping mask which is equal to $0$ inside the physical domain and increasing inside the sponge layer. Multiple choice of profile can be chosen for $\\eta$ from, e.g., linear to exponential."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seismic modelling with devito\n",
    "\n",
    "We describe here a step by step setup of seismic modelling with Devito in a simple 2D case. We will create a physical model of our domain and define a single source along with a set of receivers. But first, we initialize some basic utilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "%matplotlib inline\n",
    "\n",
    "from devito import configuration\n",
    "configuration['log-level'] = 'WARNING'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the physical problem\n",
    "\n",
    "The first step is to define the physical model:\n",
    "\n",
    "- What are the physical dimensions of interest\n",
    "- What is the velocity profile of this physical domain\n",
    "\n",
    "We will create a simple velocity model here by hand for demonstration purposes. This model essentially consists of two layers, each with a different velocity: $1.5km/s$ in the top layer and $2.5km/s$ in the bottom layer. We will use this simple model a lot in the following tutorials, so we will rely on a utility function to create it again later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rhodri/environments/devito_pip/lib/python3.8/site-packages/numpy/core/getlimits.py:499: UserWarning: The value of the smallest subnormal for <class 'numpy.float32'> type is zero.\n",
      "  setattr(self, word, getattr(machar, word).flat[0])\n",
      "/home/rhodri/environments/devito_pip/lib/python3.8/site-packages/numpy/core/getlimits.py:89: UserWarning: The value of the smallest subnormal for <class 'numpy.float32'> type is zero.\n",
      "  return self._float_to_str(self.smallest_subnormal)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from examples.seismic import Model, plot_velocity\n",
    "\n",
    "# Define a physical size\n",
    "shape = (101, 101)  # Number of grid point (nx, nz)\n",
    "spacing = (10., 10.)  # Grid spacing in m. The domain size is now 1km by 1km\n",
    "origin = (0., 0.)  # What is the location of the top left corner. This is necessary to define\n",
    "# the absolute location of the source and receivers\n",
    "\n",
    "# Define a velocity profile. The velocity is in km/s\n",
    "v = np.empty(shape, dtype=np.float32)\n",
    "v[:, :51] = 1.5\n",
    "v[:, 51:] = 2.5\n",
    "\n",
    "# With the velocity and model size defined, we can create the seismic model that\n",
    "# encapsulates this properties. We also define the size of the absorbing layer as 10 grid points\n",
    "model = Model(vp=v, origin=origin, shape=shape, spacing=spacing,\n",
    "              space_order=2, nbl=10, bcs=\"damp\")\n",
    "\n",
    "plot_velocity(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Acquisition geometry\n",
    "\n",
    "To fully define our problem setup we also need to define the source that injects the wave to the model and the set of receiver locations at which to the wavefield is sampled. The source time signature will be modelled using a 'Ricker' wavelet whose form is defined as\n",
    "\n",
    "\\begin{equation}\n",
    "  q(t) = (1-2\\pi^2 f_0^2 (t - \\frac{1}{f_0})^2 )e^{- \\pi^2 f_0^2 (t - \\frac{1}{f_0})}.\n",
    "\\end{equation}\n",
    "\n",
    "To include such a source signature in our model we first need to define the time duration of our model and the timestep size, which is dictated by the CFL condition and our grid spacing. Luckily, our `Model` utility provides us with the critical timestep size, so we can fully discretize our model time axis as an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from examples.seismic import TimeAxis\n",
    "\n",
    "t0 = 0.  # Simulation starts a t=0\n",
    "tn = 1000.  # Simulation last 1 second (1000 ms)\n",
    "dt = model.critical_dt  # Time step from model grid spacing\n",
    "\n",
    "time_range = TimeAxis(start=t0, stop=tn, step=dt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that we can view the documentation for the `TimeAxis` object (or any other object via):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    Data object to store the TimeAxis. Exactly three of the four key arguments\n",
      "    must be prescribed. Because of remainder values it is not possible to create\n",
      "    a TimeAxis that exactly adhears to the inputs therefore start, stop, step\n",
      "    and num values should be taken from the TimeAxis object rather than relying\n",
      "    upon the input values.\n",
      "\n",
      "    The four possible cases are:\n",
      "    start is None: start = step*(1 - num) + stop\n",
      "    step is None: step = (stop - start)/(num - 1)\n",
      "    num is None: num = ceil((stop - start + step)/step);\n",
      "                 because of remainder stop = step*(num - 1) + start\n",
      "    stop is None: stop = step*(num - 1) + start\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    start : float, optional\n",
      "        Start of time axis.\n",
      "    step : float, optional\n",
      "        Time interval.\n",
      "    num : int, optional\n",
      "        Number of values (Note: this is the number of intervals + 1).\n",
      "        Stop value is reset to correct for remainder.\n",
      "    stop : float, optional\n",
      "        End time.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(time_range.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Note: Values of the time steps are stored in `time_range.time_values`.)\n",
    "\n",
    "We position the source at a depth of $20m$ and in the center of the $x$ axis ($\\mathbf{x}_{src}=(500m, 20m)$), with a peak wavelet frequency of $10Hz$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "from examples.seismic import RickerSource\n",
    "\n",
    "f0 = 0.010  # Source peak frequency is 10Hz (0.010 kHz)\n",
    "src = RickerSource(name='src', grid=model.grid, f0=f0,\n",
    "                   npoint=1, time_range=time_range)\n",
    "\n",
    "# Set source coordinates\n",
    "src.coordinates.data[0, 0] = np.array(model.domain_size[0]) * .5\n",
    "src.coordinates.data[0, 1] = 20.  # Depth is 20m\n",
    "\n",
    "# We can plot the time signature to see the wavelet via:\n",
    "src.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly to our source object, we can now define our receiver geometry as a symbol of type `Receiver`. It is worth noting here that both utility classes, `RickerSource` and `Receiver` are thin wrappers around Devito's `SparseTimeFunction` type, which encapsulates sparse point data and allows us to inject and interpolate values into and out of the computational grid. As we have already seen, both types provide a `.coordinates` property to define the position within the domain of all points encapsulated by that symbol. \n",
    "\n",
    "In this example we will position receivers at the same depth as the source, every $10m$ along the x axis. The `rec.data` property will be initialized, but left empty, as we will compute the receiver readings during the simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "from examples.seismic import Receiver\n",
    "\n",
    "# Create symbol for 101 receivers\n",
    "rec = Receiver(name='rec', grid=model.grid, npoint=101, time_range=time_range)\n",
    "\n",
    "# Prescribe even spacing for receivers along the x-axis\n",
    "rec.coordinates.data[:, 0] = np.linspace(0, model.domain_size[0], num=101)\n",
    "rec.coordinates.data[:, 1] = 20.  # Depth is 20m\n",
    "\n",
    "# We can now show the source and receivers within our domain:\n",
    "# Red dot: Source location\n",
    "# Green dots: Receiver locations (every 4th point)\n",
    "plot_velocity(model, source=src.coordinates.data,\n",
    "              receiver=rec.coordinates.data[::4, :])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finite-difference discretization\n",
    "\n",
    "The finite-difference approximation is derived from Taylor expansions of the continuous field after removing the error term.\n",
    "\n",
    "## Time discretization\n",
    "\n",
    "We only consider the second order time discretization for now. From the Taylor expansion, the second order discrete approximation of the second order time derivative is:\n",
    "\\begin{equation}\n",
    "\\begin{aligned}\n",
    " \\frac{\\partial^2 u(\\mathbf{x},t)}{\\partial t^2} = \\frac{\\mathbf{u}(\\mathbf{x},\\mathbf{t+\\Delta t}) - 2 \\mathbf{u}(\\mathbf{x},\\mathbf{t}) + \\mathbf{u}(\\mathbf{x},\\mathbf{t-\\Delta t})}{\\mathbf{\\Delta t}^2} + O(\\mathbf{\\Delta t}^2).\n",
    "\\end{aligned}\n",
    "\\end{equation} \n",
    "\n",
    "where $\\mathbf{u}$ is the discrete wavefield, $\\mathbf{\\Delta t}$ is the discrete\n",
    "time-step (distance between two consecutive discrete time points) and $O(\\mathbf{\\Delta\n",
    "  t}^2)$ is the temporal discretization error term. The discretized approximation of the\n",
    "second order time derivative is then given by dropping the error term. This derivative is represented in Devito by `u.dt2` where u is a `TimeFunction` object.\n",
    "\n",
    "## Spatial discretization \n",
    "\n",
    "We define the discrete Laplacian as the sum of the second order spatial\n",
    "derivatives in the three dimensions:\n",
    "\\begin{equation}\n",
    "\\begin{aligned}\n",
    "\\Delta \\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t})= \\sum_{j=1}^{j=\\frac{k}{2}} \\Bigg[\\alpha_j \\Bigg(&\n",
    "\\mathbf{u}(\\mathbf{x+jdx},\\mathbf{y},\\mathbf{z},\\mathbf{t})+\\mathbf{u}(\\mathbf{x-jdx},\\mathbf{y},\\mathbf{z},\\mathbf{t}) + \\\\\n",
    "&\\mathbf{u}(\\mathbf{x},\\mathbf{y+jdy},\\mathbf{z},\\mathbf{t})+\\mathbf{u}(\\mathbf{x},\\mathbf{y-jdy},\\mathbf{z}\\mathbf{t}) + \\\\\n",
    "&\\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z+jdz},\\mathbf{t})+\\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z-jdz},\\mathbf{t})\\Bigg) \\Bigg] + \\\\\n",
    "&3\\alpha_0 \\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}).\n",
    "\\end{aligned}\n",
    "\\end{equation}\n",
    "\n",
    "where $\\alpha_j$ are the appropriate finite difference weights for the approximation. This derivative is represented in Devito by `u.laplace`.\n",
    "\n",
    "## Wave equation\n",
    "\n",
    "With the space and time discretization defined, we can fully discretize the wave-equation with the combination of time and space discretizations and obtain the following second order in time and $k^{th}$ order in space discrete stencil to update one grid point at position $\\mathbf{x}, \\mathbf{y},\\mathbf{z}$ at time $\\mathbf{t}$, i.e.\n",
    "\\begin{equation}\n",
    "\\begin{aligned}\n",
    "\\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t+\\Delta t}) = &2\\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}) - \\mathbf{u}(\\mathbf{x},\\mathbf{y}, \\mathbf{z},\\mathbf{t-\\Delta t}) +\\\\\n",
    "& \\frac{\\mathbf{\\Delta t}^2}{\\mathbf{m(\\mathbf{x},\\mathbf{y},\\mathbf{z})}} \\Big(\\Delta \\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}) + \\mathbf{q}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}) \\Big). \n",
    "\\end{aligned}\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{damp}{\\left(x,y \\right)} \\frac{\\partial}{\\partial t} u{\\left(t,x,y \\right)} - \\frac{\\partial^{2}}{\\partial x^{2}} u{\\left(t,x,y \\right)} - \\frac{\\partial^{2}}{\\partial y^{2}} u{\\left(t,x,y \\right)} + \\frac{\\frac{\\partial^{2}}{\\partial t^{2}} u{\\left(t,x,y \\right)}}{\\operatorname{vp}^{2}{\\left(x,y \\right)}}$"
      ],
      "text/plain": [
       "damp(x, y)*Derivative(u(t, x, y), t) - Derivative(u(t, x, y), (x, 2)) - Derivative(u(t, x, y), (y, 2)) + Derivative(u(t, x, y), (t, 2))/vp(x, y)**2"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# In order to represent the wavefield u and the square slowness we need symbolic objects \n",
    "# corresponding to time-space-varying field (u, TimeFunction) and \n",
    "# space-varying field (m, Function)\n",
    "from devito import TimeFunction\n",
    "\n",
    "# Define the wavefield with the size of the model and the time dimension\n",
    "u = TimeFunction(name=\"u\", grid=model.grid, time_order=2, space_order=2)\n",
    "\n",
    "# We can now write the PDE\n",
    "pde = model.m * u.dt2 - u.laplace + model.damp * u.dt\n",
    "\n",
    "# The PDE representation is as on paper\n",
    "pde"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This discrete PDE can be solved in a time-marching way updating u(t+dt) from the previous time step\n",
    "# Devito as a shortcut for u(t+dt) which is u.forward. We can then rewrite the PDE as \n",
    "# a time marching updating equation known as a stencil using customized SymPy functions\n",
    "from devito import Eq, solve\n",
    "\n",
    "stencil = Eq(u.forward, solve(pde, u.forward))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Source injection and receiver interpolation\n",
    "\n",
    "With a numerical scheme to solve the homogenous wave equation, we need to add the source to introduce seismic waves and to implement the measurement operator, and interpolation operator. This operation is linked to the discrete scheme and needs to be done at the proper time step. The semi-discretized in time wave equation with a source reads:\n",
    "\n",
    "\\begin{equation}\n",
    "\\begin{aligned}\n",
    "\\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t+\\Delta t}) = &2\\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}) - \\mathbf{u}(\\mathbf{x},\\mathbf{y}, \\mathbf{z},\\mathbf{t-\\Delta t}) +\\\\\n",
    "& \\frac{\\mathbf{\\Delta t}^2}{\\mathbf{m(\\mathbf{x},\\mathbf{y},\\mathbf{z})}} \\Big(\\Delta \\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}) + \\mathbf{q}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}) \\Big). \n",
    "\\end{aligned}\n",
    "\\end{equation}\n",
    "\n",
    "It shows that in order to update $\\mathbf{u}$ to the time $\\mathbf{t+\\Delta t}$ we must inject the value of the source term $\\mathbf{q}$ at time $\\mathbf{t}$. In Devito, this corresponds to the update of $u$ at index $t+1$ (t = time implicitly) with the source of time $t$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Finally we define the source injection and receiver read function to generate the corresponding code\n",
    "src_term = src.inject(field=u.forward, expr=src * dt**2 / model.m)\n",
    "\n",
    "# Create interpolation expression for receivers\n",
    "rec_term = rec.interpolate(expr=u.forward)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Devito operator and solve\n",
    "After constructing all the necessary expressions for updating the wavefield, injecting the source term and interpolating onto the receiver points, we can now create the Devito operator that will generate the C code at runtime. When creating the operator, Devito's two optimization engines will log which performance optimizations have been performed:\n",
    "* **DSE:** The Devito Symbolics Engine will attempt to reduce the number of operations required by the kernel.\n",
    "* **DLE:** The Devito Loop Engine will perform various loop-level optimizations to improve runtime performance.\n",
    "\n",
    "**Note**: The argument `subs=model.spacing_map` causes the operator to substitute values for our current grid spacing into the expressions before code generation. This reduces the number of floating point operations executed by the kernel by pre-evaluating certain coefficients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "from devito import Operator\n",
    "\n",
    "op = Operator([stencil] + src_term + rec_term, subs=model.spacing_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can execute the create operator for a number of timesteps. We specify the number of timesteps to compute with the keyword `time` and the timestep size with `dt`. First, lets run for a few timesteps and visualize the wave-field:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PerformanceSummary([(PerfKey(name='section0', rank=None),\n",
       "                     PerfEntry(time=0.002516, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[])),\n",
       "                    (PerfKey(name='section1', rank=None),\n",
       "                     PerfEntry(time=4.9999999999999996e-06, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[])),\n",
       "                    (PerfKey(name='section2', rank=None),\n",
       "                     PerfEntry(time=0.00020399999999999965, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[]))])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op(time=100, dt=model.critical_dt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from examples.seismic import plot_image\n",
    "plot_image(u.data[0, :, :], cmap=\"seismic\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, lets reset the wavefield and run the simulation for the full duration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PerformanceSummary([(PerfKey(name='section0', rank=None),\n",
       "                     PerfEntry(time=0.007876000000000008, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[])),\n",
       "                    (PerfKey(name='section1', rank=None),\n",
       "                     PerfEntry(time=2.4000000000000007e-05, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[])),\n",
       "                    (PerfKey(name='section2', rank=None),\n",
       "                     PerfEntry(time=0.0006310000000000043, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[]))])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.data[:] = 0.0\n",
    "op(time=time_range.num-1, dt=model.critical_dt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After running our operator kernel, the data associated with the receiver symbol `rec.data` has now been populated due to the interpolation expression we inserted into the operator. This allows us the visualize the shot record:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from examples.seismic import plot_shotrecord\n",
    "\n",
    "plot_shotrecord(rec.data, model, t0, tn)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.12"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}