From dc847dff9a5ef2d830e9a0948cd7dd98fe8b9f4b Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Wed, 8 May 2024 16:32:20 -0500 Subject: [PATCH 1/5] feat: support for local grid refinement models that only occupy some layers of the enclosing parent model --- docs/source/concepts/index.rst | 1 + docs/source/concepts/lgr.rst | 31 + docs/source/conf.py | 2 + docs/source/references.rst | 4 + examples/Pleasant_lake_lgr_example.ipynb | 688 ++--------------------- examples/pleasant_lgr_inset.yml | 3 +- examples/pleasant_lgr_parent.yml | 2 + mfsetup/discretization.py | 10 +- mfsetup/mf6model.py | 35 +- mfsetup/sourcedata.py | 19 + mfsetup/tests/test_lgr.py | 71 ++- mfsetup/wells.py | 3 +- 12 files changed, 202 insertions(+), 667 deletions(-) create mode 100644 docs/source/concepts/lgr.rst diff --git a/docs/source/concepts/index.rst b/docs/source/concepts/index.rst index 7678cbb2..a7c63d76 100644 --- a/docs/source/concepts/index.rst +++ b/docs/source/concepts/index.rst @@ -6,4 +6,5 @@ Modflow-setup concepts and methods :maxdepth: 1 Interpolation + Local grid refinement Specifying perimeter boundary conditions diff --git a/docs/source/concepts/lgr.rst b/docs/source/concepts/lgr.rst new file mode 100644 index 00000000..13d81f57 --- /dev/null +++ b/docs/source/concepts/lgr.rst @@ -0,0 +1,31 @@ +=========================================================== +Local grid refinement +=========================================================== + +In MODFLOW 6, two groundwater models can be tightly coupled in the same simulation, which allows for efficient "local grid refinement" (LGR; Mehl and others, 2006) and "semistructured" (Feinstein and others, 2016) configurations that combine multiple structured model layers at different resolutions (Langevin and others, 2017). Locally refined area(s) are conceptualized as separate model(s) that are linked to the surrounding (usually coarser) "parent" model through the GWF Model Exchange Package. Similarly, "semistructured" configurations are represented by multiple linked models for each layer or group of layers with the same resolution. + +Modflow-setup supports this functionality via an ``lgr:`` subblock within the ``setup_grid:`` block of the configuration file. The ``lgr:`` subblock consists of one of more subblocks, each keyed by a linked model name and containing configuration input for that linked model. Vertical layer refinement relative to the "parent" model, and the range of parent model layers that will be occupied by the linked "inset" model are also specified. + +For example, the following "parent" configuration for the :ref:`Pleasant Lake Example ` creates a local refinement model named "``pleasant_lgr_inset``" that spans layers 0 through 3 (the first 4 layers) of the parent model, at the same vertical resolution (1 inset model layer per parent model layer). The horizontal location and resolution of the inset model are specified in the inset model configuration file, in the same way that they are specified for any model. + +.. literalinclude:: ../../../examples/pleasant_lgr_parent.yml + :language: yaml + :start-at: lgr: + :end-before: # Structured Discretization Package + +Input from the ``lgr:`` subblock and the inset model configuration file(s) is passed to the :py:class:`Flopy Lgr Utility `, which helps create input for the GWF Model Exchange Package. + +Within the context of a Python session, inset model information is stored in a dictionary under an ``inset`` attribute attached to the parent model. For example, to access a Flopy model object for the above inset model from a parent model named ``model``: + +.. code-block:: python + + inset_model = model.inset['pleasant_lgr_inset'] + + +**A few notes about LGR functionality in Modflow-setup** + +* **Locally refined "inset" models must be aligned with the parent model grid**, which also means that their horizontal resolution must be a factor of the "parent" model resolution. Modflow-setup handles the alignment automatically by "snapping" inset model grids to the lower left corner of the parent cell containing the lower left corner of the inset model grid (the inset model origin in real-world coordinates). +* Similarly, inset models need to align vertically with the parent model layers. Parent layers can be subdivided using the ``layer_refinement:`` input option. +* In principal, a **semistructured** configuration consisting of a "parent" model at the coarsest horizontal resolution, and one or more inset models representing [horizontally and potentially vertically] refined layers within the "parent" model domain is possible, but this configuration has not been tested with Modflow-setup. Please contact the Modflow-setup development team by posting a `GitHub issue `_ if you are interested in this. +* Similarly, multiple inset models at different horizontal locations, and even inset models within inset models should be achievable, but have not been tested. +* **Multi-model configurations come with costs.** Each model within a MODFLOW 6 simulation carries its own set of files, including external text array and list input files to packages. As with a single model, when using the automated parameterization functionality in `pyEMU `_, the number of files is multiplied. At some point, at may be more efficient to work with individual models, and design the grids in such a way that boundary conditions along the model perimeters have a minimal impact on the predictions of interest. diff --git a/docs/source/conf.py b/docs/source/conf.py index 99e56e32..8c3bc988 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -236,3 +236,5 @@ 'matplotlib': ('https://matplotlib.org/stable/', None), 'rasterio': ('https://rasterio.readthedocs.io/en/latest/', None) } + +tls_verify = False diff --git a/docs/source/references.rst b/docs/source/references.rst index affe3c2b..fc76bb6b 100644 --- a/docs/source/references.rst +++ b/docs/source/references.rst @@ -13,6 +13,8 @@ Scripting MODFLOW Model Development Using Python and FloPy: Groundwater, v. 54, Clark, B.R., Barlow, P.M., Peterson, S.M., Hughes, J.D., Reeves, H.W., and Viger, R.J., 2018, National-scale grid to support regional groundwater availability studies and a national hydrogeologic database: U.S. Geological Survey data release, https://doi.org/10.5066/F7P84B24. +Feinstein, D.T., Fienen, M.N., Reeves, H.W., and Langevin, C.D., 2016, A semi-structured MODFLOW-USG model to evaluate local water sources to wells for decision support: Groundwater, v. 54, no. 4, p. 532–544, accessed June 27, 2017, at https://doi.org/10.1111/gwat.12389. + Fienen, M.N., Haserodt, M.J., Leaf, A.T., Westenbroek, S.M., 2021a, Appendix C: Central sands lakes study technical report: Modeling documentation, Central Sands Lake Study, Wisconsin Department of Natural Resources, 10.5281/zenodo.5708719 Haitjema, H.M. (1995). Analytic Element Modeling of Groundwater Flow. Academic Press, Inc. @@ -24,6 +26,8 @@ Langevin, C.D., Hughes, J.D., Banta, E.R., Niswonger, R.G., Panday, Sorab, and P Leaf AT and Fienen MN (2022) Modflow-setup: Robust automation of groundwater model construction. Front. Earth Sci. 10:903965. https://doi.org/10.3389/feart.2022.903965 +Mehl, S., Hill, M. C., and Leake, S. A. (2006). Comparison of local grid refinement methods for MODFLOW. Ground Water 44, 792–796. doi:10.1111/j.1745-6584.2006.00192.x + Niswonger, R.G., Panday, S., and Ibaraki, M., 2011, MODFLOW–NWT—A Newton formulation for MODFLOW–2005: U.S. Geological Survey Techniques and Methods, book 6, chap. A37, 44 p. https://doi.org/10.3133/tm6A45 Westenbroek, S.M., Engott, J.A., Kelson, V.A., and Hunt, R.J., 2018, SWB Version 2.0—A soil-water-balance code for estimating net infiltration and other water-budget components: U.S. Geological Survey Techniques and Methods, book 6, chap. A59, 118 p., https://doi.org/10.3133/tm6A59. diff --git a/examples/Pleasant_lake_lgr_example.ipynb b/examples/Pleasant_lake_lgr_example.ipynb index dbf737d5..1a4b5760 100644 --- a/examples/Pleasant_lake_lgr_example.ipynb +++ b/examples/Pleasant_lake_lgr_example.ipynb @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -71,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -89,52 +89,18 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "5 layer(s), 25 row(s), 25 column(s)\n", - "delr: [200.00...200.00] meters\n", - "delc: [200.00...200.00] meters\n", - "CRS: EPSG:3070\n", - "length units: meters\n", - "xll: 553000.0; yll: 388000.0; rotation: 0.0\n", - "Bounds: (553000.0, 558000.0, 388000.0, 393000.0)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "m.modelgrid" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "70 row(s), 80 column(s)\n", - "delr: [40.00...40.00] meters\n", - "delc: [40.00...40.00] meters\n", - "CRS: EPSG:3070\n", - "length units: meters\n", - "xll: 554200.0; yll: 389000.0; rotation: 0.0\n", - "Bounds: (554200.0, 557400.0, 389000.0, 391800.0)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "m.inset['plsnt_lgr_inset'].modelgrid" ] @@ -149,20 +115,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'d:\\\\github\\\\modflow-setup\\\\examples\\\\pleasant_lgr'" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "os.getcwd()" ] @@ -177,24 +132,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "creating shapely Polygons of grid cells...\n", - "finished in 0.02s\n", - "\n", - "writing postproc/shps/plsnt_lgr_parent_grid.shp... Done\n", - "creating shapely Polygons of grid cells...\n", - "finished in 0.24s\n", - "\n", - "writing postproc/shps/plsnt_lgr_inset_grid.shp... Done\n" - ] - } - ], + "outputs": [], "source": [ "m.modelgrid.write_shapefile('postproc/shps/plsnt_lgr_parent_grid.shp')\n", "m.inset['plsnt_lgr_inset'].modelgrid.write_shapefile('postproc/shps/plsnt_lgr_inset_grid.shp')" @@ -209,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -225,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -242,36 +182,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Pleasant Lake test case version 0.1.post23.dev0+g8c863de\n", - "Parent model: d:\\github\\modflow-setup\\examples\\data\\pleasant/pleasant\n", - "5 layer(s), 25 row(s), 25 column(s)\n", - "delr: [200.00...200.00] meters\n", - "delc: [200.00...200.00] meters\n", - "CRS: EPSG:3070\n", - "length units: meters\n", - "xll: 553000.0; yll: 388000.0; rotation: 0.0\n", - "Bounds: (553000.0, 558000.0, 388000.0, 393000.0)\n", - "Packages: dis ic npf sto rcha_0 oc chd_0 obs_0 sfr_0 wel_0 obs_1 obs_2\n", - "13 period(s):\n", - " per start_datetime end_datetime perlen steady nstp\n", - " 0 2012-01-01 2012-01-01 1.0 True 1\n", - " 1 2012-01-01 2012-02-01 31.0 False 1\n", - " 2 2012-02-01 2012-03-01 29.0 False 1\n", - " ...\n", - " 12 2012-12-01 2013-01-01 31.0 False 1" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "m" ] @@ -285,20 +198,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['metadata', 'simulation', 'model', 'parent', 'postprocessing', 'setup_grid', 'dis', 'tdis', 'ic', 'npf', 'sto', 'rch', 'sfr', 'high_k_lakes', 'lak', 'mvr', 'chd', 'drn', 'ghb', 'riv', 'wel', 'oc', 'obs', 'ims', 'mfsetup_options', 'filename', 'maw', 'external_files', 'intermediate_data', 'grid'])" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "m.cfg.keys()" ] @@ -312,46 +214,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "defaultdict(dict,\n", - " {'remake_top': True,\n", - " 'options': {'length_units': 'meters'},\n", - " 'dimensions': {'nlay': 5, 'nrow': 25, 'ncol': 25},\n", - " 'griddata': {'top': [{'filename': '.\\\\external\\\\plsnt_lgr_parent_top.dat'}],\n", - " 'botm': [{'filename': '.\\\\external\\\\plsnt_lgr_parent_botm_000.dat'},\n", - " {'filename': '.\\\\external\\\\plsnt_lgr_parent_botm_001.dat'},\n", - " {'filename': '.\\\\external\\\\plsnt_lgr_parent_botm_002.dat'},\n", - " {'filename': '.\\\\external\\\\plsnt_lgr_parent_botm_003.dat'},\n", - " {'filename': '.\\\\external\\\\plsnt_lgr_parent_botm_004.dat'}],\n", - " 'idomain': [{'filename': '.\\\\external\\\\plsnt_lgr_parent_idomain_000.dat'},\n", - " {'filename': '.\\\\external\\\\plsnt_lgr_parent_idomain_001.dat'},\n", - " {'filename': '.\\\\external\\\\plsnt_lgr_parent_idomain_002.dat'},\n", - " {'filename': '.\\\\external\\\\plsnt_lgr_parent_idomain_003.dat'},\n", - " {'filename': '.\\\\external\\\\plsnt_lgr_parent_idomain_004.dat'}]},\n", - " 'top_filename_fmt': 'top.dat',\n", - " 'botm_filename_fmt': 'botm_{:03d}.dat',\n", - " 'idomain_filename_fmt': 'idomain_{:03d}.dat',\n", - " 'minimum_layer_thickness': 1,\n", - " 'drop_thin_cells': True,\n", - " 'source_data': {'top': {'filename': 'd:\\\\github\\\\modflow-setup\\\\examples\\\\data\\\\pleasant\\\\source_data\\\\rasters\\\\dem40m.tif',\n", - " 'elevation_units': 'meters'},\n", - " 'botm': {'filenames': {1: 'd:\\\\github\\\\modflow-setup\\\\examples\\\\data/pleasant/source_data/rasters/botm0.tif',\n", - " 2: 'd:\\\\github\\\\modflow-setup\\\\examples\\\\data/pleasant/source_data/rasters/botm1.tif',\n", - " 3: 'd:\\\\github\\\\modflow-setup\\\\examples\\\\data/pleasant/source_data/rasters/botm2.tif',\n", - " 4: 'd:\\\\github\\\\modflow-setup\\\\examples\\\\data/pleasant/source_data/rasters/botm3.tif'}}},\n", - " 'nlay': 4})" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "m.cfg['dis']" ] @@ -365,36 +230,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'plsnt_lgr_inset': plsnt_lgr_inset model version 0.3.0.post23.dev0+g8c863de\n", - " Parent model: ./plsnt_lgr_parent\n", - " 5 layer(s), 70 row(s), 80 column(s)\n", - " delr: [40.00...40.00] meters\n", - " delc: [40.00...40.00] meters\n", - " CRS: EPSG:3070\n", - " length units: meters\n", - " xll: 554200.0; yll: 389000.0; rotation: 0.0\n", - " Bounds: (554200.0, 557400.0, 389000.0, 391800.0)\n", - " Packages: dis ic npf sto rcha_0 oc sfr_0 lak_0 obs_0 obs_1\n", - " 13 period(s):\n", - " per start_datetime end_datetime perlen steady nstp\n", - " 0 2012-01-01 2012-01-01 1.0 True 1\n", - " 1 2012-01-01 2012-02-01 31.0 False 1\n", - " 2 2012-02-01 2012-03-01 29.0 False 1\n", - " ...\n", - " 12 2012-12-01 2013-01-01 31.0 False 1}" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "m.inset" ] @@ -408,30 +246,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "inset = m.inset['plsnt_lgr_inset']\n", "\n", @@ -470,141 +287,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "writing simulation...\n", - " writing simulation name file...\n", - " writing simulation tdis package...\n", - " writing solution package ims_-1...\n", - " writing package pleasant_lgr.mvr...\n", - " writing package pleasant_lgr.gwfgwf...\n", - " writing model plsnt_lgr_parent...\n", - " writing model name file...\n", - " writing package dis...\n", - " writing package ic...\n", - " writing package npf...\n", - " writing package sto...\n", - " writing package rcha_0...\n", - " writing package oc...\n", - " writing package chd_0...\n", - "INFORMATION: maxbound in ('gwf6', 'chd', 'dimensions') changed to 240 based on size of stress_period_data\n", - " writing package obs_0...\n", - " writing package sfr_0...\n", - " writing package wel_0...\n", - "INFORMATION: maxbound in ('gwf6', 'wel', 'dimensions') changed to 2 based on size of stress_period_data\n", - " writing package obs_1...\n", - " writing package obs_2...\n", - " writing model plsnt_lgr_inset...\n", - " writing model name file...\n", - " writing package dis...\n", - " writing package ic...\n", - " writing package npf...\n", - " writing package sto...\n", - " writing package rcha_0...\n", - " writing package oc...\n", - " writing package sfr_0...\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - "WARNING: Unable to resolve dimension of ('gwf6', 'sfr', 'connectiondata', 'connectiondata', 'ic') based on shape \"nconifno\".\n", - " writing package lak_0...\n", - " writing package obs_0...\n", - " writing package obs_1...\n", - "SFRmaker v. 0.11.1.post5+ga0e0c61\n", - "\n", - "Running Flopy v. 3.5.0.dev0 diagnostics...\n", - "passed.\n", - "\n", - "Checking for continuity in segment and reach numbering...\n", - "passed.\n", - "\n", - "Checking for increasing segment numbers in downstream direction...\n", - "passed.\n", - "\n", - "Checking for circular routing...\n", - "passed.\n", - "\n", - "Checking reach connections for proximity...\n", - "2 segments with non-adjacent reaches found.\n", - "At segments:\n", - "1 2\n", - "\n", - "2 segments with non-adjacent reaches found.\n", - "At segments:\n", - "1 2\n", - "\n", - "\n", - "Checking for model cells with multiple non-zero SFR conductances...\n", - "passed.\n", - "\n", - "Checking for streambed tops of less than -10...\n", - "isfropt setting of 1,2 or 3 requires strtop information!\n", - "\n", - "\n", - "Checking for streambed tops of greater than 15000...\n", - "isfropt setting of 1,2 or 3 requires strtop information!\n", - "\n", - "\n", - "Checking segment_data for downstream rises in streambed elevation...\n", - "Segment elevup and elevdn not specified for nstrm=-13 and isfropt=1\n", - "passed.\n", - "\n", - "Checking reach_data for downstream rises in streambed elevation...\n", - "3 reaches encountered with strtop < strtop of downstream reach.\n", - "Elevation rises:\n", - "k i j iseg ireach strtop strtopdn d_strtop reachID diff\n", - "4 20 16 2 1 290.3638610839844 294.76507568359375 4.401214599609375 5 -4.401214599609375\n", - "4 20 17 2 2 290.3638610839844 293.5867614746094 3.222900390625 6 -3.222900390625\n", - "4 21 17 2 3 290.3638610839844 292.6883850097656 2.32452392578125 7 -2.32452392578125\n", - "\n", - "\n", - "Checking reach_data for inconsistencies between streambed elevations and the model grid...\n", - "passed.\n", - "\n", - "Checking segment_data for inconsistencies between segment end elevations and the model grid...\n", - "Segment elevup and elevdn not specified for nstrm=-13 and isfropt=1\n", - "passed.\n", - "\n", - "Checking for streambed slopes of less than 0.0001...\n", - "passed.\n", - "\n", - "Checking for streambed slopes of greater than 1.0...\n", - "passed.\n", - "\n", - "wrote plsnt_lgr_parent_SFR.chk\n", - "wrote plsnt_lgr_parent.sfr.obs\n", - "converting reach and segment data to package data...\n", - "wrote d:\\github\\modflow-setup\\examples\\pleasant_lgr\\external\\plsnt_lgr_parent_packagedata.dat\n", - "wrote d:\\github\\modflow-setup\\examples\\pleasant_lgr\\plsnt_lgr_parent.sfr\n" - ] - } - ], + "outputs": [], "source": [ "m.write_input()" ] @@ -620,78 +305,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "FloPy is using the following executable to run the model: ..\\..\\..\\..\\software\\mf6.exe\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 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 16:14:29 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): 2023/11/15 14:15:29\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", - " Solving: Stress period: 2 Time step: 1\n", - " Solving: Stress period: 3 Time step: 1\n", - " Solving: Stress period: 4 Time step: 1\n", - " Solving: Stress period: 5 Time step: 1\n", - " Solving: Stress period: 6 Time step: 1\n", - " Solving: Stress period: 7 Time step: 1\n", - " Solving: Stress period: 8 Time step: 1\n", - " Solving: Stress period: 9 Time step: 1\n", - " Solving: Stress period: 10 Time step: 1\n", - " Solving: Stress period: 11 Time step: 1\n", - " Solving: Stress period: 12 Time step: 1\n", - " Solving: Stress period: 13 Time step: 1\n", - " \n", - " Run end date and time (yyyy/mm/dd hh:mm:ss): 2023/11/15 14:15:35\n", - " Elapsed run time: 6.504 Seconds\n", - " \n", - " Normal termination of simulation.\n" - ] - }, - { - "data": { - "text/plain": [ - "(True, [])" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "m.simulation.run_simulation()" ] @@ -705,7 +321,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -738,7 +354,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -776,20 +392,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.rcParams['axes.labelsize'] = 8\n", "plt.rcParams['xtick.labelsize'] = 8\n", @@ -881,220 +486,9 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "dis package...\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\thickness_lay0.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\thickness_lay1.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\thickness_lay2.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\thickness_lay3.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\thickness_lay4.tif\n", - "top:\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\top.tif\n", - "botm:\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\botm_lay0.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\botm_lay1.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\botm_lay2.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\botm_lay3.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\botm_lay4.tif\n", - "idomain:\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\idomain_lay0.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\idomain_lay1.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\idomain_lay2.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\idomain_lay3.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\idomain_lay4.tif\n", - "\n", - "ic package...\n", - "strt:\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\strt_lay0.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\strt_lay1.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\strt_lay2.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\strt_lay3.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\strt_lay4.tif\n", - "\n", - "npf package...\n", - "icelltype:\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\icelltype_lay0.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\icelltype_lay1.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\icelltype_lay2.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\icelltype_lay3.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\icelltype_lay4.tif\n", - "k:\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\k_lay0.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\k_lay1.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\k_lay2.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\k_lay3.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\k_lay4.tif\n", - "k33:\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\k33_lay0.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\k33_lay1.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\k33_lay2.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\k33_lay3.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\k33_lay4.tif\n", - "\n", - "sto package...\n", - "iconvert:\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\iconvert_lay0.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\iconvert_lay1.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\iconvert_lay2.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\iconvert_lay3.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\iconvert_lay4.tif\n", - "ss:\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\ss_lay0.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\ss_lay1.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\ss_lay2.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\ss_lay3.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\ss_lay4.tif\n", - "sy:\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\sy_lay0.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\sy_lay1.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\sy_lay2.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\sy_lay3.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\sy_lay4.tif\n", - "\n", - "rcha_0 package...\n", - "irch:\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\irch_per0.tif\n", - "recharge:\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\recharge_per0.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\recharge_per1.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\recharge_per2.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\recharge_per3.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\recharge_per4.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\recharge_per5.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\recharge_per6.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\recharge_per7.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\recharge_per8.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\recharge_per9.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\recharge_per10.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\recharge_per11.tif\n", - "wrote postproc\\plsnt_lgr_parent\\rasters\\recharge_per12.tif\n", - "\n", - "chd_0 package...\n", - "skipped, not implemented yet\n", - "\n", - "obs_0 package...\n", - "skipped, not implemented yet\n", - "\n", - "sfr_0 package...\n", - "writing postproc\\plsnt_lgr_parent\\shps\\plsnt_lgr_parent.sfr.shp... Done\n", - "\n", - "wel_0 package...\n", - "skipped, not implemented yet\n", - "\n", - "obs_1 package...\n", - "skipped, not implemented yet\n", - "\n", - "obs_2 package...\n", - "writing postproc\\plsnt_lgr_parent\\shps\\obs2_stress_period_data.shp... Done\n", - "\n", - "dis package...\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\thickness_lay0.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\thickness_lay1.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\thickness_lay2.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\thickness_lay3.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\thickness_lay4.tif\n", - "top:\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\top.tif\n", - "botm:\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\botm_lay0.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\botm_lay1.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\botm_lay2.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\botm_lay3.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\botm_lay4.tif\n", - "idomain:\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\idomain_lay0.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\idomain_lay1.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\idomain_lay2.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\idomain_lay3.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\idomain_lay4.tif\n", - "\n", - "ic package...\n", - "strt:\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\strt_lay0.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\strt_lay1.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\strt_lay2.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\strt_lay3.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\strt_lay4.tif\n", - "\n", - "npf package...\n", - "icelltype:\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\icelltype_lay0.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\icelltype_lay1.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\icelltype_lay2.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\icelltype_lay3.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\icelltype_lay4.tif\n", - "k:\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\k_lay0.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\k_lay1.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\k_lay2.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\k_lay3.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\k_lay4.tif\n", - "k33:\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\k33_lay0.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\k33_lay1.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\k33_lay2.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\k33_lay3.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\k33_lay4.tif\n", - "\n", - "sto package...\n", - "iconvert:\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\iconvert_lay0.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\iconvert_lay1.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\iconvert_lay2.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\iconvert_lay3.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\iconvert_lay4.tif\n", - "ss:\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\ss_lay0.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\ss_lay1.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\ss_lay2.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\ss_lay3.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\ss_lay4.tif\n", - "sy:\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\sy_lay0.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\sy_lay1.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\sy_lay2.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\sy_lay3.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\sy_lay4.tif\n", - "\n", - "rcha_0 package...\n", - "irch:\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\irch_per0.tif\n", - "recharge:\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\recharge_per0.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\recharge_per1.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\recharge_per2.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\recharge_per3.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\recharge_per4.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\recharge_per5.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\recharge_per6.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\recharge_per7.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\recharge_per8.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\recharge_per9.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\recharge_per10.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\recharge_per11.tif\n", - "wrote postproc\\plsnt_lgr_inset\\rasters\\recharge_per12.tif\n", - "\n", - "sfr_0 package...\n", - "writing postproc\\plsnt_lgr_inset\\shps\\plsnt_lgr_inset.sfr.shp... Done\n", - "\n", - "lak_0 package...\n", - "skipping lak0.perioddata; efficient export not implemented\n", - "\n", - "obs_0 package...\n", - "skipped, not implemented yet\n", - "\n", - "obs_1 package...\n", - "writing postproc\\plsnt_lgr_inset\\shps\\obs1_stress_period_data.shp... Done\n" - ] - } - ], + "outputs": [], "source": [ "for model in m, inset:\n", " mfexport.export(model, model.modelgrid, output_path=f'postproc/{model.name}/')" @@ -1109,21 +503,9 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "summarizing plsnt_lgr_parent input...\n", - "skipped, not implemented yet\n", - "skipped, not implemented yet\n", - "summarizing plsnt_lgr_inset input...\n", - "skipped, not implemented yet\n" - ] - } - ], + "outputs": [], "source": [ "for model in m, inset:\n", " mfexport.summarize(model, output_path=f'postproc/{model.name}/')" @@ -1146,7 +528,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.12.2" } }, "nbformat": 4, diff --git a/examples/pleasant_lgr_inset.yml b/examples/pleasant_lgr_inset.yml index 1eda2f8f..51ff9abc 100644 --- a/examples/pleasant_lgr_inset.yml +++ b/examples/pleasant_lgr_inset.yml @@ -44,7 +44,7 @@ dis: length_units: 'meters' dimensions: # nrow and ncol are based on the buffer distance and grid spacing - nlay: 5 + nlay: 4 source_data: top: filename: 'data/pleasant/source_data/rasters/dem40m.tif' # DEM file; path relative to setup script @@ -54,7 +54,6 @@ dis: 1: 'data/pleasant/source_data/rasters/botm0.tif' # preprocessed surface for parent model layer 0 bottom 2: 'data/pleasant/source_data/rasters/botm1.tif' # preprocessed surface for parent model layer 1 bottom 3: 'data/pleasant/source_data/rasters/botm2.tif' # preprocessed surface for parent model layer 2 bottom - 4: 'data/pleasant/source_data/rasters/botm3.tif' # preprocessed surface for parent model layer 3 bottom # Recharge and Well packages are inherited from the parent model # (since this is an LGR model diff --git a/examples/pleasant_lgr_parent.yml b/examples/pleasant_lgr_parent.yml index 24f540d7..70d8c719 100644 --- a/examples/pleasant_lgr_parent.yml +++ b/examples/pleasant_lgr_parent.yml @@ -80,6 +80,8 @@ setup_grid: pleasant_lgr_inset: filename: 'pleasant_lgr_inset.yml' layer_refinement: 1 # number of lgr model layers per parent model layer + parent_start_layer: 0 # uppermost parent model layer to include in lgr + parent_end_layer: 3 # lowermost parent model layer to include in lgr # Structured Discretization Package dis: diff --git a/mfsetup/discretization.py b/mfsetup/discretization.py index 50a29b96..29502674 100644 --- a/mfsetup/discretization.py +++ b/mfsetup/discretization.py @@ -226,7 +226,7 @@ def get_next_above(seq, value): def fill_cells_vertically(top, botm): - """In MODFLOW 6, cells where idomain != 1 are excluded from the solution. + """In MODFLOW 6, cells where idomain < 1 are excluded from the solution. However, in the botm array, values are needed in overlying cells to compute layer thickness (cells with idomain != 1 overlying cells with idomain >= 1 need values in botm). Given a 3D numpy array with nan values indicating excluded cells, @@ -404,7 +404,8 @@ def make_ibound(top, botm, nodata=-9999, return idomain -def make_lgr_idomain(parent_modelgrid, inset_modelgrid): +def make_lgr_idomain(parent_modelgrid, inset_modelgrid, + parent_start_layer=0, parent_end_layer=None): """Inactivate cells in parent_modelgrid that coincide with area of inset_modelgrid.""" if parent_modelgrid.rotation != inset_modelgrid.rotation: @@ -412,6 +413,8 @@ def make_lgr_idomain(parent_modelgrid, inset_modelgrid): f'\nParent rotation: {parent_modelgrid.rotation}' f'\nInset rotation: {inset_modelgrid.rotation}' ) + if parent_end_layer is None: + parent_end_layer = parent_modelgrid.nlay -1 # upper left corner of inset model in parent model # use the cell centers, to avoid edge situation # where neighboring parent cell is accidentally selected @@ -423,7 +426,8 @@ def make_lgr_idomain(parent_modelgrid, inset_modelgrid): y1 = inset_modelgrid.ycellcenters[-1, -1] pi1, pj1 = parent_modelgrid.intersect(x1, y1, forgive=True) idomain = np.ones(parent_modelgrid.shape, dtype=int) - idomain[:, pi0:pi1+1, pj0:pj1+1] = 0 + idomain[parent_start_layer:parent_end_layer, + pi0:pi1+1, pj0:pj1+1] = 0 return idomain diff --git a/mfsetup/mf6model.py b/mfsetup/mf6model.py index 17d24e46..058ce76f 100644 --- a/mfsetup/mf6model.py +++ b/mfsetup/mf6model.py @@ -375,11 +375,38 @@ def create_lgr_models(self): self.inset[inset_model.name] = inset_model #self.inset[inset_model.name]._is_lgr = True - # create idomain indicating area of parent grid that is LGR - lgr_idomain = make_lgr_idomain(self.modelgrid, self.inset[inset_model.name].modelgrid) - - ncpp = int(self.modelgrid.delr[0] / self.inset[inset_model.name].modelgrid.delr[0]) + # establish inset model layering within parent model + parent_start_layer = v.get('parent_start_layer', 0) + # parent_end_layer is specified as the last zero-based + # parent layer that includes LGR refinement (not as a slice end) + parent_end_layer = v.get('parent_end_layer', self.nlay - 1) + 1 ncppl = v.get('layer_refinement', 1) + specified_nlay_lgr = ncppl * (parent_end_layer - parent_start_layer) + specified_nlay_dis = inset_cfg['dis']['dimensions']['nlay'] + if specified_nlay_lgr != specified_nlay_dis: + raise ValueError( + f"Parent model layers of {parent_start_layer} to {parent_end_layer} " + f"and layer refinement of {ncppl} implies {specified_nlay_lgr} inset model layers.\n" + f"{specified_nlay_dis} inset model layers specified in DIS package.") + # mapping between parent and inset model layers + # that is used for copying input from parent model + parent_inset_layer_mapping = dict() + inset_k = -1 + for parent_k in range(parent_start_layer, parent_end_layer): + for i in range(ncppl): + inset_k += 1 + parent_inset_layer_mapping[parent_k] = inset_k + self.inset[inset_model.name].cfg['parent']['inset_layer_mapping'] =\ + parent_inset_layer_mapping + # create idomain indicating area of parent grid that is LGR + lgr_idomain = make_lgr_idomain(self.modelgrid, self.inset[inset_model.name].modelgrid, + parent_start_layer, parent_end_layer) + + # inset model horizontal refinement from parent resolution + refinement = self.modelgrid.delr[0] / self.inset[inset_model.name].modelgrid.delr[0] + if not np.round(refinement, 4).is_integer(): + raise ValueError(f"LGR inset model spacing must be a factor of the parent model spacing.") + ncpp = int(refinement) self.lgr[inset_model.name] = Lgr(self.nlay, self.nrow, self.ncol, self.dis.delr.array, self.dis.delc.array, self.dis.top.array, self.dis.botm.array, diff --git a/mfsetup/sourcedata.py b/mfsetup/sourcedata.py index 399b1d89..05b268d1 100644 --- a/mfsetup/sourcedata.py +++ b/mfsetup/sourcedata.py @@ -1425,6 +1425,25 @@ def setup_array(model, package, var, data=None, model.cfg['dis']['top_filename_fmt']) top = model.load_array(model.cfg['dis']['griddata']['top'][0]['filename']) + # special case of LGR models + # with bottom connections to underlying parent cells + if model.version == 'mf6': + # (if model is an lgr inset model) + if model._is_lgr: + # regardless of what is specified for inset model bottom + # use top elevations of underlying parent model cells + nlay = model.cfg['dis']['dimensions']['nlay'] + if (nlay < model.parent.modelgrid.nlay): + # use the parent model bottoms + # mapped to the inset model grid by the Flopy Lgr util + lgr = model.parent.lgr[model.name] # Flopy Lgr inst. + data[nlay-1] = lgr.botm[nlay-1] + # set parent model top to top of + # first active parent model layer below this lgr domain + kp = lgr.get_parent_indices(nlay-1, 0, 0)[0] + model.parent.dis.top = lgr.botmp[kp] + j=2 + # fill missing layers if any if len(data) < model.nlay: all_surfaces = np.zeros((model.nlay + 1, model.nrow, model.ncol), dtype=float) * np.nan diff --git a/mfsetup/tests/test_lgr.py b/mfsetup/tests/test_lgr.py index 692dd1db..e8b0e64b 100644 --- a/mfsetup/tests/test_lgr.py +++ b/mfsetup/tests/test_lgr.py @@ -107,8 +107,54 @@ def test_make_lgr_idomain(get_pleasant_lgr_parent_with_grid): assert np.all(idomain[:, ~isinset] >= 1) -def test_lgr_grid_setup(get_pleasant_lgr_parent_with_grid): - m = get_pleasant_lgr_parent_with_grid +@pytest.mark.parametrize( + 'lgr_grid_spacing,parent_start_end_layers,inset_nlay', [ + # parent layers 0 through 3 + # are specified in pleasant_lgr_parent.yml + (40, 'use configuration', 4), + (40, (0, 2), 3), + # special case to test setup + # with no parent start/end layers specified + (40, None, 5), + pytest.param(35, None, 5, marks=pytest.mark.xfail( + reason='inset spacing not a factor of parent spacing')), + pytest.param(40, None, 4, marks=pytest.mark.xfail( + reason='inset nlay inconsistent with parent layers')), + ] + ) +def test_lgr_grid_setup(lgr_grid_spacing, parent_start_end_layers, + inset_nlay, + pleasant_lgr_cfg, pleasant_simulation, + project_root_path): + + # apply test parameters to inset/parent configurations + inset_cfg_path = project_root_path + '/examples/pleasant_lgr_inset.yml' + inset_cfg = load_cfg(inset_cfg_path, + default_file='/mf6_defaults.yml') + inset_cfg['setup_grid']['dxy'] = lgr_grid_spacing + inset_cfg['dis']['dimensions']['nlay'] = inset_nlay + + cfg = pleasant_lgr_cfg.copy() + lgr_cfg = cfg['setup_grid']['lgr']['pleasant_lgr_inset'] + lgr_cfg['cfg'] = inset_cfg + del lgr_cfg['filename'] + if parent_start_end_layers is None: + del lgr_cfg['parent_start_layer'] + del lgr_cfg['parent_end_layer'] + k0, k1 = 0, None + elif parent_start_end_layers == 'use configuration': + k0 = lgr_cfg['parent_start_layer'] + k1 = lgr_cfg['parent_end_layer'] + else: + k0, k1 = parent_start_end_layers + lgr_cfg['parent_start_layer'] = k0 + lgr_cfg['parent_end_layer'] = k1 + + cfg['model']['simulation'] = pleasant_simulation + kwargs = get_input_arguments(cfg['model'], mf6.ModflowGwf, exclude='packages') + m = MF6model(cfg=cfg, **kwargs) + m.setup_grid() + inset_model = m.inset['plsnt_lgr_inset'] assert isinstance(inset_model, MF6model) assert inset_model.parent is m @@ -120,10 +166,27 @@ def test_lgr_grid_setup(get_pleasant_lgr_parent_with_grid): inset_model.modelgrid.write_shapefile(outfolder / 'pleasant_lgr_inset_grid.shp') # verify that lgr area was removed from parent idomain - lgr_idomain = make_lgr_idomain(m.modelgrid, inset_model.modelgrid) + lgr_idomain = make_lgr_idomain(m.modelgrid, inset_model.modelgrid, + k0, k1) idomain = m.idomain assert idomain[lgr_idomain == 0].sum() == 0 - + inset_cells_per_layer = inset_model.modelgrid.shape[1] *\ + inset_model.modelgrid.shape[2] + refinement_factor = int(cfg['setup_grid']['dxy'] / lgr_grid_spacing) + nparent_cells_within_lgr_per_layer = inset_cells_per_layer / refinement_factor**2 + # for each layer where lgr is specified, + # there should be at least enough inactive cells to cover the lrg grid area + if k1 is None: + k1 = m.modelgrid.nlay -1 + layers_with_lgr = (lgr_idomain == 0).sum(axis=(1, 2)) >=\ + nparent_cells_within_lgr_per_layer + assert all(layers_with_lgr[k0:k1]) + # layers outside of the specified lgr range should have + # less inactive cells than the size of the lgr grid area + # (specific to this test case with a large LGR extent relative to the total grid) + assert not any(layers_with_lgr[k1+1:]) + assert not any(layers_with_lgr[:k0]) + j=2 # todo: add test that grids are aligned diff --git a/mfsetup/wells.py b/mfsetup/wells.py index acf33e5a..94aa1209 100644 --- a/mfsetup/wells.py +++ b/mfsetup/wells.py @@ -83,7 +83,8 @@ def setup_wel_data(model, source_data=None, #for_external_files=True, # map wells to inset model layers if different from parent to_inset_layers = {v:k for k, v in model.parent_layers.items()} - spd['k'] = [to_inset_layers[k] for k in spd['k']] + spd['k'] = [to_inset_layers.get(k, -9999) for k in spd['k']] + spd = spd.loc[spd['k'] >= 0].copy() df = pd.concat([df, spd], axis=0) From 6b16236564c48fb6cadf2886cc7b0486648e9520 Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Sat, 3 Aug 2024 09:34:49 -0500 Subject: [PATCH 2/5] refactor(bcs.py:setup_basic_stress_data): for models with LGR, drop non-well BCs within LGR areas. (assumes that CHD, DRN, GHB, and RIV cells all represent surface or near-surface features that should be represented in the LGR child model(s) and not the parent model). --- mfsetup/bcs.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/mfsetup/bcs.py b/mfsetup/bcs.py index fda3b658..680b7ec1 100644 --- a/mfsetup/bcs.py +++ b/mfsetup/bcs.py @@ -244,6 +244,16 @@ def setup_basic_stress_data(model, shapefile=None, csvfile=None, # drop locations that are completely inactive df = df.loc[df['k'].isin(range(idomain.shape[0]))] + # for models with LGR: + # drop non-well BCs within LGR areas + # (assumes that CHD, DRN, GHB, and RIV cells + # all represent surface or near-surface features + # that are represented in the LGR models; + # the Well Package is set up using other code in wells.py) + if model.lgr: + df['lgr_idomain'] = model._lgr_idomain2d[df['i'], df['j']] + df = df.loc[df['lgr_idomain'] > 0].copy() + # sort the columns col_order = ['per', 'k', 'i', 'j', 'head', 'elev', 'bhead', 'stage', 'cond', 'rbot', 'boundname'] From 15f13d98e730f975c9b2b851dd4b5ea10cce253f Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Sat, 3 Aug 2024 09:37:23 -0500 Subject: [PATCH 3/5] fix(discretization.py:fill_empty_layers): get_next_above() was not actually returning the next layer above because of incorrect sorting. Include the model top when filling missing layers, in case there are all nans in the botm array; introducing nans into the top can cause issues with partical vertical LGR. feat(with partical vertical LGR:make_lgr_idomain): refactor vertical refinement input to use nccpl (list of LGR child layers in each parent layer), to allow for setup of LGR idomain with partial vertical refinement. --- mfsetup/discretization.py | 16 +- .../data/pleasant_vertical_lgr_inset.yml | 131 ++++++++++ .../data/pleasant_vertical_lgr_parent.yml | 238 ++++++++++++++++++ 3 files changed, 378 insertions(+), 7 deletions(-) create mode 100644 mfsetup/tests/data/pleasant_vertical_lgr_inset.yml create mode 100644 mfsetup/tests/data/pleasant_vertical_lgr_parent.yml diff --git a/mfsetup/discretization.py b/mfsetup/discretization.py index 29502674..7b95bede 100644 --- a/mfsetup/discretization.py +++ b/mfsetup/discretization.py @@ -201,7 +201,7 @@ def get_next_below(seq, value): return item def get_next_above(seq, value): - for item in sorted(seq[::-1]): + for item in sorted(seq)[::-1]: if item < value: return item @@ -264,9 +264,13 @@ def fill_cells_vertically(top, botm): # add in the model bottom elevations # use the minimum values instead of the bottom layer, # in case there are nans in the bottom layer - filled += np.nanmin(botm, axis=0) # botm[-1] + # include the top, in case there are nans in all botms + # introducing nans into the top can cause issues + # with partical vertical LGR + all_surfaces = np.stack([top] + [arr2d for arr2d in botm]) + filled += np.nanmin(all_surfaces, axis=0) # botm[-1] # append the model bottom elevations - filled = np.append(filled, [np.nanmin(botm, axis=0)], axis=0) + filled = np.append(filled, [np.nanmin(all_surfaces, axis=0)], axis=0) return filled[0].copy(), filled[1:].copy() @@ -405,7 +409,7 @@ def make_ibound(top, botm, nodata=-9999, def make_lgr_idomain(parent_modelgrid, inset_modelgrid, - parent_start_layer=0, parent_end_layer=None): + ncppl): """Inactivate cells in parent_modelgrid that coincide with area of inset_modelgrid.""" if parent_modelgrid.rotation != inset_modelgrid.rotation: @@ -413,8 +417,6 @@ def make_lgr_idomain(parent_modelgrid, inset_modelgrid, f'\nParent rotation: {parent_modelgrid.rotation}' f'\nInset rotation: {inset_modelgrid.rotation}' ) - if parent_end_layer is None: - parent_end_layer = parent_modelgrid.nlay -1 # upper left corner of inset model in parent model # use the cell centers, to avoid edge situation # where neighboring parent cell is accidentally selected @@ -426,7 +428,7 @@ def make_lgr_idomain(parent_modelgrid, inset_modelgrid, y1 = inset_modelgrid.ycellcenters[-1, -1] pi1, pj1 = parent_modelgrid.intersect(x1, y1, forgive=True) idomain = np.ones(parent_modelgrid.shape, dtype=int) - idomain[parent_start_layer:parent_end_layer, + idomain[0:(np.array(ncppl) > 0).sum(), pi0:pi1+1, pj0:pj1+1] = 0 return idomain diff --git a/mfsetup/tests/data/pleasant_vertical_lgr_inset.yml b/mfsetup/tests/data/pleasant_vertical_lgr_inset.yml new file mode 100644 index 00000000..ab163592 --- /dev/null +++ b/mfsetup/tests/data/pleasant_vertical_lgr_inset.yml @@ -0,0 +1,131 @@ +simulation: + sim_name: 'pleasant_lgr' + version: 'mf6' + sim_ws: 'pleasant_lgr/' + +model: + simulation: 'pleasant_lgr' + modelname: 'plsnt_lgr_inset' + options: + print_input: True + save_flows: True + newton: True + newton_under_relaxation: True + external_path: 'external/' + packages: ['dis', + 'ic', + 'npf', + 'oc', + 'sto', + 'rch', + 'sfr', + 'lak', + 'obs', + 'wel', + 'ims' + ] + +# parent model block is not needed as the pleasant_lgr_inset +# model is set up as an LGR in the context of the pleast_lgr_parent model + +# grid for LGR inset based on buffer distance around Pleasant Lake +setup_grid: + source_data: + features_shapefile: + filename: 'data/pleasant/source_data/shps/all_lakes.shp' + id_column: 'HYDROID' + include_ids: [600059060] # pleasant lake + dxy: 40 # grid spacing, in CRS units (meters) + buffer: 1000 # distance from feature(s) of interest to model boundary, in meters + epsg: 3070 # CRS (Wisconsin Transverse Mercator) + +dis: + options: + length_units: 'meters' + dimensions: + # nrow and ncol are based on the buffer distance and grid spacing + nlay: 5 + source_data: + top: + filename: 'data/pleasant/source_data/rasters/dem40m.tif' # DEM file; path relative to setup script + elevation_units: 'meters' + botm: + filenames: + 1: 'data/pleasant/source_data/rasters/botm0.tif' # preprocessed surface for parent model layer 0 bottom + 2: 'data/pleasant/source_data/rasters/botm1.tif' # preprocessed surface for parent model layer 1 bottom + 3: 'data/pleasant/source_data/rasters/botm2.tif' # preprocessed surface for parent model layer 2 bottom + +# Recharge and Well packages are inherited from the parent model +# (since this is an LGR model +# and the packages are specified in the packages: list) + +# Lake Package +lak: + options: + boundnames: True + save_flows: True + surfdep: 0.1 # undulations in lake bottom that affect GW discharge. Range in online instructions is 0.01-0.5. (Value from Trout Lake) + source_data: + # initial lakebed leakance rates + # for thin zone around lake perimeter + littoral_leakance: 0.045 # 1/d + # for interior of lake basin + profundal_leakance: 0.025 # 1/d + # polygon shapefile of lake footprints + littoral_zone_buffer_width: 40 + lakes_shapefile: + filename: 'data/pleasant/source_data/shps/all_lakes.shp' + id_column: 'HYDROID' + include_ids: [600059060] # pleasant lake + # setup lake precipitation and evaporation from PRISM data + climate: + filenames: + 600059060: 'data/pleasant/source_data/PRISM_ppt_tmean_stable_4km_189501_201901_43.9850_-89.5522.csv' + format: 'prism' + period_stats: + # for period 0, use average precip and evap for dates below + 0: ['mean', '2012-01-01', '2018-12-31'] # average daily rate for model period for initial steady state + # for subsequent periods, + # average precip and evap to period start/end dates + 1: 'mean' # average daily rate or value for each month + # bathymetry file with lake depths to subtract off model top + bathymetry_raster: + filename: 'data/pleasant/source_data/rasters/pleasant_bathymetry.tif' + length_units: 'meters' + # bathymetry file with stage/area/volume relationship + stage_area_volume_file: + filename: 'data/pleasant/source_data/tables/area_stage_vol_Pleasant.csv' + length_units: 'meters' + id_column: 'hydroid' + column_mappings: + volume_m3: 'volume' + external_files: False # option to write connectiondata table to external file + +sfr: + options: + save_flows: True + source_data: + flowlines: + nhdplus_paths: ['data/pleasant/source_data/shps'] + dem: + filename: 'data/pleasant/source_data/rasters/dem40m.tif' + elevation_units: 'meters' + sfrmaker_options: + set_streambed_top_elevations_from_dem: True + +obs: + # same observation data that were applied to pleasant_lgr_parent model + # any observations not within the LGR extent are culled + source_data: + filenames: [ + #'data/pleasant/source_data/tables/nwis_heads_info_file.csv', + 'data/pleasant/source_data/tables/lake_sites.csv', # some lakes are high-k; obs need to be in hydmod + 'data/pleasant/source_data/tables/wdnr_gw_sites.csv', + #'data/pleasant/source_data/tables/uwsp_heads.csv', + #'data/pleasant/source_data/tables/wgnhs_head_targets.csv' + ] + column_mappings: + obsname: ['obsprefix', 'common_name'] + mfsetup_options: + drop_observations: ['10019209_lk' # pleasant lake; monitored via gage package + ] diff --git a/mfsetup/tests/data/pleasant_vertical_lgr_parent.yml b/mfsetup/tests/data/pleasant_vertical_lgr_parent.yml new file mode 100644 index 00000000..e98514e8 --- /dev/null +++ b/mfsetup/tests/data/pleasant_vertical_lgr_parent.yml @@ -0,0 +1,238 @@ +# starting version number for the project (optional) +# version reported by modflow-setup will then be +# the start_version appended by the remaining information +# in a pep440-post style version tag +# (e.g. most recent git commit hash for the model repository +# + "dirty" if the model repository has uncommited changes) +# see https://github.com/warner/python-versioneer/blob/master/details.md +metadata: + start_version: 0.1 + longname: 'Pleasant Lake test case' + +# input for MODFLOW 6 simulation +simulation: + sim_name: 'pleasant_lgr' + version: 'mf6' + sim_ws: 'pleasant_lgr/' + +# input for MODFLOW 6 model +model: + simulation: 'pleasant_lgr' + modelname: 'plsnt_lgr_parent' + options: + print_input: True + save_flows: True + newton: True + newton_under_relaxation: True + # packages to build + # (any packages not listed or commented out will not be built, + # event if they have an input block below) + packages: ['dis', + 'ic', + 'npf', + 'oc', + 'sto', + 'rch', # Note: with no recharge block below and default_source_data=True, recharge is regridded from parent model + 'sfr', + 'lak', + 'obs', + 'wel', + 'ims', + 'chd' + ] + +# Regional model to extract boundary conditions, +# property arrays, and pumping data from +parent: + # argments to flopy.modflow.Modflow.load for parent model + namefile: 'pleasant.nam' + model_ws: 'data/pleasant/' + version: 'mfnwt' + # information for modflow-setup + # note: parent model is geo-located in namfile header + # (only works if length_units='meters') + #hiKlakes_value: 1.e4 # unfortunately python yaml currently requires a dot to parse exp notation as float + default_source_data: True # if True, packages and variables that are omitted will be pulled from this model + copy_stress_periods: 'all' + inset_layer_mapping: # mapping between inset and parent model layers + 0: 0 # inset: parent (inset layers 1 and 0 copied from parent layer 0) + 1: 0 + 2: 1 + 3: 2 + 4: 3 + 5: 3 + start_date_time: '2012-01-01' + length_units: 'meters' + time_units: 'days' + +# parameters for setting up the horizontal configuration of the grid +# in the context of a coordinate reference system +setup_grid: + #remake: True + xoff: 553000 # lower left x-coordinate + yoff: 388000 # lower left y-coordinate + rotation: 0. + dxy: 200 # in CRS units of meters + epsg: 3070 # CRS (Wisconsin Transverse Mercator) + # local-grid refinement area + # specified in another configuration file + # is set up in tandem and connected in the same MODFLOW 6 simulation + lgr: + pleasant_lgr_inset: + filename: 'pleasant_lgr_inset.yml' + # number of inset layers for each parent layer + # this can be an integer (vertically uniform refinement) + # a list (with an entry for each parent layer) + # or a dictionary (with entries for each parent layer that is refined; + # unlisted layers will default to zero) + # only a + layer_refinement: [1, 1, 1, 1, 1, 0] + +# Structured Discretization Package +dis: + options: + length_units: 'meters' + dimensions: + # if nrow and ncol are not specified here, the entries above in setup_grid are used + nlay: 6 + nrow: 25 + ncol: 25 + # griddata: + # delr and delc are developed from information above in setup_grid + # top and botm arrays are sampled from GeoTIFF files + # idomain is developed from layer pinch-outs and boundary condition locations + source_data: + top: + filename: 'data/pleasant/source_data/rasters/dem40m.tif' # DEM file; path relative to setup script + elevation_units: 'meters' + botm: + filenames: + 1: 'data/pleasant/source_data/rasters/botm0.tif' # preprocessed surface for parent model layer 0 bottom + 2: 'data/pleasant/source_data/rasters/botm1.tif' # preprocessed surface for parent model layer 1 bottom + 3: 'data/pleasant/source_data/rasters/botm2.tif' # preprocessed surface for parent model layer 2 bottom + 5: 'data/pleasant/source_data/rasters/botm3.tif' # preprocessed surface for parent model layer 3 bottom + +# Temporal Discretization Package +tdis: + options: + time_units: 'days' + start_date_time: '2012-01-01' + perioddata: + # time discretization info can be specified directly under the perioddata key + # or in groups of stress periods that are discretized in a similar way + group 1: # initial steady-state period (steady specified under sto package) + #perlen: 1 # Specify perlen as an int or list of lengths in model units, or perlen=None and 3 of start_date, end_date, nper and/or freq." + nper: 1 + nstp: 1 + tsmult: 1 + steady: True # "steady" can be entered here; otherwise the global entry specified in the sto package is used as the default + # oc_saverecord: can also be specified by group here; otherwise the global entry specified in the oc package is used as the default + group 2: # monthly stress periods + start_date_time: '2012-01-01' # can be specified by group, otherwise start_date_time for the model (under tdis: options) will be used. + end_date_time: '2013-01-01' # model ends at midnight on this date (2007-03-31 would be the last day simulated) + freq: '1MS' # same as argument to pandas.date_range; (see "Offset Aliases" at https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#timeseries-offset-aliases) + nstp: 1 + tsmult: 1.5 + steady: False + +# Initial Conditions Package +ic: + # starting heads sampled from parent model + source_data: + strt: + from_parent: + binaryfile: 'data/pleasant/pleasant.hds' + stress_period: 0 + +# Node Property Flow Package +npf: + options: + save_flows: True + griddata: + icelltype: 1 # variable sat. thickness in all layers + # with parent: default_source_data: True, + # unspecified variables such as "k" and "k33" are resampled from parent model + +# Storage Package +sto: + options: + save_flows: True + griddata: + iconvert: 1 # convertible layers + # with parent: default_source_data: True, + # unspecified variables such as "sy" and "ss" are resampled from parent model + + # Well Package +wel: + options: + print_input: True + print_flows: True + save_flows: True + # with parent: default_source_data: True, + # unspecified well fluxes are resampled from parent model + +# Streamflow Routing Package +# SFR input is created using SFRmaker +# https://github.com/usgs/sfrmaker +sfr: + options: + save_flows: True + source_data: + flowlines: + # path to NHDPlus version 2 dataset + nhdplus_paths: ['data/pleasant/source_data/shps'] + # if a DEM is included, streambed top elevations will be sampled + # from the minimum DEM values within a 100 meter buffer around each stream reach + dem: + filename: 'data/pleasant/source_data/rasters/dem40m.tif' + elevation_units: 'meters' + # SFR observations can be automatically setup from a CSV file + # of x, y locations and fluxes + observations: # see sfrmaker.observations.add_observations for arguments + filename: 'data/pleasant/source_data/tables/gages.csv' + obstype: 'downstream-flow' # modflow-6 observation type + x_location_column: 'x' + y_location_column: 'y' + obsname_column: 'site_no' + sfrmaker_options: + # the sfrmaker_options: block can include arguments to the Lines.to_sfr method in SFRmaker + # (see https://doi-usgs.github.io/sfrmaker/api/sfrmaker.lines.html#sfrmaker.lines.Lines.to_sfr) + # or other options such as set_streambed_top_elevations_from_dem (see pleasant examples) + # or to_riv (shellmound_tmr example) + set_streambed_top_elevations_from_dem: True + +# Iterative model solution +ims: + options: + complexity: 'moderate' + nonlinear: + outer_dvclose: 1.e-2 + outer_maximum: 200 + linear: + inner_maximum: 100 + inner_dvclose: 1.e-4 + rcloserecord: [0.0001, 'relative_rclose'] + +# Observation (OBS) Utility +obs: + source_data: + # Head observations are supplied via csv files with x, y locations and observation names + # an observation is generated in each model layer; + # observations at each location can subsequently be processed + # to represent a given screened interval + # for example, using modflow-obs (https://github.com/aleaf/modflow-obs) + filenames: ['data/pleasant/source_data/tables/nwis_heads_info_file.csv', + 'data/pleasant/source_data/tables/lake_sites.csv', # some lakes are high-k; obs need to be in hydmod + 'data/pleasant/source_data/tables/wdnr_gw_sites.csv', + 'data/pleasant/source_data/tables/uwsp_heads.csv', + 'data/pleasant/source_data/tables/wgnhs_head_targets.csv' + ] + column_mappings: + obsname: ['obsprefix', 'obsnme', 'common_name'] + mfsetup_options: + drop_observations: ['10019209_lk' # pleasant lake; monitored via Lake Package observations + ] + +chd: + perimeter_boundary: + parent_head_file: 'data/pleasant/pleasant.hds' # needed for the perimeter boundary setup From e00b587dadc89cac3bd40eeebab0f1d9a01ededf Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Sat, 3 Aug 2024 09:46:39 -0500 Subject: [PATCH 4/5] feat(wells.py::setup_wel_data): add layer assignment from screen top/botm to wells: dictionary input option to facilitate easier testing. LGR parent models, remove wells with >50% of their open interval within the LGR child area; LGR child models, remove wells with <50% of their open interval within the LGR child area. This ensures that pumping wells aren't included twice in a partial vertical LGR case (due to the automated well rellocation routines). Add any dropped wells to dropped_wells_file. --- mfsetup/wells.py | 53 ++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 45 insertions(+), 8 deletions(-) diff --git a/mfsetup/wells.py b/mfsetup/wells.py index 94aa1209..5be780bb 100644 --- a/mfsetup/wells.py +++ b/mfsetup/wells.py @@ -128,6 +128,15 @@ def setup_wel_data(model, source_data=None, #for_external_files=True, aw['x'].values, aw['y'].values) aw['per'] = aw['per'].astype(int) + if 'k' not in aw.columns: + if model.nlay > 1: + vfd = vfd_defaults.copy() + vfd.update(v.get('vertical_flux_distribution', {})) + aw = assign_layers_from_screen_top_botm(aw, + model, + **vfd) + else: + aw['k'] = 0 aw['k'] = aw['k'].astype(int) df = pd.concat([df, aw], axis=0) @@ -401,8 +410,35 @@ def assign_layers_from_screen_top_botm(data, model, inactive = idomain[data.k, data.i, data.j] < 1 invalid_open_interval = (data['laythick'] < minimum_layer_thickness) | inactive + outfile = model.cfg['wel']['output_files']['dropped_wells_file'].format(model.name) + bad_wells = pd.DataFrame() + # for LGR parent models, remove wells with >50% of their open interval within the LGR area + # (these should be represented in the LGR child model) + if model.lgr: + data['model_top'] = model.dis.top.array[data['i'], data['j']] + data['frac_in_model'] = (data['model_top'] - data['screen_botm'])/\ + (data['screen_top'] - data['screen_botm']) + in_model = data['frac_in_model'] > 0.5 + bad_wells = pd.concat([bad_wells, data.loc[~in_model].copy()]) + bad_wells['category'] = 'dropped' + bad_wells['reason'] =\ + ">50%% of well in LGR area (should be represented in LGR child model)" + data = data.loc[in_model].copy() + # for LGR child models, remove wells with <50% of their open interval within the LGR area + if model._is_lgr: + data['model_botm'] = model.dis.botm.array[-1, data['i'], data['j']] + data['frac_in_model'] = (data['screen_top'] - data['model_botm'])/\ + (data['screen_top'] - data['screen_botm']) + in_model = data['frac_in_model'] > 0.5 + bad_wells = pd.concat([bad_wells, data.loc[~in_model].copy()]) + bad_wells['category'] = 'dropped' + bad_wells['reason'] = ( + ">50%% of well below LGR area (should be represented in " + "underlying parent model, or model bottom and open interval " + "should be checked)." + ) + data = data.loc[in_model].copy() if any(invalid_open_interval): - outfile = model.cfg['wel']['output_files']['dropped_wells_file'].format(model.name) # move wells that are still in a thin layer to the thickest active layer data['orig_layer'] = data['k'] @@ -422,22 +458,21 @@ def assign_layers_from_screen_top_botm(data, model, data['idomain'] = idomain[data['k'], i, j] # record which wells were moved or dropped, and why - bad_wells = data.loc[invalid_open_interval].copy() - bad_wells['category'] = 'moved' - bad_wells['reason'] = (f'longest open interval thickness < {minimum_layer_thickness} ' + wells_in_too_thin_layers = data.loc[invalid_open_interval].copy() + wells_in_too_thin_layers['category'] = 'moved' + wells_in_too_thin_layers['reason'] = (f'longest open interval thickness < {minimum_layer_thickness} ' f'{model.length_units} minimum ' 'or open interval placed well in inactive layer.' ) - bad_wells['routine'] = __name__ + '.assign_layers_from_screen_top_botm' msg = ('Warning: {} of {} wells in layers less than ' 'specified minimum thickness of {} {}\n' 'were moved to the thickest layer at their i, j locations.\n'.format(invalid_open_interval.sum(), len(data), minimum_layer_thickness, model.length_units)) - still_below_minimum = bad_wells['laythick'] < minimum_layer_thickness - bad_wells.loc[still_below_minimum, 'category'] = 'dropped' - bad_wells.loc[still_below_minimum, 'reason'] = 'no layer above minimum thickness of {} {}'.format(minimum_layer_thickness, + still_below_minimum = wells_in_too_thin_layers['laythick'] < minimum_layer_thickness + wells_in_too_thin_layers.loc[still_below_minimum, 'category'] = 'dropped' + wells_in_too_thin_layers.loc[still_below_minimum, 'reason'] = 'no layer above minimum thickness of {} {}'.format(minimum_layer_thickness, model.length_units) n_below = np.sum(still_below_minimum) if n_below > 0: @@ -455,6 +490,8 @@ def assign_layers_from_screen_top_botm(data, model, print(msg) # write shapefile and CSV output for wells that were dropped + bad_wells = pd.concat([bad_wells, data.loc[invalid_open_interval].copy()]) + bad_wells['routine'] = __name__ + '.assign_layers_from_screen_top_botm' cols = ['k', 'i', 'j', 'boundname', 'category', 'laythick', 'idomain', 'reason', 'routine', 'x', 'y'] cols = [c for c in cols if c in bad_wells.columns] From 0ed7ef6b3ffd5ab940fc47a3073c8783be40b569 Mon Sep 17 00:00:00 2001 From: "Leaf, Andrew T" Date: Sat, 3 Aug 2024 12:22:04 -0500 Subject: [PATCH 5/5] feat: partial LGR in the vertical direction (child model nested in a subset of parent layers). * replace parent_start/end layer configuration input with "vertical_refinement" in each parent layer (int, list or dict), which gets translated to ncppl input to the Flopy Lgr utility * add some additional checks/error traps for invalid refinement input * ensure that child model bottom and parent model top are aligned (no overlap or gaps in numerical grid) * on setup of the Lgr grid, the parent model cell tops/bottoms are collapsed to zero thickness within the child model area(s) (parent model top is also set to child model bottom(s) in the child model area(s)); because of this, some additional logic is needed to disable the "original model top" functionality that is used in the context of the lake package to ensure that supplied bathymetry is always subtracted from the original top (the land surface) in the context of repeated model setups. A better fix would be to ensure that this functionality is only active when the Lake Package is being built. * prevent recharge, SFR and non-Well basic stress boundary conditions from being populated in any parts of the parent model below a child model (assuming that these represent surface or near-surface features that should be represented only in the child model) * wells with > 50% of their open interval within the child model domain get assigned to the child model * wells with > 50% of their open interval in the parent model get assigned to the parent model * added some additional functionality to allow the child model bottom to coincide with a sub-divided parent model bottom (between two supplied raster surfaces) * added some additional testing for LGR grid setup and boundary condition handling for models with partial vertical LGR. --- docs/source/concepts/lgr.rst | 72 +++++- examples/Pleasant_lake_lgr_example.ipynb | 29 ++- examples/pleasant_lgr_inset.yml | 2 +- examples/pleasant_lgr_parent.yml | 9 +- mfsetup/bcs.py | 1 - mfsetup/mf6model.py | 111 ++++++-- mfsetup/mfmodel.py | 14 +- mfsetup/obs.py | 25 ++ mfsetup/sourcedata.py | 125 ++++++--- .../data/pleasant_vertical_lgr_inset.yml | 45 ++-- .../data/pleasant_vertical_lgr_parent.yml | 55 ++-- mfsetup/tests/test_lgr.py | 241 ++++++++++++++++-- mfsetup/tests/test_mf6_shellmound.py | 13 +- mfsetup/wells.py | 62 ++--- 14 files changed, 624 insertions(+), 180 deletions(-) diff --git a/docs/source/concepts/lgr.rst b/docs/source/concepts/lgr.rst index 13d81f57..bee938cc 100644 --- a/docs/source/concepts/lgr.rst +++ b/docs/source/concepts/lgr.rst @@ -2,18 +2,28 @@ Local grid refinement =========================================================== -In MODFLOW 6, two groundwater models can be tightly coupled in the same simulation, which allows for efficient "local grid refinement" (LGR; Mehl and others, 2006) and "semistructured" (Feinstein and others, 2016) configurations that combine multiple structured model layers at different resolutions (Langevin and others, 2017). Locally refined area(s) are conceptualized as separate model(s) that are linked to the surrounding (usually coarser) "parent" model through the GWF Model Exchange Package. Similarly, "semistructured" configurations are represented by multiple linked models for each layer or group of layers with the same resolution. +In MODFLOW 6, two groundwater models can be tightly coupled in the same simulation, which allows for efficient "local grid refinement" (LGR; Mehl and others, 2006) and "semistructured" (Feinstein and others, 2016) configurations that combine multiple structured model layers at different resolutions (Langevin and others, 2017). Locally refined areas are conceptualized as separate "child" models that are linked to the surrounding (usually coarser) "parent" model through the GWF Model Exchange (GWFGWF) Package. Similarly, "semistructured" configurations are represented by multiple linked models for each layer or group of layers with the same resolution. -Modflow-setup supports this functionality via an ``lgr:`` subblock within the ``setup_grid:`` block of the configuration file. The ``lgr:`` subblock consists of one of more subblocks, each keyed by a linked model name and containing configuration input for that linked model. Vertical layer refinement relative to the "parent" model, and the range of parent model layers that will be occupied by the linked "inset" model are also specified. +Modflow-setup supports local grid refinment via an ``lgr:`` subblock within the ``setup_grid:`` block of the configuration file. The ``lgr:`` subblock consists of one of more subblocks, each keyed by a linked model name and containing configuration input for that linked model. Vertical layer refinement relative to the "parent" model is also specified for each layer of the parent model. -For example, the following "parent" configuration for the :ref:`Pleasant Lake Example ` creates a local refinement model named "``pleasant_lgr_inset``" that spans layers 0 through 3 (the first 4 layers) of the parent model, at the same vertical resolution (1 inset model layer per parent model layer). The horizontal location and resolution of the inset model are specified in the inset model configuration file, in the same way that they are specified for any model. +For example, the following "parent" configuration for the :ref:`Pleasant Lake Example ` creates a local refinement model named "``pleasant_lgr_inset``" that spans all layers of the parent model, at the same vertical resolution (1 inset model layer per parent model layer). .. literalinclude:: ../../../examples/pleasant_lgr_parent.yml :language: yaml :start-at: lgr: :end-before: # Structured Discretization Package -Input from the ``lgr:`` subblock and the inset model configuration file(s) is passed to the :py:class:`Flopy Lgr Utility `, which helps create input for the GWF Model Exchange Package. +The horizontal location and resolution of the inset model are specified in the :ref:`inset model configuration file `, in the same way that they are specified for any model. In this example, the parent model has a uniform horizontal resolution of 200 meters, and the inset a uniform resolution of 40 meters (a horizontal refinement of 5 inset model cells per parent model cells). The inset model resolution must be a factor of the parent model resolution. + +.. image:: ../_static/pleasant_lgr.png + :width: 1200 + :alt: Example of LGR refinement in all layers. + +.. image:: ../_static/pleasant_lgr_xsection.png + :width: 1200 + :alt: Example of LGR refinement in all layers. + +Input from the ``lgr:`` subblock and the inset model configuration file(s) is passed to the :py:class:`Flopy Lgr Utility `, which helps create input for the GWF Model Exchange Package. Within the context of a Python session, inset model information is stored in a dictionary under an ``inset`` attribute attached to the parent model. For example, to access a Flopy model object for the above inset model from a parent model named ``model``: @@ -22,10 +32,58 @@ Within the context of a Python session, inset model information is stored in a d inset_model = model.inset['pleasant_lgr_inset'] + + +Specification of vertical refinement +----------------------------------------- +Vertical refinement in the LGR child grid is specified in the ``layer_refinement:`` item, as the number of child layers in each parent model layer. Currently vertical refinement is limited to even subdivision of parent model layers. Vertical refinement can be specified as an integer for uniform refinement across all parent model layers: + +.. code-block:: yaml + + layer_refinement: 1 + +a list with an entry for each parent layer: + +.. code-block:: yaml + + layer_refinement: [1, 1, 1, 0, 0] + +or a dictionary with entries for each parent layer that is refined: + +.. code-block:: yaml + + layer_refinement: + 0:1 + 1:1 + 2:1 + +Parent model layers with 0 specified refinement are excluded from the child model. The list and dictionary inputs above are equivalent, as unlisted layers in the dictionary are assigned default refinement values of 0. Refinement values > 1 result in even subdivision of the parent layers. Similar to one-way coupled inset models, LGR child model layers surfaces can be discretized at the finer child resolution from the original source data. In the example below, a 9-layer child model is set within the top 4 layers of a 5 layer parent model. The parent model ``lgr:`` configuration block is specified as: + +.. literalinclude:: ../../../mfsetup/tests/data/pleasant_vertical_lgr_parent.yml + :language: yaml + :start-at: lgr: + :end-before: # Structured Discretization Package + +In the child model ``dis:`` configuration block, raster surfaces that were used to define the parent model layer bottoms are specified at their respective desired locations within the child model grid; Modflow-setup then subdivides these to create the desired layer configuration. The layer specification in the child model ``dis:`` block must be consistent with the `layer_refinement:` input in the parent model configuration (see below). The image below shows + +.. literalinclude:: ../../../mfsetup/tests/data/pleasant_vertical_lgr_inset.yml + :language: yaml + :start-at: dis: + :end-before: # Recharge and Well packages are inherited + +The figure below shows a cross section through the model grid resulting from this configuration: + +.. image:: ../_static/pleasant_vlgr_xsection.png + :width: 1500 + :alt: Example of partial vertical LGR refinement with layer subdivision. + + **A few notes about LGR functionality in Modflow-setup** * **Locally refined "inset" models must be aligned with the parent model grid**, which also means that their horizontal resolution must be a factor of the "parent" model resolution. Modflow-setup handles the alignment automatically by "snapping" inset model grids to the lower left corner of the parent cell containing the lower left corner of the inset model grid (the inset model origin in real-world coordinates). -* Similarly, inset models need to align vertically with the parent model layers. Parent layers can be subdivided using the ``layer_refinement:`` input option. -* In principal, a **semistructured** configuration consisting of a "parent" model at the coarsest horizontal resolution, and one or more inset models representing [horizontally and potentially vertically] refined layers within the "parent" model domain is possible, but this configuration has not been tested with Modflow-setup. Please contact the Modflow-setup development team by posting a `GitHub issue `_ if you are interested in this. -* Similarly, multiple inset models at different horizontal locations, and even inset models within inset models should be achievable, but have not been tested. +* Similarly, inset models need to align vertically with the parent model layers. Parent layers can be subdivided using values > 1 in the ``layer_refinement:`` input option. +* Specifically, **the layer specification in the child model** ``dis:`` **block must be consistent with the** ``layer_refinement:`` **input in the parent model configuration**. For example, if a ``layer_refinement`` of ``3`` is specified for the last parent layer included in the child model domain, then the last two raster surfaces specified in the child model ``dis``: block must be specified with two layer bottoms in between. Similarly, the values in ``layer_refinement:`` in the parent model configuration must sum to ``nlay:`` specified in the child model ``dis:`` configuration block. +* Regardless of the supplied input, the child model bottom and parent model tops are aligned to remove any vertical gaps or overlap in the numerical model grid. If a raster surface is supplied for the child model bottom, the child bottom/parent top surface is based on the mean bottom elevations sampled to the child cells within each parent cell area. +* Child model ``layer_refinement:`` must start at the top of the parent model, and include a contiguous sequence of parent model layers. +* Multiple inset models at different horizontal locations, and even inset models within inset models should be achievable, but have not been tested. * **Multi-model configurations come with costs.** Each model within a MODFLOW 6 simulation carries its own set of files, including external text array and list input files to packages. As with a single model, when using the automated parameterization functionality in `pyEMU `_, the number of files is multiplied. At some point, at may be more efficient to work with individual models, and design the grids in such a way that boundary conditions along the model perimeters have a minimal impact on the predictions of interest. diff --git a/examples/Pleasant_lake_lgr_example.ipynb b/examples/Pleasant_lake_lgr_example.ipynb index 1a4b5760..8056d36c 100644 --- a/examples/Pleasant_lake_lgr_example.ipynb +++ b/examples/Pleasant_lake_lgr_example.ipynb @@ -277,6 +277,33 @@ "plt.colorbar(qmi)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Make a cross section of the grid" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(14, 5))\n", + "xs_line = [(553000, 390200), (558000, 390200)]\n", + "xs = flopy.plot.PlotCrossSection(model=m,\n", + " line={\"line\": xs_line}, ax=ax,\n", + " geographic_coords=True)\n", + "lc = xs.plot_grid(zorder=4)\n", + "xs2 = flopy.plot.PlotCrossSection(model=inset,\n", + " line={\"line\": xs_line}, ax=ax,\n", + " geographic_coords=True)\n", + "lc = xs2.plot_grid(zorder=4)\n", + "ax.set_ylim(190, 400)\n", + "plt.savefig('../../docs/source/_static/pleasant_lgr_xsection.png', bbox_inches='tight')" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -528,7 +555,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.2" + "version": "3.10.14" } }, "nbformat": 4, diff --git a/examples/pleasant_lgr_inset.yml b/examples/pleasant_lgr_inset.yml index 51ff9abc..ab163592 100644 --- a/examples/pleasant_lgr_inset.yml +++ b/examples/pleasant_lgr_inset.yml @@ -44,7 +44,7 @@ dis: length_units: 'meters' dimensions: # nrow and ncol are based on the buffer distance and grid spacing - nlay: 4 + nlay: 5 source_data: top: filename: 'data/pleasant/source_data/rasters/dem40m.tif' # DEM file; path relative to setup script diff --git a/examples/pleasant_lgr_parent.yml b/examples/pleasant_lgr_parent.yml index 70d8c719..a3df95b6 100644 --- a/examples/pleasant_lgr_parent.yml +++ b/examples/pleasant_lgr_parent.yml @@ -79,9 +79,12 @@ setup_grid: lgr: pleasant_lgr_inset: filename: 'pleasant_lgr_inset.yml' - layer_refinement: 1 # number of lgr model layers per parent model layer - parent_start_layer: 0 # uppermost parent model layer to include in lgr - parent_end_layer: 3 # lowermost parent model layer to include in lgr + # number of inset layers for each parent layer + # this can be an integer (vertically uniform refinement) + # a list (with an entry for each parent layer) + # or a dictionary (with entries for each parent layer that is refined; + # unlisted layers will default to zero) + layer_refinement: [1, 1, 1, 1, 1] # number of lgr model layers per parent model layer # Structured Discretization Package dis: diff --git a/mfsetup/bcs.py b/mfsetup/bcs.py index 680b7ec1..7869c2a8 100644 --- a/mfsetup/bcs.py +++ b/mfsetup/bcs.py @@ -394,7 +394,6 @@ def remove_inactive_bcs(pckg, external_files=False): Parameters ---------- - model : flopy model instance pckg : flopy package instance """ model = pckg.parent diff --git a/mfsetup/mf6model.py b/mfsetup/mf6model.py index 058ce76f..11edd56e 100644 --- a/mfsetup/mf6model.py +++ b/mfsetup/mf6model.py @@ -2,6 +2,7 @@ import os import shutil import time +from pathlib import Path import flopy import numpy as np @@ -36,7 +37,7 @@ ) from mfsetup.mfmodel import MFsetupMixin from mfsetup.mover import get_mover_sfr_package_input -from mfsetup.obs import setup_head_observations +from mfsetup.obs import remove_inactive_obs, setup_head_observations from mfsetup.oc import parse_oc_period_input from mfsetup.tdis import add_date_comments_to_tdis, setup_perioddata from mfsetup.units import convert_time_units @@ -200,6 +201,7 @@ def _set_idomain(self): if isinstance(self.lgr, dict): for k, v in self.lgr.items(): lgr_idomain[v.idomain == 0] = 0 + self._lgr_idomain2d = lgr_idomain[0] idomain_from_layer_elevations = make_idomain(self.dis.top.array, self.dis.botm.array, nodata=self._nodata_value, @@ -379,28 +381,55 @@ def create_lgr_models(self): parent_start_layer = v.get('parent_start_layer', 0) # parent_end_layer is specified as the last zero-based # parent layer that includes LGR refinement (not as a slice end) - parent_end_layer = v.get('parent_end_layer', self.nlay - 1) + 1 - ncppl = v.get('layer_refinement', 1) - specified_nlay_lgr = ncppl * (parent_end_layer - parent_start_layer) - specified_nlay_dis = inset_cfg['dis']['dimensions']['nlay'] - if specified_nlay_lgr != specified_nlay_dis: + parent_end_layer = v.get('parent_end_layer', self.nlay - 1) + # the layer refinement can be specified as an int, a list or a dict + ncppl_input = v.get('layer_refinement', 1) + if np.isscalar(ncppl_input): + ncppl = np.array([0] * self.modelgrid.nlay) + ncppl[parent_start_layer:parent_end_layer+1] = ncppl_input + elif isinstance(ncppl_input, list): + if not len(ncppl_input) == self.modelgrid.nlay: + raise ValueError( + "Configuration input: layer_refinement specified as" + "a list must include a value for every layer." + ) + ncppl = ncppl_input.copy() + elif isinstance(ncppl_input, dict): + ncppl = [ncppl_input.get(i, 0) for i in range(self.modelgrid.nlay)] + else: + raise ValueError("Configuration input: Unsupported input for " + "layer_refinement: supply an int, list or dict.") + + # refined layers must be consecutive, starting from layer 1 + is_refined = (np.array(ncppl) > 0).astype(int) + last_refined_layer = max(np.where(is_refined > 0)[0]) + consecutive = all(np.diff(is_refined)[:last_refined_layer] == 0) + if (is_refined[0] != 1) | (not consecutive): + raise ValueError("Configuration input: layer_refinement must" + "include consecutive sequence of layers, " + "starting with the top layer.") + # check the specified DIS package input is consistent + # with the specified layer_refinement + specified_nlay_dis = inset_cfg['dis']['dimensions'].get('nlay') + # skip this check if nlay hasn't been entered into the configuration file yet + if specified_nlay_dis and (np.sum(ncppl) != specified_nlay_dis): raise ValueError( - f"Parent model layers of {parent_start_layer} to {parent_end_layer} " - f"and layer refinement of {ncppl} implies {specified_nlay_lgr} inset model layers.\n" + f"Configuration input: layer_refinement of {ncppl} " + f"implies {is_refined.sum()} inset model layers.\n" f"{specified_nlay_dis} inset model layers specified in DIS package.") # mapping between parent and inset model layers # that is used for copying input from parent model - parent_inset_layer_mapping = dict() + inset_parent_layer_mapping = dict() inset_k = -1 - for parent_k in range(parent_start_layer, parent_end_layer): - for i in range(ncppl): + for parent_k, n_inset_lay in enumerate(ncppl): + for i in range(n_inset_lay): inset_k += 1 - parent_inset_layer_mapping[parent_k] = inset_k + inset_parent_layer_mapping[inset_k] = parent_k self.inset[inset_model.name].cfg['parent']['inset_layer_mapping'] =\ - parent_inset_layer_mapping + inset_parent_layer_mapping # create idomain indicating area of parent grid that is LGR lgr_idomain = make_lgr_idomain(self.modelgrid, self.inset[inset_model.name].modelgrid, - parent_start_layer, parent_end_layer) + ncppl) # inset model horizontal refinement from parent resolution refinement = self.modelgrid.delr[0] / self.inset[inset_model.name].modelgrid.delr[0] @@ -412,10 +441,55 @@ def create_lgr_models(self): self.dis.top.array, self.dis.botm.array, lgr_idomain, ncpp, ncppl) inset_model._perioddata = self.perioddata - self._set_idomain() + # set parent model top in LGR area to bottom of LGR area + # this is an initial draft; + # bottom elevations are readjusted in sourcedata.py + # when inset model DIS package botm array is set up + # (set to mean of inset model bottom elevations + # within each parent cell) + # number of layers in parent model with LGR + n_parent_lgr_layers = np.sum(np.array(ncppl) > 0) + lgr_area = self.lgr[inset_model.name].idomain == 0 + self.dis.top[lgr_area[0]] =\ + self.lgr[inset_model.name].botmp[n_parent_lgr_layers -1][lgr_area[0]] + # set parent model layers in LGR area to zero-thickness + new_parent_botm = self.dis.botm.array.copy() + for k in range(n_parent_lgr_layers): + new_parent_botm[k][lgr_area[0]] = self.dis.top[lgr_area[0]] + self.dis.botm = new_parent_botm + self._update_top_botm_external_files() + + + def _update_top_botm_external_files(self): + """Update the external files after assigning new elevations to the + Discretization Package top and botm arrays; adjust idomain as needed.""" + # reset the model top + # (this step may not be needed if the "original top" functionality + # is limited to cases where there is a lake package, + # or if the "original top"/"lake bathymetry" functionality is eliminated + # and we instead require the top to be pre-processed) + original_top_file = Path(self.external_path, + f"{self.name}_{self.cfg['dis']['top_filename_fmt']}.original") + original_top_file.unlink(missing_ok=True) + self._setup_array('dis', 'top', + data={0: self.dis.top.array}, + datatype='array2d', resample_method='linear', + write_fmt='%.2f', dtype=float) + # _set_idomain() regerates external files for bottom array + self._set_idomain() + def setup_lgr_exchanges(self): for inset_name, inset_model in self.inset.items(): + + # update cell information for computing any bottom exchanges + self.lgr[inset_name].top = inset_model.dis.top.array + self.lgr[inset_name].botm = inset_model.dis.botm.array + # update only the layers of the parent model below the child model + parent_top_below_child = np.sum(self.lgr[inset_name].ncppl > 0) -1 + self.lgr[inset_name].botmp[parent_top_below_child:] =\ + self.dis.botm.array[parent_top_below_child:] + # get the exchange data exchangelist = self.lgr[inset_name].get_exchange_data(angldegx=True, cdist=True) @@ -426,7 +500,9 @@ def setup_lgr_exchanges(self): # unpack the cellids and get their respective ibound values k1, i1, j1 = zip(*exchangedf['cellidm1']) k2, i2, j2 = zip(*exchangedf['cellidm2']) + # limit connections to active1 = self.idomain[k1, i1, j1] >= 1 + active2 = inset_model.idomain[k2, i2, j2] >= 1 # screen out connections involving an inactive cell @@ -454,6 +530,7 @@ def setup_lgr_exchanges(self): kwargs = get_input_arguments(kwargs, mf6.ModflowGwfgwf) gwfe = mf6.ModflowGwfgwf(self.simulation, **kwargs) + def setup_dis(self, **kwargs): """""" package = 'dis' @@ -624,7 +701,6 @@ def setup_rch(self, **kwargs): resample_method='nearest', write_fmt='%.6e', write_nodata=0.) - kwargs = self.cfg[package].copy() kwargs.update(self.cfg[package]['options']) kwargs = get_input_arguments(kwargs, mf6.ModflowGwfrcha) @@ -901,6 +977,9 @@ def write_input(self): external_files = self.cfg[pckg.lower()]['stress_period_data'] remove_inactive_bcs(package_instance, external_files=external_files) + if hasattr(self, 'obs'): + for obs_package_instance in self.obs: + remove_inactive_obs(obs_package_instance) # write the model with flopy # but skip the sfr package diff --git a/mfsetup/mfmodel.py b/mfsetup/mfmodel.py index 1b7e030c..3829c88d 100644 --- a/mfsetup/mfmodel.py +++ b/mfsetup/mfmodel.py @@ -120,6 +120,7 @@ def __init__(self, parent): self.inset = None # dictionary of inset models attached to LGR parent self._is_lgr = False # flag for lgr inset models self.lgr = None # holds flopy Lgr utility object + self._lgr_idomain2d = None # array of Lgr inset model locations within parent grid self.tmr = None # holds TMR class instance for TMR-type perimeter boundaries self._load = False # whether model is being made or loaded from existing files self.lake_info = None @@ -1301,12 +1302,13 @@ def _setup_basic_stress_package(self, package, flopy_package_class, if 'source_data' in kwargs: if package == 'wel': dropped_wells_file =\ - kwargs['output_files']['dropped_wells_file'].format(self.name) + kwargs.get('output_files', {})\ + .get('dropped_wells_file', '{}_dropped_wells.csv').format(self.name) df_sd = setup_wel_data(self, source_data=kwargs['source_data'], dropped_wells_file=dropped_wells_file) else: - df_sd = setup_basic_stress_data(self, **kwargs['source_data'], **kwargs['mfsetup_options']) + df_sd = setup_basic_stress_data(self, **kwargs['source_data'], **kwargs.get('mfsetup_options', dict())) if df_sd is not None and len(df_sd) > 0: dfs.append(df_sd) # set up package from parent model @@ -1514,7 +1516,13 @@ def setup_sfr(self, **kwargs): # create isfr array (where SFR cells will be populated) if self.version == 'mf6': active_cells = np.sum(self.idomain >= 1, axis=0) > 0 - #active_cells = self.idomain.sum(axis=0) > 0 + # For models with LGR, set the LGR area to isfr=0 + # to prevent SFR from being generated within the LGR area + # needed for LGR models that only have refinement + # in some layers (in other words, active parent model cells + # below the LGR inset) + if self.lgr: + active_cells[self._lgr_idomain2d == 0] = 0 else: active_cells = np.sum(self.ibound >= 1, axis=0) > 0 #active_cells = self.ibound.sum(axis=0) > 0 diff --git a/mfsetup/obs.py b/mfsetup/obs.py index 6868cf5b..605298e9 100644 --- a/mfsetup/obs.py +++ b/mfsetup/obs.py @@ -208,3 +208,28 @@ def make_obsname(name, unique_names={}, if name[slc] not in unique_names: return name[slc] return name[-maxlen:] + + +def remove_inactive_obs(obs_package_instance): + """Remove boundary conditions from cells that are inactive. + + Parameters + ---------- + obs_package_instance : flopy Modflow-6 Observation package instance + """ + model = obs_package_instance.parent + idomain = model.dis.idomain.array + if model.version != 'mf6': + raise NotImplementedError( + "obs.py::remove_inactive_obs(): " + "Support for removing MODFLOW 2005 not implemented.") + for obsfile, recarray in obs_package_instance.continuous.data.items(): + try: + k, i, j = zip(*recarray['id']) + except: + # for now, only support obs defined by k, i, j cellids + return + # cull any observations in inactive cells + is_active = idomain[k, i, j] > 0 + # update the flopy dataset + obs_package_instance.continuous.set_data({obsfile: recarray[is_active]}) diff --git a/mfsetup/sourcedata.py b/mfsetup/sourcedata.py index 05b268d1..09857608 100644 --- a/mfsetup/sourcedata.py +++ b/mfsetup/sourcedata.py @@ -502,7 +502,10 @@ def get_data(self): weight0=weight0) # repeat last layer if length of data is less than number of layers - if self.datatype == 'array3d' and i < (self.dest_model.nlay - 1): + # we probably don't want to do this for layer bottoms, + # but may want to for aquifer properties + if (self.variable != 'botm') and (self.datatype == 'array3d')\ + and (i < (self.dest_model.nlay - 1)): for j in range(i, self.dest_model.nlay): data[j] = data[i] @@ -1425,28 +1428,18 @@ def setup_array(model, package, var, data=None, model.cfg['dis']['top_filename_fmt']) top = model.load_array(model.cfg['dis']['griddata']['top'][0]['filename']) - # special case of LGR models - # with bottom connections to underlying parent cells - if model.version == 'mf6': - # (if model is an lgr inset model) - if model._is_lgr: - # regardless of what is specified for inset model bottom - # use top elevations of underlying parent model cells - nlay = model.cfg['dis']['dimensions']['nlay'] - if (nlay < model.parent.modelgrid.nlay): - # use the parent model bottoms - # mapped to the inset model grid by the Flopy Lgr util - lgr = model.parent.lgr[model.name] # Flopy Lgr inst. - data[nlay-1] = lgr.botm[nlay-1] - # set parent model top to top of - # first active parent model layer below this lgr domain - kp = lgr.get_parent_indices(nlay-1, 0, 0)[0] - model.parent.dis.top = lgr.botmp[kp] - j=2 - # fill missing layers if any if len(data) < model.nlay: all_surfaces = np.zeros((model.nlay + 1, model.nrow, model.ncol), dtype=float) * np.nan + # for LGR models, populate any missing bottom layer(s) + # from the refined parent grid + # this allows for the LGR model to be + # bounded on the bottom by a sub-divided parent layer surface + last_specified_layer = max(data.keys()) + if model._is_lgr and last_specified_layer < (model.nlay - 1): + #for k in range(last_specified_layer + 1, model.nlay): + # all_surfaces[k+1:] = model.parent.lgr[model.name].botm[k] + all_surfaces[model.nlay] = model.parent.lgr[model.name].botm[model.nlay -1] all_surfaces[0] = top for k, botm in data.items(): all_surfaces[k + 1] = botm @@ -1476,8 +1469,8 @@ def setup_array(model, package, var, data=None, # (so they won't get expanded again by fix_model_layer_conflicts) # only do this for mf6, where pinched out cells are allowed min_thickness = model.cfg['dis'].get('minimum_layer_thickness', 1) -# if model.version == 'mf6': -# botm[botm >= (top - min_thickness)] = np.nan + if model.version == 'mf6': + botm[botm >= (top - min_thickness)] = np.nan #for k, kbotm in enumerate(botm): # inlayer = lake_botm_elevations > kbotm[bathy != 0] @@ -1512,26 +1505,74 @@ def setup_array(model, package, var, data=None, else: model.dis.top = model.cfg['dis']['top'][0] data = {i: arr for i, arr in enumerate(botm)} - elif var in ['rech', 'recharge'] and simulate_high_k_lakes: - for per in range(model.nper): - if per == 0 and per not in data: - raise KeyError("No recharge input specified for first stress period.") - if per in data: - # assign high-k lake recharge for stress period - # only assign if precip and open water evaporation data were read - # (otherwise keep original values in recharge array) - last_data_array = data[per].copy() - if model.high_k_lake_recharge is not None: - data[per][model.isbc[0] == 2] = model.high_k_lake_recharge[per] - # zero-values to lak package lakes - data[per][model.isbc[0] == 1] = 0. - else: - if model.high_k_lake_recharge is not None: - # start with the last period with recharge data; update the high-k lake recharge - last_data_array[model.isbc[0] == 2] = model.high_k_lake_recharge[per] - last_data_array[model.isbc[0] == 1] = 0. - # assign to current per - data[per] = last_data_array + + # special case of LGR models + # with bottom connections to underlying parent cells + if model.version == 'mf6': + # (if model is an lgr inset model) + if model._is_lgr: + # regardless of what is specified for inset model bottom + # use top elevations of underlying parent model cells + nlay = model.cfg['dis']['dimensions']['nlay'] + lgr = model.parent.lgr[model.name] # Flopy Lgr inst. + n_refined = (np.array(lgr.ncppl) > 0).astype(int).sum() + # check if LGR model has connections to underlying parent cells + if (n_refined < model.parent.modelgrid.nlay): + # use the parent model bottoms + # mapped to the inset model grid by the Flopy Lgr util + #data[nlay-1] = lgr.botm[nlay-1] + # set the inset and parent model botms + # to the mean elevations of the inset cells + # connecting to each parent cell + ncpp = lgr.ncpp + nrowp = int(data[nlay-1].shape[0]/ncpp) + ncolp = int(data[nlay-1].shape[1]/ncpp) + lgr_inset_botm = data[nlay-1] + if any(np.isnan(lgr_inset_botm.flat)): + raise ValueError( + "Nan values in LGR inset model bottom; " + "can't use this to make the top of the parent model." + ) + # average each nccp x nccp block of inset model cells + topp = np.reshape(lgr_inset_botm, + (nrowp, ncpp, ncolp, ncpp)).mean(axis=(1, 3)) + n_parent_lgr_layers = np.sum(np.array(lgr.ncppl) > 0) + # remap averages back to the inset model shape + data[nlay-1] = np.repeat(np.repeat(topp, 5, axis=0), 5, axis=1) + # set the parent model botm in this area to be the same + lgr_area = model.parent.lgr[model.name].idomain == 0 + model.parent.dis.top[lgr_area[0]] = topp.ravel() + # set parent model layers in LGR area to zero-thickness + new_parent_botm = model.parent.dis.botm.array.copy() + for k in range(n_parent_lgr_layers): + new_parent_botm[k][lgr_area[0]] = topp.ravel() + model.parent.dis.botm = new_parent_botm + model.parent._update_top_botm_external_files() + + elif var in ['rech', 'recharge']: + if simulate_high_k_lakes: + for per in range(model.nper): + if per == 0 and per not in data: + raise KeyError("No recharge input specified for first stress period.") + if per in data: + # assign high-k lake recharge for stress period + # only assign if precip and open water evaporation data were read + # (otherwise keep original values in recharge array) + last_data_array = data[per].copy() + if model.high_k_lake_recharge is not None: + data[per][model.isbc[0] == 2] = model.high_k_lake_recharge[per] + # zero-values to lak package lakes + data[per][model.isbc[0] == 1] = 0. + else: + if model.high_k_lake_recharge is not None: + # start with the last period with recharge data; update the high-k lake recharge + last_data_array[model.isbc[0] == 2] = model.high_k_lake_recharge[per] + last_data_array[model.isbc[0] == 1] = 0. + # assign to current per + data[per] = last_data_array + if model.lgr: + for per, rech_array in data.items(): + rech_array[model._lgr_idomain2d == 0] = 0 elif var in ['hk', 'k'] and simulate_high_k_lakes: for i, arr in data.items(): data[i][model.isbc[i] == 2] = model.cfg['high_k_lakes']['high_k_value'] diff --git a/mfsetup/tests/data/pleasant_vertical_lgr_inset.yml b/mfsetup/tests/data/pleasant_vertical_lgr_inset.yml index ab163592..cb513b4e 100644 --- a/mfsetup/tests/data/pleasant_vertical_lgr_inset.yml +++ b/mfsetup/tests/data/pleasant_vertical_lgr_inset.yml @@ -1,10 +1,10 @@ simulation: - sim_name: 'pleasant_lgr' + sim_name: 'pleasant_vlgr' version: 'mf6' - sim_ws: 'pleasant_lgr/' + sim_ws: '../tmp/pleasant_vlgr/' model: - simulation: 'pleasant_lgr' + simulation: 'pleasant_vlgr' modelname: 'plsnt_lgr_inset' options: print_input: True @@ -32,7 +32,7 @@ model: setup_grid: source_data: features_shapefile: - filename: 'data/pleasant/source_data/shps/all_lakes.shp' + filename: '../../../examples/data/pleasant/source_data/shps/all_lakes.shp' id_column: 'HYDROID' include_ids: [600059060] # pleasant lake dxy: 40 # grid spacing, in CRS units (meters) @@ -44,16 +44,21 @@ dis: length_units: 'meters' dimensions: # nrow and ncol are based on the buffer distance and grid spacing - nlay: 5 + nlay: 9 source_data: top: - filename: 'data/pleasant/source_data/rasters/dem40m.tif' # DEM file; path relative to setup script + filename: '../../../examples/data/pleasant/source_data/rasters/dem40m.tif' # DEM file; path relative to setup script elevation_units: 'meters' botm: filenames: - 1: 'data/pleasant/source_data/rasters/botm0.tif' # preprocessed surface for parent model layer 0 bottom - 2: 'data/pleasant/source_data/rasters/botm1.tif' # preprocessed surface for parent model layer 1 bottom - 3: 'data/pleasant/source_data/rasters/botm2.tif' # preprocessed surface for parent model layer 2 bottom + # bottom of layer 0 set halfway between layer 1 bottom and model top (layer_refinement[0] == 2) + 1: '../../../examples/data/pleasant/source_data/rasters/botm0.tif' # preprocessed surface for parent model layer 0 bottom + # bottom of layer 2 set halfway between layers 1 and 3 (layer_refinement[1] == 2) + 3: '../../../examples/data/pleasant/source_data/rasters/botm1.tif' # preprocessed surface for parent model layer 1 bottom + # bottom of layer 4 set halfway between layers 3 and 5 (layer_refinement[2] == 2) + 5: '../../../examples/data/pleasant/source_data/rasters/botm2.tif' # preprocessed surface for parent model layer 2 bottom + # bottoms of layers 6 and 7 equally subdivide layers 5 and 8 (layer_refinement[3] == 3) + # bottom of layer 8 set from parent model layer 3 bottom # Recharge and Well packages are inherited from the parent model # (since this is an LGR model @@ -74,13 +79,13 @@ lak: # polygon shapefile of lake footprints littoral_zone_buffer_width: 40 lakes_shapefile: - filename: 'data/pleasant/source_data/shps/all_lakes.shp' + filename: '../../../examples/data/pleasant/source_data/shps/all_lakes.shp' id_column: 'HYDROID' include_ids: [600059060] # pleasant lake # setup lake precipitation and evaporation from PRISM data climate: filenames: - 600059060: 'data/pleasant/source_data/PRISM_ppt_tmean_stable_4km_189501_201901_43.9850_-89.5522.csv' + 600059060: '../../../examples/data/pleasant/source_data/PRISM_ppt_tmean_stable_4km_189501_201901_43.9850_-89.5522.csv' format: 'prism' period_stats: # for period 0, use average precip and evap for dates below @@ -90,11 +95,11 @@ lak: 1: 'mean' # average daily rate or value for each month # bathymetry file with lake depths to subtract off model top bathymetry_raster: - filename: 'data/pleasant/source_data/rasters/pleasant_bathymetry.tif' + filename: '../../../examples/data/pleasant/source_data/rasters/pleasant_bathymetry.tif' length_units: 'meters' # bathymetry file with stage/area/volume relationship stage_area_volume_file: - filename: 'data/pleasant/source_data/tables/area_stage_vol_Pleasant.csv' + filename: '../../../examples/data/pleasant/source_data/tables/area_stage_vol_Pleasant.csv' length_units: 'meters' id_column: 'hydroid' column_mappings: @@ -106,9 +111,9 @@ sfr: save_flows: True source_data: flowlines: - nhdplus_paths: ['data/pleasant/source_data/shps'] + nhdplus_paths: ['../../../examples/data/pleasant/source_data/shps'] dem: - filename: 'data/pleasant/source_data/rasters/dem40m.tif' + filename: '../../../examples/data/pleasant/source_data/rasters/dem40m.tif' elevation_units: 'meters' sfrmaker_options: set_streambed_top_elevations_from_dem: True @@ -118,11 +123,11 @@ obs: # any observations not within the LGR extent are culled source_data: filenames: [ - #'data/pleasant/source_data/tables/nwis_heads_info_file.csv', - 'data/pleasant/source_data/tables/lake_sites.csv', # some lakes are high-k; obs need to be in hydmod - 'data/pleasant/source_data/tables/wdnr_gw_sites.csv', - #'data/pleasant/source_data/tables/uwsp_heads.csv', - #'data/pleasant/source_data/tables/wgnhs_head_targets.csv' + #'../../../examples/data/pleasant/source_data/tables/nwis_heads_info_file.csv', + '../../../examples/data/pleasant/source_data/tables/lake_sites.csv', # some lakes are high-k; obs need to be in hydmod + '../../../examples/data/pleasant/source_data/tables/wdnr_gw_sites.csv', + #'../../../examples/data/pleasant/source_data/tables/uwsp_heads.csv', + #'../../../examples/data/pleasant/source_data/tables/wgnhs_head_targets.csv' ] column_mappings: obsname: ['obsprefix', 'common_name'] diff --git a/mfsetup/tests/data/pleasant_vertical_lgr_parent.yml b/mfsetup/tests/data/pleasant_vertical_lgr_parent.yml index e98514e8..bb234e4d 100644 --- a/mfsetup/tests/data/pleasant_vertical_lgr_parent.yml +++ b/mfsetup/tests/data/pleasant_vertical_lgr_parent.yml @@ -11,13 +11,13 @@ metadata: # input for MODFLOW 6 simulation simulation: - sim_name: 'pleasant_lgr' + sim_name: 'pleasant_vlgr' version: 'mf6' - sim_ws: 'pleasant_lgr/' + sim_ws: '../tmp/pleasant_vlgr/' # input for MODFLOW 6 model model: - simulation: 'pleasant_lgr' + simulation: 'pleasant_vlgr' modelname: 'plsnt_lgr_parent' options: print_input: True @@ -46,7 +46,7 @@ model: parent: # argments to flopy.modflow.Modflow.load for parent model namefile: 'pleasant.nam' - model_ws: 'data/pleasant/' + model_ws: '../../../examples/data/pleasant/' version: 'mfnwt' # information for modflow-setup # note: parent model is geo-located in namfile header @@ -56,11 +56,10 @@ parent: copy_stress_periods: 'all' inset_layer_mapping: # mapping between inset and parent model layers 0: 0 # inset: parent (inset layers 1 and 0 copied from parent layer 0) - 1: 0 - 2: 1 - 3: 2 + 1: 1 + 2: 2 + 3: 3 4: 3 - 5: 3 start_date_time: '2012-01-01' length_units: 'meters' time_units: 'days' @@ -79,14 +78,13 @@ setup_grid: # is set up in tandem and connected in the same MODFLOW 6 simulation lgr: pleasant_lgr_inset: - filename: 'pleasant_lgr_inset.yml' + filename: 'pleasant_vertical_lgr_inset.yml' # number of inset layers for each parent layer # this can be an integer (vertically uniform refinement) # a list (with an entry for each parent layer) - # or a dictionary (with entries for each parent layer that is refined; + # or a dictionary (with entries for each parent layer that is refined; # unlisted layers will default to zero) - # only a - layer_refinement: [1, 1, 1, 1, 1, 0] + layer_refinement: [2, 2, 2, 3, 0] # Structured Discretization Package dis: @@ -94,7 +92,7 @@ dis: length_units: 'meters' dimensions: # if nrow and ncol are not specified here, the entries above in setup_grid are used - nlay: 6 + nlay: 5 nrow: 25 ncol: 25 # griddata: @@ -103,14 +101,15 @@ dis: # idomain is developed from layer pinch-outs and boundary condition locations source_data: top: - filename: 'data/pleasant/source_data/rasters/dem40m.tif' # DEM file; path relative to setup script + filename: '../../../examples/data/pleasant/source_data/rasters/dem40m.tif' # DEM file; path relative to setup script elevation_units: 'meters' botm: filenames: - 1: 'data/pleasant/source_data/rasters/botm0.tif' # preprocessed surface for parent model layer 0 bottom - 2: 'data/pleasant/source_data/rasters/botm1.tif' # preprocessed surface for parent model layer 1 bottom - 3: 'data/pleasant/source_data/rasters/botm2.tif' # preprocessed surface for parent model layer 2 bottom - 5: 'data/pleasant/source_data/rasters/botm3.tif' # preprocessed surface for parent model layer 3 bottom + 0: '../../../examples/data/pleasant/source_data/rasters/botm0.tif' # preprocessed surface for parent model layer 0 bottom + 1: '../../../examples/data/pleasant/source_data/rasters/botm1.tif' # preprocessed surface for parent model layer 1 bottom + 2: '../../../examples/data/pleasant/source_data/rasters/botm2.tif' # preprocessed surface for parent model layer 2 bottom + # bottom of layer 3 set halfway between layers 2 and 5 + 4: '../../../examples/data/pleasant/source_data/rasters/botm3.tif' # preprocessed surface for parent model layer 3 bottom # Temporal Discretization Package tdis: @@ -141,7 +140,7 @@ ic: source_data: strt: from_parent: - binaryfile: 'data/pleasant/pleasant.hds' + binaryfile: '../../../examples/data/pleasant/pleasant.hds' stress_period: 0 # Node Property Flow Package @@ -180,16 +179,16 @@ sfr: source_data: flowlines: # path to NHDPlus version 2 dataset - nhdplus_paths: ['data/pleasant/source_data/shps'] + nhdplus_paths: ['../../../examples/data/pleasant/source_data/shps'] # if a DEM is included, streambed top elevations will be sampled # from the minimum DEM values within a 100 meter buffer around each stream reach dem: - filename: 'data/pleasant/source_data/rasters/dem40m.tif' + filename: '../../../examples/data/pleasant/source_data/rasters/dem40m.tif' elevation_units: 'meters' # SFR observations can be automatically setup from a CSV file # of x, y locations and fluxes observations: # see sfrmaker.observations.add_observations for arguments - filename: 'data/pleasant/source_data/tables/gages.csv' + filename: '../../../examples/data/pleasant/source_data/tables/gages.csv' obstype: 'downstream-flow' # modflow-6 observation type x_location_column: 'x' y_location_column: 'y' @@ -221,11 +220,11 @@ obs: # observations at each location can subsequently be processed # to represent a given screened interval # for example, using modflow-obs (https://github.com/aleaf/modflow-obs) - filenames: ['data/pleasant/source_data/tables/nwis_heads_info_file.csv', - 'data/pleasant/source_data/tables/lake_sites.csv', # some lakes are high-k; obs need to be in hydmod - 'data/pleasant/source_data/tables/wdnr_gw_sites.csv', - 'data/pleasant/source_data/tables/uwsp_heads.csv', - 'data/pleasant/source_data/tables/wgnhs_head_targets.csv' + filenames: ['../../../examples/data/pleasant/source_data/tables/nwis_heads_info_file.csv', + '../../../examples/data/pleasant/source_data/tables/lake_sites.csv', # some lakes are high-k; obs need to be in hydmod + '../../../examples/data/pleasant/source_data/tables/wdnr_gw_sites.csv', + '../../../examples/data/pleasant/source_data/tables/uwsp_heads.csv', + '../../../examples/data/pleasant/source_data/tables/wgnhs_head_targets.csv' ] column_mappings: obsname: ['obsprefix', 'obsnme', 'common_name'] @@ -235,4 +234,4 @@ obs: chd: perimeter_boundary: - parent_head_file: 'data/pleasant/pleasant.hds' # needed for the perimeter boundary setup + parent_head_file: '../../../examples/data/pleasant/pleasant.hds' # needed for the perimeter boundary setup diff --git a/mfsetup/tests/test_lgr.py b/mfsetup/tests/test_lgr.py index e8b0e64b..d1bc298b 100644 --- a/mfsetup/tests/test_lgr.py +++ b/mfsetup/tests/test_lgr.py @@ -1,11 +1,11 @@ import copy import glob import os -import shutil from pathlib import Path import flopy import numpy as np +import pandas as pd import pytest mf6 = flopy.mf6 @@ -15,7 +15,7 @@ from mfsetup import MF6model from mfsetup.discretization import make_lgr_idomain from mfsetup.fileio import dump, exe_exists, load, load_cfg, read_mf6_block -from mfsetup.interpolate import regrid3d +from mfsetup.grid import get_ij from mfsetup.mover import get_sfr_package_connections from mfsetup.testing import compare_inset_parent_values from mfsetup.utils import get_input_arguments @@ -25,6 +25,9 @@ def pleasant_lgr_test_cfg_path(project_root_path): return project_root_path + '/examples/pleasant_lgr_parent.yml' +@pytest.fixture(scope="session") +def pleasant_vertical_lgr_test_cfg_path(test_data_path): + return test_data_path / 'pleasant_vertical_lgr_parent.yml' @pytest.fixture(scope="function") def pleasant_lgr_cfg(pleasant_lgr_test_cfg_path): @@ -34,6 +37,13 @@ def pleasant_lgr_cfg(pleasant_lgr_test_cfg_path): cfg['gisdir'] = os.path.join(cfg['simulation']['sim_ws'], 'gis') return cfg +@pytest.fixture(scope="function") +def pleasant_vertical_lgr_cfg(pleasant_vertical_lgr_test_cfg_path): + cfg = load_cfg(pleasant_vertical_lgr_test_cfg_path, + default_file='/mf6_defaults.yml') + # add some stuff just for the tests + cfg['gisdir'] = os.path.join(cfg['simulation']['sim_ws'], 'gis') + return cfg @pytest.fixture(scope="function") def pleasant_simulation(pleasant_lgr_cfg): @@ -67,6 +77,11 @@ def pleasant_lgr_setup_from_yaml(pleasant_lgr_cfg): m.write_input() return m +@pytest.fixture(scope="function") +def pleasant_vertical_lgr_setup_from_yaml(pleasant_vertical_lgr_cfg): + m = MF6model.setup_from_cfg(pleasant_vertical_lgr_cfg) + m.write_input() + return m @pytest.fixture(scope="function") def pleasant_lgr_stand_alone_parent(pleasant_lgr_test_cfg_path, tmpdir): @@ -96,7 +111,8 @@ def pleasant_lgr_stand_alone_parent(pleasant_lgr_test_cfg_path, tmpdir): def test_make_lgr_idomain(get_pleasant_lgr_parent_with_grid): m = get_pleasant_lgr_parent_with_grid inset_model = m.inset['plsnt_lgr_inset'] - idomain = make_lgr_idomain(m.modelgrid, inset_model.modelgrid) + idomain = make_lgr_idomain(m.modelgrid, inset_model.modelgrid, + m.lgr['plsnt_lgr_inset'].ncppl) assert idomain.shape == m.modelgrid.shape l, b, r, t = inset_model.modelgrid.bounds isinset = (m.modelgrid.xcellcenters > l) & \ @@ -108,21 +124,34 @@ def test_make_lgr_idomain(get_pleasant_lgr_parent_with_grid): @pytest.mark.parametrize( - 'lgr_grid_spacing,parent_start_end_layers,inset_nlay', [ + 'lgr_grid_spacing,layer_refinement_input,inset_nlay', [ # parent layers 0 through 3 # are specified in pleasant_lgr_parent.yml - (40, 'use configuration', 4), - (40, (0, 2), 3), + (40, 'use configuration', 5), + (40, [1, 1, 1, 1, 0], 4), + (40, [2, 1, 1, 1, 0], 5), + # dictionary input option + (40, {0:1, 1:1, 2:1}, 3), + # integer layer refinement input option + (40, 1, 5), # special case to test setup - # with no parent start/end layers specified + # with no layer refinement specified (40, None, 5), pytest.param(35, None, 5, marks=pytest.mark.xfail( reason='inset spacing not a factor of parent spacing')), pytest.param(40, None, 4, marks=pytest.mark.xfail( reason='inset nlay inconsistent with parent layers')), + pytest.param(40, [1, 1, 1, 1], 5, marks=pytest.mark.xfail( + reason='List layer_refinement input must include a value for each layer')), + pytest.param(40, [0, 1, 1, 1, 1], 5, marks=pytest.mark.xfail( + reason='LGR child grid must start at model top')), + pytest.param(40, {1: 1}, 5, marks=pytest.mark.xfail( + reason='LGR child grid must start at model top')), + pytest.param(40, [1, 1, 0, 1, 1], 5, marks=pytest.mark.xfail( + reason='LGR child grid must be contiguous')), ] ) -def test_lgr_grid_setup(lgr_grid_spacing, parent_start_end_layers, +def test_lgr_grid_setup(lgr_grid_spacing, layer_refinement_input, inset_nlay, pleasant_lgr_cfg, pleasant_simulation, project_root_path): @@ -138,17 +167,14 @@ def test_lgr_grid_setup(lgr_grid_spacing, parent_start_end_layers, lgr_cfg = cfg['setup_grid']['lgr']['pleasant_lgr_inset'] lgr_cfg['cfg'] = inset_cfg del lgr_cfg['filename'] - if parent_start_end_layers is None: - del lgr_cfg['parent_start_layer'] - del lgr_cfg['parent_end_layer'] - k0, k1 = 0, None - elif parent_start_end_layers == 'use configuration': - k0 = lgr_cfg['parent_start_layer'] - k1 = lgr_cfg['parent_end_layer'] + if layer_refinement_input is None: + del lgr_cfg['layer_refinement'] + layer_refinement = [1] * cfg['dis']['dimensions']['nlay'] + elif layer_refinement_input == 'use configuration': + layer_refinement = lgr_cfg['layer_refinement'] else: - k0, k1 = parent_start_end_layers - lgr_cfg['parent_start_layer'] = k0 - lgr_cfg['parent_end_layer'] = k1 + lgr_cfg['layer_refinement'] = layer_refinement_input + layer_refinement = layer_refinement_input cfg['model']['simulation'] = pleasant_simulation kwargs = get_input_arguments(cfg['model'], mf6.ModflowGwf, exclude='packages') @@ -165,9 +191,14 @@ def test_lgr_grid_setup(lgr_grid_spacing, parent_start_end_layers, m.modelgrid.write_shapefile(outfolder / 'pleasant_lgr_parent_grid.shp') inset_model.modelgrid.write_shapefile(outfolder / 'pleasant_lgr_inset_grid.shp') + if np.isscalar(layer_refinement): + layer_refinement = np.array([1] * m.modelgrid.nlay) + elif isinstance(layer_refinement, dict): + layer_refinement = [layer_refinement.get(i, 0) for i in range(m.modelgrid.nlay)] + layer_refinement = np.array(layer_refinement) # verify that lgr area was removed from parent idomain lgr_idomain = make_lgr_idomain(m.modelgrid, inset_model.modelgrid, - k0, k1) + layer_refinement) idomain = m.idomain assert idomain[lgr_idomain == 0].sum() == 0 inset_cells_per_layer = inset_model.modelgrid.shape[1] *\ @@ -176,18 +207,28 @@ def test_lgr_grid_setup(lgr_grid_spacing, parent_start_end_layers, nparent_cells_within_lgr_per_layer = inset_cells_per_layer / refinement_factor**2 # for each layer where lgr is specified, # there should be at least enough inactive cells to cover the lrg grid area - if k1 is None: - k1 = m.modelgrid.nlay -1 layers_with_lgr = (lgr_idomain == 0).sum(axis=(1, 2)) >=\ nparent_cells_within_lgr_per_layer - assert all(layers_with_lgr[k0:k1]) + assert all(layers_with_lgr[layer_refinement > 0]) # layers outside of the specified lgr range should have # less inactive cells than the size of the lgr grid area # (specific to this test case with a large LGR extent relative to the total grid) - assert not any(layers_with_lgr[k1+1:]) - assert not any(layers_with_lgr[:k0]) - j=2 - # todo: add test that grids are aligned + assert not any(layers_with_lgr[layer_refinement == 0]) + + # make a plot for the docs + if layer_refinement_input == 'use configuration': + import matplotlib.pyplot as plt + fig, ax = plt.subplots(figsize=(10, 10)) + parent_mv = flopy.plot.PlotMapView(model=m, ax=ax, layer=0) + inset_mv = flopy.plot.PlotMapView(model=inset_model, ax=ax, layer=0) + l, r, b, t = m.modelgrid.extent + lcp = parent_mv.plot_grid(lw=0.5, ax=ax) + lci = inset_mv.plot_grid(lw=0.5) + ax.set_ylim(b, t) + ax.set_xlim(l, r) + ax.set_aspect(1) + plt.savefig(project_root_path + '/docs/source/_static/pleasant_lgr.png', + bbox_inches='tight') def test_setup_mover(pleasant_lgr_setup_from_yaml): @@ -201,6 +242,51 @@ def test_setup_mover(pleasant_lgr_setup_from_yaml): assert 'mover' in options +def test_lgr_parent_bcs_in_lgr_area(pleasant_vertical_lgr_setup_from_yaml): + """Test that boundary conditions specified in the parent model + inside of the LGR area don't get created + (these should be represented in the LGR inset/child model instead.""" + m = pleasant_vertical_lgr_setup_from_yaml + ghb_source_data = { + 'shapefile': { # pond near pleasant lake + 'filename': '../../../../examples/data/pleasant/source_data/shps/all_lakes.shp', + 'id_column': 'HYDROID', + 'include_ids': [600059161], + 'all_touched': True + }, + 'bhead': { + 'filename': '../../../../examples/data/pleasant/source_data/rasters/dem40m.tif', + 'elevation_units': 'meters', + 'stat': 'mean' + }, + 'cond': 9, # m2/d + } + m.setup_ghb(source_data=ghb_source_data) + # there should be no GHB Package, because this feature is inside of the LGR area + # (and should therefore be represented in the LGR inset/child model) + assert not hasattr(m, 'ghb') + wel_source_data = { + 'wells': { + # well with screen mostly in LGR area (should not be represented) + 'well1': {'per': 1, 'x': 555910.8, 'y': 389618.3, + 'screen_top': 300, 'screen_botm': 260, 'q': -2000}, + # well with screen mostly in parent model below LGR area (should be represented) + 'well2': {'per': 1, 'x': 555910.8, 'y': 389618.3, + 'screen_top': 250, 'screen_botm': 200, 'q': -2000} + } + } + added_wells = m.setup_wel(source_data=wel_source_data) + # well1 should not be in the parent model (open interval within LGR area) + assert 'well1' not in added_wells.stress_period_data.data[1]['boundname'] + assert 'well2' in added_wells.stress_period_data.data[1]['boundname'] + inset = m.inset['plsnt_lgr_inset'] + inset.setup_ghb(source_data=ghb_source_data) + assert hasattr(inset, 'ghb') + inset_added_wells = inset.setup_wel(source_data=wel_source_data) + assert 'well1' in inset_added_wells.stress_period_data.data[1]['boundname'] + assert 'well2' not in inset_added_wells.stress_period_data.data[1]['boundname'] + + def test_mover_get_sfr_package_connections(pleasant_lgr_setup_from_yaml): m = pleasant_lgr_setup_from_yaml parent_reach_data = m.sfrdata.reach_data @@ -225,6 +311,109 @@ def test_mover_get_sfr_package_connections(pleasant_lgr_setup_from_yaml): assert to_parent == {29: 8, 41: 1} +def test_lgr_bottom_elevations(pleasant_vertical_lgr_setup_from_yaml, mf6_exe): + """Test that boundary elevations specified in the LGR area + are the same as the top of the underlying active area in + the parent model (so there aren't gaps or overlap in the + numerical grid).""" + m = pleasant_vertical_lgr_setup_from_yaml + inset = m.inset['plsnt_lgr_inset'] + x = inset.modelgrid.xcellcenters + y = inset.modelgrid.ycellcenters + pi, pj = get_ij(m.modelgrid, x.ravel(), y.ravel(), + local=False) + pi = np.reshape(pi, x.shape) + pj = np.reshape(pj, x.shape) + parent_model_top = np.reshape(m.dis.top.array[pi, pj], x.shape) + + # LGR child bottom and parent top should be aligned + assert np.allclose(inset.dis.botm.array[-1], + parent_model_top) + + # check exchange data + exchange_data = pd.DataFrame(m.simulation.gwfgwf.exchangedata.array) + k1, i1, j1 = zip(*exchange_data['cellidm1']) + k2, i2, j2 = zip(*exchange_data['cellidm2']) + exchange_data = exchange_data.assign( + k1=k1, i1=i1, j1=j1, k2=k2, i2=i2, j2=j2) + vertical_connections = exchange_data.loc[exchange_data['ihc'] == 0] + + lgr = m.lgr[inset.name] # Flopy Lgr utility instance + active_cells = np.sum(inset.dis.idomain.array > 0, axis=0) > 0 + has_vertical_connection = np.zeros_like(active_cells) + has_vertical_connection[vertical_connections['i2'], vertical_connections['j2']] = 1 + # all active cells should have a vertical connection + assert all(has_vertical_connection[active_cells] == 1) + # each active horizontal location should only have 1 vertical connection + assert np.sum(has_vertical_connection[active_cells] == 1) == len(vertical_connections) + # check connection distances + all_layers = np.stack([m.dis.top.array] + [arr for arr in m.dis.botm.array]) + cell_thickness1 = -np.diff(all_layers, axis=0) + all_layers2 = np.stack([inset.dis.top.array] + [arr for arr in inset.dis.botm.array]) + cell_thickness2 = -np.diff(all_layers2, axis=0) + vertical_connections['layer_thick1'] = cell_thickness1[vertical_connections['k1'], + vertical_connections['i1'], + vertical_connections['j1']] + vertical_connections['layer_thick2'] = cell_thickness2[vertical_connections['k2'], + vertical_connections['i2'], + vertical_connections['j2']] + # cl1 should be 0.5 x parent cell thickness + assert np.allclose(vertical_connections['cl1'], vertical_connections['layer_thick1']/2) + # cl2 should be 0.5 x inset/child cell thickness + assert np.allclose(vertical_connections['cl2'], vertical_connections['layer_thick2']/2) + # hwva should equal inset cell bottom face area + inset_cell_areas = inset.dis.delc.array[vertical_connections['i2']] *\ + inset.dis.delr.array[vertical_connections['j2']] + assert np.allclose(vertical_connections['hwva'], inset_cell_areas) + + # test the horizontal connections too + horizontal_connections_ns = exchange_data.loc[(exchange_data['ihc'] > 0) & exchange_data['angldegx'].isin([0., 180.])] + horizontal_connections_ew = exchange_data.loc[(exchange_data['ihc'] > 0) & exchange_data['angldegx'].isin([90., 270.])] + # cl1 should be 0.5 x parent cell width + assert np.allclose(horizontal_connections_ns['cl1'], m.dis.delc.array[horizontal_connections_ns['i1']]/2) + assert np.allclose(horizontal_connections_ew['cl1'], m.dis.delr.array[horizontal_connections_ew['j1']]/2) + #cl2—is the distance between the center of cell 2 and the its shared face with cell 1. + assert np.allclose(horizontal_connections_ns['cl2'], inset.dis.delc.array[horizontal_connections_ns['i2']]/2) + assert np.allclose(horizontal_connections_ew['cl2'], inset.dis.delr.array[horizontal_connections_ew['j2']]/2) + #hwva is the parent cell width perpendicular to the connection + assert np.allclose(horizontal_connections_ns['hwva'], inset.dis.delr.array[horizontal_connections_ns['j2']]) + assert np.allclose(horizontal_connections_ew['hwva'], inset.dis.delc.array[horizontal_connections_ew['i2']]) + + # verify that the model runs + success = False + if exe_exists(mf6_exe): + success, buff = m.simulation.run_simulation() + if not success: + list_file = m.name_file.list.array + with open(list_file) as src: + list_output = src.read() + assert success, 'model run did not terminate successfully:\n{}'.format(list_output) + + # make a cross section plot for the documentation + import matplotlib.pyplot as plt + fig, ax = plt.subplots(figsize=(14, 5)) + # plot cross section through an area prone to mis-patch + # because of inconsistencies in input raster layer surfaces, + # and sub-200m variability in topography + #xs_line = [(553000, 390900), (558000, 390900)] + # line thru the lake + xs_line = [(553000, 390200), (558000, 390200)] + xs = flopy.plot.PlotCrossSection(model=m, + line={"line": xs_line}, ax=ax, + geographic_coords=True) + lc = xs.plot_grid(zorder=4) + xs2 = flopy.plot.PlotCrossSection(model=inset, + line={"line": xs_line}, ax=ax, + geographic_coords=True) + lc = xs2.plot_grid(zorder=4) + #xs2.plot_surface(inset.ic.strt.array, c='b') + #xs.plot_surface(m.ic.strt.array, c='b') + plt.savefig('../../../../docs/source/_static/pleasant_vlgr_xsection.png', + bbox_inches='tight') + plt.close() + + + def test_lgr_model_setup(pleasant_lgr_setup_from_yaml, tmpdir): m = pleasant_lgr_setup_from_yaml assert isinstance(m.inset, dict) diff --git a/mfsetup/tests/test_mf6_shellmound.py b/mfsetup/tests/test_mf6_shellmound.py index 768a0f17..6391d32d 100644 --- a/mfsetup/tests/test_mf6_shellmound.py +++ b/mfsetup/tests/test_mf6_shellmound.py @@ -349,11 +349,20 @@ def test_dis_setup(shellmound_model_with_grid): invalid_botms = np.ones_like(botm) invalid_botms[np.isnan(botm)] = 0 invalid_botms[thickness < 1.0001] = 0 + + import matplotlib.pyplot as plt + fig, axes = plt.subplots(3, 4) + for i, ax in enumerate(axes.flat): + if i < 12: + ax.imshow(m.idomain[i]) # these two arrays are not equal # because isolated cells haven't been removed from the second one # this verifies that _set_idomain is removing them - assert not np.array_equal(m.idomain[:, isactive].sum(axis=1), - invalid_botms[:, isactive].sum(axis=1)) + # note: 8/4/2024: after 012b6c6, this statement is True, + # presumably because the isolated cells are getting culled as part of setup_dis() + # TODO: might be better to test find_remove_isolated_cells directly + # assert not np.array_equal(m.idomain[:, isactive].sum(axis=1), + # invalid_botms[:, isactive].sum(axis=1)) invalid_botms = find_remove_isolated_cells(invalid_botms, minimum_cluster_size=20) active_cells = m.idomain[:, isactive].copy() active_cells[active_cells < 0] = 0 # need to do this because some idomain cells are -1 diff --git a/mfsetup/wells.py b/mfsetup/wells.py index 5be780bb..6226c51c 100644 --- a/mfsetup/wells.py +++ b/mfsetup/wells.py @@ -382,34 +382,6 @@ def assign_layers_from_screen_top_botm(data, model, T_r = T[::-1] data['k'] = len(T_r) - np.argmax(T_r, axis=0) - 1 - # get thicknesses for all layers - # (including portions of layers outside open interval) - all_layers = np.zeros((model.nlay + 1, model.nrow, model.ncol)) - all_layers[0] = model.dis.top.array - all_layers[1:] = model.dis.botm.array - all_layer_thicknesses = np.abs(np.diff(all_layers, axis=0)) - layer_thicknesses = -np.diff(all_layers[:, i, j], axis=0) - - # only include thicknesses for valid layers - # reset thicknesses to sat. thickness - if strt3D is not None: - sat_thickness = strt3D - model.dis.botm.array - # cells where the head is above the layer top - no_unsat = sat_thickness > all_layer_thicknesses - sat_thickness[no_unsat] = all_layer_thicknesses[no_unsat] - # cells where the head is below the cell bottom - sat_thickness[sat_thickness < 0] = 0 - layer_thicknesses = sat_thickness[:, i, j] - - # set inactive cells to 0 thickness for the purpose or relocating wells - layer_thicknesses[idomain[:, i, j] < 1] = 0 - data['idomain'] = idomain[data['k'], i, j] - data['laythick'] = layer_thicknesses[data['k'].values, - list(range(layer_thicknesses.shape[1]))] - # flag layers that are too thin or inactive - inactive = idomain[data.k, data.i, data.j] < 1 - invalid_open_interval = (data['laythick'] < minimum_layer_thickness) | inactive - outfile = model.cfg['wel']['output_files']['dropped_wells_file'].format(model.name) bad_wells = pd.DataFrame() # for LGR parent models, remove wells with >50% of their open interval within the LGR area @@ -438,6 +410,36 @@ def assign_layers_from_screen_top_botm(data, model, "should be checked)." ) data = data.loc[in_model].copy() + + + # get thicknesses for all layers + # (including portions of layers outside open interval) + k, i, j = data['k'].values, data['i'].values, data['j'].values + all_layers = np.zeros((model.nlay + 1, model.nrow, model.ncol)) + all_layers[0] = model.dis.top.array + all_layers[1:] = model.dis.botm.array + all_layer_thicknesses = np.abs(np.diff(all_layers, axis=0)) + layer_thicknesses = -np.diff(all_layers[:, i, j], axis=0) + + # only include thicknesses for valid layers + # reset thicknesses to sat. thickness + if strt3D is not None: + sat_thickness = strt3D - model.dis.botm.array + # cells where the head is above the layer top + no_unsat = sat_thickness > all_layer_thicknesses + sat_thickness[no_unsat] = all_layer_thicknesses[no_unsat] + # cells where the head is below the cell bottom + sat_thickness[sat_thickness < 0] = 0 + layer_thicknesses = sat_thickness[:, i, j] + + # set inactive cells to 0 thickness for the purpose or relocating wells + layer_thicknesses[idomain[:, i, j] < 1] = 0 + data['idomain'] = idomain[k, i, j] + data['laythick'] = layer_thicknesses[k, list(range(layer_thicknesses.shape[1]))] + # flag layers that are too thin or inactive + inactive = idomain[data.k, data.i, data.j] < 1 + invalid_open_interval = (data['laythick'] < minimum_layer_thickness) | inactive + if any(invalid_open_interval): # move wells that are still in a thin layer to the thickest active layer @@ -483,14 +485,14 @@ def assign_layers_from_screen_top_botm(data, model, minimum_layer_thickness, model.length_units)) if flux_col in data.columns: - pct_flux_below = 100 * bad_wells.loc[still_below_minimum, flux_col].sum()/data[flux_col].sum() + pct_flux_below = 100 * wells_in_too_thin_layers.loc[still_below_minimum, flux_col].sum()/data[flux_col].sum() msg += ', \nrepresenting {:.2f} %% of total flux,'.format(pct_flux_below) msg += '\nwere dropped. See {} for details.'.format(outfile) print(msg) # write shapefile and CSV output for wells that were dropped - bad_wells = pd.concat([bad_wells, data.loc[invalid_open_interval].copy()]) + bad_wells = pd.concat([bad_wells, wells_in_too_thin_layers]) bad_wells['routine'] = __name__ + '.assign_layers_from_screen_top_botm' cols = ['k', 'i', 'j', 'boundname', 'category', 'laythick', 'idomain', 'reason', 'routine', 'x', 'y']