diff --git a/autotest/t063_test_lgrutil.py b/autotest/t063_test_lgrutil.py index 3ac93d6ef..aa9e3f33b 100644 --- a/autotest/t063_test_lgrutil.py +++ b/autotest/t063_test_lgrutil.py @@ -104,5 +104,61 @@ def test_lgrutil(): return +def test_lgrutil2(): + # Define parent grid information + xoffp = 0.0 + yoffp = 0.0 + nlayp = 1 + nrowp = 5 + ncolp = 5 + dx = 100.0 + dy = 100.0 + dz = 100.0 + delrp = dx * np.array([1.0, 0.75, 0.5, 0.75, 1.0], dtype=float) + delcp = dy * np.array([1.0, 0.75, 0.5, 0.75, 1.0], dtype=float) + topp = dz * np.ones((nrowp, ncolp), dtype=float) + botmp = np.empty((nlayp, nrowp, ncolp), dtype=float) + for k in range(nlayp): + botmp[k] = -(k + 1) * dz + + # Define relation of child to parent + idomainp = np.ones((nlayp, nrowp, ncolp), dtype=int) + idomainp[:, 1:4, 1:4] = 0 + ncpp = 3 + ncppl = nlayp * [1] + + lgr = Lgr( + nlayp, + nrowp, + ncolp, + delrp, + delcp, + topp, + botmp, + idomainp, + ncpp=ncpp, + ncppl=ncppl, + xllp=xoffp, + yllp=yoffp, + ) + + # check to make sure child delr and delc are calculated correctly for + # the case where the parent grid has variable row and column spacings + answer = [ + 25.0, + 25.0, + 25.0, + 50.0 / 3.0, + 50.0 / 3.0, + 50.0 / 3.0, + 25.0, + 25.0, + 25.0, + ] + assert np.allclose(lgr.delr, answer), f"{lgr.delr} /= {answer}" + assert np.allclose(lgr.delc, answer), f"{lgr.delc} /= {answer}" + + if __name__ == "__main__": test_lgrutil() + test_lgrutil2() diff --git a/examples/Notebooks/flopy3_mf6_lgr.ipynb b/examples/Notebooks/flopy3_mf6_lgr.ipynb new file mode 100644 index 000000000..0e6a83b6e --- /dev/null +++ b/examples/Notebooks/flopy3_mf6_lgr.ipynb @@ -0,0 +1,405 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# FloPy\n", + "\n", + "## Local grid refinement (LGR) example\n", + "\n", + "First set the path and import the required packages. The flopy path doesn't have to be set if you install flopy from a binary installer. If you want to run this notebook, you have to set the path to your own flopy path." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2022-03-07T20:22:34.412069Z", + "iopub.status.busy": "2022-03-07T20:22:34.411420Z", + "iopub.status.idle": "2022-03-07T20:22:35.466833Z", + "shell.execute_reply": "2022-03-07T20:22:35.467291Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.9.7 (default, Sep 16 2021, 08:50:36) \n", + "[Clang 10.0.0 ]\n", + "numpy version: 1.22.3\n", + "matplotlib version: 3.5.1\n", + "flopy version: 3.3.6\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import numpy as np\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# run installed version of flopy or add local path\n", + "try:\n", + " import flopy\n", + "except:\n", + " fpth = os.path.abspath(os.path.join(\"..\", \"..\"))\n", + " sys.path.append(fpth)\n", + " import flopy\n", + "from flopy.utils.lgrutil import Lgr\n", + "\n", + "workspace = os.path.join(\"data\", \"mf6lgr\")\n", + "# make sure workspace directory exists\n", + "if not os.path.isdir(workspace):\n", + " os.makedirs(workspace, exist_ok=True)\n", + "\n", + "print(sys.version)\n", + "print(\"numpy version: {}\".format(np.__version__))\n", + "print(\"matplotlib version: {}\".format(mpl.__version__))\n", + "print(\"flopy version: {}\".format(flopy.__version__))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set up the LGR Configuration\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "execution": { + "iopub.execute_input": "2022-03-07T20:22:35.479200Z", + "iopub.status.busy": "2022-03-07T20:22:35.478511Z", + "iopub.status.idle": "2022-03-07T20:22:35.614251Z", + "shell.execute_reply": "2022-03-07T20:22:35.614701Z" + } + }, + "outputs": [], + "source": [ + "# set up the parent grid information\n", + "xoffp = 0.\n", + "yoffp = 0.\n", + "angrotp = 0.\n", + "nlayp = 5\n", + "nrowp = 5\n", + "ncolp = 5\n", + "dx = 100.\n", + "dy = 100.\n", + "dz = 100.\n", + "delrp = dx * np.ones(ncolp, dtype=float)\n", + "delcp = dy * np.ones(nrowp, dtype=float)\n", + "topp = dz * np.ones((nrowp, ncolp), dtype=float)\n", + "botmp = np.empty((nlayp, nrowp, ncolp), dtype=float)\n", + "for k in range(nlayp):\n", + " botmp[k] = - (k + 1) * dz\n", + " \n", + "# Define relation of child to parent\n", + "# idomainp has a 1 where parent is active and 0 where child is active\n", + "idomainp = np.ones((nlayp, nrowp, ncolp), dtype=int)\n", + "idomainp[:, 1:4, 1:4] = 0\n", + "\n", + "# Set the number of child cells per parent cell\n", + "ncpp = 5\n", + "\n", + "# Set the number of child layers per parent layer (list of cell parent nlay)\n", + "ncppl = [1, 1, 1, 1, 1]\n", + "\n", + "# Create the Lgr utility object, which contains methods for connecting a\n", + "# parent and child model in a MODFLOW 6 simulation\n", + "lgr = Lgr(nlayp, nrowp, ncolp, delrp, delcp,\n", + " topp, botmp, idomainp, ncpp=ncpp, ncppl=ncppl,\n", + " xllp=xoffp, yllp=yoffp)\n", + "\n", + "# from the Lgr object, it is possible to ask for a flopy modelgrid object\n", + "# for the parent and child. These objects are created on the fly and\n", + "# can be used to plot the grids prior to creating the MODFLOW 6 simulation\n", + "mgp = lgr.parent.modelgrid\n", + "mgc = lgr.child.modelgrid" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot the child and parent grids, which can be\n", + "# done easily using the flopy modelgrid objects\n", + "fig = plt.figure(figsize=(6, 6))\n", + "ax = fig.add_subplot(1, 1, 1, aspect=\"equal\")\n", + "mgc.plot(ax=ax)\n", + "mgp.plot(ax=ax)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Building a Simple MODFLOW 6 Model\n", + "\n", + " For this example, we reproduce the simple model shown on the front page of the flopy GitHub repository. In this adaptation, we insert a finer, locally refined grid in the middle of the domain, but we tightly couple the parent and child models." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "execution": { + "iopub.execute_input": "2022-03-07T20:22:38.019418Z", + "iopub.status.busy": "2022-03-07T20:22:38.018491Z", + "iopub.status.idle": "2022-03-07T20:22:38.203739Z", + "shell.execute_reply": "2022-03-07T20:22:38.204280Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "writing simulation...\n", + " writing simulation name file...\n", + " writing simulation tdis package...\n", + " writing ims package ims_-1...\n", + " writing package lgr.gwfgwf...\n", + " writing model parent...\n", + " writing model name file...\n", + " writing package dis...\n", + " writing package ic...\n", + " writing package npf...\n", + " writing package chd_0...\n", + "INFORMATION: maxbound in ('gwf6', 'chd', 'dimensions') changed to 2 based on size of stress_period_data\n", + " writing package oc...\n", + " writing model child...\n", + " writing model name file...\n", + " writing package dis...\n", + " writing package ic...\n", + " writing package npf...\n", + " writing package oc...\n", + "FloPy is using the following executable to run the model: /Users/langevin/langevin/bin/mac/mf6\n", + " MODFLOW 6\n", + " U.S. GEOLOGICAL SURVEY MODULAR HYDROLOGIC MODEL\n", + " VERSION 6.3.0 03/04/2022\n", + "\n", + " MODFLOW 6 compiled Mar 07 2022 13:50:09 with Intel(R) Fortran Intel(R) 64\n", + " Compiler Classic for applications running on Intel(R) 64, Version 2021.5.0\n", + " Build 20211109_000000\n", + "\n", + "This software has been approved for release by the U.S. Geological \n", + "Survey (USGS). Although the software has been subjected to rigorous \n", + "review, the USGS reserves the right to update the software as needed \n", + "pursuant to further analysis and review. No warranty, expressed or \n", + "implied, is made by the USGS or the U.S. Government as to the \n", + "functionality of the software and related material nor shall the \n", + "fact of release constitute any such warranty. Furthermore, the \n", + "software is released on condition that neither the USGS nor the U.S. \n", + "Government shall be held liable for any damages resulting from its \n", + "authorized or unauthorized use. Also refer to the USGS Water \n", + "Resources Software User Rights Notice for complete use, copyright, \n", + "and distribution information.\n", + "\n", + " \n", + " Run start date and time (yyyy/mm/dd hh:mm:ss): 2022/05/02 16:19:46\n", + " \n", + " Writing simulation list file: mfsim.lst\n", + " Using Simulation name file: mfsim.nam\n", + " \n", + " Solving: Stress period: 1 Time step: 1\n", + " \n", + " Run end date and time (yyyy/mm/dd hh:mm:ss): 2022/05/02 16:19:46\n", + " Elapsed run time: 0.197 Seconds\n", + " \n", + " Normal termination of simulation.\n" + ] + } + ], + "source": [ + "# set up the MODFLOW 6 simulation\n", + "ws = workspace\n", + "simname = 'lgr'\n", + "pname = \"parent\"\n", + "cname = \"child\"\n", + "sim = flopy.mf6.MFSimulation(sim_name=simname, sim_ws=ws, exe_name='mf6')\n", + "tdis = flopy.mf6.ModflowTdis(sim)\n", + "\n", + "# Because we will use the xt3d option for coupling the models\n", + "# we need use to the asymmetric BICGSTAB linear solver\n", + "ims = flopy.mf6.ModflowIms(sim, linear_acceleration=\"BICGSTAB\")\n", + "\n", + "# retrieve the exchange data from the lgr object\n", + "exchangedata = lgr.get_exchange_data(angldegx=True, cdist=True)\n", + "nexg = len(exchangedata)\n", + "\n", + "# When creating the exchange, which couples the child and parent\n", + "# models, use the xt3d option, which is an alternative to the\n", + "# ghost-node correction. This xt3d option was added as a new\n", + "# capability in MODFLOW version 6.3.0.\n", + "exg = flopy.mf6.ModflowGwfgwf(sim, exgtype=\"GWF6-GWF6\", \n", + " xt3d=True,\n", + " auxiliary=[\"angldegx\", \"cdist\"],\n", + " exgmnamea=pname, exgmnameb=cname,\n", + " nexg=nexg, exchangedata=exchangedata)\n", + "\n", + "# Set up the parent model and use the lgr.parent object to\n", + "# help provide the necessary information.\n", + "lgrp = lgr.parent\n", + "gwfp = flopy.mf6.ModflowGwf(sim, modelname=pname, save_flows=True)\n", + "dis = flopy.mf6.ModflowGwfdis(gwfp, **lgrp.get_gridprops_dis6())\n", + "ic = flopy.mf6.ModflowGwfic(gwfp)\n", + "npf = flopy.mf6.ModflowGwfnpf(gwfp, save_specific_discharge=True)\n", + "chdspd = [\n", + " [(0, 0, 0), 1.],\n", + " [(0, lgrp.nrow - 1, lgrp.ncol - 1), 0.]\n", + "]\n", + "chd = flopy.mf6.ModflowGwfchd(gwfp, stress_period_data=chdspd)\n", + "oc = flopy.mf6.ModflowGwfoc(gwfp,\n", + " budget_filerecord=pname + '.bud',\n", + " head_filerecord=pname + '.hds',\n", + " saverecord=[('HEAD', 'ALL'), ('BUDGET', 'ALL')])\n", + "\n", + "# Set up the child model and use the lgr.child object to\n", + "# help provide the necessary information.\n", + "lgrc = lgr.child\n", + "gwfc = flopy.mf6.ModflowGwf(sim, modelname=cname, save_flows=True)\n", + "dis = flopy.mf6.ModflowGwfdis(gwfc, **lgrc.get_gridprops_dis6())\n", + "ic = flopy.mf6.ModflowGwfic(gwfc)\n", + "npf = flopy.mf6.ModflowGwfnpf(gwfc, save_specific_discharge=True)\n", + "oc = flopy.mf6.ModflowGwfoc(gwfc,\n", + " budget_filerecord=cname + '.bud',\n", + " head_filerecord=cname + '.hds',\n", + " saverecord=[('HEAD', 'ALL'), ('BUDGET', 'ALL')])\n", + "\n", + "sim.write_simulation()\n", + "success, buff = sim.run_simulation()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "execution": { + "iopub.execute_input": "2022-03-07T20:22:38.348884Z", + "iopub.status.busy": "2022-03-07T20:22:38.277318Z", + "iopub.status.idle": "2022-03-07T20:22:38.891986Z", + "shell.execute_reply": "2022-03-07T20:22:38.892466Z" + } + }, + "outputs": [], + "source": [ + "# load and store the head arrays from the parent and child models\n", + "head = [gwfp.output.head().get_data(), gwfc.output.head().get_data()]\n", + "\n", + "# load and store the specific discharge results for the parent and child models\n", + "bud = gwfp.output.budget()\n", + "spdis = bud.get_data(text='DATA-SPDIS')[0]\n", + "spdisp = flopy.utils.postprocessing.get_specific_discharge(spdis, gwfp)\n", + "bud = gwfc.output.budget()\n", + "spdis = bud.get_data(text='DATA-SPDIS')[0]\n", + "spdisc = flopy.utils.postprocessing.get_specific_discharge(spdis, gwfc)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "execution": { + "iopub.execute_input": "2022-03-07T20:22:38.977786Z", + "iopub.status.busy": "2022-03-07T20:22:38.943385Z", + "iopub.status.idle": "2022-03-07T20:22:39.702450Z", + "shell.execute_reply": "2022-03-07T20:22:39.703340Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot the results from both the parent and child models\n", + "# on the same figure\n", + "f = plt.figure(figsize=(10, 10))\n", + "ax = plt.subplot(1, 1, 1, aspect=\"equal\")\n", + "pmvp = flopy.plot.PlotMapView(gwfp, ax=ax)\n", + "pmvc = flopy.plot.PlotMapView(gwfc, ax=ax, extent=pmvp.extent)\n", + "\n", + "pmvp.plot_array(head[0], vmin=0., vmax=1.)\n", + "pmvc.plot_array(head[1], vmin=0., vmax=1.)\n", + "\n", + "pmvp.plot_grid(colors=\"white\")\n", + "pmvc.plot_grid(colors=\"white\")\n", + "\n", + "pmvp.plot_vector(spdisp[0], spdisp[1], normalize=True, color=\"white\")\n", + "pmvc.plot_vector(spdisc[0], spdisc[1], normalize=True, color=\"white\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/flopy/utils/lgrutil.py b/flopy/utils/lgrutil.py index c0239824d..6d0f41f08 100644 --- a/flopy/utils/lgrutil.py +++ b/flopy/utils/lgrutil.py @@ -1,9 +1,99 @@ import numpy as np +from ..discretization import StructuredGrid from ..modflow import Modflow from .util_array import Util2d, Util3d +class SimpleRegularGrid: + """ + Simple object for representing regular MODFLOW grid information. + + Parameters + ---------- + nlay : int + number of layers + nrow : int + number of rows + ncol : int + number of columns + delr : ndarray + delr array + delc : ndarray + delc array + top : ndarray + top array (nrow, ncol) + botm : ndarray + botm array (nlay, nrow, ncol) + idomain : ndarray + idomain array (nlay, nrow, ncol) + xorigin : float + x location of grid lower left corner + yorigin : float + y location of grid lower left corner + """ + + def __init__( + self, + nlay, + nrow, + ncol, + delr, + delc, + top, + botm, + idomain, + xorigin, + yorigin, + ): + # enforce compliance + assert delr.shape == (ncol,) + assert delc.shape == (nrow,) + assert top.shape == (nrow, ncol) + assert botm.shape == (nlay, nrow, ncol) + assert idomain.shape == (nlay, nrow, ncol) + + self.nlay = nlay + self.nrow = nrow + self.ncol = ncol + self.delr = delr + self.delc = delc + self.top = top + self.botm = botm + self.idomain = idomain + self.xorigin = xorigin + self.yorigin = yorigin + return + + @property + def modelgrid(self): + mg = StructuredGrid( + delc=self.delc, + delr=self.delr, + top=self.top, + botm=self.botm, + idomain=self.idomain, + xoff=self.xorigin, + yoff=self.yorigin, + ) + return mg + + def get_gridprops_dis6(self): + gridprops = { + "xorigin": self.xorigin, + "yorigin": self.yorigin, + "nlay": self.nlay, + "nrow": self.nrow, + "ncol": self.ncol, + "delr": self.delr, + "delc": self.delc, + "top": self.top, + "botm": self.botm, + "idomain": self.idomain, + } + return gridprops + + class Lgr: def __init__( self, @@ -24,8 +114,6 @@ def __init__( Parameters ---------- - parent : flopy.modflow.Modflow - parent model nlayp : int parent layers nrowp : int @@ -144,13 +232,13 @@ def get_delr_delc(self): jstart = 0 jend = self.ncpp for j in range(self.npcbeg, self.npcend + 1): - delr[jstart:jend] = self.delrp[j - 1] / self.ncpp + delr[jstart:jend] = self.delrp[j] / self.ncpp jstart = jend jend = jstart + self.ncpp istart = 0 iend = self.ncpp for i in range(self.nprbeg, self.nprend + 1): - delc[istart:iend] = self.delcp[i - 1] / self.ncpp + delc[istart:iend] = self.delcp[i] / self.ncpp istart = iend iend = istart + self.ncpp return delr, delc @@ -433,3 +521,62 @@ def get_exchange_data(self, angldegx=False, cdist=False): exg.append(cd) exglist.append(exg) return exglist + + @property + def parent(self): + """ + Return a SimpleRegularGrid object for the parent model + + Returns + ------- + simple_regular_grid : SimpleRegularGrid + simple grid object containing grid information for the parent + + """ + simple_regular_grid = SimpleRegularGrid( + self.nlayp, + self.nrowp, + self.ncolp, + self.delrp, + self.delcp, + self.topp, + self.botmp, + self.idomain, + self.xllp, + self.yllp, + ) + return simple_regular_grid + + @property + def child(self): + """ + Return a SimpleRegularGrid object for the child model + + Returns + ------- + simple_regular_grid : SimpleRegularGrid + simple grid object containing grid information for the child + + """ + delrc, delcc = self.get_delr_delc() + idomainc = self.get_idomain() # child idomain + topc, botmc = self.get_top_botm() # top/bottom of child grid + child_dis_shp = self.get_shape() + nlayc = child_dis_shp[0] + nrowc = child_dis_shp[1] + ncolc = child_dis_shp[2] + xorigin = self.xll + yorigin = self.yll + simple_regular_grid = SimpleRegularGrid( + nlayc, + nrowc, + ncolc, + delrc, + delcc, + topc, + botmc, + idomainc, + xorigin, + yorigin, + ) + return simple_regular_grid