{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Subdomains tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial is designed to introduce users to the concept of subdomains in Devito and how to utilize them within simulations for a variety of purposes.\n",
    "\n",
    "We will begin by exploring the subdomains created internally (and by default) when creating a `Grid` and then explore in detail how users can define and utilize their own subdomains.\n",
    "\n",
    "Consider the construction of the following `Grid`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from devito import Grid\n",
    "shape = (10, 10, 10)\n",
    "grid = Grid(shape=shape, extent=shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the `subdomains` property we see:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'domain': Domain[domain(x, y, z)],\n",
       " 'interior': Interior[interior(i0x, i0y, i0z)]}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the creation of `Grid` two subdomains have been generated by default, 'domain' and 'interior'. We will shortly explore how such subdomains are defined, but before continuing let us explore some of their properties a little further.\n",
    "\n",
    "First, looking at the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Domain[domain(x, y, z)]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains['domain']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 10, 10)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains['domain'].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we see that 'domain' is in fact the entire computational domain. We can check that it has the same dimensions as grid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains['domain'].dimensions == grid.dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, when we look at the 'interior' subdomain we see:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Interior[interior(i0x, i0y, i0z)]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains['interior']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 8, 8)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains['interior'].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains['interior'].dimensions == grid.dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This subdomain is in fact defined to be the computational grid excluding the 'outermost' grid point in each dimension, hence the shape `(8, 8, 8)`.\n",
    "\n",
    "The above two subdomains are initialised upon creation of a grid for various internal reasons and users, generally, need not concern themselves with their existence. However, users will often wish to specify their own subdomains to, e.g., specify different physical equations on different parts of a grid. Before returning to an example of the latter, and to familiarise ourselves with the basics, let us dive into an example of how a user could 'explicitly' create subdomains such as 'domain' and 'interior' themselves."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `SubDomain` class\n",
    "\n",
    "To make use of subdomains we first import the `SubDomain` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from devito import SubDomain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of how to define a subdomain that spans an entire 3D computational grid (this is similar to how 'domain' is defined internally):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FullDomain(SubDomain):\n",
    "    name = 'mydomain'\n",
    "    def define(self, dimensions):\n",
    "        x, y, z = dimensions\n",
    "        return {x: x, y: y, z: z}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above snippet, we have defined a class `FullDomain` based on `SubDomain` with the method `define` overridden. This method takes as input a set of Dimensions and produces a mapper from which we can create a subdomain. It is through utilizing this mapper that various types of subdomains can be created. The mapper `{x: x, y: y, z: z}` is simply saying that we wish for the three dimensions of our subdomain be exactly the input dimensions `x, y, z`. Note that for a 2D domain we would need to remove one of the dimensions, i.e. `{x: x, y: y}`, or more generally for an N-dimensional domain one could write `{d: d for d in dimensions}`.\n",
    "\n",
    "Now, lets us compose a subdomain from our class `FullDomain`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_domain = FullDomain()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to note that whilst the `full_domain` object has now been initialised, it has not yet been finalised, i.e. it is not currently associated with any grid. To attach this subdomain to a grid we must pass it to the grid during its creation (the subdomain will then be finalised during creation of the grid):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_grid = Grid(shape = (10, 10, 10), subdomains = (full_domain, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we look at the subdomains of `my_grid` we see that our new subdomain 'mydomain' is now present:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'domain': Domain[domain(x, y, z)],\n",
       " 'interior': Interior[interior(i0x, i0y, i0z)],\n",
       " 'mydomain': FullDomain[mydomain(x, y, z)]}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_grid.subdomains"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected (and intended), the dimensions of our newly defined subdomain match those of 'domain'.\n",
    "\n",
    "Now, let us create a subdomain consisting of all but the outer grid point in each dimension (similar to 'interior'):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class InnerDomain(SubDomain):\n",
    "    name = 'inner'\n",
    "    def define(self, dimensions):\n",
    "        d = dimensions\n",
    "        return {d: ('middle', 1, 1) for d in dimensions}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, note that in the above we have used the shortand `d = dimensions` so that `d` will be a tuple of N-dimensions and then `{d: ... for d in dimensions}` such that our mapper will be valid for N-dimensional grids. Next we note the inclusion of `('middle', 1, 1)`. For mappers of the form `('middle', N, M)`, the `SubDomain` spans a contiguous region of `dimension_size - (N + M)` points starting at (in terms of python indexing) `N` and finishing at ``dimension_size - M - 1``.\n",
    "\n",
    "The two other options available are `'left'` and `'right'`. For a statement of the form `d: ('left', N)` the `SubDomain` spans a contiguous region of `N` points starting at `d`\\'s left extreme. A statement of the form `('right', N)` is analogous to the previous case but starting at the dimensions right extreme instead.\n",
    "\n",
    "Now, to create a grid containing both of the subdomains defined above, 'mydomain' and 'inner', we simply pass these during the creation of a grid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "inner_domain = InnerDomain()\n",
    "my_grid = Grid(shape = (10, 10, 10), subdomains = (full_domain, inner_domain))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If our subdomain `'inner'` is defined correctly we would expect it have a shape of `(8, 8, 8)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 8, 8)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_grid.subdomains['inner'].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is indeed the case.\n",
    "\n",
    "Now, let us look at some simple examples of how to define subdomains using 'middle', 'left' and 'right' and then utilize these in an operator.\n",
    "\n",
    "The first subdomain we define will consist of the computational grid excluding, in the `x` dimension 3 nodes on the right and 4 on the left and in the `y` dimension, 4 nodes on the left and 3 on the right:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Middle(SubDomain):\n",
    "    name = 'middle'\n",
    "    def define(self, dimensions):\n",
    "        x, y = dimensions\n",
    "        return {x: ('middle', 3, 4), y: ('middle', 4, 3)}\n",
    "mid = Middle()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let us form an equation and evaluate it only on the subdomain 'middle'. To do this we first import some required objects from Devito:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from devito import Function, Eq, Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then create our grid containing the subdomain 'middle' and when forming our equation pass this subdomain to the equation, thus telling Devito to only evaluate that particular equation within the subdomain 'middle':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Kernel` ran in 0.01 s\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "grid = Grid(shape = (10, 10), subdomains = (mid, ))\n",
    "f = Function(name = 'f', grid = grid)\n",
    "\n",
    "eq = Eq(f, f+1, subdomain = grid.subdomains['middle'])\n",
    "\n",
    "op = Operator(eq)()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result we expect is that our function `f`'s data should have a values of `1` within the subdomain and `0` elsewhere. Viewing `f`'s data we see this is indeed the case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Data([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 1., 1., 1., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 1., 1., 1., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 1., 1., 1., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now create some additional subdomains utilising `'left'` and `'right'`. The first domain named 'left' will consist of two nodes on the left hand side in the `x` dimension and the entire of the `y` dimension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Left(SubDomain):\n",
    "    name = 'left'\n",
    "    def define(self, dimensions):\n",
    "        x, y = dimensions\n",
    "        return {x: ('left', 2), y: y}\n",
    "ld = Left()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, our subdomain named 'right' will consist of the entire `x` dimension and the two 'right-most' nodes in the `y` dimension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Right(SubDomain):\n",
    "    name = 'right'\n",
    "    def define(self, dimensions):\n",
    "        x, y = dimensions\n",
    "        return {x: x, y: ('right', 2)}\n",
    "rd = Right()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that owing to the chosen definitions of 'left' and 'right' there will be four grid points on which these two subdomains overlap.\n",
    "\n",
    "Then, let us create a grid consisting of the subdomains 'middle', 'left' and 'right' and specify an equation on each of the three subdomains:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid = Grid(shape = (10, 10), subdomains = (mid, ld, rd))\n",
    "f = Function(name = 'f', grid = grid)\n",
    "\n",
    "eq1 = Eq(f, f+1, subdomain = grid.subdomains['middle'])\n",
    "eq2 = Eq(f, f+2, subdomain = grid.subdomains['left'])\n",
    "eq3 = Eq(f, f+3, subdomain = grid.subdomains['right'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then create and execute an operator that evaluates the above equations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Kernel` ran in 0.01 s\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "op2 = Operator([eq1, eq2, eq3])()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Viewing the data of `f` after performing the operation we see that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Data([[2., 2., 2., 2., 2., 2., 2., 2., 5., 5.],\n",
       "      [2., 2., 2., 2., 2., 2., 2., 2., 5., 5.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 1., 1., 1., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 1., 1., 1., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 1., 1., 1., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 3., 3.]], dtype=float32)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Seismic wave propagation example with subdomains\n",
    "\n",
    "We will now utilise subdomains in a seismic wave-propagation model. Subdomains are used here to specify different equations in two sections of the domain. Our model will consist of an upper water section and a lower rock section consisting of two distinct layers of rock. In this example the elastic wave-equation will be solved, however in the water section, since the Lame constant (`mu`) is zero (and hence the equations can be reduced to the acoustic wave-equations), terms containing `mu` will be removed.\n",
    "\n",
    "It is useful to review seismic tutorial numbers 6 (elastic setup) to understand the seismic based utilities used below (since here they will simply be 'used' with little explanation).\n",
    "\n",
    "We first import all required modules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from devito import (TimeFunction, VectorTimeFunction, TensorTimeFunction,\n",
    "                    div, grad, curl, diag)\n",
    "from examples.seismic import ModelElastic, plot_velocity, TimeAxis, RickerSource, plot_image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now define the problem dimensions and velocity model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "extent = (200., 100., 100.) # 200 x 100 x 100 m domain\n",
    "h = 1.0 # Desired grid spacing\n",
    "# Set the grid to have a shape (201, 101, 101) for h=1:\n",
    "shape = (int(extent[0]/h+1), int(extent[1]/h+1), int(extent[2]/h+1))\n",
    "\n",
    "# Model physical parameters:\n",
    "vp = np.zeros(shape)\n",
    "vs = np.zeros(shape)\n",
    "rho = np.zeros(shape)\n",
    "\n",
    "# Set up three horizontally separated layers:\n",
    "l1 = int(0.5*shape[2])+1 # End of the water layer at 50m depth\n",
    "l2 = int(0.5*shape[2])+1+int(4/h) # End of the soft rock section at 54m depth\n",
    "\n",
    "# Water layer model\n",
    "vp[:,:,:l1] = 1.52\n",
    "vs[:,:,:l1] = 0.\n",
    "rho[:,:,:l1] = 1.05\n",
    "\n",
    "# Soft-rock layer model\n",
    "vp[:,:,l1:l2] = 1.6\n",
    "vs[:,:,l1:l2] = 0.4\n",
    "rho[:,:,l1:l2] = 1.3\n",
    "\n",
    "# Hard-rock layer model\n",
    "vp[:,:,l2:] = 2.2\n",
    "vs[:,:,l2:] = 1.2\n",
    "rho[:,:,l2:] = 2.\n",
    "\n",
    "origin = (0, 0, 0)\n",
    "spacing = (h, h, h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before defining and creating our subdomains we define the thickness of our absorption layer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "nbl = 20 # Number of absorbing boundary layers cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now define our subdomains, one for the upper water layer, and one for the rock layers beneath:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define our 'upper' and 'lower' SubDomains:\n",
    "class Upper(SubDomain):\n",
    "    name = 'upper'\n",
    "    def define(self, dimensions):\n",
    "        x, y, z = dimensions\n",
    "        return {x: x, y: y, z: ('left', l1+nbl)}\n",
    "    \n",
    "class Lower(SubDomain):\n",
    "    name = 'lower'\n",
    "    def define(self, dimensions):\n",
    "        x, y, z = dimensions\n",
    "        return {x: x, y: y, z: ('right', shape[2]+nbl-l1)}\n",
    "\n",
    "# Create these subdomains:\n",
    "ur = Upper()\n",
    "lr = Lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create our model to which we pass the subdomains `ur` and `lr`. Within model they will then be used when creating the model grid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.02 s\n",
      "Operator `pad_lam` ran in 0.02 s\n",
      "Operator `pad_mu` ran in 0.02 s\n",
      "Operator `pad_b` ran in 0.01 s\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "so = 4 # FD space order (Note that the time order is by default 1).\n",
    "\n",
    "model = ModelElastic(space_order=so, vp=vp, vs=vs, b=1/rho, origin=origin, shape=shape,\n",
    "                     spacing=spacing, nbl=nbl, subdomains=(ur,lr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now prepare model parameters along with the functions to be used in the PDE, and the source injection term:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = model.grid.stepping_dim.spacing\n",
    "\n",
    "# Source freq. in MHz (note that the source is defined below):\n",
    "f0 = 0.12\n",
    "\n",
    "# Thorbecke's parameter notation\n",
    "l = model.lam\n",
    "mu = model.mu\n",
    "ro = model.b\n",
    "\n",
    "t0, tn = 0., 30.\n",
    "dt = model.critical_dt\n",
    "time_range = TimeAxis(start=t0, stop=tn, step=dt)\n",
    "\n",
    "# PDE functions:\n",
    "v = VectorTimeFunction(name='v', grid=model.grid, space_order=so, time_order=1)\n",
    "tau = TensorTimeFunction(name='t', grid=model.grid, space_order=so, time_order=1)\n",
    "\n",
    "# Source\n",
    "src = RickerSource(name='src', grid=model.grid, f0=f0, time_range=time_range)\n",
    "src.coordinates.data[:] = np.array([100., 50., 35.])\n",
    "\n",
    "# The source injection term\n",
    "src_xx = src.inject(field=tau[0, 0].forward, expr=src*s)\n",
    "src_yy = src.inject(field=tau[1, 1].forward, expr=src*s)\n",
    "src_zz = src.inject(field=tau[2, 2].forward, expr=src*s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now define the model equations. Sets of equations will be defined on each subdomain, 'upper' and 'lower', to which we pass the subdomain object when creating the equation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "u_v_u = Eq(v.forward, model.damp * (v + s*ro*div(tau)), subdomain = model.grid.subdomains['upper'])\n",
    "u_t_u = Eq(tau.forward, model.damp * (tau + s * l * diag(div(v.forward))),\n",
    "           subdomain = model.grid.subdomains['upper'])\n",
    "\n",
    "u_v_l = Eq(v.forward, model.damp * (v + s*ro*div(tau)), subdomain = model.grid.subdomains['lower'])\n",
    "u_t_l = Eq(tau.forward, model.damp * (tau + s * l * diag(div(v.forward))\n",
    "                                      + s * mu * (grad(v.forward) + grad(v.forward).T)),\n",
    "           subdomain = model.grid.subdomains['lower'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now create and run an operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Kernel` ran in 13.59 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "PerformanceSummary([(PerfKey(name='section0', rank=None),\n",
       "                     PerfEntry(time=13.584479000000002, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[])),\n",
       "                    (PerfKey(name='section1', rank=None),\n",
       "                     PerfEntry(time=0.0003199999999999996, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[]))])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "op = Operator([u_v_u, u_v_l, u_t_u, u_t_l] + src_xx + src_yy + src_zz, subs=model.spacing_map)\n",
    "op(dt=dt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, plot some results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "\n",
    "# Plots\n",
    "%matplotlib inline\n",
    "\n",
    "# Mid-points:\n",
    "mid_x = int(0.5*(v[0].data.shape[1]-1))+1\n",
    "mid_y = int(0.5*(v[0].data.shape[2]-1))+1\n",
    "\n",
    "# Plot some selected results:\n",
    "\n",
    "plot_image(v[0].data[1, :, mid_y, :], cmap=\"seismic\")\n",
    "plot_image(v[0].data[1, mid_x, :, :], cmap=\"seismic\")\n",
    "\n",
    "plot_image(tau[2, 2].data[1, :, mid_y, :], cmap=\"seismic\")\n",
    "plot_image(tau[2, 2].data[1, mid_x, :, :], cmap=\"seismic\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Note:\n",
    "\n",
    "When creating a grid with many subdomains the process introduced in this notebook becomes cumbersome. For such cases the `SubDomainSet` object is available allowing users to easily define a large number of subdomains. A tutorial regarding the use of `SubDomainSet`'s will be released at some point in the future."
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}