flopy/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.8.6 | packaged by conda-forge | (default, Oct  7 2020, 18:42:56) \n",
      "[Clang 10.0.1 ]\n",
      "numpy version: 1.18.5\n",
      "matplotlib version: 3.2.2\n",
      "flopy version: 3.3.3\n"
     ]
    }
   ],
   "source": [
    "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= 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=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=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=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=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": {
      "needs_background": "light"
     },
     "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.PlotCrossSection(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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}