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.0\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",
      " |  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_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"
     ]
    }
   ],
   "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.0 12/12/2019\n",
      "\n",
      "   MODFLOW 6 compiled Dec 13 2019 12:29:49 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): 2019/12/14 15:38:47\n",
      "\n",
      " Writing simulation list file: mfsim.lst\n",
      " Using Simulation name file: mfsim.nam\n",
      " Solving:  Stress period:     1    Time step:     1\n",
      " Run end date and time (yyyy/mm/dd hh:mm:ss): 2019/12/14 15:38:47\n",
      " Elapsed run time:  0.550 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",
    "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": "iVBORw0KGgoAAAANSUhEUgAAAQsAAAD8CAYAAABgtYFHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXgkZbX48e+prbfsmQzMsDiAgHJVUAYF9CooyACy/sQF9aIXBBEUryjLVRH14aqgIioqiygiKCAqiijCAOIGOGwKArKILLNksie91vL+/ujKGMZhptLpdCc95/M8ebq7Um/VqZnkpOqtt94jxhiUUmpTrGYHoJSaHzRZKKUS0WShlEpEk4VSKhFNFkqpRDRZKKUSSZwsRMQWkftE5Ib4c4+I3Cwij8Wv3VPWPVNEHheRR0XkgNkIXCnVWNM5szgFeHjK5zOA5caYHYHl8WdEZBfgHcB/AMuAb4qIXZ9wlVLNkihZiMjWwMHApVMWHwZcHr+/HDh8yvIfGWPKxph/AI8Dr65PuEqpZnESrvdV4DSgfcqyLYwxqwCMMatEZGG8fCvgzinrPRsvex4ROR44HiCXy+3+kpe8ZJqhK6Wm45577hkwxvTV2n6TyUJE3gL0G2PuEZF9EmxTNrDs38aUG2MuBi4GWLp0qVmxYkWCTSulaiUi/5xJ+yRnFq8FDhWRg4A00CEiPwDWiMii+KxiEdAfr/8ssM2U9lsDK2cSpFKq+TbZZ2GMOdMYs7UxZgnVjstbjTHvBn4OHBOvdgxwffz+58A7RCQlItsBOwJ31z1ypVRDJe2z2JAvANeIyLHA08BRAMaYh0TkGuBvQACcZIwJZxypUqqpZC48oq59FkrNPhG5xxiztNb2OoJTKZWIJgulVCKaLJRSiWiyUEoloslCKZWIJgulVCKaLJRSiWiyUEoloslCKZWIJgulVCKaLJRSiWiyUEoloslCKZWIJgulVCKaLJRSiWiyUEoloslCKZWIJgulVCKbTBYikhaRu0XkARF5SEQ+Ey8/W0SeE5H746+DprTR8oVKtZgkE/aWgTcaYyZExAV+LyK/ir93vjHmS1NXXq984WLgFhHZSSftVWp+S1IKwBhjJuKPbvy1sVl+tXyhUi0oaa1TW0Tup1pI6GZjzF3xt04Wkb+IyGVTqqhvBTwzpfkGyxcqpeaXRMnCGBMaY3ajWl3s1SLyMuBbwA7AbsAq4Mvx6onKF4rI8SKyQkRWrF27tqbglVKNM627IcaYEeB2YJkxZk2cRCLgEv51qZGofKEx5mJjzFJjzNK+vpprtSqlGiTJ3ZA+EemK32eA/YBH4vqmk44AHozfa/lCpVpQkrshi4DLRcSmmlyuMcbcICJXiMhuVC8xngJOAC1fqFSr0vKFSm0mtHyhUqohNFkopRLRZKGUSkSThVIqEU0WSqlENFkopRLRZKGUSkSThVIqEU0WSqlENFkopRLRZKGUSkSThVIqEU0WSqlENFkopRLRZKGUSkSThVIqEU0WSqlENFkopRLRZKGUSmQmtU57RORmEXksfu2e0kZrnSrVYpKcWUzWOt2VakGhZSKyJ3AGsNwYsyOwPP68fq3TZcA345nBlVLz2ExqnR4GXB4vvxw4PH6vtU6VakEzqXW6hTFmFUD8ujBePVGtUy1fqNT8MpNapy8kUa1TLV+o1PxSc61TYM1kCcP4tT9eLVGtU6XU/FJzrVOqNU2PiVc7Brg+fq+1TpVqQTOpdfon4BoRORZ4GjgKtNapUq1Ka50qtZnQWqdKqYbQZKGUSkSThVIqEU0WSqlENFkopRLRZKGUSkSThVIqEU0WSqlENFkopRLRZKGUSkSThVIqEU0WSqlENFkopRLRZKGUSkSThVIqEU0WSqlENFkopRLRZKGUSiTJhL3biMhtIvJwXL7wlHj52SLynIjcH38dNKWNli9UqsUkmbA3AE41xtwrIu3APSJyc/y9840xX5q68nrlCxcDt4jITjppr1LzW5LyhauMMffG78eBh9lAhbEptHyhUi1oWn0WIrIEeCVwV7zoZBH5i4hcNqWKupYvVKoFJU4WItIGXAd8xBgzBnwL2IFqZfVVwJcnV91Acy1fqNQ8l7Qwsks1UVxpjPkJgDFmTVwDNQIu4V+XGlq+UKkWlORuiADfAR42xnxlyvJFU1Y7Angwfq/lC5VqQUnuhrwWeA/wVxG5P172v8A7RWQ3qpcYTwEngJYvVKpVbTJZGGN+z4b7IW7cSJtzgHNmEJdSao7REZxKqUQ0WSilEtFkoZRKRJOFUioRTRZKqUQ0WSilEtFkoZRKRJOFUioRTRZKqUSSDPdWdWZMQBT+kyh4gij4JyZcRRSuxkQjGDMGpkJ1pLyApBDJIlYXYvUg1pZYzlZY9vbY7o6I1dXsw1GbCU0WDWCiUYLKXYTlOwkr9xEGD4Ep/WsFyWBZixCru5oQJA3YQATGx5g8UfAsJroPEw0w9Yl/sbfCdl+B7b0aJ7U3lrMzInrCqOpPk8UsicLV+MVfEpRuJqzcBYRACtvbFS/7Lix3FyznxdjOdiCdVB/u3TRjKphwJWHwBFHwGGHlr4T+/QSlX1EGxFqIk94PN70MO/U6RPS/WNWH/iTVkTEl/OKN+IWrCSt3AgbL2Rmv7USc1Buwvd0QSc1oHyIe4izBcpYAb1q3PAqeI6j8kaB0K37xevzCVYjVi5s5BDf7Lmx35xntVylNFnUQhYNU8t/FL1yBiYax7CWk2j+Ckz4E231xQ2KwnK3wnKPwskdhTJmgdDt+8adU8ldRyX8P29sTr+39OKk36WWKqokmixmIwn4qE9+gkv8hUMFJvxkvdwy2t3dTfyFFUriZA3AzBxCFg/iFa6gUrqA4dCyWsxOp9lNw0gdr0lDToj8tNTBRgdLYeUz0v45K/grc7OHk+paT7bkEJ/W6OfVLaNm9pNpPpG3hHWS6vgYYisMnkR94C0H5d80OT80jc+eneh4wxuAXf8FE/75UJr6Okz6AtoW3kek6r2GXG7USceKk9hvSXV/FRKMUBt9FYegEouDZZoen5gFNFglF4RqKw++nOHwSYveS7f0x2e6vxx2N84eIjZc9kraFy0m1n0ZQvo2JtftRyV9Ode5lpTZsJuULe0TkZhF5LH7tntKmpcoX+sVfM9G/H0Hpt6Q6PkVuwS9wUvO7bpJImlT7ybT13Yrt7U5p9FMUBo8mClc3OzQ1RyU5s5gsX/hSYE/gpLhE4RnAcmPMjsDy+PP65QuXAd8UEXs2gp9txpQpjnyK4vDxWM625Bb+mlTb+5mnh7NBlrM12Z4fkO78IqF/H/m1B+CXbml2WGoOmkn5wsOAy+PVLgcOj9+3RPnCKBygMPhO/MLleLnjyC34KbazQ7PDmhUigpd7J7m+GxFrEcWh/6Y09mW9LFHPM5PyhVsYY1ZBNaEAC+PV5n35wtB/hPzAIYT+g2S6LyTdeRYiXrPDmnW2swO5vp/hZt5GZeICisMnYqJis8NSc8RMyhe+4KobWDZvyhcG5T+TH3grmIBc73W4mUOaHVJDiaRJd51HquMsgtKvKQy+gygcanZYag6ouXwhsGayKln82h8vn7flC4PSbykMvQvL6q1edngvb3ZITSEipNqOI9N9EaH/NwqDR2nHp6q9fCHVMoXHxO+PAa6fsnzelS8Myr+nMHQclr0D2QXXYTlbNzukpnMzy8j2fp8oXElh4O2aMDZzSc4sJssXvlFE7o+/DgK+AOwvIo8B+8efMcY8BEyWL/w186B8YVC+m8LQsVjOdmQXXIVlL2h2SHOGk9qLbO8VRFF/fGtVL0k2V2LMv3UnNNzSpUvNihUrmrLv0P87+YEjsew+sr3XaqJ4AUH5TgqD78FyX0Ku90eIlWt2SGqaROQeY8zSWttv1iM4o3CQwtD7EEmR7blCE8VGOKk9yfRcSOT/leLwh5jjJ4tqFmy2ycKYCsXh92PCfrI9l2kfRQJu+s2kO88mKN9CefzcZoejGmyzfUS9PPZ5wsoKMt3fwPZ2bXY484abPYbQf5TKxLew3V1xMwc1OyTVIJvlmYVf+g2V/Hfwcu/FzRza7HDmFREh3fkZLHdXiiOnEQXPbLqRagmbXbKIwtUUh0/Fcl9GquMTzQ5nXhLxyHZ/g+rcGB/GmKDZIakG2KyShTGG0sgZQJlM94Uzng9zc2Y5LyLTeQ6hfw+V/KXNDkc1wGaVLPzidQTlW0m1n16dVVvNiJM5DCf9ZspjXyYMnmx2OGqWbTbJIgoHKY9+FtvdHS/3vmaH0xKq/RfngKQojX6KuTBmR82ezSZZlMfPxZgJ0l1fnFNzZM53lr0FqfaPEpZ/R1C6qdnhqFm0WfzWhP4j+IUfVWfedndqdjgtx8v9F5azE+Wxz2OM3+xw1CzZLJJFeezzIO2k2k9pdigvaD6PiBRxSHWcRhT+A79wbbPDUbOk5ZNFUP4jQfk2Uu0fmrNFhAv5axgeOp6BtUdSKt02L6/9ndT+2O6rKE98Tc8uWlTLJ4vy+PmItQVe7phNr9wE5fKfyOe/S3vHqbS1f5hC/odE0VD8vd8TBE83OcJkRASv/cOYcCV+8fpNN1DzTksni6B8N2HlLry2E+PK5HOP7z+E570G192FdHofEAtjRhkZ/ij5ie8zPPR+hgaPI4ommh3qJjmpfbGcl1CZuHhenh2pjWvpZ0MqE99GrB687DubFkMUFQiDJwmjfqJoBGOK2NZC0pn9J9fAmOo8l+XynTj21oyPnU8Q/IO+hTcAMDb6eYLgCbwNPMNijElcgX22VSf+fR+l0dMJK3+e9+US1PO1bLIIgycIyrfgtX0EsTIN228QPEu5dAuVyt1UKisIw3+v9uW6u69LFun0QYyWzmBg4G1Y0gkIkRkhlX79uvXFaqNcvgPP23UDySGkUr4P19uN6uyHzeVmDqM0dg6Vwg80WbSYlk0WlYnvAR5e7r9mfV9RNEGx8GMKhavx/QcAsKxFeKmlZJ2jcdwdsO3FWNJVvRya8kvtOFvTu+AH+JUHKZVuJopGacueSH7iu5TLf8AYn/zEZXR1TT4SbuKEYVEu/5Fy6bdUKvcShk+RTi+jveMMrCZOTCNWFjdzKH7xx5gor5PktJCWTBYmKuAXr8PNHDyrE9pE4RATE98in/8+xozjui+jveMTZNLLsJ3tN3l5UCrdQhQOkc29jTBag+//jVzbe/G8V1LxVpCf+B6OswRjKqTS+wE8b0DZ2NgXaMsdS0fnmRhTplK5hw1Prt5YbuZw/MIP8Es34WWPbHY4qk6STNh7mYj0i8iDU5adLSLPrTcn5+T3ml660C/9EswEbvboWdm+MRXGx7/GmjV7MjHxTVLpfVnQ9wsW9N1Ee/tJOO4OifsRisWfsWb1XpSKv4wTxd4AtLW9n57eS7CsXlKpvRCR543FKJf/BCYASeH7jyKSIpXaG5HGXXK9ENtbiliLCEq/bnYoqo6SnFl8D/gG8P31lp9vjPnS1AXrlS5cDNwiIjs1esJev3Atlr0E26v/NXOlch8jw6cSBI/Ep/2n47o717StdHo/0un9iKICYLCsHMXCzygUriOVfgNh8DQQ0tZ+ctzCrOuzKBZ/gTF5guBxJsa/Tjb7VnJt75sTnZ0iFk56f/zitRhTmrN3otT0JClfeAeQdErnppcujILnCCt34mbfWtdfHGMMExMXM7D2UCIzSk/P9+jpvazmRDGVZWXX9TNksoeTy/0Xgf8Ilt1He8fpeN5uQHWk5OQxBf4jtLV9kPb2k+noPBPff4gwnDuV3Zz0m8AUCctzvgqESmgm4yxOFpG/xJcpkxXUE5UuhNkrX+iXqrcb6zkDVhQVGB7+AGOjZ5NOH8DChbeRzry5bttfXzqzP13dX6K9/UNYVgcAlcoDDA9VzzCMiTAEpDNvAcCy+gijtRhTmLWYpsvxXg04BJU/NTsUVSe1JotvATsAuwGrgC/HyxOVLoTZK1/oF3+J5b4cy1lSl+1F0ThDg++mVLyBjo5P0t1zybpf4EbyvF3p6DwbqJ7mZ7NvZ3Tk4xQL11PIX4VtL8JxXtTwuF6IWDlsd1fCyl3NDkXVSU3JwhizxhgTmmqZ7Uv416VGU0sXRuFqIv9+3PSB9dleNMLgwNuoVFbQ3f1N2to/2NQ+AXvKnZ1M5lBcd1eKpRtxnO3p6DgTYE6NnLS9XQn9B3XavRZR061TEVk0WUEdOAKYvFPyc+AqEfkK1Q7OhpYuDErLAXDS+29izU0zpszQ4Pvw/Yfp6fnOlBGXc4NltdPWfsK/LZ8LHZyTLPcVYC4jCp7ArkPfjmquTSYLEfkhsA+wQESeBT4N7CMiu1G9xHgKOAGqpQtFZLJ0YUCDSxcG5TsQezGWM7M5K4wxjAx/jErlLrq6L5xziWJD8vnvY9tbk06/sdmhrDM5d0gUPKbJogVsMlkYYzb0YMV3NrL+OcA5MwmqFsaEBOU/4GYOmvFf1/zEtykWr6O9/TSy2SPqFOHsMaZCIf8DguBp+hbegjNHCiZZ9vYARMETTY5E1UPLPHUaBY+AGcOJBzXVyq88yNjYF0inD6RtDk+WM5WIR3fPpUDEyPD/zJl+C7GyiNVHFD7X7FBUHbRMsgjK1V53ewYPLxlTYXj4Q1hWN51d586p6/9NcZxt6ej8NJXKHygUftjscNYRexFR2LA+bjWLWiZZhP59iLUIy15c8zYmJi4iCB6lq+s8bLu3jtE1RjZ7NJ63B+Nj58ajQpvPsvowUdIxfWoua51kUbkfOx7pWFP7sJ+J8QtIp5fNiw7NDREROjo+RRT1k5+4uNnhACBWFyYabXYYqg5aIlmYaAwT/hPbfXnN25iY+BbGlOno/GQdI2s8L7WUVHp/JiYumRtnF9IGZu7P8qU2rSWSReg/DIDl7lJb+3CAQv5yMpkjcZzt6xlaU7S1fQBjhikWf9LsUBDxMKbS7DBUHbREsoiCvwNgO7Xdyy/kr8CYEu3tH6pnWNXbueEA5cojVPwniaJ8Xbf/QjxvTxznpRTyVzdkfxtnVR+lV/NeS0x+EwX/AMkg9qJptzUmpFC4klTqDTjui2ccSxiNMZa/hnzpdgrlP2JM6Xnfd+xF5NL70pY5iFx631m54yIiZLJHMD72fwTB0zjOtnXfR3LB82YGU/NXyyQLy35RTWUJK5U/EYYr6ej89MxiMCWGxy9laPybRNEInrMDnbl34jk7YNu9GFMhCNdQqjzAeOEXjOavIu3tTl/Xp8jOwlyVmcyhjI/9H6XSb2hrO67u20/KmMqcmBtUzVxrJIvwOSy7tlGLxeKNiKRJpd5U8/4rwVOsHDiesv8gufSbWND5cdLeK15wfWN8RvPXMDD6JZ7pP5yejlNY0PExROyaY1if42yLbb+ISvmP0NRkMQ7S+Kd0Vf21SLJYiZ3ac9rtjDGUS78hldoHy8rWtO9S5QGeWXs0YNhqwfdoSzDPhYhLV9u76MgeQf/IpxgauwA/eJpFPV+ra8LwUntSLv2mqeUCTDSCWJ1N2beqr3nfwWlMCcwYlrVw2m3D8GnCcCWp1Os3vfIG+MFzPLv2v7CljRdtcWOiRDGVZWXZsufLLOg8k/HCT1k7Wt9Hajz35UTRMFG0pq7bnQ4Trsayt2ja/lX9zPszCxMOAiDW9EdcVuIh4l5NZyUhKwdPwJgiWy38Md4MJtvp7fgQQbCScuWvGOPX7RrfiZ/09P1Hse0t67LN6YrCVdjeHk3Zt6qv+Z8sTHV0YC1Fj33/b4ikcZwdp912NH8lpcq9LOr5Bil3+u3Xt7D7M4CFSP3+S2y7OqNhFDbnzCKKhsGM1m3WMtVc8z9ZROMAiNU+7bZB8AiOs9O0+wkiU2Jg9Dwyqb1pr9Mj7CJeXbYzlWVVpysMo+ZM5Dv5aLrVAgPdVAv0WRDXCUWm30EZBM9i1zBvZaH0W8JokN72k+b0k6kS/5tM1lJttCgeWVvrYDk1t8z7ZGFMGajtL3MUrcG2pt/5Nl64EcvqIpt+3bTbNlI1kQkQNWX/of9XxOpG7A1O8K7mmXmfLGBy1r7pXUoYE2JMHquGvo5i5R6yqb3n/GCj6jMZBqE5cYaVFdjuK+f02ZdKrtbyhT0icrOIPBa/dk/5XoPLF07+IE5vdqjJMxIkNc12AX7wNJ6zw7TaTcfk06IznfEqih8Nt6zuTaxZf1G4lih4vKbxL2puSnJm8T1g2XrLzgCWG2N2BJbHn9cvX7gM+KbUc5TRhkxuftoPK1VPzWWahYTDaBQIcOz61TqZaqxwPSsHP0AleCqub1r7JUQUrgaY1eLQLyQo/w4Ax9ur4ftWs6PW8oWHAZfH7y8HDp+yvKHlC4V0HGd5eu3iAsLT7fyzZHJ/s/PYdal8H374HAMjX6ASPI2IVXPdjSC+G9GMx+6D0m8QayHWDOYYUXNLrX0WW0zWDYlfJ4dPNr584WTV8GmW7hOxEckQxbdek7fLAC5BNDitdpsyeQaRSe1Oe+Ygsum9GRg5J74Uqe2a3w8eBSwcZ7v6BZqAiYoE5d/ipPer6eE+NTfV+3+y4eULJ587mBycNR2WvYgwWrXpFafuTyzS3sspVe6b9v42tV0Az3kxleAJsqnX4bk78ezat7Ny8DiMqWCMP61tVsorcN3/WHcW1ShBeTmYfF3rzarmqzVZrBGRRVCtTgb0x8sbXr5wcuRmLfM82vZWhMHT026X8fagVLmfMBqbdtuNMSbEsjqxJIPnbo9tdVGq3A9Ubw1P5+6LMSV8/148r6FF7AHwiz9DrD5s7zUN37eaPbUmi58Dx8TvjwGun7L8HSKSEpHtaED5QrF6AKumIc2u81J8/9Fp9wl05I7AmBJj+Wumvc+p1r/bIWLjOouxrW5WDnyA4YnvsmXP+djWAgZGz53WtsulOzCmSCpd+6P3tYjCVQSl5bjZo+r6BK1qvlrLF34BuEZEjgWeBo6C5pQvFHEQayEmnN7lBIDrvQLyJYLgUVz3PxK3S3uvIO0tZWj823TkjsKu4RHsMBqrni2s66CdTBwG215IqfIXtu67Es95EZ67E840n9wsFm9ApJNUamZFl6arkr8KCPGyGypkp+azWssXAmzwT1YzyhdazjZE4T+n3S4VnyaXS7+bVrIAWNh1Fk/3H8nqoY+yuPfSxAOPjPFZOfgBLMliWZ1kvN3pyB2x7japiEVH9v/RlTsay2qrxjnNB9XCcJBi8Rdkc2+flWdOXoiJCvj5y3FS+2HVMIxezW0t0VVt2dtV5+GcJtvZCsfZmVL51mm3zaSW0tf5v0wUf8Xg2FcTDaAyJmLV4Mm49rYs7D6H9sxB9I+cxXjhF89bz7F7say2msdYFApXAmVyuffV1L5WlcKPMGYEr/2DDd2vaozWSBbujphobfWR6GlKZ5ZRKf+RsIbLmO72E2jPHs7g2HmsGjqJKNp4fQwRC9vqobv9OGyrg2x6bzKp17B66DTyxdvX3RHpH/kchdKdNd12jKJx8hMXkUrti9vAyuUmKlKZuBDbezWOt7Rh+1WN0xLJwnZeCkDk/23abbPZo4CIQuHH024rIizq+UY809XPeWrNAYzmf0y03gCxIFxNvng7YThMGA3RP3IWYTROofQHXHsxfV3/y0j+ynV3VzqzbyWbrm2YdH7iEqJomPaO02pqX6tK4XJMtJZU+8cbul/VOC2RLCz3ZQCElQem3dZxtsfz9iY/8b1pjwKF6tlCb8eH2KbvGgSX1UMf5smVu7Ny4ASGxi+hWLqHp/uPZLz4c/pHPkMmtQdl/1EGRj/P2tHPk02/lo7skXFnZ7ULKeW9dNpxAATBPxgf/wbp9MF43q41baMWUdhPefzrOKl9cVJ6u7RVzfvJbwAsuwfL3o7Qv6em9m3tJzM0eDSFwjXkcu+paRvZ9N4s2fI2CuU7GM1fQ7H8Z8aLv6Az9y4WdJ5GR/Zw8sXbGJ74Lrn0G+jKvQe3awmWpAmjEcJoiDAarHniYGMMIyOnI+LS2fXZmrZRq/LYuWBKpGZYTkHNbS1xZgFge3sQlO+mlju1qdQbcN3dGR/7yrSHf08lIuTSb2Bx74XssPhudlj8AMaEVPxqxbRcZl9sqwcw5Mu/RbAoVx7h6TWHkfH2wHW22fgONmJi4ptUyr+no/OT2DUUW6pVUP4TfvEavLZjsXVGrJbWMsnCSb8ezCih/5dptxUROrs+SxT1Mz725frFZPfR2fZ2/GAl/SOfY2j8IoJwZXUEaPleRDwqwZP0dpzCgs6P1ryfcvkPjI99nnTmELLZd9ct/k0xUYHiyMew7CWk2v6nYftVzdEyycJO/SdgEZSW19Te815JNvtu8vlLKZf/ULe4Mt7udLW9F0xAGA6wqPdbdOSOIDTjBOEa2jLL6MgdWfP2ff9RhgaPx3G2p6vryw2daKY0djYmfJZ013mI1djnT1TjtUSfBVQneLG9PQlKN2LaT63pl6aj8ywqlT8xPHQifQtvqsvpvIhDJrUbmdRu64r95Eu/Jwz71w3CqlUQ/IPBgerAq57eK9YN4moEv/hz/MKP8No+qJ2am4mWObMAcDMHEwWPEwXTv4UKYFk5unsuxZgCQ4PHzaj/YkNEhPHCjawZPp2+zk/iOrUnI99/hMGBowCf3gVX4zRwxGTo/53iyBnY7u6k2k9t2H5Vc7VYsjgESFEpXF37Ntyd6O6+EN//K4OD76p7wsik9mCr3kvJZfapeRul0u0MrD0MY0J6e6/GdXeqX4CbEEXDFIaORSRDpufCOT8PqaqflkoWYnXhZA7EL/wEE+Vr3k46cwDdPd/Cr9zP4MA7CcP61d1w7L6ax1EYEzI+/nWGBt+DbW9DX98NuN7L6hbbpvdfojh0AiZcTabnEix7ccP2rZqvpZIFgJd7H5gxKoWrZrSdTOZgunsuwvf/xtr+N1OOSx02SxD8k8GBt1bveqQPZEHfz7Cdxk2xb0xAcfhDhJU7yXSdh+O9qmH7VnNDyyULx3sltrcXlYmLq0WTZyCTOZC+hTcgkmVw4K2MjZ3b8II9UVRgfOx8+tfsi+8/RFf3BXT3XNTQzkxjQkojHyco3US64zO42cM33Ui1nJZLFgCp9g9jojVU8lfMeFuuuwt9C39FJnM4E+NfpX/NvhQL19c0+Gs6ogq4JykAAAuiSURBVKjAxPi36V+zF+Pj55FO78fCLW4nmz2qobdHjQkojXwUv3gdqfZT8doa+ySrmjtaMlk4qddip95AefwConDmE+taVgfdPV+nd8G1iGQYHj6Rtf37ks9fWfcOUN//O6Ojn2HN6qWMjX0Wx92Z3gU/paf3YuwG9xEYU6I4fBJ+8aek2k8j1X5KQ/ev5haZaSGbeli6dKlZsWJFXbcZ+n8nv/ZAnMzBZLu/VrftGhNSKt3I+PgFBHEV9nT6AFLpN5FKvR7bXrjpjUwRRQX8yj2Uy7+nVPo1QfAY4JDOHEhb7ji81B51i31acYVDFIePI6ysINXxaVJtxzYlDlU/InKPMabm+QNaZlDW+mx3J1LtJ1MePx8//RbczJvrsl0Rm0zmENLpt+D791HIX02pdCPFYnUaUttejOu+HNveFttejGV1/qtAMWWiaIwoXEMYPoPvP0oQPE51BkIbL7UXnbljSGcOwZ6lIkZJhP7fKQz9NyZcQ6b7wviWtNrczejMQkSeAsapFhwNjDFLRaQHuBpYAjwFvM0Ys9FZaWbjzAKqhYDyaw/FRKvJLfgl1izdPTAmwvcfpFL+A77/F3z/b4ThsxvpDHWw7UU47s64zi54qdfgeUuxrPZZiW86/MJPKY6eiUiOTM+lON4rmx2SqpOZnlnUI1ksNcYMTFl2LjBkjPmCiJwBdBtjTt/YdmYrWQCE/uPkBw7FcpaQW/ATJK4oNtuMMRgzShSNYUwBEERSiLRjWd1zrviOiYqUxs7CL1yN7e1BpvtCLHvLZoel6mimyWI2fmJfqLRhU9jui8l0X0DkP0hx+JRZv4sxSUSwrC4cZ1tc9yW47s44zhJsu3fOJYqgfBf5tQfgF67Ba/sw2d6rNVGofzPTn1oD/EZE7hGR4+NlL1TasGnc9P6kOj5NUPoVxZH/aVjCmOtMNE5x9CwKg0dhCMn2/pB0x8cQadmuLDUDM/2peK0xZqWILARuFpFHkjaMk8vxANtuu+0Mw9i0VNuxYEqUx79I0VTIdH+1YZckc40xEX7xJ5THvoiJ+vFy7yXVfjpi5ZodmprDZpQsjDEr49d+Efkp1Yrpa0RkkTFm1XqlDddvezFwMVT7LGYSR1Kp9pNAPMpjn6MwsIpMz0Wb3el2UP49pbH/I/IfxHJ3JdNzsXZiqkRqvgwRkZyItE++B94MPMgLlzacE1Jt7yfTfRFh8Cj5tQcTlO5odkizzhhDUL6T/MA7KAwejYlGyHR9jdyC6zVRqMRmcmaxBfDTeOixA1xljPm1iPyZDZQ2nEvczIFYzvYUh0+kMPRu3Ow7SHd8ErE6mh1aXRkTEpRuojJxMaF/L2L1keo4Cy/37s32EkzVruZkYYx5Evi3+eaNMYO8QGnDucR2dybXdyPl8a9QmbiYoLScVPvH4oK+86ODLwrXYMI1YLVjO9utm4krCtfiF66lUrgSEz6D2NuS7vwcbvbtmiRUzebHb8UsEUmT7vhf3PTBlEbPpjR6OpWJi/DaT8TNHNHQOqHAul/2dZ+jCWQDT5caU6Y8fgFB6WbE6kasPtIdHycKV1PJX0pQuhUIsL3X4HV8Aid9gFY0VzO2WSeLSba3K9kFPyEo3UR5/AJKIx+nPPYl3Ow78bJvn72Rn1GR0P8LJurHdl+O5SwhDJ6kNHwqxhSwnO1Jd56NtV4FdROuISjeQNsW1f6WwtAJBJW7MdEYYeU+vNyxuNm3YU+zoLJSG6PJIiYiuJllOOkDCMu/pZy/jMrEBVQmLsD2luKkD8ZN74fl1Oc2rzER5YmvEVbux7K3xC/dTKbzHMrj5+O1/Tdu5hD84k2Ux79EuvMLzzszEKsDQ4Wgch+CBRhsbw8sexFe7r3z5jJKzS/6U7UeEcFJ74OT3ocoeAa/+BP84i8pj51NeexsLHs77NRe2N7u2O5uWM72NZ3im3AVQelWcn2/QsSiNHoWQfl3BKVbSXd8EgAn9TrKY+dgwpXIlAJEYnWR7vg0xeGTEWzE3hoTDiDOdnX7d1BqfZosNsJytiHVfgqp9lMIgycJSrcTlu/AL96Av27avhSWuyOWvR2WswTLXoTYW1T7EiR+4lQycUIRIAIsTDSE7b4UE61G7MUgnYSVP2NZCwhKN+Pl3k1Q+SNRtIYofBbL2QZjIqrPmAhB+XbSnWfjpvenUrgWv3gtYnVgN7Byutq8aLJIyHa2x27bHtr+G2MiouAxQv+vRP7DhMHfCf0HCEq/pJoMNs5JH0ym++uYaAS/cC22t5QoeBLEItVxKqH/N8bX/Cdu5nAsZ2ei4B+Q2gvwEUkRBc8AHlA9o7HdVxBW/oyJhmbzn0Bt5jRZ1EDEwnZ3/re/4sYEmGgAE67BRCMYM4qJCmCKGEKqj9IIlrMDIg7pzs9SyX+fSuFH2O7LMFE/lv0inPRbSLV/BJE0pdECk2PnRFLVV6sHRAhKN+N4ryYo/QpIYbuvaOi/g9q8aLKoIxEHsbeEhEPILWdb0p3V/omgfCeVwpVY7kvjp1LT+KVbMdEITvqN8Tp3EVbuJdV+Il7uvVQmvk1+4K3Y7s642aP12Q41qzRZNJGJCoT+/ZhogqC8HMd7LQCl0c/hl36JZW2B134yVjxVn2UvhlT1v8x2tifTdW7TYlebH00WTWTMGOXxryJWF7a7K272KEDw2k4k1X4qYsXT8cWDtSxnGyy22fhGlZolmiyayLK3JLfgmn9bLvaC539u4NT/Sr2QuTVlk1JqztJkoZRKRJOFUioRTRZKqUQ0WSilEtFkoZRKRJOFUioRTRZKqURmLVmIyDIReVREHo/LGCql5rFZSRZSnbzhQuBAYBfgnSKyy2zsSynVGLN1ZvFq4HFjzJPGmArwI6o1UJVS89RsPRuyFfDMlM/PAq+ZusLU8oVAWUQenKVYmm0BMLDJteYfPa75Z0bTqM1WstjQk0/PK1E4tXyhiKyYSSn4uaxVj02Pa/4RkRUzaT9blyHPwvOepd4aWDlL+1JKNcBsJYs/AzuKyHZSrdTzDqo1UJVS89SsXIYYYwIRORm4ieqsspcZYx7aSJOLZyOOOaJVj02Pa/6Z0bGJMWbTaymlNns6glMplYgmC6VUIk1PFvN5WLiIXCYi/VPHiIhIj4jcLCKPxa/dU753Znycj4rIAc2JetNEZBsRuU1EHhaRh0TklHh5KxxbWkTuFpEH4mP7TLx83h8bVEdPi8h9InJD/Ll+x2WMadoX1c7PJ4DtqZbYegDYpZkxTTP+1wOvAh6csuxc4Iz4/RnAF+P3u8THlwK2i4/bbvYxvMBxLQJeFb9vB/4ex98KxyZAW/zeBe4C9myFY4vj/ShwFXBDvX8em31mMa+HhRtj7gDWrxl4GHB5/P5y4PApy39kjCkbY/4BPE71+OccY8wqY8y98ftx4GGqo3Jb4diMMWYi/ujGX4YWODYR2Ro4GLh0yuK6HVezk8WGhoVv1aRY6mULY8wqqP7SAQvj5fPyWEVkCfBKqn+BW+LY4lP1+4F+4GZjTKsc21eB03h+wd26HVezk8Umh4W3kHl3rCLSBlwHfMQYM7axVTewbM4emzEmNMbsRnVk8atF5GUbWX1eHJuIvAXoN8bck7TJBpZt9LianSxacVj4GhFZBBC/9sfL59WxiohLNVFcaYz5Sby4JY5tkjFmBLgdWMb8P7bXAoeKyFNUL+ffKCI/oI7H1exk0YrDwn8OHBO/Pwa4fsryd4hISkS2A3YE7m5CfJsk1RJo3wEeNsZ8Zcq3WuHY+kSkK36fAfYDHmGeH5sx5kxjzNbGmCVUf49uNca8m3oe1xzovT2Iam/7E8Anmh3PNGP/IbAK8Klm6mOBXmA58Fj82jNl/U/Ex/kocGCz49/Icb2O6inpX4D746+DWuTYXgHcFx/bg8BZ8fJ5f2xT4t2Hf90Nqdtx6XBvpVQizb4MUUrNE5oslFKJaLJQSiWiyUIplYgmC6VUIposlFKJaLJQSiXy/wFKWATW5a2AmwAAAABJRU5ErkJggg==\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",
    "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": {},
   "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": "iVBORw0KGgoAAAANSUhEUgAAAioAAAHdCAYAAAAzT1KPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO29fbwdZXnv/b12gICAkoDBQIJgjSig4ksRsVoUBUTQ2haLpy88lYqPH1SotRb008ppD762tj1Pq+dJDzxi1WqOSA0BEkIUFUUwKGoQLaioCBIhQUHkJXtfzx9r1s6s2bPWvKyZNffM+n357E8y977mvuZea2d7O/Nd12XujhBCCCFEiMw0fQFCCCGEEMPQRkUIIYQQwaKNihBCCCGCRRsVIYQQQgSLNipCCCGECJZdmr4AgD33fIwv22+v+eNHZxcBsOui2dTjPDFlzgk9t9ak3NO4piZza03KXee8P/3pz+5x98cjRhLERmXZfnvx/ev3mT/+6NqXAvAnr7w69ThPTJlzQs+tNSn3NK6pydxak3LXOe+fvuHDP0JkkvvRj5ktMrNvmNm66HipmW00s1ujP5fEYs8zs9vM7HtmdkIdFy6EEEKI7lPEUTkbuCV2fC6wyd1XAZuiY8zsMOA04HDgROBDZraomssVQgghxDRheSrTmtkK4GLgAuCt7n6ymX0PONbd7zKz5cA17n6omZ0H4O7vic7dAJzv7tcNm3/FiuX+P/7m1fPHP7u3d3PmCftuTz3OE1PmnNBza03KPY1rajK31qTcdc573jvefaO7Pxcxkrx3VP4JeDswFxvb393vAoj+XBaNHwj8JBZ3RzQ2gJmdaWabzWyzzyW/K4QQQgiRQ6Y1s5OBre5+o5kdm2NOSxlbcNvG3VcDqwEOeeIyD0lwCjW31qTc07imJnNrTcpd97wim8yNCvAC4JVmdhKwO/BYM/sYcLeZLY89+tkaxd8BrIydvwK4s8qLFkIIIcR0kMtRmQ/u3VF5W+SofAC4193fa2bnAkvd/e1mdjjwCeAo4AB6ou0qd58dNq8cFa2pS2tqMncX19Rkbq1JueWoNE+eOyrDeC+wxszOAH4MnArg7jeb2RrgO8AO4KxRmxSRjSeenCWPJxnTtnmbzi2EEGI8Ct1RqYtDnrjMVfAtPcZx/viVGwH497UvA5g/ThurK6Zt8zad+2Nrjwfa97xcubUm5Z7cvH/6hg/rjkoO1OtHCCGEEMGijYoQQgghgiWIRz9tlWn333cbAHffu3TkcVUxdc07KmZZdLw1cZw2ViZm3Hnb9nqGNG9IUmGoubUm5ZZM2zy6oyKEEEKIYBnnUz+Vseui2aAEp6yYi9ceB3RbPP1odPyHp2wA4OOXnTBwnDZWJqbsvJ+IxtryeoY2r2Gt+jfXRlEy1NxdXFOTucedV2SjOypCCCGECBY5KmPEhOwfyFEJ8/UMad6QntWHmltrUm45Ks0TxKOfEGmymFcyU9ZxnTGhU8W663w9Q2aSBfSEEKIsQWxUQnJUsvyTtLGq/IMsL6QuTyRPTNvmbTp3lkPTtKMyqdxZhe/SxrrkH4SYu4trajK3HJX6kaMihBBCiGCRozIkpkn/oC6fo0mXZJrWFB8L2VGZZO6QPYEm5tWaupNbjkr9BPHoZ9JM6pl6F70GUYy6/Ji2UVcjSCFE9wliozIpR6UK/yRPzL+vfRlOs07Fa09ZPx/zH5edODCWPM4TU+acJuctkrtNfkxT7kuemEnmbrv70mTuLq6pydxyVOpHjooQQgghgkUbFSGEEEIES+dl2jqlwi6Jp3dHr1eb12RYMK9nG+TkaRF5xyl0J/lTuSXTNo/uqAghhBAiWDot0zpei9hXd2G2JsTTvqR52ilXAvDJy14+8riqmCrnNSw4kTfUAnpGu2XaSTVjlPyp3JJpm0d3VIQQQggRLHJUxogJ2T+QoyJHJescOSpyKrqypiZzy1GpnyAe/bSB5rdzPTz6L3486s+8MV2g6GuT97UyrOYrb4ZpKTaXpGyxOSFEMwSxUQndUSlavK2Mf5I2lnbseOWeSJ6YUeecevIVAPyfdScNHKeNDTsObU3juC95YoqcM+2NFvPE1DlvUa+lqpi2zTutueWo1I8cFSGEEEIEizYqQgghhAiWzsm0dYuyaWNtF1rrXNM0Cq0AP79330Zyh/p6hiTTTnLersmfyi2Ztgl0R0UIIYQQwdIpmTYuz9ZVzC1trApRFqotulZEaM0TU+acJucdFVO3pAvwqct6uSZVbG4SMm0ZkTdLwE0bC02mLTNvFd2dQ5U/lVsy7aTRHRUhhBBCBIsclSExclTaPW/TueWoDJ4TuksiR0W5m5hXjko+gnj00zST2KqFUHQtTzGvrJiyRcKamrcpyhSb6zKhvk91o0JyQoxPEBuVJh2VosXc4mNF/IMs/yRtrCr/ZE009vsnXw7Ap9e9YuA4bSzruKqYuuYFuCQaq8uPqbrYXJbXkjY2qUJyeWLqKiSXNha6o1KFxxKqU6HcclQmjRwVIYQQQgSLNipCCCGECJbWy7RlJLhJSIWOT1RWfHw09vPEcdpY/3i/fe+dj7knkj/7Y1nHVcWMO2+Zdec5J1TptSlJt841VSHlhirTVpE7JPlTuSXTNoHuqAghhBAiWFor01689jigmARXRTE3qL/LcRH5s6wo6zi/G4v5TBTTH8s6riqm7LyXrju51LqzzskScNPGygi3bSskB9PZubnpjtB1dG7uotDaZG7JtPWjOypCCCGECBY5KtTzrF6OymTmlaMiRyXtuKoYOSrKLUeleYJ49NN26i7iVaZYVto1dLHYVJ6CWmWKboVaoCxPATnDmrm4CRDq+1In0/JvWYhhBLFRCdFRKfI8v0gxt6Lug1O/fxIf+52T1wHwn5EDMuy4qphx5x3XjzGs8kJyaWNZDRKhGo/lk5e9HMMqc1Ta1BDR6J6jkuecoh5LFz2RJnPLUakfOSpCCCGECBY5Koz/TD2rmWDZeSfln+SJCdVRqSJ3Ea8lPhaiz7H13qUY1llHJSt3Fx2VPOeE4GpMa245KvUTxKOfOqljG1Z3Q7msWWt5Zh2dPr9vzTquKibvOTVqF2Vfz1B9CY/+m0amc9VyVkS3CWKjUpejUkfDQch2UupqHljEPynqfFx6WW/slSdfBsDadaeMPK4qJu85ZtX5MUW9ljo8liJeSwjNDvPE1NXsME9M25od1pm7qWaHeWK6mFuOSv3IURFCCCFEsGijIoQQQohgyZRpzWx34IvAYnqPij7t7u8ys/OB1wM/j0Lf4e5XROecB5wBzAJvcfcNCyaOUadMW4W0V7R427iF2cYWTx32jcXcG8X0x5LHeWLKnNPkvAD3bgu/2FwoQmtWIbk6c4cg8rZdpi0i3HZRaG0yt2Ta+snjqDwMvMTdHzCzXYFrzaz/APwf3f3v48FmdhhwGnA4cABwtZk9xd1nq7xwIYQQQnSfzI2K9265PBAd7hp9jboN8yrgk+7+MPBDM7sNOAq4btgJTcu0WcJg3gaD4zYP7J+X1cAvSxh1Ly+9nhyNrcs4riqmyDlF13TZ5acseG1GHcfHJtEQ0WhPs8O0sSICbhMybcjNDvPEVDlvvChcF4XWJnNLpq2fXI6KmS0ys5uArcBGd78++tabzOxbZnaRmS2Jxg4EfhI7/Y5oLDnnmWa22cw2P7JDH60TQgghxEIKFXwzs32AS4E303NT7qF3d+XvgOXu/joz+1fgOnf/WHTOhcAV7n7JsHnlqDAwJkdFjkracZ4YOSpyVOSoyFHpGoU+9ePu9wHXACe6+93uPuvuc8C/0Xu8A707KCtjp60A7qzgWjuJx/4rOQF4rziaR38vcFrhr7nYV3KsSEzRr1KkvTYlXqvh0w++b2Xey7HXWBGe8t80EcJ7UDfT+L6KbpDpqJjZ44FH3f0+M9sDeCnwPjNb7u53RWGvBrZEf18LfMLMPkhPpl0F3DAqx7Q6KkWLtxUp1JblfDhw0slr52OuWPdKiI2lHTtw4it2nrP+8l5Mfyx5PCzGRuQZlttyrGnYukcVm8tbSK5ok8csj6XqZofjOipVNDcct5BcE45KVnPDrjgqyeOijQyripGjIkelDHk+9bMcuNjMFtG7A7PG3deZ2b+b2ZH0/o/I7cAbANz9ZjNbA3wH2AGcpU/8CCGEEKIMeT718y3gWSnjfzzinAuAC8a7NCGEEEJMO53rnjyuXFdFJ+SkOAvZomzaWFKMzSuVeo4YgKWxmG2JsazjqmKKnJO1Jsu57nEE3LSxIjFlBNxQhNYs4bbNMu2kuzLniWli3pDF01BzS6atH5XQF0IIIUSwdKp7clyeraszcnxsVGdcp1gxt/jYsOJteQu15RFl84qxx0fHVyWO08bKxFxVQsAdtqa8wu04ReLSxvIIt2WLxBUtClemSFzaWJmicFV3ZW5Kpk0ex+Va6IZMmzwnq+Ny2lhIQmuTuSXT1o/uqAghhBAiWOSoIEcF5KjMnyNHZWiMHJUeIbgkclTCyS1HpX6CePSTl9CLFY19ddEE83vHHBMmQ0edmuf6kjHJ47mUc5JjeWKy8qSRtaZk0a6018RyJvFCJ+WnzM9wKD/1/WuP/2lVvjgBU/bfU9sI/XesmE6C2KjkcVQcz3wO25SjMk7DwTzF20YVc7ssGhvHPwHYEI299BW9ua+OXI34sQPHnbQz96YrejH9seTxsBgbkQdgUzSWx30Zx2PJWyQub1G4Is0NP7PuFRhWqJEhZBeFK1MkDsoVhauikWHRmCYclTzn1OGxNO2+1FEUTo6KHJUyyFERQgghRLBooyKEEEKIYGmVTJtHGKu7M/KomKQEWVjAvCdb/hwmyuaRU5dEY9uj431iMfclxtKOveA5w2KsxDnx64+vYRwpt4yAOzTGir3fVXdlDkVoNayTMm2ec7og09Yt3EqmlUxbBt1REUIIIUSwTL1MW7QzMiyUE4t0Rh6nE3JaMbfL15UTZYeJscee1Luea644ecGxAy86aeeavnhFb039seTxsBhLyVNEwIXhwm3Rzs1Fi8RBNV2Yy3RcThtLFoUrItNWXRSuTMflcWMk005u3iqKwkmmlUxbBt1REUIIIUSwyFEZw1EZ5hLkdlS8WPG2IoXa0nyOPL7J46I1/CJaw7Dj+Nhjo7FfJo7jY1nzJq8lr8eS9G7KFJvbN+WcJh2VYUXiYPjP2jhF4qqKKVMkrs7cIcwrR0WOyqgYOSr50B0VERzTUUJMCCFEHuSolHBUsgq85XVU4g0HIdtJGVXMLe5qOIM+x8bLFzofSd/kC5Er8sKX98a+dGXveo95eW/dX7nypIFjgC9HY0e/vPd6fvXKEweOAa6PxpLzxPMYPnAtX4q8llEey+euWFiQzsguCpc8ThaJuzJyfuoqCpenKeU4ReHKNDKMj43rqCTPmVRRuDKNDPPElHVf+oUj5ajIUcmKEdnojooQQgghgkWOihyV+TEIw1H5RYH6LHJU5KiEPK8cFTkqo2LkqOQjiEc/XWFkQ68cDQeLNBgcdm7a8fB5F9ogO8/rfW/Obf7YgVm3WOxgTPJ42DwLj33gWvrXMIcNHOdpDFdm2z12I8MosK49vxoZtpdQ3ocqUeNCMWmC2KjU6ahkPece5qiMep6fdFTGaThYpMFgkRopfb8D4POR4xGvZeLYSN/kuit6r8NzX957PTdfeQIOPPvEne/B19f33oP+WPIY4BvRWHwegOdFea6/8kRmzAeupYjHMk6tlaSzAjtfzzy1VoY1jwS4LMo9rG5O0lmBdEclGZNVa6VMI8O0sTKNC/N6LXXUWinTyDBtrM5mh0VrrYTmqFTRuFCOSvccFTO7CDgZ2OruR0RjS4FPAQcDtwOvcfft0ffOA84AZoG3uPuGlGkHkKMihBBCiLJ8BDgxMXYusMndVwGbomPM7DDgNODw6JwPmdmirATaqAghhBCiFO7+RWBbYvhVwMXR3y8Gfic2/kl3f9jdfwjcBhyVlUMybU6ZNo/QOE7Dwfh5w+TZakVZY++lMel1W28N/bH7o+O9lvbegwe29d6Dxyy9b/6cB7ftMzCWPI6P7RmN/So6js9rsby93L1cSUk3TeQd1uwwvu5hwu2oRoaj3qdSwu228jJtkcaFoxoZhiKe1tG4sOk1jRPTNpl2HOFWMm2zMu0JL97T7902W+icG7/18M3AQ7Gh1e6+Oh5jZgcD62KPfu5z931i39/u7kvM7F+Ar7r7x6LxC4Er3f3To64hCEdFCCGEEPVyz7ZZrt+wotA5uy7//kMVbqbSTPrMuyVBbFRCl2md0Y3hJinTjlPMLV50bc5tXmiFncXa+iLsjet7xZ2eceImAL61/jjmMA4/4fPz59y84cUAPPWELwDw3Q2/DTAQ850o5ogTPgfAlg0vwXCedWLvvf3G+pcyg8/LtvHc8UJyxk65FuDaSLhNNjssUhQurZFhmkwbP4bhReFGNS7MkmvjYyHJtEWKwkmmrbYoXBtk2mRMVlE4ybRNy7TOrM9NItHdZrbc3e8ys+XA1mj8DmBlLG4FcGfWZHJUhBBCiCnAgTm80FdJ1gKnR38/HfhsbPw0M1tsZocAq4AbsiaToyJHBZCj0keOihyVScwbH5OjEr5LUte8k3ZUnv3Mxf6l9U8odM5eB/x45DWa2X8AxwL7AXcD7wL+E1gDHAT8GDjV3bdF8e8EXgfsAM5x9ytTph0giEc/bWXcwkdOviJmo76fr5hbevG2uZTHhbPRTbb+PDsGjo0dvvOTZP0c/bHkcXxs1mfmjw0fyL3wWqJCbwuKwi0krWjdwpjRx3nOCY22F4FT0TAhuoG7v3bIt44bEn8BcEGRHEFsVNrmqAxzUoo6KvGGgwCXr0svSBZ3KuYY9DCujjyMUcXcro2Ko8WLrM1h854IwI1RYba+X/LtDS8BYNXx1wJw61W/xZzP8MSXXTd/zo82Ph+AFS+7HoA7Nj4PYCDmJxuPBuBJ0Tw/uOq3mLG5Aa9lBp93YQC2rO/ljheJM/PUZofxonAz+EChu2Qzw2RRuLyNDKtoXFiVo5LVuDDNUZlU48IyjQyhmsaFRc6RoyJHJaR5J4njzAbwFKUoQWxUhBBCCFE/Y3gnjaGNihBCCDEFODDbwo3KVMm0d0fzlJHg0uTEkZ1xC3ZGjscMk2eT4mx8LNmNON7BuN+NOCnKxqXXX0UC6+5LfgHAr7c/DoDdltwPwCPb98YxFu3zq/lzZu/bEwDb50EA/L7HAAzEzEVjuy55AIBHt++FxfI8tP1xGJ4q4OYRbst0YS7TcbmSDsvJ44Idl0fF5JFp6+6wXKV4WlS4bbNMm4zpgkybjJFMG4ZMe+Qzd/ONVz6+0DnLDryz8Q7PuqMihBBCTAEOclTKMimZti+v5ZH/ysi0cVHSPb0AWFzAzCPTxgu8pXVG7hc1i0ulDgPi6VeiTsjxLsezzAwUZvvW+p6gffDxXwHg+1f9FgDLjrsRgK2bnsMOX8SeL94yf879n386ALseewsAj17zNGbwgZiHrjkMgMdH8/x803PYhdn5PLdfdQyLYnItwH9teBHAgqJw8QJ1X1vfey/jReyGdVjuv17XXHFyYzJtsgDc2nWnYJYu0xbtsDxpmXZYh+WyMm0VReHKCLjxsSZk2uRYllybNhaaTJvVYVkybdMF32Ai5d4qJoiNihBCCCHqxXE5KmWRozIYI0dFjkra8agYOSrhrylvjByV8FySuuadtKPyjGfs6muv2K/QOYes/JkclXFpfpsVIhYrlraTeHG0ZJG1/uu4s+Bb73uP+C7zx3NuPDK36/w5i6Iibg/vWAzAYp/B8IGY3aLreGQuKgLnBubsoF8krne9c76wm0PyevMUx5tEAbi0InvZWeulzQXgxCB6X0Rd9H7vt48gNiplHJWPRs9Cs54tt9FRiRd4y+uoJBsOxpv83RAVR4s3GNzBzHwxN4BbooaCfSfljqt7xdvi/smOuV3YfsxP58/Z+9qDAPjxUfcAcNAN+7HLzOxAzP7X7Q/ALsd+D4Ad1xzKrjOzA87KrszOF4QD+NHGY4DBRoYzzM07NgA3bej9jIxqXPjlqHFh3FGB4QXgADZFhdmSRfeyGhcazTkqyeO4swL1Ny6Uo1JPzMcvOwFDjkpVMaHOO1mM2cb/b1VxgtioCCGEEKJeHJhr4S271jsqRZ4tT4+jkt5wMO58OLDH0l/Mx/S9kL6T8vD2xwKD/smcGzse9/D8OYt+sXsvdu9HAVh8/64YPhCz2y926/0lmof7HoOZL3BW9liy81oeinInGxnG1/RAjsaF/bGkozLMWYHyjQuNZh2VYc4KTK5xoRyVenLLUWneJalr3kk7Kkc8Yzdfc3mxOiqHH6Q6KlNPGT8iT9PCtJhk47+4F5JsKNhvYLhjrvcjsosbsz7DA48unj9nz9ne+b94cA8Als7OMTPjAzH7RH/uiFyXXTBmGN2kML6OwePsxoVp54fkkoh8qHGhENXTq0zbvt+CQWxUptVRmWPQfchqQrjpip6jEq8V8oXIu4g7KrNuAz5Hv+ZIv27KzRtezA5fNNA88NarXggwXwPlnk3PApj3TZZ85UAeeHQxm4/Yebfk6TfuBcCVy3obk5dvfZjFix8diInUlIF59ph5dD7Prz5/BLvZjvnGhgA/u7q3eU82Low3UfxmVPcl3mhxxnzAUbk2clTiDRuNfI5K/D2A8o5KstZKGUelSOPCJhyVYc4KTK5x4biOyrDGhXJU5Kh0y1HZ+X9C20QQGxUhhBBC1IvuqAghhBAiWBybL0HRJiTT0qxMm6fYWFz+dAZl2r4QGpdKPSHTJgu8PbhtHxxj8ZJfzsf0C7zF5dlZnxkQZXfMzrBtt50/5I//Re97v/rZQwDs+YTdmd1j0UDMstkdADwUzbP7/buyyOYG8hg+cC2PbN87ut5fRNf7OIydMjDsLFA3WMTOB2TaZBG4+yLpNRiZNnnONsm0w2J+Hq1LMm07Zdphci20Q3qta95Jy7RPe8Zi/8hlBxQ65+iDb29cpm3f1kpMhNmUAmxCCCHEpMl89GNmuwNfBBZH8Z9293eZ2VLgU8DBwO3Aa9x9e3TOecAZwCzwFnffkDL1PE3LtFnCYMgybb+IWbzw2dwQmTYup+7wRQMC621RE8J+gbdfXX0kMFjM7RcP7jEvzgL83vd6H2X+9sU/BODppx/Cg4fuPRDzBw/8GoAf/Wbv/1E98WtL2WuXhwcKyS22RzngpTfMn7N1U2/z/pTjvwjAf131IhYxl0um7UvFANdd2Xt/Q5Vp48cAl0W5JdNKpu0fd0GmTR7H5Vpoj/TaBZm2rY5Knv/b/DDwEnd/JnAkcKKZHQ2cC2xy91XApugYMzsMOA04HDgR+JCZLarj4oUQQgiRl16ZiSJfIVDIUTGzxwDXAm8EPgoc6+53mdly4Bp3PzS6m4K7vyc6ZwNwvrtfN2xeOSo9QnJUdmzvffRYjooclT5yVKpdkxyVHm1wSeqad9KOyqHP2N1Xrz2o0DnHHnJr445Krk/9RHdEbgSeDPyru19vZvu7+10A0WZlWRR+IPDV2Ol3RGPJOc8EzgQ4YPkTyq9AVMrMfJvA3p+7zMxGx7swM+MsXvzofOzsHr0bZQ8e2ttY7P7I3IIYiwrS7hqbJ55nll4RtoWl3HZeQ/tuVDZP2WJpzav1IoneE1ElbXz0k2uj4u6zwJFmtg9wqZkdMSI87VVY8G/N3VcDqwEOeeIyl6NSv6MyDQXf5KgMHgNcGp0zylFJ81iM6XVUhjkrMFlHJXlO/3eYHBU5KmXwqMJ42yhUR8Xd7zOza+i5J3eb2fLYo5+tUdgdwMrYaSuAO6u4WCGEEEKUJ61dSehkbq3M7PHRnRTMbA/gpcB3gbXA6VHY6cBno7+vBU4zs8VmdgiwCrgBIYQQQjRG71M/M4W+QiBTpjWzZwAXA4vobWzWuPvfmtm+wBrgIODHwKnuvi06553A64AdwDnufmXq5BGSaXuMI9Pm6Z4c70bs2EDH4gcjmbbf1fiRbT3vJN71eI707slxUbZs9+TdY9fS79wcl3+hePfkaZZp087JI9MmY0IVT7Pk2qpyhyDTpp0jmVYybRlWPf0x/sHPPrnQOa/8jW+HL9O6+7eAZ6WM3wscN+ScC4ALxr46IYQQQlSCA3OB3CUpQhC9flTwrUdV3ZPn3Hjuy3cKeNdHUukRJ3wOgC0bXsKsz/Ck46+dj/neVb8NwOOPuxGAn248CoBdIht2xzWHssN3mZdiAfa6tvcxt3gxt11nZgdi9r9u/wXz7DozO5/n55uewy7McvDxX5k/5ycbjwYG5d9FzA0Iwjdt6P2MxCVig1Z1T44fQ3dk2rRzxpVpk2NZcm3amGRaybQhzjtpZtU9WQghhBAhoqaEYyBHpYcclR5yVOSoZMXIUZGjUjQmxHkn7aj8xtP39Hdfelihc05btTl8R0XUS56bcMliaGVv3FmsnI3hzNjcghy70CvM9qj1YvuF2h41ZwbYYyZW8M16m5C9dultTDzqlBCPmbNdF8xjwCJ6uXt1a50ZW7hhnhm43uLrtiF/CiGapWxBQjEe/U/9tI0gNirT6qg4Oz0HgMvXLXRUnJ0OxdWX98459qSdzsLnrujN23czvnTlK5hzmy+EBjsLn/ULpn1j/UuZw+YLqgHcvP7FAPOuyG1RAbi4SzLrM/OF2gDu//zTAQYaDM7gAzEPXXPYgnkWMTdfbO5HG5/PIpubb0AI8P2oQeIzTtwEwLfWH8cMPuDd3Lj+eGC0o/LlyFHpv1794nhyVOSo5I2Ro1J/Q8SPre39Ww7dJemCo+KYHBUhhBBChIs+9SOEEEKIIHGnlSX0JdPSrEybFpMUOfuy5/aEXJs2lpRrAX4RjcU7DTuD3Yj7cupj5oXb3nFfuO13V453OX4okl77Yw9vfyyWiOmLsX1Z9qHtjwN8QWfkvujbyz0oz96/bSkGiY7QSwbWmRRn4+tOvjbJ4zxCs2TasMTTaZdpx+mwHIJMm3ZOyNJrXfNOWqY9+Ii9/G8+c2Shc8449MuSaYUQQggxCayVvX6C2Kg0LdOmSXtNyrR9cXP9EJm2L4MCXB3JtPGiZo4NdBG+9ore9fVl1KeCbTkAACAASURBVM1XnsAcNi+rAty0vvea9wXb70Rybb8o3A+u+i3msIEuxz/Z+DwADnhpr5XTnVcfhcFATL9wXF/Svf2qY5gxn5dn/+uqFzGDzxejA/jOhmMB5gu8fX39yzAYEIT7HaHjhe4MHyiG96Vo3aNk2hl2irOwU56VTCuZNn4cikybFmNIps0TE+q8k8Rp56OfIDYqQgghhKifNn48eaocla33LsXx1jkqwwrAQbp34aQXPhssjmYJ52PQW+k7K/EicbDTYYFeITaHBb5JMiZ+Xv84mSd5LXEn5f5tSwFPXVPcUYkXcxv22sBC5ycYR+XefcHkqOSNMSwoT0SOihyVovNO2lE56IjH+ts/XSzdm5/2eTkqk0RFhoZT5pWp69Vs3xPUipjahRfH9GIJUYo23lEJYqMiR6VHmqMCw5sUQs+zgEEPYw4bKHz2xSt71xcvjuaJxoU3XNl7Ft8vCvf19b3XN97I0GGgSNwtkUsS900MH4j57oZes8N4g8EZfKCYm+EDDQe/EeXuOynXX3kiM+YD3s1XomJu8UJ3M/hAMbysAm9XX947TnNUku+BHJXpdlTSzpGjIkelinkniQNzclSEEEIIESbGbAvvRk6Vo9LWOiqTcFT6jQuLOCo7x6p1VB6IrmXqHBXVUckdozoqclSKxoQ476QdlRVHPM7fsuaYQuf81eHr5ah0FgPL2LgOa7SXtd/N18hw4QZ08DzHYo0A+9+bSZw3w1zieOE5/QaDw+aIx/Tj+jHpDQN739vZqHD4ZjptnXXQvv8PIoQQC2njHZUgNipddFTixwCXXtYbSzoKca/hsmgs7j44w5sUAmyMvIa4h+EwUE/kC5GrEfc5nJ3OCsB1V/TW/byYxwKDtUwcm3dYoNfcEAabHcaPAW5af9yCeYzBmi7xvJBeIyV+/QDXRmPx+jEGtTgqxqBLdMU6OSp5juNjclTkqAw7R47K5HC3Vjoq7btiIYQQQpRi1mcKfeXBzM42sy1mdrOZnRONHWlmXzWzm8xss5kdVfaatVERQgghpgAH5qIy+nm/sjCzI4DXA0cBzwRONrNVwPuB/+7uRwJ/Ex2XovUybVLSmqRMmxQPRwqN92TLlPcMES7ziJ3jNy5cKKdCdpE4SEqv6c0DB+dZeJznWoo0HIyPDZNnR72eyZh9M2TaZEwumdaKibJ5YiTTSqZtq0ybjAlJeq1r3knLtAccvsTP+OSxhc75H8/4z5HXaGanAie4+59Fx38NPAwcB1zk7p8ys9cCp7j7fytz3UE4KkIIIYSol14dlcIy7X5mtjl2vNrdV8eOtwAXmNm+wK+Bk4DNwDnABjP7e3pPb4p93ChGEBuVMjJtmqTlTEamTYqHWXItjCfTDisABzuLj5VpXBiXU78UFYXrC6xfjmTVZJG4uPR6fSTcxguzxY8BbojE2KMTkm782GJ5Ib2YW9GGgwCfi9Y9TJ5NaziYLPCWJtNeGcm0SVE2TaYdJs+uXXcKZumirGRaybRFzmm7TJsWY1hw0msXZFooVZn2nlF3VNz9FjN7H7AReAD4JrADeCPw5+5+iZm9BrgQKLVoOSpCCCHEFOAYc17sK9e87he6+7Pd/UXANuBW4HTgM1HI/6HnsJRCjgpyVECOSh85KnJUmlqTHBU5KnXzhMOX+p984rhC53zgyE9nXqOZLXP3rWZ2EHAV8HzgK8Ab3f0aMzsOeL+7P6fMdQfx6GdS9BuZxf8MqVFhsviZ0XummK/A2/DjtHkhvTBbsoBashDbjPnAMSwszDYYk319ybzJ60svCpdOmQJ6eecRQoi2M1fPg5RLIkflUeAsd99uZq8H/tnMdgEeAs4sO3kQG5VJOSppz58dD8ZRSSsSFm9cmHRWIL1xYZ6icDBYHO3zkePR90DSisTFj+NjycJsWb5J8jivf1KkmBvApmjdSSdllKOS1nAwfgxyVOSoyFEpGyNHpemCbzBbXKbNMa+/MGXsWqDUHZQkQWxUhBBCCFE/JT710zjaqAghhBBTQE+mbd9naKZKpk0T0RwvLcEVkmkr6LCclGuhWLffUcLtsE7Dya7MRc4ZFmMlzhkWM04n5DRRNu09KNoZOU9M3TJtHlFWMm1Ya6p6Xsm0kmmTLDtsX//9j7280Dkffs7H1T1ZCCGEEPVTsuBb4wSxUQldpo0fA6yJxorItGmipPtg99ykYFtEph23KFxSsE0KrNdccfKCrsxfjKTXeCE5csTEuxznFWXjx5BdzA2y5dm6OiNDujybPM4r08bF2Cx59jPrXoFhmaJs/HhYjGTadsi0yZh+YUvJtJJpF9LORz9BbFSEEEIIUT95Gg2GhhwVOSqAHJU+clTkqDS1JjkqclTqZr+n7eenfPSUQud85KiPyFERozHKFYAbNteo42FjadcSjx32Z9b3shj3eoMiulAr80IIIURF6NFPSUJ0VJLPy8s4KmluQR5HZVhRuKSzAnD5unRHpWhRuKsvH3Q+hhWJS/NaxonJ65/EjyG7mFt8bNhrM0lH5bLoevMUc5OjIkdlnHnlqMhRGUa/10/bCGKjIoQQQoj6aaOjoo2KEEIIMQW09ePJkmkrlGmHybWQU5TM6LBcpuMyFBNukzFJWXVJ7JzkWJmYMhJs0Zgir2cVnZFTY7aNL8rmiRlXpm2LeCqZVjJt0RjJtLD0aY/3l130e4XOWXPM/yuZVgghhBATwOWolKZOmTZNRKtapk0TER3PlGnjx5DdYTmtS+9l0di4ReGSMmpakbj4cdpYmZgihdqKiLLxNQzrhFxXZ+S0sSIybR4pu2qZ9pJoLI8YK5lWMm3ZGMm0Tcu07XRU2vc5JSGEEEJMDXJUxnBUkjFjOyoZReHy+hKeIwbKFUer2iWpet6iRdfqKOYG2U5K1Y5KmWJuclTCWpMcFTkqdbPkqcv82AtPLXTOf/7Wh+SoCCGEEKJ+2vqpnyA2Km1zVJLP4tOclWGOyjiNC5POCqQXH0sWhUtzM/J6LEW8llEuybCYsv5J2eJtyeM6Gg5CtpNSpaMSd1LyFnNLxshRkaMyiRg5Kk03JdRGRQghhBCB0tbKtJmOipmtBD4KPAGYA1a7+z+b2fnA64GfR6HvcPcronPOA84AZoG3uPuGBRPHkKMyIkaOihwVOSpyVErMK0dFjkqSxz11fz9m9WmFzln/2/+zFY7KDuAv3P3rZrY3cKOZ9e/b/aO7/3082MwOA04DDgcOAK42s6e4+2yVF14VFv1X19wVTDLYyC6H+5xsHjgqLs9YKJRpopjnz0qIv09CCBEi3tFHP+5+F3BX9Pf7zewW4MARp7wK+KS7Pwz80MxuA44Crht2QpOOSvwYdj7fHddRiR/HzynauDB5PKyRYdFaK/HjtLEizQ7HianLP4HsmihV1UhZu+4UzPI1GByn4eCwmNAclXH9EzkqclTkqNRDW2XaQnVUzOxg4FnA9dHQm8zsW2Z2kZkticYOBH4SO+0ORm9shBBCCDEB5qLqtHm/QiD3RsXM9gIuAc5x918CHwZ+AziS3h2Xf+iHppy+4IGFmZ1pZpvNbPMjO5qv5SKEEEJ0mb5M27aNSq6Cb2a2K7AO2ODuH0z5/sHAOnc/IhJpcff3RN/bAJzv7kMf/TQp0yZj7o5yVSHB5REaCzec85rkz8TYsGaHVecuO28VzQPrEmXTxqqWabMaYub52QtN/pRMK5k2fhyS9FrXvJOWafc+9An+nA/9UaFzvvDSf2hcps28o2JmBlwI3BLfpJjZ8ljYq4Et0d/XAqeZ2WIzOwRYBdxQ3SULIYQQogxzWKGvEMjzqZ8XAH8MfNvMborG3gG81syOpPdY53bgDQDufrOZrQG+Q+8TQ2dlfeKnDTJtmtg3Sip0soXGoo0LR8m0eeTPPBJpf6yMgFsmpuy8RZoHZsm0VRdzSxurSqa9NDpvVEPM+PGwGKOYKJsnRjKtZFrJtMXnnSTe4U/9XEu6d3JFylj/nAuAC8a4LiGEEEJUjLdwozL1TQmTMXJU5KhkxshRqeycsjFyVOSoFI2RowJ7PWW5P/1fTi90zldPeF/jjopK6LeNZGGx6O9Fi8LlSDPyz6piys47UVTMTQjREdp4RyWIjYoclR5ZjQvzuhB5PZYyPkeRc5qcNz42zDepq5jbqJiixdySMXJU5KhkxchRkaMyjKko+CaEEEIIMUmCuKMihBBCiJrx3id/2karZNo0WSlL2qpCcCvaYXnUvHmkx8oFzHsaFE8bmrd07gpE2TwxZTojQ7Y8W1dn5DwxdYqnWfJsG9dUZe66hFbJtN2Safdctdyf+j9fV+icr5802WtMQ3dUhBBCiCnAkUxbmjwybfwY4OK1xwGjpa24XAvDRbQsuc7xXPLfKBGxig7LSbkW8omdl17WGysqkaYdhybTVrGmqou5xcey3ssinZEhW56tqzPyqJiqRdm0mCx5dpplWqMeobWOGMm0zcq0EE7/niIEsVERQgghRP0EYHsURo5Kjhg5KnJU5KjIUal6TXJURp8TkktS17yTdlQes+oAf/IH/6zQOd9+5d/JURELsapLm6UVhWNKi5hZ+K9D5e+/EELQu5siR6UkclRIHUsWhStSJKxqj6WMA5Inpq55h8XEi7eN65+M02CwTDG3tDE5KpNxVKr2T/LEyFEJyyXphqPSzoJvQWxUhBBCCFE/AdgehZGjkiNm0o7KsMaFdfkSkO2xdMZRsQm9nmM4KmV+RuSotG9NclRGnxOSS1LXvJN2VPZ48gF+8AfeUOic7/7u+XJUpo0yN90m4ixkeSyh+Rx5rm9ITEjU9d4GuFQhRMM4JkelLF1xVIY5K1C+cWHyOG8jw7SYcdyMuuuzFPVPqqh3Upd/kiemTI2UPDF1NRyMj2X93MtRkaMiRyVcR6X5ZyjFCWKjIoQQQoiaaemnftQ9WQghhJgWvOBXDszsbDPbYmY3m9k5sfE3m9n3ovH3l71kybQlYu6Octcl4JURJUMqUBbCvKHmHkeUHRXTNvkzK8awIKTXtryekmkl0+Zh99840Fe+942FzrntNX898hrN7Ajgk8BRwCPAeuCNwArgncAr3P1hM1vm7lvLXLce/QghhBBTQg33Jp4GfNXdHwQwsy8ArwaeC7zX3R/u5S23SYFANiqhy7TJmE9E540r0yZjsorClWlkmDZWRritujha3fMWyV21KJs2VkUxt2ExcXm26mJuTcm0hlXWPFAyrWTasudMYt5JUrJ78n5mtjl2vNrdV8eOtwAXmNm+wK+Bk4DNwFOAF5rZBcBDwNvc/WtlrjuIjYoQQgghguSeUY9+3P0WM3sfsBF4APgmsIPe/mIJcDTwm8AaM3uSl/BN5KiUiJGjEv68oeaWoyJHpY7cclTkqORh8ZMO9BXvPqvQOT947TsLXaOZvRu4A3glvUc/10Tj3weOdvefF7oAdEclSIItCicKo4JuQoiQqOPeRF+UNbODgN8Fng/MAS8BrjGzpwC7AfeUmT+IjUrTjkpaTBWOStpz+KKeQLwoXJlGhlBdgTJop6NSpDFgVTFZTkpZRyWrwWBdDQchf6HDLjgqdfsneWLkqITlknTBUQHqqvh2SeSoPAqc5e7bzewi4CIz20Lv00Cnl3nsA4FsVIQQQghRN/WU0Hf3F6aMPQL8URXza6MihBBCTAvNa6mF6bxMmyZtVS3BZcm1ZecddlyVgBmCeNpmmbauLsfDRFnojvxZpDNyk+tuy+spmVYybR4WH7LCl//tmwqd86M/OU/dk4UQQggxIZq/N1GYIDYqdcm08ePePL2xcWXa5FiWXJs2VqYoXJmOy8Niigq3dYmndQqtdeWuonhbmWJukO9nhILnjIqZhEyb1Rk5bUwyrWTa+HGeGMm0fdr3mcEgNipCCCGEmAAtvKMiR4Xxny3LUZGjEj9OG5OjIkelztxyVOSo5GHxISt8+bveXOicH/3puXJURHGqunGXVoxMheN6JF+HSb4uegdEFvoZEaVwoIaPJ9dNEBuVEB2VIo0Lx3FUihSFK9PIMG0sT0zVzQ7b4qjU2Tww65ysYm5pY5NqOJg2Jkdl8o5K/3fNJDyROmLkqDTvqATwEKUwQWxUhBBCCDEBtFERQgghRLC08NGPZFrqkeAcb1Suq0q4baukGx+rYk11vZ7TKH8W7Yzc5LpDfT0nJbRKpu2YTHvwCl/+zrMLnfOjM98umVYIIYQQE8DRo5+ytF2mTTt2fCIybZ1F4cqcE0ohOaivg3FVr2fRYm55Yuoq5pYnpq7OyHlixpVpxy26VkeMZNqwpNeuyLRtJIiNihBCCCHqxuSolKWLjkrynCqKwlV9vXU5KiHMG0ruaXcqqijm1uS6Q3s9u+yohOyS1DXvxB2VJ6705ecVdFTe+JdyVIQQQggxIZq/N1GYIDYqXXRUkudU0biwyoZzRT2WSRY+60LurOJtVTcPrLuYW56Yuoq55YmRo9JeR+Vja48HwndJOuOoaKMihBBCiCBpaQl9OSpM5tmyHBU5KqOOq4oJzamQoyJHJe85Ibskdc07cUfloJV+wNvPKXTO7W9+mxyVcSnTLK59+8l6SHsd9NrkJ/la6bUTdaCfK1Epzd+bKEwQG5UyjkpajOOFn5865Z8tT8pRGeasQH3uQ13NDrvgqITQPDBr3qr9kzwxbXFUxvVEJumoGM3VMqkjRo5KAI5KC5nJCjCzlWb2eTO7xcxuNrOzo/GlZrbRzG6N/lwSO+c8M7vNzL5nZifUuQAhhBBC5MO82FcIZG5UgB3AX7j704CjgbPM7DDgXGCTu68CNkXHRN87DTgcOBH4kJktquPihRBCCFEAt2JfAVBYpjWzzwL/En0d6+53mdly4Bp3P9TMzgNw9/dE8RuA8939umFzjiPTJmPKiF5NCXhFGxeGKvaFKOkWyR366xnCvHlz19FwsMl1N/16QrONASXTdkymXbnSD/yLPy90zg///C8al2nz3FGZx8wOBp4FXA/s7+53AUR/LovCDgR+EjvtjmgsOdeZZrbZzDb7XPELF0IIIURBvOBXAOSWac1sL+AS4Bx3/6XZ0FtCad9YsFx3Xw2sBjjkicu86zJtFY0LyxSJg8k2uwulkFze3HU0BswTU/W8dYuyeWLqajiYJ0YyrWRaybT5CMU7KUKuOypmtiu9TcrH3f0z0fDd0SMfoj+3RuN3ACtjp68A7qzmcoUQQghRmhbeUcl0VKx36+RiYJu7nxMb/wBwr7u/18zOBZa6+9vN7HDgE8BRwAH0RNtV7j47LIcclWrnbXJNIEclT0zb5s2bW45K9bnlqDTvktQ1bxOOyoqzizkqP/jL5h2VPI9+XgD8MfBtM7spGnsH8F5gjZmdAfwYOBXA3W82szXAd+h9YuisUZuUacai/7pGnkJyeYqlTTJGlCP+M9zFn+Um0Kso6iKkjxwXIXOj4u7XMvzfznFDzrkAuCDvRbS14NuwxoVln8NnFYUb1y0Iyamoe94u5a7LYxo3ZlLF3PLElGk4mDbWpKNSRcPBPDFyVMKaV2QTRGVaIYQQQkyAQGqjFEEbFSGEEGJaaOGjn9Z3T65Cpq26w3KVcl1cuA1B7GvLvNOau841ZXVC1utZTUyTQuukclcttOaJCXHeScu0u69Y6Svf9NZC59x23ltbIdMKIYQQogs0f2+iMEFsVJqUaZMxH43GmpBps4rCTUKUlEzb7i7Hdf6MZMmzkmkl0+bJbVjlQmuemFDnnShd/dSPEEIIITpCCzcqclSGxITyXFuOinKHMC/IUZnUmuSohOeS1DXvxB2VA1f6QW8s5qjc+tdyVEQGyYJa3sbtsGglXS1IGBp6hcUk0aOfknTFURnmrEB1z+GLNjKsKqbpZodtzT1pl6TKeYs2GAzBUamjMWAd80K2kyJHJSyXpBOOSksJYqMihBBCiAnQwjsqclSGxIT4XDvprEw6d5vmndbcVc5btMGgXs9yMZN2SeSohDPvxB2VA1b6wW8o5qh873w5KqIg8gZEHSQbC+pnTIiO0vy9icIEsVHpqqOSdk7VtSKyGhmmjTXhPrTdUQnt9ax63ioaDDbhqNTtkshRkaPSOUdFGxUhhBBChIihT/0IIYQQImRauFHpnEw7TK6F8WSwEAS8vOfUIdw2vSblLj9vVqG20NfUZO66irlBc9JrEzJt3UJrnpgQ5520TLvH8pV+yBnFZNpbLmhepp1pMrkQQggh2o2ZnW1mW8zsZjM7J/G9t5mZm9l+ZecP4tFPVTJt8jgu10J5GcypT8CrQ1asoyhcaPKncueftwpRNk/MJGTaSUuvVc5rhCG9TlqmjcuzdQmteWJCnXfiVPwQxcyOAF4PHAU8Aqw3s8vd/VYzWwm8DPjxODl0R0UIIYSYFrzgVzZPA77q7g+6+w7gC0Df5fhH4O25ZxqCHJWcMW16Xi5HZXpzy1EJe94QXBI5KuHM24Sj8qT/q5ij8p33vvVHwD2xodXuvrp/YGZPAz4LPB/4NbAJ2AxsBI5z97PN7Hbgue4enyc3QTz6EdWSLAqXVsxLzQ27i4oCCiGGUvxX/z2jNlPufouZvY/exuQB4JvADuCdwPElr3KAIDYqclR6TNIBKOqxtM3VmNbcZZoJVhVTVzE3aK4wmxwVOSqdclTyP84pNq37hcCFAGb2buBu4A+Bb5oZwArg62Z2lLv/rOj8QWxUhBBCCFE/dRR8M7Nl7r7VzA4Cfhd4vrv/c+z7t6NHP0IIIYTIpJ6n/peY2b7Ao8BZ7r4964QiSKYdI6btYt+ygTUt6dyaupg7S4xt45pCzj3uvCFKr5OQaScttOaJCXHeicu0T1jpT/6jYjLtln9ovuCb7qgIIYQQ00Lz9yYKE8RGJXSZNhmT1WF5XAGviYJaWV2Y2yaVdjV3VvG2JjoY113MLW0sdJk2qzNy2lgXZNqPre19yGPSQmuemFDnnSg1ybR1E8RGRQghhBD1YtFX25CjMkZM256Xy1Fpf245Ku36+QzRJZGjEs68k3ZUHrP/Sn/yfyvmqHz7n+SoiEBIKwqX/FNF4uol6z0QYaN3SbSBOj6eXDdBbFTkqIyOCcU/aFOzwzbmrqJ5YNM/I3nPCcUlqWreosXc8sTIUQnLJemEowJyVIQQQggRMNqoCCGEECJIvJ2PfiTTVhgTutjXRO6mJN061xSy9NrV17MNMm1bpNe6OiNDc0Jrk7lbJdMuW+lP+YNiMu03/0UyrRBCCCEmRfP3JgoTxEalbTJtcixLrk0bG0fsC12UDKGQXJ6YOnM3VZgtVJk2FOm1rnmnVaaNd0aG5oTWJnO3TaZt46OfIDYqQgghhJgALdyoyFGpMCak5+Wh5JajEq5TodxyVKqYNwRPpMncbXNUnvp7xRyVb/wvOSq1o2JZzZKnkFz8z0nG1JlbdB+926J1qNdPeepyVJLnXLz2OKD9jkqRRoZpYyG5D6E6FW3NHcKaqv65zxMzyXmraDiYJ6YN88pRaZ+joo2KEEIIIYLEaKdM23lHJe0cOSrh5O7imprM3cU1NZl71Dltc0nkqIQ376QdlT0fv9Kf+jvFHJWv/285Kp1Cz6yF6Cb6t70TuVjtxgK4OVGUIDYqbXdU0o6dZp/Dt8V9CMGp6FLuJtZUtyeSJ6bOeeuokZInJrR5sxoOpo3JUQnMUZFMK4QQQoiQaaOjoo2KEEIIMS20cKOSKdOa2UXAycBWdz8iGjsfeD3w8yjsHe5+RfS984AzgFngLe6+YcGkCboi0+Y5J0RhsMncXVxTk7m7uKYmctf9OyJPTKjzhii0Npm7VTLtfiv98JP/vNA5X7v4LxqXaWdyxHwEODFl/B/d/cjoq79JOQw4DTg8OudDZraoqosVQgghxBh4wa8AyHz04+5fNLODc873KuCT7v4w8EMzuw04Crhu1EldlGmT51RRFK5qYTAESbOLQmuTuesSZaE5oXXSuePybF2/I/LEhDavZNpuyLRtdFTy3FEZxpvM7FtmdpGZLYnGDgR+Eou5IxpbgJmdaWabzWzzIzta+MoJIYQQbaOFd1RyFXyL7qisizkq+wP30FvG3wHL3f11ZvavwHXu/rEo7kLgCne/ZNT8clRIHeuyA9DlNTWZu4traiK3HBU5KpOYd9KOyl77rvQjXl7MUbn+4+1wVBbg7ne7+6y7zwH/Ru/xDvTuoKyMha4A7hzvEqvHov+EEAKi0uJNX0SAWOw/IZqi1MeTzWy5u98VHb4a2BL9fS3wCTP7IHAAsAq4IWu+STkqaTGOT62jUqS5YVucimnPXZd/kiemjY5KVoPBaXZUijYczBMjRyWEpoSBPM8pQOZGxcz+AzgW2M/M7gDeBRxrZkfSe/RzO/AGAHe/2czWAN8BdgBnuftsPZcuhBBCiCK0UabN86mf16YMXzgi/gLggnEuSgghhBAVE5AgW4Sp7J6cjGlSVptWWbHLa2oydxfXVHXuEITWJnPXJcrmiZFM27BMu3SlP+Nl5xQ657o1b2tcplUJfSGEEGJaaP7eRGGC2KhMg0xbRYflEGTFtkil05q7LlE2T0wIP59FirlBc0Jrk7nrKuaWJ0YybfMybScdFSGEEEJ0AKeVn/qRo4IclSZzd3FNTebu4pqqzh2CJ9Jkbjkq4cw7cUdlyUo/8iVnFzrny5/5Szkq047KKAlRL/o3lo6KuE0pzd+bKEwQG5VpdVSSMVlF4drgAEAYrkaXcnfNE5lU7qxibmlj0+Ko1FHMLU+MHJVmHRVDjooQQgghQsW9lY6KNipCCCHElNDGOyqSaYfEhCTBtU1WDGHeac3dxTUVyd0WobXJ3ElxFtohnoaau00y7d77rPBnvaiYTPuly94umVYIIYQQk6GNd1SC2Kg0KdMmYy5eexwQjgQXLwoXmqxY97whCa1VxbT1fWpD7qLF3PLESKYN4/dyyLnbJNPiwFz7dipBbFSEEEIIMQHat0+RozIsJqRnyyE5AG2Zd1pzd3FNo2Lab/XSugAAFQdJREFU6ok0kbvLnkiTuVvlqDxuhT/7BW8pdM4Xr/wrOSpCCCGEmAxyVEoiR2V4zDQ7Ksodzryh5a6imFuemK44KnEnpYueSJO5W+WoQC11VMzsbOD19GrK/Zu7/5OZfQA4BXgE+D7wp+5+X5n5Zyq7UiGEEEIEjXmxr8z5zI6gt0k5CngmcLKZrQI2Ake4+zOA/wLOK3/NclTkqOSIadu805q7i2saFdM2T0SOSvdyt8pReewKf+7Rby50zjUbzx15jWZ2KnCCu/9ZdPzXwMPu/v5YzKuB33f3Pyxz3bqj0gKMwcZqljImRNdI+znXz31+LPpPiD69Xj9e6AvYz8w2x77OTEy7BXiRme1rZo8BTgJWJmJeB1xZ9rrlqBC2o5J1TlYjw7SxkPyDaXEq2j7vpHMXrYnSBk9kUrk/tvZ4YLo8kSZzt85RmSt8xj2j7qi4+y1m9j56j3oeAL4J7Oh/38zeGR1/vHDmCN1REUIIIaaEEndUMnH3C9392e7+ImAbcCuAmZ0OnAz8oY/hmQRxR0UIIYQQNePUUvDNzJa5+1YzOwj4XeD5ZnYi8FfAb7v7g2PNL5k2X0wIAl4ZARfCFiWnTf5s67yTyB2SeNo2mTYEqXRac7dJpn3s3gf6bz7nrELnfO4L78y8RjP7ErAv8CjwVnffZGa3AYuBe6Owr7r7/13isnVHRQghhJgW6ij45u4vTBl7clXzB7FRCUmmTYtxPAgBr0yROAhPlJzEvNOau41rqqJ4W9P/5prMXbTBYBeF1iZzt06mDeApSlGC2KgIIYQQomYcrPinfhpHjkrOmBCea8tRUe4urylEl0SOSjg+R6i5W+Wo7HWgP++Zbyx0ztVf+Ws1JRT1oDJPIiSSP4/6+RwPFXITpWn+3kRhgtioyFGpd94qisKF5jUodzvW1PbmgaE5KlnF3NLGpsETaTJ32xyVvLVRQiKIjYoQQgghJkALNyqqTCuEEEKIYJFMO0ZMF8U+yZ/tzt3FDsZ5Yto2b5HcIcmfyt1ymXbPA/3ow99Q6JyNX3uXZFohhBBC1I+Rv39PSASxUQldpk3GZHVYbqPYlyXcTov82fbck1zTpETZPDFtmzdv7qLF3PLEdFFobTJ322TaNjoqQWxUhBBCCDEBWrhRkaMyRkwXn5dPg1PR5dxyVNoxb5HcITkVyt1uR+VxjznAjz709YXOueqmv5WjIsJCZaREnLSfB/2M1IuKuYk6kaNSEjkq+WIm+by8iiJxeWK66Ik0mbvKeY1wfz7bPm/aWBXF3PLEdNETaTK3HJX6CWKjIoQQQoi68VZuVOSojBEzDc/Lu+hUdDl3Xf4JhPnz2dZ5R8WE7FQod8sdlT2W+/Of/LpC52zYMtlrTEN3VMZgGp4l52km1/1XoZvovQyDafg9IgJirukLKE4QG5W2OSrJsSxnJW0s9OflZc9xwnA1pjV3Xf5Jnpg2/HyGMi9kOymhOhXK3W5HRTKtEEIIIcJFGxUhhBBCBIkDc+3bqEimrTCmi2LfpObtktDaRO4u/4w0mbsuURbaKX8qd8tl2t2f4MccdHqhc9bf+n7JtEIIIYSYEAHcnChK5kbFzC4CTga2uvsR0dhS4FPAwcDtwGvcfXv0vfOAM4BZ4C3uviFl2gEk0+aL6aqsWFTArSqmKzJtXIzt4s9Ik7mrnLdog8FQ5U/lbrdM28aNykyOmI8AJybGzgU2ufsqYFN0jJkdBpwGHB6d8yEzW1TZ1QohhBBiqsjlqJjZwcC62B2V7wHHuvtdZrYcuMbdD43upuDu74niNgDnu/t1o+aXo5IvpssOQBc8ETkq3cstR0W5O+WoLH6CH3PgHxU6Z/0P/6FxRyXPHZU09nf3uwCiP5dF4wcCP4nF3RGNLcDMzjSzzWa22VtYgCYNi/4TxbHYV3Js3JgmqWtNIa1RDEe/E0RYOPhcsa8AqFqmTfsXmXrLxt1XA6sBDnniMg/tueG4uR0P+nl5KLnrXFNWY8U6HZVPRGNdej2nMXddxdzSxtriVCi3HJVJU3ajcreZLY89+tkajd8BrIzFrQDuHOcChRBCCFEBLa2jUvbRz1qg/2Hs04HPxsZPM7PFZnYIsAq4YbxLFEIIIUQluBf7CoBMmdbM/gM4FtgPuBt4F/CfwBrgIODHwKnuvi2KfyfwOmAHcI67X5l1EV2RacfpuJw2JllRuUOZd1pz1yXK5okJUf5U7pbLtLvt78cs+4NC56z/6f/TuEyb+ejH3V875FvHDYm/ALhgnIsSQgghRNWEc5ekCEFUpm17wbc851RRFE6yonJP45qazF1XMbc8MaHKn8rdYpnWgbkwPslThCA2KkIIIYSYAC28o6KmhDXEyFFpft5pzd3FNTWZW46KcnfKUdl1mR+z9PcKnbN+6/8K31ER1aLiT0J0A/1bFu3DW/nx5CA2KtPgqFRRFG6aHQDlnt41NZm7rmJueWLaNu+05m6bo+KBVJstQhAbFSGEEEJMAN1REUIIIUSwBOClFkUybQ0x484rWVG5Q5t32nJ34fdIF383hpi7VTLtov38+Xu9stA5G375/0mmFUIIIcSECODmRFGC2KhMq0ybjMkqCjctsqJyhzfvNOWOF29r4++RLv5uDDl3q2TalhLERkUIIYQQ9eMtrEwrR6WGmKrn7aID0OU1NZm7i2uaRO5p+D3S5TU1mbtdjsq+fvTuryh0zlUP/rscFSGEEEJMAEcfTy6LHJXhMfGicF1xACYx77Tm7uKa6sydVbytK79Hur6mJnO3zlFpYcG3maYvQAghhBD144DPeaGvPJjZ2Wa2xcxuNrNzorGlZrbRzG6N/lxS9rrlqNQQI0el+XmnNXcX1zSJ3NPwe6TLa2oyd5sclcfaUj96l+MLnbNxx6dGXqOZHQF8EjgKeARYD7wReD2wzd3fa2bnAkvc/a/KXLfuqLQAi/4TQoyPxf4TYtqo4Y7K04CvuvuD7r4D+ALwauBVwMVRzMXA75S9ZjkqNcTUOW/RRoZVxbRt3mnN3cU1VZk7XiMFpvf3SNfW1GTuNjkq97P9xo2znyp0B8dszeaMkC3ABWa2L/Br4CRgM7C/u98F4O53mdmyMtcMgWxUhBBCCFE795hZ1sYjye6Jc1a7++r+gbvfYmbvAzYCDwDfBHaMf6k70UZFCCGEmALc/cSa5r0QuBDAzN4N3AHcbWbLo7spy4GtZeeXTFtDTAjzhiYrdlHADDF3F9dUJHdb/i03mbuLa2oyd5tk2rows2XuvtXMDgKuAp4PvAO4NybTLnX3t5eZX3dUhBBCCDEOl0SOyqPAWe6+3czeC6wxszOAHwOnlp08iI2KZNpq561DuG1aglTu6V1T3txFRdk8MdP8e0S5JzNvF3D3F6aM3QscV8X8+niyEEIIIYJFjkoNMSHM2xb/IASvoUu5u7imIrnb8m+5ydxdXFOTueWo1E8Qj35E9aiYlegiyZ9r/ZwL0X2C2KjIUal33ovX9h4ThugfNO01dC13F9cEzTUP1O8R5Zaj0jxyVIQQQggRLNqoCCGEECJYJNPWENO2eeNjkj/bnbvNawrx34Z+jyi3ZNrm0R0VIYQQQgSLZNoaYto2L2QLt20UMKcxdxvXlCXKpo114d+c1tSN3JJp60d3VIQQQggRLHJUaohp27zxMTkV7c7d5jWF+G9Dv0eUW45K8wTx6EeEQ1ZBLRXYEmXQz5EQoixBbFTkqLRzTSEXkpvW3KGtqQr/JE9M2+bVmrqTW45K/chREUIIIUSwaKMihBBCiGCRTFtDTNvmbSJ3F+TPEHNPYk3T8POpNSn3JOaVTJsP3VERQgghRLBIpq0hpm3zTjq348HKn23P3cUOxnli2jav1tSd3JJp60d3VIQQQggRLHJUaohp27xtXlPoPkdIjkro72WIubUm5Zaj0jy6oyKEEEKIYJGjUkNM2+Zt45pUbG56iq41mVtrUm45Ks2jOypCCCGECJaxHBUzux24H5gFdrj7c81sKfAp4GDgduA17r592BwgR6Xpedu8phA9kSZzy1Fpx7xaU3dyy1GpnyruqLzY3Y+MvdjnApvcfRWwKToWohYs+i95nDZWxTlVxTQxrxBCtJE6HJVXAcdGf78YuAb4q1EnyFHRmrq0piZzd3FNTebWmpRbjkrzjHtHxYGrzOxGMzszGtvf3e8CiP5cNmYOIYQQQkwp495ReYG732lmy4CNZvbdvCdGG5szAQ44YL8xL0MIIYQQXaSygm9mdj7wAPB64Fh3v8vMlgPXuPuho86VTKs1dWlNTebu4pqazK01Kbdk2uYp/ejHzPY0s737fweOB7YAa4HTo7DTgc+Oe5FCCCGEmE7GefSzP3CpmfXn+YS7rzezrwFrzOwM4MfAqVkTSabVmrq0piZzd3FNTebWmpRbMm3zlN6ouPsPgGemjN8LHDfORQkhhBBCgJoS1hLTtnm1pu7k7uKamsytNSm3HJXmUQl9IYQQQgTLuB9PrgQ5KlpTl9bUZO4urqnJ3FqTcstRaR7dURFCCCFEsGijIoQQQohgkUxbQ0zb5tWaupO7i2tqMrfWpNySaZtHd1SEEEIIESySaWuIadu8WlN3cndxTU3m1pqUWzJt8+iOihBCCCGCRY5KDTFtm1dr6k7uLq6pydxak3LLUWke3VERQgghRLDIUakhpm3zak3dyd3FNTWZW2tSbjkqzaM7KkIIIYQIFjkqNcS0bV6tqTu5u7imJnNrTcotR6V5dEdFCCGEEMEiR6WGmLbNqzV1J3cX19Rkbq1JueWoNI/uqAghhBAiWLRREUIIIUSwSKatIaZt82pN3cndxTU1mVtrUm7JtM2jOypCCCGECBbJtDXEtG1erak7ubu4piZza03KLZm2eXRHRQghhBDBIkelhpi2zas1dSd3F9fUZG6tSbnlqDSP7qgIIYQQIljkqNQQ07Z5tabu5O7imprMrTUptxyV5tEdFSGEEEIEizYqQgghhAgWybQ1xLRtXq2pO7m7uKYmc2tNyi2Ztnl0R0UIIYQQwSKZtoaYts2rNXUndxfX1GRurUm5JdM2j+6oCCGEECJY5KjUENO2ebWm7uTu4pqazK01KbcclebRHRUhhBBCBIsclRpi2jav1tSd3F1cU5O5tSbllqPSPLqjIoQQQohg0UZFCCGEEMEimbaGmLbNqzV1J3cX19Rkbq1JuSXTNo/uqAghhBAiWCTT1hDTtnm1pu7k7uKamsytNSm3ZNrm0R0VIYQQQgSLHJUaYto2r9bUndxdXFOTubUm5Zaj0jy6oyKEEEKIYJGjUkNM2+bVmrqTu4trajK31qTcclSaR3dUhBBCCBEsclRqiGnbvFpTd3J3cU1N5taalFuOSvPojooQQgghgkWOSg0xbZtXa+pO7i6uqcncWpNyy1FpntruqJjZiWb2PTO7zczOrSuPEEIIIbpLLRsVM1sE/CvwcuAw4LVmdlgduYQQQgjRXWqRac3s+cD57n5CdHwegLu/Jy1eMq3W1KU1NZm7i2tqMrfWpNySaZunLkflQOAnseM7gOfFA8zsTODM6PDhP33Dh7fUdC0hsB9wT9MXURNaWzvp8tqg2+vT2tpJ2tqe2MSFtI26NiqWMjZw68bdVwOrAcxsc5d3lV1en9bWTrq8Nuj2+rS2dtLltdVNXTLtHcDK2PEK4M6acgkhhBCio9S1UfkasMrMDjGz3YDTgLU15RJCCCFER6nl0Y+77zCzNwEbgEXARe5+84hTVtdxHQHR5fVpbe2ky2uDbq9Pa2snXV5brQRRQl8IIYQQIg2V0BdCCCFEsGijIoQQQohgaXyj0rVS+2Z2u5l928xuMrPN0dhSM9toZrdGfy5p+jrzYGYXmdlWM9sSGxu6FjM7L3ofv2dmJzRz1fkZsr7zzeyn0ft3k5mdFPtea9ZnZivN7PNmdouZ3WxmZ0fjrX//Rqyt9e+dme1uZjeY2Tejtf33aLwL79uwtbX+fetjZovM7Btmti46bv37FgTu3tgXPdH2+8CTgN2AbwKHNXlNFazpdmC/xNj7gXOjv58LvK/p68y5lhcBzwa2ZK2FXquEbwKLgUOi93VR02sosb7zgbelxLZqfcBy4NnR3/cG/itaQ+vfvxFra/17R68G1V7R33cFrgeO7sj7NmxtrX/fYtf8VuATwLrouPXvWwhfTd9ROQq4zd1/4O6PAJ8EXtXwNdXBq4CLo79fDPxOg9eSG3f/IrAtMTxsLa8CPunuD7v7D4Hb6L2/wTJkfcNo1frc/S53/3r09/uBW+hVjG79+zdibcNo09rc3R+IDneNvpxuvG/D1jaM1qwNwMxWAK8A/ndsuPXvWwg0vVFJK7U/6hdOG3DgKjO7MWoTALC/u98FvV+ywLLGrm58hq2lS+/lm8zsW9Gjof6t2tauz8wOBp5F7//Bdur9S6wNOvDeRY8PbgK2AhvdvTPv25C1QQfeN+CfgLcDc7GxTrxvTdP0RiWz1H4LeYG7P5te5+izzOxFTV/QhOjKe/lh4DeAI4G7gH+Ixlu5PjPbC7gEOMfdfzkqNGUs6PWlrK0T7527z7r7kfQqeh9lZkeMCO/C2lr/vpnZycBWd78x7ykpY0GuLQSa3qh0rtS+u98Z/bkVuJTe7by7zWw5QPTn1uaucGyGraUT76W73x39Mp0D/o2dt2Nbtz4z25Xe/5B/3N0/Ew134v1LW1uX3jsAd78PuAY4kY68b33ia+vI+/YC4JVmdjs9heElZvYxOva+NUXTG5VOldo3sz3NbO/+34HjgS301nR6FHY68NlmrrAShq1lLXCamS02s0OAVcANDVzfWPR/qUS8mt77By1bn5kZcCFwi7t/MPat1r9/w9bWhffOzB5vZvtEf98DeCnwXbrxvqWurQvvm7uf5+4r3P1gev879jl3/yM68L6FQF3dk3PhxUvth87+wKW936PsAnzC3deb2deANWZ2BvBj4NQGrzE3ZvYfwLHAfmZ2B/Au4L2krMXdbzazNcB3gB3AWe4+28iF52TI+o41syPp3Ya9HXgDtHJ9LwD+GPh25AQAvINuvH/D1vbaDrx3y4GLzWwRvf8jucbd15nZdbT/fRu2tn/vwPs2jC78e2scldAXQgghRLA0/ehHCCGEEGIo2qgIIYQQIli0URFCCCFEsGijIoQQQohg0UZFCCGEEMGijYoQQgghgkUbFSGEEEIEy/8PbUYKexgB19IAAAAASUVORK5CYII=\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
}