notebooks/notebook1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "notebooks/notebook1.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python2",
      "display_name": "Python 2"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/stoiver/anuga-clinic-2018/blob/master/notebooks/notebook1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MFkDMm10DPK7",
        "colab_type": "text"
      },
      "source": [
        "# CSDMS ANUGA Clinic 2018\n",
        "\n",
        "## Notebook 1: Introduction to ANUGA\n",
        "\n",
        "Here we introduce the idea of creating a `domain` which contains the mesh and quantities needed to run the simulation, and encapsulates the methods for setting up the initial conditions, the boundary conditions and the method for evolving the solution. \n",
        "\n",
        "These notebooks have been designed to run in the google `colaboratory` environment, which provides a jupyter notebook environment running on a virtual machine on the cloud. To use this environment you need a google account so that your notebook can be saved on google drive. \n",
        "\n",
        "To start interacting with the notebook follow the \n",
        "`View in Colaboratory` link above. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dt-Ti7kdQX3C",
        "colab_type": "text"
      },
      "source": [
        "## Setup Environment\n",
        "\n",
        "If on github, first follow the link `View in Colaboratory' to start running on google's colab environment. Then ....\n",
        "\n",
        "Run the following cell to install the dependencies and some extra code for visualising on Colaboratory.\n",
        "\n",
        "Wait until you see the comment *(5) Ready to go* before proceeding to subsequent commands. \n",
        "\n",
        "The install should take less than a minute (and quicker if you have already run this earlier)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xdCgMgk7_ZcW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "try:\n",
        "  # On colab we can install all the packages we need via the notebook\n",
        "  #\n",
        "  # First download the clinic repository\n",
        "  import os\n",
        "  os.chdir('/content')\n",
        "  !git clone https://github.com/stoiver/anuga-clinic-2018.git\n",
        "\n",
        "  # Now install environment using tool\n",
        "  !/bin/bash /content/anuga-clinic-2018/anuga_tools/install_anuga_colab.sh\n",
        " \n",
        "except:\n",
        "  pass\n",
        "\n",
        "# Make anuga-clinic code available\n",
        "\n",
        "if not 'workbookDir' in globals():\n",
        "    workbookDir = os.getcwd()\n",
        "\n",
        "import sys\n",
        "sys.path.append(os.path.join(workbookDir,\"anuga-clinic-2018\"))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0jTxMSaddabt",
        "colab_type": "text"
      },
      "source": [
        "### Setup inline graphics and animation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zyvvRz5ydNQx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from google.colab import files\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "# Allow inline jshtml animations\n",
        "from matplotlib import rc\n",
        "rc('animation', html='jshtml')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n6CIHtFYYbkx",
        "colab_type": "text"
      },
      "source": [
        "## Import ANUGA\n",
        "\n",
        "Allows us access to `anuga` and inline plotting. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1l0-N381KKGO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import anuga"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p_QOy0bRZ37C",
        "colab_type": "text"
      },
      "source": [
        "# Create an ANUGA domain\n",
        "\n",
        "A `domain` is the core object which contains the mesh and the quantities for the particular problem. Here we create a simple rectangular domain. We set the name to `channel1` which will be used when storing the simulation output to a `sww` file called `channel1.sww`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nCKdVO1BPAhx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "domain1 = anuga.rectangular_cross_domain(40, 20, len1=20.0, len2=10.0)\n",
        "\n",
        "domain1.set_name('domain1')\n",
        "domain1.set_store_vertices_smoothly(False)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mfgw_HkDarZY",
        "colab_type": "text"
      },
      "source": [
        "## Plot Mesh\n",
        "\n",
        "Let's look at the mesh. We will use some code derived form the `clawpack` project to simply plot and animate the output from our simulations. This is available via the `animate` module loaded from `anuga`.\n",
        "\n",
        "The `Domain_plotter` class provides a plotting wrapper around our standard `anuga` `domain`, providing simple access to the centroid values of our evolution quantities, `stage`, `depth`, `elev`, `xmon` and `ymon` and the triangulation `triang`.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bb2oWmRraSU6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dplotter1 = anuga.Domain_plotter(domain1)  \n",
        "plt.triplot(dplotter1.triang, linewidth = 0.4);"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZGGxHd8EEvea",
        "colab_type": "text"
      },
      "source": [
        "## Setup Initial Conditions\n",
        "\n",
        "We have to setup the values of various quantities associated with the domain. In particular we need to setup the `elevation` the elevation of the bed or the bathymetry. In this case we will do this using a function. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KYe-klLvkpug",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def topography(x, y):\n",
        "\n",
        "    z = -x/10\n",
        "\n",
        "    N = len(x)\n",
        "    \n",
        "    minx = np.floor(np.max(x)/4)\n",
        "    wallx1 = np.min(x[(x >= minx)])\n",
        "    wallx2 = np.min(x[(x > wallx1 + 0.25)])\n",
        "    \n",
        "    minx = np.floor(np.max(x)/2)\n",
        "    wallx3 = np.min(x[(x >= minx)])\n",
        "    wallx4 = np.min(x[(x > wallx3 + 0.25)])\n",
        "    \n",
        "    minx = np.floor(3*np.max(x)/4)\n",
        "    wallx5 = np.min(x[(x >= minx)])\n",
        "    wallx6 = np.min(x[(x > wallx5 + 0.25)])\n",
        "    \n",
        "    dist = 0.4 * (np.max(y) - np.min(y))\n",
        "    \n",
        "    for i in range(N):\n",
        "        if wallx1 <= x[i] <= wallx2:\n",
        "            if (y[i] < dist):\n",
        "                z[i] += 1\n",
        "                \n",
        "        if wallx3 <= x[i] <= wallx4:\n",
        "            if (y[i] > np.max(y) - dist):\n",
        "                z[i] += 1\n",
        "                \n",
        "        if wallx5 <= x[i] <= wallx6:\n",
        "            if (y[i] < dist):\n",
        "                z[i] += 1\n",
        "            \n",
        "    return z"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RXHrU0jPFuzh",
        "colab_type": "text"
      },
      "source": [
        "### Set Quantities\n",
        "\n",
        "Now we set the `elevation`, `stage` and `friction` using the `domain.set_quantity` function. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xLn6Mozrnedv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "domain1.set_quantity('elevation', topography, location='centroids')         # Use function for elevation\n",
        "domain1.set_quantity('friction', 0.01, location='centroids')                # Constant friction \n",
        "domain1.set_quantity('stage', expression='elevation', location='centroids') # Dry Bed "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B1Y_Aad3GWV3",
        "colab_type": "text"
      },
      "source": [
        "### View Elevation\n",
        "\n",
        "Let's use the `matplotlib` function `tripcolor` to plot the `elevation` quantitiy.  We access the `domain` mesh and elevation quantitiy via the `dplotter` interface.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qGJQfKBxnjGm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "plt.tripcolor(dplotter1.triang, \n",
        "              facecolors = dplotter1.elev, \n",
        "              edgecolors='k', \n",
        "              cmap='Greys_r')\n",
        "plt.colorbar();"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jlgKD23QvDhF",
        "colab_type": "text"
      },
      "source": [
        "## Setup Boundary Conditions\n",
        "\n",
        "The rectangular domain has 4 tagged boundaries, left, top, right and bottom. We need to set boundary conditons for each of these tagged boundaries. We can set Dirichlet type BC with specified values of stage, and x and y \"momentum\". Another common BC is `Reflective_boundary` which mimic a wall. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rF7q2bzOn64K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "Bi = anuga.Dirichlet_boundary([0.4, 0, 0])         # Inflow\n",
        "Bo = anuga.Dirichlet_boundary([-2, 0, 0])          # Inflow\n",
        "Br = anuga.Reflective_boundary(domain1)            # Solid reflective wall\n",
        "\n",
        "domain1.set_boundary({'left': Bi, 'right': Bo, 'top': Br, 'bottom': Br})"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YRJs8HbRwLfM",
        "colab_type": "text"
      },
      "source": [
        "## Run the Evolution\n",
        "\n",
        "We evolve using a `for` statement, which evolves the quantities using the shallow water wave solver. The calculation `yields` every `yieldstep` seconds, for a given `duration`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3yxIDXQiH3XN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for t in domain1.evolve(yieldstep=2, duration=40):\n",
        "  \n",
        "    #dplotter.plot_depth_frame()\n",
        "    dplotter1.save_depth_frame(vmin=0.0,vmax=1.0)\n",
        "    \n",
        "    domain1.print_timestepping_statistics()\n",
        "\n",
        "    \n",
        "# Read in the png files stored during the evolve loop\n",
        "dplotter1.make_depth_animation() "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IHzda-KcvXao",
        "colab_type": "text"
      },
      "source": [
        "### Optional Installation of ANUGA Viewer\n",
        "\n",
        "On  Windows you might like to download and extract a precompiled version ``anuga_viewer.zip`` from sourceforge https://sourceforge.net/projects/anuga/files/anuga_viewer_windows/\n",
        "\n",
        "Once extracted, go to the data directory and associate the sww file with the viewer executable in the bin directory. \n",
        "\n",
        "Then sww files should always open with the anuga viewer."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WhIyS6Tr7coZ",
        "colab_type": "text"
      },
      "source": [
        "### Download Domain \n",
        "\n",
        "If you have the ``anuga_viewer`` installed on your local machine you might want to download the output file ``domain1.sww`` to your local disk and view it using the ``anuga_viewer``\n",
        "\n",
        "I had problems on using the Chrome browser and had to follow the instructions from this site to allow downloads, https://stackoverflow.com/questions/53581023/google-colab-file-download-failed-to-fetch-error"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GaXRMAszvsoS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "files.download('domain1.sww')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lDnBhN3Cc7wa",
        "colab_type": "text"
      },
      "source": [
        "# Alternative Mesh Constructions\n",
        "\n",
        "`ANUGA` is based on triangles and so  the mesh can conform to interesting geometrical structures. In our example the steps define an interesting geometry. Let's conform our mesh to the steps. \n",
        "\n",
        "We will use the construction function  `anuga.create_domain_from_regions`. This function needs at least a polygon which defines the boundary of the region, and a tagging of the sections of the boundry polygon, which will allow us to specify specific boundary conditions associated with the tagged sections of the boundary. \n",
        "\n",
        "In our previous example the function `rectangular_cross_doamin` created a mesh with 4 tagged boundary sections, corresponding to the tags  `left`,  `right`, '`top` and `bottom`. \n",
        "\n",
        "We wil do the same, but this time using the function `anuga.create_domain_from_regions`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VmUj1J82dXOO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "bounding_polygon = [[0.0, 0.0],\n",
        "                    [20.0, 0.0],\n",
        "                    [20.0, 10.0],\n",
        "                    [0.0, 10.0]]\n",
        "\n",
        "boundary_tags={'bottom': [0],\n",
        "                'right': [1],\n",
        "                'top': [2],\n",
        "                'left': [3]}\n",
        "\n",
        "\n",
        "domain2 = anuga.create_domain_from_regions(bounding_polygon, boundary_tags)\n",
        "\n",
        "# Plot the resulting mesh\n",
        "dplotter2 = anuga.Domain_plotter(domain2)  \n",
        "plt.triplot(dplotter2.triang, linewidth = 0.4);"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mBCEfV1DDtHB",
        "colab_type": "text"
      },
      "source": [
        "### Mesh size\n",
        "\n",
        "Obviously the mesh is too coarse. We can force the mesh size to be smaller by using the argument `maximum_triangle_size`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rFpr2id0MGBe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "domain2 = anuga.create_domain_from_regions(bounding_polygon,\n",
        "                               boundary_tags, \n",
        "                               maximum_triangle_area = 0.2,\n",
        "                               )\n",
        "\n",
        "# Plot the resulting mesh\n",
        "dplotter2 = anuga.Domain_plotter(domain2)  \n",
        "plt.triplot(dplotter2.triang, linewidth = 0.4);"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "njryuCywDrgN",
        "colab_type": "text"
      },
      "source": [
        "### More Complicated Boundary\n",
        "\n",
        "In the first example we created the steps using a discontinuous elevation. We can mimic that behaviour by explicitly cutting out the triangles associated with the steps. This leads to a more complicated boundary polygon. \n",
        "\n",
        "Note that we need to be careful about associating boundary polygon sections with the approriate tagged boundary.\n",
        "\n",
        "We now have 7 tagged bounday regions. These 7 regions will need to be associated with appropriate boundary conditions. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DfyXjVdFdP6a",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "bounding_polygon = [[0.0, 0.0],\n",
        "                    [5.0, 0.0], [5.0, 4.0], [5.5, 4.0], [5.5, 0.0],\n",
        "                    [15.0, 0.0], [15.0, 4.0], [15.5, 4.0], [15.5, 0.0],\n",
        "                    [20.0, 0.0],\n",
        "                    [20.0, 10.0],\n",
        "                    [10.5, 10.0], [10.5, 6.0], [10, 6.0], [10, 10.0],\n",
        "                    [0.0, 10.0]]\n",
        "\n",
        "boundary_tags={'bottom': [0,4,8],\n",
        "               'right': [9],\n",
        "               'top': [10,14],\n",
        "               'left': [15],\n",
        "               'wall1': [1,2,3],\n",
        "               'wall2': [5,6,7],\n",
        "               'wall3': [11,12,13]\n",
        "              }\n",
        "\n",
        "\n",
        "domain2 = anuga.create_domain_from_regions(bounding_polygon, \n",
        "                                           boundary_tags,\n",
        "                                           maximum_triangle_area = 0.2,)\n",
        "\n",
        "domain2.set_name('domain2')\n",
        "domain2.set_store_vertices_smoothly(False)\n",
        "\n",
        "# Plot the resulting mesh\n",
        "dplotter2 = anuga.Domain_plotter(domain2)  \n",
        "plt.triplot(dplotter2.triang, linewidth = 0.4);"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5wS3N4D7FrK8",
        "colab_type": "text"
      },
      "source": [
        "### Initial Conditions and Boundary Conditions\n",
        "\n",
        "As before we setup the inital values for our elevation, friction and stage. And associated Dirichlet BC on the left and right boundary regions and reflective everywhere else. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LCoiLLGrQ75n",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Initial Conditions\n",
        "domain2.set_quantity('elevation', lambda x,y : -x/10, location='centroids')  # Use function for elevation\n",
        "domain2.set_quantity('friction', 0.01, location='centroids')                # Constant friction \n",
        "domain2.set_quantity('stage', expression='elevation', location='centroids') # Dry Bed \n",
        "\n",
        "# Boundary Conditions\n",
        "Bi = anuga.Dirichlet_boundary([0.4, 0, 0])         # Inflow\n",
        "Bo = anuga.Dirichlet_boundary([-2, 0, 0])          # Inflow\n",
        "Br = anuga.Reflective_boundary(domain2)            # Solid reflective wall\n",
        "\n",
        "domain2.set_boundary({'left': Bi, 'right': Bo, 'top': Br, 'bottom': Br, 'wall1': Br, 'wall2': Br, 'wall3': Br})"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zLtXZwJzGGxK",
        "colab_type": "text"
      },
      "source": [
        "### Evolve\n",
        "\n",
        "Now we can evolve. With this implementation the step walls are infinitely high and so we will not get a flow over the top of 2nd lower step. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aYIRAiKlRE-P",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for t in domain2.evolve(yieldstep=2, duration=40):\n",
        "  \n",
        "    #dplotter.plot_depth_frame()\n",
        "    dplotter2.save_depth_frame(vmin=0.0, vmax=1.0)\n",
        "    \n",
        "    domain2.print_timestepping_statistics()\n",
        "\n",
        "    \n",
        "# Read in the png files stored during the evolve loop\n",
        "dplotter2.make_depth_animation() "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_oh2AWWkwCl3",
        "colab_type": "text"
      },
      "source": [
        "### Download to Local Disk\n",
        "If you have the anuga viewer installed you might want to download the output file domain2.sww to your local disk."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DvfI5EFTwBAK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "files.download('domain2.sww')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_wQvUqf-GmG4",
        "colab_type": "text"
      },
      "source": [
        "# River Walls\n",
        "\n",
        "An alternative method to simulate our walls is to use `riverWalls`. Think of  `riverWalls` as infinitely thin walls. To set these up we need to build our mesh with  `breaklines` to define where the wall will occur and also how to apply them during the evolution by setting up a `riverWall` operator. \n",
        "\n",
        "First setup the mesh.\n",
        "\n",
        "We setup a dictionary to contain the x,y,z information of each of the river walls in our simulation. In this case 3 river walls associated with wall1 to wall3. \n",
        "\n",
        "Look carefully at the mesh produced and notice the straight lines in the mesh at the location of the walls. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0oUJDyGPRQ1U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "bounding_polygon = [[0.0, 0.0],\n",
        "                    [20.0, 0.0],\n",
        "                    [20.0, 10.0],\n",
        "                    [0.0, 10.0]]\n",
        "\n",
        "boundary_tags={'bottom': [0],\n",
        "               'right': [1],\n",
        "               'top': [2],\n",
        "               'left': [3]\n",
        "              }\n",
        "\n",
        "\n",
        "riverWalls = { 'wall1': [[5.0,0.0,   0.5], [5.0,4.0,  0.5]],\n",
        "               'wall2': [[15.0,0.0, -0.5], [15.0,4.0,-0.5]],\n",
        "               'wall3': [[10.0,10.0, 0.0], [10.0,6.0, 0.0]]\n",
        "             }\n",
        "\n",
        "#bline = [[[0.1,5.0,0.0],[19.9,5.0,0.0]]]\n",
        "              \n",
        "domain3 = anuga.create_domain_from_regions(bounding_polygon, \n",
        "                                           boundary_tags,\n",
        "                                           maximum_triangle_area = 0.2,\n",
        "                                           breaklines = riverWalls.values())\n",
        "\n",
        "domain3.set_name('domain3')\n",
        "domain3.set_store_vertices_smoothly(False)\n",
        "\n",
        "# Plot the resulting Mesh\n",
        "dplotter3 = anuga.Domain_plotter(domain3)  \n",
        "plt.triplot(dplotter3.triang, linewidth = 0.4);"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qThSW52fH_vE",
        "colab_type": "text"
      },
      "source": [
        "### Initial and Boundary Conditions and River walls"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jlXTa435RSTN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Initial Conditions\n",
        "domain3.set_quantity('elevation', lambda x,y : -x/10, location='centroids') # Use function for elevation\n",
        "domain3.set_quantity('friction', 0.01, location='centroids')                # Constant friction \n",
        "domain3.set_quantity('stage', expression='elevation', location='centroids') # Dry Bed \n",
        "\n",
        "\n",
        "# Boundary Conditions\n",
        "Bi = anuga.Dirichlet_boundary([0.4, 0, 0])         # Inflow\n",
        "Bo = anuga.Dirichlet_boundary([-2, 0, 0])          # Inflow\n",
        "Br = anuga.Reflective_boundary(domain2)            # Solid reflective wall\n",
        "\n",
        "domain3.set_boundary({'left': Bi, 'right': Bo, 'top': Br, 'bottom': Br})\n",
        "\n",
        "# Setup RiverWall\n",
        "domain3.riverwallData.create_riverwalls(riverWalls, verbose=False)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j7kym_0RIwiX",
        "colab_type": "text"
      },
      "source": [
        "### Evolve\n",
        "\n",
        "Notice that we have setup the river walls to be only 1 metre high. So we would expect some overtopping of the 2nd lower step. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cl0LBu6CRTRG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for t in domain3.evolve(yieldstep=2, duration=40):\n",
        "  \n",
        "    #dplotter.plot_depth_frame()\n",
        "    dplotter3.save_depth_frame(vmin=0.0, vmax=1.0)\n",
        "    \n",
        "    domain3.print_timestepping_statistics()\n",
        "\n",
        "    \n",
        "# Read in the png files stored during the evolve loop\n",
        "dplotter3.make_depth_animation() "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fPd71cGEwVv7",
        "colab_type": "text"
      },
      "source": [
        "### Download to Local Disk\n",
        "If you have the anuga viewer installed you might want to download the output file domain3.sww to your local disk."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NTO10S0qmy-e",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "files.download('domain3.sww')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wNEA8gHAm3Ok",
        "colab_type": "text"
      },
      "source": [
        "[Next Notebook](https://colab.research.google.com/github/stoiver/anuga-clinic-2018/blob/master/notebooks/notebook2.ipynb)"
      ]
    }
  ]
}