diff --git a/.github/workflows/readme_rust.yml b/.github/workflows/readme_rust.yml new file mode 100644 index 00000000..45c39f14 --- /dev/null +++ b/.github/workflows/readme_rust.yml @@ -0,0 +1,43 @@ +name: readme_rust + +defaults: + run: + shell: bash + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + schedule: + - cron: '0 13 * * 4' + +jobs: + rust: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: dtolnay/rust-toolchain@stable + with: + components: rust-src + - uses: actions/setup-python@v5 + with: + python-version: 3.9 + - run: pip install -e . + - run: pip install pytest-codeblocks pytest + + - run: | + cat >Cargo.toml <> $GITHUB_ENV - - # Python 3.12 workaround - python -m pip install --break-system-packages setuptools - run: | python -m pip install $PIP_INSTALL_ARGS -e . # to check if usable without test/example dependencies python -We -c "import PyMPDATA" @@ -176,40 +168,20 @@ jobs: needs: [pylint, precommit] strategy: matrix: - platform: [ubuntu-latest, macos-12, macos-14, windows-latest] + platform: [ubuntu-latest, macos-13, macos-14, windows-latest] python-version: ["3.9", "3.12"] - exclude: - - platform: ubuntu-latest - python-version: system - - platform: macos-12 - python-version: system - - platform: windows-latest - python-version: system - - platform: macos-14 - python-version: "3.9" - - platform: macos-14 - python-version: "3.12" fail-fast: false runs-on: ${{ matrix.platform }} steps: - uses: actions/checkout@v2 with: submodules: recursive - fetch-depth: 0 + fetch-depth: 0 - - if: matrix.platform != 'macos-14' - uses: actions/setup-python@v1 + - uses: actions/setup-python@v5.2.0 with: python-version: ${{ matrix.python-version }} - - if: matrix.platform == 'macos-14' - run: | - sudo ln -s `which python3` /usr/local/bin/python - echo "PIP_INSTALL_ARGS=--break-system-packages" >> $GITHUB_ENV - - # Python 3.12 workaround - python -m pip install --break-system-packages setuptools - - run: python -m pip install $PIP_INSTALL_ARGS -e .[tests] ./examples - run: python -m pip install $PIP_INSTALL_ARGS -r tests/devops_tests/requirements.txt - if: matrix.platform == 'ubuntu-latest' @@ -223,6 +195,8 @@ jobs: sudo make install cd ../../../ rm -rf libmpdataxx + - uses: julia-actions/setup-julia@v2 + - run: julia --version # https://github.com/numba/numba/issues/6350#issuecomment-728174860 - if: matrix.platform == 'ubuntu-latest' @@ -279,7 +253,7 @@ jobs: with: submodules: recursive fetch-depth: 0 # https://github.com/pypa/setuptools_scm/issues/480 - - uses: actions/setup-python@v2 + - uses: actions/setup-python@v5.2.0 with: python-version: "3.10" @@ -295,13 +269,15 @@ jobs: cd .. - if: github.event_name == 'push' && github.ref == 'refs/heads/main' - uses: pypa/gh-action-pypi-publish@unstable/v1 + uses: pypa/gh-action-pypi-publish@release/v1.12 with: + attestations: false repository_url: https://test.pypi.org/legacy/ packages-dir: ${{ matrix.package-dir }}/dist - if: startsWith(github.ref, 'refs/tags') - uses: pypa/gh-action-pypi-publish@unstable/v1 + uses: pypa/gh-action-pypi-publish@release/v1.12 with: + attestations: false packages-dir: ${{ matrix.package-dir }}/dist diff --git a/docs/markdown/pympdata_examples_landing.md b/docs/markdown/pympdata_examples_landing.md deleted file mode 100644 index 473620d4..00000000 --- a/docs/markdown/pympdata_examples_landing.md +++ /dev/null @@ -1,24 +0,0 @@ -# Introduction -PyMPDATA examples are bundled with PyMPDATA and located in the examples subfolder. -They constitute a separate PyMPDATA_examples Python package which is also available at PyPI. -The examples have additional dependencies listed in PyMPDATA_examples package setup.py file. -Running the examples requires the PyMPDATA_examples package to be installed. - -Below is an example of how to use the PyMPDATA_examples package to run a simple advection-diffusion in 2D -`PyMPDATA_examples.advection_diffusion_2d` -![adv_diff](https://github.com/open-atmos/PyMPDATA/releases/download/tip/advection_diffusion.gif) - -# Installation -Since the examples package includes Jupyter notebooks (and their execution requires write access), the suggested install and launch steps are: - -``` -git clone https://github.com/open-atmos/PyMPDATA-examples.git -cd PyMPDATA-examples -pip install -e . -jupyter-notebook -``` - -Alternatively, one can also install the examples package from pypi.org by using -``` -pip install PyMPDATA-examples. -``` diff --git a/docs/markdown/pympdata_landing.md b/docs/markdown/pympdata_landing.md index dda70595..043165f5 100644 --- a/docs/markdown/pympdata_landing.md +++ b/docs/markdown/pympdata_landing.md @@ -42,7 +42,7 @@ The Numba's deviation from Python semantics rendering [closure variables information on domain extents, algorithm variant used and problem characteristics (e.g., coordinate transformation used, or lack thereof). -# Tutorial (in Python, Julia and Matlab) +# Tutorial (in Python, Julia, Rust and Matlab) ## Options class The [``Options``](https://open-atmos.github.io/PyMPDATA/PyMPDATA/options.html) class @@ -71,7 +71,6 @@ with arguments suiting the problem at hand, e.g.:
Julia code (click to expand) - ```Julia using Pkg Pkg.add("PyCall") @@ -83,16 +82,27 @@ options = Options(n_iters=2)
Matlab code (click to expand) - ```Matlab Options = py.importlib.import_module('PyMPDATA').Options; options = Options(pyargs('n_iters', 2)); ```
+
+Rust code (click to expand) +```Rust +use pyo3::prelude::*; +use pyo3::types::{IntoPyDict, PyDict, PyTuple}; + +fn main() -> PyResult<()> { + Python::with_gil(|py| { + let options_args = [("n_iters", 2)].into_py_dict_bound(py); + let options = py.import_bound("PyMPDATA")?.getattr("Options")?.call((), Some(&options_args))?; +``` +
+
Python code (click to expand) - ```Python from PyMPDATA import Options options = Options(n_iters=2) @@ -117,7 +127,6 @@ The schematic of the employed grid/domain layout in two dimensions is given belo
Python code (click to expand) - ```Python import numpy as np from matplotlib import pyplot @@ -176,7 +185,6 @@ conditions and with an initial Gaussian signal in the scalar field
Julia code (click to expand) - ```Julia ScalarField = pyimport("PyMPDATA").ScalarField VectorField = pyimport("PyMPDATA").VectorField @@ -201,9 +209,9 @@ advector = VectorField( ) ```
+
Matlab code (click to expand) - ```Matlab ScalarField = py.importlib.import_module('PyMPDATA').ScalarField; VectorField = py.importlib.import_module('PyMPDATA').VectorField; @@ -236,9 +244,47 @@ advector = VectorField(pyargs(... )); ```
+ +
+Rust code (click to expand) +```Rust + let vector_field = py.import_bound("PyMPDATA")?.getattr("VectorField")?; + let scalar_field = py.import_bound("PyMPDATA")?.getattr("ScalarField")?; + let periodic = py.import_bound("PyMPDATA.boundary_conditions")?.getattr("Periodic")?; + + let nx_ny = [24, 24]; + let cx_cy = [-0.5, -0.25]; + let boundary_con = PyTuple::new_bound(py, [periodic.call0()?, periodic.call0()?]).into_any(); + let halo = options.getattr("n_halo")?; + + let indices = PyDict::new_bound(py); + Python::run_bound(py, &format!(r#" +import numpy as np +nx, ny = {}, {} +xi, yi = np.indices((nx, ny), dtype=float) +data=np.exp( + -(xi+.5-nx/2)**2 / (2*(ny/10)**2) + -(yi+.5-nx/2)**2 / (2*(ny/10)**2) +) + "#, nx_ny[0], nx_ny[1]), None, Some(&indices)).unwrap(); + + let advectee_arg = vec![("data", indices.get_item("data")?), ("halo", Some(halo.clone())), ("boundary_conditions", Some(boundary_con))].into_py_dict_bound(py); + let advectee = scalar_field.call((), Some(&advectee_arg))?; + let full = PyDict::new_bound(py); + Python::run_bound(py, &format!(r#" +import numpy as np +nx, ny = {}, {} +Cx, Cy = {}, {} +data = (np.full((nx + 1, ny), Cx), np.full((nx, ny + 1), Cy)) + "#, nx_ny[0], nx_ny[1], cx_cy[0], cx_cy[1]), None, Some(&full)).unwrap(); + let boundary_con = PyTuple::new_bound(py, [periodic.call0()?, periodic.call0()?]).into_any(); + let advector_arg = vec![("data", full.get_item("data")?), ("halo", Some(halo.clone())), ("boundary_conditions", Some(boundary_con))].into_py_dict_bound(py); + let advector = vector_field.call((), Some(&advector_arg))?; +``` +
+
Python code (click to expand) - ```Python from PyMPDATA import ScalarField from PyMPDATA import VectorField @@ -286,7 +332,6 @@ When instantiating the [``Stepper``](https://open-atmos.github.io/PyMPDATA/PyMPD of either supplying just the number of dimensions or specialising the stepper for a given grid:
Julia code (click to expand) - ```Julia Stepper = pyimport("PyMPDATA").Stepper @@ -295,7 +340,6 @@ stepper = Stepper(options=options, n_dims=2)
Matlab code (click to expand) - ```Matlab Stepper = py.importlib.import_module('PyMPDATA').Stepper; @@ -306,8 +350,18 @@ stepper = Stepper(pyargs(... ```
-Python code (click to expand) +
+Rust code (click to expand) +```Rust +let n_dims: i32 = 2; +let stepper_arg = PyDict::new_bound(py); +let _ = PyDictMethods::set_item(&stepper_arg, "options", &options); +let _ = PyDictMethods::set_item(&stepper_arg, "n_dims", &n_dims); +``` +
+ +Python code (click to expand) ```Python from PyMPDATA import Stepper @@ -317,14 +371,13 @@ stepper = Stepper(options=options, n_dims=2) or
Julia code (click to expand) - ```Julia stepper = Stepper(options=options, grid=(nx, ny)) ```
+
Matlab code (click to expand) - ```Matlab stepper = Stepper(pyargs(... 'options', options, ... @@ -332,9 +385,18 @@ stepper = Stepper(pyargs(... )); ```
+ +
+Rust code (click to expand) +```Rust + let _stepper_arg_alternative = vec![("options", &options), ("grid", &PyTuple::new_bound(py, nx_ny).into_any())].into_py_dict_bound(py); + let stepper_ = py.import_bound("PyMPDATA")?.getattr("Stepper")?; + let stepper = stepper_.call((), Some(&stepper_arg))?; //or use stepper args alternative +``` +
+
Python code (click to expand) - ```Python stepper = Stepper(options=options, grid=(nx, ny)) ``` @@ -388,7 +450,6 @@ Continuing with the above code snippets, instantiating a solver and making 75 integration steps looks as follows:
Julia code (click to expand) - ```Julia Solver = pyimport("PyMPDATA").Solver solver = Solver(stepper=stepper, advectee=advectee, advector=advector) @@ -396,9 +457,9 @@ solver.advance(n_steps=75) state = solver.advectee.get() ```
+
Matlab code (click to expand) - ```Matlab Solver = py.importlib.import_module('PyMPDATA').Solver; solver = Solver(pyargs('stepper', stepper, 'advectee', advectee, 'advector', advector)); @@ -406,9 +467,23 @@ solver.advance(pyargs('n_steps', 75)); state = solver.advectee.get(); ```
+ +
+Rust code (click to expand) +```Rust + let solver_ = py.import_bound("PyMPDATA")?.getattr("Solver")?; + let solver = solver_.call((), Some(&vec![("stepper", stepper), ("advectee", advectee), ("advector", advector)].into_py_dict_bound(py)))?; + let _state_0 = solver.getattr("advectee")?.getattr("get")?.call0()?.getattr("copy")?.call0()?; + solver.getattr("advance")?.call((), Some(&vec![("n_steps", 75)].into_py_dict_bound(py)))?; + let _state = solver.getattr("advectee")?.getattr("get")?.call0()?; + Ok(()) + }) +} +``` +
+
Python code (click to expand) - ```Python from PyMPDATA import Solver @@ -422,7 +497,6 @@ state = solver.advectee.get() Now let's plot the results using `matplotlib` roughly as in Fig. 5 in [Arabas et al. 2014](https://doi.org/10.3233/SPR-140379):
Python code (click to expand) - ```Python def plot(psi, zlim, norm=None): xi, yi = np.indices(psi.shape) @@ -467,21 +541,20 @@ interactive debugging, one way of enabling it is by setting the following environment variable before importing PyMPDATA:
Julia code (click to expand) - ```Julia ENV["NUMBA_DISABLE_JIT"] = "1" ```
+
Matlab code (click to expand) - ```Matlab setenv('NUMBA_DISABLE_JIT', '1'); ```
+
Python code (click to expand) - ```Python import os os.environ["NUMBA_DISABLE_JIT"] = "1" diff --git a/docs/templates/index.html.jinja2 b/docs/templates/index.html.jinja2 index 722e99b3..c2704f79 100644 --- a/docs/templates/index.html.jinja2 +++ b/docs/templates/index.html.jinja2 @@ -1,12 +1,27 @@ {% extends "default/index.html.jinja2" %} -{% block title %}PyMPDATA module list{% endblock %} +{% block title %}PyMPDATA documentation{% endblock %} {% block nav %} + {% endblock %} {% block content %} +
@@ -17,13 +32,19 @@

What is PyMPDATA?

- PyMPDATA is a Numba-accelerated Pythonic implementation of the MPDATA algorithm - of Smolarkiewicz et al. used in geophysical fluid dynamics and beyond for - numerically solving generalised convection-diffusion PDEs. PyMPDATA supports integration in 1D, 2D and 3D structured meshes - with optional coordinate transformations. + + PyMPDATA is a Numba-accelerated multi-threaded Pythonic implementation of the + MPDATA algorithm of Smolarkiewicz et al. used in + geophysical fluid dynamics and beyond for + numerically solving generalised convection-diffusion PDEs. + PyMPDATA supports integration in 1D, 2D and 3D structured meshes + with optional coordinate transformations. + The animation shown depicts a "hello-world" 2D advection-only simulation + with dotted lines indicating domain decomposition across three threads.

- A separate project called PyMPDATA-MPI depicts how numba-mpi can be used to enable distributed memory parallelism in PyMPDATA. + A separate project called PyMPDATA-MPI depicts how + numba-mpi can be used to enable distributed memory parallelism in PyMPDATA.

@@ -50,34 +71,34 @@ @@ -89,15 +110,24 @@ PyMPDATA is available on PyPI and can be installed using pip: 

pip install PyMPDATA
-

Note: the way above will not install PyMPDATA-examples, to install them both you can run:

- 
pip install PyMPDATA[tests]
-
+

Note: the way above will not install PyMPDATA-examples, to install them, and run the tests, likely the most convenient way is:

+ 
git clone https://github.com/open-atmos/PyMPDATA.git
+pip install -e PyMPDATA[tests] -e PyMPDATA/examples[tests]
+pytest PyMPDATA
+

(the above should be a viable way to set up development environment for PyMPDATA, see also our Python dev hints Wiki for further information)

PyMPDATA-examples is available on PyPI and can be installed using pip: 

pip install PyMPDATA-examples
-

Note: this will also install PyMPDATA

-
+

Note: this will also install PyMPDATA if needed, but the examples package wheels do not include the Jupyter notebooks - only common code used from the notebooks. + All PyMPDATA example notebooks can be viewed on GitHub and feature header cells with badges enabling single-click execution on either + Google Colab or mybinder.org platforms. + To try the notebooks out locally, use: +

+ 
git clone https://github.com/open-atmos/PyMPDATA.git
+pip install -e PyMPDATA -e PyMPDATA/examples
+jupyter-notebook PyMPDATA/examples
+

Dependencies

@@ -125,6 +155,28 @@ feature (rather than the issue tracker) for seeking support in understanding, using and extending PyMPDATA code.

+
+
+

Licensing, credits, acknowledgements

+

+ PyMPDATA and PyMPDATA-examples are free/libre open-source software packages released under the + GNU GPL v3 license. +

+ Development of PyMPDATA was started by Piotr Bartman[-Szwarc], + Sylwester Arabas and collaborators + at the Jagiellonian University in Kraków. + For an overview of features of the initial release, see the + 2022 PyMPDATA v1 JOSS paper. + See list of code committers + for a complete list of contributors. +

+

+ Development of PyMPDATA was supported by: +

+

{% include "search.html.jinja2" %} diff --git a/examples/MANIFEST.in b/examples/MANIFEST.in index fd3bf40e..4bbc8430 100644 --- a/examples/MANIFEST.in +++ b/examples/MANIFEST.in @@ -1 +1,2 @@ global-exclude *.ipynb +include docs/*.md diff --git a/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/__init__.py b/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/__init__.py index 42fd658b..34b60703 100644 --- a/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/__init__.py +++ b/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/__init__.py @@ -4,6 +4,18 @@ study on pricing of European and American options using MPDATA. Each notebook in this directory corresponds to a figure or a table in the paper. + +fig_1.ipynb: +.. include:: ./fig_1.ipynb.badges.md + +fig_2.ipynb: +.. include:: ./fig_2.ipynb.badges.md + +fig_3.ipynb: +.. include:: ./fig_3.ipynb.badges.md + +tab_1.ipynb: +.. include:: ./tab_1.ipynb.badges.md """ from .simulation import Simulation diff --git a/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_1.ipynb b/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_1.ipynb index fd68c6a2..230633fa 100644 --- a/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_1.ipynb +++ b/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_1.ipynb @@ -1,15 +1,22 @@ { "cells": [ { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![preview notebook](https://img.shields.io/static/v1?label=render%20on&logo=github&color=87ce3e&message=GitHub)](https://github.com/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_1.ipynb)\n", + "[![launch on mybinder.org](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_1.ipynb)\n", + "[![launch on Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_1.ipynb)" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# license: GPL v3\n", - "# authors: Sylwester Arabas, Michael Olesik, Piotr Bartman\n", - "# copyright: Jagiellonian University\n", - "# based on Fig. 1 from Arabas & Farhat 2020 (https://doi.org/10.1016/j.cam.2019.05.023)" + "license: GPL v3 \n", + "authors: Sylwester Arabas, Michael Olesik, Piotr Bartman \n", + "copyright: Jagiellonian University \n", + "based on Fig. 1 from [Arabas & Farhat 2020](https://doi.org/10.1016/j.cam.2019.05.023)" ] }, { @@ -134,7 +141,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -148,9 +155,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.9.2" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_2.ipynb b/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_2.ipynb index e1f4da53..e3ad0131 100644 --- a/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_2.ipynb +++ b/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_2.ipynb @@ -1,15 +1,22 @@ { "cells": [ { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![preview notebook](https://img.shields.io/static/v1?label=render%20on&logo=github&color=87ce3e&message=GitHub)](https://github.com/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_2.ipynb)\n", + "[![launch on mybinder.org](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_2.ipynb)\n", + "[![launch on Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_2.ipynb)" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# license: GPL v3\n", - "# authors: Sylwester Arabas, Michael Olesik, Piotr Bartman\n", - "# copyright: Jagiellonian University\n", - "# based on Fig. 2 from Arabas & Farhat 2020 (https://doi.org/10.1016/j.cam.2019.05.023)" + "license: GPL v3 \n", + "authors: Sylwester Arabas, Michael Olesik, Piotr Bartman \n", + "copyright: Jagiellonian University \n", + "based on Fig. 2 from [Arabas & Farhat 2020](https://doi.org/10.1016/j.cam.2019.05.023)" ] }, { @@ -24,7 +31,7 @@ "source": [ "import sys\n", "if 'google.colab' in sys.modules:\n", - " !pip --quiet install atmos-atmos-jupyter-utils\n", + " !pip --quiet install open-atmos-jupyter-utils\n", " from open_atmos_jupyter_utils import pip_install_on_colab\n", " pip_install_on_colab('PyMPDATA-examples')" ] @@ -130,7 +137,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -144,9 +151,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.9.2" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_3.ipynb b/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_3.ipynb index 9823e971..ae973280 100644 --- a/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_3.ipynb +++ b/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_3.ipynb @@ -1,15 +1,22 @@ { "cells": [ { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![preview notebook](https://img.shields.io/static/v1?label=render%20on&logo=github&color=87ce3e&message=GitHub)](https://github.com/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_3.ipynb)\n", + "[![launch on mybinder.org](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_3.ipynb)\n", + "[![launch on Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_3.ipynb)" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# license: GPL v3\n", - "# authors: Sylwester Arabas, Michael Olesik, Piotr Bartman\n", - "# copyright: Jagiellonian University\n", - "# based on Fig. 3 from Arabas & Farhat 2020 (https://doi.org/10.1016/j.cam.2019.05.023)" + "license: GPL v3 \n", + "authors: Sylwester Arabas, Michael Olesik, Piotr Bartman \n", + "copyright: Jagiellonian University \n", + "based on Fig. 3 from [Arabas & Farhat 2020](https://doi.org/10.1016/j.cam.2019.05.023)" ] }, { @@ -116,7 +123,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -130,9 +137,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.9.2" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/tab_1.ipynb b/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/tab_1.ipynb index 0e5f5b69..6c7b01b4 100644 --- a/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/tab_1.ipynb +++ b/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/tab_1.ipynb @@ -1,15 +1,22 @@ { "cells": [ { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![preview notebook](https://img.shields.io/static/v1?label=render%20on&logo=github&color=87ce3e&message=GitHub)](https://github.com/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/tab_1.ipynb)\n", + "[![launch on mybinder.org](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/tab_1.ipynb)\n", + "[![launch on Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/tab_1.ipynb)" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# license: GPL v3\n", - "# authors: Sylwester Arabas, Michael Olesik, Piotr Bartman\n", - "# copyright: Jagiellonian University\n", - "# based on Tab. 1 from Arabas & Farhat 2020 (https://doi.org/10.1016/j.cam.2019.05.023)" + "license: GPL v3 \n", + "authors: Sylwester Arabas, Michael Olesik, Piotr Bartman \n", + "copyright: Jagiellonian University \n", + "based on Tab. 1 from [Arabas & Farhat 2020](https://doi.org/10.1016/j.cam.2019.05.023)" ] }, { @@ -262,7 +269,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -276,9 +283,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.9.2" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/examples/PyMPDATA_examples/Bartman_et_al_2022/__init__.py b/examples/PyMPDATA_examples/Bartman_et_al_2022/__init__.py index fd48dbbf..5302cc8d 100644 --- a/examples/PyMPDATA_examples/Bartman_et_al_2022/__init__.py +++ b/examples/PyMPDATA_examples/Bartman_et_al_2022/__init__.py @@ -1,4 +1,7 @@ """ This example is based on the paper: [Bartman et al. 2022](https://doi.org/10.21105/joss.03896). + +fig_X.ipynb: +.. include:: ./fig_X.ipynb.badges.md """ diff --git a/examples/PyMPDATA_examples/Bartman_et_al_2022/fig_X.ipynb b/examples/PyMPDATA_examples/Bartman_et_al_2022/fig_X.ipynb index 4df972fc..bc652615 100644 --- a/examples/PyMPDATA_examples/Bartman_et_al_2022/fig_X.ipynb +++ b/examples/PyMPDATA_examples/Bartman_et_al_2022/fig_X.ipynb @@ -1,5 +1,34 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![preview notebook](https://img.shields.io/static/v1?label=render%20on&logo=github&color=87ce3e&message=GitHub)](https://github.com/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Bartman_et_al_2022/fig_X.ipynb)\n", + "[![launch on mybinder.org](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples/Bartman_et_al_2022/fig_X.ipynb)\n", + "[![launch on Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Bartman_et_al_2022/fig_X.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "performance comparison against libmpdata++ presented in the [PyMPDATA JOSS paper](https://doi.org/10.21105/joss.03896)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "if 'google.colab' in sys.modules:\n", + " !pip --quiet install open-atmos-jupyter-utils\n", + " from open_atmos_jupyter_utils import pip_install_on_colab\n", + " pip_install_on_colab('PyMPDATA-examples')" + ] + }, { "cell_type": "code", "execution_count": null, @@ -25,7 +54,6 @@ "outputs": [], "source": [ "import subprocess\n", - "import sys\n", "import json\n", "import numpy as np\n", "import numba\n", @@ -486,7 +514,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.5" + "version": "3.9.2" } }, "nbformat": 4, diff --git a/examples/PyMPDATA_examples/DPDC/__init__.py b/examples/PyMPDATA_examples/DPDC/__init__.py index d559df63..bc91f929 100644 --- a/examples/PyMPDATA_examples/DPDC/__init__.py +++ b/examples/PyMPDATA_examples/DPDC/__init__.py @@ -1,3 +1,6 @@ """ This example demonstrates the use of the Double-Pass Donor-Cell option in `PyMPDATA.options`. + +demo.ipynb: +.. include:: ./demo.ipynb.badges.md """ diff --git a/examples/PyMPDATA_examples/DPDC/demo.ipynb b/examples/PyMPDATA_examples/DPDC/demo.ipynb index ea2997f1..938c499c 100644 --- a/examples/PyMPDATA_examples/DPDC/demo.ipynb +++ b/examples/PyMPDATA_examples/DPDC/demo.ipynb @@ -4,8 +4,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/master?filepath=examples/PyMPDATA_examples/DPDC/demo.ipynb)\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/DPDC/demo.ipynb)" + "[![preview notebook](https://img.shields.io/static/v1?label=render%20on&logo=github&color=87ce3e&message=GitHub)](https://github.com/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/DPDC/demo.ipynb)\n", + "[![launch on mybinder.org](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples/DPDC/demo.ipynb)\n", + "[![launch on Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/DPDC/demo.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "demo of the Double Pass Donor Cell variant" ] }, { @@ -301,7 +309,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -315,7 +323,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.7" + "version": "3.9.2" } }, "nbformat": 4, diff --git a/examples/PyMPDATA_examples/Jarecka_et_al_2015/__init__.py b/examples/PyMPDATA_examples/Jarecka_et_al_2015/__init__.py index 2e9b2113..84e8fb95 100644 --- a/examples/PyMPDATA_examples/Jarecka_et_al_2015/__init__.py +++ b/examples/PyMPDATA_examples/Jarecka_et_al_2015/__init__.py @@ -2,6 +2,9 @@ This module showcases the PyMPDATA implementation of an MPDATA-based shallow-water equations solver discussed and bencharked against analytical solutions in [Jarecka_et_al_2015](https://doi.org/10.1016/j.jcp.2015.02.003). + +fig_6.ipynb: +.. include:: ./fig_6.ipynb.badges.md """ from .plot_output import plot_output diff --git a/examples/PyMPDATA_examples/Jarecka_et_al_2015/fig_6.ipynb b/examples/PyMPDATA_examples/Jarecka_et_al_2015/fig_6.ipynb index 002f5ffb..81d966e5 100644 --- a/examples/PyMPDATA_examples/Jarecka_et_al_2015/fig_6.ipynb +++ b/examples/PyMPDATA_examples/Jarecka_et_al_2015/fig_6.ipynb @@ -4,8 +4,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples/Jarecka_et_al_2015/fig_6.ipynb)\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/examples/blob/main/examples/PyMPDATA_examples/Jarecka_et_al_2015/fig_6.ipynb)" + "[![preview notebook](https://img.shields.io/static/v1?label=render%20on&logo=github&color=87ce3e&message=GitHub)](https://github.com/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Jarecka_et_al_2015/fig_6.ipynb)\n", + "[![launch on mybinder.org](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples/Jarecka_et_al_2015/fig_6.ipynb)\n", + "[![launch on Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Jarecka_et_al_2015/fig_6.ipynb)" ] }, { @@ -120,9 +121,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.9.2" } }, "nbformat": 4, - "nbformat_minor": 1 + "nbformat_minor": 4 } diff --git a/examples/PyMPDATA_examples/Jaruga_et_al_2015/__init__.py b/examples/PyMPDATA_examples/Jaruga_et_al_2015/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/examples/PyMPDATA_examples/Jaruga_et_al_2015/boussinesq.py b/examples/PyMPDATA_examples/Jaruga_et_al_2015/boussinesq.py index 8b137891..3e729bfc 100644 --- a/examples/PyMPDATA_examples/Jaruga_et_al_2015/boussinesq.py +++ b/examples/PyMPDATA_examples/Jaruga_et_al_2015/boussinesq.py @@ -1 +1,2 @@ +#not implemented yet diff --git a/examples/PyMPDATA_examples/Jaruga_et_al_2015/fig19.ipynb b/examples/PyMPDATA_examples/Jaruga_et_al_2015/fig19.ipynb new file mode 100644 index 00000000..f126a912 --- /dev/null +++ b/examples/PyMPDATA_examples/Jaruga_et_al_2015/fig19.ipynb @@ -0,0 +1,637 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8519709f-5065-4493-9af6-b5857dfc41b2", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "id": "76ffcb39-d58b-4c7b-b795-a4206a63716d", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "9ef2a5c3-3ac9-418b-92dd-e422ba66af66", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "if 'google.colab' in sys.modules:\n", + " !pip --quiet install open-atmos-jupyter-utils\n", + " from open_atmos_jupyter_utils import pip_install_on_colab\n", + " pip_install_on_colab('PyMPDATA-examples')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "69583de6-8b30-4a74-8cd0-d3ade00ec579", + "metadata": {}, + "outputs": [], + "source": [ + "from open_atmos_jupyter_utils import show_plot" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "28a63fae-2714-4fd3-af80-acb56dd0ce76", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2024-11-05T14:32:25.734808\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.8.2, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ], + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "495b5735ebc841fc815c45fb93eb955d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(HTML(value=\".\\\\fig_19.pdf
\"), HTML(value=\"" - ] + ], + "image/png": "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" }, "metadata": {}, "output_type": "display_data" }, { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d6fdbacca62746459f4ff36aaae89d34", - "version_major": 2, - "version_minor": 0 - }, "text/plain": [ "HBox(children=(HTML(value=\"./fig_1.pdf
\"), HTML(value=\"" - ] + ], + "image/png": "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" }, "metadata": {}, "output_type": "display_data" }, { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7b34d1077e5a4b72ad14f6112fd85986", - "version_major": 2, - "version_minor": 0 - }, "text/plain": [ "HBox(children=(HTML(value=\"./fig_2.pdf
\"), HTML(value=\"" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "HBox(children=(HTML(value=\".\\\\tmpjzrlzgss.pdf
\"), HTML(val…" + ], + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "8d95a28c505d40e7b9820b2a48f1366a" + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 14 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-30T19:30:28.064651Z", + "start_time": "2024-10-30T19:30:28.050633Z" + } + }, + "cell_type": "code", + "source": "solution_filename = [f for f in os.listdir(\"./out\") if \"solution\" in f][0]", + "id": "c58862c96237cccf", + "outputs": [], + "execution_count": 15 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-30T19:30:28.079639Z", + "start_time": "2024-10-30T19:30:28.065644Z" + } + }, + "cell_type": "code", + "source": [ + "%%writefile to_vtk.jl\n", + "using Trixi2Vtk\n", + "trixi2vtk(joinpath(\"out\", ARGS[1]))" + ], + "id": "8d35a730ab764f86", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overwriting to_vtk.jl\n" + ] + } + ], + "execution_count": 16 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-30T19:30:40.084503Z", + "start_time": "2024-10-30T19:30:28.080639Z" + } + }, + "cell_type": "code", + "source": "subprocess.run([\"julia\", \"to_vtk.jl\", solution_filename], check=True)", + "id": "960cee65b6c01544", + "outputs": [ + { + "data": { + "text/plain": [ + "CompletedProcess(args=['julia', 'to_vtk.jl', 'solution_000030.h5'], returncode=0)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 17 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-30T19:30:40.100519Z", + "start_time": "2024-10-30T19:30:40.085510Z" + } + }, + "cell_type": "code", + "source": [ + "try:\n", + " vtu_filename = [f for f in os.listdir(\"./\") if \"vtu\" in f and \"celldata\" not in f][0]\n", + " mesh = meshio.read(vtu_filename)\n", + " trixi_points = ((mesh.points[:,:2] + 1)*SETUP[\"nx\"]*SETUP[\"polydeg\"]/2).round().astype(np.int16)\n", + " assert trixi_points.shape[0] == SETUP[\"nx\"]**2 * (SETUP[\"polydeg\"] + 1)**2\n", + "except Exception as e:\n", + " e.args += (list(os.walk(os.path.curdir)),)\n", + " raise e" + ], + "id": "451911db51e18682", + "outputs": [], + "execution_count": 18 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-30T19:30:40.116510Z", + "start_time": "2024-10-30T19:30:40.101521Z" + } + }, + "cell_type": "code", + "source": [ + "try:\n", + " trixi_output = np.zeros_like(pympdata_result_state)\n", + " for i in range(trixi_points.shape[0]):\n", + " trixi_output[trixi_points[i][0], trixi_points[i][1]] = mesh.point_data['scalar'][i][0]\n", + "except Exception as e:\n", + " e.args += (list(mesh.point_data.keys()),)\n", + " e.args += (list(mesh.points.shape),)\n", + " raise e" + ], + "id": "58595cff705f196c", + "outputs": [], + "execution_count": 19 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-30T19:30:40.684640Z", + "start_time": "2024-10-30T19:30:40.117511Z" + } + }, + "cell_type": "code", + "source": [ + "plt.imshow(trixi_output, cmap='viridis', vmin=vmin, vmax=vmax)\n", + "plt.colorbar()\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.title(\"Trixi solution\")\n", + "show_plot(inline_format='png')" + ], + "id": "a126dbabdf719ee3", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "HBox(children=(HTML(value=\".\\\\tmp__kuzitk.pdf
\"), HTML(val…" + ], + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "c75b8c33ee774761ad1c8d8fbe1eee33" + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 20 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-30T19:30:40.700641Z", + "start_time": "2024-10-30T19:30:40.685639Z" + } + }, + "cell_type": "code", + "source": [ + "residual = pympdata_result_state - trixi_output\n", + "rmse = np.sqrt(np.mean(residual**2))\n", + "mse = np.mean(residual**2)\n", + "max_diff = np.max(np.abs(residual))\n", + "min_diff = np.min(np.abs(residual))" + ], + "id": "ec2fffd2627288b4", + "outputs": [], + "execution_count": 21 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-30T19:30:40.716644Z", + "start_time": "2024-10-30T19:30:40.702644Z" + } + }, + "cell_type": "code", + "source": [ + "assert np.allclose(rmse, 6.94e-2, 0.1)\n", + "assert np.allclose(mse, 4.81e-3, 0.1)\n", + "assert np.allclose(max_diff, 0.285, 0.1)\n", + "assert np.allclose(min_diff, 2.69e-5, 0.1)" + ], + "id": "a7496a6f898495a3", + "outputs": [], + "execution_count": 22 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-30T19:30:40.732655Z", + "start_time": "2024-10-30T19:30:40.718646Z" + } + }, + "cell_type": "code", + "source": "", + "id": "119bd01509fa1ceb", + "outputs": [], + "execution_count": 22 + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/PyMPDATA_examples/utils/__init__.py b/examples/PyMPDATA_examples/utils/__init__.py index 8c49a4c8..0b9b3355 100644 --- a/examples/PyMPDATA_examples/utils/__init__.py +++ b/examples/PyMPDATA_examples/utils/__init__.py @@ -5,3 +5,5 @@ from open_atmos_jupyter_utils import show_plot from .nondivergent_vector_field_2d import nondivergent_vector_field_2d + +from .notebook_vars import notebook_vars \ No newline at end of file diff --git a/examples/PyMPDATA_examples/utils/notebook_vars.py b/examples/PyMPDATA_examples/utils/notebook_vars.py new file mode 100644 index 00000000..48dad07f --- /dev/null +++ b/examples/PyMPDATA_examples/utils/notebook_vars.py @@ -0,0 +1,31 @@ +""" helper routines for use in smoke tests """ + +from pathlib import Path + +import nbformat + + +def notebook_vars(file: Path, plot: bool): + """Executes the code from all cells of the Jupyter notebook `file` and + returns a dictionary with the notebook variables. If the `plot` argument + is set to `True`, any code line within the notebook starting with `show_plot(` + (see [open_atmos_jupyter_utils docs](https://pypi.org/p/open_atmos_jupyter_utils)) + is replaced with `pyplot.show() #`, otherwise it is replaced with `pyplot.gca().clear() #` + to match the smoke-test conventions.""" + notebook = nbformat.read(file, nbformat.NO_CONVERT) + context = {} + for cell in notebook.cells: + if cell.cell_type != "markdown": + lines = cell.source.splitlines() + for i, line in enumerate(lines): + if line.strip().startswith("!"): + lines[i] = line.replace("!", "pass #") + if line.strip().startswith("show_plot("): + lines[i] = line.replace( + "show_plot(", + "from matplotlib import pyplot; " + + ("pyplot.show() #" if plot else "pyplot.gca().clear() #"), + ) + + exec("\n".join(lines), context) # pylint: disable=exec-used + return context \ No newline at end of file diff --git a/examples/README.md b/examples/README.md index aa6478ec..75c57dcf 100644 --- a/examples/README.md +++ b/examples/README.md @@ -4,53 +4,6 @@ [![PyPI version](https://badge.fury.io/py/PyMPDATA-examples.svg)](https://pypi.org/project/PyMPDATA-examples) [![API docs](https://img.shields.io/badge/API_docs-pdoc3-blue.svg)](https://open-atmos.github.io/PyMPDATA-examples/) -Each of the examples listed below can either be executed using Jupyer after downaloding it (and installing - the PySDM-examples package using ``pip install``) or executed in the cloud by clicking on one of the - Mybinder or Colab badges below: - -- [Smolarkiewicz 2006](http://doi.org/10.1002/fld.1071) Figs 3,4,10,11 & 12 - [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples%2FSmolarkiewicz_2006_Figs_3_4_10_11_12/demo.ipynb) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Smolarkiewicz_2006_Figs_3_4_10_11_12/demo.ipynb) - (1D homogeneous cases depicting infinite-gauge and flux-corrected transport cases) -- [Arabas & Farhat 2020](https://doi.org/10.1016/j.cam.2019.05.023) (1D advection-diffusion example based on Black-Scholes equation): - - Fig 1: - [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples%2FArabas_and_Farhat_2020/fig_1.ipynb) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_1.ipynb) - - Fig 2: - [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples%2FArabas_and_Farhat_2020/fig_2.ipynb) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_2.ipynb) - - Fig 3: - [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples%2FArabas_and_Farhat_2020/fig_3.ipynb) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/fig_3.ipynb) - - Tab 1: - [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples%2FArabas_and_Farhat_2020/tab_1.ipynb) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/tab_1.ipynb) -- [Olesik et al. 2022](https://doi.org/10.5194/gmd-15-3879-2022) - [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples%2FOlesik_et_al_2022/) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Olesik_et_al_2022/demo_make_plots.ipynb) - (1D particle population condensational growth problem with coordinate transformations) -- [Shipway and Hill 2012 (KiD-1D)](https://doi.org/10.1002/qj.1913) (analysis discussed in [Olesik et al. 2022](https://arxiv.org/abs/2011.14726)) - [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples%2FShipway_and_Hill_2012/) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Shipway_and_Hill_2012/fig_1.ipynb) - (2D spectral-spatial problem of droplet condensational growth in a column of air) -![animation](https://github.com/open-atmos/PyMPDATA/wiki/files/KiD-1D_PyMPDATA_n_iters=1.gif) -![animation](https://github.com/open-atmos/PyMPDATA/wiki/files/KiD-1D_PyMPDATA_n_iters=3.gif) -- Molenkamp 2D solid-body rotation test (as in [Jaruga et al. 2015](https://doi.org/10.5194/gmd-8-1005-2015), Fig. 12) - [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples%2FMolenkamp_test_as_in_Jaruga_et_al_2015_Fig_12/demo.ipynb) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Molenkamp_test_as_in_Jaruga_et_al_2015_Fig_12/demo.ipynb) -- 1D advection-diffusion example with animation - [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples%2Fadvection_diffusion_1d/demo.ipynb) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/advection_diffusion_1d/demo.ipynb) -- 2D advection-diffusion example with visualization - [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples%2Fadvection_diffusion_2d/advection-diffusion-2d.ipynb) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/advection_diffusion_2d/advection-diffusion-2d.ipynb) -- 2D shallow-water equations (3D elliptic drop spreading on 2D plane under gravity example from [Jarecka et al. 2015](https://doi.org/10.1016/j.jcp.2015.02.003)) - - Fig 6: [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples/Jarecka_et_al_2015/fig_6.ipynb) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Jarecka_et_al_2015/fig_6.ipynb) -- 2D advection on a sphere (setup depicting coordinate transformation based on [Williamson and Rasch 1989](https://doi.org/10.1175/1520-0493(1989)117%3C0102:TDSLTW%3E2.0.CO;2)) - [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples%2FWilliamson_and_Rasch_1989_as_in_Jaruga_et_al_2015_Fig_14/demo_over_the_pole.ipynb) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Williamson_and_Rasch_1989_as_in_Jaruga_et_al_2015_Fig_14/demo_over_the_pole.ipynb) -![animation](https://github.com/open-atmos/PyMPDATA/wiki/files/sphere_upwind.gif) -- 3D advection (spherical signal revolving in a box, based on [Smolarkiewicz 1984](https://doi.org/10.1016/0021-9991(84)90121-9)) - [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PyMPDATA.git/main?urlpath=lab/tree/examples/PyMPDATA_examples%2FSmolarkiewicz_1984/figs_13-14.ipynb) - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PyMPDATA/blob/main/examples/PyMPDATA_examples/Smolarkiewicz_1984/figs_13-14.ipynb) +For a list of examples, see [PyMPDATA-examples documentation](https://open-atmos.github.io/PyMPDATA/PyMPDATA_examples.html). + +For information on package development, see [PyMPDATA README](https://github.com/open-atmos/PyMPDATA/blob/main/README.md). diff --git a/examples/docs/pympdata_examples_landing.md b/examples/docs/pympdata_examples_landing.md new file mode 100644 index 00000000..160d53e4 --- /dev/null +++ b/examples/docs/pympdata_examples_landing.md @@ -0,0 +1,55 @@ +# Introduction +PyMPDATA examples are bundled with PyMPDATA and located in the examples subfolder. +They constitute a separate PyMPDATA_examples Python package which is also available at PyPI. +The examples have additional dependencies listed in PyMPDATA_examples package setup.py file. +Running the examples requires the PyMPDATA_examples package to be installed. + +We recommend you look through the example gallery below to see the examples in action. + +# Example gallery +Unless stated otherwise the following examples solve the basic advection equation: +$$ \partial_t (\psi) + \nabla \cdot (u \psi) = 0 $$ + +The examples are grouped by the dimensionality of the computational grid. + +## in 1D +| tags | link | +|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------| +| advection-diffusion equation
$$ \partial_t (\psi) + \nabla \cdot (u \psi) + \mu \Delta (\psi) = 0 $$ | `PyMPDATA_examples.advection_diffusion_1d`* | +| Black-Scholes equation, option pricing
$$ \frac{\partial f}{\partial t} + rS \frac{\partial f}{\partial S} + \frac{\sigma^2}{2} S^2 \frac{\partial^2 f}{\partial S^2} - rf = 0$$ | `PyMPDATA_examples.Arabas_and_Farhat_2020`* | +| advection equation, homogeneous, several algorithm variants comparison: infinite-gauge, flux-corrected,.. | `PyMPDATA_examples.Smolarkiewicz_2006_Figs_3_4_10_11_12` | +| Size-spectral advection, particle population condensational growth, coordinate transformation
$$ \partial_t (G \psi) + \nabla \cdot (Gu \psi) = 0 $$ | `PyMPDATA_examples.Olesik_et_al_2022`* | +| advection equation, [double-pass donor-cell option](https://osti.gov/servlets/purl/7049237) | `PyMPDATA_examples.DPDC` | + +## in 2D +| tags | link | +|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| advection-diffusion equation
$$ \partial_t (\psi) + \nabla \cdot (u \psi) + \mu \Delta (\psi) = 0 $$ | `PyMPDATA_examples.advection_diffusion_2d`*
adv-diff | +| Spectral-spatial advection, particle population condensational growth in a vertical column of air, time dependent flow | `PyMPDATA_examples.Shipway_and_Hill_2012`
spectral-spatial | +| shallow-water equations
$$\begin{eqnarray} \partial_t h + \partial_x (uh) + \partial_y (vh) &=& 0~ \\\ \partial_t (uh) + \partial_x ( uuh) + \partial_y (vuh) &=& - h \partial_x h~ \\\ \partial_t (vh) + \partial_x ( uvh) + \partial_y (vvh) &=& - h \partial_y h~ \end{eqnarray}$$ | `PyMPDATA_examples.Jarecka_et_al_2015`* | +| advection equation, solid body rotation | `PyMPDATA_examples.Molenkamp_test_as_in_Jaruga_et_al_2015_Fig_12`* | +| advection equation, coordinate transformation, spherical coordinates, see also examples in [PyMPDATA-MPI](https://pypi.org/project/PyMPDATA-MPI/) $$ \partial_t (G \psi) + \nabla \cdot (Gu \psi) = 0 $$ | `PyMPDATA_examples.Williamson_and_Rasch_1989_as_in_Jaruga_et_al_2015_Fig_14`
mpi-gif | +| advection equation, comparison against DG solution using [Trixi.jl](https://trixi-framework.github.io/) | `PyMPDATA_examples.trixi_comparison` | + +## in 3D +| tags | link | +|:------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------| +| homogeneous advection equation | `PyMPDATA_examples.Smolarkiewicz_1984` | +| homogeneous advection equation, performance comparison against libmpdata++, scalability analysis in respect to threads | `PyMPDATA_examples.Bartman_et_al_2022` | + +\* - with comparison against analytic solution + +# Installation +Since the examples package includes Jupyter notebooks (and their execution requires write access), the suggested install and launch steps are: + +``` +git clone https://github.com/open-atmos/PyMPDATA-examples.git +cd PyMPDATA-examples +pip install -e . +jupyter-notebook +``` + +Alternatively, one can also install the examples package from pypi.org by using +``` +pip install PyMPDATA-examples. +``` diff --git a/examples/setup.py b/examples/setup.py index 9b8678d7..fcaad0c1 100644 --- a/examples/setup.py +++ b/examples/setup.py @@ -1,15 +1,21 @@ """ the magick behind ``pip install ...`` """ import os +import re from setuptools import find_packages, setup def get_long_description(): - """returns contents of README.md file""" - with open("README.md", "r", encoding="utf8") as file: - long_description = file.read() - return long_description + """returns contents of the pdoc landing site with pdoc links converted into URLs""" + with open("docs/pympdata_examples_landing.md", "r", encoding="utf8") as file: + pdoc_links = re.compile( + r"(`)([\w\d_-]*).([\w\d_-]*)(`)", re.MULTILINE | re.UNICODE + ) + return pdoc_links.sub( + r'\3', + file.read(), + ) CI = "CI" in os.environ @@ -35,6 +41,7 @@ def get_long_description(): "joblib", "sympy", "imageio", + "meshio", ], author="https://github.com/open-atmos/PyMPDATA/graphs/contributors", license="GPL-3.0", diff --git a/setup.py b/setup.py index 25a5d988..6c4eedfd 100644 --- a/setup.py +++ b/setup.py @@ -25,7 +25,7 @@ def get_long_description(): setup( name="PyMPDATA", description="Numba-accelerated Pythonic implementation of MPDATA " - "with examples in Python, Julia and Matlab", + "with examples in Python, Julia, Rust and Matlab", use_scm_version={"local_scheme": lambda _: "", "version_scheme": "post-release"}, setup_requires=["setuptools_scm"], install_requires=[ @@ -81,6 +81,7 @@ def get_long_description(): "pytest-benchmark", "joblib" + ("==1.4.0" if CI else ""), "imageio", + "nbformat", ] }, author="https://github.com/open-atmos/PyMPDATA/graphs/contributors", diff --git a/tests/devops_tests b/tests/devops_tests index 231c989f..16203c50 160000 --- a/tests/devops_tests +++ b/tests/devops_tests @@ -1 +1 @@ -Subproject commit 231c989f109a1da47ad77f240db7a6b693983377 +Subproject commit 16203c50739ba13125a044f6adaff6ce9a8b2c1a diff --git a/tests/smoke_tests/jaruga_et_al_2015/test_fig19.py b/tests/smoke_tests/jaruga_et_al_2015/test_fig19.py new file mode 100644 index 00000000..d757c04d --- /dev/null +++ b/tests/smoke_tests/jaruga_et_al_2015/test_fig19.py @@ -0,0 +1,30 @@ +""" +checking consistency with values in the paper for Figure 19 +""" + +from pathlib import Path + +import numpy as np +import pytest + +from PyMPDATA_examples.utils import notebook_vars +from PyMPDATA_examples import Jaruga_et_al_2015 + + + +PLOT = False + + +@pytest.fixture(scope="session", name="variables") +def variables_fixture(): + return notebook_vars( + file=Path(Jaruga_et_al_2015.__file__).parent / "fig19.ipynb", plot=PLOT + ) + + +class TestFig19: + @staticmethod + def test_range_of_value_at_t0(variables): + assert np.amin(variables["net"]) == 300 + assert np.amax(variables["net"]) == 300.5 +