diff --git a/docs/source/conf.py b/docs/source/conf.py index a36a78f1..98bd0ba4 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -133,9 +133,9 @@ # a list of builtin themes. # html_theme = 'sphinx_rtd_theme' -import sphinx_rtd_theme +#import sphinx_rtd_theme -html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] +#html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the @@ -146,7 +146,7 @@ # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". -#html_static_path = ['_static'] +html_static_path = ['_static'] # Custom sidebar templates, must be a dictionary that maps document names # to template names. @@ -289,7 +289,8 @@ source_path / 'part1_flopy/solutions/07-stream_capture_voronoi.ipynb', source_path / 'part1_flopy/08_Modflow-setup-demo.ipynb', source_path / 'part1_flopy/09-gwt-voronoi-demo.ipynb', - source_path / 'part1_flopy/10_modpath_particle_tracking-demo.ipynb', + source_path / 'part1_flopy/10a_prt_particle_tracking-demo.ipynb', + source_path / 'part1_flopy/10b_modpath_particle_tracking-demo.ipynb', # "bonus" notebooks source_path / 'part0_python_intro/09_b_Geopandas_ABQ.ipynb' ] @@ -314,4 +315,10 @@ nbsphinx_thumbnails = { 'notebooks/part1_flopy/01-Flopy-intro': '_images/flopylogo_sm.png', + 'notebooks/part0_python_intro/07b_VSCode': + '_images/code-stable.png', + 'notebooks/part0_python_intro/0[0-4]*': + '_static/python-logo-only.png', + 'notebooks/part0_python_intro/solutions/0[0-4]*': + '_static/python-logo-only.png' } diff --git a/docs/source/part0.rst b/docs/source/part0.rst index 73daf63c..25729992 100644 --- a/docs/source/part0.rst +++ b/docs/source/part0.rst @@ -18,6 +18,6 @@ Part 0: General Python Exercises notebooks/part0_python_intro/solutions/08_pandas.ipynb notebooks/part0_python_intro/09_a_Geopandas.ipynb notebooks/part0_python_intro/solutions/09_Geopandas__solutions.ipynb - notebooks/part0_python_intro/10a_Rasterio_into.ipynb + notebooks/part0_python_intro/10a_Rasterio_intro.ipynb notebooks/part0_python_intro/10b_Rasterio_advanced.ipynb notebooks/part0_python_intro/11_xarray_mt_rainier_precip.ipynb diff --git a/docs/source/part1.rst b/docs/source/part1.rst index f5efc87e..2ffa338e 100644 --- a/docs/source/part1.rst +++ b/docs/source/part1.rst @@ -14,4 +14,5 @@ Part 1 flopy notebooks/part1_flopy/solutions/07-stream_capture_voronoi.ipynb notebooks/part1_flopy/08_Modflow-setup-demo.ipynb notebooks/part1_flopy/09-gwt-voronoi-demo.ipynb - notebooks/part1_flopy/10_modpath_particle_tracking-demo.ipynb \ No newline at end of file + notebooks/part1_flopy/10a_prt_particle_tracking-demo.ipynb + notebooks/part1_flopy/10b_modpath_particle_tracking-demo.ipynb \ No newline at end of file diff --git a/notebooks/clear_all_notebooks.py b/notebooks/clear_all_notebooks.py index 68930b39..54bf0616 100644 --- a/notebooks/clear_all_notebooks.py +++ b/notebooks/clear_all_notebooks.py @@ -16,7 +16,7 @@ #'07-stream_capture_voronoi.ipynb', #'08_Modflow-setup-demo.ipynb', #'09-gwt-voronoi-demo.ipynb', - '10_modpath_particle_tracking-demo.ipynb' + '10b_modpath_particle_tracking-demo.ipynb' ] if __name__ == "__main__": diff --git a/notebooks/part0_python_intro/07b_VSCode.md b/notebooks/part0_python_intro/07b_VSCode.md index 3295f017..fdb9b144 100644 --- a/notebooks/part0_python_intro/07b_VSCode.md +++ b/notebooks/part0_python_intro/07b_VSCode.md @@ -1,3 +1,5 @@ +![](data/code-stable.png) + # 07b: VSCode Tutorial In this tutorial we will explore using an integrated development environment (IDE) for python programming. IDEs offer many advantages over Jupyter Notebooks, particularly for developing production code that will be reused many times and shared with others. The advantages of IDEs include: * *Linting* to catch errors, dead code, and other code quality issues @@ -5,7 +7,7 @@ In this tutorial we will explore using an integrated development environment (ID * code navigation (jumping to function definitions, etc.) * interactive debugging (including plotting) * support for automated testing and version control -* unlike Notebooks, code is always executed in the same order (as it would be by another user), thereby increasing the chances for reproducibility. +* unlike Notebooks, code is always executed from start to finish (as it would be by another user), thereby increasing the chances for reproducibility. VSCode offers the above advantages, and many other features through Extensions (plugins) that can be created by anyone. VSCode is also free and works well with large files (GB in size). The Live Share plugin allows for real-time code collaboration and debugging with multiple people. @@ -16,7 +18,8 @@ If you haven't yet, install VS Code [here](https://code.visualstudio.com/downloa Once VSCode is installed, * Open ``notebooks/part0_python_intro/solutions/07a_Theis-exercise-solution.ipynb`` in Jupyter * From the ``File`` menu, select ``Save and Export Notebook as`` and then ``Executable Script``. This will create a python script version of the notebook (``07a_Theis-exercise-solution.py``) -* Save ``07a_Theis-exercise-solution.py`` to the ``notebooks/part0_python_intro`` folder (or copy it there from your Downloads folder). +* Rename this file to ``my_07a_Theis-exercise-solution.py`` +* Save ``my_07a_Theis-exercise-solution.py`` to the ``notebooks/part0_python_intro`` folder (or copy it there from your Downloads folder). ### Launching VSCode * Open a fresh Miniforge prompt from the Start menu and navigate to the root folder for the class (containing the ``AGENDA.md`` file). @@ -27,7 +30,7 @@ Once VSCode is installed, ### Getting started See [here](https://code.visualstudio.com/docs/getstarted/userinterface) for an overview of the VSCode user interface. -Once VSCode is launched, click on [the Extensions icon](https://code.visualstudio.com/docs/editor/extension-marketplace) on the activity bar on the left. Install the following extensions: +Once VSCode is launched, click on [the Extensions icon](https://code.visualstudio.com/docs/editor/extension-marketplace) on the Activity Bar on the left. Install the following extensions: * Python * Python indent * Pylance @@ -35,14 +38,15 @@ Once VSCode is launched, click on [the Extensions icon](https://code.visualstudi * Jupyter * Code spell checker * autoDocstring +* Rainbow CSV You may find other cool extensions that you want too. A key indicator of an extension's quality is the number of downloads. ### Linting -Now let's open the script we copied earlier (``notebooks/part0_python_intro/07a_Theis-exercise-solution.py``). You can do this from the File Explorer on the left side of the screen. +Now let's open the script we copied earlier (``notebooks/part0_python_intro/my_07a_Theis-exercise-solution.py``). You can do this from the File Explorer on the left side of the screen. -* as you scroll down through the script, note that "ts" is grayed out in the statement ``for ts in t:`` on line 213. This is the linter telling us that this variable is declared but never used. This is "dead code" that we want remove by refactoring. -* similarly, note further down that the variables ``x`` and ``y`` are underlined on lines 253 and 254. The linter is warning us that these variables were never declared. This is because their declarations were wrapped in the ``get_ipython().run_cell_magic`` statement on line 232, in translation of the notebook to a script. +* as you scroll down through the script, note that "ts" is grayed out in the statement ``for ts in t:`` near line 213. This is the linter telling us that this variable is declared but never used. This is "dead code" that we want remove by refactoring. +* similarly, note further down that the variables ``x`` and ``y`` are underlined near lines 253 and 254. The linter is warning us that these variables were never declared. This is because their declarations were wrapped in the ``get_ipython().run_cell_magic`` statement near line 232, in translation of the notebook to a script. ### Cleaning up the script Let's clean up the script so that @@ -61,12 +65,14 @@ Let's use Partial Diff to compare our script to the class solution. Assuming the * Partial Diff will open up a third window showing the differences ### Debugging -* Place a break point anywhere below the first ``theis()`` call in the ``__main__`` part of the script. +* Place a break point anywhere below the first ``theis()`` call in the ``__main__`` part of the script, by clicking to the left of a line number (you should see a red dot). +* If needed, select the ``pyclass` environment as the Python interpreter. Go to ``View --> Command Palette``, then type ``Python: Select Interpreter``. Choose the option with ``(pyclass)`` from the dropdown menu. +* With the Python script (e.g.``07a_Theis-exercise-solution.py``) tab selected, you should see some version numbers followed by ``(pyclass)`` in the bottom right of the VS Code window. Note that you can also click here to change the Python environment. * Then go to either ``Run --> Start Debugging`` or click on the debug icon in the Activity Bar and choose ``Run and Debug``. Choose ``Python File`` if prompted for a configuration. The debugger should run to the break point. Often it is prudent to include internal checks in code, regardless of the context. There are a number of ways to do this; a simple one is an ``assert`` statement that checks a condition. -* Add an ``s = `` in front of the first ``theis()`` call to assign the results to a variable, and then right below, the following ``assert`` statement: +* Add an ``s = `` in front of the first ``theis()`` call to assign the results to a variable, and then in the line below, the following ``assert`` statement: ``` assert np.allclose(s, 1.40636669) ``` @@ -77,9 +83,9 @@ Often it is prudent to include internal checks in code, regardless of the contex #### The debug working directory Import ``pathlib`` and type ``pathlib.Path.cwd()`` in the debug console. Note that the current directory is the root folder for the class (where we launched VSCode). VSCode is structured around projects, which include everything in a folder that was opened (and any subfolders). By default, the working directory for debugging is set at the root level for the project. We can change this (and other debugging settings), by creating a configuration file called ``launch.json``, which lives inside of a ``.vscode/`` folder at the root level of the project. -* After stopping the debugging session, make a default ``launch.json`` by clicking on the debug icon in the Activity Bar and then ``create a launch.json file``. Choose ``Python File`` if prompted for a configuration. A new tab will open up with ``launch.json``. Add ``"cwd": "${fileDirname}"`` at the bottom (don't forget the preceding comma!) so that the file looks like this: +* After stopping the debugging session, make a default ``launch.json`` by clicking on the debug icon in the Activity Bar and then ``create a launch.json file``. Choose ``Python Debugger`` and then ``Python File`` if prompted for a configuration. A new tab will open up with ``launch.json``. Add ``"cwd": "${fileDirname}"`` at the bottom (don't forget the preceding comma!) so that the file looks like this: - ``` + ```json { // Use IntelliSense to learn about possible attributes. // Hover to view descriptions of existing attributes. @@ -110,12 +116,22 @@ The Run and Debug view on the left (available via the Activity Bar) shows the cu During a debug session, as long as matplotlib has been imported, one can make plots via the Debug Console or by putting plotting code in the script. ### Automatic docstring generation -Right click at the beginning of the first line *below* the ``def`` statement for any of the functions and choose ``Generate docstring``. The autoDocstring extension should make a new template for a numpy docstring that includes all of the parameters listed in the function signature. +Right click at the beginning of the first line *below* the ``def`` statement for any of the functions and choose ``Generate docstring``. The autoDocstring extension should make a new template for a docstring that includes all of the parameters listed in the function signature. + +Note the format of the docstring, which may be different than the [Numpy-style docstrings](https://numpydoc.readthedocs.io/en/latest/format.html) in the class solution (the most widely-used format for scientific Python). To generate Numpy-style docstrings by default, click on [the Extensions icon](https://code.visualstudio.com/docs/editor/extension-marketplace) on the Activity Bar on the left. Find the autoDocstring extension, right click and select ``Settings``. In the ``Auto Docstring: Docstring Format`` drop-down, select ``numpy``. ### [Code navigation](https://code.visualstudio.com/docs/editor/editingevolved) In the main part of the script, right click on one of the function calls (e.g. ``theis``) and choose ``Go to Definition``. VSCode should take you to where the function is defined. Right clicking on ``theis`` after the ``def`` and then ``Go to References`` opens a "peek" window with a list of all of the times ``theis()`` is called. Clicking on one of them takes you to that location in the script. Navigation works across modules and packages too. If you right click on ``np.meshgrid`` in the main part of the script and ``Go to Definition``, VSCode takes you to the relevant code in ``numpy``. +### Code search +VS Code's powerful search capabilities are another key feature. +* To search for text within a script (for example, the ``theis_xy`` function name), select ``Edit --> Find`` or press ``Ctrl+F``. +* You can also highlight text and press ``Ctrl+F`` to auto-fill the search bar. +* ``Edit --> Find in Files`` will quickly search across all files in a project (i.e., everything within the root folder for the class, which we launched VS Code from earlier). +* ``Edit --> Replace in Files`` can be used to quickly refactor variable names across multiple code modules. +* In complex scripts or workflows, **ease of search is a key reason to choose meaningful and unique variable names!** + ### Liveshare We will demo the Live Share extension during the class. In the meantime, you can learn more about it [here](https://code.visualstudio.com/learn/collaboration/live-share). \ No newline at end of file diff --git a/notebooks/part0_python_intro/10a_Rasterio_into.ipynb b/notebooks/part0_python_intro/10a_Rasterio_intro.ipynb similarity index 100% rename from notebooks/part0_python_intro/10a_Rasterio_into.ipynb rename to notebooks/part0_python_intro/10a_Rasterio_intro.ipynb diff --git a/notebooks/part1_flopy/10a_prt_particle_tracking-demo.ipynb b/notebooks/part1_flopy/10a_prt_particle_tracking-demo.ipynb new file mode 100644 index 00000000..2ca5e5ab --- /dev/null +++ b/notebooks/part1_flopy/10a_prt_particle_tracking-demo.ipynb @@ -0,0 +1,1003 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 10a: Particle tracking with MODFLOW 6 PRT\n", + "In this exercise, we will use the MODFLOW 6 Particle Tracking (PRT) Model to simulate advective transport with a quadtree version of the Freyberg flow model. \n", + "\n", + "The PRT Model calculates three-dimensional, advective particle trajectories in flowing groundwater. The PRT Model is designed to work with the MODFLOW 6 Groundwater Flow (GWF) Model and uses the same spatial discretization, which may be represented using either a structured (DIS) or an unstructured (DISV) grid. The PRT Model replicates much of the functionality of MODPATH 7 and offers support for a much broader class of unstructured grids. The PRT Model can be run in the same simulation as the associated GWF Model or in a separate simulation that reads previously calculated flows from a binary budget file. Currently, the PRT Model documented does not support grids of DISU type, tracking of particles through advanced stress package features such as lakes or streams reaches, or exchange of particles between PRT models.\n", + "\n", + "This exercise demonstrates setting up and running the PRT Model in a separate simulation contained in a subfolder of the groundwater flow model workspace. We will also do some basic post-processing- making plots and exporting results to a GeoPackage for visualization in a GIS environment." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:42.843261Z", + "iopub.status.busy": "2025-05-19T23:51:42.843261Z", + "iopub.status.idle": "2025-05-19T23:51:44.720376Z", + "shell.execute_reply": "2025-05-19T23:51:44.720376Z", + "shell.execute_reply.started": "2025-05-19T23:51:42.843261Z" + } + }, + "outputs": [], + "source": [ + "from IPython.display import clear_output, display\n", + "import os\n", + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import geopandas as gpd\n", + "import matplotlib.pyplot as plt\n", + "from flopy.utils.gridintersect import GridIntersect\n", + "import flopy\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The location of the contamination patch and the nodes that the define bounding cells of the patch are calculated below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:44.721381Z", + "iopub.status.busy": "2025-05-19T23:51:44.721381Z", + "iopub.status.idle": "2025-05-19T23:51:44.732875Z", + "shell.execute_reply": "2025-05-19T23:51:44.732875Z", + "shell.execute_reply.started": "2025-05-19T23:51:44.721381Z" + } + }, + "outputs": [], + "source": [ + "# patch upper left and lower right\n", + "xmin, xmax = 250. * 1, 250. * 3\n", + "ymin, ymax = (40 - 14) * 250., (40 - 11) * 250. \n", + "\n", + "csx, csy = [xmin, xmin, xmax, xmax, xmin], [ymin, ymax, ymax, ymin, ymin]\n", + "polygon = [list(zip(csx, csy))]\n", + "(xmin, ymax), (xmax, ymin)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "--------------------------\n", + "\n", + "### Define the workspace, model names and key options." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:44.734884Z", + "iopub.status.busy": "2025-05-19T23:51:44.734884Z", + "iopub.status.idle": "2025-05-19T23:51:44.739569Z", + "shell.execute_reply": "2025-05-19T23:51:44.739569Z", + "shell.execute_reply.started": "2025-05-19T23:51:44.734884Z" + } + }, + "outputs": [], + "source": [ + "load_ws = Path('data/quadtree')\n", + "gwf_ws = Path(\"temp/ex10a\")\n", + "gwf_name = \"project\"\n", + "#name_mp = f\"{name}_mp\"\n", + "exe_name = 'mf6'\n", + "\n", + "# flow model output files to use with PRT\n", + "headfile = f\"{gwf_name}.hds\"\n", + "budgetfile = f\"{gwf_name}.cbc\"\n", + "\n", + "prt_name = f\"{gwf_name}-prt\"\n", + "prt_model_ws = gwf_ws / 'prt'\n", + "\n", + "# PRT output files\n", + "budgetfile_prt = f\"{prt_name}.cbc\"\n", + "trackfile_prt = f\"{prt_name}.trk\"\n", + "trackcsvfile_prt = f\"{prt_name}.trk.csv\"\n", + "\n", + "# if using \"local_z\" option\n", + "# 1=start particles at top of cell\n", + "# 0=start particles at bottom of cell\n", + "# 1 resulted in Error: release point (z=29.899951638778955) is above grid top 29.886768340000000\n", + "particle_release_zrpt = .99\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load the MODFLOW 6 Model\n", + "\n", + "Load a simulation object using `flopy.mf6.MFSimulation().load()`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:44.740578Z", + "iopub.status.busy": "2025-05-19T23:51:44.740578Z", + "iopub.status.idle": "2025-05-19T23:51:46.326188Z", + "shell.execute_reply": "2025-05-19T23:51:46.326188Z", + "shell.execute_reply.started": "2025-05-19T23:51:44.740578Z" + } + }, + "outputs": [], + "source": [ + "%%capture\n", + "sim = flopy.mf6.MFSimulation.load(sim_name=gwf_name, exe_name=exe_name,\n", + " sim_ws=load_ws)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the groundwater flow model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:46.328195Z", + "iopub.status.busy": "2025-05-19T23:51:46.327194Z", + "iopub.status.idle": "2025-05-19T23:51:46.335263Z", + "shell.execute_reply": "2025-05-19T23:51:46.334255Z", + "shell.execute_reply.started": "2025-05-19T23:51:46.327194Z" + } + }, + "outputs": [], + "source": [ + "gwf = sim.get_model(gwf_name)\n", + "gwf.modelgrid" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Change the workspace" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:46.338264Z", + "iopub.status.busy": "2025-05-19T23:51:46.338264Z", + "iopub.status.idle": "2025-05-19T23:51:46.341860Z", + "shell.execute_reply": "2025-05-19T23:51:46.341860Z", + "shell.execute_reply.started": "2025-05-19T23:51:46.338264Z" + } + }, + "outputs": [], + "source": [ + "sim.set_sim_path(gwf_ws)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Add ``save_saturation`` and ``save_flows`` to the NPF Package\n", + "(required for PRT)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gwf.npf.save_saturation = True\n", + "gwf.npf.save_flows = True" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Write the model files" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:46.343869Z", + "iopub.status.busy": "2025-05-19T23:51:46.343869Z", + "iopub.status.idle": "2025-05-19T23:51:47.335786Z", + "shell.execute_reply": "2025-05-19T23:51:47.335786Z", + "shell.execute_reply.started": "2025-05-19T23:51:46.343869Z" + } + }, + "outputs": [], + "source": [ + "%%capture\n", + "sim.write_simulation()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:47.336791Z", + "iopub.status.busy": "2025-05-19T23:51:47.336791Z", + "iopub.status.idle": "2025-05-19T23:51:48.248739Z", + "shell.execute_reply": "2025-05-19T23:51:48.247730Z", + "shell.execute_reply.started": "2025-05-19T23:51:47.336791Z" + } + }, + "outputs": [], + "source": [ + "sim.run_simulation()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create and Run the PRT model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot the model grid and the location of the contamination patch" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:48.249738Z", + "iopub.status.busy": "2025-05-19T23:51:48.249738Z", + "iopub.status.idle": "2025-05-19T23:51:49.499193Z", + "shell.execute_reply": "2025-05-19T23:51:49.498182Z", + "shell.execute_reply.started": "2025-05-19T23:51:48.249738Z" + } + }, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(5, 9))\n", + "mm = flopy.plot.PlotMapView(gwf, layer=0, ax=ax)\n", + "\n", + "mm.plot_bc('SFR', color=\"b\", plotAll=True)\n", + "mm.plot_bc('WEL', plotAll=True)\n", + "mm.plot_inactive(alpha=0.75)\n", + "\n", + "mm.plot_grid(lw=0.25, color='grey')\n", + "\n", + "ax.fill(csx, csy, color='#e534eb');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Get the model cells intersecting the contamination patch\n", + "The `GridIntersect` utility in Flopy has an `intersect` method that can find the model cells intersecting a set of points, lines, or polygons. Since this is a DISV grid, these will be ``cell2d`` values (that are the same across the model layers). Similarly, for a structured grid, `GridIntersect` would return row, column locations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:49.500189Z", + "iopub.status.busy": "2025-05-19T23:51:49.499193Z", + "iopub.status.idle": "2025-05-19T23:51:49.710246Z", + "shell.execute_reply": "2025-05-19T23:51:49.710246Z", + "shell.execute_reply.started": "2025-05-19T23:51:49.500189Z" + } + }, + "outputs": [], + "source": [ + "gx = GridIntersect(gwf.modelgrid)\n", + "results = gx.intersect(polygon, 'Polygon')\n", + "particle_start_nodes = results.cellids.astype(int)\n", + "particle_start_nodes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Instantiate the MODFLOW 6 prt model\n", + "and discretization packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prt_sim = flopy.mf6.MFSimulation(sim_name=prt_name, sim_ws=prt_model_ws)\n", + "\n", + "# Instantiate the MODFLOW 6 temporal discretization package\n", + "flopy.mf6.modflow.mftdis.ModflowTdis(\n", + " prt_sim,\n", + " time_units=\"DAYS\",\n", + " nper=1,\n", + " perioddata=[(1, 1, 1)], # perlen, nstp, tsmult\n", + ")\n", + "prt = flopy.mf6.ModflowPrt(\n", + " prt_sim, modelname=prt_name, model_nam_file=f\"{prt_name}.nam\"\n", + ")\n", + "\n", + "# Instantiate the MODFLOW 6 prt discretization package\n", + "nlay, ncells_per_layer = gwf.dis.botm.array.shape\n", + "disv = flopy.mf6.ModflowGwfdisv(\n", + " prt,\n", + " nlay=nlay,\n", + " ncpl=gwf.dis.ncpl.array,\n", + " nvert=gwf.dis.nvert.array,\n", + " length_units=gwf.dis.length_units.array,\n", + " top=gwf.dis.top.array,\n", + " botm=gwf.dis.botm.array,\n", + " vertices=gwf.dis.vertices.array,\n", + " cell2d=gwf.dis.cell2d.array,\n", + " idomain=gwf.dis.idomain.array,\n", + " xorigin=gwf.dis.xorigin.array,\n", + " yorigin=gwf.dis.yorigin.array,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Instantiate the MODFLOW 6 PRT Model Input Package.\n", + "\n", + "**First make an ``izone`` array** with a zone number for each cell. The \"izone\" for the model cell will be reported in the PRT output, allowing us to more easily track where particles go, and where they ultimately discharge. For example, if we start particles at the water table, we can determine the contributing area for a stream or other boundary condition, by assigning an izone to those cells. One of the izone numbers can be designated as an ``istopzone``; particles entering this zone will be terminated regardless of whether the zone is a strong sink or not.\n", + "\n", + "In this example, we'll assign different izone numbers to SFR and Well Package cells." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# start with a default zone of 0\n", + "izone_array = np.zeros((nlay, ncells_per_layer), dtype=int)\n", + "\n", + "# get the locations of SFR cells\n", + "sfr_k, sfr_cellid = zip(*gwf.sfr.packagedata.array['cellid'])\n", + "sfr_k[:10], sfr_cellid[:10]\n", + "\n", + "izones = {\n", + " 'wel': 1,\n", + " 'sfr': 2\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Assign SFR cells to zone 2**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "izone_array[sfr_k, sfr_cellid] = izones['sfr']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Assign wells to zone 1**\n", + "Using the stress period data. Note that in models with more than one stress period, different wells may be represented in different stress periods." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "well_k = list()\n", + "well_cellid = list()\n", + "for per, recarray in gwf.wel.stress_period_data.data.items():\n", + " well_k_per, well_cellid_per = zip(*recarray['cellid'])\n", + " well_k.append(well_k_per)\n", + " well_cellid.append(well_cellid_per)\n", + "\n", + "izone_array[well_k, well_cellid] = izones['wel']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Make the package**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "flopy.mf6.ModflowPrtmip(prt,\n", + " porosity=0.1, \n", + " izone=izone_array\n", + " ) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create the particle start data\n", + "From the nodes intersecting the polygon we made above, develop a DataFrame of particle start locations. For simplicity, we are just starting a single particle in each cell, but since the x and y are in local (model) coordinates, it would be fairly straightforward to start multiple particles in each cell on a finer spacing. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# release particles at each row, column location\n", + "prt_start_x, prt_start_y = gwf.modelgrid.get_local_coords(\n", + " gwf.modelgrid.xcellcenters[particle_start_nodes], \n", + " gwf.modelgrid.ycellcenters[particle_start_nodes])\n", + "\n", + "prt_start_data = pd.DataFrame({\n", + " 'irptno': np.arange(len(prt_start_x.ravel())),\n", + " 'k': 0,\n", + " 'cell2d': particle_start_nodes,\n", + " 'xrpt': prt_start_x.ravel(),\n", + " 'yrpt': prt_start_y.ravel(),\n", + " # start particles near top of saturation in cell with local_z=True\n", + " 'zrpt': particle_release_zrpt, #[1] * len(prt_i) ,\n", + " # generic boundname for now;\n", + " # could be used to differentiate source areas\n", + " 'boundname': [f'prt_{cell2d}' for cell2d in particle_start_nodes]\n", + "})\n", + "#prt_start_data = prt_particle_data\n", + "prt_start_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternatively, the [Modflow 6 Examples](https://github.com/MODFLOW-ORG/modflow6-examples/blob/develop/scripts/ex-prt-mp7-p02.py) illustrate functionality in Flopy to generate evenly spaced particles along cell faces for MODPATH models, and then convert the results to PRT format (if you can get it to work; search the MODFLOW 6 Examples repository for \"``ModflowPrtprp``\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sd = flopy.modpath.CellDataType()\n", + "mp7_particle_data = flopy.modpath.NodeParticleData(subdivisiondata=[sd],\n", + " nodes=list(particle_start_nodes))\n", + "prt_particle_data = list(mp7_particle_data.to_prp(prt.modelgrid))\n", + "prt_particle_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Instantiate the MODFLOW 6 prt particle release point (PRP) package\n", + "\n", + "**Notes:**\n", + "\n", + "``local_z``—indicates that “zrpt” [in the particle start data] defines the local z coordinate of the release point within the cell, with value of 0\n", + "at the bottom and 1 at the top of the cell. If the cell is partially saturated at release time, the top of the cell is\n", + "considered to be the water table elevation (the head in the cell) rather than the top defined by the user. \n", + "\n", + "``istopzone``—integer value defining the stop zone number. If cells have been assigned IZONE values in the\n", + "GRIDDATA block, a particle terminates if it enters a cell whose IZONE value matches ISTOPZONE. An\n", + "ISTOPZONE value of zero indicates that there is no stop zone. The default value is zero. This way we can allow weak sinks but have exceptions where the particles will stop anyways. \n", + "\n", + "See the MODFLOW 6 Description of Input and Output for more options\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "flopy.mf6.ModflowPrtprp(\n", + " prt,\n", + " nreleasepts=len(prt_start_data),\n", + " packagedata=prt_start_data.to_records(index=False).tolist(),\n", + " local_z=True,\n", + " boundnames=True,\n", + " perioddata={0: [\"FIRST\"]},\n", + " exit_solve_tolerance=1e-5,\n", + " extend_tracking=True,\n", + " #istopzone=istopzone\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Instantiate the MODFLOW 6 PRT output control package\n", + "\n", + "**Notes:**\n", + "PRT outputs a record each time a:\n", + " 0: particle was released\n", + " 1: particle exited a cell\n", + " 2: time step ended\n", + " 3: particle terminated\n", + " 4: particle entered a weak sink cell\n", + " 5: user-specified tracking time\n", + " \n", + "The code below shows how to input user-specified tracking times to Flopy. Depending on the problem, this may not be necessary in a real-world context, as there may already be many records from particles exiting cells. Therefore, `tracktimes=None` (no user-specified times) is ultimately input to Flopy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "budget_record = [budgetfile_prt]\n", + "track_record = [trackfile_prt]\n", + "trackcsv_record = [trackcsvfile_prt]\n", + "# track positions every year for 100 years\n", + "track_nyears = 100\n", + "tracktimes = np.linspace(0, track_nyears*365.25, track_nyears+1)\n", + "flopy.mf6.ModflowPrtoc(\n", + " prt,\n", + " budget_filerecord=budget_record,\n", + " track_filerecord=track_record,\n", + " trackcsv_filerecord=trackcsv_record,\n", + " ntracktimes=0,#len(tracktimes),\n", + " tracktimes=None,#[(t,) for t in tracktimes],\n", + " saverecord=[(\"BUDGET\", \"ALL\")],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Instantiate the PRT Flow Model Interface and Explicit Model Solution Packages\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fmi_pd = [\n", + " (\"GWFHEAD\", os.path.relpath(gwf_ws / headfile, prt_model_ws)), #Path(f\"../{gwf_ws.name}/{headfile}\")),\n", + " (\"GWFBUDGET\", os.path.relpath(gwf_ws / budgetfile, prt_model_ws)) #Path(f\"../{gwf_ws.name}/{budgetfile}\")),\n", + "]\n", + "flopy.mf6.ModflowPrtfmi(prt, packagedata=fmi_pd)\n", + "\n", + "# Create an explicit model solution (EMS) for the MODFLOW 6 prt model\n", + "ems = flopy.mf6.ModflowEms(\n", + " prt_sim,\n", + " filename=f\"{prt_name}.ems\",\n", + ")\n", + "sim.register_solution_package(ems, [prt.name])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Write the PRT input files and run the model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prt_sim.write_simulation()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:49.759280Z", + "iopub.status.busy": "2025-05-19T23:51:49.758283Z", + "iopub.status.idle": "2025-05-19T23:51:50.320224Z", + "shell.execute_reply": "2025-05-19T23:51:50.319210Z", + "shell.execute_reply.started": "2025-05-19T23:51:49.759280Z" + } + }, + "outputs": [], + "source": [ + "prt_sim.run_simulation()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Post-Process the MODFLOW and PRT Results\n", + "\n", + "\n", + "### Load MODFLOW and PRT results from the heads and pathline files\n", + "\n", + "Load the MODFLOW heads" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:50.326230Z", + "iopub.status.busy": "2025-05-19T23:51:50.324226Z", + "iopub.status.idle": "2025-05-19T23:51:50.336707Z", + "shell.execute_reply": "2025-05-19T23:51:50.335695Z", + "shell.execute_reply.started": "2025-05-19T23:51:50.326230Z" + } + }, + "outputs": [], + "source": [ + "hobj = gwf.output.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:50.338705Z", + "iopub.status.busy": "2025-05-19T23:51:50.338705Z", + "iopub.status.idle": "2025-05-19T23:51:50.346022Z", + "shell.execute_reply": "2025-05-19T23:51:50.345014Z", + "shell.execute_reply.started": "2025-05-19T23:51:50.338705Z" + } + }, + "outputs": [], + "source": [ + "hds = hobj.get_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load the tracking CSV file" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:50.348023Z", + "iopub.status.busy": "2025-05-19T23:51:50.347022Z", + "iopub.status.idle": "2025-05-19T23:51:50.410326Z", + "shell.execute_reply": "2025-05-19T23:51:50.409317Z", + "shell.execute_reply.started": "2025-05-19T23:51:50.348023Z" + } + }, + "outputs": [], + "source": [ + "particle_data = pd.read_csv(prt_model_ws / trackcsvfile_prt)\n", + "particle_data.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot the heads and pathlines" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:50.435176Z", + "iopub.status.busy": "2025-05-19T23:51:50.434174Z", + "iopub.status.idle": "2025-05-19T23:51:51.973396Z", + "shell.execute_reply": "2025-05-19T23:51:51.973396Z", + "shell.execute_reply.started": "2025-05-19T23:51:50.435176Z" + } + }, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(5, 9))\n", + "mm = flopy.plot.PlotMapView(model=gwf, layer=0, ax=ax)\n", + "mm.plot_array(hds, masked_values=[1e30])\n", + "\n", + "mm.plot_bc('SFR', color='b', plotAll=True)\n", + "mm.plot_bc('WEL', plotAll=True)\n", + "mm.plot_ibound()\n", + "mm.plot_pathline(particle_data, layer='all', color='blue', lw=1)\n", + "mm.plot_grid(lw=0.2, color=\"0.5\")\n", + "\n", + "ax = plt.gca()\n", + "ax.fill(csx, csy, color='#e534eb', zorder=100, alpha=.75);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:51:51.974407Z", + "iopub.status.busy": "2025-05-19T23:51:51.974407Z", + "iopub.status.idle": "2025-05-19T23:52:39.589909Z", + "shell.execute_reply": "2025-05-19T23:52:39.588899Z", + "shell.execute_reply.started": "2025-05-19T23:51:51.974407Z" + } + }, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(5, 9))\n", + "\n", + "mm = flopy.plot.PlotMapView(model=gwf, ax=ax, layer=0)\n", + "mm.plot_array(hds, masked_values=[1e30])\n", + "mm.plot_bc('SFR', color='b', plotAll=True)\n", + "mm.plot_bc('WEL', plotAll=True)\n", + "mm.plot_ibound()\n", + "mm.plot_grid(lw=0.2, color=\"0.5\")\n", + "\n", + "df = particle_data\n", + "vmin, vmax = df['t'].min(), df['t'].max()\n", + "\n", + "times = list(range(0, 74001, 1000))\n", + "for ix in range(1, len(times)):\n", + " tmp = df[(df['t'] >= times[ix - 1]) & (df['t'] < times[ix])]\n", + " s = ax.scatter(tmp['x'].values, tmp['y'].values, s=5, c=tmp['t'].values, \n", + " vmin=vmin, vmax=vmax, cmap=\"magma\")\n", + " ax.set_title(f\"{times[ix - 1]} - {times[ix]} days\")\n", + " if ix == 1:\n", + " cbar = fig.colorbar(s, shrink=0.7)\n", + " cbar.set_label('particle travel time from source', rotation=270, labelpad=14)\n", + " display(fig)\n", + " clear_output(wait=True)\n", + " plt.pause(0.1) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Export the pathlines to a GeoPackage\n", + "GeoPackages allow for subsequent adding of layers; delete any pre-existing version of this GeoPackage to clear any pre-existing layers (often good practice in real projects)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "output_geopackage = Path(prt_model_ws / 'Pathlines.gpkg')\n", + "output_geopackage.unlink(missing_ok=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### First the PRT results DataFrame needs to be converted to a ``GeoDataFrame``\n", + "* In the real world, the model coordinates also need to be converted to real world coordinates. \n", + "* We may also want to convert the travel times from the typical model time units of days to years.\n", + "* We may want to decompose the ``cellid`` into model layer (`k`) and ``cell2d`` (location in each layer, in this case), or layer, row column if the model has a regular structured grid.\n", + "* Finally, the GeoDataFrame will need a coordinate reference (to write to the GeoPackage) defining the coordinate reference system for the real-world coordinates (for example, UTM zone 15 north, represented by EPSG code 29615)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gwf.modelgrid.crs # no CRS attached" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gwf.modelgrid.crs = 26915" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df['t_years'] = df['t'] * 325.25\n", + "df['k'] = df['icell'].values[-1] // ncells_per_layer\n", + "df['cell2d'] = df['icell'].values[-1] % ncells_per_layer\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x_crs, y_crs = gwf.modelgrid.get_coords(df['x'], df['y'])\n", + "\n", + "gdf = gpd.GeoDataFrame(df, \n", + " geometry=gpd.points_from_xy(x_crs, y_crs),\n", + " crs=gwf.modelgrid.crs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### write the GeoPackage\n", + "Write particles terminating in Well and SFR cells to separate layers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for package, izone in izones.items():\n", + " layer_name = f\"Particles going to {package.upper()} cells\"\n", + " izone_df = gdf.loc[gdf['izone'] == izone]\n", + " izone_df.to_file(output_geopackage, index=False, layer=layer_name)\n", + "\n", + "gdf.loc[gdf['izone'] == 0].to_file(\n", + " output_geopackage, index=False, layer='All other particles')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Add a layer with pathlines\n", + "The previous layers that we added to the GeoPackage were points representing particle locations at discrete points in time. We can also combine these in to pathlines (linestrings) to better visualize the paths taken by the particles. In real-world projects, for example where are particle is started in every cell of a large model, we may also have too many points to work with easily; showing a single pathline for each particle may be advantageous." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from shapely.geometry import LineString\n", + "\n", + "# create set of pathlines with start and end information\n", + "# first group by particle\n", + "by_particle = gdf.sort_values(by=['irpt', 't']).groupby('irpt')\n", + "lines = by_particle.last()\n", + "lines.crs = gdf.crs # CRS isn't retained in groupby\n", + "lines.rename(columns={'k': 'end_k', 'cell2d': 'end_cell2d'}, inplace=True)\n", + "line_starts = by_particle.first()\n", + "lines['start_k'] = line_starts['k']\n", + "lines['start_cell2d'] = line_starts['cell2d']\n", + "\n", + "# above we sorted the results by particle and then time\n", + "# use the .agg method on the grouby object to create a LineString\n", + "# from the (sorted) sequence of points defining each particle path\n", + "linestring_geoms = by_particle['geometry'].agg(lambda x: LineString(x))\n", + "lines['geometry'] = linestring_geoms" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for package, izone in izones.items():\n", + " layer_name = f\"Pathlines going to {package.upper()} cells\"\n", + " izone_df = lines.loc[lines['izone'] == izone]\n", + " izone_df.to_file(output_geopackage, index=False, layer=layer_name)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot pathlines going to SFR and WEL cells" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-19T23:52:41.021991Z", + "iopub.status.busy": "2025-05-19T23:52:41.021022Z", + "iopub.status.idle": "2025-05-19T23:52:43.070799Z", + "shell.execute_reply": "2025-05-19T23:52:43.069784Z", + "shell.execute_reply.started": "2025-05-19T23:52:41.021991Z" + } + }, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(6, 10))\n", + "pmv = flopy.plot.PlotMapView(gwf, ax=ax)\n", + "pmv.plot_grid(lw=0.5)\n", + "line_colors = {\n", + " 'sfr': 'b',\n", + " 'wel': 'r'\n", + "}\n", + "for package, izone in izones.items():\n", + " izone_df = lines.loc[lines['izone'] == izone]\n", + " izone_df.plot(ax=ax, ec=line_colors[package],\n", + " label=f'Pathlines going to {package.upper()} cells')\n", + "pmv.plot_ibound()\n", + "pmv.ax.legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pyclass", + "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.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/part1_flopy/10_modpath_particle_tracking-demo.ipynb b/notebooks/part1_flopy/10b_modpath_particle_tracking-demo.ipynb similarity index 96% rename from notebooks/part1_flopy/10_modpath_particle_tracking-demo.ipynb rename to notebooks/part1_flopy/10b_modpath_particle_tracking-demo.ipynb index effcb886..e9cb1e1f 100644 --- a/notebooks/part1_flopy/10_modpath_particle_tracking-demo.ipynb +++ b/notebooks/part1_flopy/10b_modpath_particle_tracking-demo.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# 10: Particle tracking with MODPATH\n", + "# 10b: Particle tracking with MODPATH\n", "In this exercise, we will use MODPATH to simulate advective transport with the Freyberg flow model. \n", "\n", "MODPATH is a particle tracking software that simulates the advective transport of particles using the output from a MODFLOW groundwater flow model. The MODPATH user guide, documentation, and executable can be found [here](https://www.usgs.gov/software/modpath-particle-tracking-model-modflow). The MODPATH executable is downloaded with the stack of modflow related programs when `get_modflow()` was run in setup for this course. Students should already have this program on their machines.\n", @@ -27,7 +27,7 @@ "outputs": [], "source": [ "from IPython.display import clear_output, display\n", - "import pathlib as pl\n", + "from pathlib import Path\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import geopandas as gpd\n", @@ -100,8 +100,8 @@ }, "outputs": [], "source": [ - "load_ws = pl.Path('data/quadtree')\n", - "ws = pl.Path(\"temp/ex10a\")\n", + "load_ws = Path('data/quadtree')\n", + "ws = Path(\"temp/ex10a\")\n", "name = \"project\"\n", "name_mp = f\"{name}_mp\"\n", "exe_name = 'mf6'" @@ -241,61 +241,18 @@ }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "FloPy is using the following executable to run the model: ..\\..\\..\\..\\..\\..\\AppData\\Local\\Microsoft\\WindowsApps\\mf6.exe\n", - " MODFLOW 6\n", - " U.S. GEOLOGICAL SURVEY MODULAR HYDROLOGIC MODEL\n", - " VERSION 6.5.0 05/23/2024\n", - "\n", - " MODFLOW 6 compiled Jun 21 2024 02:57:23 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", - " MODFLOW runs in SEQUENTIAL mode\n", - " \n", - " Run start date and time (yyyy/mm/dd hh:mm:ss): 2025/05/19 16:51:47\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): 2025/05/19 16:51:48\n", - " Elapsed run time: 0.872 Seconds\n", - " \n", - "\n", - "WARNING REPORT:\n", - "\n", - " 1. OPTIONS BLOCK VARIABLE 'UNIT_CONVERSION' IN FILE 'project.sfr' WAS\n", - " DEPRECATED IN VERSION 6.4.2. SETTING UNIT_CONVERSION DIRECTLY.\n", - " Normal termination of simulation.\n" + "ename": "FileNotFoundError", + "evalue": "The program mf6 does not exist or is not executable.", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mFileNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[8]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43msim\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_simulation\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/pyclass/lib/python3.12/site-packages/flopy/mf6/mfsimbase.py:1820\u001b[39m, in \u001b[36mMFSimulationBase.run_simulation\u001b[39m\u001b[34m(self, silent, pause, report, processors, normal_msg, use_async, cargs, custom_print)\u001b[39m\n\u001b[32m 1818\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 1819\u001b[39m silent = \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1820\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mrun_model\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1821\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mexe_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1822\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 1823\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43msimulation_data\u001b[49m\u001b[43m.\u001b[49m\u001b[43mmfpath\u001b[49m\u001b[43m.\u001b[49m\u001b[43mget_sim_path\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1824\u001b[39m \u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[43m=\u001b[49m\u001b[43msilent\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1825\u001b[39m \u001b[43m \u001b[49m\u001b[43mpause\u001b[49m\u001b[43m=\u001b[49m\u001b[43mpause\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1826\u001b[39m \u001b[43m \u001b[49m\u001b[43mreport\u001b[49m\u001b[43m=\u001b[49m\u001b[43mreport\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1827\u001b[39m \u001b[43m \u001b[49m\u001b[43mprocessors\u001b[49m\u001b[43m=\u001b[49m\u001b[43mprocessors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1828\u001b[39m \u001b[43m \u001b[49m\u001b[43mnormal_msg\u001b[49m\u001b[43m=\u001b[49m\u001b[43mnormal_msg\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1829\u001b[39m \u001b[43m \u001b[49m\u001b[43muse_async\u001b[49m\u001b[43m=\u001b[49m\u001b[43muse_async\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1830\u001b[39m \u001b[43m \u001b[49m\u001b[43mcargs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1831\u001b[39m \u001b[43m \u001b[49m\u001b[43mcustom_print\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcustom_print\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1832\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/pyclass/lib/python3.12/site-packages/flopy/mbase.py:1692\u001b[39m, in \u001b[36mrun_model\u001b[39m\u001b[34m(exe_name, namefile, model_ws, silent, pause, report, processors, normal_msg, use_async, cargs, custom_print)\u001b[39m\n\u001b[32m 1690\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m exe_name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 1691\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33m\"\u001b[39m\u001b[33mAn executable name or path must be provided\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m-> \u001b[39m\u001b[32m1692\u001b[39m exe_path = \u001b[43mresolve_exe\u001b[49m\u001b[43m(\u001b[49m\u001b[43mexe_name\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1693\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m silent:\n\u001b[32m 1694\u001b[39m \u001b[38;5;28mprint\u001b[39m(\n\u001b[32m 1695\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mFloPy is using the following executable to run the model: \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 1696\u001b[39m + flopy_io.relpath_safe(exe_path, model_ws)\n\u001b[32m 1697\u001b[39m )\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/pyclass/lib/python3.12/site-packages/flopy/mbase.py:110\u001b[39m, in \u001b[36mresolve_exe\u001b[39m\u001b[34m(exe_name, forgive)\u001b[39m\n\u001b[32m 104\u001b[39m warn(\n\u001b[32m 105\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mThe program \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexe_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m does not exist or is not executable.\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 106\u001b[39m category=\u001b[38;5;167;01mUserWarning\u001b[39;00m,\n\u001b[32m 107\u001b[39m )\n\u001b[32m 108\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m110\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mFileNotFoundError\u001b[39;00m(\n\u001b[32m 111\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mThe program \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexe_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m does not exist or is not executable.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 112\u001b[39m )\n", + "\u001b[31mFileNotFoundError\u001b[39m: The program mf6 does not exist or is not executable." ] - }, - { - "data": { - "text/plain": [ - "(True, [])" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -327,7 +284,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -419,6 +376,25 @@ " filename=fpth)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'CellDataType' object has no attribute 'data'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mAttributeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[25]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43msd\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdata\u001b[49m\n", + "\u001b[31mAttributeError\u001b[39m: 'CellDataType' object has no attribute 'data'" + ] + } + ], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, @@ -428,7 +404,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "metadata": { "execution": { "iopub.execute_input": "2025-05-19T23:51:49.720218Z", @@ -447,9 +423,9 @@ "\n", "class Modpath7Sim(flopy.pakbase.Package)\n", " | Modpath7Sim(model, mpnamefilename=None, listingfilename=None, endpointfilename=None, pathlinefilename=None, timeseriesfilename=None, tracefilename=None, simulationtype='pathline', trackingdirection='forward', weaksinkoption='stop_at', weaksourceoption='stop_at', budgetoutputoption='no', traceparticledata=None, budgetcellnumbers=None, referencetime=None, stoptimeoption='extend', stoptime=None, timepointdata=None, zonedataoption='off', stopzone=None, zones=0, retardationfactoroption='off', retardation=1.0, particlegroups=None, extension='mpsim')\n", - " | \n", + " |\n", " | MODPATH Simulation File Package Class.\n", - " | \n", + " |\n", " | Parameters\n", " | ----------\n", " | model : model object\n", @@ -573,55 +549,55 @@ " | particle in the center of node 0 will be created (default is None).\n", " | extension : string\n", " | Filename extension (default is 'mpsim')\n", - " | \n", + " |\n", " | Examples\n", " | --------\n", - " | \n", + " |\n", " | >>> import flopy\n", " | >>> m = flopy.modflow.Modflow.load('mf2005.nam')\n", " | >>> mp = flopy.modpath.Modpath7('mf2005_mp', flowmodel=m)\n", " | >>> mpsim = flopy.modpath.Modpath7Sim(mp)\n", - " | \n", + " |\n", " | Method resolution order:\n", " | Modpath7Sim\n", " | flopy.pakbase.Package\n", " | flopy.pakbase.PackageInterface\n", " | builtins.object\n", - " | \n", + " |\n", " | Methods defined here:\n", - " | \n", + " |\n", " | __init__(self, model, mpnamefilename=None, listingfilename=None, endpointfilename=None, pathlinefilename=None, timeseriesfilename=None, tracefilename=None, simulationtype='pathline', trackingdirection='forward', weaksinkoption='stop_at', weaksourceoption='stop_at', budgetoutputoption='no', traceparticledata=None, budgetcellnumbers=None, referencetime=None, stoptimeoption='extend', stoptime=None, timepointdata=None, zonedataoption='off', stopzone=None, zones=0, retardationfactoroption='off', retardation=1.0, particlegroups=None, extension='mpsim')\n", " | Initialize self. See help(type(self)) for accurate signature.\n", - " | \n", + " |\n", " | write_file(self, check=False)\n", " | Write the package file\n", - " | \n", + " |\n", " | Parameters\n", " | ----------\n", " | check : boolean\n", " | Check package data for common errors. (default False)\n", - " | \n", + " |\n", " | Returns\n", " | -------\n", " | None\n", - " | \n", + " |\n", " | ----------------------------------------------------------------------\n", " | Methods inherited from flopy.pakbase.Package:\n", - " | \n", + " |\n", " | __getitem__(self, item)\n", - " | \n", + " |\n", " | __repr__(self)\n", " | Return repr(self).\n", - " | \n", + " |\n", " | __setattr__(self, key, value)\n", " | Implement setattr(self, name, value).\n", - " | \n", + " |\n", " | __setitem__(self, key, value)\n", - " | \n", + " |\n", " | export(self, f, **kwargs)\n", " | Method to export a package to netcdf or shapefile based on the\n", " | extension of the file name (.shp for shapefile, .nc for netcdf)\n", - " | \n", + " |\n", " | Parameters\n", " | ----------\n", " | f : str\n", @@ -630,17 +606,17 @@ " | modelgrid : flopy.discretization.Grid instance\n", " | user supplied modelgrid which can be used for exporting\n", " | in lieu of the modelgrid associated with the model object\n", - " | \n", + " |\n", " | Returns\n", " | -------\n", " | None or Netcdf object\n", - " | \n", + " |\n", " | level1_arraylist(self, idx, v, name, txt)\n", - " | \n", + " |\n", " | plot(self, **kwargs)\n", " | Plot 2-D, 3-D, transient 2-D, and stress period list (MfList)\n", " | package input data\n", - " | \n", + " |\n", " | Parameters\n", " | ----------\n", " | **kwargs : dict\n", @@ -659,39 +635,39 @@ " | zero)\n", " | key : str\n", " | MfList dictionary key. (default is None)\n", - " | \n", + " |\n", " | Returns\n", " | -------\n", " | axes : list\n", " | Empty list is returned if filename_base is not None. Otherwise\n", " | a list of matplotlib.pyplot.axis are returned.\n", - " | \n", + " |\n", " | See Also\n", " | --------\n", - " | \n", + " |\n", " | Notes\n", " | -----\n", - " | \n", + " |\n", " | Examples\n", " | --------\n", " | >>> import flopy\n", " | >>> ml = flopy.modflow.Modflow.load('test.nam')\n", " | >>> ml.dis.plot()\n", - " | \n", + " |\n", " | set_cbc_output_file(self, ipakcb, model, fname)\n", - " | \n", + " |\n", " | to_shapefile(self, *args, **kwargs)\n", " | Raises AttributeError, use :meth:`export`.\n", - " | \n", + " |\n", " | webdoc(self)\n", " | Open the web documentation.\n", - " | \n", + " |\n", " | ----------------------------------------------------------------------\n", " | Static methods inherited from flopy.pakbase.Package:\n", - " | \n", + " |\n", " | add_to_dtype(dtype, field_names, field_types)\n", " | Add one or more fields to a structured array data type\n", - " | \n", + " |\n", " | Parameters\n", " | ----------\n", " | dtype : numpy.dtype\n", @@ -701,32 +677,32 @@ " | field_types : numpy.dtype or list\n", " | One or more data types. If one data type is supplied, it is\n", " | repeated for each field name.\n", - " | \n", + " |\n", " | load(f: Union[str, bytes, os.PathLike], model, pak_type, ext_unit_dict=None, **kwargs)\n", " | Default load method for standard boundary packages.\n", - " | \n", + " |\n", " | ----------------------------------------------------------------------\n", " | Readonly properties inherited from flopy.pakbase.Package:\n", - " | \n", + " |\n", " | data_list\n", - " | \n", + " |\n", " | package_type\n", - " | \n", + " |\n", " | plottable\n", - " | \n", + " |\n", " | ----------------------------------------------------------------------\n", " | Data descriptors inherited from flopy.pakbase.Package:\n", - " | \n", + " |\n", " | name\n", - " | \n", + " |\n", " | parent\n", - " | \n", + " |\n", " | ----------------------------------------------------------------------\n", " | Methods inherited from flopy.pakbase.PackageInterface:\n", - " | \n", + " |\n", " | check(self, f=None, verbose=True, level=1, checktype=None)\n", " | Check package data for common errors.\n", - " | \n", + " |\n", " | Parameters\n", " | ----------\n", " | f : str or file handle\n", @@ -743,33 +719,41 @@ " | checktype : check\n", " | Checker type to be used. By default class check is used from\n", " | check.py.\n", - " | \n", + " |\n", " | Returns\n", " | -------\n", " | None\n", - " | \n", + " |\n", " | Examples\n", " | --------\n", - " | \n", + " |\n", " | >>> import flopy\n", " | >>> m = flopy.modflow.Modflow.load('model.nam')\n", " | >>> m.dis.check()\n", - " | \n", + " |\n", " | ----------------------------------------------------------------------\n", " | Readonly properties inherited from flopy.pakbase.PackageInterface:\n", - " | \n", + " |\n", " | has_stress_period_data\n", - " | \n", + " |\n", " | ----------------------------------------------------------------------\n", " | Data descriptors inherited from flopy.pakbase.PackageInterface:\n", - " | \n", + " |\n", " | __dict__\n", " | dictionary for instance variables\n", - " | \n", + " |\n", " | __weakref__\n", " | list of weak references to the object\n", "\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/aleaf/miniforge3/envs/pyclass/lib/python3.12/site-packages/flopy/mbase.py:104: UserWarning: The program mp7 does not exist or is not executable.\n", + " warn(\n" + ] } ], "source": [ @@ -796,7 +780,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "metadata": { "execution": { "iopub.execute_input": "2025-05-19T23:51:49.759280Z", @@ -808,42 +792,17 @@ }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "FloPy is using the following executable to run the model: ..\\..\\..\\..\\..\\..\\AppData\\Local\\Microsoft\\WindowsApps\\mp7.exe\n", - "\n", - "MODPATH Version 7.2.001 \n", - "Program compiled Jun 21 2024 03:01:44 with IFORT compiler (ver. 20.21.7) \n", - " \n", - " \n", - "Run particle tracking simulation ...\n", - "Processing Time Step 1 Period 1. Time = 1.00000E+00 Steady-state flow \n", - "\n", - "Particle Summary:\n", - " 0 particles are pending release.\n", - " 0 particles remain active.\n", - " 0 particles terminated at boundary faces.\n", - " 0 particles terminated at weak sink cells.\n", - " 0 particles terminated at weak source cells.\n", - " 162 particles terminated at strong source/sink cells.\n", - " 0 particles terminated in cells with a specified zone number.\n", - " 0 particles were stranded in inactive or dry cells.\n", - " 0 particles were unreleased.\n", - " 0 particles have an unknown status.\n", - " \n", - "Normal termination. \n" + "ename": "ValueError", + "evalue": "An executable name or path must be provided", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[16]\u001b[39m\u001b[32m, line 5\u001b[39m\n\u001b[32m 2\u001b[39m mp.write_input()\n\u001b[32m 4\u001b[39m \u001b[38;5;66;03m# run modpath\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m5\u001b[39m \u001b[43mmp\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/pyclass/lib/python3.12/site-packages/flopy/mbase.py:1382\u001b[39m, in \u001b[36mBaseModel.run_model\u001b[39m\u001b[34m(self, silent, pause, report, normal_msg)\u001b[39m\n\u001b[32m 1352\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mrun_model\u001b[39m(\n\u001b[32m 1353\u001b[39m \u001b[38;5;28mself\u001b[39m,\n\u001b[32m 1354\u001b[39m silent=\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[32m (...)\u001b[39m\u001b[32m 1357\u001b[39m normal_msg=\u001b[33m\"\u001b[39m\u001b[33mnormal termination\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 1358\u001b[39m ) -> \u001b[38;5;28mtuple\u001b[39m[\u001b[38;5;28mbool\u001b[39m, \u001b[38;5;28mlist\u001b[39m[\u001b[38;5;28mstr\u001b[39m]]:\n\u001b[32m 1359\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 1360\u001b[39m \u001b[33;03m This method will run the model using subprocess.Popen.\u001b[39;00m\n\u001b[32m 1361\u001b[39m \n\u001b[32m (...)\u001b[39m\u001b[32m 1379\u001b[39m \n\u001b[32m 1380\u001b[39m \u001b[33;03m \"\"\"\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1382\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mrun_model\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1383\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mexe_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1384\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mnamefile\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1385\u001b[39m \u001b[43m \u001b[49m\u001b[43mmodel_ws\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mmodel_ws\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1386\u001b[39m \u001b[43m \u001b[49m\u001b[43msilent\u001b[49m\u001b[43m=\u001b[49m\u001b[43msilent\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1387\u001b[39m \u001b[43m \u001b[49m\u001b[43mpause\u001b[49m\u001b[43m=\u001b[49m\u001b[43mpause\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1388\u001b[39m \u001b[43m \u001b[49m\u001b[43mreport\u001b[49m\u001b[43m=\u001b[49m\u001b[43mreport\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1389\u001b[39m \u001b[43m \u001b[49m\u001b[43mnormal_msg\u001b[49m\u001b[43m=\u001b[49m\u001b[43mnormal_msg\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1390\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/pyclass/lib/python3.12/site-packages/flopy/mbase.py:1691\u001b[39m, in \u001b[36mrun_model\u001b[39m\u001b[34m(exe_name, namefile, model_ws, silent, pause, report, processors, normal_msg, use_async, cargs, custom_print)\u001b[39m\n\u001b[32m 1689\u001b[39m \u001b[38;5;66;03m# make sure executable exists\u001b[39;00m\n\u001b[32m 1690\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m exe_name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1691\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33m\"\u001b[39m\u001b[33mAn executable name or path must be provided\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 1692\u001b[39m exe_path = resolve_exe(exe_name)\n\u001b[32m 1693\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m silent:\n", + "\u001b[31mValueError\u001b[39m: An executable name or path must be provided" ] - }, - { - "data": { - "text/plain": [ - "(True, [])" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -868,7 +827,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 17, "metadata": { "execution": { "iopub.execute_input": "2025-05-19T23:51:50.326230Z", @@ -885,7 +844,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 18, "metadata": { "execution": { "iopub.execute_input": "2025-05-19T23:51:50.338705Z", @@ -909,7 +868,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 21, "metadata": { "execution": { "iopub.execute_input": "2025-05-19T23:51:50.348023Z", @@ -928,7 +887,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 22, "metadata": { "execution": { "iopub.execute_input": "2025-05-19T23:51:50.411325Z", @@ -943,124 +902,124 @@ { "data": { "text/plain": [ - "[array([(0, 0, 0, 0, 0. , 291.66666, 7041.6665, 25.157747 , 0, 1352, 0.16666667, 0.16666667, 1.6666667e-01, 1, 1),\n", - " (0, 0, 0, 0, 1066.4448, 292.26624, 7053.4077, 24.259151 , 0, 1352, 0.16906492, 0.21363032, 0.0000000e+00, 1, 1),\n", - " (0, 0, 0, 0, 9176.974 , 296.88052, 7186.961 , 18.867577 , 1, 6460, 0.18752205, 0.7478427 , 0.0000000e+00, 1, 1),\n", - " (0, 0, 0, 0, 11675.895 , 298.31778, 7250. , 17.831028 , 2, 11568, 0.1932711 , 1. , 8.0774677e-01, 1, 1),\n", - " (0, 0, 0, 0, 17508.531 , 327.402 , 7500. , 17.036358 , 2, 11413, 0.3096081 , 1. , 4.6607250e-01, 1, 1),\n", - " (0, 0, 0, 0, 21433.229 , 351.98386, 7750. , 14.882585 , 2, 11258, 0.4079354 , 1. , 3.3182257e-01, 1, 1),\n", - " (0, 0, 0, 0, 24273.396 , 384.3024 , 8000. , 14.73489 , 2, 11103, 0.53720963, 1. , 2.5644755e-01, 1, 1),\n", - " (0, 0, 0, 0, 26450.156 , 438.04953, 8250. , 15.476079 , 2, 11002, 0.75219816, 1. , 2.0560372e-01, 1, 1),\n", - " (0, 0, 0, 0, 27142.572 , 500. , 8325.201 , 14.163236 , 2, 10883, 1. , 0.30080554, 1.9235782e-01, 1, 1),\n", - " (0, 0, 0, 0, 28333.227 , 693.0646 , 8500. , 15.877007 , 2, 10884, 0.7722584 , 1. , 1.6770701e-01, 1, 1),\n", - " (0, 0, 0, 0, 28640.107 , 750. , 8540.619 , 17.174723 , 2, 10735, 1. , 0.16247602, 1.6078836e-01, 1, 1),\n", - " (0, 0, 0, 0, 30107.553 , 1000. , 8630.747 , 14.296062 , 2, 10736, 1. , 0.5229883 , 1.3627680e-01, 1, 1),\n", - " (0, 0, 0, 0, 31395.525 , 1250. , 8669.412 , 14.056885 , 2, 10737, 1. , 0.6776476 , 1.1699189e-01, 1, 1),\n", - " (0, 0, 0, 0, 32419.59 , 1500. , 8683.368 , 15.128927 , 2, 10738, 1. , 0.7334708 , 1.0098625e-01, 1, 1),\n", - " (0, 0, 0, 0, 33252.95 , 1750. , 8648.69 , 15.426741 , 2, 10739, 1. , 0.59476316, 8.7877855e-02, 1, 1),\n", - " (0, 0, 0, 0, 34158.152 , 2000. , 8599.295 , 13.061578 , 2, 10740, 1. , 0.39717785, 7.7130035e-02, 1, 1),\n", - " (0, 0, 0, 0, 34809.42 , 2250. , 8531.471 , 14.423331 , 2, 10741, 1. , 0.1258834 , 6.7920834e-02, 1, 1),\n", - " (0, 0, 0, 0, 35052.605 , 2321.5945 , 8500. , 10.877581 , 2, 10742, 0.28637758, 0. , 6.5525644e-02, 1, 1),\n", - " (0, 0, 0, 0, 35709.406 , 2500. , 8421.606 , 9.151835 , 2, 10891, 1. , 0.6864245 , 6.0210422e-02, 1, 1),\n", - " (0, 0, 0, 0, 36168.727 , 2588.3293 , 8375. , 3.7601037, 2, 10892, 0.35331735, 0.5 , 5.7744998e-02, 1, 1),\n", - " (0, 0, 0, 0, 36348.137 , 2625. , 8356.658 , 3.7553706, 2, 10892, 0.5 , 0.4266338 , 5.6809664e-02, 1, 1),\n", - " (0, 0, 0, 0, 36915.703 , 2750. , 8295.735 , 3.7408967, 2, 10892, 1. , 0.18294339, 5.3949330e-02, 1, 1),\n", - " (0, 0, 0, 0, 37332.492 , 2848.8037 , 8250. , 3.6513097, 2, 10895, 0.79043037, 0. , 5.1839087e-02, 1, 1),\n", - " (0, 0, 0, 0, 37458.54 , 2875. , 8235.481 , 3.6113982, 2, 11012, 1. , 0.88385004, 5.1213466e-02, 1, 1),\n", - " (0, 0, 0, 0, 37734.29 , 2937.5 , 8205.1 , 3.7398448, 2, 11013, 0.5 , 0.64079404, 4.9810495e-02, 1, 1),\n", - " (0, 0, 0, 0, 37880.523 , 2971.1736 , 8187.5 , 3.7365134, 2, 11013, 0.7693885 , 0.5 , 4.9082145e-02, 1, 1),\n", - " (0, 0, 0, 0, 37986.574 , 3000. , 8174.9 , 3.7341275, 2, 11013, 1. , 0.39920017, 4.8560604e-02, 1, 1),\n", - " (0, 0, 0, 0, 38200.332 , 3062.5 , 8156.407 , 3.9852014, 2, 11018, 1. , 0.50251484, 4.7473054e-02, 1, 1),\n", - " (0, 0, 0, 0, 38202.113 , 3063.0354 , 8156.25 , 4.1619935, 2, 11019, 0.00856868, 0.5 , 4.7463749e-02, 1, 1),\n", - " (0, 0, 0, 0, 38301.484 , 3093.75 , 8147.6895, 4.159827 , 2, 11019, 0.5 , 0.3630322 , 4.6948180e-02, 1, 1),\n", - " (0, 0, 0, 0, 38395.734 , 3125. , 8139.3667, 4.1577945, 2, 11019, 1. , 0.22986941, 4.6464350e-02, 1, 1),\n", - " (0, 0, 0, 0, 38439.938 , 3140.625 , 8136.436 , 4.201936 , 2, 11039, 0.5 , 0.36595035, 4.6155930e-02, 1, 1),\n", - " (0, 0, 0, 0, 38483.227 , 3156.25 , 8133.3994, 4.2006955, 2, 11039, 1. , 0.2687796 , 4.5855876e-02, 1, 1),\n", - " (0, 0, 0, 0, 38525.527 , 3171.875 , 8131.455 , 4.051697 , 2, 11042, 1. , 0.4131344 , 4.2345017e-02, 1, 1),\n", - " (0, 0, 0, 0, 38632.52 , 3187.5 , 8127.738 , 3.803076 , 2, 11043, 1. , 0.17520487, 1.2762860e-03, 1, 1),\n", - " (0, 0, 0, 0, 38716.156 , 3190.756 , 8125. , 3.7086718, 2, 11049, 0.10419805, 0. , 1.1967426e-03, 1, 1),\n", - " (0, 0, 0, 0, 38927.37 , 3203.125 , 8118.0605, 3.697413 , 2, 11065, 0.5 , 0.7779371 , 1.0305363e-03, 1, 1),\n", - " (0, 0, 0, 0, 39160.566 , 3218.75 , 8110.6187, 3.696747 , 2, 11065, 1. , 0.53979385, 8.7371230e-04, 1, 1),\n", - " (0, 0, 0, 0, 39553.043 , 3250. , 8098.2773, 3.5428393, 2, 11066, 1. , 0.14486945, 8.3452079e-04, 1, 1),\n", - " (0, 0, 0, 0, 39659.312 , 3259.2083 , 8093.75 , 3.3440814, 2, 11088, 0.1473308 , 0.5 , 8.2521880e-04, 1, 1),\n", - " (0, 0, 0, 0, 39943.36 , 3281.25 , 8082.1904, 3.343975 , 2, 11088, 0.5 , 0.3150456 , 8.0086139e-04, 1, 1),\n", - " (0, 0, 0, 0, 40300.027 , 3312.5 , 8069.8804, 3.3438456, 2, 11088, 1. , 0.11808853, 7.7129243e-04, 1, 1),\n", - " (0, 0, 0, 0, 40519.176 , 3333.165 , 8062.5 , 3.0362787, 2, 11089, 0.33064136, 0. , 7.5411168e-04, 1, 1),\n", - " (0, 0, 0, 0, 40970.117 , 3375. , 8047.3403, 3.1637106, 2, 11091, 1. , 0.75744605, 7.1955106e-04, 1, 1),\n", - " (0, 0, 0, 0, 41608.25 , 3437.5 , 8012.9004, 2.9553747, 2, 11092, 0.5 , 0.10320323, 6.7426631e-04, 1, 1),\n", - " (0, 0, 0, 0, 41862.598 , 3464.6055 , 8000. , 2.9552968, 2, 11092, 0.7168429 , 0. , 6.5702124e-04, 1, 1),\n", - " (0, 0, 0, 0, 42047.312 , 3500. , 7990.659 , 3.2104216, 2, 11191, 1. , 0.9252723 , 6.4448244e-04, 1, 1),\n", - " (0, 0, 0, 0, 42567.055 , 3625. , 7967.93 , 3.2902284, 2, 11206, 1. , 0.743441 , 6.1054900e-04, 1, 1),\n", - " (0, 0, 0, 0, 42734.812 , 3680.0312 , 7937.5 , 3.2615628, 2, 11207, 0.44024998, 0.5 , 6.0008443e-04, 1, 1),\n", - " (0, 0, 0, 0, 42751.48 , 3687.5 , 7934.898 , 3.2615583, 2, 11207, 0.5 , 0.47918445, 5.9905433e-04, 1, 1),\n", - " (0, 0, 0, 0, 42860.734 , 3750. , 7915.0635, 3.2615283, 2, 11207, 1. , 0.32050937, 5.9234723e-04, 1, 1),\n", - " (0, 0, 0, 0, 42891.69 , 3773.683 , 7906.25 , 3.2376916, 2, 11212, 0.37892786, 0.5 , 5.8756938e-04, 1, 1),\n", - " (0, 0, 0, 0, 42899.246 , 3781.25 , 7904.36 , 3.2376864, 2, 11212, 0.5 , 0.46975595, 5.8640906e-04, 1, 1),\n", - " (0, 0, 0, 0, 42923.63 , 3812.5 , 7896.438 , 3.2376695, 2, 11212, 1. , 0.34301 , 5.8268092e-04, 1, 1),\n", - " (0, 0, 0, 0, 42932.125 , 3828.125 , 7891.5283, 3.2256029, 2, 11215, 0.5 , 0.52890146, 5.4762413e-04, 1, 1),\n", - " (0, 0, 0, 0, 42933.113 , 3830.2742 , 7890.625 , 3.225585 , 2, 11215, 0.5687721 , 0.5 , 5.4369128e-04, 1, 1),\n", - " (0, 0, 0, 0, 42937.06 , 3843.75 , 7887.585 , 3.225515 , 2, 11215, 1. , 0.40272585, 5.2825559e-04, 1, 1),\n", - " (0, 0, 0, 0, 42939.137 , 3859.375 , 7885.2866, 3.2016568, 2, 11219, 0. , 0.6583343 , 3.6290975e-04, 1, 1),\n", - " (0, 0, 0, 0, 42939.137 , 3859.375 , 7885.2866, 3.218809 , 2, 11218, 1. , 0.6583343 , 3.6290975e-04, 1, 1)],\n", + "[array([(0, 0, 0, 0, 0. , 291.66666, 7041.6665, 25.157747 , 0, 1352, 0.16666667, 0.16666667, 1.6666667e-01, 1, 1),\n", + " (0, 0, 0, 0, 1066.425, 292.2685 , 7053.4917, 24.259151 , 0, 1352, 0.16907398, 0.21396767, 0.0000000e+00, 1, 1),\n", + " (0, 0, 0, 0, 9177.14 , 296.90045, 7187.993 , 18.867577 , 1, 6460, 0.18760175, 0.7519722 , 0.0000000e+00, 1, 1),\n", + " (0, 0, 0, 0, 11623.706, 298.3129 , 7250. , 17.850622 , 2, 11568, 0.19325161, 1. , 8.1138092e-01, 1, 1),\n", + " (0, 0, 0, 0, 17445.506, 327.38663, 7500. , 17.049046 , 2, 11413, 0.3095466 , 1. , 4.6866903e-01, 1, 1),\n", + " (0, 0, 0, 0, 21365.98 , 351.95578, 7750. , 14.893128 , 2, 11258, 0.40782306, 1. , 3.3380401e-01, 1, 1),\n", + " (0, 0, 0, 0, 24204.107, 384.25403, 8000. , 14.742931 , 2, 11103, 0.53701615, 1. , 2.5803149e-01, 1, 1),\n", + " (0, 0, 0, 0, 26379.746, 437.96545, 8250. , 15.481973 , 2, 11002, 0.7518618 , 1. , 2.0690233e-01, 1, 1),\n", + " (0, 0, 0, 0, 27073.143, 500. , 8325.333 , 14.168972 , 2, 10883, 1. , 0.3013334 , 1.9355534e-01, 1, 1),\n", + " (0, 0, 0, 0, 28262.705, 692.84955, 8500. , 15.88128 , 2, 10884, 0.7713981 , 1. , 1.6877499e-01, 1, 1),\n", + " (0, 0, 0, 0, 28570.799, 750. , 8540.788 , 17.17807 , 2, 10735, 1. , 0.16315117, 1.6178566e-01, 1, 1),\n", + " (0, 0, 0, 0, 30038.275, 1000. , 8630.954 , 14.299529 , 2, 10736, 1. , 0.5238181 , 1.3712475e-01, 1, 1),\n", + " (0, 0, 0, 0, 31326.36 , 1250. , 8669.666 , 14.059713 , 2, 10737, 1. , 0.6786623 , 1.1771935e-01, 1, 1),\n", + " (0, 0, 0, 0, 32350.568, 1500. , 8683.666 , 15.130941 , 2, 10738, 1. , 0.73466474, 1.0161406e-01, 1, 1),\n", + " (0, 0, 0, 0, 33184.07 , 1750. , 8649.0205, 15.428246 , 2, 10739, 1. , 0.5960806 , 8.8422537e-02, 1, 1),\n", + " (0, 0, 0, 0, 34089.45 , 2000. , 8599.658 , 13.063103 , 2, 10740, 1. , 0.39863175, 7.7607140e-02, 1, 1),\n", + " (0, 0, 0, 0, 34740.848, 2250. , 8531.887 , 14.424319 , 2, 10741, 1. , 0.12754703, 6.8339482e-02, 1, 1),\n", + " (0, 0, 0, 0, 34987.312, 2322.559 , 8500. , 10.878742 , 2, 10742, 0.290236 , 0. , 6.5897785e-02, 1, 1),\n", + " (0, 0, 0, 0, 35640.72 , 2500. , 8422.05 , 9.153153 , 2, 10891, 1. , 0.68819803, 6.0578957e-02, 1, 1),\n", + " (0, 0, 0, 0, 36104.54 , 2589.1863 , 8375. , 3.7617726, 2, 10892, 0.35674474, 0.5 , 5.8074813e-02, 1, 1),\n", + " (0, 0, 0, 0, 36279.742, 2625. , 8357.09 , 3.7571237, 2, 10892, 0.5 , 0.42836112, 5.7156086e-02, 1, 1),\n", + " (0, 0, 0, 0, 36847.414, 2750. , 8296.136 , 3.74256 , 2, 10892, 1. , 0.1845447 , 5.4277979e-02, 1, 1),\n", + " (0, 0, 0, 0, 37268.14 , 2849.683 , 8250. , 3.6527355, 2, 10895, 0.79746544, 0. , 5.2135389e-02, 1, 1),\n", + " (0, 0, 0, 0, 37389.89 , 2875. , 8235.971 , 3.6129007, 2, 11012, 1. , 0.8877678 , 5.1527575e-02, 1, 1),\n", + " (0, 0, 0, 0, 37665.7 , 2937.5 , 8205.581 , 3.7412417, 2, 11013, 0.5 , 0.64464676, 5.0115835e-02, 1, 1),\n", + " (0, 0, 0, 0, 37816.004, 2972.0994 , 8187.5 , 3.7377973, 2, 11013, 0.77679414, 0.5 , 4.9362838e-02, 1, 1),\n", + " (0, 0, 0, 0, 37918.566, 3000. , 8175.3057, 3.7354765, 2, 11013, 1. , 0.4024466 , 4.8855513e-02, 1, 1),\n", + " (0, 0, 0, 0, 38132.367, 3062.5 , 8156.827 , 3.9864547, 2, 11018, 1. , 0.5092376 , 4.7761355e-02, 1, 1),\n", + " (0, 0, 0, 0, 38138.92 , 3064.4675 , 8156.25 , 4.1631 , 2, 11019, 0.0314803 , 0.5 , 4.7726989e-02, 1, 1),\n", + " (0, 0, 0, 0, 38233.55 , 3093.75 , 8148.09 , 4.161025 , 2, 11019, 0.5 , 0.36943898, 4.7233250e-02, 1, 1),\n", + " (0, 0, 0, 0, 38327.824, 3125. , 8139.738 , 4.15898 , 2, 11019, 1. , 0.23580766, 4.6746470e-02, 1, 1),\n", + " (0, 0, 0, 0, 38372.035, 3140.625 , 8136.8047, 4.203094 , 2, 11039, 0.5 , 0.37775394, 4.6436224e-02, 1, 1),\n", + " (0, 0, 0, 0, 38415.336, 3156.25 , 8133.7593, 4.2018466, 2, 11039, 1. , 0.28029665, 4.6134390e-02, 1, 1),\n", + " (0, 0, 0, 0, 38457.65 , 3171.875 , 8131.8296, 4.0527744, 2, 11042, 1. , 0.43707943, 4.2602737e-02, 1, 1),\n", + " (0, 0, 0, 0, 38564.637, 3187.5 , 8128.147 , 3.803116 , 2, 11043, 1. , 0.2013962 , 1.2858289e-03, 1, 1),\n", + " (0, 0, 0, 0, 38660.48 , 3191.2632 , 8125. , 3.708662 , 2, 11049, 0.12042002, 0. , 1.1944468e-03, 1, 1),\n", + " (0, 0, 0, 0, 38862.535, 3203.125 , 8118.368 , 3.697433 , 2, 11065, 0.5 , 0.7877901 , 1.0352990e-03, 1, 1),\n", + " (0, 0, 0, 0, 39095.668, 3218.75 , 8110.9272, 3.6967647, 2, 11065, 1. , 0.5496728 , 8.7783765e-04, 1, 1),\n", + " (0, 0, 0, 0, 39488.062, 3250. , 8098.543 , 3.5428562, 2, 11066, 1. , 0.15338022, 8.3847297e-04, 1, 1),\n", + " (0, 0, 0, 0, 39600.6 , 3259.7537 , 8093.75 , 3.3440962, 2, 11088, 0.1560589 , 0.5 , 8.2857930e-04, 1, 1),\n", + " (0, 0, 0, 0, 39877.094, 3281.25 , 8082.4824, 3.343992 , 2, 11088, 0.5 , 0.31971985, 8.0476422e-04, 1, 1),\n", + " (0, 0, 0, 0, 40233.7 , 3312.5 , 8070.1533, 3.3438623, 2, 11088, 1. , 0.12245228, 7.7505718e-04, 1, 1),\n", + " (0, 0, 0, 0, 40460.684, 3333.9407 , 8062.5 , 3.0362926, 2, 11089, 0.34305042, 0. , 7.5718301e-04, 1, 1),\n", + " (0, 0, 0, 0, 40903.15 , 3375. , 8047.6304, 3.1637266, 2, 11091, 1. , 0.7620828 , 7.2312116e-04, 1, 1),\n", + " (0, 0, 0, 0, 41541.184, 3437.5 , 8013.1743, 2.95539 , 2, 11092, 0.5 , 0.10539599, 6.7761948e-04, 1, 1),\n", + " (0, 0, 0, 0, 41800.92 , 3465.193 , 8000. , 2.9553099, 2, 11092, 0.7215439 , 0. , 6.5992685e-04, 1, 1),\n", + " (0, 0, 0, 0, 41982.45 , 3500. , 7990.8164, 3.210435 , 2, 11191, 1. , 0.9265324 , 6.4754800e-04, 1, 1),\n", + " (0, 0, 0, 0, 42502.145, 3625. , 7968.0464, 3.2902412, 2, 11206, 1. , 0.74437314, 6.1345613e-04, 1, 1),\n", + " (0, 0, 0, 0, 42670.46 , 3680.2456 , 7937.5 , 3.2615755, 2, 11207, 0.4419644 , 0.5 , 6.0290669e-04, 1, 1),\n", + " (0, 0, 0, 0, 42686.645, 3687.5 , 7934.9727, 3.261571 , 2, 11207, 0.5 , 0.47978276, 6.0190214e-04, 1, 1),\n", + " (0, 0, 0, 0, 42795.89 , 3750. , 7915.1133, 3.261541 , 2, 11207, 1. , 0.32090622, 5.9516344e-04, 1, 1),\n", + " (0, 0, 0, 0, 42827.008, 3773.8174 , 7906.25 , 3.237704 , 2, 11212, 0.38107696, 0.5 , 5.9033406e-04, 1, 1),\n", + " (0, 0, 0, 0, 42834.42 , 3781.25 , 7904.3936, 3.2376988, 2, 11212, 0.5 , 0.47029385, 5.8918889e-04, 1, 1),\n", + " (0, 0, 0, 0, 42858.8 , 3812.5 , 7896.461 , 3.237682 , 2, 11212, 1. , 0.34337416, 5.8543991e-04, 1, 1),\n", + " (0, 0, 0, 0, 42867.297, 3828.125 , 7891.5454, 3.2256145, 2, 11215, 0.5 , 0.5294564 , 5.5021694e-04, 1, 1),\n", + " (0, 0, 0, 0, 42868.305, 3830.3154 , 7890.625 , 3.2255962, 2, 11215, 0.5700975 , 0.5 , 5.4618990e-04, 1, 1),\n", + " (0, 0, 0, 0, 42872.234, 3843.75 , 7887.5947, 3.225526 , 2, 11215, 1. , 0.40302902, 5.3074013e-04, 1, 1),\n", + " (0, 0, 0, 0, 42874.312, 3859.375 , 7885.291 , 3.2016647, 2, 11219, 0. , 0.65862405, 3.6462079e-04, 1, 1),\n", + " (0, 0, 0, 0, 42874.312, 3859.375 , 7885.291 , 3.2188168, 2, 11218, 1. , 0.65862405, 3.6462079e-04, 1, 1)],\n", " dtype=[('particleid', '" ] @@ -1179,7 +1138,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": { "execution": { "iopub.execute_input": "2025-05-19T23:52:39.590906Z", @@ -1221,7 +1180,7 @@ } ], "source": [ - "spth = pl.Path(ws / 'pathline.shp')\n", + "spth = Path(ws / 'pathline.shp')\n", "p.write_shapefile(p0, mg=gwf.modelgrid, one_per_particle=False, shpname=spth)" ] }, @@ -1666,7 +1625,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": { "execution": { "iopub.execute_input": "2025-05-19T23:52:44.843915Z", @@ -1678,7 +1637,7 @@ }, "outputs": [], "source": [ - "pth = pl.Path(\"temp\")\n", + "pth = Path(\"temp\")\n", "pth.mkdir(exist_ok=True)\n", "\n", "vtk.write(pth / \"freyberg\")" @@ -1969,7 +1928,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "pyclass", "language": "python", "name": "python3" }, @@ -1983,7 +1942,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.12" + "version": "3.12.11" } }, "nbformat": 4, diff --git a/notebooks/part1_flopy/data/pleasant-lake/pleasant.hds b/notebooks/part1_flopy/data/pleasant-lake/pleasant.hds index c6867ace..887d46ec 100644 Binary files a/notebooks/part1_flopy/data/pleasant-lake/pleasant.hds and b/notebooks/part1_flopy/data/pleasant-lake/pleasant.hds differ diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index 5cbab86b..23adc680 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -24,7 +24,7 @@ # platforms # Notebook : (platforms,), reason skip_notebooks = { - "10_modpath_particle_tracking-demo.ipynb" : [("darwin","linux","windows"), "transient timeout"] + "10b_modpath_particle_tracking-demo.ipynb" : [("darwin","linux","windows"), "transient timeout"] } def included_notebooks():