From b2d09c4f8a5423997340ed7335f475b3b9dd1c31 Mon Sep 17 00:00:00 2001 From: Daniel Buckley Date: Thu, 11 Jan 2024 20:23:32 -0700 Subject: [PATCH] Implement and test TWRI example --- .gitignore | 3 + .pylintrc | 631 ++++++ README.md | 8 + .../implementing/gwf_twri01/gwf_twri01.ipynb | 903 ++++++++ .../gwf_twri01/model/gwf_twri01.chd | 41 + .../gwf_twri01/model/gwf_twri01.dis | 26 + .../gwf_twri01/model/gwf_twri01.dis.grb | Bin 0 -> 54888 bytes .../gwf_twri01/model/gwf_twri01.drn | 20 + .../gwf_twri01/model/gwf_twri01.ic | 6 + .../gwf_twri01/model/gwf_twri01.ims | 15 + .../gwf_twri01/model/gwf_twri01.lst | 330 +++ .../gwf_twri01/model/gwf_twri01.nam | 15 + .../gwf_twri01/model/gwf_twri01.npf | 28 + .../gwf_twri01/model/gwf_twri01.oc | 11 + .../gwf_twri01/model/gwf_twri01.rcha | 10 + .../gwf_twri01/model/gwf_twri01.tdis | 13 + .../gwf_twri01/model/gwf_twri01.wel | 26 + .../implementing/gwf_twri01/model/mfsim.lst | 216 ++ .../implementing/gwf_twri01/model/mfsim.nam | 19 + notebooks/learning/gwf_twri01.ipynb | 1851 +++++++++++++++++ notebooks/testing/gwf_twri01/gwf_twri01.ipynb | 499 +++++ .../testing/gwf_twri01/model/gwf_twri01.chd | 41 + .../testing/gwf_twri01/model/gwf_twri01.dis | 26 + .../gwf_twri01/model/gwf_twri01.dis.grb | Bin 0 -> 54888 bytes .../testing/gwf_twri01/model/gwf_twri01.drn | 20 + .../testing/gwf_twri01/model/gwf_twri01.ic | 6 + .../testing/gwf_twri01/model/gwf_twri01.ims | 15 + .../testing/gwf_twri01/model/gwf_twri01.lst | 330 +++ .../testing/gwf_twri01/model/gwf_twri01.nam | 15 + .../testing/gwf_twri01/model/gwf_twri01.npf | 28 + .../testing/gwf_twri01/model/gwf_twri01.oc | 11 + .../testing/gwf_twri01/model/gwf_twri01.rcha | 10 + .../testing/gwf_twri01/model/gwf_twri01.tdis | 13 + .../testing/gwf_twri01/model/gwf_twri01.wel | 26 + notebooks/testing/gwf_twri01/model/mfsim.lst | 216 ++ notebooks/testing/gwf_twri01/model/mfsim.nam | 19 + pyproject.toml | 31 + setup.py | 9 + src/flopy_mf6_work/__init__.py | 2 + src/flopy_mf6_work/gwf/__init__.py | 0 src/flopy_mf6_work/gwf/twri01.py | 348 ++++ 41 files changed, 5837 insertions(+) create mode 100644 .pylintrc create mode 100644 notebooks/implementing/gwf_twri01/gwf_twri01.ipynb create mode 100644 notebooks/implementing/gwf_twri01/model/gwf_twri01.chd create mode 100644 notebooks/implementing/gwf_twri01/model/gwf_twri01.dis create mode 100644 notebooks/implementing/gwf_twri01/model/gwf_twri01.dis.grb create mode 100644 notebooks/implementing/gwf_twri01/model/gwf_twri01.drn create mode 100644 notebooks/implementing/gwf_twri01/model/gwf_twri01.ic create mode 100644 notebooks/implementing/gwf_twri01/model/gwf_twri01.ims create mode 100644 notebooks/implementing/gwf_twri01/model/gwf_twri01.lst create mode 100644 notebooks/implementing/gwf_twri01/model/gwf_twri01.nam create mode 100644 notebooks/implementing/gwf_twri01/model/gwf_twri01.npf create mode 100644 notebooks/implementing/gwf_twri01/model/gwf_twri01.oc create mode 100644 notebooks/implementing/gwf_twri01/model/gwf_twri01.rcha create mode 100644 notebooks/implementing/gwf_twri01/model/gwf_twri01.tdis create mode 100644 notebooks/implementing/gwf_twri01/model/gwf_twri01.wel create mode 100644 notebooks/implementing/gwf_twri01/model/mfsim.lst create mode 100644 notebooks/implementing/gwf_twri01/model/mfsim.nam create mode 100644 notebooks/learning/gwf_twri01.ipynb create mode 100644 notebooks/testing/gwf_twri01/gwf_twri01.ipynb create mode 100644 notebooks/testing/gwf_twri01/model/gwf_twri01.chd create mode 100644 notebooks/testing/gwf_twri01/model/gwf_twri01.dis create mode 100644 notebooks/testing/gwf_twri01/model/gwf_twri01.dis.grb create mode 100644 notebooks/testing/gwf_twri01/model/gwf_twri01.drn create mode 100644 notebooks/testing/gwf_twri01/model/gwf_twri01.ic create mode 100644 notebooks/testing/gwf_twri01/model/gwf_twri01.ims create mode 100644 notebooks/testing/gwf_twri01/model/gwf_twri01.lst create mode 100644 notebooks/testing/gwf_twri01/model/gwf_twri01.nam create mode 100644 notebooks/testing/gwf_twri01/model/gwf_twri01.npf create mode 100644 notebooks/testing/gwf_twri01/model/gwf_twri01.oc create mode 100644 notebooks/testing/gwf_twri01/model/gwf_twri01.rcha create mode 100644 notebooks/testing/gwf_twri01/model/gwf_twri01.tdis create mode 100644 notebooks/testing/gwf_twri01/model/gwf_twri01.wel create mode 100644 notebooks/testing/gwf_twri01/model/mfsim.lst create mode 100644 notebooks/testing/gwf_twri01/model/mfsim.nam create mode 100644 pyproject.toml create mode 100644 setup.py create mode 100644 src/flopy_mf6_work/__init__.py create mode 100644 src/flopy_mf6_work/gwf/__init__.py create mode 100644 src/flopy_mf6_work/gwf/twri01.py diff --git a/.gitignore b/.gitignore index 68bc17f..b6acf39 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,6 @@ +# Visual Studio Code settings +.vscode/ + # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] diff --git a/.pylintrc b/.pylintrc new file mode 100644 index 0000000..9078b89 --- /dev/null +++ b/.pylintrc @@ -0,0 +1,631 @@ +[MAIN] + +# Analyse import fallback blocks. This can be used to support both Python 2 and +# 3 compatible code, which means that the block might have code that exists +# only in one or another interpreter, leading to false positives when analysed. +analyse-fallback-blocks=no + +# Clear in-memory caches upon conclusion of linting. Useful if running pylint +# in a server-like mode. +clear-cache-post-run=no + +# Load and enable all available extensions. Use --list-extensions to see a list +# all available extensions. +#enable-all-extensions= + +# In error mode, messages with a category besides ERROR or FATAL are +# suppressed, and no reports are done by default. Error mode is compatible with +# disabling specific errors. +#errors-only= + +# Always return a 0 (non-error) status code, even if lint errors are found. +# This is primarily useful in continuous integration scripts. +#exit-zero= + +# A comma-separated list of package or module names from where C extensions may +# be loaded. Extensions are loading into the active Python interpreter and may +# run arbitrary code. +extension-pkg-allow-list= + +# A comma-separated list of package or module names from where C extensions may +# be loaded. Extensions are loading into the active Python interpreter and may +# run arbitrary code. (This is an alternative name to extension-pkg-allow-list +# for backward compatibility.) +extension-pkg-whitelist= + +# Return non-zero exit code if any of these messages/categories are detected, +# even if score is above --fail-under value. Syntax same as enable. Messages +# specified are enabled, while categories only check already-enabled messages. +fail-on= + +# Specify a score threshold under which the program will exit with error. +fail-under=10 + +# Interpret the stdin as a python script, whose filename needs to be passed as +# the module_or_package argument. +#from-stdin= + +# Files or directories to be skipped. They should be base names, not paths. +ignore=CVS + +# Add files or directories matching the regular expressions patterns to the +# ignore-list. The regex matches against paths and can be in Posix or Windows +# format. Because '\\' represents the directory delimiter on Windows systems, +# it can't be used as an escape character. +ignore-paths= + +# Files or directories matching the regular expression patterns are skipped. +# The regex matches against base names, not paths. The default value ignores +# Emacs file locks +ignore-patterns=^\.# + +# List of module names for which member attributes should not be checked +# (useful for modules/projects where namespaces are manipulated during runtime +# and thus existing member attributes cannot be deduced by static analysis). It +# supports qualified module names, as well as Unix pattern matching. +ignored-modules= + +# Python code to execute, usually for sys.path manipulation such as +# pygtk.require(). +#init-hook= + +# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the +# number of processors available to use, and will cap the count on Windows to +# avoid hangs. +jobs=1 + +# Control the amount of potential inferred values when inferring a single +# object. This can help the performance when dealing with large functions or +# complex, nested conditions. +limit-inference-results=100 + +# List of plugins (as comma separated values of python module names) to load, +# usually to register additional checkers. +load-plugins= + +# Pickle collected data for later comparisons. +persistent=yes + +# Minimum Python version to use for version dependent checks. Will default to +# the version used to run pylint. +py-version=3.11 + +# Discover python modules and packages in the file system subtree. +recursive=no + +# Add paths to the list of the source roots. Supports globbing patterns. The +# source root is an absolute path or a path relative to the current working +# directory used to determine a package namespace for modules located under the +# source root. +source-roots= + +# When enabled, pylint would attempt to guess common misconfiguration and emit +# user-friendly hints instead of false-positive error messages. +suggestion-mode=yes + +# Allow loading of arbitrary C extensions. Extensions are imported into the +# active Python interpreter and may run arbitrary code. +unsafe-load-any-extension=no + +# In verbose mode, extra non-checker-related info will be displayed. +#verbose= + + +[BASIC] + +# Naming style matching correct argument names. +argument-naming-style=snake_case + +# Regular expression matching correct argument names. Overrides argument- +# naming-style. If left empty, argument names will be checked with the set +# naming style. +#argument-rgx= + +# Naming style matching correct attribute names. +attr-naming-style=snake_case + +# Regular expression matching correct attribute names. Overrides attr-naming- +# style. If left empty, attribute names will be checked with the set naming +# style. +#attr-rgx= + +# Bad variable names which should always be refused, separated by a comma. +bad-names=foo, + bar, + baz, + toto, + tutu, + tata + +# Bad variable names regexes, separated by a comma. If names match any regex, +# they will always be refused +bad-names-rgxs= + +# Naming style matching correct class attribute names. +class-attribute-naming-style=any + +# Regular expression matching correct class attribute names. Overrides class- +# attribute-naming-style. If left empty, class attribute names will be checked +# with the set naming style. +#class-attribute-rgx= + +# Naming style matching correct class constant names. +class-const-naming-style=UPPER_CASE + +# Regular expression matching correct class constant names. Overrides class- +# const-naming-style. If left empty, class constant names will be checked with +# the set naming style. +#class-const-rgx= + +# Naming style matching correct class names. +class-naming-style=PascalCase + +# Regular expression matching correct class names. Overrides class-naming- +# style. If left empty, class names will be checked with the set naming style. +#class-rgx= + +# Naming style matching correct constant names. +const-naming-style=UPPER_CASE + +# Regular expression matching correct constant names. Overrides const-naming- +# style. If left empty, constant names will be checked with the set naming +# style. +#const-rgx= + +# Minimum line length for functions/classes that require docstrings, shorter +# ones are exempt. +docstring-min-length=-1 + +# Naming style matching correct function names. +function-naming-style=snake_case + +# Regular expression matching correct function names. Overrides function- +# naming-style. If left empty, function names will be checked with the set +# naming style. +#function-rgx= + +# Good variable names which should always be accepted, separated by a comma. +good-names=i, + j, + k, + ex, + Run, + _ + +# Good variable names regexes, separated by a comma. If names match any regex, +# they will always be accepted +good-names-rgxs= + +# Include a hint for the correct naming format with invalid-name. +include-naming-hint=no + +# Naming style matching correct inline iteration names. +inlinevar-naming-style=any + +# Regular expression matching correct inline iteration names. Overrides +# inlinevar-naming-style. If left empty, inline iteration names will be checked +# with the set naming style. +#inlinevar-rgx= + +# Naming style matching correct method names. +method-naming-style=snake_case + +# Regular expression matching correct method names. Overrides method-naming- +# style. If left empty, method names will be checked with the set naming style. +#method-rgx= + +# Naming style matching correct module names. +module-naming-style=snake_case + +# Regular expression matching correct module names. Overrides module-naming- +# style. If left empty, module names will be checked with the set naming style. +#module-rgx= + +# Colon-delimited sets of names that determine each other's naming style when +# the name regexes allow several styles. +name-group= + +# Regular expression which should only match function or class names that do +# not require a docstring. +no-docstring-rgx=^_ + +# List of decorators that produce properties, such as abc.abstractproperty. Add +# to this list to register other decorators that produce valid properties. +# These decorators are taken in consideration only for invalid-name. +property-classes=abc.abstractproperty + +# Regular expression matching correct type alias names. If left empty, type +# alias names will be checked with the set naming style. +#typealias-rgx= + +# Regular expression matching correct type variable names. If left empty, type +# variable names will be checked with the set naming style. +#typevar-rgx= + +# Naming style matching correct variable names. +variable-naming-style=snake_case + +# Regular expression matching correct variable names. Overrides variable- +# naming-style. If left empty, variable names will be checked with the set +# naming style. +#variable-rgx= + + +[CLASSES] + +# Warn about protected attribute access inside special methods +check-protected-access-in-special-methods=no + +# List of method names used to declare (i.e. assign) instance attributes. +defining-attr-methods=__init__, + __new__, + setUp, + asyncSetUp, + __post_init__ + +# List of member names, which should be excluded from the protected access +# warning. +exclude-protected=_asdict,_fields,_replace,_source,_make,os._exit + +# List of valid names for the first argument in a class method. +valid-classmethod-first-arg=cls + +# List of valid names for the first argument in a metaclass class method. +valid-metaclass-classmethod-first-arg=mcs + + +[DESIGN] + +# List of regular expressions of class ancestor names to ignore when counting +# public methods (see R0903) +exclude-too-few-public-methods= + +# List of qualified class names to ignore when counting class parents (see +# R0901) +ignored-parents= + +# Maximum number of arguments for function / method. +max-args=5 + +# Maximum number of attributes for a class (see R0902). +max-attributes=7 + +# Maximum number of boolean expressions in an if statement (see R0916). +max-bool-expr=5 + +# Maximum number of branch for function / method body. +max-branches=12 + +# Maximum number of locals for function / method body. +max-locals=15 + +# Maximum number of parents for a class (see R0901). +max-parents=7 + +# Maximum number of public methods for a class (see R0904). +max-public-methods=20 + +# Maximum number of return / yield for function / method body. +max-returns=6 + +# Maximum number of statements in function / method body. +max-statements=50 + +# Minimum number of public methods for a class (see R0903). +min-public-methods=2 + + +[EXCEPTIONS] + +# Exceptions that will emit a warning when caught. +overgeneral-exceptions=builtins.BaseException,builtins.Exception + + +[FORMAT] + +# Expected format of line ending, e.g. empty (any line ending), LF or CRLF. +expected-line-ending-format= + +# Regexp for a line that is allowed to be longer than the limit. +ignore-long-lines=^\s*(# )??$ + +# Number of spaces of indent required inside a hanging or continued line. +indent-after-paren=4 + +# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 +# tab). +indent-string=' ' + +# Maximum number of characters on a single line. +max-line-length=100 + +# Maximum number of lines in a module. +max-module-lines=1000 + +# Allow the body of a class to be on the same line as the declaration if body +# contains single statement. +single-line-class-stmt=no + +# Allow the body of an if to be on the same line as the test if there is no +# else. +single-line-if-stmt=no + + +[IMPORTS] + +# List of modules that can be imported at any level, not just the top level +# one. +allow-any-import-level= + +# Allow explicit reexports by alias from a package __init__. +allow-reexport-from-package=no + +# Allow wildcard imports from modules that define __all__. +allow-wildcard-with-all=no + +# Deprecated modules which should not be used, separated by a comma. +deprecated-modules= + +# Output a graph (.gv or any supported image format) of external dependencies +# to the given file (report RP0402 must not be disabled). +ext-import-graph= + +# Output a graph (.gv or any supported image format) of all (i.e. internal and +# external) dependencies to the given file (report RP0402 must not be +# disabled). +import-graph= + +# Output a graph (.gv or any supported image format) of internal dependencies +# to the given file (report RP0402 must not be disabled). +int-import-graph= + +# Force import order to recognize a module as part of the standard +# compatibility libraries. +known-standard-library= + +# Force import order to recognize a module as part of a third party library. +known-third-party=enchant + +# Couples of modules and preferred modules, separated by a comma. +preferred-modules= + + +[LOGGING] + +# The type of string formatting that logging methods do. `old` means using % +# formatting, `new` is for `{}` formatting. +logging-format-style=old + +# Logging modules to check that the string format arguments are in logging +# function parameter format. +logging-modules=logging + + +[MESSAGES CONTROL] + +# Only show warnings with the listed confidence levels. Leave empty to show +# all. Valid levels: HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE, +# UNDEFINED. +confidence=HIGH, + CONTROL_FLOW, + INFERENCE, + INFERENCE_FAILURE, + UNDEFINED + +# Disable the message, report, category or checker with the given id(s). You +# can either give multiple identifiers separated by comma (,) or put this +# option multiple times (only on the command line, not in the configuration +# file where it should appear only once). You can also use "--disable=all" to +# disable everything first and then re-enable specific checks. For example, if +# you want to run only the similarities checker, you can use "--disable=all +# --enable=similarities". If you want to run only the classes checker, but have +# no Warning level messages displayed, use "--disable=all --enable=classes +# --disable=W". +disable=raw-checker-failed, + bad-inline-option, + locally-disabled, + file-ignored, + suppressed-message, + useless-suppression, + deprecated-pragma, + use-symbolic-message-instead + +# Enable the message, report, category or checker with the given id(s). You can +# either give multiple identifier separated by comma (,) or put this option +# multiple time (only on the command line, not in the configuration file where +# it should appear only once). See also the "--disable" option for examples. +enable=c-extension-no-member + + +[METHOD_ARGS] + +# List of qualified names (i.e., library.method) which require a timeout +# parameter e.g. 'requests.api.get,requests.api.post' +timeout-methods=requests.api.delete,requests.api.get,requests.api.head,requests.api.options,requests.api.patch,requests.api.post,requests.api.put,requests.api.request + + +[MISCELLANEOUS] + +# List of note tags to take in consideration, separated by a comma. +notes=FIXME, + XXX, + TODO + +# Regular expression of note tags to take in consideration. +notes-rgx= + + +[REFACTORING] + +# Maximum number of nested blocks for function / method body +max-nested-blocks=5 + +# Complete name of functions that never returns. When checking for +# inconsistent-return-statements if a never returning function is called then +# it will be considered as an explicit return statement and no message will be +# printed. +never-returning-functions=sys.exit,argparse.parse_error + + +[REPORTS] + +# Python expression which should return a score less than or equal to 10. You +# have access to the variables 'fatal', 'error', 'warning', 'refactor', +# 'convention', and 'info' which contain the number of messages in each +# category, as well as 'statement' which is the total number of statements +# analyzed. This score is used by the global evaluation report (RP0004). +evaluation=max(0, 0 if fatal else 10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)) + +# Template used to display messages. This is a python new-style format string +# used to format the message information. See doc for all details. +msg-template= + +# Set the output format. Available formats are text, parseable, colorized, json +# and msvs (visual studio). You can also give a reporter class, e.g. +# mypackage.mymodule.MyReporterClass. +#output-format= + +# Tells whether to display a full report or only the messages. +reports=no + +# Activate the evaluation score. +score=yes + + +[SIMILARITIES] + +# Comments are removed from the similarity computation +ignore-comments=yes + +# Docstrings are removed from the similarity computation +ignore-docstrings=yes + +# Imports are removed from the similarity computation +ignore-imports=yes + +# Signatures are removed from the similarity computation +ignore-signatures=yes + +# Minimum lines number of a similarity. +min-similarity-lines=4 + + +[SPELLING] + +# Limits count of emitted suggestions for spelling mistakes. +max-spelling-suggestions=4 + +# Spelling dictionary name. No available dictionaries : You need to install +# both the python package and the system dependency for enchant to work.. +spelling-dict= + +# List of comma separated words that should be considered directives if they +# appear at the beginning of a comment and should not be checked. +spelling-ignore-comment-directives=fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy: + +# List of comma separated words that should not be checked. +spelling-ignore-words= + +# A path to a file that contains the private dictionary; one word per line. +spelling-private-dict-file= + +# Tells whether to store unknown words to the private dictionary (see the +# --spelling-private-dict-file option) instead of raising a message. +spelling-store-unknown-words=no + + +[STRING] + +# This flag controls whether inconsistent-quotes generates a warning when the +# character used as a quote delimiter is used inconsistently within a module. +check-quote-consistency=no + +# This flag controls whether the implicit-str-concat should generate a warning +# on implicit string concatenation in sequences defined over several lines. +check-str-concat-over-line-jumps=no + + +[TYPECHECK] + +# List of decorators that produce context managers, such as +# contextlib.contextmanager. Add to this list to register other decorators that +# produce valid context managers. +contextmanager-decorators=contextlib.contextmanager + +# List of members which are set dynamically and missed by pylint inference +# system, and so shouldn't trigger E1101 when accessed. Python regular +# expressions are accepted. +generated-members= + +# Tells whether to warn about missing members when the owner of the attribute +# is inferred to be None. +ignore-none=yes + +# This flag controls whether pylint should warn about no-member and similar +# checks whenever an opaque object is returned when inferring. The inference +# can return multiple potential results while evaluating a Python object, but +# some branches might not be evaluated, which results in partial inference. In +# that case, it might be useful to still emit no-member and other checks for +# the rest of the inferred objects. +ignore-on-opaque-inference=yes + +# List of symbolic message names to ignore for Mixin members. +ignored-checks-for-mixins=no-member, + not-async-context-manager, + not-context-manager, + attribute-defined-outside-init + +# List of class names for which member attributes should not be checked (useful +# for classes with dynamically set attributes). This supports the use of +# qualified names. +ignored-classes=optparse.Values,thread._local,_thread._local,argparse.Namespace + +# Show a hint with possible names when a member name was not found. The aspect +# of finding the hint is based on edit distance. +missing-member-hint=yes + +# The minimum edit distance a name should have in order to be considered a +# similar match for a missing member name. +missing-member-hint-distance=1 + +# The total number of similar names that should be taken in consideration when +# showing a hint for a missing member. +missing-member-max-choices=1 + +# Regex pattern to define which classes are considered mixins. +mixin-class-rgx=.*[Mm]ixin + +# List of decorators that change the signature of a decorated function. +signature-mutators= + + +[VARIABLES] + +# List of additional names supposed to be defined in builtins. Remember that +# you should avoid defining new builtins when possible. +additional-builtins= + +# Tells whether unused global variables should be treated as a violation. +allow-global-unused-variables=yes + +# List of names allowed to shadow builtins +allowed-redefined-builtins= + +# List of strings which can identify a callback function by name. A callback +# name must start or end with one of those strings. +callbacks=cb_, + _cb + +# A regular expression matching the name of dummy variables (i.e. expected to +# not be used). +dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_ + +# Argument names that match this expression will be ignored. +ignored-argument-names=_.*|^ignored_|^unused_ + +# Tells whether we should check for unused import in __init__ files. +init-import=no + +# List of qualified module names which can have objects that can redefine +# builtins. +redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io diff --git a/README.md b/README.md index 474de48..ff669d0 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,10 @@ # flopy_mf6_work Learning MODFLOW 6 using the FloPy library + +Going through the examples in the [MODFLOW 6 software download](https://www.usgs.gov/software/modflow-6-usgs-modular-hydrologic-model): +- Models are in the `examples/` directory of the download +- Descriptions for the examples are in `doc/mf6examples.pdf` within the download + +## Development + +Docstrings should follow the [numpydoc style guide](https://numpydoc.readthedocs.io/en/latest/format.html). \ No newline at end of file diff --git a/notebooks/implementing/gwf_twri01/gwf_twri01.ipynb b/notebooks/implementing/gwf_twri01/gwf_twri01.ipynb new file mode 100644 index 0000000..bf1e279 --- /dev/null +++ b/notebooks/implementing/gwf_twri01/gwf_twri01.ipynb @@ -0,0 +1,903 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from os import getcwd\n", + "from pathlib import Path\n", + "\n", + "import flopy as fp\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "WindowsPath('c:/Users/buckl/Documents/Github/flopy_mf6_work/notebooks/implementing/gwf_twri01/model')" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "workspace = Path(getcwd(), \"model\")\n", + "workspace" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "sim_name = gwf_twri01\n", + "sim_path = c:\\Users\\buckl\\Documents\\Github\\flopy_mf6_work\\notebooks\\implementing\\gwf_twri01\\model\n", + "exe_name = C:\\Users\\buckl\\Documents\\Software\\mf6.4.1\\bin\\mf6.exe\n", + "\n", + "###################\n", + "Package mfsim.nam\n", + "###################\n", + "\n", + "package_name = mfsim.nam\n", + "filename = mfsim.nam\n", + "package_type = nam\n", + "model_or_simulation_package = simulation\n", + "simulation_name = gwf_twri01\n", + "\n" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim_name = \"gwf_twri01\"\n", + "sim = fp.mf6.MFSimulation(\n", + " sim_name=sim_name,\n", + " version=\"mf6\",\n", + " exe_name=Path(\"C:\\\\Users\\\\buckl\\\\Documents\\\\Software\\\\mf6.4.1\\\\bin\\\\mf6.exe\"),\n", + " sim_ws=workspace\n", + ")\n", + "sim" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "package_name = tdis\n", + "filename = gwf_twri01.tdis\n", + "package_type = tdis\n", + "model_or_simulation_package = simulation\n", + "simulation_name = gwf_twri01\n", + "\n", + "Block options\n", + "--------------------\n", + "time_units\n", + "{internal}\n", + "('seconds')\n", + "\n", + "\n", + "Block dimensions\n", + "--------------------\n", + "nper\n", + "{internal}\n", + "(1)\n", + "\n", + "\n", + "Block perioddata\n", + "--------------------\n", + "perioddata\n", + "{internal}\n", + "(rec.array([(86400., 1, 1.)],\n", + " dtype=[('perlen', '}\n" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def make_chd_iter():\n", + " for layer in [0, 2]:\n", + " for row in range(15):\n", + " yield ((layer, row, 0), 0.0)\n", + "\n", + "fp.mf6.ModflowGwfchd(\n", + " model=model,\n", + " maxbound=30,\n", + " stress_period_data=list(make_chd_iter()),\n", + " filename=f\"{sim_name}.chd\",\n", + " pname=\"chd_0\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "rec.array([((0, 0, 0), 0.), ((0, 1, 0), 0.), ((0, 2, 0), 0.),\n", + " ((0, 3, 0), 0.), ((0, 4, 0), 0.), ((0, 5, 0), 0.),\n", + " ((0, 6, 0), 0.), ((0, 7, 0), 0.), ((0, 8, 0), 0.),\n", + " ((0, 9, 0), 0.), ((0, 10, 0), 0.), ((0, 11, 0), 0.),\n", + " ((0, 12, 0), 0.), ((0, 13, 0), 0.), ((0, 14, 0), 0.),\n", + " ((2, 0, 0), 0.), ((2, 1, 0), 0.), ((2, 2, 0), 0.),\n", + " ((2, 3, 0), 0.), ((2, 4, 0), 0.), ((2, 5, 0), 0.),\n", + " ((2, 6, 0), 0.), ((2, 7, 0), 0.), ((2, 8, 0), 0.),\n", + " ((2, 9, 0), 0.), ((2, 10, 0), 0.), ((2, 11, 0), 0.),\n", + " ((2, 12, 0), 0.), ((2, 13, 0), 0.), ((2, 14, 0), 0.)],\n", + " dtype=[('cellid', 'O'), ('head', '}\n" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def make_drn_iter():\n", + " elev = [0, 0, 10, 20, 30, 50, 70, 90, 100]\n", + " for col in range(1, 10):\n", + " yield ((0, 7, col), float(elev[col - 1]), 1.0)\n", + "\n", + "fp.mf6.ModflowGwfdrn(\n", + " model=model,\n", + " maxbound=9,\n", + " stress_period_data=list(make_drn_iter()),\n", + " filename=f\"{sim_name}.drn\",\n", + " pname=\"drn_0\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "rec.array([((0, 7, 1), 0., 1.), ((0, 7, 2), 0., 1.),\n", + " ((0, 7, 3), 10., 1.), ((0, 7, 4), 20., 1.),\n", + " ((0, 7, 5), 30., 1.), ((0, 7, 6), 50., 1.),\n", + " ((0, 7, 7), 70., 1.), ((0, 7, 8), 90., 1.),\n", + " ((0, 7, 9), 100., 1.)],\n", + " dtype=[('cellid', 'O'), ('elev', '}\n" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def make_wel_iter():\n", + " # wells in unconfined aquifer\n", + " for row in range(8, 13, 2):\n", + " for col in range(7, 14, 2):\n", + " yield ((0, row, col), -5.0)\n", + "\n", + " # wells in middle confined aquifer\n", + " yield ((2, 3, 5), -5.0)\n", + " yield ((2, 5, 11), -5.0)\n", + "\n", + " # well in lower confined aquifer\n", + " yield ((4, 4, 10), -5.0)\n", + "\n", + "fp.mf6.ModflowGwfwel(\n", + " model=model,\n", + " maxbound=15,\n", + " stress_period_data=list(make_wel_iter()),\n", + " filename=f\"{sim_name}.wel\",\n", + " pname=\"wel_0\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "rec.array([((0, 8, 7), -5.), ((0, 8, 9), -5.), ((0, 8, 11), -5.),\n", + " ((0, 8, 13), -5.), ((0, 10, 7), -5.), ((0, 10, 9), -5.),\n", + " ((0, 10, 11), -5.), ((0, 10, 13), -5.), ((0, 12, 7), -5.),\n", + " ((0, 12, 9), -5.), ((0, 12, 11), -5.), ((0, 12, 13), -5.),\n", + " ((2, 3, 5), -5.), ((2, 5, 11), -5.), ((4, 4, 10), -5.)],\n", + " dtype=[('cellid', 'O'), ('q', ']" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim.check()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "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...\n", + " writing model gwf_twri01...\n", + " writing model name file...\n", + " writing package dis...\n", + " writing package npf...\n", + " writing package ic...\n", + " writing package chd_0...\n", + " writing package drn_0...\n", + " writing package wel_0...\n", + " writing package rcha_0...\n", + " writing package oc...\n" + ] + } + ], + "source": [ + "sim.write_simulation()" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FloPy is using the following executable to run the model: ..\\..\\..\\..\\..\\..\\Software\\mf6.4.1\\bin\\mf6.exe\n", + " MODFLOW 6\n", + " U.S. GEOLOGICAL SURVEY MODULAR HYDROLOGIC MODEL\n", + " VERSION 6.4.1 Release 12/09/2022\n", + "\n", + " MODFLOW 6 compiled Dec 09 2022 18:18:37 with Intel(R) Fortran Intel(R) 64\n", + " Compiler Classic for applications running on Intel(R) 64, Version 2021.7.0\n", + " Build 20220726_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): 2024/01/11 19:47:55\n", + " \n", + " Writing simulation list file: mfsim.lst\n", + " Using Simulation name file: mfsim.nam\n", + " \n", + " Solving: Stress period: 1 Time step: 1\n", + " \n", + " Run end date and time (yyyy/mm/dd hh:mm:ss): 2024/01/11 19:47:55\n", + " Elapsed run time: 0.049 Seconds\n", + " \n", + " Normal termination of simulation.\n" + ] + } + ], + "source": [ + "success, buff = sim.run_simulation()\n", + "assert success, \"MODFLOW did not terminate normally!\"" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "sim.delete_output_files()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/implementing/gwf_twri01/model/gwf_twri01.chd b/notebooks/implementing/gwf_twri01/model/gwf_twri01.chd new file mode 100644 index 0000000..801e5a4 --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/gwf_twri01.chd @@ -0,0 +1,41 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. +BEGIN options +END options + +BEGIN dimensions + MAXBOUND 30 +END dimensions + +BEGIN period 1 + 1 1 1 0.00000000E+00 + 1 2 1 0.00000000E+00 + 1 3 1 0.00000000E+00 + 1 4 1 0.00000000E+00 + 1 5 1 0.00000000E+00 + 1 6 1 0.00000000E+00 + 1 7 1 0.00000000E+00 + 1 8 1 0.00000000E+00 + 1 9 1 0.00000000E+00 + 1 10 1 0.00000000E+00 + 1 11 1 0.00000000E+00 + 1 12 1 0.00000000E+00 + 1 13 1 0.00000000E+00 + 1 14 1 0.00000000E+00 + 1 15 1 0.00000000E+00 + 3 1 1 0.00000000E+00 + 3 2 1 0.00000000E+00 + 3 3 1 0.00000000E+00 + 3 4 1 0.00000000E+00 + 3 5 1 0.00000000E+00 + 3 6 1 0.00000000E+00 + 3 7 1 0.00000000E+00 + 3 8 1 0.00000000E+00 + 3 9 1 0.00000000E+00 + 3 10 1 0.00000000E+00 + 3 11 1 0.00000000E+00 + 3 12 1 0.00000000E+00 + 3 13 1 0.00000000E+00 + 3 14 1 0.00000000E+00 + 3 15 1 0.00000000E+00 +END period 1 + diff --git a/notebooks/implementing/gwf_twri01/model/gwf_twri01.dis b/notebooks/implementing/gwf_twri01/model/gwf_twri01.dis new file mode 100644 index 0000000..13b7788 --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/gwf_twri01.dis @@ -0,0 +1,26 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. +BEGIN options + LENGTH_UNITS feet +END options + +BEGIN dimensions + NLAY 5 + NROW 15 + NCOL 15 +END dimensions + +BEGIN griddata + delr + CONSTANT 5000.00000000 + delc + CONSTANT 5000.00000000 + top + CONSTANT 200.00000000 + botm LAYERED + CONSTANT -150.00000000 + CONSTANT -200.00000000 + CONSTANT -300.00000000 + CONSTANT -350.00000000 + CONSTANT -450.00000000 +END griddata + diff --git a/notebooks/implementing/gwf_twri01/model/gwf_twri01.dis.grb b/notebooks/implementing/gwf_twri01/model/gwf_twri01.dis.grb new file mode 100644 index 0000000000000000000000000000000000000000..b2441a58bb617103c1d3ff663866f509794315bb GIT binary patch literal 54888 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 CK;=yU literal 0 HcmV?d00001 diff --git a/notebooks/implementing/gwf_twri01/model/gwf_twri01.drn b/notebooks/implementing/gwf_twri01/model/gwf_twri01.drn new file mode 100644 index 0000000..974199c --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/gwf_twri01.drn @@ -0,0 +1,20 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. +BEGIN options +END options + +BEGIN dimensions + MAXBOUND 9 +END dimensions + +BEGIN period 1 + 1 8 2 0.00000000E+00 1.00000000E+00 + 1 8 3 0.00000000E+00 1.00000000E+00 + 1 8 4 1.00000000E+01 1.00000000E+00 + 1 8 5 2.00000000E+01 1.00000000E+00 + 1 8 6 3.00000000E+01 1.00000000E+00 + 1 8 7 5.00000000E+01 1.00000000E+00 + 1 8 8 7.00000000E+01 1.00000000E+00 + 1 8 9 9.00000000E+01 1.00000000E+00 + 1 8 10 1.00000000E+02 1.00000000E+00 +END period 1 + diff --git a/notebooks/implementing/gwf_twri01/model/gwf_twri01.ic b/notebooks/implementing/gwf_twri01/model/gwf_twri01.ic new file mode 100644 index 0000000..213a121 --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/gwf_twri01.ic @@ -0,0 +1,6 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. +BEGIN griddata + strt + CONSTANT 0.00000000 +END griddata + diff --git a/notebooks/implementing/gwf_twri01/model/gwf_twri01.ims b/notebooks/implementing/gwf_twri01/model/gwf_twri01.ims new file mode 100644 index 0000000..c62b9ee --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/gwf_twri01.ims @@ -0,0 +1,15 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. +BEGIN options +END options + +BEGIN nonlinear + OUTER_DVCLOSE 1.00000000E-09 + OUTER_MAXIMUM 50 +END nonlinear + +BEGIN linear + INNER_MAXIMUM 100 + INNER_DVCLOSE 1.00000000E-09 + inner_rclose 1.00000000E-06 strict +END linear + diff --git a/notebooks/implementing/gwf_twri01/model/gwf_twri01.lst b/notebooks/implementing/gwf_twri01/model/gwf_twri01.lst new file mode 100644 index 0000000..0db3e0e --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/gwf_twri01.lst @@ -0,0 +1,330 @@ + MODFLOW 6 + U.S. GEOLOGICAL SURVEY MODULAR HYDROLOGIC MODEL + GROUNDWATER FLOW MODEL (GWF) + VERSION 6.4.1 Release 12/09/2022 + + MODFLOW 6 compiled Dec 09 2022 18:18:37 with Intel(R) Fortran Intel(R) 64 + Compiler Classic for applications running on Intel(R) 64, Version 2021.7.0 + Build 20220726_000000 + +This software has been approved for release by the U.S. Geological +Survey (USGS). Although the software has been subjected to rigorous +review, the USGS reserves the right to update the software as needed +pursuant to further analysis and review. No warranty, expressed or +implied, is made by the USGS or the U.S. Government as to the +functionality of the software and related material nor shall the +fact of release constitute any such warranty. Furthermore, the +software is released on condition that neither the USGS nor the U.S. +Government shall be held liable for any damages resulting from its +authorized or unauthorized use. Also refer to the USGS Water +Resources Software User Rights Notice for complete use, copyright, +and distribution information. + + +As a work of the United States Government, this USGS product is +in the public domain within the United States. You can copy, +modify, distribute, and perform the work, even for commercial +purposes, all without asking permission. Additionally, USGS +waives copyright and related rights in the work worldwide +through CC0 1.0 Universal Public Domain Dedication +(https://creativecommons.org/publicdomain/zero/1.0/). + +The following GNU Lesser General Public License (LGPL) libraries +are used in this USGS product: + + SPARSKIT version 2.0 + ilut, luson, and qsplit + (https://www-users.cse.umn.edu/~saad/software/SPARSKIT/) + + RCM - Reverse Cuthill McKee Ordering + (https://people.math.sc.edu/Burkardt/f_src/rcm/rcm.html) + + BLAS - Basic Linear Algebra Subprograms Level 1 + (https://people.math.sc.edu/Burkardt/f_src/blas1_d/blas1_d.html) + + SPARSEKIT - Sparse Matrix Utility Package + amux, dperm, dvperm, rperm, and cperm + (https://people.sc.fsu.edu/~jburkardt/f77_src/sparsekit/sparsekit.html) + +The following BSD-3 License libraries are used in this USGS product: + + Modern Fortran DAG Library + Copyright (c) 2018, Jacob Williams + All rights reserved. + (https://github.com/jacobwilliams/daglib) + +MODFLOW 6 compiler options: /Isrc\libmf6core.a.p /Isrc /I..\src +/Isrc\libmf6_external.a.p /MTd /nologo /warn:general /warn:truncated_source +/stand:f08 /Zi /traceback /O2 /fpe:0 /heap-arrays:0 /traceback /fpp +/Qdiag-disable:7416 /Qdiag-disable:7025 /Qdiag-disable:5268 +/Fdsrc\libmf6core.a.p\Utilities_compilerversion.F90.pdb +/module:src\libmf6core.a.p +/Fosrc/libmf6core.a.p/Utilities_compilerversion.F90.obj /c + +System command used to initiate simulation: +C:\Users\buckl\Documents\Software\mf6.4.1\bin\mf6.exe + +MODFLOW was compiled using uniform precision. + +Real Variables + KIND: 8 + TINY (smallest non-zero value): 2.225074-308 + HUGE (largest value): 1.797693+308 + PRECISION: 15 + SIZE IN BITS: 64 + +Integer Variables + KIND: 4 + HUGE (largest value): 2147483647 + SIZE IN BITS: 32 + +Long Integer Variables + KIND: 8 + HUGE (largest value): 9223372036854775807 + SIZE IN BITS: 64 + +Logical Variables + KIND: 4 + SIZE IN BITS: 32 + + + OPENED gwf_twri01.dis + FILE TYPE:DIS6 UNIT 1005 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.npf + FILE TYPE:NPF6 UNIT 1006 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.ic + FILE TYPE:IC6 UNIT 1007 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.chd + FILE TYPE:CHD6 UNIT 1008 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.drn + FILE TYPE:DRN6 UNIT 1009 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.wel + FILE TYPE:WEL6 UNIT 1010 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.rcha + FILE TYPE:RCH6 UNIT 1011 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.oc + FILE TYPE:OC6 UNIT 1012 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + DIS -- STRUCTURED GRID DISCRETIZATION PACKAGE, VERSION 2 : 3/27/2014 - INPUT READ FROM UNIT 1005 + + Loading input for GWF_TWRI01/DIS + # File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. + NLAY = 5 + NROW = 15 + NCOL = 15 + DELR = 5000.000000000000 + DELC = 5000.000000000000 + TOP = 200.0000000000000 + BOTM = variable 3D double precision array ranging from -450.0000000000000 to -150.0000000000000 + Loading input complete... + + + NPF -- NODE PROPERTY FLOW PACKAGE, VERSION 1, 3/30/2015 INPUT READ FROM UNIT 1006 + + Loading input for GWF_TWRI01/NPF + # File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. + IVARCV = 1 + IDEWATCV = 1 + IPERCHED = 1 + ISAVSPDIS = 1 + ICELLTYPE = variable 1D integer array ranging from 0 to 1 + K = variable 1D double precision array ranging from .1000000000000000E-07 to .1000000000000000E-02 + K33 = variable 1D double precision array ranging from .1000000000000000E-07 to .1000000000000000E-02 + Loading input complete... + + Setting Discretization Options + Model length unit [0=UND, 1=FEET, 2=METERS, 3=CENTIMETERS] set as 1 + End Setting Discretization Options + + Setting Discretization Dimensions + NLAY = 5 + NROW = 15 + NCOL = 15 + End Setting Discretization Dimensions + + Setting Discretization Griddata + DELR set from input file + DELC set from input file + TOP set from input file + BOTM set from input file + End Setting Discretization Griddata + + Setting NPF Options + Vertical flow will be adjusted for perched conditions. + Vertical conductance varies with water table. + Vertical conductance accounts for dewatered portion of an underlying cell. + Specific discharge will be calculated at cell centers and written to DATA-SPDIS in budget file when requested. + End Setting NPF Options + + Setting NPF Griddata + ICELLTYPE set from input file + K set from input file + K33 set from input file + K22 not provided. Setting K22 = K. + End Setting NPF Griddata + + + WEL -- WEL PACKAGE, VERSION 8, 2/22/2014 INPUT READ FROM UNIT 1010 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. + + PROCESSING WEL OPTIONS + END OF WEL OPTIONS + + PROCESSING WEL DIMENSIONS + MAXBOUND = 15 + END OF WEL DIMENSIONS + + DRN -- DRN PACKAGE, VERSION 8, 2/22/2014 INPUT READ FROM UNIT 1009 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. + + PROCESSING DRN OPTIONS + END OF DRN OPTIONS + + PROCESSING DRN DIMENSIONS + MAXBOUND = 9 + END OF DRN DIMENSIONS + + RCH -- RCH PACKAGE, VERSION 8, 2/22/2014 INPUT READ FROM UNIT 1011 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. + + PROCESSING RCH OPTIONS + RECHARGE INPUT WILL BE READ AS ARRAY(S). + END OF RCHA OPTIONS + + CHD -- CHD PACKAGE, VERSION 8, 2/22/2014 INPUT READ FROM UNIT 1008 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. + + PROCESSING CHD OPTIONS + END OF CHD OPTIONS + + PROCESSING CHD DIMENSIONS + MAXBOUND = 30 + END OF CHD DIMENSIONS + + IC -- INITIAL CONDITIONS PACKAGE, VERSION 8, 3/28/2015 INPUT READ FROM UNIT 1007 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. + PROCESSING GRIDDATA + + INITIAL HEAD = 0.000000 + END PROCESSING GRIDDATA + BINARY GRID INFORMATION WILL BE WRITTEN TO: + UNIT NUMBER: 1014 + FILE NAME: c:\Users\buckl\Documents\Github\flopy_mf6_work\notebooks\implementing\gwf_twri01\model\gwf_twri01.dis.grb + + OPENED c:\Users\buckl\Documents\Github\flopy_mf6_work\notebooks\implementing\gwf_twri01\model\gwf_twri01.dis.grb + FILE TYPE:DATA(BINARY) UNIT 1014 STATUS:REPLACE + FORMAT:UNFORMATTED ACCESS:STREAM + ACTION:READWRITE + + THE LAST TIME STEP WILL BE PRINTED + THE LAST TIME STEP WILL BE PRINTED + # File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. + + PROCESSING OC OPTIONS + + BUDGET INFORMATION WILL BE WRITTEN TO: + UNIT NUMBER: 1015 + FILE NAME: gwf_twri01.cbc + + OPENED gwf_twri01.cbc + FILE TYPE:DATA(BINARY) UNIT 1015 STATUS:REPLACE + FORMAT:UNFORMATTED ACCESS:STREAM + ACTION:READWRITE + + HEAD INFORMATION WILL BE WRITTEN TO: + UNIT NUMBER: 1016 + FILE NAME: gwf_twri01.hds + + OPENED gwf_twri01.hds + FILE TYPE:DATA(BINARY) UNIT 1016 STATUS:REPLACE + FORMAT:UNFORMATTED ACCESS:STREAM + ACTION:READWRITE + + END OF OC OPTIONS + +start timestep kper="1" kstp="1" mode="normal" + + + BEGIN READING OUTPUT CONTROL FOR STRESS PERIOD 1 + ALL TIME STEPS WILL BE SAVED + ALL TIME STEPS WILL BE SAVED + + END READING OUTPUT CONTROL FOR STRESS PERIOD 1 + + RECHARGE = 0.3000000E-07 + + HEAD WILL BE SAVED ON UNIT 1016 AT END OF TIME STEP 1, STRESS PERIOD 1 + + + VOLUME BUDGET FOR ENTIRE MODEL AT END OF TIME STEP 1, STRESS PERIOD 1 + --------------------------------------------------------------------------------------------------- + + CUMULATIVE VOLUME L**3 RATES FOR THIS TIME STEP L**3/T PACKAGE NAME + ------------------ ------------------------ ---------------- + + IN: IN: + --- --- + WEL = 0.0000 WEL = 0.0000 WEL_0 + DRN = 0.0000 DRN = 0.0000 DRN_0 + RCHA = 13608000.0000 RCHA = 157.5000 RCHA_0 + CHD = 0.0000 CHD = 0.0000 CHD_0 + + TOTAL IN = 13608000.0000 TOTAL IN = 157.5000 + + OUT: OUT: + ---- ---- + WEL = 6480000.0000 WEL = 75.0000 WEL_0 + DRN = 2762140.1967 DRN = 31.9692 DRN_0 + RCHA = 0.0000 RCHA = 0.0000 RCHA_0 + CHD = 4365859.8053 CHD = 50.5308 CHD_0 + + TOTAL OUT = 13608000.0019 TOTAL OUT = 157.5000 + + IN - OUT = -1.9288E-03 IN - OUT = -2.2324E-08 + + PERCENT DISCREPANCY = -0.00 PERCENT DISCREPANCY = -0.00 + + + + + TIME SUMMARY AT END OF TIME STEP 1 IN STRESS PERIOD 1 + SECONDS MINUTES HOURS DAYS YEARS + ----------------------------------------------------------- + TIME STEP LENGTH 86400. 1440.0 24.000 1.0000 2.73785E-03 + STRESS PERIOD TIME 86400. 1440.0 24.000 1.0000 2.73785E-03 + TOTAL TIME 86400. 1440.0 24.000 1.0000 2.73785E-03 + + +end timestep + diff --git a/notebooks/implementing/gwf_twri01/model/gwf_twri01.nam b/notebooks/implementing/gwf_twri01/model/gwf_twri01.nam new file mode 100644 index 0000000..b8655ea --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/gwf_twri01.nam @@ -0,0 +1,15 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. +BEGIN options +END options + +BEGIN packages + DIS6 gwf_twri01.dis dis + NPF6 gwf_twri01.npf npf + IC6 gwf_twri01.ic ic + CHD6 gwf_twri01.chd chd_0 + DRN6 gwf_twri01.drn drn_0 + WEL6 gwf_twri01.wel wel_0 + RCH6 gwf_twri01.rcha rcha_0 + OC6 gwf_twri01.oc oc +END packages + diff --git a/notebooks/implementing/gwf_twri01/model/gwf_twri01.npf b/notebooks/implementing/gwf_twri01/model/gwf_twri01.npf new file mode 100644 index 0000000..2f0a43e --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/gwf_twri01.npf @@ -0,0 +1,28 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. +BEGIN options + VARIABLECV DEWATERED + PERCHED + SAVE_SPECIFIC_DISCHARGE +END options + +BEGIN griddata + icelltype LAYERED + CONSTANT 1 + CONSTANT 0 + CONSTANT 0 + CONSTANT 0 + CONSTANT 0 + k LAYERED + CONSTANT 0.00100000 + CONSTANT 1.00000000E-08 + CONSTANT 1.00000000E-04 + CONSTANT 5.00000000E-07 + CONSTANT 2.00000000E-04 + k33 LAYERED + CONSTANT 0.00100000 + CONSTANT 1.00000000E-08 + CONSTANT 1.00000000E-04 + CONSTANT 5.00000000E-07 + CONSTANT 2.00000000E-04 +END griddata + diff --git a/notebooks/implementing/gwf_twri01/model/gwf_twri01.oc b/notebooks/implementing/gwf_twri01/model/gwf_twri01.oc new file mode 100644 index 0000000..15baa10 --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/gwf_twri01.oc @@ -0,0 +1,11 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. +BEGIN options + BUDGET FILEOUT gwf_twri01.cbc + HEAD FILEOUT gwf_twri01.hds +END options + +BEGIN period 1 + SAVE head all + SAVE budget all +END period 1 + diff --git a/notebooks/implementing/gwf_twri01/model/gwf_twri01.rcha b/notebooks/implementing/gwf_twri01/model/gwf_twri01.rcha new file mode 100644 index 0000000..67d0b4b --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/gwf_twri01.rcha @@ -0,0 +1,10 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. +BEGIN options + READASARRAYS +END options + +BEGIN period 1 + recharge + CONSTANT 3.00000000E-08 +END period 1 + diff --git a/notebooks/implementing/gwf_twri01/model/gwf_twri01.tdis b/notebooks/implementing/gwf_twri01/model/gwf_twri01.tdis new file mode 100644 index 0000000..fcb767e --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/gwf_twri01.tdis @@ -0,0 +1,13 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. +BEGIN options + TIME_UNITS seconds +END options + +BEGIN dimensions + NPER 1 +END dimensions + +BEGIN perioddata + 86400.00000000 1 1.00000000 +END perioddata + diff --git a/notebooks/implementing/gwf_twri01/model/gwf_twri01.wel b/notebooks/implementing/gwf_twri01/model/gwf_twri01.wel new file mode 100644 index 0000000..7a18d50 --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/gwf_twri01.wel @@ -0,0 +1,26 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. +BEGIN options +END options + +BEGIN dimensions + MAXBOUND 15 +END dimensions + +BEGIN period 1 + 1 9 8 -5.00000000E+00 + 1 9 10 -5.00000000E+00 + 1 9 12 -5.00000000E+00 + 1 9 14 -5.00000000E+00 + 1 11 8 -5.00000000E+00 + 1 11 10 -5.00000000E+00 + 1 11 12 -5.00000000E+00 + 1 11 14 -5.00000000E+00 + 1 13 8 -5.00000000E+00 + 1 13 10 -5.00000000E+00 + 1 13 12 -5.00000000E+00 + 1 13 14 -5.00000000E+00 + 3 4 6 -5.00000000E+00 + 3 6 12 -5.00000000E+00 + 5 5 11 -5.00000000E+00 +END period 1 + diff --git a/notebooks/implementing/gwf_twri01/model/mfsim.lst b/notebooks/implementing/gwf_twri01/model/mfsim.lst new file mode 100644 index 0000000..0660d40 --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/mfsim.lst @@ -0,0 +1,216 @@ + MODFLOW 6 + U.S. GEOLOGICAL SURVEY MODULAR HYDROLOGIC MODEL + VERSION 6.4.1 Release 12/09/2022 + + MODFLOW 6 compiled Dec 09 2022 18:18:37 with Intel(R) Fortran Intel(R) 64 + Compiler Classic for applications running on Intel(R) 64, Version 2021.7.0 + Build 20220726_000000 + +This software has been approved for release by the U.S. Geological +Survey (USGS). Although the software has been subjected to rigorous +review, the USGS reserves the right to update the software as needed +pursuant to further analysis and review. No warranty, expressed or +implied, is made by the USGS or the U.S. Government as to the +functionality of the software and related material nor shall the +fact of release constitute any such warranty. Furthermore, the +software is released on condition that neither the USGS nor the U.S. +Government shall be held liable for any damages resulting from its +authorized or unauthorized use. Also refer to the USGS Water +Resources Software User Rights Notice for complete use, copyright, +and distribution information. + + +As a work of the United States Government, this USGS product is +in the public domain within the United States. You can copy, +modify, distribute, and perform the work, even for commercial +purposes, all without asking permission. Additionally, USGS +waives copyright and related rights in the work worldwide +through CC0 1.0 Universal Public Domain Dedication +(https://creativecommons.org/publicdomain/zero/1.0/). + +The following GNU Lesser General Public License (LGPL) libraries +are used in this USGS product: + + SPARSKIT version 2.0 + ilut, luson, and qsplit + (https://www-users.cse.umn.edu/~saad/software/SPARSKIT/) + + RCM - Reverse Cuthill McKee Ordering + (https://people.math.sc.edu/Burkardt/f_src/rcm/rcm.html) + + BLAS - Basic Linear Algebra Subprograms Level 1 + (https://people.math.sc.edu/Burkardt/f_src/blas1_d/blas1_d.html) + + SPARSEKIT - Sparse Matrix Utility Package + amux, dperm, dvperm, rperm, and cperm + (https://people.sc.fsu.edu/~jburkardt/f77_src/sparsekit/sparsekit.html) + +The following BSD-3 License libraries are used in this USGS product: + + Modern Fortran DAG Library + Copyright (c) 2018, Jacob Williams + All rights reserved. + (https://github.com/jacobwilliams/daglib) + +MODFLOW 6 compiler options: /Isrc\libmf6core.a.p /Isrc /I..\src +/Isrc\libmf6_external.a.p /MTd /nologo /warn:general /warn:truncated_source +/stand:f08 /Zi /traceback /O2 /fpe:0 /heap-arrays:0 /traceback /fpp +/Qdiag-disable:7416 /Qdiag-disable:7025 /Qdiag-disable:5268 +/Fdsrc\libmf6core.a.p\Utilities_compilerversion.F90.pdb +/module:src\libmf6core.a.p +/Fosrc/libmf6core.a.p/Utilities_compilerversion.F90.obj /c + +System command used to initiate simulation: +C:\Users\buckl\Documents\Software\mf6.4.1\bin\mf6.exe + +MODFLOW was compiled using uniform precision. + +Real Variables + KIND: 8 + TINY (smallest non-zero value): 2.225074-308 + HUGE (largest value): 1.797693+308 + PRECISION: 15 + SIZE IN BITS: 64 + +Integer Variables + KIND: 4 + HUGE (largest value): 2147483647 + SIZE IN BITS: 32 + +Long Integer Variables + KIND: 8 + HUGE (largest value): 9223372036854775807 + SIZE IN BITS: 64 + +Logical Variables + KIND: 4 + SIZE IN BITS: 32 + + + OPENED mfsim.nam + FILE TYPE:NAM UNIT 1001 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + # File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. + + READING SIMULATION OPTIONS + END OF SIMULATION OPTIONS + + READING SIMULATION TIMING + + OPENED gwf_twri01.tdis + FILE TYPE:TDIS UNIT 1002 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + TDIS -- TEMPORAL DISCRETIZATION PACKAGE, + VERSION 1 : 11/13/2014 - INPUT READ FROM UNIT 1002 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. + PROCESSING TDIS OPTIONS + SIMULATION TIME UNIT IS SECONDS + END OF TDIS OPTIONS + PROCESSING TDIS DIMENSIONS + 1 STRESS PERIOD(S) IN SIMULATION + END OF TDIS DIMENSIONS + PROCESSING TDIS PERIODDATA + + + STRESS PERIOD LENGTH TIME STEPS MULTIPLIER FOR DELT + ---------------------------------------------------------------------------- + 1 86400.00 1 1.000 + END OF TDIS PERIODDATA + END OF SIMULATION TIMING + + READING SIMULATION MODELS + GWF6 model GWF_TWRI01 will be created as model 1 + END OF SIMULATION MODELS + + READING SIMULATION EXCHANGES + END OF SIMULATION EXCHANGES + + READING SOLUTIONGROUP + + Creating solution: SLN_1 + + OPENED gwf_twri01.ims + FILE TYPE:IMS UNIT 1013 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + END OF SIMULATION SOLUTIONGROUP + +PROCESSING MODEL CONNECTIONS + + IMS -- ITERATIVE MODEL SOLUTION PACKAGE, VERSION 6, 4/28/2017 + INPUT READ FROM UNIT 1013 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. + + PROCESSING IMS OPTIONS + END OF IMS OPTIONS + + PROCESSING IMS NONLINEAR + END OF IMS NONLINEAR DATA + ***UNDER-RELAXATION WILL NOT BE USED*** + + ***IMS LINEAR SOLVER WILL BE USED*** + + IMSLINEAR -- UNSTRUCTURED LINEAR SOLUTION PACKAGE, VERSION 8, 04/28/2017 + + PROCESSING LINEAR DATA + END OF LINEAR DATA + + A symmetric matrix will be solved + + OUTER ITERATION CONVERGENCE CRITERION (DVCLOSE) = 0.100000E-08 + MAXIMUM NUMBER OF OUTER ITERATIONS (MXITER) = 50 + SOLVER PRINTOUT INDEX (IPRIMS) = 0 + NONLINEAR ITERATION METHOD (NONLINMETH) = 0 + LINEAR SOLUTION METHOD (LINMETH) = 1 + + SOLUTION BY THE CONJUGATE-GRADIENT METHOD + ------------------------------------------------------------------ + MAXIMUM OF 50 CALLS OF SOLUTION ROUTINE + MAXIMUM OF 100 INTERNAL ITERATIONS PER CALL TO SOLUTION ROUTINE + LINEAR ACCELERATION METHOD = CG + MATRIX PRECONDITIONING TYPE = INCOMPLETE LU + MATRIX SCALING APPROACH = NO SCALING + MATRIX REORDERING APPROACH = ORIGINAL ORDERING + NUMBER OF ORTHOGONALIZATIONS = 0 + HEAD CHANGE CRITERION FOR CLOSURE = 0.10000E-08 + RESIDUAL CHANGE CRITERION FOR CLOSURE = 0.10000E-05 + RESIDUAL CONVERGENCE OPTION = 1 + RESIDUAL CONVERGENCE NORM = INFINITY NORM S + RELAXATION FACTOR = 0.00000E+00 + + + + + Solving: Stress period: 1 Time step: 1 + +1 + STRESS PERIOD NO. 1, LENGTH = 86400.00 + ----------------------------------------------- + NUMBER OF TIME STEPS = 1 + MULTIPLIER FOR DELT = 1.000 + INITIAL TIME STEP SIZE = 86400.00 + + MEMORY MANAGER TOTAL STORAGE BY DATA TYPE, IN KILOBYTES + ------------------------------- + ALLOCATED + DATA TYPE MEMORY + ------------------------------- + Character 2.9340000 + Logical 4.00000000E-02 + Integer 240.60800 + Real 557.35200 + ------------------------------- + Total 800.93400 + ------------------------------- + + + + Run end date and time (yyyy/mm/dd hh:mm:ss): 2024/01/11 19:47:55 + Elapsed run time: 0.049 Seconds + Normal termination of simulation. diff --git a/notebooks/implementing/gwf_twri01/model/mfsim.nam b/notebooks/implementing/gwf_twri01/model/mfsim.nam new file mode 100644 index 0000000..2dc9af1 --- /dev/null +++ b/notebooks/implementing/gwf_twri01/model/mfsim.nam @@ -0,0 +1,19 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 19:44:43. +BEGIN options +END options + +BEGIN timing + TDIS6 gwf_twri01.tdis +END timing + +BEGIN models + gwf6 gwf_twri01.nam gwf_twri01 +END models + +BEGIN exchanges +END exchanges + +BEGIN solutiongroup 1 + ims6 gwf_twri01.ims gwf_twri01 +END solutiongroup 1 + diff --git a/notebooks/learning/gwf_twri01.ipynb b/notebooks/learning/gwf_twri01.ipynb new file mode 100644 index 0000000..bbc3eca --- /dev/null +++ b/notebooks/learning/gwf_twri01.ipynb @@ -0,0 +1,1851 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Contents\n", + "\n", + "- 1. Load and explore example\n", + "- 2. Check and run simulation\n", + "- 3. Plotting results\n", + "- 4. Breakdown: looking at simulation level packages first\n", + " - 4(a). Temporal Discretization (TDIS) Package\n", + " - 4(b). Iterative Model Solution (IMS)\n", + "- 5. Breakdown: now to look at model level packages\n", + " - 5(a). Structured Discretization (DIS)\n", + " - 5(b). Node Property Flow (NPF) Package\n", + " - 5(c). Initial Conditions (IC) Package\n", + " - 5(d). Constant-Head (CHD) Package\n", + " - 5(e). Drain (DRN) Package\n", + " - 5(f). Well (WEL) Package\n", + " - 5(g). Recharge (RCH) Package\n", + " - 5(h). Output Control (OC)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import flopy as fp\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1. Load and explore example" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loading simulation...\n", + " loading simulation name file...\n", + " loading tdis package...\n", + " loading model gwf6...\n", + " loading package dis...\n", + " loading package npf...\n", + " loading package ic...\n", + " loading package chd...\n", + " loading package drn...\n", + " loading package wel...\n", + " loading package rch...\n", + " loading package oc...\n", + " loading solution package ex-gwf-twri01...\n" + ] + }, + { + "data": { + "text/plain": [ + "sim_name = ex-gwf-twri01\n", + "sim_path = C:\\Users\\buckl\\Documents\\Software\\mf6.4.1\\examples\\ex-gwf-twri01\n", + "exe_name = C:\\Users\\buckl\\Documents\\Software\\mf6.4.1\\bin\\mf6.exe\n", + "\n", + "###################\n", + "Package mfsim.nam\n", + "###################\n", + "\n", + "package_name = mfsim.nam\n", + "filename = mfsim.nam\n", + "package_type = nam\n", + "model_or_simulation_package = simulation\n", + "simulation_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package ex-gwf-twri01.tdis\n", + "###################\n", + "\n", + "package_name = ex-gwf-twri01.tdis\n", + "filename = ex-gwf-twri01.tdis\n", + "package_type = tdis\n", + "model_or_simulation_package = simulation\n", + "simulation_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package ex-gwf-twri01\n", + "###################\n", + "\n", + "package_name = ex-gwf-twri01\n", + "filename = ex-gwf-twri01.ims\n", + "package_type = ims\n", + "model_or_simulation_package = simulation\n", + "simulation_name = ex-gwf-twri01\n", + "\n", + "\n", + "@@@@@@@@@@@@@@@@@@@@\n", + "Model ex-gwf-twri01\n", + "@@@@@@@@@@@@@@@@@@@@\n", + "\n", + "name = ex-gwf-twri01\n", + "model_type = gwf6\n", + "version = mf6\n", + "model_relative_path = \n", + "\n", + "###################\n", + "Package dis\n", + "###################\n", + "\n", + "package_name = dis\n", + "filename = ex-gwf-twri01.dis\n", + "package_type = dis\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package npf\n", + "###################\n", + "\n", + "package_name = npf\n", + "filename = ex-gwf-twri01.npf\n", + "package_type = npf\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package ic\n", + "###################\n", + "\n", + "package_name = ic\n", + "filename = ex-gwf-twri01.ic\n", + "package_type = ic\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package chd_0\n", + "###################\n", + "\n", + "package_name = chd_0\n", + "filename = ex-gwf-twri01.chd\n", + "package_type = chd\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package drn_0\n", + "###################\n", + "\n", + "package_name = drn_0\n", + "filename = ex-gwf-twri01.drn\n", + "package_type = drn\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package wel_0\n", + "###################\n", + "\n", + "package_name = wel_0\n", + "filename = ex-gwf-twri01.wel\n", + "package_type = wel\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package rcha_0\n", + "###################\n", + "\n", + "package_name = rcha_0\n", + "filename = ex-gwf-twri01.rcha\n", + "package_type = rcha\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package oc\n", + "###################\n", + "\n", + "package_name = oc\n", + "filename = ex-gwf-twri01.oc\n", + "package_type = oc\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "workspace = Path(\"C:\\\\Users\\\\buckl\\\\Documents\\\\Software\\\\mf6.4.1\\\\examples\\\\ex-gwf-twri01\")\n", + "sim_name = \"ex-gwf-twri01\"\n", + "sim = fp.mf6.MFSimulation.load(\n", + " sim_name=sim_name,\n", + " version=\"mf6\",\n", + " exe_name=\"C:\\\\Users\\\\buckl\\\\Documents\\\\Software\\\\mf6.4.1\\\\bin\\\\mf6.exe\",\n", + " sim_ws=workspace \n", + ")\n", + "sim" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['ex-gwf-twri01']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim.model_names" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "name = ex-gwf-twri01\n", + "model_type = gwf6\n", + "version = mf6\n", + "model_relative_path = \n", + "\n", + "###################\n", + "Package dis\n", + "###################\n", + "\n", + "package_name = dis\n", + "filename = ex-gwf-twri01.dis\n", + "package_type = dis\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package npf\n", + "###################\n", + "\n", + "package_name = npf\n", + "filename = ex-gwf-twri01.npf\n", + "package_type = npf\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package ic\n", + "###################\n", + "\n", + "package_name = ic\n", + "filename = ex-gwf-twri01.ic\n", + "package_type = ic\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package chd_0\n", + "###################\n", + "\n", + "package_name = chd_0\n", + "filename = ex-gwf-twri01.chd\n", + "package_type = chd\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package drn_0\n", + "###################\n", + "\n", + "package_name = drn_0\n", + "filename = ex-gwf-twri01.drn\n", + "package_type = drn\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package wel_0\n", + "###################\n", + "\n", + "package_name = wel_0\n", + "filename = ex-gwf-twri01.wel\n", + "package_type = wel\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package rcha_0\n", + "###################\n", + "\n", + "package_name = rcha_0\n", + "filename = ex-gwf-twri01.rcha\n", + "package_type = rcha\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n", + "\n", + "###################\n", + "Package oc\n", + "###################\n", + "\n", + "package_name = oc\n", + "filename = ex-gwf-twri01.oc\n", + "package_type = oc\n", + "model_or_simulation_package = model\n", + "model_name = ex-gwf-twri01\n", + "\n" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = sim.model_dict['ex-gwf-twri01']\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_title(\"Map View of Unconfined Aquifer Layer\", fontweight=\"bold\")\n", + "mapview = fp.plot.PlotMapView(model=model, ax=ax)\n", + "mapview.plot_ibound()\n", + "mapview.plot_grid()\n", + "\n", + "chd_bc = mapview.plot_bc(\"CHD\")\n", + "drn_bc = mapview.plot_bc(\"DRN\")\n", + "wel_bc = mapview.plot_bc(\"WEL\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_title(\"Map View of Middle Confined Aquifer Layer\", fontweight=\"bold\")\n", + "mapview = fp.plot.PlotMapView(model=model, ax=ax, layer=2)\n", + "mapview.plot_ibound()\n", + "mapview.plot_grid()\n", + "\n", + "chd_bc = mapview.plot_bc(\"CHD\")\n", + "drn_bc = mapview.plot_bc(\"DRN\")\n", + "wel_bc = mapview.plot_bc(\"WEL\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAGzCAYAAADNKAZOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABTOklEQVR4nO3de1wU9f4/8BcCswvigoCAJCCmqXhDMXHLvKSJRqVlph5TUrOjAUcuPxU7HjQ7JscOiheUUyna92ReOooXFEW8510hMdO8UHRSwFRASRiBz+8PHztnVy6y3sDh9Xw8eLg7856Z13wYljc7M6uFEEKAiIiISGUa1HYAIiIioseBTQ4RERGpEpscIiIiUiU2OURERKRKbHKIiIhIldjkEBERkSqxySEiIiJVYpNDREREqsQmh4iIiFSJTQ49NXr37g0LCwtYWFjg559/ru04D2XVqlXo1KkTbG1tYWFhAQcHh9qORDV0/vx5vPHGG3BxcVGOx6SkJMycOVN5vmLFilrNWJeyPIj33ntPyb9nzx6TeTt27IC/vz8aNWqk1OTn59dKTqr72OSogPELmoWFBfr371+h5sSJEyY1FhYWKC4uroW0pnlHjx5dac327duVmlatWj3hhI/XoUOH8O677+LUqVO4fft2jZYx/r497Q3eg9q5cyeGDRsGT09PaLVauLi4oFu3bvj444+RnZ39RDKUlZXhzTffxObNm3H16tUnss0n6fLly7C0tFSONQcHB5SUlNR2LMXPP/+MQYMG4ejRo7h169YT3/6ePXuUsWnevPkT3z6Zz6q2A9Cjl5aWhl9++QVeXl7KtC+++KIWE5kaMWIEPv74YwDApk2bUFJSAo1GY1Kzbt065fHw4cMBAIsWLUJBQQEAoGnTpk8o7aOXnJwMw38Z9+c//xkjR46EtbV1Laequ+7cuYNx48bh//7v/0ymX716FVevXsWxY8dw48YNxMXFPfYsWVlZ+OGHHwAArVq1Qnx8PGxsbODj44MuXbqgX79+AIDnnnvusWd5HNasWYPy8nLleUFBAbZt24bBgwc/0Rx//etf8f777wMAOnTooEzfuXOn8sfZ4MGDERYWBktLSzRq1OiJ5qOnB5scFSovL8eyZcswa9YsAEBRURFWrVpVy6n+p3Xr1vD19UVGRgYKCgqwfft2vPHGG8r80tJSbNiwQXluaHKMX+yeZpcvX1YeDxs2DC+99FItpql9RUVFaNiwYZXzw8PDlQanQYMGGD9+PF577TVotVpkZmY+0dMxxt87vV6PV155RXnu6OgIT0/PJ5blcfjmm28qTFu9evUTb3JatWpV6Tu4xuP/xhtvoFevXo9823/88QdsbW0f+Xrrkvv9zKmKoKfejBkzBAABQDRq1EgAEM2aNRNlZWVCCCGWLVtmMs/wdfv2bWUdERERQq/XCzc3NyFJkmjYsKHo3Lmz+Oyzz8SdO3dMtmdY3svLS/z0008iMDBQNGzYUDg5OYkPP/xQ3Lp1676Z//GPfyjrGTlypMm8lJQUZV6HDh2U6b169VKmZ2VlmSyTlJQk+vbtKxwcHIQkSeK5554TM2fOFH/88YdSs3DhQmX5L774Qpn+4osvKvtjsHXrVqV2ypQp992fK1euiNDQUNGiRQshSZKwt7cXvXr1EmvXrlVqsrKyTMbf+KtXr17Vrt+49t59v1dBQYH46KOPRJs2bYRWqxV2dnaiW7duIiEhQZSXlyt1b731lrLO8+fPCyGE+OOPP4S1tbUAIIKCgpTaKVOmKLVbt25Vpufl5Ynw8HDRsmVLIUmScHBwEK+++qo4dOiQSabdu3crywcFBYn//Oc/olOnTkKSJDFjxowq9+XHH38UDRo0UJZdtGhRhZry8nJx9uxZk2lpaWni1VdfFU5OTsLa2lo0a9ZMBAUFiZ9++smkzvhnZ/ny5WL+/Pni2WefFZIkiY4dO4q0tDSl1vj4u/crKyvLZF2JiYnKcl5eXsr0K1euiHfffVc4ODgIOzs78c4774hr165V2KeaHM8Ga9asET4+PkKj0Yh27dqJNWvWVJmlOhcuXFCWefHFF4WHh4cAIGxtbSv9mc7LyxPvvvuu0Ol0wt7eXowaNUpcvXrV5PWhsnE2znPvcWEQFBSkTN+9e7cQQlQ59sbbuXTpknj//feFp6enkCRJNGnSRLzzzjvizJkzJtkTExOV5WfMmCGWLl0qnnvuOWFlZVXteBnnNd5uZTZs2CBef/110bx5c2FnZyesra2Fp6eneO+995Sf4fPnzyvr69mzp8ny165dE5aWlgKAaN++vTK9vLxcLF++XLzwwguiUaNGQqvVio4dO4q4uDjlNd/A+Nj75ZdfxFtvvSV0Op1o3rx5tdnVhE2OChi/gLz33nvKL6nk5GQhhBD+/v4CgPjggw+qbHI0Gk2VLyJjxowx2Z5huoODg3B1da1QP2DAgPtm/uWXX4SFhYXSfBUXFyvzxo4dq6xr9uzZyvSqmpy//e1vVWZ/6aWXRElJiRBCiPT0dGX6uHHjhBBCyLIstFqtMv3y5csV1rlly5Zq9+XSpUvCzc2tygxTp04VQjyZJuf69euiTZs2VW5n+PDhSu38+fOV6f/3f/8nhBBi3759yrTnnntOqX3ppZcEANGgQQNRUFAghLj7PWzWrFml27G2thYbN25Uljf+5eDt7a187w2/ZKoya9Yspa5ly5aitLS02nESQoj4+HiT9Rt/NWrUSBw9elSpNf7ZadGiRaX1169fF0I8miansm3c2+TX9HgWQoi1a9dWuq8dO3asNEt1/v73vyvLLFiwQISFhSnPV61aZVJbUlIiOnXqVGG7xtOedJNz4sQJ4eDgUGmNnZ2dOHLkiLJ+4ybn3u/Jo2py/vznP1eZ2dXVVeTm5goh/ndcWVhYiF9++UVZ/quvvlLqP/30U2X66NGjq1zvsGHDTDJUdezdL7uasMlRAeMXkKlTp4o333xTABBvvvmmOHXqlDLv6NGjJj8Qxk3OrFmzxDfffCNSUlLEnj17xPr165XmyMLCQvz6669KrfE6/Pz8RFJSkli0aJGwtbVVpm/atOm+uV944QWlfsOGDUIIIe7cuSMcHR2V6RcvXlTqK2tyjPepadOmYtmyZSIlJUUEBgYq02NiYoQQQpSVlQl7e3sBQPj4+AghhDhy5IjJ/nz77bdCCCH69u0rgLu/1G/cuFHtfgwYMEBZvnfv3mLTpk1i3rx5Js3T4cOHRXFxsdi/f78YOHCgMn3hwoVi//794tSpU9Vu495fqFWZMGGCUtehQwexfv168eWXX4rGjRsr01evXi2EuPtLwTDtww8/FEKYvsMGQPz+++9ClmVhY2MjAIjOnTsr2zIe49GjR4uUlBSxdOlSYWdnJwAIJycn5R0A418OAMTzzz8v1q1bJ5KSksTOnTur3J8hQ4Yoy4waNaraMRJCiOzsbCFJkvK9mz59ukhOThZDhw5V1uPj46O8o2X8s2P4+dm0aZPJL+vFixcLIYQ4deqUybuBAwcOFPv37xf79+8XxcXFNWpymjZtKv7973+LJUuWKDktLS1Ffn6+EMK847m0tFQ888wzyvThw4eL5ORkER4eXuNf2sbatWun/Lz/97//FQcOHFDW8cYbb5jULl26VJnn5OQkli9fLtatW1flL9JH0eTs379fjBkzRpn+0Ucfif3794tjx46J8vJy0b59e2VeZGSk2LFjh/jHP/6hvBti/H03bnIAiICAAJGUlCTWrl1r0gTfy5wm5z//+Y/417/+JTZv3iz27NkjUlJSRGRkpLK84Q8442bG8L0VQoi3335bmX7p0iUhhBDr1q1TprVu3Vp88803YvPmzaJ79+4Vfr6FMD32GjZsKObNmyd27Ngh/vWvf1WbXU3Y5KjAvU1OcnKyAO7+Nf3OO+8I4O5fdkKY/rI0bnIOHDggBg0aJNzc3ISVlZVJHQCTv8qNpxtOcwghxF//+ldl+tixY++be9GiRUr9iBEjhBBCbNu2TZnWrVs3k/rKmpxJkyZVeNHbv3+/2Lx5szLd+K3eV199VXkhv3HjhoiLixMAlBf4yMhIUVZWppzaM4xbVa5du6b8Ja3RaMTvv/+uzDN+QZs0aZIyvbIX8PupSZNTVlZm0sxkZmYq84zHetCgQUKIu78kdTqdSfMyePBgk/HYvHmzyS/ev/zlLxX2283NTRn3/fv3K0028L+m0fiXg52dXaWnaCrTr18/k2P7fubNm6fUDxkyRJkuy7LJu23p6elCCNOfHcO4CCHE6tWrlelhYWHK9Kp+Kd+7rqqaHEMzL4Rpc5yRkSGEMO94Nm7Q3d3dTU4rG07B1rTJyczMVOr1er0Q4u5pEXd3dwFASJJk0uwbN+rx8fHK9NTU1MfW5FS3HuN3aX19fU2OR71er8w7fvy4EMK0yfHy8qpwSr4q5jQ5165dExEREaJ169bKHwnGX2+++aYQ4u4pYsMfX4bT8yUlJcprUPfu3ZV1Dho0SFne8AfS/v37xRdffKFMf+2115R642Pv888/r9E+qg0vPFahAQMGwMPDA7/++ivWrl0LABg/fnyV9UePHkWfPn1w586dKmsq+xwKR0dHtGzZUnnerVs35fGlS5fum3Po0KEICwtDWVkZNm/ejOLi4krvqqrOTz/9pDz+9NNP8emnn1aoOXv2rPK4Z8+e2Lp1K4QQOHLkCA4dOgQACAsLw/jx43Hw4EFkZmbi5s2bAHDfi4LPnz+v3Cn17LPPwsnJSZlnPB7GOR+Xq1ev4saNGwAAW1tbtG/fvtoslpaWeOGFF5CSkoJTp06hqKgIhw4dgiRJ+PDDDxEcHIyDBw/C1dVVWdYwHhcuXFD2Oycnp8px+vHHHytMe/HFF+Ho6FijfbK3t1ceG190WhXjcfb391ceW1tbo3Pnzti2bZtS5+vra7Ks8UWsxt/HR/kZLPfbhjnHs/HPmK+vL6ys/vdy3q1bN3z33Xc1zmV8wfHbb78N4O7HFgwZMgSLFi2CLMtYv349xo4dW2Hbzz//vMl2a4PxuGVkZFR7PPr5+ZlMGzBggMnYPQplZWXo168f0tPTq6wxfM9tbGwwYsQIJCQkIDMzE5mZmbhy5YryGjRixAhlGeP9/Mtf/lLpeiv7mQOA119/3dzdUAV+To4KNWjQAGPGjFGea7VavPvuu1XWJyQkKA3Oa6+9hq1bt2L//v0mn2FjfFtpVSwsLMzK6erqij59+gAAbt26hY0bNyIpKUnZh3feeces9VWltLRU+ayPnj17KtMPHTqEQ4cOwdLSEsOHD4eLiwtOnjxp8uFjD3Pnk7nj8Sjdu+2qshjGo6ysDGvWrEFubi46d+6sfF8MY2Rg7ngUFRVVmGbcNN1Pp06dlMeHDx9GWVmZWds3dr/vR+PGjZXHxr/0DM3co/AotmF8PFfF3GNvzZo1yuPIyEjls2AWLVqkTF+9evV911PVdo2nG38Pf//9d7NyPqyHPR5r6rvvvlManKZNm2LlypXYt2+fSTNp/Jo6btw45fG///1vbNq0CcDdP0SGDRtm1rYr20fg8ezn04BNjkqNHTsWDRrc/fYOGTKk2k/U/e2335THc+bMwcCBA9GjRw/k5uZWu43r16/jwoULyvMjR44oj1u0aFGjnMZ/pUyePBnXr18HcPeX6TPPPHPf5Y0/jyQxMRHi7ilYk6+ioiLlc3i6du0KGxsbAMD69euRnZ2NDh06wM7ODnq9HiUlJVi6dKmyTuOmqDItW7ZUXsAvXryIa9euKfOMx+NJfG5KkyZNlO9zUVGR8nku1WUxblrmz58P4O6t0W3atIGDgwOOHTumvCPw3HPPKS+Uxvv97LPPorS0tMK4y7KsfIyBMXN+AQ8dOlQ5js+fP4/PP/+8Qo0QAufOnauwb0ePHlUe37lzx+Sv6rr6OTbmHM/GP2MZGRkmzYPx9/t+jh49iosXL963bteuXcjLywNg+vN9/Pjx+27X+B25nJwc5XFKSkqNc1bHeNx69epV5bj9+c9/rrDs4/hjxPg19U9/+hNGjx5d7R8IXbt2RceOHQHcfVdt8+bNAIA+ffqYNCfG+7l79+5K97Oq72Vt/tFVm3i6SqW8vLwQHx+PnJwc5e3n6moN5syZg6CgIGzbtg3bt2+/73b+9Kc/Yfr06fjvf/9r8mFsgwYNqlHOt956CxMnToQsy/j111+V6TU5VWXY/oIFCwDc/TyV69evo2PHjsjPz8fFixexY8cOeHl5Yfny5QDunrbo3r07du/ejczMTAB3f6kb/t24caPyC/PZZ5+974cOOjk5ISAgACkpKSgpKcE777yD8PBwXLx4EUuWLFHqjJu5h/WPf/zD5JcGAPj5+WHo0KEYPnw4EhISAAAjR47EjBkzcOPGDcyYMaPSLN26dYNWq0VxcTFOnz4N4O44WFhYoHv37khJSVH+MjR+kXZ0dMTAgQOxdetWXLx4EW+88QbGjRuHRo0a4ZdffkF6ejrWr1+PQ4cOPdQnw7Zp0wYTJ05EfHw8ACA0NBSZmZkIDAyERqPB6dOnkZiYiD59+iAuLg5vv/02pk6dijt37mD9+vWYMWMGunfvjpUrV+LKlSsAAB8fH5N3iOoSc45nPz8/PPPMM/jtt99w+fJljB49Gu+++y7S0tIe+FTVsGHD0KNHD5P5SUlJSEtLQ1lZGdatW4fg4GC88cYbyqm/6Oho2NjYwM7ODtOmTat0G8antefNmwc7OztcuHBB+bl8WJ06dUL79u1x+vRp7N27F6NHj8bQoUNhbW2Nn3/+GUePHsWGDRuU07mPwo0bNxAVFVVh+tChQ01eU//zn/+gR48eVdYbjBs3DpMmTTJ5Hbz3dWPkyJHYuHEjAGDUqFH461//ilatWuHq1as4f/48kpOTMXDgQJOf93rvSVz4Q4/XvRceVwdGF74ZLjw+cuRIhdtQLSwsTC7YM77IzzDN0dGx0luIX3nlFZPPY7mfN954w2R5KysrcfXq1Qp1D3ILOSq5QDQ6Otpk/ldffSWEEGLv3r0m0997770a5b948WKNbiE3eNgLj6vbx2vXrt33FvJ7vzc9e/Y0qcnOzhZCCPHxxx+bTF+xYoXJctXdQn7v96m6C3bvR5ZlMWrUqGq3Y3xh94PeQl6TC2If9sJjY1UdB+Ycz998802lNS1btqw0y73KysqUi4sB04vVDZKSkpT5PXr0EEJUfQu58a3rxhfmyrIsPD09K9S3bdu20v0y98JjIaq/hfze8b/3c3Jq6t67BCv7SkxMFKWlpSZjYfgyviD83o+NuHbtmslHedx7sbdBdbeQ37s/VR179QlPVxG6deuGDRs2oEOHDtBqtWjXrh3WrVtX6f+BZaxRo0bYv38/Xn/9dTRs2BCOjo6YMGEC1q9fb9Zbo/f+tdK3b184OzvXePlZs2Zhy5YtGDBgAJycnGBtbY1nnnkGPXr0QExMjPJfSBjcewrK8E5O165dTa6TqOn1Jy1atMDJkycREhICb29vWFtbQ6fToWfPnlizZg1iYmJqvC8Py9HREYcPH8a0adPQunVraDQaNGzYEM8//zyWLl2KVatWVfjeGI/HM888Aw8PDwD/GxeDe8fD09MT6enpmDx5Mtq0aQOtVotGjRqhTZs2GD16NDZt2qSs62FYW1vjq6++wo4dOzB06FA0a9YMkiTByckJXbp0wd/+9jdEREQo9R9++CFSU1MxcOBAODo6wsrKCu7u7hg9ejROnDhhcqFsXWTO8Tx8+HB88803aNu2LSRJQuvWrbF8+XKMHDmyRtvat2+fckG3t7e3ycXqBq+88gq0Wi2Au9ea/Prrr5AkCampqRg5ciR0Oh10Oh1GjBiBnTt3Vroda2trJCUlQa/XQ5IkNGvWDB9//DEWLlxo7vBUqUuXLsjIyMCECRPQokULSJIEBwcHtG/fHhMmTEBaWtoj29b9WFpaIjk5GYMGDYK9vT2aNGmCSZMm4csvv6xyGUdHR5NPlh44cGCllxmsXLkSX331FXr16gV7e3tIkgRPT0/07dsXCxcuxIcffvgY9ujpZSHEI7yqjuoFwy9JLy+vevufRRJR5fj68OC++uorBAUFAbh7MfijuvmiPuM1OURERLXojz/+wLVr15CYmAgAcHBwqLe3fD9qbHKIiIhqkY+PD3755Rfl+eTJk5W7QOnhsMkhIiKqA5o2bYqxY8dWexcWmYfX5BAREZEq8e4qIiIiUiU2OURERKRK9fqanPLycly+fBmNGjWqtx95TURE9LQRQuDmzZtwd3dX/uuXytTrJufy5cuP5MPKiIiI6Mn79ddf0axZsyrn1+smp1GjRgCAs2fPwsnJ6YlvX5Zl5X/5DQ0NhSRJzMAMzMAMzMAMdTJDXckhyzL++c9/Yv78+crv8arU6ybHcIrKycnJrP9G4FGRZVn5uHRnZ+daO1iYgRmYgRmYgRmelhyyLEOj0QC4//+uzguPiYiISJXY5BAREZEqsckhIiIiVWKTQ0RERKrEJoeIiIhUiU0OERERqRKbHCIiIlIlNjlERESkSmxyiIiISJXY5BAREZEqsckhIiIiVWKTQ0RERKrEJoeIiIhUiU0OERERqRKbHCIiIlIlNjlERESkSmxyiIiISJXManKaN28OCwuLCl/BwcEAgOLiYgQHB8PJyQl2dnYYMmQIcnNzTdaRnZ2NwMBA2NrawsXFBZMnT0ZpaalJzZ49e9ClSxdoNBq0bNkSK1asqJAlPj4ezZs3h1arhb+/P44ePWrmrhMREZGamdXkHDt2DFeuXFG+UlNTAQBDhw4FAISHh2Pz5s1Yt24d9u7di8uXL+Ott95Sli8rK0NgYCBkWcbBgwexcuVKrFixAtHR0UpNVlYWAgMD0adPH2RkZCAsLAzvv/8+tm/frtSsWbMGERERmDFjBk6ePIlOnTohICAAeXl5DzUYREREpB5W5hQ3adLE5HlMTAyeffZZ9OrVCwUFBVi2bBlWrVqFl19+GQCQmJiItm3b4vDhw+jevTt27NiBM2fOYOfOnXB1dYWvry8++eQTTJ06FTNnzoQkSUhISIC3tzdiY2MBAG3btsWBAwcwf/58BAQEAADmzZuH8ePHY8yYMQCAhIQEJCcnY/ny5YiKijJ7EGRZhizLZi/3sIy3WRvbZwZmYAZmYAZmeNpymLNdCyGEeNCNuLu7IyIiAh999BF27dqFvn374saNG3BwcFDqvLy8EBYWhvDwcERHR2PTpk3IyMhQ5mdlZaFFixY4efIkOnfujJ49e6JLly6Ii4tTahITExEWFoaCggLIsgxbW1t8++23GDx4sFITFBSE/Px8bNy4scrMJSUlKCkpUZ4XFhbCw8MDUVFR0Gq1DzIMRERE9IQVFxcjJiYGBQUF0Ol0VdY98IXHSUlJyM/Px3vvvQcAyMnJgSRJJg0OALi6uiInJ0epcXV1rTDfMK+6msLCQty+fRu///47ysrKKq0xrKMqc+bMgb29vfLl4eFh1j4TERHR08Os01XGli1bhoEDB8Ld3f1R5nmspk2bhoiICOW54Z2c0NBQODs7P/E8siwrp+UiIyMhSRIzMAMzMAMzMEOdzFBXcsiyjNmzZ9eo9oGanF9++QU7d+7E+vXrlWlubm6QZRn5+fkm7+bk5ubCzc1Nqbn3LijD3VfGNffekZWbmwudTgcbGxtYWlrC0tKy0hrDOqqi0Wig0WgqTJckqdYOGGZgBmZgBmZghqctQ13KUZ0HOl2VmJgIFxcXBAYGKtP8/PxgbW2NtLQ0Zdq5c+eQnZ0NvV4PANDr9cjMzDS5Cyo1NRU6nQ4+Pj5KjfE6DDWGdUiSBD8/P5Oa8vJypKWlKTVEREREZr+TU15ejsTERAQFBcHK6n+L29vbY9y4cYiIiICjoyN0Oh1CQ0Oh1+vRvXt3AED//v3h4+ODUaNGYe7cucjJycH06dMRHBysvMMyYcIELF68GFOmTMHYsWOxa9curF27FsnJycq2IiIiEBQUhK5du6Jbt26Ii4tDUVGRcrcVERERkdlNzs6dO5GdnY2xY8dWmDd//nw0aNAAQ4YMQUlJCQICArBkyRJlvqWlJbZs2YKJEydCr9ejYcOGCAoKwqxZs5Qab29vJCcnIzw8HAsWLECzZs3w5ZdfKrePA8CwYcNw9epVREdHIycnB76+vkhJSalwMTIRERHVX2Y3Of3790dVd51rtVrEx8cjPj6+yuW9vLywdevWarfRu3dvpKenV1sTEhKCkJCQ+wcmIiKieon/dxURERGpEpscIiIiUiU2OURERKRKbHKIiIhIldjkEBERkSqxySEiIiJVYpNDREREqsQmh4iIiFSJTQ4RERGpEpscIiIiUiU2OURERKRKbHKIiIhIldjkEBERkSqxySEiIiJVYpNDREREqsQmh4iIiFTJqrYD1AWyLEOW5VrZbmWPmYEZmIEZmIEZ6lqGupLDnO1aCCHEY8xSpxUWFsLe3h5RUVHQarW1HYeIiIhqoLi4GDExMSgoKIBOp6uyjqeriIiISJV4ugpAaGgonJ2dn/h2ZVlGbGwsACAyMhKSJDEDMzADMzADM9TJDHUlhyzLmD17do1q2eQAkCSp1g4YZmAGZmAGZmCGpy1DXcpRHZ6uIiIiIlVik0NERESqxCaHiIiIVIlNDhEREakSmxwiIiJSJTY5REREpEpscoiIiEiV2OQQERGRKrHJISIiIlVik0NERESqxCaHiIiIVIlNDhEREakSmxwiIiJSJTY5REREpEpscoiIiEiV2OQQERGRKrHJISIiIlVik0NERESqZHaT89tvv+Hdd9+Fk5MTbGxs0KFDBxw/flyZL4RAdHQ0mjZtChsbG/Tr1w/nz583Wcf169cxcuRI6HQ6ODg4YNy4cbh165ZJzalTp/DSSy9Bq9XCw8MDc+fOrZBl3bp1aNOmDbRaLTp06ICtW7eauztERESkUmY1OTdu3MCLL74Ia2trbNu2DWfOnEFsbCwaN26s1MydOxcLFy5EQkICjhw5goYNGyIgIADFxcVKzciRI/HDDz8gNTUVW7Zswb59+/DBBx8o8wsLC9G/f394eXnhxIkT+OyzzzBz5kx8/vnnSs3BgwcxYsQIjBs3Dunp6Rg8eDAGDx6M06dPP8x4EBERkUpYmVP8j3/8Ax4eHkhMTFSmeXt7K4+FEIiLi8P06dMxaNAgAMBXX30FV1dXJCUlYfjw4fjxxx+RkpKCY8eOoWvXrgCARYsW4dVXX8U///lPuLu74+uvv4Ysy1i+fDkkSUK7du2QkZGBefPmKc3QggULMGDAAEyePBkA8MknnyA1NRWLFy9GQkKCWYMgyzJkWTZrmUfBeJu1sX1mYAZmYAZmYIanLYc527UQQoiaFvv4+CAgIAD//e9/sXfvXjzzzDP48MMPMX78eADApUuX8OyzzyI9PR2+vr7Kcr169YKvry8WLFiA5cuXIzIyEjdu3FDml5aWQqvVYt26dXjzzTcxevRoFBYWIikpSanZvXs3Xn75ZVy/fh2NGzeGp6cnIiIiEBYWptTMmDEDSUlJ+P777yvNX1JSgpKSEuV5YWEhPDw8EBUVBa1WW9NhICIiolpUXFyMmJgYFBQUQKfTVVln1umqS5cuYenSpWjVqhW2b9+OiRMn4i9/+QtWrlwJAMjJyQEAuLq6mizn6uqqzMvJyYGLi4vJfCsrKzg6OprUVLYO421UVWOYX5k5c+bA3t5e+fLw8DBn94mIiOgpYtbpqvLycnTt2hWffvopAKBz5844ffo0EhISEBQU9FgCPkrTpk1DRESE8tzwTk5oaCicnZ2feB5ZlhEbGwsAiIyMhCRJzMAMzMAMzMAMdTJDXckhyzJmz55do1qzmpymTZvCx8fHZFrbtm3xn//8BwDg5uYGAMjNzUXTpk2VmtzcXOX0lZubG/Ly8kzWUVpaiuvXryvLu7m5ITc316TG8Px+NYb5ldFoNNBoNBWmS5JUawcMMzADMzADMzDD05ahLuWojlmnq1588UWcO3fOZNpPP/0ELy8vAHcvQnZzc0NaWpoyv7CwEEeOHIFerwcA6PV65Ofn48SJE0rNrl27UF5eDn9/f6Vm3759uHPnjlKTmpqK1q1bK3dy6fV6k+0YagzbISIiovrNrCYnPDwchw8fxqeffooLFy5g1apV+PzzzxEcHAwAsLCwQFhYGP7+979j06ZNyMzMxOjRo+Hu7o7BgwcDuPvOz4ABAzB+/HgcPXoU3333HUJCQjB8+HC4u7sDAP70pz9BkiSMGzcOP/zwA9asWYMFCxaYnGqaNGkSUlJSEBsbi7Nnz2LmzJk4fvw4QkJCHtHQEBER0dPMrNNVzz//PDZs2IBp06Zh1qxZ8Pb2RlxcHEaOHKnUTJkyBUVFRfjggw+Qn5+PHj16ICUlxeTupa+//hohISHo27cvGjRogCFDhmDhwoXKfHt7e+zYsQPBwcHw8/ODs7MzoqOjTT5L54UXXsCqVaswffp0fPTRR2jVqhWSkpLQvn37hxkPIiIiUgmzmhwAeO211/Daa69VOd/CwgKzZs3CrFmzqqxxdHTEqlWrqt1Ox44dsX///mprhg4diqFDh1YfmIiIiOol/t9VREREpEpscoiIiEiV2OQQERGRKrHJISIiIlVik0NERESqxCaHiIiIVIlNDhEREakSmxwiIiJSJTY5REREpEpscoiIiEiV2OQQERGRKrHJISIiIlVik0NERESqxCaHiIiIVIlNDhEREamSVW0HqAtkWYYsy7Wy3coeMwMzMAMzMAMz1LUMdSWHOdu1EEKIx5ilTissLIS9vT2ioqKg1WprOw4RERHVQHFxMWJiYlBQUACdTldlHU9XERERkSrxdBWA0NBQODs7P/HtyrKM2NhYAEBkZCQkSWIGZmAGZqibGebOhXTnzpPPYG2N2ClT7maoC+NQjzPUlRyyLGP27Nk1qmWTA0CSpFo7YJiBGZiBGZ6KDHfu1EqTY5KhLowDM9S5HNXh6SoiIiJSJTY5REREpEpscoiIiEiV2OQQERGRKrHJISIiIlVik0NERESqxCaHiIiIVIlNDhEREakSmxwiIiJSJTY5REREpEpscoiIiEiV2OQQERGRKrHJISIiIlVik0NERESqxCaHiIiIVIlNDhEREakSmxwiIiJSJTY5REREpEpmNTkzZ86EhYWFyVebNm2U+cXFxQgODoaTkxPs7OwwZMgQ5ObmmqwjOzsbgYGBsLW1hYuLCyZPnozS0lKTmj179qBLly7QaDRo2bIlVqxYUSFLfHw8mjdvDq1WC39/fxw9etScXSEiIiKVM/udnHbt2uHKlSvK14EDB5R54eHh2Lx5M9atW4e9e/fi8uXLeOutt5T5ZWVlCAwMhCzLOHjwIFauXIkVK1YgOjpaqcnKykJgYCD69OmDjIwMhIWF4f3338f27duVmjVr1iAiIgIzZszAyZMn0alTJwQEBCAvL+9Bx4GIiIhUxsrsBays4ObmVmF6QUEBli1bhlWrVuHll18GACQmJqJt27Y4fPgwunfvjh07duDMmTPYuXMnXF1d4evri08++QRTp07FzJkzIUkSEhIS4O3tjdjYWABA27ZtceDAAcyfPx8BAQEAgHnz5mH8+PEYM2YMACAhIQHJyclYvnw5oqKizB4EWZYhy7LZyz0s423WxvaZgRmYgRlqnMHaunYyGG23ToxDPc5QV3KYs10LIYSoafHMmTPx2Wefwd7eHlqtFnq9HnPmzIGnpyd27dqFvn374saNG3BwcFCW8fLyQlhYGMLDwxEdHY1NmzYhIyNDmZ+VlYUWLVrg5MmT6Ny5M3r27IkuXbogLi5OqUlMTERYWBgKCgogyzJsbW3x7bffYvDgwUpNUFAQ8vPzsXHjxirzl5SUoKSkRHleWFgIDw8PREVFQavV1nQYiIiIqBYVFxcjJiYGBQUF0Ol0VdaZdbrK398fK1asQEpKCpYuXYqsrCy89NJLuHnzJnJyciBJkkmDAwCurq7IyckBAOTk5MDV1bXCfMO86moKCwtx+/Zt/P777ygrK6u0xrCOqsyZMwf29vbKl4eHhzm7T0RERE8Rs05XDRw4UHncsWNH+Pv7w8vLC2vXroWNjc0jD/eoTZs2DREREcpzwzs5oaGhcHZ2fuJ5ZFlWTstFRkZCkiRmYAZmYAZmYIY6maGu5JBlGbNnz65RrdnX5BhzcHDAc889hwsXLuCVV16BLMvIz883eTcnNzdXuYbHzc2twl1QhruvjGvuvSMrNzcXOp0ONjY2sLS0hKWlZaU1lV0rZEyj0UCj0VSYLklSrR0wzMAMzMAMzMAMT1uGupSjOg/1OTm3bt3CxYsX0bRpU/j5+cHa2hppaWnK/HPnziE7Oxt6vR4AoNfrkZmZaXIXVGpqKnQ6HXx8fJQa43UYagzrkCQJfn5+JjXl5eVIS0tTaoiIiIjManL+3//7f9i7dy9+/vlnHDx4EG+++SYsLS0xYsQI2NvbY9y4cYiIiMDu3btx4sQJjBkzBnq9Ht27dwcA9O/fHz4+Phg1ahS+//57bN++HdOnT0dwcLDyDsuECRNw6dIlTJkyBWfPnsWSJUuwdu1ahIeHKzkiIiLwxRdfYOXKlfjxxx8xceJEFBUVKXdbEREREZl1uuq///0vRowYgWvXrqFJkybo0aMHDh8+jCZNmgAA5s+fjwYNGmDIkCEoKSlBQEAAlixZoixvaWmJLVu2YOLEidDr9WjYsCGCgoIwa9Yspcbb2xvJyckIDw/HggUL0KxZM3z55ZfK7eMAMGzYMFy9ehXR0dHIycmBr68vUlJSKlyMTERERPWXWU3O6tWrq52v1WoRHx+P+Pj4Kmu8vLywdevWatfTu3dvpKenV1sTEhKCkJCQamuIiIio/uL/XUVERESqxCaHiIiIVIlNDhEREakSmxwiIiJSJTY5REREpEpscoiIiEiV2OQQERGRKrHJISIiIlVik0NERESqxCaHiIiIVIlNDhEREakSmxwiIiJSJTY5REREpEpscoiIiEiV2OQQERGRKrHJISIiIlWyqu0AdYEsy5BluVa2W9ljZmAGZmAGZmCGupahruQwZ7sWQgjxGLPUaYWFhbC3t0dUVBS0Wm1txyEiIqIaKC4uRkxMDAoKCqDT6aqs4+kqIiIiUiWergIQGhoKZ2fnJ75dWZYRGxsLAIiMjIQkSczADMzADMzADHUyQ13JIcsyZs+eXaNaNjkAJEmqtQOGGZiBGZiBGZjhactQl3JUh6eriIiISJXY5BAREZEqsckhIiIiVWKTQ0RERKrEJoeIiIhUiU0OERERqRKbHCIiIlIlNjlERESkSmxyiIiISJXY5BAREZEqsckhIiIiVWKTQ0RERKrEJoeIiIhUiU0OERERqRKbHCIiIlIlNjlERESkSmxyiIiISJUeqsmJiYmBhYUFwsLClGnFxcUIDg6Gk5MT7OzsMGTIEOTm5posl52djcDAQNja2sLFxQWTJ09GaWmpSc2ePXvQpUsXaDQatGzZEitWrKiw/fj4eDRv3hxarRb+/v44evTow+wOERERqcgDNznHjh3Dv/71L3Ts2NFkenh4ODZv3ox169Zh7969uHz5Mt566y1lfllZGQIDAyHLMg4ePIiVK1dixYoViI6OVmqysrIQGBiIPn36ICMjA2FhYXj//fexfft2pWbNmjWIiIjAjBkzcPLkSXTq1AkBAQHIy8t70F0iIiIiFbF6kIVu3bqFkSNH4osvvsDf//53ZXpBQQGWLVuGVatW4eWXXwYAJCYmom3btjh8+DC6d++OHTt24MyZM9i5cydcXV3h6+uLTz75BFOnTsXMmTMhSRISEhLg7e2N2NhYAEDbtm1x4MABzJ8/HwEBAQCAefPmYfz48RgzZgwAICEhAcnJyVi+fDmioqLM2h9ZliHL8oMMxUMx3mZtbJ8ZmIEZmIEZmOFpy2HOdi2EEMLcDQQFBcHR0RHz589H79694evri7i4OOzatQt9+/bFjRs34ODgoNR7eXkhLCwM4eHhiI6OxqZNm5CRkaHMz8rKQosWLXDy5El07twZPXv2RJcuXRAXF6fUJCYmIiwsDAUFBZBlGba2tvj2228xePBgk1z5+fnYuHFjpblLSkpQUlKiPC8sLISHhweioqKg1WrNHQYiIiKqBcXFxYiJiUFBQQF0Ol2VdWa/k7N69WqcPHkSx44dqzAvJycHkiSZNDgA4OrqipycHKXG1dW1wnzDvOpqCgsLcfv2bdy4cQNlZWWV1pw9e7bK7HPmzMHHH39csx0lIiKip5pZTc6vv/6KSZMmITU19al852PatGmIiIhQnhveyQkNDYWzs/MTzyPLsnJKLjIyEpIkMQMzMAMzMAMz1MkMdSWHLMuYPXt2jWrNanJOnDiBvLw8dOnSRZlWVlaGffv2YfHixdi+fTtkWUZ+fr7Juzm5ublwc3MDALi5uVW4C8pw95Vxzb13ZOXm5kKn08HGxgaWlpawtLSstMawjspoNBpoNJoK0yVJqrUDhhmYgRmYgRmY4WnLUJdyVMesu6v69u2LzMxMZGRkKF9du3bFyJEjlcfW1tZIS0tTljl37hyys7Oh1+sBAHq9HpmZmSZ3QaWmpkKn08HHx0epMV6HocawDkmS4OfnZ1JTXl6OtLQ0pYaIiIjqN7PeyWnUqBHat29vMq1hw4ZwcnJSpo8bNw4RERFwdHSETqdDaGgo9Ho9unfvDgDo378/fHx8MGrUKMydOxc5OTmYPn06goODlXdZJkyYgMWLF2PKlCkYO3Ysdu3ahbVr1yI5OVnZbkREBIKCgtC1a1d069YNcXFxKCoqUu62IiIiovrtgW4hr878+fPRoEEDDBkyBCUlJQgICMCSJUuU+ZaWltiyZQsmTpwIvV6Phg0bIigoCLNmzVJqvL29kZycjPDwcCxYsADNmjXDl19+qdw+DgDDhg3D1atXER0djZycHPj6+iIlJaXCxchERERUPz10k7Nnzx6T51qtFvHx8YiPj69yGS8vL2zdurXa9fbu3Rvp6enV1oSEhCAkJKTGWYmIiKj+4P9dRURERKrEJoeIiIhUiU0OERERqRKbHCIiIlIlNjlERESkSmxyiIiISJXY5BAREZEqsckhIiIiVWKTQ0RERKrEJoeIiIhUiU0OERERqRKbHCIiIlIlNjlERESkSmxyiIiISJXY5BAREZEqsckhIiIiVbKq7QB1gSzLkGW5VrZb2WNmYAZmYAZmYIa6lqGu5DBnuxZCCPEYs9RphYWFsLe3R1RUFLRabW3HISIiohooLi5GTEwMCgoKoNPpqqzj6SoiIiJSJZ6uAhAaGgpnZ+cnvl1ZlhEbGwsAiIyMhCRJzMAMzMAMzMAMdTJDXckhyzJmz55do1o2OQAkSaq1A4YZmIEZmIEZmOFpy1CXclSHp6uIiIhIldjkEBERkSqxySEiIiJVYpNDREREqsQmh4iIiFSJTQ4RERGpEpscIiIiUiU2OURERKRKbHKIiIhIldjkEBERkSqxySEiIiJVYpNDREREqsQmh4iIiFSJTQ4RERGpEpscIiIiUiU2OURERKRKbHKIiIhIldjkEBERkSqZ1eQsXboUHTt2hE6ng06ng16vx7Zt25T5xcXFCA4OhpOTE+zs7DBkyBDk5uaarCM7OxuBgYGwtbWFi4sLJk+ejNLSUpOaPXv2oEuXLtBoNGjZsiVWrFhRIUt8fDyaN28OrVYLf39/HD161JxdISIiIpWzMqe4WbNmiImJQatWrSCEwMqVKzFo0CCkp6ejXbt2CA8PR3JyMtatWwd7e3uEhITgrbfewnfffQcAKCsrQ2BgINzc3HDw4EFcuXIFo0ePhrW1NT799FMAQFZWFgIDAzFhwgR8/fXXSEtLw/vvv4+mTZsiICAAALBmzRpEREQgISEB/v7+iIuLQ0BAAM6dOwcXFxezB0GWZciybPZyD8t4m7WxfWZgBmZgBmZghqcthznbtRBCiIfZmKOjIz777DO8/fbbaNKkCVatWoW3334bAHD27Fm0bdsWhw4dQvfu3bFt2za89tpruHz5MlxdXQEACQkJmDp1Kq5evQpJkjB16lQkJyfj9OnTyjaGDx+O/Px8pKSkAAD8/f3x/PPPY/HixQCA8vJyeHh4IDQ0FFFRUVVmLSkpQUlJifK8sLAQHh4eiIqKglarfZhhICIioiekuLgYMTExKCgogE6nq7Luga/JKSsrw+rVq1FUVAS9Xo8TJ07gzp076Nevn1LTpk0beHp64tChQwCAQ4cOoUOHDkqDAwABAQEoLCzEDz/8oNQYr8NQY1iHLMs4ceKESU2DBg3Qr18/paYqc+bMgb29vfLl4eHxoLtPREREdZxZp6sAIDMzE3q9HsXFxbCzs8OGDRvg4+ODjIwMSJIEBwcHk3pXV1fk5OQAAHJyckwaHMN8w7zqagoLC3H79m3cuHEDZWVlldacPXu22uzTpk1DRESE8tzwTk5oaCicnZ1rPgiPiCzLiI2NBQBERkZCkiRmYAZmYAZmYIY6maGu5JBlGbNnz65RrdlNTuvWrZGRkYGCggJ8++23CAoKwt69e80OWRs0Gg00Gk2F6ZIk1doBwwzMwAzMwAzM8LRlqEs5qmN2kyNJElq2bAkA8PPzw7Fjx7BgwQIMGzYMsiwjPz/f5N2c3NxcuLm5AQDc3Nwq3AVluPvKuObeO7Jyc3Oh0+lgY2MDS0tLWFpaVlpjWAcRERHRQ39OTnl5OUpKSuDn5wdra2ukpaUp886dO4fs7Gzo9XoAgF6vR2ZmJvLy8pSa1NRU6HQ6+Pj4KDXG6zDUGNYhSRL8/PxMasrLy5GWlqbUEBEREZn1Ts60adMwcOBAeHp64ubNm1i1ahX27NmD7du3w97eHuPGjUNERAQcHR2h0+kQGhoKvV6P7t27AwD69+8PHx8fjBo1CnPnzkVOTg6mT5+O4OBg5TTShAkTsHjxYkyZMgVjx47Frl27sHbtWiQnJys5IiIiEBQUhK5du6Jbt26Ii4tDUVERxowZ8wiHhoiIiJ5mZjU5eXl5GD16NK5cuQJ7e3t07NgR27dvxyuvvAIAmD9/Pho0aIAhQ4agpKQEAQEBWLJkibK8paUltmzZgokTJ0Kv16Nhw4YICgrCrFmzlBpvb28kJycjPDwcCxYsQLNmzfDll18qn5EDAMOGDcPVq1cRHR2NnJwc+Pr6IiUlpcLFyERERFR/mdXkLFu2rNr5Wq0W8fHxiI+Pr7LGy8sLW7durXY9vXv3Rnp6erU1ISEhCAkJqbaGiIiI6i/+31VERESkSmxyiIiISJXY5BAREZEqsckhIiIiVWKTQ0RERKrEJoeIiIhUiU0OERERqRKbHCIiIlIlNjlERESkSmxyiIiISJXY5BAREZEqsckhIiIiVWKTQ0RERKrEJoeIiIhUiU0OERERqZJVbQeoC2RZhizLtbLdyh4zAzMwAzMwAzPUtQx1JYc527UQQojHmKVOKywshL29PaKioqDVams7DhEREdVAcXExYmJiUFBQAJ1OV2UdT1cRERGRKvF0FYDQ0FA4Ozs/8e3KsozY2FgAQGRkJCRJYgZmYAZmYAZmqJMZ6koOWZYxe/bsGtWyyQEgSVKtHTDMwAzMwAzMwAxPW4a6lKM6PF1FREREqsQmh4iIiFSJTQ4RERGpEpscIiIiUiU2OURERKRKbHKIiIhIldjkEBERkSqxySEiIiJVYpNDREREqsQmh4iIiFSJTQ4RERGpEpscIiIiUiU2OURERKRKbHKIiIhIldjkEBERkSqxySEiIiJVYpNDREREqsQmh4iIiFTJrCZnzpw5eP7559GoUSO4uLhg8ODBOHfunElNcXExgoOD4eTkBDs7OwwZMgS5ubkmNdnZ2QgMDIStrS1cXFwwefJklJaWmtTs2bMHXbp0gUajQcuWLbFixYoKeeLj49G8eXNotVr4+/vj6NGj5uwOERERqZhZTc7evXsRHByMw4cPIzU1FXfu3EH//v1RVFSk1ISHh2Pz5s1Yt24d9u7di8uXL+Ott95S5peVlSEwMBCyLOPgwYNYuXIlVqxYgejoaKUmKysLgYGB6NOnDzIyMhAWFob3338f27dvV2rWrFmDiIgIzJgxAydPnkSnTp0QEBCAvLy8hxkPIiIiUgkrc4pTUlJMnq9YsQIuLi44ceIEevbsiYKCAixbtgyrVq3Cyy+/DABITExE27ZtcfjwYXTv3h07duzAmTNnsHPnTri6usLX1xeffPIJpk6dipkzZ0KSJCQkJMDb2xuxsbEAgLZt2+LAgQOYP38+AgICAADz5s3D+PHjMWbMGABAQkICkpOTsXz5ckRFRZk1CLIsQ5Zls5Z5FIy3WRvbZwZmYAZmYAZmeNpymLNdCyGEeNANXbhwAa1atUJmZibat2+PXbt2oW/fvrhx4wYcHByUOi8vL4SFhSE8PBzR0dHYtGkTMjIylPlZWVlo0aIFTp48ic6dO6Nnz57o0qUL4uLilJrExESEhYWhoKAAsizD1tYW3377LQYPHqzUBAUFIT8/Hxs3bqw0b0lJCUpKSpTnhYWF8PDwQFRUFLRa7YMOAxERET1BxcXFiImJQUFBAXQ6XZV1D3zhcXl5OcLCwvDiiy+iffv2AICcnBxIkmTS4ACAq6srcnJylBpXV9cK8w3zqqspLCzE7du38fvvv6OsrKzSGsM6KjNnzhzY29srXx4eHubvOBERET0VzDpdZSw4OBinT5/GgQMHHmWex2ratGmIiIhQnhveyQkNDYWzs/MTzyPLsnJKLjIyEpIkMQMzMAMzMAMz1MkMdSWHLMuYPXt2jWofqMkJCQnBli1bsG/fPjRr1kyZ7ubmBlmWkZ+fb/JuTm5uLtzc3JSae++CMtx9ZVxz7x1Zubm50Ol0sLGxgaWlJSwtLSutMayjMhqNBhqNpsJ0SZJq7YBhBmZgBmZgBmZ42jLUpRzVMet0lRACISEh2LBhA3bt2gVvb2+T+X5+frC2tkZaWpoy7dy5c8jOzoZerwcA6PV6ZGZmmtwFlZqaCp1OBx8fH6XGeB2GGsM6JEmCn5+fSU15eTnS0tKUGiIiIqrfzHonJzg4GKtWrcLGjRvRqFEj5foXe3t72NjYwN7eHuPGjUNERAQcHR2h0+kQGhoKvV6P7t27AwD69+8PHx8fjBo1CnPnzkVOTg6mT5+O4OBg5V2WCRMmYPHixZgyZQrGjh2LXbt2Ye3atUhOTlayREREICgoCF27dkW3bt0QFxeHoqIi5W4rIiIiqt/ManKWLl0KAOjdu7fJ9MTERLz33nsAgPnz56NBgwYYMmQISkpKEBAQgCVLlii1lpaW2LJlCyZOnAi9Xo+GDRsiKCgIs2bNUmq8vb2RnJyM8PBwLFiwAM2aNcOXX36p3D4OAMOGDcPVq1cRHR2NnJwc+Pr6IiUlpcLFyERERFQ/mdXk1ORuc61Wi/j4eMTHx1dZ4+Xlha1bt1a7nt69eyM9Pb3ampCQEISEhNw3ExEREdU//L+riIiISJXY5BAREZEqsckhIiIiVWKTQ0RERKrEJoeIiIhUiU0OERERqRKbHCIiIlIlNjlERESkSmxyiIiISJXY5BAREZEqsckhIiIiVWKTQ0RERKrEJoeIiIhUiU0OERERqRKbHCIiIlIlq9oOUBfIsgxZlmtlu5U9ZgZmYAZmYAZmqGsZ6koOc7ZrIYQQjzFLnVZYWAh7e3tERUVBq9XWdhwiIiKqgeLiYsTExKCgoAA6na7KOp6uIiIiIlXi6SoAoaGhcHZ2fuLblWUZsbGxAIDIyEhIksQMzMAMzMAMzFAnM9SVHLIsY/bs2TWqZZMDQJKkWjtgmIEZmIEZmIEZnrYMdSlHdXi6ioiIiFSJTQ4RERGpEpscIiIiUiU2OURERKRKbHKIiIhIldjkEBERkSqxySEiIiJVYpNDREREqsQmh4iIiFSJTQ4RERGpEpscIiIiUiU2OURERKRKbHKIiIhIldjkEBERkSqxySEiIiJVYpNDREREqsQmh4iIiFSJTQ4RERGpktlNzr59+/D666/D3d0dFhYWSEpKMpkvhEB0dDSaNm0KGxsb9OvXD+fPnzepuX79OkaOHAmdTgcHBweMGzcOt27dMqk5deoUXnrpJWi1Wnh4eGDu3LkVsqxbtw5t2rSBVqtFhw4dsHXrVnN3h4iIiFTK7CanqKgInTp1Qnx8fKXz586di4ULFyIhIQFHjhxBw4YNERAQgOLiYqVm5MiR+OGHH5CamootW7Zg3759+OCDD5T5hYWF6N+/P7y8vHDixAl89tlnmDlzJj7//HOl5uDBgxgxYgTGjRuH9PR0DB48GIMHD8bp06fN3SUiIiJSIStzFxg4cCAGDhxY6TwhBOLi4jB9+nQMGjQIAPDVV1/B1dUVSUlJGD58OH788UekpKTg2LFj6Nq1KwBg0aJFePXVV/HPf/4T7u7u+PrrryHLMpYvXw5JktCuXTtkZGRg3rx5SjO0YMECDBgwAJMnTwYAfPLJJ0hNTcXixYuRkJBg1j7JsgxZls0diodmvM3a2D4zMAMzMAMzMMPTlsOc7VoIIcSDbsjCwgIbNmzA4MGDAQCXLl3Cs88+i/T0dPj6+ip1vXr1gq+vLxYsWIDly5cjMjISN27cUOaXlpZCq9Vi3bp1ePPNNzF69GgUFhaanArbvXs3Xn75ZVy/fh2NGzeGp6cnIiIiEBYWptTMmDEDSUlJ+P777yvNW1JSgpKSEuV5YWEhPDw8EBUVBa1W+6DDQERERE9QcXExYmJiUFBQAJ1OV2XdI73wOCcnBwDg6upqMt3V1VWZl5OTAxcXF5P5VlZWcHR0NKmpbB3G26iqxjC/MnPmzIG9vb3y5eHhYe4uEhER0VPC7NNVT7Np06YhIiJCeW54Jyc0NBTOzs5PPI8sy4iNjQUAREZGQpIkZmAGZmAGZmCGOpmhruSQZRmzZ8+uUe0jbXLc3NwAALm5uWjatKkyPTc3Vzl95ebmhry8PJPlSktLcf36dWV5Nzc35ObmmtQYnt+vxjC/MhqNBhqNpsJ0SZJq7YBhBmZgBmZgBmZ42jLUpRzVeaSnq7y9veHm5oa0tDRlWmFhIY4cOQK9Xg8A0Ov1yM/Px4kTJ5SaXbt2oby8HP7+/krNvn37cOfOHaUmNTUVrVu3RuPGjZUa4+0YagzbISIiovrN7Cbn1q1byMjIQEZGBgAgKysLGRkZyM7OhoWFBcLCwvD3v/8dmzZtQmZmJkaPHg13d3fl4uS2bdtiwIABGD9+PI4ePYrvvvsOISEhGD58ONzd3QEAf/rTnyBJEsaNG4cffvgBa9aswYIFC0xONU2aNAkpKSmIjY3F2bNnMXPmTBw/fhwhISEPPypERET01DP7dNXx48fRp08f5bmh8QgKCsKKFSswZcoUFBUV4YMPPkB+fj569OiBlJQUk7uXvv76a4SEhKBv375o0KABhgwZgoULFyrz7e3tsWPHDgQHB8PPzw/Ozs6Ijo42+SydF154AatWrcL06dPx0UcfoVWrVkhKSkL79u0faCCIiIhIXcxucnr37o3q7jq3sLDArFmzMGvWrCprHB0dsWrVqmq307FjR+zfv7/amqFDh2Lo0KHVByYiIqJ6if93FREREakSmxwiIiJSJTY5REREpEpscoiIiEiV2OQQERGRKrHJISIiIlVik0NERESqxCaHiIiIVIlNDhEREakSmxwiIiJSJTY5REREpEpscoiIiEiV2OQQERGRKrHJISIiIlVik0NERESqxCaHiIiIVMmqtgPUBbIsQ5blWtluZY+ZgRmYgRmYgRnqWoa6ksOc7VoIIcRjzFKnFRYWwt7eHlFRUdBqtbUdh4iIiGqguLgYMTExKCgogE6nq7KOp6uIiIhIlXi6CkBoaCicnZ2f+HZlWUZsbCwAIDIyEpIkMQMzMAMzMAMz1MkMdSWHLMuYPXt2jWrZ5ACQJKnWDhhmYAZmYAZmYIanLUNdylEdnq4iIiIiVWKTQ0RERKrEJoeIiIhUiU0OERERqRKbHCIiIlIlNjlERESkSmxyiIiISJXY5BAREZEqsckhIiIiVWKTQ0RERKrEJoeIiIhUiU0OERERqRKbHCIiIlIlNjlERESkSmxyiIiISJXY5BAREZEqsckhIiIiVXrqm5z4+Hg0b94cWq0W/v7+OHr0aG1HIiIiojrgqW5y1qxZg4iICMyYMQMnT55Ep06dEBAQgLy8vNqORkRERLXMqrYDPIx58+Zh/PjxGDNmDAAgISEBycnJWL58OaKiomq8HlmWIcvy44pZ7XYre8wMzMAMzMAMzFDXMtSVHOZs10IIIR5jlsdGlmXY2tri22+/xeDBg5XpQUFByM/Px8aNGyssU1JSgpKSEuV5QUEBPD09ER4eDo1G8yRiExER0UMqKSnB/PnzkZ+fD3t7+yrrntp3cn7//XeUlZXB1dXVZLqrqyvOnj1b6TJz5szBxx9/XGH6/PnzH0tGIiIienxu3rypzibnQUybNg0RERHK8/z8fHh5eSE7O7vaQVK7wsJCeHh44Ndff4VOp6vtOLWG43AXx+EujsNdHIe7OA7/UxfGQgiBmzdvwt3dvdq6p7bJcXZ2hqWlJXJzc02m5+bmws3NrdJlNBpNpael7O3t6/1BCwA6nY7jAI6DAcfhLo7DXRyHuzgO/1PbY1GTNyee2rurJEmCn58f0tLSlGnl5eVIS0uDXq+vxWRERERUFzy17+QAQEREBIKCgtC1a1d069YNcXFxKCoqUu62IiIiovrrqW5yhg0bhqtXryI6Oho5OTnw9fVFSkpKhYuRq6LRaDBjxox6f2cVx+EujsNdHIe7OA53cRzu4jj8z9M0Fk/tLeRERERE1Xlqr8khIiIiqg6bHCIiIlIlNjlERESkSmxyiIiISJXY5BAREZEq1dsmJz4+Hs2bN4dWq4W/vz+OHj1a25FqbN++fXj99dfh7u4OCwsLJCUlmcwXQiA6OhpNmzaFjY0N+vXrh/Pnz5vUXL9+HSNHjoROp4ODgwPGjRuHW7dumdScOnUKL730ErRaLTw8PDB37twKWdatW4c2bdpAq9WiQ4cO2Lp16yPf36rMmTMHzz//PBo1agQXFxcMHjwY586dM6kpLi5GcHAwnJycYGdnhyFDhlT4lOzs7GwEBgbC1tYWLi4umDx5MkpLS01q9uzZgy5dukCj0aBly5ZYsWJFhTy1dUwtXboUHTt2VD59VK/XY9u2bcr8+jAGlYmJiYGFhQXCwsKUafVhLGbOnAkLCwuTrzZt2ijz68MYGPz2229499134eTkBBsbG3To0AHHjx9X5teX18rmzZtXOCYsLCwQHBwMQOXHhKiHVq9eLSRJEsuXLxc//PCDGD9+vHBwcBC5ubm1Ha1Gtm7dKv7617+K9evXCwBiw4YNJvNjYmKEvb29SEpKEt9//7144403hLe3t7h9+7ZSM2DAANGpUydx+PBhsX//ftGyZUsxYsQIZX5BQYFwdXUVI0eOFKdPnxbffPONsLGxEf/617+Umu+++05YWlqKuXPnijNnzojp06cLa2trkZmZ+djHQAghAgICRGJiojh9+rTIyMgQr776qvD09BS3bt1SaiZMmCA8PDxEWlqaOH78uOjevbt44YUXlPmlpaWiffv2ol+/fiI9PV1s3bpVODs7i2nTpik1ly5dEra2tiIiIkKcOXNGLFq0SFhaWoqUlBSlpjaPqU2bNonk5GTx008/iXPnzomPPvpIWFtbi9OnT9ebMbjX0aNHRfPmzUXHjh3FpEmTlOn1YSxmzJgh2rVrJ65cuaJ8Xb16tV6NgRBCXL9+XXh5eYn33ntPHDlyRFy6dEls375dXLhwQampL6+VeXl5JsdDamqqACB2794thFD3MVEvm5xu3bqJ4OBg5XlZWZlwd3cXc+bMqcVUD+beJqe8vFy4ubmJzz77TJmWn58vNBqN+Oabb4QQQpw5c0YAEMeOHVNqtm3bJiwsLMRvv/0mhBBiyZIlonHjxqKkpESpmTp1qmjdurXy/J133hGBgYEmefz9/cWf//znR7qPNZWXlycAiL179woh7u63tbW1WLdunVLz448/CgDi0KFDQoi7DWODBg1ETk6OUrN06VKh0+mUfZ8yZYpo166dybaGDRsmAgIClOd17Zhq3Lix+PLLL+vlGNy8eVO0atVKpKamil69eilNTn0ZixkzZohOnTpVOq++jIEQd1+vevToUeX8+vxaOWnSJPHss8+K8vJy1R8T9e50lSzLOHHiBPr166dMa9CgAfr164dDhw7VYrJHIysrCzk5OSb7Z29vD39/f2X/Dh06BAcHB3Tt2lWp6devHxo0aIAjR44oNT179oQkSUpNQEAAzp07hxs3big1xtsx1NTWOBYUFAAAHB0dAQAnTpzAnTt3TDK2adMGnp6eJmPRoUMHk0/JDggIQGFhIX744Qelprr9rEvHVFlZGVavXo2ioiLo9fp6OQbBwcEIDAyskLc+jcX58+fh7u6OFi1aYOTIkcjOzgZQv8Zg06ZN6Nq1K4YOHQoXFxd07twZX3zxhTK/vr5WyrKMf//73xg7diwsLCxUf0zUuybn999/R1lZWYX/+sHV1RU5OTm1lOrRMexDdfuXk5MDFxcXk/lWVlZwdHQ0qalsHcbbqKqmNsaxvLwcYWFhePHFF9G+fXslnyRJcHBwqDLjw+xnYWEhbt++XSeOqczMTNjZ2UGj0WDChAnYsGEDfHx86tUYAMDq1atx8uRJzJkzp8K8+jIW/v7+WLFiBVJSUrB06VJkZWXhpZdews2bN+vNGADApUuXsHTpUrRq1Qrbt2/HxIkT8Ze//AUrV6402Zf69lqZlJSE/Px8vPfee0o2NR8TT/X/XUVkEBwcjNOnT+PAgQO1HaVWtG7dGhkZGSgoKMC3336LoKAg7N27t7ZjPVG//vorJk2ahNTUVGi12tqOU2sGDhyoPO7YsSP8/f3h5eWFtWvXwsbGphaTPVnl5eXo2rUrPv30UwBA586dcfr0aSQkJCAoKKiW09WeZcuWYeDAgXB3d6/tKE9EvXsnx9nZGZaWlhWuHM/NzYWbm1stpXp0DPtQ3f65ubkhLy/PZH5paSmuX79uUlPZOoy3UVXNkx7HkJAQbNmyBbt370azZs2U6W5ubpBlGfn5+VVmfJj91Ol0sLGxqRPHlCRJaNmyJfz8/DBnzhx06tQJCxYsqFdjcOLECeTl5aFLly6wsrKClZUV9u7di4ULF8LKygqurq71ZiyMOTg44LnnnsOFCxfq1fHQtGlT+Pj4mExr27atcuquPr5W/vLLL9i5cyfef/99ZZraj4l61+RIkgQ/Pz+kpaUp08rLy5GWlga9Xl+LyR4Nb29vuLm5mexfYWEhjhw5ouyfXq9Hfn4+Tpw4odTs2rUL5eXl8Pf3V2r27duHO3fuKDWpqalo3bo1GjdurNQYb8dQ86TGUQiBkJAQbNiwAbt27YK3t7fJfD8/P1hbW5tkPHfuHLKzs03GIjMz0+SFLDU1FTqdTnmBvN9+1sVjqry8HCUlJfVqDPr27YvMzExkZGQoX127dsXIkSOVx/VlLIzdunULFy9eRNOmTevV8fDiiy9W+EiJn376CV5eXgDq12ulQWJiIlxcXBAYGKhMU/0x8dguaa7DVq9eLTQajVixYoU4c+aM+OCDD4SDg4PJleN12c2bN0V6erpIT08XAMS8efNEenq6+OWXX4QQd2+LdHBwEBs3bhSnTp0SgwYNqvS2yM6dO4sjR46IAwcOiFatWpncFpmfny9cXV3FqFGjxOnTp8Xq1auFra1thdsiraysxD//+U/x448/ihkzZjzR2yInTpwo7O3txZ49e0xuj/zjjz+UmgkTJghPT0+xa9cucfz4caHX64Ver1fmG26N7N+/v8jIyBApKSmiSZMmld4aOXnyZPHjjz+K+Pj4Sm+NrK1jKioqSuzdu1dkZWWJU6dOiaioKGFhYSF27NhRb8agKsZ3VwlRP8YiMjJS7NmzR2RlZYnvvvtO9OvXTzg7O4u8vLx6MwZC3P0YASsrKzF79mxx/vx58fXXXwtbW1vx73//W6mpL6+VQty9k8nT01NMnTq1wjw1HxP1sskRQohFixYJT09PIUmS6Natmzh8+HBtR6qx3bt3CwAVvoKCgoQQd2+N/Nvf/iZcXV2FRqMRffv2FefOnTNZx7Vr18SIESOEnZ2d0Ol0YsyYMeLmzZsmNd9//73o0aOH0Gg04plnnhExMTEVsqxdu1Y899xzQpIk0a5dO5GcnPzY9vtelY0BAJGYmKjU3L59W3z44YeicePGwtbWVrz55pviypUrJuv5+eefxcCBA4WNjY1wdnYWkZGR4s6dOyY1u3fvFr6+vkKSJNGiRQuTbRjU1jE1duxY4eXlJSRJEk2aNBF9+/ZVGhwh6scYVOXeJqc+jMWwYcNE06ZNhSRJ4plnnhHDhg0z+WyY+jAGBps3bxbt27cXGo1GtGnTRnz++ecm8+vLa6UQQmzfvl0AqLB/Qqj7mLAQQojH9z4RERERUe2od9fkEBERUf3AJoeIiIhUiU0OERERqRKbHCIiIlIlNjlERESkSmxyiIiISJXY5BAREZEqsckhIiIiVWKTQ0RERKrEJoeIiIhUiU0OERERqdL/B8tNk2aDiHYAAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_title(\"Map View of Lower Confined Aquifer Layer\", fontweight=\"bold\")\n", + "mapview = fp.plot.PlotMapView(model=model, ax=ax, layer=4)\n", + "mapview.plot_ibound()\n", + "mapview.plot_grid()\n", + "\n", + "chd_bc = mapview.plot_bc(\"CHD\")\n", + "drn_bc = mapview.plot_bc(\"DRN\")\n", + "wel_bc = mapview.plot_bc(\"WEL\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2. Check and run simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Checking model \"ex-gwf-twri01\"...\n", + "\n", + "ex-gwf-twri01 MODEL DATA VALIDATION SUMMARY:\n", + " No errors or warnings encountered.\n", + "\n", + " Checks that passed:\n", + " npf package: zero or negative horizontal hydraulic conductivity values\n", + " npf package: vertical hydraulic conductivity values below checker threshold of 1e-11\n", + " npf package: vertical hydraulic conductivity values above checker threshold of 100000.0\n", + " npf package: horizontal hydraulic conductivity values below checker threshold of 1e-11\n", + " npf package: horizontal hydraulic conductivity values above checker threshold of 100000.0\n", + " chd_0 package: BC indices valid\n", + " chd_0 package: not a number (Nan) entries\n", + " chd_0 package: BC in inactive cells\n", + " drn_0 package: BC indices valid\n", + " drn_0 package: not a number (Nan) entries\n", + " drn_0 package: BC in inactive cells\n", + " wel_0 package: BC indices valid\n", + " wel_0 package: not a number (Nan) entries\n", + " wel_0 package: BC in inactive cells\n", + "\n", + "Checking for missing simulation packages...\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim.check()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FloPy is using the following executable to run the model: ..\\..\\bin\\mf6.exe\n", + " MODFLOW 6\n", + " U.S. GEOLOGICAL SURVEY MODULAR HYDROLOGIC MODEL\n", + " VERSION 6.4.1 Release 12/09/2022\n", + "\n", + " MODFLOW 6 compiled Dec 09 2022 18:18:37 with Intel(R) Fortran Intel(R) 64\n", + " Compiler Classic for applications running on Intel(R) 64, Version 2021.7.0\n", + " Build 20220726_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): 2024/01/11 17:57:19\n", + " \n", + " Writing simulation list file: mfsim.lst\n", + " Using Simulation name file: mfsim.nam\n", + " \n", + " Solving: Stress period: 1 Time step: 1\n", + " \n", + " Run end date and time (yyyy/mm/dd hh:mm:ss): 2024/01/11 17:57:19\n", + " Elapsed run time: 0.048 Seconds\n", + " \n", + " Normal termination of simulation.\n" + ] + } + ], + "source": [ + "success, buff = sim.run_simulation()\n", + "assert success, \"MODFLOW did not terminate normally!\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3. Plotting results" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5, 15, 15)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hds = fp.utils.binaryfile.HeadFile(Path(workspace, \"ex-gwf-twri01.hds\"))\n", + "head_data = hds.get_data()\n", + "head_data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_title(\"Unconfined Aquifer w/ Heads\", fontweight=\"bold\")\n", + "mapview = fp.plot.PlotMapView(model=model, ax=ax)\n", + "mapview.plot_ibound()\n", + "mapview.plot_grid()\n", + "\n", + "head_filled = mapview.plot_array(head_data)\n", + "plt.colorbar(head_filled)\n", + "\n", + "# chd_bc = mapview.plot_bc(\"CHD\")\n", + "drn_bc = mapview.plot_bc(\"DRN\")\n", + "wel_bc = mapview.plot_bc(\"WEL\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_title(\"Middle Confined Aquifer w/ Heads\", fontweight=\"bold\")\n", + "mapview = fp.plot.PlotMapView(model=model, ax=ax, layer=2)\n", + "mapview.plot_ibound()\n", + "mapview.plot_grid()\n", + "\n", + "head_filled = mapview.plot_array(head_data)\n", + "plt.colorbar(head_filled)\n", + "\n", + "# chd_bc = mapview.plot_bc(\"CHD\")\n", + "drn_bc = mapview.plot_bc(\"DRN\")\n", + "wel_bc = mapview.plot_bc(\"WEL\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_title(\"Lower Confined Aquifer w/ Heads\", fontweight=\"bold\")\n", + "mapview = fp.plot.PlotMapView(model=model, ax=ax, layer=4)\n", + "mapview.plot_ibound()\n", + "mapview.plot_grid()\n", + "\n", + "head_filled = mapview.plot_array(head_data)\n", + "plt.colorbar(head_filled)\n", + "\n", + "# chd_bc = mapview.plot_bc(\"CHD\")\n", + "drn_bc = mapview.plot_bc(\"DRN\")\n", + "wel_bc = mapview.plot_bc(\"WEL\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 4. Breakdown: looking at simulation level packages first\n", + "That is, packages for which `model_or_simulation_package = simulation`" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['nam', 'tdis', 'ims'])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 'nam' package handled by MFSimulation\n", + "sim.package_type_dict.keys()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4(a). [Temporal Discretization (TDIS) Package](https://flopy.readthedocs.io/en/latest/source/flopy.mf6.modflow.mftdis.html)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "flopy.mf6.modflow.mftdis.ModflowTdis" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim.package_type_dict['tdis'][0].__class__" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "package_name = ex-gwf-twri01.tdis\n", + "filename = ex-gwf-twri01.tdis\n", + "package_type = tdis\n", + "model_or_simulation_package = simulation\n", + "simulation_name = ex-gwf-twri01\n", + "\n", + "Block options\n", + "--------------------\n", + "time_units\n", + "{internal}\n", + "('seconds')\n", + "\n", + "\n", + "Block dimensions\n", + "--------------------\n", + "nper\n", + "{internal}\n", + "(1)\n", + "\n", + "\n", + "Block perioddata\n", + "--------------------\n", + "perioddata\n", + "{internal}\n", + "(rec.array([(86400., 1, 1.)],\n", + " dtype=[('perlen', '}\n" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.package_dict['chd_0']" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "rec.array([((0, 0, 0), 0.), ((0, 1, 0), 0.), ((0, 2, 0), 0.),\n", + " ((0, 3, 0), 0.), ((0, 4, 0), 0.), ((0, 5, 0), 0.),\n", + " ((0, 6, 0), 0.), ((0, 7, 0), 0.), ((0, 8, 0), 0.),\n", + " ((0, 9, 0), 0.), ((0, 10, 0), 0.), ((0, 11, 0), 0.),\n", + " ((0, 12, 0), 0.), ((0, 13, 0), 0.), ((0, 14, 0), 0.),\n", + " ((2, 0, 0), 0.), ((2, 1, 0), 0.), ((2, 2, 0), 0.),\n", + " ((2, 3, 0), 0.), ((2, 4, 0), 0.), ((2, 5, 0), 0.),\n", + " ((2, 6, 0), 0.), ((2, 7, 0), 0.), ((2, 8, 0), 0.),\n", + " ((2, 9, 0), 0.), ((2, 10, 0), 0.), ((2, 11, 0), 0.),\n", + " ((2, 12, 0), 0.), ((2, 13, 0), 0.), ((2, 14, 0), 0.)],\n", + " dtype=[('cellid', 'O'), ('head', '}\n" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.package_dict['drn_0']" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "rec.array([((0, 7, 1), 0., 1.), ((0, 7, 2), 0., 1.),\n", + " ((0, 7, 3), 10., 1.), ((0, 7, 4), 20., 1.),\n", + " ((0, 7, 5), 30., 1.), ((0, 7, 6), 50., 1.),\n", + " ((0, 7, 7), 70., 1.), ((0, 7, 8), 90., 1.),\n", + " ((0, 7, 9), 100., 1.)],\n", + " dtype=[('cellid', 'O'), ('elev', '}\n" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.package_dict['wel_0']" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "rec.array([((4, 4, 10), -5.), ((2, 3, 5), -5.), ((2, 5, 11), -5.),\n", + " ((0, 8, 7), -5.), ((0, 8, 9), -5.), ((0, 8, 11), -5.),\n", + " ((0, 8, 13), -5.), ((0, 10, 7), -5.), ((0, 10, 9), -5.),\n", + " ((0, 10, 11), -5.), ((0, 10, 13), -5.), ((0, 12, 7), -5.),\n", + " ((0, 12, 9), -5.), ((0, 12, 11), -5.), ((0, 12, 13), -5.)],\n", + " dtype=[('cellid', 'O'), ('q', '" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ex_sim.plot_mapview_unconfined();" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ex_sim.plot_mapview_middle_confined();" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ex_sim.plot_mapview_lower_confined();" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "ex_sim.simulation.delete_output_files()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/testing/gwf_twri01/model/gwf_twri01.chd b/notebooks/testing/gwf_twri01/model/gwf_twri01.chd new file mode 100644 index 0000000..d0157a4 --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/gwf_twri01.chd @@ -0,0 +1,41 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. +BEGIN options +END options + +BEGIN dimensions + MAXBOUND 30 +END dimensions + +BEGIN period 1 + 1 1 1 0.00000000E+00 + 1 2 1 0.00000000E+00 + 1 3 1 0.00000000E+00 + 1 4 1 0.00000000E+00 + 1 5 1 0.00000000E+00 + 1 6 1 0.00000000E+00 + 1 7 1 0.00000000E+00 + 1 8 1 0.00000000E+00 + 1 9 1 0.00000000E+00 + 1 10 1 0.00000000E+00 + 1 11 1 0.00000000E+00 + 1 12 1 0.00000000E+00 + 1 13 1 0.00000000E+00 + 1 14 1 0.00000000E+00 + 1 15 1 0.00000000E+00 + 3 1 1 0.00000000E+00 + 3 2 1 0.00000000E+00 + 3 3 1 0.00000000E+00 + 3 4 1 0.00000000E+00 + 3 5 1 0.00000000E+00 + 3 6 1 0.00000000E+00 + 3 7 1 0.00000000E+00 + 3 8 1 0.00000000E+00 + 3 9 1 0.00000000E+00 + 3 10 1 0.00000000E+00 + 3 11 1 0.00000000E+00 + 3 12 1 0.00000000E+00 + 3 13 1 0.00000000E+00 + 3 14 1 0.00000000E+00 + 3 15 1 0.00000000E+00 +END period 1 + diff --git a/notebooks/testing/gwf_twri01/model/gwf_twri01.dis b/notebooks/testing/gwf_twri01/model/gwf_twri01.dis new file mode 100644 index 0000000..148b1a3 --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/gwf_twri01.dis @@ -0,0 +1,26 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. +BEGIN options + LENGTH_UNITS feet +END options + +BEGIN dimensions + NLAY 5 + NROW 15 + NCOL 15 +END dimensions + +BEGIN griddata + delr + CONSTANT 5000.00000000 + delc + CONSTANT 5000.00000000 + top + CONSTANT 200.00000000 + botm LAYERED + CONSTANT -150.00000000 + CONSTANT -200.00000000 + CONSTANT -300.00000000 + CONSTANT -350.00000000 + CONSTANT -450.00000000 +END griddata + diff --git a/notebooks/testing/gwf_twri01/model/gwf_twri01.dis.grb b/notebooks/testing/gwf_twri01/model/gwf_twri01.dis.grb new file mode 100644 index 0000000000000000000000000000000000000000..b2441a58bb617103c1d3ff663866f509794315bb GIT binary patch literal 54888 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 CK;=yU literal 0 HcmV?d00001 diff --git a/notebooks/testing/gwf_twri01/model/gwf_twri01.drn b/notebooks/testing/gwf_twri01/model/gwf_twri01.drn new file mode 100644 index 0000000..33ab131 --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/gwf_twri01.drn @@ -0,0 +1,20 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. +BEGIN options +END options + +BEGIN dimensions + MAXBOUND 9 +END dimensions + +BEGIN period 1 + 1 8 2 0.00000000E+00 1.00000000E+00 + 1 8 3 0.00000000E+00 1.00000000E+00 + 1 8 4 1.00000000E+01 1.00000000E+00 + 1 8 5 2.00000000E+01 1.00000000E+00 + 1 8 6 3.00000000E+01 1.00000000E+00 + 1 8 7 5.00000000E+01 1.00000000E+00 + 1 8 8 7.00000000E+01 1.00000000E+00 + 1 8 9 9.00000000E+01 1.00000000E+00 + 1 8 10 1.00000000E+02 1.00000000E+00 +END period 1 + diff --git a/notebooks/testing/gwf_twri01/model/gwf_twri01.ic b/notebooks/testing/gwf_twri01/model/gwf_twri01.ic new file mode 100644 index 0000000..f8c5442 --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/gwf_twri01.ic @@ -0,0 +1,6 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. +BEGIN griddata + strt + CONSTANT 0.00000000 +END griddata + diff --git a/notebooks/testing/gwf_twri01/model/gwf_twri01.ims b/notebooks/testing/gwf_twri01/model/gwf_twri01.ims new file mode 100644 index 0000000..fbc108d --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/gwf_twri01.ims @@ -0,0 +1,15 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. +BEGIN options +END options + +BEGIN nonlinear + OUTER_DVCLOSE 1.00000000E-09 + OUTER_MAXIMUM 50 +END nonlinear + +BEGIN linear + INNER_MAXIMUM 100 + INNER_DVCLOSE 1.00000000E-09 + inner_rclose 1.00000000E-06 strict +END linear + diff --git a/notebooks/testing/gwf_twri01/model/gwf_twri01.lst b/notebooks/testing/gwf_twri01/model/gwf_twri01.lst new file mode 100644 index 0000000..aa7cece --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/gwf_twri01.lst @@ -0,0 +1,330 @@ + MODFLOW 6 + U.S. GEOLOGICAL SURVEY MODULAR HYDROLOGIC MODEL + GROUNDWATER FLOW MODEL (GWF) + VERSION 6.4.1 Release 12/09/2022 + + MODFLOW 6 compiled Dec 09 2022 18:18:37 with Intel(R) Fortran Intel(R) 64 + Compiler Classic for applications running on Intel(R) 64, Version 2021.7.0 + Build 20220726_000000 + +This software has been approved for release by the U.S. Geological +Survey (USGS). Although the software has been subjected to rigorous +review, the USGS reserves the right to update the software as needed +pursuant to further analysis and review. No warranty, expressed or +implied, is made by the USGS or the U.S. Government as to the +functionality of the software and related material nor shall the +fact of release constitute any such warranty. Furthermore, the +software is released on condition that neither the USGS nor the U.S. +Government shall be held liable for any damages resulting from its +authorized or unauthorized use. Also refer to the USGS Water +Resources Software User Rights Notice for complete use, copyright, +and distribution information. + + +As a work of the United States Government, this USGS product is +in the public domain within the United States. You can copy, +modify, distribute, and perform the work, even for commercial +purposes, all without asking permission. Additionally, USGS +waives copyright and related rights in the work worldwide +through CC0 1.0 Universal Public Domain Dedication +(https://creativecommons.org/publicdomain/zero/1.0/). + +The following GNU Lesser General Public License (LGPL) libraries +are used in this USGS product: + + SPARSKIT version 2.0 + ilut, luson, and qsplit + (https://www-users.cse.umn.edu/~saad/software/SPARSKIT/) + + RCM - Reverse Cuthill McKee Ordering + (https://people.math.sc.edu/Burkardt/f_src/rcm/rcm.html) + + BLAS - Basic Linear Algebra Subprograms Level 1 + (https://people.math.sc.edu/Burkardt/f_src/blas1_d/blas1_d.html) + + SPARSEKIT - Sparse Matrix Utility Package + amux, dperm, dvperm, rperm, and cperm + (https://people.sc.fsu.edu/~jburkardt/f77_src/sparsekit/sparsekit.html) + +The following BSD-3 License libraries are used in this USGS product: + + Modern Fortran DAG Library + Copyright (c) 2018, Jacob Williams + All rights reserved. + (https://github.com/jacobwilliams/daglib) + +MODFLOW 6 compiler options: /Isrc\libmf6core.a.p /Isrc /I..\src +/Isrc\libmf6_external.a.p /MTd /nologo /warn:general /warn:truncated_source +/stand:f08 /Zi /traceback /O2 /fpe:0 /heap-arrays:0 /traceback /fpp +/Qdiag-disable:7416 /Qdiag-disable:7025 /Qdiag-disable:5268 +/Fdsrc\libmf6core.a.p\Utilities_compilerversion.F90.pdb +/module:src\libmf6core.a.p +/Fosrc/libmf6core.a.p/Utilities_compilerversion.F90.obj /c + +System command used to initiate simulation: +C:\Users\buckl\Documents\Software\mf6.4.1\bin\mf6.exe + +MODFLOW was compiled using uniform precision. + +Real Variables + KIND: 8 + TINY (smallest non-zero value): 2.225074-308 + HUGE (largest value): 1.797693+308 + PRECISION: 15 + SIZE IN BITS: 64 + +Integer Variables + KIND: 4 + HUGE (largest value): 2147483647 + SIZE IN BITS: 32 + +Long Integer Variables + KIND: 8 + HUGE (largest value): 9223372036854775807 + SIZE IN BITS: 64 + +Logical Variables + KIND: 4 + SIZE IN BITS: 32 + + + OPENED gwf_twri01.dis + FILE TYPE:DIS6 UNIT 1005 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.npf + FILE TYPE:NPF6 UNIT 1006 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.ic + FILE TYPE:IC6 UNIT 1007 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.chd + FILE TYPE:CHD6 UNIT 1008 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.drn + FILE TYPE:DRN6 UNIT 1009 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.wel + FILE TYPE:WEL6 UNIT 1010 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.rcha + FILE TYPE:RCH6 UNIT 1011 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + OPENED gwf_twri01.oc + FILE TYPE:OC6 UNIT 1012 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + DIS -- STRUCTURED GRID DISCRETIZATION PACKAGE, VERSION 2 : 3/27/2014 - INPUT READ FROM UNIT 1005 + + Loading input for GWF_TWRI01/DIS + # File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. + NLAY = 5 + NROW = 15 + NCOL = 15 + DELR = 5000.000000000000 + DELC = 5000.000000000000 + TOP = 200.0000000000000 + BOTM = variable 3D double precision array ranging from -450.0000000000000 to -150.0000000000000 + Loading input complete... + + + NPF -- NODE PROPERTY FLOW PACKAGE, VERSION 1, 3/30/2015 INPUT READ FROM UNIT 1006 + + Loading input for GWF_TWRI01/NPF + # File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. + IVARCV = 1 + IDEWATCV = 1 + IPERCHED = 1 + ISAVSPDIS = 1 + ICELLTYPE = variable 1D integer array ranging from 0 to 1 + K = variable 1D double precision array ranging from .1000000000000000E-07 to .1000000000000000E-02 + K33 = variable 1D double precision array ranging from .1000000000000000E-07 to .1000000000000000E-02 + Loading input complete... + + Setting Discretization Options + Model length unit [0=UND, 1=FEET, 2=METERS, 3=CENTIMETERS] set as 1 + End Setting Discretization Options + + Setting Discretization Dimensions + NLAY = 5 + NROW = 15 + NCOL = 15 + End Setting Discretization Dimensions + + Setting Discretization Griddata + DELR set from input file + DELC set from input file + TOP set from input file + BOTM set from input file + End Setting Discretization Griddata + + Setting NPF Options + Vertical flow will be adjusted for perched conditions. + Vertical conductance varies with water table. + Vertical conductance accounts for dewatered portion of an underlying cell. + Specific discharge will be calculated at cell centers and written to DATA-SPDIS in budget file when requested. + End Setting NPF Options + + Setting NPF Griddata + ICELLTYPE set from input file + K set from input file + K33 set from input file + K22 not provided. Setting K22 = K. + End Setting NPF Griddata + + + WEL -- WEL PACKAGE, VERSION 8, 2/22/2014 INPUT READ FROM UNIT 1010 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. + + PROCESSING WEL OPTIONS + END OF WEL OPTIONS + + PROCESSING WEL DIMENSIONS + MAXBOUND = 15 + END OF WEL DIMENSIONS + + DRN -- DRN PACKAGE, VERSION 8, 2/22/2014 INPUT READ FROM UNIT 1009 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. + + PROCESSING DRN OPTIONS + END OF DRN OPTIONS + + PROCESSING DRN DIMENSIONS + MAXBOUND = 9 + END OF DRN DIMENSIONS + + RCH -- RCH PACKAGE, VERSION 8, 2/22/2014 INPUT READ FROM UNIT 1011 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. + + PROCESSING RCH OPTIONS + RECHARGE INPUT WILL BE READ AS ARRAY(S). + END OF RCHA OPTIONS + + CHD -- CHD PACKAGE, VERSION 8, 2/22/2014 INPUT READ FROM UNIT 1008 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. + + PROCESSING CHD OPTIONS + END OF CHD OPTIONS + + PROCESSING CHD DIMENSIONS + MAXBOUND = 30 + END OF CHD DIMENSIONS + + IC -- INITIAL CONDITIONS PACKAGE, VERSION 8, 3/28/2015 INPUT READ FROM UNIT 1007 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. + PROCESSING GRIDDATA + + INITIAL HEAD = 0.000000 + END PROCESSING GRIDDATA + BINARY GRID INFORMATION WILL BE WRITTEN TO: + UNIT NUMBER: 1014 + FILE NAME: c:\Users\buckl\Documents\Github\flopy_mf6_work\notebooks\testing\gwf_twri01\model\gwf_twri01.dis.grb + + OPENED c:\Users\buckl\Documents\Github\flopy_mf6_work\notebooks\testing\gwf_twri01\model\gwf_twri01.dis.grb + FILE TYPE:DATA(BINARY) UNIT 1014 STATUS:REPLACE + FORMAT:UNFORMATTED ACCESS:STREAM + ACTION:READWRITE + + THE LAST TIME STEP WILL BE PRINTED + THE LAST TIME STEP WILL BE PRINTED + # File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. + + PROCESSING OC OPTIONS + + BUDGET INFORMATION WILL BE WRITTEN TO: + UNIT NUMBER: 1015 + FILE NAME: gwf_twri01.cbc + + OPENED gwf_twri01.cbc + FILE TYPE:DATA(BINARY) UNIT 1015 STATUS:REPLACE + FORMAT:UNFORMATTED ACCESS:STREAM + ACTION:READWRITE + + HEAD INFORMATION WILL BE WRITTEN TO: + UNIT NUMBER: 1016 + FILE NAME: gwf_twri01.hds + + OPENED gwf_twri01.hds + FILE TYPE:DATA(BINARY) UNIT 1016 STATUS:REPLACE + FORMAT:UNFORMATTED ACCESS:STREAM + ACTION:READWRITE + + END OF OC OPTIONS + +start timestep kper="1" kstp="1" mode="normal" + + + BEGIN READING OUTPUT CONTROL FOR STRESS PERIOD 1 + ALL TIME STEPS WILL BE SAVED + ALL TIME STEPS WILL BE SAVED + + END READING OUTPUT CONTROL FOR STRESS PERIOD 1 + + RECHARGE = 0.3000000E-07 + + HEAD WILL BE SAVED ON UNIT 1016 AT END OF TIME STEP 1, STRESS PERIOD 1 + + + VOLUME BUDGET FOR ENTIRE MODEL AT END OF TIME STEP 1, STRESS PERIOD 1 + --------------------------------------------------------------------------------------------------- + + CUMULATIVE VOLUME L**3 RATES FOR THIS TIME STEP L**3/T PACKAGE NAME + ------------------ ------------------------ ---------------- + + IN: IN: + --- --- + WEL = 0.0000 WEL = 0.0000 WEL_0 + DRN = 0.0000 DRN = 0.0000 DRN_0 + RCHA = 13608000.0000 RCHA = 157.5000 RCHA_0 + CHD = 0.0000 CHD = 0.0000 CHD_0 + + TOTAL IN = 13608000.0000 TOTAL IN = 157.5000 + + OUT: OUT: + ---- ---- + WEL = 6480000.0000 WEL = 75.0000 WEL_0 + DRN = 2762140.1967 DRN = 31.9692 DRN_0 + RCHA = 0.0000 RCHA = 0.0000 RCHA_0 + CHD = 4365859.8053 CHD = 50.5308 CHD_0 + + TOTAL OUT = 13608000.0019 TOTAL OUT = 157.5000 + + IN - OUT = -1.9288E-03 IN - OUT = -2.2324E-08 + + PERCENT DISCREPANCY = -0.00 PERCENT DISCREPANCY = -0.00 + + + + + TIME SUMMARY AT END OF TIME STEP 1 IN STRESS PERIOD 1 + SECONDS MINUTES HOURS DAYS YEARS + ----------------------------------------------------------- + TIME STEP LENGTH 86400. 1440.0 24.000 1.0000 2.73785E-03 + STRESS PERIOD TIME 86400. 1440.0 24.000 1.0000 2.73785E-03 + TOTAL TIME 86400. 1440.0 24.000 1.0000 2.73785E-03 + + +end timestep + diff --git a/notebooks/testing/gwf_twri01/model/gwf_twri01.nam b/notebooks/testing/gwf_twri01/model/gwf_twri01.nam new file mode 100644 index 0000000..9a8f70c --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/gwf_twri01.nam @@ -0,0 +1,15 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. +BEGIN options +END options + +BEGIN packages + DIS6 gwf_twri01.dis dis + NPF6 gwf_twri01.npf npf + IC6 gwf_twri01.ic ic + CHD6 gwf_twri01.chd chd_0 + DRN6 gwf_twri01.drn drn_0 + WEL6 gwf_twri01.wel wel_0 + RCH6 gwf_twri01.rcha rcha_0 + OC6 gwf_twri01.oc oc +END packages + diff --git a/notebooks/testing/gwf_twri01/model/gwf_twri01.npf b/notebooks/testing/gwf_twri01/model/gwf_twri01.npf new file mode 100644 index 0000000..a3a8639 --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/gwf_twri01.npf @@ -0,0 +1,28 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. +BEGIN options + VARIABLECV DEWATERED + PERCHED + SAVE_SPECIFIC_DISCHARGE +END options + +BEGIN griddata + icelltype LAYERED + CONSTANT 1 + CONSTANT 0 + CONSTANT 0 + CONSTANT 0 + CONSTANT 0 + k LAYERED + CONSTANT 0.00100000 + CONSTANT 1.00000000E-08 + CONSTANT 1.00000000E-04 + CONSTANT 5.00000000E-07 + CONSTANT 2.00000000E-04 + k33 LAYERED + CONSTANT 0.00100000 + CONSTANT 1.00000000E-08 + CONSTANT 1.00000000E-04 + CONSTANT 5.00000000E-07 + CONSTANT 2.00000000E-04 +END griddata + diff --git a/notebooks/testing/gwf_twri01/model/gwf_twri01.oc b/notebooks/testing/gwf_twri01/model/gwf_twri01.oc new file mode 100644 index 0000000..1bee27e --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/gwf_twri01.oc @@ -0,0 +1,11 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. +BEGIN options + BUDGET FILEOUT gwf_twri01.cbc + HEAD FILEOUT gwf_twri01.hds +END options + +BEGIN period 1 + SAVE head all + SAVE budget all +END period 1 + diff --git a/notebooks/testing/gwf_twri01/model/gwf_twri01.rcha b/notebooks/testing/gwf_twri01/model/gwf_twri01.rcha new file mode 100644 index 0000000..0abf31b --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/gwf_twri01.rcha @@ -0,0 +1,10 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. +BEGIN options + READASARRAYS +END options + +BEGIN period 1 + recharge + CONSTANT 3.00000000E-08 +END period 1 + diff --git a/notebooks/testing/gwf_twri01/model/gwf_twri01.tdis b/notebooks/testing/gwf_twri01/model/gwf_twri01.tdis new file mode 100644 index 0000000..5bf2580 --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/gwf_twri01.tdis @@ -0,0 +1,13 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. +BEGIN options + TIME_UNITS seconds +END options + +BEGIN dimensions + NPER 1 +END dimensions + +BEGIN perioddata + 86400.00000000 1 1.00000000 +END perioddata + diff --git a/notebooks/testing/gwf_twri01/model/gwf_twri01.wel b/notebooks/testing/gwf_twri01/model/gwf_twri01.wel new file mode 100644 index 0000000..28789f9 --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/gwf_twri01.wel @@ -0,0 +1,26 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. +BEGIN options +END options + +BEGIN dimensions + MAXBOUND 15 +END dimensions + +BEGIN period 1 + 1 9 8 -5.00000000E+00 + 1 9 10 -5.00000000E+00 + 1 9 12 -5.00000000E+00 + 1 9 14 -5.00000000E+00 + 1 11 8 -5.00000000E+00 + 1 11 10 -5.00000000E+00 + 1 11 12 -5.00000000E+00 + 1 11 14 -5.00000000E+00 + 1 13 8 -5.00000000E+00 + 1 13 10 -5.00000000E+00 + 1 13 12 -5.00000000E+00 + 1 13 14 -5.00000000E+00 + 3 4 6 -5.00000000E+00 + 3 6 12 -5.00000000E+00 + 5 5 11 -5.00000000E+00 +END period 1 + diff --git a/notebooks/testing/gwf_twri01/model/mfsim.lst b/notebooks/testing/gwf_twri01/model/mfsim.lst new file mode 100644 index 0000000..9c9b7ad --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/mfsim.lst @@ -0,0 +1,216 @@ + MODFLOW 6 + U.S. GEOLOGICAL SURVEY MODULAR HYDROLOGIC MODEL + VERSION 6.4.1 Release 12/09/2022 + + MODFLOW 6 compiled Dec 09 2022 18:18:37 with Intel(R) Fortran Intel(R) 64 + Compiler Classic for applications running on Intel(R) 64, Version 2021.7.0 + Build 20220726_000000 + +This software has been approved for release by the U.S. Geological +Survey (USGS). Although the software has been subjected to rigorous +review, the USGS reserves the right to update the software as needed +pursuant to further analysis and review. No warranty, expressed or +implied, is made by the USGS or the U.S. Government as to the +functionality of the software and related material nor shall the +fact of release constitute any such warranty. Furthermore, the +software is released on condition that neither the USGS nor the U.S. +Government shall be held liable for any damages resulting from its +authorized or unauthorized use. Also refer to the USGS Water +Resources Software User Rights Notice for complete use, copyright, +and distribution information. + + +As a work of the United States Government, this USGS product is +in the public domain within the United States. You can copy, +modify, distribute, and perform the work, even for commercial +purposes, all without asking permission. Additionally, USGS +waives copyright and related rights in the work worldwide +through CC0 1.0 Universal Public Domain Dedication +(https://creativecommons.org/publicdomain/zero/1.0/). + +The following GNU Lesser General Public License (LGPL) libraries +are used in this USGS product: + + SPARSKIT version 2.0 + ilut, luson, and qsplit + (https://www-users.cse.umn.edu/~saad/software/SPARSKIT/) + + RCM - Reverse Cuthill McKee Ordering + (https://people.math.sc.edu/Burkardt/f_src/rcm/rcm.html) + + BLAS - Basic Linear Algebra Subprograms Level 1 + (https://people.math.sc.edu/Burkardt/f_src/blas1_d/blas1_d.html) + + SPARSEKIT - Sparse Matrix Utility Package + amux, dperm, dvperm, rperm, and cperm + (https://people.sc.fsu.edu/~jburkardt/f77_src/sparsekit/sparsekit.html) + +The following BSD-3 License libraries are used in this USGS product: + + Modern Fortran DAG Library + Copyright (c) 2018, Jacob Williams + All rights reserved. + (https://github.com/jacobwilliams/daglib) + +MODFLOW 6 compiler options: /Isrc\libmf6core.a.p /Isrc /I..\src +/Isrc\libmf6_external.a.p /MTd /nologo /warn:general /warn:truncated_source +/stand:f08 /Zi /traceback /O2 /fpe:0 /heap-arrays:0 /traceback /fpp +/Qdiag-disable:7416 /Qdiag-disable:7025 /Qdiag-disable:5268 +/Fdsrc\libmf6core.a.p\Utilities_compilerversion.F90.pdb +/module:src\libmf6core.a.p +/Fosrc/libmf6core.a.p/Utilities_compilerversion.F90.obj /c + +System command used to initiate simulation: +C:\Users\buckl\Documents\Software\mf6.4.1\bin\mf6.exe + +MODFLOW was compiled using uniform precision. + +Real Variables + KIND: 8 + TINY (smallest non-zero value): 2.225074-308 + HUGE (largest value): 1.797693+308 + PRECISION: 15 + SIZE IN BITS: 64 + +Integer Variables + KIND: 4 + HUGE (largest value): 2147483647 + SIZE IN BITS: 32 + +Long Integer Variables + KIND: 8 + HUGE (largest value): 9223372036854775807 + SIZE IN BITS: 64 + +Logical Variables + KIND: 4 + SIZE IN BITS: 32 + + + OPENED mfsim.nam + FILE TYPE:NAM UNIT 1001 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + # File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. + + READING SIMULATION OPTIONS + END OF SIMULATION OPTIONS + + READING SIMULATION TIMING + + OPENED gwf_twri01.tdis + FILE TYPE:TDIS UNIT 1002 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + + TDIS -- TEMPORAL DISCRETIZATION PACKAGE, + VERSION 1 : 11/13/2014 - INPUT READ FROM UNIT 1002 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. + PROCESSING TDIS OPTIONS + SIMULATION TIME UNIT IS SECONDS + END OF TDIS OPTIONS + PROCESSING TDIS DIMENSIONS + 1 STRESS PERIOD(S) IN SIMULATION + END OF TDIS DIMENSIONS + PROCESSING TDIS PERIODDATA + + + STRESS PERIOD LENGTH TIME STEPS MULTIPLIER FOR DELT + ---------------------------------------------------------------------------- + 1 86400.00 1 1.000 + END OF TDIS PERIODDATA + END OF SIMULATION TIMING + + READING SIMULATION MODELS + GWF6 model GWF_TWRI01 will be created as model 1 + END OF SIMULATION MODELS + + READING SIMULATION EXCHANGES + END OF SIMULATION EXCHANGES + + READING SOLUTIONGROUP + + Creating solution: SLN_1 + + OPENED gwf_twri01.ims + FILE TYPE:IMS UNIT 1013 STATUS:OLD + FORMAT:FORMATTED ACCESS:SEQUENTIAL + ACTION:READ + + END OF SIMULATION SOLUTIONGROUP + +PROCESSING MODEL CONNECTIONS + + IMS -- ITERATIVE MODEL SOLUTION PACKAGE, VERSION 6, 4/28/2017 + INPUT READ FROM UNIT 1013 + # File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. + + PROCESSING IMS OPTIONS + END OF IMS OPTIONS + + PROCESSING IMS NONLINEAR + END OF IMS NONLINEAR DATA + ***UNDER-RELAXATION WILL NOT BE USED*** + + ***IMS LINEAR SOLVER WILL BE USED*** + + IMSLINEAR -- UNSTRUCTURED LINEAR SOLUTION PACKAGE, VERSION 8, 04/28/2017 + + PROCESSING LINEAR DATA + END OF LINEAR DATA + + A symmetric matrix will be solved + + OUTER ITERATION CONVERGENCE CRITERION (DVCLOSE) = 0.100000E-08 + MAXIMUM NUMBER OF OUTER ITERATIONS (MXITER) = 50 + SOLVER PRINTOUT INDEX (IPRIMS) = 0 + NONLINEAR ITERATION METHOD (NONLINMETH) = 0 + LINEAR SOLUTION METHOD (LINMETH) = 1 + + SOLUTION BY THE CONJUGATE-GRADIENT METHOD + ------------------------------------------------------------------ + MAXIMUM OF 50 CALLS OF SOLUTION ROUTINE + MAXIMUM OF 100 INTERNAL ITERATIONS PER CALL TO SOLUTION ROUTINE + LINEAR ACCELERATION METHOD = CG + MATRIX PRECONDITIONING TYPE = INCOMPLETE LU + MATRIX SCALING APPROACH = NO SCALING + MATRIX REORDERING APPROACH = ORIGINAL ORDERING + NUMBER OF ORTHOGONALIZATIONS = 0 + HEAD CHANGE CRITERION FOR CLOSURE = 0.10000E-08 + RESIDUAL CHANGE CRITERION FOR CLOSURE = 0.10000E-05 + RESIDUAL CONVERGENCE OPTION = 1 + RESIDUAL CONVERGENCE NORM = INFINITY NORM S + RELAXATION FACTOR = 0.00000E+00 + + + + + Solving: Stress period: 1 Time step: 1 + +1 + STRESS PERIOD NO. 1, LENGTH = 86400.00 + ----------------------------------------------- + NUMBER OF TIME STEPS = 1 + MULTIPLIER FOR DELT = 1.000 + INITIAL TIME STEP SIZE = 86400.00 + + MEMORY MANAGER TOTAL STORAGE BY DATA TYPE, IN KILOBYTES + ------------------------------- + ALLOCATED + DATA TYPE MEMORY + ------------------------------- + Character 2.9340000 + Logical 4.00000000E-02 + Integer 240.60800 + Real 557.35200 + ------------------------------- + Total 800.93400 + ------------------------------- + + + + Run end date and time (yyyy/mm/dd hh:mm:ss): 2024/01/11 20:18:52 + Elapsed run time: 0.049 Seconds + Normal termination of simulation. diff --git a/notebooks/testing/gwf_twri01/model/mfsim.nam b/notebooks/testing/gwf_twri01/model/mfsim.nam new file mode 100644 index 0000000..9b08be3 --- /dev/null +++ b/notebooks/testing/gwf_twri01/model/mfsim.nam @@ -0,0 +1,19 @@ +# File generated by Flopy version 3.5.0 on 01/11/2024 at 20:18:42. +BEGIN options +END options + +BEGIN timing + TDIS6 gwf_twri01.tdis +END timing + +BEGIN models + gwf6 gwf_twri01.nam gwf_twri01 +END models + +BEGIN exchanges +END exchanges + +BEGIN solutiongroup 1 + ims6 gwf_twri01.ims gwf_twri01 +END solutiongroup 1 + diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..595cd68 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,31 @@ +[build-system] +requires = ["setuptools>=61.0"] +build-backend = "setuptools.build_meta" + +[project] +name = "flopy_mf6_work" +dynamic = ["version"] +dependencies = [ + "flopy", + "matplotlib", + "numpy", + "pandas >= 2", + "seaborn" +] +authors = [{ name = "Daniel N. Buckley", email = "buckley.daniel.n@gmail.com" }] +description = "Learning MODFLOW 6 using the FloPy library" +readme = "README.md" +requires-python = ">=3.11" + +[project.urls] +Homepage = "https://github.com/dannbuckley/flopy_mf6_work" + +[project.optional-dependencies] +testing = [ + "mypy", + "pylint", + "pytest" +] + +[tool.setuptools.dynamic] +version = { attr = "flopy_mf6_work.__version__" } diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..384f34f --- /dev/null +++ b/setup.py @@ -0,0 +1,9 @@ +from setuptools import setup, find_packages + +setup( + packages=find_packages( + where="src", + include=["flopy_mf6_work*"], + ), + package_dir={"": "src"}, +) diff --git a/src/flopy_mf6_work/__init__.py b/src/flopy_mf6_work/__init__.py new file mode 100644 index 0000000..1814153 --- /dev/null +++ b/src/flopy_mf6_work/__init__.py @@ -0,0 +1,2 @@ +"""Package description""" +__version__ = "2024.1" diff --git a/src/flopy_mf6_work/gwf/__init__.py b/src/flopy_mf6_work/gwf/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/flopy_mf6_work/gwf/twri01.py b/src/flopy_mf6_work/gwf/twri01.py new file mode 100644 index 0000000..62d9250 --- /dev/null +++ b/src/flopy_mf6_work/gwf/twri01.py @@ -0,0 +1,348 @@ +"""twri01 module""" +from os import PathLike +from typing import Iterator, Union + +import flopy as fp +import matplotlib.pyplot as plt + + +class TWRI: + """TWRI example + (see mf6examples.pdf, pages 1-1 through 1-3) + + Parameters + ---------- + exe_name : str or PathLike + sim_ws : str or PathLike + + Attributes + ---------- + sim_name : str + Simulation name is `gwf_twri01`. + simulation : flopy.mf6.MFSimulation + model : flopy.mf6.ModflowGwf + """ + + sim_name = "gwf_twri01" + + def __init__( + self, + exe_name: Union[str, PathLike], + sim_ws: Union[str, PathLike], + ): + # setup simulation + self._simulation = fp.mf6.MFSimulation( + sim_name=self.sim_name, version="mf6", exe_name=exe_name, sim_ws=sim_ws + ) + self._add_sim_tdis() + self._add_sim_ims() + + # setup model + self._model = fp.mf6.ModflowGwf( + simulation=self._simulation, + modelname=self.sim_name, + model_nam_file=f"{self.sim_name}.nam", + ) + self._add_model_dis() + self._add_model_npf() + self._add_model_ic() + self._add_model_chd() + self._add_model_drn() + self._add_model_wel() + self._add_model_rcha() + self._add_model_oc() + + @property + def simulation(self): + """Get simulation object for this example.""" + return self._simulation + + @property + def model(self): + """Get groundwater flow model object for this example.""" + return self._model + + def check_simulation(self): + """Check MODFLOW simulation for errors and warnings.""" + self._simulation.check() + + def write_simulation(self): + """Write files for MODFLOW simulation.""" + self._simulation.write_simulation() + + def run_simulation(self): + """Run MODFLOW simulation. + + Raises + ------ + AssertionError + If MODFLOW simulation does not terminate normally. + """ + success, _ = self._simulation.run_simulation() + assert success, "MODFLOW did not terminate normally!" + + def plot_mapview_unconfined(self): + """Generate a map-view plot of the unconfined aquifer in the first layer + with constant-head, drain, and well boundary conditions. + + Returns + ------- + fig : matplotlib.figure.Figure + """ + fig, ax = plt.subplots() + ax.set_title("Map View of Unconfined Aquifer Layer", fontweight="bold") + mapview = fp.plot.PlotMapView(model=self._model, ax=ax) + mapview.plot_ibound() + mapview.plot_grid() + + # plot constant-head cells + mapview.plot_bc("CHD") + # plot drain cells + mapview.plot_bc("DRN") + # plot wells + mapview.plot_bc("WEL") + + # return completed figure to caller + return fig + + def plot_mapview_middle_confined(self): + """Generate a map-view plot of the middle confined aquifer in the third layer + with constant-head and well boundary conditions. + + Returns + ------- + fig : matplotlib.figure.Figure + """ + fig, ax = plt.subplots() + ax.set_title("Map View of Middle Confined Aquifer Layer", fontweight="bold") + mapview = fp.plot.PlotMapView(model=self._model, ax=ax, layer=2) + mapview.plot_ibound() + mapview.plot_grid() + + # plot constant-head cells + mapview.plot_bc("CHD") + # plot wells + mapview.plot_bc("WEL") + + # return completed figure to caller + return fig + + def plot_mapview_lower_confined(self): + """Generate a map-view plot of the lower confined aquifer in the fifth layer + with well boundary conditions. + + Returns + ------- + fig : matplotlib.figure.Figure + """ + fig, ax = plt.subplots() + ax.set_title("Map View of Lower Confined Aquifer Layer", fontweight="bold") + mapview = fp.plot.PlotMapView(model=self._model, ax=ax, layer=4) + mapview.plot_ibound() + mapview.plot_grid() + + # plot wells + mapview.plot_bc("WEL") + + # return completed figure to caller + return fig + + def _add_sim_tdis(self): + """Add Temporal Discretization (TDIS) packge to simulation.""" + try: + fp.mf6.ModflowTdis( + simulation=getattr(self, "_simulation"), + time_units="seconds", + nper=1, + perioddata=[(86400.0, 1, 1.0)], + filename=f"{self.sim_name}.tdis", + pname="tdis", + ) + except AttributeError: + # simulation doesn't exist, do nothing + pass + + def _add_sim_ims(self): + """Add Iterative Model Solution (IMS) to simulation.""" + try: + fp.mf6.ModflowIms( + simulation=getattr(self, "_simulation"), + outer_dvclose=1e-9, + outer_maximum=50, + inner_maximum=100, + inner_dvclose=1e-9, + rcloserecord=[(1e-6, "strict")], + filename=f"{self.sim_name}.ims", + pname="ims", + ) + except AttributeError: + # simulation doesn't exist, do nothing + pass + + def _add_model_dis(self): + """Add Structured Discretization (DIS) to model.""" + try: + fp.mf6.ModflowGwfdis( + model=getattr(self, "_model"), + length_units="FEET", + nlay=5, + nrow=15, + ncol=15, + delr=5000.0, + delc=5000.0, + top=200.0, + botm=[-150.0, -200.0, -300.0, -350.0, -450.0], + filename=f"{self.sim_name}.dis", + pname="dis", + ) + except AttributeError: + # model doesn't exist, do nothing + pass + + def _add_model_npf(self): + """Add Node Property Flow (NPF) package to model.""" + try: + k = [0.001, 1e-8, 0.0001, 5e-7, 0.0002] + fp.mf6.ModflowGwfnpf( + model=getattr(self, "_model"), + cvoptions=[(True, "DEWATERED")], + perched=True, + save_specific_discharge=True, + icelltype=[1, 0, 0, 0, 0], + k=k, + k33=k, + filename=f"{self.sim_name}.npf", + pname="npf", + ) + except AttributeError: + # model doesn't exist, do nothing + pass + + def _add_model_ic(self): + """Add Initial Conditions (IC) package to model.""" + try: + fp.mf6.ModflowGwfic( + model=getattr(self, "_model"), + strt=0.0, + filename=f"{self.sim_name}.ic", + pname="ic", + ) + except AttributeError: + # model doesn't exist, do nothing + pass + + def _add_model_chd(self): + """Add Constant-Head (CHD) package to model.""" + + def _make_chd_iter() -> Iterator[tuple[tuple[int, int, int], float]]: + """Generate constant-head data for model. + The first column of the first and third layers should be set to 0.0 ft. + + Yields + ------ + ((layer, row, column), head) + """ + for layer in [0, 2]: + for row in range(15): + yield ((layer, row, 0), 0.0) + + try: + fp.mf6.ModflowGwfchd( + model=getattr(self, "_model"), + maxbound=30, + stress_period_data=list(_make_chd_iter()), + filename=f"{self.sim_name}.chd", + pname="chd_0", + ) + except AttributeError: + # model doesn't exist, do nothing + pass + + def _add_model_drn(self): + """Add Drain (DRN) package to model.""" + + def _make_drn_iter() -> Iterator[tuple[tuple[int, int, int], float, float]]: + """Generate drain data for model. + + Yields + ------ + ((layer, row, column), elev, cond) + """ + elev = [0, 0, 10, 20, 30, 50, 70, 90, 100] + for col in range(1, 10): + yield ((0, 7, col), float(elev[col - 1]), 1.0) + + try: + fp.mf6.ModflowGwfdrn( + model=getattr(self, "_model"), + maxbound=9, + stress_period_data=list(_make_drn_iter()), + filename=f"{self.sim_name}.drn", + pname="drn_0", + ) + except AttributeError: + # model doesn't exist, do nothing + pass + + def _add_model_wel(self): + """Add Well (WEL) package to model.""" + + def _make_wel_iter() -> Iterator[tuple[tuple[int, int, int], float]]: + """Generate well data for model. + + Yields + ------ + ((layer, row, column), q) + """ + # wells in unconfined aquifer + for row in range(8, 13, 2): + for col in range(7, 14, 2): + yield ((0, row, col), -5.0) + + # wells in middle confined aquifer + yield ((2, 3, 5), -5.0) + yield ((2, 5, 11), -5.0) + + # well in lower confined aquifer + yield ((4, 4, 10), -5.0) + + try: + fp.mf6.ModflowGwfwel( + model=getattr(self, "_model"), + maxbound=15, + stress_period_data=list(_make_wel_iter()), + filename=f"{self.sim_name}.wel", + pname="wel_0", + ) + except AttributeError: + # model doesn't exist, do nothing + pass + + def _add_model_rcha(self): + """Add Recharge (RCH) package to model (array-based version).""" + try: + fp.mf6.ModflowGwfrcha( + model=getattr(self, "_model"), + recharge=3e-8, + filename=f"{self.sim_name}.rcha", + pname="rcha_0", + ) + except AttributeError: + # model doesn't exist, do nothing + pass + + def _add_model_oc(self): + """Add Output Control (OC) to model.""" + try: + fp.mf6.ModflowGwfoc( + model=getattr(self, "_model"), + budget_filerecord=[f"{self.sim_name}.cbc"], + head_filerecord=[f"{self.sim_name}.hds"], + saverecord=[("head", "all"), ("budget", "all")], + # printrecord=None, + filename=f"{self.sim_name}.oc", + pname="oc", + ) + except AttributeError: + # model doesn't exist, do nothing + pass