From 8b7a49730478ecc7b62c638e801dfbc69744273d Mon Sep 17 00:00:00 2001
From: Sylwester Arabas <sylwester.arabas@agh.edu.pl>
Date: Tue, 5 Nov 2024 11:05:34 +0100
Subject: [PATCH 01/14] docs fixes (incl. rel->abs links in PyPI metadata)
 (#472)

---
 docs/markdown/pympdata_landing.md | 32 +++++++------------------------
 docs/templates/index.html.jinja2  |  2 +-
 examples/setup.py                 |  5 ++++-
 3 files changed, 12 insertions(+), 27 deletions(-)

diff --git a/docs/markdown/pympdata_landing.md b/docs/markdown/pympdata_landing.md
index ff7d4eb3..043165f5 100644
--- a/docs/markdown/pympdata_landing.md
+++ b/docs/markdown/pympdata_landing.md
@@ -71,7 +71,6 @@ with arguments suiting the problem at hand, e.g.:
 
 <details>
 <summary>Julia code (click to expand)</summary>
-
 ```Julia
 using Pkg
 Pkg.add("PyCall")
@@ -83,16 +82,12 @@ options = Options(n_iters=2)
 
 <details>
 <summary>Matlab code (click to expand)</summary>
-
 ```Matlab
 Options = py.importlib.import_module('PyMPDATA').Options;
 options = Options(pyargs('n_iters', 2));
 ```
 </details>
 
-<details open>
-<summary>Python code (click to expand)</summary>
-
 <details>
 <summary>Rust code (click to expand)</summary>
 ```Rust
@@ -106,6 +101,8 @@ fn main() -> PyResult<()> {
 ```
 </details>
 
+<details open>
+<summary>Python code (click to expand)</summary>
 ```Python
 from PyMPDATA import Options
 options = Options(n_iters=2)
@@ -130,7 +127,6 @@ The schematic of the employed grid/domain layout in two dimensions is given belo
 
 <details>
 <summary>Python code (click to expand)</summary>
-
 ```Python
 import numpy as np
 from matplotlib import pyplot
@@ -189,7 +185,6 @@ conditions and with an initial Gaussian signal in the scalar field
 
 <details>
 <summary>Julia code (click to expand)</summary>
-
 ```Julia
 ScalarField = pyimport("PyMPDATA").ScalarField
 VectorField = pyimport("PyMPDATA").VectorField
@@ -214,9 +209,9 @@ advector = VectorField(
 )
 ```
 </details>
+
 <details>
 <summary>Matlab code (click to expand)</summary>
-
 ```Matlab
 ScalarField = py.importlib.import_module('PyMPDATA').ScalarField;
 VectorField = py.importlib.import_module('PyMPDATA').VectorField;
@@ -290,7 +285,6 @@ data = (np.full((nx + 1, ny), Cx), np.full((nx, ny + 1), Cy))
 
 <details open>
 <summary>Python code (click to expand)</summary>
-
 ```Python
 from PyMPDATA import ScalarField
 from PyMPDATA import VectorField
@@ -338,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:
 <details>
 <summary>Julia code (click to expand)</summary>
-
 ```Julia
 Stepper = pyimport("PyMPDATA").Stepper
 
@@ -347,7 +340,6 @@ stepper = Stepper(options=options, n_dims=2)
 </details>
 <details>
 <summary>Matlab code (click to expand)</summary>
-
 ```Matlab
 Stepper = py.importlib.import_module('PyMPDATA').Stepper;
 
@@ -361,7 +353,6 @@ stepper = Stepper(pyargs(...
 
 <details>
 <summary>Rust code (click to expand)</summary>
-
 ```Rust
 let n_dims: i32 = 2;
 let stepper_arg = PyDict::new_bound(py);
@@ -371,7 +362,6 @@ let _ = PyDictMethods::set_item(&stepper_arg, "n_dims", &n_dims);
 </details>
 
 <summary>Python code (click to expand)</summary>
-
 ```Python
 from PyMPDATA import Stepper
 
@@ -381,14 +371,13 @@ stepper = Stepper(options=options, n_dims=2)
 or
 <details>
 <summary>Julia code (click to expand)</summary>
-
 ```Julia
 stepper = Stepper(options=options, grid=(nx, ny))
 ```
 </details>
+
 <details>
 <summary>Matlab code (click to expand)</summary>
-
 ```Matlab
 stepper = Stepper(pyargs(...
   'options', options, ...
@@ -399,7 +388,6 @@ stepper = Stepper(pyargs(...
 
 <details>
 <summary>Rust code (click to expand)</summary>
-
 ```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")?;
@@ -409,7 +397,6 @@ stepper = Stepper(pyargs(...
 
 <details open>
 <summary>Python code (click to expand)</summary>
-
 ```Python
 stepper = Stepper(options=options, grid=(nx, ny))
 ```
@@ -463,7 +450,6 @@ Continuing with the above code snippets, instantiating
 a solver and making 75 integration steps looks as follows:
 <details>
 <summary>Julia code (click to expand)</summary>
-
 ```Julia
 Solver = pyimport("PyMPDATA").Solver
 solver = Solver(stepper=stepper, advectee=advectee, advector=advector)
@@ -471,9 +457,9 @@ solver.advance(n_steps=75)
 state = solver.advectee.get()
 ```
 </details>
+
 <details>
 <summary>Matlab code (click to expand)</summary>
-
 ```Matlab
 Solver = py.importlib.import_module('PyMPDATA').Solver;
 solver = Solver(pyargs('stepper', stepper, 'advectee', advectee, 'advector', advector));
@@ -484,7 +470,6 @@ state = solver.advectee.get();
 
 <details>
 <summary>Rust code (click to expand)</summary>
-
 ```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)))?;
@@ -499,7 +484,6 @@ state = solver.advectee.get();
 
 <details open>
 <summary>Python code (click to expand)</summary>
-
 ```Python
 from PyMPDATA import Solver
 
@@ -513,7 +497,6 @@ state = solver.advectee.get()
 Now let's plot the results using `matplotlib` roughly as in Fig.&nbsp;5 in [Arabas et al. 2014](https://doi.org/10.3233/SPR-140379):
 <details>
 <summary>Python code (click to expand)</summary>
-
 ```Python
 def plot(psi, zlim, norm=None):
     xi, yi = np.indices(psi.shape)
@@ -558,21 +541,20 @@ interactive debugging, one way of enabling it is by setting the
 following environment variable before importing PyMPDATA:
 <details>
 <summary>Julia code (click to expand)</summary>
-
 ```Julia
 ENV["NUMBA_DISABLE_JIT"] = "1"
 ```
 </details>
+
 <details>
 <summary>Matlab code (click to expand)</summary>
-
 ```Matlab
 setenv('NUMBA_DISABLE_JIT', '1');
 ```
 </details>
+
 <details open>
 <summary>Python code (click to expand)</summary>
-
 ```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..a86c29bd 100644
--- a/docs/templates/index.html.jinja2
+++ b/docs/templates/index.html.jinja2
@@ -50,7 +50,7 @@
             <tr>
             <td>
               <ul>
-                <li><a href="https://open-atmos.github.io/PyMPDATA/PyMPDATA.html">docs</a></li>
+                <li><a href="https://open-atmos.github.io/PyMPDATA/PyMPDATA.html">docs (<b>incl. tutorial</b>)</a></li>
                 <li><a href="https://pypi.org/p/PyMPDATA">pypi</a></li>
               </ul>
             </td>
diff --git a/examples/setup.py b/examples/setup.py
index 197ba244..6fbb48c6 100644
--- a/examples/setup.py
+++ b/examples/setup.py
@@ -12,7 +12,10 @@ def get_long_description():
         pdoc_links = re.compile(
             r"(`)([\w\d_-]*).([\w\d_-]*)(`)", re.MULTILINE | re.UNICODE
         )
-        return pdoc_links.sub(r'<a href="\2/\3.html">\3</a>', file.read())
+        return pdoc_links.sub(
+            r'<a href="https://open-atmos.github.io/PyMPDATA/\2/\3.html">\3</a>',
+            file.read(),
+        )
 
 
 CI = "CI" in os.environ

From 1591524eb42b05ea15591f88dbd43c4067480c91 Mon Sep 17 00:00:00 2001
From: Sylwester Arabas <sylwester.arabas@agh.edu.pl>
Date: Wed, 6 Nov 2024 18:51:47 +0100
Subject: [PATCH 02/14] disable attestations for PyPI uploads (cause HTTPError:
 400 Bad Request as of now)

---
 .github/workflows/tests+pypi.yml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/tests+pypi.yml b/.github/workflows/tests+pypi.yml
index e8bf7ace..01557ce1 100644
--- a/.github/workflows/tests+pypi.yml
+++ b/.github/workflows/tests+pypi.yml
@@ -267,13 +267,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@unstable/v1.12.0
         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@unstable/v1.12.0
         with:
+          attestations: false
           packages-dir: ${{ matrix.package-dir }}/dist
 

From 9784ee90b7220b7333cfbf62151b8ec1b9f7a2e1 Mon Sep 17 00:00:00 2001
From: Sylwester Arabas <sylwester.arabas@agh.edu.pl>
Date: Wed, 6 Nov 2024 18:59:45 +0100
Subject: [PATCH 03/14] add Rust mention to pkg metadata

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 25a5d988..d58f07fd 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=[

From 652ed8648272ad57b8ed58b7426e7f1d7d92a90b Mon Sep 17 00:00:00 2001
From: Sylwester Arabas <sylwester.arabas@agh.edu.pl>
Date: Wed, 6 Nov 2024 22:33:04 +0100
Subject: [PATCH 04/14] fix pypa/gh-action-pypi-publish version

---
 .github/workflows/tests+pypi.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/tests+pypi.yml b/.github/workflows/tests+pypi.yml
index 01557ce1..1867304a 100644
--- a/.github/workflows/tests+pypi.yml
+++ b/.github/workflows/tests+pypi.yml
@@ -267,14 +267,14 @@ jobs:
           cd ..
 
       - if: github.event_name == 'push' && github.ref == 'refs/heads/main'
-        uses: pypa/gh-action-pypi-publish@unstable/v1.12.0
+        uses: pypa/gh-action-pypi-publish@release/v1.12.0
         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.12.0
+        uses: pypa/gh-action-pypi-publish@release/v1.12.0
         with:
           attestations: false
           packages-dir: ${{ matrix.package-dir }}/dist

From 293a87011a5a4587a5c15ab9619ce2105c1c11e0 Mon Sep 17 00:00:00 2001
From: Sylwester Arabas <sylwester.arabas@agh.edu.pl>
Date: Thu, 7 Nov 2024 07:17:25 +0100
Subject: [PATCH 05/14] fix pypa/gh-action-pypi-publish branch name

---
 .github/workflows/tests+pypi.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/tests+pypi.yml b/.github/workflows/tests+pypi.yml
index 1867304a..f89dfc94 100644
--- a/.github/workflows/tests+pypi.yml
+++ b/.github/workflows/tests+pypi.yml
@@ -267,14 +267,14 @@ jobs:
           cd ..
 
       - if: github.event_name == 'push' && github.ref == 'refs/heads/main'
-        uses: pypa/gh-action-pypi-publish@release/v1.12.0
+        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@release/v1.12.0
+        uses: pypa/gh-action-pypi-publish@release/v1.12
         with:
           attestations: false
           packages-dir: ${{ matrix.package-dir }}/dist

From c30971fb79593f166664e6a025b96f8bcd3d0c91 Mon Sep 17 00:00:00 2001
From: AgnieszkaZaba <56157996+AgnieszkaZaba@users.noreply.github.com>
Date: Thu, 7 Nov 2024 14:56:58 +0100
Subject: [PATCH 06/14] workaround flexparser frozen dataclass issue (#473)

---
 setup.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/setup.py b/setup.py
index d58f07fd..0e083b5d 100644
--- a/setup.py
+++ b/setup.py
@@ -56,6 +56,7 @@ def get_long_description():
             else ""
         ),
         "pystrict",
+        "flexparser<0.4",
     ],
     extras_require={
         "tests": [

From 0dd54e276fb4a1468bcda528612bf8d3395ee2c7 Mon Sep 17 00:00:00 2001
From: Sylwester Arabas <sylwester.arabas@agh.edu.pl>
Date: Fri, 8 Nov 2024 16:46:37 +0100
Subject: [PATCH 07/14]  bump CI mac jobs to macos-13 from macos-12 (will be
 phased out in Dec 24) (#475)

---
 .github/workflows/tests+pypi.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/tests+pypi.yml b/.github/workflows/tests+pypi.yml
index f89dfc94..21573c02 100644
--- a/.github/workflows/tests+pypi.yml
+++ b/.github/workflows/tests+pypi.yml
@@ -128,7 +128,7 @@ jobs:
     needs: [nojit_and_codecov, pylint, pdoc, precommit, zenodo_json]
     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: macos-14
@@ -168,7 +168,7 @@ 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"]
       fail-fast: false
     runs-on: ${{ matrix.platform }}

From 1b951f4d89aaab86be19b8c0ca6583bb844cc2ef Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Magnuszewski?=
 <47724273+pawelmagnu@users.noreply.github.com>
Date: Fri, 8 Nov 2024 18:35:21 +0100
Subject: [PATCH 08/14] comparison against trixi via 2d advection (#454)

---
 .github/workflows/tests+pypi.yml              |   4 +-
 .../trixi_comparison/__init__.py              |   7 +
 .../advection_comparison.ipynb                | 659 ++++++++++++++++++
 examples/docs/pympdata_examples_landing.md    |   3 +-
 examples/setup.py                             |   1 +
 5 files changed, 672 insertions(+), 2 deletions(-)
 create mode 100644 examples/PyMPDATA_examples/trixi_comparison/__init__.py
 create mode 100644 examples/PyMPDATA_examples/trixi_comparison/advection_comparison.ipynb

diff --git a/.github/workflows/tests+pypi.yml b/.github/workflows/tests+pypi.yml
index 21573c02..9adbf8e4 100644
--- a/.github/workflows/tests+pypi.yml
+++ b/.github/workflows/tests+pypi.yml
@@ -176,7 +176,7 @@ jobs:
       - uses: actions/checkout@v2
         with:
           submodules: recursive
-          fetch-depth: 0 
+          fetch-depth: 0
 
       - uses: actions/setup-python@v5.2.0
         with:
@@ -195,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'
diff --git a/examples/PyMPDATA_examples/trixi_comparison/__init__.py b/examples/PyMPDATA_examples/trixi_comparison/__init__.py
new file mode 100644
index 00000000..c58d4bbd
--- /dev/null
+++ b/examples/PyMPDATA_examples/trixi_comparison/__init__.py
@@ -0,0 +1,7 @@
+"""
+This example uses a basic 2D advection test case to compare PyMPDATA
+solution against Trixi.jl (Julia DG code)
+
+advection_comparison.ipynb:
+.. include:: ./advection_comparison.ipynb.badges.md
+"""
diff --git a/examples/PyMPDATA_examples/trixi_comparison/advection_comparison.ipynb b/examples/PyMPDATA_examples/trixi_comparison/advection_comparison.ipynb
new file mode 100644
index 00000000..1e95b0d9
--- /dev/null
+++ b/examples/PyMPDATA_examples/trixi_comparison/advection_comparison.ipynb
@@ -0,0 +1,659 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e333839d",
+   "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/trixi_comparison/advection_comparison.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/trixi_comparison/advection_comparison.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/trixi_comparison/advection_comparison.ipynb)"
+   ]
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "# Introduction\n",
+    "Trixi.jl is a numerical simulation framework for conservation laws written in Julia. It is based on the Discontinuous Galerkin (DG) method and for the purpose of this comparison, we will use the StructuredMesh for data representation.\n",
+    "\n",
+    "This notebook compares the results of a simple advection equation solved in 2D by PyMPDATA and Trixi.jl.\n",
+    "The general flow of the notebook is as follows:\n",
+    "1. define the advection equation and the common settings for both PyMPDATA and Trixi.jl in the JSON file;\n",
+    "2. run the simulation in Trixi.jl and save the results;\n",
+    "3. use Trixi2Vtk to convert the results to a vtk file;\n",
+    "4. reshape the results from Trixi.jl to match the shape of the results from PyMPDATA;\n",
+    "5. run the simulation in PyMPDATA for a bigger nx and ny, to account for the polynomial degree in Trixi.jl;\n",
+    "6. compare the results from PyMPDATA and Trixi.jl;\n",
+    "7. assert that the results are close to each other, this is to ensure that the implementation of PyMPDATA is correct.\n",
+    "\n",
+    "To run the notebook, Julia and the following Julia packages are required:\n",
+    "- JSON\n",
+    "- Trixi\n",
+    "- OrdinaryDiffEq\n",
+    "- Trixi2Vtk\n",
+    "- Pkg"
+   ],
+   "id": "2448bffa3ee6d9ff"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:29:10.871429Z",
+     "start_time": "2024-10-30T19:29:10.857440Z"
+    }
+   },
+   "cell_type": "code",
+   "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')"
+   ],
+   "id": "6127e1a5c94b8ece",
+   "outputs": [],
+   "execution_count": 1
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "if 'google.colab' in sys.modules:\n",
+    "    JULIA_URL = \"https://julialang-s3.julialang.org/bin/linux/x64/1.11/julia-1.11.1-linux-x86_64.tar.gz\"\n",
+    "    !wget -nv $JULIA_URL -O /tmp/julia.tar.gz\n",
+    "    !tar -x -f /tmp/julia.tar.gz -C /usr/local --strip-components 1\n",
+    "    !rm /tmp/julia.tar.gz"
+   ],
+   "id": "6c2e6e6520f308da"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f162ce9-5704-4464-8b67-be8c86ecabc8",
+   "metadata": {},
+   "source": [
+    "## common settings"
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:29:10.887433Z",
+     "start_time": "2024-10-30T19:29:10.873430Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "SETUP = {\n",
+    "    \"nx\": 32,\n",
+    "    \"ny\": 32,\n",
+    "    \"ux\": 0.25,\n",
+    "    \"uy\": 0.25,\n",
+    "    \"dt\": 0.025,\n",
+    "    \"tmax\": 2.0,\n",
+    "    \"polydeg\": 2,\n",
+    "    \"omega\": 3.141592,\n",
+    "    \"min_x\": -1.0,\n",
+    "    \"min_y\": -1.0,\n",
+    "    \"max_x\": 1.0,\n",
+    "    \"max_y\": 1.0\n",
+    "}\n",
+    "\n",
+    "assert SETUP[\"nx\"] == SETUP[\"ny\"]\n",
+    "\n",
+    "import json\n",
+    "import subprocess\n",
+    "with open('setup.json', 'w', encoding='UTF-8') as f:\n",
+    "    json.dump(SETUP, f)"
+   ],
+   "id": "dff76910f0610a2d",
+   "outputs": [],
+   "execution_count": 2
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "## Trixi.jl",
+   "id": "52cd27020f7efe9"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:29:10.903438Z",
+     "start_time": "2024-10-30T19:29:10.888434Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "%%writefile trixi.jl\n",
+    "import Pkg\n",
+    "Pkg.add([\"JSON\", \"Trixi\", \"OrdinaryDiffEq\", \"Trixi2Vtk\"])\n",
+    "using JSON\n",
+    "using Trixi\n",
+    "using OrdinaryDiffEq\n",
+    "using Trixi2Vtk\n",
+    "\n",
+    "setup = JSON.parsefile(\"./setup.json\")\n",
+    "\n",
+    "advection_velocity = (setup[\"ux\"], setup[\"uy\"])\n",
+    "equations = LinearScalarAdvectionEquation2D(advection_velocity)\n",
+    "solver = DGSEM(polydeg = setup[\"polydeg\"])\n",
+    "\n",
+    "function initial_condition(x, t, equations::LinearScalarAdvectionEquation2D)\n",
+    "    return SVector(sin(setup[\"omega\"]*sum(x)) + 1)\n",
+    "end\n",
+    "\n",
+    "cells_per_dimension = (setup[\"nx\"], setup[\"ny\"])\n",
+    "coordinates_min = (setup[\"min_x\"], setup[\"min_y\"])\n",
+    "coordinates_max = (setup[\"max_x\"], setup[\"max_y\"])\n",
+    "\n",
+    "mesh = StructuredMesh(cells_per_dimension, coordinates_min, coordinates_max)\n",
+    "semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver)\n",
+    "\n",
+    "tspan = (0.0, setup[\"tmax\"])\n",
+    "ode = semidiscretize(semi, tspan);\n",
+    "\n",
+    "summary_callback = SummaryCallback()\n",
+    "save_solution = SaveSolutionCallback(save_initial_solution = false, interval=100)\n",
+    "\n",
+    "stepsize_callback = StepsizeCallback(cfl = 1.6)\n",
+    "\n",
+    "callbacks = CallbackSet(summary_callback, save_solution, stepsize_callback)\n",
+    "\n",
+    "time_int_tol = 1e-6\n",
+    "sol = solve(ode, CarpenterKennedy2N54();\n",
+    "            abstol = time_int_tol,\n",
+    "            reltol = time_int_tol,\n",
+    "            dt = setup[\"dt\"],\n",
+    "            ode_default_options()..., callback = callbacks);\n",
+    "\n",
+    "summary_callback()"
+   ],
+   "id": "6586bff9a39d588f",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overwriting trixi.jl\n"
+     ]
+    }
+   ],
+   "execution_count": 3
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:29:51.466613Z",
+     "start_time": "2024-10-30T19:29:10.905438Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "subprocess.run([\"julia\", \"trixi.jl\"], check=True)",
+   "id": "56fb8302adfc01e7",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "CompletedProcess(args=['julia', 'trixi.jl'], returncode=0)"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 4
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "## PyMPDATA",
+   "id": "a30cc2b4961f1be7"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:29:52.484809Z",
+     "start_time": "2024-10-30T19:29:51.469600Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "import numpy as np\n",
+    "import meshio\n",
+    "from open_atmos_jupyter_utils import show_plot\n",
+    "import matplotlib.pyplot as plt\n",
+    "from PyMPDATA import Solver, ScalarField, VectorField, Stepper, Options\n",
+    "from PyMPDATA.boundary_conditions import Periodic\n",
+    "import os"
+   ],
+   "id": "9aaadc4a5234804a",
+   "outputs": [],
+   "execution_count": 5
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:29:52.500805Z",
+     "start_time": "2024-10-30T19:29:52.485809Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "dt = SETUP[\"dt\"]\n",
+    "tmax = SETUP[\"tmax\"]\n",
+    "nt = int(tmax / dt)\n",
+    "\n",
+    "nx = SETUP[\"nx\"] * SETUP[\"polydeg\"] + 1\n",
+    "ny = SETUP[\"ny\"] * SETUP[\"polydeg\"] + 1\n",
+    "ux  = SETUP[\"ux\"]\n",
+    "uy = SETUP[\"uy\"]\n",
+    "omega = SETUP[\"omega\"]\n",
+    "\n",
+    "min_x, min_y = SETUP[\"min_x\"], SETUP[\"min_y\"]\n",
+    "max_x, max_y = SETUP[\"max_x\"], SETUP[\"max_y\"]\n",
+    "dx_temp = (max_x - min_x) / (nx - 1)\n",
+    "dy_temp = (max_y - min_y) / (ny - 1)\n",
+    "min_x, max_x = min_x - dx_temp/2, max_x + dx_temp/2\n",
+    "min_y, max_y = min_y - dy_temp/2, max_y + dy_temp/2\n",
+    "dx = (max_x - min_x) / nx\n",
+    "dy = (max_y - min_y) / ny\n",
+    "Cx = ux * dt / dx\n",
+    "Cy = uy * dt / dy"
+   ],
+   "id": "9a0f60b51e32ce3e",
+   "outputs": [],
+   "execution_count": 6
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:29:52.516818Z",
+     "start_time": "2024-10-30T19:29:52.502806Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "opt = Options(n_iters=3)\n",
+    "boundary_conditions = (Periodic(), Periodic())"
+   ],
+   "id": "64e3274fa4ac14a6",
+   "outputs": [],
+   "execution_count": 7
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:29:52.532819Z",
+     "start_time": "2024-10-30T19:29:52.518818Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "def initial_condition():\n",
+    "    return np.array(\n",
+    "    [\n",
+    "        np.sin(omega*(x+y)) + 1 for x in np.linspace(min_x, max_x, nx)\n",
+    "        for y in np.linspace(min_y, max_y, ny)\n",
+    "    ],\n",
+    "    dtype=float\n",
+    ").reshape((nx, ny))\n",
+    "\n",
+    "advectee = ScalarField(data=initial_condition(), halo=opt.n_halo, boundary_conditions=boundary_conditions)"
+   ],
+   "id": "cab790be5c425ea5",
+   "outputs": [],
+   "execution_count": 8
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:29:52.547815Z",
+     "start_time": "2024-10-30T19:29:52.534814Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "field_x = np.full((nx+1, ny), Cx, dtype=opt.dtype)\n",
+    "field_y = np.full((nx, ny+1), Cy, dtype=opt.dtype)\n",
+    "\n",
+    "advector = VectorField(\n",
+    "    data=(field_x, field_y),\n",
+    "    halo=opt.n_halo,\n",
+    "    boundary_conditions=(boundary_conditions[0], Periodic())\n",
+    ")"
+   ],
+   "id": "b454a74473b8f900",
+   "outputs": [],
+   "execution_count": 9
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:29:52.988941Z",
+     "start_time": "2024-10-30T19:29:52.548817Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "stepper = Stepper(options=opt, n_dims=2)\n",
+    "solver = Solver(stepper=stepper, advector=advector, advectee=advectee)"
+   ],
+   "id": "ce055b2d3a61a491",
+   "outputs": [],
+   "execution_count": 10
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:29:53.003936Z",
+     "start_time": "2024-10-30T19:29:52.989935Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "vmin = np.min(solver.advectee.get())\n",
+    "vmax = np.max(solver.advectee.get())"
+   ],
+   "id": "5290dbc73bd36d29",
+   "outputs": [],
+   "execution_count": 11
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:30:27.249334Z",
+     "start_time": "2024-10-30T19:29:53.004932Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "_ = solver.advance(n_steps=nt)",
+   "id": "b29adee15e8ff545",
+   "outputs": [],
+   "execution_count": 12
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:30:27.264339Z",
+     "start_time": "2024-10-30T19:30:27.250335Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "pympdata_result_state = solver.advectee.get().copy()",
+   "id": "f59fd725765b765e",
+   "outputs": [],
+   "execution_count": 13
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-30T19:30:28.048648Z",
+     "start_time": "2024-10-30T19:30:27.267338Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "plt.imshow(pympdata_result_state, cmap='viridis', vmin=vmin, vmax=vmax)\n",
+    "plt.colorbar()\n",
+    "plt.xlabel('x')\n",
+    "plt.ylabel('y')\n",
+    "plt.title('PyMDATA solution')\n",
+    "show_plot(inline_format='png')"
+   ],
+   "id": "a041cd5f2c2dbaa",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "HBox(children=(HTML(value=\"<a href='.\\\\tmpjzrlzgss.pdf' target='_blank'>.\\\\tmpjzrlzgss.pdf</a><br>\"), 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": [
+       "<Figure size 640x480 with 2 Axes>"
+      ],
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAggAAAHHCAYAAADaqqCfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABi/klEQVR4nO3de3xV1Z3//9dJyIUACXJLSA0XRwVRuQgS46WipkbGcUSpVUcr4u0rghUyrZaZCnipIFZFLYJaBXSqeGmltSqKUXAcATXKVKtDRVEikKD+5JIAScjZvz9OPXqyPydkkU1OOHk/H4/zeMjKzsk+ubmy9/u9VsjzPA8RERGR70lJ9AmIiIhI26MJgoiIiPhogiAiIiI+miCIiIiIjyYIIiIi4qMJgoiIiPhogiAiIiI+miCIiIiIjyYIIiIi4qMJgoijUaNGMWrUKOf3W758OaFQiOXLlwd+TvHMmDGDUCgU+PP269ePSy+9NPDnFZG2QxMEaXdCoVCzHq35P/K26M0332TGjBls3bo10aciIgnQIdEnINLaHnvssZh/P/rooyxbtsw3fsQRR5jv//LLL+/Tx/3hD3/Irl27SE9P36f3b21vvvkmN910E5deeildu3aNedvatWtJSdHfFyLJTBMEaXcuvvjimH+vWrWKZcuW+cYb27lzJ1lZWfv8P/iUlBQyMzP36X3bmoyMjESfgojsZ/oTQMQwatQojjrqKMrLy/nhD39IVlYW//Ef/xF92/czCOPGjSMzM5OPPvoo5jlKSko46KCD2LRpE9D8DMKOHTuYPHky/fr1IyMjg169evGjH/2Id999N+a4p59+muHDh9OxY0d69OjBxRdfzMaNG5t87s8++4xQKMTChQt9bwuFQsyYMQOIZBd+8YtfANC/f//obZfPPvsMsDMIn376Keeddx7dunUjKyuL4447jueffz7mmG8/B0899RS//vWvOfjgg8nMzOS0005j3bp1TZ67iLQuXUEQiePrr79m9OjRXHDBBVx88cXk5uaax91zzz28+uqrjBs3jpUrV5KamsoDDzzAyy+/zGOPPUZ+fr7Tx7366qt55plnmDRpEoMGDeLrr7/mjTfe4KOPPuKYY44BYOHChYwfP55jjz2WmTNnUlVVxT333MP//M//8N577/luCbg699xz+fvf/84TTzzB3XffTY8ePQDo2bOneXxVVRXHH388O3fu5Gc/+xndu3dn0aJF/Ou//ivPPPMM55xzTszxs2bNIiUlhZ///Ods27aN2bNnc9FFF7F69eoWnbeIBMgTaecmTpzoNf5ROPnkkz3Amz9/vu/4k08+2Tv55JNjxl566SUP8G699Vbv008/9Tp37uyNGTMm5pjXXnvNA7zXXnutyfPJycnxJk6cGPftdXV1Xq9evbyjjjrK27VrV3T8L3/5iwd406ZNi45Nnz495rWtX7/eA7wFCxb4nhfwpk+fHv33HXfc4QHe+vXrfcf27dvXGzduXPTfkydP9gDvv//7v6NjO3bs8Pr37+/169fPa2ho8Dzvu8/BEUcc4dXW1kaPveeeezzAe//99+O+bhFpXbrFIBJHRkYG48ePb9axp59+Ov/v//0/br75Zs4991wyMzN54IEH9unjdu3aldWrV0dvTTT2zjvvsGXLFq655pqYTMOZZ57JwIEDfZf1W8MLL7zAyJEjOfHEE6NjnTt35qqrruKzzz7jww8/jDl+/PjxMVmOk046CYjcphCRtkETBJE4fvCDHzgFEn/zm9/QrVs31qxZw7333kuvXr326ePOnj2bDz74gIKCAkaOHMmMGTNi/sf5+eefAzBgwADf+w4cODD69tb0+eefm+fzbROk8Tn16dMn5t8HHXQQAN98881+OkMRcaUJgkgcHTt2dDr+vffeY8uWLQC8//77+/xxf/KTn/Dpp59y3333kZ+fzx133MGRRx7Jiy++uM/P+a14iyY1NDS0+LldpKammuOe57XqeYhIfJogiASgpqaG8ePHM2jQIK666ipmz57N22+/vc/P17t3b6655hqWLFnC+vXr6d69O7/+9a8B6Nu3LxBZi6CxtWvXRt9u+fYv9caLH1lXHVxWYOzbt695Pv/3f/8Xc84icuDQBEEkADfccAMbNmxg0aJF3HXXXfTr149x48ZRW1vr9DwNDQ1s27YtZqxXr17k5+dHn2vEiBH06tWL+fPnxzz/iy++yEcffcSZZ54Z9/mzs7Pp0aMHr7/+esz4/fff7zu2U6dOgH8yYfnnf/5n3nrrLVauXBkdq6mp4cEHH6Rfv34MGjRor88hIm2Lao4iLfTqq69y//33M3369GgNccGCBYwaNYobb7yR2bNnN/u5duzYwcEHH8yPf/xjhgwZQufOnXnllVd4++23ufPOOwFIS0vj9ttvZ/z48Zx88slceOGF0Zpjv379mDJlSpMf44orrmDWrFlcccUVjBgxgtdff52///3vvuOGDx8OwH/+539ywQUXkJaWxllnnRWdOHzfL3/5S5544glGjx7Nz372M7p168aiRYtYv349f/jDH7TqosgBSBMEkRbYsWMHl112GcOGDeM///M/o+MnnXQS1113HXfeeSfnnnsuxx13XLOeLysri2uuuYaXX36ZP/7xj4TDYQ499FDuv/9+JkyYED3u0ksvJSsri1mzZnHDDTfQqVMnzjnnHG6//fa9roEwbdo0vvzyS5555hmeeuopRo8ezYsvvugLVR577LHccsstzJ8/n6VLlxIOh1m/fr05QcjNzeXNN9/khhtu4L777mP37t0MHjyY5557rskrGiLSdoU8pYJERESkEV33ExERER9NEERERMRHEwQRERHx0QRBREREfDRBEBERER9NEERERMTngFgHYe7cudxxxx1UVlYyZMgQ7rvvPkaOHNms9w2Hw2zatIkuXbo4LR0rIiJtg+d57Nixg/z8/P226Nbu3bupq6sL5LnS09Njdlo9YCV2t+m9W7x4sZeenu498sgj3t/+9jfvyiuv9Lp27epVVVU16/0rKio8QA899NBDjwP8UVFRsV/+P7Nr1y4vr1dqYOeZl5fn7dq1a7+ca2tq8wslFRYWcuyxx/Lb3/4WiFwRKCgo4Nprr+WXv/zlXt9/27ZtdO3alYNn/IqURjO6DtX+KwoddtpXGdKq7edPq/F/+tJqwnGewx7vUFNvjqfu3OMbS9lpr+0f2rXbHPd2+2fEXm2cY+vs8/Dq/edBOIDd/1LsHf1CafaFrVB6mj2e4Z+phzLtbZq9jvasPpyV4RtryLLPY08n+zzqO/v/sqnPsv/aqe9sf5/V+xcpZE8n+0c03ni4k/21Se3k//p27mR/P+V03GWO98ry/yDkZuwwj81N32aO90rb7hvrkWo/R49U+wcvJ8X/fZ0T5w/LjiH7+ywjZH8d0+Ic76Le838Naj3752uXcSzANuPXxbaw/X39VUPnOONdfGNb6rPNY6vqcuzxWv9zAHy1y//N+s3OLPPYmhr/zxfAnhr/1yClxv/5D+/ezRc33crWrVvJybHPsyW2b99OTk4On5f3I7tLy65QbN8Rpu/wz9i2bRvZ2fbn+kDRpm8x1NXVUV5eztSpU6NjKSkpFBcXx2wK8321tbUxG9js2BH5xZOSmembIKTs8f+STm2wf3GnxrnylFrv/yXdoS7ORCAtzngH+xdSaqr/F0qc/6cSSrH/Z+EZ3+teyD4PL84dGM+6NRMK4DJfnF/EoVCcCULI/uUYSvGPh1LsX0heqj0eNsZDHez/gZBmj3tp/s9JON3+PIXT7U922Di9cKb9tU2JM05H+384KVn+z3eq/fucDllxJrlZ/h+E9Ez785EZZ0LX0ZgAZsX5GeiUan/+OhuXmeP9Xs+K872aEWc8LYDv7Xrj765a64cR6BDnb7QG40uwJ2w/x84G+/PXcY//c51Zb39d0uviTJg62D93HYyfsVTsn68Uz56Yp4SNCUKc1wJuO4zui85dQnTu0rKPESZ5bmW36ZDiV199RUNDA7m5uTHjubm5VFZWmu8zc+ZMcnJyoo+CgoLWOFURETnANXjhQB7Jok1PEPbF1KlT2bZtW/RRUVGR6FMSEZEDQBgvkEeyaNO3GHr06EFqaipVVVUx41VVVeTl5Znvk5GRQUaGfZlLREREmqdNTxDS09MZPnw4ZWVljBkzBoiEFMvKypg0aZLTc3WoDvkyB2k1/ntFaXZWygwjAqQbwcO4YcTqOGHEOCFFK5AY2hkvjGiHzbzd/uO9OFUeM4wI+y2QGD+MGCdrEKc2FMr0Twi9rOaHEQEajODhns7NDyMC1HUyQorxwoh27ot6I3gYN4zYOU4YsbP9/dSlk/97oWuWHUbMzbJ/EPIy/QHD3nHCiLlp9njPDv7n6BknpNjVCCNGxv1jWW0kjAh2IHFnnGO3xrkivdUIJH5phA4BvtwTJ3hY7w/0bY4TRqzcbT/Hl7vsAOT/V+MPsOyosX/uGqrtr4EVSOxg/F4O726d+/phwrT0BkHLn6HtaNMTBIDS0lLGjRvHiBEjGDlyJHPmzKGmpobx48cn+tRERCSJNHgeDS0s9rX0/duSNj9BOP/88/nyyy+ZNm0alZWVDB06lKVLl/qCiyIiIhKcNj9BAJg0aZLzLQUREREXQYQMFVIUERFJMmE8GjRBiGo3E4QOO0O+RZCsQKJLGBHsQGIQYUSwA4kuYUSwA4mtHUYEO5AYRBgR7ECiSxgR7ECiSxgxcrw/SFVv57vMMCLYgcQgwohgBxJdwohgBxJdwohgBxJdwohgBxLbShgR7ECiSxgR7ECiSxgR7EBiEGFEgGojkOgSRgR7NVsrPN5QmzyLDx1I2s0EQUREpCm6xRBLEwQRERHUYmgs6VZSFBERkZbTFQQREREg/I9HS58jWWiCICIiAjQE0GJo6fu3Je1mgpBW7d+y2WosuLQVwG4sBNFWALux4NJWgDiNhVZuK4DdWAiirQB2Y8GlrQB2Y8GlrQD28skubQWwGwtBtBXAbiy4tBXAbiy4tBXAbiy4tBXAbiwE0VYAu7Hg0lYAu7Hg0lYAu7Hg0lYAu7Hg2lZwWT7Zpa0AzV/uPk7JJXANXuTR0udIFsogiIiIiE+7uYIgIiLSFGUQYmmCICIiAoQJ0UDLFmUKt/D92xLdYhAREREfXUEQEREBwl7k0dLnSBbtZoKQVuORWh/7lbMaCy5tBbAbC0G0FSLjxl4MLm0F2G+NBZe2AtiNhSDaCmA3FlzaCmA3FuK2FRz2V3BpK4DdWAiirQB2Y8GlrQB2Y8GlrRAZ94+5tBWg9fdXcGkrRMb9PwcubQWwGwsubQWwGwsueyuA2/4KLm0FiLMfTrX/ZyalrnX+r9sQwC2Glr5/W6JbDCIiIuLTbq4giIiINEVXEGJpgiAiIgKEvRBhr4Uthha+f1uiWwwiIiLi026uIKTVhOlQF5sosgKJLmFEsAOJQYQRwQ4ktnYYEexAoksYMTLuDxgGEUYEO5DoEkaMHO+f9VtLJ4Pb8skuYUSwA4lBhBHBDiS6hBHBDiS6hBHBDiS2lTAi2IFElzAi2IFElzAi2IFElzAi2IFEl6WTwW35ZJcwYuR4Y7n7Gv8ne0996yw/pFsMsdrNBEFERKQpDaTQ0MIL6wH8qdZmaIIgIiICeAFkEDxlEERERCSZ6QqCiIgIyiA0pgmCiIgI0OCl0OC1MIOgpZYPPGnVYTqkxSZhrcaCS1sB7MZCEG0FiNNYaOW2AtiNBZe2AtiNhSDaCmA3FlzaCpFxY8yhrQB2Y8GlrQB2YyGItgLYjQWXtgLYjQWXtgLYjYW20lYAu7Hg0lYAu7Hg0lYAu7Hg0lYAe/nkINoKYDcWXNoK0Pzl7kOt1GKQWO1mgiAiItKUMCHCLYzmhUmeSwiaIIiIiKAMQmNqMYiIiIiPriCIiIgQVEhRtxhERESSSiSD0MLNmpLoFkO7mSB0qKmnQ4fYlK7VWHBpK4DdWAikrQD7rbHg0lYAu7Hg0lYAu7EQRFsB7MZC3LaCw/4KLm0FsBsLLm0FsBsLQbQVwG4suLQVIuP+MZe2Auy/xkIQbYXIuP/nwKWtAHZjwaWtAHZjIV5bwWV/hSDaCmA3FlzaCuCwH84e+2sr+1e7mSCIiIg0JRzAXgzJ1GJQSFFERITvMggtfbh4/fXXOeuss8jPzycUCrFkyZImj7/00ksJhUK+x5FHHhk9ZsaMGb63Dxw40PnzoQmCiIgIkSsIQTxc1NTUMGTIEObOndus4++55x42b94cfVRUVNCtWzfOO++8mOOOPPLImOPeeOMNp/MC3WIQERFJmNGjRzN69OhmH5+Tk0NOznd5liVLlvDNN98wfvz4mOM6dOhAXl5ei85NVxBERESABi8UyANg+/btMY/aWjsA31IPP/wwxcXF9O3bN2b8448/Jj8/n0MOOYSLLrqIDRs2OD93u7mCkLpzD6mpsUlYq7Hg0laIjBt7MbSRtgLYjQWXtkJk3N9AcGkrgN1YCKKtEDnen7K29lYAt/0VXNoKYDcWXNoKYDcWgmgrgN1YcGkrgN1YaO22AtiNhSDaCmA3FlzaCmA3FlzaCmA3Fqy9FcBtf4Ug2gqR4/0/My5thci5NG8/HK8hzu/OgDUEEFJs+EdIsaCgIGZ8+vTpzJgxo0XP3dimTZt48cUXefzxx2PGCwsLWbhwIQMGDGDz5s3cdNNNnHTSSXzwwQd06RKnymVoNxMEERGR1lJRUUF29neTwowM+4+nlli0aBFdu3ZlzJgxMePfv2UxePBgCgsL6du3L0899RSXX355s59fEwQREREg7KUQbuFKiuF/rKSYnZ0dM0EImud5PPLII/z0pz8lPc5V4W917dqVww8/nHXr1jl9DGUQRERE+O4WQ0sfrWHFihWsW7euWVcEqqur+eSTT+jdu7fTx9AEQUREJEGqq6tZs2YNa9asAWD9+vWsWbMmGiqcOnUql1xyie/9Hn74YQoLCznqqKN8b/v5z3/OihUr+Oyzz3jzzTc555xzSE1N5cILL3Q6t3ZziyFlZ60vx2cFEl3CiGAHEttKGBHsQKJLGBHsQKJLGBHsQGIQYUSwl092CSOCHUh0CSOCHUh0CSOCHUgMIowIdiDRJYwIdiCxtcOIYAcSgwgjgh1IdAkjgh1IdAkjgr18sksYEexAYhBhRLADiS5hRIiz3H2N/+crpWH/NAAaC0O0hdCS53DxzjvvcMopp0T/XVpaCsC4ceNYuHAhmzdv9jUQtm3bxh/+8Afuuece8zm/+OILLrzwQr7++mt69uzJiSeeyKpVq+jZs6fTubWbCYKIiEhT9mWhI+s5XIwaNQqviR0gFy5c6BvLyclh586dcd9n8eLFTucQj24xiIiIiI+uIIiIiMA+7aVgPUey0ARBREQECBMiTEszCC17/7YkoVOdve1i5Xke06ZNo3fv3nTs2JHi4mI+/vjjxJysiIgktUTs5tiWJfQKwre7WF122WWce+65vrfPnj2be++9l0WLFtG/f39uvPFGSkpK+PDDD8mMk8SPJ7RrN6GU2CCI1VhwaStAnMZCEG0FMBsLLm0FsBsLLm0FsBsLLm0FsBsLzm0Fh+WTXdoKYDcWXNoKYDcWXNoKYDcWgmgrRMb9Yy5tBdh/jQWXtgLYjYUg2gpgNxZc2gpgNxbitRVclk92aSuA3VgIoq0AdmPBpa0AcZa732WMhVunxSCxEjpBaGoXK8/zmDNnDr/61a84++yzAXj00UfJzc1lyZIlXHDBBa15qiIikuSC2Yshea4gtNlXsn79eiorKykuLo6O5eTkUFhYyMqVK+O+X21trW8XLRERkb0Je6FAHsmizU4QKisrAcjNzY0Zz83Njb7NMnPmzOh+2Tk5Ob4dtURERGTv2uwEYV9NnTqVbdu2RR8VFRWJPiURETkAhAPYh6GlCy21JW225piXlwdAVVVVzAYTVVVVDB06NO77ZWRk7JdtNUVEJLkFs5ujJgj7Xf/+/cnLy6OsrCw6Idi+fTurV69mwoQJzs/n7a6j8dfNaiw4tRWg1fdXcGkrRMb9kyWXtgLYjQWXtgLYjQWXvRXAbX8Fl7YC2I0Fl7YC2I0Fl7YC2I2FINoKYDcWWrutAHZjwaWtEBn3/xwE0VYAu7Hg0lYAu7Fg7a0AbvsruLQVwG4sBNFWiJyL/+vo0laA5u+H44Xt73XZvxI6Qaiuro7Zn/rbXay6detGnz59mDx5MrfeeiuHHXZYtOaYn5/PmDFjEnfSIiKSlBoI0dDChY5a+v5tSUInCHvbxer666+npqaGq666iq1bt3LiiSeydOlS5zUQRERE9ka3GGIldIKwt12sQqEQN998MzfffHMrnpWIiIi02QyCiIhIa2qg5bcIAlpHt01oNxMEr3Y3Xig2bGMFEttKGBHsQKJLGBHsQKJLGBHsQKJLGDFyvP+HzmXpZHBbPtkljAh2INEljAh2INEljAh2IDGIMCLYgcTWDiOCHUh0CSOCHUgMIowIdiDRJYwI9vLJLmFEsAOJLmHEyPH+n5kgwohgBxJdwojQ/OXuPa91Qoq6xRCr3UwQREREmqLtnmMlzysRERGRwOgKgoiICOARItzCDIKnmqOIiEhy0S2GWMnzSkRERCQw7eYKgldXT+NdOM3GQhtpK4DdWHBpK4DdWHBpK4DdWHBpK4C9fHIQbQWwGwsubQWwGwsubQWwGwsubQWwGwtBtBVg/zUWXNoKYDcWXNoKYDcWgmgrgN1YiNdWcFk+2aWtAHZjwaWtAHZjIYi2AtiNBZe2QmS8ecvde3G+x4IWxHbNybTdc7uZIIiIiDTl2x0ZW/ocySJ5XomIiIgERlcQRERE0C2GxjRBEBERAcKkEG7hhfWWvn9bkjyvRERERALTbq4gePV78EKNLv3sp8ZCEG2FyLi/geDSVgC7seDSVgC7sRC3reCwv0IQbQWwGwsubQWwGwsubQWwGwsubYXIuH+srbQVwG4suLQVIuP+nwOXtgLYjYUg2gpgNxasvRXAbX8Fl7YC2I0Fl7YC2I2FINoKYDcWXNoK0Pz9cDwvzh45AWvwQjS08BZBS9+/LWk3EwQREZGmKIMQSxMEERERwAtgN0dPKymKiIhIMtMVBBEREaCBEA0t3Gyppe/flrSfCUK4AUItuGDisHxyEGFEsAOJLmFEsAOJLmHEyPH+b3hr6WRwWz45iDAi2IFElzAi2IFElzAi2IFElzAi2IHEthJGBDuQ6BJGBDuQ6BJGBDuQGEQYEezlk13CiGAHEl3CiJHj/T8zLmHEyHn4v45BhBHBDiS6hBHBYbn7ON+nQQt7Lc8QhO1fgQck3WIQERERn/ZzBUFERKQJ4QBCii19/7YkeV6JiIhIC4QJBfJw8frrr3PWWWeRn59PKBRiyZIlTR6/fPlyQqGQ71FZWRlz3Ny5c+nXrx+ZmZkUFhby1ltvuX46NEEQERFJlJqaGoYMGcLcuXOd3m/t2rVs3rw5+ujVq1f0bU8++SSlpaVMnz6dd999lyFDhlBSUsKWLVucPoZuMYiIiJCYlRRHjx7N6NGjnT9Or1696Nq1q/m2u+66iyuvvJLx48cDMH/+fJ5//nkeeeQRfvnLXzb7Y2iC0JhDWwHsxkIQbQWwGwsubQWwGwsubYXIuDHm0FYAu7EQRFsB7MaCS1sB7MaCS1sB7MaCS1sB7MZCEG0FsBsLLm0FsBsLLm0FsBsLLm0FsBsLrm0Fl+WTXdoKYDcWXNoKYDcWXNoKYDcWgmgrRMaNpZZd2goQzHL3AQoyg7B9e+zvj4yMDDIy7P8H7IuhQ4dSW1vLUUcdxYwZMzjhhBMAqKuro7y8nKlTp0aPTUlJobi4mJUrVzp9DN1iEBERCVhBQQE5OTnRx8yZMwN53t69ezN//nz+8Ic/8Ic//IGCggJGjRrFu+++C8BXX31FQ0MDubm5Me+Xm5vryynsja4giIiI8I+QYkvXQfhHSLGiooLs7O+udAV19WDAgAEMGDAg+u/jjz+eTz75hLvvvpvHHnsskI/xLU0QREREAG8fWgjWcwBkZ2fHTBD2p5EjR/LGG28A0KNHD1JTU6mqqoo5pqqqiry8PKfn1S0GERERvtvNsaWP1rZmzRp69+4NQHp6OsOHD6esrOy71xUOU1ZWRlFRkdPz6gqCiIhIglRXV7Nu3brov9evX8+aNWvo1q0bffr0YerUqWzcuJFHH30UgDlz5tC/f3+OPPJIdu/eze9+9zteffVVXn755ehzlJaWMm7cOEaMGMHIkSOZM2cONTU10VZDc7XvCYLRWHBpK4DdWAiirQB2Y8GlrQB2YyFuW8FhfwWXtgLYjYUg2gpgNxZc2gpgNxZc2gqRcf+YS1sBWn9/BZe2QmTc/3Pg0lYAu7Hg0lYAu7HgsrcCuO2v4NJWALux4NJWALux4NJWALuxEERbAezGwoHSVognESspvvPOO5xyyinRf5eWlgIwbtw4Fi5cyObNm9mwYUP07XV1dfz7v/87GzduJCsri8GDB/PKK6/EPMf555/Pl19+ybRp06isrGTo0KEsXbrUF1zcm/Y9QRAREfmHIG4RuL7/qFGj8Lz4OzwtXLgw5t/XX389119//V6fd9KkSUyaNMnpXBpTBkFERER8dAVBREQE9mkvBes5koUmCCIiIiTmFkNb1n4mCCmp0CgAZgUSXcKIkXF/wDCIMCLYgUSXMGLkeP83q7V0Mrgtn+wSRgQ7kBhEGBHsQKJLGBHsQKJLGBHsQGJbCSOCHUh0CSOCHUh0CSOCHUh0CSOCHUh0WToZ3JZPdgkjRo73/8y4hBEj5+H/OrqEEcEOJAYRRoQ4gcQgwojWcvdeGOJ8r8r+034mCCIiIk3QFYRYmiCIiIigCUJjajGIiIiIj64giIiIoCsIjWmCICIiAni0vKYYf8mjA0+7mSCE0joQCsW+XKux4NJWALuxEERbAezGgktbAezlk13aCmA3FlzaCmA3FoJoK4DdWHBpK4DdWHBpK4DdWGgrbQWwGwsubQWwGwsubQWwGwsubQWwl08Ooq0AdmPBpa0AdmPBpa0AdmPBpa0AdmMhkLYC7LfGgtku8zywX3qgdAUhljIIIiIi4tNuriCIiIg0RVcQYmmCICIigiYIjSX0FsPMmTM59thj6dKlC7169WLMmDGsXbs25pjdu3czceJEunfvTufOnRk7dixVVVUJOmMREZH2IaEThBUrVjBx4kRWrVrFsmXLqK+v5/TTT6empiZ6zJQpU3juued4+umnWbFiBZs2beLcc89N4FmLiEgy+vYKQksfySKhtxiWLl0a8++FCxfSq1cvysvL+eEPf8i2bdt4+OGHefzxxzn11FMBWLBgAUcccQSrVq3iuOOOa/bHCqWnEQrFJratxoJLWwHsxkIQbQWwGwtx2woO+yu4tBXAbiy4tBXAbiwE0VYAu7Hg0laIjPvHXNoKsP8aC0G0FSLj/saCS1sB7MaCS1sB7MZCvLaCy/4KQbQVwG4suLQVwG4suLQVwG4suLQVIuPGXgxtpK0Azd8PJ+TRKi0GzwvhtfB/8C19/7akTbUYtm2L/A+gW7duAJSXl1NfX09xcXH0mIEDB9KnTx9WrlyZkHMUERFpD9pMSDEcDjN58mROOOEEjjrqKAAqKytJT0+na9euMcfm5uZSWVlpPk9tbS21td9NNbdvt/9KFRER+b4woRYvlNTS929L2swVhIkTJ/LBBx+wePHiFj3PzJkzycnJiT4KCgoCOkMREUlmyiDEahMThEmTJvGXv/yF1157jYMPPjg6npeXR11dHVu3bo05vqqqiry8PPO5pk6dyrZt26KPioqK/XnqIiIiSSmhEwTP85g0aRLPPvssr776Kv379495+/Dhw0lLS6OsrCw6tnbtWjZs2EBRUZH5nBkZGWRnZ8c8RERE9ubbkGJLH8kioRmEiRMn8vjjj/OnP/2JLl26RHMFOTk5dOzYkZycHC6//HJKS0vp1q0b2dnZXHvttRQVFTk1GABCGZmEUhq3GPwNBJe2AtiNhSDaCpHj/d9o1t4K4La/gktbAezGgktbAezGQhBtBbAbCy5tBbAbC63dVgC7sRBEWwHsxoJLWwHsxoJLWwHsxoK1twK47a8QRFshcrz/Z8alrRA5F//X0aWtAHZjwaWtAHZjoa20FaD5++GEwikQ5+sVJC2UFCuhE4R58+YBMGrUqJjxBQsWcOmllwJw9913k5KSwtixY6mtraWkpIT777+/lc9URESSnWqOsRI6QfC8vW+MmZmZydy5c5k7d24rnJGIiIhAG6o5ioiIJJIXwC0GXUEQERFJMh7QjAvbe32OZNFuJgihzHRCKbFBQyuQ6BJGBDuQGEQYMTJujDmEEcEOJLqEEcEOJLqEEcEOJAYRRgQ7kOgSRgQ7kNjaYUSwA4lBhBHBDiS6hBHBDiS6hBHBXj7ZJYwIdiAxiDAi2IFElzAi2IFElzAi2IFElzAixAkkBhFGBDOQ6BJGhOYvdx+K8zMg+1e7mSCIiIg0JUyIkFZSjNIEQUREBLUYGmsTKymKiIhI26IrCCIiIkQWOQppoaQoTRBERESINBha3GJIohpDu5kgeB0z8VJj07FWY8GlrQB2Y8G5reCwfLJLWwHsxoJLWwHsxoJLWwHsxkIQbYXIuH/Mpa0A+6+x4NJWALuxEERbAezGgktbAezGQry2gsvyyS5tBbAbC0G0FcBuLLi0FcBuLLi0FSLjxlLLLm0FaPXlk13aCpHx5i137zUkz1/lB5J2M0EQERFpikKKsTRBEBERQROExtRiEBER4bvdHFv6cPH6669z1llnkZ+fTygUYsmSJU0e/8c//pEf/ehH9OzZk+zsbIqKinjppZdijpkxYwahUCjmMXDgQNdPhyYIIiIiiVJTU8OQIUOavSHh66+/zo9+9CNeeOEFysvLOeWUUzjrrLN47733Yo478sgj2bx5c/TxxhtvOJ+bbjGIiIiQmBbD6NGjGT16dLOPnzNnTsy/b7vtNv70pz/x3HPPMWzYsOh4hw4dyMvLczuZRtrNBCGclUG4UYvBaiy4tBXAbiy47K0AbvsruLQVwG4suLQVwG4suLQVwG4sBNFWALux0NptBbAbCy5thci4PwUeRFsB7MaCS1sB7MaCtbcCuO2v4NJWALuxEERbIXIu/q+jS1sB7MaCS1sB7MZCW2krgN1YcGkrQPP3wwlq+4i9iUwQWppBCOhkmikcDrNjxw66desWM/7xxx+Tn59PZmYmRUVFzJw5kz59+jg9d7uZIIiIiLSW7dtj/yjKyMggI8OeKLXEb37zG6qrq/nJT34SHSssLGThwoUMGDCAzZs3c9NNN3HSSSfxwQcf0KVLnF69QRkEERERvmsxtPQBUFBQQE5OTvQxc+bMwM/38ccf56abbuKpp56iV69e0fHRo0dz3nnnMXjwYEpKSnjhhRfYunUrTz31lNPz6wqCiIgI4P3j0dLnAKioqCA7+7tbeEFfPVi8eDFXXHEFTz/9NMXFxU0e27VrVw4//HDWrVvn9DF0BUFERCRg2dnZMY8gJwhPPPEE48eP54knnuDMM8/c6/HV1dV88skn9O7d2+njtJsrCA1ZHQh1iA1NWYFElzBi5Hh/oMVl6WRwWz7ZJYwIdiDRJYwIdiDRJYwIdiAxiDAi2IHE1g4jgh1IdAkjgh1IDCKMCHYg0SWMCPbyyS5hRLADiS5hxMjx/p+ZIMKIYAcSXcKIYAcSXcKIECeQ2EbCiGAHEl3CiND85e4b9rROSjERCyVVV1fH/GW/fv161qxZQ7du3ejTpw9Tp05l48aNPProo0DktsK4ceO45557KCwspLKyEoCOHTuSkxP52f/5z3/OWWedRd++fdm0aRPTp08nNTWVCy+80OncdAVBREQEvrvH0NKHg3feeYdhw4ZFK4qlpaUMGzaMadOmAbB582Y2bNgQPf7BBx9kz549TJw4kd69e0cf1113XfSYL774ggsvvJABAwbwk5/8hO7du7Nq1Sp69uzpdG7t5gqCiIhIkwK4goDj+48aNQqviW7kwoULY/69fPnyvT7n4sWLnc4hHl1BEBERER9dQRARESExKym2ZZogiIiIoN0cG2s3E4Q9ndIgLTYdazUWXNoKkXFjLIC2AtiNBZe2AtiNBZe2AtiNBZe2AtiNhSDaCrD/GgsubQWwGwsubQWwGwtBtBXAbizEayu4LJ/s0lYAu7Hg0lYAu7EQRFsB7MaCS1shMm4stezSVoD91lgIoq0QGfc3EFzaCtD85e731LfSWssSo91MEERERJrkhZxDhuZzJAlNEERERFAGoTG1GERERMRHVxBEREQg2M0YkoAmCCIiIqjF0Fi7mSDUd07BS4u9o2I1FuK2FRz2VwiirQB2Y8GlrQB2Y8GlrQB2Y8GlrRAZ94+1lbYC2I0Fl7ZCZNyfAndpK4DdWAiirQB2Y8HaWwHc9ldwaSuA3VhwaSuA3VgIoq0AdmPBpa0AdmOhtdsKYDcWgmgrgN1YcGkrQPP3w9lTr7vhidBuJggiIiJ7lUS3CFpKEwQRERF0i6ExTRBERERAIcVGdGNHREREfNrNFYT6rBTC6bHzISuQaC2dDG7LJwcRRgQ7kOgSRgQ7kOgSRgQ7kOgSRgQ7kNhWwohgBxJdwohgBxJdwohgBxKDCCOCvXyySxgR7ECiSxgxcrz/Z8YljBg5D//XMYgwItiBRJcwIsQJJLZyGBHsQGIQYUSwA4kuYUSIs9y9MdZQ11p/y4b+8WjpcySHdjNBEBERaZJuMcTQLQYRERHx0RUEERER0BWERjRBEBERAe3m2IhuMYiIiIhPu7mCUN85RDg9dmZnLZ/s0lYAu7EQRFsB7MaCS1sB7MaCS1sB7MaCS1sB7MZCEG0FsBsLLm0FsBsLLm0FsBsLLm0FsBsLrm0Fl+WTXdoKYDcWXNoKYDcWXNoKYDcWgmgrRMaNpZZd2gqw3xoLLm0FsBsLQbQVwG4suLQVIM5y953832MNaa3zV7m2e47VbiYIIiIiTVIGIYZuMYiIiIiPriCIiIiAQoqNJPQKwrx58xg8eDDZ2dlkZ2dTVFTEiy++GH377t27mThxIt27d6dz586MHTuWqqqqBJ6xiIgkq5AXzCNZJHSCcPDBBzNr1izKy8t55513OPXUUzn77LP529/+BsCUKVN47rnnePrpp1mxYgWbNm3i3HPPTeQpi4hIsvICeiSJhN5iOOuss2L+/etf/5p58+axatUqDj74YB5++GEef/xxTj31VAAWLFjAEUccwapVqzjuuOOcPlZ9JwhnNB7zfyVd2gpgNxaCaCuA3VhwaSuA3VhwaStExv1jLm0FaP39FVzaCpFxfwrcpa0AdmPBpa0AdmPBZW8FcNtfwaWtAHZjwaWtAHZjwaWtAHZjIYi2AtiNhdZuK4DdWHBpK0TG/Q2EINoKYDcWXNoKkeON/XCMH7sG+0so+1mbCSk2NDSwePFiampqKCoqory8nPr6eoqLi6PHDBw4kD59+rBy5coEnqmIiCSlbzMILX0kiYSHFN9//32KiorYvXs3nTt35tlnn2XQoEGsWbOG9PR0unbtGnN8bm4ulZWVcZ+vtraW2trvppvbt9udfxERkRiqOcZI+BWEAQMGsGbNGlavXs2ECRMYN24cH3744T4/38yZM8nJyYk+CgoKAjxbERGR9iHhE4T09HQOPfRQhg8fzsyZMxkyZAj33HMPeXl51NXVsXXr1pjjq6qqyMvLi/t8U6dOZdu2bdFHRUXFfn4FIiKSFBRSjJHwWwyNhcNhamtrGT58OGlpaZSVlTF27FgA1q5dy4YNGygqKor7/hkZGWRk+MM2ezp5hDM935jv4zuEEcEOJAYRRgQ7kOgSRgQ7kOgSRgQ7kNhWwohgBxJdwohgBxJdwohgBxJdwohgBxJdlk4Gt+WTXcKIkeP9PzMuYcTIefi/ji5hRLADiUGEESFOILGVw4hgBxJdwohgBxKDCCOCHUh0CSNC85e7D6e20v91dYshRkInCFOnTmX06NH06dOHHTt28Pjjj7N8+XJeeuklcnJyuPzyyyktLaVbt25kZ2dz7bXXUlRU5NxgEBERETcJnSBs2bKFSy65hM2bN5OTk8PgwYN56aWX+NGPfgTA3XffTUpKCmPHjqW2tpaSkhLuv//+RJ6yiIgkK62kGCOhE4SHH364ybdnZmYyd+5c5s6d20pnJCIi7VUQKyFqJUURERFJapogiIiIQEJaDK+//jpnnXUW+fn5hEIhlixZstf3Wb58OccccwwZGRkceuihLFy40HfM3Llz6devH5mZmRQWFvLWW2+5nRj7cIth3LhxXH755fzwhz90/mCJtKeTR0qjFoPVWHBpK4DdWAiirQB2Y8GlrQB2Y8GlrQB2Y6GttBXAbiy4tBXAbiy4tBXAbiy4tBXAXj45iLYC2I0Fl7YC2I0Fl7YC2I0Fl7YC2I2FQNoKsN8aCy5tBbAbCy5tBbAbC0G0FcBuLMRtK9g/BvZy952NFkOHJLpu30hNTQ1Dhgzhsssua9ZeQ+vXr+fMM8/k6quv5ve//z1lZWVcccUV9O7dm5KSEgCefPJJSktLmT9/PoWFhcyZM4eSkhLWrl1Lr169mn1uzlcQtm3bRnFxMYcddhi33XYbGzdudH0KERGRNidEALs5On7M0aNHc+utt3LOOec06/j58+fTv39/7rzzTo444ggmTZrEj3/8Y+6+++7oMXfddRdXXnkl48ePZ9CgQcyfP5+srCweeeQRp3NzniAsWbKEjRs3MmHCBJ588kn69evH6NGjeeaZZ6ivt/9iEBERaU+2b98e8/j+FgAtsXLlypg9igBKSkqiexTV1dVRXl4ec0xKSgrFxcXO+xjtUwahZ8+elJaW8r//+7+sXr2aQw89lJ/+9Kfk5+czZcoUPv744315WhERkcQJcLOmgoKCmGX/Z86cGcgpVlZWkpubGzOWm5vL9u3b2bVrF1999RUNDQ3mMU3tY2RpUc1x8+bNLFu2jGXLlpGamso///M/8/777zNo0CBmz57NlClTWvL0IiIirSfAlRQrKirIzv4ul2St8NvWOU8Q6uvr+fOf/8yCBQt4+eWXGTx4MJMnT+bf/u3fop+MZ599lssuu0wTBBERaZeys7NjJghBycvLo6qqKmasqqqK7OxsOnbsSGpqKqmpqeYxTe1jZHGeIPTu3ZtwOMyFF17IW2+9xdChQ33HnHLKKb5tmhMt3KkBOsamk63GgktbAezGQhBtBbAbCy5thci4f8ylrQD7r7EQRFshMu5Pgbu0FcBuLLi0FcBuLMRrK7jsrxBEWwHsxoJLWwHsxoJLWwHsxoJLWyEybuzF0EbaCmA3FlzaCpFx/1+cLm0FsBsLQbQVIsf7v8+svRXAbitAnP1wOvm/LuGUAL5WzXEA7MVQVFTECy+8EDO2bNmy6B5F6enpDB8+nLKyMsaMGQNE9jgqKytj0qRJTh/LeYJw9913c95555EZ55saoGvXrqxfv971qUVERBImESspVldXs27duui/169fz5o1a+jWrRt9+vRh6tSpbNy4kUcffRSAq6++mt/+9rdcf/31XHbZZbz66qs89dRTPP/889HnKC0tZdy4cYwYMYKRI0cyZ84campqGD9+vNO5OU8QfvrTn7q+i4iIiBjeeecdTjnllOi/S0tLgciaQwsXLmTz5s1s2LAh+vb+/fvz/PPPM2XKFO655x4OPvhgfve730XXQAA4//zz+fLLL5k2bRqVlZUMHTqUpUuX+oKLe9PmtnsWERFJiATcYhg1ahSeF/+drFUSR40axXvvvdfk806aNMn5lkJjmiCIiIjAAZFBaE3ai0FERER82s0VhNRO9aRkxSaOrcaCS1sB7MZCEG0FsBsLLm0FsBsLrd1WALuxEERbAezGgktbAezGgktbAezGgrW3ArjtrxBEWyFyvP9PG5e2QuRc/F9Hl7YC2I0Fl7YC2I2FttJWALux4NJWALux4NJWALuxEERbITJujDm0FaD5++GEUlpnlV5t9xyr3UwQREREmvS9lRBb9BxJQhMEERERUAahEWUQRERExEdXEERERFAGobF2M0Ho3KmW1EYZMiuQ6BJGBDuQGEQYEexAoksYEexAYmuHEcEOJAYRRgQ7kOgSRgQ7kOgSRgR7+WSXMCLYgcQgwohgBxJdwohgBxJdwohgBxJdwogQJ5AYRBgRzECiSxgR7ECiSxgR7ECiSxgR7ECicxjRYflklzAiNH+5+4ZQMFsl75VuMcTQLQYRERHxaTdXEERERJoUwC2GZLqCoAmCiIgI6BZDI7rFICIiIj66giAiIgK6gtBIu5kg5HTcRYes2MS21VhwaSuA3VgIoq0QGfePubQVYP81FlzaCmA3FoJoK4DdWHBpK4DdWIjXVnBZPtmlrQB2YyGItgLYjQWXtgLYjQWXtkJk3Fhq2aWtAK2+fLJLWyEy7m8guLQVwG4suLQVwG4suCydDG7LJ7u0FcBuLHTrtNP/sWidFoNqjrF0i0FERER8NEEQERERn3Zzi0FERKRJyiDE0ARBREQEZRAa0y0GERER8Wk3VxB6ZVWTlhWblLYaCy5tBbAbC0G0FcBuLLR2WwHsxoJLWyEy7k+BB9FWALux4NJWALuxYO2tAG77K7i0FcBuLATRVoici//r6NJWALux4NJWALux0FbaCmA3FlzaCmA3FlzaCmA3FlzaCpHj/d9nLnsrgNv+Ci5tBbD3w+nZsdp/bmH7d+d+kURXAFqq3UwQREREmqQMQgzdYhAREREfXUEQERFBIcXGNEEQEREB3WJopN1MEHIzdpCeGRv6sQKJLmFEsAOJQYQRwQ4ktnYYEexAoksYEexAYhBhRLADiS5hRLCXT3YJI4IdSHQJI0aO9/92CSKMCHYg0SWMCHYg0SWMCHECiW0kjAh2INEljAh2INEljAh2INEljBgZN8YCCCOCHUh0CSNC85e7r9tjf0/L/tVuJggiIiJN0S2GWJogiIiIgG4xNKIWg4iIiPjoCoKIiAjoCkIjmiCIiIigDEJj7WaCkJu+jcz02LSw1VhwaSuA3VgIoq0A+6+x4NJWALux4NJWALuxEERbAezGQry2gsvyyS5tBbAbCy5tBbAbC0G0FcBuLLi0FSLjxlLLLm0F2G+NhSDaCpFxfwPBpa0AdmPBpa0AdmMhblvBYfnkINoKYDcWXNoK0Pzl7nent1KLQVcQYiiDICIiIj7t5gqCiIhIk3QFIYYmCCIiIiiD0FibucUwa9YsQqEQkydPjo7t3r2biRMn0r17dzp37szYsWOpqqpK3EmKiIi0E21igvD222/zwAMPMHjw4JjxKVOm8Nxzz/H000+zYsUKNm3axLnnnpugsxQRkaTmBfRwNHfuXPr160dmZiaFhYW89dZbcY8dNWoUoVDI9zjzzDOjx1x66aW+t59xxhnO55XwWwzV1dVcdNFFPPTQQ9x6663R8W3btvHwww/z+OOPc+qppwKwYMECjjjiCFatWsVxxx3n9HF6pW2nY6OUs9VYcGkrRMb9Y22lrQB2Y8GlrRAZ96fAXdoKYDcWgmgrgN1YsPZWALf9FVzaCmA3FlzaCmA3FoJoK4DdWHBpK4DdWGjttgLYjYUg2gpgNxZc2gpgNxZc2gqR4/3fZ9beCuC2v0IQbQWwGwsubQVo/n44u9LifI8FLBG3GJ588klKS0uZP38+hYWFzJkzh5KSEtauXUuvXr18x//xj3+k7ns/h19//TVDhgzhvPPOiznujDPOYMGCBdF/Z2TY38NNSfgVhIkTJ3LmmWdSXFwcM15eXk59fX3M+MCBA+nTpw8rV66M+3y1tbVs37495iEiItIW3XXXXVx55ZWMHz+eQYMGMX/+fLKysnjkkUfM47t160ZeXl70sWzZMrKysnwThIyMjJjjDjroIOdzS+gEYfHixbz77rvMnDnT97bKykrS09Pp2rVrzHhubi6VlZVxn3PmzJnk5OREHwUFBUGftoiIJKMAbzE0/kO1ttZ/ta6uro7y8vKYP4RTUlIoLi5u8g/h73v44Ye54IIL6NSpU8z48uXL6dWrFwMGDGDChAl8/fXXzf40RM/F+T0CUlFRwXXXXcfvf/97MuNcAtwXU6dOZdu2bdFHRUVFYM8tIiJJLMAJQkFBQcwfq9Yfwl999RUNDQ3k5ubGjO/tD+FvvfXWW3zwwQdcccUVMeNnnHEGjz76KGVlZdx+++2sWLGC0aNH09DgdtsvYRmE8vJytmzZwjHHHBMda2ho4PXXX+e3v/0tL730EnV1dWzdujXmKkJVVRV5eXlxnzcjI2Of7rWIiIgEpaKiguzs7/JU++P/Sw8//DBHH300I0eOjBm/4IILov999NFHM3jwYP7pn/6J5cuXc9pppzX7+RM2QTjttNN4//33Y8bGjx/PwIEDueGGGygoKCAtLY2ysjLGjh0LwNq1a9mwYQNFRUXOH69H6g6yOsQGnqxAoksYEexAYlsJI4IdSHQJI4IdSHQJI4IdSAwijAj28skuYUSwA4kuYcTI8f50kksYMXIe/q9jEGFEsAOJLmFEiBNIbOUwItiBxCDCiGAHEl3CiGAHEl3CiGAvn+wSRgQ7kBhEGBHsQKJLGBHsQGJeB//YztQAvseaIfSPR0ufAyA7OztmgmDp0aMHqampvvr+3v4QBqipqWHx4sXcfPPNez2nQw45hB49erBu3boDY4LQpUsXjjrqqJixTp060b179+j45ZdfTmlpKd26dSM7O5trr72WoqIi5waDiIjIXrXySorp6ekMHz6csrIyxowZA0A4HKasrIxJkyY1+b5PP/00tbW1XHzxxXv9OF988QVff/01vXv3bv7J0QZqjk25++67SUlJYezYsdTW1lJSUsL999+f6NMSEZEklIiaY2lpKePGjWPEiBGMHDmSOXPmUFNTw/jx4wG45JJL+MEPfuDLMDz88MOMGTOG7t27x4xXV1dz0003MXbsWPLy8vjkk0+4/vrrOfTQQykpKXE6tzY1QVi+fHnMvzMzM5k7dy5z585NzAmJiIjsR+effz5ffvkl06ZNo7KykqFDh7J06dJocHHDhg2kpMTenlq7di1vvPEGL7/8su/5UlNT+etf/8qiRYvYunUr+fn5nH766dxyyy3OOYg2NUEQERFJmARt1jRp0qS4txQa/+EMMGDAADzP/kAdO3bkpZdecj8JgyYIIiIi30qizZZaqt1MEHqkVtMpNfYyjdVYcGkrgN1YCKKtAHZjwaWtAHZjwaWtAHZjwaWtAHZjwbWt4LJ8sktbAezGgktbAezGgktbAezGQhBthci4sdSyS1sB9ltjwaWtAHZjIYi2AtiNBZe2AtiNhbhtBYflk13aCmA3FoJoK4DdWHBpK4C93H231GrfWEZqnOqV7FftZoIgIiLSFG33HEsTBBEREUhYBqGtSvhmTSIiItL26AqCiIgIusXQmCYIIiIioFsMjbSbCUJOSh2dUxq3GPzHubQVoPX3V3BpK0TG/Slwl7YC2I0Fl7YC2I0Fl70VwG1/BZe2AtiNBZe2AtiNBZe2AtiNhSDaCmA3Flq7rQB2Y8GlrRAZ9zcQgmgrgN1YcGkrRI73f59ZeyuA2/4KLm0FsBsLQbQVwG4suLQVoPn74XRIUYshEdrNBEFERKQpusUQSxMEERER0C2GRjRBEBERAU0QGlHNUURERHzazRWEnBTo0mg6ZAUS20oYEexAoksYEexAoksYEexAoksYEexAosvSyeC2fLJLGDFyvH/a7xJGjJyH/+voEkYEO5AYRBgR4gQSWzmMCHYg0SWMCHYgMYgwItiBRJcwYmTcGHMII4IdSHQJI4IdSAwijAh2INEljAjNX+4+tZX+lFUGIVa7mSCIiIg0SbcYYugWg4iIiPjoCoKIiAgQ8jxCXssuAbT0/dsSTRBERERAtxga0S0GERER8Wk3VxA6hlLJCsXOh6zGQltpK4DdWHBpK4DdWHBpK4DdWHBpK4C9fHIQbQWwGwsubQWwGwsubQWwGwsubQWwGwuBtBVgvzUWXNoKYDcWXNoKYDcWgmgrgN1YiNtWcFg+2aWtAHZjwaWtAHZjIYi2AtiNBZe2QmTcP2a1y/aE7M9/0NRiiNVuJggiIiJN0i2GGLrFICIiIj66giAiIoJuMTSmCYKIiAjoFkMjmiCIiIigKwiNtZsJQkYojYxGLYb91VgIoq0QGfenwF3aCmA3FlzaCmA3FuK1FVz2VwiirQB2Y8GlrQB2Y8GlrQB2Y8GlrRAZN/ZiaCNtBbAbCy5thci4v4Hg0lYAu7EQRFshcrz/+8zaWwHc9ldwaSuA3VhwaSuA3VgIoq0AdmPBpa0Azd8PJyMU55ek7FftZoIgIiLSJN1iiKEJgoiIyD8k0y2CllLNUURERHx0BUFERATA8yKPlj5HktAEQUREBLUYGms3E4S0UCppoX2/o+Kyv0IQbQWwGwsubQWwGwsubQWwGwvW3grgtr9CEG2FyPH+n0iXtkLkXPxfR5e2AtiNBZe2AtiNhbbSVgC7seDSVgC7seDSVgC7sRBEWwHs/RVc2gpgNxZc2gpgNxZc2gpgNxaCaCuA3VhwaStA8/fDSWulvRgkVruZIIiIiDRJLYYYmiCIiIgAoXDk0dLnSBZqMYiIiIiPriCIiIiAbjE0oglCIy5hRLADiUGEEcEOJLqEEcEOJLqEEcFePtkljAh2IDGIMCLYgUSXMCLYgUSXMCLYgUSXMCLECSQGEUYEM5DoEkYEO5DoEkYEO5DoEkYEO5DoHEZ0WD7ZJYwIdiDRJYwIdiDRJYwIdiAxiDBiZNw/5hJGhGCWuw9SoloMc+fO5Y477qCyspIhQ4Zw3333MXLkSPPYhQsXMn78+JixjIwMdn/vd43neUyfPp2HHnqIrVu3csIJJzBv3jwOO+wwp/PSLQYRERH4bh2Elj4cPPnkk5SWljJ9+nTeffddhgwZQklJCVu2bIn7PtnZ2WzevDn6+Pzzz2PePnv2bO69917mz5/P6tWr6dSpEyUlJTGTiObQBEFERCRB7rrrLq688krGjx/PoEGDmD9/PllZWTzyyCNx3ycUCpGXlxd95ObmRt/meR5z5szhV7/6FWeffTaDBw/m0UcfZdOmTSxZssTp3DRBEBER4btbDC19AGzfvj3mUVvrvwVZV1dHeXk5xcXF0bGUlBSKi4tZuXJl3POsrq6mb9++FBQUcPbZZ/O3v/0t+rb169dTWVkZ85w5OTkUFhY2+ZwWTRBERETgu5BiSx9AQUEBOTk50cfMmTN9H+6rr76ioaEh5goAQG5uLpWVleYpDhgwgEceeYQ//elP/Nd//RfhcJjjjz+eL774AiD6fi7PGY9CiiIiIgGrqKggO/u7kHhGhh3mdVVUVERRUVH038cffzxHHHEEDzzwALfccksgH+Nb7XqCYDUWXNoKYDcWgmgrgN1YcGkrgN1YiNdWcFk+2aWtAHZjIYi2AtiNBZe2AtiNBZe2QmTcWGrZpa0Arb58sktbITLu/yXn0lYAu7Hg0lYAu7HgsnQyuC2f7NJWALux4NJWALux4NJWALuxEERbAezGwoHSVognyBZDdnZ2zATB0qNHD1JTU6mqqooZr6qqIi8vr1kfLy0tjWHDhrFu3TqA6PtVVVXRu3fvmOccOnRoM19FhG4xiIiIQKu3GNLT0xk+fDhlZWXRsXA4TFlZWcxVgqY0NDTw/vvvRycD/fv3Jy8vL+Y5t2/fzurVq5v9nN9q11cQREREEqm0tJRx48YxYsQIRo4cyZw5c6ipqYmudXDJJZfwgx/8IJphuPnmmznuuOM49NBD2bp1K3fccQeff/45V1xxBRBpOEyePJlbb72Vww47jP79+3PjjTeSn5/PmDFjnM5NEwQRERESs1DS+eefz5dffsm0adOorKxk6NChLF26NBoy3LBhAykp313s/+abb7jyyiuprKzkoIMOYvjw4bz55psMGjQoesz1119PTU0NV111FVu3buXEE09k6dKlZMa5dRhPQm8xzJgxg1AoFPMYOHBg9O27d+9m4sSJdO/enc6dOzN27FjfvRoREZFABNhicDFp0iQ+//xzamtrWb16NYWFhdG3LV++nIULF0b/fffdd0ePrays5Pnnn2fYsGExzxcKhbj55puprKxk9+7dvPLKKxx++OHO55XwDMKRRx4ZsyLUG2+8EX3blClTeO6553j66adZsWIFmzZt4txzz03g2YqIiLQPCb/F0KFDBzOtuW3bNh5++GEef/xxTj31VAAWLFjAEUccwapVqzjuuOOcPk6910B9o/CI1VhwaStExv0p8CDaCmA3FlzaCmA3Fqy9FcBtfwWXtgLYjYUg2gqRc/F/HV3aCmA3FlzaCmA3FtpKWwHsxoJLWwHsxoJLWwHsxoJLWyFyvP/7zGVvBXDbX8GlrQB2Y8GlrQB2Y8GlrQB2YyGItgLYjYUg2gpWu6zea509lBO1F0NblfArCB9//DH5+fkccsghXHTRRWzYsAGA8vJy6uvrY1aDGjhwIH369GlyNaja2lrfClYiIiJ7FfaCeSSJhE4QCgsLWbhwIUuXLmXevHmsX7+ek046iR07dlBZWUl6ejpdu3aNeZ+9rQY1c+bMmNWrCgoK9vOrEBGRpJCgDEJbldBbDKNHj47+9+DBgyksLKRv37489dRTdOzYcZ+ec+rUqZSWlkb/vX37dk0SREREHCX8FsP3de3alcMPP5x169aRl5dHXV0dW7dujTlmbytMZWRkRFewas5KViIiIgAhAtisKdEvIkAJDyl+X3V1NZ988gk//elPGT58OGlpaZSVlTF27FgA1q5dy4YNG5xXg4JIILHWi50PWYFElzAi2IHEIMKIYAcSXcKIYC+f7BJGBDuQ6BJGjBzvv+4WRBgR7ECiSxgR7ECiSxgR4gQS20gYEexAoksYEexAoksYEexAoksYEezlk4MII4IdSHQJI4IdSHQJI4IdSHQJI4IdSAwijAj7L5BohcdrWymk6LoSYtznSBIJnSD8/Oc/56yzzqJv375s2rSJ6dOnk5qayoUXXkhOTg6XX345paWldOvWjezsbK699lqKioqcGwwiIiLiJqEThC+++IILL7yQr7/+mp49e3LiiSeyatUqevbsCUQWhEhJSWHs2LHU1tZSUlLC/fffn8hTFhGRJKWaY6yEThAWL17c5NszMzOZO3cuc+fObaUzEhGRdiuIFkISTRDaVEhRRERE2oY2FVIUERFJlJDnEWphyLCl79+WtJsJwi6vgQ6NvnBWY8GlrQB2YyGItgLYjYV4bQWX5ZNd2gpgNxZc2gpgNxaCaCuA3VhwaStExo2lll3aCrDfGgtBtBUi4/4GgktbAezGgktbAezGQty2gsPyyUG0FcBuLLi0FcBuLLi0FcBuLLi0FSLj/rG20laA5i93v6u1Wgzhfzxa+hxJQrcYRERExKfdXEEQERFpim4xxNIEQUREBNRiaEQTBBEREdBKio0ogyAiIiI+7eYKwrYwNDRKl1qNBZe2AtiNhSDaCmA3Fqy9FcBtfwWXtgLYjQWXtgLYjYUg2gpgNxZc2gpgNxZau60AdmMhiLYC2I0Fl7YC2I0Fl7ZC5Hj/95m1twK47a8QRFsB7MaCS1sB7MaCS1sB7MaCS1sB7MZCW2krQPP3w4nzayVwWkkxVruZIIiIiDRJtxhi6BaDiIiI+OgKgoiICBAKRx4tfY5koQmCiIgI6BZDI+1mgrAtnM6ecOwdFSuQ6BJGBDuQGEQYEezlk13CiGAHEl3CiJHj/d/wLmHEyHn4Q0pBhBHBDiS6hBEhTiCxlcOIYAcSgwgjgh1IdAkjgh1IdAkjRsaNMYcwItiBxCDCiGAHEl3CiGAHEl3CiGAHEl3CiGAHEoMII4IdSHQJI0Lzl7uvCSfRn+UHkHYzQRAREWmSFkqKoQmCiIgIWmq5MbUYRERExEdXEEREREAhxUY0QRAREYFIfqClecjkmR+0nwnCVw2d2dkQm961GgsubQWwGwuubQWX5ZNd2gpgNxZc2gpgNxZc2gpgNxaCaCtExo2lll3aCrDfGgsubQWwGwtBtBXAbiy4tBXAbizEbSs4LJ/s0lYAu7EQRFsB7MaCS1sB7MaCS1shMu4fc2krQOsvn+zSVoiMN2+5+50NAfx8NoMyCLGUQRARERGfdnMFQUREpEkeAWQQAjmTNkETBBEREVBIsRHdYhAREREfXUEQERGBSIPBzty6PUeSaDcThK8autBxT+zLtRoLLm0FsBsLLnsrgNv+Ci5tBbAbCy5tBbAbCy5tBbAbC0G0FcBuLLR2WwHsxoJLWyEy7m8gBNFWALux4NJWiBzv/z6z9lYAt/0VXNoKYDcWgmgrgN1YcGkrgN1YcGkrgN1YaCttBbAbCy5tBWj+fji7GuL8PAcsUS2GuXPncscdd1BZWcmQIUO47777GDlypHnsQw89xKOPPsoHH3wAwPDhw7nttttijr/00ktZtGhRzPuVlJSwdOlSp/PSLQYREZEEefLJJyktLWX69Om8++67DBkyhJKSErZs2WIev3z5ci688EJee+01Vq5cSUFBAaeffjobN26MOe6MM85g8+bN0ccTTzzhfG6aIIiIiMB3IcWWPhzcddddXHnllYwfP55BgwYxf/58srKyeOSRR8zjf//733PNNdcwdOhQBg4cyO9+9zvC4TBlZWUxx2VkZJCXlxd9HHTQQc6fDk0QREREoNUnCHV1dZSXl1NcXBwdS0lJobi4mJUrVzbrOXbu3El9fT3dunWLGV++fDm9evViwIABTJgwga+//rrZ5/WtdpNBEBERaS3bt8fmUzIyMsjIiM0NffXVVzQ0NJCbmxsznpuby//93/816+PccMMN5Ofnx0wyzjjjDM4991z69+/PJ598wn/8x38wevRoVq5cSWpq8/Mq7WaCsKU+m8z62ICPFUh0CSOCHUh0WToZ3JZPdgkjRo73z2ZdwoiR8/CHlFzCiGAHEoMII0KcQGIrhxHBDiS6hBHBDiQGEUYEO5DoEkYEe/lklzAi2IFElzAi2IHEIMKIYAcSXcKIYAcSXcKIYAcS20oYEexAoksYEZq/3P3uevvcAhfgOggFBQUxw9OnT2fGjBkte+5GZs2axeLFi1m+fDmZ3/tdc8EFF0T/++ijj2bw4MH80z/9E8uXL+e0005r9vO3mwmCiIhIkwKsOVZUVJCd/d0EqPHVA4AePXqQmppKVVVVzHhVVRV5eXlNfpjf/OY3zJo1i1deeYXBgwc3eewhhxxCjx49WLdundMEQRkEERERvqs5tvQBkJ2dHfOwJgjp6ekMHz48JmD4beCwqKgo7nnOnj2bW265haVLlzJixIi9vq4vvviCr7/+mt69ezt9PjRBEBERSZDS0lIeeughFi1axEcffcSECROoqalh/PjxAFxyySVMnTo1evztt9/OjTfeyCOPPEK/fv2orKyksrKS6upqAKqrq/nFL37BqlWr+OyzzygrK+Pss8/m0EMPpaSkxOncdItBREQEErIXw/nnn8+XX37JtGnTqKysZOjQoSxdujQaXNywYQMpKd/9LT9v3jzq6ur48Y9/HPM832YcUlNT+etf/8qiRYvYunUr+fn5nH766dxyyy3mVYymaIIgIiICEPYg1MIJQtj9/SdNmsSkSZPMty1fvjzm35999lmTz9WxY0deeukl53OwtJsJQlVdDul1salgq7Hg0lYAe/nkINoKYDcWXNoKYDcWXNoKYDcWXNoKYDcWAmkrwH5rLLi0FcBuLLi0FcBuLATRVgC7sRC3reCwfLJLWwHsxoJLWwHsxkIQbQWwGwsubYXIuH/Mpa0A+6+xEERbITLu/zlwaStA85e7r6trpRaDxGg3EwQREZEmabvnGJogiIiIABDABIHkmSCoxSAiIiI+uoIgIiICusXQiCYIIiIi8I8GQuu3GNqqdjNBqKrtQlqH2NSt1ViI11Zw2V8hiLYC2I0Fl7YC2I0Fl7YC2I0Fl7ZCZNzYi6GNtBXAbiy4tBUi4/4GgktbAezGQhBthcjx/u8za28FcNtfwaWtAHZjwaWtAHZjIYi2AtiNBZe2AtiNhdZuK4DdWAiirQB2Y8GlrQDN3w+nvtb+/Mv+1W4mCCIiIk3ywpFHS58jSWiCICIiAsogNKIJgoiICCiD0EjCa44bN27k4osvpnv37nTs2JGjjz6ad955J/p2z/OYNm0avXv3pmPHjhQXF/Pxxx8n8IxFRESSX0InCN988w0nnHACaWlpvPjii3z44YfceeedHHTQQdFjZs+ezb333sv8+fNZvXo1nTp1oqSkhN1xlukVERHZJ9/eYmjpI0kk9BbD7bffTkFBAQsWLIiO9e/fP/rfnucxZ84cfvWrX3H22WcD8Oijj5Kbm8uSJUu44IILmv2xvtrViQ4psclxq7Fg7a0AbvsrBNFWiBzv/0ZzaStEzsWfYnZpK4DdWHBpK4DdWGgrbQWwGwsubQWwGwsubQWwGwtBtBUi48aYQ1sB7MaCS1sB7MaCS1sB7MZCEG0FsBsLLm0FsBsLrd1WALuxEERbAezGgktbAezGQtVO/8fbE+d3U+A8AsggBHImbUJCryD8+c9/ZsSIEZx33nn06tWLYcOG8dBDD0Xfvn79eiorKykuLo6O5eTkUFhYyMqVK83nrK2tZfv27TEPERERcZPQCcKnn37KvHnzOOyww3jppZeYMGECP/vZz1i0aBEAlZWVANF9sb+Vm5sbfVtjM2fOJCcnJ/ooKCjYvy9CRESSg24xxEjoBCEcDnPMMcdw2223MWzYMK666iquvPJK5s+fv8/POXXqVLZt2xZ9VFRUBHjGIiKStMLhYB5JIqEThN69ezNo0KCYsSOOOIINGzYAkJeXB0BVVVXMMVVVVdG3NZaRkUF2dnbMQ0RERNwkNKR4wgknsHbt2pixv//97/Tt2xeIBBbz8vIoKytj6NChAGzfvp3Vq1czYcIEp4/1zc4sUokNjFnLJ7uEEcEOJAYRRgQ7kOgSRgQ7kOgSRgQ7kOgSRoQ4gcQgwohgBhJdwohgBxJdwohgBxJdwohgBxKdw4gOyye7hBHBDiS6hBHBDiS6hBHBDiQGEUaMjPvHXMKIsP8CiS5hRLADiUGEEcEOJLqEEcFe7n7rzo6+sYZdrfS3rBZKipHQCcKUKVM4/vjjue222/jJT37CW2+9xYMPPsiDDz4IQCgUYvLkydx6660cdthh9O/fnxtvvJH8/HzGjBmTyFMXEZFkowlCjIROEI499lieffZZpk6dys0330z//v2ZM2cOF110UfSY66+/npqaGq666iq2bt3KiSeeyNKlS8mMU0ETERGRlkv4Usv/8i//wr/8y7/EfXsoFOLmm2/m5ptvbsWzEhGRdkdLLcdI+ARBRESkLfC8MF4Ld2Ns6fu3JZogiIiIQCQ/0NIrAMogHHhqajJI8WJzC1ZjwaWtAHZjIYi2AtiNBZe2AtiNBZe2QmTcWGrZpa0Arb58sktbITLubyC4tBXAbiy4tBXAbiy4LJ0Mbssnu7QVwG4suLQVwG4suLQVwG4sBNFWALux0NptBbAbCy5thci4/+cgiLYC2I0Fl7YC2MvdW+2y8E7z3WU/azcTBBERkSZ5AWQQdAVBREQkyYTDEGphhiCJMggJXUlRRERE2iZdQRAREQHdYmhEEwQRERHAC4fxWniLQTXHA9CemjRSwrFJZKux4NJWALuxEERbIXIu/hSzS1sB7MaCS1sB7MZCW2krgN1YcGkrgN1YcGkrgN1YcGkrRI73f5+57K0AbvsruLQVwG4suLQVwG4suLQVwG4sBNFWALux0NptBbAbCy5tBbAbC0G0FcBuLLi0FaD5++GEdwW0b4s4aTcTBBERkSbpFkMMTRBEREQgskhSSBOEb6nFICIiIj66giAiIgL/+Ou/pesgJM8VhHYzQUipSSWlITZo1MFaJtkhjAiQVu3/ZkivaXkYEexAYkqNHR4L7YoXPPSPu4QRIU4gsY2EEcEOJLqEEcEOJLqEEcEOJNbFCSnWd4qzfLIRSIwbRuwcJ4zYqfnLJ8cLI3brZK9t27NjtW/MJYwIdiAxr4N9bLdU/8cDO5AYRBgR9l8g0SWMCHYg0SWMCHYgMYgwIkDVTv/H3Lqzo3msFUaEOMvdVxuf/90t/5o0hxf28Fp4i8HTBEFERCTJeGFafgUheWqOyiCIiIiIj64giIiIoFsMjWmCICIiArrF0EjSTxC+nc2FjWBeeLc/KNZQa4fH4izSRkqdf7a4p97+BgnFGWePHV7yGvzhwJSGOCsmhuOEFMPGKohenDBinBCV5xkhxTjBKidxfpBCcWbg8Sb2obD/Tlm81VK9Bvvra2UuG/bYr3FPfbxx/3k01Nl38RrS7POwvrzh1DhhxA5xxlPs8wul+L++DSH7+2YP9ni98f1UF+f7d3e6Pb4rzf/9tDPVPueM1DjB3hT/eGqcG6Z7QvbnOiPON0lanONd1Bvf27Vxvt93xRm3Ms01YfvYnQ3252+X8Ttkd739damrs8fra+3fF3uM1VsbdtlfhLCdebVXSDQCid/+/t7ff53vob7F6yTtwf48HohCXjJdDzF88cUXFBQUJPo0RESkhSoqKjj44IMDf97du3fTv39/KisrA3m+vLw81q9fT2acJd8PFEk/QQiHw2zatIkuXbqwY8cOCgoKqKioIDvbru4c6LZv357UrzHZXx/oNSYLvcbgeJ7Hjh07yM/PJyVl/2Trd+/eTV2cqrer9PT0A35yAO3gFkNKSkp0xhn6x6XD7OzspP2B/Vayv8Zkf32g15gs9BqDkZNjr9MQlMzMzKT4n3qQVHMUERERH00QRERExKddTRAyMjKYPn06GRn2MrzJINlfY7K/PtBrTBZ6jXKgS/qQooiIiLhrV1cQREREpHk0QRAREREfTRBERETERxMEERER8Wk3E4S5c+fSr18/MjMzKSws5K233kr0Ke2z119/nbPOOov8/HxCoRBLliyJebvneUybNo3evXvTsWNHiouL+fjjjxNzsvto5syZHHvssXTp0oVevXoxZswY1q5dG3PM7t27mThxIt27d6dz586MHTuWqqqqBJ2xu3nz5jF48ODoIjNFRUW8+OKL0bcf6K+vsVmzZhEKhZg8eXJ07EB/jTNmzCAUCsU8Bg4cGH37gf76vrVx40YuvvhiunfvTseOHTn66KN55513om9Pht854tcuJghPPvkkpaWlTJ8+nXfffZchQ4ZQUlLCli1bEn1q+6SmpoYhQ4Ywd+5c8+2zZ8/m3nvvZf78+axevZpOnTpRUlLCbmPDqrZqxYoVTJw4kVWrVrFs2TLq6+s5/fTTqampiR4zZcoUnnvuOZ5++mlWrFjBpk2bOPfccxN41m4OPvhgZs2aRXl5Oe+88w6nnnoqZ599Nn/729+AA//1fd/bb7/NAw88wODBg2PGk+E1HnnkkWzevDn6eOONN6JvS4bX980333DCCSeQlpbGiy++yIcffsidd97JQQcdFD0mGX7niMFrB0aOHOlNnDgx+u+GhgYvPz/fmzlzZgLPKhiA9+yzz0b/HQ6Hvby8PO+OO+6Ijm3dutXLyMjwnnjiiQScYTC2bNniAd6KFSs8z4u8prS0NO/pp5+OHvPRRx95gLdy5cpEnWaLHXTQQd7vfve7pHp9O3bs8A477DBv2bJl3sknn+xdd911nuclx9dw+vTp3pAhQ8y3JcPr8zzPu+GGG7wTTzwx7tuT9XeOeF7SX0Goq6ujvLyc4uLi6FhKSgrFxcWsXLkygWe2f6xfv57KysqY15uTk0NhYeEB/Xq3bdsGQLdu3QAoLy+nvr4+5nUOHDiQPn36HJCvs6GhgcWLF1NTU0NRUVFSvb6JEydy5plnxrwWSJ6v4ccff0x+fj6HHHIIF110ERs2bACS5/X9+c9/ZsSIEZx33nn06tWLYcOG8dBDD0Xfnqy/c6Qd3GL46quvaGhoIDc3N2Y8Nzc3sK0925JvX1Myvd5wOMzkyZM54YQTOOqoo4DI60xPT6dr164xxx5or/P999+nc+fOZGRkcPXVV/Pss88yaNCgpHl9ixcv5t1332XmzJm+tyXDaywsLGThwoUsXbqUefPmsX79ek466SR27NiRFK8P4NNPP2XevHkcdthhvPTSS0yYMIGf/exnLFq0CEjO3zkSkfS7OcqBb+LEiXzwwQcx93aTxYABA1izZg3btm3jmWeeYdy4caxYsSLRpxWIiooKrrvuOpYtW5a0u+SNHj06+t+DBw+msLCQvn378tRTT9GxY8cEnllwwuEwI0aM4LbbbgNg2LBhfPDBB8yfP59x48Yl+Oxkf0r6Kwg9evQgNTXVlxyuqqoiLy8vQWe1/3z7mpLl9U6aNIm//OUvvPbaa9FtuyHyOuvq6ti6dWvM8Qfa60xPT+fQQw9l+PDhzJw5kyFDhnDPPfckxesrLy9ny5YtHHPMMXTo0IEOHTqwYsUK7r33Xjp06EBubu4B/xob69q1K4cffjjr1q1Liq8hQO/evRk0aFDM2BFHHBG9lZJsv3PkO0k/QUhPT2f48OGUlZVFx8LhMGVlZRQVFSXwzPaP/v37k5eXF/N6t2/fzurVqw+o1+t5HpMmTeLZZ5/l1VdfpX///jFvHz58OGlpaTGvc+3atWzYsOGAep2NhcNhamtrk+L1nXbaabz//vusWbMm+hgxYgQXXXRR9L8P9NfYWHV1NZ988gm9e/dOiq8hwAknnOCrGP/973+nb9++QPL8zhFDolOSrWHx4sVeRkaGt3DhQu/DDz/0rrrqKq9r165eZWVlok9tn+zYscN77733vPfee88DvLvuust77733vM8//9zzPM+bNWuW17VrV+9Pf/qT99e//tU7++yzvf79+3u7du1K8Jk334QJE7ycnBxv+fLl3ubNm6OPnTt3Ro+5+uqrvT59+nivvvqq984773hFRUVeUVFRAs/azS9/+UtvxYoV3vr1672//vWv3i9/+UsvFAp5L7/8sud5B/7rs3y/xeB5B/5r/Pd//3dv+fLl3vr1673/+Z//8YqLi70ePXp4W7Zs8TzvwH99nud5b731ltehQwfv17/+tffxxx97v//9772srCzvv/7rv6LHJMPvHPFrFxMEz/O8++67z+vTp4+Xnp7ujRw50lu1alWiT2mfvfbaax7ge4wbN87zvEjt6MYbb/Ryc3O9jIwM77TTTvPWrl2b2JN2ZL0+wFuwYEH0mF27dnnXXHONd9BBB3lZWVneOeec423evDlxJ+3osssu8/r27eulp6d7PXv29E477bTo5MDzDvzXZ2k8QTjQX+P555/v9e7d20tPT/d+8IMfeOeff763bt266NsP9Nf3reeee8476qijvIyMDG/gwIHegw8+GPP2ZPidI37a7llERER8kj6DICIiIu40QRAREREfTRBERETERxMEERER8dEEQURERHw0QRAREREfTRBERETERxMEERER8dEEQURERHw0QRAREREfTRBEDkBffvkleXl53HbbbdGxN998k/T09Jhd9URE9pX2YhA5QL3wwguMGTOGN998kwEDBjB06FDOPvts7rrrrkSfmogkAU0QRA5gEydO5JVXXmHEiBG8//77vP3222RkZCT6tEQkCWiCIHIA27VrF0cddRQVFRWUl5dz9NFHJ/qURCRJKIMgcgD75JNP2LRpE+FwmM8++yzRpyMiSURXEEQOUHV1dYwcOZKhQ4cyYMAA5syZw/vvv0+vXr0SfWoikgQ0QRA5QP3iF7/gmWee4X//93/p3LkzJ598Mjk5OfzlL39J9KmJSBLQLQaRA9Dy5cuZM2cOjz32GNnZ2aSkpPDYY4/x3//938ybNy/RpyciSUBXEERERMRHVxBERETERxMEERER8dEEQURERHw0QRAREREfTRBERETERxMEERER8dEEQURERHw0QRAREREfTRBERETERxMEERER8dEEQURERHw0QRARERGf/x980ZDKrSf/iQAAAABJRU5ErkJggg=="
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "HBox(children=(HTML(value=\"<a href='.\\\\tmp__kuzitk.pdf' target='_blank'>.\\\\tmp__kuzitk.pdf</a><br>\"), 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/docs/pympdata_examples_landing.md b/examples/docs/pympdata_examples_landing.md
index ed60f6fb..160d53e4 100644
--- a/examples/docs/pympdata_examples_landing.md
+++ b/examples/docs/pympdata_examples_landing.md
@@ -28,7 +28,8 @@ The examples are grouped by the dimensionality of the computational grid.
 | <mark>Spectral-spatial advection</mark>, particle population condensational growth in a vertical column of air, time dependent flow                                                                                                                                                                     | `PyMPDATA_examples.Shipway_and_Hill_2012`<br/><img src="https://github.com/open-atmos/PyMPDATA/wiki/files/KiD-1D_PyMPDATA_n_iters=3.gif" width="50%" alt="spectral-spatial">                                                                                                                           |
 | <mark>shallow-water equations</mark><br/>$$\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`*                                                                                                                                                                                                                                                                |
 | <mark>advection equation</mark>, solid body rotation                                                                                                                                                                                                                                                    | `PyMPDATA_examples.Molenkamp_test_as_in_Jaruga_et_al_2015_Fig_12`*                                                                                                                                                                                                                                     |
-| <mark>advection equation</mark>, 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`<br><img src="https://github.com/open-atmos/PyMPDATA-MPI/releases/download/latest-generated-plots/n_iters.1_rank_0_size_1_c_field_.0.5.0.25._mpi_dim_0_n_threads_1-SphericalScenario-anim.gif" width="50%" alt="mpi-gif"> |
+| <mark>advection equation</mark>, 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`<br><img src="https://github.com/open-atmos/PyMPDATA-MPI/releases/download/latest-generated-plots/n_iters.1_rank_0_size_1_c_field_.0.5.0.25._mpi_dim_0_n_threads_1-SphericalScenario-anim.gif" width="50%" alt="mpi-gif">  |
+| <mark>advection equation</mark>, comparison against DG solution using [Trixi.jl](https://trixi-framework.github.io/)                                                                                                                                                                                    | `PyMPDATA_examples.trixi_comparison`                                                                                                                                                                                                                                                                   |
 
 ## in 3D
 | tags                                                                                                                                | link                                   |
diff --git a/examples/setup.py b/examples/setup.py
index 6fbb48c6..fcaad0c1 100644
--- a/examples/setup.py
+++ b/examples/setup.py
@@ -41,6 +41,7 @@ def get_long_description():
         "joblib",
         "sympy",
         "imageio",
+        "meshio",
     ],
     author="https://github.com/open-atmos/PyMPDATA/graphs/contributors",
     license="GPL-3.0",

From cbf9a8d96a7c398223ff2d6a918441d7bfe1c887 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Magnuszewski?=
 <47724273+pawelmagnu@users.noreply.github.com>
Date: Mon, 11 Nov 2024 22:44:39 +0100
Subject: [PATCH 09/14] add badges to docs; remove nav from index.html (#477)

Co-authored-by: Sylwester Arabas <sylwester.arabas@agh.edu.pl>
---
 docs/templates/index.html.jinja2 | 33 +++++++++++++++++++++++---------
 1 file changed, 24 insertions(+), 9 deletions(-)

diff --git a/docs/templates/index.html.jinja2 b/docs/templates/index.html.jinja2
index a86c29bd..e24538c3 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 %}
+    <style>
+    nav {
+        display: none;
+    }
+    </style>
 {% endblock %}
 
 
 {% block content %}
+    <style>
+    .pdoc {
+        margin: 0 auto;
+        padding: 1em;
+    }
+    ul {
+        list-style-type: none;
+        padding: 0;
+    }
+    </style>
     <main class="pdoc">
         <div style="display: flex; align-items: center;">
             <a href="https://open-atmos.github.io/PyMPDATA/index.html">
@@ -51,33 +66,33 @@
             <td>
               <ul>
                 <li><a href="https://open-atmos.github.io/PyMPDATA/PyMPDATA.html">docs (<b>incl. tutorial</b>)</a></li>
-                <li><a href="https://pypi.org/p/PyMPDATA">pypi</a></li>
+                <li><a href="https://pypi.org/p/PyMPDATA"><img src="https://img.shields.io/pypi/v/pympdata?logo=pypi&logoColor=white"></a></li>
               </ul>
             </td>
             <td>
               <ul>
-                <li><a href="https://open-atmos.github.io/PyMPDATA/PyMPDATA_examples.html">docs</a></li>
-                <li><a href="https://pypi.org/p/PyMPDATA-examples">pypi</a></li>
+                <li><a href="https://open-atmos.github.io/PyMPDATA/PyMPDATA_examples.html">docs (<b>incl. example gallery</b>)</a></li>
+                <li><a href="https://pypi.org/p/PyMPDATA-examples"><img src="https://img.shields.io/pypi/v/pympdata-examples?logo=pypi&logoColor=white"></a></li>
               </ul>
             </td>
             <td>
                 <ul>
                     <li><a href="https://open-atmos.github.io/PyMPDATA-MPI/PyMPDATA_MPI.html">docs</a></li>
-                    <li><a href="https://pypi.org/p/PyMPDATA-MPI/">pypi</a></li>
+                    <li><a href="https://pypi.org/p/PyMPDATA-MPI/"><img src="https://img.shields.io/pypi/v/pympdata-mpi?logo=pypi&logoColor=white"></a></li>
                 </ul>
             </td>
             </tr>
             <tr>
             <td colspan="2">
                 <ul>
-                    <li><a href="https://github.com/open-atmos/PyMPDATA">repository</a></li>
-                    <li><a href="https://github.com/open-atmos/PyMPDATA/issues">issue tracker</a></li>
+                    <li><a href="https://github.com/open-atmos/PyMPDATA"><img src="https://img.shields.io/static/v1?label=PyMPDATA&logo=github&color=gold&message=code+repository"></a></li>
+                        <li><a href="https://github.com/open-atmos/PyMPDATA/issues"><img src="https://img.shields.io/github/issues/open-atmos/pympdata?label=PyMPDATA%20issues&logo=github&logoColor=white"></a></li>
                 </ul>
             </td>
             <td>
                 <ul>
-                    <li><a href="https://github.com/open-atmos/PyMPDATA-MPI">repository</a></li>
-                    <li><a href="https://github.com/open-atmos/PyMPDATA-MPI/issues">issue tracker</a></li>
+                    <li><a href="https://github.com/open-atmos/PyMPDATA-MPI"><img src="https://img.shields.io/static/v1?label=PyMPDATA-MPI&logo=github&color=gold&message=code+repository"></a></li>
+                    <li><a href="https://github.com/open-atmos/PyMPDATA-MPI/issues"><img src="https://img.shields.io/github/issues/open-atmos/pympdata-mpi?label=PyMPDATA-MPI%20issues&logo=github&logoColor=white)"></a></li>
                 </ul>
             </td>
             </tr>

From facf9549ccd6f4d087a1ce6d99822b7278d82e4c Mon Sep 17 00:00:00 2001
From: Sylwester Arabas <sylwester.arabas@agh.edu.pl>
Date: Tue, 12 Nov 2024 23:49:16 +0100
Subject: [PATCH 10/14] more info in docs index (credits, paper, better
 pip-install hints)

---
 docs/templates/index.html.jinja2 | 45 +++++++++++++++++++++++++++-----
 1 file changed, 39 insertions(+), 6 deletions(-)

diff --git a/docs/templates/index.html.jinja2 b/docs/templates/index.html.jinja2
index e24538c3..6c5078cd 100644
--- a/docs/templates/index.html.jinja2
+++ b/docs/templates/index.html.jinja2
@@ -38,7 +38,8 @@
             with optional coordinate transformations.
         </p>
         <p>
-            A separate project called <b>PyMPDATA-MPI</b> depicts how <b>numba-mpi</b> can be used to enable <b>distributed memory parallelism</b> in PyMPDATA.
+            A separate project called <b><a href="https://github.com/open-atmos/PyMPDATA-MPI">PyMPDATA-MPI</a></b> depicts how 
+            <b><a href="https://github.com/numba-mpi/numba-mpi">numba-mpi</a></b> can be used to enable <mark>distributed memory parallelism</mark> in PyMPDATA.
         </p>
     </div>
     <div style="padding-top: 0.5em">
@@ -104,15 +105,25 @@
             PyMPDATA is available on PyPI and can be installed using pip:
         </p>
         <pre><code>pip install PyMPDATA</code></pre>
-        <p>Note: the way above <b>will not</b> install PyMPDATA-examples, to install them both you can run:</p>
-        <pre><code>pip install PyMPDATA[tests]</code></pre>
-        <br>
+        <p>Note: the way above <b>will not</b> install PyMPDATA-examples, to install them, and run the tests, likely the most convenient way is:</p>
+        <pre><code>git clone https://github.com/open-atmos/PySDM.git
+pip install -e PyMPDATA[tests] -e PyMPDATA/examples[tests]
+pytest PyMPDATA
+        </code></pre>
+        <p>(the above should be a viable way to set up development environment for PyMPDATA, see also our <a href="https://github.com/open-atmos/python-dev-hints/wiki">Python dev hints Wiki</a> for further information)</p>
         <p>
             PyMPDATA-examples is available on PyPI and can be installed using pip:
         </p>
         <pre><code>pip install PyMPDATA-examples</code></pre>
-        <p>Note: this will also install PyMPDATA</p>
-    </div>
+        <p>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 
+          <a href="https://colab.research.google.com">Google Colab</a> or <a href="https://mybinder.org">mybinder.org</a> platforms. 
+          To try the notebooks out locally, use:
+        </p>
+        <pre><code>git clone https://github.com/open-atmos/PyMPDATA.git
+pip install -e PyMPDATA -e PyMPDATA/examples
+jupyter-notebook PyMPDATA/examples</code></pre>
+        </div>
         <div style="padding-top: 0.5em">
         <h2>Dependencies</h2>
         <p>
@@ -140,6 +151,28 @@
             feature (rather than the issue tracker) for seeking support in understanding,
             using and extending PyMPDATA code.
         </p>
+    </div>
+     <div style="padding-top: 0.5em">
+        <h2>Licensing, credits, acknowledgements</h2>
+        <p>
+          PyMPDATA and PyMPDATA-examples are free/libre open-source software packages released under the
+            <a href="https://www.gnu.org/licenses/gpl-3.0.en.html">GNU GPL v3 license</a>.
+        <p>
+          Development of PyMPDATA was started by <a href="https://github.com/piotrbartman">Piotr Bartman[-Szwarc]</a>, 
+            <a href="https://github.com/slayoo">Sylwester Arabas</a> and collaborators
+            at the <a href="https://en.uj.edu.pl/en">Jagiellonian University in Kraków</a>.
+          For an overview of features of the initial release, see the
+            <a href="https://doi.org/10.21105/joss.03896">2022 PyMPDATA v1 JOSS paper</a>.
+          See <a href="https://github.com/open-atmos/PyMPDATA/graphs/contributors">list of code committers</a>
+            for a complete list of contributors.
+        </p>
+        <p>
+          Development of PySDM was supported by:
+          <ul>
+            <li><a href="https://www.fnp.org.pl/en/">Foundation for Polish Science</a> (grant no. POIR.04.04.00-00-5E1C/18 co-financed by the European Union under the European Regional Development Fund)</li>
+            <li><a href="https://ncn.gov.pl/en">Polish National Science Centre</a> (grant no. 2020/39/D/ST10/01220)</li>
+          </ul>
+        </p>
     </div>
     </main>
     {% include "search.html.jinja2" %}

From 4eede80a6bcf6bebb820a4db59376a46dc54f4e2 Mon Sep 17 00:00:00 2001
From: Sylwester Arabas <sylwester.arabas@agh.edu.pl>
Date: Wed, 13 Nov 2024 01:32:09 +0100
Subject: [PATCH 11/14] remove PySDM copy-paste leftovers

---
 docs/templates/index.html.jinja2 | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/docs/templates/index.html.jinja2 b/docs/templates/index.html.jinja2
index 6c5078cd..1fbd9f5c 100644
--- a/docs/templates/index.html.jinja2
+++ b/docs/templates/index.html.jinja2
@@ -106,10 +106,9 @@
         </p>
         <pre><code>pip install PyMPDATA</code></pre>
         <p>Note: the way above <b>will not</b> install PyMPDATA-examples, to install them, and run the tests, likely the most convenient way is:</p>
-        <pre><code>git clone https://github.com/open-atmos/PySDM.git
+        <pre><code>git clone https://github.com/open-atmos/PyMPDATA.git
 pip install -e PyMPDATA[tests] -e PyMPDATA/examples[tests]
-pytest PyMPDATA
-        </code></pre>
+pytest PyMPDATA</code></pre>
         <p>(the above should be a viable way to set up development environment for PyMPDATA, see also our <a href="https://github.com/open-atmos/python-dev-hints/wiki">Python dev hints Wiki</a> for further information)</p>
         <p>
             PyMPDATA-examples is available on PyPI and can be installed using pip:
@@ -167,7 +166,7 @@ jupyter-notebook PyMPDATA/examples</code></pre>
             for a complete list of contributors.
         </p>
         <p>
-          Development of PySDM was supported by:
+          Development of PyMPDATA was supported by:
           <ul>
             <li><a href="https://www.fnp.org.pl/en/">Foundation for Polish Science</a> (grant no. POIR.04.04.00-00-5E1C/18 co-financed by the European Union under the European Regional Development Fund)</li>
             <li><a href="https://ncn.gov.pl/en">Polish National Science Centre</a> (grant no. 2020/39/D/ST10/01220)</li>

From ce1b77f4b05b1a161fef590c2e4bef81ebe576e2 Mon Sep 17 00:00:00 2001
From: Sylwester Arabas <sylwester.arabas@agh.edu.pl>
Date: Wed, 13 Nov 2024 10:25:08 +0100
Subject: [PATCH 12/14] remove version pin for flexparser (#478)

---
 setup.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/setup.py b/setup.py
index 0e083b5d..d58f07fd 100644
--- a/setup.py
+++ b/setup.py
@@ -56,7 +56,6 @@ def get_long_description():
             else ""
         ),
         "pystrict",
-        "flexparser<0.4",
     ],
     extras_require={
         "tests": [

From 6d161a26d367abcd178a6e19021272e8cebb3c68 Mon Sep 17 00:00:00 2001
From: Sylwester Arabas <sylwester.arabas@agh.edu.pl>
Date: Wed, 13 Nov 2024 12:41:21 +0100
Subject: [PATCH 13/14] add animation to the docs landing site

---
 docs/templates/index.html.jinja2 | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/docs/templates/index.html.jinja2 b/docs/templates/index.html.jinja2
index 1fbd9f5c..c2704f79 100644
--- a/docs/templates/index.html.jinja2
+++ b/docs/templates/index.html.jinja2
@@ -32,10 +32,15 @@
     <div style="padding-top: 2em">
         <h2>What is PyMPDATA?</h2>
         <p>
-            PyMPDATA is a <b>Numba-accelerated</b> Pythonic implementation of the <b>MPDATA algorithm</b>
-            of <a href="https://doi.org/10.1016/0021-9991(84)90121-9">Smolarkiewicz et al.</a> used in geophysical fluid dynamics and beyond for
-            <b>numerically solving generalised convection-diffusion PDEs</b>. PyMPDATA supports integration in 1D, 2D and 3D structured meshes
-            with optional coordinate transformations.
+            <img align="right" src="https://github.com/open-atmos/PyMPDATA-MPI/releases/download/latest-generated-plots/n_iters.3_rank_0_size_1_c_field_.0.5.0.25._mpi_dim_0_n_threads_3-CartesianScenario-anim.gif">
+            PyMPDATA is a <b><a href="https://numba.pydata.org">Numba-accelerated</a></b> <mark>multi-threaded</mark> Pythonic implementation of the 
+            <b>MPDATA algorithm</b> of <a href="https://doi.org/10.1016/0021-9991(84)90121-9">Smolarkiewicz et al.</a> used in 
+            <mark>geophysical fluid dynamics</mark> and beyond for
+            <b>numerically solving generalised <mark>convection-diffusion PDEs</mark></b>.
+            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 <mark>domain decomposition</mark> across three threads.
         </p>
         <p>
             A separate project called <b><a href="https://github.com/open-atmos/PyMPDATA-MPI">PyMPDATA-MPI</a></b> depicts how 

From a8f04f7e4fb2c41a98c6c23c1d9c6b531d6bb499 Mon Sep 17 00:00:00 2001
From: AgnieszkaZaba <56157996+AgnieszkaZaba@users.noreply.github.com>
Date: Fri, 22 Nov 2024 11:56:08 +0100
Subject: [PATCH 14/14] remove nogus array flip in 2D adv-diff example + code
 cleanup (#468)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Agnieszka Żaba <azaba@agh.edu.pl>
---
 .../advection-diffusion-2d.ipynb              | 356 +++++++++---------
 1 file changed, 180 insertions(+), 176 deletions(-)

diff --git a/examples/PyMPDATA_examples/advection_diffusion_2d/advection-diffusion-2d.ipynb b/examples/PyMPDATA_examples/advection_diffusion_2d/advection-diffusion-2d.ipynb
index 1e4c346c..1a97aea4 100644
--- a/examples/PyMPDATA_examples/advection_diffusion_2d/advection-diffusion-2d.ipynb
+++ b/examples/PyMPDATA_examples/advection_diffusion_2d/advection-diffusion-2d.ipynb
@@ -30,51 +30,49 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
    "id": "e333666d",
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:07.160534Z",
-     "start_time": "2024-10-10T18:30:07.154497Z"
+     "end_time": "2024-11-17T10:48:24.048516Z",
+     "start_time": "2024-11-17T10:48:24.040750Z"
     }
    },
-   "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')"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 59
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
    "id": "43d2893d-f472-43ac-ad5b-bf342a3783b9",
    "metadata": {
+    "id": "43d2893d-f472-43ac-ad5b-bf342a3783b9",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:08.508979Z",
-     "start_time": "2024-10-10T18:30:07.162539Z"
-    },
-    "id": "43d2893d-f472-43ac-ad5b-bf342a3783b9"
+     "end_time": "2024-11-17T10:48:24.064Z",
+     "start_time": "2024-11-17T10:48:24.058632Z"
+    }
    },
-   "outputs": [],
    "source": [
     "from open_atmos_jupyter_utils import show_plot"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 60
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
    "id": "9aaadc4a5234804a",
    "metadata": {
+    "id": "9aaadc4a5234804a",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:09.426364Z",
-     "start_time": "2024-10-10T18:30:08.508979Z"
-    },
-    "id": "9aaadc4a5234804a"
+     "end_time": "2024-11-17T10:48:24.074911Z",
+     "start_time": "2024-11-17T10:48:24.072769Z"
+    }
    },
-   "outputs": [],
    "source": [
     "import os\n",
     "import numpy as np\n",
@@ -84,20 +82,20 @@
     "import matplotlib.pyplot as plt\n",
     "from PyMPDATA import Solver, ScalarField, VectorField, Stepper, Options\n",
     "from PyMPDATA.boundary_conditions import Periodic"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 61
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
    "id": "a563a769a256feba",
    "metadata": {
+    "id": "a563a769a256feba",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:09.432980Z",
-     "start_time": "2024-10-10T18:30:09.427370Z"
-    },
-    "id": "a563a769a256feba"
+     "end_time": "2024-11-17T10:48:24.083541Z",
+     "start_time": "2024-11-17T10:48:24.080757Z"
+    }
    },
-   "outputs": [],
    "source": [
     "mu = 0.0005 # diffusion coefficient\n",
     "dt = 0.025\n",
@@ -117,54 +115,54 @@
     "dy = (max_y - min_y) / ny\n",
     "Cx = ux * dt / dx\n",
     "Cy = uy * dt / dy"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 62
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
    "id": "9a0f60b51e32ce3e",
    "metadata": {
+    "id": "9a0f60b51e32ce3e",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:09.442790Z",
-     "start_time": "2024-10-10T18:30:09.433984Z"
-    },
-    "id": "9a0f60b51e32ce3e"
+     "end_time": "2024-11-17T10:48:24.091078Z",
+     "start_time": "2024-11-17T10:48:24.089428Z"
+    }
    },
-   "outputs": [],
    "source": [
     "opt = Options(n_iters=3, non_zero_mu_coeff=True)\n",
     "boundary_conditions = (Periodic(), Periodic())"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 63
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
    "id": "cab790be5c425ea5",
    "metadata": {
+    "id": "cab790be5c425ea5",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:09.451908Z",
-     "start_time": "2024-10-10T18:30:09.443796Z"
-    },
-    "id": "cab790be5c425ea5"
+     "end_time": "2024-11-17T10:48:24.098801Z",
+     "start_time": "2024-11-17T10:48:24.096647Z"
+    }
    },
-   "outputs": [],
    "source": [
     "def analytic_solution(x, y, t):\n",
     "    return np.sin(omega*(x-ux*t+y-uy*t))*np.exp(-2*mu*t*omega**2) + 1"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 64
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
    "id": "b454a74473b8f900",
    "metadata": {
+    "id": "b454a74473b8f900",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:09.464508Z",
-     "start_time": "2024-10-10T18:30:09.452917Z"
-    },
-    "id": "b454a74473b8f900"
+     "end_time": "2024-11-17T10:48:24.108540Z",
+     "start_time": "2024-11-17T10:48:24.104379Z"
+    }
    },
-   "outputs": [],
    "source": [
     "def z(t):\n",
     "    return np.array(\n",
@@ -176,20 +174,20 @@
     ").reshape((nx, ny))\n",
     "\n",
     "advectee = ScalarField(data=z(t=0), halo=opt.n_halo, boundary_conditions=boundary_conditions)"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 65
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
    "id": "fb28f958a4920cd",
    "metadata": {
+    "id": "fb28f958a4920cd",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:09.474302Z",
-     "start_time": "2024-10-10T18:30:09.465513Z"
-    },
-    "id": "fb28f958a4920cd"
+     "end_time": "2024-11-17T10:48:24.116792Z",
+     "start_time": "2024-11-17T10:48:24.114299Z"
+    }
    },
-   "outputs": [],
    "source": [
     "field_x = np.full((nx+1, ny), Cx, dtype=opt.dtype)\n",
     "field_y = np.full((nx, ny+1), Cy, dtype=opt.dtype)\n",
@@ -199,67 +197,70 @@
     "    halo=opt.n_halo,\n",
     "    boundary_conditions=(boundary_conditions[0], Periodic())\n",
     ")"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 66
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
    "id": "45c8ea60d8490cd4",
    "metadata": {
+    "id": "45c8ea60d8490cd4",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:10.886354Z",
-     "start_time": "2024-10-10T18:30:09.476309Z"
-    },
-    "id": "45c8ea60d8490cd4"
+     "end_time": "2024-11-17T10:48:24.125339Z",
+     "start_time": "2024-11-17T10:48:24.122603Z"
+    }
    },
-   "outputs": [],
    "source": [
     "stepper = Stepper(options=opt, n_dims=2)\n",
     "solver = Solver(stepper=stepper, advector=advector, advectee=advectee)"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 67
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
    "id": "bd4722c47297508c",
    "metadata": {
+    "id": "bd4722c47297508c",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:10.890517Z",
-     "start_time": "2024-10-10T18:30:10.886354Z"
-    },
-    "id": "bd4722c47297508c"
+     "end_time": "2024-11-17T10:48:24.132258Z",
+     "start_time": "2024-11-17T10:48:24.130678Z"
+    }
    },
-   "outputs": [],
    "source": [
     "vmin = np.min(solver.advectee.get())\n",
     "vmax = np.max(solver.advectee.get())"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 68
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
    "id": "0e66ee78-f623-4e5f-99ef-0e43a2c81da1",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-11-17T10:48:24.145284Z",
+     "start_time": "2024-11-17T10:48:24.139694Z"
+    }
+   },
    "source": [
-    "def plot(*, data, title):\n",
+    "def plot(*, data, title, colorbar=True):\n",
     "    fig, axs = plt.subplots(1, 1, figsize=(6, 6))\n",
-    "    ims = axs.imshow(data, cmap='viridis', vmin=vmin, vmax=vmax)\n",
-    "    fig.colorbar(ims, ax=axs)\n",
+    "    ims = axs.imshow(data, cmap='viridis', vmin=vmin, vmax=vmax, origin='lower')\n",
+    "    if colorbar:\n",
+    "        fig.colorbar(ims, ax=axs)\n",
     "    axs.set_xlabel('x')\n",
     "    axs.set_ylabel('y')\n",
     "    axs.set_title(title)"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 69
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
    "id": "d7a5cd43651621e6",
    "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:11.275924Z",
-     "start_time": "2024-10-10T18:30:10.891521Z"
-    },
     "colab": {
      "base_uri": "https://localhost:8080/",
      "height": 536,
@@ -275,51 +276,51 @@
      ]
     },
     "id": "d7a5cd43651621e6",
-    "outputId": "dcf9d10e-7f93-4491-8c26-a24e322eb4ee"
+    "outputId": "dcf9d10e-7f93-4491-8c26-a24e322eb4ee",
+    "ExecuteTime": {
+     "end_time": "2024-11-17T10:48:24.401807Z",
+     "start_time": "2024-11-17T10:48:24.156844Z"
+    }
    },
+   "source": [
+    "plot(\n",
+    "    data=solver.advectee.get().copy(),\n",
+    "    title='Initial condition'\n",
+    ")\n",
+    "show_plot(\"fig_1\", inline_format='png')"
+   ],
    "outputs": [
     {
      "data": {
-      "image/png": "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",
       "text/plain": [
        "<Figure size 600x600 with 2 Axes>"
-      ]
+      ],
+      "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=\"<a href='./fig_1.pdf' target='_blank'>./fig_1.pdf</a><br>\"), HTML(value=\"<a href='.…"
-      ]
+      ],
+      "application/vnd.jupyter.widget-view+json": {
+       "version_major": 2,
+       "version_minor": 0,
+       "model_id": "ba8740985b92437e813025222bedab09"
+      }
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
-   "source": [
-    "plot(\n",
-    "    data=solver.advectee.get().copy(),\n",
-    "    title='Initial condition'\n",
-    ")\n",
-    "show_plot(\"fig_1\", inline_format='png')"
-   ]
+   "execution_count": 70
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
    "id": "2b279996b00be430",
    "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:49.915008Z",
-     "start_time": "2024-10-10T18:30:11.276920Z"
-    },
     "colab": {
      "base_uri": "https://localhost:8080/",
      "height": 69,
@@ -330,44 +331,44 @@
      ]
     },
     "id": "2b279996b00be430",
-    "outputId": "9b04d6f4-e170-42bc-f79b-18114f7c4164"
+    "outputId": "9b04d6f4-e170-42bc-f79b-18114f7c4164",
+    "ExecuteTime": {
+     "end_time": "2024-11-17T10:48:24.648416Z",
+     "start_time": "2024-11-17T10:48:24.410361Z"
+    }
    },
+   "source": [
+    "progbar = FloatProgress(value=0, min=0, max=1)\n",
+    "display(progbar)\n",
+    "\n",
+    "states_history = [solver.advectee.get().copy()]\n",
+    "for i in range(nt//10):\n",
+    "    solver.advance(n_steps=10, mu_coeff=(mu, mu))\n",
+    "    states_history.append(solver.advectee.get().copy())\n",
+    "    progbar.value = (i + 1.) / (nt//10)"
+   ],
    "outputs": [
     {
      "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c079f50692b9449cb47711c096647208",
-       "version_major": 2,
-       "version_minor": 0
-      },
       "text/plain": [
        "FloatProgress(value=0.0, max=1.0)"
-      ]
+      ],
+      "application/vnd.jupyter.widget-view+json": {
+       "version_major": 2,
+       "version_minor": 0,
+       "model_id": "718e6e7c9a484e17ad0976e18883dcef"
+      }
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
-   "source": [
-    "progbar = FloatProgress(value=0, min=0, max=1)\n",
-    "display(progbar)\n",
-    "\n",
-    "states_history = [solver.advectee.get().copy()]\n",
-    "for i in range(nt//10):\n",
-    "    solver.advance(n_steps=10, mu_coeff=(mu, mu))\n",
-    "    states_history.append(solver.advectee.get().copy())\n",
-    "    progbar.value = (i + 1.) / (nt//10)"
-   ]
+   "execution_count": 71
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
    "id": "2576fcdbfa20c032",
    "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:50.206389Z",
-     "start_time": "2024-10-10T18:30:49.916003Z"
-    },
     "colab": {
      "base_uri": "https://localhost:8080/",
      "height": 536,
@@ -383,131 +384,134 @@
      ]
     },
     "id": "2576fcdbfa20c032",
-    "outputId": "d47a4681-9734-4553-d424-3830b5549d6d"
+    "outputId": "d47a4681-9734-4553-d424-3830b5549d6d",
+    "ExecuteTime": {
+     "end_time": "2024-11-17T10:48:24.875574Z",
+     "start_time": "2024-11-17T10:48:24.655381Z"
+    }
    },
+   "source": [
+    "plot(\n",
+    "    data=solver.advectee.get().copy(),\n",
+    "    title='Final condition'\n",
+    ")\n",
+    "show_plot(\"fig_2\", inline_format='png')"
+   ],
    "outputs": [
     {
      "data": {
-      "image/png": "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",
       "text/plain": [
        "<Figure size 600x600 with 2 Axes>"
-      ]
+      ],
+      "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=\"<a href='./fig_2.pdf' target='_blank'>./fig_2.pdf</a><br>\"), HTML(value=\"<a href='.…"
-      ]
+      ],
+      "application/vnd.jupyter.widget-view+json": {
+       "version_major": 2,
+       "version_minor": 0,
+       "model_id": "9f20a696185647c0b352673c3822f263"
+      }
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
-   "source": [
-    "plot(\n",
-    "    data=solver.advectee.get().copy(),\n",
-    "    title='Final condition'\n",
-    ")\n",
-    "show_plot(\"fig_2\", inline_format='png')"
-   ]
+   "execution_count": 72
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
    "id": "556684f5a2e2483d",
    "metadata": {
+    "id": "556684f5a2e2483d",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:50.213674Z",
-     "start_time": "2024-10-10T18:30:50.207377Z"
-    },
-    "id": "556684f5a2e2483d"
+     "end_time": "2024-11-17T10:48:24.892189Z",
+     "start_time": "2024-11-17T10:48:24.886346Z"
+    }
    },
-   "outputs": [],
    "source": [
     "assert np.allclose(solver.advectee.get(), z(t=nt*dt), atol=0.25)"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 73
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
    "id": "cc07e0075e5b9857",
    "metadata": {
+    "id": "cc07e0075e5b9857",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:52.377040Z",
-     "start_time": "2024-10-10T18:30:50.214687Z"
-    },
-    "id": "cc07e0075e5b9857"
+     "end_time": "2024-11-17T10:48:26.052714Z",
+     "start_time": "2024-11-17T10:48:24.898326Z"
+    }
    },
-   "outputs": [],
    "source": [
     "os.makedirs(\"animation\", exist_ok=True)\n",
     "for i, state in enumerate(states_history):\n",
-    "    state = np.flipud(state)\n",
-    "    plt.imshow(state, cmap='viridis')\n",
+    "    plot(data=state, title=None,colorbar=False)\n",
     "    plt.axis('off')\n",
     "    plt.tight_layout()\n",
-    "    plt.colorbar()\n",
     "    plt.savefig(f\"animation/frame_{i:03d}.png\")\n",
     "    plt.close()"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 74
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
    "id": "1888a38e39bf2395",
    "metadata": {
+    "id": "1888a38e39bf2395",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:52.381500Z",
-     "start_time": "2024-10-10T18:30:52.378029Z"
-    },
-    "id": "1888a38e39bf2395"
+     "end_time": "2024-11-17T10:48:26.063023Z",
+     "start_time": "2024-11-17T10:48:26.060767Z"
+    }
    },
-   "outputs": [],
    "source": [
     "def merge_images_into_gif(image_folder, gif_name, duration=0.01):\n",
     "    with imageio.get_writer(gif_name, mode='I', duration=duration, loop=0) as writer:\n",
     "        for filename in sorted(os.listdir(image_folder)):\n",
     "            image = imageio.v3.imread(os.path.join(image_folder, filename))\n",
     "            writer.append_data(image)"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 75
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
    "id": "52bc22d60805baa6",
    "metadata": {
+    "id": "52bc22d60805baa6",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:53.093920Z",
-     "start_time": "2024-10-10T18:30:52.382495Z"
-    },
-    "id": "52bc22d60805baa6"
+     "end_time": "2024-11-17T10:48:26.428970Z",
+     "start_time": "2024-11-17T10:48:26.075064Z"
+    }
    },
-   "outputs": [],
    "source": [
     "merge_images_into_gif(\"animation\", \"advection_diffusion.gif\", duration=0.01)"
-   ]
+   ],
+   "outputs": [],
+   "execution_count": 76
   },
   {
    "cell_type": "code",
-   "execution_count": null,
    "id": "5403105d000206da",
    "metadata": {
+    "id": "5403105d000206da",
     "ExecuteTime": {
-     "end_time": "2024-10-10T18:30:53.097687Z",
-     "start_time": "2024-10-10T18:30:53.094915Z"
-    },
-    "id": "5403105d000206da"
+     "end_time": "2024-11-17T10:48:26.437388Z",
+     "start_time": "2024-11-17T10:48:26.435624Z"
+    }
    },
+   "source": [],
    "outputs": [],
-   "source": []
+   "execution_count": null
   }
  ],
  "metadata": {