examples/Notebooks/flopy3_mf6_A_simple-model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FloPy\n",
    "\n",
    "## Creating a Simple MODFLOW 6 Model with Flopy\n",
    "\n",
    "The purpose of this notebook is to demonstrate the Flopy capabilities for building a simple MODFLOW 6 model from scratch, running the model, and viewing the results.  This notebook will demonstrate the capabilities using a simple lake example.  A separate notebook is also available in which the same lake example is created for MODFLOW-2005 (flopy3_lake_example.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setup the Notebook Environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "flopy is installed in /Users/jdhughes/Documents/Development/flopy_git/flopy_fork/flopy\n",
      "3.7.3 | packaged by conda-forge | (default, Jul  1 2019, 14:38:56) \n",
      "[Clang 4.0.1 (tags/RELEASE_401/final)]\n",
      "numpy version: 1.17.3\n",
      "matplotlib version: 3.1.1\n",
      "flopy version: 3.3.1\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import os\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": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For this example, we will set up a model workspace.\n",
    "# Model input files and output files will reside here.\n",
    "workspace = os.path.join('data', 'mf6lake')\n",
    "if not os.path.exists(workspace):\n",
    "    os.makedirs(workspace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the Flopy Model Objects\n",
    "\n",
    "We are creating a square model with a specified head equal to `h1` along all boundaries. The head at the cell in the center in the top layer is fixed to `h2`. First, set the name of the model and the parameters of the model: the number of layers `Nlay`, the number of rows and columns `N`, lengths of the sides of the model `L`, aquifer thickness `H`, hydraulic conductivity `k`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'mf6lake'\n",
    "h1 = 100\n",
    "h2 = 90\n",
    "Nlay = 10 \n",
    "N = 101 \n",
    "L = 400.0 \n",
    "H = 50.0 \n",
    "k = 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One big difference between MODFLOW 6 and previous MODFLOW versions is that MODFLOW 6 is based on the concept of a simulation.  A simulation consists of the following:\n",
    "\n",
    "* Temporal discretization (TDIS)\n",
    "* One or more models (GWF is the only model supported at present)\n",
    "* Zero or more exchanges (instructions for how models are coupled)\n",
    "* Solutions\n",
    "\n",
    "For this simple lake example, the simulation consists of the temporal discretization (TDIS) package (TDIS), a groundwater flow (GWF) model, and an iterative model solution (IMS), which controls how the GWF model is solved. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the Flopy simulation object\n",
    "sim = flopy.mf6.MFSimulation(sim_name=name, exe_name='mf6', \n",
    "                             version='mf6', sim_ws=workspace)\n",
    "\n",
    "# Create the Flopy temporal discretization object\n",
    "tdis = flopy.mf6.modflow.mftdis.ModflowTdis(sim, pname='tdis', time_units='DAYS', nper=1, \n",
    "                                            perioddata=[(1.0, 1, 1.0)])\n",
    "\n",
    "# Create the Flopy groundwater flow (gwf) model object\n",
    "model_nam_file = '{}.nam'.format(name)\n",
    "gwf = flopy.mf6.ModflowGwf(sim, modelname=name, \n",
    "                           model_nam_file=model_nam_file)\n",
    "\n",
    "# Create the Flopy iterative model solver (ims) Package object\n",
    "ims = flopy.mf6.modflow.mfims.ModflowIms(sim, pname='ims', complexity='SIMPLE')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that the overall simulation is set up, we can focus on building the groundwater flow model.  The groundwater flow model will be built by adding packages to it that describe the model characteristics.\n",
    "\n",
    "Define the discretization of the model. All layers are given equal thickness. The `bot` array is build from `H` and the `Nlay` values to indicate top and bottom of each layer, and `delrow` and `delcol` are computed from model size `L` and number of cells `N`. Once these are all computed, the Discretization file is built."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the discretization package\n",
    "bot = np.linspace(-H/Nlay, -H, Nlay) \n",
    "delrow = delcol = L/(N-1)\n",
    "dis = flopy.mf6.modflow.mfgwfdis.ModflowGwfdis(gwf, pname='dis', nlay=Nlay, nrow=N, ncol=N,\n",
    "                                               delr=delrow,delc=delcol,top=0.0,\n",
    "                                               botm=bot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the initial conditions package\n",
    "start = h1 * np.ones((Nlay, N, N))\n",
    "ic = flopy.mf6.modflow.mfgwfic.ModflowGwfic(gwf, pname='ic', strt=start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the node property flow package\n",
    "npf = flopy.mf6.modflow.mfgwfnpf.ModflowGwfnpf(gwf, pname='npf', icelltype=1, k=k,\n",
    "                                               save_flows=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the constant head package.\n",
    "# List information is created a bit differently for \n",
    "# MODFLOW 6 than for other MODFLOW versions.  The\n",
    "# cellid (layer, row, column, for a regular grid)\n",
    "# must be entered as a tuple as the first entry.\n",
    "# Remember that these must be zero-based indices!\n",
    "chd_rec = []\n",
    "chd_rec.append(((0, int(N / 4), int(N / 4)), h2))\n",
    "for layer in range(0, Nlay):\n",
    "    for row_col in range(0, N):\n",
    "        chd_rec.append(((layer, row_col, 0), h1))\n",
    "        chd_rec.append(((layer, row_col, N - 1), h1))\n",
    "        if row_col != 0 and row_col != N - 1:\n",
    "            chd_rec.append(((layer, 0, row_col), h1))\n",
    "            chd_rec.append(((layer, N - 1, row_col), h1))\n",
    "chd = flopy.mf6.modflow.mfgwfchd.ModflowGwfchd(gwf, pname='chd', maxbound=len(chd_rec), \n",
    "                                               stress_period_data=chd_rec, save_flows=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec.array([((0, 25, 25),  90.), ((0, 0, 0), 100.), ((0, 0, 100), 100.),\n",
       "           ..., ((9, 100, 99), 100.), ((9, 100, 0), 100.),\n",
       "           ((9, 100, 100), 100.)],\n",
       "          dtype=[('cellid', 'O'), ('head', '<f8')])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The chd package stored the constant heads in a structured\n",
    "# array, also called a recarray.  We can get a pointer to the\n",
    "# recarray for the first stress period (iper = 0) as follows.\n",
    "iper = 0\n",
    "ra = chd.stress_period_data.get_data(key=iper)\n",
    "ra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Layer 1: Constant Head Cells')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We can make a quick plot to show where our constant\n",
    "# heads are located by creating an integer array\n",
    "# that starts with ones everywhere, but is assigned\n",
    "# a -1 where chds are located\n",
    "ibd = np.ones((Nlay, N, N), dtype=np.int)\n",
    "for k, i, j in ra['cellid']:\n",
    "    ibd[k, i, j] = -1\n",
    "\n",
    "ilay = 0\n",
    "plt.imshow(ibd[ilay, :, :], interpolation='none')\n",
    "plt.title('Layer {}: Constant Head Cells'.format(ilay + 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the output control package\n",
    "headfile = '{}.hds'.format(name)\n",
    "head_filerecord = [headfile]\n",
    "budgetfile = '{}.cbb'.format(name)\n",
    "budget_filerecord = [budgetfile]\n",
    "saverecord = [('HEAD', 'ALL'), \n",
    "              ('BUDGET', 'ALL')]\n",
    "printrecord = [('HEAD', 'LAST')]\n",
    "oc = flopy.mf6.modflow.mfgwfoc.ModflowGwfoc(gwf, pname='oc', saverecord=saverecord, \n",
    "                                            head_filerecord=head_filerecord,\n",
    "                                            budget_filerecord=budget_filerecord,\n",
    "                                            printrecord=printrecord)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on ModflowGwfoc in module flopy.mf6.modflow.mfgwfoc object:\n",
      "\n",
      "class ModflowGwfoc(flopy.mf6.mfpackage.MFPackage)\n",
      " |  ModflowGwfoc(model, loading_package=False, budget_filerecord=None, head_filerecord=None, headprintrecord=None, saverecord=None, printrecord=None, filename=None, pname=None, parent_file=None)\n",
      " |  \n",
      " |  ModflowGwfoc defines a oc package within a gwf6 model.\n",
      " |  \n",
      " |  Parameters\n",
      " |  ----------\n",
      " |  model : MFModel\n",
      " |      Model that this package is a part of.  Package is automatically\n",
      " |      added to model when it is initialized.\n",
      " |  loading_package : bool\n",
      " |      Do not set this parameter. It is intended for debugging and internal\n",
      " |      processing purposes only.\n",
      " |  budget_filerecord : [budgetfile]\n",
      " |      * budgetfile (string) name of the output file to write budget\n",
      " |        information.\n",
      " |  head_filerecord : [headfile]\n",
      " |      * headfile (string) name of the output file to write head information.\n",
      " |  headprintrecord : [columns, width, digits, format]\n",
      " |      * columns (integer) number of columns for writing data.\n",
      " |      * width (integer) width for writing each number.\n",
      " |      * digits (integer) number of digits to use for writing a number.\n",
      " |      * format (string) write format can be EXPONENTIAL, FIXED, GENERAL, or\n",
      " |        SCIENTIFIC.\n",
      " |  saverecord : [rtype, ocsetting]\n",
      " |      * rtype (string) type of information to save or print. Can be BUDGET or\n",
      " |        HEAD.\n",
      " |      * ocsetting (keystring) specifies the steps for which the data will be\n",
      " |        saved.\n",
      " |          all : [keyword]\n",
      " |              * all (keyword) keyword to indicate save for all time steps in\n",
      " |                period.\n",
      " |          first : [keyword]\n",
      " |              * first (keyword) keyword to indicate save for first step in\n",
      " |                period. This keyword may be used in conjunction with other\n",
      " |                keywords to print or save results for multiple time steps.\n",
      " |          last : [keyword]\n",
      " |              * last (keyword) keyword to indicate save for last step in\n",
      " |                period. This keyword may be used in conjunction with other\n",
      " |                keywords to print or save results for multiple time steps.\n",
      " |          frequency : [integer]\n",
      " |              * frequency (integer) save at the specified time step\n",
      " |                frequency. This keyword may be used in conjunction with other\n",
      " |                keywords to print or save results for multiple time steps.\n",
      " |          steps : [integer]\n",
      " |              * steps (integer) save for each step specified in STEPS. This\n",
      " |                keyword may be used in conjunction with other keywords to\n",
      " |                print or save results for multiple time steps.\n",
      " |  printrecord : [rtype, ocsetting]\n",
      " |      * rtype (string) type of information to save or print. Can be BUDGET or\n",
      " |        HEAD.\n",
      " |      * ocsetting (keystring) specifies the steps for which the data will be\n",
      " |        saved.\n",
      " |          all : [keyword]\n",
      " |              * all (keyword) keyword to indicate save for all time steps in\n",
      " |                period.\n",
      " |          first : [keyword]\n",
      " |              * first (keyword) keyword to indicate save for first step in\n",
      " |                period. This keyword may be used in conjunction with other\n",
      " |                keywords to print or save results for multiple time steps.\n",
      " |          last : [keyword]\n",
      " |              * last (keyword) keyword to indicate save for last step in\n",
      " |                period. This keyword may be used in conjunction with other\n",
      " |                keywords to print or save results for multiple time steps.\n",
      " |          frequency : [integer]\n",
      " |              * frequency (integer) save at the specified time step\n",
      " |                frequency. This keyword may be used in conjunction with other\n",
      " |                keywords to print or save results for multiple time steps.\n",
      " |          steps : [integer]\n",
      " |              * steps (integer) save for each step specified in STEPS. This\n",
      " |                keyword may be used in conjunction with other keywords to\n",
      " |                print or save results for multiple time steps.\n",
      " |  filename : String\n",
      " |      File name for this package.\n",
      " |  pname : String\n",
      " |      Package name for this package.\n",
      " |  parent_file : MFPackage\n",
      " |      Parent package file that references this package. Only needed for\n",
      " |      utility packages (mfutl*). For example, mfutllaktab package must have \n",
      " |      a mfgwflak package parent_file.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      ModflowGwfoc\n",
      " |      flopy.mf6.mfpackage.MFPackage\n",
      " |      flopy.mf6.mfbase.PackageContainer\n",
      " |      flopy.pakbase.PackageInterface\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, model, loading_package=False, budget_filerecord=None, head_filerecord=None, headprintrecord=None, saverecord=None, printrecord=None, filename=None, pname=None, parent_file=None)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  budget_filerecord = <flopy.mf6.data.mfdatautil.ListTemplateGenerator o...\n",
      " |  \n",
      " |  dfn = [['block options', 'name budget_filerecord', 'type record budget...\n",
      " |  \n",
      " |  dfn_file_name = 'gwf-oc.dfn'\n",
      " |  \n",
      " |  head_filerecord = <flopy.mf6.data.mfdatautil.ListTemplateGenerator obj...\n",
      " |  \n",
      " |  headprintrecord = <flopy.mf6.data.mfdatautil.ListTemplateGenerator obj...\n",
      " |  \n",
      " |  package_abbr = 'gwfoc'\n",
      " |  \n",
      " |  printrecord = <flopy.mf6.data.mfdatautil.ListTemplateGenerator object>\n",
      " |  \n",
      " |  saverecord = <flopy.mf6.data.mfdatautil.ListTemplateGenerator object>\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from flopy.mf6.mfpackage.MFPackage:\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __setattr__(self, name, value)\n",
      " |      Implement setattr(self, name, value).\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  build_child_package(self, pkg_type, data, parameter_name, filerecord)\n",
      " |  \n",
      " |  build_child_packages_container(self, pkg_type, filerecord)\n",
      " |  \n",
      " |  build_mfdata(self, var_name, data=None)\n",
      " |  \n",
      " |  check(self, f=None, verbose=True, level=1, checktype=None)\n",
      " |      Check package data for common errors.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      f : str or file handle\n",
      " |          String defining file name or file handle for summary file\n",
      " |          of check method output. If a sting is passed a file handle\n",
      " |          is created. If f is None, check method does not write\n",
      " |          results to a summary file. (default is None)\n",
      " |      verbose : bool\n",
      " |          Boolean flag used to determine if check method results are\n",
      " |          written to the screen\n",
      " |      level : int\n",
      " |          Check method analysis level. If level=0, summary checks are\n",
      " |          performed. If level=1, full checks are performed.\n",
      " |      checktype : check\n",
      " |          Checker type to be used. By default class check is used from\n",
      " |          check.py.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      None\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      \n",
      " |      >>> import flopy\n",
      " |      >>> m = flopy.modflow.Modflow.load('model.nam')\n",
      " |      >>> m.dis.check()\n",
      " |  \n",
      " |  create_package_dimensions(self)\n",
      " |  \n",
      " |  export(self, f, **kwargs)\n",
      " |      Method to export a package to netcdf or shapefile based on the\n",
      " |      extension of the file name (.shp for shapefile, .nc for netcdf)\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      f : str\n",
      " |          filename\n",
      " |      kwargs : keyword arguments\n",
      " |          modelgrid : flopy.discretization.Grid instance\n",
      " |              user supplied modelgrid which can be used for exporting\n",
      " |              in lieu of the modelgrid associated with the model object\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |          None or Netcdf object\n",
      " |  \n",
      " |  get_file_path(self)\n",
      " |  \n",
      " |  is_valid(self)\n",
      " |  \n",
      " |  load(self, strict=True)\n",
      " |  \n",
      " |  plot(self, **kwargs)\n",
      " |      Plot 2-D, 3-D, transient 2-D, and stress period list (MfList)\n",
      " |      package input data\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      package: flopy.pakbase.Package instance supplied for plotting\n",
      " |      \n",
      " |      **kwargs : dict\n",
      " |          filename_base : str\n",
      " |              Base file name that will be used to automatically generate file\n",
      " |              names for output image files. Plots will be exported as image\n",
      " |              files if file_name_base is not None. (default is None)\n",
      " |          file_extension : str\n",
      " |              Valid matplotlib.pyplot file extension for savefig(). Only used\n",
      " |              if filename_base is not None. (default is 'png')\n",
      " |          mflay : int\n",
      " |              MODFLOW zero-based layer number to return.  If None, then all\n",
      " |              all layers will be included. (default is None)\n",
      " |          kper : int\n",
      " |              MODFLOW zero-based stress period number to return. (default is\n",
      " |              zero)\n",
      " |          key : str\n",
      " |              MfList dictionary key. (default is None)\n",
      " |      \n",
      " |      Returns\n",
      " |      ----------\n",
      " |      axes : list\n",
      " |          Empty list is returned if filename_base is not None. Otherwise\n",
      " |          a list of matplotlib.pyplot.axis are returned.\n",
      " |  \n",
      " |  remove(self)\n",
      " |  \n",
      " |  set_all_data_external(self)\n",
      " |  \n",
      " |  set_model_relative_path(self, model_ws)\n",
      " |  \n",
      " |  write(self, ext_file_action=<ExtFileAction.copy_relative_paths: 3>)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from flopy.mf6.mfpackage.MFPackage:\n",
      " |  \n",
      " |  data_list\n",
      " |  \n",
      " |  filename\n",
      " |  \n",
      " |  name\n",
      " |  \n",
      " |  package_type\n",
      " |  \n",
      " |  parent\n",
      " |  \n",
      " |  plotable\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from flopy.mf6.mfbase.PackageContainer:\n",
      " |  \n",
      " |  get_package(self, name=None)\n",
      " |      Get a package.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      name : str\n",
      " |          Name of the package, 'RIV', 'LPF', etc.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      pp : Package object\n",
      " |  \n",
      " |  register_package(self, package)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from flopy.mf6.mfbase.PackageContainer:\n",
      " |  \n",
      " |  get_module(package_file_path)\n",
      " |  \n",
      " |  get_module_val(module, item, attrb)\n",
      " |  \n",
      " |  get_package_file_paths()\n",
      " |  \n",
      " |  model_factory(model_type)\n",
      " |  \n",
      " |  package_factory(package_type, model_type)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from flopy.mf6.mfbase.PackageContainer:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  package_dict\n",
      " |  \n",
      " |  package_names\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from flopy.pakbase.PackageInterface:\n",
      " |  \n",
      " |  has_stress_period_data\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Note that help can always be found for a package\n",
    "# using either forms of the following syntax\n",
    "help(oc)\n",
    "#help(flopy.mf6.modflow.mfgwfoc.ModflowGwfoc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the MODFLOW 6 Input Files and Run the Model\n",
    "\n",
    "Once all the flopy objects are created, it is very easy to create all of the input files and run the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "writing simulation...\n",
      "  writing simulation name file...\n",
      "  writing simulation tdis package...\n",
      "  writing ims package ims...\n",
      "  writing model mf6lake...\n",
      "    writing model name file...\n",
      "    writing package dis...\n",
      "    writing package ic...\n",
      "    writing package npf...\n",
      "    writing package chd...\n",
      "    writing package oc...\n"
     ]
    }
   ],
   "source": [
    "# Write the datasets\n",
    "sim.write_simulation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['mf6lake.oc', 'mf6lake.nam', 'mf6lake.dis', 'mf6lake.ims', 'mf6lake.chd', 'mf6lake.npf', 'mf6lake.ic', 'mfsim.nam', 'mf6lake.tdis']\n"
     ]
    }
   ],
   "source": [
    "# Print a list of the files that were created\n",
    "# in workspace\n",
    "print(os.listdir(workspace))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run the Simulation\n",
    "\n",
    "We can also run the simulation from the notebook, but only if the MODFLOW 6 executable is available.  The executable can be made available by putting the executable in a folder that is listed in the system path variable.  Another option is to just put a copy of the executable in the simulation folder, though this should generally be avoided.  A final option is to provide a full path to the executable when the simulation is constructed.  This would be done by specifying exe_name with the full path."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FloPy is using the following  executable to run the model: /Users/jdhughes/.local/bin/mf6\n",
      "                                   MODFLOW 6\n",
      "                U.S. GEOLOGICAL SURVEY MODULAR HYDROLOGIC MODEL\n",
      "                            VERSION 6.1.1 06/12/2020\n",
      "\n",
      "   MODFLOW 6 compiled Jun 12 2020 12:02:16 with IFORT compiler (ver. 19.0.5)\n",
      "\n",
      "This software has been approved for release by the U.S. Geological \n",
      "Survey (USGS). Although the software has been subjected to rigorous \n",
      "review, the USGS reserves the right to update the software as needed \n",
      "pursuant to further analysis and review. No warranty, expressed or \n",
      "implied, is made by the USGS or the U.S. Government as to the \n",
      "functionality of the software and related material nor shall the \n",
      "fact of release constitute any such warranty. Furthermore, the \n",
      "software is released on condition that neither the USGS nor the U.S. \n",
      "Government shall be held liable for any damages resulting from its \n",
      "authorized or unauthorized use. Also refer to the USGS Water \n",
      "Resources Software User Rights Notice for complete use, copyright, \n",
      "and distribution information.\n",
      "\n",
      " Run start date and time (yyyy/mm/dd hh:mm:ss): 2020/06/26  9:36:41\n",
      " \n",
      " Writing simulation list file: mfsim.lst\n",
      " Using Simulation name file: mfsim.nam\n",
      " \n",
      "    Solving:  Stress period:     1    Time step:     1\n",
      " \n",
      " Run end date and time (yyyy/mm/dd hh:mm:ss): 2020/06/26  9:36:42\n",
      " Elapsed run time:  0.610 Seconds\n",
      " \n",
      " Normal termination of simulation.\n",
      "\n",
      "Success is:  True\n"
     ]
    }
   ],
   "source": [
    "# Run the simulation\n",
    "success, buff = sim.run_simulation()\n",
    "print('\\nSuccess is: ', success)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Post-Process Head Results\n",
    "\n",
    "Post-processing MODFLOW 6 results is still a work in progress.  There aren't any Flopy plotting functions built in yet, like they are for other MODFLOW versions.  So we need to plot the results using general Flopy capabilities.  We can also use some of the Flopy ModelMap capabilities for MODFLOW 6, but in order to do so, we need to manually create a SpatialReference object, that is needed for the plotting.  Examples of both approaches are shown below.\n",
    "\n",
    "First, a link to the heads file is created with `HeadFile`. The link can then be accessed with the `get_data` function, by specifying, in this case, the step number and period number for which we want to retrieve data. A three-dimensional array is returned of size `nlay, nrow, ncol`. Matplotlib contouring functions are used to make contours of the layers or a cross-section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Read the binary head file and plot the results\n",
    "# We can use the existing Flopy HeadFile class because\n",
    "# the format of the headfile for MODFLOW 6 is the same\n",
    "# as for previous MODFLOW verions\n",
    "fname = os.path.join(workspace, headfile)\n",
    "hds = flopy.utils.binaryfile.HeadFile(fname)\n",
    "h = hds.get_data(kstpkper=(0, 0))\n",
    "x = y = np.linspace(0, L, N)\n",
    "y = y[::-1]\n",
    "c = plt.contour(x, y, h[0], np.arange(90,100.1,0.2))\n",
    "plt.clabel(c, fmt='%2.1f')\n",
    "plt.axis('scaled');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = y = np.linspace(0, L, N)\n",
    "y = y[::-1]\n",
    "c = plt.contour(x, y, h[-1], np.arange(90,100.1,0.2))\n",
    "plt.clabel(c, fmt='%1.1f')\n",
    "plt.axis('scaled');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "z = np.linspace(-H/Nlay/2, -H+H/Nlay/2, Nlay)\n",
    "c = plt.contour(x, z, h[:,50,:], np.arange(90,100.1,.2))\n",
    "plt.axis('scaled');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We can also use the Flopy PlotMapView capabilities for MODFLOW 6\n",
    "fig = plt.figure(figsize=(10, 10))\n",
    "ax = fig.add_subplot(1, 1, 1, aspect='equal')\n",
    "modelmap = flopy.plot.PlotMapView(model=gwf, ax=ax) \n",
    "\n",
    "# Then we can use the plot_grid() method to draw the grid\n",
    "# The return value for this function is a matplotlib LineCollection object,\n",
    "# which could be manipulated (or used) later if necessary.\n",
    "quadmesh = modelmap.plot_ibound(ibound=ibd)\n",
    "linecollection = modelmap.plot_grid()\n",
    "contours = modelmap.contour_array(h[0], levels=np.arange(90,100.1,0.2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We can also use the Flopy PlotMapView capabilities for MODFLOW 6\n",
    "fig = plt.figure(figsize=(10, 10))\n",
    "ax = fig.add_subplot(1, 1, 1, aspect='equal')\n",
    "\n",
    "# Next we create an instance of the ModelMap class\n",
    "modelmap = flopy.plot.PlotMapView(model=gwf, ax=ax)\n",
    "\n",
    "# Then we can use the plot_grid() method to draw the grid\n",
    "# The return value for this function is a matplotlib LineCollection object,\n",
    "# which could be manipulated (or used) later if necessary.\n",
    "quadmesh = modelmap.plot_ibound(ibound=ibd)\n",
    "linecollection = modelmap.plot_grid()\n",
    "pa = modelmap.plot_array(h[0])\n",
    "cb = plt.colorbar(pa, shrink=0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Post-Process Flows\n",
    "\n",
    "MODFLOW 6 writes a binary grid file, which contains information about the model grid.  MODFLOW 6 also writes a binary budget file, which contains flow information.  Both of these files can be read using Flopy capabilities.  The MfGrdFile class in Flopy can be used to read the binary grid file.  The CellBudgetFile class in Flopy can be used to read the binary budget file written by MODFLOW 6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('NCELLS', 102010),\n",
       "             ('NLAY', 10),\n",
       "             ('NROW', 101),\n",
       "             ('NCOL', 101),\n",
       "             ('NJA', 689628),\n",
       "             ('XORIGIN', 0.0),\n",
       "             ('YORIGIN', 0.0),\n",
       "             ('ANGROT', 0.0),\n",
       "             ('DELR',\n",
       "              array([4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "                     4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "                     4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "                     4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "                     4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "                     4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.])),\n",
       "             ('DELC',\n",
       "              array([4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "                     4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "                     4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "                     4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "                     4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "                     4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.])),\n",
       "             ('TOP', array([[0., 0., 0., ..., 0., 0., 0.],\n",
       "                     [0., 0., 0., ..., 0., 0., 0.],\n",
       "                     [0., 0., 0., ..., 0., 0., 0.],\n",
       "                     ...,\n",
       "                     [0., 0., 0., ..., 0., 0., 0.],\n",
       "                     [0., 0., 0., ..., 0., 0., 0.],\n",
       "                     [0., 0., 0., ..., 0., 0., 0.]])),\n",
       "             ('BOTM', array([[[ -5.,  -5.,  -5., ...,  -5.,  -5.,  -5.],\n",
       "                      [ -5.,  -5.,  -5., ...,  -5.,  -5.,  -5.],\n",
       "                      [ -5.,  -5.,  -5., ...,  -5.,  -5.,  -5.],\n",
       "                      ...,\n",
       "                      [ -5.,  -5.,  -5., ...,  -5.,  -5.,  -5.],\n",
       "                      [ -5.,  -5.,  -5., ...,  -5.,  -5.,  -5.],\n",
       "                      [ -5.,  -5.,  -5., ...,  -5.,  -5.,  -5.]],\n",
       "              \n",
       "                     [[-10., -10., -10., ..., -10., -10., -10.],\n",
       "                      [-10., -10., -10., ..., -10., -10., -10.],\n",
       "                      [-10., -10., -10., ..., -10., -10., -10.],\n",
       "                      ...,\n",
       "                      [-10., -10., -10., ..., -10., -10., -10.],\n",
       "                      [-10., -10., -10., ..., -10., -10., -10.],\n",
       "                      [-10., -10., -10., ..., -10., -10., -10.]],\n",
       "              \n",
       "                     [[-15., -15., -15., ..., -15., -15., -15.],\n",
       "                      [-15., -15., -15., ..., -15., -15., -15.],\n",
       "                      [-15., -15., -15., ..., -15., -15., -15.],\n",
       "                      ...,\n",
       "                      [-15., -15., -15., ..., -15., -15., -15.],\n",
       "                      [-15., -15., -15., ..., -15., -15., -15.],\n",
       "                      [-15., -15., -15., ..., -15., -15., -15.]],\n",
       "              \n",
       "                     ...,\n",
       "              \n",
       "                     [[-40., -40., -40., ..., -40., -40., -40.],\n",
       "                      [-40., -40., -40., ..., -40., -40., -40.],\n",
       "                      [-40., -40., -40., ..., -40., -40., -40.],\n",
       "                      ...,\n",
       "                      [-40., -40., -40., ..., -40., -40., -40.],\n",
       "                      [-40., -40., -40., ..., -40., -40., -40.],\n",
       "                      [-40., -40., -40., ..., -40., -40., -40.]],\n",
       "              \n",
       "                     [[-45., -45., -45., ..., -45., -45., -45.],\n",
       "                      [-45., -45., -45., ..., -45., -45., -45.],\n",
       "                      [-45., -45., -45., ..., -45., -45., -45.],\n",
       "                      ...,\n",
       "                      [-45., -45., -45., ..., -45., -45., -45.],\n",
       "                      [-45., -45., -45., ..., -45., -45., -45.],\n",
       "                      [-45., -45., -45., ..., -45., -45., -45.]],\n",
       "              \n",
       "                     [[-50., -50., -50., ..., -50., -50., -50.],\n",
       "                      [-50., -50., -50., ..., -50., -50., -50.],\n",
       "                      [-50., -50., -50., ..., -50., -50., -50.],\n",
       "                      ...,\n",
       "                      [-50., -50., -50., ..., -50., -50., -50.],\n",
       "                      [-50., -50., -50., ..., -50., -50., -50.],\n",
       "                      [-50., -50., -50., ..., -50., -50., -50.]]])),\n",
       "             ('IA',\n",
       "              array([     1,      5,     10, ..., 689620, 689625, 689629], dtype=int32)),\n",
       "             ('JA',\n",
       "              array([     1,      2,    102, ...,  91809, 101909, 102009], dtype=int32)),\n",
       "             ('IDOMAIN', array([1, 1, 1, ..., 1, 1, 1], dtype=int32)),\n",
       "             ('ICELLTYPE', array([1, 1, 1, ..., 1, 1, 1], dtype=int32))])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# read the binary grid file\n",
    "fname = os.path.join(workspace, '{}.dis.grb'.format(name))\n",
    "bgf = flopy.utils.mfgrdfile.MfGrdFile(fname)\n",
    "\n",
    "# data read from the binary grid file is stored in a dictionary\n",
    "bgf._datadict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Information from the binary grid file is easily retrieved\n",
    "ia = bgf._datadict['IA'] - 1\n",
    "ja = bgf._datadict['JA'] - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, b'    FLOW-JA-FACE', 689628, 1, -1, 1, 1., 1., 1., b'', b'', b'', b'')\n",
      "(1, 1, b'             CHD', 101, 101, -10, 6, 1., 1., 1., b'MF6LAKE         ', b'MF6LAKE         ', b'MF6LAKE         ', b'CHD             ')\n"
     ]
    }
   ],
   "source": [
    "# read the cell budget file\n",
    "fname = os.path.join(workspace, '{}.cbb'.format(name))\n",
    "cbb = flopy.utils.CellBudgetFile(fname, precision='double')\n",
    "cbb.list_records()\n",
    "\n",
    "flowja = cbb.get_data(text='FLOW-JA-FACE')[0][0, 0, :]\n",
    "chdflow = cbb.get_data(text='CHD')[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing flows for cell 56106\n",
      "Cell 56106 flow with cell 45905 is -0.0002858449337963975\n",
      "Cell 56106 flow with cell 56005 is -0.025019694309449392\n",
      "Cell 56106 flow with cell 56105 is -0.025019694309449392\n",
      "Cell 56106 flow with cell 56107 is 0.025058524820593675\n",
      "Cell 56106 flow with cell 56207 is 0.02505852482066473\n",
      "Cell 56106 flow with cell 66307 is 0.00033448625827077195\n"
     ]
    }
   ],
   "source": [
    "# By having the ia and ja arrays and the flow-ja-face we can look at\n",
    "# the flows for any cell and process them in the follow manner.\n",
    "k = 5; i = 50; j = 50\n",
    "celln = k * N * N + i * N + j\n",
    "print('Printing flows for cell {}'.format(celln + 1))\n",
    "for ipos in range(ia[celln] + 1, ia[celln + 1]):\n",
    "    cellm = ja[ipos]  # change from one-based to zero-based\n",
    "    print('Cell {} flow with cell {} is {}'.format(celln + 1, cellm + 1, flowja[ipos]))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}