Repository: modflowpy/flopy

Issue:
Reading data from PathlineFile is slow
Hi,

I'm using MODPATH 6 and encountering performance issues with data reading.
I can't provide a minimal working example easily, but my model has 40401 pathlines and 926690 points (that makes 23 points per pathline on average), and I use `PathlineFile.get_alldata()` to extract the data:
```python3
pathobj = flopy.utils.PathlineFile(path+'.mppth'))
path_data = pathobj.get_alldata()
```

It spends `143s` on `get_alldata` while my MODFLOW + MODPATH models together take only `16.091s` to run.
```
   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000  179.221  179.221 /home/gael/Documents/Codes/./Xtemp_testmodpath.py:15(run)
        1    0.008    0.008  159.899  159.899 /home/gael/Documents/Codes/modpathsim.py:62(export_data)
        1    6.902    6.902  158.693  158.693 /home/gael/Documents/Codes/modpathsim.py:12(extract_data)
        1    0.000    0.000  143.554  143.554 /home/gael/miniconda3/envs/hydromodpy/lib/python3.9/site-packages/flopy/utils/modpathfile.py:351(get_alldata)
        1    0.073    0.073  143.554  143.554 /home/gael/miniconda3/envs/hydromodpy/lib/python3.9/site-packages/flopy/utils/modpathfile.py:390(<listcomp>)
    40401  132.793    0.003  143.480    0.004 /home/gael/miniconda3/envs/hydromodpy/lib/python3.9/site-packages/flopy/utils/modpathfile.py:295(get_data)
        2    0.000    0.000   16.091    8.045 /home/gael/miniconda3/envs/hydromodpy/lib/python3.9/site-packages/flopy/mbase.py:1351(run_model)
        2    0.000    0.000   16.091    8.045 /home/gael/miniconda3/envs/hydromodpy/lib/python3.9/site-packages/flopy/mbase.py:1647(run_model)
       27   16.084    0.596   16.084    0.596 {method 'readline' of '_io.BufferedReader' objects}
  1896343    9.098    0.000   13.093    0.000 /home/gael/miniconda3/envs/hydromodpy/lib/python3.9/site-packages/numpy/core/records.py:518(__getitem__)
```

I found that `get_alldata` [iteratively calls `get_data`](https://github.com/modflowpy/flopy/blob/4104cf5/flopy/utils/modpathfile.py#L390-L393), while `get_data` [searches in the whole array](https://github.com/modflowpy/flopy/blob/4104cf5/flopy/utils/modpathfile.py#L344), leading to square complexity. I may come soon with a PR to fix this, but I am unsure I would do it very well, considering I'm not familiar with flopy code, yet.

Discussion:
codecov[bot]: # [Codecov](https://codecov.io/gh/modflowpy/flopy/pull/1136?src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy) Report
> Merging [#1136](https://codecov.io/gh/modflowpy/flopy/pull/1136?src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy) (14f2b31) into [develop](https://codecov.io/gh/modflowpy/flopy/commit/e566845172380e3eae06981ca180923d2362ee56?el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy) (e566845) will **decrease** coverage by `54.607%`.
> The diff coverage is `6.666%`.

> :exclamation: Current head 14f2b31 differs from pull request most recent head e541cba. Consider uploading reports for the commit e541cba to get more accurate results
```diff
@@              Coverage Diff               @@
##           develop     #1136        +/-   ##
==============================================
- Coverage   72.060%   17.453%   -54.608%     
==============================================
  Files          225       217         -8     
  Lines        51934     48152      -3782     
==============================================
- Hits         37424      8404     -29020     
- Misses       14510     39748     +25238     
```

| [Impacted Files](https://codecov.io/gh/modflowpy/flopy/pull/1136?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy) | Coverage Δ | |
|---|---|---|
| [flopy/utils/modpathfile.py](https://codecov.io/gh/modflowpy/flopy/pull/1136/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy#diff-ZmxvcHkvdXRpbHMvbW9kcGF0aGZpbGUucHk=) | `11.290% <6.666%> (-62.374%)` | :arrow_down: |
| [flopy/modflow/mfsms.py](https://codecov.io/gh/modflowpy/flopy/pull/1136/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy#diff-ZmxvcHkvbW9kZmxvdy9tZnNtcy5weQ==) | `5.479% <0.000%> (-92.727%)` | :arrow_down: |
| [flopy/modflow/mfevt.py](https://codecov.io/gh/modflowpy/flopy/pull/1136/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy#diff-ZmxvcHkvbW9kZmxvdy9tZmV2dC5weQ==) | `8.152% <0.000%> (-85.902%)` | :arrow_down: |
| [flopy/utils/swroutputfile.py](https://codecov.io/gh/modflowpy/flopy/pull/1136/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy#diff-ZmxvcHkvdXRpbHMvc3dyb3V0cHV0ZmlsZS5weQ==) | `11.290% <0.000%> (-84.530%)` | :arrow_down: |
| [flopy/utils/zonbud.py](https://codecov.io/gh/modflowpy/flopy/pull/1136/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy#diff-ZmxvcHkvdXRpbHMvem9uYnVkLnB5) | `5.280% <0.000%> (-84.343%)` | :arrow_down: |
| [flopy/modflowlgr/mflgr.py](https://codecov.io/gh/modflowpy/flopy/pull/1136/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy#diff-ZmxvcHkvbW9kZmxvd2xnci9tZmxnci5weQ==) | `6.574% <0.000%> (-83.771%)` | :arrow_down: |
| [flopy/modflow/mfhyd.py](https://codecov.io/gh/modflowpy/flopy/pull/1136/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy#diff-ZmxvcHkvbW9kZmxvdy9tZmh5ZC5weQ==) | `12.686% <0.000%> (-83.583%)` | :arrow_down: |
| [flopy/modflow/mfag.py](https://codecov.io/gh/modflowpy/flopy/pull/1136/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy#diff-ZmxvcHkvbW9kZmxvdy9tZmFnLnB5) | `7.356% <0.000%> (-83.504%)` | :arrow_down: |
| [flopy/modflow/mfswt.py](https://codecov.io/gh/modflowpy/flopy/pull/1136/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy#diff-ZmxvcHkvbW9kZmxvdy9tZnN3dC5weQ==) | `4.642% <0.000%> (-82.190%)` | :arrow_down: |
| [flopy/utils/mtlistfile.py](https://codecov.io/gh/modflowpy/flopy/pull/1136/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy#diff-ZmxvcHkvdXRpbHMvbXRsaXN0ZmlsZS5weQ==) | `5.396% <0.000%> (-82.143%)` | :arrow_down: |
| ... and [188 more](https://codecov.io/gh/modflowpy/flopy/pull/1136/diff?src=pr&el=tree-more&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=modflowpy) | |


Patch:
diff --git a/examples/Notebooks/flopy3_Modflow_postprocessing_example.ipynb b/examples/Notebooks/flopy3_Modflow_postprocessing_example.ipynb
index fb5b2831..dbe88833 100644
--- a/examples/Notebooks/flopy3_Modflow_postprocessing_example.ipynb
+++ b/examples/Notebooks/flopy3_Modflow_postprocessing_example.ipynb
@@ -9,21 +9,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "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"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import os\n",
     "import sys\n",
@@ -39,7 +27,7 @@
     "    sys.path.append(fpth)\n",
     "    import flopy\n",
     "    \n",
-    "from flopy.utils.postprocessing import get_transmissivities, get_water_table, get_gradients, get_saturated_thickness\n",
+    "from flopy.utils.postprocessing import get_transmissivities, get_water_table, get_gradients\n",
     "import flopy.utils.binaryfile as bf\n",
     "    \n",
     "print(sys.version)\n",
@@ -50,7 +38,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -68,7 +56,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -77,20 +65,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(5, 25, 25)"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "hdsobj = bf.HeadFile(model_ws+heads_file)\n",
     "hds = hdsobj.get_data(kstpkper=(0, 2))\n",
@@ -107,56 +84,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "wrote data/heads1.tif\n",
-      "No CRS information for writing a .prj file.\n",
-      "Supply an epsg code or .prj file path to the model spatial reference or .export() method.(writing .prj files from proj4 strings not supported)\n",
-      "wrote data/heads1.shp\n",
-      "wrote data/heads2.tif\n",
-      "No CRS information for writing a .prj file.\n",
-      "Supply an epsg code or .prj file path to the model spatial reference or .export() method.(writing .prj files from proj4 strings not supported)\n",
-      "wrote data/heads2.shp\n",
-      "wrote data/heads3.tif\n",
-      "No CRS information for writing a .prj file.\n",
-      "Supply an epsg code or .prj file path to the model spatial reference or .export() method.(writing .prj files from proj4 strings not supported)\n",
-      "wrote data/heads3.shp\n",
-      "wrote data/heads4.tif\n",
-      "No CRS information for writing a .prj file.\n",
-      "Supply an epsg code or .prj file path to the model spatial reference or .export() method.(writing .prj files from proj4 strings not supported)\n",
-      "wrote data/heads4.shp\n",
-      "wrote data/heads5.tif\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "No CRS information for writing a .prj file.\n",
-      "Supply an epsg code or .prj file path to the model spatial reference or .export() method.(writing .prj files from proj4 strings not supported)\n",
-      "wrote data/heads5.shp\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 792x612 with 6 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "fig, axes = plt.subplots(2, 3, figsize=(11, 8.5))\n",
     "axes = axes.flat\n",
@@ -188,30 +118,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "wrote data/heads5_rot.asc\n",
-      "wrote data/heads5_rot.tif\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAToAAAD4CAYAAAB8FSpXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAfgklEQVR4nO3dfYxc1Znn8e+vi/YLJjMBDFkDzsIELxqGJM2M1xttViMgJPFEERAxWSU7Il4ljIMUNDtRVgoMyguKkEjIy4w0bFiHkHglSNZahglCIeBFQVk2C46JjLGJs1gZkxg89hpiwBi7u6ue/ePeJtVd1fecdpe7um7/PtZVV906ferUSz++957nPlcRgZlZnQ31ewBmZieaA52Z1Z4DnZnVngOdmdWeA52Z1d5Jc/lky09rxLkrh2fVR5CeJW5ltMmZa24lZqSbKNlHVpuo/v+mmfH/UaoPgPFo9GAss389AM1WdZtWpJ+nV20i0SYrMSHjebK+dLPsY/zF39I8/FrGYKb3/kuXxYsvNbPaPrn92EMRsXY2zzcX5jTQnbtymC0PrZxVH2OR/gCOxViyzdGMfo4kvuGvttKB49XWomSbQ62Tqx9vVj+e2+al8VOSbX47Xt3PK+NLkn28PLY02eaV0ep+joyl37fXRtNtjo6lv+Kjo9VtmuPpz7k1lg7uMZ4Rf1qJNonH//mWv0s/R8KLLzXZ8tBbs9o2Vjy7fNZPOAdmtesqaa2kX0raLemGXg3KzPongFbmv0Fx3Ft0khrA7cB7gb3AzyTdHxHP9GpwZjb3gsjacxoks9miWwPsjohfRcQo8H3gyt4My8z6yVt0v3M28Ju2+3uBfzO1kaT1wHqAt549p4cEzew4BEGzZqeGzmaLrttR0Y53JyI2RMTqiFh9xunpg7pm1n8tImsZFLPZxNoLtE+hngO8MLvhmFm/BdAcoCCWYzZbdD8DVkk6T9Ii4CPA/b0Zlpn1k7foShExLul64CGgAdwVETtnO6BmDM4BzvkkJ6m4lZHsm+wjIxk4J0l3LvoYSPMgdgQwVrNjdLOaHYiIHwI/7NFYzGweCKJ2u66eBjWzyQKa9YpzDnRmNllxZkS9ONCZ2RTKKt4wSFymycwmKSYjlLWkSFoiaYukpyTtlHRzuf5LkrZL2ibpYUlnletPl/RjSYcl/X1Fv1+U9Hz5+9skfaBqHN6iM7NJijy6nm3RHQMui4jDkoaBxyQ9CNwWEZ8DkPRXwOeB64CjwOeAi8qlyjci4qs5g3CgM7MOvUrvieIyg4fLu8PlEhHxSluzZZSJNRHxGkUwPL8nAygNXKDr1YnEOb2kZp56Vngz0WY0o2BmTn5bTkHMscRz9arYZW8KbyabJItqFm1m93jdzHCLbrmkrW33N0TEhvYGZaWjJ4Hzgdsj4oly/S3Ax4CXgUuPY6jXS/oYsBX4TET8drqGPkZnZpMEoslQ1gIcnDiXvVw2dPQX0YyIEYrTRNdIuqhcf1NErATuBq6f4TC/CbwNGAH2AV+rauxAZ2YdWqGsZSYi4hDwKDC19Po9wNUz7Gt/GUBbwLcoysZNy4HOzCYJxGg0spYUSWdIenN5eylwObBL0qq2ZlcAu2YyRkkr2u5+CNhR1X7gjtGZ2YlVJAz3bBtoBbCxPE43BGyKiAck3SvpAorD5c9RzLgCIGkP8HvAIklXAe+LiGck3QncERFbga9IGimHuwf4ZNUgHOjMrEOv0ksiYjtwcZf10+6qRsS506y/tu32NTMZhwOdmU0SoawZ+kHiQGdmHXpR0ms+caAzs0mKyYh6hYY5fTXFRTeqU3V7UbU0p5ZWzsU/UknFOdPrYxlfmFSbnAPDqUTf3DbjiYtyH2ulX0+qD0hvMTRzEoYTSceQmeybeq6sxOQePE9umxOsx5MR80K9wraZ9UTOfzSDxIHOzCaZODOiThzozKxDzrnTg8SBzswmKU7qd6AzsxoLlDVxNUgc6Mxskoi8kl6DxIHOzKaQE4bNrN4Cb9H1XVaib0abZs5zpSr/ZhywzSllk2pztDWc7COnTU6yb6rNeMYfwGhGwvBYs7pNqgIx9DKpuLqfnCrFecnA6SZz0kcGT0aYWa0FMy+qOd850JnZJMXlDusVGur1asysB+p3AWsHOjObJPCZEWa2AHiLzsxqLULeojOzeismI3wKmJnVmq8ZMWupCsKtRF3f1OOQV2E43QuMJT7srKq+pNukkn2PRkYycEY6wOvNRRltEmMZT49lLCdhOJHIO95M/6HlJAO3WuljTcmE4KzqwT1qMxd9ZDxF3fLoZhW2Je2R9LSkbZK29mpQZtZfTYaylhRJSyRtkfSUpJ2Sbi7Xf0nS9jJ2PCzprHL96ZJ+LOmwpL+v6Pc0SZslPVv+PLVqHL3YPr00IkYiYnUP+jKzPps4MyJnyXAMuCwi3gmMAGslvQu4LSLeEREjwAPA58v2R4HPAf850e8NwCMRsQp4pLw/rXrtiJtZT7QYylpSonC4vDtcLhERr7Q1W0a5Ux4Rr0XEYxQBr8qVwMby9kbgqqrGsz1GF8DDkgL4rxGxYWoDSeuB9QArz67XTI5ZHUWkj6G2WT7lsNWGqXFAUgN4EjgfuD0inijX3wJ8DHgZuHSGw3xLROwrxhv7JJ1Z1Xi2W3Tvjog/Bv4M+JSkP53aICI2RMTqiFh9xukOdGbzXbHrOpS1AAcn/r7LpWNjJyKa5S7qOcAaSReV62+KiJXA3cD1J/I1zSrQRcQL5c8DwH3Aml4Mysz6q1me75paZiIiDgGPAmunPHQPcPUMh7hf0gqA8ueBqsbHHegkLZP0ponbwPuAHcfbn5nNDxPpJb2YjJB0hqQ3l7eXApcDuyStamt2BbBrhsO8H1hX3l4H/KCq8WyO0b0FuE/SRD/3RMSPqn6huAJ4dQZbqrBmTo7cWEbhzbGMfKR0Hl367TvaSueuHY3qNkeai5N9HB5Pt3ktI4/uSCJP7vWMPLrXx9JtRscTBT5zCm9m5NpFTh5dIqkypw9y2vSgOKeSffQi/62np4CtADaWx+mGgE0R8YCkeyVdQJHS+hxw3RvPLu0Bfg9YJOkq4H0R8YykO4E7ImIrcCuwSdIngF8DH64axHEHuoj4FfDO4/19M5u/enXNiIjYDlzcZf20u6oRce40669tu/0i8J7ccfgUMDObpJh1rdfEoQOdmU3iUupmtiD4codmVmt1PKnfgc7MOrjwppnVWoSyrt87SBzozKyDd11nKZUQnCy8mZEM3MwZR8bB1tHEiSOjGYU3c4pmHkkkFR/OSBh+ZXxpss2rYxlJxYk2h8cyEqDH0l+rsWb1ezc+nn5vm830Z5hTnDOZENyDRN9sqX5cePO4eIvOzDo40JlZrTmPzswWBOfRmVmtReQVVRgkDnRm1sG7rmZWaz5GZ2YLQvJatwPGgc7MOngyYhaCSFcYTmREjmVkTCYKxhb9ZJziMpZICM5JBj7aykgYTiQE5yQMvzy2JN1mNCOp+Fj1c70+mn49zR5UB+5dMnCySTphOOcLlZPIm9EmXUH4xIvwMTozqz1l/Wc1SBzozKyDj9GZWa35XFczq78ojtPViQOdmXWo26xrvY44mtmsRTkZkbOkSFoiaYukpyTtlHRzuf5LkrZL2ibpYUlntf3OjZJ2S/qlpPdP0+8XJT1f/v42SR+oGoe36MysQw93XY8Bl0XEYUnDwGOSHgRui4jPAUj6K+DzwHWSLgQ+AvwRcBbwPyX9q4joVmbyGxHx1ZxBzH3hzUQyUU5hzeRzZHSRU3hzLKrfntTjkJdrl8qTOzSWzn97+Vi6zUtH0m2OHK0eS3M8/b941oHsRJusr0FGm0jk6+WMJa/wZo+Kc8628GaPAlSvZl0jIoDD5d3hcomIeKWt2TJ+N/Irge9HxDHgnyTtBtYA/2c24/Cuq5lNElEEupwFWC5pa9uyfmp/khqStgEHgM0R8US5/hZJvwH+gmKLDuBs4Ddtv763XNfN9eXu712STq16TQ50ZtahFcpagIMRsbpt2TC1r4hoRsQIcA6wRtJF5fqbImIlcDdwfdm826Zkt+3UbwJvA0aAfcDXql6PA52ZdYjIW2bWZxwCHgXWTnnoHuDq8vZeYGXbY+cAL3Tpa38ZQFvAtyh2b6flQGdmkwSi1RrKWlIknSHpzeXtpcDlwC5Jq9qaXQHsKm/fD3xE0mJJ5wGrgC1d+l3RdvdDwI6qcXjW1cw69DBfeAWwUVKDYsNqU0Q8IOleSRdQlEx4DrgOICJ2StoEPAOMA5+amHGVdCdwR0RsBb4iaaQc6h7gk1WDcKAzs8mip7Ou24GLu6y/ukvzicduAW7psv7attvXzGQcDnRm1smngJlZ3bl6yQmWSihuZkz15NRJzElqTSUVpwpzAhzLKbzZWlT5+OGxdOHN3x5NJwO/8urJyTbjr6bHm9TI2BxItFGP/s6SRTUh/YXp0dZNVlHNOUoITj1FK+d9GyDzLtCZWZ8FeWd6DJDk/HCZdXxA0o62dadJ2izp2fJnZVaymQ2WE5FH1085eXTfpTPB7wbgkYhYBTxS3jezuojMZUAkA11E/AR4acrqK4GN5e2NwFU9HpeZ9U3eea6DNGFxvGdGvCUi9gGUP8+crqGk9RMn/B58MWeawMz6bqFt0c1WRGyYOOF3+ek+48xs3otitjpnGRTHG3n2T5xrVv480LshmVn/KXMZDMcb6O4H1pW31wE/6M1wzGxeqNmuazKPTtL3gEsoCuztBb4A3ApskvQJ4NfAh3OerLiM2uzenW71lDvbzD4ZGKAZ1f8PjGYkDB/NSBh+vVnd5rWMhOHDr6fbNF9Kt1m2t/o1jf5++vMbPyV9LDYWVbeJk+bwryhZYTinj56MZP6o2etJBrqI+Og0D72nx2Mxs/mghgnDPjPCzDoMUjJwDgc6M+s0QDOqORzozKyDvEVnZrU2YDOqORzozGwKeTLCzBYAb9GZWe3V7LR0B7oKrTm6GmQrkZg8nngcYHQ0/VEuPpBOcD771p9WPv7Pn/63yT5eG85Ixj4p0SbnD20oY7OjF1smNduNS3IenZktBHWbdXU5ETPr1KNzXSUtkbRF0lOSdkq6uVz/JUnbJW2T9LCks9p+50ZJuyX9UtL7p+l3RlXOHejM7EQ6BlwWEe8ERoC1kt4F3BYR74iIEeAB4PMAki4EPgL8EUVl8/9SXvx6qhlVOXegM7MOirwlJQqHy7vD5RIR8Upbs2X8bvvwSuD7EXEsIv4J2A2s6dL1jKqc+xidmU0WzOQUsOWStrbd3xARG9oblFtkTwLnA7dHxBPl+luAjwEvA5eWzc8GHm/79b3luqkmVTmXNG2Vc/AWnZl1k3+M7uBEBfFy2dDRVUSz3EU9B1gj6aJy/U0RsRK4G7i+bN4tws56asSBzsw69GrXtV1EHAIepfOqgvcAV5e39wIr2x47B3ihS3czqnLuXdcKQ3OUNTmk6uc5KfE4wKJF48k2R89Mly19/obqPLmcwputxRl/AakcuJwcuRw5e2Cpp8o6GFWvvLNenRkh6QxgLCIOSVoKXA58WdKqiHi2bHYFsKu8fT9wj6SvA2cBq4AtXbqeqHJ+KxlVzh3ozKxT7/LoVgAby+N0Q8CmiHhA0r2SLqBIDX8OuA4gInZK2gQ8A4wDn4qIJoCkO4E7ImIrM6xy7kBnZpMcz27pdCJiO3Bxl/VXd2k+8dgtwC1d1l/bdvtFZlDl3IHOzDq58KaZ1V3dTgFzoDOzTg50ZlZrPTxGN1840JlZJwc6M6u7jNTNgTKngU7AkKpnc5qJC0qmS0dCI+O/o6w2iU97kdIJuEuGxpJtljaq2ywbPpbs45Sl6TZjp6U/7teGh5NtkhoZmwOJNomvSbbImT1M7aflDKZek5S14y06M+vkXVczqzVPRpjZguBAZ2a150BnZnUmPOtqZnXnY3RmtiA40JlZ7TnQnViNROZlTv7nUCLpGGAoY9s8lVQ8nJEwvDgjYfjkodHKx0/JSBg+dcnryTbNjDfvyPDi6j7G09X3WznVdhNtMj7CzD/G9Hgjle3bq9psGd859SpTepbqtuua/BZIukvSAUk72tZ9UdLz5cVnt0n6wIkdppnNqR5dwHq+yLk4znfpvJgFwDciYqRcftjbYZlZ30Qx65qzDIpkoIuInwAvzcFYzGy+WIBbdNO5XtL2ctf21OkaSVovaaukrQdfHKD/AswWsBNxucN+Ot5A903gbcAIsA/42nQNI2LDxMVtl5/uy8iaDQRv0UFE7C+vvt0CvgWs6e2wzKxvcoNc3QPdxBWySx8CdkzX1swGi+jdrqukJZK2SHpK0k5JN5frb5O0qzz8dZ+kN5frF0n6jqSny9+5ZJp+Z5T5kcyjk/Q94BJguaS9wBeASySNUMT0PcAn0y/ZzAZFD4+/HQMui4jDkoaBxyQ9CGwGboyIcUlfBm4EPgv8JUBEvF3SmcCDkv51ufc41Tci4qs5g0gGuoj4aJfV387pvJtUQnCyUmtGJmkjI+eykdHPsMZn9TjAEqUThk9pVCcEv3k4nQx8dHG6MnArowzucKN6wuj10fTzNFvpHYVms7pNs5keayvjeYoLwVeLSPSTk8Ob1WYOKhX3Kt+4dxewDuBweXe4XCIiHm5r9jjw5+XtC4FHyt89IOkQsBrYMptxeHbAzDrlH6NbPpFVUS7rp3YlqSFpG3AA2BwRT0xp8nHgwfL2U8CVkk6SdB7wJ8DKaUaZlfkBDnRmNlXm8bly9/bgRFZFuWzo6K6YuBwBzgHWSLpo4jFJNwHjwN3lqruAvcBW4G+Bn5aPT5Wd+QHz8FxXM5sHTsCMakQckvQoxZlWOyStAz4IvKfcxSUixoFPT/yOpJ8Cz3bpa39bm28BD1Q9t7fozKxDr04Bk3RG24zqUuByYJektRSTD1dExJG29idLWlbefi8wHhHPdOl3Rpkf3qIzsw49nHVdAWyU1KDYsNoUEQ9I2g0sBjaXFVsej4jrgDOBhyS1gOeBa94Yk3QncEdEbAW+MpPMDwc6M5ush8nAEbEduLjL+vOnab8HuGCax65tu31NtzbTcaAzs04DdNZDjjkNdEIMJQ8LVu/4D2ckCo1mfErDGQcYUoU1c3LkluQU3kzk0aXy7AB+f/hosk1OQcyhxHvXGEq/b0fH0l+rsaFG5ePFnk618XQaI61I96Oh6tccOYVEc+pVZNUjrR6LcsYySxNnRtSJt+jMrINa9Yp0DnRmNtmAnbCfw4HOzDp419XM6s+Bzszqzlt0ZlZ/DnRmVmsxWFf4yuFAZ2aTOI+uBxqp4oOJIohDGZ9AI+NDamRsmy9KZIEuSiQUQ15S8clDo5WP5yQMHzsp/VGOpwpMkpdUnJLTw1AP8l6zEnm7Fqad0mSo+n2JnJyynKKaOVLdnPh84UJGYdpB4i06M+vgLTozqzcnDJvZQuDJCDOrPQc6M6u3wJMRZlZ/nowws/pzoDOzOnPC8CwJ0hWGE0dBcxJahzOSN4d7UIV4WOkSt0sSycAAS1rVbVIViAGORfqjPNYaTrYZO6m6Im8rJ+k4I6s19e43W+k+Wo30EfNWRj9KfSUTFYgBIqNNVhXixHuXqkDck02xCBfeNLMFoF5xzoHOzDrVbdfVF7A2s8kCaEXekiBpiaQtkp6StFPSzeX62yTtkrRd0n1tF7leJOk7kp4uf+eSafo9TdJmSc+WP0+tGocDnZl1iswl7RhwWUS8ExgB1kp6F7AZuCgi3gH8X+DGsv1fAkTE24H3Al+Tuh5FvQF4JCJWAY+U96flQGdmHRR5S0oUDpd3h8slIuLhiJiYzXscOKe8fSFF4CIiDgCHgNVdur4S2Fje3ghcVTUOBzoz66BWZC3Acklb25b1HX1JDUnbgAPA5oh4YkqTjwMPlrefAq6UdJKk84A/AVZ2GeJbImIfQPnzzKrX48kIM5tsZtVLDkZEty2u33UX0QRGyuNw90m6KCJ2AEi6CRgH7i6b3wX8IbAVeA74afn4rMx5oBtK5lglCm9mfAKNjISlnH7SeXTpwpvDZBTnHKouzrmklS7euTgjp29pI53Td6xV/ZXIKd452qrOxQMYHqpuM5aRIzfeyvicE0U1AVqpfbCcopo5BTFz2qS+lnNQeLNIGO79tGtEHJL0KLAW2CFpHfBB4D0RxROWu7OffmMs0k+BZ7t0t1/SiojYJ2kFxdbitLzramadWplLgqQz2mZUlwKXA7skrQU+C1wREUfa2p8saVl5+73AeEQ806Xr+4F15e11wA+qxpHcopO0EvhvwL+geGkbIuLvJJ0G/HfgXGAP8O8j4rep/sxs/uvhFt0KYKOkBsWG1aaIeEDSbmAxsFnFFvPjEXEdxbG2hyS1gOeBa94Yk3QncEdEbAVuBTZJ+gTwa+DDVYPI2XUdBz4TET+X9CbgSUmbgf9IMb17q6QbKKZ3P5v/+s1sXuphheGI2A5c3GX9+dO03wNcMM1j17bdfhF4T+44kruuEbEvIn5e3n4V+AVwNjOc3jWzQZE34zpI58POaDJC0rkU0fkJpkzvSuo6vVtON68HeOvZnuQ1Gwg1K7yZPRkh6RTgXuCvI+KV3N+LiA0RsToiVi8/3XMfZvNeeQHrnGVQZEUeScMUQe7uiPiHcvX+clqXnOldMxsgEXnLgEgGOhVTIt8GfhERX297aEbTu2Y2QHp3ruu8kHPQ7N0UU7xPl6dxAPwNM5ze7ZVGRvJmOikZGhkfUiPxSS7KSCRalJFUnGqTSijObbN4KJ1UnGrzutLFOxcNpV/zWKO6TaOZTjpuZJxs2RxKf0bdzxlvfzyj8GbOiZ85icfJPmbfRdbTZCRjD5JkoIuIx5j+7c2e3jWzARFkVkMeHJ4GNbNJRJyQU8D6yYHOzDo50JlZ7TnQmVmt+RidmS0EC27W1cwWmsFKBs7hQGdmkwUOdLMhRCN1WfSo3mTO2aBu5CQM5yQeJz7soYwk0eGMyr+pNkMZrzqr2nFGm5MSyb45ScdHh9Jfq1SF55xk4KGsZOB04nHyKi85BYYz2uQlFSc7SffRC/Xac/UWnZl1ch6dmdWfA52Z1VoENOu17+pAZ2advEVnZrXnQGdmtRbAAF0PIocDnZlNEck0r0HjiziY2WRBMRmRsyRIWiJpi6SnJO2UdHO5/jZJuyRtl3Rf20WuhyVtlPS0pF9IunGafr8o6XlJ28rlA1XjGLgtuqGs2JxOjM3ppZHIzWxkHMdIVSnOaZNTpXgo40oljYw2qaTinCTpnDaNRLJv3vMkm2RVB04l+2YlA6ebDJbeHaM7BlwWEYfLa888JulBYDNwY0SMS/oycCPFdaE/DCyOiLdLOhl4RtL3yuu9TvWNiPhqziC8RWdmnXp0cZwoHC7vDpdLRMTDETFxms3jwDkTvwIsk3QSsBQYBbKvOjgdBzozmyIzyBWBbrmkrW3L+qm9SWqU15s5AGyOiCemNPk48GB5+38ArwH7KK5F89WIeGmagV5f7vreJenUqlfkQGdmkwXQauUtcHDius3lsqGju4hmRIxQbLWtkXTRxGOSbgLGgbvLVWsojj2dBZwHfEbSH3QZ5TeBtwEjFEHxa1UvyYHOzDqdgOu6RsQh4FFgLYCkdcAHgb+IeKOz/wD8KCLGIuIA8L+B1V362l8G0BbwLYoAOS0HOjObIno563pG24zqUuByYJektRSTD1dExJG2X/k1cJkKy4B3Abu69Lui7e6HgB1V4xi4WVczO8ECond5dCuAjSrqZQ0BmyLiAUm7gcXAZhXT2o9HxHXA7cB3KAKXgO9ExHYASXcCd0TEVuArkkaK0bIH+GTVIBzozKxTj86MKIPUxV3Wnz9N+8MUKSbdHru27fY1MxnHvAt0qcKcrUjnlC1EjYxKialilzly8vVycuDmoo+BlCy8OSej8LmuZlZzERMzqrXhQGdmnbxFZ2b1FkSzXoeIHOjMbDKXaTKzBaFmZZoc6MxskgDCW3RmVmtRv8KbDnRm1qFukxGKOZxGlvT/gOfaVi0HDs7ZAGZvkMY7SGOFwRrvfB7rv4yIM2bTgaQfUbzGHAcjYu1snm8uzGmg63hyaWtEdFQmmK8GabyDNFYYrPEO0lit4OolZlZ7DnRmVnv9DnQd1UjnuUEa7yCNFQZrvIM0VqPPx+jMzOZCv7fozMxOOAc6M6u9vgU6SWsl/VLSbkk39GscOSTtKa8cvk3S1n6PZ6rycm8HJO1oW3eapM2Sni1/Vl4Obi5NM94ZXXl9rkhaKenH5VXjd0r6T+X6efv+Wqe+BLqyfvztwJ8BFwIflXRhP8YyA5dGxMg8zZ/6LuWVldrcADwSEauAR8r788V36RwvFFdeHymXH87xmKYzDnwmIv6Q4kItnyq/q/P5/bUp+rVFtwbYHRG/iohR4PvAlX0ay8CLiJ8AUy/yeyWwsby9EbhqTgdVYZrxzksRsS8ifl7efhX4BXA28/j9tU79CnRnA79pu7+3XDdfBfCwpCe7XYl8nnpLROyD4o8VOLPP48mRfeX1fpB0LsWFXp5gMN/fBatfga7bJUDmc57LuyPijyl2tT8l6U/7PaAamtGV1+eapFOAe4G/johX+j0em5l+Bbq9wMq2++cAL/RpLEkR8UL58wBwH4mrgs8T+ycu8lv+PNDn8VSa6ZXX55KkYYogd3dE/EO5eqDe34WuX4HuZ8AqSedJWgR8BLi/T2OpJGmZpDdN3AbeR+Kq4PPE/cC68vY64Ad9HEvSTK+8PldUXF3528AvIuLrbQ8N1Pu70PXtzIgyfeBvgQZwV0Tc0peBJEj6A4qtOCjq990z38Yq6XvAJRSldfYDXwD+EdgEvBX4NfDhiJgXEwDTjPcSit3WN668PnEMrJ8k/TvgfwFPwxsXz/0biuN08/L9tU4+BczMas9nRphZ7TnQmVntOdCZWe050JlZ7TnQmVntOdCZWe050JlZ7f1/P6KvFJPkFCUAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 432x288 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "m.sr.rotation = 30.\n",
     "nodata = 0.\n",
@@ -226,30 +135,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'driver': 'GTiff', 'dtype': 'float32', 'nodata': 0.0, 'width': 25, 'height': 25, 'count': 1, 'crs': None, 'transform': Affine(400.0, 0.0, 0.0,\n",
-      "       0.0, -400.0, 10000.0)}\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "try:\n",
     "    import rasterio\n",
@@ -271,22 +159,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 792x612 with 5 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "grad = get_gradients(hds, m, nodata=-999)\n",
     "\n",
@@ -312,29 +187,16 @@
    "metadata": {},
    "source": [
     "### Get the saturated thickness of a layer\n",
-    "`get_saturated_thickness()` returns an nlay, nrow, ncol array of saturated thicknesses."
+    "`m.modelgrid.saturated_thick()` returns an nlay, nrow, ncol array of saturated thicknesses."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUIAAAEICAYAAAAqbv2WAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAev0lEQVR4nO3dfZRlVX3m8e/T1SiCEEBehAYDKDq+TGhND9GQMBAVmZ4YfBdiFDEzbSZCzMQkdjQZnbiyljEhhpk4JNCCJAswCra2LtKAxEhMBtK09kJemtDpaaUs7KZFQkdemq565o9zCu6te6vuqapTde+p+3xYZ917XvY5+96+/Grvs/fZW7aJiBhmy/qdgYiIfksgjIihl0AYEUMvgTAihl4CYUQMvQTCiBh6CYQRMfQSCJcISTskvabf+Wgl6WhJGySNSbKk4/udp4huEgijFpKWd9k8AWwE3rzI2YmYlQTCJU7SoZK+IulBST8s3x9b7nurpM1Tjv+ApC+W758p6Y8lfVfSTkl/LulZ5b7TJY1K+qCk7wNXTL227Z22/w+waeE/acTcJRAufcsogtSPA88DHgP+rNy3AThB0otbjv8l4K/K938IvBBYCbwAWAH8j5ZjnwscVp57zQLlP2LBKc8aLw2SdgD/xfZXexy3Evia7UPL9UuAh2x/WNJLgW9QBLi9wL8BP2H7X8pjXwVcbfsESacDNwIH2368xzWXA08CJ9jeMfdPGbEwut3XiSVE0gHAJ4GzgEPLzQdJGrE9DlwJXCPpd4F3Ap+z/YSkI4EDgM2SnjodMNJy+gd7BcGIJkjVeOn7APAi4KdsHwycVm4XgO1bKUp/Pwv8Ik9Xi3dTVKNfavuQcvkx289uOXeqE7EkJBAuLftJ2r9lWQ4cRBHQHpZ0GPCRLun+kuK+4T7b3wCwPQFcBnyyLB0iaYWk180mQ5L2B55Zrj6zXI8YKAmES8v1FEFvcvko8KfAsyhKeLdSdGeZ6q+Al/F0aXDSB4FtwK2SHgG+SlG6nI3HKO41Amwt1yMGShpLgrJLzC7gFbbv63d+IhZbSoQB8N+ATQmCMazSajzkym43At7Q56xE9E2qxhEx9FI1joiht6hV48MPG/Hxx+03r3O4pq5rVc4y0eOoKqXpiQrXGUcz7p/osR9g3L3/po1X+Lu3zyM99vc+x5M9zgGwb2LmY56cqPB5KhwzMV7hb/34zN+v9vU+xbIqxzzZ+/cy8sTMvxg/NnP/9cf5EXv9RO8fzAxed8aB/sFD45WO3XzHEzfYPms+1xsEixoIjz9uP/7phuPmdY5x9w4tvQIYwJPu/Q/9hGf+dT9eIS+PV4i4ezzzP8OjE73/eDw8cUDvY8Z7H/OD8WfPuH/Xkwf3PMeDew/qecyux3tc59He53joR70/z6OP9O62qIdn/n6f8VDvYPqsB3v/Qz/7gd6/uQO3PzLj/ok7ts64/zbf3PMavfzgoXH+6YbnVTp25Oj7Dp/3BQfAvKrGks6SdK+kbZLW1pWpiOgfAxMV/1sq5lwilDQCfAp4LTAKbJK0wfbddWUuIhafcaUa01IynxLhKcA229tt7wU+C5xdT7Yiop9SIqxuBXB/y/oo8FNTD5K0hnKsuuetSLfFiEFnzPiQdaubT4mwW8tUx7dn+1Lbq2yvOuI5vVsTI6L/JnClZamYTxFtFGhtAj4WGJtfdiKi3wyML6EgV8V8SoSbgJMknSDpGcA5FEO/R0TDpURYke19ki4AbqAYtfhy23fVlrOI6AsDTw7ZPcJ5tV7Yvp5iDLyIWCKMh65qnGbciGhnGB+uOJhAGBHtiidLhksCYURMoZ4DgSw1CYQR0aZoLEkgjIghVvQjTCCMiCE3UWOJUNIhwDqKmRINvAf4dZ6eEfEQ4GHbK7uk3QHsAcYppptdVVvGWiQQRkSbBSgRXgxstP2W8uGLA2y/fXKnpIuAf50h/Rm2d9eZoakSCCOijVGl0cyrkHQwcBrwboBypKq9LfsFvA34uVouOEeZsyQiOkxYlRbgcEm3tyxrppzqROBB4ApJ35K0TtKBLft/Ftg5w1SyBm6UtLnLuWuTEmFEtDFib4V5Z0q7e9y3Ww68ArjQ9m2SLgbWAr9X7j8XuGaG9KfaHpN0JHCTpK22b6mauapSIoyINkWH6mWVlgpGgVHbt5Xr11IERiQtB94E/PW0ebHHytddwHqKAaFrl0AYER3Gy07VvZZebH8fuF/SZAvxq4HJ6TxeA2y1PdotraQDJR00+R44E7hzvp+tm1SNI6KNrUrTw87ChcBVZYvxduD8cvs5TKkWSzoGWGd7NXAUsL5oT2E5cLXtjXVmbFICYUR0qDKXdlW2twAd9xFtv7vLtjFgdfl+O3BybRmZQQJhRLQpGkuGKzQM16dtqMV83Gmi3ipRNNBkY8kwSSCMiA7jGXQhIoZZnU+WNEUCYUR0GLZbJAmEEdGmGHQhgTAihpgRT1Z/xG5JSCCMiDY2dXeoHngJhBExhWrtUN0ECYQR0cakRLgkTAzQZISDk5PhuwEeczdsv5UlGQgjYu6Map2zpAkSCCOiTTGd53CFhuH6tBFRQSZ4j4ghZ/JkSURESoQRMdxspUQYEcOtaCzJI3YRMdRqn7Nk4A3Xp20xUeG/iGFUNJZUnuC9J0mHSLpW0lZJ90h6laSPSvqepC3lsnqatGdJulfSNklr6/ycreZVIpS0A9gDjAP7ekz0HBENUfOTJRcDG22/pZzJ7gDgdcAnbf/xdIkkjQCfAl5LMT/yJkkbbN89XZq5qqNqfIbt3TWcJyIGQJ1Plkg6GDgNeDeA7b3A3nKKzl5OAbaVs9kh6bPA2Tw9L3JthrZqHBHTm2BZpaWCE4EHgSskfUvSunKydoALJN0h6XJJh3ZJuwK4v2V9tNxWu/kGQgM3StosaU23AyStkXS7pNsf/MH4PC8XEQvNhicnllVagMMn//8ul6lxYDnwCuAS2y8HfgSsBS4Bng+sBB4ALuqSlW7FRtf1Oadmcj5OtT0m6UjgJklbbd/SeoDtS4FLAVadvP+CfIiIqE9RNa5cRtrdo21gFBi1fVu5fi2w1vbOyQMkXQZ8ZZq0x7WsHwuMVc3YbMyrRFjOSo/tXcB6ijp9RDTcePm8ca+lF9vfB+6X9KJy06uBuyUd3XLYG4E7uyTfBJwk6YSykeUcYMP8Pll3cy4RlvX8Zbb3lO/PBH6/tpxFRF9Mdp+p0YXAVWUw2w6cD/wvSSvLy+0A3gsg6Rhgne3VtvdJugC4ARgBLrd9V50ZmzSfqvFRwPqy9Wc5cLXtjbXkKpa8YRvvrlnqfcTO9hZgavX5ndMcOwasblm/Hri+tsxMY86BsGzSPrnGvETEgMicJREx1IpW4zxrHBFDLEP1R0SQqnFEDLkFaDUeeAmEEdEhA7NGxFCzxb4EwogYdqkaRyMN22Q7UHTzWAwasifkm36PsBzJ5jjbd1RNk0AYER2aFggl/R3wCxQxbQvwoKSv2/6NKumH60ZARPQ02Y+wrqH6F8mP2X4EeBNwhe2fBF5TNXECYUR0mECVlgGyvBzR5m10H9Jr5sT15ycimsyGfRONKyP9PsUoNd+wvUnSicB9VRMnEEZEhwGr9vZk+/PA51vWtwNvrpq+cWE/IhZWE+8RSvqEpIMl7SfpZkm7Jf1S1fQJhBHRwValZYCcWTaW/DzFEP8vBH6rauJUjSOiw4A1hFSxX/m6GrjG9kMVpwwFEghjAYzXUFKoq9pVpdN14/6XX2B28+4RAl+WtBV4DPhVSUcAj1dNnEAYEVOI8Ya1GtteK+kPgUdsj0t6lGIy+Eqa9WkjYlE07R6hpAOA91HMlwxwDJ3zpEwrJcKIaFP3s8aSDgHWAS8rT/8eiidAXg/sBf4FON/2w13S7gD2AOPAvhnmUL4C2Az8dLk+StGdplLn6pQII6Kdi/uEVZaKLgY22v53FBO+3QPcBLzM9k8A/wz8zgzpz7C9ssdE8s+3/QngSQDbjzGL278JhBHRoa5H7CQdDJwGfBrA9l7bD9u+0fa+8rBbgWPnmeW9kp5FUeJE0vOBJ6omTiCMiDYuG0uqLMDhkm5vWdZMOd2JwIPAFZK+JWmdpAOnHPMe4G+mzQ7cKGlzl3O3+giwEThO0lXAzcBvV/3MuUcYER1mUe3d3aPKuhx4BXCh7dskXQysBX4PQNKHgX3AVdOkP9X2mKQjgZskbbV9S2d+fZOkbwKvpKgSv9/27qofIiXCaDOOZl68rOcSzVdjq/EoMGr7tnL9WorAiKTzKJ4EeYfdPfTaHitfdwHrgVNmuNb+wA+BR4CXSDqtSgYhJcKImKJoCKmrQ7u/L+l+SS+yfS/wauBuSWcBHwT+o+1Hu6Utq9DLbO8p359JMcpMt2P/EHg7cBcwMXl5oKP02E0CYUR0qPnJkguBqyQ9A9gOnA9sAp5JUd0FuNX2r0g6BlhnezVwFLC+3L8cuNr2xmmu8QbgRbYrN5C0SiCMiA51zgdjewudnZtfMM2xYxTPC08OpXVyxctsp3jeOIEwIubPiImGPWIHPApskXQzLcHQ9q9VSZxAGBEdGjhx34ZymZMEwohoV2NjySK60/bm1g2SXl81cePKvxGxCFxxGRyXSfr3kyuSzgV+t2rilAgjokMDS4RvAa6V9A7gZ4B3UXS3qSSBcB7GazrPYg2CWceAqUtSHSWbwSodzYuBiYlm/VZsb5d0DvBF4H6Kofsfq5o+gTAi2hloyB9NSd+m/c/QYcAIcJskytFteuoZCCVdTvEYzC7bLyu3HQb8NXA8sAN4m+0fzuYDRMTgqrMf4QL7+TpOUqWx5DPAWVO2rQVutn0SxSgPa+vITEQMiIY0ltj+ju3vAEcDD7WsPwQ8t+p5egbCcqSHh6ZsPhu4snx/JcXjLRGxJFQbcGHAGlQuAf6tZf1HPD1sf09z7T5zlO0HAMrXI6c7UNKaybHKHvxBXc0LEbGgGlIibKHWEWxsTzCLNpAF70do+1Lbq2yvOuI5Iwt9uYiYL4MnVGkZINsl/Zqk/crl/RTPH1cy10C4U9LRAOXrrjmeJyIGkiouA+NXKCZu+h7FGIg/Bcw0onWbuXaf2QCcB3y8fP3SHM8TEYNosKq9PZUDt54z1/RVus9cA5xOMTfBKMXcAB8HPifpl4HvAm+dawait/E8CRmLrSGBUNJv2/6EpP9Nl1zXNvqM7XOn2fXqKheIiIZpUIdqiqlBAW6fz0nyZElEdGhKh2rbXy5fr+x17EwSCCOi02C1CPck6YXAb1I87fZUXLP9c1XSJxBGRAc1pETY4vPAnwPrmMN4KAmEEdFu8DpLV7HPduUnSaZKc2RETKGisaTKUuVs0iGSrpW0VdI9kl4l6TBJN0m6r3w9dJq0Z0m6V9I2SR1jGpTnOQz4sqRflXT05LZyeyUpEUZEp3pLhBcDG22/pZzS8wDgQxQDt3y8DHBrKeY5foqkEeBTwGspOklvkrTB9t0th20uczsZlX9ryqc4sUoGEwgjotNE70OqkHQwcBrwbgDbe4G9ks6m6J8MxcAtf8eUQAicAmwrp/VE0mcpBnx5KhDaPqHct7/tx6dce/+q+UzVOCLaTfYjrFY1PnxyUJVymfpY24nAg8AVkr4laZ2kA6k2cMsKitGmJ42W27r5x4rbukqJMCI6zKLVeLftqZO3t1oOvAK40PZtki6m+vil3W5CtuVM0nMpguOzJL28Jc3BFFXwShIII6JTffcIR4FR27eV69dSBMKdko62/cAMA7eMAse1rB8LjE055nUU1e5jgYt4OhA+QnEfspIEwohYMLa/L+l+SS+yfS/Fo7l3l0uvgVs2ASdJOoFiVJlzgF+ccv4rgSslvdn2dXPNZwJhRHSouUP1hcBVZYvxduB8ivaJjoFbJB0DrLO92vY+SRcAN1BMyHS57bu6XWA+QRASCCNiKlPrI3a2twDd7iN2DNxiewxY3bJ+PXB9bZmZRgJhRHRq3pMl85JAGBEdmvKssaQ3zbTf9heqnCeBMCI6NSQQAq8vX4+kGKr/b8v1Myg6aScQRsQcNSQQ2j4fQNJXgJdMdtIuu+R8qup5Eggjoo3cnKpxi+Mng2BpJ/DCqokTCCOiU8MGZgX+TtINwDUU5dlzgK9VTZxAGBEdmlYitH2BpDdSDPAAcKnt9VXTJxBGRKeGBcLSN4E9tr8q6QBJB9neUyVhRp+JiHZ++j5hr2VQSPqvFM8x/0W5aQXwxarpEwgjopMrLoPjfcCpFIMtYPs+ug/t1VWqxhHRQTUNzLqInrC9VyoaeSQtZxahOoGwAUbqGi44Yun6uqQPUYxL+FrgV4EvV02cqnFEdGpe1XgtxUjY3wbeC1xv+8NVE6dEGBHtBqwhpKILbV8MXDa5QdL7y209pUQYEZ2aVyI8r8u2d1dNnBJhRHQarCA3LUnnUoxafYKkDS27DgJ+UPU8CYQR0UY0qtX4H4EHgMMp5iyZtAe4o+pJEggjol2D7hHa/g7wHeBV8zlP7hFGRKeG3SOU9EpJmyT9m6S9ksYlPVI1fUqEEdGpxiAnaQdFVXUc2Gd7laS/Bl5UHnII8LDtlVXSTnOZP6MYcebzFPOjvAt4QdU8JhDOw0hN51nWqx5S049ypCn1ncVWx4hTjRu1amYL8FM5w/buyRXbb3/qWtJFwL9WTTsd29skjdgeB66Q9I9VM9ezaizpckm7JN3Zsu2jkr4naUu5rJ7pHBHRMItUNVbxTNzbKMYRnI9Hy+lCt0j6hKT/DhxYNXGVe4SfAc7qsv2TtleWy4JPtxcRi8RFq3GVpfoZuVHSZklrpuz7WWBnOUjCbNO2eidFPLsA+BFwHPDmqhnsWTW2fYuk46ueMCKWgOqlvcMl3d6yfqntS6ccc6rtMUlHAjdJ2mr7lnLfucxcGpwpLQCSRoA/sP1LwOPA/6yc+9J87hFeIOldwO3AB2z/sNtBZRRfA/C8FbklGdEEs7hHuHuGBgzgqUnbsb1L0nrgFOCWcoSYNwE/Odu0U44Zl3SEpGfY3ls55y3m2n3mEuD5wEqKzowXTXeg7Uttr7K96ojn1NW8EBELqqZ7hJIOlHTQ5HvgTGCyveE1wFbbo3NIO9UO4B8k/Z6k35hceuewMKcimu2dLZm9DPjKXM4TEQOo3j6CRwHry3EClwNX295Y7juHKdViSccA62yv7pF2qrFyWUbxeN2szCkQSjq6Zeq8NzJ9lI6IhhH1dZ+xvR04eZp97+6ybQxY3Sttl3Szvi/YqmcglHQNcDrFTdFR4CPA6ZJWUvzd2EEx/ldELBFN63Iq6Wt0Kcfa/rkq6au0Gp/bZfOnq5w8mmekR51opEFP48c8NCwQAr/Z8n5/iq4z+6omTjNuRHRqWCC0vXnKpn+Q9PWq6RMII6Jdg0afmSTpsJbVZRRdcp5bNX0CYUR0alggBDZT5FoUVeL/B/xy1cQJhBHRoYG3gl9s+/HWDZKeWTVxxiOMiA5ytWWAdBtp5v9WTZwSYUS0G7BBV2ci6bnACor5jF/O0wOiHQwcUPU8CYQR0akhgRB4HcVsdccCf9KyfQ/woaonSSCM2tUxAGzPwWor0hIbMHUx1PlkyUKzfSVwpaQ3275urudJIIyIDppoSCQs2b5O0n8GXkrRoXpy++9XSZ9AGBHtGnSPcJKkP6e4J3gGsA54C/BPVdOn1TgiOjSw1finbb8L+GE5AMOrKEapriSBMCI6NWw6T+Cx8vXRciivJ4ETqiZO1TgiOgxYaa+Kr0g6BPgj4JsUYfqyqokTCCOiU8MCoe2PlW+vk/QVYH/bM00R2iZV44hoV/8sdgtG0n8oO1VPrr8L+BzwsSkDMcwogTAi2kz2I2xIY8lfAHsBJJ0GfBz4S4oJ46fOpjetVI2XiF4Dqi5Fi9VZ2sPYKduN+T2N2H6ofP92iulEr6OoIm+pepKUCCOiQ4NKhCPltKAArwb+tmVf5YJeAmFEtKvadaZiIJS0Q9K3JW2ZnAxe0kclfa/ctkXS6mnSniXpXknbJK3tcsg1wNclfYmiC83fl+leQFE9riRV44josAANIWfY3j1l2ydt//G0eZBGgE8BrwVGgU2SNti+e/IY238g6WbgaOBG+6k6/TLgwqqZSyCMiA6D0CIMnAJsK6f1RNJngbOBu1sPsn3r1IS2/3k2F0rVOCLamaKxpMpSTPN7e8uyZpoz3ihp85T9F0i6Q9Llkg7tkm4FcH/L+mi5rXYpEUZEh1k0hOy2varHMafaHpN0JHCTpK3AJcDHKILkx4CLgPdMzUaXcy1IE01KhBHRqcbGEttj5esuYD1wiu2dtsdtT1A8CndKl6SjtA+ccCwwNodP01MCYUS0qbNDtaQDJR00+R44E7hT0tEth70RuLNL8k3ASZJOkPQM4Bxgwzw/XlepGkdf1DUCdSwAu86BWY8C1qvo/b4cuNr2Rkl/JWklRblyB/BegHLkmHW2V9veJ+kC4AZgBLjc9l11ZaxVAmFEdKopDpYtvid32f7OaY4fA1a3rF8PXF9PbqaXQBgRHYatwJ5AGBHtDDRszpL5SiCMiE7DFQcTCCOiU6rGETH0mjad53wlEEZEu8GbmGnBDW0gXFapL/lgPHkesZiKDtXDFQmHNhBGxAyGrAzQs1gk6ThJX5N0j6S7JL2/3H6YpJsk3Ve+dhs9IiIaSHalZamoUj/cB3zA9ouBVwLvk/QSYC1ws+2TgJvL9YhouppHqG6CnoHQ9gO2v1m+3wPcQzEm2NnAleVhVwJvWKhMRsRiKp41rrIsFbO6RyjpeODlwG3AUbYfgCJYlmONdUuzBlgD8LwVuSUZ0QhLqNpbReVhuCQ9G7gO+HXbj1RNZ/tS26tsrzriOSNzyWNELKYGTfBel0qBUNJ+FEHwKttfKDfvnBxTrHzdtTBZjIhFV32o/iWhSquxgE8D99j+k5ZdG4DzyvfnAV+qP3sR0RdD1lhS5abdqcA7gW+3zBz/IeDjwOck/TLwXeCtC5PF2avSWXqc8UXIyWANAT4ybJ3DYs40MVy/lZ6B0PY36D6JChQzy0fEUmKGrkN1mnEjoo1YWp2lq0ggjIhOCYQRMfQSCCNiqNV8j1DSDmAPMA7ss71K0h8Brwf2Av8CnG/74Spp68vZ0wapUTMiBoQmJiots3CG7ZUtgewm4GW2fwL4Z+B3ZpG2dgmEETFFxc7U86g+277R9r5y9Vbg2FqyPkcJhBHRzswmEB4u6faWZc00Z7xR0uZp9r8H+JsZcjNT2lrkHmEDjCxiF/5lS+kB0pi76j+D3RWqrKfaHisHZrlJ0lbbtwBI+jDFUH9XzTZtnVIijIgOdQ7ManusfN0FrAdOAZB0HvDzwDvs7iebLm3dEggjolNN9wglHSjpoMn3wJnAnZLOAj4I/ILtR2eTtqZP2CZV44hoZ8N4bbdIjgLWF2O3sBy42vZGSduAZ1JUdwFutf0rko4B1tlePV3aujLWKoEwIjrV1KHa9nbg5C7bXzDN8WPA6pnSLoQEwojolCdLImKoGVhC85FUkUAYEVMYPFzdqBIII6KdqbOxpBESCCOiU+4RRsTQSyCMiOG2tGaoqyKBMCLaGcjkTREx9FIijIjhVusjdo2QQBgR7QxOP8KIGHp5siQihl7uEUbEULPTahwRkRJhRAw54/HxfmdiUSUQRkS7DMMVEUGG4YqI4WbAKRFGxFBzBmaNiBi6xhJNM6/ywlxMehD4Tsumw4Hdi5aB+WtSfpuUV2hWfgc5rz9u+4j5nEDSRorPWMVu22fN53qDYFEDYcfFpdttr+pbBmapSfltUl6hWfltUl6jmmX9zkBERL8lEEbE0Ot3ILy0z9efrSblt0l5hWblt0l5jQr6eo8wImIQ9LtEGBHRdwmEETH0+hYIJZ0l6V5J2ySt7Vc+qpC0Q9K3JW2RdHu/8zOVpMsl7ZJ0Z8u2wyTdJOm+8vXQfuax1TT5/aik75Xf8RZJq/uZx0mSjpP0NUn3SLpL0vvL7QP7/cbs9SUQShoBPgX8J+AlwLmSXtKPvMzCGbZXDmj/sc8AUzu1rgVutn0ScHO5Pig+Q2d+AT5ZfscrbV+/yHmazj7gA7ZfDLwSeF/5Wx3k7zdmqV8lwlOAbba3294LfBY4u095aTzbtwAPTdl8NnBl+f5K4A2LmqkZTJPfgWT7AdvfLN/vAe4BVjDA32/MXr8C4Qrg/pb10XLboDJwo6TNktb0OzMVHWX7ASj+ZwaO7HN+qrhA0h1l1XngqpqSjgdeDtxGM7/fmEa/AqG6bBvkfjyn2n4FRVX+fZJO63eGlqBLgOcDK4EHgIv6m512kp4NXAf8uu1H+p2fqFe/AuEocFzL+rHAWJ/y0pPtsfJ1F7Ceomo/6HZKOhqgfN3V5/zMyPZO2+MuJtS9jAH6jiXtRxEEr7L9hXJzo77fmFm/AuEm4CRJJ0h6BnAOsKFPeZmRpAMlHTT5HjgTuHPmVANhA3Be+f484Et9zEtPk0Gl9EYG5DuWJODTwD22/6RlV6O+35hZ354sKbtH/CkwAlxu+w/6kpEeJJ1IUQqEYvzGqwctr5KuAU6nGDppJ/AR4IvA54DnAd8F3mp7IBoopsnv6RTVYgM7gPdO3oPrJ0k/A/w98G1gcrTSD1HcJxzI7zdmL4/YRcTQy5MlETH0EggjYuglEEbE0EsgjIihl0AYEUMvgTAihl4CYUQMvf8PsiyvKtoAKXEAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 432x288 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "st = get_saturated_thickness(hds, m, nodata=-9999)\n",
+    "st = m.modelgrid.saturated_thick(hds, mask=-9999.)\n",
     "\n",
     "plt.imshow(st[0])\n",
     "plt.colorbar(label='Saturated thickness')\n",
@@ -352,22 +214,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "wt = get_water_table(heads=hds, nodata=-9999)\n",
     "\n",
@@ -389,24 +238,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[3.42867432e+03, 2.91529083e+03],\n",
-       "       [2.50000000e+03, 2.50000000e+03],\n",
-       "       [1.99999996e-01, 1.99999996e-01],\n",
-       "       [2.00000000e+04, 2.00000000e+04],\n",
-       "       [2.00000000e+04, 2.00000000e+04]])"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r=[20, 5] \n",
     "c=[5, 20]\n",
@@ -416,24 +250,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[3.42867432e+03, 2.50000000e+03],\n",
-       "       [2.50000000e+03, 2.50000000e+03],\n",
-       "       [9.99999978e-02, 1.99999996e-01],\n",
-       "       [0.00000000e+00, 1.00000000e+04],\n",
-       "       [0.00000000e+00, 0.00000000e+00]])"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r=[20, 5] \n",
     "c=[5, 20]\n",
@@ -454,24 +273,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[5.78310817e-01, 1.66664444e-01],\n",
-       "       [4.21672316e-01, 1.66664444e-01],\n",
-       "       [1.68668923e-05, 1.33331553e-05],\n",
-       "       [0.00000000e+00, 6.66657778e-01],\n",
-       "       [0.00000000e+00, 0.00000000e+00]])"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "trfrac = tr/tr.sum(axis=0)\n",
     "trfrac"
@@ -486,51 +290,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[5.e+01, 5.e+01],\n",
-       "       [5.e+01, 5.e+01],\n",
-       "       [1.e-02, 1.e-02],\n",
-       "       [2.e+02, 2.e+02],\n",
-       "       [2.e+02, 2.e+02]], dtype=float32)"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "m.lpf.hk.array[:, r, c]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[130., 130.],\n",
-       "       [ 50.,  50.],\n",
-       "       [ 20.,  20.],\n",
-       "       [100., 100.],\n",
-       "       [100., 100.]], dtype=float32)"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "m.dis.thickness.array[:, r, c]"
+    "m.modelgrid.thick[:, r, c]"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -550,9 +331,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.6"
+   "version": "3.8.10"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/flopy/discretization/grid.py b/flopy/discretization/grid.py
index 0f902e64..cabcf85f 100644
--- a/flopy/discretization/grid.py
+++ b/flopy/discretization/grid.py
@@ -280,8 +280,50 @@ class Grid:
 
     @property
     def top_botm(self):
-        new_top = np.expand_dims(self._top, 0)
-        return np.concatenate((new_top, self._botm), axis=0)
+        raise NotImplementedError("must define top_botm in child class")
+
+    @property
+    def thick(self):
+        """
+        Get the cell thickness for a structured, vertex, or unstructured grid.
+
+        Returns
+        -------
+            thick : calculated thickness
+        """
+        return -np.diff(self.top_botm, axis=0).reshape(self._botm.shape)
+
+    def saturated_thick(self, array, mask=None):
+        """
+        Get the saturated thickness for a structured, vertex, or unstructured
+        grid. If the optional array is passed then thickness is returned
+        relative to array values (saturated thickness). Returned values
+        ranges from zero to cell thickness if optional array is passed.
+
+        Parameters
+        ----------
+        array : ndarray
+            array of elevations that will be used to adjust the cell thickness
+        mask: float, list, tuple, ndarray
+            array values to replace with a nan value.
+
+        Returns
+        -------
+            thick : calculated saturated thickness
+        """
+        thick = self.thick
+        top = self.top_botm[:-1].reshape(thick.shape)
+        bot = self.top_botm[1:].reshape(thick.shape)
+        idx = np.where((array < top) & (array > bot))
+        thick[idx] = array[idx] - bot[idx]
+        idx = np.where(array <= bot)
+        thick[idx] = 0.0
+        if mask is not None:
+            if isinstance(mask, (float, int)):
+                mask = [float(mask)]
+            for mask_value in mask:
+                thick[np.where(array == mask_value)] = np.nan
+        return thick
 
     @property
     def units(self):
diff --git a/flopy/discretization/structuredgrid.py b/flopy/discretization/structuredgrid.py
index 9191de8a..d361e388 100644
--- a/flopy/discretization/structuredgrid.py
+++ b/flopy/discretization/structuredgrid.py
@@ -830,6 +830,11 @@ class StructuredGrid(Grid):
             vrts = np.array(pts).transpose([2, 0, 1])
             return [v.tolist() for v in vrts]
 
+    @property
+    def top_botm(self):
+        new_top = np.expand_dims(self._top, 0)
+        return np.concatenate((new_top, self._botm), axis=0)
+
     def get_cell_vertices(self, *args, **kwargs):
         """
         Method to get a set of cell vertices for a single cell
diff --git a/flopy/discretization/unstructuredgrid.py b/flopy/discretization/unstructuredgrid.py
index d936a75d..c0ffb514 100644
--- a/flopy/discretization/unstructuredgrid.py
+++ b/flopy/discretization/unstructuredgrid.py
@@ -443,6 +443,12 @@ class UnstructuredGrid(Grid):
         x, y = super().intersect(x, y, local, forgive)
         raise Exception("Not implemented yet")
 
+    @property
+    def top_botm(self):
+        new_top = np.expand_dims(self._top, 0)
+        new_botm = np.expand_dims(self._botm, 0)
+        return np.concatenate((new_top, new_botm), axis=0)
+
     def get_cell_vertices(self, cellid):
         """
         Method to get a set of cell vertices for a single cell
diff --git a/flopy/discretization/vertexgrid.py b/flopy/discretization/vertexgrid.py
index c67d0767..9ae16f46 100644
--- a/flopy/discretization/vertexgrid.py
+++ b/flopy/discretization/vertexgrid.py
@@ -125,6 +125,12 @@ class VertexGrid(Grid):
     def shape(self):
         return self.nlay, self.ncpl
 
+    @property
+    def top_botm(self):
+        new_top = np.expand_dims(self._top, 0)
+        # new_botm = np.expand_dims(self._botm, 0)
+        return np.concatenate((new_top, self._botm), axis=0)
+
     @property
     def extent(self):
         self._copy_cache = False
diff --git a/flopy/modflow/mfdis.py b/flopy/modflow/mfdis.py
index 9512c149..f7660c53 100644
--- a/flopy/modflow/mfdis.py
+++ b/flopy/modflow/mfdis.py
@@ -324,7 +324,7 @@ class ModflowDis(Package):
         Check layer thickness.
 
         """
-        return (self.thickness > 0).all()
+        return (self.parent.modelgrid.thick > 0).all()
 
     def get_totim(self):
         """
@@ -471,7 +471,7 @@ class ModflowDis(Package):
         """
         vol = np.empty((self.nlay, self.nrow, self.ncol))
         for l in range(self.nlay):
-            vol[l, :, :] = self.thickness.array[l]
+            vol[l, :, :] = self.parent.modelgrid.thick[l]
         for r in range(self.nrow):
             vol[:, r, :] *= self.delc[r]
         for c in range(self.ncol):
@@ -636,6 +636,11 @@ class ModflowDis(Package):
         thickness : util3d array of floats (nlay, nrow, ncol)
 
         """
+        warnings.warn(
+            "ModflowDis.thickness will be deprecated and removed "
+            "in version 3.3.5.  Use grid.thick().",
+            PendingDeprecationWarning,
+        )
         # return self.__thickness
         thk = []
         thk.append(self.top - self.botm[0])
@@ -750,7 +755,7 @@ class ModflowDis(Package):
         active = chk.get_active(include_cbd=True)
 
         # Use either a numpy array or masked array
-        thickness = self.thickness.array
+        thickness = self.parent.modelgrid.thick
         non_finite = ~(np.isfinite(thickness))
         if non_finite.any():
             thickness[non_finite] = 0
diff --git a/flopy/modflow/mfdisu.py b/flopy/modflow/mfdisu.py
index d960e45c..3802bba6 100644
--- a/flopy/modflow/mfdisu.py
+++ b/flopy/modflow/mfdisu.py
@@ -495,7 +495,7 @@ class ModflowDisU(Package):
         Check layer thickness.
 
         """
-        return (self.thickness > 0).all()
+        return (self.parent.modelgrid.thick > 0).all()
 
     def get_cell_volumes(self):
         """
@@ -927,266 +927,3 @@ class ModflowDisU(Package):
     @staticmethod
     def _defaultunit():
         return 11
-
-        # def get_node_coordinates(self):
-
-    #     """
-    #     Get y, x, and z cell centroids.
-    #
-    #     Returns
-    #     -------
-    #     y : list of cell y-centroids
-    #
-    #     x : list of cell x-centroids
-    #
-    #     z : array of floats (nlay, nrow, ncol)
-    #     """
-    #     # In row direction
-    #     y = np.empty((self.nrow))
-    #     for r in range(self.nrow):
-    #         if (r == 0):
-    #             y[r] = self.delc[r] / 2.
-    #         else:
-    #             y[r] = y[r - 1] + (self.delc[r] + self.delc[r - 1]) / 2.
-    #     # Invert y to convert to a cartesian coordinate system
-    #     y = y[::-1]
-    #     # In column direction
-    #     x = np.empty((self.ncol))
-    #     for c in range(self.ncol):
-    #         if (c == 0):
-    #             x[c] = self.delr[c] / 2.
-    #         else:
-    #             x[c] = x[c - 1] + (self.delr[c] + self.delr[c - 1]) / 2.
-    #     # In layer direction
-    #     z = np.empty((self.nlay, self.nrow, self.ncol))
-    #     for l in range(self.nlay):
-    #         if (l == 0):
-    #             z[l, :, :] = (self.top[:, :] + self.botm[l, :, :]) / 2.
-    #         else:
-    #             z[l, :, :] = (self.botm[l - 1, :, :] + self.botm[l, :, :]) / 2.
-    #     return y, x, z
-    #
-    # def get_lrc(self, nodes):
-    #     """
-    #     Get layer, row, column from a list of MODFLOW node numbers.
-    #
-    #     Returns
-    #     -------
-    #     v : list of tuples containing the layer (k), row (i),
-    #         and column (j) for each node in the input list
-    #     """
-    #     if not isinstance(nodes, list):
-    #         nodes = [nodes]
-    #     nrc = self.nrow * self.ncol
-    #     v = []
-    #     for node in nodes:
-    #         k = int(node / nrc)
-    #         if (k * nrc) < node:
-    #             k += 1
-    #         ij = int(node - (k - 1) * nrc)
-    #         i = int(ij / self.ncol)
-    #         if (i * self.ncol) < ij:
-    #             i += 1
-    #         j = ij - (i - 1) * self.ncol
-    #         v.append((k, i, j))
-    #     return v
-    #
-    # def get_node(self, lrc_list):
-    #     """
-    #     Get node number from a list of MODFLOW layer, row, column tuples.
-    #
-    #     Returns
-    #     -------
-    #     v : list of MODFLOW nodes for each layer (k), row (i),
-    #         and column (j) tuple in the input list
-    #     """
-    #     if not isinstance(lrc_list, list):
-    #         lrc_list = [lrc_list]
-    #     nrc = self.nrow * self.ncol
-    #     v = []
-    #     for [k, i, j] in lrc_list:
-    #         node = int(((k - 1) * nrc) + ((i - 1) * self.ncol) + j)
-    #         v.append(node)
-    #     return v
-    #
-    # def read_from_cnf(self, cnf_file_name, n_per_line=0):
-    #     """
-    #     Read discretization information from an MT3D configuration file.
-    #
-    #     """
-    #
-    #     def getn(ii, jj):
-    #         if (jj == 0):
-    #             n = 1
-    #         else:
-    #             n = int(ii / jj)
-    #             if (ii % jj != 0):
-    #                 n = n + 1
-    #
-    #         return n
-    #
-    #     try:
-    #         f_cnf = open(cnf_file_name, 'r')
-    #
-    #         # nlay, nrow, ncol
-    #         line = f_cnf.readline()
-    #         s = line.split()
-    #         cnf_nlay = int(s[0])
-    #         cnf_nrow = int(s[1])
-    #         cnf_ncol = int(s[2])
-    #
-    #         # ncol column widths delr[c]
-    #         line = ''
-    #         for dummy in range(getn(cnf_ncol, n_per_line)):
-    #             line = line + f_cnf.readline()
-    #         cnf_delr = [float(s) for s in line.split()]
-    #
-    #         # nrow row widths delc[r]
-    #         line = ''
-    #         for dummy in range(getn(cnf_nrow, n_per_line)):
-    #             line = line + f_cnf.readline()
-    #         cnf_delc = [float(s) for s in line.split()]
-    #
-    #         # nrow * ncol htop[r, c]
-    #         line = ''
-    #         for dummy in range(getn(cnf_nrow * cnf_ncol, n_per_line)):
-    #             line = line + f_cnf.readline()
-    #         cnf_top = [float(s) for s in line.split()]
-    #         cnf_top = np.reshape(cnf_top, (cnf_nrow, cnf_ncol))
-    #
-    #         # nlay * nrow * ncol layer thickness dz[l, r, c]
-    #         line = ''
-    #         for dummy in range(
-    #                 getn(cnf_nlay * cnf_nrow * cnf_ncol, n_per_line)):
-    #             line = line + f_cnf.readline()
-    #         cnf_dz = [float(s) for s in line.split()]
-    #         cnf_dz = np.reshape(cnf_dz, (cnf_nlay, cnf_nrow, cnf_ncol))
-    #
-    #         # cinact, cdry, not used here so commented
-    #         '''line = f_cnf.readline()
-    #         s = line.split()
-    #         cinact = float(s[0])
-    #         cdry = float(s[1])'''
-    #
-    #         f_cnf.close()
-    #     finally:
-    #         self.nlay = cnf_nlay
-    #         self.nrow = cnf_nrow
-    #         self.ncol = cnf_ncol
-    #
-    #         self.delr = Util2d(model, (self.ncol,), np.float32, cnf_delr,
-    #                             name='delr', locat=self.unit_number[0])
-    #         self.delc = Util2d(model, (self.nrow,), np.float32, cnf_delc,
-    #                             name='delc', locat=self.unit_number[0])
-    #         self.top = Util2d(model, (self.nrow, self.ncol), np.float32,
-    #                            cnf_top, name='model_top',
-    #                            locat=self.unit_number[0])
-    #
-    #         cnf_botm = np.empty((self.nlay + sum(self.laycbd), self.nrow,
-    #                              self.ncol))
-    #
-    #         # First model layer
-    #         cnf_botm[0:, :, :] = cnf_top - cnf_dz[0, :, :]
-    #         # All other layers
-    #         for l in range(1, self.nlay):
-    #             cnf_botm[l, :, :] = cnf_botm[l - 1, :, :] - cnf_dz[l, :, :]
-    #
-    #         self.botm = Util3d(model, (self.nlay + sum(self.laycbd),
-    #                                     self.nrow, self.ncol), np.float32,
-    #                             cnf_botm, 'botm',
-    #                             locat=self.unit_number[0])
-    #
-    # def gettop(self):
-    #     """
-    #     Get the top array.
-    #
-    #     Returns
-    #     -------
-    #     top : array of floats (nrow, ncol)
-    #     """
-    #     return self.top.array
-    #
-    # def getbotm(self, k=None):
-    #     """
-    #     Get the bottom array.
-    #
-    #     Returns
-    #     -------
-    #     botm : array of floats (nlay, nrow, ncol), or
-    #
-    #     botm : array of floats (nrow, ncol) if k is not none
-    #     """
-    #     if k is None:
-    #         return self.botm.array
-    #     else:
-    #         return self.botm.array[k, :, :]
-    #
-    # def check(self, f=None, verbose=True, level=1):
-    #     """
-    #     Check dis package data for zero and negative thicknesses.
-    #
-    #     Parameters
-    #     ----------
-    #     f : str or file handle
-    #         String defining file name or file handle for summary file
-    #         of check method output. If a sting is passed a file handle
-    #         is created. If f is None, check method does not write
-    #         results to a summary file. (default is None)
-    #     verbose : bool
-    #         Boolean flag used to determine if check method results are
-    #         written to the screen
-    #     level : int
-    #         Check method analysis level. If level=0, summary checks are
-    #         performed. If level=1, full checks are performed.
-    #
-    #     Returns
-    #     -------
-    #     None
-    #
-    #     Examples
-    #     --------
-    #
-    #     >>> import flopy
-    #     >>> m = flopy.modflow.Modflow.load('model.nam')
-    #     >>> m.dis.check()
-    #     """
-    #     if f is not None:
-    #         if isinstance(f, str):
-    #             pth = os.path.join(self.parent.model_ws, f)
-    #             f = open(pth, 'w', 0)
-    #
-    #     errors = False
-    #     txt = '\n{} PACKAGE DATA VALIDATION:\n'.format(self.name[0])
-    #     t = ''
-    #     t1 = ''
-    #     inactive = self.parent.bas6.ibound.array == 0
-    #     # thickness errors
-    #     d = self.thickness.array
-    #     d[inactive] = 1.
-    #     if d.min() <= 0:
-    #         errors = True
-    #         t = '{}  ERROR: Negative or zero cell thickness specified.\n'.format(
-    #             t)
-    #         if level > 0:
-    #             idx = np.column_stack(np.where(d <= 0.))
-    #             t1 = self.level1_arraylist(idx, d, self.thickness.name, t1)
-    #     else:
-    #         t = '{}  Specified cell thickness is OK.\n'.format(t)
-    #
-    #     # add header to level 0 text
-    #     txt += t
-    #
-    #     if level > 0:
-    #         if errors:
-    #             txt += '\n  DETAILED SUMMARY OF {} ERRORS:\n'.format(
-    #                 self.name[0])
-    #             # add level 1 header to level 1 text
-    #             txt += t1
-    #
-    #     # write errors to summary file
-    #     if f is not None:
-    #         f.write('{}\n'.format(txt))
-    #
-    #     # write errors to stdout
-    #     if verbose:
-    #         print(txt)
diff --git a/flopy/modflow/mfrch.py b/flopy/modflow/mfrch.py
index 063347b7..07013187 100644
--- a/flopy/modflow/mfrch.py
+++ b/flopy/modflow/mfrch.py
@@ -236,15 +236,13 @@ class ModflowRch(Package):
                 )
                 l = 0
                 for i, cbd in enumerate(self.parent.dis.laycbd):
-                    thickness[i, :, :] = self.parent.dis.thickness.array[
-                        l, :, :
-                    ]
+                    thickness[i, :, :] = self.parent.modelgrid.thick[l, :, :]
                     if cbd > 0:
                         l += 1
                     l += 1
-                assert l == self.parent.dis.thickness.shape[0]
+                assert l == self.parent.modelgrid.thick.shape[0]
             else:
-                thickness = self.parent.dis.thickness.array
+                thickness = self.parent.modelgrid.thick
             assert thickness.shape == self.parent.get_package(pkg).hk.shape
             Tmean = (
                 (self.parent.get_package(pkg).hk.array * thickness)[:, active]
diff --git a/flopy/mt3d/mtbtn.py b/flopy/mt3d/mtbtn.py
index 8b3c574b..ad2198d0 100644
--- a/flopy/mt3d/mtbtn.py
+++ b/flopy/mt3d/mtbtn.py
@@ -552,7 +552,7 @@ class Mt3dBtn(Package):
                 array_free_format=False,
             )
         else:
-            thickness = mf.dis.thickness.get_value()
+            thickness = mf.modelgrid.thick
             self.dz = Util3d(
                 self.parent,
                 (nlay, nrow, ncol),
diff --git a/flopy/utils/modpathfile.py b/flopy/utils/modpathfile.py
index 3e16ed81..8524517b 100644
--- a/flopy/utils/modpathfile.py
+++ b/flopy/utils/modpathfile.py
@@ -18,7 +18,423 @@ from ..utils.flopy_io import loadtxt
 from ..utils.recarray_utils import ra_slice
 
 
-class PathlineFile:
+class _ModpathSeries(object):
+    """
+    Base class for PathlineFile and TimeseriesFile objects.
+
+    This class served to reduce the amount of duplicated code and
+    increase maintainability of the modpath output methods
+
+    Parameters
+    ----------
+    filename : str
+        name of pathline or modpath file
+    verbose : bool
+        Write information to the screen. Default is False
+    output_type : str
+        pathline or timeseries file type
+
+    """
+
+    def __init__(self, filename, verbose=False, output_type="pathline"):
+        self.fname = filename
+        self.verbose = verbose
+        self.output_type = output_type.upper()
+
+        self._build_index()
+
+        # set output type
+        self.outdtype = self._get_outdtype()
+
+    def _build_index(self):
+        """
+        Set position of the start of the pathline data.
+        """
+        compact = False
+        self.skiprows = 0
+        self.file = open(self.fname, "r")
+        while True:
+            line = self.file.readline()
+            if isinstance(line, bytes):
+                line = line.decode()
+            if self.skiprows < 1:
+                if (
+                    "MODPATH_{}_FILE 6".format(self.output_type)
+                    in line.upper()
+                ):
+                    self.version = 6
+                elif (
+                    "MODPATH_{}_FILE         7".format(self.output_type)
+                    in line.upper()
+                ):
+                    self.version = 7
+                elif "MODPATH 5.0" in line.upper():
+                    self.version = 5
+                    if "COMPACT" in line.upper():
+                        compact = True
+                elif "MODPATH Version 3.00" in line.upper():
+                    self.version = 3
+                else:
+                    self.version = None
+                if self.version is None:
+                    errmsg = "{} is not a valid {} file".format(
+                        self.fname, self.output_type.lower()
+                    )
+                    raise Exception(errmsg)
+            self.skiprows += 1
+            if self.version == 6 or self.version == 7:
+                if "end header" in line.lower():
+                    break
+            elif self.version == 3 or self.version == 5:
+                break
+
+        # set compact
+        self.compact = compact
+
+        # return to start of file
+        self.file.seek(0)
+
+    def _get_outdtype(self):
+        outdtype = np.dtype(
+            [
+                ("x", np.float32),
+                ("y", np.float32),
+                ("z", np.float32),
+                ("time", np.float32),
+                ("k", np.int32),
+                ("particleid", np.int32),
+            ]
+        )
+        return outdtype
+
+    def get_maxid(self):
+        """
+        Get the maximum timeseries number in the file timeseries file
+
+        Returns
+        ----------
+        out : int
+            Maximum pathline number.
+
+        """
+        return self._data["particleid"].max()
+
+    def get_maxtime(self):
+        """
+        Get the maximum time in pathline file
+
+        Returns
+        ----------
+        out : float
+            Maximum pathline time.
+
+        """
+        return self._data["time"].max()
+
+    def get_data(self, partid=0, totim=None, ge=True):
+        """
+        get pathline data from the pathline file for a single pathline.
+
+        Parameters
+        ----------
+        partid : int
+            The zero-based particle id
+        totim : float
+            The simulation time.
+        ge : bool
+            Boolean that determines if pathline times greater than or equal
+            to or less than or equal to totim.
+
+        Returns
+        ----------
+        ra : np.recarray
+            Recarray with the x, y, z, time, k, and particleid.
+
+        """
+        ra = self._data
+        ra.sort(order=["particleid", "time"])
+        if totim is not None:
+            if ge:
+                idx = np.where(
+                    (ra["time"] >= totim) & (ra["particleid"] == partid)
+                )[0]
+            else:
+                idx = np.where(
+                    (ra["time"] <= totim) & (ra["particleid"] == partid)
+                )[0]
+        else:
+            idx = np.where(ra["particleid"] == partid)[0]
+        ra = ra[idx]
+        return ra[["x", "y", "z", "time", "k", "particleid"]]
+
+    def get_alldata(self, totim=None, ge=True):
+        """
+        get data from the output file for all particles and all times.
+
+        Parameters
+        ----------
+        totim : float
+            The simulation time.
+        ge : bool
+            Boolean that determines if pathline times greater than or equal
+            to or less than or equal to totim.
+
+        Returns
+        ----------
+        plist : list of numpy record arrays
+            A list of numpy recarrays
+
+        """
+        ra = self._data
+        ra.sort(order=["particleid", "time"])
+        if totim is not None:
+            if ge:
+                idx = np.where(ra["time"] >= totim)[0]
+            else:
+                idx = np.where(ra["time"] <= totim)[0]
+            if len(idx) > 0:
+                ra = ra[idx]
+        ra = ra[["x", "y", "z", "time", "k", "particleid"]]
+        return [ra[ra["particleid"] == i] for i in range(self.nid.size)]
+
+    def get_destination_data(self, dest_cells, to_recarray=True):
+        """
+        Get data for set of destination cells.
+
+        Parameters
+        ----------
+        dest_cells : list or array of tuples
+            (k, i, j) of each destination cell (zero-based)
+        to_recarray : bool
+            Boolean that controls returned series. If to_recarray is True,
+            a single recarray with all of the pathlines that intersect
+            dest_cells are returned. If to_recarray is False, a list of
+            recarrays (the same form as returned by get_alldata method)
+            that intersect dest_cells are returned (default is False).
+
+        Returns
+        -------
+        series : np.recarray
+            Slice of data array (e.g. PathlineFile._data, TimeseriesFile._data)
+            containing only pathlines with final k,i,j in dest_cells.
+
+        """
+
+        # create local copy of _data
+        ra = np.array(self._data)
+
+        # find the intersection of pathlines and dest_cells
+        # convert dest_cells to same dtype for comparison
+        if self.version < 7:
+            try:
+                raslice = ra[["k", "i", "j"]]
+            except (KeyError, ValueError):
+                msg = (
+                    "could not extract 'k', 'i', and 'j' keys "
+                    + "from {} data".format(self.output_type.lower())
+                )
+                raise KeyError(msg)
+        else:
+            try:
+                raslice = ra[["node"]]
+            except (KeyError, ValueError):
+                msg = "could not extract 'node' key from {} data".format(
+                    self.output_type.lower()
+                )
+                raise KeyError(msg)
+            if isinstance(dest_cells, (list, tuple)):
+                allint = all(isinstance(el, int) for el in dest_cells)
+                # convert to a list of tuples
+                if allint:
+                    t = []
+                    for el in dest_cells:
+                        t.append((el,))
+                        dest_cells = t
+
+        dest_cells = np.array(dest_cells, dtype=raslice.dtype)
+        inds = np.in1d(raslice, dest_cells)
+        epdest = ra[inds].copy().view(np.recarray)
+
+        if to_recarray:
+            # use particle ids to get the rest of the paths
+            inds = np.in1d(ra["particleid"], epdest.particleid)
+            series = ra[inds].copy()
+            series.sort(order=["particleid", "time"])
+            series = series.view(np.recarray)
+        else:
+
+            # get list of unique particleids in selection
+            partids = np.unique(epdest["particleid"])
+
+            # build list of unique particleids in selection
+            series = [self.get_data(partid) for partid in partids]
+
+        return series
+
+    def write_shapefile(
+        self,
+        data=None,
+        one_per_particle=True,
+        direction="ending",
+        shpname="endpoints.shp",
+        mg=None,
+        epsg=None,
+        sr=None,
+        **kwargs
+    ):
+        """
+        Write pathlines or timeseries to a shapefile
+
+        data : np.recarray
+            Record array of same form as that returned by
+            get_alldata(). (if none, get_alldata() is exported).
+        one_per_particle : boolean (default True)
+            True writes a single LineString with a single set of attribute
+            data for each particle. False writes a record/geometry for each
+            pathline segment (each row in the PathLine file). This option can
+            be used to visualize attribute information (time, model layer,
+            etc.) across a pathline in a GIS.
+        direction : str
+            String defining if starting or ending particle locations should be
+            included in shapefile attribute information. Only used if
+            one_per_particle=False. (default is 'ending')
+        shpname : str
+            File path for shapefile
+        mg : flopy.discretization.grid instance
+            Used to scale and rotate Global x,y,z values.
+        epsg : int
+            EPSG code for writing projection (.prj) file. If this is not
+            supplied, the proj4 string or epgs code associated with mg will be
+            used.
+        kwargs : keyword arguments to flopy.export.shapefile_utils.recarray2shp
+
+        """
+        from ..utils.reference import SpatialReference
+        from ..utils import geometry
+        from ..discretization import StructuredGrid
+        from ..utils.geometry import LineString
+        from ..export.shapefile_utils import recarray2shp
+
+        series = data
+        if series is None:
+            series = self._data.view(np.recarray)
+        else:
+            # convert pathline list to a single recarray
+            if isinstance(series, list):
+                s = series[0]
+                print(s.dtype)
+                for n in range(1, len(series)):
+                    s = stack_arrays((s, series[n]))
+                series = s.view(np.recarray)
+
+        seires = series.copy()
+        series.sort(order=["particleid", "time"])
+
+        if isinstance(mg, SpatialReference) or isinstance(
+            sr, SpatialReference
+        ):
+            warnings.warn(
+                "Deprecation warning: SpatialReference is deprecated."
+                "Use the Grid class instead.",
+                DeprecationWarning,
+            )
+            if isinstance(mg, SpatialReference):
+                sr = mg
+            mg = StructuredGrid(sr.delc, sr.delr)
+            mg.set_coord_info(
+                xoff=sr.xll,
+                yoff=sr.yll,
+                angrot=sr.rotation,
+                epsg=sr.epsg,
+                proj4=sr.proj4_str,
+            )
+
+        if epsg is None:
+            epsg = mg.epsg
+
+        particles = np.unique(series.particleid)
+        geoms = []
+
+        # create dtype with select attributes in pth
+        names = series.dtype.names
+        dtype = []
+        atts = ["particleid", "particlegroup", "time", "k", "i", "j", "node"]
+        for att in atts:
+            if att in names:
+                t = np.int32
+                if att == "time":
+                    t = np.float32
+                dtype.append((att, t))
+        dtype = np.dtype(dtype)
+
+        # reset names to the selected names in the created dtype
+        names = dtype.names
+
+        # 1 geometry for each path
+        if one_per_particle:
+
+            loc_inds = 0
+            if direction == "ending":
+                loc_inds = -1
+
+            sdata = []
+            for pid in particles:
+                ra = series[series.particleid == pid]
+
+                x, y = geometry.transform(
+                    ra.x, ra.y, mg.xoffset, mg.yoffset, mg.angrot_radians
+                )
+                z = ra.z
+                geoms.append(LineString(list(zip(x, y, z))))
+
+                t = [pid]
+                if "particlegroup" in names:
+                    t.append(ra.particlegroup[0])
+                t.append(ra.time.max())
+                if "node" in names:
+                    t.append(ra.node[loc_inds])
+                else:
+                    if "k" in names:
+                        t.append(ra.k[loc_inds])
+                    if "i" in names:
+                        t.append(ra.i[loc_inds])
+                    if "j" in names:
+                        t.append(ra.j[loc_inds])
+                sdata.append(tuple(t))
+
+            sdata = np.array(sdata, dtype=dtype).view(np.recarray)
+
+        # geometry for each row in PathLine file
+        else:
+            dtype = series.dtype
+            sdata = []
+            for pid in particles:
+                ra = series[series.particleid == pid]
+                if isinstance(mg, StructuredGrid):
+                    x, y = geometry.transform(
+                        ra.x, ra.y, mg.xoffset, mg.yoffset, mg.angrot_radians
+                    )
+                else:
+                    x, y = mg.transform(ra.x, ra.y)
+                z = ra.z
+                geoms += [
+                    LineString(
+                        [(x[i - 1], y[i - 1], z[i - 1]), (x[i], y[i], z[i])]
+                    )
+                    for i in np.arange(1, (len(ra)))
+                ]
+                sdata += ra[1:].tolist()
+            sdata = np.array(sdata, dtype=dtype).view(np.recarray)
+
+        # convert back to one-based
+        for n in set(self.kijnames).intersection(set(sdata.dtype.names)):
+            sdata[n] += 1
+
+        # write the final recarray to a shapefile
+        recarray2shp(sdata, geoms, shpname=shpname, epsg=epsg, **kwargs)
+
+
+class PathlineFile(_ModpathSeries):
     """
     PathlineFile Class.
 
@@ -55,14 +471,8 @@ class PathlineFile:
         Class constructor.
 
         """
-        self.fname = filename
-        self.verbose = verbose
-
-        # build index
-        self._build_index()
 
-        # set output dtype
-        self.outdtype = self._get_outdtype()
+        super().__init__(filename, verbose=verbose, output_type="pathline")
 
         # set data dtype and read pathline data
         if self.version == 7:
@@ -84,42 +494,6 @@ class PathlineFile:
 
         # close the input file
         self.file.close()
-        return
-
-    def _build_index(self):
-        """
-        Set position of the start of the pathline data.
-        """
-        self.skiprows = 0
-        self.file = open(self.fname, "r")
-        while True:
-            line = self.file.readline()
-            if isinstance(line, bytes):
-                line = line.decode()
-            if self.skiprows < 1:
-                if "MODPATH_PATHLINE_FILE 6" in line.upper():
-                    self.version = 6
-                elif "MODPATH_PATHLINE_FILE         7" in line.upper():
-                    self.version = 7
-                elif "MODPATH 5.0" in line.upper():
-                    self.version = 5
-                elif "MODPATH Version 3.00" in line.upper():
-                    self.version = 3
-                else:
-                    self.version = None
-                if self.version is None:
-                    errmsg = "{} is not a valid pathline file".format(
-                        self.fname
-                    )
-                    raise Exception(errmsg)
-            self.skiprows += 1
-            if self.version == 6 or self.version == 7:
-                if "end header" in line.lower():
-                    break
-            elif self.version == 3 or self.version == 5:
-                break
-        self.file.seek(0)
-        return
 
     def _get_dtypes(self):
         """
@@ -159,28 +533,15 @@ class PathlineFile:
                     ("yloc", np.float32),
                     ("zloc", np.float32),
                     ("linesegmentindex", np.int32),
-                ]
-            )
-        elif self.version == 7:
-            msg = (
-                "_get_dtypes() should not be called for "
-                + "MODPATH 7 pathline files"
-            )
-            raise TypeError(msg)
-        return dtype
-
-    def _get_outdtype(self):
-        outdtype = np.dtype(
-            [
-                ("x", np.float32),
-                ("y", np.float32),
-                ("z", np.float32),
-                ("time", np.float32),
-                ("k", np.int32),
-                ("particleid", np.int32),
-            ]
-        )
-        return outdtype
+                ]
+            )
+        elif self.version == 7:
+            msg = (
+                "_get_dtypes() should not be called for "
+                + "MODPATH 7 pathline files"
+            )
+            raise TypeError(msg)
+        return dtype
 
     def _get_mp7data(self):
         dtyper = np.dtype(
@@ -278,7 +639,7 @@ class PathlineFile:
             Maximum pathline number.
 
         """
-        return self._data["particleid"].max()
+        return super().get_maxid()
 
     def get_maxtime(self):
         """
@@ -290,7 +651,7 @@ class PathlineFile:
             Maximum pathline time.
 
         """
-        return self._data["time"].max()
+        return super().get_maxtime()
 
     def get_data(self, partid=0, totim=None, ge=True):
         """
@@ -330,23 +691,7 @@ class PathlineFile:
         >>> p1 = pthobj.get_data(partid=1)
 
         """
-        # idx = self._data['particleid'] == partid
-        if totim is not None:
-            if ge:
-                idx = (self._data["time"] >= totim) & (
-                    self._data["particleid"] == partid
-                )
-            else:
-                idx = (self._data["time"] <= totim) & (
-                    self._data["particleid"] == partid
-                )
-        else:
-            idx = self._data["particleid"] == partid
-        self._ta = self._data[idx]
-        names = ["x", "y", "z", "time", "k", "particleid"]
-        return np.rec.fromarrays(
-            (self._ta[name] for name in names), dtype=self.outdtype
-        )
+        return super().get_data(partid=partid, totim=totim, ge=ge)
 
     def get_alldata(self, totim=None, ge=True):
         """
@@ -366,15 +711,8 @@ class PathlineFile:
         Returns
         ----------
         plist : a list of numpy record array
-            A list of numpy recarrays with the x, y, z, time, k, and particleid for
-            all pathlines.
-
-
-        See Also
-        --------
-
-        Notes
-        -----
+            A list of numpy recarrays with the x, y, z, time, k, and particleid
+            for all pathlines.
 
         Examples
         --------
@@ -384,13 +722,7 @@ class PathlineFile:
         >>> p = pthobj.get_alldata()
 
         """
-        # plist = []
-        # for partid in self.nid:
-        #     plist.append(self.get_data(partid=partid, totim=totim, ge=ge))
-        return [
-            self.get_data(partid=partid, totim=totim, ge=ge)
-            for partid in self.nid
-        ]
+        return super().get_alldata(totim=totim, ge=ge)
 
     def get_destination_pathline_data(self, dest_cells, to_recarray=False):
         """
@@ -422,62 +754,16 @@ class PathlineFile:
         ...                                       (1, 0, 0)])
 
         """
-
-        # create local copy of _data
-        ra = np.array(self._data)
-
-        # find the intersection of pathlines and dest_cells
-        # convert dest_cells to same dtype for comparison
-        if self.version < 7:
-            try:
-                raslice = ra[["k", "i", "j"]]
-            except:
-                msg = (
-                    "could not extract 'k', 'i', and 'j' keys "
-                    + "from pathline data"
-                )
-                raise KeyError(msg)
-        else:
-            try:
-                raslice = ra[["node"]]
-            except:
-                msg = "could not extract 'node' key from pathline data"
-                raise KeyError(msg)
-            if isinstance(dest_cells, (list, tuple)):
-                allint = all(isinstance(el, int) for el in dest_cells)
-                # convert to a list of tuples
-                if allint:
-                    t = []
-                    for el in dest_cells:
-                        t.append((el,))
-                        dest_cells = t
-
-        dest_cells = np.array(dest_cells, dtype=raslice.dtype)
-        inds = np.in1d(raslice, dest_cells)
-        epdest = ra[inds].copy().view(np.recarray)
-
-        if to_recarray:
-            # use particle ids to get the rest of the paths
-            inds = np.in1d(ra["particleid"], epdest.particleid)
-            pthldes = ra[inds].copy()
-            pthldes.sort(order=["particleid", "time"])
-            pthldes = pthldes.view(np.recarray)
-        else:
-
-            # get list of unique particleids in selection
-            partids = np.unique(epdest["particleid"])
-
-            # build list of unique particleids in selection
-            pthldes = [self.get_data(partid) for partid in partids]
-
-        return pthldes
+        return super().get_destination_data(
+            dest_cells=dest_cells, to_recarray=to_recarray
+        )
 
     def write_shapefile(
         self,
         pathline_data=None,
         one_per_particle=True,
         direction="ending",
-        shpname="endpoints.shp",
+        shpname="pathlines.shp",
         mg=None,
         epsg=None,
         sr=None,
@@ -488,7 +774,7 @@ class PathlineFile:
 
         pathline_data : np.recarray
             Record array of same form as that returned by
-            EndpointFile.get_alldata(). (if none, EndpointFile.get_alldata()
+            PathlineFile.get_alldata(). (if none, PathlineFile.get_alldata()
             is exported).
         one_per_particle : boolean (default True)
             True writes a single LineString with a single set of attribute
@@ -503,7 +789,7 @@ class PathlineFile:
         shpname : str
             File path for shapefile
         mg : flopy.discretization.grid instance
-            Used to scale and rotate Global x,y,z values in MODPATH Endpoint
+            Used to scale and rotate Global x,y,z values in MODPATH Pathline
             file.
         epsg : int
             EPSG code for writing projection (.prj) file. If this is not
@@ -512,131 +798,16 @@ class PathlineFile:
         kwargs : keyword arguments to flopy.export.shapefile_utils.recarray2shp
 
         """
-        from ..utils.reference import SpatialReference
-        from ..utils import geometry
-        from ..discretization import StructuredGrid
-        from ..utils.geometry import LineString
-        from ..export.shapefile_utils import recarray2shp
-
-        pth = pathline_data
-        if pth is None:
-            pth = self._data.view(np.recarray)
-        else:
-            # convert pathline list to a single recarray
-            if isinstance(pth, list):
-                s = pth[0]
-                print(s.dtype)
-                for n in range(1, len(pth)):
-                    s = stack_arrays((s, pth[n]))
-                pth = s.view(np.recarray)
-
-        pth = pth.copy()
-        pth.sort(order=["particleid", "time"])
-
-        if isinstance(mg, SpatialReference) or isinstance(
-            sr, SpatialReference
-        ):
-            warnings.warn(
-                "Deprecation warning: SpatialReference is deprecated."
-                "Use the Grid class instead.",
-                DeprecationWarning,
-            )
-            if isinstance(mg, SpatialReference):
-                sr = mg
-            mg = StructuredGrid(sr.delc, sr.delr)
-            mg.set_coord_info(
-                xoff=sr.xll,
-                yoff=sr.yll,
-                angrot=sr.rotation,
-                epsg=sr.epsg,
-                proj4=sr.proj4_str,
-            )
-
-        if epsg is None:
-            epsg = mg.epsg
-
-        particles = np.unique(pth.particleid)
-        geoms = []
-
-        # create dtype with select attributes in pth
-        names = pth.dtype.names
-        dtype = []
-        atts = ["particleid", "particlegroup", "time", "k", "i", "j", "node"]
-        for att in atts:
-            if att in names:
-                t = np.int32
-                if att == "time":
-                    t = np.float32
-                dtype.append((att, t))
-        dtype = np.dtype(dtype)
-
-        # reset names to the selected names in the created dtype
-        names = dtype.names
-
-        # 1 geometry for each path
-        if one_per_particle:
-
-            loc_inds = 0
-            if direction == "ending":
-                loc_inds = -1
-
-            pthdata = []
-            for pid in particles:
-                ra = pth[pth.particleid == pid]
-
-                x, y = geometry.transform(
-                    ra.x, ra.y, mg.xoffset, mg.yoffset, mg.angrot_radians
-                )
-                z = ra.z
-                geoms.append(LineString(list(zip(x, y, z))))
-
-                t = [pid]
-                if "particlegroup" in names:
-                    t.append(ra.particlegroup[0])
-                t.append(ra.time.max())
-                if "node" in names:
-                    t.append(ra.node[loc_inds])
-                else:
-                    if "k" in names:
-                        t.append(ra.k[loc_inds])
-                    if "i" in names:
-                        t.append(ra.i[loc_inds])
-                    if "j" in names:
-                        t.append(ra.j[loc_inds])
-                pthdata.append(tuple(t))
-
-            pthdata = np.array(pthdata, dtype=dtype).view(np.recarray)
-
-        # geometry for each row in PathLine file
-        else:
-            dtype = pth.dtype
-            # pthdata = np.empty((0, len(dtype)), dtype=dtype).view(np.recarray)
-            pthdata = []
-            for pid in particles:
-                ra = pth[pth.particleid == pid]
-                if isinstance(mg, StructuredGrid):
-                    x, y = geometry.transform(
-                        ra.x, ra.y, mg.xoffset, mg.yoffset, mg.angrot_radians
-                    )
-                else:
-                    x, y = mg.transform(ra.x, ra.y)
-                z = ra.z
-                geoms += [
-                    LineString(
-                        [(x[i - 1], y[i - 1], z[i - 1]), (x[i], y[i], z[i])]
-                    )
-                    for i in np.arange(1, (len(ra)))
-                ]
-                # pthdata = np.append(pthdata, ra[1:]).view(np.recarray)
-                pthdata += ra[1:].tolist()
-            pthdata = np.array(pthdata, dtype=dtype).view(np.recarray)
-
-        # convert back to one-based
-        for n in set(self.kijnames).intersection(set(pthdata.dtype.names)):
-            pthdata[n] += 1
-
-        # write the final recarray to a shapefile
-        recarray2shp(pthdata, geoms, shpname=shpname, epsg=epsg, **kwargs)
+        super().write_shapefile(
+            data=pathline_data,
+            one_per_particle=one_per_particle,
+            direction=direction,
+            shpname=shpname,
+            mg=mg,
+            epsg=epsg,
+            sr=sr,
+            **kwargs
+        )
 
 
 class EndpointFile:
@@ -1053,7 +1224,7 @@ class EndpointFile:
                 keys = ["k", "i", "j"]
             try:
                 raslice = ra_slice(ra, keys)
-            except:
+            except (KeyError, ValueError):
                 msg = (
                     "could not extract"
                     + "'"
@@ -1069,7 +1240,7 @@ class EndpointFile:
                 keys = ["node"]
             try:
                 raslice = ra_slice(ra, keys)
-            except:
+            except (KeyError, ValueError):
                 msg = (
                     "could not extract '{}' ".format(keys[0])
                     + "key from endpoint data"
@@ -1183,7 +1354,7 @@ class EndpointFile:
         recarray2shp(epd, geoms, shpname=shpname, epsg=epsg, **kwargs)
 
 
-class TimeseriesFile:
+class TimeseriesFile(_ModpathSeries):
     """
     TimeseriesFile Class.
 
@@ -1220,14 +1391,7 @@ class TimeseriesFile:
         Class constructor.
 
         """
-        self.fname = filename
-        self.verbose = verbose
-
-        # build index
-        self._build_index()
-
-        # set output dtype
-        self.outdtype = self._get_outdtype()
+        super().__init__(filename, verbose=verbose, output_type="timeseries")
 
         # set dtype
         self.dtype = self._get_dtypes()
@@ -1392,7 +1556,7 @@ class TimeseriesFile:
             Maximum pathline number.
 
         """
-        return self._data["particleid"].max()
+        return super().get_maxid()
 
     def get_maxtime(self):
         """
@@ -1404,7 +1568,7 @@ class TimeseriesFile:
             Maximum pathline time.
 
         """
-        return self._data["time"].max()
+        return super().get_maxtime()
 
     def get_data(self, partid=0, totim=None, ge=True):
         """
@@ -1445,22 +1609,7 @@ class TimeseriesFile:
         >>> ts1 = tsobj.get_data(partid=1)
 
         """
-        if totim is not None:
-            if ge:
-                idx = (self._data["time"] >= totim) & (
-                    self._data["particleid"] == partid
-                )
-            else:
-                idx = (self._data["time"] <= totim) & (
-                    self._data["particleid"] == partid
-                )
-        else:
-            idx = self._data["particleid"] == partid
-        self._ta = self._data[idx]
-        names = ["x", "y", "z", "time", "k", "particleid"]
-        return np.rec.fromarrays(
-            (self._ta[name] for name in names), dtype=self.outdtype
-        )
+        return super().get_data(partid=partid, totim=totim, ge=ge)
 
     def get_alldata(self, totim=None, ge=True):
         """
@@ -1484,13 +1633,6 @@ class TimeseriesFile:
             A list of numpy recarrays with the x, y, z, time, k, and
             particleid for all timeseries.
 
-
-        See Also
-        --------
-
-        Notes
-        -----
-
         Examples
         --------
 
@@ -1499,10 +1641,7 @@ class TimeseriesFile:
         >>> ts = tsobj.get_alldata()
 
         """
-        return [
-            self.get_data(partid=partid, totim=totim, ge=ge)
-            for partid in self.nid
-        ]
+        return super().get_alldata(totim=totim, ge=ge)
 
     def get_destination_timeseries_data(self, dest_cells):
         """
@@ -1528,42 +1667,55 @@ class TimeseriesFile:
         ...                                           (1, 0, 0)])
 
         """
+        return super().get_destination_data(dest_cells=dest_cells)
 
-        # create local copy of _data
-        ra = np.array(self._data)
-
-        # find the intersection of timeseries and dest_cells
-        # convert dest_cells to same dtype for comparison
-        if self.version < 7:
-            try:
-                raslice = ra[["k", "i", "j"]]
-            except:
-                msg = (
-                    "could not extract 'k', 'i', and 'j' keys "
-                    + "from timeseries data"
-                )
-                raise KeyError(msg)
-        else:
-            try:
-                raslice = ra[["node"]]
-            except:
-                msg = "could not extract 'node' key from timeseries data"
-                raise KeyError(msg)
-            if isinstance(dest_cells, (list, tuple)):
-                allint = all(isinstance(el, int) for el in dest_cells)
-                # convert to a list of tuples
-                if allint:
-                    t = []
-                    for el in dest_cells:
-                        t.append((el,))
-                        dest_cells = t
+    def write_shapefile(
+        self,
+        timeseries_data=None,
+        one_per_particle=True,
+        direction="ending",
+        shpname="pathlines.shp",
+        mg=None,
+        epsg=None,
+        sr=None,
+        **kwargs
+    ):
+        """
+        Write pathlines to a shapefile
 
-        dest_cells = np.array(dest_cells, dtype=raslice.dtype)
-        inds = np.in1d(raslice, dest_cells)
-        epdest = ra[inds].copy().view(np.recarray)
+        timeseries_data : np.recarray
+            Record array of same form as that returned by
+            Timeseries.get_alldata(). (if none, Timeseries.get_alldata()
+            is exported).
+        one_per_particle : boolean (default True)
+            True writes a single LineString with a single set of attribute
+            data for each particle. False writes a record/geometry for each
+            pathline segment (each row in the Timeseries file). This option can
+            be used to visualize attribute information (time, model layer,
+            etc.) across a pathline in a GIS.
+        direction : str
+            String defining if starting or ending particle locations should be
+            included in shapefile attribute information. Only used if
+            one_per_particle=False. (default is 'ending')
+        shpname : str
+            File path for shapefile
+        mg : flopy.discretization.grid instance
+            Used to scale and rotate Global x,y,z values in MODPATH Timeseries
+            file.
+        epsg : int
+            EPSG code for writing projection (.prj) file. If this is not
+            supplied, the proj4 string or epgs code associated with mg will be
+            used.
+        kwargs : keyword arguments to flopy.export.shapefile_utils.recarray2shp
 
-        # use particle ids to get the rest of the timeseries
-        inds = np.in1d(ra["particleid"], epdest.particleid)
-        tsdes = ra[inds].copy()
-        tsdes.sort(order=["particleid", "time"])
-        return tsdes.view(np.recarray)
+        """
+        super().write_shapefile(
+            data=timeseries_data,
+            one_per_particle=one_per_particle,
+            direction=direction,
+            shpname=shpname,
+            mg=mg,
+            epsg=epsg,
+            sr=sr,
+            **kwargs
+        )
diff --git a/flopy/utils/postprocessing.py b/flopy/utils/postprocessing.py
index ebc90504..91e553e4 100644
--- a/flopy/utils/postprocessing.py
+++ b/flopy/utils/postprocessing.py
@@ -1,4 +1,5 @@
 import numpy as np
+import warnings
 
 
 def get_transmissivities(
@@ -188,6 +189,11 @@ def get_saturated_thickness(heads, m, nodata, per_idx=None):
     sat_thickness : 3 or 4-D np.ndarray
         Array of saturated thickness
     """
+    warnings.warn(
+        "postprocessing.get_saturated_thickness will be deprecated and "
+        "removed in version 3.3.5.  Use grid.saturated_thick(heads).",
+        PendingDeprecationWarning,
+    )
 
     if not isinstance(nodata, list):
         nodata = [nodata]
@@ -199,7 +205,7 @@ def get_saturated_thickness(heads, m, nodata, per_idx=None):
     botm = m.dis.botm.array
     top.shape = (1,) + botm.shape[1:]
     top = np.concatenate((top, botm[0:-1]), axis=0)
-    thickness = m.dis.thickness.array
+    thickness = m.modelgrid.thick
     nper, nlay, nrow, ncol = heads.shape
     if per_idx is None:
         per_idx = list(range(nper))
@@ -220,7 +226,8 @@ def get_saturated_thickness(heads, m, nodata, per_idx=None):
     sat_thickness = []
     for per in per_idx:
         hds = heads[per]
-        unconf_thickness = np.where((hds - botm) > top, top, hds - botm)
+        hds = np.where(hds < botm, botm, hds)  # for NWT when hds < botm
+        unconf_thickness = np.where(hds > top, top - botm, hds - botm)
         perthickness = np.where(is_conf, thickness, unconf_thickness)
         sat_thickness.append(perthickness)
     sat_thickness = np.squeeze(sat_thickness)
@@ -701,10 +708,10 @@ def get_specific_discharge(
     if classical_budget:
         # get saturated thickness (head - bottom elev for unconfined layer)
         if head is None:
-            sat_thk = model.dis.thickness.array
+            sat_thk = modelgrid.thick
         else:
-            sat_thk = get_saturated_thickness(
-                head, model, [model.hdry, model.hnoflo]
+            sat_thk = modelgrid.saturated_thick(
+                head, mask=[model.hdry, model.hnoflo]
             )
             sat_thk.shape = model.modelgrid.shape
 


Test patch:
diff --git a/autotest/t042_test.py b/autotest/t042_test.py
index 6efa1ea4..b41992bb 100644
--- a/autotest/t042_test.py
+++ b/autotest/t042_test.py
@@ -116,10 +116,10 @@ def test_get_sat_thickness_gradients():
     dz = np.array([np.nan, -0.9])
     assert np.nansum(np.abs(dh / dz - grad[:, 1, 0])) < 1e-6
 
-    sat_thick = get_saturated_thickness(hds, m, nodata)
+    sat_thick = m.modelgrid.saturated_thick(hds, mask=nodata)
     assert (
-        np.abs(np.sum(sat_thick[:, 1, 1] - np.array([0.2, 1.0, 1.6]))) < 1e-6
-    )
+        np.abs(np.sum(sat_thick[:, 1, 1] - np.array([0.2, 1.0, 1.0]))) < 1e-6
+    ), "failed saturated thickness comparison (grid.thick())"
 
 
 if __name__ == "__main__":
diff --git a/autotest/t050_test.py b/autotest/t050_test.py
index 8e8bfca4..9516b873 100644
--- a/autotest/t050_test.py
+++ b/autotest/t050_test.py
@@ -468,14 +468,18 @@ def test_vtk_vector():
     # assert(totalbytes1==942413)
     # nlines1 = count_lines_in_file(filetocheck, binary=True)
     # assert(nlines1==3824)
-    assert os.path.exists(filetocheck)
+    assert os.path.exists(filetocheck), "file (0) does not exist: {}".format(
+        filetocheck
+    )
 
     # with values directly given at vertices
     q = pp.get_specific_discharge(vectors, m, head, position="vertices")
     nancount = np.count_nonzero(np.isnan(q[0]))
-    assert nancount == 472
+    assert nancount == 472, "nancount != 472 ({})".format(nancount)
     overall = np.nansum(q[0]) + np.nansum(q[1]) + np.nansum(q[2])
-    assert np.allclose(overall, -45.38671967357735)
+    assert np.allclose(
+        overall, -15.849639024891047
+    ), "vertices overall = {}".format(overall)
     output_dir = os.path.join(cpth, "freyberg_vector")
     filenametocheck = "discharge_verts.vtu"
     vtk.export_vector(m, q, output_dir, "discharge_verts")
@@ -483,7 +487,7 @@ def test_vtk_vector():
     # totalbytes2 = os.path.getsize(filetocheck)
     # assert(totalbytes2==1990047)
     nlines2 = count_lines_in_file(filetocheck)
-    assert nlines2 == 10598
+    assert nlines2 == 10598, "nlines != 10598 ({})".format(nlines2)
 
     # with values directly given at vertices and binary
     vtk.export_vector(
@@ -494,7 +498,9 @@ def test_vtk_vector():
     # assert(totalbytes3==891486)
     # nlines3 = count_lines_in_file(filetocheck, binary=True)
     # assert(nlines3==3012)
-    assert os.path.exists(filetocheck)
+    assert os.path.exists(filetocheck), "file (1) does not exist: {}".format(
+        filetocheck
+    )
 
     return
 
diff --git a/autotest/t072_test_spedis.py b/autotest/t072_test_spedis.py
index 8e4d7cab..92d63640 100644
--- a/autotest/t072_test_spedis.py
+++ b/autotest/t072_test_spedis.py
@@ -450,11 +450,11 @@ def test_specific_discharge_comprehensive():
     for col in ax.collections:
         if not isinstance(col, Quiver):
             raise AssertionError("Unexpected collection type")
-    assert np.sum(quiver.Umask) == 2
+    assert np.sum(quiver.Umask) == 4
     pos = np.sum(quiver.X) + np.sum(quiver.Y)
     assert np.allclose(pos, 1600.0)
     val = np.sum(quiver.U) + np.sum(quiver.V)
-    assert np.allclose(val, 10.11359908150753)
+    assert np.allclose(val, 12.0225525)
 
     # close figure
     plt.close()
@@ -481,15 +481,15 @@ def test_specific_discharge_comprehensive():
     for col in ax.collections:
         if not isinstance(col, Quiver):
             raise AssertionError("Unexpected collection type")
-    assert np.sum(quiver.Umask) == 5
+    assert np.sum(quiver.Umask) == 7
     X = np.ma.masked_where(quiver.Umask, quiver.X)
     Y = np.ma.masked_where(quiver.Umask, quiver.Y)
     pos = X.sum() + Y.sum()
-    assert np.allclose(pos, -153.8341064453125)
+    assert np.allclose(pos, -152.0747652053833)
     U = np.ma.masked_where(quiver.Umask, quiver.U)
     V = np.ma.masked_where(quiver.Umask, quiver.V)
     val = U.sum() + V.sum()
-    assert np.allclose(val, -5.2501876516091235)
+    assert np.allclose(val, -3.3428158026088326)
 
     # close figure
     plt.close()
diff --git a/autotest/t076_modelgrid_thick.py b/autotest/t076_modelgrid_thick.py
new file mode 100644
index 00000000..44fd300c
--- /dev/null
+++ b/autotest/t076_modelgrid_thick.py
@@ -0,0 +1,205 @@
+"""
+Model grid thick method tests
+
+"""
+
+import numpy as np
+from flopy.discretization import StructuredGrid, VertexGrid, UnstructuredGrid
+
+
+def test_structured_thick():
+    nlay, nrow, ncol = 3, 2, 3
+    delc = 1.0 * np.ones(nrow, dtype=float)
+    delr = 1.0 * np.ones(ncol, dtype=float)
+    top = 10.0 * np.ones((nrow, ncol), dtype=float)
+    botm = np.zeros((nlay, nrow, ncol), dtype=float)
+    botm[0, :, :] = 5.0
+    botm[1, :, :] = 0.0
+    botm[2, :, :] = -5.0
+    grid = StructuredGrid(
+        nlay=nlay,
+        nrow=nrow,
+        ncol=ncol,
+        delc=delc,
+        delr=delr,
+        top=top,
+        botm=botm,
+    )
+    thick = grid.thick
+    assert np.allclose(thick, 5.0), "thicknesses != 5."
+
+    sat_thick = grid.saturated_thick(grid.botm + 10.0)
+    assert np.allclose(sat_thick, thick), "saturated thicknesses != 5."
+
+    sat_thick = grid.saturated_thick(grid.botm + 5.0)
+    assert np.allclose(sat_thick, thick), "saturated thicknesses != 5."
+
+    sat_thick = grid.saturated_thick(grid.botm + 2.5)
+    assert np.allclose(sat_thick, 2.5), "saturated thicknesses != 2.5"
+
+    sat_thick = grid.saturated_thick(grid.botm)
+    assert np.allclose(sat_thick, 0.0), "saturated thicknesses != 0."
+
+    sat_thick = grid.saturated_thick(grid.botm - 100.0)
+    assert np.allclose(sat_thick, 0.0), "saturated thicknesses != 0."
+
+    return
+
+
+def test_vertices_thick():
+    nlay, ncpl = 3, 5
+    vertices = [
+        [0, 0.0, 3.0],
+        [1, 1.0, 3.0],
+        [2, 2.0, 3.0],
+        [3, 0.0, 2.0],
+        [4, 1.0, 2.0],
+        [5, 2.0, 2.0],
+        [6, 0.0, 1.0],
+        [7, 1.0, 1.0],
+        [8, 2.0, 1.0],
+        [9, 0.0, 0.0],
+        [10, 1.0, 0.0],
+    ]
+    iverts = [
+        [0, 0, 1, 4, 3],
+        [1, 1, 2, 5, 4],
+        [2, 3, 4, 7, 6],
+        [3, 4, 5, 8, 7],
+        [4, 6, 7, 10, 9],
+        [5, 0, 1, 4, 3],
+        [6, 1, 2, 5, 4],
+        [7, 3, 4, 7, 6],
+        [8, 4, 5, 8, 7],
+        [9, 6, 7, 10, 9],
+        [10, 0, 1, 4, 3],
+        [11, 1, 2, 5, 4],
+        [12, 3, 4, 7, 6],
+        [13, 4, 5, 8, 7],
+        [14, 6, 7, 10, 9],
+    ]
+    top = np.ones(ncpl, dtype=float) * 10.0
+    botm = np.zeros((nlay, ncpl), dtype=float)
+    botm[0, :] = 5.0
+    botm[1, :] = 0.0
+    botm[2, :] = -5.0
+    grid = VertexGrid(
+        nlay=nlay,
+        ncpl=ncpl,
+        vertices=vertices,
+        cell2d=iverts,
+        top=top,
+        botm=botm,
+    )
+    thick = grid.thick
+    assert np.allclose(thick, 5.0), "thicknesses != 5."
+
+    sat_thick = grid.saturated_thick(grid.botm + 10.0)
+    assert np.allclose(sat_thick, thick), "saturated thicknesses != 5."
+
+    sat_thick = grid.saturated_thick(grid.botm + 5.0)
+    assert np.allclose(sat_thick, thick), "saturated thicknesses != 5."
+
+    sat_thick = grid.saturated_thick(grid.botm + 2.5)
+    assert np.allclose(sat_thick, 2.5), "saturated thicknesses != 2.5"
+
+    sat_thick = grid.saturated_thick(grid.botm)
+    assert np.allclose(sat_thick, 0.0), "saturated thicknesses != 0."
+
+    sat_thick = grid.saturated_thick(grid.botm - 100.0)
+    assert np.allclose(sat_thick, 0.0), "saturated thicknesses != 0."
+
+    return
+
+
+def test_unstructured_thick():
+    nlay = 3
+    ncpl = [5, 5, 5]
+    vertices = [
+        [0, 0.0, 3.0],
+        [1, 1.0, 3.0],
+        [2, 2.0, 3.0],
+        [3, 0.0, 2.0],
+        [4, 1.0, 2.0],
+        [5, 2.0, 2.0],
+        [6, 0.0, 1.0],
+        [7, 1.0, 1.0],
+        [8, 2.0, 1.0],
+        [9, 0.0, 0.0],
+        [10, 1.0, 0.0],
+    ]
+    iverts = [
+        [0, 0, 1, 4, 3],
+        [1, 1, 2, 5, 4],
+        [2, 3, 4, 7, 6],
+        [3, 4, 5, 8, 7],
+        [4, 6, 7, 10, 9],
+        [5, 0, 1, 4, 3],
+        [6, 1, 2, 5, 4],
+        [7, 3, 4, 7, 6],
+        [8, 4, 5, 8, 7],
+        [9, 6, 7, 10, 9],
+        [10, 0, 1, 4, 3],
+        [11, 1, 2, 5, 4],
+        [12, 3, 4, 7, 6],
+        [13, 4, 5, 8, 7],
+        [14, 6, 7, 10, 9],
+    ]
+    xcenters = [
+        0.5,
+        1.5,
+        0.5,
+        1.5,
+        0.5,
+    ]
+    ycenters = [
+        2.5,
+        2.5,
+        1.5,
+        1.5,
+        0.5,
+    ]
+    top = np.ones((nlay, 5), dtype=float)
+    top[0, :] = 10.0
+    top[1, :] = 5.0
+    top[2, :] = 0.0
+    botm = np.zeros((nlay, 5), dtype=float)
+    botm[0, :] = 5.0
+    botm[1, :] = 0.0
+    botm[2, :] = -5.0
+
+    grid = UnstructuredGrid(
+        vertices=vertices,
+        iverts=iverts,
+        xcenters=xcenters,
+        ycenters=ycenters,
+        ncpl=ncpl,
+        top=top.flatten(),
+        botm=botm.flatten(),
+    )
+
+    thick = grid.thick
+    assert np.allclose(thick, 5.0), "thicknesses != 5."
+
+    sat_thick = grid.saturated_thick(grid.botm + 10.0)
+    assert np.allclose(sat_thick, thick), "saturated thicknesses != 5."
+
+    sat_thick = grid.saturated_thick(grid.botm + 5.0)
+    assert np.allclose(sat_thick, thick), "saturated thicknesses != 5."
+
+    sat_thick = grid.saturated_thick(grid.botm + 2.5)
+    assert np.allclose(sat_thick, 2.5), "saturated thicknesses != 2.5"
+
+    sat_thick = grid.saturated_thick(grid.botm)
+    assert np.allclose(sat_thick, 0.0), "saturated thicknesses != 0."
+
+    sat_thick = grid.saturated_thick(grid.botm - 100.0)
+    assert np.allclose(sat_thick, 0.0), "saturated thicknesses != 0."
+
+    return
+
+
+if __name__ == "__main__":
+    test_unstructured_thick()
+    test_vertices_thick()
+    test_structured_thick()
diff --git a/autotest/t504_test.py b/autotest/t504_test.py
index bb1eea8e..37f28d85 100644
--- a/autotest/t504_test.py
+++ b/autotest/t504_test.py
@@ -925,8 +925,11 @@ def test045_lake2tr():
         head_file = os.path.join(os.getcwd(), expected_head_file_a)
         head_new = os.path.join(run_folder, "lakeex2a.hds")
         assert pymake.compare_heads(
-            None, None, files1=head_file, files2=head_new,
-            htol=10.,
+            None,
+            None,
+            files1=head_file,
+            files2=head_new,
+            htol=10.0,
         )
 
     # change some settings
@@ -952,8 +955,11 @@ def test045_lake2tr():
         head_file = os.path.join(os.getcwd(), expected_head_file_b)
         head_new = os.path.join(save_folder, "lakeex2a.hds")
         assert pymake.compare_heads(
-            None, None, files1=head_file, files2=head_new,
-            htol=10.,
+            None,
+            None,
+            files1=head_file,
+            files2=head_new,
+            htol=10.0,
         )
 
 
@@ -1084,8 +1090,12 @@ def test027_timeseriestest():
         head_new = os.path.join(run_folder, "timeseriestest.hds")
         outfile = os.path.join(run_folder, "head_compare.dat")
         assert pymake.compare_heads(
-            None, None, files1=head_file, files2=head_new, outfile=outfile,
-            htol=10.,
+            None,
+            None,
+            files1=head_file,
+            files2=head_new,
+            outfile=outfile,
+            htol=10.0,
         )
 
     model = sim.get_model(model_name)
@@ -1108,8 +1118,11 @@ def test027_timeseriestest():
         head_file = os.path.join(os.getcwd(), expected_head_file_b)
         head_new = os.path.join(save_folder, "timeseriestest.hds")
         assert pymake.compare_heads(
-            None, None, files1=head_file, files2=head_new,
-            htol=10.,
+            None,
+            None,
+            files1=head_file,
+            files2=head_new,
+            htol=10.0,
         )
 
 
diff --git a/autotest/t505_test.py b/autotest/t505_test.py
index bbab804f..dbadb76f 100644
--- a/autotest/t505_test.py
+++ b/autotest/t505_test.py
@@ -2916,8 +2916,12 @@ def test028_sfr():
         head_new = os.path.join(run_folder, "test1tr.hds")
         outfile = os.path.join(run_folder, "head_compare.dat")
         assert pymake.compare_heads(
-            None, None, files1=head_file, files2=head_new, outfile=outfile,
-            htol=10.,
+            None,
+            None,
+            files1=head_file,
+            files2=head_new,
+            outfile=outfile,
+            htol=10.0,
         )
 
         # clean up