{
 "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': SubDomain domain[(x, y, z)],\n",
       " 'interior': SubDomain 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": [
       "SubDomain 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": [
       "SubDomain 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': SubDomain domain[(x, y, z)],\n",
       " 'interior': SubDomain interior[(i0x, i0y, i0z)],\n",
       " 'mydomain': SubDomain 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` run 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` run 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` run in 0.02 s\n",
      "Operator `padfunc` run in 0.01 s\n",
      "Operator `padfunc` run in 0.01 s\n",
      "Operator `padfunc` run in 0.02 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` run in 15.77 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "PerformanceSummary([(PerfKey(name='section0', rank=None),\n",
       "                     PerfEntry(time=15.689911, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[])),\n",
       "                    (PerfKey(name='section1', rank=None),\n",
       "                     PerfEntry(time=0.07815599999999932, 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": "iVBORw0KGgoAAAANSUhEUgAAAUgAAAD8CAYAAAAVOD3kAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzsvX98VcWZ+P9+khAv4UJvQoAEAgYLNqvQIqVKu9YPrajU0mL3i5VWq7a6rFvptrvrrrr1tdrWvj7auu22tR9dlrpauxWVXRWpSqVLVtwFS9RYwGJJMUowwQSIJECAwHz/mJlz5l7Ozb35HXLn/Xrd150z95w5c+bmPnmeeZ55RpRSeDwej+dk8ga7Ax6PxzNU8QLS4/F40uAFpMfj8aTBC0iPx+NJgxeQHo/HkwYvID0ejycN/SYgRWSBiLwhInUickt/3cfj8Xj6C+mPOEgRyQf+AFwENACbgS8opV7v85t5PB5PP9FfGuS5QJ1SaqdS6iiwEljUT/fyeDyefqGgn9qdBOxyjhuA89KdXFxcqiZNquynrng8HoBt215uUUqNA5gmog5leV0jrFVKLejHrg1Z+ktAZkRElgJLAcrLp/DYYzWD1RWPJyc4+2x5y5YPAX+R5XV3QGm/dOgUoL9M7N3AZOe4wtQFKKWWK6XmKKXmlJSM66dueDyeKAT948/mlcv0lwa5GZguIlPRgnEJ8MV+upfH4+kmwiCaj6cQ/TJGSqlOEVkGrAXygQeUUtv6414ej6dn5Lp2mA399k9EKfUM8Ex/te/xeHqHF5CZ8Vq2x5OD2DlIT9d4Aenx5CheQGbGC0iPJwfxGmR2eAHp8eQo+YPdgVMALyA9nhxE8AIyG7yA9HhyFG9iZ8YLSI8nB/FzkNnhBaTHk6N4AZkZLyA9nhzELzXMDj9GHk+O4jXIzHgB6fHkIGJenq7xAtLjyVF8mE9mvID0eHIQ78XODi8gPZ4cxQvIzHgB6fHkIN6LnR1+jDyeHMVrkJnxY5TDFBQMzssz+PT1njQiskBE3hCROhG5JeLz00TkUfP5SyJS6Xx2q6l/Q0QuydSmiEw1bdSZNgtN/Q0iskVEakXkRRE5q5vDchL+z3WYEiWIUuvc464EV36W7s7jx9N/1tkZXY46Tlfn6Vv6KsxHRPKBnwIXobd43iwiq5VSrzunXQfsV0pNE5ElwN3AFUaILQHOBiYC60TkTHNNujbvBn6olFopIvebtu8DfqmUut/06bPAD4BebVfrNUiPJ0fJz/KVBecCdUqpnUqpo8BKYFHKOYuAh0x5FXChiIipX6mUOqKUehOoM+1Ftmmu+aRpA9PmZQBKqQPO/UYBKrvup8drkMOArjRB16zNz4cRIzJf019EaZHHjoWaZ2dnWG/71JXm6ek5feykmQTsco4bgPPSnWM29XsPGGvqN6VcO8mUo9ocC7QqpTojzkdEbgT+BihEC9Je4QXkKYoVIK4ALCgIzeGRI6M/z+OEPnCljSMhT5AXfOS+ZxJOqfex5eB+ae6Zej9bPnxYvx8/Ht0PLyx7RzfjIEtFpMY5Xq6UWt7XfeoLlFI/BX4qIl8EbgOu6U17XkB6PDlKNwRki1JqThef7wYmO8cVpi7qnAYRKQDeB+zNcG1U/V4gISIFRouMuhdok/y+rh4qG3osIEVkMvBzYALa1l+ulPqRiJQAjwKVQD3weaXU/t521BOtoZ12Wmg2x2L6BZDXeVQXOjuhI0JbjMU42ql/Iu2t0NGhq9vb9cuWQX8WpcWlao323vG4fulyXtC3eLwQgMKCE8EN8zo7KTRdKywogFiBua4wuLft27FjcOTIyf3w2mTP6EMHxGZguohMRQurJcAXU85ZjdbmNgKLgf9SSikRWQ38UkR+gHbSTAd+i1ZyT2rTXLPetLHStPkUgIhMV0rtMPf7NLCDXtIbDbIT+Ful1CsiMhp4WUSeB64FfqOUusu45m8Bbu5tR3OVdELRmtCxGBRihGFHB7SmSA1Hch0tKGK/+Ve1pw5aWnS5qUm/QNfZ+tZW/d7WFi2YUvs0erQuJxJQWqrL9r2sTL90XR4TJhQBUFwMhZ2Hwv6bxvNMw0UFBRTFTf8pDITl4cNeWPaGvlxqaOYUlwFr0X6dB5RS20Tk20CNUmo18DPgYRGpA/ahBR7mvMeA19Ey5Ual1HGAqDbNLW8GVorIncCrpm2AZSIyHzgG7KeX5jX0QkAqpRqBRlNuE5HfoydLFwHzzGkPAdV4AenxDDn6MpuPUuoZ4JmUun90yh3A5Wmu/S7w3WzaNPU70V7u1Pqvd7vjGeiTOUgT9HkO8BIwwQhPgCa0Ce7pAa6G5prP8XiK1mjVKnsRBKrbvtY8Gup0VX091DnlHcYA2b0bGhp0ef/+48BB05ht9yj6nzJAarCjDQQZAYGxHENHWUBxsf68ogImGV/j9OlQWanL06ZBZWWROaeIklLj1LHqq/N8hbEYhWYQYrHCpCkAdwi8FpkZQX9jnq7ptYAUkTjwH8A3lFIHdJiSxswXRMYiichSYClAefmU3nZjWOCa0/b9tNN0efRoZ36x41A4QehekEjwTpM2nOpe1FXbt8Orr+rytm36GKC5+SDaCgE4QCgMo6K9s4mIOx557f79+eY9xpYtYwB47rlixo3TArSqCs4+W597zjlQVaX7P21aCQATy05EC8t4nESiKKhua9OnHDlysrntBWY0Pgg6M70aIxEZgRaO/66U+k9TvUdEys3n5cC7UdcqpZYrpeYopeaUlIzrTTc8Hk836eulhsOV3nixBT05+nul1A+cj6y36i4cD5Ona1I9wpDsDS7kKLQarbGzM+mkd1q0abu9GmprdfUmE3pbUwNvvmm1w0ZCrfEooVYYA4pNOYGILlsHy9ixoQMmFksO4rambVsb7N2ryy0tEAYuGO2PdnN/gAaam3Wfm5uL2bChHICpU2PMMcEkc+fq91mz8qiqMtpk6dEkF3ueuXlRPE5BcaGtTlKuLV6LPJlcF37Z0BsT+0+BLwFbRMT8LPkHtGB8TESuA94CPt+7Lno8nr7GJ8zNjt54sV8kvSPswp62m2ukiyO073kdJgTGVYtiMQ6g5/N+/yq89JKurq6GF83cY3OzUed4h9DpAqGmOJVx43R51iz9suWqKl22jpSS2KEw9qe9PTnOx3a2tJR9HXpOsL4etm/XbdfW2vdQu21u3k8487LHvODNN0fx5psTzbOMBeD882HePH3meecV8id/orXJMQUHQvW1tZVC049EoigYU9eJY/GaZIgXkJnxK2kGkVQvtZU1Y+LGk9venvzrNjbvzvq8wIRet06/AHbt2otemgrapAUYCZwOwLhx5cyfr2sXLIBLTGKpCXtfDyXrpq3w4HbboH7fuzf0gnR0BIsH82zHAUaPpmSsFmolkycz20jZL86YoT+/9nz2jNXZp9auLea554qD/jc3W9O7EdD3bm7Wg/HEExXU1Oh2588n6P/cuWM4o9IMWEtLIA3zOjsZYwfSEQFeSCbjE+Zmhx8jjydH8RpkZkSpXmcE6jUzZsxRjz1Wk/nEYUKUWZ1IQFEsJQbQccYcipUEJmp1NaxZo8sbN3YQrqg6gNYYAaYCcM45xVxxha750pdgYt0L+mDNGt0QQG0trcd0nOMhwoCfEynvmchz3s1jUWTeEyNGhHb8vHmwcCEA70y7gIcf1tWPPgqvvmqdO2+a98NgphNgOh/9qG554cLQ9J41C4o69ukD14GVSOhn6shLihTK1fCfs8+Wl+2a6pkiQdhJJs6E4Lpcw2uQA0yqWW1+w1o4uoLRnLCvUwuHF9fBs8/q6qeegsbGt0yL1jwFOIOZM7VH+IYbdM1XbzgB95k1+0se5cSGDYCeATSzm3QS/iHEANOlQLjFINmN7eK4sa1gdYWsEVu8e+wYBZs363Y3b2b8978PwMSPf5ybjQS/ueYv+X/3a9P7fvO+ZUsj2tcHUMvGjfr56utPD2YAWlrg/PP13GRJLHluEqAokYBEXlDlzW2N1yAz4wWkx5OjeAGZGS8gB4iszGqrzhgnwzutRYEVvGoVPPmkLiu1hTC+cCzFxdr5sWwZ3Habri28/8e6MGsF7Vu2ANCC1hZBLwosMeVELBa6rqdP1+v/IFwbWF4eqrrpAiFbW4k1am02tnt3uKbRrmfcvp1Wc+4BYKcdlw0bKDVabfxf/oWvXn89ANfX/BUAd95Zzr33aq1x//7XgbcBaGw8wL/8y0wA9uwJPdbz5o1hYiLFjd3aqrVIgESyuW3JNU3SO2myw4/RAJDOW32SWW0+eLtFG7fPPQcrV+qP168/ALxhWjwKfACAiy4azx136NqPtayG+fcA0O6Y0pY4MN7mRps7V8fQAMyZE8wPHq04g/p6XW0z/LS2Qrspu0LFPg/orie0vKLsojBEqLDBiMLaWhI1ep458eKLQST7u8eOBX18d8sWxn9d5xuIr9IZ9b99000sWPNZAO644yyef96evQOltMn+xBMfoLVVT0W0t8OCBXr8pphAd9rbk8ztzrj3bkPfJqsYrngB6fHkIELW+83kNF5ADgCuBhmPO3GOKWa11Ryth/oXv4CNG23A9w7CP+lz+bu/05rg9+48CjfdpKt/8hNjgGJz/ZAASq15+alPwac/rcuf+ARvd+qg7K1bof45Xd3UFCq17c7Kxqi9YVL3tXGf0d6yrOwMACorz2DGDX8GwJRl78D69QCM/9WvGG+8Ty2trRhFlUKjAU/ZsIGPfe1rAPx6zT38/W3jAfj+94sBu4Drddavnw5AR8fYoH8LFzqapGNuj7Gdc7Z7cJ8rV/BzkJnxArIfcecd3dUxSZLH2KjvtBbxnBFSv/iFft+48V3CEJ6RjB49G4B77oGls36rq+ffxD4jTPYRep6nWNv3c5+DxYt1+bLL+N9N+mdR+ySBKd3SEpqaUZnTuipb3OtaW8P0aXYqsqYmjCqqrJzIrFlXAvCxX3whmFwtXbWK0iee0ONhGqwDSn7yEwBKamv53j16CmHatHO56aaPANDW9go2wHzjxunA+KR+LlxYxMR4Z9hRM/7x+JhAKLa3R28UNlzxSw2zwwtIjydH8QIyM15A9hOp2xFYDTKv41CobhUUBHGO1dWhQybZrNYXlpd/iHvv1bV/1vkYXKGTtL9TXx/EHJYBcZsG58tf1u9XXcULNVqvrPnn0Kn83nvRGxsmEmEOynQ7I7qk25HQbocQtddNQwMYxzqbNuUxZ442vS9YsSCI/p74b/+mr9u0KXDidGzYwEQTM7n07rspfVDnQVm2bDaNja8FY7Zxo56KiMX0EsV4HBYs0ONcUhB63vMKCojH9dgcO5ZbW8x6L3Z2+DHqY6LCeUaOdDKAO0knDsVKeNGso161ynqqwTWry8s/BMCKFXBpg9lp86abqLdro4EzbOHP/zyIEP9DXJvj6x4Mk+S2tETnmXDnDF0vu+1/dwWkY8UmxWy7dTY12nvvhab+1q1FzJ+/FIAzTd6z+P33E//XfwX0DnD15uTK66/nz+7Rk6WxFUu5/no9To2NrwTjt369nqdNJMYEzzR/fglF7UbktrdTaEKCRo4sDPbnzgXPtjexs8MLSI8nR/ECMjNeQPYTJ6Uvaw01R5uVp3ZTuHxQ+ylsnKM2EUePnh2Y1Zc2LAcTI1jf0RF8cRVlZTpCHOBrX+OZF7UpabP91NcnWfSBpphIJJddbdKN2bTXuc/laqFRZqm73tndQtZ6x1tbkz3lbrylLc+dqzXgS++5B07X2Ygq772XBnNCfVsblWY8Lv0R3Huv1jyvvXY2bW2bTY/0eD755EeYYHZGKi2Fj801AZJOFqB4oiRSGx7OeAGZGS8gPZ4cxJvY2eEFZB+ROkd3kmPGSUCxs17/aVZX68QTYJcP2uhFvaPlPfcYhwzoeUejChYAFXapyq23cvRarT2tXKnDaSDUxCAppy0mZSPjxsEovW9W0oZg7nyjJT8lotg6cVLLdg4vHg8f12qp7sZaBw9Cc7Mu792bnIvXzpdaDbOlZQxL/u6bABSOG0fF//2/ADTU1wfjUXnTTfzZCn2jlns+z1/8hckahA6FUmoLTz2ll/lMngxlZXr8zyiNhQ6bjkNpHTYwPDXKvhSQIrIA+BHa/FmhlLor5fPTgJ8DHwb2AlcoperNZ7cC16F3ffsrpdTartoUkanASmAs8DLwJaXUURH5G+B69IraZuArSqm36AVeQPYxVriMHAmFBTbxbUfwwQHGBObvmjVuVp5W7PJBGwS+dNZvA291fVtbaFZXVsK3vgXAvoVXs+pBXb9pU2jSuru/lpWFZbvPjLuNbCyWLARHROwH6sYIpiu715nsaYEAde83enQoOIuLw3JTUygsrYCvrg6nCBYvXkqJaaTi9ttpMA6b+rY2Km/W47T00Urq/k7/g/n+96eb3rwRjPOaNacHyyBLF45hTEE4L1CY0G2PHJkXeOGHo2CEvvVii0g+8FPgInTG5s0islop9bpz2nXAfqXUNBFZAtwNXCEiZwFLgLOBicA6ETnTXJOuzbuBHyqlVorI/abt+4BXgTlKqUMi8pfA94ArevNsXsv2eHIUEcnqlQXnAnVKqZ1KqaNo7W5RyjmLgIdMeRVwodn4bxGwUil1RCn1JnptwLnp2jTXfNK0gWnzMgCl1HqllM3itwmo6PagpOA1yD4gNeYRjLbkrpgxatLvXw23SNDJbm0+x7FcdJFeAfK9O42pPf8m3rExMBiHDMCtt7Jv4dWANqutRtrRkWxOA1RUhBpaaWm01jhiRPTqGPf5nBmCjGV7jUtnZ3i/WGjZJmmW8XhYds1uuxtEZycsWaKfu6Sjg4rbbwegvqkpGKeJN93E98wA19bq8Xz++RbsOG/cOIGqKn2T978fzjvHDJgThxSLjQm+x2EbGynS9ZfuYs2B9EwCdjnHDcB56c5RSnWKyHtoE3kSWpi515o0UpFtjgValVKdEee7XAc8m6njmfACso9wTWswcY+O+9huzfrSS6GADOMdobj4rCArj11bvW/DhiAI/AwIvNVHr12aZFbb2yQSyYIR9JxjsdmnKx7PTij2dsldqnfb1rntusLS/eeSOpfb0hLOR27aFNZfe+1SCs1EZuVttwXp0/Zt2ECJGb877tAp32pqzmL/fvsb3MG6dXo+ctYsmDxZfy8TYwXBQBbGYowcqeuHtamdvYAsFRE35f9ypdTyfulTHyAiVwFzgP/T27a8gPR4cpHuaJDQkmHLhd3AZOe4wtRFndMgIgXA+9DOmq6ujarfCyREpMBokUn3EpH5wDeB/6OUOpLd46Wn1wLSTNDWALuVUgvTeZh6e5+hiKvtJJnWkLwcI5Fge7UuVlfb3QdBp47V62CWLTP5HAFMcoZ96OWDgF4lY7LapJrVYeacUHO0mmQiEXqrXSdKNrGN2SSriCqnOm+6anfEiFCbLCgI+xi1cqe1NXzuWAyuNuPBW28x3qy2aSJMbvExswXismWf5TvfOd20sjMY/+rqsdhNFyfOS4R2fUcHsZjWIIetqZ2Xd/L2GelwVm2lYTMw3fz2d6OdLl9MOWc1cA2wEVgM/JdSSonIauCXIvIDtJNmOjr8QKLaNNesN22sNG0+BSAi5wD/AixQSr1LH9AXGuTXgd8T7qyUzsM0bCkocExr67nuCD3X7zTlBRtu6fk0k+qGkcEeMrfdRpDs1qYsK8JZW33DDUEQeE1NOL0Zjyeb1Xaa0s5FjhrVtWDMVO4J3RWgtn9WkKde5wZw2+euqYHSUj0el95wA3GzuLto06Zg/KaYzD+3rfssTz6px1nvcaPH/8UXxwY5g6uq8rSZDdqjbQZw5EjtxzxyZJgIRkv3NMguMXOKy4C16JCcB5RS20Tk20CNUmo18DPgYRGpQ//vX2Ku3SYijwGvo8NzblRKHdddPLlNc8ubgZUicifac/0zU/99dPKCx41z6W2l1Gd782y9GiERqQA+DXwX+BvHw2T/ezwE3MEwF5AezylJHwlIAKXUM8AzKXX/6JQ7gMvTXPtdtAzJ2Kap34kNFk6un9/tjmegtyP0z8DfA2bLu6w9TMOCqMQUqaY1QN2LoWnY3LwXsMsOzwp2Hyy8/8fBNgl2PmJKLBZk5flDfHbQRlNTcpyja1a7miOc7Izpw99Ej+mqD64WCfqZXA3SDm9TUzim066azZlmnCbW1lJnTrLjGb//x9xwg97j5sYbp6KVFf1dbNqkI+fnzIGJ55u5CidBZixWFPR5WOWL7EMNcjjT4xESkYXAu0qpl0VkXg+uXwosBSgvn9LTbgwaqfvMBH9r7U4qs1Ztnm3dGq5wgXewe1efc06x3pYVYNaKIK2XzXfN5z4HV10F6Kw8TsRPklltV8dEzTcONeGYSrq5SVdQ2iiTVAFpx2PdOjjzWj1OVFeTeOQRINyPJ75iBV+t1REAK1YU8+qrdu/wd6ip0YO3dSvMmKG/r5KC0KNdkNAC0g1jivLSn3J4AZkVvRmhPwU+KyKXordOHoNeFpTWw+RiwgSWA8yYMUf1oh8ej6e7eAGZFT0eIaXUrcCtAEaDvEkpdaWIPE6Eh2k4U1AAeZ3GMHb2mGkw2w1s2QJvvnnQnH0Q0B7VK64A7tPTs3ZrVnD2kFm8OEh2u317qD3F46EzJpEI4xxdh0xP//az8UB3t9wdUs8fNSps68iR8LndBLzbtxOM0wWLF1NqUiQdMAGU7Vu2EDfjfMUVN/Lqq+Wm9beC72XLllGBw6ZkWixo3H6vBQWF3XuQoY5I9l7sHKY//oWk8zANK1JN7NT9UE/EigITcNs2cDdgHTdO/0C/9CVgyaOA3rM6bk/41Kf0+2WXUfPPutjSkjzvaE1sd96xqzXUUfRlaE+6cjZCM8pjbRkxInl1kJuA15ZbWsIpjAu+cZnOPgzEjandAsQf1eP8pZU38k//pMe/ufkt7PeybdvU4PuaMaOIvJSMv7FYYdKcszexc4M+GSGlVDVQbcqRHiaPxzOE8AIyK/wIdRP3byopoWyKetTcHO7op1N47TdXFWPil5lY9wInjKe1ExhvVUCzNev/bsoL9pBxlnMzdmxyVh43E0+6rREyPUt//Va6e49Ma7jtc+/fn5yA147T/27K42Nm/MYbTbLu2LFgnCfWvcD8+RcA8MgjxdjvZfv2qcH31dwME0Ykq8BupIIT4nrqapJeQGaFHyGPJxfxAjIr/Aj1EHcOMq/zaJJzBmBvU6jVNDcfJIxunMqCBaa4Zk0wM1kIYFfNfOITgN67+r33wvtZDXLcuOSsPL11zKSjN46e/uiDm/ln3Lhw46/29nCcamvhY5fp8bPjWbhhQzDOZWvWsGCB1SDHY7dlaG4+yI4dOrZo716YUBkLG0d/x9ZRMyzmIMELyCzwI9RDXAGZ9Gsxv2A3Tk+7CTTjxhVzySXm4N5qbPK6EsC6Ud/unAjo6125a+MdR40KBUV+fmYzNp05mOn3EbU0MB3ZnOOem6l/UffOzw+fe9SocDycrWWorw/Hb4oZzzEbNrDPNlxdzSV/q4vjxhUHmc2hhfp6LSCbmuCsqmQBSWdnkoA85enOWuwcZjh81R6Pp7t4Ezsr/Ah1k0htrSNUfQ516NUYyRrkQezqmVmzYMJek4m+thZ7ZSIW0+vd0Ks6IEwuA1qDHG0WdLp7yKRLRNFlfzM8V3c+y/Y+XSXTdeujtEtbN2JE8rYNdjzi8VDRa2kJx2+KGc9ELMa7NiaotjYY/1mzzuL55+2qmoPB99XUFH6PRc4DFDgKl3fS5AZ+hLqB+/eUZNo6dqDNDNXUBHv22LM7AB3NPWsWQYrs1mPHwi+gqsp8CPXPmascb6m7NavruU4y9elaSKbbT2YgSI11zLZPqXWuR9uORyI5U1n4j2mB2byrqooCk06p9dgxEmb8tYC0Saj2B99XU1P4PRY53mzX1Hef65QUkl5AZoUfIY8nV/ECMiN+hHrIiBGQx4mwwvyxHTSxeU1NsH+/2QeVo9gUFLNmAZu0DXgIvYgdgOnTOVpxRnAtJCfDdTWmgoL0q2aiVrCkdPGkcjoNKFN9V6ZyV/Vd9Smqbbcfrsfe1ait6d3aGo6fHc/C6dOJGQ3yEJAwNvisuRCmBtkTfF9NTfkctCtDS8MBtd/3iBHDYK8776TJCi8gu0naf7rmAzsXpoOYDzgnaFOuqgp4UG/+3IGTuWfatMA0tAHQEGa0dje0ShUqmeYeLemyYnd2Jh9H7dFk97xOR+re2akCvKupgGynCGxfbZ272Ze7P7cdPzueZ06bFvwjaoVg8+2qayHM8wz2+2ptLQ6+R8qiJxv9HGRu4EfI48lFvIDMCj9CPSRpeaHjSUjWIG0Ci3zGjdMqVmUlsEvvZnkCx0s6aVKSaW3vYbdycHNOuvGA2ZjNbjdt2dUSjxzp+jq3nGoGd8eUd7U811TuyvROvYd97mPHwnNisXCcCgqSc0YCnDlpUjDO+yAY/8pKgu+luTkf+305O8Amq4rBssNhktnHC8iM+BHqK8wfm/1xai9ouFeZnUssiR0KloCcwJmDLC8PTENXQLorZjKF9qQTiocP6/Lx49HCMvXaqEfrzlxmVFuu4EoVitY8HzkyexPbDflxx8a9TzBVUV4ejPMJCMa/JHaIhEmIqwPG9ffV1uYkZxquQsRrkFnhR8jjyUW8gMwKP0LdJMkcdFSlE2jPptU8tBfUernzAw2SlpbkbTRttHMiQbsxCaOCqtOZouk0QVdrtH1KPS91nXPqfSyuAybV+eKa6q4jJ1WbdO/txne6z3P8eLI2aT9LZ8ZHjY17r9DRkgjHua0tHP+WFhIJu91HPvb7OngwHDP7veY5DRcUFJ76ssV7sbPiVP+ahxzJAsFKjPzwb7G9PTm5rmMnRq0iiQpOdu/jlg8fDucT05m77rydnRMcOTJZQLrrvO3nqddH9aMrodzREX7ubqHqCvj29rB9+xynnZZ8/yjz3Q3adwVqcK5rg7v2c3u7IyPysd9X6j+dYcspL+X7n2EQ0OXxeLqNNbGzeWXVnCwQkTdEpE5Ebon4/DQRedR8/pKIVDqf3Wrq3xCRSzK1KSJTTRt1ps1CU3+BiLwiIp0isrgXoxPg/4X0K6HN6S5LPBF1akGOtoyfAAAgAElEQVTBSaak+/fpmrapWluUF9pty7Zx2mnJ65fdQOui2InwwpTtI7JSqQoKGDPS+XMqTXazH+rIcxW3wPxta0vWeqNu42qTUQHy7ta2kU6rlB+5Hf88Z/mgJkOw53CiD+cgRSQf+ClwEXqr580islop9bpz2nXAfqXUNBFZAtwNXCEiZwFLgLOBicA6ETnTXJOuzbuBHyqlVorI/abt+4C3gWuBm/rkwfAapMeTm/StBnkuUKeU2qmUOoresG9RyjmLgIdMeRVwoYiIqV+plDqilHoTqDPtRbZprvmkaQPT5mUASql6pdTvIFoH6Qleg+xXwolDV5tJ+q/kbPrc1eqXY8einS2px+4cIyRriqNGhRpkUexE2GBHB7Q6WmNPtiTsygMEFMViFJlOlSRiQbactjaCZX2uZpluDjVKWz52LH1oUXCi403Kc05Ivi5lonc4071dDUtFpMY5Xm62bbZMAnY5xw3AeSltBOcopTpF5D1grKnflHLtJFOOanMs0Gq2lU49v8/xArKPSTb17A/ueGi1xuOhnehKvfb2wGkSEZvMwYOhcEsXh+gKQDfTjf0dFHYecu6XIlVde9s0erQzL+iHa3VbWeOau24ge2HBiWTvjG3ESr/2dorMyUWjYxwtLgpOtbGLrgluBWg6j/3Bg5Ex+2FgeqpjzHY8Hneqj2O/r25MvZ26dM/EblFKzenP7gxVhvufgcfjiaJv4yB3A5Od4wpTF3VOg4gUAO8D9ma4Nqp+L5AQkQKjRUbdq8/o1QiJSAJYAcwAFPAV9CYfjwKVQD3weaXU/jRNnHIkmX6xcPhsppdYTGtdo0bpWs3xcFVHaWmwrOZEczOdRoUpaG5mdPHJ93KUriB8zw3LcbP8xOPhih37ntdxKCmhr3uha+a+Z/Ip7t+fbPJCekdQ6jJCG44Tj+cxapRejldcrN/f97405n1nJ4WdOklEYUEB8QqtTdrxcpcRuia4GzaUaprbftn74YzzCXdwSkudxCDHsd+Xu6VFVMamzo5hEAbUtwJyMzBdRKaihdUS4Isp56wGrgE2AouB/1JKKRFZDfxSRH6AdtJMB34LSFSb5pr1po2Vps2n+upBUuntCP0IeE4ptdi42ouAfwB+o5S6y7jmbwFu7uV9hj7mFxOLaYGgf5zhml37QzzQWcQY8wPNa24OVmvH9+4lMVWX7d+t+8Nvbw9/16NHJ5vQzu+dQru80RWK5uQD7Xm0GkHY0hImmW1qCvvn7u/iCp2ODFOUrontznvabVoTCSgrs3V5lJYWBfVj4kYIdXRogQ6UxAtMW4VBP1M91FZop46TOzYA1O0NxjnP+eBAZ1FS5iT7fbkZ2099SZiGPhSQZk5xGbAWPU/xgFJqm4h8G6hRSq0GfgY8LCJ16CXxS8y120TkMeB1oBO4USl1XHfx5DbNLW8GVorIncCrpm1E5CPAE+js1J8RkW8ppc7uzbP1eIRE5H3ABWi3OsbTdFREFgHzzGkPAdXkgoD0eE4l+nipoVLqGeCZlLp/dModwOVprv0u8N1s2jT1O9Fe7tT6zWiTu8/ozQhNBZqBfxORDwEvA18HJiilGs05TcCE3nVxaNLZSeTyjXhcayFaSbFqyPFAC6qrg9kV+jvM27Ej1CAbGii128EaXKeFuzzPNaXLyhxzujNMjnEiFpqqTfW6rqEhzHDT0BBqkG72mo6O0AmTKQdkOvLzQz+I6013NV0zBJSVQUVFnikXnfQshRylrKwwqS3Qw+2OTWqiD3sf+7BJGqS5eV2du+/Pcez35W5vERVQOiyUyu55sXOW3gjIAmA28DWl1Esi8iO0OR1g5gtU1MUishRYClBePiXqlCFJ2h9HICD1of6h22Ss+dhp2O3bi5k9bRoAhevXBz9c6usDE9S24Zq2nZ3h0j/XXE0kwnmyEwWFgaBoaAjf3c2o7Dan772X3LYbHuRmMbfvUYHY7ni4fe3oODkkqaUlFGJNTUHGMcaNC5+lsjIUnBUV4T8a+3yJRBgg1dkJjY3R42THz7ZLfX0wzoUAZvy3b4dwejwf+31FCsgUTnkh6ZNVZEVvAsUbgAal1EvmeBVaYO4RkXIA8/5u1MVKqeVKqTlKqTklJeN60Q2Px9Nt+nip4XClx0+vlGoSkV0i8gGl1BvAheiJ1tfRnqW76GcP02By7Fh0phftvdbaS3GxVvn278/HpvPfurUYPvQhAOKYLQAA6usZ06m3t08kSoCT4x3dGEc3VrK9Pdxq1prQVmtMNaVdi3GCmfwoLtZeZtAanWsKQ/ISRfc348YluksGXW3R1Vj3G2Xt4EF9bMuug8j23/a5rAzKyvJOem53G9zUcbL9t+NJfX2QmTMBwfjrrWnsthj5wfdVVhZ+j1EZm6K2pDjl8BpkVvR2hL4G/LvxYO8EvoyWF4+JyHXAW8Dne3mPIYNrirrJZwudLK32R6vn1nR5//4Yem9sePVVYMnHASghWUDaDZ0rKy8A9KFr+rpmrg1xaWkJhVB9Pew2EWFW0LS1hXOJiUQo9LTg0eWKirBcVgZ5rUawuK7hdMt4gpiaGJQbu3RGnBNGyNt+NDWFZr8ryFtawqYbG1MzssOkSWF407hxoeByBbUb6hSLmaztdgDtwBhKAD6ux//Vm8F+LxBLmhcNQoRsQL2TbSkqrdspiReQGenVCCmlaoGoCPsLe9Oux+PpZ7wGmRV+hLpJ1FK3QucPzWbFKSvLCzSZLVvGYKdiX3sN9kz4IAAT5s6lcJNehnq0uTkoz1kYapBubl1X07K8916yQyZ1LXNxcag1TpoUaleVlTBhtI451CqdUdm2tyYnbox68ChSosbzTHT3RGPvTkwkmF2l1dQ9bUWBUudqva42aTXM9vYwcL2iIpwKgGSPta0fPRrm2H/Za5yxtSfOnRuM/2uvQbhv0PhgbMrKnOxGzt402W5RcUrgE+ZmhReQPSRpXbCzosZKqLKyMaGpRymgpVpj4wHWrtXe0qsvuogxRigeAEpffBGAs666CoBZsybaHUrp7AwFoWvxtrZGhwKF3uDAacu0aVDUbnxmTU3wRkRsDIRLV6yd2V03tjs4djKxpSV4gAmJBBOmamE5c+Z46ur0KXV1yWa4fVZ3O1zXw26fu7NTm9+gt9U9K/GOPjDjeQBnc9eLLmLtWl1sbDxAmOKsNElAhunICZ67M80swymJ1yCzwo+Qx5OreAGZET9CPcRVkk4UFJLnunbRWojV3MrLYzQ2WiOvgSefPAuAq+9YzJif/ETXtrbC88/rU554AoB5n7sxUMBcb3SqJ9mWE4lQc7T3rqqCEqw3tyla3SwtjVy7eNQYpu3toefWtbohzJgzYkTYRCFHw/u46XmsVuasZyxKtPDBCq1NVlSUBBqz1SobGkiK7bSapTv+sVj43PPmheNnx7MDKLWq5+LFPHmH7X0DdnlheXksGLOyMk5aT3mioDBtCrZTEq9BZoUfIY8nF/ECMiv8CHUTV7Fwct2GjhozD1dSeoJp03TcXFUVNDbaWbB3WLNGl1657YPMvugiAPIef5x3zLUTH31Uv3/iE1RWam1z69akaJVAW5swASabpFDvfz/8yZ/o8owZ+j2v4e1Q9ezoCCfmS0sD783ReEk4VdgErUaLc5cfZpOsIlxWWEgiMd7cxrxXQmG70WTdjBitrc6YtTN37pSk5zvtNPjjH3V51y7Ysye5b6AdTuefr8sTW18HM352PPMAzDi/0vnBYPxhPzqBjP6OrAZZkjgBLY56ykk5d099LdI7abLCC8ge0tkZxsMlCUhni77KSi0UZ8yA9evHmyt3cuzYGwA8+OAHmL1IZ6aPP/44O80ZYzZs0HVPPEHV5VpArlkTLs87ciT0RldUhOblzJn6hw5GMIIWQPaH4KxRPNBZlOQQcS1id8mgJVNwdGryXPeW4a1LTJ9LGFPgeNAdj5Nd2jVjhhaUBQWhWe/2s74+NO8rK8Pn5vEnaDfjZ5dwnQFgxvnBBwnGXxvf4839nPjJ9vaT/gukft/DAq9BZsSPkMeTi3gTOyv8CPUCd1eBokTyLn60t1NRoTXIqioYN04vAWluLkQvMIJVqz7APfdcCcCYm27iqPFA1Jv2Zzz1FGf+5V8CUFpaEmgwbphPPJ6yCqbl3eTOOU6XA4yhwTSeugQxNdIHkvfKzibKxx0PNwzJtuVmEqowiXErKs5gjF3u56yFtM9RVjY+KYmHuzOi62M6s9SY7089FYyfXV44pqyMo5frcV71d2DHH0YG30tVVaiJJzVuBqGjdRhpjuAFZJb4EeoF7qZRwbpsZy5yTEz/RKuqCoM5wfXrx6KTrkNj41s8+ODpACy9/PLAo20zcB3avJmiZ58F4EMfupJNztZGbhoxGySt65Kzxe5rLwyEYn198tI/N2wxKkO5ayZHCctUoejGJbrzl/bdlTmuULdTERUVYyiJH00a3Bjh88XjyX2yAu1DHwLMOB3avDlYvmmznXH55Tz4oC42Nr5FuLywIvheqqoIvi9awwFx1197AZl7+BHyeHIRLyCzwo9QD3G1iSNHQo1pjLPU40RBmNNw1ixdvXHjWXR02JjICaE3ds4cKk3RfilFo0cHLupt62D9emsHv8GOHVrr2r59aqC5jRgBsxNGRayuBqCkupqSzZsBqNq+HfMpLWCjIzlAuKLuKOGmwkedcy2p+fFORJRj6L03INx0Ik64mqWEULsrAwqth+UjHzGBjATv21vP4D/+Q1f94hfQ2Phm0OsdOz4AwPnnx2C+Hqei0aMpM+szg9TSc+bQHjzEBGCm7mdsWvC9JBIE31deaWmgQdrv58iR9FvRnoooFe5a6UmPF5B9RBA0bk3tzs5gf5WysqIghKSyErZvt9vB7uCee/SPdd6aq5n917UATPzhDwHY19ZGyde/DsC3v/Utbmz6LADbtn0oyGozcyYUtRiPdUsLdGr7+OhVXwFgXdlXeNqc+9R71sQEvT+7cWNzgFAcQrhdrVlyyAinnIe7nW0oFg8Dx5xyajryQkIRWQHoASkvP51F83TtZz4D8+ebs+v/AMBsXmH2Mi1O77hjClu26I17Dh6Es81uIxNeWg1fvz0Ys4nmLrG//msAXplxNfcstP3YgZ2GqKwkKTjcfl90dgbf43AQhlEoNXyfrS/xAtLjyUG8gMwOLyD7ADeI2DolimKxpG0YbIzdOefA9u3l5sodNJrUPHfeWc5/rrxLX2vW2bU//TS/q9VaZdGiRYFm9MmqKrjc7H80+QZ++aKOGbzjjins2FFtzlpu3m3MXyoz0QngAS5k8mRtkJ5/fhhTaPvsrkS0sYcWd2dB6xWvrydYMmjyRbBrVwNgvUy/Af4Z0JmJ7r9f1+r3D5hztMo3ffo87rhD13xx3juc9ytz8uOPc8jcpA4wuh9lQNFnPqMP7tLjeecSgnHW6PE/55zwGYMtFgBiseB7dBcDDCe8gMwOLyD7gNTtSAGOFhTS0anntBoawiw1HR1QXKzntw4fnsmnPqXr77sPuOEGAPY9/bQ+F/jg9On6hOee4yt3ngHAv/3bXviOWVLynQnceqsubt8OeSu0acomM8MYmxxOgF52Gb+u1YHRq1YRrChpbNzPrl1akD7yiBvvE3PeXXPbNbFds9peG9XGeMrLFwOwcOFiFusiF896F558Uh/U1kKH6fdc/Rwnrp/HbbfpKrlyAma3UODrfPnLYwF44LadsEDvePb2jh3B+JWY8bzvvgewQvHZZ8uDZEUdHcmp4mzoUawgOi/wcBMow+15+gM/S+vx5CBWg8zmlQ0iskBE3hCROhG5JeLz00TkUfP5SyJS6Xx2q6l/Q0QuydSmiEw1bdSZNgsz3aOneA2yh2Taz6ijI3m5sZt5xpp1BQVh+fhx4MMfBqCkpka/79gRrtXbuJFly7QG2dIylqefNvUc4P77i009XHvtUgA+Zr0d69aFqXHuvJOLzUY0Fy+cCXfOBWBn+3g2bdJt1NaG5rHVrtw9ZlIDyt24RJuYt6IiNNOt8jp3LpwRN0HsmzbB5i26vGZP2MisWYGX5n+b9LM+eIPWdu2zWhP8M5/JZ9kygrGx4zQlFgOrdZvxPH48HOeZM5O/C1t2c02mI8pSOFU5cSJ6cUBPEJF84KfARWjP32YRWa2Uet057Tpgv1JqmogsAe4GrhCRs9BmwdnohfHrRORMc026Nu8GfqiUWiki95u270t3j948m9cgPZ4cpI81yHOBOqXUTqXUUWAlsCjlnEXAQ6a8CrhQRMTUr1RKHVFKvYmeUj43XZvmmk+aNjBtXpbhHj3Ga5ADQH5+9FK9trZkx8ZEq+ZYVaajA3bs0OX//m9mm82mFi6cQkODngd89dVC9u/XmtmKFWF27sWLtQa2ZMlSSra+oCs3bAhT47z2WjD3d0ZZGWeYeJcvXlYVpALac1iH5ezeHb0JWH5+8iZlkybp8oSRB8INs6w6uqIuOU249Yq8//3BJlr7ZlzAypW62mqN1dWglE07MYpzzsk3YwCzS98OxiYYp46OcPzMeNbXh+Pc1hYmTHetALvneC7RDS24VERqnOPlSqnlzvEkYJdz3ACcl9JGcI5SqlNE3gPGmvpNKdeav6TINscCrUqpzojz093DDeXtFl5A9jFuEhj7oxs5MjkfrbUo3e0EamrgY9dqQRHsCbBlCx3Gto0991ywPm/pbbfR3l5o7jeKLcZaVaqB9etHmva0A+O552Ch2eNm0fUXMOGt3+qTq6u1PQ2wfj1ODrCggxNMpyckEsnrD921hu7iaDc5bqr9NmoUTNUxjMyZEwSC7zn9XJ4yGwOvuSeIb6etba+58DCgzf+ZM0dhdqNg6bVH4c4V2IcMxsmNyjeCt+bBcJyPH0+eFrCPNXJkspA81U3oTHTTi92ilIranG/Y4wWkx5OD9HGYz25gsnNcYeqizmkQkQLgfcDeDNdG1e8FEiJSYLRI9/x09+gxvRKQIvLXwPWAArag98UuR88XjAVeBr5k5hCGNdbsdPMi2nIsFlp9Tp5a9u8Pla6aGnhhljZpL7jMTKnU1VFokjB07NpF7OGHg7b/5qabTHtj+MUv9FKZdetGoZReKdPWpq2Kp5+O8fTT2jFz770x5s8/F4AFC87l4m+Yr+X55+F//keXa2tDp44xj0+0tQXrbNylhRBOYhcCea69bZeoWG3uT/80SFr76+pCnjOm9Lp1sGWL1Tb3EIYIaTVP5PRgdc1VV8HVl5nMP3feA2Y8OnbtCnct/OhHwYzfC7V6PGtqwnHOzw/Hv7Q0eRMw97uzHE9dEDRM6EsnDbAZmC4iU9FCagnwxZRzVgPXABuBxcB/KaWUiKwGfikiP0A7aaYDvwUkqk1zzXrTxkrT5lNd3aM3D9ZjASkik4C/As5SSh0WkcfQD3Ep0R6mYUdUZu0oCgpCU66sLMxk4+5I2NAQmpfTrv8kABOvbCTP/BXH1q+n09iJBQ8/HFx49bXXMuMuHfC9ciU8/bTODrR9u81Y8xagTektW46bLWjhhz+cyLhx2gw///xPM2/ep3X5Tpg9w4hDY4Ln7dhBzO7N6rrkCwpCCTNpUug9njWLV7ZqkWUDxat/Bi9+WZebm/cCZudBDhDGVY4BdP+rqrTQ/8xnYIkJfZzNK3Dbg/rg6aeD8YgBfOITuv7KK3mnSo9f9YpwbC3jxiVnErLfSzZ5G4ab2d1Xz2Pm+5YBa9Ff5gNKqW0i8m2gRim1GvgZ8LCI1KHTACwx124zsuN1oBO4USl1HCCqTXPLm4GVInIn8Kppm3T36A29NbELgJEicgydn6AR7WGy/z0eAu5gmApIj+dUpa9X0iilngGeSan7R6fcAVye5trvAt/Npk1TvxPt5U6tT3uPntJjAamU2i0i9wBvo2fSf402qdN5mIYV7m6CbjlqawI3x2JpaZjH0FXGOjpCh++6dfr9qquuJM+u5YvFKNi4UZd37w5XnzQ1MXuhXpY3+7bLWLBAa4hr1liz+yy2bLHa5E7CBBWv09ysDeYnnhjBE0/YRBKl2FUnoOMIJ08+NzBLE4nk57YacEsL7Npl7dF3sfuAhw7EA4SrbvJITlyhPe4zZ44KzGnzSHxyzoHwWdesIUiK2dREgdVeP/pR7NKcE1+4knW/0NV2PDs6kjV4O/7uEkp3e5bU/WdsXVT5VMUvNcyO3pjYxei4o6lAK/A4sKAb1y8FlgKUl0/paTeGDPaPLSpcJD8/2YtthU1ZWXLm7f37ddlGyDz3HFxq7cvTTgsvrK2F5uawbKXU1q18cq4O/v7kbfMAeOWqEqqrtbCsrp5JdbXOHtTW9hZgU4c1kJzZx0oHLfB27YJdu+yDpUt45k7W5aOXJEIoCEsJE5BNZfRobUrPm5ec4Wx2pVlqaOcb7twUetvr60PJVVUVzm9ecgl87nOAHjM7fnY83ZmAsjKShL39XtKF+QxXIeIFZHb0JlB8PvCmUqpZKXUM+E/gTzEeJnNOlDcLAKXUcqXUHKXUnJKScb3ohsfj6S59vdRwuNKbOci3gbkiUoQ2sS8EaoB0HqacwPV6Wq/oiBGhCTdqFIzVvhHKypK3L7XKkY2n3rIFEgmdQOFjn/tcGJVdURHaj42NoTa5aVMY8GdM0dlVVcyepzWtb3xjNiZ3Li+9dDovvqi1uJoaePNN4x3mLUJt0kZI7Cf0Lh9OeWKbBieGjVfUAQxWW9T3mDp1DHNMJN3558N5Joz4Ix+BvNpX9EFtLaw0z2Wfo6lJR3eDHjh3jwSjLTN/Pv9bWxSMmR0/S6rWbsd/1Kjwe3E92MeODV/vtUWpPvViD1t6Mwf5koisAl5Be59eRefY+hXRHqZhS9R/2VSTzc7bjR6tPamgk75aARm1j8vu3aG5GIsVMdtkrKG0NFy28tZboURobQ0bcRdUm7XdeWVlnGcm4M6bUclfXaZDcQ6VTgm823/840y2b9dmuCuj7EqU1B1R3blV6x12t2F9//v1e1Ji37o62GYaX9sQ3X930zG7wqisDE7XApdzzsFK3Fe2FgbjtHt3OH52xUzqxmZ2/EePTu+9Ts0ePtw0KW9iZ0evvNhKqduB21OqIz1MHo9n6OAFZHb4lTS9oKs4yFRT22qU8Xhy0Hiq1uiW29vDGD69o5+OLTxr7tywkbo67UUB2Ls3bNBt2Jbr6sIg8FgssC+LEgnOM+2dV1oKc0zbCyK8Ga67N7Wzrkvblv/HqJ6/ak1OCZRun1n7XPZ+8XhoE0+eHAagV1Xx+nY9hb59ezhO7pRFlHbrBofH48mavp3iSGdeDyeB4gVkdngB2UdEJVh1sXNcx49He7QPH05OvWXbtNOLjjwD8qiqOkuX4vGwkZaWcL7uoAntaW/XjUPy7mKukLK2tL1paufd43QbY6cru+e7e8faPsfjYZpyd9G63XRn9OikPGonKnTEw/bt4SxCfX04Tu4WtlYQTpgQ7bkuKIhePeN2f7gKES8gs8MLSI8nR/ECMjNeQPYBUUpX6h+f1VTy85M1HFdTsTHhltbWsK6lJVnRs1RWTtH739gGUzPbHj4c2owdHaEdeeRIqFkePBie72qWbhR7ugdzH9xVzWyf3HerFY4cGWqNros/Pz/0rERk4j0UH0+90Rq3bw/Ho6UleezcKQyA8vLQxHazKaWa13aYogTHcBMmfbwWe9jiBaTHk4N4Ezs7vIDsYzKF/LhzXvF4spIW9R/d9bm4SRcsHR1QWak34iqpjIfxOO5EZroJNbfell1Vyt3aL1NgYH5+cvoi+9C2zs1Om26O0z3HUQP3degYx3pHa6yvj3bMpMY8miaSHDOu8uoSNRzDFS8gs8MLyD6iOx7tqDRox451/QfrOqMbGpK3mbVyrLKyiDLjxMhzs/K6JnNUR7NJZdMXpHPi2Ps7i9ZPlGqh39SULBStw37Pnswea/s+dmz6tGa55LlOZTg/W1/hBaTHk4N4DTI7vIDsJ7r644ty2BQXpz8fkheZuJqTG7njhiKWlRmzuyIRvRVCqjbXlUaZrYbZVcqb1GPXeePEPe0zW0k0OQuB3BU97qNY3NhSN9+m2cCR4uLsHDPDPbTHxTtpssMLyD7GtRwz/dBS5yOjiJqea2tLXpHnxmrbKUib0qusrDAQlmMSiWRp6nquXenQFyZ3V3GQrlCMxznQYYRifbjq0M4vpi5ztF12NwxLJJLnG13BaG6RNCXqmtXp5h2Hu5D0GmR2eAHp8eQoXkBmxgvIfiJVEUv3x5hJi3Q1SHchilUEjx0L8x66jhyrdU2YECZnKCsrZOzYEgCKy0oo7Dx08oWuSpqp8+k66z6MrdNrJQE4WlAU9HlvXag1Njdr5wuEpnRraxiuCeEYuAuI3H1+xo5N1hwh2cGezqzuyeOeyngNMju8gOxH3D/ATMIynaB0o2RseEosFm12ussVrbxrbQ2FTkND8pI7m0otkSginigJ7p3XeTS5o9kGijsS/ERBYVI/2tuh1UnaE7Vs251ndSOMXK+/6622S7SLi5NXLqYmwU1nVrvkQmiPixeQ2eEFpMeTg3gBmR1eQA4Q6bTJqAS7lng82sQeOTIsu9qYm6vR5qzo6Ag/j8dD54ebtMHVutysQeF7UaSTO9WpEbVa0dUgo7ztqda91fTsWLj5K7TWq8tu8HdqsqHUGPV0ce65pjW6+IS52eEF5ACQusFXJlxB6c472jZOOy05Q7kVDvv3h0l8XGFl5/AOHw7bbm1Njs92E+qkLqMuKDhZ6FiiTFdXQLqJhNwII9eEdp/beqbd57Nziu97X3LZnuv+I0mdb0ztm72/+55azgUGSoMUkRLgUaASqAc+r5TaH3HeNcBt5vBOpdRDpv7DwIPASPQOh183e2NHtisiAvwIvf30IeBapdQrpq3ngLnAi0qphdn0vzd70ng8nlOUAdyT5hbgN0qp6cBvzHESRtjdDpyHTrZ9u9kUEPSW0X8OTDcvuzFgunY/5ZErE2AAAA/MSURBVJy7lOQtp78PfKk7nfca5ACRLj4yk2ZpNbf8/GSNz91OwNWkUoPJ04U7uuZVe3t0nHjU0uls0kFG/bDSPV+qxuqa+vY9ypR2nOInbW+RunwwtY+5rDlaBnAOchEwz5QfAqqBm1POuQR4Xim1D0BEngcWiEg1MEYptcnU/xy4DHi2i3YXAT9XSilgk4gkRKRcKdWolPqNiMyjG3gBOcB0x9xO/eHb41gsWVi6oS9WMLp5c23d4cOhCZ66cqS/hUZqrgpbHjUqWdi7eXJtXZRQdM3+VFIFY6acvrnIAArICUopu0l6EzAh4pxJwC7nuMHUTSLcQc6t76rddG010gO8gPR4cpBuOmlKRaTGOV6ulFpuD0RkHVAWcd03k++plIio7vY1E/3VLngBOShEmduZlia62lJ+fnjserfj8WjvsVsX5WlOXWnYEydGqhkeZaa7pnSUWR1lYrvnZqM1un31mmN6uqlBtiil5qRvS81P95mI7LEmroiUA+9GnLab0FwGvWdwtamvSKnfbcrp2t0NTE5zTbfxThqPJwcZQCfNauAaU74GeCrinLXAxSJSbJwzFwNrjQl9QETmGu/01c716dpdDVwtmrnAe44p3m0yapAi8gCwEHhXKTXD1HXbxe45me6G/0RpT+m0SVertKE2iUR0+M/x49EpI913NxwnihEjoucY3blS289Ux0y2IUbpyCaMJ/WzXGcA5yDvAh4TkeuAt4DPA4jIHOAGpdT1Sql9IvIdYLO55tvWYQN8lTDM51nzStsuOhToUqAOLYO+bDsiIhuAKiAuIg3AdUqptV11PhsT+0HgXuDnTp11sd8lIreY45tJdrGfh3axn5fFPXKW7ni0XbIRlpBstrrxh67QO3Ik2bsd5YHujoBMvb89djN5u59HCdZshKLbv65MaC8UT2agBKRSai9wYUR9DXC9c/wA8ECa82Z0o10F3JimLx/vTt8hCxNbKfUCsC+lehHatY55v8yp/7nSbAISZn7A4/EMMQbIxD6l6amTptcudhFZig7kpLx8Sg+7MbxwHTbucSbSaZP23Wpux4+7e2und8yk3tfVHlOX7KXbbyfKSZMurjKTthh1765iG6PO8STjE+ZmR6+92D11sZswgeUAM2bM6RcX/alKT81u6FrYuCY4JAvOqHv3VMCkCyzPVhC6ZNM376HuPj5ZRXb0VEAOiIvd4/H0D15AZkdPBaR1sd/FyS72ZSKyEu2c6ZWL3ZN9nGRXZNLcUmMsLVbDHCjSZdzJVI469mTGj1lmsgnzeQQdxFlqXOO30wMXu6d3pJrd6f64U+cx09ETc7cv6Y4wTFfnf+A9x2uQ2ZFRQCqlvpDmo2652D0ez9DBC8js8EsNT0Gy1SZTz0/d9qG/tMwo7TCqP+mO09V1Ve/pHt6LnR1eQJ7ipAqM7ni9M5njUW10le4s2/tlW9/d9j3dw49tZryA9HhyEG9iZ4cXkMOMdBpl1Gd90X5fX+t/tAOHUicGuwtDHi8ghznpBE5fC87u4gXhYKOADJPFHi8gPZ7cRAFHB7sTQx4vIHOU7mhwmbzdPWnTMxTwJnYmvID0eHISb2JngxeQnox4zXA44gVkNngB6fHkLF5AZsILSI8nJ/EaZDZ4Aenx5CQKyLCPhscLSI8nN/EaZDZ4Aenx5CxeQGbCC0iPJyfxGmQ2ZNzV0OPxDFdOZPnqOSJSIiLPi8gO816c5rxrzDk7ROQap/7DIrJFROpE5MciIl21K5ofm/N/JyKzTf0sEdkoIttM/RXZ9N8LSI8nJ7EaZDavXnEL8Bul1HTgN+Y4CREpQe9UcB5wLnC7I0jvA/4cmG5eCzK0+ynn3KXmetA7HFytlDrbtPHPIpLI1HkvID2enMSuxc7m1SsWAQ+Z8kPAZRHnXAI8r5Tap5TaDzwPLDAbAo5RSm0yuxX83Lk+XbuLgJ8rzSYgYTYY/INSageAUuod9EaD4zJ13s9Bejw5yYDNQU5wNu5rAiZEnDMJ2OUcN5i6SaacWt9Vu+naCjYPFJFzgULgj5k67wWkx5OzZD2/WCoiNc7xcrOvPQAisg4oi7jum+6BUkqJiOp2NzPQnXaNVvowcI3KIiGmF5AeT07SLQ2yRSk1J21LSs1P95mI7DEmbqMRTu9GnLYbvXOqpQKoNvUVKfW7TTldu7uByVHXiMgY4FfAN435nRE/B+nx5CwD4qRZDViv9DXAUxHnrAUuFpFi45y5GFhrTOgDIjLXeK+vdq5P1+5q4GrjzZ4LvGeEaCHwBHp+clW2nc8oIEXkARF5V0S2OnXfF5Htxl3+hOsNEpFbjYv9DRG5JNuOeDyegWTAnDR3AReJyA5gvjlGROaIyAoApdQ+4DvAZvP6tqkD+CqwAqhDzxk+21W7wDPATnP+v5rrAT4PXABcKyK15jUrU+dFO4e6OEHkAqAdLXlnmLqLgf9SSnWKyN3mIW8WkbOAR9Cu+onAOuBMpVSX/4ZmzJijHnuspqtTPB5PLzn7bHnZmsoiZyr4aZZXXvxyVyb2cCajBqmUegHYl1L3a6WUzRK4iXCeYBGwUil1RCn1JlqKn9uH/fV4PH3GgJjYpzR9MQf5FUK1N52L/SREZKmI1IhIzb59zX3QDY/Hkz0DFih+StMrASki3wQ6gX/v7rVKqeVKqTlKqTklJRnjNT0eT5/iBWQ29DjMR0SuBRYCF6pwIjOti93j8Qw1/KZdmeiRBikiC4C/Bz6rlDrkfLQaWCIip4nIVPR6yN/2vpsej6dvGTAv9ilNRg1SRB5BB3GWikgDelH5rcBpwPMmucYmpdQNSqltIvIY8Dra9L4xkwfb4/EMBj7dWTZkFJBKqS9EVP+si/O/C3y3N53yeDwDgReQmfBLDT2enETh5yAz4wWkx5OTeBM7G7yA9HhyFi8gM+EFpMeTk1gvtqcrvID0eHISPweZDV5Aejw5izexM+EFpMeTk3gnTTZ4Aenx5CReQGaDF5AeT07inTTZ4AWkx5OzeCdNJryA9HhyEm9iZ4MXkB5PzuIFZCa8gPR4chKvQWaDF5AeT87i5yAz4QWkx5OTnMB7sTPTF5t2eTyeU5L+35NGREpE5HkR2WHei9Ocd405Z4eIXOPUf1hEtohInYj8WEyG7nTtiubH5vzfichsU3+6iLxi9sPeJiI3ZNN/LyA9npxkwDbtugX4jVJqOvAbc5yEiJSgdyo4D71N9O2OIL0P+HP09i3TgQUZ2v2Uc+5Scz1AI/BRpdQsc59bRGRips57Aenx5Cwnsnz1ikXAQ6b8EHBZxDmXAM8rpfYppfYDzwMLRKQcGKOU2mQ2Bvy5c326dhcBP1eaTUBCRMqVUkeVUkfMOaeRpezzAtLjyUkGTIOcoJRqNOUmYELEOZOAXc5xg6mbZMqp9V21m64tRGSyiPzOfH63UuqdTJ33ThqPJ2fJWviVikiNc7xcKbXcHojIOqAs4rpvugdKKSUiKuK8XpFtu0qpXcAHjWn9pIisUkrt6eoaLyA9npykW17sFqXUnHQfKqXmp/tMRPYYE7fRmMzvRpy2G71zqqUCqDb1FSn1u005Xbu7gclprrH9fUdEtgIfB1al6ztkYWKLyAMi8q5pMPWzvxURJSKl5jjSg+TxeIYiA2JirwasV/oa4KmIc9YCF4tIsXHOXAysNSb0ARGZa7zXVzvXp2t3NXC1kUVzgfeMEK0QkZEA5h7nA29k6nw2c5APEnqOAkRksnmQt53qdB4kj8czpLAZxfvdSXMXcJGI7ADmm2NEZI6IrABQSu0DvgNsNq9vmzqArwIrgDrgj8CzXbULPAPsNOf/q7ke4E+Al0TkNeC/gXuUUlsydT6bfbFfEJHKiI9+CPw9yf8RAg8SsElErAepMeJ6j8czqPT/UkOl1F7gwoj6GuB65/gB4IE0583oRrsKuDGi/nngg93sfs+82CKyCNitlHot5aO0HiSPxzOUGDAv9ilNt500IlIE/APavO4xIrIUbYZTXj6lN015PJ5uo4Bjg92JIU9PvNjvB6YCr5lVPxXAKyJyLll4kCwmTGA5gIg0n322HARaetCfgaCUodm3odovGLp9G6r9gv7v2+lh8b218HRpltcN1fHqd7otIM3E5nh7LCL1wBylVIuIrAaWichK9HKe97KZf1RKjRORmq5CCQaTodq3odovGLp9G6r9goHtm1LqJMer52SyCfN5BNgIfEBEGkTkui5OT+dB8ng8nlOObLzYX8jweaVTjvQgeTwez6nIUFqLvTzzKYPGUO3bUO0XDN2+DdV+wdDuW04iWunzeDweTypDSYP0eDyeIcWgC0gRWSAib5j12ycl0xzgvkwWkfUi8rrJOvx1U3+HiOw22YhrReTSQepfvcmuXGuzq2Sbsbkf+/QBZ1xqReSAiHxjsMYsKndAd7NPD2C/vi8i2829nxCRhKmvFJHDztjd31/98mRAKTVoLyAfvb7yDKAQeA04axD7Uw7MNuXRwB+As4A7gJsGc6xMn+qB0pS67wG3mPIt6Dx3g/l9NqHj7QZlzIALgNnA1kxjBFyKXtsrwFzgpQHu18VAgSnf7fSr0j3PvwbvNdga5LlAnVJqp1LqKLASvZ57UFBKNSqlXjHlNuD3DP2lktlkbB4oLgT+qJR6a7A6oJR6AdiXUt2t7NMD1S+l1K+VUp3mcBPJqb08Q4DBFpBDdu22SdBxDvCSqVpmTKEHBtqMdVDAr0XkZbNUE7LL2DxQLAEecY6HwphBD7JPDwJfIcxUAzBVRF4Vkf8WkY8PUp9ynsEWkEMSEYkD/wF8Qyl1AJ227f3ALPTmP/80SF07Xyk1G51W7kYRucD9UGn7bFDCEkSkEPgs8LipGipjlsRgjlE6ROSbQCfw76aqEZiilDoH+BvglyIyZrD6l8sMtoDMeu32QCEiI9DC8d+VUv8JoJTao5Q6rpQ6gV4hdO5g9E0ptdu8vws8Yfqxx5qFkj5j80DwKeAVZVLYD5UxM6Qbo0H/+xORa4GFwJVGeKOUOqJ0Oi+UUi+j5+nPHMh+eTSDLSA3A9NFZKrRQJagMwIPCqKzb/wM+L1S6gdOvTsv9TngpOzqA9C3USIy2pbRE/xbyS5j80DwBRzzeiiMmUO3sk8PVKdEZAE6p+pnlVKHnPpxIpJvymegE1DvHKh+eRwG20uE9iT+Af1f8puD3Jfz0ebX74Ba87oUeBjYYupXA+WD0Lcz0F7+14BtdqyAseh9gXcA64CSQejbKGAv8D6nblDGDC2kG9G5vBqA69KNEdp7/VPzt7cFnXRlIPtVh54DtX9r95tz/z/zHdcCrwCfGejv1L/0y6+k8Xg8njQMtont8Xg8QxYvID0ejycNXkB6PB5PGryA9Hg8/387dSAAAAAAIMjfeoINCiKGIAGGIAGGIAGGIAFGEquPYaV4s+sAAAAASUVORK5CYII=\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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}