examples/Notebooks/flopy3_mf6_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Flopy MODFLOW 6 (MF6) Support"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Flopy library contains classes for creating, saving, running, loading, and modifying MF6 simulations.  The MF6 portion of the flopy library is located in:\n",
    "\n",
    "*flopy.mf6*\n",
    "\n",
    "While there are a number of classes in flopy.mf6, to get started you only need to use the main classes summarized below:\n",
    "\n",
    "flopy.mf6.MFSimulation  \n",
    "* MODFLOW Simulation Class.  Entry point into any MODFLOW simulation.\n",
    "\n",
    "flopy.mf6.ModflowGwf\n",
    "* MODFLOW Groundwater Flow Model Class.  Represents a single model in a simulation.\n",
    "\n",
    "flopy.mf6.Modflow[pc]\n",
    "    * MODFLOW package classes where [pc] is the abbreviation of the package name.  Each package is a separate class.  \n",
    "\n",
    "For packages that are part of a groundwater flow model, the abbreviation begins with \"Gwf\".  For example, \"flopy.mf6.ModflowGwfdis\" is the Discretization package.\n",
    "  "
   ]
  },
  {
   "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_us/flopy\n",
      "3.7.3 (default, Mar 27 2019, 16:54:48) \n",
      "[Clang 4.0.1 (tags/RELEASE_401/final)]\n",
      "numpy version: 1.16.2\n",
      "matplotlib version: 3.0.3\n",
      "flopy version: 3.2.12\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "from shutil import copyfile\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "try:\n",
    "    import flopy\n",
    "except:\n",
    "    fpth = os.path.abspath(os.path.join('..', '..'))\n",
    "    sys.path.append(fpth)\n",
    "    import flopy\n",
    "    \n",
    "print(sys.version)\n",
    "print('numpy version: {}'.format(np.__version__))\n",
    "print('matplotlib version: {}'.format(mpl.__version__))\n",
    "print('flopy version: {}'.format(flopy.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a MF6 Simulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A MF6 simulation is created by first creating a simulation object \"MFSimulation\".  When you create the simulation object you can define the simulation's name, version, executable name, workspace path, and the name of the tdis file.  All of these are optional parameters, and if not defined each one will default to the following:\n",
    "\n",
    "sim_name='modflowtest'\n",
    "\n",
    "version='mf6'\n",
    "\n",
    "exe_name='mf6.exe'\n",
    "\n",
    "sim_ws='.'\n",
    "\n",
    "sim_tdis_file='modflow6.tdis'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "from shutil import copyfile\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",
    "sim_name = 'example_sim'\n",
    "sim_path = os.path.join('data', 'example_project')\n",
    "sim = flopy.mf6.MFSimulation(sim_name=sim_name, version='mf6', exe_name='mf6', \n",
    "                             sim_ws=sim_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is to create a tdis package object \"ModflowTdis\".  The first parameter of the ModflowTdis class is a simulation object, which ties a ModflowTdis object to a specific simulation.  The other parameters and their definitions can be found in the docstrings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "tdis = flopy.mf6.ModflowTdis(sim, pname='tdis', time_units='DAYS', nper=2, \n",
    "                             perioddata=[(1.0, 1, 1.0), (10.0, 5, 1.0)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next one or more models are created using the ModflowGwf class.  The first parameter of the ModflowGwf class is the simulation object that the model will be a part of."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_name = 'example_model'\n",
    "model = flopy.mf6.ModflowGwf(sim, modelname=model_name,\n",
    "                             model_nam_file='{}.nam'.format(model_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next create one or more Iterative Model Solution (IMS) files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "ims_package = flopy.mf6.ModflowIms(sim, pname='ims', print_option='ALL',\n",
    "                                   complexity='SIMPLE', outer_hclose=0.00001,\n",
    "                                   outer_maximum=50, under_relaxation='NONE',\n",
    "                                   inner_maximum=30, inner_hclose=0.00001,\n",
    "                                   linear_acceleration='CG',\n",
    "                                   preconditioner_levels=7,\n",
    "                                   preconditioner_drop_tolerance=0.01,\n",
    "                                   number_orthogonalizations=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each ModflowGwf object needs to be associated with an ModflowIms object.  This is done by calling the MFSimulation object's \"register_ims_package\" method.  The first parameter in this method is the ModflowIms object and the second parameter is a list of model names (strings) for the models to be associated with the ModflowIms object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "sim.register_ims_package(ims_package, [model_name])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next add packages to each model.  The first package added needs to be a spatial discretization package since flopy uses  information from the spatial discretization package to help you build other packages.  There are three spatial discretization packages to choose from:\n",
    "\n",
    "DIS (ModflowGwfDis) - Structured discretization\n",
    "DISV (ModflowGwfdisv) - Discretization with vertices\n",
    "DISU (ModflowGwfdisu) - Unstructured discretization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "dis_package = flopy.mf6.ModflowGwfdis(model, pname='dis', length_units='FEET', nlay=2,\n",
    "                                      nrow=2, ncol=5, delr=500.0,\n",
    "                                      delc=500.0,\n",
    "                                      top=100.0, botm=[50.0, 20.0],\n",
    "                                      filename='{}.dis'.format(model_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing Namefiles\n",
    "\n",
    "Namefiles are automatically built for you by flopy.  However, there are some options contained in the namefiles that you may want to set. To get the namefile object access the name_file attribute in either a simulation or model object to get the simulation or model namefile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set the nocheck property in the simulation namefile\n",
    "sim.name_file.nocheck = True\n",
    "# set the print_input option in the model namefile\n",
    "model.name_file.print_input = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Specifying Options\n",
    "\n",
    "Option that appear alone are assigned a boolean value, like the print_input option above.  Options that have additional optional parameters are assigned using a tuple, with the entries containing the names of the optional parameters to turn on.  Use a tuple with an empty string to indicate no optional parameters and use a tuple with None to turn the option off. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Turn Newton option on with under relaxation \n",
    "model.name_file.newtonoptions = ('UNDER_RELAXATION')\n",
    "# Turn Newton option on without under relaxation\n",
    "model.name_file.newtonoptions = ('')\n",
    "# Turn off Newton option \n",
    "model.name_file.newtonoptions = (None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MFArray Templates\n",
    "\n",
    "Lastly define all other packages needed.  \n",
    "\n",
    "Note that flopy supports a number of ways to specify data for a package.  A template, which defines the data array shape for you, can be used to specify the data.  Templates are built by calling the empty of the data type you are building.  For example, to build a template for k in the npf package you would call:\n",
    "\n",
    "ModflowGwfnpf.k.empty()\n",
    "\n",
    "The empty method for \"MFArray\" data templates (data templates whose size is based on the structure of the model grid)  take up to four parameters:\n",
    "\n",
    "* model - The model object that the data is a part of.  A valid model object with a discretization package is required in order to build the proper array dimensions.  This parameter is required.\n",
    "\n",
    "* layered - True or false whether the data is layered or not.\n",
    "\n",
    "* data_storage_type_list - List of data storage types, one for each model layer.  If the template is not layered, only one data storage type needs to be specified.  There are three data storage types supported, internal_array, internal_constant, and external_file. \n",
    "\n",
    "* default_value - The initial value for the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'factor': 1.5, 'iprn': 1, 'data': [65.0, 60.0, 55.0, 50.0, 45.0, 40.0, 35.0, 30.0, 25.0, 20.0]}, 100.0]\n"
     ]
    }
   ],
   "source": [
    "# build a data template for k that stores the first layer as an internal array and the second\n",
    "# layer as a constant with the default value of k for all layers set to 100.0 \n",
    "layer_storage_types = [flopy.mf6.data.mfdatastorage.DataStorageType.internal_array, \n",
    "                       flopy.mf6.data.mfdatastorage.DataStorageType.internal_constant]\n",
    "k_template = flopy.mf6.ModflowGwfnpf.k.empty(model, True, layer_storage_types, 100.0)\n",
    "# change the value of the second layer to 50.0\n",
    "k_template[0]['data'] = [65.0, 60.0, 55.0, 50.0, 45.0, 40.0, 35.0, 30.0, 25.0, 20.0]\n",
    "k_template[0]['factor'] = 1.5\n",
    "print(k_template)\n",
    "# create npf package using the k template to define k\n",
    "npf_package = flopy.mf6.ModflowGwfnpf(model, pname='npf', save_flows=True, icelltype=1, k=k_template)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Specifying MFArray Data\n",
    "\n",
    "MFArray data can also be specified as a numpy array, a list of values, or a single value.  Below strt (starting heads) are defined as a single value, 100.0, which is interpreted as an internal constant storage type of value 100.0.  Strt could also be defined as a list defining a value for every model cell:\n",
    "\n",
    "strt=[100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, \n",
    "      90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0]\n",
    "      \n",
    "Or as a list defining a value or values for each model layer:\n",
    "\n",
    "strt=[100.0, 90.0]\n",
    "\n",
    "or:\n",
    "\n",
    "strt=[[100.0], [90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0]]\n",
    "\n",
    "MFArray data can also be stored in an external file by using a dictionary using the keys 'filename' to specify the file name relative to the model folder and 'data' to specific the data.  The optional 'factor', 'iprn', and 'binary' keys may also be used.\n",
    "\n",
    "strt={'filename': 'strt.txt', 'factor':1.0, 'data':[100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, \n",
    "      90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0], 'binary': 'True'}\n",
    "      \n",
    "If the 'data' key is omitted from the dictionary flopy will try to read the data from an existing file 'filename'.  Any relative paths for loading data from a file should specified relative to the MF6 simulation folder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "strt={'filename': 'strt.txt', 'factor':1.0, 'data':[100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, \n",
    "      90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0, 90.0], 'binary': 'True'}\n",
    "ic_package = flopy.mf6.ModflowGwfic(model, pname='ic', strt=strt,\n",
    "                                    filename='{}.ic'.format(model_name))\n",
    "# move external file data into model folder\n",
    "icv_data_path = os.path.join('..', 'data', 'mf6', 'notebooks', 'iconvert.txt')\n",
    "copyfile(icv_data_path, os.path.join(sim_path, 'iconvert.txt'))\n",
    "# create storage package\n",
    "sto_package = flopy.mf6.ModflowGwfsto(model, pname='sto', save_flows=True, iconvert={'filename':'iconvert.txt'},\n",
    "                                      ss=[0.000001, 0.000002], \n",
    "                                      sy=[0.15, 0.14, 0.13, 0.12, 0.11, 0.11, 0.12, 0.13, 0.14, 0.15,\n",
    "                                         0.15, 0.14, 0.13, 0.12, 0.11, 0.11, 0.12, 0.13, 0.14, 0.15])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MFList Templates\n",
    "\n",
    "Flopy supports specifying record and recarray \"MFList\" data in a number of ways.  Templates can be created that define the shape of the data.  The empty method for \"MFList\" data templates take up to 7 parameters.\n",
    "\n",
    "* model - The model object that the data is a part of.  A valid model object with a discretization package is required in order to build the proper array dimensions.  This parameter is required.\n",
    "\n",
    "* maxbound - The number of rows in the recarray.  If not specified one row is returned.\n",
    "\n",
    "* aux_vars - List of auxiliary variable names.  If not specified auxiliary variables are not used.\n",
    "\n",
    "* boundnames - True/False if boundnames is to be used.\n",
    "\n",
    "* nseg - Number of segments (only relevant for a few data types)\n",
    "\n",
    "* timeseries - True/False indicates that time series data will be used.\n",
    "\n",
    "* stress_periods - List of integer stress periods to be used (transient MFList data only).  If not specified for transient data, template will only be defined for stress period 1. \n",
    "\n",
    "MFList transient data templates are numpy recarrays stored in a dictionary with the dictionary key an integer zero based stress period value (stress period - 1).\n",
    "\n",
    "In the code below the well package is set up using a transient MFList template to help build the well's stress_periods.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "maxbound = 2\n",
    "# build a stress_period_data template with 2 wells over stress periods 1 and 2 with boundnames \n",
    "# and three aux variables\n",
    "wel_periodrec = flopy.mf6.ModflowGwfwel.stress_period_data.empty(model, maxbound=maxbound, boundnames=True, \n",
    "                                                             aux_vars=['var1', 'var2', 'var3'],\n",
    "                                                             stress_periods=[0,1])\n",
    "# define the two wells for stress period one\n",
    "wel_periodrec[0][0] = ((0,1,2), -50.0, -1, -2, -3, 'First Well')\n",
    "wel_periodrec[0][1] = ((1,1,4), -25.0, 2, 3, 4, 'Second Well')\n",
    "# define the two wells for stress period two\n",
    "wel_periodrec[1][0] = ((0,1,2), -200.0, -1, -2, -3, 'First Well')\n",
    "wel_periodrec[1][1] = ((1,1,4), -4000.0, 2, 3, 4, 'Second Well')\n",
    "# build the well package\n",
    "wel_package = flopy.mf6.ModflowGwfwel(model, pname='wel', print_input=True, print_flows=True,\n",
    "                                      auxiliary=['var1', 'var2', 'var3'], maxbound=maxbound,\n",
    "                                      stress_period_data=wel_periodrec, boundnames=True, save_flows=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cell IDs\n",
    "\n",
    "Cell IDs always appear as tuples in an MFList. For a structured grid cell IDs appear as:\n",
    "\n",
    "(&lt;layer&gt;, &lt;row&gt;, &lt;column&gt;)\n",
    "\n",
    "For vertice based grid cells IDs appear as:\n",
    "\n",
    "(&lt;layer&gt;, &lt;intralayer_cell_id&gt;)\n",
    "\n",
    "Unstructured grid cell IDs appear as:\n",
    "\n",
    "(&lt;cell_id&gt;)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Specifying MFList Data\n",
    "\n",
    "MFList data can also be defined as a list of tuples, with each tuple being a row of the recarray.  For transient data the list of tuples can be stored in a dictionary with the dictionary key an integer zero based stress period value.  If only a list of tuples is specified for transient data, the data is assumed to apply to stress period 1.  Additional stress periods can be added with the add_transient_key method.  The code below defines saverecord and printrecord as a list of tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# printrecord data as a list of tuples.  since no stress\n",
    "# period is specified it will default to stress period 1\n",
    "printrec_tuple_list = [('HEAD', 'ALL'), ('BUDGET', 'ALL')]\n",
    "# saverecord data as a dictionary of lists of tuples for \n",
    "# stress periods 1 and 2.  \n",
    "saverec_dict = {0:[('HEAD', 'ALL'), ('BUDGET', 'ALL')],1:[('HEAD', 'ALL'), ('BUDGET', 'ALL')]}\n",
    "# create oc package\n",
    "oc_package = flopy.mf6.ModflowGwfoc(model, pname='oc', \n",
    "                                    budget_filerecord=[('{}.cbc'.format(model_name),)],\n",
    "                                    head_filerecord=[('{}.hds'.format(model_name),)],\n",
    "                                    saverecord=saverec_dict,\n",
    "                                    printrecord=printrec_tuple_list)\n",
    "# add stress period two to the print record\n",
    "oc_package.printrecord.add_transient_key(1)\n",
    "# set the data for stress period two in the print record\n",
    "oc_package.printrecord.set_data([('HEAD', 'ALL'), ('BUDGET', 'ALL')], 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specifying MFList Data in an External File \n",
    "\n",
    "MFList data can be specified in an external file using a dictionary with the 'filename' key.  If the 'data' key is also included in the dictionary and is not None, flopy will create the file with the data contained in the 'data' key.  The 'binary' key can be used to save data to a binary file ('binary': True).  The code below creates a chd package which creates and references an external file containing data for stress period 1 and stores the data internally in the chd package file for stress period 2. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "stress_period_data = {0: {'filename': 'chd_sp1.dat', 'data': [[(0, 0, 0), 70.]]},\n",
    "                      1: [[(0, 0, 0), 60.]]}\n",
    "chd = flopy.mf6.ModflowGwfchd(model, maxbound=1, stress_period_data=stress_period_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Packages that Support both List-based and Array-based Data\n",
    "\n",
    "The recharge and evapotranspiration packages can be specified using list-based or array-based input.  The array packages have an \"a\" on the end of their name:\n",
    "\n",
    "ModflowGwfrch - list based recharge package\n",
    "ModflowGwfrcha - array based recharge package\n",
    "ModflowGwfevt - list based evapotranspiration package\n",
    "ModflowGwfevta - array based evapotranspiration package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "rch_recarray = {0:[((0,0,0), 'rch_1'), ((1,1,1), 'rch_2')],\n",
    "                1:[((0,0,0), 'rch_1'), ((1,1,1), 'rch_2')]}\n",
    "rch_package = flopy.mf6.ModflowGwfrch(model, pname='rch', fixed_cell=True, print_input=True, \n",
    "                                      maxbound=2, stress_period_data=rch_recarray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Utility Files (TS, TAS, OBS, TAB)\n",
    "\n",
    "Utility files, MF6 formatted files that reference by packages, include time series, time array series, observation, and tab files.  The file names for utility files are specified using the package that references them. The utility files can be created in several ways. A simple case is demonstrated below. More detail is given in the flopy3_mf6_obs_ts_tas notebook. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# build a time series array for the recharge package\n",
    "ts_data = [(0.0, 0.015, 0.0017), (1.0, 0.016, 0.0019), (2.0, 0.012, 0.0015),\n",
    "           (3.0, 0.020, 0.0014), (4.0, 0.015, 0.0021), (5.0, 0.013, 0.0012),\n",
    "           (6.0, 0.022, 0.0012), (7.0, 0.016, 0.0014), (8.0, 0.013, 0.0011),\n",
    "           (9.0, 0.021, 0.0011), (10.0, 0.017, 0.0016), (11.0, 0.012, 0.0015)]\n",
    "rch_package.ts.initialize(time_series_namerecord=['rch_1', 'rch_2'],                                     \n",
    "                          timeseries=ts_data, filename='recharge_rates.ts',\n",
    "                          interpolation_methodrecord=['stepwise', 'stepwise'])\n",
    "\n",
    "# build an recharge observation package that outputs the western recharge to a binary file and the eastern\n",
    "# recharge to a text file\n",
    "obs_data = {('rch_west.csv', 'binary'): [('rch_1_1_1', 'RCH', (0, 0, 0)),\n",
    "                                    ('rch_1_2_1', 'RCH', (0, 1, 0))],\n",
    "             'rch_east.csv': [('rch_1_1_5', 'RCH', (0, 0, 4)),\n",
    "                              ('rch_1_2_5', 'RCH', (0, 1, 4))]}\n",
    "rch_package.obs.initialize(filename='example_model.rch.obs', digits=10, \n",
    "                           print_input=True, continuous=obs_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Saving and Running a MF6 Simulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Saving and running a simulation are done with the MFSimulation class's write_simulation and run_simulation methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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 example_model...\n",
      "    writing model name file...\n",
      "    writing package dis...\n",
      "    writing package npf...\n",
      "    writing package ic...\n",
      "    writing package sto...\n",
      "    writing package wel...\n",
      "    writing package oc...\n",
      "    writing package chd_0...\n",
      "    writing package rch...\n",
      "    writing package ts_0...\n",
      "    writing package obs_0...\n",
      "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.0.4 03/13/2019\n",
      "\n",
      "   MODFLOW 6 compiled Mar 19 2019 16:46:21 with IFORT compiler (ver. 19.0.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",
      " Run start date and time (yyyy/mm/dd hh:mm:ss): 2019/05/31 18:25:42\n",
      "\n",
      " Writing simulation list file: mfsim.lst\n",
      " Using Simulation name file: mfsim.nam\n",
      " Solving:  Stress period:     1    Time step:     1\n",
      " Solving:  Stress period:     2    Time step:     1\n",
      " Solving:  Stress period:     2    Time step:     2\n",
      " Solving:  Stress period:     2    Time step:     3\n",
      " Solving:  Stress period:     2    Time step:     4\n",
      " Solving:  Stress period:     2    Time step:     5\n",
      " Run end date and time (yyyy/mm/dd hh:mm:ss): 2019/05/31 18:25:42\n",
      " Elapsed run time:  0.031 Seconds\n",
      "\n",
      " Normal termination of simulation.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(True, [])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# write simulation to new location\n",
    "sim.write_simulation()\n",
    "\n",
    "# run simulation\n",
    "sim.run_simulation()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exporting a MF6 Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exporting a MF6 model to a shapefile or netcdf is the same as exporting a MF2005 model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote data/netCDF_export/botm.shp\n"
     ]
    }
   ],
   "source": [
    "# make directory\n",
    "pth = os.path.join('data', 'netCDF_export')\n",
    "if not os.path.exists(pth):\n",
    "    os.makedirs(pth)\n",
    "    \n",
    "# export the dis package to a netcdf file\n",
    "model.dis.export(os.path.join(pth, 'dis.nc'))\n",
    "\n",
    "# export the botm array to a shapefile\n",
    "model.dis.botm.export(os.path.join(pth, 'botm.shp'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading an Existing MF6 Simulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Loading a simulation can be done with the flopy.mf6.MFSimulation.load static method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loading simulation...\n",
      "  loading simulation name file...\n",
      "  loading tdis package...\n",
      "  loading model gwf6...\n",
      "    loading package dis...\n",
      "    loading package npf...\n",
      "    loading package ic...\n",
      "    loading package sto...\n",
      "    loading package wel...\n",
      "    loading package oc...\n",
      "    loading package chd...\n",
      "    loading package rch...\n",
      "WARNING: Block header for block \"continuous\" is not a unique block header ('example_model', 'rch', 'obs', 'continuous')\n",
      "  loading ims package example_model...\n"
     ]
    }
   ],
   "source": [
    "# load the simulation\n",
    "loaded_sim = flopy.mf6.MFSimulation.load(sim_name, 'mf6', 'mf6', sim_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Retrieving Data and Modifying an Existing MF6 Simulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data can be easily retrieved from a simulation.  Data can be retrieved using two methods.  One method is to retrieve the data object from a master simulation dictionary that keeps track of all the data.  The master simulation dictionary is accessed by accessing a simulation's \"simulation_data\" property and then the \"mfdata\" property:\n",
    "\n",
    "sim.simulation_data.mfdata[<data path>]\n",
    "\n",
    "The data path is the path to the data stored as a tuple containing the model name, package name, block name, and data name.\n",
    "\n",
    "The second method is to get the data from the package object.  If you do not already have the package object, you can work your way down the simulation structure, from the simulation to the correct model, to the correct package, and finally to the data object.\n",
    "\n",
    "These methods are demonstrated in the code below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get hydraulic conductivity data object from the data dictionary\n",
    "hk = sim.simulation_data.mfdata[(model_name, 'npf', 'griddata', 'k')]\n",
    "\n",
    "# get specific yield data object from the storage package\n",
    "sy = sto_package.sy\n",
    "\n",
    "# get the model object from the simulation object using the get_model method, \n",
    "# which takes a string with the model's name and returns the model object\n",
    "mdl = sim.get_model(model_name)\n",
    "# get the package object from the model mobject using the get_package method,\n",
    "# which takes a string with the package's name or type\n",
    "ic = mdl.get_package('ic')\n",
    "# get the data object from the initial condition package object\n",
    "strt = ic.strt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have the appropriate data object there are a number methods to retrieve data from that object.  Data  retrieved can either be the data as it appears in the model file or the data with any factor specified in the model file applied to it.  To get the raw data without applying a factor use the get_data method.  To get the data with the factor already applied use .array.\n",
    "\n",
    "Note that MFArray data is always a copy of the data stored by flopy.  Modifying the copy of the flopy data will have no affect on the data stored in flopy.  Non-constant internal MFList data is returned as a reference to a numpy recarray.  Modifying this recarray will modify the data stored in flopy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data without factor:\n",
      "[[[ 65.  60.  55.  50.  45.]\n",
      "  [ 40.  35.  30.  25.  20.]]\n",
      "\n",
      " [[100. 100. 100. 100. 100.]\n",
      "  [100. 100. 100. 100. 100.]]]\n",
      "\n",
      "Data with factor:\n",
      "[[[ 97.5  90.   82.5  75.   67.5]\n",
      "  [ 60.   52.5  45.   37.5  30. ]]\n",
      "\n",
      " [[100.  100.  100.  100.  100. ]\n",
      "  [100.  100.  100.  100.  100. ]]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# get the data without applying any factor\n",
    "hk_data_no_factor = hk.get_data()\n",
    "print('Data without factor:\\n{}\\n'.format(hk_data_no_factor))\n",
    "\n",
    "# get data with factor applied\n",
    "hk_data_factor = hk.array\n",
    "print('Data with factor:\\n{}\\n'.format(hk_data_factor))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data can also be retrieved from the data object using []. For unlayered data the [] can be used to slice the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SY slice of layer on row two\n",
      "[0.13 0.13]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# slice layer one row two\n",
    "print('SY slice of layer on row two\\n{}\\n'.format(sy[0,:,2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For layered data specify the layer number within the brackets.  This will return a \"LayerStorage\" object which let's you change attributes of an individual layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Layer one data without factor:\n",
      "[[65. 60. 55. 50. 45.]\n",
      " [40. 35. 30. 25. 20.]]\n",
      "\n",
      "Data with new factor:\n",
      "[[[ 71.5  66.   60.5  55.   49.5]\n",
      "  [ 44.   38.5  33.   27.5  22. ]]\n",
      "\n",
      " [[100.  100.  100.  100.  100. ]\n",
      "  [100.  100.  100.  100.  100. ]]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# get layer one LayerStorage object\n",
    "hk_layer_one = hk[0]\n",
    "# change the print code and factor for layer one\n",
    "hk_layer_one.iprn = '2'\n",
    "hk_layer_one.factor = 1.1\n",
    "print('Layer one data without factor:\\n{}\\n'.format(hk_layer_one.get_data()))\n",
    "print('Data with new factor:\\n{}\\n'.format(hk.array))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modifying Data\n",
    "\n",
    "Data can be modified in several ways.  One way is to set data for a given layer within a LayerStorage object, like the one accessed in the code above.  Another way is to set the data attribute to the new data.  Yet another way is to call the data object's set_data method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New HK data no factor:\n",
      "[[[120. 100.  80.  70.  60.]\n",
      "  [ 50.  40.  30.  25.  20.]]\n",
      "\n",
      " [[100. 100. 100. 100. 100.]\n",
      "  [100. 100. 100. 100. 100.]]]\n",
      "\n",
      "New strt values:\n",
      "[[[150. 150. 150. 150. 150.]\n",
      "  [150. 150. 150. 150. 150.]]\n",
      "\n",
      " [[150. 150. 150. 150. 150.]\n",
      "  [150. 150. 150. 150. 150.]]]\n",
      "\n",
      "New ss values:\n",
      "[[[3.e-06 3.e-06 3.e-06 3.e-06 3.e-06]\n",
      "  [3.e-06 3.e-06 3.e-06 3.e-06 3.e-06]]\n",
      "\n",
      " [[4.e-06 4.e-06 4.e-06 4.e-06 4.e-06]\n",
      "  [4.e-06 4.e-06 4.e-06 4.e-06 4.e-06]]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# set data within a LayerStorage object\n",
    "hk_layer_one.set_data([120.0, 100.0, 80.0, 70.0, 60.0, 50.0, 40.0, 30.0, 25.0, 20.0])\n",
    "print('New HK data no factor:\\n{}\\n'.format(hk.get_data()))\n",
    "# set data attribute to new data\n",
    "ic_package.strt = 150.0\n",
    "print('New strt values:\\n{}\\n'.format(ic_package.strt.array))\n",
    "# call set_data\n",
    "sto_package.ss.set_data([0.000003, 0.000004])\n",
    "print('New ss values:\\n{}\\n'.format(sto_package.ss.array))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modifying the Simulation Path\n",
    "\n",
    "The simulation path folder can be changed by using the set_sim_path method in the MFFileMgmt object. The MFFileMgmt object can be obtained from the simulation object through properties:\n",
    "\n",
    "sim.simulation_data.mfpath"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# create new path\n",
    "save_folder = os.path.join(sim_path, 'sim_modified')\n",
    "# change simulation path\n",
    "sim.simulation_data.mfpath.set_sim_path(save_folder)\n",
    "# create folder\n",
    "if not os.path.isdir(save_folder):\n",
    "    os.makedirs(save_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding a Model Relative Path\n",
    "\n",
    "A model relative path lets you put all of the files associated with a model in a folder relative to the simulation folder.  Warning, this will override all of your file paths to model package files and will also override any relative file paths to external model data files. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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 example_model...\n",
      "    writing model name file...\n",
      "    writing package dis...\n",
      "    writing package npf...\n",
      "    writing package ic...\n",
      "    writing package sto...\n",
      "    writing package wel...\n",
      "    writing package oc...\n",
      "    writing package chd_0...\n",
      "    writing package rch...\n",
      "    writing package ts_0...\n",
      "    writing package obs_0...\n",
      "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.0.4 03/13/2019\n",
      "\n",
      "   MODFLOW 6 compiled Mar 19 2019 16:46:21 with IFORT compiler (ver. 19.0.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",
      " Run start date and time (yyyy/mm/dd hh:mm:ss): 2019/05/31 18:25:43\n",
      "\n",
      " Writing simulation list file: mfsim.lst\n",
      " Using Simulation name file: mfsim.nam\n",
      " Solving:  Stress period:     1    Time step:     1\n",
      " Solving:  Stress period:     2    Time step:     1\n",
      " Solving:  Stress period:     2    Time step:     2\n",
      " Solving:  Stress period:     2    Time step:     3\n",
      " Solving:  Stress period:     2    Time step:     4\n",
      " Solving:  Stress period:     2    Time step:     5\n",
      " Run end date and time (yyyy/mm/dd hh:mm:ss): 2019/05/31 18:25:43\n",
      " Elapsed run time:  0.036 Seconds\n",
      "\n",
      " Normal termination of simulation.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(True, [])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Change path of model files relative to the simulation folder\n",
    "model.set_model_relative_path('model_folder')\n",
    "\n",
    "# create folder\n",
    "if not os.path.isdir(save_folder):\n",
    "    os.makedirs(os.path.join(save_folder,'model_folder'))\n",
    "\n",
    "# write simulation to new folder\n",
    "sim.write_simulation()\n",
    "\n",
    "# run simulation from new folder\n",
    "sim.run_simulation()   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Post-Processing the Results\n",
    "\n",
    "Results can be retrieved from the master simulation dictionary.  Results are retrieved from the master simulation dictionary with using a tuple key that identifies the data to be retrieved.  For head data use the key\n",
    "\n",
    "('&lt;model name&gt;', 'HDS', 'HEAD')\n",
    "\n",
    "where &lt;model name&gt; is the name of your model. For cell by cell budget data use the key\n",
    "\n",
    "('&lt;model name&gt;', 'CBC', '&lt;flow data name&gt;')\n",
    "\n",
    "where &lt;flow data name&gt; is the name of the flow data to be retrieved (ex. 'FLOW-JA-FACE').  All available output keys can be retrieved using the output_keys method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('example_model', 'CBC', 'STO-SS')\n",
      "('example_model', 'CBC', 'STO-SY')\n",
      "('example_model', 'CBC', 'FLOW-JA-FACE')\n",
      "('example_model', 'CBC', 'WEL')\n",
      "('example_model', 'HDS', 'HEAD')\n"
     ]
    }
   ],
   "source": [
    "keys = sim.simulation_data.mfdata.output_keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The entries in the list above are keys for data in the head file \"HDS\" and data in cell by cell flow file \"CBC\". Keys in this list are not gaurenteed to be in any particular order. The code below uses the head file key to retrieve head data and then plots head data using matplotlib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# get all head data\n",
    "head = sim.simulation_data.mfdata['example_model', 'HDS', 'HEAD']\n",
    "# get the head data from the end of the model run\n",
    "head_end = head[-1]\n",
    "# plot the head data from the end of the model run\n",
    "levels = np.arange(160,162,1)\n",
    "extent = (0.0, 1000.0, 2500.0, 0.0)\n",
    "plt.contour(head_end[0, :, :],extent=extent)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Results can also be retrieved using the existing binaryfile method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAD8CAYAAABpcuN4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xlwm2ee4PfvA4AACYDiTYqX7vuWrFtyW750+JDknplsd5JtV2+nvJXqTmZSUzvVPZukJzs1VZtkdyaZqknXenZ6p3sz6U5nWpZkt0VZVlu2SUqyqIOSeOkWCd7gDYDE+eQPgmO2LUvPC+sAqN+nikXixfMAD17D70/vc/wepbVGCCGE+Cq2J90AIYQQ6U0ChRBCiPuSQCGEEOK+JFAIIYS4LwkUQggh7ksChRBCiPt6YKBQSlUrpT5SSrUopZqUUn+YPP5nSqlOpdSl5M8r0+r8SCl1QynVppTaM+343uSxG0qpHz6ajySEEOJhUg9aR6GUKgfKtdYXlFK5wHngIPBfAAGt9b/7QvkVwC+AzUAF8CGwJPn0NeBlwAecA76ttW5+eB9HCCHEw+Z4UAGtdTfQnfx7TCnVAlTep8oB4Jda6zBwWyl1g8mgAXBDa30LQCn1y2RZCRRCCJHGHhgoplNKzQPWA2eBHcAPlFLfARqAP9ZaDzEZRM5Mq+bj88DS8YXjW+7xHm8BbwF4PJ5nli1b9jvPRyMx+rqHKZmdh9OVZdTu/sEACigu9BqVjyUSdA6MUJrnJcdp+B6hILFEgnJvrlH5hNa0Bwcpyc7F43Aa1RmLjhFORCh2FRmVB00g2oHLXkiWzeyzCyEy3/nz5/1a65KH9XrGgUIp5QV+DfyR1npUKfUT4M8Bnfz974F/Aah7VNfcezzkS/1eWuu3gbcBNm7cqBsaGn7n+Z//zYf88m8/5ufH/xXFZbMe2O5wOMr+/+YnPLt5Ef/jf/fKA8sD/OdPLvC/HfmYw//qOyyc/eCLcjyRYOd/+ltWlpTyH/e/YfQeh9sb+dH5w/zfz36XZ4rnPLC81po/vfo/47a7+Z9W/MjoPXpDZ6jr/m/ZUva/U+l9yaiOECLzKaXuPszXM5r1pJTKYjJI/IPW+hCA1rpXax3XWieAv+Xz7iUfUD2tehXQdZ/jxhKJBB++e4l1WxcaBQmAT8/dJBiKsG/XKuP3OXqumZXVZUZBAqC+o53eYIBvLl9p/B5H2huZ4ylgQ1H1gwsDd4J36RrvYmfxduP38AVqcCgPs907jesIIcQXmcx6UsDfAS1a67+cdrx8WrE3gKvJv48C31JKuZRS84HFwGdMDl4vVkrNV0o5gW8lyxq70nCHvq5hXn59vXGd9z+6SllxLutXml2Q27r6ae3qZ//GFcbv8Y8tTeS5snlx/gKj8p2hYc7032b/nLVMnt4H+9RfR5ZysLlwk1H5uI7QFTxJhed57LZsozpCCHEvJl1PO4B/DlxRSl1KHvtT4NtKqXVMdh/dAf4lgNa6SSn1KyYHqWPA97XWcQCl1A+A44Ad+KnWuslKY08cvYjb42LbC8uNyvsHAzRcvst//cYWbDazC/KRc8047DZeWb/UqPxoOMwHN2/w+ytW4nKY9eQdbb8MwMHqtUblo4koZwbOsqFgPR6H26hOb6iOaCJAde4+o/JCCPFVTGY91XLvcYf371PnL4C/uMfx9+9X737GQ2FqTzTx3N7VZOeYDf4e/6SZREKzd5fZ3UE0Huc3F1p5bsUC8j05RnWOXW8jHI/xe4bdTlprjrQ3sql4LpWefKM6jcOXCcaD7CjeYVQeoGPsGC5bASU5mx9cWAgh7iNjVmbXfdjMxHiEl/ebdTtprTn2UROrllYwp6LQqE59210GAyFL3U6/bm1mQUEBa8tmG5W/NOjjbnCQg3PM7iYAav315GXlsSrPMOAlgnSHPqHS+zI2ZWlimxBCfEnGBIoPj16kvKqAlRvmGpVvu9nLHd8Ae3dZGGA+10yBJ4dnl80zKn93eJiGrk6+uWyl8VjD4fZL5Niz2FNhdtEfjY5xeeQK24u2Yld2ozrdwVMkdJhqr3Q7CSG+vowIFH3dwzSeu81L+9cbX5CPnWrCmWXnxR1mYw0joQlONd3ilQ1LyXKYXZAPtTahgDeWmV30J+JRjnU28VLFcjxZLqM6ZwbOENdxS7OdOgI15DhmU5i9xriOEEJ8lYwIFCffvYTWmhcNZztFo3E+rG3l2c2LyPWYzfipudRGNB7nwEazO5CE1rzT2syO6rmU55otsvttdxtj0TBvWOx2mueeS5W7yqh8OD5EX+gM1d69KJUR/3mFEGku7a8kWms+fPciqzfOY3ZlgVGd+gu3GBkbt9TtdPRcM4vLi1lWabaY8VynD9/oqKW1E4fbGynPmcWWkvlG5TtCPu6G2tlpYRC7M/AhmhhV3r3GdYQQ4n7SPlC0NHbQeXfAeBAboOajJoryPWxaO8+o/K3eQS6393Bg4wrjrq1ftzbhzXKyZ+Eio/J9E2PU9d5kf/UabIbvUeuvw67sbC0yn7nkC9SQmzWfPOeSBxcWQggDaR8oThy9gCs7i50vm62sHhoJUX/hFru/sRyH3ezjHW1oxm5TvLph2YMLA6FolGPXr7Fv8RJyssxyQb3bfpkEmgOG3U5xHef0wBnW5q8hN8usaysU68E/cZEq717jgCeEEA+S1oFCa80nx6+y46UVuD1mg78nPm0hHk+w73mzLqF4IsG751vYvnQexbM8RnWO37hOMBq1tHbicHsjawuqmJ9bbFTnyshVRqKjFlN2fABoqnOl20kI8fCkdaAIjE0QHJvgJSvdTqeaWLKgjAVzzMYazl7voG8kwP6NZqu9YbLbqXpWHhsr7pdt/XPNw93cGOvn4Fxrg9heh5e1eeYzl3xjNeS7VuDNenCSQSGEMJXWgWJsOETJ7DzWbjLLoXTzbj/Xbvexz8ogdkMzuTkunl+50Kh819gopzvaeWPZCuOxhsPtjThtdvZVmrUrGAtycegS24q24LCZLZgbi9xlONIiayeEEA9dWgeKYCDMi6+tw2441nDsVBN2u42XdpqNNQQmwpy8coO965bgyjK7IL/T2oIGvrncbO1EJBHnPd8VXihfSp7TLC3I2cFzxHSMHRYzxYKiyrvbuI4QQphI60BRNbeIV/7ALFtqLJ7gg0+a2f7MAgryzBLnnWi8zkQ0xoFN5mMNh1qa2FxRxZw8szxNn/RcZzgyzsE564zKA9T211GVU8k8t9kqdK01HYFjFGc/Q46j1Ph9hBDCRFoHihyPi9JyswvyuUt3GBwOWep2OtLQzLySAtbMMczT1NPN7eEh47sJmOx2KnZ52VFq1rXVPd7DzeAtdhRvN565NBxpJRC9K4PYQohHIq0DhRXHTjWRl5vDtg1m4xm+gRHO3+pkv6W1E81kOxzsW2S2RmEoHOKTnmu8Xr0ah83sVNf561EothdtNSoPk4PYCgcVnheN6wghhKkZEShGAxPUnrvBy88uIyvLLE/Tuw3NKAWvP2M22ykci/HetVb2LFxMrstsqu5vfFeI6oRxptiETlA3UM/qvFXkO83upLRO4Ascp8y9HZfdrI4QQlgxIwLFb+taiUTjxik7EgnNkYZmNi+qZnaB2WK2D2/dZDQcttTt9E57I8vzZrMkr8yofMtoK4ORIUtrJwYmLjIe76VaUnYIIR6RGREojp1qYn51EUsXmF2QL9zupHNwlAOW9p1oYrbHy/YqszUK10b7aB7utrjvRB1uew7rC8zXjXQEarCrbMo9zxnXEUIIKzI+ULR3DtJ0rZt9u8z3hDja0IzblcWLqxcble8PBvn07h0OLluB3XCs4cjdSziUjdeqVxuVH4+P0zB0gc2Fm3HazNKCJHSUzsCHlHuew2Ezm+klhBBWZXygOHaqCZtNsfs5s7uD8UiUDxqv8/KaxbhdZhfkI20txLXm9wy7nWKJBEc7rvCNssUUuszSgpwbPE8kEbHU7dQXOkMkMSyZYoUQj1RGB4pEQnP8k2Y2r51HcYHXqM7JKzcIhiPG3U5aa37d0sTastksLCwyqlPfdxN/OGCcABAmZzuVucpY5DWbRgvQEThOli2XMrd5cBFCCKsyOlBcuNpOn3/MOAEgTHY7VRbO4pkFZhsBNff30TbgN04ACJNrJ/KdOewqN5tG2x/up3WsjZ0l5msnYolxuoMfUeF5EbtyGrdNCCGsyuhAcexUE163i52bzPaE6Bke48z1dl5/Zjk2m/naCafNzmtLzLZUHY1McLK7lVerVuG0mU3VrfOfRqHYUbTNqDxAT6iWmA5JbichxCOXsYEiNB7h4zPXeGHHUlxOszxN751vQWvYb9jtFInHOdrawosLFpKfbZanqaaziUgibpyyQ2tNrb+e5bOWUuQy69oC6AgcI9teTEnOM8Z1hBAiFRkbKD463cZEOGacskNrzZFzzWyYX0F1sdnCtI/v3GZwYtzi2olLLMwtYWV+uVH5a4Hr9If72WFhu9NIfIzeYC2V3t0oZXbXIoQQqcrYQHHsVBNV5QWsWlphVP5Kew93+oeM7yZgcu1EUY6bb8yZZ1T+9tgAlwZ9HJyz1nisodZfj8vmYmPBBuN2dQV/S4KoLLITQjwWGRkounqHudTkY+8u8zxNRxuacTns7F5rmKdpfJyPbt/iwNLlZNnN/tV+pKMRG4r91WabDYXjYT4bOMemwmfItmcb1YHJlOIeRxUFLrPtYYUQ4uvIyEBx/ONmAPZ+w3CsIRbj2MU2Xli9iNwcszxN715rJZpIGK+dSGjN0fbLbC9dQGmOWVqQC0MXmUhMsNNCt9NEzE/f+GeyL7YQ4rHJuEChtabm42aeWT2H2aV5RnVONd1idDxsLWVHSxPLi0tYXmK2v8Nn/jt0j49YTNlRT7GziKW5Znc5AJ3BE0BCUooLIR6bjAsUl1s76ewZNk4ACJPdTqWzPGxdYpan6frAAFf6eq2tnbjbiNfh4sUKs931BiNDNI02s714GzZl/p+hY6yGWc7FzHKaL8wTQoivI+MCRc2pJnKys3hui1meJv9YkNrWO7z2zHLjPE2/bm3CYbOxf6lZCvJgLMKJrmb2Va0k226WFuS0/zQabSllRzDayWD4sgxiCyEeq4wKFOFwlN/Wt7Fr6xLcOWarkd+/0EY8oTmwyazbKZ5IcKS1hefmzqPYbbilamczoXjUuNtpau3EYu8iyrLNMt7C1L7YSG4nIcRjlVGB4pPPbhAMRSxtd3q0oZlV1WUsKDNbzFbX0U5vMMA3LabsmOMpZH1htVH528E7dE10W7qbgMncToWuNXiyzKYECyHEw5BRgeLYR03MLpnFupVmF+TWzj7auvotrZ34x5ar5LmyeWGe2ZaqncFhzvrvcGDOGgtrJ+rIUllsLtxk3K7RyE1GI9dlEFsI8dhlTKDoHxij4cpd9jy3wjhP05GGZhx2G/vWG+ZpCoc5cfMmry9ZisthlhbkSEcjAAeqzbqdookoZwbOsqFgPW6H+R4SHWM1gI1Kz27jOkII8TBkTKA4/kkziYRm73NmXULReJz3L7Sya8UC8j1meZrev95GOB4znu2kteZI+2U2F8+j0mOWFuTScCPBeMhSt5PWGl+ghtKczWQ7zPNBCSHEw/DAQKGUqlZKfaSUalFKNSml/jB5vFApdUIpdT35uyB5XCml/lopdUMpdVkptWHaa72ZLH9dKfWmaSO11tScamL10gqqKwqM6tS13mEwMG4tZUdLEwsLCllTNtuo/MXBDtqDg5bXTuRn5bEqz3wMZCh8lWDMJ4PYQognwuSOIgb8sdZ6ObAV+L5SagXwQ+Ck1noxcDL5GGAfsDj58xbwE5gMLMCPgS3AZuDHU8HlQVpv9nDHN8i+581TVhxtaKbQm8PO5fOMyt8ZHuJ8dxffXG6eFuRweyM59ix2V5hNox2NjnJl5CrbiyyunQjUYFNOKj0vGNcRQoiH5YFXK611t9b6QvLvMaAFqAQOAD9LFvsZcDD59wHg53rSGSBfKVUO7AFOaK0HtdZDwAnA6J/Ixz5qwul08MJ2s7GGkdAEp5pu88qGZcZ5mt5pbcamFG8sM7sDmYhHOeZrYnfFCjxZZmlBTg+cJa7j7LDU7RTHF/iA2e6dZNnNUoMIIcTDZGmMQik1D1gPnAXKtNbdMBlMgKlcF5VAx7RqvuSxrzr+xfd4SynVoJRq6O/vJxKN8WFtK89uWoTXY3ZBPnaxjWg8bpyyI6E1h1qa2VE9h9les4vxye42ArEwB+da6XaqY75nHlXuL33sr9Q/3kA47pduJyHEE2McKJRSXuDXwB9prUfvV/Qex/R9jv/uAa3f1lpv1FpvLCkp4fT5W4wGJixvd7qkvJhllYZ5mjp9dI6NWlo7caS9kfKcPDYXzzMq3x7qoD3UYeluAia7nRzKTbn7WUv1hBDiYTEKFEqpLCaDxD9orQ8lD/cmu5RI/u5LHvcB0xc6VAFd9zl+X8dONVFU4GHTmrkmTeVW7wBX2nvYb7gSGyYHsb1ZTnYvMNtStW98jLrem+yfswab4XhGnb8eu7KzrXCLcbviOkJX8CQVnuex28zTkAshxMNkMutJAX8HtGit/3LaU0eBqZlLbwJHph3/TnL201ZgJNk1dRzYrZQqSA5i704e+0rxeILTF26z5xsrsNvNbn6OnGvGblO8usEsOV8wEuHYjWu8sngJOVlmeZqOdlwmgTZeOxFLxKj3n2Fd/lq8WV6jOgC9oXqiiTHpdhJCPFEmq8p2AP8cuKKUupQ89qfAvwV+pZT6HtAO/EHyufeBV4AbQAj4LoDWelAp9efAuWS5f6O1HrzfG48GJvDEE8aZYuOJBO+db2HH0nkU53qM6hy/eZ1QNGrc7aS15nB7I+sKq5ifa7am4epIE6OxUcspO3yBYzht+ZS6ze9ChBDiYXtgoNBa13Lv8QWAF+9RXgPf/4rX+inwU9PGjYyNs2thGQvmFBuVP3u9g77RIH9y0Eq3UzNzZuWxqcJsgLlpuJubY/382bpXjd+j1l9HrsPLmrzVxnViiRDdwU+Yk/saNmV2pyOEEI9CWq/MjkTjvGIhAeCRc83k5rjYtcIwT9PYKGd87bxhae3EJZw2O/sqzdZ0BGIBLg43srVoCw6bWVoQgO7gx8T1BNXefcZ1hBDiUUjrQLFoXgmvvGB4QZ4I89urN3hl/VJcWWYX5MOtzWjgm8vMglEkEec3vqu8UL6MWU6zweWzA+eI6Zil7U5hcrZTjr2Moux1luoJIcTDltaBwqYUOdlm+0580HidiWjMOGWH1ppftzSzpbKK6jyzLVU/7rnGcGScNyyk7Kjz11OVU8Vct9nuegDh+DC9oXqqvHtQFlZwCyHEozBjrkJHGpqZV1LA6jmGeZp6urkzPGR57USxy8v2UrNtSLvHe7gZvMXO4u3GXVsAXcGTaGJUSUpxIUQamBGBomNgmAu3OjmwyXys4dctTeQ4HOxbtMSo/GA4yMc919lfvRqH4Zaqtf46bNjYVrTVqPyUjrEavFnzyHeaTfEVQohHaUYEincbWlAKXnvGLDlfOBbjvWtt7Fm4GK/TrGvrN76rxHSCA3PNxgwSOkH9wGlW560k32nWtQUwHuvDP3Geau9eS3chQgjxqGR8oEgkNEcbmtmyaA6z883yNJ24dYOxSNhSt9M7dy+xIr+cJbPM0oI0j7YwGBlih8VBbF/gOKBlkZ0QIm1kfKA4f7uTzsFRiyk7min3etlWZbal6rWRXlpGeizvO+G2u1lfYG3WUkeghnzncnKdZilLhBDiUcv4QHH0XDNuVxYvrjLM0xQM8Gn7HQ4uW4HdcKzhcHsjDmXj1Sqzqbrj8XHOD11gS+EmnDbzxXKByF2Gw82yL7YQIq1kdKAIhaN8cPkae9Yuwe0yuyAfaWshobXxdqexRIJ3Oy7z3OzFFLrM0oKcG2wgkohYTtnREagBFJXePZbqCSHEo5TRgeLk1RuEwlHLayfWzy5nQUGhUZ26vpv4w0EOzjHvQqr11zM7u4yFXrNptFNt8wWOU5y9HrejzLieEEI8ahkdKI6ea6aycBYb5hvmaerv49qA39Ig9uH2RvKdOXxj9mKj8v3hftrGrrGzeIelWUsjkWuMRW/LILYQIu1kbKDoGRrj7I129m9cgc1mdkE+1NKE027ntcWGW6pGxvltdyuvVa3GaTPbUrXWX49Csb1om1H5Kb5ADQoHld6XLNUTQohHLWMDxXsXWtAaXt9otnYiEo9ztK2Vl+YvJC/bLE9TTWcTkUTceLZTQieo89ezfNYyilxmXVsAWifoCNRQ6t6Ky15gXE8IIR6HjAwUWmuOnGtmw4JKqovyjeqcunOLwYlxi2snGlmUW8KK/HKj8tfGrtMf9lsexB6YaGQ81kO1dDsJIdJQRgaKy+093Okf4oDhIDbAoZZmit1uvjF3nlH522N+God8HJyz1nisoc5fT7bNxcaCZ4zbBZPdTjblotyzy1I9IYR4HDIyUBw910x2loPda80GmAfHQ3x05xYHli43ztN0pL0RG4rX56wxKh+Oh/lssIGNhRtx2V1GdQASOkpn4ATl7ufIsplNvxVCiMcp4wJFOBrj2KU2Xli1CG+22QX53WutRBMJ426nhNYc7bjMjrKFlGabpQU5P3SRicSE5W6nvvHPCCeGZJGdECJtZVygONV8i7HxMAcspuxYWVLK8uISo/Jn+2/TPT7KAUspO+oodhaxNNcsG+0U31gNWTYvZW5rOaGEEOJxybhAcfRcM6V5XrYsNszTNODnal+v5bUTuVkuXiw3m0Y7GBmkebSFHcXbsVnYaCiemKAr+BEVnhexK7MstkII8bhlVKDwjwWpa7vD688sN87TdKilCYfNxv4lZns7BKNhTnS1sK9yJdl2s7Qg9f4zaDQ7LHY79YRqiemgzHYSQqS1jAoUv7nQSjyhjVN2xBIJDre1sGvufIrcbqM6H3S1MB6PGqfs0FpT669niXcxZdlmKcindASO4bIXUZKzyVI9IYR4nDImUEytnVg9ZzYLygzzNLXfpS8YtNztNNdTyLrCKqPyt4K36Z7otnw3EY2P0ROqpcr7MkqZrfoWQognIWMCRWtnP9e7/cZ3EzC53Wl+djbPz5tvVN4XHOIz/x0OWFg7UeuvI0tlsblwo3G7ALqCH5HQEcntJIRIexkTKI42NJNlt7NvvdkA82h4gg9u3eD1JctwORxGdY50XAZgv+HaiWgiytmBz3imYANuh1nX1pSOwHHcjgoKXWbvJYQQT0pGBIpoPM77F1vZtXI+eW6zPE2/uX6NSDxu3O2kteZoeyNbiudR6TZLC3JpuJFgPGR57cREbJD+8bNUyb7YQogMkBGBorblDoOBcQ5sMh9rONTSxKKCQtaUmu3tcGGgg/bgkOXtTvOz8lmZZ94dBtAZPIEmLrOdhBAZISMCxdGGZgq9brYvNdtH+vbwEOe7u/i9FSuN/8V+uP0SbnsWL1eaXfRHoiNcHr7C9uKtltZOwGRup1nOReS5zFKQCCHEk5T2gWI4OM6p5lu8umEZWXaz2UHvtDRjU4qDS80u+hPxKDWdzeyuXIHHYbbw7fTAWRIk2FlsbUV1KNrFwMQlGcQWQmSMtA8Uxy62EYsnjFN2JLTmUGsTO6vnUub1GtU52dVKIBa21O1U569nvmc+lTkVxnVgchAboFr2xRZCZIi0DxRHG5pZWlHC0grDPE2+DrrGxvjmcvNxg8PtjVS489hUPM+ofHuog/ZQh+VBbJjsdipwrcaTZbZOQwghnrS0DhThaIyrHb2W1k4cam3G63Sye+Eio/K946PU991if/UabKZrJ/rrsCs7Wws3G7cLYDRyi5HINRnEFkJklLQOFMOhCew2xSsbzNZOBCMRjt24xquLl5LtMMvTdLTjMgm0cabYWCJG/cAZ1uevxZtl1rU1xReoAWxUeXdbqieEEE9SWgeKkeA4O5fNozjXbEOfmpvXCUWjxt1OWmuOtDeyvrCaed4iozpXRq4yFhtjh8VBbK01HWM1lORsJNtRbKmuEEI8SQ8MFEqpnyql+pRSV6cd+zOlVKdS6lLy55Vpz/1IKXVDKdWmlNoz7fje5LEbSqkfmjTOleXgoMW1E3Pz8tlYXmlU/upwFzfH/JbXTuQ6clmTt8q4DsBQuJlgrEO6nYQQGcfkjuLvgXtd3f5Ka70u+fM+gFJqBfAtYGWyzv+llLKryax3fwPsA1YA306Wva+5JQW8tMZsrUHn6CinfR28sWyFhbUTjThtdvZWmgWjQCzApeFGthVtwWEzSwsyxRc4ho0sKjwvWqonhBBP2gOvdlrrT5RS8wxf7wDwS611GLitlLoBTI343tBa3wJQSv0yWbbZcou/wjutky9l2u0Uicf4TcdVXqpYziynWVqQswOfEdMxy2sntI7jC3xAmXsHTvssS3WFEOJJ+zpjFD9QSl1Odk0VJI9VAh3TyviSx77q+Jcopd5SSjUopRr6+/uNGqK15lBrM1srq6malWdU51TPdUai45a7napzqpjrmWNcB8A/cYGJeL/siy2EyEipBoqfAAuBdUA38O+Tx+/V56Pvc/zLB7V+W2u9UWu9saTEbO3EhZ4u7gwPWVo7caS9kZJsL9tLFxiV7xrv5lbwdkprJzrGarCrHGa7v2G5rhBCPGkpBQqtda/WOq61TgB/y+fdSz5g+mbWVUDXfY4/FIdamslxONi7aIlR+cFwkE96r/N69Rrshnmaav312LCxrXirpbYldJTO4IdUeJ7HYcuxVFcIIdJBSoFCKVU+7eEbwNSMqKPAt5RSLqXUfGAx8BlwDlislJqvlHIyOeB9NPVmf24iFuW9a23sXbQEr9MsT9N7HVeI6YRxt1NCJ6j3n2Z13iryssy6tqb0hk4TTYxKbichRMZ64GC2UuoXwC6gWCnlA34M7FJKrWOy++gO8C8BtNZNSqlfMTlIHQO+r7WOJ1/nB8BxwA78VGvd9DA+wIlbNxmLhC2n7FiZX87iWWZ7XDeNNjMUHeK/LPlnltvXETiG05ZHmdvanYgQQqQLk1lP377H4b+7T/m/AP7iHsffB9631DoDh1qaKPfmsq3KbIC5baSXlpEe/vUa83/h1/mHkRx0AAAY0klEQVTrcdvdrMtfZ6ltscQ43cFTVOe+ik2ZrRQXQoh0k9Yrsx+kNxDg0/a7vLFshXGepsPtl8hSNl6tWm1Ufjw+zvmhi2wp2ozTZu1i3x38mLiekEV2QoiMltGB4khbCwmtjbudYokE73Vc4Ruzl1DgMtvj+rPBBiKJSMqZYrPtpRRnb7BcVwgh0kXGBgqtNYdamtgwu5wFBYVGdWr7buAPB3nD0tqJOsqzZ7PQYzaNdkokPkJPqI4q726UxR3whBAinWTsFexqfx/XBgf45nLzXFBH2hspcLp5drZZWpC+iX6ujV1nR/F247QgUzqDJ9HEpNtJCJHxMjZQHGppwmm389oSsxTkI5FxTna38Vr1Kpw2sy1V6/z1KBQ7irdZbp8vcBxv1hzyXeazsYQQIh1lZKCIxOMcbWvh5QULmeUyy9N0rLOJaCLOgTlmM5cSOkHdQD0rZi2n0GnWtTVlPNZP//g5qrx7Ld+JCCFEusnIQPHRnVsMTUxY6nZ65+4lFs8qZUXebKPy18au0x/2syOFQezOwAeAlm4nIcSMkJGB4lBLEyVuD8/OmWdU/vaYn8tDnRycs9b4X/i1/jqybS42FlifsdQRqCHPuZRc53zLdYUQIt1kXKAYCIX46M5tDixdhsNm1vzD7Y3YULxWbbZ2IhwPc26wgU2FG3HZXZbaF4h2MBS+SrV3n6V6QgiRrjIuULx7rZVYImHc7RTXCY52XGZH2UJKs3ON6jQMXWAiEba87wRM7YuN7IsthJgxMi5QHGppYlVJKcuKzVKQn+2/Q8/4KG8YDmLD5GynElcxS3LNptFOmdoXuyh7Pe6s8gdXEEKIDJBRgaJtwM/V/j5Lg9iH2xuZlZXNC+Vm02gHwoM0j7awo2g7NosL5UYj1xmL3pJMsUKIGSWjAsWhliYcNhuvL1lmVD4YDfNhVwv7KlfispvtcV0/cBqNTmm2U0egBoWdKu9LlusKIUS6yphAEUskONzawvPz5lPkNsvTdLyrmfF4lAOGKTu01tT561mSu5jSbLOurel1fYEaSnO24LJbW3chhBDpLGMCRW37XfpDQcvdTnM9hawrrDIqfyt4m+6JnpQGsQfDjYRi3VTJvthCiBkmYwLFr1uuUpCdzfPzzJLz+YJDnPPf5eBc87UTn/rrcNqcbC7caLl9HWM12JSLCs/zlusKIUQ6y4hAMTIxwYlbN3l9yTKcdrM8TUfaG1HA/mqzbqdIIsrZgc94pmA9OXZre1sndIzO4AnK3c+SZfNaqiuEEOkuIwLFb663EYnHjbudtNYc6bjMlpL5VLjN9ri+NHyJUDyU0iB2//g5wvFBme0khJiRMiJQHGppYklhEatLy4zKnx9opyM4ZDyIDVDbX09BVgErZ1nP9toRqMFh8zLbvdNyXSGESHdpHyhuDQ1yoaebby5faTzWcLi9EbfDye6K5UblR6IjXBm5yvbibZbXTsQTYbqCv6XC8wJ2m7V0H0IIkQnSPlC809qMTSkOLjO76I/HotR0NrGnYgVuh9Oozmn/GRIkUtrutCdURywRkEyxQogZKyMCxbNz5lLqMRskPtndSjAW4aCl7U7rWeCZT0WO9bQbvsAxXPZCSnI2Wa4rhBCZIK0DRSASoWtszPLaiQp3HhuL5xqVvxtsp2Pcl9LdRDQRoDv0KZWel7Eps5XfQgiRadI6UAxPjJPrdPHygoVG5XvHRzndd4sD1WuxGe87UY9DOdhStNly+7qDp0joMNWyyE4IMYOldaAYCYd5dfESsh1ZRuWPtl8mgTae7RRLxDg9cIZ1+WvxOqyvf+gI1OB2lFPoMu/mEkKITJPWgaLU4+Hbq83zNB1ub2RDYTVzvWa5li6PXGUsNpZSt1M4Pkhf6AxV3j2yL7YQYkZL60BR4vYYr524MtTFrYDf0tqJOn8duY5cVuetsty2zsCHaOKyyE4IMeOldaCw4nD7JVw2B/uqzAa+A9EAF4cb2Va0FYfN+kB0R6CG3KwF5DmXWK4rhBCZZEYEikg8xvu+q7xUsYzcrGyjOmcGPyOu4zxbYj1TbCjWw8DERapz90q3kxBixpsRgeJUzzVGohOW107McVczx11t+f18Y8cBqPLusVxXCCEyzYwIFIfbGynNzmVbqVkK8q7xLm4Hb6eUABAmu50KXCvxZs1Jqb4QQmSSjA8UA+Egn/be4PXq1dgN8zTV+uuxYWNb0RbL7zcWucNIpJVq7z7LdYUQIhNlfKB4r+MKMZ3g4Jx1RuUTOkGd/zRr8leTl2WWgny6jkANoKj0vmy5rhBCZKKMDxSH2y+xKr+CRbPM9rhuGmlmODqc0tqJyX2xj1GSvZEcR6nl+kIIkYkyOlC0jvTQOtJreRDbY3ezLt/6aurhSAuBaLvsiy2EeKo8MFAopX6qlOpTSl2ddqxQKXVCKXU9+bsgeVwppf5aKXVDKXVZKbVhWp03k+WvK6XefBiNP3y3kSxl45UqswVzoViI80MX2FK0mSybWVqQ6XxjNSgcVHpetFxXCCEylckdxd8DX/wn9A+Bk1rrxcDJ5GOAfcDi5M9bwE9gMrAAPwa2AJuBH08Fl1RFE3He811hV/lSClxuozqfDTYQ1VF2FltfO6F1go7Accrc23HarY9tCCFEpnpgoNBafwIMfuHwAeBnyb9/BhycdvznetIZIF8pVQ7sAU5orQe11kPACb4cfCyp7b3JQDhoqdupzl9PeXY5CzzzLb+ff+ICE/E+2aBICPHUSXWMokxr3Q2Q/D01slsJdEwr50se+6rjX6KUeksp1aCUaujv7//KBhxpb6TQ6ebZskVGDe6d6ONa4Do7i7entJraF6jBrrIp9+yyXFcIITLZwx7MvtcVWN/n+JcPav221nqj1npjScm9ZzINR8b5bU8br1avJstmN2pYnb8ehWJ78Vaj8tMldJTOwEnKPbtw2HIs1xdCiEyWaqDoTXYpkfzdlzzuA6bnxKgCuu5zPCXHfFeJJuLG3U5TaydWzFpOodMsBfl0faEzRBLD0u0khHgqpRoojgJTM5feBI5MO/6d5OynrcBIsmvqOLBbKVWQHMTenTyWksPtjSyZVcryvNlG5dvGruGP+FMaxIbJRXZZtlmUuVNL+SGEEJnsgfm1lVK/AHYBxUopH5Ozl/4t8Cul1PeAduAPksXfB14BbgAh4LsAWutBpdSfA+eS5f6N1vqLA+RGbo35uTzUyZ+setl4rKHWX0+2LZtnCtZbfr9YYpyu4EdUe/diU9an1AohRKZ7YKDQWn/7K5760mICrbUGvv8Vr/NT4KeWWncPh9svYVeK16rXGJUPx8M0DDawuXATLrvL8vv1hD4lrsepzpXcTkKIp1NGrcyO6wRH2y+zs3QRJdlme1w3DJ1nIhH+Wplis+3FFGdveHBhIYSYgTIqUJzpv03vxBgH51pL2VHiKmFJ7mLL7xeJj9EbrE3ui202u0oIIWaajAoUR9obmZWVzfOzlxqVHwgP0jLayo7ibdgMU5BP1xU8SYKo7IsthHiqZUygCETDnOhqYV/VSlx2sz2u6wdOo9EpZYqFyUV2Hkc1BS6zfbiFEGImyphAcbyzmYl4zHjfCa01tf46luYuocRlloJ8uomYn77xc1Tl7pF9sYUQT7WMCRSH2xuZ5y1ibcE9M398yc3gLXomer/G3cQHQEIW2QkhnnoZESg6gkM0DNzl4Jy15msn+utw2pxsKtyY0nv6AjXkORczy7kwpfpCCDFTZESgONLeiAL2G66diCSinB08xzMFG8ixW8/NFIz6GAxfoUr2xRZCiPQPFAmtOdLeyJaS+ZS7zfaBuDh0iVA8lHK3U0dgMrtItXdPSvWFEGImSftAcX6gHV9omDcMB7EB6vx1FDoLWDFreUrv6QvUUJi9FndWRUr1hRBiJkn7QHG4/RJuh5OXKpYZlR+OjHBlpIntRamtnRgJ32A0coNq6XYSQgggzQNFQmuOdzazt2IFbofTqM7pgTMkSKScKdYXqEFhp9Lzckr1hRBipjFbufaEjEUncMQiHDBM2TG5dqKehZ4FlOeYpSD/Yv2OQA0lOZvJdljft0IIIWaitL6jGIqEqHTns7ForlH59lA7vnFfygkAh8JXCMU6Ze2EEEJMk9aBIhgLc2DOGmwW9p1wKAdbijal9H4dgRpsykmF5/mU6gshxEyU1oFiQW4J/2ye2YK5WCLG6YEzrM9fi9dhloJ8Oq3j+AIfMNu9kyx7ruX6QggxU6V1oMixZ1GaY3bRvjxyhbFYIOVB7P7xc4TjA9LtJIQQX5DWgcKKWn89sxyzWJWXWqbXjkANDuVhtvvZh9wyIYTIbDMiUASiAS4NN7K9eCsOm/WJXHEdoSt4kgrP89ht2Y+ghUIIkblmRKA4PXiWuI6nPNupN1RHNBGgKle6nYQQ4otmRKCo89czx13NHHd1SvU7xmpw2vIpzdn8kFsmhBCZL+MDRed4F7eDd1IexI4lQvSEPqHS+zI2lfWQWyeEEJkv4wNFrb8Ou7KzrWhLSvW7gqeI6wnJ7SSEEF8howNFXMep959mdd4qZmXNSuk1fIEachyzKco2SxMihBBPm4wOFE0jzQxHR1LedyIcH6Y3dJoq7x5UCplmhRDiaZDRV8dafz0eu5t1+andDXQGPkQTk0V2QghxHxkbKEKxEBeGLrK1aAtZttQGoX2BGnKz5pPnXPqQWyeEEDNHxgaKzwbPEdXRlGc7hWK9+CcuJLudzJIOCiHE0yhjA0Wtv56K7HLme+alVL8zcBzQ0u0khBAPkJGBoneil+uBG+ws3p7y3UBHoIZ813K8TrO9LoQQ4mmVkYGizn8ahWJb8baU6gcidxkOt8jaCSGEMJBxgSKhE9T561k5awWFzoKUXqMjUAMoqrx7Hm7jhBBiBsq4QNE2dg1/ZCDltRNT+2IXZ28gx1H6kFsnhBAzT8YFilp/Hdm2bDYUrE+p/kikjUD0DlUyiC2EEEa+VqBQSt1RSl1RSl1SSjUkjxUqpU4opa4nfxckjyul1F8rpW4opS4rpTZYfb+J+ATnBs+zuWgTLrsrpTZ3BGpQOKj0vpRSfSGEeNo8jDuK57XW67TWU5tb/xA4qbVeDJxMPgbYByxO/rwF/MTqGzUMXSCcCPNsimsntE7gCxynzL0Nlz0/pdcQQoinzaPoejoA/Cz598+Ag9OO/1xPOgPkK6XKrbxwnb+OUlcpi72LUmrYwMQlxmM90u0khBAWfN1AoYEPlFLnlVJvJY+Vaa27AZK/p0aMK4GOaXV9yWO/Qyn1llKqQSnV0N/f/0/HB8IDtIy2saN429daO2FX2VR4dqVUXwghnkbWN5j+XTu01l1KqVLghFKq9T5l73V11186oPXbwNsAGzdu/Kfn6wZOo9Epb3ea0FE6Ayco93wDh82d0msIIcTT6GvdUWitu5K/+4B3gM1A71SXUvJ3X7K4D5i+V2kV0GX4PtT217MsdyklruKU2to3/hmRxLB0OwkhhEUpBwqllEcplTv1N7AbuAocBd5MFnsTOJL8+yjwneTsp63AyFQX1YPcDNykN9yb8t0EgG/sGFm2XMrcqQ2ECyHE0+rrdD2VAe8kxwscwP+jta5RSp0DfqWU+h7QDvxBsvz7wCvADSAEfNf0jT711+O0OdlU+ExKDY0nJugKfkSl92XsypnSawghxNMq5UChtb4FfGnHIK31APDiPY5r4PtW3yeSiPDZ4GdsLNhAjj0npbb2hD4lpkOS20kIIVKQ9iuzLw5dIhQfT3nfCZic7eSyF1OSs/HBhYUQQvyOtA8Utf56Cp2FLJ+1LKX60fgYPaFaqrwvo5T9IbdOCCFmvrQOFHEd58rIVXYUbcOmUmtqV/AjEjoi3U5CCJGitA4UgVjwa62dgMluJ4+jigLXqofYMiGEeHqkeaAIsNCzgPKc2SnVn4gN0Dd+VvbFFkKIryGtA0Vcx9lZkvogdmfwBJCQRXZCCPE1pHWgqHZXfe3ZTrOci8lzpZZEUAghRJoHCoXCactKqW4w2sXgRCPVst2pEEJ8LWkdKL4OX6AGQLqdhBDia5rRgaLQtRpP1pcymQshhLBgRgaK0chNRiLXqc6VtRNCCPF1zchA0RGoAWxUenY/6aYIIUTGm3GBQmuNb6yG0pxNZDuKnnRzhBAi4824QDEUbiIY88kgthBCPCQzLlD4AjXYyKLC86VM50IIIVIwowKF1nF8geOUeXbitOc+6eYIIcSMMKMCRf/4eSbifqql20kIIR6aGRUofIEaHMrNbPezT7opQggxY8yYQJHQUTqDJyn3PI/DltqWqUIIIb5sxgSK3lA90cSo5HYSQoiHbMYEio7AMZy2fErdW590U4QQYkaZEYEilhinO/gxld4XsanUss0KIYS4txkRKLqDp4jrCdkXWwghHoEZESg6AjXk2Msoyl7/pJsihBAzTsYHikh8hN5QPVXe3SiV8R9HCCHSTsZfWTuDJ9HEqMqVRXZCCPEoZHyg8I3V4M2aS75z+ZNuihBCzEgZHSjGY330TzRQ5d2LUupJN0cIIWakjA4UvsAHgJbcTkII8QhleKCoIc+5jFznvCfdFCGEmLEyNlAEou0MhZtkX2whhHjEMjZQ+ALHAajyyr7YQgjxKGVkoNBa0zF2jKLs9bgds590c4QQYkbLyEAxErnGWPS2DGILIcRjkJGBwheoQeGg0vvyk26KEELMeI89UCil9iql2pRSN5RSP7RaX+sEvsBxSt1bcNkLHkUThRBCTPNYA4VSyg78DbAPWAF8Wym1wsprDE5cJhTrlm4nIYR4TB73HcVm4IbW+pbWOgL8Ejhg5QXG473kOGZT7nn+kTRQCCHE73I85verBDqmPfYBW6YXUEq9BbyVfBhWSl2990t5H0Hz0lox4H/SjUgTci4+J+fic3IuPrf0Yb7Y4w4U90rIpH/ngdZvA28DKKUatNYbH0fD0p2ci8/JuficnIvPybn4nFKq4WG+3uPuevIB1dMeVwFdj7kNQgghLHjcgeIcsFgpNV8p5QS+BRx9zG0QQghhwWPtetJax5RSPwCOA3bgp1rrpvtUefvxtCwjyLn4nJyLz8m5+Jyci8891HOhtNYPLiWEEOKplZErs4UQQjw+EiiEEELcV9oGiq+b6iPTKKWqlVIfKaValFJNSqk/TB4vVEqdUEpdT/4uSB5XSqm/Tp6fy0qpDU/2EzxcSim7UuqiUuq95OP5SqmzyfPw/yYnQ6CUciUf30g+P+9JtvtRUErlK6X+USnVmvx+bHuKvxf/Q/L/j6tKqV8opbKflu+GUuqnSqm+6WvLUvkeKKXeTJa/rpR60+S90zJQPIxUHxkoBvyx1no5sBX4fvIz/xA4qbVeDJxMPobJc7M4+fMW8JPH3+RH6g+BlmmP/1fgr5LnYQj4XvL494AhrfUi4K+S5Waa/xOo0VovA9YyeV6euu+FUqoS+O+BjVrrVUxOiPkWT8934++BL+YusvQ9UEoVAj9mcqHzZuDHU8HlvrTWafcDbAOOT3v8I+BHT7pdj/kcHAFeBtqA8uSxcqAt+fd/AL49rfw/lcv0HybX15wEXgDeY3Khph9wfPH7weQMum3Jvx3JcupJf4aHeC5mAbe/+Jme0u/FVGaHwuR/6/eAPU/TdwOYB1xN9XsAfBv4D9OO/065r/pJyzsK7p3qo/IJteWxS94irwfOAmVa626A5O/SZLGZfI7+D+BPgETycREwrLWOJR9P/6z/dB6Sz48ky88UC4B+4D8lu+L+o1LKw1P4vdBadwL/DmgHupn8b32ep/e7Ada/Byl9P9I1UDww1cdMpZTyAr8G/khrPXq/ovc4lvHnSCn1GtCntT4//fA9imqD52YCB7AB+InWej0Q5PPuhXuZsecj2UVyAJgPVAAeJrtYvuhp+W7cz1d99pTOSboGiqcy1YdSKovJIPEPWutDycO9Sqny5PPlQF/y+Ew9RzuA/UqpO0xmF36ByTuMfKXU1ALR6Z/1n85D8vk8YPBxNvgR8wE+rfXZ5ON/ZDJwPG3fC4CXgNta636tdRQ4BGzn6f1ugPXvQUrfj3QNFE9dqg+llAL+DmjRWv/ltKeOAlMzE95kcuxi6vh3krMbtgIjU7egmUxr/SOtdZXWeh6T/91/q7X+r4CPgN9PFvvieZg6P7+fLD9j/tWote4BOpRSU9lAXwSaecq+F0ntwFallDv5/8vUuXgqvxtJVr8Hx4HdSqmC5B3a7uSx+3vSgzP3GbR5BbgG3AT+9ZNuz2P4vDuZvAW8DFxK/rzCZJ/qSeB68ndhsrxicmbYTeAKkzNBnvjneMjnZBfwXvLvBcBnwA3g/wNcyePZycc3ks8veNLtfgTnYR3QkPxuHAYKntbvBfC/AK3AVeA/A66n5bsB/ILJsZkok3cG30vlewD8i+Q5uQF81+S9JYWHEEKI+0rXrichhBBpQgKFEEKI+5JAIYQQ4r4kUAghhLgvCRRCCCHuSwKFEEKI+5JAIYQQ4r7+f7+UyPQSRc+zAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get head data using old flopy method\n",
    "hds_path = os.path.join(sim_path, model_name + '.hds')\n",
    "hds = flopy.utils.HeadFile(hds_path)\n",
    "# get heads after 1.0 days\n",
    "head = hds.get_data(totim=1.0)\n",
    "# plot head data\n",
    "plt.contour(head[0, :, :],extent=extent)\n",
    "plt.show()"
   ]
  }
 ],
 "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": 1
}