examples/Notebooks/flopy3_shapefile_export.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FloPy shapefile export demo\n",
    "The goal of this notebook is to demonstrate ways to export model information to shapefiles.\n",
    "This example will cover:\n",
    "* basic exporting of information for a model, individual package, or dataset\n",
    "* custom exporting of combined data from different packages\n",
    "* general exporting and importing of geographic data from other sources"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.8.6 | packaged by conda-forge | (default, Oct  7 2020, 18:42:56) \n",
      "[Clang 10.0.1 ]\n",
      "numpy version: 1.18.5\n",
      "matplotlib version: 3.2.2\n",
      "flopy version: 3.3.3\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\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": [
    "# set the output directory\n",
    "outdir = os.path.join('temp', 'shapefile_export')\n",
    "if not os.path.isdir(outdir):\n",
    "    os.makedirs(outdir)\n",
    "\n",
    "# load an existing model\n",
    "model_ws = \"../data/freyberg\"\n",
    "m = flopy.modflow.Modflow.load(\"freyberg.nam\", model_ws=model_ws, verbose=False,\n",
    "                               check=False, exe_name=\"mfnwt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['DIS', 'BAS6', 'LPF', 'WEL', 'RIV', 'RCH', 'OC', 'PCG']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.get_package_list()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### set the model coordinate information\n",
    "the coordinate information where the grid is located in a projected coordinate system (e.g. UTM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid = m.modelgrid\n",
    "grid.set_coord_info(xoff=273170, yoff=5088657, epsg=26916)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(273170.0, 278170.0, 5088657.0, 5098657.0)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.extent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Declarative export using attached `.export()` methods\n",
    "#### Export the whole model to a single shapefile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote temp/shapefile_export/model.shp\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'temp/shapefile_export/model.shp'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fname = '{}/model.shp'.format(outdir)\n",
    "m.export(fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": [
    "ax = plt.subplot(1, 1, 1, aspect='equal')\n",
    "extents = grid.extent\n",
    "pc = flopy.plot.plot_shapefile(fname, ax=ax, edgecolor='k', facecolor='none')\n",
    "ax.set_xlim(extents[0], extents[1])\n",
    "ax.set_ylim(extents[2], extents[3])\n",
    "ax.set_title(fname);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote temp/shapefile_export/wel.shp\n"
     ]
    }
   ],
   "source": [
    "fname = '{}/wel.shp'.format(outdir)\n",
    "m.wel.export(fname)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export a package to a shapefile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export a FloPy list or array object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<flopy.utils.util_array.Util3d at 0x12537b610>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.lpf.hk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote temp/shapefile_export/hk.shp\n"
     ]
    }
   ],
   "source": [
    "fname = '{}/hk.shp'.format(outdir)\n",
    "m.lpf.hk.export('{}/hk.shp'.format(outdir))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": [
    "ax = plt.subplot(1, 1, 1, aspect='equal')\n",
    "extents = grid.extent\n",
    "a = m.lpf.hk.array.ravel()\n",
    "pc = flopy.plot.plot_shapefile(fname, ax=ax, a=a)\n",
    "ax.set_xlim(extents[0], extents[1])\n",
    "ax.set_ylim(extents[2], extents[3])\n",
    "ax.set_title(fname);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<flopy.utils.util_list.MfList at 0x12537ba00>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.riv.stress_period_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote temp/shapefile_export/riv_spd.shp\n"
     ]
    }
   ],
   "source": [
    "m.riv.stress_period_data.export('{}/riv_spd.shp'.format(outdir))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MfList.export() exports the whole grid by default, regardless of the locations of the boundary cells\n",
    "`sparse=True` only exports the boundary cells in the MfList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote temp/shapefile_export/riv_spd.shp\n"
     ]
    }
   ],
   "source": [
    "m.riv.stress_period_data.export('{}/riv_spd.shp'.format(outdir), sparse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote temp/shapefile_export/wel_spd.shp\n"
     ]
    }
   ],
   "source": [
    "m.wel.stress_period_data.export('{}/wel_spd.shp'.format(outdir), sparse=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ad-hoc exporting using `recarray2shp`\n",
    "* The main idea is to create a recarray with all of the attribute information, and a list of geometry features (one feature per row in the recarray)\n",
    "* each geometry feature is an instance of the `Point`, `LineString` or `Polygon` classes in `flopy.utils.geometry`. The shapefile format requires all the features to be of the same type.\n",
    "* We will use pandas dataframes for these examples because they are easy to work with, and then convert them to recarrays prior to exporting.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flopy.export.shapefile_utils import recarray2shp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### combining data from different packages\n",
    "write a shapefile of RIV and WEL package cells"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>k</th>\n",
       "      <th>i</th>\n",
       "      <th>j</th>\n",
       "      <th>flux</th>\n",
       "      <th>iface</th>\n",
       "      <th>stage</th>\n",
       "      <th>cond</th>\n",
       "      <th>rbot</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>8</td>\n",
       "      <td>15</td>\n",
       "      <td>-0.00820</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "      <td>12</td>\n",
       "      <td>-0.00410</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>19</td>\n",
       "      <td>13</td>\n",
       "      <td>-0.00390</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>25</td>\n",
       "      <td>9</td>\n",
       "      <td>-0.00083</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>28</td>\n",
       "      <td>5</td>\n",
       "      <td>-0.00072</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   k   i   j     flux  iface  stage  cond  rbot\n",
       "0  0   8  15 -0.00820    0.0    NaN   NaN   NaN\n",
       "1  0  10  12 -0.00410    0.0    NaN   NaN   NaN\n",
       "2  0  19  13 -0.00390    0.0    NaN   NaN   NaN\n",
       "3  0  25   9 -0.00083    0.0    NaN   NaN   NaN\n",
       "4  0  28   5 -0.00072    0.0    NaN   NaN   NaN"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wellspd = pd.DataFrame(m.wel.stress_period_data[0])\n",
    "rivspd = pd.DataFrame(m.riv.stress_period_data[0])\n",
    "spd = wellspd.append(rivspd)\n",
    "spd.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### create a list of Polygon features from the cell vertices stored in the SpatialReference object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<flopy.utils.geometry.Polygon at 0x12582ce50>,\n",
       " <flopy.utils.geometry.Polygon at 0x12582c310>,\n",
       " <flopy.utils.geometry.Polygon at 0x1256cf4c0>,\n",
       " <flopy.utils.geometry.Polygon at 0x1256cf640>,\n",
       " <flopy.utils.geometry.Polygon at 0x1256cffa0>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571b5e0>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571ba60>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571bca0>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571bf40>,\n",
       " <flopy.utils.geometry.Polygon at 0x11d04fd30>,\n",
       " <flopy.utils.geometry.Polygon at 0x12570fb20>,\n",
       " <flopy.utils.geometry.Polygon at 0x12570f700>,\n",
       " <flopy.utils.geometry.Polygon at 0x12582ca00>,\n",
       " <flopy.utils.geometry.Polygon at 0x12582c730>,\n",
       " <flopy.utils.geometry.Polygon at 0x12582ca90>,\n",
       " <flopy.utils.geometry.Polygon at 0x12582cac0>,\n",
       " <flopy.utils.geometry.Polygon at 0x12582c160>,\n",
       " <flopy.utils.geometry.Polygon at 0x12582ca60>,\n",
       " <flopy.utils.geometry.Polygon at 0x1256e86a0>,\n",
       " <flopy.utils.geometry.Polygon at 0x1256e8580>,\n",
       " <flopy.utils.geometry.Polygon at 0x1257286a0>,\n",
       " <flopy.utils.geometry.Polygon at 0x125602df0>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571b880>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571b040>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571bb80>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571b7c0>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571be80>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571bac0>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571bdc0>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571bbe0>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571b8e0>,\n",
       " <flopy.utils.geometry.Polygon at 0x12571b460>,\n",
       " <flopy.utils.geometry.Polygon at 0x1258260d0>,\n",
       " <flopy.utils.geometry.Polygon at 0x125826340>,\n",
       " <flopy.utils.geometry.Polygon at 0x125826190>,\n",
       " <flopy.utils.geometry.Polygon at 0x125826eb0>,\n",
       " <flopy.utils.geometry.Polygon at 0x1258266a0>,\n",
       " <flopy.utils.geometry.Polygon at 0x125826b80>,\n",
       " <flopy.utils.geometry.Polygon at 0x1258269a0>,\n",
       " <flopy.utils.geometry.Polygon at 0x125826790>,\n",
       " <flopy.utils.geometry.Polygon at 0x125826640>,\n",
       " <flopy.utils.geometry.Polygon at 0x125826cd0>,\n",
       " <flopy.utils.geometry.Polygon at 0x125826a60>,\n",
       " <flopy.utils.geometry.Polygon at 0x125826940>,\n",
       " <flopy.utils.geometry.Polygon at 0x125826430>,\n",
       " <flopy.utils.geometry.Polygon at 0x125826dc0>]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from flopy.utils.geometry import Polygon\n",
    "\n",
    "vertices = []\n",
    "for row, col in zip(spd.i, spd.j):\n",
    "    vertices.append(grid.get_cell_vertices(row, col))\n",
    "polygons = [Polygon(vrt) for vrt in vertices]\n",
    "polygons"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### write the shapefile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote temp/shapefile_export/bcs.shp\n"
     ]
    }
   ],
   "source": [
    "fname = '{}/bcs.shp'.format(outdir)\n",
    "recarray2shp(spd.to_records(), geoms=polygons,\n",
    "             shpname=fname,\n",
    "             epsg=grid.epsg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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": [
    "ax = plt.subplot(1, 1, 1, aspect='equal')\n",
    "extents = grid.extent\n",
    "pc = flopy.plot.plot_shapefile(fname, ax=ax)\n",
    "ax.set_xlim(extents[0], extents[1])\n",
    "ax.set_ylim(extents[2], extents[3])\n",
    "ax.set_title(fname);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### exporting other data\n",
    "Suppose we have some well data with actual locations that we want to export to a shapefile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>wellID</th>\n",
       "      <th>q</th>\n",
       "      <th>x_utm</th>\n",
       "      <th>y_utm</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>-862.945320</td>\n",
       "      <td>5.089145e+06</td>\n",
       "      <td>270734.114900</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>-891.398625</td>\n",
       "      <td>5.088714e+06</td>\n",
       "      <td>272246.635698</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>-867.329397</td>\n",
       "      <td>5.089374e+06</td>\n",
       "      <td>271505.564780</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>-1134.000744</td>\n",
       "      <td>5.089179e+06</td>\n",
       "      <td>271368.228678</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>-1032.775216</td>\n",
       "      <td>5.089059e+06</td>\n",
       "      <td>271905.308018</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   wellID            q         x_utm          y_utm\n",
       "0       0  -862.945320  5.089145e+06  270734.114900\n",
       "1       1  -891.398625  5.088714e+06  272246.635698\n",
       "2       2  -867.329397  5.089374e+06  271505.564780\n",
       "3       3 -1134.000744  5.089179e+06  271368.228678\n",
       "4       4 -1032.775216  5.089059e+06  271905.308018"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "welldata = pd.DataFrame({'wellID': np.arange(0, 10),\n",
    "                         'q': np.random.randn(10)*100 - 1000,\n",
    "                         'x_utm': np.random.rand(10)*1000 + grid.yoffset,\n",
    "                         'y_utm': grid.xoffset - np.random.rand(10)*3000})\n",
    "welldata.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### convert the x, y coorindates to point features and then export"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote temp/shapefile_export/wel_data.shp\n"
     ]
    }
   ],
   "source": [
    "from flopy.utils.geometry import Point\n",
    "geoms = [Point(x, y) for x, y in zip(welldata.x_utm, welldata.y_utm)]\n",
    "\n",
    "fname = '{}/wel_data.shp'.format(outdir)\n",
    "recarray2shp(welldata.to_records(), geoms=geoms,\n",
    "             shpname=fname,\n",
    "             epsg=grid.epsg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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": [
    "ax = plt.subplot(1, 1, 1, aspect='equal')\n",
    "extents = grid.extent\n",
    "pc = flopy.plot.plot_shapefile(fname, ax=ax, radius=25)\n",
    "ax.set_xlim(extents[0], extents[1])\n",
    "ax.set_ylim(extents[2], extents[3])\n",
    "ax.set_title(fname);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding attribute data to an existing shapefile\n",
    "Suppose we have a GIS coverage representing the river in the riv package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote temp/shapefile_export/riv_reaches.shp\n"
     ]
    }
   ],
   "source": [
    "from flopy.utils.geometry import LineString \n",
    "\n",
    "### make up a linestring shapefile of the river reaches\n",
    "i, j = m.riv.stress_period_data[0].i, m.riv.stress_period_data[0].j\n",
    "x0 = grid.xyzcellcenters[0][i[0], j[0]]\n",
    "x1 = grid.xyzcellcenters[0][i[-1], j[-1]]\n",
    "y0 = grid.xyzcellcenters[1][i[0], j[0]]\n",
    "y1 = grid.xyzcellcenters[1][i[-1], j[-1]]\n",
    "x = np.linspace(x0, x1, m.nrow+1)\n",
    "y = np.linspace(y0, y1, m.nrow+1)\n",
    "l0 = zip(list(zip(x[:-1], y[:-1])), list(zip(x[1:], y[1:])))\n",
    "lines = [LineString(l) for l in l0]\n",
    "\n",
    "rivdata = pd.DataFrame(m.riv.stress_period_data[0])\n",
    "rivdata['reach'] = np.arange(len(lines))\n",
    "lines_shapefile = '{}/riv_reaches.shp'.format(outdir)\n",
    "recarray2shp(rivdata.to_records(index=False), geoms=lines,\n",
    "             shpname=lines_shapefile,\n",
    "             epsg=grid.epsg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "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": [
    "ax = plt.subplot(1, 1, 1, aspect='equal')\n",
    "extents = grid.extent\n",
    "pc = flopy.plot.plot_shapefile(lines_shapefile, ax=ax, radius=25)\n",
    "ax.set_xlim(extents[0], extents[1])\n",
    "ax.set_ylim(extents[2], extents[3])\n",
    "ax.set_title(lines_shapefile);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### read in the GIS coverage using `shp2recarray`\n",
    "`shp2recarray` reads a shapefile into a numpy record array, which can easily be converted to a DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flopy.export.shapefile_utils import shp2recarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>k</th>\n",
       "      <th>i</th>\n",
       "      <th>j</th>\n",
       "      <th>stage</th>\n",
       "      <th>cond</th>\n",
       "      <th>rbot</th>\n",
       "      <th>iface</th>\n",
       "      <th>reach</th>\n",
       "      <th>geometry</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>14</td>\n",
       "      <td>20.100000</td>\n",
       "      <td>0.05</td>\n",
       "      <td>20.00</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>&lt;flopy.utils.geometry.LineString object at 0x1...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>14</td>\n",
       "      <td>19.870001</td>\n",
       "      <td>0.05</td>\n",
       "      <td>19.75</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1</td>\n",
       "      <td>&lt;flopy.utils.geometry.LineString object at 0x1...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>14</td>\n",
       "      <td>19.650000</td>\n",
       "      <td>0.05</td>\n",
       "      <td>19.50</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2</td>\n",
       "      <td>&lt;flopy.utils.geometry.LineString object at 0x1...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>14</td>\n",
       "      <td>19.420000</td>\n",
       "      <td>0.05</td>\n",
       "      <td>19.25</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3</td>\n",
       "      <td>&lt;flopy.utils.geometry.LineString object at 0x1...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>14</td>\n",
       "      <td>19.190001</td>\n",
       "      <td>0.05</td>\n",
       "      <td>19.00</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4</td>\n",
       "      <td>&lt;flopy.utils.geometry.LineString object at 0x1...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   k  i   j      stage  cond   rbot  iface  reach  \\\n",
       "0  0  0  14  20.100000  0.05  20.00    0.0      0   \n",
       "1  0  1  14  19.870001  0.05  19.75    0.0      1   \n",
       "2  0  2  14  19.650000  0.05  19.50    0.0      2   \n",
       "3  0  3  14  19.420000  0.05  19.25    0.0      3   \n",
       "4  0  4  14  19.190001  0.05  19.00    0.0      4   \n",
       "\n",
       "                                            geometry  \n",
       "0  <flopy.utils.geometry.LineString object at 0x1...  \n",
       "1  <flopy.utils.geometry.LineString object at 0x1...  \n",
       "2  <flopy.utils.geometry.LineString object at 0x1...  \n",
       "3  <flopy.utils.geometry.LineString object at 0x1...  \n",
       "4  <flopy.utils.geometry.LineString object at 0x1...  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linesdata = shp2recarray(lines_shapefile)\n",
    "linesdata = pd.DataFrame(linesdata)\n",
    "linesdata.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Suppose we have some flow information that we read in from the cell budget file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.51019391,  3.00890828,  2.05467269,  2.71588802,  3.35816143,\n",
       "        0.14258792,  0.87736847,  3.51692144,  0.89709727,  3.24054984,\n",
       "        1.55514581,  0.86166044,  1.49100319, -0.15122894,  0.23941059,\n",
       "        1.55509947, -0.17866781,  0.08334555,  0.72284485,  1.13914413,\n",
       "        1.99498601,  2.4237807 ,  1.80672756,  0.95424536,  1.24747095,\n",
       "       -0.28632199,  0.17251608, -0.62335644, -0.45685156,  0.8900417 ,\n",
       "        1.16991818,  2.62243268,  0.45293882, -0.03513629,  1.17110312,\n",
       "       -0.69021108,  1.69718902,  0.75600948,  0.57773914,  0.51926594])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# make up some fluxes between the river and aquifer at each reach\n",
    "q = np.random.randn(len(linesdata))+1\n",
    "q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Add reachs fluxes and cumulative flow to lines DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "linesdata['qreach'] = q\n",
    "linesdata['qstream'] = np.cumsum(q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote temp/shapefile_export/riv_reaches.shp\n"
     ]
    }
   ],
   "source": [
    "recarray2shp(linesdata.drop('geometry', axis=1).to_records(), \n",
    "             geoms=linesdata.geometry,\n",
    "             shpname=lines_shapefile,\n",
    "             epsg=grid.epsg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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": [
    "ax = plt.subplot(1, 1, 1, aspect='equal')\n",
    "extents = grid.extent\n",
    "pc = flopy.plot.plot_shapefile(lines_shapefile, ax=ax, radius=25)\n",
    "ax.set_xlim(extents[0], extents[1])\n",
    "ax.set_ylim(extents[2], extents[3])\n",
    "ax.set_title(lines_shapefile);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overriding the model's modelgrid with a user supplied modelgrid\n",
    "\n",
    "In some cases it may be necessary to override the model's modelgrid instance with a seperate modelgrid. An example of this is if the model discretization is in feet and the user would like it projected in meters. Exporting can be accomplished by supplying a modelgrid as a `kwarg` in any of the `export()` methods within flopy. Below is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote temp/shapefile_export/freyberg.shp\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'temp/shapefile_export/freyberg.shp'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mg0 = m.modelgrid\n",
    "\n",
    "# build a new modelgrid instance with discretization in meters\n",
    "modelgrid = flopy.discretization.StructuredGrid(delc=mg0.delc * 0.3048, delr=mg0.delr * 0.3048,\n",
    "                                                top= mg0.top, botm=mg0.botm, idomain=mg0.idomain,\n",
    "                                                xoff=mg0.xoffset * 0.3048, yoff=mg0.yoffset * 0.3048)\n",
    "\n",
    "# exporting an entire model\n",
    "m.export('{}/freyberg.shp'.format(outdir), modelgrid=modelgrid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And for a specific parameter the method is the same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrote temp/shapefile_export/hk.shp\n"
     ]
    }
   ],
   "source": [
    "fname = '{}/hk.shp'.format(outdir)\n",
    "m.lpf.hk.export(fname, modelgrid=modelgrid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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": [
    "ax = plt.subplot(1, 1, 1, aspect='equal')\n",
    "extents = modelgrid.extent\n",
    "a = m.lpf.hk.array.ravel()\n",
    "pc = flopy.plot.plot_shapefile(fname, ax=ax, a=a)\n",
    "ax.set_xlim(extents[0], extents[1])\n",
    "ax.set_ylim(extents[2], extents[3])\n",
    "ax.set_title(fname);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}