examples/Notebooks/flopy3_swi2package_ex4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FloPy\n",
    "\n",
    "### SWI2 Example 4. Upconing Below a Pumping Well in a Two-Aquifer Island System\n",
    "\n",
    "This example problem is the fourth example problem in the SWI2 documentation (http://pubs.usgs.gov/tm/6a46/) and simulates transient movement of the freshwater-seawater interface beneath an island in response to recharge and groundwater withdrawals. The island is 2,050$\\times$2,050 m and consists of two 20-m thick aquifers that extend below sea level. The aquifers are confined, storage changes are not considered (all MODFLOW stress periods are steady-state), and the top and bottom of each aquifer is horizontal. The top of the upper aquifer and the bottom of the lower aquifer are impermeable.\n",
    "\n",
    "The domain is discretized into 61 columns, 61 rows, and 2 layers, with respective cell dimensions of 50 m (`DELR`), 50 m (`DELC`), and 20 m. A total of 230 years is simulated using three stress periods with lengths of 200, 12, and 18 years, with constant time steps of 0.2, 0.1, and 0.1 years, respectively. \n",
    "\n",
    "The horizontal and vertical hydraulic conductivity of both aquifers are 10 m/d and 0.2 m/d, respectively. The effective porosity is 0.2 for both aquifers. The model is extended 500 m offshore along all sides and the ocean boundary is represented as a general head boundary condition (GHB) in model layer 1. A freshwater head of 0 m is specified at the ocean bottom in all general head boundaries. The GHB conductance that controls outflow from the aquifer into the ocean is 62.5 m$^{2}$/d and corresponds to a leakance of 0.025 d$^{-1}$ (or a resistance of 40 days).\n",
    "\n",
    "The groundwater is divided into a freshwater zone and a seawater zone, separated by an active ZETA surface between the zones (`NSRF=1`) that approximates the 50-percent seawater salinity contour. Fluid density is represented using the stratified density option (`ISTRAT=1`). The dimensionless density difference ($\\nu$) between freshwater and saltwater is 0.025. The tip and toe tracking parameters are a `TOESLOPE` and `TIPSLOPE` of 0.005, a default `ALPHA` of 0.1, and a default `BETA` of 0.1. Initially, the interface between freshwater and saltwater is 1 m below land surface on the island and at the top of the upper aquifer offshore. The SWI2 `ISOURCE` parameter is set to -2 in cells having GHBs so that water that infiltrates into the aquifer from the GHB cells is saltwater (zone 2), whereas water that flows out of the model at the GHB cells is identical to water at the top of the aquifer. `ISOURCE` in layer 2, row 31, column 36 is set to 2 so that a saltwater well may be simulated in the third stress period of simulation 2. In all other cells, the SWI2 `ISOURCE` parameter is set to 0, indicating boundary conditions have water that is identical to water at the top of the aquifer and can be either freshwater or saltwater, depending on the elevation of the active `ZETA` surface in the cell.\n",
    "\n",
    "A constant recharge rate of 0.4 millimeters per day (mm/d) is used in all three stress periods. The development of the freshwater lens is simulated for 200 years, after which a pumping well having a withdrawal rate of 250 m$^3$/d is started in layer 1, row 31, column 36. For the first simulation (simulation 1), the well pumps for 30 years, after which the interface almost reaches the top of the upper aquifer layer. In the second simulation (simulation 2), an additional well withdrawing\n",
    "saltwater at a rate of 25 m$^3$/d is simulated below the freshwater well in layer 2 , row 31, column 36, 12 years after the freshwater groundwater withdrawal begins in the well in layer 1. The saltwater well is intended to prevent the interface from\n",
    "upconing into the upper aquifer (model layer)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import `numpy` and `matplotlib`, set all figures to be inline, import `flopy.modflow` and `flopy.utils`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.6.5 | packaged by conda-forge | (default, Apr  6 2018, 13:44:09) \n",
      "[GCC 4.2.1 Compatible Apple LLVM 6.1.0 (clang-602.0.53)]\n",
      "numpy version: 1.14.5\n",
      "matplotlib version: 2.2.2\n",
      "flopy version: 3.2.10\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import os\n",
    "import sys\n",
    "import platform\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# run installed version of flopy or add local path\n",
    "try:\n",
    "    import flopy\n",
    "except:\n",
    "    fpth = os.path.abspath(os.path.join('..', '..'))\n",
    "    sys.path.append(fpth)\n",
    "    import flopy\n",
    "\n",
    "print(sys.version)\n",
    "print('numpy version: {}'.format(np.__version__))\n",
    "print('matplotlib version: {}'.format(mpl.__version__))\n",
    "print('flopy version: {}'.format(flopy.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define model name of your model and the location of MODFLOW executable. All MODFLOW files and output will be stored in the subdirectory defined by the workspace. Create a model named `ml` and specify that this is a MODFLOW-2005 model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set name of MODFLOW exe\n",
    "#  assumes executable is in users path statement\n",
    "exe_name = 'mf2005'\n",
    "if platform.system() == 'Windows':\n",
    "    exe_name = 'mf2005.exe'\n",
    "\n",
    "workspace = os.path.join('data')\n",
    "#make sure workspace directory exists\n",
    "if not os.path.exists(workspace):\n",
    "    os.makedirs(workspace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the number of layers, rows and columns. The heads are computed quasi-steady state (hence a steady MODFLOW run) while the interface will move. There are three stress periods with a length of 200, 12, and 18 years and 1,000, 120, and 180 steps. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "ncol = 61\n",
    "nrow = 61\n",
    "nlay = 2\n",
    "\n",
    "nper = 3\n",
    "perlen = [365.25 * 200., 365.25 * 12., 365.25 * 18.]\n",
    "nstp = [1000, 120, 180]\n",
    "save_head = [200, 60, 60]\n",
    "steady = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Specify the cell size along the rows (`delr`) and along the columns (`delc`) and the top and bottom of the aquifer for the `DIS` package. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dis data\n",
    "delr, delc = 50.0, 50.0\n",
    "botm = np.array([-10., -30., -50.])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the `IBOUND` array and starting heads for the `BAS` package. The corners of the model are defined to be inactive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bas data\n",
    "# ibound - active except for the corners\n",
    "ibound = np.ones((nlay, nrow, ncol), dtype= np.int)\n",
    "ibound[:, 0, 0] = 0\n",
    "ibound[:, 0, -1] = 0\n",
    "ibound[:, -1, 0] = 0\n",
    "ibound[:, -1, -1] = 0\n",
    "# initial head data\n",
    "ihead = np.zeros((nlay, nrow, ncol), dtype=np.float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the layers to be confined and define the horizontal and vertical hydraulic conductivity of the aquifer for the `LPF` package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lpf data\n",
    "laytyp = 0\n",
    "hk = 10.\n",
    "vka = 0.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the boundary condition data for the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# boundary condition data\n",
    "# ghb data\n",
    "colcell, rowcell = np.meshgrid(np.arange(0, ncol), np.arange(0, nrow))\n",
    "index = np.zeros((nrow, ncol), dtype=np.int)\n",
    "index[:, :10] = 1\n",
    "index[:, -10:] = 1\n",
    "index[:10, :] = 1\n",
    "index[-10:, :] = 1\n",
    "nghb = np.sum(index)\n",
    "lrchc = np.zeros((nghb, 5))\n",
    "lrchc[:, 0] = 0\n",
    "lrchc[:, 1] = rowcell[index == 1]\n",
    "lrchc[:, 2] = colcell[index == 1]\n",
    "lrchc[:, 3] = 0.\n",
    "lrchc[:, 4] = 50.0 * 50.0 / 40.0\n",
    "# create ghb dictionary\n",
    "ghb_data = {0:lrchc}\n",
    "\n",
    "# recharge data\n",
    "rch = np.zeros((nrow, ncol), dtype=np.float)\n",
    "rch[index == 0] = 0.0004\n",
    "# create recharge dictionary\n",
    "rch_data = {0: rch}\n",
    "\n",
    "# well data\n",
    "nwells = 2\n",
    "lrcq = np.zeros((nwells, 4))\n",
    "lrcq[0, :] = np.array((0, 30, 35, 0))\n",
    "lrcq[1, :] = np.array([1, 30, 35, 0])\n",
    "lrcqw = lrcq.copy()\n",
    "lrcqw[0, 3] = -250\n",
    "lrcqsw = lrcq.copy()\n",
    "lrcqsw[0, 3] = -250.\n",
    "lrcqsw[1, 3] = -25.\n",
    "# create well dictionary\n",
    "base_well_data = {0:lrcq, 1:lrcqw}\n",
    "swwells_well_data = {0:lrcq, 1:lrcqw, 2:lrcqsw}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# swi2 data\n",
    "nadptmx = 10\n",
    "nadptmn = 1\n",
    "nu = [0, 0.025]\n",
    "numult = 5.0\n",
    "toeslope = nu[1] / numult  #0.005\n",
    "tipslope = nu[1] / numult  #0.005\n",
    "z1 = -10.0 * np.ones((nrow, ncol))\n",
    "z1[index == 0] = -11.0\n",
    "z = np.array([[z1, z1]])\n",
    "iso = np.zeros((nlay, nrow, ncol), dtype=np.int)\n",
    "iso[0, :, :][index == 0] = 1\n",
    "iso[0, :, :][index == 1] = -2\n",
    "iso[1, 30, 35] = 2\n",
    "ssz=0.2\n",
    "# swi2 observations\n",
    "obsnam = ['layer1_', 'layer2_']\n",
    "obslrc=[[0, 30, 35], [1, 30, 35]]\n",
    "nobs = len(obsnam)\n",
    "iswiobs = 1051"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create output control (OC) data using words "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# oc data\n",
    "spd = {(0,199): ['print budget', 'save head'],\n",
    "       (0,200): [],\n",
    "       (0,399): ['print budget', 'save head'],\n",
    "       (0,400): [],\n",
    "       (0,599): ['print budget', 'save head'],\n",
    "       (0,600): [],\n",
    "       (0,799): ['print budget', 'save head'],\n",
    "       (0,800): [],\n",
    "       (0,999): ['print budget', 'save head'],\n",
    "       (1,0): [],\n",
    "       (1,59): ['print budget', 'save head'],\n",
    "       (1,60): [],\n",
    "       (1,119): ['print budget', 'save head'],\n",
    "       (1,120): [],\n",
    "       (2,0): [],\n",
    "       (2,59): ['print budget', 'save head'],\n",
    "       (2,60): [],\n",
    "       (2,119): ['print budget', 'save head'],\n",
    "       (2,120): [],\n",
    "       (2,179): ['print budget', 'save head']}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the model with the freshwater well (Simulation 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ModflowSwi2: specification of nobs is deprecated.\n"
     ]
    }
   ],
   "source": [
    "modelname = 'swiex4_s1'\n",
    "ml = flopy.modflow.Modflow(modelname, version='mf2005', exe_name=exe_name, model_ws=workspace)\n",
    "\n",
    "discret = flopy.modflow.ModflowDis(ml, nlay=nlay, nrow=nrow, ncol=ncol, laycbd=0,\n",
    "                                   delr=delr, delc=delc, top=botm[0], botm=botm[1:],\n",
    "                                   nper=nper, perlen=perlen, nstp=nstp)\n",
    "bas = flopy.modflow.ModflowBas(ml, ibound=ibound, strt=ihead)\n",
    "lpf = flopy.modflow.ModflowLpf(ml, laytyp=laytyp, hk=hk, vka=vka)\n",
    "wel = flopy.modflow.ModflowWel(ml, stress_period_data=base_well_data)\n",
    "ghb = flopy.modflow.ModflowGhb(ml, stress_period_data=ghb_data)\n",
    "rch = flopy.modflow.ModflowRch(ml, rech=rch_data)\n",
    "swi = flopy.modflow.ModflowSwi2(ml, nsrf=1, istrat=1, toeslope=toeslope, tipslope=tipslope, nu=nu,\n",
    "                                zeta=z, ssz=ssz, isource=iso, nsolver=1,\n",
    "                                nadptmx=nadptmx, nadptmn=nadptmn, \n",
    "                                nobs=nobs, iswiobs=iswiobs, obsnam=obsnam, obslrc=obslrc, iswizt=55)\n",
    "oc = flopy.modflow.ModflowOc(ml, stress_period_data=spd)\n",
    "pcg = flopy.modflow.ModflowPcg(ml, hclose=1.0e-6, rclose=3.0e-3, mxiter=100, iter1=50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write the simulation 1 MODFLOW input files and run the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, [])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ml.write_input()\n",
    "ml.run_model(silent=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the model with the saltwater well (Simulation 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ModflowSwi2: specification of nobs is deprecated.\n"
     ]
    }
   ],
   "source": [
    "modelname2 = 'swiex4_s2'\n",
    "ml2 = flopy.modflow.Modflow(modelname2, version='mf2005', exe_name=exe_name, model_ws=workspace)\n",
    "\n",
    "discret = flopy.modflow.ModflowDis(ml2, nlay=nlay, nrow=nrow, ncol=ncol, laycbd=0,\n",
    "                                   delr=delr, delc=delc, top=botm[0], botm=botm[1:],\n",
    "                                   nper=nper, perlen=perlen, nstp=nstp)\n",
    "bas = flopy.modflow.ModflowBas(ml2, ibound=ibound, strt=ihead)\n",
    "lpf = flopy.modflow.ModflowLpf(ml2, laytyp=laytyp, hk=hk, vka=vka)\n",
    "wel = flopy.modflow.ModflowWel(ml2, stress_period_data=swwells_well_data)\n",
    "ghb = flopy.modflow.ModflowGhb(ml2, stress_period_data=ghb_data)\n",
    "rch = flopy.modflow.ModflowRch(ml2, rech=rch_data)\n",
    "swi = flopy.modflow.ModflowSwi2(ml2, nsrf=1, istrat=1, \n",
    "                                toeslope=toeslope, tipslope=tipslope, nu=nu,\n",
    "                                zeta=z, ssz=ssz, isource=iso, nsolver=1,\n",
    "                                nadptmx=nadptmx, nadptmn=nadptmn,\n",
    "                                nobs=nobs, iswiobs=iswiobs, obsnam=obsnam, obslrc=obslrc, iswizt=55)\n",
    "oc = flopy.modflow.ModflowOc(ml2, stress_period_data=spd)\n",
    "pcg = flopy.modflow.ModflowPcg(ml2, hclose=1.0e-6, rclose=3.0e-3, mxiter=100, iter1=50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write the simulation 2 MODFLOW input files and run the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, [])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ml2.write_input()\n",
    "ml2.run_model(silent=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the simulation 1 `ZETA` data and `ZETA` observations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read base model zeta\n",
    "zfile = flopy.utils.CellBudgetFile(os.path.join(ml.model_ws, modelname+'.zta'))\n",
    "kstpkper = zfile.get_kstpkper()\n",
    "zeta = []\n",
    "for kk in kstpkper:\n",
    "    zeta.append(zfile.get_data(kstpkper=kk, text='ZETASRF  1')[0])\n",
    "zeta = np.array(zeta)\n",
    "# read swi obs\n",
    "zobs = np.genfromtxt(os.path.join(ml.model_ws, modelname+'.zobs.out'), names=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the simulation 2 `ZETA` data and `ZETA` observations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read saltwater well model zeta\n",
    "zfile2 = flopy.utils.CellBudgetFile(os.path.join(ml2.model_ws, modelname2+'.zta'))\n",
    "kstpkper = zfile2.get_kstpkper()\n",
    "zeta2 = []\n",
    "for kk in kstpkper:\n",
    "    zeta2.append(zfile2.get_data(kstpkper=kk, text='ZETASRF  1')[0])\n",
    "zeta2 = np.array(zeta2)\n",
    "# read swi obs\n",
    "zobs2 = np.genfromtxt(os.path.join(ml2.model_ws, modelname2+'.zobs.out'), names=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create arrays for the x-coordinates and the output years"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(-1500, 1500, 61)\n",
    "xcell = np.linspace(-1500, 1500, 61) + delr / 2.\n",
    "xedge = np.linspace(-1525, 1525, 62)\n",
    "years = [40, 80, 120, 160, 200, 6, 12, 18, 24, 30]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define figure dimensions and colors used for plotting `ZETA` surfaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# figure dimensions\n",
    "fwid, fhgt = 8.00, 5.50\n",
    "flft, frgt, fbot, ftop = 0.125, 0.95, 0.125, 0.925\n",
    "\n",
    "# line color definition\n",
    "icolor = 5\n",
    "colormap = plt.cm.jet  #winter\n",
    "cc = []\n",
    "cr = np.linspace(0.9, 0.0, icolor)\n",
    "for idx in cr:\n",
    "    cc.append(colormap(idx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recreate **Figure 9** from the SWI2 documentation (http://pubs.usgs.gov/tm/6a46/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams.update({'legend.fontsize': 6, 'legend.frameon' : False})\n",
    "fig = plt.figure(figsize=(fwid, fhgt), facecolor='w')\n",
    "fig.subplots_adjust(wspace=0.25, hspace=0.25, left=flft, right=frgt, bottom=fbot, top=ftop)\n",
    "# first plot\n",
    "ax = fig.add_subplot(2, 2, 1)\n",
    "# axes limits\n",
    "ax.set_xlim(-1500, 1500)\n",
    "ax.set_ylim(-50, -10)\n",
    "for idx in range(5):\n",
    "    # layer 1\n",
    "    ax.plot(xcell, zeta[idx, 0, 30, :], drawstyle='steps-mid', \n",
    "            linewidth=0.5, color=cc[idx], label='{:2d} years'.format(years[idx]))\n",
    "    # layer 2\n",
    "    ax.plot(xcell, zeta[idx, 1, 30, :], drawstyle='steps-mid',\n",
    "            linewidth=0.5, color=cc[idx], label='_None')\n",
    "ax.plot([-1500, 1500], [-30, -30], color='k', linewidth=1.0)\n",
    "# legend\n",
    "plt.legend(loc='lower left')\n",
    "# axes labels and text\n",
    "ax.set_xlabel('Horizontal distance, in meters')\n",
    "ax.set_ylabel('Elevation, in meters')\n",
    "ax.text(0.025, .55, 'Layer 1', transform=ax.transAxes, va='center', ha='left', size='7')\n",
    "ax.text(0.025, .45, 'Layer 2', transform=ax.transAxes, va='center', ha='left', size='7')\n",
    "ax.text(0.975, .1, 'Recharge conditions', transform=ax.transAxes, va='center', ha='right', size='8')\n",
    "\n",
    "# second plot\n",
    "ax = fig.add_subplot(2, 2, 2)\n",
    "# axes limits\n",
    "ax.set_xlim(-1500, 1500)\n",
    "ax.set_ylim(-50, -10)\n",
    "for idx in range(5, len(years)):\n",
    "    # layer 1\n",
    "    ax.plot(xcell, zeta[idx, 0, 30, :], drawstyle='steps-mid', \n",
    "            linewidth=0.5, color=cc[idx-5], label='{:2d} years'.format(years[idx]))\n",
    "    # layer 2\n",
    "    ax.plot(xcell, zeta[idx, 1, 30, :], drawstyle='steps-mid',\n",
    "            linewidth=0.5, color=cc[idx-5], label='_None')\n",
    "ax.plot([-1500, 1500], [-30, -30], color='k', linewidth=1.0)\n",
    "# legend\n",
    "plt.legend(loc='lower left')\n",
    "# axes labels and text\n",
    "ax.set_xlabel('Horizontal distance, in meters')\n",
    "ax.set_ylabel('Elevation, in meters')\n",
    "ax.text(0.025, .55, 'Layer 1', transform=ax.transAxes, va='center', ha='left', size='7')\n",
    "ax.text(0.025, .45, 'Layer 2', transform=ax.transAxes, va='center', ha='left', size='7')\n",
    "ax.text(0.975, .1, 'Freshwater well withdrawal', transform=ax.transAxes, va='center', ha='right', size='8')\n",
    "\n",
    "# third plot\n",
    "ax = fig.add_subplot(2, 2, 3)\n",
    "# axes limits\n",
    "ax.set_xlim(-1500, 1500)\n",
    "ax.set_ylim(-50, -10)\n",
    "for idx in range(5, len(years)):\n",
    "    # layer 1\n",
    "    ax.plot(xcell, zeta2[idx, 0, 30, :], drawstyle='steps-mid', \n",
    "            linewidth=0.5, color=cc[idx-5], label='{:2d} years'.format(years[idx]))\n",
    "    # layer 2\n",
    "    ax.plot(xcell, zeta2[idx, 1, 30, :], drawstyle='steps-mid',\n",
    "            linewidth=0.5, color=cc[idx-5], label='_None')\n",
    "ax.plot([-1500, 1500], [-30, -30], color='k', linewidth=1.0)\n",
    "# legend\n",
    "plt.legend(loc='lower left')\n",
    "# axes labels and text\n",
    "ax.set_xlabel('Horizontal distance, in meters')\n",
    "ax.set_ylabel('Elevation, in meters')\n",
    "ax.text(0.025, .55, 'Layer 1', transform=ax.transAxes, va='center', ha='left', size='7')\n",
    "ax.text(0.025, .45, 'Layer 2', transform=ax.transAxes, va='center', ha='left', size='7')\n",
    "ax.text(0.975, .1, 'Freshwater and saltwater\\nwell withdrawals', transform=ax.transAxes,\n",
    "        va='center', ha='right', size='8')\n",
    "\n",
    "# fourth plot\n",
    "ax = fig.add_subplot(2, 2, 4)\n",
    "# axes limits\n",
    "ax.set_xlim(0, 30)\n",
    "ax.set_ylim(-50, -10)\n",
    "t = zobs['TOTIM'][999:] / 365 - 200.\n",
    "tz2 = zobs['layer1_001'][999:]\n",
    "tz3 = zobs2['layer1_001'][999:]\n",
    "for i in range(len(t)):\n",
    "    if zobs['layer2_001'][i+999] < -30. - 0.1:\n",
    "        tz2[i] = zobs['layer2_001'][i+999]\n",
    "    if zobs2['layer2_001'][i+999] < 20. - 0.1:\n",
    "        tz3[i] = zobs2['layer2_001'][i+999]\n",
    "ax.plot(t, tz2, linestyle='solid', color='r', linewidth=0.75, label='Freshwater well')\n",
    "ax.plot(t, tz3, linestyle='dotted', color='r', linewidth=0.75, label='Freshwater and saltwater well')\n",
    "ax.plot([0, 30], [-30, -30], 'k', linewidth=1.0, label='_None')\n",
    "# legend\n",
    "leg = plt.legend(loc='lower right', numpoints=1)\n",
    "# axes labels and text\n",
    "ax.set_xlabel('Time, in years')\n",
    "ax.set_ylabel('Elevation, in meters')\n",
    "ax.text(0.025, .55, 'Layer 1', transform=ax.transAxes, va='center', ha='left', size='7')\n",
    "ax.text(0.025, .45, 'Layer 2', transform=ax.transAxes, va='center', ha='left', size='7');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `ModelCrossSection` plotting class and `plot_fill_between()` method to fill between zeta surfaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x198 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(fwid, fhgt/2))\n",
    "fig.subplots_adjust(wspace=0.25, hspace=0.25, left=flft, right=frgt, bottom=fbot, top=ftop)\n",
    "\n",
    "colors = ['#40d3f7', '#F76541']\n",
    "\n",
    "ax = fig.add_subplot(1, 2, 1)\n",
    "modelxsect = flopy.plot.ModelCrossSection(model=ml, line={'Row': 30}, \n",
    "                                          extent=(0, 3050, -50, -10))\n",
    "modelxsect.plot_fill_between(zeta[4, :, :, :], colors=colors, ax=ax,\n",
    "                              edgecolors='none')\n",
    "linecollection = modelxsect.plot_grid(ax=ax)\n",
    "ax.set_title('Recharge year {}'.format(years[4]));\n",
    "\n",
    "ax = fig.add_subplot(1, 2, 2)\n",
    "ax.set_xlim(0, 3050)\n",
    "ax.set_ylim(-50, -10)\n",
    "modelxsect.plot_fill_between(zeta[-1, :, :, :], colors=colors, ax=ax)\n",
    "linecollection = modelxsect.plot_grid(ax=ax)\n",
    "ax.set_title('Scenario year {}'.format(years[-1]));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}