Synthetic_recharge_LandlabLandslide.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Watershed Dynamics Model \n",
    "\n",
    "<img src=\"https://www.washington.edu/brand/files/2014/09/W-Logo_Purple_Hex.png\" style=\"float:right;width:300px;padding:20px\">   \n",
    "\n",
    "\n",
    "<br />\n",
    "This Jupyter Notebook runs the Landlab LandslideProbability component on a synthetic \n",
    "Landlab grid using four recharge options as described in the paper: <br />\n",
    "#### Strauch et al. 2018. A hydro-climatological approach to predicting regional landslide probability using Landlab. Earth Surface Dynamics, 6, 1-26. <br /> \n",
    "This notebook performs the following functions:<br >\n",
    "* Import libraries and set HydroShare variables<br />\n",
    "* Create a grid and data fields used to calculate landslide probability<br />\n",
    "* Specify Recharge Distributions to compare four options<br /> \n",
    "* Run LandslideProbability function from Landlab landslide component<br /> \n",
    "* Compare the sensitivity based on four recharge options<br /> \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.  HydroShare Setup and Preparation\n",
    "\n",
    "To run this notebook, we must import several libraries.\n",
    "The hs_utils library provides functions for interacting with HydroShare, including resource querying, dowloading, and creation.  Additional libraries support the functions of Landlab. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import Python utilities for calculating and plotting\n",
    "import six\n",
    "import os\n",
    "import matplotlib as mpl\n",
    "mpl.use('agg')\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "\n",
    "#import utilities for importing and exporting to HydroShare\n",
    "from utilities import hydroshare\n",
    "# set variables for interacting with HydroShare from this notebook\n",
    "hs=hydroshare.hydroshare()\n",
    "# Create object to map the home directory\n",
    "homedir = r'/home/jovyan/work/notebooks/data/' + str(os.environ[\"HS_RES_ID\"]) + '/' + str(os.environ[\"HS_RES_ID\"]) + '/data/contents/'\n",
    "print homedir\n",
    "\n",
    "# Import Landlab libraries\n",
    "import landslide_probability\n",
    "from landslide_probability import LandslideProbability\n",
    "from landlab import RasterModelGrid\n",
    "from landlab import imshow_grid_at_node\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are curious about where the data is being downloaded, click on the Jupyter Notebook dashboard icon to see a File System view.  The homedir directory location printed above is where you can find the data and contents you will download to a HydroShare JupyterHub server.  At the end of this work session, you can migrate this data to the HydroShare iRods server as a Generic Resource. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a grid and data fields used to calculate landslide probability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example uses a synthetic model domain. As a first example, make a synthetic grid with 5 rows and 4 columns space 0.2 units apart.   <br /> \n",
    "##### Synthetic Grid Restart opportunity: After completing this entire notebook, go to the Dashboard, Kernal, and select Restart and Clear Output.  Execute the code from the beginning, but change the cell below to the rows, columns, and spacing of your choice.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid = RasterModelGrid((5, 4), spacing=(0.2, 0.2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Confirm the size of the grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid.number_of_nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see what the grid id of our nodes are, execute the command below.  However, note that this command gives you the rows of the grid, but these are technically up-side-down from how the RasterModelGrid nodes are numbered (e.g,. node id 0 is at the bottom left corner of the grid). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid.nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also see how many core nodes we have (i.e., the nodes that calculations are performed on) in the center of the grid...not the edges, which are 'closed nodes'. Compare this array to the full grid above.  Asign these to the variable 'core_nodes' so we can use these later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "core_nodes = grid.core_nodes\n",
    "core_nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the list of data inputs that the component needs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted(LandslideProbability.input_var_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Review the details of what each variable represents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "LandslideProbability._var_doc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the units of each variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "LandslideProbability._var_units"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will create the required fields for the landslide component and add data as fields to the grid.  Thus, the data arrays will need to be as the length of the number of nodes.<br /> \n",
    "##### Data Fields Restart opportunity: After completing this entire notebook, go to the Dashboard, Kernal, and select Restart and Clear Output.  Execute the code from the beginning, but change the cell below to the data inputs of your choice.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gridnodes = grid.number_of_nodes\n",
    "grid_size = grid.number_of_nodes\n",
    "\n",
    "grid['node']['soil__density']= \\\n",
    "         2000. * np.ones(gridnodes)\n",
    "\n",
    "grid['node']['soil__internal_friction_angle']= \\\n",
    "         np.sort(np.random.randint(26, 37, gridnodes))\n",
    "\n",
    "grid['node']['soil__mode_total_cohesion']= \\\n",
    "         np.sort(np.random.randint(30, 900, gridnodes))\n",
    "    \n",
    "scatter_dat = np.random.randint(1, 10, gridnodes)    \n",
    "grid['node']['soil__maximum_total_cohesion']= \\\n",
    "         grid.at_node['soil__mode_total_cohesion'] + scatter_dat\n",
    "\n",
    "grid['node']['soil__minimum_total_cohesion']= \\\n",
    "         grid.at_node['soil__mode_total_cohesion'] - scatter_dat\n",
    "\n",
    "grid['node']['soil__thickness']= \\\n",
    "         np.sort(np.random.randint(1, 10, gridnodes))\n",
    "\n",
    "grid['node']['soil__transmissivity']= \\\n",
    "         np.sort(np.random.randint(5, 20, gridnodes),-1)\n",
    "        \n",
    "grid['node']['topographic__slope'] = np.random.rand(gridnodes)\n",
    "\n",
    "grid['node']['topographic__specific_contributing_area']= \\\n",
    "         np.sort(np.random.randint(30, 900, gridnodes))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see what one of these fields (slope) looks like on the grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure('Slope')\n",
    "imshow_grid_at_node(grid,'topographic__slope', cmap='copper_r',\n",
    "                 grid_units=('coordinates', 'coordinates'), shrink=0.75,\n",
    "                 var_name='Slope', var_units='m/m')\n",
    "plt.savefig('Slope.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Number of iterations to run Monte Carlo simulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The landslide component employes the infinite slope model to calculate factor-of-safety values using a Monte Carlo simulation approach, which randomly selects input values from parameter distributions. You can pick the number of iterations to run Monte Carlo simulations, but the default is 250. The higher the number of iteration, the longer the program runs, but the more precise the probability of failure result becomes.<br /> \n",
    "##### Random iterations Restart opportunity: After completing this entire notebook, go to the Dashboard, Kernal, and select Restart and Clear Output.  Execute the code from the beginning, but change the cell below to the number of iterations of your choice.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Specify Recharge Distributions to compare four options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are _four_ different options for providing recharge for the Monte Carlo simulation.  We'll provide each of these recharge options below by specifying a recharge distribution and the necessary parameters. <br /> \n",
    "##### Restart opportunity: After completing this entire notebook, go to the Dashboard, Kernal, and select Restart and Clear Output.  Execute the code from the beginning, but change the cells below to adjust the recharge distributions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### 1. Recharge Option - 'uniform' distribution "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this option, we'll apply a uniform distribution of recharge based on minimum and maximum recharge values.  We will then instantiate the LandslideProbability component with these parameters, as well as the grid and number of iterations we specified above.  Instantiate creates an instance of a class.  (For example, the _iPhone_ is a class and _each phone_ is an instance.)\n",
    "\n",
    "No outputs are generated by these commands as they are setting up the recharge and instantiating the component.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "distribution1 = 'uniform'\n",
    "Remin_value = 5 \n",
    "Remax_value = 15 \n",
    "\n",
    "LS_prob1 = LandslideProbability(grid,number_of_iterations=n,\n",
    "    groudwater__recharge_distribution=distribution1,\n",
    "    groundwater__recharge_min_value=Remin_value,\n",
    "    groundwater__recharge_max_value=Remax_value)\n",
    "print('Distribution = '), LS_prob1.groundwater__recharge_distribution\n",
    "print('Uniform recharge successfully instantiated')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Recharge Option - 'lognormal' distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this option, we specify a lognormal distribution with a recharge mean and standard deviation values.  We instantiate the LandslideProbabilty class to create a new object or 'instance' of the class/component LandslideProbability. So now we have created two instances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "distribution2 = 'lognormal'\n",
    "Remean = 5.\n",
    "Restandard_deviation = 0.25\n",
    "LS_prob2 = LandslideProbability(grid,number_of_iterations=n,\n",
    "    groundwater__recharge_distribution=distribution2,\n",
    "    groundwater__recharge_mean=Remean,\n",
    "    groundwater__recharge_standard_deviation=Restandard_deviation)\n",
    "print('Distribution = '), LS_prob2.groundwater__recharge_distribution\n",
    "print('Lognormal recharge successfully instantiated')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Recharge Option - 'lognormal_spatial' distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to the previous option (#2), we use a lognormal distribution for recharge.  However, in this case we provide arrays to represent mean and standard deviation values for each node in our grid.  Thus, the recharge distribution varies for each node - representing a spatially varying distribution of recharge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "distribution3 = 'lognormal_spatial'\n",
    "Remean3 = np.random.randint(2,7,grid_size)\n",
    "Restandard_deviation3 = np.random.rand(grid_size)\n",
    "LS_prob3 = LandslideProbability(grid,number_of_iterations=n,\n",
    "    groundwater__recharge_distribution=distribution3,\n",
    "    groundwater__recharge_mean=Remean3,\n",
    "    groundwater__recharge_standard_deviation=Restandard_deviation3)\n",
    "print('Distribution = '), LS_prob3.groundwater__recharge_distribution\n",
    "print('Lognormal spatial recharge successfully instantiated')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Recharge Option - 'data_driven_spatial' distribution "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the most complex representation of recharge used in the LandslideProbability component.  \n",
    "In this case, we provide recharge distributions (arrays) directly that are unique for each node.  \n",
    "\n",
    "In a real-world situation, we would acquire these from a hydrologic model that often has a coarser resolution than our grid.<br />\n",
    "Thus, we route the recharge data arrays from these larger Hydraulic Source Domain (HSD) grids down to each node of our grid. Landlab has a 'Source tracking algorithm' utility that performs this routing and produces Python dictionaries (_key: value_ pairs) that become parameters for the 'data_driven_spatial' recharge distribution.  In this synthetic example, we'll generate synthetic versions of these dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HSD_dict = {}\n",
    "for vkey in range(2,8):\n",
    "    HSD_dict[vkey] = np.random.randint(20,120,10)\n",
    "print('HSD_dict dictionary is a unique array of recharge provided as arrays (‘values’) for each of the Hydrologic Source Domain (HSD) (‘keys’). ')    \n",
    "print('The first key of this dictionary is:')\n",
    "HSD_dict.keys()[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "HSD_ID dictionary has the grid node ID as ‘keys’ and HSD IDs in a list as ‘values’. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HSD_id_dict = {}\n",
    "for ckey in grid.core_nodes:\n",
    "    HSD_id_dict[ckey] = np.random.randint(2,8,2)\n",
    "print('The first key:value pair of this dictionary is:')\n",
    "HSD_id_dict.items()[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The fractions dictionary assigns to each node ID as ‘key’ a lists the fractions of each HSD draining to the node as ‘values’. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fract_dict = {}\n",
    "for ckey in grid.core_nodes:\n",
    "    fract_dict[ckey] =  np.random.rand(2)\n",
    "print('The fractions (values) assigned to the first node (key) are: ')\n",
    "fract_dict.values()[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the component is instantiated, the three dictionaries are provided as the 'parameters' for the distribution in explicit order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "distribution4 = 'data_driven_spatial'\n",
    "HSD_inputs = [HSD_dict,HSD_id_dict,fract_dict]\n",
    "LS_prob4 = LandslideProbability(grid,number_of_iterations=n,\n",
    "    groundwater__recharge_distribution=distribution4,\n",
    "    groundwater__recharge_HSD_inputs=HSD_inputs)\n",
    "print('Distribution = '), LS_prob4.groundwater__recharge_distribution\n",
    "print('Data driven spatial recharge successfully instantiated')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run the Landslide Component "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To generate the outputs from running the component, we call the 'calculate_landslide_probability' method inside the component using the class instance (e.g., LS_prob1) for each recharge option specified above. The following cell runs the model; in the following section we will assessing the results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using recharge option 1 as an example, run the first recharge option simulation of probability of failure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "LS_prob1.calculate_landslide_probability()\n",
    "print('Landslide probability successfully calculated')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The outputs of model simulations are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted(LS_prob1.output_var_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save the arrays as variables by 'attaching the fields to the grid' and view the outputs. \n",
    "\n",
    "This simulation generates a probability value for each core node. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "LS_prob1_probability_of_failure = grid.at_node['landslide__probability_of_failure']\n",
    "grid.at_node['landslide__probability_of_failure']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This simulation generates a mean relative wetness value for each core node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "LS_prob1_relative_wetness = grid.at_node['soil__mean_relative_wetness']\n",
    "grid.at_node['soil__mean_relative_wetness']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These model output arrays are attached to the grid as fields. When we run the model for a different recharge, these fields are over-written. Run the remaining three recharge options and save the arrays as variables for plotting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "LS_prob2.calculate_landslide_probability()\n",
    "LS_prob2_probability_of_failure = grid.at_node['landslide__probability_of_failure']\n",
    "LS_prob2_relative_wetness = grid.at_node['soil__mean_relative_wetness']\n",
    "\n",
    "LS_prob3.calculate_landslide_probability()\n",
    "LS_prob3_probability_of_failure = grid.at_node['landslide__probability_of_failure']\n",
    "LS_prob3_relative_wetness = grid.at_node['soil__mean_relative_wetness']\n",
    "\n",
    "LS_prob4.calculate_landslide_probability()\n",
    "LS_prob4_probability_of_failure = grid.at_node['landslide__probability_of_failure']\n",
    "LS_prob4_relative_wetness = grid.at_node['soil__mean_relative_wetness']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compare the sensitivity based on four recharge options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Now lets do some plotting to see what we produced.  The four commands below will plot the probability of failure for each of the recharge options we specified above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets compare the probabilities of failure for our four recharge options.  Note - we use the arrays we named above instead of fields after 'grid'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fig = plt.figure('Probability of Failure')\n",
    "xticks = np.arange(-0.1, 0.8, 0.4)\n",
    "ax1 = fig.add_subplot(221)\n",
    "ax1.xaxis.set_visible(False)\n",
    "imshow_grid_at_node(grid, LS_prob1_probability_of_failure, plot_name='Recharge 1',\n",
    "                    allow_colorbar=False, cmap='OrRd',\n",
    "                    grid_units=('coordinates',''))\n",
    "ax2 = fig.add_subplot(222)\n",
    "ax2.xaxis.set_visible(False)\n",
    "imshow_grid_at_node(grid, LS_prob2_probability_of_failure, plot_name='Recharge 2',\n",
    "                    allow_colorbar=False, cmap='OrRd',\n",
    "                    grid_units=('coordinates', 'coordinates'))\n",
    "ax3 = fig.add_subplot(223)\n",
    "ax3.set_xticks(xticks)\n",
    "imshow_grid_at_node(grid, LS_prob3_probability_of_failure,plot_name='Recharge 3',\n",
    "                    allow_colorbar=False, cmap='OrRd',\n",
    "                    grid_units=('coordinates', 'coordinates'))\n",
    "ax4 = fig.add_subplot(224)\n",
    "ax4.set_xticks(xticks)\n",
    "imshow_grid_at_node(grid, LS_prob4_probability_of_failure, cmap='OrRd', plot_name='Recharge 4',\n",
    "                    grid_units=('coordinates', 'coordinates'), shrink=0.9,\n",
    "                    var_name='Probability of Failure')\n",
    "plt.savefig('Probability_of_Failure_synthetic.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that only the core nodes in the middle have values.  The outside nodes are closed.  Also, see how these compare with the slope plot above.\n",
    "\n",
    "Now lets do the same for mean relative wetness."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure('Mean Relative Wetness')\n",
    "xticks = np.arange(-0.1, 0.8, 0.4)\n",
    "ax1 = fig.add_subplot(221)\n",
    "ax1.xaxis.set_visible(False)\n",
    "imshow_grid_at_node(grid, LS_prob1_relative_wetness, plot_name='Re Opt. 1',\n",
    "                    allow_colorbar=False, cmap='YlGnBu',\n",
    "                    grid_units=('coordinates',''))\n",
    "ax2 = fig.add_subplot(222)\n",
    "ax2.xaxis.set_visible(False)\n",
    "imshow_grid_at_node(grid, LS_prob2_relative_wetness, plot_name='Re Opt. 2',\n",
    "                    allow_colorbar=False, cmap='YlGnBu',\n",
    "                    grid_units=('coordinates', 'coordinates'))\n",
    "ax3 = fig.add_subplot(223)\n",
    "ax3.set_xticks(xticks)\n",
    "imshow_grid_at_node(grid, LS_prob3_relative_wetness,plot_name='Re Opt. 3',\n",
    "                    allow_colorbar=False, cmap='YlGnBu',\n",
    "                    grid_units=('coordinates', 'coordinates'))\n",
    "ax4 = fig.add_subplot(224)\n",
    "ax4.set_xticks(xticks)\n",
    "imshow_grid_at_node(grid, LS_prob4_relative_wetness, cmap='YlGnBu', plot_name='Re Opt. 4',\n",
    "                    grid_units=('coordinates', 'coordinates'), shrink=0.9,\n",
    "                    var_name='Mean Relative Wetness')\n",
    "plt.savefig('Mean_Relative_Wetness_synthetic.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These might be all 1.0, which is the maximum, indicating that given the inputs above, this domain is often saturated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 2.7",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}