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": [
      "3.8.11 (default, Aug  6 2021, 08:56:27) \n",
      "[Clang 10.0.0 ]\n",
      "numpy version: 1.19.2\n",
      "matplotlib version: 3.4.2\n",
      "flopy version: 3.3.5\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.isdir(workspace):\n",
    "    os.makedirs(workspace, exist_ok=True)"
   ]
  },
  {
   "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(\n",
    "    sim_name=name, exe_name=\"mf6\", version=\"mf6\", sim_ws=workspace\n",
    ")\n",
    "\n",
    "# Create the Flopy temporal discretization object\n",
    "tdis = flopy.mf6.modflow.mftdis.ModflowTdis(\n",
    "    sim, pname=\"tdis\", time_units=\"DAYS\", nper=1, perioddata=[(1.0, 1, 1.0)]\n",
    ")\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, 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(\n",
    "    gwf,\n",
    "    pname=\"dis\",\n",
    "    nlay=Nlay,\n",
    "    nrow=N,\n",
    "    ncol=N,\n",
    "    delr=delrow,\n",
    "    delc=delcol,\n",
    "    top=0.0,\n",
    "    botm=bot,\n",
    ")"
   ]
  },
  {
   "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(\n",
    "    gwf, pname=\"npf\", icelltype=1, k=k, save_flows=True\n",
    ")"
   ]
  },
  {
   "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(\n",
    "    gwf,\n",
    "    pname=\"chd\",\n",
    "    maxbound=len(chd_rec),\n",
    "    stress_period_data=chd_rec,\n",
    "    save_flows=True,\n",
    ")"
   ]
  },
  {
   "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=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\"), (\"BUDGET\", \"ALL\")]\n",
    "printrecord = [(\"HEAD\", \"LAST\")]\n",
    "oc = flopy.mf6.modflow.mfgwfoc.ModflowGwfoc(\n",
    "    gwf,\n",
    "    pname=\"oc\",\n",
    "    saverecord=saverecord,\n",
    "    head_filerecord=head_filerecord,\n",
    "    budget_filerecord=budget_filerecord,\n",
    "    printrecord=printrecord,\n",
    ")"
   ]
  },
  {
   "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",
      " |      Builds a child package.  This method is only intended for FloPy\n",
      " |      internal use.\n",
      " |  \n",
      " |  build_child_packages_container(self, pkg_type, filerecord)\n",
      " |      Builds a container object for any child packages.  This method is\n",
      " |      only intended for FloPy internal use.\n",
      " |  \n",
      " |  build_mfdata(self, var_name, data=None)\n",
      " |      Returns the appropriate data type object (mfdatalist, mfdataarray,\n",
      " |      or mfdatascalar) given that object the appropriate structure (looked\n",
      " |      up based on var_name) and any data supplied.  This method is for\n",
      " |      internal FloPy library use only.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      var_name : str\n",
      " |          Variable name\n",
      " |      \n",
      " |      data : many supported types\n",
      " |          Data contained in this object\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      data object : MFData subclass\n",
      " |  \n",
      " |  check(self, f=None, verbose=True, level=1, checktype=None)\n",
      " |      Data check, returns True on success.\n",
      " |  \n",
      " |  create_package_dimensions(self)\n",
      " |      Creates a package dimensions object.  For internal FloPy library\n",
      " |      use.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      package dimensions : PackageDimensions\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",
      " |      Returns the package file's path.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      file path : str\n",
      " |  \n",
      " |  is_valid(self)\n",
      " |      Returns whether or not this package is valid.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      is valid : bool\n",
      " |  \n",
      " |  load(self, strict=True)\n",
      " |      Loads the package from file.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      strict : bool\n",
      " |          Enforce strict checking of data.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      success : bool\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",
      " |      **kwargs : dict\n",
      " |          filename_base : str\n",
      " |              Base file name that will be used to automatically generate\n",
      " |              file names for output image files. Plots will be exported as\n",
      " |              image files if file_name_base is not None. (default is None)\n",
      " |          file_extension : str\n",
      " |              Valid matplotlib.pyplot file extension for savefig(). Only\n",
      " |              used 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",
      " |      Removes this package from the simulation/model it is currently a\n",
      " |      part of.\n",
      " |  \n",
      " |  set_all_data_external(self, check_data=True, external_data_folder=None)\n",
      " |      Sets the package's list and array data to be stored externally.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |          check_data : bool\n",
      " |              Determine if data error checking is enabled\n",
      " |          external_data_folder\n",
      " |              Folder where external data will be stored\n",
      " |  \n",
      " |  set_all_data_internal(self, check_data=True)\n",
      " |      Sets the package's list and array data to be stored internally.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |          check_data : bool\n",
      " |              Determine if data error checking is enabled\n",
      " |  \n",
      " |  set_model_relative_path(self, model_ws)\n",
      " |      Sets the model path relative to the simulation's path.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      model_ws : str\n",
      " |          Model path relative to the simulation's path.\n",
      " |  \n",
      " |  write(self, ext_file_action=<ExtFileAction.copy_relative_paths: 3>)\n",
      " |      Writes the package to a file.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      ext_file_action : ExtFileAction\n",
      " |          How to handle pathing of external data files.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from flopy.mf6.mfpackage.MFPackage:\n",
      " |  \n",
      " |  __init_subclass__() from builtins.type\n",
      " |      Register package type\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from flopy.mf6.mfpackage.MFPackage:\n",
      " |  \n",
      " |  data_list\n",
      " |      List of data in this package.\n",
      " |  \n",
      " |  output\n",
      " |      Method to get output associated with a specific package\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |          MF6Output object\n",
      " |  \n",
      " |  package_type\n",
      " |      String describing type of package\n",
      " |  \n",
      " |  plottable\n",
      " |      If package is plottable\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from flopy.mf6.mfpackage.MFPackage:\n",
      " |  \n",
      " |  filename\n",
      " |      Package's file name.\n",
      " |  \n",
      " |  name\n",
      " |      Name of package\n",
      " |  \n",
      " |  parent\n",
      " |      Parent package\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from flopy.mf6.mfbase.PackageContainer:\n",
      " |  \n",
      " |  get_package(self, name=None)\n",
      " |      Finds a package by package name, package key, package type, or partial\n",
      " |      package name. returns either a single package, a list of packages,\n",
      " |      or None.\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",
      " |      Base method for registering a package.  Should be overridden.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from flopy.mf6.mfbase.PackageContainer:\n",
      " |  \n",
      " |  get_module_val(module, item, attrb)\n",
      " |      Static method that returns a python class module value.  For\n",
      " |      internal FloPy use only, not intended for end users.\n",
      " |  \n",
      " |  model_factory(model_type)\n",
      " |      Static method that returns the appropriate model type object based\n",
      " |      on the model_type string. For internal FloPy use only, not intended\n",
      " |      for end users.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |          model_type : str\n",
      " |              Type of model that package is a part of\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |          model : MFModel subclass\n",
      " |  \n",
      " |  package_factory(package_type: str, model_type: str)\n",
      " |      Static method that returns the appropriate package type object based\n",
      " |      on the package_type and model_type strings.  For internal FloPy use\n",
      " |      only, not intended for end users.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |          package_type : str\n",
      " |              Type of package to create\n",
      " |          model_type : str\n",
      " |              Type of model that package is a part of\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |          package : MFPackage subclass\n",
      " |  \n",
      " |  package_list()\n",
      " |      Static method that returns the list of available packages.\n",
      " |      For internal FloPy use only, not intended for end users.\n",
      " |      \n",
      " |      Returns a list of MFPackage subclasses\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from flopy.mf6.mfbase.PackageContainer:\n",
      " |  \n",
      " |  package_dict\n",
      " |      Returns a copy of the package name dictionary.\n",
      " |  \n",
      " |  package_names\n",
      " |      Returns a list of package names.\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",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from flopy.mf6.mfbase.PackageContainer:\n",
      " |  \n",
      " |  models_by_type = {'gwf': <class 'flopy.mf6.modflow.mfgwf.ModflowGwf'>,...\n",
      " |  \n",
      " |  modflow_models = [<class 'flopy.mf6.modflow.mfgwf.ModflowGwf'>, <class...\n",
      " |  \n",
      " |  modflow_packages = [<class 'flopy.mf6.modflow.mfnam.ModflowNam'>, <cla...\n",
      " |  \n",
      " |  packages_by_abbr = {'gnc': <class 'flopy.mf6.modflow.mfgnc.ModflowGnc'...\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties 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"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    writing package npf...\n",
      "    writing package chd...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    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.2.2 07/30/2021\n",
      "                               ***DEVELOP MODE***\n",
      "\n",
      "  MODFLOW 6 compiled Aug 31 2021 16:00:07 with GFORTRAN compiler (ver. 10.3.0)\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",
      "\n",
      " Run start date and time (yyyy/mm/dd hh:mm:ss): 2021/10/25 16:36:17\n",
      "\n",
      " Writing simulation list file: mfsim.lst\n",
      " Using Simulation name file: mfsim.nam\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Solving:  Stress period:     1    Time step:     1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Run end date and time (yyyy/mm/dd hh:mm:ss): 2021/10/25 16:36:18\n",
      " Elapsed run time:  0.957 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": "iVBORw0KGgoAAAANSUhEUgAAAYIAAABFCAYAAABHYOExAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAIZUlEQVR4nO3dXYhcZx3H8e9vJpvU2miMm2raJG6qVYix1BCCUAmitaaxpOpVLoSAQhEqKFI0MSD1ouALvlyIQqpC0WoRtFQKQlNf6FVbkzavpmmTGrVt7FJEbBCsm/17cZ5JTtY5s0tmss+zOb8PLHvmzMzOj//OzH+ec86cRxGBmZm1Vyd3ADMzy8uNwMys5dwIzMxazo3AzKzl3AjMzFrOjcDMrOUW5Q5QNz4+HhMTE7ljXHLTU6dAY3S61+aO0k7xGtNTz6PuNajzhtxpzIa2f//+VyJixcXev6hGMDExwb59+3LHuOTOTN5CZ9HbuHL5vbmjtNL01CnOTG7mimVfY/GVn8gdx2xokv4yzP29aSgLAf4in5mVwY0gCzcCMyuHG0EWAp/aowD+H5iBG0Ee8ojAzMrhRpCFG4GZlcONIAs3AjMrhxtBFiLcCMysEG4EGYguMJ07hqHcAcyK4EaQhSDO5g7RWh6NmV1oqEYg6ZuSnpF0SNKDkpbVrtsl6YSk45I+MnTSy4k8IiiBPCIwA4YfEewF1kfEDcCzwC4ASeuA7cC7gS3A9yV1h3ysy0gX8IggH48IzOqGagQR8UhETKWLjwOr0vLtwAMR8Z+I+DNwAtg0zGNdXjreNJRVrxF4RGAGo91H8CngN2n5WuBvteteSOsMQIvwpqGMwo3ArG7Ws49KehR4a5+rdkfEQ+k2u4Ep4P7e3frcvu94XNIdwB0Aa9asmUPkhU90mWZq9hvaJZKeinIjMIM5NIKIuHnQ9ZJ2ALcBH4o491HrBWB17WargJca/v4eYA/Axo0b27HxVl1vGsqqHU8zs7ka9qihLcCXgG0R8e/aVb8GtktaImktcD3w5DCPdXlZhHcW59RrBD5+wQyGn5jme8ASYK+qYfbjEfGZiDgq6RfAn6g2Gd0Z4Y/A5/moobx6+2f8NRozGLIRRMQ7Blx3D3DPMH//sqUuhPcR5ONGYFbnV0IGokt4RJBPpEbgncVmgBtBJos8IsjKIwKzOr8SclAH7yPI5/xozDuLzcCNIBOfayivqvZyIzAD3Agy8eGjWfUOYPM+AjPAjSALqYOPps2pNxrziMAM3Agy8fcI8vI+ArM6N4Is3AiyCh81ZFY3kleCpLskhaTx2jpPTNNEndqbkc2/3vcI3AjMYPhTTCBpNfBh4K+1dfWJaa4BHpX0Tp9moscjgpx6h4/6qCGzyig+En0H+CIXntLRE9MM5EaQV6/2HhGYwfBnH90GvBgRB2dc5YlpBlDaJBHePJRH72zpnj3VDBhyYhrgy8At/e7WZ50npjmn9wZ0Fn8qzcEjArO6i56YRtJ7gLXAwXQK6lXAU5I24YlpZtF7AzoLjOUM0lI+asis7qJfCRFxOCKujoiJiJigevPfEBF/xxPTzMLfaM2r1wj8fzCDERw11I8npplN6r8Rfi/KyiMCMxhhI0ijgvplT0zT5Nw5blqyJaw0no/A7AL+SJSBOivojK3Hw4FMOm+kM7YesSR3ErMiKKKcT6WSXgWO584xB+PAK7lDzIFzjpZzjs5CyAgLJ+e7ImLpxd75kuwjGMLxiNiYO8RsJO1zztFxztFaCDkXQkZYWDmHub83DZmZtZwbgZlZy5XWCPbkDjBHzjlazjlaCyHnQsgILclZ1M5iMzObf6WNCMzMbJ4V0wgkbUmT2JyQtDN3njpJpyQdlnSgt3de0nJJeyU9l36/KUOuH0ualHSktq4xV47Jghoy3i3pxVTPA5K25syYHne1pN9LOibpqKTPpfWl1bMpZ1E1lXSFpCclHUw5v5rWF1PPARmLqmXtsbuSnpb0cLo8ulpGRPYfqtNxngSuAxYDB4F1uXPV8p0Cxmes+wawMy3vBL6eIddmYANwZLZcwLpU1yVUJws8CXQzZbwbuKvPbbNkTI+9kupcWQBLgWdTntLq2ZSzqJpSfVvyqrQ8BjwBvK+keg7IWFQta4//BeBnwMPp8shqWcqIYBNwIiKej4jXgAeoJrcp2e3AfWn5PuBj8x0gIh4D/jFjdVOuLJMFNWRskm1Co4g4HRFPpeVXgWNUc2iUVs+mnE1y5YyIOJMujqWfoKB6DsjYJNvzU9Iq4KPAD2fkGUktS2kEpU9kE8Ajkvan+RMA3hIRp6F6cQJXZ0t3oaZcpdX4s5IOpU1HvSFtERklTQDvpfqEWGw9Z+SEwmqaNmUcACaBvRFRXD0bMkJhtQS+SzUTZH02q5HVspRGMOeJbDK5KSI2ALcCd0ranDvQRSipxj8A3g7cCJwGvpXWZ88o6Srgl8DnI+Jfg27aZ928Ze2Ts7iaRsTZiLiRaj6STZLWD7h5lpwNGYuqpaTbgMmI2D/Xu/RZNzBnKY1gzhPZ5BARL6Xfk8CDVMOslyWtBEi/J/MlvEBTrmJqHBEvpxfgNHAv54etWTNKGqN6c70/In6VVhdXz345S61pyvZP4A/AFgqs58yMBdbyJmCbpFNUm80/KOmnjLCWpTSCPwLXS1oraTGwnWpym+wkvV7S0t4y1dScR6jy7Ug32wE8lCfh/2nKVcxkQb0nb/JxqnpCxoySBPwIOBYR365dVVQ9m3KWVlNJKyQtS8uvA24GnqGgejZlLK2WEbErIlZFdar/7cDvIuKTjLKW87XHew57xLdSHQFxEtidO08t13VUe+APAkd72YA3A78Fnku/l2fI9nOqoet/qT4FfHpQLqp5pk9SneH11owZfwIcBg6lJ+3KnBnT476favh8CDiQfrYWWM+mnEXVFLgBeDrlOQJ8Ja0vpp4DMhZVyxmZP8D5o4ZGVkt/s9jMrOVK2TRkZmaZuBGYmbWcG4GZWcu5EZiZtZwbgZlZy7kRmJm1nBuBmVnLuRGYmbXc/wBd9jUMpODb0AAAAABJRU5ErkJggg==\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, 0.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": [
       "{'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': 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': 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",
       " 'BOTM': array([ -5.,  -5.,  -5., ..., -50., -50., -50.]),\n",
       " 'IA': array([     1,      5,     10, ..., 689620, 689625, 689629], dtype=int32),\n",
       " 'JA': 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.mf6.utils.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": [
    {
     "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": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing flows for cell 56105\n",
      "Cell 56105 flow with cell 45904 is -0.000285844933887347\n",
      "Cell 56105 flow with cell 56004 is -0.025019694309662555\n",
      "Cell 56105 flow with cell 56104 is -0.025019694309662555\n",
      "Cell 56105 flow with cell 56106 is 0.02505852482052262\n",
      "Cell 56105 flow with cell 56206 is 0.025058524820593675\n",
      "Cell 56105 flow with cell 66306 is 0.0003344862580433983\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\n",
    "i = 50\n",
    "j = 50\n",
    "celln = k * N * N + i * N + j\n",
    "ia, ja = bgf.ia, bgf.ja\n",
    "print(\"Printing flows for cell {}\".format(celln))\n",
    "for ipos in range(ia[celln] + 1, ia[celln + 1]):\n",
    "    cellm = ja[ipos]\n",
    "    print(\"Cell {} flow with cell {} is {}\".format(celln, cellm, flowja[ipos]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}