diff --git a/.github/workflows/mpi.yml b/.github/workflows/mpi.yml
index 4ff2e30d..19985d37 100644
--- a/.github/workflows/mpi.yml
+++ b/.github/workflows/mpi.yml
@@ -88,7 +88,7 @@ jobs:
- if: steps.cache.outputs.cache-hit != 'true'
run: |
HDF5_MPI="ON" CC=mpicc pip install --no-binary=h5py h5py==3.13.0
- pip install -e MPI[tests]
+ pip install -e .[tests] -e ./examples[tests] -e ./MPI[tests]
- run: pip show numpy
- id: cache-save
if: steps.cache.outputs.cache-hit != 'true'
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 1877efda..9e0a6c36 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -134,6 +134,9 @@ jobs:
python -We -c "import PyMPDATA"
python -m pip install $PIP_INSTALL_ARGS -e .[tests] -e ./examples
+ - if: startsWith(matrix.platform, 'macos-')
+ run: python -m pip install intel-openmp
+
- if: startsWith(matrix.platform, 'ubuntu-')
run: echo NUMBA_THREADING_LAYER=omp >> $GITHUB_ENV
diff --git a/MPI/pyproject.toml b/MPI/pyproject.toml
index 6b86a85f..9ee0e98a 100644
--- a/MPI/pyproject.toml
+++ b/MPI/pyproject.toml
@@ -14,7 +14,7 @@ build-backend = "setuptools.build_meta"
name = "pympdata-mpi"
description = "PyMPDATA + numba-mpi coupler sandbox"
readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.9"
keywords = ["MPI", "MPDATA", "Numba", "PyMPDATA"]
license = {text = "GPL-3.0"}
classifiers = [
@@ -32,6 +32,7 @@ dependencies = [
"numpy<1.25.0",
"numba_mpi>=0.30",
"PyMPDATA",
+ "PyMPDATA-examples",
"mpi4py==4.0.3",
"h5py",
]
diff --git a/PyMPDATA/impl/formulae_divide.py b/PyMPDATA/impl/formulae_divide.py
new file mode 100644
index 00000000..25dfc275
--- /dev/null
+++ b/PyMPDATA/impl/formulae_divide.py
@@ -0,0 +1,62 @@
+"""operation logic for dividing the field by a set divisor table and saving
+the result to a temporary field. Requires 'dynmaic_advector' option to be enabled"""
+
+import numba
+import numpy as np
+
+from .enumerations import INNER, MID3D, OUTER
+from .meta import META_HALO_VALID
+
+
+def make_divide_or_zero(options, traversals):
+ """returns njit-ted function for use with given traversals"""
+
+ n_dims = traversals.n_dims
+
+ @numba.njit(**options.jit_flags)
+ # pylint: disable=too-many-arguments
+ def divide_or_zero(
+ out_outer_meta,
+ out_outer_data,
+ out_mid3d_meta,
+ out_mid3d_data,
+ out_inner_meta,
+ out_inner_data,
+ _,
+ dividend_outer,
+ __,
+ dividend_mid3d,
+ ___,
+ dividend_inner,
+ ____,
+ divisor,
+ time_step,
+ grid_step,
+ ):
+ eps = 1e-7
+ for i in np.ndindex(out_inner_data.shape):
+ if n_dims > 1:
+ out_outer_data[i] = (
+ dividend_outer[i] / divisor[i] * time_step / grid_step[OUTER]
+ if divisor[i] > eps
+ else 0
+ )
+ if n_dims > 2:
+ out_mid3d_data[i] = (
+ dividend_mid3d[i] / divisor[i] * time_step / grid_step[MID3D]
+ if divisor[i] > eps
+ else 0
+ )
+ out_inner_data[i] = (
+ dividend_inner[i] / divisor[i] * time_step / grid_step[INNER]
+ if divisor[i] > eps
+ else 0
+ )
+
+ if n_dims > 1:
+ out_outer_meta[META_HALO_VALID] = False
+ if n_dims > 2:
+ out_mid3d_meta[META_HALO_VALID] = False
+ out_inner_meta[META_HALO_VALID] = False
+
+ return divide_or_zero
diff --git a/PyMPDATA/impl/indexers.py b/PyMPDATA/impl/indexers.py
index f40fc66d..f55f75eb 100644
--- a/PyMPDATA/impl/indexers.py
+++ b/PyMPDATA/impl/indexers.py
@@ -31,6 +31,14 @@ def ats_1d(focus, arr, k, _=INVALID_INDEX, __=INVALID_INDEX):
def atv_1d(focus, arrs, k, _=INVALID_INDEX, __=INVALID_INDEX):
return arrs[INNER][focus[INNER] + int(k - 0.5)]
+ @staticmethod
+ @numba.njit(**jit_flags)
+ def ati_1d(focus, arrs, k, _=INVALID_INDEX, __=INVALID_INDEX):
+ return (
+ arrs[INNER][focus[INNER] + int(k - 0.5)]
+ + arrs[INNER][focus[INNER] + int(k + 0.5)]
+ ) / 2
+
@staticmethod
@numba.njit(**jit_flags)
def set(arr, _, __, k, value):
@@ -70,6 +78,30 @@ def atv_axis1(focus, arrs, k, i=0, _=INVALID_INDEX):
dim, _ii, _kk = OUTER, int(i - 0.5), int(k)
return arrs[dim][focus[OUTER] + _ii, focus[INNER] + _kk]
+ @staticmethod
+ @numba.njit(**jit_flags)
+ def ati_axis0(focus, arrs, i, k=0, _=INVALID_INDEX):
+ if _is_integral(i):
+ dim, _ii, _kk = INNER, int(i), int(k - 0.5)
+ else:
+ dim, _ii, _kk = OUTER, int(i - 0.5), int(k)
+ return (
+ arrs[dim][focus[OUTER] + _ii, focus[INNER] + _kk]
+ + arrs[dim][focus[OUTER] + _ii + 1, focus[INNER] + _kk]
+ ) / 2
+
+ @staticmethod
+ @numba.njit(**jit_flags)
+ def ati_axis1(focus, arrs, k, i=0, _=INVALID_INDEX):
+ if _is_integral(i):
+ dim, _ii, _kk = INNER, int(i), int(k - 0.5)
+ else:
+ dim, _ii, _kk = OUTER, int(i - 0.5), int(k)
+ return (
+ arrs[dim][focus[OUTER] + _ii, focus[INNER] + _kk]
+ + arrs[dim][focus[OUTER] + _ii, focus[INNER] + _kk + 1]
+ ) / 2
+
@staticmethod
@numba.njit(**jit_flags)
def set(arr, i, _, k, value):
@@ -140,17 +172,23 @@ def get(arr, i, j, k):
return arr[i, j, k]
Indexers = namedtuple( # pylint: disable=invalid-name
- Path(__file__).stem + "_Indexers", ("ats", "atv", "set", "get", "n_dims")
+ Path(__file__).stem + "_Indexers", ("ats", "atv", "ati", "set", "get", "n_dims")
)
indexers = (
None,
Indexers(
- (None, None, _1D.ats_1d), (None, None, _1D.atv_1d), _1D.set, _1D.get, 1
+ (None, None, _1D.ats_1d),
+ (None, None, _1D.atv_1d),
+ (None, None, _1D.ati_1d),
+ _1D.set,
+ _1D.get,
+ 1,
),
Indexers(
(_2D.ats_axis0, None, _2D.ats_axis1),
(_2D.atv_axis0, None, _2D.atv_axis1),
+ (_2D.ati_axis0, None, _2D.ati_axis1),
_2D.set,
_2D.get,
2,
@@ -158,6 +196,7 @@ def get(arr, i, j, k):
Indexers(
(_3D.ats_axis0, _3D.ats_axis1, _3D.ats_axis2),
(_3D.atv_axis0, _3D.atv_axis1, _3D.atv_axis2),
+ (None, None, None),
_3D.set,
_3D.get,
3,
diff --git a/PyMPDATA/options.py b/PyMPDATA/options.py
index 4ed9d181..a8c597fe 100644
--- a/PyMPDATA/options.py
+++ b/PyMPDATA/options.py
@@ -32,6 +32,7 @@ def __init__(
DPDC: bool = False, # pylint: disable=invalid-name
epsilon: float = 1e-15,
non_zero_mu_coeff: bool = False,
+ dynamic_advector: bool = False,
dimensionally_split: bool = False,
dtype: [np.float32, np.float64] = np.float64
):
@@ -44,6 +45,7 @@ def __init__(
"nonoscillatory": nonoscillatory,
"third_order_terms": third_order_terms,
"non_zero_mu_coeff": non_zero_mu_coeff,
+ "dynamic_advector": dynamic_advector,
"dimensionally_split": dimensionally_split,
"dtype": dtype,
"DPDC": DPDC,
@@ -131,6 +133,11 @@ def non_zero_mu_coeff(self) -> bool:
"""flag enabling handling of Fickian diffusion term"""
return self._values["non_zero_mu_coeff"]
+ @property
+ def dynamic_advector(self) -> bool:
+ """flag enabling (todo desc)"""
+ return self._values["dynamic_advector"]
+
@property
def dimensionally_split(self) -> bool:
"""flag disabling cross-dimensional terms in antidiffusive velocities"""
diff --git a/PyMPDATA/solver.py b/PyMPDATA/solver.py
index 8e6fff61..caf40d60 100644
--- a/PyMPDATA/solver.py
+++ b/PyMPDATA/solver.py
@@ -3,7 +3,7 @@ class grouping user-supplied stepper, fields and post-step/post-iter hooks,
as well as self-initialised temporary storage
"""
-from typing import Union
+from typing import Hashable, Iterable, Mapping, Union
import numba
@@ -13,6 +13,27 @@ class grouping user-supplied stepper, fields and post-step/post-iter hooks,
from .vector_field import VectorField
+@numba.experimental.jitclass([])
+class AnteStepNull: # pylint: disable=too-few-public-methods
+ """do-nothing version of the ante-step hook"""
+
+ def __init__(self):
+ pass
+
+ def call(
+ self,
+ traversals_data,
+ advectee,
+ advector,
+ step,
+ index,
+ todo_outer,
+ todo_mid3d,
+ todo_inner,
+ ): # pylint: disable-next=unused-argument,disable=too-many-arguments
+ """think of it as a `__call__` method (which Numba does not allow)"""
+
+
@numba.experimental.jitclass([])
class PostStepNull: # pylint: disable=too-few-public-methods
"""do-nothing version of the post-step hook"""
@@ -20,7 +41,9 @@ class PostStepNull: # pylint: disable=too-few-public-methods
def __init__(self):
pass
- def call(self, psi, step): # pylint: disable-next=unused-argument
+ def call(
+ self, traversals_data, psi, step, index
+ ): # pylint: disable-next=unused-argument
"""think of it as a `__call__` method (which Numba does not allow)"""
@@ -31,7 +54,9 @@ class PostIterNull: # pylint: disable=too-few-public-methods
def __init__(self):
pass
- def call(self, flux, g_factor, step, iteration): # pylint: disable=unused-argument
+ def call(
+ self, traversals_data, flux, g_factor, step, iteration
+ ): # pylint: disable=unused-argument,disable=too-many-arguments
"""think of it as a `__call__` method (which Numba does not allow)"""
@@ -48,66 +73,88 @@ class Solver:
def __init__(
self,
stepper: Stepper,
- advectee: ScalarField,
+ advectee: [ScalarField, Iterable[ScalarField], Mapping[Hashable, ScalarField]],
advector: VectorField,
g_factor: [ScalarField, None] = None,
):
+ self.advectee = advectee
+ n_dims = advector.n_dims
+ if isinstance(advectee, ScalarField):
+ self.__fields = {"advectee": (advectee,)}
+
+ elif isinstance(advectee, Mapping):
+ self.__fields = {"advectee": tuple(advectee.values())}
+
+ elif isinstance(advectee, Iterable):
+ self.__fields = {"advectee": tuple(advectee)}
+
def scalar_field(dtype=None):
- return ScalarField.clone(advectee, dtype=dtype)
+ return ScalarField.clone(self.__fields["advectee"][0], dtype=dtype)
def null_scalar_field():
- return ScalarField.make_null(advectee.n_dims, stepper.traversals)
+ return ScalarField.make_null(n_dims, stepper.traversals)
def vector_field():
return VectorField.clone(advector)
def null_vector_field():
- return VectorField.make_null(advector.n_dims, stepper.traversals)
+ return VectorField.make_null(n_dims, stepper.traversals)
- for field in [advector, advectee] + (
+ for field in [advector, *self.__fields["advectee"]] + (
[g_factor] if g_factor is not None else []
):
assert field.halo == stepper.options.n_halo
assert field.dtype == stepper.options.dtype
assert field.grid == advector.grid
- self.__fields = {
- "advectee": advectee,
- "advector": advector,
- "g_factor": g_factor or null_scalar_field(),
- "vectmp_a": vector_field(),
- "vectmp_b": vector_field(),
- "vectmp_c": (
- vector_field()
- if stepper.options.non_zero_mu_coeff
- else null_vector_field()
- ),
- "nonosc_xtrm": (
- scalar_field(dtype=complex)
- if stepper.options.nonoscillatory
- else null_scalar_field()
- ),
- "nonosc_beta": (
- scalar_field(dtype=complex)
- if stepper.options.nonoscillatory
- else null_scalar_field()
- ),
- }
- for field in self.__fields.values():
- field.assemble(stepper.traversals)
+ self.__fields.update(
+ {
+ "advector": advector,
+ "g_factor": g_factor or null_scalar_field(),
+ "vectmp_a": vector_field(),
+ "vectmp_b": vector_field(),
+ "vectmp_c": (
+ vector_field()
+ if stepper.options.non_zero_mu_coeff
+ else null_vector_field()
+ ),
+ "todo_outer": (
+ scalar_field()
+ if stepper.options.dynamic_advector and n_dims > 1
+ else null_scalar_field()
+ ),
+ "todo_mid3d": (
+ scalar_field()
+ if stepper.options.dynamic_advector and n_dims > 2
+ else null_scalar_field()
+ ),
+ "todo_inner": (
+ scalar_field()
+ if stepper.options.dynamic_advector
+ else null_scalar_field()
+ ),
+ "nonosc_xtrm": (
+ scalar_field(dtype=complex)
+ if stepper.options.nonoscillatory
+ else null_scalar_field()
+ ),
+ "nonosc_beta": (
+ scalar_field(dtype=complex)
+ if stepper.options.nonoscillatory
+ else null_scalar_field()
+ ),
+ }
+ )
+ for key, value in self.__fields.items():
+ for field in (value,) if key != "advectee" else value:
+ field.assemble(stepper.traversals)
self.__stepper = stepper
- @property
- def advectee(self) -> ScalarField:
- """advectee scalar field (with halo), modified by advance(),
- may be modified from user code (e.g., source-term handling)"""
- return self.__fields["advectee"]
-
@property
def advector(self) -> VectorField:
- """advector vector field (with halo), unmodified by advance(),
- may be modified from user code"""
+ """advector vector field , todo_outer, todo_mid3d, todo_inner(with halo),
+ unmodified by advance(), may be modified from user code"""
return self.__fields["advector"]
@property
@@ -126,9 +173,10 @@ def advance(
self,
n_steps: int,
mu_coeff: Union[tuple, None] = None,
+ ante_step=None,
post_step=None,
post_iter=None,
- ):
+ ): # pylint: disable=too-many-arguments
"""advances solution by `n_steps` steps, optionally accepts: a tuple of diffusion
coefficients (one value per dimension) as well as `post_iter` and `post_step`
callbacks expected to be `numba.jitclass`es with a `call` method, for
@@ -144,12 +192,14 @@ def advance(
):
raise NotImplementedError()
+ ante_step = ante_step or AnteStepNull()
post_step = post_step or PostStepNull()
post_iter = post_iter or PostIterNull()
return self.__stepper(
n_steps=n_steps,
mu_coeff=mu_coeff,
+ ante_step=ante_step,
post_step=post_step,
post_iter=post_iter,
fields=self.__fields,
diff --git a/PyMPDATA/stepper.py b/PyMPDATA/stepper.py
index 34c70f7a..54d72e4f 100644
--- a/PyMPDATA/stepper.py
+++ b/PyMPDATA/stepper.py
@@ -9,7 +9,7 @@
from numba.core.errors import NumbaExperimentalFeatureWarning
from .impl.clock import clock
-from .impl.enumerations import ARG_DATA, IMPL_BC, IMPL_META_AND_DATA, MAX_DIM_NUM
+from .impl.enumerations import IMPL_BC, IMPL_META_AND_DATA, MAX_DIM_NUM
from .impl.formulae_antidiff import make_antidiff
from .impl.formulae_axpy import make_axpy
from .impl.formulae_flux import make_flux_first_pass, make_flux_subsequent
@@ -108,18 +108,28 @@ def n_dims(self) -> int:
"""dimensionality (1, 2 or 3)"""
return self.__n_dims
- def __call__(self, *, n_steps, mu_coeff, post_step, post_iter, fields):
+ def __call__(self, *, n_steps, mu_coeff, ante_step, post_step, post_iter, fields):
assert self.n_threads == 1 or numba.get_num_threads() == self.n_threads
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=NumbaExperimentalFeatureWarning)
wall_time_per_timestep = self.__call(
n_steps,
mu_coeff,
+ ante_step,
post_step,
post_iter,
*(
- _Impl(field=v.impl[IMPL_META_AND_DATA], bc=v.impl[IMPL_BC])
- for v in fields.values()
+ (
+ _Impl(field=v.impl[IMPL_META_AND_DATA], bc=v.impl[IMPL_BC])
+ if k != "advectee"
+ else tuple(
+ _Impl(
+ field=vv.impl[IMPL_META_AND_DATA], bc=vv.impl[IMPL_BC]
+ )
+ for vv in v
+ )
+ )
+ for k, v in fields.items()
),
self.traversals.data,
)
@@ -163,79 +173,107 @@ def make_step_impl(
def step(
n_steps,
mu_coeff,
+ ante_step,
post_step,
post_iter,
- advectee,
+ advectees,
advector,
g_factor,
vectmp_a,
vectmp_b,
vectmp_c,
+ todo_outer,
+ todo_mid3d,
+ todo_inner,
psi_extrema,
beta,
- null_impl,
+ traversals_data,
):
time = clock()
for step in range(n_steps):
- if non_zero_mu_coeff:
- advector_orig = advector
- advector = vectmp_c
- for iteration in range(n_iters):
- if iteration == 0:
- if nonoscillatory:
- nonoscillatory_psi_extrema(null_impl, psi_extrema, advectee)
- if non_zero_mu_coeff:
- laplacian(null_impl, advector, advectee)
- axpy(
- *advector.field,
- mu_coeff,
- *advector.field,
- *advector_orig.field,
- )
- flux_first_pass(null_impl, vectmp_a, advector, advectee)
- flux = vectmp_a
- else:
- if iteration == 1:
- advector_oscil = advector
- advector_nonos = vectmp_a
- flux = vectmp_b
- elif iteration % 2 == 0:
- advector_oscil = vectmp_a
- advector_nonos = vectmp_b
+ for index, advectee in enumerate(advectees):
+ ante_step.call(
+ traversals_data,
+ advectees,
+ advector,
+ step,
+ index,
+ todo_outer,
+ todo_mid3d,
+ todo_inner,
+ )
+ if non_zero_mu_coeff:
+ advector_orig = advector
+ advector = vectmp_c
+ for iteration in range(n_iters):
+ if iteration == 0:
+ if nonoscillatory:
+ nonoscillatory_psi_extrema(
+ traversals_data, psi_extrema, advectee
+ )
+ if non_zero_mu_coeff:
+ laplacian(traversals_data, advector, advectee)
+ axpy(
+ *advector.field,
+ mu_coeff,
+ *advector.field,
+ *advector_orig.field,
+ )
+ flux_first_pass(traversals_data, vectmp_a, advector, advectee)
flux = vectmp_a
else:
- advector_oscil = vectmp_b
- advector_nonos = vectmp_a
- flux = vectmp_b
- if iteration < n_iters - 1:
- antidiff(
- null_impl,
- advector_nonos,
- advectee,
- advector_oscil,
- g_factor,
- )
- else:
- antidiff_last_pass(
- null_impl,
- advector_nonos,
- advectee,
- advector_oscil,
- g_factor,
- )
- flux_subsequent(null_impl, flux, advectee, advector_nonos)
- if nonoscillatory:
- nonoscillatory_beta(
- null_impl, beta, flux, advectee, psi_extrema, g_factor
- )
- # note: in libmpdata++, the oscillatory advector from prev iter is used
- nonoscillatory_correction(null_impl, advector_nonos, beta)
- flux_subsequent(null_impl, flux, advectee, advector_nonos)
- upwind(null_impl, advectee, flux, g_factor)
- post_iter.call(flux.field, g_factor.field, step, iteration)
- if non_zero_mu_coeff:
- advector = advector_orig
- post_step.call(advectee.field[ARG_DATA], step)
+ if iteration == 1:
+ advector_oscil = advector
+ advector_nonos = vectmp_a
+ flux = vectmp_b
+ elif iteration % 2 == 0:
+ advector_oscil = vectmp_a
+ advector_nonos = vectmp_b
+ flux = vectmp_a
+ else:
+ advector_oscil = vectmp_b
+ advector_nonos = vectmp_a
+ flux = vectmp_b
+ if iteration < n_iters - 1:
+ antidiff(
+ traversals_data,
+ advector_nonos,
+ advectee,
+ advector_oscil,
+ g_factor,
+ )
+ else:
+ antidiff_last_pass(
+ traversals_data,
+ advector_nonos,
+ advectee,
+ advector_oscil,
+ g_factor,
+ )
+ flux_subsequent(traversals_data, flux, advectee, advector_nonos)
+ if nonoscillatory:
+ nonoscillatory_beta(
+ traversals_data,
+ beta,
+ flux,
+ advectee,
+ psi_extrema,
+ g_factor,
+ )
+ # note: in libmpdata++, the oscillatory advector from prev iter is used
+ nonoscillatory_correction(
+ traversals_data, advector_nonos, beta
+ )
+ flux_subsequent(
+ traversals_data, flux, advectee, advector_nonos
+ )
+ upwind(traversals_data, advectee, flux, g_factor)
+ post_iter.call(
+ traversals_data, flux.field, g_factor.field, step, iteration
+ )
+ if non_zero_mu_coeff:
+ advector = advector_orig
+ post_step.call(traversals_data, advectees, step, index)
return (clock() - time) / n_steps if n_steps > 0 else np.nan
return step, traversals
diff --git a/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/simulation.py b/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/simulation.py
index c2cb6fe5..e021863e 100644
--- a/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/simulation.py
+++ b/examples/PyMPDATA_examples/Arabas_and_Farhat_2020/simulation.py
@@ -4,6 +4,7 @@
from PyMPDATA import Options, ScalarField, Solver, Stepper, VectorField
from PyMPDATA.boundary_conditions import Extrapolated
+from PyMPDATA.impl.enumerations import ARG_DATA
class Simulation:
@@ -98,11 +99,14 @@ class PostStep:
def __init__(self):
pass
- def call(self, psi, step):
+ def call(self, _, psi, step, index):
t = T - (step + 1) * dt
- psi += np.maximum(psi, f_T / np.exp(r * t)) - psi
+ psi[index].field[ARG_DATA][:] += (
+ np.maximum(psi[index].field[ARG_DATA], f_T / np.exp(r * t))
+ - psi[index].field[ARG_DATA]
+ )
- self.solvers[n_iters].advance(self.nt, self.mu_coeff, PostStep())
+ self.solvers[n_iters].advance(self.nt, self.mu_coeff, post_step=PostStep())
else:
self.solvers[n_iters].advance(self.nt, self.mu_coeff)
diff --git a/examples/PyMPDATA_examples/Jarecka_et_al_2015/formulae.py b/examples/PyMPDATA_examples/Jarecka_et_al_2015/formulae.py
index 9796a588..f7dc2e52 100644
--- a/examples/PyMPDATA_examples/Jarecka_et_al_2015/formulae.py
+++ b/examples/PyMPDATA_examples/Jarecka_et_al_2015/formulae.py
@@ -7,6 +7,8 @@
import numpy as np
from scipy.integrate import odeint
+from PyMPDATA.impl.enumerations import ARG_DATA, ARG_FOCUS, MAX_DIM_NUM
+
def amplitude(x, y, lx, ly):
A = 1 / lx / ly
@@ -34,3 +36,95 @@ def d2_el_lamb_lamb_t_evol(times, lamb_x0, lamb_y0):
result, info = odeint(deriv, yinit, times, full_output=True)
assert info["message"] == "Integration successful."
return result
+
+
+def make_rhs_indexers(ats, grid_step, time_step, options):
+ @numba.njit(**options.jit_flags)
+ def rhs(m, _0, h, _1, _2, _3):
+ retval = (
+ m
+ - ((ats(*h, +1) - ats(*h, -1)) / 2) / 2 * ats(*h, 0) * time_step / grid_step
+ )
+ return retval
+
+ return rhs
+
+
+def make_rhs(grid_step, time_step, axis, options, traversals):
+ indexers = traversals.indexers[traversals.n_dims]
+ apply_scalar = traversals.apply_scalar(loop=False)
+
+ formulae_rhs = tuple(
+ (
+ make_rhs_indexers(
+ ats=indexers.ats[axis],
+ grid_step=grid_step[axis],
+ time_step=time_step,
+ options=options,
+ ),
+ None,
+ None,
+ )
+ )
+
+ @numba.njit(**options.jit_flags)
+ def apply(traversals_data, momentum, h):
+ null_scalarfield, null_scalarfield_bc = traversals_data.null_scalar_field
+ null_vectorfield, null_vectorfield_bc = traversals_data.null_vector_field
+ return apply_scalar(
+ *formulae_rhs,
+ *momentum.field,
+ *null_vectorfield,
+ null_vectorfield_bc,
+ *h.field,
+ h.bc,
+ *null_scalarfield,
+ null_scalarfield_bc,
+ *null_scalarfield,
+ null_scalarfield_bc,
+ *null_scalarfield,
+ null_scalarfield_bc,
+ traversals_data.buffer
+ )
+
+ return apply
+
+
+def make_interpolate_indexers(ati, options):
+ @numba.njit(**options.jit_flags)
+ def interpolate(momentum_x, _, momentum_y):
+ momenta = (momentum_x[ARG_FOCUS], (momentum_x[ARG_DATA], momentum_y[ARG_DATA]))
+ return ati(*momenta, 0.5)
+
+ return interpolate
+
+
+def make_interpolate(options, traversals):
+ indexers = traversals.indexers[traversals.n_dims]
+ apply_vector = traversals.apply_vector()
+
+ formulae_interpolate = tuple(
+ (
+ make_interpolate_indexers(ati=indexers.ati[i], options=options)
+ if indexers.ati[i] is not None
+ else None
+ )
+ for i in range(MAX_DIM_NUM)
+ )
+
+ @numba.njit(**options.jit_flags)
+ def apply(traversals_data, momentum_x, momentum_y, advector):
+ null_vectorfield, null_vectorfield_bc = traversals_data.null_vector_field
+ return apply_vector(
+ *formulae_interpolate,
+ *advector.field,
+ *momentum_x.field,
+ momentum_x.bc,
+ *null_vectorfield,
+ null_vectorfield_bc,
+ *momentum_y.field,
+ momentum_y.bc,
+ traversals_data.buffer
+ )
+
+ return apply
diff --git a/examples/PyMPDATA_examples/Jarecka_et_al_2015/settings.py b/examples/PyMPDATA_examples/Jarecka_et_al_2015/settings.py
index 2acfbecb..050880f6 100644
--- a/examples/PyMPDATA_examples/Jarecka_et_al_2015/settings.py
+++ b/examples/PyMPDATA_examples/Jarecka_et_al_2015/settings.py
@@ -14,7 +14,9 @@ def __init__(self):
self.eps = 1e-7
self.lx0 = 2
self.ly0 = 1
- self.options = Options(nonoscillatory=True, infinite_gauge=True)
+ self.options = Options(
+ nonoscillatory=True, infinite_gauge=True, dynamic_advector=True
+ )
@property
def nt(self):
diff --git a/examples/PyMPDATA_examples/Jarecka_et_al_2015/simulation.py b/examples/PyMPDATA_examples/Jarecka_et_al_2015/simulation.py
index ff9b44bc..4c2043f9 100644
--- a/examples/PyMPDATA_examples/Jarecka_et_al_2015/simulation.py
+++ b/examples/PyMPDATA_examples/Jarecka_et_al_2015/simulation.py
@@ -1,11 +1,72 @@
+import numba
import numpy as np
from PyMPDATA_examples.Jarecka_et_al_2015 import formulae
from PyMPDATA import ScalarField, Solver, Stepper, VectorField
from PyMPDATA.boundary_conditions import Constant
+from PyMPDATA.impl.enumerations import INNER, OUTER
+from PyMPDATA.impl.formulae_divide import make_divide_or_zero
+
+
+def make_hooks(*, traversals, options, grid_step, time_step):
+
+ divide_or_zero = make_divide_or_zero(options, traversals)
+ interpolate = formulae.make_interpolate(options, traversals)
+ rhs_x = formulae.make_rhs(grid_step, time_step, OUTER, options, traversals)
+ rhs_y = formulae.make_rhs(grid_step, time_step, INNER, options, traversals)
+
+ @numba.experimental.jitclass([])
+ class AnteStep: # pylint:disable=too-few-public-methods
+ def __init__(self):
+ pass
+
+ def call(
+ self,
+ traversals_data,
+ advectees,
+ advector,
+ _,
+ index,
+ todo_outer,
+ todo_mid3d,
+ todo_inner,
+ ):
+ if index == 0:
+ divide_or_zero(
+ *todo_outer.field,
+ *todo_mid3d.field,
+ *todo_inner.field,
+ *advectees[1].field,
+ *todo_mid3d.field,
+ *advectees[2].field,
+ *advectees[0].field,
+ time_step,
+ grid_step
+ )
+ interpolate(traversals_data, todo_outer, todo_inner, advector)
+ elif index == 1:
+ rhs_x(traversals_data, advectees[index], advectees[0])
+ else:
+ rhs_y(traversals_data, advectees[index], advectees[0])
+
+ @numba.experimental.jitclass([])
+ class PostStep: # pylint:disable=too-few-public-methods
+ def __init__(self):
+ pass
+
+ def call(self, traversals_data, advectees, _, index):
+ if index == 0:
+ pass
+ if index == 1:
+ rhs_x(traversals_data, advectees[index], advectees[0])
+ else:
+ rhs_y(traversals_data, advectees[index], advectees[0])
+
+ return AnteStep(), PostStep()
class Simulation:
+ # pylint: disable=too-few-public-methods
def __init__(self, settings):
self.settings = settings
s = settings
@@ -25,52 +86,36 @@ def __init__(self, settings):
y = yi * s.dy
h0 = formulae.amplitude(x, y, s.lx0, s.ly0)
- advectees = {
+ self.advectees = {
"h": ScalarField(h0, halo, bcs),
"uh": ScalarField(np.zeros(grid), halo, bcs),
"vh": ScalarField(np.zeros(grid), halo, bcs),
}
stepper = Stepper(options=s.options, grid=grid)
- self.solvers = {
- k: Solver(stepper, v, self.advector) for k, v in advectees.items()
- }
- @staticmethod
- def interpolate(psi, axis):
- idx = (
- (slice(None, -1), slice(None, None)),
- (slice(None, None), slice(None, -1)),
+ self.ante_step, self.post_step = make_hooks(
+ traversals=stepper.traversals,
+ options=settings.options,
+ grid_step=(s.dx, None, s.dy),
+ time_step=s.dt,
)
- return np.diff(psi, axis=axis) / 2 + psi[idx[axis]]
+
+ self.solver = Solver(stepper, self.advectees, self.advector)
def run(self):
s = self.settings
- grid_step = (s.dx, s.dy)
- idx = ((slice(1, -1), slice(None, None)), (slice(None, None), slice(1, -1)))
output = []
for it in range(s.nt + 1):
if it != 0:
- h = self.solvers["h"].advectee.get()
- for xy, k in enumerate(("uh", "vh")):
- mask = h > s.eps
- vel = np.where(mask, np.nan, 0)
- np.divide(self.solvers[k].advectee.get(), h, where=mask, out=vel)
- self.advector.get_component(xy)[idx[xy]] = (
- self.interpolate(vel, axis=xy) * s.dt / grid_step[xy]
- )
- self.solvers["h"].advance(1)
- assert h.ctypes.data == self.solvers["h"].advectee.get().ctypes.data
- for xy, k in enumerate(("uh", "vh")):
- psi = self.solvers[k].advectee.get()
- psi[:] -= s.dt / 2 * h * np.gradient(h, grid_step[xy], axis=xy)
- self.solvers[k].advance(1)
- psi[:] -= s.dt / 2 * h * np.gradient(h, grid_step[xy], axis=xy)
+ self.solver.advance(
+ 1, ante_step=self.ante_step, post_step=self.post_step
+ )
if it % s.outfreq == 0:
output.append(
{
- k: self.solvers[k].advectee.get().copy()
- for k in self.solvers.keys()
+ k: self.solver.advectee[k].get().copy()
+ for k in self.advectees.keys() # pylint:disable=consider-iterating-dictionary
}
)
return output
diff --git a/examples/PyMPDATA_examples/Jaruga_et_al_2015/fig19.ipynb b/examples/PyMPDATA_examples/Jaruga_et_al_2015/fig19.ipynb
index 25c62e85..0c668e1b 100644
--- a/examples/PyMPDATA_examples/Jaruga_et_al_2015/fig19.ipynb
+++ b/examples/PyMPDATA_examples/Jaruga_et_al_2015/fig19.ipynb
@@ -252,6 +252,7 @@
")\n",
"\n",
"from PyMPDATA import solver\n",
+ "MPDATA_ANTE_STEP = solver.AnteStepNull()\n",
"MPDATA_POST_STEP = solver.PostStepNull() \n",
"MPDATA_POST_ITER = solver.PostIterNull()\n",
"\n",
@@ -261,12 +262,16 @@
" solvers[k]._Solver__stepper.traversals.data for k in (_U, _W, _T)#pylint: disable=protected-access\n",
")\n",
"\n",
- "MPDATA_FIELDS = tuple(\n",
- " tuple(\n",
- " _Impl(field=v.impl[IMPL_META_AND_DATA], bc=v.impl[IMPL_BC])#pylint: disable=protected-access\n",
+ "MPDATA_FIELDS = [\n",
+ " [\n",
+ " _Impl(field=(vv:=v[0] if isinstance(v, tuple) else v).impl[IMPL_META_AND_DATA], bc=vv.impl[IMPL_BC])#pylint: disable=protected-access\n",
" for v in solvers[k]._Solver__fields.values()#pylint: disable=protected-access\n",
- " ) for k in (_U, _W, _T)\n",
- ")"
+ " ] for k in (_U, _W, _T)\n",
+ "]\n",
+ "for k in (_U, _W, _T):\n",
+ " MPDATA_FIELDS[k][0] = (MPDATA_FIELDS[k][0],) \n",
+ " MPDATA_FIELDS[k] = tuple(MPDATA_FIELDS[k])\n",
+ "MPDATA_FIELDS = tuple(MPDATA_FIELDS)"
]
},
{
@@ -446,7 +451,7 @@
" ARRAYS.vip_rhs[k][:] /= 0.5 * SETUP.dt\n",
"\n",
"@jit(**OPTIONS.jit_flags)\n",
- "def mpdata_advance(steppers, post_step, post_iter, fields, traversals_data):\n",
+ "def mpdata_advance(steppers, ante_step, post_step, post_iter, fields, traversals_data):\n",
" n_steps = 1\n",
" mu_coeff = (0,0,0)\n",
" wall_time = 0\n",
@@ -454,6 +459,7 @@
" wall_time += steppers[k](\n",
" n_steps, \n",
" mu_coeff, \n",
+ " ante_step,\n",
" post_step,\n",
" post_iter,\n",
" *fields[k],\n",
@@ -462,7 +468,7 @@
" return wall_time\n",
"\n",
"@jit(**OPTIONS.jit_flags)\n",
- "def advance(amount,ARRAYS,ADVECTOR_DATA, ADVECTEE_DATA,MPDATA_STEPPERS, MPDATA_POST_STEP, \n",
+ "def advance(amount,ARRAYS,ADVECTOR_DATA, ADVECTEE_DATA,MPDATA_STEPPERS, MPDATA_ANTE_STEP, MPDATA_POST_STEP, \n",
" MPDATA_POST_ITER, MPDATA_FIELDS, MPDATA_TRAVERSALS_DATA,output):\n",
" times = np.zeros(SETUP.nt)\n",
" t0 = clock()\n",
@@ -474,7 +480,7 @@
" fill_stash(ARRAYS, ADVECTEE_DATA)\n",
" apply_half_rhs(ARRAYS, ADVECTEE_DATA)\n",
" vip_rhs_apply(ARRAYS, ADVECTEE_DATA)\n",
- " mpdata_advance(MPDATA_STEPPERS, MPDATA_POST_STEP, MPDATA_POST_ITER, MPDATA_FIELDS,\n",
+ " mpdata_advance(MPDATA_STEPPERS, MPDATA_ANTE_STEP, MPDATA_POST_STEP, MPDATA_POST_ITER, MPDATA_FIELDS,\n",
" MPDATA_TRAVERSALS_DATA)\n",
" update_rhs(ARRAYS, ADVECTEE_DATA)\n",
" apply_half_rhs(ARRAYS, ADVECTEE_DATA)\n",
@@ -505,7 +511,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "np.min(times)=995300.0 np.mean(times)=21259795315.5 np.max(times)=48717086800.0\n"
+ "np.min(times)=np.float64(37424.0) np.mean(times)=np.float64(24427831425.1425) np.max(times)=np.float64(56895706287.0)\n"
]
}
],
@@ -513,7 +519,7 @@
"with warnings.catch_warnings():\n",
" warnings.simplefilter(action=\"ignore\",category=NumbaExperimentalFeatureWarning)\n",
" output = np.empty((SETUP.nt//SETUP.outfreq+1, *SETUP.grid))\n",
- " times = advance(SETUP.nt,ARRAYS,ADVECTOR_DATA, ADVECTEE_DATA,MPDATA_STEPPERS, MPDATA_POST_STEP, \n",
+ " times = advance(SETUP.nt,ARRAYS,ADVECTOR_DATA, ADVECTEE_DATA, MPDATA_STEPPERS, MPDATA_ANTE_STEP, MPDATA_POST_STEP, \n",
" MPDATA_POST_ITER, MPDATA_FIELDS, MPDATA_TRAVERSALS_DATA,output)\n",
"\n",
"print(f\"{np.min(times)=} {np.mean(times)=} {np.max(times)=}\")\n",
@@ -538,7 +544,7 @@
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "63a7dcf8718b4334a39ba45028562a73",
+ "model_id": "abb0767e1ee04a718c2425ccd483403c",
"version_major": 2,
"version_minor": 0
},
@@ -552,7 +558,7 @@
{
"data": {
"text/html": [
- "
"
+ "
"
],
"text/plain": [
""
@@ -564,12 +570,12 @@
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "933b2b6d83f04054814642575580975c",
+ "model_id": "234bebf8777a473094a45078bb6233e4",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
- "HTML(value=\".\\\\boussinesq_2d_anim.gif
\")"
+ "HTML(value=\"./boussinesq_2d_anim.gif
\")"
]
},
"metadata": {},
@@ -616,7 +622,7 @@
"outputs": [
{
"data": {
- "image/png": "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",
+ "image/png": "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",
"text/plain": [
""
]
@@ -627,12 +633,12 @@
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "b2d3ad2a6cf5463ea5e1ac25b92f3e6f",
+ "model_id": "a1d19fb849984af09afe7b43ab84a48c",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
- "HBox(children=(HTML(value=\".\\\\tmpwol4nt8x.pdf
\"), HTML(val…"
+ "HBox(children=(HTML(value=\"./tmp_wgsjb_d.pdf
\"), HTML(value…"
]
},
"metadata": {},
@@ -651,7 +657,7 @@
"outputs": [
{
"data": {
- "image/png": "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",
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkoAAAHWCAYAAACIb6Y8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAfQpJREFUeJzt3Xd4VMX+x/H37qYH0klCqKH3IoHQlBYITUH4qXhRERUscAVjxavYRREBC4p4pegFRewiohiaaOgdKdJrOiGkJ7vn98fKwposEloCfF7Ps4/snDlzvmeQ8GXOnBmTYRgGIiIiIlKMuawDEBERESmvlCiJiIiIuKBESURERMQFJUoiIiIiLihREhEREXFBiZKIiIiIC0qURERERFxQoiQiIiLighIlEREREReUKIlcoWbOnInJZGL//v1lHYqIyFVLiZJIGfj99995/vnnycjIKPH4O++8g7+/P4WFhaVq97333mPmzJkXHuBf1qxZw8iRI2ncuDG+vr5Ur16dW2+9lV27dpVYf/v27fTs2ZMKFSoQFBTEnXfeSUpKSrF6NpuN8ePHExkZiZeXF82aNePTTz+9aHGLiFwsSpREysDvv//OCy+84DJR+uGHH+jRowfu7u6lavdiJ0qvv/46X375Jd26deOtt95i+PDhLF++nOuuu46tW7c61T18+DA33HADu3fv5tVXX+Wxxx7jhx9+oHv37hQUFDjV/c9//sOTTz5J9+7deeedd6hevTr/+te/+Oyzzy5a7CIiF4NbWQcgIs5ycnJYtmwZ77//flmHQlxcHHPmzMHDw8NRdtttt9G0aVNee+01/ve//znKX331VbKzs1m3bh3Vq1cHoE2bNnTv3p2ZM2cyfPhwAI4cOcKbb77JiBEjePfddwG477776NSpE48//ji33HILFovlMt6liIhrGlESucyef/55Hn/8cQAiIyMxmUxOc43i4+PJz8+nV69ejnO2bdtG165d8fb2pmrVqrz88svYbDandmvWrMm2bdtYtmyZo83OnTtfUKzt27d3SpIA6tatS+PGjdm+fbtT+Zdffknfvn0dSRJATEwM9erV4/PPP3eUffvttxQWFvLQQw85ykwmEw8++CCHDx8mISHhgmIWEbmYNKIkcpkNGDCAXbt28emnnzJp0iRCQkIAqFSpEgALFiygVatWhIWFAZCYmEiXLl0oKiriqaeewtfXl2nTpuHt7e3U7uTJk/n3v/9NhQoV+M9//gPgaMNms5Genn5O8fn7+5/1kZ9hGCQlJdG4cWNH2ZEjR0hOTiYqKqpY/TZt2rBgwQLH9w0bNuDr60vDhg2L1Tt1vGPHjucUq4jIpaZESeQya9asGddddx2ffvop/fv3p2bNmk7HFyxYwNChQx3fX3/9dVJSUli1apUjmRgyZAh169Z1Oq9///4888wzhISEcMcddzgdO3jwIJGRkecU35IlS846EjV79myOHDnCiy++6Cg7duwYAJUrVy5Wv3LlyqSnp5Ofn4+npyfHjh0jLCwMk8lUrB7A0aNHzylOEZHLQYmSSDmydetWDh48SJ8+fRxlCxYsoG3bto4kCeyjT4MHD+a99947p3bDw8NZtGjROdVt3ry5y2M7duxgxIgRtGvXjiFDhjjKc3NzAfD09Cx2jpeXl6OOp6en479nqyciUl4oURIpR3744QfCwsKcHmEdOHCA6OjoYnXr169/zu16eXkRExNzQbElJibSp08f/P39+eKLL5wmXJ96DJifn1/svLy8PKc63t7e51RPRKQ8UKIkUo4sWLCAnj17FnssdaGsVmuJ6xmVJCgoqNgE7hMnTtCrVy8yMjL49ddfiYiIcDp+6rHZqUdwZzp27BhBQUGOUaTKlSuzZMkSDMNwus9T5/69bRGRsqS33kTKQEmJUEZGBr///rvTYzeAGjVq8Oeffxarv3PnznNqF+DQoUNUrlz5nD6///6707l5eXnceOON7Nq1i/nz59OoUaNi7VepUoVKlSqxdu3aYsdWr15NixYtHN9btGhBTk5OsbfmVq1a5TguIlJeaERJpAz4+voCOC04+fPPPwPQo0cPp7q9e/dm8uTJrF692jFPKSUlhdmzZ5fYbkmLWJ7vHCWr1cptt91GQkIC3377Le3atXN53sCBA5k1axaHDh2iWrVqgH2pg127dvHII4846vXr149HHnmE9957z7GOkmEYTJ06lSpVqtC+fftzilNE5HIwGYZhlHUQIteaNWvW0KZNG3r37s2gQYNwd3fnyy+/JDU1lSVLljjVPXbsGE2bNsVmszFq1Cin5QE2b97Mvn37HG/OjRgxgvfff58XX3yROnXqEBoaSteuXc87ztGjR/PWW29x4403cuuttxY7fubbdYcOHaJly5YEBAQwatQosrKyeOONN6hatSpr1qxxmsD9xBNP8MYbbzB8+HBat27NN998ww8//MDs2bP517/+dd7xiohcdIaIlImXXnrJqFKlimE2mw3ACA0NNcaPH19i3c2bNxudOnUyvLy8jCpVqhgvvfSS8dFHHxmAsW/fPke9xMREo0+fPkbFihUNwOjUqdMFxdipUycDcPn5u61btxo9evQwfHx8jICAAGPw4MFGYmJisXpWq9V49dVXjRo1ahgeHh5G48aNjf/9738XFKuIyKWgESWRcmD16tVER0ezbdu2EucAiYhI2dBkbpFy4tVXX1WSJCJSzmhESURERMQFjSiJiIiIuFCmidLy5cu58cYbiYiIwGQy8c033zgdNwyDsWPHUrlyZby9vYmJiSm2nkx6ejqDBw/Gz8+PgIAA7r33XrKysi7jXYiIiMjVqkwTpezsbJo3b86UKVNKPD5+/Hjefvttpk6dyqpVq/D19SU2Ntax1QHA4MGD2bZtG4sWLWL+/PksX76c4cOHX65bEBERkatYuZmjZDKZ+Prrr+nfvz9gH02KiIjg0Ucf5bHHHgPs2yiEhYUxc+ZMBg0axPbt22nUqBFr1qxx7I21cOFCevfuzeHDh7UVgoiIiFyQcrsy9759+0hMTHTayNPf35/o6GgSEhIYNGgQCQkJBAQEOG0gGhMTg9lsZtWqVdx8880ltp2fn++0KafNZiM9PZ3g4OCLvseWiIiUb4ZhcPLkSSIiIjCbNXVXnJXbRCkxMRGAsLAwp/KwsDDHscTEREJDQ52Ou7m5ERQU5KhTknHjxvHCCy9c5IhFRORKdujQIapWrVrWYUg5U24TpUtpzJgxxMXFOb6fOHGC6tWrs2vXLoKCgsowsitHYWEhS5YsoUuXLri7u5d1OFcE9Vnpqc9KT31Weunp6dSrV4+KFSuWdShSDpXbRCk8PByApKQkKleu7ChPSkpy7C4eHh5OcnKy03lFRUWkp6c7zi+Jp6en075TpwQFBREcHHwRor/6FRYW4uPjQ3BwsH4YnyP1Wempz0pPfXb+NPVCSlJuH8ZGRkYSHh5OfHy8oywzM5NVq1Y5djBv164dGRkZrFu3zlFn8eLF2Gw2oqOjL3vMIiIicnUp0xGlrKwsdu/e7fi+b98+Nm7cSFBQENWrV2f06NG8/PLL1K1bl8jISJ599lkiIiIcb8Y1bNiQnj17MmzYMKZOnUphYSEjR45k0KBBeuNNRERELliZJkpr166lS5cuju+n5g0NGTKEmTNn8sQTT5Cdnc3w4cPJyMigY8eOLFy4EC8vL8c5s2fPZuTIkXTr1g2z2czAgQN5++23L/u9iIiIyNWnTBOlzp07c7ZlnEwmEy+++CIvvviiyzpBQUHMmTPnUoQnIiIi17hyO0dJREREpKwpURIRERFxQYmSiIiIiAtKlERERERcUKIkIiIi4oISJREREREXlCiJiIiIuKBESURERMQFJUoiIiIiLihREhEREXFBiZKIiIiIC0qURERERFxQoiQiIiLighIlEREREReUKImIiIi4oERJRERExAUlSiIiIiIuKFESERERcUGJkoiIiIgLSpREREREXFCiJCIiIuKCEiURERERF5QoiYiIiLigRElERETEBSVKIiIiIi4oURIRERFxQYmSiIjINWzKlCnUrFkTLy8voqOjWb16tcu6M2fOxGQyOX28vLyc6tx9993F6vTs2fNS38Yl41bWAYiIiEjZmDt3LnFxcUydOpXo6GgmT55MbGwsO3fuJDQ0tMRz/Pz82Llzp+O7yWQqVqdnz57MmDHD8d3T0/PiB3+ZaERJRETkGjVx4kSGDRvG0KFDadSoEVOnTsXHx4fp06e7PMdkMhEeHu74hIWFFavj6enpVCcwMPBS3sYlpRElERGRyyQvL4+CgoJLeg3DMIqN8nh6ehYb1SkoKGDdunWMGTPGUWY2m4mJiSEhIcFl+1lZWdSoUQObzcZ1113Hq6++SuPGjZ3qLF26lNDQUAIDA+natSsvv/wywcHBF+HuLj8lSiIiIpdBXl4ekZHeJCZe2utUqFCBrKwsp7LnnnuO559/3qksNTUVq9VabEQoLCyMHTt2lNh2/fr1mT59Os2aNePEiRNMmDCB9u3bs23bNqpWrQrYH7sNGDCAyMhI9uzZw9NPP02vXr1ISEjAYrFcvBu9TJQoiYiIXAYFBQUkJsKhQ+Dnd2mukZkJ1aplcejQIfzOuMjFmiPUrl072rVr5/jevn17GjZsyAcffMBLL70EwKBBgxzHmzZtSrNmzahduzZLly6lW7duFyWOy0mJkoiIyGXk53fpEqXT1/BzSpRKEhISgsViISkpyak8KSmJ8PDwc7qOu7s7LVu2ZPfu3S7r1KpVi5CQEHbv3n1FJkqazC0iInIN8vDwoFWrVsTHxzvKbDYb8fHxTqNGZ2O1WtmyZQuVK1d2Wefw4cOkpaWdtU55pkRJRETkGhUXF8eHH37IrFmz2L59Ow8++CDZ2dkMHToUgLvuustpsveLL77Izz//zN69e1m/fj133HEHBw4c4L777gPsE70ff/xxVq5cyf79+4mPj6dfv37UqVOH2NjYMrnHC6VHbyIiIteo2267jZSUFMaOHUtiYiItWrRg4cKFjgneBw8exGw+PaZy/Phxhg0bRmJiIoGBgbRq1Yrff/+dRo0aAWCxWNi8eTOzZs0iIyODiIgIevTowUsvvXTFrqWkRElEROQaNnLkSEaOHFnisaVLlzp9nzRpEpMmTXLZlre3Nz/99NPFDK/M6dGbiIiIiAtKlERERERcUKIkIiIi4oISJREREREXlCiJiIiIuKBESURERMQFJUoiIiIiLihREhEREXFBiZKIiIiIC0qURERERFxQoiQiIiLighIlEREREReUKImIiIi4oERJRERExAUlSiIiIiIuKFESERERcUGJkoiIiIgLSpREREREXFCiJCIiIuKCEiURERERF5QoiYiIiLigRElERETEBSVKIiIiIi4oURIRERFxQYmSiIiIiAtKlERERERcUKIkIiIi4oISJREREREXlCiJiIiIuFCuEyWr1cqzzz5LZGQk3t7e1K5dm5deegnDMBx1DMNg7NixVK5cGW9vb2JiYvjzzz/LMGoRERG5WpTrROn111/n/fff591332X79u28/vrrjB8/nnfeecdRZ/z48bz99ttMnTqVVatW4evrS2xsLHl5eWUYuYiIiFwN3Mo6gLP5/fff6devH3369AGgZs2afPrpp6xevRqwjyZNnjyZZ555hn79+gHw8ccfExYWxjfffMOgQYPKLHYRERG58pXrRKl9+/ZMmzaNXbt2Ua9ePTZt2sSKFSuYOHEiAPv27SMxMZGYmBjHOf7+/kRHR5OQkOAyUcrPzyc/P9/xPTMzE4DCwkIKCwsv4R1dPU71k/rr3KnPSk99Vnrqs9JTX8nZlOtE6amnniIzM5MGDRpgsViwWq288sorDB48GIDExEQAwsLCnM4LCwtzHCvJuHHjeOGFF4qVL1myBB8fn4t4B1e/RYsWlXUIVxz1Wempz0pPfXbucnJyyjoEKcfKdaL0+eefM3v2bObMmUPjxo3ZuHEjo0ePJiIigiFDhpx3u2PGjCEuLs7xPTMzk2rVqtGlSxeCg4MvRuhXvcLCQhYtWkT37t1xd3cv63CuCOqz0lOflZ76rPTS0tLKOgQpx8p1ovT444/z1FNPOR6hNW3alAMHDjBu3DiGDBlCeHg4AElJSVSuXNlxXlJSEi1atHDZrqenJ56ensXK3d3d9YOllNRnpac+Kz31Wempz86d+knOply/9ZaTk4PZ7ByixWLBZrMBEBkZSXh4OPHx8Y7jmZmZrFq1inbt2l3WWEVEROTqU65HlG688UZeeeUVqlevTuPGjdmwYQMTJ07knnvuAcBkMjF69Ghefvll6tatS2RkJM8++ywRERH079+/bIMXERGRK165TpTeeecdnn32WR566CGSk5OJiIjg/vvvZ+zYsY46TzzxBNnZ2QwfPpyMjAw6duzIwoUL8fLyKsPIRURE5GpQrhOlihUrMnnyZCZPnuyyjslk4sUXX+TFF1+8fIGJiIjINaFcz1ESERERKUtKlERERK5hU6ZMoWbNmnh5eREdHe3Y/eKffPbZZ5hMpmJzgu+++25MJpPTp2fPnpcg8stDiZKIiMg1au7cucTFxfHcc8+xfv16mjdvTmxsLMnJyWc9b//+/Tz22GNcf/31JR7v2bMnx44dc3w+/fTTSxH+ZaFESURE5Bo1ceJEhg0bxtChQ2nUqBFTp07Fx8eH6dOnuzzHarUyePBgXnjhBWrVqlViHU9PT8LDwx2fwMDAS3ULl5wSJRERkatMZmam0+fM/U1PKSgoYN26dU77pZrNZmJiYkhISHDZ9osvvkhoaCj33nuvyzpLly4lNDSU+vXr8+CDD17Rq5+X67feRERErjbWiXWwelkuTdt5VmA31apVcyp/7rnneP75553KUlNTsVqtJe6XumPHjhLbX7FiBR999BEbN250GUPPnj0ZMGAAkZGR7Nmzh6effppevXqRkJCAxXJp7vtSUqIkIiJylTl06BB+fn6O7yVt21VaJ0+e5M477+TDDz8kJCTEZb1T246BfeuxZs2aUbt2bZYuXUq3bt0uOI7LTYmSiIjIVcbPz88pUSpJSEgIFouFpKQkp/KkpCTHXqpn2rNnD/v37+fGG290lJ3aUszNzY2dO3dSu3btYufVqlWLkJAQdu/efUUmSpqjJCIicg3y8PCgVatWTvul2mw24uPjS9wvtUGDBmzZsoWNGzc6PjfddBNdunRh48aNxR73nXL48GHS0tKcNq+/kmhESURE5BoVFxfHkCFDiIqKok2bNkyePJns7GyGDh0KwF133UWVKlUYN24cXl5eNGnSxOn8gIAAAEd5VlYWL7zwAgMHDiQ8PJw9e/bwxBNPUKdOHWJjYy/rvV0sSpRERESuUbfddhspKSmMHTuWxMREWrRowcKFCx0TvA8ePIjZfO4PnywWC5s3b2bWrFlkZGQQERFBjx49eOmlly7KPKmyoERJRETkGjZy5EhGjhxZ4rGlS5ee9dyZM2c6fff29uann366SJGVD5qjJCIiIuKCEiURERERF5QoiYiIiLigRElERETEBSVKIiIiIi4oURIRERFxQYmSiIiIiAtKlERERERcUKIkIiIi4oISJREREREXlCiJiIiIuKBESURERMQFJUoiIiIiLihREhEREXFBiZKIiIiIC0qURERERFxQoiQiIiLighIlEREREReUKImIiIi4oERJRERExAUlSiIiIiIuKFESERERcUGJkoiIiIgLSpREREREXFCiJCIiIuKCEiURERERF5QoiYiIiLigRElERETEBSVKIiIiIi4oURIRERFxQYmSiIiIiAtKlERERERcUKIkIiIi4oISJREREREXlCiJiIiIuKBESURERMQFJUoiIiIiLihREhEREXFBiZKIiIiIC0qURERERFxQoiQiIiLighIlERGRa9iUKVOoWbMmXl5eREdHs3r1apd1v/rqK6KioggICMDX15cWLVrwySefONW5++67MZlMTp+ePXte6tu4ZNzKOgAREREpG3PnziUuLo6pU6cSHR3N5MmTiY2NZefOnYSGhharHxQUxH/+8x8aNGiAh4cH8+fPZ+jQoYSGhhIbG+uo17NnT2bMmOH47unpeVnu51LQiJKIiMg1auLEiQwbNoyhQ4fSqFEjpk6dio+PD9OnTy+xfufOnbn55ptp2LAhtWvXZtSoUTRr1owVK1Y41fP09CQ8PNzxCQwMvBy3c0koURIREbnKZGZmOn3y8/OL1SkoKGDdunXExMQ4ysxmMzExMSQkJPzjNQzDID4+np07d3LDDTc4HVu6dCmhoaHUr1+fBx98kLS0tAu/qTKiR28iIiKXUVyX3XhUuDRtF2QBL0C1atWcyp977jmef/55p7LU1FSsVithYWFO5WFhYezYscPlNU6cOEGVKlXIz8/HYrHw3nvv0b17d8fxnj17MmDAACIjI9mzZw9PP/00vXr1IiEhAYvFcsH3eLkpURIREbnKHDp0CD8/P8f3izlHqGLFimzcuJGsrCzi4+OJi4ujVq1adO7cGYBBgwY56jZt2pRmzZpRu3Ztli5dSrdu3S5aHJeLEiUREZGrjJ+fn1OiVJKQkBAsFgtJSUlO5UlJSYSHh7s8z2w2U6dOHQBatGjB9u3bGTdunCNR+rtatWoREhLC7t27r8hESXOURERErkEeHh60atWK+Ph4R5nNZiM+Pp527dqdczs2m63EOVCnHD58mLS0NCpXrnxB8ZYVjSiJiIhco+Li4hgyZAhRUVG0adOGyZMnk52dzdChQwG46667qFKlCuPGjQNg3LhxREVFUbt2bfLz81mwYAGffPIJ77//PgBZWVm88MILDBw4kPDwcPbs2cMTTzxBnTp1nJYPuJIoURIREblG3XbbbaSkpDB27FgSExNp0aIFCxcudEzwPnjwIGbz6YdP2dnZPPTQQxw+fBhvb28aNGjA//73P2677TYALBYLmzdvZtasWWRkZBAREUGPHj146aWXrti1lJQoiYiIXMNGjhzJyJEjSzy2dOlSp+8vv/wyL7/8ssu2vL29+emnny5meGVOc5REREREXFCiJCIiIuJCuU+Ujhw5wh133EFwcDDe3t40bdqUtWvXOo4bhsHYsWOpXLky3t7exMTE8Oeff5ZhxCIiInK1KNeJ0vHjx+nQoQPu7u78+OOP/PHHH7z55ptOe8aMHz+et99+m6lTp7Jq1Sp8fX2JjY0lLy+vDCMXERGRq0G5nsz9+uuvU61aNacdiCMjIx2/NgyDyZMn88wzz9CvXz8APv74Y8LCwvjmm2+cVgcVERERKa1ynSh99913xMbGcsstt7Bs2TKqVKnCQw89xLBhwwDYt28fiYmJThv6+fv7Ex0dTUJCgstEKT8/32lxrMzMTAAKCwspLCy8hHd09TjVT+qvc6c+Kz31Wempz0pPfSVnU64Tpb179/L+++8TFxfH008/zZo1a3j44Yfx8PBgyJAhJCYmApS4od+pYyUZN24cL7zwQrHyJUuW4OPjc3Fv4iq3aNGisg7hiqM+Kz31Wempz85dTk5OWYcg5Vi5TpRsNhtRUVG8+uqrALRs2ZKtW7cydepUhgwZct7tjhkzhri4OMf3zMxMqlWrRpcuXQgODr7guK8FhYWFLFq0iO7du+Pu7l7W4VwR1Gelpz4rPfVZ6aWlpZV1CFKOletEqXLlyjRq1MiprGHDhnz55ZcAjk37kpKSnPaQSUpKokWLFi7b9fT0LHGFUHd3d/1gKSX1Wempz0pPfVZ66rNzp36SsynXb7116NCBnTt3OpXt2rWLGjVqAPaJ3eHh4U4b+mVmZrJq1apSbegnIiIiUpJyPaL0yCOP0L59e1599VVuvfVWVq9ezbRp05g2bRoAJpOJ0aNH8/LLL1O3bl0iIyN59tlniYiIoH///mUbvIiIiFzxynWi1Lp1a77++mvGjBnDiy++SGRkJJMnT2bw4MGOOk888QTZ2dkMHz6cjIwMOnbsyMKFC/Hy8irDyEVERORS+u6770p9Tvfu3fH29i7VOeU6UQLo27cvffv2dXncZDLx4osv8uKLL17GqERERKQslfbJkclk4s8//6RWrVqlOq9cz1ESERERcSUxMRGbzXZOn/Nd/keJkoiIiFxxhgwZUqrHaHfccQd+fn6lvk65f/QmIiIi8ndnbm92NllZWVSoUIH333//vK6jESURERG5Ik2aNOmsx0+ePElsbOwFXUOJkoiIiFyRnn76aT7++OMSj2VnZ9OzZ88LXnldiZKIiIhckT755BPuv//+YksFZGdnExsbS0pKCkuWLLmga2iOkoiIiFyR/u///o+MjAxuv/12fvjhBzp37uwYSUpKSmLZsmVOW5ydDyVKIiIicsW67777SE9Pp1+/fnz77beMHTuWo0ePsmzZMiIiIi64fSVKIiIickV74oknSE9Pp1u3btSsWZOlS5dStWrVi9K2EiURERG5Ig0YMMDpu7u7OyEhIYwaNcqp/KuvvjrvayhREhERkSuSv7+/0/fbb7/9ol9DiZKIiIhckc510ckLoeUBRERE5IqzefNmbDbbOdfftm0bRUVFpb6OEiURERG54rRs2bJUi0m2a9eOgwcPlvo6evQmIiIiVxzDMHj22Wfx8fE5p/oFBQXndR0lSiIiInLFueGGG9i5c+c512/Xrh3e3t6lvo4SJREREbniLF269LJcR3OURERERFxQoiQiIiLiQqkTpRkzZpCTk3MpYhEREREpV0qdKD311FOEh4dz77338vvvv1+KmERERETKhVInSkeOHGHWrFmkpqbSuXNnGjRowOuvv05iYuKliE9ERETknIwbN+6it1nqRMnNzY2bb76Zb7/9lkOHDjFs2DBmz55N9erVuemmm/j2229LtVKmiIiIyMXwxRdfANCxY8eL1uYFTeYOCwujY8eOtGvXDrPZzJYtWxgyZAi1a9e+bK/tiYiIiABERUXRq1cvDh48yFdffcWuXbswDOOC2jyvRCkpKYkJEybQuHFjOnfuTGZmJvPnz2ffvn0cOXKEW2+9lSFDhlxQYCIiIiKl8cEHH/D6669js9lYuXIlDz/8MHXq1CEqKoq77777vNos9YKTN954Iz/99BP16tVj2LBh3HXXXQQFBTmO+/r68uijj/LGG2+cV0AiIiIi56tZs2Z8+umnLF++nG7durFw4ULS0tLYsmXLebVX6hGl0NBQli1bxtatWxk9erRTknRKpUqV2Ldv33kFJCIiInIhnn32WUJCQpg5cyYAR48eZeHChefVVqkTpY8++oh27dqdtY7JZKJGjRrnFZCIiIjIhcjOzub+++/Hw8MDgKZNm/LTTz+dV1vn9Ojt7bffPucGH3744fMKRERERC6/KVOm8MYbb5CYmEjz5s155513aNOmTYl1P/zwQz7++GO2bt0KQKtWrXj11Ved6t99993MmjXL6bzY2NjzHtE5H2FhYRw9ehSTyeQoy8vLO6+2zilRmjRpktP3lJQUcnJyCAgIACAjIwMfHx9CQ0OVKImIiFwh5s6dS1xcHFOnTiU6OprJkycTGxvLzp07CQ0NLVZ/6dKl3H777bRv3x4vLy9ef/11evTowbZt26hSpYqjXs+ePZkxY4bju6en52W5n1MmT57M3XffTXJyMnPnzmXhwoU0aNDgvNo6p0dv+/btc3xeeeUVWrRowfbt20lPTyc9PZ3t27dz3XXX8dJLL51XECIiInLxZGZmOn3y8/NLrDdx4kSGDRvG0KFDadSoEVOnTsXHx4fp06eXWH/27Nk89NBDtGjRggYNGvDf//4Xm81GfHy8Uz1PT0/Cw8Mdn8DAwIt+j67YbDaWL1/O/PnzmThxIlu3biUqKorZs2efV3ulfuvt2Wef5YsvvqB+/fqOsvr16zNp0iT+7//+j8GDB59XICIiIteCmZwA/C5R65mAP9WqVXMqfe6553j++eedygoKCli3bh1jxoxxlJnNZmJiYkhISDinq+Xk5FBYWFjsxa6lS5cSGhpKYGAgXbt25eWXXyY4OPi87qi0zGYzH3zwAffccw+33nort9566wW1V+pE6dixYxQVFRUrt1qtJCUlXVAwIiIicuEOHTqEn9/pZKykR1+pqalYrVbCwsKcysPCwtixY8c5XefJJ58kIiKCmJgYR1nPnj0ZMGAAkZGR7Nmzh6effppevXqRkJCAxWI5zzsqnaioKN59911Gjhx5wW2VOlHq1q0b999/P//973+57rrrAFi3bh0PPvigU0eJiIhI2fDz83NKlC6F1157jc8++4ylS5fi5eXlKB80aJDj102bNqVZs2aOHTu6det2SWM65fDhw/z4449MmDCB9u3b07RpU5o2bUrfvn1L3VaplweYPn064eHhREVF4enpiaenJ23atCEsLIz//ve/pQ5ARERELr+QkBAsFkuxp0FJSUmEh4ef9dwJEybw2muv8fPPP9OsWbOz1q1VqxYhISHs3r37gmM+V99++y179+5l69atjBo1ikqVKvHLL7+cV1ulHlGqVKkSCxYsYNeuXY6huQYNGlCvXr3zCkBEREQuPw8PD1q1akV8fDz9+/cHcEzMPtsjq/Hjx/PKK6/w008/ERUV9Y/XOXz4MGlpaVSuXPlihX7OKlSoQHR0NNHR0efdxjknStdffz39+vXjpptuol69eo6PiIiIXJni4uIYMmQIUVFRtGnThsmTJ5Odnc3QoUMBuOuuu6hSpQrjxo0D4PXXX2fs2LHMmTOHmjVrkpiYCNgTkgoVKpCVlcULL7zAwIEDCQ8PZ8+ePTzxxBPUqVOH2NjYixr7yZMnef7551mwYAGpqan4+/tTr149OnTowMCBA897OYC/O+dHb8OGDSMhIYFWrVrRsGFDnnzySX777bcL3pVXREREysZtt93GhAkTGDt2LC1atGDjxo0sXLjQMcH74MGDHDt2zFH//fffp6CggP/7v/+jcuXKjs+ECRMAsFgsbN682TGocu+999KqVSt+/fXXi76W0l133cW8efP417/+xSuvvMK///1vFi9ezCeffELjxo3p168fR44cueDrnPOI0l133cVdd91Ffn4+v/zyC9999x233HILVquVPn36cNNNNxEbG4u3t/cFByUiIiKXx8iRI10+alu6dKnT9/3795+1LW9v7/PeKqS0fv75Z1asWEHLli0dZc888wwLFizAYrHwyiuv0KZNG1asWEFkZOR5X6fUk7k9PT3p06cPH3zwAUePHuW7776jcuXKPPvsswQHB9O3b19+++238w5IRERE5J+EhYWRk5NT4rEaNWowbdo0HnzwQUaNGnVB1yl1ojRkyBCWL1/u+B4dHc0rr7zCli1b2LJlC926dXMaphMRERG52EaOHMk999zDpk2bXNa54447WLx48QVdp9RvvZ04cYKYmBhq1KjB0KFDGTJkiGN/l9q1a/PII49cUEAiIiIi/yQuLo6jR49y3XXX0b17d/r374/NZnPaCPezzz4jJCTkgq5T6hGlb775hiNHjvDggw8yd+5catasSa9evZg3bx6FhYUXFIyIiIjIuZowYQK///47FStW5NFHHyU3N5fmzZtTq1YtgoODeemll3jjjTcu6BqlHlEC+1pKcXFxxMXFsX79embMmMFdd91FhQoVGDx4MCNGjKBu3boXFJiIiIjIP4mOjmbevHkUFBSwfv16du3aRWZmJiEhIXTt2pXQ0NALav+8EqVTjh07xqJFi1i0aBEWi4XevXuzdetWGjVqxPjx4/UYTkRERC4LDw8P2rZtS9u2bS9qu6V+9FZYWMiXX35J3759qVGjBvPmzWP06NEcPXqUWbNm8csvv/D555/z4osvXtRARURERC63Uo8oVa5cGZvNxu23387q1atp0aJFsTpdunQhICDgIoQnIiIiUnZKnShNmjSJW265xWmn4L8LCAhg3759FxSYiIiISGnt2rWLWrVq4eZ2QbOLHEr96O3OO+88a5IkIiIiUlYaNmzI3r17L1p7pU6URERERMqri70HrRIlEREREReUKImIiIi4oERJRERExAUlSiIiIiIuKFESERERcUGJkoiIiIgLSpRERETkqvHkk08SHBx80dq7OMtWioiIiJQD48aNu6jtaURJRERExAUlSiIiIiIuKFESERERcUGJkoiIiFxxTp48yaOPPkrDhg2pVKkSderUoXfv3rzyyivs2LHjol1Hk7lFRETkinPXXXexbt06hg0bRlhYGLm5uTz55JPs3buXsWPH0rdvX95//30iIiIu6DpKlEREROSK8/PPP7NixQpatmzpKHvmmWdYsGABFouFV155hdatW7NixQoiIyPP+zp69CYiIiJXnLCwMHJycko8VqNGDaZNm8aDDz7IqFGjLug6SpRERETkijNy5EjuueceNm3a5LLOHXfcweLFiy/oOlfUo7fXXnuNMWPGMGrUKCZPngxAXl4ejz76KJ999hn5+fnExsby3nvvERYWVrbBilxk06KmOX0fvnZ4GUXyz66kWEXkyhQXF8fRo0e57rrr6N69O/3798dms2EymRx1PvvsM0JCQi7oOldMorRmzRo++OADmjVr5lT+yCOP8MMPPzBv3jz8/f0ZOXIkAwYM4LfffiujSEUunuTkZH777TeysrJYlrIMq2Gltm9tavjWKOvQzirPmsfylOW4m93xMHsQ8HkADRs2pGnTpmUdmohcRSZMmMAtt9zChAkTePTRR8nNzaV58+aEhIRw4sQJ8vLymDlz5gVd44pIlLKyshg8eDAffvghL7/8sqP8xIkTfPTRR8yZM4euXbsCMGPGDBo2bMjKlStp27ZtWYUsckHWrVvHkiVLqFSpEjExMVSsWJGsyVlYTBYWJS0iyCOorEN0yTAM4pPjiQmNwd3sTqGtkM6dO7Nx40YWLlxI7dq1uemmm3BzuyJ+/IhIORcdHc28efMoKChg/fr17Nq1i8zMTEJCQujatSuhoaEX1P4V8ZNqxIgR9OnTh5iYGKdEad26dRQWFhITE+Moa9CgAdWrVychIcFlopSfn09+fr7je2ZmJgCFhYUUFhZeoru4upzqJ/XXuTuXPtu5cydfffUVbdu25eGHH3YaQnbztP9x7VqlKz8e+ZEReSOwWCyXNujzMHPmTFqHtsbL2wsACxYCAwPp0qULXbp0Yffu3UyaNIlatWpx0003nbUt/X9Weuqz0lNfXR08PDxo27btRR8kKfeJ0meffcb69etZs2ZNsWOJiYl4eHgQEBDgVB4WFkZiYqLLNseNG8cLL7xQrHzJkiX4+PhccMzXkkWLFpV1CFccV322fv160tLSiImJITc3l2+++YYff/wRNzc3zGYzNAWbzUZAQAA3N7qZf//73/Tt2/cyR392f/zxBzk5OUQMj2DJr0uoWLEiAGtHruXkyZN06tSJ8PBw6tWrx44dO3jwwQfp3bv3PyZ8+v+s9NRn587Vm1MiUM4TpUOHDjFq1CgWLVqEl5fXRWt3zJgxxMXFOb5nZmZSrVo1unTpQnBw8EW7ztWssLCQRYsW0b17d9zd3cs6nCuCqz7Lz8/nww8/pEOHDhx4/gAp61PYc3IPuzJ38eOMDzBVDHBqx/rLF5g86/HDoOoYhkGnTp0u852ULCcnhx07djBmzBj8H3kdt9EznUbEDJuNLxb8jzsmfEt0SDRBpiDq5ddjY8RGhg4dStWqVYu1qf/PSk99VnppaWllHYKUY+U6UVq3bh3Jyclcd911jjKr1cry5ct59913+emnnygoKCAjI8NpVCkpKYnw8HCX7Xp6euLp6Vms3N3dXT9YSkl9Vnpn9tn27dv54osveOCBB6hUqRJvPfkWy1KWUcOnBtcHXs/X38wATy8w/bWSh7UI2vWEX7+n21uP88477zg9ei5LGzZsoHfv3syfP5+iXndS9Om74PHXnzPDgKwT0Okm6ngl8ePBH2nq35RqPtWIGxvHzJkzCQoKYsCAASW2rf/PSk99du7UT3I25TpR6tatG1u2bHEqGzp0KA0aNODJJ5+kWrVquLu7Ex8fz8CBAwH7HI+DBw/Srl27sghZ5JzNnz+flJQUnnnmGUwmEzt37mRx8mJiQmPYlrmNlWkroftrsGszNGgJYdXsJ05/FarVYf/+/RiGUbY3cYatW7fywAMPsHDhQsjKhh63QWgVOJkBO9aDrx8c2s2mjE3EhMWw4fgG0grScHNz47777mPlypVMnDiRhx9+WBO9RaTcKNc/jSpWrEiTJk2cynx9fQkODnaU33vvvcTFxREUFISfnx///ve/adeund54k3Jr+g3TWXJkCVW9q1KvYj0+nPIh205s43jhcfxmfMfHX39HjU6QeQjePfg5fQbCpk2w/8VQCq0G1QLccD9p4onrO+Bl8WLS9En4uvmW6VpF06KmsSRxCXve3oNhGExu+Aa5q5/A292Mv5eZqLGJHDwIu9Jg7X/hfws+J6wZYIJB1dPpXKkzZpMZa6GVmyfcTOdKnanoXhGTh4nQJy/sjRURkQtRrhOlczFp0iTMZjMDBw50WnBSpDzas2cPyw4vo11gO4I8grAZNn5L/Y0QzxAifSP56QdofBts+xxqXA9BwCefwGOPgcf2QAzDYOKvxwEwm8xEBUaxInUFMWElP37bunUr+/btIzMzk8zMTCIiIujXr985xbpp0yZ+/fVXKlSogJ+fH4GBgXTu3Nlp3tEpf2T+QYOKDfgz608sJgtNPcz8X9MKhFe0/4iZtTqRtDS44w6Y/SLUioGM/WAtgPYBLVlwbAFdQ7vi7+5Pr/BeLE1ZSqBHINeFXlfsWiIil9MVlygtXbrU6buXlxdTpkxhypQpZROQyDnYsmUL3333HYWFhfSp2gcK4WjuUTZkbKBNUBvSC9LZn72fur1h66fQeBDs+g7q3QG9e8PEifCk2cBkMuHlZsJihkD3QHKsOVhMFgptxV9vXr9+PRs3bqR79+5UrFiRihUrsn79ej744AOGDx9eYsJzym+//cauXbsYMWIEOTk5ZGZmsn//fv773/8ybNiwYvWP5h4lJiyGvdl7AcguMBxJ0rfbTtLgBmjUCCZNgvr94dAK8KsKbl6wMWMj3cO6syJ1BcGewTT3b05MWAzJecn8fPRn6q+qT69evS7Ob4SISClprzeRS6ioqIg333yTAwcO8Pjjj9OyZUuKjCIWJy/mWN4xeof35mDOQXKtudSuUJtdf40obf0UasdCq1bg7w8DB8LH6+3rfVnMEFbBgrvZnbT8NJr4N2Fb5jan66alpfHLL79wzz33UK1aNQICArBYLLRu3ZoOHTrw1ltvuZzf9Msvv3Do0CGGDh2KyWTC19eXypUr065dO6pVq8aSJUuc6p88eRJPc/GXIwC2JOaTVWCjfXsICIBnn4XdC6BSIyjIhuxkaOTXiPjkeDpV6kSwRzALEheQXpBOqFcoPav0JCIigldeeYUjR45c+G+IiEgpXXEjSiJXiuzsbAbVHUSnSp046n6UWa/OIue2HB5reYKiV98DN3daf+5HldZg2GDLLvj8AZg1C96fDGcu6dWgAezytbBsbw7VAtwxY2AzbKQVpFG3Yl02Zmx01LVarbzzzju8EDuGJ5edsE+mLiq0fyoGQkgTqOlF/vjxPP744/Y1mv7y/fffY7Vaub3uIG5fkQ3HDoCbu/3j4QWVesLcdzlYpw7VqlVznNMsoBm51ly8zF7k2fIASM+xsmBHFk90CgLs65q5ucHKt+yPEys1Al9feCZzLDU6wfQvvqVWN/iuRhHfzZ8FPhXw7nYznx5dgPtsd0Z9NIom/k14ftvzl/Y3TkTkDBpRErkE1qxZw+TJk+ke1h0/dz+OFxxn0dFFHDlyBMvdT8K6pfD1hzS5zT5P5+RRqNYB5s6FZ55xTpJO6V3fl6V7cwj0tuBuMVNoFJJrzQXA0+zpWDRv7ty53HPPPZCdCf97E/7cDId2Q8pRWDQXdm2CanUYPHgwkyZNcjy6fvfdd/H29qZ///6Qmw0fvwFpiXBkL+zZCit+gBUL4P8e5LPPPnPElZycjL+7P8cLjlPRrSJuJvu/v77edpLBLf1KfMR3551gs0FGBoQ2hT0/w3X3QdqfwBfvQ/dboXo9CmeNZ/v27ZhNZrqHdWd/9n5mz55drt72E7nSTZkyhZo1a+Ll5UV0dDSrV692WXfbtm0MHDiQmjVrYjKZHBvUn+n555/HZDI5fRo0aHAJ7+DSUqIkcpH997//JSkpif/85z+4m91ZnLyYP7P+pHNYZ7y8vLB+MgEiG0L3W9n+FeRnQkRr2P2jfdK22cWfyu/+yOLmxhXYnpxPJV8L3hZvx7F6FeuxfPlyAFJTU6levTp881+o1dieIGVn2jOTzv1h7RI4doCqVavy6KOPMmLECEaMGMHIkSOJiYmhqKgIPpkAA4bb12/Ky4H0ZCjIg91bIDcbLy8vbDYb+fn5jjXJ8qx5VHCrQJFRhAHc0dKP2RsyXfZT795gtUJuOkS0gk2zoEIY0OdO+G46bF+L220jMQyDHw7/wInCE7QPaU/r1q158cUXyc7Ovki/YyLXrrlz5xIXF8dzzz3H+vXrad68ObGxsSQnJ5dYPycnh1q1avHaa6+ddb3Cxo0bc+zYMcdnxYoVl+oWLjklSiIXiWEYvPPOO7Rp04a+ffty/PhxFhxbQKuAVniaPYlPjCcoKAhLz9vhtwWwfhlNBkHlVvDHF9D8LtdJUkYGHMgoolllL3ILDXKLDHwtvo7jYZ5h7Ny5E8MwMAzDvn1FxQDwD4Z+90BUF6hcA36dDy06wg+flLgasWEYTJgwAXrdAV9Ng4AQaBINsbfbP2YzfPMhzZo1Y/Pmzfz222906NABgDxbHt5up5M3Tzcz7Wt4s3iP64Smf3/ISYWiPGhx91+FX7wP9VtC5/5Yv53OoUOH6BLehbXH17I/ez/16tXj0UcfZfz48Y59GkXk/EycOJFhw4YxdOhQGjVqxNSpU/Hx8WH69Okl1m/dujVvvPEGgwYNKnHh5lPc3NwIDw93fEJCQi7VLVxymqMkchEYhsGkSZPImp7Fylkr+SbvG9YfX4/ff+fz2TfzqRUDFXy82PSlH++vmsjtTbwxAT8n29dImvo2nG2Xng8/hAda+/91LTiea8XH7fTzOZPJhGEY7N69m6pVq7J69WqeXzeJ7ASDKgtP/zFvFObBji8KuL6mD0OarqRneE88zB6O40uSl1CvQj2eqRzN/zWtyLLZ7zuOpedaqeBhxs1swmSaR0JCAgUFBTz88MOsZCV51jy8LPabCKtgIfFkEddH+vDGsjQ65oL36RzKyeJnYMYMsG2Em28G/5SZ/Lb2PX77Mpc2Nf051uF53nMfSqXmRaxOggdrH6dlYEsq2Sox+MPBzNo6i6CgoNL/polcxf7+j4iSdqQoKChg3bp1jBkzxlFmNpuJiYkhISHhgq7/559/EhERgZeXF+3atWPcuHH2ke4rkBIlkQtks9mYMGECAwcOJH5OPFtObOFk4Ulq+dYi4RdoMsj+WM27gpUH+/alz5717DyayTfbTnL7LXDjjWdvv6AAKlQAH6t9uMlsAh93M3nWPKyG1VGvffv2PPPMM3Tp0oWAgABsXhYejPYj2Pf0hrMLdmRRK8idn/7MpnVga1akrsDE6TlEtXxrsT5jPeN6VuS7P+wTsc+cYzR5RTpWw2D9+vWkpKRQvXp1x/EThSfwtfhiM2xE+LlxNLOI8Ipu3Nbcjx9/TMXF7iQADB0Kx4/Dp59CyJaTDGxakQ41fVhyoIiFCxcSebOF1P1F5J+ECm4V+CXpF7qGdqVneE/eeecdHnjgAcLCwkrz2yZSZiaPnuH06PxiyrXmMhocL1uc8txzz/H88887laWmpmK1Wov92QkLC2PHjh3nHUN0dDQzZ86kfv36HDt2jBdeeIHrr7+erVu3OjbKvpLo0ZvIBTAMgzfeeIPbb7+d2rVrs+H4Bqw2K9lW++OmwEjY9T3U6wv1e7uRnZ3NtIQ0tibm85+uwdSr98/XSEyEKlVOfzeZoF11b/Zk7aF2hdqON97atGnDI488QmFhITabDasBf6YVsP5IHvlFNgB6N6hARq6NDtW9WJ+xnqjAKDqGdKRjSEc6hHRg+8ntRAVG8fnmkzx2gz1JstkM9qQVMH97FmbAYrL/q7Nfv36ONZXS8tOwmCwk5ydT2bsyqdlWQivYE7SIim64mO7gJDAQHnoIagW78+qSNLYl5dMx0peBAweSst1GdgpUaQM7Tu4g0jeShYkLsZgs/Oc//2HatGmkpKSc8++byNXu0KFDnDhxwvE5c9ToUuvVqxe33HILzZo1IzY2lgULFpCRkcHnn39+2WK4mDSiJHKeDMPglmq3cF3gdfw470fWH19Pj/bfs/5oPg+39OOLLUsZ2xrqDYbvvoPU1CLWH17P0x+kERqaBxw7p+skJkJ4OPDH6TIPNxOf3tIG/jUaFn4KNepB1DQAfkv+DYD2jyWzIhc6dIBPtkF+vv3x3rBP4f33wb3TIebv/I4zBqUIawbf/fw1K96GZSvS2L7dPi0psrl9PrdPgT1RW/7KanL9c9nosZE8ax5PdyiEez+Grz6Am8bQ4I3PCPW1/3hxs5goKjr3fo16+wDNC2HJklR+3uzOzgULmDjKTKVK8NFH0LnfJlYdXk2XSu6sPvwb/42GEEK49/176RLahUc2PnLuFxO5Svn5+eHn53fWOiEhIVgsFpKSkpzK/2lj+dIKCAigXr167N69+6K1eTlpREnkPL399ts0D2hOiGcIa9PXYsbM+qP5RFX1ZNGf2cR1DOTPP+2v/N90E4wa5UaXLl0IDHS9InZJEhPhzJFxx5vxfoFwIh163g7rlnG84DgFtgJMhr19iwUiIqBjR7j/fnj4Yfuvp0+HBx+EQ79DSAOo2tb+qRINe+Oh6b9g+3ZITrafM3Ik9OljvwerFYqKwMBgX/Y+rIaVX5J+gcFx9oyqIB88PCkoMvBwK919nsndHXr0sPdZz5492bHD4OOP7SNOabk2LCbYnVZA66pe/Jj4IwCx4bEsTl6sCd4i58jDw4NWrVoRHx/vKLPZbMTHx1/UjeWzsrLYs2cPlStXvmhtXk5KlETOw9dff03Hjh0J8wpj64mteJg9OJh7kG61fcgrNHiwbQDvJGTQtq09KbmQucZRUfZFKHMK7I/PWlfz4q0V6XD9TfD5u7B9Hdw+iq0ntvLl4S8poggzZsLDoWlT57YaNYL69e1zgZrdaV8ZO+1P+yd9NzQcYC9buRIGD3Y+NzjYvsJAbi7kFOWwN3svvyT9wvWVrof8XJgxDlp3hV/nU9Hz9I+WT9afoGHD879/Nzc3+vWzMGIEvPUWRFfzJraeL2azmZ0pBTTya8SipEW4mdyIDY/l3XffPf+LiVxj4uLi+PDDD5k1axbbt2/nwQcfJDs7m6FDhwJw1113OT22KygoYOPGjWzcuJGCggKOHDnCxo0bnUaLHnvsMZYtW8b+/fv5/fffufnmm7FYLNx+++2X/f4uBiVKIqW0Z88eUlNTadWqFQeyD3Cy8CRH847Swr8FG47m8X9NK/Lmr8cZ0KQCdete+PUiImD0aBi/LJ3Ek0W0qebNoOZ+8Nlb0P8+OJ4Cn7xB3Yp1GVBlACZM5NvyOXkSatcu3l7HjlCtGuxdBNU72DffPfXJOw7H1ttHblypXBlCvUJp4d+CGyrdwPrj62HpN3Drv2HNYqgYwF2t/LHaDN5cnk6zyp5063bh/eDjA2PGwJSE4wR6W2hQyYOagW78kfkH9SrU47e03/Awe9CrVy/mzp174RcUuQbcdtttTJgwgbFjx9KiRQs2btzIwoULHRO8Dx48yLFjp6cJHD16lJYtW9KyZUuOHTvGhAkTaNmyJffdd5+jzuHDh7n99tupX78+t956K8HBwaxcuZJKlSpd9vu7GDRHSaQUUlJSePSGR+kV3otxb49jSe9XcfeFoDqw8LevWfUevP9+Cre8C7VqXbzJxX5+8NxPaUyalEbbtnD99ZD3yqdMfe99wipYuLlRBW4c8ifHNkD1jvZ5RFlZ4OoFk+uvh+eBlYtPrwJuGPZHXve/fvZYbr4ZpmycRv4J8PSHen1g1RcJLHhpDMPaBBCe4saxO3by4Ycw/EPniegXysMD/rMgjVdeSePpd2DePDB1/Y5Fv39HeAv4Mu8TGPYBmzI2sXrsat7c+ebFu7jIVWrkyJGMHDmyxGN/34i+Zs2a/7gy/pkr918NlCiJnKP8/HymTJlCbHgsebY8VqavxK8quHnB4QRoOhgWLYImTaBWrYt/fTc3ePxxWLYMXn0VBh4vZGT7QP5MLeDNFcdxvxHaPwobZ0LzIVD469nbu/56+6c0TCb73CfDal8gMyfNvlhmSpaVZ7oGk1to8M5vxwmsbN+Kxd39vG/XJQ8PGDUKJk+GJ56Adx+B2t3hwHLwqwr7svfRPKA5v6X+xrZt22jcuPHFD0JErhl69CZyjubOncv999+PxWRhZdpKrg+5nswjkJ0CdXrZ5/gcPw6dO1/aODp1sj+CWrE/l+/+OEndEA+e7ByMuy+snfrXdigL7XObLrbbboNx4+z3u3EmJG22J0w96/uyK7WQib+mc1crP4YMuTRJ0ilBQdC3L0ydCk1vh32LIbwFeAfDzpP2Fco7hHRgwYIFly4IEbkmKFESOQc2m43k5GQqV67M8YLjuJvd2ZCxgRqdoOCk/ZOxHy7XXEWTCe6O8ifCz503l6czZ0MmwXUh6gE4cRAqhJd+tOhchITAiBHwxzxoeS/U6Wmf0zTx13Q2HcvjP12D8fey/HNDF0HjxtCmDez6wf7GXlE+JG6EZn7NWJ+xHoCGDRvyxx9/nL0hEZGz0KM3kXMwf/58brzxRqxWK0+1zYVbJ0L8PN7aN4dn7oYlS2Dki5c3JstTO4kGooFjx+Dk15CWBnd0vjRJ0ikhIbDwFfsbaIGBcH8naHX/qflY57Y21MXSqhW8mgdJSbDzGPQYClF120DqUWjdDWvvGkycOJFGjRpd1rhE5OqhESWRf2AYBtu3b6d+/fp89NFHcPMw+GkOXNeJoCD44YezvyV2OVSubI/h2WcvbZJ0SkgIvPQSxMXZk5Wy1KEDHDpkn2S+fTuwezP0vRsWfILJZCI8PJzDhw+XbZAicsVSoiTyD+bOnUu/fv3Izc2loKAAPL3Bwwt+/5HbbrOvdm3Wn6Qy1b49ZGTYR5bo0Bt+WwDX92Xx4sUMGjSIWbNmlXWIInKF0o93kbNITEwkIyODBg0a8OWXXzJw4EBY8AlEx4B/MKmp9nWOpGw1bgxbt8LAgcC+7bB/B9RtzoYNG3Bzc6N37958++23ZR2miFyBNEdJ5Cw++ugjgr4K4oMPP+DnpJ85HHSYmQ3eIv3DVxnexp8Vm6FZs7KOUnx87CuG16wJr/36bwY0qcCqiZNZtroPr338GkEeQcQnxXPDDTcQGBhY1uGKyBVEI0oiLvzyyy/06NEDi8nCodxD1PCpwfrj6+nfqAJuZvByN7NnT8mrX8vlZ/pra7me9Xz5M7WQo5lFNPdvzqaMTQBcX+l6PYITkVJToiTiwh9//EHr1q0B2J+9n9oVamMxWdh7vJAm4Z6Afe8zy+V5G17OUeMwD3anFlAryJ1sazYG9lWEPcwemDWZTERKST81RM5BkVGE2WTGbDKzI6WABpU8yjokKYFhgOmvoaVmlT05nHv4r3J7slS1alUOHTpUZvGJyJVHc5RESnD8+HECAgIAuP+D4fBZHnNb3wDp9Wmz4Bcq+dqHkU497pGyFxxsX0cqEDCAyEB33h3QACJ6MbdaHahRj5Qaqfz888/861//KutwReQKoRElkRKsWrWKtm3b2r8c/BOq1oEDO6FGfUycHrWwWssuRnHm6wsnT9p/bQLMZpN9iKl1V1izGICQkBDS09PLLkgRueIoURIpwYEDB6hZs6b9y/4dULvxXxOSnAdhbTb738VS9vbts7/15sRkAk8vsBadUaRhQBE5d0qUREpQWFiIh8df85CSDkFoVfuqkoYNTzcT+UU2ABo1gh07yjBQAezJqn1+UllHIiJXG81REvmbaVHT+C35Nzxm/pUodf3r1TazGWw2qvq7cyijiDohHnTqBNOnQ8OGZRvztW7XLmjQ4PR3VwnTtKhprEhegdt0N0wmE8PXDr88AYrIFUsjSiLnqoI/ZKbTKMyDLYn5AHh6ap5SebBiBXTqZP/1yXz7qB9gfzb6N/7u/mQWZV7G6ETkSqZESeSfnBqeaBgFf6yleoA7+48XFjssZScvD7y97b/+7o+T9G1QgcSTRRAcVqxuiGcIKfkplzlCEblSKVES+Ztcay5eFq/iB3wrQm42AEE+FtKyNZRUHiVnWQmr6MbvB3KheYdix4M9gknLTyuDyETkSqQ5SiJ/k5qfSrBHsHPhqZnChsFD3XeS3xZmLYZlgJsbFBaCu3uZhCtn2L8ffuqUwp/dUtiaBoRWKVbH182XHGvOZY9NRK5MGlES+ZusoiwqulU8XeAfDCf+GoHwqUBhLnhWhKI8e5HJVOJUGLmMTvX/mjUQ3qKEClrDQUTOkxIlkb8xMDCbzvijUb2ufdFJgEoR5Pw1veXU3KT8fPukbik7p5YH8PAA49QT0TPnjv1tIpkJTSwTkXOjR28if2MYhtNfpJPfXMHGjI20C97CkdwjrB8F/tVP19dk7rIXEQGJifZEyXp6nj0f3D+N7KJstp7YSvTiaWUXoIhcsTSiJPI3BobT6s3eFm9yrbkABLgHOEaUDMM+N8lN/9wocy1bwoYN9kTJVggF2eDuYz+WnJ9MqFeoU30DPYoTkXOjREnkb6yGFYvJ4lR2aoQpvSAdnxA4cQh8gmHbNvvq3FK2atWCvXuheXNI3AhunlD413ztPGse3hZvp/p69CYi50qJksjfFNoKcTeV/Arbn1l/Et4S9i+Fml1g/Xpo1eryxifF/fVCIiEhUJD115ylv+YqWUwWrIaWchCR86OHBiJ/U2gU4m4+nSjd/8Fw+LyQz24dDnNyOPztWhYdzebOxf6857sTX98yDFacGAZ86lmL3ybn0tfTzM3PdIX0JvaNcRtcxwf3a56SiJSORpRE/qbQ5pwoAfa/gfdth8iGfLX1JP/XtCI2m0FhYcltyOVXrRrs2QPVAtw5kllE9zo+sGqRPUnKz3OqqzlKInKulCiJ/E2xOUp/boaaDWD9criuE4VWA0+LifHL07nllrKLU5z17QuffgpJJ4toVtmT3WmFUFQIkY1g18ayDk9ErlBKlET+ydolENUFCvNh10ZaV/Vi/PJ0Brfwo1q1sg5OTnFzgzFj4MPVGTQO9WDp3hzw8LKPBhbka9FJETkvmqMkchaOScCGAWYLbFkJgw8R4wE1o1PLNjgpxs0Nnl6QxnvvpWGEAeHtYPPv0LgNbFvjqOdl8XIs+SAicjYaURL5mzPnr+zI3AFtYmDbamjQEsxm1q2DNm3KMEA5K3d3+5YmrVsDedmwZys0bw+bfnPUqeRZiZT8lLILUkSuGEqURM5w+PBhAtwDHN+P5h2F2o3tI0k2GzRpi7u7VuMu7ypVgoYNsSe4Npt9RNDi5hghrOZdjYM5B8s2SBG5IihREjnD8uXLqVexHgAFtgI8zB5wMgO8fGD7OmgUVbYByjmpUsW+pQmGAW17wO8/QnQM2zO3A+Bp8aTAVlC2QYrIFUFzlETOkJqaSgW3CgBsPbGVpv5N6fBjIHV7w87voIlpdNkGKOckIgIOHoSe1UbjZ4H9u6F5BziW93808W/iqGcYztvViIj8nUaURFxIL0inglsFDMO+ZUlQHchOgrCwso5M/knVqrB/P0S0hkMJULUdHFkFbqbTj9/CPMPYuXNn2QYqIuWeEiWRvxw5coQqVaoA9pEGs8nMH5l/UK0DHPrd/pfu/qXQp0/Zxin/zNcXTpwAiwd4VgQvf0jfAzV8ajjmJtWuUJvffvvtH1oSkWudEiWRvyxbtoxOnToB9h3nK3lWIjU/lYJMCG9h35UewNvbdRtSfnTsaN8gt3YPe4JrtkAV7yqORMnL4kV2dnaZxigi5Z8SJZG/pKamEhISAsDe7L1U966Om8mNdp9V4uu0enR+qzJz3GqVcZRyrtq2hY5fVeKDZfUZsL0S7xbUYE/2nmIb5BpaiFJEzkKTuUX+cuak3lxrLkfzjlK3Ql3czfGkZls5mllEVX/3s7RQvqSlwd69kJwMqalw8qS9/J/mLp+ZN5hM4OEBISH2T40a9vk/5ivkn1iNwjxYtjeHGyJ9yMi1kpiX6HS8Xr167N69m7p165ZRhCJS3ilREgGsVisWi8WpLDk/mQD3AOqGePDeygye7hJcRtG5ZrXaN4L94w84fPh0uckEQUFQqxY0bmxPcnx9z2/9p/x8e9KVkgIbN8L8+faliU5dx88PGjWCBg3s1yhPetWvwH9XZ9C5lg+rD+ViwoSPxYesoiwquFWgbt267Nq1S4mSiLikREkE+0KT1f7auC2rKAsfiw+51lwO5x5mgL8bGbkeuFvKx2vkhgEbNsCyZWCx2BOUqCjo1+/SLITp6Wl/3T4iApo3L348IwO2b4c5cyArC2rXhp497SNR5cGtzSry9bYsiv5K7hr5NWLria20DW5L9erV+eWXX8o2QJEyNmXKFN544w0SExNp3rw577zzDm3Osv3AvHnzePbZZ9m/fz9169bl9ddfp3fv3o7jd999N7NmzXI6JzY2loULF16ye7iUlCiJAHv27KF27doAPDowFNqPh58+A6DfDf+lXSOw1DpWliGS/VJd5m4+SVqOlZYRXoyM9MZsNsF6YD3YyiiuikCbvz4Afy4v4P3/ZmO1GQxsWpGq/u5Yniqb1/AtT+0kEMh+Bywm+Cz6Jj5r2x0W/I8Z/xrOcHcoLCwsk9hEyoO5c+cSFxfH1KlTiY6OZvLkycTGxrJz505CQ0OL1f/999+5/fbbGTduHH379mXOnDn079+f9evX06TJ6TXKevbsyYwZMxzfPT09L8v9XApKlESwLw0QFfXXqtsn0sAvyHHswIGyWxIgKwsWLoQjR8Cy9gQDmlQkrOI//7HNyrex8VgefyQVUGh1nqx85qiTYRT/XhKTyX6sRqA7UVW9CD9LDHVDPKgb4kFBkcGXW0+SnHWSih9CbCxUr/6PoV8SJpN9Dzhq1ofdW8DNHYoKgStnzpnIpTBx4kSGDRvG0KFDAZg6dSo//PAD06dP56mnnipW/6233qJnz548/vjjALz00kssWrSId999l6lTpzrqeXp6Eh4efnlu4hJToiQCZGVl4evri81mA5MZDu+BanXg0G7g8u7tlpsLP/5oT9AqVIBevewTqK25gS7PSTpZxJI9OaTm2N/o8vUw0yLCk7tb+ePhdnGCNwyDfccLWbE/l6STRRiAp5uJ9jW8aRTqUWyFaw83E7e38AMg718pLFwIX34JFStC375wOX+Gmkz2bU0o9IOtq6BRa/hjLUS3u3xBiFxGmZmZTt89PT2LjeoUFBSwbt06xowZ4ygzm83ExMSQkJBQYrsJCQnExcU5lcXGxvLNN984lS1dupTQ0FACAwPp2rUrL7/8MsHB5W+e57lQoiQC2Gw2LBYLW7ZssW+Cu2M9tOrsSJQuh9xcmH57KFYb9G7gS78gD8gH/gfWEuoPbbWTvb+AzQreQVDlXvt/TxlmLYKdG+z3kJF6+sD5DCl5+UBETejQGnwrMhz7OUV58P0myNgHtiKIiIKQBvDeovrOp79Tn/5//TrzhJUfRmdzMKOQ21v4Efna3nPsoQtTowaw8igUFUGD6+CrDwAlSnL5DV02FD8/v0vSdmZmJqP9RzvmXJ7y3HPP8fzzzzuVpaamYrVaCfvbdgNhYWHs2LGjxPYTExNLrJ+YePqN0p49ezJgwAAiIyPZs2cPTz/9NL169SIhIaHYSzNXAiVKImdISEiApnfCN/8FTy+o4O8yd7hYDAO+/tq+5cYdTf0I9j37D5Ltyfks2JHNoXyofxO4eZ0+lp8Jh1dCThpgeg8atoLoGPAPvrBhsdxsOLofFn0OOSfZ7mVfqdy/GlSNtn8Mw75NyMZZsCAzi571fO1zqP7Gz8vC7S38KLIafLopk/nvwNCh9tGzS8Uw/nrs9419sUnc3OwZpshV6tChQ07J2OWcIzRo0CDHr5s2bUqzZs2oXbs2S5cupVu3bpctjotFiZIIpxcdLCwsBC9v+0JBJ9LBP+gfziw9m81g+3ZYs8a+zUZhof3x2oABYH2t5CTJMAwW/ZnDpmN5NAz15JGOgeyJTQEgLwMOroC8E+DpB9XagU8IJPBvyM+DY/th62pIOgTWor83fPYRJoCgMKhaCyIiof+9ANTNe4Qjq+HAcjC7QZU2EBgJVdvaP9U+cWfSiuOE+Fq4pWlFfDyKL7zkZjFx53X+ZN2VyKxZ9qUOPDygWTNo2fLir4Du7w9knTi9CJTpClkMSuQ8+Pn5/eOoVUhICBaLhaSkJKfypKQkl/OLwsPDS1UfoFatWoSEhLB7924lSiJXqlPzaxzzbE7NXsZ0UecnbdiwgW3bimjTBm68EQJdTzsCoMhqnxB96EQR3er48Hin08/4k7fB0bX2pKj69fb9zAqyIXEDZB4GjLfA0xuq1LJPYm7b3T6JuTQMA9KS4Mhe+HU+ZKaDycQ+f6jcEmrcANZCexwHV0CFcIjsCk3DPWka7klyVhEz1p4A4LbmFQnxLf4jx98fRoyw/zo/H7ZsgRkz7PnMkCEXZzjP8Xt45m/m33/PRa4xHh4etGrVivj4ePr37w/YpyHEx8czcuTIEs9p164d8fHxjB492lG2aNEi2rVz/Rj78OHDpKWlUbly5YsZ/mWjREnEpRJGV/7G+lp9ftqVzcajecTW86XV2weKHQc4mW9jyqqTeF7vySOWRrivzYe1Jc89OuWX3dmM9T5M7cFQsTI8xV9Jw8bfYOOvjJ6eRM+KDTCZTBz67BDbM7fjbfGmQ8X6VPKsxG/r7ne0VVBQQGpqCqmpqeTk5JCTk0Nubi4FBQVO17RYLHh7e+Pj44O3tzeBQYGENgzF17c90N5Rb2KLInbN2EVqfiphXmHc5N8Us8lMSn4K699dj9uDAyHmFntidjPck2di3g/JmLNhoWc9pwnmp/oI7D+QWv71OZZZxLh+WYTedAjrpLqYbfn2GM9YaiAlBebca3+FeWT7wGLHS6QtS0Qc4uLiGDJkCFFRUbRp04bJkyeTnZ3teAvurrvuokqVKowbNw6AUaNG0alTJ95880369OnDZ599xtq1a5k2bRpgfzHmhRdeYODAgYSHh7Nnzx6eeOIJ6tSpQ2xsbJnd54VQoiTC6Udvjn2/zvjL9Gx/r+YX2diamM8TnYJY9GcO48fbHx2FhkJODmTuyiY5q4jkLCv3twvlt0aN4B/+Ht+bXsDcTSfpUtuHFnefceDALoj/Alp0hLufomHCNLae2MqR3CNU86lGTFgMZpOZY7nHWJ66nIJ37EmQ2WzG3d2d0NBQgoOD8fHxITw8HG9vbzw8nN9WKyoqIjc31/HZvn07y5YtIzs7G8MwHP1zKOcQLQNaYjKZSMxLZHHyYjzMHrQLbkdseCxftegIsydB7SbQsTduXtBoIOSkwluT02le2Yse9c6+jHdlPzfGdAvlmX37eG93KnUCTVTwMFNxjX1l8BUr7CNy90T5s3xfLmsP5xFV1avEthy/h2f+Zv7991zkGnTbbbeRkpLC2LFjSUxMpEWLFixcuNAxYfvgwYOYz9izqH379syZM4dnnnmGp59+mrp16/LNN9841lCyWCxs3ryZWbNmkZGRQUREBD169OCll166YtdSUqIkcgbHX5o2GwSGwoZfMc7yRuuCHdkMbFoRk8lEj3q+9HrCvkp1RoZ9cnJwoDtRVbwI9rVQaD77JG2rzeB/G+yv9D7ZKQiz2cTHfx3b+wuQlwBDx9hHuXKzWZi4kAYVGxAbbv9XWlZRFr+n/k6oVyjtg9sz4t8jLqwzXDAMg7Hvj+XHxB9p4t+E6j7VCfcKJ6soi58Sf6J1UGsIrw5DnrDPjfr4DYpuAzdP+2PCxzsF89v+HMYvS+PeqICzTl43mUzccMMNdAz8meOZ2WQVGBT89Vv08MP2tZGsr5npWd+XySvSz5oopaZiXx/rzDcARYSRI0e6fNS2dOnSYmW33HILt9xyS4n1vb29+emnny5meGVOiZII9r+QDcMgJCQEjqfY33hzc4ecLEIbQlIS/O2NWAAOZBRyc5OKTmUNG57+tXXhue3jseFoHgt2ZHPndX5UDzg9j6goD7bOtb9VRoMh9sI/N8Py7+lUqRPeFm+shpVVaasoNArpEtoFd/OlXUTRZDJRzacaVb2rsjVzKz8l/kSHkA5UcKtAn8p9WJm+0v52XPdboUkbqF6XzZ88QZ2e4FfV3kaHmj60quLF9LUnHBO+zzZXyNfDTECQvS8tLnZW8LSYyC+y4VNizLB1K1CnKaxbWux+RERcKdeJ0rhx4/jqq6/YsWMH3t7etG/fntdff5369U/PacjLy+PRRx/ls88+Iz8/n9jYWN57771i6zyInI2/vz+ZmZk0atQIVv4BkQ1hv30dkWbN7BOM//6/VFaW/S/wM5053+afGIbBbdV3cWQ1BERC9bvgNdPp0Y6Tx+DTj5+H20exumIAH9w/jdXpqzFhIiowivs33M+qVatYvHgxL93xUrF1Uy6l4WuHO36dl5fHjBkz8K7gzR133MH9pvup2uhZtr7zKd3CuuFh9uD+qTbWfvNfOFQduvc83VBvyNgPE+OPEVLf/vbcB8vO3oeu+rhHPV9+2pXNzX8rt9nsidLOnUDzerB2ieYpicg5K9fvxy5btowRI0awcuVKFi1aRGFhIT169CA7O9tR55FHHuH7779n3rx5LFu2jKNHjzJgwIAyjFquRCEhISQnJ9uT8P07oFZj2LMVgLp1Ydeu4ucsWAC96599ns3fFRYW8suuk7y1Ip13fs+gIBua/sv+9tiZAxuJm+xvkXHfs1AxAIBFSYuo7FWZ1kGtMZlMfPrppyQnJzNmzJjLmiT9nZeXFw8++CBt27bl5Zdfxmq1Us2nGp1DO/NT4k+cLDxpv7mbh4GbOzu+cT4/oCZcd699tGnnd/DWinQ+3ZhJanZRSZdzqXawB/vSi+/btmcP1KplX4aBvByo4G9fKiG0CqA5SiJyduV6ROnvOw3PnDmT0NBQ1q1bxw033MCJEyf46KOPmDNnDl27dgVgxowZNGzYkJUrV9K2bduyCFuuQC1atGDp0qXUrVsXcrPAL9D+KnxYNRIT7ROzs7KcF0VMSYEq/v/8mCs9x8ovu7M5fBJ271nEA/7u9KwdiMlkYker5GL1sxIhbSc0vhV+O/VvmY2/UdOnJtV87AlRoa2Q48ePc/vtt1+U+78Y6tatS//+/Vm8eDEA3hZveob3ZHnK8tOVWncl0Av2L4WanZ3PD6hp/4zyDyI5q4iFO7NJzs1h3/6fqFsxn3oBxj8+JnO3FD/+5Zf2+Ux79gBbVkLTtrBiAfQazIkTJ/D1LV2yKyLXlnKdKP3diRP29ViCguyLAK5bt47CwkJiYmIcdRo0aED16tVJSEhwmSjl5+eTn5/v+H5qT5zCwkLtJH6OTvXT1dJfwcHBHD16lMLCQjyq1ca0dws2w4alcSt+/dWDe+818+67RTz66OnEyGototBc/C2OdYdzWHUgx/E9wNtC5zoB3BhQgfi6van75waK/nrV3c3mvKpi6p829i6x0vo+N0w2E9781c8bllEvuJ6j3pa0LTzW47Fy1/8NGjRg4cKFBHgEAOCBB+4e7nidSMH018hYlcbe7PihiENLTNToYMb8t73oCs2eBPp5cluUL0VmTxZU78y2hb+wcMfpkeSwim4MbBZQ7PpWkxuFhaf79OefrbRrB/n5Zjw9rbjv3I65TResy07g7u3FkiU/0K5du3LXjxfiavuzeTmor+RsTMYVMu5ss9m46aabyMjIYMWKFQDMmTOHoUOHOiU9AG3atKFLly68/vrrJbb1/PPP88ILLxQrnzNnDj4+JU0FlWvB/Pnz6du3L1arlR9++AF/f39atmzJ8uXL6du3L1u2bMEwDJo1awbAggUL6N27t1Mbf/zxB0lJSXTp0uWcr5uXl0dCQgInTpygRo0aNG/e3Ol13P3795OWlkarVq0cZd9++y39+vW7wDu+NH766SduuOEGvP9aWjsnJ4dly5bRq1cvp3qHDx9m/fr1WCwW2rRpQ6VKlc75Gnv37mXnzp3F2ly4cCHdu3fHYrGQlZXF4sWLuemmm9i8eTN+fn5s3bqVmjVr4unpSd26dZk/fz59+vTRhO5rXE5ODv/61784ceLEJduDDez/KPf397+k17kc17jWXDEjSiNGjGDr1q2OJOlCjBkzxmn348zMTKpVq0aXLl2u2N2NL7fCwkIWLVpE9+7dcXe/tG9ZXS6GYRAREcHGURvJOpZFncA6rJi/gjr1fqDHjlXEeph4+9cU6v1fOqGhJnbuLCJ250rH+X+m5DPZcy+NBrvxM9OKtW+xedP12Ed8kngXKXvzMGywyvQGuHtg6fkYpuCSX0AoXDIZt389w9ujZwFQYC0gPyWf3h/0LrF+WWvYsCGTb5xMy+CWjrLp0XWYFRaL6cwNMSOANmAU5DNr+fcYO/cDEG08jk+wiZodzXh6+NAtcTrx4fdgNec6nZsRbuPdzdP53vOM1wzzMwkOnUGzZiZef72ICbUa4L1zLbtWp/B/1wWyfkkUm4o2EVM5hsO2w9QdWJc+ffpc2g65zK7GP5uXWlpaWlmHIOXYFZEojRw5kvnz57N8+XKqVq3qKA8PD6egoICMjAwCAgIc5f+074ynp2eJC1+5u7vrB0spXU191q9fPyZOnEjByQKa+DbhwIkDpOSncG9Nd37+I52+DSsQ174in6w8xrFjMHo0uL99ejTz+Mkcgq8rpMhcfBjfMODgaitfr/0aU9cC6v9fIWYLrGAUAGcd+PfwpsjigfHXAkLuuFNQWFBu+33NmjVEekU64gUorNGAwpREiKhZ/AQvd+hxeq5VI0aTnQJbvwNPLyvXNyvAas6l6MxECfCvB4c3grv76d+DvvU8mb03nxUr4IknoML7haRnWfE2W5m3PpX63vXZcXIH1gIrC48t5H/3/6/c9uOFupr+bF5q6ic5m3L91pthGIwcOZKvv/6axYsXExkZ6XS8VatWuLu7Ex8f7yjbuXMnBw8ePOu+MyIlMZlMPPLII6xKX4W3xZuU/BRaBrRkT3ohJ/NtfLPtJCaTiaFD4emn4e9PaX08zBTlFW83eStsmgXeASYGDBhAWCMz/7D25Gk22+lNXM/g7+7P0aNHS3+Tl8GxY8fwd/d3LqxeDw6W8OqgC76VoMkgqNHRwk8//cSuhUXn/Eb/XXfBU0/Z95DbkZzP1FUZxNbzxc/LzMaMjUQFRvFT4k90qtQJf3//f25QRK5p5XpEacSIEcyZM4dvv/2WihUrkpiYCNjXvPH29sbf3597772XuLg4goKC8PPz49///jft2rXTG29yXsxmM18c+IJXX32V125/jU2bNvHmb8dofCuk7oQJm2DJK/VKfLvKx91MofOgB9M2LIekw3D37WyxFTL46AJmcIJc7P+CnTr8AzKLMvGx+DgtFJmcl8z2k9spsBXQ1L8p4b84P8prEdCCb775hoceeujid8IF2LhxIy1atGDvZ3udyt97JZ7FyYsx8xE1fGtQy7cWZpM9AbQZNk4WncTX4oub2Y37PzidEXkHFfLpjQu4LXckv8z7DW4dwXBO931JydOpdZa+/yOLyZH7qfcK3PlJKnXugdiesRiGwVvd36JGjRqXoAdE5GpTrhOl999/H4DOnTs7lc+YMYO7774bgEmTJmE2mxk4cKDTgpMi58vNzY1evXpx6NAh9u3bR2RX2Dwbmt8FFSNg3Pg0/tXCjzohzqtup2YX4XbGE11bEbBqETzwYskX+u1HlqQswc/Nj1xrLkWGfd0gm2Gjkmcl2gW3w8Nc8sreHmYPcgtzycvLw8ur5G07ysLPP//MY489xl6cEyWLyUL3sO4YhsGBnAMsTVmK6a+Ex2wyU8GtAllFWdgMGzC8WLvm2o0hJRHWLYPTc9opyi1WlewCGx+syqBNNS/q3wSHV4F/dfjzR3j7+ZuZPXu2kiQROWflOlE6lxfyvLy8mDJlClOmTLkMEcm1onXr1owfP57777+f2LFPULc3bJxhX/vnma7BzNmYyfJ9OQxp5Y/FbCKv0MbyfbmEDzvdhtkN8A+G7JPgW7H4RQ7uomto1/OOcfDgwcyaNYv777//vNu4mLZs2UKDBg2c3tj7O5PJRE3fmtT0rVni8SXJS8BqBUsJzyZ3bYQ7HnMq8qsKG4/k0SLCniwu25vD6kO5DI8OAGDjLAhtAhZPCGtqf1tw0KBB53N7InKNKtdzlETKUvPmzdm3bx9hzSHlD2h5r327jQ9WZXBrMz9i6vry6pI0xzyY+//6y9nJTffAd9OLl1+EVTlCQkJwc3Nj7969/1z5EissLOSrr77ixhtvvKB2qvlUg50bipVbN6yApu3AzfnfdpHdYMHObFKyipiwPB2rYfB4p2B+P5DLjLUnaHIb+FWBEwcgrBkcP368VMsQiIiU6xElkbLUo0cP3njjDfp8/gE7MndwcPJBbqx0A/8eP4h/f/E+9B3CsP+L5OGf0/BtBLtaphRrY7ivH3/6Q+XE0QSEegOf2g/s32HfT27p/vOOb1rUNAzDIG5sHB1DOvLYpsf++aRLwGazcUvNW7g+5Ho+/P7DC2qrpk9N2LYaGkU5ygzD4LrNPWg2tPiWJiYT7H4ylX5fp9J4DPzpBj0+fR1uuB6atuXeW4dhsuZxR0gHNn61kf6L+l9QfCJy7VGiJOKCyWSiSZMmLJu+jAZ+DajpW5OlKUshtZN9D7bvprMTqNf3r8dsLoQ2sb/5FnDmU7akQxBSGdh/wTHGhsfyS9IvF9TOhVi2bBkN/RpS0b2Ex4ulZDFZoCDHqSwnJwd3H9cLQnr5Q4u74cgaez8z4D77o7uPXqa6T3XCvcLJteaSmp9KrVq1LjhGEbm26NGbyFn07t2bAzkHSC9Ix8viRc/wnrB3G3z9IXS/jWod7BO9t86Fg79BVpL9qVreCdi9ELZ8CkdWQ82/L9TduhusXPSP18+z5nEk98hZ5+vlWfOKv45/GTVr1ozkvOJ71p0pszCTlPziI25/90fmH9Daed6Wr68vflVMbPkU/vgSThy0lxdkQeJG2P41bJwJFg9oMQTYkgBfvA93PEa4Vzg2w8YvSb/QJfTcV0sXETlFI0oi/6Bzpc4sTVmKn5sfrQJbQc9/wYl0+HE2e/KhVjeoUBlOHoGUbbB/CXhUgKptwSfkjIZsZ/zaYoEKfmQXncTXreRNWXdk7uBQ7iGqeFdhe+Z2LCYLjfwaEeblvIL3nqw91K5Q++Lf+DkKDg4m25pdrDy7KJvNJzaTXZSNn7sfhmGwPXM7HUM6OpYG+LvDuYehXvNi5TXaW6hihqI8OLoWDv1u7+OgOlC3F9issHcRJG8B2kdCR/tq2wdzDrL1xFauD7ne5RuEIiJno0RJ5B88sO4BHuABdu7cybx58xhzx9N/vbVlxmq8x6ZvN5FekI6n2ZNF770CXauX2I43hfRgwemCmFtZ9/FD3FDpBqd6udZclqcsJ9I3knmH5jnKCwoKWLRoEbt378ZsNnPsvWPU8KlBakEqTf2bXoI7L730gnT+yPyDVo+0ItA/kDf6vkFIyOls8ciRIzzU5iGuC7iOyt6Vnc49mnuUyl6V/94kwOm1p7yAjn8VZp+EhJ+45anP8TB70D+wFb5uvgz9dQWZhQtISEug/bR7eanXS9rLTUTOmxIlkXNUv359nnnmGUbOHMnPiT/TOqg1gR6BXBd4HWB/BPa/bWvgp88gIARqN4HajcH79IiRYRgYGamwegkcTynxkdmylGV0qdQFT4vzNjseHh6OfcmsVitjpoxhUdIiQjxDyjwRqFehHj8l/kSIZwhRgVE8POrhEutVqVKF3uG9WZi4kCCPoGL3mJyfbH9s1robVK0NZ95WUREc3g27t0DiQfCuAB37EBOW7qhSYCtgbfpa8m35dA3tWmzTYhGR0lKiJFJKzQKa0cjWiPUZ6zlecJxm/s2o7F0ZL4sXdBtor5STZZ/L9PNcyMsBk4kiw8qPJ7ZhrZoJbXtCUCjNl55ecTuzMJPf036nQcUGxRKIv7NYLNSpUIc6Fepcyls9Z1V9qlLVp+o/V8Q+Af2GSjcQnxxPI79GjjWVIrwjiPCOYN6Nd8GaxbBmMUXWAhac2EaR335w84CqdaDF9RAcZn/l7S/ZRdmsSV+DDRtRgVH4uWvXdBG5OEzGuazqeJXLzMzE39+f1NRUgoODyzqcK0JhYSELFiygd+/e1/SGkjabjfnz57N//34AGjZsSPv27fH1LT7vyFWfWa1W/ve//5Gbm8vQoUNL3LD5avXjjz+ydetW7r33XoKCgoodP1ufbdq0iVWrVlFYWIiPjw+33norfn5KkPRns/TS0tIICQnhxIkTl/T/oVN/11zK61yOa1xrNKIkcgHMZjM33XQTYH+stmPHDj799FPy8vKcHoeZTCaKiorYtm0bBw4cwHLGytN5eXn83//93zW5rUavXr3o3Lkzs2bNwmq1OsoNw8BkMmG1Wh195ubm5vT2X7NmzbjnnnuuqcRSRC4/JUoiF4nJZKJhw4Y0bNiwxOP6l37JvL29eeCBB0o8pj4TkbKmdZREREREXFCiJCIiIuKCEiURERERF5QoiYiIiLigRElERETEBSVKIiIiIi4oURIRERFxQYmSiIiIiAtKlERERERcUKIkIiIi4oISJREREREXlCiJiIiIuKBESURERMQFJUoiIiIiLihREhEREXFBiZKIiIiIC0qURERERFxQoiQiIiLighIlERER+Ufp6ekMHjwYPz8/AgICuPfee8nKyjrrOXl5eYwYMYLg4GAqVKjAwIEDSUpKcqpjMpmKfT777LNLeSulokRJRERE/tHgwYPZtm0bixYtYv78+Sxfvpzhw4ef9ZxHHnmE77//nnnz5rFs2TKOHj3KgAEDitWbMWMGx44dc3z69+9/ie6i9NzKOgAREREp37Zv387ChQtZs2YNUVFRALzzzjv07t2bCRMmEBERUeycEydO8NFHHzFnzhy6du0K2BOihg0bsnLlStq2beuoGxAQQHh4+OW5mVJSoiQiInIZZWZmXvK2/34NT09PPD09z7vdhIQEAgICHEkSQExMDGazmVWrVnHzzTcXO2fdunUUFhYSExPjKGvQoAHVq1cnISHBKVEaMWIE9913H7Vq1eKBBx5g6NChmEym8473YlKiJCIichl4eHgQHh5OtWrVLul1KlSoUOwazz33HM8///x5t5mYmEhoaKhTmZubG0FBQSQmJro8x8PDg4CAAKfysLAwp3NefPFFunbtio+PDz///DMPPfQQWVlZPPzww+cd78WkRElEROQy8PLyYt++fRQUFFzS6xiGUWw0xtVo0lNPPcXrr79+1va2b99+0WIrybPPPuv4dcuWLcnOzuaNN95QoiQiInKt8fLywsvLq6zDcHj00Ue5++67z1qnVq1ahIeHk5yc7FReVFREenq6y7lF4eHhFBQUkJGR4TSqlJSUdNb5SNHR0bz00kvk5+df0OPCi0WJkoiIyDWqUqVKVKpU6R/rtWvXjoyMDNatW0erVq0AWLx4MTabjejo6BLPadWqFe7u7sTHxzNw4EAAdu7cycGDB2nXrp3La23cuJHAwMBykSSBEiURERH5Bw0bNqRnz54MGzaMqVOnUlhYyMiRIxk0aJDjjbcjR47QrVs3Pv74Y9q0aYO/vz/33nsvcXFxBAUF4efnx7///W/atWvnmMj9/fffk5SURNu2bfHy8mLRokW8+uqrPPbYY2V5u06UKImIiMg/mj17NiNHjqRbt26YzWYGDhzI22+/7TheWFjIzp07ycnJcZRNmjTJUTc/P5/Y2Fjee+89x3F3d3emTJnCI488gmEY1KlTh4kTJzJs2LDLem9no0RJRERE/lFQUBBz5sxxebxmzZoYhuFU5uXlxZQpU5gyZUqJ5/Ts2ZOePXte1DgvNq3MLSIiIuKCEiURERERF5QoiYiIiLigRElERETEBSVKIiIiIi4oURIRERFxQYmSiIiIiAtKlERERERcUKIkIiIi4oISJREREREXlCiJiIiIuKBESURERMQFJUoiIiIiLihREhEREXFBiZKIiIiIC0qURERERFxQoiQiIiLighIlEREREReUKImIiIi4oERJRERExAUlSiIiIiIuKFESERERcUGJkoiIiIgLSpREREREXFCiJCIiIuKCEiURERERF66aRGnKlCnUrFkTLy8voqOjWb16dVmHJCIiIle4qyJRmjt3LnFxcTz33HOsX7+e5s2bExsbS3JyclmHJiIiIlewqyJRmjhxIsOGDWPo0KE0atSIqVOn4uPjw/Tp08s6NBEREbmCuZV1ABeqoKCAdevWMWbMGEeZ2WwmJiaGhISEEs/Jz88nPz/f8f3EiRMApKenX9pgryKFhYXk5OSQlpaGu7t7WYdzRVCflZ76rPTUZ6V36me/YRhlHImUR1d8opSamorVaiUsLMypPCwsjB07dpR4zrhx43jhhReKlderV++SxCgiIuVfWloa/v7+ZR2GlDNXfKJ0PsaMGUNcXJzje0ZGBjVq1ODgwYP6Q3KOMjMzqVatGocOHcLPz6+sw7kiqM9KT31Weuqz0jtx4gTVq1cnKCiorEORcuiKT5RCQkKwWCwkJSU5lSclJREeHl7iOZ6ennh6ehYr9/f31w+WUvLz81OflZL6rPTUZ6WnPis9s/mqmLYrF9kV/3+Fh4cHrVq1Ij4+3lFms9mIj4+nXbt2ZRiZiIiIXOmu+BElgLi4OIYMGUJUVBRt2rRh8uTJZGdnM3To0LIOTURERK5gV0WidNttt5GSksLYsWNJTEykRYsWLFy4sNgEb1c8PT157rnnSnwcJyVTn5We+qz01Gelpz4rPfWZnI3J0PuQIiIiIiW64ucoiYiIiFwqSpREREREXFCiJCIiIuKCEiURERERF675RGnKlCnUrFkTLy8voqOjWb16dVmHVG6MGzeO1q1bU7FiRUJDQ+nfvz87d+50qpOXl8eIESMIDg6mQoUKDBw4sNjin9ey1157DZPJxOjRox1l6rPijhw5wh133EFwcDDe3t40bdqUtWvXOo4bhsHYsWOpXLky3t7exMTE8Oeff5ZhxGXLarXy7LPPEhkZibe3N7Vr1+all15y2qvsWu+z5cuXc+ONNxIREYHJZOKbb75xOn4u/ZOens7gwYPx8/MjICCAe++9l6ysrMt4F1IeXNOJ0ty5c4mLi+O5555j/fr1NG/enNjYWJKTk8s6tHJh2bJljBgxgpUrV7Jo0SIKCwvp0aMH2dnZjjqPPPII33//PfPmzWPZsmUcPXqUAQMGlGHU5ceaNWv44IMPaNasmVO5+szZ8ePH6dChA+7u7vz444/88ccfvPnmmwQGBjrqjB8/nrfffpupU6eyatUqfH19iY2NJS8vrwwjLzuvv/4677//Pu+++y7bt2/n9ddfZ/z48bzzzjuOOtd6n2VnZ9O8eXOmTJlS4vFz6Z/Bgwezbds2Fi1axPz581m+fDnDhw+/XLcg5YVxDWvTpo0xYsQIx3er1WpEREQY48aNK8Ooyq/k5GQDMJYtW2YYhmFkZGQY7u7uxrx58xx1tm/fbgBGQkJCWYVZLpw8edKoW7eusWjRIqNTp07GqFGjDMNQn5XkySefNDp27OjyuM1mM8LDw4033njDUZaRkWF4enoan3766eUIsdzp06ePcc899ziVDRgwwBg8eLBhGOqzvwOMr7/+2vH9XPrnjz/+MABjzZo1jjo//vijYTKZjCNHjly22KXsXbMjSgUFBaxbt46YmBhHmdlsJiYmhoSEhDKMrPw6ceIEgGPjyHXr1lFYWOjUhw0aNKB69erXfB+OGDGCPn36OPUNqM9K8t133xEVFcUtt9xCaGgoLVu25MMPP3Qc37dvH4mJiU595u/vT3R09DXbZ+3btyc+Pp5du3YBsGnTJlasWEGvXr0A9dk/OZf+SUhIICAggKioKEedmJgYzGYzq1atuuwxS9m5KlbmPh+pqalYrdZiq3eHhYWxY8eOMoqq/LLZbIwePZoOHTrQpEkTABITE/Hw8CAgIMCpblhYGImJiWUQZfnw2WefsX79etasWVPsmPqsuL179/L+++8TFxfH008/zZo1a3j44Yfx8PBgyJAhjn4p6c/qtdpnTz31FJmZmTRo0ACLxYLVauWVV15h8ODBAOqzf3Au/ZOYmEhoaKjTcTc3N4KCgtSH15hrNlGS0hkxYgRbt25lxYoVZR1KuXbo0CFGjRrFokWL8PLyKutwrgg2m42oqCheffVVAFq2bMnWrVuZOnUqQ4YMKePoyqfPP/+c2bNnM2fOHBo3bszGjRsZPXo0ERER6jORi+yaffQWEhKCxWIp9rZRUlIS4eHhZRRV+TRy5Ejmz5/PkiVLqFq1qqM8PDycgoICMjIynOpfy324bt06kpOTue6663Bzc8PNzY1ly5bx9ttv4+bmRlhYmPrsbypXrkyjRo2cyho2bMjBgwcBHP2iP6unPf744zz11FMMGjSIpk2bcuedd/LII48wbtw4QH32T86lf8LDw4u92FNUVER6err68BpzzSZKHh4etGrVivj4eEeZzWYjPj6edu3alWFk5YdhGIwcOZKvv/6axYsXExkZ6XS8VatWuLu7O/Xhzp07OXjw4DXbh926dWPLli1s3LjR8YmKimLw4MGOX6vPnHXo0KHYshO7du2iRo0aAERGRhIeHu7UZ5mZmaxateqa7bOcnBzMZucf3xaLBZvNBqjP/sm59E+7du3IyMhg3bp1jjqLFy/GZrMRHR192WOWMlTWs8nL0meffWZ4enoaM2fONP744w9j+PDhRkBAgJGYmFjWoZULDz74oOHv728sXbrUOHbsmOOTk5PjqPPAAw8Y1atXNxYvXmysXbvWaNeundGuXbsyjLr8OfOtN8NQn/3d6tWrDTc3N+OVV14x/vzzT2P27NmGj4+P8b///c9R57XXXjMCAgKMb7/91ti8ebPRr18/IzIy0sjNzS3DyMvOkCFDjCpVqhjz58839u3bZ3z11VdGSEiI8cQTTzjqXOt9dvLkSWPDhg3Ghg0bDMCYOHGisWHDBuPAgQOGYZxb//Ts2dNo2bKlsWrVKmPFihVG3bp1jdtvv72sbknKyDWdKBmGYbzzzjtG9erVDQ8PD6NNmzbGypUryzqkcgMo8TNjxgxHndzcXOOhhx4yAgMDDR8fH+Pmm282jh07VnZBl0N/T5TUZ8V9//33RpMmTQxPT0+jQYMGxrRp05yO22w249lnnzXCwsIMT09Po1u3bsbOnTvLKNqyl5mZaYwaNcqoXr264eXlZdSqVcv4z3/+Y+Tn5zvqXOt9tmTJkhJ/fg0ZMsQwjHPrn7S0NOP22283KlSoYPj5+RlDhw41Tp48WQZ3I2XJZBhnLOUqIiIiIg7X7BwlERERkX+iRElERETEBSVKIiIiIi4oURIRERFxQYmSiIiIiAtKlERERERcUKIkIiIi4oISJREREREXlCiJSDE1a9Zk8uTJZR2GiEiZU6Ikcg2aNWsWHTt2LOswRETKPSVKItegb7/9lptuuqmswxARKfeUKIlcRVJSUggPD+fVV191lP3+++94eHgQHx8PQF5eHj///LMjUUpOTubGG2/E29ubyMhIZs+e7dTm0qVL8fDw4Ndff3WUjR8/ntDQUJKSki7DXYmIlB23sg5ARC6eSpUqMX36dPr370+PHj2oX78+d955JyNHjqRbt24AxMfHU6VKFRo0aADA3XffzdGjR1myZAnu7u48/PDDJCcnO9rs3Lkzo0eP5s4772TTpk3s3buXZ599lnnz5hEWFlYm9ykicrmYDMMwyjoIEbm4RowYwS+//EJUVBRbtmxhzZo1eHp6AjB8+HD8/f1544032LVrF/Xr12f16tW0bt0agB07dtCwYUMmTZrE6NGjASgoKCA6Opp69eqxdetWOnTowLRp08rq9kRELhuNKIlchSZMmECTJk2YN28e69atcyRJhmHw/fff8/nnnwOwfft23NzcaNWqlePcBg0aEBAQ4NSeh4cHs2fPplmzZtSoUYNJkyZdtnsRESlLmqMkchXas2cPR48exWazsX//fkf56tWrKSoqon379qVu8/fffwcgPT2d9PT0ixWqiEi5pkRJ5CpTUFDAHXfcwW233cZLL73Efffd55hz9O2339KnTx8sFgtgHz0qKipi3bp1jvN37txJRkaGU5t79uzhkUce4cMPPyQ6OpohQ4Zgs9ku2z2JiJQVJUoiV5n//Oc/nDhxgrfffpsnn3ySevXqcc899wDw3XffOS0LUL9+fXr27Mn999/PqlWrWLduHffddx/e3t6OOlarlTvuuIPY2FiGDh3KjBkz2Lx5M2+++eZlvzcRkctNiZLIVWTp0qVMnjyZTz75BD8/P8xmM5988gm//vorU6ZMYffu3cTGxjqdM2PGDCIiIujUqRMDBgxg+PDhhIaGOo6/8sorHDhwgA8++ACAypUrM23aNJ555hk2bdp0We9PRORy01tvIteIiRMn8ssvv7BgwYKyDkVE5IqhESWRa0TVqlUZM2ZMWYchInJF0YiSiIiIiAsaURIRERFxQYmSiIiIiAtKlERERERcUKIkIiIi4oISJREREREXlCiJiIiIuKBESURERMQFJUoiIiIiLihREhEREXHh/wGgOz2pm5uvugAAAABJRU5ErkJggg==",
"text/plain": [
""
]
@@ -662,12 +668,12 @@
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "83f4d41ba83d4076a91e56345569a42e",
+ "model_id": "d91ac17a62234383b6f1416c45e6a69e",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
- "HBox(children=(HTML(value=\".\\\\tmpnkdegtbv.pdf
\"), HTML(val…"
+ "HBox(children=(HTML(value=\"./tmph1ztvg9l.pdf
\"), HTML(value…"
]
},
"metadata": {},
@@ -686,7 +692,7 @@
"outputs": [
{
"data": {
- "image/png": "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",
+ "image/png": "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",
"text/plain": [
""
]
@@ -697,12 +703,12 @@
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "1bfd99ea8d4b47f7a62b39259d0a17b1",
+ "model_id": "8ab56653021c49c2a5e758a7c393064e",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
- "HBox(children=(HTML(value=\".\\\\tmp9pxcudl0.pdf
\"), HTML(val…"
+ "HBox(children=(HTML(value=\"./tmp3_2bkgs8.pdf
\"), HTML(value…"
]
},
"metadata": {},
@@ -720,6 +726,14 @@
"metadata": {},
"outputs": [],
"source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "01432220-f245-426a-aac5-63d41bd4c070",
+ "metadata": {},
+ "outputs": [],
+ "source": []
}
],
"metadata": {
@@ -738,7 +752,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.12.0"
+ "version": "3.12.11"
}
},
"nbformat": 4,
diff --git a/examples/PyMPDATA_examples/Shipway_and_Hill_2012/fig_1.ipynb b/examples/PyMPDATA_examples/Shipway_and_Hill_2012/fig_1.ipynb
index ffb60a8a..a9eeacd2 100644
--- a/examples/PyMPDATA_examples/Shipway_and_Hill_2012/fig_1.ipynb
+++ b/examples/PyMPDATA_examples/Shipway_and_Hill_2012/fig_1.ipynb
@@ -40,6 +40,7 @@
"outputs": [],
"source": [
"import os\n",
+ "os.environ['NUMBA_THREADING_LAYER'] = 'omp'\n",
"import numpy as np\n",
"import numba\n",
"from matplotlib import pylab\n",
@@ -157,7 +158,7 @@
" def __init__(self):\n",
" self.dpsi_cond = np.zeros(dpsi_shape)\n",
"\n",
- " def call(self, flux, g_factor, t, it): # pylint: disable=unused-argument\n",
+ " def call(self, _, flux, g_factor, t, it): # pylint: disable=unused-argument\n",
" if it == 0:\n",
" self.dpsi_cond[:] = 0\n",
" flux_wo_halo = flux[ARG_DATA_INNER][halo:-halo, halo-1:halo-1 + nr+ONE_FOR_STAGGERED_GRID]\n",
@@ -394,7 +395,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.9.2"
+ "version": "3.12.11"
}
},
"nbformat": 4,
diff --git a/examples/PyMPDATA_examples/__init__.py b/examples/PyMPDATA_examples/__init__.py
index fe920da1..e915baa1 100644
--- a/examples/PyMPDATA_examples/__init__.py
+++ b/examples/PyMPDATA_examples/__init__.py
@@ -2,6 +2,7 @@
.. include:: ../docs/pympdata_examples_landing.md
"""
+import re
from importlib.metadata import PackageNotFoundError, version
import PyMPDATA
diff --git a/scenarios_mpi/_scenario.py b/scenarios_mpi/_scenario.py
index 7745c7c8..c4486c56 100644
--- a/scenarios_mpi/_scenario.py
+++ b/scenarios_mpi/_scenario.py
@@ -1,5 +1,7 @@
"""Provides base _Scenario base class that every scenario should inherit"""
+from typing import Iterable
+
from PyMPDATA.impl.enumerations import INNER, OUTER
@@ -9,7 +11,7 @@ class _Scenario: # pylint: disable=too-few-public-methods
# pylint: disable=too-many-arguments
def __init__(self, *, mpi_dim, solver=None):
self.mpi_dim = mpi_dim
- self.solvers = {"psi": solver}
+ self.solver = solver
def advance(self, dataset, output_steps, mpi_range):
"""Logic for performing simulation. Returns wall time of one timestep (in clock ticks)"""
@@ -21,8 +23,11 @@ def advance(self, dataset, output_steps, mpi_range):
wall_time_per_timestep = self._solver_advance(n_steps=n_steps)
wall_time += wall_time_per_timestep * n_steps
steps_done += n_steps
- for key in self.solvers:
- data = self[key]
+ data = (
+ self.solver.advectee.get()
+ if not isinstance(self.solver.advectee, Iterable)
+ else self.solver.advectee["h"].get()
+ )
dataset[
(
mpi_range if self.mpi_dim == OUTER else slice(None),
@@ -30,11 +35,11 @@ def advance(self, dataset, output_steps, mpi_range):
slice(index, index + 1),
)
] = data.reshape((data.shape[0], data.shape[1], 1))
- break # TODO #510: add logic to seperatly read multp. advectees
+ # TODO #510: add logic to seperatly read multp. advectees
return wall_time
def _solver_advance(self, n_steps):
- return self.solvers["psi"].advance(n_steps=n_steps)
+ return self.solver.advance(n_steps=n_steps)
def __getitem__(self, _):
- return self.solvers["psi"].advectee.get()
+ return self.solver.advectee.get()
diff --git a/scenarios_mpi/shallow_water.py b/scenarios_mpi/shallow_water.py
index 1ec9bec9..218c0dea 100644
--- a/scenarios_mpi/shallow_water.py
+++ b/scenarios_mpi/shallow_water.py
@@ -3,6 +3,7 @@
import numba
import numpy as np
from matplotlib import pyplot
+from PyMPDATA_examples.Jarecka_et_al_2015.simulation import make_hooks
from PyMPDATA_MPI.domain_decomposition import mpi_indices
from PyMPDATA_MPI.mpi_periodic import MPIPeriodic
@@ -15,19 +16,6 @@
subdomain = make_subdomain(jit_flags={})
-def gradient(psi, grid_step, axis, halo):
- """Helper function needed to calculate gradients"""
- grad_left = (
- (slice(halo + 1, None if halo == 1 else (-halo + 1)), slice(halo, -halo)),
- (slice(halo, -halo), slice(halo + 1, None if halo == 1 else (-halo + 1))),
- )
- grad_right = (
- (slice(None if halo == 1 else (halo - 1), -halo - 1), slice(halo, -halo)),
- (slice(halo, -halo), slice(None if halo == 1 else (halo - 1), -halo - 1)),
- )
- return (psi[grad_left[axis]] - psi[grad_right[axis]]) / 2 / grid_step
-
-
class ShallowWaterScenario(_Scenario):
# pylint: disable=too-many-instance-attributes, too-many-locals
"""class represenation of shallow water equation solver based on
@@ -44,23 +32,22 @@ def __init__( # pylint: disable=too-many-arguments,too-many-locals
courant_field_multiplier, # pylint: disable=unused-argument
mpi_dim,
):
- @staticmethod
def initial_condition(x, y, lx, ly):
"""returns advectee array for a given grid indices"""
# pylint: disable=invalid-name
A = 1 / lx / ly
- h = A * (1 - (x / lx) ** 2 - (y / ly) ** 2) * 6.25
+ h = A * (1 - (x / lx) ** 2 - (y / ly) ** 2)
return np.where(h > 0, h, 0)
# pylint: disable=invalid-name
self.halo = mpdata_options.n_halo
- self.n_threads = n_threads
xyi = mpi_indices(grid=grid, rank=rank, size=size, mpi_dim=mpi_dim)
nx, ny = xyi[mpi_dim].shape
for dim in enumerate(grid):
xyi[dim[0]] -= (grid[dim[0]] - 1) / 2
+ self.rank = rank
self.dt = 0.1
self.dx = 32 / grid[0]
self.dy = 32 / grid[1]
@@ -116,62 +103,26 @@ def initial_condition(x, y, lx, ly):
* 2 # for complex dtype
* (2 if mpi_dim == OUTER else n_threads),
)
- self.traversals = stepper.traversals
super().__init__(mpi_dim=mpi_dim)
- self.solvers = {
- k: Solver(stepper, v, self.advector) for k, v in advectees.items()
- }
+ self.solver = Solver(stepper, advectees, self.advector)
- @staticmethod
- def interpolate(psi, axis):
- """Method that does simple interpolation of given field"""
- idx = (
- (slice(None, -1), slice(None, None)),
- (slice(None, None), slice(None, -1)),
+ self.ante_step, self.post_step = make_hooks(
+ traversals=stepper.traversals,
+ options=mpdata_options,
+ grid_step=(self.dx, None, self.dy),
+ time_step=self.dt,
)
- return np.diff(psi, axis=axis) / 2 + psi[idx[axis]]
def __getitem__(self, key):
- return self.solvers[key].advectee.get()
+ return self.solver.advectee[key].get()
def data(self, key):
"""Method used to get raw data from advectee"""
- return self.solvers[key].advectee.data
+ return self.solver.advectee[key].data
def _solver_advance(self, n_steps):
- grid_step = (self.dx, self.dy)
for _ in range(n_steps):
- self.solvers[ # pylint: disable=protected-access
- "h"
- ].advectee._debug_fill_halos(self.traversals, range(self.n_threads))
- for xy, k in enumerate(("uh", "vh")): # pylint: disable=invalid-name
- mask = self.data("h") > self.eps
- vel = np.where(mask, np.nan, 0)
- self.solvers[ # pylint: disable=protected-access
- k
- ].advectee._debug_fill_halos(self.traversals, range(self.n_threads))
- np.divide(self.data(k), self.data("h"), where=mask, out=vel)
- self.advector.data[xy][:] = (
- self.interpolate(vel, xy) * self.dt / grid_step[xy]
- )
- self.solvers["h"].advance(1)
- self.solvers[ # pylint: disable=protected-access
- "h"
- ].advectee._debug_fill_halos(self.traversals, range(self.n_threads))
- for xy, k in enumerate(("uh", "vh")): # pylint: disable=invalid-name
- self[k][:] -= (
- self.dt
- / 2
- * self["h"]
- * gradient(self.data("h"), grid_step[xy], axis=xy, halo=self.halo)
- )
- self.solvers[k].advance(1)
- self[k][:] -= (
- self.dt
- / 2
- * self["h"]
- * gradient(self.data("h"), grid_step[xy], axis=xy, halo=self.halo)
- )
+ self.solver.advance(1, ante_step=self.ante_step, post_step=self.post_step)
return -1
@staticmethod
diff --git a/tests/unit_tests/test_indexers.py b/tests/unit_tests/test_indexers.py
new file mode 100644
index 00000000..4c41253c
--- /dev/null
+++ b/tests/unit_tests/test_indexers.py
@@ -0,0 +1,130 @@
+# pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring,invalid-name
+import numpy as np
+import pytest
+
+from PyMPDATA import Options, ScalarField, VectorField
+from PyMPDATA.boundary_conditions import Constant
+from PyMPDATA.impl import indexers
+from PyMPDATA.impl.enumerations import INNER, OUTER
+
+options = Options()
+bc = [Constant(value=0)]
+indexers = indexers.make_indexers(options.jit_flags)
+halo = options.n_halo
+focus = (0, 0, 0)
+
+rng = np.random.default_rng()
+
+
+def test_ats1D():
+ # arrange
+ grid = 5
+ inp_arr = rng.random(grid)
+ field = ScalarField(inp_arr, halo, bc)
+ arr = field.data
+ sut = indexers[1].ats[INNER]
+ index = 2
+
+ # act
+ value = sut(focus, arr, index)
+
+ # assert
+ assert value == arr[index]
+
+
+def test_atv1D():
+ # arrange
+ grid = 5
+ field = VectorField((rng.random(size=grid),), halo, bc)
+ arrs = field.data
+ sut = indexers[1].atv[INNER]
+ index_vec = 2.5
+ index = 2
+
+ # act
+ value = sut(focus, arrs, index_vec)
+
+ # assert
+ assert value == arrs[INNER][index]
+
+
+def test_ati1D():
+ # arrange
+ grid = 5
+ field = VectorField((rng.random(size=grid),), halo, bc)
+ arrs = field.data
+ sut = indexers[1].ati[INNER]
+ index_vec = 2.5
+ index = 2
+
+ # act
+ value = sut(focus, arrs, index_vec)
+
+ # assert
+ assert value == (arrs[INNER][index] + arrs[INNER][index + 1]) / 2
+
+
+@pytest.mark.parametrize("axis", (INNER, OUTER))
+def test_ats2D(axis):
+ # arrange
+ grid = (5, 5)
+ bc_2D = [bc] * len(grid)
+ field = ScalarField(rng.random(grid), halo, bc_2D)
+ arr = field.data
+ sut = indexers[2].ats[axis]
+ index = 2
+
+ # act
+ value = sut(focus, arr, index, halo)
+
+ # assert
+ assert value == arr[((index, halo), (halo, index))[axis]]
+
+
+@pytest.mark.parametrize("axis", (INNER, OUTER))
+def test_atv2D(axis):
+ # arrange
+ xi = 5
+ yi = 5
+ bc_2D = [bc] * len((xi, yi))
+ field = VectorField(
+ (rng.random((xi + 1, yi)), rng.random((xi, yi + 1))), options.n_halo, bc_2D
+ )
+ arrs = field.data
+ sut = indexers[2].atv[axis]
+ index_vec = 2.5
+ index = 2
+
+ # act
+ value = sut(focus, arrs, index_vec, halo)
+
+ # assert
+ assert value == arrs[axis][((index, halo), (halo, index))[axis]]
+
+
+@pytest.mark.parametrize("axis", (INNER, OUTER))
+def test_ati2D(axis):
+ # arrange
+ grid = 5, 5
+ bc_2D = [bc] * len((grid))
+ fields = (
+ ScalarField(rng.random(grid), halo, bc_2D),
+ ScalarField(rng.random(grid), halo, bc_2D),
+ )
+ arrs = (fields[INNER].data, fields[OUTER].data)
+ sut = indexers[2].ati[axis]
+ index_vec = 2.5
+ index = 2
+
+ # act
+ value = sut(focus, arrs, index_vec, halo)
+
+ # assert
+ assert (
+ value
+ == (
+ arrs[axis][((index, halo), (halo, index))[axis]]
+ + arrs[axis][((index + 1, halo), (halo, index + 1))[axis]]
+ )
+ / 2
+ )
diff --git a/tests/unit_tests/test_solver.py b/tests/unit_tests/test_solver.py
index 23baf7a0..7a3ae9ce 100644
--- a/tests/unit_tests/test_solver.py
+++ b/tests/unit_tests/test_solver.py
@@ -35,3 +35,17 @@ def test_mu_arg_handling(case):
sut = Solver(stepper, advectee, advector, case["g_factor"])
sut.advance(1, mu_coeff=case["mu"])
+
+
+def test_multiple_scalar_fields():
+ opt = Options()
+ data = np.asarray([4.0, 5])
+ advector = VectorField((np.asarray([1.0, 2, 3]),), opt.n_halo, BCS)
+ advectees = [ScalarField(data, opt.n_halo, BCS)] * 5
+ stepper = Stepper(options=opt, n_dims=1)
+ sut = Solver(stepper, advectees, advector)
+
+ sut.advance(1)
+
+ for advectee in advectees:
+ assert (advectee.get() != data).all()
diff --git a/tests_mpi/contract_tests/test_single_vs_multi_node.py b/tests_mpi/contract_tests/test_single_vs_multi_node.py
index 247ce070..046fb560 100644
--- a/tests_mpi/contract_tests/test_single_vs_multi_node.py
+++ b/tests_mpi/contract_tests/test_single_vs_multi_node.py
@@ -103,7 +103,9 @@ def test_single_vs_multi_node( # pylint: disable=too-many-arguments,too-many-br
pytest.skip("threading requires Numba JIT to be enabled")
if scenario_class is ShallowWaterScenario and (
- options_kwargs["n_iters"] == 3 or options_kwargs.get("third_order_terms", False)
+ options_kwargs["n_iters"] == 3
+ or options_kwargs.get("third_order_terms", False)
+ or mpi_dim == INNER
):
pytest.skip("Unsupported method for simulation")
# pylint: disable=too-many-boolean-expressions
@@ -120,6 +122,9 @@ def test_single_vs_multi_node( # pylint: disable=too-many-arguments,too-many-br
pass
# request.node.add_marker(pytest.mark.xfail(reason="TODO #570", strict=True))
+ if scenario_class is ShallowWaterScenario:
+ options_kwargs["dynamic_advector"] = True
+
plot = (
"CI_PLOTS_PATH" in os.environ
and (