From a26cb00c02ffbe1e72159cf9b170d3e86c4e2aca Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 18 Apr 2024 08:43:50 -0400 Subject: [PATCH 001/154] Updating setup.py to reflect version number --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index bb24006a..7466a814 100644 --- a/setup.py +++ b/setup.py @@ -50,6 +50,6 @@ def local_pkg(name: str, relative_path: str) -> str: packages=find_namespace_packages(include=["ndsl", "ndsl.*"]), include_package_data=True, url="https://github.com/NOAA-GFDL/NDSL", - version="2024.04.00-RC", + version="2024.04.00", zip_safe=False, ) From 695c174b59b88bfd6d2b4d82b9e927f01391ba6f Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Wed, 24 Apr 2024 11:33:53 -0400 Subject: [PATCH 002/154] Update to `mypy` 1.4.1 Fix TypeVar returning without concrete allocation --- .pre-commit-config.yaml | 3 ++- ndsl/types.py | 12 ++++++------ 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 8e207343..8df5e5ae 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -15,11 +15,12 @@ repos: args: ["--profile", "black"] - repo: https://github.com/pre-commit/mirrors-mypy - rev: v0.812 + rev: v1.4.1 hooks: - id: mypy name: mypy-ndsl args: [--config-file, setup.cfg] + additional_dependencies: [types-PyYAML] files: ndsl exclude: | (?x)^( diff --git a/ndsl/types.py b/ndsl/types.py index 6c4ce596..e3461c39 100644 --- a/ndsl/types.py +++ b/ndsl/types.py @@ -9,7 +9,7 @@ class Allocator(Protocol): - def __call__(self, shape: Iterable[int], dtype: type) -> Array: + def __call__(self, shape: Iterable[int], dtype: type): pass @@ -21,23 +21,23 @@ class NumpyModule(Protocol): @functools.wraps(np.rot90) def rot90(self, *args, **kwargs): - ... + pass @functools.wraps(np.sum) def sum(self, *args, **kwargs): - ... + pass @functools.wraps(np.log) def log(self, *args, **kwargs): - ... + pass @functools.wraps(np.sin) def sin(self, *args, **kwargs): - ... + pass @functools.wraps(np.asarray) def asarray(self, *args, **kwargs): - ... + pass class AsyncRequest(Protocol): From 4f640ba52e8bd607df780d698a2789c1493bbe55 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Fri, 10 May 2024 14:01:30 -0400 Subject: [PATCH 003/154] Update to DaCe fixing parsing issue when using python 3.11.x --- external/dace | 2 +- external/gt4py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/external/dace b/external/dace index b1a7f8a6..ee5a6dfe 160000 --- a/external/dace +++ b/external/dace @@ -1 +1 @@ -Subproject commit b1a7f8a6ea76f913a0bf8b32de5bc416697218fd +Subproject commit ee5a6dfe695f329c3882105b087f3563a0c80b81 diff --git a/external/gt4py b/external/gt4py index d6dfd6ff..8c5ab417 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit d6dfd6ff46cc1d50b0fb6d05fb0b6271e4a1f5cc +Subproject commit 8c5ab41797a74bc0695566a91d811132bf29f327 From 385860e8c8c1d542f41071d08bce603cccaf98d7 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Tue, 14 May 2024 10:50:50 -0400 Subject: [PATCH 004/154] Basic boilerplate + utset --- ndsl/boilerplate.py | 93 +++++++++++++++++++++++++++++++++++++++ tests/test_boilerplate.py | 61 +++++++++++++++++++++++++ 2 files changed, 154 insertions(+) create mode 100644 ndsl/boilerplate.py create mode 100644 tests/test_boilerplate.py diff --git a/ndsl/boilerplate.py b/ndsl/boilerplate.py new file mode 100644 index 00000000..bf2ef7aa --- /dev/null +++ b/ndsl/boilerplate.py @@ -0,0 +1,93 @@ +import numpy as np +from ndsl import ( + StencilFactory, + DaceConfig, + DaCeOrchestration, + GridIndexing, + StencilConfig, + CompilationConfig, + RunMode, + SubtileGridSizer, + NullComm, + QuantityFactory, + TileCommunicator, + TilePartitioner, +) + +from typing import Tuple + + +def _get_one_tile_factory( + nx, ny, nz, nhalo, backend, orchestration +)-> Tuple[StencilFactory, QuantityFactory]: + """Build a Stencil & Quantity factory for: + - one tile + - no MPI communicator + """ + dace_config = DaceConfig( + communicator=None, + backend=backend, + orchestration=orchestration, + ) + + compilation_config = CompilationConfig( + backend=backend, + rebuild=True, + validate_args=True, + format_source=False, + device_sync=False, + run_mode=RunMode.BuildAndRun, + use_minimal_caching=False, + ) + + stencil_config = StencilConfig( + compare_to_numpy=False, + compilation_config=compilation_config, + dace_config=dace_config, + ) + + partitioner = TilePartitioner((1, 1)) + sizer = SubtileGridSizer.from_tile_params( + nx_tile=nx, + ny_tile=ny, + nz=nz, + n_halo=nhalo, + extra_dim_lengths={}, + layout=partitioner.layout, + tile_partitioner=partitioner, + ) + + tile_comm = TileCommunicator(comm=NullComm(0, 1, 42), partitioner=partitioner) + + grid_indexing = GridIndexing.from_sizer_and_communicator(sizer, tile_comm) + stencil_factory = StencilFactory(config=stencil_config, grid_indexing=grid_indexing) + quantity_factory = QuantityFactory(sizer, np) + + return stencil_factory, quantity_factory + + +def get_one_tile_factory_orchestrated_cpu( + nx, ny, nz, nhalo +) -> Tuple[StencilFactory, QuantityFactory]: + """Build a Stencil & Quantity factory for orchestrated CPU""" + return _get_one_tile_factory( + nx=nx, + ny=ny, + nz=nz, + nhalo=nhalo, + backend="dace:cpu", + orchestration=DaCeOrchestration.BuildAndRun + ) + +def get_one_tile_factory_numpy( + nx, ny, nz, nhalo +) -> Tuple[StencilFactory, QuantityFactory]: + """Build a Stencil & Quantity factory for Numpy""" + return _get_one_tile_factory( + nx=nx, + ny=ny, + nz=nz, + nhalo=nhalo, + backend="numpy", + orchestration=DaCeOrchestration.Python + ) diff --git a/tests/test_boilerplate.py b/tests/test_boilerplate.py new file mode 100644 index 00000000..b677a7a2 --- /dev/null +++ b/tests/test_boilerplate.py @@ -0,0 +1,61 @@ +from ndsl.constants import X_DIM, Y_DIM, Z_DIM +from ndsl.dsl.typing import FloatField +from ndsl import StencilFactory, QuantityFactory +import numpy as np +from gt4py.cartesian.gtscript import ( + computation, PARALLEL, interval +) + +def _copy_ops(stencil_factory: StencilFactory, quantity_factory: QuantityFactory): + # Allocate data and fill input + qty_out = quantity_factory.zeros(dims=[X_DIM, Y_DIM, Z_DIM], units="n/a") + qty_in = quantity_factory.zeros(dims=[X_DIM, Y_DIM, Z_DIM], units="n/a") + qty_in.view[:] = np.indices( + dimensions=quantity_factory.sizer.get_extent([X_DIM, Y_DIM, Z_DIM]), + dtype=np.float64).sum( + axis=0 + ) # Value of each entry is sum of the I and J index at each point + + # Define a stencil + def copy_stencil(input_field: FloatField, output_field: FloatField): + with computation(PARALLEL), interval(...): + output_field = input_field + + # Execute + copy = stencil_factory.from_dims_halo(func=copy_stencil, compute_dims=[X_DIM, Y_DIM, Z_DIM]) + copy(qty_in, qty_out) + assert (qty_in.view[:] == qty_out.view[:]).all() + +def test_boilerplate_import_numpy(): + """Test make sure the basic numpy boilerplate works as expected. + + Dev Note: the import inside the function are part of the test. + """ + from ndsl.boilerplate import get_one_tile_factory_numpy + # Boilerplate + stencil_factory, quantity_factory = get_one_tile_factory_numpy( + nx = 5, + ny = 5, + nz = 2, + nhalo=1 + ) + + _copy_ops(stencil_factory, quantity_factory) + + +def test_boilerplate_import_orchestrated_cpu(): + """Test make sure the basic orchestrate boilerplate works as expected. + + Dev Note: the import inside the function are part of the test. + """ + from ndsl.boilerplate import get_one_tile_factory_orchestrated_cpu + + # Boilerplate + stencil_factory, quantity_factory = get_one_tile_factory_orchestrated_cpu( + nx = 5, + ny = 5, + nz = 2, + nhalo=1 + ) + + _copy_ops(stencil_factory, quantity_factory) From 50b8d82692ea3ed12f1f27bc6a79e0d44f4d11ad Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Tue, 14 May 2024 11:01:16 -0400 Subject: [PATCH 005/154] lint --- ndsl/boilerplate.py | 26 ++++++++++++++------------ tests/test_boilerplate.py | 37 ++++++++++++++++++------------------- 2 files changed, 32 insertions(+), 31 deletions(-) diff --git a/ndsl/boilerplate.py b/ndsl/boilerplate.py index bf2ef7aa..d2b0cb96 100644 --- a/ndsl/boilerplate.py +++ b/ndsl/boilerplate.py @@ -1,28 +1,29 @@ +from typing import Tuple + import numpy as np + from ndsl import ( - StencilFactory, + CompilationConfig, DaceConfig, DaCeOrchestration, GridIndexing, - StencilConfig, - CompilationConfig, - RunMode, - SubtileGridSizer, NullComm, QuantityFactory, + RunMode, + StencilConfig, + StencilFactory, + SubtileGridSizer, TileCommunicator, TilePartitioner, ) -from typing import Tuple - def _get_one_tile_factory( nx, ny, nz, nhalo, backend, orchestration -)-> Tuple[StencilFactory, QuantityFactory]: +) -> Tuple[StencilFactory, QuantityFactory]: """Build a Stencil & Quantity factory for: - - one tile - - no MPI communicator + - one tile + - no MPI communicator """ dace_config = DaceConfig( communicator=None, @@ -76,9 +77,10 @@ def get_one_tile_factory_orchestrated_cpu( nz=nz, nhalo=nhalo, backend="dace:cpu", - orchestration=DaCeOrchestration.BuildAndRun + orchestration=DaCeOrchestration.BuildAndRun, ) + def get_one_tile_factory_numpy( nx, ny, nz, nhalo ) -> Tuple[StencilFactory, QuantityFactory]: @@ -89,5 +91,5 @@ def get_one_tile_factory_numpy( nz=nz, nhalo=nhalo, backend="numpy", - orchestration=DaCeOrchestration.Python + orchestration=DaCeOrchestration.Python, ) diff --git a/tests/test_boilerplate.py b/tests/test_boilerplate.py index b677a7a2..983a8d07 100644 --- a/tests/test_boilerplate.py +++ b/tests/test_boilerplate.py @@ -1,10 +1,10 @@ +import numpy as np +from gt4py.cartesian.gtscript import PARALLEL, computation, interval + +from ndsl import QuantityFactory, StencilFactory from ndsl.constants import X_DIM, Y_DIM, Z_DIM from ndsl.dsl.typing import FloatField -from ndsl import StencilFactory, QuantityFactory -import numpy as np -from gt4py.cartesian.gtscript import ( - computation, PARALLEL, interval -) + def _copy_ops(stencil_factory: StencilFactory, quantity_factory: QuantityFactory): # Allocate data and fill input @@ -12,7 +12,8 @@ def _copy_ops(stencil_factory: StencilFactory, quantity_factory: QuantityFactory qty_in = quantity_factory.zeros(dims=[X_DIM, Y_DIM, Z_DIM], units="n/a") qty_in.view[:] = np.indices( dimensions=quantity_factory.sizer.get_extent([X_DIM, Y_DIM, Z_DIM]), - dtype=np.float64).sum( + dtype=np.float64, + ).sum( axis=0 ) # Value of each entry is sum of the I and J index at each point @@ -22,22 +23,23 @@ def copy_stencil(input_field: FloatField, output_field: FloatField): output_field = input_field # Execute - copy = stencil_factory.from_dims_halo(func=copy_stencil, compute_dims=[X_DIM, Y_DIM, Z_DIM]) + copy = stencil_factory.from_dims_halo( + func=copy_stencil, compute_dims=[X_DIM, Y_DIM, Z_DIM] + ) copy(qty_in, qty_out) assert (qty_in.view[:] == qty_out.view[:]).all() + def test_boilerplate_import_numpy(): """Test make sure the basic numpy boilerplate works as expected. - - Dev Note: the import inside the function are part of the test. + + Dev Note: the import inside the function are part of the test. """ from ndsl.boilerplate import get_one_tile_factory_numpy + # Boilerplate stencil_factory, quantity_factory = get_one_tile_factory_numpy( - nx = 5, - ny = 5, - nz = 2, - nhalo=1 + nx=5, ny=5, nz=2, nhalo=1 ) _copy_ops(stencil_factory, quantity_factory) @@ -45,17 +47,14 @@ def test_boilerplate_import_numpy(): def test_boilerplate_import_orchestrated_cpu(): """Test make sure the basic orchestrate boilerplate works as expected. - - Dev Note: the import inside the function are part of the test. + + Dev Note: the import inside the function are part of the test. """ from ndsl.boilerplate import get_one_tile_factory_orchestrated_cpu # Boilerplate stencil_factory, quantity_factory = get_one_tile_factory_orchestrated_cpu( - nx = 5, - ny = 5, - nz = 2, - nhalo=1 + nx=5, ny=5, nz=2, nhalo=1 ) _copy_ops(stencil_factory, quantity_factory) From 2e20297626e3a08c9e24d0f5fc64dec0d551062d Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Tue, 14 May 2024 11:11:54 -0400 Subject: [PATCH 006/154] Add pytest-cov, configure --- .coveragerc | 7 +++++++ setup.cfg | 3 +++ setup.py | 2 +- 3 files changed, 11 insertions(+), 1 deletion(-) create mode 100644 .coveragerc diff --git a/.coveragerc b/.coveragerc new file mode 100644 index 00000000..9beb909a --- /dev/null +++ b/.coveragerc @@ -0,0 +1,7 @@ +[run] +omit = + tests/* + .gt_cache* + .dacecache* + external/* + __init__.py \ No newline at end of file diff --git a/setup.cfg b/setup.cfg index 76603c37..d9d91755 100644 --- a/setup.cfg +++ b/setup.cfg @@ -23,3 +23,6 @@ namespace_packages = True strict_optional = False warn_unreachable = True explicit_package_bases = True + +[tool:pytest] +addopts = --cov-config=.coveragerc --cov=ndsl diff --git a/setup.py b/setup.py index 7466a814..c25070b4 100644 --- a/setup.py +++ b/setup.py @@ -11,7 +11,7 @@ def local_pkg(name: str, relative_path: str) -> str: return path -test_requirements = ["pytest", "pytest-subtests"] +test_requirements = ["pytest", "pytest-subtests", "pytest-cov"] develop_requirements = test_requirements + ["pre-commit"] extras_requires = {"test": test_requirements, "develop": develop_requirements} From 637191db44d21204400a9b0dd4da47d6a2f08a51 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Tue, 14 May 2024 11:19:09 -0400 Subject: [PATCH 007/154] lint --- .coveragerc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.coveragerc b/.coveragerc index 9beb909a..6f6e0ab2 100644 --- a/.coveragerc +++ b/.coveragerc @@ -1,7 +1,7 @@ [run] -omit = +omit = tests/* .gt_cache* .dacecache* external/* - __init__.py \ No newline at end of file + __init__.py From e375e4ed5a6bff86e988af96d040fb6562e07118 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Tue, 14 May 2024 12:10:48 -0400 Subject: [PATCH 008/154] Swap `pytest-cov` for raw usage of `coverage` which allows for better paralle process --- .coveragerc | 7 ------- .github/workflows/unit_tests.yaml | 9 +++++++-- setup.cfg | 11 +++++++++-- setup.py | 2 +- 4 files changed, 17 insertions(+), 12 deletions(-) delete mode 100644 .coveragerc diff --git a/.coveragerc b/.coveragerc deleted file mode 100644 index 6f6e0ab2..00000000 --- a/.coveragerc +++ /dev/null @@ -1,7 +0,0 @@ -[run] -omit = - tests/* - .gt_cache* - .dacecache* - external/* - __init__.py diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 77a0d5c2..6c733170 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -27,7 +27,12 @@ jobs: pip install .[test] - name: Run serial-cpu tests run: | - pytest -x tests + coverage run --rcfile=setup.cfg -m pytest -x tests - name: Run parallel-cpu tests run: | - mpirun -np 6 --oversubscribe pytest -x tests/mpi + mpirun -np 6 --oversubscribe coverage run --rcfile=setup.cfg -m mpi4py -m pytest -x tests/mpi + - name: Output code coverage + run: | + coverage combine + coverage report + diff --git a/setup.cfg b/setup.cfg index d9d91755..133a3e2d 100644 --- a/setup.cfg +++ b/setup.cfg @@ -24,5 +24,12 @@ strict_optional = False warn_unreachable = True explicit_package_bases = True -[tool:pytest] -addopts = --cov-config=.coveragerc --cov=ndsl +[coverage:run] +parallel = true +branch = true +omit = + tests/* + .gt_cache* + .dacecache* + external/* + __init__.py diff --git a/setup.py b/setup.py index c25070b4..ce6fb6f3 100644 --- a/setup.py +++ b/setup.py @@ -11,7 +11,7 @@ def local_pkg(name: str, relative_path: str) -> str: return path -test_requirements = ["pytest", "pytest-subtests", "pytest-cov"] +test_requirements = ["pytest", "pytest-subtests", "coverage"] develop_requirements = test_requirements + ["pre-commit"] extras_requires = {"test": test_requirements, "develop": develop_requirements} From 77e19d0ec47d23f3ba031cfe3848938d8895989b Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Tue, 14 May 2024 12:14:59 -0400 Subject: [PATCH 009/154] lint --- .github/workflows/unit_tests.yaml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 6c733170..e6ef31bc 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -34,5 +34,4 @@ jobs: - name: Output code coverage run: | coverage combine - coverage report - + coverage report From c682381c640db03bc51e335f5f67ba656fa7ae75 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Tue, 14 May 2024 12:23:35 -0400 Subject: [PATCH 010/154] Better source coverage --- setup.cfg | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/setup.cfg b/setup.cfg index 133a3e2d..1a142931 100644 --- a/setup.cfg +++ b/setup.cfg @@ -29,7 +29,8 @@ parallel = true branch = true omit = tests/* - .gt_cache* + *gt_cache* .dacecache* external/* __init__.py +source_pkgs = ndsl From 352c04af90d7c3c3e5519c1182e11ffaa014bca9 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Tue, 14 May 2024 15:46:21 -0400 Subject: [PATCH 011/154] Updating submodules --- external/gt4py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/external/gt4py b/external/gt4py index 8c5ab417..2f5799eb 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit 8c5ab41797a74bc0695566a91d811132bf29f327 +Subproject commit 2f5799ebcb49314f9bf40932c797f7acb85b4c67 From 931e336e795735a3694b569e8546ea513083bd6d Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Wed, 15 May 2024 11:20:07 -0400 Subject: [PATCH 012/154] Updated quantity.py to use dsl type Float where needed --- external/dace | 2 +- external/gt4py | 2 +- ndsl/quantity.py | 6 ++++-- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/external/dace b/external/dace index b1a7f8a6..ee5a6dfe 160000 --- a/external/dace +++ b/external/dace @@ -1 +1 @@ -Subproject commit b1a7f8a6ea76f913a0bf8b32de5bc416697218fd +Subproject commit ee5a6dfe695f329c3882105b087f3563a0c80b81 diff --git a/external/gt4py b/external/gt4py index 66f84473..2f5799eb 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit 66f8447398762127ba51c7a335d0da7ada369219 +Subproject commit 2f5799ebcb49314f9bf40932c797f7acb85b4c67 diff --git a/ndsl/quantity.py b/ndsl/quantity.py index f998c860..6e7e25b4 100644 --- a/ndsl/quantity.py +++ b/ndsl/quantity.py @@ -6,6 +6,7 @@ import ndsl.constants as constants from ndsl.comm._boundary_utils import bound_default_slice, shift_boundary_slice_tuple +from ndsl.dsl.typing import Float from ndsl.optional_imports import cupy, dace, gt4py from ndsl.optional_imports import xarray as xr from ndsl.types import NumpyModule @@ -260,7 +261,8 @@ def _validate_quantity_property_lengths(shape, dims, origin, extent): def _is_float(dtype): """Expected floating point type for Pace""" return ( - dtype == float + dtype == Float + or dtype == float or dtype == np.float32 or dtype == np.float64 or dtype == np.float16 @@ -298,7 +300,7 @@ def __init__( """ # ToDo: [Florian 01/23] Kill the abomination. # See https://github.com/NOAA-GFDL/pace/issues/3 - from ndsl.dsl.typing import Float + # from ndsl.dsl.typing import Float if ( not allow_mismatch_float_precision From c9709141845e6e55f91b79991d05796566842f30 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Wed, 15 May 2024 11:40:35 -0400 Subject: [PATCH 013/154] Added use of 'Float' dsl type where needed in allocator.py --- ndsl/initialization/allocator.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/ndsl/initialization/allocator.py b/ndsl/initialization/allocator.py index 5320e4c6..869086f6 100644 --- a/ndsl/initialization/allocator.py +++ b/ndsl/initialization/allocator.py @@ -3,6 +3,7 @@ import numpy as np from ndsl.constants import SPATIAL_DIMS +from ndsl.dsl.typing import Float from ndsl.initialization.sizer import GridSizer from ndsl.optional_imports import gt4py from ndsl.quantity import Quantity, QuantityHaloSpec @@ -60,7 +61,7 @@ def empty( self, dims: Sequence[str], units: str, - dtype: type = np.float64, + dtype: type = Float, allow_mismatch_float_precision: bool = False, ): return self._allocate( @@ -71,7 +72,7 @@ def zeros( self, dims: Sequence[str], units: str, - dtype: type = np.float64, + dtype: type = Float, allow_mismatch_float_precision: bool = False, ): return self._allocate( @@ -82,7 +83,7 @@ def ones( self, dims: Sequence[str], units: str, - dtype: type = np.float64, + dtype: type = Float, allow_mismatch_float_precision: bool = False, ): return self._allocate( @@ -116,7 +117,7 @@ def _allocate( allocator: Callable, dims: Sequence[str], units: str, - dtype: type = np.float64, + dtype: type = Float, allow_mismatch_float_precision: bool = False, ): origin = self.sizer.get_origin(dims) @@ -150,7 +151,7 @@ def get_quantity_halo_spec( self, dims: Sequence[str], n_halo: Optional[int] = None, - dtype: type = np.float64, + dtype: type = Float, ) -> QuantityHaloSpec: """Build memory specifications for the halo update. From 6c86f0ae8b1e8752bfb36def76156de33d9d1400 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 16 May 2024 11:33:03 -0400 Subject: [PATCH 014/154] Updating gt4py and casting of float types to Float dsl type where needed in geometry.py and helper.py --- external/gt4py | 2 +- ndsl/grid/geometry.py | 9 +++++---- ndsl/grid/helper.py | 5 +++-- 3 files changed, 9 insertions(+), 7 deletions(-) diff --git a/external/gt4py b/external/gt4py index 2f5799eb..c89bd818 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit 2f5799ebcb49314f9bf40932c797f7acb85b4c67 +Subproject commit c89bd8189f232fcb2ee1cc96a5b4dc9ae7636491 diff --git a/ndsl/grid/geometry.py b/ndsl/grid/geometry.py index 804be0fe..74441cde 100644 --- a/ndsl/grid/geometry.py +++ b/ndsl/grid/geometry.py @@ -1,4 +1,5 @@ from ndsl.comm.partitioner import TilePartitioner +from ndsl.dsl.typing import Float from ndsl.grid.gnomonic import ( get_lonlat_vect, get_unit_vector_direction, @@ -591,7 +592,7 @@ def edge_factors( nhalo: int, tile_partitioner: TilePartitioner, rank: int, - radius: float, + radius: Float, np, ): """ @@ -704,7 +705,7 @@ def efactor_a2c_v( nhalo: int, tile_partitioner: TilePartitioner, rank: int, - radius: float, + radius: Float, np, ): """ @@ -888,7 +889,7 @@ def unit_vector_lonlat(grid, np): return unit_lon, unit_lat -def _fill_halo_corners(field, value: float, nhalo: int, tile_partitioner, rank): +def _fill_halo_corners(field, value: Float, nhalo: int, tile_partitioner, rank): """ Fills a tile halo corners (ghost cells) of a field with a set value along the first 2 axes @@ -905,7 +906,7 @@ def _fill_halo_corners(field, value: float, nhalo: int, tile_partitioner, rank): field[-nhalo:, -nhalo:] = value # NE corner -def _fill_single_halo_corner(field, value: float, nhalo: int, corner: str): +def _fill_single_halo_corner(field, value: Float, nhalo: int, corner: str): """ Fills a tile halo corner (ghost cells) of a field with a set value along the first 2 axes diff --git a/ndsl/grid/helper.py b/ndsl/grid/helper.py index fd62d771..745dce37 100644 --- a/ndsl/grid/helper.py +++ b/ndsl/grid/helper.py @@ -12,6 +12,7 @@ split_cartesian_into_storages = None import ndsl.constants as constants from ndsl.constants import Z_DIM, Z_INTERFACE_DIM +from ndsl.dsl.typing import Float from ndsl.filesystem import get_fs from ndsl.grid.generation import MetricTerms from ndsl.initialization.allocator import QuantityFactory @@ -226,13 +227,13 @@ def dp(self) -> Quantity: return self._dp_ref @property - def ptop(self) -> float: + def ptop(self) -> Float: """ top of atmosphere pressure (Pa) """ if self.bk.view[0] != 0: raise ValueError("ptop is not well-defined when top-of-atmosphere bk != 0") - return float(self.ak.view[0]) + return Float(self.ak.view[0]) @dataclasses.dataclass(frozen=True) From e7e4c95e7907fda8f86d382f649d862005cdbc89 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Fri, 17 May 2024 12:52:23 -0400 Subject: [PATCH 015/154] Pull down pyFV3 & pySHiELD configuration that shouldn't be there. Add grid & layout options Remove dperiodic now "--layout=tile" Remove compute_grid now "--grid=compute" --- ndsl/stencils/testing/conftest.py | 174 ++++++++++++++++++------ ndsl/stencils/testing/test_translate.py | 6 +- 2 files changed, 138 insertions(+), 42 deletions(-) diff --git a/ndsl/stencils/testing/conftest.py b/ndsl/stencils/testing/conftest.py index d000e1fa..9bcf3414 100644 --- a/ndsl/stencils/testing/conftest.py +++ b/ndsl/stencils/testing/conftest.py @@ -7,7 +7,7 @@ import xarray as xr import yaml -import ndsl.dsl +from ndsl import CompilationConfig, StencilConfig, StencilFactory from ndsl.comm.communicator import ( Communicator, CubedSphereCommunicator, @@ -17,11 +17,87 @@ from ndsl.comm.partitioner import CubedSpherePartitioner, TilePartitioner from ndsl.dsl.dace.dace_config import DaceConfig from ndsl.namelist import Namelist +from ndsl.stencils.testing.grid import Grid # type: ignore from ndsl.stencils.testing.parallel_translate import ParallelTranslate from ndsl.stencils.testing.savepoint import SavepointCase, dataset_to_dict from ndsl.stencils.testing.translate import TranslateGrid +def pytest_addoption(parser): + """Option for the Translate Test system + + See -h or inline help for details. + """ + parser.addoption( + "--backend", + action="store", + default="numpy", + help="Backend to execute the test with, can only be one.", + ) + parser.addoption( + "--which_modules", + action="store", + help="Whitelist of modules to run. Only the part after Translate, e.g. in TranslateXYZ it'd be XYZ", + ) + parser.addoption( + "--skip_modules", + action="store", + help="Blacklist of modules to not run. Only the part after Translate, e.g. in TranslateXYZ it'd be XYZ", + ) + parser.addoption( + "--which_rank", action="store", help="Restrict test to a single rank" + ) + parser.addoption( + "--data_path", + action="store", + default="./", + help="Path of Netcdf input and outputs. Naming pattern needs to be XYZ-In and XYZ-Out for a test class named TranslateXYZ", + ) + parser.addoption( + "--threshold_overrides_file", + action="store", + default=None, + help="Path to a yaml overriding the default error threshold for a custom value.", + ) + parser.addoption( + "--print_failures", + action="store_true", + help="Print the failures detail. Default to True.", + ) + parser.addoption( + "--failure_stride", + action="store", + default=1, + help="How many indices of failures to print from worst to best. Default to 1.", + ) + parser.addoption( + "--grid", + action="store", + default="file", + help='Grid loading mode. "file" looks for "Grid-Info.nc", "compute" does the same but recomputes MetricTerms, "default" creates a simple grid with no metrics terms. Default to "file".', + ) + parser.addoption( + "--layout", + action="store", + default="cube", + help='Layout of the grid. "cube" means a 6-faced grid, "tile" means a 1 tile grid. Default to "cube".', + ) + + +def pytest_configure(config): + # register an additional marker + config.addinivalue_line( + "markers", "sequential(name): mark test as running sequentially on ranks" + ) + config.addinivalue_line( + "markers", "parallel(name): mark test as running in parallel across ranks" + ) + config.addinivalue_line( + "markers", + "mock_parallel(name): mark test as running in mock parallel across ranks", + ) + + @pytest.fixture() def data_path(pytestconfig): return data_path_and_namelist_filename_from_config(pytestconfig) @@ -109,12 +185,14 @@ def get_parallel_savepoint_names(metafunc, data_path): def get_ranks(metafunc, layout): only_rank = metafunc.config.getoption("which_rank") - dperiodic = metafunc.config.getoption("dperiodic") + layout_mode = metafunc.config.getoption("layout") if only_rank is None: - if dperiodic: + if layout_mode == "tile": total_ranks = layout[0] * layout[1] - else: + elif layout_mode == "cube": total_ranks = 6 * layout[0] * layout[1] + else: + raise NotImplementedError(f"Layout {layout_mode} is unknown.") return range(total_ranks) else: return [int(only_rank)] @@ -125,8 +203,8 @@ def get_namelist(namelist_filename): def get_config(backend: str, communicator: Optional[Communicator]): - stencil_config = ndsl.dsl.stencil.StencilConfig( - compilation_config=ndsl.dsl.stencil.CompilationConfig( + stencil_config = StencilConfig( + compilation_config=CompilationConfig( backend=backend, rebuild=False, validate_args=True ), dace_config=DaceConfig( @@ -142,8 +220,8 @@ def sequential_savepoint_cases(metafunc, data_path, namelist_filename, *, backen namelist = get_namelist(namelist_filename) stencil_config = get_config(backend, None) ranks = get_ranks(metafunc, namelist.layout) - compute_grid = metafunc.config.getoption("compute_grid") - dperiodic = metafunc.config.getoption("dperiodic") + grid_mode = metafunc.config.getoption("grid") + layout_mode = metafunc.config.getoption("layout") return _savepoint_cases( savepoint_names, ranks, @@ -151,8 +229,8 @@ def sequential_savepoint_cases(metafunc, data_path, namelist_filename, *, backen namelist, backend, data_path, - compute_grid, - dperiodic, + grid_mode, + layout_mode, ) @@ -161,25 +239,38 @@ def _savepoint_cases( ranks, stencil_config, namelist, - backend, - data_path, - compute_grid: bool, - dperiodic: bool, + backend: str, + data_path: str, + grid_mode: str, + layout_mode: bool, ): return_list = [] - ds_grid: xr.Dataset = xr.open_dataset(os.path.join(data_path, "Grid-Info.nc")).isel( - savepoint=0 - ) for rank in ranks: - grid = TranslateGrid( - dataset_to_dict(ds_grid.isel(rank=rank)), - rank=rank, - layout=namelist.layout, - backend=backend, - ).python_grid() - if compute_grid: - compute_grid_data(grid, namelist, backend, namelist.layout, dperiodic) - stencil_factory = ndsl.dsl.stencil.StencilFactory( + if grid_mode == "default": + grid = Grid._make( + namelist.npx + 1, + namelist.npy + 1, + namelist.npz, + namelist.layout, + rank, + backend, + ) + elif grid_mode == "file" or grid_mode == "compute": + ds_grid: xr.Dataset = xr.open_dataset( + os.path.join(data_path, "Grid-Info.nc") + ).isel(savepoint=0) + grid = TranslateGrid( + dataset_to_dict(ds_grid.isel(rank=rank)), + rank=rank, + layout=namelist.layout, + backend=backend, + ).python_grid() + if grid_mode == "compute": + compute_grid_data(grid, namelist, backend, namelist.layout, layout_mode) + else: + raise NotImplementedError(f"Grid mode {grid_mode} is unknown.") + + stencil_factory = StencilFactory( config=stencil_config, grid_indexing=grid.grid_indexing, ) @@ -204,12 +295,12 @@ def _savepoint_cases( return return_list -def compute_grid_data(grid, namelist, backend, layout, dperiodic): +def compute_grid_data(grid, namelist, backend, layout, layout_mode): grid.make_grid_data( npx=namelist.npx, npy=namelist.npy, npz=namelist.npz, - communicator=get_communicator(MPI.COMM_WORLD, layout, dperiodic), + communicator=get_communicator(MPI.COMM_WORLD, layout, layout_mode), backend=backend, ) @@ -218,11 +309,11 @@ def parallel_savepoint_cases( metafunc, data_path, namelist_filename, mpi_rank, *, backend: str, comm ): namelist = get_namelist(namelist_filename) - dperiodic = metafunc.config.getoption("dperiodic") - communicator = get_communicator(comm, namelist.layout, dperiodic) + layout_mode = metafunc.config.getoption("layout") + communicator = get_communicator(comm, namelist.layout, layout_mode) stencil_config = get_config(backend, communicator) savepoint_names = get_parallel_savepoint_names(metafunc, data_path) - compute_grid = metafunc.config.getoption("compute_grid") + grid_mode = metafunc.config.getoption("grid") return _savepoint_cases( savepoint_names, [mpi_rank], @@ -230,8 +321,8 @@ def parallel_savepoint_cases( namelist, backend, data_path, - compute_grid, - dperiodic, + grid_mode, + layout_mode, ) @@ -276,8 +367,8 @@ def generate_parallel_stencil_tests(metafunc, *, backend: str): ) -def get_communicator(comm, layout, dperiodic): - if (MPI.COMM_WORLD.Get_size() > 1) and (not dperiodic): +def get_communicator(comm, layout, layout_mode): + if (MPI.COMM_WORLD.Get_size() > 1) and (layout_mode == "tile"): partitioner = CubedSpherePartitioner(TilePartitioner(layout)) communicator = CubedSphereCommunicator(comm, partitioner) else: @@ -297,10 +388,15 @@ def failure_stride(pytestconfig): @pytest.fixture() -def compute_grid(pytestconfig): - return pytestconfig.getoption("compute_grid") +def grid(pytestconfig): + return pytestconfig.getoption("grid") + + +@pytest.fixture() +def layout_mode(pytestconfig): + return pytestconfig.getoption("layout_mode") @pytest.fixture() -def dperiodic(pytestconfig): - return pytestconfig.getoption("dperiodic") +def backend(pytestconfig): + return pytestconfig.getoption("backend") diff --git a/ndsl/stencils/testing/test_translate.py b/ndsl/stencils/testing/test_translate.py index 29c4ed65..3d633b53 100644 --- a/ndsl/stencils/testing/test_translate.py +++ b/ndsl/stencils/testing/test_translate.py @@ -353,7 +353,7 @@ def test_parallel_savepoint( subtests, caplog, threshold_overrides, - compute_grid, + grid, xy_indices=True, ): if MPI.COMM_WORLD.Get_size() % 6 != 0: @@ -389,8 +389,8 @@ def test_parallel_savepoint( ) if case.testobj.skip_test: return - if compute_grid and not case.testobj.compute_grid_option: - pytest.xfail(f"compute_grid option not used for test {case.savepoint_name}") + if grid and not case.testobj.compute_grid_option: + pytest.xfail(f"Grid compute option not used for test {case.savepoint_name}") input_data = dataset_to_dict(case.ds_in) # run python version of functionality output = case.testobj.compute_parallel(input_data, communicator) From 480a5745e994c1716111b3ffcffa76349af168ae Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Fri, 17 May 2024 12:52:41 -0400 Subject: [PATCH 016/154] Add serialbox to netcdf as a tool of ndsl --- ndsl/stencils/testing/serialbox_to_netcdf.py | 147 +++++++++++++++++++ setup.py | 5 + 2 files changed, 152 insertions(+) create mode 100644 ndsl/stencils/testing/serialbox_to_netcdf.py diff --git a/ndsl/stencils/testing/serialbox_to_netcdf.py b/ndsl/stencils/testing/serialbox_to_netcdf.py new file mode 100644 index 00000000..bee0a789 --- /dev/null +++ b/ndsl/stencils/testing/serialbox_to_netcdf.py @@ -0,0 +1,147 @@ +import argparse +import os +import shutil +import xarray as xr +import f90nml +import numpy as np +from typing import Optional + +try: + import serialbox +except ModuleNotFoundError: + raise ModuleNotFoundError("Serialbox couldn't be imported, make sure it's in your PYTHONPATH or you env") + + +def get_parser(): + parser = argparse.ArgumentParser("Converts Serialbox data to netcdf") + parser.add_argument( + "data_path", + type=str, + help="path of serialbox data to convert", + ) + parser.add_argument( + "output_path", type=str, help="output directory where netcdf data will be saved" + ) + parser.add_argument( + "-dn", "--data_name", type=str, help="[Optional] Give the name of the data, will default to Generator_rankX" + ) + return parser + + +def read_serialized_data(serializer, savepoint, variable): + data = serializer.read(variable, savepoint) + if len(data.flatten()) == 1: + return data[0] + data[data == 1e40] = 0.0 + return data + + +def get_all_savepoint_names(serializer): + savepoint_names = set() + for savepoint in serializer.savepoint_list(): + savepoint_names.add(savepoint.name) + return savepoint_names + + +def get_serializer(data_path: str, rank:int , data_name:Optional[str] = None): + if data_name: + name = data_name + else: + name = f"Generator_rank{rank}" + return serialbox.Serializer(serialbox.OpenModeKind.Read, data_path, name) + + +def main(data_path: str, output_path: str, data_name: Optional[str] = None): + os.makedirs(output_path, exist_ok=True) + namelist_filename_in = os.path.join(data_path, "input.nml") + + if not os.path.exists(namelist_filename_in): + raise FileNotFoundError(f"Can't find input.nml in {data_path}. Required.") + + namelist_filename_out = os.path.join(output_path, "input.nml") + if namelist_filename_out != namelist_filename_in: + shutil.copyfile(os.path.join(data_path, "input.nml"), namelist_filename_out) + namelist = f90nml.read(namelist_filename_out) + total_ranks = ( + 6 * namelist["fv_core_nml"]["layout"][0] * namelist["fv_core_nml"]["layout"][1] + ) + + # all ranks have the same names, just look at first one + serializer_0 = get_serializer(data_path, rank=0, data_name=data_name) + + savepoint_names = get_all_savepoint_names(serializer_0) + for savepoint_name in sorted(list(savepoint_names)): + rank_list = [] + names_list = list( + serializer_0.fields_at_savepoint(serializer_0.get_savepoint(savepoint_name)[0]) + ) + serializer_list = [] + for rank in range(total_ranks): + serializer = get_serializer(data_path, rank, data_name) + serializer_list.append(serializer) + savepoints = serializer.get_savepoint(savepoint_name) + rank_data = {} + for name in set(names_list): + rank_data[name] = [] + for savepoint in savepoints: + rank_data[name].append( + read_serialized_data(serializer, savepoint, name) + ) + rank_list.append(rank_data) + n_savepoints = len(savepoints) # checking from last rank is fine + data_vars = {} + if n_savepoints > 0: + encoding = {} + for varname in set(names_list).difference(["rank"]): + data_shape = list(rank_list[0][varname][0].shape) + if savepoint_name in ["FVDynamics-In", "FVDynamics-Out", "Driver-In", "Driver-Out"]: + if varname in [ + "qvapor", + "qliquid", + "qice", + "qrain", + "qsnow", + "qgraupel", + "qo3mr", + "qsgs_tke", + ]: + data_vars[varname] = get_data( + data_shape, total_ranks, n_savepoints, rank_list, varname + )[:, :, 3:-3, 3:-3, :] + else: + data_vars[varname] = get_data( + data_shape, total_ranks, n_savepoints, rank_list, varname + ) + else: + data_vars[varname] = get_data( + data_shape, total_ranks, n_savepoints, rank_list, varname + ) + if len(data_shape) > 2: + encoding[varname] = {"zlib": True, "complevel": 1} + dataset = xr.Dataset(data_vars=data_vars) + dataset.to_netcdf( + os.path.join(output_path, f"{savepoint_name}.nc"), encoding=encoding + ) + + +def get_data(data_shape, total_ranks, n_savepoints, output_list, varname): + array = np.full([n_savepoints, total_ranks] + data_shape, fill_value=np.nan) + dims = ["savepoint", "rank"] + [ + f"dim_{varname}_{i}" for i in range(len(data_shape)) + ] + data = xr.DataArray(array, dims=dims) + for rank in range(total_ranks): + for i_savepoint in range(n_savepoints): + if len(data_shape) > 0: + data[i_savepoint, rank, :] = output_list[rank][varname][i_savepoint] + else: + data[i_savepoint, rank] = output_list[rank][varname][i_savepoint] + return data + +def entry_point(): + parser = get_parser() + args = parser.parse_args() + main(data_path=args.data_path, output_path=args.output_path, data_name=args.data_name) + +if __name__ == "__main__": + entry_point() \ No newline at end of file diff --git a/setup.py b/setup.py index 7466a814..7103703b 100644 --- a/setup.py +++ b/setup.py @@ -52,4 +52,9 @@ def local_pkg(name: str, relative_path: str) -> str: url="https://github.com/NOAA-GFDL/NDSL", version="2024.04.00", zip_safe=False, + entry_points={ + "console_scripts": [ + "ndsl-serialbox_to_netcdf = ndsl.stencils.testing.serialbox_to_netcdf:entry_point", + ] + }, ) From 2bfdf47b19f28763ebd33f4ff7723a792c53a726 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Fri, 17 May 2024 13:04:57 -0400 Subject: [PATCH 017/154] Linting --- ndsl/stencils/testing/serialbox_to_netcdf.py | 38 ++++++++++++++------ 1 file changed, 28 insertions(+), 10 deletions(-) diff --git a/ndsl/stencils/testing/serialbox_to_netcdf.py b/ndsl/stencils/testing/serialbox_to_netcdf.py index bee0a789..453a861b 100644 --- a/ndsl/stencils/testing/serialbox_to_netcdf.py +++ b/ndsl/stencils/testing/serialbox_to_netcdf.py @@ -1,15 +1,19 @@ import argparse import os import shutil -import xarray as xr +from typing import Any, Dict, Optional + import f90nml import numpy as np -from typing import Optional +import xarray as xr + try: import serialbox except ModuleNotFoundError: - raise ModuleNotFoundError("Serialbox couldn't be imported, make sure it's in your PYTHONPATH or you env") + raise ModuleNotFoundError( + "Serialbox couldn't be imported, make sure it's in your PYTHONPATH or you env" + ) def get_parser(): @@ -23,7 +27,10 @@ def get_parser(): "output_path", type=str, help="output directory where netcdf data will be saved" ) parser.add_argument( - "-dn", "--data_name", type=str, help="[Optional] Give the name of the data, will default to Generator_rankX" + "-dn", + "--data_name", + type=str, + help="[Optional] Give the name of the data, will default to Generator_rankX", ) return parser @@ -43,7 +50,7 @@ def get_all_savepoint_names(serializer): return savepoint_names -def get_serializer(data_path: str, rank:int , data_name:Optional[str] = None): +def get_serializer(data_path: str, rank: int, data_name: Optional[str] = None): if data_name: name = data_name else: @@ -73,14 +80,16 @@ def main(data_path: str, output_path: str, data_name: Optional[str] = None): for savepoint_name in sorted(list(savepoint_names)): rank_list = [] names_list = list( - serializer_0.fields_at_savepoint(serializer_0.get_savepoint(savepoint_name)[0]) + serializer_0.fields_at_savepoint( + serializer_0.get_savepoint(savepoint_name)[0] + ) ) serializer_list = [] for rank in range(total_ranks): serializer = get_serializer(data_path, rank, data_name) serializer_list.append(serializer) savepoints = serializer.get_savepoint(savepoint_name) - rank_data = {} + rank_data: Dict[str, Any] = {} for name in set(names_list): rank_data[name] = [] for savepoint in savepoints: @@ -94,7 +103,12 @@ def main(data_path: str, output_path: str, data_name: Optional[str] = None): encoding = {} for varname in set(names_list).difference(["rank"]): data_shape = list(rank_list[0][varname][0].shape) - if savepoint_name in ["FVDynamics-In", "FVDynamics-Out", "Driver-In", "Driver-Out"]: + if savepoint_name in [ + "FVDynamics-In", + "FVDynamics-Out", + "Driver-In", + "Driver-Out", + ]: if varname in [ "qvapor", "qliquid", @@ -138,10 +152,14 @@ def get_data(data_shape, total_ranks, n_savepoints, output_list, varname): data[i_savepoint, rank] = output_list[rank][varname][i_savepoint] return data + def entry_point(): parser = get_parser() args = parser.parse_args() - main(data_path=args.data_path, output_path=args.output_path, data_name=args.data_name) + main( + data_path=args.data_path, output_path=args.output_path, data_name=args.data_name + ) + if __name__ == "__main__": - entry_point() \ No newline at end of file + entry_point() From 7474861f88103c56f918cbc231e44f606dfb2005 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Fri, 17 May 2024 13:59:14 -0400 Subject: [PATCH 018/154] Rename --layout to --topology --- ndsl/stencils/testing/conftest.py | 40 +++++++++++++++---------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/ndsl/stencils/testing/conftest.py b/ndsl/stencils/testing/conftest.py index 9bcf3414..d629507d 100644 --- a/ndsl/stencils/testing/conftest.py +++ b/ndsl/stencils/testing/conftest.py @@ -77,10 +77,10 @@ def pytest_addoption(parser): help='Grid loading mode. "file" looks for "Grid-Info.nc", "compute" does the same but recomputes MetricTerms, "default" creates a simple grid with no metrics terms. Default to "file".', ) parser.addoption( - "--layout", + "--topology", action="store", - default="cube", - help='Layout of the grid. "cube" means a 6-faced grid, "tile" means a 1 tile grid. Default to "cube".', + default="cube-sphere", + help='Topology of the grid. "cube-sphere" means a 6-faced grid, "doubly-periodic" means a 1 tile grid. Default to "cube-sphere".', ) @@ -185,14 +185,14 @@ def get_parallel_savepoint_names(metafunc, data_path): def get_ranks(metafunc, layout): only_rank = metafunc.config.getoption("which_rank") - layout_mode = metafunc.config.getoption("layout") + topology = metafunc.config.getoption("topology") if only_rank is None: - if layout_mode == "tile": + if topology == "doubly-periodic": total_ranks = layout[0] * layout[1] - elif layout_mode == "cube": + elif topology == "cube-sphere": total_ranks = 6 * layout[0] * layout[1] else: - raise NotImplementedError(f"Layout {layout_mode} is unknown.") + raise NotImplementedError(f"Topology {topology} is unknown.") return range(total_ranks) else: return [int(only_rank)] @@ -221,7 +221,7 @@ def sequential_savepoint_cases(metafunc, data_path, namelist_filename, *, backen stencil_config = get_config(backend, None) ranks = get_ranks(metafunc, namelist.layout) grid_mode = metafunc.config.getoption("grid") - layout_mode = metafunc.config.getoption("layout") + topology_mode = metafunc.config.getoption("topology") return _savepoint_cases( savepoint_names, ranks, @@ -230,7 +230,7 @@ def sequential_savepoint_cases(metafunc, data_path, namelist_filename, *, backen backend, data_path, grid_mode, - layout_mode, + topology_mode, ) @@ -242,7 +242,7 @@ def _savepoint_cases( backend: str, data_path: str, grid_mode: str, - layout_mode: bool, + topology_mode: bool, ): return_list = [] for rank in ranks: @@ -266,7 +266,7 @@ def _savepoint_cases( backend=backend, ).python_grid() if grid_mode == "compute": - compute_grid_data(grid, namelist, backend, namelist.layout, layout_mode) + compute_grid_data(grid, namelist, backend, namelist.layout, topology_mode) else: raise NotImplementedError(f"Grid mode {grid_mode} is unknown.") @@ -295,12 +295,12 @@ def _savepoint_cases( return return_list -def compute_grid_data(grid, namelist, backend, layout, layout_mode): +def compute_grid_data(grid, namelist, backend, layout, topology_mode): grid.make_grid_data( npx=namelist.npx, npy=namelist.npy, npz=namelist.npz, - communicator=get_communicator(MPI.COMM_WORLD, layout, layout_mode), + communicator=get_communicator(MPI.COMM_WORLD, layout, topology_mode), backend=backend, ) @@ -309,8 +309,8 @@ def parallel_savepoint_cases( metafunc, data_path, namelist_filename, mpi_rank, *, backend: str, comm ): namelist = get_namelist(namelist_filename) - layout_mode = metafunc.config.getoption("layout") - communicator = get_communicator(comm, namelist.layout, layout_mode) + topology_mode = metafunc.config.getoption("topology") + communicator = get_communicator(comm, namelist.layout, topology_mode) stencil_config = get_config(backend, communicator) savepoint_names = get_parallel_savepoint_names(metafunc, data_path) grid_mode = metafunc.config.getoption("grid") @@ -322,7 +322,7 @@ def parallel_savepoint_cases( backend, data_path, grid_mode, - layout_mode, + topology_mode, ) @@ -367,8 +367,8 @@ def generate_parallel_stencil_tests(metafunc, *, backend: str): ) -def get_communicator(comm, layout, layout_mode): - if (MPI.COMM_WORLD.Get_size() > 1) and (layout_mode == "tile"): +def get_communicator(comm, layout, topology_mode): + if (MPI.COMM_WORLD.Get_size() > 1) and (topology_mode == "doubly-periodic"): partitioner = CubedSpherePartitioner(TilePartitioner(layout)) communicator = CubedSphereCommunicator(comm, partitioner) else: @@ -393,8 +393,8 @@ def grid(pytestconfig): @pytest.fixture() -def layout_mode(pytestconfig): - return pytestconfig.getoption("layout_mode") +def topology_mode(pytestconfig): + return pytestconfig.getoption("topology_mode") @pytest.fixture() From 1b3e415ddcba984b01b68eca68a1c8be8c97d9af Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Fri, 17 May 2024 14:05:05 -0400 Subject: [PATCH 019/154] lint --- ndsl/stencils/testing/conftest.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ndsl/stencils/testing/conftest.py b/ndsl/stencils/testing/conftest.py index d629507d..f23f385d 100644 --- a/ndsl/stencils/testing/conftest.py +++ b/ndsl/stencils/testing/conftest.py @@ -266,7 +266,9 @@ def _savepoint_cases( backend=backend, ).python_grid() if grid_mode == "compute": - compute_grid_data(grid, namelist, backend, namelist.layout, topology_mode) + compute_grid_data( + grid, namelist, backend, namelist.layout, topology_mode + ) else: raise NotImplementedError(f"Grid mode {grid_mode} is unknown.") From b168c94c796a7f2718cc9a729e36d9327d58568d Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Fri, 17 May 2024 22:25:37 -0400 Subject: [PATCH 020/154] Updating gt4py --- external/gt4py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/external/gt4py b/external/gt4py index c89bd818..d49086e5 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit c89bd8189f232fcb2ee1cc96a5b4dc9ae7636491 +Subproject commit d49086e56019964bccf08e211a1bcad0a175074b From 1a938f26c17cbc93b557539035f2802f5631516b Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Fri, 17 May 2024 22:42:24 -0400 Subject: [PATCH 021/154] Testing for pyFV3 --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 7466a814..3958a501 100644 --- a/setup.py +++ b/setup.py @@ -50,6 +50,6 @@ def local_pkg(name: str, relative_path: str) -> str: packages=find_namespace_packages(include=["ndsl", "ndsl.*"]), include_package_data=True, url="https://github.com/NOAA-GFDL/NDSL", - version="2024.04.00", + version="2024.04.02", zip_safe=False, ) From 0f8906b084bba1bb3774ae0ac1c9f9bb647aa385 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Mon, 20 May 2024 09:55:41 -0400 Subject: [PATCH 022/154] Adjust naming & verbose choice for private generic function --- ndsl/boilerplate.py | 65 ++++++++++++++++++++++++--------------- tests/test_boilerplate.py | 8 ++--- 2 files changed, 45 insertions(+), 28 deletions(-) diff --git a/ndsl/boilerplate.py b/ndsl/boilerplate.py index d2b0cb96..a07a476e 100644 --- a/ndsl/boilerplate.py +++ b/ndsl/boilerplate.py @@ -4,9 +4,12 @@ from ndsl import ( CompilationConfig, + CubedSphereCommunicator, + CubedSpherePartitioner, DaceConfig, DaCeOrchestration, GridIndexing, + LocalComm, NullComm, QuantityFactory, RunMode, @@ -18,12 +21,22 @@ ) -def _get_one_tile_factory( - nx, ny, nz, nhalo, backend, orchestration +def _get_factories( + nx: int, + ny: int, + nz: int, + nhalo, + backend: str, + orchestration: DaCeOrchestration, + topology: str, ) -> Tuple[StencilFactory, QuantityFactory]: - """Build a Stencil & Quantity factory for: - - one tile - - no MPI communicator + """Build a Stencil & Quantity factory for a combination of options. + + Dev Note: We don't expose this function because we want the boilerplate to remain + as easy and self describing as possible. It should be a very easy call to make. + The other reason is that the orchestration requires two inputs instead of change + a backend name for now, making it confusing. Until refactor, we choose to hide this + pattern for boilerplate use. """ dace_config = DaceConfig( communicator=None, @@ -47,49 +60,53 @@ def _get_one_tile_factory( dace_config=dace_config, ) - partitioner = TilePartitioner((1, 1)) - sizer = SubtileGridSizer.from_tile_params( - nx_tile=nx, - ny_tile=ny, - nz=nz, - n_halo=nhalo, - extra_dim_lengths={}, - layout=partitioner.layout, - tile_partitioner=partitioner, - ) - - tile_comm = TileCommunicator(comm=NullComm(0, 1, 42), partitioner=partitioner) + if topology == "tile": + partitioner = TilePartitioner((1, 1)) + sizer = SubtileGridSizer.from_tile_params( + nx_tile=nx, + ny_tile=ny, + nz=nz, + n_halo=nhalo, + extra_dim_lengths={}, + layout=partitioner.layout, + tile_partitioner=partitioner, + ) + comm = TileCommunicator(comm=NullComm(0, 1, 42), partitioner=partitioner) + else: + raise NotImplementedError(f"Topology {topology} is not implemented.") - grid_indexing = GridIndexing.from_sizer_and_communicator(sizer, tile_comm) + grid_indexing = GridIndexing.from_sizer_and_communicator(sizer, comm) stencil_factory = StencilFactory(config=stencil_config, grid_indexing=grid_indexing) quantity_factory = QuantityFactory(sizer, np) return stencil_factory, quantity_factory -def get_one_tile_factory_orchestrated_cpu( +def get_factories_single_tile_orchestrated_cpu( nx, ny, nz, nhalo ) -> Tuple[StencilFactory, QuantityFactory]: - """Build a Stencil & Quantity factory for orchestrated CPU""" - return _get_one_tile_factory( + """Build a Stencil & Quantity factory for orchestrated CPU, on a single tile toplogy.""" + return _get_factories( nx=nx, ny=ny, nz=nz, nhalo=nhalo, backend="dace:cpu", orchestration=DaCeOrchestration.BuildAndRun, + topology="tile", ) -def get_one_tile_factory_numpy( +def get_factories_single_tile_numpy( nx, ny, nz, nhalo ) -> Tuple[StencilFactory, QuantityFactory]: - """Build a Stencil & Quantity factory for Numpy""" - return _get_one_tile_factory( + """Build a Stencil & Quantity factory for Numpy, on a single tile toplogy.""" + return _get_factories( nx=nx, ny=ny, nz=nz, nhalo=nhalo, backend="numpy", orchestration=DaCeOrchestration.Python, + topology="tile", ) diff --git a/tests/test_boilerplate.py b/tests/test_boilerplate.py index 983a8d07..a8de4075 100644 --- a/tests/test_boilerplate.py +++ b/tests/test_boilerplate.py @@ -35,10 +35,10 @@ def test_boilerplate_import_numpy(): Dev Note: the import inside the function are part of the test. """ - from ndsl.boilerplate import get_one_tile_factory_numpy + from ndsl.boilerplate import get_factories_single_tile_numpy # Boilerplate - stencil_factory, quantity_factory = get_one_tile_factory_numpy( + stencil_factory, quantity_factory = get_factories_single_tile_numpy( nx=5, ny=5, nz=2, nhalo=1 ) @@ -50,10 +50,10 @@ def test_boilerplate_import_orchestrated_cpu(): Dev Note: the import inside the function are part of the test. """ - from ndsl.boilerplate import get_one_tile_factory_orchestrated_cpu + from ndsl.boilerplate import get_factories_single_tile_orchestrated_cpu # Boilerplate - stencil_factory, quantity_factory = get_one_tile_factory_orchestrated_cpu( + stencil_factory, quantity_factory = get_factories_single_tile_orchestrated_cpu( nx=5, ny=5, nz=2, nhalo=1 ) From 0789fc0151fc2239603560a31d1ea02dca91528f Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Mon, 20 May 2024 10:01:21 -0400 Subject: [PATCH 023/154] Lint --- ndsl/boilerplate.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/ndsl/boilerplate.py b/ndsl/boilerplate.py index a07a476e..ced15115 100644 --- a/ndsl/boilerplate.py +++ b/ndsl/boilerplate.py @@ -4,12 +4,9 @@ from ndsl import ( CompilationConfig, - CubedSphereCommunicator, - CubedSpherePartitioner, DaceConfig, DaCeOrchestration, GridIndexing, - LocalComm, NullComm, QuantityFactory, RunMode, From 8bfa5e1417a1e30ed5c6168042276e3ca811d75e Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Mon, 20 May 2024 13:22:41 -0400 Subject: [PATCH 024/154] Updated gt4py to latest version --- external/gt4py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/external/gt4py b/external/gt4py index 2f5799eb..d49086e5 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit 2f5799ebcb49314f9bf40932c797f7acb85b4c67 +Subproject commit d49086e56019964bccf08e211a1bcad0a175074b From b87f8132f4f9d99731dda5fc7295ae84a03ecd52 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Mon, 20 May 2024 13:40:12 -0400 Subject: [PATCH 025/154] Updated setup.py to reflect actual version number --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 4eaf99a7..ce6fb6f3 100644 --- a/setup.py +++ b/setup.py @@ -50,6 +50,6 @@ def local_pkg(name: str, relative_path: str) -> str: packages=find_namespace_packages(include=["ndsl", "ndsl.*"]), include_package_data=True, url="https://github.com/NOAA-GFDL/NDSL", - version="2024.04.02", + version="2024.04.00", zip_safe=False, ) From f47b2b95659c9c403c15fddbcfd713787ab808d2 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Tue, 21 May 2024 11:59:01 -0400 Subject: [PATCH 026/154] Updating gt4py --- external/gt4py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/external/gt4py b/external/gt4py index d49086e5..32dde792 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit d49086e56019964bccf08e211a1bcad0a175074b +Subproject commit 32dde792bde505807a5729261e4f1d12a1451bdb From 2aef448aabfb75acbc41d1a74c6e0a509d812ef1 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 30 May 2024 16:53:05 -0400 Subject: [PATCH 027/154] Removed commented Float import in ndsl/quantity.py --- ndsl/quantity.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ndsl/quantity.py b/ndsl/quantity.py index 6e7e25b4..178df991 100644 --- a/ndsl/quantity.py +++ b/ndsl/quantity.py @@ -300,7 +300,6 @@ def __init__( """ # ToDo: [Florian 01/23] Kill the abomination. # See https://github.com/NOAA-GFDL/pace/issues/3 - # from ndsl.dsl.typing import Float if ( not allow_mismatch_float_precision From 1617e9f7687ad0c9e7d31dd116554fde75718c18 Mon Sep 17 00:00:00 2001 From: Christopher Kung Date: Fri, 31 May 2024 10:50:39 -0400 Subject: [PATCH 028/154] Readding tutorial notebooks based off NDSL develop branch --- examples/NDSL/01_gt4py_basics.ipynb | 1278 +++++++++++++++++++ examples/NDSL/02_NDSL_basics.ipynb | 492 +++++++ examples/NDSL/03_orchestration_basics.ipynb | 214 ++++ examples/NDSL/basic_boilerplate.py | 72 ++ examples/NDSL/orch_boilerplate.py | 63 + 5 files changed, 2119 insertions(+) create mode 100755 examples/NDSL/01_gt4py_basics.ipynb create mode 100644 examples/NDSL/02_NDSL_basics.ipynb create mode 100644 examples/NDSL/03_orchestration_basics.ipynb create mode 100755 examples/NDSL/basic_boilerplate.py create mode 100644 examples/NDSL/orch_boilerplate.py diff --git a/examples/NDSL/01_gt4py_basics.ipynb b/examples/NDSL/01_gt4py_basics.ipynb new file mode 100755 index 00000000..4d2497ac --- /dev/null +++ b/examples/NDSL/01_gt4py_basics.ipynb @@ -0,0 +1,1278 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# **GT4Py Tutorial : Stencil Basics**\n", + "\n", + "## **Introduction**\n", + "\n", + "This notebook will show how to create a simple GT4Py stencil that copies data from one variable to another.\n", + "\n", + "### **Notebook Requirements**\n", + "\n", + "- Python v3.11.x to v3.12.x\n", + "- [NOAA/NASA Domain Specific Language Middleware](https://github.com/NOAA-GFDL/NDSL)\n", + "- `ipykernel==6.1.0`\n", + "- [`ipython_genutils`](https://pypi.org/project/ipython_genutils/)\n", + "\n", + "### **Quick GT4Py (Cartesian version) Overview**\n", + "\n", + "GT4Py is a Domain Specific Language (DSL) in Python that enables a developer to write stencil computations. Compared to simply running under Python, GT4Py achieves performance when the Python code is translated and compiled into a lower level language such as C++ and CUDA, which enables the codebase to execute on a multitude of architectures. In this notebook, we will cover the basics of creating GT4Py stencils and demonstrate several intracies of the DSL. Additional information about GT4Py can be found at the [GT4Py site](https://gridtools.github.io/gt4py/latest/index.html). One small note is that this tutorial covers and uses the Cartesian version of GT4Py and not the unstructured version.\n", + "\n", + "### **GT4Py Parallel/Execution Model**\n", + "\n", + "Within a 3-dimensional domain, GT4Py considers computations in two parts. If we assume an `(I,J,K)` coordinate system as a reference, GT4Py separates computations in the Horizontal (`IJ`) spatial plane and Vertical (`K`) spatial interval. In the Horizontal spatial plane, computations are implicitly executed in parallel, which also means that there is no assumed calculation order within the plane. In the Vertical spatial interval, comptuations are specified by an iteration policy that will be discussed later through examples.\n", + "\n", + "Another quick note is that the computations are executed sequentially in the order they appear in code.\n", + "\n", + "## **Tutorial**\n", + "\n", + "### **Copy Stencil example**\n", + "\n", + "To demonstrate how to implement a GT4Py stencil, we'll step through an example that copies the values of one array into another array. First, we import several packages. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-05-28 15:40:01|INFO|rank 0|ndsl.logging:Constant selected: ConstantVersions.GFS\n" + ] + } + ], + "source": [ + "from gt4py.cartesian.gtscript import PARALLEL, computation, interval, stencil\n", + "from ndsl.dsl.typing import FloatField\n", + "from ndsl.quantity import Quantity\n", + "import numpy as np\n", + "from basic_boilerplate import plot_field_at_k0, plot_field_at_kN" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we walk through the example, we'll highlight different terms and such from the imported packages. Let's first define, in GT4Py terms, two arrays of size 5 by 5 by 2 (dimensionally `I` by `J` by `K`). These arrays are defined using a `Quantity` object, an NDSL data container for physical quantities. More detailed information about the `Quantity` object and its arguments can be found from the [`Quantity` docstring](https://github.com/NOAA-GFDL/NDSL/blob/develop/ndsl/quantity.py#L270). To make debugging easier, the `numpy` backend will be used." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "backend = 'numpy'\n", + "\n", + "nx = 5\n", + "ny = 5\n", + "nz = 2\n", + "\n", + "shape = (nx, ny, nz)\n", + "\n", + "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "arr = np.indices(shape,dtype=float).sum(axis=0) # Value of each entry is sum of the I and J index at each point\n", + "\n", + "qty_in = Quantity(data=arr,\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will next create a simple GT4Py stencil that copies values from one input to another. A stencil will look like a Python subroutine or function except that it uses specific GT4Py functionalities." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "@stencil(backend=backend)\n", + "def copy_stencil(input_field: FloatField,\n", + " output_field: FloatField):\n", + " with computation(PARALLEL), interval(...):\n", + " output_field = input_field" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As mentioned before, GT4Py (cartesian version) was designed for stencil-based computation. Since stencil calculations generally are localized computations, GT4Py stencils are written using variables and the variable's relative location if it's an array. If there are no indices in brackets next to a GT4Py type (such as `FloatField`), it's implied to be at the [0] (for 1-dimension), [0,0] (for 2-dimension), or [0,0,0] (for 3-dimension) location. For the simple example `copy_stencil`, the value of `input_field` simply gets copied to `output_field` at every point in the domain of interest.\n", + "\n", + "We see that this stencil does not contain any explicit loops. As mentioned above in the notebook, GT4Py has a particular computation policy that implicitly executes in parallel within an `IJ` plane and is user defined in the `K` interval. This execution policy in the `K` interval is dictated by the `computation` and `interval` keywords. \n", + "\n", + "- `with computation(PARALLEL)` means that there's no order preference to executing the `K` interval. This also means that the `K` interval can be computed in parallel to potentially gain performace if computational resources are available.\n", + "\n", + "- `interval(...)` means that the entire `K` interval is executed. Instead of `(...)`, more specific intervals can be specified using a tuple of two integers. For example... \n", + "\n", + " - `interval(0,2)` : The interval `K` = 0 to 1 is executed.\n", + " - `interval(0,-1)` : The interval `K` = 0 to N-2 (where N is the size of `K`) is executed.\n", + "\n", + "The decorator `@stencil(backend=backend)` (Note: `stencil` comes from the package `gt4py.cartesian.gtscript`) converts `copy_stencil` to use the specified `backend` to \"compile\" the stencil. `stencil` can also be a function call to create a stencil object." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "copy_stencil_numpy = stencil(backend=\"numpy\", definition=copy_stencil)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the input and output parameters to `copy_stencil` are of type `FloatField`, which can essentially be thought of as a 3-dimensional NumPy array of `float` types.\n", + "\n", + "`plot_field_at_kN` plots the values within the `IJ` plane at `K = 0` if no integer is specified or at `K` equal to the integer that is specified as an argument. As we can see in the plots below, `copy_stencil` copies the values from `qty_in` into `qty_out`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_in at K = 0\n", + "Min and max values: 8.0 0.0\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAHHCAYAAACbaKDRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAo00lEQVR4nO3df3xV9X3H8fdNgJtAcgNBAmQkQLXCAIP8iCylBZQfLo/AZFudczhD2JyriZpmrpqtRWDV4KOPUdiIgfqw4Kx5gFqBDkGG2pAHXalJMCu4SqGleLVAaFfzS7ngvWd/YG6JCXDuPTf3nJvzej4e3z/uyf2e8yE+8MPn8/2eczyGYRgCAACOk2R3AAAAoHckaQAAHIokDQCAQ5GkAQBwKJI0AAAORZIGAMChSNIAADgUSRoAAIciSQMA4FAkabhaXV2dPB6P6urq7A4FAHogSaNf2rp1qzweT3ikpKToxhtvVFlZmc6ePRuTa+zZs0erVq2KybkuV1tbq/Xr15v+/rhx47R48eIex59//nklJyfrj//4j3X+/PkYRnh1H3zwgf7iL/5CQ4cOlc/n0x133KFf/vKXcbs+0J8MsDsAoC+tWbNG48eP1/nz53Xw4EHV1NRoz549Onr0qAYPHmzp3Hv27FF1dXXME3Vtba2OHj2q8vLyqM/xwgsvaPny5VqwYIF27typlJSU2AV4FR0dHbr11lvV2tqqf/qnf9LAgQP17W9/W3PnzlVzc7OGDx8elziA/oIkjX6tsLBQM2fOlCT97d/+rYYPH65169Zp165duvvuu22Orm9s27ZNxcXFuu2227Rr1664JWhJevrpp3X8+HG99dZbys/Pl3Tpv8GUKVP0r//6r3ryySfjFgvQH9DuhqvcdtttkqSTJ09e9XsvvfSSZsyYodTUVF133XW655579MEHH4R/vnz5clVXV0tSt7b61ezatUtFRUXKzs6W1+vV9ddfr3/5l39RMBgMf2fevHl69dVXderUqfA5x40bZ/rP9+KLL+qee+7RvHnz9IMf/CCuCVqSXn75ZeXn54cTtCRNnDhR8+fP14svvhjXWID+gEoarvKLX/xCkq7adt26datKSkqUn5+vqqoqnT17Vhs2bNCPfvQjvf322xo6dKjuv/9+/frXv9b+/fv1/PPPm7r21q1blZaWpoqKCqWlpenNN9/UypUr1dbWpm9961uSpH/+539Wa2ur3n//fX3729+WJKWlpZk6//e//30tW7ZMc+bM0X/+538qNTXV1LyOjg5Ta9YDBw5URkbGFX8eCoX005/+VCtWrOjxs1tuuUX/9V//pfb2dqWnp5uKC4AkA+iHtmzZYkgyXn/9dePcuXOG3+83tm3bZgwfPtxITU013n//fcMwDOOHP/yhIcn44Q9/aBiGYVy4cMHIysoypkyZYnz88cfh8+3evduQZKxcuTJ8rLS01Ijkr9BHH33U49j9999vDB482Dh//nz4WFFRkTF27FjT5x07dqyRnZ1tDBgwwJg3b57R2dlpeq5hGEZxcbEh6Zpj7ty5Vz3PuXPnDEnGmjVrevysurrakGS8++67EcUGuB2VNPq1BQsWdPs8duxYvfDCC/qDP/iDXr/f2NiolpYWrVq1qluruKioSBMnTtSrr76q1atXRxXL5ZVte3u7AoGAvvSlL2nz5s169913NXXq1KjOK0n/93//p08++URjxowxXUF3+drXvqZ77rnnmt8bNmzYVX/+8ccfS5K8Xm+Pn3X9Lru+A8AckjT6terqat14440aMGCARo4cqQkTJigp6cpbMU6dOiVJmjBhQo+fTZw4UQcPHow6lnfeeUdf//rX9eabb6qtra3bz1pbW6M+ryTNnz9fubm5qqmpUWZmpjZs2GB67qRJkzRp0iRL15d+/4+QQCDQ42dd7fRI/wEBuB1JGv3aLbfcEt7dbacPP/xQc+fOlc/n05o1a3T99dcrJSVFhw8f1qOPPqpQKGT5Ghs3btTvfvc7/du//ZuGDRtm+taw1tZWUxXuoEGDlJmZecWfZ2Zmyuv16vTp0z1+1nUsOzvbVEwALiFJA5cZO3asJOnYsWPhneBdjh07Fv65pGvu5r5cXV2dfvvb3+qVV17RnDlzwsd722UeyXkvl5SUpP/4j/9Qa2urVq9erczMTD300EPXnPfwww/rueeeu+b35s6de9UnsyUlJemmm25SY2Njj5/95Cc/0ec+9zk2jQERIkkDl5k5c6aysrK0adMmrVixIry+unfvXv3sZz/TypUrw98dMmSIpEtV8tChQ6963uTkZEmSYRjhYxcuXNDTTz/d47tDhgyJuv09cOBAvfzyy1q0aJHKy8s1bNgw/fVf//VV58RqTVqSvvzlL+uxxx5TY2NjuINx7Ngxvfnmm3rkkUfM/SEAhJGkgcsMHDhQTz31lEpKSjR37lzdfffd4Vuwxo0bp69+9avh786YMUOS9NBDD+n2229XcnKy/vIv/7LX837hC1/QsGHDVFxcrIceekgej0fPP/98t6R9+Xm3b9+uiooK5efnKy0tTUuWLDH9Zxg8eLBeffVVzZ07VytWrFBGRob+5E/+5Irfj9WatCQ98MADeuaZZ1RUVKRHHnlEAwcO1Lp16zRy5Ej9wz/8Q0yuAbiK3dvLgb7QdQtWQ0PDVb/32Vuwumzfvt2YNm2a4fV6jczMTGPZsmXh27a6fPLJJ8aDDz5ojBgxwvB4PNe8HetHP/qR8Ud/9EdGamqqkZ2dbXzta18z9u3b1+P6HR0dxl/91V8ZQ4cONSRd83assWPHGkVFRT2OnzlzxrjhhhuMlJSUHn++vuT3+40vf/nLhs/nM9LS0ozFixcbx48fj9v1gf7EYxi9/FMeAADYjseCAgDgUCRpAAAciiQNAIBDkaQBAOgDwWBQ3/jGNzR+/HilpqaG33wXyVYwbsECAKAPPPXUU6qpqdFzzz2nyZMnq7GxUSUlJcrIyDD1oCFJYnc3AAB9YPHixRo5cqSeffbZ8LE///M/V2pqqr73ve+ZOkdCV9KhUEi//vWvlZ6eHvWjFAEA9jEMQ+3t7crOzr7qy2+sOn/+vC5cuGD5PIZh9Mg3Xq+317e/feELX9B3vvMd/fznP9eNN96o//mf/9HBgwe1bt26iC6YsPx+v6n34DIYDAbD2cPv9/dZrvj444+NUVnJMYkzLS2tx7HHH3+81+sGg0Hj0UcfNTwejzFgwADD4/EYTz75ZESxJ3Ql3fWw/jGrvq6ky979i568YzrsDiEhzBjttzuEhFCU+VO7Q0gIi4d02h2C47V1hDR2+q/69OUrFy5c0JmWoE41jZMvPfpqva09pLEzfiW/3y+fzxc+3lsVLUkvvviiXnjhBdXW1mry5Mlqbm5WeXm5srOzVVxcbOqaCZ2ku1oOSSkpJOlrSB580e4QEsKgtEF2h5AQBqcn2x1CQvAN4QYas+KxZJmW7lFaevTXCenSXJ/P1y1JX8k//uM/6rHHHgs/0/+mm27SqVOnVFVV5Y4kDQCAWUEjpKBhbX4kPvroox7r7MnJyRG9P54kDQBwhZAMhRR9lo507pIlS/TEE08oNzdXkydP1ttvv61169ZpxYoVps9BkgYAoA/8+7//u77xjW/ogQceUEtLi7Kzs3X//fd3ey/9tZCkAQCuEFJIkTWse86PRHp6utavX6/169dHfU2SNADAFYKGoaCF53dZmRstth4CAOBQVNIAAFeI98axWCBJAwBcISRDwQRL0rS7AQBwKCppAIAr0O4GAMCh2N0NAABihkoaAOAKoU+HlfnxRpIGALhC0OLubitzo0WSBgC4QtCQxbdgxS4Ws1iTBgDAoaikAQCuwJo0AAAOFZJHQXkszY832t0AADgUlTQAwBVCxqVhZX68kaQBAK4QtNjutjI3WrS7AQBwKCppAIArJGIlTZIGALhCyPAoZFjY3W1hbrRodwMA4FBU0gAAV6DdDQCAQwWVpKCFBnIwhrGYRZIGALiCYXFN2mBNGgAAdKGSBgC4QiKuSTumkl67dq08Ho/Ky8vtDgUA0A8FjSTLI94ckaQbGhq0efNm5eXl2R0KAACOYXuS7ujo0LJly/TMM89o2LBhdocDAOinQvIopCQLw4Xt7tLSUhUVFWnBggXX/G4gEFBbW1u3AQCAGV1r0lZGvNm6cWzbtm06fPiwGhoaTH2/qqpKq1ev7uOoAABwBtsqab/fr4cfflgvvPCCUlJSTM2prKxUa2trePj9/j6OEgDQXyTixjHbKummpia1tLRo+vTp4WPBYFD19fXauHGjAoGAkpOTu83xer3yer3xDhUA0A9cWpO28IINN7W758+fryNHjnQ7VlJSookTJ+rRRx/tkaABAHAb25J0enq6pkyZ0u3YkCFDNHz48B7HAQCwKmTx2d0hGTGMxhzbd3cDABAP8V6THjdunDweT49RWlpq+hyOeixoXV2d3SEAAPqprvudo58fWSXd0NCgYPD37846evSoFi5cqDvvvNP0ORyVpAEA6C9GjBjR7fPatWt1/fXXa+7cuabPQZIGALhC0PAoaOF1k11zP/sgLTN3Hl24cEHf+973VFFRIY/HfAysSQMAXCH46cYxK0OScnJylJGRER5VVVXXvPbOnTv14Ycfavny5RHFTCUNAEAE/H6/fD5f+LOZ53c8++yzKiwsVHZ2dkTXIkkDAFwhZCQpZOGpYSHj0sYxn8/XLUlfy6lTp/T666/rlVdeifiaJGkAgCsELd4nHYzyPuktW7YoKytLRUVFEc9lTRoAgD4SCoW0ZcsWFRcXa8CAyOtiKmkAgCuEJEu7u0NRzHn99df13nvvacWKFVFdkyQNAHAF6w8ziXzuokWLZBjRP06UdjcAAA5FJQ0AcAWr74R21fukAQCIJ94nDQCAQyViJc2aNAAADkUlDQBwBesPM2FNGgCAPhEyPApZuU/awtxo0e4GAMChqKQBAK4QstjutvIglGiRpAEArmD9LVjs7gYAAJ+ikgYAuEJQHgUtPJDEytxokaQBAK5AuxsAAMQMlTQAwBWCstayDsYuFNNI0gAAV0jEdjdJGgDgCrxgAwAAxAyVNADAFQyL75M2uAULAIC+QbsbAADETL+opIf4k5Ts5d8bV9OhdLtDSAhvKdfuENCvvG13AI73UWf8bmxKxFdV9oskDQDAtQQtvgXLytxoUX4CAOBQVNIAAFeg3Q0AgEOFlKSQhQaylbnRot0NAIBDUUkDAFwhaHgUtNCytjI3WiRpAIArsCYNAIBDGRbfgmXwxDEAANCFShoA4ApBeRS08JIMK3OjRZIGALhCyLC2rhwyYhiMSbS7AQBwKCppAIArhCxuHLMyN1pU0gAAVwjJY3lE6oMPPtA999yj4cOHKzU1VTfddJMaGxtNz6eSBgCgD/zud7/T7Nmzdeutt2rv3r0aMWKEjh8/rmHDhpk+B0kaAOAK8X7i2FNPPaWcnBxt2bIlfGz8+PERnYN2NwDAFbrWpK2MSPzgBz/QzJkzdeeddyorK0vTpk3TM888E9E5SNIAAESgra2t2wgEAr1+75e//KVqamr0+c9/Xvv27dNXvvIVPfTQQ3ruuedMX4skDQBwhZA84ed3RzU+3TiWk5OjjIyM8Kiqqur9eqGQpk+frieffFLTpk3T3/3d3+m+++7Tpk2bTMfMmjQAwBWMKHdoXz5fkvx+v3w+X/i41+vt9fujR4/WpEmTuh37wz/8Q33/+983fU2SNADAFWL1Fiyfz9ctSV/J7NmzdezYsW7Hfv7zn2vs2LGmr0m7GwCAPvDVr35Vhw4d0pNPPqkTJ06otrZW3/nOd1RaWmr6HFTSAABXiPcTx/Lz87Vjxw5VVlZqzZo1Gj9+vNavX69ly5aZPgdJGgDgCrFqd0di8eLFWrx4cdTXpN0NAIBDUUkDAFwh2udvXz4/3kjSAABXsKPdbRXtbgAAHIpKGgDgColYSZOkAQCukIhJmnY3AAAORSUNAHAFKukI1dTUKC8vL/wc1IKCAu3du9fOkAAA/ZSh39+GFc0wbIjZ1kp6zJgxWrt2rT7/+c/LMAw999xzuuOOO/T2229r8uTJdoYGAOhnErGStjVJL1mypNvnJ554QjU1NTp06BBJGgDgeo5Zkw4Gg3rppZfU2dmpgoKCXr8TCAQUCATCn9va2uIVHgAgwVFJR+HIkSMqKCjQ+fPnlZaWph07dvR4SXaXqqoqrV69Os4RAgD6g0RM0rbfgjVhwgQ1NzfrJz/5ib7yla+ouLhY//u//9vrdysrK9Xa2hoefr8/ztECABA/tlfSgwYN0g033CBJmjFjhhoaGrRhwwZt3ry5x3e9Xq+8Xm+8QwQA9AOJWEnbnqQ/KxQKdVt3BgAgFgzDI8NCorUyN1q2JunKykoVFhYqNzdX7e3tqq2tVV1dnfbt22dnWAAAOIKtSbqlpUX33nuvTp8+rYyMDOXl5Wnfvn1auHChnWEBAPoh3icdoWeffdbOywMAXCQR16Rt390NAAB657iNYwAA9AU2jgEA4FCJ2O4mSQMAXCERK2nWpAEAcCgqaQCAKxgW292sSQMA0EcMSYZhbX680e4GAMChqKQBAK4QkkcenjgGAIDzsLsbAADEDJU0AMAVQoZHHh5mAgCA8xiGxd3dNmzvpt0NAIBDUUkDAFwhETeOkaQBAK6QiEmadjcAwBW63oJlZURi1apV8ng83cbEiRMjOgeVNAAAfWTy5Ml6/fXXw58HDIgs7ZKkAQCuYMfu7gEDBmjUqFFRX5N2NwDAFS4laY+FEfk1jx8/ruzsbH3uc5/TsmXL9N5770U0n0oaAIAItLW1dfvs9Xrl9Xp7fG/WrFnaunWrJkyYoNOnT2v16tX60pe+pKNHjyo9Pd3UtaikAQCuYK2K/v3O8JycHGVkZIRHVVVVr9crLCzUnXfeqby8PN1+++3as2ePPvzwQ7344oumY6aSBgC4giFr74Tumuv3++Xz+cLHe6uiezN06FDdeOONOnHihOlrUkkDABABn8/XbZhN0h0dHfrFL36h0aNHm74WSRoA4Aqxaneb9cgjj+jAgQP61a9+pf/+7//Wn/7pnyo5OVl333236XPQ7gYAuEOs+t0mvf/++7r77rv129/+ViNGjNAXv/hFHTp0SCNGjDB9DpI0AMAdLD4WVBHO3bZtW/TX+hTtbgAAHIpKGgDgCon4PmmSNADAFRLxLVj9IkmnvxfUgIFBu8NwuGS7A0gIHTL3FCC3e0u5doeAfuJCxwVJR+wOw7H6RZIGAOCaDE/Em796zI8zkjQAwBUScU2a3d0AADgUlTQAwB3i/DCTWCBJAwBcIRF3d9PuBgDAoaikAQDuYUPL2gqSNADAFRKx3U2SBgC4QwJuHGNNGgAAh6KSBgC4hOfTYWV+fJGkAQDuQLsbAADECpU0AMAdErCSJkkDANwhAd+CRbsbAACHopIGALhCIr6qkiQNAHCHBFyTpt0NAIBDUUkDANwhATeOkaQBAK7gMS4NK/PjjSQNAHAH1qQBAECsUEkDANyBNWkAAByKdjcAAIgVKmkAgDskYCVNkgYAuEMCJmna3QAAOBSVNADAHdjdDQCAMyXiE8dodwMA4FC2Jumqqirl5+crPT1dWVlZWrp0qY4dO2ZnSACA/sqIwYjS2rVr5fF4VF5eHtE8W5P0gQMHVFpaqkOHDmn//v26ePGiFi1apM7OTjvDAgAgZhoaGrR582bl5eVFPNfWNenXXnut2+etW7cqKytLTU1NmjNnjk1RAQD6I48srklHMaejo0PLli3TM888o29+85sRzzeVpP/sz/7s2icaMECjRo3SwoULtWTJkogDkaTW1lZJUmZmZq8/DwQCCgQC4c9tbW1RXQcAgGh9Nvd4vV55vd5ev1taWqqioiItWLAgqiRtqt2dkZFxzZGamqrjx4/rrrvu0sqVKyMOJBQKqby8XLNnz9aUKVN6/U5VVVW3a+bk5ER8HQCAS3XdgmVlSMrJyemWi6qqqnq93LZt23T48OEr/twMU5X0li1bTJ9w9+7deuCBB7RmzZqIAiktLdXRo0d18ODBK36nsrJSFRUV4c9tbW0kagCAOTF64pjf75fP5wsf7q2K9vv9evjhh7V//36lpKREfcmYr0l/8Ytf1MyZMyOaU1ZWpt27d6u+vl5jxoy54veu1lIAACAefD5ftyTdm6amJrW0tGj69OnhY8FgUPX19dq4caMCgYCSk5Ovea2YJ+mhQ4fqlVdeMfVdwzD04IMPaseOHaqrq9P48eNjHQ4AAJfE8dnd8+fP15EjR7odKykp0cSJE/Xoo4+aStCSzbu7S0tLVVtbq127dik9PV1nzpyRpPAaNwAAsRLPJ46lp6f32F81ZMgQDR8+/Ir7rnpj633SNTU1am1t1bx58zR69Ojw2L59u51hAQDgCLZW0oZhw4NQAQDuZPOrKuvq6iKewws2AADuwPukAQBArFBJAwBcIRFfVUmSBgC4w2VPDYt6fpyRpAEA7sCaNAAAiBUqaQCAK7AmDQCAU9HuBgAAsUIlDQBwB4vtbjsqaZI0AMAdaHcDAIBYoZIGALhDAlbSJGkAgCsk4i1YtLsBAHAokjQAAA5FuxsA4A6sSQMA4EysSQMAgJihkgYAuIcN1bAVJGkAgDsk4Jo07W4AAByKShoA4AqJuHGMJA0AcAfa3QAAIFaopAEArkC7GwAAp6LdDQAAYoVKGgDgDglYSZOkAQCuwJq0TdJPtGpA8nm7w3C4oXYHkCCS7Q4gIXQo3e4QEsJbyrU7BMcLfhSI38USsJJmTRoAAIfqF5U0AADXlICVNEkaAOAKibgmTbsbAACHIkkDANzBiMGIQE1NjfLy8uTz+eTz+VRQUKC9e/dGdA6SNADAFbra3VZGJMaMGaO1a9eqqalJjY2Nuu2223THHXfonXfeMX0O1qQBAOgDS5Ys6fb5iSeeUE1NjQ4dOqTJkyebOgdJGgDgDjHa3d3W1tbtsNfrldfrverUYDCol156SZ2dnSooKDB9SdrdAAB3iNGadE5OjjIyMsKjqqrqipc8cuSI0tLS5PV69fd///fasWOHJk2aZDpkKmkAACLg9/vl8/nCn69WRU+YMEHNzc1qbW3Vyy+/rOLiYh04cMB0oiZJAwBcwfPpsDJfUni3thmDBg3SDTfcIEmaMWOGGhoatGHDBm3evNnUfJI0AMAdHPDEsVAopEDA/PPKSdIAAFeI9xPHKisrVVhYqNzcXLW3t6u2tlZ1dXXat2+f6XOQpAEA6AMtLS269957dfr0aWVkZCgvL0/79u3TwoULTZ+DJA0AcIc4t7ufffZZCxe7hCQNAHAPG16SYQX3SQMA4FBU0gAAV0jEV1WSpAEA7uCAW7AiRbsbAACHopIGALgC7W4AAJyKdjcAAIgVKmkAgCvQ7gYAwKkSsN1NkgYAuEMCJmnWpAEAcCgqaQCAK7AmDQCAU9HuBgAAsUIlDQBwBY9hyGNEXw5bmRstkjQAwB1od0emvr5eS5YsUXZ2tjwej3bu3GlnOAAAOIqtSbqzs1NTp05VdXW1nWEAAFyga3e3lRFvtra7CwsLVVhYaGcIAAC3SMB2d0KtSQcCAQUCgfDntrY2G6MBAKBvJdQtWFVVVcrIyAiPnJwcu0MCACSIRGx3J1SSrqysVGtra3j4/X67QwIAJAojBiPOEqrd7fV65fV67Q4DAJCAEvGxoAlVSQMA4Ca2VtIdHR06ceJE+PPJkyfV3NyszMxM5ebm2hgZAKDfYXd3ZBobG3XrrbeGP1dUVEiSiouLtXXrVpuiAgD0V3a0rK2wNUnPmzdPhg3PQgUAIBEk1MYxAACiZhiXhpX5cUaSBgC4Aru7AQBAzFBJAwDcgd3dAAA4kyd0aViZH2+0uwEAcCgqaQCAOyRgu5tKGgDgCvF+C1ZVVZXy8/OVnp6urKwsLV26VMeOHYvoHCRpAIA7dN0nbWVE4MCBAyotLdWhQ4e0f/9+Xbx4UYsWLVJnZ6fpc9DuBgCgD7z22mvdPm/dulVZWVlqamrSnDlzTJ2DJA0AcIVYPcykra2t23Gzr1FubW2VJGVmZpq+Ju1uAIA7GDEYknJycpSRkREeVVVV17x0KBRSeXm5Zs+erSlTppgOmUoaAIAI+P1++Xy+8GczVXRpaamOHj2qgwcPRnQtkjQAwBVi1e72+XzdkvS1lJWVaffu3aqvr9eYMWMiuiZJGgDgDnF+C5ZhGHrwwQe1Y8cO1dXVafz48RFfkiQNAEAfKC0tVW1trXbt2qX09HSdOXNGkpSRkaHU1FRT52DjGADAFeL9MJOamhq1trZq3rx5Gj16dHhs377d9DmopAEA7hDnx4IaVlrrn6KSBgDAoaikAQCuEKvd3fFEkgYAuEPIuDSszI8zkjQAwB14VSUAAIgVKmkAgCt4ZHFNOmaRmEeSBgC4Q5yfOBYLtLsBAHAoKmkAgCtwCxYAAE7F7m4AABArVNIAAFfwGIY8FjZ/WZkbrX6RpIM/Oy6PZ6DdYThauibYHUKCGGp3AAki2e4AEkKH0u0OwfFC5+P4/+7Qp8PK/Dij3Q0AgEP1i0oaAIBrod0NAIBTJeDubpI0AMAdeOIYAACIFSppAIAr8MQxAACcinY3AACIFSppAIAreEKXhpX58UaSBgC4A+1uAAAQK1TSAAB34GEmAAA4UyI+FpR2NwAADkUlDQBwhwTcOEaSBgC4gyFr74RmTRoAgL7BmjQAAIgZKmkAgDsYsrgmHbNITCNJAwDcIQE3jtHuBgDAoaikAQDuEJLksTg/zqikAQCu0LW728qIRH19vZYsWaLs7Gx5PB7t3Lkz4phJ0gAA9IHOzk5NnTpV1dXVUZ+DdjcAwB3ivHGssLBQhYWF0V9PJGkAgFsk4O5ukjQAABFoa2vr9tnr9crr9fbJtViTBgC4Q1clbWVIysnJUUZGRnhUVVX1WchU0gAAd4jRLVh+v18+ny98uK+qaIkkDQBwiVi9YMPn83VL0n2JJA0AQB/o6OjQiRMnwp9Pnjyp5uZmZWZmKjc319Q5HLEmXV1drXHjxiklJUWzZs3SW2+9ZXdIAID+JkZr0mY1NjZq2rRpmjZtmiSpoqJC06ZN08qVK02fw/ZKevv27aqoqNCmTZs0a9YsrV+/XrfffruOHTumrKwsu8MDAPQXIUPyWLiNKhTZ3Hnz5smweNuW7ZX0unXrdN9996mkpESTJk3Spk2bNHjwYH33u9+1OzQAAGxla5K+cOGCmpqatGDBgvCxpKQkLViwQD/+8Y9tjAwA0O/Eud0dC7a2u3/zm98oGAxq5MiR3Y6PHDlS7777bo/vBwIBBQKB8OfP3lAOAMCVWU20vE/6qqqqqrrdQJ6Tk2N3SAAA9Blbk/R1112n5ORknT17ttvxs2fPatSoUT2+X1lZqdbW1vDw+/3xChUAkOgSsN1ta5IeNGiQZsyYoTfeeCN8LBQK6Y033lBBQUGP73u93vBN5PG8mRwA0A+EDOsjzmy/BauiokLFxcWaOXOmbrnlFq1fv16dnZ0qKSmxOzQAAGxle5K+6667dO7cOa1cuVJnzpzRzTffrNdee63HZjIAACwxQpeGlflxZnuSlqSysjKVlZXZHQYAoD/jfdIAADhUyJCl26hsWJNOqFuwAABwEyppAIA70O4GAMChDFlM0jGLxDTa3QAAOBSVNADAHWh3AwDgUKGQJAv3Oofif5807W4AAByKShoA4A60uwEAcKgETNK0uwEAcCgqaQCAOyTgY0FJ0gAAVzCMkAwLb7KyMjdaJGkAgDsYhrVqmDVpAADQhUoaAOAOhsU1aW7BAgCgj4RCksfCurINa9K0uwEAcCgqaQCAO9DuBgDAmYxQSIaFdrcdt2DR7gYAwKGopAEA7kC7GwAAhwoZkiexkjTtbgAAHIpKGgDgDoYhycp90rS7AQDoE0bIkGGh3W3Q7gYAoI8YIesjCtXV1Ro3bpxSUlI0a9YsvfXWW6bnkqQBAOgj27dvV0VFhR5//HEdPnxYU6dO1e23366WlhZT80nSAABXMEKG5RGpdevW6b777lNJSYkmTZqkTZs2afDgwfrud79raj5JGgDgDnFud1+4cEFNTU1asGBB+FhSUpIWLFigH//4x6bOkdAbx7oW8T/RRUv3p7uBEQzYHUJC+OTiebtDSAjBQLLdISSE0Pn4P0Yy0YTOX/o7F49NWVZzxSe6KElqa2vrdtzr9crr9fb4/m9+8xsFg0GNHDmy2/GRI0fq3XffNXXNhE7S7e3tkqSD2mNzJAngZ3YHkCD4PQG2aG9vV0ZGRp+ce9CgQRo1apQOnrGeK9LS0pSTk9Pt2OOPP65Vq1ZZPndvEjpJZ2dny+/3Kz09XR6Px+5wJF36F1ZOTo78fr98Pp/d4TgWvydz+D2Zw+/JHCf+ngzDUHt7u7Kzs/vsGikpKTp58qQuXLhg+VyGYfTIN71V0ZJ03XXXKTk5WWfPnu12/OzZsxo1apSp6yV0kk5KStKYMWPsDqNXPp/PMX8JnIzfkzn8nszh92SO035PfVVBXy4lJUUpKSl9fp3LDRo0SDNmzNAbb7yhpUuXSpJCoZDeeOMNlZWVmTpHQidpAACcrKKiQsXFxZo5c6ZuueUWrV+/Xp2dnSopKTE1nyQNAEAfueuuu3Tu3DmtXLlSZ86c0c0336zXXnutx2ayKyFJx5jX69Xjjz9+xTUKXMLvyRx+T+bwezKH35M9ysrKTLe3P8tj2PEwUgAAcE08zAQAAIciSQMA4FAkaQAAHIokDQCAQ5GkY8zKe0PdoL6+XkuWLFF2drY8Ho927txpd0iOVFVVpfz8fKWnpysrK0tLly7VsWPH7A7LcWpqapSXlxd+OEdBQYH27t1rd1iOtnbtWnk8HpWXl9sdCkwgSceQ1feGukFnZ6emTp2q6upqu0NxtAMHDqi0tFSHDh3S/v37dfHiRS1atEidnZ12h+YoY8aM0dq1a9XU1KTGxkbddtttuuOOO/TOO+/YHZojNTQ0aPPmzcrLy7M7FJjELVgxNGvWLOXn52vjxo2SLj3+LScnRw8++KAee+wxm6NzHo/Hox07doQfl4crO3funLKysnTgwAHNmTPH7nAcLTMzU9/61rf0N3/zN3aH4igdHR2aPn26nn76aX3zm9/UzTffrPXr19sdFq6BSjpGYvHeUOBKWltbJV1KQOhdMBjUtm3b1NnZqYKCArvDcZzS0lIVFRV1+38UnI8njsVILN4bCvQmFAqpvLxcs2fP1pQpU+wOx3GOHDmigoICnT9/XmlpadqxY4cmTZpkd1iOsm3bNh0+fFgNDQ12h4IIkaQBhystLdXRo0d18OBBu0NxpAkTJqi5uVmtra16+eWXVVxcrAMHDpCoP+X3+/Xwww9r//79cX8LFKwjScdILN4bCnxWWVmZdu/erfr6ese+ltVugwYN0g033CBJmjFjhhoaGrRhwwZt3rzZ5sicoampSS0tLZo+fXr4WDAYVH19vTZu3KhAIKDk5GQbI8TVsCYdI5e/N7RL13tDWR9DpAzDUFlZmXbs2KE333xT48ePtzukhBEKhRQIBOwOwzHmz5+vI0eOqLm5OTxmzpypZcuWqbm5mQTtcFTSMWT1vaFu0NHRoRMnToQ/nzx5Us3NzcrMzFRubq6NkTlLaWmpamtrtWvXLqWnp+vMmTOSpIyMDKWmptocnXNUVlaqsLBQubm5am9vV21trerq6rRv3z67Q3OM9PT0HnsZhgwZouHDh7PHIQGQpGPI6ntD3aCxsVG33npr+HNFRYUkqbi4WFu3brUpKuepqamRJM2bN6/b8S1btmj58uXxD8ihWlpadO+99+r06dPKyMhQXl6e9u3bp4ULF9odGhAT3CcNAIBDsSYNAIBDkaQBAHAokjQAAA5FkgYAwKFI0gAAOBRJGgAAhyJJAwDgUCRpAAAciiQNONjy5cu1dOlSu8MAYBOSNAAADkWSBgDAoUjSAAA4FEkaAACHIkkDAOBQJGkAAByKJA0AgEORpAEAcCiSNAAADuUxDMOwOwgAANATlTQAAA5FkgYAwKFI0gAAOBRJGgAAhyJJAwDgUCRpAAAciiQNAIBDkaQBAHAokjQAAA5FkgYAwKFI0gAAOBRJGgAAh/p/2Ww8TswexzgAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_out at K = 0\n", + "Min and max values: 0.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing `copy_stencil`\n", + "Plotting qty_out from `copy_stencil` at K = 0\n", + "Min and max values: 8.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting qty_out from `copy_stencil` at K = 1\n", + "Min and max values: 9.0 1.0\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAHHCAYAAACbaKDRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAoYklEQVR4nO3df3BV9Z3/8ddNgJtI7g0ECZCSBBYrFGhUArIBC6gBm4lUZmeqZXENoe26bRBjZltltgXU2uC640ILjdSx4LJSUCvSRSGD2MDgyhKC2S+6lUqX0usPiO1qfik3cO/5/oHcEglw7j0395yT83zMfGa8J/dzzpvMyJv3+/M55/gMwzAEAAAcJ83uAAAAQM9I0gAAOBRJGgAAhyJJAwDgUCRpAAAciiQNAIBDkaQBAHAokjQAAA5FkgYAwKFI0vC0hoYG+Xw+NTQ02B0KAFyAJI0+acOGDfL5fLGRkZGhq6++WosXL9bJkyeTco2XX35ZK1asSMq5zrdp0yatWrXK9PdHjRqlW2+99YLjGzduVHp6ur761a/q1KlTSYzw4o4cOaL77rtP06ZNU0ZGhnw+n/7whz+k5NpAX0SSRp/20EMPaePGjVqzZo2mTZumuro6lZSU6JNPPrF87pdfflkPPvhgEqLsLt4k3ZNnnnlGCxcuVGlpqV588UVlZGQkJ7jLeP311/WTn/xE7e3t+tKXvpSSawJ9WT+7AwB6U1lZmSZPnixJ+ta3vqUhQ4bo8ccf17Zt2zR//nybo+sdmzdvVkVFhW666SZt27YtZQlakr72ta/p448/ViAQ0L/8y7+oubk5ZdcG+iIqaXjKTTfdJEk6duzYJb/33HPPqbi4WJmZmbryyit155136r333ov9fOHChVq7dq0kdWurX8q2bdtUXl6uvLw8+f1+jRkzRg8//LAikUjsO7NmzdJLL72k48ePx845atQo03++Z599VnfeeadmzZqlX//61ylN0JKUk5OjQCCQ0msCfRmVNDzl97//vSRpyJAhF/3Ohg0bVFlZqSlTpqi2tlYnT57U6tWr9dprr+mNN97QoEGDdPfdd+v999/Xrl27tHHjRlPX3rBhg7KyslRTU6OsrCy9+uqrWrZsmdra2vTYY49Jkv7pn/5Jra2tevfdd/Wv//qvkqSsrCxT5//Vr36lBQsWaMaMGfqP//gPZWZmmprX0dFhas26f//+ys7ONnVOAEliAH3Q+vXrDUnGK6+8Ynz44YdGKBQyNm/ebAwZMsTIzMw03n33XcMwDOM3v/mNIcn4zW9+YxiGYXR1dRm5ubnGxIkTjU8//TR2vu3btxuSjGXLlsWOVVVVGfH8L/TJJ59ccOzuu+82rrjiCuPUqVOxY+Xl5UZhYaHp8xYWFhp5eXlGv379jFmzZhmdnZ2m5xqGYVRUVBiSLjtmzpwZ13kfe+wxQ5Jx7NixuOYB+AsqafRppaWl3T4XFhbqmWee0Re+8IUev3/w4EG1tLRoxYoV3VrF5eXlGjdunF566aWEN4udX9m2t7crHA7rK1/5itatW6e3335b11xzTULnlaT/+7//05kzZzRy5EjTFfQ53//+93XnnXde9nuDBw9ONDwACSJJo09bu3atrr76avXr10/Dhg3T2LFjlZZ28a0Yx48flySNHTv2gp+NGzdO+/btSziWt956Sz/4wQ/06quvqq2trdvPWltbEz6vJN18880qKChQXV2dcnJytHr1atNzx48fr/Hjx1u6PoDeQZJGn3b99dfHdnfb6eOPP9bMmTMVDAb10EMPacyYMcrIyNChQ4d0//33KxqNWr7GmjVr9NFHH+knP/mJBg8ebPoe7tbWVn366aeX/d6AAQOUk5NjMUoA8SBJA+cpLCyUdPahHOd2gp9z5MiR2M8lXXY39/kaGhr05z//WS+88IJmzJgRO97TLvN4znu+tLQ0/du//ZtaW1v14IMPKicnR0uWLLnsvHvvvVdPP/30Zb83c+ZMnswGpBhJGjjP5MmTlZubqyeeeEKLFi2S3++XJO3YsUO//e1vtWzZsth3Bw4cKOlslTxo0KBLnjc9PV2SZBhG7FhXV5d+9rOfXfDdgQMHJtz+7t+/v55//nnNmTNH1dXVGjx4sP7u7/7uknNYkwaciyQNnKd///569NFHVVlZqZkzZ2r+/PmxW7BGjRql++67L/bd4uJiSdKSJUt0yy23KD09Xd/4xjd6PO+0adM0ePBgVVRUaMmSJfL5fNq4cWO3pH3+ebds2aKamhpNmTJFWVlZmjt3ruk/wxVXXKGXXnpJM2fO1KJFi5Sdna2vfe1rF/1+MtekW1tb9dOf/lSS9Nprr0k624YfNGiQBg0apMWLFyflOoBn2L29HOgN527BamxsvOT3Pn8L1jlbtmwxrrvuOsPv9xs5OTnGggULYrdtnXPmzBnjnnvuMYYOHWr4fL7L3o712muvGX/9139tZGZmGnl5ecb3v/99o76+/oLrd3R0GH/7t39rDBo0yJB02duxCgsLjfLy8guOnzhxwrjqqquMjIyMC/58veXYsWMXvYUrntvKAJzlM4we/ikPAABsx2NBAQBwKJI0AAAORZIGAMChSNIAAPSS9vZ2VVdXq7CwUJmZmZo2bZoaGxtNzydJAwDQS771rW/F3pZ3+PBhzZkzR6Wlpd1efXsp7O4GAKAXfPrppwoEArF3yZ9TXFyssrIy/ehHP7rsOVz9MJNoNKr3339fgUAg4UcpAgDsYxiG2tvblZeXd8mX31h16tQpdXV1WT6PYRgX5Bu/3x97OuH5zpw5o0gk0u2NetLZN+KZflmPnTdpWxUKhUy9B5fBYDAYzh6hUKjXcsWnn35qDM9NT0qcWVlZFxxbvnz5Ra9dUlJizJw503jvvfeMM2fOGBs3bjTS0tKMq6++2lTsrq6kA4GAJGnkih8o7XP/UkF3/pEddofgCsUjQnaH4ArlOf/P7hBc4daBnXaH4HhtHVEVTvpD7O/z3tDV1aUTLREdbxqlYCDxar2tParC4j8oFAopGAzGjvdURZ+zceNGLVq0SF/4wheUnp6uSZMmaf78+WpqajJ1TVcn6XMth7SMDJL0ZaRfcdruEFxhQNYAu0NwhSsC6XaH4ArBgezNNSsVS5ZZAZ+yAolfJ6qzc4PBYLckfSljxozRnj171NnZqba2No0YMUJ33HGH/uqv/srUfFcnaQAAzIoYUUUMa/MTNXDgQA0cOFAfffSR6uvr9c///M+m5pGkAQCeEJWhqBLP0onMra+vl2EYGjt2rI4eParvfe97GjdunCorK03NpxcDAEAvaW1tVVVVlcaNG6e77rpLN9xwg+rr69W/f39T86mkAQCeEFVUiTesldDs22+/XbfffnvC1yRJAwA8IWIYilh4fpeVuYmi3Q0AgENRSQMAPMGOjWNWkaQBAJ4QlaGIy5I07W4AAByKShoA4Am0uwEAcCh2dwMAgKShkgYAeEL0s2FlfqqRpAEAnhCxuLvbytxEkaQBAJ4QMWTxLVjJi8Us1qQBAHAoKmkAgCewJg0AgENF5VNEPkvzU412NwAADkUlDQDwhKhxdliZn2okaQCAJ0QstrutzE0U7W4AAByKShoA4AlurKRJ0gAAT4gaPkUNC7u7LcxNFO1uAAAcikoaAOAJtLsBAHCoiNIUsdBAjiQxFrNI0gAATzAsrkkbrEkDAIBzqKQBAJ7gxjVpx1TSK1eulM/nU3V1td2hAAD6oIiRZnmkmiOSdGNjo9atW6eioiK7QwEAwDFsT9IdHR1asGCBnnzySQ0ePNjucAAAfVRUPkWVZmF4sN1dVVWl8vJylZaWXva74XBYbW1t3QYAAGacW5O2MlLN1o1jmzdv1qFDh9TY2Gjq+7W1tXrwwQd7OSoAAJzBtko6FArp3nvv1TPPPKOMjAxTc5YuXarW1tbYCIVCvRwlAKCvcOPGMdsq6aamJrW0tGjSpEmxY5FIRHv37tWaNWsUDoeVnp7ebY7f75ff7091qACAPuDsmrSFF2x4qd1988036/Dhw92OVVZWaty4cbr//vsvSNAAAHiNbUk6EAho4sSJ3Y4NHDhQQ4YMueA4AABWRS0+uzsqI4nRmGP77m4AAFIh1WvSkUhEP/zhDzV69GhlZmZqzJgxevjhh2UY5pO9ox4L2tDQYHcIAIA+6tz9zonPj6+SfvTRR1VXV6enn35aEyZM0MGDB1VZWans7GwtWbLE1DkclaQBAOgr/vM//1O33XabysvLJUmjRo3SL3/5Sx04cMD0OWh3AwA8IWL4LA9JFzxUKxwO93i9adOmaffu3frd734nSfrv//5v7du3T2VlZaZjppIGAHhCxOLGschn7e78/Pxux5cvX64VK1Zc8P0HHnhAbW1tGjdunNLT0xWJRPTII49owYIFpq9JkgYAIA6hUEjBYDD2+WLP73j22Wf1zDPPaNOmTZowYYKam5tVXV2tvLw8VVRUmLoWSRoA4AlRI01RC08Ni362KzsYDHZL0hfzve99Tw888IC+8Y1vSJK+/OUv6/jx46qtrSVJAwBwvmS1u8365JNPlJbW/Xrp6emKRqOmz0GSBgCgF8ydO1ePPPKICgoKNGHCBL3xxht6/PHHtWjRItPnIEkDADwhKsV2aCc6Px4//elP9cMf/lDf/e531dLSory8PN19991atmyZ6XOQpAEAnmD9YSbxzQ0EAlq1apVWrVqV8DW5TxoAAIeikgYAeILVd0J76n3SAACkEu+TBgDAodxYSbMmDQCAQ1FJAwA8wfrDTFiTBgCgV0QNn6JW7pO2MDdRtLsBAHAoKmkAgCdELba7rTwIJVEkaQCAJ1h/Cxa7uwEAwGeopAEAnhCRTxELDySxMjdRJGkAgCfQ7gYAAElDJQ0A8ISIrLWsI8kLxTSSNADAE9zY7iZJAwA8gRdsAACApKGSBgB4gmHxfdIGt2ABANA7aHcDAICk6ROV9MBQmtL9/HvjUjoUsDsEVzigArtDQJ/yht0BON4nnam7scmNr6rsE0kaAIDLiVh8C5aVuYmi/AQAwKGopAEAnkC7GwAAh4oqTVELDWQrcxNFuxsAAIeikgYAeELE8ClioWVtZW6iSNIAAE9gTRoAAIcyLL4Fy+CJYwAA4BwqaQCAJ0TkU8TCSzKszE0USRoA4AlRw9q6ctRIYjAm0e4GAMChqKQBAJ4QtbhxzMrcRFFJAwA8ISqf5RGPUaNGyefzXTCqqqpMn4NKGgCAXtDY2KhI5C+v4nzzzTc1e/Zsff3rXzd9DpI0AMATUv3EsaFDh3b7vHLlSo0ZM0YzZ840fQ6SNADAE+xck+7q6tK///u/q6amRj6f+WRPkgYAIA5tbW3dPvv9fvn9/kvOefHFF/Xxxx9r4cKFcV2LjWMAAE+Iyhd7fndC47ONY/n5+crOzo6N2tray177qaeeUllZmfLy8uKKmUoaAOAJRgI7tD8/X5JCoZCCwWDs+OWq6OPHj+uVV17RCy+8EPc1SdIAAE9I1luwgsFgtyR9OevXr1dubq7Ky8vjvibtbgAAekk0GtX69etVUVGhfv3ir4uppAEAnmDH7u5XXnlFf/zjH7Vo0aKErkmSBgB4QrLa3fGYM2eODCPxN3PQ7gYAwKGopAEAnpDI87c/Pz/VSNIAAE+wo91tFe1uAAAcikoaAOAJbqykSdIAAE9wY5Km3Q0AgENRSQMAPIFKOk51dXUqKiqKPQe1pKREO3bssDMkAEAfZegvt2ElMhJ/JEnibK2kR44cqZUrV+qLX/yiDMPQ008/rdtuu01vvPGGJkyYYGdoAIA+xo2VtK1Jeu7cud0+P/LII6qrq9P+/ftJ0gAAz3PMmnQkEtFzzz2nzs5OlZSU9PidcDiscDgc+9zW1paq8AAALkclnYDDhw+rpKREp06dUlZWlrZu3arx48f3+N3a2lo9+OCDKY4QANAXuDFJ234L1tixY9Xc3Kz/+q//0ne+8x1VVFTof/7nf3r87tKlS9Xa2hoboVAoxdECAJA6tlfSAwYM0FVXXSVJKi4uVmNjo1avXq1169Zd8F2/3y+/35/qEAEAfYAbK2nbk/TnRaPRbuvOAAAkg2H4ZFhItFbmJsrWJL106VKVlZWpoKBA7e3t2rRpkxoaGlRfX29nWAAAOIKtSbqlpUV33XWXPvjgA2VnZ6uoqEj19fWaPXu2nWEBAPog3icdp6eeesrOywMAPMSNa9K27+4GAAA9c9zGMQAAegMbxwAAcCg3trtJ0gAAT3BjJc2aNAAADkUlDQDwBMNiu5s1aQAAeokhyTCszU812t0AADgUlTQAwBOi8snHE8cAAHAedncDAICkoZIGAHhC1PDJx8NMAABwHsOwuLvbhu3dtLsBAHAoKmkAgCe4ceMYSRoA4AluTNK0uwEAnnDuLVhWRrzee+893XnnnRoyZIgyMzP15S9/WQcPHjQ9n0oaAIBe8NFHH2n69Om68cYbtWPHDg0dOlTvvPOOBg8ebPocJGkAgCekenf3o48+qvz8fK1fvz52bPTo0XGdg3Y3AMATziZpn4UR3/V+/etfa/Lkyfr617+u3NxcXXfddXryySfjOgdJGgCAOLS1tXUb4XC4x+/97//+r+rq6vTFL35R9fX1+s53vqMlS5bo6aefNn0tkjQAwBOsVdF/2Rmen5+v7Ozs2Kitre3xetFoVJMmTdKPf/xjXXfddfr7v/97ffvb39YTTzxhOmbWpAEAnmDI2juhz80NhUIKBoOx436/v8fvjxgxQuPHj+927Etf+pJ+9atfmb4mSRoAgDgEg8FuSfpipk+friNHjnQ79rvf/U6FhYWmr0WSBgB4QqofZnLfffdp2rRp+vGPf6zbb79dBw4c0M9//nP9/Oc/N30O1qQBAN5gJGHEYcqUKdq6dat++ctfauLEiXr44Ye1atUqLViwwPQ5qKQBAN5gsZJWAnNvvfVW3XrrrQlfkkoaAACHopIGAHiCG98nTZIGAHiCG9+C1SeSdOCPEfXrH7E7DIdLtzsAV+hQwO4QXOGACuwOAX1EV0eXpMN2h+FYfSJJAwBwWYYvoc1f3eanGEkaAOAJblyTZnc3AAAORSUNAPCGZD28O4VI0gAAT3Dj7m7a3QAAOBSVNADAO2xoWVtBkgYAeIIb290kaQCAN7hw4xhr0gAAOBSVNADAI3yfDSvzU4skDQDwBtrdAAAgWaikAQDe4MJKmiQNAPAGF74Fi3Y3AAAORSUNAPAEN76qkiQNAPAGF65J0+4GAMChqKQBAN7gwo1jJGkAgCf4jLPDyvxUI0kDALyBNWkAAJAsVNIAAG9gTRoAAIei3Q0AAJKFShoA4A0urKRJ0gAAb3BhkqbdDQCAQ1FJAwC8gd3dAAA4kxufOEa7GwAAh7I1SdfW1mrKlCkKBALKzc3VvHnzdOTIETtDAgD0VUYSRhxWrFghn8/XbYwbNy6uc9iapPfs2aOqqirt379fu3bt0unTpzVnzhx1dnbaGRYAAEkxYcIEffDBB7Gxb9++uObbuia9c+fObp83bNig3NxcNTU1acaMGTZFBQDoi3yyuCadwJx+/fpp+PDhCV/TVJL+m7/5G9OBzJ49W3Pnzk0omNbWVklSTk5Ojz8Ph8MKh8Oxz21tbQldBwCARH0+9/j9fvn9/h6/+8477ygvL08ZGRkqKSlRbW2tCgoKTF/LVLs7Ozv7siMzM1PvvPOO7rjjDi1btsx0AOdEo1FVV1dr+vTpmjhxYo/fqa2t7XbN/Pz8uK8DAPCoc7dgWRmS8vPzu+Wi2traHi83depUbdiwQTt37lRdXZ2OHTumr3zlK2pvbzcdsqlKev369aZPuH37dn33u9/VQw89ZHqOJFVVVenNN9+8ZL9+6dKlqqmpiX1ua2sjUQMAzEnSE8dCoZCCwWDs8MWq6LKysth/FxUVaerUqSosLNSzzz6rb37zm6YumfQ16RtuuEGTJ0+Oa87ixYu1fft27d27VyNHjrzo9y7VUgAAIBWCwWC3JG3WoEGDdPXVV+vo0aOm5yR9d/egQYP0wgsvmPquYRhavHixtm7dqldffVWjR49OdjgAAJyV4luwPq+jo0O///3vNWLECNNzbN3dXVVVpU2bNmnbtm0KBAI6ceKEJMXWuAEASJZUP3HsH//xHzV37lwVFhbq/fff1/Lly5Wenq758+ebPoetSbqurk6SNGvWrG7H169fr4ULF6Y+IAAAkuTdd9/V/Pnz9ec//1lDhw7VDTfcoP3792vo0KGmz2FrkjYMGx6ECgDwphS/qnLz5s0WLnYWL9gAAHgD75MGAADJQiUNAPAEN76qkiQNAPCG854alvD8FCNJAwC8gTVpAACQLFTSAABPYE0aAACnot0NAACShUoaAOANFtvddlTSJGkAgDfQ7gYAAMlCJQ0A8AYXVtIkaQCAJ7jxFiza3QAAOBRJGgAAh6LdDQDwBtakAQBwJtakAQBA0lBJAwC8w4Zq2AqSNADAG1y4Jk27GwAAh6KSBgB4ghs3jpGkAQDeQLsbAAAkC5U0AMATaHcDAOBUtLsBAECyUEkDALzBhZU0SRoA4AmsSdskcLRV/dJP2R2Gww2yOwCXSLc7AFfoUMDuEFzhgArsDsHxIp+EU3cxF1bSrEkDAOBQfaKSBgDgslxYSZOkAQCe4MY1adrdAAA4FEkaAOANRhJGglauXCmfz6fq6uq45tHuBgB4gl3t7sbGRq1bt05FRUVxz6WSBgCgl3R0dGjBggV68sknNXjw4Ljnk6QBAN6QpHZ3W1tbtxEOX/xe76qqKpWXl6u0tDShkEnSAABvSFKSzs/PV3Z2dmzU1tb2eLnNmzfr0KFDF/25GaxJAwAQh1AopGAwGPvs9/t7/M69996rXbt2KSMjI+FrkaQBAJ7g+2xYmS9JwWCwW5LuSVNTk1paWjRp0qTYsUgkor1792rNmjUKh8NKT7/8Y4hJ0gAAb0jhE8duvvlmHT58uNuxyspKjRs3Tvfff7+pBC2RpAEAHpHKW7ACgYAmTpzY7djAgQM1ZMiQC45fChvHAABwKCppAIA32PyCjYaGhrjnkKQBAN5hw0syrKDdDQCAQ1FJAwA8wY2vqiRJAwC8weY16UTQ7gYAwKGopAEAnkC7GwAAp6LdDQAAkoVKGgDgCbS7AQBwKhe2u0nSAABvcGGSZk0aAACHopIGAHgCa9IAADgV7W4AAJAsVNIAAE/wGYZ8RuLlsJW5iSJJAwC8gXZ3fPbu3au5c+cqLy9PPp9PL774op3hAADgKLYm6c7OTl1zzTVau3atnWEAADzg3O5uKyPVbG13l5WVqayszM4QAABe4cJ2t6vWpMPhsMLhcOxzW1ubjdEAANC7XHULVm1trbKzs2MjPz/f7pAAAC7hxna3q5L00qVL1draGhuhUMjukAAAbmEkYaSYq9rdfr9ffr/f7jAAAC7kxseCuqqSBgDAS2ytpDs6OnT06NHY52PHjqm5uVk5OTkqKCiwMTIAQJ/D7u74HDx4UDfeeGPsc01NjSSpoqJCGzZssCkqAEBfZUfL2gpbk/SsWbNk2PAsVAAA3MBVG8cAAEiYYZwdVuanGEkaAOAJ7O4GAABJQyUNAPAGdncDAOBMvujZYWV+qtHuBgDAoaikAQDe4MJ2N5U0AMATUv0WrLq6OhUVFSkYDCoYDKqkpEQ7duyI6xwkaQCAN5y7T9rKiMPIkSO1cuVKNTU16eDBg7rpppt022236a233jJ9DtrdAAD0grlz53b7/Mgjj6iurk779+/XhAkTTJ2DJA0A8IRkPcykra2t23Ezr1GORCJ67rnn1NnZqZKSEtPXpN0NAPAGIwlDUn5+vrKzs2Ojtrb2opc8fPiwsrKy5Pf79Q//8A/aunWrxo8fbzpkKmkAAOIQCoUUDAZjny9VRY8dO1bNzc1qbW3V888/r4qKCu3Zs8d0oiZJAwA8IVnt7nO7tc0YMGCArrrqKklScXGxGhsbtXr1aq1bt87UfJI0AMAbHPAWrGg0qnA4bPr7JGkAAHrB0qVLVVZWpoKCArW3t2vTpk1qaGhQfX296XOQpAEAnpDqV1W2tLTorrvu0gcffKDs7GwVFRWpvr5es2fPNn0OkjQAwBtS/FjQp556ysLFzuIWLAAAHIpKGgDgCaludycDSRoA4A1R4+ywMj/FSNIAAG/gVZUAACBZqKQBAJ7gk8U16aRFYh5JGgDgDQ544li8aHcDAOBQVNIAAE/gFiwAAJyK3d0AACBZqKQBAJ7gMwz5LGz+sjI3UX0iSUd++458vv52h+FoAY21OwSXGGR3AC6RbncArtChgN0hOF70VAr/7o5+NqzMTzHa3QAAOFSfqKQBALgc2t0AADiVC3d3k6QBAN7AE8cAAECyUEkDADyBJ44BAOBUtLsBAECyUEkDADzBFz07rMxPNZI0AMAbaHcDAIBkoZIGAHgDDzMBAMCZ3PhYUNrdAAA4FJU0AMAbXLhxjCQNAPAGQ9beCc2aNAAAvYM1aQAAkDRU0gAAbzBkcU06aZGYRpIGAHiDCzeO0e4GAMChqKQBAN4QleSzOD/FqKQBAJ5wbne3lRGP2tpaTZkyRYFAQLm5uZo3b56OHDkS1zlI0gAA9II9e/aoqqpK+/fv165du3T69GnNmTNHnZ2dps9BuxsA4A0p3ji2c+fObp83bNig3NxcNTU1acaMGabOQZIGAHiDzbu7W1tbJUk5OTmm55CkAQCIQ1tbW7fPfr9ffr//knOi0aiqq6s1ffp0TZw40fS1WJMGAHjDuUraypCUn5+v7Ozs2Kitrb3spauqqvTmm29q8+bNcYVMJQ0A8IYk3YIVCoUUDAZjhy9XRS9evFjbt2/X3r17NXLkyLguSZIGAHhCsl6wEQwGuyXpizEMQ/fcc4+2bt2qhoYGjR49Ou5rkqQBAOgFVVVV2rRpk7Zt26ZAIKATJ05IkrKzs5WZmWnqHI5Yk167dq1GjRqljIwMTZ06VQcOHLA7JABAX5OkNWmz6urq1NraqlmzZmnEiBGxsWXLFtPnsL2S3rJli2pqavTEE09o6tSpWrVqlW655RYdOXJEubm5docHAOgroobks3AbVTS+uUYSXshheyX9+OOP69vf/rYqKys1fvx4PfHEE7riiiv0i1/8wu7QAACwla1JuqurS01NTSotLY0dS0tLU2lpqV5//XUbIwMA9Dkpbncng63t7j/96U+KRCIaNmxYt+PDhg3T22+/fcH3w+GwwuFw7PPnbygHAODirCZa3id9SbW1td1uIM/Pz7c7JAAAeo2tSfrKK69Uenq6Tp482e34yZMnNXz48Au+v3TpUrW2tsZGKBRKVagAALdzYbvb1iQ9YMAAFRcXa/fu3bFj0WhUu3fvVklJyQXf9/v9sZvIzd5MDgCApLO7s62OFLP9FqyamhpVVFRo8uTJuv7667Vq1Sp1dnaqsrLS7tAAALCV7Un6jjvu0Icffqhly5bpxIkTuvbaa7Vz584LNpMBAGCJET07rMxPMduTtHT24eOLFy+2OwwAQF9m8/ukE+GIJA0AQK+LGrJ0G5UNa9KuugULAAAvoZIGAHgD7W4AABzKkMUknbRITKPdDQCAQ1FJAwC8gXY3AAAOFY1KsnCvczT190nT7gYAwKGopAEA3kC7GwAAh3JhkqbdDQCAQ1FJAwC8wYWPBSVJAwA8wTCiMiy8ycrK3ESRpAEA3mAY1qph1qQBAMA5VNIAAG8wLK5JcwsWAAC9JBqVfBbWlW1Yk6bdDQCAQ1FJAwC8gXY3AADOZESjMiy0u+24BYt2NwAADkUlDQDwBtrdAAA4VNSQfO5K0rS7AQBwKCppAIA3GIYkK/dJ0+4GAKBXGFFDhoV2t0G7GwCAXmJErY847N27V3PnzlVeXp58Pp9efPHFuEMmSQMA0As6Ozt1zTXXaO3atQmfg3Y3AMATUt3uLisrU1lZWcLXk0jSAACvMKKytnEs9U8cc3WSPvevmjM6ben+dC8wImG7Q3CFM6dP2R2CK0TC6XaH4ArRU6n/S91toqfO/j+Xik1ZVnPFGZ2WJLW1tXU77vf75ff7rYR2Ua5O0u3t7ZKkfXrZ5khc4Ld2B+AS/J4AW7S3tys7O7tXzj1gwAANHz5c+05YzxVZWVnKz8/vdmz58uVasWKF5XP3xNVJOi8vT6FQSIFAQD6fz+5wJJ39F1Z+fr5CoZCCwaDd4TgWvydz+D2Zw+/JHCf+ngzDUHt7u/Ly8nrtGhkZGTp27Ji6urosn8swjAvyTW9V0ZLLk3RaWppGjhxpdxg9CgaDjvmfwMn4PZnD78kcfk/mOO331FsV9PkyMjKUkZHR69dJNlcnaQAAnKqjo0NHjx6NfT527Jiam5uVk5OjgoICU+cgSQMA0AsOHjyoG2+8Mfa5pqZGklRRUaENGzaYOgdJOsn8fr+WL1/eq2sUfQG/J3P4PZnD78kcfk+pNWvWLMu71n2GHQ8jBQAAl8VjQQEAcCiSNAAADkWSBgDAoUjSAAA4FEk6ydauXatRo0YpIyNDU6dO1YEDB+wOyVGS8X5VL6itrdWUKVMUCASUm5urefPm6ciRI3aH5Th1dXUqKiqKPZyjpKREO3bssDssR1u5cqV8Pp+qq6vtDgUmkKSTaMuWLaqpqdHy5ct16NAhXXPNNbrlllvU0tJid2iOkYz3q3rBnj17VFVVpf3792vXrl06ffq05syZo87OTrtDc5SRI0dq5cqVampq0sGDB3XTTTfptttu01tvvWV3aI7U2NiodevWqaioyO5QYBK3YCXR1KlTNWXKFK1Zs0aSFI1GlZ+fr3vuuUcPPPCAzdE5j8/n09atWzVv3jy7Q3G8Dz/8ULm5udqzZ49mzJhhdziOlpOTo8cee0zf/OY37Q7FUTo6OjRp0iT97Gc/049+9CNde+21WrVqld1h4TKopJOkq6tLTU1NKi0tjR1LS0tTaWmpXn/9dRsjQ1/Q2toq6WwCQs8ikYg2b96szs5OlZSU2B2O41RVVam8vLzb31FwPp44liR/+tOfFIlENGzYsG7Hhw0bprffftumqNAXRKNRVVdXa/r06Zo4caLd4TjO4cOHVVJSolOnTikrK0tbt27V+PHj7Q7LUTZv3qxDhw6psbHR7lAQJ5I04HBVVVV68803tW/fPrtDcaSxY8equblZra2tev7551VRUaE9e/aQqD8TCoV07733ateuXa58C5TXkaST5Morr1R6erpOnjzZ7fjJkyc1fPhwm6KC2y1evFjbt2/X3r17HftaVrsNGDBAV111lSSpuLhYjY2NWr16tdatW2dzZM7Q1NSklpYWTZo0KXYsEolo7969WrNmjcLhsNLT022MEJfCmnSSDBgwQMXFxdq9e3fsWDQa1e7du1kfQ9wMw9DixYu1detWvfrqqxo9erTdIblGNBpVOBy2OwzHuPnmm3X48GE1NzfHxuTJk7VgwQI1NzeToB2OSjqJampqVFFRocmTJ+v666/XqlWr1NnZqcrKSrtDc4xkvF/VC6qqqrRp0yZt27ZNgUBAJ06ckCRlZ2crMzPT5uicY+nSpSorK1NBQYHa29u1adMmNTQ0qL6+3u7QHCMQCFywl2HgwIEaMmQIexxcgCSdRHfccYc+/PBDLVu2TCdOnNC1116rnTt3XrCZzMuS8X5VL6irq5N09lV351u/fr0WLlyY+oAcqqWlRXfddZc++OADZWdnq6ioSPX19Zo9e7bdoQFJwX3SAAA4FGvSAAA4FEkaAACHIkkDAOBQJGkAAByKJA0AgEORpAEAcCiSNAAADkWSBgDAoUjSgIMtXLhQ8+bNszsMADYhSQMA4FAkaQAAHIokDQCAQ5GkAQBwKJI0AAAORZIGAMChSNIAADgUSRoAAIciSQMA4FA+wzAMu4MAAAAXopIGAMChSNIAADgUSRoAAIciSQMA4FAkaQAAHIokDQCAQ5GkAQBwKJI0AAAORZIGAMChSNIAADgUSRoAAIciSQMA4FD/HwWTrr6jbFwEAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Plotting values of qty_in at K = 0\")\n", + "plot_field_at_kN(qty_in.data)\n", + "print(\"Plotting values of qty_out at K = 0\")\n", + "plot_field_at_kN(qty_out.data)\n", + "print(\"Executing `copy_stencil`\")\n", + "copy_stencil(qty_in, qty_out)\n", + "print(\"Plotting qty_out from `copy_stencil` at K = 0\")\n", + "plot_field_at_kN(qty_out.data)\n", + "print(\"Plotting qty_out from `copy_stencil` at K = 1\")\n", + "plot_field_at_kN(qty_out.data,1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Setting domain subsets in a stencil call**\n", + "\n", + "GT4Py also allows a subset to be specified from a stencil call and executed in a fashion similar to using `interval(...)` in the K interval. This is done by setting the stencil call's `origin` and `domain` argument.\n", + "\n", + "- `origin` : This specifies the \"starting\" coordinate to perform computations. \n", + "\n", + "- `domain` : This specifies the range of the stencil computation based on `origin` as the \"starting\" coordinate (Note: May need to check whether this affects `interval()`)\n", + "\n", + "If these two parameters are not set, the stencil call by default will iterate over the entire input domain. The following demonstrates the effect of specifying different `origin` and `domain`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_in at K = 0\n", + "Min and max values: 8.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_out at K = 0\n", + "Min and max values: 0.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing `copy_stencil` with origin=(1,0,0)\n", + "Plotting qty_out at K = 0 based on `copy_stencil` with origin=(1,0,0)\n", + "Min and max values: 8.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Resetting qty_out to zero...\n", + "Plotting values of qty_out at K = 0\n", + "Min and max values: 0.0 0.0\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhMAAAHHCAYAAAAF5NqAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA/8UlEQVR4nO3deXRU9f3/8dckkIQlkxAgCZGwVcuiLJJAiLWyJBoUrXyJp0Djl8UU/LUEheAClgIubbAqi4JEK7iVfEGsYkVEY1Lgq0SWYFqhkKP9aonABCwlIaFZyNzfHzRTp5lAkpthktzn45x7ZO79fD73c8ej8+b9Wa7NMAxDAAAATeTn6w4AAIDWjWACAACYQjABAABMIZgAAACmEEwAAABTCCYAAIApBBMAAMAUggkAAGAKwQQAADCFYAKWtnPnTtlsNu3cudPXXQGAVotgAm3SK6+8IpvN5jqCgoL0/e9/X2lpaSouLm6We2zfvl3Lli1rlra+KysrS6tWrWpw+T59+uj222+vc/7111+Xv7+/xo8fr4qKimbs4aUdP35cP/7xjxUaGiq73a4777xT//d//3fF7g/gymvn6w4A3vTYY4+pb9++qqio0Mcff6x169Zp+/btOnTokDp27Giq7e3bt2vt2rXNHlBkZWXp0KFDmjdvXpPb2Lhxo2bMmKHExERt3bpVQUFBzdfBSygrK9PYsWNVUlKiRx55RO3bt9fKlSs1evRoFRQUqGvXrlekHwCuLIIJtGm33nqrYmNjJUk//elP1bVrV61YsULvvPOOpk6d6uPeecemTZs0ffp0jRs3Tu+8884VCyQk6fnnn9cXX3yhffv2acSIEZIu/ju47rrr9Mwzz+jXv/71FesLgCuHYQ5Yyrhx4yRJX3311SXLbdmyRTExMerQoYO6deumu+++W8ePH3ddnzFjhtauXStJbsMpl/LOO+9owoQJioqKUmBgoL73ve/p8ccfV01NjavMmDFj9N577+lvf/ubq80+ffo0+PneeOMN3X333RozZoz+8Ic/XNFAQpLefPNNjRgxwhVISNKAAQOUkJCgN95444r2BcCVQ2YClvLXv/5Vki6Zbn/llVc0c+ZMjRgxQhkZGSouLtbq1av1ySef6LPPPlNoaKjuvfdenThxQtnZ2Xr99dcbdO9XXnlFnTt3Vnp6ujp37qzc3FwtWbJEpaWleuqppyRJv/jFL1RSUqJvvvlGK1eulCR17ty5Qe3//ve/V0pKim666Sa9++676tChQ4PqlZWVNWhORfv27RUSElLvdafTqT//+c+655576lwbOXKkPvzwQ507d07BwcEN6heAVsQA2qCXX37ZkGR89NFHxunTp42ioiJj06ZNRteuXY0OHToY33zzjWEYhvHHP/7RkGT88Y9/NAzDMKqqqozw8HDjuuuuM/75z3+62tu2bZshyViyZInr3Jw5c4zG/Cd0/vz5Oufuvfdeo2PHjkZFRYXr3IQJE4zevXs3uN3evXsbUVFRRrt27YwxY8YY5eXlDa5rGIYxffp0Q9Jlj9GjR1+yndOnTxuSjMcee6zOtbVr1xqSjKNHjzaqbwBaBzITaNMSExPdPvfu3VsbN27UVVdd5bH8gQMHdOrUKS1btsxtiGDChAkaMGCA3nvvPT366KNN6st3MwXnzp1TZWWlfvjDH+qFF17Q0aNHNXTo0Ca1K0lnzpzRhQsX1LNnzwZnJGo99NBDuvvuuy9brkuXLpe8/s9//lOSFBgYWOda7XdZWwZA20IwgTZt7dq1+v73v6927dopIiJC/fv3l59f/VOF/va3v0mS+vfvX+fagAED9PHHHze5L4cPH9bixYuVm5ur0tJSt2slJSVNbleSEhIS1KtXL61bt05hYWFavXp1g+sOGjRIgwYNMnV/6d/BUmVlZZ1rtcMojQ10ALQOBBNo00aOHOlazeFLZ8+e1ejRo2W32/XYY4/pe9/7noKCgnTw4EE9/PDDcjqdpu+xZs0a/eMf/9Czzz6rLl26NHjJaklJSYMyBgEBAQoLC6v3elhYmAIDA3Xy5Mk612rPRUVFNahPAFoXggngO3r37i1JKiwsdK38qFVYWOi6Lumyqze+a+fOnfr73/+ut956SzfddJPrvKdVJY1p97v8/Pz02muvqaSkRI8++qjCwsJ03333Xbbe/fffr1dfffWy5UaPHn3JnUL9/Pw0ePBgHThwoM61vXv3ql+/fky+BNooggngO2JjYxUeHq7MzEzdc889rvH/999/X0eOHNGSJUtcZTt16iTpYtYhNDT0ku36+/tLkgzDcJ2rqqrS888/X6dsp06dmjzs0b59e7355pu65ZZbNG/ePHXp0kX//d//fck6zTVnQpLuuusuLVy4UAcOHHBlhAoLC5Wbm6sHHnigYQ8BoNUhmAC+o3379nryySc1c+ZMjR49WlOnTnUtDe3Tp4/mz5/vKhsTEyNJuu+++5SUlCR/f39NmTLFY7s33HCDunTpounTp+u+++6TzWbT66+/7hZcfLfdzZs3Kz09XSNGjFDnzp11xx13NPgZOnbsqPfee0+jR4/WPffco5CQEP3oRz+qt3xzzZmQpJ///Of67W9/qwkTJuiBBx5Q+/bttWLFCkVERGjBggXNcg8ALZCvl5MA3lC7NHT//v2XLPefS0Nrbd682bj++uuNwMBAIywszEhJSXEtJ6114cIFY+7cuUb37t0Nm8122WWin3zyiTFq1CijQ4cORlRUlPHQQw8ZH3zwQZ37l5WVGT/5yU+M0NBQQ9Jll4n27t3bmDBhQp3zDofDuPrqq42goKA6z+dNRUVFxl133WXY7Xajc+fOxu2332588cUXV+z+AK48m2F4+KsRAABAA7GdNgAAMIVgAgAAmEIwAQAATCGYAADAi9auXas+ffooKChIcXFx2rdvX71lDx8+rOTkZPXp00c2m02rVq1qUpsVFRWaM2eOunbtqs6dOys5OVnFxcXN+VhuCCYAAPCS2mXeS5cu1cGDBzV06FAlJSXp1KlTHsufP39e/fr10/LlyxUZGdnkNufPn693331XW7Zs0a5du3TixAlNmjTJK88oSazmAADAS+Li4jRixAitWbNGkuR0OhUdHa25c+dq4cKFl6zbp08fzZs3T/PmzWtUmyUlJerevbuysrJ01113SZKOHj2qgQMHKi8vT6NGjWr252zVm1Y5nU6dOHFCwcHBTd6CGADgO4Zh6Ny5c4qKirrkS/jMqqioUFVVlel2DMOo83sTGBjo8W25VVVVys/P16JFi1zn/Pz8lJiYqLy8vCbdvyFt5ufnq7q62u2tyQMGDFCvXr0IJjw5ceKEoqOjfd0NAIBJRUVF6tmzp1farqioUN/eneU4VWO6rc6dO6usrMzt3NKlSz2+WO/bb79VTU2NIiIi3M5HRETo6NGjTbp/Q9p0OBwKCAios81/RESEHA5Hk+57Oa06mKh9aVDPZYvlFxTk494AABrLWVGhb5Y94dWXwFVVVclxqkZ/y+8je3DTsx+l55zqHfO1ioqKZLfbXec9ZSWsplUHE7WpJr+gIIIJAGjFrsRQdedgmzoHN/0+Tl2sa7fb3YKJ+nTr1k3+/v51VlEUFxfXO7myOdqMjIxUVVVVnZcQmrnv5bCaAwBgCTWG0/TRGAEBAYqJiVFOTo7rnNPpVE5OjuLj45v0DA1pMyYmRu3bt3crU1hYqGPHjjX5vpfTqjMTAAA0lFOGnGr6Asam1E1PT9f06dMVGxurkSNHatWqVSovL9fMmTMlSdOmTdNVV12ljIwMSReHZP7yl7+4/nz8+HEVFBSoc+fOuvrqqxvUZkhIiFJTU5Wenq6wsDDZ7XbNnTtX8fHxXpl8KRFMAADgNZMnT9bp06e1ZMkSORwODRs2TDt27HBNoDx27JjbKpYTJ07o+uuvd31++umn9fTTT2v06NHauXNng9qUpJUrV8rPz0/JycmqrKxUUlKSnn/+ea89Z6veZ6K0tFQhISHqtfwJ5kwAQCvkrKjQsYWLVVJS0qB5CE1R+1txorCn6QmYUf2/8WpfWysyEwAAS6gxDNWY+PuzmbptHRMwAQCAKWQmAACW4IsJmFZBMAEAsASnDNUQTHgFwxwAAMAUMhMAAEtgmMN7CCYAAJbAag7vYZgDAACYQmYCAGAJzn8dZurDM4IJAIAl1JhczWGmbltHMAEAsIQa4+Jhpj48Y84EAAAwhcwEAMASmDPhPQQTAABLcMqmGtlM1YdnDHMAAABTyEwAACzBaVw8zNSHZwQTAABLqDE5zGGmblvHMAcAADCFzAQAwBLITHgPwQQAwBKchk1Ow8RqDhN12zqGOQAAgClkJgAAlsAwh/cQTAAALKFGfqoxkZCvaca+tDUEEwAASzBMzpkwmDNRL+ZMAAAAU8hMAAAsgTkT3tNiMhPLly+XzWbTvHnzfN0VAEAbVGP4mT7gWYv4Zvbv368XXnhBQ4YM8XVXAABAI/k8mCgrK1NKSop++9vfqkuXLr7uDgCgjXLKJqf8TBwMc9TH58HEnDlzNGHCBCUmJl62bGVlpUpLS90OAAAaonbOhJkDnvl0AuamTZt08OBB7d+/v0HlMzIy9Oijj3q5VwAAoDF8lpkoKirS/fffr40bNyooKKhBdRYtWqSSkhLXUVRU5OVeAgDaCiZgeo/PMhP5+fk6deqUhg8f7jpXU1Oj3bt3a82aNaqsrJS/v79bncDAQAUGBl7prgIA2oCLcyZMvOiLYY56+SyYSEhI0Oeff+52bubMmRowYIAefvjhOoEEAABomXwWTAQHB+u6665zO9epUyd17dq1znkAAMxymnw3h1NGM/ambWEACABgCb6aM7F27Vr16dNHQUFBiouL0759+y5ZfsuWLRowYICCgoI0ePBgbd++3e26zWbzeDz11FOuMn369Klzffny5U3qf0O0qO20d+7c6esuAADaqNr9Ippev/GZic2bNys9PV2ZmZmKi4vTqlWrlJSUpMLCQoWHh9cpv2fPHk2dOlUZGRm6/fbblZWVpYkTJ+rgwYOurP3Jkyfd6rz//vtKTU1VcnKy2/nHHntMs2bNcn0ODg5udP8biswEAABesmLFCs2aNUszZ87UoEGDlJmZqY4dO2rDhg0ey69evVrjx4/Xgw8+qIEDB+rxxx/X8OHDtWbNGleZyMhIt+Odd97R2LFj1a9fP7e2goOD3cp16tTJa89JMAEAsIQaw2b6kFRn88TKykqP96uqqlJ+fr7bpox+fn5KTExUXl6exzp5eXl1NnFMSkqqt3xxcbHee+89paam1rm2fPlyde3aVddff72eeuopXbhwoUHfU1O0qGEOAAC8pcbkBMyafw1zREdHu51funSpli1bVqf8t99+q5qaGkVERLidj4iI0NGjRz3ew+FweCzvcDg8ln/11VcVHBysSZMmuZ2/7777NHz4cIWFhWnPnj1atGiRTp48qRUrVlzyGZuKYAIAgEYoKiqS3W53ffbl/kcbNmxQSkpKnc0f09PTXX8eMmSIAgICdO+99yojI8Mr/SWYAABYgtPwk9PELpZO42Jmwm63uwUT9enWrZv8/f1VXFzsdr64uFiRkZEe60RGRja4/P/+7/+qsLBQmzdvvmxf4uLidOHCBX399dfq37//Zcs3FnMmAACWUDvMYeZojICAAMXExCgnJ8d1zul0KicnR/Hx8R7rxMfHu5WXpOzsbI/l169fr5iYGA0dOvSyfSkoKJCfn5/HFSTNgcwEAABekp6erunTpys2NlYjR47UqlWrVF5erpkzZ0qSpk2bpquuukoZGRmSpPvvv1+jR4/WM888owkTJmjTpk06cOCAXnzxRbd2S0tLtWXLFj3zzDN17pmXl6e9e/dq7NixCg4OVl5enubPn6+7775bXbp08cpzEkwAACzBKblWZDS1fmNNnjxZp0+f1pIlS+RwODRs2DDt2LHDNcny2LFj8vP7d8bjhhtuUFZWlhYvXqxHHnlE11xzjbZu3VpnZ+hNmzbJMAxNnTq1zj0DAwO1adMmLVu2TJWVlerbt6/mz5/vNo+iudkMw2i1+4OWlpYqJCREvZY/Ib8GvnkUANByOCsqdGzhYpWUlDRoHkJT1P5WrDs4Qh06N/3v0P8su6CfDd/v1b62VsyZAAAApjDMAQCwBDPv16itD88IJgAAluCUTU6ZmTPR9LptHcEEAMASyEx4D98MAAAwhcwEAMASzL+bg79/14dgAgBgCU7DJqeZfSZM1G3rCLMAAIApZCYAAJbgNDnM4eTv3/UimAAAWIL5t4YSTNSHbwYAAJhCZgIAYAk1sqnGxMZTZuq2dQQTAABLYJjDe/hmAACAKWQmAACWUCNzQxU1zdeVNodgAgBgCQxzeA/BBADAEnjRl/fwzQAAAFPITAAALMGQTU4TcyYMlobWi2ACAGAJDHN4D98MAAAwhcwEAMASeAW59xBMAAAsocbkW0PN1G3r+GYAAIApZCYAAJbAMIf3EEwAACzBKT85TSTkzdRt6/hmAACAKWQmAACWUGPYVGNiqMJM3baOYAIAYAnMmfAeggkAgCUYJt8aarADZr34ZgAAgClkJgAAllAjm2pMvKzLTN22jmACAGAJTsPcvAen0YydaWMY5gAAAKaQmQAAWILT5ARMM3XbOr4ZAIAlOGUzfTTF2rVr1adPHwUFBSkuLk779u27ZPktW7ZowIABCgoK0uDBg7V9+3a36zNmzJDNZnM7xo8f71bmzJkzSklJkd1uV2hoqFJTU1VWVtak/jcEwQQAAF6yefNmpaena+nSpTp48KCGDh2qpKQknTp1ymP5PXv2aOrUqUpNTdVnn32miRMnauLEiTp06JBbufHjx+vkyZOu43/+53/crqekpOjw4cPKzs7Wtm3btHv3bs2ePdtrz0kwAQCwhNodMM0cjbVixQrNmjVLM2fO1KBBg5SZmamOHTtqw4YNHsuvXr1a48eP14MPPqiBAwfq8ccf1/Dhw7VmzRq3coGBgYqMjHQdXbp0cV07cuSIduzYoZdeeklxcXG68cYb9dxzz2nTpk06ceJEo5+hIQgmAACWUDtnwszRGFVVVcrPz1diYqLrnJ+fnxITE5WXl+exTl5enlt5SUpKSqpTfufOnQoPD1f//v31s5/9TH//+9/d2ggNDVVsbKzrXGJiovz8/LR3795GPUNDMQETAIBGKC0tdfscGBiowMDAOuW+/fZb1dTUKCIiwu18RESEjh496rFth8PhsbzD4XB9Hj9+vCZNmqS+ffvqr3/9qx555BHdeuutysvLk7+/vxwOh8LDw93aaNeuncLCwtzaaU4EEwAAS3DK5Ls5/jUBMzo62u380qVLtWzZMjNda5QpU6a4/jx48GANGTJE3/ve97Rz504lJCRcsX58F8EEAMASDBMrMmrrS1JRUZHsdrvrvKeshCR169ZN/v7+Ki4udjtfXFysyMhIj3UiIyMbVV6S+vXrp27duunLL79UQkKCIiMj60zwvHDhgs6cOXPJdsxgzgQAwBJq3xpq5pAku93udtQXTAQEBCgmJkY5OTn/7oPTqZycHMXHx3usEx8f71ZekrKzs+stL0nffPON/v73v6tHjx6uNs6ePav8/HxXmdzcXDmdTsXFxTXsy2okggkAALwkPT1dv/3tb/Xqq6/qyJEj+tnPfqby8nLNnDlTkjRt2jQtWrTIVf7+++/Xjh079Mwzz+jo0aNatmyZDhw4oLS0NElSWVmZHnzwQX366af6+uuvlZOTozvvvFNXX321kpKSJEkDBw7U+PHjNWvWLO3bt0+ffPKJ0tLSNGXKFEVFRXnlORnmAABYgi92wJw8ebJOnz6tJUuWyOFwaNiwYdqxY4drkuWxY8fk5/fvdm+44QZlZWVp8eLFeuSRR3TNNddo69atuu666yRJ/v7++vOf/6xXX31VZ8+eVVRUlG655RY9/vjjbhmSjRs3Ki0tTQkJCfLz81NycrKeffbZJj/75dgMw2i1ry4pLS1VSEiIei1/Qn5BQb7uDgCgkZwVFTq2cLFKSkrc5iE0p9rfijs/vEftOwU0uZ3q8iq9c8sGr/a1tWKYAwAAmMIwBwDAEsy8X6O2PjwjmAAAWMJ3V2Q0tT48Y5gDAACYQmYCAGAJZCa8h2ACAGAJBBPewzAHAAAwhcwEAMASyEx4j08zE+vWrdOQIUNc+5vHx8fr/fff92WXAABtlKF/Lw9tytFqd3i8AnyamejZs6eWL1+ua665RoZh6NVXX9Wdd96pzz77TNdee60vuwYAaGPITHiPT4OJO+64w+3zr371K61bt06ffvopwQQAAK1Ei5kzUVNToy1btqi8vLzeV61WVlaqsrLS9bm0tPRKdQ8A0MqRmfAenwcTn3/+ueLj41VRUaHOnTvr7bff1qBBgzyWzcjI0KOPPnqFewgAaAsIJrzH50tD+/fvr4KCAu3du1c/+9nPNH36dP3lL3/xWHbRokUqKSlxHUVFRVe4twAA4D/5PDMREBCgq6++WpIUExOj/fv3a/Xq1XrhhRfqlA0MDHR7XzsAAA1FZsJ7fB5M/Cen0+k2LwIAgOZgGDYZJgICM3XbOp8GE4sWLdKtt96qXr166dy5c8rKytLOnTv1wQcf+LJbAACgEXwaTJw6dUrTpk3TyZMnFRISoiFDhuiDDz7QzTff7MtuAQDaoNrNp8zUh2c+DSbWr1/vy9sDACyEORPe4/PVHAAAoHVrcRMwAQDwBiZgeg/BBADAEhjm8B6CCQCAJZCZ8B7mTAAAAFPITAAALMEwOcxBZqJ+BBMAAEswJBmGufrwjGEOAABgCpkJAIAlOGWTjR0wvYJgAgBgCazm8B6GOQAAgClkJgAAluA0bLKxaZVXEEwAACzBMEyu5mA5R70Y5gAAAKaQmQAAWAITML2HYAIAYAkEE97DMAcAwBJq3xpq5miKtWvXqk+fPgoKClJcXJz27dt3yfJbtmzRgAEDFBQUpMGDB2v79u2ua9XV1Xr44Yc1ePBgderUSVFRUZo2bZpOnDjh1kafPn1ks9ncjuXLlzep/w1BMAEAgJds3rxZ6enpWrp0qQ4ePKihQ4cqKSlJp06d8lh+z549mjp1qlJTU/XZZ59p4sSJmjhxog4dOiRJOn/+vA4ePKhf/vKXOnjwoN566y0VFhbqRz/6UZ22HnvsMZ08edJ1zJ0712vPSTABALCE2tUcZo7GWrFihWbNmqWZM2dq0KBByszMVMeOHbVhwwaP5VevXq3x48frwQcf1MCBA/X4449r+PDhWrNmjSQpJCRE2dnZ+vGPf6z+/ftr1KhRWrNmjfLz83Xs2DG3toKDgxUZGek6OnXq1PgHaCCCCQCAJVwMCGwmjsbdr6qqSvn5+UpMTHSd8/PzU2JiovLy8jzWycvLcysvSUlJSfWWl6SSkhLZbDaFhoa6nV++fLm6du2q66+/Xk899ZQuXLjQuAdoBCZgAgDQCKWlpW6fAwMDFRgYWKfct99+q5qaGkVERLidj4iI0NGjRz227XA4PJZ3OBwey1dUVOjhhx/W1KlTZbfbXefvu+8+DR8+XGFhYdqzZ48WLVqkkydPasWKFQ16xsYimAAAWEJzreaIjo52O7906VItW7bMTNeapLq6Wj/+8Y9lGIbWrVvndi09Pd315yFDhiggIED33nuvMjIyPAY+ZhFMAAAswfjXYaa+JBUVFbllAer7ce7WrZv8/f1VXFzsdr64uFiRkZEe60RGRjaofG0g8be//U25ublu/fEkLi5OFy5c0Ndff63+/ftfsmxTMGcCAIBGsNvtbkd9wURAQIBiYmKUk5PjOud0OpWTk6P4+HiPdeLj493KS1J2drZb+dpA4osvvtBHH32krl27XrbPBQUF8vPzU3h4eEMesdHITAAALMEXm1alp6dr+vTpio2N1ciRI7Vq1SqVl5dr5syZkqRp06bpqquuUkZGhiTp/vvv1+jRo/XMM89owoQJ2rRpkw4cOKAXX3xR0sVA4q677tLBgwe1bds21dTUuOZThIWFKSAgQHl5edq7d6/Gjh2r4OBg5eXlaf78+br77rvVpUuXJj//pRBMAACsobnGORph8uTJOn36tJYsWSKHw6Fhw4Zpx44drkmWx44dk5/fvwcJbrjhBmVlZWnx4sV65JFHdM0112jr1q267rrrJEnHjx/XH/7wB0nSsGHD3O71xz/+UWPGjFFgYKA2bdqkZcuWqbKyUn379tX8+fPd5lE0N5thtN73oJWWliokJES9lj8hv6AgX3cHANBIzooKHVu4WCUlJZcd92+q2t+Kfq/8Qn4dm/5b4Txfof+b8Suv9rW1Ys4EAAAwhWEOAIAlNHUXy+/Wh2cEEwAAS+Ctod7DMAcAADCFzAQAwBoM28XDTH14RDABALAE5kx4D8McAADAFDITAABr8MGmVVZBMAEAsARWc3gPwxwAAMAUMhMAAOtgqMIrCCYAAJbAMIf3EEwAAKyBCZhew5wJAABgCpkJAIBF2P51mKkPTwgmAADWwDCH1zDMAQAATCEzAQCwBjITXkMwAQCwBt4a6jUMcwAAAFPITAAALIFXkHsPwQQAwBqYM+E1DHMAAABTyEwAAKyBCZheQzABALAEm3HxMFMfnhFMAACsgTkTXsOcCQAAYAqZCQCANTBnwmsIJgAA1sAwh9cwzAEAAEwhMwEAsAYyE15DMAEAsAaCCa9hmAMAAJhCZgIAYA2s5vAaggkAgCWwA6b3MMwBAABM8WkwkZGRoREjRig4OFjh4eGaOHGiCgsLfdklAEBbZTTD0QRr165Vnz59FBQUpLi4OO3bt++S5bds2aIBAwYoKChIgwcP1vbt290fwzC0ZMkS9ejRQx06dFBiYqK++OILtzJnzpxRSkqK7Ha7QkNDlZqaqrKysqY9QAP4NJjYtWuX5syZo08//VTZ2dmqrq7WLbfcovLycl92CwCAZrF582alp6dr6dKlOnjwoIYOHaqkpCSdOnXKY/k9e/Zo6tSpSk1N1WeffaaJEydq4sSJOnTokKvMb37zGz377LPKzMzU3r171alTJyUlJamiosJVJiUlRYcPH1Z2dra2bdum3bt3a/bs2V57TpthGC1mFOj06dMKDw/Xrl27dNNNN122fGlpqUJCQtRr+RPyCwq6Aj0EADQnZ0WFji1crJKSEtntdq/co/a3oveT5n4rnBUV+tvDjetrXFycRowYoTVr1lxsw+lUdHS05s6dq4ULF9YpP3nyZJWXl2vbtm2uc6NGjdKwYcOUmZkpwzAUFRWlBQsW6IEHHpAklZSUKCIiQq+88oqmTJmiI0eOaNCgQdq/f79iY2MlSTt27NBtt92mb775RlFRUU3+DurToAmYkyZNunxD7dopMjJSN998s+64444mdaakpESSFBYW5vF6ZWWlKisrXZ9LS0ubdB8AAJrqP397AgMDFRgYWKdcVVWV8vPztWjRItc5Pz8/JSYmKi8vz2PbeXl5Sk9PdzuXlJSkrVu3SpK++uorORwOJSYmuq6HhIQoLi5OeXl5mjJlivLy8hQaGuoKJCQpMTFRfn5+2rt3r/7rv/6r0c98OQ0a5ggJCbns0aFDB33xxReaPHmylixZ0uiOOJ1OzZs3Tz/4wQ903XXXeSyTkZHhds/o6OhG3wcAYFG1S0PNHJKio6PdfosyMjI83u7bb79VTU2NIiIi3M5HRETI4XB4rONwOC5ZvvaflysTHh7udr1du3YKCwur975mNSgz8fLLLze4wW3btunnP/+5HnvssUZ1ZM6cOTp06JA+/vjjesssWrTILWIrLS0loAAANEwz7YBZVFTkNszhKSthNc2+z8SNN97ollppiLS0NNcEkZ49e9Zbrr5UEgAAV4rdbm/QnIlu3brJ399fxcXFbueLi4sVGRnpsU5kZOQly9f+s7i4WD169HArM2zYMFeZ/5zgeeHCBZ05c6be+5rV7Ks5QkND9dZbbzWorGEYSktL09tvv63c3Fz17du3ubsDAMBFV3hpaEBAgGJiYpSTk+M653Q6lZOTo/j4eI914uPj3cpLUnZ2tqt83759FRkZ6VamtLRUe/fudZWJj4/X2bNnlZ+f7yqTm5srp9OpuLi4xj1EA/l0B8w5c+YoKytL77zzjoKDg11jObVzMAAAaC6+2AEzPT1d06dPV2xsrEaOHKlVq1apvLxcM2fOlCRNmzZNV111lWvexf3336/Ro0frmWee0YQJE7Rp0yYdOHBAL7744sU+2GyaN2+ennjiCV1zzTXq27evfvnLXyoqKkoTJ06UJA0cOFDjx4/XrFmzlJmZqerqaqWlpWnKlCleWckh+TiYWLdunSRpzJgxbudffvllzZgx48p3CACAZjR58mSdPn1aS5YskcPh0LBhw7Rjxw7XBMpjx47Jz+/fgwQ33HCDsrKytHjxYj3yyCO65pprtHXrVreFCQ899JDKy8s1e/ZsnT17VjfeeKN27NihoO8se924caPS0tKUkJAgPz8/JScn69lnn/Xac7aofSYai30mAKB1u5L7TPR54lem95n4evEvvNrX1ooXfQEArKGZVnOgLl70BQAATCEzAQCwBF5B7j0EEwAAa/jOLpZNrg+PCCYAANbAnAmvYc4EAAAwhcwEAMASmDPhPQQTAABrYJjDaxjmAAAAppCZAABYg8lhDjIT9SOYAABYA8McXsMwBwAAMIXMBADAGshMeA3BBADAElga6j0McwAAAFMIJgAAgCkMcwAArIE5E15DMAEAsATmTHgPwxwAAMAUMhMAAOsgu+AVBBMAAGtgzoTXMMwBAABMITMBALAEJmB6D8EEAMAaGObwGoY5AACAKWQmAACWwDCH9xBMAACsgWEOr2GYAwAAmEJmAgBgDWQmvIZgAgBgCcyZ8B6CCQCANZCZ8BrmTAAAAFPITAAArIHMhNcQTAAALIE5E97DMAcAADCFYAIAYA1GMxxecubMGaWkpMhutys0NFSpqakqKyu7ZJ2KigrNmTNHXbt2VefOnZWcnKzi4mLX9T/96U+aOnWqoqOj1aFDBw0cOFCrV692a2Pnzp2y2Wx1DofD0aj+M8wBALCEljzMkZKSopMnTyo7O1vV1dWaOXOmZs+eraysrHrrzJ8/X++99562bNmikJAQpaWladKkSfrkk08kSfn5+QoPD9fvfvc7RUdHa8+ePZo9e7b8/f2Vlpbm1lZhYaHsdrvrc3h4eKP6TzABAIAPHTlyRDt27ND+/fsVGxsrSXruued022236emnn1ZUVFSdOiUlJVq/fr2ysrI0btw4SdLLL7+sgQMH6tNPP9WoUaN0zz33uNXp16+f8vLy9NZbb9UJJsLDwxUaGtrkZ2CYAwBgDc00zFFaWup2VFZWmupWXl6eQkNDXYGEJCUmJsrPz0979+71WCc/P1/V1dVKTEx0nRswYIB69eqlvLy8eu9VUlKisLCwOueHDRumHj166Oabb3ZlNhqDYAIAYA3NFExER0crJCTEdWRkZJjqlsPhqDOs0K5dO4WFhdU7d8HhcCggIKBONiEiIqLeOnv27NHmzZs1e/Zs17kePXooMzNTv//97/X73/9e0dHRGjNmjA4ePNioZ2CYAwCARigqKnKbXxAYGOix3MKFC/Xkk09esq0jR440a9/qc+jQId15551aunSpbrnlFtf5/v37q3///q7PN9xwg/76179q5cqVev311xvcPsEEAMASbP86zNSXJLvd7hZM1GfBggWaMWPGJcv069dPkZGROnXqlNv5Cxcu6MyZM4qMjPRYLzIyUlVVVTp79qxbdqK4uLhOnb/85S9KSEjQ7NmztXjx4sv2e+TIkfr4448vW+67CCYAANZwhXfA7N69u7p3737ZcvHx8Tp79qzy8/MVExMjScrNzZXT6VRcXJzHOjExMWrfvr1ycnKUnJws6eKKjGPHjik+Pt5V7vDhwxo3bpymT5+uX/3qVw3qd0FBgXr06NGgsrUIJgAAltBSl4YOHDhQ48eP16xZs5SZmanq6mqlpaVpypQprpUcx48fV0JCgl577TWNHDlSISEhSk1NVXp6usLCwmS32zV37lzFx8dr1KhRki4ObYwbN05JSUlKT093zaXw9/d3BTmrVq1S3759de2116qiokIvvfSScnNz9eGHHzbqGQgmAADwsY0bNyotLU0JCQny8/NTcnKynn32Wdf16upqFRYW6vz5865zK1eudJWtrKxUUlKSnn/+edf1N998U6dPn9bvfvc7/e53v3Od7927t77++mtJUlVVlRYsWKDjx4+rY8eOGjJkiD766CONHTu2Uf23GYbRancbLy0tVUhIiHotf0J+QUG+7g4AoJGcFRU6tnCxSkpKGjQPoSlqfyuuvffX8g9s+m9FTWWFDr/wiFf72lqRmQAAWEer/etzy8Y+EwAAwBQyEwAAS2ipEzDbAoIJAIA1XOGloVbCMAcAADCFzAQAwBIY5vAeggkAgDUwzOE1DHMAAABTyEwAACyBYQ7vIZgAAFgDwxxeQzABALAGggmvYc4EAAAwhcwEAMASmDPhPQQTAABrYJjDaxjmAAAAppCZAABYgs0wZDOanl4wU7etI5gAAFgDwxxe49Nhjt27d+uOO+5QVFSUbDabtm7d6svuAACAJvBpMFFeXq6hQ4dq7dq1vuwGAMACaldzmDngmU+HOW699VbdeuutvuwCAMAqGObwmlY1Z6KyslKVlZWuz6WlpT7sDQAAkFrZ0tCMjAyFhIS4jujoaF93CQDQSjDM4T2tKphYtGiRSkpKXEdRUZGvuwQAaC2MZjjgUasa5ggMDFRgYKCvuwEAaIXYTtt7WlVmAgAAtDw+zUyUlZXpyy+/dH3+6quvVFBQoLCwMPXq1cuHPQMAtDms5vAanwYTBw4c0NixY12f09PTJUnTp0/XK6+84qNeAQDaKoYqvMOnwcSYMWNksNc5AACtWquagAkAQJMZxsXDTH14RDABALAEVnN4D6s5AACAKWQmAADWwGoOryGYAABYgs158TBTH54xzAEAAEwhMwEAsAaGObyGzAQAwBJa8ltDz5w5o5SUFNntdoWGhio1NVVlZWWXrFNRUaE5c+aoa9eu6ty5s5KTk1VcXOz+zDZbnWPTpk1uZXbu3Knhw4crMDBQV199dZM2jSSYAABYQ+0+E2YOL0lJSdHhw4eVnZ2tbdu2affu3Zo9e/Yl68yfP1/vvvuutmzZol27dunEiROaNGlSnXIvv/yyTp486TomTpzouvbVV19pwoQJGjt2rAoKCjRv3jz99Kc/1QcffNCo/jPMAQCADx05ckQ7duzQ/v37FRsbK0l67rnndNttt+npp59WVFRUnTolJSVav369srKyNG7cOEkXg4aBAwfq008/1ahRo1xlQ0NDFRkZ6fHemZmZ6tu3r5555hlJ0sCBA/Xxxx9r5cqVSkpKavAzkJkAAFhCcw1zlJaWuh2VlZWm+pWXl6fQ0FBXICFJiYmJ8vPz0969ez3Wyc/PV3V1tRITE13nBgwYoF69eikvL8+t7Jw5c9StWzeNHDlSGzZscHuNRV5enlsbkpSUlFSnjcshmAAAWIPRDIek6OhohYSEuI6MjAxT3XI4HAoPD3c7165dO4WFhcnhcNRbJyAgQKGhoW7nIyIi3Oo89thjeuONN5Sdna3k5GT9/Oc/13PPPefWTkRERJ02SktL9c9//rPBz8AwBwAAjVBUVCS73e76HBgY6LHcwoUL9eSTT16yrSNHjjRr3/7TL3/5S9efr7/+epWXl+upp57Sfffd16z3IZgAAFhCc72bw263uwUT9VmwYIFmzJhxyTL9+vVTZGSkTp065Xb+woULOnPmTL1zHSIjI1VVVaWzZ8+6ZSeKi4vrrSNJcXFxevzxx1VZWanAwEBFRkbWWQFSXFwsu92uDh06XPoBv4NgAgBgDVf4raHdu3dX9+7dL1suPj5eZ8+eVX5+vmJiYiRJubm5cjqdiouL81gnJiZG7du3V05OjpKTkyVJhYWFOnbsmOLj4+u9V0FBgbp06eLKpsTHx2v79u1uZbKzsy/ZhicEEwAA+NDAgQM1fvx4zZo1S5mZmaqurlZaWpqmTJniWslx/PhxJSQk6LXXXtPIkSMVEhKi1NRUpaenKywsTHa7XXPnzlV8fLxrJce7776r4uJijRo1SkFBQcrOztavf/1rPfDAA657/7//9/+0Zs0aPfTQQ7rnnnuUm5urN954Q++9916jnoFgAgBgCS35FeQbN25UWlqaEhIS5Ofnp+TkZD377LOu69XV1SosLNT58+dd51auXOkqW1lZqaSkJD3//POu6+3bt9fatWs1f/58GYahq6++WitWrNCsWbNcZfr27av33ntP8+fP1+rVq9WzZ0+99NJLjVoWKkk2w/DiLhxeVlpaqpCQEPVa/oT8goJ83R0AQCM5Kyp0bOFilZSUNGgeQlPU/lbEj39M7do3/bfiQnWF8nYs8WpfWyuWhgIAAFMY5gAAWEJLHuZo7QgmAADW4DQuHmbqwyOCCQCANfAKcq9hzgQAADCFzAQAwBJsMjlnotl60vYQTAAArOEK74BpJQxzAAAAU8hMAAAsgaWh3kMwAQCwBlZzeA3DHAAAwBQyEwAAS7AZhmwmJlGaqdvWEUwAAKzB+a/DTH14xDAHAAAwhcwEAMASGObwHoIJAIA1sJrDawgmAADWwA6YXsOcCQAAYAqZCQCAJbADpvcQTAAArIFhDq9hmAMAAJhCZgIAYAk258XDTH14RjABALAGhjm8hmEOAABgCpkJAIA1sGmV1xBMAAAsge20vYdhDgAAYAqZCQCANTAB02sIJgAA1mBIMrO8k1iiXgQTAABLYM6E9zBnAgAAmEJmAgBgDYZMzplotp60OQQTAABrYAKm1zDMAQAATCEzAQCwBqckm8n68IjMBADAEmpXc5g5vOXMmTNKSUmR3W5XaGioUlNTVVZWdsk6FRUVmjNnjrp27arOnTsrOTlZxcXFruuvvPKKbDabx+PUqVOSpJ07d3q87nA4GtV/ggkAAHwsJSVFhw8fVnZ2trZt26bdu3dr9uzZl6wzf/58vfvuu9qyZYt27dqlEydOaNKkSa7rkydP1smTJ92OpKQkjR49WuHh4W5tFRYWupX7z+uXwzAHAMAaWugEzCNHjmjHjh3av3+/YmNjJUnPPfecbrvtNj399NOKioqqU6ekpETr169XVlaWxo0bJ0l6+eWXNXDgQH366acaNWqUOnTooA4dOrjqnD59Wrm5uVq/fn2d9sLDwxUaGtrkZyAzAQCwhtpgwszhBXl5eQoNDXUFEpKUmJgoPz8/7d2712Od/Px8VVdXKzEx0XVuwIAB6tWrl/Ly8jzWee2119SxY0fdddddda4NGzZMPXr00M0336xPPvmk0c9AZgIAgEYoLS11+xwYGKjAwMAmt+dwOOoMK7Rr105hYWH1zl1wOBwKCAiok02IiIiot8769ev1k5/8xC1b0aNHD2VmZio2NlaVlZV66aWXNGbMGO3du1fDhw9v8DOQmQAAWEMzZSaio6MVEhLiOjIyMjzebuHChfVOgKw9jh49ekUePS8vT0eOHFFqaqrb+f79++vee+9VTEyMbrjhBm3YsEE33HCDVq5c2aj2yUwAAKyhmZaGFhUVyW63u07Xl5VYsGCBZsyYcckm+/Xrp8jISNfqiloXLlzQmTNnFBkZ6bFeZGSkqqqqdPbsWbfsRHFxscc6L730koYNG6aYmJhL9keSRo4cqY8//viy5b6LYAIAYAnN9aIvu93uFkzUp3v37urevftly8XHx+vs2bPKz893/djn5ubK6XQqLi7OY52YmBi1b99eOTk5Sk5OlnRxRcaxY8cUHx/vVrasrExvvPFGvRmU/1RQUKAePXo0qGwtggkAAHxo4MCBGj9+vGbNmqXMzExVV1crLS1NU6ZMca3kOH78uBISEvTaa69p5MiRCgkJUWpqqtLT0xUWFia73a65c+cqPj5eo0aNcmt/8+bNunDhgu6+++469161apX69u2ra6+9VhUVFXrppZeUm5urDz/8sFHP0CLmTKxdu1Z9+vRRUFCQ4uLitG/fPl93CQDQ1rTQ1RyStHHjRg0YMEAJCQm67bbbdOONN+rFF190Xa+urlZhYaHOnz/vOrdy5UrdfvvtSk5O1k033aTIyEi99dZbddpev369Jk2a5HHpZ1VVlRYsWKDBgwdr9OjR+tOf/qSPPvpICQkJjeq/zTB8++aSzZs3a9q0acrMzFRcXJxWrVqlLVu2qLCw8LKbZpSWliokJES9lj8hv6CgK9RjAEBzcVZU6NjCxSopKWnQ0EFT1P5WJH5vntr5N33VxYWaSn3011Ve7Wtr5fPMxIoVKzRr1izNnDlTgwYNUmZmpjp27KgNGzb4umsAAKABfBpMVFVVKT8/323TDT8/PyUmJta76QYAAE3Sgoc5WjufTsD89ttvVVNTo4iICLfzERERHtfeVlZWqrKy0vX5PzcOAQCgfmYDAoKJ+vh8mKMxMjIy3DYKiY6O9nWXAACwPJ8GE926dZO/v7/bK1Ol+jfdWLRokUpKSlxHUVHRleoqAKC1Y5jDa3waTAQEBCgmJkY5OTmuc06nUzk5OXU23ZAu7jJWu1lIQzcNAQBAkuQ0zB/wyOebVqWnp2v69OmKjY3VyJEjtWrVKpWXl2vmzJm+7hoAAGgAnwcTkydP1unTp7VkyRI5HA4NGzZMO3bsqDMpEwAAUwznxcNMfXjk82BCktLS0pSWlubrbgAA2jKz8x6YM1GvFhFMAADgdU5DppZ3MmeiXq1qaSgAAGh5yEwAAKyBYQ6vIZgAAFiDIZPBRLP1pM1hmAMAAJhCZgIAYA0Mc3gNwQQAwBqcTkkm9opwss9EfRjmAAAAppCZAABYA8McXkMwAQCwBoIJr2GYAwAAmEJmAgBgDWyn7TUEEwAASzAMpwwTb/40U7etI5gAAFiDYZjLLjBnol7MmQAAAKaQmQAAWINhcs4EmYl6EUwAAKzB6ZRsJuY9MGeiXgxzAAAAU8hMAACsgWEOryGYAABYguF0yjAxzMHS0PoxzAEAAEwhMwEAsAaGObyGYAIAYA1OQ7IRTHgDwxwAAMAUMhMAAGswDElm9pkgM1EfggkAgCUYTkOGiWEOg2CiXgxzAACswXCaP7zkzJkzSklJkd1uV2hoqFJTU1VWVnbJOi+++KLGjBkju90um82ms2fPNqndP//5z/rhD3+ooKAgRUdH6ze/+U2j+08wAQCAj6WkpOjw4cPKzs7Wtm3btHv3bs2ePfuSdc6fP6/x48frkUceaXK7paWluuWWW9S7d2/l5+frqaee0rJly/Tiiy82qv8McwAALKGlDnMcOXJEO3bs0P79+xUbGytJeu6553Tbbbfp6aefVlRUlMd68+bNkyTt3Lmzye1u3LhRVVVV2rBhgwICAnTttdeqoKBAK1asuGww811kJgAA1tBChzny8vIUGhrq+sGXpMTERPn5+Wnv3r1ebTcvL0833XSTAgICXGWSkpJUWFiof/zjHw2+V6vOTNRGic6KCh/3BADQFLX//74SkxsvqNrUnlUXVC3p4tDAdwUGBiowMLDJ7TocDoWHh7uda9euncLCwuRwOLzarsPhUN++fd3KREREuK516dKlQfdq1cHEuXPnJEnfLHvCxz0BAJhx7tw5hYSEeKXtgIAARUZG6mPHdtNtde7cWdHR0W7nli5dqmXLltUpu3DhQj355JOXbO/IkSOm+9QStOpgIioqSkVFRQoODpbNZvN1dyRdjFijo6NVVFQku93u6+60WHxPDcP31DB8Tw3TEr8nwzB07ty5eucFNIegoCB99dVXqqqqMt2WYRh1fm/qy0osWLBAM2bMuGR7/fr1U2RkpE6dOuV2/sKFCzpz5owiIyOb3NeGtBsZGani4mK3MrWfG3PvVh1M+Pn5qWfPnr7uhkd2u73F/MfakvE9NQzfU8PwPTVMS/uevJWR+K6goCAFBQV5/T7f1b17d3Xv3v2y5eLj43X27Fnl5+crJiZGkpSbmyun06m4uLgm378h7cbHx+sXv/iFqqur1b59e0lSdna2+vfv3+AhDokJmAAA+NTAgQM1fvx4zZo1S/v27dMnn3yitLQ0TZkyxZWxOX78uAYMGKB9+/a56jkcDhUUFOjLL7+UJH3++ecqKCjQmTNnGtzuT37yEwUEBCg1NVWHDx/W5s2btXr1aqWnpzfqGQgmAADwsY0bN2rAgAFKSEjQbbfdphtvvNFtr4fq6moVFhbq/PnzrnOZmZm6/vrrNWvWLEnSTTfdpOuvv15/+MMfGtxuSEiIPvzwQ3311VeKiYnRggULtGTJkkYtC5Ukm8H+oM2qsrJSGRkZWrRokanZvW0d31PD8D01DN9Tw/A9wVsIJgAAgCkMcwAAAFMIJgAAgCkEEwAAwBSCCQAAYArBRDNbu3at+vTpo6CgIMXFxbmtCYa0e/du3XHHHYqKipLNZtPWrVt93aUWKSMjQyNGjFBwcLDCw8M1ceJEFRYW+rpbLc66des0ZMgQ1yZM8fHxev/9933drRZt+fLlstlsrjdOAs2BYKIZbd68Wenp6Vq6dKkOHjyooUOHKikpqc52plZWXl6uoUOHau3atb7uSou2a9cuzZkzR59++qmys7NVXV2tW265ReXl5b7uWovSs2dPLV++XPn5+Tpw4IDGjRunO++8U4cPH/Z111qk/fv364UXXtCQIUN83RW0MSwNbUZxcXEaMWKE1qxZI0lyOp2Kjo7W3LlztXDhQh/3ruWx2Wx6++23NXHiRF93pcU7ffq0wsPDtWvXLt10002+7k6LFhYWpqeeekqpqam+7kqLUlZWpuHDh+v555/XE088oWHDhmnVqlW+7hbaCDITzaSqqkr5+flKTEx0nfPz81NiYqLy8vJ82DO0BSUlJZIu/lDCs5qaGm3atEnl5eWKj4/3dXdanDlz5mjChAlu/48CmkurftFXS/Ltt9+qpqbG9R74WhERETp69KiPeoW2wOl0at68efrBD36g6667ztfdaXE+//xzxcfHq6KiQp07d9bbb7+tQYMG+bpbLcqmTZt08OBB7d+/39ddQRtFMAG0cHPmzNGhQ4f08ccf+7orLVL//v1VUFCgkpISvfnmm5o+fbp27dpFQPEvRUVFuv/++5WdnX3F35oJ6yCYaCbdunWTv7+/x/fCm3kfPawtLS1N27Zt0+7du9WzZ09fd6dFCggI0NVXXy1JiomJ0f79+7V69Wq98MILPu5Zy5Cfn69Tp05p+PDhrnM1NTXavXu31qxZo8rKSvn7+/uwh2gLmDPRTAICAhQTE6OcnBzXOafTqZycHMZv0WiGYSgtLU1vv/22cnNz1bdvX193qdVwOp2qrKz0dTdajISEBNerqWuP2NhYpaSkqKCggEACzYLMRDNKT0/X9OnTFRsbq5EjR2rVqlUqLy/XzJkzfd21FqOsrExffvml6/NXX32lgoIChYWFqVevXj7sWcsyZ84cZWVl6Z133lFwcLAcDoeki68L7tChg49713IsWrRIt956q3r16qVz584pKytLO3fu1AcffODrrrUYwcHBdebadOrUSV27dmUODpoNwUQzmjx5sk6fPq0lS5bI4XBo2LBh2rFjR51JmVZ24MABjR071vU5PT1dkjR9+nS98sorPupVy7Nu3TpJ0pgxY9zOv/zyy5oxY8aV71ALderUKU2bNk0nT55USEiIhgwZog8++EA333yzr7sGWAr7TAAAAFOYMwEAAEwhmAAAAKYQTAAAAFMIJgAAgCkEEwAAwBSCCQAAYArBBAAAMIVgAgAAmEIwAbRgM2bM0MSJE33dDQC4JIIJAABgCsEEAAAwhWACAACYQjABAABMIZgAAACmEEwAAABTCCYAAIApBBMAAMAUggkAAGCKzTAMw9edAAAArReZCQAAYArBBAAAMIVgAgAAmEIwAQAATCGYAAAAphBMAAAAUwgmAACAKQQTAADAFIIJAABgCsEEAAAwhWACAACYQjABAABM+f9EXPLbaXVIpAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing `copy_stencil` with origin=(0,1,0)\n", + "Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0,1,0)\n", + "Min and max values: 8.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Resetting qty_out to zero...\n", + "Plotting values of qty_out at K = 0\n", + "Min and max values: 0.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing `copy_stencil` with origin = (0,0,1)\n", + "Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0,0,1)\n", + "Min and max values: 0.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting qty_out at K = 1 based on `copy_stencil` with origin=(0,0,1)\n", + "Min and max values: 9.0 1.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Resetting qty_out to zero...\n", + "Plotting values of qty_in at K = 0\n", + "Min and max values: 8.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_out at K = 0\n", + "Min and max values: 0.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing `copy_stencil` with domain=(2,2,nz)\n", + "Plotting qty_out at K = 0 based on `copy_stencil` with domain = (2,2,nz)\n", + "Min and max values: 2.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Resetting qty_out to zero...\n", + "Plotting values of qty_out at K = 0\n", + "Min and max values: 0.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing `copy_stencil` with origin = (2,2,0), domain=(2,2,nz)\n", + "Plotting qty_out at K = 0 based on `copy_stencil` with origin = (2,2,0), domain = (2,2,nz)\n", + "Min and max values: 6.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "print(\"Plotting values of qty_in at K = 0\")\n", + "plot_field_at_kN(qty_in.data)\n", + "print(\"Plotting values of qty_out at K = 0\")\n", + "plot_field_at_kN(qty_out.data)\n", + "print(\"Executing `copy_stencil` with origin=(1,0,0)\")\n", + "copy_stencil(qty_in, qty_out,origin=(1,0,0))\n", + "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(1,0,0)\")\n", + "plot_field_at_kN(qty_out.data)\n", + "\n", + "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "print(\"Resetting qty_out to zero...\")\n", + "print(\"Plotting values of qty_out at K = 0\")\n", + "plot_field_at_kN(qty_out.data)\n", + "print(\"Executing `copy_stencil` with origin=(0,1,0)\")\n", + "copy_stencil(qty_in, qty_out,origin=(0,1,0))\n", + "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0,1,0)\")\n", + "plot_field_at_kN(qty_out.data)\n", + "\n", + "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "print(\"Resetting qty_out to zero...\")\n", + "print(\"Plotting values of qty_out at K = 0\")\n", + "plot_field_at_kN(qty_out.data)\n", + "print(\"Executing `copy_stencil` with origin = (0,0,1)\")\n", + "copy_stencil(qty_in, qty_out,origin=(0,0,1))\n", + "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0,0,1)\")\n", + "plot_field_at_kN(qty_out.data)\n", + "print(\"Plotting qty_out at K = 1 based on `copy_stencil` with origin=(0,0,1)\")\n", + "plot_field_at_kN(qty_out.data, 1)\n", + "\n", + "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "print(\"Resetting qty_out to zero...\")\n", + "print(\"Plotting values of qty_in at K = 0\")\n", + "plot_field_at_kN(qty_in.data)\n", + "print(\"Plotting values of qty_out at K = 0\")\n", + "plot_field_at_kN(qty_out.data)\n", + "print(\"Executing `copy_stencil` with domain=(2,2,nz)\")\n", + "copy_stencil(qty_in, qty_out, domain=(2,2,nz))\n", + "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with domain = (2,2,nz)\")\n", + "plot_field_at_kN(qty_out.data)\n", + "\n", + "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "print(\"Resetting qty_out to zero...\")\n", + "print(\"Plotting values of qty_out at K = 0\")\n", + "plot_field_at_kN(qty_out.data)\n", + "print(\"Executing `copy_stencil` with origin = (2,2,0), domain=(2,2,nz)\")\n", + "copy_stencil(qty_in, qty_out, origin=(2,2,0), domain=(2,2,nz))\n", + "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin = (2,2,0), domain = (2,2,nz)\")\n", + "plot_field_at_kN(qty_out.data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **`FORWARD` and `BACKWARD` `computation` keywords and Offset Indexing within a stencil call**\n", + "\n", + "Besides `PARALLEL`, the developer can specify `FORWARD` or `BACKWARD` as the iteration policy in `K` for a stencil. Essentially, the `FORWARD` policy has `K` iterating consecutively starting from the lowest vertical index to the highest, while the `BACKWARD` policy performs the reverse.\n", + "\n", + "An array-based stencil variable can also have an integer dimensional offset if the array variable is on the right hand side of the `=` for the computation. When a computation is performed at a particular point, an offset variable's coordinate is based on that particular point plus (or minus) the offset in the offset dimension.\n", + "\n", + "The following examples demonstrate the use of these two iteration policies and also offset indexing in the `K` dimension. Note that offsets can also be applied to the `I` or `J` dimension." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_in at K = 0\n", + "Min and max values: 12.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_in at K = 1\n", + "Min and max values: 13.0 1.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_in at K = 2\n", + "Min and max values: 14.0 2.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing 'mult_upward' with origin=(nhalo,nhalo,0),domain=(nx,ny,2)\n", + "Plotting values of qty_out at K = 0 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\n", + "Min and max values: 0.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_out at K = 1 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\n", + "Min and max values: 20.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_out at K = 2 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\n", + "Min and max values: 22.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_out at K = 3 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\n", + "Min and max values: 0.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Resetting qty_out to zeros\n", + "Executing 'copy_downward' with origin=(1,1,0), domain=(nx,ny,nz-1)\n", + "***\n", + "Plotting values of qty_out at K = 0\n", + "Min and max values: 11.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_out at K = 1\n", + "Min and max values: 12.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_out at K = 2\n", + "Min and max values: 13.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from gt4py.cartesian.gtscript import FORWARD, BACKWARD\n", + "\n", + "nx = 5\n", + "ny = 5\n", + "nz = 5\n", + "nhalo = 1\n", + "backend=\"numpy\"\n", + "\n", + "shape = (nx + 2 * nhalo, ny + 2 * nhalo, nz)\n", + "\n", + "qty_out = Quantity(data=np.zeros(shape),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "arr = np.indices(shape,dtype=float).sum(axis=0) # Value of each entry is sum of the I and J index at each point\n", + "qty_in = Quantity(data=arr,\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "print(\"Plotting values of qty_in at K = 0\")\n", + "plot_field_at_kN(qty_in.data,0)\n", + "print(\"Plotting values of qty_in at K = 1\")\n", + "plot_field_at_kN(qty_in.data,1)\n", + "print(\"Plotting values of qty_in at K = 2\")\n", + "plot_field_at_kN(qty_in.data,2)\n", + "\n", + "@stencil(backend=backend)\n", + "def mult_upward(qty_in: FloatField, qty_out: FloatField):\n", + " with computation(FORWARD), interval(...):\n", + " qty_out = qty_in[0,0,-1] * 2.0\n", + "\n", + "print(\"Executing 'mult_upward' with origin=(nhalo,nhalo,0),domain=(nx,ny,2)\")\n", + "mult_upward(qty_in, qty_out, origin=(nhalo,nhalo,1), domain=(nx,ny,2))\n", + "print(\"Plotting values of qty_out at K = 0 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\")\n", + "plot_field_at_kN(qty_out.data,0)\n", + "print(\"Plotting values of qty_out at K = 1 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\")\n", + "plot_field_at_kN(qty_out.data,1)\n", + "print(\"Plotting values of qty_out at K = 2 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\")\n", + "plot_field_at_kN(qty_out.data,2)\n", + "print(\"Plotting values of qty_out at K = 3 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\")\n", + "plot_field_at_kN(qty_out.data,3)\n", + "\n", + "@stencil(backend=backend)\n", + "def copy_downward(qty_in: FloatField, qty_out: FloatField):\n", + " with computation(BACKWARD), interval(...):\n", + " qty_out = qty_in[0,0,1]\n", + "\n", + "print(\"Resetting qty_out to zeros\")\n", + "qty_out = Quantity(data=np.zeros(shape),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "print(\"Executing 'copy_downward' with origin=(1,1,0), domain=(nx,ny,nz-1)\")\n", + "copy_downward(qty_in, qty_out, origin=(1,1,0), domain=(nx,ny,nz-1))\n", + "print(\"***\")\n", + "print(\"Plotting values of qty_out at K = 0\")\n", + "plot_field_at_kN(qty_out.data,0)\n", + "print(\"Plotting values of qty_out at K = 1\")\n", + "plot_field_at_kN(qty_out.data,1)\n", + "print(\"Plotting values of qty_out at K = 2\")\n", + "plot_field_at_kN(qty_out.data,2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Regarding offsets, GT4Py does not allow offsets to variables in the left hand side of the `=`. Uncomment and execute the below code to see the error `Assignment to non-zero offsets is not supported.`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# @stencil(backend=backend)\n", + "# def mult_upward_error(qty_in: FloatField, qty_out: FloatField):\n", + "# with computation(FORWARD), interval(...):\n", + "# qty_out[0,-1,-1] = qty_in * 2.0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Limits to offset : Cannot set offset outside of usable domain**\n", + "\n", + "Note that there are limits to the offsets that can be applied in the stencil. An error will result if the specified shift results attemps to read data that is not available or allocated. In the example below, a shift of -2 in the `J` axis will shift `field_in` out of its possible range in `J`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing 'copy_stencil' with origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\n", + "Executing 'copy_stencil' where qty_out is copied back to qty_in\n", + "Min and max values: 10.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing 'copy_stencil_offset' where origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Origin for field field_in too small. Must be at least (0, 2, 0), is (1, 1, 0)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_23384/2175782849.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0mplot_field_at_kN\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqty_in\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Executing 'copy_stencil_offset' where origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 33\u001b[0;31m \u001b[0mcopy_stencil_offset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqty_in\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mqty_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnhalo\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnhalo\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdomain\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mny\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 34\u001b[0m \u001b[0mplot_field_at_kN\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqty_out\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/SMT-Nebulae-Tutorial/tutorial/NDSL/.gt_cache_000000/py311_1013/numpy/__main__/copy_stencil_offset/m_copy_stencil_offset__numpy_ef139435cf.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, field_in, field_out, domain, origin, validate_args, exec_info)\u001b[0m\n\u001b[1;32m 99\u001b[0m \u001b[0;31m# assert that all required values have been provided\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 100\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 101\u001b[0;31m self._call_run(\n\u001b[0m\u001b[1;32m 102\u001b[0m \u001b[0mfield_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfield_args\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[0mparameter_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparameter_args\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_object.py\u001b[0m in \u001b[0;36m_call_run\u001b[0;34m(self, field_args, parameter_args, domain, origin, validate_args, exec_info)\u001b[0m\n\u001b[1;32m 582\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 583\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mvalidate_args\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 584\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validate_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray_infos\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparameter_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdomain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 585\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 586\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_domain_origin_cache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcache_key\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mdomain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_object.py\u001b[0m in \u001b[0;36m_validate_args\u001b[0;34m(self, arg_infos, param_args, domain, origin)\u001b[0m\n\u001b[1;32m 466\u001b[0m )\n\u001b[1;32m 467\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfield_domain_origin\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mmin_origin\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 468\u001b[0;31m raise ValueError(\n\u001b[0m\u001b[1;32m 469\u001b[0m \u001b[0;34mf\"Origin for field {name} too small. Must be at least {min_origin}, is {field_domain_origin}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 470\u001b[0m )\n", + "\u001b[0;31mValueError\u001b[0m: Origin for field field_in too small. Must be at least (0, 2, 0), is (1, 1, 0)" + ] + } + ], + "source": [ + "nx = 5\n", + "ny = 5\n", + "nz = 5\n", + "nhalo = 1\n", + "backend=\"numpy\"\n", + "\n", + "shape = (nx + 2 * nhalo, ny + 2 * nhalo, nz)\n", + "\n", + "qty_out = Quantity(data=np.zeros(shape),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "arr = np.indices(shape,dtype=float).sum(axis=0) # Value of each entry is sum of the I and J index at each point\n", + "qty_in = Quantity(data=arr,\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "@stencil(backend=backend)\n", + "def copy_stencil_offset(field_in: FloatField, field_out: FloatField):\n", + " with computation(PARALLEL), interval(...):\n", + " field_out = field_in[0,-2,0]\n", + "\n", + "print(\"Executing 'copy_stencil' with origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\")\n", + "copy_stencil(qty_in, qty_out, origin=(nhalo, nhalo,0), domain=(nx, ny, nz))\n", + "print(\"Executing 'copy_stencil' where qty_out is copied back to qty_in\")\n", + "copy_stencil(qty_out, qty_in)\n", + "plot_field_at_kN(qty_in.data,0)\n", + "print(\"Executing 'copy_stencil_offset' where origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\")\n", + "copy_stencil_offset(qty_in, qty_out, origin=(nhalo, nhalo,0), domain=(nx, ny, nz))\n", + "plot_field_at_kN(qty_out.data,0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **`if/else` statements**\n", + "\n", + "GT4Py allows for `if/else` statements to exist within a stencil. The following simple example shows a stencil `stencil_if_zero` modifing values of `in_out_field` depending on its initial value." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_in at K = 0\n", + "Min and max values: 12.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_out at K = 0\n", + "Min and max values: 0.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\n", + "Plotting values of qty_out at K = 0 based on running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\n", + "Min and max values: 10.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_out at K = 1 based on running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\n", + "Min and max values: 11.0 0.0\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfIAAAHHCAYAAABEJtrOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAp10lEQVR4nO3de3RV9Zn/8c8hkJMISUgigaSEkCqKgCASYCAoKKlOBqjMrOUoE2YidjqOTeSS5WizpnJzJDidcfDChEunQF1SsE4BiwJDUWBhpZLQzAJnGkFTjdoQ7WhOEkvQc/bvD+X8iAmQnH3O2bf3a63vWj2bfXl2W3x8nu937+0zDMMQAABwpD5WBwAAACJHIgcAwMFI5AAAOBiJHAAAByORAwDgYCRyAAAcjEQOAICDkcgBAHAwEjkAAA5GIoenHTx4UD6fTwcPHrQ6FACICIkcrrR582b5fL7wSEpK0jXXXKPy8nKdOXMmKtd4+eWXtXz58qic60Jbt27VmjVrerz/8OHDNXv27C7bn332WSUkJOhP//RPdfbs2ShGeHH19fVasmSJpk6dqqSkJPl8Pv3ud7+Ly7UBryKRw9VWrlypZ599Vs8884ymTp2q6upqTZkyRZ999pnpc7/88stasWJFFKLsrLeJvDvPPfec7rnnHhUVFWnnzp1KSkqKTnCX8frrr+upp55Sa2urrrvuurhcE/C6vlYHAMRScXGxCgoKJEl/+7d/q8zMTD3xxBPatWuX5s2bZ3F0sbFt2zaVlpbq1ltv1a5du+KWxCXp29/+tj799FOlpKToX/7lX1RXVxe3awNeRUUOT7n11lslSQ0NDZfc72c/+5kmTJig5ORkXXnllZo/f74++OCD8J/fc889Wrt2rSR1auFfyq5duzRr1izl5OTI7/frqquu0qOPPqpgMBjeZ8aMGXrppZf07rvvhs85fPjwHt/f888/r/nz52vGjBl68cUX45rEJSkjI0MpKSlxvSbgdVTk8JS3335bkpSZmXnRfTZv3qwFCxZo4sSJqqqq0pkzZ/Tkk0/qtdde029+8xsNHDhQ9913nz788EPt379fzz77bI+uvXnzZg0YMEAVFRUaMGCAXnnlFS1dulSBQEA//OEPJUn/+I//qJaWFr3//vv6t3/7N0nSgAEDenT+//zP/1RJSYluvvlm/eIXv1BycnKPjmtra+vRHHq/fv2UlpbWo3MCiCMDcKFNmzYZkoxf/vKXxkcffWQ0NjYa27ZtMzIzM43k5GTj/fffNwzDMF599VVDkvHqq68ahmEY586dM7KysowxY8YYf/zjH8Pn2717tyHJWLp0aXhbWVmZ0Zu/Qp999lmXbffdd59xxRVXGGfPng1vmzVrlpGXl9fj8+bl5Rk5OTlG3759jRkzZhjt7e09PtYwDKO0tNSQdNkxffr0Xp33hz/8oSHJaGho6NVxAHqHihyuVlRU1Ol3Xl6ennvuOX3jG9/odv+amho1Nzdr+fLlndrSs2bN0siRI/XSSy9FvMDtwgq5tbVVHR0duummm7R+/Xr99re/1bhx4yI6ryT93//9n7744gsNHTq0x5X4eQ899JDmz59/2f3S09MjDQ9ADJHI4Wpr167VNddco759+2rw4MG69tpr1afPxZeGvPvuu5Kka6+9tsufjRw5UkeOHIk4ljfffFM/+MEP9MorrygQCHT6s5aWlojPK0kzZ87UsGHDVF1drYyMDD355JM9PnbUqFEaNWqUqesDsA6JHK42adKk8Kp1K3366aeaPn26UlNTtXLlSl111VVKSkrS8ePH9fDDDysUCpm+xjPPPKNPPvlETz31lNLT03v8jHtLS4v++Mc/Xna/xMREZWRkmIwSQLSRyIEL5OXlSfryxSbnV7ifV19fH/5zSZddpX6hgwcP6g9/+IN+/vOf6+abbw5v7271fG/Oe6E+ffroJz/5iVpaWrRixQplZGRo4cKFlz1u0aJF2rJly2X3mz59Om/AA2yIRA5coKCgQFlZWVq3bp3uvfde+f1+SdKePXv0v//7v1q6dGl43/79+0v6stoeOHDgJc+bkJAgSTIMI7zt3Llz+vd///cu+/bv3z/iVnu/fv30wgsv6LbbbtPixYuVnp6uv/7rv77kMcyRA85GIgcu0K9fPz3++ONasGCBpk+frnnz5oUfPxs+fLiWLFkS3nfChAmSpIULF+r2229XQkKC7r777m7PO3XqVKWnp6u0tFQLFy6Uz+fTs88+2ymxX3je7du3q6KiQhMnTtSAAQM0Z86cHt/DFVdcoZdeeknTp0/Xvffeq7S0NH3729++6P7RnCNvaWnR008/LUl67bXXJH3Z8h84cKAGDhyo8vLyqFwHwAWsXjYPxML5x8+OHTt2yf2+/vjZedu3bzfGjx9v+P1+IyMjwygpKQk/snbeF198YTzwwAPGoEGDDJ/Pd9lH0V577TXjT/7kT4zk5GQjJyfHeOihh4x9+/Z1uX5bW5vxV3/1V8bAgQMNSZd9FC0vL8+YNWtWl+1NTU3G1VdfbSQlJXW5v1hpaGi46ONrvXmkDkDP+Qyjm5IAAAA4Aq9oBQDAwUjkAAA4GIkcAAAHI5EDAOBgJHIAAByMRA4AgIM5+oUwoVBIH374oVJSUiJ+rSUAwDqGYai1tVU5OTmX/KCRWWfPntW5c+dMnycxMbHTlxHtwNGJ/MMPP1Rubq7VYQAATGpsbNTQoUNjcu6zZ88qP2+AmpqDps81ZMgQNTQ02CqZOzqRp6SkSJKm6c/UV/0sjgYA0Ftf6HMd0cvhf57Hwrlz59TUHNS7tcOVmhJ51R9oDSlvwu907tw5Enm0nG+n91U/9fWRyAHAcb56t2g8pkcHpPg0ICXy64RkzylcRydyAAB6KmiEFDTxUvKgEYpeMFFEIgcAeEJIhkKKPJObOTaWePwMAAAHoyIHAHhCSCGZaY6bOzp2SOQAAE8IGoaCJr7cbebYWKK1DgCAg1GRAwA8wa2L3UjkAABPCMlQ0IWJnNY6AAAORkUOAPAEWusAADgYq9YBAIDtUJEDADwh9NUwc7wdkcgBAJ4QNLlq3cyxsUQiBwB4QtCQya+fRS+WaGKOHAAAB6MiBwB4AnPkAAA4WEg+BeUzdbwd0VoHAMDBLE/kH3zwgebPn6/MzEwlJyfr+uuvV01NjdVhAQBcJmSYH3ZkaWv9k08+UWFhoW655Rbt2bNHgwYN0qlTp5Senm5lWAAAFwqabK2bOTaWLE3kjz/+uHJzc7Vp06bwtvz8fAsjAgDAWSxtrb/44osqKCjQnXfeqaysLI0fP14bN260MiQAgEudr8jNDDuyNJG/8847qq6u1ogRI7Rv3z7df//9WrhwobZs2dLt/h0dHQoEAp0GAAA9ETJ8pocdWdpaD4VCKigo0KpVqyRJ48eP18mTJ7Vu3TqVlpZ22b+qqkorVqyId5gAANiWpRV5dna2Ro0a1Wnbddddp/fee6/b/SsrK9XS0hIejY2N8QgTAOACtNZjoLCwUPX19Z22vfXWW8rLy+t2f7/fr9TU1E4DAICeCKqP6dEbhw8f1pw5c5STkyOfz6edO3d2+nPDMLR06VJlZ2crOTlZRUVFOnXqVK/vy9JEvmTJEh09elSrVq3S6dOntXXrVm3YsEFlZWVWhgUAcCHD5Py40cs58vb2do0bN05r167t9s//+Z//WU899ZTWrVunX//61+rfv79uv/12nT17tlfXsXSOfOLEidqxY4cqKyu1cuVK5efna82aNSopKbEyLAAATCsuLlZxcXG3f2YYhtasWaMf/OAHuuOOOyRJP/nJTzR48GDt3LlTd999d4+vY/m71mfPnq3Zs2dbHQYAwOXs9EKYhoYGNTU1qaioKLwtLS1NkydP1uuvv+6sRA4AQDwEjT4KGpHPKJ//HvnXH332+/3y+/29OldTU5MkafDgwZ22Dx48OPxnPWX5u9YBAHCS3NxcpaWlhUdVVZWl8VCRAwA8ISSfQibq15C+LMkbGxs7PTXV22pckoYMGSJJOnPmjLKzs8Pbz5w5oxtuuKFX56IiBwB4QrSeI//6Y9CRJPL8/HwNGTJEBw4cCG8LBAL69a9/rSlTpvTqXFTkAADEQFtbm06fPh3+3dDQoLq6OmVkZGjYsGFavHix/umf/kkjRoxQfn6+HnnkEeXk5Gju3Lm9ug6JHADgCeYXu/Xug+Q1NTW65ZZbwr8rKiokSaWlpdq8ebMeeughtbe36+/+7u/06aefatq0adq7d6+SkpJ6dR0SOQDAE76cI4/8EbLeHjtjxgwZl0j+Pp9PK1eu1MqVKyOOSWKOHAAAR6MiBwB4QiiC96V3Pr53rfV4IZEDADwh3nPk8UIiBwB4Qkh9ovIcud0wRw4AgINRkQMAPCFo+BTs5adIv368HZHIAQCeEDS52C1Iax0AAEQbFTkAwBNCRh+FTKxaD7FqHQAA69BaBwAAtkNFDgDwhJDMrTwPRS+UqCKRAwA8wfwLYezZxCaR29CHO0ZZHULUXXtls9UhRNXEge9aHULUTetfb3UIUVeYZM9/8Jpxe84NVocAmyGRAwA8wfy71u35L4YkcgCAJ8T7e+TxQiIHAHiCWytye0YFAAB6hIocAOAJ5l8IY8/al0QOAPCEkOFTyMxz5Db9+pk9//UCAAD0CBU5AMATQiZb67wQBgAAC5n/+pk9E7k9owIAAD1CRQ4A8ISgfAqaeKmLmWNjiUQOAPAEWusAAMB2qMgBAJ4QlLn2eDB6oUQViRwA4Aluba2TyAEAnsBHUwAAgO1QkQMAPMEw+T1yg8fPAACwDq11AABgO1TkAABP4DOmMbB8+XL5fL5OY+TIkVaGBABwqeBXXz8zM+zI8op89OjR+uUvfxn+3bev5SEBAOAYlmfNvn37asiQIVaHAQBwOVrrMXLq1Cnl5OTom9/8pkpKSvTee+9ddN+Ojg4FAoFOAwCAngipj+lhR5ZGNXnyZG3evFl79+5VdXW1GhoadNNNN6m1tbXb/auqqpSWlhYeubm5cY4YAAB7sbS1XlxcHP7PY8eO1eTJk5WXl6fnn39e3/nOd7rsX1lZqYqKivDvQCBAMgcA9EjQ8Clooj1u5thYsnyO/EIDBw7UNddco9OnT3f7536/X36/P85RAQDcgDnyOGhra9Pbb7+t7Oxsq0MBALiM8dXXzyIdBm926+rBBx/UoUOH9Lvf/U6/+tWv9Od//udKSEjQvHnzrAwLAADHsLS1/v7772vevHn6wx/+oEGDBmnatGk6evSoBg0aZGVYAAAXCsqnoIkPn5g5NpYsTeTbtm2z8vIAAA8JGebmuUNGFIOJIns2/AEAQI/YatU6AACxcn7Rmpnj7YhEDgDwhJB8CpmY5zZzbCzZ818vAABAj1CRAwA8gTe7AQDgYG6dI7dnVAAAoEeoyAEAnhCSyXet23SxG4kcAOAJhslV6waJHAAA6/D1MwAAYDskcgCAJ5j5hGkkK96DwaAeeeQR5efnKzk5WVdddZUeffRRGUZ0X9pOax0A4Anxbq0//vjjqq6u1pYtWzR69GjV1NRowYIFSktL08KFCyOO4+tI5AAAxMCvfvUr3XHHHZo1a5Ykafjw4frpT3+qN954I6rXobUOAPCE8+9aNzMkKRAIdBodHR3dXm/q1Kk6cOCA3nrrLUnSf//3f+vIkSMqLi6O6n1RkQMAPCFarfXc3NxO25ctW6bly5d32f/73/++AoGARo4cqYSEBAWDQT322GMqKSmJOIbukMgBAOiFxsZGpaamhn/7/f5u93v++ef13HPPaevWrRo9erTq6uq0ePFi5eTkqLS0NGrxkMgBAJ4QrYo8NTW1UyK/mH/4h3/Q97//fd19992SpOuvv17vvvuuqqqqSOQAAPRWvFetf/bZZ+rTp/NStISEBIVCoYhj6A6JHACAGJgzZ44ee+wxDRs2TKNHj9ZvfvMbPfHEE7r33nujeh0SuQ21Nfe3OoSoq1eW1SHAk+qtDgA2Eu+K/Omnn9Yjjzyi733ve2publZOTo7uu+8+LV26NOIYukMiBwB4giFzXzDr7fvYUlJStGbNGq1Zsybia/YEiRwA4Al8NAUAANgOFTkAwBPcWpGTyAEAnuDWRE5rHQAAB6MiBwB4glsrchI5AMATDMMnw0QyNnNsLNFaBwDAwajIAQCecOE3xSM93o5I5AAAT3DrHDmtdQAAHIyKHADgCW5d7EYiBwB4gltb6yRyAIAnuLUiZ44cAAAHoyIHAHiCYbK1bteKnEQOAPAEQ5JhmDvejmitAwDgYFTkAABPCMknH292AwDAmVi1HmOrV6+Wz+fT4sWLrQ4FAADHsEVFfuzYMa1fv15jx461OhQAgEuFDJ98LnwhjOUVeVtbm0pKSrRx40alp6dbHQ4AwKUMw/ywI8sTeVlZmWbNmqWioqLL7tvR0aFAINBpAADgZZa21rdt26bjx4/r2LFjPdq/qqpKK1asiHFUAAA3YrFblDU2NmrRokV67rnnlJSU1KNjKisr1dLSEh6NjY0xjhIA4BbnE7mZYUeWVeS1tbVqbm7WjTfeGN4WDAZ1+PBhPfPMM+ro6FBCQkKnY/x+v/x+f7xDBQC4gFsXu1mWyGfOnKkTJ0502rZgwQKNHDlSDz/8cJckDgAAurIskaekpGjMmDGdtvXv31+ZmZldtgMAYJbZled2XbVui+fIAQCItS8TuZnFblEMJopslcgPHjxodQgAADiKrRI5AACx4tbHz0jkAABPMGTum+I27axb/2Y3AAAQOSpyAIAn0FoHAMDJXNpbJ5EDALzB7GtWbVqRM0cOAICDUZEDADyBN7sBAOBgbl3sRmsdAAAHoyIHAHiD4TO3YM2mFTmJHADgCW6dI6e1DgCAg1GRAwC8gRfCAADgXKxaBwAAtkNFDgDwDpu2x80gkQMAPMGtrXUSOQDAG1y62I05cgAAHIyK3IYSP3Lf/yxt6m91CFFVryyrQwDQa76vhpnj7cd9GQMAgO7QWgcAAHZDRQ4A8AaXVuQkcgCAN7j062e01gEAiJEPPvhA8+fPV2ZmppKTk3X99derpqYmqtegIgcAeEK8P2P6ySefqLCwULfccov27NmjQYMG6dSpU0pPT488iG6QyAEA3hDnOfLHH39cubm52rRpU3hbfn6+iQC6R2sdAIBeCAQCnUZHR0e3+7344osqKCjQnXfeqaysLI0fP14bN26MejwkcgCAN5xf7GZmSMrNzVVaWlp4VFVVdXu5d955R9XV1RoxYoT27dun+++/XwsXLtSWLVuielu01gEAnuAzvhxmjpekxsZGpaamhrf7/f5u9w+FQiooKNCqVaskSePHj9fJkye1bt06lZaWRh7I11CRAwC8wYjCkJSamtppXCyRZ2dna9SoUZ22XXfddXrvvfeielskcgAAYqCwsFD19fWdtr311lvKy8uL6nVI5AAAb4jSHHlPLVmyREePHtWqVat0+vRpbd26VRs2bFBZWVlUb4tEDgDwhii11ntq4sSJ2rFjh376059qzJgxevTRR7VmzRqVlJRE536+wmI3AABiZPbs2Zo9e3ZMr0EiBwB4Ax9NAQDAwVyayJkjBwDAwajIAQDe4NLPmJLIAQCeEK03u9kNrXUAABzM0kReXV2tsWPHhl9zN2XKFO3Zs8fKkAAAbhXn58jjxdJEPnToUK1evVq1tbWqqanRrbfeqjvuuENvvvmmlWEBAOAYls6Rz5kzp9Pvxx57TNXV1Tp69KhGjx5tUVQAADfyyeQcedQiia4eJfK/+Iu/uPyJ+vbVkCFD9K1vfatLgu6JYDCon/3sZ2pvb9eUKVO63aejo6PTB9wDgUCvrwMAgJv0KJGnpaVddp9QKKRTp07pRz/6kR588EGtXLmyRwGcOHFCU6ZM0dmzZzVgwADt2LGjy2ffzquqqtKKFSt6dF4AADrx8uNnmzZt6vEJd+/ere9973s9TuTXXnut6urq1NLSohdeeEGlpaU6dOhQt8m8srJSFRUV4d+BQEC5ubk9jg0A4GEufbNb1OfIp02bpoKCgh7vn5iYqKuvvlqSNGHCBB07dkxPPvmk1q9f32Vfv99/0Q+4AwDgRVFP5AMHDtTPf/7ziI8PhUKd5sEBAIgKKvLoq6ysVHFxsYYNG6bW1lZt3bpVBw8e1L59+6wMCwDgQm59s5uliby5uVl/8zd/o9///vdKS0vT2LFjtW/fPn3rW9+yMiwAABzD0kT+H//xH1ZeHgDgJbTWAQBwMJcmcj6aAgCAg1GRAwA8gcVuAAA4mZff7AYAgOMxRw4AAOyGihwA4AnMkQMA4GS01gEAgN1QkQMAvMFka92uFTmJHADgDbTWAQCA3VCRAwC8waUVOYkcAOAJbn38jNY6AAAORiIHAMDBaK0DALyBOXIAAJyLOXIAAGA7VOQAAO+waVVtBonchpKb7fnxenPc9X+1NvW3OoSoq1eW1SGgRz62OgDncukcOa11AAAczF1lEgAAF+HWxW4kcgCAN9BaBwAAdkNFDgDwBFrrAAA4Ga11AABgN1TkAABvcGlFTiIHAHgCc+QAADiZSyty5sgBAHAwKnIAgDe4tCInkQMAPMGtc+S01gEAcDAqcgCAN9BaBwDAuWitAwAA26EiBwB4g0tb61TkAABvMKIwIrR69Wr5fD4tXrw48pNcBIkcAIAYOnbsmNavX6+xY8fG5PyWJvKqqipNnDhRKSkpysrK0ty5c1VfX29lSAAAl/JFYfRWW1ubSkpKtHHjRqWnp5u+h+5YmsgPHTqksrIyHT16VPv379fnn3+u2267Te3t7VaGBQBwoyi11gOBQKfR0dFx0UuWlZVp1qxZKioqitFNWbzYbe/evZ1+b968WVlZWaqtrdXNN99sUVQAADeK1uNnubm5nbYvW7ZMy5cv77L/tm3bdPz4cR07dizyi/aArVatt7S0SJIyMjIsjgQAgO41NjYqNTU1/Nvv93e7z6JFi7R//34lJSXFNB7bJPJQKKTFixersLBQY8aM6Xafjo6OTi2MQCAQr/AAAE4XpcfPUlNTOyXy7tTW1qq5uVk33nhjeFswGNThw4f1zDPPqKOjQwkJCSaC+f9sk8jLysp08uRJHTly5KL7VFVVacWKFXGMCgDgKnF6FnzmzJk6ceJEp20LFizQyJEj9fDDD0ctiUs2SeTl5eXavXu3Dh8+rKFDh150v8rKSlVUVIR/BwKBLnMVAABYLSUlpUt3uX///srMzLxo1zlSliZywzD0wAMPaMeOHTp48KDy8/Mvub/f7+92LgIAgMtx67vWLU3kZWVl2rp1q3bt2qWUlBQ1NTVJktLS0pScnGxlaAAAt7H4Fa0HDx40d4KLsPQ58urqarW0tGjGjBnKzs4Oj+3bt1sZFgAAjmF5ax0AgHigtQ4AgJPx9TMAAGA3VOQAAE+gtQ4AgJO5tLVOIgcAeINLEzlz5AAAOBgVOQDAE5gjBwDAyWitAwAAu6EiBwB4gs8w5DPxRlEzx8YSiRwA4A201gEAgN1QkQMAPIFV6wAAOBmtdQAAYDdU5AAAT6C1DgCAk7m0tU4iBwB4glsrcubIAQBwMCpyAIA30FpHvPRvClkdQgy4rfnjvr86bepvdQhRV68sq0OIuhx9bHUIjmbX9rgZbvunKwAAnuK+sgIAgO4YxpfDzPE2RCIHAHgCq9YBAIDtUJEDALyBVesAADiXL/TlMHO8HdFaBwDAwajIAQDeQGsdAADncuuqdRI5AMAbXPocOXPkAAA4GBU5AMATaK0DAOBkLl3sRmsdAAAHoyIHAHgCrXUAAJyMVesAAMBuqMgBAJ5Aax0AACdj1ToAALAbKnIAgCe4tbVuaUV++PBhzZkzRzk5OfL5fNq5c6eV4QAA3CxkmB82ZGkib29v17hx47R27VorwwAAeIERhWFDlrbWi4uLVVxcbGUIAAA4GnPkAABP8MnkHHnUIokuRyXyjo4OdXR0hH8HAgELowEAOApvdrNeVVWV0tLSwiM3N9fqkAAAsJSjEnllZaVaWlrCo7Gx0eqQAAAOcf7xMzPDjhzVWvf7/fL7/VaHAQBwIpe+2c3SRN7W1qbTp0+Hfzc0NKiurk4ZGRkaNmyYhZEBAOAMlibympoa3XLLLeHfFRUVkqTS0lJt3rzZoqgAAG7kMwz5TCxYM3NsLFmayGfMmCHDpv/FAABcJvTVMHO8DTlqsRsAAOiMRA4A8ITzrXUzozeqqqo0ceJEpaSkKCsrS3PnzlV9fX3U74tEDgDwhji/a/3QoUMqKyvT0aNHtX//fn3++ee67bbb1N7eHp37+YqjHj8DACBicX6z2969ezv93rx5s7KyslRbW6ubb7458ji+hoocAIA4aGlpkSRlZGRE9bxU5AAATzD7drbzx379Ox89eVlZKBTS4sWLVVhYqDFjxkQeRDeoyAEA3nC+tW5mSMrNze303Y+qqqrLXrqsrEwnT57Utm3bon5bVOQAAPRCY2OjUlNTw78vV42Xl5dr9+7dOnz4sIYOHRr1eEjkAABP8IW+HGaOl6TU1NROifxiDMPQAw88oB07dujgwYPKz8+P/OKXQCIHAHhDnFetl5WVaevWrdq1a5dSUlLU1NQkSUpLS1NycnLkcXwNc+QAAMRAdXW1WlpaNGPGDGVnZ4fH9u3bo3odKnIAgDfE+TOm8fqWCIkcAOAJbv36Ga11AAAcjIocAOANcV7sFi8kcgCANxgy901xe+ZxEjkAwBuYIwcAALZDRQ4A8AZDJufIoxZJVJHIAQDewGI3xMuA549aHULUDbA6AABwKRI5AMAbQpJ8Jo+3IRI5AMATWLUOAABsh4ocAOANLHYDAMDBXJrIaa0DAOBgVOQAAG9waUVOIgcAeAOPnwEA4Fw8fgYAAGyHihwA4A3MkQMA4GAhQ/KZSMYheyZyWusAADgYFTkAwBtorQMA4GQmE7nsmchprQMA4GBU5AAAb6C1DgCAg4UMmWqPs2odAABEGxU5AMAbjNCXw8zxNkQiBwB4g0vnyG3RWl+7dq2GDx+upKQkTZ48WW+88YbVIQEA3CZkmB82ZHki3759uyoqKrRs2TIdP35c48aN0+23367m5marQwMAwPYsT+RPPPGEvvvd72rBggUaNWqU1q1bpyuuuEI//vGPrQ4NAOAm51vrZoYNWZrIz507p9raWhUVFYW39enTR0VFRXr99de77N/R0aFAINBpAADQI4ZMJnKrb6B7libyjz/+WMFgUIMHD+60ffDgwWpqauqyf1VVldLS0sIjNzc3XqECAGBLlrfWe6OyslItLS3h0djYaHVIAACncGlr3dLHz6688kolJCTozJkznbafOXNGQ4YM6bK/3++X3++PV3gAADcJhSSZeBY8ZM/nyC2tyBMTEzVhwgQdOHAgvC0UCunAgQOaMmWKhZEBAOAMlr8QpqKiQqWlpSooKNCkSZO0Zs0atbe3a8GCBVaHBgBwE5e+EMbyRH7XXXfpo48+0tKlS9XU1KQbbrhBe/fu7bIADgAAU0jksVNeXq7y8nKrwwAAwHFskcgBAIg5l37GlEQOAPAEwwjJMPEFMzPHxhKJHADgDYbJD5/YdI7cUS+EAQAAnVGRAwC8wTA5R27TipxEDgDwhlBI8pmY57bpHDmtdQAAHIyKHADgDbTWAQBwLiMUkmGitW7Xx89orQMA4GBU5AAAb6C1DgCAg4UMyee+RE5rHQAAB6MiBwB4g2FIMvMcuT0rchI5AMATjJAhw0Rr3bBpIqe1DgDwBiNkfkRg7dq1Gj58uJKSkjR58mS98cYbUb0tEjkAADGyfft2VVRUaNmyZTp+/LjGjRun22+/Xc3NzVG7BokcAOAJRsgwPXrriSee0He/+10tWLBAo0aN0rp163TFFVfoxz/+cdTui0QOAPCGOLfWz507p9raWhUVFYW39enTR0VFRXr99dejdluOXux2fuHBF/rc1DP+AABrfKHPJcVnIZnZXHE+1kAg0Gm73++X3+/vsv/HH3+sYDCowYMHd9o+ePBg/fa3v408kK9xdCJvbW2VJB3RyxZHAgAwo7W1VWlpaTE5d2JiooYMGaIjTeZzxYABA5Sbm9tp27Jly7R8+XLT546UoxN5Tk6OGhsblZKSIp/PF9NrBQIB5ebmqrGxUampqTG9Vjy47X4k7skpuCf7i+f9GIah1tZW5eTkxOwaSUlJamho0Llz50yfyzCMLvmmu2pckq688kolJCTozJkznbafOXNGQ4YMMR3LeY5O5H369NHQoUPjes3U1FRX/EU9z233I3FPTsE92V+87idWlfiFkpKSlJSUFPPrXCgxMVETJkzQgQMHNHfuXElSKBTSgQMHVF5eHrXrODqRAwBgZxUVFSotLVVBQYEmTZqkNWvWqL29XQsWLIjaNUjkAADEyF133aWPPvpIS5cuVVNTk2644Qbt3bu3ywI4M0jkPeT3+7Vs2bKLzoU4jdvuR+KenIJ7sj+33Y/VysvLo9pK/zqfYdeXxwIAgMvihTAAADgYiRwAAAcjkQMA4GAkcgAAHIxE3gOx/pZsPB0+fFhz5sxRTk6OfD6fdu7caXVIplVVVWnixIlKSUlRVlaW5s6dq/r6eqvDMqW6ulpjx44Nv5BjypQp2rNnj9VhRc3q1avl8/m0ePFiq0OJ2PLly+Xz+TqNkSNHWh2WaR988IHmz5+vzMxMJScn6/rrr1dNTY3VYeESSOSXEY9vycZTe3u7xo0bp7Vr11odStQcOnRIZWVlOnr0qPbv36/PP/9ct912m9rb260OLWJDhw7V6tWrVVtbq5qaGt16662644479Oabb1odmmnHjh3T+vXrNXbsWKtDMW306NH6/e9/Hx5HjhyxOiRTPvnkExUWFqpfv37as2eP/ud//kf/+q//qvT0dKtDw6UYuKRJkyYZZWVl4d/BYNDIyckxqqqqLIwqOiQZO3bssDqMqGtubjYkGYcOHbI6lKhKT083fvSjH1kdhimtra3GiBEjjP379xvTp083Fi1aZHVIEVu2bJkxbtw4q8OIqocfftiYNm2a1WGgl6jILyFe35JFdLW0tEiSMjIyLI4kOoLBoLZt26b29nZNmTLF6nBMKSsr06xZszr9nXKyU6dOKScnR9/85jdVUlKi9957z+qQTHnxxRdVUFCgO++8U1lZWRo/frw2btxodVi4DBL5JVzqW7JNTU0WRYVLCYVCWrx4sQoLCzVmzBirwzHlxIkTGjBggPx+v/7+7/9eO3bs0KhRo6wOK2Lbtm3T8ePHVVVVZXUoUTF58mRt3rxZe/fuVXV1tRoaGnTTTTeFP6/sRO+8846qq6s1YsQI7du3T/fff78WLlyoLVu2WB0aLoFXtMJVysrKdPLkScfPVUrStddeq7q6OrW0tOiFF15QaWmpDh065Mhk3tjYqEWLFmn//v1x/wJVrBQXF4f/89ixYzV58mTl5eXp+eef13e+8x0LI4tcKBRSQUGBVq1aJUkaP368Tp48qXXr1qm0tNTi6HAxVOSXEK9vySI6ysvLtXv3br366qtx/7xtLCQmJurqq6/WhAkTVFVVpXHjxunJJ5+0OqyI1NbWqrm5WTfeeKP69u2rvn376tChQ3rqqafUt29fBYNBq0M0beDAgbrmmmt0+vRpq0OJWHZ2dpd/UbzuuuscP2XgdiTyS7jwW7Lnnf+WrNPnKt3EMAyVl5drx44deuWVV5Sfn291SDERCoXU0dFhdRgRmTlzpk6cOKG6urrwKCgoUElJierq6pSQkGB1iKa1tbXp7bffVnZ2ttWhRKywsLDLo5tvvfWW8vLyLIoIPUFr/TLi8S3ZeGpra+tUMTQ0NKiurk4ZGRkaNmyYhZFFrqysTFu3btWuXbuUkpISXr+Qlpam5ORki6OLTGVlpYqLizVs2DC1trZq69atOnjwoPbt22d1aBFJSUnpsmahf//+yszMdOxahgcffFBz5sxRXl6ePvzwQy1btkwJCQmaN2+e1aFFbMmSJZo6dapWrVqlv/zLv9Qbb7yhDRs2aMOGDVaHhkuxetm8Ezz99NPGsGHDjMTERGPSpEnG0aNHrQ4pYq+++qohqcsoLS21OrSIdXc/koxNmzZZHVrE7r33XiMvL89ITEw0Bg0aZMycOdP4r//6L6vDiiqnP3521113GdnZ2UZiYqLxjW98w7jrrruM06dPWx2Wab/4xS+MMWPGGH6/3xg5cqSxYcMGq0PCZfAZUwAAHIw5cgAAHIxEDgCAg5HIAQBwMBI5AAAORiIHAMDBSOQAADgYiRwAAAcjkQMA4GAkcsDG7rnnHs2dO9fqMADYGIkcAAAHI5EDAOBgJHIAAByMRA4AgIORyAEAcDASOQAADkYiBwDAwUjkAAA4GIkcAAAH8xmGYVgdBAAAiAwVOQAADkYiBwDAwUjkAAA4GIkcAAAHI5EDAOBgJHIAAByMRA4AgIORyAEAcDASOQAADkYiBwDAwUjkAAA4GIkcAAAH+39eDLU0OWOEfwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running 'stencil_if_zero' on qty_out\n", + "Plotting values of qty_out at K = 0 based on running stencil_if_zero\n", + "Min and max values: 30.0 10.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_out at K = 1 based on running stencil_if_zero\n", + "Min and max values: 30.0 10.0\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf8AAAHHCAYAAACx2FF+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA5zElEQVR4nO3de3RU9bn/8c+QwCSSCwTIZUoIAYSIELCAaQQxSkrIogheKlA8BqSl8ktQTK2WHgUEj/HSi1JpUI8StFIUawSxhIORhEMLKOFkKbamQIOEQoJQyU0JmNm/P5AJY0Iyk0kyyez3a63vWsye/f3uZ+iyD8+zbxbDMAwBAADT6ObtAAAAQMci+QMAYDIkfwAATIbkDwCAyZD8AQAwGZI/AAAmQ/IHAMBkSP4AAJgMyR8AAJMh+cPUCgoKZLFYVFBQ4O1QAKDDkPzhk3JycmSxWBwjICBAQ4cOVUZGhioqKtrkGH/+85+1fPnyNlnrUuvXr9czzzzj8v4DBw7UD37wg0bbX331Vfn5+WnKlCk6e/ZsG0Z4eSUlJbr//vt13XXXKSAgQBaLRUeOHOmQYwNwHckfPm3FihV69dVX9dxzz+m6665Tdna2EhMT9eWXX3q89p///Gc9+uijbRClM3eTf1Nee+01zZ07V8nJyXr77bcVEBDQNsG1YPfu3Vq1apWqq6t11VVXdcgxAbjP39sBAO0pNTVVY8eOlST9+Mc/Vp8+ffSb3/xGmzZt0uzZs70cXfvYsGGD0tLSdNNNN2nTpk0dlvgl6eabb9aZM2cUHBysX/3qVyouLu6wYwNwHZU/TOWmm26SJJWWlja738aNGzVmzBgFBgaqb9++uvPOO/Wvf/3L8f3cuXO1evVqSXI6vdCcTZs2aerUqbLZbLJarRo8eLBWrlyp+vp6xz5JSUl699139dlnnznWHDhwoMu/74033tCdd96ppKQkbd68uUMTvySFhYUpODi4Q48JwH1U/jCVw4cPS5L69Olz2X1ycnI0b948jRs3TllZWaqoqNCzzz6rv/zlL/q///s/9erVSz/96U91/Phxbd++Xa+++qpLx87JyVFQUJAyMzMVFBSk999/X0uXLlVVVZWefvppSdJ//ud/qrKyUseOHdNvf/tbSVJQUJBL6//pT3/SnDlzNHHiRL3zzjsKDAx0aV5NTY1L1wR0795doaGhLq0JoJMzAB+0du1aQ5Lx3nvvGZ9//rlRVlZmbNiwwejTp48RGBhoHDt2zDAMw9ixY4chydixY4dhGIZx7tw5Izw83BgxYoTx1VdfOdbbsmWLIclYunSpY1t6errhzn9CX375ZaNtP/3pT40rrrjCOHv2rGPb1KlTjZiYGJfXjYmJMWw2m+Hv728kJSUZtbW1Ls81DMNIS0szJLU4brjhBrfWffrppw1JRmlpqVvzALQ/Kn/4tOTkZKfPMTExeu211/Sd73ynyf337dunkydPavny5U4t86lTpyouLk7vvvtuqy/yu7QSr66uVl1dna6//no9//zz+vTTTzVq1KhWrStJ//73v/X111+rf//+Llf8Fz344IO68847W9yvd+/erQ0PQCdD8odPW716tYYOHSp/f39FRERo2LBh6tbt8pe6fPbZZ5KkYcOGNfouLi5Ou3btanUsn3zyiR5++GG9//77qqqqcvqusrKy1etK0qRJkzRgwABlZ2crLCxMzz77rMtzhw8fruHDh3t0fABdC8kfPu3aa691XO3vTWfOnNENN9ygkJAQrVixQoMHD1ZAQID279+vhx56SHa73eNjPPfcc/riiy+0atUq9e7d2+VnEFRWVuqrr75qcb8ePXooLCzMwygBdAYkf+ASMTExki48rObinQEXlZSUOL6X1OLV/ZcqKCjQ6dOn9dZbb2nixImO7U3ddeDOupfq1q2bXnnlFVVWVurRRx9VWFiY7r333hbn3XfffVq3bl2L+91www08CRHwESR/4BJjx45VeHi41qxZo7vvvltWq1WStHXrVv3973/X0qVLHfv27NlT0oWqvlevXs2u6+fnJ0kyDMOx7dy5c/r973/faN+ePXu2+jRA9+7d9eabb2ry5MlavHixevfurf/4j/9odg7n/AHzIfkDl+jevbuefPJJzZs3TzfccINmz57tuNVv4MCBuv/++x37jhkzRpJ07733KiUlRX5+fpo1a1aT61533XXq3bu30tLSdO+998pisejVV191+sfApeu+/vrryszM1Lhx4xQUFKRp06a5/BuuuOIKvfvuu7rhhht09913KzQ0VDfffPNl92/Lc/6VlZX63e9+J0n6y1/+IunC6YhevXqpV69eysjIaJPjAPCQt283ANrDxVv9Pvzww2b3+/atfhe9/vrrxjXXXGNYrVYjLCzMmDNnjuP2wIu+/vprY9GiRUa/fv0Mi8XS4m1/f/nLX4zvfe97RmBgoGGz2YwHH3zQ2LZtW6Pj19TUGD/60Y+MXr16GZJavO0vJibGmDp1aqPt5eXlxpAhQ4yAgIBGv6+9lJaWXvZWQXduXwTQviyG0UTpAQAAfBaP9wUAwGRI/gAAmAzJHwAAkyH5AwDQDrKzsxUfH6+QkBCFhIQoMTFRW7dudXx/9uxZpaenq0+fPgoKCtJtt92mioqKZtc0DENLly5VVFSUAgMDlZycrIMHD7odG8kfAIB20L9/fz3xxBMqKirSvn37dNNNN2n69On65JNPJEn333+/3nnnHW3cuFGFhYU6fvy4br311mbXfOqpp7Rq1SqtWbNGe/fuVc+ePZWSkuLSmzkvxdX+AAB0kLCwMD399NO6/fbb1a9fP61fv1633367JOnTTz/VVVddpd27d+t73/teo7mGYchms+lnP/uZHnjgAUkXnq0RERGhnJycyz5npCld+iE/drtdx48fV3BwcKsfiQoA8B7DMFRdXS2bzdbsS7c8dfbsWZ07d87jdQzDaJRvrFar42mgl1NfX6+NGzeqtrZWiYmJKioq0vnz553ePBoXF6cBAwZcNvmXlpaqvLzcaU5oaKgSEhK0e/du8yT/48ePKzo62tthAAA8VFZWpv79+7fL2mfPnlVsTJDKT9Z7vFZQUJBqamqcti1btuyyL9L6+OOPlZiYqLNnzyooKEi5ubkaPny4iouL1aNHj0aPBo+IiFB5eXmTa13cHhER4fKcy+nSyT84OFiS9Nn+gQoJ4vIFAOhqqmrsivnuEcf/n7eHc+fOqfxkvT4rGqiQ4Nbniqpqu2LGHFFZWZlCQkIc25ur+ocNG6bi4mJVVlbqzTffVFpamgoLC1sdQ1vp0sn/YuslJKibR/+DAgC8qyNO3QYFWxQU3Prj2PVNzvnm6n1X9OjRQ0OGDJF04b0dH374oZ599lnNnDlT586da/RisIqKCkVGRja51sXtFRUVioqKcpozevRot34LGRMAYAr1ht3j4Sm73a66ujqNGTNG3bt3V35+vuO7kpISHT16VImJiU3OjY2NVWRkpNOcqqoq7d2797JzLqdLV/4AALjKLkN2tf4GN3fnLlmyRKmpqRowYICqq6u1fv16FRQUaNu2bQoNDdX8+fOVmZmpsLAwhYSEaNGiRUpMTHS62C8uLk5ZWVm65ZZbZLFYtHjxYj322GO68sorFRsbq0ceeUQ2m00zZsxwKzaSPwAA7eDkyZO66667dOLECYWGhio+Pl7btm3T97//fUnSb3/7W3Xr1k233Xab6urqlJKSot///vdOa5SUlKiystLx+cEHH1Rtba0WLFigM2fOaMKECcrLy1NAQIBbsXXp+/yrqqoUGhqqL/4xiHP+ANAFVVXb1XvoP1VZWenyeXS3j/FNrjhe0t/jC/5sw461a6wdhcofAGAK9Yaheg/qXU/mdjaUywAAmAyVPwDAFDr6gr/OjOQPADAFuwzVk/wl0fYHAMB0qPwBAKZA278ByR8AYApc7d+Atj8AACZD5Q8AMAX7N8OT+b6C5A8AMIV6D6/292RuZ0PyBwCYQr1xYXgy31dwzh8AAJOh8gcAmALn/BuQ/AEApmCXRfWyeDTfV9D2BwDAZLye/P/1r3/pzjvvVJ8+fRQYGKiRI0dq37593g4LAOBj7Ibnw1d4te3/xRdfaPz48brxxhu1detW9evXTwcPHlTv3r29GRYAwAfVe9j292RuZ+PV5P/kk08qOjpaa9eudWyLjY31YkQAAPg+r7b9N2/erLFjx+qHP/yhwsPDdc011+jFF1/0ZkgAAB91sfL3ZPgKryb/f/7zn8rOztaVV16pbdu2aeHChbr33nu1bt26Jvevq6tTVVWV0wAAwBV2w+Lx8BVebfvb7XaNHTtWjz/+uCTpmmuu0YEDB7RmzRqlpaU12j8rK0uPPvpoR4cJAIBP8WrlHxUVpeHDhzttu+qqq3T06NEm91+yZIkqKysdo6ysrCPCBAD4ANr+Dbxa+Y8fP14lJSVO2/7xj38oJiamyf2tVqusVmtHhAYA8DH16qZ6D2re+jaMxdu8mvzvv/9+XXfddXr88cd1xx136IMPPtALL7ygF154wZthAQB8kOHheXvDh875e7XtP27cOOXm5uqPf/yjRowYoZUrV+qZZ57RnDlzvBkWAAA+zevP9v/BD36gH/zgB94OAwDg43jITwOvJ38AADpCvdFN9YYH5/x96PG+Xn+2PwAA6FhU/gAAU7DLIrsHNa9dvlP6k/wBAKbAOf8GtP0BADAZKn8AgCl4fsEfbX8AALqUC+f8W9+692RuZ0PbHwAAk6HyBwCYgt3DZ/v70tX+VP4AAFO4eM7fk+GOrKwsjRs3TsHBwQoPD9eMGTOcXmZ35MgRWSyWJsfGjRsvu+7cuXMb7T9lyhS3YiP5AwBMwa5uHg93FBYWKj09XXv27NH27dt1/vx5TZ48WbW1tZKk6OhonThxwmk8+uijCgoKUmpqarNrT5kyxWneH//4R7dio+0PAEA7yMvLc/qck5Oj8PBwFRUVaeLEifLz81NkZKTTPrm5ubrjjjsUFBTU7NpWq7XRXHdQ+QMATKHesHg8JKmqqspp1NXVuXT8yspKSVJYWFiT3xcVFam4uFjz589vca2CggKFh4dr2LBhWrhwoU6fPu3i38IFJH8AgCnUf3PBnydDutCuDw0NdYysrKwWj22327V48WKNHz9eI0aMaHKfl156SVdddZWuu+66ZteaMmWKXnnlFeXn5+vJJ59UYWGhUlNTVV9f7/LfBW1/AADcUFZWppCQEMdnq9Xa4pz09HQdOHBAu3btavL7r776SuvXr9cjjzzS4lqzZs1y/HnkyJGKj4/X4MGDVVBQoEmTJrnwC6j8AQAmYTe6eTwkKSQkxGm0lPwzMjK0ZcsW7dixQ/37929ynzfffFNffvml7rrrLrd/16BBg9S3b18dOnTI5TlU/gAAU7i0dd+6+e7d528YhhYtWqTc3FwVFBQoNjb2svu+9NJLuvnmm9WvXz+34zp27JhOnz6tqKgol+dQ+QMA0A7S09P1hz/8QevXr1dwcLDKy8tVXl6ur776ymm/Q4cOaefOnfrxj3/c5DpxcXHKzc2VJNXU1OjnP/+59uzZoyNHjig/P1/Tp0/XkCFDlJKS4nJsVP4AAFOwS44r9ls73x3Z2dmSpKSkJKfta9eu1dy5cx2fX375ZfXv31+TJ09ucp2SkhLHnQJ+fn766KOPtG7dOp05c0Y2m02TJ0/WypUrXbr24CKSPwDAFFrzoJ5vz3eH4eJbAB9//HE9/vjjLq0TGBiobdu2uRVHU0j+nVCKbbS3QwDQSW07XuztEOADSP4AAFNozfP5vz3fV5D8AQCmYJdFdnlyzr/1czsbkj8AwBSo/Bv4zi8BAAAuofIHAJiC5w/58Z16meQPADAFu2GR3ZP7/D2Y29n4zj9jAACAS6j8AQCmYPew7e/JA4I6G5I/AMAULn0zX2vn+wrf+SUAAMAlVP4AAFOol0X1Hjyox5O5nQ3JHwBgCrT9G/jOLwEAAC6h8gcAmEK9PGvd17ddKF5H8gcAmAJt/wYkfwCAKfBinwa+80sAAIBLqPwBAKZgyCK7B+f8DW71AwCga6Ht38B3fgkAAHAJlT8AwBR4pW8Dr1b+y5cvl8VicRpxcXHeDAkA4KPqv3mrnyfDV3i98r/66qv13nvvOT77+3s9JAAAfJrXM62/v78iIyO9HQYAwMfR9m/g9R7GwYMHZbPZNGjQIM2ZM0dHjx697L51dXWqqqpyGgAAuMKubh4PX+HVX5KQkKCcnBzl5eUpOztbpaWluv7661VdXd3k/llZWQoNDXWM6OjoDo4YAICuz6tt/9TUVMef4+PjlZCQoJiYGL3xxhuaP39+o/2XLFmizMxMx+eqqir+AQAAcEm9YVG9B617T+Z2Nl4/53+pXr16aejQoTp06FCT31utVlmt1g6OCgDgCzjn36BTncCoqanR4cOHFRUV5e1QAAA+xvjmrX6tHQZP+GsbDzzwgAoLC3XkyBH99a9/1S233CI/Pz/Nnj3bm2EBAODTvNr2P3bsmGbPnq3Tp0+rX79+mjBhgvbs2aN+/fp5MywAgA+ql0X1Hrycx5O5nY1Xk/+GDRu8eXgAgInYDc/O29uNNgzGy3znBAYAAHBJp7raHwCA9nLxwj1P5vsK3/klAAA0wy6Lx8MdWVlZGjdunIKDgxUeHq4ZM2aopKTEaZ+kpKRGL7i75557ml3XMAwtXbpUUVFRCgwMVHJysg4ePOhWbCR/AADaQWFhodLT07Vnzx5t375d58+f1+TJk1VbW+u0309+8hOdOHHCMZ566qlm133qqae0atUqrVmzRnv37lXPnj2VkpKis2fPuhwbbX8AgCl09BP+8vLynD7n5OQoPDxcRUVFmjhxomP7FVdc4fIL7gzD0DPPPKOHH35Y06dPlyS98sorioiI0Ntvv61Zs2a5tA6VPwDAFDx5wI+n1wtIUmVlpSQpLCzMaftrr72mvn37asSIEVqyZIm+/PLLy65RWlqq8vJyJScnO7aFhoYqISFBu3fvdjkWKn8AANzw7TfKuvLoebvdrsWLF2v8+PEaMWKEY/uPfvQjxcTEyGaz6aOPPtJDDz2kkpISvfXWW02uU15eLkmKiIhw2h4REeH4zhUkfwCAKdjl4bP9v7ng79svlFu2bJmWL1/e7Nz09HQdOHBAu3btctq+YMECx59HjhypqKgoTZo0SYcPH9bgwYNbHWtLSP4AAFMwWnHF/rfnS1JZWZlCQkIc21uq+jMyMrRlyxbt3LlT/fv3b3bfhIQESdKhQ4eaTP4Xrw2oqKhweg9ORUWFRo8e7dLvkDjnDwAwiYtv9fNkSFJISIjTuFzyNwxDGRkZys3N1fvvv6/Y2NgWYywuLpaky77gLjY2VpGRkcrPz3dsq6qq0t69e5WYmOjy3wXJHwCAdpCenq4//OEPWr9+vYKDg1VeXq7y8nJ99dVXkqTDhw9r5cqVKioq0pEjR7R582bdddddmjhxouLj4x3rxMXFKTc3V5JksVi0ePFiPfbYY9q8ebM+/vhj3XXXXbLZbJoxY4bLsdH2BwCYQkc/4S87O1vShQf5XGrt2rWaO3euevTooffee0/PPPOMamtrFR0drdtuu00PP/yw0/4lJSWOOwUk6cEHH1Rtba0WLFigM2fOaMKECcrLy1NAQIDLsZH8AQCmcGnrvrXz3WEYzb8JKDo6WoWFhW6vY7FYtGLFCq1YscKteC5F2x8AAJOh8gcAmEJrns//7fm+guQPADCFjm77d2a0/QEAMBkqfwCAKVD5NyD5AwBMgeTfgLY/AAAmQ+UPADAFKv8GJH8AgCkY8ux2veYf2dO1kPwBAKZA5d+Ac/4AAJgMlT8AwBSo/BuQ/AEApkDyb0DbHwAAk6HyBwCYApV/A5I/AMAUDMMiw4ME7snczoa2PwAAJkPlDwAwBbssHj3kx5O5nQ3JHwBgCpzzb0DbHwAAk6HyBwCYAhf8NSD5AwBMgbZ/A5I/AMAUqPwbcM4fAACTofIHAJiC4WHb35cqf5I/AMAUDEmG4dl8X0HbHwAAk6HyBwCYgl0WWXjCnySSPwDAJLjav0Gnafs/8cQTslgsWrx4sbdDAQDAp3WKyv/DDz/U888/r/j4eG+HAgDwUXbDIgsP+ZHUCSr/mpoazZkzRy+++KJ69+7t7XAAAD7KMDwfvsLryT89PV1Tp05VcnJyi/vW1dWpqqrKaQAAAPd4te2/YcMG7d+/Xx9++KFL+2dlZenRRx9t56gAAL6IC/4aeK3yLysr03333afXXntNAQEBLs1ZsmSJKisrHaOsrKydowQA+IqLyd+T4Su8lvyLiop08uRJffe735W/v7/8/f1VWFioVatWyd/fX/X19Y3mWK1WhYSEOA0AAFxx8a1+ngx3ZGVlady4cQoODlZ4eLhmzJihkpISx/f//ve/tWjRIg0bNkyBgYEaMGCA7r33XlVWVja77ty5c2WxWJzGlClT3IrNa23/SZMm6eOPP3baNm/ePMXFxemhhx6Sn5+flyIDAMBzhYWFSk9P17hx4/T111/rl7/8pSZPnqy//e1v6tmzp44fP67jx4/rV7/6lYYPH67PPvtM99xzj44fP64333yz2bWnTJmitWvXOj5brVa3YvNa8g8ODtaIESOctvXs2VN9+vRptB0AAE95esW+u3Pz8vKcPufk5Cg8PFxFRUWaOHGiRowYoT/96U+O7wcPHqz/+q//0p133qmvv/5a/v6XT9FWq1WRkZHuBXQJr1/tDwBAR7iQ/D055+/Z8S+288PCwprdJyQkpNnEL0kFBQUKDw/XsGHDtHDhQp0+fdqtWDrFQ34uKigo8HYIAAA069u3mVut1hbb7na7XYsXL9b48eMv290+deqUVq5cqQULFjS71pQpU3TrrbcqNjZWhw8f1i9/+UulpqZq9+7dLp8y71TJHwCA9tJWt/pFR0c7bV+2bJmWL1/e7Nz09HQdOHBAu3btavL7qqoqTZ06VcOHD29xrVmzZjn+PHLkSMXHx2vw4MEqKCjQpEmTWv4hIvkDAEzC+GZ4Ml+6cKv6pXebtVT1Z2RkaMuWLdq5c6f69+/f6Pvq6mpNmTJFwcHBys3NVffu3d2Ka9CgQerbt68OHTpE8gcAoD24equ5YRhatGiRcnNzVVBQoNjY2Eb7VFVVKSUlRVarVZs3b3b5uTeXOnbsmE6fPq2oqCiX53DBHwDAFDr6IT/p6en6wx/+oPXr1ys4OFjl5eUqLy/XV199JelC4p88ebJqa2v10ksvqaqqyrHPpc+6iYuLU25urqQL78P5+c9/rj179ujIkSPKz8/X9OnTNWTIEKWkpLgcG5U/AMAc2qrv76Ls7GxJUlJSktP2tWvXau7cudq/f7/27t0rSRoyZIjTPqWlpRo4cKAkqaSkxHGngJ+fnz766COtW7dOZ86ckc1m0+TJk7Vy5Uq37vUn+QMAzMHTR/S6Oddo4d7ApKSkFvf59jqBgYHatm2bW3E0hbY/AAAmQ+UPADCFjn7CX2dG8gcAmAKv9G1A2x8AAJOh8gcAmINhcfuivUbzfQTJHwBgCpzzb0DbHwAAk6HyBwCYQwc/5KczI/kDAEyBq/0b0PYHAMBkqPwBAObhQ617T5D8AQCmQNu/AckfAGAOXPDnwDl/AABMhsofAGASlm+GJ/N9A8kfAGAOtP0daPsDAGAyVP4AAHOg8ncg+QMAzIG3+jnQ9gcAwGSo/AEApsArfRuQ/AEA5sA5fwfa/gAAmAyVPwDAHLjgz4HkDwAwBYtxYXgy31eQ/AEA5sA5fwfO+QMAYDJU/gAAc+CcvwPJHwBgDrT9HWj7AwBgMlT+AABzoPJ3IPkDAMyB5O9A2x8AAJOh8gcAmANX+zuQ/AEApsAT/hrQ9gcAwGS8mvyzs7MVHx+vkJAQhYSEKDExUVu3bvVmSAAAX2W0wXBDVlaWxo0bp+DgYIWHh2vGjBkqKSlx2ufs2bNKT09Xnz59FBQUpNtuu00VFRXN/wzD0NKlSxUVFaXAwEAlJyfr4MGDbsXm1eTfv39/PfHEEyoqKtK+fft00003afr06frkk0+8GRYAAB4rLCxUenq69uzZo+3bt+v8+fOaPHmyamtrHfvcf//9euedd7Rx40YVFhbq+PHjuvXWW5td96mnntKqVau0Zs0a7d27Vz179lRKSorOnj3rcmwWwzA61VmMsLAwPf3005o/f36L+1ZVVSk0NFRf/GOQQoJ95wxGim20t0MA0EltO17s7RDaVFW1Xb2H/lOVlZUKCQlpn2N8kytinnxM3QICWr2O/exZffbQw62O9fPPP1d4eLgKCws1ceJEVVZWql+/flq/fr1uv/12SdKnn36qq666Srt379b3vve9RmsYhiGbzaaf/exneuCBByRJlZWVioiIUE5OjmbNmuVSLC5d8NfSv0Ikyd/fX5GRkfr+97+vadOmuXTwS9XX12vjxo2qra1VYmJik/vU1dWprq7O8bmqqsrt4wAA4Ilv5x6r1Sqr1drivMrKSkkXilxJKioq0vnz55WcnOzYJy4uTgMGDLhs8i8tLVV5ebnTnNDQUCUkJGj37t0uJ3+XyuXQ0NAWR2BgoA4ePKiZM2dq6dKlLh1ckj7++GMFBQXJarXqnnvuUW5uroYPH97kvllZWU7HjI6Odvk4AACTu3irnydDUnR0tFMuysrKavHQdrtdixcv1vjx4zVixAhJUnl5uXr06KFevXo57RsREaHy8vIm17m4PSIiwuU5TXGp8l+7dq3LC27ZskX/7//9P61YscKl/YcNG6bi4mJVVlbqzTffVFpamgoLC5v8B8CSJUuUmZnp+FxVVcU/AAAArmmjJ/yVlZU5tf1dqfrT09N14MAB7dq1y4MA2k6b3+c/YcIEjR071uX9e/TooSFDhkiSxowZow8//FDPPvusnn/++Ub7utpaAQCgvVy8Q81VGRkZ2rJli3bu3Kn+/fs7tkdGRurcuXM6c+aMU/VfUVGhyMjIJte6uL2iokJRUVFOc0aPHu1yTG1+lVyvXr301ltvtXq+3W53Oq8PAECb6OBb/QzDUEZGhnJzc/X+++8rNjbW6fsxY8aoe/fuys/Pd2wrKSnR0aNHL3vtW2xsrCIjI53mVFVVae/evZed0xSvPuFvyZIlSk1N1YABA1RdXa3169eroKBA27Zt82ZYAAAf1NFP+EtPT9f69eu1adMmBQcHO87JX7xOLjQ0VPPnz1dmZqbCwsIUEhKiRYsWKTEx0eliv7i4OGVlZemWW26RxWLR4sWL9dhjj+nKK69UbGysHnnkEdlsNs2YMcPl2Lya/E+ePKm77rpLJ06cUGhoqOLj47Vt2zZ9//vf92ZYAAB4LDs7W5KUlJTktH3t2rWaO3euJOm3v/2tunXrpttuu011dXVKSUnR73//e6f9S0pKHHcKSNKDDz6o2tpaLViwQGfOnNGECROUl5enADduY+x09/m7g/v8AZgN9/m34hjf5IqBj/2Xx/f5H3n4P9s11o7Ci30AAObQRlf7+wLfKZcBAIBLqPwBAKbAK30bkPwBAOZwyVP6Wj3fR5D8AQDmwDl/B875AwBgMlT+AABT4Jx/A5I/AMAcaPs70PYHAMBkqPwBAObgYdvflyp/kj8AwBxo+zvQ9gcAwGSo/AEA5kDl70DyBwCYArf6NaDtDwCAyZD8AQAwGdr+AABz4Jy/A8kfAGAKnPNvQNsfAACTofIHAJiHD1XvniD5AwDMgXP+DrT9AQAwGSp/AIApcMFfA5I/AMAcaPs70PYHAMBkqPwBAKZA278ByR8AYA60/R1o+wMAYDJU/gAAc6DydyD5AwBMgXP+DUj+AABzoPJ34Jw/AAAmQ+UPADAHKn8Hkj8AwBQ459+Atj8AACZD8gcAmIPRBsMNO3fu1LRp02Sz2WSxWPT22287fW+xWJocTz/99GXXXL58eaP94+Li3AtMtP0BACbR0W3/2tpajRo1SnfffbduvfXWRt+fOHHC6fPWrVs1f/583Xbbbc2ue/XVV+u9995zfPb3dz+Vk/wBAGgHqampSk1Nvez3kZGRTp83bdqkG2+8UYMGDWp2XX9//0Zz3UXbHwBgDm3U9q+qqnIadXV1HodWUVGhd999V/Pnz29x34MHD8pms2nQoEGaM2eOjh496vbxSP4AAHNoo+QfHR2t0NBQx8jKyvI4tHXr1ik4OLjJ0wOXSkhIUE5OjvLy8pSdna3S0lJdf/31qq6udut4tP0BAHBDWVmZQkJCHJ+tVqvHa7788suaM2eOAgICmt3v0tMI8fHxSkhIUExMjN544w2XugYXebXyz8rK0rhx4xQcHKzw8HDNmDFDJSUl3gwJAOCjLG0wJCkkJMRpeJr8//d//1clJSX68Y9/7PbcXr16aejQoTp06JBb87ya/AsLC5Wenq49e/Zo+/btOn/+vCZPnqza2lpvhgUA8EUdfKufq1566SWNGTNGo0aNcntuTU2NDh8+rKioKLfmebXtn5eX5/Q5JydH4eHhKioq0sSJE70UFQDAF3X0rX41NTVOFXlpaamKi4sVFhamAQMGSLpw8eDGjRv161//usk1Jk2apFtuuUUZGRmSpAceeEDTpk1TTEyMjh8/rmXLlsnPz0+zZ892K7ZOdc6/srJSkhQWFublSAAA8My+fft04403Oj5nZmZKktLS0pSTkyNJ2rBhgwzDuGzyPnz4sE6dOuX4fOzYMc2ePVunT59Wv379NGHCBO3Zs0f9+vVzK7ZOk/ztdrsWL16s8ePHa8SIEU3uU1dX53RLRVVVVUeFBwDo6jr4xT5JSUkyjOYnLViwQAsWLLjs90eOHHH6vGHDBveCuIxOc6tfenq6Dhw40OwPy8rKcrq9Ijo6ugMjBAB0eZ3sfL+3dIrkn5GRoS1btmjHjh3q37//ZfdbsmSJKisrHaOsrKwDowQAwDd4te1vGIYWLVqk3NxcFRQUKDY2ttn9rVZrm9xPCQAwH17p28CryT89PV3r16/Xpk2bFBwcrPLycklSaGioAgMDvRkaAMDXdPA5/87Mq23/7OxsVVZWKikpSVFRUY7x+uuvezMsAAB8mtfb/gAAdATa/g06za1+AAC0K9r+Dp3ian8AANBxqPwBAKZA278ByR8AYA60/R1I/gAAcyD5O3DOHwAAk6HyBwCYAuf8G5D8AQDmQNvfgbY/AAAmQ+UPADAFi2HI4sGTZT2Z29mQ/AEA5kDb34G2PwAAJkPlDwAwBa72b0DyBwCYA21/B9r+AACYDJU/AMAUaPs3IPkDAMyBtr8DyR8AYApU/g045w8AgMlQ+QMAzIG2vwPJHwBgGr7UuvcEbX8AAEyGyh8AYA6GcWF4Mt9HkPwBAKbA1f4NaPsDAGAyVP4AAHPgan8Hkj8AwBQs9gvDk/m+grY/AAAmQ+UPADAH2v4OVP4AAFO4eLW/J8MdO3fu1LRp02Sz2WSxWPT22287fT937lxZLBanMWXKlBbXXb16tQYOHKiAgAAlJCTogw8+cC8wkfwBAGZx8T5/T4YbamtrNWrUKK1evfqy+0yZMkUnTpxwjD/+8Y/Nrvn6668rMzNTy5Yt0/79+zVq1CilpKTo5MmTbsVG2x8AgHaQmpqq1NTUZvexWq2KjIx0ec3f/OY3+slPfqJ58+ZJktasWaN3331XL7/8sn7xi1+4vA6VPwDAFNqq7V9VVeU06urqWh1TQUGBwsPDNWzYMC1cuFCnT5++7L7nzp1TUVGRkpOTHdu6deum5ORk7d69263jkvwBAOZgtMGQFB0drdDQUMfIyspqVThTpkzRK6+8ovz8fD355JMqLCxUamqq6uvrm9z/1KlTqq+vV0REhNP2iIgIlZeXu3Vs2v4AALihrKxMISEhjs9Wq7VV68yaNcvx55EjRyo+Pl6DBw9WQUGBJk2a5HGczaHyBwCYQlu1/UNCQpxGa5P/tw0aNEh9+/bVoUOHmvy+b9++8vPzU0VFhdP2iooKt64bkEj+AACz6OCr/d117NgxnT59WlFRUU1+36NHD40ZM0b5+fmObXa7Xfn5+UpMTHTrWCR/AADaQU1NjYqLi1VcXCxJKi0tVXFxsY4ePaqamhr9/Oc/1549e3TkyBHl5+dr+vTpGjJkiFJSUhxrTJo0Sc8995zjc2Zmpl588UWtW7dOf//737Vw4ULV1tY6rv53Fef8AQCm0NGv9N23b59uvPFGx+fMzExJUlpamrKzs/XRRx9p3bp1OnPmjGw2myZPnqyVK1c6nUY4fPiwTp065fg8c+ZMff7551q6dKnKy8s1evRo5eXlNboIsCUkfwCAOXTw432TkpJkNHOqYNu2bS2uceTIkUbbMjIylJGR4V4w30LbHwAAk6HyBwCYQke3/Tszr1b+Lb30AACANmM3PB8+wqvJ35WXHgAA0Cba6Al/vsCrbX9XXnoAAADaFuf8AQCmYJGH5/zbLBLv61LJv66uzuntSVVVVV6MBgDQpXj6lL52fsJfR+pSt/plZWU5vUkpOjra2yEBANDldKnkv2TJElVWVjpGWVmZt0MCAHQRbfViH1/Qpdr+Vqu1zd6eBAAwmQ5+wl9n5tXkX1NT4/TqwosvPQgLC9OAAQO8GBkAAL7Lq8m/uZce5OTkeCkqAIAvshiGLB5ctOfJ3M7Gq8m/pZceAADQZuzfDE/m+4gudcEfAADwXJe64A8AgNai7d+A5A8AMAeu9ncg+QMAzIEn/Dlwzh8AAJOh8gcAmIKnT+njCX8AAHQ1tP0daPsDAGAyVP4AAFOw2C8MT+b7CpI/AMAcaPs70PYHAMBkqPwBAObAQ34cSP4AAFPg8b4NaPsDAGAyVP4AAHPggj8Hkj8AwBwMSZ7cruc7uZ/kDwAwB875N+CcPwAAJkPlDwAwB0MenvNvs0i8juQPADAHLvhzIPl3QtuOF3s7BACADyP5AwDMwS7J4uF8H8EFfwAAU7h4tb8nwx07d+7UtGnTZLPZZLFY9Pbbbzu+O3/+vB566CGNHDlSPXv2lM1m01133aXjx483u+by5ctlsVicRlxcnNt/FyR/AADaQW1trUaNGqXVq1c3+u7LL7/U/v379cgjj2j//v166623VFJSoptvvrnFda+++mqdOHHCMXbt2uV2bLT9AQDm0MEX/KWmpio1NbXJ70JDQ7V9+3anbc8995yuvfZaHT16VAMGDLjsuv7+/oqMjHQrlm+j8gcAmMPF5O/JaEeVlZWyWCzq1atXs/sdPHhQNptNgwYN0pw5c3T06FG3j0XlDwCAG6qqqpw+W61WWa1Wj9Y8e/asHnroIc2ePVshISGX3S8hIUE5OTkaNmyYTpw4oUcffVTXX3+9Dhw4oODgYJePR+UPADCHNqr8o6OjFRoa6hhZWVkehXX+/HndcccdMgxD2dnZze6bmpqqH/7wh4qPj1dKSor+/Oc/68yZM3rjjTfcOiaVPwDAHNroVr+ysjKn6tyTqv9i4v/ss8/0/vvvN1v1N6VXr14aOnSoDh065NY8Kn8AgCm01a1+ISEhTqO1yf9i4j948KDee+899enTx+01ampqdPjwYUVFRbk1j+QPAEA7qKmpUXFxsYqLiyVJpaWlKi4u1tGjR3X+/Hndfvvt2rdvn1577TXV19ervLxc5eXlOnfunGONSZMm6bnnnnN8fuCBB1RYWKgjR47or3/9q2655Rb5+flp9uzZbsVG2x8AYA4dfKvfvn37dOONNzo+Z2ZmSpLS0tK0fPlybd68WZI0evRop3k7duxQUlKSJOnw4cM6deqU47tjx45p9uzZOn36tPr166cJEyZoz5496tevn1uxkfwBAOZgNySLB8nf7t7cpKQkGc38g6G57y46cuSI0+cNGza4FcPl0PYHAMBkqPwBAObAK30dSP4AAJPw9Cl9vpP8afsDAGAyVP4AAHOg7e9A8gcAmIPdkEetezev9u/MaPsDAGAyVP4AAHMw7BeGJ/N9BMkfAGAOnPN36BRt/9WrV2vgwIEKCAhQQkKCPvjgA2+HBADwNXbD8+EjvJ78X3/9dWVmZmrZsmXav3+/Ro0apZSUFJ08edLboQEA4JO8nvx/85vf6Cc/+YnmzZun4cOHa82aNbriiiv08ssvezs0AIAvudj292T4CK8m/3PnzqmoqEjJycmObd26dVNycrJ2797daP+6ujpVVVU5DQAAXGLIw+Tv7R/Qdrya/E+dOqX6+npFREQ4bY+IiFB5eXmj/bOyshQaGuoY0dHRHRUqAAA+w+ttf3csWbJElZWVjlFWVubtkAAAXQVtfwev3urXt29f+fn5qaKiwml7RUWFIiMjG+1vtVpltVo7KjwAgC+x2yV5cK++3Xfu8/dq5d+jRw+NGTNG+fn5jm12u135+flKTEz0YmQAAPgurz/kJzMzU2lpaRo7dqyuvfZaPfPMM6qtrdW8efO8HRoAwJfwkB8Hryf/mTNn6vPPP9fSpUtVXl6u0aNHKy8vr9FFgAAAeITk7+D15C9JGRkZysjI8HYYAACYQqdI/gAAtDte6etA8gcAmIJh2GV48GY+T+Z2NiR/AIA5GB6+nMeHzvl3qYf8AAAAz1H5AwDMwfDwnL8PVf4kfwCAOdjtksWD8/Y+dM6ftj8AACZD5Q8AMAfa/g4kfwCAKRh2uwwP2v6+dKsfbX8AAEyGyh8AYA60/R1I/gAAc7AbkoXkL9H2BwDAdKj8AQDmYBiSPLnP33cqf5I/AMAUDLshw4O2v+FDyZ+2PwDAHAy758MNO3fu1LRp02Sz2WSxWPT22287h2MYWrp0qaKiohQYGKjk5GQdPHiwxXVXr16tgQMHKiAgQAkJCfrggw/ciksi+QMA0C5qa2s1atQorV69usnvn3rqKa1atUpr1qzR3r171bNnT6WkpOjs2bOXXfP1119XZmamli1bpv3792vUqFFKSUnRyZMn3YrNYnThPkZVVZVCQ0P1xT8GKSSYf8cAQFdTVW1X76H/VGVlpUJCQtrnGN/kiiTLLfK3dG/1Ol8b51Vg5LYqVovFotzcXM2YMUPSharfZrPpZz/7mR544AFJUmVlpSIiIpSTk6NZs2Y1uU5CQoLGjRun5557TpJkt9sVHR2tRYsW6Re/+IXL8ZAxAQDm0MFt/+aUlpaqvLxcycnJjm2hoaFKSEjQ7t27m5xz7tw5FRUVOc3p1q2bkpOTLzvncrr0BX8XmxZVNb7zyEUAMJOL///dEU3or3Xeo2f8fK3zki50Ei5ltVpltVrdWqu8vFySFBER4bQ9IiLC8d23nTp1SvX19U3O+fTTT906fpdO/tXV1ZKkmO8e8W4gAACPVFdXKzQ0tF3W7tGjhyIjI7Wr/M8erxUUFKTo6GinbcuWLdPy5cs9Xrsjdenkb7PZVFZWpuDgYFkslnY9VlVVlaKjo1VWVtZu56U6kq/9Honf1FXwmzq/jvw9hmGourpaNput3Y4REBCg0tJSnTt3zuO1DMNolG/crfolKTIyUpJUUVGhqKgox/aKigqNHj26yTl9+/aVn5+fKioqnLZXVFQ41nNVl07+3bp1U//+/Tv0mCEhIT7xH/dFvvZ7JH5TV8Fv6vw66ve0V8V/qYCAAAUEBLT7cVwVGxuryMhI5efnO5J9VVWV9u7dq4ULFzY5p0ePHhozZozy8/MdFw7a7Xbl5+crIyPDreN36eQPAEBnVVNTo0OHDjk+l5aWqri4WGFhYRowYIAWL16sxx57TFdeeaViY2P1yCOPyGazORK7JE2aNEm33HKLI7lnZmYqLS1NY8eO1bXXXqtnnnlGtbW1mjdvnluxkfwBAGgH+/bt04033uj4nJmZKUlKS0tTTk6OHnzwQdXW1mrBggU6c+aMJkyYoLy8PKcOxeHDh3Xq1CnH55kzZ+rzzz/X0qVLVV5ertGjRysvL6/RRYAtIfm7yGq1atmyZa06t9MZ+drvkfhNXQW/qfPztd/jLUlJSc3exWCxWLRixQqtWLHisvscOXKk0baMjAy32/yNjt2VH/IDAADcx0N+AAAwGZI/AAAmQ/IHAMBkSP4AAJgMyd8FbfHu5M6ipfdLd0VZWVkaN26cgoODFR4erhkzZqikpMTbYXkkOztb8fHxjoesJCYmauvWrd4Oq8088cQTslgsWrx4sbdDabXly5fLYrE4jbi4OG+H5bF//etfuvPOO9WnTx8FBgZq5MiR2rdvn7fDQhsj+begrd6d3Fm09H7prqiwsFDp6enas2ePtm/frvPnz2vy5Mmqra31dmit1r9/fz3xxBMqKirSvn37dNNNN2n69On65JNPvB2axz788EM9//zzio+P93YoHrv66qt14sQJx9i1a5e3Q/LIF198ofHjx6t79+7aunWr/va3v+nXv/61evfu7e3Q0NYMNOvaa6810tPTHZ/r6+sNm81mZGVleTGqtiHJyM3N9XYYbe7kyZOGJKOwsNDbobSp3r17G//93//t7TA8Ul1dbVx55ZXG9u3bjRtuuMG47777vB1Sqy1btswYNWqUt8NoUw899JAxYcIEb4eBDkDl34y2fHcyOk5lZaUkKSwszMuRtI36+npt2LBBtbW1SkxM9HY4HklPT9fUqVOd/pvqyg4ePCibzaZBgwZpzpw5Onr0qLdD8sjmzZs1duxY/fCHP1R4eLiuueYavfjii94OC+2A5N+M5t6dfLn3LcO77Ha7Fi9erPHjx2vEiBHeDscjH3/8sYKCgmS1WnXPPfcoNzdXw4cP93ZYrbZhwwbt379fWVlZ3g6lTSQkJCgnJ0d5eXnKzs5WaWmprr/+eserxruif/7zn8rOztaVV16pbdu2aeHChbr33nu1bt06b4eGNsbjfeFT0tPTdeDAgS5/7lWShg0bpuLiYlVWVurNN99UWlqaCgsLu+Q/AMrKynTfffdp+/btnerNap5ITU11/Dk+Pl4JCQmKiYnRG2+8ofnz53sxstaz2+0aO3asHn/8cUnSNddcowMHDmjNmjVKS0vzcnRoS1T+zWjLdyej/WVkZGjLli3asWNHh7/quT306NFDQ4YM0ZgxY5SVlaVRo0bp2Wef9XZYrVJUVKSTJ0/qu9/9rvz9/eXv76/CwkKtWrVK/v7+qq+v93aIHuvVq5eGDh3q9Ba3riYqKqrRPy6vuuqqLn86A42R/Jtx6buTL7r47uSufu7VlxiGoYyMDOXm5ur9999XbGyst0NqF3a7XXV1dd4Oo1UmTZqkjz/+WMXFxY4xduxYzZkzR8XFxfLz8/N2iB6rqanR4cOHFRUV5e1QWm38+PGNbpP9xz/+oZiYGC9FhPZC278FbfXu5M6ipfdLd0Xp6elav369Nm3apODgYMf1GKGhoQoMDPRydK2zZMkSpaamasCAAaqurtb69etVUFCgbdu2eTu0VgkODm50DUbPnj3Vp0+fLnttxgMPPKBp06YpJiZGx48f17Jly+Tn56fZs2d7O7RWu//++3Xdddfp8ccf1x133KEPPvhAL7zwgl544QVvh4a25u3bDbqC3/3ud8aAAQOMHj16GNdee62xZ88eb4fUajt27DAkNRppaWneDq3Vmvo9koy1a9d6O7RWu/vuu42YmBijR48eRr9+/YxJkyYZ//M//+PtsNpUV7/Vb+bMmUZUVJTRo0cP4zvf+Y4xc+ZM49ChQ94Oy2PvvPOOMWLECMNqtRpxcXHGCy+84O2Q0A54pS8AACbDOX8AAEyG5A8AgMmQ/AEAMBmSPwAAJkPyBwDAZEj+AACYDMkfAACTIfkDAGAyJH+gE5s7d65mzJjh7TAA+BiSPwAAJkPyBwDAZEj+AACYDMkfAACTIfkDAGAyJH8AAEyG5A8AgMmQ/AEAMBmSPwAAJmMxDMPwdhAAAKDjUPkDAGAyJH8AAEyG5A8AgMmQ/AEAMBmSPwAAJkPyBwDAZEj+AACYDMkfAACTIfkDAGAyJH8AAEyG5A8AgMmQ/AEAMJn/D89f9u3yLA9lAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qty_out = Quantity(data=np.zeros(shape),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "arr = np.indices(shape,dtype=float).sum(axis=0) # Value of each entry is sum of the I and J index at each point\n", + "qty_in = Quantity(data=arr,\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "print(\"Plotting values of qty_in at K = 0\")\n", + "plot_field_at_kN(qty_in.data,0)\n", + "print(\"Plotting values of qty_out at K = 0\")\n", + "plot_field_at_kN(qty_out.data,0)\n", + "print(\"Running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\")\n", + "copy_stencil(qty_in,qty_out,origin=(nhalo,nhalo,0),domain=(nx,ny,5))\n", + "print(\"Plotting values of qty_out at K = 0 based on running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\")\n", + "plot_field_at_kN(qty_out.data,0)\n", + "print(\"Plotting values of qty_out at K = 1 based on running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\")\n", + "plot_field_at_kN(qty_out.data,1)\n", + "\n", + "@stencil(backend=backend)\n", + "def stencil_if_zero(in_out_field: FloatField):\n", + " with computation(PARALLEL), interval(...):\n", + " if in_out_field == 0.0:\n", + " in_out_field = 30\n", + " else:\n", + " in_out_field = 10\n", + "print(\"Running 'stencil_if_zero' on qty_out\")\n", + "stencil_if_zero(qty_out)\n", + "print(\"Plotting values of qty_out at K = 0 based on running stencil_if_zero\")\n", + "plot_field_at_kN(qty_out.data,0)\n", + "print(\"Plotting values of qty_out at K = 1 based on running stencil_if_zero\")\n", + "plot_field_at_kN(qty_out.data,1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Function calls**\n", + "\n", + "GT4Py also has the capability to create functions in order to better organize code. The main difference between a GT4Py function call and a GT4Py stencil is that a function does not (and cannot) contain the keywords `computation` and `interval`. However, array index referencing within a GT4py function is the same as in a GT4Py stencil.\n", + "\n", + "GT4Py functions can be created by using the decorator `function` (Note: `function` originates from the package `gt4py.cartesian.gtscript`)." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_in at K = 0\n", + "Min and max values: 12.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting values of qty_out at K = 0\n", + "Min and max values: 0.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing 'field_plus_one'\n", + "Plotting values of qty_out at K = 0 after executing 'field_plus_one'\n", + "Min and max values: 13.0 1.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from gt4py.cartesian.gtscript import function\n", + "\n", + "@function\n", + "def plus_one(field: FloatField):\n", + " return field[0, 0, 0] + 1\n", + "\n", + "@stencil(backend=backend)\n", + "def field_plus_one(source: FloatField, target: FloatField):\n", + " with computation(PARALLEL), interval(...):\n", + " target = plus_one(source)\n", + "\n", + "nx = 5\n", + "ny = 5\n", + "nz = 5\n", + "nhalo = 1\n", + "backend=\"numpy\"\n", + "\n", + "shape = (nx + 2 * nhalo, ny + 2 * nhalo, nz)\n", + "\n", + "qty_out = Quantity(data=np.zeros(shape),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "arr = np.indices(shape, dtype=float).sum(axis=0) # Value of each entry is sum of the I and J index at each point\n", + "qty_in = Quantity(data=arr,\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "print(\"Plotting values of qty_in at K = 0\")\n", + "plot_field_at_kN(qty_in.data)\n", + "print(\"Plotting values of qty_out at K = 0\")\n", + "plot_field_at_kN(qty_out.data)\n", + "print(\"Executing 'field_plus_one'\")\n", + "field_plus_one(qty_in, qty_out)\n", + "print(\"Plotting values of qty_out at K = 0 after executing 'field_plus_one'\")\n", + "plot_field_at_kN(qty_out.data)" + ] + } + ], + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/NDSL/02_NDSL_basics.ipynb b/examples/NDSL/02_NDSL_basics.ipynb new file mode 100644 index 00000000..9675fa19 --- /dev/null +++ b/examples/NDSL/02_NDSL_basics.ipynb @@ -0,0 +1,492 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# **NDSL Basics** #\n", + "\n", + "### **Introduction**\n", + "After establishing the basics of using GT4Py, we'll take a look at developing an object-oriented coding approach with the NDSL middleware. Much of the object-oriented work comes from the development of [Pace](https://github.com/NOAA-GFDL/pace), the implementation of the FV3GFS / SHiELD atmospheric model using GT4Py and [DaCe](https://github.com/spcl/dace). The `StencilFactory` object will be introduced and demoed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Creating the `StencilFactory` object**\n", + "\n", + "The `StencilFactory` object enables the sharing of stencil properties across multiple stencils as well as \"build and execute\" the stencil. To help ease the introduction, the [`boilerplate` module](./boilerplate.py) contains a function `get_one_tile_factory` that takes the domain size, halo size, and backend of interest and returns a `StencilFactory` object. For more details about the objects needed to create the `StencilFactory`, the reader can view the [`get_one_tile_factory`](./boilerplate.py#get_one_tile_factory) function." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from basic_boilerplate import get_one_tile_factory, plot_field_at_k0\n", + "from ndsl import StencilFactory\n", + "\n", + "nx = 6\n", + "ny = 6\n", + "nz = 1\n", + "nhalo = 1\n", + "backend=\"numpy\"\n", + "\n", + "stencil_factory: StencilFactory = get_one_tile_factory(nx, ny, nz, nhalo, backend)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Creating the Copy stencil**\n", + "\n", + "The `NDSL` and `gt4py` module contain key terms that will be used to create the stencil. Many terms are covered in the [GT4Py basic tutorial](./01_basics.ipynb) notebook, but we'll briefly recap.\n", + "\n", + "- `FloatField` : This type can generally can be thought of as a `gt4py` 3-dimensional `numpy` array of floating point values.\n", + "\n", + "- `computation(PARALLEL)` : This keyword combination means that there is no assumed order to perform calcuations in the `k` (3rd) dimension of a `gt4py` storage. `PARALLEL` can be replaced by `FORWARD` or `BACKWARD` for serialized calculations in the `k` dimension.\n", + "\n", + "- `interval(...)` : This keyword specifies the range of computation in the `k` dimension.\n", + "\n", + "The code below contains the Copy stencil implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from ndsl.dsl.typing import FloatField\n", + "from gt4py.cartesian.gtscript import PARALLEL, computation, interval\n", + "\n", + "def copy_field_stencil(field_in: FloatField, field_out: FloatField):\n", + " with computation(PARALLEL), interval(...):\n", + " field_out = field_in" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that a decorator does not surround this stencil as shown before in the [basic tutorial](./01_basics.ipynb). Instead, we'll use the `StencilFactory` to \"initiate\" the stencil." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Creating a class that performs a stencil computation**\n", + "\n", + "Using the `StencilFactory` object created earlier, the code will now create a class `CopyField` that takes `copy_field_stencil` and defines the computation domain from the parameters `origin` and `domain` within `__init__`. `origin` indicates the \"starting\" point of the stencil calculation, and `domain` indicates the extent of the stencil calculation in the 3 dimensions. Note that when creating `stencil_factory`, a 6 by 6 by 1 sized domain surrounded with a halo layer of size 1 was defined (see the initialization of `grid_indexing` at [boilerplate.py](./boilerplate.py#get_one_tile_factory)). Thus, whenever a `CopyField` object is created, it will perform calcuations within the 6 by 6 by 1 domain (specified by `domain=grid_indexing.domain_compute()`), and the 'origin' will start at the `[0,0,0]` location of the 6 by 6 by 1 grid (specified by `origin=grid_indexing.origin_compute()`)." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "class CopyField:\n", + " def __init__(self, stencil_factory: StencilFactory):\n", + " grid_indexing = stencil_factory.grid_indexing\n", + " self._copy_field = stencil_factory.from_origin_domain(\n", + " copy_field_stencil, # <-- gt4py stencil function wrapped into NDSL\n", + " origin=grid_indexing.origin_compute(),\n", + " domain=grid_indexing.domain_compute(),\n", + " )\n", + "\n", + " def __call__( # <-- Runtime path\n", + " self,\n", + " field_in: FloatField,\n", + " field_out: FloatField,\n", + " ):\n", + " self._copy_field(field_in, field_out)\n", + " \n", + " \n", + "copy_field = CopyField(stencil_factory)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Allocating Data in `NDSL`**\n", + "\n", + "The next code section will create arrays using `Quantity`. For more information about `Quantity`, see the [GT4Py Basic tutorial](./01_gt4py_basics.ipynb#Copy_Stencil_example)." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting qty_in at K = 0\n", + "Min and max values: 14.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting qty_out at K = 0\n", + "Min and max values: 0.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## Change this to Quantity\n", + "\n", + "import gt4py.storage as gt_storage\n", + "from ndsl.quantity import Quantity\n", + "import numpy as np\n", + "\n", + "size = (nx + 2 * nhalo) * (ny + 2 * nhalo) * nz\n", + "shape = (nx + 2 * nhalo, ny + 2 * nhalo, nz)\n", + "\n", + "qty_out = Quantity(data=np.zeros(shape),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "\n", + "\n", + "\n", + "arr = np.indices(shape,dtype=float).sum(axis=0) # Value of each entry is sum of the I and J index at each point\n", + "\n", + "qty_in = Quantity(data=arr,\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend)\n", + "\n", + "print(\"Plotting qty_in at K = 0\")\n", + "plot_field_at_k0(qty_in.data)\n", + "print(\"Plotting qty_out at K = 0\")\n", + "plot_field_at_k0(qty_out.data)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Calling `copy_field` stencil**\n", + "\n", + "The code will call `copy_field` to execute `copy_field_stencil` using the previously defined `Quantity` data containers and plot the result at `k = 0`." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Copying copy_field stencil\n", + "Plotting qty_out at K = 0\n", + "Min and max values: 12.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Copying copy_field stencil\")\n", + "copy_field(qty_in, qty_out)\n", + "print(\"Plotting qty_out at K = 0\")\n", + "plot_field_at_k0(qty_out.data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the plot, we see that the copy is only applied to the inner 6 by 6 area and not the entire domain. The stencil in this case only applies in this \"domain\" and not the \"halo\" region surrounding the domain." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Applying a J offset**\n", + "\n", + "The next example will create a stencil that takes a `Quantity` as an input, shift the input by 1 in the `-j` direction, and write it to an output `Quantity`. This stencil is defined in `copy_field_offset_stencil`.\n", + "\n", + "Note that in `copy_field_offset_stencil`, the shift in the J dimension is performed by referencing the `J` object from `gt4py.cartesian.gtscript` for simplicity. This reference will apply the shift in J to the entire input domain. Another way to perform the shift without referencing the `J` object is to write `[0,-1,0]` (assuming that the variable being modified is 3-dimensional) instead of `[J-1]`.\n", + "\n", + "With the stencil in place, a class `CopyFieldOffset` is defined using the `StencilFactory` object and `copy_field_offset_stencil`. The class is instantiated and demonstrated to shift `qty_in` by 1 in the J-dimension and write to `qty_out`." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialize qty_out to zeros\n" + ] + } + ], + "source": [ + "from gt4py.cartesian.gtscript import J\n", + "\n", + "def copy_field_offset_stencil(field_in: FloatField, field_out: FloatField):\n", + " with computation(PARALLEL), interval(...):\n", + " field_out = field_in[J-1]\n", + " \n", + "class CopyFieldOffset:\n", + " def __init__(self, stencil_factory: StencilFactory):\n", + " grid_indexing = stencil_factory.grid_indexing\n", + " self._copy_field_offset = stencil_factory.from_origin_domain(\n", + " copy_field_offset_stencil,\n", + " origin=grid_indexing.origin_compute(),\n", + " domain=grid_indexing.domain_compute(),\n", + " )\n", + "\n", + " def __call__(\n", + " self,\n", + " field_in: FloatField,\n", + " field_out: FloatField,\n", + " ):\n", + " self._copy_field_offset(field_in, field_out)\n", + " \n", + "copy_field_offset = CopyFieldOffset(stencil_factory)\n", + " \n", + "qty_out = Quantity(data=np.zeros(shape),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "print(\"Initialize qty_out to zeros\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing copy_field_offset stencil\n", + "Plotting values of qty_out at K = 0\n", + "Min and max values: 11.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Executing copy_field_offset stencil\")\n", + "copy_field_offset(qty_in, qty_out)\n", + "print(\"Plotting values of qty_out at K = 0\")\n", + "plot_field_at_k0(qty_out.data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Limits to offset : Cannot set offset outside of usable domain**\n", + "\n", + "Note that when the copy offset by -1 in the j-direction is performed, the 'halo' region at J = 8 is copied over due to the `J` shift. This means that there are limits to the shift amount since choosing a large shift amount may result in accessing a data region that does not exist. The following example shows this by trying to perform a shift by -2 in the j-direction." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Origin for field field_in too small. Must be at least (0, 2, 0), is (1, 1, 0)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_6732/2658447685.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0mcopy_field_offset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCopyFieldOffset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstencil_factory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m \u001b[0mcopy_field_offset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqty_in\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mqty_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/tmp/ipykernel_6732/2658447685.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, field_in, field_out)\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0mfield_out\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mFloatField\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m ):\n\u001b[0;32m---> 19\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_copy_field_offset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfield_in\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfield_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0mcopy_field_offset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCopyFieldOffset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstencil_factory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/NDSL/ndsl/dsl/stencil.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 418\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m__debug__\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;34m\"domain\"\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 419\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"domain cannot be passed to FrozenStencil call\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 420\u001b[0;31m self.stencil_object(\n\u001b[0m\u001b[1;32m 421\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 422\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/SMT-Nebulae-Tutorial/tutorial/NDSL/.gt_cache_000000/py311_1013/numpy/__main__/copy_field_offset_stencil/m_copy_field_offset_stencil__numpy_d84da3ed67.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, field_in, field_out, domain, origin, validate_args, exec_info)\u001b[0m\n\u001b[1;32m 78\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 80\u001b[0;31m self._call_run(\n\u001b[0m\u001b[1;32m 81\u001b[0m \u001b[0mfield_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfield_args\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 82\u001b[0m \u001b[0mparameter_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparameter_args\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_object.py\u001b[0m in \u001b[0;36m_call_run\u001b[0;34m(self, field_args, parameter_args, domain, origin, validate_args, exec_info)\u001b[0m\n\u001b[1;32m 582\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 583\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mvalidate_args\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 584\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validate_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray_infos\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparameter_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdomain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 585\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 586\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_domain_origin_cache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcache_key\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mdomain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_object.py\u001b[0m in \u001b[0;36m_validate_args\u001b[0;34m(self, arg_infos, param_args, domain, origin)\u001b[0m\n\u001b[1;32m 466\u001b[0m )\n\u001b[1;32m 467\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfield_domain_origin\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mmin_origin\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 468\u001b[0;31m raise ValueError(\n\u001b[0m\u001b[1;32m 469\u001b[0m \u001b[0;34mf\"Origin for field {name} too small. Must be at least {min_origin}, is {field_domain_origin}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 470\u001b[0m )\n", + "\u001b[0;31mValueError\u001b[0m: Origin for field field_in too small. Must be at least (0, 2, 0), is (1, 1, 0)" + ] + } + ], + "source": [ + "def copy_field_offset_stencil(field_in: FloatField, field_out: FloatField):\n", + " with computation(PARALLEL), interval(...):\n", + " field_out = field_in[J-2]\n", + " \n", + "class CopyFieldOffset:\n", + " def __init__(self, stencil_factory: StencilFactory):\n", + " grid_indexing = stencil_factory.grid_indexing\n", + " self._copy_field_offset = stencil_factory.from_origin_domain(\n", + " copy_field_offset_stencil,\n", + " origin=grid_indexing.origin_compute(),\n", + " domain=grid_indexing.domain_compute(),\n", + " )\n", + "\n", + " def __call__(\n", + " self,\n", + " field_in: FloatField,\n", + " field_out: FloatField,\n", + " ):\n", + " self._copy_field_offset(field_in, field_out)\n", + " \n", + "copy_field_offset = CopyFieldOffset(stencil_factory)\n", + "\n", + "copy_field_offset(qty_in, qty_out)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Example demonstrating error when writing to offset outputs**\n", + "\n", + "While offsets can be applied to all input `Quantity` variables in a stencil, output `Quantity` variables cannot have such offsets. When an offset is applied to an output stencil calcuation, the error `GTScriptSyntaxError: Assignment to non-zero offsets is not supported.` will be displayed." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "ename": "GTScriptSyntaxError", + "evalue": "Assignment to non-zero offsets is not supported.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mGTScriptSyntaxError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_6732/416380115.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_copy_field_offset_output\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfield_in\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfield_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m \u001b[0mcopy_field_offset_output\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCopyFieldOffsetOutput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstencil_factory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 24\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/tmp/ipykernel_6732/416380115.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, stencil_factory)\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstencil_factory\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mStencilFactory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mgrid_indexing\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstencil_factory\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrid_indexing\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m self._copy_field_offset_output = stencil_factory.from_origin_domain(\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0mcopy_field_offset_output_stencil\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgrid_indexing\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0morigin_compute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/NDSL/ndsl/dsl/stencil.py\u001b[0m in \u001b[0;36mfrom_origin_domain\u001b[0;34m(self, func, origin, domain, externals, skip_passes)\u001b[0m\n\u001b[1;32m 910\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 911\u001b[0m \u001b[0mcls\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFrozenStencil\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 912\u001b[0;31m return cls(\n\u001b[0m\u001b[1;32m 913\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 914\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morigin\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/NDSL/ndsl/dsl/stencil.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, func, origin, domain, stencil_config, externals, skip_passes, timing_collector, comm)\u001b[0m\n\u001b[1;32m 361\u001b[0m \u001b[0mblock_waiting_for_compilation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mMPI\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCOMM_WORLD\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompilation_config\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 362\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 363\u001b[0;31m self.stencil_object = gtscript.stencil(\n\u001b[0m\u001b[1;32m 364\u001b[0m \u001b[0mdefinition\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 365\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/gtscript.py\u001b[0m in \u001b[0;36mstencil\u001b[0;34m(backend, definition, build_info, dtypes, externals, format_source, name, rebuild, cache_settings, raise_if_not_cached, **kwargs)\u001b[0m\n\u001b[1;32m 317\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_decorator\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 318\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 319\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_decorator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 320\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 321\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/gtscript.py\u001b[0m in \u001b[0;36m_decorator\u001b[0;34m(definition_func)\u001b[0m\n\u001b[1;32m 304\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 305\u001b[0m \u001b[0moriginal_annotations\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_set_arg_dtypes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtypes\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 306\u001b[0;31m out = gt_loader.gtscript_loader(\n\u001b[0m\u001b[1;32m 307\u001b[0m \u001b[0mdefinition_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 308\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/loader.py\u001b[0m in \u001b[0;36mgtscript_loader\u001b[0;34m(definition_func, backend, build_options, externals, dtypes)\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mbuild_options\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0mbuild_options\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mf\"{definition_func.__name__}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 75\u001b[0;31m stencil_class = load_stencil(\n\u001b[0m\u001b[1;32m 76\u001b[0m \u001b[0;34m\"gtscript\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdefinition_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuild_options\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 77\u001b[0m )\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/loader.py\u001b[0m in \u001b[0;36mload_stencil\u001b[0;34m(frontend_name, backend_name, definition_func, externals, dtypes, build_options)\u001b[0m\n\u001b[1;32m 58\u001b[0m )\n\u001b[1;32m 59\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 60\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuild\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_builder.py\u001b[0m in \u001b[0;36mbuild\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 91\u001b[0m \u001b[0;34mf\"The stencil {self._definition.__name__} is not up to date in the cache\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 92\u001b[0m )\n\u001b[0;32m---> 93\u001b[0;31m \u001b[0mstencil_class\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 94\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mstencil_class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36mgenerate\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_impl_opts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"disable-code-generation\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[0msrc_dir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmkdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparents\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexist_ok\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 110\u001b[0;31m \u001b[0mrecursive_write\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msrc_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate_computation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 111\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake_module\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36mgenerate_computation\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[0mignore_np_errstate\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend_opts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"ignore_np_errstate\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 95\u001b[0;31m \u001b[0msource\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mNpirCodegen\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnpir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mignore_np_errstate\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mignore_np_errstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 96\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat_source\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0msource\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformat_source\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"python\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msource\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36mnpir\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"gtcnumpy:npir\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend_data\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_backend_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_npir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 136\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36m_make_npir\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_make_npir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mnpir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mComputation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 114\u001b[0;31m \u001b[0mbase_oir\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGTIRToOIR\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgtir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 115\u001b[0m oir_pipeline = self.builder.options.backend_opts.get(\n\u001b[1;32m 116\u001b[0m \u001b[0;34m\"oir_pipeline\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_builder.py\u001b[0m in \u001b[0;36mgtir\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 289\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 290\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgtir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mgtir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mStencil\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 291\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgtir_pipeline\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 292\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 293\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_builder.py\u001b[0m in \u001b[0;36mgtir_pipeline\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 282\u001b[0m \u001b[0;34m\"gtir_pipeline\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 283\u001b[0m GtirPipeline(\n\u001b[0;32m--> 284\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrontend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 285\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstencil_id\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 286\u001b[0m ),\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mgenerate\u001b[0;34m(cls, definition, externals, dtypes, options)\u001b[0m\n\u001b[1;32m 2124\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprepare_stencil_definition\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2125\u001b[0m \u001b[0mtranslator\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGTScriptParser\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2126\u001b[0;31m \u001b[0mdefinition_ir\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtranslator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2127\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2128\u001b[0m \u001b[0;31m# GTIR only supports LatLonGrids\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 2058\u001b[0m \u001b[0;31m# Generate definition IR\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2059\u001b[0m \u001b[0mdomain\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDomain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLatLonGrid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2060\u001b[0;31m computations = IRMaker(\n\u001b[0m\u001b[1;32m 2061\u001b[0m \u001b[0mfields\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfields_decls\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2062\u001b[0m \u001b[0mparameters\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparameter_decls\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, ast_root)\u001b[0m\n\u001b[1;32m 780\u001b[0m \u001b[0mfunc_ast\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mast_root\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbody\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 781\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparsing_context\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParsingContext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCONTROL_FLOW\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 782\u001b[0;31m \u001b[0mcomputations\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc_ast\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 783\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 784\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcomputations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/SMT-Nebulae/sw_stack_path/install/python3/lib/python3.11/ast.py\u001b[0m in \u001b[0;36mvisit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 416\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'visit_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 417\u001b[0m \u001b[0mvisitor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeneric_visit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 418\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mvisitor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgeneric_visit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mvisit_FunctionDef\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 1595\u001b[0m \u001b[0mblocks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1596\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mstmt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfilter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mast\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAnnAssign\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbody\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1597\u001b[0;31m \u001b[0mblocks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstmt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1598\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1599\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mComputationBlock\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mitem\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mblocks\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/SMT-Nebulae/sw_stack_path/install/python3/lib/python3.11/ast.py\u001b[0m in \u001b[0;36mvisit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 416\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'visit_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 417\u001b[0m \u001b[0mvisitor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeneric_visit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 418\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mvisitor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgeneric_visit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mvisit_With\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 1587\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcompute_blocks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1588\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparsing_context\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mParsingContext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCONTROL_FLOW\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1589\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mgtc_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_visit_computation_node\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1590\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1591\u001b[0m \u001b[0;31m# Mixing nested `with` blocks with stmts not allowed\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36m_visit_computation_node\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 977\u001b[0m \u001b[0mstmts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 978\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mstmt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbody\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 979\u001b[0;31m \u001b[0mstmts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgtc_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstmt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 980\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparsing_context\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParsingContext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCONTROL_FLOW\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 981\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/SMT-Nebulae/sw_stack_path/install/python3/lib/python3.11/ast.py\u001b[0m in \u001b[0;36mvisit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 416\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'visit_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 417\u001b[0m \u001b[0mvisitor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeneric_visit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 418\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mvisitor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgeneric_visit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mvisit_Assign\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 1444\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mspatial_offset\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1445\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moffset\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moffset\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mspatial_offset\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1446\u001b[0;31m raise GTScriptSyntaxError(\n\u001b[0m\u001b[1;32m 1447\u001b[0m \u001b[0mmessage\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"Assignment to non-zero offsets is not supported.\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1448\u001b[0m \u001b[0mloc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLocation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_ast_node\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mGTScriptSyntaxError\u001b[0m: Assignment to non-zero offsets is not supported." + ] + } + ], + "source": [ + "from gt4py.cartesian.gtscript import J\n", + "\n", + "def copy_field_offset_output_stencil(field_in: FloatField, field_out: FloatField):\n", + " with computation(PARALLEL), interval(...):\n", + " field_out[0,1,0] = field_in\n", + " \n", + "class CopyFieldOffsetOutput:\n", + " def __init__(self, stencil_factory: StencilFactory):\n", + " grid_indexing = stencil_factory.grid_indexing\n", + " self._copy_field_offset_output = stencil_factory.from_origin_domain(\n", + " copy_field_offset_output_stencil,\n", + " origin=grid_indexing.origin_compute(),\n", + " domain=grid_indexing.domain_compute(),\n", + " )\n", + "\n", + " def __call__(\n", + " self,\n", + " field_in: FloatField,\n", + " field_out: FloatField,\n", + " ):\n", + " self._copy_field_offset_output(field_in, field_out)\n", + " \n", + "copy_field_offset_output = CopyFieldOffsetOutput(stencil_factory)\n", + " " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gt4py_jupyter", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/NDSL/03_orchestration_basics.ipynb b/examples/NDSL/03_orchestration_basics.ipynb new file mode 100644 index 00000000..86351257 --- /dev/null +++ b/examples/NDSL/03_orchestration_basics.ipynb @@ -0,0 +1,214 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# **NDSL Orchestration Basics**\n", + "\n", + "### **Introduction**\n", + "\n", + "When writing code using NDSL, there will be moments where an algorithm or code pattern does not match the stencil paradigm, and shoehorning the algorithm into the paradigm increases development difficulty. For these moments, we have a capability called orchestration that enables developers to use regular Python for non-stencil algorithms alongside stencil-based code via [DaCe](https://github.com/spcl/dace). DaCe also will attempt to find optimizations before output C++ code.\n", + "\n", + "In this example, we will explore how to orchestrate a codebase using NDSL.\n", + "\n", + "### **Orchestration Example**\n", + "\n", + "We'll step through a simple example that will orchestrate a codebase containing stencils and Python code. First we'll import the necessary packages." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-05-29 13:16:33|INFO|rank 0|ndsl.logging:Constant selected: ConstantVersions.GFS\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from gt4py.cartesian.gtscript import (\n", + " PARALLEL,\n", + " computation,\n", + " interval,\n", + ")\n", + "from ndsl import (\n", + " StencilFactory,\n", + " DaceConfig,\n", + " orchestrate,\n", + " QuantityFactory,\n", + ")\n", + "from ndsl.constants import X_DIM, Y_DIM, Z_DIM\n", + "from ndsl.dsl.typing import FloatField, Float\n", + "\n", + "from orch_boilerplate import get_one_tile_factory_orchestrated" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we'll define a simple stencil that sums the values around a point and applies a weight factor to that sum. Note that unlike [previous](./01_gt4py_basics.ipynb#Copy_Stencil_example) examples, we are not using the `@stencil` decorator since this stencil will be referenced within a `StencilFactory` function call." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def localsum_stencil(\n", + " field: FloatField, # type: ignore\n", + " result: FloatField, # type: ignore\n", + " weight: Float, # type: ignore\n", + "):\n", + " with computation(PARALLEL), interval(...):\n", + " result = weight * (\n", + " field[1, 0, 0] + field[0, 1, 0] + field[-1, 0, 0] + field[0, -1, 0]\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll define an object that enables the orchestration and combines both stencils and regular Python codes. The orchestration occurs with the `orchestrate` call in the `__init__` definition. Within `__call__`, there's a combination of both stencil and regular python codes." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class LocalSum:\n", + " def __init__(\n", + " self, stencil_factory: StencilFactory, quantity_factory: QuantityFactory\n", + " ) -> None:\n", + " orchestrate(\n", + " obj=self,\n", + " config=stencil_factory.config.dace_config\n", + " or DaceConfig(None, stencil_factory.backend),\n", + " )\n", + " grid_indexing = stencil_factory.grid_indexing\n", + " self._local_sum = stencil_factory.from_origin_domain(\n", + " localsum_stencil, # <-- gt4py stencil function wrapped into NDSL\n", + " origin=grid_indexing.origin_compute(),\n", + " domain=grid_indexing.domain_compute(),\n", + " )\n", + " self._tmp_field = quantity_factory.zeros(\n", + " [X_DIM, Y_DIM, Z_DIM], \"n/a\", dtype=dtype\n", + " )\n", + " self._n_halo = quantity_factory.sizer.n_halo\n", + "\n", + " def __call__(self, in_field: FloatField, out_result: FloatField) -> None:\n", + " self._local_sum(in_field, out_result, 2.0) # GT4Py Stencil\n", + " tmp_field = out_result[:, :, :] + 2 # Regular Python code\n", + " self._local_sum(tmp_field, out_result, 2.0) # GT4Py Stencil" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we'll create a simple driver that defines the domain and halo size, specifies the backend (`dace:cpu` in order to use DaCe), and uses the boilerplate code to create a stencil and quantity factory objects. These objects help define the computational domain used for this particular example. After defining quantities (`in_field` and `out_field`) to hold the appropriate values and creating an object `local_sum` for our combined stencil/Python calculation, `local_sum` is called to perform the computation. In the output, we can see DaCe orchestrating the code. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-05-29 13:16:33|INFO|rank 0|ndsl.logging:[DaCeOrchestration.BuildAndRun] Rank 0 reading/writing cache .gt_cache_FV3_A\n", + "2024-05-29 13:16:33|INFO|rank 0|ndsl.logging:Building DaCe orchestration\n", + "Inlined 2 SDFGs.\n", + "Fused 4 states.\n", + "Inferred 2 optional arrays.\n", + "SDFG 0: Eliminated 1 arrays: {'out_result_0'}.\n", + "Fused 2 states.\n", + "Inferred 4 optional arrays.\n", + "Inlined 2 SDFGs.\n", + "2024-05-29 13:16:34|INFO|rank 0|ndsl.logging:[DaCeOrchestration.BuildAndRun] LocalSum___call__:\n", + "StorageType.Default:\n", + " Alloc ref 0.01 mb\n", + " Alloc unref 0.00 mb\n", + " Pooled 0.00 mb\n", + " Top lvl alloc: 0.01mb\n", + "\n", + "[DaCe Config] Rank 0 loading SDFG /home/ckung/Documents/Code/SMT-Nebulae-Tutorial/tutorial/NDSL/.gt_cache_FV3_A/dacecache/LocalSum___call__\n" + ] + } + ], + "source": [ + "# ----- Driver ----- #\n", + "\n", + "if __name__ == \"__main__\":\n", + " # Settings\n", + " backend = \"dace:cpu\"\n", + " dtype = np.float64\n", + " origin = (0, 0, 0)\n", + " rebuild = True\n", + " tile_size = (3, 3, 3)\n", + "\n", + " # Setup\n", + " stencil_factory, qty_factory = get_one_tile_factory_orchestrated(\n", + " nx=tile_size[0],\n", + " ny=tile_size[1],\n", + " nz=tile_size[2],\n", + " nhalo=2,\n", + " backend=backend,\n", + " )\n", + " local_sum = LocalSum(stencil_factory, qty_factory)\n", + "\n", + " in_field = qty_factory.zeros([X_DIM, Y_DIM, Z_DIM], \"n/a\", dtype=dtype)\n", + " in_field.view[:] = 2.0\n", + " out_field = qty_factory.zeros([X_DIM, Y_DIM, Z_DIM], \"n/a\", dtype=dtype)\n", + "\n", + " # Run\n", + " local_sum(in_field, out_field)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gt4py_jupyter", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/NDSL/basic_boilerplate.py b/examples/NDSL/basic_boilerplate.py new file mode 100755 index 00000000..8b60474e --- /dev/null +++ b/examples/NDSL/basic_boilerplate.py @@ -0,0 +1,72 @@ +from ndsl import( + StencilFactory, + GridIndexing, + StencilConfig, + DaceConfig, + DaCeOrchestration, + CompilationConfig, + RunMode +) +import matplotlib.pyplot as plt + + +def get_one_tile_factory(nx, ny, nz, nhalo, backend) -> StencilFactory: + + dace_config = DaceConfig( + communicator=None, backend=backend, orchestration=DaCeOrchestration.Python + ) + + compilation_config = CompilationConfig( + backend=backend, + rebuild=True, + validate_args=True, + format_source=False, + device_sync=False, + run_mode=RunMode.BuildAndRun, + use_minimal_caching=False, + ) + + stencil_config = StencilConfig( + compare_to_numpy=False, + compilation_config=compilation_config, + dace_config=dace_config, + ) + + grid_indexing = GridIndexing( + domain=(nx, ny, nz), + n_halo=nhalo, + south_edge=True, + north_edge=True, + west_edge=True, + east_edge=True, + ) + + return StencilFactory(config=stencil_config, grid_indexing=grid_indexing) + + +def plot_field_at_k0(field): + + print("Min and max values:", field.max(), field.min()) + + fig = plt.figure() + fig.patch.set_facecolor("white") + ax = fig.add_subplot(111) + ax.set_facecolor(".4") + + f1 = ax.pcolormesh(field[:, :, 0]) + + cbar = plt.colorbar(f1) + plt.show() + +def plot_field_at_kN(field, k_index=0): + + print("Min and max values:", field[:,:,k_index].max(), field[:,:,k_index].min()) + plt.xlabel("I") + plt.ylabel("J") + + im = plt.imshow(field[:,:,k_index].transpose(), origin='lower') + + plt.colorbar(im) + plt.title("Plot at K = " + str(k_index)) + plt.show() + \ No newline at end of file diff --git a/examples/NDSL/orch_boilerplate.py b/examples/NDSL/orch_boilerplate.py new file mode 100644 index 00000000..996d29ee --- /dev/null +++ b/examples/NDSL/orch_boilerplate.py @@ -0,0 +1,63 @@ +import numpy as np +from ndsl import ( + StencilFactory, + DaceConfig, + DaCeOrchestration, + GridIndexing, + StencilConfig, + CompilationConfig, + RunMode, + SubtileGridSizer, + NullComm, + QuantityFactory, + TileCommunicator, + TilePartitioner, +) + +from typing import Tuple + + +def get_one_tile_factory_orchestrated( + nx, ny, nz, nhalo, backend +) -> Tuple[StencilFactory, QuantityFactory]: + """Create a 1 tile grid - no boundaries""" + dace_config = DaceConfig( + communicator=None, + backend=backend, + orchestration=DaCeOrchestration.BuildAndRun, + ) + + compilation_config = CompilationConfig( + backend=backend, + rebuild=True, + validate_args=True, + format_source=False, + device_sync=False, + run_mode=RunMode.BuildAndRun, + use_minimal_caching=False, + ) + + stencil_config = StencilConfig( + compare_to_numpy=False, + compilation_config=compilation_config, + dace_config=dace_config, + ) + + partitioner = TilePartitioner((1, 1)) + sizer = SubtileGridSizer.from_tile_params( + nx_tile=nx, + ny_tile=ny, + nz=nz, + n_halo=nhalo, + extra_dim_lengths={}, + layout=partitioner.layout, + tile_partitioner=partitioner, + ) + + tile_comm = TileCommunicator(comm=NullComm(0, 1, 42), partitioner=partitioner) + + grid_indexing = GridIndexing.from_sizer_and_communicator(sizer, tile_comm) + stencil_factory = StencilFactory(config=stencil_config, grid_indexing=grid_indexing) + quantity_factory = QuantityFactory(sizer, np) + + return stencil_factory, quantity_factory From 69dee7e3c2e883aafb005082e6ad52bfb17a7580 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Fri, 31 May 2024 12:18:15 -0400 Subject: [PATCH 029/154] Removed comment in quantity regarding pace issue 3 --- ndsl/quantity.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/ndsl/quantity.py b/ndsl/quantity.py index 178df991..dc30c685 100644 --- a/ndsl/quantity.py +++ b/ndsl/quantity.py @@ -298,8 +298,6 @@ def __init__( storage attribute is disabled and will raise an exception. Will raise a TypeError if this is given with a gt4py storage type as data """ - # ToDo: [Florian 01/23] Kill the abomination. - # See https://github.com/NOAA-GFDL/pace/issues/3 if ( not allow_mismatch_float_precision From 360c316e5b1c817bdaaf5363bf5187bdb0321acb Mon Sep 17 00:00:00 2001 From: Chris Kung Date: Mon, 3 Jun 2024 09:43:48 -0400 Subject: [PATCH 030/154] Added Fortran serialization notebooks --- .../01_serialize_fortran_data.ipynb | 667 ++++++++++++++++++ .../02_read_serialized_data_python.ipynb | 240 +++++++ 2 files changed, 907 insertions(+) create mode 100644 examples/Fortran_serialization/01_serialize_fortran_data.ipynb create mode 100644 examples/Fortran_serialization/02_read_serialized_data_python.ipynb diff --git a/examples/Fortran_serialization/01_serialize_fortran_data.ipynb b/examples/Fortran_serialization/01_serialize_fortran_data.ipynb new file mode 100644 index 00000000..743d15ee --- /dev/null +++ b/examples/Fortran_serialization/01_serialize_fortran_data.ipynb @@ -0,0 +1,667 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Serialbox Tutorial : Serializing Fortran Data**\n", + "\n", + "This notebook will cover the basics on extracting data within a Fortran program using [Serialbox](https://gridtools.github.io/serialbox/).\n", + "\n", + "### **Notebook Requirements**\n", + "\n", + "- Python v3.11.x to v3.12.x\n", + "- [NOAA/NASA Domain Specific Language Middleware](https://github.com/NOAA-GFDL/NDSL)\n", + "- `ipykernel==6.1.0`\n", + "- [`ipython_genutils`](https://pypi.org/project/ipython_genutils/)\n", + "- Fortran compiler that built Serialbox in the `NDSL` middleware (Note: The default build instructions for `NDSL` builds Serialbox such that it outputs to binary data files from Fortran. Serialbox has compiler options that enable it to write netCDF files.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Brief Serialbox Overview**\n", + "\n", + "[Serialbox](https://gridtools.github.io/serialbox/) is a library that can extract data from Fortran programs for use in code porting and verification. It uses directive-based code statements that are translated later into actual Serialbox library calls, which makes it approachable to use. Extracting data from a Fortran program using Serialbox essentially follows these steps.\n", + "\n", + "1) Initialize Serialbox\n", + "2) Create a savepoint\n", + "3) Save the data of interest\n", + "4) \"Clean up\" the savepoint\n", + "\n", + "These four steps corrolate to the following directives in Serialbox.\n", + "\n", + "1) `!$ser init directory='' prefix=''`\n", + "2) `!$ser savepoint `\n", + "3) `!$ser data =`\n", + "4) `!$ser cleanup`\n", + "\n", + "Note that in 3, multiple variables can be specified (ex: `!$ser data serialA=fortranA serialB=fortranB serialC=fortranC`)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Serialbox Example 1**\n", + "\n", + "We'll step through a basic example that extracts data from a Fortran code using Serialbox.\n", + "\n", + "The following sets the environment variables `SERIALBOX_EXAMPLE_PATH` and `SERIALBOX_INSTALL_PATH`. Afterwards, a Bash script issues commands that create a `Fortran` directory within `SERIALBOX_EXAMPLE_PATH` that will store the Fortran code used to demonstrate Serialbox commands. Be sure to change the environment variables `SERIALBOX_EXAMPLE_PATH` and `SERIALBOX_INSTALL_PATH` to ones that're appropriate for your machine." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env: SERIALBOX_EXAMPLE_PATH=/home/ckung/Documents/Code/SMT-Nebulae-Tutorial/tutorial/Fortran_porting\n", + "env: SERIALBOX_INSTALL_PATH=/home/ckung/Documents/Code/SMT-Nebulae/sw_stack_path/install/serialbox/\n" + ] + } + ], + "source": [ + "# Change SERIALBOX_EXAMPLE_PATH and SERIALBOX_INSTALL_PATH to appropriate paths\n", + "%env SERIALBOX_EXAMPLE_PATH=/home/ckung/Documents/Code/SMT-Nebulae-Tutorial/tutorial/Fortran_porting\n", + "%env SERIALBOX_INSTALL_PATH=/home/ckung/Documents/Code/SMT-Nebulae/sw_stack_path/install/serialbox/" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [], + "source": [ + "%%bash\n", + "\n", + "cd $SERIALBOX_EXAMPLE_PATH\n", + "\n", + "if [ ! -d \"./Fortran\" ]; then\n", + " mkdir Fortran\n", + "else\n", + " rm -rf Fortran\n", + " mkdir Fortran\n", + "fi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### **Serialbox directive calls in Fortran code**\n", + "\n", + "Next we'll issue commands that create and write the file `testSerialBox.F90` and move it to the previously created `Fortran` directory. This file will contain the Fortran program `testSerialBox` that allocates three arrays, writes random numbers into two arrays (`Qin_out`, `MASS`), and passes the arrays into the subroutine `FILLQ2ZERO1`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Writing testSerialBox.F90\n" + ] + } + ], + "source": [ + "%%writefile testSerialBox.F90\n", + "\n", + "program testSerialBox\n", + "\n", + " implicit none\n", + "\n", + " real, dimension(:,:,:), allocatable :: Qin_out, MASS\n", + " real, dimension(:,:), allocatable :: FILLQ_out\n", + "\n", + " integer :: N = 5\n", + "\n", + " allocate(Qin_out(N,N,N), MASS(N,N,N), FILLQ_out(N,N))\n", + "\n", + " call random_number(Qin_out)\n", + " call random_number(MASS)\n", + "\n", + " where(Qin_out < 0.1) Qin_out = -Qin_out\n", + "\n", + " print*, 'sum(Qin_out) = ', sum(Qin_out)\n", + " print*, 'sum(MASS) = ', sum(MASS)\n", + "\n", + "\n", + "!$ser init directory='.' prefix='FILLQ2ZERO_InOut'\n", + "!$ser savepoint sp1\n", + "!$ser mode write\n", + "!$ser data q_in=Qin_out m_in=MASS fq_in=FILLQ_out\n", + "\n", + " call FILLQ2ZERO1(Qin_out, MASS, FILLQ_out)\n", + "\n", + "!$ser data q_out=Qin_out m_out=MASS fq_out=FILLQ_out\n", + "!$ser cleanup\n", + " print*, 'sum(Qin_out) = ', sum(Qin_out)\n", + " print*, 'sum(FILLQ_out) = ', sum(FILLQ_out)\n", + "\n", + " contains\n", + "\n", + " subroutine FILLQ2ZERO1( Q, MASS, FILLQ )\n", + " real, dimension(:,:,:), intent(inout) :: Q\n", + " real, dimension(:,:,:), intent(in) :: MASS\n", + " real, dimension(:,:), intent( out) :: FILLQ\n", + " integer :: IM,JM,LM\n", + " integer :: I,J,K,L\n", + " real :: TPW, NEGTPW\n", + " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n", + " ! Fills in negative q values in a mass conserving way.\n", + " ! Conservation of TPW was checked.\n", + " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n", + " IM = SIZE( Q, 1 )\n", + " JM = SIZE( Q, 2 )\n", + " LM = SIZE( Q, 3 )\n", + " do j=1,JM\n", + " do i=1,IM\n", + " TPW = SUM( Q(i,j,:)*MASS(i,j,:) )\n", + " NEGTPW = 0.\n", + " do l=1,LM\n", + " if ( Q(i,j,l) < 0.0 ) then\n", + " NEGTPW = NEGTPW + ( Q(i,j,l)*MASS( i,j,l ) )\n", + " Q(i,j,l) = 0.0\n", + " endif\n", + " enddo\n", + " do l=1,LM\n", + " if ( Q(i,j,l) >= 0.0 ) then\n", + " Q(i,j,l) = Q(i,j,l)*( 1.0+NEGTPW/(TPW-NEGTPW) )\n", + " endif\n", + " enddo\n", + " FILLQ(i,j) = -NEGTPW\n", + " end do\n", + " end do\n", + " end subroutine FILLQ2ZERO1\n", + "end program" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [], + "source": [ + "%%bash\n", + "\n", + "mv testSerialBox.F90 $SERIALBOX_EXAMPLE_PATH/Fortran" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Assuming that we are interested in porting the subroutine `FILLQ2ZERO1`, we need the array data before and after calling `FILLQ2ZERO1`, which will let us set the initial data state in our ported code appropriately and have output data for comparison purposes. To get this data, there are directive-based Serialbox commands inserted before and after the call to `FILLQ2ZERO1` that follow the steps presented in the [Serialbox overview](#brief-serialbox-overview). Let's quickly examine the Serialbox commands before the call to `FILLQ2ZERO1`.\n", + "\n", + "- `!$ser init directory='.' prefix='FILLQ2ZERO_In'` : Initializes Serialbox and specifies that the extracted data will be written into the current path where the code is executed. The data will be grouped and named with the prefix `FILLQ2ZERO_In`.\n", + "\n", + "- `!$ser savepoint sp1` : Creates a savepoint with the name `sp1`.\n", + "\n", + "- `!$ser mode write` : Serialbox's operation mode will be to write data files. This is the default mode (have to check this). Other modes include `read`.\n", + "\n", + "- `!$ser data q_in=Qin_out m_in=MASS fq_in=FILLQ_out` : Serialbox will write the arrays out into data files. Note that the variable on the left side of `=` is the variable name that Serialbox will use, and the variable on the right side of `=` is the Fortran variable.\n", + "\n", + "After the `FILLQ2ZERO1` call, the Serialbox command `!$ser data...` records the resulting output arrays from `FILLQ2ZERO1` . `!$ser cleanup` indicates we're done with writing data and finalizes the files.\n", + "\n", + "#### **Translating Serialbox directive calls into actual library calls**\n", + "\n", + "While we've expressed the Serialbox commands using directives, these directives will need to be mapped to the appropriate Serialbox library calls. To do this, we run a Python script `pp_ser.py` (found in the Serialbox installation directory) that will replace the `!ser` directive statements will the appropriate Fortran Serialbox calls and will write a new `testSerialBox.F90` file. The following Bash commands will create an `sb` directory with the `Fortran` directory and execute the `pp_ser.py` script." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing file testSerialBox.F90\n" + ] + } + ], + "source": [ + "%%bash\n", + "\n", + "cd $SERIALBOX_EXAMPLE_PATH/Fortran\n", + "if [ ! -d \"./sb\" ]; then\n", + " mkdir sb\n", + "else\n", + " rm -rf sb\n", + " mkdir sb\n", + "fi\n", + "\n", + "python /home/ckung/Documents/Code/SMT-Nebulae/sw_stack/discover/sles15/src/2024.03.00/install/serialbox/python/pp_ser/pp_ser.py --output-dir=./sb testSerialBox.F90" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that we specified the option `--output-dir=./sb` when running `pp_ser.py`, which specifies the location where we want the resulting Fortran code with the Serialbox directives replaced with library calls. If we did not specify the output directory, executing `pp_ser.py` would simply print the Fortran code to the terminal. In the `sb` directory, we'll find a `testSerialBox.F90` file that contains the appropriate Serialbox calls." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 16\n", + "drwxrwxr-x 2 ckung ckung 4096 May 13 10:08 .\n", + "drwxrwxr-x 3 ckung ckung 4096 May 13 10:08 ..\n", + "-rw-rw-r-- 1 ckung ckung 5033 May 13 10:08 testSerialBox.F90\n" + ] + } + ], + "source": [ + "%%bash\n", + "\n", + "cd $SERIALBOX_EXAMPLE_PATH/Fortran/sb\n", + "ls -al" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### **Building and Running Fortran code with Serialbox library**\n", + "\n", + "Compiling the Fortran code with Serialbox requires the following during compilation:\n", + "\n", + "- References to the following Serialbox libraries (assuming that we want the resulting binary with libraries statically linked)\n", + " - `libSerialboxFortran.a`\n", + " - `libSerialboxC.a`\n", + " - `libSerialboxCore.a`\n", + " - `-lstdc++`\n", + " \n", + "- The `-DSERIALIZE` macro to activate the Serialbox codepath within the Fortran code. Note that not having this macro during compilation will result in a binary without Serialbox calls.\n", + "\n", + "- The `include` path from the Serialbox installation\n", + "\n", + "The compilation line can look as follows." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [], + "source": [ + "%%bash\n", + "\n", + "cd $SERIALBOX_EXAMPLE_PATH/Fortran/sb\n", + "\n", + "# Note: Adjust the libraries and include paths appropriately\n", + "\n", + "gfortran testSerialBox.F90 \\\n", + " $SERIALBOX_INSTALL_PATH/lib/libSerialboxFortran.a \\\n", + " $SERIALBOX_INSTALL_PATH/lib/libSerialboxC.a \\\n", + " $SERIALBOX_INSTALL_PATH/lib/libSerialboxCore.a \\\n", + " -lstdc++ \\\n", + " -DSERIALIZE \\\n", + " -I$SERIALBOX_INSTALL_PATH/include \\\n", + " -o testSerialBox.bin\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After successful compilation, we can execute the code. Note that whenever Serialbox is running, the code displays `WARNING: SERIALIZATION IS ON` in the terminal." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " sum(Qin_out) = 58.7446289 \n", + " sum(MASS) = 62.1698570 \n", + " >>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<\n", + " >>> WARNING: SERIALIZATION IS ON <<<\n", + " >>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<\n", + " sum(Qin_out) = 58.7851906 \n", + " sum(FILLQ_out) = 0.252184689 \n" + ] + } + ], + "source": [ + "%%bash\n", + "\n", + "cd $SERIALBOX_EXAMPLE_PATH/Fortran/sb\n", + "./testSerialBox.bin" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After the code executes, you will see several `.json` and `.dat` files that are named based on the Serialbox's written variables and the `prefix` specified during Serialbox's initialization." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 1028\n", + "drwxrwxr-x 2 ckung ckung 4096 May 13 10:08 .\n", + "drwxrwxr-x 3 ckung ckung 4096 May 13 10:08 ..\n", + "-rw-rw-r-- 1 ckung ckung 872 May 13 10:08 ArchiveMetaData-FILLQ2ZERO_InOut.json\n", + "-rw-rw-r-- 1 ckung ckung 100 May 13 10:08 FILLQ2ZERO_InOut_fq_in.dat\n", + "-rw-rw-r-- 1 ckung ckung 100 May 13 10:08 FILLQ2ZERO_InOut_fq_out.dat\n", + "-rw-rw-r-- 1 ckung ckung 500 May 13 10:08 FILLQ2ZERO_InOut_m_in.dat\n", + "-rw-rw-r-- 1 ckung ckung 500 May 13 10:08 FILLQ2ZERO_InOut_m_out.dat\n", + "-rw-rw-r-- 1 ckung ckung 500 May 13 10:08 FILLQ2ZERO_InOut_q_in.dat\n", + "-rw-rw-r-- 1 ckung ckung 500 May 13 10:08 FILLQ2ZERO_InOut_q_out.dat\n", + "-rw-rw-r-- 1 ckung ckung 7157 May 13 10:08 MetaData-FILLQ2ZERO_InOut.json\n", + "-rwxrwxr-x 1 ckung ckung 997608 May 13 10:08 testSerialBox.bin\n", + "-rw-rw-r-- 1 ckung ckung 5033 May 13 10:08 testSerialBox.F90\n" + ] + } + ], + "source": [ + "%%bash\n", + "\n", + "cd $SERIALBOX_EXAMPLE_PATH/Fortran/sb\n", + "ls -al" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Serialbox Example 2 : Looping Region**\n", + "\n", + "There may be cases where a function or subroutine is located within a looping region, and we want to check the values of a looping region. Serialbox enables saving data within a looping region by adding metadata to the `!$ser savepoint` declaration. In general, it can look like this.\n", + "\n", + "- `!$ser savepoint =`\n", + "\n", + "For example, if there's a timestep looping region that increments the variable `currTS`, we can use that variable to create separate savepoints within that looping region.\n", + "\n", + "- `!$ser savepoint sp timestep=currTS`\n", + "\n", + "In the example below, we'll use Serialbox to create multiple savepoints within a looping region." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [], + "source": [ + "%%bash\n", + "\n", + "cd $SERIALBOX_EXAMPLE_PATH\n", + "\n", + "if [ ! -d \"./Fortran_ts\" ]; then\n", + " mkdir Fortran_ts\n", + "else\n", + " rm -rf Fortran_ts\n", + " mkdir Fortran_ts\n", + "fi" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Writing testSerialBox_ts.F90\n" + ] + } + ], + "source": [ + "%%writefile testSerialBox_ts.F90\n", + "\n", + "program testSerialBox_ts\n", + "\n", + " implicit none\n", + "\n", + " real, dimension(:,:,:), allocatable :: Qin_out, MASS\n", + " real, dimension(:,:), allocatable :: FILLQ_out\n", + "\n", + " integer :: N = 5, N_ts = 10, t\n", + "\n", + " allocate(Qin_out(N,N,N), MASS(N,N,N), FILLQ_out(N,N))\n", + "\n", + "!$ser init directory='.' prefix='FILLQ2ZERO_InOut'\n", + "\n", + " do t = 1, N_ts\n", + "\n", + " call random_number(Qin_out)\n", + " call random_number(MASS)\n", + "\n", + " where(Qin_out < 0.1) Qin_out = -Qin_out\n", + "\n", + " print*, 'sum(Qin_out) = ', sum(Qin_out)\n", + " print*, 'sum(MASS) = ', sum(MASS)\n", + "\n", + "\n", + "!$ser savepoint sp1 timestep=t\n", + "!$ser data q_in=Qin_out m_in=MASS fq_in=FILLQ_out\n", + "\n", + " call FILLQ2ZERO1(Qin_out, MASS, FILLQ_out)\n", + "\n", + "!$ser data q_out=Qin_out m_out=MASS fq_out=FILLQ_out\n", + "\n", + "! print*, 'sum(Qin_out) = ', sum(Qin_out)\n", + "! print*, 'sum(FILLQ_out) = ', sum(FILLQ_out)\n", + "\n", + " enddo\n", + " \n", + "!$ser cleanup\n", + " contains\n", + "\n", + " subroutine FILLQ2ZERO1( Q, MASS, FILLQ )\n", + " real, dimension(:,:,:), intent(inout) :: Q\n", + " real, dimension(:,:,:), intent(in) :: MASS\n", + " real, dimension(:,:), intent( out) :: FILLQ\n", + " integer :: IM,JM,LM\n", + " integer :: I,J,K,L\n", + " real :: TPW, NEGTPW\n", + " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n", + " ! Fills in negative q values in a mass conserving way.\n", + " ! Conservation of TPW was checked.\n", + " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n", + " IM = SIZE( Q, 1 )\n", + " JM = SIZE( Q, 2 )\n", + " LM = SIZE( Q, 3 )\n", + " do j=1,JM\n", + " do i=1,IM\n", + " TPW = SUM( Q(i,j,:)*MASS(i,j,:) )\n", + " NEGTPW = 0.\n", + " do l=1,LM\n", + " if ( Q(i,j,l) < 0.0 ) then\n", + " NEGTPW = NEGTPW + ( Q(i,j,l)*MASS( i,j,l ) )\n", + " Q(i,j,l) = 0.0\n", + " endif\n", + " enddo\n", + " do l=1,LM\n", + " if ( Q(i,j,l) >= 0.0 ) then\n", + " Q(i,j,l) = Q(i,j,l)*( 1.0+NEGTPW/(TPW-NEGTPW) )\n", + " endif\n", + " enddo\n", + " FILLQ(i,j) = -NEGTPW\n", + " end do\n", + " end do\n", + " end subroutine FILLQ2ZERO1\n", + "end program" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing file testSerialBox_ts.F90\n", + " >>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<\n", + " >>> WARNING: SERIALIZATION IS ON <<<\n", + " >>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<\n", + " sum(Qin_out) = 61.9121895 \n", + " sum(MASS) = 59.9121780 \n", + " sum(Qin_out) = 56.1568756 \n", + " sum(MASS) = 64.7800751 \n", + " sum(Qin_out) = 61.0407639 \n", + " sum(MASS) = 63.4687958 \n", + " sum(Qin_out) = 58.9772873 \n", + " sum(MASS) = 62.4764175 \n", + " sum(Qin_out) = 62.8103752 \n", + " sum(MASS) = 63.0623398 \n", + " sum(Qin_out) = 64.0034027 \n", + " sum(MASS) = 59.7669296 \n", + " sum(Qin_out) = 66.0840454 \n", + " sum(MASS) = 58.6753502 \n", + " sum(Qin_out) = 60.5121956 \n", + " sum(MASS) = 62.7025185 \n", + " sum(Qin_out) = 65.6868591 \n", + " sum(MASS) = 70.1329956 \n", + " sum(Qin_out) = 60.6698227 \n", + " sum(MASS) = 63.8359032 \n", + "total 1052\n", + "drwxrwxr-x 2 ckung ckung 4096 May 13 10:08 .\n", + "drwxrwxr-x 3 ckung ckung 4096 May 13 10:08 ..\n", + "-rw-rw-r-- 1 ckung ckung 6457 May 13 10:08 ArchiveMetaData-FILLQ2ZERO_InOut.json\n", + "-rw-rw-r-- 1 ckung ckung 1000 May 13 10:08 FILLQ2ZERO_InOut_fq_in.dat\n", + "-rw-rw-r-- 1 ckung ckung 1000 May 13 10:08 FILLQ2ZERO_InOut_fq_out.dat\n", + "-rw-rw-r-- 1 ckung ckung 5000 May 13 10:08 FILLQ2ZERO_InOut_m_in.dat\n", + "-rw-rw-r-- 1 ckung ckung 5000 May 13 10:08 FILLQ2ZERO_InOut_m_out.dat\n", + "-rw-rw-r-- 1 ckung ckung 5000 May 13 10:08 FILLQ2ZERO_InOut_q_in.dat\n", + "-rw-rw-r-- 1 ckung ckung 5000 May 13 10:08 FILLQ2ZERO_InOut_q_out.dat\n", + "-rw-rw-r-- 1 ckung ckung 9456 May 13 10:08 MetaData-FILLQ2ZERO_InOut.json\n", + "-rwxrwxr-x 1 ckung ckung 997648 May 13 10:08 testSerialBox_ts.bin\n", + "-rw-rw-r-- 1 ckung ckung 5117 May 13 10:08 testSerialBox_ts.F90\n" + ] + } + ], + "source": [ + "%%bash\n", + "\n", + "mv testSerialBox_ts.F90 $SERIALBOX_EXAMPLE_PATH/Fortran_ts\n", + "\n", + "cd $SERIALBOX_EXAMPLE_PATH/Fortran_ts\n", + "if [ ! -d \"./sb\" ]; then\n", + " mkdir sb\n", + "else\n", + " rm -rf sb\n", + " mkdir sb\n", + "fi\n", + "\n", + "python /home/ckung/Documents/Code/SMT-Nebulae/sw_stack/discover/sles15/src/2024.03.00/install/serialbox/python/pp_ser/pp_ser.py --output-dir=./sb testSerialBox_ts.F90\n", + "\n", + "cd $SERIALBOX_EXAMPLE_PATH/Fortran_ts/sb\n", + "\n", + "gfortran testSerialBox_ts.F90 \\\n", + " $SERIALBOX_INSTALL_PATH/lib/libSerialboxFortran.a \\\n", + " $SERIALBOX_INSTALL_PATH/lib/libSerialboxC.a \\\n", + " $SERIALBOX_INSTALL_PATH/lib/libSerialboxCore.a \\\n", + " -lstdc++ \\\n", + " -DSERIALIZE \\\n", + " -I$SERIALBOX_INSTALL_PATH/include \\\n", + " -o testSerialBox_ts.bin\n", + "\n", + "./testSerialBox_ts.bin\n", + "\n", + "ls -al" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gt4py_jupyter", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/Fortran_serialization/02_read_serialized_data_python.ipynb b/examples/Fortran_serialization/02_read_serialized_data_python.ipynb new file mode 100644 index 00000000..c8265202 --- /dev/null +++ b/examples/Fortran_serialization/02_read_serialized_data_python.ipynb @@ -0,0 +1,240 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Serialbox Tutorial : Incorporating Fortran Serialbox Data into Python**\n", + "\n", + "In the [previous notebook](./01_serialize_fortran_data.ipynb), we covered how to extract data from a Fortran code using Serialbox. In this notebook, we'll cover how to read and incorporate those files within a Python code." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Notebook Requirements**\n", + "\n", + "- Python v3.11.x to v3.12.x\n", + "- [NOAA/NASA Domain Specific Language Middleware](https://github.com/NOAA-GFDL/NDSL)\n", + "- `ipykernel==6.1.0`\n", + "- [`ipython_genutils`](https://pypi.org/project/ipython_genutils/)\n", + "\n", + "This notebook assumes that the code from the [previous notebook](./01_serialize_fortran_data.ipynb) was run, and the serialized data from Fortran was written out." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Importing Fortran Serialbox Data From Example 1 into Python** ###\n", + "\n", + "We'll step through importing Serialbox data [created in Fortran](./01_serialize_fortran_data.ipynb#Serialbox-Example-1) into Python to test a Python port of `FILLQ2ZERO1`. Importing Serialbox data into Python essentially comes from opening a file via a \"serializer\" object denoted by a particular Serialbox initialization prefix (see [Serialbox directive calls in Fortran code](./01_serialize_fortran_data.ipynb#Serialbox-directive-calls-in-Fortran-code)) and stepping through the savepoints within the \"serializer\" object to read the data. This is done by the following Python calls assuming that the imported `serialbox` package is referenced via `ser`.\n", + "\n", + "- `ser.Serializer(ser.OpenModeKind.Read,\"\", \"\")` : This function call creates a \"serializer\" object that will read Serialbox files within a declared path and reference data from a particular Serialbox initialization prefix.\n", + "\n", + "- `serializer.savepoint_list()` : Using a \"serializer\" object called `serializer`, this function call creates a list of Serialbox savepoints\n", + "\n", + "- `serializer.read(\"\", )` : Using a \"serializer\" object called `serializer`, this function call will look for the specified Serialbox variable name from the savepoint list and output that variable.\n", + "\n", + "Below is a Python example that uses these three calls to import the [Example 1](./01_serialize_fortran_data.ipynb#Serialbox-Example-1) Fortran data into Python. You can check to see that the summation of the arrays with Python match closely with the [values presented in Fortran](./01_serialize_fortran_data.ipynb#Building-and-Running-Fortran-code-with-Serialbox-library)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sum of Qin_out = 57.30306911468506\n", + "Sum of mass = 65.57122611999512\n", + "Sum of fq_out = 0.0\n" + ] + } + ], + "source": [ + "import sys\n", + "# Appends the Serialbox python path to PYTHONPATH. If needed, change to appropriate path containing serialbox installation\n", + "sys.path.append('/home/ckung/Documents/Code/SMT-Nebulae/sw_stack_path/install/serialbox/python')\n", + "import serialbox as ser\n", + "import numpy as np\n", + "\n", + "# If needed, change the path in second parameter of ser.Serializer to appropriate path that contains Fortran data via Serialbox from 01.ipynb\n", + "serializer = ser.Serializer(ser.OpenModeKind.Read,\"./Fortran/sb/\",\"FILLQ2ZERO_InOut\")\n", + "\n", + "savepoints = serializer.savepoint_list()\n", + "\n", + "Qin_out = serializer.read(\"q_in\", savepoints[0])\n", + "mass = serializer.read(\"m_in\", savepoints[0])\n", + "fq_out = serializer.read(\"fq_in\", savepoints[0])\n", + "\n", + "print('Sum of Qin_out = ', sum(sum(sum(Qin_out))))\n", + "print('Sum of mass = ', sum(sum(sum(mass))))\n", + "print('Sum of fq_out = ', sum(sum(fq_out)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we'll create a rudimentary port of `fillq2zero1` and test whether or not it computes properly by comparing the output arrays `Qin_out` and `fq_out` to the corresonding arrays created from Fortran, which are retrieved using `serializer.read()`. In this example, the comparison between the Fortran and Python data is performed using `np.allclose`; however, note that the proper metric of comparison will depend on the application. We'll see that `np.allclose()` will report `True` for both the `Qin_out` and `fq_out` array comparisons. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sum of Qin_out = 57.2715950012207\n", + "Sum of fq_out = 0.36869711382314563\n", + "True\n", + "True\n" + ] + } + ], + "source": [ + "def fillq2zero1(Q, MASS, FILLQ):\n", + " IM = Q.shape[0]\n", + " JM = Q.shape[1]\n", + " LM = Q.shape[2]\n", + "\n", + " TPW = np.sum(Q*MASS,2)\n", + " for J in range(JM):\n", + " for I in range(IM):\n", + " NEGTPW = 0.\n", + " for L in range(LM):\n", + " if(Q[I,J,L] < 0.0):\n", + " NEGTPW = NEGTPW + (Q[I,J,L]*MASS[I,J,L])\n", + " Q[I,J,L] = 0.0\n", + " for L in range(LM):\n", + " if(Q[I,J,L] >= 0.0):\n", + " Q[I,J,L] = Q[I,J,L]*(1.0 + NEGTPW/(TPW[I,J]-NEGTPW))\n", + " FILLQ[I,J] = -NEGTPW\n", + " \n", + "fillq2zero1(Qin_out,mass,fq_out)\n", + "\n", + "print('Sum of Qin_out = ', sum(sum(sum(Qin_out))))\n", + "print('Sum of fq_out = ', sum(sum(fq_out)))\n", + "\n", + "Qin_out_ref = serializer.read(\"q_out\", savepoints[0])\n", + "mass_ref = serializer.read(\"m_out\", savepoints[0])\n", + "fq_out_ref = serializer.read(\"fq_out\", savepoints[0])\n", + "\n", + "print(np.allclose(Qin_out,Qin_out_ref))\n", + "print(np.allclose(fq_out,fq_out_ref))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Importing Fortran Data from Example 2 into Python : Looping Regions** ###\n", + "\n", + "In [Example 2](./01_serialize_fortran_data.ipynb#Serialbox-Example-2), Serialbox was set up to record data within a looping region. This results in a larger list of savepoints that we can step through in Python to recreating the looping process done in Fortran. The code below replicates the looping of `FILLQ2ZERO1` and reads multiple savepoints to intialize the data and compare outputs." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current savepoint = sp1 {\"timestep\": 1, \"ID\": 1}\n", + "SUM(Qin_out) = 63.43995475769043\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 2, \"ID\": 2}\n", + "SUM(Qin_out) = 59.70357894897461\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 3, \"ID\": 3}\n", + "SUM(Qin_out) = 59.850998878479004\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 4, \"ID\": 4}\n", + "SUM(Qin_out) = 62.012206077575684\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 5, \"ID\": 5}\n", + "SUM(Qin_out) = 60.80107021331787\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 6, \"ID\": 6}\n", + "SUM(Qin_out) = 60.730340003967285\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 7, \"ID\": 7}\n", + "SUM(Qin_out) = 61.0941276550293\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 8, \"ID\": 8}\n", + "SUM(Qin_out) = 59.69675540924072\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 9, \"ID\": 9}\n", + "SUM(Qin_out) = 67.9124870300293\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 10, \"ID\": 10}\n", + "SUM(Qin_out) = 60.42111110687256\n", + "True\n", + "True\n" + ] + } + ], + "source": [ + "# If needed, change the path in second parameter of ser.Serializer to appropriate path that contains Fortran data via Serialbox from 01.ipynb\n", + "serializer = ser.Serializer(ser.OpenModeKind.Read,\"./Fortran_ts/sb/\",\"FILLQ2ZERO_InOut\")\n", + "\n", + "savepoints = serializer.savepoint_list()\n", + "\n", + "for currentSavepoint in savepoints:\n", + " Qin_out = serializer.read(\"q_in\", currentSavepoint)\n", + " mass = serializer.read(\"m_in\", currentSavepoint)\n", + " fq_out = serializer.read(\"fq_in\", currentSavepoint)\n", + "\n", + " fillq2zero1(Qin_out,mass,fq_out)\n", + "\n", + " Qin_out_ref = serializer.read(\"q_out\", currentSavepoint)\n", + " mass_ref = serializer.read(\"m_out\", currentSavepoint)\n", + " fq_out_ref = serializer.read(\"fq_out\", currentSavepoint)\n", + "\n", + " print('Current savepoint = ', currentSavepoint)\n", + " print('SUM(Qin_out) = ', sum(sum(sum(Qin_out))))\n", + " print(np.allclose(Qin_out,Qin_out_ref))\n", + " print(np.allclose(fq_out,fq_out_ref))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gt4py_jupyter", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 30e09072090cb50105df7f793bcf89f64e30adc1 Mon Sep 17 00:00:00 2001 From: Chris Kung Date: Mon, 3 Jun 2024 10:09:58 -0400 Subject: [PATCH 031/154] Local linting --- examples/NDSL/basic_boilerplate.py | 21 +++++++++++---------- examples/NDSL/orch_boilerplate.py | 15 ++++++++------- 2 files changed, 19 insertions(+), 17 deletions(-) diff --git a/examples/NDSL/basic_boilerplate.py b/examples/NDSL/basic_boilerplate.py index 8b60474e..9cd3ebe9 100755 --- a/examples/NDSL/basic_boilerplate.py +++ b/examples/NDSL/basic_boilerplate.py @@ -1,13 +1,14 @@ -from ndsl import( - StencilFactory, - GridIndexing, - StencilConfig, +import matplotlib.pyplot as plt + +from ndsl import ( + CompilationConfig, DaceConfig, DaCeOrchestration, - CompilationConfig, - RunMode + GridIndexing, + RunMode, + StencilConfig, + StencilFactory, ) -import matplotlib.pyplot as plt def get_one_tile_factory(nx, ny, nz, nhalo, backend) -> StencilFactory: @@ -58,15 +59,15 @@ def plot_field_at_k0(field): cbar = plt.colorbar(f1) plt.show() + def plot_field_at_kN(field, k_index=0): - print("Min and max values:", field[:,:,k_index].max(), field[:,:,k_index].min()) + print("Min and max values:", field[:, :, k_index].max(), field[:, :, k_index].min()) plt.xlabel("I") plt.ylabel("J") - im = plt.imshow(field[:,:,k_index].transpose(), origin='lower') + im = plt.imshow(field[:, :, k_index].transpose(), origin="lower") plt.colorbar(im) plt.title("Plot at K = " + str(k_index)) plt.show() - \ No newline at end of file diff --git a/examples/NDSL/orch_boilerplate.py b/examples/NDSL/orch_boilerplate.py index 996d29ee..f8739a3e 100644 --- a/examples/NDSL/orch_boilerplate.py +++ b/examples/NDSL/orch_boilerplate.py @@ -1,21 +1,22 @@ +from typing import Tuple + import numpy as np + from ndsl import ( - StencilFactory, + CompilationConfig, DaceConfig, DaCeOrchestration, GridIndexing, - StencilConfig, - CompilationConfig, - RunMode, - SubtileGridSizer, NullComm, QuantityFactory, + RunMode, + StencilConfig, + StencilFactory, + SubtileGridSizer, TileCommunicator, TilePartitioner, ) -from typing import Tuple - def get_one_tile_factory_orchestrated( nx, ny, nz, nhalo, backend From a601d0580fd4b65b37bfeaad78fbd1901115e62e Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Mon, 3 Jun 2024 15:53:25 -0400 Subject: [PATCH 032/154] Updated version to 2024.06.00 --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index bb0ff1dd..a2484e20 100644 --- a/setup.py +++ b/setup.py @@ -50,7 +50,7 @@ def local_pkg(name: str, relative_path: str) -> str: packages=find_namespace_packages(include=["ndsl", "ndsl.*"]), include_package_data=True, url="https://github.com/NOAA-GFDL/NDSL", - version="2024.04.00", + version="2024.06.00", zip_safe=False, entry_points={ "console_scripts": [ From 3d0c7adc38d01eaf351444e1b2597c9e3b7ada48 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 16:14:31 -0400 Subject: [PATCH 033/154] try test --- .github/workflows/unit_tests.yaml | 33 ++++++++++++++++--------------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 77a0d5c2..bc008319 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -1,33 +1,34 @@ name: "Unit tests" on: + push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] +# cancel running jobs if theres a newer push +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + jobs: all: runs-on: ubuntu-latest - strategy: - matrix: - python: [3.8.12, 3.11.7] + container: + image: ghcr.io/noaa-gfdl/miniforge:mpich steps: - name: Checkout repository - uses: actions/checkout@v3.5.2 + uses: actions/checkout@v4 with: submodules: 'recursive' - - name: Setup Python - uses: actions/setup-python@v4.6.0 - with: - python-version: ${{ matrix.python }} - - name: Install OpenMPI & Boost for gt4py - run: | - sudo apt-get install libopenmpi-dev libboost1.74-dev - name: Install Python packages run: | - python -m pip install --upgrade pip setuptools wheel - pip install .[test] + conda create --name=test python=3.11.7 -y + conda activate test + pip3 install .[test] - name: Run serial-cpu tests - run: | - pytest -x tests + run: coverage run --rcfile=setup.cfg -m pytest -x tests - name: Run parallel-cpu tests + run: mpirun -np 6 coverage run --rcfile=setup.cfg -m mpi4py -m pytest -x tests/mpi + - name: output coverage run: | - mpirun -np 6 --oversubscribe pytest -x tests/mpi + coverage combine + coverage report From 3803a5b761fe5a727dc208fff32b8d399f435b18 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 16:16:25 -0400 Subject: [PATCH 034/154] conda init --- .github/workflows/unit_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index bc008319..a4ef716d 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -22,7 +22,7 @@ jobs: - name: Install Python packages run: | conda create --name=test python=3.11.7 -y - conda activate test + conda init && conda activate test pip3 install .[test] - name: Run serial-cpu tests run: coverage run --rcfile=setup.cfg -m pytest -x tests From 45dace20f4930042a3023ac7ac03b41725bc2b89 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 16:20:14 -0400 Subject: [PATCH 035/154] conda init --- .github/workflows/unit_tests.yaml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index a4ef716d..e8c31be5 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -22,7 +22,8 @@ jobs: - name: Install Python packages run: | conda create --name=test python=3.11.7 -y - conda init && conda activate test + conda init + conda activate test pip3 install .[test] - name: Run serial-cpu tests run: coverage run --rcfile=setup.cfg -m pytest -x tests From 20bae61f60b7171d9000d9ce19c9846bae554a0b Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 16:23:00 -0400 Subject: [PATCH 036/154] echo y --- .github/workflows/unit_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index e8c31be5..ad90103f 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -21,7 +21,7 @@ jobs: submodules: 'recursive' - name: Install Python packages run: | - conda create --name=test python=3.11.7 -y + echo "y" | conda create --name=test python=3.11.7 conda init conda activate test pip3 install .[test] From bee9222e775cdefd6308ab020b6756b43ebdc787 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 16:26:46 -0400 Subject: [PATCH 037/154] source --- .github/workflows/unit_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index ad90103f..a4fa362f 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -22,7 +22,7 @@ jobs: - name: Install Python packages run: | echo "y" | conda create --name=test python=3.11.7 - conda init + source /root/.bashrc && conda init conda activate test pip3 install .[test] - name: Run serial-cpu tests From d0ff431a88c6e4a57e58701bc8a4396a4aeccf3c Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 16:28:55 -0400 Subject: [PATCH 038/154] . --- .github/workflows/unit_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index a4fa362f..2c1c0221 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -22,7 +22,7 @@ jobs: - name: Install Python packages run: | echo "y" | conda create --name=test python=3.11.7 - source /root/.bashrc && conda init + . /root/.bashrc && conda init conda activate test pip3 install .[test] - name: Run serial-cpu tests From 6881340be0be61614306415cd6d06abf13565ce3 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 16:33:16 -0400 Subject: [PATCH 039/154] bash --- .github/workflows/unit_tests.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 2c1c0221..3a5fce43 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -21,6 +21,7 @@ jobs: submodules: 'recursive' - name: Install Python packages run: | + bash echo "y" | conda create --name=test python=3.11.7 . /root/.bashrc && conda init conda activate test From d461ea11b00d436022e4097eb916b6733fa6d4b8 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 16:39:42 -0400 Subject: [PATCH 040/154] . --- .github/workflows/unit_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 3a5fce43..43c02ca9 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -23,7 +23,7 @@ jobs: run: | bash echo "y" | conda create --name=test python=3.11.7 - . /root/.bashrc && conda init + conda init conda activate test pip3 install .[test] - name: Run serial-cpu tests From a4ff3c17834943adf28085cae666c40ea8e42be1 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 16:49:20 -0400 Subject: [PATCH 041/154] try again --- .github/workflows/unit_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 43c02ca9..ad650884 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -23,7 +23,7 @@ jobs: run: | bash echo "y" | conda create --name=test python=3.11.7 - conda init + /opt/view/setup.sh conda activate test pip3 install .[test] - name: Run serial-cpu tests From 770b465b9134607b6bf3e9c2dc60ae4d2a9954eb Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 16:54:13 -0400 Subject: [PATCH 042/154] s --- .github/workflows/unit_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index ad650884..feeac29d 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -1,4 +1,4 @@ -name: "Unit tests" +name: "Unit tests" on: push: pull_request: From 532d7376da090c034d42d69e095c44edc307d545 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 17:02:56 -0400 Subject: [PATCH 043/154] test --- .github/workflows/unit_tests.yaml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index feeac29d..434dac68 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -22,9 +22,6 @@ jobs: - name: Install Python packages run: | bash - echo "y" | conda create --name=test python=3.11.7 - /opt/view/setup.sh - conda activate test pip3 install .[test] - name: Run serial-cpu tests run: coverage run --rcfile=setup.cfg -m pytest -x tests From b5d5694e60c770bfcbcc3560f91a6dda47515eec Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 17:24:23 -0400 Subject: [PATCH 044/154] mpiexec --- .github/workflows/unit_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index ef703602..edd940a3 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -26,7 +26,7 @@ jobs: - name: Run serial-cpu tests run: coverage run --rcfile=setup.cfg -m pytest -x tests - name: Run parallel-cpu tests - run: mpirun -np 6 coverage run --rcfile=setup.cfg -m mpi4py -m pytest -x tests/mpi + run: mpiexec -np 6 --oversubscribe coverage run --rcfile=setup.cfg -m mpi4py -m pytest -x tests/mpi - name: Output code coverage run: | coverage combine From eee00a4f353aac80e346937e9391254dd2054d73 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 17:36:23 -0400 Subject: [PATCH 045/154] remove extra space --- .github/workflows/unit_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index edd940a3..8daa7cf8 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -1,4 +1,4 @@ -name: "Unit tests" +name: "Unit tests" on: push: pull_request: From ef725505c06df266ba0f82831d6227c646a56727 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 5 Jun 2024 17:37:12 -0400 Subject: [PATCH 046/154] more fixes --- .github/workflows/unit_tests.yaml | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 8daa7cf8..58822036 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -1,6 +1,5 @@ name: "Unit tests" on: - push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] @@ -20,9 +19,7 @@ jobs: with: submodules: 'recursive' - name: Install Python packages - run: | - bash - pip3 install .[test] + run: pip3 install .[test] - name: Run serial-cpu tests run: coverage run --rcfile=setup.cfg -m pytest -x tests - name: Run parallel-cpu tests From 047bb6ab65c4ffada3536b9c12f21bbca2a37123 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 6 Jun 2024 10:47:08 -0400 Subject: [PATCH 047/154] separate build --- .github/workflows/unit_tests.yaml | 3 +-- external/dace | 2 +- external/gt4py | 2 +- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 58822036..8d021198 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -1,5 +1,6 @@ name: "Unit tests" on: + push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] @@ -18,8 +19,6 @@ jobs: uses: actions/checkout@v4 with: submodules: 'recursive' - - name: Install Python packages - run: pip3 install .[test] - name: Run serial-cpu tests run: coverage run --rcfile=setup.cfg -m pytest -x tests - name: Run parallel-cpu tests diff --git a/external/dace b/external/dace index b1a7f8a6..8632b8ba 160000 --- a/external/dace +++ b/external/dace @@ -1 +1 @@ -Subproject commit b1a7f8a6ea76f913a0bf8b32de5bc416697218fd +Subproject commit 8632b8babaa248c6e13d584cee21c2bfc8f9cbcf diff --git a/external/gt4py b/external/gt4py index 66f84473..f472c904 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit 66f8447398762127ba51c7a335d0da7ada369219 +Subproject commit f472c9041dca338a8d73c7226ee7892ac00ab78d From 3239abda8eb7324e06b2ad9d92fe3c1beeb666b3 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 6 Jun 2024 10:47:39 -0400 Subject: [PATCH 048/154] add untracked file --- .github/workflows/build_test.yaml | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 .github/workflows/build_test.yaml diff --git a/.github/workflows/build_test.yaml b/.github/workflows/build_test.yaml new file mode 100644 index 00000000..8a45d874 --- /dev/null +++ b/.github/workflows/build_test.yaml @@ -0,0 +1,28 @@ +name: "Build test" +on: + push: + pull_request: + types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] + +jobs: + all: + runs-on: ubuntu-latest + strategy: + matrix: + python: [3.8.12, 3.11.7] + steps: + - name: Checkout repository + uses: actions/checkout@v3.5.2 + with: + submodules: 'recursive' + - name: Setup Python + uses: actions/setup-python@v4.6.0 + with: + python-version: ${{ matrix.python }} + - name: Install OpenMPI & Boost for gt4py + run: | + sudo apt-get install libopenmpi-dev libboost1.74-dev + - name: Install Python packages + run: | + python -m pip install --upgrade pip setuptools wheel + pip install .[test] From 4164b282ff089f36e1335e1eefd63e92efda694d Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 6 Jun 2024 10:54:40 -0400 Subject: [PATCH 049/154] update to develop --- external/dace | 2 +- external/gt4py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/external/dace b/external/dace index b1a7f8a6..8632b8ba 160000 --- a/external/dace +++ b/external/dace @@ -1 +1 @@ -Subproject commit b1a7f8a6ea76f913a0bf8b32de5bc416697218fd +Subproject commit 8632b8babaa248c6e13d584cee21c2bfc8f9cbcf diff --git a/external/gt4py b/external/gt4py index 66f84473..f472c904 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit 66f8447398762127ba51c7a335d0da7ada369219 +Subproject commit f472c9041dca338a8d73c7226ee7892ac00ab78d From c9d237942b4ad5e4b8e8155fa17dd7ea485390f1 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 6 Jun 2024 10:55:11 -0400 Subject: [PATCH 050/154] remove push --- .github/workflows/build_test.yaml | 1 - .github/workflows/unit_tests.yaml | 1 - 2 files changed, 2 deletions(-) diff --git a/.github/workflows/build_test.yaml b/.github/workflows/build_test.yaml index 8a45d874..5d19f5f3 100644 --- a/.github/workflows/build_test.yaml +++ b/.github/workflows/build_test.yaml @@ -1,6 +1,5 @@ name: "Build test" on: - push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 8d021198..f225868a 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -1,6 +1,5 @@ name: "Unit tests" on: - push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] From c9fb6e6f3769e712127b83ded72c9d67da471653 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 6 Jun 2024 10:58:10 -0400 Subject: [PATCH 051/154] concurrency --- .github/workflows/build_test.yaml | 5 +++++ .github/workflows/lint.yaml | 5 +++++ 2 files changed, 10 insertions(+) diff --git a/.github/workflows/build_test.yaml b/.github/workflows/build_test.yaml index 5d19f5f3..e56aabe2 100644 --- a/.github/workflows/build_test.yaml +++ b/.github/workflows/build_test.yaml @@ -3,6 +3,11 @@ on: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] +# cancel running jobs if theres a newer push +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + jobs: all: runs-on: ubuntu-latest diff --git a/.github/workflows/lint.yaml b/.github/workflows/lint.yaml index 0cab2313..6051711a 100644 --- a/.github/workflows/lint.yaml +++ b/.github/workflows/lint.yaml @@ -3,6 +3,11 @@ on: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] +# cancel running jobs if theres a newer push +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + jobs: lint: runs-on: ubuntu-latest From 712045dacc5fc5111f86eb8b18b27770435aa0ff Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 6 Jun 2024 11:01:09 -0400 Subject: [PATCH 052/154] submodule woes --- external/dace | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/external/dace b/external/dace index 8632b8ba..ee5a6dfe 160000 --- a/external/dace +++ b/external/dace @@ -1 +1 @@ -Subproject commit 8632b8babaa248c6e13d584cee21c2bfc8f9cbcf +Subproject commit ee5a6dfe695f329c3882105b087f3563a0c80b81 From e19c1d85bbf5758ea1940a2885ceca3ed08092ab Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 6 Jun 2024 11:34:59 -0400 Subject: [PATCH 053/154] test parallel --- .github/workflows/unit_tests.yaml | 5 ++++- external/dace | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 8d021198..0015dd48 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -20,7 +20,10 @@ jobs: with: submodules: 'recursive' - name: Run serial-cpu tests - run: coverage run --rcfile=setup.cfg -m pytest -x tests + run: | + pip3 install pytest-parallel + pytest tests/test_boilerplate.py + pytest --workers auto --ignore tests/test_boilerplate.py tests - name: Run parallel-cpu tests run: mpiexec -np 6 --oversubscribe coverage run --rcfile=setup.cfg -m mpi4py -m pytest -x tests/mpi - name: Output code coverage diff --git a/external/dace b/external/dace index 8632b8ba..ee5a6dfe 160000 --- a/external/dace +++ b/external/dace @@ -1 +1 @@ -Subproject commit 8632b8babaa248c6e13d584cee21c2bfc8f9cbcf +Subproject commit ee5a6dfe695f329c3882105b087f3563a0c80b81 From fea603bf9bd8c26e4efb82e45d864f6e91a18958 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 6 Jun 2024 11:56:02 -0400 Subject: [PATCH 054/154] undo separate build --- .github/workflows/build_test.yaml | 28 ---------------------------- .github/workflows/unit_tests.yaml | 8 +++----- 2 files changed, 3 insertions(+), 33 deletions(-) delete mode 100644 .github/workflows/build_test.yaml diff --git a/.github/workflows/build_test.yaml b/.github/workflows/build_test.yaml deleted file mode 100644 index 8a45d874..00000000 --- a/.github/workflows/build_test.yaml +++ /dev/null @@ -1,28 +0,0 @@ -name: "Build test" -on: - push: - pull_request: - types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] - -jobs: - all: - runs-on: ubuntu-latest - strategy: - matrix: - python: [3.8.12, 3.11.7] - steps: - - name: Checkout repository - uses: actions/checkout@v3.5.2 - with: - submodules: 'recursive' - - name: Setup Python - uses: actions/setup-python@v4.6.0 - with: - python-version: ${{ matrix.python }} - - name: Install OpenMPI & Boost for gt4py - run: | - sudo apt-get install libopenmpi-dev libboost1.74-dev - - name: Install Python packages - run: | - python -m pip install --upgrade pip setuptools wheel - pip install .[test] diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 0015dd48..58822036 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -1,6 +1,5 @@ name: "Unit tests" on: - push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] @@ -19,11 +18,10 @@ jobs: uses: actions/checkout@v4 with: submodules: 'recursive' + - name: Install Python packages + run: pip3 install .[test] - name: Run serial-cpu tests - run: | - pip3 install pytest-parallel - pytest tests/test_boilerplate.py - pytest --workers auto --ignore tests/test_boilerplate.py tests + run: coverage run --rcfile=setup.cfg -m pytest -x tests - name: Run parallel-cpu tests run: mpiexec -np 6 --oversubscribe coverage run --rcfile=setup.cfg -m mpi4py -m pytest -x tests/mpi - name: Output code coverage From 164120b355599f117f50bf9c0f0417e3e0b4514f Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Fri, 7 Jun 2024 11:50:26 -0400 Subject: [PATCH 055/154] Changed conditional statement to check for compute option in test_translate.py --- ndsl/stencils/testing/test_translate.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ndsl/stencils/testing/test_translate.py b/ndsl/stencils/testing/test_translate.py index 3d633b53..55d1918b 100644 --- a/ndsl/stencils/testing/test_translate.py +++ b/ndsl/stencils/testing/test_translate.py @@ -389,7 +389,7 @@ def test_parallel_savepoint( ) if case.testobj.skip_test: return - if grid and not case.testobj.compute_grid_option: + if (grid=="compute") and not case.testobj.compute_grid_option: pytest.xfail(f"Grid compute option not used for test {case.savepoint_name}") input_data = dataset_to_dict(case.ds_in) # run python version of functionality From a8e58e62e5a76e6feaaa7adf4ee5ea13c1b02709 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Fri, 7 Jun 2024 11:58:31 -0400 Subject: [PATCH 056/154] Linting --- ndsl/stencils/testing/test_translate.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ndsl/stencils/testing/test_translate.py b/ndsl/stencils/testing/test_translate.py index 55d1918b..d2564868 100644 --- a/ndsl/stencils/testing/test_translate.py +++ b/ndsl/stencils/testing/test_translate.py @@ -389,7 +389,7 @@ def test_parallel_savepoint( ) if case.testobj.skip_test: return - if (grid=="compute") and not case.testobj.compute_grid_option: + if (grid == "compute") and not case.testobj.compute_grid_option: pytest.xfail(f"Grid compute option not used for test {case.savepoint_name}") input_data = dataset_to_dict(case.ds_in) # run python version of functionality From 170e47a613a249b9ffdfdf46a2f16ddb8e7a37ef Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Fri, 7 Jun 2024 12:37:49 -0400 Subject: [PATCH 057/154] Updating submodules --- external/dace | 2 +- external/gt4py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/external/dace b/external/dace index ee5a6dfe..8632b8ba 160000 --- a/external/dace +++ b/external/dace @@ -1 +1 @@ -Subproject commit ee5a6dfe695f329c3882105b087f3563a0c80b81 +Subproject commit 8632b8babaa248c6e13d584cee21c2bfc8f9cbcf diff --git a/external/gt4py b/external/gt4py index 32dde792..f472c904 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit 32dde792bde505807a5729261e4f1d12a1451bdb +Subproject commit f472c9041dca338a8d73c7226ee7892ac00ab78d From 94b10794ea789a5c5f08ab0a024a51f5d0f3a540 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Tue, 11 Jun 2024 12:40:05 -0400 Subject: [PATCH 058/154] Updating dace --- external/dace | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/external/dace b/external/dace index 8632b8ba..e8aebc02 160000 --- a/external/dace +++ b/external/dace @@ -1 +1 @@ -Subproject commit 8632b8babaa248c6e13d584cee21c2bfc8f9cbcf +Subproject commit e8aebc02ce76ac96d26efefa81cfaffc9de35d5d From 777aab4ae5ee04aa83d513fd1009328c1e8ae21f Mon Sep 17 00:00:00 2001 From: mlee03 Date: Tue, 11 Jun 2024 12:41:54 -0400 Subject: [PATCH 059/154] trigger ci --- .github/workflows/unit_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 58822036..1167176b 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -9,7 +9,7 @@ concurrency: cancel-in-progress: true jobs: - all: + all_tests: runs-on: ubuntu-latest container: image: ghcr.io/noaa-gfdl/miniforge:mpich From 6999653feb71342e394ff2e5a013005224518fae Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Tue, 11 Jun 2024 14:08:15 -0400 Subject: [PATCH 060/154] Changed get_communicator conditional to check for cubed-sphere --- ndsl/stencils/testing/conftest.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ndsl/stencils/testing/conftest.py b/ndsl/stencils/testing/conftest.py index f23f385d..878e9d7e 100644 --- a/ndsl/stencils/testing/conftest.py +++ b/ndsl/stencils/testing/conftest.py @@ -79,8 +79,8 @@ def pytest_addoption(parser): parser.addoption( "--topology", action="store", - default="cube-sphere", - help='Topology of the grid. "cube-sphere" means a 6-faced grid, "doubly-periodic" means a 1 tile grid. Default to "cube-sphere".', + default="cubed-sphere", + help='Topology of the grid. "cubed-sphere" means a 6-faced grid, "doubly-periodic" means a 1 tile grid. Default to "cube-sphere".', ) @@ -370,7 +370,7 @@ def generate_parallel_stencil_tests(metafunc, *, backend: str): def get_communicator(comm, layout, topology_mode): - if (MPI.COMM_WORLD.Get_size() > 1) and (topology_mode == "doubly-periodic"): + if (MPI.COMM_WORLD.Get_size() > 1) and (topology_mode == "cubed-sphere"): partitioner = CubedSpherePartitioner(TilePartitioner(layout)) communicator = CubedSphereCommunicator(comm, partitioner) else: From 4e56cca0fd7edb2383659a6dfb12c7adf41a6324 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Wed, 12 Jun 2024 12:57:08 -0400 Subject: [PATCH 061/154] attempt 1 --- .github/workflows/fv3_tests.yaml | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 .github/workflows/fv3_tests.yaml diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml new file mode 100644 index 00000000..cab0cfe5 --- /dev/null +++ b/.github/workflows/fv3_tests.yaml @@ -0,0 +1,23 @@ +name: "Unit tests" +on: + push: + pull_request: + types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] + +# cancel running jobs if theres a newer push +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + all_tests: + runs-on: ubuntu-latest + container: + image: ghcr.io/noaa-gfdl/miniforge:mpich + uses: mlee03/pyFV3/.github/workflows/translate.yml + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + repository: 'NOAA-GFDL/pyFV3' + submodules: 'recursive' From e2bd82f17ca9cbfa56c44f58efaa0c9ccc57d2b2 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Wed, 12 Jun 2024 15:35:41 -0400 Subject: [PATCH 062/154] Changed get_communicator topology selection conditional --- ndsl/stencils/testing/conftest.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ndsl/stencils/testing/conftest.py b/ndsl/stencils/testing/conftest.py index 878e9d7e..6b89d227 100644 --- a/ndsl/stencils/testing/conftest.py +++ b/ndsl/stencils/testing/conftest.py @@ -80,7 +80,7 @@ def pytest_addoption(parser): "--topology", action="store", default="cubed-sphere", - help='Topology of the grid. "cubed-sphere" means a 6-faced grid, "doubly-periodic" means a 1 tile grid. Default to "cube-sphere".', + help='Topology of the grid. "cubed-sphere" means a 6-faced grid, "doubly-periodic" means a 1 tile grid. Default to "cubed-sphere".', ) @@ -189,7 +189,7 @@ def get_ranks(metafunc, layout): if only_rank is None: if topology == "doubly-periodic": total_ranks = layout[0] * layout[1] - elif topology == "cube-sphere": + elif topology == "cubed-sphere": total_ranks = 6 * layout[0] * layout[1] else: raise NotImplementedError(f"Topology {topology} is unknown.") From 50c8bc7eeadf61d1d6544b2c972e0e232a1cdf05 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Wed, 12 Jun 2024 16:34:37 -0400 Subject: [PATCH 063/154] Changed mysign in fill_corners_dgrid_def to external variable --- ndsl/dsl/stencil.py | 1 + ndsl/stencils/corners.py | 3 +-- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ndsl/dsl/stencil.py b/ndsl/dsl/stencil.py index 75ef28ea..64eb2c3e 100644 --- a/ndsl/dsl/stencil.py +++ b/ndsl/dsl/stencil.py @@ -763,6 +763,7 @@ def axis_offsets( "local_js": gtscript.J[0] + self.jsc - origin[1], "j_end": j_end, "local_je": gtscript.J[-1] + self.jec - origin[1] - domain[1] + 1, + "mysign": -1.0, } def get_origin_domain( diff --git a/ndsl/stencils/corners.py b/ndsl/stencils/corners.py index 86fea187..84266872 100644 --- a/ndsl/stencils/corners.py +++ b/ndsl/stencils/corners.py @@ -989,7 +989,6 @@ def fill_corners_dgrid_defn( x_out: FloatField, y_in: FloatField, y_out: FloatField, - mysign: float, ): """ Args: @@ -998,7 +997,7 @@ def fill_corners_dgrid_defn( y_in (in): y_out (inout): """ - from __externals__ import i_end, i_start, j_end, j_start + from __externals__ import mysign, i_end, i_start, j_end, j_start with computation(PARALLEL), interval(...): # sw corner From 7db441acda885f0439f57d7ff0cfb991cda72e1b Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Wed, 12 Jun 2024 16:41:41 -0400 Subject: [PATCH 064/154] Linting --- ndsl/stencils/corners.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ndsl/stencils/corners.py b/ndsl/stencils/corners.py index 84266872..1313e583 100644 --- a/ndsl/stencils/corners.py +++ b/ndsl/stencils/corners.py @@ -997,7 +997,7 @@ def fill_corners_dgrid_defn( y_in (in): y_out (inout): """ - from __externals__ import mysign, i_end, i_start, j_end, j_start + from __externals__ import i_end, i_start, j_end, j_start, mysign with computation(PARALLEL), interval(...): # sw corner From ad6c5008e6aee7b489e5e404e61beb82f65c638e Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 13 Jun 2024 10:32:46 -0400 Subject: [PATCH 065/154] Rolling back dace and gt4py --- external/dace | 2 +- external/gt4py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/external/dace b/external/dace index e8aebc02..ee5a6dfe 160000 --- a/external/dace +++ b/external/dace @@ -1 +1 @@ -Subproject commit e8aebc02ce76ac96d26efefa81cfaffc9de35d5d +Subproject commit ee5a6dfe695f329c3882105b087f3563a0c80b81 diff --git a/external/gt4py b/external/gt4py index f472c904..32dde792 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit f472c9041dca338a8d73c7226ee7892ac00ab78d +Subproject commit 32dde792bde505807a5729261e4f1d12a1451bdb From 2a5c9f45d093aab0232d3d8ead5553b4d800ccc1 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 13 Jun 2024 10:53:05 -0400 Subject: [PATCH 066/154] Removing mysign from axis_offsets --- ndsl/dsl/stencil.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ndsl/dsl/stencil.py b/ndsl/dsl/stencil.py index 64eb2c3e..75ef28ea 100644 --- a/ndsl/dsl/stencil.py +++ b/ndsl/dsl/stencil.py @@ -763,7 +763,6 @@ def axis_offsets( "local_js": gtscript.J[0] + self.jsc - origin[1], "j_end": j_end, "local_je": gtscript.J[-1] + self.jec - origin[1] - domain[1] + 1, - "mysign": -1.0, } def get_origin_domain( From ee2b2c82df37aee80ac90bd380c63e8736498c98 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Thu, 13 Jun 2024 11:52:22 -0400 Subject: [PATCH 067/154] Cast parameters in Translate test to proper float precision --- ndsl/stencils/testing/translate.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ndsl/stencils/testing/translate.py b/ndsl/stencils/testing/translate.py index ef828302..2f07f82f 100644 --- a/ndsl/stencils/testing/translate.py +++ b/ndsl/stencils/testing/translate.py @@ -5,7 +5,7 @@ import ndsl.dsl.gt4py_utils as utils from ndsl.dsl.stencil import StencilFactory -from ndsl.dsl.typing import Field # noqa: F401 +from ndsl.dsl.typing import Field, Float # noqa: F401 from ndsl.quantity import Quantity from ndsl.stencils.testing.grid import Grid # type: ignore @@ -168,7 +168,7 @@ def make_storage_data_input_vars(self, inputs, storage_vars=None): if type(inputs_in[p]) in [np.int64, np.int32]: inputs_out[p] = int(inputs_in[p]) else: - inputs_out[p] = inputs_in[p] + inputs_out[p] = Float(inputs_in[p]) for d, info in storage_vars.items(): serialname = info["serialname"] if "serialname" in info else d self.update_info(info, inputs_in) From 22845547d78f4b8bb4f5c93d408ddd79ac078fa1 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 13 Jun 2024 13:17:34 -0400 Subject: [PATCH 068/154] test --- .github/workflows/test.yaml | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 .github/workflows/test.yaml diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml new file mode 100644 index 00000000..b240a486 --- /dev/null +++ b/.github/workflows/test.yaml @@ -0,0 +1,24 @@ +name: "Unit tests" +on: + workflow_call : + inputs: + test_hash: + required: false + type: string + default: "NONE" + push: + pull_request: + types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] + +# cancel running jobs if theres a newer push +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + all_tests: + runs-on: ubuntu-latest + steps: + - name: Checkout repository + if: ${{ github.event.action == 'push' }} + run: echo ${{github.event.action}} \ No newline at end of file From 889b99df9dd5e5dbbb2ff3e627ce829332452394 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 13 Jun 2024 13:18:35 -0400 Subject: [PATCH 069/154] test --- .github/workflows/test.yaml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml index b240a486..63273b5e 100644 --- a/.github/workflows/test.yaml +++ b/.github/workflows/test.yaml @@ -20,5 +20,4 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout repository - if: ${{ github.event.action == 'push' }} run: echo ${{github.event.action}} \ No newline at end of file From 6ee554b26770ae0a84aff19b0fb79f4b9acd8708 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 13 Jun 2024 13:21:08 -0400 Subject: [PATCH 070/154] test --- .github/workflows/test.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml index 63273b5e..ecc64419 100644 --- a/.github/workflows/test.yaml +++ b/.github/workflows/test.yaml @@ -19,5 +19,5 @@ jobs: all_tests: runs-on: ubuntu-latest steps: - - name: Checkout repository - run: echo ${{github.event.action}} \ No newline at end of file + - name: test + run: echo ${{github.event}} \ No newline at end of file From 2eaa6371b87926c7c9b23c429a7208b06d20cca6 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 13 Jun 2024 13:22:52 -0400 Subject: [PATCH 071/154] test --- .github/workflows/test.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml index ecc64419..93cbcfa7 100644 --- a/.github/workflows/test.yaml +++ b/.github/workflows/test.yaml @@ -20,4 +20,4 @@ jobs: runs-on: ubuntu-latest steps: - name: test - run: echo ${{github.event}} \ No newline at end of file + run: echo ${{github.event_name}} \ No newline at end of file From 5cf9bcaacaab9e141105a21af47e6e3ba0855ed5 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 13 Jun 2024 13:23:36 -0400 Subject: [PATCH 072/154] test --- .github/workflows/test.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml index 93cbcfa7..36732c0b 100644 --- a/.github/workflows/test.yaml +++ b/.github/workflows/test.yaml @@ -20,4 +20,5 @@ jobs: runs-on: ubuntu-latest steps: - name: test + if: ${{ github.event_name == 'push' }} run: echo ${{github.event_name}} \ No newline at end of file From ccbb8738eac26e1d865553bff6e75fa4eaee83fc Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 13 Jun 2024 13:31:28 -0400 Subject: [PATCH 073/154] test --- .github/workflows/fv3_tests.yaml | 8 ++------ .github/workflows/test.yaml | 24 ------------------------ 2 files changed, 2 insertions(+), 30 deletions(-) delete mode 100644 .github/workflows/test.yaml diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index cab0cfe5..7740c6f7 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -15,9 +15,5 @@ jobs: container: image: ghcr.io/noaa-gfdl/miniforge:mpich uses: mlee03/pyFV3/.github/workflows/translate.yml - steps: - - name: Checkout repository - uses: actions/checkout@v4 - with: - repository: 'NOAA-GFDL/pyFV3' - submodules: 'recursive' + with: + ndsl_hash: ${{GITHUB_SHA}} \ No newline at end of file diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml deleted file mode 100644 index 36732c0b..00000000 --- a/.github/workflows/test.yaml +++ /dev/null @@ -1,24 +0,0 @@ -name: "Unit tests" -on: - workflow_call : - inputs: - test_hash: - required: false - type: string - default: "NONE" - push: - pull_request: - types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] - -# cancel running jobs if theres a newer push -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - -jobs: - all_tests: - runs-on: ubuntu-latest - steps: - - name: test - if: ${{ github.event_name == 'push' }} - run: echo ${{github.event_name}} \ No newline at end of file From ba05f2ca192e02aebc6d90df36859d7214872b3d Mon Sep 17 00:00:00 2001 From: MiKyung Lee <58964324+mlee03@users.noreply.github.com> Date: Thu, 13 Jun 2024 13:34:45 -0400 Subject: [PATCH 074/154] Update fv3_tests.yaml --- .github/workflows/fv3_tests.yaml | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index 7740c6f7..ebf8b915 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -11,9 +11,6 @@ concurrency: jobs: all_tests: - runs-on: ubuntu-latest - container: - image: ghcr.io/noaa-gfdl/miniforge:mpich - uses: mlee03/pyFV3/.github/workflows/translate.yml + uses: mlee03/pyFV3/.github/workflows/translate.yml@develop with: - ndsl_hash: ${{GITHUB_SHA}} \ No newline at end of file + ndsl_hash: ${{GITHUB_SHA}} From 1efe582d2975f03c60ce3582313d2235e11800fd Mon Sep 17 00:00:00 2001 From: MiKyung Lee <58964324+mlee03@users.noreply.github.com> Date: Thu, 13 Jun 2024 13:35:33 -0400 Subject: [PATCH 075/154] Update fv3_tests.yaml --- .github/workflows/fv3_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index ebf8b915..3e267440 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -11,6 +11,6 @@ concurrency: jobs: all_tests: - uses: mlee03/pyFV3/.github/workflows/translate.yml@develop + uses: mlee03/pyFV3/.github/workflows/translate.yml@reusing_workflows with: ndsl_hash: ${{GITHUB_SHA}} From 54416c55036e68e2919f76ed334ee5280342dd3b Mon Sep 17 00:00:00 2001 From: MiKyung Lee <58964324+mlee03@users.noreply.github.com> Date: Thu, 13 Jun 2024 13:36:10 -0400 Subject: [PATCH 076/154] Update fv3_tests.yaml --- .github/workflows/fv3_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index 3e267440..26589c7f 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -13,4 +13,4 @@ jobs: all_tests: uses: mlee03/pyFV3/.github/workflows/translate.yml@reusing_workflows with: - ndsl_hash: ${{GITHUB_SHA}} + ndsl_hash: $GITHUB_SHA From 59630dac684634272842eb345b69fb3a62f6d6fb Mon Sep 17 00:00:00 2001 From: MiKyung Lee <58964324+mlee03@users.noreply.github.com> Date: Thu, 13 Jun 2024 13:36:33 -0400 Subject: [PATCH 077/154] Update fv3_tests.yaml --- .github/workflows/fv3_tests.yaml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index 26589c7f..46b1e092 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -4,11 +4,6 @@ on: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] -# cancel running jobs if theres a newer push -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - jobs: all_tests: uses: mlee03/pyFV3/.github/workflows/translate.yml@reusing_workflows From 56fbc8b57e6284b408802da02cfe6add7e9f7360 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 13 Jun 2024 13:49:16 -0400 Subject: [PATCH 078/154] test --- .github/workflows/fv3_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index 46b1e092..39a0176f 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -5,7 +5,7 @@ on: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] jobs: - all_tests: + all_tests: uses: mlee03/pyFV3/.github/workflows/translate.yml@reusing_workflows with: ndsl_hash: $GITHUB_SHA From f5a812b40768ade0bed32419a1de7026245e4a5d Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 13 Jun 2024 13:59:57 -0400 Subject: [PATCH 079/154] test --- .github/workflows/fv3_tests.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index 39a0176f..3211750b 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -9,3 +9,4 @@ jobs: uses: mlee03/pyFV3/.github/workflows/translate.yml@reusing_workflows with: ndsl_hash: $GITHUB_SHA + trigger: true From 49ad6307511c7167ceee8d9f6b4a357f197b02ab Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 13 Jun 2024 14:35:00 -0400 Subject: [PATCH 080/154] trigger fv3 workflow --- .github/workflows/fv3_unit_tests.yaml | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 .github/workflows/fv3_unit_tests.yaml diff --git a/.github/workflows/fv3_unit_tests.yaml b/.github/workflows/fv3_unit_tests.yaml new file mode 100644 index 00000000..aac8ee83 --- /dev/null +++ b/.github/workflows/fv3_unit_tests.yaml @@ -0,0 +1,12 @@ +name: "FV3 unit tests" +on: + push: + pull_request: + types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] + +jobs: + all_tests: + uses: NOAA-GFDL/pyFV3/.github/workflows/translate.yml@develop + with: + ndsl_hash: $GITHUB_SHA + trigger: true From ba5d216a2d4a15900b79163c5d65f2a84f6669ea Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 13 Jun 2024 14:36:42 -0400 Subject: [PATCH 081/154] remove push --- .github/workflows/fv3_unit_tests.yaml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/fv3_unit_tests.yaml b/.github/workflows/fv3_unit_tests.yaml index aac8ee83..19275f8d 100644 --- a/.github/workflows/fv3_unit_tests.yaml +++ b/.github/workflows/fv3_unit_tests.yaml @@ -1,6 +1,5 @@ name: "FV3 unit tests" on: - push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] @@ -9,4 +8,4 @@ jobs: uses: NOAA-GFDL/pyFV3/.github/workflows/translate.yml@develop with: ndsl_hash: $GITHUB_SHA - trigger: true + trigger: true \ No newline at end of file From 63a2bb41799a22c5d8e33a38eeb92d53e9c7b353 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 13 Jun 2024 14:56:39 -0400 Subject: [PATCH 082/154] lint --- .github/workflows/fv3_unit_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/fv3_unit_tests.yaml b/.github/workflows/fv3_unit_tests.yaml index 19275f8d..59f00728 100644 --- a/.github/workflows/fv3_unit_tests.yaml +++ b/.github/workflows/fv3_unit_tests.yaml @@ -8,4 +8,4 @@ jobs: uses: NOAA-GFDL/pyFV3/.github/workflows/translate.yml@develop with: ndsl_hash: $GITHUB_SHA - trigger: true \ No newline at end of file + trigger: true From d65eed53da3d5bd21372c4a2f2f5c6bc48da4a28 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 13 Jun 2024 16:10:12 -0400 Subject: [PATCH 083/154] test --- .github/workflows/fv3_tests.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index 3211750b..05b9df59 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -8,5 +8,5 @@ jobs: all_tests: uses: mlee03/pyFV3/.github/workflows/translate.yml@reusing_workflows with: - ndsl_hash: $GITHUB_SHA - trigger: true + ndsl_hash: 2024.04.00 #$GITHUB_SHA + ndsl_trigger: true From 0c95e25aeef6a40401949167b75246a83419f745 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Fri, 14 Jun 2024 11:08:59 -0400 Subject: [PATCH 084/154] When building a default Grid, do not pass adjusted npx/npy --- ndsl/stencils/testing/conftest.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ndsl/stencils/testing/conftest.py b/ndsl/stencils/testing/conftest.py index f23f385d..c1bf782b 100644 --- a/ndsl/stencils/testing/conftest.py +++ b/ndsl/stencils/testing/conftest.py @@ -238,7 +238,7 @@ def _savepoint_cases( savepoint_names, ranks, stencil_config, - namelist, + namelist: Namelist, backend: str, data_path: str, grid_mode: str, @@ -248,8 +248,8 @@ def _savepoint_cases( for rank in ranks: if grid_mode == "default": grid = Grid._make( - namelist.npx + 1, - namelist.npy + 1, + namelist.npx, + namelist.npy, namelist.npz, namelist.layout, rank, From 67b2a2aa14db80976185936df71573472e115c86 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 20 Jun 2024 07:36:59 -0400 Subject: [PATCH 085/154] fix action name --- .github/workflows/fv3_unit_tests.yaml | 11 ----------- 1 file changed, 11 deletions(-) delete mode 100644 .github/workflows/fv3_unit_tests.yaml diff --git a/.github/workflows/fv3_unit_tests.yaml b/.github/workflows/fv3_unit_tests.yaml deleted file mode 100644 index 59f00728..00000000 --- a/.github/workflows/fv3_unit_tests.yaml +++ /dev/null @@ -1,11 +0,0 @@ -name: "FV3 unit tests" -on: - pull_request: - types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] - -jobs: - all_tests: - uses: NOAA-GFDL/pyFV3/.github/workflows/translate.yml@develop - with: - ndsl_hash: $GITHUB_SHA - trigger: true From 7e0d08ca248faed85214341b452479f0f7da2e48 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Thu, 20 Jun 2024 07:38:21 -0400 Subject: [PATCH 086/154] UNTRACKED FILE --- .github/workflows/fv3_translate_tests.yaml | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 .github/workflows/fv3_translate_tests.yaml diff --git a/.github/workflows/fv3_translate_tests.yaml b/.github/workflows/fv3_translate_tests.yaml new file mode 100644 index 00000000..8f0d09c6 --- /dev/null +++ b/.github/workflows/fv3_translate_tests.yaml @@ -0,0 +1,11 @@ +name: "FV3 Translate tests" +on: + pull_request: + types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] + +jobs: + all_tests: + uses: NOAA-GFDL/pyFV3/.github/workflows/translate.yml@develop + with: + ndsl_hash: $GITHUB_SHA + ndsl_trigger: true From 6481be55c4a6566ec8914c4565df746bb990cdc3 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 20 Jun 2024 11:31:15 -0400 Subject: [PATCH 087/154] Pinning numpy version in setup.py --- setup.py | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.py b/setup.py index a2484e20..27980336 100644 --- a/setup.py +++ b/setup.py @@ -28,6 +28,7 @@ def local_pkg(name: str, relative_path: str) -> str: "scipy", # restart capacities only "h5netcdf", # for xarray "dask", # for xarray + "numpy==1.26.4", ] From e274d6480217a7a44c387194d169b488f7e45e78 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 20 Jun 2024 11:34:34 -0400 Subject: [PATCH 088/154] Removed python 3.8.12 from testing matrix --- .github/workflows/unit_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index e6ef31bc..fb466150 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -8,7 +8,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python: [3.8.12, 3.11.7] + python: [3.11.7] steps: - name: Checkout repository uses: actions/checkout@v3.5.2 From 787c70acf3396aa30ec1ad67aec6f55efe368dd9 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 20 Jun 2024 11:46:57 -0400 Subject: [PATCH 089/154] Updating lint workflow to use python 3.11.7 --- .github/workflows/lint.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/lint.yaml b/.github/workflows/lint.yaml index 0cab2313..7ef52638 100644 --- a/.github/workflows/lint.yaml +++ b/.github/workflows/lint.yaml @@ -14,7 +14,7 @@ jobs: - name: Step Python uses: actions/setup-python@v4.6.0 with: - python-version: '3.8.12' + python-version: '3.11.7' - name: Install OpenMPI for gt4py run: | sudo apt-get install libopenmpi-dev From da2d5ee80e116ac9607cbd7d2216d9ddbf61ea11 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 20 Jun 2024 12:25:53 -0400 Subject: [PATCH 090/154] Changed action/checkout to version 4 --- .github/workflows/unit_tests.yaml | 2 +- setup.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index fb466150..913ff973 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -11,7 +11,7 @@ jobs: python: [3.11.7] steps: - name: Checkout repository - uses: actions/checkout@v3.5.2 + uses: actions/checkout@v4 with: submodules: 'recursive' - name: Setup Python diff --git a/setup.py b/setup.py index 27980336..648f4fbf 100644 --- a/setup.py +++ b/setup.py @@ -28,7 +28,7 @@ def local_pkg(name: str, relative_path: str) -> str: "scipy", # restart capacities only "h5netcdf", # for xarray "dask", # for xarray - "numpy==1.26.4", + # "numpy==1.26.4", ] From ee8aa85b254701ccda7cf42449370ad3d4884eab Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 20 Jun 2024 12:30:22 -0400 Subject: [PATCH 091/154] Re-pinning numpy --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 648f4fbf..27980336 100644 --- a/setup.py +++ b/setup.py @@ -28,7 +28,7 @@ def local_pkg(name: str, relative_path: str) -> str: "scipy", # restart capacities only "h5netcdf", # for xarray "dask", # for xarray - # "numpy==1.26.4", + "numpy==1.26.4", ] From b21263edfc697f9cf223622e0c381f2deff4bc2e Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 20 Jun 2024 13:51:49 -0400 Subject: [PATCH 092/154] Looking at pip list --- .github/workflows/unit_tests.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 913ff973..4e16b9ff 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -25,6 +25,7 @@ jobs: run: | python -m pip install --upgrade pip setuptools wheel pip install .[test] + pip list - name: Run serial-cpu tests run: | coverage run --rcfile=setup.cfg -m pytest -x tests From 45260315b253b768e25efea71034d036ee869174 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 20 Jun 2024 15:23:22 -0400 Subject: [PATCH 093/154] Pinned other requirements --- setup.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index 27980336..1d2cbc2b 100644 --- a/setup.py +++ b/setup.py @@ -24,11 +24,13 @@ def local_pkg(name: str, relative_path: str) -> str: "xarray", "f90nml>=1.1.0", "fsspec", - "netcdf4", + "netcdf4==1.7.0", "scipy", # restart capacities only "h5netcdf", # for xarray - "dask", # for xarray + "dask==2024.5.2", # for xarray "numpy==1.26.4", + "importlib_metadata==7.1.0", + "Faker==25.8.0", ] From 5cc229f2a79ecc8ce3dfe0f8eac00811c56359aa Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 20 Jun 2024 16:00:18 -0400 Subject: [PATCH 094/154] Only pinning what needs to be pinned --- setup.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/setup.py b/setup.py index 1d2cbc2b..abb1ccf9 100644 --- a/setup.py +++ b/setup.py @@ -27,10 +27,8 @@ def local_pkg(name: str, relative_path: str) -> str: "netcdf4==1.7.0", "scipy", # restart capacities only "h5netcdf", # for xarray - "dask==2024.5.2", # for xarray + "dask", # for xarray "numpy==1.26.4", - "importlib_metadata==7.1.0", - "Faker==25.8.0", ] From 7c5326d76b4eae3f3866249c87c93853906ffdb9 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Fri, 21 Jun 2024 07:50:32 -0400 Subject: [PATCH 095/154] Removing call to pip list from unit_tests.yaml --- .github/workflows/unit_tests.yaml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 4e16b9ff..913ff973 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -25,7 +25,6 @@ jobs: run: | python -m pip install --upgrade pip setuptools wheel pip install .[test] - pip list - name: Run serial-cpu tests run: | coverage run --rcfile=setup.cfg -m pytest -x tests From 0bfba1cb859f6db7f646298926d27658c267300c Mon Sep 17 00:00:00 2001 From: mlee03 Date: Fri, 21 Jun 2024 17:40:58 -0400 Subject: [PATCH 096/154] add shield trigger --- .github/workflows/shield_translate_tests.yaml | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 .github/workflows/shield_translate_tests.yaml diff --git a/.github/workflows/shield_translate_tests.yaml b/.github/workflows/shield_translate_tests.yaml new file mode 100644 index 00000000..c2a3209f --- /dev/null +++ b/.github/workflows/shield_translate_tests.yaml @@ -0,0 +1,11 @@ +name: "SHiELD Translate tests" +on: + push: + pull_request: + types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] + +jobs: + all_tests: + uses: mlee03/pySHiELD/.github/workflows/translate.yml@reusing_workflows + with: + shield_trigger: true From 7bcc65e4ae925bd689d941e07c95eae50aa3524a Mon Sep 17 00:00:00 2001 From: mlee03 Date: Fri, 21 Jun 2024 17:43:54 -0400 Subject: [PATCH 097/154] crrect trigger --- .github/workflows/shield_translate_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/shield_translate_tests.yaml b/.github/workflows/shield_translate_tests.yaml index c2a3209f..47888649 100644 --- a/.github/workflows/shield_translate_tests.yaml +++ b/.github/workflows/shield_translate_tests.yaml @@ -8,4 +8,4 @@ jobs: all_tests: uses: mlee03/pySHiELD/.github/workflows/translate.yml@reusing_workflows with: - shield_trigger: true + ndsl_trigger: true From d39cca94044a9424406ca6c89570ac90c630921b Mon Sep 17 00:00:00 2001 From: mlee03 Date: Sun, 23 Jun 2024 15:19:04 -0400 Subject: [PATCH 098/154] add pace tests --- .github/workflows/pace_tests.yaml | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 .github/workflows/pace_tests.yaml diff --git a/.github/workflows/pace_tests.yaml b/.github/workflows/pace_tests.yaml new file mode 100644 index 00000000..bd3deb16 --- /dev/null +++ b/.github/workflows/pace_tests.yaml @@ -0,0 +1,11 @@ +name: "Unit tests" +on: + push: + pull_request: + types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] + +jobs: + all_tests: + uses: mlee03/pace/.github/workflows/main_unit_tests_mpich.yaml@reusable_workflow + with: + ndsl_trigger: true From 77e0f9af31214e757eb26abfe34567341db681dc Mon Sep 17 00:00:00 2001 From: mlee03 Date: Sun, 23 Jun 2024 15:21:58 -0400 Subject: [PATCH 099/154] test --- .github/workflows/fv3_tests.yaml | 1 - .github/workflows/shield_translate_tests.yaml | 1 - 2 files changed, 2 deletions(-) diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index 05b9df59..3fbabc50 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -1,6 +1,5 @@ name: "Unit tests" on: - push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] diff --git a/.github/workflows/shield_translate_tests.yaml b/.github/workflows/shield_translate_tests.yaml index 47888649..d4a462f3 100644 --- a/.github/workflows/shield_translate_tests.yaml +++ b/.github/workflows/shield_translate_tests.yaml @@ -1,6 +1,5 @@ name: "SHiELD Translate tests" on: - push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] From 89904e1b4762f94f266eb0c83cf3821bb0606f51 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Sun, 23 Jun 2024 15:29:26 -0400 Subject: [PATCH 100/154] uniformity --- .github/workflows/fv3_tests.yaml | 2 +- .github/workflows/pace_tests.yaml | 2 +- .github/workflows/shield_translate_tests.yaml | 10 ---------- 3 files changed, 2 insertions(+), 12 deletions(-) delete mode 100644 .github/workflows/shield_translate_tests.yaml diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index 3fbabc50..eef109be 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -4,7 +4,7 @@ on: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] jobs: - all_tests: + fv3_translate_tests: uses: mlee03/pyFV3/.github/workflows/translate.yml@reusing_workflows with: ndsl_hash: 2024.04.00 #$GITHUB_SHA diff --git a/.github/workflows/pace_tests.yaml b/.github/workflows/pace_tests.yaml index bd3deb16..a30c58d0 100644 --- a/.github/workflows/pace_tests.yaml +++ b/.github/workflows/pace_tests.yaml @@ -5,7 +5,7 @@ on: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] jobs: - all_tests: + pace_unit_tests: uses: mlee03/pace/.github/workflows/main_unit_tests_mpich.yaml@reusable_workflow with: ndsl_trigger: true diff --git a/.github/workflows/shield_translate_tests.yaml b/.github/workflows/shield_translate_tests.yaml deleted file mode 100644 index d4a462f3..00000000 --- a/.github/workflows/shield_translate_tests.yaml +++ /dev/null @@ -1,10 +0,0 @@ -name: "SHiELD Translate tests" -on: - pull_request: - types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] - -jobs: - all_tests: - uses: mlee03/pySHiELD/.github/workflows/translate.yml@reusing_workflows - with: - ndsl_trigger: true From e77346df3ba564c0ebf9e9db25198bce2298636d Mon Sep 17 00:00:00 2001 From: mlee03 Date: Sun, 23 Jun 2024 15:33:48 -0400 Subject: [PATCH 101/154] fix file --- .github/workflows/pace_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pace_tests.yaml b/.github/workflows/pace_tests.yaml index a30c58d0..ae5522f5 100644 --- a/.github/workflows/pace_tests.yaml +++ b/.github/workflows/pace_tests.yaml @@ -6,6 +6,6 @@ on: jobs: pace_unit_tests: - uses: mlee03/pace/.github/workflows/main_unit_tests_mpich.yaml@reusable_workflow + uses: mlee03/pace/.github/workflows/main_unit_tests.yaml@reusable_workflow with: ndsl_trigger: true From 6b897e00cf1e91bb0d0b3b4106e7ec05b6cbd136 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Sun, 23 Jun 2024 15:36:13 -0400 Subject: [PATCH 102/154] test --- .github/workflows/shield_tests.yaml | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 .github/workflows/shield_tests.yaml diff --git a/.github/workflows/shield_tests.yaml b/.github/workflows/shield_tests.yaml new file mode 100644 index 00000000..15d79a76 --- /dev/null +++ b/.github/workflows/shield_tests.yaml @@ -0,0 +1,10 @@ +name: "SHiELD Translate tests" +on: + pull_request: + types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] + +jobs: + shield_translate_tests: + uses: mlee03/pySHiELD/.github/workflows/translate.yml@reusing_workflows + with: + ndsl_trigger: true From cb5581edc8b6791c35d601f1e46b2f2620704f90 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Sun, 23 Jun 2024 15:49:32 -0400 Subject: [PATCH 103/154] fix --- .github/workflows/fv3_tests.yaml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index eef109be..b3ff3d57 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -5,7 +5,6 @@ on: jobs: fv3_translate_tests: - uses: mlee03/pyFV3/.github/workflows/translate.yml@reusing_workflows + uses: mlee03/pyFV3/.github/workflows/translate.yaml@reusing_workflows with: - ndsl_hash: 2024.04.00 #$GITHUB_SHA ndsl_trigger: true From 3b1de9c9bf549e07d0a54b809c4e3f8fa99807e4 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Sun, 23 Jun 2024 15:55:24 -0400 Subject: [PATCH 104/154] test --- .github/workflows/fv3_tests.yaml | 1 + .github/workflows/shield_tests.yaml | 3 ++- .github/workflows/unit_tests.yaml | 1 + 3 files changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index b3ff3d57..bff58c18 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -1,5 +1,6 @@ name: "Unit tests" on: + push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] diff --git a/.github/workflows/shield_tests.yaml b/.github/workflows/shield_tests.yaml index 15d79a76..93a826cf 100644 --- a/.github/workflows/shield_tests.yaml +++ b/.github/workflows/shield_tests.yaml @@ -1,10 +1,11 @@ name: "SHiELD Translate tests" on: + push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] jobs: shield_translate_tests: - uses: mlee03/pySHiELD/.github/workflows/translate.yml@reusing_workflows + uses: mlee03/pySHiELD/.github/workflows/translate.yaml@reusing_workflows with: ndsl_trigger: true diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 1167176b..65a47d4f 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -1,5 +1,6 @@ name: "Unit tests" on: + push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] From bc7f40a7b8ab3b9a69c1e4db63087dd8f91ae699 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Sun, 23 Jun 2024 16:16:33 -0400 Subject: [PATCH 105/154] change name --- .github/workflows/fv3_tests.yaml | 2 +- .github/workflows/pace_tests.yaml | 2 +- .github/workflows/unit_tests.yaml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index bff58c18..1ce260f7 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -1,4 +1,4 @@ -name: "Unit tests" +name: "pyFV3 translate tests" on: push: pull_request: diff --git a/.github/workflows/pace_tests.yaml b/.github/workflows/pace_tests.yaml index ae5522f5..c0be3209 100644 --- a/.github/workflows/pace_tests.yaml +++ b/.github/workflows/pace_tests.yaml @@ -1,4 +1,4 @@ -name: "Unit tests" +name: "pace unit tests" on: push: pull_request: diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 65a47d4f..80d36fd3 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -1,4 +1,4 @@ -name: "Unit tests" +name: "NDSL Unit tests" on: push: pull_request: From 75ea6f2904b26acdab0eba8c8220f157092e6c51 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Mon, 24 Jun 2024 08:55:33 -0400 Subject: [PATCH 106/154] reusable workflows --- .github/workflows/fv3_tests.yaml | 11 ----------- .github/workflows/fv3_translate_tests.yaml | 3 +-- .github/workflows/pace_tests.yaml | 3 +-- .github/workflows/shield_tests.yaml | 3 +-- .github/workflows/unit_tests.yaml | 1 - 5 files changed, 3 insertions(+), 18 deletions(-) delete mode 100644 .github/workflows/fv3_tests.yaml diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml deleted file mode 100644 index 1ce260f7..00000000 --- a/.github/workflows/fv3_tests.yaml +++ /dev/null @@ -1,11 +0,0 @@ -name: "pyFV3 translate tests" -on: - push: - pull_request: - types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] - -jobs: - fv3_translate_tests: - uses: mlee03/pyFV3/.github/workflows/translate.yaml@reusing_workflows - with: - ndsl_trigger: true diff --git a/.github/workflows/fv3_translate_tests.yaml b/.github/workflows/fv3_translate_tests.yaml index 8f0d09c6..38a751cf 100644 --- a/.github/workflows/fv3_translate_tests.yaml +++ b/.github/workflows/fv3_translate_tests.yaml @@ -5,7 +5,6 @@ on: jobs: all_tests: - uses: NOAA-GFDL/pyFV3/.github/workflows/translate.yml@develop + uses: NOAA-GFDL/pyFV3/.github/workflows/translate.yaml@develop with: - ndsl_hash: $GITHUB_SHA ndsl_trigger: true diff --git a/.github/workflows/pace_tests.yaml b/.github/workflows/pace_tests.yaml index c0be3209..03a1af9b 100644 --- a/.github/workflows/pace_tests.yaml +++ b/.github/workflows/pace_tests.yaml @@ -1,11 +1,10 @@ name: "pace unit tests" on: - push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] jobs: pace_unit_tests: - uses: mlee03/pace/.github/workflows/main_unit_tests.yaml@reusable_workflow + uses: NOAA-GFDL/pace/.github/workflows/main_unit_tests.yaml@develop with: ndsl_trigger: true diff --git a/.github/workflows/shield_tests.yaml b/.github/workflows/shield_tests.yaml index 93a826cf..70935ed8 100644 --- a/.github/workflows/shield_tests.yaml +++ b/.github/workflows/shield_tests.yaml @@ -1,11 +1,10 @@ name: "SHiELD Translate tests" on: - push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] jobs: shield_translate_tests: - uses: mlee03/pySHiELD/.github/workflows/translate.yaml@reusing_workflows + uses: NOAA-GFDL/pySHiELD/.github/workflows/translate.yaml@develop with: ndsl_trigger: true diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 80d36fd3..72570923 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -1,6 +1,5 @@ name: "NDSL Unit tests" on: - push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] From 118b029f2ee526b54bad00b4b5ea3f4660b15fa4 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Fri, 28 Jun 2024 11:26:45 -0400 Subject: [PATCH 107/154] Reverting changes to use of mysign in corners.py --- ndsl/stencils/corners.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ndsl/stencils/corners.py b/ndsl/stencils/corners.py index 1313e583..86fea187 100644 --- a/ndsl/stencils/corners.py +++ b/ndsl/stencils/corners.py @@ -989,6 +989,7 @@ def fill_corners_dgrid_defn( x_out: FloatField, y_in: FloatField, y_out: FloatField, + mysign: float, ): """ Args: @@ -997,7 +998,7 @@ def fill_corners_dgrid_defn( y_in (in): y_out (inout): """ - from __externals__ import i_end, i_start, j_end, j_start, mysign + from __externals__ import i_end, i_start, j_end, j_start with computation(PARALLEL), interval(...): # sw corner From def2191a64738eb492dc3413ef6f83e7910597c7 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Mon, 1 Jul 2024 15:57:53 -0400 Subject: [PATCH 108/154] test --- .github/workflows/fv3_tests.yaml | 3 ++- .github/workflows/pace_tests.yaml | 3 ++- .github/workflows/shield_tests.yaml | 3 ++- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/.github/workflows/fv3_tests.yaml b/.github/workflows/fv3_tests.yaml index 1ce260f7..4236b827 100644 --- a/.github/workflows/fv3_tests.yaml +++ b/.github/workflows/fv3_tests.yaml @@ -8,4 +8,5 @@ jobs: fv3_translate_tests: uses: mlee03/pyFV3/.github/workflows/translate.yaml@reusing_workflows with: - ndsl_trigger: true + component_trigger: true + component_name: NDSL diff --git a/.github/workflows/pace_tests.yaml b/.github/workflows/pace_tests.yaml index c0be3209..4e6140db 100644 --- a/.github/workflows/pace_tests.yaml +++ b/.github/workflows/pace_tests.yaml @@ -8,4 +8,5 @@ jobs: pace_unit_tests: uses: mlee03/pace/.github/workflows/main_unit_tests.yaml@reusable_workflow with: - ndsl_trigger: true + component_trigger: true + component_name: NDSL diff --git a/.github/workflows/shield_tests.yaml b/.github/workflows/shield_tests.yaml index 93a826cf..15a9dcd0 100644 --- a/.github/workflows/shield_tests.yaml +++ b/.github/workflows/shield_tests.yaml @@ -8,4 +8,5 @@ jobs: shield_translate_tests: uses: mlee03/pySHiELD/.github/workflows/translate.yaml@reusing_workflows with: - ndsl_trigger: true + component_trigger: true + component_name: NDSL \ No newline at end of file From b7727dacc2b2d31f72bb6788b11ed0daf8a64c91 Mon Sep 17 00:00:00 2001 From: mlee03 Date: Tue, 2 Jul 2024 08:08:55 -0400 Subject: [PATCH 109/154] test --- .github/workflows/pace_tests.yaml | 4 ++-- .github/workflows/unit_tests.yaml | 5 +++++ 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pace_tests.yaml b/.github/workflows/pace_tests.yaml index 4e6140db..f3c321ae 100644 --- a/.github/workflows/pace_tests.yaml +++ b/.github/workflows/pace_tests.yaml @@ -1,11 +1,11 @@ -name: "pace unit tests" +name: "pace main tests" on: push: pull_request: types: [opened, synchronize, reopened, ready_for_review, labeled, unlabeled] jobs: - pace_unit_tests: + pace_main_tests: uses: mlee03/pace/.github/workflows/main_unit_tests.yaml@reusable_workflow with: component_trigger: true diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index 80d36fd3..ef99bccb 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -15,16 +15,21 @@ jobs: container: image: ghcr.io/noaa-gfdl/miniforge:mpich steps: + - name: Checkout repository uses: actions/checkout@v4 with: submodules: 'recursive' + - name: Install Python packages run: pip3 install .[test] + - name: Run serial-cpu tests run: coverage run --rcfile=setup.cfg -m pytest -x tests + - name: Run parallel-cpu tests run: mpiexec -np 6 --oversubscribe coverage run --rcfile=setup.cfg -m mpi4py -m pytest -x tests/mpi + - name: Output code coverage run: | coverage combine From a5c808675a92344973910fe36a66880a46020e5c Mon Sep 17 00:00:00 2001 From: "Xingqiu.Yuan" Date: Mon, 29 Jul 2024 20:49:34 -0400 Subject: [PATCH 110/154] fix the mysign symbol bug in python 3.11 --- ndsl/stencils/corners.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ndsl/stencils/corners.py b/ndsl/stencils/corners.py index 86fea187..d83cfac5 100644 --- a/ndsl/stencils/corners.py +++ b/ndsl/stencils/corners.py @@ -1001,6 +1001,8 @@ def fill_corners_dgrid_defn( from __externals__ import i_end, i_start, j_end, j_start with computation(PARALLEL), interval(...): + # this line of code is used to fix the missing symbol crash due to the node visitor depth limitation + acoef = mysign # sw corner with horizontal(region[i_start - 1, j_start - 1]): x_out = mysign * y_in[0, 1, 0] From 5184be803335b760d9bc09ad3b827deb10055e71 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Wed, 31 Jul 2024 12:19:09 -0400 Subject: [PATCH 111/154] Make sure the netCDF reflects the Fortran type as saved --- ndsl/stencils/testing/serialbox_to_netcdf.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/ndsl/stencils/testing/serialbox_to_netcdf.py b/ndsl/stencils/testing/serialbox_to_netcdf.py index 453a861b..11814fff 100644 --- a/ndsl/stencils/testing/serialbox_to_netcdf.py +++ b/ndsl/stencils/testing/serialbox_to_netcdf.py @@ -139,7 +139,16 @@ def main(data_path: str, output_path: str, data_name: Optional[str] = None): def get_data(data_shape, total_ranks, n_savepoints, output_list, varname): - array = np.full([n_savepoints, total_ranks] + data_shape, fill_value=np.nan) + # Read in dtype + if total_ranks <= 0: + return + varname_dtype = output_list[0][varname][0].dtype + # Build data array + array = np.full( + [n_savepoints, total_ranks] + data_shape, + fill_value=np.nan, + dtype=varname_dtype, + ) dims = ["savepoint", "rank"] + [ f"dim_{varname}_{i}" for i in range(len(data_shape)) ] From 979c965046e1d63caa6a9d5feda177a92926be61 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Thu, 1 Aug 2024 13:44:54 -0400 Subject: [PATCH 112/154] Attempt to quantify noise (non-binding) --- ndsl/stencils/testing/test_translate.py | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/ndsl/stencils/testing/test_translate.py b/ndsl/stencils/testing/test_translate.py index d2564868..9adf3208 100644 --- a/ndsl/stencils/testing/test_translate.py +++ b/ndsl/stencils/testing/test_translate.py @@ -58,23 +58,26 @@ def sample_wherefail( bad_indices_count = len(found_indices[0]) # Determine worst result worst_metric_err = 0.0 + abs_errs = [] for b in range(bad_indices_count): full_index = [f[b] for f in found_indices] metric_err = compare_scalar(computed_failures[b], reference_failures[b]) - abs_err = abs(computed_failures[b] - reference_failures[b]) + abs_errs.append(abs(computed_failures[b] - reference_failures[b])) if print_failures and b % failure_stride == 0: return_strings.append( f"index: {full_index}, computed {computed_failures[b]}, " f"reference {reference_failures[b]}, " - f"absolute diff {abs_err:.3e}, " + f"absolute diff {abs_errs[-1]:.3e}, " f"metric diff: {metric_err:.3e}" ) if np.isnan(metric_err) or (metric_err > worst_metric_err): worst_metric_err = metric_err worst_full_idx = full_index - worst_abs_err = abs_err + worst_abs_err = abs_errs[-1] computed_worst = computed_failures[b] reference_worst = reference_failures[b] + # Try to quantify noisy errors + unique_errors = len(np.unique(np.array(abs_errs))) # Summary and worst result fullcount = len(ref_data.flatten()) return_strings.append( @@ -85,6 +88,8 @@ def sample_wherefail( f"\treference: {reference_worst}\n" f"\tabsolute diff: {worst_abs_err:.3e}\n" f"\tmetric diff: {worst_metric_err:.3e}\n" + f"Noise quantification:\n" + f"\tunique errors: {unique_errors}/{bad_indices_count}\n" ) if xy_indices: @@ -112,7 +117,7 @@ def any(array, axis): ) return_strings.append( - "failed horizontal indices:" + str(list(zip(*found_xy_indices))) + "Failed horizontal indices:" + str(list(zip(*found_xy_indices))) ) return "\n".join(return_strings) @@ -153,9 +158,9 @@ def process_override(threshold_overrides, testobj, test_name, backend): for key in testobj.out_vars.keys(): if key not in testobj.ignore_near_zero_errors: testobj.ignore_near_zero_errors[key] = {} - testobj.ignore_near_zero_errors[key][ - "near_zero" - ] = float(match["all_other_near_zero"]) + testobj.ignore_near_zero_errors[key]["near_zero"] = ( + float(match["all_other_near_zero"]) + ) else: raise TypeError( From 3b7420e17dd317a0f94142a59ef3b81b306372b4 Mon Sep 17 00:00:00 2001 From: Roman Cattaneo <> Date: Fri, 2 Aug 2024 17:50:37 +0200 Subject: [PATCH 113/154] Fix typo in print statement (FORWARD example) The sample code for showcasing FORWARD computation (in the K axis) calls `mult_upward` with `origin=(nhalo,nhalo,1)`. The print statement differs in the z-value and shows `origin=(nhalo,nhalo,0)`. This can be confusing for developers which just skim the output and don't read the code that is actually executed. --- examples/NDSL/01_gt4py_basics.ipynb | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/examples/NDSL/01_gt4py_basics.ipynb b/examples/NDSL/01_gt4py_basics.ipynb index 4d2497ac..4ae96f11 100755 --- a/examples/NDSL/01_gt4py_basics.ipynb +++ b/examples/NDSL/01_gt4py_basics.ipynb @@ -828,15 +828,15 @@ " with computation(FORWARD), interval(...):\n", " qty_out = qty_in[0,0,-1] * 2.0\n", "\n", - "print(\"Executing 'mult_upward' with origin=(nhalo,nhalo,0),domain=(nx,ny,2)\")\n", + "print(\"Executing 'mult_upward' with origin=(nhalo,nhalo,1), domain=(nx,ny,2)\")\n", "mult_upward(qty_in, qty_out, origin=(nhalo,nhalo,1), domain=(nx,ny,2))\n", - "print(\"Plotting values of qty_out at K = 0 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\")\n", + "print(\"Plotting values of qty_out at K = 0 with origin=(nhalo,nhalo,1), domain=(nx,ny,2)\")\n", "plot_field_at_kN(qty_out.data,0)\n", - "print(\"Plotting values of qty_out at K = 1 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\")\n", + "print(\"Plotting values of qty_out at K = 1 with origin=(nhalo,nhalo,1), domain=(nx,ny,2)\")\n", "plot_field_at_kN(qty_out.data,1)\n", - "print(\"Plotting values of qty_out at K = 2 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\")\n", + "print(\"Plotting values of qty_out at K = 2 with origin=(nhalo,nhalo,1), domain=(nx,ny,2)\")\n", "plot_field_at_kN(qty_out.data,2)\n", - "print(\"Plotting values of qty_out at K = 3 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\")\n", + "print(\"Plotting values of qty_out at K = 3 with origin=(nhalo,nhalo,1), domain=(nx,ny,2)\")\n", "plot_field_at_kN(qty_out.data,3)\n", "\n", "@stencil(backend=backend)\n", From ffd042912b6a20c1db240433d144863e056329fc Mon Sep 17 00:00:00 2001 From: Roman Cattaneo <> Date: Tue, 6 Aug 2024 10:13:06 +0200 Subject: [PATCH 114/154] NDSL examples: clear output from notebooks --- examples/NDSL/01_gt4py_basics.ipynb | 769 +------------------- examples/NDSL/02_NDSL_basics.ipynb | 170 +---- examples/NDSL/03_orchestration_basics.ipynb | 58 +- 3 files changed, 42 insertions(+), 955 deletions(-) diff --git a/examples/NDSL/01_gt4py_basics.ipynb b/examples/NDSL/01_gt4py_basics.ipynb index 4ae96f11..0e9c58ff 100755 --- a/examples/NDSL/01_gt4py_basics.ipynb +++ b/examples/NDSL/01_gt4py_basics.ipynb @@ -36,29 +36,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2024-05-28 15:40:01|INFO|rank 0|ndsl.logging:Constant selected: ConstantVersions.GFS\n" - ] - } - ], + "outputs": [], "source": [ "from gt4py.cartesian.gtscript import PARALLEL, computation, interval, stencil\n", "from ndsl.dsl.typing import FloatField\n", @@ -76,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -111,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -142,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -160,83 +140,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_in at K = 0\n", - "Min and max values: 8.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_out at K = 0\n", - "Min and max values: 0.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing `copy_stencil`\n", - "Plotting qty_out from `copy_stencil` at K = 0\n", - "Min and max values: 8.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting qty_out from `copy_stencil` at K = 1\n", - "Min and max values: 9.0 1.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "print(\"Plotting values of qty_in at K = 0\")\n", "plot_field_at_kN(qty_in.data)\n", @@ -267,253 +173,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_in at K = 0\n", - "Min and max values: 8.0 0.0\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAHHCAYAAACbaKDRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAo00lEQVR4nO3df3xV9X3H8fdNgJtAcgNBAmQkQLXCAIP8iCylBZQfLo/AZFudczhD2JyriZpmrpqtRWDV4KOPUdiIgfqw4Kx5gFqBDkGG2pAHXalJMCu4SqGleLVAaFfzS7ngvWd/YG6JCXDuPTf3nJvzej4e3z/uyf2e8yE+8MPn8/2eczyGYRgCAACOk2R3AAAAoHckaQAAHIokDQCAQ5GkAQBwKJI0AAAORZIGAMChSNIAADgUSRoAAIciSQMA4FAkabhaXV2dPB6P6urq7A4FAHogSaNf2rp1qzweT3ikpKToxhtvVFlZmc6ePRuTa+zZs0erVq2KybkuV1tbq/Xr15v+/rhx47R48eIex59//nklJyfrj//4j3X+/PkYRnh1H3zwgf7iL/5CQ4cOlc/n0x133KFf/vKXcbs+0J8MsDsAoC+tWbNG48eP1/nz53Xw4EHV1NRoz549Onr0qAYPHmzp3Hv27FF1dXXME3Vtba2OHj2q8vLyqM/xwgsvaPny5VqwYIF27typlJSU2AV4FR0dHbr11lvV2tqqf/qnf9LAgQP17W9/W3PnzlVzc7OGDx8elziA/oIkjX6tsLBQM2fOlCT97d/+rYYPH65169Zp165duvvuu22Orm9s27ZNxcXFuu2227Rr1664JWhJevrpp3X8+HG99dZbys/Pl3Tpv8GUKVP0r//6r3ryySfjFgvQH9DuhqvcdtttkqSTJ09e9XsvvfSSZsyYodTUVF133XW655579MEHH4R/vnz5clVXV0tSt7b61ezatUtFRUXKzs6W1+vV9ddfr3/5l39RMBgMf2fevHl69dVXderUqfA5x40bZ/rP9+KLL+qee+7RvHnz9IMf/CCuCVqSXn75ZeXn54cTtCRNnDhR8+fP14svvhjXWID+gEoarvKLX/xCkq7adt26datKSkqUn5+vqqoqnT17Vhs2bNCPfvQjvf322xo6dKjuv/9+/frXv9b+/fv1/PPPm7r21q1blZaWpoqKCqWlpenNN9/UypUr1dbWpm9961uSpH/+539Wa2ur3n//fX3729+WJKWlpZk6//e//30tW7ZMc+bM0X/+538qNTXV1LyOjg5Ta9YDBw5URkbGFX8eCoX005/+VCtWrOjxs1tuuUX/9V//pfb2dqWnp5uKC4AkA+iHtmzZYkgyXn/9dePcuXOG3+83tm3bZgwfPtxITU013n//fcMwDOOHP/yhIcn44Q9/aBiGYVy4cMHIysoypkyZYnz88cfh8+3evduQZKxcuTJ8rLS01Ijkr9BHH33U49j9999vDB482Dh//nz4WFFRkTF27FjT5x07dqyRnZ1tDBgwwJg3b57R2dlpeq5hGEZxcbEh6Zpj7ty5Vz3PuXPnDEnGmjVrevysurrakGS8++67EcUGuB2VNPq1BQsWdPs8duxYvfDCC/qDP/iDXr/f2NiolpYWrVq1qluruKioSBMnTtSrr76q1atXRxXL5ZVte3u7AoGAvvSlL2nz5s169913NXXq1KjOK0n/93//p08++URjxowxXUF3+drXvqZ77rnnmt8bNmzYVX/+8ccfS5K8Xm+Pn3X9Lru+A8AckjT6terqat14440aMGCARo4cqQkTJigp6cpbMU6dOiVJmjBhQo+fTZw4UQcPHow6lnfeeUdf//rX9eabb6qtra3bz1pbW6M+ryTNnz9fubm5qqmpUWZmpjZs2GB67qRJkzRp0iRL15d+/4+QQCDQ42dd7fRI/wEBuB1JGv3aLbfcEt7dbacPP/xQc+fOlc/n05o1a3T99dcrJSVFhw8f1qOPPqpQKGT5Ghs3btTvfvc7/du//ZuGDRtm+taw1tZWUxXuoEGDlJmZecWfZ2Zmyuv16vTp0z1+1nUsOzvbVEwALiFJA5cZO3asJOnYsWPhneBdjh07Fv65pGvu5r5cXV2dfvvb3+qVV17RnDlzwsd722UeyXkvl5SUpP/4j/9Qa2urVq9erczMTD300EPXnPfwww/rueeeu+b35s6de9UnsyUlJemmm25SY2Njj5/95Cc/0ec+9zk2jQERIkkDl5k5c6aysrK0adMmrVixIry+unfvXv3sZz/TypUrw98dMmSIpEtV8tChQ6963uTkZEmSYRjhYxcuXNDTTz/d47tDhgyJuv09cOBAvfzyy1q0aJHKy8s1bNgw/fVf//VV58RqTVqSvvzlL+uxxx5TY2NjuINx7Ngxvfnmm3rkkUfM/SEAhJGkgcsMHDhQTz31lEpKSjR37lzdfffd4Vuwxo0bp69+9avh786YMUOS9NBDD+n2229XcnKy/vIv/7LX837hC1/QsGHDVFxcrIceekgej0fPP/98t6R9+Xm3b9+uiooK5efnKy0tTUuWLDH9Zxg8eLBeffVVzZ07VytWrFBGRob+5E/+5Irfj9WatCQ98MADeuaZZ1RUVKRHHnlEAwcO1Lp16zRy5Ej9wz/8Q0yuAbiK3dvLgb7QdQtWQ0PDVb/32Vuwumzfvt2YNm2a4fV6jczMTGPZsmXh27a6fPLJJ8aDDz5ojBgxwvB4PNe8HetHP/qR8Ud/9EdGamqqkZ2dbXzta18z9u3b1+P6HR0dxl/91V8ZQ4cONSRd83assWPHGkVFRT2OnzlzxrjhhhuMlJSUHn++vuT3+40vf/nLhs/nM9LS0ozFixcbx48fj9v1gf7EYxi9/FMeAADYjseCAgDgUCRpAAAciiQNAIBDkaQBAOgDwWBQ3/jGNzR+/HilpqaG33wXyVYwbsECAKAPPPXUU6qpqdFzzz2nyZMnq7GxUSUlJcrIyDD1oCFJYnc3AAB9YPHixRo5cqSeffbZ8LE///M/V2pqqr73ve+ZOkdCV9KhUEi//vWvlZ6eHvWjFAEA9jEMQ+3t7crOzr7qy2+sOn/+vC5cuGD5PIZh9Mg3Xq+317e/feELX9B3vvMd/fznP9eNN96o//mf/9HBgwe1bt26iC6YsPx+v6n34DIYDAbD2cPv9/dZrvj444+NUVnJMYkzLS2tx7HHH3+81+sGg0Hj0UcfNTwejzFgwADD4/EYTz75ZESxJ3Ql3fWw/jGrvq6ky979i568YzrsDiEhzBjttzuEhFCU+VO7Q0gIi4d02h2C47V1hDR2+q/69OUrFy5c0JmWoE41jZMvPfpqva09pLEzfiW/3y+fzxc+3lsVLUkvvviiXnjhBdXW1mry5Mlqbm5WeXm5srOzVVxcbOqaCZ2ku1oOSSkpJOlrSB580e4QEsKgtEF2h5AQBqcn2x1CQvAN4QYas+KxZJmW7lFaevTXCenSXJ/P1y1JX8k//uM/6rHHHgs/0/+mm27SqVOnVFVV5Y4kDQCAWUEjpKBhbX4kPvroox7r7MnJyRG9P54kDQBwhZAMhRR9lo507pIlS/TEE08oNzdXkydP1ttvv61169ZpxYoVps9BkgYAoA/8+7//u77xjW/ogQceUEtLi7Kzs3X//fd3ey/9tZCkAQCuEFJIkTWse86PRHp6utavX6/169dHfU2SNADAFYKGoaCF53dZmRstth4CAOBQVNIAAFeI98axWCBJAwBcISRDwQRL0rS7AQBwKCppAIAr0O4GAMCh2N0NAABihkoaAOAKoU+HlfnxRpIGALhC0OLubitzo0WSBgC4QtCQxbdgxS4Ws1iTBgDAoaikAQCuwJo0AAAOFZJHQXkszY832t0AADgUlTQAwBVCxqVhZX68kaQBAK4QtNjutjI3WrS7AQBwKCppAIArJGIlTZIGALhCyPAoZFjY3W1hbrRodwMA4FBU0gAAV6DdDQCAQwWVpKCFBnIwhrGYRZIGALiCYXFN2mBNGgAAdKGSBgC4QiKuSTumkl67dq08Ho/Ky8vtDgUA0A8FjSTLI94ckaQbGhq0efNm5eXl2R0KAACOYXuS7ujo0LJly/TMM89o2LBhdocDAOinQvIopCQLw4Xt7tLSUhUVFWnBggXX/G4gEFBbW1u3AQCAGV1r0lZGvNm6cWzbtm06fPiwGhoaTH2/qqpKq1ev7uOoAABwBtsqab/fr4cfflgvvPCCUlJSTM2prKxUa2trePj9/j6OEgDQXyTixjHbKummpia1tLRo+vTp4WPBYFD19fXauHGjAoGAkpOTu83xer3yer3xDhUA0A9cWpO28IINN7W758+fryNHjnQ7VlJSookTJ+rRRx/tkaABAHAb25J0enq6pkyZ0u3YkCFDNHz48B7HAQCwKmTx2d0hGTGMxhzbd3cDABAP8V6THjdunDweT49RWlpq+hyOeixoXV2d3SEAAPqprvudo58fWSXd0NCgYPD37846evSoFi5cqDvvvNP0ORyVpAEA6C9GjBjR7fPatWt1/fXXa+7cuabPQZIGALhC0PAoaOF1k11zP/sgLTN3Hl24cEHf+973VFFRIY/HfAysSQMAXCH46cYxK0OScnJylJGRER5VVVXXvPbOnTv14Ycfavny5RHFTCUNAEAE/H6/fD5f+LOZ53c8++yzKiwsVHZ2dkTXIkkDAFwhZCQpZOGpYSHj0sYxn8/XLUlfy6lTp/T666/rlVdeifiaJGkAgCsELd4nHYzyPuktW7YoKytLRUVFEc9lTRoAgD4SCoW0ZcsWFRcXa8CAyOtiKmkAgCuEJEu7u0NRzHn99df13nvvacWKFVFdkyQNAHAF6w8ziXzuokWLZBjRP06UdjcAAA5FJQ0AcAWr74R21fukAQCIJ94nDQCAQyViJc2aNAAADkUlDQBwBesPM2FNGgCAPhEyPApZuU/awtxo0e4GAMChqKQBAK4QstjutvIglGiRpAEArmD9LVjs7gYAAJ+ikgYAuEJQHgUtPJDEytxokaQBAK5AuxsAAMQMlTQAwBWCstayDsYuFNNI0gAAV0jEdjdJGgDgCrxgAwAAxAyVNADAFQyL75M2uAULAIC+QbsbAADETL+opIf4k5Ts5d8bV9OhdLtDSAhvKdfuENCvvG13AI73UWf8bmxKxFdV9oskDQDAtQQtvgXLytxoUX4CAOBQVNIAAFeg3Q0AgEOFlKSQhQaylbnRot0NAIBDUUkDAFwhaHgUtNCytjI3WiRpAIArsCYNAIBDGRbfgmXwxDEAANCFShoA4ApBeRS08JIMK3OjRZIGALhCyLC2rhwyYhiMSbS7AQBwKCppAIArhCxuHLMyN1pU0gAAVwjJY3lE6oMPPtA999yj4cOHKzU1VTfddJMaGxtNz6eSBgCgD/zud7/T7Nmzdeutt2rv3r0aMWKEjh8/rmHDhpk+B0kaAOAK8X7i2FNPPaWcnBxt2bIlfGz8+PERnYN2NwDAFbrWpK2MSPzgBz/QzJkzdeeddyorK0vTpk3TM888E9E5SNIAAESgra2t2wgEAr1+75e//KVqamr0+c9/Xvv27dNXvvIVPfTQQ3ruuedMX4skDQBwhZA84ed3RzU+3TiWk5OjjIyM8Kiqqur9eqGQpk+frieffFLTpk3T3/3d3+m+++7Tpk2bTMfMmjQAwBWMKHdoXz5fkvx+v3w+X/i41+vt9fujR4/WpEmTuh37wz/8Q33/+983fU2SNADAFWL1Fiyfz9ctSV/J7NmzdezYsW7Hfv7zn2vs2LGmr0m7GwCAPvDVr35Vhw4d0pNPPqkTJ06otrZW3/nOd1RaWmr6HFTSAABXiPcTx/Lz87Vjxw5VVlZqzZo1Gj9+vNavX69ly5aZPgdJGgDgCrFqd0di8eLFWrx4cdTXpN0NAIBDUUkDAFwh2udvXz4/3kjSAABXsKPdbRXtbgAAHIpKGgDgColYSZOkAQCukIhJmnY3AAAORSUNAHAFKukI1dTUKC8vL/wc1IKCAu3du9fOkAAA/ZSh39+GFc0wbIjZ1kp6zJgxWrt2rT7/+c/LMAw999xzuuOOO/T2229r8uTJdoYGAOhnErGStjVJL1mypNvnJ554QjU1NTp06BBJGgDgeo5Zkw4Gg3rppZfU2dmpgoKCXr8TCAQUCATCn9va2uIVHgAgwVFJR+HIkSMqKCjQ+fPnlZaWph07dvR4SXaXqqoqrV69Os4RAgD6g0RM0rbfgjVhwgQ1NzfrJz/5ib7yla+ouLhY//u//9vrdysrK9Xa2hoefr8/ztECABA/tlfSgwYN0g033CBJmjFjhhoaGrRhwwZt3ry5x3e9Xq+8Xm+8QwQA9AOJWEnbnqQ/KxQKdVt3BgAgFgzDI8NCorUyN1q2JunKykoVFhYqNzdX7e3tqq2tVV1dnfbt22dnWAAAOIKtSbqlpUX33nuvTp8+rYyMDOXl5Wnfvn1auHChnWEBAPoh3icdoWeffdbOywMAXCQR16Rt390NAAB657iNYwAA9AU2jgEA4FCJ2O4mSQMAXCERK2nWpAEAcCgqaQCAKxgW292sSQMA0EcMSYZhbX680e4GAMChqKQBAK4QkkcenjgGAIDzsLsbAADEDJU0AMAVQoZHHh5mAgCA8xiGxd3dNmzvpt0NAIBDUUkDAFwhETeOkaQBAK6QiEmadjcAwBW63oJlZURi1apV8ng83cbEiRMjOgeVNAAAfWTy5Ml6/fXXw58HDIgs7ZKkAQCuYMfu7gEDBmjUqFFRX5N2NwDAFS4laY+FEfk1jx8/ruzsbH3uc5/TsmXL9N5770U0n0oaAIAItLW1dfvs9Xrl9Xp7fG/WrFnaunWrJkyYoNOnT2v16tX60pe+pKNHjyo9Pd3UtaikAQCuYK2K/v3O8JycHGVkZIRHVVVVr9crLCzUnXfeqby8PN1+++3as2ePPvzwQ7344oumY6aSBgC4giFr74Tumuv3++Xz+cLHe6uiezN06FDdeOONOnHihOlrUkkDABABn8/XbZhN0h0dHfrFL36h0aNHm74WSRoA4Aqxaneb9cgjj+jAgQP61a9+pf/+7//Wn/7pnyo5OVl333236XPQ7gYAuEOs+t0mvf/++7r77rv129/+ViNGjNAXv/hFHTp0SCNGjDB9DpI0AMAdLD4WVBHO3bZtW/TX+hTtbgAAHIpKGgDgCon4PmmSNADAFRLxLVj9IkmnvxfUgIFBu8NwuGS7A0gIHTL3FCC3e0u5doeAfuJCxwVJR+wOw7H6RZIGAOCaDE/Em796zI8zkjQAwBUScU2a3d0AADgUlTQAwB3i/DCTWCBJAwBcIRF3d9PuBgDAoaikAQDuYUPL2gqSNADAFRKx3U2SBgC4QwJuHGNNGgAAh6KSBgC4hOfTYWV+fJGkAQDuQLsbAADECpU0AMAdErCSJkkDANwhAd+CRbsbAACHopIGALhCIr6qkiQNAHCHBFyTpt0NAIBDUUkDANwhATeOkaQBAK7gMS4NK/PjjSQNAHAH1qQBAECsUEkDANyBNWkAAByKdjcAAIgVKmkAgDskYCVNkgYAuEMCJmna3QAAOBSVNADAHdjdDQCAMyXiE8dodwMA4FC2Jumqqirl5+crPT1dWVlZWrp0qY4dO2ZnSACA/sqIwYjS2rVr5fF4VF5eHtE8W5P0gQMHVFpaqkOHDmn//v26ePGiFi1apM7OTjvDAgAgZhoaGrR582bl5eVFPNfWNenXXnut2+etW7cqKytLTU1NmjNnjk1RAQD6I48srklHMaejo0PLli3TM888o29+85sRzzeVpP/sz/7s2icaMECjRo3SwoULtWTJkogDkaTW1lZJUmZmZq8/DwQCCgQC4c9tbW1RXQcAgGh9Nvd4vV55vd5ev1taWqqioiItWLAgqiRtqt2dkZFxzZGamqrjx4/rrrvu0sqVKyMOJBQKqby8XLNnz9aUKVN6/U5VVVW3a+bk5ER8HQCAS3XdgmVlSMrJyemWi6qqqnq93LZt23T48OEr/twMU5X0li1bTJ9w9+7deuCBB7RmzZqIAiktLdXRo0d18ODBK36nsrJSFRUV4c9tbW0kagCAOTF64pjf75fP5wsf7q2K9vv9evjhh7V//36lpKREfcmYr0l/8Ytf1MyZMyOaU1ZWpt27d6u+vl5jxoy54veu1lIAACAefD5ftyTdm6amJrW0tGj69OnhY8FgUPX19dq4caMCgYCSk5Ovea2YJ+mhQ4fqlVdeMfVdwzD04IMPaseOHaqrq9P48eNjHQ4AAJfE8dnd8+fP15EjR7odKykp0cSJE/Xoo4+aStCSzbu7S0tLVVtbq127dik9PV1nzpyRpPAaNwAAsRLPJ46lp6f32F81ZMgQDR8+/Ir7rnpj633SNTU1am1t1bx58zR69Ojw2L59u51hAQDgCLZW0oZhw4NQAQDuZPOrKuvq6iKewws2AADuwPukAQBArFBJAwBcIRFfVUmSBgC4w2VPDYt6fpyRpAEA7sCaNAAAiBUqaQCAK7AmDQCAU9HuBgAAsUIlDQBwB4vtbjsqaZI0AMAdaHcDAIBYoZIGALhDAlbSJGkAgCsk4i1YtLsBAHAokjQAAA5FuxsA4A6sSQMA4EysSQMAgJihkgYAuIcN1bAVJGkAgDsk4Jo07W4AAByKShoA4AqJuHGMJA0AcAfa3QAAIFaopAEArkC7GwAAp6LdDQAAYoVKGgDgDglYSZOkAQCuwJq0TdJPtGpA8nm7w3C4oXYHkCCS7Q4gIXQo3e4QEsJbyrU7BMcLfhSI38USsJJmTRoAAIfqF5U0AADXlICVNEkaAOAKibgmTbsbAACHIkkDANzBiMGIQE1NjfLy8uTz+eTz+VRQUKC9e/dGdA6SNADAFbra3VZGJMaMGaO1a9eqqalJjY2Nuu2223THHXfonXfeMX0O1qQBAOgDS5Ys6fb5iSeeUE1NjQ4dOqTJkyebOgdJGgDgDjHa3d3W1tbtsNfrldfrverUYDCol156SZ2dnSooKDB9SdrdAAB3iNGadE5OjjIyMsKjqqrqipc8cuSI0tLS5PV69fd///fasWOHJk2aZDpkKmkAACLg9/vl8/nCn69WRU+YMEHNzc1qbW3Vyy+/rOLiYh04cMB0oiZJAwBcwfPpsDJfUni3thmDBg3SDTfcIEmaMWOGGhoatGHDBm3evNnUfJI0AMAdHPDEsVAopEDA/PPKSdIAAFeI9xPHKisrVVhYqNzcXLW3t6u2tlZ1dXXat2+f6XOQpAEA6AMtLS269957dfr0aWVkZCgvL0/79u3TwoULTZ+DJA0AcIc4t7ufffZZCxe7hCQNAHAPG16SYQX3SQMA4FBU0gAAV0jEV1WSpAEA7uCAW7AiRbsbAACHopIGALgC7W4AAJyKdjcAAIgVKmkAgCvQ7gYAwKkSsN1NkgYAuEMCJmnWpAEAcCgqaQCAK7AmDQCAU9HuBgAAsUIlDQBwBY9hyGNEXw5bmRstkjQAwB1od0emvr5eS5YsUXZ2tjwej3bu3GlnOAAAOIqtSbqzs1NTp05VdXW1nWEAAFyga3e3lRFvtra7CwsLVVhYaGcIAAC3SMB2d0KtSQcCAQUCgfDntrY2G6MBAKBvJdQtWFVVVcrIyAiPnJwcu0MCACSIRGx3J1SSrqysVGtra3j4/X67QwIAJAojBiPOEqrd7fV65fV67Q4DAJCAEvGxoAlVSQMA4Ca2VtIdHR06ceJE+PPJkyfV3NyszMxM5ebm2hgZAKDfYXd3ZBobG3XrrbeGP1dUVEiSiouLtXXrVpuiAgD0V3a0rK2wNUnPmzdPhg3PQgUAIBEk1MYxAACiZhiXhpX5cUaSBgC4Aru7AQBAzFBJAwDcgd3dAAA4kyd0aViZH2+0uwEAcCgqaQCAOyRgu5tKGgDgCvF+C1ZVVZXy8/OVnp6urKwsLV26VMeOHYvoHCRpAIA7dN0nbWVE4MCBAyotLdWhQ4e0f/9+Xbx4UYsWLVJnZ6fpc9DuBgCgD7z22mvdPm/dulVZWVlqamrSnDlzTJ2DJA0AcIVYPcykra2t23Gzr1FubW2VJGVmZpq+Ju1uAIA7GDEYknJycpSRkREeVVVV17x0KBRSeXm5Zs+erSlTppgOmUoaAIAI+P1++Xy+8GczVXRpaamOHj2qgwcPRnQtkjQAwBVi1e72+XzdkvS1lJWVaffu3aqvr9eYMWMiuiZJGgDgDnF+C5ZhGHrwwQe1Y8cO1dXVafz48RFfkiQNAEAfKC0tVW1trXbt2qX09HSdOXNGkpSRkaHU1FRT52DjGADAFeL9MJOamhq1trZq3rx5Gj16dHhs377d9DmopAEA7hDnx4IaVlrrn6KSBgDAoaikAQCuEKvd3fFEkgYAuEPIuDSszI8zkjQAwB14VSUAAIgVKmkAgCt4ZHFNOmaRmEeSBgC4Q5yfOBYLtLsBAHAoKmkAgCtwCxYAAE7F7m4AABArVNIAAFfwGIY8FjZ/WZkbrX6RpIM/Oy6PZ6DdYThauibYHUKCGGp3AAki2e4AEkKH0u0OwfFC5+P4/+7Qp8PK/Dij3Q0AgEP1i0oaAIBrod0NAIBTJeDubpI0AMAdeOIYAACIFSppAIAr8MQxAACcinY3AACIFSppAIAreEKXhpX58UaSBgC4A+1uAAAQK1TSAAB34GEmAAA4UyI+FpR2NwAADkUlDQBwhwTcOEaSBgC4gyFr74RmTRoAgL7BmjQAAIgZKmkAgDsYsrgmHbNITCNJAwDcIQE3jtHuBgDAoaikAQDuEJLksTg/zqikAQCu0LW728qIRH19vZYsWaLs7Gx5PB7t3Lkz4phJ0gAA9IHOzk5NnTpV1dXVUZ+DdjcAwB3ivHGssLBQhYWF0V9PJGkAgFsk4O5ukjQAABFoa2vr9tnr9crr9fbJtViTBgC4Q1clbWVIysnJUUZGRnhUVVX1WchU0gAAd4jRLVh+v18+ny98uK+qaIkkDQBwiVi9YMPn83VL0n2JJA0AQB/o6OjQiRMnwp9Pnjyp5uZmZWZmKjc319Q5HLEmXV1drXHjxiklJUWzZs3SW2+9ZXdIAID+JkZr0mY1NjZq2rRpmjZtmiSpoqJC06ZN08qVK02fw/ZKevv27aqoqNCmTZs0a9YsrV+/XrfffruOHTumrKwsu8MDAPQXIUPyWLiNKhTZ3Hnz5smweNuW7ZX0unXrdN9996mkpESTJk3Spk2bNHjwYH33u9+1OzQAAGxla5K+cOGCmpqatGDBgvCxpKQkLViwQD/+8Y9tjAwA0O/Eud0dC7a2u3/zm98oGAxq5MiR3Y6PHDlS7777bo/vBwIBBQKB8OfP3lAOAMCVWU20vE/6qqqqqrrdQJ6Tk2N3SAAA9Blbk/R1112n5ORknT17ttvxs2fPatSoUT2+X1lZqdbW1vDw+/3xChUAkOgSsN1ta5IeNGiQZsyYoTfeeCN8LBQK6Y033lBBQUGP73u93vBN5PG8mRwA0A+EDOsjzmy/BauiokLFxcWaOXOmbrnlFq1fv16dnZ0qKSmxOzQAAGxle5K+6667dO7cOa1cuVJnzpzRzTffrNdee63HZjIAACwxQpeGlflxZnuSlqSysjKVlZXZHQYAoD/jfdIAADhUyJCl26hsWJNOqFuwAABwEyppAIA70O4GAMChDFlM0jGLxDTa3QAAOBSVNADAHWh3AwDgUKGQJAv3Oofif5807W4AAByKShoA4A60uwEAcKgETNK0uwEAcCgqaQCAOyTgY0FJ0gAAVzCMkAwLb7KyMjdaJGkAgDsYhrVqmDVpAADQhUoaAOAOhsU1aW7BAgCgj4RCksfCurINa9K0uwEAcCgqaQCAO9DuBgDAmYxQSIaFdrcdt2DR7gYAwKGopAEA7kC7GwAAhwoZkiexkjTtbgAAHIpKGgDgDoYhycp90rS7AQDoE0bIkGGh3W3Q7gYAoI8YIesjCtXV1Ro3bpxSUlI0a9YsvfXWW6bnkqQBAOgj27dvV0VFhR5//HEdPnxYU6dO1e23366WlhZT80nSAABXMEKG5RGpdevW6b777lNJSYkmTZqkTZs2afDgwfrud79raj5JGgDgDnFud1+4cEFNTU1asGBB+FhSUpIWLFigH//4x6bOkdAbx7oW8T/RRUv3p7uBEQzYHUJC+OTiebtDSAjBQLLdISSE0Pn4P0Yy0YTOX/o7F49NWVZzxSe6KElqa2vrdtzr9crr9fb4/m9+8xsFg0GNHDmy2/GRI0fq3XffNXXNhE7S7e3tkqSD2mNzJAngZ3YHkCD4PQG2aG9vV0ZGRp+ce9CgQRo1apQOnrGeK9LS0pSTk9Pt2OOPP65Vq1ZZPndvEjpJZ2dny+/3Kz09XR6Px+5wJF36F1ZOTo78fr98Pp/d4TgWvydz+D2Zw+/JHCf+ngzDUHt7u7Kzs/vsGikpKTp58qQuXLhg+VyGYfTIN71V0ZJ03XXXKTk5WWfPnu12/OzZsxo1apSp6yV0kk5KStKYMWPsDqNXPp/PMX8JnIzfkzn8nszh92SO035PfVVBXy4lJUUpKSl9fp3LDRo0SDNmzNAbb7yhpUuXSpJCoZDeeOMNlZWVmTpHQidpAACcrKKiQsXFxZo5c6ZuueUWrV+/Xp2dnSopKTE1nyQNAEAfueuuu3Tu3DmtXLlSZ86c0c0336zXXnutx2ayKyFJx5jX69Xjjz9+xTUKXMLvyRx+T+bwezKH35M9ysrKTLe3P8tj2PEwUgAAcE08zAQAAIciSQMA4FAkaQAAHIokDQCAQ5GkY8zKe0PdoL6+XkuWLFF2drY8Ho927txpd0iOVFVVpfz8fKWnpysrK0tLly7VsWPH7A7LcWpqapSXlxd+OEdBQYH27t1rd1iOtnbtWnk8HpWXl9sdCkwgSceQ1feGukFnZ6emTp2q6upqu0NxtAMHDqi0tFSHDh3S/v37dfHiRS1atEidnZ12h+YoY8aM0dq1a9XU1KTGxkbddtttuuOOO/TOO+/YHZojNTQ0aPPmzcrLy7M7FJjELVgxNGvWLOXn52vjxo2SLj3+LScnRw8++KAee+wxm6NzHo/Hox07doQfl4crO3funLKysnTgwAHNmTPH7nAcLTMzU9/61rf0N3/zN3aH4igdHR2aPn26nn76aX3zm9/UzTffrPXr19sdFq6BSjpGYvHeUOBKWltbJV1KQOhdMBjUtm3b1NnZqYKCArvDcZzS0lIVFRV1+38UnI8njsVILN4bCvQmFAqpvLxcs2fP1pQpU+wOx3GOHDmigoICnT9/XmlpadqxY4cmTZpkd1iOsm3bNh0+fFgNDQ12h4IIkaQBhystLdXRo0d18OBBu0NxpAkTJqi5uVmtra16+eWXVVxcrAMHDpCoP+X3+/Xwww9r//79cX8LFKwjScdILN4bCnxWWVmZdu/erfr6ese+ltVugwYN0g033CBJmjFjhhoaGrRhwwZt3rzZ5sicoampSS0tLZo+fXr4WDAYVH19vTZu3KhAIKDk5GQbI8TVsCYdI5e/N7RL13tDWR9DpAzDUFlZmXbs2KE333xT48ePtzukhBEKhRQIBOwOwzHmz5+vI0eOqLm5OTxmzpypZcuWqbm5mQTtcFTSMWT1vaFu0NHRoRMnToQ/nzx5Us3NzcrMzFRubq6NkTlLaWmpamtrtWvXLqWnp+vMmTOSpIyMDKWmptocnXNUVlaqsLBQubm5am9vV21trerq6rRv3z67Q3OM9PT0HnsZhgwZouHDh7PHIQGQpGPI6ntD3aCxsVG33npr+HNFRYUkqbi4WFu3brUpKuepqamRJM2bN6/b8S1btmj58uXxD8ihWlpadO+99+r06dPKyMhQXl6e9u3bp4ULF9odGhAT3CcNAIBDsSYNAIBDkaQBAHAokjQAAA5FkgYAwKFI0gAAOBRJGgAAhyJJAwDgUCRpAAAciiQNONjy5cu1dOlSu8MAYBOSNAAADkWSBgDAoUjSAAA4FEkaAACHIkkDAOBQJGkAAByKJA0AgEORpAEAcCiSNAAADuUxDMOwOwgAANATlTQAAA5FkgYAwKFI0gAAOBRJGgAAhyJJAwDgUCRpAAAciiQNAIBDkaQBAHAokjQAAA5FkgYAwKFI0gAAOBRJGgAAh/p/2Ww8TswexzgAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_out at K = 0\n", - "Min and max values: 0.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing `copy_stencil` with origin=(1,0,0)\n", - "Plotting qty_out at K = 0 based on `copy_stencil` with origin=(1,0,0)\n", - "Min and max values: 8.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Resetting qty_out to zero...\n", - "Plotting values of qty_out at K = 0\n", - "Min and max values: 0.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing `copy_stencil` with origin=(0,1,0)\n", - "Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0,1,0)\n", - "Min and max values: 8.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Resetting qty_out to zero...\n", - "Plotting values of qty_out at K = 0\n", - "Min and max values: 0.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing `copy_stencil` with origin = (0,0,1)\n", - "Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0,0,1)\n", - "Min and max values: 0.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting qty_out at K = 1 based on `copy_stencil` with origin=(0,0,1)\n", - "Min and max values: 9.0 1.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Resetting qty_out to zero...\n", - "Plotting values of qty_in at K = 0\n", - "Min and max values: 8.0 0.0\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAHHCAYAAACbaKDRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAo00lEQVR4nO3df3xV9X3H8fdNgJtAcgNBAmQkQLXCAIP8iCylBZQfLo/AZFudczhD2JyriZpmrpqtRWDV4KOPUdiIgfqw4Kx5gFqBDkGG2pAHXalJMCu4SqGleLVAaFfzS7ngvWd/YG6JCXDuPTf3nJvzej4e3z/uyf2e8yE+8MPn8/2eczyGYRgCAACOk2R3AAAAoHckaQAAHIokDQCAQ5GkAQBwKJI0AAAORZIGAMChSNIAADgUSRoAAIciSQMA4FAkabhaXV2dPB6P6urq7A4FAHogSaNf2rp1qzweT3ikpKToxhtvVFlZmc6ePRuTa+zZs0erVq2KybkuV1tbq/Xr15v+/rhx47R48eIex59//nklJyfrj//4j3X+/PkYRnh1H3zwgf7iL/5CQ4cOlc/n0x133KFf/vKXcbs+0J8MsDsAoC+tWbNG48eP1/nz53Xw4EHV1NRoz549Onr0qAYPHmzp3Hv27FF1dXXME3Vtba2OHj2q8vLyqM/xwgsvaPny5VqwYIF27typlJSU2AV4FR0dHbr11lvV2tqqf/qnf9LAgQP17W9/W3PnzlVzc7OGDx8elziA/oIkjX6tsLBQM2fOlCT97d/+rYYPH65169Zp165duvvuu22Orm9s27ZNxcXFuu2227Rr1664JWhJevrpp3X8+HG99dZbys/Pl3Tpv8GUKVP0r//6r3ryySfjFgvQH9DuhqvcdtttkqSTJ09e9XsvvfSSZsyYodTUVF133XW655579MEHH4R/vnz5clVXV0tSt7b61ezatUtFRUXKzs6W1+vV9ddfr3/5l39RMBgMf2fevHl69dVXderUqfA5x40bZ/rP9+KLL+qee+7RvHnz9IMf/CCuCVqSXn75ZeXn54cTtCRNnDhR8+fP14svvhjXWID+gEoarvKLX/xCkq7adt26datKSkqUn5+vqqoqnT17Vhs2bNCPfvQjvf322xo6dKjuv/9+/frXv9b+/fv1/PPPm7r21q1blZaWpoqKCqWlpenNN9/UypUr1dbWpm9961uSpH/+539Wa2ur3n//fX3729+WJKWlpZk6//e//30tW7ZMc+bM0X/+538qNTXV1LyOjg5Ta9YDBw5URkbGFX8eCoX005/+VCtWrOjxs1tuuUX/9V//pfb2dqWnp5uKC4AkA+iHtmzZYkgyXn/9dePcuXOG3+83tm3bZgwfPtxITU013n//fcMwDOOHP/yhIcn44Q9/aBiGYVy4cMHIysoypkyZYnz88cfh8+3evduQZKxcuTJ8rLS01Ijkr9BHH33U49j9999vDB482Dh//nz4WFFRkTF27FjT5x07dqyRnZ1tDBgwwJg3b57R2dlpeq5hGEZxcbEh6Zpj7ty5Vz3PuXPnDEnGmjVrevysurrakGS8++67EcUGuB2VNPq1BQsWdPs8duxYvfDCC/qDP/iDXr/f2NiolpYWrVq1qluruKioSBMnTtSrr76q1atXRxXL5ZVte3u7AoGAvvSlL2nz5s169913NXXq1KjOK0n/93//p08++URjxowxXUF3+drXvqZ77rnnmt8bNmzYVX/+8ccfS5K8Xm+Pn3X9Lru+A8AckjT6terqat14440aMGCARo4cqQkTJigp6cpbMU6dOiVJmjBhQo+fTZw4UQcPHow6lnfeeUdf//rX9eabb6qtra3bz1pbW6M+ryTNnz9fubm5qqmpUWZmpjZs2GB67qRJkzRp0iRL15d+/4+QQCDQ42dd7fRI/wEBuB1JGv3aLbfcEt7dbacPP/xQc+fOlc/n05o1a3T99dcrJSVFhw8f1qOPPqpQKGT5Ghs3btTvfvc7/du//ZuGDRtm+taw1tZWUxXuoEGDlJmZecWfZ2Zmyuv16vTp0z1+1nUsOzvbVEwALiFJA5cZO3asJOnYsWPhneBdjh07Fv65pGvu5r5cXV2dfvvb3+qVV17RnDlzwsd722UeyXkvl5SUpP/4j/9Qa2urVq9erczMTD300EPXnPfwww/rueeeu+b35s6de9UnsyUlJemmm25SY2Njj5/95Cc/0ec+9zk2jQERIkkDl5k5c6aysrK0adMmrVixIry+unfvXv3sZz/TypUrw98dMmSIpEtV8tChQ6963uTkZEmSYRjhYxcuXNDTTz/d47tDhgyJuv09cOBAvfzyy1q0aJHKy8s1bNgw/fVf//VV58RqTVqSvvzlL+uxxx5TY2NjuINx7Ngxvfnmm3rkkUfM/SEAhJGkgcsMHDhQTz31lEpKSjR37lzdfffd4Vuwxo0bp69+9avh786YMUOS9NBDD+n2229XcnKy/vIv/7LX837hC1/QsGHDVFxcrIceekgej0fPP/98t6R9+Xm3b9+uiooK5efnKy0tTUuWLDH9Zxg8eLBeffVVzZ07VytWrFBGRob+5E/+5Irfj9WatCQ98MADeuaZZ1RUVKRHHnlEAwcO1Lp16zRy5Ej9wz/8Q0yuAbiK3dvLgb7QdQtWQ0PDVb/32Vuwumzfvt2YNm2a4fV6jczMTGPZsmXh27a6fPLJJ8aDDz5ojBgxwvB4PNe8HetHP/qR8Ud/9EdGamqqkZ2dbXzta18z9u3b1+P6HR0dxl/91V8ZQ4cONSRd83assWPHGkVFRT2OnzlzxrjhhhuMlJSUHn++vuT3+40vf/nLhs/nM9LS0ozFixcbx48fj9v1gf7EYxi9/FMeAADYjseCAgDgUCRpAAAciiQNAIBDkaQBAOgDwWBQ3/jGNzR+/HilpqaG33wXyVYwbsECAKAPPPXUU6qpqdFzzz2nyZMnq7GxUSUlJcrIyDD1oCFJYnc3AAB9YPHixRo5cqSeffbZ8LE///M/V2pqqr73ve+ZOkdCV9KhUEi//vWvlZ6eHvWjFAEA9jEMQ+3t7crOzr7qy2+sOn/+vC5cuGD5PIZh9Mg3Xq+317e/feELX9B3vvMd/fznP9eNN96o//mf/9HBgwe1bt26iC6YsPx+v6n34DIYDAbD2cPv9/dZrvj444+NUVnJMYkzLS2tx7HHH3+81+sGg0Hj0UcfNTwejzFgwADD4/EYTz75ZESxJ3Ql3fWw/jGrvq6ky979i568YzrsDiEhzBjttzuEhFCU+VO7Q0gIi4d02h2C47V1hDR2+q/69OUrFy5c0JmWoE41jZMvPfpqva09pLEzfiW/3y+fzxc+3lsVLUkvvviiXnjhBdXW1mry5Mlqbm5WeXm5srOzVVxcbOqaCZ2ku1oOSSkpJOlrSB580e4QEsKgtEF2h5AQBqcn2x1CQvAN4QYas+KxZJmW7lFaevTXCenSXJ/P1y1JX8k//uM/6rHHHgs/0/+mm27SqVOnVFVV5Y4kDQCAWUEjpKBhbX4kPvroox7r7MnJyRG9P54kDQBwhZAMhRR9lo507pIlS/TEE08oNzdXkydP1ttvv61169ZpxYoVps9BkgYAoA/8+7//u77xjW/ogQceUEtLi7Kzs3X//fd3ey/9tZCkAQCuEFJIkTWse86PRHp6utavX6/169dHfU2SNADAFYKGoaCF53dZmRstth4CAOBQVNIAAFeI98axWCBJAwBcISRDwQRL0rS7AQBwKCppAIAr0O4GAMCh2N0NAABihkoaAOAKoU+HlfnxRpIGALhC0OLubitzo0WSBgC4QtCQxbdgxS4Ws1iTBgDAoaikAQCuwJo0AAAOFZJHQXkszY832t0AADgUlTQAwBVCxqVhZX68kaQBAK4QtNjutjI3WrS7AQBwKCppAIArJGIlTZIGALhCyPAoZFjY3W1hbrRodwMA4FBU0gAAV6DdDQCAQwWVpKCFBnIwhrGYRZIGALiCYXFN2mBNGgAAdKGSBgC4QiKuSTumkl67dq08Ho/Ky8vtDgUA0A8FjSTLI94ckaQbGhq0efNm5eXl2R0KAACOYXuS7ujo0LJly/TMM89o2LBhdocDAOinQvIopCQLw4Xt7tLSUhUVFWnBggXX/G4gEFBbW1u3AQCAGV1r0lZGvNm6cWzbtm06fPiwGhoaTH2/qqpKq1ev7uOoAABwBtsqab/fr4cfflgvvPCCUlJSTM2prKxUa2trePj9/j6OEgDQXyTixjHbKummpia1tLRo+vTp4WPBYFD19fXauHGjAoGAkpOTu83xer3yer3xDhUA0A9cWpO28IINN7W758+fryNHjnQ7VlJSookTJ+rRRx/tkaABAHAb25J0enq6pkyZ0u3YkCFDNHz48B7HAQCwKmTx2d0hGTGMxhzbd3cDABAP8V6THjdunDweT49RWlpq+hyOeixoXV2d3SEAAPqprvudo58fWSXd0NCgYPD37846evSoFi5cqDvvvNP0ORyVpAEA6C9GjBjR7fPatWt1/fXXa+7cuabPQZIGALhC0PAoaOF1k11zP/sgLTN3Hl24cEHf+973VFFRIY/HfAysSQMAXCH46cYxK0OScnJylJGRER5VVVXXvPbOnTv14Ycfavny5RHFTCUNAEAE/H6/fD5f+LOZ53c8++yzKiwsVHZ2dkTXIkkDAFwhZCQpZOGpYSHj0sYxn8/XLUlfy6lTp/T666/rlVdeifiaJGkAgCsELd4nHYzyPuktW7YoKytLRUVFEc9lTRoAgD4SCoW0ZcsWFRcXa8CAyOtiKmkAgCuEJEu7u0NRzHn99df13nvvacWKFVFdkyQNAHAF6w8ziXzuokWLZBjRP06UdjcAAA5FJQ0AcAWr74R21fukAQCIJ94nDQCAQyViJc2aNAAADkUlDQBwBesPM2FNGgCAPhEyPApZuU/awtxo0e4GAMChqKQBAK4QstjutvIglGiRpAEArmD9LVjs7gYAAJ+ikgYAuEJQHgUtPJDEytxokaQBAK5AuxsAAMQMlTQAwBWCstayDsYuFNNI0gAAV0jEdjdJGgDgCrxgAwAAxAyVNADAFQyL75M2uAULAIC+QbsbAADETL+opIf4k5Ts5d8bV9OhdLtDSAhvKdfuENCvvG13AI73UWf8bmxKxFdV9oskDQDAtQQtvgXLytxoUX4CAOBQVNIAAFeg3Q0AgEOFlKSQhQaylbnRot0NAIBDUUkDAFwhaHgUtNCytjI3WiRpAIArsCYNAIBDGRbfgmXwxDEAANCFShoA4ApBeRS08JIMK3OjRZIGALhCyLC2rhwyYhiMSbS7AQBwKCppAIArhCxuHLMyN1pU0gAAVwjJY3lE6oMPPtA999yj4cOHKzU1VTfddJMaGxtNz6eSBgCgD/zud7/T7Nmzdeutt2rv3r0aMWKEjh8/rmHDhpk+B0kaAOAK8X7i2FNPPaWcnBxt2bIlfGz8+PERnYN2NwDAFbrWpK2MSPzgBz/QzJkzdeeddyorK0vTpk3TM888E9E5SNIAAESgra2t2wgEAr1+75e//KVqamr0+c9/Xvv27dNXvvIVPfTQQ3ruuedMX4skDQBwhZA84ed3RzU+3TiWk5OjjIyM8Kiqqur9eqGQpk+frieffFLTpk3T3/3d3+m+++7Tpk2bTMfMmjQAwBWMKHdoXz5fkvx+v3w+X/i41+vt9fujR4/WpEmTuh37wz/8Q33/+983fU2SNADAFWL1Fiyfz9ctSV/J7NmzdezYsW7Hfv7zn2vs2LGmr0m7GwCAPvDVr35Vhw4d0pNPPqkTJ06otrZW3/nOd1RaWmr6HFTSAABXiPcTx/Lz87Vjxw5VVlZqzZo1Gj9+vNavX69ly5aZPgdJGgDgCrFqd0di8eLFWrx4cdTXpN0NAIBDUUkDAFwh2udvXz4/3kjSAABXsKPdbRXtbgAAHIpKGgDgColYSZOkAQCukIhJmnY3AAAORSUNAHAFKukI1dTUKC8vL/wc1IKCAu3du9fOkAAA/ZSh39+GFc0wbIjZ1kp6zJgxWrt2rT7/+c/LMAw999xzuuOOO/T2229r8uTJdoYGAOhnErGStjVJL1mypNvnJ554QjU1NTp06BBJGgDgeo5Zkw4Gg3rppZfU2dmpgoKCXr8TCAQUCATCn9va2uIVHgAgwVFJR+HIkSMqKCjQ+fPnlZaWph07dvR4SXaXqqoqrV69Os4RAgD6g0RM0rbfgjVhwgQ1NzfrJz/5ib7yla+ouLhY//u//9vrdysrK9Xa2hoefr8/ztECABA/tlfSgwYN0g033CBJmjFjhhoaGrRhwwZt3ry5x3e9Xq+8Xm+8QwQA9AOJWEnbnqQ/KxQKdVt3BgAgFgzDI8NCorUyN1q2JunKykoVFhYqNzdX7e3tqq2tVV1dnfbt22dnWAAAOIKtSbqlpUX33nuvTp8+rYyMDOXl5Wnfvn1auHChnWEBAPoh3icdoWeffdbOywMAXCQR16Rt390NAAB657iNYwAA9AU2jgEA4FCJ2O4mSQMAXCERK2nWpAEAcCgqaQCAKxgW292sSQMA0EcMSYZhbX680e4GAMChqKQBAK4QkkcenjgGAIDzsLsbAADEDJU0AMAVQoZHHh5mAgCA8xiGxd3dNmzvpt0NAIBDUUkDAFwhETeOkaQBAK6QiEmadjcAwBW63oJlZURi1apV8ng83cbEiRMjOgeVNAAAfWTy5Ml6/fXXw58HDIgs7ZKkAQCuYMfu7gEDBmjUqFFRX5N2NwDAFS4laY+FEfk1jx8/ruzsbH3uc5/TsmXL9N5770U0n0oaAIAItLW1dfvs9Xrl9Xp7fG/WrFnaunWrJkyYoNOnT2v16tX60pe+pKNHjyo9Pd3UtaikAQCuYK2K/v3O8JycHGVkZIRHVVVVr9crLCzUnXfeqby8PN1+++3as2ePPvzwQ7344oumY6aSBgC4giFr74Tumuv3++Xz+cLHe6uiezN06FDdeOONOnHihOlrUkkDABABn8/XbZhN0h0dHfrFL36h0aNHm74WSRoA4Aqxaneb9cgjj+jAgQP61a9+pf/+7//Wn/7pnyo5OVl333236XPQ7gYAuEOs+t0mvf/++7r77rv129/+ViNGjNAXv/hFHTp0SCNGjDB9DpI0AMAdLD4WVBHO3bZtW/TX+hTtbgAAHIpKGgDgCon4PmmSNADAFRLxLVj9IkmnvxfUgIFBu8NwuGS7A0gIHTL3FCC3e0u5doeAfuJCxwVJR+wOw7H6RZIGAOCaDE/Em796zI8zkjQAwBUScU2a3d0AADgUlTQAwB3i/DCTWCBJAwBcIRF3d9PuBgDAoaikAQDuYUPL2gqSNADAFRKx3U2SBgC4QwJuHGNNGgAAh6KSBgC4hOfTYWV+fJGkAQDuQLsbAADECpU0AMAdErCSJkkDANwhAd+CRbsbAACHopIGALhCIr6qkiQNAHCHBFyTpt0NAIBDUUkDANwhATeOkaQBAK7gMS4NK/PjjSQNAHAH1qQBAECsUEkDANyBNWkAAByKdjcAAIgVKmkAgDskYCVNkgYAuEMCJmna3QAAOBSVNADAHdjdDQCAMyXiE8dodwMA4FC2Jumqqirl5+crPT1dWVlZWrp0qY4dO2ZnSACA/sqIwYjS2rVr5fF4VF5eHtE8W5P0gQMHVFpaqkOHDmn//v26ePGiFi1apM7OTjvDAgAgZhoaGrR582bl5eVFPNfWNenXXnut2+etW7cqKytLTU1NmjNnjk1RAQD6I48srklHMaejo0PLli3TM888o29+85sRzzeVpP/sz/7s2icaMECjRo3SwoULtWTJkogDkaTW1lZJUmZmZq8/DwQCCgQC4c9tbW1RXQcAgGh9Nvd4vV55vd5ev1taWqqioiItWLAgqiRtqt2dkZFxzZGamqrjx4/rrrvu0sqVKyMOJBQKqby8XLNnz9aUKVN6/U5VVVW3a+bk5ER8HQCAS3XdgmVlSMrJyemWi6qqqnq93LZt23T48OEr/twMU5X0li1bTJ9w9+7deuCBB7RmzZqIAiktLdXRo0d18ODBK36nsrJSFRUV4c9tbW0kagCAOTF64pjf75fP5wsf7q2K9vv9evjhh7V//36lpKREfcmYr0l/8Ytf1MyZMyOaU1ZWpt27d6u+vl5jxoy54veu1lIAACAefD5ftyTdm6amJrW0tGj69OnhY8FgUPX19dq4caMCgYCSk5Ovea2YJ+mhQ4fqlVdeMfVdwzD04IMPaseOHaqrq9P48eNjHQ4AAJfE8dnd8+fP15EjR7odKykp0cSJE/Xoo4+aStCSzbu7S0tLVVtbq127dik9PV1nzpyRpPAaNwAAsRLPJ46lp6f32F81ZMgQDR8+/Ir7rnpj633SNTU1am1t1bx58zR69Ojw2L59u51hAQDgCLZW0oZhw4NQAQDuZPOrKuvq6iKewws2AADuwPukAQBArFBJAwBcIRFfVUmSBgC4w2VPDYt6fpyRpAEA7sCaNAAAiBUqaQCAK7AmDQCAU9HuBgAAsUIlDQBwB4vtbjsqaZI0AMAdaHcDAIBYoZIGALhDAlbSJGkAgCsk4i1YtLsBAHAokjQAAA5FuxsA4A6sSQMA4EysSQMAgJihkgYAuIcN1bAVJGkAgDsk4Jo07W4AAByKShoA4AqJuHGMJA0AcAfa3QAAIFaopAEArkC7GwAAp6LdDQAAYoVKGgDgDglYSZOkAQCuwJq0TdJPtGpA8nm7w3C4oXYHkCCS7Q4gIXQo3e4QEsJbyrU7BMcLfhSI38USsJJmTRoAAIfqF5U0AADXlICVNEkaAOAKibgmTbsbAACHIkkDANzBiMGIQE1NjfLy8uTz+eTz+VRQUKC9e/dGdA6SNADAFbra3VZGJMaMGaO1a9eqqalJjY2Nuu2223THHXfonXfeMX0O1qQBAOgDS5Ys6fb5iSeeUE1NjQ4dOqTJkyebOgdJGgDgDjHa3d3W1tbtsNfrldfrverUYDCol156SZ2dnSooKDB9SdrdAAB3iNGadE5OjjIyMsKjqqrqipc8cuSI0tLS5PV69fd///fasWOHJk2aZDpkKmkAACLg9/vl8/nCn69WRU+YMEHNzc1qbW3Vyy+/rOLiYh04cMB0oiZJAwBcwfPpsDJfUni3thmDBg3SDTfcIEmaMWOGGhoatGHDBm3evNnUfJI0AMAdHPDEsVAopEDA/PPKSdIAAFeI9xPHKisrVVhYqNzcXLW3t6u2tlZ1dXXat2+f6XOQpAEA6AMtLS269957dfr0aWVkZCgvL0/79u3TwoULTZ+DJA0AcIc4t7ufffZZCxe7hCQNAHAPG16SYQX3SQMA4FBU0gAAV0jEV1WSpAEA7uCAW7AiRbsbAACHopIGALgC7W4AAJyKdjcAAIgVKmkAgCvQ7gYAwKkSsN1NkgYAuEMCJmnWpAEAcCgqaQCAK7AmDQCAU9HuBgAAsUIlDQBwBY9hyGNEXw5bmRstkjQAwB1od0emvr5eS5YsUXZ2tjwej3bu3GlnOAAAOIqtSbqzs1NTp05VdXW1nWEAAFyga3e3lRFvtra7CwsLVVhYaGcIAAC3SMB2d0KtSQcCAQUCgfDntrY2G6MBAKBvJdQtWFVVVcrIyAiPnJwcu0MCACSIRGx3J1SSrqysVGtra3j4/X67QwIAJAojBiPOEqrd7fV65fV67Q4DAJCAEvGxoAlVSQMA4Ca2VtIdHR06ceJE+PPJkyfV3NyszMxM5ebm2hgZAKDfYXd3ZBobG3XrrbeGP1dUVEiSiouLtXXrVpuiAgD0V3a0rK2wNUnPmzdPhg3PQgUAIBEk1MYxAACiZhiXhpX5cUaSBgC4Aru7AQBAzFBJAwDcgd3dAAA4kyd0aViZH2+0uwEAcCgqaQCAOyRgu5tKGgDgCvF+C1ZVVZXy8/OVnp6urKwsLV26VMeOHYvoHCRpAIA7dN0nbWVE4MCBAyotLdWhQ4e0f/9+Xbx4UYsWLVJnZ6fpc9DuBgCgD7z22mvdPm/dulVZWVlqamrSnDlzTJ2DJA0AcIVYPcykra2t23Gzr1FubW2VJGVmZpq+Ju1uAIA7GDEYknJycpSRkREeVVVV17x0KBRSeXm5Zs+erSlTppgOmUoaAIAI+P1++Xy+8GczVXRpaamOHj2qgwcPRnQtkjQAwBVi1e72+XzdkvS1lJWVaffu3aqvr9eYMWMiuiZJGgDgDnF+C5ZhGHrwwQe1Y8cO1dXVafz48RFfkiQNAEAfKC0tVW1trXbt2qX09HSdOXNGkpSRkaHU1FRT52DjGADAFeL9MJOamhq1trZq3rx5Gj16dHhs377d9DmopAEA7hDnx4IaVlrrn6KSBgDAoaikAQCuEKvd3fFEkgYAuEPIuDSszI8zkjQAwB14VSUAAIgVKmkAgCt4ZHFNOmaRmEeSBgC4Q5yfOBYLtLsBAHAoKmkAgCtwCxYAAE7F7m4AABArVNIAAFfwGIY8FjZ/WZkbrX6RpIM/Oy6PZ6DdYThauibYHUKCGGp3AAki2e4AEkKH0u0OwfFC5+P4/+7Qp8PK/Dij3Q0AgEP1i0oaAIBrod0NAIBTJeDubpI0AMAdeOIYAACIFSppAIAr8MQxAACcinY3AACIFSppAIAreEKXhpX58UaSBgC4A+1uAAAQK1TSAAB34GEmAAA4UyI+FpR2NwAADkUlDQBwhwTcOEaSBgC4gyFr74RmTRoAgL7BmjQAAIgZKmkAgDsYsrgmHbNITCNJAwDcIQE3jtHuBgDAoaikAQDuEJLksTg/zqikAQCu0LW728qIRH19vZYsWaLs7Gx5PB7t3Lkz4phJ0gAA9IHOzk5NnTpV1dXVUZ+DdjcAwB3ivHGssLBQhYWF0V9PJGkAgFsk4O5ukjQAABFoa2vr9tnr9crr9fbJtViTBgC4Q1clbWVIysnJUUZGRnhUVVX1WchU0gAAd4jRLVh+v18+ny98uK+qaIkkDQBwiVi9YMPn83VL0n2JJA0AQB/o6OjQiRMnwp9Pnjyp5uZmZWZmKjc319Q5HLEmXV1drXHjxiklJUWzZs3SW2+9ZXdIAID+JkZr0mY1NjZq2rRpmjZtmiSpoqJC06ZN08qVK02fw/ZKevv27aqoqNCmTZs0a9YsrV+/XrfffruOHTumrKwsu8MDAPQXIUPyWLiNKhTZ3Hnz5smweNuW7ZX0unXrdN9996mkpESTJk3Spk2bNHjwYH33u9+1OzQAAGxla5K+cOGCmpqatGDBgvCxpKQkLViwQD/+8Y9tjAwA0O/Eud0dC7a2u3/zm98oGAxq5MiR3Y6PHDlS7777bo/vBwIBBQKB8OfP3lAOAMCVWU20vE/6qqqqqrrdQJ6Tk2N3SAAA9Blbk/R1112n5ORknT17ttvxs2fPatSoUT2+X1lZqdbW1vDw+/3xChUAkOgSsN1ta5IeNGiQZsyYoTfeeCN8LBQK6Y033lBBQUGP73u93vBN5PG8mRwA0A+EDOsjzmy/BauiokLFxcWaOXOmbrnlFq1fv16dnZ0qKSmxOzQAAGxle5K+6667dO7cOa1cuVJnzpzRzTffrNdee63HZjIAACwxQpeGlflxZnuSlqSysjKVlZXZHQYAoD/jfdIAADhUyJCl26hsWJNOqFuwAABwEyppAIA70O4GAMChDFlM0jGLxDTa3QAAOBSVNADAHWh3AwDgUKGQJAv3Oofif5807W4AAByKShoA4A60uwEAcKgETNK0uwEAcCgqaQCAOyTgY0FJ0gAAVzCMkAwLb7KyMjdaJGkAgDsYhrVqmDVpAADQhUoaAOAOhsU1aW7BAgCgj4RCksfCurINa9K0uwEAcCgqaQCAO9DuBgDAmYxQSIaFdrcdt2DR7gYAwKGopAEA7kC7GwAAhwoZkiexkjTtbgAAHIpKGgDgDoYhycp90rS7AQDoE0bIkGGh3W3Q7gYAoI8YIesjCtXV1Ro3bpxSUlI0a9YsvfXWW6bnkqQBAOgj27dvV0VFhR5//HEdPnxYU6dO1e23366WlhZT80nSAABXMEKG5RGpdevW6b777lNJSYkmTZqkTZs2afDgwfrud79raj5JGgDgDnFud1+4cEFNTU1asGBB+FhSUpIWLFigH//4x6bOkdAbx7oW8T/RRUv3p7uBEQzYHUJC+OTiebtDSAjBQLLdISSE0Pn4P0Yy0YTOX/o7F49NWVZzxSe6KElqa2vrdtzr9crr9fb4/m9+8xsFg0GNHDmy2/GRI0fq3XffNXXNhE7S7e3tkqSD2mNzJAngZ3YHkCD4PQG2aG9vV0ZGRp+ce9CgQRo1apQOnrGeK9LS0pSTk9Pt2OOPP65Vq1ZZPndvEjpJZ2dny+/3Kz09XR6Px+5wJF36F1ZOTo78fr98Pp/d4TgWvydz+D2Zw+/JHCf+ngzDUHt7u7Kzs/vsGikpKTp58qQuXLhg+VyGYfTIN71V0ZJ03XXXKTk5WWfPnu12/OzZsxo1apSp6yV0kk5KStKYMWPsDqNXPp/PMX8JnIzfkzn8nszh92SO035PfVVBXy4lJUUpKSl9fp3LDRo0SDNmzNAbb7yhpUuXSpJCoZDeeOMNlZWVmTpHQidpAACcrKKiQsXFxZo5c6ZuueUWrV+/Xp2dnSopKTE1nyQNAEAfueuuu3Tu3DmtXLlSZ86c0c0336zXXnutx2ayKyFJx5jX69Xjjz9+xTUKXMLvyRx+T+bwezKH35M9ysrKTLe3P8tj2PEwUgAAcE08zAQAAIciSQMA4FAkaQAAHIokDQCAQ5GkY8zKe0PdoL6+XkuWLFF2drY8Ho927txpd0iOVFVVpfz8fKWnpysrK0tLly7VsWPH7A7LcWpqapSXlxd+OEdBQYH27t1rd1iOtnbtWnk8HpWXl9sdCkwgSceQ1feGukFnZ6emTp2q6upqu0NxtAMHDqi0tFSHDh3S/v37dfHiRS1atEidnZ12h+YoY8aM0dq1a9XU1KTGxkbddtttuuOOO/TOO+/YHZojNTQ0aPPmzcrLy7M7FJjELVgxNGvWLOXn52vjxo2SLj3+LScnRw8++KAee+wxm6NzHo/Hox07doQfl4crO3funLKysnTgwAHNmTPH7nAcLTMzU9/61rf0N3/zN3aH4igdHR2aPn26nn76aX3zm9/UzTffrPXr19sdFq6BSjpGYvHeUOBKWltbJV1KQOhdMBjUtm3b1NnZqYKCArvDcZzS0lIVFRV1+38UnI8njsVILN4bCvQmFAqpvLxcs2fP1pQpU+wOx3GOHDmigoICnT9/XmlpadqxY4cmTZpkd1iOsm3bNh0+fFgNDQ12h4IIkaQBhystLdXRo0d18OBBu0NxpAkTJqi5uVmtra16+eWXVVxcrAMHDpCoP+X3+/Xwww9r//79cX8LFKwjScdILN4bCnxWWVmZdu/erfr6ese+ltVugwYN0g033CBJmjFjhhoaGrRhwwZt3rzZ5sicoampSS0tLZo+fXr4WDAYVH19vTZu3KhAIKDk5GQbI8TVsCYdI5e/N7RL13tDWR9DpAzDUFlZmXbs2KE333xT48ePtzukhBEKhRQIBOwOwzHmz5+vI0eOqLm5OTxmzpypZcuWqbm5mQTtcFTSMWT1vaFu0NHRoRMnToQ/nzx5Us3NzcrMzFRubq6NkTlLaWmpamtrtWvXLqWnp+vMmTOSpIyMDKWmptocnXNUVlaqsLBQubm5am9vV21trerq6rRv3z67Q3OM9PT0HnsZhgwZouHDh7PHIQGQpGPI6ntD3aCxsVG33npr+HNFRYUkqbi4WFu3brUpKuepqamRJM2bN6/b8S1btmj58uXxD8ihWlpadO+99+r06dPKyMhQXl6e9u3bp4ULF9odGhAT3CcNAIBDsSYNAIBDkaQBAHAokjQAAA5FkgYAwKFI0gAAOBRJGgAAhyJJAwDgUCRpAAAciiQNONjy5cu1dOlSu8MAYBOSNAAADkWSBgDAoUjSAAA4FEkaAACHIkkDAOBQJGkAAByKJA0AgEORpAEAcCiSNAAADuUxDMOwOwgAANATlTQAAA5FkgYAwKFI0gAAOBRJGgAAhyJJAwDgUCRpAAAciiQNAIBDkaQBAHAokjQAAA5FkgYAwKFI0gAAOBRJGgAAh/p/2Ww8TswexzgAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_out at K = 0\n", - "Min and max values: 0.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing `copy_stencil` with domain=(2,2,nz)\n", - "Plotting qty_out at K = 0 based on `copy_stencil` with domain = (2,2,nz)\n", - "Min and max values: 2.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Resetting qty_out to zero...\n", - "Plotting values of qty_out at K = 0\n", - "Min and max values: 0.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing `copy_stencil` with origin = (2,2,0), domain=(2,2,nz)\n", - "Plotting qty_out at K = 0 based on `copy_stencil` with origin = (2,2,0), domain = (2,2,nz)\n", - "Min and max values: 6.0 0.0\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAHHCAYAAACbaKDRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAlqklEQVR4nO3df3AU9f3H8dcR4AIkdxA0YCSASoUiDRaINqIQfijNF6i0Y7UWa8DWsTUBMXXUtB1+WQ0dpwodYkRHiXWk4C+gRX4Uf4QUFQ3BTMEWCpbaQ4Gg1fyqBL3b7x+YKzEB9m4vt3vZ52Nm/7i9/ey+OQffvN+fz+56DMMwBAAAHKeL3QEAAID2kaQBAHAokjQAAA5FkgYAwKFI0gAAOBRJGgAAhyJJAwDgUCRpAAAciiQNAIBDkaThahUVFfJ4PKqoqLA7FABogySNTqm8vFwejye8JScn6+KLL1ZhYaGOHj0ak2ts3LhRCxcujMm5TrVq1SotXbrU9PGDBw/WtGnT2ux/+umnlZSUpG9/+9s6fvx4DCM8sw8++EDXX3+9evfuLZ/Pp2uvvVb//Oc/43Z9oDPpancAQEdavHixLrjgAh0/flzbt29XWVmZNm7cqD179qhnz56Wzr1x40aVlpbGPFGvWrVKe/bs0bx586I+xzPPPKNZs2Zp8uTJWrdunZKTk2MX4Bk0NjZqwoQJqqur0y9+8Qt169ZNDz/8sMaPH6+amhr17ds3LnEAnQVJGp1aXl6exowZI0n6yU9+or59++qhhx7S+vXrdeONN9ocXcdYvXq18vPzNXHiRK1fvz5uCVqSHnnkEe3fv19vv/22srOzJZ38bzBixAj99re/1QMPPBC3WIDOgHY3XGXixImSpIMHD57xuOeee06jR49Wjx49dM455+imm27SBx98EP5+1qxZKi0tlaRWbfUzWb9+vaZOnaqMjAx5vV5ddNFFuu+++xQMBsPH5Obm6qWXXtL7778fPufgwYNN//meffZZ3XTTTcrNzdUf//jHuCZoSXr++eeVnZ0dTtCSNGzYME2aNEnPPvtsXGMBOgMqabjKe++9J0lnbLuWl5dr9uzZys7OVklJiY4ePaply5bp9ddf1zvvvKPevXvrtttu04cffqitW7fq6aefNnXt8vJypaSkqKioSCkpKXr11Vc1f/581dfX68EHH5Qk/fKXv1RdXZ0OHTqkhx9+WJKUkpJi6vwvvPCCZs6cqXHjxulPf/qTevToYWpcY2OjqTnrbt26ye/3n/b7UCikv/71r7rlllvafHfZZZfpz3/+sxoaGpSammoqLgCSDKATWrlypSHJePnll41jx44ZgUDAWL16tdG3b1+jR48exqFDhwzDMIzXXnvNkGS89tprhmEYxokTJ4z09HRjxIgRxmeffRY+34YNGwxJxvz588P7CgoKjEj+Cv33v/9ts++2224zevbsaRw/fjy8b+rUqcagQYNMn3fQoEFGRkaG0bVrVyM3N9doamoyPdYwDCM/P9+QdNZt/PjxZzzPsWPHDEnG4sWL23xXWlpqSDL27t0bUWyA21FJo1ObPHlyq8+DBg3SM888o/PPP7/d43fu3Kna2lotXLiwVat46tSpGjZsmF566SUtWrQoqlhOrWwbGhrU3Nysq666SitWrNDevXs1cuTIqM4rSf/5z3/0xRdfaMCAAaYr6BZ33323brrpprMe16dPnzN+/9lnn0mSvF5vm+9afsuWYwCYQ5JGp1ZaWqqLL75YXbt2Vb9+/TR06FB16XL6pRjvv/++JGno0KFtvhs2bJi2b98edSzvvvuufvWrX+nVV19VfX19q+/q6uqiPq8kTZo0SQMHDlRZWZnS0tK0bNky02OHDx+u4cOHW7q+9L9/hDQ3N7f5rqWdHuk/IAC3I0mjU7vsssvCq7vt9Omnn2r8+PHy+XxavHixLrroIiUnJ2vXrl265557FAqFLF9j+fLl+uSTT/S73/1Offr0MX1rWF1dnakKt3v37kpLSzvt92lpafJ6vTp8+HCb71r2ZWRkmIoJwEkkaeAUgwYNkiTt27cvvBK8xb59+8LfSzrrau5TVVRU6OOPP9aLL76ocePGhfe3t8o8kvOeqkuXLvr973+vuro6LVq0SGlpaZo7d+5Zx91xxx166qmnznrc+PHjz/hkti5duugb3/iGdu7c2ea7t956SxdeeCGLxoAIkaSBU4wZM0bp6el69NFHdcstt4TnVzdt2qS///3vmj9/fvjYXr16STpZJffu3fuM501KSpIkGYYR3nfixAk98sgjbY7t1atX1O3vbt266fnnn9c111yjefPmqU+fPvrRj350xjGxmpOWpOuuu0733nuvdu7cGe5g7Nu3T6+++qruuusuc38IAGEkaeAU3bp1029+8xvNnj1b48eP14033hi+BWvw4MG68847w8eOHj1akjR37lxNmTJFSUlJ+sEPftDuea+44gr16dNH+fn5mjt3rjwej55++ulWSfvU865Zs0ZFRUXKzs5WSkqKpk+fbvrP0LNnT7300ksaP368brnlFvn9fn3nO9857fGxmpOWpNtvv12PP/64pk6dqrvuukvdunXTQw89pH79+unnP/95TK4BuIrdy8uBjtByC1ZVVdUZj/vqLVgt1qxZY3zzm980vF6vkZaWZsycOTN821aLL774wpgzZ45x7rnnGh6P56y3Y73++uvGt771LaNHjx5GRkaGcffddxtbtmxpc/3Gxkbjhz/8odG7d29D0llvxxo0aJAxderUNvuPHDliDBkyxEhOTm7z5+tIgUDAuO666wyfz2ekpKQY06ZNM/bv3x+36wOdiccw2vmnPAAAsB2PBQUAwKFI0gAAOBRJGgAAhyJJAwDQQT744APddNNN6tu3r3r06HHaZwmcDrdgAQDQAT755BONHTtWEyZM0KZNm3Tuuedq//79pp450ILV3QAAdIB7771Xr7/+uv7yl79EfY6ETtKhUEgffvihUlNTo36UIgDAPoZhqKGhQRkZGWd8+Y1Vx48f14kTJyyfxzCMNvnG6/W2+/a34cOHa8qUKTp06JC2bdum888/X7fffrtuvfXWiC6YsAKBgKn34LKxsbGxOXsLBAIdlis+++wzo396UkziTElJabNvwYIF7V7X6/UaXq/XKC4uNnbt2mWsWLHCSE5ONsrLy03HntCVdF1dnXr37q0r9X/qqm52hwMAiNAX+lzbtVGffvqp/H5/h1yjvr5efr9f71cPli81+mq9viGkQaP/pUAgIJ/PF95/ukq6e/fuGjNmjN54443wvrlz56qqqkpvvvmmqWsm9MKxlpZDV3VTVw9JGgASzpdlYjymLFNSPUpJjf46IZ0c6/P5WiXp0znvvPPaPBf/61//ul544QXT10zoJA0AgFlBI6Sghd5x0Ijsve9jx47Vvn37Wu37xz/+0eqVt2dDkgYAuEJIhkKKPktHOvbOO+/UFVdcoQceeEDXX3+93n77bT322GN67LHHTJ+Dh5kAANABsrOztXbtWv3hD3/QiBEjdN9992np0qWaOXOm6XNQSQMAXCGkkCJrWLcdH6lp06Zp2rRpUV+TJA0AcIWgYSho4YYmK2OjRbsbAACHopIGALhCvBeOxQJJGgDgCiEZCiZYkqbdDQCAQ1FJAwBcgXY3AAAOxepuAAAQM1TSAABXCH25WRkfbyRpAIArBC2u7rYyNlokaQCAKwQNWXwLVuxiMYs5aQAAHIpKGgDgCsxJAwDgUCF5FJTH0vh4o90NAIBDUUkDAFwhZJzcrIyPN5I0AMAVghbb3VbGRot2NwAADkUlDQBwhUSspEnSAABXCBkehQwLq7stjI0W7W4AAByKShoA4Aq0uwEAcKiguihooYEcjGEsZpGkAQCuYFickzaYkwYAAC2opAEArpCIc9KOqaSXLFkij8ejefPm2R0KAKATChpdLG/x5ogkXVVVpRUrVigrK8vuUAAAcAzbk3RjY6Nmzpypxx9/XH369LE7HABAJxWSRyF1sbC5sN1dUFCgqVOnavLkyWc9trm5WfX19a02AADMaJmTtrLFm60Lx1avXq1du3apqqrK1PElJSVatGhRB0cFAIAz2FZJBwIB3XHHHXrmmWeUnJxsakxxcbHq6urCWyAQ6OAoAQCdRSIuHLOtkq6urlZtba1GjRoV3hcMBlVZWanly5erublZSUlJrcZ4vV55vd54hwoA6AROzklbeMGGm9rdkyZN0u7du1vtmz17toYNG6Z77rmnTYIGAMBtbEvSqampGjFiRKt9vXr1Ut++fdvsBwDAqpDFZ3eHZMQwGnN44hgAwBWszisHDZcn6YqKCrtDAAB0Ui33O0c/Pv5J2vb7pAEAQPscVUkDANBRgoZHQQuvm7QyNlokaQCAKwQtLhwL0u4GAAAtqKQBAK4QMrooZGF1d8jtq7sBAOgotLsBAEDMUEkDAFwhJGsrtEOxC8U0kjQAwBWsP8wk/s1n2t0AADgUlTQAwBWsP7vbRe+TBgAgnnifNAAADpWIlTRz0gAAdICFCxfK4/G02oYNGxbROaikAQCuYP1hJpGPveSSS/Tyyy+HP3ftGlnaJUkDAFwhZHgUsnKfdBRju3btqv79+0d9TdrdAAB0kP379ysjI0MXXnihZs6cqX//+98RjaeSBgC4Qshiu7vlYSb19fWt9nu9Xnm93jbHX3755SovL9fQoUN1+PBhLVq0SFdddZX27Nmj1NRUU9ekkgYAuELLW7CsbJKUmZkpv98f3kpKStq9Xl5enr7//e8rKytLU6ZM0caNG/Xpp5/q2WefNR0zlTQAABEIBALy+Xzhz+1V0e3p3bu3Lr74Yh04cMD0taikAQCuEJTH8iZJPp+v1WY2STc2Nuq9997TeeedZzpmkjQAwBVi1e4266677tK2bdv0r3/9S2+88Ya++93vKikpSTfeeKPpc9DuBgCgAxw6dEg33nijPv74Y5177rm68sortWPHDp177rmmz0GSBgC4QlAKt6yjHR+J1atXR32tFiRpAIArRNOy/ur4eCNJAwBcgRdsAACAmKGSBgC4gmHxfdIG75MGAKBj0O4GAAAxQyUNnGLau5/YHUJCmNPnfbtDSAhTMi61OwScwo5XVVpFkgYAuELQ4luwrIyNFu1uAAAcikoaAOAKtLsBAHCokLooZKGBbGVstGh3AwDgUFTSAABXCBoeBS20rK2MjRZJGgDgCsxJAwDgUIbFt2AZPHEMAAC0oJIGALhCUB4FLbwkw8rYaJGkAQCuEDKszSuHjBgGYxLtbgAAHIpKGgDgCiGLC8esjI0WSRoA4AoheRSyMK9sZWy0aHcDAOBQVNIAAFfgiWMAADhUIs5J0+4GAMChqKQBAK4QksVnd/MwEwAAOoZhcXW3QZIGAKBjJOJbsJiTBgDAoaikAQCukIiru0nSAABXoN0NAABihkoaAOAKifjsbpI0AMAVaHcDAICYoZIGALhCIlbSJGkAgCskYpKm3Q0AgENRSQMAXIFKOkJlZWXKysqSz+eTz+dTTk6ONm3aZGdIAIBOytD/bsOKZjNsiNnWSnrAgAFasmSJvva1r8kwDD311FO69tpr9c477+iSSy6xMzQAQCeTiJW0rUl6+vTprT7ff//9Kisr044dO0jSAADXc8ycdDAY1HPPPaempibl5OS0e0xzc7Oam5vDn+vr6+MVHgAgwVFJR2H37t3KycnR8ePHlZKSorVr12r48OHtHltSUqJFixbFOUIAQGeQiEna9luwhg4dqpqaGr311lv62c9+pvz8fP3tb39r99ji4mLV1dWFt0AgEOdoAQCIH9sr6e7du2vIkCGSpNGjR6uqqkrLli3TihUr2hzr9Xrl9XrjHSIAoBNIxEra9iT9VaFQqNW8MwAAsWAYHhkWEq2VsdGyNUkXFxcrLy9PAwcOVENDg1atWqWKigpt2bLFzrAAAHAEW5N0bW2tbr75Zh0+fFh+v19ZWVnasmWLrr76ajvDAgB0QrxPOkJPPPGEnZcHALhIIs5J2766GwAAtI8kDQBwhZaFY1a2aC1ZskQej0fz5s2LaJzjVncDANAR7Gp3V1VVacWKFcrKyop4LJU0AMAV7KikGxsbNXPmTD3++OPq06dPxONJ0gAARKC+vr7VdqZnexQUFGjq1KmaPHlyVNciSQMAXMH4st0d7dZSSWdmZsrv94e3kpKSdq+3evVq7dq167Tfm8GcNADAFQxJhmFtvCQFAgH5fL7w/vYeVx0IBHTHHXdo69atSk5OjvqaJGkAACLg8/laJen2VFdXq7a2VqNGjQrvCwaDqqys1PLly9Xc3KykpKSzXoskDQBwhZA88sTpiWOTJk3S7t27W+2bPXu2hg0bpnvuucdUgpZI0gAAl4jnCzZSU1M1YsSIVvt69eqlvn37ttl/JiwcAwDAoaikAQCuEDI88tj47O6KioqIx5CkAQCuYBgWV3dbGBst2t0AADgUlTQAwBXiuXAsVkjSAABXIEkDAOBQdi8ciwZz0gAAOBSVNADAFRJxdTdJGgDgCieTtJU56RgGYxLtbgAAHIpKGgDgCqzuBgDAoQz9753Q0Y6PN9rdAAA4FJU0AMAVaHcDAOBUCdjvJkkDANzBYiUtnjgGAABaUEkDAFyBJ44BAOBQLBwDEtwz72fbHQIAhJGkAQDuYHisLf6ikgYAoGMk4pw0q7sBAHAoKmkAgDvwMBMAAJwpEVd30+4GAMChqKQBAO5hx/smLSBJAwBcIRHb3SRpAIA7JODCMeakAQBwKCppAIBLeL7crIyPL5I0AMAdaHcDAIBYoZIGALhDAlbSJGkAgDsk4FuwaHcDAOBQVNIAAFdIxFdVkqQBAO6QgHPStLsBAHAoKmkAgDsk4MIxkjQAwBU8xsnNyvh4I0kDANyBOWkAABArVNIAAHdgThoAAIei3Q0AAGKFShoA4A4JWEmTpAEA7pCASZp2NwAADkUlDQBwB1Z3AwDgTIn4xDHa3QAAOJStSbqkpETZ2dlKTU1Venq6ZsyYoX379tkZEgCgszJisEWgrKxMWVlZ8vl88vl8ysnJ0aZNmyI6h61Jetu2bSooKNCOHTu0detWff7557rmmmvU1NRkZ1gAAFg2YMAALVmyRNXV1dq5c6cmTpyoa6+9Vu+++67pc9g6J7158+ZWn8vLy5Wenq7q6mqNGzfOpqgAAJ2RRxbnpCM8fvr06a0+33///SorK9OOHTt0ySWXmDqHqST9ve997+wn6tpV/fv319VXX90mMLPq6uokSWlpae1+39zcrObm5vDn+vr6qK4DAEC0vpp7vF6vvF7vGccEg0E999xzampqUk5OjulrmWp3+/3+s249evTQ/v37dcMNN2j+/PmmA2gRCoU0b948jR07ViNGjGj3mJKSklbXzMzMjPg6AACXarkFy8omKTMzs1UuKikpOe0ld+/erZSUFHm9Xv30pz/V2rVrNXz4cNMhm6qkV65cafqEGzZs0O23367FixebHiNJBQUF2rNnj7Zv337aY4qLi1VUVBT+XF9fT6IGAJgToyeOBQIB+Xy+8O4zVdFDhw5VTU2N6urq9Pzzzys/P1/btm0znahjPid95ZVXasyYMRGNKSws1IYNG1RZWakBAwac9jgzLQUAADpSy2ptM7p3764hQ4ZIkkaPHq2qqiotW7ZMK1asMDU+5km6d+/eevHFF00daxiG5syZo7Vr16qiokIXXHBBrMMBAOAkBzy7OxQKtVpbdTa2ru4uKCjQqlWrtH79eqWmpurIkSOSFJ7jBgAgVuL9xLHi4mLl5eVp4MCBamho0KpVq1RRUaEtW7aYPoetSbqsrEySlJub22r/ypUrNWvWrPgHBABAjNTW1urmm2/W4cOH5ff7lZWVpS1btujqq682fQ5bk7Rh2PAgVACAO8W53f3EE09YuNhJvGADAOAODpiTjhQv2AAAwKGopAEArpCIr6okSQMA3OGUp4ZFPT7OSNIAAHdgThoAAMQKlTQAwBWYkwYAwKlodwMAgFihkgYAuIPFdrcdlTRJGgDgDrS7AQBArFBJAwDcIQEraZI0AMAVEvEWLNrdAAA4FEkaAACHot0NAHAH5qQBAHAm5qQBAEDMUEkDANzDhmrYCpI0AMAdEnBOmnY3AAAORSUNAHCFRFw4RpIGALgD7W4AABArVNIAAFeg3Q0AgFPR7gYAALFCJQ0AcIcErKRJ0gAAV2BOGkhw/v87YHcICWGD+tgdAhC5BKykmZMGAMChqKQBAO6QgJU0SRoA4AqJOCdNuxsAAIeikgYAuAPtbgAAnIl2NwAAiBkqaQCAO9DuBgDAoRIwSdPuBgDAoaikAQCu4PlyszI+3kjSAAB3SMB2N0kaAOAK3IIFAABihkoaAOAOtLsBAHAwGxKtFbS7AQBwKCppAIArJOLCMZI0AMAdEnBOmnY3AAAdoKSkRNnZ2UpNTVV6erpmzJihffv2RXQOkjQAwBVa2t1Wtkhs27ZNBQUF2rFjh7Zu3arPP/9c11xzjZqamkyfg3Y3AMAd4tzu3rx5c6vP5eXlSk9PV3V1tcaNG2fqHFTSAADEQV1dnSQpLS3N9BgqaQCAK8RqdXd9fX2r/V6vV16v94xjQ6GQ5s2bp7Fjx2rEiBGmr0klDQBwByMGm6TMzEz5/f7wVlJSctZLFxQUaM+ePVq9enVEIVNJAwDcIUZz0oFAQD6fL7z7bFV0YWGhNmzYoMrKSg0YMCCiS5KkAQCIgM/na5WkT8cwDM2ZM0dr165VRUWFLrjggoivRZIGALhCvJ84VlBQoFWrVmn9+vVKTU3VkSNHJEl+v189evQwdQ7mpAEA7hCjOWmzysrKVFdXp9zcXJ133nnhbc2aNabPQSUNAEAHMAzrzxElSQMAXMFjGPJYSJxWxkaLJA0AcAdesBGZyspKTZ8+XRkZGfJ4PFq3bp2d4QAA4Ci2JummpiaNHDlSpaWldoYBAHCBeL9gIxZsbXfn5eUpLy/PzhAAAG6RgO3uhJqTbm5uVnNzc/jzV5+fCgBAZ5JQ90mXlJS0el5qZmam3SEBABJEIra7EypJFxcXq66uLrwFAgG7QwIAJIo4P8wkFhKq3W3mdWAAALQn3o8FjYWEqqQBAHATWyvpxsZGHThwIPz54MGDqqmpUVpamgYOHGhjZACATofV3ZHZuXOnJkyYEP5cVFQkScrPz1d5eblNUQEAOis7WtZW2Jqkc3NzY/IAcgAAOqOEWjgGAEDUDOPkZmV8nJGkAQCuwOpuAAAQM1TSAAB3YHU3AADO5Amd3KyMjzfa3QAAOBSVNADAHWh3AwDgTIm4upskDQBwhwS8T5o5aQAAHIpKGgDgCrS7AQBwqgRcOEa7GwAAh6KSBgC4Au1uAACcitXdAAAgVqikAQCuQLsbAACnYnU3AACIFSppAIAr0O4GAMCpQsbJzcr4OCNJAwDcgTlpAAAQK1TSAABX8MjinHTMIjGPJA0AcAeeOAYAAGKFShoA4ArcggUAgFOxuhsAAMQKlTQAwBU8hiGPhcVfVsZGiyQNAHCH0JeblfFxRrsbAACHopIGALgC7W4AAJwqAVd3k6QBAO7AE8cAAECsUEkDAFyBJ44BAOBUtLsBAIAkVVZWavr06crIyJDH49G6desiPgdJGgDgCp6Q9S0STU1NGjlypEpLS6OOmXY3AMAd4tzuzsvLU15eXvTXE0kaAICI1NfXt/rs9Xrl9Xo75Fq0uwEA7mDEYJOUmZkpv98f3kpKSjosZCppAIArxOqxoIFAQD6fL7y/o6poiSQNAEBEfD5fqyTdkUjSAAB3SMD7pEnSAAB3MGTtndAR5ujGxkYdOHAg/PngwYOqqalRWlqaBg4caOocJGkAgCvE+1WVO3fu1IQJE8Kfi4qKJEn5+fkqLy83dQ6SNAAAHSA3N1eGxRY5SRoA4A6GLM5JxywS00jSAAB3SMCFYzzMBAAAh6KSBgC4Q0iSx+L4OCNJAwBcId6ru2OBdjcAAA5FJQ0AcIcEXDhGkgYAuEMCJmna3QAAOBSVNADAHRKwkiZJAwDcgVuwAABwJm7BAgAAMeOIJF1aWqrBgwcrOTlZl19+ud5++227QwIAdDYtc9JWtjizPUmvWbNGRUVFWrBggXbt2qWRI0dqypQpqq2ttTs0AEBnEjKsb3Fme5J+6KGHdOutt2r27NkaPny4Hn30UfXs2VNPPvmk3aEBAGArW5P0iRMnVF1drcmTJ4f3denSRZMnT9abb75pY2QAgE4nAdvdtq7u/uijjxQMBtWvX79W+/v166e9e/e2Ob65uVnNzc3hz/X19R0eIwCgs7CaaF3Y7o5ESUmJ/H5/eMvMzLQ7JAAAOoytSfqcc85RUlKSjh492mr/0aNH1b9//zbHFxcXq66uLrwFAoF4hQoASHQJ2O62NUl3795do0eP1iuvvBLeFwqF9MorrygnJ6fN8V6vVz6fr9UGAIApCbi62/YnjhUVFSk/P19jxozRZZddpqVLl6qpqUmzZ8+2OzQAAGxle5K+4YYbdOzYMc2fP19HjhzRpZdeqs2bN7dZTAYAgCVG6ORmZXyc2Z6kJamwsFCFhYV2hwEA6Mx4CxYAAA4VMmTpNio3PnEMAAC0j0oaAOAOtLsBAHAoQxaTdMwiMY12NwAADkUlDQBwB9rdAAA4VCgkycK9zqH43ydNuxsAAIeikgYAuAPtbgAAHCoBkzTtbgAAHIpKGgDgDgn4WFCSNADAFQwjJMPCm6ysjI0WSRoA4A6GYa0aZk4aAAC0oJIGALiDYXFOmluwAADoIKGQ5LEwr2zDnDTtbgAAHIpKGgDgDrS7AQBwJiMUkmGh3W3HLVi0uwEAcCgqaQCAO9DuBgDAoUKG5EmsJE27GwAAh6KSBgC4g2FIsnKfNO1uAAA6hBEyZFhodxu0uwEA6CBGyPoWhdLSUg0ePFjJycm6/PLL9fbbb5seS5IGAKCDrFmzRkVFRVqwYIF27dqlkSNHasqUKaqtrTU1niQNAHAFI2RY3iL10EMP6dZbb9Xs2bM1fPhwPfroo+rZs6eefPJJU+NJ0gAAd4hzu/vEiROqrq7W5MmTw/u6dOmiyZMn68033zR1joReONYyif+FPrd0fzoAwB5f6HNJ8VmUZTVXtMRaX1/far/X65XX621z/EcffaRgMKh+/fq12t+vXz/t3bvX1DUTOkk3NDRIkrZro82RAACsaGhokN/v75Bzd+/eXf3799f2I9ZzRUpKijIzM1vtW7BggRYuXGj53O1J6CSdkZGhQCCg1NRUeTweu8ORdPJfWJmZmQoEAvL5fHaH41j8TubwO5nD72SOE38nwzDU0NCgjIyMDrtGcnKyDh48qBMnTlg+l2EYbfJNe1W0JJ1zzjlKSkrS0aNHW+0/evSo+vfvb+p6CZ2ku3TpogEDBtgdRrt8Pp9j/hI4Gb+TOfxO5vA7meO036mjKuhTJScnKzk5ucOvc6ru3btr9OjReuWVVzRjxgxJUigU0iuvvKLCwkJT50joJA0AgJMVFRUpPz9fY8aM0WWXXaalS5eqqalJs2fPNjWeJA0AQAe54YYbdOzYMc2fP19HjhzRpZdeqs2bN7dZTHY6JOkY83q9WrBgwWnnKHASv5M5/E7m8DuZw+9kj8LCQtPt7a/yGHY8jBQAAJwVDzMBAMChSNIAADgUSRoAAIciSQMA4FAk6Riz8t5QN6isrNT06dOVkZEhj8ejdevW2R2SI5WUlCg7O1upqalKT0/XjBkztG/fPrvDcpyysjJlZWWFH86Rk5OjTZs22R2Woy1ZskQej0fz5s2zOxSYQJKOIavvDXWDpqYmjRw5UqWlpXaH4mjbtm1TQUGBduzYoa1bt+rzzz/XNddco6amJrtDc5QBAwZoyZIlqq6u1s6dOzVx4kRde+21evfdd+0OzZGqqqq0YsUKZWVl2R0KTOIWrBi6/PLLlZ2dreXLl0s6+fi3zMxMzZkzR/fee6/N0TmPx+PR2rVrw4/Lw+kdO3ZM6enp2rZtm8aNG2d3OI6WlpamBx98UD/+8Y/tDsVRGhsbNWrUKD3yyCP69a9/rUsvvVRLly61OyycBZV0jMTivaHA6dTV1Uk6mYDQvmAwqNWrV6upqUk5OTl2h+M4BQUFmjp1aqv/R8H5eOJYjMTivaFAe0KhkObNm6exY8dqxIgRdofjOLt371ZOTo6OHz+ulJQUrV27VsOHD7c7LEdZvXq1du3apaqqKrtDQYRI0oDDFRQUaM+ePdq+fbvdoTjS0KFDVVNTo7q6Oj3//PPKz8/Xtm3bSNRfCgQCuuOOO7R169a4vwUK1pGkYyQW7w0FvqqwsFAbNmxQZWWlY1/Larfu3btryJAhkqTRo0erqqpKy5Yt04oVK2yOzBmqq6tVW1urUaNGhfcFg0FVVlZq+fLlam5uVlJSko0R4kyYk46RU98b2qLlvaHMjyFShmGosLBQa9eu1auvvqoLLrjA7pASRigUUnNzs91hOMakSZO0e/du1dTUhLcxY8Zo5syZqqmpIUE7HJV0DFl9b6gbNDY26sCBA+HPBw8eVE1NjdLS0jRw4EAbI3OWgoICrVq1SuvXr1dqaqqOHDkiSfL7/erRo4fN0TlHcXGx8vLyNHDgQDU0NGjVqlWqqKjQli1b7A7NMVJTU9usZejVq5f69u3LGocEQJKOIavvDXWDnTt3asKECeHPRUVFkqT8/HyVl5fbFJXzlJWVSZJyc3Nb7V+5cqVmzZoV/4Acqra2VjfffLMOHz4sv9+vrKwsbdmyRVdffbXdoQExwX3SAAA4FHPSAAA4FEkaAACHIkkDAOBQJGkAAByKJA0AgEORpAEAcCiSNAAADkWSBgDAoUjSgIPNmjVLM2bMsDsMADYhSQMA4FAkaQAAHIokDQCAQ5GkAQBwKJI0AAAORZIGAMChSNIAADgUSRoAAIciSQMA4FAewzAMu4MAAABtUUkDAOBQJGkAAByKJA0AgEORpAEAcCiSNAAADkWSBgDAoUjSAAA4FEkaAACHIkkDAOBQJGkAAByKJA0AgEORpAEAcKj/Byhx5Du5nUeRAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", " dims=[\"I\", \"J\", \"K\"],\n", @@ -604,194 +266,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_in at K = 0\n", - "Min and max values: 12.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_in at K = 1\n", - "Min and max values: 13.0 1.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_in at K = 2\n", - "Min and max values: 14.0 2.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing 'mult_upward' with origin=(nhalo,nhalo,0),domain=(nx,ny,2)\n", - "Plotting values of qty_out at K = 0 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\n", - "Min and max values: 0.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_out at K = 1 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\n", - "Min and max values: 20.0 0.0\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf8AAAHHCAYAAACx2FF+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA3vklEQVR4nO3de3hV1Z3/8c9JAicRknDLVUIABSIiAbnEAApIBFNKAVtKMziEi7Z1EgUzVkvHAl7G2Dr1VmhQpxJqpaCdAhY1DKAJYwEl0DwjTqWAgQQhQfhJQlIJmLN/f2hOOOZCTvZJdnL2+/U863k8++y19/f4tH6zvmvttR2GYRgCAAC2EWB1AAAAoH2R/AEAsBmSPwAANkPyBwDAZkj+AADYDMkfAACbIfkDAGAzJH8AAGyG5A8AgM2Q/GFr+fn5cjgcys/PtzoUAGg3JH/4pdzcXDkcDncLDg7W4MGDlZmZqfLycp/c46233tLKlSt9cq3LrV+/Xs8++2yLz+/fv7++/e1vNzj+yiuvKDAwULfffrsuXLjgwwibdujQId1///0aN26cgoOD5XA4dOzYsXa5N4CWI/nDrz366KN65ZVXtGrVKo0bN045OTlKTk7WP/7xD9PXfuutt/TII4/4IEpP3ib/xrz66qtasGCBUlJStHnzZgUHB/smuCvYs2ePnn/+eZ0/f17XXXddu9wTgPeCrA4AaEupqakaPXq0JOmuu+5S79699fTTT2vLli1KS0uzOLq2sWHDBqWnp+vWW2/Vli1b2i3xS9J3vvMdnTt3TqGhofqP//gPFRUVtdu9AbQcI3/Yyq233ipJKi4ubva8119/XaNGjVJISIj69OmjO++8U59++qn7+wULFmj16tWS5DG90JwtW7Zo+vTpio2NldPp1DXXXKPHHntMtbW17nMmTZqkN998U8ePH3dfs3///i3+fa+99pruvPNOTZo0SW+88Ua7Jn5J6tWrl0JDQ9v1ngC8x8gftnL06FFJUu/evZs8Jzc3VwsXLtSYMWOUnZ2t8vJyPffcc/rLX/6iv/71r+rRo4d+9KMf6eTJk9q+fbteeeWVFt07NzdX3bt3V1ZWlrp376533nlHy5cvV2VlpZ566ilJ0r/927+poqJCJ06c0DPPPCNJ6t69e4uu/1//9V+aN2+ebrnlFv35z39WSEhIi/pVVVW1aE1Aly5dFB4e3qJrAujgDMAPrV271pBk7Nixw/jss8+M0tJSY8OGDUbv3r2NkJAQ48SJE4ZhGMa7775rSDLeffddwzAM4+LFi0ZkZKQxbNgw44svvnBfb+vWrYYkY/ny5e5jGRkZhjf/F/rHP/7R4NiPfvQj46qrrjIuXLjgPjZ9+nQjPj6+xdeNj483YmNjjaCgIGPSpElGdXV1i/sahmGkp6cbkq7YJk6c6NV1n3rqKUOSUVxc7FU/AG2PkT/8WkpKisfn+Ph4vfrqq7r66qsbPb+wsFCnT5/WypUrPUrm06dPV0JCgt58881WL/K7fCR+/vx51dTU6Oabb9YLL7ygjz/+WImJia26riT9v//3//Tll1+qb9++LR7x13nwwQd15513XvG8nj17tjY8AB0MyR9+bfXq1Ro8eLCCgoIUFRWlIUOGKCCg6aUux48flyQNGTKkwXcJCQl67733Wh3LRx99pIcffljvvPOOKisrPb6rqKho9XUlacqUKerXr59ycnLUq1cvPffccy3uO3ToUA0dOtTU/QF0LiR/+LWxY8e6V/tb6dy5c5o4caLCwsL06KOP6pprrlFwcLAOHDighx56SC6Xy/Q9Vq1apc8//1zPP/+8evbs2eI9CCoqKvTFF19c8byuXbuqV69eJqME0BGQ/IHLxMfHS/pqs5q6JwPqHDp0yP29pCuu7r9cfn6+zp49qz/96U+65ZZb3Mcbe+rAm+teLiAgQL/73e9UUVGhRx55RL169dJ99913xX5LlizRunXrrnjexIkT2QkR8BMkf+Ayo0ePVmRkpNasWaNFixbJ6XRKkt5++2397W9/0/Lly93nduvWTdJXo/oePXo0e93AwEBJkmEY7mMXL17Ub37zmwbnduvWrdXTAF26dNEf//hHTZ06VUuXLlXPnj31z//8z832Yc4fsB+SP3CZLl266Be/+IUWLlyoiRMnKi0tzf2oX//+/XX//fe7zx01apQk6b777tO0adMUGBioH/zgB41ed9y4cerZs6fS09N13333yeFw6JVXXvH4Y+Dy627cuFFZWVkaM2aMunfvrhkzZrT4N1x11VV68803NXHiRC1atEjh4eH6zne+0+T5vpzzr6io0K9//WtJ0l/+8hdJX01H9OjRQz169FBmZqZP7gPAJKsfNwDaQt2jfvv27Wv2vG8+6ldn48aNxsiRIw2n02n06tXLmDdvnvvxwDpffvmlce+99xoRERGGw+G44mN/f/nLX4ybbrrJCAkJMWJjY40HH3zQ2LZtW4P7V1VVGf/0T/9k9OjRw5B0xcf+4uPjjenTpzc4XlZWZlx77bVGcHBwg9/XVoqLi5t8VNCbxxcBtC2HYTQy9AAAAH6L7X0BALAZkj8AADZD8gcAwGZI/gAAtIHs7GyNGTNGoaGhioyM1KxZs3To0CGPcy5cuKCMjAz17t1b3bt313e/+12Vl5c3e13DMLR8+XLFxMQoJCREKSkpOnz4sFexkfwBAGgDBQUFysjI0N69e7V9+3ZdunRJU6dOVXV1tfuc+++/X3/+85/1+uuvq6CgQCdPntQdd9zR7HV/+ctf6vnnn9eaNWv0/vvvq1u3bpo2bVqL3s5Zh9X+AAC0g88++0yRkZEqKCjQLbfcooqKCkVERGj9+vX63ve+J0n6+OOPdd1112nPnj266aabGlzDMAzFxsbqX//1X/XAAw9I+mp/jaioKOXm5ja518g3depNflwul06ePKnQ0NBWb4kKALCOYRg6f/68YmNjm33pllkXLlzQxYsXTV/HMIwG+cbpdLp3A21O3c6dde/I2L9/vy5duuTx9tGEhAT169evyeRfXFyssrIyjz7h4eFKSkrSnj177JH8T548qbi4OKvDAACYVFpaqr59+7bJtS9cuKAB8d1VdrrW9LW6d++uqqoqj2MrVqy44ou0XC6Xli5dqvHjx2vYsGGSpLKyMnXt2rXB9uBRUVEqKytr9Dp1x6OiolrcpzGdOvmHhoZKkiboWwpSF4ujAQB460td0nt6y/3f87Zw8eJFlZ2u1fH9/RUW2vrqQuV5l+JHHVNpaanCwsLcx1sy6s/IyNDBgwdNvRbclzp18q8rvQSpi4IcJH8A6HS+XnXWHlO33UMd6h7a+vu49FXfsLAwj+R/JZmZmdq6dat27drlUd2Ijo7WxYsXG7wcrLy8XNHR0Y1eq+54eXm5YmJiPPqMGDGixTGx2h8AYAu1hst084ZhGMrMzNSmTZv0zjvvaMCAAR7fjxo1Sl26dNHOnTvdxw4dOqSSkhIlJyc3es0BAwYoOjrao09lZaXef//9Jvs0plOP/AEAaCmXDLnU+gfcvO2bkZGh9evXa8uWLQoNDXXPyYeHhyskJETh4eFavHixsrKy1KtXL4WFhenee+9VcnKyx2K/hIQEZWdna/bs2XI4HFq6dKkef/xxDRo0SAMGDNDPf/5zxcbGatasWS2OjeQPAEAbyMnJkSRNmjTJ4/jatWu1YMECSdIzzzyjgIAAffe731VNTY2mTZum3/zmNx7nHzp0yP2kgCQ9+OCDqq6u1g9/+EOdO3dOEyZMUF5enoKDg1scW6d+zr+yslLh4eGapJnM+QNAJ/SlcUn52qKKigqv5tG9UZcrTh7qa3rBX+yQE20aa3th5A8AsIVaw1CtifGumb4dDQv+AACwGUb+AABbaO8Ffx0ZyR8AYAsuGaol+Uui7A8AgO0w8gcA2AJl/3okfwCALbDavx5lfwAAbIaRPwDAFlxfNzP9/QXJHwBgC7UmV/ub6dvRkPwBALZQa3zVzPT3F8z5AwBgM4z8AQC2wJx/PZI/AMAWXHKoVg5T/f0FZX8AAGzG8uT/6aef6s4771Tv3r0VEhKiG264QYWFhVaHBQDwMy7DfPMXlpb9P//8c40fP16TJ0/W22+/rYiICB0+fFg9e/a0MiwAgB+qNVn2N9O3o7E0+f/iF79QXFyc1q5d6z42YMAACyMCAMD/WVr2f+ONNzR69GjNmTNHkZGRGjlypF566SUrQwIA+Km6kb+Z5i8sTf6ffPKJcnJyNGjQIG3btk333HOP7rvvPq1bt67R82tqalRZWenRAABoCZfhMN38haVlf5fLpdGjR+uJJ56QJI0cOVIHDx7UmjVrlJ6e3uD87OxsPfLII+0dJgAAfsXSkX9MTIyGDh3qcey6665TSUlJo+cvW7ZMFRUV7lZaWtoeYQIA/ABl/3qWjvzHjx+vQ4cOeRz7+9//rvj4+EbPdzqdcjqd7REaAMDP1CpAtSbGvLU+jMVqlib/+++/X+PGjdMTTzyh73//+/rggw/04osv6sUXX7QyLACAHzJMztsbfjTnb2nZf8yYMdq0aZP+8Ic/aNiwYXrsscf07LPPat68eVaGBQCAX7N8b/9vf/vb+va3v211GAAAP8cmP/UsT/4AALSHWiNAtYaJOX8/2t7X8r39AQBA+2LkDwCwBZcccpkY87rkP0N/kj8AwBaY869H2R8AAJth5A8AsAXzC/4o+wMA0Kl8Neff+tK9mb4dDWV/AABshpE/AMAWXCb39ven1f6M/AEAtlA352+meWPXrl2aMWOGYmNj5XA4tHnzZo/vHQ5Ho+2pp55q8porV65scH5CQoLX/y4Y+QMAbMGlgHZ9zr+6ulqJiYlatGiR7rjjjgbfnzp1yuPz22+/rcWLF+u73/1us9e9/vrrtWPHDvfnoCDvUznJHwCANpCamqrU1NQmv4+Ojvb4vGXLFk2ePFkDBw5s9rpBQUEN+nqL5A8AsIVaw6FaE6/lretbWVnpcdzpdMrpdJqKrby8XG+++abWrVt3xXMPHz6s2NhYBQcHKzk5WdnZ2erXr59X92POHwBgC7VfL/gz0yQpLi5O4eHh7padnW06tnXr1ik0NLTR6YHLJSUlKTc3V3l5ecrJyVFxcbFuvvlmnT9/3qv7MfIHAMALpaWlCgsLc382O+qXpJdfflnz5s1TcHBws+ddPo0wfPhwJSUlKT4+Xq+99poWL17c4vuR/AEAtuAyAuQyscOf6+sd/sLCwjySv1n/8z//o0OHDmnjxo1e9+3Ro4cGDx6sI0eOeNWPsj8AwBZ8Vfb3td/+9rcaNWqUEhMTve5bVVWlo0ePKiYmxqt+JH8AANpAVVWVioqKVFRUJEkqLi5WUVGRSkpK3OdUVlbq9ddf11133dXoNaZMmaJVq1a5Pz/wwAMqKCjQsWPHtHv3bs2ePVuBgYFKS0vzKjbK/gAAW3BJplb7u7w8v7CwUJMnT3Z/zsrKkiSlp6crNzdXkrRhwwYZhtFk8j569KjOnDnj/nzixAmlpaXp7NmzioiI0IQJE7R3715FRER4FZvDMDrva4oqKysVHh6uSZqpIEcXq8MBAHjpS+OS8rVFFRUVPp1Hv1xdrsg5MEYh3Vs/5v2i6kvdc+O+No21vTDy74A+WT/C6hB8bmDUmSuf1ImM6X3c6hB8LiX0I6tD8LlJId6O1Tq+abEjrA4BfoDkDwCwhdbsz//N/v6C5A8AsAWXHHLJzJx/6/t2NCR/AIAtMPKv5z+/BAAAtAgjfwCALZjdqKetNvmxAskfAGALLsMhl5nn/E307Wj8588YAADQIoz8AQC24DJZ9nf50XiZ5A8AsAXzb/Xzn+TvP78EAAC0CCN/AIAt1MqhWhMb9Zjp29GQ/AEAtkDZv57//BIAANAijPwBALZQK3Ol+1rfhWI5kj8AwBYo+9cj+QMAbIEX+9Tzn18CAABahJE/AMAWDDnkMjHnb/CoHwAAnQtl/3r+80sAAECLMPIHANgCr/StZ+nIf+XKlXI4HB4tISHBypAAAH6q9uu3+plp/sLykf/111+vHTt2uD8HBVkeEgAAfs3yTBsUFKTo6GirwwAA+DnK/vUsr2EcPnxYsbGxGjhwoObNm6eSkpImz62pqVFlZaVHAwCgJVwKMN38haW/JCkpSbm5ucrLy1NOTo6Ki4t188036/z5842en52drfDwcHeLi4tr54gBAOj8LC37p6amuv95+PDhSkpKUnx8vF577TUtXry4wfnLli1TVlaW+3NlZSV/AAAAWqTWcKjWROneTN+OxvI5/8v16NFDgwcP1pEjRxr93ul0yul0tnNUAAB/wJx/vQ41gVFVVaWjR48qJibG6lAAAH7G+Pqtfq1tBjv8+cYDDzyggoICHTt2TLt379bs2bMVGBiotLQ0K8MCAMCvWVr2P3HihNLS0nT27FlFRERowoQJ2rt3ryIiIqwMCwDgh2rlUK2Jl/OY6dvRWJr8N2zYYOXtAQA24jLMzdu7DB8GYzH/mcAAAAAt0qFW+wMA0FbqFu6Z6e8v/OeXAADQDJccpps3du3apRkzZig2NlYOh0ObN2/2+H7BggUNXm53++23X/G6q1evVv/+/RUcHKykpCR98MEHXsUlkfwBAGgT1dXVSkxM1OrVq5s85/bbb9epU6fc7Q9/+EOz19y4caOysrK0YsUKHThwQImJiZo2bZpOnz7tVWyU/QEAttDeO/ylpqZ67GTbGKfT6dXL7Z5++mndfffdWrhwoSRpzZo1evPNN/Xyyy/rpz/9aYuvw8gfAGALZjb4MbteoCn5+fmKjIzUkCFDdM899+js2bNNnnvx4kXt379fKSkp7mMBAQFKSUnRnj17vLovI38AALzwzTfKtnbr+dtvv1133HGHBgwYoKNHj+pnP/uZUlNTtWfPHgUGBjY4/8yZM6qtrVVUVJTH8aioKH388cde3ZvkDwCwBZdM7u3/9YK/b75QbsWKFVq5cqXX1/vBD37g/ucbbrhBw4cP1zXXXKP8/HxNmTKl1XG2BMkfAGALRitW7H+zvySVlpYqLCzMfdxXL5wbOHCg+vTpoyNHjjSa/Pv06aPAwECVl5d7HC8vL/dq3YDEnD8AwCbq3upnpklSWFiYR/NV8j9x4oTOnj3b5MvtunbtqlGjRmnnzp31v8nl0s6dO5WcnOzVvUj+AAC0gaqqKhUVFamoqEiSVFxcrKKiIpWUlKiqqko/+clPtHfvXh07dkw7d+7UzJkzde2112ratGnua0yZMkWrVq1yf87KytJLL72kdevW6W9/+5vuueceVVdXu1f/txRlfwCALbT3Dn+FhYWaPHmy+3NWVpYkKT09XTk5Ofrf//1frVu3TufOnVNsbKymTp2qxx57zKOScPToUZ05c8b9ee7cufrss8+0fPlylZWVacSIEcrLy2uwCPBKSP4AAFu4vHTf2v7emDRpkgyj6bcBbdu27YrXOHbsWINjmZmZyszM9CqWb6LsDwCAzTDyBwDYQmv25/9mf39B8gcA2EJ7l/07Msr+AADYDCN/AIAtMPKvR/IHANgCyb8eZX8AAGyGkX8H5CoPtjoEn/tEfawOAbb0kdUBoANh5F+P5A8AsAVD5h7Xa3q7ns6H5A8AsAVG/vWY8wcAwGYY+QMAbIGRfz2SPwDAFkj+9Sj7AwBgM4z8AQC2wMi/HskfAGALhuGQYSKBm+nb0VD2BwDAZhj5AwBswSWHqU1+zPTtaEj+AABbYM6/HmV/AABshpE/AMAWWPBXj+QPALAFyv71SP4AAFtg5F+POX8AAGyGkT8AwBYMk2V/fxr5k/wBALZgSDIMc/39BWV/AABshpE/AMAWXHLIwQ5/kkj+AACbYLV/vQ5T9n/yySflcDi0dOlSq0MBAMCvdYiR/759+/TCCy9o+PDhVocCAPBTLsMhB5v8SOoAI/+qqirNmzdPL730knr27Gl1OAAAP2UY5pu/sDz5Z2RkaPr06UpJSbniuTU1NaqsrPRoAADAO5aW/Tds2KADBw5o3759LTo/OztbjzzySBtHBQDwRyz4q2fZyL+0tFRLlizRq6++quDg4Bb1WbZsmSoqKtyttLS0jaMEAPiLuuRvpvkLy5L//v37dfr0ad14440KCgpSUFCQCgoK9PzzzysoKEi1tbUN+jidToWFhXk0AABaou6tfmaaN3bt2qUZM2YoNjZWDodDmzdvdn936dIlPfTQQ7rhhhvUrVs3xcbGav78+Tp58mSz11y5cqUcDodHS0hI8PrfhWVl/ylTpujDDz/0OLZw4UIlJCTooYceUmBgoEWRAQBgXnV1tRITE7Vo0SLdcccdHt/94x//0IEDB/Tzn/9ciYmJ+vzzz7VkyRJ95zvfUWFhYbPXvf7667Vjxw7356Ag71O5Zck/NDRUw4YN8zjWrVs39e7du8FxAADMMrti39u+qampSk1NbfS78PBwbd++3ePYqlWrNHbsWJWUlKhfv35NXjcoKEjR0dHeBfMNlq/2BwCgPXyV/M3M+bdtfBUVFXI4HOrRo0ez5x0+fFixsbEaOHCg5s2bp5KSEq/v1SE2+amTn59vdQgAADTrm4+ZO51OOZ1OU9e8cOGCHnroIaWlpTW7ni0pKUm5ubkaMmSITp06pUceeUQ333yzDh48qNDQ0Bbfj5E/AMAWfLXaPy4uTuHh4e6WnZ1tKq5Lly7p+9//vgzDUE5OTrPnpqamas6cORo+fLimTZumt956S+fOndNrr73m1T071MgfAIC2YnzdzPSXvnpU/fLRuZlRf13iP378uN555x2vn2Lr0aOHBg8erCNHjnjVj5E/AABe+OYj561N/nWJ//Dhw9qxY4d69+7t9TWqqqp09OhRxcTEeNWP5A8AsIX23uSnqqpKRUVFKioqkiQVFxerqKhIJSUlunTpkr73ve+psLBQr776qmpra1VWVqaysjJdvHjRfY0pU6Zo1apV7s8PPPCACgoKdOzYMe3evVuzZ89WYGCg0tLSvIqNsj8AwB58VfdvocLCQk2ePNn9OSsrS5KUnp6ulStX6o033pAkjRgxwqPfu+++q0mTJkmSjh49qjNnzri/O3HihNLS0nT27FlFRERowoQJ2rt3ryIiIryKjeQPALAHs1v0etl30qRJMpp5PrC57+ocO3bM4/OGDRu8iqEplP0BALAZRv4AAFto7x3+OjKSPwDAFnilbz3K/gAA2AwjfwCAPRgOrxftNejvJ0j+AABbYM6/HmV/AABshpE/AMAe2nmTn46M5A8AsAVW+9ej7A8AgM0w8gcA2Icfle7NIPkDAGyBsn89kj8AwB5Y8OfGnD8AADbDyL8DCinzv7/JvlCw1SH41CfqY3UIALzm+LqZ6e8fSP4AAHug7O/mf0NMAADQLEb+AAB7YOTvRvIHANgDb/Vzo+wPAIDNMPIHANgCr/StR/IHANgDc/5ulP0BALAZRv4AAHtgwZ8byR8AYAsO46tmpr+/IPkDAOyBOX835vwBALAZRv4AAHtgzt+N5A8AsAfK/m6U/QEAsBlG/gAAe2Dk70byBwDYA8nfjbI/AAA2w8gfAGAPrPZ3I/kDAGyBHf7qUfYHAMBmLE3+OTk5Gj58uMLCwhQWFqbk5GS9/fbbVoYEAPBXhg+aF3bt2qUZM2YoNjZWDodDmzdv9gzHMLR8+XLFxMQoJCREKSkpOnz48BWvu3r1avXv31/BwcFKSkrSBx984F1gsjj59+3bV08++aT279+vwsJC3XrrrZo5c6Y++ugjK8MCAMC06upqJSYmavXq1Y1+/8tf/lLPP/+81qxZo/fff1/dunXTtGnTdOHChSavuXHjRmVlZWnFihU6cOCAEhMTNW3aNJ0+fdqr2CxN/jNmzNC3vvUtDRo0SIMHD9a///u/q3v37tq7d6+VYQEA/JBD9fP+rWpe3i81NVWPP/64Zs+e3eA7wzD07LPP6uGHH9bMmTM1fPhw/e53v9PJkycbVAgu9/TTT+vuu+/WwoULNXToUK1Zs0ZXXXWVXn75Za9ia9GCvzvuuOPKFwoKUnR0tG677TbNmDHDqyAkqba2Vq+//rqqq6uVnJzc6Dk1NTWqqalxf66srPT6PgAAmPHN3ON0OuV0Or26RnFxscrKypSSkuI+Fh4erqSkJO3Zs0c/+MEPGvS5ePGi9u/fr2XLlrmPBQQEKCUlRXv27PHq/i0a+YeHh1+xhYSE6PDhw5o7d66WL1/e4gA+/PBDde/eXU6nUz/+8Y+1adMmDR06tNFzs7OzPe4ZFxfX4vsAAGyu7lE/M01SXFycRy7Kzs72OpSysjJJUlRUlMfxqKgo93ffdObMGdXW1nrVpyktGvmvXbu2xRfcunWr/uVf/kWPPvpoi84fMmSIioqKVFFRoT/+8Y9KT09XQUFBo38ALFu2TFlZWe7PlZWV/AEAAGgZH+3wV1paqrCwMPdhb0f9HYHPn/OfMGGCRo8e3eLzu3btqmuvvVaSNGrUKO3bt0/PPfecXnjhhQbntqa0AgCAL9U9oWZGdHS0JKm8vFwxMTHu4+Xl5RoxYkSjffr06aPAwECVl5d7HC8vL3dfr6V8vuCvR48e+tOf/tTq/i6Xy2NeHwAAn2jnR/2aM2DAAEVHR2vnzp3uY5WVlXr//febXPfWtWtXjRo1yqOPy+XSzp07m+zTFEt3+Fu2bJlSU1PVr18/nT9/XuvXr1d+fr62bdtmZVgAAD/U3jv8VVVV6ciRI+7PxcXFKioqUq9evdSvXz8tXbpUjz/+uAYNGqQBAwbo5z//uWJjYzVr1ix3nylTpmj27NnKzMyUJGVlZSk9PV2jR4/W2LFj9eyzz6q6uloLFy70KjZLk//p06c1f/58nTp1SuHh4Ro+fLi2bdum2267zcqwAAAwrbCwUJMnT3Z/rluzlp6ertzcXD344IOqrq7WD3/4Q507d04TJkxQXl6egoOD3X2OHj2qM2fOuD/PnTtXn332mZYvX66ysjKNGDFCeXl5DRYBXonDMIxOu1txZWWlwsPDNUkzFeToYnU4PvPpQ+OsDsHnvoh2WR2CTwVENb0JR2c1MOrMlU/qZMb0Pm51CD63b0Sg1SH41JfGJeVriyoqKkzPozelLlf0f/zfFXBZYvWW68IFHXv439o01vbCi30AAPbgo9X+/oAX+wAAYDOM/AEAtsArfeuR/AEA9nDZLn2t7u8nSP4AAHtgzt+NOX8AAGyGkT8AwBaY869H8gcA2ANlfzfK/gAA2AwjfwCAPZgs+/vTyJ/kDwCwB8r+bpT9AQCwGUb+AAB7YOTvRvIHANgCj/rVo+wPAIDNkPwBALAZyv4AAHtgzt+N5A8AsAXm/OtR9gcAwGYY+QMA7MOPRu9mkPw7oG4n/fF/nf5VZPpCwVaH4HOfqI/VIaBFTlgdQOfFnL+bf/0XGQAAXBEjfwCALbDgrx7JHwBgD5T93Sj7AwBgM4z8AQC2QNm/HskfAGAPlP3dKPsDAGAzjPwBAPbAyN+N5A8AsAXm/OuR/AEA9sDI3405fwAAbIaRPwDAHhj5u5H8AQC2wJx/Pcr+AADYDMkfAGAPhg+aF/r37y+Hw9GgZWRkNHp+bm5ug3ODg9vm9eGU/QEAttDeZf99+/aptrbW/fngwYO67bbbNGfOnCb7hIWF6dChQ/X3dDi8jrMlSP4AALSBiIgIj89PPvmkrrnmGk2cOLHJPg6HQ9HR0W0dGmV/AIBN+KjsX1lZ6dFqamqueOuLFy/q97//vRYtWtTsaL6qqkrx8fGKi4vTzJkz9dFHH7X21zaL5A8AsAcfJf+4uDiFh4e7W3Z29hVvvXnzZp07d04LFixo8pwhQ4bo5Zdf1pYtW/T73/9eLpdL48aN04kTJ1r5g5tG2R8AAC+UlpYqLCzM/dnpdF6xz29/+1ulpqYqNja2yXOSk5OVnJzs/jxu3Dhdd911euGFF/TYY4+ZC/obLB35Z2dna8yYMQoNDVVkZKRmzZrlsdABAABfcfigSV8tyru8XSn5Hz9+XDt27NBdd93lVbxdunTRyJEjdeTIEa/6tYSlyb+goEAZGRnau3evtm/frkuXLmnq1Kmqrq62MiwAgD9q50f96qxdu1aRkZGaPn26V/1qa2v14YcfKiYmpnU3boalZf+8vDyPz7m5uYqMjNT+/ft1yy23WBQVAMAfWbHDn8vl0tq1a5Wenq6gIM+UO3/+fF199dXuNQOPPvqobrrpJl177bU6d+6cnnrqKR0/ftzrikFLdKg5/4qKCklSr169LI4EAADzduzYoZKSEi1atKjBdyUlJQoIqC/Af/7557r77rtVVlamnj17atSoUdq9e7eGDh3q87g6TPJ3uVxaunSpxo8fr2HDhjV6Tk1NjccjFZWVle0VHgCgs7PgxT5Tp06VYTTeMT8/3+PzM888o2eeeaYVgXmvwzzql5GRoYMHD2rDhg1NnpOdne3xeEVcXFw7RggA6PTaeb6/o+oQyT8zM1Nbt27Vu+++q759+zZ53rJly1RRUeFupaWl7RglAAD+wdKyv2EYuvfee7Vp0ybl5+drwIABzZ7vdDpb9DwlAADfxCt961ma/DMyMrR+/Xpt2bJFoaGhKisrkySFh4crJCTEytAAAP7Ggjn/jsrSsn9OTo4qKio0adIkxcTEuNvGjRutDAsAAL9medkfAID2QNm/Xod51A8AgDZF2d+tQ6z2BwAA7YeRPwDAFij71yP5AwDsgbK/G8kfAGAPJH835vwBALAZRv4AAFtgzr8eyR8AYA+U/d0o+wMAYDOM/AEAtuAwDDlM7Cxrpm9HQ/IHANgDZX83yv4AANgMI38AgC2w2r8eyR8AYA+U/d0o+wMAYDOM/AEAtkDZvx7JHwBgD5T93Uj+AABbYORfjzl/AABshpE/AMAeKPu7kfw7oO6fXrQ6hDbQ1eoAfMz/imZfKNjqEHzuE/WxOgSfG6gTVofQqflT6d4M//svGAAAaBYjfwCAPRjGV81Mfz9B8gcA2AKr/etR9gcAwGYY+QMA7IHV/m4kfwCALThcXzUz/f0FZX8AAGyGkT8AwB4o+7sx8gcA2ELdan8zzRsrV66Uw+HwaAkJCc32ef3115WQkKDg4GDdcMMNeuutt0z84qaR/AEA9lD3nL+Z5qXrr79ep06dcrf33nuvyXN3796ttLQ0LV68WH/96181a9YszZo1SwcPHjTzqxtF8gcAoI0EBQUpOjra3fr0aXrL6eeee0633367fvKTn+i6667TY489phtvvFGrVq3yeVwkfwCALfiq7F9ZWenRampqmrzn4cOHFRsbq4EDB2revHkqKSlp8tw9e/YoJSXF49i0adO0Z88en/z+y5H8AQD2YPigSYqLi1N4eLi7ZWdnN3q7pKQk5ebmKi8vTzk5OSouLtbNN9+s8+fPN3p+WVmZoqKiPI5FRUWprKzM1M9uDKv9AQDwQmlpqcLCwtyfnU5no+elpqa6/3n48OFKSkpSfHy8XnvtNS1evLjN42wOyR8AYAu+2ts/LCzMI/m3VI8ePTR48GAdOXKk0e+jo6NVXl7ucay8vFzR0dFe3+tKKPsDAOzBgtX+l6uqqtLRo0cVExPT6PfJycnauXOnx7Ht27crOTnZ1H0bQ/IHAKANPPDAAyooKNCxY8e0e/duzZ49W4GBgUpLS5MkzZ8/X8uWLXOfv2TJEuXl5elXv/qVPv74Y61cuVKFhYXKzMz0eWyU/QEAttDer/Q9ceKE0tLSdPbsWUVERGjChAnau3evIiIiJEklJSUKCKgfg48bN07r16/Xww8/rJ/97GcaNGiQNm/erGHDhrU+6CaQ/AEA9tDO2/tu2LCh2e/z8/MbHJszZ47mzJnj3Y1agbI/AAA2w8gfAGAL7V3278gsHfnv2rVLM2bMUGxsrBwOhzZv3mxlOAAAf+YyzDc/YWnyr66uVmJiolavXm1lGAAAO/DRDn/+wNKyf2pqqscOSAAAoO0x5w8AsAWHTM75+ywS63Wq5F9TU+Px9qTKykoLowEAdCpmd+kzucNfR9KpHvXLzs72eJNSXFyc1SEBANDpdKrkv2zZMlVUVLhbaWmp1SEBADqJukf9zDR/0anK/k6ns8lXJwIA0Kx23uGvI7M0+VdVVXm82rC4uFhFRUXq1auX+vXrZ2FkAAD4L0uTf2FhoSZPnuz+nJWVJUlKT09Xbm6uRVEBAPyRwzDkMLFoz0zfjsbS5D9p0iQZfvQvEwDQgbm+bmb6+4lOteAPAACY16kW/AEA0FqU/euR/AEA9sBqfzeSPwDAHtjhz405fwAAbIaRPwDAFszu0scOfwAAdDaU/d0o+wMAYDOM/AEAtuBwfdXM9PcXJH8AgD1Q9nej7A8AgM0w8gcA2AOb/LiR/AEAtsD2vvUo+wMAYDOM/AEA9sCCPzeSPwDAHgxJZh7X85/cT/IHANgDc/71mPMHAMBmGPkDAOzBkMk5f59FYjmSPwDAHljw50by74CC3tlvdQg+18PqAHysh9UBAIAJJH8AgD24JDlM9vcTLPgDANhC3Wp/M80b2dnZGjNmjEJDQxUZGalZs2bp0KFDzfbJzc2Vw+HwaMHBwWZ+dqNI/gAAtIGCggJlZGRo79692r59uy5duqSpU6equrq62X5hYWE6deqUux0/ftznsVH2BwDYQzsv+MvLy/P4nJubq8jISO3fv1+33HJLk/0cDoeio6NbFWJLMfIHANhDXfI300yoqKiQJPXq1avZ86qqqhQfH6+4uDjNnDlTH330kan7NobkDwCAFyorKz1aTU3NFfu4XC4tXbpU48eP17Bhw5o8b8iQIXr55Ze1ZcsW/f73v5fL5dK4ceN04sQJX/4Ekj8AwCZ8NPKPi4tTeHi4u2VnZ1/x1hkZGTp48KA2bNjQ7HnJycmaP3++RowYoYkTJ+pPf/qTIiIi9MILL/jkX0Ed5vwBAPbgo0f9SktLFRYW5j7sdDqb7ZaZmamtW7dq165d6tu3r1e37NKli0aOHKkjR454HW5zSP4AAFvw1Yt9wsLCPJJ/UwzD0L333qtNmzYpPz9fAwYM8PqetbW1+vDDD/Wtb33L677NIfkDANAGMjIytH79em3ZskWhoaEqKyuTJIWHhyskJESSNH/+fF199dXuqYNHH31UN910k6699lqdO3dOTz31lI4fP6677rrLp7GR/AEA9tDOj/rl5ORIkiZNmuRxfO3atVqwYIEkqaSkRAEB9cvvPv/8c919990qKytTz549NWrUKO3evVtDhw5tfdyNIPkDAOzBZUgOE8nf5V1fowV/LOTn53t8fuaZZ/TMM894dZ/WYLU/AAA2w8gfAGAPvNLXjeQPALAJs7v0+U/yp+wPAIDNMPIHANgDZX83kj8AwB5chkyV7r1c7d+RUfYHAMBmGPkDAOzBcH3VzPT3EyR/AIA9MOfv1iHK/qtXr1b//v0VHByspKQkffDBB1aHBADwNy7DfPMTlif/jRs3KisrSytWrNCBAweUmJioadOm6fTp01aHBgCAX7I8+T/99NO6++67tXDhQg0dOlRr1qzRVVddpZdfftnq0AAA/qSu7G+m+QlLk//Fixe1f/9+paSkuI8FBAQoJSVFe/bsaXB+TU2NKisrPRoAAC1iyGTyt/oH+I6lyf/MmTOqra1VVFSUx/GoqCj3e48vl52drfDwcHeLi4trr1ABAPAblpf9vbFs2TJVVFS4W2lpqdUhAQA6C8r+bpY+6tenTx8FBgaqvLzc43h5ebmio6MbnO90OuV0OtsrPACAP3G5JJl4Vt/lP8/5Wzry79q1q0aNGqWdO3e6j7lcLu3cuVPJyckWRgYAgP+yfJOfrKwspaena/To0Ro7dqyeffZZVVdXa+HChVaHBgDwJ2zy42Z58p87d64+++wzLV++XGVlZRoxYoTy8vIaLAIEAMAUkr+b5clfkjIzM5WZmWl1GAAA2EKHSP4AALQ5XunrRvIHANiCYbhkmHgzn5m+HQ3JHwBgD4bJl/P40Zx/p9rkBwAAmMfIHwBgD4bJOX8/GvmT/AEA9uBySQ4T8/Z+NOdP2R8AAJth5A8AsAfK/m4kfwCALRgulwwTZX9/etSPsj8AADbDyB8AYA+U/d1I/gAAe3AZkoPkL1H2BwDAdhj5AwDswTAkmXnO339G/iR/AIAtGC5Dhomyv+FHyZ+yPwDAHgyX+dYKq1evVv/+/RUcHKykpCR98MEHzZ7/+uuvKyEhQcHBwbrhhhv01ltvteq+zSH5AwDQRjZu3KisrCytWLFCBw4cUGJioqZNm6bTp083ev7u3buVlpamxYsX669//atmzZqlWbNm6eDBgz6Ny2F04jpGZWWlwsPDNUkzFeToYnU4AAAvfWlcUr62qKKiQmFhYW1yD3eucMw2lSu+NC4p39jkVaxJSUkaM2aMVq1aJUlyuVyKi4vTvffeq5/+9KcNzp87d66qq6u1detW97GbbrpJI0aM0Jo1a1od+zcx8gcA2EM7l/0vXryo/fv3KyUlxX0sICBAKSkp2rNnT6N99uzZ43G+JE2bNq3J81urUy/4qytafKlLpvZtAABY40tdktQ+i+nM5oq6WCsrKz2OO51OOZ3OBuefOXNGtbW1ioqK8jgeFRWljz/+uNF7lJWVNXp+WVlZ6wNvRKdO/ufPn5ckvSffL4YAALSf8+fPKzw8vE2u3bVrV0VHR+u9MvO5onv37oqLi/M4tmLFCq1cudL0tdtTp07+sbGxKi0tVWhoqBwOR5veq7KyUnFxcSotLW2zean25G+/R+I3dRb8po6vPX+PYRg6f/68YmNj2+wewcHBKi4u1sWLF01fyzCMBvmmsVG/JPXp00eBgYEqLy/3OF5eXq7o6OhG+0RHR3t1fmt16uQfEBCgvn37tus9w8LC/OL/3HX87fdI/KbOgt/U8bXX72mrEf/lgoODFRwc3Ob3uVzXrl01atQo7dy5U7NmzZL01YK/nTt3KjMzs9E+ycnJ2rlzp5YuXeo+tn37diUnJ/s0tk6d/AEA6MiysrKUnp6u0aNHa+zYsXr22WdVXV2thQsXSpLmz5+vq6++WtnZ2ZKkJUuWaOLEifrVr36l6dOna8OGDSosLNSLL77o07hI/gAAtJG5c+fqs88+0/Lly1VWVqYRI0YoLy/PvaivpKREAQH1D96NGzdO69ev18MPP6yf/exnGjRokDZv3qxhw4b5NC6Sfws5nU6tWLGiybmdzsbffo/Eb+os+E0dn7/9HqtlZmY2WebPz89vcGzOnDmaM2dOm8bUqTf5AQAA3mOTHwAAbIbkDwCAzZD8AQCwGZI/AAA2Q/JvAW/fxdyR7dq1SzNmzFBsbKwcDoc2b95sdUimZWdna8yYMQoNDVVkZKRmzZqlQ4cOWR2WKTk5ORo+fLh7k5Xk5GS9/fbbVoflM08++aQcDofHRiadzcqVK+VwODxaQkKC1WGZ9umnn+rOO+9U7969FRISohtuuEGFhYVWhwUfI/lfgbfvYu7oqqurlZiYqNWrV1sdis8UFBQoIyNDe/fu1fbt23Xp0iVNnTpV1dXVVofWan379tWTTz6p/fv3q7CwULfeeqtmzpypjz76yOrQTNu3b59eeOEFDR8+3OpQTLv++ut16tQpd3vvvfesDsmUzz//XOPHj1eXLl309ttv6//+7//0q1/9Sj179rQ6NPiagWaNHTvWyMjIcH+ura01YmNjjezsbAuj8g1JxqZNm6wOw+dOnz5tSDIKCgqsDsWnevbsafznf/6n1WGYcv78eWPQoEHG9u3bjYkTJxpLliyxOqRWW7FihZGYmGh1GD710EMPGRMmTLA6DLQDRv7NaM27mGG9iooKSVKvXr0sjsQ3amtrtWHDBlVXV/t8f+/2lpGRoenTpzd4X3lndfjwYcXGxmrgwIGaN2+eSkpKrA7JlDfeeEOjR4/WnDlzFBkZqZEjR+qll16yOiy0AZJ/M5p7F7Ov360M33C5XFq6dKnGjx/v8+0w29uHH36o7t27y+l06sc//rE2bdqkoUOHWh1Wq23YsEEHDhxw72He2SUlJSk3N1d5eXnKyclRcXGxbr75ZverxjujTz75RDk5ORo0aJC2bdume+65R/fdd5/WrVtndWjwMbb3hV/JyMjQwYMHO/3cqyQNGTJERUVFqqio0B//+Eelp6eroKCgU/4BUFpaqiVLlmj79u3t/ma1tpKamur+5+HDhyspKUnx8fF67bXXtHjxYgsjaz2Xy6XRo0friSeekCSNHDlSBw8e1Jo1a5Senm5xdPAlRv7NaM27mGGdzMxMbd26Ve+++267v+q5LXTt2lXXXnutRo0apezsbCUmJuq5556zOqxW2b9/v06fPq0bb7xRQUFBCgoKUkFBgZ5//nkFBQWptrbW6hBN69GjhwYPHqwjR45YHUqrxcTENPjj8rrrruv00xloiOTfjMvfxVyn7l3MnX3u1Z8YhqHMzExt2rRJ77zzjgYMGGB1SG3C5XKppqbG6jBaZcqUKfrwww9VVFTkbqNHj9a8efNUVFSkwMBAq0M0raqqSkePHlVMTIzVobTa+PHjGzwm+/e//13x8fEWRYS2Qtn/Cq70LubOpqqqymNkUlxcrKKiIvXq1Uv9+vWzMLLWy8jI0Pr167VlyxaFhoa612OEh4crJCTE4uhaZ9myZUpNTVW/fv10/vx5rV+/Xvn5+dq2bZvVobVKaGhogzUY3bp1U+/evTvt2owHHnhAM2bMUHx8vE6ePKkVK1YoMDBQaWlpVofWavfff7/GjRunJ554Qt///vf1wQcf6MUXX/T5u+TRAVj9uEFn8Otf/9ro16+f0bVrV2Ps2LHG3r17rQ6p1d59911DUoOWnp5udWit1tjvkWSsXbvW6tBabdGiRUZ8fLzRtWtXIyIiwpgyZYrx3//931aH5VOd/VG/uXPnGjExMUbXrl2Nq6++2pg7d65x5MgRq8My7c9//rMxbNgww+l0GgkJCcaLL75odUhoA7zSFwAAm2HOHwAAmyH5AwBgMyR/AABshuQPAIDNkPwBALAZkj8AADZD8gcAwGZI/gAA2AzJH+jAFixYoFmzZlkdBgA/Q/IHAMBmSP4AANgMyR8AAJsh+QMAYDMkfwAAbIbkDwCAzZD8AQCwGZI/AAA2Q/IHAMBmHIZhGFYHAQAA2g8jfwAAbIbkDwCAzZD8AQCwGZI/AAA2Q/IHAMBmSP4AANgMyR8AAJsh+QMAYDMkfwAAbIbkDwCAzZD8AQCwGZI/AAA28/8BdMJM42GGXEkAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_out at K = 2 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\n", - "Min and max values: 22.0 0.0\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf8AAAHHCAYAAACx2FF+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA3k0lEQVR4nO3de3wV9Z3/8fdJICcISbjlKiGAIohIoAFiACVIJORHKaCllIUlXNSum1QxtVq6llutse3W20KDWiXWygZ1uVhEKCIJtYAaaHbBVQoIJBQSxJWEpCVgzvz+sEw45npyTjLJmdfz8fg+Hp058535jLv6yef7/c6MwzAMQwAAwDYCrA4AAAC0LZI/AAA2Q/IHAMBmSP4AANgMyR8AAJsh+QMAYDMkfwAAbIbkDwCAzZD8AQCwGZI/bC0/P18Oh0P5+flWhwIAbYbkD7+Um5srh8NhtuDgYN1www3KzMxUWVmZT66xdetWLV++3Cfnutq6dev09NNPN/v4fv366Zvf/Gad/a+88ooCAwM1efJkXbx40YcRNmzDhg2aNWuWBgwYoGuuuUaDBg3SD37wA50/f75Nrg+geUj+8GsrV67UK6+8olWrVmnMmDHKyclRUlKS/va3v3l97q1bt2rFihU+iNKdp8m/Pq+++qrmz5+vlJQUbdq0ScHBwb4Jrgn33nuvPv74Y82dO1fPPvusJk+erFWrVikpKUl///vf2yQGAE3rZHUAQGtKS0vTyJEjJUl33323evXqpSeffFKbN2/W7NmzLY6udeTl5Sk9PV233367Nm/e3GaJX5LeeOMNJScnu+1LSEhQenq6Xn31Vd19991tFguAhlH5w1Zuv/12SdLx48cbPe71119XQkKCunTpot69e2vu3Ln661//av4+f/58rV69WpLcphcas3nzZk2ZMkUxMTFyOp267rrr9NOf/lQ1NTXmMcnJyXrrrbd08uRJ85z9+vVr9v299tprmjt3rpKTk/Xmm2+2aeKXVCfxS9KMGTMkSR9//HGbxgKgYVT+sJVjx45Jknr16tXgMbm5uVqwYIFGjRql7OxslZWV6ZlnntGf/vQn/fnPf1b37t31ve99T6dPn9aOHTv0yiuvNOvaubm56tatm7KystStWze9++67Wrp0qSoqKvTLX/5SkvRv//ZvKi8v16lTp/TUU09Jkrp169as8//Xf/2X5syZo9tuu02///3v1aVLl2b1q6ysbNaagM6dOyssLKxZ57xaaWmpJKl3794e9wXQSgzAD61du9aQZLzzzjvGZ599ZpSUlBh5eXlGr169jC5duhinTp0yDMMwdu3aZUgydu3aZRiGYVy6dMmIiIgwhg4davz97383z7dlyxZDkrF06VJzX0ZGhuHJv0J/+9vf6uz73ve+Z1xzzTXGxYsXzX1Tpkwx4uLimn3euLg4IyYmxujUqZORnJxsVFVVNbuvYRhGenq6IanJNn78eI/Oe8WiRYuMwMBA4y9/+UuL+gPwPSp/+LWUlBS37bi4OL366qu69tpr6z2+sLBQZ8+e1fLly92GzKdMmaLBgwfrrbfeavEiv6sr8QsXLqi6ulq33nqrnnvuOX3yySeKj49v0Xkl6f/+7//05Zdfqk+fPs2u+K94+OGHNXfu3CaP69Gjh8dxrVu3Ti+++KIefvhhDRw40OP+AFoHyR9+bfXq1brhhhvUqVMnRUZGatCgQQoIaHipy8mTJyVJgwYNqvPb4MGD9d5777U4lo8++kiPPvqo3n33XVVUVLj9Vl5e3uLzStLEiRPVt29f5eTkqGfPnnrmmWea3XfIkCEaMmSIV9evzx//+EctWrRIqamp+tnPfubz8wNoOZI//Nro0aPN1f5WOn/+vMaPH6/Q0FCtXLlS1113nYKDg3XgwAE98sgjcrlcXl9j1apV+uKLL/Tss8+qR48ezX4HQXl5ebMewwsKClLPnj2bdc7//u//1re+9S0NHTpUb7zxhjp14j81QHvCv5HAVeLi4iRJhw8fNp8MuOLw4cPm75KaXN1/tfz8fH3++efasGGDbrvtNnN/fU8deHLeqwUEBOi3v/2tysvLtWLFCvXs2VP3339/k/0eeOABvfzyy00eN378+Ga9CfHYsWOaPHmyIiIitHXr1mYvWATQdkj+wFVGjhypiIgIrVmzRgsXLpTT6ZQkvf322/r444+1dOlS89iuXbtK+qqq7969e6PnDQwMlCQZhmHuu3Tpkn7961/XObZr164tngbo3Lmz3njjDU2aNEmLFy9Wjx499M///M+N9vHlnH9paakmTZqkgIAAbd++XeHh4c2OHUDbIfkDV+ncubN+/vOfa8GCBRo/frxmz55tPurXr18/Pfjgg+axCQkJkqT7779fqampCgwM1He/+916zztmzBj16NFD6enpuv/+++VwOPTKK6+4/TFw9XnXr1+vrKwsjRo1St26ddPUqVObfQ/XXHON3nrrLY0fP14LFy5UWFiYvvWtbzV4vC/n/CdPnqxPP/1UDz/8sN577z23NRKRkZG64447fHIdAF6y+nEDoDVcedTvww8/bPS4rz/qd8X69euNESNGGE6n0+jZs6cxZ84c8/HAK7788kvj+9//vhEeHm44HI4mH/v705/+ZNxyyy1Gly5djJiYGOPhhx82tm/fXuf6lZWVxj/90z8Z3bt3NyQ1+dhfXFycMWXKlDr7S0tLjeuvv94IDg6uc3+tRa3wqCAA33MYRj2lBwAA8Fu83hcAAJsh+QMAYDMkfwAAbIbkDwCAzZD8AQCwGZI/AAA206Ff8uNyuXT69GmFhIS0+JWoAADrGIahCxcuKCYmptGPbnnr4sWLunTpktfnCQoKcvviZ0fVoZP/6dOnFRsba3UYAAAvlZSUqE+fPq1y7osXL6p/XDeVnq3x+lxRUVE6fvx4h/8DoEMn/5CQEEnSOP0/dVJni6MBAHjqS13We9pq/ve8NVy6dEmlZ2t0cn8/hYa0fHSh4oJLcQkndOnSJZK/la4M9XdSZ3VykPwBoMP5xztm22LqtluIQ91CWn4dl/xnerlDJ38AAJqrxnCpxosX2tcYLt8FYzGSPwDAFlwy5FLLs783fdsbHvUDAMBmqPwBALbgkkveDNx717t9IfkDAGyhxjBU48VX7L3p294w7A8AgM1Q+QMAbIEFf7VI/gAAW3DJUA3JXxLD/gAA2A6VPwDAFhj2r0XyBwDYAqv9azHsDwCAzVD5AwBswfWP5k1/f0HyBwDYQo2Xq/296dvekPwBALZQY8jLr/r5LharMecPAIDNUPkDAGyBOf9aJH8AgC245FCNHF719xcM+wMAYDOWJ/+//vWvmjt3rnr16qUuXbro5ptvVmFhodVhAQD8jMvwvvkLS4f9v/jiC40dO1YTJkzQ22+/rfDwcB05ckQ9evSwMiwAgB+q8XLY35u+7Y2lyf/nP/+5YmNjtXbtWnNf//79LYwIAAD/Z+mw/5tvvqmRI0dq5syZioiI0IgRI/TCCy9YGRIAwE9dqfy9af7C0uT/6aefKicnRwMHDtT27dt133336f7779fLL79c7/HV1dWqqKhwawAANIfLcHjd/IWlw/4ul0sjR47U448/LkkaMWKEDh06pDVr1ig9Pb3O8dnZ2VqxYkVbhwkAgF+xtPKPjo7WkCFD3PbdeOONKi4urvf4JUuWqLy83GwlJSVtESYAwA8w7F/L0uQ/duxYHT582G3fX/7yF8XFxdV7vNPpVGhoqFsDAKA5ahTgdfNEdna2Ro0apZCQEEVERGj69Ol1ct7FixeVkZGhXr16qVu3brrrrrtUVlbW6HkNw9DSpUsVHR2tLl26KCUlRUeOHPEoNkuT/4MPPqh9+/bp8ccf19GjR7Vu3To9//zzysjIsDIsAIAfMryc7zc8nPMvKChQRkaG9u3bpx07dujy5cuaNGmSqqqqzGMefPBB/f73v9frr7+ugoICnT59WnfeeWej5/3FL36hZ599VmvWrNH777+vrl27KjU1VRcvXmx2bA7DMCx9bcGWLVu0ZMkSHTlyRP3791dWVpbuueeeZvWtqKhQWFiYkjVNnRydWzlSAICvfWlcVr42q7y8vNVGc6/kip0H+6prSMtr3qoLLk28ubjFsX722WeKiIhQQUGBbrvtNpWXlys8PFzr1q3Tt7/9bUnSJ598ohtvvFF79+7VLbfcUucchmEoJiZGP/jBD/TQQw9JksrLyxUZGanc3Fx997vfbVYslr/h75vf/KYOHjyoixcv6uOPP2524gcAwBNWz/mXl5dLknr27ClJ2r9/vy5fvqyUlBTzmMGDB6tv377au3dvvec4fvy4SktL3fqEhYUpMTGxwT714cM+AABbqDECVGO0vOat+cc4+dcfM3c6nXI6nY32dblcWrx4scaOHauhQ4dKkkpLSxUUFKTu3bu7HRsZGanS0tJ6z3Nlf2RkZLP71Mfyyh8AgI4kNjZWYWFhZsvOzm6yT0ZGhg4dOqS8vLw2iLBpVP4AAFtwySGXFzWvS1+V/iUlJW5z/k1V/ZmZmdqyZYt2796tPn36mPujoqJ06dIlnT9/3q36LysrU1RUVL3nurK/rKxM0dHRbn2GDx/e7Huh8gcA2IKv5vy//sh5Q8nfMAxlZmZq48aNevfdd+t8uyYhIUGdO3fWzp07zX2HDx9WcXGxkpKS6j1n//79FRUV5danoqJC77//foN96kPyBwCgFWRkZOh3v/ud1q1bp5CQEJWWlqq0tFR///vfJX21UG/RokXKysrSrl27tH//fi1YsEBJSUluK/0HDx6sjRs3SpIcDocWL16sxx57TG+++aYOHjyoefPmKSYmRtOnT292bAz7AwBswfsFf549GZ+TkyNJSk5Odtu/du1azZ8/X5L01FNPKSAgQHfddZeqq6uVmpqqX//6127HHz582HxSQJIefvhhVVVV6d5779X58+c1btw4bdu2TcHBwc2OzfLn/L3Bc/4A0LG15XP+//XfN6hrSGCLz1N1oUZ3xf+lVWNtKwz7AwBgMwz7AwBswdWC9/O79++wA+V1kPwBALbQ1nP+7RnJHwBgCy4F+OQ5f3/AnD8AADZD5Q8AsIUaw6EaDz/L+/X+/oLkDwCwhRovF/zVMOwPAAA6Kip/AIAtuIwAubxY7e9itT8AAB0Lw/61GPYHAMBmqPwBALbgkncr9l2+C8VyJH8AgC14/5If/xksJ/m3Q6c3DrE6BJ8b1Pus1SH41KjuJ60OwefGdT1sdQg+NzbYf/5jfUVqzHCrQ4AfIPkDAGzB+3f7+88fkyR/AIAtuOSQS97M+fOGPwAAOhQq/1r+cycAAKBZqPwBALbg/Ut+/KdeJvkDAGzBZTjk8uY5fz/6qp///BkDAACahcofAGALLi+H/XnJDwAAHYz3X/Xzn+TvP3cCAACahcofAGALNXKoxosX9XjTt70h+QMAbIFh/1r+cycAAKBZqPwBALZQI++G7mt8F4rlSP4AAFtg2L8WyR8AYAt82KeW/9wJAABoFpI/AMAWDDnk8qIZHq4X2L17t6ZOnaqYmBg5HA5t2rTJ7XeHw1Fv++Uvf9ngOZcvX17n+MGDB3v8z4JhfwCALbT1sH9VVZXi4+O1cOFC3XnnnXV+P3PmjNv222+/rUWLFumuu+5q9Lw33XST3nnnHXO7UyfPUznJHwCAVpCWlqa0tLQGf4+KinLb3rx5syZMmKABAwY0et5OnTrV6esphv0BALZw5ZO+3rTWUlZWprfeekuLFi1q8tgjR44oJiZGAwYM0Jw5c1RcXOzx9SxN/r6auwAAoCk1//iqnzdNkioqKtxadXW117G9/PLLCgkJqXd64GqJiYnKzc3Vtm3blJOTo+PHj+vWW2/VhQsXPLqe5cP+vpi7AACgrcTGxrptL1u2TMuXL/fqnC+99JLmzJmj4ODgRo+7ehph2LBhSkxMVFxcnF577bVmjRpcYXmm9cXcBQAATfF26P5K35KSEoWGhpr7nU6nV3H98Y9/1OHDh7V+/XqP+3bv3l033HCDjh496lE/y+f8PZm7qK6urjPcAgBAc7gU4HWTpNDQULfmbfJ/8cUXlZCQoPj4eI/7VlZW6tixY4qOjvaon6XJ39O5i+zsbIWFhZnt60MvAAC0F5WVlSoqKlJRUZEk6fjx4yoqKnIrcisqKvT666/r7rvvrvccEydO1KpVq8zthx56SAUFBTpx4oT27NmjGTNmKDAwULNnz/YoNkuH/T2du1iyZImysrLM7YqKCv4AAAA0S43hUI0Xw/6e9i0sLNSECRPM7Sv5Kz09Xbm5uZKkvLw8GYbRYPI+duyYzp07Z26fOnVKs2fP1ueff67w8HCNGzdO+/btU3h4uEexWT7nf7Wm5i6cTqfXwysAAHvy1Zx/cyUnJ8swjEaPuffee3Xvvfc2+PuJEyfctvPy8jyKoSGWz/lfraVzFwAANMX4x1f9WtoMPuzjG76auwAAAM1n6bC/r+YuAABoSo0cqvHw4zxf7+8vLE3+vpq7AACgKS7D83n7r/f3F/4zgQEAAJqlXa32BwCgtVxZuOdNf39B8gcA2IJLDrm8mLf3pm974z9/xgAAgGah8gcA2EJbv+GvPSP5AwBsgTn/Wv5zJwAAoFmo/AEAtuCSl+/296MFfyR/AIAtGF6u9jdI/gAAdCxt/VW/9ow5fwAAbIbKHwBgC6z2r0XyBwDYAsP+tfznzxgAANAsVP4AAFvg3f61SP4AAFtg2L8Ww/4AANgMlT8AwBao/GuR/AEAtkDyr8WwPwAANkPl3w5Vnu1qdQg+d1gRVocAWzpsdQBoR6j8a5H8AQC2YMi7x/UM34ViOZI/AMAWqPxrMecPAIDNUPkDAGyByr8WyR8AYAsk/1oM+wMAYDMkfwCALVyp/L1pnti9e7emTp2qmJgYORwObdq0ye33+fPny+FwuLXJkyc3ed7Vq1erX79+Cg4OVmJioj744AOP4pJI/gAAmzAMh9fNE1VVVYqPj9fq1asbPGby5Mk6c+aM2f7zP/+z0XOuX79eWVlZWrZsmQ4cOKD4+Hilpqbq7NmzHsXGnD8AAK0gLS1NaWlpjR7jdDoVFRXV7HM++eSTuueee7RgwQJJ0po1a/TWW2/ppZde0o9+9KNmn4fKHwBgCy45vG6+lp+fr4iICA0aNEj33XefPv/88waPvXTpkvbv36+UlBRzX0BAgFJSUrR3716PrkvlDwCwBV+t9q+oqHDb73Q65XQ6PT7f5MmTdeedd6p///46duyYfvzjHystLU179+5VYGBgnePPnTunmpoaRUZGuu2PjIzUJ5984tG1Sf4AAHggNjbWbXvZsmVavny5x+f57ne/a/7vm2++WcOGDdN1112n/Px8TZw40dswG0XyBwDYQksW7X29vySVlJQoNDTU3N+Sqr8+AwYMUO/evXX06NF6k3/v3r0VGBiosrIyt/1lZWUerRuQmPMHANiErx71Cw0NdWu+Sv6nTp3S559/rujo6Hp/DwoKUkJCgnbu3Fl7Ty6Xdu7cqaSkJI+uRfIHANhCWz/qV1lZqaKiIhUVFUmSjh8/rqKiIhUXF6uyslI//OEPtW/fPp04cUI7d+7UtGnTdP311ys1NdU8x8SJE7Vq1SpzOysrSy+88IJefvllffzxx7rvvvtUVVVlrv5vLob9AQBoBYWFhZowYYK5nZWVJUlKT09XTk6O/ud//kcvv/yyzp8/r5iYGE2aNEk//elP3UYSjh07pnPnzpnbs2bN0meffaalS5eqtLRUw4cP17Zt2+osAmwKyR8AYAuGl6v9Pa38k5OTZRhGg79v3769yXOcOHGizr7MzExlZmZ6FMvXkfwBALZgSGokFzerv79gzh8AAJuh8gcA2IJLDjm8eEtfa7zhzyokfwCALfjqOX9/0G6G/Z944gk5HA4tXrzY6lAAAPBr7aLy//DDD/Xcc89p2LBhVocCAPBTLsMhhw/e7e8PLK/8KysrNWfOHL3wwgvq0aOH1eEAAPyUYXjf/IXlyT8jI0NTpkxx+0RhQ6qrq1VRUeHWAACAZywd9s/Ly9OBAwf04YcfNuv47OxsrVixopWjAgD4Ixb81bKs8i8pKdEDDzygV199VcHBwc3qs2TJEpWXl5utpKSklaMEAPiLtn63f3tmWeW/f/9+nT17Vt/4xjfMfTU1Ndq9e7dWrVql6upqBQYGuvVxOp0++3oSAMBeWPBXy7LkP3HiRB08eNBt34IFCzR48GA98sgjdRI/AADwDcuSf0hIiIYOHeq2r2vXrurVq1ed/QAAeMvbFfv+tNq/XTznDwBAa/sq+Xuz4M+HwVisXSX//Px8q0MAAMDvtavkDwBAa+FRv1okfwCALRj/aN709xeWv+EPAAC0LSp/AIAtMOxfi+QPALAHxv1NJH8AgD14+4peP6r8mfMHAMBmqPwBALbAG/5qkfwBALbAgr9aDPsDAGAzVP4AAHswHN4t2vOjyp/kDwCwBeb8azHsDwCAzVD5AwDsgZf8mEj+AABbYLV/LYb9AQCwGZI/AMA+DC+ah3bv3q2pU6cqJiZGDodDmzZtMn+7fPmyHnnkEd18883q2rWrYmJiNG/ePJ0+fbrRcy5fvlwOh8OtDR482OPYSP4AAFu4MuzvTfNEVVWV4uPjtXr16jq//e1vf9OBAwf0k5/8RAcOHNCGDRt0+PBhfetb32ryvDfddJPOnDljtvfee8+juCTm/AEAdtHGC/7S0tKUlpZW729hYWHasWOH275Vq1Zp9OjRKi4uVt++fRs8b6dOnRQVFeVZMF9D5Q8AQDtQXl4uh8Oh7t27N3rckSNHFBMTowEDBmjOnDkqLi72+FpU/u1Q0Gf+93+WSnW1OgSfOqwIq0MA4DHHP5o3/aWKigq3vU6nU06n04vzShcvXtQjjzyi2bNnKzQ0tMHjEhMTlZubq0GDBunMmTNasWKFbr31Vh06dEghISHNvh6VPwDAHrxZ7HfVlEFsbKzCwsLMlp2d7VVYly9f1ne+8x0ZhqGcnJxGj01LS9PMmTM1bNgwpaamauvWrTp//rxee+01j67pfyUmAACtqKSkxK0696bqv5L4T548qXfffbfRqr8+3bt31w033KCjR4961I/KHwBgDz6q/ENDQ91aS5P/lcR/5MgRvfPOO+rVq5fH56isrNSxY8cUHR3tUT+SPwDAHq581c+b5oHKykoVFRWpqKhIknT8+HEVFRWpuLhYly9f1re//W0VFhbq1VdfVU1NjUpLS1VaWqpLly6Z55g4caJWrVplbj/00EMqKCjQiRMntGfPHs2YMUOBgYGaPXu2R7Ex7A8AQCsoLCzUhAkTzO2srCxJUnp6upYvX64333xTkjR8+HC3frt27VJycrIk6dixYzp37pz526lTpzR79mx9/vnnCg8P17hx47Rv3z6Fh4d7FBvJHwBgC239Sd/k5GQZjXRq7LcrTpw44badl5fnWRANIPkDAOyBr/qZmPMHAMBmqPwBAPbQgkV7dfr7CZI/AMAWHMZXzZv+/oLkDwCwB+b8Tcz5AwBgM1T+AAB7YM7fRPIHANgDw/4mhv0BALAZKn8AgD1Q+ZtI/gAAeyD5mxj2BwDAZqj8AQD2wGp/E8kfAGALvOGvFsP+AADYjKXJPycnR8OGDVNoaKhCQ0OVlJSkt99+28qQAAD+yvBB8xOWJv8+ffroiSee0P79+1VYWKjbb79d06ZN00cffWRlWAAA+DVL5/ynTp3qtv2zn/1MOTk52rdvn2666SaLogIA+COHvJzz91kk1mtW8r/zzjubPlGnToqKitIdd9xRJ6k3R01NjV5//XVVVVUpKSmp3mOqq6tVXV1tbldUVHh8HQAA7K5ZyT8sLKzJY1wul44cOaLf/OY3euihh7Ry5cpmBXDw4EElJSXp4sWL6tatmzZu3KghQ4bUe2x2drZWrFjRrPMCAOCGR/1MzUr+a9eubfYJt2zZon/9139tdvIfNGiQioqKVF5erjfeeEPp6ekqKCio9w+AJUuWKCsry9yuqKhQbGxss2MDANgYb/gz+XzOf9y4cRo5cmSzjw8KCtL1118vSUpISNCHH36oZ555Rs8991ydY51Op5xOp89iBQDAjnye/Lt3764NGza0uL/L5XKb1wcAwCeo/E2WrvZfsmSJ0tLS1LdvX124cEHr1q1Tfn6+tm/fbmVYAAA/xBv+alma/M+ePat58+bpzJkzCgsL07Bhw7R9+3bdcccdVoYFAIBfszT5v/jii1ZeHgBgJwz7m/iwDwDAHkj+Jj7sAwCAzVD5AwBsgQV/tUj+AAB74A1/JpI/AMAemPM3MecPAEAr2L17t6ZOnaqYmBg5HA5t2rTJ7XfDMLR06VJFR0erS5cuSklJ0ZEjR5o87+rVq9WvXz8FBwcrMTFRH3zwgcexkfwBALZwZc7fm+aJqqoqxcfHa/Xq1fX+/otf/ELPPvus1qxZo/fff19du3ZVamqqLl682OA5169fr6ysLC1btkwHDhxQfHy8UlNTdfbsWY9iI/kDAOzB8EHzQFpamh577DHNmDGjbiiGoaefflqPPvqopk2bpmHDhum3v/2tTp8+XWeE4GpPPvmk7rnnHi1YsEBDhgzRmjVrdM011+ill17yKDaSPwAAbez48eMqLS1VSkqKuS8sLEyJiYnau3dvvX0uXbqk/fv3u/UJCAhQSkpKg30awoI/AIA9ePmo35XKv6Kiwm13S744W1paKkmKjIx02x8ZGWn+9nXnzp1TTU1NvX0++eQTj65P5Q8AsAcfDfvHxsYqLCzMbNnZ2W17Hz5A5Q8AgAdKSkoUGhpqbnta9UtSVFSUJKmsrEzR0dHm/rKyMg0fPrzePr1791ZgYKDKysrc9peVlZnnay4qfwCAPfio8g8NDXVrLUn+/fv3V1RUlHbu3Gnuq6io0Pvvv6+kpKR6+wQFBSkhIcGtj8vl0s6dOxvs0xAqfwCALbT1630rKyt19OhRc/v48eMqKipSz5491bdvXy1evFiPPfaYBg4cqP79++snP/mJYmJiNH36dLPPxIkTNWPGDGVmZkqSsrKylJ6erpEjR2r06NF6+umnVVVVpQULFngUG8kfAIBWUFhYqAkTJpjbWVlZkqT09HTl5ubq4YcfVlVVle69916dP39e48aN07Zt2xQcHGz2OXbsmM6dO2duz5o1S5999pmWLl2q0tJSDR8+XNu2bauzCLApJH8AAFpBcnKyDKPh4QKHw6GVK1dq5cqVDR5z4sSJOvsyMzPNkYCWIvkDAOyBd/ubSP4AAFvgk761WO0PAIDNUPkDAOzDj6p3b5D826EuZx1Wh9AK/Ov/1SrV1eoQfO6wIqwOAc1yrulDUD/m/E0M+wMAYDP+VY4BANAAFvzVIvkDAOyBYX8Tw/4AANgMlT8AwBYY9q9F8gcA2APD/iaG/QEAsBkqfwCAPVD5m0j+AABbYM6/FskfAGAPVP4m5vwBALAZKn8AgD1Q+ZtI/gAAW2DOvxbD/gAA2AyVPwDAHhj2N5H8AQC2wLB/LYb9AQCwGSp/AIA9MOxvIvkDAOyB5G9i2B8AAJuxNPlnZ2dr1KhRCgkJUUREhKZPn67Dhw9bGRIAwE85fND8haXJv6CgQBkZGdq3b5927Nihy5cva9KkSaqqqrIyLACAPzJ80PyEpXP+27Ztc9vOzc1VRESE9u/fr9tuu82iqAAA/ohH/Wq1qzn/8vJySVLPnj0tjgQAAP/Vblb7u1wuLV68WGPHjtXQoUPrPaa6ulrV1dXmdkVFRVuFBwDo6Fjtb2o3lX9GRoYOHTqkvLy8Bo/Jzs5WWFiY2WJjY9swQgBAh8d8v6R2kvwzMzO1ZcsW7dq1S3369GnwuCVLlqi8vNxsJSUlbRglAADN169fPzkcjjotIyOj3uNzc3PrHBscHNwqsVk67G8Yhr7//e9r48aNys/PV//+/Rs93ul0yul0tlF0AAB/0tYL/j788EPV1NSY24cOHdIdd9yhmTNnNtgnNDTU7ZF3h6N1HjC0NPlnZGRo3bp12rx5s0JCQlRaWipJCgsLU5cuXawMDQDgb9p4zj88PNxt+4knntB1112n8ePHN9jH4XAoKiqqJdF5xNJh/5ycHJWXlys5OVnR0dFmW79+vZVhAQDgU5cuXdLvfvc7LVy4sNFqvrKyUnFxcYqNjdW0adP00UcftUo8lg/7AwDQFnw17P/1J82aMyW9adMmnT9/XvPnz2/wmEGDBumll17SsGHDVF5ern//93/XmDFj9NFHHzW6Hq4l2sWCPwAAWp2P3vAXGxvr9uRZdnZ2k5d+8cUXlZaWppiYmAaPSUpK0rx58zR8+HCNHz9eGzZsUHh4uJ577rmW3nGD2s1z/gAAdAQlJSUKDQ01t5uq+k+ePKl33nlHGzZs8Og6nTt31ogRI3T06NEWxdkYKn8AgC1cGfb3pklfrci/ujWV/NeuXauIiAhNmTLFo3hramp08OBBRUdHt/SWG0TyBwDYgwUf9nG5XFq7dq3S09PVqZP7YPu8efO0ZMkSc3vlypX6wx/+oE8//VQHDhzQ3LlzdfLkSd19992eX7gJDPsDAOzBgtf7vvPOOyouLtbChQvr/FZcXKyAgNoa/IsvvtA999yj0tJS9ejRQwkJCdqzZ4+GDBniRdD1I/kDANBKJk2a1OCTbfn5+W7bTz31lJ566qk2iIrkDwCwCT7pW4vkDwCwB77qZ2LBHwAANkPlDwCwBYdhyOHFm2W96dvekPwBAPbAsL+JYX8AAGyGyh8AYAus9q9F8gcA2APD/iaG/QEAsBkqfwCALTDsX4vkDwCwB4b9TSR/AIAtUPnXYs4fAACbofIHANgDw/4mkn871LXUZXUIrcDfBpn871+dSnW1OgSfO6wIq0PwuRidszqEDs2fhu694W//RQYAAE3wv/IFAID6GMZXzZv+foLkDwCwBVb712LYHwAAm6HyBwDYA6v9TSR/AIAtOFxfNW/6+wuG/QEAsBkqfwCAPTDsbyL5AwBsgdX+tUj+AAB74Dl/E3P+AADYDJU/AMAWGPavRfIHANgDC/5MDPsDAGAzVP4AAFtg2L8WyR8AYA+s9jcx7A8AQCtYvny5HA6HWxs8eHCjfV5//XUNHjxYwcHBuvnmm7V169ZWiY3kDwCwhSvD/t40T9100006c+aM2d57770Gj92zZ49mz56tRYsW6c9//rOmT5+u6dOn69ChQ17cdf1I/gAAezB80DzUqVMnRUVFma13794NHvvMM89o8uTJ+uEPf6gbb7xRP/3pT/WNb3xDq1at8vzCTSD5AwDQSo4cOaKYmBgNGDBAc+bMUXFxcYPH7t27VykpKW77UlNTtXfvXp/HxYI/AIAt+Gq1f0VFhdt+p9Mpp9NZ5/jExETl5uZq0KBBOnPmjFasWKFbb71Vhw4dUkhISJ3jS0tLFRkZ6bYvMjJSpaWlLQ+6AZZW/rt379bUqVMVExMjh8OhTZs2WRkOAMCfuQzvm6TY2FiFhYWZLTs7u97LpaWlaebMmRo2bJhSU1O1detWnT9/Xq+99lpb3nW9LK38q6qqFB8fr4ULF+rOO++0MhQAgL/z0Rv+SkpKFBoaau6ur+qvT/fu3XXDDTfo6NGj9f4eFRWlsrIyt31lZWWKiopqWbyNsLTyT0tL02OPPaYZM2ZYGQYAAM0WGhrq1pqb/CsrK3Xs2DFFR0fX+3tSUpJ27tzptm/Hjh1KSkryOuavY8EfAMAWHPLyUT8Pr/fQQw+poKBAJ06c0J49ezRjxgwFBgZq9uzZkqR58+ZpyZIl5vEPPPCAtm3bpl/96lf65JNPtHz5chUWFiozM9N3/xD+oUMt+KuurlZ1dbW5/fVFFwAANKiN3/B36tQpzZ49W59//rnCw8M1btw47du3T+Hh4ZKk4uJiBQTU1uBjxozRunXr9Oijj+rHP/6xBg4cqE2bNmno0KEtj7kBHSr5Z2dna8WKFVaHAQBAk/Ly8hr9PT8/v86+mTNnaubMma0UUa0ONey/ZMkSlZeXm62kpMTqkAAAHYQVb/hrrzpU5d/Qs5QAADTJR6v9/YGlyb+ystLtkYfjx4+rqKhIPXv2VN++fS2MDAAA/2Vp8i8sLNSECRPM7aysLElSenq6cnNzLYoKAOCPHIYhhxcL/rzp295YmvyTk5Nl+NE/TABAO+b6R/Omv5/oUAv+AACA9zrUgj8AAFqKYf9aJH8AgD2w2t9E8gcA2EMbv+GvPWPOHwAAm6HyBwDYgrdv6eMNfwAAdDQM+5sY9gcAwGao/AEAtuBwfdW86e8vSP4AAHtg2N/EsD8AADZD5Q8AsAde8mMi+QMAbIHX+9Zi2B8AAJuh8gcA2AML/kwkfwCAPRiSvHlcz39yP8kfAGAPzPnXYs4fAACbofIHANiDIS/n/H0WieVI/gAAe2DBn4nk3w51e22f1SH4XDerAwAAmEj+AAB7cElyeNnfT5D8AQC2wGr/Wqz2BwDAZqj8AQD2wII/E8kfAGAPJH8Tw/4AALSC7OxsjRo1SiEhIYqIiND06dN1+PDhRvvk5ubK4XC4teDgYJ/HRvIHANjDlcrfm+aBgoICZWRkaN++fdqxY4cuX76sSZMmqaqqqtF+oaGhOnPmjNlOnjzpzV3Xi2F/AIA9tPGjftu2bXPbzs3NVUREhPbv36/bbrutwX4Oh0NRUVEtibDZqPwBALZw5VE/b5o3ysvLJUk9e/Zs9LjKykrFxcUpNjZW06ZN00cffeTVdetD8gcAwAMVFRVurbq6usk+LpdLixcv1tixYzV06NAGjxs0aJBeeuklbd68Wb/73e/kcrk0ZswYnTp1ype3QPIHANiEj+b8Y2NjFRYWZrbs7OwmL52RkaFDhw4pLy+v0eOSkpI0b948DR8+XOPHj9eGDRsUHh6u5557zif/CK5gzh8AYA8uQ3J4MXTv+qpvSUmJQkNDzd1Op7PRbpmZmdqyZYt2796tPn36eHTJzp07a8SIETp69Kjn8TaCyh8AAA+Ehoa6tYaSv2EYyszM1MaNG/Xuu++qf//+Hl+rpqZGBw8eVHR0tLdhu6HyBwDYQxu/5CcjI0Pr1q3T5s2bFRISotLSUklSWFiYunTpIkmaN2+err32WnPqYOXKlbrlllt0/fXX6/z58/rlL3+pkydP6u6772553PUg+QMAbMLL5C/P+ubk5EiSkpOT3favXbtW8+fPlyQVFxcrIKB2EP6LL77QPffco9LSUvXo0UMJCQnas2ePhgwZ4kXcdZH8AQBoBUYz/tDIz893237qqaf01FNPtVJEtUj+AAB74N3+JpI/AMAeXIY8Hbqv298/sNofAACbofIHANiD4fqqedPfT5D8AQD2wJy/qV0M+69evVr9+vVTcHCwEhMT9cEHH1gdEgDA37gM75ufsDz5r1+/XllZWVq2bJkOHDig+Ph4paam6uzZs1aHBgCAX7I8+T/55JO65557tGDBAg0ZMkRr1qzRNddco5deesnq0AAA/sRHH/bxB5Ym/0uXLmn//v1KSUkx9wUEBCglJUV79+6tc3x1dXWdTykCANAshrxM/lbfgO9YmvzPnTunmpoaRUZGuu2PjIw034F8tezsbLfPKMbGxrZVqAAA+A3Lh/09sWTJEpWXl5utpKTE6pAAAB0Fw/4mSx/16927twIDA1VWVua2v6ysTFFRUXWOdzqdTX43GQCAerlckrx4Vt/lP8/5W1r5BwUFKSEhQTt37jT3uVwu7dy5U0lJSRZGBgCA/7L8JT9ZWVlKT0/XyJEjNXr0aD399NOqqqrSggULrA4NAOBPeMmPyfLkP2vWLH322WdaunSpSktLNXz4cG3btq3OIkAAALxC8jdZnvwlKTMzU5mZmVaHAQCALbSL5A8AQKvjk74mkj8AwBYMwyXDiy/zedO3vSH5AwDswfDy4zx+NOffoV7yAwAAvEflDwCwB8PLOX8/qvxJ/gAAe3C5JIcX8/Z+NOfPsD8AADZD5Q8AsAeG/U0kfwCALRgulwwvhv396VE/hv0BALAZKn8AgD0w7G8i+QMA7MFlSA6Sv8SwPwAAtkPlDwCwB8OQ5M1z/v5T+ZP8AQC2YLgMGV4M+xt+lPwZ9gcA2IPh8r61wOrVq9WvXz8FBwcrMTFRH3zwQaPHv/766xo8eLCCg4N18803a+vWrS26bmNI/gAAtJL169crKytLy5Yt04EDBxQfH6/U1FSdPXu23uP37Nmj2bNna9GiRfrzn/+s6dOna/r06Tp06JBP43IYHXgco6KiQmFhYUrWNHVydLY6HACAh740Litfm1VeXq7Q0NBWuYaZKxwzvMoVXxqXlW9s9CjWxMREjRo1SqtWrZIkuVwuxcbG6vvf/75+9KMf1Tl+1qxZqqqq0pYtW8x9t9xyi4YPH641a9a0OPavo/IHANhDGw/7X7p0Sfv371dKSoq5LyAgQCkpKdq7d2+9ffbu3et2vCSlpqY2eHxLdegFf1cGLb7UZa/e2wAAsMaXuiypbRbTeZsrrsRaUVHhtt/pdMrpdNY5/ty5c6qpqVFkZKTb/sjISH3yySf1XqO0tLTe40tLS1seeD06dPK/cOGCJOk9+X4xBACg7Vy4cEFhYWGtcu6goCBFRUXpvVLvc0W3bt0UGxvrtm/ZsmVavny51+duSx06+cfExKikpEQhISFyOByteq2KigrFxsaqpKSk1eal2pK/3Y/EPXUU3FP715b3YxiGLly4oJiYmFa7RnBwsI4fP65Lly55fS7DMOrkm/qqfknq3bu3AgMDVVZW5ra/rKxMUVFR9faJiory6PiW6tDJPyAgQH369GnTa4aGhvrFv9xX+Nv9SNxTR8E9tX9tdT+tVfFfLTg4WMHBwa1+nasFBQUpISFBO3fu1PTp0yV9teBv586dyszMrLdPUlKSdu7cqcWLF5v7duzYoaSkJJ/G1qGTPwAA7VlWVpbS09M1cuRIjR49Wk8//bSqqqq0YMECSdK8efN07bXXKjs7W5L0wAMPaPz48frVr36lKVOmKC8vT4WFhXr++ed9GhfJHwCAVjJr1ix99tlnWrp0qUpLSzV8+HBt27bNXNRXXFysgIDaB+/GjBmjdevW6dFHH9WPf/xjDRw4UJs2bdLQoUN9GhfJv5mcTqeWLVvW4NxOR+Nv9yNxTx0F99T++dv9WC0zM7PBYf78/Pw6+2bOnKmZM2e2akwd+iU/AADAc7zkBwAAmyH5AwBgMyR/AABshuQPAIDNkPybwdNvMbdnu3fv1tSpUxUTEyOHw6FNmzZZHZLXsrOzNWrUKIWEhCgiIkLTp0/X4cOHrQ7LKzk5ORo2bJj5kpWkpCS9/fbbVoflM0888YQcDofbi0w6muXLl8vhcLi1wYMHWx2W1/76179q7ty56tWrl7p06aKbb75ZhYWFVocFHyP5N8HTbzG3d1VVVYqPj9fq1autDsVnCgoKlJGRoX379mnHjh26fPmyJk2apKqqKqtDa7E+ffroiSee0P79+1VYWKjbb79d06ZN00cffWR1aF778MMP9dxzz2nYsGFWh+K1m266SWfOnDHbe++9Z3VIXvniiy80duxYde7cWW+//bb+93//V7/61a/Uo0cPq0ODrxlo1OjRo42MjAxzu6amxoiJiTGys7MtjMo3JBkbN260OgyfO3v2rCHJKCgosDoUn+rRo4fxm9/8xuowvHLhwgVj4MCBxo4dO4zx48cbDzzwgNUhtdiyZcuM+Ph4q8PwqUceecQYN26c1WGgDVD5N6Il32KG9crLyyVJPXv2tDgS36ipqVFeXp6qqqp8/n7vtpaRkaEpU6bU+V55R3XkyBHFxMRowIABmjNnjoqLi60OyStvvvmmRo4cqZkzZyoiIkIjRozQCy+8YHVYaAUk/0Y09i1mX39bGb7hcrm0ePFijR071uevw2xrBw8eVLdu3eR0OvUv//Iv2rhxo4YMGWJ1WC2Wl5enAwcOmO8w7+gSExOVm5urbdu2KScnR8ePH9ett95qfmq8I/r000+Vk5OjgQMHavv27brvvvt0//336+WXX7Y6NPgYr/eFX8nIyNChQ4c6/NyrJA0aNEhFRUUqLy/XG2+8ofT0dBUUFHTIPwBKSkr0wAMPaMeOHW3+ZbXWkpaWZv7vYcOGKTExUXFxcXrttde0aNEiCyNrOZfLpZEjR+rxxx+XJI0YMUKHDh3SmjVrlJ6ebnF08CUq/0a05FvMsE5mZqa2bNmiXbt2tfmnnltDUFCQrr/+eiUkJCg7O1vx8fF65plnrA6rRfbv36+zZ8/qG9/4hjp16qROnTqpoKBAzz77rDp16qSamhqrQ/Ra9+7ddcMNN+jo0aNWh9Ji0dHRdf64vPHGGzv8dAbqIvk34upvMV9x5VvMHX3u1Z8YhqHMzExt3LhR7777rvr37291SK3C5XKpurra6jBaZOLEiTp48KCKiorMNnLkSM2ZM0dFRUUKDAy0OkSvVVZW6tixY4qOjrY6lBYbO3Zsncdk//KXvyguLs6iiNBaGPZvQlPfYu5oKisr3SqT48ePq6ioSD179lTfvn0tjKzlMjIytG7dOm3evFkhISHmeoywsDB16dLF4uhaZsmSJUpLS1Pfvn114cIFrVu3Tvn5+dq+fbvVobVISEhInTUYXbt2Va9evTrs2oyHHnpIU6dOVVxcnE6fPq1ly5YpMDBQs2fPtjq0FnvwwQc1ZswYPf744/rOd76jDz74QM8//7zPvyWPdsDqxw06gv/4j/8w+vbtawQFBRmjR4829u3bZ3VILbZr1y5DUp2Wnp5udWgtVt/9SDLWrl1rdWgttnDhQiMuLs4ICgoywsPDjYkTJxp/+MMfrA7Lpzr6o36zZs0yoqOjjaCgIOPaa681Zs2aZRw9etTqsLz2+9//3hg6dKjhdDqNwYMHG88//7zVIaEV8ElfAABshjl/AABshuQPAIDNkPwBALAZkj8AADZD8gcAwGZI/gAA2AzJHwAAmyH5AwBgMyR/oB2bP3++pk+fbnUYAPwMyR8AAJsh+QMAYDMkfwAAbIbkDwCAzZD8AQCwGZI/AAA2Q/IHAMBmSP4AANgMyR8AAJtxGIZhWB0EAABoO1T+AADYDMkfAACbIfkDAGAzJH8AAGyG5A8AgM2Q/AEAsBmSPwAANkPyBwDAZkj+AADYDMkfAACbIfkDAGAzJH8AAGzm/wMEUITiKRBDBwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_out at K = 3 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\n", - "Min and max values: 0.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Resetting qty_out to zeros\n", - "Executing 'copy_downward' with origin=(1,1,0), domain=(nx,ny,nz-1)\n", - "***\n", - "Plotting values of qty_out at K = 0\n", - "Min and max values: 11.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_out at K = 1\n", - "Min and max values: 12.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_out at K = 2\n", - "Min and max values: 13.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from gt4py.cartesian.gtscript import FORWARD, BACKWARD\n", "\n", @@ -871,7 +348,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -892,50 +369,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing 'copy_stencil' with origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\n", - "Executing 'copy_stencil' where qty_out is copied back to qty_in\n", - "Min and max values: 10.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing 'copy_stencil_offset' where origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\n" - ] - }, - { - "ename": "ValueError", - "evalue": "Origin for field field_in too small. Must be at least (0, 2, 0), is (1, 1, 0)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_23384/2175782849.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0mplot_field_at_kN\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqty_in\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Executing 'copy_stencil_offset' where origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 33\u001b[0;31m \u001b[0mcopy_stencil_offset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqty_in\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mqty_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnhalo\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnhalo\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdomain\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mny\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 34\u001b[0m \u001b[0mplot_field_at_kN\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqty_out\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/SMT-Nebulae-Tutorial/tutorial/NDSL/.gt_cache_000000/py311_1013/numpy/__main__/copy_stencil_offset/m_copy_stencil_offset__numpy_ef139435cf.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, field_in, field_out, domain, origin, validate_args, exec_info)\u001b[0m\n\u001b[1;32m 99\u001b[0m \u001b[0;31m# assert that all required values have been provided\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 100\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 101\u001b[0;31m self._call_run(\n\u001b[0m\u001b[1;32m 102\u001b[0m \u001b[0mfield_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfield_args\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[0mparameter_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparameter_args\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_object.py\u001b[0m in \u001b[0;36m_call_run\u001b[0;34m(self, field_args, parameter_args, domain, origin, validate_args, exec_info)\u001b[0m\n\u001b[1;32m 582\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 583\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mvalidate_args\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 584\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validate_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray_infos\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparameter_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdomain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 585\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 586\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_domain_origin_cache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcache_key\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mdomain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_object.py\u001b[0m in \u001b[0;36m_validate_args\u001b[0;34m(self, arg_infos, param_args, domain, origin)\u001b[0m\n\u001b[1;32m 466\u001b[0m )\n\u001b[1;32m 467\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfield_domain_origin\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mmin_origin\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 468\u001b[0;31m raise ValueError(\n\u001b[0m\u001b[1;32m 469\u001b[0m \u001b[0;34mf\"Origin for field {name} too small. Must be at least {min_origin}, is {field_domain_origin}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 470\u001b[0m )\n", - "\u001b[0;31mValueError\u001b[0m: Origin for field field_in too small. Must be at least (0, 2, 0), is (1, 1, 0)" - ] - } - ], + "outputs": [], "source": [ "nx = 5\n", "ny = 5\n", @@ -984,120 +420,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_in at K = 0\n", - "Min and max values: 12.0 0.0\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfIAAAHHCAYAAABEJtrOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAtB0lEQVR4nO3dfXQV9Z3H8c8lkJtAHkgiD4mEEBVFHkUCLKICksrmAAu7R0E2bCN0XatBiCwrsq2AuBLcPaVopeGhW6EeKFArD0WBUh4PVYSA7EJ3RVAKEQyga/OkCXjv7B82t8QEkty5uXNn5v06Z84xc2fufAcPfPP9/n4zP49hGIYAAIAttbI6AAAAEDwSOQAANkYiBwDAxkjkAADYGIkcAAAbI5EDAGBjJHIAAGyMRA4AgI2RyAEAsDESOVxt79698ng82rt3r9WhAEBQSORwpFWrVsnj8QS2mJgY3X777Zo2bZouXrwYkmu8/fbbmj9/fki+61pr167VkiVLmnx8t27dNGbMmHr7X3/9dUVFRemv//qvVV1dHcIIb+z8+fOaMGGC2rdvr4SEBI0bN04ff/xx2K4PuE1rqwMAWtKCBQuUmZmp6upqHThwQEVFRXr77bd14sQJtW3b1tR3v/3221q6dGnIk/natWt14sQJFRQUBP0da9as0aOPPqrs7Gxt2rRJMTExoQvwBiorKzVixAiVlZXpX//1X9WmTRv9+Mc/1rBhw3Ts2DGlpKSEJQ7ATUjkcLScnBxlZWVJkv7xH/9RKSkpWrx4sTZv3qxJkyZZHF3LWLdunfLy8vTAAw9o8+bNYUvikvTTn/5Up06d0qFDhzRw4EBJ3/w/6N27t370ox9p4cKFYYsFcAta63CVBx54QJJ05syZGx73q1/9SgMGDFBsbKxuuukmTZ48WefPnw98/uijj2rp0qWSVKeFfyObN2/W6NGjlZaWJq/Xq1tvvVUvvPCCfD5f4Jjhw4frrbfe0tmzZwPf2a1btybf34YNGzR58mQNHz5cW7ZsCWsSl6Q33nhDAwcODCRxSerRo4dGjhypDRs2hDUWwC2oyOEqH330kSTdsMW7atUqTZkyRQMHDlRhYaEuXryol19+Wb///e/1/vvvq3379nr88cd14cIF7dy5U6+//nqTrr1q1SrFxcVp5syZiouL0+7duzV37lyVl5frP/7jPyRJP/jBD1RWVqZPPvlEP/7xjyVJcXFxTfr+X//618rNzdX999+v3/zmN4qNjW3SeZWVlU0aQ2/Tpo0SExOv+7nf79d///d/a+rUqfU+GzRokH7729+qoqJC8fHxTYoLQBMZgAO99tprhiTjd7/7nXH58mWjpKTEWLdunZGSkmLExsYan3zyiWEYhrFnzx5DkrFnzx7DMAzjypUrRseOHY3evXsbX331VeD7tm7dakgy5s6dG9iXn59vNOev0Jdffllv3+OPP260bdvWqK6uDuwbPXq0kZGR0eTvzcjIMNLS0ozWrVsbw4cPN6qqqpp8rmEYRl5eniGp0W3YsGE3/J7Lly8bkowFCxbU+2zp0qWGJOODDz5oVmwAGkdFDkfLzs6u83NGRobWrFmjm2++ucHji4uLdenSJc2fP79OW3r06NHq0aOH3nrrLT3//PNBxXJthVxRUaGamhrdd999Wr58uT744AP169cvqO+VpP/7v//T119/rS5dujS5Eq/1zDPPaPLkyY0el5SUdMPPv/rqK0mS1+ut91ntn2XtMQBCh0QOR1u6dKluv/12tW7dWp06ddIdd9yhVq2uPzXk7NmzkqQ77rij3mc9evTQgQMHgo7lD3/4g374wx9q9+7dKi8vr/NZWVlZ0N8rSSNHjlTXrl1VVFSk5ORkvfzyy00+t2fPnurZs6ep60t/+UWlpqam3me1rfvm/pIBoHEkcjjaoEGDArPWrfSnP/1Jw4YNU0JCghYsWKBbb71VMTExOnr0qGbPni2/32/6Gq+++qq++OILvfLKK0pKSmryY3FlZWVNqpSjo6OVnJx83c+Tk5Pl9Xr16aef1vusdl9aWlqTYgLQdCRy4BoZGRmSpJMnTwZmuNc6efJk4HNJjc5Sv9bevXv1+eef680339T9998f2N/Q7PnmfO+1WrVqpV/84hcqKyvT888/r+TkZE2fPr3R82bMmKHVq1c3etywYcNu+Aa8Vq1aqU+fPiouLq732XvvvadbbrmFiW5ACyCRA9fIyspSx44dtWzZMk2dOjUw3rtt2zb97//+r+bOnRs4tl27dpK+qbbbt29/w++NioqSJBmGEdh35coV/fSnP613bLt27YJutbdp00ZvvPGGHnzwQRUUFCgpKUn/8A//cMNzQjVGLkkPPfSQnn32WRUXFwc6ISdPntTu3bs1a9aspt0EgGYhkQPXaNOmjV566SVNmTJFw4YN06RJkwKPn3Xr1k1PP/104NgBAwZIkqZPn65Ro0YpKipKjzzySIPfe8899ygpKUl5eXmaPn26PB6PXn/99TqJ/drvXb9+vWbOnKmBAwcqLi5OY8eObfI9tG3bVm+99ZaGDRumqVOnKjExUX/zN39z3eNDNUYuSU8++aRWrlyp0aNHa9asWWrTpo0WL16sTp066Z//+Z9Dcg0A32L1tHmgJdQ+fnb48OEbHvftx89qrV+/3ujfv7/h9XqN5ORkIzc3N/DIWq2vv/7aeOqpp4wOHToYHo+n0UfRfv/73xt/9Vd/ZcTGxhppaWnGM888Y+zYsaPe9SsrK42///u/N9q3b29IavRRtIyMDGP06NH19peWlhq33XabERMTU+/+WlJJSYnx0EMPGQkJCUZcXJwxZswY49SpU2G7PuA2HsNooCQAAAC2wCtaAQCwMRI5AAA2RiIHAMDGSOQAALSA/fv3a+zYsUpLS5PH49GmTZsCn129elWzZ89Wnz591K5dO6Wlpem73/2uLly40OzrkMgBAGgBVVVV6tevX2DJ42t9+eWXOnr0qJ577jkdPXpUb775pk6ePHnDR0Wvh1nrAAC0MI/Ho40bN2r8+PHXPebw4cMaNGiQzp49q65duzb5u239Qhi/368LFy4oPj4+6NdaAgCsYxiGKioqlJaWdsMFjcyqrq7WlStXTH+PYRj18o3X621w1b/mKisrk8fjafRNkd9m60R+4cIFpaenWx0GAMCkkpISdenSpUW+u7q6WpkZcSq95DP9XXFxcaqsrKyzb968eU1epOh6qqurNXv2bE2aNEkJCQnNOtfWibx2AYYu83+oVtesHW17yfWXgbS7m5IrGz/IRm5PumR1CCF3V/wnVocQclmxH1sdQsgN8LaxOoSQKq/0K+PuP7bogjpXrlxR6SWfzh7ppoT44Kv+8gq/Mgb8USUlJXWSrdlq/OrVq5owYYIMw1BRUVGzz7d1Iq9tb7SKiXFWIm/rvGGCqHZXrQ4hpKLjoq0OIeRi4mz9z0GD2rV13nzeBK/z7kkKftW/5oiL9yguPvjr+PXNuQkJCc2umq+nNomfPXtWu3fvDup7nfc3FwCABvgMv3wmpnf7DH/ogtFfkvipU6e0Z88epaSkBPU9JHIAgCv4Zciv4DN5c8+trKzU6dOnAz+fOXNGx44dU3JyslJTU/XQQw/p6NGj2rp1q3w+n0pLSyVJycnJio5uetePRA4AQAsoLi7WiBEjAj/PnDlTkpSXl6f58+dry5YtkqS77rqrznl79uzR8OHDm3wdEjkAwBX88stMc7y5Zw8fPlw3elVLqF7jQiIHALiCzzDkM5E8zZzbkpw5/REAAJegIgcAuEK4J7uFC4kcAOAKfhnyOTCR01oHAMDGqMgBAK5Aax0AABtj1joAAIg4VOQAAFfw/3kzc34kIpEDAFzBZ3LWuplzWxKJHADgCj5DJlc/C10socQYOQAANkZFDgBwBcbIAQCwMb888slj6vxIRGsdAAAbszyRnz9/XpMnT1ZKSopiY2PVp08fFRcXWx0WAMBh/Ib5LRJZ2lr/4osvNHToUI0YMULbtm1Thw4ddOrUKSUlJVkZFgDAgXwmW+tmzm1Jlibyl156Senp6XrttdcC+zIzMy2MCAAAe7G0tb5lyxZlZWXp4YcfVseOHdW/f3+tXLnSypAAAA5VW5Gb2SKRpYn8448/VlFRkbp3764dO3boiSee0PTp07V69eoGj6+pqVF5eXmdDQCApvAbHtNbJLK0te73+5WVlaWFCxdKkvr3768TJ05o2bJlysvLq3d8YWGhnn/++XCHCQBAxLK0Ik9NTVXPnj3r7Lvzzjt17ty5Bo+fM2eOysrKAltJSUk4wgQAOIBTW+uWVuRDhw7VyZMn6+z78MMPlZGR0eDxXq9XXq83HKEBABzGp1bymahffSGMJZQsTeRPP/207rnnHi1cuFATJkzQoUOHtGLFCq1YscLKsAAADmSYHOc2InSM3NLW+sCBA7Vx40b98pe/VO/evfXCCy9oyZIlys3NtTIsAABsw/J3rY8ZM0ZjxoyxOgwAgMPxQhgAAGzMZ7SSzzAxRh6hr2i1/F3rAAAgeFTkAABX8Msjv4n61a/ILMlJ5AAAV3DqGDmtdQAAbIyKHADgCuYnu9FaBwDAMt+MkQffHjdzbkuitQ4AgI1RkQMAXMFv8l3rzFoHAMBCjJEDAGBjfrVy5HPkjJEDAGBjVOQAAFfwGR75TCxFaubclkQiBwC4gs/kZDcfrXUAABBqVOQAAFfwG63kNzFr3c+sdQAArENrHQAARBwqcgCAK/hlbua5P3ShhBSJHADgCuZfCBOZTWxHJHLvZ60U5Y3MP+BgVMtrdQghd9nqAADHOG11ACFVVROpda59OCKRAwDQGPPvWo/MgpFEDgBwBaeuR04iBwC4glMr8siMCgAAm9u/f7/Gjh2rtLQ0eTwebdq0qc7nhmFo7ty5Sk1NVWxsrLKzs3Xq1KlmX4dEDgBwhdoXwpjZmqOqqkr9+vXT0qVLG/z83//93/XKK69o2bJleu+999SuXTuNGjVK1dXVzboOrXUAgCv4DY/8Zp4jb+a5OTk5ysnJafAzwzC0ZMkS/fCHP9S4ceMkSb/4xS/UqVMnbdq0SY888kiTr0NFDgBAmJ05c0alpaXKzs4O7EtMTNTgwYP17rvvNuu7qMgBAK7gN/mu9doXwpSXl9fZ7/V65fU27/0fpaWlkqROnTrV2d+pU6fAZ01FRQ4AcIXa1c/MbJKUnp6uxMTEwFZYWGjpfVGRAwDQDCUlJUpISAj83NxqXJI6d+4sSbp48aJSU1MD+y9evKi77rqrWd9FRQ4AcAWfPKY3SUpISKizBZPIMzMz1blzZ+3atSuwr7y8XO+9956GDBnSrO+iIgcAuMK17fFgz2+OyspKnT79l3fjnzlzRseOHVNycrK6du2qgoIC/du//Zu6d++uzMxMPffcc0pLS9P48eObdR0SOQAALaC4uFgjRowI/Dxz5kxJUl5enlatWqVnnnlGVVVV+qd/+if96U9/0r333qvt27crJiamWdchkQMAXMEnBdrjwZ7fHMOHD5dhGNf93OPxaMGCBVqwYEHQMUkkcgCAS4S7tR4uJHIAgCuwaAoAAIg4VOQAAFcwTK5HbrAeOQAA1qG1DgAAIg4VOQDAFcK9jGm4WFqRz58/Xx6Pp87Wo0cPK0MCADiU78+rn5nZIpHlFXmvXr30u9/9LvBz69aWhwQAgG1YnjVbt24dWAUGAICWQmu9hZw6dUppaWm65ZZblJubq3Pnzl332JqaGpWXl9fZAABoCr9amd4ikaVRDR48WKtWrdL27dtVVFSkM2fO6L777lNFRUWDxxcWFtZZzD09PT3MEQMAEFksba3n5OQE/rtv374aPHiwMjIytGHDBn3ve9+rd/ycOXMCq8dI36zdSjIHADSFz/DIZ6I9bubclmT5GPm12rdvr9tvv73O+q3X8nq9QS3gDgAAY+RhUFlZqY8++kipqalWhwIAcBjjz6ufBbsZvNmtvlmzZmnfvn364x//qHfeeUd/+7d/q6ioKE2aNMnKsAAAsA1LW+uffPKJJk2apM8//1wdOnTQvffeq4MHD6pDhw5WhgUAcCCfPPKZWPjEzLktydJEvm7dOisvDwBwEb9hbpzbb4QwmBCKzIY/AABokoiatQ4AQEupnbRm5vxIRCIHALiCXx75TYxzmzm3JUXmrxcAAKBJqMgBAK7Am90AALAxp46RR2ZUAACgSajIAQCu4JfJd61H6GQ3EjkAwBUMk7PWDRI5AADWYfUzAAAQcajIAQCu4NRZ6yRyAIAr0FoHAAARh4ocAOAKTn3XOokcAOAKtNYBAEDEoSIHALiCUytyEjkAwBWcmshprQMAYGOOqMhjPjcUFW1YHUYIOe/3q2p5rQ4hpC5bHQDgENVffS2pJCzXcmpF7ohEDgBAYwyZe4QsUstFEjkAwBWcWpE7r4cLAICLUJEDAFzBqRU5iRwA4ApOTeS01gEAsDEqcgCAKzi1IieRAwBcwTA8MkwkYzPntiRa6wAA2BgVOQDAFViPHAAAG3PqGDmtdQAAbIxEDgBwhdrJbma25vD5fHruueeUmZmp2NhY3XrrrXrhhRdkGKF9azutdQCAK4S7tf7SSy+pqKhIq1evVq9evVRcXKwpU6YoMTFR06dPDzqObyORAwBcIdyPn73zzjsaN26cRo8eLUnq1q2bfvnLX+rQoUNBx9AQWusAADRDeXl5na2mpqbB4+655x7t2rVLH374oSTpv/7rv3TgwAHl5OSENB4qcgCAKxgmW+u1FXl6enqd/fPmzdP8+fPrHf/ss8+qvLxcPXr0UFRUlHw+n1588UXl5uYGHUNDSOQAAFcwJJmZZ1Z7aklJiRISEgL7vV5vg8dv2LBBa9as0dq1a9WrVy8dO3ZMBQUFSktLU15eXvCBfAuJHACAZkhISKiTyK/nX/7lX/Tss8/qkUcekST16dNHZ8+eVWFhIYkcAIDm8ssjTxjf7Pbll1+qVau6U9GioqLk9/uDjqEhJHIAgCuEe9b62LFj9eKLL6pr167q1auX3n//fS1evFhTp04NOoaGRMys9UWLFsnj8aigoMDqUAAAMO0nP/mJHnroIT355JO68847NWvWLD3++ON64YUXQnqdiKjIDx8+rOXLl6tv375WhwIAcCi/4ZEnjC+EiY+P15IlS7RkyZKgr9kUllfklZWVys3N1cqVK5WUlGR1OAAAhzIM81sksjyR5+fna/To0crOzm702JqamnoP4gMA4GaWttbXrVuno0eP6vDhw006vrCwUM8//3wLRwUAcKJwT3YLF8sq8pKSEs2YMUNr1qxRTExMk86ZM2eOysrKAltJSUkLRwkAcIpwr34WLpZV5EeOHNGlS5d09913B/b5fD7t379fr776qmpqahQVFVXnHK/Xe9036AAAcCPhnuwWLpYl8pEjR+r48eN19k2ZMkU9evTQ7Nmz6yVxAABQn2WJPD4+Xr17966zr127dkpJSam3HwAAs8zOPI/UWesR8Rw5AAAt7ZtEbmayWwiDCaGISuR79+61OgQAAGwlohI5AAAtxamPn5HIAQCuYOgva4oHe34ksvzNbgAAIHhU5AAAV6C1DgCAnTm0t04iBwC4g9nXrEZoRc4YOQAANkZFDgBwBd7sBgCAjTl1shutdQAAbIyKHADgDobH3IS1CK3ISeQAAFdw6hg5rXUAAGyMihwA4A68EAYAAPti1joAAIg4VOQAAPeI0Pa4GSRyAIArOLW1TiIHALiDQye7MUYOAICNOaIij/3Mr9Zt/FaHEUJO/P3KWfdULa/VIYTcZasDgCtdqbwSxqt5/ryZOT/yOCKRAwDQKFrrAAAg0lCRAwDcwaEVOYkcAOAODl39jNY6AAA2RkUOAHAFpy5jSiIHALiDQ8fIaa0DAGBjVOQAAHdw6GQ3EjkAwBU8xjebmfMjEYkcAOAOjJEDAIBIQ0UOAHAHxsgBALAxWusAACDSUJEDANzBoRU5iRwA4A4OTeS01gEAsDEqcgCAOzBrHQAA+3Lqm91orQMAYGOWJvKioiL17dtXCQkJSkhI0JAhQ7Rt2zYrQwIAOJURgq2Zzp8/r8mTJyslJUWxsbHq06ePiouLzd/LNSxtrXfp0kWLFi1S9+7dZRiGVq9erXHjxun9999Xr169rAwNAABTvvjiCw0dOlQjRozQtm3b1KFDB506dUpJSUkhvY6liXzs2LF1fn7xxRdVVFSkgwcPksgBACHlkckx8mYe/9JLLyk9PV2vvfZaYF9mZmbwAVxHkxL53/3d3zX+Ra1bq3PnzvrOd75TL0E3hc/n069+9StVVVVpyJAhDR5TU1OjmpqawM/l5eXNvg4AAGZ8O/d4vV55vd56x23ZskWjRo3Sww8/rH379unmm2/Wk08+qcceeyyk8TRpjDwxMbHRLTY2VqdOndLEiRM1d+7cJgdw/PhxxcXFyev16vvf/742btyonj17NnhsYWFhnWump6c3+ToAAJerffzMzCYpPT29Ti4qLCxs8HIff/yxioqK1L17d+3YsUNPPPGEpk+frtWrV4f0tjyGYYR0Qv3WrVv15JNP6ty5c006/sqVKzp37pzKysr0xhtv6Gc/+5n27dvXYDJvqCJPT0/XoLEvqHWbmJDdg9W+7OC8hwmqb4rM5y+DVd3Bb3UIoXdTTePH2EyHlAqrQwi5O5MvWh1CSF2pvKJ1I9eorKxMCQkJLXKN8vJyJSYmKqPwRbWKCT5X+KurdXbOD1RSUlIn1utV5NHR0crKytI777wT2Dd9+nQdPnxY7777btBxfFvIx8jvvfdeZWVlNfn46Oho3XbbbZKkAQMG6PDhw3r55Ze1fPnyesde7w8LAIBwqX3SqjGpqan1itI777xTv/71r0MaT8gTefv27fXmm28Gfb7f769TdQMAEBJhftf60KFDdfLkyTr7PvzwQ2VkZJgIoj5LZ63PmTNHOTk56tq1qyoqKrR27Vrt3btXO3bssDIsAIADhfvNbk8//bTuueceLVy4UBMmTNChQ4e0YsUKrVixIvggGmBpIr906ZK++93v6tNPP1ViYqL69u2rHTt26Dvf+Y6VYQEAYNrAgQO1ceNGzZkzRwsWLFBmZqaWLFmi3NzckF7H0kT+n//5n1ZeHgDgJhYsYzpmzBiNGTPGxEUbx6IpAAB3YD1yAAAQaajIAQCu4NRlTEnkAAB3uObtbEGfH4FI5AAAd2CMHAAARBoqcgCAKzBGDgCAndFaBwAAkYaKHADgDiZb65FakZPIAQDuQGsdAABEGipyAIA7OLQiJ5EDAFzBqY+f0VoHAMDGSOQAANgYrXUAgDswRg4AgH0xRg4AACIOFTkAwD0itKo2wxGJvG3pV2rd2kn/d2KtDqAFOK3547T7karltTqEkLtsdQBolK+qJnwXc+gYufP+NQIAwEUcUZEDANAYp052I5EDANyB1joAAIg0VOQAAFegtQ4AgJ3RWgcAAJGGihwA4A4OrchJ5AAAV2CMHAAAO3NoRc4YOQAANkZFDgBwB4dW5CRyAIArOHWMnNY6AAA2RkUOAHAHWusAANgXrXUAABBxqMgBAO5Aax0AABtzaCKntQ4AgI1ZmsgLCws1cOBAxcfHq2PHjho/frxOnjxpZUgAAIfyhGCLRJYm8n379ik/P18HDx7Uzp07dfXqVT344IOqqqqyMiwAgBMZIdgikKVj5Nu3b6/z86pVq9SxY0cdOXJE999/v0VRAQCciMfPwqCsrEySlJycbHEkAADYQ8TMWvf7/SooKNDQoUPVu3fvBo+pqalRTU1N4Ofy8vJwhQcAsDtmrbes/Px8nThxQuvWrbvuMYWFhUpMTAxs6enpYYwQAGB7DhsflyIkkU+bNk1bt27Vnj171KVLl+seN2fOHJWVlQW2kpKSMEYJAEDksbS1bhiGnnrqKW3cuFF79+5VZmbmDY/3er3yer1hig4A4CROnexmaSLPz8/X2rVrtXnzZsXHx6u0tFSSlJiYqNjYWCtDAwA4DWPkoVdUVKSysjINHz5cqampgW39+vVWhgUAQEgtWrRIHo9HBQUFIf9uy1vrAACEg1Wt9cOHD2v58uXq27dv8Be/gYiY7AYAQIuz4M1ulZWVys3N1cqVK5WUlGT+HhpAIgcAoIXk5+dr9OjRys7ObrFrRMwLYQAAaEmhaq1/+2Vk13uiat26dTp69KgOHz4c/EWbgIocAOAOIWqtp6en13k5WWFhYb1LlZSUaMaMGVqzZo1iYmJa9LaoyAEA7hCix89KSkqUkJAQ2N1QNX7kyBFdunRJd999d2Cfz+fT/v379eqrr6qmpkZRUVEmgvkLEjkAAM2QkJBQJ5E3ZOTIkTp+/HidfVOmTFGPHj00e/bskCVxiUQOAHCJcD5+Fh8fX28BsHbt2iklJeW6C4MFi0QOAHAHh77ZjUQOAEAY7N27t0W+l0QOAHAFj2HIY+KNombObUkkcgCAOzi0tc5z5AAA2BgVOQDAFViPHAAAO6O1DgAAIg0VOQDAFWitAwBgZw5trZPIAQCu4NSKnDFyAABsjIocAOAOtNYjV+tPv1DrVvXXg7Wrtkq2OoQWEGt1ACHmxGaW8+6pWs75d6HWZasDCDH/l23Cer1IbY+b4by/uQAAuIgjKnIAABplGN9sZs6PQCRyAIArMGsdAABEHCpyAIA7MGsdAAD78vi/2cycH4lorQMAYGNU5AAAd6C1DgCAfTl11jqJHADgDg59jpwxcgAAbIyKHADgCrTWAQCwM4dOdqO1DgCAjVGRAwBcgdY6AAB2xqx1AAAQaajIAQCuQGsdAAA7Y9Y6AACINFTkAABXcGpr3dKKfP/+/Ro7dqzS0tLk8Xi0adMmK8MBADiZ3zC/RSBLE3lVVZX69eunpUuXWhkGAMANjBBsEcjS1npOTo5ycnKsDAEAAFtjjBwA4AoemRwjD1kkoWWrRF5TU6OamprAz+Xl5RZGAwCwFd7sZr3CwkIlJiYGtvT0dKtDAgDAUrZK5HPmzFFZWVlgKykpsTokAIBN1D5+ZmaLRLZqrXu9Xnm9XqvDAADYkUPf7GZpIq+srNTp06cDP585c0bHjh1TcnKyunbtamFkAADYg6WJvLi4WCNGjAj8PHPmTElSXl6eVq1aZVFUAAAn8hiGPCYmrJk5tyVZmsiHDx8uI0L/YAAADuP/82bm/Ahkq8luAACgLltNdgMAIFi01gEAsDNmrQMAYGO82Q0AAEQaKnIAgCuYfTsbb3YDAMBKtNYBAEBTFRYWauDAgYqPj1fHjh01fvx4nTx5MuTXIZEDAFzB4ze/Nce+ffuUn5+vgwcPaufOnbp69aoefPBBVVVVhfS+aK0DANwhzK317du31/l51apV6tixo44cOaL7778/+Di+hUQOAEAzlJeX1/m5qStzlpWVSZKSk5NDGg+tdQCAOxgh2CSlp6crMTExsBUWFjZ6ab/fr4KCAg0dOlS9e/cO6W1RkQMAXCFUr2gtKSlRQkJCYH9TqvH8/HydOHFCBw4cCPr610MiBwCgGRISEuok8sZMmzZNW7du1f79+9WlS5eQx0MiBwC4Q5gnuxmGoaeeekobN27U3r17lZmZGfy1b4BEDgBwB0Pm1hRv5u8A+fn5Wrt2rTZv3qz4+HiVlpZKkhITExUbG2sikLqY7AYAcIXaMXIzW3MUFRWprKxMw4cPV2pqamBbv359SO+LihwAgBZghOmVriRyAIA7GDI5Rh6ySEKKRA4AcAeHLpriiET+9ScXJE8bq8MIGUf8T/mWtgrtm4ysF7qJKpHDiVNmnHdP1Wr8mWVbqY7M5GgnTswZAADU55fkMXl+BCKRAwBcIVRvdos0zus7AQDgIlTkAAB3YLIbAAA25tBETmsdAAAboyIHALiDQytyEjkAwB14/AwAAPvi8TMAABBxqMgBAO7AGDkAADbmNySPiWTsj8xETmsdAAAboyIHALgDrXUAAOzMZCJXZCZyWusAANgYFTkAwB1orQMAYGN+Q6ba48xaBwAAoUZFDgBwB8P/zWbm/AhEIgcAuINDx8gjorW+dOlSdevWTTExMRo8eLAOHTpkdUgAAKfxG+a3CGR5Il+/fr1mzpypefPm6ejRo+rXr59GjRqlS5cuWR0aAAARz/JEvnjxYj322GOaMmWKevbsqWXLlqlt27b6+c9/bnVoAAAnqW2tm9kikKWJ/MqVKzpy5Iiys7MD+1q1aqXs7Gy9++679Y6vqalReXl5nQ0AgCYxZDKRW30DDbM0kX/22Wfy+Xzq1KlTnf2dOnVSaWlpveMLCwuVmJgY2NLT08MVKgAAEcny1npzzJkzR2VlZYGtpKTE6pAAAHbh0Na6pY+f3XTTTYqKitLFixfr7L948aI6d+5c73iv1yuv1xuu8AAATuL3SzLxLLg/Mp8jt7Qij46O1oABA7Rr167APr/fr127dmnIkCEWRgYAgD1Y/kKYmTNnKi8vT1lZWRo0aJCWLFmiqqoqTZkyxerQAABO4tAXwlieyCdOnKjLly9r7ty5Ki0t1V133aXt27fXmwAHAIApJPKWM23aNE2bNs3qMAAAsJ2ISOQAALQ4hy5jSiIHALiCYfhlmFjBzMy5LYlEDgBwB8PkwicROkZuqxfCAACAuqjIAQDuYJgcI4/QipxEDgBwB79f8pgY547QMXJa6wAA2BgVOQDAHWitAwBgX4bfL8NEaz1SHz+jtQ4AgI1RkQMA3IHWOgAANuY3JI/zEjmtdQAAbIyKHADgDoYhycxz5JFZkZPIAQCuYPgNGSZa60aEJnJa6wAAdzD85rcgLF26VN26dVNMTIwGDx6sQ4cOhfS2SOQAALSQ9evXa+bMmZo3b56OHj2qfv36adSoUbp06VLIrkEiBwC4guE3TG/NtXjxYj322GOaMmWKevbsqWXLlqlt27b6+c9/HrL7IpEDANwhzK31K1eu6MiRI8rOzg7sa9WqlbKzs/Xuu++G7LZsPdmtduLB17pq6hn/iOOvsTqCkPv662qrQwipr696rA4h5HxXnPd7va/Gef+f/NWR+ZrQYPmrv/m3IRwTyczmiq91VZJUXl5eZ7/X65XX6613/GeffSafz6dOnTrV2d+pUyd98MEHwQfyLbZO5BUVFZKkA3rb4khC7BOrA2gBTrwnACFTUVGhxMTEFvnu6Ohode7cWQdKzeeKuLg4paen19k3b948zZ8/3/R3B8vWiTwtLU0lJSWKj4+Xx9Oyv3mXl5crPT1dJSUlSkhIaNFrhYPT7kfinuyCe4p84bwfwzBUUVGhtLS0FrtGTEyMzpw5oytXrpj+LsMw6uWbhqpxSbrpppsUFRWlixcv1tl/8eJFde7c2XQstWydyFu1aqUuXbqE9ZoJCQmO+Itay2n3I3FPdsE9Rb5w3U9LVeLXiomJUUxMTItf51rR0dEaMGCAdu3apfHjx0uS/H6/du3apWnTpoXsOrZO5AAARLKZM2cqLy9PWVlZGjRokJYsWaKqqipNmTIlZNcgkQMA0EImTpyoy5cva+7cuSotLdVdd92l7du315sAZwaJvIm8Xq/mzZt33bEQu3Ha/Ujck11wT5HPafdjtWnTpoW0lf5tHiNSXx4LAAAa5bwHRwEAcBESOQAANkYiBwDAxkjkAADYGIm8CVp6Ldlw2r9/v8aOHau0tDR5PB5t2rTJ6pBMKyws1MCBAxUfH6+OHTtq/PjxOnnypNVhmVJUVKS+ffsGXsgxZMgQbdu2zeqwQmbRokXyeDwqKCiwOpSgzZ8/Xx6Pp87Wo0cPq8My7fz585o8ebJSUlIUGxurPn36qLi42OqwcAMk8kaEYy3ZcKqqqlK/fv20dOlSq0MJmX379ik/P18HDx7Uzp07dfXqVT344IOqqqqyOrSgdenSRYsWLdKRI0dUXFysBx54QOPGjdMf/vAHq0Mz7fDhw1q+fLn69u1rdSim9erVS59++mlgO3DggNUhmfLFF19o6NChatOmjbZt26b/+Z//0Y9+9CMlJSVZHRpuxMANDRo0yMjPzw/87PP5jLS0NKOwsNDCqEJDkrFx40arwwi5S5cuGZKMffv2WR1KSCUlJRk/+9nPrA7DlIqKCqN79+7Gzp07jWHDhhkzZsywOqSgzZs3z+jXr5/VYYTU7NmzjXvvvdfqMNBMVOQ3EK61ZBFaZWVlkqTk5GSLIwkNn8+ndevWqaqqSkOGDLE6HFPy8/M1evToOn+n7OzUqVNKS0vTLbfcotzcXJ07d87qkEzZsmWLsrKy9PDDD6tjx47q37+/Vq5caXVYaASJ/AZutJZsaWmpRVHhRvx+vwoKCjR06FD17t3b6nBMOX78uOLi4uT1evX9739fGzduVM+ePa0OK2jr1q3T0aNHVVhYaHUoITF48GCtWrVK27dvV1FRkc6cOaP77rsvsLyyHX388ccqKipS9+7dtWPHDj3xxBOaPn26Vq9ebXVouAFe0QpHyc/P14kTJ2w/VilJd9xxh44dO6aysjK98cYbysvL0759+2yZzEtKSjRjxgzt3Lkz7CtQtZScnJzAf/ft21eDBw9WRkaGNmzYoO9973sWRhY8v9+vrKwsLVy4UJLUv39/nThxQsuWLVNeXp7F0eF6qMhvIFxrySI0pk2bpq1bt2rPnj1hX962JURHR+u2227TgAEDVFhYqH79+unll1+2OqygHDlyRJcuXdLdd9+t1q1bq3Xr1tq3b59eeeUVtW7dWj6fz+oQTWvfvr1uv/12nT592upQgpaamlrvF8U777zT9kMGTkciv4Fr15KtVbuWrN3HKp3EMAxNmzZNGzdu1O7du5WZmWl1SC3C7/erpqbG6jCCMnLkSB0/flzHjh0LbFlZWcrNzdWxY8cUFRVldYimVVZW6qOPPlJqaqrVoQRt6NCh9R7d/PDDD5WRkWFRRGgKWuuNCMdasuFUWVlZp2I4c+aMjh07puTkZHXt2tXCyIKXn5+vtWvXavPmzYqPjw/MX0hMTFRsbKzF0QVnzpw5ysnJUdeuXVVRUaG1a9dq79692rFjh9WhBSU+Pr7enIV27dopJSXFtnMZZs2apbFjxyojI0MXLlzQvHnzFBUVpUmTJlkdWtCefvpp3XPPPVq4cKEmTJigQ4cOacWKFVqxYoXVoeFGrJ42bwc/+clPjK5duxrR0dHGoEGDjIMHD1odUtD27NljSKq35eXlWR1a0Bq6H0nGa6+9ZnVoQZs6daqRkZFhREdHGx06dDBGjhxp/Pa3v7U6rJCy++NnEydONFJTU43o6Gjj5ptvNiZOnGicPn3a6rBM+81vfmP07t3b8Hq9Ro8ePYwVK1ZYHRIawTKmAADYGGPkAADYGIkcAAAbI5EDAGBjJHIAAGyMRA4AgI2RyAEAsDESOQAANkYiBwDAxkjkQAR79NFHNX78eKvDABDBSOQAANgYiRwAABsjkQMAYGMkcgAAbIxEDgCAjZHIAQCwMRI5AAA2RiIHAMDGSOQAANiYxzAMw+ogAABAcKjIAQCwMRI5AAA2RiIHAMDGSOQAANgYiRwAABsjkQMAYGMkcgAAbIxEDgCAjZHIAQCwMRI5AAA2RiIHAMDGSOQAANjY/wP404PxB4S1RAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_out at K = 0\n", - "Min and max values: 0.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\n", - "Plotting values of qty_out at K = 0 based on running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\n", - "Min and max values: 10.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_out at K = 1 based on running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\n", - "Min and max values: 11.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running 'stencil_if_zero' on qty_out\n", - "Plotting values of qty_out at K = 0 based on running stencil_if_zero\n", - "Min and max values: 30.0 10.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_out at K = 1 based on running stencil_if_zero\n", - "Min and max values: 30.0 10.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "qty_out = Quantity(data=np.zeros(shape),\n", " dims=[\"I\", \"J\", \"K\"],\n", @@ -1151,65 +476,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_in at K = 0\n", - "Min and max values: 12.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_out at K = 0\n", - "Min and max values: 0.0 0.0\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhMAAAHHCAYAAAAF5NqAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABD4klEQVR4nO3de3hU1b3/8c8kIRNukxAgCdFwq5aL3BMSglYuSQ1KrVQ8BRqPgDlgLUEh2AqUAl6OwarcFImoiLZwQKxXxGgMgkeJXIL5tVDgqMUSgQlYSkKguZDZvz9opk4zCUl2hiHZ79fzrKdkz1p7f3f6tPPN+q61t80wDEMAAACNFODvAAAAQPNGMgEAAEwhmQAAAKaQTAAAAFNIJgAAgCkkEwAAwBSSCQAAYArJBAAAMIVkAgAAmEIyAUvbvn27bDabtm/f7u9QAKDZIplAi7Ru3TrZbDZ3CwkJ0fe//32lp6erqKioSa6xdetWLV68uEnO9V0bNmzQ8uXL692/e/fu+tGPflTj+O9+9zsFBgZqzJgxKisra8II63bs2DH99Kc/VVhYmBwOh2677Tb95S9/uWzXB3D5Bfk7AMCXHn74YfXo0UNlZWX65JNPtHr1am3dulX79+9XmzZtTJ1769atWrVqVZMnFBs2bND+/fs1a9asRp9j/fr1mjJlipKTk/Xmm28qJCSk6QKsQ2lpqUaNGqXi4mLNnz9frVq10rJlyzRixAgVFBSoY8eOlyUOAJcXyQRatJtvvllxcXGSpP/6r/9Sx44dtXTpUr311luaNGmSn6PzjY0bN2ry5MkaPXq03nrrrcuWSEjSs88+qy+++EK7d+/W0KFDJV3876Bfv3566qmn9Nhjj122WABcPpQ5YCmjR4+WJB05cqTOfps3b1ZsbKxat26tTp066c4779SxY8fcn0+ZMkWrVq2SJI9ySl3eeustjR07VtHR0bLb7fre976nRx55RFVVVe4+I0eO1Lvvvqu//vWv7nN279693vf36quv6s4779TIkSP19ttvX9ZEQpJee+01DR061J1ISFLv3r2VlJSkV1999bLGAuDyYWYClvLVV19JUp3T7evWrdPUqVM1dOhQZWZmqqioSCtWrNCnn36qzz//XGFhYbrnnnt0/Phx5eTk6He/+129rr1u3Tq1a9dOGRkZateunbZt26aFCxeqpKRETzzxhCTp17/+tYqLi/XNN99o2bJlkqR27drV6/x/+MMflJqaqhtvvFHvvPOOWrduXa9xpaWl9VpT0apVK4WGhtb6ucvl0h//+EfdfffdNT6Lj4/XBx98oLNnz6p9+/b1igtAM2IALdBLL71kSDI+/PBD49SpU0ZhYaGxceNGo2PHjkbr1q2Nb775xjAMw/joo48MScZHH31kGIZhVFRUGBEREUa/fv2Mf/zjH+7zbdmyxZBkLFy40H1sxowZRkP+J3T+/Pkax+655x6jTZs2RllZmfvY2LFjjW7dutX7vN26dTOio6ONoKAgY+TIkca5c+fqPdYwDGPy5MmGpEu2ESNG1HmeU6dOGZKMhx9+uMZnq1atMiQZhw4dalBsAJoHZibQoiUnJ3v83K1bN61fv15XXXWV1/579+7VyZMntXjxYo8SwdixY9W7d2+9++67euihhxoVy3dnCs6ePavy8nL94Ac/0HPPPadDhw5p4MCBjTqvJJ0+fVoXLlzQ1VdfXe8ZiWq/+tWvdOedd16yX4cOHer8/B//+IckyW631/is+ndZ3QdAy0IygRZt1apV+v73v6+goCBFRkaqV69eCgiofanQX//6V0lSr169anzWu3dvffLJJ42O5cCBA1qwYIG2bdumkpISj8+Ki4sbfV5JSkpKUteuXbV69WqFh4drxYoV9R7bt29f9e3b19T1pX8lS+Xl5TU+qy6jNDTRAdA8kEygRYuPj3fv5vCnM2fOaMSIEXI4HHr44Yf1ve99TyEhIdq3b58efPBBuVwu09d45pln9Pe//10rV65Uhw4d6r1ltbi4uF4zBsHBwQoPD6/18/DwcNntdp04caLGZ9XHoqOj6xUTgOaFZAL4jm7dukmSDh8+7N75Ue3w4cPuzyVdcvfGd23fvl1/+9vf9Prrr+vGG290H/e2q6Qh5/2ugIAAvfLKKyouLtZDDz2k8PBw3XfffZccd//99+vll1++ZL8RI0bU+aTQgIAA9e/fX3v37q3x2a5du9SzZ08WXwItFMkE8B1xcXGKiIhQVlaW7r77bnf9/7333tPBgwe1cOFCd9+2bdtKujjrEBYWVud5AwMDJUmGYbiPVVRU6Nlnn63Rt23bto0ue7Rq1UqvvfaabrrpJs2aNUsdOnTQf/7nf9Y5pqnWTEjSHXfcoblz52rv3r3uGaHDhw9r27ZteuCBB+p3EwCaHZIJ4DtatWqlxx9/XFOnTtWIESM0adIk99bQ7t27a/bs2e6+sbGxkqT77rtPKSkpCgwM1MSJE72ed/jw4erQoYMmT56s++67TzabTb/73e88kovvnnfTpk3KyMjQ0KFD1a5dO9166631voc2bdro3Xff1YgRI3T33XcrNDRUP/7xj2vt31RrJiTpF7/4hZ5//nmNHTtWDzzwgFq1aqWlS5cqMjJSc+bMaZJrALgC+Xs7CeAL1VtD9+zZU2e/f98aWm3Tpk3G4MGDDbvdboSHhxupqanu7aTVLly4YMycOdPo3LmzYbPZLrlN9NNPPzWGDRtmtG7d2oiOjjZ+9atfGe+//36N65eWlho/+9nPjLCwMEPSJbeJduvWzRg7dmyN406n07jmmmuMkJCQGvfnS4WFhcYdd9xhOBwOo127dsaPfvQj44svvrhs1wdw+dkMw8ufRgAAAPXE47QBAIApJBMAAMAUkgkAAGAKyQQAAD60atUqde/eXSEhIUpISNDu3btr7XvgwAGNHz9e3bt3l81m0/Llyxt1zrKyMs2YMUMdO3ZUu3btNH78eBUVFTXlbXkgmQAAwEeqt3kvWrRI+/bt08CBA5WSkqKTJ0967X/+/Hn17NlTS5YsUVRUVKPPOXv2bL3zzjvavHmzduzYoePHj+v222/3yT1KErs5AADwkYSEBA0dOlTPPPOMJMnlcikmJkYzZ87U3Llz6xzbvXt3zZo1S7NmzWrQOYuLi9W5c2dt2LBBd9xxhyTp0KFD6tOnj/Ly8jRs2LAmv89m/dAql8ul48ePq3379o1+BDEAwH8Mw9DZs2cVHR1d50v4zCorK1NFRYXp8xiGUeP7xm63e31bbkVFhfLz8zVv3jz3sYCAACUnJysvL69R16/POfPz81VZWenx1uTevXura9euJBPeHD9+XDExMf4OAwBgUmFhoa6++mqfnLusrEw9urWT82SV6XO1a9dOpaWlHscWLVrk9cV63377raqqqhQZGelxPDIyUocOHWrU9etzTqfTqeDg4BqP+Y+MjJTT6WzUdS+lWScT1S8NunrxAgWEhPg5GgBAQ7nKyvTN4kd9+hK4iooKOU9W6a/53eVo3/jZj5KzLnWL/VqFhYVyOBzu495mJaymWScT1VNNASEhJBMA0IxdjlJ1u/Y2tWvf+Ou4dHGsw+HwSCZq06lTJwUGBtbYRVFUVFTr4sqmOGdUVJQqKipqvITQzHUvhd0cAABLqDJcpltDBAcHKzY2Vrm5ue5jLpdLubm5SkxMbNQ91OecsbGxatWqlUefw4cP6+jRo42+7qU065kJAADqyyVDLjV+A2NjxmZkZGjy5MmKi4tTfHy8li9frnPnzmnq1KmSpLvuuktXXXWVMjMzJV0syfz5z392//vYsWMqKChQu3btdM0119TrnKGhoUpLS1NGRobCw8PlcDg0c+ZMJSYm+mTxpUQyAQCAz0yYMEGnTp3SwoUL5XQ6NWjQIGVnZ7sXUB49etRjF8vx48c1ePBg989PPvmknnzySY0YMULbt2+v1zkladmyZQoICND48eNVXl6ulJQUPfvssz67z2b9nImSkhKFhoaq65JHWTMBAM2Qq6xMR+cuUHFxcb3WITRG9XfF8cNXm16AGd3rG5/G2lwxMwEAsIQqw1CVib+fzYxt6ViACQAATGFmAgBgCf5YgGkVJBMAAEtwyVAVyYRPUOYAAACmMDMBALAEyhy+QzIBALAEdnP4DmUOAABgCjMTAABLcP2zmRkP70gmAACWUGVyN4eZsS0dyQQAwBKqjIvNzHh4x5oJAABgCjMTAABLYM2E75BMAAAswSWbqmQzNR7eUeYAAACm+D2ZOHbsmO6880517NhRrVu3Vv/+/bV3715/hwUAaGFchvkG7/xa5vj73/+u66+/XqNGjdJ7772nzp0764svvlCHDh38GRYAoAWqMlnmMDO2pfNrMvH4448rJiZGL730kvtYjx49/BgRAABoKL+WOd5++23FxcXpP/7jPxQREaHBgwfr+eef92dIAIAWqnpmwkyDd35NJv7yl79o9erVuvbaa/X+++/r3nvv1X333aeXX37Za//y8nKVlJR4NAAA6sNl2Ew3eOfXMofL5VJcXJwee+wxSdLgwYO1f/9+ZWVlafLkyTX6Z2Zm6qGHHrrcYQIAgDr4dWaiS5cu6tu3r8exPn366OjRo177z5s3T8XFxe5WWFh4OcIEALQAlDl8x68zE9dff70OHz7scez//u//1K1bN6/97Xa77Hb75QgNANDCVClAVSb+hq5qwlhaGr8mE7Nnz9bw4cP12GOP6ac//al2796tNWvWaM2aNf4MCwDQAhkm1z0YrJmolV/LHEOHDtUbb7yh//mf/1G/fv30yCOPaPny5UpNTfVnWAAAoAH8/m6OH/3oR/rRj37k7zAAAC0cD63yHb8nEwAAXA5VRoCqDBNrJnicdq38/m4OAADQvDEzAQCwBJdscpn4G9olpiZqQzIBALAE1kz4DmUOAABgCjMTAABLML8AkzJHbUgmAACWcHHNRONLFWbGtnSUOQAAgCnMTAAALMFl8t0c7OaoHTMTAABLqF4zYaY1xqpVq9S9e3eFhIQoISFBu3fvrrP/5s2b1bt3b4WEhKh///7aunWrx+c2m81re+KJJ9x9unfvXuPzJUuWNCr++iCZAABYgksBpltDbdq0SRkZGVq0aJH27dungQMHKiUlRSdPnvTaf+fOnZo0aZLS0tL0+eefa9y4cRo3bpz279/v7nPixAmPtnbtWtlsNo0fP97jXA8//LBHv5kzZzY4/voimQAAwEeWLl2qadOmaerUqerbt6+ysrLUpk0brV271mv/FStWaMyYMfrlL3+pPn366JFHHtGQIUP0zDPPuPtERUV5tLfeekujRo1Sz549Pc7Vvn17j35t27b12X2STAAALKHKsJluklRSUuLRysvLvV6voqJC+fn5Sk5Odh8LCAhQcnKy8vLyvI7Jy8vz6C9JKSkptfYvKirSu+++q7S0tBqfLVmyRB07dtTgwYP1xBNP6MKFC/X6PTUGCzABAJZQZXIBZtU/F2DGxMR4HF+0aJEWL15co/+3336rqqoqRUZGehyPjIzUoUOHvF7D6XR67e90Or32f/nll9W+fXvdfvvtHsfvu+8+DRkyROHh4dq5c6fmzZunEydOaOnSpXXeY2ORTAAA0ACFhYVyOBzun+12u99iWbt2rVJTUxUSEuJxPCMjw/3vAQMGKDg4WPfcc48yMzN9Ei/JBADAElxGgFwmnoDp+ucTMB0Oh0cyUZtOnTopMDBQRUVFHseLiooUFRXldUxUVFS9+//v//6vDh8+rE2bNl0yloSEBF24cEFff/21evXqdcn+DcWaCQCAJVSXOcy0hggODlZsbKxyc3Pdx1wul3Jzc5WYmOh1TGJiokd/ScrJyfHa/8UXX1RsbKwGDhx4yVgKCgoUEBCgiIiIBt1DfTEzAQCAj2RkZGjy5MmKi4tTfHy8li9frnPnzmnq1KmSpLvuuktXXXWVMjMzJUn333+/RowYoaeeekpjx47Vxo0btXfvXq1Zs8bjvCUlJdq8ebOeeuqpGtfMy8vTrl27NGrUKLVv3155eXmaPXu27rzzTnXo0MEn90kyAQCwBJfk3pHR2PENNWHCBJ06dUoLFy6U0+nUoEGDlJ2d7V5kefToUQUE/GvGY/jw4dqwYYMWLFig+fPn69prr9Wbb76pfv36eZx348aNMgxDkyZNqnFNu92ujRs3avHixSovL1ePHj00e/Zsj3UUTc1mGM33NWglJSUKDQ1V1yWPKuDfFp8AAK58rrIyHZ27QMXFxfVah9AY1d8Vq/cNVet2jf8b+h+lF3TvkD0+jbW5Ys0EAAAwhTIHAMASzLxfo3o8vCOZAABYgks2uWRmzUTjx7Z0JBMAAEtgZsJ3+M0AAABTmJkAAFiC+Xdz8Pd3bUgmAACW4DJscpl5zoSJsS0daRYAADCFmQkAgCW4TJY5XPz9XSuSCQCAJZh/ayjJRG34zQAAAFOYmQAAWEKVbKoy8eApM2NbOpIJAIAlUObwHX4zAADAFGYmAACWUCVzpYqqpgulxSGZAABYAmUO3yGZAABYAi/68h1+MwAAwBRmJgAAlmDIJpeJNRMGW0NrRTIBALAEyhy+w28GAACYwswEAMASeAW57/h1ZmLx4sWy2WwerXfv3v4MCQDQQlX9862hZhq88/vMxHXXXacPP/zQ/XNQkN9DAgAADeD3b+6goCBFRUX5OwwAQAtHmcN3/D5n88UXXyg6Olo9e/ZUamqqjh49Wmvf8vJylZSUeDQAAOrDpQDTDd759TeTkJCgdevWKTs7W6tXr9aRI0f0gx/8QGfPnvXaPzMzU6Ghoe4WExNzmSMGAAD/zq9ljptvvtn97wEDBighIUHdunXTq6++qrS0tBr9582bp4yMDPfPJSUlJBQAgHqpMmyqMlGqMDO2pfP7monvCgsL0/e//319+eWXXj+32+2y2+2XOSoAQEvAmgnfuaIKQKWlpfrqq6/UpUsXf4cCAGhhjH++NbSxzeAJmLXy62/mgQce0I4dO/T1119r586d+slPfqLAwEBNmjTJn2EBAIAG8GuZ45tvvtGkSZP0t7/9TZ07d9YNN9ygzz77TJ07d/ZnWACAFqhKNlWZeFmXmbEtnV+TiY0bN/rz8gAAC3EZ5tY9uIwmDKaFoQAEAABMuaJ2cwAA4CvVCynNjId3/GYAAJbgks10a4xVq1ape/fuCgkJUUJCgnbv3l1n/82bN6t3794KCQlR//79tXXrVo/Pp0yZUuMlmWPGjPHoc/r0aaWmpsrhcCgsLExpaWkqLS1tVPz1QTIBAICPbNq0SRkZGVq0aJH27dungQMHKiUlRSdPnvTaf+fOnZo0aZLS0tL0+eefa9y4cRo3bpz279/v0W/MmDE6ceKEu/3P//yPx+epqak6cOCAcnJytGXLFn388ceaPn26z+6TZAIAYAnVT8A00xpq6dKlmjZtmqZOnaq+ffsqKytLbdq00dq1a732X7FihcaMGaNf/vKX6tOnjx555BENGTJEzzzzjEc/u92uqKgod+vQoYP7s4MHDyo7O1svvPCCEhISdMMNN+jpp5/Wxo0bdfz48QbfQ32QTAAALMHMA6sas96ioqJC+fn5Sk5Odh8LCAhQcnKy8vLyvI7Jy8vz6C9JKSkpNfpv375dERER6tWrl+6991797W9/8zhHWFiY4uLi3MeSk5MVEBCgXbt2Nege6osFmAAANMC/v7G6tlc9fPvtt6qqqlJkZKTH8cjISB06dMjruZ1Op9f+TqfT/fOYMWN0++23q0ePHvrqq680f/583XzzzcrLy1NgYKCcTqciIiI8zhEUFKTw8HCP8zQlkgkAgCW4ZPLdHP9cgPnvL5hctGiRFi9ebCa0Bpk4caL73/3799eAAQP0ve99T9u3b1dSUtJli+O7SCYAAJZgmNiRUT1ekgoLC+VwONzHa3sBZadOnRQYGKiioiKP40VFRYqKivI6JioqqkH9Jalnz57q1KmTvvzySyUlJSkqKqrGAs8LFy7o9OnTdZ7HDNZMAAAsofqtoWaaJDkcDo9WWzIRHBys2NhY5ebm/isGl0u5ublKTEz0OiYxMdGjvyTl5OTU2l+6+GqKv/3tb+6XZCYmJurMmTPKz89399m2bZtcLpcSEhLq98tqIJIJAAB8JCMjQ88//7xefvllHTx4UPfee6/OnTunqVOnSpLuuusuzZs3z93//vvvV3Z2tp566ikdOnRIixcv1t69e5Weni7p4tu1f/nLX+qzzz7T119/rdzcXN1222265pprlJKSIknq06ePxowZo2nTpmn37t369NNPlZ6erokTJyo6Oton90mZAwBgCf54AuaECRN06tQpLVy4UE6nU4MGDVJ2drZ7keXRo0cVEPCv8w4fPlwbNmzQggULNH/+fF177bV688031a9fP0lSYGCg/vjHP+rll1/WmTNnFB0drZtuukmPPPKIxwzJ+vXrlZ6erqSkJAUEBGj8+PFauXJlo+/9UmyGYTTbV5eUlJQoNDRUXZc8qoCQEH+HAwBoIFdZmY7OXaDi4mKPdQhNqfq74rYP7lartsGNPk/luQq9ddNan8baXFHmAAAAplDmAABYgpn3a1SPh3ckEwAAS/jujozGjod3lDkAAIApzEwAACyBmQnfIZkAAFgCyYTvUOYAAACmMDMBALAEZiZ8h2QCAGAJhsxt72y2T3i8DEgmAACWwMyE77BmAgAAmMLMBADAEpiZ8B2SCQCAJZBM+A5lDgAAYAozEwAAS2BmwndIJgAAlmAYNhkmEgIzY1s6yhwAAMAUZiYAAJbgks3UQ6vMjG3pSCYAAJbAmgnfocwBAABMYWYCAGAJLMD0HZIJAIAlUObwHZIJAIAlMDPhO6yZAAAApjAzAQCwBMNkmYOZidqRTAAALMGQZBjmxsM7yhwAAMAUZiYAAJbgkk02noDpEyQTAABLYDeH71wxZY4lS5bIZrNp1qxZ/g4FAAA0wBUxM7Fnzx4999xzGjBggL9DAQC0UC7DJhsPrfIJv89MlJaWKjU1Vc8//7w6dOjg73AAAC2UYZhv8M7vycSMGTM0duxYJScnX7JveXm5SkpKPBoAAPAvv5Y5Nm7cqH379mnPnj316p+ZmamHHnrIx1EBAFoiFmD6jt9mJgoLC3X//fdr/fr1CgkJqdeYefPmqbi42N0KCwt9HCUAoKWoTibMNHjnt2QiPz9fJ0+e1JAhQxQUFKSgoCDt2LFDK1euVFBQkKqqqmqMsdvtcjgcHg0AgPqofmuomdYYq1atUvfu3RUSEqKEhATt3r27zv6bN29W7969FRISov79+2vr1q3uzyorK/Xggw+qf//+atu2raKjo3XXXXfp+PHjHufo3r27bDabR1uyZEmj4q8PvyUTSUlJ+tOf/qSCggJ3i4uLU2pqqgoKChQYGOiv0AAAaBKbNm1SRkaGFi1apH379mngwIFKSUnRyZMnvfbfuXOnJk2apLS0NH3++ecaN26cxo0bp/3790uSzp8/r3379uk3v/mN9u3bp9dff12HDx/Wj3/84xrnevjhh3XixAl3mzlzps/u029rJtq3b69+/fp5HGvbtq06duxY4zgAAGaZ3ZHRmLFLly7VtGnTNHXqVElSVlaW3n33Xa1du1Zz586t0X/FihUaM2aMfvnLX0qSHnnkEeXk5OiZZ55RVlaWQkNDlZOT4zHmmWeeUXx8vI4ePaquXbu6j7dv315RUVEND7oR/L6bAwCAy+FiMmFmzUTDrldRUaH8/HyP3YoBAQFKTk5WXl6e1zF5eXk1djempKTU2l+SiouLZbPZFBYW5nF8yZIl6tixowYPHqwnnnhCFy5caNgNNMAV8dCqatu3b/d3CAAA1OnfH0tgt9tlt9tr9Pv2229VVVWlyMhIj+ORkZE6dOiQ13M7nU6v/Z1Op9f+ZWVlevDBBzVp0iSPdYT33XefhgwZovDwcO3cuVPz5s3TiRMntHTp0nrdY0NdUckEAAC+0lRbQ2NiYjyOL1q0SIsXLzYTWqNUVlbqpz/9qQzD0OrVqz0+y8jIcP97wIABCg4O1j333KPMzEyviY9ZJBMAAEsw/tnMjJcuPtrgu7MAtX05d+rUSYGBgSoqKvI4XlRUVOtahqioqHr1r04k/vrXv2rbtm2X3N2YkJCgCxcu6Ouvv1avXr3q7NsYrJkAAKAB/v0RBbUlE8HBwYqNjVVubq77mMvlUm5urhITE72OSUxM9OgvSTk5OR79qxOJL774Qh9++KE6dux4yZgLCgoUEBCgiIiI+txigzEzAQCwBH88ATMjI0OTJ09WXFyc4uPjtXz5cp07d869u+Ouu+7SVVddpczMTEnS/fffrxEjRuipp57S2LFjtXHjRu3du1dr1qyRdDGRuOOOO7Rv3z5t2bJFVVVV7vUU4eHhCg4OVl5ennbt2qVRo0apffv2ysvL0+zZs3XnnXf67B1YJBMAAGtoqjpHA0yYMEGnTp3SwoUL5XQ6NWjQIGVnZ7sXWR49elQBAf8qEgwfPlwbNmzQggULNH/+fF177bV688033Y9MOHbsmN5++21J0qBBgzyu9dFHH2nkyJGy2+3auHGjFi9erPLycvXo0UOzZ8/2WEfR1GyG0Xzfg1ZSUqLQ0FB1XfKoAur5SG4AwJXDVVamo3MXqLi42GdPNa7+rui57tcKaNP47wrX+TL9Zcp/+zTW5oo1EwAAwBTKHAAAS/DHEzCtgmQCAGAJvILcdyhzAAAAU5iZAABYg2G72MyMh1ckEwAAS2DNhO9Q5gAAAKYwMwEAsAY/PLTKKkgmAACWwG4O36HMAQAATGFmAgBgHZQqfIJkAgBgCZQ5fIdkAgBgDSzA9BnWTAAAAFOYmQAAWITtn83MeHhDMgEAsAbKHD5DmQMAAJjCzAQAwBqYmfAZkgkAgDXw1lCfocwBAABMYWYCAGAJvILcd0gmAADWwJoJn6HMAQAATGFmAgBgDSzA9BmSCQCAJdiMi83MeHhHMgEAsAbWTPgMayYAAIApzEwAAKyBNRM+QzIBALAGyhw+Q5kDAACYwswEAMAamJnwGZIJAIA1kEz4DGUOAABgCjMTAABrYDeHz5BMAAAsgSdg+g5lDgAAYIpfk4nVq1drwIABcjgccjgcSkxM1HvvvefPkAAALZXRBK0RVq1ape7duyskJEQJCQnavXt3nf03b96s3r17KyQkRP3799fWrVs9b8MwtHDhQnXp0kWtW7dWcnKyvvjiC48+p0+fVmpqqhwOh8LCwpSWlqbS0tLG3UA9+DWZuPrqq7VkyRLl5+dr7969Gj16tG677TYdOHDAn2EBANAkNm3apIyMDC1atEj79u3TwIEDlZKSopMnT3rtv3PnTk2aNElpaWn6/PPPNW7cOI0bN0779+939/ntb3+rlStXKisrS7t27VLbtm2VkpKisrIyd5/U1FQdOHBAOTk52rJliz7++GNNnz7dZ/dpMwzjiqoChYeH64knnlBaWtol+5aUlCg0NFRdlzyqgJCQyxAdAKApucrKdHTuAhUXF8vhcPjkGtXfFd0eN/dd4Sor018fbFisCQkJGjp0qJ555pmL53C5FBMTo5kzZ2ru3Lk1+k+YMEHnzp3Tli1b3MeGDRumQYMGKSsrS4ZhKDo6WnPmzNEDDzwgSSouLlZkZKTWrVuniRMn6uDBg+rbt6/27NmjuLg4SVJ2drZuueUWffPNN4qOjm7076A29VqAefvtt1/6REFBioqK0g9/+EPdeuutDQ6kqqpKmzdv1rlz55SYmOi1T3l5ucrLy90/l5SUNPg6AACY8e/fPXa7XXa7vUa/iooK5efna968ee5jAQEBSk5OVl5entdz5+XlKSMjw+NYSkqK3nzzTUnSkSNH5HQ6lZyc7P48NDRUCQkJysvL08SJE5WXl6ewsDB3IiFJycnJCggI0K5du/STn/ykwfd8KfUqc4SGhl6ytW7dWl988YUmTJighQsX1juAP/3pT2rXrp3sdrt+/vOf64033lDfvn299s3MzPS4ZkxMTL2vAwCwuOqtoWaapJiYGI/voszMTK+X+/bbb1VVVaXIyEiP45GRkXI6nV7HOJ3OOvtX/+el+kRERHh8HhQUpPDw8Fqva1a9ZiZeeumlep9wy5Yt+sUvfqGHH364Xv179eqlgoICFRcX67XXXtPkyZO1Y8cOrwnFvHnzPDK2kpISEgoAQP000RMwCwsLPcoc3mYlrKbJnzNxww03eEytXEpwcLCuueYaSVJsbKz27NmjFStW6LnnnqvRt7apJAAALpfqHYiX0qlTJwUGBqqoqMjjeFFRkaKioryOiYqKqrN/9X8WFRWpS5cuHn0GDRrk7vPvCzwvXLig06dP13pds5p8N0dYWJhef/31Ro93uVwe6yIAAGgSl3lraHBwsGJjY5Wbm+s+5nK5lJubW+vawMTERI/+kpSTk+Pu36NHD0VFRXn0KSkp0a5du9x9EhMTdebMGeXn57v7bNu2TS6XSwkJCQ27iXry6xMw582bp5tvvlldu3bV2bNntWHDBm3fvl3vv/++P8MCALRA/ngCZkZGhiZPnqy4uDjFx8dr+fLlOnfunKZOnSpJuuuuu3TVVVe5113cf//9GjFihJ566imNHTtWGzdu1N69e7VmzZqLMdhsmjVrlh599FFde+216tGjh37zm98oOjpa48aNkyT16dNHY8aM0bRp05SVlaXKykqlp6dr4sSJPtnJIfk5mTh58qTuuusunThxQqGhoRowYIDef/99/fCHP/RnWAAANIkJEybo1KlTWrhwoZxOpwYNGqTs7Gz3AsqjR48qIOBfRYLhw4drw4YNWrBggebPn69rr71Wb775pvr16+fu86tf/Urnzp3T9OnTdebMGd1www3Kzs5WyHe2va5fv17p6elKSkpSQECAxo8fr5UrV/rsPq+450w0BM+ZAIDm7XI+Z6L7o/9t+jkTXy/4tU9jba540RcAwBqaaDcHauJFXwAAwBRmJgAAlsAryH2HZAIAYA3feYplo8fDK5IJAIA1sGbCZ1gzAQAATGFmAgBgCayZ8B2SCQCANVDm8BnKHAAAwBRmJgAA1mCyzMHMRO1IJgAA1kCZw2cocwAAAFOYmQAAWAMzEz5DMgEAsAS2hvoOZQ4AAGAKyQQAADCFMgcAwBpYM+EzJBMAAEtgzYTvUOYAAACmMDMBALAOZhd8gmQCAGANrJnwGcocAADAFGYmAACWwAJM3yGZAABYA2UOn6HMAQAATGFmAgBgCZQ5fIdkAgBgDZQ5fIYyBwAAMIWZCQCANTAz4TMkEwAAS2DNhO+QTAAArIGZCZ9hzQQAADCFmQkAgDUwM+EzJBMAAEtgzYTvUOYAAACmkEwAAKzBaILmI6dPn1ZqaqocDofCwsKUlpam0tLSOseUlZVpxowZ6tixo9q1a6fx48erqKjI/fn/+3//T5MmTVJMTIxat26tPn36aMWKFR7n2L59u2w2W43mdDobFD9lDgCAJVzJZY7U1FSdOHFCOTk5qqys1NSpUzV9+nRt2LCh1jGzZ8/Wu+++q82bNys0NFTp6em6/fbb9emnn0qS8vPzFRERod///veKiYnRzp07NX36dAUGBio9Pd3jXIcPH5bD4XD/HBER0aD4SSYAAPCjgwcPKjs7W3v27FFcXJwk6emnn9Ytt9yiJ598UtHR0TXGFBcX68UXX9SGDRs0evRoSdJLL72kPn366LPPPtOwYcN09913e4zp2bOn8vLy9Prrr9dIJiIiIhQWFtboe6DMAQCwhiYqc5SUlHi08vJyU2Hl5eUpLCzMnUhIUnJysgICArRr1y6vY/Lz81VZWank5GT3sd69e6tr167Ky8ur9VrFxcUKDw+vcXzQoEHq0qWLfvjDH7pnNhqCZAIAYA1NlEzExMQoNDTU3TIzM02F5XQ6a5QVgoKCFB4eXuvaBafTqeDg4BqzCZGRkbWO2blzpzZt2qTp06e7j3Xp0kVZWVn6wx/+oD/84Q+KiYnRyJEjtW/fvgbdA2UOAAAaoLCw0GN9gd1u99pv7ty5evzxx+s818GDB5s0ttrs379ft912mxYtWqSbbrrJfbxXr17q1auX++fhw4frq6++0rJly/S73/2u3uf3azKRmZmp119/XYcOHVLr1q01fPhwPf744x43BgBAU7D9s5kZL0kOh8MjmajNnDlzNGXKlDr79OzZU1FRUTp58qTH8QsXLuj06dOKioryOi4qKkoVFRU6c+aMx+xEUVFRjTF//vOflZSUpOnTp2vBggWXjDs+Pl6ffPLJJft9l1+TiR07dmjGjBkaOnSoLly4oPnz5+umm27Sn//8Z7Vt29afoQEAWprL/ATMzp07q3Pnzpfsl5iYqDNnzig/P1+xsbGSpG3btsnlcikhIcHrmNjYWLVq1Uq5ubkaP368pIs7Mo4eParExER3vwMHDmj06NGaPHmy/vu//7tecRcUFKhLly716lvNr8lEdna2x8/r1q1TRESE8vPzdeONN/opKgBAS3Slbg3t06ePxowZo2nTpikrK0uVlZVKT0/XxIkT3Ts5jh07pqSkJL3yyiuKj49XaGio0tLSlJGRofDwcDkcDs2cOVOJiYkaNmyYpIuljdGjRyslJUUZGRnutRSBgYHuJGf58uXq0aOHrrvuOpWVlemFF17Qtm3b9MEHHzToHq6oNRPFxcWS5HWlKQAALdX69euVnp6upKQkBQQEaPz48Vq5cqX788rKSh0+fFjnz593H1u2bJm7b3l5uVJSUvTss8+6P3/ttdd06tQp/f73v9fvf/979/Fu3brp66+/liRVVFRozpw5OnbsmNq0aaMBAwboww8/1KhRoxoUv80wjCviaeMul0s//vGPdebMmVprNeXl5R5bcEpKShQTE6OuSx5VQEjI5QoVANBEXGVlOjp3gYqLi+u1DqExSkpKFBoaquvueUyB9sZ/V1SVl+nAc/N9GmtzdcVsDZ0xY4b279+vjRs31tonMzPTYztOTEzMZYwQANDsXYGP0m4JrohkIj09XVu2bNFHH32kq6++utZ+8+bNU3FxsbsVFhZexigBAIA3fl0zYRiGZs6cqTfeeEPbt29Xjx496uxvt9tr3c8LAEBdrtQFmC2BX5OJGTNmaMOGDXrrrbfUvn1790rT0NBQtW7d2p+hAQBamsu8NdRK/FrmWL16tYqLizVy5Eh16dLF3TZt2uTPsAAAQAP4vcwBAMDlQJnDd66o50wAAOAzlDl85orYzQEAAJovZiYAAJZAmcN3SCYAANZAmcNnSCYAANZAMuEzrJkAAACmMDMBALAE1kz4DskEAMAaKHP4DGUOAABgCjMTAABLsBmGbCaevGxmbEtHMgEAsAbKHD5DmQMAAJjCzAQAwBLYzeE7JBMAAGugzOEzlDkAAIApzEwAACyBMofvkEwAAKyBMofPkEwAACyBmQnfYc0EAAAwhZkJAIA1UObwGZIJAIBlUKrwDcocAADAFGYmAADWYBgXm5nx8IpkAgBgCezm8B3KHAAAwBRmJgAA1sBuDp8hmQAAWILNdbGZGQ/vKHMAAABTmJkAAFgDZQ6fYWYCAGAJ1bs5zDRfOX36tFJTU+VwOBQWFqa0tDSVlpbWOaasrEwzZsxQx44d1a5dO40fP15FRUWe92yz1WgbN2706LN9+3YNGTJEdrtd11xzjdatW9fg+EkmAADWUP2cCTPNR1JTU3XgwAHl5ORoy5Yt+vjjjzV9+vQ6x8yePVvvvPOONm/erB07duj48eO6/fbba/R76aWXdOLECXcbN26c+7MjR45o7NixGjVqlAoKCjRr1iz913/9l95///0GxU+ZAwAAPzp48KCys7O1Z88excXFSZKefvpp3XLLLXryyScVHR1dY0xxcbFefPFFbdiwQaNHj5Z0MWno06ePPvvsMw0bNszdNywsTFFRUV6vnZWVpR49euipp56SJPXp00effPKJli1bppSUlHrfAzMTAABLaKoyR0lJiUcrLy83FVdeXp7CwsLciYQkJScnKyAgQLt27fI6Jj8/X5WVlUpOTnYf6927t7p27aq8vDyPvjNmzFCnTp0UHx+vtWvXyvjODEteXp7HOSQpJSWlxjkuhWQCAGANRhM0STExMQoNDXW3zMxMU2E5nU5FRER4HAsKClJ4eLicTmetY4KDgxUWFuZxPDIy0mPMww8/rFdffVU5OTkaP368fvGLX+jpp5/2OE9kZGSNc5SUlOgf//hHve+BMgcAAA1QWFgoh8Ph/tlut3vtN3fuXD3++ON1nuvgwYNNGtu/+81vfuP+9+DBg3Xu3Dk98cQTuu+++5r0OiQTAABLaKp3czgcDo9kojZz5szRlClT6uzTs2dPRUVF6eTJkx7HL1y4oNOnT9e61iEqKkoVFRU6c+aMx+xEUVFRrWMkKSEhQY888ojKy8tlt9sVFRVVYwdIUVGRHA6HWrduXfcNfgfJBADAGi7zW0M7d+6szp07X7JfYmKizpw5o/z8fMXGxkqStm3bJpfLpYSEBK9jYmNj1apVK+Xm5mr8+PGSpMOHD+vo0aNKTEys9VoFBQXq0KGDezYlMTFRW7du9eiTk5NT5zm8IZkAAMCP+vTpozFjxmjatGnKyspSZWWl0tPTNXHiRPdOjmPHjikpKUmvvPKK4uPjFRoaqrS0NGVkZCg8PFwOh0MzZ85UYmKieyfHO++8o6KiIg0bNkwhISHKycnRY489pgceeMB97Z///Od65pln9Ktf/Up33323tm3bpldffVXvvvtug+6BZAIAYAlX8ivI169fr/T0dCUlJSkgIEDjx4/XypUr3Z9XVlbq8OHDOn/+vPvYsmXL3H3Ly8uVkpKiZ5991v15q1attGrVKs2ePVuGYeiaa67R0qVLNW3aNHefHj166N1339Xs2bO1YsUKXX311XrhhRcatC1UkmyG4cOncPhYSUmJQkND1XXJowoICfF3OACABnKVleno3AUqLi6u1zqExqj+rkgc87CCWjX+u+JCZZnyshf6NNbmiq2hAADAFMocAABLuJLLHM2dX2cmPv74Y916662Kjo6WzWbTm2++6c9wAAAtmcsw3+CVX5OJc+fOaeDAgVq1apU/wwAAWEETPQETNfm1zHHzzTfr5ptv9mcIAADAJNZMAAAswSaTayaaLJKWp1klE+Xl5R5vZyspKfFjNACAZuUyPwHTSprV1tDMzEyPN7XFxMT4OyQAACyvWSUT8+bNU3FxsbsVFhb6OyQAQDNRvTXUTIN3zarMYbfba33VKwAAdTK7I4NkolZ+TSZKS0v15Zdfun8+cuSICgoKFB4erq5du/oxMgAAUF9+TSb27t2rUaNGuX/OyMiQJE2ePFnr1q3zU1QAgJbIZhiymVhEaWZsS+fXZGLkyJFqxu8ZAwA0J65/NjPj4VWzWoAJAACuPM1qASYAAI1FmcN3SCYAANbAbg6fIZkAAFgDT8D0GdZMAAAAU5iZAABYgtmnWPIEzNqRTAAArIEyh89Q5gAAAKYwMwEAsASb62IzMx7ekUwAAKyBMofPUOYAAACmMDMBALAGHlrlMyQTAABL4HHavkOZAwAAmMLMBADAGliA6TMkEwAAazAkmdneSS5RK5IJAIAlsGbCd1gzAQAATGFmAgBgDYZMrploskhaHJIJAIA1sADTZyhzAAAAU5iZAABYg0uSzeR4eMXMBADAEqp3c5hpvnL69GmlpqbK4XAoLCxMaWlpKi0trXNMWVmZZsyYoY4dO6pdu3YaP368ioqK3J+vW7dONpvNazt58qQkafv27V4/dzqdDYqfZAIAAD9LTU3VgQMHlJOToy1btujjjz/W9OnT6xwze/ZsvfPOO9q8ebN27Nih48eP6/bbb3d/PmHCBJ04ccKjpaSkaMSIEYqIiPA41+HDhz36/fvnl0KZAwBgDVfoAsyDBw8qOztbe/bsUVxcnCTp6aef1i233KInn3xS0dHRNcYUFxfrxRdf1IYNGzR69GhJ0ksvvaQ+ffros88+07Bhw9S6dWu1bt3aPebUqVPatm2bXnzxxRrni4iIUFhYWKPvgZkJAIA1VCcTZpoP5OXlKSwszJ1ISFJycrICAgK0a9cur2Py8/NVWVmp5ORk97HevXura9euysvL8zrmlVdeUZs2bXTHHXfU+GzQoEHq0qWLfvjDH+rTTz9t8D0wMwEAQAOUlJR4/Gy322W32xt9PqfTWaOsEBQUpPDw8FrXLjidTgUHB9eYTYiMjKx1zIsvvqif/exnHrMVXbp0UVZWluLi4lReXq4XXnhBI0eO1K5duzRkyJB63wMzEwAAa2iimYmYmBiFhoa6W2ZmptfLzZ07t9YFkNXt0KFDl+XW8/LydPDgQaWlpXkc79Wrl+655x7FxsZq+PDhWrt2rYYPH65ly5Y16PzMTAAArKGJtoYWFhbK4XC4D9c2KzFnzhxNmTKlzlP27NlTUVFR7t0V1S5cuKDTp08rKirK67ioqChVVFTozJkzHrMTRUVFXse88MILGjRokGJjY+uMR5Li4+P1ySefXLLfd5FMAAAsoale9OVwODySidp07txZnTt3vmS/xMREnTlzRvn5+e4v+23btsnlcikhIcHrmNjYWLVq1Uq5ubkaP368pIs7Mo4eParExESPvqWlpXr11VdrnUH5dwUFBerSpUu9+lYjmQAAwI/69OmjMWPGaNq0acrKylJlZaXS09M1ceJE906OY8eOKSkpSa+88ori4+MVGhqqtLQ0ZWRkKDw8XA6HQzNnzlRiYqKGDRvmcf5NmzbpwoULuvPOO2tce/ny5erRo4euu+46lZWV6YUXXtC2bdv0wQcfNOgeSCYAANZwhW4NlaT169crPT1dSUlJCggI0Pjx47Vy5Ur355WVlTp8+LDOnz/vPrZs2TJ33/LycqWkpOjZZ5+tce4XX3xRt99+u9etnxUVFZozZ46OHTumNm3aaMCAAfrwww81atSoBsVvM4zm++aSkpIShYaGquuSRxUQEuLvcAAADeQqK9PRuQtUXFxcr9JBY1R/VyR/b5aCAhu/6+JCVbk+/Gq5T2NtrtjNAQAATKHMAQCwhiu4zNHckUwAACzC7FMsSSZqQ5kDAACYwswEAMAaKHP4DMkEAMAaXIZMlSpcJBO1ocwBAABMYWYCAGANhutiMzMeXpFMAACsgTUTPnNFlDlWrVql7t27KyQkRAkJCdq9e7e/QwIAtDQuw3yDV35PJjZt2qSMjAwtWrRI+/bt08CBA5WSklLjdawAAODK5PdkYunSpZo2bZqmTp2qvn37KisrS23atNHatWv9HRoAoCWpLnOYafDKr8lERUWF8vPzlZyc7D4WEBCg5ORk5eXl1ehfXl6ukpISjwYAQL0YMplM+PsGrlx+TSa+/fZbVVVVKTIy0uN4ZGSknE5njf6ZmZkKDQ11t5iYmMsVKgAAqIXfyxwNMW/ePBUXF7tbYWGhv0MCADQXlDl8xq9bQzt16qTAwEAVFRV5HC8qKlJUVFSN/na7XXZ7499FDwCwMJdLkolnRbh4zkRt/DozERwcrNjYWOXm5rqPuVwu5ebmKjEx0Y+RAQCA+vL7Q6syMjI0efJkxcXFKT4+XsuXL9e5c+c0depUf4cGAGhJeGiVz/g9mZgwYYJOnTqlhQsXyul0atCgQcrOzq6xKBMAAFNIJnzG78mEJKWnpys9Pd3fYQAAgEa4IpIJAAB8jleQ+wzJBADAEgzDJcPEmz/NjG3pSCYAANZgmHxZF2smatWsHloFAACuPMxMAACswTC5ZoKZiVqRTAAArMHlkmwm1j2wZqJWlDkAAIApzEwAAKyBMofPkEwAACzBcLlkmChzsDW0dpQ5AACAKcxMAACsgTKHz5BMAACswWVINpIJX6DMAQAATGFmAgBgDYYhycxzJpiZqA3JBADAEgyXIcNEmcMgmagVZQ4AgDUYLvPNR06fPq3U1FQ5HA6FhYUpLS1NpaWldY5Zs2aNRo4cKYfDIZvNpjNnzjTqvH/84x/1gx/8QCEhIYqJidFvf/vbBsdPMgEAgJ+lpqbqwIEDysnJ0ZYtW/Txxx9r+vTpdY45f/68xowZo/nz5zf6vCUlJbrpppvUrVs35efn64knntDixYu1Zs2aBsVPmQMAYAlXapnj4MGDys7O1p49exQXFydJevrpp3XLLbfoySefVHR0tNdxs2bNkiRt37690eddv369KioqtHbtWgUHB+u6665TQUGBli5deslk5ruYmQAAWMMVWubIy8tTWFiY+wtfkpKTkxUQEKBdu3b59Lx5eXm68cYbFRwc7O6TkpKiw4cP6+9//3u9r9WsZyaqs0RXWZmfIwEANEb1/39fjsWNF1Rp6plVF1Qp6WJp4Lvsdrvsdnujz+t0OhUREeFxLCgoSOHh4XI6nT49r9PpVI8ePTz6REZGuj/r0KFDva7VrJOJs2fPSpK+WfyonyMBAJhx9uxZhYaG+uTcwcHBioqK0ifOrabP1a5dO8XExHgcW7RokRYvXlyj79y5c/X444/Xeb6DBw+ajulK0KyTiejoaBUWFqp9+/ay2Ww+vVZJSYliYmJUWFgoh8Ph02tdDi3tfiTuqbngnq58l/N+DMPQ2bNna10X0BRCQkJ05MgRVVRUmD6XYRg1vm9qm5WYM2eOpkyZUuf5evbsqaioKJ08edLj+IULF3T69GlFRUU1Otb6nDcqKkpFRUUefap/bsi1m3UyERAQoKuvvvqyXtPhcLSI/7Oo1tLuR+Kemgvu6cp3ue7HVzMS3xUSEqKQkBCfX+e7OnfurM6dO1+yX2Jios6cOaP8/HzFxsZKkrZt2yaXy6WEhIRGX78+501MTNSvf/1rVVZWqlWrVpKknJwc9erVq94lDokFmAAA+FWfPn00ZswYTZs2Tbt379ann36q9PR0TZw40T1jc+zYMfXu3Vu7d+92j3M6nSooKNCXX34pSfrTn/6kgoICnT59ut7n/dnPfqbg4GClpaXpwIED2rRpk1asWKGMjIwG3QPJBAAAfrZ+/Xr17t1bSUlJuuWWW3TDDTd4POuhsrJShw8f1vnz593HsrKyNHjwYE2bNk2SdOONN2rw4MF6++23633e0NBQffDBBzpy5IhiY2M1Z84cLVy4sEHbQqVmXua4nOx2uxYtWmRqxe6VpKXdj8Q9NRfc05Wvpd1PcxAeHq4NGzbU+nn37t1r7HhZvHix14WfDTmvJA0YMED/+7//W+9YvbEZPGwcAACYQJkDAACYQjIBAABMIZkAAACmkEwAAABTSCbqYdWqVerevbtCQkKUkJDgsc+3ufn444916623Kjo6WjabTW+++aa/QzItMzNTQ4cOVfv27RUREaFx48bp8OHD/g7LlNWrV2vAgAHuhwYlJibqvffe83dYTWbJkiWy2Wzutx42R4sXL5bNZvNovXv39ndYph07dkx33nmnOnbsqNatW6t///7au3evv8PCFY5k4hI2bdqkjIwMLVq0SPv27dPAgQOVkpJS4xGlzcW5c+c0cOBArVq1yt+hNJkdO3ZoxowZ+uyzz5STk6PKykrddNNNOnfunL9Da7Srr75aS5YsUX5+vvbu3avRo0frtttu04EDB/wdmml79uzRc889pwEDBvg7FNOuu+46nThxwt0++eQTf4dkyt///nddf/31atWqld577z39+c9/1lNPPdWgJyHCogzUKT4+3pgxY4b756qqKiM6OtrIzMz0Y1RNQ5Lxxhtv+DuMJnfy5ElDkrFjxw5/h9KkOnToYLzwwgv+DsOUs2fPGtdee62Rk5NjjBgxwrj//vv9HVKjLVq0yBg4cKC/w2hSDz74oHHDDTf4Oww0Q8xM1KGiokL5+flKTk52HwsICFBycrLy8vL8GBnqUlxcLOniw1pagqqqKm3cuFHnzp1TYmKiv8MxZcaMGRo7dqzH/6aasy+++ELR0dHq2bOnUlNTdfToUX+HZMrbb7+tuLg4/cd//IciIiI0ePBgPf/88/4OC80AyUQdvv32W1VVVbnf7V4tMjLS1Dvm4Tsul0uzZs3S9ddfr379+vk7HFP+9Kc/qV27drLb7fr5z3+uN954Q3379vV3WI22ceNG7du3T5mZmf4OpUkkJCRo3bp1ys7O1urVq3XkyBH94Ac/0NmzZ/0dWqP95S9/0erVq3Xttdfq/fff17333qv77rtPL7/8sr9DwxWOx2mjRZkxY4b279/f7GvXktSrVy8VFBSouLhYr732miZPnqwdO3Y0y4SisLBQ999/v3Jyci77mxt95eabb3b/e8CAAUpISFC3bt306quvKi0tzY+RNZ7L5VJcXJwee+wxSdLgwYO1f/9+ZWVlafLkyX6ODlcyZibq0KlTJwUGBnp917uZd8zDN9LT07VlyxZ99NFHl/3V9L4QHBysa665RrGxscrMzNTAgQO1YsUKf4fVKPn5+Tp58qSGDBmioKAgBQUFaceOHVq5cqWCgoJUVVXl7xBNCwsL0/e//333Gxyboy5dutRIVvv06dPsyzfwPZKJOgQHBys2Nla5ubnuYy6XS7m5uc2+dt2SGIah9PR0vfHGG9q2bZt69Ojh75B8wuVyqby83N9hNEpSUpL79cjVLS4uTqmpqSooKFBgYKC/QzSttLRUX331lbp06eLvUBrt+uuvr7Gt+v/+7//UrVs3P0WE5oIyxyVkZGRo8uTJiouLU3x8vJYvX65z585p6tSp/g6tUUpLSz3+cjpy5IgKCgoUHh6url27+jGyxpsxY4Y2bNigt956S+3bt3evZwkNDVXr1q39HF3jzJs3TzfffLO6du2qs2fPasOGDdq+fbvef/99f4fWKO3bt6+xhqVt27bq2LFjs13b8sADD+jWW29Vt27ddPz4cS1atEiBgYGaNGmSv0NrtNmzZ2v48OF67LHH9NOf/lS7d+/WmjVrPF5ZDXjl7+0kzcHTTz9tdO3a1QgODjbi4+ONzz77zN8hNdpHH31kSKrRJk+e7O/QGs3b/UgyXnrpJX+H1mh333230a1bNyM4ONjo3LmzkZSUZHzwwQf+DqtJNfetoRMmTDC6dOliBAcHG1dddZUxYcIE48svv/R3WKa98847Rr9+/Qy73W707t3bWLNmjb9DQjPAK8gBAIAprJkAAACmkEwAAABTSCYAAIApJBMAAMAUkgkAAGAKyQQAADCFZAIAAJhCMgEAAEwhmQCuYFOmTNG4ceP8HQYA1IlkAgAAmEIyAQAATCGZAAAAppBMAAAAU0gmAACAKSQTAADAFJIJAABgCskEAAAwhWQCAACYYjMMw/B3EAAAoPliZgIAAJhCMgEAAEwhmQAAAKaQTAAAAFNIJgAAgCkkEwAAwBSSCQAAYArJBAAAMIVkAgAAmEIyAQAATCGZAAAAppBMAAAAU/4/ueyEGyTJxwEAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing 'field_plus_one'\n", - "Plotting values of qty_out at K = 0 after executing 'field_plus_one'\n", - "Min and max values: 13.0 1.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from gt4py.cartesian.gtscript import function\n", "\n", @@ -1270,7 +539,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.11.9" } }, "nbformat": 4, diff --git a/examples/NDSL/02_NDSL_basics.ipynb b/examples/NDSL/02_NDSL_basics.ipynb index 9675fa19..fdc5fb70 100644 --- a/examples/NDSL/02_NDSL_basics.ipynb +++ b/examples/NDSL/02_NDSL_basics.ipynb @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -86,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -121,46 +121,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting qty_in at K = 0\n", - "Min and max values: 14.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting qty_out at K = 0\n", - "Min and max values: 0.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "## Change this to Quantity\n", "\n", @@ -204,29 +167,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Copying copy_field stencil\n", - "Plotting qty_out at K = 0\n", - "Min and max values: 12.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "print(\"Copying copy_field stencil\")\n", "copy_field(qty_in, qty_out)\n", @@ -256,17 +199,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initialize qty_out to zeros\n" - ] - } - ], + "outputs": [], "source": [ "from gt4py.cartesian.gtscript import J\n", "\n", @@ -303,29 +238,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing copy_field_offset stencil\n", - "Plotting values of qty_out at K = 0\n", - "Min and max values: 11.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "print(\"Executing copy_field_offset stencil\")\n", "copy_field_offset(qty_in, qty_out)\n", @@ -344,26 +259,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Origin for field field_in too small. Must be at least (0, 2, 0), is (1, 1, 0)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_6732/2658447685.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0mcopy_field_offset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCopyFieldOffset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstencil_factory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m \u001b[0mcopy_field_offset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqty_in\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mqty_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/tmp/ipykernel_6732/2658447685.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, field_in, field_out)\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0mfield_out\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mFloatField\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m ):\n\u001b[0;32m---> 19\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_copy_field_offset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfield_in\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfield_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0mcopy_field_offset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCopyFieldOffset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstencil_factory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/NDSL/ndsl/dsl/stencil.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 418\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m__debug__\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;34m\"domain\"\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 419\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"domain cannot be passed to FrozenStencil call\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 420\u001b[0;31m self.stencil_object(\n\u001b[0m\u001b[1;32m 421\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 422\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/SMT-Nebulae-Tutorial/tutorial/NDSL/.gt_cache_000000/py311_1013/numpy/__main__/copy_field_offset_stencil/m_copy_field_offset_stencil__numpy_d84da3ed67.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, field_in, field_out, domain, origin, validate_args, exec_info)\u001b[0m\n\u001b[1;32m 78\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 80\u001b[0;31m self._call_run(\n\u001b[0m\u001b[1;32m 81\u001b[0m \u001b[0mfield_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfield_args\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 82\u001b[0m \u001b[0mparameter_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparameter_args\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_object.py\u001b[0m in \u001b[0;36m_call_run\u001b[0;34m(self, field_args, parameter_args, domain, origin, validate_args, exec_info)\u001b[0m\n\u001b[1;32m 582\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 583\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mvalidate_args\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 584\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validate_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray_infos\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparameter_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdomain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 585\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 586\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_domain_origin_cache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcache_key\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mdomain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_object.py\u001b[0m in \u001b[0;36m_validate_args\u001b[0;34m(self, arg_infos, param_args, domain, origin)\u001b[0m\n\u001b[1;32m 466\u001b[0m )\n\u001b[1;32m 467\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfield_domain_origin\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mmin_origin\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 468\u001b[0;31m raise ValueError(\n\u001b[0m\u001b[1;32m 469\u001b[0m \u001b[0;34mf\"Origin for field {name} too small. Must be at least {min_origin}, is {field_domain_origin}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 470\u001b[0m )\n", - "\u001b[0;31mValueError\u001b[0m: Origin for field field_in too small. Must be at least (0, 2, 0), is (1, 1, 0)" - ] - } - ], + "outputs": [], "source": [ "def copy_field_offset_stencil(field_in: FloatField, field_out: FloatField):\n", " with computation(PARALLEL), interval(...):\n", @@ -401,45 +299,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "GTScriptSyntaxError", - "evalue": "Assignment to non-zero offsets is not supported.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mGTScriptSyntaxError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_6732/416380115.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_copy_field_offset_output\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfield_in\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfield_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m \u001b[0mcopy_field_offset_output\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCopyFieldOffsetOutput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstencil_factory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 24\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/tmp/ipykernel_6732/416380115.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, stencil_factory)\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstencil_factory\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mStencilFactory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mgrid_indexing\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstencil_factory\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrid_indexing\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m self._copy_field_offset_output = stencil_factory.from_origin_domain(\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0mcopy_field_offset_output_stencil\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgrid_indexing\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0morigin_compute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/NDSL/ndsl/dsl/stencil.py\u001b[0m in \u001b[0;36mfrom_origin_domain\u001b[0;34m(self, func, origin, domain, externals, skip_passes)\u001b[0m\n\u001b[1;32m 910\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 911\u001b[0m \u001b[0mcls\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFrozenStencil\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 912\u001b[0;31m return cls(\n\u001b[0m\u001b[1;32m 913\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 914\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morigin\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/NDSL/ndsl/dsl/stencil.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, func, origin, domain, stencil_config, externals, skip_passes, timing_collector, comm)\u001b[0m\n\u001b[1;32m 361\u001b[0m \u001b[0mblock_waiting_for_compilation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mMPI\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCOMM_WORLD\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompilation_config\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 362\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 363\u001b[0;31m self.stencil_object = gtscript.stencil(\n\u001b[0m\u001b[1;32m 364\u001b[0m \u001b[0mdefinition\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 365\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/gtscript.py\u001b[0m in \u001b[0;36mstencil\u001b[0;34m(backend, definition, build_info, dtypes, externals, format_source, name, rebuild, cache_settings, raise_if_not_cached, **kwargs)\u001b[0m\n\u001b[1;32m 317\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_decorator\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 318\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 319\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_decorator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 320\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 321\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/gtscript.py\u001b[0m in \u001b[0;36m_decorator\u001b[0;34m(definition_func)\u001b[0m\n\u001b[1;32m 304\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 305\u001b[0m \u001b[0moriginal_annotations\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_set_arg_dtypes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtypes\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 306\u001b[0;31m out = gt_loader.gtscript_loader(\n\u001b[0m\u001b[1;32m 307\u001b[0m \u001b[0mdefinition_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 308\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/loader.py\u001b[0m in \u001b[0;36mgtscript_loader\u001b[0;34m(definition_func, backend, build_options, externals, dtypes)\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mbuild_options\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0mbuild_options\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mf\"{definition_func.__name__}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 75\u001b[0;31m stencil_class = load_stencil(\n\u001b[0m\u001b[1;32m 76\u001b[0m \u001b[0;34m\"gtscript\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdefinition_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuild_options\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 77\u001b[0m )\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/loader.py\u001b[0m in \u001b[0;36mload_stencil\u001b[0;34m(frontend_name, backend_name, definition_func, externals, dtypes, build_options)\u001b[0m\n\u001b[1;32m 58\u001b[0m )\n\u001b[1;32m 59\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 60\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuild\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_builder.py\u001b[0m in \u001b[0;36mbuild\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 91\u001b[0m \u001b[0;34mf\"The stencil {self._definition.__name__} is not up to date in the cache\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 92\u001b[0m )\n\u001b[0;32m---> 93\u001b[0;31m \u001b[0mstencil_class\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 94\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mstencil_class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36mgenerate\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_impl_opts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"disable-code-generation\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[0msrc_dir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmkdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparents\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexist_ok\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 110\u001b[0;31m \u001b[0mrecursive_write\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msrc_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate_computation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 111\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake_module\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36mgenerate_computation\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[0mignore_np_errstate\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend_opts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"ignore_np_errstate\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 95\u001b[0;31m \u001b[0msource\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mNpirCodegen\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnpir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mignore_np_errstate\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mignore_np_errstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 96\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat_source\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0msource\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformat_source\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"python\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msource\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36mnpir\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"gtcnumpy:npir\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend_data\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_backend_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_npir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 136\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36m_make_npir\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_make_npir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mnpir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mComputation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 114\u001b[0;31m \u001b[0mbase_oir\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGTIRToOIR\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgtir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 115\u001b[0m oir_pipeline = self.builder.options.backend_opts.get(\n\u001b[1;32m 116\u001b[0m \u001b[0;34m\"oir_pipeline\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_builder.py\u001b[0m in \u001b[0;36mgtir\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 289\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 290\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgtir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mgtir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mStencil\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 291\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgtir_pipeline\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 292\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 293\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_builder.py\u001b[0m in \u001b[0;36mgtir_pipeline\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 282\u001b[0m \u001b[0;34m\"gtir_pipeline\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 283\u001b[0m GtirPipeline(\n\u001b[0;32m--> 284\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrontend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 285\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstencil_id\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 286\u001b[0m ),\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mgenerate\u001b[0;34m(cls, definition, externals, dtypes, options)\u001b[0m\n\u001b[1;32m 2124\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprepare_stencil_definition\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2125\u001b[0m \u001b[0mtranslator\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGTScriptParser\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2126\u001b[0;31m \u001b[0mdefinition_ir\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtranslator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2127\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2128\u001b[0m \u001b[0;31m# GTIR only supports LatLonGrids\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 2058\u001b[0m \u001b[0;31m# Generate definition IR\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2059\u001b[0m \u001b[0mdomain\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDomain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLatLonGrid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2060\u001b[0;31m computations = IRMaker(\n\u001b[0m\u001b[1;32m 2061\u001b[0m \u001b[0mfields\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfields_decls\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2062\u001b[0m \u001b[0mparameters\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparameter_decls\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, ast_root)\u001b[0m\n\u001b[1;32m 780\u001b[0m \u001b[0mfunc_ast\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mast_root\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbody\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 781\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparsing_context\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParsingContext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCONTROL_FLOW\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 782\u001b[0;31m \u001b[0mcomputations\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc_ast\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 783\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 784\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcomputations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/SMT-Nebulae/sw_stack_path/install/python3/lib/python3.11/ast.py\u001b[0m in \u001b[0;36mvisit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 416\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'visit_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 417\u001b[0m \u001b[0mvisitor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeneric_visit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 418\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mvisitor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgeneric_visit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mvisit_FunctionDef\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 1595\u001b[0m \u001b[0mblocks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1596\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mstmt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfilter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mast\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAnnAssign\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbody\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1597\u001b[0;31m \u001b[0mblocks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstmt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1598\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1599\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mComputationBlock\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mitem\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mblocks\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/SMT-Nebulae/sw_stack_path/install/python3/lib/python3.11/ast.py\u001b[0m in \u001b[0;36mvisit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 416\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'visit_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 417\u001b[0m \u001b[0mvisitor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeneric_visit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 418\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mvisitor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgeneric_visit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mvisit_With\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 1587\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcompute_blocks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1588\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparsing_context\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mParsingContext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCONTROL_FLOW\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1589\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mgtc_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_visit_computation_node\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1590\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1591\u001b[0m \u001b[0;31m# Mixing nested `with` blocks with stmts not allowed\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36m_visit_computation_node\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 977\u001b[0m \u001b[0mstmts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 978\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mstmt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbody\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 979\u001b[0;31m \u001b[0mstmts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgtc_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstmt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 980\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparsing_context\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParsingContext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCONTROL_FLOW\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 981\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/SMT-Nebulae/sw_stack_path/install/python3/lib/python3.11/ast.py\u001b[0m in \u001b[0;36mvisit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 416\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'visit_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 417\u001b[0m \u001b[0mvisitor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeneric_visit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 418\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mvisitor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgeneric_visit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mvisit_Assign\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 1444\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mspatial_offset\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1445\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moffset\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moffset\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mspatial_offset\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1446\u001b[0;31m raise GTScriptSyntaxError(\n\u001b[0m\u001b[1;32m 1447\u001b[0m \u001b[0mmessage\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"Assignment to non-zero offsets is not supported.\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1448\u001b[0m \u001b[0mloc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLocation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_ast_node\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mGTScriptSyntaxError\u001b[0m: Assignment to non-zero offsets is not supported." - ] - } - ], + "outputs": [], "source": [ "from gt4py.cartesian.gtscript import J\n", "\n", @@ -484,7 +346,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.11.9" } }, "nbformat": 4, diff --git a/examples/NDSL/03_orchestration_basics.ipynb b/examples/NDSL/03_orchestration_basics.ipynb index 86351257..236fb93f 100644 --- a/examples/NDSL/03_orchestration_basics.ipynb +++ b/examples/NDSL/03_orchestration_basics.ipynb @@ -19,29 +19,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2024-05-29 13:16:33|INFO|rank 0|ndsl.logging:Constant selected: ConstantVersions.GFS\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "from gt4py.cartesian.gtscript import (\n", @@ -70,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -94,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -133,33 +113,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2024-05-29 13:16:33|INFO|rank 0|ndsl.logging:[DaCeOrchestration.BuildAndRun] Rank 0 reading/writing cache .gt_cache_FV3_A\n", - "2024-05-29 13:16:33|INFO|rank 0|ndsl.logging:Building DaCe orchestration\n", - "Inlined 2 SDFGs.\n", - "Fused 4 states.\n", - "Inferred 2 optional arrays.\n", - "SDFG 0: Eliminated 1 arrays: {'out_result_0'}.\n", - "Fused 2 states.\n", - "Inferred 4 optional arrays.\n", - "Inlined 2 SDFGs.\n", - "2024-05-29 13:16:34|INFO|rank 0|ndsl.logging:[DaCeOrchestration.BuildAndRun] LocalSum___call__:\n", - "StorageType.Default:\n", - " Alloc ref 0.01 mb\n", - " Alloc unref 0.00 mb\n", - " Pooled 0.00 mb\n", - " Top lvl alloc: 0.01mb\n", - "\n", - "[DaCe Config] Rank 0 loading SDFG /home/ckung/Documents/Code/SMT-Nebulae-Tutorial/tutorial/NDSL/.gt_cache_FV3_A/dacecache/LocalSum___call__\n" - ] - } - ], + "outputs": [], "source": [ "# ----- Driver ----- #\n", "\n", @@ -206,7 +162,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.11.9" } }, "nbformat": 4, From 727503e09c896ba0a9bc7570d4d210c1d2b5171e Mon Sep 17 00:00:00 2001 From: Roman Cattaneo <> Date: Tue, 6 Aug 2024 11:06:57 +0200 Subject: [PATCH 115/154] Fix typos in boilerplate doc strings --- ndsl/boilerplate.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ndsl/boilerplate.py b/ndsl/boilerplate.py index ced15115..f22e0b9f 100644 --- a/ndsl/boilerplate.py +++ b/ndsl/boilerplate.py @@ -82,7 +82,7 @@ def _get_factories( def get_factories_single_tile_orchestrated_cpu( nx, ny, nz, nhalo ) -> Tuple[StencilFactory, QuantityFactory]: - """Build a Stencil & Quantity factory for orchestrated CPU, on a single tile toplogy.""" + """Build a Stencil & Quantity factory for orchestrated CPU, on a single tile topology.""" return _get_factories( nx=nx, ny=ny, @@ -97,7 +97,7 @@ def get_factories_single_tile_orchestrated_cpu( def get_factories_single_tile_numpy( nx, ny, nz, nhalo ) -> Tuple[StencilFactory, QuantityFactory]: - """Build a Stencil & Quantity factory for Numpy, on a single tile toplogy.""" + """Build a Stencil & Quantity factory for Numpy, on a single tile topology.""" return _get_factories( nx=nx, ny=ny, From 8c6b4e07dabc8d9e4348d61391f112ec5155c7a3 Mon Sep 17 00:00:00 2001 From: Roman Cattaneo <> Date: Mon, 5 Aug 2024 10:17:28 +0200 Subject: [PATCH 116/154] Improved NDSL examples - Use boilerplate from ndsl.boilerplate - Fix typos & broken links in notebooks - Added README with quickstart guide --- examples/NDSL/01_gt4py_basics.ipynb | 90 ++++++++++----------- examples/NDSL/02_NDSL_basics.ipynb | 34 ++++---- examples/NDSL/03_orchestration_basics.ipynb | 15 ++-- examples/NDSL/README.md | 14 ++++ examples/NDSL/basic_boilerplate.py | 73 ----------------- examples/NDSL/orch_boilerplate.py | 64 --------------- ndsl/boilerplate.py | 14 ++++ setup.py | 8 +- 8 files changed, 102 insertions(+), 210 deletions(-) create mode 100644 examples/NDSL/README.md delete mode 100755 examples/NDSL/basic_boilerplate.py delete mode 100644 examples/NDSL/orch_boilerplate.py diff --git a/examples/NDSL/01_gt4py_basics.ipynb b/examples/NDSL/01_gt4py_basics.ipynb index 0e9c58ff..aa6ca296 100755 --- a/examples/NDSL/01_gt4py_basics.ipynb +++ b/examples/NDSL/01_gt4py_basics.ipynb @@ -44,7 +44,7 @@ "from ndsl.dsl.typing import FloatField\n", "from ndsl.quantity import Quantity\n", "import numpy as np\n", - "from basic_boilerplate import plot_field_at_k0, plot_field_at_kN" + "from ndsl.boilerplate import plot_field_at_kN" ] }, { @@ -187,9 +187,9 @@ "plot_field_at_kN(qty_in.data)\n", "print(\"Plotting values of qty_out at K = 0\")\n", "plot_field_at_kN(qty_out.data)\n", - "print(\"Executing `copy_stencil` with origin=(1,0,0)\")\n", - "copy_stencil(qty_in, qty_out,origin=(1,0,0))\n", - "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(1,0,0)\")\n", + "print(\"Executing `copy_stencil` with origin=(1, 0, 0)\")\n", + "copy_stencil(qty_in, qty_out, origin=(1, 0, 0))\n", + "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(1, 0, 0)\")\n", "plot_field_at_kN(qty_out.data)\n", "\n", "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", @@ -201,9 +201,9 @@ "print(\"Resetting qty_out to zero...\")\n", "print(\"Plotting values of qty_out at K = 0\")\n", "plot_field_at_kN(qty_out.data)\n", - "print(\"Executing `copy_stencil` with origin=(0,1,0)\")\n", - "copy_stencil(qty_in, qty_out,origin=(0,1,0))\n", - "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0,1,0)\")\n", + "print(\"Executing `copy_stencil` with origin=(0, 1, 0)\")\n", + "copy_stencil(qty_in, qty_out, origin=(0, 1, 0))\n", + "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0, 1, 0)\")\n", "plot_field_at_kN(qty_out.data)\n", "\n", "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", @@ -215,11 +215,11 @@ "print(\"Resetting qty_out to zero...\")\n", "print(\"Plotting values of qty_out at K = 0\")\n", "plot_field_at_kN(qty_out.data)\n", - "print(\"Executing `copy_stencil` with origin = (0,0,1)\")\n", - "copy_stencil(qty_in, qty_out,origin=(0,0,1))\n", - "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0,0,1)\")\n", + "print(\"Executing `copy_stencil` with origin = (0, 0, 1)\")\n", + "copy_stencil(qty_in, qty_out, origin=(0, 0, 1))\n", + "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0, 0, 1)\")\n", "plot_field_at_kN(qty_out.data)\n", - "print(\"Plotting qty_out at K = 1 based on `copy_stencil` with origin=(0,0,1)\")\n", + "print(\"Plotting qty_out at K = 1 based on `copy_stencil` with origin=(0, 0, 1)\")\n", "plot_field_at_kN(qty_out.data, 1)\n", "\n", "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", @@ -232,9 +232,9 @@ "plot_field_at_kN(qty_in.data)\n", "print(\"Plotting values of qty_out at K = 0\")\n", "plot_field_at_kN(qty_out.data)\n", - "print(\"Executing `copy_stencil` with domain=(2,2,nz)\")\n", - "copy_stencil(qty_in, qty_out, domain=(2,2,nz))\n", - "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with domain = (2,2,nz)\")\n", + "print(\"Executing `copy_stencil` with domain=(2, 2, nz)\")\n", + "copy_stencil(qty_in, qty_out, domain=(2, 2, nz))\n", + "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with domain=(2, 2, nz)\")\n", "plot_field_at_kN(qty_out.data)\n", "\n", "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", @@ -245,9 +245,9 @@ "print(\"Resetting qty_out to zero...\")\n", "print(\"Plotting values of qty_out at K = 0\")\n", "plot_field_at_kN(qty_out.data)\n", - "print(\"Executing `copy_stencil` with origin = (2,2,0), domain=(2,2,nz)\")\n", - "copy_stencil(qty_in, qty_out, origin=(2,2,0), domain=(2,2,nz))\n", - "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin = (2,2,0), domain = (2,2,nz)\")\n", + "print(\"Executing `copy_stencil` with origin=(2, 2, 0), domain=(2, 2, nz)\")\n", + "copy_stencil(qty_in, qty_out, origin=(2, 2, 0), domain=(2, 2, nz))\n", + "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(2, 2, 0), domain=(2, 2, nz)\")\n", "plot_field_at_kN(qty_out.data)" ] }, @@ -305,16 +305,16 @@ " with computation(FORWARD), interval(...):\n", " qty_out = qty_in[0,0,-1] * 2.0\n", "\n", - "print(\"Executing 'mult_upward' with origin=(nhalo,nhalo,1), domain=(nx,ny,2)\")\n", + "print(\"Executing 'mult_upward' with origin=(nhalo, nhalo, 1), domain=(nx, ny, 2)\")\n", "mult_upward(qty_in, qty_out, origin=(nhalo,nhalo,1), domain=(nx,ny,2))\n", - "print(\"Plotting values of qty_out at K = 0 with origin=(nhalo,nhalo,1), domain=(nx,ny,2)\")\n", - "plot_field_at_kN(qty_out.data,0)\n", - "print(\"Plotting values of qty_out at K = 1 with origin=(nhalo,nhalo,1), domain=(nx,ny,2)\")\n", - "plot_field_at_kN(qty_out.data,1)\n", - "print(\"Plotting values of qty_out at K = 2 with origin=(nhalo,nhalo,1), domain=(nx,ny,2)\")\n", - "plot_field_at_kN(qty_out.data,2)\n", - "print(\"Plotting values of qty_out at K = 3 with origin=(nhalo,nhalo,1), domain=(nx,ny,2)\")\n", - "plot_field_at_kN(qty_out.data,3)\n", + "print(\"Plotting values of qty_out at K = 0 with origin=(nhalo, nhalo, 1), domain=(nx, ny, 2)\")\n", + "plot_field_at_kN(qty_out.data, 0)\n", + "print(\"Plotting values of qty_out at K = 1 with origin=(nhalo, nhalo, 1), domain=(nx, ny, 2)\")\n", + "plot_field_at_kN(qty_out.data, 1)\n", + "print(\"Plotting values of qty_out at K = 2 with origin=(nhalo, nhalo, 1), domain=(nx, ny, 2)\")\n", + "plot_field_at_kN(qty_out.data, 2)\n", + "print(\"Plotting values of qty_out at K = 3 with origin=(nhalo, nhalo, 1), domain=(nx, ny, 2)\")\n", + "plot_field_at_kN(qty_out.data, 3)\n", "\n", "@stencil(backend=backend)\n", "def copy_downward(qty_in: FloatField, qty_out: FloatField):\n", @@ -328,15 +328,15 @@ " gt4py_backend=backend\n", " )\n", "\n", - "print(\"Executing 'copy_downward' with origin=(1,1,0), domain=(nx,ny,nz-1)\")\n", - "copy_downward(qty_in, qty_out, origin=(1,1,0), domain=(nx,ny,nz-1))\n", + "print(\"Executing 'copy_downward' with origin=(1, 1, 0), domain=(nx, ny, nz-1)\")\n", + "copy_downward(qty_in, qty_out, origin=(1, 1, 0), domain=(nx, ny, nz-1))\n", "print(\"***\")\n", "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data,0)\n", + "plot_field_at_kN(qty_out.data, 0)\n", "print(\"Plotting values of qty_out at K = 1\")\n", - "plot_field_at_kN(qty_out.data,1)\n", + "plot_field_at_kN(qty_out.data, 1)\n", "print(\"Plotting values of qty_out at K = 2\")\n", - "plot_field_at_kN(qty_out.data,2)" + "plot_field_at_kN(qty_out.data, 2)" ] }, { @@ -399,14 +399,14 @@ " with computation(PARALLEL), interval(...):\n", " field_out = field_in[0,-2,0]\n", "\n", - "print(\"Executing 'copy_stencil' with origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\")\n", - "copy_stencil(qty_in, qty_out, origin=(nhalo, nhalo,0), domain=(nx, ny, nz))\n", + "print(\"Executing 'copy_stencil' with origin=(nhalo, nhalo, 0), domain=(nx, ny, nz)\")\n", + "copy_stencil(qty_in, qty_out, origin=(nhalo, nhalo, 0), domain=(nx, ny, nz))\n", "print(\"Executing 'copy_stencil' where qty_out is copied back to qty_in\")\n", "copy_stencil(qty_out, qty_in)\n", - "plot_field_at_kN(qty_in.data,0)\n", - "print(\"Executing 'copy_stencil_offset' where origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\")\n", - "copy_stencil_offset(qty_in, qty_out, origin=(nhalo, nhalo,0), domain=(nx, ny, nz))\n", - "plot_field_at_kN(qty_out.data,0)" + "plot_field_at_kN(qty_in.data, 0)\n", + "print(\"Executing 'copy_stencil_offset' where origin=(nhalo, nhalo, 0), domain=(nx, ny, nz)\")\n", + "copy_stencil_offset(qty_in, qty_out, origin=(nhalo, nhalo, 0), domain=(nx, ny, nz))\n", + "plot_field_at_kN(qty_out.data, 0)" ] }, { @@ -438,15 +438,15 @@ " )\n", "\n", "print(\"Plotting values of qty_in at K = 0\")\n", - "plot_field_at_kN(qty_in.data,0)\n", + "plot_field_at_kN(qty_in.data, 0)\n", "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data,0)\n", - "print(\"Running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\")\n", - "copy_stencil(qty_in,qty_out,origin=(nhalo,nhalo,0),domain=(nx,ny,5))\n", - "print(\"Plotting values of qty_out at K = 0 based on running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\")\n", - "plot_field_at_kN(qty_out.data,0)\n", - "print(\"Plotting values of qty_out at K = 1 based on running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\")\n", - "plot_field_at_kN(qty_out.data,1)\n", + "plot_field_at_kN(qty_out.data, 0)\n", + "print(\"Running copy_stencil with origin=(nhalo, nhalo, 0), domain=(nx, ny, 5)\")\n", + "copy_stencil(qty_in, qty_out, origin=(nhalo, nhalo, 0), domain=(nx, ny, 5))\n", + "print(\"Plotting values of qty_out at K = 0 based on running copy_stencil with origin=(nhalo, nhalo, 0), domain=(nx, ny, 5)\")\n", + "plot_field_at_kN(qty_out.data, 0)\n", + "print(\"Plotting values of qty_out at K = 1 based on running copy_stencil with origin=(nhalo, nhalo, 0), domain=(nx, ny, 5)\")\n", + "plot_field_at_kN(qty_out.data, 1)\n", "\n", "@stencil(backend=backend)\n", "def stencil_if_zero(in_out_field: FloatField):\n", diff --git a/examples/NDSL/02_NDSL_basics.ipynb b/examples/NDSL/02_NDSL_basics.ipynb index fdc5fb70..30465698 100644 --- a/examples/NDSL/02_NDSL_basics.ipynb +++ b/examples/NDSL/02_NDSL_basics.ipynb @@ -25,16 +25,15 @@ "metadata": {}, "outputs": [], "source": [ - "from basic_boilerplate import get_one_tile_factory, plot_field_at_k0\n", "from ndsl import StencilFactory\n", + "from ndsl.boilerplate import get_factories_single_tile_numpy, plot_field_at_kN\n", "\n", "nx = 6\n", "ny = 6\n", "nz = 1\n", "nhalo = 1\n", - "backend=\"numpy\"\n", "\n", - "stencil_factory: StencilFactory = get_one_tile_factory(nx, ny, nz, nhalo, backend)" + "stencil_factory, _ = get_factories_single_tile_numpy(nx, ny, nz, nhalo)" ] }, { @@ -43,15 +42,15 @@ "source": [ "### **Creating the Copy stencil**\n", "\n", - "The `NDSL` and `gt4py` module contain key terms that will be used to create the stencil. Many terms are covered in the [GT4Py basic tutorial](./01_basics.ipynb) notebook, but we'll briefly recap.\n", + "The `NDSL` and `gt4py` module contain key terms that will be used to create the stencil. Many terms are covered in the [GT4Py basic tutorial](./01_gt4py_basics.ipynb) notebook, but we'll briefly recap.\n", "\n", "- `FloatField` : This type can generally can be thought of as a `gt4py` 3-dimensional `numpy` array of floating point values.\n", "\n", - "- `computation(PARALLEL)` : This keyword combination means that there is no assumed order to perform calcuations in the `k` (3rd) dimension of a `gt4py` storage. `PARALLEL` can be replaced by `FORWARD` or `BACKWARD` for serialized calculations in the `k` dimension.\n", + "- `computation(PARALLEL)` : This keyword combination means that there is no assumed order to perform calculations in the `K` (3rd) dimension of a `gt4py` storage. `PARALLEL` can be replaced by `FORWARD` or `BACKWARD` for serialized calculations in the `K` dimension.\n", "\n", - "- `interval(...)` : This keyword specifies the range of computation in the `k` dimension.\n", + "- `interval(...)` : This keyword specifies the range of computation in the `K` dimension.\n", "\n", - "The code below contains the Copy stencil implementation." + "The code below contains the copy stencil implementation." ] }, { @@ -72,7 +71,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Note that a decorator does not surround this stencil as shown before in the [basic tutorial](./01_basics.ipynb). Instead, we'll use the `StencilFactory` to \"initiate\" the stencil." + "Note that a decorator does not surround this stencil as shown before in the [basic tutorial](./01_gt4py_basics.ipynb). Instead, we'll use the `StencilFactory` to \"initiate\" the stencil." ] }, { @@ -81,7 +80,7 @@ "source": [ "### **Creating a class that performs a stencil computation**\n", "\n", - "Using the `StencilFactory` object created earlier, the code will now create a class `CopyField` that takes `copy_field_stencil` and defines the computation domain from the parameters `origin` and `domain` within `__init__`. `origin` indicates the \"starting\" point of the stencil calculation, and `domain` indicates the extent of the stencil calculation in the 3 dimensions. Note that when creating `stencil_factory`, a 6 by 6 by 1 sized domain surrounded with a halo layer of size 1 was defined (see the initialization of `grid_indexing` at [boilerplate.py](./boilerplate.py#get_one_tile_factory)). Thus, whenever a `CopyField` object is created, it will perform calcuations within the 6 by 6 by 1 domain (specified by `domain=grid_indexing.domain_compute()`), and the 'origin' will start at the `[0,0,0]` location of the 6 by 6 by 1 grid (specified by `origin=grid_indexing.origin_compute()`)." + "Using the `StencilFactory` object created earlier, the code will now create a class `CopyField` that takes `copy_field_stencil` and defines the computation domain from the parameters `origin` and `domain` within `__init__`. `origin` indicates the \"starting\" point of the stencil calculation, and `domain` indicates the extent of the stencil calculation in the three dimensions. Note that when creating `stencil_factory`, a 6 by 6 by 1 sized domain surrounded with a halo layer of size 1 was defined. Thus, whenever a `CopyField` object is created, it will perform calculations within the 6 by 6 by 1 domain (specified by `domain=grid_indexing.domain_compute()`), and the `origin` will start at the `[0,0,0]` location of the 6 by 6 by 1 grid (specified by `origin=grid_indexing.origin_compute()`)." ] }, { @@ -125,12 +124,11 @@ "metadata": {}, "outputs": [], "source": [ - "## Change this to Quantity\n", - "\n", "import gt4py.storage as gt_storage\n", "from ndsl.quantity import Quantity\n", "import numpy as np\n", "\n", + "backend = stencil_factory.backend\n", "size = (nx + 2 * nhalo) * (ny + 2 * nhalo) * nz\n", "shape = (nx + 2 * nhalo, ny + 2 * nhalo, nz)\n", "\n", @@ -151,9 +149,9 @@ " gt4py_backend=backend)\n", "\n", "print(\"Plotting qty_in at K = 0\")\n", - "plot_field_at_k0(qty_in.data)\n", + "plot_field_at_kN(qty_in.data)\n", "print(\"Plotting qty_out at K = 0\")\n", - "plot_field_at_k0(qty_out.data)\n" + "plot_field_at_kN(qty_out.data)\n" ] }, { @@ -162,7 +160,7 @@ "source": [ "### **Calling `copy_field` stencil**\n", "\n", - "The code will call `copy_field` to execute `copy_field_stencil` using the previously defined `Quantity` data containers and plot the result at `k = 0`." + "The code will call `copy_field` to execute `copy_field_stencil` using the previously defined `Quantity` data containers and plot the result at `K = 0`." ] }, { @@ -174,7 +172,7 @@ "print(\"Copying copy_field stencil\")\n", "copy_field(qty_in, qty_out)\n", "print(\"Plotting qty_out at K = 0\")\n", - "plot_field_at_k0(qty_out.data)" + "plot_field_at_kN(qty_out.data)" ] }, { @@ -190,7 +188,7 @@ "source": [ "### **Applying a J offset**\n", "\n", - "The next example will create a stencil that takes a `Quantity` as an input, shift the input by 1 in the `-j` direction, and write it to an output `Quantity`. This stencil is defined in `copy_field_offset_stencil`.\n", + "The next example will create a stencil that takes a `Quantity` as an input, shift the input by 1 in the `-J` direction, and write it to an output `Quantity`. This stencil is defined in `copy_field_offset_stencil`.\n", "\n", "Note that in `copy_field_offset_stencil`, the shift in the J dimension is performed by referencing the `J` object from `gt4py.cartesian.gtscript` for simplicity. This reference will apply the shift in J to the entire input domain. Another way to perform the shift without referencing the `J` object is to write `[0,-1,0]` (assuming that the variable being modified is 3-dimensional) instead of `[J-1]`.\n", "\n", @@ -245,7 +243,7 @@ "print(\"Executing copy_field_offset stencil\")\n", "copy_field_offset(qty_in, qty_out)\n", "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_k0(qty_out.data)" + "plot_field_at_kN(qty_out.data)" ] }, { @@ -294,7 +292,7 @@ "source": [ "### **Example demonstrating error when writing to offset outputs**\n", "\n", - "While offsets can be applied to all input `Quantity` variables in a stencil, output `Quantity` variables cannot have such offsets. When an offset is applied to an output stencil calcuation, the error `GTScriptSyntaxError: Assignment to non-zero offsets is not supported.` will be displayed." + "While offsets can be applied to all input `Quantity` variables in a stencil, output `Quantity` variables cannot have such offsets. When an offset is applied to an output stencil calculation, the error `GTScriptSyntaxError: Assignment to non-zero offsets is not supported.` will be displayed." ] }, { diff --git a/examples/NDSL/03_orchestration_basics.ipynb b/examples/NDSL/03_orchestration_basics.ipynb index 236fb93f..eea24154 100644 --- a/examples/NDSL/03_orchestration_basics.ipynb +++ b/examples/NDSL/03_orchestration_basics.ipynb @@ -37,8 +37,7 @@ ")\n", "from ndsl.constants import X_DIM, Y_DIM, Z_DIM\n", "from ndsl.dsl.typing import FloatField, Float\n", - "\n", - "from orch_boilerplate import get_one_tile_factory_orchestrated" + "from ndsl.boilerplate import get_factories_single_tile_orchestrated_cpu" ] }, { @@ -55,9 +54,9 @@ "outputs": [], "source": [ "def localsum_stencil(\n", - " field: FloatField, # type: ignore\n", + " field: FloatField, # type: ignore\n", " result: FloatField, # type: ignore\n", - " weight: Float, # type: ignore\n", + " weight: Float, # type: ignore\n", "):\n", " with computation(PARALLEL), interval(...):\n", " result = weight * (\n", @@ -99,8 +98,8 @@ " self._n_halo = quantity_factory.sizer.n_halo\n", "\n", " def __call__(self, in_field: FloatField, out_result: FloatField) -> None:\n", - " self._local_sum(in_field, out_result, 2.0) # GT4Py Stencil\n", - " tmp_field = out_result[:, :, :] + 2 # Regular Python code\n", + " self._local_sum(in_field, out_result, 2.0) # GT4Py Stencil\n", + " tmp_field = out_result[:, :, :] + 2 # Regular Python code\n", " self._local_sum(tmp_field, out_result, 2.0) # GT4Py Stencil" ] }, @@ -121,19 +120,17 @@ "\n", "if __name__ == \"__main__\":\n", " # Settings\n", - " backend = \"dace:cpu\"\n", " dtype = np.float64\n", " origin = (0, 0, 0)\n", " rebuild = True\n", " tile_size = (3, 3, 3)\n", "\n", " # Setup\n", - " stencil_factory, qty_factory = get_one_tile_factory_orchestrated(\n", + " stencil_factory, qty_factory = get_factories_single_tile_orchestrated_cpu(\n", " nx=tile_size[0],\n", " ny=tile_size[1],\n", " nz=tile_size[2],\n", " nhalo=2,\n", - " backend=backend,\n", " )\n", " local_sum = LocalSum(stencil_factory, qty_factory)\n", "\n", diff --git a/examples/NDSL/README.md b/examples/NDSL/README.md new file mode 100644 index 00000000..84a6af83 --- /dev/null +++ b/examples/NDSL/README.md @@ -0,0 +1,14 @@ +# NDSL examples + +This folder contains a couple of Jupyter notebooks with the following examples: + +- Getting started with GT4Py: [GT4Py basics](./01_gt4py_basics.ipynb) +- Getting started with NDSL middleware: [NDSL basics](./02_NDSL_basics.ipynb) +- Combining stencil and non-stencil code with DaCe: [Orchestration basics](./03_orchestration_basics.ipynb) + +## Quickstart + +1. Make sure you fulfill the [requirements of NDSL](../../README.md#quickstart), e.g. python version. +2. Create a virtual environment `python -m venv .venv`, and activate it `source .venv/bin/activate`. +3. Install NDSL into your environment `pip install ../../[demos]`. +4. In VSCode, install the Jupyter extension, select your virtual environment as kernel and run the notebooks. diff --git a/examples/NDSL/basic_boilerplate.py b/examples/NDSL/basic_boilerplate.py deleted file mode 100755 index 9cd3ebe9..00000000 --- a/examples/NDSL/basic_boilerplate.py +++ /dev/null @@ -1,73 +0,0 @@ -import matplotlib.pyplot as plt - -from ndsl import ( - CompilationConfig, - DaceConfig, - DaCeOrchestration, - GridIndexing, - RunMode, - StencilConfig, - StencilFactory, -) - - -def get_one_tile_factory(nx, ny, nz, nhalo, backend) -> StencilFactory: - - dace_config = DaceConfig( - communicator=None, backend=backend, orchestration=DaCeOrchestration.Python - ) - - compilation_config = CompilationConfig( - backend=backend, - rebuild=True, - validate_args=True, - format_source=False, - device_sync=False, - run_mode=RunMode.BuildAndRun, - use_minimal_caching=False, - ) - - stencil_config = StencilConfig( - compare_to_numpy=False, - compilation_config=compilation_config, - dace_config=dace_config, - ) - - grid_indexing = GridIndexing( - domain=(nx, ny, nz), - n_halo=nhalo, - south_edge=True, - north_edge=True, - west_edge=True, - east_edge=True, - ) - - return StencilFactory(config=stencil_config, grid_indexing=grid_indexing) - - -def plot_field_at_k0(field): - - print("Min and max values:", field.max(), field.min()) - - fig = plt.figure() - fig.patch.set_facecolor("white") - ax = fig.add_subplot(111) - ax.set_facecolor(".4") - - f1 = ax.pcolormesh(field[:, :, 0]) - - cbar = plt.colorbar(f1) - plt.show() - - -def plot_field_at_kN(field, k_index=0): - - print("Min and max values:", field[:, :, k_index].max(), field[:, :, k_index].min()) - plt.xlabel("I") - plt.ylabel("J") - - im = plt.imshow(field[:, :, k_index].transpose(), origin="lower") - - plt.colorbar(im) - plt.title("Plot at K = " + str(k_index)) - plt.show() diff --git a/examples/NDSL/orch_boilerplate.py b/examples/NDSL/orch_boilerplate.py deleted file mode 100644 index f8739a3e..00000000 --- a/examples/NDSL/orch_boilerplate.py +++ /dev/null @@ -1,64 +0,0 @@ -from typing import Tuple - -import numpy as np - -from ndsl import ( - CompilationConfig, - DaceConfig, - DaCeOrchestration, - GridIndexing, - NullComm, - QuantityFactory, - RunMode, - StencilConfig, - StencilFactory, - SubtileGridSizer, - TileCommunicator, - TilePartitioner, -) - - -def get_one_tile_factory_orchestrated( - nx, ny, nz, nhalo, backend -) -> Tuple[StencilFactory, QuantityFactory]: - """Create a 1 tile grid - no boundaries""" - dace_config = DaceConfig( - communicator=None, - backend=backend, - orchestration=DaCeOrchestration.BuildAndRun, - ) - - compilation_config = CompilationConfig( - backend=backend, - rebuild=True, - validate_args=True, - format_source=False, - device_sync=False, - run_mode=RunMode.BuildAndRun, - use_minimal_caching=False, - ) - - stencil_config = StencilConfig( - compare_to_numpy=False, - compilation_config=compilation_config, - dace_config=dace_config, - ) - - partitioner = TilePartitioner((1, 1)) - sizer = SubtileGridSizer.from_tile_params( - nx_tile=nx, - ny_tile=ny, - nz=nz, - n_halo=nhalo, - extra_dim_lengths={}, - layout=partitioner.layout, - tile_partitioner=partitioner, - ) - - tile_comm = TileCommunicator(comm=NullComm(0, 1, 42), partitioner=partitioner) - - grid_indexing = GridIndexing.from_sizer_and_communicator(sizer, tile_comm) - stencil_factory = StencilFactory(config=stencil_config, grid_indexing=grid_indexing) - quantity_factory = QuantityFactory(sizer, np) - - return stencil_factory, quantity_factory diff --git a/ndsl/boilerplate.py b/ndsl/boilerplate.py index f22e0b9f..dd7c31f3 100644 --- a/ndsl/boilerplate.py +++ b/ndsl/boilerplate.py @@ -1,5 +1,6 @@ from typing import Tuple +import matplotlib.pyplot as plt import numpy as np from ndsl import ( @@ -107,3 +108,16 @@ def get_factories_single_tile_numpy( orchestration=DaCeOrchestration.Python, topology="tile", ) + + +def plot_field_at_kN(field, k_index=0): + + print("Min and max values:", field[:, :, k_index].min(), field[:, :, k_index].max()) + plt.xlabel("I") + plt.ylabel("J") + + im = plt.imshow(field[:, :, k_index].transpose(), origin="lower") + + plt.colorbar(im) + plt.title("Plot at K = " + str(k_index)) + plt.show() diff --git a/setup.py b/setup.py index abb1ccf9..f18fe4b9 100644 --- a/setup.py +++ b/setup.py @@ -13,8 +13,13 @@ def local_pkg(name: str, relative_path: str) -> str: test_requirements = ["pytest", "pytest-subtests", "coverage"] develop_requirements = test_requirements + ["pre-commit"] +demos_requirements = ["ipython", "ipykernel"] -extras_requires = {"test": test_requirements, "develop": develop_requirements} +extras_requires = { + "test": test_requirements, + "develop": develop_requirements, + "demos": demos_requirements, +} requirements: List[str] = [ local_pkg("gt4py", "external/gt4py"), @@ -29,6 +34,7 @@ def local_pkg(name: str, relative_path: str) -> str: "h5netcdf", # for xarray "dask", # for xarray "numpy==1.26.4", + "matplotlib", # for plotting in boilerplate ] From 7fda6d42f05fe92561f6e8bc409f762669160f2c Mon Sep 17 00:00:00 2001 From: Roman Cattaneo <> Date: Tue, 6 Aug 2024 15:38:00 +0200 Subject: [PATCH 117/154] Move plotting (at level k) to quantity class --- examples/NDSL/01_gt4py_basics.ipynb | 79 ++++++++++++++--------------- examples/NDSL/02_NDSL_basics.ipynb | 11 ++-- ndsl/boilerplate.py | 14 ----- ndsl/quantity.py | 17 +++++++ 4 files changed, 61 insertions(+), 60 deletions(-) diff --git a/examples/NDSL/01_gt4py_basics.ipynb b/examples/NDSL/01_gt4py_basics.ipynb index aa6ca296..ce66cfa2 100755 --- a/examples/NDSL/01_gt4py_basics.ipynb +++ b/examples/NDSL/01_gt4py_basics.ipynb @@ -43,8 +43,7 @@ "from gt4py.cartesian.gtscript import PARALLEL, computation, interval, stencil\n", "from ndsl.dsl.typing import FloatField\n", "from ndsl.quantity import Quantity\n", - "import numpy as np\n", - "from ndsl.boilerplate import plot_field_at_kN" + "import numpy as np" ] }, { @@ -145,15 +144,15 @@ "outputs": [], "source": [ "print(\"Plotting values of qty_in at K = 0\")\n", - "plot_field_at_kN(qty_in.data)\n", + "qty_in.plot_k_level(0)\n", "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data)\n", + "qty_out.plot_k_level(0)\n", "print(\"Executing `copy_stencil`\")\n", "copy_stencil(qty_in, qty_out)\n", "print(\"Plotting qty_out from `copy_stencil` at K = 0\")\n", - "plot_field_at_kN(qty_out.data)\n", + "qty_out.plot_k_level(0)\n", "print(\"Plotting qty_out from `copy_stencil` at K = 1\")\n", - "plot_field_at_kN(qty_out.data,1)" + "qty_out.plot_k_level(1)" ] }, { @@ -184,13 +183,13 @@ " )\n", "\n", "print(\"Plotting values of qty_in at K = 0\")\n", - "plot_field_at_kN(qty_in.data)\n", + "qty_in.plot_k_level(0)\n", "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data)\n", + "qty_out.plot_k_level(0)\n", "print(\"Executing `copy_stencil` with origin=(1, 0, 0)\")\n", "copy_stencil(qty_in, qty_out, origin=(1, 0, 0))\n", "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(1, 0, 0)\")\n", - "plot_field_at_kN(qty_out.data)\n", + "qty_out.plot_k_level(0)\n", "\n", "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", " dims=[\"I\", \"J\", \"K\"],\n", @@ -200,11 +199,11 @@ "\n", "print(\"Resetting qty_out to zero...\")\n", "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data)\n", + "qty_out.plot_k_level(0)\n", "print(\"Executing `copy_stencil` with origin=(0, 1, 0)\")\n", "copy_stencil(qty_in, qty_out, origin=(0, 1, 0))\n", "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0, 1, 0)\")\n", - "plot_field_at_kN(qty_out.data)\n", + "qty_out.plot_k_level(0)\n", "\n", "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", " dims=[\"I\", \"J\", \"K\"],\n", @@ -214,13 +213,13 @@ "\n", "print(\"Resetting qty_out to zero...\")\n", "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data)\n", + "qty_out.plot_k_level(0)\n", "print(\"Executing `copy_stencil` with origin = (0, 0, 1)\")\n", "copy_stencil(qty_in, qty_out, origin=(0, 0, 1))\n", "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0, 0, 1)\")\n", - "plot_field_at_kN(qty_out.data)\n", + "qty_out.plot_k_level(0)\n", "print(\"Plotting qty_out at K = 1 based on `copy_stencil` with origin=(0, 0, 1)\")\n", - "plot_field_at_kN(qty_out.data, 1)\n", + "qty_out.plot_k_level(1)\n", "\n", "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", " dims=[\"I\", \"J\", \"K\"],\n", @@ -229,13 +228,13 @@ " )\n", "print(\"Resetting qty_out to zero...\")\n", "print(\"Plotting values of qty_in at K = 0\")\n", - "plot_field_at_kN(qty_in.data)\n", + "qty_in.plot_k_level(0)\n", "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data)\n", + "qty_out.plot_k_level(0)\n", "print(\"Executing `copy_stencil` with domain=(2, 2, nz)\")\n", "copy_stencil(qty_in, qty_out, domain=(2, 2, nz))\n", "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with domain=(2, 2, nz)\")\n", - "plot_field_at_kN(qty_out.data)\n", + "qty_out.plot_k_level(0)\n", "\n", "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", " dims=[\"I\", \"J\", \"K\"],\n", @@ -244,11 +243,11 @@ " )\n", "print(\"Resetting qty_out to zero...\")\n", "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data)\n", + "qty_out.plot_k_level(0)\n", "print(\"Executing `copy_stencil` with origin=(2, 2, 0), domain=(2, 2, nz)\")\n", "copy_stencil(qty_in, qty_out, origin=(2, 2, 0), domain=(2, 2, nz))\n", "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(2, 2, 0), domain=(2, 2, nz)\")\n", - "plot_field_at_kN(qty_out.data)" + "qty_out.plot_k_level(0)" ] }, { @@ -294,11 +293,11 @@ " )\n", "\n", "print(\"Plotting values of qty_in at K = 0\")\n", - "plot_field_at_kN(qty_in.data,0)\n", + "qty_in.plot_k_level(0)\n", "print(\"Plotting values of qty_in at K = 1\")\n", - "plot_field_at_kN(qty_in.data,1)\n", + "qty_in.plot_k_level(1)\n", "print(\"Plotting values of qty_in at K = 2\")\n", - "plot_field_at_kN(qty_in.data,2)\n", + "qty_in.plot_k_level(2)\n", "\n", "@stencil(backend=backend)\n", "def mult_upward(qty_in: FloatField, qty_out: FloatField):\n", @@ -308,13 +307,13 @@ "print(\"Executing 'mult_upward' with origin=(nhalo, nhalo, 1), domain=(nx, ny, 2)\")\n", "mult_upward(qty_in, qty_out, origin=(nhalo,nhalo,1), domain=(nx,ny,2))\n", "print(\"Plotting values of qty_out at K = 0 with origin=(nhalo, nhalo, 1), domain=(nx, ny, 2)\")\n", - "plot_field_at_kN(qty_out.data, 0)\n", + "qty_out.plot_k_level(0)\n", "print(\"Plotting values of qty_out at K = 1 with origin=(nhalo, nhalo, 1), domain=(nx, ny, 2)\")\n", - "plot_field_at_kN(qty_out.data, 1)\n", + "qty_out.plot_k_level(1)\n", "print(\"Plotting values of qty_out at K = 2 with origin=(nhalo, nhalo, 1), domain=(nx, ny, 2)\")\n", - "plot_field_at_kN(qty_out.data, 2)\n", + "qty_out.plot_k_level(2)\n", "print(\"Plotting values of qty_out at K = 3 with origin=(nhalo, nhalo, 1), domain=(nx, ny, 2)\")\n", - "plot_field_at_kN(qty_out.data, 3)\n", + "qty_out.plot_k_level(3)\n", "\n", "@stencil(backend=backend)\n", "def copy_downward(qty_in: FloatField, qty_out: FloatField):\n", @@ -332,11 +331,11 @@ "copy_downward(qty_in, qty_out, origin=(1, 1, 0), domain=(nx, ny, nz-1))\n", "print(\"***\")\n", "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data, 0)\n", + "qty_out.plot_k_level(0)\n", "print(\"Plotting values of qty_out at K = 1\")\n", - "plot_field_at_kN(qty_out.data, 1)\n", + "qty_out.plot_k_level(1)\n", "print(\"Plotting values of qty_out at K = 2\")\n", - "plot_field_at_kN(qty_out.data, 2)" + "qty_out.plot_k_level(2)" ] }, { @@ -403,10 +402,10 @@ "copy_stencil(qty_in, qty_out, origin=(nhalo, nhalo, 0), domain=(nx, ny, nz))\n", "print(\"Executing 'copy_stencil' where qty_out is copied back to qty_in\")\n", "copy_stencil(qty_out, qty_in)\n", - "plot_field_at_kN(qty_in.data, 0)\n", + "qty_in.plot_k_level(0)\n", "print(\"Executing 'copy_stencil_offset' where origin=(nhalo, nhalo, 0), domain=(nx, ny, nz)\")\n", "copy_stencil_offset(qty_in, qty_out, origin=(nhalo, nhalo, 0), domain=(nx, ny, nz))\n", - "plot_field_at_kN(qty_out.data, 0)" + "qty_out.plot_k_level(0)" ] }, { @@ -438,15 +437,15 @@ " )\n", "\n", "print(\"Plotting values of qty_in at K = 0\")\n", - "plot_field_at_kN(qty_in.data, 0)\n", + "qty_in.plot_k_level(0)\n", "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data, 0)\n", + "qty_out.plot_k_level(0)\n", "print(\"Running copy_stencil with origin=(nhalo, nhalo, 0), domain=(nx, ny, 5)\")\n", "copy_stencil(qty_in, qty_out, origin=(nhalo, nhalo, 0), domain=(nx, ny, 5))\n", "print(\"Plotting values of qty_out at K = 0 based on running copy_stencil with origin=(nhalo, nhalo, 0), domain=(nx, ny, 5)\")\n", - "plot_field_at_kN(qty_out.data, 0)\n", + "qty_out.plot_k_level(0)\n", "print(\"Plotting values of qty_out at K = 1 based on running copy_stencil with origin=(nhalo, nhalo, 0), domain=(nx, ny, 5)\")\n", - "plot_field_at_kN(qty_out.data, 1)\n", + "qty_out.plot_k_level(1)\n", "\n", "@stencil(backend=backend)\n", "def stencil_if_zero(in_out_field: FloatField):\n", @@ -458,9 +457,9 @@ "print(\"Running 'stencil_if_zero' on qty_out\")\n", "stencil_if_zero(qty_out)\n", "print(\"Plotting values of qty_out at K = 0 based on running stencil_if_zero\")\n", - "plot_field_at_kN(qty_out.data,0)\n", + "qty_out.plot_k_level(0)\n", "print(\"Plotting values of qty_out at K = 1 based on running stencil_if_zero\")\n", - "plot_field_at_kN(qty_out.data,1)" + "qty_out.plot_k_level(1)" ] }, { @@ -513,13 +512,13 @@ " )\n", "\n", "print(\"Plotting values of qty_in at K = 0\")\n", - "plot_field_at_kN(qty_in.data)\n", + "qty_in.plot_k_level(0)\n", "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data)\n", + "qty_out.plot_k_level(0)\n", "print(\"Executing 'field_plus_one'\")\n", "field_plus_one(qty_in, qty_out)\n", "print(\"Plotting values of qty_out at K = 0 after executing 'field_plus_one'\")\n", - "plot_field_at_kN(qty_out.data)" + "qty_out.plot_k_level(0)" ] } ], diff --git a/examples/NDSL/02_NDSL_basics.ipynb b/examples/NDSL/02_NDSL_basics.ipynb index 30465698..eac17cad 100644 --- a/examples/NDSL/02_NDSL_basics.ipynb +++ b/examples/NDSL/02_NDSL_basics.ipynb @@ -26,7 +26,7 @@ "outputs": [], "source": [ "from ndsl import StencilFactory\n", - "from ndsl.boilerplate import get_factories_single_tile_numpy, plot_field_at_kN\n", + "from ndsl.boilerplate import get_factories_single_tile_numpy\n", "\n", "nx = 6\n", "ny = 6\n", @@ -124,7 +124,6 @@ "metadata": {}, "outputs": [], "source": [ - "import gt4py.storage as gt_storage\n", "from ndsl.quantity import Quantity\n", "import numpy as np\n", "\n", @@ -149,9 +148,9 @@ " gt4py_backend=backend)\n", "\n", "print(\"Plotting qty_in at K = 0\")\n", - "plot_field_at_kN(qty_in.data)\n", + "qty_in.plot_k_level(0)\n", "print(\"Plotting qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data)\n" + "qty_out.plot_k_level(0)\n" ] }, { @@ -172,7 +171,7 @@ "print(\"Copying copy_field stencil\")\n", "copy_field(qty_in, qty_out)\n", "print(\"Plotting qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data)" + "qty_out.plot_k_level(0)" ] }, { @@ -243,7 +242,7 @@ "print(\"Executing copy_field_offset stencil\")\n", "copy_field_offset(qty_in, qty_out)\n", "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data)" + "qty_out.plot_k_level(0)" ] }, { diff --git a/ndsl/boilerplate.py b/ndsl/boilerplate.py index dd7c31f3..f22e0b9f 100644 --- a/ndsl/boilerplate.py +++ b/ndsl/boilerplate.py @@ -1,6 +1,5 @@ from typing import Tuple -import matplotlib.pyplot as plt import numpy as np from ndsl import ( @@ -108,16 +107,3 @@ def get_factories_single_tile_numpy( orchestration=DaCeOrchestration.Python, topology="tile", ) - - -def plot_field_at_kN(field, k_index=0): - - print("Min and max values:", field[:, :, k_index].min(), field[:, :, k_index].max()) - plt.xlabel("I") - plt.ylabel("J") - - im = plt.imshow(field[:, :, k_index].transpose(), origin="lower") - - plt.colorbar(im) - plt.title("Plot at K = " + str(k_index)) - plt.show() diff --git a/ndsl/quantity.py b/ndsl/quantity.py index dc30c685..b95a9aad 100644 --- a/ndsl/quantity.py +++ b/ndsl/quantity.py @@ -2,6 +2,7 @@ import warnings from typing import Any, Dict, Iterable, Optional, Sequence, Tuple, Union, cast +import matplotlib.pyplot as plt import numpy as np import ndsl.constants as constants @@ -593,6 +594,22 @@ def transpose( transposed._attrs = self._attrs return transposed + def plot_k_level(self, k_index=0): + field = self.data + print( + "Min and max values:", + field[:, :, k_index].min(), + field[:, :, k_index].max(), + ) + plt.xlabel("I") + plt.ylabel("J") + + im = plt.imshow(field[:, :, k_index].transpose(), origin="lower") + + plt.colorbar(im) + plt.title("Plot at K = " + str(k_index)) + plt.show() + def transpose_sequence(sequence, order): return sequence.__class__(sequence[i] for i in order) From 24b4a3f8fb116e2f1a87e2c2e0e971d7a88ca04f Mon Sep 17 00:00:00 2001 From: Roman Cattaneo <> Date: Tue, 6 Aug 2024 17:50:08 +0200 Subject: [PATCH 118/154] Remove executable flag on GT4Py example notebook For some reason, this file was had the executable flag, marking it an executable under linux-based filesystem. Since notebooks aren't directly executed and rather read by Jupyter (or whatever platform), this is unnecessary. Other notebooks didn't have the executable flag (which is what I would expect). --- examples/NDSL/01_gt4py_basics.ipynb | 0 1 file changed, 0 insertions(+), 0 deletions(-) mode change 100755 => 100644 examples/NDSL/01_gt4py_basics.ipynb diff --git a/examples/NDSL/01_gt4py_basics.ipynb b/examples/NDSL/01_gt4py_basics.ipynb old mode 100755 new mode 100644 From 6fc7158563d41b22ab0a9657e27f464a80a07063 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Tue, 6 Aug 2024 13:26:16 -0400 Subject: [PATCH 119/154] Better error when missing data from the netCDF --- ndsl/stencils/testing/test_translate.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/ndsl/stencils/testing/test_translate.py b/ndsl/stencils/testing/test_translate.py index 9adf3208..41e3cb4e 100644 --- a/ndsl/stencils/testing/test_translate.py +++ b/ndsl/stencils/testing/test_translate.py @@ -262,7 +262,12 @@ def test_sequential_savepoint( case.testobj.serialnames(case.testobj.in_vars["data_vars"]) + case.testobj.in_vars["parameters"] ) - input_data = {name: input_data[name] for name in input_names} + try: + input_data = {name: input_data[name] for name in input_names} + except KeyError as e: + raise KeyError( + f"Variable {e} was described in the translate test but cannot be found in the netCDF" + ) original_input_data = copy.deepcopy(input_data) # run python version of functionality output = case.testobj.compute(input_data) From 1bda968732eb657c58339b0a9baf87c95b55be43 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Tue, 20 Aug 2024 15:13:10 -0400 Subject: [PATCH 120/154] Added conditional to MetricTerms init to allow for metric term generation for surface level (no eta_file specified) --- ndsl/grid/generation.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/ndsl/grid/generation.py b/ndsl/grid/generation.py index 275db563..c58a6838 100644 --- a/ndsl/grid/generation.py +++ b/ndsl/grid/generation.py @@ -297,12 +297,13 @@ def __init__( self._dy_center = None self._area = None self._area_c = None - ( - self._ks, - self._ptop, - self._ak, - self._bk, - ) = self._set_hybrid_pressure_coefficients(eta_file, ak, bk) + if eta_file != "None": + ( + self._ks, + self._ptop, + self._ak, + self._bk, + ) = self._set_hybrid_pressure_coefficients(eta_file, ak, bk) self._ec1 = None self._ec2 = None self._ew1 = None From d0c17033dcc48bbb74761380f55f890e8f29263d Mon Sep 17 00:00:00 2001 From: Oliver Elbert Date: Wed, 21 Aug 2024 14:27:23 -0400 Subject: [PATCH 121/154] Support for pbl scheme (#66) This PR adds features needed for the ported PBL scheme. Adding relevant namelist switches, Including a few useful physics constants and some infrastructure for bool fields and 4d fields --- ndsl/constants.py | 5 ++++- ndsl/dsl/typing.py | 9 +++++++++ ndsl/namelist.py | 32 ++++++++++++++++++++++++++++++++ 3 files changed, 45 insertions(+), 1 deletion(-) diff --git a/ndsl/constants.py b/ndsl/constants.py index d0b512b5..0f7d55da 100644 --- a/ndsl/constants.py +++ b/ndsl/constants.py @@ -128,6 +128,7 @@ class ConstantVersions(Enum): CV_VAP = 3.0 * RVGAS # Heat capacity of water vapor at constant volume ZVIR = RVGAS / RDGAS - 1 # con_fvirt in Fortran physics C_ICE = 1972.0 # Heat capacity of ice at -15 degrees Celsius +C_ICE_0 = 2106.0 # Heat capacity of ice at 0 degrees Celsius C_LIQ = 4.1855e3 # Heat capacity of water at 15 degrees Celsius CP_VAP = 4.0 * RVGAS # Heat capacity of water vapor at constant pressure TICE = 273.16 # Freezing temperature @@ -136,6 +137,7 @@ class ConstantVersions(Enum): D2ICE = DC_VAP + DC_ICE # Isobaric heating / cooling LI0 = HLF - DC_ICE * TICE EPS = RDGAS / RVGAS +EPSM1 = EPS - 1.0 LV0 = ( HLV - DC_VAP * TICE ) # 3.13905782e6, evaporation latent heat coefficient at 0 degrees Kelvin @@ -145,7 +147,8 @@ class ConstantVersions(Enum): LI2 = ( LV0 + LI00 ) # 2.86799816e6, sublimation latent heat coefficient at 0 degrees Kelvin -E00 = 611.21 # Saturation vapor pressure at 0 degrees Celsius +E00 = 611.21 # Saturation vapor pressure at 0 degrees Celsius (Pa) +PSAT = 610.78 # Saturation vapor pressure at H2O 3pt (Pa) T_WFR = TICE - 40.0 # homogeneous freezing temperature TICE0 = TICE - 0.01 T_MIN = 178.0 # Minimum temperature to freeze-dry all water vapor diff --git a/ndsl/dsl/typing.py b/ndsl/dsl/typing.py index d85ee30f..5eab76ef 100644 --- a/ndsl/dsl/typing.py +++ b/ndsl/dsl/typing.py @@ -63,10 +63,19 @@ def global_set_floating_point_precision(): IntFieldIJ = Field[gtscript.IJ, Int] IntFieldK = Field[gtscript.K, Int] BoolField = Field[gtscript.IJK, Bool] +BoolFieldIJ = Field[gtscript.IJ, Bool] Index3D = Tuple[int, int, int] +def set_4d_field_size(n, dtype): + """ + Defines a 4D field with a given size and type + The extra data dimension is not parallel + """ + return Field[gtscript.IJK, (dtype, (n,))] + + def cast_to_index3d(val: Tuple[int, ...]) -> Index3D: if len(val) != 3: raise ValueError(f"expected 3d index, received {val}") diff --git a/ndsl/namelist.py b/ndsl/namelist.py index 71a1f1ca..205954ca 100644 --- a/ndsl/namelist.py +++ b/ndsl/namelist.py @@ -111,6 +111,22 @@ class NamelistDefaults: tice = 273.16 # set tice = 165. to turn off ice - phase phys (kessler emulator) alin = 842.0 # "a" in lin1983 clin = 4.8 # "c" in lin 1983, 4.8 -- > 6. (to ehance ql -- > qs) + isatmedmf = 0 # which version of satmedmfvdif to use + dspheat = False # flag for tke dissipative heating + xkzm_h = 1.0 # background vertical diffusion for heat q over ocean + xkzm_m = 1.0 # background vertical diffusion for momentum over ocean + xkzm_hl = 1.0 # background vertical diffusion for heat q over land + xkzm_ml = 1.0 # background vertical diffusion for momentum over land + xkzm_hi = 1.0 # background vertical diffusion for heat q over ice + xkzm_mi = 1.0 # background vertical diffusion for momentum over ice + xkzm_s = 1.0 # sigma threshold for background mom. diffusion + xkzm_lim = 0.01 # background vertical diffusion limit + xkzminv = 0.15 # diffusivity in inversion layers + xkgdx = 25.0e3 # background vertical diffusion threshold + rlmn = 30.0 # lower-limter on asymtotic mixing length in satmedmfdiff + rlmx = 300.0 # upper-limter on asymtotic mixing length in satmedmfdiff + do_dk_hb19 = False # flag for using hb19 background diff formula in satmedmfdiff + cap_k0_land = False # flag for applying limter on background diff in inversion layer over land in satmedmfdiff @classmethod def as_dict(cls): @@ -293,6 +309,22 @@ class Namelist: tice: float = NamelistDefaults.tice alin: float = NamelistDefaults.alin clin: float = NamelistDefaults.clin + isatmedmf: int = NamelistDefaults.isatmedmf + dspheat: bool = NamelistDefaults.dspheat + xkzm_h: float = NamelistDefaults.xkzm_h + xkzm_m: float = NamelistDefaults.xkzm_m + xkzm_hl: float = NamelistDefaults.xkzm_hl + xkzm_ml: float = NamelistDefaults.xkzm_ml + xkzm_hi: float = NamelistDefaults.xkzm_hi + xkzm_mi: float = NamelistDefaults.xkzm_mi + xkzm_s: float = NamelistDefaults.xkzm_s + xkzm_lim: float = NamelistDefaults.xkzm_lim + xkzminv: float = NamelistDefaults.xkzminv + xkgdx: float = NamelistDefaults.xkgdx + rlmn: float = NamelistDefaults.rlmn + rlmx: float = NamelistDefaults.rlmx + do_dk_hb19: bool = NamelistDefaults.do_dk_hb19 + cap_k0_land: bool = NamelistDefaults.cap_k0_land # c0s_shal: Any # c1_shal: Any # cal_pre: Any From b18880b666ed00e9231749a9fdaacee4488a4291 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 22 Aug 2024 10:29:49 -0400 Subject: [PATCH 122/154] Changes to support testing in pace for eta file specification --- ndsl/grid/eta.py | 4 +--- ndsl/grid/generation.py | 21 +++++++++++++++++++++ 2 files changed, 22 insertions(+), 3 deletions(-) diff --git a/ndsl/grid/eta.py b/ndsl/grid/eta.py index 90db8c4a..1015312d 100644 --- a/ndsl/grid/eta.py +++ b/ndsl/grid/eta.py @@ -30,10 +30,8 @@ class HybridPressureCoefficients: def _load_ak_bk_from_file(eta_file: str) -> Tuple[np.ndarray, np.ndarray]: - if eta_file == "None": - raise ValueError("eta file not specified") if not os.path.isfile(eta_file): - raise ValueError("file " + eta_file + " does not exist") + raise ValueError("eta file does not exist") # read file into ak, bk arrays data = xr.open_dataset(eta_file) diff --git a/ndsl/grid/generation.py b/ndsl/grid/generation.py index c58a6838..a42edfdf 100644 --- a/ndsl/grid/generation.py +++ b/ndsl/grid/generation.py @@ -304,6 +304,27 @@ def __init__( self._ak, self._bk, ) = self._set_hybrid_pressure_coefficients(eta_file, ak, bk) + else: + ks = self.quantity_factory.zeros( + [], + "", + dtype=Float, + ) + ptop = self.quantity_factory.zeros( + [], + "Pa", + dtype=Float, + ) + ak = self.quantity_factory.zeros( + [Z_INTERFACE_DIM], + "Pa", + dtype=Float, + ) + bk = self.quantity_factory.zeros( + [Z_INTERFACE_DIM], + "", + dtype=Float, + ) self._ec1 = None self._ec2 = None self._ew1 = None From 5ce87f1d44a52398229b77ce47ed8fa10779209e Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Fri, 23 Aug 2024 14:49:25 -0400 Subject: [PATCH 123/154] Multi modal float metric (see comparison.py) Refactor previous metric in `LegacyMetric` Add `--multimodal_metric` option to translate Clean up failure triggering stack dumps --- ndsl/stencils/testing/conftest.py | 11 + ndsl/stencils/testing/test_translate.py | 200 ++++++----------- ndsl/testing/comparison.py | 287 +++++++++++++++++++----- 3 files changed, 308 insertions(+), 190 deletions(-) diff --git a/ndsl/stencils/testing/conftest.py b/ndsl/stencils/testing/conftest.py index bd8b2faf..af5bb6a6 100644 --- a/ndsl/stencils/testing/conftest.py +++ b/ndsl/stencils/testing/conftest.py @@ -82,6 +82,12 @@ def pytest_addoption(parser): default="cubed-sphere", help='Topology of the grid. "cubed-sphere" means a 6-faced grid, "doubly-periodic" means a 1 tile grid. Default to "cubed-sphere".', ) + parser.addoption( + "--multimodal_metric", + action="store_true", + default=False, + help="Use the multi-modal float metric. Default to False.", + ) def pytest_configure(config): @@ -389,6 +395,11 @@ def failure_stride(pytestconfig): return int(pytestconfig.getoption("failure_stride")) +@pytest.fixture() +def multimodal_metric(pytestconfig): + return bool(pytestconfig.getoption("multimodal_metric")) + + @pytest.fixture() def grid(pytestconfig): return pytestconfig.getoption("grid") diff --git a/ndsl/stencils/testing/test_translate.py b/ndsl/stencils/testing/test_translate.py index 41e3cb4e..10c3b90c 100644 --- a/ndsl/stencils/testing/test_translate.py +++ b/ndsl/stencils/testing/test_translate.py @@ -15,7 +15,7 @@ from ndsl.quantity import Quantity from ndsl.restart._legacy_restart import RESTART_PROPERTIES from ndsl.stencils.testing.savepoint import SavepointCase, dataset_to_dict -from ndsl.testing.comparison import compare_scalar, success, success_array +from ndsl.testing.comparison import MultiModalFloatMetric, LegacyMetric from ndsl.testing.perturbation import perturb @@ -32,97 +32,6 @@ def platform(): return "docker" if in_docker else "metal" -def sample_wherefail( - computed_data, - ref_data, - eps, - print_failures, - failure_stride, - test_name, - ignore_near_zero_errors, - near_zero, - xy_indices=False, -): - found_indices = np.where( - np.logical_not( - success_array( - computed_data, ref_data, eps, ignore_near_zero_errors, near_zero - ) - ) - ) - computed_failures = computed_data[found_indices] - reference_failures = ref_data[found_indices] - - # List all errors - return_strings = [] - bad_indices_count = len(found_indices[0]) - # Determine worst result - worst_metric_err = 0.0 - abs_errs = [] - for b in range(bad_indices_count): - full_index = [f[b] for f in found_indices] - metric_err = compare_scalar(computed_failures[b], reference_failures[b]) - abs_errs.append(abs(computed_failures[b] - reference_failures[b])) - if print_failures and b % failure_stride == 0: - return_strings.append( - f"index: {full_index}, computed {computed_failures[b]}, " - f"reference {reference_failures[b]}, " - f"absolute diff {abs_errs[-1]:.3e}, " - f"metric diff: {metric_err:.3e}" - ) - if np.isnan(metric_err) or (metric_err > worst_metric_err): - worst_metric_err = metric_err - worst_full_idx = full_index - worst_abs_err = abs_errs[-1] - computed_worst = computed_failures[b] - reference_worst = reference_failures[b] - # Try to quantify noisy errors - unique_errors = len(np.unique(np.array(abs_errs))) - # Summary and worst result - fullcount = len(ref_data.flatten()) - return_strings.append( - f"Failed count: {bad_indices_count}/{fullcount} " - f"({round(100.0 * (bad_indices_count / fullcount), 2)}%),\n" - f"Worst failed index {worst_full_idx}\n" - f"\tcomputed:{computed_worst}\n" - f"\treference: {reference_worst}\n" - f"\tabsolute diff: {worst_abs_err:.3e}\n" - f"\tmetric diff: {worst_metric_err:.3e}\n" - f"Noise quantification:\n" - f"\tunique errors: {unique_errors}/{bad_indices_count}\n" - ) - - if xy_indices: - if len(computed_data.shape) == 3: - axis = 2 - any = np.any - elif len(computed_data.shape) == 4: - axis = (2, 3) - any = np.any - else: - axis = None - - def any(array, axis): - return array - - found_xy_indices = np.where( - any( - np.logical_not( - success_array( - computed_data, ref_data, eps, ignore_near_zero_errors, near_zero - ) - ), - axis=axis, - ) - ) - - return_strings.append( - "Failed horizontal indices:" + str(list(zip(*found_xy_indices))) - ) - - return "\n".join(return_strings) - - def process_override(threshold_overrides, testobj, test_name, backend): override = threshold_overrides.get(test_name, None) if override is not None: @@ -234,6 +143,7 @@ def test_sequential_savepoint( subtests, caplog, threshold_overrides, + multimodal_metric, xy_indices=True, ): if case.testobj is None: @@ -283,23 +193,24 @@ def test_sequential_savepoint( with subtests.test(varname=varname): failing_names.append(varname) output_data = gt_utils.asarray(output[varname]) - assert success( - output_data, - ref_data, - case.testobj.max_error, - ignore_near_zero, - case.testobj.near_zero, - ), sample_wherefail( - output_data, - ref_data, - case.testobj.max_error, - print_failures, - failure_stride, - case.savepoint_name, - ignore_near_zero_errors=ignore_near_zero, - near_zero=case.testobj.near_zero, - xy_indices=xy_indices, - ) + if multimodal_metric: + metric = MultiModalFloatMetric( + reference_values=ref_data, + computed_values=output_data, + eps=case.testobj.max_error, + ignore_near_zero_errors=ignore_near_zero, + near_zero=case.testobj.near_zero, + ) + else: + metric = LegacyMetric( + reference_values=ref_data, + computed_values=output_data, + eps=case.testobj.max_error, + ignore_near_zero_errors=ignore_near_zero, + near_zero=case.testobj.near_zero, + ) + if not metric.check: + pytest.fail(str(metric), pytrace=False) passing_names.append(failing_names.pop()) ref_data_out[varname] = [ref_data] if len(failing_names) > 0: @@ -317,8 +228,12 @@ def test_sequential_savepoint( failing_names, out_filename, ) - assert failing_names == [], f"only the following variables passed: {passing_names}" - assert len(passing_names) > 0, "No tests passed" + if failing_names != []: + pytest.fail( + f"Only the following variables passed: {passing_names}", pytrace=False + ) + if len(passing_names) == 0: + pytest.fail("No tests passed") def state_from_savepoint(serializer, savepoint, name_to_std_name): @@ -364,6 +279,7 @@ def test_parallel_savepoint( caplog, threshold_overrides, grid, + multimodal_metric, xy_indices=True, ): if MPI.COMM_WORLD.Get_size() % 6 != 0: @@ -420,23 +336,24 @@ def test_parallel_savepoint( with subtests.test(varname=varname): failing_names.append(varname) output_data = gt_utils.asarray(output[varname]) - assert success( - output_data, - ref_data[varname][0], - case.testobj.max_error, - ignore_near_zero, - case.testobj.near_zero, - ), sample_wherefail( - output_data, - ref_data[varname][0], - case.testobj.max_error, - print_failures, - failure_stride, - case.savepoint_name, - ignore_near_zero, - case.testobj.near_zero, - xy_indices, - ) + if multimodal_metric: + metric = MultiModalFloatMetric( + reference_values=ref_data[varname][0], + computed_values=output_data, + eps=case.testobj.max_error, + ignore_near_zero_errors=ignore_near_zero, + near_zero=case.testobj.near_zero, + ) + else: + metric = LegacyMetric( + reference_values=ref_data[varname][0], + computed_values=output_data, + eps=case.testobj.max_error, + ignore_near_zero_errors=ignore_near_zero, + near_zero=case.testobj.near_zero, + ) + if not metric.check: + pytest.fail(str(metric), pytrace=False) passing_names.append(failing_names.pop()) if len(failing_names) > 0: os.makedirs(OUTDIR, exist_ok=True) @@ -457,8 +374,12 @@ def test_parallel_savepoint( ) except Exception as error: print(f"TestParallel SaveNetCDF Error: {error}") - assert failing_names == [], f"only the following variables passed: {passing_names}" - assert len(passing_names) > 0, "No tests passed" + if failing_names != []: + pytest.fail( + f"Only the following variables passed: {passing_names}", pytrace=False + ) + if len(passing_names) == 0: + pytest.fail("No tests passed") def save_netcdf( @@ -474,6 +395,7 @@ def save_netcdf( data_vars = {} for i, varname in enumerate(failing_names): + # Read in dimensions and attributes if hasattr(testobj, "outputs"): dims = [dim_name + f"_{i}" for dim_name in testobj.outputs[varname]["dims"]] attrs = {"units": testobj.outputs[varname]["units"]} @@ -482,27 +404,33 @@ def save_netcdf( f"dim_{varname}_{j}" for j in range(len(ref_data[varname][0].shape)) ] attrs = {"units": "unknown"} + + # Try to save inputs try: - data_vars[f"{varname}_in"] = xr.DataArray( + data_vars[f"{varname}_input"] = xr.DataArray( np.stack([in_data[varname] for in_data in inputs_list]), dims=("rank",) + tuple([f"{d}_in" for d in dims]), attrs=attrs, ) except KeyError as error: print(f"No input data found for {error}") - data_vars[f"{varname}_ref"] = xr.DataArray( + + # Reference, computed and error computation + data_vars[f"{varname}_reference"] = xr.DataArray( np.stack(ref_data[varname]), dims=("rank",) + tuple([f"{d}_out" for d in dims]), attrs=attrs, ) - data_vars[f"{varname}_out"] = xr.DataArray( + data_vars[f"{varname}_computed"] = xr.DataArray( np.stack([output[varname] for output in output_list]), dims=("rank",) + tuple([f"{d}_out" for d in dims]), attrs=attrs, ) - data_vars[f"{varname}_error"] = ( - data_vars[f"{varname}_ref"] - data_vars[f"{varname}_out"] + absolute_errors = ( + data_vars[f"{varname}_reference"] - data_vars[f"{varname}_computed"] ) - data_vars[f"{varname}_error"].attrs = attrs + data_vars[f"{varname}_absolute_error"] = absolute_errors + data_vars[f"{varname}_absolute_error"].attrs = attrs + print(f"File saved to {out_filename}") xr.Dataset(data_vars=data_vars).to_netcdf(out_filename) diff --git a/ndsl/testing/comparison.py b/ndsl/testing/comparison.py index 0ffe55ed..636f2a3f 100644 --- a/ndsl/testing/comparison.py +++ b/ndsl/testing/comparison.py @@ -1,68 +1,247 @@ from typing import Union import numpy as np +import numpy.typing as npt -def compare_arr(computed_data, ref_data): - """ - Smooth error near zero values. - Inputs are arrays. +class BaseMetric: + def __init__( + self, + reference_values: np.ndarray, + computed_values: np.ndarray, + ): + self.references = np.atleast_1d(reference_values) + self.computed = np.atleast_1d(computed_values) + self.check = False + + def __str__(self) -> str: ... + + def __repr__(self) -> str: ... + + +class LegacyMetric(BaseMetric): + """Legacy (AI2) metric used for original FV3 port. + + This metric attempts to smooth error comparison around 0. + It further tries to deal with close-to-0 breakdown of absolute + error by allowing `near_zero` threshold to be specified by hand. """ - if ref_data.dtype in (np.float64, np.int64, np.float32, np.int32): - denom = np.abs(ref_data) + np.abs(computed_data) - compare = np.asarray(2.0 * np.abs(computed_data - ref_data) / denom) - compare[denom == 0] = 0.0 - return compare - elif ref_data.dtype in (np.bool,): - return np.logical_xor(computed_data, ref_data) - else: - raise TypeError(f"recieved data with unexpected dtype {ref_data.dtype}") - - -def compare_scalar(computed_data: np.float64, ref_data: np.float64) -> np.float64: - """Smooth error near zero values. Scalar versions.""" - err_as_array = compare_arr(np.atleast_1d(computed_data), np.atleast_1d(ref_data)) - return err_as_array[0] - - -def success_array( - computed_data: np.ndarray, - ref_data: np.ndarray, - eps: float, - ignore_near_zero_errors: Union[dict, bool], - near_zero: float, -): - success = np.logical_or( - np.logical_and(np.isnan(computed_data), np.isnan(ref_data)), - compare_arr(computed_data, ref_data) < eps, - ) - if isinstance(ignore_near_zero_errors, dict): - if ignore_near_zero_errors.keys(): - near_zero = ignore_near_zero_errors["near_zero"] + + def __init__( + self, + reference_values: np.ndarray, + computed_values: np.ndarray, + eps: float, + ignore_near_zero_errors: Union[dict, bool], + near_zero: float, + ): + super().__init__(reference_values, computed_values) + self.eps = eps + self.success = self._compute_errors( + ignore_near_zero_errors, + near_zero, + ) + self.check = np.all(self.success) + self._calculated_metric = np.empty_like(self.references) + + def _compute_errors( + self, + ignore_near_zero_errors, + near_zero, + ) -> npt.NDArray[np.bool_]: + if self.references.dtype in (np.float64, np.int64, np.float32, np.int32): + denom = np.abs(self.references) + np.abs(self.computed) + self._calculated_metric = np.asarray( + 2.0 * np.abs(self.computed - self.references) / denom + ) + self._calculated_metric[denom == 0] = 0.0 + elif self.references.dtype in (np.bool_, bool): + self._calculated_metric = np.logical_xor(self.computed, self.references) + else: + raise TypeError( + f"recieved data with unexpected dtype {self.references.dtype}" + ) + success = np.logical_or( + np.logical_and(np.isnan(self.computed), np.isnan(self.references)), + self._calculated_metric < self.eps, + ) + if isinstance(ignore_near_zero_errors, dict): + if ignore_near_zero_errors.keys(): + near_zero = ignore_near_zero_errors["near_zero"] + success = np.logical_or( + success, + np.logical_and( + np.abs(self.computed) < near_zero, + np.abs(self.references) < near_zero, + ), + ) + elif ignore_near_zero_errors: success = np.logical_or( success, np.logical_and( - np.abs(computed_data) < near_zero, - np.abs(ref_data) < near_zero, + np.abs(self.computed) < near_zero, + np.abs(self.references) < near_zero, ), ) - elif ignore_near_zero_errors: - success = np.logical_or( - success, - np.logical_and( - np.abs(computed_data) < near_zero, np.abs(ref_data) < near_zero - ), - ) - return success + return success + def __str__(self) -> str: + return self.__repr__() -def success(computed_data, ref_data, eps, ignore_near_zero_errors, near_zero=0.0): - return np.all( - success_array( - np.asarray(computed_data), - np.asarray(ref_data), - eps, - ignore_near_zero_errors, - near_zero, + def __repr__(self) -> str: + report = [] + report.append("✅ Success" if self.check else "❌ Numerical failures") + + found_indices = np.logical_not(self.success).nonzero() + computed_failures = self.computed[found_indices] + reference_failures = self.references[found_indices] + + # List all errors + bad_indices_count = len(found_indices[0]) + # Determine worst result + worst_metric_err = 0.0 + abs_errs = [] + details = [ + "All failures:", + "Index Computed Reference Absloute E Metric E", + ] + for b in range(bad_indices_count): + full_index = tuple([f[b] for f in found_indices]) + + metric_err = self._calculated_metric[full_index] + + absolute_distance = abs(computed_failures[b] - reference_failures[b]) + abs_errs.append(absolute_distance) + + details.append( + f"{full_index} {computed_failures[b]} " + f"{reference_failures[b]} {abs_errs[-1]:.3e} {metric_err:.3e}" + ) + + if np.isnan(metric_err) or (metric_err > worst_metric_err): + worst_metric_err = metric_err + worst_full_idx = full_index + worst_abs_err = abs_errs[-1] + computed_worst = computed_failures[b] + reference_worst = reference_failures[b] + # Try to quantify noisy errors + unique_errors = len(np.unique(np.array(abs_errs))) + # Summary and worst result + fullcount = len(self.references.flatten()) + report.append( + f"Failed count: {bad_indices_count}/{fullcount} " + f"({round(100.0 * (bad_indices_count / fullcount), 2)}%),\n" + f"Worst failed index {worst_full_idx}\n" + f" Computed:{computed_worst}\n" + f" Reference: {reference_worst}\n" + f" Absolute diff: {worst_abs_err:.3e}\n" + f" Metric diff: {worst_metric_err:.3e}\n" + f" Metric threshold: {self.eps}\n" + f" Noise quantification:\n" + f" Reference dtype: {type(reference_worst)}\n" + f" Unique errors: {unique_errors}/{bad_indices_count}" ) - ) + report.extend(details) + + return "\n".join(report) + + +class MultiModalFloatMetric(BaseMetric): + """Combination of absolute, relative & ULP comparison for floats + + This metric attempts to combine well known comparison on floats + to leverage a robust 32/64 bit float comparison on large accumulating + floating errors. + + ULP is used to clear noise (ULP<=1.0 passes) + Absolute errors for large amplitute + """ + + def __init__( + self, + reference_values: np.ndarray, + computed_values: np.ndarray, + eps: float, + **kwargs, + ): + super().__init__(reference_values, computed_values) + self.eps = eps + self.absolute_distance = np.empty_like(self.references) + self.absolute_distance_metric = np.empty_like(self.references, dtype=np.bool_) + self.relative_distance = np.empty_like(self.references) + self.relative_distance_metric = np.empty_like(self.references, dtype=np.bool_) + self.ulp_distance = np.empty_like(self.references) + self.ulp_distance_metric = np.empty_like(self.references, dtype=np.bool_) + + self.relative_fraction = 0.000001 + self.absolute_eps = 1.0e-13 + self.ulp_threshold = 1.0 + + self.success = self._compute_all_metrics() + self.check = np.all(self.success) + + def _compute_all_metrics( + self, + ) -> npt.NDArray[np.bool_]: + if self.references.dtype in (np.float64, np.int64, np.float32, np.int32): + max_values = np.maximum( + np.absolute(self.computed), np.absolute(self.references) + ) + # Absolute distance + self.absolute_distance = np.absolute(self.computed - self.references) + self.absolute_distance_metric = self.absolute_distance < 1.0e-13 + # Relative distance (in pct) + self.relative_distance = np.divide(self.absolute_distance, max_values) + self.relative_distance_metric = ( + self.absolute_distance < 0.000001 * max_values + ) + # ULP distance + self.ulp_distance = np.divide( + self.absolute_distance, np.spacing(max_values) + ) + self.ulp_distance_metric = self.ulp_distance <= self.ulp_threshold + + # Combine all distances into sucess or failure + success = np.logical_and(np.isnan(self.computed), np.isnan(self.references)) + success = np.logical_or(success, self.absolute_distance_metric) + success = np.logical_or(success, self.relative_distance_metric) + success = np.logical_or(success, self.ulp_distance_metric) + return success + elif self.references.dtype in (np.bool_, bool): + success = np.logical_xor(self.computed, self.references) + return success + else: + raise TypeError( + f"recieved data with unexpected dtype {self.references.dtype}" + ) + + def __str__(self) -> str: + return self.__repr__() + + def __repr__(self) -> str: + report = [] + report.append("✅ Success" if self.check else "❌ Numerical failures") + + found_indices = np.logical_not(self.success).nonzero() + # List all errors + bad_indices_count = len(found_indices[0]) + full_count = len(self.references.flatten()) + failures_pct = round(100.0 * (bad_indices_count / full_count), 2) + report = [ + f"All failures ({bad_indices_count}/{full_count}) ({failures_pct}%),\n", + f"Index Computed Reference " + f"Absolute E(<{self.absolute_eps:.2e}) " + f"Relative E(<{self.relative_fraction*100:.2e}%) " + f"ULP E(<{self.ulp_threshold})", + ] + # Summary and worst result + for iBad in range(bad_indices_count): + fi = tuple([f[iBad] for f in found_indices]) + report.append( + f"({fi[0]:02}, {fi[1]:02}, {fi[2]:02}) {self.computed[fi]:.16e} {self.references[fi]:.16e} " + f"{self.absolute_distance[fi]:.2e} {'✅' if self.absolute_distance_metric[fi] else '❌'} " + f"{self.relative_distance[fi] * 100:.2e} {'✅' if self.relative_distance_metric[fi] else '❌'} " + f"{int(self.ulp_distance[fi]):02} {'✅' if self.ulp_distance_metric[fi] else '❌'} " + ) + + return "\n".join(report) From 59a529c8852a1d230b2b49a9a6959585d9d6b4b7 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Tue, 27 Aug 2024 08:53:49 -0400 Subject: [PATCH 124/154] Clamp f32 to 1e-10 Fix metric to require no NaNs --- ndsl/testing/comparison.py | 26 ++++++++++++++++++-------- 1 file changed, 18 insertions(+), 8 deletions(-) diff --git a/ndsl/testing/comparison.py b/ndsl/testing/comparison.py index 636f2a3f..31fda0e2 100644 --- a/ndsl/testing/comparison.py +++ b/ndsl/testing/comparison.py @@ -157,6 +157,9 @@ class MultiModalFloatMetric(BaseMetric): Absolute errors for large amplitute """ + _f32_absolute_eps = 1e-10 + _f64_absolute_eps = 1e-13 + def __init__( self, reference_values: np.ndarray, @@ -165,7 +168,6 @@ def __init__( **kwargs, ): super().__init__(reference_values, computed_values) - self.eps = eps self.absolute_distance = np.empty_like(self.references) self.absolute_distance_metric = np.empty_like(self.references, dtype=np.bool_) self.relative_distance = np.empty_like(self.references) @@ -174,7 +176,10 @@ def __init__( self.ulp_distance_metric = np.empty_like(self.references, dtype=np.bool_) self.relative_fraction = 0.000001 - self.absolute_eps = 1.0e-13 + if self.references.dtype is (np.float32, np.int32): + self.absolute_eps = max(eps, self._f32_absolute_eps) + else: + self.absolute_eps = max(eps, self._f64_absolute_eps) self.ulp_threshold = 1.0 self.success = self._compute_all_metrics() @@ -189,11 +194,11 @@ def _compute_all_metrics( ) # Absolute distance self.absolute_distance = np.absolute(self.computed - self.references) - self.absolute_distance_metric = self.absolute_distance < 1.0e-13 + self.absolute_distance_metric = self.absolute_distance < self.absolute_eps # Relative distance (in pct) self.relative_distance = np.divide(self.absolute_distance, max_values) self.relative_distance_metric = ( - self.absolute_distance < 0.000001 * max_values + self.absolute_distance < self.relative_fraction * max_values ) # ULP distance self.ulp_distance = np.divide( @@ -202,10 +207,15 @@ def _compute_all_metrics( self.ulp_distance_metric = self.ulp_distance <= self.ulp_threshold # Combine all distances into sucess or failure - success = np.logical_and(np.isnan(self.computed), np.isnan(self.references)) - success = np.logical_or(success, self.absolute_distance_metric) - success = np.logical_or(success, self.relative_distance_metric) - success = np.logical_or(success, self.ulp_distance_metric) + # Success = no NANs & ( abs or rel or ulp ) + naninf_success = not np.logical_and( + np.isnan(self.computed), np.isnan(self.references) + ).all() + metric_success = np.logical_or( + self.relative_distance_metric, self.absolute_distance_metric + ) + metric_success = np.logical_or(metric_success, self.ulp_distance_metric) + success = np.logical_and(naninf_success, metric_success) return success elif self.references.dtype in (np.bool_, bool): success = np.logical_xor(self.computed, self.references) From ba28f33c97559fed6056a2ac03bacd253e0cfc82 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Tue, 27 Aug 2024 14:24:54 -0400 Subject: [PATCH 125/154] Moved test_eta.py from pace/tests/main/grid into NDSL/tests/grid, added eta_file generator script for testing --- ndsl/grid/eta.py | 2 +- tests/grid/generate_eta_files.py | 399 +++++++++++++++++++++++++++++++ tests/grid/test_eta.py | 216 +++++++++++++++++ 3 files changed, 616 insertions(+), 1 deletion(-) create mode 100755 tests/grid/generate_eta_files.py create mode 100755 tests/grid/test_eta.py diff --git a/ndsl/grid/eta.py b/ndsl/grid/eta.py index 1015312d..b14da5a2 100644 --- a/ndsl/grid/eta.py +++ b/ndsl/grid/eta.py @@ -31,7 +31,7 @@ class HybridPressureCoefficients: def _load_ak_bk_from_file(eta_file: str) -> Tuple[np.ndarray, np.ndarray]: if not os.path.isfile(eta_file): - raise ValueError("eta file does not exist") + raise ValueError("eta file " + eta_file + " does not exist") # read file into ak, bk arrays data = xr.open_dataset(eta_file) diff --git a/tests/grid/generate_eta_files.py b/tests/grid/generate_eta_files.py new file mode 100755 index 00000000..1fb4d5ee --- /dev/null +++ b/tests/grid/generate_eta_files.py @@ -0,0 +1,399 @@ +import numpy as np +import xarray as xr + + +""" +This notebook uses the python xarray module +to create an eta_file containing ak and bk coefficients +for km=79 and km=91. The coefficients are written out to +eta79.nc and eta91.nc netcdf files respectively + +To run this script: `python3 ./generate_eta_files.py` +""" + +# km = 79 +ak = xr.DataArray( + dims=["km1"], + attrs=dict(units="Pa", _FillValue=False), + data=np.array( + [ + 3.000000e02, + 6.467159e02, + 1.045222e03, + 1.469188e03, + 1.897829e03, + 2.325385e03, + 2.754396e03, + 3.191294e03, + 3.648332e03, + 4.135675e03, + 4.668282e03, + 5.247940e03, + 5.876271e03, + 6.554716e03, + 7.284521e03, + 8.066738e03, + 8.902188e03, + 9.791482e03, + 1.073499e04, + 1.162625e04, + 1.237212e04, + 1.299041e04, + 1.349629e04, + 1.390277e04, + 1.422098e04, + 1.446058e04, + 1.462993e04, + 1.473633e04, + 1.478617e04, + 1.478511e04, + 1.473812e04, + 1.464966e04, + 1.452370e04, + 1.436382e04, + 1.417324e04, + 1.395491e04, + 1.371148e04, + 1.344540e04, + 1.315890e04, + 1.285407e04, + 1.253280e04, + 1.219685e04, + 1.184788e04, + 1.148739e04, + 1.111682e04, + 1.073748e04, + 1.035062e04, + 9.957395e03, + 9.558875e03, + 9.156069e03, + 8.749922e03, + 8.341315e03, + 7.931065e03, + 7.519942e03, + 7.108648e03, + 6.698281e03, + 6.290007e03, + 5.884984e03, + 5.484372e03, + 5.089319e03, + 4.700960e03, + 4.320421e03, + 3.948807e03, + 3.587201e03, + 3.236666e03, + 2.898237e03, + 2.572912e03, + 2.261667e03, + 1.965424e03, + 1.685079e03, + 1.421479e03, + 1.175419e03, + 9.476516e02, + 7.388688e02, + 5.497130e02, + 3.807626e02, + 2.325417e02, + 1.054810e02, + -8.381903e-04, + 0.000000e00, + ] + ), +) +bk = xr.DataArray( + dims=["km1"], + attrs=dict(units="None", _FillValue=False), + data=np.array( + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.00106595, + 0.00412866, + 0.00900663, + 0.01554263, + 0.02359921, + 0.03305481, + 0.0438012, + 0.05574095, + 0.06878554, + 0.08285347, + 0.09786981, + 0.1137643, + 0.130471, + 0.1479275, + 0.1660746, + 0.1848558, + 0.2042166, + 0.2241053, + 0.2444716, + 0.2652672, + 0.286445, + 0.3079604, + 0.3297701, + 0.351832, + 0.3741062, + 0.3965532, + 0.4191364, + 0.4418194, + 0.4645682, + 0.48735, + 0.5101338, + 0.5328897, + 0.5555894, + 0.5782067, + 0.6007158, + 0.6230936, + 0.6452944, + 0.6672683, + 0.6889648, + 0.7103333, + 0.7313231, + 0.7518838, + 0.7719651, + 0.7915173, + 0.8104913, + 0.828839, + 0.846513, + 0.8634676, + 0.8796583, + 0.8950421, + 0.9095779, + 0.9232264, + 0.9359506, + 0.9477157, + 0.9584892, + 0.9682413, + 0.9769447, + 0.9845753, + 0.9911126, + 0.9965372, + 1.0, + ] + ), +) +coefficients = xr.Dataset(data_vars={"ak": ak, "bk": bk}) +coefficients.to_netcdf("eta79.nc") + + +# km = 91 +ak = xr.DataArray( + dims=["km1"], + attrs=dict(units="Pa", _FillValue=False), + data=np.array( + [ + 1.00000000e00, + 1.75000000e00, + 2.75000000e00, + 4.09999990e00, + 5.98951054e00, + 8.62932968e00, + 1.22572632e01, + 1.71510906e01, + 2.36545467e01, + 3.21627693e01, + 4.31310921e01, + 5.71100426e01, + 7.46595764e01, + 9.64470978e01, + 1.23169769e02, + 1.55601318e02, + 1.94594009e02, + 2.41047531e02, + 2.95873840e02, + 3.60046967e02, + 4.34604828e02, + 5.20628723e02, + 6.19154846e02, + 7.31296021e02, + 8.58240906e02, + 1.00106561e03, + 1.16092859e03, + 1.33903992e03, + 1.53650012e03, + 1.75448938e03, + 1.99417834e03, + 2.25667407e03, + 2.54317139e03, + 2.85476392e03, + 3.19258569e03, + 3.55775366e03, + 3.95135107e03, + 4.37428662e03, + 4.82711084e03, + 5.31022168e03, + 5.82387793e03, + 6.36904248e03, + 6.94875244e03, + 7.56691992e03, + 8.22634277e03, + 8.93120996e03, + 9.68446191e03, + 1.04822725e04, + 1.13182793e04, + 1.21840771e04, + 1.30655674e04, + 1.39532207e04, + 1.48307285e04, + 1.56872617e04, + 1.65080645e04, + 1.72810996e04, + 1.79942988e04, + 1.86363223e04, + 1.91961797e04, + 1.96640723e04, + 2.00301914e04, + 2.02853691e04, + 2.04215254e04, + 2.04300684e04, + 2.03028730e04, + 2.00323711e04, + 1.96110664e04, + 1.90313848e04, + 1.82866426e04, + 1.73777930e04, + 1.63224639e04, + 1.51444033e04, + 1.38725674e04, + 1.25404785e04, + 1.11834170e04, + 9.83532715e03, + 8.52630664e03, + 7.28224512e03, + 6.12326074e03, + 5.06350684e03, + 4.11124902e03, + 3.27000122e03, + 2.53922729e03, + 1.91530762e03, + 1.39244995e03, + 9.63134766e02, + 6.20599365e02, + 3.57989502e02, + 1.69421387e02, + 5.10314941e01, + 2.48413086e00, + 0.00000000e00, + ] + ), +) +bk = xr.DataArray( + dims=["km1"], + attrs=dict(units="None", _FillValue=False), + data=np.array( + [ + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 0.00000000e00, + 3.50123992e-06, + 2.81484008e-05, + 9.38666999e-05, + 2.28561999e-04, + 5.12343016e-04, + 1.04712998e-03, + 1.95625005e-03, + 3.42317997e-03, + 5.58632007e-03, + 8.65428988e-03, + 1.27844000e-02, + 1.81719996e-02, + 2.49934997e-02, + 3.34198996e-02, + 4.36249003e-02, + 5.57769015e-02, + 7.00351968e-02, + 8.65636021e-02, + 1.05520003e-01, + 1.27051994e-01, + 1.51319996e-01, + 1.78477004e-01, + 2.08675995e-01, + 2.42069006e-01, + 2.78813988e-01, + 3.19043010e-01, + 3.62558991e-01, + 4.08596009e-01, + 4.56384987e-01, + 5.05111992e-01, + 5.53902984e-01, + 6.01903021e-01, + 6.48333013e-01, + 6.92534983e-01, + 7.33981013e-01, + 7.72292018e-01, + 8.07236016e-01, + 8.38724971e-01, + 8.66774976e-01, + 8.91497016e-01, + 9.13065016e-01, + 9.31702971e-01, + 9.47658002e-01, + 9.61175978e-01, + 9.72495019e-01, + 9.81844008e-01, + 9.89410996e-01, + 9.95342016e-01, + 1.00000000e00, + ] + ), +) +coefficients = xr.Dataset(data_vars={"ak": ak, "bk": bk}) +coefficients.to_netcdf("eta91.nc") + +# km = diff --git a/tests/grid/test_eta.py b/tests/grid/test_eta.py new file mode 100755 index 00000000..44c92dee --- /dev/null +++ b/tests/grid/test_eta.py @@ -0,0 +1,216 @@ +#!/usr/bin/env python3 + +import os + +import numpy as np +import pytest +import xarray as xr + +from ndsl import ( + NullComm, + CubedSphereCommunicator, + CubedSpherePartitioner, + QuantityFactory, + TilePartitioner, + SubtileGridSizer, +) +from ndsl.grid import MetricTerms + + +""" +This test checks to ensure that ak and bk +values are read-in and stored properly. +In addition, this test checks to ensure that +the function set_hybrid_pressure_coefficients +fail as expected if the computed eta values +vary non-mononitically and if the eta_file +is not provided. +""" + + +def set_answers(eta_file): + + """ + Read in the expected values of ak and bk + arrays from the input eta NetCDF files. + """ + + data = xr.open_dataset(eta_file) + return data["ak"].values, data["bk"].values + + +def write_non_mono_eta_file(in_eta_file, out_eta_file): + """ + Reads in file eta79.nc and alters randomly chosen ak/bk values + This tests the expected failure of set_eta_hybrid_coefficients + for coefficients that lead to non-monotonically increasing + eta values + """ + + data = xr.open_dataset(in_eta_file) + data["ak"].values[10] = data["ak"].values[0] + data["bk"].values[20] = 0.0 + + data.to_netcdf(out_eta_file) + + +@pytest.mark.parametrize("km", [79, 91]) +def test_set_hybrid_pressure_coefficients_correct(km): + + """This test checks to see that the ak and bk arrays + are read-in correctly and are stored as + expected. Both values of km=79 and km=91 are + tested and both tests are expected to pass + with the stored ak and bk values agreeing with the + values read-in directly from the NetCDF file. + """ + + dirname = os.path.dirname(os.path.abspath(__file__)) + eta_file = os.path.join(dirname, f"eta{km}.nc") + + backend = "numpy" + + layout = (1,1) + + nz = km + ny = 48 + nx = 48 + nhalo = 3 + + partitioner = CubedSpherePartitioner(TilePartitioner(layout)) + + communicator = CubedSphereCommunicator(NullComm(rank=0,total_ranks=6), partitioner) + + sizer = SubtileGridSizer.from_tile_params( + nx_tile=nx, + ny_tile=ny, + nz=nz, + n_halo=nhalo, + extra_dim_lengths={}, + layout=layout, + tile_partitioner=partitioner.tile, + tile_rank=communicator.tile.rank, + ) + + quantity_factory = QuantityFactory.from_backend(sizer=sizer, backend=backend) + + metric_terms = MetricTerms(quantity_factory=quantity_factory, communicator=communicator, eta_file=eta_file) + + ak_results = metric_terms.ak.data + bk_results = metric_terms.bk.data + ak_answers, bk_answers = set_answers(f"eta{km}.nc") + + if ak_answers.size != ak_results.size: + raise ValueError("Unexpected size of bk") + if bk_answers.size != bk_results.size: + raise ValueError("Unexpected size of ak") + + if not np.array_equal(ak_answers, ak_results): + raise ValueError("Unexpected value of ak") + if not np.array_equal(bk_answers, bk_results): + raise ValueError("Unexpected value of bk") + + + +def test_set_hybrid_pressure_coefficients_nofile(): + + """This test checks to see that the program + fails when (1) the eta_file is not specified in the yaml + configuration file; and (2), the computed eta values + increase non-monotonically. For the latter test, the eta_file + is specified in test_config_not_mono.yaml file and + the ak and bk values in the eta_file have been changed nonsensically + to result in erronenous eta values. + """ + + eta_file = "NULL" + + backend = "numpy" + + layout = (1,1) + + nz = 79 + ny = 48 + nx = 48 + nhalo = 3 + + partitioner = CubedSpherePartitioner(TilePartitioner(layout)) + + communicator = CubedSphereCommunicator(NullComm(rank=0,total_ranks=6), partitioner) + + sizer = SubtileGridSizer.from_tile_params( + nx_tile=nx, + ny_tile=ny, + nz=nz, + n_halo=nhalo, + extra_dim_lengths={}, + layout=layout, + tile_partitioner=partitioner.tile, + tile_rank=communicator.tile.rank, + ) + + quantity_factory = QuantityFactory.from_backend(sizer=sizer, backend=backend) + + try: + metric_terms = MetricTerms(quantity_factory=quantity_factory, communicator=communicator, eta_file=eta_file) + except Exception as error: + if str(error) == "eta file NULL does not exist": + pytest.xfail("testing eta file not specified") + else: + pytest.fail(f"ERROR {error}") + + +def test_set_hybrid_pressure_coefficients_not_mono(): + + """This test checks to see that the program + fails when (1) the eta_file is not specified in the yaml + configuration file; and (2), the computed eta values + increase non-monotonically. For the latter test, the eta_file + is specified in test_config_not_mono.yaml file and + the ak and bk values in the eta_file have been changed nonsensically + to result in erronenous eta values. + """ + + dirname = os.path.dirname(os.path.abspath(__file__)) + in_eta_file = os.path.join(dirname, "eta79.nc") + out_eta_file = "eta_not_mono_79.nc" + write_non_mono_eta_file(in_eta_file, out_eta_file) + eta_file = out_eta_file + + backend = "numpy" + + layout = (1,1) + + nz = 79 + ny = 48 + nx = 48 + nhalo = 3 + + partitioner = CubedSpherePartitioner(TilePartitioner(layout)) + + communicator = CubedSphereCommunicator(NullComm(rank=0,total_ranks=6), partitioner) + + sizer = SubtileGridSizer.from_tile_params( + nx_tile=nx, + ny_tile=ny, + nz=nz, + n_halo=nhalo, + extra_dim_lengths={}, + layout=layout, + tile_partitioner=partitioner.tile, + tile_rank=communicator.tile.rank, + ) + + quantity_factory = QuantityFactory.from_backend(sizer=sizer, backend=backend) + + try: + metric_terms = MetricTerms(quantity_factory=quantity_factory, communicator=communicator, eta_file=eta_file) + except Exception as error: + if os.path.isfile(out_eta_file): + os.remove(out_eta_file) + if str(error) == "ETA values are not monotonically increasing": + pytest.xfail("testing eta values are not monotomincally increasing") + else: + pytest.fail( + "ERROR in testing etav values not are not monotonically increasing" + ) From 9cafe2e93cdcd5ee0e58557b4d6ee736e2cf3502 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Tue, 27 Aug 2024 14:33:36 -0400 Subject: [PATCH 126/154] Amending unit_tests.yaml to reflect addition of tests/grid/test_eta.py --- .github/workflows/unit_tests.yaml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index d3b127dc..e780c190 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -22,6 +22,10 @@ jobs: - name: Install Python packages run: pip3 install .[test] + - name: prepare input eta files + run: | + python tests/grid/generate_eta_files.py + - name: Run serial-cpu tests run: coverage run --rcfile=setup.cfg -m pytest -x tests From 9cb8f1407d5ebfe1c39d2913c12599ceec184eae Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Tue, 27 Aug 2024 14:53:59 -0400 Subject: [PATCH 127/154] Amending file path for test_eta.py --- .github/workflows/unit_tests.yaml | 1 + tests/grid/test_eta.py | 10 +++++----- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index e780c190..c4cbb425 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -24,6 +24,7 @@ jobs: - name: prepare input eta files run: | + cd ${GITHUB_WORKSPACE}/ndsl python tests/grid/generate_eta_files.py - name: Run serial-cpu tests diff --git a/tests/grid/test_eta.py b/tests/grid/test_eta.py index 44c92dee..2835ab99 100755 --- a/tests/grid/test_eta.py +++ b/tests/grid/test_eta.py @@ -65,8 +65,8 @@ def test_set_hybrid_pressure_coefficients_correct(km): values read-in directly from the NetCDF file. """ - dirname = os.path.dirname(os.path.abspath(__file__)) - eta_file = os.path.join(dirname, f"eta{km}.nc") + working_dir = str(os.getcwd()) + eta_file = f"{working_dir}/eta{km}.nc" backend = "numpy" @@ -155,7 +155,7 @@ def test_set_hybrid_pressure_coefficients_nofile(): metric_terms = MetricTerms(quantity_factory=quantity_factory, communicator=communicator, eta_file=eta_file) except Exception as error: if str(error) == "eta file NULL does not exist": - pytest.xfail("testing eta file not specified") + pytest.xfail("testing eta file not correctly specified") else: pytest.fail(f"ERROR {error}") @@ -171,8 +171,8 @@ def test_set_hybrid_pressure_coefficients_not_mono(): to result in erronenous eta values. """ - dirname = os.path.dirname(os.path.abspath(__file__)) - in_eta_file = os.path.join(dirname, "eta79.nc") + working_dir = str(os.getcwd()) + in_eta_file = f"{working_dir}/eta79.nc" out_eta_file = "eta_not_mono_79.nc" write_non_mono_eta_file(in_eta_file, out_eta_file) eta_file = out_eta_file From a0c4992aab98dea6719d7deb060767bc4ef978df Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Tue, 27 Aug 2024 14:57:53 -0400 Subject: [PATCH 128/154] Another attempt to get the workflow to generate the test eta_files --- .github/workflows/unit_tests.yaml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/unit_tests.yaml b/.github/workflows/unit_tests.yaml index c4cbb425..e780c190 100644 --- a/.github/workflows/unit_tests.yaml +++ b/.github/workflows/unit_tests.yaml @@ -24,7 +24,6 @@ jobs: - name: prepare input eta files run: | - cd ${GITHUB_WORKSPACE}/ndsl python tests/grid/generate_eta_files.py - name: Run serial-cpu tests From 10942b2381403a6c54def53e76e7bac1c06e8eef Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Tue, 27 Aug 2024 14:59:14 -0400 Subject: [PATCH 129/154] Linting --- tests/grid/test_eta.py | 33 +++++++++++++++++++++------------ 1 file changed, 21 insertions(+), 12 deletions(-) diff --git a/tests/grid/test_eta.py b/tests/grid/test_eta.py index 2835ab99..1e0cd099 100755 --- a/tests/grid/test_eta.py +++ b/tests/grid/test_eta.py @@ -7,12 +7,12 @@ import xarray as xr from ndsl import ( - NullComm, CubedSphereCommunicator, CubedSpherePartitioner, + NullComm, QuantityFactory, - TilePartitioner, SubtileGridSizer, + TilePartitioner, ) from ndsl.grid import MetricTerms @@ -70,7 +70,7 @@ def test_set_hybrid_pressure_coefficients_correct(km): backend = "numpy" - layout = (1,1) + layout = (1, 1) nz = km ny = 48 @@ -79,7 +79,7 @@ def test_set_hybrid_pressure_coefficients_correct(km): partitioner = CubedSpherePartitioner(TilePartitioner(layout)) - communicator = CubedSphereCommunicator(NullComm(rank=0,total_ranks=6), partitioner) + communicator = CubedSphereCommunicator(NullComm(rank=0, total_ranks=6), partitioner) sizer = SubtileGridSizer.from_tile_params( nx_tile=nx, @@ -94,7 +94,9 @@ def test_set_hybrid_pressure_coefficients_correct(km): quantity_factory = QuantityFactory.from_backend(sizer=sizer, backend=backend) - metric_terms = MetricTerms(quantity_factory=quantity_factory, communicator=communicator, eta_file=eta_file) + metric_terms = MetricTerms( + quantity_factory=quantity_factory, communicator=communicator, eta_file=eta_file + ) ak_results = metric_terms.ak.data bk_results = metric_terms.bk.data @@ -111,7 +113,6 @@ def test_set_hybrid_pressure_coefficients_correct(km): raise ValueError("Unexpected value of bk") - def test_set_hybrid_pressure_coefficients_nofile(): """This test checks to see that the program @@ -127,7 +128,7 @@ def test_set_hybrid_pressure_coefficients_nofile(): backend = "numpy" - layout = (1,1) + layout = (1, 1) nz = 79 ny = 48 @@ -136,7 +137,7 @@ def test_set_hybrid_pressure_coefficients_nofile(): partitioner = CubedSpherePartitioner(TilePartitioner(layout)) - communicator = CubedSphereCommunicator(NullComm(rank=0,total_ranks=6), partitioner) + communicator = CubedSphereCommunicator(NullComm(rank=0, total_ranks=6), partitioner) sizer = SubtileGridSizer.from_tile_params( nx_tile=nx, @@ -152,7 +153,11 @@ def test_set_hybrid_pressure_coefficients_nofile(): quantity_factory = QuantityFactory.from_backend(sizer=sizer, backend=backend) try: - metric_terms = MetricTerms(quantity_factory=quantity_factory, communicator=communicator, eta_file=eta_file) + metric_terms = MetricTerms( + quantity_factory=quantity_factory, + communicator=communicator, + eta_file=eta_file, + ) except Exception as error: if str(error) == "eta file NULL does not exist": pytest.xfail("testing eta file not correctly specified") @@ -179,7 +184,7 @@ def test_set_hybrid_pressure_coefficients_not_mono(): backend = "numpy" - layout = (1,1) + layout = (1, 1) nz = 79 ny = 48 @@ -188,7 +193,7 @@ def test_set_hybrid_pressure_coefficients_not_mono(): partitioner = CubedSpherePartitioner(TilePartitioner(layout)) - communicator = CubedSphereCommunicator(NullComm(rank=0,total_ranks=6), partitioner) + communicator = CubedSphereCommunicator(NullComm(rank=0, total_ranks=6), partitioner) sizer = SubtileGridSizer.from_tile_params( nx_tile=nx, @@ -204,7 +209,11 @@ def test_set_hybrid_pressure_coefficients_not_mono(): quantity_factory = QuantityFactory.from_backend(sizer=sizer, backend=backend) try: - metric_terms = MetricTerms(quantity_factory=quantity_factory, communicator=communicator, eta_file=eta_file) + metric_terms = MetricTerms( + quantity_factory=quantity_factory, + communicator=communicator, + eta_file=eta_file, + ) except Exception as error: if os.path.isfile(out_eta_file): os.remove(out_eta_file) From 775e932ea2f3bb5c9462fd80a2e1767e3586d208 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Wed, 28 Aug 2024 10:40:08 -0400 Subject: [PATCH 130/154] Fix compare_to_numpy use of metric Lint --- ndsl/dsl/stencil.py | 42 +++++-------------------- ndsl/stencils/testing/test_translate.py | 8 ++--- ndsl/testing/comparison.py | 6 ++-- 3 files changed, 16 insertions(+), 40 deletions(-) diff --git a/ndsl/dsl/stencil.py b/ndsl/dsl/stencil.py index 75ef28ea..6a70b4d8 100644 --- a/ndsl/dsl/stencil.py +++ b/ndsl/dsl/stencil.py @@ -32,7 +32,7 @@ from ndsl.dsl.typing import Float, Index3D, cast_to_index3d from ndsl.initialization.sizer import GridSizer, SubtileGridSizer from ndsl.quantity import Quantity -from ndsl.testing import comparison +from ndsl.testing.comparison import LegacyMetric try: @@ -68,40 +68,14 @@ def report_difference(args, kwargs, args_copy, kwargs_copy, function_name, gt_id def report_diff(arg: np.ndarray, numpy_arg: np.ndarray, label) -> str: - metric_err = comparison.compare_arr(arg, numpy_arg) - nans_match = np.logical_and(np.isnan(arg), np.isnan(numpy_arg)) - n_points = np.product(arg.shape) - failures_14 = n_points - np.sum( - np.logical_or( - nans_match, - metric_err < 1e-14, - ) - ) - failures_10 = n_points - np.sum( - np.logical_or( - nans_match, - metric_err < 1e-10, - ) + metric = LegacyMetric( + reference_values=arg, + computed_values=numpy_arg, + eps=1e-13, + ignore_near_zero_errors=False, + near_zero=0, ) - failures_8 = n_points - np.sum( - np.logical_or( - nans_match, - metric_err < 1e-8, - ) - ) - greatest_error = np.max(metric_err[~np.isnan(metric_err)]) - if greatest_error == 0.0 and failures_14 == 0: - report = "" - else: - report = f"\n {label}: " - report += f"max_err={greatest_error}" - if failures_14 > 0: - report += f" 1e-14 failures: {failures_14}" - if failures_10 > 0: - report += f" 1e-10 failures: {failures_10}" - if failures_8 > 0: - report += f" 1e-8 failures: {failures_8}" - return report + return metric.__repr__() @dataclasses.dataclass diff --git a/ndsl/stencils/testing/test_translate.py b/ndsl/stencils/testing/test_translate.py index 10c3b90c..ffafdc6f 100644 --- a/ndsl/stencils/testing/test_translate.py +++ b/ndsl/stencils/testing/test_translate.py @@ -15,7 +15,7 @@ from ndsl.quantity import Quantity from ndsl.restart._legacy_restart import RESTART_PROPERTIES from ndsl.stencils.testing.savepoint import SavepointCase, dataset_to_dict -from ndsl.testing.comparison import MultiModalFloatMetric, LegacyMetric +from ndsl.testing.comparison import LegacyMetric, MultiModalFloatMetric from ndsl.testing.perturbation import perturb @@ -67,9 +67,9 @@ def process_override(threshold_overrides, testobj, test_name, backend): for key in testobj.out_vars.keys(): if key not in testobj.ignore_near_zero_errors: testobj.ignore_near_zero_errors[key] = {} - testobj.ignore_near_zero_errors[key]["near_zero"] = ( - float(match["all_other_near_zero"]) - ) + testobj.ignore_near_zero_errors[key][ + "near_zero" + ] = float(match["all_other_near_zero"]) else: raise TypeError( diff --git a/ndsl/testing/comparison.py b/ndsl/testing/comparison.py index 31fda0e2..f1230ef0 100644 --- a/ndsl/testing/comparison.py +++ b/ndsl/testing/comparison.py @@ -14,9 +14,11 @@ def __init__( self.computed = np.atleast_1d(computed_values) self.check = False - def __str__(self) -> str: ... + def __str__(self) -> str: + ... - def __repr__(self) -> str: ... + def __repr__(self) -> str: + ... class LegacyMetric(BaseMetric): From 25fe597c033bb5844cfac33ee5f2f28bf7b3f8db Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Wed, 28 Aug 2024 10:46:56 -0400 Subject: [PATCH 131/154] Fix success message --- ndsl/testing/comparison.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/ndsl/testing/comparison.py b/ndsl/testing/comparison.py index f1230ef0..311a8a7a 100644 --- a/ndsl/testing/comparison.py +++ b/ndsl/testing/comparison.py @@ -91,8 +91,11 @@ def __str__(self) -> str: return self.__repr__() def __repr__(self) -> str: + if self.check: + return "✅ No numerical differences" + report = [] - report.append("✅ Success" if self.check else "❌ Numerical failures") + report.append("❌ Numerical failures") found_indices = np.logical_not(self.success).nonzero() computed_failures = self.computed[found_indices] @@ -231,8 +234,11 @@ def __str__(self) -> str: return self.__repr__() def __repr__(self) -> str: + if self.check: + return "✅ No numerical differences" + report = [] - report.append("✅ Success" if self.check else "❌ Numerical failures") + report.append("❌ Numerical failures") found_indices = np.logical_not(self.success).nonzero() # List all errors From 0edcf73831567da242aac491821a96d61089e76f Mon Sep 17 00:00:00 2001 From: Oliver Elbert Date: Wed, 28 Aug 2024 16:50:00 -0400 Subject: [PATCH 132/154] adding block merging to netcdf conversion --- external/dace | 2 +- external/gt4py | 2 +- ndsl/stencils/testing/serialbox_to_netcdf.py | 57 +++++++++++++++++--- 3 files changed, 53 insertions(+), 8 deletions(-) diff --git a/external/dace b/external/dace index ee5a6dfe..22982afe 160000 --- a/external/dace +++ b/external/dace @@ -1 +1 @@ -Subproject commit ee5a6dfe695f329c3882105b087f3563a0c80b81 +Subproject commit 22982afe133bccd906d5eeee448092f5f065ff6a diff --git a/external/gt4py b/external/gt4py index 32dde792..d6dfd6ff 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit 32dde792bde505807a5729261e4f1d12a1451bdb +Subproject commit d6dfd6ff46cc1d50b0fb6d05fb0b6271e4a1f5cc diff --git a/ndsl/stencils/testing/serialbox_to_netcdf.py b/ndsl/stencils/testing/serialbox_to_netcdf.py index 11814fff..c34b8fc3 100644 --- a/ndsl/stencils/testing/serialbox_to_netcdf.py +++ b/ndsl/stencils/testing/serialbox_to_netcdf.py @@ -32,6 +32,12 @@ def get_parser(): type=str, help="[Optional] Give the name of the data, will default to Generator_rankX", ) + parser.add_argument( + "-m", "--merge", + action='store_true', + default=False, + help="merges datastreams blocked into separate savepoints" + ) return parser @@ -58,7 +64,7 @@ def get_serializer(data_path: str, rank: int, data_name: Optional[str] = None): return serialbox.Serializer(serialbox.OpenModeKind.Read, data_path, name) -def main(data_path: str, output_path: str, data_name: Optional[str] = None): +def main(data_path: str, output_path: str, merge_blocks: bool, data_name: Optional[str] = None): os.makedirs(output_path, exist_ok=True) namelist_filename_in = os.path.join(data_path, "input.nml") @@ -69,9 +75,20 @@ def main(data_path: str, output_path: str, data_name: Optional[str] = None): if namelist_filename_out != namelist_filename_in: shutil.copyfile(os.path.join(data_path, "input.nml"), namelist_filename_out) namelist = f90nml.read(namelist_filename_out) - total_ranks = ( - 6 * namelist["fv_core_nml"]["layout"][0] * namelist["fv_core_nml"]["layout"][1] - ) + if namelist["fv_core_nml"]["grid_type"] <= 3: + total_ranks = ( + 6 * namelist["fv_core_nml"]["layout"][0] * namelist["fv_core_nml"]["layout"][1] + ) + else: + total_ranks = ( + namelist["fv_core_nml"]["layout"][0] * namelist["fv_core_nml"]["layout"][1] + ) + nx = int((namelist["fv_core_nml"]['npx'] - 1) / ( + namelist["fv_core_nml"]['layout'][0] + )) + ny = int((namelist["fv_core_nml"]['npy'] - 1) / ( + namelist["fv_core_nml"]['layout'][1] + )) # all ranks have the same names, just look at first one serializer_0 = get_serializer(data_path, rank=0, data_name=data_name) @@ -96,8 +113,33 @@ def main(data_path: str, output_path: str, data_name: Optional[str] = None): rank_data[name].append( read_serialized_data(serializer, savepoint, name) ) + if merge_blocks and len(rank_data[name] > 1): + full_data = np.array(rank_data[name]) + if len(full_data.shape) > 1: + if (nx * ny == full_data.shape[0] * full_data.shape[1]): + # If we have an (i, x) array from each block reshape it + new_shape = (nx, ny) + full_data.shape[2:] + full_data = full_data.reshape(new_shape) + elif full_data.shape[1] == namelist["fv_core_nml"]['npz']: + # If it's a k-array from each block just take one + full_data = full_data[0] + else: + return IndexError( + "Shape mismatch in block merging: " + f"{full_data.shape[0]} by {full_data.shape[1]} " + f"is not compatible with {nx} by {ny}" + ) + elif len(full_data.shape) == 1: + # if it's a scalar from each block then just take one + full_data = full_data[0] + else: + raise IndexError(f"{name} data appears to be empty") + rank_data[name] = [full_data] rank_list.append(rank_data) - n_savepoints = len(savepoints) # checking from last rank is fine + if merge_blocks: + n_savepoints = 1 + else: + n_savepoints = len(savepoints) # checking from last rank is fine data_vars = {} if n_savepoints > 0: encoding = {} @@ -166,7 +208,10 @@ def entry_point(): parser = get_parser() args = parser.parse_args() main( - data_path=args.data_path, output_path=args.output_path, data_name=args.data_name + data_path=args.data_path, + output_path=args.output_path, + merge_blocks=args.merge, + data_name=args.data_name, ) From 712a385c08e35c3034cc48495c10504a25431c27 Mon Sep 17 00:00:00 2001 From: Frank Malatino <142349306+fmalatino@users.noreply.github.com> Date: Thu, 29 Aug 2024 15:49:02 -0400 Subject: [PATCH 133/154] Use of f-string in ValueError statement of _load_ak_bk_from_file Co-authored-by: Oliver Elbert --- ndsl/grid/eta.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ndsl/grid/eta.py b/ndsl/grid/eta.py index b14da5a2..35ac510d 100644 --- a/ndsl/grid/eta.py +++ b/ndsl/grid/eta.py @@ -31,7 +31,7 @@ class HybridPressureCoefficients: def _load_ak_bk_from_file(eta_file: str) -> Tuple[np.ndarray, np.ndarray]: if not os.path.isfile(eta_file): - raise ValueError("eta file " + eta_file + " does not exist") + raise ValueError(f"eta file {eta_file} does not exist") # read file into ak, bk arrays data = xr.open_dataset(eta_file) From 37872f07f9a42e60de6226f4cfea9e4534c7df85 Mon Sep 17 00:00:00 2001 From: Frank Malatino <142349306+fmalatino@users.noreply.github.com> Date: Thu, 29 Aug 2024 15:49:51 -0400 Subject: [PATCH 134/154] Amending pytest.fail statement in test_eta.py Co-authored-by: Oliver Elbert --- tests/grid/test_eta.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/grid/test_eta.py b/tests/grid/test_eta.py index 1e0cd099..a4808fdf 100755 --- a/tests/grid/test_eta.py +++ b/tests/grid/test_eta.py @@ -221,5 +221,5 @@ def test_set_hybrid_pressure_coefficients_not_mono(): pytest.xfail("testing eta values are not monotomincally increasing") else: pytest.fail( - "ERROR in testing etav values not are not monotonically increasing" + "ERROR in testing eta values not are not monotonically increasing" ) From 82df2292d6a844505d25f6a4a7d2185f6227f5fb Mon Sep 17 00:00:00 2001 From: Oliver Elbert Date: Thu, 29 Aug 2024 16:58:50 -0400 Subject: [PATCH 135/154] bigfix --- ndsl/stencils/testing/serialbox_to_netcdf.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/ndsl/stencils/testing/serialbox_to_netcdf.py b/ndsl/stencils/testing/serialbox_to_netcdf.py index c34b8fc3..f812fd43 100644 --- a/ndsl/stencils/testing/serialbox_to_netcdf.py +++ b/ndsl/stencils/testing/serialbox_to_netcdf.py @@ -113,6 +113,7 @@ def main(data_path: str, output_path: str, merge_blocks: bool, data_name: Option rank_data[name].append( read_serialized_data(serializer, savepoint, name) ) + nblocks = len(rank_data.name) if merge_blocks and len(rank_data[name] > 1): full_data = np.array(rank_data[name]) if len(full_data.shape) > 1: @@ -120,11 +121,12 @@ def main(data_path: str, output_path: str, merge_blocks: bool, data_name: Option # If we have an (i, x) array from each block reshape it new_shape = (nx, ny) + full_data.shape[2:] full_data = full_data.reshape(new_shape) - elif full_data.shape[1] == namelist["fv_core_nml"]['npz']: - # If it's a k-array from each block just take one + elif full_data.shape[0] == nblocks: + # We have one array for all blocks + # could be a k-array or something else, so we take one copy full_data = full_data[0] else: - return IndexError( + raise IndexError( "Shape mismatch in block merging: " f"{full_data.shape[0]} by {full_data.shape[1]} " f"is not compatible with {nx} by {ny}" From c76a4869c05d829d70a1ca2b81ed09c94d7b7487 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Fri, 30 Aug 2024 10:35:28 -0400 Subject: [PATCH 136/154] Amended generation.py to define hybrid pressure variables appropriately --- ndsl/grid/generation.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/ndsl/grid/generation.py b/ndsl/grid/generation.py index a42edfdf..1ba36e9c 100644 --- a/ndsl/grid/generation.py +++ b/ndsl/grid/generation.py @@ -305,22 +305,22 @@ def __init__( self._bk, ) = self._set_hybrid_pressure_coefficients(eta_file, ak, bk) else: - ks = self.quantity_factory.zeros( + self._ks = self.quantity_factory.zeros( [], "", dtype=Float, ) - ptop = self.quantity_factory.zeros( + self._ptop = self.quantity_factory.zeros( [], "Pa", dtype=Float, ) - ak = self.quantity_factory.zeros( + self._ak = self.quantity_factory.zeros( [Z_INTERFACE_DIM], "Pa", dtype=Float, ) - bk = self.quantity_factory.zeros( + self._bk = self.quantity_factory.zeros( [Z_INTERFACE_DIM], "", dtype=Float, From 50a1f93a013d132a312ee1e720bb19afd65c70ba Mon Sep 17 00:00:00 2001 From: oelbert Date: Fri, 30 Aug 2024 12:35:02 -0400 Subject: [PATCH 137/154] bug --- ndsl/stencils/testing/serialbox_to_netcdf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ndsl/stencils/testing/serialbox_to_netcdf.py b/ndsl/stencils/testing/serialbox_to_netcdf.py index f812fd43..07df7ca7 100644 --- a/ndsl/stencils/testing/serialbox_to_netcdf.py +++ b/ndsl/stencils/testing/serialbox_to_netcdf.py @@ -113,7 +113,7 @@ def main(data_path: str, output_path: str, merge_blocks: bool, data_name: Option rank_data[name].append( read_serialized_data(serializer, savepoint, name) ) - nblocks = len(rank_data.name) + nblocks = len(rank_data[name]) if merge_blocks and len(rank_data[name] > 1): full_data = np.array(rank_data[name]) if len(full_data.shape) > 1: From 50607ca96f938fef777ef81cfc56a16a009a50a3 Mon Sep 17 00:00:00 2001 From: oelbert Date: Fri, 30 Aug 2024 13:44:11 -0400 Subject: [PATCH 138/154] uninspiring revelation --- ndsl/stencils/testing/serialbox_to_netcdf.py | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/ndsl/stencils/testing/serialbox_to_netcdf.py b/ndsl/stencils/testing/serialbox_to_netcdf.py index 07df7ca7..a6c9db34 100644 --- a/ndsl/stencils/testing/serialbox_to_netcdf.py +++ b/ndsl/stencils/testing/serialbox_to_netcdf.py @@ -114,23 +114,24 @@ def main(data_path: str, output_path: str, merge_blocks: bool, data_name: Option read_serialized_data(serializer, savepoint, name) ) nblocks = len(rank_data[name]) - if merge_blocks and len(rank_data[name] > 1): + if merge_blocks and len(rank_data[name]) > 1: full_data = np.array(rank_data[name]) if len(full_data.shape) > 1: if (nx * ny == full_data.shape[0] * full_data.shape[1]): # If we have an (i, x) array from each block reshape it new_shape = (nx, ny) + full_data.shape[2:] full_data = full_data.reshape(new_shape) - elif full_data.shape[0] == nblocks: + else: # We have one array for all blocks # could be a k-array or something else, so we take one copy + # TODO: is there a decent check for this? full_data = full_data[0] - else: - raise IndexError( - "Shape mismatch in block merging: " - f"{full_data.shape[0]} by {full_data.shape[1]} " - f"is not compatible with {nx} by {ny}" - ) + #else: + # raise IndexError( + # "Shape mismatch in block merging: " + # f"{full_data.shape[0]} by {full_data.shape[1]} " + # f"is not compatible with {nx} by {ny}" + # ) elif len(full_data.shape) == 1: # if it's a scalar from each block then just take one full_data = full_data[0] From 24ddc5d65e762d410a3f6b914a7547399ae37db9 Mon Sep 17 00:00:00 2001 From: Oliver Elbert Date: Tue, 3 Sep 2024 10:25:48 -0400 Subject: [PATCH 139/154] lint --- ndsl/stencils/testing/serialbox_to_netcdf.py | 32 ++++++++++++-------- 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/ndsl/stencils/testing/serialbox_to_netcdf.py b/ndsl/stencils/testing/serialbox_to_netcdf.py index 07df7ca7..71010f8c 100644 --- a/ndsl/stencils/testing/serialbox_to_netcdf.py +++ b/ndsl/stencils/testing/serialbox_to_netcdf.py @@ -33,10 +33,11 @@ def get_parser(): help="[Optional] Give the name of the data, will default to Generator_rankX", ) parser.add_argument( - "-m", "--merge", - action='store_true', + "-m", + "--merge", + action="store_true", default=False, - help="merges datastreams blocked into separate savepoints" + help="merges datastreams blocked into separate savepoints", ) return parser @@ -64,7 +65,12 @@ def get_serializer(data_path: str, rank: int, data_name: Optional[str] = None): return serialbox.Serializer(serialbox.OpenModeKind.Read, data_path, name) -def main(data_path: str, output_path: str, merge_blocks: bool, data_name: Optional[str] = None): +def main( + data_path: str, + output_path: str, + merge_blocks: bool, + data_name: Optional[str] = None, +): os.makedirs(output_path, exist_ok=True) namelist_filename_in = os.path.join(data_path, "input.nml") @@ -77,18 +83,20 @@ def main(data_path: str, output_path: str, merge_blocks: bool, data_name: Option namelist = f90nml.read(namelist_filename_out) if namelist["fv_core_nml"]["grid_type"] <= 3: total_ranks = ( - 6 * namelist["fv_core_nml"]["layout"][0] * namelist["fv_core_nml"]["layout"][1] + 6 + * namelist["fv_core_nml"]["layout"][0] + * namelist["fv_core_nml"]["layout"][1] ) else: total_ranks = ( namelist["fv_core_nml"]["layout"][0] * namelist["fv_core_nml"]["layout"][1] ) - nx = int((namelist["fv_core_nml"]['npx'] - 1) / ( - namelist["fv_core_nml"]['layout'][0] - )) - ny = int((namelist["fv_core_nml"]['npy'] - 1) / ( - namelist["fv_core_nml"]['layout'][1] - )) + nx = int( + (namelist["fv_core_nml"]["npx"] - 1) / (namelist["fv_core_nml"]["layout"][0]) + ) + ny = int( + (namelist["fv_core_nml"]["npy"] - 1) / (namelist["fv_core_nml"]["layout"][1]) + ) # all ranks have the same names, just look at first one serializer_0 = get_serializer(data_path, rank=0, data_name=data_name) @@ -117,7 +125,7 @@ def main(data_path: str, output_path: str, merge_blocks: bool, data_name: Option if merge_blocks and len(rank_data[name] > 1): full_data = np.array(rank_data[name]) if len(full_data.shape) > 1: - if (nx * ny == full_data.shape[0] * full_data.shape[1]): + if nx * ny == full_data.shape[0] * full_data.shape[1]: # If we have an (i, x) array from each block reshape it new_shape = (nx, ny) + full_data.shape[2:] full_data = full_data.reshape(new_shape) From 6588154a61cb29c0ed5ecc2b2b211faf26f5f70c Mon Sep 17 00:00:00 2001 From: Oliver Elbert Date: Tue, 3 Sep 2024 10:38:02 -0400 Subject: [PATCH 140/154] removing dead code --- ndsl/stencils/testing/serialbox_to_netcdf.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/ndsl/stencils/testing/serialbox_to_netcdf.py b/ndsl/stencils/testing/serialbox_to_netcdf.py index 66954a3a..a29139c5 100644 --- a/ndsl/stencils/testing/serialbox_to_netcdf.py +++ b/ndsl/stencils/testing/serialbox_to_netcdf.py @@ -134,12 +134,6 @@ def main( # could be a k-array or something else, so we take one copy # TODO: is there a decent check for this? full_data = full_data[0] - #else: - # raise IndexError( - # "Shape mismatch in block merging: " - # f"{full_data.shape[0]} by {full_data.shape[1]} " - # f"is not compatible with {nx} by {ny}" - # ) elif len(full_data.shape) == 1: # if it's a scalar from each block then just take one full_data = full_data[0] From cb4ce981e9cd8ab0ae43360a988251ade6321e8c Mon Sep 17 00:00:00 2001 From: Oliver Elbert Date: Tue, 3 Sep 2024 10:40:44 -0400 Subject: [PATCH 141/154] revert externals --- external/dace | 2 +- external/gt4py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/external/dace b/external/dace index 22982afe..ee5a6dfe 160000 --- a/external/dace +++ b/external/dace @@ -1 +1 @@ -Subproject commit 22982afe133bccd906d5eeee448092f5f065ff6a +Subproject commit ee5a6dfe695f329c3882105b087f3563a0c80b81 diff --git a/external/gt4py b/external/gt4py index d6dfd6ff..32dde792 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit d6dfd6ff46cc1d50b0fb6d05fb0b6271e4a1f5cc +Subproject commit 32dde792bde505807a5729261e4f1d12a1451bdb From 5ff184c4eaa1723ba82d4197dd5c7e6cce5f0c0c Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Wed, 4 Sep 2024 08:29:07 -0400 Subject: [PATCH 142/154] Move all thresholds to class variable --- ndsl/stencils/testing/test_translate.py | 2 +- ndsl/testing/comparison.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ndsl/stencils/testing/test_translate.py b/ndsl/stencils/testing/test_translate.py index ffafdc6f..55ee1001 100644 --- a/ndsl/stencils/testing/test_translate.py +++ b/ndsl/stencils/testing/test_translate.py @@ -176,7 +176,7 @@ def test_sequential_savepoint( input_data = {name: input_data[name] for name in input_names} except KeyError as e: raise KeyError( - f"Variable {e} was described in the translate test but cannot be found in the netCDF" + f"Variable {e} was described in the translate test but cannot be found in the NetCDF" ) original_input_data = copy.deepcopy(input_data) # run python version of functionality diff --git a/ndsl/testing/comparison.py b/ndsl/testing/comparison.py index 311a8a7a..9812e064 100644 --- a/ndsl/testing/comparison.py +++ b/ndsl/testing/comparison.py @@ -164,6 +164,8 @@ class MultiModalFloatMetric(BaseMetric): _f32_absolute_eps = 1e-10 _f64_absolute_eps = 1e-13 + relative_fraction = 0.000001 # 0.0001% + ulp_threshold = 1.0 def __init__( self, @@ -180,12 +182,10 @@ def __init__( self.ulp_distance = np.empty_like(self.references) self.ulp_distance_metric = np.empty_like(self.references, dtype=np.bool_) - self.relative_fraction = 0.000001 if self.references.dtype is (np.float32, np.int32): self.absolute_eps = max(eps, self._f32_absolute_eps) else: self.absolute_eps = max(eps, self._f64_absolute_eps) - self.ulp_threshold = 1.0 self.success = self._compute_all_metrics() self.check = np.all(self.success) From 99f1e436666694f8087a28488f2a5ea2bb3897e8 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Wed, 4 Sep 2024 14:25:18 -0400 Subject: [PATCH 143/154] Non-ideal fix for unreachable scalar variables, specifically in stencils/corners.py::fill_corners_dgrid_defn --- ndsl/stencils/corners.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ndsl/stencils/corners.py b/ndsl/stencils/corners.py index d83cfac5..8e1b5a78 100644 --- a/ndsl/stencils/corners.py +++ b/ndsl/stencils/corners.py @@ -1003,6 +1003,7 @@ def fill_corners_dgrid_defn( with computation(PARALLEL), interval(...): # this line of code is used to fix the missing symbol crash due to the node visitor depth limitation acoef = mysign + x_out = x_in # sw corner with horizontal(region[i_start - 1, j_start - 1]): x_out = mysign * y_in[0, 1, 0] From 1082b622281f24d34e12a8ca875ad28b884b0dac Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Wed, 4 Sep 2024 21:23:42 -0400 Subject: [PATCH 144/154] Amended test_eta.py docstrings to reflect updated testing methods and eta_file variable in generation.py to use an empty string in conditional statement for hybrid pressure generation --- ndsl/grid/generation.py | 4 ++-- tests/grid/test_eta.py | 26 ++++++++++++-------------- 2 files changed, 14 insertions(+), 16 deletions(-) diff --git a/ndsl/grid/generation.py b/ndsl/grid/generation.py index 1ba36e9c..5c39c346 100644 --- a/ndsl/grid/generation.py +++ b/ndsl/grid/generation.py @@ -237,7 +237,7 @@ def __init__( dy_const: float = 1000.0, deglat: float = 15.0, extdgrid: bool = False, - eta_file: str = "None", + eta_file: str = "", ak: Optional[np.ndarray] = None, bk: Optional[np.ndarray] = None, ): @@ -297,7 +297,7 @@ def __init__( self._dy_center = None self._area = None self._area_c = None - if eta_file != "None": + if eta_file is not "": ( self._ks, self._ptop, diff --git a/tests/grid/test_eta.py b/tests/grid/test_eta.py index a4808fdf..713e30b6 100755 --- a/tests/grid/test_eta.py +++ b/tests/grid/test_eta.py @@ -115,13 +115,10 @@ def test_set_hybrid_pressure_coefficients_correct(km): def test_set_hybrid_pressure_coefficients_nofile(): - """This test checks to see that the program - fails when (1) the eta_file is not specified in the yaml - configuration file; and (2), the computed eta values - increase non-monotonically. For the latter test, the eta_file - is specified in test_config_not_mono.yaml file and - the ak and bk values in the eta_file have been changed nonsensically - to result in erronenous eta values. + """ + This test checks to see that the program + fails when the eta_file is not specified + in the yaml configuration file. """ eta_file = "NULL" @@ -167,13 +164,14 @@ def test_set_hybrid_pressure_coefficients_nofile(): def test_set_hybrid_pressure_coefficients_not_mono(): - """This test checks to see that the program - fails when (1) the eta_file is not specified in the yaml - configuration file; and (2), the computed eta values - increase non-monotonically. For the latter test, the eta_file - is specified in test_config_not_mono.yaml file and - the ak and bk values in the eta_file have been changed nonsensically - to result in erronenous eta values. + """ + This test checks to see that the program + fails when the computed eta values increase + non-monotonically. For the latter test, the + eta_file is specified in test_config_not_mono.yaml + file and the ak and bk values in the eta_file + have been changed nonsensically to result in + erronenous eta values. """ working_dir = str(os.getcwd()) From e3cca7cc2458617dea5dd300cafbfe4f321f1926 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 5 Sep 2024 14:13:44 -0400 Subject: [PATCH 145/154] Amended method fill_corners_dgrid_defn to use x_out = x_out instead of x_out = x_in --- ndsl/stencils/corners.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ndsl/stencils/corners.py b/ndsl/stencils/corners.py index 8e1b5a78..5eb7767a 100644 --- a/ndsl/stencils/corners.py +++ b/ndsl/stencils/corners.py @@ -1003,7 +1003,7 @@ def fill_corners_dgrid_defn( with computation(PARALLEL), interval(...): # this line of code is used to fix the missing symbol crash due to the node visitor depth limitation acoef = mysign - x_out = x_in + x_out = x_out # sw corner with horizontal(region[i_start - 1, j_start - 1]): x_out = mysign * y_in[0, 1, 0] From 57f18078e76bf0bffe2b1ed4985d2cbac8a4ea94 Mon Sep 17 00:00:00 2001 From: Oliver Elbert Date: Thu, 5 Sep 2024 16:59:28 -0400 Subject: [PATCH 146/154] fix compute 0 errors --- ndsl/testing/comparison.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/ndsl/testing/comparison.py b/ndsl/testing/comparison.py index 9812e064..78685ccb 100644 --- a/ndsl/testing/comparison.py +++ b/ndsl/testing/comparison.py @@ -52,9 +52,10 @@ def _compute_errors( near_zero, ) -> npt.NDArray[np.bool_]: if self.references.dtype in (np.float64, np.int64, np.float32, np.int32): - denom = np.abs(self.references) + np.abs(self.computed) + denom = self.references + denom[self.references == 0] = self.computed[self.references == 0] self._calculated_metric = np.asarray( - 2.0 * np.abs(self.computed - self.references) / denom + np.abs(self.computed - self.references / denom) ) self._calculated_metric[denom == 0] = 0.0 elif self.references.dtype in (np.bool_, bool): @@ -123,7 +124,7 @@ def __repr__(self) -> str: f"{reference_failures[b]} {abs_errs[-1]:.3e} {metric_err:.3e}" ) - if np.isnan(metric_err) or (metric_err > worst_metric_err): + if np.isnan(metric_err) or (abs(metric_err) > abs(worst_metric_err)): worst_metric_err = metric_err worst_full_idx = full_index worst_abs_err = abs_errs[-1] @@ -249,7 +250,7 @@ def __repr__(self) -> str: f"All failures ({bad_indices_count}/{full_count}) ({failures_pct}%),\n", f"Index Computed Reference " f"Absolute E(<{self.absolute_eps:.2e}) " - f"Relative E(<{self.relative_fraction*100:.2e}%) " + f"Relative E(<{self.relative_fraction * 100:.2e}%) " f"ULP E(<{self.ulp_threshold})", ] # Summary and worst result From 1bd19eaf2b8f1f57e92fd76e408c8ced72b6ef62 Mon Sep 17 00:00:00 2001 From: Oliver Elbert Date: Thu, 5 Sep 2024 17:08:35 -0400 Subject: [PATCH 147/154] oops --- ndsl/testing/comparison.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ndsl/testing/comparison.py b/ndsl/testing/comparison.py index 78685ccb..5ba7983a 100644 --- a/ndsl/testing/comparison.py +++ b/ndsl/testing/comparison.py @@ -55,7 +55,7 @@ def _compute_errors( denom = self.references denom[self.references == 0] = self.computed[self.references == 0] self._calculated_metric = np.asarray( - np.abs(self.computed - self.references / denom) + np.abs((self.computed - self.references) / denom) ) self._calculated_metric[denom == 0] = 0.0 elif self.references.dtype in (np.bool_, bool): From a427b1ab0cf24a686ae92a39fe578eea6f91a5d5 Mon Sep 17 00:00:00 2001 From: Oliver Elbert Date: Thu, 5 Sep 2024 17:17:09 -0400 Subject: [PATCH 148/154] found the culprit --- ndsl/testing/comparison.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ndsl/testing/comparison.py b/ndsl/testing/comparison.py index 5ba7983a..d3ac0d65 100644 --- a/ndsl/testing/comparison.py +++ b/ndsl/testing/comparison.py @@ -39,12 +39,12 @@ def __init__( ): super().__init__(reference_values, computed_values) self.eps = eps + self._calculated_metric = np.empty_like(self.references) self.success = self._compute_errors( ignore_near_zero_errors, near_zero, ) self.check = np.all(self.success) - self._calculated_metric = np.empty_like(self.references) def _compute_errors( self, From 36496917793743ad71f8219cdb8fce60b07d3194 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Fri, 6 Sep 2024 11:02:06 -0400 Subject: [PATCH 149/154] Linting --- ndsl/grid/generation.py | 2 +- tests/grid/test_eta.py | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/ndsl/grid/generation.py b/ndsl/grid/generation.py index 5c39c346..caf91031 100644 --- a/ndsl/grid/generation.py +++ b/ndsl/grid/generation.py @@ -297,7 +297,7 @@ def __init__( self._dy_center = None self._area = None self._area_c = None - if eta_file is not "": + if eta_file != "": ( self._ks, self._ptop, diff --git a/tests/grid/test_eta.py b/tests/grid/test_eta.py index 713e30b6..ab0539f8 100755 --- a/tests/grid/test_eta.py +++ b/tests/grid/test_eta.py @@ -117,7 +117,7 @@ def test_set_hybrid_pressure_coefficients_nofile(): """ This test checks to see that the program - fails when the eta_file is not specified + fails when the eta_file is not specified in the yaml configuration file. """ @@ -166,11 +166,11 @@ def test_set_hybrid_pressure_coefficients_not_mono(): """ This test checks to see that the program - fails when the computed eta values increase - non-monotonically. For the latter test, the - eta_file is specified in test_config_not_mono.yaml - file and the ak and bk values in the eta_file - have been changed nonsensically to result in + fails when the computed eta values increase + non-monotonically. For the latter test, the + eta_file is specified in test_config_not_mono.yaml + file and the ak and bk values in the eta_file + have been changed nonsensically to result in erronenous eta values. """ From 85ebd2477b966e0f672b0d8bc62cdabee5a4f344 Mon Sep 17 00:00:00 2001 From: Oliver Elbert Date: Mon, 9 Sep 2024 11:25:53 -0400 Subject: [PATCH 150/154] hotfix to handle bool in serialized test data --- ndsl/stencils/testing/translate.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ndsl/stencils/testing/translate.py b/ndsl/stencils/testing/translate.py index 2f07f82f..3d9d20f9 100644 --- a/ndsl/stencils/testing/translate.py +++ b/ndsl/stencils/testing/translate.py @@ -167,6 +167,8 @@ def make_storage_data_input_vars(self, inputs, storage_vars=None): for p in self.in_vars["parameters"]: if type(inputs_in[p]) in [np.int64, np.int32]: inputs_out[p] = int(inputs_in[p]) + elif type(inputs_in[p]) is bool: + inputs_out[p] == inputs_in[p] else: inputs_out[p] = Float(inputs_in[p]) for d, info in storage_vars.items(): From 1318b56927143905cbb8d48f88f84141bfde4d31 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 12 Sep 2024 13:10:01 -0400 Subject: [PATCH 151/154] Amended generation.py to set default eta_file to None --- ndsl/grid/generation.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ndsl/grid/generation.py b/ndsl/grid/generation.py index caf91031..8a20be65 100644 --- a/ndsl/grid/generation.py +++ b/ndsl/grid/generation.py @@ -237,7 +237,7 @@ def __init__( dy_const: float = 1000.0, deglat: float = 15.0, extdgrid: bool = False, - eta_file: str = "", + eta_file: str = None, ak: Optional[np.ndarray] = None, bk: Optional[np.ndarray] = None, ): @@ -297,7 +297,7 @@ def __init__( self._dy_center = None self._area = None self._area_c = None - if eta_file != "": + if eta_file is not None: ( self._ks, self._ptop, From a1010dd603fe32c11bc3d6c0379cbf32ea59e118 Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Thu, 12 Sep 2024 14:06:58 -0400 Subject: [PATCH 152/154] Changed type hinting of eta_file in generation.py to reflect optional aspect --- ndsl/grid/generation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ndsl/grid/generation.py b/ndsl/grid/generation.py index 8a20be65..75437272 100644 --- a/ndsl/grid/generation.py +++ b/ndsl/grid/generation.py @@ -237,7 +237,7 @@ def __init__( dy_const: float = 1000.0, deglat: float = 15.0, extdgrid: bool = False, - eta_file: str = None, + eta_file: Optional[str] = None, ak: Optional[np.ndarray] = None, bk: Optional[np.ndarray] = None, ): From b87b0cbd7e02c2b39eda456fdc543983b61e779a Mon Sep 17 00:00:00 2001 From: Frank Malatino Date: Fri, 13 Sep 2024 10:37:33 -0400 Subject: [PATCH 153/154] Updates to submodules and version number --- external/dace | 2 +- external/gt4py | 2 +- setup.py | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/external/dace b/external/dace index ee5a6dfe..da644fe8 160000 --- a/external/dace +++ b/external/dace @@ -1 +1 @@ -Subproject commit ee5a6dfe695f329c3882105b087f3563a0c80b81 +Subproject commit da644fe8c179022fe8e730fb3f47f6399f1db4ce diff --git a/external/gt4py b/external/gt4py index 32dde792..0ddddd37 160000 --- a/external/gt4py +++ b/external/gt4py @@ -1 +1 @@ -Subproject commit 32dde792bde505807a5729261e4f1d12a1451bdb +Subproject commit 0ddddd37d3056ad6518f33908eb02f3b1f992878 diff --git a/setup.py b/setup.py index f18fe4b9..03dcbf0f 100644 --- a/setup.py +++ b/setup.py @@ -40,7 +40,7 @@ def local_pkg(name: str, relative_path: str) -> str: setup( author="NOAA/NASA", - python_requires=">=3.8", + python_requires=">=3.11", classifiers=[ "Development Status :: 2 - Pre-Alpha", "Intended Audience :: Developers", @@ -57,7 +57,7 @@ def local_pkg(name: str, relative_path: str) -> str: packages=find_namespace_packages(include=["ndsl", "ndsl.*"]), include_package_data=True, url="https://github.com/NOAA-GFDL/NDSL", - version="2024.06.00", + version="2024.09.00", zip_safe=False, entry_points={ "console_scripts": [ From 8a719ef69c4c49c835bfb707ab012b60963ff585 Mon Sep 17 00:00:00 2001 From: Florian Deconinck Date: Thu, 26 Sep 2024 10:59:34 -0400 Subject: [PATCH 154/154] Translate: print only ~10 errors and dump all data in files under `.translate-errors` --- ndsl/stencils/testing/test_translate.py | 19 ++- ndsl/testing/comparison.py | 195 +++++++++++++----------- 2 files changed, 125 insertions(+), 89 deletions(-) diff --git a/ndsl/stencils/testing/test_translate.py b/ndsl/stencils/testing/test_translate.py index 55ee1001..db8e6047 100644 --- a/ndsl/stencils/testing/test_translate.py +++ b/ndsl/stencils/testing/test_translate.py @@ -210,13 +210,19 @@ def test_sequential_savepoint( near_zero=case.testobj.near_zero, ) if not metric.check: + os.makedirs(OUTDIR, exist_ok=True) + log_filename = os.path.join( + OUTDIR, + f"details-{case.savepoint_name}-{varname}-rank{case.rank}.log", + ) + metric.report(log_filename) pytest.fail(str(metric), pytrace=False) passing_names.append(failing_names.pop()) ref_data_out[varname] = [ref_data] if len(failing_names) > 0: get_thresholds(case.testobj, input_data=original_input_data) os.makedirs(OUTDIR, exist_ok=True) - out_filename = os.path.join(OUTDIR, f"translate-{case.savepoint_name}.nc") + nc_filename = os.path.join(OUTDIR, f"translate-{case.savepoint_name}.nc") input_data_on_host = {} for key, _input in input_data.items(): input_data_on_host[key] = gt_utils.asarray(_input) @@ -226,7 +232,7 @@ def test_sequential_savepoint( [output], ref_data_out, failing_names, - out_filename, + nc_filename, ) if failing_names != []: pytest.fail( @@ -353,11 +359,16 @@ def test_parallel_savepoint( near_zero=case.testobj.near_zero, ) if not metric.check: + os.makedirs(OUTDIR, exist_ok=True) + log_filename = os.path.join( + OUTDIR, f"details-{case.savepoint_name}-{varname}.log" + ) + metric.report(log_filename) pytest.fail(str(metric), pytrace=False) passing_names.append(failing_names.pop()) if len(failing_names) > 0: os.makedirs(OUTDIR, exist_ok=True) - out_filename = os.path.join( + nct_filename = os.path.join( OUTDIR, f"translate-{case.savepoint_name}-{case.grid.rank}.nc" ) try: @@ -370,7 +381,7 @@ def test_parallel_savepoint( [output], ref_data, failing_names, - out_filename, + nct_filename, ) except Exception as error: print(f"TestParallel SaveNetCDF Error: {error}") diff --git a/ndsl/testing/comparison.py b/ndsl/testing/comparison.py index d3ac0d65..9e2d1d59 100644 --- a/ndsl/testing/comparison.py +++ b/ndsl/testing/comparison.py @@ -1,4 +1,4 @@ -from typing import Union +from typing import List, Optional, Union import numpy as np import numpy.typing as npt @@ -20,6 +20,9 @@ def __str__(self) -> str: def __repr__(self) -> str: ... + def report(self, file_path: Optional[str] = None) -> List[str]: + ... + class LegacyMetric(BaseMetric): """Legacy (AI2) metric used for original FV3 port. @@ -88,67 +91,78 @@ def _compute_errors( ) return success - def __str__(self) -> str: - return self.__repr__() - - def __repr__(self) -> str: + def report(self, file_path: Optional[str] = None) -> List[str]: + report = [] if self.check: - return "✅ No numerical differences" + report.append("✅ No numerical differences") + else: + report.append("❌ Numerical failures") + + found_indices = np.logical_not(self.success).nonzero() + computed_failures = self.computed[found_indices] + reference_failures = self.references[found_indices] + + # List all errors + bad_indices_count = len(found_indices[0]) + # Determine worst result + worst_metric_err = 0.0 + abs_errs = [] + details = [ + "All failures:", + "Index Computed Reference Absloute E Metric E", + ] + for b in range(bad_indices_count): + full_index = tuple([f[b] for f in found_indices]) + + metric_err = self._calculated_metric[full_index] + + absolute_distance = abs(computed_failures[b] - reference_failures[b]) + abs_errs.append(absolute_distance) + + details.append( + f"{full_index} {computed_failures[b]} " + f"{reference_failures[b]} {abs_errs[-1]:.3e} {metric_err:.3e}" + ) - report = [] - report.append("❌ Numerical failures") - - found_indices = np.logical_not(self.success).nonzero() - computed_failures = self.computed[found_indices] - reference_failures = self.references[found_indices] - - # List all errors - bad_indices_count = len(found_indices[0]) - # Determine worst result - worst_metric_err = 0.0 - abs_errs = [] - details = [ - "All failures:", - "Index Computed Reference Absloute E Metric E", - ] - for b in range(bad_indices_count): - full_index = tuple([f[b] for f in found_indices]) - - metric_err = self._calculated_metric[full_index] - - absolute_distance = abs(computed_failures[b] - reference_failures[b]) - abs_errs.append(absolute_distance) - - details.append( - f"{full_index} {computed_failures[b]} " - f"{reference_failures[b]} {abs_errs[-1]:.3e} {metric_err:.3e}" + if np.isnan(metric_err) or (abs(metric_err) > abs(worst_metric_err)): + worst_metric_err = metric_err + worst_full_idx = full_index + worst_abs_err = abs_errs[-1] + computed_worst = computed_failures[b] + reference_worst = reference_failures[b] + # Try to quantify noisy errors + unique_errors = len(np.unique(np.array(abs_errs))) + # Summary and worst result + fullcount = len(self.references.flatten()) + report.append( + f"Failed count: {bad_indices_count}/{fullcount} " + f"({round(100.0 * (bad_indices_count / fullcount), 2)}%),\n" + f"Worst failed index {worst_full_idx}\n" + f" Computed:{computed_worst}\n" + f" Reference: {reference_worst}\n" + f" Absolute diff: {worst_abs_err:.3e}\n" + f" Metric diff: {worst_metric_err:.3e}\n" + f" Metric threshold: {self.eps}\n" + f" Noise quantification:\n" + f" Reference dtype: {type(reference_worst)}\n" + f" Unique errors: {unique_errors}/{bad_indices_count}" ) + report.extend(details) - if np.isnan(metric_err) or (abs(metric_err) > abs(worst_metric_err)): - worst_metric_err = metric_err - worst_full_idx = full_index - worst_abs_err = abs_errs[-1] - computed_worst = computed_failures[b] - reference_worst = reference_failures[b] - # Try to quantify noisy errors - unique_errors = len(np.unique(np.array(abs_errs))) - # Summary and worst result - fullcount = len(self.references.flatten()) - report.append( - f"Failed count: {bad_indices_count}/{fullcount} " - f"({round(100.0 * (bad_indices_count / fullcount), 2)}%),\n" - f"Worst failed index {worst_full_idx}\n" - f" Computed:{computed_worst}\n" - f" Reference: {reference_worst}\n" - f" Absolute diff: {worst_abs_err:.3e}\n" - f" Metric diff: {worst_metric_err:.3e}\n" - f" Metric threshold: {self.eps}\n" - f" Noise quantification:\n" - f" Reference dtype: {type(reference_worst)}\n" - f" Unique errors: {unique_errors}/{bad_indices_count}" - ) - report.extend(details) + if file_path: + with open(file_path, "w") as fd: + fd.write("\n".join(report)) + + return report + + def __str__(self) -> str: + return self.__repr__() + def __repr__(self) -> str: + report = self.report() + if len(report) > 30: + report = report[:30] # ~10 first errors + report.append("...") return "\n".join(report) @@ -231,36 +245,47 @@ def _compute_all_metrics( f"recieved data with unexpected dtype {self.references.dtype}" ) + def report(self, file_path: Optional[str] = None) -> List[str]: + report = [] + if self.check: + report.append("✅ No numerical differences") + else: + report.append("❌ Numerical failures") + + found_indices = np.logical_not(self.success).nonzero() + # List all errors to terminal and file + bad_indices_count = len(found_indices[0]) + full_count = len(self.references.flatten()) + failures_pct = round(100.0 * (bad_indices_count / full_count), 2) + report = [ + f"All failures ({bad_indices_count}/{full_count}) ({failures_pct}%),\n", + f"Index Computed Reference " + f"Absolute E(<{self.absolute_eps:.2e}) " + f"Relative E(<{self.relative_fraction * 100:.2e}%) " + f"ULP E(<{self.ulp_threshold})", + ] + # Summary and worst result + for iBad in range(bad_indices_count): + fi = tuple([f[iBad] for f in found_indices]) + report.append( + f"{str(fi)} {self.computed[fi]:.16e} {self.references[fi]:.16e} " + f"{self.absolute_distance[fi]:.2e} {'✅' if self.absolute_distance_metric[fi] else '❌'} " + f"{self.relative_distance[fi] * 100:.2e} {'✅' if self.relative_distance_metric[fi] else '❌'} " + f"{int(self.ulp_distance[fi]):02} {'✅' if self.ulp_distance_metric[fi] else '❌'} " + ) + + if file_path: + with open(file_path, "w") as fd: + fd.write("\n".join(report)) + + return report + def __str__(self) -> str: return self.__repr__() def __repr__(self) -> str: - if self.check: - return "✅ No numerical differences" - - report = [] - report.append("❌ Numerical failures") - - found_indices = np.logical_not(self.success).nonzero() - # List all errors - bad_indices_count = len(found_indices[0]) - full_count = len(self.references.flatten()) - failures_pct = round(100.0 * (bad_indices_count / full_count), 2) - report = [ - f"All failures ({bad_indices_count}/{full_count}) ({failures_pct}%),\n", - f"Index Computed Reference " - f"Absolute E(<{self.absolute_eps:.2e}) " - f"Relative E(<{self.relative_fraction * 100:.2e}%) " - f"ULP E(<{self.ulp_threshold})", - ] - # Summary and worst result - for iBad in range(bad_indices_count): - fi = tuple([f[iBad] for f in found_indices]) - report.append( - f"({fi[0]:02}, {fi[1]:02}, {fi[2]:02}) {self.computed[fi]:.16e} {self.references[fi]:.16e} " - f"{self.absolute_distance[fi]:.2e} {'✅' if self.absolute_distance_metric[fi] else '❌'} " - f"{self.relative_distance[fi] * 100:.2e} {'✅' if self.relative_distance_metric[fi] else '❌'} " - f"{int(self.ulp_distance[fi]):02} {'✅' if self.ulp_distance_metric[fi] else '❌'} " - ) - + report = self.report() + if len(report) > 12: + report = report[:12] # ~10 first errors + report.append("...") return "\n".join(report)