diff --git a/.binder/environment.yml b/.binder/environment.yml index 1a59c7771..f64dc2dba 100644 --- a/.binder/environment.yml +++ b/.binder/environment.yml @@ -3,4 +3,5 @@ channels: - conda-forge dependencies: - parcels + - pooch - trajan diff --git a/.gitattributes b/.gitattributes index 00a7b00c9..9851bd8e5 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1 +1,3 @@ .git_archival.txt export-subst +# SCM syntax highlighting & preventing 3-way merges +pixi.lock merge=binary linguist-language=YAML linguist-generated=true diff --git a/.github/actions/install-parcels/action.yml b/.github/actions/install-parcels/action.yml deleted file mode 100644 index 66a3bbccc..000000000 --- a/.github/actions/install-parcels/action.yml +++ /dev/null @@ -1,33 +0,0 @@ -name: Setup Conda and install parcels -description: > - In-repo composite action to setup Conda and install parcels. Installation of parcels relies on - `setup.py` file being available in the root. For general setup of Anaconda environments, just use - the `conda-incubator/setup-miniconda` action (setting C variables as required). -inputs: - environment-file: - description: Conda environment file to use. - default: environment.yml - python-version: - description: Python version to use. - default: "" -runs: - using: "composite" - steps: - - name: Configure pagefile # Windows compatability fix as per PR #1279 - if: ${{ runner.os == 'Windows' }} - uses: al-cheb/configure-pagefile-action@v1.3 - with: - minimum-size: 8GB - - name: Install miniconda (${{ inputs.environment-file }}) - uses: conda-incubator/setup-miniconda@v3 - with: - environment-file: ${{ inputs.environment-file }} - python-version: ${{ inputs.python-version }} - channels: conda-forge - - name: MPI support - if: ${{ ! (runner.os == 'Windows') }} - run: conda install -c conda-forge mpich mpi4py - shell: bash -el {0} - - name: Install parcels - run: pip install . - shell: bash -el {0} diff --git a/.github/ci/min-core-deps.yml b/.github/ci/min-core-deps.yml index 25eec60d9..55c3f47a6 100644 --- a/.github/ci/min-core-deps.yml +++ b/.github/ci/min-core-deps.yml @@ -6,18 +6,14 @@ dependencies: # MINIMUM VERSIONS POLICY: keep track of minimum versions # for core packages. Dev and conda release builds should use this as reference. # Run ci/min_deps_check.py to verify that this file respects the policy. - - python=3.10 + - python=3.11 - cftime=1.6 - - cgen=2020.1 - dask=2022.8 - matplotlib-base=3.5 # netcdf follows a 1.major.minor[.patch] convention # (see https://github.com/Unidata/netcdf4-python/issues/1090) - netcdf4=1.6 - numpy=1.23 - - platformdirs=2.5 - - psutil=5.9 - - pymbolic=2022.1 - pytest=7.1 - scipy=1.9 - tqdm=4.64 diff --git a/.github/ci/min_deps_check.py b/.github/ci/min_deps_check.py index ea23ba657..36278ff3c 100644 --- a/.github/ci/min_deps_check.py +++ b/.github/ci/min_deps_check.py @@ -60,8 +60,8 @@ def parse_requirements(fname) -> Iterator[tuple[str, int, int, int | None]]: try: version_tup = tuple(int(x) for x in version.split(".")) - except ValueError: - raise ValueError("non-numerical version: " + row) + except ValueError as e: + raise ValueError("non-numerical version: " + row) from e if len(version_tup) == 2: yield (pkg, *version_tup, None) # type: ignore[misc] @@ -193,7 +193,7 @@ def main() -> None: print("\nErrors:") print("-------") for i, e in enumerate(errors): - print(f"{i+1}. {e}") + print(f"{i + 1}. {e}") sys.exit(1) diff --git a/.github/ci/recipe.yaml b/.github/ci/recipe.yaml new file mode 100644 index 000000000..5f4fa5ce9 --- /dev/null +++ b/.github/ci/recipe.yaml @@ -0,0 +1,69 @@ +# Recipe for https://github.com/prefix-dev/rattler-build used for nightly releases of Parcels +# during version 4 alpha development +# +# Adapted from the conda forge recipe +context: + name: parcels + version: 4.0.0alpha0 # The last number here needs to be bumped for each new alpha release + +package: + name: ${{ name|lower }} + version: ${{ version }} + +source: + path: ../.. + +build: + number: 0 + noarch: python + script: + - python -m pip install . -vv --no-deps --no-build-isolation + +requirements: + host: + - python 3.11.* + - pip + - setuptools + - setuptools_scm + - setuptools_scm_git_archive + - wheel + run: + - python >=3.11 + - cftime + - dask + - matplotlib-base >=2.0.2 + - netcdf4 >=1.1.9 + - numpy >=1.11 + - platformdirs + - pytest + - scipy >=0.16.0 + - trajan + - tqdm + - xarray >=0.10.8 + - zarr >=2.11.0,!=2.18.0,<3 + - uxarray>=2025.3.0 + - pyogrio # needed for geopandas (uxarray -> geoviews -> geopandas -> pyogrio, but for some reason conda doesn't pick it up automatically) + - pooch + +tests: + - python: + imports: + - parcels + +about: + homepage: https://github.com/OceanParcels/parcels + license: MIT + license_file: LICENSE.md + summary: Probably A Really Computationally Efficient Lagrangian Simulator + description: | + Parcels (Probably A Really Computationally Efficient Lagrangian Simulator) + is a set of Python classes and methods to create customisable particle + tracking simulations using output from Ocean Circulation models. + Parcels can be used to track passive and active particulates such as + water, nutrients, plankton, plastic and fish. + documentation: https://oceanparcels.org/ + repository: https://github.com/OceanParcels/parcels + +extra: + recipe-maintainers: + - VeckoTheGecko diff --git a/.github/workflows/additional.yml b/.github/workflows/additional.yml index 8be353f76..790a7a5bb 100644 --- a/.github/workflows/additional.yml +++ b/.github/workflows/additional.yml @@ -29,7 +29,7 @@ jobs: python .github/ci/min_deps_check.py .github/ci/min-core-deps.yml linkcheck: - name: Sphinx linkcheck + name: pixi run docs-linkcheck runs-on: "ubuntu-latest" defaults: run: @@ -37,8 +37,6 @@ jobs: steps: - uses: actions/checkout@v4 - - name: Setup parcels - uses: ./.github/actions/install-parcels - with: - environment-file: environment.yml - - run: sphinx-build -b linkcheck docs/ _build/linkcheck + - uses: actions/checkout@v4 + - uses: prefix-dev/setup-pixi@v0.9.0 + - run: pixi run docs-linkcheck diff --git a/.github/workflows/cache-pixi-lock.yml b/.github/workflows/cache-pixi-lock.yml new file mode 100644 index 000000000..48fa1b72b --- /dev/null +++ b/.github/workflows/cache-pixi-lock.yml @@ -0,0 +1,49 @@ +name: Generate and cache Pixi lockfile + +on: + workflow_call: + outputs: + cache-id: + description: "The lock file contents" + value: ${{ jobs.cache-pixi-lock.outputs.cache-id }} + +jobs: + cache-pixi-lock: + name: Generate output + runs-on: ubuntu-latest + outputs: + cache-id: ${{ steps.restore.outputs.cache-primary-key }} + steps: + - uses: actions/checkout@v5 + with: + fetch-depth: 0 + sparse-checkout: pixi.toml + - name: Get current date + id: date + run: echo "date=$(date +'%Y-%m-%d')" >> "$GITHUB_OUTPUT" + - uses: actions/cache/restore@v4 + id: restore + with: + path: | + pixi.lock + key: ${{ steps.date.outputs.date }}_${{hashFiles('pixi.toml')}} + - uses: prefix-dev/setup-pixi@v0.9.0 + if: ${{ !steps.restore.outputs.cache-hit }} + with: + pixi-version: v0.49.0 + run-install: false + - name: Run pixi lock + if: ${{ !steps.restore.outputs.cache-hit }} + run: pixi lock + - uses: actions/cache/save@v4 + if: ${{ !steps.restore.outputs.cache-hit }} + id: cache + with: + path: | + pixi.lock + key: ${{ steps.restore.outputs.cache-primary-key }} + - name: Upload pixi.lock + uses: actions/upload-artifact@v4 + with: + name: pixi-lock + path: pixi.lock diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f943a1f3d..27079c96d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -17,68 +17,82 @@ defaults: shell: bash -el {0} jobs: + cache-pixi-lock: + uses: ./.github/workflows/cache-pixi-lock.yml unit-test: - name: "py${{ matrix.python-version }} | ${{ matrix.os }} | unit tests" + name: "Unit tests: ${{ matrix.os }} | pixi run -e ${{ matrix.pixi-environment }} tests" runs-on: ${{ matrix.os }}-latest + needs: [cache-pixi-lock] + env: + COVERAGE_REPORT: "${{ matrix.os }}_${{ matrix.pixi-environment }}_unit_test_report.html" strategy: fail-fast: false matrix: - os: [macos, ubuntu, windows] - python-version: ["3.13"] + os: [ubuntu] #, mac, windows] # TODO v4: Re-enable windows and mac + pixi-environment: [test-latest] include: - os: ubuntu - python-version: "3.10" - - os: ubuntu - python-version: "3.11" - - os: ubuntu - python-version: "3.12" + pixi-environment: "test-py311" steps: - - name: Checkout - uses: actions/checkout@v4 - - name: Setup Conda and parcels - uses: ./.github/actions/install-parcels + - uses: actions/checkout@v4 + - name: Restore cached pixi lockfile + uses: actions/cache/restore@v4 + id: restore-pixi-lock + with: + path: | + pixi.lock + key: ${{ needs.cache-pixi-lock.outputs.cache-id }} + - uses: prefix-dev/setup-pixi@v0.9.0 with: - environment-file: environment.yml - python-version: ${{ matrix.python-version }} + cache: true + cache-write: ${{ github.event_name == 'push' && github.ref_name == 'v4-dev' }} # TODO: Update v4-dev to main when v4 is released - name: Unit test run: | - coverage run -m pytest -v -s --html=${{ matrix.os }}_${{ matrix.python-version }}_unit_test_report.html --self-contained-html tests - coverage xml + pixi run -e ${{ matrix.pixi-environment }} tests -v -s --cov=parcels --cov-report=xml --html="${{ env.COVERAGE_REPORT }}" --self-contained-html - name: Codecov uses: codecov/codecov-action@v5.3.1 env: CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} - if: matrix.python-version == '3.13' with: flags: unit-tests - name: Upload test results if: ${{ always() }} # Always run this step, even if tests fail uses: actions/upload-artifact@v4 with: - name: Unittest report ${{ matrix.os }}-${{ matrix.python-version }} - path: ${{ matrix.os }}_${{ matrix.python-version }}_unit_test_report.html + name: Unittest report ${{ matrix.os }}-${{ matrix.pixi-environment }} + path: ${{ env.COVERAGE_REPORT }} integration-test: - name: "py${{ matrix.python-version }} | ${{ matrix.os }} | integration tests" + # TODO v4: Re-enable the workflow once development has stabilized and we want to run integration tests again + if: false + name: "Integration: ${{ matrix.os }} | pixi run -e ${{ matrix.pixi-environment }} tests-notebooks" runs-on: ${{ matrix.os }}-latest + needs: [cache-pixi-lock] + env: + COVERAGE_REPORT: "${{ matrix.os }}_${{ matrix.pixi-environment }}_integration_test_report.html" strategy: fail-fast: false matrix: - os: [macos, ubuntu, windows] - python-version: ["3.13"] + os: [ubuntu] #, mac, windows] # TODO v4: Re-enable windows and mac + python-version: ["3.12"] include: - os: ubuntu - python-version: "3.10" + python-version: "3.11" steps: - - name: Checkout - uses: actions/checkout@v4 - - name: Setup Conda and parcels - uses: ./.github/actions/install-parcels + - uses: actions/checkout@v4 + - name: Restore cached pixi lockfile + uses: actions/cache/restore@v4 + id: restore-pixi-lock + with: + path: | + pixi.lock + key: ${{ needs.cache-pixi-lock.outputs.cache-id }} + - uses: prefix-dev/setup-pixi@v0.9.0 with: - environment-file: environment.yml + cache: true + cache-write: ${{ github.event_name == 'push' && github.ref_name == 'v4-dev' }} # TODO: Update v4-dev to main when v4 is released - name: Integration test run: | - coverage run -m pytest -v -s --nbval-lax -k "not documentation" --html="${{ matrix.os }}_${{ matrix.python-version }}_integration_test_report.html" --self-contained-html docs/examples - coverage xml + pixi run test-notebooks -v -s --html="${{ env.COVERAGE_REPORT }}" --self-contained-html --cov=parcels --cov-report=xml - name: Codecov uses: codecov/codecov-action@v5.3.1 env: @@ -89,13 +103,14 @@ jobs: if: ${{ always() }} # Always run this step, even if tests fail uses: actions/upload-artifact@v4 with: - name: Integration test report ${{ matrix.os }}-${{ matrix.python-version }} - path: ${{ matrix.os }}_${{ matrix.python-version }}_integration_test_report.html + name: Integration test report ${{ matrix.os }}-${{ matrix.pixi-environment }} + path: ${{ env.COVERAGE_REPORT }} merge-test-artifacts: runs-on: ubuntu-latest needs: - unit-test - integration-test + - typechecking steps: - name: Merge Artifacts uses: actions/upload-artifact/merge@v4 @@ -103,25 +118,31 @@ jobs: name: Testing reports pattern: "* report *" typechecking: - name: mypy + name: "TypeChecking: pixi run typing" + # TODO v4: Enable typechecking again + if: false runs-on: ubuntu-latest + needs: [cache-pixi-lock] steps: - name: Checkout uses: actions/checkout@v4 - - name: Setup Conda and parcels - uses: ./.github/actions/install-parcels + - name: Restore cached pixi lockfile + uses: actions/cache/restore@v4 + id: restore-pixi-lock with: - environment-file: environment.yml - - run: conda install lxml # dep for report generation + path: | + pixi.lock + key: ${{ needs.cache-pixi-lock.outputs.cache-id }} + - uses: prefix-dev/setup-pixi@v0.9.0 + with: + cache: true + cache-write: ${{ github.event_name == 'push' && github.ref_name == 'v4-dev' }} # TODO: Update v4-dev to main when v4 is released - name: Typechecking run: | - mypy --install-types --non-interactive parcels --cobertura-xml-report mypy_report - - name: Upload mypy coverage to Codecov - uses: codecov/codecov-action@v5.3.1 - if: ${{ always() }} # Upload even on error of mypy - env: - CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} + pixi run typing --non-interactive --html-report mypy-report + - name: Upload test results + if: ${{ always() }} # Upload even on mypy error + uses: actions/upload-artifact@v4 with: - file: mypy_report/cobertura.xml - flags: mypy - fail_ci_if_error: false + name: Mypy report + path: mypy-report diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml new file mode 100644 index 000000000..19d159a7f --- /dev/null +++ b/.github/workflows/nightly.yml @@ -0,0 +1,28 @@ +on: + workflow_dispatch: + +permissions: + contents: read + id-token: write + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Build conda package + uses: prefix-dev/rattler-build-action@v0.2.19 + with: + recipe-path: .github/ci/recipe.yaml + + - name: Upload all packages + shell: bash + run: | + shopt -s nullglob + EXIT_CODE=0 + for pkg in $(find output -type f \( -name "*.conda" -o -name "*.tar.bz2" \) ); do + if ! rattler-build upload prefix -c parcels "${pkg}"; then + EXIT_CODE=1 + fi + done + exit $EXIT_CODE diff --git a/.github/workflows/pypi-release.yml b/.github/workflows/pypi-release.yml index ad3c789f6..1b4bd922c 100644 --- a/.github/workflows/pypi-release.yml +++ b/.github/workflows/pypi-release.yml @@ -19,7 +19,7 @@ jobs: - uses: actions/setup-python@v5 name: Install Python with: - python-version: "3.10" + python-version: "3.11" - name: Install dependencies run: | @@ -54,7 +54,7 @@ jobs: - uses: actions/setup-python@v5 name: Install Python with: - python-version: "3.10" + python-version: "3.11" - uses: actions/download-artifact@v4 with: name: releases @@ -90,10 +90,6 @@ jobs: path: dist - name: Publish package to PyPI uses: pypa/gh-action-pypi-publish@v1.12.4 - with: - user: __token__ - password: ${{ secrets.PARCELS_PYPI_PROD_TOKEN }} - verbose: true test-pypi-release: needs: upload-to-pypi @@ -102,9 +98,9 @@ jobs: - uses: conda-incubator/setup-miniconda@v3 with: activate-environment: parcels - python-version: "3.10" + python-version: "3.11" channels: conda-forge - - run: conda install -c conda-forge c-compiler pip + - run: conda install -c conda-forge pip - run: pip install parcels --no-cache - run: curl https://raw.githubusercontent.com/OceanParcels/parcels/main/docs/examples/example_peninsula.py > example_peninsula.py - run: python example_peninsula.py diff --git a/.gitignore b/.gitignore index 8f4c7fd1c..a9dd99553 100644 --- a/.gitignore +++ b/.gitignore @@ -1,19 +1,14 @@ build/* docs/_build/* docs/_downloads -lib/ -bin/ -parcels_examples +output -*.so *.log *.nc *.nc4 !*testfields*.nc out-* -*.c *.pyc -*.dSYM/* **/*.zarr/* .DS_store @@ -27,4 +22,12 @@ parcels.egg-info/* dist/parcels*.egg parcels/_version_setup.py .pytest_cache +.hypothesis .coverage + +# pixi environments +.pixi +*.egg-info + +# Ignore pixi.lock file for now as Vecko is the only one using pixi for development. This should be checked into VCS if it becomes a more common tool. +pixi.lock diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index ea0d8e8e7..ba03b4ac5 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,6 +1,6 @@ repos: - repo: https://github.com/pre-commit/pre-commit-hooks - rev: v5.0.0 + rev: v6.0.0 hooks: - id: trailing-whitespace - id: end-of-file-fixer @@ -10,7 +10,7 @@ repos: types: [text] files: \.(json|ipynb)$ - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.8.6 + rev: v0.13.2 hooks: - id: ruff name: ruff lint (.py) @@ -23,13 +23,13 @@ repos: - id: ruff-format types_or: [python, jupyter] - repo: https://github.com/rbubley/mirrors-prettier # Update mirror as official mirror is deprecated - rev: v3.4.2 + rev: v3.6.2 hooks: - id: prettier # Ruff doesn't have full coverage of pydoclint https://github.com/astral-sh/ruff/issues/12434 - repo: https://github.com/PyCQA/flake8 - rev: 7.1.1 + rev: 7.3.0 hooks: - id: flake8 name: pydoclint @@ -39,3 +39,18 @@ repos: - --select=DOC103 # TODO: Expand coverage to other codes additional_dependencies: - pydoclint[flake8] + - repo: https://github.com/kynan/nbstripout + rev: 0.8.1 + hooks: + - id: nbstripout + - repo: https://github.com/ComPWA/taplo-pre-commit + rev: v0.9.3 + hooks: + - id: taplo-format + args: + [ + "--option", + "array_auto_collapse=false", + "--option", + "align_comments=false", + ] diff --git a/.readthedocs.yaml b/.readthedocs.yaml index 13922d8e2..fd072af0d 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -1,11 +1,18 @@ version: 2 build: - os: ubuntu-22.04 + os: ubuntu-lts-latest tools: - python: mambaforge-22.9 - + # just so RTD stops complaining + python: "latest" + jobs: + create_environment: + - asdf plugin add pixi + - asdf install pixi latest + - asdf global pixi latest + install: + - pixi install -e docs + build: + html: + - pixi run -e docs sphinx-build -T -b html docs $READTHEDOCS_OUTPUT/html sphinx: configuration: docs/conf.py - -conda: - environment: environment.yml diff --git a/README.md b/README.md index 5b9239134..d6f6831c9 100644 --- a/README.md +++ b/README.md @@ -1,13 +1,19 @@ ## Parcels +[![Pixi Badge](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json)](https://pixi.sh) [![Anaconda-release](https://anaconda.org/conda-forge/parcels/badges/version.svg)](https://anaconda.org/conda-forge/parcels/) [![Anaconda-date](https://anaconda.org/conda-forge/parcels/badges/latest_release_date.svg)](https://anaconda.org/conda-forge/parcels/) [![Zenodo](https://zenodo.org/badge/DOI/10.5281/zenodo.823561.svg)](https://doi.org/10.5281/zenodo.823561) -[![Code style: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/format.json)](https://github.com/astral-sh/ruff) +[![Xarray](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/pydata/xarray/refs/heads/main/doc/badge.json)](https://xarray.dev) +[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) [![unit-tests](https://github.com/OceanParcels/parcels/actions/workflows/ci.yml/badge.svg)](https://github.com/OceanParcels/parcels/actions/workflows/ci.yml) [![codecov](https://codecov.io/gh/OceanParcels/parcels/branch/main/graph/badge.svg)](https://codecov.io/gh/OceanParcels/parcels) [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/5353/badge)](https://bestpractices.coreinfrastructure.org/projects/5353) [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/OceanParcels/parcels/main?labpath=docs%2Fexamples%2Fparcels_tutorial.ipynb) +[![LinkedIn](https://custom-icon-badges.demolab.com/badge/LinkedIn-0A66C2?logo=linkedin-white&logoColor=fff)](https://www.linkedin.com/company/parcelscode/) + +> [!WARNING] +> This branch is `v4-dev` - version 4 of Parcels which is in active development. See `main` (or the tags) to browse stable versions of Parcels. **Parcels** (**P**robably **A** **R**eally **C**omputationally **E**fficient **L**agrangian **S**imulator) is a set of Python classes and methods to create customisable particle tracking simulations using output from Ocean Circulation models. Parcels can be used to track passive and active particulates such as water, plankton, [plastic](http://www.topios.org/) and [fish](https://github.com/Jacketless/IKAMOANA). diff --git a/docs/_static/homepage.gif b/docs/_static/homepage.gif index a76c535d1..4689dd893 100644 Binary files a/docs/_static/homepage.gif and b/docs/_static/homepage.gif differ diff --git a/docs/_static/logo-horo.svg b/docs/_static/logo-horo.svg new file mode 100644 index 000000000..3f040e6f0 --- /dev/null +++ b/docs/_static/logo-horo.svg @@ -0,0 +1,185 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Ocean + Parcels + + diff --git a/docs/_static/logo-horo_dia.svg b/docs/_static/logo-horo_dia.svg new file mode 100644 index 000000000..9272f4f7c --- /dev/null +++ b/docs/_static/logo-horo_dia.svg @@ -0,0 +1,90 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Ocean + + + + + Parcels + + + + + diff --git a/docs/_static/parcelslogo-inverted.png b/docs/_static/parcelslogo-inverted.png deleted file mode 100644 index 89aa520a3..000000000 Binary files a/docs/_static/parcelslogo-inverted.png and /dev/null differ diff --git a/docs/_static/parcelslogo.png b/docs/_static/parcelslogo.png deleted file mode 100755 index c3ecaf30f..000000000 Binary files a/docs/_static/parcelslogo.png and /dev/null differ diff --git a/docs/community/contributing.rst b/docs/community/contributing.rst index a3f5fb633..6581272da 100644 --- a/docs/community/contributing.rst +++ b/docs/community/contributing.rst @@ -18,7 +18,7 @@ There are two primary groups that contribute to Parcels; oceanographers who brin .. note:: - The first component of this documentation is geared to those new to open source. Already familiar with GitHub and open source? Skip ahead to the `Editing Parcels code`_ section. + The first component of this documentation is geared to those new to open source. Already familiar with GitHub and open source? Skip ahead to the `Development`_ section. What is open source? -------------------- @@ -55,26 +55,85 @@ In the `Projects panel `_, uses `Pixi `_ to manage environments and run developer tooling. Pixi is a modern alternative to Conda and also includes other powerful tooling useful for a project like Parcels (`read more `_). It is our sole development workflow - we do not offer a Conda development workflow. Give Pixi a try, you won't regret it! To get started contributing to Parcels: -- `fork the repo `_ -- install the developer version of Parcels following `our developer installation instructions <../installation.rst#installation-for-developers>`_ - - but instead of cloning the Parcels repo, you should clone your fork +**Step 1:** `Install Pixi `_. + +**Step 2:** `Fork the repository `_ + +**Step 3:** Clone your fork and ``cd`` into the repository. + +**Step 4:** Install the Pixi environment + +.. code-block:: bash + + pixi install + +Now you have a development installation of Parcels, as well as a bunch of developer tooling to run tests, check code quality, and build the documentation! Simple as that. + +Pixi workflows +~~~~~~~~~~~~~~ + +You can use the following Pixi commands to run common development tasks. + +**Testing** + +- ``pixi run tests`` - Run the full test suite using pytest +- ``pixi run tests-notebooks`` - Run notebook tests (specifically Argo-related examples) + + +**Documentation** -Now you have a cloned repo that you have full control over, and a conda environment where Parcels is installed in an editable mode (i.e., any changes that you make to the Parcels code will take effect when you use that conda environment to run Python code). +- ``pixi run docs`` - Build the documentation using Sphinx +- ``pixi run docs-watch`` - Build and auto-rebuild documentation when files change (useful for live editing) +- ``pixi run docs-linkcheck`` - Check for broken links in the documentation + +**Code quality** + +- ``pixi run lint`` - Run pre-commit hooks on all files (includes formatting, linting, and other code quality checks) +- ``pixi run typing`` - Run mypy type checking on the codebase + +**Different environments** + +Parcels supports testing against different environments (e.g., different Python versions) with different feature sets. In CI we test against these environments, and you can too locally. For example: + +- ``pixi run -e test-py311 tests`` - Run tests using Python 3.11 +- ``pixi run -e test-py312 tests`` - Run tests using Python 3.12 + +The name of the workflow on GitHub contains the command you have to run locally to recreate the workflow - making it super easy to reproduce CI failures locally. + +**Typical development workflow** + +1. Make your code changes +2. Run ``pixi run lint`` to ensure code formatting and style compliance +3. Run ``pixi run tests`` to verify your changes don't break existing functionality +4. If you've added new features, run ``pixi run typing`` to check type annotations +5. If you've modified documentation, run ``pixi run docs`` to build and verify the docs + +.. tip:: + + You can run ``pixi info`` to see all available environments and ``pixi task list`` to see all available tasks across environments. + + +Changing code +~~~~~~~~~~~~~ From there: - create a git branch, implement, commit, and push your changes - `create a pull request `_ (PR) into ``main`` of the original repo making sure to link to the issue that you are working on. Not yet finished with your feature but still want feedback on how you're going? Then mark it as "draft" and ``@ping`` a maintainer. See our `maintainer notes `_ to see our PR review workflow. -If you made changes to the documentation, and want to render a local version, you can run the command ``sphinx-autobuild --ignore "*.zip" docs docs/_build`` to create a server to automatically rebuild the documentation when you make changes. + Code guidelines ~~~~~~~~~~~~~~~ @@ -85,10 +144,8 @@ Code guidelines - Write clear commit messages that explain the changes you've made. - Include tests for any new code you write. Tests are implemented using pytest and are located in the ``tests`` directory. -- Follow the `NumPy docstring conventions `_ when adding or modifying docstrings. -- Follow the `PEP 8 `_ style guide when writing code. This codebase also uses `flake8 `_ and `isort `_ to ensure a consistent code style. - -If you're comfortable with these code guidelines, and want to enforce them on your local machine before pushing, you can install the Git hooks for the repo by running ``pre-commit install``. This will run tools to check your changes adhere to these guidelines as you make commits. +- Follow the `NumPy docstring conventions `_ when adding or modifying public API docstrings. +- Follow the `PEP 8 `_ style guide when writing code. This codebase also uses additional tooling to enforce additional style guidelines. You can run this tooling with ``pixi run lint``, and see which tooling is run in the ``.pre-commit-config.yaml`` file. ---- diff --git a/docs/community/index.rst b/docs/community/index.rst index 3121d6cab..857152b5c 100644 --- a/docs/community/index.rst +++ b/docs/community/index.rst @@ -10,6 +10,8 @@ See the sections in the primary sidebar and below to explore. contributing Versioning and Deprecation Policies + Release Notes + Parcels v4.0 Migration Guide diff --git a/docs/community/v4-migration.md b/docs/community/v4-migration.md new file mode 100644 index 000000000..21da7fdd7 --- /dev/null +++ b/docs/community/v4-migration.md @@ -0,0 +1,35 @@ +# Parcels v4 migration guide + +```{warning} +Version 4 of Parcels is unreleased at the moment. The information in this migration guide is a work in progress, and is subject to change. If you would like to provide feedback on this migration guide (or generally on the development of v4) please [submit an issue](https://github.com/OceanParcels/Parcels/issues/new/choose). +``` + +## Kernels + +- The Kernel loop has been 'vectorized', so that the input of a Kernel is not one particle anymore, but a collection of particles. This means that `if`-statements in Kernels don't work anymore. Replace `if`-statements with `numpy.where` statements. +- `particle.delete()` is no longer valid. Instead, use `particle.state = StatusCode.Delete`. +- Sharing state between kernels must be done via the particle data (as the kernels are not combined under the hood anymore). +- `particl_dlon`, `particle_dlat` etc have been renamed to `particle.dlon` and `particle.dlat`. +- `particle.dt` is a np.timedelta64 object; be careful when multiplying `particle.dt` with a velocity, as its value may be cast to nanoseconds. +- The `time` argument in the Kernel signature has been removed in the Kernel API, so can't be used. Use `particle.time` instead. +- The `particle` argument in the Kernel signature has been renamed to `particles`. +- `math` functions should be replaced with array compatible equivalents (e.g., `math.sin` -> `np.sin`). Instead of `ParcelsRandom` you should use numpy's random functions. + +## FieldSet + +- `interp_method` has to be an Interpolation function, instead of a string. + +## Particle + +- `Particle.add_variables()` has been replaced by `Particle.add_variable()`, which now also takes a list of `Variables`. + +## ParticleSet + +- `repeatdt` and `lonlatdepth_dtype` have been removed from the ParticleSet. +- ParticleSet.execute() expects `numpy.datetime64`/`numpy.timedelta.64` for `runtime`, `endtime` and `dt`. +- `ParticleSet.from_field()`, `ParticleSet.from_line()`, `ParticleSet.from_list()` have been removed. + +## ParticleFile + +- Particlefiles should be created by `ParticleFile(...)` instead of `pset.ParticleFile(...)` +- The `name` argument in `ParticleFile` has been replaced by `store` and can now be a string, a Path or a zarr store. diff --git a/docs/conf.py b/docs/conf.py index 9af6eb045..e45d42189 100755 --- a/docs/conf.py +++ b/docs/conf.py @@ -43,6 +43,7 @@ "myst_parser", "nbsphinx", "numpydoc", + "sphinxcontrib.mermaid", ] # Add any paths that contain templates here, relative to this directory. @@ -194,8 +195,8 @@ html_static_path = ["_static"] html_theme_options = { "logo": { - "image_light": "parcelslogo.png", - "image_dark": "parcelslogo-inverted.png", + "image_light": "logo-horo.svg", + "image_dark": "logo-horo_dia.svg", }, "use_edit_page_button": True, "github_url": "https://github.com/OceanParcels/parcels", @@ -207,6 +208,7 @@ "type": "fontawesome", } ], + "announcement": "WARNING: This documentation is built for v4 of Parcels, which is unreleased and in active development. Use the version switcher in the bottom right to select your version of Parcels, or see stable docs.", } html_context = { @@ -372,7 +374,6 @@ def linkcode_resolve(domain, info): nbsphinx_thumbnails = { "examples/tutorial_parcels_structure": "_images/parcels_user_diagram.png", "examples/tutorial_timestamps": "_static/calendar-icon.jpg", - "examples/tutorial_jit_vs_scipy": "_static/clock-icon.png", "examples/documentation_homepage_animation": "_images/homepage.gif", "examples/tutorial_interaction": "_static/pulled_particles_twoatractors_line.gif", "examples/documentation_LargeRunsOutput": "_static/harddrive.png", @@ -380,6 +381,7 @@ def linkcode_resolve(domain, info): "examples/documentation_geospatial": "_images/tutorial_geospatial_google_earth.png", "examples/tutorial_kernelloop": "_static/loop-icon.jpeg", } +nbsphinx_execute = "never" # -- Options for LaTeX output --------------------------------------------- latex_elements = { diff --git a/docs/documentation/additional_examples.rst b/docs/documentation/additional_examples.rst index e4c8eefd0..19a3f8f66 100644 --- a/docs/documentation/additional_examples.rst +++ b/docs/documentation/additional_examples.rst @@ -8,13 +8,6 @@ example_brownian.py :language: python :linenos: -example_dask_chunk_OCMs.py --------------------------- - -.. literalinclude:: ../examples/example_dask_chunk_OCMs.py - :language: python - :linenos: - example_decaying_moving_eddy.py ------------------------------- diff --git a/docs/documentation/index.rst b/docs/documentation/index.rst index 7d66a8177..78baeea3a 100644 --- a/docs/documentation/index.rst +++ b/docs/documentation/index.rst @@ -3,9 +3,6 @@ Documentation and Tutorials Parcels has several documentation and tutorial Jupyter notebooks and scripts which go through various aspects of Parcels. Static versions of the notebooks are available below via the gallery in the site, with the interactive notebooks being available either completely online at the following `Binder link `_. Following the gallery of notebooks is a list of scripts which provide additional examples to users. You can work with the example notebooks and scripts locally by downloading :download:`parcels_tutorials.zip ` and running with your own Parcels installation. -.. warning:: - In v3.1.0 we updated kernels in the tutorials to use ``parcels.ParcelsRandom`` instead of ``from parcels import ParcelsRandom``. Due to our C-conversion code, using ``parcels.ParcelsRandom`` only works with v3.1.0+. When browsing/downloading the tutorials, it's important that you are using the documentation corresponding to the version of Parcels that you have installed. You can find which parcels version you have installed by doing ``import parcels`` followed by ``print(parcels.__version__)``. If you don't want to use the latest version of Parcels, you can browse prior versions of the documentation by using the version switcher in the bottom right of this page. - .. nbgallery:: :caption: Overview :name: tutorial-overview @@ -23,19 +20,16 @@ Parcels has several documentation and tutorial Jupyter notebooks and scripts whi ../examples/tutorial_nemo_curvilinear.ipynb ../examples/tutorial_nemo_3D.ipynb ../examples/tutorial_croco_3D.ipynb - ../examples/tutorial_NestedFields.ipynb ../examples/tutorial_timevaryingdepthdimensions.ipynb ../examples/tutorial_periodic_boundaries.ipynb ../examples/tutorial_interpolation.ipynb ../examples/tutorial_unitconverters.ipynb - ../examples/tutorial_timestamps.ipynb .. nbgallery:: :caption: Creating ParticleSets :name: tutorial-particlesets - ../examples/tutorial_jit_vs_scipy.ipynb ../examples/tutorial_delaystart.ipynb diff --git a/docs/examples/documentation_LargeRunsOutput.ipynb b/docs/examples/documentation_LargeRunsOutput.ipynb index f33e42bf0..bd8876b09 100644 --- a/docs/examples/documentation_LargeRunsOutput.ipynb +++ b/docs/examples/documentation_LargeRunsOutput.ipynb @@ -3,7 +3,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "e2d8b054", + "id": "0", "metadata": {}, "source": [ "# Dealing with large output files\n" @@ -12,7 +12,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "eb5792d0", + "id": "1", "metadata": {}, "source": [ "You might imagine that if you followed the instructions [on the making of parallel runs](https://docs.oceanparcels.org/en/latest/examples/documentation_MPI.html) and the loading of the resulting dataset, you could just use the `dataset.to_zarr()` function to save the data to a single `zarr` datastore. This is true for small enough datasets. However, there is a bug in `xarray` which makes this inefficient for large data sets.\n", @@ -23,7 +23,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "4010c8d0", + "id": "2", "metadata": {}, "source": [ "## Why are we doing this? And what chunk sizes should we choose?\n" @@ -32,7 +32,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "46cb22d5", + "id": "3", "metadata": {}, "source": [ "If you are running a relatively small case (perhaps 1/10 the size of the memory of your machine), nearly anything you do will work. However, as your problems get larger, it can help to write the data into a single zarr datastore, and to chunk that store appropriately.\n", @@ -57,7 +57,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "0d5d3385", + "id": "4", "metadata": {}, "source": [ "## How to save the output of an MPI ocean parcels run to a single zarr dataset\n" @@ -66,7 +66,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "b5001615", + "id": "5", "metadata": {}, "source": [ "First, we need to import the necessary modules, specify the directory `inputDir` which contains the output of the parcels run (the directory that has proc01, proc02 and so forth), the location of the output zarr file `outputDir` and a dictionary giving the chunk size for the `trajectory` and `obs` coordinates, `chunksize`.\n" @@ -75,7 +75,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2622a91d", + "id": "6", "metadata": {}, "outputs": [], "source": [ @@ -105,7 +105,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "33383cbe", + "id": "7", "metadata": {}, "source": [ "Now for large datasets, this code can take a while to run; for 36 million trajectories and 250 observations, it can take an hour and a half. I prefer not to accidentally destroy data that takes more than an hour to create, so I put in a safety check and only let the code run if the output directory does not exist.\n" @@ -114,7 +114,7 @@ { "cell_type": "code", "execution_count": null, - "id": "51a1414d", + "id": "8", "metadata": {}, "outputs": [], "source": [ @@ -128,7 +128,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "b8818397", + "id": "9", "metadata": {}, "source": [ "It will often be useful to change the [dtype](https://numpy.org/doc/stable/reference/generated/numpy.dtype.html) of the output data. Doing so can save a great deal of disk space. For example, the input data for this example is 88Gb in size, but by changing lat, lon and z to single precision, I can make the file about half as big.\n", @@ -142,8 +142,8 @@ }, { "cell_type": "code", - "execution_count": 14, - "id": "9ca2bb15", + "execution_count": null, + "id": "10", "metadata": {}, "outputs": [], "source": [ @@ -158,7 +158,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "c26e9ba7", + "id": "11", "metadata": {}, "source": [ "Now we need to read in the data as discussed in the section on making an MPI run. However, note that `xr.open_zarr()` is given the `decode_times=False` option, which prevents the time variable from being converted into a datetime64[ns] object. This is necessary due to a bug in xarray. As discussed above, when the data set is read back in, time will again be interpreted as a datetime.\n" @@ -166,19 +166,10 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "e7dd9f61", + "execution_count": null, + "id": "12", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "opening data from multiple process files\n", - " done opening in 6.37\n" - ] - } - ], + "outputs": [], "source": [ "print(\"opening data from multiple process files\")\n", "tic = time.time()\n", @@ -195,7 +186,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "f93a60ff", + "id": "13", "metadata": {}, "source": [ "Now we can take advantage of the `.astype` operator to change the type of the variables. This is a lazy operator, and it will only be applied to the data when the data values are requested below, when the data is written to a new zarr store.\n" @@ -203,8 +194,8 @@ }, { "cell_type": "code", - "execution_count": 16, - "id": "6819cd84", + "execution_count": null, + "id": "14", "metadata": {}, "outputs": [], "source": [ @@ -215,7 +206,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "f8410589", + "id": "15", "metadata": {}, "source": [ "The dataset is then rechunked to our desired shape. This does not actually do anything right now, but will when the data is written below. Before doing this, it is useful to remove the per-variable chunking metadata, because of inconsistencies which arise due to (I think) each MPI process output having a different chunking. This is explained in more detail in https://github.com/dcs4cop/xcube/issues/347\n" @@ -223,19 +214,10 @@ }, { "cell_type": "code", - "execution_count": 17, - "id": "9a56c3cc", + "execution_count": null, + "id": "16", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "re-chunking\n", - " done in 9.15590238571167\n" - ] - } - ], + "outputs": [], "source": [ "print(\"re-chunking\")\n", "tic = time.time()\n", @@ -249,7 +231,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "6f59018b", + "id": "17", "metadata": {}, "source": [ "The dataset `dataIn` is now ready to be written back out with dataIn.to_zarr(). Because this can take a while, it is nice to delay computation and then compute() the resulting object with a progress bar, so we know how long we have to get a cup of coffee or tea.\n" @@ -257,18 +239,10 @@ }, { "cell_type": "code", - "execution_count": 19, - "id": "de5415ed", + "execution_count": null, + "id": "18", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[########################################] | 100% Completed | 33m 9ss\n" - ] - } - ], + "outputs": [], "source": [ "delayedObj = dataIn.to_zarr(outputDir, compute=False)\n", "with ProgressBar():\n", @@ -278,7 +252,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "9080025f", + "id": "19", "metadata": {}, "source": [ "We can now load the zarr data set we have created, and see what is in it, compared to what was in the input dataset. Note that since we have not used \"decode_times=False\", the time coordinate appears as a datetime object.\n" @@ -286,56 +260,10 @@ }, { "cell_type": "code", - "execution_count": 20, - "id": "3157592c", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The original data\n", - " \n", - "Dimensions: (trajectory: 39363539, obs: 250)\n", - "Coordinates:\n", - " * obs (obs) int32 0 1 2 3 4 5 6 7 ... 242 243 244 245 246 247 248 249\n", - " * trajectory (trajectory) int64 0 22 32 40 ... 39363210 39363255 39363379\n", - "Data variables:\n", - " age (trajectory, obs) float32 dask.array\n", - " lat (trajectory, obs) float64 dask.array\n", - " lon (trajectory, obs) float64 dask.array\n", - " time (trajectory, obs) datetime64[ns] dask.array\n", - " z (trajectory, obs) float64 dask.array\n", - "Attributes:\n", - " Conventions: CF-1.6/CF-1.7\n", - " feature_type: trajectory\n", - " ncei_template_version: NCEI_NetCDF_Trajectory_Template_v2.0\n", - " parcels_mesh: spherical\n", - " parcels_version: 2.3.2.dev137 \n", - "\n", - "The new dataSet\n", - " \n", - "Dimensions: (trajectory: 39363539, obs: 250)\n", - "Coordinates:\n", - " * obs (obs) int32 0 1 2 3 4 5 6 7 ... 242 243 244 245 246 247 248 249\n", - " * trajectory (trajectory) int64 0 22 32 40 ... 39363210 39363255 39363379\n", - "Data variables:\n", - " age (trajectory, obs) float32 dask.array\n", - " lat (trajectory, obs) float32 dask.array\n", - " lon (trajectory, obs) float32 dask.array\n", - " time (trajectory, obs) datetime64[ns] dask.array\n", - " z (trajectory, obs) float32 dask.array\n", - "Attributes:\n", - " Conventions: CF-1.6/CF-1.7\n", - " feature_type: trajectory\n", - " ncei_template_version: NCEI_NetCDF_Trajectory_Template_v2.0\n", - " parcels_mesh: spherical\n", - " parcels_version: 2.3.2.dev137\n" - ] - } - ], + "execution_count": null, + "id": "20", + "metadata": {}, + "outputs": [], "source": [ "dataOriginal = xr.concat(\n", " [xr.open_zarr(f) for f in files],\n", diff --git a/docs/examples/documentation_MPI.ipynb b/docs/examples/documentation_MPI.ipynb index eab6293d8..ee1f7e3df 100644 --- a/docs/examples/documentation_MPI.ipynb +++ b/docs/examples/documentation_MPI.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Parallelisation with MPI and Field chunking with dask\n" + "# Parallelisation with MPI\n" ] }, { @@ -159,292 +159,6 @@ "For small projects, the above instructions are sufficient. If your project is large, then it is helpful to combine the `proc*` directories into a single zarr dataset and to optimise the chunking for your analysis. What is \"large\"? If you find yourself running out of memory while doing your analysis, saving the results, or sorting the dataset, or if reading the data is taking longer than you can tolerate, your problem is \"large.\" Another rule of thumb is if the size of your output directory is 1/3 or more of the memory of your machine, your problem is large. Chunking and combining the `proc*` data in order to speed up analysis is discussed [in the documentation on runs with large output](https://docs.oceanparcels.org/en/latest/examples/documentation_LargeRunsOutput.html).\n" ] }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Chunking the FieldSet with dask\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The basic idea of field-chunking in Parcels is that we use the `dask` library to load only these regions of the `Field` that are occupied by `Particles`. The advantage is that if different MPI processors take care of Particles in different parts of the domain, each only needs to load a small section of the full `FieldSet` (although note that this load-balancing functionality is still in [development](#Future-developments:-load-balancing)). Furthermore, the field-chunking in principle makes the `indices` keyword superfluous, as Parcels will determine which part of the domain to load itself.\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The default behaviour is for `dask` to control the chunking, via a call to `da.from_array(data, chunks='auto')`. The chunksizes are then determined by the layout of the NetCDF files.\n", - "\n", - "However, in tests we have experienced that this may not necessarily be the most efficient chunking. Therefore, Parcels provides control over the chunksize via the `chunksize` keyword in `Field` creation, which requires a dictionary that sets the typical size of chunks for each dimension.\n", - "\n", - "It is strongly encouraged to explore what the best value for chunksize is for your experiment, which will depend on the `FieldSet`, the `ParticleSet` and the type of simulation (2D versus 3D). As a guidance, we have found that chunksizes in the zonal and meridional direction of approximately around 128 to 512 are typically most effective. The binning relates to the size of the model and its data size, so power-of-two values are advantageous but not required.\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The notebook below shows an example script to explore the scaling of the time taken for `pset.execute()` as a function of zonal and meridional `chunksize` for a dataset from the [Copernicus Marine Service](http://marine.copernicus.eu/) portal.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "pycharm": { - "is_executing": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Populating the interactive namespace from numpy and matplotlib\n" - ] - } - ], - "source": [ - "%pylab inline\n", - "import os\n", - "import time\n", - "from datetime import timedelta\n", - "from glob import glob\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import psutil\n", - "\n", - "import parcels\n", - "\n", - "\n", - "def set_cms_fieldset(cs):\n", - " data_dir_head = \"/data/oceanparcels/input_data\"\n", - " data_dir = os.path.join(data_dir_head, \"CMS/GLOBAL_REANALYSIS_PHY_001_030/\")\n", - " files = sorted(glob(data_dir + \"mercatorglorys12v1_gl12_mean_201607*.nc\"))\n", - " variables = {\"U\": \"uo\", \"V\": \"vo\"}\n", - " dimensions = {\"lon\": \"longitude\", \"lat\": \"latitude\", \"time\": \"time\"}\n", - "\n", - " if cs not in [\"auto\", False]:\n", - " cs = {\"time\": (\"time\", 1), \"lat\": (\"latitude\", cs), \"lon\": (\"longitude\", cs)}\n", - " return parcels.FieldSet.from_netcdf(files, variables, dimensions, chunksize=cs)\n", - "\n", - "\n", - "func_time = []\n", - "mem_used_GB = []\n", - "chunksize = [128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048, 2610, \"auto\", False]\n", - "for cs in chunksize:\n", - " fieldset = set_cms_fieldset(cs)\n", - " pset = parcels.ParticleSet(\n", - " fieldset=fieldset,\n", - " pclass=parcels.JITParticle,\n", - " lon=[0],\n", - " lat=[0],\n", - " repeatdt=timedelta(hours=1),\n", - " )\n", - "\n", - " tic = time.time()\n", - " pset.execute(parcels.AdvectionRK4, dt=timedelta(hours=1))\n", - " func_time.append(time.time() - tic)\n", - " process = psutil.Process(os.getpid())\n", - " mem_B_used = process.memory_info().rss\n", - " mem_used_GB.append(mem_B_used / (1024 * 1024))" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "pycharm": { - "is_executing": true - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 1, figsize=(15, 7))\n", - "\n", - "ax.plot(chunksize[:-2], func_time[:-2], \"o-\")\n", - "ax.plot([0, 2800], [func_time[-2], func_time[-2]], \"--\", label=chunksize[-2])\n", - "ax.plot([0, 2800], [func_time[-1], func_time[-1]], \"--\", label=chunksize[-1])\n", - "plt.xlim([0, 2800])\n", - "plt.legend()\n", - "ax.set_xlabel(\"chunksize\")\n", - "ax.set_ylabel(\"Time spent in pset.execute() [s]\")\n", - "plt.show()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The plot above shows that in this case, `chunksize='auto'` and `chunksize=False` (the two dashed lines) are roughly the same speed, but that the fastest run is for `chunksize=(1, 256, 256)`. But note that the actual thresholds and numbers depend on the `FieldSet` used and the specifics of your experiment.\n", - "\n", - "Furthermore, one of the major advantages of field chunking is the efficient utilization of memory. This permits the distribution of the particle advection to many cores, as otherwise the processing unit (e.g. a CPU core; a node in a cluster) would exhaust the memory rapidly. This is shown in the following plot of the memory behaviour.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "pycharm": { - "is_executing": true - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 1, figsize=(15, 12))\n", - "ax.plot(chunksize[:-2], mem_used_GB[:-2], \"--\", label=\"memory_blocked [MB]\")\n", - "ax.plot([0, 2800], [mem_used_GB[-2], mem_used_GB[-2]], \"x-\", label=\"auto [MB]\")\n", - "ax.plot([0, 2800], [mem_used_GB[-1], mem_used_GB[-1]], \"--\", label=\"no chunking [MB]\")\n", - "plt.legend()\n", - "ax.set_xlabel(\"chunksize\")\n", - "ax.set_ylabel(\"Memory blocked in pset.execute() [MB]\")\n", - "plt.show()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "It can clearly be seen that with `chunksize=False` (green line), all Field data are loaded in full directly into memory, which can lead to MPI-run simulations being aborted for memory reasons. Furthermore, one can see that even the automatic method is not optimal, and optimizing the chunksize for a specific hydrodynamic dataset can make a large difference to the memory used.\n", - "\n", - "It may - depending on your simulation goal - be necessary to tweak the chunksize to leave more memory space for additional particles that are being simulated. Since particles and fields share the same memory space, lower memory utilisation by the `FieldSet` means more memory available for a larger `ParticleSet`.\n", - "\n", - "Also note that the above example is for a 2D application. For 3D applications, the `chunksize=False` will almost always be slower than `chunksize='auto'` or any dictionary, and is likely to run into insufficient memory issues, raising a `MemoryError`. The plot below shows the same analysis as above, but this time for a set of simulations using the full 3D Copernicus Marine Service code. In this case, the `chunksize='auto'` is about two orders of magnitude faster than running without chunking, and about 7.5 times faster than with minimal chunk capacity (i.e. `chunksize=(1, 128, 128)`).\n", - "\n", - "Choosing too small chunksizes can make the code slower, again highlighting that it is wise to explore which chunksize is best for your experiment before you perform it.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "pycharm": { - "is_executing": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Computed 3D field advection.\n" - ] - } - ], - "source": [ - "from parcels import AdvectionRK4_3D\n", - "\n", - "\n", - "def set_cms_fieldset_3D(cs):\n", - " data_dir_head = \"/data/oceanparcels/input_data\"\n", - " data_dir = os.path.join(data_dir_head, \"CMS/GLOBAL_REANALYSIS_PHY_001_030/\")\n", - " files = sorted(glob(data_dir + \"mercatorglorys12v1_gl12_mean_201607*.nc\"))\n", - " variables = {\"U\": \"uo\", \"V\": \"vo\"}\n", - " dimensions = {\n", - " \"lon\": \"longitude\",\n", - " \"lat\": \"latitude\",\n", - " \"depth\": \"depth\",\n", - " \"time\": \"time\",\n", - " }\n", - "\n", - " if cs not in [\"auto\", False]:\n", - " cs = {\n", - " \"time\": (\"time\", 1),\n", - " \"depth\": {\"depth\", 1},\n", - " \"lat\": (\"latitude\", cs),\n", - " \"lon\": (\"longitude\", cs),\n", - " }\n", - " return parcels.FieldSet.from_netcdf(files, variables, dimensions, chunksize=cs)\n", - "\n", - "\n", - "chunksize_3D = [128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048, 2610, \"auto\", False]\n", - "func_time3D = []\n", - "for cs in chunksize_3D:\n", - " fieldset = set_cms_fieldset_3D(cs)\n", - " pset = parcels.ParticleSet(\n", - " fieldset=fieldset,\n", - " pclass=parcels.JITParticle,\n", - " lon=[0],\n", - " lat=[0],\n", - " repeatdt=timedelta(hours=1),\n", - " )\n", - "\n", - " tic = time.time()\n", - " pset.execute(AdvectionRK4_3D, dt=timedelta(hours=1))\n", - " func_time3D.append(time.time() - tic)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "pycharm": { - "is_executing": true - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 1, figsize=(15, 7))\n", - "\n", - "ax.plot(chunksize[:-2], func_time3D[:-2], \"o-\")\n", - "ax.plot([0, 2800], [func_time3D[-2], func_time3D[-2]], \"--\", label=chunksize_3D[-2])\n", - "plt.xlim([0, 2800])\n", - "plt.legend()\n", - "ax.set_xlabel(\"chunksize\")\n", - "ax.set_ylabel(\"Time spent in pset.execute() [s]\")\n", - "plt.show()" - ] - }, { "attachments": {}, "cell_type": "markdown", diff --git a/docs/examples/documentation_advanced_zarr.ipynb b/docs/examples/documentation_advanced_zarr.ipynb index c79a6157a..971768292 100644 --- a/docs/examples/documentation_advanced_zarr.ipynb +++ b/docs/examples/documentation_advanced_zarr.ipynb @@ -3,7 +3,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "98ac56f8-9510-4eeb-8732-e894af58e290", + "id": "0", "metadata": { "papermill": { "duration": 0.058812, @@ -27,7 +27,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "6796b369-d5ce-43f2-bcb2-47d33985ec03", + "id": "1", "metadata": {}, "source": [ "## A simple flow field\n", @@ -37,8 +37,8 @@ }, { "cell_type": "code", - "execution_count": 1, - "id": "e129151b-56de-47de-ab0e-b204f6c892e6", + "execution_count": null, + "id": "2", "metadata": {}, "outputs": [], "source": [ @@ -49,8 +49,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "e21f6731-be72-4cae-8abb-deb116ef1cad", + "execution_count": null, + "id": "3", "metadata": {}, "outputs": [], "source": [ @@ -59,472 +59,10 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "2a351cd0-d1fc-4ecb-b208-f7604bcb7bec", + "execution_count": null, + "id": "4", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:  (lat: 101, lon: 101)\n",
-       "Coordinates:\n",
-       "  * lat      (lat) float64 -20.0 -19.6 -19.2 -18.8 -18.4 ... 18.8 19.2 19.6 20.0\n",
-       "  * lon      (lon) float64 -20.0 -19.6 -19.2 -18.8 -18.4 ... 18.8 19.2 19.6 20.0\n",
-       "Data variables:\n",
-       "    U        (lat, lon) float64 0.4693 0.1444 0.6768 ... -0.2509 -0.1513 -0.425\n",
-       "    V        (lat, lon) float64 -0.4215 -0.3119 -0.2634 ... 0.02258 0.4363
" - ], - "text/plain": [ - "\n", - "Dimensions: (lat: 101, lon: 101)\n", - "Coordinates:\n", - " * lat (lat) float64 -20.0 -19.6 -19.2 -18.8 -18.4 ... 18.8 19.2 19.6 20.0\n", - " * lon (lon) float64 -20.0 -19.6 -19.2 -18.8 -18.4 ... 18.8 19.2 19.6 20.0\n", - "Data variables:\n", - " U (lat, lon) float64 0.4693 0.1444 0.6768 ... -0.2509 -0.1513 -0.425\n", - " V (lat, lon) float64 -0.4215 -0.3119 -0.2634 ... 0.02258 0.4363" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAG0CAYAAAD6ncdZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9d3gcx5Xu/euenDAzyBkgmHMOkiiKyqJytBxkW7acvd7g/Xb32r571772tddr71ralfPalmRbtmTlnMVMijlngshhgMEMJsfu748hMKgGBhhKpERq532eechCn66urq6qPl3nnPdIqqqqFFBAAQUUUEABBVwgkD/oBhRQQAEFFFBAAQWcCQrKSwEFFFBAAQUUcEZIp9N87nOf47/+679oaWl5368vFcxGBRRQQAEFFFDAmWDlypVs3bqVdDoNwM0338z999/PpEmT3pfrF5SXAgoooIACCijgjJBOp/nMZz7D7NmzufHGG5k1axaSJL1v1y8oLwUUUEABBRRQwAWFgs9LAQUUUEABBRRwQaGgvBRQQAEFFFBAARcUCspLAQUUUEABBRRwQaGgvBRQQAEFFFBAARcUCspLAQUUUEABBRRwQeGCUV5+8IMfsHTpUhwOB+Xl5dx6660cPXpUkFFVlW9/+9tUV1djsVhYvXo1Bw8e/IBaXEABBRRQQAEFnAtcMKHS1113HR/96EdZunQpqVSKb33rW+zfv59Dhw5hs9kA+OEPf8j/+3//j4ceeohp06bxve99j/Xr13P06FEcDkde11EUha6uLhwOx/sas15AAQUUUMCFBVVVCQaDVFdXI8vnbi8gFouRSCTOSl1GoxGz2XxW6vpAoV6g8Hg8KqCuW7dOVVVVVRRFraysVP/1X/91WCYWi6lOp1P9xS9+kXe97e3tKlD4FX6FX+FX+BV+ef3a29vP+jtuCNFoVK0s1521tlZWVqrRaHTC637/+99XlyxZotrtdrWsrEy95ZZb1CNHjkx43tq1a9VFixapJpNJnTRpkvrzn/98lMwTTzyhzpw5UzUajerMmTPVp5566oz7Rc8FisHBQQCKi4sBOHXqFD09PVxzzTXDMiaTicsuu4zNmzfzxS9+ccx64vE48Xh8uKye3oiaee//QWfMaKdlO4LCOdFKy/D/5bRYX7hC7NKytR1CObCwWijLSUUoh2rF81WNMh93iWVZo4w7OlWhHKwVd49KD6TE43Xi9VIjFHJ7h9g2VSdey+wT6wo0GIVyWixS1KqRb8x9bQCLV7wXs1fsbGNQrM87W6zA2iu2P9CY7Ux9VLxW6T7xDwMzLUJZe+9xJ+Met/aK5aRVLKc05aRLvFdbu/jcBmeJ92rwiX1XfDB7vpTW9JvmORm94r32rhBvJloptk3SjDGTXywbwmI5JXYdSbtYtnrE9sUd4r2GmsTnLDuzDaj7k9jRrTeLE8Tgjgnlsr+IjfFNE8+3d4tt8U8R22IQpz51L/YJ5ZP3lAllbV/pkmJZ0ay4iZLsvTqPiG0bnCH2Q8UWsW0xt3jvsviYcR0X+8I/TZwf7iPiOAjVisftHeL57VdpHqw4vXC0i2VhHIjdTOl+8dp9C8S6tfOjfJfYsYNN4uKiXSeDjeIFDYOaXXRNsfZNcRDrBzULhD8gFH2XZyjw08kYe576bt47++8GiUSCHk+a1p2NFDne2+5OIKjQsLiFRCIx4e7LunXr+OpXvypYO6655hrB2qHFqVOnuP766/n85z/PH/7wBzZt2sRXvvIVysrKuOOOOwDYsmULd999N9/97ne57bbbePrpp/nIRz7Cxo0bWb58ed73ckEqL6qq8vWvf52VK1cyZ84cAHp6egCoqKgQZCsqKmhtbc1Z1w9+8AO+853vjPq7zmgeVl70mhVIb8g+dO1Ooc4odqleNuU8F0DWrADa87UvRZ1mvMmaSagzipNWZxIF9AZxhRt1PdNI2fGVF71eW5dGW9EUR13blPvamfrEe9EbxMV81PVNYudo268zZR+WTrPw6vWafjOKdY16Dpq2aj8DdJp7V7TymnLaPP5zky3ivcpRzTgzjFBeZE2/afpJr9P2i2ZMaseYdoxrn5PmBa1OcO8TjVHZolFerCOUTr1OIys2Tqd56Wnnm84knj+qLWaxLTqNMqLX3LyseQGM6itNWTKI5ZH3qjNq700z3g2athk1yovmWvpRY1IzP/Ta+aU9rmmr5l4lzRzSjnlhjGuUl1HzTTMGtfNDr9c8Z+P4yousnU8xzUI5qq80fa1dIGTxetq+fD9cDOwOCbvjvV1H0Wpt4+CVV14Ryr/73e8oLy9n586drFq1asxzfvGLX1BfX8/9998PwMyZM9mxYwc//vGPh5WX+++/n6uvvppvfOMbAHzjG99g3bp13H///fzpT3/Ku30XjMPuSPzVX/0V+/btG/NGtYNIVdVxB9Y3vvENBgcHh3/t7e3D5yUCA2e34SOQTETyllVVlWQ4QMTTweDubXmdEx30EA/73m3zJoSSTk4sdBrpRJxUNMTJA8+RTp0du+0QVFUlHh8kkQiSDAcmPgFIDJ7Zc40HvPm3R1FQkmfQN9HMOFDT6QkkT8sHwxMLvY9QUvnfK2R3Ns93qIqCkkpNLHieQlXSpNNnd659mKAqygUzFoeQVpWz8gMIBALCb6T1IRe01o6xsGXLFsH6AXDttdeyY8cOkqfXxVwymzdvPqP+uOB2Xr72ta/x3HPPsX79empra4f/XlmZ2evu6emhqqpq+O8ej2fUbsxImEwmTCbTqL9H9+ylfd9LzL76awxOLxWOOU9kXyDq6U8rj/cQNksprpC45952d51QLj6SQlXSHHj7QSoallI5c7WgXKU1X2axcgjs3E5g+1aSPh+zm26jJJwdaIF68YsgaZWI+no48frPsZTWsCB6r1B/0iZ+3VW81k08Hcasz+ztB+Zlt8HllDi51dPbPD2n3iHoa6Nu9UeEuqPiDjrxUpXIwUMEt20n3taOe8EK+peYkU5/ImrNCyUHVFRFYaB9H4mQj6Lpq4XjaZOoa7dfYcb7xstEu5tJ9HkoXnAL1gVzho9LKbFvFFmlf/0rhJqPQipN7W2fwejMTMT+uWJj5GTmRTtwbDvd219i3ux7KHJmn2XLDWLd+pBEwttH79OP4Zi3iL5TbVRdfSfy6c/XRJF4r0gQOrQf/+Z16J0u0pEwNZ/OmjZt3eKXX8KhJ3BgF96tb2OpacQ2dQb26bOz149k5MOD3fQ0BVASCdREAiSJ0vmLkaRs38mafnG0n17Q+k8x0HmA6pU3C8f900TlP2mH5KAPz5vPYyqtwGYsxz114fDxkoPiQjg42UQ6EaP/yFZigx7c8+4UjsfcYv2Tns0ocurphbblzuyk8CzMLlnh9mYiG/0ZxU9RkE1mTI3zhDHZtyBbbzoaRQmGSMciKNEoSjyGrnouki47J6QhfUWVGHjzNcKdJzA1TcI8qRFT0yRa7ygX2qoLK/i2rGNg89uAhNGmMP8ry2i8dgoAe1+YKfadQ5xTrkM64oNeQh3H8Nj0uOYuHT429Q+i2cZTFSMVj2B1VyHJOvQxsS6fcCmZlh2voTObcS+6BIPTjaTRj1PWbF+qqkpX2xZMrjLs1VOQJIlwjbguTvm9aDKLO42Aiu70lsvx+8TFy3EwU1aVNANHtyMZTBjdxRhcJcTcZuE5ac1p9hNxvC27KWlchKzTj5r7oVpRvnpjVolWlDSxUnFnpP5V0f43OMlC54HXqZ13LQA9F4tmkOKj2XuPhvo4ZT2Ec9oCLBV1SJJE1YbMh1IqLT6jcwkFFUW7hfUu6gCoqxPfS//yL//Ct7/97ZznjWXtGAs9PT1jWj9SqRT9/f1UVVXllBmynuSLC0Z5UVWVr33tazz99NOsXbt2VNrtSZMmUVlZyeuvv87ChZmFNJFIsG7dOn74wx+e8fXa9r6I0VpELNiP0VU6rmwqFedk6xs01V+JxVk5rizAQO8RUokwFnvZhNuNiT4Pfc89hZpI4LrsCor108aVjw50c+L5n5OKhYgP9pGIBzGZtW9OES2+bcwou2LCdgP4Pcdo3vs0juIG0okoepM1p2zSO0DfHx9FiURx33A9JUuuyimrKgr9p3bTtf91YgEPJnsJNRrlZVRbtqxnYN3rAFTc+QnMS3JPKiWdouu5PxM4sAuA6us/Nqy4jIV0Ikrbhifwn9wNgM/XLCgv2rb7Nm/E+8ZLqMkkKAolcy9m1F75kLyq4t+0jv5XnwdVxX3ZVZTf8pHcbUkl6H7hWQb3vAOAtWEK5tr6MWWN5iLCBzYTfOcdUFVMdXUY58tY66disI89DlKJKG37X6S3eSuyzkDF8mvRGUYr9ABKIk7f2rcY2Po2aipFvLgMw7RlOdueSITpeOdV+g9vRUnGkA1m0rNuRqc35jxnoP8YzSdeJRbxctGqb5JrmTKXVuDduo3QtsxupHnaNIxpE5aGJmTD6PrTkRD9b7xA6Mj+TF+VVaBbCkWT5wwrmUOQJImSK9eQeO0vBN54m4BOR+XXvgw20YFHkmWKL7kcS0MT3U8/Stw/wO4HttCztZ3a1ZNQkpPHbAtA5OAhup54nrjfk2lPSYWgvGhhtDpp3/E8g51HsZfVU7nwKhxVU3LKl116Lc2//je8W9fimDGPqqtuR2+1jykrSRKOuhkc+cuPMFgcFM9cTlXVEoyW3L4csqxj7+FHqa1aRqk797okyTqsDVNpf+zXJAYy92pY8RmKK2flrltnIBYaYN+LP6Ju3nVUFs8VFHAtYlEfzYdewD/QTEXNIuwrbs8pm2mTzEDHAXRGC1UzxjaBDMFiL0OfsnHyT/djdJdRPHs5leqicdtzvqO9vZ2ioux6MNYH/EgMWTs2btw4Yd1jWT+0fz9TC8lYuGCUl69+9as8+uijPPvsszgcjmEtzel0YrFYkCSJv/3bv+X73/8+U6dOZerUqXz/+9/HarXy8Y9//IyvN2npnRTXzkGSJK1f2igkUxGWzvsCer15QlmAZDzIwsu/jtHsYDxjgZJO0fvkHzCWV1K0ZBn2eQuRNud+wEoqSaDtMLWX3IalrBZTUQmmjvHNEZIkMaVkZR6tznwJp1Nxllz3TYzmIuKm3JNXSSXx/PFhZJMZx0UrsMycMe4AlWQZd/1cbMW1xMMDJKNBVEUZ3qXRor9tN4PNW3EuuwTLpMlYGifn7HtVUejfux6d2Ur5VbdgdBVjdo+vZMZ8vRRPXkjpjOXIBhNuT+6pEj16lHQkjPvi1SCBvsiJc9riMe9VVVUGt28m2nIS5/JLMLiKMdfUIWv9hYblFfpbd6G3OSi74sbM7kJZJXrb2C8Vg8lG2V134Vi+HO9TT2FuaiLUfIRIxymqrrlzzHNUVKqmXUbl1JWoyvgjONnXh7GkjPKrbiYdiyLpdJRPXZ1T3mi0UTn/SlwNc4j5e0kEfYzyltSguHQaNkcl/b0HkXWGnHI6i42yj96NffFi+p/4C+bGRnxb1xM8tJfKm+8e3ZaSMmru/gyRlhN4Xn0WY2k5wVOHKJoyttIrSRIlH7kdNR5HiUbp++3DKEsuw7101Shlx1LbQOMX/x5b8Gkm3TCNro1tnHrxGD07NmNtmIJr4QrsTdOFc6yzZ1EmNTHYfAD/id0Yq0Vn/lHtkXU0XfoJTrz9EIGe49TbcyvfAHq7g4prbqXr2UdJeD0wgZnEVFRM3aV30PrWo3gPbaGm7qLx2yPJVJTOJhLtR3VNHVfW6C6h8dNfo+PJh0j4Bzix50kWXdGI3pj746dq1mo8JzbTsf81Si5qwmjKrUiZLW5mLPwYvR07MVlc5GPMtBSV0b7nRayuSvRVM8aVLV1yOeHOZoKnDhP39yOZ33/FRUHJ6/0yUR0ARUVFgvIyHnJZO8ZCZWXlqB0Uj8eDXq+npKRkXJnxLCRj4YLhecn10vvd737HvffeC2ReDN/5znf45S9/ic/nY/ny5fz0pz8dd5tLi0AggNPppPY//y+yJbP1OPX34lRQRjiPxYvFxTVpFdspaXo3VCUet3dptpEPDGZlY330L3JgLsm+aLURBc5m0a6tajx4JUWsP1IptlfROKKGq7Pn6zRm0KRm7Ujac0fIRHvaKd4TxGmrHX52xz8pbs26D4kLQFwzl/SaHVlDKHu9VDyCIyxuDfcuEW+marP43AzBbPnEJ8QvDVuLeG6sVBOx0yf2a6RWXEbMveK9mCdwk9Fu4cfdYlnrAByZIj5n5x5R2XGdzA6MnmWZk1VFQYlFcQTGjgwYgn+GxjFb48Rq7Bf7RtHoEymneDOqTjy/6m2xb3pXiOfLcbFvzV6xPNKk4DopttXSl3mm6XQSVU3Tfp/4XMveEMtDjp2qopCMDEK1qADEShglr6bTpKMR1HSa4OtvUXnpjcind460i2ekRvyLEosROXIEyaDHNnv0OuRoyd6rb3pCMGE5j4r9nrgsY6pQ4kmiR9owWhcKx00aFzdDMLMm+o5sJx2PUCxX4yybnG2bXhNZFcn4gRzb9wTVjReRXNIoHC8+Li4+5o6Q8EHScZ1LlD+clddHM89NUVIE/G2k59QLu7YVb4vheb1XZF5k/ua92ComUdYpPsdwtTj+I+XjO1qbfZoxHUzj6dyDqqSpqFvM4CRxwtm6xHHWP08mHQkzuH0L5roG6mKZfkwlY+x44n8zODiYtzJwphh6J7UfqTkr0UZ1Mzrzaq/W2jF16vgKKsA//dM/8fzzz3Po0KHhv335y19mz549bNmyBYC7776bYDDISy+9NCyzZs0aXC7XGTnsXjA7L/noWJIk8e1vf3tc292FBLu5jFCJ64NuxruCpbIOlz04seC7hN5khfB7/Q75cEOSZXRWG+Tnx3xBQ6czAAZymeq0kGQZo91NPi6tkk6H3p7R3KsvH98coYVsNmNfsCC/Nul0EwsBssmAbf5kksfzqFOSKJ6ZMevZuyd2CpckiWlzb0eSdeTj1n6mW/2yrMdV3MSgKbfZcCRcTfNP/29ih9IzRXnNgjOS11ltuFddmbnnQx/+tWciawdkAl46Ozt55JFHAPjSl77Egw8+yNe//nU+//nPs2XLFn7zm98ISsnf/M3fsGrVKn74wx9yyy238Oyzz/LGG2/kZZIaiQvXaFdAAQUUUMBZhyTnp0T9T8QHybo+5LD7Xn/54uc//zmDg4OsXr2aqqqq4d9jjz02LNPd3U1bW9twedKkSbz00kusXbuWBQsW8N3vfpf//M//HA6TBrj44ov585//zO9+9zvmzZvHQw89xGOPPXZGHC9wAe28FFBAAQUUUMD/VCiopM9StFE+yMfa8dBDD43622WXXcauXbvGPe/OO+/kzjvH9sHLFwXlJQeaHk8Nk3sNzNLE9I54pjFNIJJNw3Br8Yh24phbdBgwe8Xj3atdQlnLBFvxlujoFG8QnSX8GpZbbYhuXGPTt7eJZdeJ7HaotVfDajlJQ9Cl2YWOiFGkyAnx3twHND4uLlG+9i3RvtG/QGx8/yKxb8t2ivVpid7aPiY20NCWtbE7DwmHKNsjdnT3CvGZa4nWDH4NaZbGPyeq9T3T7DKnNG4oRSfFsmVAPEExjP9c/U3ZqZzWtNXsE+sKV4ptd5wSy5LGr2pwrvgH537NstEhfqlr/bw8S7WEYeJx5zGNP5HGlzpWnm1/j2aMmfvEm617XGxr10qxbosmGlPWPBeLRyyPmj8usWwXCbQJa/ayjQENK26pxr9ohI+a5BB9tFwnxX4LJMXGuDTP1bVeJONs/bQYkdlXLj4nvYYyKG0VG2/0i8cDGjZu3xSXUNaGO/umjhiTmiXUpvH1O/VxzYTRPJeBuWLlda9pSOWiYj+nNcSHtk5t+L7oL6cN79f6DlZpAiUU4+ly8sNvPjpfUVBeCiiggAIKKOA8x9nkefkwoKC8FFBAAQX8D0fGRHBm/hzxAQ+m4vKJBQs4K0irKun3GBz8Xs8/n1Bw2M0BRcmPrn0IZxpxHh/05nVOIuynY9PTdGx5lkhf+4TyQ+g/tPmMqNtTsfxp54faHfZ20Lnn1bzl80E41k807s9bHiAZC5GK55duIXToAKFDBwh3t+Qln45FMmnvj+xHSU4cmzIkk45GJ+RMGYJ6AdPQnykuEGaGYUTamvN67hc6wq3H8e/ckveYBejd8jJRT+c5bNX5g0Q8dNZTmxTw3lDYecmBg8eewO6oYtLUa0dlOx6ZkKxqc8aAf/TYs5SUzMCkIbzyLBJ9XNxHFVQlzfHXfo2jdBKhL98hhEiW7xAXj5i9CO/R7SjJOOVzVkFKfEl7Fog2f0MYgh3Had/0FAMndjLlzq8Jx+vuF+MrT31+Cv4dmxjcvwNLbSMl5bNx1GTi+SMV4o0PLkoQO9JMor2bREsniX0tVKy8gYg744WvzS6cKLOiKGn2732EadNvJu4W/XMic0Tnh+ApO11Hd9C67wWmX3wv7rDYl6YBUdeOuSDc2Uz7S7/HVtOEfdb16N2u4eM1z4p+IoP1CgOvvEjc20vN//oY+qVZB6D+tEhiEytTSfb343nmUWSzCWkwhsNWi9GRqdOhIf/rulQmeuwYgQ0b0btdRHbuZdJtX8RcVgOAovWFCEIy6Kdv59uZl+N1a9A7sj4N6gguIVVVUQaCJP1eEv4B9DYHFUaRWTVSlv1qVnUqyb4+wgcOIFvMpK4RGXAbnhHbHqo2oCppUrEIqXgYxWHA5Mz2ja1ZXCaSdkgGfAQO70VNp3DcfKVwXJvE0t4ikQj68B3chpJM4Lj9WmRDdl6YAuKYNw2K5/eOSB9g7dKkKmhpJ52IYymuRG+x45+iIY8b4cOiqgoh/SDJgX6SXi+y0UhJwyKxL6aIiqT6dorWP/yM2js/i8FehKN1fOXL9kILJpsb42lW62C9xuelKftBker3ERvUgaqioiJtkTCWZncyosXazMhpeg6to2zqCvRGC9Ye8WXafavo46LubyE22Ie7aQGyTo/VIz5337RsXzlqptD16JP4dm/GfdetmCdPovZNcX4mHRqOqCoHp174FZV/91cYSkooOqHJ8B3Otj/RF6Vv/zpKpi/H6CjGdUz0MdNHxbUmHY6AqmAwZRiBgyFxUKVN4pjx16RJBv0kAz5SwUGm9E4/HT5/ui17mwX5smaRaTgyv0YohyvE60VCSTz7Xqd+VYYJu2R/ZrFLpc5+CHcuKIxyBXpXdXxYUFBeciAe81M/6bK8QuPS6ST9/UepqlycV939bbtJRANYiiZmFJQkGVt5PUgSRrsbGH+HIR7w0vL6I4CKpNOTCAxgLBqbiTOWDtPxp18TPnkEAFvTDMyu3G2Kn2zH85OHUONJXLdfTcOnPzJM1pULA95jJOJBFDW/nazwYDfOimm4KsdnvFQVhb7tb9O76WVQFZIBH7J5fIrrwLF9xL29mXQPOZh7h5AKBOj+9a9IDXixzJjB5Dv/OifbL0Bw6zv0P/EEKArO1auZ9ql/Qm8emxwu4ffSt/1N/Ie2oyppdBY7lq45Qq6ikffpPbSF7h2vko6EAHBMm4ttihF72egUAcFTh+n54wskuruBDM/IwKuvYGyooeKv7xtdv6riO7WXji1Pk4xkHKbrrrtHUF5GItLViuft54m0Z14Gkk5HoPUQNV/72pjy8Y4O+p95hWDrEVBVZIMR/bzJ2GbOHFNeSafoPPwm3cfWA9C48FZYkTv9gNlVQfNrvyPYfhS9xYF79lIqVl4/irpdVVWCJw7Q884rJHozXrum2npSrd245y7H6B47BYi1vomEt5eWh+6n7s7PYpVqxpQbgsnqZt9rP8FR2kjV1JVI9bmJvdKBMG0vPkWsP/OsHHMXUXXLx3OOM0mSkfUG9j/3QxqW3oZNN33c9claVk/H9hfo3PES5XMupb542ajM0cN1yzLOa6/C+8if6PvV7yj/yueBsjFlh2AoLyUdCNL78/+m6m//CsjNgKs3WdGZbBz88/dxNc1H71hBkSN3X+r0Rk688yiBvmbsxfVU3Pox9Jax51M04KF9+3OETmXWMb3dibMuTWX5/DHlh9AXbcFhLMWsGztlwkjIegPew1spqpuBa9K8CeXPBdJnIdrovZ5/PqGgvORAdd1FuIqb8pKNJwIsXHgfVkvJhFRKqqqQiAVYsOYfMZqL6NVNrBzZKhowu6smlFPSKbyHtlK94gaKGmZjsDpGfQUPy6ppPPFTWBsmY5s8HUmnx1xdh8EwNutitK8Tz69/A7KMec5UTFMbkOMTE03JOgOLl30FWdYTmlAa9AYLTYvuQNbpx51m8e4OZL2R2ms/imyyoDNZSeeg2IfTNPs711Nx6Y2ULFpFenE0p2w6EaP3od+is9uwL1iAZcqUnNTqqqrS3byJ4OAebPPnoy8uxjJlck7FBTK07aWLVlE0eTYJv5dUNIR18vQxZSVZpnTOJdiWLcW/ZyverW9hqZ2EnIPQzDFpJtKCBqLHjhE5fBi924XjplVIulwvRAn3pPkU1c6gd9/b9B3aiLk4d+oEa3UDtXfeR6S9mXDLMSRZxnX3zTnlTbW1OK/5GNHediK9bSiJGNYZuRVTWaenbva1uCqn07zzKezF9YxHdSgbjDRddx+tb/4R/6n9yCbzmDlnJEmiaOo8jEvnED56iIG1b2CbPgudYoJxFABJp8fWNIPgkb3492/HPadyXB4Uo6WISYtu5fjWR6maOn7aDVNTLVM+9nX6dr6F553XMu2e4GOpdPJSOva+QuuOZyib/wUsltwpAiRJouGSOzn09L/Tu38dNZfMz6m8ANgWLyC0cQvpYIiUp48JlZeyMow11RjrapEnyI0DUDZ7Jb4TO/Gf3M1AYykOe3VO5UuW9UxdcQ/NO58gFvKiM+dOI2ApKqfhzi8Q6TyFZ/NrSIBOzp1WYgguUyWylN8rcOgjrW3d41jL6skQIr6/SKuZ33ut48OCCyY9wPuFISrmhXd/D70pE9/nPiiG8PpnZl/wVo/oV9J6nTiord3i5Ixr1hpHi1iWk+Lj0Mch1N+K1V2NrDPgnyzWV/emuBPTdak4ybU09VplZuTWLoBverb+IbpxVVUInjhIdasNm6Vs+OXQu1x8QSc1HzDasFNtCO3APHETs+i4jJJKIuszfWgeEE+Ilon3ntB86Bk02tHIyNJUOIQUV4aTE9o7xLrjI0wTydAg0TojOvOI+E7NGlt8UJN2QUNPrjWhBRvFsl6zgZZwadJEHNaED59Oe6Mkk6jpFMUd4kuofwRTvGlghAlJVTFowkjD1Zq0Dp3ivSfrbUgjcvfIGtephFt8boaAqCxoQ3Bj5eL1KrZpQoAbNOef7hslmUDSG2AEjX1oiah0Sl2ZflAVhcGNG6iYtUpQXrRpHoyDmbpUVUVJxEk0ifO1dJvYFv8MCO3fR6K7i6TXy+IKMWfS4CTx/KH0A5G+DqxltYQ0uTy1z916eo7EfL3EpjnQWbLz19Ylyiacp9u0dxuW6np0DaKSWb5T3N2MOzON6d73Fs7amThsovzAbPFea9+Ok0yESaXj7N75ayqvuxNHUzZ5YnCOOBBK3lJR0kkOPP1vzL7l74nMEz98Sg5kx0nodHh+tK8T/8Ft1Cy+QUhYqc1I72zOPDdVVUlGA4SWuITjruPic3Ufyk7+WCJA/xpxV8d9VJPCQhMKrUuIYzruEhfKvplJOu+/H3NDA87LL6eiL9PgdCLGnt9/631JD7DvUDmO95geIBhUmDfLc07b+36hsPOSAx8kk6IW9tKGD/T6kiRTNHUu9r78nXrfLYYUl7MNvc1OHh9jABjsThK5P1A/UMgGAxjOgAb/DMexwe4kdZ6sCkMvt3zuVJJlXKsuQ/Lmd7+SJKEzmWHc1KgZ2OfOQ50zFzUeh815VY+1bPwEdlqY3RUkLRPLAbjmZ8xo+bp5V869PDMO4hP3pMFow4CN+Qvuxecev0Gy3oCsN1A6bRnBnhPo5i0aVx7AUlaDedUtyIn8XsKSJGG0OvOSHYLZePZfypJeT+3f/V1Wqe8765eYEAWfFxHnyTJVQAEFFHD+QpIkJLOZ/FWG8wfv5kPMZq8g4p7YFARQs3ANkiQxOLFopj0T+Judj5AkCfQf7OtSQSJ9huHsY9XxYcGFN4oKKKCAAgo4b3A+7VIX8D8HhZ2XHDAGFfSGzCZbyi46go4Mf9TSXE//ici333OjaPIJNYnb1IFJom01Zdf4PhwR9cviI+LGX9dK0cel9jW/UO64yiWUZc2Ho8kvXq90b7Ycrhav3X6t6OOialRfrY1e6+OiS4h/qNRswXev1FB+7xb7Jlwrnp+2i/KOrRr5xWKop/lQdhvcP13jP1Ms1mVvFutydIj9HqgTb15L9x+tFNtq7dQs8Jq+cx8V5fvni/JavxPPMlF+ZF8P+XUMIVwtnmueKvpw6U+I2/IOTcqIwSmaB6m5lZRNPK5o/KbluHhCz8XavhHlS28V+Yw8z2cdR6y7RVNGQoy+H0Xfr+2L+EzRZ8auqc8/Q2xb/StiOHLHFeJuRMohjgtHs/hgS/eL9cXcYnv807PHtWkZtP4xATE6HnOfxm8jpkkpUaJZW8yivLVbrK93sXhv9Y+JzyHQKg4k3zSxvsk/bxHKwaXZ5xZuFNvW8KJ4s1JaHDSmgDgfUxpfD0e7OCH80+2a4xqfNE3oc1wzbhS9pv428Xx7m3ivzhOZcZRKaXJdnEMoaub3Xuv4sKCgvBRQQAEFFFDAeY70WTAbvdfzzycUzEYfQuTLqSKck06RSuQOH/4woRBgV0ABBRRwYaOgvJwlnGk6gTNFfNA7sdBpnOxax6G2F0mk8qPMjwX7ad/3Mp0HX89LPh0JEzy0FyWe35apkkqQjIbyVhqUeGarPhH25yWvqiopX36y6XgM7+Y3UeLnhhlTOU31n45ESEcnVgbPhI79TKGqKqr6YYovGB8FpTSLVDJK38GNKOkP3sFYUdJn/GyUdIqgL/90KGcCVVVJhcZjDzo/MbTz8l5/HxYUzEY5oPfFCIdbcLsn458m2sVLDmYXBPU0B8XBPX/CXTKVmhkrBFmt/X/6r4OklRQ9vgNUFc+lf4XIZCppHEnMXoVkLMjhNx6kevpq1EsvE46Hpoq2X0/AheeZLsK9zUTK9Mw6fJvAe9GxWkN7bYnS9l8/R9Lrqf+rvycYzMomNTwqJi+oSppTz/2eUOcJpky/iar6i4aPt18lxiIbAxLJQR8dj/8OY0kZav8g09d8ZdjBL2ET71VOqgQ2bSF26hRqMklncwsNn/v6MG1+yV6xPYkiPTFvD53rn0JntpG64h6BQKxoi/jcpDS0vf0MA0e2ISlQuuKq4WPV67XU6TrUdJpwVzOBloNEp8/HVp2lX1c1YdeJYoXwnn1EDx1B0ukI79tP6efuxFKfIWSTOjWpChoSBN5cj5pKIVvMxHcdxnXxZdinZXg1nCfExX6wLE605QTh5mO4L7qMqv2aVAvl2b70z0qT9PTje/I5iq5ajfpiCzFPJ3U3fhpJkognxTHgPk0bHwl6CPnakG9YLhxXjGJb5KBK9OQJQvv24Fq1GrO7AlVVh5+rNDP7Ykj0DBD+w2GsVQ1YqxrQma1EDOICmjr9mELHDuHb+BYtbzrQl7gx1FRiW7YQ14j37+BkDcdMUCY16Gfwnc3IJjNVxlnIegMme4ZQKVyp8VXYYEFJp4j2dRDubkZXPQlbVfa5yskRHDmKQrupFaPNhamoBEnWjeJNkvpGpnFQiKg+Ej4vSf8AensR9tQ0UT6drT+diJF+fCfO+lkYbS6iGq6gsIaAtnxb5t4TkUH8XYdJrl4g8MKMjCnX6y0M0kPPc/9G8c03Y501i7q1Yt/1zxKXf3X3SQDsZZOQJIkjfy82YGTbAaqfDxCL+rAXZXxhfJeJ/n0Je0Y+nUzR95s/IBkMWJqmYGmaQkoT/pzScNANTjdz8tFnqVx1E7bayUz7nV9s+yKX2LbOflRVxWzLPPdBjS+hpV8cwwPb3kZnslC6+HJkvZ6ad0QaiK5VohNb6aZBkskIFktm3gUbMlwK6fcx3ZGiSijqe4w2eo/nn08oKC85sHf/Q8SiPi65+BsTyqZSMQL+Nuonrc6r7kQqzECwheri8emrh9C6/8XhLxdVUcYNNVRVldhAN/bqKdSuvB2pd/zBGjqwj1RgEJ2jiKTXi8U4Pv15z5aXCLUfQ2e2TvhVH2k/Redffkc6HEKJRZhx9VdyRiaoqsLAcy8w+NZakCRK7rydmhs+kZP3JZ2M0bXxdfr2rQdFweBwk07G0ZtyM3H6T+1n4Mg2DHYXqqKiplNIutFTQFHS9O1ei2f766Tjmd2T+GA/tls/l6PtKv7X3sT//MsgSbhuXEPNv/49sm1snoxYfzc9T/2ZRGs7ss2Kbdkiii+9EkvDaEbndCJG9+7X6D20ARQFkAifOEKsdDaN828a3fZUEv+LbzD42tuQSpEOBHFWz6Jk4Soyb7fR/R+PDtJy4AX6O/ZiMDuYdP2yMZ+TkkwSeGsdgbc3oEQyi31o725Qofqe+7BOHk2Fb6wsJllUTOtTvwagaMpciu/7OPIYbMj2abOQ9Xo6H38INRrDunAO5imTyMX0Gm9pw/vaekIH9oGiIJvMRG17KJu6nPLpF4+SV9NpPHs20LPjVZRkZuetZtUdgvIyEpIsIxtMHHvhv0jFo1iKq6i/5V6MY6ROUFWFgQPv0Lv9dVJBPwC2yTOxVaYorpo1Sh5AZzQj6fXsf+y72CuacCxaimve2H0PEBnsoXXnswR6joMkUz+nGktd45iyAK4rryS4bRu9v/0t7jVrqJVXjxsZZCuuY/8LP0JvtlM1azXq0tnjrjV6g4Wj239F49RrKSnLzZqsM5gou/UOOn/xIKFdO9C7i6lc/lcYzbnTCQCYS6toeepX1N/8GSA36zOAwezg0Mb/JhkLUla/CHvjVWMyLQ+hZP5Kjv3u+/gPbadq9a1UMj6Xlk5nZM+e3zB9+i04xklrUMD7h4LykgML59+HXp8fU1ks6mfB0i9gtZXlxailkw3Mqr8hrxDDeMSPo2QSTYvuRNbpCU+UkycSxOQsY9Kaz55+8Y+/bRzctwtL0xQq7/4kersD+nPLhjpPkE7EmHTLF7HXTKH4ZG5TWXLAS+jwXtxLL0XvcGJwONFLY7/MlXSKru0vEo92YF+2FH1xMaaG+nEJ69LJOM7J83DUT0dJJTJsrOPQtqeiIQIth5h0/ecoqptB0pm7H2VZR9nC1bimLSLYcojAqUOULBqb6l1Np+hb9zKRzuNYF8xF73Zjnjo5p+IS9/fj3bcZY00Vxpoq0OtwXX8NlujY+VV0RjO1y2/GdtUqgof2EjpygPI1t1HWPXrhV1UF/4k9KGoc+0VLUZMpzNMnU1GSOzcQgMniZNqSj9Ewaw2xyABJVR2Tpl42GHBecyWOmQuIHj9G9MQx3FdcjaWiboxas3DPWYaSStL99tNEultxBoPIJWPnTrI2TaPqf/0V3t8/gaGmkp4f/pRQaRO1V96NzihGwxhrq3GvvgrbjFnEe7qRZJnJdWtyzitJp6N8wWrc0xbjP7GbgaM7sJRWjyk7BFt5A9Nu+honXv4VSjKO3jY2YZokyZTMvQj70qUM7t+Od/Ob2CfPQB8ffw0pnbqMcG8r/ce2UiTlVlwArM5KZqz+HMH+VvxdhzGWjZ8bTe9y4bjoIiKHDpHy+WDsLh+GrDfQuPxOjr75S4KeZsyMzrWlhdPVSGfLRtzFkxnvdaKz2am674t0/vy/0NlsHN3xR6YuvAuzLXejrDWT8B14h551z1Jf9VEsxtxkdbKsZ/qKT3Hg7QeRdcZxFRcAo7MY18zF+A9tx39kN2lX9bgpBSRJwulswNN3ELt9/DFzrlBw2BVRSA+gwRAV8+K7vjecByRtEh94qDZbljXbhuYBsazNnhpsFBezeJFYd1GbqGx0Xi6+kI2+8cMdpfY+dHozBlNm29M/WZvpNfv/ZDhA36FNVKy4dvgLayQlf1qzva/N/hst1WR51qxDkka3sXVrTCFNYv1aE5u1RyxHNGu1o1Usa9MTOJuzDVBVFc+KbF9qt8C1Yao168UH2/Jp8d7tu8zD9UqSRLh+/GlkHBCvp9OMm1iZ5vxq0Z/IcDirDKmqCobci5BJMwb1GtektIZ7LDBFvDejJnu3QeMeoA2Rt2voAgZmiW0z+jP/Dh7aibVuMnKJU3hJa0OCU1ZQEnFkoymzk9R1EOv8eUiShNkj1q1q3pdVm0RfpoGZ4s1q+z1UkRJSIZg0ZqGhMZkMBUgGfUi3iAkcjXtF84Lu9OVVJY2STI7KJZTQvH9dxzMU+30nt1O0cDnyiJ1ALdVA8UGxowZmibuMIU2eTkcLJCMBJJ2eU288jHnGNEouyWYA16ZxGJr7vtb9FNVMp6RZnBTNt4nXK2qWSMUj6IyWjDnSJdY3Mju4f8Zpk1dPL4byMvSP7sRZPg3TafORf4o4qIwBiPs89O56i1QkyIL5nxGOd14mrovl2zNtj4d9mGxuYsUaiolDmgz2DSaigx76T2xD1huZWnmFcFzSxBS33KRHTWXHirU9U386HuPoA998X9IDvHWgDvt7TA8QCipcMae9kB6ggPMP433JaKG32Km8eM05bM35g3NFpPVBEHRJknRB5oZ1zspkXVfy6DL59C6LrDdgW5CfefXdQMqTNdVgL8JgLyJKfikyJFmHzqTLi49d1hmomHYx8TyStJ4pDNbMC6rpms8SLs7PQcPdMPf0/yZ29h3PTDsWjJWZL5DyxqUTy7rKqLvi7oy5tDO/EW+yuScWOg2Ls5zaRaczkPdOfK/5jpVzBfUs+LyoBZ+XAj4MkGT5gnwJFlBAAWcGncGE3pYf3f/5guEPA52Oc5WWYSLzUgHnLwrKSwEFFFBAAQWc5yj4vIgoKC85YO1Lotdn7KpJu9hNciqrrac0/jCGqLiX4VkiOm7qNP4HugnoRmrfEh1H2q8WvxSSWp+Z1zWp3zW019p0AFq6cveBLHX88U+KNtHy7eP7iVg8YlmbDqBvtRjWXf2C2K/BerGt2vDGaJnG90jjJ5qyi3v0+qhoF697I7tt3rpGdM4rPiDW1fZZsR+rnxAdcrQU95KGvt99RCzHNLvZOo281j9I6RV9JZynNH4lMzXPYsT5VbeKzkDH2kVnIetBsW7VKPabySc+h1CjeG2jXxPqrKGd16YyiBeLZaOYnYDIEtEvrGiDds5k6zeExHP9M8W2exaJuwshDS292SPeW7RWbKytQxwXKc2HuWG/6OOipRPQzu/YJWKDi14Wzx/p86a9l5I9Yr/6ZogmmoG5onzxPrGxvtmadBoOccJO/4XY2IF5otOYZ7HYVq0PWvkWv1COVYvyPSuyfVm6W7yXYJ1YrnlbNMcNThPvNeHQOONrzHGGsPgH7XwK1mt9n8bfc+6bJ873kj2ifGJoadSM9XOJtCqT1jqcnXEdZ6kx5wEKe2YFFFBAAQUUUMAFhcLOSwHnHVRVueBt0fGgF6PdfcHfRwEFnA2oSnpcKoMCJoaChPIe9xuUD5GXY2FlzYEB73Gi0YGJBU8jOtCFeg5TBJwJzXsiHiQSHoewRYOYt4dof9fEgqeRSkRJxSOceuNhogPdE8ono0EiA130/exPE9Lhp+NROl97nKinc1y5IaiKQjoaQYnHibe2TSw/RPaXShF85x2SA+M/46H2qqpKLDR+nw7VHT50iKMvPEjM7xlX/v2Akvpg0wMo8TjpyMRpKlRFIdHhQU2dOzp7JRYjFQxMLHiBIxHy4z+1j3QoNLHwaZxrxox4cICe/W/ndZ33g70jHvblfR1VVUjF80u1ci5RSA8gorDzkgMH9z9Kce08pl/8KeJFoo6nS2YHvbU/jaKk2PXcv1PRsJTK6+8WwmctfeIEcR/IkB94/Ecoc06nf5noDBGuFB+J62ScZCLMwQN/Zvbcj1O8zyUcT2i4TRJFOrqO7qN13/PMWPlZio/OFI6b+7RONma6tr5Nf/MOZlz1JbzzpwwfKZ/RJ0h6pFLinV0MPP0cKZ8P58zFqNMriJ7unpIDovLWvVImtHs3gW2bSfb307j8Tlwbs7Znz53iglD0po3BQ7vxH9hGorcby42fR28ZcYNTRLt4usVM3+OPgaoSPX4c9+xluPWNw8e1PjF9ZadIdPSihGMEvrcVU10Dtpop6CwS2gjCVFhP9OAxYvuPonM66Fi7A2NxGXV3Z1h201aNompN4X/6DSSTkdBb71D5pS8Qq6pkyKtAHvFOVtNprMejKKkE6WQCJZWAeQb0ruy9po6LzhTtUzoJvrUJ67KF6Bw2LKlOTDUlGCtcAMS2ZR1Lju+qJ+Xz4Xv5ZUz19ZgqT6Km0pTemCGrU9Kiz4uhWyLe3UGk+QSSwYDuikuF47VvivfadnGSyOHDRA8dpvjWW0hNEQehYs6OeVU10P/g77FU1VG8ZBU6s2UUz4zanWlPfE8/nY//DH25C2NNOUXXXoRl1iTMu7M+MINTs3UrsRihJ9ejM1swuEsxuEsIzi5CMmR9LYp3Z+eTqlo4sfERUFWcSy7C2jQVOSLuBgxxBQ0e38vgiX2kSjOM1sbGapzXXYxjq+iPE2nIPthEZw+hHScwl1VjLqtGb7WT6BXlAxpuI0NXnFh/N7H+LixH7SPClKFkR1ax9gSOc2rqALLRiGQyoSsqwhqfK6w1Q7wwJpuL/kOb6P3fD2Gsq8Aydwruu67EtcclXNu7INtPiZCPti1/wFrbhGPqbAwOFyWHREXSuuGYUG6dL2F1VmI8zdUSc4nrZMn+rOLsWVJGz9otBKQ+ym65k0kviv42XZdm/WXUdJqedc8gGwzYp8zGUtNA3VpxrUhaxDEnpVS8nsMUl01HkuRRPC0ps9i2gOxjYM9r1K6+C1mnZ2CmJi2LsPTJtO16AXvdVFxTFyJJEsZApv70BL4zBZw7FJSXHJB0Rqqmjs2qqkUyHkanN1E7dTXpPHg/IrEBOvp347aPT0k9hK6uHciyHiXPRBr9rTsprp6Do2Ti+hORQbwtuyhpXIjFOT5jpxKP0/fwH0j2erAtXEDppVePSx+e8vnof/JJlGgU56pVOOvGpkkfCe/RdzDY3dSsuEVUXDRQFYW+x/5MaOdOJIOR6q9+FacpN9Nr+OB+ev/0e1RFxbF6EdX3fRlj6di086qqEnh5Lf6nXgHAfsXF1N75GUxluSnKI3uOMPjMm+hcDiq/81cYE6U5ZdVUkt49b+PZvw4UBUmnZ9I1XxvzHiNHDzO4eQPR45kXR2T7XnSlbixVdspuWTasvAwhHY8x8NKbBNauQ02liLW04lw+Cfv8sSnwQy3H6Hr7KZL9mV0i2WpjcMcWSm69Beu06YJsKhml5cirdL/0DqTTIEmE9+0HoOSGm3EuH03JL0kSZSuv5dTDP8G7fT0lyy/HfdnlY5oQ7IsXIVvMeB5+mGRXP4bKEoy15cDYbMWy2UzR7IV0/OnXJH1eJIORyv/1VYy1VWPKS5JE+Q230/rTHxE6tA/btFmUfP4TyKbRIcRFU+ahKgqdG55ECUUwtnajJpIY9AsxF489T4w1lSQ4TsuTvwDAMXk27q/dg2QYvcyqqkpw9w68L79AKpJhAbSV1eOonILeNPp+yxxTaDXtZeDll0FRsM6ahaGsDGP12PdaveR6IsWDBN/aAZKEY/ViwDWmLIDR7sY1bzltj/2KnteepGjWItyT7kDW5WadNVqK2Pviv2F1V1M1fRVWV24+HkmSsE2fyeCWjSQHBqgtvguDfuznKul0lF16DS0P/yfeLW9hcJVQ3HAPNsv4HFahQCe+/mNMnnnzuHIA1spGTr34G5IhP43X3UuuMTYE9/TFND/9M/xHdlJz+Z0YdK4Jr3G2cXYcdj88ylZBecmB0voFOErHXvC1SMZDTFv8MSz2MvLZqDXoLSyc/NG8Cc6cznrqG1YhSRIT5XGOBvsob1pGxeSLM/VPYDXwdx5m2uX34azKvKjGM3x5n3yWdDhM0WWXYl+2BEmX24atqgqeP/0JndOJ6+qrcSxejNQ2/v1GvV2YikqZfP2X0JssOa2zqqLQ99/Pk/R6KVq5ElNNLTq7Pafn/+CWTfQ/9zQ6lx1DZQlFVy7DmCNfjpJK0rXjJcKB45hnT0XnsGNbvgCTlFtxUSJRBn73NJLRgGXBTNTk+KYP2WSm5qKbKJmxjPaNT5GKhtDZx1g8JQlTTR2uSy/HNH8qyc4ezLOnYVu+EHfV2OaPhKcHQ3EJruuuRQlHkG02qj6/IOdYszdOo+Fr/0j01AmC+3ejdzixX7IM2TqafExvsDB5zi3oPraKyOHDxI4fp+Qjd2E05aZtB7BU1eGcm6HNT0fD4/o+WGfNovKbnyF24CRKPEnHPzyAc/pSSpddjt42OiWCsbSc+s/+NZ1//g2oKr0P/Jrqf/l7dHbbGLWD3u6g4uaP0PPMn0n09ZDs7cNUXztKTpIkXNMXIt1US/9vn8Vx5TJiB0/SuvF3GOxOmm778pj1ly65HElvpHvt00R72nFGo+gMo9stSRJFi5ZSWr2AwaN78O7ZgLthATrD6JxPw+254grMkyfj+eMfMdXX4/n977EvXYLriivGlC+97xYkvQ7TlDq6//VhYvXzqVhxLboxlCPIjIXKK2+hd+3zRLtaiVYMYHPk/qCxuqqYtOwumt95LC+yOuv0mQR370A2mcal4gfQWWzU3nUfLQ8/gBKP0ec7jM0y/sekzV7JsQNPUl2/AqNtbKVuCLJOj71mCoGWg7S//Tjln/jEuCR0tprJmMtqCLYexrtvI9YF17/v/mwZn5f3mJjxQ2Q2KqQH0GCIivmSxf8fFrMr87cmcbK79/mH/++f7RSc0frniwN66oNi2GpkvpjUSxtq7ZuuSQcwKBSp2OQXyq23uoRy9dqo8KIanCR+VfYvFbWZ+mfTopmrK6t+td2QNWklA34czx2m1NGELGXa2HaTuLugjmh6wushag5jaqgfrl/Ri0OtdJfYV4MlEWSLNZt1ukiUt3afriedQpIkJEnsK1uvKB+ukFBSSRK+PozOEiRLti8ic0Q10HJINKXYejR1VYnPyTzC/aVn1+vEK/U4li5Dd/ql72gV5aNaXen0YVVVSfR2oWsS86VYNAk1Fc1ar2jW2dIRJruBmWK/6DTm+sBsUcsz9WQrV1UVsyYFRbhW7Auzd/wFUGuCi1UopAYHiR0/Sby5hZpLbhMU39RCUeVPt9iGE5CmwyH8m9ZjnTsbU6OG/x7QhzJjSEkkSPl96BxF6MzZ+apNB1B0OuQ81NdKOhFjoOwEJXdmM7VrzXX66GkfDFVFkmViZQrpUHhYOSrboQkBbsyUg4f2Ypsyk6TGDCxp6IUtp8e0qqpEnXFhF0gXF2VLDmTmbioRRdYb6Vuqg3R6+KXraNbUPaAMO7+nkjH633iGZDrG3MrrAei9fLRCrqoqgy370ZvtSNOr0Zmy88J1XFw7hij4I/2dWEtrCGoeT9nurLx/qoySSpL0D9DxxG+pv+ROHDXZRJ7aMZM8rXuGWo9hKqlA6R3APiKBZkKjDxoDkIpHkXX6TE40TX1jzR/vnk2E245RuuxKipxi47UZvSu2pfC07yTo66CifjFuQ0Y5SqVibFj7nfclPcCTe6dh04aMnyHCwTR3zD9WSA/wYYYhz6SMwHnlRX+mdPX5yhuKXJQXjc4anAvGknLUsjNzFtVZx/5a1mI4/0searesN2Auq85X/IyhqioVC68kMO3dfdFIkoSpsobUeRIFcK7SHeidTuxLFmFfsgipZ+Iv1iFzpM5mx33TxCksZKMRY3lF3g/ZXpYxqUo3T5whWJIkIVFlrl2dkXDMGjKh5DcHJEka03w1FvRGS7ZdE1DWD+0O6A1mZpRdMaGTqiRJuCbNAyCWJyGvtTS/LMuy3oCptILqWz+JKZ7fXLc3TAPAII+/uweMaW4bD+7ZSylZcEmmEB1fFqCsZgFltYsy/R4+d8EZuaAgky5EGw2joLwUUMB7QOZlL3FuVKMCCji7+CBycWlhqazFmH8g5zmDnMNElwsf9EdqwedFREF5KaCAAgoooIDzHApygedlBC4o5WX9+vX86Ec/YufOnXR3d/P0009z6623Dh+/9957efjhh4Vzli9fztatW8/4Wv3zreiMGdORlmo65cyalGxdolHd7BUHV2KK6PCW0KQ0710mfgk5xWhE9Jp0A11XuoSyVUOzomq+rLwLtDT24nH/FNEY3Lcw6+eipf8PTRPDuuOlmrpTYt1DaeOHkNSYWG1dou9F/0Lxy8bcr+lLzc5x1Wbx/Na7xS166zFx3ztWlm1v0XbRLBiYKp6btmhSFfSK1x64WHzupjbxK25wulhf6U6NH0mNWK64WHyQXTtEHxht6oPyyV5R3p31P1Js4oOzHxenucE7vrNk020nhfLeg41COWIXn3tZrU8oDxwUfaG0lPzxOeIevXm7GFVWfbXI8RP8c9Ys4V2mHZRi3Q4N1Y8uLra1d6U4ma17ROeJZL1Yv6FV7DvtmOy7SJSXNSkpDIMamgUNU0F8xJSq3ig+Y3+TWJfWP654v6Yul1juXSrKB+pEHxetj5i2b2wt4r33f0R0nrK9JT43R4t4/a6rsvcjhzVpSI5p1rXLhCLFe8V+k1OivOuEOPd9U8X5Zwxq/LR84r0NNon3VnxQk6KiTZwjbdeI7SndnXk26cQHy6P0PxkXFEldOBxm/vz5PPjggzllrrvuOrq7u4d/L7300vvYwgIKKKCAAgo4+0ir0ln5fVhwQSkva9as4Xvf+x633357ThmTyURlZeXwr7i4OKfseEgEfCTDZ8bGeSYsuBn5c7eFF436SKUmCqx+f5Ho68W79vUPuhkFFFBAARcc0qcddt/r70ywfv16brrpJqqrq5EkiWeeeWZc+Xvvvfd0JKj4mz179rDMQw89NKZMLHZm76sLSnnJB2vXrqW8vJxp06bx+c9/Ho9nfIr2eDxOIBAQfgB9u97Cf2IP6eQEaZ9Pw9N3gP0H/sigryUveX/XEfpbduUlm07GUNL506YHAu0cPfIU3v4jEwufRqj9eN7KVDw6SMifH33/cP0tR2l/6OeZiJAJoETycP0fAV//cRLxYF6yKZ+PVCBA8zO/zEs5VdOZ7eZg+zEGDm87o3blg5HpEtT0xMrvUHvyRdLjnTAlQwHvHelAiMAbG0j5BycWfheI9nbkvRa9H0h0e/Gf3Ju/vMeDEs+//alYKMM8nQdUVT3jD8FQ50mUc5iK4sOCfKwdI/HAAw8Ilo/29naKi4u56667BLmioiJBrru7G7M5/whfuMB8XibCmjVruOuuu2hoaODUqVP88z//M1dccQU7d+7ElCMM8Qc/+AHf+c53Rv3dd2wngfYjOBYvJaZ537pOZG3RvUuNJAM+Tvz0T+htDopnuUm7s/ZXW4/44og7ZVLxKCd3/IVkeJD5lnLs7ixJVtKqoakeSOHtPcax/U8yd9l9pKtE1lx7QKy/81IjJ3/8CEoyiX3ZNZg0PgFJt/jyMwZVPEc20779WSat/CjctHD4mGoQFwRbj4yqqhx/5wmCvc1U3/KP6IpG2L2TmrbP8hI55SF8uIOe9dso+5t7MTTUEiOzaLR9XGxLw2MSoUAXB975LXOX30fgapEx19ojFOmfY8C7fR19e19F1htYFvkKZnPWMaZ3sSiv+kL0/PxXqKkUpQtWIbkdpIf4VmTxXmNVKaL7DxM9cIyUpx/FG6Dk5psJTsrImZuzz1hNpwhwgMieYxjrKnCsWoSaEvsiViyOv2BVBP9TL2OsqSDl9XPi1wdwXHQRzstWAVC7RMw11bGpmMHNG0n0eXAsWMSpbUHsS7M3WDkrq6SHX6lAVRS8ezbgeecNYssvofSK67KVneaRV1WVdDBIfNBD0tNHqq8Py6yZNA+UC9c29ou+FyG6iOzcD+k0RTddxeBWN6qiIBszfeJYlA0lUVWV6KsGEt5e4l4PssGIbZ6YsiI1gt8sHQlz4vEYiZ4ekj4vxVdfR/rirH+Da6foi+CbGSOy/zCRHXsp/ugtxOv1KNEo+pLiDK2/P/scEv0elLUDKMkEajKZUQRvmS2Qkxk7M89JTacJ7NxGKB5F0uuRdDpM1TUUORuF61euH+obJ13HFdqf+C7mmZOxXbQI27J5FB0XydtG8s6oikJw91u46udgcVUQLhf7OTgvKxw/EePUf3wXfUUZ5qmTsMyfRYkkUheomtXcvSWC5/gWKmeuQtYZ8FwrftmaAtmXRaSvA/WNYEbRVRTQ6dBXzBSik9x/yoYiq2oNu/Y9QX/nHspuuh293TGKq8XSkW1QOmqh5Zf/QenFV+KctxRDSJz7rsPic00VGTnx9C+pWX07lrIaUmatuUPkJurZ9Rqy3oBr5hIMtiJsPaJPjGeh6BOTPBrl1HO/ou7Wz6AzWQjXaOZnrYav6/dBYolBzMbM+hKvyPRFKvn+hUwrqozyHqONlDNU8tasWcOaNRNTFQzB6XTidGbX4GeeeQafz8dnPvMZQU6SJCorcxN/5oMPlfJy9913D/9/zpw5LFmyhIaGBl588cWcpqZvfOMbfP3rXx8uBwIB6uoyL033govQmSzjss4CBA7uBlXFVF6Vk71yJDo3P0syPEhR3QxSiYkTfgUHO3GVTMHmqJyQjiDl95EOh9A73RhcE5vMAt0naH/naQw2F8lIEL2qjhtO2X9yO4NdR3HVzibV7xOVFw16n91OzxNbMZY7mfEfn8IfHc1kqkVXyxYcrloMxtz1DsF/YDu9bz8LgGPqXEym0UymQtufe5akx4O+pISiqXPHvc/ooWP0/ez3kErh/ugtuBatHJUKQVVVQof34nntOVIBPwCS0YD34RcysrJM5T9/CUOl6MAa6W6l549/JNXbj67EjX3lUsrv/TSGitG7UqlQjK5ndtP+2C6UaBTJaEKJRjE25e7L+ICHjtf+TKS7BYB0JIQ61nNNp4kcPYx/3dskPZlkLrGTzcQOurEvmIxr9VxBPNbRSt+LzxBrP028qNMReHU9kqTDXFNH7ae/NKp/AluP0f3nDcT7M5qnqbya9OQERZeOppJPePvwvv0qwYN7QFGQTWbiPd0YZ9fjuvkqsemJGL07Xsf7u63DO3Wxw8eRzGZks5nKr30JnU3kEtE7ihjcvhXf1vWgKhhLK3BUKdiWzh1F4S/pdNhmzcHzzONEDh0EwHXZ5ZhnOjC6x6apr5q1mr70CWL7jyLp9dguWjim3PA1ZBlbaR0Hn/kRrrpZlC+6EltF45iypin1lH7hHjwP/pbEqTb05SWoVVPGHcN6k5V4yMv+539Ew9LbgKacsga7i8EdawkczOwG2xqnYbnYhaW0ekx5SZJwrliJ5+nHiDafoOrj92Jumpy7LfYiimbMo/vFxxjYvgHzpFtxunOnL5H1RiylVZx47H4qL7kR14pLczLaSpJE6YJVHP/jj+nZ9BJFk2ZhrroGm618THkAW91k2p99iFN/fpCGO74AjL92ABxrf43Zjbeg051ZiPXZwrsx+4yuI6O8DFkYhmAymXJ+4L8X/OY3v+Gqq66ioUF81qFQiIaGBtLpNAsWLOC73/0uCxeOP1+0+FApL1pUVVXR0NDA8ePHc8rkfGh6A8VLVuV1ncDhPZRddj0lF1+BPjb+4Ar3tqAzWZj1sW9gcpZh9UysuVtspTRMuSIvOupYTyd6h5O6T38Zg6t4XMVLTaaIDfYy86a/w+KuQpIkBsbx50on46RiIebd9i1Mdjeephx8/ECyt4/uR9ajJlK4L5mOwWmdkAhKVdIUl02jpHLOhHwUEU8HkfaTVF13N7a6JgyuUqQdubelgycPETl8COeqy3BevBJD2p1TNnbsJP2/eARDVTmmpnoMtZVj5nCSJAnHrAXYp89hMH2IyI5DmKbUYb9kPkpCyigMevFrOtrTjnf3BoyNdZgmN6JzOii6bjX66NgLh6qCe0kjscRkkr4B0oFB3FdfByW55FVSkTDlF107/Ld0iXnM/pT0eoqWLsd28RIiBw4x+PY63Ndfi8Hch2wZHZFkrm2g5rNfIRg6QexQxszovvN6zF1jRy9JkoTzoulYUisINR/G+87b2BqmYqrPkRuopIyqO++h5IYbGdy6meRAP84VK0k6Rz9XndFM1Yob0F0/l/jxFuInW3Ddeh1GZ+4XlmwyU37NzTgXLKX3xScxlpQRO9yMbdm8MeX1dgeVn/oswe3vENi6GVVRaXvsl0y69+8EFt/s/cqUfu5ufH9+HiUcxfOT32Jfdg8Ga+4XY1H1NIqbFjDQvBv3jKU55QAss6ZS9rmPE9l3mNDG7cQ5SOWVt2IqyW2KrZp1OX0nt9FzeB2uWA2yeexxY7DYqbnlHpxzFtP98hMYS8oIdzbnVF4AHPMXMvDmK6iKgq5oYhK54hWX49u5ieTgAAbDxOkE3LOW492/Gc/2NzDVN2CtacwpqzNbqLvuEzQ/8VPC3S3o68Y3QehMFiyVdUS7W/Ht3YKr8eoJ1xyrqZh4MohVN36OpQsBQx/oQ/iXf/kXvv3tb5/Va3R3d/Pyyy/z6KOPCn+fMWMGDz30EHPnziUQCPDAAw9wySWXsHfvXqZOzZ8I9YJNDyBJ0qhQaS28Xi81NTX86le/4lOf+lRe9Q5RMZcuv5rKizPbZc5WUQUIV2RfSAF7kERfL9ZJmWzMmoS9muykkDKJX8AJt9j96RJRIWh4TBMe+S0x3UDHb8SvnZ6TW7DXTMHsPr2Ia56u2S+amRJ2jVlpxIZHSrO+lBwU+6FvvvhiHkoPoCoKHQ//Asltp2jVSkyTGjJMspow0/HCRkGk4AfQaXQlZ7Nos27/iFgucmV2tYZ2AEyxhcN05wZNEqroqtCwbLy5G0t9MbI5+4Ul7RDjvLXh89pMyUaNC054ubjDZtordq52y98sRkITWCWen46KJ+j6swqEYhIfupzQZDIOaRbpuZnGqqoKioJy0iUcTtWK5gZ1UPzylFMTRDBI2fYo8TjGuPjiT9RpfBuGTHnpdGYH5HD2eqHJ4jO2FIsasbxDVBS0tPDx0sz4V1UVJRTCkhZfukVLxAnrPZ55UQ2lBEgbFGH+6gc1WalLk6ipNMgSwdc3EntrF9Pv+vth5Tc1hu6QDAcItR7FcukSoe5kkThXzTWZMarEk0gGHf3PHkGJxSm6PJPzp+i42JbAgky/hrftwzyjCXuvuBOr12z6DlERKPE4ajqFJSXuXGlTZkRLJKJ9ncQGevDu3Ujp//6q0P76V7LykdMmMd+pfahKimB9P+6bLhk+7nhV3GkNTso8I8+zf0HWGyi/6maBJM6icWUs3Ze5mdbOjTgdtcSunCF87Gnnpy4G3r2biPS04WiYztS4mDQ2ZRH7Uhuqregy95lKxtj8xr+8L+kBfrlrMRb7e9tviIZSfHHRTtrb24X25rPzks87dyR+8IMf8O///u90dXVhNOberVIUhUWLFrFq1Sr+8z//M6+64QLbeQmFQpw4cWK4fOrUKfbs2UNxcTHFxcV8+9vf5o477qCqqoqWlha++c1vUlpaym233XbG1ypZcGlecnq7A7194i3HIZxrhsuSmcvHTZj4fiAdCVN5+8dRG86P3BlDOwDJzRM7hEmShHlyNbLuf56TqyRJcI7HjmwyQZ5+m+dyHEuShM7hAH9+8kMpAfKZv0O7bUXXrqLONdrcqIXBVoR71lLieS4NsimjkdkvGn+nZgjDO0u948tl6zcBJsgj2NJSVoOlrAZH3XTCefSN+3TqAf114QllJUmi/KY7kHQ6pPx8d2moyShyvXnsUhfPu5jieRdllJy951dk5lg4OyR1mfOLiorOaW4jVVX57W9/yyc/+clxFRcAWZZZunTpuBaSsXBBKS87duzg8ssvHy4P+ap8+tOf5uc//zn79+/nkUcewe/3U1VVxeWXX85jjz2Gw5G/cjGE4fw5Fxg+aMUFGFbmEnnmdSmggA8rdIaz70dwPkJvtTN+Tvp3h3OtwI7K4FjAWcG6des4ceIE991334SyqqqyZ88e5s6dO6HsSFxQb+jVq1ePGxL36quvvo+tKaCAAgoooID3B2cnt9GZnT+etaO+vp5vfOMbdHZ28sgjjwjn/eY3v2H58uXMmTNnVJ3f+c53WLFiBVOnTiUQCPCf//mf7Nmzh5/+9Kdn1LYLSnl5P6GPg+60nuSdpbF/jvC9qHtTtLn3Lhbt+XGNb5f7iEb5ahGLfUs1VO5hcY/92PNThLJJsyMXLRPL1RvE871zxS/BlMaSEqnJ7pZoqc21dOXajxZtqGTRcfF8SXPrwQbxD5XviOW++eL5abN43K+ZF/pe8d6Mb4rl0Jzs+WlN6GU6pXnG+0UbfGQc52QA927RuUK7RqR9YlvSGn9P51LR1yKWFMeBekrjEGnRpDMoyn71yhqncXu7eK+hi0RnB8NecWfSqNmiN4TEQRKZIgro7ZoTjoh9l6gR/VQ0GSowdGnCWF3iF7zu4mz6Ackn+mE4LOJ2v7dMvLZJ44GuHZOBaWI//u/pIiP33+//tFBO28VxIKfFcSPpxDE6OEVDa39MbI9vVvb67gNi2wY0qT2U/Zpt/kax3w0hTWoCi9hWRbN9L2soaUr3i32RtIptjZZq5ozGn8jSI16//epsfY5m8dyETxxTWn83baoB7bomaTZ1Fb3mOWv8FLWh1lp5/xSxPZZ+bToB8d6G/PXSifcxVBoJ5T3uFJ3p+eNZOx566CG6u7tpaxNzcgwODvLkk0/ywAMPjFmn3+/nC1/4Aj09PTidThYuXMj69etZtmzZGbWtoLwUUEABBRRQwHmOD2LnZSJrx0MPPTTqb06nk0gkNwXIT37yE37yk5+cUTvGwoeOYfdCgaoqJGOhiQXfbf3KmX8RXKCBZ+ctzoQVuYACPuw40/Xl3axhBfzPQUF5yYF8qanhtCKSjOSd2yjU10rvkQ00b/lznvWrdPXspKt7B0pi4lCNdDRMz/OPE+/PL7wg2t1OpOMUbY/98pwoMPFBL0oqSSqan7IWDfYRj/jzrj8dyC81AGTp+JVkksHd21DzoAg/0z5JJ+J0b3qeU8/84ozOyweJXs8ZtelM0gmc8ctFVS+Y1ANKIk60owUlNb75bySC/tQFr9AnuvonFjoNJZ1/37ybfgmeOkQynP9c7T+y9ZykRFBVhVBf68SCI5AMB0jFJo6QOpf4IHIbnc8omI1yILB+LclEiCkzbwFEO/tIe2vSrqfl2Gt0ntrAxdd8B6Pm/WwKiJM8WC/R33GSvp0vYp8yi1Qyit6YdYCoWi/K9yyzEDi2j/YNT2MqraS8YiE62whqbL04GK090L19A4E921E8A0j3fRadJVu/rHlXK4kEbU//BoDquz9N8eGsbTel8cso253xL/D5T2UWgH8QOWaKtmvs2CUQ6+mi46lfYiqvQvZFmXfZ14bDTUO1oh054YB4cIAjG36B2VlGxUVfFkJTpbRorzV1yvg2rSV4cC/mqhpk9FRek2VSDjaK7Y+Emglv3IlcZCfyyjvYK5qwWGZisNjprxD9AVJlSaL7DxHc+A7uW69HvzWFkohjmzw9c28VolIQXeXH/9p29G4Hnsdfo/SiScz55xvQ27sB8LdkjfaqohCM7Se4bjeln7wOVVHo2h0hPRjGMn8KkiyT1nCpmD0S3k1vMLh3WyYNxaJLcc7KMlKO9BmQFEgOePFvWg+STGryLGSDEUtthuXS9abIMdO/NExoww5SfQNYVyzALZ0g3DZA46dWIOt1NLeIJGi6Xpnwgf0ENm2keM0NRKVBjE316N2nfTJqM4q/kkgSP9EKB46Q7AtQ+9c3IulkKpvEF9iJ7fWk/H68LzxHyj+IbFWRbWYqv3IzeqedxI4RNzf5dN3hKP4nX8PjG8zQ9+t1OG++ArdX498zJ/vyC7SdoPX3P8VYX4WpqQ7HmktxdokU5X/zxieG/5/qH6D/wZ9gaZiEfeZcLA1N2E6Kjh7xuVHUZIrAm9tIenwokThKNE7RlcuwzJmMLqZxShsxvVPxKOqf9+ConIypqJSBhaIiaG/Ozo90LErE05bZjVAU1HQaS3sNRneWvTmmIdR2vGmj+dXHqF5+I2ZXOVENf5/WH8+/bzfJaIjyeauQ9UYUjYtbuCbb+ERvD4PPvYZj8iwck+egM1tGcakU78+uTXEnpBIROtc+Qd3N91K+SetHKN57sE4mHPMQOfwaFatvwnVcPN63UONP1xPD332EsklLkGQdoY+Kcd7Wv4z0GdPR69lNV/tmKq64Gb3VPopzShfXvOSjCTq3vUjjlZ9CkiSMwUx7Usn3T3lXVAnlPWaFfq/nn08oKC854PUcorbxUmR54i6qqFlEX/fevBhwAeKeLpAknHOWCIrLWEjHY3S/9RRIZJg0J/iSTsej9B3YgNldSeXia8Eyfv3+bRtJBwPorLYMnesE8HqPcfzki1SUzwdy04EDRNpO0fnof6PEoqSsNhat/KtxeTISkUGOvfoLUrEQkqsik+YgB4dO0jdA358fJdraDIBj1jzcs3I7fIWOHaL3iYdRE0nsV65g+g1fw+QYnT5BSSQIvr2J4NrNpH1+APr6+zHY3JjKK4eVl5FQVZWenz9HYP1ezE3V1Pzj3dQuGM2hoMQTBN/YQGjDNtLejBNqZO8JdE4bOocNXZEd86xGJI0XthKL0fnkXwgd2Q+Aa8FyimYuGPM+450d+N9+k9CBfaCq6Gx2Uh4P9ulzhpWXIaSTcfoPb6Hn8bdJDwaRjIaMsjHFgbWhBDWpwAiGYCWRJLx+G8FXNpLyZfIXeZ9/Dl1NMfqKEnBn7znZ04fv8ZeJ7j1yOleOzODWo8hmIydsOnRmA7P/8WqKpmaUOr3LRdmdH8H7/LMEt21DMujp+emz2JfNwG5djN4mjgPZZsF113X4Hn2e0PodGX4aWUZfvgBbw3Rk/eh5W7TmUtS0gv8vr5DyeLHMn45qrMg5JvWlxZRdexMdj/wS/9YNuJavpPKK20bJSwY99ksW4PvLG4TW7wJVJdU3gHnGJKwl07E0TsrML239JguyTs+Bp/4Vo92N3XcJRZdfNmZ7ZJOZdCxKz5tPkw4HQZKpuup23E63QN6mhc5o4eTLv2barX8DjJ9ywz11EYce/T79h7ZQs+JGiqYtyNk3xopKHE2z6Hz5T0iyjuLFq3DfdMP4nDaSRPD4fgJH92ArWTBuWwCUZAL/7k245iwDysaVNVqdDPYcp+vwWurmXYdRbRx3rSleuooTv/w+oZOHqbjyFoqnLB5XXtLp8TfvZaB+ByXT8uPXKeDcoqC85MC02bfjdDfmJWuxlVI/5cq86473dVN1w90UzVoA7eMrDP3vvEHR1HmULL4Mo6uEcNH4mv7AiV1ULrmWslmXIOl0jLdJm47F8G1Zj/viyyi+7Gp0Fit0jXMC4HJNYsWyvwOgeRy5uL+fwP5tFF+8GmNZBaaySuT28YdbpL+DxpUfxVZah6w3MGgfezFRUykix45gnzUPx7xFSHo9psrqUS+4Ifi3b6Z/3asY6irRl5dgnT8Dk3/svE+y0Yhj1UWYJjWS7Ogi0dGFfeUKimyNOdvtf+ZlAmv3oHNYscxqwNRQCYx2WJNNRhxXXoJpSiPp7lPETnRQfNflmOorUZQc96qqRHYfwFI7Ccf0eehtDgwud+6XSlU1xddcj2PhEhKeXpREnLKV146pWCvJOBZ3Jc5briTlGSAdjlB8z81MnuLP0TcGrMsXYHHXkfB4SHo82ObOw7B4dJ4lQ2UZ5X/9KdKBEMrhHSS6Bqj67FUosQQlOh/paBKTJjJINpspu+tuiq6aSmoggN7tIPTOYfrfeRvHrHlUrLlDlLeYKLnvTiwLZxI/2oKhpoKBtzfT+fKfmfzpv8fgcI1ql/PG1ajpNLLVjP+p1wmpmyi//EYsVXWjZAGsTVMpu/ZmfFvWEzp8gHDjTOyTZ46S0zmslH72ZhxXLMP/wnqc168kdqSF4K4dRI4dpvzWu8aoHUqmLCER9tO193V0RUU5n6skSThnLsA+aRq9a18g5ukk7u2FCT6YjEXFJI5tp/mV31D72S8jG3IThsl6IxWLrqJj41P07HoDS3UjRkfuNBquOUuJ9LTh3/8O0e423BN9/Jy+t951z1O6pgmDZXySNCWZAEXBs+FlyuZ9ckKCwLp517H3pR8T8JykVGkAXW55o6sEx7R5BI/uJRnwk9kSyy0v6zI7bh2bnsJe2YSJ3P1yrqCcBbPPeyW5O59wwaYHOFcYomKe9ZXvD1PJW/rELjKERygQQ1TmpxPfBevEryBtKLIcSuE7vI2SuRdnTteYccy+bN2qqhI1xdGbstv8+qjYloFZ4oQr3RYfnmgAnsWawToie3KsvR1z0ipsPY+kzQ9r3klak5OtUyz7Z4iKlaNZE5Y6VbNrpGnayG1yGE3pnXCK9641I2lDsQ2BjH1bSSTQmczES0cIaHRAVRP2KWtcnizTxbhSpzUTIh8+6cG/pw3T7MlYGsuR5EybAprwYqtFrDC5XVz8ok3icVWjzLgrRDU0MCjuqCmB7EtJdop1WfaKskmNjmeZPyCUBwdEpUIbyqwNWVf1Ynnl0sNCeU9vjVAud2jMRierhLK1RFT8Ir1m0oEgepdzVOZyrJkxpSoKkiwjB3WkI1FkSyaf0xUX7xfE152aMiwPoOzaScofpuLWzK6dPzQ6546qqiRae1AVlfQpBcu0acPHjH7xOcXKlGF/EEmSMPo06TeKNOHP1nRmnh84gqtMzOllFyNQ8V6afa4prx9bg/hci14Qn5vnkhThrbuJ7NxP0bWrqOmZJOzSaEOfE+7Mh4HnyccoWnEJ9qtFu5LtFXHgmH0KipLC130Yo7mI6DWThONaCv9Q+3H8h3eit9pxr7le2KXRzu3S3eBrO0DX/jdoWH47loo6oW9kzVIyZMoP9rVgK66lb6XY7+VbNbQLRomwp5VEeJBA+yEWVNwsHD91q6Zv98Y5+fpvsVc2UTp9BelGV6aeeIyjP/nm+5Ie4PvbLsf8HtMDxEIpvrns7XPa3vcLhZ2Xs4R8af8lnW5YccmnzpGKSz4YqbhMBHNdHUbfh8cGOhYkSR5WQs8FbJPLsU0uJ5L4YDLN/k+AJMsZxWUCmSHorBNndh+SL1k9e2JZScLUmFGwlDwSCp5pChBJkrDOnYnUm/95+hIX+eRZsC6Zi21FxjdK8kzMVivp9ZTf+dHTzLYTO9fKsp6Smgwz6kQZ7+11U7GU1yHpZFITpEwAcNfPwVxUitHmyrtPHWWNp/83sS+KrbwBG6dTFhzNHdoLmV2pqWu+OLyDOdG9FnDuUVBe3mec69xGBRRQQAFDkMbw/ZnwnHNIyX+mHxIWV8ah+oOOaTsfUgmkkUi/xza81/PPJxSUlwIKKKCAAgo4z6GoMsp7JKl7r+efTygoLzkQKwX59EeCrOEzj5Zmv0zsneI3gayhSig7Kv6hZ7lo1tH6Vph9jItoidiWqq2i8TdULX41OTR2c21IoNavJDTCz6Vi2/iRTd7Z4rWKTogTY3CxeHOOfaJpJVwv9l1osuZ62strwvx0JSI1vKLxeVFkjX+BJ/dXn6Kh22+Y2yOUWw9UC+VUnXivJQ6RA8L4rOjTMnCb2JbUDHHj2dAqmjqs3WL73LeK29qxuCZkd2TfaPph3q2iD8olrhNC+cfbrhXKUkBcFvTTxbDThFc0nUh6se+2tjUKZbVZjLSZfGWLUG73iM6yyQGNLb5ixDgyi4PCWiSOgfkzRY/ztW/OF8qpSnFMBnXimEj1iM9BNYidKVeK14uWaagKDosTStWssFozbWykr4fmucU0ocxExPmmdIo+KNpQaWOfZoxofEwVzdxXGsUxadoi1l/UIvbdYJM4nw0amohwdfaGjAHxvpN28WbLt4vlSLnYr8EmcYy5D4nHtbQOlRvF64WrxLK2rZ4l4piu2CpeL+4Sr+dsfv9DpQsQUVBeCiiggAIKKOA8R5r3bvb5MHEWf3j2kM4yUuEg8e4J4obfAy70IK8zbX/K68d3YFve8ko8f4bjofYMvriRwRc35ll//Jw+g/QZMDQXUMD5gHzZmDvbtxAKdk8s+D4iX3bzCxlDZqP3+vuw4MNzJ2cZg1s2Edi2JW/680HPCfw9Rwm0HZ5YGPCuf43eF58gFZmYclpJJQm0H8l7gibDAdKJ2MSCp3GmFNx97bs5tu2PhE8dn1BWTaVQ4gk89z+cV66SeHMrsaMn6fnBA3kvpkoiSd8vniS8/RD2lQvGlU2HIyS9Xrp//ADx5pa86h9C0tOH7+XXiLe2jXk8HU+iJFJ43jjIwdf+K6/7VVWVlC8wodzwNRL550u60BRkJRE/J+kG1HSawU0bCOzYRry5fULFWEkm8T75DL7nXiJ64DBKdOLYEiWRJNnrzT9tg6oS93Sfs2cU7W0nFcx/XAHEjrUR2XdiQjmnq4Ed7/wXp157iKg3/w+8M7nXWH8XiUFv3vLJoB/f4R15y58pgl3HP/BcS0OJGd/r78OCgtkoBwY3r0dnsVE6fxWmSKlwTB1heg40yijJBCdf/wuJQR8zZ38E14jF0TdNYxcOQqSrBe/aV9HbiqhpuBSzK2tvjRVrbOi9Cr7uY5zc+Bvq56zBdcXVwvGYxhbraE9xbM+LBHytLFj51VEMvv4m8ZEXH07QfOwVUskYU2beJISC+u7RGIa3O4n39dD85KPoi1w0eW7EFMxO6K5LNBMjJuP700ukBnyYp06mqn4F+LMLWHC+6A9kbjYx8OJGgof3UX7drejieiE6q/Yt8cWd/Ogx9FYj+777PEUNJej/6ktI6FFOU7LIUQ3HxoCH/kcfIzXgw33T9ZinZHkpZk3rEGRd3ccxF5lQVZXjr7XS80I3SiSB+7JZuOemKXOKL4ZTh6vxPf08yT4vKU8f9T+4m2Bl1k9FUsS22HZaiHS30rv+efS2Ihb/42TcM7P87cf/MlWsf0MRvjffRE0mMdXXkwjuwn3Xmmz9xuxzUNNpQht2k+jqw37xPNY9FiLu6cbaOAX71FnsmFuf6Q+Pj0RbL7H2dSR7vUhA8advpmyKyGljNYgv+/BzDlLxCFF/L7HBXvRXLEI2jXCgmDmSjyRAsPkgsSPNmKZNwn7xIl7bOVeob+6lGbrDZCjOzv/zCiGfAWNdHaa6OqwzZzB7UjZH18GTIvlQqDNKaMMelEgU5w2Xsq3TSDoYxVBShKHMiW5qJtzXUTqJju88QvKJfiSdzIIf34F7fi2n9on1GcISYKLskmvo+PVPGXzjLfRFZpY8+FGstW56XhP9cyLVGWVLh4HAq2vx7NqDedoULNOmYZk+DalGnP/lb2X9UPpPttP9l4coWrAEx4LFxGeLPiZxDXGR+/ko6VQcncGEzmAm3CgL8yM4L/sRkvKb6fk/P8FQWoJ1/jxs8+ZhMLuE+hIusX5LcwUt//3vNNz715jKKqnaJH5YhWsza4nBVU+FZzm9zVtI08Hy/7gFc4kN7381CvIjOabcRxT62nZhc1ZjdVYS1PiMBWs1/mypEk786gdUXn07RdPn4Twmymv5rqRqF52PPIFc4sTWOJWkVZQvahWVYv/ASZBkHKUZJl5Fk2YlbRbbE/EP4Nn0DnXXfhxJlome9slJa9MIFPC+oaC8jAPX3KWYissgMv4Xg2fjyyT8XozuMmTdxF3q3b0BJAnXjEUY7a4J5Qe6DuIsn0r55IvIxxgRj/qpm3I5esPEfBdKOkl/7wHqm65AkiYOkfTt3gyAubJ2Qvl0IEhw4zugqJR+7uMTGlzT0QihIweQZN2E4ZqJeIg9//AUAPV3LqLujgWcOJq771VVxfvnJ4g3t2CeOhnr/Dk55dqe2sfrv9iAe5KTmD/O5KvqqP/aGqxTq0a8LMSdrXhLK4G31gNQ+plPYKzMzcCZ6PbS88JTBI7tBcDoKkVJTRpTNh2P0b9rLX171qHG4+jsdpAkDNOrh4nZhtueShPauJvBZ98m1edDMuiJH2vD4qjGVF6FwS0q4bLZSKy5i8FXtqKEopn0ACfbCTS4MNe4Kb9xMcZikfhMVVT6jm2lc9fLpGIhZL2JhlVzReXldD8G1+9l4C9rSfZkSPDCW3bh+/MLyGYT1iULcN+6RjjHYDex+P9ex9ovv0Zg7ToMZWVYpolK3HAftnXhf+pVovuPgqoiGfSEt+xHV2RGZ7fgXrMUQ1mWG8ZQ6qTue5+l7wcPER8Ic+TfX6fxE8tQy6vGHGs6m52az3yR7kfuBwmOPvAW0766GhibiRfAddMa0oMBQlu3Edl/kOq//1t05Ob/KZ28lP7wCbxvvoxv8zoqvvlFjDWVOeV1BiPtu57H27ILgPqPfRlb49j9o3cVUX7vJ+l+8OfETjYjSRL2GZfmrBvAUORCScRp//OvafzM3wC552DdnOtIWE4R84bp39FO7bUzxq0bwO6qZd8bP6FxwS1Yai8alzZCNpqw1k2m4+mHKF56GbVLbhx3TZBkGYPDSccTv6PhU1/DQlVOWQBbcR37X/0PZNlA1YzLsJfkTi0CYCmrpvP1x5D1BmquuosPwmihIqG8R58XtRAq/eGHbLFResk1E8pFuluJe3upv/1z2JtmULZ3/G39RNBH3NfH5I/9LZbKOuTB8RUjVVUw24ppWngbkqzLS3kpr11IRd3iPCQhHg8wb8nnMVtcE8oqiTih4wepvunjFM1ZjPHw+Fv8wQ0ZxaXo2tVY582C3ePXH9i/G2NpOVV3fhJTWQVJLWXuaaiqyomDTxPrDWKuLKJsZdOE/Dmhd7YRb23FcclFFF2+atTLFiDhj7D/X9+gb0sLAHqzjk8+ezM6g8zm3upR8kNIJ1J4//AYhooyHJetxDJ7JozzpPQuOxUrb6B00WWkomHS8QjuGWOnNlASMWy1k2FKGalgECUaxXXllajlo+83PRhCtpopuvYiUv1+lHCUkk/fiKV1bEVKV2Sj5CNX4Lh2FaF1O1AVFeuC6VjD7cQ6B4bZgkdCkiXKpq2gpGkxA6d2Eeg+kUkroZWTJIouW4Bj1XxCe/sIb92NedYUzDOnoAZTMEbdkFFgKr/4eXp++WtMDfV0/tuPcfgW03CLuFtjrK+m5PN3k+xoIX68DSUUpfhTN2Cx5Z5/eqeNhf9+J6GWfmSDjpZH3sF/fBeuq6/EvmTxqJej3uliwY/uQGfWM7CjlT3/9BS2+lOUXXotOvPY91z60Y+QDgbRuVx0P/Agrruvw37xwlGyQyi/6Q5iHa2ZvD9vbML9sZuRjWMTTeoMZpou+ThFVVPpPboJU/n4L2jzpEmU3HYLkUOH8b/+JoaIHtfCFblTEOh0GIrcpEKDhE8dA0anQRiCwWRj6Q9vJBVO8M7fP0sqksRB47jtsRSVY3VW0nNiE/VL5uZM5zEE56xFBA7vJtrVSioWxmAbnxHW4CohMdBH8PBeXNMrx10TdHojk5d/jCNrf4XOMDH3jKmkEiQZ/5Hd2OumYF+U3/p6NnE2zD4fJrNRIT2ABkNUzBVX3U7JkpUAmDVZ5QNN2f/X/6UPvS77IvQsEyeYrUfcbvBZBzFYncMLpTKB+hipUMVJqNEX4pXiYq3364ZTFQC4j4jywQZNyKCGRDMyIrzRdViU7S3vRjKZ0LtdAJTt0GTwrcuW1XSa1md+g+umazHVZ7bmJQ3lvalfnEi+IzuwzZ2PbMgs3tqwbtOCTBy5f/0Bun/3BraLL8ZxyTJ0zkyfm/o0L595GfOHkkzhf30Xhkkr0NkzYbtSSmyL4kqS7O1HjSeQTEbch+3IBiOywYgkyaNSH8hl2cZFD51CSSiYZ08e7ndVYyYiJLZNNYv1adfZ8iq/UO73afIA6cTzU7HsC0+nCZGtWyD6JXTsFOn605owcW3YOJqQ87sW7xz+v6qqPHd8nnA8GRUH9exG8fqHO8XdBaNJHMNVrkFSoTg6i4H4QJja0AlqF2dMaj0xcX4ZNTzxGzeIjLnatdreLnZ0n62FweffwDS1kaJrV2NrEdsuLc2a0NLROL1/2khww15q/u/nMZS7SQbFnRWTM5NVWjLoSXR7ib/Vi2vxRcPHY5Vie6WURKLHg77ETeiZt3BfshqdObNj6mgV+z3pyLY9HY9iVMWd1cAVoplHPmZDVVWUaAQlHmfw5VepWX0nsj4zPiw3iPz9ffvLiB4/xsDLL1O8Zg0lNjEJqUnzoTVwevMyFQjQ84tfMuXmRqbcs2h4DjQ/k03cOrTOxXo7MbpLiU4X+9nco6FdaFZR0im8zTvpO/4OJX/3OXTWrMJYqvkQktPg7zyMt3UPtpI6ymevFI5bPOIY67gqc/1Eby/Gigpq1onPpe0aceBUbYS2vS8R8Jxk1uVfIlKXWfPT8RiHf/b+pAf4h803YLLnz6A+FuKhJD+6+MVCeoAPM5xzFuUlN1JxyQfGMTIZj4d3w8h7rlh8DZUVecuq6RTlX/z0GTF8OhYtmbheVUVf7GDGf/81wR5XXvXKBj3F1y8j0j46s+9IGCpG5Hhqy5/u3zJrEkrqw7MdeyY4V2NNb8/MK3OZg9rp5RNIv3sYG2op+6t783Im1VlMlHziWoquXY6+JHe6AtmSabuprhzL4qaccsNtqMzcX+mVayaQHNEWk0VruRwTkiShs9rQWW3UXfWxCeUtU6dRXlyCrqgI+vJri76oiKqvfpXuR/8Le4ObqlW579lcMaQ4T+z8Kuv0lE1dTumUZXitE48zV81MbCW1yPr812RjRf5rWt28zPP5oFjSFVVCUd/btd/r+ecTCspLDoyVhbeA/CEbTUj6s++dL0kS9jkNZ73eAv5n40xeSIZS17lryHkAQ4mWHW9i6GxWLn7gVnSms/9KOaNnY86Yos5F4PQHndolfRaySr/X888nFJSXAgoooIAC3jP0lvdm0iiggDNBQXnJAdeJNHpDZucgpQmbq9yW3WI+9inRF0HrQ+JoF7ejfQtE2+ukJ8RvhJabxUdibRc15UitKG87JcrbO8XrOY+JtPK+WRpqd40fij6cLetvE/eNpePiF5lvFiK0rhJJse1Gv3gtq8jAPyrvWaBRU24XbbSGQdFOHq/V5GbYJ27t60esrckS8TmoaY3/jhhBi2oSb07tEZ38VJd4bTWlSR/Q6BfKbov4XK4oPyaUPQnRmfHZFtFB8J8uf14ov9KfjZ7qqRTP7fKJ/VC3RAwLH4iIY2JasejkVWYWB/UT74jmPckq9qXOJO64HTwl+tho0w+kK8W+1aZiGGjKti8YEP08Lpp8Sii7ZoncIN5TorNyyiyOGa3vU+nlon9OZ594/oJ6se+OPCdG+zguF/N79M8S6y9/Sezr9N3Z9vZbxOcUb9CEAwfFflM1vkiqxv9GbxWPB6aK5cETYvSZq1Vsq+WmXqHs3SGaWKwaipeeX4nmIuPIKaKxyqVsGh+XU6JATJMGRU5qKtCsFRGNA7ujTRyDnZeLfVd0UjPfq8TjDS+J89mzWFTMpNNDPv0+bsYUzEYiCspLAQUUUEABqKpSMJefx1CQUd6j2ee9nn8+4cNzJ+cAHzSj4ljIl3X2TKAkzpzKXk2n8a19CzWVP+OrkkgQaW3OSzbQfpTkQP4MmwDxlo4zTiuQLwpBeRcuYieaiR45jppMTiysQTo0Mbvuu4GSTp0xs/W5Rt+e9We05sUHPBMLfYiQjp2bsVDAu0NBecmBeNTPyT1PEfJ3TiirquoZv9zUVIrI/vxSCaTjsQxZ2Ttv0ffwH8eVjQX68RzdwmDX0bzb0vPcY3Q/86e8qNnVVCpD+PbE08Q7OkDObwglurpp/fVPCB05MK5cOh4l6u2i7e0/5a0YqYqCb/1b9D34CCnP+AqPEouhKgqBtzbhe/rlCetODfpJeHrp/dHPSIfGT+WgHQNKOHLWlalzQZ9/rqAqCulAmJTXf07qjx4+Rcf6VtKJ8V+4xvpa/M+/Qvs//Attj/0K/77tec9X32OvEW8efw1QVRXvjvX0v/MW4ZO9qNr05mNAknWc2vRnvK/tnVA+svsQgy+tI3rkGOnwxOlE3i3ivl461j6Rd98M7N1MqCW/dSbsaSHmz1/ZUZJx0vH8U5wAhNomTlcyhFQsjJI+g1QbSpr+tROvF+cSaVU6K78PCwpmoxw41fw6gy37iOkTNDZ+FFmftSeHRpjwm56KoShptm77CXNm3U3wZtEGrrWlOg9lJk7riw8R9/ayZ80y3HdeOXy8/g/i4Gq/WqL/iRdInFYUplz+WfRHswpDUnS5QY6naN36BOVTVlBcOo32q8XwYKtoskcfUQgfPYSSjFNkr8N2RZYfIbClTJBV6lIE39xCoq2TZG8flf/rc6SNmVynADoNX4dJH2fw7T0oyTTeJzbgvvN2rPPnEDstH9NGKSbB8/NHSPZ7Kb7nDvS15SgjjOWSU/xyTsaaSXT2M/jmLpAkar/8dfQmB5xeI+Nl4kst0d2L77FnUFMpdDozZbfeicF7mu+hVGx72qwSPXoU73PPo4TDFN96CwapCE6/O9wzRCUp2B2l78/rKL5hGaGdx4nuPkq0fYAZ376Vomm19AWyD0qJxolv2ETtFZNRFZXBE15+djBEuLkXWa9j2r/cgXdXNjxYVVWi/qMEXl2P44qLAfjWNiemybWYJ2ecc4qdmVQOSjJNzw4PkT3HURJJSu+9nhnVou/S8uIWofyXt1x4Xt5L3WcuI9ruZf2xIIn2PpAlyu5dg9MWHW5H5Hg3vPM4slFH48eXoqYU2vscqKnTY8BpI752K92PbSY5EAJF5ebPlXHr58txlmT8Bv5h+13C9YvsmfojJ3vpfWoryZgd2WRCZ7fhvPwy7KasApiwZOeTcW4l73zzdRL/ZwPWBbOwLV/IpDWicmesyNRd888fo+NbvybcfISllwS59eOdGIwyP94lpttobRXHvNHdQNe3f03Zxz6Gff589nRNEY6n65TT11lK7wM/x/PVDvRuOzVfvwPb3EZsVnF3pXdVdh0xlC+n9ce/pvup3bg/dhOmqZrw61DmXi2T5xDZ8hj+xzMvz7pPXULdPZeg/rcYQl7x163D/4/0BNn84z0Y3CVYahux1DbCJO1ioVG25xbjf+xl0lNtuG6/Bv3jYv2JSzQ7V5UO2l94mOq//muM5RWoOnHtipeMmLsllZz4r+/jWnwRxZdeib1L9M8pahZ3NZKzzJx88VdUL78Ra1ktVZvEudw3X8MT44X+7W+jl0xYK+oxhER5W7uGnTeq0PrGwzRd/ilknZ64S5OeICaOo6TPj3/XVkouvRq9zYE5QxpN+n3Mv1rweRFRUF5yYLB5H5byOopnLEXSje9FL0kyOp0Ru72K4LiSEPf1ceq5/ybhz7xQDNWl48pHT5wkuClDyV/68Y+ht9jHlbc4K7A6q3BWjE0bPqo9/j6UZJzqFTdRNmclkXFk1XSawBsbSPcP4LzlGjCMP3z6n9hA/+PrsEypofGH95FM1IwrH29pJXr4KJLRiGQYv8+VaJzuf3+cZPcApZ+4kuJbLiF9MjdjZzoYou+nvyXlHcC6ZAFVt39y3NDHdChE36N/Ih0MYlswH9vcuWPKqaqK99U9dPz3WyiRONGj7diXTqPhs6twzKxG0mUVTSWeYPCVbQw8sxElGOH4o3uwVjpwTilBX1dL1e3LsDaNUFoUhdCBvfg3rCXe2Q5Aqs+LobIcY7UbU5PYn5GTPbT94g1CBzOy6HUE1+2m9TRTcc01M5jz9dXD8q27vKz75XFObu4DCfw7mrHUlyJVVmKsK8fUmCWTCx3qoPVnrxFtzjhxygYdHU/vRTLoUCQ9kl6HsaaUmm9+gvIbFlE0v4HOh9fh23SUruY4/3DLMSQJJs+z4nOtw9RUg6mpBp0964BrnVxB+c1LOfndZ0kN+DBUlKN3u0lPrUBnHj0eJIOe0i/eQ/f3HiC8dRfG+hqgbJQcZNh1q7/1SabsfoqgN8EPbt3Bx749bcIV0DpzJv1/+QueP/wBNZXCsXhsZlXZZKL8S/fR+8ADpHwhBtfvxzypAr0zN1+QeeYUTDOaiB9pJrr/KMbJjUK6h+H7lGVK7rkbW3GCgU3H6X1xLzqbiYr01cg51iZrpYPSy66l7ZGf4duyFlNVLRVf//KYzNJDMFRm+i667xj2S5cA43Og6F0ulFiMnt/8hpq//hsg99qkM5txLlyOd/3rBPbvounKe7GW5l4PJEnGWt7AsacfoOaim7GW5GYGzkKl7c0/Me0jX59ADgwWO9GBbprfepimKz4NjL/exPt7UdMpfNs3Ubb6ugnrPxdQz0JWaPVDxLBbUF5yoP7qe3BNXYgkSUgTmMolSWLm9NuR5fG7U1UVYv1d1Ky+DYPDjdHhJnxx7i3vdDpJ/2OPY54ymaJVq7DOngV5uIyUNMynqGLKxIJApL+DquU3ULHg8gllo7sPku4fwLp8IfZV4y8mkf0n6H9sLZJBj6mxHJ3DSnICF5bghi3IDgelH7sTy4xpkKPfVVXF+5unSXZ5MVaXYih3j7noD8snk/T94iHQ63BceSmWOTNBVUfT2o6s/7HH0DmduK6+CtvCRWPmVVHTCn3P7yCwuwXrjDpUVcV15UKcK2dTZBW/JFVFIbz9CCl/COvcJozBfuqunsrkOzJRQp3BMUjPJAlr01T0jiKi8W6S3R5M05uwLpyN3jp6y9s6uZIZP7oHz8k44e2HUUIRiu++iumVo7fr4+EUof44TStKCRXXEuvxU3/famxN5XgDo8n87LNqmfXAvYSPd5PYl4mMavr0CgDaBkanHzDXljD5W7cTOtrFVy/ZSVGxHp8nyckDEY6+mmLw5U0kmjuxLJyO65+yLwPb9Gqq/+Hr9D/2F0z1dYT3H+DAljeY99NPjzne9C4nZZ//BJFd+wlt3EZzsI2GL1yJzjJaaTBWlXDrlU3IssSRLT4e/eejRBqepPjj16ErGpvAUO90Ypk+nURPD8bK3HmHAHRFDur/zydI+cOEdp3g5N/8gqrPXIFr1eycc8V16zXEDp0gtH4b1kVzMTbWjiknyTKT//Y6SlZOw1xTTPsjG+ne9m/UzryassbFSPLo8WmqqKbuni/R8cdfgqoy8PTzlH70zpztN9RVUvL5uxh87m10Ja5x7xUyyouhohJjRXnOuTQS7hWr8O/YjJpOY5jgIwygeNpiene9Ttf2l3EtKcVVNsEHmSQT9/XSs+0VisuvnbB+W1k9vlN76Nn3JiWXj6+QJLwekGRCR/dTcskVME7OqgLeHxTSA2gwRMU87evfR2fKxPoZNdsp0ogdRVnzgk1rxrQpIHavNuw6oCGjdLRk/x/2tBEv02GuzH6hWMXoRaEtkKHhTidi6E7HKcqad5x3pbjPaXgnjMGZffmMvNfkiPVcVVU6X/wDznnLsDdlaMMjNaLiZanM2FRS/hCe37+OpXg29plzkE/3o6pZX5PV2bakQ2H8j71A8T3Xo3NkwknVfvEr0d6aUVACJw4Q7jiJ8cqFGGtrhl8MNTPEznEYM1v2kU4/ACFX9sUQjop1x6PZL6+UL0DaH8bYkA3ZlTR5lgxmsWMlzRZ8zC+GUttLxD2tErvou9AfFF+euo2iMpO4WByEybioKF8xNRtqbdEMyk09YtLHSEwcpLIsDiKd5l6CmhB12S2aQmS9eL7TISpu353xrFB+uCdjmlRVlVQ0xcmoGBrttkQztPaJFDqTAW/QPLyDFTkkKkpK/WmTViqNqigknnkeY6mdmo8sByAUF+81lc4OQiWRYuCp9Qy8tofKT63GfcU8goMaJcZnJB2OEDtxksFX32DSJ/9WUGSjteIcmDmzffj/wWYvO76/AeuS2ThvOJ0UcUBsj2pWUFWV2JETeB96jIp//AzG2syOh9Uh9nN4UAwTT3V34nv8dcwzJ+G8YSU1j4t1B+oz7Yx5uzEVV5CI+DEWZRm+wzUas5ExU+752a9xrFiKdfl84XjRUXEC++vjqMkkXd/9IdX/559w9eamjTAFMmMk2N9K2NdJoChEyZVZhcGs+bAJTMv0a//vH8c0qYEmw0XCcW0odeLiIH2/f53YsXbK7r0OS2CaoDCOteEwuHsbSjyGc9FyJv+mVTiWmFUvlCMxL6eaX6e8fC6lpTPpvCKzRqVjMU5+//1JD3Dfuo9gfI/pARKhJL+57PFCeoACzi1s5fVI+bNXD0NnnDjR2BBGKi7jQlGouuFuZMPEXxw6p43qr91G+mD+k0M2Gin7cu6vwpFwTJ5N0ZQ5hOryc1611rgAmMDfdhh6dxE6Z2769wLODiRJwmA1wBhBHJIkoTNlFuqRprecdel1SOiY9JUr83Y4lY16Kj9xGa5Vs+n+7Rs4FjaBPHoHRmezYpt/2mx4Bi4DjqYSKv/5C6iJ8R1DJUnCMnMqpV+8a1hxzwfG+koq/r9PTujEbS7JJHAcqbiMB9fVV+B7/qVRyosWstEARgPOa69CCYYYz2w0BEdpA47SBvSz8+vIko/fkVEW35lYtvQTVw7vwEp7Jq6/aMHSvFlzrZYSamsvxmC0fWDh5Ir63n1W8vAlv2BQUF4KyAuSToesz52SXpB9N/mYjAbyyXfybusv4H8OznR8mOtKmfQvHwUg6s8tZ5s/F8lzZi8uSZaRzPmZGCyzJ08slOMaZxOmKU2Uf/GzecsXXX56V+nU+HIjke8zGstcm1P2DPvhTMeJ01k/sVAB7xsKyksBBRRQQAHDkCQJnc2GqqXFLeADhXIWHHbf6/nnEwrKSw6MTA+gDQFUDNmyvU3c826+UzTZOJrFwaLXhPMYBzXlkLhghOrFayc1u8rBmeKWdPFO8ZFqfWqm/kqU980QbaiBpuz1SveMvx2tSuJXkf6EaCaK12v8RALivZg0mZtLV4j5Ajx6MXrIMlXsPLvGV6N7r+hQmZ4rOqrqRvitxAbF53Tnop1CeX23+BWs01wr8JZoz5ty40mhvFeTXyDcI26ph02i/4I2bLV+jci93uERzXuLG9qF8o7euuH/a60m904W99xNGp+YXx5fKZTDEdEfSF8mjnGdxsflm3NfEcqveOcI5f9qv1IoT3OIz+WoJEYITXOKod0md3bMLpsh9vM/vyaGXXf6xLoctaKvUKRNM6bqxONaX6bZi0RugWPPiY7w82e3COUWv/icrp5+RCgfD4jRhaeOVg3/371RHJMDl2jCd/vEuZrWUOx7PinOj8rfiWMs/Tdiv2qNul0HxfmjavoiXixez9KrSf8REOvzzcoOxLJd4r1o06jENdbrsnfEutNGzTqosVCVPioujIpBE+qsyUod1aQTOPLP4nO1tYnX12lConVD7kjvZ6g0EsqZ2C1z1PFhwQWlhq1fv56bbrqJ6upqJEnimWeeEY6rqsq3v/1tqqursVgsrF69moMHD34wjS3gXaPgQ15AAec/VPXCIUws4MOHC0p5CYfDzJ8/nwcffHDM4//2b//Gf/zHf/Dggw+yfft2KisrufrqqwkGJ2JfGY0zTQ3wbieykpxYdU9HoyT6zi0V97thbo12tKDmyVKZ7Osj1tUxsSDgeXkfbY9sPKO2hJs9eF984YzOyRdKMk3rr98mFc6fzj1+qgMldn7Rvxdw7hBsGSDSE5hY8F1CVRTinROzfY+Er/8ESjq/lAiqopLy+SYWHIGBresLCsz7iALDrogLSnlZs2YN3/ve97j99ttHHVNVlfvvv59vfetb3H777cyZM4eHH36YSCTCo48+esbX6m/fTfPup/D3HptQVlHT7DnwMJ3d2/OitFdVhehAN107XqbnjWfGlU0N+vG+9iKe558k3n1mi1e+SEYCtG95mmR0YiVPVRWUdBJv+146n3yE5OD4C146GCQdidL769+S9PaNKwunGWKf3417yaQJZYcQaenj6D8/gaVpYofHRF8AVVEJvr2F8I7948qqaQVVUWm5/0WSA6ExuUME+dOu/G0vH6Hvgd+T6s0/N1NqYJDB59cSO5Jf7qfYQIQTf9nP+r99YUJ6/AsB0eZeQgfbiPf4SMXyp20/E4QPtpLO80Mm3u4htO0wsYHxaBuzsFYVseXvnqPjwRdJePwTyid8ETqe3k06GMqrfkmW8b/1Jr4338j7QyMZD3F416N5fYhJsoT36WeJtbROKDuEWGcr/etfy0s2nToz+0oi7CcW6J9YEEhHw8TCA2dUfyoUOKMdXlVJE2zNP+XKucCQz8t7/X1Y8KHxeTl16hQ9PT1cc801w38zmUxcdtllbN68mS9+8YtjnhePx4nHs1/IgUDm66mrczvx/i7SxRaM7ulCeJyjLfs1459mIR70MrDxJIFYD3PemonZMdKuLS40fQtkgrt24X31efTFJTTe/nnh+MAsUTO29jlo2bkNNZ3C4FMwanxe5LBohy7f1E8o1gdI2M2lGEMlwvGOy8UKLH3Qtu1Z/Cf3oMoSjdyCfJrwqnuVeC3VpBDatJ3o4eMkmtso//++QLqimOjpKCFrhWYhbnPge+VV4qdasC2Yh3nlfJIj+sN5VJxIHfvd9D74S5SYxGBiBpZDYthqb52oPCjedqKHW/A/t4HSz95C2aVVgH/4uHe76JcSjXvp/eXjyFYbOqeess/fjMGeWVSLdKJfh6fXif/p10kHw6R6E0y6/vME12Wny6ybRaV2+8k6Bn7/ApJeR/TACSq+/lUMpcUMURYbS8X6rUe3Y6lyEm730fXyQfxHvNguWojO6Ya0zLWV2bxX/u4oF5emsBQZOPBGL3tf6ubtoyFmXFXNdV+dRJ3bQ6k9O4aPbhvEs6ODKR+ZT+DUAL96K024ZYBQi5faW+Zxza1ZB4NwfxTrM39h0d2TkfUSvrYQnrYYg+0hBjtClEx10bfqDgDS4SjBdXv5zPIjLFrtJDCQwt+X5H/9dhlpf4j0YJB0KMql/2BCSSn4D/fi2dpCqqWba7+3Ap1BBlnileMzQZZAkpAkiasbjxK3J3jtf2/m5MYujgAll01n+jduRNLJlFmyMe5be69AVVV8G4/gW3+YZOhB0qEYjmVTqfz4ZUQ0/D0/nvuX4f+fMsT46h2Poyt2YZkxFeuCufzf63YI8v97Q+bDSHXUEHhyK6/8aAf68mKsi2dS/NFrMWgcRUb6uJTccxVt//okvjf3Ufu3N+NaNYe1rywQT5g5NEdcDPQdY+Bn38Uydyb2i5bCjJlCdI3kF31cbJcvwnP/74icPELp5+7G3i3S98ckcW4nbqjE+71H2eV7kpJ77sK0tUo8XiPuypjqaun56c8o+8THsC2cj96j4aSZJc5vtcqG963XkOZXYV0wCy1LrbUru5ZFLDE63nyY4tkrKGqaQ1rDdxWvEBVWw0ARxx/+EZWrbqJo8mwCGt++updHcLioJvY2/wlUcC25CNvUmRiD4tpS+7K4cx2YGqL36IvUrbwDWW8kadP4uGg2TdPhKN3rn8Vx998jyToqtmXWjVQqwcSftwWcC3xolJeenoyzZ0WF+MKqqKigtTX318QPfvADvvOd74z6e7y/C3vDdEoWXDphXH8i6EPS6Zl81Wcw28en+1eSCbyvvkQ6FMQ8qQlJP/4jkHQ6TKWVSLKMpbIO8tiZ9oZO4bY1TCwIDLYdxn9yD/bqqRQ1zBr3XpVoDN/TL6MEQjhvuRZ9+QT3Go0S2r4TNZHAtnghqqqOT8k/OEj8VAvo9SR7+7A4xmY9HcLAY28Q2XkE122rsS6aznjec+lolN7//m+Snj6MNUYqv34PsiU3VXo6HPn/2Tvr8Dqua+3/Zg6jjpglyzIzxZjYccgOY5O0aaBNm7Ypw+392tveprfMjCmE2jA4adBO4pgdM6Msi1k6zGfm++PYkvaxdWaU2qHqfR4/0WTW7LNnZu89ay94F/6X16LGEhTc/SEkQ/b3FFy9lcDKjRgLcyn9v08jc3qeGDWVoueR1+h7Zi1Gp4Xc6eWUXzEVx50LkE6Tir5vZRvPfGsPxWOcdNUHGX9eIefdNoric8rTysDJdlWVtm0dbL93F23bO5AMMvXPHsBdk4u1qhBHTT7FS8fhrC0Auump97PtgUPs/1cDqYTCjseOYXGZyK104Kpwk1PhZMyFleSNcdN0oBnfK1sIrN+LGk/w28cNKIpKTp4RT6EJv1HG6HFhyHFiKskn1Obj4B820L72GGpKxWCWeeDa51EVQFWJJ56DE8VMq390F4wCi8vM5T9fzOY/7mHb3/cR2NvCwW+voOTKGRScW4gkD4wbSZLIPXcCstlI419eI97SS6ytj8DWOszjRmEbX4V1QhVGjxicWzPBSuFdt9Hxu7+QaGnDVC6S4w2GJMvk3XE9KHFCG3cTPVBPrL4Fk3H8kNfkLJyAY0o10YZOEl2+IeVOIu+6xYS21RPZtQ9JlrFPmJRV3jplHIZcN7HD9cSOHsdZUpRV3lRUCLJMeNsubBPGYRk9J6u8bdIE+p5/ka5HHkd2OnBUjssqb3Cno2aDr27AOr6WbBT7JmcO7tFTaHjhPsw5+eQuvpCcmfOGXA8k2YCzaiyNK/5K4dyLsI6/aMhUaEmSKLnyRup//2NCR/bjmjyDygs+hJxlbXWUjKL+1Qc4/Oxvqbn4DiA7B04yGiba207vgTfJn7wgq+zZgsIZqG00zIDdNWvW8JOf/IRt27bR1tbG008/zTXXXDOk/OrVq1m69FS29gMHDjBhwoT+4yeffJJvfvOb1NXVUVtby/e+9z2uvfbaYfXtfaO8nETmZND6YH7ta1/jS18aqIXh9/uprKyk5LyrKJi1JH2tRnHTWLCXUefdjLO4BkLZTZG+dWuQzWYKbrkdx+SpyH5tM56tsBxHpX4OiMq82f3Wk2xQU0lC7fWMv+5L2AvT2TFSlv77XnwNJRzFdeG5OBdpEzwFtmwDSSL/phtwLRh6oTqJlC+tmRV88ANYRlVBFq9L7GgD4W0HMRZ4MJcXnppiMwhqMkn7Yw9icLlwnjMH+8QJmtwbgVc3okbjOBefg3XCaMjisQu1+en95/PIOU4ci2akixSeZmYlvUHaf/kYkX3HMToteKaWMeWbl2GwGPHVi+8rHknx4o/3s+XxxvT9BpP898tLsDjSDQdS4rgJd0fwNvgomlKAIddFzBfhnHsuwpprxx8XlbRUQsHbFCS32sXEy6vpO+7nnFvHMv6iNJNzJCV+hIydbhzzJmIsyCFa18plC/184POl/e/z/20V3biO0nZm/9+lxP1ROjc1oBw+zuKvzEQ2pvv8cv3EjCeTNvnLBpkFn55OsGw0ufNr6d1wlOaHN3H8t35qrp5M7U0DpGmSJOGZNxbr9LH0vLAV16xalFgC7+52gpv2Et5TR9HHrzrlHVjHjaHgtpuJHq7Dv2o1v+2K8+H/qcZTdOp4kGSZwk/egKkkH3N1KV1/eIJAcRUFF1+OKffUj50kSZR9YjkGh5WG7z9GKhQjZ9p1Q3+gDTIFd3yQvqeeJ9ndQ8/Dj5P3gWuRzacfm5Isk3PZUpI9XkJv7iLvyjlZNxuSyYj7kvMJbdyKebT2ZsZcXoZt8kTiTS0Ycz2a8paxo3Bfej5KPJF1I3ASeVPm03dwK+G24+n+aawHOeNn0LtrPb4juzF2zMBUOrSyZnS5Kb78erpeXkG0pZFYbwe2ouy1k3JrptG1bx2tm/9FwbgPZd1IpqJp61/75hfxjJ3JOxFxoZ6BbCN1mNefjDP9yEc+wvXXX6/7ukOHDgkMvoWFA1mAGzdu5KabbuI73/kO1157LU8//TQ33ngj69atY968ebp/4z1bHkCSJEELPHbsGLW1tWzfvp2ZM2f2y1199dV4PB7uv/9+Xe2epGK+qOazGOX0hAxOESeNb/TAIPfUJYnHgpgt6V1IoCIjVbl24PGqqRTKG/txj57cX4sk5hF/P5P+318DwV07cUyekp5cGW8rR8wcpXdqBtV7NEOZy5hzSY9ojjV6B/pvDA1cm/B78W5aS+78xRjdJ6wKGfNgMMW3qio0r3uGgnlL+1l8kxkur5xzxBiYzp83E+5sonxh+qNTcGOjcP7I/vITbat03fsAtlGjcJ23CPlEEUclN8MM7khbYlLBCJJBJhEfZA1Jip035gzYiZVYnPZvP0r+BcuxVY0C4NLL3xTkN5yg3FdVlbZ/ruOn5x3l2kudmE+kdI5dfYcgb7YkSPpCIIHBYWVZ7RHh/LaeSuHY0tlCtDuEwWbCaDWxoKwZd6FFsLYMxkdyBrLq/uydJpybZxcHySe3fVi8d4MYE+G0ihYsOaM0QiQhjvGLK0XDeThD+TniF9OX8yyiC605KFqpCmwiFfLe7QqBzQfJv+E8vpmRlr0lKMZG7egRU9RjKbGvbUfT1kI1kQBZxrDnBfIW1GKvSrtX5xaIY+7pA9P7N0BqMknk9fXIVhN5y9IFGh0W8Vl17Uvf68mChRUzbcz84qJ+y1EwISomB9uKUeIJJEmi9zevYC4sxjM/TfpWu/i4IHugviwdp6GqdP7879gmV5N77fn9500HxQkWHR1DVVX8L6wh2dHDzG8sEc431IvrmqXdiJJIENi5lcDenYz55Y2CghE4KuYzS0o6pq35pz+l8hvfwJnhZgoPKj9g7Ui3E+1uJ9LagOMDFRhzByxjqQOiP06V0kHK3rWvE+/qZHL19cKGLGkX50Go+ET7nS0kQn5SBVZsowbGhiMjV0BSIdh6DH/DfgqnnYfVKP5+wiGuD9EjR+jcvw5bXikF4+aRG0iv98lElA0rv/W2lAe4ftXtmBz/Xk2lRCjOkxfd/5b6m/nNPR1OWl76+vrweDynlbnpppvw+/28+OKL/f9v+fLl5Obm8vDDD+vuz/vG8lJTU0NJSQkrV67sV17i8ThvvPEGP/rRj87qb59UXLQgGQzkjJmmLZgBx7Tp7zirrNGVQ+ElV+q/QIWSi68dVr+tniI8o7NTkgOQTJL/oRswWfU99/7KxTpjBtWUQvmtH9fF7ilJEmW3nMdNMzs0ZY052d1gg+GsysVZNfCxyM3XH/z7foOlqghLVXYXyXBxsmp5xU1ztWVPjGHJaKTg6vm62petVko+/nHUNx8kHohhyRm6ZIdsTvel6MobNINIJSkdK1TwyZsJrlqjaVmWJAnXhfPp+vU/UFOKZqkF2WTCPXteOsg3pYAGq7bB5cJaW0t43z6chTOzygJYC0qwFpSg5Gr7vyVZJndJmiNI3qYvKN1aVI6VcmL52rKO0lE4SmvSzy+W/bk7S2pxlQ7iggmcnaDytwsnYztPwmKxYMlScXy4mDlzJtFolEmTJvGNb3xDcCVt3LiRL37xi4L8smXL+OUvfzms33hPKS/BYJCjR4/2H9fX17Nz507y8vKoqqriC1/4At///vcZO3YsY8eO5fvf/z52u50PfehD72Cv/32804rLW+mDJMt6Cs0KsBUMbeYV2jaZMJhMcJbWD4PdOixa8hGM4HSQzWZm/9d5w7pG7zwzOB3k3Xyxvn5YLRR/9aNIBn0KsCTLeOadi2TUl8FTeOONSBYLtGrLvpswnBpF74Y1+Ewy7FZWipbeb33rW9xzzz3/VtsApaWl/PnPf2b27NnEYjEefPBBLrzwQlavXs3ixekMkPb29tPGpp6MW9WL95TysnXrVkGDOxmrcvvtt3Pffffx1a9+lUgkwt13301fXx/z5s3jlVdeweVyDdXkCEYwghGM4N+AbNVfCHYEbx2KegYCdk9c39TUJLiNzpTVZfz48YwfPxDUvmDBApqamvjpT3/ar7zA8GNTT4f3lPJy/vnnZzWrSpLEPffcc0Y0yKarSjFY0pPSmkFlkhw0V/tqxUdY8aDIBRD7hJidEMpIcHBn0HqEM6pIZ6bsZTC7o2QE+EspcQAkc7KbW/O2iQ30TRuQt7WL1oecS0TNuMsnum18nSId+dhJYpTr8U1iYbNMyv0+cTNAeK0onzm9ZlwkPus3t44VjjMtwcZB9OpKpRh3oTaK8QLOWeIuda9XTDMtcIhxGV9sm002LKoUq9ataswYF73i74+dckA4/tNecQcvZZQTOFg90L9Ve8SslQdzRddIdb64oz5yWByUzirRv1ZoF1Nkj3aLWWYrDk8Vjl0OMcI9EBI/bmXV4rMoymh/Qa44KY72DPzey71i6YEtreKgGV8oxlF5Y+Jv33vpX4Vjtyz29fZtHxGOyYj3CXSIYz6WlxHNXyYeb39DfM8pq9heyjkw31IF4lw9tnqUcGzO2HSbpopjWJkmugLMinhB4zHR9TZr0nHhuGmjmBQQDotByaY5GRw5e8VNoZIRjmFrH1iLLF7xXCCj4nzmeVMG60L7QvFecjOI080ZXUstFJ+FNaOvUkp8D96xYvtyhos5ZclI7c5JryWpWApW8p6D2+0+azE6mZg/fz4PPfRQ/3FJSckpVpbOzs5TrDFaeP8w1rzPoSrKu442X4kn8L646S2x855pHHvuIKmQPkKxk1ATyXRm0Aje94i0et918+e9Dj2EnP9W+++CdeXdhJO1jf7df283duzYQWnpwOZqwYIFrFwpanyvvPIKCxcuHFa7I8rLGYKqKqips/ch9O/cQvcr+unvA1u2kvSdRbrylEL7r58k1tjJsINbhvM7Oj44vQe7OHDf9v4gTD1I+UO0fe9vhDZlZ9kdjGBdF/G+4SlIZxOJjl7Ce/Qx8p6EEtNHF/9+Q/BYF7u+/Dj7tmm/PyWRpPfZ9cRb9DG8DheqquJft25YdPyqqhJt0s9++3ag542VZ3XN69yz5qy0m0pEScbfPfNYL066jf7df8NBMBhk586d7Ny5ExiIM21sTGflfe1rX+O2227rl//lL3/JM888w5EjR9i3bx9f+9rXePLJJ/nMZz7TL/P5z3+eV155hR/96EccPHiQH/3oR6xatYovfOELw+rbiPIyBJIhv+6JqaoKLa88ytGHfoqi6rsmfPQIwb27admsrZCoySS+rZtwjMvkxzhdX1TCBw/S++xzSGZ9H3NVSZGMRbQFB/3Gsd+tAkWl6GNXaPoqQ019JIJRkgFtZeqksqLE4/Sue42W+/+UVYFRVZWdv9rA1E/N7c/a0EK8s4PWb/0J++wJOBZpZzelonGO/mkNu77+DJEWb9a+JCJJVFUltO0Aoe0Hh5Q95dpEkvDOAwTXbdWUTXT76PjTszR9868kOrU/gGoyRWDzQZq++0+O/7+/Dvk830uWiZZNzex/eC/BnXUkegOafS9YNAZVUfniBxr55p1NtBwfOvVMNhkxlxdS/7nf0HrPvQTW7ECJDS2f9AWJNXWS9IV0WQskScJYUEDT935AzwNPkOjUDqSVJAnf1o10r3xe97qU6PISb9MXpJsMJ+g6uHFYNd1inW10r3pet3ykd3gRvV171xBs06+cq6qKr0G7EK9sNHN43f2EffoDRFOxyHtqfpwpbN26lZkzZ/Zn8H7pS19i5syZ/O///i8AbW1t/YoMpDN8v/KVrzBt2jTOO+881q1bx/PPPy+U9Fm4cCGPPPIIf//735k2bRr33Xcfjz766LA4XuA9FvPydiL62nrau44wdf5dBKd5xHMlAwuUo0Em1tOBd/8WDFY7XRMlcj0DhFDxDLeiIQahIwdpf/R+jE4XhV++nd7Sgd2wc7/4AQ5WpWj/5R9Ihv0wpoC4WZxAaobiYOyJ0/Hnv2B05ZA62ESRXfS5RzNKz7ubkjQfW0NP+z6mzb8L39gBx3VwjLiQTbD5UBIpDj+8i2RjOyVf/biQeim5xV190+oqwo31tD7yBKa8fEgq1Nz2hf4o/45u8eEYChvxr96NbDPT8/R6rJPHkfuZq0kUpgN/jM1i/MK2bQaiDZ2E4mZ8UxehdoofDneuuLsqde4n1Oxj2/2vUv6x5eQsmshJBkKfS3TYW+UIfZuPIRlkjv3uVaYt8fChZ87F5g4DR6mxiHTj//PGNfQ9/CyS0Uh0/1HsuRK1dy7CU5zevdcHBuIHVEXFsvoVaq+eQPubzTS9Xk/7xmZyJhZTtWwipbXNbG4ZGENKLMG1xWtRVZU19x5h/8o2Lrq1lPN/OA2row9YxT+aB+Ja7ih+nNJaO50NEdY/0c6rT3mxVBfjuWgWrjnjOHpY5FUxphroevQNcpZOR4kl6N5wnODRLvLn1VBx5VR88fRzT/gj9G6sI7rxac751HQcxXaUuMKbTaWoiRRqIom5OJe7x2zsbzvkS/Ldp8cQ2X8Ig8tJzmUXs5lyMMj9Su9fZ6U5mNpbkvz8Wz18u6UaY14extxcXPPmQd7Ae3+jL836qjrH0LvjGYJvpH3ppdfOZtQnL2B6jkjo8VT9gHJacPsy/F/9GwcOKuySJ3AkYOGxQ7ME+c9MXZ3+YxI8fqyc9Y80YFcCLL7JgsluYl3jaEH+O9NXkIwrPPDDFl56oAsksFYVMvYHH8LkcRDImENOS3qOOGtLiOwag3/tmxi6Gpn+w2tp3yvGbOXOE8eYNziDzp/8mVDzEQo+8UFcKTFOKtInzg/XfjuH7/8hlcs/jKNsFFIGr17nqIyYtcQ+2l/8BUWXX4991GgSOeJ8Mu7PiBspcdC3ejWGqSU4FswgkVHOwNw3sDaZgtB7fDeG1sMUzTgfaZIYpJLcIbYdGJ9EeUylftMjlH7zC1i94r32TRTXQddx8B3bg7/hAK7aycibxbUlJgx5A+q4Yva89hsKb/sQ9qmTydstiJ8Sm2je20dv4y4qpi1P//749L2lNAhMzyTOZMCuXmjFmd53333C8Ve/+lW++tWvarZ7ww03cMMNNwyrL5kYUV6GQHfbXqrHXoTJrM3NEW5NByAWLVhGLtkLCiqxKB3PPo4aj2HMqUJ2Z+cqUSIRYsfqQZZJdnZjrjg97fxJJEMhUFUMLhe2UbWgUYw6GvHSUr+ekso5JJMxYGgSpNY19dQ/f5BwW4Dzf381B4LZLR2BfTtpe/qfqKkkhriTmg99fsj0xERnL80/uI9EpxfXoslU/9/tpNxD07cDdD+1Hv/G/RTffvEp5H2Z8G85TMM/VpIIxpn3/eX0lQ5txVJVlbpfvEL3mkPYyjyM/9oVXHHB0FajZFyh588PE96yG9luo+DTtzLl0tOPm2iHn/0/ehnfnhb237eD/ClFVC6tYdxnLsDkOjXiX4nEafr+wzyTG6Ztv485N1bz2WeXUp13qtlbVVVan9zGr57eTfEoG11NURZeV8KoH9yJqfDUcZPs6cP3wiqCG7eAohI51IxtbDlFk3KouGoarvHpALpULEHzI2/S9MibqIn0x7jrQA8GkwGDWSYm2ZBMBiSTkZKPXAQnYpcPbvLy5E+P071nEwCS1UJw/ZugJCm4eSl5V4icKSXlRr72wwKuvz5M+MABjLm5WCorMeXWnGLdk2SZvNuvxV0EHS/sonv1QSSDTOgzeTjyT585YR9XzpXfmY2vPcI/P7GeD/5x0WnlTuLqr46lpdOIkkjx6n+v5vzvnD7t2WiW+ej/VjJmmp3f/U8LiZ4Add9+nIJlMzDNmTkk+2zpnZeg9nmJdQfx7m4Geexp5U7CMq4GQ34u8WONxA4fxzUmezkB2WDEWlBK/ZO/p3L5LVjnZbcy5p17AfW/+j7Nf/stBZdcgfOyJVmtqoac9NoV3rYX26xJyFnKAwA4S2uo+9efSMWjuC9cqCO7RCLZ6yWwegPWGRdllVSVFG0bX8DiKcwqdxL26VMJrNtA9yOPU5zjBrIzEFtdhbTsfRWjxUnJ+HN1/caZxjuhvLybMaK8DIEp59yBw12qLQiE2xopv+RmcqfMhR3ZVfHuVS9gLavAc90HsY2qJe7IHvSmnKg6m3fdVVjHjNYsVZAKBTHYHZTdfEfW2h797SdjzDn/yxgMGhWTVZWDD+6g72AXoy4fj9FugiwFcRPt3cS62im+4gOY8vIx5+YjG06/iCfaumn73l9RI1FsEypxzRmHuSyfiEbB3fD+RtRYIs0pIw89KVPhGC2/f4FkT4CKi8aSM66AvizFhX3/egXfK3uRDDJ5547DObGUoYpKRUMp/vL1YyR7nDgWzcFUVoSxKJ/MF6WqKh2vHuTI799AiSYxOcyM/cBkpnw0vfPPpPAHSIWiNH33n0QONtHkMnLXw+eRX316ZTcViXP4Zy/TvTqdgXXOFUV8/m/TkA0SdQdOVVxUVSXR1YO5poqCShvJngC28RV4LpxJuUesy2OwmKi+fRFl187Cu7MRac8BJt80nvwxaTPehtZMhT3NHjxhvof/eWIG33rsPCK79iIZDLjOX4StOMRQyC0wUPqpT9D1yCOYCgvpee45TNuLKbjt5lNkJUmi+mNLyJlRhXNcCa1PbOEP173O1CsqWPSRMTgLTk3hnXJFOoPNaJb5x51rcf73FIHpdTDMNgPnf+c8ZKPMrvv28Oztz5P3BQ/W2tMr1YuvyWeV7WKUaBw1qdDz8k58972BY854ij5+5Sm1q8zFHqb/4BoS/ii7vvY07nk2cuYMTYInyTLuy84n2dVLePte1EsnaioAruoJBI7to3v7G5RMHo3ROTRthCk3D/e02YSOHkwT2mm0bZs2Hgwyii+IbDGDhufZXlwNkkTnzteQ1rpwL85O2Om5bjl9jz6Ha/F8zZpuvfs3E/N29meIasE6ZjS2KZOINzYj22yD67meFrLBiNWZR+u+V8kpHQ+cWdLEEQwf79nyAGcLJ6mYp33k+xjM6YngqRPzlYNlAx96Q1wl2NOIMz+9KHbMFSe8s3FQ9dNUirDB30+XD6eWA+idkeFzXteAd+cmSq/4IJIkYchwvSsZ+klXdA+S0Yh1YpoN0tYs7oby9omm4NalGa9/kGHE0jmw2IbqDtNy/x9xT59D4cVXYnS6iBaIbVm7MiqzZixmocniczzp1gntb8TocRIPjRKKry1asF+Q3/T65P6/k34/DT/+Nou+tZjRy9Ipno1BjyDfsiFNFd/57BOE6w4z7tZJVF46AaPdTHfk9JYR/54metcdYuyifIpmlvbTcR/oEdP4Kt1eAJRkCskgs3ffKOG8vVTUvKzmOKj0K1mJpPghS2bUKprirmf7rzajJBVyx+ZRMt5NwYR8LCfcW6vWDuyiVVUl2b6JpDeEIceOOceGMd+FtaLgtL8V8YkLvNUtvhfloPiBm3q+WMpgT5uo1CdaRZN+zmivcByOiIrxN6eLcRKveUUr2PrG0ensukQSyWziHM9BLDlp5S6eMeArbWLMz9O7RtP77EYks4nCGxdTliMqYsFBSmL7s9tpfWY7ld+6DVNBWsGbU9YkyO/rKen/27+tjs7fPsPiuycw87pRADy0W0xDl7pEJXTcuIN0bWmk7IK0VWV/a4lwflJZOu4i0hFgzedfxLFwFu7L0xaPm2duEWSfeSptKVIVheYH/4inYjKFMwYo/71TxY2QKkOis4fQujeRrBaKZ1winC9c2CYc97xRSryvB9loouXJ+5k863aBxdpXI45RKQXJcJCj9/2YcR/7H0LTxPOWtoG1Z/TDaffp3tYXsJncqF+8WlCO7BnhMNETBpTWR+/HNWUGuTWi1Sj3kLhOHp3YgPeJ5zHXVJL7gctxHBPXvVi+uM6ZvRJKMol/7zZ8O9+k8NsfF9aeotczXGABhb6OQ5gsTpyecryj03MqFYty8Ddff1vKA1z8wifOSHmAlZf96az29+3CiOXlDOCk4qIFyWAQFBc9MNgdlCy/QTeBj3XCGCTTmX+toUP7qLzjbuyjxmgLDxOOSennl6jTHz8ea2liyQ8uoGpJdnNvKhzCPn4ihVdcR83S45rtuqdW4p5aSblbH7uorEGffhJpWnddogCYHGbmfX3ATeHI1Foz2nYvGlDsMvlz3ouQZBnJkl6oTyouemB02yn68IW6ZEuumkVUsdL4rfupuuc2TIWerPLu2bVcev95PPP1bdTML8JTZs8qD2ByWfoVl2ywFbso/von6PrNQ9jPmYKpeOiK7ZIsU3r9hwmu3TikTP/vF+WTc+3y9PjTES9rzk3z6lfd/hlMR7T3tUa7E2fVWPxHdmOYNkNTflLpMmTJQJ3O9cw5fjKhowdPUV4yYRldSfFXP6mrzZOQjUZyps9N15nTsYfPLR66ovjbAZXhV4U+XRvvF4woL+9yWPKHR9xzNhQXVVUpXHYVsvTuocy3jx1P1RLtqWiwO3COn6wpN4L/THguno0hx4Fs16cgecod3H7feWeFLt7gdFD8/+7S1bbR6aZk7jJd7b6Vvqav0fepK7nwOgwWK0G0lebhriHOKTNwTZ0JMW3ZtwJJksiZNodIls3BuwUjMS8iRpSXEWhCkiQwGNCxNr1tyFa+fgQjGA5ccycMS/5s1rl5N9TQGS6MtpMu2DO/QOiJ2xvBfyZGRsYQ8I1TkU9QeSczdmU59QP+1sbLxd1J8TpxZxHPiI8r2C36auVkhi82IF7fe40YO2HcIAZshkaLfu7MZB7rHNH90VrgEX8/IS6W5oqBYMqoNWM3Ghcbdx0Uh0+kRLyXuPhTyEZxcQsGxNgLtXBge6XEE/g6YtgKB2JTfnWTSO3+vaOXC8cdfeLDLjhHTLVqDw6cNxrEvlS5vMJxUhHfw5xiMRbizTbRVahaxPY+Pn6DcPxsm0ih37G+QjgOjRbTzHcgFqkM9WSUL2gX31syMBCUGxol7iJtLjF4ODPGJd6YEQRcIwYrbTssuuYMVnEMu4+I48KfFF2jik18Nt/ecYVwXJAjBvDOqxDJ2NYcG3BVmkzib68PiZT2rhyx74mU+B6n54slKzbGRwnHm5vEe102WuTqWdkqKjoFeWLk99Ip24XjlxrFeB6pUSyh0eUZePZGmzgGDBnKgDRdjFoNHRRjFvJ2iPMxcalXOA6YxDHU+aYYu6RkDINgufheiy4R09CVn4pWYWNEjBNJDJqOrZeIbrBErvgeIxlxWdYMr21mbF/zpeJa46gTfzueK543BTLWuYwA4ERnBkVFhSgfGi2+i/zNJ2Je3kaDzYjlRcQISd0I3hKUyNklOAi8spG9927RFnwboST17yxTw5AdwXsb8S4/0WZ9ZHCDoST+M9mO9cJft/esth/396Gkzm6JgzOJd4Jh992MEeXlDEPvZDi05R+oqr4PnKqqJLPl9p5GHs5ebZCk10/rPT/X3X9IswTHmzu0BYGUP4j/xfVMvnPOsPoVb+ogvPOItiDQ8s8NBA60aAuegK/Rz9O3PIe/SZslON7Uyq9ufnNEgXmPIt7Wg5rQ/1Ez5bs49tPnqP/F8/hah04Dz0Syp4f2Z7e9lS7qgqLzHlLRKKEjB4fFINu9oY5oRH95A4BAwyFtoUFoX/8C8cDwfmM48B7aRqSjSVtwBO9KjCgvQ0CJRIb18Y/sPUTg1XXUr38kq5yqqgS9Lfi66nS33fnHFRz/3K+IHGrUFgbCm3fifeYV+v75rC754LYdhA/oW7zUVIrQpu3YZ00ZknBuMFLBIEokQucDD+FfuUlXf7xPv4bz/DnYi7MT+PX3SVFpfWILrd+7HyU+9G5WTaWLW3as2ELPukPYqobO6BiMjjebeOGTLzHzzmm4K7OnF6a8frp++wCXfm4MBmP256MkE6hKClVRCG/fS7whuzJ1kqI+2eulfdVTJAK+rPLJXt+J/waIHNFW1M4ma4JW2wlviNCxDhLeEKqSXVaJxel++FW6H1tNaMNOYnWNKKGhSUa6N9ZR96c3aHpiK0dfqqd9Z2fW/ijBCPWf+hlN37iXdT/fTuPGtiFlIZ3+XvGRpfSs3M1frnqJ7Y8czSp/EqaCAhr//Crdr+/PKqcqKpvuP4Lvjd2kAvpr8kSOttL32i5NOYPVSmDndlr//DuiDcd1tW0pcrFjw2/x9dZrC59A7671BBsP65ZPBL10rH9Rl2wyFCDWpZ/uH8B7eAfBJn39SfmDJPvOXq04PRixvIgYiXkZAi3f+zGTpn6QgsKJeMeKufWh4gH/rLUN4t2ddP/+fgwOF+Wf/QK9roEBYs2o7dY9y0j9r/5BUoly0PsquZeJGQMpawbt9Xon8d3tqNE4rIuQyDBG5G8RX2E0D7pe3EK4qY6CBRcTX+MRlIyMcAfsXSpdL68n1NvMxIs+RdnXBu4tdr9IxtW4TML79EuEd+4h7+br8E+PCgGGBnMGR02HFe9rrxHZfwBzeTljPn8BkmFgZxpfKSoP027aj6++j9d37WH5w9ezu130yX9u3UeFYzm0HltlAcd/8xKS0cDYn9+JKd8FpD/ypU5xsVn7QDeJpjbC2/dz2V8vw5oX4SSzVo5J/Pg1+ZxEOgJ0bW6g/rEdXPjTCymYWEDqxOsxGcV7Ndqj+F7eTHDtLnKvWMiRseM5Muibp2YsGoEiL12/fQD7zMkEVm/CUeGi5COLcVakYyLa2sW4kURbG97HX8RYmEd4615cF88lPkshaU/3OxUZGAcGr5FYUzOdf38Aa+1ookcOUHbzQpxT08/baRkYBAl/hLq6VgKbDuCaPxHHtNFEjlggmUK22zC4Xbgq0rWDAm8eJlrfTrg1QLKzD8f8KeRcMp9ohg4olaX7pCoKkb3HkN9cT/nF43FWeoj7Y9Q/7yEVCWOw2XCMn0R7mQk15cK74iX8L69lu0HGWl1M1f9+CKPHiaFuIFbj3EvSH+PQR4t55fOr6DnSh2w2cOEfriR/bCHbmiuFvlxcexD1GpU13QFW/Xorx1SYdEUVNZPtmGxGIjFxblcX9EKBneLvXs6O/3qanYcSuFwqUxa5kQ0S55aItXaCyRPXXywTe6Gc9u3t2OIByi1pi0FKERXY/7pqhXD8mV/nUffTfxFU87BOEuNptnsH7kVZmEfnxx6n7ddPYxlXTf5tV2IsEeNn/AYxbsPoG0/9b75B8pgFz+z5WDJ0aWnQ3qzw/OXU/+4HtPzh1+Rft4iiD1+IL1/cPEQ3DcRpqWo5ivtf7Np6L/m3X4nrgrmQUdfNuX0gpi04SiWVa6Zx5T8o+68vYQyLm4B4nnitZXIvyi+ieA9upfCTMzB0i2zClnxxvloUB4ee+C3Vy2/DVlhOPEecb5nrcFdlI9HuNtQCK7ZzllD4ihjfF/OI8nl10LD2CcYs+ziSJGHrTlu1ksOw0P27UFXplHXkrbTxfsGI8jIE7I5CPLnZqf5Poue1l1CTSQwOJ0okDK6hWSwBzAVFJHq7yZl5jq72ZbMFe1kNnvGz0Joq8b4uwk11WApLyZk4U9M6Eg/7CPe1UDP3elyFo4DsZtR4cyvJ7l4iew5gm1ubVTbp9RJYux41mcR5zmzIwoILcPiJ/bRuaGLKnTPTZExZDAvxjg5a/vAvZINMxe2LKbp8JpHE0AROakrB99zrJNu68NxwCZZc25CyAEcf2ELLykOYPTYW/P4DFFRkt8KFtx2i574XMI8qwbFwCjC0BSjc3Ef79+4j2dmDmkxS+JlbqZ43dKpurK6Rzp/9HSUUwXHeHMp+8GWMOUNTsYf37qfz/gdR4wlSRYVM/csnMdjEZ6MqKm0v7qX+b+tIeNMfglh9O71Pr0dVjUgGA475c3Cfn6ZClyQJ+6QqIkdbCW/ZjxKOEjveiv/lTVhySjAXlpB37lJkixVVUfCv2oJ3xRpSPemX2LO9BXOuDbPbSiyej2yzY60Y+DhLBgO5N1+OqaqM3vueIN7WQ8vPnyJ3+RyszrlIBjGg01Fo5/I/L+eV/15DKpJk7X+9TNl51aSWXoK5XNSmJEliycfHUDLOxYrv7kdNqvz58heZuLyS+LxSzOWnUsp7ppQx4wdXE3lpI237vPzlpte56MtTKJ1XcYrsScz7/Cxq7V08+OV9JOMKy+7WXj9M5YUku/qIt3RimTh+yGwja6GToi/dSvt3/ky8oZV4QxuG4vKs2Umy2YKlqISO5x5DVVJ45g1dDsHkySPv8nl4X91B0hvS5D2RJAnHnMn4X95AoiM9jiVD9s+JbLOSCgToeuiflNx1l0AKl4lUMELOookkegK6CsxKkozZncexp39PzTWfhPLKrPLR/XXIOU5SvsAJi2b2VHlJNuBvOUTXgfUUTXpnygOMQMSI8jIEamovwWjUppqOtbcQaW6g5PpbcE2diWLTdqVYikqQDDKm3HxSOrgUDBYbxQuW60qj9O7dQt7sxRQtuRzZqD3pQ71NTLz40zjzs0/2k1DCEcyjqsi97gpNWe/LqzB4csi78nLs06ciSdn91wcf2UuwxU/Zwux9SUUitD/wd5RwHEtVAe5pVZrPpvWNYyTburBOG4f9nKlI0tC1B7oO9FD3j62oKZXyS8ZjybOTtRYC4H1xI0gS9mljTtSyOb3yEqzrpO6Pb2AqL8Y2bQKm4gJMxYUMWX7gQB09f38K86hyTOXFWMaOQrJZGCotNVbXQHD7DtyLz8OYn4cpPx/ZfOo0l2SJssunUrp8Mse3BQjtrMM6pgzn7HFE2k7PPmx02Si+ZSn2S5bgf3kTjnMmIVnNpDZ7iXe293+8JFnGffFc7DPGETvSiL31EAWzKyk5N/0xP7R29GnbB3AunIl7nAs1pZAKROh7aSvRoyvJXXLhKR9fs9PMkp8tJ9QWwJpno27FQfZ+934sNaXkXrUI2wQxc2j8kmJurikkp8xBqCfKnmeO0/K9BzEV5ZKzbC7Oc0TLR+6MCi5aNAuT1cCxTZ2s+ule7IXHWPLF6RSMObXkQu6oHIodYe7++0z+eNdOUgkVdfm5Wcem55oLMFeUkOrza45hy+gKCj75AWSbBe/TrxHcuIe8267DmOcZ8hpreRXx7k6UWBRVUbIqDAU3nIvn4pl03LeS1t+swP3BD2WVdyyagXXKGHr+voKcq87HYM/+OTEVFGKprsI19xxN5ciU66TiM5dz8BO/x1KeR0IHwZ69uJpg4yHa1j1L4cSPYrAOvUFxXTSf0Oa95H1w+SllG04H+cTYbtnyPO6ysdjQ53I+k1CQ/m2Sun/3+ncTRsoDZOAkFfOY//f9/joZzqbMdOaB4y65GWt+CbIxvbO1Z1Q2VjPmfuc8CG7djjE3F2ttDWq+mGtnPSgqTI5WlUDbUVyl6XRR31hx8OXvFfvWZWnDWjjg7okWZH+9SWtGDRPngG3H0C0qP+5jEoce/wU1y+/A7MolniUkJRkJ0RN8E/cFc/o5WTJH2mBXR8ofpOWL38FcXUnR5z6GwWEHc0aqqDkdH+J9fCUYZEourMVWU9Tf/+ocUTlqC7pP/K7Kke88zdRrqyk/N63oLPaIvu6wkt55JeMKv7xpM8H8CvIvPwfHlOq01cEsKiMXlg4EH3Ye9vH4/9vJvP9ZTN7E9C6+NyampQYzahe1tIklfiW/uPDbWtMDJxWLYrBYMcz3CudH54nZLTM9Axaz+zZm7AwtGSb54xkm8tIMe56SscBl6En2ZnGxV+eIildmGnosId6bvFscOK75XcJxV4P4bBLebpJ9XqzjRmN2i/PlwtFiEOjKQ7UEN+zFt/JNyr52G+dNEuNVtreLlpOP165h/9oe1j7cwrVfHcOeHNEaWt83qBp4SsG7ehcd/1hDzsIJlH38Eny9oqJXU5G+l2Qoxu6vPw2lY/DccHn/GM0rzyhXELGQ8odo+OJvWXDfrZhzBj64brPo493VOJA+ryoKkdXriRxuoeJL1wEQz6hhZQxBrKudWHcHvh2b+ORTIkvtC4+LdZSiJyj01WSSzgceRHIZyf/4Df1WL+decdzI56XnW/uDr5HoDlBy7h3CebN34O+EOz0PAwd34du7nfzPibK5+8SF0nhl+jnu/cSfGfOtG4h2iuy29tOEIQUaDhJoPIirajzGeWKKui2jQK0xBAdX/JLqxTdjyy0hlbFPTWSsbSk1Qeerz2GvHoNzzERMyfTamIpFOfDbt6c8wLxnPofRoZ9t+nRIhmJsvubXI+UBRgD2Yn2lAQbDNmlCuhiYTpxUXPRgsOKiB8Mlxao49xrMLu0SB0abg5yFQxeZy0SsrgFL7SiKPnMnsi2LxUuSyL0pHSdkz9WX2aEmUoz57yupKM4e4Arg64hy5+9n8kzofF1tn+zTJX+/BoPpzDMQ6y00936GsTAPY2GetiBp8kLX4hm4Fs/QJS8bJKacX8CU89M76T3dQ8tKBpm8i2bgOXcS4UPZA6CNDgvTfngdW770An2PrCD3pquGtGIY3A5cS2bQ8uwuam7VN2ckWSb/inmagdCWwhLMBcXYq2oBfanHktFI0e230bNyBUoogsGdPXC+6ObFHL/nYZJBP0bn0B9ESZJwjp1M4PBeVFXVtfY4xpcROtSKIVebmt9ZNR5Xddp6plEjEgAlGddlnQaQjSZKll038D/eOxnW71uMKC/vAAx27Zoo71Y4SvXFAQ0XkslE0Wc/hpxJjJcp9xYYSE/nNhkK+ZUn3o2+hBEAisa6CYbfPaUTRnB2IVvNOKdrzwOjzUzRZz+K/5U3QFEgiwsm74YlVBbqp0M4CT3zQZIkjA59mXv91xgM5N2i7RoGkE1Gar77YZJbtXfystFE+dUfJizpy+R0z6xBiSXQM7uGuzYUTV6M0XJ6F+m7ESMBuyJGlJcRvCtgmzIOKTGSuT+C9xdkixnPlRdryhnsVgwWPfaCdyfOVlmD/KXpumTenWe+7YIJ+i3D7waMMOyKGFFehoC9EwwnEjQCo8QXbgwNKuXeKZptg6XiBzgwXfTRj35AlO+ZKroF5Ay66e75YrzChN+Ju7OemR7hOFQjyrsOiXuWwFjxvJQU783UNJCVklmrrG9KRiq0XTweVSHGLnQGMkoZdIu7nHOninEn4x0iid0bXaK7zB8Vn1X30XzhOHeKyIFR7BCf1c2Fm/v/7kqKu8RNXjGINDNOIzOOY6dXjJ0wG8Rn4Y+Jfc0sP9BuEX9fzc9Iva7OoPQ3iXbq40+ImV4NyYFje8YG2LxIjEnxBjNiUELiGMmkUs+M2wqPEeN/nBvEH4wUiWPcGBbbixWIzzLaJLoh5Zj4g4a+gf4pTvG3V74xUzieMOe4cLy1TQz+DmaUWfhZg1hiYtw0MduuNiO2yJ8Ru+TrEjMLJ3rEMXxMFin0r6raIxw/3zRQNLShS3SNpTpE17Icy6CsLxaf0/gFYlmFQ8dFqoGOqNjXzHg4a2tKyBiKV4hjLlIiZqxJEfE4M+41PMiDnWlosbeKfQ+J1TBIHhIDYm0Z8eypDANtTFwKyD2YsS6Xi88us2yLMcMDLWdQSth6xfaS1nR7mev12cSI5UXEyFZ3BG8Jw43zDu44infFK7rl97zQQrRTvxk9vG8/gaOd2oInoKoqD3/vGK1H9ZF+qaqqm7F0BP+ZCG3ZPax50bSz96wSAw4XvdvXk4q+d60/I/jPwojy8g4gHg8Oi1o/5Q8Oq5aQmkgOe1FM9vbhe3W1vvZVlc5f/5lEqz5lQU0pdN63Euu4oVNkB8PfEeGlH+9DNuuLI0kFAvQ88gSyjpTHk3j8x8dpPRqmsEo7IFZVVVr//jqt972uu/1UVP+WTE2mCLyx/awz3MY7tQOW30tItHWjplLagm8R7auPEOvTz2gb3XeEtT/corsGVuP2Hlr+vlrXe1cSCQJb3hzWGEkFw6SC+vufDPrpeG2FtuAg6GUhV+KxYb2rs1XaZDBSsbNbn+1MQz0D7Lojlpf/AMSDXhIhfXTQ7Xvf4NDLf6T32A5N2Uikjzc3/5LDh/QtEpH9h+n87d/p+sMDJDq6tC8AQtt30/WH+whu3KopqyoKyT4v3f98VBcZlBKNET14BCUSxVh6KrnX6eB7fSemwhysE/VlTb32u0PMu6UGs0dfYHPPkytwnbsQx6h8bWHgqT93cXiLn7t/MwGTOfsUUFWV7odWEjrQROkti7PKJiMJ4v4oTS8fYs+n7kOJZS+8pyaTKJEY7T95iMjuI5DSXrBToRjxnuEFdgZ21XP0K/fReq8+y5fej8zb8YHJ+vvJFM0/+xmBN9/U7LOqqvg37Cfe2Kq739YCB69++BGaXjmsS2mwThnHvieO8NKX3yAR1i66WDrJQ/sTm2i5/w3N9mWTifDBg3Q+9CBKRJ91RJJluv/wsH6lQVXx7n6T4LGD2rInEFirXX7gRGdof+whlLg+pT5ad4zQnj3agieQ9A+fur/7jZd0y8bDflKJd1bZUUnTTfxb/97ROzizGIl5GQK+revoatrBjPM/j9VSJJzLOzAwAYPlJpKxEIHWIxRPPO8UCiDHQdEv3GA+RCIRoit4hPzpFowZG6NIhj6Q11JG5/FmDBYr+Z3FHPySuCga28VfzDlgoPe1HUQaDmKJWgh9c1I/zwoAfWJ/4vVNdN7/AObiYtwLF5EYFNshecUPu5SS8D2/kvCe/emyBikE1tymDJ99vrULJalQ9+hqJnz/RiIecfJHU6KydN+a0SQ6+mhf66fm17cRP+gRzt+8SKyNtKIhn1hLL2pfK6O+tZzjnWKMzc0TB4reqarK8z1TOPx8PTsebaD6B3dyX4cdToQoOMziomq3xPBvrSO4p4H4kRZKvnY7EcnSn4PpM4sWm5aDxXQ/8gSJtnaUWJzCu+6io3nAb+/NoHKP98bpe/BZEq2dWCePwXPjMlRk1BOeKX+b6JRP7Vfp3bWBrk2rcI+bhvtjBsylA8qacfvAvZcvraNjbR22EjdH/7qBQGcKz1WXYpsyAW+ThLlY/Pg5XnUS8/fgq9uF99huimZfQE7ttP7zc2/f2f931BvlpcfCBNbuJu+6xRjz3PQkZdRYDHNVZZqfJy/9LGPHmul96HnUuIJss2IqLSL3hiuwdosBCwmXhJpK4V+3nlhDA4oaQ4nGcV2wAMecqUglg8Z888BzNEujsM0aTdejj9L3+isUfvI69tWPFdqWewfGmCqPpvOnvwFZxjZxLM4lC5iwTHwvHcGB565Wj0MqyGfb/63i4AvNFH/mehZPElOkmwbF1BjyJtJjkGjd1cPBXXEKZhTwpUWiwvhQ/dz+v5PuCLCRzhVbcY0rxjJH5GFxjRPztiMXT6XjZw8Ra2+i6DM3ke8R40IO7cuIw/LJxA7V479vJQWXXcWa1DjhvDFDh3OMCtDzJgSPv8Loj1roiIjzOWwVL3CvtdP00BsURKZgcnoIjhI/janCgTllbrKQCgVpue9PlN36MWwLxDEYPyDGPbk81Rz96bdILWglf8klWPrEdS6Th0XZeYzOg9sonr88XR7AKcoX7hDXza5pRrzbN5Izbjr2ihrMGfuBntkZsYMNcRq3PMPoJbciSRKpE8vo2bP7jUALI8rLEOhp3Uf1pEux2HPR2it4qqbQsXc1rtIxmun/+TMXE25rIFCfvRjbSZhdHhzlozFYbLoKISbDAQKNh3FWjaNsyTVEjdlfcXj3HlJeH0mbjZQ/gCE3e2mDeFMryc4uIgcOYjt3clZZ/75mjv9uFe6Z1dgq8oho0LKE9xyj48/P45o3ETWuHV/S+rfXCO5rYtRXrgJD9mdTt66D/Wt6aFjbwtX3XsxBObtVx7+tjvrvPoGtpogx378lrbhkQWjXXoLr08pV4R0fxlSUnYHT+/hLhDbuxDKhhpyrLxiSA0RVVcI79tL6z+dIBLxA2rw/FCuokoiz85v/om9XK5ZCJ2M+Oh9v0flDt59K0bVnLZ07Xu23NEa6WwXlBSAVT7Hnn/vZ8dc9JKPpd9P9wMvIdgtI9nRWjScnrbycgGV0BYWfvpmu3zxK9MAREm2dyDYrcu05mAvEDYFkMOA+dxF+VaXv5ZdRozGSnd1EduzHNq0ax6zxGHJOTffNveECgut3owQjaJGHmouKKLz7Djp+8WdCW3dhnTIeVS0bMlNGkiQ8l86n897nwCCfYDYeGgabjRn/dT7Hn9tPtFubg8joslF0+Qz6Nh7FOa6EmIa8bdo4ZLeDlD94anTsEP03uNx4167GUlqOZdm0rPL582qI9YbIm1WVphfQMPDEvF3E/T34ju2lYJo2Zb6tppbe116h+S+/o3bcjZhyh07flk1mHGMm0PPGK8TaWxm98EMYzEO7eHPGTKd75xqOPPwzcsbOoHTeZVhyhp6DSjyGmkzQsfpfjLrlM2gNHqPVQd/xXXQUVlMyeYnmvZ4NKEhIIwy7/RhRXobAlEV3YXcVaQsCjoIK8kbPwmCyaCovkiRRfvGN1D38K5RkAtB21XjGz0JJ6DO3eo/spnjeJRSdc9GJD9bQK5CqqoR278Y+dQqFt3wQ2WpF1TAsxtvasU+fSv4HP6DpdAweaCXW5sVgN5MMRkHKrhhFj7SAomAqyUV22iCLuz4RSRLYdRw1pZDwhrKmaqqqyvp7D9Gyq5epHxyPo8gGWcjI1JRC699fR02mMObYUeLJrKVPYt1Beh59EtvUybgWzMWWUWAvE+GDjQRffxNzTQWuixZkdddJkoRj1lSKLJNIhAIkg35UVcFU6DlFVknEaX7ib4SONyBbjFReM42SpePwHRj6RUkGA4VTz6NgyrlE+zoINB3CVlx+ipzBbGDGHVOZfNMEVq4yE9l3HMec8VjHVpBoHVoRNObnUPzlT+B9biWW0VXE65toefDPFF52Lc7xovIrGQzknL8E25Kp+J57lZzLlxI7fJzY0SOYywtPq7wYHDYKP3EtBpedjl88TN7t12OfMfTzt44ZRcGdHyTZ2U3gtfXs3Wtk7OcuxFpyKt0/gHPhFExlBfT84xX6nnoDvpy9dEX1FRPxTCxi03/9i6K5laDhyaz5zCVYSz00P7iOwk9fn1VWMhoo+sxNRA830vfYK+RNuhFJo16YpawcJRLGmHP6+xuM3JmVJAJROl47SOny7BsTgEDDAQD8dXt0Ky/GHA/mgkKMOdr8Kq4JUwkfPYhssWiSyUmSROm5V1H3+K8Jtx3H5MjOOZM8oajH+7oJN9Zhc2R3aRtMViTZQNvuVbhLx2J0nTpHzjZGso1EjJQHyMBJKuaJnxkoDxAuER9R2foB82kkP/1hSEQCmGwueqeK7Rki4mBxnyhKG+nrwGRz4l0sfhUzq0T7ayEVDpHyBzCXlGDKMG9KGXZLpc8vTFxzhiu4b/LAvcRaWgnv2Yvnkov6d+aWqoEfiB8TlQ2pPUTbUw9R/sGPIRuNME3sTDQg3kvnD/5GKhyh5JN3YXDYUUwZpRMs4nHbN3+BfdoUPJctQ5IkZswSK/ju2TCQDhzav5++px7ksp8sovKcdDpqY1g0cwdPFGrs3dHE9i89ScHscqZ94TzcNXk4jeI+tyE4YLbuWLmPzhVbmfypBRTOTpvidx4XTfLlxQOlCAIHWvH2jME4iG57sMk8fbMn/pNK4X1yJbYJE7CMG92vdLn3i+/dNzlDDZbFMWjqEeXz9oG3aT+pRARzWQUWTyGSnN6dJzK+E6HqjPdgFNs2hERlx9otjmHPEXHQRfJFK0Awg3RaOfHdOcmqGs+Lg6L0087LGQR/7iPi7/umDDyL/EqvcC66emB3He1qo/n5P1F55wXkLU7Tw2dWFm/wpd+zqqSDAFr/dhBLRSXWqnQdJLlWrGFVlJMe4wl/hN2f/wc1dyyi6PwBttdKp9ifpbnpeJEnf95AoDdBx813C+dvGLNTOM4xRkhEU/zk8rXYP/0pzOUlA79dKrZd7U6POTWlsPZLzxOvnUbOZQNxWJYGcf7lzu0kGYrR9NfXsVbmk3+VyGuSWU6jrjefVDjGoY//hgn3fYHYIdGHLWcMSZ9/B74X1uM4ZxKui+chdYpKrDKo9EnuZgtKMk4qHuPI07+h4I5bsFQPDBQlLyP9fq+ZVCxKIuCl+bkHqLztkwJ7r5pheDqZzu/dsgFLaTnmWrGuVcEuccz7LQECTYfx1+1h1BUfxRQS54B/tDjm5QT0bnwDS1EJjtrxxD1peSUapeFr//O2lAeY9vhXMNj/vfIAqXCM3R/46Uh5gBEMwGTLblXIhC33JP+DtnvEYHdgsOtjgtTacQyGubgIS/kluuVRVcpv+khacdESPcEoWnr3J3SVQlCiMRyzZuBZdpGuriS6u7jx/ovIrda+37aX9zP1fy9j9MXVusi07JV5LLn3Bt3EW66JZQR363zuskzujcshduYZeT2VkwBI2N+du6uTz1OSJDCc+fu3FpYy/ocfQolqB8umLRYSOQv1VQg2uW1M+s51tD66mcIl4zTHxpV3V3DP1TsxTT2OffKo7G1bDVz4iVpefOoVij57m3bfDTJzv3Uhr317u2axRaPDQun1c0l49WUdGewWbLWlhPY2YjRlD8i3z5qAfVZ2K+NgyEYzstFM7RV3EanwaPfFYsVgKaH2ti+jOPWNF885CwHtWBSTMwfP2Om4KsdpSA4gb8E74y46CUWVkEZI6voxkm30HwxJhxIyGEanC9msT/NXkymKbr9Vdw0nyWzSrbgA5Jx7ni7FRU0pjP/8UoqXan9wTsI1ofSsMYaerXZHkIa1NBd7jT5373Bhq8hj/FeW6XqHZquBD99TS6z+NBUET4M516arhuvOhMqzU/jZW7IqLv2y5Xm4Jldoyp2E65yxBHcd0xZ8i7DkFPRb3fRgOLLDgWw0Y3Jqu9PeLfi3M41UzWLe7ymMWF5GcFYgm03IVn1FzwBdi/BbkZcMMkabWVtwBCM4w5i0wEOua4EuWYNJJve6ZWe5R/qQt3wWksFAVF9OwQhG8I5gRHkZAuFKBflEaqDzeAaVdfEguvKMJ2jIsM46WsVjJeN7Lkcz2s7YIGVe75sgGkQzrzd7M3aFi73CoXWTRzjOLAWf2jdgzVA84i4wkaG1O80Z5vkMz1m8T7xZY1DcQSkeMS6koFzsa6Nf7Ks8Wszg6I2LrrS6XjE6cnnVAeG41DxA0nbfa8VYS3Iw5aT99H0h0V9faBN/K8cjvti2HnHHZhwlxkqkMuJ/pIy8VHudOHAiGcYCYwYNPi3ii6qd2ygcN/cM+PgzqdNTGcYvV11GCYvZYgq7kshIp88Rx1TfOPE9xj2ZvyfeqxzPiJnZLY6LWEbB6Mxjx6BnldwvZpBEKzJo28Pic/JuF10fNYtECn2/OaM0gfjTtHZ6hOOc9eLDlK4Xf/93vaJr4cJRYgmMmCre+6MNE/v/duWLY85sFF3Ku1rFivEfnbVBOH7QNlc4DsXE9/jtyc8Kx19+4cPC8SnvKcP40rtEHCeeteKz8NdmlBuoHxiImfT/tg7xt8IZVmDLiamaSsQwmCzEM9aeTIoJq1ccc+EC8U0qpgxKiePiszVExeu7FojXG73imHc2pNtLxd4+S+pIwK6IEbfR+xSqqtL+rydIBc88sVJo/378mzbqlg8fPEiiK0t6z2mQHGa/Wzc14998SJdsPJri0HefIzaM8gOpaPxdReU+gncXYl2BYY2PZDxFKjE8lpBER99ZHYNJr3fY16Ti2vM0GQy8JSZkVVVo37Fy2Ne9X3FSefl3/71fMKK8ZIFe//NwmUaVZIJUPKp7IVIVBTWVGtbCFTy0j3hXG7Ije4yKmkoNe2GJHDkMiv6++F59jVRAv6IQ6/Sx7+6/plOU9cj7Y2z+4TqMefqCptc80EjO1AqcY4u1hYFEKE7dfz9AaF+jtjCQ9AZJ+fTdb6jxKLFefczJ73eoySRKQjvY9u1CosdHyhfUFgQS/ii7/usJoi29uuQNRpkXvr6ZeJd+ZthYUwe9T6zWLR/v9KazqnQifPgQwV06GXNPoH3rK9rrh6rS8vc/kvB5h9V2sP0YvUe36V73At0N2kKcKG/SvH1YfVGT73xds3+3NMCZqEr9bsL7Snm55557kCRJ+FdSUqJ94WnQ9P0f431JH526v+EAR576DR1bXkHRUS+ja9cbHHrsZ3RsW6mLLjvcdpz6Z++lbd1zuvqjqgrdr79IwdJLNYMLU+EQx3/7Q9qe/Afxro6ssicRa2rEUpmd76K/L6kU8ZZWzBX6AgbVlELLA2soump2mihLB7b+fCM1y8dgH1umKRvojrH2oUaqPnqerraVZIrN33wF54wanFOqs8omOvpIdPTR8p0HiezWtgL59m2j7eUndI0ZoP/DHmtuYtt/PY13X/ZgUCWZwL9nG6mQvg+wmkiihLP3JXzkEOHGumHV5tINg4GO5x6jb8t61JT2x0JVVbxvvEG8S5/yF+toG1axT6PbQdv3/0p49xFNWWdtIZIsc+Due2l7eB2KhlVFkiXcpQ4OfPav+LbW6eqPKT+H3sdeJ7BeH21+vMNL270v6f74S7KB7ief0E21ryoKfYe2EurMrjQYXW4ko4nG3/6M0EH9gTR9R7eTCPmI+fVZbTsOryfU16opJ0kSHU3baDm2TndfQvv3E2tq0hYcwduG913My+TJk1m1alX/seEtRqorPj8OnwPPPpmwWFme2CA3uatBxZQyEG6rx2xxMf2pEDDgu+6dJTrwY26JVCpO3N9D1NeJvVwBBj4YMYNoKbH0GvDV7yXYeBglEcdTH8NgG4jPiGSUrVcs9USPtWMqteK5Pp/4Vo9w3i5SOyD7FRK9PUhxBfesHCHmxlYhLvSxqJlYfSuJ7g7M5+SyrFJcRB/bNVvsizWM77lXMRblkbKEqJjcI5zPtYgEejt3F9Hzl0eIN7dhv+FmultEn70lo7zAngMmwvWddBzyM/nT19EXEeVvyRXLCfyu8wLW/nITY6+dwDnjAsDA/Sm5opK3umEsvtd2EN5/HNXkoeKWi0kkB2ScDrEvwYO5dD/+AqG9e8hZdC7O8+YI51VFbD9lhfbXnkGJx4n42jAXi0q2e4sYT9DtOEhg1SZURSVe30LpjEuJHJhJ9GB6/xEZM6BMOBplUrEITc/8jWhHE5YNJdTe/Pl+RVbOMG5IrUYC27bifWUl7oULsezvxZ1XTVHFLAA6Zw3scexF1Rz/y89RUymcs2binDMbT5c4QRRLWl5NJenbvpF4xNdv4XNOnEJykVig03Hs5DIkkT97CfX3/YKeTa+Sc8WFOBbMwdEyMCdiQmiShDVWQfNPf4xzxixyL7wYU0iMcRkcGyGrbjZ+5n6QJGzjx2OfMIHb7l4vKPgPbxkcN2LBOm4sHT+6D9dF55F7zaXc8hmxHs5vt1zQ/7dp6YWo2/6Gd+UOJl9WgbPSQ0dUzIgbvPN1LplG6oFDHPvek9R8/Xr+5+ZmQfbba64Wjk1F6efa8funMZfm8veYGAyspsQxJiXG0fvCA6QCDvIvv5JfOy4UzpeMF5W+ukMplHCY7ucfpehLH6Y7R5xPslc8bncdJRkN0hnfT2JmFXnbxc9J36SBMVl5Qy2HfnCQ3lWPU3rB9XTnThRkjUFxH227rgnf47sBSFRswxFeLpzvnS0OYnOnCf/qdmJd6yhefDOjF4oKVfvT4sZDmVvJsReepXdiipxLllC4UYxFyt8qPsvuiIn25x5k9B1fwmCx9fPMZPLNnE2ciWyh95Pn+31leQEwGo2UlJT0/yss1Fc88BTIBmz5pdpygGQ0IRvNVM6/WluY9I7F5MihbPF1uuT9x/ZhyS+hcvktguJyOvS+sJWW3/4Lx+Qq1KQOd9CJHXTV+Tdnpd8+ic7fPoqaSOH9l/auRTKb8L+8hnhDC7E6bZdLvKGFyM79qLG4rorV9b98gfpfvUTNFy5DNmVfRTrakux99ABN65uZdqs2e2j0eDvtv3uG8O5jFN2xTJPJNNHbS2DrFpRwGCRJc7ebikVJhUOYC4txTZqeVTbUXEfHj+8jtHE3ppJ8yn/8BXLHzx6yXEQi5Kf+0d8Rbq5DVSFv6vzTWuBUVcF7ZCfNP/0J3Y89RtLbR/R4Pc6ccly5p7cyGaxWiu64DSUQwPfqayQ6hrbWSQYj7skzSQYDeDe8gW/zOryb1hHauG3Ia6wlFTgWzibV6yV25LhQO+t0sI0eg2PyVILbt9L56D9JRYbmMzHYHJR87GMooRD+NWuIHNQuQOhceA4A4a27SXRmt/BYp4xlzIdmYCuw07amXrPtnHEFOKdVY3TZMLq1i5DKThvm6mJkhy3NQK0Bg92OMTcX39rV9L2iowihQe5vN9WnbX0J79wHskz0wFFN2fxFY8g/byxKPKXLza4mU9R+9kLyzx1LznRtK6+qKCS6Ogns3EYyoN13S02aIC+0aTuJzh4N6TTnTMLbQ+uLj71jsW9p5eXfjXl5R7p+VvC+s7wcOXKEsrIyLBYL8+bN4/vf/z6jR48eUj4WixGLDbCt+k+YTHNHz8Cap+2GAJCNJkpnXYLZ4QG0fd6qqlBx4U0YrXaycuADsd5OLJ5CKpd/GIPFqllnKXKsAyWawGC3DFn/RuyLSuHkc3GVjdWUBZBdDuj24Vo8E8jOBSFJErLDjqm0CNuMiUD2RSJe3wQGmbwPX4e5ujxrCdSkL4R/T9qMGzrajnN8dkVz57Y4G3+6haIpBcR8cWyO7Ipa34r1ANjGVeqKG/C+9iqWikryr7kGa2UVKSl77EaitxtjTi4VH/rYCe6c08uHmo7S+K8HMFeXYh5VhmVcdVZ+HlVViXY0U7z4Six5RZhcOcjK6ZUcSZJxVU+geGYZKZ+PlN+PbLdT0pl9LFgqysm79hrizc30PPUMxvlRPFPnnVZBMtqdlFz3Qdwz5tC37nXcM+YQDfedptUBeK5ZjjE/l/CW3QRWrcUx/sKs8vmXXUnS5yXp7SPSdBznuElDypry8ym+8068q1YRbWjg8bsPcdWP5mJ1nz6d3lxZhufqZYR37SdWn10BlySJyZ9aQNwXZe2nnsZW4qTqoqFp5yVJoubr1xM+3ErDT1YQWTwWm3PodytJEpXf+SitP/gnibZeTDnaMVvWmlqiah32SZP6GY6Hgm3SaAo/cT3+V9/EmJdDSqM8U87ypYR37CX/w9dpftANVhMTvn4FvRvrOPid58j/wlhk89AUBoYT9AYGuxlbeS5azr5kXy/m0jJQVOJdnWiVXbHUVOG54XICr67D4B66xtJJyCfY1mOdLUTbm3AUVmlcMYKzjfeV8jJv3jweeOABxo0bR0dHB9/97ndZuHAh+/btIz//9EVGfvCDH/Dtb3/7lP9fMPcC5FwnKSCeI07MwRVOe6dAKpyPyVJGrwFsPR5B1hATr40USdgXzsFYUkYEMJpE64h7T0Y6cdTMuMUfQYrKEFXxjxHbM3cPvEJVVYke66TgostxVV1IbCcoGd9o/yjxOGYwY517Kb2WdD+sJQPKlCGDkl7psmCwunEvqUVOFbHiWdHVMXHJceH44O4qDA4HeVddiRw20tIupqV2HxUVDof3Zcb+3zJKF7uBRpoDYjryDdU7+v/e9nQzLS4zi753EcWzy4AeanJE5egDb97V/3fX8y8Am7j2GgPXTt7PP7tEk/vGplH9fye6vBiOH+P63yxi9HmlQAMH/OK97qkfyP1UYnGsc6vJn3c5kiyjEsVoEHeXqQ5xpxy2hCj67MdIljhJomBtERfb4Kj09QmXh4pF/0vZhhMKSEP6X28Gsanar59I5BcM+ngHIJShgw/KGEcyWandZQBOvJte6J0oLgs5R8VxEC6WsFcuQC1NkJx8EeHV68kzJ/s/jH1jxOsNEbDkjsVz2WgkgyFNFzBos55pencG83DMWE5q3Hk0P/hHgsFcPBPSLqxEBi9h0pNE8rgp/MJHSHl9+J54Ffv4if19yZRPFcYxFZaQP+VGJJOR0GuHWLF5aj9vkJQrKpETx7agjh9HtKOUTZ9+nF8W3IWlfJBv1Sm+55270iUs3B8tZscv/oCS48EzbUC+3S926K7p62A6rDju5Idf62PWNy/uP3fVrJ2C7H5fMeSC7QNTaHt5HbZpIjvs8lqRGuAFyyQKPnspoS376V3/Is6ltwjnM4M3LV1OTI4cug4/jbRPovhcUcnsbPMIx+Z4DiQVzOZ8DEEjiUu9wvliy8BWq8t/QkGYMQvzljb6Hl5B4Ydu7D+ftItjrGl/CYFjTcQjOTTtL6GsS3zOoQ5xvuRdnMRZsZim+9ZQ9QEX/j+KFnezTWw/r8FDXumFNJf3EXtoLYlzRLdUJEMvtDW4qV52G107V+N2VyGfUOxkfSXnzgjeiVTpNWvW8JOf/IRt27bR1tbG008/zTXXXDOk/FNPPcUf/vAHdu7cSSwWY/Lkydxzzz0sWzbAYXTffffxkY985JRrI5EIVqu29f8k3lduo0svvZTrr7+eqVOnctFFF/H8888DcP/99w95zde+9jV8Pl//v6YTQVlmV+6Q12TCYLcPiwXSUqLPogNgduToJmRLevvwzF9M3uLsO9XBMNjTFYH1wlRSjPvCpbrl3UvOw1KlL7i39uaZlC4e2ko2GL1NYS752zUnFBdtRI8089nvlHDtR/M0ZZVonNsfveiE4qIN2WLGuWDasIj2rOPGYCrR3jmb8vOGTeD3dkCSJGSTGXNOHjUTtQPDYXhMqZIkYXQ4qbz9btxjpmjKGxx2zOWllN18h66+yBYzkizjmDFd8/lKkoStxM20byzTzTBtKiyg8KO3su+7LxJp13ZjXP75WoKNXjo2HteULTi3lmB9N/E2bXeHbLPgPHc6Ocv1keXJJhP2mjGEjxzQFoZ0japhjs+i2y8h3txMcPuOrHJqLIZk0fe8JUnCVpGHZ26ttvAgFM9bRjLo05Qz2px4xs6g9rrPDKv9Mwn1DP0bDkKhENOnT+e3v/2tLvk1a9Zw8cUX88ILL7Bt2zaWLl3KlVdeyY4d4rt2u920tbUJ/4ajuMD7zPKSCYfDwdSpUzlyZOhsAYvFgkXnBHm3w+Bwkr/07LJ05lxwPrJN/yBzLpirLXQCnvH645Mu+NQY9kX01RNSE0k8l83n8lv26ZK3VBZhsrXr7stbwUiZAH0w2OynBBi/U8ifWUFPUv8YtYwexbTvXY21UNstYTTLzPvxFZjd2muRbDQw+evL6dNwfZ6EJMvYp49Fu+JPGvkXLD+hNGg/+PLPfx4pi/vndJDNJoruvENz06TE4sjDWJuNbhtlN+hfbwBMdhcVF94EOpPnZMP7+pN5Ci699FIuvfRS3fK//OUvhePvf//7rFixgueee46ZM2f2//9/JxP4JN59W7oziFgsxoEDBygt1beDfq9DNpvP+kdxOIoLDJ/2/ySCzV5SkaFtsgaT/nYlkxHXudPeUj9GMIJ/B66xRUgGfWPVkmvTLeuZVoHBra9Y63BhLirGlOPRJWvMzX1Lc9yUn4fBmV2pcy85F/f5+igN/hNwJknq/H6/8G9w3OeZhKIoBAIB8vJEi3cwGKS6upqKigquuOKKUywzevC+UiO/8pWvcOWVV1JVVUVnZyff/e538fv93H777cNuSwmFMSgysslM5UoxHbnjnAF/q+u4qCwMLh0AkMiYnylrRvzMdpFYLZNi2xAV2zf5xWPXcbF933jx+lSBuHsytom7HUM4o7yAaeBeg3Ue4ZxqEttOuMXjujWjhGOpdiAVWglHmVvdgmFQVtCGmBjMGE0NDMcdP1zN9I9Oo2TuQLzAvatEd5ilMs1fEj3eTu+KDXzvj2Jc0+4O0aX0vWOX9//duk08VzBdzG56fO8s4ViJJpHMg9777oyU9j7xWfhrxPeULBbHkKVdnHrmjBjWhEu8vnN2RntOcRddunbgvJzMKEXQKR63LhbHqLU3oy++DMp9q/jb5avEzh69xSMcj35cDK/sniWOcTmZMQcyqd0z5tDg0gnREvG+zV1i3+O5Ylu21gya+Fbxvc07X+Qd2XBEdFvuPyLy2l++VCQ3i6TE2IuNTTVkg8cu0gNs8g783nGv6Koe6xrIbkolUox1i9lOVU7xPTy7U8xas9j8gnUj4hU3Hka7OCZTeeKz7fGJytElU0XL5aq14u8FfGJcVyA08N7N3eI7zcmgKPItEp+LodEGnOhvEiIZIYvxUnFd6wuK2VrmkszyAOL1wWpxnJSIlRaQk+L1meU7TsaNpd7O7J234vc5XRtAZQZP17e+9S3uueeef7PxU/Gzn/2MUCjEjTcOxDdNmDCB++67j6lTp+L3+/nVr37FokWL2LVrF2PH6kscgfeZ8tLc3MwHP/hBuru7KSwsZP78+WzatInq6uzkYqdD587XseWVUjBl4Vno6XsfaVZN/cOn78nXOFwTZ+KtMzRlQ819RNr9FM8p15QFCKzfh7n09AHZZwKJtm46f/kPSr/3OV27zHBPC10Ht1F4qb7U+RG8fUj09WL05L4r3HZqSkFJKcg6rC0tO7rp6Ugy9tLsytFgBN88hKk4F9s4fQSRSZ8fg8t5VmKskgE/BrvjrFWIfitQk0mQ5XdlTNlpcSbo/U9c39TUhNs94HY/G6ETDz/8MPfccw8rVqygqGhA+5s/fz7z58/vP160aBGzZs3iN7/5Db/+9a91t/8eeWv68Mgjj9Da2ko8HqelpYUnn3ySSZOGTpvMhlQkjNGmzyyrqiqRrlaUhD7Tm5pMDosrINHbQ3Dfbt3yqqoSOXZsWLT/3jVvkPRpB66dRPeDjxDeqy+GJOUPEdqwi9FXTdAWBlpfOkDZ8kma3CqQvlf/hn24FmlztwxGtKkR34a1umR7H3kR18ULdC1yqqrQuOFJrBXaCrMeduVT2h9mKYoRiIg2NuDftF6XbLylg+hBfey3AEpSGfb72fOnrbrkSqbksfrbG9n9T52BtACqSvvvnkGJ6wsaSjS3Ely3SVvwLSAVDtH53BPDWvfCR/TVKhuMeIv+GmqRfQdItJ3d2LZ3K9xut/DvTCsvjz76KHfeeSePPfYYF110UVZZWZY555xzssamng7vK8vLmUTC6UVeopKa0of8G1GJKdoxYG711hrp3LKKnt0byJ10DgVLliHJg3YXGXM154hE45qn8dbvoWTWxeROEn264bHiQiNvDuLbvJqErw+bvZDCqBjk1DNZ/MBbOyTaXnkS/+HdjP3EN7A0im6iSEa8YSISItpwDP8bb5A7cxH+5oEPtDFjzVMsKko0RqK9k3hDI5ZPXo9iGhBKZlTMrS1Nm7mP/ms9FZdNYHv7ZBi0Vvzf4mcE+ZQqk0qq/PeqXfy/f0xlXslq4XxOhmnZZkjQeaCXHpfC1ed2cSiDCtllFZXJpvYckCQie47S/dCTFH3mRtSqdJu920S78LgT1Yd7dzTR1dNJ3vIbkQwD9xrIqKzsHJXO/Oh8cRfGKgnzkinEpQHlcYBF9kTfu1Ratq0i3N1CxbwrCc8tEqwBUgY7vr0NEkEfnW+uxFE2moJq0a0VHeRxMIUGBl0iGsRsMGMwDryb3AyG9kyTursuKvTl2LXiGIrlpn9MVVXi3m6KN4sf7Hi+6J4oXiO6O7rniZWhY56BMZeKR0goEgbLgAvCPsjFkHCICqS1G/oObsMzfmaatC+DuC/vAtE/4VtrpPV7z2CZlYtt4ih6YxnkcH0D92qyltPx1+/iWrYI96XnIUkSL78uPvdU0YACqioK3t8+R8HFl2Owp9cMZaG4IRiTI35c//lSEx3SaFxL5/HROaJStcAxaDF3w2OT8tn4821EeqPM/fQM/AnRTTOmRvwQdx0L0tbcRfK5lxh71yLqFdE6GQ9nBMzaEvSteAH7wnEY83KQGsRns6pNdBPl7YVA+zFcJWnXV99EsT1n88AYCs014//tZswTc8i9+lzCquhPV3vFj2fKotL14rMUl34EU34+jo4MpXCTOGhD5SaibS0Edu+hcNlVRMUhhtkrHiOpBN/chm38GMwVpQTLxPmczBgWiT1HsOQVY3KkrRWOtnR/kom3bzPxXmHYffjhh/noRz/Kww8/zOWXX64pr6oqO3fuZOrUqcP6nfeV5eVMIhUIY8jRZr1MQyIZ9JEMB0TFZShp2UAqFsJo1bbsGB0u+nZsJFi3H/QwU6oqfbs3kQqH8B/cqSmf6Oqg7eH7MDhdJL3ZycMAfM+/Qs+Dj+K56lIkU3bdV0mkSASitL64j+oPzMoqexL71vdRUmOjoEJfYPDhV5oYd4m+VOzAa1vwPr6K7nufpuSrt2GbPHRatpJMoSRSHPrdWsbffZ6muTvhDRPvDtD04DpGffpiXW6JSG8b/uYD+Br3acqrqkrzqkfp3b0Bf/1+zR2sqqToOLCWvSt+RMjbnFUWIObvoWPvGg6/+EcCwez1YVRVwX94N8ce/AVtrzxOV6N2sF0sqcF4dgKy0ULD8/fTvuEFkhF9NZki7Y20vbFC167e6HFCSqH954+Q7MluaZRkGfvsSXgfeZHu3/4TJZLdsirJMrLZQuPvf0ak6biuvhvyPfQ+tILIPu1dZ9mcYkwOE0arASWp46N5Ykj1bGsk2q3jWaYU1GiMnvv0PUuA1u0vkYho14uSbRZkl53uf6wkuFlnfSNVpfOBB3UXRfRuXkusQ7u2EUAqFCay9wDROm0m5JNo+NffUJLvXOrbO1FVOhgMsnPnTnbu3AlAfX09O3fupLExTdj4ta99jdtuu61f/uGHH+a2227jZz/7GfPnz6e9vZ329nZ8g6z63/72t3n55Zc5duwYO3fu5M4772Tnzp188pOfHFbfRpSXIRBr66N7xWZd7KqW3EJAonC2Pv4Ts9ODxVNEbu1MTVnZaMJSUIytrBprsXYMiJqIg6KQM2UOOVPO0ZSPd6cDVS2l5ZgKtNNAo3X1JNo6iOw/pGki79pwjF3feI7iC8ZhztVWBBVFZd2TnZx3g75qz96mIIdXNjHuEm22y4Q3TN+jK/E+s5q8Dy7HUpOdH8Z/uIutX3wSc56dgrnaLqC+TUfY87kHKFgyEWupPo6gqK+ToilLKJ6qPW769m4iePwg9rIaXDUTsyqysWAvR17/Oy27XiYZjxDqHVp5UVWVvuO7Obb6IZo3ryDQeoRoZGiW6Hh7B8cf/QNNK+4j2tFM3NsjWHWGQqtvD31h7cJ2kixTsvAyOre8yoG/fZf2jS9qjjNrYRk9O9fSseEFzfYNOU6M+W4MHidKTPtDZJ87DWSZZK9P10fUNW0WSZ+Xlr/9nuCBvZryxnwPqCqRPYdQNKI/x18xmit+dyEHV9ShJLXXJdfYIsZ/ejGuMYVYC7TTtVVFQbJbUZMpUhqKHaTHWbC9jmCHPgXAOqYc2WrG4NHuC4BstRBvaqL3ee33mgoFCezZTqwje7HSkwhv3wWpFLGj9boUNZMzh3BHI82vvnPlAd4JbN26lZkzZ/anOX/pS19i5syZ/O///i8AbW1t/YoMwJ/+9CeSySSf/vSnKS0t7f/3+c9/vl/G6/Vy1113MXHiRC655BJaWlpYs2YNc+cOL819xG00BNRIHKPLpivuwpJbhHvMFCy5RbqYFEzOXEpnL0vHUOgIV7eVVGKv0ke+lIqGsRSUUHrx9bp2//HuLhwTJlN05Q3au/9EgnhTK465s8i/5QYkOXvfQ429eHe3kPBHifsiWWUB/v71oxze4ufWe/Td61OfWk3MH6frUB+eyuwLYtPfV6NEYjjPm4m5WptfwLevFe/eNuyVuUS7gkD2gGDfjgYSPUHCjd26PoqqksJZNIqKuVdoV/4OBYl5uxlzy1ewFaaVLinL47Q48xh34cfSv6OqGMJDf3QlSSJ31DRyR00jEfbja9qPMzG0YmcuKabm5k+TikWIe3tJ+HrwSOOGlD+J8pxpGGRtJQfAXlJF3pR59O57E0lHQKWtIN1f76EdWFumYy0fOkBVdlip/NHdNH719ycsh9nflWVcNUVfuo2+R18ierAec3V2xdRSVoGlooqkz4spNw8tAhHnknkY3K50XSFD9nGQU5V2WVSdW872v+5h9McXZ2+7Og+T08Kmux7WtQmzjhtFwceuI7RxF8YCD2gYMXqPpjOvgh315I7SpiIo+dwNdP9zJdHDTdjHaMciWmvHkPT6cM6Zg3o0e2mDSGM9RrcHVUmRDAYw5LiGlAWwTRqPuaYK95JzURNJtD6FJmea7dt/bC/+ut04HcNzcZwRqFJ/wO2/1cYwcP7552dV1u677z7hePXq1Zpt/uIXv+AXv/jFsPpxOowoL1ngLlhCcmMu5h6v8P/bF3n6/1ZMYCzIp2D+hSgmsGqUNko4wFYzGqPTTVJKlwsYDMkvvhI5Ac7KcbhrpyAnoH1BRpppr3h9sCxB/qdvJVJiAFJILnFxNmSkilpxUHHBcuS+tFsk6Rz4ULgnizfTutaLY8Es8m69HmQJ2Su6UjLjNNr3RjB43Hju+jgNnXk4ikTXwSu9YpDtmy++STKa4uVVKlOuLOX/NlwpNhgVfy/qfQQkieJJaQ4Bi0HsQPeJVM/Y8TZiqpXbV1xGTrkT6OC1JrH0QCBHfC7eF7oxFbqp+sYH8dnySPRlTJVBi4Cqqni3NuGcM4e8D9xIz1EDkjkzHVi8vHdJBNf5V9JnTMdMmOrE+AWrEBrhQv7wFaSA4IkgKrNPfO+D41YczYPPSVgDBkFJNsTFa0/eisXkpmj0fOJmSaihNe5vYudbL/RgNNkwFpZDYTlqmyIo7YMrOQP4puQzWPmLZVTwdh/PVPllKqdfSm7JROz55XgHpf+L95amcVfySsi75FKUSIRRzSXQPDAO5LVi8IOyzAg4cc46B9+K3XTuEAm4zBlGPGudDZiGZ0kRx/72R9wfr8Xk9vSfn7VArF68x1FKxbc+QORoK72v/QvbBR8Uzi8tEt1DNUsmEZs0ib2fe4Ce0DJM1oFx9tkd4rUlOWmmXs+HLmbrx+5n7jVHKKgZ+Ej/Y6/IovvVJS9ACRwvl5nRvY7mXR8WzieKRcVKsudgGTOOnr+tIBUC2zjR+qJuE+eMMnsC+W4Vc0U1wUqJzAA/ZdB0tWx0Ak6Kyy/k+FP34vrGhYIrVnWKc9eaE6Xk7nPp+keMeMt2mq8VyTeLXhcVWtPSicg71pB79XKS1SbUuNgXV0NGbGBRAWo4hr2kBlPCQrhMlHe0ZFBgTDDhWXYxqWAQedlUvJ3p30/F3j7nxXsl5uXtwojbaAjYq2ox5+lj05RNZmyl+gt1mVyeISsCnw45E2Ygm/SxWJoK8zGVFGkLnkDhrKW62zbk5pB36/W6UwuVQIiiL3wMY4E2JX8ymiQZTTHt+hqmXKkvtT0ZS3HB12fjLsseO2SuKqbwzitPKC7aUFWVpDfImB/ehqVcu++J1nZc8+ZReNPNulNBJZNRV+HM/1QYrU481VMwO7VdcLLJRN7Siym47Crd7bvmzyPw5puoir6MPGt+CcXzLtEVU2HMc+OaO4GyL39AV9uWQjfuaVU0b8tetfokTC4ro+5YyCs/3KXLhTF1aT57XtcuJQAg222YyoqIHdOuAm8tq6RgySU4asfrahvAkleMJa+I0F5tl5okSeQsnYExV9+8zblkCaayoqyFSwdDTSaRh0FJn3vZMgpuvF63/AjOLkaUlyFQuOSyd7oL/RiOojPstofBcWDM8wxLPvcDV2Au00cBHffHKJ6Uy4VfnaFLXk2lGLesigmXais6w+VxUBNJqv/rWszFHl3yxvw88i697F3BHTICfTDl51N06630R7XqQP7UhTjH6qde0ApoH4wxX72CmkX6mcBLlk0hGU3RcVA7NmXaBQUcWK9d7f4k8j58LeaKf4+6PRtKl16LbbS+GmaW8gI8F8/WJWubMgHZZtMWPIHq//46BrvepIx3Ad6J4kbvYowoL0PAUvifUVLgbMJcof8ZqimFq38yH6PFQCqh6NpRLv1vfRlMp/29LO3LZhOmAn11kyAdWDiC9x6so2veNQRlesoCDB6zkixxy1/Oo2SiR/O6snEOvvDADN19MZUVI9v1KwHDhSW3EIMre0zKCE7FO5Ft9G7GSMzLEIhUJ5FtaT9s80Ue8dyMgWhJ264MSuwM75GUEa+XcIkfTWu3OJgMUXERS2VYNS094nlDBs+ZlMyIZ/CKLiH3UfF870KxAckw0OFQVLzW0pkeLsGD+zDY7NTcKJ5v2C8qK56ytI8+3u1HjSUZl8G9sKdzkLyhlFY5CW3Q+a/txDp82K8XlRODU+zrFRWHAfjbD9u57cvFvBoSgwanV4gm/tUt6XIEib4gx+55gOL/vrvfWmLyi881cFB0Vxgy3qMcE59jvEB0P2SWXchgkSdnvThuSl4TyxMEx2e6q8SpqmZ4nFyNA7/feVNUOGd/TPytvNWiS0ApFu81nisOOsUhvueKFWJGR7wiu2vH7BPfm7NJnANHbxTdfjXPiSnJcddAfyxe8dpYXkbMV4n4nDJp3fP2itf3TM8opZBRTsA/RjyfGZuxdZtY4mLh3IPC8bo9YjDzUw0iV0o0NjAwLhgrkj6usYuB643rWrGPK8PoTlsLHmkSY1z+dslfhOP/PXo1qjoQ6GqY6xXOj3aJKc7n5Ivj4rF94vxTJ4jjyuYQ35MSEpV4+6ASGh0XZ6wzXnFCGDvFMRbvFc9n6pjdM8Rj12HxvWeOEykjMSLpFN+rIZLBD3RAjBX0TxR/z9Gafqap+PvIlPEew7tj2zGCM4pUOKybVfOtILh3N0mfV7d832u76Vu9R7d8YE8jjnH6rDa+3iSrV/gwmvTvKHpf2Yl5dJUuN89wWIpH8P6Bquiz/mWi96A+hlc1mSIZ1M7AG4ykL0Trn14e1jXdrx/UlWkEkIgOb6z7N2jzDb1dUNX/EObpEZdRP0aUlyGgqiq+l14/kUanjb5dm+jZukZ320oiMawPY7DuIB0rV+jry9PPEdmjj7ofILhmC4ku/T7xRG83prwCbcETCO1rwjFZH5GcqqoE9jbhmqpP/tj+KDUT9QfdqSmF3ld24FoyX1sY8K5ejfe113S3Hz1yjL6ntXkphD4pCl1BbRr6RMh/VhdpVVXe8Y9AKhw+y/eocwWXoP2VJ4m3dwyr/f0P7tKlwEhGA02/fI7ocf309JIk4V2zD996/SUCulcfxLezQVsQWPeH/cQC+jc9wa2H8b+hf1MyXAxnfUwEfPiPagcBD4YSiQ6rnIMSPTuVl/VixG0kYsRtNATCT64lfGgfRZMvQs6Yz67NA2b4cAnEuzoJtB7GOWX6KVTryVxR+TE9e4yWTc+RjIaYdPPX8C7JmBBKhhupx0Sip4fuba/jXrQIZaKYbux4TTS5R3JV1FgCSTYhJSRMEbG92GVigF/qwSaCazdgapWxTStAWjD0brDyBGV+4887GXNZGF9c5D6RMvruMMdRUwqRI60UTilkzwbRp3b+UrFek8cUoa8hwLEciQsntmORRFKzV1rE2kh/aF5K3cbtJCoL+UPzfMrtXuF8S0BM7bx21G4OrW4nWGPCMtkBDOT0RjJqexi6zCQDASKHD5F7yTJmn3tYbPunorugfb5MvKOd4CvrcEyZiikjlTkzLrRvTgIlHAFJpvveh7GmJMyT5vQzNFu7xHEhlxlpevFBEuEA1Rd9mNKgSOTXO2Fg4FX8ZeBvRUkRy3CdNH5QDHI+6Xrs2rYaNZmgJjwVm22QKyhj5x6pFd+77bCYJdN+qUimaA6I18czKmYbBt2qGk6xufNxim68uT+Y0nNw4Ho543tmagxjsNj6rWhqxoqWSfPe2rMNS3Ep1tI0F4zqFid3sr88gIy5uoq2H/2Mkg/Mp+ymhcgWE51tHkHedUzc/x1PuHj1/62h+iefwGC3ImWkpVe6vf1/RyZ6OPL1e6n+3OXkLZ3MX9tE3pZylzhXq4qaaAJ6//Y8N10aYEV8kXD+zn/dJRzbKwP4j3SSeHoP6vhJBLvFh5GTUeH6QFMeu+/aR9GX70AyGrFmuGlTh8Q4FUlN0fG3l/CcMwpjjoOF48VaRFs9AxuQgqdySSWixAK92PPK6FogvkhLt/gcjRGJzvWrKFx4CZIkE8vwonoOiWOqfZxE68OPUja/EoPLRcVU0QXW+sQo4dhx3EDfrt3YykZhLSwlVCuu000XiwPJsTdB1+a1FJ+bTq0PnqASSsXeRmXgDFaVfj9gxPIyBHrXriIVDhJt1U4Z9G1cR3DvboJ7dmruFmwF5cQDvSiJGLIOZlKA9nvvJdrYiMGhXU4gsHET0bpj+Fa9SioU1pSP93UR62zDv387kkFbl01GEiiJFCaXtrVDVVTCDd1Yit0Y7PqCWpu2dVExW1+KOoDvSDfusfqtQFsfPc6cm0bpku1+4nGix48Ta27WtWPvfPQRQgf260rVTAXDdP76ftp/8HtMpUVMWHhH1tISqqoS7mwi5usmGdamYwdoa9nKkQP6rHXR7lY6NjxPx6aXiUazl4lQVZW25i2kUvp26V11b9J5ZBPxkFdT1uhyo8bjNP/qF8SatRl5U9EwdU/8hp7d60nFo5rytqpRNP71V/SsWamZJu2aOgtjjp22hzfQ8s/1usaAwWYh0d5Lx5/+pSlfunQMaixJ429ewLdV2/LmyLMw9dJyZlxdgdWlvXYk/WGS3X4Cbx4i0e3XlDeWFBDdX0f3vU/oskioikIqEKH1Lys1ZQES4QCt2/RbJaMdLXS88S99wgYjSjBEzz/1F3/07tlCpEUfO3Ai6KN36xqSYX0lK0Zw9jGivGSBe8psbOXaqbiyxQqKgn3CJE2eD6PVQdGMCzDa9UXbK7EYia4uJElC1pHWZ6mqJOX3I1ktGBza8taS9O7IM0PbjZKKJTn+8FashU5Cjdp1kIKH2jj2m5WY85xEWrTdUuHeKM3buqiYrY+npvX1o/gOdWIrdGouWAl/hI5DPjqP+Bl/vr40UDWlQCqFuahIV3xMorsLyWDAVKCtTPU98hyxw/WAhHvZYs10+GTYj5KMU3n+jbirJ2aVBeho20ln207MFqfmR1pJJml66R9IBhN50xZgMmUfN5IkoShJtm34FQGfdt2kvKrpdB5az86nvkPdun9q9sc5fQbJvl7aH3yAeFd27hOLp4DcCXNoWf0kB/76bbr2rMsqb84rxFZdS/frL9L80J9RIkMrPLLRSPE15+CaWkWkvvMUC9TpYMh1Yi4vwDa+EpIaytGoPHLmj8PotmN0am8GahcWct7Hx3Do9Q4MJu2lO+kNkrNkKq55EzTrMgGYigvAYEAJhEj1aSs79rHlWMrzybtouq64mkTEj6/pAIH2Y5qyAKacXHq2rKZ35wZN2ZOcSdEjR4ns1nYfxXo6ibQeJ9xyXFdfkgEfSiJG95v6XchnHtIZ+vf+wIjyMgSsFaMovFC7IiaAbLViqazGNUMfH0HRlPOwFwxNYT4Yyd5eMBgovuMOzCXaH11zeTmyzYZzxgxd7VtLKjDYnbjGa9N7GyxGmp/bS6Cum8Axbb++wWEhsK+FwIFWTG5tRWrDH/Zx9PUWWnd16yo817npOKEmL3WP7NBULiLHu/j7HespqHHi79AXKCkZjTimTcM+UVtZSEUiKLEYxR/6MJay7DWo/PX7CW3eiX3uNPJuvQbZpW1Ri3q7KJ17GfkT9NX/KC6dwfQ5H6NmzCWaxUID9fvIn7mEiR//FuVLr8fp1B5nxWWzcLhKsDu0rWQGk4VxF3wMi6sAd8kYzf44pk7DWjMaVUnpIhHLm7IAZ9V4VCWlq9ipZ/YCDE4XstmCZMlO0Fh02UzGff9mZKuJht++rKkk519zLnlXLyJa16KL56Xmq1dT9fnLOP7T50iGtS1ZRWNcJGMpehq1C11aq4pwL5qMZJCxVGq/J1N1KcX/72Mk2rowuLWJ4QqvmYd7/njCR9p0lVFJnLAYtm57QV89oZy0ezJwbD+pSPY5KxkMeK6+DNlhxzZtimbbvv3bkAwGIm3alnWARMALgP/wHhJBbcXurGCE50XASMzLEJhRfA2OtWmfb8Itmmj7xgw8NsWkIjms5F97DarlVIpsa4v4iF0tSUBmXPVyLC1JvH1i20qO6HtVm3spueom3CXjIACySTyvZLzB3KMGvGXjKbVPw3hYwjdW7I/xTTEOJFUEecsvI5mf7keyY2DRqqgV03cP76lEyi/BaPDhyz0fGjPSsl1i38oL4uwEpt41h6qSOJJD3EX3xUWF5pi/lES4jgZ5Ik/tmYPZlZEHnoFAsgKkQxjmX8e+7SU0jRGtQZHtA45y/54WYsEkrX43z3YtIdO4IPnE92DyS5gsTgoWX4LRL7GlXozXMc4UP8CxSA+5JkRkuAABAABJREFU112BZe5EkigkC8Vdd94L6RelqgrBlj5mL/8fLLYcOAIcAWNIlFfMYvsFiUKMpaOQ2tJywTLxxbsHpUpbD4lBoDGPqCjnHRZ/q7z7BGHY1jgQP6Ucj3xEXODDF00EjIw993YUSULJEy8oebFFOI5X5QEW5kz+KBZzDspR8b1GikQFwtXuwH3Bx+neux7/o/+ifNrN/ecyn1PurvQHMc++jHB1L65gLfKuAXep/7yM8hvHbNinTqGyqoKeVS+S+7Qfq3vgw+7PMLT29KQVOdfNt9Lxi3vhgTcoOPfi/vOBOaLlxlifi61wLp1bVpHYa+GSy8SA1lePimy0SkqC6lws0xrZ/Is3GfPFARr83qA4SGfmNCFJEuOXlnDw9XYKlokuDFueOP5LbAF6xobZ9mIPs0qa2VAnEuw1t4ixS5a4CYungGDlKMIv7cb2QVEJSFaK9xoMWTFOmUjfY69iv/QC1jaKxHPq/gHrcnxekliBm7zy67COr8WzWxaU2Li4LBH3gHliLYWuG0gF/eR0ien+UsZH2NFlxjHlIiKbdiFvb+V45yjhvJyh0+YtvgDfoR2UXvNBUmYFzx5xPnknieOs1FeMNOo8LNZcSo5ZaZiRXuuUiL6EjhGceYxYXoaAxaKfRMkxfTrWKv3lAQAsNo8uOVt1LTnT5wyr7dI5y3TtQE/CNUd/NU9TcRHupYt1kXuZXRbco/OouVLbcgFpsjdTeTGupfoygYyeHByzZmIu1bYUpAJ+jIW5FH3uZt20/PnnXYzRlaMtSLq+leuC8zTlJEmmuHZBWnEZBkwW57uOwXe4/bFY9N+zwWShaMb5VCy8Wpe81ewmzzkKWdbej0kGA6a8fEpu/LCguGS9xmSi8NN3EDi8l4Tfm1XWYLVhqxlD6ID+jD/PjZcQ2N+Kb5d2nM/EC0o49Jq+LCVbgZ1Il3bsm9CX8y8guGO7Llnr2CrizZ0oYe14I0ttNa7F8zEVF2pa3wCs5RV45i0k/8LluvoC4Jk+l4RP20Utmy3UfPzLWMsqdTGYO1wl1Iy7lIpRi965eThieREwYnk5AzibFNOGYdBdn4Q1t1hbaBCGwzJqra3BPl1fRVXZbGDml89FNuprX7ZZyf3QlbqVC2NeHrnjtCsaAyixKEVfugWDW79SN7gAnxZGWHbPPCRJTivhwXcHh4fBYWfURz6v62OXe/6FJ1wp+uoVyWYTk3/0AUwe7fFZOSOPnoYQxb4wppzsa48110b+JP0B8ACWigpKP/4JQNu9KhkN5Fy+iFQgDDnDU8jPBvLOSW8g9HyjZfPw5qysQ+E6q3gHqkq/mzGivIxgWHDMnqlb2ZEkicIZZbrbts+ZijHfo1veNn6c7r545p2LUj1iaBzBvwe9dcas5SdddfqUFwBznr4ChLJBYt6Ha+jpDWkqL7JR5tz/O193H05Cb4FRgNxrlpz4a4TQcQRvH0aUlyFw/CMgn1gXzBnU0/YsFlvFLOr8uUfE41CxuCh4DoiasH+U6P83ZFhjQ+3iApdcIvq9lWPieXtrhqadGc8wU7xe9Q4ESHb0ifV9rOWibCwixomYD4lWIn+tBf+hDsx5DqyFzlN4K/LNYtDhmBl2wo0HOfzLVcz4+U3kWsWd31inGINzoCjtLurb345nYjF76zOI7YoGL6ZWTMaBh5mIiO/UGBQ/StHadHaGqihIskxhrnjvEb94r4kc8TlbGsT36BOZ3pEzkj889RnjpCyjDESGfP4uMWgwWDPg5my7UnRhlrwhVhQO1XqE47hH3IEGy8X36swXrVu2DnFQRjKqegfniDtwe5f4UXNtETOUao6JzypRJvav8eKBZ+1oyyjjUCUSgGTyLFXeLwbBtiwRz5sDYt+ixWL79gZxnKQy43t7M2jtc7sxDArAfmWHGDciOzN4ZXqTyLb0nPvBmKeEc187ep1wvLl3VP/flutGUaAYgIH2jjSJFld7TfpcqNWHoyyH+YtEcruGgFjWYemsI8LxE0dnCMe2g2LwdLhcfHaZqovRMoifx5Ug5Q/1Wz4jxRkxW3Xi+PctF11dltniWtG9W7QmpaziwialxPloCmTwXRWLsSpyXOyPtVNcp/vGisdGX7q/SvTts8aoavrfv9vG+wUjW9ERnFU0rdhD3y7tdNqTiPeFMVj18d8AxL0Rtn3zxbPmh/ateA3/Su1UzRGMAMD77BqSXn08PADB1RtJ9mlXhgaI9YWJdOhv+yT2/GKtbu6T6DAYdoeLwOtbibfqt0TBCTbyaPbA/f8YjMS8CBhRXoaAEouT7PHqlk/6/boXiFigl77j+mi1VVUdNl16rKWZeId+WnP/6zuIHDg+vN9o6kSJaS8qRpeFREA/rXbCG8bk0R9D5DvShXuMfpI6gJ5HVpHo6NEWBOINrZhK9LWvKgpJn59Ej762oz0dxHo7tQVHcEaRig6vptBwKORTvgC9/3hRt3yiqwf/86/q7Ajs/M7LumgETqJ3bzudmxqIdmunVifjKdb84aCmXCYUjTTmk0i0d+N7Vl8JlZMIrN1FvFVnvShVJdaoHfDcLz+M93oSSvLsKXcjGB5G3EZDoOObfwNFYdTVH0euFF0E3kkDgz7nkIyqqhx+/C/IRhMFn/sY8qAg246MRB5zXZjOLa8S6WwhmWvCuECkvFdLMiq3HrJw+MXfoyoK5bMvRZ4qpr0mW0STvbJxPz2bV2FyeSg593JC00XTcO5YMRLf91APgY17yZk6BylsxjhjQCGRZFEZU3e5UZJJ+javwbtlPSUfug1T1UBuqTpd3BX2RewkrS4CfQp9ETtldnGH6TGJpuExOd3Eo10YitN/b2geJZw/2iMqEVZTgvZ9AQzV5bQHXdwxW7SQ5BrFBfsXf19AvKOdwGu7ybn6AiTDwP3NWCLS/+9pTxeGTDS14ppYgNsqvhfFKxyiyjK9OzYSPLoPW8VoDAsuEs5nVhcPNR6mff0LGKx2Ss+7EkNETFu1ZiRMmANJ4vEgRqMVWTbSslR0zRRvG+ifrTN9XyklgUE2IcVEE7lza8YCbxPdAaag6C6UM66P5VtRlVR/xoi9zite73dkyIuulb7zRPeeq0F8tnJG+mnZuoExmelWtfWkH2wiFsJkcWBvE9tKZDDRmn3Q/uorFJ67DIPFirc2o1p3nni96ZiV7h3rKJiZpu6PVWXMCbfYV5cxRPsbRym8fhQFc6qoe71GOF90rqis+mJd9G1rYNLHpvCSX+Ra6vKLLmAlYqJvTxtb/ryP/BuXcsu4rWJb0VOD+4/+YxsAoWYfhzvEcgKWInH+PbB9Kq0Pv0DzpBswFuYzbbyYIr+nXHyvjgYDoaY6lIAP16RZSBl+I0fHwLNyn9NFn7cD3942pn9qBr5e0Z2W6SZKeC2kQmG673+Jwrtvp+9NkbjSnKEvpWwSkcbjhHdvw3VF9SnudmvGfsLWaaTv0Dac1RMwWh2nyNu7xPfaM8lIMhSgb88GCs9b1u+GenvLA4wE7A7GiOVlCMT7ukiE/KCjOFg80Eeku4VwdwvRhuxF0AxWO6HGI0Tbm5B10PFLkoSSTBLuacGWq50SbHTlEGk7Trj1OCZ3rqZ8rKeDcP0Reja8povWPnT0AN2r/oXB7sDg0k4nNzotJIPaaZQnEemNYMvTl2GlphTCdR3YR+vLroo1N9H2wF8x5ReQCmTfiaqpFLHGDtSUgtGjL5Ay0tpA8NhBIq0NKMns/A/m3EIi7Y1EOpow5+rLBjl88FkO7Htct4Vv05Zf0dunTTsPEEuG6ArpYz6FNINvPKaPKt3fU09X006SCX07dFVV8IdadfdFVRXqdz6jWz7h66Xzjed1y/fu20Sg4ZC2IOlxIxlkene16npP8Z4gyBLtL2pbYiVLWhHrefwNwvu1iy1Gu0PEAzHMHhuhZm3XlBIMQSqF9+mXNGUBVCVF+8qnUOL6LKux7hCyxUjH64e1hQHvMy+hBEK6i+N6N68l3tGmSxag7/A2Qq36xrwSj9H0+F/eUYJaST0z/94vGFFesqB86Q1YC0o15UJtx5BNFmqv+AT2CROyykqShHP0RAxWG/aK0VllT8KaU0jBuLkYrdofUWt+CZLRRN7Uefq4WPLTO5q8BUt1ZVIE9u4AScI1YSrGHE9W2ViXH9/2evw7j9O7VtscHemJEOmNYs2zoqS0TbotD6zBv7uB0NH2NJW/BmLtraCqWErLMOS6swvLMo3f/Ht6MV+1TbNtgFhXO+bcAsqWfQBZQxE0u3IxOT14JszWpcQCJJMRasdeqiu+R1UVnI4icj01mrIARtlCStFvEo/HAhw7rK9OjSuvms7Grbz5r2/TXr9ZU16SZOpaXqfLq09haD2yhkCvvsrJAKgqfdvXE27Sr6w1r3qUVExbCZ/46fPIm15G/uxKXe9p/FeXY7AYqf6wNreRJMvYJo/C4HFizNWxFhQ4KFk4ilHXTKb8wjGa8qlgCCSJeEMziXZtd2bv9vXEutpQEtruY1VVmfH9q5CNMtU3azORJzp7iB468X4S2uMy4fcS2LeLWEebLqUxGQkSaDxMsOWodt+VFM3PPEC0rQlz7vBc1GcUIzEvAkaUlyHgGT+bvEnn6JKN9XUy5uq7cZbpU0acoyfiHD1ZF1ETgM1TTPGU83XJSrIBW3Elnin6iOfMeYUYXW7cU2ZpyiqxKNGWRipu/ST5iy/WVI7MBS6iTT1EjnViKdHmgGhc18zRF+rY/qedxAPaC6JklEn2hVCT6d2uFuLtbbjPmUf+ZVdpflgkScLgtKHEkzjPya6QQtp/riRiVN30SYxODcXoBOyl1eRO1veeVFVl/IRrsVo9OuUVJo2/QXdqr0E2UuzUx5kDYDI7UFWVZFJ71y1JMuPPuYXckvG4C/QpU6PLz8ftyF5mASCViNLTtAvZoD/IW1VVkCQCdft1WrEkEiE/Xdtf15S0l+WQP7uS7q36aOedtUXYq/IINeiLk6r45q0Y3Q6UsD5rR7DRi7PSg9GevQwCgKmwgNybrsI6cSymkuz1xZRYnODR/SBJupQXSZJwVOVhsJmI92mT5pmK8rGMriL3pqswFmkrDPGONsyFxZhy80lqkAgCeI/uAlUh2KJtmYyEekhFQiAbdFtJR3D2MRLzMgQqzrmy3w+ayIwfHZSGZ+tWqKpaglG2QbeCv0b8KMqJjBS9PDC6arE7038XZhBZtl0gvpLcA2Gc0nRMzVYgjL8mI8YlY80OTEnglC4gNtlJjARSSFSQQm+KC0HJFS2gnkPhBeksgK6NA5amzLTQiKWNov++G4MnhygpDB5x0bJllC64sPwIjuvK2HCvj8sX+dgTFGMdjgfENNdwlYNUbAO28RU0SpXkOkQ3gz8ixmbklFjotJkYf9tMzLYInXHRjfXPZ84Xjh1Tn6L4g4uRDH34fRmlCXxiXyK9NmR3Dq45M0mkCmhbKb4XQ4Z+koqFqbz+TsyedDt5B0V3Y2aKfNIO+TPOxVZ4ggcnQ5ky+8RnGaiyACWcjCrKjC8IlQ2kO3v2ek/8JQNRyFTsMmop+SeL8TaO5oyPS8YHXlKgtHQOZWVp5T5ZID4bc6voojD1pgfp7PyrkNsNRCyilcxYL3IP9F5QA4wnmu49CfvAsynYLsZVhSvsTF18N4lYCCml0nSh+F4tXvFWTEEoP+dyWmIJcsunYPHD4O2oY5c4xvxzojhj5yFt3o3tU+eRkjOsADHx2R7YMYqYy0DPy0+hzB6FUiDeq8MkzpkWXw7G6jI69nn5h12MSblxumjxW9uRzrePXTiBxKbt9Fwk5t9PzBOD9NccGUPH0QiJuePobShHNYl9iQUz4odqZWRTBZ2/34LJHePARnEzJtkHrjcYLbgnzsBSUIx77FRQIVSV0f7cgfnb0XjCtVtUwuGtkJGpjHxQHJNOr0rrnjoqplyGyeshuUikBggHxPR+q2ci8vrXyL/sCqSCHDILnuceFq1mvrIKPBPnYC+vIWlIodrE+dl02cDfqlKA8pMkZd+6EyqdxOxhxv1vehwmUzHEBPOziJGYFwEjyssQkE3aO5WTMJqHx4Irm8zYx2nv5k9Cq8pvJmyTx+qWlQwyJVfO0NcPjd3Y6TD5iioa3uzUxbJrr85HthopuVy7SCSApcBJ1Q2zMOfoe/5pxUW/sdFUVoL74sW6ZI12J0a7vtiYk3BU1GoLvUvxVlLTZenscGLIsnFY5Ras+SXUXPGxtLsurG15cS6agXPRDAD0JP6ZK8pJ9PaSCoeR3Npj0za6hGh9B059hl7yz5/Ivi8+hKqM1iyImGjvxlSq39Vhrigi2eNDTSQ1wztyp81HTSWRdLo9AUylhSRau8CTvWRIMuTHYLVjcnl0t+05dwmmgiJd7nJ7aTX20kGFrLK8V0mWKf/ep9758hxnwu0z4jYawb+Ld3wiDMJwPujDhavYxqJP6KttJBlkCs+fQM70Sm1hwFGdR9WNM3X3Zbj3mXPlxcj24ZdnGMG7H3rjjN4KJFnGWjua6FF9wdLW0SXEmvWlAwNYityM+tSFmnFhJ+sNyXbtytwnIckyo/7wFV0VsYFhKS4AprIiEq3a8TQmZw61t35xWG07Jk95S+VU9ODdtF6PII0Ry8sIzjoqZunf+Y362GLdC4W93PMWe6QPBvfwLCkjGMFJFN58I5LVqmuja6stZdS3byGgj6sOVVXxnDMagyl7RpZkNlL81Tv0NTr4Oh1Zh28VjoUz0y7SvTr6oTNe6z8GI5YXASPKyxDwj1GRrek3bekRP6aeQwPHHfPE65yNomwio85aKmMTFCwT5d37xSCWuptFU7tZrHqPNEmMAaj0iCtgKC76hr0+MeAs+IyYTWUcFDYSqxAdx3nFot/ZHxRvptApps7WWEQ2zYoikbzksRYx6+Ce2mdpOBrDk2ckJ9fAJ7bcKpwvyBHbP3JcTB3vLc5wr00Q5X3daWVEicawd4h978ugyLdWZpQDsInvxWQVnfbmzRmcHBkeEk+dGGDZeJH4e/ZOcSp69ogv2urKKCtxWGwv6RjonxQT31u00iO2dUD86LleFd9TbI6YmWKtF4NJzamMUgajxVijjnPE91K6Rhyj/irxXn3VYmxF8aaMr/ig34tlvGPVkEkDL14azdCb5YzYUnuHeC+BURntHRfHSSZfjzmjq8r0Bkz5J59HFG+LGBxVt2aUcHz5FQPZV0cD4tzc0SdyOrktaUtK9+bjGGwmnukS/UwVlRlBv7IJc2V5v6vLkiOOmXifeG9XTtspHD/tE+dnZrhELE9ULjLTcBOdA1aQk8/NQHqcRsUwK+Ie8cEm7eKPGTN+3NAtuvVzNngx2waedfc0sW+ti8R7dTWKnTVGxWM5mVG+IIMaqeWydAxPKhaFP/D2YER5ETCi2r6DSPp9ujk7hoPebQ3U3392KO19W47qSksG8HXFeeEPw0hhBR78dS/7tupnQE0FQ0QP6jPPA6iJJC3/9WNNHhZI88iMUJOPYDhztOVPL6PE9fGSnIQeWoDBqP/nVsLNXn1txxPEG/VznyTjwyuuGDq4f1jyw4GqKEQb9WVttR9eR9ir/z5H8N7HiPIyBCL19bpl411dxFr1kVKdhJKI03jvr0j4ejVl1VSKyOEjqDoI8wAiTX0oUf0LqKoqtG38F6qi3X7bQ28QadBXn8TmMrDqvhZSCf2Ls9EIyaT+5xg72kDg1f/P3nuH11Fd6/+fmdOrjnq3JPfeu+MCppkSOqQRkgCpN43fbSS5N+2m996AQEJC72DAxoDBuPfeZMnq/fR+zszvj2Nb2mNLMyI4EL56n0cPjGfNPntm9t6z9irv2mxYPnGsEeuocl0eFoBUey/NX7/PcNvBw7vp221caVTSKRLNxhbnEbxzCO3U56Y5jWRbH+3366dUn0YmmeXA08bXmsD+Nvx7Wom1BgzJJ/YfI7bjgOH2j69rIdhqjHwQoO/F58lG9UsPnEbyZJPhdSzV2kp4i9G5rXJ884Mo2eEpjum48VpRgR59TpjzitPZRv/o33sEb8lt9IlPfIJf/OIXeDQMq9FolM9//vPce++9b0vn3kmEVr+MqT2Kb9o8SreL5tbA6H6Tv+VQkN4Na0j2dlA8byXJ+WIAaf4R8cPdvkLJcSS8sQXbpNHY3YUwYL7FNGSxrkaZpucfINJwkFFXfYL45SJPRrkmnfhkRyF9jRlMvlJOdhRy4XiRzXKdV7TXhjp6CO3dQayngfwSE+mJ/e1ZT4jBb30JH+aqsXRv6MUtjcOkqcQa84mL3k/2XEWmqJlvPz4TW10VZrvozlhQI1pl7jxwE83R5zjSUMdTB6awuEZc1F8/Kroz1KhE+kQXlrJyiJsI7hV9BBmPuEh6q0PEThzEN7+GRIXG7ZMvplJmjjrItpshbSZzxI4tIbqNkuM08tkAsVAHSiJGNNWLwyOmXgfGaNxEHXD8778mHQ1RfdlHcITEStDJUtEN5XpdfI9Skdh+6/J+V03Vq+Jzk8tnCMdqUHT/SZWim8d+TFMXS8NwKlk1lPsB8Xz5L0TaelO16P4o2i3umTJusT3pmKjQtd027cz/Fx4QLWFpW6721+kAXJMmRVbrRvI2KqTiQaynspMS+WJfFM2KmHEo9Kx5DtusSZjzvHjGiO485TXxPThsKj1Pb2HyyhJK5lTSZhX7210gvtcnHq2i+29vUF/wASbOFu/baxXXnQW+Bv72/G4A3D0tlI4WLQ1H60UXsMmZIb5zP+m2HuQbL6RY43ZFc/zUG/PoeuQQ9t0VeN83D3eT+Gzi5eKmIutuJtXRTty/C+/0mWR6xfXC0tfv6jztNup6+iVKrr6R5BTx26GldFArEkQ37iF25CBKWQzzNlHepXGfWxeEaLuvjYDtYaZ+ZiGmn4iuyIxd/GiHamWSPZ2E6ndSvHwVqiZry6GJn26bL9H0q6cZdcV/IMnyGaqCrHHy8H8YbwdD7v/zDLv3338/8XMU44rH4/zlL3/5hzv1bkC8rZFMTF8rN7u9JHvaSXS3YXK4dOUBeu9/hNDa9eRdebEh+ZS/CyWdQknrz5RkQyuZrj5Mbqchl0c6FKT3jbWkgwGS3R1DymYjUVAVwq9vJLJxq27bSiyBbXQV4XWbSNYbK5gmmWTUTNaQFSuycRvR7bvI+oO5vukg3RcmvLMe9yxjKcqdf3+AdGcngdfX6/dbkuhbv4bAlg0oBphYAVKhPjKxMCabsWyQlDK8goIp1fjKmlXSw7IcqqpKNGmMWA0gPcxVPqUYk5dkmZNbn6S3cbfh/ve1HcDffsiQrJpOo8Ri+J83xiZszbMhW2RiHcZ29KmWVtIdnYYyk1RVZdWXxlNQ5WDprbX68tkssZ2HSda3kA3rE8MpqTTxg4eIHzLGbBzdmVOoo9uNycebGogdP0ImGDAkH9t5mGwgTKpRv1SEbDFh8VhJBuJk4vqMvKqq0rHmCbJJY3Mq2dFGqruTeINxF/UIzi+GpbyEQiGCwVycRjgcJhQKnfnz+/2sXr2akpLhc4G83fjtb39LXV0ddrudOXPm8MYbb7yldmSzPteLJMkUL7gEAIu3QEc658eN7z9MNhAivttAyD0gma24ayfiGTNNVzbV2EZ0y376HnrRUGpwNprbffnmLcFWPHTtJNnlJNXeSbq9E8mkz9mRszBtJ/rGDlQDMSahrceI7DtJ91NbSDbrp47Kdhvp9k7SXT2Y3PqKY/NPniTZ3E3scIuurGQyYa2oREkkdEs+AJi9edgqqnP/LavQlc/9hpnCmctwlFTpCwPNycMoBiuMq6pKs2rczJ1RkuxpexpFNWbS98eaaA8Zj3dojRwkmTXuXmhKGVMuAIrHzqf+jb9y8MVfEevWf7eqotCw8wmyBtiBT1dMjmzbbqhi8byvXUjRjHLsRcY2MsnWVgDCb+q7GyVJwt8Wp6jWRc0Mn658qqULS2UJ1ppyUif140ESR46iptIkjh43NF9lhxWTz42lvNBQhea+dS8BkA7ou8qz4RgmjwtLeRHpdn0luebKiUz6+FzMDgtmhz7bcvjQbmKNx1AMlB4AiDfmShWEdxsrFXJeMFIeQMCwlBefz0dBQQGSJDF+/Hjy8/PP/BUVFfGJT3yCz33uc+err4bw8MMP86UvfYmvfvWr7Nq1i6VLl7Jq1SqaDAZ+nYZvxgIkszHKce+4adiLyg0RKmV6/ajJFHnvvwTvxcsNtW+2Oym/4DpDKcTWUTnTsWf5HENcDdloGM/kGRQsvkBXVpIkCq6/CiTJEP+JOd9L3hUrAAzJOydWkmzrIxOIYqvWT682F/gA8F15ia4sgJrOomYVHHXGCjk6J0zAXFCAtdyYMuKeMAXX+MmGU72tviJKF11qSBZgjGMWssH0UUmSGCNP1Rc8BZvZzYyKqw0TyRW4ahhbvNRw+zXeWdhMxj7oAGPtxvl73MU1+KqmoKST2Av0i5eqSoZ0MkKgQ99ioGazeJctxTl5EuaiQl15e6GTyhWjaV1vrG6SY+IETD4fnkULDVmOuhujFNcae462mnJc86bgnDkex1R9a6OlpBjHtCnkX7kKJamv2HlXzEJ22sm7dJ4uMVw2HsdcUIiluMRQ2yaPE+/l78NSVYp7yQxdeUeRi4rlo2l7vQFVGfo5qqpCvK0px1FjMP4GwORyY3K5DClqIzj/GFbMy6uvvoqqqlx44YU8/vjjFBT0WxqsVis1NTVUVBhb6M8XfvrTn3Lbbbdx++23A/Dzn/+cl156id/97nd873vfM9xOydyLSQV6kZPQcKs4GUY93L8riReaAInaedfjCpqIa9b+YJ3Gp76/g/xlKymceylSl0TSJ8o7NeEGkgKl8y/B4S0CBeSY+AMdHWIDXr+PdpOZ4vJlWPY4eDkofsBkRUNDb3ZTcPEHMMVz/66Y+ydz9SJxp9kbc8EoN8mLZ+CtU5CrxZ20PyKmsc4Ze5Ls52pYs8HNjCm9rJwg7tQfOCHW9fnegqf5n4VOCkrNfHnyM/hk0dS9rU0kr7vk4pO8+EYJN97aC/TSmxJ/f0OjuGAXueIU31THqsv8/HWnhso8JMakeDskzL6JKHVdODtlzBovRqJMVGyzDhXHjMlkAkGyDpVItfic45XiIlm0TaZm/rU4kjZIqqS84nt1N4rxCNIpRe00Oi8UP9I1f+63sgSvFVNo8/aLO1e1RjNH+3IxMKd77F9RK5z27RZ3ylkNo7Fli2glkcaLz713rvjRd/SIu/p4sbgMmaeJ15dt6HfBqBZxPnVek3tuztGX4y0soOzv4ovqnCfGmPROkzGNnk/d5QvA6SKs2Z+kK8UPqynjxXvjhbR95cdQaiHoF/sqV4lrQyBlx71oIgfu/RujP28llRHfa7pdHKPFvmlEXK/hDDuZmS9usDZ0iXEbvzl8Af6Nz2IuGU/z5kWUlAeE8+VVYiBIt98DioJkkpEkCKwTx0y0RhyT5gkZsIK5Lh+50krMKc4Ra5U43xMdTtSsTLrbhpp14GzVxK0MOFQtDqx5BVgme8iftQgpT9NWXHwu1uMOzG1W5KiM5biDeIn4nNNzxOt37siNmaxtPZuftFBUM5QSLlPUPha1vJeacauwnVSxhsVnESsSry+btJzI9h0UjZmPLSDj6M71J5v655kyJN6GmJe3pSfvDgxLeVm+PGcpaGhooLq6GtkADfM/E6lUih07dvDf//3fwr9fcsklbNx4brNsMpkkOWAnEArlFnKTzYl7lL4b6DQ8JcYKztnKK3FPnj4sxkZn2Sh9oVOQLVYKF1xomFbbO3HWsNkjy25ZgZJMY2TPYrKZmfbZRVjdNn1hYNFlebg8xnb/riI7Sz6n70o7jbwKJxd8YbJheYvHR9EcY9YxAGt5BdYSY1YdAGfBO6vov5dgKT3trtZ3A5hdwyMfNLmcuBbMRI0nkCz649hW4MJZlU9gXxvSBP1SHa4a4wUx0x09OKYbY6yGXLr/WbWthoC5MA/ZNQxGXgnDrghX3Xgki8UQff9bhWvGNKJ79lE0fej12FcxCU9x3bBKuxTNuwCTY3ilWkZw/vCWRlFNTQ2yLBOLxTh8+DB79+4V/t4p9PT0kM1mKS0VPyClpaV0dJw7GPV73/seeXl5Z/6qq41R079VWAuKzjvVdNGCCw3LvpW+WPLd2MryDctXrhyDyWFMT154sZeZS4x9XGSTTMV0fVP+aVz4xcnYPcarD0OOptwoJEk6r+ykI3jnUPCh9w+rVETJ0rF0bTAWc1Sy+FIcZcbWnUxnN+Yy44zVrtkTcM0xruwUfOQqbGOMb5bcSxchO4wpO/bKamwl+m6907CWluGb/z7D8gDOmdOJ7dWPJZQkadg16XwTZ2F2evQFzxfegVTp119/nauuuoqKigokSeKpp57SvWb9+vXMmTMHu93O6NGj+f3vf3+WzOOPP87kyZOx2WxMnjyZJ598clj9greovHR3d3PllVfi8XiYMmUKs2bNEv7eaWg/yKqqDvqRvuuuuwgGg2f+mpuNZcW8mzGcopLDRaKll1S3QR7zU5AkybCSVFBiIa/w/CgAnpKROkUj+Oeg4oopjL19ib7gMKAqCpLVginfuEJtHVWGdZRxhWG48K5433mr/2Xx+nCONl5kFsBSXET5lz9/XvrzjuMdCNiNRqPMmDGDX//614bkGxoauPzyy1m6dCm7du3iK1/5Cl/4whd4/PHHz8hs2rSJm2++mVtuuYU9e/Zwyy23cNNNN7Fli3E+JXiLPC9f+tKX8Pv9bN68mQsuuIAnn3ySzs5O/u///o+f/OQnb6XJtwVFRUWYTKazrCxdXV1nWWNOw2azYbOdbQq2hVVMyVNvere4s+geUPTY2yj6hbUxJUnNvM47IY6eeJGGf2CCxhmjjQ3TqJumbtGSEB2TyZFASRKSLJN3UEPFPkdDK+8X712p77d61MfEti+afJitj+zAVeJkys2TePmgZkcXFn9r8jgxw8GvqZUwt1RUFD+/5qN0/fbPFN56MyaXky+veFE4f9PYXWf+P5tWOFpvJm9UPyW4RcPd7rCLqeJ/3TETMllkpx2LU3Qv5HvE+JqgT3znplfFHZejTePf17wXLb9ItleU9zaI7yFSJSqcyk6RWCx+lRgflH9YTPFUKvp346aU+BzULjFzS/KIlq3UeNF9ZfNrxqBF7LukDVjUZKZIvWLshe+IOMYSpZqYmYjYXqxMlDfH+8+Hq8QxadJUhQ7XDm3W15bXYEVA7MtWn3CczBfbV8vFmJqsW3xWza+KVovsVDE2Q7WK7cUqVJREAiWV4qHdYqzSuFHiOjZrYgs8eD2q2oQkSXRGxTHZ3iJaQ6WMOCiTs8W+LKgWM7OWF4gBzL86uEI4zmjid9Dce6xSPC1lB6xt+eJclBvFMehuF9dBbRkVc0w8P3CdAhjYM5PsIVIrjilTVHwWofGataJVU57juHje2aN5zxfl2lPiKjzEexarVq1i1apVhuV///vfM2rUKH7+858DMGnSJLZv386Pf/xjrr/+eiAXh3rxxRdz1113ATkDwvr16/n5z3/Ogw8+aPi33pLl5ZVXXuFnP/sZ8+bNQ5Zlampq+MhHPsIPf/jDYQXFvt2wWq3MmTOHtWvXCv++du1aFi9e/A716p+PnnseJH7AGPfCcOHw2Uj4jXFw9J2M8OzXdw6r/UyfHyWqz0nR1xTlpS+/MixukvDazQSff2tp80ZwPko9jOBfC9l4lFSvMQbq0whv2UqqWT/F+zSaXzw/c/s0lKzxcZw8Prwszmx0eFxF2VgUJWMsnXm4UFLnp93zhrfR8jKQ5iQUCglxn/8INm3axCWXiNmfl156Kdu3byd9Ki19MJnB4lIHw1tSXqLR6Bk+l4KCArq7c5N12rRp7Nw5vI/V240777yTu+++m3vvvZdDhw7x5S9/maamJj796U+ft99UshkyqRjppDEeC1VV6Tm2jXQspC98Sr7rN/cYptVGUYYVFNe15hliTcZSO+35dhIBY8qLp9TBkXXtwyoPIDsdZ7g1hkLxGA9mh5nug8aJ0sxFPjK9w3N5tf/0UTJ+Y4Rjjb/7Adm4vuI1grcf51NxVBWFTEBrsjk30gE/vW+s1Rcc0HbojTdIdRiry5P0xzn8x82G7jcbjZE4brz0wGmsu8+469z/4HMoSeP1v4JPv4qSMP6h7Nmw5gwXlRFkI8ZlQy8Nb/MTjwxPKX27cZph9x/9A6iurhZiPd8uo0NHR8c5Y04zmQw9PT1DygwWlzoY3pLbaMKECRw5coTa2lpmzpzJH/7wB2pra/n9739PeXm5fgPnETfffDO9vb1861vfor29nalTp7J69WpqamqG1U74wB7sjjx8peNJu0Rzqc3fP+BDSg+N6x4gFeqh5qJbsLlEV4pZ8y2LlUh0vfES/t0byZa6cNi9QjyIrUv8LSWVJrhjE9nuANZOSI8VFZhsRpP6XJhAMmWw+DJYCxOENZwQalpUamKtDcRbGnGOHYdCFgbyfGiCu8ptQaIlWbpDEcptQawtoqtjxSW7heNHji1ELdnN/S9UYhtdxZwacVE85hcDD+dMP8GmMoXRpSconZ5mdaeY5v3Z6teEY8/yGWx5soPRFTm5SFLsT2WeqKiEKt2E1/Vhc6Qp9oqLXOtuTXXtqET02CGi249TvMhNRuP+06Y+m/tkTD4fkZajOMaMw6LhNNHGyaV8Znpa96IqWQorphErFQUC3xYthZ71nfS27aNqfI6Px9ol9j9W5zvz/13uHtKREJ5RuSyWri+IY3L0g11okc2mMZlyLhlnY0A8qXEDZSeLrhHraHFuJarFmIx4UW6ZSUb7sLkKyF9zTDifnFkrHCvm3BhVVQVJksna+p+N1p3gO5w7F2jcj692Gim3phqxRs82J1Ri/nac+bn3HdnkE/taoXEndMpE6o+SDvhxzVlM1CcumVJK/L2Et4vQvh14P/o+rJXFZLvEgTNpmmip6N1wjMa+Plzp41RVTBHOJbPib7X4ffQ9v4VET5QDe2XKNK6PyeNaheMjmypp/9PfqLrzTkwuN3Omi9adSFqcLz98+UqSJxrp+tMOdtV8FnuXuFZkJ2hclaE+ksebSB46gmvuZNQ8sT9Sd7/7T4mZUeIJwq9uwzlzFvIU0TUY0RLLObKkO3rw73gT++Uzsbt94uk2zYSSIBOP4t/4MmUrryGdFfteulV0bTavlIhs2IJz8mRsNaOQNZx8sWLx+lSeTOvjayi78mZMNjuOU7pmNvnuyrg1iubmZrzefpf7uUIn3irOFXOq/ffhxKUOhrf05L/0pS/R3p57e1//+td58cUXqa6u5he/+AXf/e5330qTbys++9nP0tjYSDKZZMeOHSxbtmzYbXTUb+DE3qd1rSl2Xwkmm4NsKoFVM8EGQ6q3k2wsQqy1UfeFSWYzPWufI9XbTfjAHt22s+EYqpKj1zdiFo3VHyXR3EjPyy+AAWuNM99G1G9s56QqCrYJNUS37CdpgOIbwOKxkY4Y28kVXTCJ3jeOkIkkdImpACxFeWS6g4ao0gH8G9ejJBP0vfGyrmz0wD6Sba10PPRXQ20D9Lbt58TuJ0knh7bsqIpC06E1nDywmmxm6GejZDM0Pns3DU//ntb1T6Ck9Z+lomTYuftPhCPGdv+qqtLVvZ9s1viOu6dxF70n9cfvaXS17SYWNbbTTUUDtO9aY7jt3sZd9DXtMyzv37mJRIcxa0SmLwiqiv/xVwzJR5r8yFYTmZgxF0botd0AxA7pu2sksxklGqXrwQcNEaspySQ9f3kQSTb2EYnvzSmhse3GmJYjG7ejJpKkW43tsAOPvwhZhWzE2Hzt3fIKyd5OfUEg6/eTDYWJbN5mSD4TDRM+so9E2zuY0PE2uo28Xq/w93YpL2VlZeeMOTWbzRQWFg4pM1hc6mB4S8rLhz/8YT72sY8BMGvWLBobG9m+fTstLS3cfPPNb6XJdx3SqRgTF96KxabPZlk+N8eSanX5DLUt2x2YXB6KFq7UlZUkCZPTjbWoBO/0ObryofW7ie9voOs3TxnSZG3luSi7vHmLDMk7863E/ClDfvFMT4Doht0En32DrAHXS6wzgslqIni8l2ibvkstE05g8TrY89n7DdVx6nnoNdI9QTr+8JyuLIClsAhkmfxFK3RlXZOnYnI6kSxWZINcENl0gnFzP4DNOXTauSTLjJ11A25fFYno0G4ySZKw5ZcgW2z0HdjMsUd+Trzl5JDXKEqWivJ5tLRsJJvV/4hKkgSqysbNPyIaPduKo0Wg/QgnNj+Ew2usdEhHy3aOHnwSp6vYkHygYS/x3lbDFYLNVjsNGx8iEdYvQZEOBYgcO0i83VhMippMYy7Jx+RxGnKnjL5xBiabmTnf1GdaVpIpPIsmYx9TjjnPGMuu7HAQP3KEoIH6XJENm8gEgmA2xrOkROPIbifIsq5ypCoKsR17QZZJt+srGJneANlgGMluQzGgvKQjIfp2bCATMeaKTzbklL/ozt0oKf33FNq3AxSFeOvQc+m84h3INhouFi1adFbM6Zo1a5g7dy4Wi2VImeHGpRp2G915552GG/3pT386rE68GzFuzs04PcYWW3f5aHyjZ2CyOQxQZIHJ4aRk6SpMNrsxojeXm6KVqwzFsbhmjaPnvhexT64xVB7AVl6JbLfjnT5bV1ZVVbb8tZ5ga4y1P9oHU4YmcLOUFOBePpvgM68bIr5KR5I0PJXbxY2+drLus5HtFpI9YbKRJJlYCnQoGJzTagms3YGlzBj5oLWgGM/UmVjyC0DHlS7JMvkXXExg/SuGzZ+ltfMpKDdGmmcyW5m06OOkEkN/oCXZRN37Pyn8W7xw6BXLbLZRWTGPyop5qAZrJxUXTyWdSeBwFMIQHxdFydLTsANVVbAbUF5UVUU2WSitmI1ksBSCvyFn0Qm3HadgjD5Vg8nqJJtO0HnkTQomXD3k+4qeOIzJ6SIbDRsKHM27YgkZfwhreRGyzUpWZ9zEO8M4yjyYrCbQCSWTbVZstWUk6ttxz50A6H/U3XPnEt66Dc/8BcDQCphr3hyCL68n/+ordNsFyLtiKeH1O/FdewGSLKMXPuK7/nKCT6/BvUL/I2Uu9GGtqcS1YCb2SWN0P7rhY/uQzGbDMWeWijJcc2djHz8GsjqKl6qS6u1CMplIB4zH2L0XEIlEOH68n6+ooaGB3bt3U1BQwKhRo7jrrrtobW09U5D505/+NL/+9a+58847ueOOO9i0aRP33HOPkEX0xS9+kWXLlvGDH/yAq6++mqeffpqXX36ZDRs2DKtvhpWXXbt26Qvx1kjP3o0wjashZs3tQDQZuKQ9A2JUTsW/1My+GnNMxWrSpD6P1aRamlXMs8dgnTCOmKxQodkQ9UwTF2xXOxTWzKTYNRGpHZRJ4gLq3KXhdMnUYvHkU+iejfM1N6HR4u97Dom+5VhZHnkrVqD4rCioFE7p3432BsXd3d/WLyXgj5NOnOBYaAK3XbFZOL+1R4yFkCTIv2YFkdd3YnI5OOYXtYtrakRCw2NFJeSPLyQVSpJfZqPEJpoWf9ZwkXDcSxEFn7iR7l8+QPtJOxdeILo93tg7QTi2F1Zj8r6M2VJDc4eowKhF4nN1dFhxuIrxzhqHJQwJjRGgYLcmDiqkUCjP4GR+M0X7FPwTxPfo0HhA/ONNyONncDqaxKTxxJXsFFU3xSJhtuRh9uShAIkqMa7Esak/jsR5xCfemyZVOj1L5M5I+cQxYYmKAQByQhwHijV3b+W1C3LXlw6uNcqyiYnTbyJauwyX5EOKKmTrxNTs0ChxDJfK0ykpnoZ0yroXLe/vny0ojmd7Z4rRo1YSL+rFk8ynd6n4IM0dojk8U54iPbmK8is+j6WyhHSHJgXXJT730pqFBN1bqFp2PbaARMKqUak16cijSgNYp3gIHT5JdfE4qusCwvlYVrzXvYdMZPOLOdRZypemiq4mf0Z87sEiB4eONNFUFufS0ftpT4hjYMNxsazCwiWHURePYet3WimKrWHr9quF81a/Jq5jx0bcE6aQP3o2BCBRLt5rnleMeVFVCZMFnI44No+DYKc4DvLH9cdKhY7no7QHMfsKsLmKcewVn3taM4RsARNd+1soKVuIo6mAtIa3Ml4pLsqF6cX0vLmW2us/jZRS0RLhty4X56srWkHcnoccymJLOs+iNogLeraE98pLiZw8RsHN15Eyq5RuzY3DzDCSEf5RDAy4/UfaGA62b9/OBRf01707bcS49dZbue+++2hvbxfqBtbV1bF69Wq+/OUv85vf/IaKigp++ctfnkmTBli8eDEPPfQQX/va1/if//kfxowZw8MPP8yCBQuG1TfDysurr746rIb/X4PVmacvdAqOSRP0hQagZNpyw0qhJEnkjZ6GZ5R+JeTT8r4V+kUZT8O9cD6BF9diqxkF+HXlZYeNgpsvQXYaY+EcfcU4eg4Yj+p3zp2C5+JFKAn9DCjJZCJv0RKsZcaCyl0145FNxmPaJdlE1VRjRSL/X4IkybjzhlcKwfh4l8kvGkc+OYWs7yxipLNhqTRmUT2NulWfwGxznqqkrm8rdY0ppv0FYzE1me4glmLja0cinMY2DJZoSZIYf/NU0pEU3TqFotVsFs8MfQusAFnWtVycRjYaxVJojBFbyWZI+ruxFxmbq5IkMeH2/zFU7f40LIXG3JIAJpeL8js++c4yaL8FhtxztjEMrFixYsiMrPvuu++sf1u+fLlu1vENN9zADTfcMKy+aDHCZf4vgOFMSIDSuRdhshoPwBrOhDTn+3BMnohtVBVGlBcA97JZ5GzK+r7lmkvGYLIb68/pCPX8D1xONhgB9GMYvPMXIdtsKOis5DAsxeU0hks5PoJ3PyzDpIR31RRS89FFhmTTXX7MxT7DbeePcg+bKTp/XE5hOKETm+pbZLxK+GmUf2wl5gJjzydv2VLDqcmyycyEO742rLVvuOtk3tyFw2rbUmS8LMN5wdsRs/IeoqIaUV7egzA7hld4brjIv+pyZIfxBXQ4nDP2fAd1l+tTgtf/YT2JknG4FkxHspgxF/kworyYXKdN8frKywhG8FYgW80UzKk1JOu7fKGhLL/TqF04vIyM8w33zNH6QgMwnLACk21kIzCCwTGivAwCU1LFdGqXkNZwR4Tr+s2k7pPiwhOtFk2oRbvEa3s08YSRcvF6SetS13hbZJPYfni0eKzYNdTwJk05Ag13hKVOjCjsOtkfC2LKEy0lUlEunsBWVAAkeeqIWNG5olDkVSnIE9u+pPKwcDzeLsa0NMSK2P2nnVQtrqZoSjE7esVidTdV7jjz/zsWxNi2dj03fLo/lf2+HWIg4KjR/ZkwSipDa7LqzLGW78buFWMlZE1sQtYhPte+GeJzdTeIu76Cg6J8vEj8PW+j+KIzTvF8vECzi9Ss+fEiTZxIZ3/9mrRPXPTjM8UPnr1HfK/uPeJ7SFeL8UByRHRTWHs1sQ+a8gGWLg2F/lifcBycKCrXhQ+LKdThy6cLx+7WfkVT0mS5mePic/RtEyeMqnmMUVW0SDo12eHpfPE9FNwgpsaqMTEOJWwVf69lp+gea/SKdYXGjBcpA+xFpzPTsjQlRZfKQzvFcgFOX/9zz0YTLBnbhjygYnSeTwxW3XQsp1ictlBOm9konG8K+oTjUKN4XDlGdN92bRfvJevS8LrkiRuC0LH+LLpxs8TU7qMmcW5r1y1rULNOaZKIFIv4nrTlObTeQ1eLOIHcbaJAcLSmAc18s/k1PExjc8f/TJ6XdyLm5d2Mf02GnRG8bWj/9ZMocWO8LbFdhw1zLgCc/PWLxJuHF50fagyS8Osz7E5ZUciJLT2kE8ZYh/d/5XESDecvzVHJZEgF+85b+yPQR2/v+aXNNwo1kyHVpZ9CPhCJBuPsoqqq0vH75wzzscQ27xkWk6xhJm8wFGsmtq0Mqy+JnuGxrg4XRvhv3jX4F0iV/mdiRHkZBIpifAKfTyjZDJGmoyg65GSnkTzZgv8xYzwmANlwnNhBYx/1+P4ThFa/abhta7GXnpd2G5YHkC2yoXICdpeZ6pn51L9p7CNRdtk0gmv0yeZOo+ON50gNIy0y0dlCy3MPGJZXlSzxSI/hkhIjGBo9vUdo69ihL3gKSiJB7NhRQ7KqqtKz2TjNfmTPbhIn6g3Lpzr8dD2wzrB839ObiB04acgFo6TS+B96AdUgJb+SShHesMlwX/wvGCcHBOh47Rgpv7ENkKootK97XF/wFJR0yhAp42kkIr0EOt4dCu8Iho8Rt9EgaHHvJG9lzmzrfV00ww90BVn6kgQ6jhDqbaB22pXYLhCDWHsk0QRf9HKUrhObkU1WyscvpWOhxgwe1aRa1++n5aW/4x0zlVFXfBQOiMFxSqloqrVHXPRs3Ycrvw7PlBlnpXknSkWlzDZ5PKHtJ7BMylGT+6r6XT+xhOia8F62nLb//SXuS5YhO2zMmyDyRiQ0Linrkvl0/OfvcN9wGbLFzN82aPgd3GLfp9W1kpZthOJm+pJOrq0Q3QnrekWa+49ctZst6w9w7bU52/99khgk2d7Xn8WhzpiPcv9GXPJBnKNL6fGLrosZ5aI5/5XqfJo2PIrvggtxjh2HJahJK83XuOfmVZF8ppugowdznpeExq0zMBVaVRRa33yB3gOb8I2fRfUFN5+Vij0wdVNVVfy7N1IwbdGZ+CFPs/j7oQm+M/9vTipEgm3YHD4sVifODvHDJWU0irldk26v3RlrskniFaLrxHVYjDXqWyC6qXyHxTxUSVNrQZ02Vjj2HhXdj93z+t0PssZtFLkqTiYYpeHLj+GaPpqoprKxYtFQFcg5y0LnQ3/Bs3ABGS2foMbN2rSlmtjRI4R3NROTlqFoqkJ7Jojz3V8qE9i8HtuEWpxlKewu8WM6yi3KN7T7aPv5U8gWM9GM6NIaVytaHZzmNL172jj8wMu4R+Vj1XDaV3rE55ZMmel96k2y/hCWdC8HWjQlMCziOJAUiGzYTLKpBWnpOdxETvHeM5kEodc34L5gMZaiQuQ+TcXvRP9admz3qNy4/+NDFH9oAmVhTZmSMvE4Mi1JbNchYs31BEcHqNzgFeUrtYqbROTkUSRZxjN68lmpz2nxcjqrJHqf3ojJ4yI1fzI+HT22aJfYYPfs3Do8DJLpfxxvg9toxPLy/wBCL20ktHaLrpwkmehs3Epnw1ZD7aqqQtvR14el8avZDJmYMfbQvtdfJhP0E9qz3UBfVOyTRhPfe5Tw6/q7VpPPg2vBDHrvfozYlr268uZ8D/Zx1QRWbyLRYIx6XjbLqBljptwVFzvYuD5BOqU/IyWTibIbFtL28CYSbfpZUo7Ro0l1tNN+z5/IxvR3iokTDZhcLtp+/HNdxk5JlrHll6BkUkg6GU2qqlL/t5/Rvv5pTjz6G5IB/aDkRMzPng2/pemocUtTd+QE4YTxFPV4tJfWExvIpI1VCU5n4vSFGw23H4oZL1XQ8btnyAaihkgZAfqeeZb44cOY84dmNj7dft8rL5E2WJgxeaSB1Mk20i3GaOoDz7xB8kgTGOx7tCWIJEvYCvRZnLPRBL1P5Ii/Mn79goVKKk1w3atk+oy5P5MNjaAoRLcZ4wCL7t5DurOTjN/YswyvyVl5063GnmW4/gDhE4cMySqJBOEtW0i1GxtnAD2B4/pC5xMjbiMBI8rLIEi3dBMw4CKRJInRs67DbDEWGW+1exg772YUAzTsAHnjZ+AeNR7JbIzbofCCS5HMZkxOffpwSZIIPv8GmY5eYtsO6Mor8SSpxlbiOw+SatKf9Bl/mExfkN4H1pJq0l+AQid6SYeTBI91E2vXp/n25slMmmZhy5vG/O72qkKCW45z/P+e0JWVnU7MPh9ks8SP6iua1opylHgcJRYzlF1VMGkBjqJKTJah+W8kScI3cTaSyUS8s5njf/8ZvXs3Dhk3YHP4mDj7g4T6ThILG3OruW2FRFPG3GSNh15g+ys/wGyxGxr3mWyKlp6dtPYY+8ipqsrB1heMxUYoCnkrZmCrK8NaqZ/KGjt4iPDW3EbD7PPpysfrj5E42UjGb+yDnm7vQXY7UQ1wn6iqiqW0EFOeC0uRfl8AZJuJ0sV1zPjPFfrtpzPkLZ+Oe+EkXVmAyOYtZMMRMn3GlIvE0RMgScR279N9V6qiEDjltjWiHGUDuc2aqSCPdLu+Uq2qCuH6A0TqDxoaN5Ft21ETCdLtxmNqjjW9RCYzvBifEZw/jCgvg8AyqpRMt99QQJfNkUft9CsNt51fMZmS0cbYBCVJouLC6wynDVp8BfgWLDWkvAAUfOBSZKcdyUA9E9lho/D2GzDleUi16E96c74H7/KZAKd4WHSgqrS9cozGx/dh8RojtVu5ysHa5+Ps2aHv0zc5LCBLxBu7dItWmj1eKj71WVxTpxE7cnhIWQCT00nh9dfmDgwoL5IsU7H0WmSr/n0WzV3BlM99j6lf+CFTPvsdCqYNzSEiSRKF5VOYufTfMJmN8f04LHmUeY0RG5ZUz6VmwqWUVs81JG82WakrW8K0umsNyauoTK2+CtUA4ZxkMhHdcwLfRbMpuFqfdt4+biyyzYZ36VJktz6lgGSxYikswj6q1lAgq+eC+aAolPz7x3Q/opIkkfGHcC2eQeFHL9dtG6B59WFGXT4RV4U+sZ3Z5ybdHcS3chbOKbW68q65szEXFuC77GJD6557yQKso6oovPla0KttlM3iu3gl9gnjsZTrE8+ZfB4csybhWjQT9xJ94rx4exNKKkkmHiHZo7+xso8bizk/H/eC+YaUHUXNMqbqQkNj8rxhxPIiYCTmZRBMmPUxjvb8Ac8TCdRyURFI5g0oDxDI/bewMpc2rD4l7v5sGmLRntPZxVPn0CNJIGv8yB7xOFSgAIU4Ky8kVJGlYI+oZFj94iuMl0HexRcR3b+PrP3sFF9tnImls4iCy68ifvwYcoeNQHQAFXux6C6R+6zYLOWUfepTdP/t72w+INKRV4wSd+6ZVheuaRcSn9tJujWFKS5+1C1lonulNTMZS1kBpnwP9eFqnmwTHdX+qGgq/+/k+9m7bh1ta4+wKz2GFXcdE84nsqK1yjzKTNkPVvLanS8xybQPX11/PNKmHSLrsWRXwW6h6PZbCK3fQMahCAGSvtqAIB/dW4Bn7Ayik6dijpuxaeJwq9aJliT/ZA8Fnjpcsg9rWCXtEn340SpxHHjrB56XsAfF96gODN4c8L9myYO5S9zpJqtFd0m0WhzfXbM1lPdrxGOPRcZTcwEkc2NL7RCtO4l8MVaic6H4Hl0d4ph0HhD7p+a5cdtOzSNVJTCp/1lUvqZJMX/BTeSNI1RdfyWWNV4iYoUK3M3ic+1IbcExZRTF/3YxkhSn4HVRuSvQ6Kmt76smG41Q/JEPoprls2JeovvEmDZLZReSzYKzACBNKinOz/XHRA6j6OuvUnDNVdDrYfXRKcK5908UXbOPvlpH3/EgjuLFdJww0aNZl8b7xPdwqLmG+NEOCq4aR7LZjVogzje7W1TgEz4rSjyG65K5qJKKWWMgSVeK11+4sIuXn80wY1ITxVMTvLFTVH6VAfstb2WU5P52vLNKKbmijJ4u8bdt7eJcLV1rJbEjhMNbTMmrDrrErHF8h8X3mrGWUjb7EkwWK04pn7hPlC/bIs6XfGsx7eEY4y1LkLZARLNOxyrE95wo9AHzOW0/Np3ylmb/idv/kVRpESPKyyCwOjyMv+h2MskYFoxRWg8Hw60BZa0o0xc6BZPDgWe2fgXq0/DMmz+8vpSXU3TTjajpjG6cgSRJFN50I+FNm4eUOy3rWjAF2WHVlQWQzSYqL55A29ojqGlj2WFl8ytZ9I0VhJuD+MbqF2iUZJm8C5YZIQdGkiSKr7puWKRjNpd+3MUIBkekvR57XjEWp1dfGLBWFWMbU2F8/ikKhddea5iFOt0VwFLiMySb6QmQCQaw1dQYko9s2IFr0SzDTLLZSARUFZPXGAOuEkvgWjxnWGuTu9J7doD3IDD73FhKjJdCSMUC5JWPN9a2zUHZrJWG21ayaUpHLzRc/HME7z6MKC9DwOHLKQz/zIDytwvDotWW5WErMLZRo8hajCkMstWCd+mSs4ijzgX3wimGF0OA4gU1jLp6GtmEsRgigJqLRpOMGJcH48qmOc83rHZH8I/B6imgYr5xl619XLW+0ABIZjOeucbcYwDWikLK/+0aQ7Imn5uyT3/KMAN18vAJCm65Wl/wFNSsQv4q47W2zPleCj54lWF5gIV3vc+wbP7KGcNqe9Sc92O26gcmvxWYzDZqZw7vXkfw7sKI2jkCYHgU/kahJPvjUIy2bxtdgW20fhE/NasQOZmza0/8zBIcZcOrP2NxGbPujODdDZu3EFdZ7TvdjTOQbVasFcZq4EhmM9Yy43T/Jf95O5aKXFFJxQBviznPi2fR8Cr1vptgc+Vjshiv0faex0jMi4ARy8sgiJZJmGy53bZZE79gGmCKSeaJH+Wk1gugsTZkfOLoKdwtnu+ZLZ4f/bjoq225QLSoZO0anpiYaCFwdGn4SQLiYpAsEq0nsqf/5lJx0Q+t5ovWCq0xoq2l3w2T8Yfw/+x7XPjQR88wgXZGRQWjb49IblI1t1U4nlskUrPfOr4/+ysYUFi5PMjSx+5Astmp/uACehJih9ojOVdC5EAz9lFFhHr7AwVHTdBkP2ligRx5mhTgbaK5298uuinyRZoYuEwMGGhPaWIjNPHLpTvFj1HfRPE9WaLie5aT4nvzT+zfodqCGurzC0SXY16jpjzACTEex5QSA1mTBeI4yNg1cSRfFOn8ax8Wg7mDs8QqzuaY2PfW68RAlYKDYv/KNvXfe880cclyt4rPxdku9i2l0WnznxN38qEaUX7VbWKG4S5/lXDc+rzo4omXiL+f7hLbNxeI2SkzqsSBcsHs/iCb3x5eJpxr0wRufG7eeiCXpfTM9w6Rqv6wcL7KHhCOZ83tJ8pL9MVQvOIYbuzVlIGwiXMgPlbzpYuKz94sa3hisuKzHFiaJLVTXBilInGMpjTrkF8W1zmHZrqeVUblanG+mXaI99Z8mdg3e6e4LsoaXVA7jsya5SAwKdd/JfHPC+AdiXkRMWJ5GYFhpNu6CDxtjAnUnO/FUeKmd1ervjC5VMrDP3gBRUugNgjyfDL2Eg/h47k0SpNtcD08tKOe1nuMc57098nYTM+Go7RvNM5qPIJ/TSgG+YeGC1VV2feqPn/Paex9qYMD64yXHwg19FH/2H7D8rGdxrhSTiMdSw+L8v98Qs1kiexrfKe7MYJ/AkaUl0GgZrNkE8YIuLKpBHsf+qbxtlXVcE2Q3t4j1B9/wZBsJuAnEzWQkjwAqeZWspEoalo/BsTk8xJ+eSNq2lhF5qrLJtLyorGFUJJl0uEEvRuN06oXzBlF344mXbmyD76P2JE24geNEwNGdtfT/uunDcnKLgehxoNE2k4Ybt8oYp1NJIPGP2wjMAZVVUiEjD/Xni2NhI4aVxgSx4yPhR3Pd3FgvTGOnVggxTPfPYSSNaYsKJks27+9zhDvDECmN0jfw2sNyUJuLdv2822GY8LSQWMcMmfkA/5hKUbt979KssV4WY/sMGszveMYcRmdwYjbaBDU/+F71C7/EK5RkwmJGcEU7e1fCHqmSCTbe1HNEr2FAbwx0TzqbdJUIw6coHnzk8hmCxOv+iJZmzjpR70oKgbNl9bQ+rsnSJeNxj15Oimf2J4p2X997PAhwpu24J09H++c+cgWK7FyccRmnf3XZ3r9hP76LKmQn9pr7sBeWEqstD+/UR6jUYQ8Vmx1lSQOH8M5cwLzx4g1kbbWiyb1S6528ts/NTDZ2ojVaabF7hPOr68W3ROWpUtoeGIjiUkLAWjqFE2/raNFs/eyC/ez4e7DLPl8Tu7vR8TAynlV/YpN6f8uZtP/PshVN12B1W3hlWfEbKwZF4lK097WKUS2PY1/dTv22lqkqaIia2kZyM9iwnfrctpeXk3lBz4OQPaoOA7U2eIimfd4BJu7P4stmSdOxfQp70M85afjhXvJv+1abKOrkV0OJJMJU0rk/bH39VusLJEsqVSEdCqGy11CtEyM7+maLR4nunqRLVasvlx/rBp+wMID/feuqgrJGhvSALO+t1EcY30LxTgOS1Qcs90zRDdUskjjEkuJ/RtYGVpb7qL3lMdKzWSI7t2LfChO4az+IFIt/X9wrISqqnS/+CyusRPwukXX5YPbxcB1KSmT7uqh4wdrKLvrS1jqNJZBzfbP2msicnAfifpjeAvHYS7TpuiK9AO/2LGIhu/+Cue0OkpS4hiwm8QNhVNOsuvlNjLJLFa7iRKXOD8PhkX+lETGzNF7txM40kPRgjoONQwdS2Z1p+h5ci3ZviBmW5bqclG5a3tVDHZ+Ze8kQmvfILyhh8TeSUhW8eXk7+m/n5T3VI2oF56h6ppbsWrKbZjPQWKtqirtTz5O1Y2fwL5MVEhCu8W4InPaTHjrYXqe2kzFndefVb7D2iu6ocwRSIcDBPdtoWTxpSTmibEBtvViGrq3IUU2m8Jkyo1NVcr9N5v6J+7/3w4F5D2kwIxYXgZBNhkTFujBIEkSPaufJhMO4X/jVV15R34ZqViQTNKYVSe8dydKPEbPC8/qyrrnzcPkdNH93BOEthsobWCzkgr2kQ71kY3rW2xURcE5dwrhdZuJbtYvD2D3WKhdUMyhtdqAkHPDOXM86Y5e+h59WZdEDqB6ZgHth4KGKksXTS1h9IWj2PyrXaiKqrubS3d2IjuddNz9JzJBfbZf14LJZAMR+h57lVT70Du/TCDEwTW/oX7DAyRCQ7OHeifMYNQNd+B/8Dm6f/0AwWf1x5iiZDm05+80HntJV7Z3++u0r3mM+ru/T8crz5BNDF0KQVGyHHj+ZzRuepRg2xFUnQKmipKl+fDLdJ7cRriviWxm8EBTVVEI79hB9+7X6NjyIq1vPEmkdWhK9kwwSN8LL9D0f/9H7zPPkDdx1pDyAP43XyOw6XUshSW6skoiQfcf7kOJxw2lHGcTCbqffQI1a8w62fvIa2T9YZS4sZzG2ZeXYDLL3P6rqbqymXiaeGcYk8OCZNJf6pONHYRf240SS6AacN8mjjYQeHQ1Jo8xQsxERzOhw3vJxI0VIw0d3E3k+EFDhHmpLj/tv34KANmpT/yoqiptax9DSRq3vDSdeM2w7AjOP0aUl0FgdngMZ8g4x08EVcU1aYqurNnuomr+Vcg6NW1Owzt3ESa3FyVjLLXXXl2DZDbjf+MVlMzQC6jJ7aLmqo8hmcxkjCgvmSzhV7YQ332EVJsxE/qM949i37NNdNfrKwCJw40oiRSBJ141xMhrtpmomOLj5PZeYn797It5n55Oy9YO1n93K6meocsVWCsqcvTxqko2GNBtO9MbAkmi75FXSJ0cmuFTiSZQsxli/nZObn+acFfDkPL2kko8Fy8meayR4LOvkKwf2lUmyyYmTvsA6XRMV7nImzwb2WxBzWbp2/EGjX/7NeGWwavUKUqaVDRIX+Nuuo5sxN+kQw2vqrTXv0nzobWE+04OKSvJMtF9+2h78xm6d7+Go6Qad+XYQeUhZ3EJbdxINhym6IYbMDuG/pCG9uygZ82zYDJh8elz7MT3HSLjDyI57MhW/RIdvS+vJhMKnlXM8px9V1Vcs8dj8rmxj9FnnQU4usnP2Hk+6mYaYNh1WLD6HIy7dT5Vl+uXCJAsJuzjqnAvnEI2OvTmSlVVUieaQALZoPISOrwHUImd1K8RlIlF6Vzz5Kkf03+WZp8b9+xxuOeOx+TWZyMPHtxB5MRBXbnTSKdjNDe+Tio5PLf824nTAbv/6N97BSNuo0FQOf9KQ5YXANeEyfhfW4ezdgwYcKMXjp1HImCs2JjJbqfshg/R/uB9urKyxULhysvwzppH9wtPE965FfeyoankHaXVVFx4PZmY/m5Itloo/MS1tH/zd4YWZ4BQV5ymnb089/VdXHz3qCFlHZNH4148jdCaLWQDYcyFQ39cuuvDpOJZHvvP7XzgF/NBh6csk8jgyLdx6MnjFF10EFvx4MR/kslEyUduoe1XvyATCAJD84NYin3kXbaQ7j8+TbKpC0fVELLlRcy+8VviP8aHfp6e5fMxuV1EXt9Gzx8fpmrFnUPWRbLZvUydfStZJQ0MvpibHC7KL7sJk92JbLUhSdJZbiNB3mRl/MrbcBVWn5kfWlfOQMgmMxMXfhRP/ihD88kzdy5Kazc1l96KvWDoNOJkbxcdT92Dd8kSspEIrqlTQYcZ3jGqFtnpwlFda2hzYq2pQnbaKbj5Ol1ZVVGwV1QT9eVj9uorF5IkkQ1FcU6to/DGFRgx1hx8o5fJS/XJFSGnYHS+Xs+8H12No8QDQ+vIWCqKSHf0UvHVWzC57MDg8SmSJCE7HTjnz8R76bJB5Qb2Jd7WhGS2EGttxDFvaM6XZHc7JrsDVNWQ5UXNKkR31zP6t19AdthItQwhm8kQbjgEknx2yuRg/YkHKC6dSioZwmrTLytxXjDiNhIworwMghLvJGTZhMmfJd0lLrpJb/+iJ6fBnl+Gb+5iTKqZwgOiBaD+wxpq9cMWQKJg5WUkLBLxMnE0qfLZuztH7Wh8i08tEBrVOesQj13jQtiR8ay4lkRzN1qDjTadMTIvjnXedNKdvURK49gd/eZrVdWknUYtWEtqybv8ItREipMhjXLhF2MV/vbyUlKRMajsp7NV5tWdomXqfy94Sji+r3kR5XcuZl97K3lqBxlbpfj7ijhcd9jmEUgdIxnuY3toNMumiXErVln8GnQ7ipnwycX03fUSkZb9eCf2K3Z79tQJsqovCz4rRV/8GIlDx8lGxfdijYjPJhGz4Fy8iPxgmuTxk5SaxffSuaj/2UhA5zLRIuJs0JR5KBcX7Mq1DmAuTJ1LItJDwNyLo7hfQ8ra+8do6dbcfVvJpVu7W8XfUixi312tdnI5/bnddusKMVAkmT/w3i0UqdUQAsi1m3aJYzxWLB5ny8cSGHi+WuxP4c4B8TPqBIo+OAHZYj0np+HAIZBVUhQvvxzP5BmoShYpKJHRGAFSlRoK/Ibt5F0whZKPrES2B4k3i64g7fyI7ngT70Wz8a6oAxKkwxp+oIFzxCSRX9GK/eIaJn52IpLceFY68q5ucUxH9r6MdcJo0gkzUoeojF43V6z0vjE8hn1vBJhxx0xaUs4zVACnYTOL493cchKTw4KrygfAkomixWN3h9iXwM4EstNDNlxANgwdW8WPtHOFuDOL3r+N/KuuxOHNjYfyN8U35h9QcSNjUSm57mbaHvozBZdejkuThJjWvDdf3mjakynG33Qn5qiZzItijItDowe3HTiBffxE0n05OcWtHfMD56NE3sx5WAoL8U6eiWIDtUUc81GNIazyWAWTp37gVGOQPvVosvoG3xGcJ4y4jQaBJEmYzMaIzCRJonDZxcNqX7YMjyQt/30XDEsewF5drC90CpZS4yUQ8i67EGt1pb4gOfdL4XXXocSNxfjIZhOT/vcqZAM+ekmWqPvCJUgmGdlqTA8vnlnBhX+6jmw0TjY8dHwHgKW0GPeSebpyp+FdtQzHHP14hH8EdncRjpIhTDv/wpDNVsNzw15ehWdybgdv1Eqaf/l8ij98IbLdYAkKqwXvBcZLbZQsqaPm+hlnuI30kDjYgGPSaEOyPcdD2L1WvKXGWGc7Xq+nbNkYfcFTSDY2Ya0zVqogE0kgO53YRxvruyTLWAuKqPnMvyNb9N1vkiQz8aNfxerJN+Rij27Zjnue8ffkHjORkhWXYy/RJ8R8t2DEbSRiRHl5myDbzi8T5HDo/s83JJMJ51zjVN/uBfNxTp1iOOXRmu8if4GxRdFZW0z59fOQLcafj7sqj4qv34ESMxasp1e/6az2F+sHjY7gnYFkkjE5jM/VgptWYi4wVjcJwFmeh7PcWP0eVVXxXb0Cc5mxjcOJDR2MXmKckTdwoIPSpcaVF2t1JZ5l+pW5AcxuO2WfvGPYNdqGI280LhAg79KV2CeM0xf8V8YIw66AEbfRCN4ShrMISZJE4bXX5pQXg9cNp/3KDy9GTSsgOCeGhsnlwOTSD+wbwQjOFyRJwv2+mYblE+E0Y5cbC+wFmPejq4UK43qwlhsv/vpug2OCsQKOI3jvYER5GQTRChMmW243n9JspFzt/b7d0BhxdTh5hWiOLtghnteEbeA9Lp6PadaPVJWYQmlrEtsfSJutZFIk1wSFWi/qEo11QROXYjlsB1U5Y3ZXpvf7zdNpjTUjoZLp6cVSknNHdbSJMS/muCbWYQCnjGSxYtFwO3xrs1gYze4WHcjvHyuygj62M2cW9j+yGvvE0bjmi66TLW3ii7pl7FbheF1j/wI3v7ZRODdpqkhp/3ijaFn6ysQXhePfN4lBiic7xd1z1xzRNO6qDQrHyps+hkLRTnFchKs1XyHNDqpoT39sh0lTOiBaLloa8k6IcSCdc0U3hFN8FFiDYizFwPgaAN9eMYCh+9NicHPdM2IweOyEqDS2rhT7W7BbM+4G3Kui8TjY+8QHYQtqOGc0F6S6xDGiFGuCwhTxOWf6xDiUzy0TGabvPybWDkpk+ie4kspgVaOYBrioelp9grxk7b/3ymmdqKp6RnH3yaJbs+ITFxEHjp1KeLHLSSEF2iSLMSeH9tUKx5aQplSIhpJ/1ETxxbfki/M7vUuMO1FrxLWl/ToNX09z/3vOFIhjSFLFhTDlFa+1d+eegZrNIplMZ/H1pEo00c2aWCVJFtsr2CuOKUlzubasi2eOGN8TbBHv/XSsopL4J5oyRgJ2BYy4jd7lUBWFwFPGqO2VTIYTL96LkjFeB7vzuUcJH9TnbIFcqnT7T3+JmjVG4a8qiiGOlNNIHG815Fpyzp5C3wNPGypOdxrxUBrFIDNw+6GgYUZSgOjJXlItxtlXR/DuwPmktM+mMhz87mrD7l5VVWl9ZAsYLEmR6I3l5A0icbyebFw/xut8Q81kDDN0q6pK37b157lH/zoYiXkRMaK8DAJVVQyl6IU2byLR3Kwrdxp9h7aRjoUNL5ySLBN+ZTNKXD8+w2x34iqrJdRkvDaJtbiUZIex+kOy1YKlpIRUqzHSuWTDSbrv/avhvnTevZrYPp18TsA2tgbH9An4HzVWZwnghZ8dJfD8ZkOyr//pGO33Gq+FFDvZS/dvHjFE7JVs70NJG1P+AMP8PiMYHtRMhuCbbwzrmtjegyQi+h/ebCrDga8/Q7InYigWS81k6P3To4QPtBoik4u2hVj/mSdPpTPrI3GikZ6/P4JsN+YmDR00Nr8hp2BENu0xLB95cxuZ3j59QSDZ2Yp/1ybDbQNkgyFD6/ZpvFtqMhnCSMyLgBG30SA48ufvUDplORUzLyaqSawJjulfYMwtProfeQjfsgvwzJpLwSGtrHgcPxIksPExHKNGk794OSZNEk7aoxldSRlLSRHppl6sNVUkCzS0135xsSv98Gh61m+i/LpcYF/2OdEPpXVbpRfm43/qAMrUnC06GehfEK0e0YLjqg0SmVkO/kN4lnlxWsUPa2+HyFhqr64l091DqqEVS0kxJXMCwvkyV1g4fn3pMnqf2AbuOkxuFy+ZJwrni8v6ry/47CJOfuE33PiJODXTcgGV+zUvyjKg9Oyln6nlO1dvxjZ5PpLZTKxEdJ8difYHQk79yiU8c8daOp/cRsFVC1FVle8cWiXIZ7YMtDNXYalsIvjMa/iuW5HjD9F8gzLbfblntG4DkaMHKPjM1djGjUKJJjB5nDj3ih+iwIRTlbgfeQw1myXvw5ejJpKYy4qRJImy18QfaL6s/yNpOZ4k2d2OqyYXwOhuE8dUqLbflaJkM0ihOCZb/4ctpYlP7Zsk9s3enRaye1o/KbqJCveLv9c9qz8PVlWyeDo06f0nxQ984pQHLtndQTYewza+P3hbO35TeafcC4pC9NB+fO0m8sv6x406UxxjmS4naiZD9x//iqWilA/OFV2Lj70kBqymCzIoyRSBh58l0+Pnbxd9RDg/t1LcuEipFK9+bR19W1uZcOMkCp2iy8xdJ1oL3Zkg2772AtHtLdR8aTk+W/+C8H+NVwiyXmuS0Ik+Nnz5ORI9UVKuGbQf7B+3ik+cj8Vje4kcaaP5jw/hmlRBqlxUvJwF4uLTsamCVG83Xc9so+rjn0EpEJXsVLnYvqnDRnjHduKHjuCtm499rGhlTQ7kF0pLqOkMwedfwZxfRLZCzPJR7JqyJwvDhO7dSDrQizK2iXRUk12n8aI6W02o2SzNjz7GqA/cQeF+8V6Dmvh/SwQyiSjR7ibyqiehaufrS6KbyHmqUns6GcVic1Gy/ZRcWqWREbwTGLG8DIJsKo7V5dOVsxQUomYydD36IKkufeI5S14ekUP76dvwiqEdQrL+JCgq/kefJdOlz4CXv2AMoX3NpHojKCn9XaJtVCnJkx3EjxqzHjknVRM91EyqO6grmzjRgGy30/7LXxly8VjKS0kcP0HXb+7VlTU5bdz4tXH87X+OkE3rP0dvsQ3Xkvl0/PA3xHYO7SYzOyxUf+WD9D2/ld6nNxLeqM/EWfTxKwm9sp2ePz5Fpm9wV1nJyispveQaev74OD2/fYSun/11yFIIJdfdhK2igo7v/JLu3/+V0IuvDtmP+JFjtDx1Pycf+h1Nj99Dsm9od5aSTnH4oR9x/Knf0LXrFeK97bq70SMb76d++2OEexp1ZZVshkjbCTq3raH+6d8RahzaKqiqKtHGYzQ9/CeaHvw9tpKhA1Sz8Tj+Da/R+NPv0LvuBfKKdRh5s1m67/kb8X0HDaX7p5pa6fj2L4m8vhXX++bqygN4qrw4ihwUTS7SlU0F4iS6oyBLFM0dmggRIJvOkomlsBe7sJQOnXmUjadoe+ANsrEkztH6wbhqNkvn4w8adgune3vpeeIJJLN+6jNAZNNWsoEgWX/AQF8Ugq/nYt6iB/WLrwJ0vfo8qZ4OfcFTaNu2mlRkcCI+oT+qQuuBl/G3GmflfdsxYnkRMKK8DAKz3Y2zQD+y35yfj60qxxwbPahfdt41YQrOurFkI2GS7UPQQJ6CqSifZFMryfqTmAv06cwT7QHsZXns/be/kOrTZ83teWgd2WCU3gf13SRqViG0+QjhbUfpfvRNXXlbzSiQZdRMBnRo6gGURBI1nSZ1stnQAjr9wiJKapysu6+FE7uGVqYySYV0cytZf4DEMX3XlMnnIv+yuXTdt5beJ97U/Uir6Qwmr4vwazuJ7Tw8pKxrzATK7rqN+MF6kkdP0vOHx1AHoUCXzGbyl6/EfcFi0u2dBJ58kfAbg8c62EbXYi/LfQSjDUdoevgPdB3bPGj72UQUJZsm0laP/9gugif2kokM/SwTkV5CXcfpPLGZUPfQ1ZM7D79O/ZO/pmPri3jrppI3emgOnMiJQzQ99Aei9YcoveTaHMvqUH1pbqRnzXNkggFKrr1ZN7021dJOujX3gbOOMsBVJMtk/UFklxPnLP3yH+lYmpPrGll191VULtLn4om2BJBMEgt/fNUZMrmh0LWlmYpldSz+4SpdhmCTw4rZbaPkqjm4J+vfq/+NV0g0NxqK01EzWbofeQQ1mTRUNkFNp4lszpkrMgaUFyWRovjmZXjmjsNarr/uhQ7toW/La5h0ykOcRrS7iZ7Dm1HS+vGBmXiEw+vvoeXAWgqq9MfA+cJIzIuIEbfRICiesBB7nj6ngmyxUnrzh7GVlxM5sB8qVw4pb3I4qbzlk3Q9/ziRIwdxLRqaMt+c58W9eA7xA0dzfCM6IRC2Ig8pf4xUb4SsgWJv+VcsIvTyDsyF+twUkknGNbWGwKt7Mbn0uTJki4XiD3+Itp//wlAArH1sHYUfvoHe+x8m4w9Ctf6iuPDaMv70hf2Uj3Vx5V8nDypndZgo/szH6LnvIZJHT6Cqi4dMx5YkCee0Wuyjy0mcaCe6/yTuabWDypsLvBTcfDGdv3yY6PbDeCctH7LfsttJ0SdvIL73KPF9x+ha/zylK64aVN570VJso0eROFJPdPNO/BV55Feefb+yxULRwgspWXrZGbI3rdtoIKyeAsoXrMI7aiJWT44NNjOEvqCqKlMu+CwWW/9HYqjSkg5fOTZfCXljplM8fekQkjmEj+7DXlKB2ZOHZ8L0IWUzwQA9Lz6DZ8YcTA4njupa6Bla6ZWdDtRUiqLbP4K5cGiafVVRCDz2At7LlmOtq0ayWDjNKjwY9v15D2OvGoe7/BQF6xAxstlEmr0/e53ZX72IgmnlZJSh85pjXRGOP7aPC++9AUeRC7YNKU7sRCeRI+1M/cMdyBYzXUOEsqiqiq2yCpPLjbXYAJeMLOFdvBhQsVYaIEw0m8m7bCXRrTtxztQncTS57Jhcdsz5bpzjKomcHFxWVVXUTDqX0Zinr+ioqkLb1ucB1VBygySbMVns5FdOwWw1RhA4gvOP95TyUltby8mT4ij/r//6L77//e8Puy3vwveRcuYWf7tmdR5YyyXtzn3o8pevxFpaTuDCHkwDqprW/lC8tnOhBzAxavGNRFuO49B4gjIucQHLVqTIv24x2WAfprwUlsNDT57kq7WMWnorx5/4NdG1HryfEH/AZxf93OHmSlxLZiF5vKRiVoEePdMpfsWcmxw4lKX483dir/cRe0mMcVHmi21PqOiE2eAMzKd8UjNNx8WPUatD/HjIcRnvjPlkLupFaQ+w6DLRcrRmxzTxXsbFKHSnsTlkmg9GUANhXIX9z96jCSiyFqcp//+upfve52k6nsVe0b/Q7WmqEWS/+L61MAGyl0xmw988rH1sL6q3P33aPENj1Wp24iyZQeXny+j6619JW6LI9v6+pCrFRdLU7sFVOR1X5XRYBWk6iHjDZ3axSkKcmlVr7MAEcE2AmdC2OEvngA1y/oEBKbOp04pFTmnR1h6KCd8mE7Ud83N0/6Gcm7FnmiaNVdBrJbJODwPDx31HNenJUwaM4SmTqSnPx1ZQdoZJv3uWuLOv2ND/bFyuxSSuKSebiGIJ5S5wHuu/gbYr+7V3pchE2eIr8dRNRs2kkfsg4xCtEXG/GK8TfuwZChZeQH71bOiBR9aJMS6+Kf3BpB0Pv4mckiiad2nOytEFX1v2hCD/s2MXnfn/ZLufhpcbufjvHyCSySn3V5eJwawD47K2/GYX0piJNNkW0HQUvrLkeY2sqBQ89d2tjLt5ek5xAVST+NydR8U4rpOPbSZ/4WVEducsyFKpqHiJ5T8ksh09eCfMoPSCq5HikM4Td0rauKzePbvxLlyEe1aOlNHzqBgslbo6OuBaF7HDnTi9leTJ1aRsmrTqhPjeEgd9JOtl1LiXxEEfNevFvgTGihubLrcN76y5FFxwCRkH9E4Rx3BeQ/8YUlWFaRM+SF/hUaySG09Tilip+OzMA6a3GTulH72VTDRC8FQpDPupwvHZ1D/ReTGSKi3gPaW8AHzrW9/ijjvuOHPsdr+1IlqyaXj0/QCuiZMxOcP6gpwiqKoeN+TO7DQsZYX4rhl6Jy/0o7yOsvmXGjKJAuRdvZLEwXp9QXLZTzWz308iPNR+W8ToD89FSaZP1cPRR/5ll5INhQB9t9ekBV6+8chkfnT7URo3djDlqtoh5SVZpvi2KzGbjWU8mMwyy2+tYYdrwRnOiaFgLS2l/LOfJRONCcqLHsxF+jvGgXg3MS7rwV5onFjN5S4lZTIju/QtgbLNimd0zowvGSgpoKoq9ooq8uYaY5HNWzAO+6iVhqvLtz+wnnEfmonFrW+V7Dse4NjzDfi++h+G2m7b1UXgcDdzv3qhIflYSyOpvh68041T5udNnYuSSRsuteCeNRvHeOPkcJLJhL3ceFkLJZlAthmbQ+7J03BNmmqI3FKSZCxWJ6UVMw33BcDseocKMp7C2+H2GXEbvYvh8XgoK/vXZYocDI5JtcOSL5lzEeloED0zN4ClpBBTnkdX7jS8pWNw5JXoebDOQDbLyGbjlOySLGP2+YAhbMUDUDHawTcfncwjTxrrkSRJmA2mmZ6GOd9nWNbkdILn/JaLGMHwIUkS+YuMbwIctSVkgsZiKLKxJOneCKOvW2KwM7Dsaws54DLmhoj7k8y4c6nhMhi2wmIqbrxlWEquye7ANEQFci1c06bpCw1A4WJjitdpWItLwaDiCMNj5R7Bvz7ecwG7P/jBDygsLGTmzJl85zvfIZUa2vqQTCYJhULC33sBkixj9Rjfzcu24VmaLHbjys7bDVVR8D/1Akq2fxvhLbQw6wNDZ5qMYATnCyanjXHf/wgmqzFloWCMj1GLjRcFHHNhNaXz9bORzvTH4cJWZqx46rsVrklTcE2Y9E53492DkWwjAe8py8sXv/hFZs+eTX5+Plu3buWuu+6ioaGBu+++e9Brvve97/HNb37zrH93diuYLecOMk15+3U+LV25+TXxo960SnNe4wkJjhctI+4GcfHzPCVaCCKa9Sit4eSIazZO7ufFdM3stSIhnZaSP9PR3/95y8S01r0t4kISrRX7LnWL1oajiIF/kobCe3xdu3B8JCXenKIhcygc1Z/W6G+v57++fRHuCf3R/+WLxXt7qje3M0w2tGGrq2BcWb+r6+Bx8be8pRHh+Jc7xSrecpH4nNLd4nupmyn+dl9M3FEndhWgZDLEjh/GPXEqabe4ilgaxfaSGk6Nzvnis5j4MzH6summ/vuJ1mnGrWbBsvaIY0w1iW1bNGPUe0B8z71TxOsDReL12jEe03iNtOUHGj6sid3QJGvFS/rnW8kropId12Qjd18ukjlKAVE+WSLei71DvJfoDrHMQ1bznh7rHDpderJHHNNOWdw8NUTE9m3e/nG1ulu0ZJTaRRf0qqJ9wvEOrxinNW2OmEW35Ujdmf+P7ztC2WxxzKczGsp87bCJiZ+HeLlmIJWIzzrkFxef0vz+jWDLaPE92BvFhVNTLQCzxp3esVBT5sGnmT8hTXkADUtEpFzcp7dfJl5fuEGU908TH0bxNrH9jhW5H1Di/0QSyZGYFwHvesvLN77xDSRJGvJv+/ZcCt6Xv/xlli9fzvTp07n99tv5/e9/zz333ENvb++g7d91110Eg8Ezf83DYMv9V0foYBvxI/+a91t0xWyCWzfqyqnZLF2/e5Lwm8ZKIADEj7WdF+ZNNZ2iZ81zhPbufNvbHsH5h6qqpMLGKpGfRialDGssZRJv/8cwWd9EcPXwaPaHO/6VRPJdwVY7HHbdERjDb3/7W+rq6rDb7cyZM4c33hicmfpjH/vYOb/RU6b0bzLvu+++c8okEsObW+965eXf/u3fOHTo0JB/U6eeO/Vu4cKFABw/fnzQ9m02G16vV/gbLjpfe46kQXKkTDRMpOGI4WDa01CyBuuBKArhPbtQdNxlAOlwgq77XzK86KjZDOlIiGxCP8o4G44MezELPLfW8HW+heNJdraR9g+umEIuSLD0SzfR+9cXiTbrE1Kpikr7fWsJPvmKoT6rqkrfY8+Q7NYP1DY5nFR85HZ61jxLokGfa2YE5xeJo/VkYhF9QUBJJun+6wOkw8bmrZJV2ftME0//utlQLIaSSHHsrzs48bAxqv1j24OkTuqX9VBiCXr+8BCS2biRPROLENy/3bB8qq2bvr+9YDjmJNnQTCasT3IJoKSM1y9TVZXQrq36gtrr0pl3heKlB+lt+hsOHn74Yb70pS/x1a9+lV27drF06VJWrVpFU9O5iQN/8Ytf0N7efuavubmZgoICbrzxRkHO6/UKcu3t7diHkeAA/wJuo6KiIoqK9Jkqz4Vdu3YBUF5uPNvhNDp2rqWgYgp5hXU4G8UPU+N1vjP/r4ZiZNMJuja8SP78pZguFf3Y2bj4iC0NYVpX/x1XzTiqrvwIzjbRdBurFCdRds8JWveuoXjMPIpGzz2r+qm2umrinnV0bVtL3uhp1FxxK8GFojbrb+h35ajFJSjJrQS2NmOfWIdkMmEZYFXf/proJkod3Uvnmy/gLK+l8tKbcTZraN2L+vve98SzkM2Qt/IiJLMJa2kpaqG4q4xnRFOwKaASvP9ZnHXjyJuzkHWbRTP63NmiEjrhVivZ+B/42Odz93R/x/uE8y7LqQ9NGRR8bhGHvv0cN/z5Esw2E1aNu+5QZ/9zKfv3D9H69XtwltgoWDUXVVXxucTnOGt8/4djf1uCDZ9/gpI7bwdZwlyYj5TQxD7UnOpLjZfCz3+Q+N1/5FN/nUXxqJyp/S+NCwXx7gO5yt1KOo2SSJA82oq9vAqzO+fWa79CdAEMNPmXv6zQfXInxTWzkWQToRpxjzLQ1RnYu43QqWP3pKmY7A6SNeIHI2sT3YGZaBiTy33mY6XNYIjViu/Z3pb7gXQwQPTIAaxjFghkclJQHAeeFrHB+AC3lH/C4Mtvuq8Xdf9xPPPHn+lbrFVcELOuXM2y0NrXiO3ah+vzXyY9wJb+gUtE/8Hjx2eSbOmm/TcPIzusHI9PgQGJeZdMERlX17WPI7C9gZP3rCd+spcL//4hnh5QyXpJoUjql0lmaXl2H81/20YmpVLxw/9gz4mcy/GL88TaXd9+/f25WkKvbSL47C7G/ukaJEv/u+qKi8HFV07bw5qvbiTT3UfNdBehBp9w3tanSU+uyZLxB+i670/kXXUpFrPGtTJBpF0IRJxEtx+i41ePU3jzSrKzxXWy7UB/4sTpKs+xAwfpe/xp8j/+FaQBU8rdrnnnhRKqqtC1YQ3lS69C433DrTEYByaoRA8fInR4L+4lC5BTGsoJTVy0ud2WY3Peu5tESzOOC94vnC/TuJEilbn2sqkE2XgMR0uO5iGbMF6n7B/GO+A2+ulPf8ptt93G7bffDsDPf/5zXnrpJX73u9/xve997yz5vLw88vL6x/tTTz2F3+/n4x//uCAnSdI/nFjzrre8GMWmTZv42c9+xu7du2loaOCRRx7hU5/6FO9///sZNWpoIrhzobV+Pal4QFdOVRRCB3cTPrzXECtstOkYmViYaPPg1qCBSMWChDuPk4wYS+21FZSAomAykGIoSRJ5V19I4OEXCDw5NMOuqqokuttJ9nYSOr4fVYcxt/gDN2POL6D917+m6/6/DEmBDzn23kw4SHjfLqL1R3T7DrDqA/mseyJAOqlvKq68eAIlEwvY8NOdZNMK6hDVe01uB7Vf/zDdT26k5+lNBNcPzZw89fpx5F1zMZ0//iNdP7tHtxSCfXwtV//7GH7/mX3EgkM/l3RHB60/+QkdzzxM4+9/ROSYPj25v/0Q9dsepnH3M7qy9rIqwnu20/n0w7Q9cLfuTjdy4jAdLzzGid98l47VjxE+sh8lObi5V81miRzaT+sDd9Pw029jcnuGZMGN7tnHkVfupm3/OsJdJ3QtjonWZrqffYKTP/keTb/6MdZS35AWACUWp/uP9xN4+gWcs4cmwQNIdwVo/cGDpFq68SzWJ1fLxlK0PbaN2IluSq+Ygati6JTvbCpD+5pDpPwx8q5eick9ePaRkkrT9+dH8P/9KRxTJ+ZIK4eCCpOvGUPBmDyKJw5NyAeQ7uqh48e/Jd3RhX1sna58eMNe2n/yEGo8iWu+fmBteONmuv74Z2y1NYasNOETBwnV67OWn0bglXWke4xROCSaTtL6u1/R+dADeObMG1JWVVWirSdoWfMg9Q/9wtDaej7wdjLsapNUksmz530qlWLHjh1ccsklwr9fcsklbNyo77IHuOeee7jooouoqRHjsyKRCDU1NVRVVXHllVeeMTQMB+8Z5cVms/Hwww+zYsUKJk+ezP/+7/9yxx138OCDD76l9ly+SvJLJ+rKmV1uSi7KMaMaSUssnLucgjnLyERChlxHRXWzqZh2MamovssDIG/sdCyefGwF+iyZqqoS332Y1Mk2kkcah5SVJIniRZdQuvQKsokYsTYdeZMJ+5gxSLJMuqODvqef1pGXKbzgMiz5BSTbjMXhFJVbmDDTwZsvhVGGUEZOY+l/zKFtVxdrvvomfXvbh5Q1F7gpunYxHfeupfvRN4ZUdgCs1RWQyZDp6Ca0+lXdvsy/qpTZq0r40xcP8Mr9zYOarW3V1VR87nOomTTZaITWv99N5wtPDMkM6vCUMGr6FUSD7XTWD12V115SjnvydExOF/GmBtoevA81PbjCENi7lXSgj7S/l8jxQ8ROHifZObjLVE0k6XnlBaJHD+KdNQ/P5KEVBiUWJ9h6iL6Te4j2tpBNxYeUz0bCBLdsJO3vpeyDt2Kv1an3Ew6TaspZzVxzZgwpCyC77ZBVsI+vwrNYnxo+sL2BRJuf4pWTqfrw0Hwyqqpy4v4tmGxmqm+YhWflwqHl02mygRDIMo45+mnKkizR8FoLk68ew5yPD84+fRqp5laygSDmkmJMXv1sQktZAWafB8f0MViKfEPKZoJBIpu3garimDBOt21VVena+jKpUK/uRgkg3nCCRGMDGb9fdxOppFL4X1tHsqkR9/SZ2MoGt8yrqkrLwTWcePTX+A9tp3LljZjs//osu9XV1WesJHl5eee0ovT09JDNZinV1NAqLS2lo0M/TKK9vZ0XXnjhjNXmNCZOnMh9993HM888w4MPPojdbmfJkiUcO3ZsWPfwrncbGcXs2bPZvHnz29ZezcTLMFuMcR7kzZhPcM82w37lsgveTyYcIBXoxerSd2lVTr+UnnpjvlxJNlE8azlWn76rTZIkCj5yFZnuPlIn9YNUJUmieP5KbIVlRJqOYR8zZkh55+RJVH/968QO7CeyfQex7ftxzh1892rx5VP1sc/Sct9vycaiUDD081dVlVUfKuC+H3bS1pCEm4cUR1VVPGVO6tc1k7a7KZw5eKqqJEk4x1fiGF9J/GgrfW8eo3Dp4IRclopSSv/7MwSff4Xwujdxz1+IpahwUHmAJTeWs/3ZTh7/Xj0TfU3kzag5p5yluJhx//UdVCWLmk6jpNOo4cHflcNbQqW3hMqJF5BNJ4io6pA7Xd/8JeTNW0za30v8ZAPxA8dxzjy34l51zUcJNRzA7MnDVlaJJElkh9iI+h9+DpPThXPsREpWXTO44CnYx41h6pX/jjO/f14MpkqFdm7D/9rL5C+7ELMvH9f4iUBgyPbjB49iKS0m/7orc+UBdHgQu+5ejXvhZIpuXI7ssJEdIrTpxLqTnLx7F5O/fzO2Ui+y2cRgP6AoKqu/u59IfYZZP7gW2WbmeMvQ60e6qZVMbx/F//Yx7BPHMPiTOfUbGYXj65q56YFLDVk60u2duBfOxWGAvj+bSNP5m8cp/tTV2Efrp3xLZgsZfwDfVZdjnzAedEKNoi31JP1doCikwwEs+UPPJbPXi2PsWKzllWRjMWDw2MVERyvJlibcM2eTv/KSQeUgtw4o2TTWvEJ8E+fgqhw9pPx5xdvoNmpubhbiO222wXmptGNH1VlPTuO+++7D5/NxzTXXCP++cOHCM/GoAEuWLGH27Nn86le/4pe//KWBm8jhPaO8vN0ocFRjjuY0+JZLfcK5VP4AN8WpwZD/ketJqypFW8UPbmCa6BawhgBk6pZ+iHQ8gkUTt5ZxiIOid7oKSEjT59MrgVQrLobFL4i7gK4laeRxs0knUwTy0sh+MUXRVxcQjhO7Cqi69jZa7vs95gOp3E7z9K1NFleYUPGpAT5pPLZYNamEOJOsAbHvaa+KyWzBM2MWnhmzSLujMODRNbWKCta8i44CMHHJZWRT+7FWFQvntx0QF44djZV0/f4RogdP0mGv5X3Xil/R79WJVO5fP3k1dZ9dib/rJVpePYHnY1cj23LxFjaL+CFYVNEIFaAuuZAjzx5n25MHiY+df2bStnX7BHnJqmCpzKfok9eTvuYC3JGj5I/t32FKmsCQH667AiWRJF5ngqY3OfngbkpK+i0BsmZtSI0faIEwE+20MnAlk9MDyjoIFPnOU2OuH5Ea0c3mOySTC+UrIq+iiNDcOANflLdRlHfZJkMKaAJQCdWKna2o7ndx5n1oKqH0ZNRMhozNCiiY4hqDb36/FcmS7yHmsQnE01ln/05a8vbPJ3vROMreNw3JJCOZTKTJwgGf0HTW139tuqOL6CsvM++3H8JW7Aba6ImKcSJJtT/+5tALTSROdlPxievISGZIgMsnWoLi2Zx80ysN7Pjldj7+p8UU1PQAufiQjT2i++Wl9kmoikr9L14i1QXX/nIZ5lMp0bZa8Tlv9PdvDlKhJH1/eZTiz92EfXxOyU3GxFihppT4ga+/OwquKra8vgwAdbxorfOND/Tfd2eQyE83U/4/X8bkdQMqthax/T5//3ztefJJ7DXjsJfMgAhkI5C2iv131vQPvNbvrsE7cx5FC3LlFJIaL1Z0lDg/7G11FEevwOR0kfGYsGu8Gj1LxPnqaCom0xeg/KoPYTF5SeaLffEe7R9zocONFN12C7aaaiSzmQwKZVvF3++e2W9Fd025EkvPAqwFRSRP/fPpb4AS/ydnN71NccVGklOKioowmUxnWVm6urrOssZooaoq9957L7fccgtW69AcYrIsM2/evGFbXt4zbqN3GtayUqzlxgOQZLMVm0ffD30aw2GPlO22YTHmyjY7lbfckav+bPQap3Emzv7fMUaE5yr34q3RJ9iTZJniT12LpbqUbMBYWQZ3tY8lv7uB/AunE9p21MBvSEy8ehzFn70ZNWks08RSUkD+Qn3TuGy3UXDj1ZTd+Vky3X2kO3p0r/lXg2tcGZLJhDzEzu6tQnbYka0Wwyyy5uJCZv3o+lOKiz4aNrRT/LmbDFlU/cf7uPAXl1FQo9922h8FVWXiN6/DbDe2fzTZzRTeds0ZxcUIQgd24p0yy5CsZDFReOtNpxSXoaFmMmQjEQquHryQqBb5S1ZQsOIifcHT/ZFN5M9dgnfyTCxen7HfWLgMs1e/rETJrAuwj6kzbCmXZBlbcem/VEmOtwNWq5U5c+awdu1a4d/Xrl3L4sVDu0TXr1/P8ePHue2223R/R1VVdu/ePezEmhHlZQQAmJwuLPnGlal3C2S7jbL/7yOoGeNR/yariYpPXoZrkvFAbpPbiWw/P5T/ttG1lH/986COcFScT0gmE67aod0PA3H5dxZgrSjWFwRmfHIOeTU+Q7LWQjdj71yFbDVu+DZZTTin6yvEp6Gk0kSOHcSrU5n7TJ8K3DimTjAkK5nNlN5yy7AUUmtR8Zkq5+cL+fPf954uEfB2BuwaxZ133sndd9/Nvffey6FDh/jyl79MU1MTn/70p4EcT9pHP/rRs6675557WLBgwTlpTL75zW/y0ksvceLECXbv3s1tt93G7t27z7RpFCNuoxH8y8NSWkDhx6407Is9c13hO1fiQAvJYsZSXqIvOIIRGIBkkqn+wCcxOf71g0tHcArvQKr0zTffTG9vL9/61rdob29n6tSprF69+kz2UHt7+1mcL8FgkMcff5xf/OIX52wzEAjwyU9+ko6ODvLy8pg1axavv/468+fPH1bfJPVfgZ3nn4hQKEReXh6LL/0WZksuhqJ1mWgutPX2fyA9zUPvlgNjReOWrDEQ2DUca+a4+DpCdeLH2HtCPK+l9D6LB0NjW0uPEtNaLU1inEja09+go7P/4nTQjxqI4ijtrwqbWiy6apRsTj7d5Se67RDOpSuE8+agqCtnbZp7yRPdMqqieXYB8fpJM8XCjQ0vifEFH/5QP0+Goqjcs2vpmeNfvO8hQfb/235D/++qKmUFYrzPeF+XcPzaUTF49+ZpO4TjV9rE88kXxR18uEa8d8UtDgxzn+ZZucQXrXpEF5+1uX9XmyrVuP80ZS4kzbHtuDgGEjoU+iZN/IGWg0Mbv2AJa6jbNXNAWypBe68D+YRSGq9Axic2ZusS+2qeLgaVJY6Lfn55lEi4mO8Rjz9YI5K1/eGQyCU0o1ws03AiIFovvzHmyVw/LLlncG/HMuH83o5+U/n0kmZkU/+Y33RYDIhXFfE5ylbx3mvKxcUkoeFR6ujwCce2Jk3phDJx3EhJcf55ajTPcq/o2k2NEgdG5dP9Yzg4WnwvGY1OpR1ztl5R3hoQ5VWNByflE48L94tjSNGUwAiPEo+Ld2vKccwTn51DnP6UPngAgIyaYl3wrwSDwbdEcGoEp79JU+/4LibrP5amnU0l2P+nr5zX/v6zMOI2ehdDyaRpf+JvhimvQ531dL8wdEqyFlmDlMwpfw8tL/zdUNqiyesk+OIWEofrdWVPQ0kOj148tv8g0ZaAYfk/37aZdFuXviDQ+fOHiRwdOpV6IFRVJREaHmPyCN490OMgeqtItPTys/9uZwhamzNI94Wof+qwvuBbhJo17pI83/tZ9V/cPZpNG2f9fTvxTriN3s0YUV4GQTJhjL76NIYz4bOJobkrTkM2W8hEwkSOGCNqchVUEt67k0zYWGXsbChC0y9/iGIgUNdVOw6rrxD/vi26srLdRslnrqHv/sd0CdtOo++RJwm9ZIz4CHK8EYd+PXiNDS2mXlqhS8R3Gt4L5nD0u8+SiRrre2L/cR757Jsombd3Uc4EA+f1Q5INhlFiw6sn8l5CuqeHzt88QeLIuanOtVBVlcTxVt13oqoq3at3cfDzf2b0JJuuKzMTjNL8jb9gMhi8m+nxk/Ebm+MA8eZe+t40RvyoKgrRTTv0BU/LDyPIH3KKS+/2143LGyD+HIhMOHRe6xt17lpHKjR0SZLzBvVt+nuPYCTmZRDs3X4vUz/wVSRJpuCA+MajA5KKpLRKx7ENZDNJqiZfRNamqdCr4TNIH6qnecuTjFlxC/a8krPcPCYNrbW3bBG9T72K/ZpxqKpKj0/M8rEEB8o78KZmEjj6MkUfyfEXOF4Xswfk9ECzox3rqGoC+7dhGzUKW2UFrqZ+fTY6SlwEFn97Gq9/8Vnm/acXi8vKsb+LrpHA1P6Fxlw6iTmXvkbm9Xu48n9yKcAPHNQwWQb7A/7yb1hF+/d/hbWqCktZcS5byiQ+91FT+q0h6sRRbP7kRnY8F8QxbSySyYQySlzo7t61pF9+zAIyJ3+KNXgCR10px5Jiqt+Y0gGZPpfmc6hhHI2/fJFJX70cSZKwyeIiPbqin8lTLc9j89pK/vjNCK73zcecn8cVs8UaNcEP5uQ3fWs9xdNL8bsvRonGMbmdSFYLtpNi8GPKp9D90FOku3vIu3A5kz9Sgmw2oWQVZJNMU7fonkgVmchGoiQOH8OePwHJaiHd3oW1soy6apF1NPL3HC9H77G9tO54gbyPXIBnxWyUcAxTnht6xb4o08VBXPQX8YPcfK3GzXNMdEckpsRJd/VhLs5HkiTKi8SNQV9E9CFEtyUxFxQgybmxuODa/qKagZQou3tXLn1ezWZJNbcS6T2OZ8l0TN5cCnSRU9woeOf5ibYEqP/LVtpfPoJjxnic0/rdM52tPkH+V/4VKIkkkQ27Ca3ZzIW3djNnXH/K/kSH6Daq95Sy84mT7PjNHmSTxJqaT7Bua/8c/MAkUTFoN8ns+r/HSLX00J0/gfAAN9KoajH7rHNjRW4N+MuTlFx5HbY60WLUtF/kW1HMKtlIlI6fPEnBDVfjiJg154VDzH4z4V07SB48im/SQjL54phP7hbdRK4O6N63mYIJczFZ7aQ1rlBHd781sm15bkz5n1lNOtiLvUbsu7NedNPYe3KKTs+BTRRPfR+BCWLbarG4sXAcsqNms7Q99jCjbr4Dq4a5um+C2H7xrtz503Fy3TM1biINUa9/XprQy2/i3/4ilk8sIUTuI5BJJ+BJRvAOYMTyMgjSUT/JkH7qajLaR9vR9fQ06dMbK9kM3Uc2Eu9ro/OAsd2HY8Y4lGic7nueJhvUYdQCfFcsIvTabvzP6lsxlGQCSZbpfewx4kf0TdaeGh+VK+o4/NddZAyUgl/5hYk0bu2lfqO+u8aU56H4Ux+i548P0fXrv+gT5plkCm+9kr4HVtP3wGrd9iWzmZKbltD5t/WEd+q7s+o+vphER4iOF/YTOjI0m6QkSRTcch2RDdvo+skfhnRDjLtuEp0722n9jx/R++cn6PzB3WSD507zLv74LRTecC3RXXvZcsu9ND+ynSM/WkOs9dxsy0o8TmzXPtr++/v0/P5vdH7/d4TWDM4OXDhuHuMu+xTRLQdo/crv6PjRA8T26HMtnDz0IvV7niTsH5wZONnTSe/mV+nb9gbhV7fR++dnaPnST+h78CUixzrOeV1g3U76nt9C73PP0fStb9HzxBMkTpwYkt04G43R9af7aPrP/6H9p7/C5HWdUVwGvSaWouO14yBJFN26akjZTG+Qtq/9jt57n8HkdTP7Bn3a/ExSoWxiHlMuqcgpg0MgcqKHZF8UyWLCWq2f2RTavY1Y/REwYJFTMxm67/kLme4eTAX61ANqJkPfSy+QiRorVqmqCj173yDRZ6wobXjjZoIvv5IjBzQi33IMf/1uQ7IAna88Q6rXmGsYINB3gvZmfUsyQPj1rfj//gyWilIk8zuTMj3iNhIxorwMAqu3iFi3Pk293V3IlBWfQcmmyaaHNsHLJjN1Sz9E9YJr8J/cRyahr4ykGttRwjHCL28l06Vf3yhxvBU1q9Bz/4tkozr9sdmx1dWBqpLxB3TbBpj08bmcXH2Ejf/9oq6CYXGYufrbM3nuW3t5/Q9Hdc25SjKJEo2Rqm8iebRBty/p9h7SXX7Cr24fktL+NCSrhdD247T+4SVdWdlsYvyXL+L471/n0HdW695rprMHNZEk09lDYv/gJvqiqSUs+dYFlH3106QaWkkeb6L9m78l2dl2lqwkSdjH1FH6yY8z44fXEzrSSefag+z6/EMkjp09Ni3FRRTfcQsVP7gLk8eFGk8QeOQ59v7XY4NWvXb4Sim/61bsk+pIHm+h8yd/J3H8xDllTyOVCBENd9Lbvp94ZJBaMqqKkkqSCQdJNXWSDYTJdPuJbNhF+5M7CB88+37VVIaMP0w2nPuL7ttHaPNm2refO/5IVVXihw6TbGpGTaUouOlaPEuGTg2Od4bZ8+2XGPfxBYz56Hys5UOnTifrm1HiCWSvi6JPXoukZQ/UoHl3H2/ec4wP/mo+l3/NYJqyz8HM71+LrFOrKBMODSumLXGsnkxn7v2YfT5d+eCmN8n4+1AMKi+hk4dJBruJ9+rHh2XDESLbdgJgKTSWrt5zaCPxnhZDbqDggR34t72ByTm04noaTcdfYd/Wuyko1k8PV1UFNZlCslmxVg+/yO/bhhG3kYARt9EgGHvp7UTajQWc2t2FTF7xadLJKBb30ORtkixTOnkpvlFTSIR6gKF3Zra6CnzXXUDvn58l3dWHTYeDyTV7HM4pdUQ2HyDd0QcMXSbAu/R9pLs6yQbOvZvXondfB6lQgq7trRRM6sPmHXohsrnMyCaJV399mMrSFuzjB+dWcUwZT+m/30HPnx4isn4r9slD73Ldy2aTau4k9OJGkidasFYMTt8P4JpcjaXATaq9j2Q0g8019PBP9oSRZIl4a4Cu/T2UTht8Z2wbU0PpV/6Nnt/8hdiOvXD70HVwTG4nxf/2YTJ9AbK9QUJ7dpC/2HOmarQWzuoCChfWIZkk4m0Bun7xEIW3XoFr3tk1a2SbFfcFi3AtnI2ayVBS0EO8NYC1yH3O+AtVVfEsnYGlJJ/EkZP0Pfg4hR/9ALaa6nP2ZdysG5Gk/n1PL2d/XGzFZRQXXwbk3EbRbQexVBRjqSiiovjc8Rr5q3KpkoGiNsz5+ViKi5EkiYr5+84pv/m/VhPuMlHyqU+QOHwU7/sWA4PHk8Wbe9n11ccZ87H5VK2ajKqq1A+yUVdVldBz64ht3UXZV25DTaexlBQAgyt2ge4Uj//nXq793my8pfokjqqq0vDnjdTduoj8WdW064TZKek09ooqlFTKkOXFWlWBqioU3XYLskM/S8U1dTr+V9bimT10ocLT6NmXizlL9OkrLyaPG8liJv/a92OtrtKVT0dDBE8eAEUhEewCBmd0VVUVNZtFttqwePUtTACFpZMxmW3YHQbIMCWZxJET5N98JfaJ743yAO8FjKRKa3A6LW3Kp76LbLUiSTKBGaIboHBrv380XCNe79WsbUPVfQFQRFcr0UrxdVhPxbR0rX0G2WYnb5VYiyNTonFRyCpqKk3nj+/Bc+EiqiRxISq6SQxO7Hh2FGo2S+eG5ylb/n7Kruo/7/+r+PFSrs9ZfvxvHKLxR09RftUHyZs258z5tEYPk9O5AMC+V16i77W1FCy64EwRS4DRF4nWlYN7cg9TSSTwP7uavPdfisnVH+Ng16TBJsozqKpKcPUrSJKEb6XI4Kl6RWvMJ+a8SV9zlHtvfZOl31tJyfR+XpWdneKCmu/IfQQTXSEOfed5TDWVlH/y8jPna/NFK9ihlrJTfU/S+9fnWf61uZhs/crRodfEtNcpF4hVxa2aHPpdbZXCcSoqDhRTlxUlmTxDFJZ19ysQckJjUC0RLXCqqkld7tWQhxUnUKIJTKcUcadTjC9QNNdHesU4lKLNYl97l4rXWx3imM20irtlOaFJCR7TbwlI9fQrBemuHmatiAgKWYFNTHXe1pYbw4mGDpq/8yATP7+MkmX9ZG8lDtHKEMvknkXHhgZOPLqHb/2+DLev/z3ui4lzIs+cGyfZtMKf79iCed5URt3YPyeqXKJG0pPov9ee7U3s+fVWRv3oU0iSdNZ7yWbE92g2pam/4yfU/uyzmFx20DC+FnlES27fI+tJhRJM/Xwuvbs55BPOR7eLG49sazctT/yZMbf/JwDpueKzMe/on+CqqhDKbye2bT+2sdXYJ40hb7s2bqv//+X9bdS//Gem3PDfSLKMu0UTr/NRcfynm9KkOzvJhiNYKypweEQOJKtffFahk4eIn6wnf+FyzG7PWanNWneJ76g4JqMV4hywxPrnU8TfwoG9D1D9n/91hmVXteQaVBIJTv7X1/4pqdLTP/b2pErvve+9kSo9YnkZAgN3l+80ii+6kuixQ4ZkJauF4i9+lOShE2AgWF8ymShZcrm+4CnkL52EbDERWNsKA5SXc7YtyxRetApraTn+19YZIpKT7XYKb7wORTLgCpIkfFesJNV8thviXCiodnHr3Ys4cNhYxpe9xMuMn9zEkYcOoGYVJNPQY0K22yi6/VokucVQ+/8IzgflPuSeqUnHgvhugKWkCEnSd70CxI+1Uv5v76dkmTHG3NIltZQsrMHt22lIfs3PD+MutFF8w2xD8qqqcvSeLRR+4ELDxIqSLFP7089gPhXTo7frdI/ykTfBOPGhyWandOXVxvoiyVjKisi7aoUhedlsZdSSG84EYev2xePG5BmwG4oNLgvgHjcJ97hJhtoeLpLxIAWXX/GOlwd4O2JW3ksxLyPKy78IJEnGPX4KRhkpTC4njjlTwFgxamSDdT5OI2/heKSAMTpxAM+0mdg9RSiJGCaHMb/0cBYLa3UFGKRfKB7tYVSp8VIIstlE0TVD1/IYCEmSkC3/b9VBebcj/5LTSraxFGNJkpDMxpSKbEYhm1a49tvTeTNi7Bo1o1CxcjzpOUO7OrUw6wQAD0TFBWOH17bLg7vO+JweDmzeQl0X87sVhRVTSM14F2xkR9xGAt4Fb2QE5wvnu86HxTe8Wkj28irDisv5hl7g5QhGYBQms8yVX5mKzWl8AyBbTNTeMOM9XYtnBCM4nxixvAyC8GgF2ZHze0ppUcdzdvf7YoLjxXOxsqF5XiJ1YnBjiSZTL+MU29Ner0Xp86J8yyqx/ZQm/rPpDU3ArCYAuH5Xv0/fVqmJjUiJw0VL8T0wNgEgGRDdGpKGt+Xwtlrh2FYnXp9qERWdZKF4b45i0ZacaBF3paOqxFT37gEPY0+3GFMyWhPDsqJQzBja6Bd3sUvzxYrUdrPo4prmbRWOL73xgHD8w1evEI7nTBeDpVaNPigcrz4uBgBnyjVbqGz/u5ILxL4oreKLmjlfDEQ/5BCDIV0O0YSVSIkxLNmsOOYks/heXDeLLrzU8yL/iJwVx0VwtshOXKV5b+19/YNUzhuayXi5T3xvOzvEWKaOkOjnn+oTg02fPjZD/O2IKP+lseuE49eDouVkToGYBXY6JuY0ehJiwGc62T+nFL8Yd1E5Tszk6gr0j99URy+OjgqkAfS97fni+G91aEpKWMVjy0TR5ZZtEOebc4PYnrY0g8cn3luyUHyv7ub+MZpXL46pk5eJsRtmTXJh0R6xr5ohg+VW8b2l/lomHFsj4vW9kzXxQTvEcRSu0fyApv5A5XpxTgVH5557NvnP2/9Lqor0D4ao/qPXv5swYnl5jyEbieF/5Ll3uhsAw6r0fD4R3NdCNmnM4da2/gTRVmPsysGuJNueNcZxAfDaAy2s+/Pg3CgjeGeQDKeIdOkEVbyLoKTSdP7yMZBHXJP/T2EkVVrAiPIyCFLd3ShxY0Gdw4GSSJCNxXPpjgbRvXM98e5WfUFAtlmIbtiuLwgk2lqINRwzxKOgqirB1/aipDOGPr6ZYJT2b/wMJWbsGUb27CF+VJ9XB4ZPSd7z+lEOf/tZsmn9+1RSWTZ8/mlaDp6bF2UgsmmVdfc289h3j6EYUNTmrCphxwtdPPqd4+eVwnwExhA/3sbL39rKE596FZvHqiuf6ovw5G9a2bHOGK1Ay64eTmw1RiWvqirRnXtQkvrrQs99q8l0+Yflckq1dZDu1CfdPI1sIk64UZ+4MhOOk+oeXimVaKybZOv5C2hXVRXFQA22eDJAMqU/zwcimxmpYfZuwYjbaBB0/Oy3jLvxCziKXWdVLI0NCOAvfzNLKhGicf9qiqtn4a4TI94D4zXVTB98kWjTMYrmXUj+5Hm0rxQtAmWvivIdyaP4j+4g2LifilUfQHqfaN6M9mno/01WMJtQo0kku42KVWJqdOvL/W4jOanQ9uSDuMZPoWTVNUgmE8UDiILDAy3uKkTeaCX8egvWwmIKll9EJk/8AAtU7E6Z3qlTCPx9NZ5li7FVV1EwRnTNRLz992KNmWj9/qMUf/hDSGYL9toa7L3is6i+OFdFes/Xn0e2W0hdeDVKPJFjvZRlfPWiLt5ZmTOzuz50FeGfP86D/72f6i9fDRJ8fKwYyXz30VMBubOKKf5MKb/51BMs+PqFlMzJuZe0bqJj8VIogPffU8nab2yh/t+f4oofLMaRn7unte0TBfnTFPi2u1aw42ePU932U278wSysjtzuebxdNIP/6NilRA634qgtxmS3UpofQslkUVJZzE4rLUfFLBKbqwOTx4lkklla1e8WSscznCgS3TbatOxEh5N0Zxfm4iIkWSZbrEnRNWvSWNfEsBYWn8nGc2i+oZXjxY9Z6Q0RlEyW7l3tOEvdjKoBs63favBak+iSa/d7yHQFSDa0k2xsR21SKV6xCtlqQ5kiKsMHW8tRM1myoSjZYJgtHRNQU2kcMycjmUx8fOEG8TnJaVRVZc0vjrL+TyeQTRJf/vtsagtySsYlk8SMvva4l7597TQ8upuONxpomVnJ3Ksv42CbdM5n+XLbBFLNnfQ+uJZkQzuz/3w7B1v73W5FDtFVo2RkEsdO4v/784ybYeOC5f1z6tn9IsndovH1NL54jOMvb8czKo/4GPFDmlcoul2DrXmo2SyhteuJvLmN2l9/DmlASfBsWmO5qYmTDUYIvriR0NqtjF/5Sazh/o1K8W7R9dOW9dH92iac1aORx9QQrxE3FZZw/+el/oacchjbd4Devz3CtElfxTQgg98/VVxLAqfc8Wo2Q/jIPkoydVid/X6rri0iWZx6arrFTzYQ2rKRGRXXIw/IbEr5xA1X82Ueute/ib2sCs+ECswaw5uWsqJvgpmkv5vQ4d0UL7qY/GO5e80YIMd8uzCSbSRiRHkZDNk0mZgxrVxVFLqbduD2VeJm8HQ9JZ0mEwmS7OvEv28z+ZP1yaCsBcUkOlsx2R1Y8grIMHRqaHT7XiSTie4//o2Sz398SFnJbEaSZYLb3sQ9aSquMYNnGkiShGfmXNr++idQFLxzFkDe0MG33qVLaPvxL4jt3U/Vt746pKxzSi35l15Cx+9+j2PSRMpuv31Q2alfuZSmJ3ZT/93fYHI5sNZWU/CxGwbvuyxT9vlr6fjh32m/Zy3mPCfcZRlU3j1rDOO/fylvfmUNM7+wCEeRC5afW9biMLPq+4vZ8eeDPPTRtVz54yWYLCY4N9ccss1K5X/cjPeJ+7n3ts3c8uu5SCYJNPQNSipDy33riZ3oxFrowTOxDPf4Ulof2Ubl9XNRx1+ENCBDrPUXTxE/3Iyl2EdinJ28Gi++Wi/1a0+SyS+i+ua5OMrEoAX/kR56D3QSbuslum0Xme4enNOn4Fk+Hsek2nPSoAdf20Pwpf0kuzvwjJ+CZ8J0nHVjhdgL4T4yCqHmEKETfez/w1YizTnFpmxGMcvumkfhuLNJwtJtvTTf9UeUWAJLZRGjrv8ssnXwtPDIpn10//ZRAMwlRRR/7tYhM9XC3UlObO3DU2Rj8Q1l1E4fmu8iE0vRvr4es9PK1P++aMhg78SRJtq/9xeUeJLiT16NyT74OFNVlcBjawg+8yqYTcz95ZVD9gPAWerG4rLgG6sfLJ9q66D3/odJnWzBd/Vlutl7qfYe2r9zL9neIJ6V83AVD04oCZCNx/BvewOL16fbF1VRCL70MsHn1+CYMkmXryQdDhLYtQn/zk24x06maurMofve3UXvS88TPbiP0hs/hBwf+tOmKlmCu7fCdBXPhKm6/c/EIjQ9/kcKZi/TlT1vGMk2EjCivAwCk9ND2qjygoq3sI7yMUsYSg+XLRaqVn2Ezo0v0LtjPYneTmDoRciaV4CrZhySyWTITGxyO8n6g5i8Hl1OBVtxOflLLqTrhScJ7989pPICYCstxz15OuE9Owjt2IKn8sIh5U+TqGV6eokfPgqTKweVVVUVVVGQ7XbiBw+RbG3Fbj83E6fJZqbug3Ppy1TRe8/DpNu6QJLwzfnAoNw8ksVM6UeWc+Irf0VJZ+n76GIKKgfnMimYXMKKX17J63e+QCqYYObdU6mbeW56Y0mSmH/bZIrH+3jq315HNsvU3lWIZ1LFueVNMld+ZQpv3t/AH2/ZhNNnYfSfRuEt6J+OstXMxO9/CFVRSbT2kTzeQmDXSZIdQU78Zh3mot343n8ZzlnTkWSZmq9/BDWrkO4KMDaxj0BjiPadXXTu7SYZbKXtub2UrpxE7UcXwpjcBzUdSxFtC5Ful1BiMbKBIIlj9ZjyJGSXA/vos/uf7vKjJOJko2HirSeRbQ5kpwtHRX+gd7g5yP57dxKs7yPaFsZV4cU7ugBHiRtVUZl/+2TGrarDZBHflZpVCL2xj+6HX8dSlo+ayVL5vx/D0ug7qx+qohA/cILwum0kDjdiKsjDVltGwa0fQnYO/l6bdvt58P/bzbLbRlM7O5/RY4deAltePMzhP21i8ufeh9Vrx1EyiFZ6Cqn2HmSvC3OxD8+KWQzF+Au5+BXZ7cS1cAaeMv1MvHBzkMqlNcz9r6VsOzm0rGy3k+npQ7JYcC9ZoNt26mQ7qGAu8lFw8yWgU/anb+vrKMkE6YB+2RIlFifZkLMCO2dOG1JWVRR6Xn+RwO4tmD0+Si96PwwRWqYqCqHtW4ge3Ie1rBz3jNmweWi3bPT4YTKhAIl2/YriSipF0xN3kwr0YvUNzVg+gn8eRpSXQTDqkg+R6DUWjCnLJsbOuckQqZ1stlC+7P14aicSOXkYK/r8Ib5p80gF9RcIANuEMVgqy7BUlunKSpKEb95ibOWVdD376KlYksF3Zyani7IbPox7ygz61q/FfcXyIXdz1vIyyv/9C3Tf8xdiew/AdYMrL5Ik4V28GNe0afQ9/zzBda+Qd8VHh+y/c94MLJWlJBuaSTW00LtnA4Uzlg6q5FmKvOQtnoT/lb2s+1MDN37jbGp9Qd5txZ5vJ9oW4tFvH+XfH5mLbBpcgaycXYyvxkPrjm6O/eh5Zvz2Y4PuvCVJYuaVlex6uoXmPQEe+KGJz36/5mw5WcJRXUheXR728jy8Uyqx+JwEwpXIHrdAEy+ZZKzlBdRUVVGzFFLRNJ5yF+G8chyVPhwVPix5Dk4zfpXMqqBkVgWJXWOJ7TuItbIcc0E+luLBa2IV3bQCB+OwFZef2XFriGGxuK1ULa1hyq2zcFd5UeTcMwie6MMzykep+2zrYaKhg9afPo6lNJ+yO2/C5HEi2yyDFln0P/4KiYMNeC6cR/FnbyB5tAn75DqyscEtNDufOMn63x7mph/MYPS8HOeIWT73vSoZhS2/3MHJrV0s/tX1OMo8IA3N+di0+hD+J3ZT8b8fB0XVtXQcvXcrqfouyr7xOSSLGdDRRoCG1UeZdvsczHYdy0JWoe/vT+BeuhDbmFpMXjdDKVLBNZsJPv8m5V/7BCgqJo9zUFnIMeySzSLbHShZfdeJEomQbm2j8KMfxDF5IgxReSUbCBI5fgjnqNEULr4Ik93BUCaDdE83kb278M5dgGvytFObtqGVl0w0jMnpRpLNp2L4Bp/Xmb4+VCWLZDZjzX/nlJcRt5GIkfIAGpymYp782e+CqmCyO7GGxEckDVjBItXioPc0ibKRKk268YBr1WyW2FRxOXQdEgMHU15Q0ilSXZ3YK6tJFYsLhTkkLpBKaZLwq9tQkinyLluCc79ono1WiZPaHMv1LxuNoCoKFke/dcGkWdctAwxRmXgUOatidvbH3EQ1G/WMN3vmPoOrXyb/g8sFa5DDJfrsvY7+HwwfboOKSmRb/8dflsVn67KK1/vXiwpbrFy81+XzcunH3fu6WP/j3VT/xw1YinIuAy3l/SU1uWBFVVGpf7WVdb+rp/CSGRRfOReAP0+9X5C/9skv59pJJonu2k3hwaeZMsvOF76Ri035W88iQf624lxV8cP7k/z9TyHWPhdn1o+vpWBmzoKxsLBRkH9gz3zh+Jqpe4Tj517s31n/2zXPC+d+tvVi4VhNiUq2q0hUJmJ+8cNVVS0Gera0i9bCAk2sRaVHjHk50SeSk6U1sRY1RX2kgnFiTX580yqQNSvskZP98Q1fnJdLVc5mFExmmYebRIbnjk7ROlZSEkJJZ2n+48tEDrUy5VtXYy/tdxM5zGLMWTxjIRNNcvAbT2Px2Jl+10WYHf1jsCXgE+RHn4qV6djQwMHfbOBL900nf4BFb123GPvUG8spY72v7KfjqW0UfP7TZyxFJqcmxV1D0ZBq6aPrp3dT8b3/RJJlXA2iYjxhVX/JieOP7KFlaxdjvnb9GTdX5jmRXbhvVu734vsOEXjiRUr/81bM+f3PxnJSXDu0pUwinccIrXmN4k+fctNlxTlkDZyKW1FVWv7wS3yLluGdNgsAs4YCQtboP8lEAMlswXyKFyquoQZQB9AuJE40kk2EcUybCLKMJEkUbhOVO2tUkyYeVdj84jeZd9F/I5uspHyifO8U8V56n38Wz4xZWEvKBHetkkhw4lvnl27/9Ddp9ge+87aUB9j50FdHygO812GyD737+EeR25npR8XLFiv2ynMXyTsXXEtm/v/snXeYHFeV9n/VOXdPzlGjnHOWZcmWc84J2xhjg8nL8sEuLAYW2F3YxSQHwCBjwAEb2zgnSU6SlXPWSJPzTPd0jlXfH62Znlsz3TPClhP9Po8eu6ZO3b5169a9p054D7G2NNV+00BrPamEjDH+TGe2ohljwoyk1eK66ByQxkiBC9gnlRKIpI8XeC8omF5IzY9uIe4dPT1W0kjUrS6nZdIZBI+0jVreQGM0Yl+0kAd+vJMj+8KEQzImc3qL3KRpRr7/8wIC166id0sDOTPL/ymJywxOM4bpYy9JoNWNPVGyf2s9cX+YST+9CVNmr0+ybZOe4vNnULByIjr92F6IvFmlLL7nUnLKRi9SCOBaMhHn/HH0esd+z4FNO7Aunj0miv3qi6egP2PRmMgYTVMnUjS+Bp3r1LYD0/hajLVVo1qYJEmi+MobMOSO3Wqht7vG3o/a6mEcNmPB/LO+iVY3thIb+eddNLrQaUbW8iIiq7x8AqEx6DFWjxxv8WHio7QpS1oNehWpV0Z5ScI6Mb3bayRMmDb2ryRzsYPyi2eMLpjFKSNnyQRci8efnH+j8/1IWg2FZ04aVW4o9DYjepsRGJvyojXpwaQfa7UCAMIHj5H36avHJKsz6dFGR0//hmRAu2QyMeYvl6HXjrGEx6koLh8Uxqq4ZPHRRFZ5ySKLLD7x+Cgpzv8oiv7fnWMubJjFJxDZbCMBWeUlDYweBa0h+aQllUXSV5laCMOF4smSd8QvO4NXHOKESRUDExe/jhTV2hTLUcXEnBDbk1UfV0aVnzq6Uvy00zSKdnNtWFXOYIi4b7J4L3KH6MZRB2qqY2Rk9b2q7i0SUfmZY2Jwpma/aBmxLxBdYV+pfU04/kniHLF/G0Uf/2F3ihulWlUOoMMvjoua1r3AKjrpX/CLGRNT54j85l5ZfA6tQTEW41cdq4VjncoHt6VPDN4120SX27qW8cKxND7Vv3tePU84Z68S54CvQxxXRfUgFVXsQvdGkVNDU6eihY+Jz3HvQTHFtnJcl3D8qYp3heM/NYuZMK19LuF4zZRUqYSwIv5Wn0907f52uRiL9MWd1wnHV0/eLhz/Zv8y4VivF9839Tx5dM7vhOMftYrV2H/9+hrhWP2OXLlM5BfapK0e/P/2A2KZBnLFmK6CcjH70WMV35ddO8TSA1Jc/HGLyguus4nvd0IVC5UwqWL9VOug47BodQmWivJ5+1IXxD8lkvXp/ijGQbWLj4HydWJbtjaxb75KVRkVn6rvKqOKL0eV2aZWAlWbevFmcR50zxbvNfdA8t7iMRmxsMfpxSfJ7fNekVXjPwTI8Rhh39jZLj8qkKNjj1k5FcR7+wnuOTa64BAo8tjf4p63XiXuPwX7fBZZfAiINDV9ZEpHxDpOLWYuiyw+aGSVlzTwdTUQ8Y2enqwkEiR8fuL9Y98cg/3t1G95/L10Ly3kWJRwbwcRz9gWHzkaIdo7Ntm2h39P4OjolOEDSPgDKInRA5LlUISue/9G6ODoqaIA/kOtHPm3RwgHx1Y7SWM00fLo70iERqf2bn9sI13Pbj8tm8jRtZvx1o9NaQ00udn741cItp8a9XoWSZxOJSCRUIjFRm9fURTibs+Y5Nqf2UH/ug2n5N6KdfYR6xobhcLA74wFgc178L8xthIjALHA2Ne+WP8HU0NqLOnbAL5j+0cXOokPvaSHorw//z4hyLqN0uDY6w9SNHc1xQvPI6IiAbW1pCZAcPchOt96FktpDeXnXEfrGaK9UlWclHgiTOBAL3GnnraqfswGsfHcg+ILkrcrSl/PEYxGB3ZnOb5ysUH3tFRf4v39uJ/+M/6O41SvvhGLpQDtJjEdTpmZ8u3EOnvp/NlvMeWVUHvpHQDIGWaE86I1dP35UfJvvA5jVQWKKtPO1JJyK0V7u2lbex/W8ZNxzV2CqbiMeFjMrLCcpNGxUIN+zS00//wP1H3/WkzVBUiSRE+Z6HqJHEuamhVtLlLuCW6/ppXCr92MEoqgddkhIHbefjIDuHDqchI9bur/62km3X05klbD1yteFmT/5k6m3PqudvDqdzdzzxYr1V+5AL3LCpKENyTa3GtsecQjCf5++8vUnlVFz6zp6JxW4m4fuhw7bzlEwr9QXIsmx8G2bz2Pc2oJyz8/GWdVypVUbBY3gDUzGnhrf5TXv/QXZq0pYNmt87DmpcZjvLlTkP/fXWcRbetBYzGiK0jOkWhbN4bSAgrtorvBahSVuCJr8nyw3YvBaaLDJLrbZs8S62q9tn8ysbYudEV5SFot19eJG90fDokusSqbm2ggyvHnj5IIx7kvGiUeTTDpkvE4Kx3EVb7SaaXtBNq9+BrcGOxGtgVy0dnN6KxGjhrEwM8Cp594IEL/zkaCDd3ccX+IeCTOsm8uwlZkpSpP3Nyfbp1J1B3At7+VaK+f3iNvoESjONesQmu3o9ZJ5Bw3gRYPXe8cx3e8lyX1cWwTiqj70llIWg1GrbhJKrY4CV+AwMYd+N/eTvnXLsY85J19Yss8QT6nqIfmX79C7yu7KbryenT+lPISzREVmX6fOUmvsOMI/a9tRRfyMevn16LRJe+xoU+kChgY1mh7B8HtuzAoFnKWrhw8Hw+K74vOGiOw7SA9DzxGwZ2Xo4mJvx8rEedNvN9ArN9N59vPUn75pzD2qPpbkzrWvZqcUy2vPkb52dfgFytCYFZRag2UYIn6PUR9fdhNoktM7V73VyQfXOj4cbxvv8WM3AsxGlMLVNsy0b8u6yHS1kLnxhcxzps6rDxAzCb+gK0Jeg5tJm/CQiSNhkBJ8vwHW1U6m200FFnlJR0UGb19OHW5IKIohPs6iXp6iAe8yKsuBzJHsEt6Az3PPoUcChE6dhTzlAUZ5WPRIEf2PkH1+DXYnSMzzg5A53RiKazA315PIjJ6QcTQniPEgz78AR9RnwfDKOmJ+sJ8tE4nHb+6n+K77sAwIz19uN6Vi3X8FPq3byTa3UnFzXeRiQjKWlpD5RfPp/7ux8m/cC65Z04DRu6PJEnkXHYxfc8/RecPH0Cbl0Phl2/M2PfiFRfSse23HP/1aziml8P4keXsJVYuu/9Mnnqgh4NfWUvhhXNRFAXrRWcNk9UZtaz8jyUc+NtRGr76ayzTa4k2d5F7+XIYN7zPZRdOp2TNZNqe38eLn3+F0gUlTL5yEj0He5hwhVhWQm/UsuqWShZfWcq6PzTz52teZtpltUxYU4G/O8T41cMXzeD2Q/S/uBHJoMc0sYrI0WYMVSUUf2m+wG0C4N58jHh/MDmHDWFQwHeij4an92KdXoVzQR3O+XUYS1LvwKafbEbSafCE2ogebyZyogXr4ll0OCSKJ6TnjIiH43RsbuXgX/YR6PBjLbRw5veX4awcfo0iK3iP99Gzs5W9v3gbJaEg6bWUXj6PsmsXgWF4doscjdP4+zcIt7jJqXVx/q/PwpKfnuYg2uvn2P+9TNwXRldYQNEdn0ZrT59DHerwcvTBd5EjcUounsW4L6xOm4Ic3LaPnt88ihKL47riHMy1JSPKDcC3qwH3GwdAq8E6MTNpoqIo9D7yKv3PvoOk1zH3/hvRjFDCYQCRE430PvIEsbZ2DJXlFNzypYzth/bV0/XzxyAhY6wuGTX5KOb10Pine7HWTMgseBLhng7c+7dQsuISsI6eiedrPUbDaw8z8fIvZ5RTFIXQ0SO4X3uN8PF6ci+4EGMsM4dJIuCn/eE/oHO5xtR3RU7Qses17GUTMNrzRr8gi9OOrPKSBhqjBYMts/IiSRKFC85Cb3PSvu5JvMf2YimYl/kajQZzzTgChw5gnTJ6TQ2jycHE6VcRCo7N3VC64AICHQ3Eo6MrL46zF5Pjr6Lp5T/hObSNwvnDN2ih7wYDGqMB4nFChw5nVF4krRbHtNnE+noInjiCb/9OLAvnZGzfPqsa67QK2v6wnrjbj+mC9Nw2kiRhnFiD79VN0NBG5FgTxpLaDPIaau5azZ4v/JHOF3bTuKqSqrqRU0kljUTxZQuwTSnn8P/7M0osTmlZJdY5wxfp3DoXy74xn+glV9Lz+AZ8b++l/WdPsKF3Aiu+NA2Nio9EY9BRftksFl9dysEnDvPK114n3BcmFpGZev3UYe2bbTou+GINlVfMZMuDB3j80+tIRBOU/HIq084QF1HXRctwXriUeHc/od1H8b+1i1hbN+/uOEDlNfOounbeIONvuLmXSGd/Up/Ux0CSiPQFkWMykeZeIqW5RMrdGAqHWIfmFhPxhGk9qiXhCyB7/QQ372a9YmXR9dXUzEv1R4nHCR49jH/3Tp76rwMUziyifFklod4gZ/z7QkzOlJIfanHTve4AvgNt+I90YCmykjutGFuFC2ddPoU3r8JUNNCP1I4a6w/R+PhOul7eS+6SOrQWIxf+egUm1/CNUY4l6Hqrnoan9hLt9eOcVYkciWO/8lY05pG5VsL1x9my9u9E3SFKz56I3mmi7JaVaV07cjxB+PBxJL0OQ1UZjvPPADLHicU9Qcy1RTjm1KA1Z+aVirX1ENx+GH1pPo7V87BWpd9EFUUh1tFJvKcHjcVMwW2fQiNlXu6NEyrROm3o8pzoS/MhA3N+3OOl/c+/JebpxVQ8NgoBz6FtoCgE209gyk1fA05RFDp3v0Hbu89hKSjHYM/NSIclSRLRri7Cx+vRFxTgXLYc1qc3MSiyTPczTxL3uDGWj40/y318F1G/m7Cn68NTXrLZRgKyyksaFMxYPqrlZQA5U+ZjKa7Cve9dxkJrZx4/ASWRQGuxDDC1Z0Re4WTCIc+Y+iJptVSf/Sncx3aOLgxYy2oZf/3X6dmxYVSabI3RSOHtt9L7178ROnQEJ2enlQWwVI3DctM4Qs0n6N+1BdPsqRkL7Ek6LY5ZNfh2nKDnxV2UrDgPrT09F4tl3lQKvvopPI+/hPvxlyj60ucyxgzIsQTWcUVEe+p57LduvvHfRWllIcnFUXj+bNzvHKbj509Q8V93YCgZeeHSmAzYF07GWF5A3ONHjjew/7lGpl1SPWKfdCYdEy6qo2NXJx07O9l6z1YSkQQzbh2Z68WSa2LezZPp2NtHx95efvuFfXzm51OZvkp0o0iShL4gB2aOp/j/3YzGYqSiIoTOZkTSphSpkitTGT4DbqP+o92Mv2ku3sLaEftcsyqZAdWyfzKG6jL0RXlo83O4br5YuTnm7qP11/dgLKvANmMWK386FYPNQNQXSZZc0Imf9IlQFEmroeyaBdgmllCSl8yC8bf0Yyt30hVUZUfJCifWbqT9hb0UrJ7KzPtvQWc1IscSmFzuYf32Hu5k578/h2NiIeXXLcI1t5qYO4DeZaHt6HDFJdLQiPu5F0n4/Ey9czZFK+pIhGPoLAYCsZHnV9QdZM/dz5Mw51P87btAqxk1rTne66broQ2M/58bMZbk4M/wygZ3HaRv7d/Iv+V8jNWl6ApdpCOJUWJxeh56hLi7n8K7PosSDqPLy4VRwmN867ZhnFBJwZ2XjcrforGYMeQWoMgJTMWZLcKQLCfgaziEpNUSaD2BaWqGArbRCFFvLygyOeNmjdq2/+gBPOteJ+e88zGWlZ9kwE3P5yNpNNhmzSXu7cdcVTOGvit0H3gHgEh/N1Sk7/vphCQPz/j6R9r4pCBbHkCFASrmFTO/jk5nQqvR4x0vpiQOnQARV2qBkhNxPMvE2VH2rKgfxk0SIW83gZ5G8mvnEc4TF0PvOPH6nAPiAqjKJh6WnmioSW5EciSGxqjH+LpoPk2oU6tPlj4YmAZxa+r3+ueLX43aLsOgbP/69TgWLEoqYANtmzOnVs6ac0wwt28/XC2c15iSm1rCH8L911eRTDZcl6ZST6fVtTASlIRM6yuH6TJPw1CeMtMb7KKPXm62oCgKgb178b7yNLN/fg3GvOTG2NghKiVSW+rrXVEUJM1Boq29OM+YjiRJfG7im4L8y92i1eTyoh3C8W8algvHPxr/lND+f+9cRP+xXlyTCjDnW/mP8mcF+c8fvn7w/+OBCJrmZrzHeyldPQGDw0StTUxFHYpnt84Wjm9YvFE4nmoRY1q+s+0S4VhRPceLJu8VjltCopK/yHWMYH8Mqys5X357cKlwPuIXFVijKg3cahKf29ByA7NcyTmw/a8nmHhmCU1GcfPZ3yHGfdTk95IIx4h6QpiLHYP0/OnQ1e4iuOsgSjyGZc40Vs04LJxfv0/cuBz5yRR194a9xN1+bDXnCYpftFy8l8Li5L0ossLhf3uEnKUTKbwwGW9VbBNjk/Y1JokmE14/Hf/1e4quuBFjcYp8UhX2RPhkqJKiKPj37MQ5fqaghOhUJaV8k1IbvByJ0vH/fkrNlZ/DmJMMOImqvt3iltT7rcTjdD71J/JuuQTJoEdj0GM6Ilq8cg6lJk7ryjjxXjf+d7bgOGsF5ohIHaCOYYnaooQPHUVfUoQuNwfXQVGZsjenFODu1t1YLYVY7cWDY9+8WpQ3dYvrbNvDvyO/bj6uquT73KuqFWlvSMkrskwiHCLU04re4sCUV4zBlxyLRDTMzr+cXrr9gT1p/mX/iU7/3soDxGNhtj717Wx5gA8SP/zhD3n++efZtWsXBoMBj8czTKapqYm77rqLdevWYTabuf766/npT3+KwTA2psmh0Gr1aDWnRk+v0eqA0TNaTPZ8DJaRKxS/XxhaE2gsOJUsB0mScK1aBfFTU+PHQlUOoLWZyb/1YiJNY8u0kbQays+bjOdY5vgCSPbdNmMGEy63Ee72DSovo11jGV+GZfypMeyOFZIkYSm2YykeA3c9oLMacc0sI3fm6enPe4UkSYOKy+nC3KtOKi1jKPyuNekxF4/9fbDMOvUv65yVyd0vvHtsc9y/vxlJq6Hg/MyuVACtw0bpf34BXfvYypVIkoR95pxTqcZB9HgTjtqpg4rLqL+h01H4hetGFxyQ12rRF+aTc9lJXpxR+iZptZinjo3luKBsJpqxJR4Oonrp1WiNljGte5JGg85sxV4xttie04as20jAx0Z5iUajXHXVVSxevJgHH3xw2PlEIsEFF1xAQUEBb7/9Nr29vdx8880oisIvf/nLD6HH6SFJElrd6V3cPwicbrZPXcHp8y3rbEZstiw9eBYfDuzTK5kwpRzGqNCf7nfNNLkOe+LUSiJ8nKE3j+1D4aOEbLaRiI+N8vK9730PgLVr1454/pVXXuHAgQM0NzdTWpo0rf7v//4vt9xyCz/84Q8/9iayLLLI4pMFSav5SNFufBJKKHyi8X7wtHyUJtx7xMdGeRkNmzZtYtq0aYOKC8A555xDJBJh+/btnHnmmSNeF4lEiERSNkyvNxkE56+0DvoXDT7RPeIvSw1bXBXvZzouWlTcIt0HRlXQnFZlPh0oIz8AzwRxsqlLx8dd4h/kFtENEl0mZh3lOkWae+82kdPDNCR0YtJPRSd5+5mipcLWKo5L11xVfE6u2Ledm0VyB4vKDx23iaZ96zSPcLx/n5jd5KoS3Upav+jnNu8T4xv8lamxPH5CDNY15Yi1DSYsFOn+B2ItBvA/W8RSBLl54rh+r/lC4ViOiH275dAdwvGCeUeF4x+1XiActzSLVqgJ0w+SDp6YalKaxefw5+2LhON1Z/9MOP7SrHXC8WecYt8Wb7tZOL5unMjz8mSzGGNz3QSRkr8t7BKO633ivXX7xTn8o+pUfNB/tojjWmMVY32O6sUAZpOKhyWaEJ+Dzy/GEEwdJz7ndXtFF5LJJc6TyC4xMCRSJgaK6nrFOd3bJ/YvYRzCGVWuKhXSLx5bxdAkQmeIc05uFOe7wSO+X4GZYt91HeL77JspuryNTeLvq3lf9MfEsTOovLzuian1IFcMAUNV5WFYLJ9sVGXpqbzxbctVMS1dYt/sDaK8q16cB63LxQ7k7hfXWXVsoPO42IHuWUmBRCSr8H1Y+MQw7HZ0dFBUJG5IOTk5GAwGOjo60lwFP/7xj3E6nYP/KirGljr3SUDcFyLW7zlt7SuK8pGhO88iiyyy+DhjwG30Xv99UvChKi933303kiRl/Ldt29hpqkcyeyqKktEc+q1vfYv+/v7Bf83Nzad8H337NhPx9JAYpfaPosiEettQFPmUNnVFUZDD4dEFT8r6t2wjdGT0WkHutw/R9cLfxtyPgfbHCvejzxDcsXd0wVNsN7T/ELHOrtEFTyLi6SEeCowueBKxbg+JcPpUy6FIeHz0/eV55GhmRi9FllFiY6Msz+KDQ7zPi//t3YTrR85kE2U99D6+Hv+WsZXIkEOnpxbYABKBsa0JA4j39Z/SeyZHxrjmyKcYLQvEgmOItD6JhN9P2N05uiDJNbZ32xtjLg9wqkjEowR86T+GTyuU9+nfJwQfqtvoC1/4Atdee21Gmerq6jG1VVxczObNm4W/ud1uYrHYMIvMUBiNRozG4YGbkcZ6bHnJ6PKuWeJ57RALYqi3DfeBLXRuepHqyz+LNCSVEcTyADGPh+aXfodjzgKMhcXYp80iUiGaI13bVDTWr+2heefzFE1aRsEkMd0WIOIQzdI9DdvxvvMaOpsTx3n5FHeKsT4t16ZM8tKCJUQe/xX9fUfQupzoC/PRxFIdPvQvKVturKMHef1GYj4PufOXo7PaaV8qKoWyUVzE7JPm0P23vyL1RnHMXyS4pCBlxk70++j4rz+Qt+YC5FgMy5QpaPR65I0uQX7iecnaRx3d7Rz+5aNEWs/FPGsyaDVorRYMXlEX989Pusx86w/geWIDeTdchxJPYJ48AUlF6x12p0zg3lcP8drGXRTecD2x7h6sM2ewN0/ksphf15DsezTBzld6OPj1v1DwxRtRYnH0hbnMrRMZvqztJ3ji9vWMW1nGxHMryV1YikarQZEVJI1EgUF0AbzYMIG4J4A+344kSUyobUdRFKLuIMZcKzatOG8e/5MWjdWEobqM82alFNdYKM70GtHfYNGJitkXj1+VvO/6HvR2I1+avUNQ+L/cKrpcfzvj4cH/P7A7wn1Pz8JRl4elxIEkSfT5xayYR4/MJtLUBfEEiixzbeUWTFYt5ROT88uo8oW+7TMSONRKzBMg7glw8RPl5C+uxTGxmOvKtgqyT3UkXVR9e9uIB6LMLNyA0arHaNXhLLXw6AbxnTl3xQ4UWWHbb/dy9MUG+pt9TD+/jMtvn41G08rmvmpBflpdC707Wzjx+C663m3AMr2WvCvPGGRDCheLfTc365FjUXpeex7bpOkwTaRa1ntVFbxzk/XRoi2tJA7uoOjMCZjyk+/oYVX1b391cueJdnbifvllrJqFmCcNoYq2ie+f36mgyDKhPYfwr9+EeeIkHKtWDO5fcrGoXCkRLXIkSmj3AQKbdpJbOQfXtBTpptrVY/BAzO/B23SIvCmL8FWrXC/OVH8iBcn3Ldbbi+fl13DJJRRPPSPV1wrVWmJIWm0D23biee5F6m74OtEhy7ClTZT3TYwjB0P0/P5RJLORXMcZAq9d2xKx80VbxLFKmNTuevFeveP0RDs76fzjQxTf+mlyT76uanfWJxH33nsvP/nJT2hvb2fq1Kncc889LF8+fC8C2LBhw4ghGgcPHmTSpFRA+JNPPsl3vvMd6uvrGTduHD/84Q+57LLLTqlfH6rykp+fT35+/uiCY8DixYv54Q9/SHt7OyUlyZTZV155BaPRyNy5c0+5vUP7n2DJ8m+NGsRmcOUTD/jGVLVY58whd/kqup7/G/qcXKyTRmfY1RnMRPy9xEJj+1Ix5ZcS9fSgMRgxOHOhM8MXiKxgmT2drvv/gGPVclwXnpNeVqPBX38Q/9H9+A7tofL6OyE/c7p3wusl7nHT8/ensc9dQDpDn9ZpJ++Wi+n7wwvEOjsxjx9P0S23kG56Fq8cj2NCIVu+8zreV95Bl59DwZc/lbYf9jPnoy8tpOtXjyL7g+RdewXWBbPTyjvOW4nekkf7r+9FURQM5WVo80YO+NYatMz95hn0399Gxw/uQ9JqKPrm7aCq3ZI3zsmnnjyPo6818+4D+/G0bKF2dSUlc4toequFi781GYMldb/Rrn6OfOcx4r4wpvJcnLU5WKvzaHl6N/mLaii/vRpbYUpJiHX0ENp9mGhjO38tMVIwJY/CKXk0b25HW1xA3Y1z0dtTq7+ckIn2hwn3hfB0x4i4Q/RsaaT1lcPszNdRN8PC0vOdrLw0FdMRD8cJdAXZfjREV2eC7vY4xw7H2PrMiwDobUbqbpyDsvIsJH3qXuRghO4/v05g2xEAnl+Rw83/qRqgIUiEorStXU/gYAuSTsvEr6zCMbF4RFk5lqD/cBctzx+g5cWDbAPyamyc/Y0ZuMpH5nTpb/bRvrOL/mYf45cVctl/zkKTIesnHorRtekEepuR4rsuzZj5E25vpf1vf0JJJCg499KMDPuJSJiutY8RPHAQJRpl6jfOGlRcRkKspwf3K6/g37EDy6RJouIyknxnD92/XEu8oxvj+BrsK5dllA8fqqfn3oeRgyEsi2bjnJp53ZTjMU68+Afypi7OKAcQ93rxvPgKvne3oMvJofD8KzPLuz30PvoEoQOHsJ+xDK1xZBbkAURb2um+/4/Eu3sp+Fz6tQCSxWu9PU0EPG1EQm7KJ65CMmWmTPDv2EH3E3/FUFSMPj8f/BnFTws+jGyjxx57jK985Svce++9LF26lAceeIDzzjuPAwcOUFmZnmH98OHDQpJMQUEqtnLTpk1cc801/OAHP+Cyyy7jqaee4uqrr+btt99m4cKFIzU3Ij42AbtNTU309fXR1NREIpFg165dANTV1WGz2VizZg1Tpkzhpptu4ic/+Ql9fX18/etf5/bbb/+HMo2KimcS8Hdgs2fmDtHoDZSdcw0nHvs1jKLoSJKEqbIa6/jJBI4epH/z21hqlmS8xlEynoo5FxHuH5up0phfhMZgwjV1/ujCJ+uiKOEIkYbM7jJ9YS62uikkwkEiXe00Pvwrir5wJ/q89OnMlslTMFVUEao/SqynG7M2vQXMNLEa+9y59L34IsEDB+h65BEqz7oh7UZhKXXivHg13fc8RKy5A++Lb1IwLT3jr6G6BEN5GaHd++h95AkMlaXoi9P3R19YiNbpJNbRQdcfH6b47jtOMncOhyRJWOdPx79uM7G2LnoffBJlwVnDFF9zjpEZV9Ux46o6uluj1L/ayOZf7KC/yUf37k4u+595FE9yJcejLJcZv/8ciXCMcEsvUlsbvvpuQu39NP9tF398dg/TrxrPwjtmYLDpcV6wHOcFy1FkmYWWzXTv76X7QC9tWzqIBpppem4/dTfNo/qy6aCDTd9+Fc/RPkw5JrQuK0ZXcnOQtBomzbVyzrW5zFxm5+D2AE99++8EupJU0NZCC+0VYQqKtBSW6Jgyw8D6dXEqL5hM9aXTsJY5OdSlI94fwL/5IP4tB4nUt2GeWIHGZKDw1nP40pf7ho2Noih07O5h39+OUf92J/bZtUS7+qn59ysonSUGxbYeDbD95V6Obu2nfv9WbDV55EwvQW83csYdE5h7bS1a/fB5I0civPvLnRx5/gTzPjudsgXFnH1z6YiyA31qfGoPxx/ZwZQvrcDoshBMo8RC0q3U/eSfiPZ0kn/WhSfvceTdQlEUgvWHiTQ2oUSj5F5yEWXnpy9vAUkLTWDfPpAkci+6KKMsQLyjGyUURjIayL31qoxKlxJPEN53BAXQFeWTe+NlSM3p1zNFUWjZ8FdCXc3o52f46DkJjdFI+PgJkGVyL74AjdqMMwKiLW0gSThWLIVRqp1Ieh1yIIjGasE8dSK0ZZY/tOkhkGDq8jvQGSyZqg+Q8Pvxbt6MEo1im5P+o+e040PINvq///s/brvtNj7zmc8AcM899/Dyyy9z33338eMf/zjtdYWFhbjS1I265557OPvss/nWt74FJEM33njjDe655x4eeeSRMfftY6O8/Md//AcPPfTQ4PHs2clJtH79elauXIlWq+X555/n85//PEuXLhVI6v4RVNeuRpLGFhJkLR9H7swlZKLWH4CppJyym24n1HiCvo3rMfpnobVlJp8qnryCvoZdY+qLJGmwVozDOXl08itJknBddA6SRsL3xsZR/eE5cxaTM2dxsm5Kv5tQ0A8ZlBeN3kDxzZ+m/fe/IdLeBuWZ6fidK1bgWLqUSGsr4RMn8J84hH1c+mJ15pkTKf7uXQTe3YXv9U3YbLWYq8eNKKsxGii8/Raire0Etu3E/bfnyL/tpmStphFgLCuj7F+/TrSlBf/WbXhffhvnBSvT9kXrslP4/27D/8ZW/Bu2cuLpA9ReNrxW0QBsxVamXz+JaCCGp6EfKRzh9Z/tZ9ntE6mal7JGak16rHXFOKc5cTQXYx9XgKnYwfTxMSz5JjRacY5KGg051U5yqp1ULC3F6DQSseVgdJkx5FiIh2Jg1bH0x6kNxx9LjkGgxcOkO5fyxZmp7KDqiWZW//dKLAUWdKbkcnF7wRuD5339CY4svwqdWXRfho+1EqlvI+f8RVhnVCOHIsihKIaiHCTptWHjse77m+k56mHq5XUYb7kCSLJE63NsqGtouDuiaDRw0Rcq2VO4DK1RRzwUo+bKWSyoHc6BrygKgZ276HvueWxn5XP1YxdgchqTVjXjyBbNRCTOvv9dT6DFw5L7rsKYZ0WSJOozlRiTZeRIGEt1Hc5ZmT8eeta9QLCxnsJbbyZcfxznmWeQqZhQwuun6+GHk+SQgKGoiAQjk0QqioL3pfX439lKwVduI+H1oS/MgzQhLPEeD933PorW5aL43+5CicXQmDJzIEU6Wwl2Jt24Omvmj0M5HKH7d3/EVFuDY+liLDOnw6708oqi4P7785inTsY0oQ59YQE0ZvwJvC9vwLpoLpa5M5D0mQkJNXoDtbMvw+IoxuLIvCZBUumNdXfhOussrDNnjSr/ccBAVu0ARgqfiEajbN++nW9+85vC39esWcPGjSJLtxqzZ88mHA4zZcoUvv3tbwuupE2bNvHVr35VkD/nnHO45557TukesuUBVBigYq799o/QmpJxEDmHxCEy9aaMwb7K5IuSiIaREzH0JpH8KKAq+zGUBltRFGQ5hkaf2kDtqvXLryJRNXeLx5Fc8TjqUIi0tmIsS14oq1Kp1U/bmpvcGLofewPniunIrpHN8wCyW7XRW8XvFVODeF5/8v1IRMIEmo7gqhXr9njnZQ4I1LaKqZhxu/h7+oLU9YosE9kbTC50A39T6ZKawpR8PKBBiSfQGJLPr7xcDMhpOSGmkMtyPFmv5qTFoK5WtITVN6UWQSWRIFp/DPPU2sGvXaOK8j7YrzKDh1S1ZFR9nzm1QTg+1iu6Wy2GVPvdx0WFUlcgfrYur6kXjn9a9qpwfMmB64Xj1k7R8mGzi88tGBQXvfMn7Bf76hf7elWxmDr9ZMccYoEoemty/nyz8gXh/Gd2pNwAf5z7B+HcjVtuE47lhKjMyT1GPK+sI7T/ALlXXcbSi8Wx2HJILC8gaRXkQIjO//kdhtpyis68QrC4xUpUQQ7h1HOLNLWQaOlNxmwNbARF4ljp65PPPREKoTEaUYakBMdKxRgUoy31W5HmLnwb27CvWJpKQnCIsUtGa1JeDkfp/sNLlIy/BJ055Q7xTRLXAs1JaoFoRwfhEyfImblYsIhpJomKne0F0bXSpW0i5vVgqR6H1mojWii2b61Pjlukt5PQlh2UzTxnsH1vlTjBgzWpewkfPYH3qdcpuvMzg+UNDG4VDYNjSIr5/gP0vfA8Jd/80qDiousX3yfHceGQfhUFheuQqj9DDO6drzxDfqSQwsp5g/33lybvLRENs/fBf/tAygMsPu/770t5gE0v/sewv3/3u9/l7rvvFv7W1tZGWVkZ77zzDkuWpDwEP/rRj3jooYc4fPgwahw+fJg333yTuXPnEolEePjhh7n//vvZsGEDK1asAMBgMLB27Vquvz61zvzlL3/h1ltvFWhLRsPHxvLyUYfWYEKL6ZSiuSVJEhSX9wsDisupoOCaM5AjMaKnoXCX1mjCMX5Gxsqw7xWSRiMoLmORlwxjT7aTdJkL1QmyWi2W6eljOrIYjgHF5XTAsXIZzrPPPLnxjJ6FJ1lMuK45D/OUOqS2sS+RxspyNAXp4wCGQnuykvVYlwtjRSGsSCpao8XhaUwGij53Mbp3Ri99AWAoLsZQXIwUOjXOElNFFSaqRpUz5hWRN+vcsbc7vgbz524fM6uwqW4cBZ+7dVSLyz+KwrMvIn9P4sMn8XsfywM0NzcLytZISSsDGMnFm24sJk6cyMSJKXKzxYsX09zczE9/+tNB5eVU20yHTwzPSxbvHadaDymLLD4O0BgMp1y7yzwlq3x+mDiVcggaoxF9fu7ogv9oXyTNh6+4vM9wOBzCv5GUl/z8fLRa7TCetK6urowZvGosWrSIo0dTRJfFxcXvuU3IKi9ZZJFFFllk8ZHHB01SZzAYmDt3Lq++KrqVX331VcGNNBp27tw5mAEMSWuMus1XXnnllNqErNsoPTSp+BRfpah1Ow+n/Nh9k0VrhZq+v2Cn6CvpmSG6HxSVNyKk8nxY28XjqKqemLqUfEIVF6Jzi4+4bKbYYFOrGB+h6UuZ761N4n3rVCEqcbOKar1O/G1ZK56P28Q3x2gRffbyAfHm4rVifIJtlxgnEvGKqbB6NefCNNFnH21NydtPiAPX0SlmleVOF2NgPB4xqLqxW/zSU2Jie2oPWTAi9n1itfgcDu9XBUfZxInkjYpfRka9eH5+USpYalrtJuHc853TheONzWKcx7ek1cJxf1Ds6/XTRW6VP+9aIBy78kQCQJ2qxK+aV+YXR0UeCJtR9HN/8+gVwvHQe30jIBYPrCsSg8AO7xLdNhVTxS+8Hc3iOBvs4qRJqJ5jLFe8l28veU44/q9nRG4K7TgxhzbXJgYbt7vF52guTckrMfF9ifSIz0G98Wi6RFeboU1s2ztZnCOVYtdpPlf0EcdVCQrmzeL7qImJHah4TXw/Gy4W4zFiQ5gU+s3iWqIui2I9Lq6j9kbxt/QB8TlEXGJfvTXi2OUcEu9NFxbb81eo1i7xlSBaJs6Lvqg41rbWZHuJ6AcYMioryX/vtY1TwNe+9jVuuukm5s2bx+LFi/nNb35DU1MTd955J5DMFGptbeWPf/wjkMwkqq6uZurUqUSjUf70pz/x5JNP8uSTTw62+eUvf5kVK1bw3//931xyySU888wzvPbaa7z99tun1Les8pLFmBH1ewj3deCo/OepPptFFllk8ZHA+xjzMlZcc8019Pb28v3vf5/29namTZvGCy+8QFVVMtapvb2dpqbUh1M0GuXrX/86ra2tmM1mpk6dyvPPP8/5558/KLNkyRIeffRRvv3tb/Od73yHcePG8dhjj50SxwtklZe0iHZ1YiwrH4x2TwdFUYj0tKMoMubC8oyy/wiC3S3EAv1Yi6vRmUYm3fpH0fb3XYQt1Rgn1Y7Jp6skYjS/+Vem3PDvo6aRJ3x+IDOJndD2Sep8RZbH5O/2NxxGa6tB0utH7bscipAIRoD3d/xOFXIkiqTTjjqnABL+4Kgp9P8MiHT76HljN+aaYqxTxxYM+3HGWAMX5UgEYlo0pxCkqijymOkfTgUJOYbbfRyYOSb5aG8XOsWA3u4ak7yv6wS51tEDg/8RJEJBtObse5YJn//85/n85z8/4rm1a9cKx9/4xjf4xje+MWqbV155JVdemZmocDRklZc06Hn2aXIXrsAxdfawtNXueSlzavDoARpeXIvRmc/E67+BtV00b/rKxY2q4N2kqVWjTQ59KF98BBFn6scUWaa7r4GeTa9inzCD0rOvwNohqs7qlMPcR9ppO/YWOcWTyS+bQd9k8bz7+VT5AqUzSu9Lf8Q+dwE5K1eh0Rso3Jbqv1/Vd9+yXDSbXbTrDqEvLUanIuyyNJ5MH4yEOf7bX2BZPBvbkoXIwSDGynJcB8X2/JHUOHY+9md0RguSRkve6nPR6A3IUVFeGmIJ9tcfILj9dcw143CdsQqNXj/MrK5/O9m+r7GN1lceJe+6q0j4fNgXLCC0SHR1KM2pBcy3ZQvR0ERinZ3oi4vRORzDKupWzU+S+rU8tQuNSU903BLkSBRkBV2uE3ziczWVBOjfvpvex9bhXDOPzgumondaiPtC6OxmMe1bUej99/sBicIzxlOwvI4rSsUc+q1e0c591JvyN778ykzi/R50OblIksT4hSJJRjQkbnivvzmT4OHDmOvqkLRacieLZCZ/PSoScykBiHV2oy8uRNJo6D/uEs7//aDoViqb3U6goYdQU5KDpbffAxoJ88wJaAx6+nvE62fPOUbDswdpePYg7gNdVJ9Vw9JPlyJJrfyteZYg632zUDguOkOsgdP3sliuw35GH4lghEhbH6aqQuyqdP+2LlVfpp0g4gnR+NxBwr1BvvrHZNZJ/qfWoM93og2L8yLSb0IOhYl1dBNr78bdFccxf9GgwmpWka1FQ3bkSAT/rp3E+t3knHvOoPKuJv0dKC0Qam6g743XKLnxNqR4SiimSi6SIppkSYmGJgJbtxPIL8KxPMWya24Vf2Ag/Tju8RCqP0Z4aj6GqtT4JcyiW6p7vpFoewfda/+M67yzye8R20sM8XrF7Mm2g4cO0fvM04y77f8JLm/HCdHN0zs92fe+115CSSTQTREJ/IKl4ss+UPjc07APR/kEvFWim8fSJcobvJAIB+la9zTl519PTOWONx0Xry/eEiaRiKLVJv/eOS/pIvsgq0pLvA8Mu+9LTz4ayCovaRBubSQRHJ0DWm9zotHpCbs7kWNRIPNXtdfTyJG9T1I76QLyitITsEEy4j4RDhIP+oh5h5NvjQSDyUFPyy6cBSOTtQ2FzuZEa7PhXvcKhqIi7DMys0cm+r1obBa6f/sweddfgS5v1ohyWqOJ2tu+RtuW5+j4n5+DRkPx178IpE9lLrj0SjrW/p7QiaMkIiGKL7kmY1+Kll/I8WceoO/1l5EMBnJWDK+nMQB71USqLv40jU8+RNztRmu1YiurGVFWSSSItLXR99KLIElJmvcbrsdWO7KrzFqTR/uL++m6/ycYKkuINraRd/tVWMZNHybrXDkT8/gy3C9tYf/nfotzfh3hll5Krl4MU1NfrZIkMf+BG/Ad7aL7zaPs+fYz/MgcY9aaAmatKWDjE+0U3VCMKWc4Zbr3cCfBI356nvkbSjSKsbIKzVEHxWfUYa0Q+Vpi7T103/84ens+kcakguNYvhxnVR1ay/Dsg2hbD/E+L5G2OJ6nXyThC2CsqcRYWYV17mwMRYXDrgGIeoK4tzVw4v4NAOhLC8i/4/JBjp3hz0DGd8KN+0AXzro8Fn97WVprRN/2d+jfuzV5XpIoCU+mYM10QV6RE8SDAeIBL8q2NmJ9ftp//xpyOIqlpgD75FLKrl6IsXA4T4eSkOnb18HxJ/YS7glgmlBO6b9egy53ZE6P0P6jdP3fg6Ao6IoLKLvpjrSWtli/m+5XXsW/ayeSRkPZN76emQU3kaD3jVfpe/M1Cs6+cFQLTbj+BL1/eox4dw/GCePIuyR97RhFlul75eWkEtXTg33+AnLOGz6HB+UVBe+b7+B++lkkoxHLtCmQoVaqoij0b1hP3wsvYF+wcFTrqiLL9Dz3NP2b3qbkltszyg6g++BGeg9vxlU9etkVORal6W8Pohuj9QegoWE948aNziZ82vAhMOx+lJFVXtJA0htIhIKjypnzy6i9+A7qn76PcF87djK7jjRaA/lFUwj4OzBZctCOwgtRsPhsIj3tRN2ZqD1T0BttFFTOw2wfPe1Mb3dhnz2PSEc7vh3bRlVeNA47ksGAEokgBzOPjdZsxbFqBaH9h0h4+um693fkXPgldOY0rhtJwlJdS9zXj3f7ZsyVNZgqZqX/AUXGMnES0Y523OtfxTF3Plpdel4Lvc2FvqiIuNtN918ewTjn8+jzXcO7odWSf+mlOFYso+3/foYcDtP5wG+IrFxF7przhm1EObMqyJlVgf6oi87/+i2yP0j3zx7CfuYKci45f1hJAUNZPkW3nU/Np5fS9sg7BA62cuz7T5B3gw/XRUsHNyRJknBMKMIxoYja25ay0PcOu17p5g9f209HfRDT80+z5N+XUb6sQmi/8bHt+HtMSJKGRDiMxmjENaUYS9nwe9UVuMj/zOUkDvUTPHgQJR7Hv3UrzbEmSm9YjiFXHE/PC+8S6/IgGeyg0YIso3U5ME+cMIxjJ9rZSfDAfgL799Ps7SJ3QQ2WmnxyF9SiPe/8tIpLtL2DDb9+Clu5kymfXUDFmvHozSPL9r1zmJ63XyMR8KF35lJ83lUUnjP8Pn1H99H55nPorA70x4zocqxorSY0FiN5yyZQeM70Yfcad3vxv7GNV97ejK3CScWaCUT6QxhuugqNfviyKUcj9G97l74tG9DmONC6HBR++Vb0geH9GYRGQ+jwYZRIhIIbP4UuDZ364H0c2EPfm68l58aseRllFUUh1t6Z/OCw28i/OX2pDYCYp49wwwliPT1YJk+h4PIrSUgZiJnkBPGeXpRYHPuyJWlLZwwg3tODb9t2UBSs00ZXLgIH9uHdvhUkCVNVNfSnl1UUhfYdr9C+/WUKp68ctW1FTtDy3J8Itp6gYMnYlJFgsIem5reoqVmNRpPdNj8KyD6FNCg69zIinaMUyDgJS1ElNRfdTsTTA47MyovDVYHDldpwRinZgSRJlJ17Lc3PrB1TXwBK65ZjNLtGlZMkCdfSFZiqa+h87M/EfT4gvf9XkiTyrruCWHMrieBoPQd9cSFl3/8WkcZmwgeP0LVzHSULzx/xS1RjMJB35jnkrlxDpKONwKF9JLx+tI6RFRKN3kjuyrNwLlyK560NeN5+k8KV548oC6Cz2im+/TPEPR78O3bgeepN8m+9IC35nD4/n8of/idKLIYSiUAgihyNDpKLDRsbnY78O685SYMfRnHHiXV2YygbuTaW1mLEOX8c+lwbsR4fgWMteF/fhmP1vGFf1JIkUTbRRtlEGwWVZjY90YYnbGDXb3bgb/cx8YrJg7LT/+N8TmytILB/H6aaWrQWC3lzRuZWl3Q6DBXFKIlCyr76VfS5uSO6jQZQ+JkLAYj2mgjtO4yxrhqNyTisQjdA/xsb0Nis5F14IbUXG5C0GsKdXkxFDlq6hisjiizjfeNtvOs2MOdrC6g4a/yQ+I+RWTftU8up+fRX6dvyJgXLz0FjMAKdw+QcE2fimJi0bOnO6EuWC9jfhHVyBTbz8NKJvQ/9ncCWfdiWzmLpzy7CVuEiHoqhNek42DV8yVQUhZa192EoKKboX24n4fNjqCpLlp4IDBMHINLdQfNffoNz1Zkk/H5sM2eOGksZ6+nCUl2HPi8frdWWVl6RE7Q/9WeiQTdFX7oDORRB53RAbGT5RChI05/uw7V6FeZxdTiXn3HyHU2vvETdvQS276Lws7eiyxudY0WOxZDDIVxnn415/HgYpY6tzpm0CtumzUBrMmdUXuRwmIi3DyQN9tLR+XkS0TAagwmtyYwxd2Rr4bD+6IxMnHApshz/0JSXD6Mw40cZ2fIAKgxQMU+7/UeE+zqwFlejD6r8pb4hx0OGT07Ece0WF373EtHnLqvmfbBQZfpVPQ3DSc9V1O9Gb3WhU63j6smojnGRVIy5RpX3KVScbEAOh4l7vbhiKYtNqERsXDYmj6MdHQR27MJ1gcia6TwibmIBFdGvQ2SlR7lMTEf27hcXQVm1xxl7VfEFBambSwRDaLVmYePX+0X5cGFqMTZ2aABlMIBx5rki1fW+ZyYKxxHR40L5vFbhuO1d8WZdc8UUXqdJVPaa+8QGc9QptfUipb6jXFztQ2FVmuz2lEUrPEv8rURYFTukiscx9ojPLTJBzInX6sVNrKpAnET1B8R7P3fRLuH4xZ1iWYiicrdw7DSFOPCTV4n0+Jnyr2dTVSHOu3eOp+IdZlaK477zQLXYV594r2rqAIziCyH1i2OhaBWiLW3oCgvQGPRow6oUeLPqhTIn21di8WQlbY3qhfSrXviTKfBKNEa0pQOrpW5QSTNMEHfooWnWiqJw7Nt7yJ+9Ao3OgEanI6b6zgiMS2knwe17KbDOFD4U1GuBb0JKcVNiMapeMQgBw30TxLEMDYkz6fztg1gWzsE6N+Xu1KiU2PL1qbHf2fE4lqnTsEyfhiRJaFWxIrVPiPe+0/cKztKJuCqS8r2qWOC83eJx30SFSEsThsJiNCYTJRtVVANV4nPoPvwultIqdGYbOqsdvarEVf+Z4jtU9oi4GPmLU+UB9qz9YMoDLDvzbnS691geIB7m7fV3n9b+flDIWl4ywFpcfUryA0G4pwMG28Bmd3p0TY3JhMFkgtbRZQ3FxWhXLD8t/fhHobWYkaKnxqL6yQpf+3hj3G1LMORYTj6XkYslflAwlJeOLqSCNIIrKaO8QY+xtgI6Rqf7h6RM8eKxU+xb5k5HOnoKJS1OZi2NlUm24JZPgWXs7edfc80pseZWLbwckMbcH0mjwVRZPeb2c2csGrNsFh9NZJWXLP4haG3W06RGZfHPCGPuh5vGnsWpQaPXI6epaj0STkVxAU5LSvfHHZKiIL1HR8l7vf6jhKzykkUWWWSRRRYfdcgn/73XNj4hyCovaRC1g3YwW1TFh2BNHatjWDoXiP5/kxj6MIxPwNEgasJ9U1XyAbXZVDw2qWIr5UrRV2vdKgaYhopFeVuzipthiGvX3iCe80wS+6pRuWksXeKbYfCp2xaP5RfF0gQG1dioxyqu+jg3dYhfZ8GJIqW3pkoVoRhOPSylRzR5b9s0QTjWzhPT5C8fv0c4fvxdkQ1SFUpBV7tLOO4xiYHHsluMWQlWqvpqEhsMBMXU5epCMV7oxMzUWOiPis9ccYptaUvEORLJFcfCZhdjXmpzxd9q84m+8uI6cRK+tEUMUNDYxXvz+MX+dR8V54F7t2qOX5iK99lxsFo4pw2Jc6BkhlgOoLlJjB2y7xPH3V8rxsSYOsSxsC8UX+Bqpxivs/WwmHJ/7SyxlMLj++cIx8YD4r0Hq1NjY9gqkjr2h8XjmEs4JFwjznebS3yu4X4VD1OdKqbmJbHBcI74fgeqxLHJ3SuOTaBUVc6gQJTvmp163wyqAF2NKnbv8K3iy+46pOKv2qdae1ShTOp1Vh0LWPKyOC/azhMXQluHGCOT/3NVOYJccaEfaP+TFAD7cUPWNvchwH9oH3J8eJbDPyvch7cT6R9bKngWWWSRxT8jBtxG7/XfJwVZ5SUN4l7PmOQUWUZJZOBDGAF9b68j2tU+uiAgx+Mo8thsfZH+5BfyWBLIFEUh7vGcknz4aDJdaKz98XWdIBGLEI+OklYtSRx/+n6ifd2Z5YYg3NRA/95tY+4LgBIf23NKBINjGpMsPpqQx/icTzcSMZlo69jn9Omcc8l16hPkM0gDOREn2NE0uuBJRDwfo48m5X369wlB1m2UBs1/+Q0zrv42kiRh9IgvfctZyf8mfH66fnof1vFTMZdXYZ88Y1i1VHuLeG3HfNBXluJvr0fON2PIFc3a4x9OmaU9gRaO5zWTCAcpWX0FkiRh7hZnX8SVNK8qikLLa4+gPViI1mYn98yzRySOKl+XNDWHAj3s2voAocsuJu7xkHNmsrLwAM12su3U/8dDQXoffRL79NkgSeSduWZY250iKzy9azcT3tZCzuwl5M5eStQlntee1GnMi+aQZ9fQ+vSvmfU/l2M5yQTb84xIwDa04rbO6qT5jbX4246Rt/pcdA4XJS+J99s7PekiSITDtD38OywlVZjLq7FPnI6af2uoi8r98kvEHu7GdfbZKNEolkmTeLxX5SbqUpnM414SXi+GktJkKqiKP0S3X49n+yZM5VWYisuYdu7x5HWeEEaXGU9ETIEMhozE3T7iPR6MNaUk4gYiJ1oxVJUgaTQ0bxLHRjIp+LZsAY0G+9lVaO0Woi3d6MvyoUVFwNZhRkkkUGQZjV6PrSpp0w83dGKsKiSxWUzj1pwvLvD9QTPR9l4kjQZdoYtFFeJm0RkX53S8OwqJBBqbFUmjoaDII5xvbxNzfqd+dj+KrNC+rY38KQVsakn5UnX9qkrlrniSkK2lndDO/XT9qpXii65GZ0+6XHQO8X0JFSaPYz09+HdsRx/Lxzo/1b5UJLq4Cq1+Yr4w7euPoSgK6z12kBUscyagL8zl/JmiO/HRnfOJdffh37CFwObdFN31GeT+lKtKXXXe0KVHjkTw7dyGrryPssvnDp7reFfMehpI55WjETx7t2DUzEFrSY1dtF10ielOepWCDfV4d2+jpPIKIXun5VJxsTIdT7om40E/weNHsTtL0VpT89ITEd1QBTsg7OtBkROYnUUE3Sr3Y3tq7XNPTH4nK4pCtLeLqN+DtS5FR2BSpeub+pLXBvs7MFpyiBarKsqLnkZkfZI1t/0vD+FatIzeyarU6Okqf7kGYl4P7W8/SeV1d+CtEOXd49S1FpKKUe/2N8idsQS5MOlfT4ge1tOLLMOugKzykgaxoIeItweTMz2lvdZuI2/52bQ/9Wf6jSaMRSXDmEaHtdveQXDvPhJeL8bKCjDmp5XVagz07noHORJCYzBStPzCtLKSJFFz6Wc59sJvCG99FxSFvDXpSdvM1nxmzr+DnS//nri7D31uHraZs9LK68xWCi+8gtaHHkDSaHDMno/elZNWXonHURJxIt3t9O/bRu7spWllARxTZ5E3vY+d//ok425fdpIRtiKtvKTToXfl4N2xBUNBITnLVqWV1ZpMOOcvovOvf0HSG6i65YuY88vSyudeeim+dzbS8bvfgSRR9qUvoa0d+blGujrwbHkHTDr633oTfWEh9llzsJ4/BX1hirdGjsWIefrw7t1JtKeT3mec5E4tIuIOEfGEqbr9DGw14lyIdfbR++dXiLZ0Y6gqQQ6GQVHIvelC9ObJ6q6gdTjw79hB3/N/x1CWjxyLo7WZybv4umHsrbGOTtp/cS9aiwVTZQ7Gsjz8e06gMRvIm34OtvFThIyPRCROsN1LxB3Cd6KH8LFWPH9/B63DQnBaLqWLyplw+WQ0OnETkiMRIseP033/w6DRoHXaiSytofLW5ehsyY0x1ttHor8fORxGDoc50n6CWCDG0b8fwdvUj76iBNPEamxnLMBsEhmplXic3t89RnDbHtBpqbz5rkHFZSQEDuzH8/rrRJoaMU+ahPNTmVP+Y74IXe82cvQPm4n0BdE4rOTfdrHwbIciuGM/3b/6M8gyOTdchL44PQla1NNL95tv4tu+FY3JRN0fb8rYl0QoQN/2t+nb/hY5s5dgsWQuKBhz99L9ynP4D+ym9PrbkELp044TvgC9b76J/+gBwi1NFJ53maC4jARFUWjY/FfKZ12QUQ4gcPwI3j3bCB4/iiLLVHz2S6NeE/S0U7/pUaaf99VRZeVImLaHHyTUcJziq29Mx2s4iEQ4RPNjv0XvHJ1gDyDY3kjrK49hLq5EazJ/kuJeP7bIKi9pYC2sIdDTnFF5AdA5cnDOWoDv4B7a/voQFZ/9Ehq9Ia28obQEY1UVwb170TqdkEFz12kNFCxYRbD1BO6976IxmKgad1ZaeUWWMdeMI9bbg/uN17FMnIzJMnINHwCtVo+pqpqA30f3k49jLC8H0itT+tw8HLPm4d21jd5Xnk8uEmkg6XSUnn8dOqudvm1vEuntQnJlZrMsXDGeSI+fAz98EdfMcirOGM42OwCdzU7uqnPpfOLPeHduw7U0fW0jAL0zB+eshfiPHaDlsQepufkr6GwjkzRJGg2m6mr0+flEW1vpePBBir/1RbS24em8WpMZU1kFsVA/KApyMES0swPNXgPapbPQmJJzQWs2U3jOJUDSFVhW+S59+zpoe+MEgTYvnVv+ROkF06i9eTGGk2nD5klVlP/gduRojMC+Frp+8ReUYJiO//wt/umzyD/vYvRO12BfLJMmYZk0CU2Zl+Ceetp/8ihKLE7o0E/Iu+RibAsWDI6noayUyv/6AQmvD72mgUhLL+51u5GDEVqPPYRt/DSKzroEvSPZvvtgF/t+9Q5Gl5mgKTfJHgsYKgqpOaeaypVVwxSXtp/+nHhPL/ryYjR2KxqLBdfFa6i5vARpSNVB/9ZtRE40IJlMaIwm+iMB9FY9OpMOc54Z/ZQ6rEtmoS8vApWVP7T3MJH6RiSziZxrL8ZcXp1xHiR8PiJNjWidTgqvvW7EFN5Ylwff1sP4tx7ieGM7efMqyZtbgRJPYLjuKrSOkdO645EEwe0H0Tps6EsLsa9ePMomKuHbuR05Eqb4+pvRWYfXkxqAIst0bngOz57N6B055C8+i2ha6ZO1it5Zj//AboylFVgnTIHd6bdcJZ7Au2c70d4uXAuWk7NgGRlpbYGe41vxdhxDUTJv5YqiEO3pwrt7G5LBSOUtd6HPzct4TcDdxqF192MvqM0oN9C++60NhE7UYyguSbJgZxh3OR6n5YnfE+lqx1o7Mb3gSbgPbKP1lUdBkak4P/2ad7qRZdgVkVVe0mDcypsI9DSPKmepqsVSVUvh+VcSrD9EqKEe6/jhX8VDkXPeuQT370c3ivJiNrgoWJB05yiKTKS3CzkWQ6MbudaL1mAi7+zzyF21hsDhA/h378A5ryytMmU0OSk6/0bkSBj/vr14t7xLXu15SJo0lPk5uRRdfi05Z6ymb/2rhFubMZWlt45odDqKV1+KtWo8/uMHsY/LrLwoioLOZsRYaMezuwVX1UEcNemLV1rrJlJ519fpeOLPRDvagJGp+AHMNeOwFY9DUWTC7S2EO1qw1aVv21heTvnXvkbc7Sawfz/+d7bgWLNymDKlczhxzl5AJOzGOn0m+vx8JElCqUj/YDU6HblTi3BNyEdj1KG36IlaHOgdphHjHjQGPYaaMoq/dRsac7Imj6HbhSZNPRlJq8VYXULZtz+FoigkOk2AghwMorWmNl5JktA5HVirqjFWFWEozsFQkovmeOWwTT1/Vikrf3cVAPs7ion19uO6cDGGkjxqykcuP1D02U+jsdvApBDcfQDz9ElIGg2SRtRAcs4VXZDzFx0AoGJ5JTkTcnnr6PANRpFluh97lEhnGwVfvAU5GMI0aRxkeGV7n3uO8NFjFFx9Dfr8AYr94c+pc+3L6HLs5F22jKnL7Wj0WqKeEAaXmUPtIysu/o4AL/3rm0iFdRR/9y6QlYzcJvGAj8ZH7yNnxZkkAgEs4ycCGcqRKAqhtkbM5TXkLzjz5DudfieKe/sJHD2Effoc7DPmjEr25v7zszjnLCTc3jKoZGeCIssEuhvR6k0wivIS8nbiP7iH3CVnYqmdgKmkfFTLhUajxWQrwJafufYbJOex1mbHUjcRc+3oBWkBzOU1xAN+DDmZP04B9DYHOqsDY04BpoJTJzB835B1GwnIlgdQYYCKedy//QitaWSzadXzKQbQtuViil/ZOo9wnLCJX1O905K+29Z3nqFs6SViqQHEVGUYnhLYo6LJVqczB8rF9qSwyJqp1rxtqsXePSUlULRF1ZaqL51TE2j0+rTnbXNSKbZyNE5sk1gs0j9eDAAoeDepNMmJON0HN+Jp2kfdBXcOKlMRlYV3IE5FkWXiHjfKVNGSYmgVBzNhGlLKwahKvYyJ4+g6KB77VTpaTBVLYaoWc0F1b4quC7+K8l6nSoGPlomxFuq+q1Pq5ctFin7P0dTgKHniZ6fdKQZMWwyq1OWAGE8QPyrOaecMUdno7VHlsAdUaaQ2sX3FL96LqV1Ujo3zxXsJR0V5aXfq9/RzPYP/37/xILPOyUVrSLV3+Hmxtk2gLtWXWGcPekcuaLWpd8KsmrQhsW/WYjFlPnRCnGMDdAH+3TtJhEKUlywRzqvpA9qXpGLUoq2tOJY5UWQ5WUF+v9h2VJV6rGuIgpxAY7EiSdIwSvvgkHdfjkZJ7DmBuboO6eT9Vj8hPsfWc1JWVkVR0MjJKuoDJQX6p4vPUVKVSrCd0CYTChJxtEYT4UJxjuqHUCUY+5I1lwbeZVn1PRVVTan8fcl7j8fC6PQmEkZVqY+cVF8UReHIqw9QcMkV6HPykDQacg+KfQnmi9d3vPMcrukL0NkcaA0mdKqcgv4JqeemJBLYtgVQEnGMjuSYhU/qPIlImCM//WDKA5yx+NvvS3mANzb9Z7Y8QBb/OIrnfzCl1cdKr/2PYKjiMqqsYexTTaPVUTRtBbmTF5KIRdEZRy6GOABJo0Gfm0c0XeW5LD6RcC6ZjNYw9mwRfVE+Uuz0JFjaZp6syD6yEWoYJEk66ab1jZl9Nl1R0JGgMRgw1U0as/xgNfMRiqZm/B2dDkapKD34G2ksupmg04++WUuSROmtd5zSWld0Rvr4wWHta7UYrK4xy58uSPLw+lT/SBufFGSVlw8JWsN706D/GZAdoyyyyGIsOJ0faR8ZZN1GArI8L1lkkUUWWWSRxccKWctLGmijoD2pzBtFlzzuKSkOgGCFaIfrnSXGOvRNVzWs0nx1QfGLoWCXihdmoXje2qry/aqSg1yHxGNJFn/PW6u6XhX0r/OnzrcvVcV1qLgY4naxr5Zm8bzlQZfYF1XMivaAOP0SqmSLoBgiQyRfjAGwNopmaFlV2TeaJ8pL8dS95YwTad69+8XOeSaq433EcVObX2MHxeeeWCYGJCitYqBntEA1djlB4TigiGmw3kliHMvKQjFYacffUv3vWSCOQ7BVTGn3WcXfNpYGhOP8Pao4jTwXmSBpxbEyHBctZpUvie23/Kv4XPp7RU6NqTViafP9NamJEe4XXSe7fOViX6aJwQtSVJwj4yeKbdfvEoOZXBPEl115XnxBYqp4zWi5mPPjmtclHHdsEPunVcUHK7tTcQfRceIz1rWLL0TCrPpqVlkb8naLp3tmi8+x4QpxsVBzzjiPi/Ixm+gWVlReH3WMi6lLVQ5kyKOKqsIr4ioaFbPI3k+wUPwxdSxgWBVna+lQH4su5ECRGGRj6lXx/xSIfc/fIR7HVVnpZeuTczoeD3OEDwjvB8ncJ8fwklVe/tkxNIju/YYsJ9CcprazyCKLsUOOxVASWiRtdsn/uCJbVVpE1m30HqEkErhfeoV4f2ZOhKGIe/qJNI2dwjrWffooxk88/Aui7p6xlQiIx4l5+oh0d44qG+psYe8b9yInRq/h5Gs8TLgnQ5roSH05WZJBkd9fKnhFlgk3NryvbQ6FHBmFPSuLTwzk2KnPTTmSib1FxFhLYySCQXr//Bh8RD4kEuFRyoWoEOptw3viwCldMxr3TBYff2TV8DToObEV69Sp6HJyhrl2hroQtLu7CWzchv+NTYy/4zuE88QhLd40JOVOUWhueZvWd/9OzrjZFK26cZg5sneaqE/6H3oG9/FdTL7iG+iMZnQRUckwD0m2kOUEbbtepmDCIoy2pBvBW6Oq5DzE/KrIMuYJE2l/4+84Zs/HNmU60YrU4qnpF+8ltG0PreuewDVxDuWrrsRxXJVOPIS01lhShjK+kH3u5zBPmYRl6mTMKv1kID1RicU48dRvsZ0zD9fFK4h1uTGUFmDaL7oIdP7k4qsoCq2//iWhKbOJdndQdNHVSJJEXOUOMfQm5cMtTcTcvRBPYCwuwVhcRp8q3VdTnrTnx91eup5+FH1FGbnXXkC8uw9jXRUEVem9veJxNOhBYzShGUiv3y+2P2C0bnvkUZREAvt1Z6KxWdCYjGgdNiL1ol3dXNxJtNODsTwfjVE/WNk52OHFUuzg9TfFnHl9eepZnDs3SVmfiCVofLOV483L0TtzB4MaE5HkHIt0tuHe+AaWcxahsZiTJGylxXScI5rc9Sr3xbhFyZQa3/EerJW5HD0scnGULBVdM8dtKV+LoigYtyiita9S3OTbHhWJFZV5qf44ckX3WkKWSPhDhBs60TksWHYUozNaBtv3rxZTnY80FBHv7kuOhUYDUg+STofWnnTrhd4V3UTak94+RU4Q7m4noS8Usuwqy1XpxxvLkeNxvNs2IYfD5K6qEs4bPMIh/gkxYm2dBLfvJfJwPQVXX4s2L+lTyTkkvuv9dcnnF+vrxf3WelwT52CpSJG4hV3i+6g4YsR7PXT94vcYasox94nnQyrXS9dcCUWWCR07RmDPbuzTl6EvTgkVvKkqvzEradGJnDhB6Gg942OzsNhSXE6ecUOquJ9c1vqP7QFZwZgrzl9jv3ivnWfEUWJx+p9fh++Vtxj3+X8jOsTVZBWnGMGTFE/BxuP49u/Ce83FQuaURSWviyTnor/7BPbCWpwnVJXXI+JxIqDB23MCR35ybnbNS06MREQLW/hgkA3YFZBVXtKg78mnkIMhctacnVFOYzAhx6Ikgn7ivn4MOemZIyVJwlYyDo3OQMQ7eopnzOPG136MWLCf3sObKJqRngIfIORuo33v63Qf3cL4VZ/GVpCZ4EkOh/Dv3UmsrxdL3YSMsoosE+nrRI6G6T+2m7IzLiOT4U6SJFznrKb9f3+B/90tlP/gO4BtRFnHuGlYSqpp2vsEbd+5j4QvQOn37gRGTg2VJImi6z9F66/uIRHwYyqtwDVvyYiyJy/At2cHgaOHkDRaii+/DkPVyESCuhwHZT/+Ap5nNtL+3V+gxBPk3nwZ1qmzRpSXYzEiHW0EGo/Q98qL6HPzMJSWYa2qwzl30bD6UiVXfwrf3p303P8Ykk6LkkhQ9I3PoEXcSaIdbjp++yKRlh50Tgt9dS7stXl0vFGPrToX7dxLMZSkSPnkaIR4wE8i4KNhQzPBvjChvhAHnzpGoPNNtGYrlqpxFKw8H11JcoPRu3IxlVXS+/BfkSMRZH+Q/FuuxbJkeIpt22/vQ47F0FqthN8CQ46F/gPtBJrcmOYtwrZkAbq8kanWe55+Gu/GjSDLaKxWStZciWPSjGFyiizT9+jT9B7rQmMwJUkXJy8C0s/jWJ+P0JEWOu59loQvqQ07q6dRvvRSDPbh/VHCUfoefobw3mSkgqGqjLxPXzGovAhte/ro272TYHM9wdYTFCw5B8us9GUl5HiC/q2b6NvwKnI0TPVX/i2tLCStA+5H/47vtXdAkij+9G3o89KvH+G2FtxvrsO/bze26bMExWUkRJs76PrfB0l4fDguzMxArcgy7ldfw7tpIwmvl7xLLxUUl2H3mojT89hT+LduQ4nHyb38UizRzCSUoa5Wml/8CzVX3JlRDiDe56H752uJtbRjXTI3LRv2YNtNJ+jZ8DLB40cov/Gzo6Z8K4pC085n0enN2AvHxuLbsPNppq36IpoPy/WmwHuuS/DJ0V2yyktaaLX4t2zFddZqIP2LYHDmUnnJrTQ8fi8xnyej8gJgyS+n5uxbaFz/l1G7oHflMOmSr9C5dwM9hzZTOO0MMisMGsrnXkjU30fH/vWUzjgbatIvtlqLlaIrbqDlwV8hhzNXGJM0GooXn4eluIrml/+Mv+UoJsfo1Nq6vFyiza0EduzCVrssvZzFRt5NF9D2vQdIuH10/vRhLFd/GY0hDWW6JOGcswjf/l10vvAUxuIypILyEUVNZRXknXU+Cb+PWL+H9r8+jDNyJs5LVo/IsSHpdDjOXU6kvonQroP0/OYxtF9wYBo/fJFL+H30vPocWnvS0iIZDFjqJuCYOnfEwpiSVotj1jw0C0tov/tXKKEIHT+8n9LP3Im+ILVZmOtKqfnv25LVv3u8uPqO4avvJdDaj+9EH6z/KbZ588i78EK0djtNa3+Nkoijs9qpb4lhzjVhzjNhzjURJ4ec2YtxTJuD1mhiwM6hMZpwLViKcfVM2v/rFyiRCN0PPISzczXOS1YJY1N47Q0k/H4Sfj+5JSeIekLE+sNEegLEN24h2t6Bc80qjNUpRaP33XoaH36XYEcIZBnL1KkUXHklFnX05sDYaDTEOrqItNVjyiulfNll2ErH0afi71EUhZb/e4rggSYUwDy+HH1JLvoihfLJl2IvqxvWtvet3XjX7SDS0ImhogRJr8N52dk41ixLu9ElImF6Nq9DjoTIX7ia/PkrCWZY/ROBCJ4t7xD3esg/92K01pGV9QGEO5oJ7T2MxmbFftZSLJMyM3MnAgH8+3ajMRgpOG90Flx9aQEamxW0WsxT6uBYelklHifa1UnC68UyfTqOpcuQSe/28nceJ1xfjyLLOM9ajXPFcngtvXws4KXx7w+ixKMY7K4MLSehsZhBAo3Ngv3sZRk3bTkew/3umwSPH8E6fgrWuklEMzwnRZFp2PokXUc3MWn150bpSRJ+dzMBTysBTwv2vOoxXfN+IxvzIiKrvKRByRc+T8/jfyV8/AR2w/DFcCgsZTWUrrmGmM8zprYd5RMpXXgh8UgQRimuJmm0FM9cjat6BlG/G70xvXJkyS3DkisqK940sgMwV1aTv+ZCEn7fKJIn+14zhfHX/0vSBz2K8qIvLKDkq1/E/ewLBDZvhwzKC4DWaaPk258huOswoZ2HaX/hcUovuUEoEDjYdk4OBavPJ3/VeUQ62gi1NGCaUZJ2IzIWlVD52a8AyXiZoKsPJRZHMo5cOkHS6Sj4wo1ET7QQOnAM7+tvoHXahxXe1OfkUvHpu4gGPTiXLMNUVYMkSWhG4cvTFeVT9t9fJ9rSQay5A9+2rbjOXJVyOw30Q5LQFzgpmliNoy4fS5kTc5Gd5o6paG22QVdQ9We/NnjNyot2DP5/zcoKdu8YXtZgKDRmM6Xf/Vdkn5+E10ci7CbR24+uIJWlpLM70NmTSkfJIiOKomCtyMFWk0dD16QR2zcWOqj7wircvmkE9u3DNuckTX3vMNFBuC48G/222eRNXpSWvE2SJHLOmkXxrWejcSX7FG7sxFhRiPlV14jXaK1mcq84A21FHYl+P0o8jr4oP+OXaLS7k9zZS0mEAhQuT1/kdACtT25HYzDgmLcI58LMc71n8+u4d24k59OXIRkMSddkhrC5kKeTrtcfJf/ci5C0WnQOBwTSywP4XtuErjCX3E9ditZlTyunxOM0P/gLjLXV5F12GbY5czPOl97jO2jf8xp5N15FvLsb26KFaWUHEPX0Jll8DSZ0VkdG5UWRZXp/8wimyXVYl87FUF4CDenlA12NhFoasU+fQ/4Zw6vdD2s/HsdozcVgycGWn768yVBEAn1Yc8qJBvsh8/dpFh8QsuUBVBigYl544Q+QNFr87maKE2J+ZNSV2vA6Fqb833G/D71FXCTMqlhbS2fqtVUUhbhd3Gx7VanVWlUlWK06nk/19ErfFi0ohmYx9dM/Xcw/1vvjKIpCb88h8gsm07EgZemQVLG2Q9MbFUWhZKu4BPnKRF14oKw9gLv9IEytQmdJNRJQUeabO8R7DeZEQVHQGJLj7ahX+exVVurYJDEQMK6ipbceT/UvVCp+yuXsFzfK0BpR7ZO2O1AUZXBRD9SI2oklV/xtvU41No1iKnXhFvFefBWZUzMjxeLvaVQxOEPLPiiqfcdQJu5ysbD4nGSvqMCZi0R5aatoKQlOEiehsVGVhjpbRfe/Q3TfqNPMozkq+oBy8feVI6k5EysTA55Nx0XLXP6yduG4vVdVYVo1OCV/FfuuTtGNnNWTrMekTc4PX5v4fuu8KflwYwOuRAkanX5Q8VKn9LqOJO/V03YIa14F7uWpB131vPjCNVyaaluJxVEOdmEqrxgsJ6BXfZmESlLjGPd4aLvnZ1T/z+3o85NjIG0Xn+PQch6R3k70ReLaoBPDiwapDOR4LMkQHMj87Tu0BICiKLj3voulvBZTbtEwGoSh5Tq8GzcR3XGIygtvGRxHg+rbami5DjkSwbHVg9HiQqNJ9inizJyLEnVKJCIhtGnYu0ufEwP0vLOLhWP3xGT7H2R5gFWzvolOm75451gQT0RYt+u/suUBPunQavU482uhM7NLZQA6m/2UfJIfFVZISZLIL8hssh7pmlNBTslkfJZTS247lfIDHwQ+Ks8riw8OGv3Yl0hTVTXalrHJukoH4orG9u0o6XUYy5M79ljKCUhaLSV3XTyouIwGY17RmJeudIVhM/ZHksidsXhMsvaFC7AUzRtz2QSN0YjZlj+6oArpFJePLLIBuwKyyksWWWSRxScMWrsdy9TMQfgfVUha7SkpjVn8c+JjM0N++MMf8vzzz7Nr1y4MBgMej2eYzEhfxvfddx933jl6dLsawSLtYLXamFW04TvqU/ZU11FV+uA0FcukysrXfa3oXjC+Kwb1GVR+b7NI2Dms+qq1Q9Sk668Wv4oszaLLS83waVcx9g79PUX14VP6tmjO7x8vjov/LDEtVfu8mMGhrgrtPCb+dkQkgh3G2OlZInZeSYgdzH9NjBdJGNQVt1P/r2bM7VuiYjc9Jg507jLR/xc+KH7phWxwD9wAAFiZSURBVEPicwyrPnB0AVUKvCqOOlyQviIvwKyJIi9Q/d/HCcfyktTECfSJzyXsFsfF2C7OkZhTxax6RDQna1UfqJIqhV5tPIjGxPORGnFszUfFl0I2qL75D4tjaRrihapdIlKpel8SYxZ6EyXCsUVFKRJTvT+Sioeob7FqHhxyCccak9hXRcUubBKJm9FGxOfYuUy8XhNKzYuueaILy6liy5ZVw65+l42qSugeWbzZksPibw+4PgagV8XQqFOp1Yy89oOiazSUp3K9WlP9sbeK42T0iG3p/eL5cK4q7Vt171YV7ULfJFU18A71c1E/NxVbuEm9HojzqGuB2J7txMn/+SBpm2TgvRp/P0H0Nx8b5SUajXLVVVexePFiHnzwwbRyf/jDHzj33HMHj53OsZlNs8giiyyyyOKjimy2kYiPjfLyve99D4C1a9dmlHO5XBQXF2eUySKJmN8DfLyDtrLIIosssvjnwyeuPMAXvvAF8vPzmT9/Pvfffz/yKBTakUgEr9cr/AOIeDPkc6rQtONZIv4+EvGxUXufSoJXIhrG31ZPpH/sJQLGAjke4/hjv8LbffzUrjtFOv6xUphDclzCnadWJiCLkZFNIvz44aP0zJREAjk69lIFH1dEA/30txwaXfAkTmU9e98xELD7Xv99QvCxsbyMBT/4wQ9YvXo1ZrOZ119/nX/5l3+hp6eHb3/722mv+fGPfzxo1RmKjo3PMv6cOwBIqKhAemekYjm84Vb6++rpfmUbtTd8mYp1olOybZl4ce5aaDz4MlVTzkOnNyHrVFWkl6SuT/h8tK17HG/jASpWXYsht2BY6qWjUZyMlX+PC7woocJ0vl091Suv59DbD1P4tduRtBp0BXnUPpZybPfXpvoeC/nYrdtMpKuNolWXoLc7h8UPjC8UFayWtn5aD75O3YJr0Wh16MKqGJchHj1FTtDy0G9IhINMvPyrSBoN7mWiU9+xJRm70bv/XVAUtOfNJLBrD7aF85EkiZhVbH+g4nbPay+gyAksljnEOjuxzZ5N7l6x7zFLKg6jd+9G4tPKiXV3Ya4dh86Vg/nXYkCOdbzqXnbtx1ZYg86YjDfxTBDPVywRq0Af3ZOPEo2BoqAkEji3S+jMtsFMjqDocmf7H2RMZZVojMl+RmtUSmR7Mk4k1tUNe44T6WzDOWcxBlfusLipvjmq4AVzgni3O8l9UlKAvluMSYk6xTkmt/UT7+vFVDMOSZKI5qjiCfpTMTaKomA5oWpvqpiDa90lxujohsReKLJM4uxUnmz9ZpFu36ii6VDHRvimiinm9v2peJ9EJMSJMyNoban3WdMvxgOpqx0HKsXnqo7L8p3sTzzoJ9zRgrSwWsiaMdhUCsERG4lQEO/2LQRlLTnzlw+e0q4RP6DC21MEI3IshrHNh97mGnzfPVNUKecn46bkSIRIRys9UQ22ourUeVWMS6BMQY7F8G/dSvDwQSYsuRWBYkn1qds3QYuiKASajiIhwXLx2RS/mhpL50ExmO/wZ8TFo2Cr2HjfdDn57L0+4r192Db24SyZgMGUvC5qE+VLNiXXClmOo9Ho8JeLc675UvF90bg1RNs76HjyNxR9+tNEp4jzxNQmzoPcPRKhvnaiAQ/OisnkHErO4Xg8zEE+IGSzjQR8qMrL3XffPaLiMBRbt25l3rx5Y2pvqJIya9YsAL7//e9nVF6+9a1v8bWvpQi+vF4vFRUVeFuPEPW7Mdhy0l4LoHflkQgHSQT9yLHRv1TcnYfoOL4Rnd5C1ZRzMspq7XYshRV4Gw8Q6mqGSQtGbf/Q7kfRaPUUl8/H4arKKGsrqcV+5hI6fvhLbGcsIufKzERc4fYmfEf3EepopuqaO5Hs6dmaFEWhu2Ervc27sLpKKJu8OmPbweYThLqbSUTD9B56l/wp6en+zXkl9Ox5B+/3X0AORwjtP0j+DdcAIxP+uRYtx71xA+333oscDiOHw+Q406dtKopCz5OPEevuRjIaKbr2RmBcWnk5EefEpr+iJGKUTFtF4eTlQGY+hsjR43T9+mTslk6HsuACCmYsHyYXOHKQUONx/EcPEOvpxjJuAtbJ0zAsnozWPpzBVYkn8O7dTuDoATw736Xsqlsxm0amP++857fE+zzoCl1orBaC7+7GPGsS+dPPxFJVNywAPtxwgt7nnkNnsRE4sA9DUTGOJcuwLJk9qFQNGxuvn2O/+J+ksmm2YMgrxFWwCn3hCNT9iox75yaiLS1EvL0kwkFKV1yKifQ09Z1vPIf38G60BlOSMXjRMmxTZowYvC8HQ3S+/Srh7jbCPe0Y84pwff2GtG3Hurqpf/TR5IIvaTDlF2O/9gK0aYglw12tuPdtIdh4jGhfF+VXfSZjum+0vRf30y/i27UdncNBzWe+nlYWwLdvF73rXiLu96HIMtUrrsU1QgkESM7hvjfX4du1jWhPF6aKKiae+dm0bStygv633sazYT0Jr5eSOz+PJKdnFpdjUdy7t9O3/S2URILaW/6F0cotKopCW98eSnOHl4ZQI+H10v6TX5Bwe0CrxTbv6kHFJR38/nb6vU2UlY5Omhc6Vk/Xg78HrRZDWSnyKJGsiWiY46+tpXLZVaO2ncUHgw9VefnCF77Atddem1Gmurr6H25/0aJFeL1eOjs7KVIRMA3AaDRiHGHhdVZOpefIZkrnnDvCVSloDSbKLriRE3/5JfIY3EYFFbMx2fJpPbKOSMiD3p5ZOSqefw5IEt6G/aO2DWC25IEkkYiHkeU4kJ6TQZETJPq9KKEIgY3bcV16Duk8iTqTDVvtJCS9gUhXG42P3kfpLbdjKBh5XCVJomrmRTiLxtN+5E3yq+YCIy+0ANaqOiZf+29079lA5651uGpnkq4sg6W4isriKhqPvED/q+sI7t5Le0cnprNvxZQ7vD86m53cZasI97QTPnaMnieewDgvSPHMkRWq/BlL0cyopPORP5Hw+Wj//W8wjD+byvGrRmT7RU7gKB6HpNESiwTwNO9DM2n2iBtX24v7aHt2L4GOEFqXE63TQf6nrqGwp3R4uyQp/LV2O5KkQdLqkiUHJGmwqrYahtJiXDMXoMTjxL0eWh//A8r8C8ifvGiYbOEXP02i30vc10twS9IUFTnaSE/fyzin9+CcvVC4X0NpGfmXXU5w3wECB/cn3XzH65H1MvbFC4exG8fdXtq/8zM0kp5EKIhj6mzylp1FonDkrz9J0hBsOY73wE709hxqLrodU14x8TTUs/59e/Ds2UwiFEBbVE7higswjq8eUXagP/2HdxL19OIYP53y82/Cb0z/Jep98x1Cnc1ISOQvWE3B/LMIWdJv6DG/F8/OjSgJmbJLbsRWM5EgGdYEScK/dxdKLErRZdeg0Y/M9gzgfusAvW+8S7SvB70zh9LrP40rVpJWPtrcTPDoIaLdnZiqaii76Xa0naa08pJGS6y3l4TXi3XWbMzjxsHR9F33thyh/ZUnQFGouu6uk33PvP51uPcRDPdm5EtS5ATuhj10rXsDEjIas5mC22+moCszy3ksFmT33oeZOOHijHLJ35AJHT6MHA5jnT3r5HuaXnlRFIXGNx8j0t+NzpSZEf20Imt5EfChKi/5+fnk5586udBYsXPnTkwmEy6X65SvrV5+HaG+1tEFAUtpFYVLz0GJj8IJfxL2nAomLbyZRGJs8sXz1qDR6pATcUZ7ZNUTMltzhkLSaMm59mJMU8bT+4cnCO09BEwZWVaSyJm1hJxZSYuIkogT1vhHlBWuKZmMq3gSifjoOYV6s43ShRdSOPNMYiEf4Moon3PBubjOPwc5FEb2+1GOp4/H0VqslNx+O4osE+/rw7ClnWigH4N15Gw0Y3kFlf/6LSDp/y9c70WRE4NMq0Oh0RsZt+Im4W8ezcgLtDHPxvgvrqRbmU344BFMk8YnN/00dTrNVTWYq2owVVZjLCkbVBCirvT3ap88A/vk1NetoSWMosjDFC9Jq0WXm4OuzIHWacN58ZlonDYsx0be5DQGA8ayMnRmO67lKweZjxOWkRd+rctO+c+/TfzFw5hKKzG4ksprguCI8gC5c5cj+4NUnHUdemvmYHLr5KnYbywl0HwM1/QFSJImI+28pNeRN3clofZGys655mTl6fTvYM6F52KV8rBVTsSUP5AEkH7xDxw/SN7i1WjNVhxTZmfse8IXpPX7a8lbfQ5xvx9zzTgymS60NhNFl1xNuPEEjtnz0VqskIEQz791O875S7DUTcS1aHlay9gAOje9RLjlBHmXXoZ12vSMsgCBzhPYx01FZ3dirUhvlRyKktzpo8bMxcMBeo/vwHXp+Wgd9mR5jOIi6Mp4GXq9henTbsBkHEN2qSQRaWoi99JL0BdmLiYJyTIRkf4ukDRojcMLeH5g+JBSpe+9915+8pOf0N7eztSpU7nnnntYvny4lRjgb3/7G/fddx+7du0iEokwdepU7r77bs45J7UvrV27lltvvXXYtaFQCJMpvYKtxsemPEBTUxN9fX38/e9/5yc/+QlvvfUWAHV1ddhsNp599lk6OjpYvHgxZrOZ9evX8y//8i/ccsst/PznPx/z7wxQMS9f8V10uuRANp8lvvi5B1NDpokn/1+RZWJhH1qVopS3RdyVDn9bNPU73xZJNPL2iytYzDakrLwio1OttZ46sW9hlXHDqOKdkFUfd7GT72Lc78N3ZC/2pSl3TcwlzvTqZ8VYiY4FKl6K46J8p8ozYzuu4jqpUZWhV8XEqPtauEXNBaHajFUvpl8VD5EY8pXtPKoqNaDyTNibxN/qmSMe21X3oo7/0av0On+12DkppuKxUH3QW1tUMTUu8Xy0SHwWpa+l+tO2UlV2oV1FeZ8rnneo+HY8C0RFU/KK1ju9V7x3WS+2Fy9UTdKoKG/sUPHAlKviUrZLaIYUtRxaBkKuEwM14h7Vpqzqi0EVuxCv8YEkpWjn94tf0uqyDFaVguCZIY67q0zk6PfvcgoWKHOneH1iZcqKFGntRY7WDJadMPSLz8HgEa+VVUZUNWV+XMXHEywRx6Jgh4pLKJCak32dBzFV1qIzpBrx1qie85DHpsgJXEdl5EQMrT65TnqrRHlLV+r3jB7V/FftOmqeFXOPOM7+UvHm/apyGhqV0adwh/iHrjmpxSTY2kDH289Sesddg/NAvXbU/bpBOK6/rphobzfGwhI0Oh0Fe5L9i8fCbHrxPz6Q8gBnTfja+1Ie4LUj/zfm/j722GPcdNNN3HvvvSxdupQHHniA3/3udxw4cIDKyuHV3r/yla9QWlrKmWeeicvl4g9/+AM//elP2bx5M7NnJxX6tWvX8uUvf5nDhw8L155qlvDHJmD3P/7jP3jooYcGjwcGYv369axcuRK9Xs+9997L1772NWRZpra2lu9///vcddddH0j/JI0Gg8U5arXU9/QbUmbz5nuBzmYnZ84S4qOLZpHFaYVmhGrc7xfSFe78MNo3luUROvHRKDuRWzSZqGHsyaeSRoukkdBqTu94ng5Yyqopvf1zYy4/AKA1mjCXjq2I4ycJ//d//8dtt93GZz7zGQDuueceXn75Ze677z5+/OMfD5O/5557hOMf/ehHPPPMMzz77LODezYk5/x7pTT52Cgva9euzcjxcu655wrkdFlkkUUWWWQxEqTTqCCfNryPMS8DlCADGCn2MxqNsn37dr75zW8Kf1+zZg0bN24c08/JsozP5yM3V3QJ+P1+qqqqSCQSzJo1ix/84AeCcjMWfAyf4AcDb40RrSH5MCtfFl05UVfKhBnKF7888reIFXX75ooxPXpVZWRHg2gy91eIPj9rq2jCb14tns85rDYFC4dICZULQWWO7Z4h+masniFtvyH2LVAiyupUPnq1KVjtWlGnnCsqE78cV32BqoxM/ePE9tSpnup716i8F/YTqfZ1Kv5+dZppZLxodnZsFcfdXynKJ/LEHwuFxXlh7BaPwyXic9DZxOt9uaJ8wQbRbO42iK9u15zU/7sqxTkoHxEXDl1Q5SaaLtoL9W0q+n7VcxpWtdoj/sHSJj7o/univSVMYnsar3gv6rIUQ+VtG8WYg7jKRZ5QuU7UCTO6I6JfKFQnvl+WQ+K9q+c0qrISxsfEgPuig+Km0HCxyjS/W4zJyDuR+gGfKjnQ4BN/3HVEtQ7liOPcdJ7YN+ch8ebVrslAkTjuYXX4oer9U5cuGVZ+o1ac0/KQOaouB9A5X+xM8bvitWqKiZq/imnjMauY6eieLc4xSbXYmMRXgkC1OOdNnWJ/QtPE+h15B0R5b2Xy3hLRD3ALlZURJuQ/0AZQUSFakb773e9y9913C3/r6ekhkUgMS3YpKiqio0PFIZAG//u//0sgEODqq68e/NukSZNYu3Yt06dPx+v18vOf/5ylS5eye/duxo8fP+ZbySovWWSRRRZZZPFPhObmZiHmZaSM2wGo3ZoDMVqj4ZFHHuHuu+/mmWeeoXBIYPSiRYtYtCiV/bh06VLmzJnDL3/5S37xi1+M+R6yyksWWWSRRRZZfNTxPrqNHA7HqAG7+fn5aLXaYVaWrq6utNQjA3jssce47bbb+Otf/8pZZ52VUVaj0TB//nyOHs2Qmz/SdacknUVaxCOjUTT9g+3Gw4RCfaMLDoGcGFvYraIoBFqOE2ga26SRE3FC3u4PlcZcUZRT/v3+7e8SOHLqPJhj+Z24200ikDllPIssxoJEMPCRKREQD/pRTrEUyOmAkkiQCAZGF/ynwPtRGmDs88tgMDB37lxeffVV4e+vvvoqS5akJxF95JFHuOWWW/jLX/7CBRdcMPpdKQq7du2ipCQ9b9FIyFpe0iC4eQtllUnTlme86EiPDnFbG5uC1L/zZ0yOQqrmXETDFaIvVq9KZyx4J4BG0p7kmEilWg9AF0o5muOxEJt2/xI0Gmqv+SJ6qwOTquTSUBeoosh46nfRengD08/8Ihqtjs75qrgTc+qRh4/W0/2btSiyzLTb/3OwTwNo/Iy4eLm//xT+5qMUL7sQ18TZw+7NtSnFi9MTasR/zSQ8W94hf/X5aPR6wtViHIlrm+iXjh04ii23cpAiP2YRTZP6kEzA3Ur9pkcprFuI8vmpyL4gGpsZrc2C63UxniGSmxxLzeQyOn/7EIEzF2GorsBYV42xTzST1v4tFfvQ1PQWPYVBNEYj9qkzMRaVIK0RFUj7S8k4Evfh47S+8yy2i5bhOGsxkcY2TOOryNshjqW3RhwrNAqhvYcwThyHxqBHc0KcY0NT4uN+H15bFJ0llWavaFSLUEVKefY+2EOoq4WC2WcgabWEVB9JCXPy2vCJExhKSjAWJJXd0MFGTJMq0XSIX2SWaWK+vWd9nITPj6m6JlmWQZUmbulI9U1RZBJP78FWNxWtMRmg4q8T4xOK3hSXoZaiZrRWM7qTQX5DY6ciKk5HaYieLsfjBIxutLmutGZtyRwn0tCGxmRAV5SH6Zg47sYhcR2KIiMlVHFWXvG5dqtS6MO5ybFLREJEvW5sbeJY+sVQCvqmQ6ynB8/69eibnOSdec7g9qIPiG23nJma34qiIEViSDr94L3qPWLbpj5l8D5iIT+mgPh+GFVD1F+nR45G6X/nTWI93eR8/kqGBr4YOsW4K+eJBPFYCDkRw2ByUPymas5XD/n/qtQ5ORZBd8SLwZF6mJ46cQ4MpIm3rXuGvDkrkCLiWqRV0UYVvZW8Ph4JkoiFcQ2tPQL0TRDbH/d4cg7KcgKNRkuwSE2doErnd0gocoK+Q1vJmTAHc39yXiSiHw1l83Tha1/7GjfddBPz5s1j8eLF/OY3v6GpqYk777wTSDLUt7a28sc//hFIKi6f+tSn+PnPf86iRYsGrTZmsxmnM/lMvve977Fo0SLGjx+P1+vlF7/4Bbt27eLXv/71KfUtq7ykQf3RFymtWDAyo+oQRPy9BD3thLxdVM6+cNR2+3uPc2z/M5TXrqCofB6aDI8gHg0haTRE+3vpfvcVSldfmbFtSdIQ9vcR8LQS6G/Dnjs8D38o9MWF6K1Own0dhPs6MeePzPIKoMTiyPEoMZ+bjreexVE7FUjPCOqNdtH80Hri/W6CDccovfImqHalb1+WOfbuIwBUzryAvMpZjMTIZHGVUrvwKrrqN9Pz1VfRF+eR8Pgo+pfrSUfhbygvo/jrX6T793+k/7nXcZyzkoKF6cn8Skrm0ZN4g74Nr9C/dSPlt34ec5p7zZk4D2vpOJqOPkvbv91Dwheg8Ks3A5OG36Oi0HLvz9CYLUj5VqLHm0j4g1gXzyFn6hKMxcO/PORIBP+hfXQ9+1d0dhfm4nLMZdVYVi9GMwKhU8IfpOWFh0hEQrgPbqVs1ZVoioaPixyL4X7pZaKtbWjtRow1JYQONmIoyyd/4UVYKtXaFoROdNL2wMsocRvBwwcwFBbhWLAY+5z5aM3mYfKKnOD4uj/i62lAfumvOCbOwDV9AUptxcjsw3teRZFl+jUdBHftQV9chHnKJKScKVjLh5crAPDs2IRn57vEvB4UOUH+nTegyxvOWh06eBTZ60eO+YkcayawcRcauxVLaQ22SdNxzJg77F33NR+hed2jGOx5GBx52Ipr0FcvTJtiG+3qonvHQbwn9hNxd1N39ZdGlBtA3Ouh64lnCOzZgy4nh8K7vpFR3r31bdyb30IOh0BRKDrnMpxT56SVjwa99NRvpbdxJ3XLP0W68hmQVHC8WzfT9+pLJHxeKr7yrxn7krxG4djuv1E1ac0ocjK9uzYRbD1OuLsVRVaoveyOUdvv3fUOfbvepnjFxUDmQrmJWITOg2/Re3wHUy78CozOiUlH5y60GgMFBSMTcw6Fv+04rW8+ia18PBqdgVOxYLxv+BAYdq+55hp6e3v5/ve/T3t7O9OmTeOFF16gqioZXd7e3k5TU9Og/AMPPEA8Hueuu+4SaEpuvvnmwWxhj8fDZz/7WTo6OnA6ncyePZs333yTBQtGL38zFFm3URpU1azE72sfVc6aU8a0c7+Mwewg1D96BLbOYKGgZAYajY7IKO4gkzWX2mu/RN7s5bgPbCPS15lRHqB88mqqpl+Av69pVFmt3U7tpZ/DlFtMsKs5o6yk11Fx7g2Ur7kOSaeje/v6jPI1jnm45i7CWFKOHIvS8pcHCW7fl1ZekePklk8nr2ImkUAfQffI7MaSJGHLq6R2wVWU/88XiHe7iXe5afvOb+g7tj1t+xqLBX15CUo4Qv9zrxJpS8+erNebMVfVYhk/KalwrL2PcHMaClzAYM8h9+ZL0dgsKOEIXT9bi7+zYUTZomtuInf1OVjmTEOOREGRibV24Nu1nVjf8AVajkYINdQj6XRIGg3m0ipc0xeMqLgk79NEzuT52ConYHTl07tnI8H64W5BjV5PyefupPIH36P87puxzq4j0R8gtL+Blj/eT+eLT5EIi4UxjSW5lNx2FsaSUtBqkfR6op0dBA8dSFttN3/iIpREHL3dBZJE1N2N7BvZDSBptGh0BiSDATQatE4nurxcjK6CERWXUEsjnt2bCbc3ozGaqL7lS5gnj5ytENyxl/DhY8R7PEgGPWi1mCZW45y1EMe0OSN+pEiSRDwSJBbwYCuqJnf8vIzcIKGDh2h/6+8E2xuoOv9mDI705TAAJJ2eaHs7KAp5l102yFg8ErobttP3zjpi7l50djuVt34xo+Iih8Mcfu0BWna9QNGEJZidozPJRlqaSHj7sc+Zj6FodA6OzqZt9LTuRqNN329Iun78DQfpP7wTRVGouepzo46Nv/Ew7eufQmexj8r7Ewv5OfTSr2jd+SLFU89Aq8vcH4DunoMcOvQ3cnJGrvs12HdFoXXPq9Q/9Ssi7i4KZ60cte3TBll5f/6dIj7/+c/T0NBAJBJh+/btrFixYvDc2rVr2bBhw+Dxhg0bBl37Q/8NpTn52c9+RmNjI5FIhK6uLl5++WUWL05fay4dspaXNCirXIxGM7bh0ZvsTFp1B5HA6LEpDlclDtcQi0gs82TSWeyUrLyMvNlnEOpqxpSTOVAKoGzimYR83aPKAegtSQWmv37PqLKSRkvOlPm4Js3Be2wvciKORjvyGEmSRN6Ks8lbcfbg39Ruo6HQ6AxUz7lE+NtoxRM0FhOl3/0Mif4ACa8feUs0bTFNSasl9/pLsa9agv+Nd+l+7inKPn1nWr4H+5QZ2KfMQFEUYu4+4p4mqEhfykJjMlL0b58l2tBK5FgTvTvfxWB1Cn2RJAlDfgHkF6DJDVJUdge6wrwkwWHnyDWodHYHRRddhWviXGy1Ewc32XiaLz9Jo6H0jEuFvwUzTBlJktAXuLDMqqPqZ59Hl2tHWz+ysqAx6bGMLyW+qILcVWtSY5cm8UDSaLEV1zL+zn9Ha06lOPudIz/ZkmmrAJArOsm9/BK0lqQ1R398ZIVBa7ZQsPJ8go315C48A63ZQigNzWLeDZcn+2SOE+vsJefqNWjtVoxH09ORW0vHUbH8KnLr5gxzqY4EfX4+9qpJuCbNxVo63HI1FHFvP61r78c2fx5aqxXrlClkqJqALaecylu+gHfPdnIWn5GsJZQhJEVjMlE572K667dSMH70jaGrbRfBliPknnchtplj49sw2/IprJiLVpeZ9VXS6rDXTkXS6ihZdXmy7MMo4TSKLCNpdRjzRlei9GYbBRMW09ewm/xx88fU97zcCcye9ZlBFvW0fZckXGWT6Tz6Do7qqehtrjG1n8Xpx8emPMAHhQEq5jnX/RCtITmxncfEYNy25Snz61D/PoC3RlzJi7aJi2mwUFwE7c3iQt45T/xqUNPUdy0Uj/N2Zk5Z65um+oNWvN7amNwYBmrf2JtTX9CdV4hf3qWPiH1Tc9wEi1X0/iq9QC9SYKCozqtLGfQuEMfOfljlF1fxTqjp0cMqyv9IVUp5Mu1VUBLxwU1Vq4q3DpapKPSPi/fWN1vsm61e5SNXUfAXbhWPu2eLG7JNZfjqmyvOC3OzqNxEnWJ7xr5U/8KFohXE2KOi51eNW/8U1YavmlKakKqvDeKxurTCQEzNAMydYoNqvh/TAlHpD28Tv8oTQ/ZGNV2/r1b8LYuqrIK6xESgQhwbk3psVHNQUg2NmgtFPefkQBCtObU+qGnnTScNeHI8ir/pKNbJUwfPlb0hBn5H8sWN1bJPtAQ33ChydahLG+gDyRpk0skPDLOqPtBQDihv21H0ufkY7DmDiqu61IijQbwZjWpsTH3inA0WpQZfE1WQ5fjgB6HBJ2ovPdNU9P/OAKHDhzHV1qJzOinYIf6WpVP8EGpbaiQRDqE1JR9IyUbxfNQhrlX+MvHY5BbnkalXvLnO8QkSoQAGVzKmseLFpJU0nojw+oGffjDlASo/j07zHssDyBFea7r3tPb3g0LW8pIFwKixPZ80aAxG4L0tBFlkocZQxSUTNDoDjtqpp7WcCDCouIwGR+l4ZEPmD6H3irFasgG0Fgu2U2RcHVBcTge0RtNgwPmHhmxVaQFZ5SWLLLLIIossPuqQTy3VOX0bnwxklZc0MPQn0OmT30XtS8SvqaG09L0zxety9ovHPdPFIVa7UhRJtGu7jqkqLUfE47ydKhrrfPFrydYuTs78XeLveSaIFhZrp4r6fUjz5m3iffdMF9tSM1Wr763qGY9w3HiJSzg2qWJg9UHxXg3dmWnjg6rkHLXrR1J91loPpA/k06rCMMwd4ri6Z4pmZH2f2DejKtxJTZ3evkLt3hDlw2KGPSZVNWSDyuVWuGNkunKAUKnqt1Rx5H1LxVQMjUf8LdmgMqF3iAMfKM/sEvPUqR6Uap6o0/1jb4r+CY0q/GeouzF/jxgYElktPpdQXDSFqyszKyZx3NSp0FFV2rfaheY8Lt6Mr1wUyDsotu9TuSfUJSuGlrRoPF+sOK+ez4Zq0U2kLs8RmiA+V/tG0bLYN118vwq3qtx5KkOk+n2OOsSxUpeJULSqeTTk1nvniNeWbFK5Nj2ojsXGgyrXpGufOA8sHWLnPXXiux5RucDU7sFha4uqdEJcfDT0zE82mIiG4QBZfAjIKi9ZZJFFFllk8VFH1m0kIKu8ZJFFFllkkcVHHQrvg/LyvvTkI4F/rijNTzgURSEW9tPXuAdv+9go/0812Szc3oKijMzp8V7aHpCNRzLki2aRxYeMSMBNIp4+5f8fRV/9zrRcOSMhcZrKkQwgFvShJD788gBZZJEOWctLGsQSqbS7ir+1Cec881PcA4U7wsTiIXRaE5IkkTCLPm5XvYr+3xsRUga754s01upYCZ+nFYurFM1Jngmtat0MlqcWPDkao/GPvyfY2UjR3LMxjZ9ATOWrNat47twHt2A0O3EVTgCgfUlKn9WKmdJE39hJ05uPU7nianLGzSaoomBQ+8iPOxtQFIW8mmTWgK1ZHIvEEH7yvgPv0thdT8zroeqazyFptRhVsRFDffKJSJjQy5spmLRkkGtGTfE9NHVUURSk1/aTUzwZSZLonKeifVfpTMFwFyigz0tynhg7xJsbiPeRoxE8W98hNn8Wgf37sM+dh8Zspubv4uYykJYqywkUJcHRaX0oiQSWcclxzz0obly+8lT/ov19SD0KRlvusPYG4FmQmhjWvyYfsjWvHIB+FQ+X5BVjE3Je7ENnMKHTJ+e7t1Kcw+p049iBBpAkTOVVSJJE92WqwWuwCodWFR+gZ744iY1NqR+IdLZhjTrQmVMT1zs/NRFjdjEOK/9hcYNtuUyM+5DLVTFkb3nRO1wns82GpzJHcsRxlUtCxFq7CG47QGDbAYp6C5halGJnjp2ZegkUReaE5QiWqtrB9tXpy+qUeH859G/eiP/EDkounsXQT2NtWDWfTybTeI/tI9rbRcnUVcJ51xZVjIvDjcZgSDI6SxLlr4s32zlPFY9nADkSxvPmBmJ9fUwPXsvQ8gChAvGdkU9Oo2BXC5KkIV4iMnQPvXf1WtIzTfxts4qWKnZyCsmJOIGmo1hM45LcNidx+DZx3bQMWaIVRSZQHEfSp34jd5/6fU+Sp3ma95NTOQ1bizgnG88XJ33VC+K8almVHOtE+PRmaAnIuo0EZJWXNDiw8UGmLbsDgzlzLryiKOw7/DhOewW1lasyyg7I76p/jKqixeQ5MrM7AtS/+yiJeISSiSsorF2IlIFUSWPQUzR7NSde+r3woqdDLOij8dDLaLUGZp/5tbSEc5CsG+NtPoQci9C+/WVcNTMZzXDXtuc1Qp52gn2tlM8+P6O8rXwCbVtfJBH007H+GUrOujxj294DO+jY8gxdB9+mbM555NTMIi1bGhCqP8bxjWvJLZlMzezLgeFEdgPoP7ab/t56PFveRmd3YqkZj6VuAvZps5G04sauxOPE/T5af/1L5ECA/jffpPCGG4GRGU39wQ52HHgIDhqJez1Yxk0g7+wLgLIR5QGCLcc59vxfsBXWkFc7l9zqmWQqzdB9dDPdhzfiLJ9C6YyzobYqrSxAV8Nm2us3UlK3lJK65YA6ajWJRCRM4yP3gk5DuLUJY0kZrvlLsdRMRGMcuT/+PbtpefElJK0OjVaPY9w0DDMXDxvHAfS9tY7GPTsw5hZjK6vFVjUJ5o1LW6uor+MgnQ2bMVpysOdWoShT08qGDzfgf3MbvgO70OfmYyouwzFpJvaJM9JeI3sDdP7fn4h39mGcWM3kwpEr5IY9nfQd2UZfw07ivn7MVeOwjp+MefZ09Dnp2WT733mLnmefwrXizLQyA1AUhd5tb9C54VlqbkhfekCRZaL9PXgP7MC97hU0JhP6vHwSrlmU1i4dkXBPSSTo37gJ9+uvkAgEqPjqNyAD6XYiEqLv4E769r+LoijUXfPljH0PHDtE2xN/BEkCSSJn1iLyl58zWMdM3X9/cz2ewzvxHt1NwfzV2Gonp+9LMETzk48R6esiEQpizCsi547r0bmcaa+RE3EaNj2O3uIkp1JNhqXqj6Lg87XR23sYp6OSnNyRy5CcdsgyQ5XJf7yNTwaybqM0KKiYTVfTNmQ5c4VmSZKYXHcpVksh4Uh/RtkB+ek1lyMriVHdKooiY8+vJrdsGpJGOybWXEf1VBxVU07W38gMvcXOnFX/QmHlPLpadmSU1eh0VK28jvEXfxGt3oT7WGZ5ORqhaPJyymadhxyP0lO/NeP96s12StZciXPKXPr3b8Ozd0vG9nU2JznVM3GUTSTU30mgJ3M5BK3ZTMWUNdhyq/C0H0SJp3+uciw6uMDrc3IxlVViGTdxxA1Xa7FSeM4l5F9+BVq7HTkaof23D9DQtGFE95rDVsYZ87+JsaQMXU4ucjRK35uv4e08lrH/JmchZlcRWr0ROZGZe9hoyyWnaiZmVxHBvpZRq16bbAUUVs1Db7AS7G9P+5w0egNlF92AoaAIjdmC1mwh2tNF+GBj2msC+/YQ8XQTD/rIn7WCgjlnplVcBiFJ6K0OLMVV2NLUNEqJavC5mzFZ88gtSa+4AAR3HkaOhkECY34hrpkLsU+cnvaauM9Hz4NPo7Vb0RXlUfTl69BII/dd0ujQWeyg1aK1WDHk5mPML0JnT//xE/X24d2xFQBjZWYFU1EUut55ic4Nf0drtmAurkgrGw/5aXjpIaKdyTQzY2k5eedcSOm45emZgjUaol2dJPx+7HPnYyjKzOTds+8dWtc/Qbi3g8pzb8z44ePevpH2v/0ZSHKxlF75KQrPvHBExQUgEQ3RtuEp3PvexVJWS/7clRn74nvrHQKNR4n2duGcOpeqa+/MqLjEwwEOv/oAvce34ypLrxQNRWPDesKhPlyjlBPI4oND1vKSBiXjlqHTj42UyGR0YjImX5axeIn1OjMFzpFrsAyFJGn+f3tnHh1Hce3/b8++SLNpJI12yVpsy/Iq2/KC8QayjfEGPz8cCNgJmLAYwvY7Px6QZ0JCeMS88M6BJOYdEhPy8oAXiI0Bszh4w+BV2HhBtiVb+67RSBrNPtP1+2OskaqkGXkfjanPOTpH3VPdfauqu/p23br3YsTUldS+ofRmQRCQdsMKOFtqLkASQCZXI6Ng3gWvY4mz5KBg+aNwtkZWFiQKJUz5JdQ+McIMq0SugK5gHHQF40ACfjjrq0DEQNjBNj5/DCzxdEK1SKtllGnpSB7dN63dIguvtxtHT4Fc0gHjtBsh1wdnaFhXShZt4RhoC/uipWZ9OHj+niACUu76KfXS1JWHb3/9qAlIMxfTOx3hla+UIvorvksbeWo7KasYyOo7f3e4jMwSCZQJyUgsXYLk5atC8gdGha9r0qq7oFGakThxDqTKoYOImWbNQ/qUpcEQ8iHcYcvrErJRXPo0pCE33fDtYlq1AGRXBywLb4fcEJwNYc1GvTi+P4n2f3wA3aJp0C++AX5rF6T6OACDf6AodQlIHDMLsqIRUFpS+9I4RBhhZeo4iA4HEm5ZAlVG5CSqgiBAnZwOhSEBmvQREXMsybU6jPzR/0W3rgfeWXOgzswOnsMavm26yw7AVXEG5mUroC2MPBMBBPN5adNzoc8bD5UpsqKjGz0euomT0X38W+iKJgZNahH0b4lcCW3aCEjkSmSU/giCIIm4zlQzrgjxmnQQnxe6URPO7w3/PEnlKugsefB7HIhLjKw0AsG2HzlqBaRSRUTl+KrDzUYUPD0AQ28o5uxfvRhKfpf0LbNWQ953A7NrVAJD6DvG07RttX0cPUMiYda0pH5OL1JpXEAPFIoeWja3ISgPCQQgSKUIMO8LbSNdvoeJUxFX38/mzgwwPjVdVtlFDxBdOfSA6jEzIfbH0MFQbGdp003GP+nz9Y9dAgDKTvp8bIhxUcbEhmBSMRgq+xq3J53+6rNn0Mfqq+hrSZgcVOy12iZTmwhoadlMR5j1BcxHp7aJrnvDzUwcjBb6eK+B/t1wqq/tbRPojpM46XYQArTsbOwRBRNjw5NA1z1lL33tjkL6/Ow6DyUTz4e9J10W+nyaBuY+6md1YZ8PHdNPbTPoF3TGNvpc9cvp3w0H6HUivet7euorIVNpIc2mgwm5RtACxB+nn9+kb2lFq2o5fX51Y1/b2s+Vo7vmJJJvDWaL9zF9ygZSSfrIioDfA7kyDnKFFh4m7oo9g95m4+moOunzN93Qd37XmQpkVpigVBtC+9rG0fecnJnA69H0QKrRhl7obD/r+qUaaR9Ly5bzPi1c0zw60JEoBfwuB2Tn03f0T1sCANp6ek1Z+0R6nZXHQG3CUDFQmfF5nZArgjerwARvU9ro+8Srp9vCFxesT8DrRtl7z16b9ADmn0ImGXpGPRJ+0Yt/tv+ZpwfgDF+GnJrncDhhiUvPAzB0ctDLIX7EaKiKRl1w+f6KxZVGXZAPZf3FeRfJtHFDF7oMZGrt0IUug17FhRObcOWFw+FwokRUzRCc2IKnB6DgyksYsra5IJMFO1rwMyHBR/Rp7E4DfZyCmVpV2Olj24uYab8h7qXmm2gzkWUfHSfeOp72DFHY6eNFZrmAsZwWMKCgj+8/texKoKd6JYx7ri+OGXiZTVUrY1JroKeG1WzIbWZqmQ3trmmhv4PZEOD2HFq+xCNMFlxv35dl2xR6ZspcRl/bp2GySI+jz6U/RZc3M6bFrlwmvDhjKmFDsbNtnfQ1fX0H44wkddPlNa198kkO0jap+Hq63Zpm0r+zphg5s4RF0UXLYh1Dtx0b2t2VTLeViUmZ4TYyZqGxtBuqYTfdr2I/M62VuUdYsyebtqFlCv279iQt+4BQAm2MWTWbycJ+ipaN7cezq+i2VTLPgJxZmNXfZJf6NW2qaB9LX6tmEWNGOsDUjclw72CyvLuS6bZL+I4Zm8bQbac/R/ejN465Rw/TMzXxx+m01TUr+0xurCt082x6LIhjZn38GsYtmzHPt06hZ2X01XTbOVLoumha6HustZh+IOMa2LQstDzyHtZt/fz2NVQGCBEveG1ipHNcL3DlhcPhcDic4Q4hl68sXUdLXLmrNIfD4XA4nJiCKy9XgID74kPaE0IuKHw+IQQBn2fIcv3LXyii6Me5LzbB5+qBGIgcz+ZS8Tm6hy50Hn+PfehCvef1Bds84A3vRnutGU5TstyJkHOtuBb32sVcIzBEHKTLocNaAVGMUtqEXlfpy/27TuBmozAcTzgG442zAQB5L5+ifhMLgh4Cot+Huo/ehd/RjeTZS6BJyYLA6ABeJsZGfJUXZw69A6+rE2NnP4yedLoLkg/SL/AKnIC9pRIjZt4VDMU+iXZvi2+kL9jafhJiwIfEjGBI/vp5jFusv2+Ni9/tgK/VhVMfvorMH90PpTkZUm+fPtudzbjMfn0UUpUGcRn5EAQBHiZILZtm3vndd6g9/BFGL3gISq0RLjPjypzeNwj4WtrQ/cFmxGcUIKl4PgDAxYSPkDv61hOc3fUhAlY5Ai4n0u+4F4IgQGGjz9/VT357xUlIYIepYCoEiQQaJmS993yz+J121H3xDtQ3l0CWYILockOVnwsjs1aif91bd22DIj0NjspTSFywDFKVCnJGD7PnButKAgH4rTYI5zpB/H5oCwohCMIA92K1tW+QcfdYQZSqYBC086gYt/GO0cF+a9/1GUQrgTzJAolSCe3oQsjc9D3Ghuu3jffDdaoS8qQEyExGKDsiDwtk9wnIVFrEJwRjZPSk0d9AUhe9bV1hh6PsDASpBBKVAgFHPCQaDWQJwUZUf0+vPzhnLIc8wQy52Rzc0a9blbS3PaRMip/A2B5qEayvkW5Yw5nzoQSICE+3FSYvHf22dSJd95Sv2JQW9HZ3Fn3Ppf0zuO3z9ECm0MIeOXwLdHUiRNEPd08HahbRN3zSYfpagsjcgwb6XF2T6Y8c/eHzKQqcdjiaqiAsoOO3JJygle2AMlh3Igbg7emEzEVfoGUaXV5xQAJXVwvEgB9aUxo6ptH5QtL/2fcQdI6mFxepbLQC0MOsUel9vtytjeg8fgiTJHNCsXMAwKul1+rZ8mQghKD90A5oUrJgrqSj4HYU9t1jot8Lv5SOIcW6RnsS6PVGzVNl6Ck/AdupL5Fx28+haQruD3iv4fe/KIYPTHShDKMPrMuFKy9h6Ph4K3ytrUhcviJsGUEqg1SpQvfpo6j9x5vIWbUOSmnkgE0SiRRypRYep21ITwOvz4GmM1/C09OB+KRcJBVMj1g+4Peg+sQn8Lrt0BrSoIkfPER9L0QMwNdlg7/bBk97C5Tm8LJ721rQuGcz/E47VOY0JE6aA/XUCWFdssWAH10N5fA6OtB0YgeyS26PKIuvtQ099RXoqa+AGPAjeUopIoX7Tx1fivLPX4fodsF26CuYpt4Y8fzWfV/C1VCN1mN7kDrtVigSRg/a/lKVBgljZ6Dl62/gqaoG8XhhvG0pDImzwvaXNisPrV99BnddNTwNdUj98X2QC4ZBywY6u9H6x00QO7sgejzQ5I1E0sLlUCgHb3tCRLScO4DGbTsgjzdAnZwBbWYBUjJKQvmu+qOfNA3Wsj1oe/89kIAfibf9C0yaKYOeu6v6JHoazsJ9OgBvdR08Z6shT7XAaSmEPncsNJbBA3jVHvsEbns7copvQ1JuyaBlehF9XnhPVMH24V64y4OBE1WFo2BauXRA2eZt78Nv74LX0QVvQz2U2dmIL54M7YQJkKoHBrgjoojGnVvgaqpBwO2EIJMjMeFWqEeF1xhcnc2wVpbBVv0dcmb9CJCED90v+rxoqtwPl70Nfq8DGWMWQqFMjFhft6MDjWd2QSpTIWvsLRHLAoDX3Y3T+97GiImR02GIAT9qP3kH7vYmAARSlRapNy6HJmnwSLuEEDiba9D+3V50nT2G3NseihC+D3B0N6G19SzsDZVwWRswYtG9AAwRZSJiAGf3vYvsyeHHyF5Z2s7sR097DXwuOxRaI/JzF0EqU4Y9xmfvQttXn6Lz+CGkr1gNoTGykhDwutHw+btw1J/FqJ89D9gGL0cIgau9ERWb/gCJUgWZNh6atBwY9fMhV4R3zbYfP4Lmv/8N+imRx2DOtYObjcIgNRrRc+RbNLzxB3jE8GYh/ehJSJyxACpzCmq3/Bkee0fYsr2k5d8IjS6ykgMACrkWY255AjnTV6Gz4Xs4bY0Ry0tlSoyf+3Pkjl+OluqDQ6Y2kGt0yLzzZ5Bq4+G1tkYuazJDnZgGTXIm1Imp8PV0wtMSXh6JVIac6Xdg1M0PwmGtg9cZOXWCPCkRGTf9CObxs9HTUIm2IzsjThUr4k1IXrACmux8tO34GO4IshAiQpWSAcOI8YhLyYWztRae1qZBywoSKXS5RUj8yV1QpKYAggDb+1tQu+NdiP7Bp6M12fmIGzUGmtwCiB436t58He62wc8vSzAi9bknoMkdBaUlFcTnQ/uX2+BsGjwisiBI4PcEPcRkcQbEjxgDY+GUQRUXAJDrDNBPmwlVTg5k8Tq0ffAeGo9tH7QtZUoNlHoz5JZESDQqSDRqKDJToU7OgDJM1FTR70XamJuROeFWuHussLdXD1rOde4sGja+jpoXfwnblq+gSE2ALMmAlP93J5Ie+inkSQOVAOPkmTBOnQWpRgOJNg7SuHiIHi/8tsHfRL5uG7orjsHVUge5zoSc//NgRMUl4HTi7I6/oPn4DpgLpiEuOSdsWSAY9bm97ig6Gk8gbdR8qOPMEcv7nQ6c2PUHWOuPIW3U0LmKvHYbju/8PXyeHmj0KRHLOm0NsFd9D09HC1QJKcha8pOwigsA+JvbUf3xn9F5ugzm8TeEVUR7cXQ3o2HfVtjrTyNr3p3QmNOHlL+pfBcc1tpgvqIICIIAj8OG9sqDkKvikDllaUTFhYgBtO7+GJ3HD0JlSUd8/tiI5/e7Haj++x/RXXEMuryx4VMgnKf+my2QKIPRRI3jpiF53vKIiovbaUPHrn8CogjV+WjFUYGbjSj4zEsYMh9/ChKVCqLHA+F35YOWEQQB2ow8aDOCAa1Evx9CS+Q8MgCg0iYgLX/2BckhU6iRmDsFiblTIIqBIdMPyOQqJGVNHqJUHwqjGZmr1qLz6IHIBSUSZC9dS80+sGajwdBZ8lC48BH43JHbRZ6cCMMoC3A+ZhchBK4I5aUyBfRjJ0M/djK8NivcTXVQJaQMOjsiCBJYbl4BVT+90h35PQSJWg3L4w+DEALR6ULckR4EPE5IZANzpgiCANOs+TDNCpq7iN8PoS28witIpUi9YzW1TxFhaVB64U3QzbwRqsT+WXsj5IlKSEDqvT8DAIheLzQH2yD6PJAq6PDP2pQcaFNyYBvvh6pgBGSJCRCkUuhPhB8WJDIFzJkTqH2D9azMaELCwsVQZmRCWuCC32ZH4k8XQ6KUw9sy+MtOmZQCJVIgZJohNRj6+jLMu1GuNyJz6U9hP3cSSdMWQJBIEBhUmiBSjQYZJcvRdmofLGPnhC3XnxETb4NMoYFSYxiyrEyjRUHJXfA4OkIZuiOhiDcifdR8+H3OIWdhtaZ0ZC+/H35nN/QFE4I7IwwG0gQD4jIK4OloQXLJwiFlMSWPgi5zNEwFkxGfNnTqEiKKEAN+qHSJFxSrJnXsTZCr45E0cub58hGEFwR42puhzRmFhCmzhzy/TKWFXGdEwO2EvmB8xLKCIGDkbY+hta4M8flFoezfgDfsMQplPIjfB8PMOVBnZEc8/9WEiCLIZZqNhtO6vMuFpwdg6A3FPG3xr0K5jRRdTJyMaX0vAfMJenbDr2LiUDDrAbxMRGaBaX2vnt6R8U/6/B2j6TgSrN2bvbfVzISK1Dt4mHufowtyrR6efu9mFfPBq2mjB5zGWXTdDOXMmhbaBD4gXUDe3+gXTdcoJugG0zZ2Zn2BwEyESJjx0JFBn0B/uu94bQtdOKBkUwswcV9Y0YppbUO6j+5Yl4W5dgV9fjdjrfAyOlHyIbojZW56u+5mZtK0X+IoNi4LG0KfTYUgTqQX6CT/hX7xsqkQOkbTX7YSZj254Szdtmyahh5mciSOyV4sc9Hyts7ve7HEHaO/2NmcU84MJq1CG10goAZEnw8SefA5kjNKozOLlj3hcOR1JqxixYax98bT15c76N+dyRIQQiAIAtx06BPE1dPbATYyPHPt/rF+AKDHIoHP0R3KE2U8S48l2iP04qeKuxIhVfetEUo4SZ9PZHRaIhWCjgdiABKpDK0L6Bsh43/7DnAk0QcT5lxsHCRVlQMCBEhkSgiCAHs63Y5xTDoNm9oGiUIBqVITNGUzY4fxDD1YaE7TgWda56UiHK6OZnSU70f6lKCpUxCEUJyXgNeN43965pqkB5inWQWZcJnpAYgXO5zv8vQAnOsHuTZ8FlYO53qiV3EZLlzNKLt0gsvI9FdcLhRBECBEyCh9qVzIzFV/FIaEoQtdImqTBRlTl121818w5ApE2L2O5iq48sLhcDgcznBHJAOn6i8Wrrxc//i0EhB5cKrSkUSvFdDV9E1Z2jOYbMFMi6Z+QadabZ0VebFF1tZOats6yUCf763vqW3b4tHUtjuBMRnU0VPF/TNiA0DXCHpaPOOzvoUhjfNp24aT0GXjz1GbiGukp2a1TGh0NkutwDxIbNZq1uykP0eXdyUyrtzMGpy46vBftE0zGXOChjU30OWTD9PtqP6ULn/6Z/TvI96jzQ/nbmcy9HbRbamvoK/XPo6Wz0h760PwMVmw+5mlHMwMeEchE0aecZV2BuhrNU+NPCzEM2uLWVNow1wmjP1But+yt9DmwqYbaLdXNnu49mSfqYjNSB1XR5eVO+i6qDvYTM30piOFKd9A90vnKPoAv4HuZ1UDPYvDhtC3M+tkU/aHX3Mg+OljZU7GHX4sfSyb0kJ3hjb/tU2kO0ZfQ/eL7UbafqehE9jDzpi8mccfxkr6Hs9+my7v7pfywlDJxGNinv32cXTHyl10XdPfp22LXdPoxcrsPZi5jW4LUUULf+4e+iFhn2/tCboxPDn0uN07dvn9wyfO1A8NrrxwOBwOhzPcIQTA5cZ5uX5mXmLCVbq6uhr33nsvcnJyoFarkZubi/Xr18PrpVeI19bWYsmSJdBqtTCbzXj00UcHlOFwOBwOJ9YgIrkif9cLMTHzcurUKYiiiDfeeAN5eXk4ceIE1q5dC4fDgVdeeQUAEAgEsHjxYiQmJmLv3r2wWq1YvXo1CCF47bXXLvqaJOAD5KqhC14kfo8TAY8LSt3VWWDmd9qpSKxDQYhIRa4csrwoQpBcHZ231+viaiAG/PDZrFDqzGED613yuUkg6HXh8UKiCh+/4lpBRBGelkYoLWlXdTEo5/oj4PNAKo/+PcwZBCLi8mdeuKt01NmwYQP++Mc/4ty54MKLTz/9FLfeeivq6uqQmhq0Z7777rtYs2YNWltbL9gtrNctzTLuJqRPWgQAMJbTNvrWKX3KQdIh2rbq09EPftPMPtc20e9Hze83AIQgdcEd0GbkIuF7ep2Iy0zrkwnfNFPbVXfRwaz6u0JbTx2E7ey3iMsaicTJwSBZKV/RvqCdo/pkD/g8qDnwAdLHLYAyLri+hXUR7sXZXAOnsw2O6gqYZ5VCYUyA+QRt82Zdav093Wit+xZpeTdCEIQBbqOu8+tziBhAy77PoJw4BvZj3yJxwVIIMtkAV01nMn18ynZ6PVHTfNou7egXZ8v62TY4Dh2GafxMJE2ZD4Fxq3Yy60SI1Q57+THox0+BRDHQPVHW75awlu2Gvb4CJOBH6tI7IYvXQc2smRngNp7nhuvYGcgsZsiTTNAdpBVlaT+vU29PJ5pOfInkkgWQaYI+2ylf0UH/Gub2eYu1bN+MzoqjSJ21HIaCiQNkDzA6eY+7BYEeO9SZORCk0gHuw6wbd9JuO6RSZUgx8muYdR5pfcqhz9ENaZcHKl1f3/iYlBk+Jj6YhJks9fTrVk8y/bxYNjsRCPig0gQXPHVn0opp/3Uaot8PsaYZalNqSAFn3bbTv6SjC1Ws8MNb1whpghEygx6mE5FdtXvbihAC0euBRJRCIutbF9N/zQ4hIhSO8B8CpnK6rjVz/PBbOyDRaCDRaJBwmpYlrplet9GVRY8laivjSs2saZHbgYb9W5FacisEQYKufPrVYKKX24UQA36Ifh8kGsZb6Xw3E0Lg6mqGSp8U+nBgwy60TaD7zfR9n6yi34fuUXRdM7bT4253XvC56Gwohz51JAJMyAo2hISmNdhWAb8XUpkC7UX02iXLIXoti9xKx21ypQfHUb/PjW+2r78mrtJzpbdBJlyep5yf+LAz8A/uKh1Nurq6YDL1LSjdt28fioqKQooLACxYsAAejwdlZWWYO3fwiJcejwceT9+bors7OHI3H98Jc94UatANR2PbEfgDbiSbiiBBhK8WMQCF3oSe6tNo2v4+Rqx+cshzA0Cb4xykEjlM6vARNYFg6oGe2jPoqT0DQSqDeeKsiOU760+ivboM9vZqFN70EBSa8O7SgkSG7vKjcFR8j56Kk0hbcQ/MyA1bHgAaz+1F/ZkdEAQBaXnhw/cTMQCpUo2Wv/8NPpsVnsYGpKxaDSAu7DEA4PE7UG09gLzEWZBKwj/URBRBfD74ejrRuv9z6PPHQxUfvl+b/vpn+Nrb4W1tgXXHZzBMmQHDlJmQxQ/+sJsm3oDu6nI4q86g/n//hMx7HgYwUOHxWtvQ8fUOAAICBhHe6kZ4z9VDnp4Mp2Us9HnjoE4aGNm08pON8HS2orP8MBInz4d5Uvi2FP1++Bzd8DvtaNj9D2jT8yCPMBPXsvtjeFw22I8fgUStQdzIQuizihA3ohCSMC6wDTXfoL35ONKyZiApZQIQ4Z732FpwbvMfodInQZ9RCGP2OCi12WHLWw/tRufR/SABPwiApGkLoJ5VHHYGydZyBpVl7yExsxjpI+cBCB+5mvi9qPzsDRAiIs6Si/jUfKgsU/sFKutDFP1wuqxwHW9DxztbIDpdgCCgM3sM0m9YAUX8wAiNblsrqt7dBH9PN0SPG8ZJM5A8e2AaBCD4Qm/f8Sk6D+6FRKGGVKWGedKNMBRNHbSuRAzA19KKlj+9hUBnUHG1puQi84aVUOkHpgHp6WrAybc2QSpXQqpQQ52ciZz8BZApIrsg2xvOoOP0ISSMipz2wWmtR1fDGdibKkCIiLz5Pw1bVhAE1O35O5zt9VAnpEGblIF0Swk0Osug5QkhcHQ2orPhe3Q2nUZ6USmAkRHlIYSgqXwX7G1VMKSNjlgWAPx+DxqqvoJEIkNG7pwhy/e422Bz1CFJVwClPPK4dLUgIgG5TG+jGJ2rGJSYWPPCcvbsWbz22mt44IEHQvuam5uRnEwPXEajEQqFAs3NzewpQrz00kvQ6/Whv4yMoIKQVHgDGo9+dkGdHRD90GnToVRENtdIFEqkL10Dy7zlEP1eWA/tHPLcAKBXWaALk/umP5rkTKSVroJp7DTYTuxHx4n9EcsbM8eh8OZ1SMqbhuYzX0OMkI1VnZQGXeEExBdOgDIxBS1fbEZz9cGI7ZM1qhRjZz0Ev9cJpz18+gGJTAHzpDmIGzMOqqwcBJwONLy1MWzo+V6kEjnSDOMgkshpEASJBAm3LkXO7Q9Cm5GHxh3vR5Tb8qN7YCy5EbL4eCgtqQi4XXBUngLxD34dIhIYp9wA/YQS+Lo60bT13UHPL1GpocnJhyY7F6qCLEjjNZDotFDmpEGVmAaFfnBTYvKEeYjLGgndiDHwO+3oOvNdWPklMhkyF96N7CX3QZOUgcbd/4jYNpq0HCiSUiDIZFClZUCZmg6lOSWs4gIAcbpUJKdNglJtHDIFhSCVQ6aKgzYxC3GJWVAbIigXooiOb/fCY2uFIFcga+lPYCycHNH0pdQYkJo/G/GmLHhdXZEjiAoSSGQKKOPNiEseAUNW0aCKCwAcPf4XlJ/+AK7yCkgTjFBkpCLxwXuQs/AngyouAa8bNZ//Fb7ODkAUkbbiblgW3k7NuvTHZ7PC/v0xiF4P5PEGpC24A8axJYPW1eWwYt+Xv4L1/c2Q6XWQGgxIvPtO5N/y4KCKCwB4PXaIPi98TjsM+ROROnPpkIoLEJzlaDjwMfxuR8RyLlszGso+gddhw4g5dw9papIoVBCkMmgS02EaFV5x6aXt3CHUHf8MCVkToLdEjvhLiIiaw5tRd+Rj6C0FEcsGyxNUntyCxppvkJI5bcjyQNA0rFYYoqa4AAiafK7E33VCVM1Gzz//PH75y19GLHPo0CFMntwX7r6xsRGzZ8/G7Nmz8eabb4b233///aipqcHnn39OHa9QKPD2229j1apVg56fnXnp6upCZmYmxq38BQgIJBI5TIybX1txn5KSWBbZbNRcQn+By86PCUQMoKfqFDI8IyCR9L0o3An0S8N0kHbZq/4X+qFnzROBfpcP+DxIPeShUo905TMKFtP9LnN4fZaNMpvwfWSzkcTPuEIzbqQuU+Sos8ZyP7Uex5VIH2/ZaaW2m+fQL3/WFKQ+r8O6O1ogk6upAF4uZiwVXIGIOVJkzNjeaw4gRISnqR5arw6KOEOfLMw7xjvCDV9bB2RmAwRBgvgyxmzEmE78jKnHso+27TTO6qtL/2M9tjbINHGQKvteXAHmPeNGNyRKJYTzLyA2IzbrhppygFZy/WomqnRqX7sFvB6o3DJqndQAs1E/a0PA44bt4B6YJ8+FRBp88Xv6das3ib522heMySo9vNmIEBFo7IQyvu9G62EmutJ2u86XDa6/qvoXObwNTZCnWiAIAgzHmUix/S7vsjbB6WmFKjkNcmNwZo+NAt3fbCQ6HXCXV0BXMH5QpcV42heSWyQBNJeq4Kmtg9ySDIlCAcNJuu7aFlqRrLIfhn5EEWTq4IOrYtzGWTdxeQ9Q/sEGBDwupJUshbSUDrXf310/4HOjvmwbLGPnQqkNKnOilKlDv82e9hqojJaQkqNup8eO9rF0v+mO98BadwxJuUHlomsELWv6DvombTZ2ofbbj5A99XaodIkDohGzZiN5kx1Oext0xqDd0FpIK5nJ3zJmow7anOhKDbap3+/GwZ0vobOzE3r91Qn02Ws2ugG3QIbLNBvBh73Ydl2YjaKqvLS3t6O9vT1imezsbKhUwZG7sbERc+fORUlJCd566y1I+g2I//Zv/4YPP/wQ3333XWifzWaDyWTCjh07wpqNWOrr60OzLxwOh8PhDEVdXR3S04dOZnkpuN1u5OTkRLQgXAwWiwVVVVWh92qsEjMLdhsaGjB37lwUFxfjv//7vyFlPEZ6F+zW19cjJSW4qPW9997D6tWrL2rBriiKaGxsBCEEmZmZqKuri1kNtbu7GxkZGbwOUYbXYXjA6zA8uJ7qUFtbC0EQkJqaSn1MX2ncbvcVC/uhUChiXnEBYmTBbmNjI+bMmYPMzEy88soraGvrs5VYLMH5/tLSUhQWFuLuu+/Ghg0b0NHRgaeeegpr1669qAdEIpEgPT09tHBXp9PF7APWC6/D8IDXYXjA6zA8uB7qoNfrr0kdVCrVdaFwXEliQnn54osvUFlZicrKygFTc70TR1KpFJ988gkeeughzJw5E2q1GnfeeWcoDgyHw+FwOJzrg5hQXtasWYM1a9YMWS4zMxMff/zx1ReIw+FwOBxO1IhJV+lrgVKpxPr166FUxm60SV6H4QGvw/CA12F4wOvAuRLEzIJdDofD4XA4HIDPvHA4HA6Hw4kxuPLC4XA4HA4npuDKC4fD4XA4nJiCKy8cDofD4XBiCq689KO6uhr33nsvcnJyoFarkZubi/Xr1w+IbFhbW4slS5ZAq9XCbDbj0UcfvWLRD68UL774ImbMmAGNRgODwTBoGUEQBvxt3Ljx2goagQupQyz0RX+ys7MHtPnTTz8dbbEi8oc//AE5OTlQqVQoLi7GV199FW2RLornn39+QJv3BrccruzZswdLlixBamoqBEHAli1bqN8JIXj++eeRmpoKtVqNOXPm4OTJk9ERNgxD1WHNmjUD+mXatAtLlHiteOmllzBlyhTEx8cjKSkJy5cvx+nTp6kysdAX1yNceenHqVOnIIoi3njjDZw8eRKvvvoqNm7ciGeeeSZUJhAIYPHixXA4HNi7dy/effddfPDBB3jyySejKPlAvF4vVq5ciQcffDBiuU2bNqGpqSn0t3r16msk4dAMVYdY6QuWF154gWrz5557LtoiheW9997DY489hmeffRZHjhzBrFmzsGjRItTW1kZbtItizJgxVJsfP3482iJFxOFwYPz48Xj99dcH/f23v/0tfve73+H111/HoUOHYLFYcPPNN8Nutw9aPhoMVQcAWLhwIdUv27Ztu4YSDs3u3bvx8MMPY//+/di+fTv8fj9KS0vhcPRlZo2FvrguIZyI/Pa3vyU5OTmh7W3bthGJREIaGhpC+9555x2iVCpJV1dXNESMyKZNm4herx/0NwBk8+bN11SeSyFcHWKtLwghJCsri7z66qvRFuOCmTp1KnnggQeofaNGjSJPP/10lCS6eNavX0/Gjx8fbTEuGfY5FUWRWCwW8u///u+hfW63m+j1erJx48YoSDg0g401q1evJsuWLYuKPJdKa2srAUB2795NCInNvrhe4DMvQ9DV1QWTyRTa3rdvH4qKipCamhrat2DBAng8HpSVlUVDxMti3bp1MJvNmDJlCjZu3AhRFIc+aJgQq33x8ssvIyEhARMmTMCLL744bM1cXq8XZWVlKC0tpfaXlpbim2++iZJUl0ZFRQVSU1ORk5ODVatW4dy5c9EW6ZKpqqpCc3Mz1S9KpRKzZ8+OuX7ZtWsXkpKSUFBQgLVr16K1tTXaIkWkq6sLAELvhOupL2KNmEgPEC3Onj2L1157Df/xH/8R2tfc3Izk5GSqnNFohEKhuGIpy68Vv/rVrzB//nyo1Wp8+eWXePLJJ9He3j6szRj9icW++PnPf45JkybBaDTi4MGD+Nd//VdUVVXhzTffjLZoA2hvb0cgEBjQxsnJycO2fQejpKQEb7/9NgoKCtDS0oJf//rXmDFjBk6ePImEhIRoi3fR9Lb9YP1SU1MTDZEuiUWLFmHlypXIyspCVVUVfvGLX2DevHkoKysblpFrCSF44okncMMNN6CoqAjA9dMXscgPYuZlsAV77N/hw4epYxobG7Fw4UKsXLkS9913H/WbIAgDrkEIGXR/tOsRieeeew7Tp0/HhAkT8OSTT+KFF17Ahg0brmINrnwdotUX/bmYOj3++OOYPXs2xo0bh/vuuw8bN27En/70J1it1msm78XCtuW1bt/LZdGiRbj99tsxduxY3HTTTfjkk08AAH/5y1+iLNnlEev9cscdd2Dx4sUoKirCkiVL8Omnn+LMmTOh/hlurFu3DseOHcM777wz4LdY74tY5Acx87Ju3TqsWrUqYpns7OzQ/42NjZg7dy6mT5+O//qv/6LKWSwWHDhwgNpns9ng8/kGaN9Xmoutx8Uybdo0dHd3o6Wl5arV5UrWIZp90Z/LqVOvd0VlZeWwmwUwm82QSqUDZllaW1uvafteabRaLcaOHYuKiopoi3JJ9HpKNTc3IyUlJbQ/1vslJSUFWVlZw7JfHnnkEWzduhV79uxBenp6aP/12hexwA9CeTGbzTCbzRdUtqGhAXPnzkVxcTE2bdoEiYSenJo+fTpefPFFNDU1hW7WL774AkqlEsXFxVdc9v5cTD0uhSNHjkClUoV1S74SXMk6RLMv+nM5dTpy5AgAUAPfcEGhUKC4uBjbt2/HihUrQvu3b9+OZcuWRVGyy8Pj8aC8vByzZs2KtiiXRE5ODiwWC7Zv346JEycCCK5P2r17N15++eUoS3fpWK1W1NXVDatngRCCRx55BJs3b8auXbuQk5ND/X699kUs8INQXi6UxsZGzJkzB5mZmXjllVfQ1tYW+q1Xwy4tLUVhYSHuvvtubNiwAR0dHXjqqaewdu1a6HS6aIk+gNraWnR0dKC2thaBQABHjx4FAOTl5SEuLg4fffQRmpubMX36dKjVauzcuRPPPvss7r///mFjbx6qDrHSF73s27cP+/fvx9y5c6HX63Ho0CE8/vjjWLp0KTIzM6Mt3qA88cQTuPvuuzF58uTQTGRtbS0eeOCBaIt2wTz11FNYsmQJMjMz0drail//+tfo7u4eVmEBWHp6elBZWRnarqqqwtGjR2EymZCZmYnHHnsMv/nNb5Cfn4/8/Hz85je/gUajwZ133hlFqWki1cFkMuH555/H7bffjpSUFFRXV+OZZ56B2WymFOVo8/DDD+N//ud/8OGHHyI+Pj40C6nX66FWqyEIQkz0xXVJFD2dhh2bNm0iAAb9609NTQ1ZvHgxUavVxGQykXXr1hG32x0lqQdn9erVg9Zj586dhBBCPv30UzJhwgQSFxdHNBoNKSoqIv/5n/9JfD5fdAXvx1B1ICQ2+qKXsrIyUlJSQvR6PVGpVGTkyJFk/fr1xOFwRFu0iPz+978nWVlZRKFQkEmTJoXcRGOFO+64g6SkpBC5XE5SU1PJbbfdRk6ePBltsSKyc+fOQe/91atXE0KCLrrr168nFouFKJVKcuONN5Ljx49HV2iGSHVwOp2ktLSUJCYmErlcTjIzM8nq1atJbW1ttMWmCPc+2LRpU6hMLPTF9YhACCFXX0XicDgcDofDuTL8ILyNOBwOh8PhXD9w5YXD4XA4HE5MwZUXDofD4XA4MQVXXjgcDofD4cQUXHnhcDgcDocTU3DlhcPhcDgcTkzBlRcOh8PhcDgxBVdeOBwOh8PhxBRceeFwOJgzZw4ee+yxaIvB4XA4FwRXXjgcDofD4cQUXHnhcDgcDocTU3DlhcPhUNhsNtxzzz0wGo3QaDRYtGgRKioqQr+/9dZbMBgM+PzzzzF69GjExcVh4cKFaGpqiqLUHA7nhwRXXjgcDsWaNWtw+PBhbN26Ffv27QMhBLfccgt8Pl+ojNPpxCuvvIK//vWv2LNnD2pra/HUU09FUWoOh/NDQhZtATgczvChoqICW7duxddff40ZM2YAAP72t78hIyMDW7ZswcqVKwEAPp8PGzduRG5uLgBg3bp1eOGFF6ImN4fD+WHBZ144HE6I8vJyyGQylJSUhPYlJCRg5MiRKC8vD+3TaDQhxQUAUlJS0Nraek1l5XA4P1y48sLhcEIQQsLuFwQhtC2Xy6nfBUEIeyyHw+FcabjywuFwQhQWFsLv9+PAgQOhfVarFWfOnMHo0aOjKBmHw+H0wZUXDocTIj8/H8uWLcPatWuxd+9efPfdd/jxj3+MtLQ0LFu2LNricTgcDgCuvHA4HIZNmzahuLgYt956K6ZPnw5CCLZt2zbAVMThcDjRQiDcUM3hcDgcDieG4DMvHA6Hw+FwYgquvHA4HA6Hw4kpuPLC4XA4HA4npuDKC4fD4XA4nJiCKy8cDofD4XBiCq68cDgcDofDiSm48sLhcDgcDiem4MoLh8PhcDicmIIrLxwOh8PhcGIKrrxwOBwOh8OJKbjywuFwOBwOJ6b4/2Ps75wRUeUBAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "lat = xr.DataArray(np.linspace(-20, 20, 101), dims=(\"lat\",), name=\"lat\")\n", "lon = xr.DataArray(np.linspace(-20, 20, 101), dims=(\"lon\",), name=\"lon\")\n", @@ -562,7 +100,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "1532a89d-b6d2-48b8-aec5-eda619f6aca0", + "id": "5", "metadata": { "papermill": { "duration": 0.015861, @@ -579,8 +117,8 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "e0cb5a53-8e8e-4f95-980a-2368a6fe289f", + "execution_count": null, + "id": "6", "metadata": { "papermill": { "duration": 0.153963, @@ -604,7 +142,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "5537cf9c-18c5-435d-a4c7-b98e7527544e", + "id": "7", "metadata": {}, "source": [ "### Create fieldset from Xarray\n" @@ -612,8 +150,8 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "5c2c3f9c-f864-484c-a7e1-475a4f0768cb", + "execution_count": null, + "id": "8", "metadata": {}, "outputs": [], "source": [ @@ -627,7 +165,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "9eae496f-7f8a-43cb-bf7c-e58806b77c17", + "id": "9", "metadata": { "papermill": { "duration": 0.017419, @@ -644,8 +182,8 @@ }, { "cell_type": "code", - "execution_count": 6, - "id": "c4f510d8-a6d5-4da8-9fa1-cc52f9d6f61d", + "execution_count": null, + "id": "10", "metadata": { "papermill": { "duration": 0.031583, @@ -656,35 +194,14 @@ }, "tags": [] }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAisAAAGdCAYAAADT1TPdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABTXUlEQVR4nO3deXBc1Zk//G/vq9TarM3IGzYhwWYnxvAyQBYnfnlJKqH4wVBFmdSETBZqwjaZOGSCIRgnYZLwvsMQJpWMIfWbJPwxNdRkIBMc4iTDbhicwQb/kIyFNJbkttRSd6tbvd77/iFa1tIt9XKXc+79fqpciSVZXF3de8/zPOc55zpUVVVBREREJCin2QdAREREtBwGK0RERCQ0BitEREQkNAYrREREJDQGK0RERCQ0BitEREQkNAYrREREJDQGK0RERCQ0t9kH0ChFUTAyMoKmpiY4HA6zD4eIiIiqoKoqkskkent74XQuXzuRPlgZGRlBX1+f2YdBREREdRgeHsYZZ5yx7NdIH6w0NTUBmP1hm5ubTT4aIiIiqkYikUBfX9/cOL4c6YOV0tRPc3MzgxUiIiLJVNPCwQZbIiIiEhqDFSIiIhIagxUiIiISGoMVIiIiEhqDFSIiIhIagxUiIiISGoMVIiIiEhqDFSIiIhKarsHKH//4R1x77bXo7e2Fw+HAU089teDzt9xyCxwOx4I/l156qZ6HRERENqUoKoZjaRwdS2A4loaiqGYfElVJ1x1sU6kUzjvvPHzuc5/DddddV/ZrPvnJT2Lfvn1zf/d6vXoeEhER2dBANInfHD6JY6emkSkU4Xe7cOaqMD6xuQsbO1fe7p3MpWuwsmPHDuzYsWPZr/H5fOju7tbzMIjIRhRFxYmpGaRyBYS8bqxuCcDp5BvZ7WwgmsS+FwYRS+XQE/Ej6A0gnSvg8EgcI/EZfO7ydQxYBGf6u4F+//vfo7OzEy0tLbjyyiuxZ88edHZ2Vvz6bDaLbDY79/dEImHEYRKRBJg902KKouI3h08ilsphU2d47j00TX4Pwj43+qPTePbISWzoCDOoFZipDbY7duzAP//zP+N3v/sdvv/97+PgwYP4yEc+siAYWWzv3r2IRCJzf/r6+gw8YiISVSl7PjwSR0vQgw0dYbQEPTg8Ese+FwYxEE2afYhkghNTMzh2aho9Ef+SF+Y5HA70RPwYiE7jxNSMSUdI1TC1snLDDTfM/f/Nmzfj4osvxtq1a/H000/js5/9bNl/s2vXLtx5551zfy+9YpqsiSV9qgaz51m8X5ZK5QrIFIoIegNlPx/wunAykUEqVzD4yKgWpk8DzdfT04O1a9eiv7+/4tf4fD74fD4Dj4rMwpI+VauW7LmvLVjXf0P0QID3S3khrxt+twvpXAFNfs+Sz8/kivC5XQh5hRoOaRGhfjsTExMYHh5GT0+P2YdCJmNDHNVC7+xZ9ECA90tlq1sCOHNVGIdH4gj73AuCWVVVMRrPYMvqCFa3lL92SAy6BivT09MYGBiY+/vx48dx6NAhtLW1oa2tDbt378Z1112Hnp4eDA4O4hvf+AY6Ojrwmc98Rs/DIsGxpE+10jN7Fj0Q4P2yPKfTgU9s7sJIfAb90dnqW8DrwkyuiNF4Bm0hL7af02XLc1MietUQ0DlYee2113D11VfP/b3Ua7Jz50786Ec/wptvvomf/exnmJqaQk9PD66++mo8+eSTaGqyZwZAs4wo6ZO16JU9yxAI8H5Z2cbOJnzu8nVz1bGTiQx8bhe2rI5g+zliVMfMInrVsETXYOWqq66CqlbeIfA3v/mNnv95khQb4qhWemXPMgQCvF+qs7GzCRuuCgtfQTCS6FXD+YTqWSEC2BBH9dEje5YhEOD9Uj2n02Hb6tJiMlQN5+PVS8JhQxzVS+vsWYZAQLb7RYb+CDuQoWo4H4MVEg4b4qgRWmbPMgQCMt0vsvRH2IEMVcP5TN3BlqiSUkl/c28EU+k8BsdTmErnsWV1RKh5VLK2UiDQFvKiPzqNZCaPgqIgmcmjPzotTCAgw/3CHYbFMr9qWI4IVcP5xDgKEp5epdvlvi8b4kgEsqwkEfl+ka0/wg5kqBrOx2CFVqRX6baa78uGOBKByIHAfKLeL7X0R6xuCQh/nq1ApulDgMEKrUCvpW0yLZmzGjY41kfUQEAG1fZHvD2awL8dGmFPi0FkqRoCDFZoGXqVblkSNg8bHOvHIK9+1ayqyhYUPP3mKHIFhQmMgWSpGjJYoYr0Wtom25I5q2A1q34iBnkyBU8r9UeMTGWQzStwO4s4q6uJCYzBZKgaMlihivRa2ibbkjkrYDWrfgPRJP7p+eM4MTWD1qAXHSEfXE6YGuSJGDwtZ6X+CJ/HiYLiRG9LgAkMlcWly1SRXkvbZFsyZwW1VLPoNEVR8fOXh/Dae5M4Gc/g8Ik4Xh2M4ejYNNpDXsRSOTx75CQUpfJrRbQm6xLg5ZZXX3NuD7xuJ4IV7vmA14VsocgExsY4GlBFei1tk23JnBWwmlWfF46N48D/iUJRgdaQFx6XA/miilPJDKazBWzqDBma8cteIavUH3Fiagb/4R4TeqdgMhcrK1SRXhtiybLRlpWwmlU7RVHx3NsnMZMvYlWTFz63E06HAz63E20hL2ZyBZyYyiCTLxgW5FmhQlbqjzi7uxl9bUE4nY65BGY0nlny8ttSArOxM8wExsYYrNCy9NoZU4YdN62Eg0HtTkzNYDSeQcjnRmHRNI/D4UDY78b4dBZFBYYFeacrZNaaLmECQythGkUr0mtpmyxL5qxAtg2gRJDKFeB0OLAq7MP4dBbekHNBNcPtdCCVLaC3JWBYkCfDixXrJdOeH2Q8+a5oMoVeS9tkWDJnFRwMahPyuhHwuBBo8SOVKyCWyiHsd8PjciJfVDCZyiHgceGjH+w0LMizer8XExiqhMEKkWQa2V+Dg0H15gcG550Rwbun0oilc0hlC+/3rrjwf23qwGVndhh2THaokDGBoXIYrBBJRIv9NTgYVGd+YDCRyuED3WEUFSCRyWMyncMZLUHctHWN4YEBK2RkRw51cbedZBKJBCKRCOLxOJqbm80+HFuSaSdNmS3dgdaNdK4wl1GzMVkf8wPEbGG2J2RjZ9j0wID3HcmulvGblRVqiGw7acpK9v01ZCbq1BkrZGQnDFaobnzXjHH4PiVzyRQYsOJCVsRgherCTN9Y3IGWqmGHSieDMXtisEJ1YaZvLCvvr0HasEOl0w7BGJXHHWypLlbdSVNU3IGWlrO40tnk98DldKDJ78GmzrApL1zUmqwvcCRtMFihuoj6rhlFUTEcS+PoWALDsbTUD+f5uB05LccK7wxajh2CMVoea8ZUFxF30rR6iZj7a1AlVu9p4rQzMVihuoi2k6Yd5usBcZfRkrms3tNk9WCMVibnlUtCECXTt9vKJJmW0ZIxRKx0asnqwRitjL9ZaogImT5LxGR3olU6tWb1YEwvVlrmzWCFGmZ2ps8SMZE4lU49WD0Y04PVevgYrJD0WCImmiVCpVMvVg7GtGbFHj4+vUl6LBETnWZ2pVNPVg7GtGLVHj4GKyQ9loiJ7MPKwZgWrNrDx03hyBJKJeLNvRFMpfMYHE9hKp3HltURKUueRET1sOru4qyskGWwRExEdmfVHj65jpZoBSwRE2CtJZtEtbBqDx+DFSKyFKst2SSqhVV7+BisEJFlWHHJJlGtrLjMm8EKEVmCVZdsEtXDaj18DFYEwTl2osZYdckmUb2s1MPHYEUAnGMnahxfu0BkXQxWTMY5diJt6LFkkxVPIjEwWDER59iJtKP1kk1WPInEwR1sTVTLHDsRLa+0ZLMt5EV/dBrJTB4FRUEyk0d/dLqmJZuliufhkThagh5s6AijJejB4ZE49r0wiIFo0oCfiIhKGKyYyKrbIhOZRYvXLiyueDb5PXA5HWjye7CpM4xYKodnj5yEoqgG/EREBHAayFRW3RaZyEyNLtnkqiJqBPuc9KFrZeWPf/wjrr32WvT29sLhcOCpp55a8HlVVbF792709vYiEAjgqquuwpEjR/Q8JKGU5thH4xmo6sIsrTTHvrEzLN22yERmKy3ZPLu7GX1twZoGC1Y8qV4D0SR+9Ptj+OH+d/D/PdePH+5/Bz/6/TFOG2pA12AllUrhvPPOwyOPPFL289/73vfwgx/8AI888ggOHjyI7u5ufPzjH0cyaY9frJZz7ESkjfkVz3JY8aRy2OekL13vth07dmDHjh1lP6eqKh5++GHcc889+OxnPwsAeOKJJ9DV1YWf//zn+Mu//Es9D00YVtwWmagWopXNRX8RnGjni7iy0wimpQbHjx/H2NgYtm/fPvcxn8+HK6+8Ei+++GLFYCWbzSKbzc79PZFI6H6serPatshE1RJxebDIL4IT8XwR+5yMYNpqoLGxMQBAV1fXgo93dXXNfa6cvXv3IhKJzP3p6+vT9TiN0sgcO5GMRC6ba7GqSGsD0ST+6flBvDo4AVVV0RHyIRIQ43zZHfuc9Gf6pOviKFRV1SUfm2/Xrl2488475/6eSCQsE7AQ2YUMZfPFFc+AxwUHgHS+iOFY2tDqp6Ko+PkrQ3htMAaHYzaTdzudaAt6sWFVEBPvL6fmNIM5VlrZmc4WUCiqGItnWDmvk2nBSnd3N4DZCktPT8/cx6PR6JJqy3w+nw8+n0/34yMi/chSNi9VPAeiSfz7n0ZNm3558dg4DhyNQlVVtIS88LicyBcVRJMZJLN5bOoMC3G+7Gq5PqeJ6SxeHYzB43TgyYPDCHg4dVcP06aB1q9fj+7ubuzfv3/uY7lcDn/4wx9w2WWXmXVYRJpTFBXDsTSOjiUwHEtzMzHIVTY3e7pKUVT89q0o0vkiOpp88LldcDoc8LldaAt5MZMrYiSeQSYvxvmyo0orO4djKfzhnVOYyRXxge4mnLlKnKlO2ehaWZmensbAwMDc348fP45Dhw6hra0Na9aswe23344HH3wQmzZtwqZNm/Dggw8iGAzipptu0vOwiAzDhsjyZNkQUYTpqhNTMxiNzyDsc6OgAK55KabD4UDY78apZBaRgMf082Vni1d2jsVnMDgxg4DHhQ+vb0V72A9ArKlOmeh6Zb/22mu4+uqr5/5e6jXZuXMnHn/8cXzta1/DzMwMvvzlL2NychJbt27Fs88+i6Ym+z7EyTr4Ru3KRF8eXCLCdFUqV4DTCawK+zA+nYU35F1wLG6nA6lsAT0R/9z54vJmc8zvczp2ahq/eHUIvZEAmgMLA3KRpjploWuwctVVVy3ZmXU+h8OB3bt3Y/fu3XoeBpHhRMjIRSby8uD5Tk9XlQ+aAl4XTiYyuk6/hLxuBDxuBFpcSOWKiKVyCPvdc30rk6k8Ah43PvrB2fPFap65Sn1OqVwBLqcDIV/lqU69rx0r4YsMiXTAN2qvTMTlwYtVs5ut1+VEYiavW09SqQo1k1dw3hkRrGryI5NXMJnOIZMrwudx4iNnr8LlZ3aY3l9Dp3EnZG3xLBHpQISMXAaib4i40nRVf3QaUIFfvDKEbFFZsYpRz/TM/CrURCqHs7vDKCgqkpkCJtM5rG4J4M+3rgEAVvMEIstUZ4noU4cMVoh0IEsDqQhKZXMRLTdd1R+dxlg8g+5mP1pDXgS97mV7khqZnlncvJktzF4/W9e3z72WYziWNr2/hk6TZaoTkGMhAJ+URDqQLauiysq9v8vrcgIq0N3sxwVrWlasYmjRbL1SFYrVPPHI8O43WRYCMFgh0oFMWRWtbHGgkJjJ4xevDKF10cocYGkVY3VLQLPpmeWqUKzmiUnkqU6ZFgKwwZZIJzI0kHLDuurNf39Xc8CDbFGpalM7o5qtS9W80XhmySrMUjVvY2eY1TwTiPruN5kWAjDEJtKRyFmVDPPUoqqlimHU9AyreVQrmaYOGawQ6UzEBlJZ5qlFVUtP0ompGcOmZ2TokSDt1buSR6apQ/OPgJYQfQkZyU2meWpR1VLFMLrZWuRqHmmvkQqpTAsBGKwIhqV50lu9W8gziF6o2iqGGdMzIlbzSHuNVkhlmjpksCIQlubJCPXMUzOILq/aKganZ0hrWlVIZbk2GawIgqV5Mkqt89QMopdXbRWD0zOkJS1fsinDtclgRRCNXHgsz5/Gc7GyWuapGURri9MzpBWtV/KIfm0yWBFEvRcey/On8VxUp5Z5am7hTiQmmVbyaIGbwgminjd08g2rp/Fc1KbaDetOB9Erb35GRMax2yaA1gi5LKBcaV5VZ9+smi0UcWJqBh9e1z534bE8fxrPRX2qmae2W/ZGJAuZVvJogU8YQSy+8AIeJ0amMjg1nUUqW0DA48aZHVm8Oz6NjZ1NmjZXGUWvfhIZz4UoVpqnlmkfBiK7kWUljxYYrAikdOH9/JUhHDgaxUy+iJDPjXXtIfS2+DGayGDfC4P43OXrUFBUabZJBvTtJ5Fpy2jZ2C17I5KNDCt5tMBgRTAbOsJoC3qxpj2I1S0B+NwuNPlPTwuVpjT+n3N7pCnP6730lVMVK2ukqmWn7E1rXJ1GRhB9JY8W7Pv0FtSJqRm8O57CmavCSwbe+VMaKiBFed6IfhJOVSxPi6qWXbI3LXF1GpF2GKwIptopjZl8UYryvBH9JJyqqEzLqpYdsjdAm2oIN9Ij0haDFcHUMqXR1xYUvjxvVD8JpyqWEnWVlMhTI1pUQ0Q970QyY7AimFqnNEQvzxvZTyL6uTCaiKukRJ4a0aoaIuJ5J5IdgxXB1DOlIXJ53uh+knLnQuRMXk+irZISeWpEy2qIaOedyAoYrAjISlMaZveTiJzJ602kVVKiT41oWQ0R6bwTWQXvFkFZaUrDrOBL5EzeCCKtkhJ9akTLaohI553IKhisCEzk6Z1aGR18iZ7JG8HsqtZ8ok+NaFkNEem8E1kFX2RIhikFX2d3N6OvLajrw7qWTN7Kqn1hod7qeVGnkbR+KZwo553IKlhZIUsSPZM3kghTiqJPjehRDRHhvBNZBYMVsiQ2OS5k9pSiDFMjevRWmX3eiazCHk9qsh3RM3k7kmGVG6shRGJisEKWJEMmb0cyBAOshhCJh8EKWZYMmbwdMRggEo/om2cyWCEp1Hsjzc/kk9k8pjMFhH1u+NwuKIoq1M1IRGQGGTbPZLBCwmv0RnI6HcgWijjw9imhb0YiIqPJsnkmgxUSmhY3kiw3IxGRkWTaPJObwpGwFt9ITX4PXE4HmvwebOoMI5bK4dkjJ6Eoqq7fg4jEpSgqhmNpHB1LYDiW5r1cA5k2z2RlhYSlxftkRH8nDRHVT4ZeC5HJtHkmgxUSVrkbSVVVJDMF5IoKXA4HMvnisjeSTDcjkRUYtaqE07uNk2nzTPOPgKiCxTdSLJXFsWgKsXQOBUWBqgI+txPjySzQXd33WEykm5FIdkZVOmTqtRCZTJtnsmeFhDX/5XIT0xkcGp5CNJmB3+NES8CDQlFFQVHxzJujGIgmV/weWrygjojKK1U6Do/E0RL0YENHGC1BDw6PxLHvhcGK92g9ZOq1EFlp88y2kBf90WkkM3kUFAXJTB790WmhNs9ksELCKt1IrUEvXj0+icRMHi3B2erIVDqP5oAHH17Xhsl0vmKTrEw3I5GsjG5kPz29W74iGvC6kC0sP0VMs2R5Qzhr3yS0jZ1N2LGlG4eGp1BUVUzN5OF2OtHZ7MeZq8JoC3nhdTuXbZLlTrZE+jK6kZ3Tu9qS4TUY/E2S8FY1+bC2PYBVYT+Kqgqvy4km/+n51WqaZGW4GYlkZXQju0y9FrIQ/TUYDFZIeCGvGwGPG26XA61+75LPV5tFiX4z2oHo7x+h+hhd6eCLSu3H9GBl9+7duO+++xZ8rKurC2NjYyYdEYmGWZQ1cE8M6zLjHuX0rr2YHqwAwDnnnIPf/va3c393uVwmHg2JhlmU/LgnhrWZdY9yetc+hAhW3G43ursrbJRBBGZRMuOeGPZg1j3K6V17ECJY6e/vR29vL3w+H7Zu3YoHH3wQGzZsMPuwSDDMouTEVx7YB+9R0ovpwcrWrVvxs5/9DGeddRZOnjyJBx54AJdddhmOHDmC9vb2JV+fzWaRzWbn/p5IJIw8XDIZsyj58JUH9sJ7lPRg+qZwO3bswHXXXYctW7bgYx/7GJ5++mkAwBNPPFH26/fu3YtIJDL3p6+vz8jDJaIazV8pUg73xCCilZgerCwWCoWwZcsW9Pf3l/38rl27EI/H5/4MDw8bfIREVAu+8oCIGiVcKpPNZvH222/jiiuuKPt5n88Hn89n8FERUb24mks83O9GPPydLM/0YOXuu+/GtddeizVr1iAajeKBBx5AIpHAzp07zT40ItIIV3OJg/vdiIe/k5WZHqz8z//8D/78z/8c4+PjWLVqFS699FK8/PLLWLt2rdmHRkQa4koR83G/G/Hwd1Id04OVX/7yl2YfAhEZhCtFzNPofjecptAe9yCqnunBChFpjwMLLVbLfjerWwILrp+ZXBH73+I0hda4B1H1GKxIiAMRLYfz3/ZS7fOg2v1u3h5N4N8OjcxdP7mCglPJLJoDHmzqDHOaQkPcg6h6DFYkw4GIlsP5b3up5XlQzZuRswUFT785ilxBmV215fHj5XcnMJbIoKgoyBeDcDkdnKbQiNFvq5aZcPusUGWlgejwSBwtQQ82dITREvTg8Egc+14YxEA0afYhkokWz383+T1zA8umzjBiqRyePXISiqIu+XfDsTSOjiUwHEsv+TyJqdbnwUr73YxMZZDNK8jmi3PXTzpXRCpXRE+zH5m8gmOnUnP/dvE0BdWOexBVj+GaJNiIRSupZ/6blTo51fM8WGm/G5/HiYLiRG9LYO775YoKCkUFHr8bYYcbsVQOyUwBzYHZKgCnKRrDPYiqx8qKJGoZiKyI2f/KTs9/l89BAl4XsoXi3MDCSp286n0elPa72dwbwVQ6j8HxFKbSeWxZHcE15/bA63YuuH68LifcLifyRRUelxNFRUGuqMx9ntMUjVvud8Jp29N4hUnCzEYssxt6mf1Xp5b5b1bq5NbI86DSfjcnpmbwH+6xBddPk9+N1qAXp5IZhHwuuJxOeF2zOW5p6mhNewDJbB7DsTSb/evEPYhWxmBFEmY1YpkdKLBhtHql+e/DI3GEfe4FGXdp/nvL6sjcwMQlk/Jq9HlQbr+bctePw+HAxs4wkpk8xhJZnNEaQMDrQjKTR390GomZPAqKgkd+N8AkokHcg2h5nAaShBmNWGZPE9TbMGpXpfnvtpAX/dFpJDOzA0lpYJk//13rlBGJRY/nQaXrx+NyoDXoRXezH61BL96bSGEolkZiJo9mvwdr2oKcQiTdsbIiCaMbsUSYJmD2X7tq38HDJZNy0+t5UOn62XZmOz72oU4EPG4kM3k89cYI3E4Hzupq4hQiGYJPIokY+TI4EQIFbphUn2rmv2uZMiIx6fU8WOn6GY6lMT6dXbBqqIRJBOmFwYpkjGrEEiFQYPZfv5Xmv7lk0hr0eh4sd/2Y8Wwwu8lfNlY8X3zK60ivC8aIRiwRAgVm//oyslJH+jG6MdPoZ4PZTf6yser5YrCiofnByXgyi0NDU3h3PCXlBSNCoMDsX39cMkm1MvLZwNWAtbHy+WKwopH50ez4dBbDsTQ8bic29zZjQ0dYugtGlECB2b/+uGTSGowq/Rv1bBChyV8mVj9fDFY0MD+a7W72Y2RqBqqqoqio6I+mEPJ50BbySnfBiBIoMPsnWp7RpX8jng0iNPnLxOrni8FKgxZHs8lMAVMzebSEvPC6nIilcjh2ahqtwVYpLxhRAgVm/5VZsZmOqmdW6V/vZ4MITf4ysfr5YrDSoMXRbK6ovL+R0uxcbti/8OVfMl4wDBTEZdVmOqqO2aV/PZ8NIjT5y8Tq54s72DZo8U6gXpcTbqcT+fdf9uVxOVGY9/Iv2S8YEofZOwyT+az8glMzdu2WmdXPF4OVBs2PZoHZF3+1Bb2YzhSgqiryRQXu91/+ZYULhsTAVxEQUPubtmVSy+sjyPrni8FKgxZHsw6HA2d2hhDwujAxncVkKo9IwANAreuCURQVw7E0jo4lMBxLc/AhANbOqKl6i5OlxUqV3KDHJeVzpNTIu7k3gql0HoPjKUyl89iyOiLFqkqjWfl8cS6iQeWW8TUHZrPbwycSUFQVPrcT8ZlCzZ3y7EegSqzeTEfVqWbPk56IH/92aETaPZ9EafKXhVXPF4MVDVRaxvfp81fj3L4IVjX5ar5grLy5DzXO6s10VJ2V9jxxOR2IJrNzQYuszxE2+dfGiueLTzKNaBnNmt3hT+ITYYdhEkOlZGlzbwQT01mMJjJ8jhiIWwnog8GKhrSKZq2+uQ81TpQdhkkM5ZIlRVXx//62n88RA3HqXj8MVgTEfgSqhig7DGtN5MxU5GNbnCwdHUvwOWIgTt3ri8GKgNiPQNWSuZmu3MD/7vi0sJmpbFkznyPG4dS9/niVCoj9CFQLGZvpyg38LUEPosksiooqXGYqY9bM54hxOHWvP+6zIiCrb+5DxhJtr55yO+9GAh483z+OPw1PoT3kFWqTO1k34ONzxDhW3pxPFKysCMqq/QhkLNGmLiqVywHA4QCcDgfeHU+hLeSd+5zZmanMWTOfI8bglJv+eOYEJnM/AplPxKmLSgN/rqigqKqIBD0LXvxZYmYzqOwN73yO6I9TbvpjsCI4GfsRyHyiNvxVGvhLLwAF1AUv/iwxMzO1QtbM54i+uJWA/tizQmRBor47qNK7bEovAI2n83A7HPC6Tj+azH4BqNXfZkvasMp7eUTrcSsRNxUgorqJOnVRqVzucDiwYVUQw5NpzNZUZissImSmzJqpWrJPuYnW4zYfgxUiC9Jj6kKLDdGWG/gnUnmc19eCzrAPUzN5RJNZYZpB2ahaP5E30tODrFNuIva4zcdghciCtG740zLjWmng39AhZmYqe9ZsBpEzdTpN1B63+RisEFmQllMXemRcKw38omamsmbNZhiIJvFPzw/ixFQabUEvOkI+uJwOYTJ1UZlRiZJheT6DFR0sd7HZrSRK5tFi6kLPjIsDv/jqfV4pioqfvzKE1wZjcDhmB0O304m2oBcbVgUx8f5Getx+fiGzKlGi9rjNx2BFY8tdbABYEtWAFQI+o36GRqcuZMi4SB+NDJwvHhvHgaNRqKqKlpAXHpcT+aKCaDKDZDaPTZ1hXjeLmNkzIsPyfAYrGlruYnt7LAEAQr73RCZWmAM3+mdopIIhQ8ZF2mtk4FQUFb99K4p0voi+1gBcztll6D63C96QExOpHN4dTyHsc+PYqWkpkw2tmd0zIsOmdgxWNLLcxRbyuvCbt04CKvCJc7rgfP/mFal5SQaid6tXQ7afQYaMy870qNA1OnCemJrBaHwGYZ8bBQWYt2UOMvki0tkCTiYyCHld+MUrQzhyIiFVsqEHsyuYMizP5xNGI8tdbNPZIorvb6wznS2iOXD67mUpvTpmZx5akPFnkCHjsiu9KnSNDpypXAFOJ7Aq7MP4dBbe99/zNJMrYCyRQS5fhKIAXc0B9Lb4hQ3UjSRCBVP05fkMVjRS7mJTVRXJTAEnkxnkiwo8TseSbcQBltKrYXbmoQUZfwYZMi470rNC1+jAGfK6EfC4EWhxIZUrIpbKIeRzY2I6h2xegepwwOt24MxVITQHZt+wLWKgbiRRKpgiL89nsKKRxRdbLJXDQHQak+kcZnIFxFI5eFzO97cZ9y34tyylr0yEzKNRsv4MomdcdlNLhQ5AzQNPowPn/GrceWdEcOxUCtFEBvFMHm6nAy6HA2vag3MBuaiBuhaqnaYTqYIp6io9jo4amX+x5QoK/vQ/cczkCgj7PQh5nYin88gXFbwzlkTY50ZbaDZgYSm9OqJkHo2Q+WcQOeOym2ordC8eG8efhuM1TxM1OnDOr8ZNpHI4uzuM9rAX6fcK8DidaA54sGV1y4LvK2qg3ohapulEq2CKuOJSvKeipEoX24mpNF4djCGbV7CqyYuCoiI+U8Cq5tngZDyVw1ujCWxd345MnqX0aomUedRL9p9B1IzLbqqp0A1Ep/HzV4egqqh5mkiLgXNxNS6VLcDtdGJVsw8f6omgLeRd8PUiB+r1qGeaTpQKpqgrLoW4Mh599FE89NBDGB0dxTnnnIOHH34YV1xxhdmHVbONnU34v7f04NDwFIouB+IzebicTnQ2+3HmqhAAB94aiSOayOLt0QRag16W0qskWuZRDyN/BhEzI9LGShW6dLaA8eksHA7gvDNa6mrk1mLgnF+NS2byeOqNEQzFUmgNLjxmGQL1WjTSSG92BVPk1YqmBytPPvkkbr/9djz66KO4/PLL8Y//+I/YsWMH3nrrLaxZs8bsw6tZR5MPa9tDWBX2oaiq8LqcaPKfzqK3bmjD26MJ/K9L+rC5N8JBpAbVvFNmOJYWeoA2InsSNTOSnSgB4EoVunfHUwAc2NARaqiRW4uBc341zut2Yt8Lg9ImG9VqtJHerAqm6KsVTQ9WfvCDH+Av/uIv8PnPfx4A8PDDD+M3v/kNfvSjH2Hv3r0mH13tZjvhXXC7HGj1e5d8PpNX0Br0YXNvhCX1OpR7gPY0+/HS8Qn875ffw2g8A6fDgYBH3AFaz+xJ5MxIZiIFgCtV6MI+N1QVCPmWVl2A2vpDlhs4VwreFn9+Q0dYiGkOvcnaSC/6akVTg5VcLofXX38dX//61xd8fPv27XjxxRfL/ptsNotsNjv390Qioesx1kr2vgQZzH+ADkSTePCZt3Hg/0Qxky8i5HNjVdiHgOD7N+iRPYmeGclKxABwuQrdljMi+Nf/OqFrI/dANIn/eHMMb56II5UvIORxY8vqCD65pRsbO5uWDe6+dNWZQlSo9CJrI73oQZapZ2t8fBzFYhFdXV0LPt7V1YWxsbGy/2bv3r247777jDi8uliht0IWs291PY7X3puEogJntAZQUFSMT2eRyhVw3hkRW70wTfTMSEYiB4CVKnQA8N/Dcd0SpoFoEg//th/vnEzObXYJAMcnUjh6MonPXLAavzsaFSq4M5KsCavoQZZz5S/R3+IHq6qqSz5WsmvXLsTj8bk/w8PDRhxiTUpZz+beCKbSeQyOpzCVzmPL6ojlb1SjlAaRE1MzcAJoDXnhcjrhc7vQFvJiJlfEu+NpdDf75gZoqzudGZV/mAS8LmQLReHKzyKrJQA0Q6lCd3Z3M/ragnA6HXMJU1vIi/7oNJKZPAqKgmQmj/7odEMJk6Ko+PnLQ/jT8BSKioomvwdtodmN3YqKij8NT+HRAwOYmM5iU2cYTX4PXE4HmvwebOoMI/Z+8qDMC3KsRs/zr6dSkDUaz0BVF/5+SkHWxs6waUGWqZWVjo4OuFyuJVWUaDS6pNpS4vP54PP5yn5OJGZ3dcui3qbF0iDSGvTixOQMPK7T/8bhcCDsdyOWyqGowDYDtOiZkYxEL41Xolcj9/BkGi8fj8HpcKD9/W30AcDndsAb8mJkKoOB6DTWdwRtXd0TZRlyLUSfFTD1qeX1enHRRRdh//79+MxnPjP38f379+PTn/60iUemDe5LsbxGmhZLg0hHyAe3y4l8UYXPffom8ricSGULSGTythigFUWFqqpo9ntw7NQ0zl0dmXthJiB2+VlkMgeAeiRMx8dTmJrJYVXYVzYYCfpcGJ/OIlMoXzkRNbjTg4wJq8hBlul32J133ombb74ZF198MbZt24Yf//jHGBoawhe/+EWzD4101GjTYmkQcTmB1qAXp5KZuRemAUC+qMDpcGAyncPW9e2WHqDnB33j01kMx9IYjWewubcZPS0BYTIjGcnaf1CiR8LkUAEV5YMRpwNwOIBcoVj28yIHd3qQMWEVNcgy/Yq54YYbMDExgfvvvx+jo6PYvHkznnnmGaxdu9bsQyOdaNG0OH8QOXNVCNPZ2fcvhf1uuJ0OTKZy8LldOKMlaOkBenHQ19sSQEfYi8MnEnhjaArj0zl0hH1CZEYyEr00brQNHSFEgh4k0nn4m11LgreZXBFhnxuZvLKk91CG4I5miRhkOdTFnTSSSSQSiEQiiMfjaG5uNvtwqArDsTR+uP8dtAQ9ZUvryUweU+k87vj4WcveMPMH6oDHiRNTMxifziGVLSDgceHqsztx09Y1lh2gFUXFj35/DIdH4guCvtnPKfjvE3Gs7wjhc5evR19rsOEBVZRN0cwwv3qVLcxWBzZ2hm0XACqKigeefgv73zoJr8uBpoAHHpcT+aKC5EweuaKKS9a1we9xYjKdLxvcWWWRgZ3vB63UMn6bXlkh+9GqaXHx/Gp7yIuWgBe9LQF89IOduOzMDks/PJZbqeJ0OnHmqjCm0nk4HY6Gz4NIm6KZQdTSuNGcTgdu2roG0WQW74wlkcwUAKgAHHA5nTivtwlfvvpMABCy70Erdr8fzMBghQynZdOinQcRo1aq6L0pmiwZqoilcTNs7GzC7R/bhP84PLspXDpXRNDrwrmrWxYM1la9L0XcJNAOGKyQ4bRuWrTrIGLEShW9N0VjhiqnjZ1N+PIKwYgV70uRNwm0OiE2hSN7kXXTJNEYsYmTnpuilTLUwyNxtAQ92NARRkvQg8Mjcex7YRAD0WTdx036K7chndWJvkmglTFYIVNwl9/GGRH06bUr7uIM1Y47nZJ8uEu0eTgNRKaxc7+JVvTexEmvqSZZ3mMkSz8NGUPmTQJlxzNKprLivLbR9Az69NoUTYZt7NlPQ4vJvkmgzBiskDCYxdZPr6BPr03RRM9QueKDyuEmgeZhsEJCYBYrLj2mmkTOULnig5Yj8vtzrIzBCpnOSlmsVatDWk81iZyhytJPQ+Zhv53xGKyQqayUxVq9OqT1VJOoGaoM/TRkPvbbGYvBCpnKKlmslapDRhIxQxW9n4bIjni3kamskMVaqTpkBtEyVJH7aexClulUWY7TChiskKmskMVapTpEs0Tup7EDWaZTZTlOqxB3BCBbsEIWW0t1SMZMTMZjbpSo/TRWJ8t0qizHaSUMVshUsmexiqIiMZNHNl9ENJFBd5nqSqk6NJ7M4rm3olJlYnbOHkXsp7EyWaZTZTlOq2GwQqaTNYstDeQD0SSGJ2fw9mgSa9uC2NgVRlvIB+B0dagn4sczb45iMp2XJhNj9iheP42VyTKdqsdx2rF6WSsGKyQE2bLYxQP5xWvb8Pp7Mbw7kUIsncNFa1vh97hmq0NBL6ACk+m8NJkYs0cymizN9lofp52rl7XgW5dJGLK8cr7cG4NXNfnw4fXt2NARQjJTwOvvTWIylcOW1RF8cks3pmbyUr1WvpbskUgL85vty2mk2V5RVAzH0jg6lsBwLN3Q27y1PM5S0nN4JI6WoAcbOsJoCXpweCSOfS8MYiCarPs4rYaVlRqwVEdA5YG8LeTFJevacEZrALFUHn++dQ0uXtuGd6JJKTLG+WTJcsk69Gq217pyodVxsnpZGwYrVWKpjkqWG8gdDgc6m/1I54poDnjgdDqkXJ4t4zGT3PRottej70qr45SlR0cUnAaqAkt1NF+tZeBSJjYaz0BVF5afS5nYxs6wUMuzZTxmkl+p2X5zbwRT6TwGx1OYSuexZXWk5sCi3HSty+lAk9+DTZ1hxFI5PHvkZF1TQloc5+mkp3zAH/C6kC0UWb18H9OiFbBUR4vVWgaWcXm2jMdcD07tikerZnstKhfLXR+NHierl7XhWViB3Ut1fJgvVc9ALuPybBmPuZJy1/G749Oc2hWUFkvGG+27qmbqv5HjtMKGmEZisLICOzcask+nsnoGctmWZwNyHvNi5a7jlqAH0WQWRUW17R4yVtdI5cKIPYbsUr3UCoOVFTRywctcleCGYCurZyCXcZMxGY+5pNx1nMoW8Hz/OGbyRVx51qq5+5pTu9ZSb+XCyKl/K1Uv9cZgZQX1XvAyVyXYp1M9mQdyq6t0HQOAwwE4HQ68O55CW8g79zk7TO3aRb2VC6On/q1QvTQCg5UV1HPBy16VsHufDunLqIpjpes4V1RQVFVEgh7EUjkkMwU0B05XTa08tWs39VQuzJj6Z9KzMgYrVajlgrdCVWL+zaqqKpKZAnJFBV6XE01+Nx/mVDcjK46VBh2vywm30wlARUFRkCsqCz7PVRjWUmvlgqt0xMSzXaVqL3grVCVKN+vIVBpj8Sxi6RwKigK304m2oBfdER9vVqqZ0RXHSoNOk9+NtqAXJ6bSCHhc8LpObzfFVRjWVEvlgqt0xMRN4WpQzbtrrLDRz+qWAFqCHhwcnMTJxAz8Hidag174PU6cTMzg4OAkWoIe3qxUNT036Kqk0sZ2DocDG1YFoajAbE1ltsKSzOTRH53mKgybK039t4W86I9OI5nJ8/oQAFNjjVmmhFh6ti+qDs3+XQVvU6qFGRXH5frNJlJ5nNfXgs6wD1MzeUSTWa7CoDkyrdKRedVpLQQfMeVjhRLiiakZTM3kccm6VozGs5hM5zCdLcDtdKKr2Y/uZh8m03mhp7JILGbtV7TSoLOhg6swqDwZVunIvOq0VgxWNGaFjX5KA8uGjjDOaA0uabAtqioGx1NCT2XRLFGyLjMrjisNOgy4qRKRV+nIvuq0VgxWdCBTCbGcxQPL/GWdADCTLcgxlWVzImVdZlccRR50iGplhVWnteJooxORS4grZdtmDyzUONGyLitUHIlEYYVVp7VisKIjEbO5al/OxYFFXqJmXbJXHO1IlGnERljhZ1jMju+sY7BiI7Vk2xxY5CVy1iVyxZEWEmkasV5W+BnKscyq0xpY5yehZdWTbXNgkZNIWVelrFakiqMVM+9GiTaNWA8r/AyV2HGqnsGKTdSbbYs2sMjMqEFRlKxLj6y2UFDwX8OTmEjl0B7y4sK+Vrjd9e9tadXMuxGiTiPWwgo/QyWl58im7jDeOZnEOyen0dti/al6Bis2IVK2PZ9dslojB0URsi49strn3j6Jx18YxOBECvmiAo/LiXXtIdxy+Tp89INdQhyjTCrdeyJPI1bLCj9DOYufI7mCgmxewVAsDZ/baempegYrNiFKtj2fXbJaowdFsxuk9chqn3v7JPb++iiSmTzaQ965n+edaBJ7f30UAGoKWKyceVdjuXuvoKhCJja1EDU5a0Sl58jI1Ax8Hheu2dKDD/Y0Wzbh47uBbKLSe1KA09n2xs6wYXOcpRvv8EgcLUEPNnSE0RL04PBIHPteGMRANGnIcejNjHfiAKcbpDf3RjCVzmNwPIWpdB5bVkd0rxjUktVWo1BQ8PgLg0hm8ljTGkCT3wO304kmvwdrWgNIZvJ44sVBFArKyt9Mp2OUyUr33qlkdi6xKUeG5s35yVk5MvwM8y33HDmrqwm5goKB6LRlAxWAlRXbMDvbns9OWa2Z5WizGqS1zmr/a3gSgxMptIe8cDoX5ldOpxPtIS+Oj6fwX8OT+PD6dlOOURbV3Hv/PRzHho4QjowmpG3eFGEqVEtWndaqBSsrNmJmtj2fnbJas9/CXc2bwrWmdVY7kcohX1QQ8LrKfj7gdSFfVDCRypl2jLKo5t47dmoa569pkfqtw1Z7c7LZzxERWOtOpBWJsBzZTlmtiL1CetM6q20PeeFxOTGTK6LJvzS/mskV4XHNVljMOkZZVHvvdTT5pN9nqdq9omRo8rfjc2QxU3+ydevW4b333lvwsb/5m7/Bd77zHZOOyB7MXo5spxvPjoOi1lOOF/a1Yl17CO9Ekwh5XQumghRltqLyga4mXNjXatoxyqKWe6+vLYgNV4UxPJnG8fEUAGBDRwhntMozzbBSciZLk78dnyOLmT4a3H///bj11lvn/h4Oh008GjKCnW48uw6KWu6A7HY7ccvl67D310cxNDmzYDXQRCqHZr8HOy9bV/N+K3bcpXmle29kKoM17QEks3kMx9KYyRWx/y3xB/PlVErOZFq6btfnyHymBytNTU3o7u42+zDIQHa78ew4KALaTjmWliWX9lmJpXLwuJz4QFcTdl5W3z4rWh+jDJa79/qj00jMzPZ2PPK7AeQKCk4ls2gOzK5cE3kwr5WMTf52fY6UONTF61gNtG7dOmSzWeRyOfT19eH666/HX//1X8PrrTz3nM1mkc1m5/6eSCTQ19eHeDyO5uZmIw6bNDK/BJstzJafN3aGLXvjyTA3Ljqtd7C1q8X3XrYUmPg92NQVRsDjwsvvTuB/pmawKuzFBWta0RbyAZitwPRHp7FldQRfvPJMKa/h4VgaP9z/DlqCnrLTYclMHlPpPO74+FnCra6x0nMkkUggEolUNX6bWln56le/igsvvBCtra149dVXsWvXLhw/fhw/+clPKv6bvXv34r777jPwKEkvdsxqRXvwycbtdla9PJkqm3/vJTN5PPXGCNxOB87qaoLD4UBiJo9UroieZj+mswUcO5VCa9ALh8NhiaWyMjf52/U5onlKsnv37rkLutKf1157DQBwxx134Morr8S5556Lz3/+83jsscfw05/+FBMTExW//65duxCPx+f+DA8Pa/0jkIHMWFo7n6KoGI6lcXQsgeFYuqrN2er5N0SiKd17TX4Pxqez6G0JzE2H5IoKCkUFHrcTYb8bsVQOyczpgVv2pbJ2XbouM81/E7fddhtuvPHGZb9m3bp1ZT9+6aWXAgAGBgbQ3l4+e/L5fPD5fA0dIxFQ30oAWVYPEFWrXJXB63LC7XIiX1ThcTmRyhaQK57eIVj2wdxOTf5WofmV1tHRgY6Ojrr+7RtvvAEA6Onp0fKQiJaoZyWALKsHrDSnLQuZz3m55cxNfjdag16cSmYQ8rngcjrhdc0W4q0wmNutyd8KTAuLX3rpJbz88su4+uqrEYlEcPDgQdxxxx341Kc+hTVr1ph1WGQD9awEkGX1ACs/xpP9nJerMjgcDmzsDCOZyWMskcUZrQEEvC4kM3nLDOYirq6ROejVm2nBis/nw5NPPon77rsP2WwWa9euxa233oqvfe1rZh0SWcRKN3w979mQ4d0cslR+rMQK57xSlcHjcqA16IXLOfu/702kTB/MtSZSk7/sQa/eTAtWLrzwQrz88stm/efJoqq54etZCSD66gFZKj9WYqVzXqnKsO3MdnzsQ50IeNymD+Z6EWF1jRWCXr3J2R1FVEa1N3w92/2L/ooAGSo/VmO1cy5SlcFOrBT06om7KZElLL7hm/weuJwONPlnd9+MpXJ49shJKIo6N0c/Gs9g8Z6IpebBjZ3hBc2D9fwbI/GtrMaz4jk3eysBO7LTW+gbwWCFLKGWG76e18eL/sp57hthPCudc+4dZB4rBr16EP8uIqpCrT0l9awEEHH1QAn3jTCeVc45GzvNJfoUsyjs/dOTZdRzw9czRy/qvD73jTCeFc45GzvNZ5WgV28MVsgS6r3h61kJIMLqgXJErvxYlcznnI2dYrBC0GsEBitkCbzhZ1VT+eHGU9oStdq2EqutZpKZzEGvURisWAAHn1l2vOEr/e4rDS7sT9CHqNW25Yi+d5DdiBr0ijK+MFiRHAefhUS94fVQ6++e/Qk0Hxs7xSNa0CvS+MKrUGIcfMoT7YbXQ62/e/Yn0GJs7KTlvHMygX84cAwT01n0RPxY3x7CTL5o2vjCfVYkVcsmaGQt9fzuufEULSb63kFknnfGkvj2r97GweMxjMUzePNEAv81NIV8UTVtfGGwIikOPvZVz++eG09ROaU+r829EUyl8xgcT2EqnceW1RHbVmbtbiCaxD8cGMCxU9NoCXrQGvLC73HhVDKDQ8NTmEznTRlfOA0kKbs1x4nS5CWCen737E+gSuzU50XLK1VtJ1JZBLxOhHxuOB0O+NwOeENexFI5HDs1jfP7IoYnN3wyScpOg49ITV4iqOd3z/4EWo4d+rxoZaWqbW8kgPHpHPJFBT63C8Bs1TbsdyOWyuFUMmv4+MJpIEmJ/mI9rZQaSQ+PxNES9GBDRxgtQQ8Oj8Sx74VBDESTZh+i4er53bM/gYhWUqrarmryoS3oxXSmsOAZ43E5USgqpowvDFYkZYfBh03E5dX7u2d/AhEtp1S1nckXcWZnCAGvC7FUDtlCEYqqIpUtIJ0roj3sM3x8kX+OwMasvgkad9isrN7fPfsTiKiS+dPFmzrDOL+vBceiKcTSOUxn8kjnFGzsDOMrV5/JfVaoNlYefOzWRFyren/37E8gonLKvbbk/DUtOJXMYjQ+g/awD1+5aiPO6jI+EWawYgFWHXys1kSsx4omq/7uSVxcmWdti6u22cJs1fayMztMrdjL8ZQnW7LSChauaCIr4HVsDyJW7BmskLCs8iZlvhaBrIDXsb2IVrXlaiASmuwrWLiiiazADtexoqgYjqVxdCyB4Vha6p/FilhZIeGJWJKsFlc0kRVY/Trm9Jb4GKyQFEQrSVaLK5rExUbR6ln5Oub0lhwYrBDpyGormqyCmXRtrHodL57eKlWNmvwehH1u9Een8eyRk9jQEWYgazL2rOiM86D2ZpfXIsiEr3ConVWvYyu+vd6qY45cYbBkmL2RVVY0WQUz6fpY9Tq22vSWlcccBis64TwolWj9WgT2WtTP6o2ierLi6z2sNL1l9TFH/N+AhJi90WJarWiycuZkBKtl0kaTeWVeOVbZeNIOYw6DFR0Ynb3JnmnLfvzVanRFk9UzJyNYKZM2i6wr88qxyvSWHSqGvCN1YGT2JnumLfvxG8UOmZMRrJJJk3asML1lh4ohgxUdGJW9yZ5py378RrJD5mQEq2TSpC3Zp7fsUDHk0mUdGLHMT/btr2U/fqOdzpzKP2wCXheyhaLUmZNRZH+FA+mjNL11dncz+tqC0gQqgHWXls8nb5glMCOyN9kzbdmP32h2yJyMJHsmTTSfHSqGfLLpRO95UNnnKGU/fqOx10J7VmoUBezTqE7lWaH3ZjkMVnSkZ/Yme6Yt+/EbzQ6ZE9WPjer2Uy44tXLFkCOBzvTK3mTPtGU+fq0y2Fq/j9UzJ6oPG9XtZ6Xg1EoVwxIGK5KSPdOW9fi1ymDr/T5WzpyodlzSbj/1BqeyTxMyWJGY7Jm2bMevVQbb6PexWq8F1Y+N6vZSb3BqhWlCBiuSkz3TluX4tcpgmQmTltiobi/1BKdWmSZksGIBsmfaMhy/Vhms3pmw7KVeqg0b1e2l1uDUSskRr2CiKmiVweqZCVuh1Eu1kblRnWpXa3BqpWlC7mBLVIX5D4ly0tkCCoqKsXgGw7F0xZ13V/o+9WbCpVLv4ZE4WoIebOgIoyXoweGROPa9MIiBaLKm70dyKDWqt4W86I9OI5nJo6AoSGby6I9OC9uoLhpFUTEcS+PoWGLZ+9dste5Ua6Wdr1lZIarCchnsxHQGrx6fhNvlxJMHhxDwuCtWNPTIhK1U6qXaydaoLhqZKpK1rqJcqRKTzhZQKM4mWaJPGzNYIapCpYfE6NQMDg5OAgAuWd2M3pbgss1reizZtlKpl+ojS6O6aGRsPq0lOF0+ycri1cEYPE4Hnjw4jIBH3CAN0DlY2bNnD55++mkcOnQIXq8XU1NTS75maGgIX/nKV/C73/0OgUAAN910E/7u7/4OXq9Xz0Mjqtnih8RYPIPBiRQCXhc+vK4N7WEfgJUrGlpnwlwRQoAcjeoikbkiWW1wWk2StXld64pJlgh0DVZyuRyuv/56bNu2DT/96U+XfL5YLOKaa67BqlWr8Pzzz2NiYgI7d+6Eqqr4+7//ez0Pjagu8x8Sx05N4xevDKG3xY/mwMLgeqWKhpaZMFeEENVO9opktcHp0iRrBoMTMwh4XPjw+la0h/0AxA/SdH163XfffQCAxx9/vOznn332Wbz11lsYHh5Gb28vAOD73/8+brnlFuzZswfNzc16Hh5RXUoPiVSuAJfLgZBvaYAArFzR0CoT5ooQotrZqSK5JMl6dQi9kQCaAwufXSIHaaauBnrppZewefPmuUAFAD7xiU8gm83i9ddfN/HIiFam18qeWnFFCFHtRLl/jVJKjrojfricDoR8cq0QMjVYGRsbQ1dX14KPtba2wuv1YmxsrOy/yWazSCQSC/4QmaHWZYR6KpV6N/dGMJXOY3A8hal0HltWR4ScfyYyW6P3ryzLnReTNUir+Wh27949N71TycGDB3HxxRdX9f0WzxUCsxdKuY8DwN69e1f87xMZQbSXMXJFCFH1Grl/ZVruvJis08Y1Byu33XYbbrzxxmW/Zt26dVV9r+7ubrzyyisLPjY5OYl8Pr+k4lKya9cu3HnnnXN/TyQS6Ovrq+q/R6Q10fa44IoQourVc//KuNx5PtGSrGrVHKx0dHSgo6NDk//4tm3bsGfPHoyOjqKnpwfAbNOtz+fDRRddVPbf+Hw++Hw+Tf77RFpgRYNoIZneUVXL/Svzcuf5REuyqqHrpNTQ0BBisRiGhoZQLBZx6NAhAMDGjRsRDoexfft2fOhDH8LNN9+Mhx56CLFYDHfffTduvfVWrgQiqbCiQTTLzCmSeoOkau9f2Zc7zydbkqVrsPKtb30LTzzxxNzfL7jgAgDAgQMHcNVVV8HlcuHpp5/Gl7/8ZVx++eULNoUjIiK5mDlFYkSQZLXlzjIlWboGK48//njFPVZK1qxZg3//93/X8zCIyGZkmoawCjOnSIwKkrgBo3l4RonIUkRYqWHHYKneKZJGz5WRQZKsK2msgMEKEVmGCCs1RAiWzFDPFIkW58rIPhJZV9JYgambwhERaWVxht3k98DldKDJ78GmzjBiqRyePXJS1827SsHS4ZE4WoIebOgIoyXoweGROPa9MIiBaFK3/7bZat1sTKtzdTpIMmZHVm7AaA5WVmzOjuVqsiajMuxK94yW0xEy3pe1TJFoea7M6CORbSWNFTBYsTG7lqupMhkHyRIjVmosd8/43C5NgiVZ78tapkiGY2nNAkuz+khkWkljBQxWbEqEuX0Si6yDZIneGfZK98yVZ61qOFjS+77UOxitdrMxLQNL9pHYA4OVCmTOMFdilV0YSTtWCF71zLCruWdef28SPpez7mBJ7/vSqGC0mikSrQNLGXdkpdowWClD9gxzJVbahZEaZ5XgVc8Mu5p7JprIYFWTD8OTM3UFS3rel0YHoytNkegRWLKPxNoYrCyi1U0tcmXGarsw0kK1XntWCl71yrCru2cUXLy+DancqbqCJb3uSxGDUb0CS/aRWBeDlXm0uqlFr8xwF0brqufas1rwqkeGXe0988HuZmzoCNUVLOl1X4oajHLqhmrB0WgeLW5qGeb+uQujNdV77VkxeNU6w67lnnE6HXUFS3rdlyIHo5y6oWrJ8/QxQKM3tYjl1nJE7Z4XeepMdI1cewxeV1brPVNPsKTXfSl6MMqpG6oGg5V5Gr2pRS23liNaCVb0qTPRNXLtiRq8isaIe0aP/waD0cYwiRIDg5V5Gr2pRS63liNKCVaGqTPRNXrtiRa8isqIe0br/waD0foxiRIHg5V5Gr2pRS+3lmN2CVaWqTPRaXHtiRK8is6Ie0br/waD0doxiRKLOKOmIBq5qVlurZ1MU2ci0+raMzt4Je2VpjEKioprz+uBCmAmX2QwugwmUeJhsFJGvRkmy621k23qTFRaXHucm7ee5aYxGJRWxiRKPAxWKqg3w2S5tTaiT53JNIA3cu1xbt56OI1RPyZR4mGwogPO/VdP5KmzRgdwMwKdeq49DmrWw2mMxoieRNkRz7ROOPdfHVGnzhodwM2sVNRy7XFQsyZOYzRG5CTKrpxmH4CVKYqK4VgaR8cSGI6loSiq2YckpNL0xebeCKbSeQyOpzCVzmPL6ogpWf3iAbzJ74HL6UCT34NNnWHEUjk8e+Rkxd9nKdA5PBJHS9CDDR1htAQ9ODwSx74XBjEQTRr68yynlkGN5HF6GqN8PhrwupAtFDmNUUEpiWoLedEfnUYyk0dBUZDM5NEfnWb/oQlYWdEJewBqI9LUWSNZqWyVCs7NWxOnMRrH/kOx8ErVAXsA6iPK1FkjA7hs5XcOatbEaQxtiJRE2R2ngTTW6BQCmW/+AF7OcgO4bOX30qA2Gs9AVRdek6VBbWNnmIOaZDiNoZ1SEnV2dzP62oI8ZyZhsKIx9gDIr5EBvJFAxwwc1KxLtF4w0p6d+iLFeGJaCHsA5NfICiUZy++cm7cuWacxKi37l2nfI73ZrS+SwYrG2ANgDfUO4KIuxV6JrIMarUyUXrBqVRqEz+5pwtHRpG0G5+XYsS+SI6bGZMysqbx6B3BZKxWyDWpkPZUG4ZePT+BfD51AT7Mfm7rCthicK5FtxaFWGKxoTNbMmspr5LULrFQQVa/SIBz2uVEozPZRrQp755JAqw/Olci24lArDFZ0IGtmTdpipYLMJFt/R6VBOJkpYHImj/aQF5PpPJKZApoDs1PsVh6cK7FrXySDFZ0wsyYis8jYfFlpEM4VFRQUBZGAB/GZPHJFZcHnrTo4V2LXvkhr/TSCYWZNREaTtfmy0iDsdTnhdjoxkyvC7XTC61q444ZVB+dK7NoXyX1WiIgsQuZNKSvtb9Tkd6M14MFEKofWoAdN/tNBiR03LrTr3kgMVoiILELmTSkrDcLT2QLcbiea/R64nU5MZwu2GJyXY8cN/+xRNyNbka2xkEgrsjdfVlqcsG1DOz7QfXqfFS5asF9fJIMVshQZGwuJtGKF5svlBuGrP9Bpm8G5Gsv1RVotaRP3iiWqkayNhURasUrzZaVBmIsWqmPFpI09K2QJMjcWEmnFrs2XdFopaTs8EkdL0IMNHWG0BD04PBLHvhcGMRBNmn2IdWGwQpYgc2MhkZbs2HxJs6yctHEaiCxB9sZCIi3ZrfmSZll5K34GK2QJVmgsJHnI0LzI/g77sXLSxic3WYJVGgtJfFZsXiRrsHLSxp4VAyiKiuFYGkfHEhiOpaWcLxQdGwvJCFZtXiRrqLQLMCD/br/yhVeSYRZmHL7tmvS0uHmxVL1r8nsQ9rnRH53Gs0dOYkNHmEExmaKUtI3EZ9Afne1dCXhdmMkVMRrPSJ20MVjREff9MB4bC0kvVm5eJOuwatLGYEUnzMLMw8ZC0oOVmxfJWqyYtOnas7Jnzx5cdtllCAaDaGlpKfs1DodjyZ/HHntMz8MyBPf9ILKW+c2L5cjcvEjWU0razu5uRl9bUOpABdA5WMnlcrj++uvxpS99admv27dvH0ZHR+f+7Ny5U8/DMsTpLKz8gyvgdSFbKDILI5KElZsXiUSnawpw3333AQAef/zxZb+upaUF3d3deh6K4ay8hIzIjqzcvEgkOiGWLt92223o6OjAJZdcgsceewyKolT82mw2i0QiseCPiJiFEVkPt7InMofpaf23v/1tfPSjH0UgEMBzzz2Hu+66C+Pj4/jmN79Z9uv37t07V7ERGbMwImuyYvMikegc6uK0fwW7d+9eMVg4ePAgLr744rm/P/7447j99tsxNTW14vf//ve/j/vvvx/xeLzs57PZLLLZ7NzfE4kE+vr6EI/H0dzcXN0PYaD5+6xkC7NTPxs7w1IvISMiImpUIpFAJBKpavyuubJy22234cYbb1z2a9atW1frt51z6aWXIpFI4OTJk+jq6lryeZ/PB5/PV/f3NxqzMCIiosbUHKx0dHSgo6NDj2MBALzxxhvw+/0VlzrLiPt+EBER1U/XnpWhoSHEYjEMDQ2hWCzi0KFDAICNGzciHA7jV7/6FcbGxrBt2zYEAgEcOHAA99xzD77whS9IVT0hIiIi/egarHzrW9/CE088Mff3Cy64AABw4MABXHXVVfB4PHj00Udx5513QlEUbNiwAffffz++8pWv6HlYREREJJGaG2xFU0uDDhEREYmhlvFbiH1WiIiIiCphsEJERERCY7BCREREQmOwQkREREJjsEJERERCY7BCREREQjP9RYaNKq28FvXty0RERLRUadyuZgcV6YOVZDIJAOjr6zP5SIiIiKhWyWQSkUhk2a+RflM4RVEwMjKCpqYmOBzavByw9Cbn4eFhbjRXBZ6v6vFc1Ybnq3o8V7Xh+aqeXudKVVUkk0n09vbC6Vy+K0X6yorT6cQZZ5yhy/dubm7mRVwDnq/q8VzVhuerejxXteH5qp4e52qlikoJG2yJiIhIaAxWiIiISGgMVsrw+Xy499574fP5zD4UKfB8VY/nqjY8X9XjuaoNz1f1RDhX0jfYEhERkbWxskJERERCY7BCREREQmOwQkREREJjsEJERERCY7CyyJ49e3DZZZchGAyipaWl7Nc4HI4lfx577DFjD1QA1ZyroaEhXHvttQiFQujo6MBf/dVfIZfLGXugglq3bt2S6+jrX/+62YcljEcffRTr16+H3+/HRRddhP/8z/80+5CEtHv37iXXUXd3t9mHJYQ//vGPuPbaa9Hb2wuHw4GnnnpqwedVVcXu3bvR29uLQCCAq666CkeOHDHnYAWw0vm65ZZbllxrl156qSHHxmBlkVwuh+uvvx5f+tKXlv26ffv2YXR0dO7Pzp07DTpCcax0rorFIq655hqkUik8//zz+OUvf4l/+Zd/wV133WXwkYrr/vvvX3AdffOb3zT7kITw5JNP4vbbb8c999yDN954A1dccQV27NiBoaEhsw9NSOecc86C6+jNN980+5CEkEqlcN555+GRRx4p+/nvfe97+MEPfoBHHnkEBw8eRHd3Nz7+8Y/PvXPOblY6XwDwyU9+csG19swzzxhzcCqVtW/fPjUSiZT9HAD1X//1Xw09HpFVOlfPPPOM6nQ61RMnTsx97Be/+IXq8/nUeDxu4BGKae3ateoPf/hDsw9DSB/+8IfVL37xiws+dvbZZ6tf//rXTToicd17773qeeedZ/ZhCG/xc1tRFLW7u1v9zne+M/exTCajRiIR9bHHHjPhCMVSbpzbuXOn+ulPf9qU42FlpU633XYbOjo6cMkll+Cxxx6DoihmH5JwXnrpJWzevBm9vb1zH/vEJz6BbDaL119/3cQjE8d3v/tdtLe34/zzz8eePXs4RYbZit3rr7+O7du3L/j49u3b8eKLL5p0VGLr7+9Hb28v1q9fjxtvvBHvvvuu2YckvOPHj2NsbGzBdebz+XDllVfyOlvG73//e3R2duKss87Crbfeimg0ash/V/oXGZrh29/+Nj760Y8iEAjgueeew1133YXx8XGW8BcZGxtDV1fXgo+1trbC6/VibGzMpKMSx1e/+lVceOGFaG1txauvvopdu3bh+PHj+MlPfmL2oZlqfHwcxWJxybXT1dXF66aMrVu34mc/+xnOOussnDx5Eg888AAuu+wyHDlyBO3t7WYfnrBK11K56+y9994z45CEt2PHDlx//fVYu3Ytjh8/jr/927/FRz7yEbz++uu6725ri8pKuQa0xX9ee+21qr/fN7/5TWzbtg3nn38+7rrrLtx///146KGHdPwJjKP1uXI4HEs+pqpq2Y9bQS3n74477sCVV16Jc889F5///Ofx2GOP4ac//SkmJiZM/inEsPgasfJ104gdO3bguuuuw5YtW/Cxj30MTz/9NADgiSeeMPnI5MDrrHo33HADrrnmGmzevBnXXnstfv3rX+Odd96Zu+b0ZIvKym233YYbb7xx2a9Zt25d3d//0ksvRSKRwMmTJ5dE6bLR8lx1d3fjlVdeWfCxyclJ5PN56c9TJY2cv1JX/cDAgK0z4o6ODrhcriVVlGg0atnrRkuhUAhbtmxBf3+/2YcitNKKqbGxMfT09Mx9nNdZ9Xp6erB27VpDrjVbBCsdHR3o6OjQ7fu/8cYb8Pv9FZfvykTLc7Vt2zbs2bMHo6Ojcw+DZ599Fj6fDxdddJEm/w3RNHL+3njjDQBY8OC0I6/Xi4suugj79+/HZz7zmbmP79+/H5/+9KdNPDI5ZLNZvP3227jiiivMPhShrV+/Ht3d3di/fz8uuOACALP9Un/4wx/w3e9+1+Sjk8PExASGh4cNeWbZIlipxdDQEGKxGIaGhlAsFnHo0CEAwMaNGxEOh/GrX/0KY2Nj2LZtGwKBAA4cOIB77rkHX/jCF2z39s6VztX27dvxoQ99CDfffDMeeughxGIx3H333bj11lvR3Nxs7sGb7KWXXsLLL7+Mq6++GpFIBAcPHsQdd9yBT33qU1izZo3Zh2e6O++8EzfffDMuvvhibNu2DT/+8Y8xNDSEL37xi2YfmnDuvvtuXHvttVizZg2i0SgeeOABJBIJW26nsNj09DQGBgbm/n78+HEcOnQIbW1tWLNmDW6//XY8+OCD2LRpEzZt2oQHH3wQwWAQN910k4lHbZ7lzldbWxt2796N6667Dj09PRgcHMQ3vvENdHR0LEgqdGPKGiSB7dy5UwWw5M+BAwdUVVXVX//61+r555+vhsNhNRgMqps3b1YffvhhNZ/Pm3vgJljpXKmqqr733nvqNddcowYCAbWtrU297bbb1EwmY95BC+L1119Xt27dqkYiEdXv96sf+MAH1HvvvVdNpVJmH5ow/uEf/kFdu3at6vV61QsvvFD9wx/+YPYhCemGG25Qe3p6VI/Ho/b29qqf/exn1SNHjph9WEI4cOBA2WfUzp07VVWdXb587733qt3d3arP51P/7M/+TH3zzTfNPWgTLXe+0um0un37dnXVqlWqx+NR16xZo+7cuVMdGhoy5Ngcqqqq+odERERERPWxxWogIiIikheDFSIiIhIagxUiIiISGoMVIiIiEhqDFSIiIhIagxUiIiISGoMVIiIiEhqDFSIiIhIagxUiIiISGoMVIiIiEhqDFSIiIhIagxUiIiIS2v8P5e99STFdE9UAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "def create_random_pset(\n", " fieldset=None, lon_range=(-15, 15), lat_range=(-15, 15), number_particles=200\n", "):\n", " return parcels.ParticleSet.from_list(\n", " fieldset=fieldset,\n", - " pclass=parcels.ScipyParticle,\n", + " pclass=parcels.Particle,\n", " lon=np.random.uniform(*lon_range, size=(number_particles,)),\n", " lat=np.random.uniform(*lat_range, size=(number_particles,)),\n", " time=np.zeros(shape=(number_particles,)),\n", @@ -699,7 +216,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "b936c2cf-107c-479e-bc5f-3dc1d03811b2", + "id": "11", "metadata": { "papermill": { "duration": 0.019595, @@ -716,757 +233,10 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "68cd0dcb-d491-4610-aeee-515d314f8bc7", + "execution_count": null, + "id": "12", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in .\n", - "100%|██████████| 1468800.0/1468800.0 [00:06<00:00, 240698.79it/s]\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:     (trajectory: 200, obs: 136)\n",
-       "Coordinates:\n",
-       "  * obs         (obs) int32 0 1 2 3 4 5 6 7 ... 128 129 130 131 132 133 134 135\n",
-       "  * trajectory  (trajectory) int64 200 201 202 203 204 ... 395 396 397 398 399\n",
-       "Data variables:\n",
-       "    lat         (trajectory, obs) float32 dask.array<chunksize=(200, 1), meta=np.ndarray>\n",
-       "    lon         (trajectory, obs) float32 dask.array<chunksize=(200, 1), meta=np.ndarray>\n",
-       "    time        (trajectory, obs) timedelta64[ns] dask.array<chunksize=(200, 1), meta=np.ndarray>\n",
-       "    z           (trajectory, obs) float32 dask.array<chunksize=(200, 1), meta=np.ndarray>\n",
-       "Attributes:\n",
-       "    Conventions:            CF-1.6/CF-1.7\n",
-       "    feature_type:           trajectory\n",
-       "    ncei_template_version:  NCEI_NetCDF_Trajectory_Template_v2.0\n",
-       "    parcels_kernels:        ScipyParticleAdvectionRK4\n",
-       "    parcels_mesh:           spherical\n",
-       "    parcels_version:        v2.4.2-370-gd0cb4110
" - ], - "text/plain": [ - "\n", - "Dimensions: (trajectory: 200, obs: 136)\n", - "Coordinates:\n", - " * obs (obs) int32 0 1 2 3 4 5 6 7 ... 128 129 130 131 132 133 134 135\n", - " * trajectory (trajectory) int64 200 201 202 203 204 ... 395 396 397 398 399\n", - "Data variables:\n", - " lat (trajectory, obs) float32 dask.array\n", - " lon (trajectory, obs) float32 dask.array\n", - " time (trajectory, obs) timedelta64[ns] dask.array\n", - " z (trajectory, obs) float32 dask.array\n", - "Attributes:\n", - " Conventions: CF-1.6/CF-1.7\n", - " feature_type: trajectory\n", - " ncei_template_version: NCEI_NetCDF_Trajectory_Template_v2.0\n", - " parcels_kernels: ScipyParticleAdvectionRK4\n", - " parcels_mesh: spherical\n", - " parcels_version: v2.4.2-370-gd0cb4110" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# create fresh particle set\n", "pset = create_random_pset(fieldset)\n", @@ -1494,7 +264,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "e6cb5684-d49e-49c7-b93a-d0fc03400f37", + "id": "13", "metadata": {}, "source": [ "## Saving to an other Zarr store\n" @@ -1503,7 +273,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "d72b7213-e79b-4478-910b-708bff3b3b85", + "id": "14", "metadata": {}, "source": [ "### Directory, without changing chunking\n" @@ -1511,749 +281,10 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "113f55b5-832b-4439-8191-1c5492beb8a0", + "execution_count": null, + "id": "15", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:     (trajectory: 200, obs: 136)\n",
-       "Coordinates:\n",
-       "  * obs         (obs) int32 0 1 2 3 4 5 6 7 ... 128 129 130 131 132 133 134 135\n",
-       "  * trajectory  (trajectory) int64 200 201 202 203 204 ... 395 396 397 398 399\n",
-       "Data variables:\n",
-       "    lat         (trajectory, obs) float32 dask.array<chunksize=(200, 1), meta=np.ndarray>\n",
-       "    lon         (trajectory, obs) float32 dask.array<chunksize=(200, 1), meta=np.ndarray>\n",
-       "    time        (trajectory, obs) timedelta64[ns] dask.array<chunksize=(200, 1), meta=np.ndarray>\n",
-       "    z           (trajectory, obs) float32 dask.array<chunksize=(200, 1), meta=np.ndarray>\n",
-       "Attributes:\n",
-       "    Conventions:            CF-1.6/CF-1.7\n",
-       "    feature_type:           trajectory\n",
-       "    ncei_template_version:  NCEI_NetCDF_Trajectory_Template_v2.0\n",
-       "    parcels_kernels:        ScipyParticleAdvectionRK4\n",
-       "    parcels_mesh:           spherical\n",
-       "    parcels_version:        v2.4.2-370-gd0cb4110
" - ], - "text/plain": [ - "\n", - "Dimensions: (trajectory: 200, obs: 136)\n", - "Coordinates:\n", - " * obs (obs) int32 0 1 2 3 4 5 6 7 ... 128 129 130 131 132 133 134 135\n", - " * trajectory (trajectory) int64 200 201 202 203 204 ... 395 396 397 398 399\n", - "Data variables:\n", - " lat (trajectory, obs) float32 dask.array\n", - " lon (trajectory, obs) float32 dask.array\n", - " time (trajectory, obs) timedelta64[ns] dask.array\n", - " z (trajectory, obs) float32 dask.array\n", - "Attributes:\n", - " Conventions: CF-1.6/CF-1.7\n", - " feature_type: trajectory\n", - " ncei_template_version: NCEI_NetCDF_Trajectory_Template_v2.0\n", - " parcels_kernels: ScipyParticleAdvectionRK4\n", - " parcels_mesh: spherical\n", - " parcels_version: v2.4.2-370-gd0cb4110" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# create store\n", "output_dirstore_name = \"zarr_advanced_01.zarr/\"\n", @@ -2273,7 +304,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "1c5d4da6-3493-41d6-9be9-e07a0ab42e56", + "id": "16", "metadata": {}, "source": [ "### Zipfile, without changing chunking\n" @@ -2281,749 +312,10 @@ }, { "cell_type": "code", - "execution_count": 9, - "id": "8a710743-1c85-42cd-b8cb-8cc80d9c9a6c", + "execution_count": null, + "id": "17", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:     (trajectory: 200, obs: 136)\n",
-       "Coordinates:\n",
-       "  * obs         (obs) int32 0 1 2 3 4 5 6 7 ... 128 129 130 131 132 133 134 135\n",
-       "  * trajectory  (trajectory) int64 200 201 202 203 204 ... 395 396 397 398 399\n",
-       "Data variables:\n",
-       "    lat         (trajectory, obs) float32 dask.array<chunksize=(200, 1), meta=np.ndarray>\n",
-       "    lon         (trajectory, obs) float32 dask.array<chunksize=(200, 1), meta=np.ndarray>\n",
-       "    time        (trajectory, obs) timedelta64[ns] dask.array<chunksize=(200, 1), meta=np.ndarray>\n",
-       "    z           (trajectory, obs) float32 dask.array<chunksize=(200, 1), meta=np.ndarray>\n",
-       "Attributes:\n",
-       "    Conventions:            CF-1.6/CF-1.7\n",
-       "    feature_type:           trajectory\n",
-       "    ncei_template_version:  NCEI_NetCDF_Trajectory_Template_v2.0\n",
-       "    parcels_kernels:        ScipyParticleAdvectionRK4\n",
-       "    parcels_mesh:           spherical\n",
-       "    parcels_version:        v2.4.2-370-gd0cb4110
" - ], - "text/plain": [ - "\n", - "Dimensions: (trajectory: 200, obs: 136)\n", - "Coordinates:\n", - " * obs (obs) int32 0 1 2 3 4 5 6 7 ... 128 129 130 131 132 133 134 135\n", - " * trajectory (trajectory) int64 200 201 202 203 204 ... 395 396 397 398 399\n", - "Data variables:\n", - " lat (trajectory, obs) float32 dask.array\n", - " lon (trajectory, obs) float32 dask.array\n", - " time (trajectory, obs) timedelta64[ns] dask.array\n", - " z (trajectory, obs) float32 dask.array\n", - "Attributes:\n", - " Conventions: CF-1.6/CF-1.7\n", - " feature_type: trajectory\n", - " ncei_template_version: NCEI_NetCDF_Trajectory_Template_v2.0\n", - " parcels_kernels: ScipyParticleAdvectionRK4\n", - " parcels_mesh: spherical\n", - " parcels_version: v2.4.2-370-gd0cb4110" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# create store\n", "output_zipstore_name = \"zarr_advanced_01.zip\"\n", @@ -3043,7 +335,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "6efe0f7b-2a0b-4d2d-862b-1d79e536efe9", + "id": "18", "metadata": {}, "source": [ "### Rechunking and saving to new stores\n" @@ -3052,7 +344,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "e46d4b23-4561-4610-9d66-bd142cfd588a", + "id": "19", "metadata": {}, "source": [ "Consider the current chunking (let's load the memory store again):\n" @@ -3060,105 +352,10 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "11823207-3fa5-455d-ba66-d5e298fa4a83", + "execution_count": null, + "id": "20", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Array Chunk
Bytes 106.25 kiB 800 B
Shape (200, 136) (200, 1)
Dask graph 136 chunks in 2 graph layers
Data type float32 numpy.ndarray
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 136\n", - " 200\n", - "\n", - "
" - ], - "text/plain": [ - "dask.array" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Frozen({'trajectory': (200,), 'obs': (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)})" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds_out_orig = xr.open_zarr(output_memorystore)\n", "display(ds_out_orig.lat.data)\n", @@ -3168,7 +365,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "581c6db4-a2c1-44d6-bb46-ecd4bf91b704", + "id": "21", "metadata": {}, "source": [ "So we have one chunk per `obs` slice which covers all trajectories. This is the optimal way of _creating_ the recorded dataset at simulation time, but may not be ideal for, e.g., time filtering.\n", @@ -3178,108 +375,10 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "fc27e257-8d92-4263-90c7-58b338803444", + "execution_count": null, + "id": "22", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Array Chunk
Bytes 106.25 kiB 1.56 kiB
Shape (200, 136) (10, 40)
Dask graph 80 chunks in 4 graph layers
Data type float32 numpy.ndarray
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 136\n", - " 200\n", - "\n", - "
" - ], - "text/plain": [ - "dask.array" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Frozen({'trajectory': (10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10), 'obs': (40, 40, 40, 16)})" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds_out_rechunked = ds_out_orig.chunk({\"trajectory\": 10, \"obs\": 40})\n", "display(ds_out_rechunked.lat.data)\n", @@ -3289,7 +388,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "8a5d7e77-c222-415e-a009-c6c59a290b97", + "id": "23", "metadata": {}, "source": [ "And of course, we could now save the rechunked data into a zip store or a directory store:\n" @@ -3297,8 +396,8 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "b936111c-8e23-485f-ba09-cf6c09c82339", + "execution_count": null, + "id": "24", "metadata": {}, "outputs": [], "source": [ @@ -3310,8 +409,8 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "6c1cc7e6-8c31-4759-9f1d-2ac5b4118f8b", + "execution_count": null, + "id": "25", "metadata": {}, "outputs": [], "source": [ diff --git a/docs/examples/documentation_geospatial.ipynb b/docs/examples/documentation_geospatial.ipynb index fcf3491ff..254de8f54 100644 --- a/docs/examples/documentation_geospatial.ipynb +++ b/docs/examples/documentation_geospatial.ipynb @@ -111,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -136,18 +136,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in tutorial_geospatial_output/agulhas_trajectories.zarr.\n", - "100%|██████████| 10368000.0/10368000.0 [00:15<00:00, 651613.20it/s]\n" - ] - } - ], + "outputs": [], "source": [ "# An example parcels simulation\n", "data_folder = parcels.download_example_dataset(\"GlobCurrent_example_data\")\n", @@ -167,7 +158,7 @@ "# Mesh of particles\n", "lons, lats = np.meshgrid(range(15, 35, 2), range(-40, -30, 2))\n", "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=lons, lat=lats\n", + " fieldset=fieldset, pclass=parcels.Particle, lon=lons, lat=lats\n", ")\n", "dt = timedelta(hours=24)\n", "output_file = pset.ParticleFile(\n", @@ -200,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -221,153 +212,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
trajectoryobstimezgeometry
0002002-01-010.0POINT (15.00000 -40.00000)
1012002-01-020.0POINT (15.23998 -39.85211)
2022002-01-030.0POINT (15.55334 -39.81898)
3032002-01-040.0POINT (15.93826 -39.85509)
4042002-01-050.0POINT (16.46919 -39.67649)
..................
59324932002-01-040.0POINT (33.59146 -32.07283)
59334942002-01-050.0POINT (33.81222 -32.14541)
59344952002-01-060.0POINT (34.14362 -32.15410)
59354962002-01-070.0POINT (34.57761 -32.23006)
59364972002-01-070.0POINT (34.57761 -32.23006)
\n", - "

2562 rows × 5 columns

\n", - "
" - ], - "text/plain": [ - " trajectory obs time z geometry\n", - "0 0 0 2002-01-01 0.0 POINT (15.00000 -40.00000)\n", - "1 0 1 2002-01-02 0.0 POINT (15.23998 -39.85211)\n", - "2 0 2 2002-01-03 0.0 POINT (15.55334 -39.81898)\n", - "3 0 3 2002-01-04 0.0 POINT (15.93826 -39.85509)\n", - "4 0 4 2002-01-05 0.0 POINT (16.46919 -39.67649)\n", - "... ... ... ... ... ...\n", - "5932 49 3 2002-01-04 0.0 POINT (33.59146 -32.07283)\n", - "5933 49 4 2002-01-05 0.0 POINT (33.81222 -32.14541)\n", - "5934 49 5 2002-01-06 0.0 POINT (34.14362 -32.15410)\n", - "5935 49 6 2002-01-07 0.0 POINT (34.57761 -32.23006)\n", - "5936 49 7 2002-01-07 0.0 POINT (34.57761 -32.23006)\n", - "\n", - "[2562 rows x 5 columns]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "def parcels_to_geopandas(ds, suppress_warnings=False):\n", " \"\"\"\n", @@ -423,7 +270,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -453,7 +300,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -510,7 +357,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -601,7 +448,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -639,7 +486,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -691,7 +538,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -758,121 +605,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
geometryFIDCOUNTRYISOCOUNTRYAFFAFF_ISOShape__AreaShape__Length
0POLYGON ((61.27655 35.60725, 61.29638 35.62854...1AfghanistanAFAfghanistanAF9.346494e+116.110457e+06
1POLYGON ((19.57083 41.68527, 19.58195 41.69569...2AlbaniaALAlbaniaAL5.058670e+101.271948e+06
2POLYGON ((4.60335 36.88791, 4.63555 36.88638, ...3AlgeriaDZAlgeriaDZ3.014489e+128.316049e+06
3POLYGON ((-170.74390 -14.37555, -170.74942 -14...4American SamoaASUnited StatesUS1.754581e+086.729120e+04
4POLYGON ((1.44584 42.60194, 1.48653 42.65042, ...5AndorraADAndorraAD9.349956e+081.171375e+05
\n", - "
" - ], - "text/plain": [ - " geometry FID COUNTRY ISO \\\n", - "0 POLYGON ((61.27655 35.60725, 61.29638 35.62854... 1 Afghanistan AF \n", - "1 POLYGON ((19.57083 41.68527, 19.58195 41.69569... 2 Albania AL \n", - "2 POLYGON ((4.60335 36.88791, 4.63555 36.88638, ... 3 Algeria DZ \n", - "3 POLYGON ((-170.74390 -14.37555, -170.74942 -14... 4 American Samoa AS \n", - "4 POLYGON ((1.44584 42.60194, 1.48653 42.65042, ... 5 Andorra AD \n", - "\n", - " COUNTRYAFF AFF_ISO Shape__Area Shape__Length \n", - "0 Afghanistan AF 9.346494e+11 6.110457e+06 \n", - "1 Albania AL 5.058670e+10 1.271948e+06 \n", - "2 Algeria DZ 3.014489e+12 8.316049e+06 \n", - "3 United States US 1.754581e+08 6.729120e+04 \n", - "4 Andorra AD 9.349956e+08 1.171375e+05 " - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Step 1: Obtain our geospatial datasets we want to compare against\n", "esri_dataset_url = \"https://services.arcgis.com/P3ePLMYs2RVChkJx/arcgis/rest/services/World_Countries_(Generalized)/FeatureServer/0/query?outFields=*&where=1%3D1&f=geojson\"\n", @@ -893,115 +628,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
trajectoryobstimezgeometryindex_rightCOUNTRY
54454502002-01-010.0POINT (25.00000 -32.00000)209.0South Africa
55664602002-01-010.0POINT (27.00000 -32.00000)209.0South Africa
56874702002-01-010.0POINT (29.00000 -32.00000)209.0South Africa
58084802002-01-010.0POINT (31.00000 -32.00000)NaNNaN
59294902002-01-010.0POINT (33.00000 -32.00000)NaNNaN
\n", - "
" - ], - "text/plain": [ - " trajectory obs time z geometry \\\n", - "5445 45 0 2002-01-01 0.0 POINT (25.00000 -32.00000) \n", - "5566 46 0 2002-01-01 0.0 POINT (27.00000 -32.00000) \n", - "5687 47 0 2002-01-01 0.0 POINT (29.00000 -32.00000) \n", - "5808 48 0 2002-01-01 0.0 POINT (31.00000 -32.00000) \n", - "5929 49 0 2002-01-01 0.0 POINT (33.00000 -32.00000) \n", - "\n", - " index_right COUNTRY \n", - "5445 209.0 South Africa \n", - "5566 209.0 South Africa \n", - "5687 209.0 South Africa \n", - "5808 NaN NaN \n", - "5929 NaN NaN " - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Step 2: Filter observations to get first observation only for each particle\n", "gdf_parcels_initial = gdf_parcels.drop_duplicates(subset=\"trajectory\", keep=\"first\")\n", @@ -1015,22 +644,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Particles with the following trajectory IDs are start in water:\n", - "[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n", - " 24 25 26 27 28 29 30 31 35 36 37 38 39 40 41 48 49]\n", - "\n", - "Particles with the following trajectory IDs are start on land:\n", - "[32 33 34 42 43 44 45 46 47]\n" - ] - } - ], + "outputs": [], "source": [ "# Step 4: Filter observations to get only the particles in the water\n", "water_particles_mask = gdf_parcels_initial[\"COUNTRY\"].isna()\n", @@ -1056,7 +672,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ diff --git a/docs/examples/documentation_homepage_animation.ipynb b/docs/examples/documentation_homepage_animation.ipynb index c5e753dc7..7a1fd9834 100644 --- a/docs/examples/documentation_homepage_animation.ipynb +++ b/docs/examples/documentation_homepage_animation.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "tags": [ "raises-exception" @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "tags": [ "raises-exception" @@ -82,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { "tags": [ "raises-exception" @@ -100,8 +100,8 @@ " central_latitude=90, central_longitude=-30, satellite_height=15000000\n", " ),\n", ")\n", - "ax1.set_facecolor(\"#1EB7D0\")\n", "ax1.add_feature(cartopy.feature.LAND, zorder=1)\n", + "ax1.add_feature(cartopy.feature.OCEAN, zorder=1)\n", "ax1.coastlines()\n", "scat1 = ax1.scatter(\n", " lon[b],\n", @@ -121,8 +121,8 @@ " central_latitude=-90, central_longitude=-30, satellite_height=15000000\n", " ),\n", ")\n", - "ax2.set_facecolor(\"#1EB7D0\")\n", "ax2.add_feature(cartopy.feature.LAND, zorder=1)\n", + "ax2.add_feature(cartopy.feature.OCEAN, zorder=1)\n", "ax2.coastlines()\n", "scat2 = ax2.scatter(\n", " lon[b],\n", @@ -152,7 +152,7 @@ "fig.canvas.draw()\n", "plt.tight_layout()\n", "# writergif = PillowWriter(fps=6)\n", - "# anim.save('homepageshort.gif',writer=writergif)" + "# anim.save('homepageshort.gif', writer=writergif, savefig_kwargs={\"transparent\": True})" ] }, { diff --git a/docs/examples/documentation_indexing.ipynb b/docs/examples/documentation_indexing.ipynb index 2836d729f..af60f5b20 100644 --- a/docs/examples/documentation_indexing.ipynb +++ b/docs/examples/documentation_indexing.ipynb @@ -50,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -73,27 +73,13 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "tags": [ "raises-exception" ] }, - "outputs": [ - { - "ename": "ValueError", - "evalue": "On a C-grid, the dimensions of velocities should be the corners (f-points) of the cells, so the same for U and V. See also ../examples/documentation_indexing.ipynb", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/erik/Codes/ParcelsCode/docs/examples/documentation_indexing.ipynb Cell 5\u001b[0m line \u001b[0;36m2\n\u001b[1;32m 7\u001b[0m variables \u001b[39m=\u001b[39m {\u001b[39m\"\u001b[39m\u001b[39mU\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39m\"\u001b[39m\u001b[39muo\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mV\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39m\"\u001b[39m\u001b[39mvo\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mW\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39m\"\u001b[39m\u001b[39mwo\u001b[39m\u001b[39m\"\u001b[39m}\n\u001b[1;32m 8\u001b[0m dimensions \u001b[39m=\u001b[39m {\n\u001b[1;32m 9\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mU\u001b[39m\u001b[39m\"\u001b[39m: {\n\u001b[1;32m 10\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mlon\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39m\"\u001b[39m\u001b[39mnav_lon\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 26\u001b[0m },\n\u001b[1;32m 27\u001b[0m }\n\u001b[0;32m---> 29\u001b[0m fieldset \u001b[39m=\u001b[39m FieldSet\u001b[39m.\u001b[39;49mfrom_nemo(filenames, variables, dimensions)\n", - "File \u001b[0;32m~/Codes/ParcelsCode/parcels/fieldset.py:545\u001b[0m, in \u001b[0;36mFieldSet.from_nemo\u001b[0;34m(cls, filenames, variables, dimensions, indices, mesh, allow_time_extrapolation, time_periodic, tracer_interp_method, chunksize, **kwargs)\u001b[0m\n\u001b[1;32m 543\u001b[0m \u001b[39mif\u001b[39;00m kwargs\u001b[39m.\u001b[39mpop(\u001b[39m'\u001b[39m\u001b[39mgridindexingtype\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mnemo\u001b[39m\u001b[39m'\u001b[39m) \u001b[39m!=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mnemo\u001b[39m\u001b[39m'\u001b[39m:\n\u001b[1;32m 544\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mgridindexingtype must be \u001b[39m\u001b[39m'\u001b[39m\u001b[39mnemo\u001b[39m\u001b[39m'\u001b[39m\u001b[39m in FieldSet.from_nemo(). Use FieldSet.from_c_grid_dataset otherwise\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m--> 545\u001b[0m fieldset \u001b[39m=\u001b[39m \u001b[39mcls\u001b[39;49m\u001b[39m.\u001b[39;49mfrom_c_grid_dataset(filenames, variables, dimensions, mesh\u001b[39m=\u001b[39;49mmesh, indices\u001b[39m=\u001b[39;49mindices, time_periodic\u001b[39m=\u001b[39;49mtime_periodic,\n\u001b[1;32m 546\u001b[0m allow_time_extrapolation\u001b[39m=\u001b[39;49mallow_time_extrapolation, tracer_interp_method\u001b[39m=\u001b[39;49mtracer_interp_method,\n\u001b[1;32m 547\u001b[0m chunksize\u001b[39m=\u001b[39;49mchunksize, gridindexingtype\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39mnemo\u001b[39;49m\u001b[39m'\u001b[39;49m, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 548\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mhasattr\u001b[39m(fieldset, \u001b[39m'\u001b[39m\u001b[39mW\u001b[39m\u001b[39m'\u001b[39m):\n\u001b[1;32m 549\u001b[0m fieldset\u001b[39m.\u001b[39mW\u001b[39m.\u001b[39mset_scaling_factor(\u001b[39m-\u001b[39m\u001b[39m1.\u001b[39m)\n", - "File \u001b[0;32m~/Codes/ParcelsCode/parcels/fieldset.py:656\u001b[0m, in \u001b[0;36mFieldSet.from_c_grid_dataset\u001b[0;34m(cls, filenames, variables, dimensions, indices, mesh, allow_time_extrapolation, time_periodic, tracer_interp_method, gridindexingtype, chunksize, **kwargs)\u001b[0m\n\u001b[1;32m 584\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Initialises FieldSet object from NetCDF files of Curvilinear NEMO fields.\u001b[39;00m\n\u001b[1;32m 585\u001b[0m \n\u001b[1;32m 586\u001b[0m \u001b[39mSee `here <../examples/documentation_indexing.ipynb>`__\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 653\u001b[0m \u001b[39m Keyword arguments passed to the :func:`Fieldset.from_netcdf` constructor.\u001b[39;00m\n\u001b[1;32m 654\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 655\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39mU\u001b[39m\u001b[39m'\u001b[39m \u001b[39min\u001b[39;00m dimensions \u001b[39mand\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39mV\u001b[39m\u001b[39m'\u001b[39m \u001b[39min\u001b[39;00m dimensions \u001b[39mand\u001b[39;00m dimensions[\u001b[39m'\u001b[39m\u001b[39mU\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m!=\u001b[39m dimensions[\u001b[39m'\u001b[39m\u001b[39mV\u001b[39m\u001b[39m'\u001b[39m]:\n\u001b[0;32m--> 656\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mOn a C-grid, the dimensions of velocities should be the corners (f-points) of the cells, so the same for U and V. \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 657\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mSee also ../examples/documentation_indexing.ipynb\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 658\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39mU\u001b[39m\u001b[39m'\u001b[39m \u001b[39min\u001b[39;00m dimensions \u001b[39mand\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39mW\u001b[39m\u001b[39m'\u001b[39m \u001b[39min\u001b[39;00m dimensions \u001b[39mand\u001b[39;00m dimensions[\u001b[39m'\u001b[39m\u001b[39mU\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m!=\u001b[39m dimensions[\u001b[39m'\u001b[39m\u001b[39mW\u001b[39m\u001b[39m'\u001b[39m]:\n\u001b[1;32m 659\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mOn a C-grid, the dimensions of velocities should be the corners (f-points) of the cells, so the same for U, V and W. \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 660\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mSee also ../examples/documentation_indexing.ipynb\u001b[39m\u001b[39m\"\u001b[39m)\n", - "\u001b[0;31mValueError\u001b[0m: On a C-grid, the dimensions of velocities should be the corners (f-points) of the cells, so the same for U and V. See also ../examples/documentation_indexing.ipynb" - ] - } - ], + "outputs": [], "source": [ "example_dataset_folder = parcels.download_example_dataset(\n", " \"NemoNorthSeaORCA025-N006_data\"\n", @@ -138,7 +124,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -155,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -203,20 +189,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "from mpl_toolkits.mplot3d import Axes3D # noqa\n", @@ -264,7 +239,7 @@ "\n", "Interpolation for Arakawa B-grids is detailed in [Section 2.1.3 of Delandmeter and Van Sebille (2019)](https://www.geosci-model-dev.net/12/3571/2019/gmd-12-3571-2019.html). Again, the dimensions that need to be provided are those of the barycentric cell edges `(i, j, k)`.\n", "\n", - "To load B-grid data, you can use the method `FieldSet.from_b_grid_dataset`, or specifically in the case of POP-model data `FieldSet.from_pop`.\n" + "To load B-grid data, you can use the method `FieldSet.from_b_grid_dataset`.\n" ] }, { diff --git a/docs/examples/documentation_stuck_particles.ipynb b/docs/examples/documentation_stuck_particles.ipynb index ef6b298a6..97444937d 100644 --- a/docs/examples/documentation_stuck_particles.ipynb +++ b/docs/examples/documentation_stuck_particles.ipynb @@ -52,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "hide_input": true, "slideshow": { @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "hide_input": true }, @@ -189,22 +189,11 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { "hide_input": true }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 15), constrained_layout=True)\n", "fig.suptitle(\"Figure 1\", fontsize=16)\n", @@ -354,22 +343,11 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "hide_input": true }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(8, 6))\n", "fig.suptitle(\"Figure 2\", fontsize=16)\n", @@ -450,20 +428,11 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "hide_input": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in SMOC.zarr.\n", - "100%|██████████| 428400.0/428400.0 [00:41<00:00, 10383.94it/s]\n" - ] - } - ], + "outputs": [], "source": [ "SMOCfile = \"SMOC_201907*.nc\"\n", "filenames = {\"U\": SMOCfile, \"V\": SMOCfile}\n", @@ -482,7 +451,7 @@ "time = np.zeros(lons.size)\n", "\n", "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=lons, lat=lats, time=time\n", + " fieldset=fieldset, pclass=parcels.Particle, lon=lons, lat=lats, time=time\n", ")\n", "\n", "kernels = pset.Kernel(parcels.AdvectionRK4)\n", @@ -507,7 +476,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": { "hide_input": true }, @@ -518,7 +487,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": { "hide_input": true }, @@ -535,22 +504,11 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { "hide_input": true }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABlAAAAKgCAYAAADkqTDeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gU1f7H8fdsyaY3EgiEEiB0kKI0RQVEBAEBFQRRsGFvV7leO9jv73qvvSsqYkGQYkFFUUB6UeldmoQSQksvuzu/P5Ks2SSbbEJiKJ/X8+zD7pQzZ84O2XPmO+ccwzRNExEREREREREREREREfGw1HQGRERERERERERERERETjYKoIiIiIiIiIiIiIiIiBSjAIqIiIiIiIiIiIiIiEgxCqCIiIiIiIiIiIiIiIgUowCKiIiIiIiIiIiIiIhIMQqgiIiIiIiIiIiIiIiIFKMAioiIiIiIiIiIiIiISDEKoIiIiIiIiIiIiIiIiBSjAIqIiIiIiIiIiIiIiEgxCqCIiIiICAA9e/bEMAzmz59f01kROeUZhoFhGBXeT/8PRUREREROHgqgiIiIiJzGEhISPDdyfb1eeumlms7mSWHWrFnccsstnH322dStW5eAgAAiIyM599xzefnll8nNza3yY2ZmZvL888/TvXt3IiMjCQgIoG7dunTs2JGxY8fyySefkJWV5bXPhAkTPN9dnTp1cDqdPtM/fPgwAQEBnu0//PBDn9smJyfz+OOPc8455xAdHU1gYCANGjRg2LBhfPnll36f0+LFi7n55ptp2bIlEREROBwO4uPjGThwIO+99x4ZGRl+p1Xcr7/+6jmXUaNGVTodERERERERf9hqOgMiIiIiUv2aNWtG7dq1S10XHx8PQMOGDWnRogXBwcF/Z9ZOGv/9739ZvHgxDoeDevXq0b59e/bv38/SpUtZunQpkydPZu7cuURGRlbJ8ZKSkujduzdbt24FIC4ujsTERHJycti0aROrV6/mvffeY926dbRt27bUNJKTk/nhhx+49NJLS10/ZcoU8vLyys3L1KlTuemmm0hLS8NqtdK8eXOCg4PZsWMHX3zxBV988QUXX3wx06ZNIyIiotQ0MjMzuf7665k6dSoAgYGBNG3alKCgIJKSkpg9ezazZ8/m8ccfZ86cObRr186fYvIyefJkz/tZs2aRlpZGWFhYhdP5O7Ro0aKmsyAiIiIiIidIPVBEREREzgAPP/wwixYtKvU1bNgwAD766CM2b95Mly5daji3NeOmm25i3rx5pKWlsWPHDlauXMnevXtZunQp9evX59dff+WRRx6psuPdcMMNbN26lWbNmrFkyRL279/PqlWrWLduHampqXz77bdcfvnl2GylP/NUeIO+aFChuMmTJ2MYBs2aNfO5zRdffMHIkSNJS0vjjjvuYP/+/WzcuJFVq1aRnJzM559/Tu3atfnxxx+5+OKLS+2Jk5eXR9++fZk6dSpxcXFMmjSJI0eOsH79elauXMm+ffvYsGEDt9xyC4cOHeKPP/6oYGmB0+nks88+AyAyMpLMzExmzJhR4XT+Lps3b2bz5s01nQ0RERERETkBCqCIiIiIiADXXXcdPXv2xG63ey3v1q0bL7zwApDf66Eq7N+/nx9++AGADz74gO7du3utDwgIoH///kyfPp2WLVuWmsZ5551HQkICX375JWlpaSXWb9++neXLl3PhhRfSsGHDUtM4cOAAY8eOxe1289hjj/Haa68RGxvrWW+z2Rg+fDg///wzoaGhrFy5kgkTJpRI54knnmDx4sXUqVOHpUuXMnr0aIKCgry2ad26NW+99Rbz5s3z2RuqLD/88APJyck0aNCAhx56CCg7eCQiIiIiInKiFEAREREREaDsyatzc3N59tlnadGiBYGBgcTHx3Prrbdy6NAhz5wcxW+sX3fddWXOu+Frv6LLDx06xJ133klCQgJ2u53rrrvOa9s5c+Zw2WWXUadOHRwOB/Xr1+f666+vVA+HshQGMTIzM6skvZ07d3red+jQoVJpFM4DkpWVxfTp00usLwwuXHPNNT7TeO211zh27BitWrXi8ccf97ldmzZtePjhhwF49dVXOX78uGfd8ePHeeWVVwB46aWXSEhIKDPfPXr04Nxzzy1zm9IUns+IESO4+uqrsVgszJs3j71791Y4rUKmafLWW2/Rvn17goKCqFOnDldffTU7duzgww8/xDCMEtdc0eUZGRk8/PDDNG/enMDAQHr27OnZrqxJ5FNSUrj99tuJj48nMDCQFi1a8NRTT/k13JqIiIiIiPx9FEARERERkTI5nU4uu+wyHnnkEbZu3UpCQgK1a9dm4sSJdOnShSNHjlTLcQ8dOsQ555zDW2+9RUREBK1bt8ZqtXrW33vvvfTr14+vv/4ayL/Jn5aWxocffkinTp1YsmRJleVl6dKlAHTq1KlK0gsPD/e8X7FiRaXTufbaawH4+OOPS6z75JNPCAwM5Morr/S5f+F8JTfffLPPocIKjR07FpvNRnp6Ot9++61n+ezZs0lLSyM2NrbMY52I1NRUz0T2V199NfXr1+eCCy7A7Xbz6aefVjrdm266idtuu421a9dSt25dGjRowMyZMznnnHPKDcJlZWVxwQUX8O9//xubzUbr1q1xOBzlHvPAgQN07dqVN998k+TkZFq1aoVpmjz++ONcfvnlmKZZ6fMREREREZGqpQCKiIiIiJTppZdeYs6cOURHR7N48WI2b97M77//zo4dO4iKiuKtt96qluO+/fbbxMfHs2vXLtasWcOaNWt4/fXXPetefvllGjduzLx58zh48CC//fYbR44c4emnnyY1NZWrrrqK7OzsSh/f5XKxd+9e3njjDcaNG0dISAjPPfdclZxb69atPcNqXX311bz++uuV6knRokULOnfuzLx580hKSvIsX7JkCX/88QeXXXaZz0nfU1JS2LZtGwAXXnhhuceKiYmhVatWwF8BpcJjQf6QYuUFYSrriy++ICsri9atW3t67IwaNQqo/DBeX3zxBe+//z4Oh4NZs2axY8cOVq1aRVJSEp07d+b//u//ytx/+vTppKens2HDBjZu3Mhvv/3mCfKU5fbbb2fHjh106tSJHTt28Pvvv7N161Z++uknFixY4FW2IiIiIiJSsxRAERERETkDXH/99Z4hhYq+ig45VBq3281LL70EwCuvvOI19FKDBg2YOnUqbre7WvJss9n44osvqF+/vmdZYGAgubm5TJgwAavVyvTp073OwWq18sgjj3DFFVewd+9epk2bVuHjvvTSSxiGgc1mo0GDBtxxxx1cdNFFLFu2jC5dulTFqWGxWJg4cSLBwcEcOHCAO++8kwYNGhAfH8/QoUN57bXXSElJ8Suta665BrfbzSeffOJZ5s/wXUUDLk2bNvXrWIXbFQ32FKbTuHFjv9KojMLzufrqqz3LrrzySgICAli/fj2rV6+ucJr/+9//AHjssccYPHiwZ3l0dDRTpkwhJCSkzP1dLhefffaZJ6gE+ddnWbZv3+6ZR+ejjz6iQYMGnnW9e/fmiSee0DBeIiIiIiInEQVQRERERM4AzZo147zzzivxateuXZn7bdy4kaSkJEJCQhg2bFiJ9YmJiZx//vnVkuc+ffpQr169EsuXLl3KgQMH6NSpEx07dix138suuwyABQsWVPi48fHxnHfeeXTp0oU6deoAMG/ePD777DNcLleF0/OlT58+rFmzhptuuonIyEgA9u3bx6xZs7jrrrtISEjg1VdfLTedkSNHYrPZPMN45ebmMnXqVGJiYujXr5/P/YpOPF9esKD4dkX3LXzvbxoV9eeff3q+x5EjR3qWR0ZGcumllwIV74WSlpbG8uXLgfzgYnFRUVEMGTKkzDTatGlT4SHdfvjhB0zT5IILLqBNmzYl1t90000EBARUKE0REREREak+1dPHXkREREROKg8//HCJybD9UTjEU8uWLX3e2D3rrLNKnXj+RBV9sr+odevWAbBr1y569OhR6jbHjh0DvHtZ+GvYsGFewaLly5dzyy238Oyzz3LkyBHefPPNCqfpS2JiIu+++y5vv/02a9euZeXKlfzwww98++23ZGRkcPfddxMREcHo0aN9phEbG0vfvn359ttvWbNmDTt37uTIkSPccccd2O12n/uFhYV53mdkZHjNy+JLRkZGiX0L3xeuq2off/wxpmnSrVs3mjRp4rVu1KhRzJo1i08//ZT//Oc/XnPklGX79u2YpkmtWrVKDdJB/nVdFl/XZ1m2bt1a5r5hYWHEx8ezc+fOCqctIiIiIiJVTwEUEREREfGptBvmxZW17kT46tFw/PhxIH+S+UOHDpWZRlZW1gnno2vXrnz77bc0adKEd955hwcffJBGjRqdcLpFWSwWOnToQIcOHRg7dix79uxh4MCBrFu3jqeeeqrMAArkTyb/7bff8vHHH3tuvhdOMO9LfHy85/0ff/zhszdPUYUTqxfdt/B9dd30L234rkIDBw4kPDycAwcOMHfuXC655BIA3n//fd5///0S2z/yyCP079+/Sq7ryvS4SU9PB/KDXr7UqVNHARQRERERkZOEhvASEREREZ8KbxIX3vgtTdHhnIoyDAMA0zRLXV/ZHguhoaFAfu8D0zTLfFVVz5h69erRoUMH3G43a9asqZI0y9KwYUP+/e9/A/m9JY4ePVrm9oMHDyY8PJzJkyfzzTff0KxZM7p27VrmPjExMTRr1gzwb6izlJQUNm3aBED37t09ywvnxVmyZAlOp7PcdCpi1apVnmPefffdJebwCQoKIjU1FfAexmvPnj0sXry4xOvgwYPAiV3XJ6Lw2i0r8JecnFzlxxURERERkcpRAEVEREREfGrevDkAmzdv9jm5deGQWsUV3qT2dbN4+/btlcpT69atAVi/fn2l9q+swuBAVQcJfCk6XFVubm6Z2wYFBXH55Zdz8OBBcnJyypw8vqjCocrefffdcs/rvffew+l0Ehoa6pl7BODSSy8lNDSU5ORkvvjiC7+O66/CoEhwcDB16tQp9VXYm2PmzJmegMiECRNKDagVDmOXmJiIxWIhJSWF/fv3l3psX9f1iSj6/6k06enp7N27t8qPKyIiIiIilaMAioiIiIj41KpVK+Lj40lPTy/15viOHTtYuHBhqfsWBgBWrlxZYt3evXuZM2dOpfJ0/vnnExMTw5o1a6pl7pXS7Nq1y9PzpH379iecXkZGBpmZmWVus2TJEiB/svSyhnwqdPPNN3PRRRdx0UUXlTt8V6E777yTiIgINm7cyJNPPulzuw0bNvDMM88AcMcdd3gmvS/M31133QXAvffey65du8o85uLFiz3nVhan08mUKVMAeP311zlw4IDPV/369cnMzGTGjBnlpgv5w3MV9tD58MMPS6w/fvw4s2bN8iutiujbty8Av/zyCxs3biyx/r333is3WCYiIiIiIn8fBVBERERExCeLxcK9994L5A+htGzZMs+6vXv3Mnz4cM9QXcX1798fgFmzZvHtt996lu/fv59Ro0ZVuidHYGCg52b/sGHDmDlzZolhwtavX8+//vUvFi9e7Feav/76K+PHj2fHjh0l1n3//ff0798fp9PJpZdeStOmTb3Wv/TSSyQkJDBixAi/z2Hbtm00adKEp556yjOvSCGn08nkyZO57777ABg9ejQWS/nV9u7duzN37lzmzp1L48aN/cpH3bp1eeeddzAMg6eeeoo777zTq8eQ0+lk2rRp9O7dm/T0dDp16sQTTzxRIp0JEybQvXt3Dh48SPfu3Zk8eTLZ2dle22zdupU77riDnj17+jVM1Zw5c0hOTiYoKIgrrrjC53YWi4WRI0cC3sN4laewfJ966im+/vprz/KjR48yYsSIMof3qqzExEQGDx6MaZqMGTPGq7fJ/PnzmTBhAna7vcqPKyIiIiIilaMAioiIiIiU6d5776Vv376kpKTQvXt3WrVqRadOnWjcuDGHDx/m1ltvBcBqtXrt16pVK2688UacTicDBgygSZMmdOzYkYYNG5KcnMztt99e6TzddtttPPjgg6SkpHD55ZcTExNDly5dOPvss6lVqxbt2rXjP//5j9/zWKSlpfHkk0/StGlT6tatS+fOnWnfvj1RUVH079+fzZs307lzZyZNmlRi32PHjrF7924OHDjgd/4Nw+DgwYM8/vjjJCYmUqdOHc455xzatWtHdHQ0o0eP5vjx4/Ts2dPT86O6DB8+nE8++YTQ0FBef/116tatS5s2bTjnnHOoXbs2w4cPJzk5mYsuuoiffvoJh8NRIo2AgAB++OEHrrjiCg4cOMDo0aOJjo6mXbt2dOnShfr169OiRQveeOMN4uLiSExMLDdfhcGQIUOGlDuhe+GQZT///DNJSUl+nfeVV17JDTfcQFZWFpdddhlNmzalc+fOxMfHs3z5ch544AGg5HV9ot544w0SEhJYtWoVTZo0oVOnTrRo0YJevXrRo0cPr/llRERERESkZimAIiIiIiJlstlsfP311zz99NM0a9aMHTt2cODAAcaMGcPy5cs9N9RLu8n91ltveQITSUlJHDp0iFtuuYWlS5d6DQNVGc899xyLFy/m6quvJiQkhDVr1rBr1y7q16/PDTfcwOzZs7nooov8Sqt9+/a8/PLLXHbZZYSEhLB582Y2b95MUFAQ/fv354MPPmDJkiXExMScUJ6LHm/16tU899xz9OnTh/DwcDZv3szWrVsJDw9n0KBBfPLJJ/z000+eicer08iRI9m+fTuPPPIIZ511Fvv27WPdunUEBwdz+eWXM2PGDObOnVvmdxYaGsoXX3zBL7/8wo033kiDBg08Q5+ZpsmAAQOYOHEiW7dupW3btmXmJzU1la+++grAr/lczjrrLNq1a4fb7ebTTz/1+7zfffdd3njjDdq1a0dSUhK7d+9m0KBBrFixgrp16wKlX9cnol69eqxYsYJbb72VmJgYNm7ciGmaPPnkk8ycOdNnjy4REREREfn7GWbx8Q5ERERERCpg0KBBfPPNN8ycOZMhQ4bUdHZEqsRdd93Fa6+9xosvvugZxk5ERERERM4sCqCIiIiISKXt3buXxMREnE4ne/fuJS4urqazJHLC0tPTadasGQcOHGDFihV07ty5prMkIiIiIiI1QEN4iYiIiEi5nn76abZt2+a1bMuWLQwePJicnBwGDx6s4Imccl566SVWr17ttSwpKckzl0unTp0UPBEREREROYOpB4qIiIiIlCshIYHdu3cTExNDQkICx48f9wRUmjRpwi+//EJ8fHwN51KkYnr27MmCBQuIiIigSZMm5OTksHnzZtxuNzExMcybN6/c+VpEREREROT0pQCKiIiIiJRr4sSJTJs2jfXr13P48GEsFguNGzdmyJAh3H///URFRdV0FkUqbObMmXz00Uf89ttvHDp0CNM0adCgAf379+eBBx5QUFBERERE5AynAIqIiIiIiIiIiIiIiEgxmgNFRERERERERERERESkGAVQREREREREREREREREilEARUREREREREREREREpBgFUERERERERERERERERIpRAEVERERERERERERERKQYBVBERERERERERERERESKUQBFRERERERERERERESkGAVQREREREREREREREREilEARUREREREREREREREpBgFUERERERERERERERERIpRAEVERERERERERERERKQYBVBERERERERERERERESKUQBFRERERERERERERESkGAVQREREREREREREREREilEARUREREREREREREREpBgFUERERERERERERERERIpRAEVERERERERERERERKQYBVBERERERERERERERESKUQBFRERERERERERERESkGAVQREREREREREREREREilEARUREREREREREREREpBgFUERERERERERERERERIpRAEVERERERERERERERKQYBVBETjG//fYbhmFgGAZXXnllTWfnlHDdddd5yqxnz57VcoyePXt6jnHdddf5vV9CQoJnvwkTJniWz58/37PcMAx27drlWfd3nM/JasKECZ5zT0hIqOnsnHJq4trRdyYiIqeaF154wfPb9dprr9V0dqSKlFUPKlrv/vDDD/1Kb9euXV77zZ8/v8rzfCorqz1Tlg8//NBrP39V5juUU0tl29wiIidKARSRk0DLli29KnyNGjXCNM1St+3UqRMDBgwAYPr06SxcuLBCxyracCj6slqt1KpViwsuuIBXX32V3NzcEz4vkVOBKuKVp+CIiIicrIrfvC182Ww2IiIiaN++PXfeeSdbt24tse+tt95KbGwskP9bd+zYsQodu+gDMmfawy415Ux6wCg7O5uoqCiv6/r888+v6WyddiobADqdVWeZqE0mIiczW01nQORMt3TpUrZs2eK1bM+ePfz8889cdNFFpe5z3333MXv2bAAefvjhCgdRSuN2uzly5AgLFy5k4cKFfPTRR8ydO5eIiIgTTlt8e+SRRzh+/DgA5557rl/7jBgxgrZt2wLQoEGDasvbyahv376EhoYC6No8Reg7ExGRk4nL5SI1NZW1a9eydu1aPvjgA+bPn0/nzp092wQHB3Prrbfy1FNPcfjwYf73v//x1FNP1WCupSqcLnXomTNnlgjqLVq0iO3bt5OYmFgzmSpF06ZNef755z2fo6Ojq/V4RY9V9P+znD5uu+02Bg4cCOD5vywi8ndQAEWkhvnqXvzhhx/6DKD07NmT+Ph4kpKSWLRoEWvXruWss86q1PELK5rHjh1jypQp/PHHHwCsWrWKCRMm8OKLL1Yq3fKkpaURFhZWLWmfSsaOHVvhffr160e/fv2qITc1y59r4txzz/U70HQyM02TjIwMT2DhdHa6fGciInJqu+qqqzjnnHNwOp2sWLGCmTNnApCZmckzzzzDrFmzvLYfNWqUJ2jy7rvv8thjjxEQEPB3Z1uq0OlSh/bVfpw0adJJEegrrNM3aNCAcePG/W3H/TuPVZ2qs518qrdBrrrqqprOgoicoTSEl0gNys7OZurUqZ7PzZs397yfMWMGaWlppe5nsVgYOnSo5/PEiRMrnYdx48Yxbtw4nn76aZYvX054eLhn3fTp0z3vn332WQYPHkyzZs2Ijo7GbrcTFRVF165defbZZ8nIyCiRdvFxaD///HO6dOlCSEgI7dq189p22bJljB49mqZNmxIUFERYWBitWrVi7Nix7N2712vbY8eO8fTTT9O5c2ciIiJwOBwkJCQwduxYtm/fXqHzX7duHddccw0JCQk4HA6CgoJo2LAhvXv35qGHHiIpKalC6RX6448/GD58OLVq1SIkJITzzz+fn3/+ucR2vuZAKUtFxm/+/vvvueCCCwgJCSEyMpLLL7+c3bt3l5ru77//zvXXX0+TJk0IDAwkLCyMzp0788ILL5CdnV1i+7fffpthw4bRsmVLYmJisNvthIeH07FjRx588EFSUlLKPd+ffvqJCy+8kPDwcK9rz5eyhowqnvaKFSvo378/4eHhhIaGcvHFF7N27doSaS1YsMCzbNKkST67pWdnZ/PKK69w/vnnEx0dTUBAAPHx8Vx99dX8/vvv5eY1OTmZsWPHUrduXWw2G1988UWp+V6+fDl9+/YlPDycsLAw+vfvX2r6AElJSYwbN462bdsSGhpKYGAgTZs25cYbb2TdunXllmdRFfk+C7vvP/HEE55lu3fvLnXs6fKG+Tpy5AgTJkygU6dOhIeH43A4aNCgASNGjGDx4sXlluuxY8f4xz/+QYMGDXA4HLRo0YI333yzQucuIiKnv379+jFu3DgefPBBZsyY4VUX3bx5c4ntW7Ro4XnC+eDBg57e3yeqovWVovbs2cO4ceNo37494eHhBAYGkpCQwJVXXsmiRYu8tnU6nbz33nv07t2bWrVqYbfbiY2NpW/fvnzyySclhgsuPjTPli1bGD9+PI0aNSI4OJguXbrw/fffA5CSksJNN91EbGwsQUFB9OjRo9Qe8cXrBd9++y09evQgJCSEqKgohg8fzo4dO0rsV5F2R+F8GZMmTfIsW7BgQalzk1RkmK+5c+dywQUXEBoaWmZeyzNr1iwGDRpE3bp1CQgIIDo6mosvvpgZM2ZUOC3Ir/vNnTvX87lo+/Gjjz7yOQx0WdatW8egQYM89fFLLrmEX3/9tUL17tLq9OUN97R7925GjhxJdHQ0ISEhXHDBBV7nVlG+5kApPqdKdnY2TzzxBImJiZ525JNPPonb7fZKq1evXl7pN27c2OcQUxVtR/nTTi4t3+PHj6dp06Y4HA6aNm3K008/TV5enlfa/rZBoGLtan/LJDs7m0ceeYR+/frRpEkTIiIisNvtxMTEcMEFF/Daa6/hdDpL5NefNll5w3xt2bKFW2+9lWbNmhEUFERISAgtW7bk7rvvLnW4seLpbdmyhWHDhhEdHU1QUBDdu3fX3EYiks8UkRrz6aefmoDntXTpUtNqtXo+v/feez73/eSTTzzbtWnTxu9jjhkzxuuYxZ1zzjmedXa73bM8JCTEa7/ir3bt2plpaWleaRVdf95553l9btSokWe7xx57zDQMw2fa8+bN82y7efNms2HDhj63DQkJMefMmePznC+88ELP8g0bNpjBwcFlntd3333nV7leeOGFnn26d+9uRkdHl0jLarWa06dP99qvUaNGnvXjx4/3LJ83b57Xvjt37iz3fIqX+bnnnlvqOTVt2tTMysry2u/VV1/1uvaKvzp37mweO3bMa582bdqUWXbx8fFmUlKSz/Pt1q1biWOWZ/z48aVeQ8XT7tKli2mz2UrkKTo62jxw4ECJtHy9Csv94MGDZrt27XxuZ7PZzEmTJvnMa0xMjNm8eXOvfT744IMS+e7Ro4dpt9tLpB8cHGwuWbLEK/0FCxaYkZGRPvNkt9vNDz/80Gufsq6dinyfxa/P0l6F51fWd7Zhwwazfv36PtMwDMN85plnfJZrrVq1zJYtW5a67zvvvFPe5SQiIqex4r9Vhb9LTqfTXLp0qRkeHu7zN7HQ2LFjPdvccccdfh+76G978bQrWl8p9NVXX5mhoaE+fzOL1iPT09PNCy64oMzf6YEDB5q5ubk+y+vss88usY/FYjGnTJliNm3atMQ6h8Nhbty40SvPRdf36tWr1HzExsaa27Zt89qvIu2ODz74oNw6SWFbwt86dP/+/UttmxTP686dO0s9jmmapsvlMq+++uoy83XzzTf7czl5efbZZ73qhwsWLPBKc+7cuRVKb+XKlaVeV4GBgWafPn181uH8qdOX1Z7ZuXOnGRcXV2rdr3///iXS8kdp/99Ns+Q1UrxdWvh6+OGHS02rtNeYMWM821amHVVWfgrLuni+e/fuXWr6Q4cO9Urb3zZIRdvV/pbJoUOHyt22T58+ptPpLJFfX6/Ca6dom7vod2Capvn555+bgYGBPtMICwsrcZ+gaHpnnXVWqf8XAgICzPXr1/tzCYrIaUxDeInUoKJPxnTp0oVu3brRq1cvz5M3H374ITfeeGOp+3bs2NHzfsOGDRw7dozIyMgTys/hw4e9JtKMi4vzvG/YsCFt27alYcOGREVFYZomO3fu5PPPPycjI4N169bxxhtv8MADD5Sa9uLFi6lTpw5XXXUV0dHR7Ny5E4DPP//cq6t5SEgII0eOpH79+vzxxx989dVXnnUul4uhQ4eyZ88eAOrUqcOoUaOIiIjgm2++YeXKlWRkZDB8+HC2bdvmmfzTl0mTJpGZmQlA/fr1ueaaawgJCWHv3r2sX7+eZcuWVbAE8y1dupR69erxr3/9i7S0NCZOnEhOTg4ul4ubbrqJPn36+NXb4kQtWbKEtm3bMnjwYBYuXMgvv/wC5PeOmTlzJiNHjgTyv5u7777b88Rajx496NOnD8eOHWPSpEkcPXqUlStXctttt/Hpp5960q9Tpw6JiYk0adKE6OhoDMMgKSmJqVOncvjwYZKSknj66ad54403Ss3fsmXLCAsLY9SoUdSrV49Vq1ZV2bmvWLGCRo0aMXLkSDZs2MDXX38N5Pd2eP/993nooYc8c3O8+eabnicKzznnHK+u4YVjNV9zzTWeHh0RERGMGjWKuLg4FixYwE8//YTT6eSmm27i7LPPpk2bNiXyk5KSQkpKCv369aN79+4cPHiQWrVqldhu0aJFNG/enGHDhrF3714mT56M2+0mMzOTMWPGsHnzZiwWC8eOHWPo0KGe8a9DQkK44YYbCAoKYvLkyezfv5+8vDxuuukmOnXqVKLHV2kq8n0Wjmn9ww8/8OOPPwIQFRXFww8/7EmvvLGnnU4nQ4cO9fQws9lsjBkzhjp16jBt2jS2bduGaZo88sgjdOzYkf79+5dI4/Dhwxw7dowbbriBWrVq8frrr3v+T//3v/+t1BB5IiJyerr++uu5/vrrSyy3WCz885//LHWfovXt0npFnih/6isAu3bt4qqrriIrKwvIfxJ8yJAhtG/fngMHDvDDDz94pXvXXXd56n0A/fv3p3Pnzvzyyy+ep6m/+eYbHnvsMf7973+Xmrdff/2V4cOH07RpU1599VXS09Nxu92MGDECq9XKzTffjMPh4I033sDlcpGTk8PLL7/MW2+9VWp68+bN4+yzz+bSSy9lw4YNnh4Yhw4d4tZbb/XqeVCRdkfnzp15/vnn+fzzzz11ySZNmnDbbbd50mvatKnf3wnAd99953deffn3v//tqTdbLBaGDRtG27Zt2bZtG5988gkul4t33nmHs88+m5tvvtnvvBXtaTNw4EAuuOACEhMTPb0FyhoGujTXX3896enpns8jR46kSZMmTJ061e/eIJWp0995550cOHDA83nQoEF07NiR7777ju+++87v/FfG4sWLGTZsGImJiUycOJHk5GQAXn31VcaPH09AQADPP/88f/zxh9f1/PDDDxMVFQX8Nf9GZdtRxfNTWju5uHnz5nHttdfSsGFDpk+f7uk5N3PmTD7++GOuueaaEvv4aoNUpl3tb5kYhkFiYiJdu3alXr16REVFkZeXx+bNm5k2bRpOp5O5c+cyffp0hg8fXqE2mS/btm1j9OjR5OTkABAbG8uYMWNwOp28//77pKamkpaWxrBhw9i6dSt16tQpkcbatWuJiYnh1ltv5eDBg0yePBmA3NxcXnnlFd5+++0y8yAip7kaDd+InMH27t1rWiwWz5MNL774ommapvnuu+96PfFQ/ImsQikpKV7bbdiwwa/jFu+B8vzzz5vPP/+8+cgjj5R4muyee+7x2vfYsWPmt99+a7711lvm//73P/P555/3erqtd+/eXtsXTSsyMrJEbwTTNM2OHTt6tgkNDS1xvseOHTNTUlJM0zTNL7/80utJkF27dnm2y8nJ8XqCpuhT676eNrv77rs9y5977rkSeTty5Ih55MgRv8q16NMrdrvd6wmror2FAHPixImeddXZA6VRo0Zmenq6aZqmmZuba9auXduz7r777vPsM3ToUM/ySy65xHS73Z5133//vWedYRjmn3/+6XW8jIwMc+7cueY777xjvvDCC+bzzz9vDh482LNPkyZNvLYver42m81cu3atX+VbyN8eKKGhoeb+/fs964peZ5dffrnXfmU9yWSaprlmzRqvci3aE8Ttdpvdu3f3rBs7dmypeQXMBx54oNRzKprvmJgYryfUnnnmGa80fvrpJ9M0TfPFF1/0Wl70aao//vjDqxfLTTfd5FlX1rVjmhX/Psv6PsrbZubMmV7n8Pbbb3vWHT161KsXV58+fXyW62uvveZZ99JLL3mtS01NLTVPIiJy+vOntyRgPvvssz7T+OKLLzzbxcbG+n1sf3ug+Ftf+cc//uGV5ylTpnil6XQ6zd27d5ummd9GKPo0/MiRIz3bud1u86KLLvKsCwkJMbOzs0str6L1hwcffNBrXdF687BhwzzLO3Xq5JWvovu0adPGzMnJ8awr2rsHMLdv3+61b0XbHeXVccrbpjJ59dUDxeVymbVq1fJ5jRUtz2bNmpWa19IsWbLE63gzZ840TdM0H3nkEc+y4OBgv+s/xdP717/+5Vl35MgRMyoqyq96t686va/2zL59+7x6+FxzzTWefXJzc0v0ivZX0X3K6oEybtw4z7pZs2Z5rSt6HmW1xwpVth1VNF1f7eTi+S7avj1+/LgZExPjWXf++ed71vnTBqlsu9qfMil08OBB88svvzTfeOMN87///a/5/PPPm23btvXse8MNN3htX16brKxt7rnnHs9yi8Xi1Rvul19+8crz008/XWp6FovFXLNmjWfdkCFDfP5tE5Ezj3qgiNSQjz76yDPOqsViYfjw4QBcccUV3H777Z6xTH1NBli8B0Phk+gVVdYTd4Vzcrjdbh588EFefvllcnNzfaZVfK6SosaMGUO9evW8lmVmZrJ69WrP59GjR5OYmOi1TUREhOd90Sf/cnNzS51PodCSJUt8rit0/vnn88orrwDw6KOP8vXXX9OiRQtatGhB165dOf/887FareWmU1q6RfN21VVXcd1113m+01WrVnHDDTdUON2KKuxRA2C322ncuLHnCaujR496titarnPmzMFiKX16LNM0WbZsGVdeeSUAL7zwAuPHj/d6aq24suaQGTBggF89Iypj8ODBXj2omjdv7plHpOi5+6P4E6dlTYhe1nX34IMPlnusyy67zOuav+aaa3jkkUc8n1etWkXv3r29jlO7dm369u3r+dykSRN69OjBvHnzys1TUSf6fVZU8XwVfWouMjKSwYMH88EHH5S6bSGr1erVS69FixZe648ePVptk3CKiMippXASeZfLxfr165kyZQpOp5OHH36YvLw8Hn/88RL7FK1vV7auXRZ/6ytF6yKtW7cuMZGy1WqlYcOGACxfvhyXy+VZd+2113reG4bB6NGj+emnnwDIyMhg7dq1pfYaHTVqlOd98Tp3YS/mwjwXKquOddVVVxEQEOD5fM011/Duu+96Pv/66680bdq0StodJ8rfvPqyZcsWDh8+7Pn88MMPe/XSLWrbtm2kpKQQExNTbr6Kjl4QERHh6Z07YsQInnnmGSC/fTV16lSfoxgU9euvv3p9Hj16tOd9VFQUgwcP9jlhfVEVrdP/+uuvXnO1FL3W7HY7w4cPZ/z48X6nV1G33HKL531pdceKqGw7qqjS2smlKfp/OTw8nEGDBnnqymX1+imtDVLV7eqisrKyuP32273ud5SmKv8PF83jOeecQ6tWrTyfzz//fBo3buzp2ePrfLp3785ZZ53l+Vz02qjodSEipx9NIi9SQ4p2vz7//PM9laaoqCivm6G+JgNMTU31+nyiw3dZLBaioqLo0aMHL774IkuXLvWk+corr/D888+X2YgBPF1mS1O0cVXo6NGjXudWVsUN8ocz8NehQ4fK3ebKK69k3LhxOBwOXC4XS5Ys4YMPPuDBBx+kV69eNG3alA0bNvh9zEK1a9f2+my1Wr2Ga/q7KmCNGjXy+uxwODzvi1ZmK1Ous2bN4v777y/zZjtU/JqoKv6euz+q4rqLjY31dG8vS/Frp3j38sJrp+g1VHyf4vv5c71VxfdZUUXzFRoaSnBwsNf6oueQmZlZ6t+fOnXqEBgY6Plc9HuGin/XIiJy+iqcRP5f//oXkydP9npA4amnnir1IYGi9e0TrWuXpjJ1tfLqy8V/9/2tWxQXHx9far6Kr7PZ/noms6zfXX/zURXtjhNV2TIrVJG6I/jXbsnOzmbq1Kmez0OGDPF8L23btvUaQtafoAeUDAoWDeaV9tmXitbpix+3vPKuakX/351o3bEq2gn+ll9Z5ZSVlVXq/wlfbZCqblcX9dBDD/Hhhx+WW5bV1a6obNuoKtuPInL6UQ8UkRqwdOlStmzZ4vm8YMECDMModds9e/bw888/lxjLtrAnQSF/nlopTWnBmeI+//xzz/u2bdvy6aef0rJlS+x2Ow888ADPP/98uWkUvzkK+cEiwzA8edi1a1eZaRSt/IWGhpb5ZJK/Ff7nn3+eRx99lCVLlrB582a2bt3KV199xb59+9i9ezd33HGHZ6xofxX/blwul9dTaNXRAC+N3W73+uzrGouKivJUjHv16sWll17qM83u3bsD3tdEvXr1mD59Oh07dvSMhX3HHXeUm7/Sromq4u+5+6N4o+PZZ58tkX4hX+fk77kWv3YOHjzo9bnw2imap+L7FN/Pn8BNVXyfFVU0X+np6WRmZnqVU9FzCA4O9noStFBVfs8iInJm6dKli+e90+lk5cqVXoEB8P6NLb6uKvj7O1Z0/P+K1Jeh/LqFr3qCr7oOeAdN/OVvHacq2h0nyt+8+lK8TG+66aYSPR2KKu2Gb3EzZ870CjxMmjTJ64G8ohYtWsT27dtL9Owvrvh5JCcne11rRecoKUtF6/SlHbeo4uVd1Ype2ydad6xMO6q4irQTGjRo4PlctJwCAwNLBIPKSrs62tWFiv4f7tWrF++88w6NGzfGarUyfPhwpk2bVqH0/FEVbSO1K0SkLAqgiNQAf58KKrp98QDKb7/95nnfpk2bar0pX/Tmf69evTxdtLOysrwmea+o4OBgOnTo4BmqYPLkydx///00adLEs016ejq5ublER0d7DZ2Unp5Op06d6N27t1eapmny888/e6Xhy86dO4mKiiIyMpL+/ft7usH37duXyy+/HCjZtd0fCxcuZNeuXZ4nBD///HPP8F2Q3634ZHLuuefy5ZdfAvkNpdtuu80z9Feh1NRUvvvuOzp06AB4XxNnn3023bp1A/KfzqmOSnF1KlpZLpyAvKjiQ3bFxcWVOgntihUrSm24VMRXX31FamqqZ8iQjz/+2Gt94bVz7rnneso5OTmZH374wdNzbceOHSxatMhn/ktT2e+zvLIrS/F8ffzxx55JVI8dO+a5JkvbVkRE5EStXLnS63PRYa8KFa1vn3feedWeJ1/OO+88VqxYAcDGjRuZNm0aw4YN86x3u90kJSXRoEEDunTpgtVq9ZzP5MmTPXVc0zQ9EyMDhISEeA1ZU50+//xzHnzwQU/dwVcdp7LtjhOpk1Q2r760bNmSWrVqec4lJyeHcePGldhuz549bNq0yaunui8VbT/6Gga6qOJDt02ZMsUzhPPRo0e96mJVqVOnTl4P0X3yySf069cPgLy8PK+eNjWp+A11X+2EirajKmvy5MmeoeBSU1P5+uuvPesq2r6sbLvanzIp+n944MCBnkBecnKyZ4jh0pxou6Lwb/qqVavYtGmTZxivhQsXeobvKtxWRKSiFEAR+ZsV737dpEmTUscdXrNmDZs3bwZgxowZvPHGG15j+S9dutTzvnhwpaq1aNGCbdu2AfDuu+9iGAbh4eFMmzbNqydNZTzwwAOecZTT0tJo3749I0eOpEGDBuzevZsvv/ySadOm0bNnTwYOHEiLFi08xxwwYABXXHEFLVu2xOl0snXrVubPn8/+/fuZN28ejRs3LvPYn3/+OePHj6dnz540a9aMunXrkpGRwWeffebZpjKBqby8PM477zyuvfZa0tLSmDhxold6RRu8J4P777+fr776CtM02bRpE23btuXyyy8nJiaGI0eOsHr1ahYuXEhcXJxnzO0WLVrw448/AjB79mzGjh1LfHw8s2fPLnMM3pNR0SdKZ8+ezYMPPkhMTAwxMTFcd911dOjQgYsuusgzXvjYsWP5+uuvPY2gnTt3smDBAnbu3MkHH3xA+/btK52XlJQUOnfuzLBhw9i7d6/XTY7ExER69eoF5I+V/NRTT3m6319++eXccMMNBAUFMXnyZE/Azmazcdddd5V73Mp+n0XL7tChQ1x//fW0bt0awzC44447CAoK8rnvwIEDadasmedvyx133MGKFSuIi4tj6tSpXkML/OMf/yj3HERERMry/fffk5KSgsvlYuPGjXz66aeedVarla5du5bY5++sb5flrrvu4s033yQ7OxvIn6NjypQpnHXWWRw+fJi5c+cyfPhwJkyYQExMDNdee63nhvtnn33GsWPH6NKlCwsWLPDqWX377bef8MMf/tqwYQPdu3dnwIABrF+/nhkzZnjWFQ6dC5VvdxStk/z666/cc889NGjQgICAAO6+++5qyasvFouFe++9l8ceewzIv/G9bds2evfuTUhICPv27WPZsmX89ttvjB49mksuuaTM9JKSkpg7d67nc7t27WjdunWJ7ZYsWcKff/4J5A8D/eSTT5b5FH3Xrl0566yzWLt2LQBPPvkkO3bsoGHDhkydOrXahh2uV68e/fv359tvvwXyA1Spqal06NCB7777rlJDKFeH4r3Obr/9dvr164fNZuOyyy6jefPmlWpHVdajjz7K5s2badSoEV988QUpKSmedWPHjq1QWpVtV/tTJi1atGD9+vUAPP300xw8eBDDMJg8ebJXnosrr01Wlttvv50333yT3Nxc3G43F154IWPGjMHpdPL+++97tgsLC+Omm26qUFmJiABQI1PXi5zBPv30UxPwvKZMmVLqdrNnz/ba7r333vOsc7lcZr169TzrVq9e7ffxx4wZ45WuPxYuXGjabDav/QAzNDTUvPzyyz2fGzVq5LVf0W0/+OADn+k/9thjpmEYJdIvfM2bN8+z7aZNm8yGDRv63La0fYqe84UXXuhZ/txzz5Wbzssvv+xXGV144YWefTp16mSGhYWVSMtisZjTpk3z2q9Ro0ae9ePHj/csnzdvnte+O3fuLPd8yivzonkcM2aM17pXXnnFtFqtZZZF0e9327ZtpZ6jzWYzR40a5fMa83W+/ho/frzP662stMsqsy+//LLU823Tpo1nmwMHDpjt2rUr93opWuZl5dVXvi+66CLT4XCUSDcoKMhctGiR134///yzGRER4TMvNpvNnDhxol/lUNnvc//+/WZwcHCpxz906FC55bBu3Tqvv2WlvZ544gmvfcpKr6z/NyIicmYp/ptQkd8a08yvcxaur1OnjpmTk+P3sYv+thevd1S2vvLVV1+ZoaGhPs+haFqpqanmeeedV+Y59+/f3+ucyvoN/eCDD3zWBcr6XS5+vNLq+7Vq1TK3bNni2aey7Y7ff//dtFgsJfYLCQnxq3yL7lO0zlxWXnfu3Om1vmj7w+l0miNHjiz32iteJy/Ns88+67XPsmXLSt3u9ddf99pu7ty55aa9cuXKUq8rh8Nh9u7d2/O5cePGXvv5U6cv65rasWOHWbt27VLLpHj5+6voPkXr5GVdv2V9h6Zpmp06dSo1j0XbdBVtR5WV16KK53vAgAGlpn3ZZZeZbrfbs5+/bZDKtKv9KZPPPvus1PV169Y1L774Yp//B/1pk5XVnv3ss89KbUcV/Vvw7bffeu1TVnr+lqOInBk0ibzI36zoWLXR0dEMGTKk1O0uueQSr3lNinbbnjdvHvv27QOgR48eJ/TEuz969OjBnDlzOPfcc3E4HERERHDppZeyZMkST7f6E/Hkk0+yePFirrnmGhISEnA4HAQHB5OYmMj111/vNX5vy5YtWbt2Lc8++yxdu3YlIiICu91OfHw8Xbt25f7772fhwoVccMEF5R53yJAhPP744/Tp04eEhASCg4Ox2WzUrVuXAQMG8NVXX1X4iTXIfypsxYoVDB06lKioKIKCgjjvvPOYM2cOV155ZYXT+zvcddddrFq1ihtvvJHExEQCAwMJCQmhWbNm9OvXj5dffplffvnFs31iYiK//PILffv2JTg4mNDQUC688EJ++ukn+vTpU4NnUnGXXXYZr732Gq1atfI53nedOnVYsWIFr776KhdeeCHR0dHYbDbi4uI4++yzue2225gzZw6jRo06obz06NGDxYsX069fP8LCwggNDaVv374sXLiwxNAhvXr1Yt26ddx77720atWKoKAgHA4HCQkJXHfddaxatYobbrjBr+NW9vuMi4vj66+/5rzzzisxXIE/2rZty9q1a3nsscfo0KEDISEhnv/Pw4YN45dffuHxxx+vcLoiIiJlcTgcNGrUiCuvvJLvv/++1N+aTz75xPN+7Nixpc7F9XcaNGgQ69ev57777qNt27aEhIQQEBBAfHw8gwcP9uohExYWxvz583n77be58MILiYqKwmazUatWLS666CImTZrEN99887ee0/Dhw/nhhx84//zzCQ4OJiIigiuuuIJly5Z5TaJd2XZHhw4d+Oyzz+jUqROBgYEnlNfrrruO2bNnc+6555aZ17JYrVY+/fRTvvzySwYPHky9evWw2+1ERUXRtm1brrrqKj755BNefvnlctMq2n5s3bp1qb2lAEaOHOl17v4M+3XOOeewZMkSBgwYQGhoKKGhoVx00UX88ssvNGvWzLNdVQ8X3bhxY5YtW8bw4cOJjIwkKCiI7t278/XXX5fb2+DvNH36dIYOHUp0dLTP3jwVbUdV1owZM3jyySdp2rQpAQEBJCQk8MQTTzBt2rRKzddR2XZ1eWUyYsQIpk6dSvv27bHb7dSqVYurrrqKZcuWlTlvqz9tsrKMGDGC33//nbFjx9K0aVMCAwMJDAykefPm3HHHHaxdu9YznKGISEUZpunHDNIiclIZMGCAp8vzL7/8wvnnn1/DORKRykpISGD37t0AjB8/3jP2tIiIiNSMzMxMEhISOHToELVq1WL79u3VOt/g6arozdUPPvjgpLoxLvlyc3Ox2WxYLN7P1qanp9O2bVtPHXXs2LG88847NZHFM9aHH37oNe+ibt2JiNQczYEicor57bffPMGTK664QsETEREREZEq9NZbb3Ho0CEAJkyYoOCJnLY2btzIZZddxqhRo2jdujVRUVHs2rWLN9980xM8sVgs3HHHHTWcUxERkZqjAIrIKaZTp056+kREREREpJrcd9993HfffTWdDZG/xZ9//sm///3vUtcFBATw5ptvVvuQ0SIiIiezGp0DZcKECRiG4fWKi4vzWt+yZUtCQkKIioqiT58+LF++vNx0X3rpJVq0aEFQUBANGjTgH//4B9nZ2V7bvPHGGzRu3JjAwEDOPvtsFi5cWOXnJyIiIiJyplEdX0Tk1FD4t7Rjx47UqlULm81GaGgo7dq146677mLNmjV+z6knIiJyuqrxHiht2rRh7ty5ns9Wq9Xzvnnz5rz22ms0adKErKwsXnzxRfr27cv27duJjY0tNb1PPvmEBx98kPfff59zzz2XrVu3esZaffHFFwH4/PPPuffee3njjTc477zzePvtt+nfvz8bN26kYcOG1XeyIiIixezataumsyAiUuVUxxcR9Zo/+dWqVYsXXnihprMhpbjuuus0b5CIyEmiRieRnzBhArNmzWL16tV+bZ+amkpERARz587loosuKnWbO++8k02bNvHTTz95lt1///2sWLHC8wRa165d6dSpE2+++aZnm1atWjFkyBCee+65yp+QiIiIiMgZTnV8ERERERE5XdToEF4A27Zto169ejRu3JgRI0awY8eOUrfLzc3lnXfeISIioszxN3v06MGvv/7KihUrANixYwfffvstAwYM8KTz66+/0rdvX6/9+vbty5IlS6rorEREREREzlyq44uIiIiIyOmgRofw6tq1Kx999BHNmzfn4MGDPP3005x77rls2LCBWrVqAfDNN98wYsQIMjMzqVu3Lj/++CMxMTE+0xwxYgSHDh2iR48emKaJ0+nktttu48EHHwQgJSUFl8tFnTp1vParU6cOBw4c8JluTk4OOTk5ns9ut5sjR45Qq1YtDMM4kWIQERERkZOIaZqkpaVRr149LJYaf97olKM6voiIiIicbE6mOr7T6SQ3N7dG83AmCwgIwGbzPyxSowGU/v37e963a9eO7t2707RpUyZNmsR9990HQK9evVi9ejUpKSm8++67DB8+nOXLl1O7du1S05w/fz7PPPMMb7zxBl27dmX79u3cc8891K1bl8cee8yzXfEGkWmaZTaSnnvuOZ544okTOV0REREROYX8+eef1K9fv6azccpRHV9ERERETlY1Wcc3TZM9e/aQkpJSI8eXv8TExNCwYUO/Hpqq0TlQSnPxxReTmJjoNXZxUc2aNeOGG27goYceKnX9+eefT7du3Xj++ec9yz7++GNuvvlm0tPTcTqdBAcHM23aNIYOHerZ5p577mH16tUsWLCg1HSLP512/PhxGjZsyChCCKDyT6e99G665/29Y0MrnY6UTuVbvVS+1UvlW71UvtVL5Vu9VL7V68lX0mlwNxw7doyIiIiazs5p4Uyr459qPuCvvynXo78pVU3lW71UvtVL5Vu9VL7VS+VbvU618s3F5BMyarSOv3v3blJSUoiPjyc0NLTGe8KcidxuN+np6SQlJRETE0OjRo3K3adGe6AUl5OTw6ZNmzj//PN9bmOaplcjp7jMzMwSF5/VasU0TUzTJCAggLPPPpsff/zRq3H1448/MnjwYJ/pOhwOHA5HieUBGCfUuAoP9k5LqpbKt3qpfKuXyrd6qXyrl8q3eql8q1d4UP6/GsKpapyJdfxT2Zl63n8XlW/1UvlWL5Vv9VL5Vi+Vb/U6lcq3pur4TqfTEzyJi4urkTxIvtDQ/IBfUlIS8fHx5Q7nVaMBlHHjxjFo0CAaNmxIcnIyTz/9NKmpqYwZM4aMjAyeeeYZLrvsMurWrcvhw4d544032Lt3L8OGDfOkMXr0aOLj43nuuecAGDRoEC+88AIdO3b0dO9/7LHHuOyyy7BarQDcd999XHvttZxzzjl0796dd955hz179nDrrbfWSDmIiIiIiJwuVMcXEREREfFWOOdJ4c37yjJNk9TDaWSlZxMUGkh4rTA9+FUJhd9Dbm7uyR1A2bt3LyNHjiQlJYXY2Fi6devGsmXLaNSoEdnZ2WzevJlJkyaRkpJCrVq16Ny5MwsXLqRNmzaeNPbs2eP1NNqjjz6KYRg8+uijJCUlERsby6BBg3jmmWc821x11VUcPnyYJ598kv3799O2bVu+/fZbv7rsiIiIiIiIb6rji4iIiIiUrrLDdqUfy+CHSfP58rXv2PfHQc/yek3rMPjO/vQd05PQyJCqyuZpryLfQ40GUKZMmeJzXWBgIDNmzCg3jfnz53t9ttlsjB8/nvHjx5e53+23387tt9/uVz5FRERERMQ/quOLiIiIiFSdlXNW8+SV/yUnM7fEuv07knnrvkl88OhnPP7FODpf0uHvz+BpTjPViIiIiIiIiIiIiIicZFbOWc2jA58jJyvXM/9fUYXLcrJyeXTgc6ycs7pmMlrFdu3ahWEYrF69uqazogCKiIiIiIiIiIiIiMjJJP1YBk9e+d/8IInbLHNb050fSHnyyv+SfiyjSvORnJzMLbfcQsOGDXE4HMTFxXHJJZewdOlSAAzDYNasWVV6zJNJjQ7hJSIiIiIiIiIiIiIi3n6YNJ+czNwSvU58Md0mOZm5/PjRAobefWmV5eOKK64gLy+PSZMm0aRJEw4ePMhPP/3EkSNHquwYJzP1QBERERERERERERER+ZuYpklWRrbPV2Z6FjNf+RYT/4InRc14eTaZ6Vk+0/Y3IANw7NgxFi1axP/93//Rq1cvGjVqRJcuXXjooYcYMGAACQkJAAwdOhTDMDyfr7vuOoYMGeKV1r333kvPnj09n91uN//3f/9HYmIiDoeDhg0b8swzz5SaD7fbzdixY2nevDm7d++uSHGcMPVAERERERERKeID0ms6CzXmbdJqOgunNZVv9VL5Vi+Vb/VS+VYvlW/1UvlWXHZmDpeFXVvl6ZqmyYGdyQwOH+1zm6/SJhMUEuhXeqGhoYSGhjJr1iy6deuGw+HwWr9y5Upq167NBx98QL9+/bBarX7n9aGHHuLdd9/lxRdfpEePHuzfv5/NmzeX2C43N5err76aP/74g0WLFlG7dm2/j1EVFEAREREREREREREREREvNpuNDz/8kLFjx/LWW2/RqVMnLrzwQkaMGMFZZ51FbGwsAJGRkcTFxfmdblpaGi+//DKvvfYaY8aMAaBp06b06NHDa7v09HQGDBhAVlYW8+fPJyIioupOzk8KoIiIiIiIiIiIiIiI/E0Cgx18lTbZ5/rUlDSuaXx7pdP/eNcbhNcK83nsirjiiisYMGAACxcuZOnSpXz//ff85z//4b333uO6666rVP42bdpETk4OF110UZnbjRw5kvr16/PTTz8RHBxcqWOdKAVQREREREREirieUAIwajobf5uiw27cQukNbak8lW/1UvlWL5Vv9SpavmbGsZrLyGnKCIn0vNf1W/VOtb8PuZgn1TCthmGUOYxWYLCDek3rsH9HcoXmLDEMg7pNalO7QQyGUXX12cDAQC6++GIuvvhiHn/8cW666SbGjx/vM4BisVhK5DsvL8/zPigoyK/jXnrppXz88ccsW7aM3r17Vzr/J0KTyIuIiIiIiIiIiIiInCQMw2Dwnf0rte+Quy6t0uBJaVq3bk1GRgYAdrsdl8vltT42Npb9+/d7LVu9erXnfbNmzQgKCuKnn34q8zi33XYb//73v7nssstYsGBB1WS+ghRAERERERERERERERE5ifQd0xNHcACGxb9giGExcAQHcPHoC6ssD4cPH6Z37958/PHHrF27lp07dzJt2jT+85//MHjwYAASEhL46aefOHDgAEePHgWgd+/erFq1io8++oht27Yxfvx41q9f70k3MDCQf/3rXzzwwAN89NFH/PHHHyxbtoyJEyeWyMNdd93F008/zcCBA1m0aFGVnZu/FEARERERERERERERETmJhEaG8PgX4zAMo9wgimExMAyD8dP/SWhkSNXlITSUrl278uKLL3LBBRfQtm1bHnvsMcaOHctrr70GwP/+9z9+/PFHGjRoQMeOHQG45JJLeOyxx3jggQfo3LkzaWlpjB492ivtxx57jPvvv5/HH3+cVq1acdVVV5GcnFxqPu69916eeOIJLr30UpYsWVJl5+cPzYEiIiIiIiIiIiIiInKS6XxJB57+5iGevPK/5GTmAnjNLVI4VJcjKIDx0//JOX3bV+nxHQ4Hzz33HM8995zPbQYNGsSgQYNKLH/iiSd44oknfO5nsVh45JFHeOSRR0qsS0hIKDGHyn333cd9991XgdxXDfVAERERERERERERERE5CXW+pAOf/fk2t714HXWb1PZaV7dJbW578Tqm7H27yoMnkk89UERERERERERERERETlKhkSEMvftShtzVn7Qj6WSmZREcFkRYdGi1Txh/plMARURERERERERERETkJGcYBuG1wgivFVbTWTljaAgvERERERERERERERGRYhRAERERERERERERERERKUYBFBERERERERERERERkWI0B4qIiIiIiIiIiIiIyEnONE0wj4I7EyzBYERpEvlqpgCKiIiIiIiIiIiIiMhJynSnQtZMzMzJ4Nrz1wprQwi+FoKGYljCay6DpzEN4SUiIiIiIiIiIiIichIycxZiHroAM+1ZcP3pvdL1J2bas/nrcxbWTAarmGEYzJo1q6az4aEAioiIiIiIiIiIiIjIScbMWYh5dCyYWYBZ8PLaIv9lZmEeHVstQZTrrrsOwzC49dZbS6y7/fbbMQyD6667rsqOt3//fvr3719l6Z0oBVBERERERERERERERE4ipjsV89hdlB44KbE1YGIeuyt/uK8q1qBBA6ZMmUJWVpZnWXZ2Np999hkNGzas0mPFxcXhcDiqNM0ToQCKiIiIiIiIiIiIiMjJJGtmkZ4n/sjviULWrCrPSqdOnWjYsCEzZszwLJsxYwYNGjSgY8eOnmU5OTncfffd1K5dm8DAQHr06MHKlSsBcLvd1K9fn7feessr7d9++w3DMNixYwfgPYTXrl27MAyDGTNm0KtXL4KDg2nfvj1Lly71SuPdd9+lQYMGBAcHM3ToUF544QUiIyOr5NwVQBERERERERERERER+ZuYponpzvT5crsyMDMmVS7tjA/z9/eVvulvQMbb9ddfzwcffOD5/P7773PDDTd4bfPAAw8wffp0Jk2axG+//UZiYiKXXHIJR44cwWKxMGLECD755BOvfT799FO6d+9OkyZNfB77kUceYdy4caxevZrmzZszcuRInE4nAIsXL+bWW2/lnnvuYfXq1Vx88cU888wzlTrH0tiqLCURERERERERERERESmbmYWZ3KE6Egb3XjjU0We/FaP2ajCCK5zytddey0MPPeTpFbJ48WKmTJnC/PnzAcjIyODNN9/kww8/9Mxh8u677/Ljjz8yceJE/vnPfzJq1CheeOEFdu/eTaNGjXC73UyZMoWHH364zGOPGzeOAQMGAPDEE0/Qpk0btm/fTsuWLXn11Vfp378/48aNA6B58+YsWbKEb775psLnWBr1QBEREREREREREREREZ9iYmIYMGAAkyZN4oMPPmDAgAHExMR41v/xxx/k5eVx3nnneZbZ7Xa6dOnCpk2bAOjYsSMtW7bks88+A2DBggUkJyczfPjwMo991llned7XrVsXgOTkZAC2bNlCly5dvLYv/vlEqAeKiIiIiIiIiIiIiMjfxQjK7wnig+k+Cim9Kp9+zHwMS6TPY1fWDTfcwJ133gnA66+/7rWucGgwwzBKLC+6bNSoUXz66ac8+OCDfPrpp1xyySVegZjS2O32v7JfkJbb7S41/aJ5qQrqgSIiIiIiIiIiIiIi8jcxDAPDEuz7Za0H1oaAUW5axVIGa0MMa13faRsVTfMv/fr1Izc3l9zcXC655BKvdYmJiQQEBLBo0SLPsry8PFatWkWrVq08y66++mrWrVvHr7/+yhdffMGoUaMqnR+Ali1bsmLFCq9lq1atOqE0i1IPFBERERERERERERGRk4RhGBB8LWbasxXfN3j0CQVJymK1Wj3DcVmtVq91ISEh3Hbbbfzzn/8kOjqahg0b8p///IfMzExuvPFGz3aNGzfm3HPP5cYbb8TpdDJ48OATytNdd93FBRdcwAsvvMCgQYP4+eef+e6776qsDNQDRURERERERERERETkZBI0tGC4LX8DAZb87YOGVGOmIDw8nPDw8FLX/fvf/+aKK67g2muvpVOnTmzfvp05c+YQFRXltd2oUaNYs2YNl19+OUFBlR9SDOC8887jrbfe4oUXXqB9+/Z8//33/OMf/yAwMPCE0i2kHigiIiIiIiIiIiIiIicRwxIOka9iHh1bsKSseT3ygyxG5Gv5+1WhDz/8sMz1s2bN8rwPDAzklVde4ZVXXilzn9tvv53bb7+91HVF5y9JSEgoMZ9JZGRkiWVjx45l7NixXp8TExPLzIO/1ANFREREREREREREROQkYzjOx4h6t0hPlOK9UQqWGUEYUe9hOHr8/Zk8Cfz3v/9lzZo1bN++nVdffZVJkyYxZsyYKklbPVBERERERERERERERE5ChuN8iP0FsmZhZn4Erj1/rbQ2wAgeDUFDMSxhNZfJGrZixQr+85//kJaWRpMmTXjllVe46aabqiRtBVBERERERERERERERE5ShiUcQkZD8LVgHgN3BlhCwIistgnjTyVTp06ttrQVQBEREREREREREREROckZhgFGFFiiyt9YqoTmQBERERERERERERERESlGARQRERERERERERERkWrmdrtrOgtCxb4HBVBERERERERERERERKpJQEAAAOnp6TWcE4G/vofC76UsmgNFRERERERERERERKSa2Gw2YmJiSEpKAiA0NBSLRX0b/m5ut5v09HSSkpKIiYnBZis/PKIAioiIiIiIiIiIiIhINWrYsCGAJ4giNScmJsbzfZRHARQRERERERERERERkWpkGAaNGjUiPj6e3Nzcms7OGSsgIMCvnieFFEAREREREREREREREfkb2Gy2Ct3Al5qlgdZERERERERERERERESKUQBFRERERERERERERESkGAVQREREREREREREREREilEARUREREREREREREREpBgFUERERERERERERERERIpRAEVERERERERERERERKQYBVBERERERERERERERESKUQBFRERERERERERERESkGAVQREREREREREREREREilEARUREREREREREREREpBhbTWfgTHUMN7tx8vDn4LBBi3rgxMSGUdNZOy2k4WYnTh6ZCnYrNK0NeZjYVb5VIqNI+VotkBADuZgEqHyrRBZuduDk0algGNCgFmRjEqjyrRI5mPxBHo9NA9OEelH5ZR6kZwqqRC4mO3Ay/gtwuqFOeP7fjBCVb5XIw2QnTiZMhzwXxITl/+aFqXyrhKugfJ/7qqZzIqeqw7j4Eyc55De0orHQCBsW/YZXicI2VDYmViAKCwnYsKp8q0QqbnbhJKugfCOw0Bib2qhVJL2gDZWFiQGEF5Sv2lBVI7OgDZVZUL6hGDTBjkPlWyUOHz7CF7O+ZG9SEgD16tZl2NAhxMTUquGcnR5yMNlJHmmYmEAwBo2xqQ1VRQrbUEdx1XRW5BSlAMrfLAknv5NLEi6swPpvDdxAptPEQQatsNOBAP3IV9IBXPxODntwYQHWzjYwgSyniZ10WmCnIwG6UVpJKbj4jVx24cQAVhcpXyvpNC8o31CVb6UcLSjfHTgxgd9n5/8dyHKZGKTTFBudcBCh8q2UVNz8Ri7bycMN/PbNX+ULGTTBRicCiMJao/k8VWUUlq/FjdN0s31ZLFaLlYOHDpNnZJJg2uiAnViVb6Vk4eZ3ctlCHrnA8q8MDCDbZeIig4ZY6YiDOJVvpeRgsppcNpFHDiZLvq3pHMmpZhdOVpPLwYI6vh0LbkxyMQnGoDV22hOgG9GVtLegDbWvlPINxKBlQR1UN6IrZ39B+f5Z0IYKwIKJSQ4mAUDLgjaq2lCVc6igjr+7oA1VtHwXg6cNpRullXOkoHx3FrShHAXlm4vJYnJohp1OBOhhk0ra/scOnvnPf5nyxQycTidxdeoAcDA5mX/862GGXz6ERx4YR4vmzWo4p6em9II21DbycAEBGBgY5OBmCTk0Lmij1lIdv1Iyi7Sh8oCAms6QnLIUQPkbbSCXReQQZlhpbgshxhqAxciv5GdaXRxwZrPOlcMunAwkSBWoCtpGHvPIJtiwkmgLJtbqwFpQvtlWFwdcOWxy5rATJwMJ1k3oCtqFk7lkEWBYaGwLprY1AJuRX4Y5NjcHnNlsKyjfAQTpB76CknAyhyysWGhoC6KOzYG9oHxzbW4OOnPY7cxmFxlcSjB1VL4VkoyLb8kCoH5B+QYUlG+ezU2yM4e9zhx2k0lfgqivn8cKOYKL7625BISH8Y8bb2TM6NHE16sHQGpaGp9Pncpbb73NV7t30dsdQGPsNZzjU0sqbr4hkyygji2QulYHgZb8vwEum8khVw77nTl8ZWbSk0Caq3wrJAM335BFGm7qWB3E2QIJMCwscx2t6azJKWIVOfxKLhGGjZb2UKItdk8dP93t5IAzh99cOezBSX+C1aO0gtaRyxJfbSi3i/0FbajdBXVQtaEqZgt5LCCbEMNKoi2EWGuApw2V5c5vQ2105rdRBxBMuMq3QnaQx09kE2hYaFLQRrUVlG9OQflu9bRRg/QgTwX9iZMfyMKGhUb2YOoUaaPmmm4OOHPY4cxmF04uJUgP8lTQkmXLGXjlVYQEh/Cvf/6Ta6++mtjYWAAOHz7Mx59+ynvvv8+Xs3vz1dTPuPD8HjWc41PLYVzMJgsXUK+gjeoouH6dpptkVy77ndnMNDO5mCAaqY1aIcdwM5tMcshvQ8VZHdgMC8uyVceXijNM0zRrOhOnotTUVCIiIrieUL+edNpeUHGqZ3XQ2B6MYZS+T6bbxYacVIIxGEKwnqLy0x6cfE8WsdYAEu0hnkZVcdluFxty07CZJkMJ1lNUfjqAk6/JIspip0VAqM/yzTXdbMxJw2W6uZxg9UTx02FczCKTUIuNVgFhnkZrcc6C8s02XVxOiIKAfjqOmxlkEGhYaeUI8wSminOZJptz00hzOxlMMDFqYPklAzdfWnNp0Kwps6ZPp07BU2nF5eTkcNMttzB79rcMMB3UVQPAL9mYzCSDPMOgTUCYJ3BSnGmabM/LINmVyyVqYPktD5NZZJKBSRtHOMEF5es0TZZlH+X48eOEh4fXcC7l71TROv56cllMDo1sQdS3Bfqs46e5nWzMSaMWFgYSdNINOfU2aZ73txBWgznxtrXgAal4WyAJtiCf5ZvhdrIhJ40wDAYTfNIN23uylu+uggd46hS0oXyVb7bbxYacNOyYXE7ISTdawslavvtwMpssoi12mpfRhsox3WzMScU0TS4n+KQLAp6s5XsIF1+SSbjFRssy2lB5BW2o3II26skWBCxavmbGsZrLSDFbtm6jW68+tG7Zis8++YTIiIhSt0tNS+OaMWP47fffWTz3e9q1bfM357RsRkik5/3JdP2m4WYmmVgNC60dYZ6H+4pzmSZbc9M55s5j0En4IOXJ+vchCzczyMRd0IZyqI4vJ6hGfzkmTJiAYRher7i4OK/1LVu2JCQkhKioKPr06cPy5cvLTLNnz54l0jQMgwEDBvh93KrmwmQJOcRY7GUGTwCCLVZaO8I4hpvN5FVbnk4nJiaLySbCYqNZGcETgECLlTYBYWRisk7l67cl5BBiWMsMngAEFPz4O4Hfyf37MniKW0YOAYalzOAJgK2gfC1YWEnO35jDU9sqcrCQX3a+gicAVsOgZUAYDsPCcpWv334nF3tYCDO/+MJn8ATA4XAw8Z136NChPcutzr8xh6e2deTm39wvI3gCYBgGifYQIi02lpBdMHqylGcTeRzFTWtHmCd4IifuTKnj52CynBzqWh00sPu+uQ8QZrHRMiCUA7jYgf4G+qOwDRVrCSgzeAIQYrHR2hHGEdxsUR3fL4VtqCiLrczgCeS3oVo7wsjAZL3q+H4xC4aPCjVsZQZPAByGhdaOcPKANSpfvy0jh0DDWmbwBMBe0IaC/HaB+OfRJ54mKiqaKZ9+6jN4AhAeFsanH31E3bg4Hnniqb8xh6e238nFBWUGTyC/jdoiIJQgw8pSXb9+W0se2Zi0LhI8ETkRNR56b9OmDfv37/e81q1b51nXvHlzXnvtNdatW8eiRYtISEigb9++HDp0yGd6M2bM8Epv/fr1WK1Whg0b5vdxq1rhRHzlNawKhVhsxFgCWE+uboD4IQkXqZg0KKdhVSjQYqW21cEm8nCpfMt1CBeHcFPfHlRmxb9QgGEhzuZgK3nkqnzLdRw3e3ERbwsqs+JfyGZYqGsPZCdOMnH/DTk8tRVOJlnXHujpzl8Wq2FQzxbEXlwcV/mWKxeT7VY3N954o183KQMCAvjn/fdz0JVHsibwK5cLk43kUbvIkF1lMQyDBrYgUjFJUvmWy8RkA7nEWOyEWNRjp6qdCXX8wvHK69uD/No+wmon0mLTDWg/7cBJTgXaUKEWG7UsdjaQpzaUH/7ERTomDct5wK9QkMVKrNXBRrWh/JKMmyO4aWAP9KsN5TAs1LE52EweeSrfch3FxT5cxNsC/WpD2Q0LdW2B/IGTLNXxy7Vv/35mfv0Nd9x6KxF+PKUfGhrKnbffzjffzWHX7t1/Qw5PbTmYbCXPM2xseSyGQX17EAdxcVh1/HI5MdlUgTaUiD9qPIBis9mIi4vzvArHUwS4+uqr6dOnD02aNKFNmza88MILpKamsnbtWp/pRUdHe6X3448/EhwcXKJxVdZxq9oW8gg3bBVqnNe1OUjDZL/+OJZrC3kEGxbCK1S+gWRjskdPAJZrC3k4MIi2+D+mfpwtECfoCUs/bCUPGwYxVv+nM6tTsO02lW+5theUUe0KlG+sNQA7hp5g9cNOnOS63Vw3erTf+/S9+GLqxcWpfP3wJy6yMYmzOfzeJ8xiI8SwqherHw4UPIARZwus6aycls6EOv5m8oi22D3jlfsjzhZIMm6O6QZeuTaTR6TFVqHeYXG2QI7h5qDKt1ybySPUsBJqVKR8HWQqSO+XLeQRiIXIirShrA7yyK9fSdm24sRe0TaUzYEJ/KHyLdfHn03F4XBw1fDhfu9z5eWXExYayqRPPqvGnJ0edpCHGypUx4+22HFgqI7vhz0FD2DUVR1fqlCNP263bds26tWrh8PhoGvXrjz77LM0adKkxHa5ubm88847RERE0L59e7/TnzhxIiNGjCAkJKRSxy2Uk5NDTs5f3eVSU1MBeOnddMKDy85Ds39A6GH//zBC/hNUAFfemsXo8yu06xmn2+OQuivAryenCgVbrNgMuPSabO7pl12NuTv1DXge9q+zV6h8HYaFYJvBhYOyeeJKlW9ZRr8JO5dZ/XpyqpDNsBBqt9C5Vw6vjFE33rLc8xFs+MlS5tBdxVkMg1CbhdZdc3nrdj0lXJYnpsPmRbWoHx/v9z5Wq5WOHTtg7v+et/6pBkBZXvke5n5MhR7AMAyDEIuV6Ia5vPV0Wvk7nME+XgRfvflXnUuq1qlex/dHGm7qWSpYxy+4WZ2Gm8iaf5btpJaGm/CKlm/B/+d03HCSjRN/sknDTYilYnX8ECN/9p40BajKlYqbEIu1QuUbaLFixyi4fqUsabgJtlj96t1TyG5YCDIspJkq3/Ls3L2bxKZNCQ/zf06LkJAQWrRowe49f1Zjzk4PaZg4sPjV+6SQxTAItlhJd6uHWnnSMLGS33NSpKrUaK29a9eufPTRR8yZM4d3332XAwcOcO6553L48GHPNt988w2hoaEEBgby4osv8uOPPxITE+NX+itWrGD9+vXcdNNNFT5ucc899xwRERGeV4MGDfw+T5ebClWciu8rZctzUalpDA0DnHp4qlwuN1SmF7mBrl9/5F+DFb+CDcCp8i2Xy125vw9g6Pr1g9MNVmvFqxIWqw2n6+SagPZk5DLBUoliMjD098EPThfY7XBB3wBGjA1k4FUOIqJ1XVaFM6WOX5lbGIVtAt3+KJ+biv+GF26vP4HlM6lE+RoGBrp+/WFSuXsAKl//VOb6LaS/D+VzuVxYLRWv41utVlwu3WQpT2V+3yC/ju/WX4hymZgEBVroPTC/jt/vCgehYarjy4mp0QBK//79ueKKK2jXrh19+vRh9uzZAEyaNMmzTa9evVi9ejVLliyhX79+DB8+nOTkZL/SnzhxIm3btqVLly4VPm5xDz30EMePH/e8/vzT/6h63SjINiv2I5Jd8FREHd9zdUmB+tGQU8Fu5Lmmmzw3xEVWT55OJ3UjIc/iwjT9/6F2mm6yXaauXz/UjYQcs2Ll6zZNslxu4lS+5YqLgCy3G3cFytc0TXJMl65fP9SNhORDRzh2/Ljf+5imyR/btxAXqcp/eeIiIM8NORV8UjIHF/FR1ZSp08hZZ4fw5++NefbtcG7+ZzDjnglhxtIobv1XMJW4ZyBFnCl1/CAMsir4/zPL7fLsK2ULxvCUl7+yCtpcwSrfcgVjeMrLX9luF250/fojGIPsCl6/eaabPEyVrx+CMMh2uyvUhnKZJjmmW38f/BBXpza7//yT3Fz/e+M7nU527tpJndq1qzFnp4dgDHJw46xgGzXbdBGs3qvlGjwslN1rEhj/Shg3/zOYB/8TwozlUYy6TUN6SeWdVGMWhISE0K5dO7Zt2+a1LDExkcTERLp160azZs2YOHEiDz30UJlpZWZmMmXKFJ588slKHbc4h8OBw1GyC/m9Y0MJKOcH2EIuR8ghx3T7PUbyAWc2DgxmPh/CV/qBL1MGeRwjm0y3y+8xkg84c7ACc98IZeEbKt+yJOMkjSzSLE7Crf6N4ZvsysVtwoqPQrj1I/3AlyUZF5lkctSaR7SfY/imuHLJdcPG6SHcOl3lW5ZjuMklgxRXLrX9HGP2qDuPTJfJ7u+DufV7dfstSyZuXEYmn02Zwm233OLXPitXrWLj5m002hzErQtPqmrISScXExvpHHBm08heznihBTLdLo65nGSuDuTWUf6Pu34qslihbR8H7S52YA802Ls+j6VTs8g4Un5jtPl5Adz9eZTn8T+rLf+NzQIjbg4kx2my5Omj1Zn9M8qpWMf3RyJ21rhyaGwGY/PzSfMDzmzCMYjRDZByJWJnmTuHXNPt9zAnB5w5BGFQV8N3lSsRO/Pc2WS5XX4Pc3LQlYMdaHhy3UY4KTXFznYzizS3kzA/h4o86MzBABqrfMuViI0N5HHM7STKzzZqiisXF/nfjZTtqisu56l/P8/Xs2dzxdChfu3z/Q8/cPBgMiOuvLyac3fqa4KNZeRwyJXj9zwdqW4nmaabplSuznIqsdqh44BAWl0YgMVmsPPXPFZMzyI7rfw6fqdBgdz0SqQnuFpYx3cEws3/DCEzC5a9qTq+VNxJVXPPyclh06ZN1K1b1+c2pml6jVPsy9SpU8nJyeGaa66pkuOeiGbYsQL7nP7NBZFnukl25dAKO1YFT8rVGBuBGCQ5s/za3mmaHHBm05z8SbikbPWxEoZBkjPbryd83KbJfmc2jbERcnL9iTkpxWIhBovf5WuaJvuc2dTDqrHT/RCJhXis7HNm+9ULpbB8a2Ghtsq3XMFYaGzaeOvtt8nKKv9vsGmavPr660RY7TTQza1yBWDQHDsHnTl+P6GW5MwmEIMmp/nNl6h4C4/Oi+HWD6PoNjyIswcHMuTRMJ77rTZnD/bdELXZAoiKrMuw8bUBA0spY6QZhsHQa4KqMfdnntO1jt8KO27ygyL+yHa7OOzOow0BGKqDlqsFdiz434bKNd0cUhvKb02wEUD+74Y/nKabA84cmmPHrvItV0OshGCQlJflVx3fZZoccObQBBtBqoOWqw5WorGQ5PSvfN0FdfwGWAlX+ZarTetWXNjjPN546y2cTme527vdbt548026delMp44dqj+Dp7hQLDTCxv4KtFGTnNlEFLRtT2dxzaw8uTSWG96MpMsVQZwzJJCrngnj2d9jadXT9wOndruDWrXqceWEaEzT9xCK190ZXl1Zl9Ncjbaux40bx6BBg2jYsCHJyck8/fTTpKamMmbMGDIyMnjmmWe47LLLqFu3LocPH+aNN95g7969DBs2zJPG6NGjiY+P57nnnvNKe+LEiQwZMoRatWpV6LjVIQCDjgSw0plNsGGlThlPQTtNNxtz0rBh0FZPRvjFisE5BLDIlUOwM5v4MiL4LtNkc24aJibt8e9p/zOdgUEXHPzkzmaPM4uGtiCfP0Zu02RLbjq5ppuOqHukPwwMOuPgO3cWO/IyaWIP9lm+pmmyLS+DDNNFL3Rzz19nE8DXZhbbczNoFhBSZvnuzMvkmNtJP4J0c8tPHbHz5d693HjzzXzw3ns+n+Q2TZP//Pe/fPXNN/QiUOXrp7MIYBt5bM5No1VAGNYynnLf58zmoCuH83CcEjcPDQMatrcTHGmQssvFoV3+DXViscJdU6KJTchvQFrtf52rYcD1r0cS7WhM5p8NCQ+LITwshrCwGMLDahEcHIE1LIU67f5VzlE0xNyJOFPq+KFYaI2djc4sgi3WMnuS5ppuNuamEYJBC9Xx/eLAoD0B/FbQhiqrJ2me6WZTThoBGLRR+frFhsHZOFjqyiHEaS3zKWiXabIpNx0Dk7PUhvKLpaCOP9+dTYgzm/q2wHLbUHmoDeWv/DZUAHPc2exyZpFQRhvVNE225WaQZbrohH89egUmPPIgfQYO4R/jxvHS//6H1Vr6jXu3280/H3yQpcuX8+2MaX9zLk9dnQhglpnJ1tx0mgeEYinj+t3jzOKIO48+p0gbymKFhE52HMEGB/9wcmSvf8OdOkIM7pkWTWit/CBn0Tp+QKDBbZOimX5bM9zH6nvq9mFhMYSHxxIUGIq9zk4i6z1ddt7s/g9LJ1JUjQZQ9u7dy8iRI0lJSSE2NpZu3bqxbNkyGjVqRHZ2Nps3b2bSpEmkpKRQq1YtOnfuzMKFC2nTpo0njT179mApNlD11q1bWbRoET/88EOFj1tdOhJAGiab8zJIdTupZ3MQUqQrr9s0OeTKZa8zC5fpZgDBenq/AlpjJw2TNXmZpLuc1LMHenWVdpsmh1257HVmk2O66EcQESpfvyViJw03K5z5Q6XF2/LL1zMRqmlyxJ3H3rwsMkwXFxNEzGn+ZERVaoiNHjhY5Moh23QRbwsiolj5HnPnsdeZTarbSU8CqXeaP11elepioxeBzHNnk53jpr49kCiL3at8j7udJDmzOOp2ch4OGql8/VYLKxe5HcyZM4dLLr2UcfffT7++fbHZ8svQNE1WrFzJq6+/ztezZ9OZAJrr5pbfIrDQjyC+c2exNieV+rZAalkDvBpZ6W4nSXnZHHLnchb2U+LmYefLAxn8UBjR9f/6rdi2LJepD6eStMnXk44GYaHRdB0aTVxiWulbWAC3hX53RXD0m9GlbxOYUX4GTdURTsSZVMfvjoMM8m8u17U6qGsL9BoOyWmaHHLlsDcvCyswgGD1gK6AcwggHTdbC9pQdYu1oVymSUpBG8ptmgwkSOPDV0C7gjr++rxM0graUKGltqGyyDXd9CdIT+9XQAvspONmlTOLdLeTeHsQYYbVqw56uKANlWW66EsQ0WpD+S0BO+dissSZTabbWWob6qg7j7152aSZTnoTSJzK1289LzifiW+8yg233cnOXbu49+676d2zp+e32TRN5v/yCy+/+irzFyzg7Vdf4pKLL6rhXJ86YrHSh0DmurNZn5NKvD2I6GJt1FS3kyRnNkfceXTFcUoMP3fBdcFc+o8Qwmvn/18z3SYb5+cw5aE0Du/x9bCUQXhYDL1vjCC8djqlxZIsVjAMCwPvief4z6X3QrYEppebvwpMOyPixTArMuuWeKSmphIREcH1lD8HSiETk3XksZpcsjAJM6wEGBZMwyQDFzkuk3isnIeDKP2wV8pGcvmNXDIwCTGsnjlnMg0n2S6TuILy1c39ytlGHivJIQ2TYMNCoJFfjtmGk0yXSW0sdMdBnG4+V8ou8lhOLsdwE2RYPDdgcnCS4TKJLijf+irfStmLk2XkcBg3gVgItuY/o59juEh3uonEQhcCaHwKVExPRgdwscKax35XHnG1a9OhQ3tsNjt//LGVTVu2E2m108llpZnKt1JScLGYHA7gIgDDc4PLaXGR6nQTgkEnAmh9CjwZfN41QYx6PgLTNL2eFnU5TZw5Jm9eZZKbUo/oyLpERdUjKqou0VH1iIqMw24PJLLvRIJaLMOw+n6azXQb7H/lHUobrdYSlEadsf/AsPiuAh9PdRHdYgfHjx8nPFxd/c8klanjuzH5jVzWkUsuEG5YsRsW3OTf/HDz18MSoSfpzee3+SsoeQthNZiTkkxM1pDHGnLJLtKGcmOS5nbhxKQ+VnoQeNI+IHWyl+9G8viNXDIxCS1sowIZbie5mNQtaEPVOknbUCdz+QJsJY9VBW2oEMOCw7BiApluJznkt6HOJZA6Kt9K2UEeK8jlOG6vNmqm20U2bmoVtKHiT9I2VNHyNTOO1VxGfJjz40888OjjrF2/gYSEBFq3bAnA5q1b2LFjJ21bt+K5J8czsH+/Gs5p6YyQSM/7k/H63Y+TpeRwCDcODM9DAtmmi0zTTXhBb7bEk7QNVfT6nfWPOAY9ULKMXU6TzOMmb1xpwZpdpH4fmf9vVGQcNlsA0UNewNFoQ6kBFE9amaEcfOflUtfZovZTe8yjZeY3Nc1FVHPV8aXiTs5fkNOUgcFZBNAGO7txstN00rRtHoEB0KIu7Pkm5KSt9J8qWhNAS+zswcUOM48mbfNw2KFpHdj7XbCe6DlBzbCTiI29uPjDzKNxuzysFmhcG/b9EEysyveEJGDPHwsVF9tMJ43b5uUPcVMLDvwUTG0sp0SX3ZNVfWxcgZVk3Gwlj4R2eZgmxEfBwflB1MWq8j0BcVi5zGUlBTtbko9iT/kRpwu61oHGW4Ko71L5nogYrAwmmKO42EQejTvkkZMHtSMgeVEQDbFi+RvL12qHxG4BBIYaJP/hYv/W8sfHhvyu+cOeyG+sFB9qw2ozsFis3PpqG458ea/PNAxbHhhlP/9jWEywuMFdsl7lzgojc3s7gpuuw7CWTMc0Ibf8qThEPCwYnIODDgSwAyd7TCc5phsbBo0JoBX2kzZwciowMOhAAO2wsxMnu00n2aYbKwaNsNMSu9pQJ8DAoE3BdboHJzsKyteCQQNstMSuh/tOUHPsNMPGnwVtqCzTjQHEF5TvyRqYOlU0wU5jbOzDxXbTSUZB+cZhpQWBxKoNdUIuufgi+vbpzdLlK/jo0ynsTUrCNE0uuvACPnzrdXqc293n8GlSvrrYuBwbh3CxhTzS3G5M8udKTcRB/N/cRrUHQbNuAdgDDfZtdnJop39D7NaLszLg/tBS11ltBqFRVu589VyOz73eZxqGPafM4AkUtAN8cB6tS/a+Rjji9pT6oJTbDUdSyk5fxBcFUGqAFYMm2GmCnbce/Ctae+s3qvhXBQsGCdhIwOZdvt+pYloVjILGVANsvPWvIuX7g8q3KhgY1MNGPWy89cBflYNbf1L5VgUDgzpYqYOVt/5ZpHzn6+ewqsRgJQYrb91fpHx/UflWlSisnFu8fBf9veXb88ZgLr0vlNDov+otO3/N5dN/lhx+y2q1USu6AbVjE4iNbUS7gdnYg+b7TNuwuHEkrMMSfAx3ZmSp2+QdakBg4iqfaZgm5B6JYvu230lNO0xaWgqpaSmkpaVwvODfiKm5/Ou7WjhCDKy2v1pqptvEsBgE7j7kX2GIFGHDoDl2DVNYTawYJGI/aZ/CPdXlt6HsJKh8q4WBQUNsNNQtmGphYBCP7aTtZXKqMwyDc7t15dxuXWs6K6etWKw1+kCqYUC/e0O4+PYQAkP/quNvWZTDx/enlhh+y2ZzEFOrAcNi69AitglDRx7HMFbiax5Bw+ImuOUyjs8bBa7Se8znJTcioO4ODEvpvcxNt0FmUizbtq8gNe2QVz0/v65/mLrfO7lvZi2sdrzq+G5Xfr5mPHqsAqUi8hf9uoiIiIiIX/r/I6TUrvkN29sZ93UMn99WH3tGM2JjG1E7NoHoqHpYiswHEdr0K3Bbwer7aTbDAGuo7wDK8TXnENZtVsEQYKVsYJp8+eJu5n8xwecxDu2E/1x6mCufDKNNLweGJT+h5J0uvnwujauHlD7HioiIiIjI6WbY02FceH1wid5Eid0C+Ne3sUy9NYEQEomNaUTt2EZERdXFMP4KtEQ0nFwwh2AZdXybE0tQOu706FLXH/u1K6Edf/K9v8Xk83+v59evfD9ItWcN/G/wYa6YEEbzcx2e5UmbnMx8Ko2Nv2gSeakcBVBEREREpFxhMRYuvc9313yLxcKwx2pzdHbpEztC/vBZ+HiqrKjs4zYOHfyDI0f3c/ToPo4e28+Ro/s4enQ/aelH6LYlkGtfDMfl+uvpMrc7/8myTfNz+GVSZrnHSN7h4o1rjhERZyGmoZXM4yb7t+T3oLl6SLm7i4iIiIic8uKaWel5Q0ip66w2g5AoC1c92pjj80b6TMOdFVbuELum20LWcZPDyVs5enQ/R47l1+0L6/gZmcfosy+Yyx8Px+U0ver4hgErpmfz29fZ5Z7Pn+ucvHTFUWo1sBJZz0L6YTcHt/s3FJmILwqgiIiIiJwh7IFw9mVBtLwwAIsFdqzKY/m0LLJSfTV4DGJq1ade3Rb0uM6CxbKOsrrmBzb9HcORgZlTeiMse9s5RFz4KZQy9wiA2wV7Vrv5z5O3lHkey6ZmcfhPF33vDKZ1z/weJEf+dDH//Uzmv5+J278pWQA4fsDN8QPlB3VERERERE5GjhCDLlcEktgtAEzYuiSXlTOyyc3yUW83LMTGNCK+XnN63ZWD6dqKYS29PmxY3AS1Xszx+VcX9DIpKXNzN8K6fe0zf24nrPshl7f/O7rM85j7ZiYHtrm4+PYQmnXPH+rr4HYXP7+bwZJPsjDLjtF4Ofyni8N/KnAiVUMBFBEREZEzQP02Nu78LIqwGAtuV/5QWWdfFsjgh0J558ZjbFqQS1hoLerVbe71cjiCAQhvMRXMDZTZNd9iYglOw1UsgHLs2AGSU3Zz6NBuEoKj6Hzt4RL7ul0mpgkznj7q1/lsW5rLtqW5WGxgsxs+G4giIiIiIqerxG52bpsURWCogbsgBnLO0ECGPBLG66OOsuv3PCLCa1OvXnPq1W1BfN3mxNVJJCAgEIDIxu9R3jz1FnsuRkA2Zk6wZ5lputl1dB9bUnaw+dAOxsSG0bp/GkaxGIvLZeLKg2/+e8yv81k/N4f1c3OwBYBhhbwsf0tCpPoogCIiIiJymguKMLj782iCIgwMw8BapAYYEGRwx+QYdr5zH0F5rXym4coMB6PsnhqmabBry07271nOoZTdJB/axaGUPeTmFmn5/AIH9odwyV2hBAQZnonbU5PdfHz/cbYvy6vQubmdkOtU8EREREREzixR8Rbu+CQKu8PAsBhYiwQvgsIN7psex+63HyaIhj7TcGeGl3scd56N7Vs3cOjgn546fsrhP3ktL8WzTebSMIY+lj+Xii3grzr+4T0uJt11nKRNFegiDjg1XYmcRBRAERERETnNdb8qiOAoA4ul5ONlhU+JxZ33G8fn+w6gZG3pSniPL3yudzlNNvyczaQPni43P9+9mMG89zJp28dBcLhByh4XmxbkYmokLRERERERv1wwJhh7gIHFWrKOb7GC4XAS22UN6St8B1AyN3cn9Jw5Pte7nCZLP0/lsykTysyL2wXTJ6Tx/SvptL3IgSPYYP9WF9uWKhIipz4FUEREREROEYYBAcEGJuX2tMdqtRFfryWNG3Wg7+jNGMZe3+la3AQm/srx+aNKXZ+aeoikLVtJiapH2yuTSqx3F3TN//r/0v0+l+w0k1Uzy58IUkRERETkdGZY8nuF52aa5c7zYbMF0KB+axo36siFI5ZhsZUx/K1hEpj4G+krBpW6+uixA+zbtIOEuFgSex8qOfyW0yQ73WTOKxl+n0vGEZPl01THl9OLAigiIiIiJ7nwWAsX3xnCeSODCAyzYLpiMQ+kYew+UmQrgzq1G9M4oQONG3WgQf02nrGNA0Oexign4mLY8rvVZ+dksH//NpL2bWHf/q3sO7CV9PSC48yCfttDuOSuEBwhf7WwDv7hYvI/jpO0sWJd80VEREREzlS1Gljpe1cIXa8MIiDIIDvdzdIpWcx5NYPU5Pyu2YZhoW5cs4I6fnvqx7fGZrMDYA9cVmb6hgGGNX943Mys1Py6/f6tJO3bwv79W8nMSgXAMhsGPxxGzxuDsTv+ajTsXZ/HpHuOazJ2OeMpgCIiIiJyEouqZ+Gf39QiLNaC1VbQoLFaoG447trh9B7ckki6k9DwLIKDI0pNI+9gAvbauzEspY+R5XYZ7NsAb797C4ePJAG+H337/uUM5r2bScsLAwgMNUje4WLnrxWbt0RERERE5ExWt7mN+76MJjDU8NTxA0MtXHBdMOcMDuG7B84iNqgLjRqdRaAjpNQ0cg8mEBhyvMw6/h+/ZjD57Rs5euyAz7y4XTDzqTS+fzmdlhcEEBBkkLTJyd71ejhKBBRAERERETmpjfy/cO/gSSGLAVgY/FQGhz7pQVmDemWs7UlI+3k+11usJt+8upfDR3L8ylNOpsma7/zbVkREREREvI15NcIreFLIajMIrWXhsvEujszqXmYaGWt6E5T4u8/1FqvJVy/v5Ogx/x52yko1+f0b1fFFirOUv4mIiIiI1ISoeAttejtKBk8KGBY39ti92ON2lrreNN3sP7CdX75dxoLXwoD8sYwLuV357xd+lMnaOWosiYiIiIhUtwZn2Wh4lr3MOn5gwgas4YdKXe92u9ibtImfP1/Dik+C8pe5StbxZ/8vnV2/qae4yIlSDxQRERGRk0xsTCNaNOtG50G1MSzTyt3eHvMneQeaAHDkSBI7d69h5+7V7N69lqzstPyN5sOGZQ763B5Ms24BGBaDvRuc/PxuBiu+0ESPIiIiIiLVKa5OIi2bd6fbiEDg63K3t8Uk4UqNBeBQym527sqv4+/Zs46c3Mz8jRbCul8CueiWYBI6BQCw49c8fnorQz3GRaqIAigiIiIi1axWAys9bwrm7MsCcQQbHNjmZMGHmayckY3pBjCoH9+SFs2606JZN6Kj4wEICNvsV/p/7vmDJd/+zq7dqzmeWvqTagDrf8ph/U85GBYwLODWsMYiIiIiIpUS18xKr5tC6HCpA6vd4M/1eSz4IJPVs/MDF4ZhoVGDtjRv1p0WzbsREV4bgKCg5X6l/8e2daz6di679qwhPf2Iz+1+/SqbX7/KxmLN/+zWnO8iVUoBFBEREZFq1PhsO3d/HoXN8dcYx4062Lnu1Uh6DAtky6QBNGvcndDQqBL75u5vijs7GEtgps/0XXkmk1+YQfph3xO/F2e6KQjciIiIiIhIRbXpHcAtH0RhWPDU8RO7BtDiPAfrvgklaeZAEhO7EhwUXmLf7N1tMF1WDKvvSEdWqptPXptCXgU6iitwIlI9NAeKiIiISDWxBcCtH0ZiD/SeINJizX/f9Pwczr/OKDV4AoDLTvqv/TB9xUZMk0UfZ1YoeCIiIiIiIpUXFGEw9t0oLDa86viF79sNTKfr8OBSgycAZnYoGWt7YZqlz4FimiZz38qoUPBERKqPAigiIiIi1aTDpYGExVg9AZOSTEI6zgWjZHeQ46nJrFj1FW/ev5D5E/N7oLicZv4k8O6CgElyOl+MT6um3IuIiIiISHHdhgdhCwSLxUcAxG0Q0vHHUtcdOZLEkuVf8Nqtq1g5s6COn2f+Vc8HFnyQyfcvZVRP5kWkwjSEl4iIiEiVM2hQvzU9h0Ziunb57J5vGGANPYYl+DjujCiSD+1iy7albNm6jAMHt3u22/0Y/DIpg27Dg4iKt9LlnGyMA2kY6Tm48sL+rpM6ZRkWaHuRg67Dg4ioY+FokoulU7LY/Etuqb17TOvfn0cRERERObkZhoWERmfRY2AABn8CpfcCNywmAbX/BIsT3Db27d+WX8fftpSUlD2e7T68A+a+mUHXK4MIi7VwbJ+LZdOyOLBVY3H5w2qHDv0DOWdoIKG1LCTvcLHk00z+WJFX6vYhURY4+jdnUk4LCqCIiIiI+KleSxs9rgmibksbOekmv8/On7DRmT9PJDG1GtCuTS/atO5JZEQdwmOmADvLTfeXhVNYs+o3jh7d53Obg9tdfPlsOgDdPlGvE385gg1umxxJ83MduJwmVpuBq6PJOUOCWDsnm/duPoYz96/tjQA7qdH1AN/fhYiIiIicPhp1sHPeqCBqN7GSccRk1ZdZrPk+B7czf31cnUTatulJm1YXEhYaTUT4O8CfZaZpmjDnx3fZsmU5qWmHfG63d72TvetVt6+okGiDe6ZGU7+NHbfLxGI1SOhg0v2qIJZ8lskn96d6PShlOBycf3MYr/1fas1lWk5ZCqCIiIiI+OHS+0IY+M8wz014t8vkrEsCGTjOZN4TZ9Okdj/i6jT12idndxtCO5XefR/A7TY5sM3J/B+/qe7sn1bCYy2ExVo4ftBN+uGSw58VNeL/wknsGgD8NS514b9tLw5k2Nst+XZ2U2yREVijIrAEB3E06jsUQBERERE5/Q1/JoyeN4T8Vcd3mnQcGMi+TSZL/30ezRr2JaZWA699cna3Ibjlcp9pupwm25bmsnKV6vgVEVnXQkiUhWP7XWQcLXuOxxvfjKRui/zb2oXDJVvt+f92HxHMcWtDFi5qjDUqHGtkBJagQDoPmgn/V73nIKcnBVBEREREynHOkEAG/jN/qKzCm++FFfXo+lYG/+cAhyY3LrFfzu425B2JwxaZjGEpeaPfYjH48XWNb+yvhu1tDH44jFYXOAAw3SYb5uXw5bPpJG10ltg+KjGczkODsPgYkstigW590liyrzE5uQGe5UGBpXf7FxEREZHTR++bg+l5QwhQpI5f8G/dFlYGPn2Ew9MblNgva2tnwnt8gSUovdQ6vtVmMPdN1fH91fzcAAY9GErTzvn1cZfTZM132Xz5bDqHdpUczqx+50haFrQHSmMYcMGgNH491hS3+6/pvx121fGlchRAERERESlH37tCPF3DizMsbuy19uFouJGcPW291h1K+ZPlDzWg5+P7iawHpjs/8OLKM7HaDea8ms7yadl/12mc0pp0tnPPtGivYIhhMWh1oYPm5zp4+SaTA0disdWJxR6X/+9ZZ+3HYl1aZrp2m4sGdVLY/mc9z7LDxzWvjIiIiMjpzGKFPreFYJomhlF6Hd/RYDO2mD9xpngHUfbt3c3KBxtx0YS1hEQVbm94erF8MT6VjfNyS6QpJbW72MEtH0R6LbPaDNr3D6RFDwcv3mDhaG4strhY7HVisdWJ4ZzOO3C7f8diKT1NgJCgHGpHH+NASrRn2ZHUkGo6CzndKYAiIiIiUobY+hHUb20vcxvTZcWRsJ6cPW1JTUthw6ZfWL9hHgeTdwAw/0foPCSIToMCCQwz2LfZycKPMvlzXcleE1K6a16IwGqjRBDLajMwLAajXorkvemXeK2zGGV3/fdsV+zJwTWbmwC/nFB+RUREROTk1bRDDJFxPropFzDdFgIbrSc9pQFHjx1g/cZ5rN8wn8NH9gKwYI5Bt2FBnHWJA3uQwZ41eSz8KJMD2zQJvD+sdrjmxXAw8nvme62zGQRGWBj+Ul2mfNfTa53FYgIGUHZdv3gd//dNTYFVJ55xOeMogCIiIiJnpOBIg9a9HDiCDfZvcbJjVdEu3QaNE9rTsX0/WnVoBfyr3PRSjuxk6pSH2b1nHabpXVnPy4Iln2Wx5LOsqj2JU1RoLQtdrwwktrGNzONufv0yu9QhuCB/Uvdml8QRl+i7y73FYlIv9ii1o4+SfCTKs3xfcq1y8+J2w/bv9nJ85xZcx47jOnqcu55L4taKn5aIiIiI1DDTnQLO5UAeHds5+H1djmedYVhIbNqZTu370bJrLPB0OYlB0oGNzPz4J/YmbSqxOjvNZP77mcx/P7NqT+IUFVnXQtdhQUTVs5KW4mbljCySd5QeTDIcDjqOqkNYLd89dawWk2YN9xEanEl6ZrBnedLBWgVBFN9ycyzsmr2drIO/4zqaiuvYcfamawJ5qRwFUEREROSMYrHC4IfD6HVTMLaAv5502r/VydR/uomx9KFD+0uIiozLX5HjxpUegSXkOKX07gfAsLqY/+Uqdu3WcFzl6XlDMFdMCMOwgNuVP0Zxv7tD+X129v+zd9/hcV1l4se/597pM+py77333mIncTrpnd4TeoDdBZb9AcvCArsLZFkIhJBAGimk9+bEce+917jKVm/T773n98dIsmTNSHKTZev9PE8e2zP3ju6cjKT3ve855+VvX6/Ewoenb088/Xrj7tcbd4+u9B/+EbCi1dfOz6lpUkAprcxh/6FC+vYsxUwzwbB+f+Wj/1jW5HG3klmDQgghhBAXEq1j6Nh/Q/I1IDWZac07fVm9Icb3fmAzL+smxo6ZT3ZWIQBOVRwn4cXwxDO+pjId3nt+CYePyHZcrbnun0Jcc18QrVPbFisDrvtuiCVPRHj6+9XgC+Du2wtPv954+vXC1a0LfSdsx3E2tlgMUQryssNNCigHirpSUpZFfm5N2hjfsTVLH6+h/I2mMb7TyooVITKRAooQQgghOpW7fpnNrI/7USctE+82yM03/uGh9KkrsCq6n3hCG4Q3zCdr1gukWybu2JpIlWbdq1I8ac2kG3zc8fPshn837mcy7hofn39lPC8vvazZebG4p9lj6UTKEsS27SJ5vATrWAnJ4yX85aEw33kpn7yeJsoApRTa0WigeJ/NU9+XmWhCCCGEEBcyrTU6+gOwllFfPKk3aYyfd18IUvLklTi1J/phaMtLZMslBMcvSNsI3rY0ZYdsdiyS4klrvv6FHK77bijtc7M+HkANHsGCDbOaPReLe1Bt2HI3fCxMdEsZ1vESksdKsY6X8Me/R/n2i/kEcgxMVyqvcxyNAj5an+SVX9Se0XsSojEpoAghhBCi0+g22GT2JwNpnzNMjVZJQtNepfKte5o8V7FyHvHsZRSOKUI7J5rJ25bGTsKfv1CBlXnymqhz3T+HcBzdbI9jAMOAsaOPsWhzDRXVTZu47zvSnXjChdeTuWdMTZnDmu+9gnPSIRVV8Isry7jkMwFm3O0nq9CgqshhyRMRljwRJR6WmWhCCCGEEBc0ewNYS9I+ZZga7Y0QmvgO1YvuavJc6cKrSGSvJW9gOaAbJljZliZWq3noC5VoCRVb5HLBD+/Lz/i8MmDalEMs3R4nFvc2eW7H/t5cM2c1ZoYiinbg+D6Lbf/+QrPnjtXAzy8rY97nA0y9zU8gV1F2wGbx41GWPRWR3EycVVJAEUIIIUSnMeUWP44FRoYISBkO/qFrqHz3c2B7OF68n/Ub32LL1oUkflvL9Dv8XPLZAN2HuEhENWtfjvL+QxFK9suWTy0xAn56zetL98FVLR6ntWJY/8Os2DSiyePJuOKDBX24+pr9Gc99/b9rmhVP6kUqNW/9b5i3/jd8ytcuhBBCCCE6Np18A61NVIZtWJXhEBi5pKGAcvjoDjZsfJut2xehfxdj9icCzPm0n4K+LmI1Diufi7Hw4TAVR5uvTBEnZGVlccfNA+la2HIPGJfpMKTvUTbvHtDk8XCti+VLezBr9tFmWyVrnSpovfrLmoyvW13s8Mova3nll7LaRJxbUkARQgghxEXPMEyGDZ3BpOkBlNoKZC54KMNh2943WLFoEUeLdjZ5ThrBp/YhHj7Xw7Tb/GR3Nag46rDimQi7lzdt8u7qWoh36EC8Qwfi7t2DgsIK4K0WX1tr8LgtdDJJ4lARiYOHSR44QuJwEa9YFtZ3glxzXwhl0lAIcyx49Ve1LHq0c/9/EUIIIYTobLTlENlSieE5hKdXyxOaDF+U1eteYf2Gtyku+ajJc9IIPrW17pgrvUy+yUcwz6DkI5tlT0Y4sLHpDCVXj274hqVi/O/06MagPkeBhS2+dn2M78QTJA8dJXHgMIkDh0kePc5T2ibxkyzmfT61S4Bjg+mGZBSe/X9VrH9dlpKI808KKEIIIYS4oHn8imm3+5h+p5+sAoOyQzZLn4yy7rUYXlcWE8ZdzeSJ15Gd3QW/fhXUlhZfLxnTvPLiQ1iy3XEzbj/c+9c8Rsz1Ylsa06WwLc2MO/2sfTXGk/+TjXvQIHxDB2Lm5jQ5t6ImhG0rTDPzPgimqdn//GaOP74AnOYz/t74TZhFj0aYeL2fnG4GlUU2a1+JEamUvRWEEEIIIS4mWtdA4hV08i3Q1WD0R3luAdccnFqb2jVlhNeW4URscubl4OlhgJl5xUhNicPb7z7Yju/gwhHIVXzjqTz6jfc0xPhDZmjmfCrAoseivPRIPp4hg/AOHYiZ1bTXSWlldoZXPUEp2P3oKorffI2T90TTwHM/quHdB8JMuiFVvCk9YLPu1ZhstSs6DCmgCCGEEOKClVVo8O0X8uk22ERrMAxFXi+TYbO93PDNLkTe+iEudaKfRnT7DLJmvJTx9WxLs/K5qBRPMrjrF9kMm51q6F7frLH+z4kf8xHvM4j3VkxIe2484WHznv6MGfIRptE8GXJsTaRSs+7vxSf3/myitkyz6G+de4agEEIIIcTFTDuH0eEvgy6tfwTs4+joMhLHp1P67OfBNhuOj2ybRXD8+xlfz7I0i5+Q+DGTz/8xl96j3UDzGH/Op/zEBg9vtsVuvaqaEHsPdad/r+PpY3xLU3LAZtcbpWnObvQ6xxze/7P8PxIdk3G+L0AIIYQQ4nR99vc5dBlgopRqaExeH+wXDCsl/9JXmhxv1xRSu/q6tK9lW5pIlcOb98seuunkdDOYdqsfw2zeAB5SM8umjN6Fx51M+7yTSPDGYzlUlaRWrTRmWxrtwN++UYmd/nQhhBBCCNEJaK3Rke+CTjV2T/0H9VvwuruuIDTpjSbnJIv7E94yO23D96SlOXTU4oOHpBdeOj2GuRg5z9uQQ6Uzc/x2lEo/wykajfLbv2QTrSZtjG8l4dFvtNwHUYiOTlagCCGEEOKC1H2IyYi53ozPK0MTHL2YmmU3oxOpPXUPHdnO6u/voufcWq78RoBQ/om5JLuWJnjqe9VUHJFmkc0YBqNu643hanlpjttl06dbCXsP9wTArqwmtmsf8V17SXx0GGybX75scO23g8y4y483aKAdzbYP4rzxmzAHNkj1RAghhBCiU7PXgbMv49NKQXD8e9SuuQac1G1N74AQroL/h/L8A5J/B1IrGRxH8/q7Yb72/WJurAi0x9VfWEyTsXf1wnHiGBmm2CsFoUCMrvlVHC/LA8AqqyC+ay//2LmFQ4cO4TgOOa/ncO23Q0y9zY/bm5owteGNGG/8JkzRTiv9iwtxgZACihBCCCEuSMNnhdA6FdRnolxJzMJ9rH+3hFVrXqbo2G4Atm2HDx6uZeBkD96Aomi3RdnBlhtPdkbunt3xjRuBf9QwsiYWAStbPccpL6VmwT7iu/ZhFTdfql9b5vDsv9Xw/L/XEMo3iNVq2d9YCCGEEEIA4MTWgDYyrngAMAO1uAqK8fYZTWhqIe6uvrpn7kH7PgP2JtBJ+o+4kSNFcvP+ZO6+vfCPG4lv5FBC4/cAmzix0ic953gR1e9vIr5rH3ZZBQAHqGl4vuKIw5P/VM0zP6wmmGcQrdIkohLji4uDFFCEEEII0SG5fameJvFI08A7GMxj6qQbmDc3F3im1dd58ZVfsXFBebPH7STsXt75mp3kdDPI6mJQXexQXdw8MTVzsvGNHY5/7EhchfkNjx8tLmj1tR1bs+237xM+1voqHjsJVcdltY8QQgghRGeidRRQKOVr8rhVmaB2RQnKLCU0BWhhkhRAl08Pwgz2bva4Uj5wTQXoVMWT/N4GgVyDyiKb2rLmhQuzIA//2BH4x47AzM1pePxoSQFGmt4ljSWiml33v92mSU9WPNXPRIiLiRRQhBBCCNGhjL/OyxVfCTJgUqpZedEui/f/HGb7GzlMm3IL48ZcgcvlQRcfRamWCyiJqGbnqor2uOwOr994Nzf9MMSw2Se2Pdu2MM5LP6/hyG4T38gh+MeOxNO/eSIKUFKRy8GiLvTqVpq2QaRtaTa+FZeESQghhBBCNKG1huRr6MST4OxNPWYMR3k/hVUxh5plJUQ2V4IGT+8hZE1rJZ5UuRiBAef+wi8AQ2d5uPEHoYbcybE1m96J89LPaig55sE/ehi+sSPx9Oqe9vz9R7pRVplFXnZt2kKKbWmWPRWRFeOiU5MCihBCCCE6jGu+HeT6f8nCtk8E6N0Hu/j4f+cQ+exMqt67lvrpaFZ5T+IHR+DpvRNlNE+yHFuz7O8RYjUS7A+a5uZbz+ajTtrbeNgcL//8uo+/vXQZReXdWn2dZ58YyJc+X0ZWrtPQTF7rVAP40gM2T3+/+lxcvhBCCCGEuEBprdGx/4LkczReVqLtnRD9IZFN1xLZdGvD44nDw0iW9sSVfyxtjA8K5bkLpeSW5tirvHz54dwmjxmmYswVPobNDfLwi1dSXpPX4mtoDU8+MpgvfmkDXr9uaCbvOKkc6vCWJC//Z+05uX4hLhQZWgQJIYQQQrSv3qNdXP8vWQCY5onkShl1zSJHL8M3aH2Tc8rf/AKR4iy0PhHkO3XFl90rErz4sxoEfPLXORgmDQlRPdME0wXXX7Y247lWeSW1C5dT8rtH2Pebl/n53CLe+t8wlUU2VkJTfsjm1f+q5VfXlFFbJqtPhBBCCCFEI/byuuIJNO6zoVTq71lT38DdY0+jExTlr38DnchF68axq5n6w3UpeD5zTi/5QmC64RO/zgZFw8Smhudc4PE5XD1nQ8bzk8Wl1Ly3mJL7H2LHf7/Jz+cd54OHIlSXpGL8kv02z/+kht/cUi6rT0SnJ+VaIYQQQnQIl3wmgJ3UmO70Gx5rxyA4bgGxvROx7SSbtixg+crnqf1VEdNu9zH9Dj9ZXQzKDtosfTLKutdiOJ1n2+OMBkxy021Q5pDPMDTdCyvpVlDB8bLUDDUnGiO2dSfRjdtIHi5qcnxtmea1/67ltf+WmWhCCCGEEKJlOvEPUsUPO/3zjkFw7AdUFg1GuRXBiQWEpg/HzJ4GiVfRyTdBV4PRH+W5BVxzUCcvq+6ERs/3klVgZnzeNDSD+hSRFYxQEw4AYNeGiW3ZQXTjdqxjxU2Orzjq8MJPa3jhpzIBTYiTSQFFCCGEEB3C4Ek5mO5kxueV4eAqPMTylc+zas3L1NSWNTy3+LEoix+LtsdlXlCUz0uvKwYCrfeBycuq4sCSMqKbthHfvR/s9EmuEEIIIYQQbaG1Rse3o8zMcaUyHNzdDpJ1SVdCUwsxA/W3Kj3g/TjK+/H2udgLiBEM0OuyfjhOZYsN4JWCHH8VxSsOEt20jcTeA6k9u4QQp0QKKEIIIYRoF6YbtAPOSfnToIGTmDPzbvKyXkbr3aj0C1AAqKmsYcHCR87thV4EzII8gtMm4Bs3CmPIcWBRq+cce/IdKt+TVSVCCCGEEKLttE4AJkqZjR7TRLdXUbOomLxrTFwttOHQGtwFOXj7p29yLk5wde9CcNpEfKOHoft8hFKrWj3n6IMvUbVFJpoJcSakgCKEEEKIc0YD0+/0c/k9AXqNcAOwa1mcd/8QJv7ROObMuptePYcBENt7GE+v3Rlfy7Y0a1+T4L8lnkH9CU6bgHfIgIbH9h3uTizhwufJvJ9ZTZnD7g+leCKEEEIIIVqntQXJ59Hxp0EfBhTanAmeTxHbNYjqxcVYxTEAonsmE5r0VoaG8KCUQnkua8erv8AohXfYIILTJuLp37vh4Z37e3Pt7NWYZvoVJdrRFO+3OSrFEyHOmBRQhBBCCHFOaEAP78qnL8tpaOwOMHial6EzvVQtmkF43bCGxyPbZhGa8jqGL9wswXJsjZ2EhQ9H2uvyLxjK7cY3biTBaRNwFeY3e96yXSxaM4YrZ67P+Bqv/3cNdubd04QQQgghhABSxRMd/WewljZ+FG0tB2sZ0W2fxyqe2fBMeOOlBMctAFcC1Wy7KQMIgfvG9rj0C4ryevFPHE1w6njM3Jxmz0diPlZuHs6McdubreDXWqMMxcu/kH4mQpwNUkARQgghxLnRJQQ9U8G+YZ6I6o261f05lzxL/KMxWOU9AdDxAPv/+ll63PlHgoUOdlKDSh0fq9U8+LkKyg52rr4cwTzFuGt8BPMMyg/ZbHw7hhVPPVeZzGFV5VS6fHsiht+X8TW04/DB3yGxAa7+osZwpbZRM02wkvDqL2tY9KjMTBNCCCGEEG2QfKGueNK0GKKUg9aQO/9vxA+Mwomk8gCnNp/KD75P3vzfADWkGsoD2KByUYHfoYwW9vi6CGV3NRh3tRdfyKB4n8Xm9+I4dYvFzYI8AtMm4B83EsPjyfga2rJ49U8uYjMd5n1cgQLHAdMFiYjm2X+rZsPr8XZ6R0Jc3KSAIoQQQohzQvfOSW1qnKGpiXYMAmMWUv3hxymvOMqSZc+wZdsHqF/ZTLjOx/A5HpSp2LcmwZoXYsQjnafhoVJw3T+FuPLrQUxXfTKkiFQ5PPc/Js8cvZodtcPRGBj+9K/hRKJE1m4isnojTk0tbzwPH/5eMfF6H9ldTSqP2ax7NUa0qvOMqxBCCCGEODM68QwnF0/qKQVaOQRGLaZ29cdwdfWRfUlX/CPGAPMh+Q7aXg8olDkZ3JejlLc9L/+8Mlxw279nccmnAyjjRIxfXWLz1K+8HNRTmmzFm45dU0tk9UYiazehI1Geexne+bXBxOtTk67KDtqsf61z5U5CnGtSQBFCCCHEWac16FCgxYbwynBQ+bt4+bVfs2XbQrSu27bLgTUvxVjzUqx9LrYDuva7Ia79Tqjh36aR+tOfbfDp/9A8/WY2utZIe26yuJTIyvVEN20Hq2nfk3CFZvFjstpECCGEEEKcOsdJgnOw1eM8fY6S378f/uHZqIaEwAeeG1DccG4vsgO78+fZzPqkH8NIjUl9jB8qMPnif9k89kqIQ8fSn5s4cozIynXEtu5KVV4aqS52ZKtjIc4hKaAIIYQQ4qwa0H88JXvvJm/GXzDdmffd1Q4cPLCHzVsr2vHqOj5/juKqbwTTPqcUOBoun7aBXQd6AankS2tNfNc+IivXkdh/qB2v9uKke2SR2mJCCCGEEEJorYntrKb6wyIK7zQyNoQHQCl8A/MxAs37dnRmBX1MZn/SjzKazzAzDHAczdzJm3jitcsbHteOQ2zbbiIr15E8XNSel3vRUQrmfc7PXx+pPd+XIi5AUkARQgghxCkZMMnNsNkeULBvVZJdyxIA9Os7lrmzP0HfPqNJRCC2ZyKB0YtbSLA0G9+UfXlPNu5qH6Y78/OGgi751XTJq6Kq0k/Fiq1EVm7Arqhst2u8kBX0Nbn8ywGm3urHG1KUHbRZ9GiExY9FSMbghu+H0EP9SAGlc/srnTe5flA+++eUjO+5JeN7bsn4nlsqmHtev/5ls/3MmOLHtjXvL46wan0qTp8/aCbfmf15xnQfCkBs/1h8AzZljPGVcrjjs4/w/Ou/a7drb4vz/fn9lxvzsHXmG7GGAQN7Hyfgi1FWoVm7di2rV6+murq6Xa/zdJ3v8R051MO378nltuuz8PsVO3YneOCvlTzyVDWWBQ/9uivXXxeCR0rO63WKC5MUUIQQQgjRJnk9Db78SC79xnmwrdSeuqZLUbrP5ODTn6B7YG6T48Pr5xMYtQTtKJTRdA9e29KEKxxWPSfbSTVmhILkTxuI1qUo1fK+xXO7L2Zw/lbu+0nm5pKiqX7jXHzruXzcPoXpSs3+K+xvcsuPs5h0g4+nv1/N1d8KUV1jn+crFUIIIYRoH8MGu3nhrz0ZPthD0tIo4Oc/KGT7VpOil77I8ODUJseH11yNb8DGtK0Ok5bmwKEkL7/deScipJObm8uUSUOASjL1j6m3YvlbvPrGVqyTtuIVmc2/JMArj/fEUOB2pz6UI4d6+MMvu3LDVSF+/acKPn93jsT44rRJAUUIIYQQrfIGFN9+IZ+8XiZAw81ngIL+mrxvvUTJ4xNxYlkNj1sVPal84+OE5j+By6tTfVF06tyaUof/u6uCWK00NwQwsrMIzp5CYMJoIvlFGMbiVs8Z5d6Esi1ACiiQSuCn3uZj7ucD9BrhxkqkVjgteDDMkW0WyoAvPZzXpHgCNOxB3W+Cm3v/kY+j5TMphBBCiM6hS4HJwhd7k5ebivHdjWKk4SM0Q3q+SMmT49DWiUbviaIhbPvHjQy95SUMQ6NJxfhul+Kjg0muuvPIyW34Oq2CggJmz57N2LFj8Qb2YhqrWzw+mdS89/5mLKuFLdI6GbcbPn93Dl/5bA5DB3mIRByefaWW3z5Ywe59SQJ+xbMPdcdlgmme+PzW//2qywJMneyXGF+cESmgCCGEEKJVU2/zUdDXbNQE8gRlOBj+GgJjFlG7+joATHcR2d0eIxB4i++MDzLtdj8DJrpxbNi+KM66V2NYsnsXZl4uwdlT8I8biTJTievuAz2JxDz4vYlms/ogtXrHrI6iYpKZ1lMGfPb3OUy52Y9jawxT4fYqptzsY8rNPv7y1UqC3U3y6wqA6RiGIienvquM6Ow+RwhPJ/o0NN524x6yWjhSnA4Z33NLxvfckvE9t873+F77mSCFeSaGmT7GN3OL8Q9bRWTrHABKyw6xaMmTbNuxhNB/KGbc5af3KBdWXLP53Tib3olzteVv77eR0fkaX1fXQoKzp+IbPawhf9q6px9XzVyLy5W+OGJbmvUvx/h4bfpeiB1R4/HV4cqz/vpaJ9CRb4O9ilSUrvF6TO75dD73fLorjvdXxGKr8PP3tHkTdWflZSmMTAcI0QZSQBFCCCFEq6bc7EdrlTEwRWn8w5dzZMEUli57hi/904soI3WDP1qtWfhwhIUPt9/1dnRmYT6h2VPxjRmOMowmz9mOyeuLpnLbFUtwnNR+yA3PWZpkTOPaLXv3Njbz434m3+QDaHIDwHQrtNZ88cFcDpdrHK1bTJ4MpWR2mhBCCCE6jam3+dMWTxpohX/YCg4tHsjipX9n6/ZFaJ0qANSWad79Q7idrvTC4OrRldCc6fhGDG72XCzh4e1lk7juktVoJzUBqJ5taSJVDq/8SvoMNZF4DOz6VTuNY3QbrW2s8LeorNH4chUqw8QXpVI5rJYYX5wBKaAIIYQQokX9+46lZ38LwyjPeIxSkFQlPPDnL2HbVkPxRDTl6lZIcM40fCOHpl3NA6Ati7XPVlD6XIzr7zPpPfJER/ldSxM89+MafvyjRHtd8nnXbbDJ5fcGmXS9D7dPcXyPxYd/i7DsqShO3cfs8nuCqZwqzZAqpTDQhLxtW10is9OEEEII0RkMGTyNvK7FQOaehMrQ1CT286e/3NtQOBHNuXv3SMX4QwdmPMZJJFn0cBXFL0S57ptuug5M3ZJ17NTqned/XEP54c4zxtregY4/CdaHgAXGEJTnTnBfjVIGWls48adRGXrGKAUel8LbxjvbmXIvIdpCCihCCCGESGvggInMmXk3fXqPRNX+AW1Xosz0Qb1ja47sjGDbnbdwYpgw9movM+/2k9/bpOq4w8pno6x7NYYq7E5wzlR8w5vPRqunkxaRdZsIL12DU1PLZmDzq6kCQjDPoOKITcXRzpNUAQyd5eFrT+RhuE703ekxzMXdv8xm8q1+3nspRvcpHroPbltI21LipLWmusyhusQhu5eR8TghhBBCiAuXYvjQGcyeeRfduw1CV/8c7d+PMtLfpLYtzUdbKjt18cTlgYnX+5h+p5/srgblh2yWPRVl41tx3H16E7xkOt6BfTOe78TjRFZtILxiHToSZTWw+plUTOvPUpQesKku6Vzjq5Pvo6M/IDW9qa6xu7MDHfsxidjrHK4cRk3NIsb1qWrxdRxdv8I8c+yutSKpu2EqB83xs/cmRKciBRQhhBBCNDF40BTmzLybXj2HNTwW2TwX/+B1Gc8xTMXixyPtcXkdktsPX30sj2GzvakeJS5Ft8GaEZd4ueJ7QZ549xriifTN3p1EgsjqjUSWr8UJNx/D43tsGhKLTsTthy/9JRfT3XRbrvq/D5nqxuzv4lCZRmvdcnEESFhQUmpTkG80NI5vTCnFG/9dy5qXY/z47cBZfz9CCCGEEOeLUgYjhs9m9ow76dqlf8Pj4U2XknfVvoznmS7F0iczr1C52AVyFd98Jp++Y90Nffa6DXIxer6PPXtyefaDK7Hs9LdWnWiM8Ip1RFatR8eaN38s2tk5J55ppxwd/TdSEXrjwlHq7269knh4BbURDWTuX1gvmjSIJjz43EmUal4IVErjDXwHzNGo6LeBPWfjbYhO5rxOr/vJT35Stxfdif+6d+/e5Pnhw4cTDAbJy8tj/vz5rFy5ssXXnDdvXrPXVEpx3XXXNTnugQceYMCAAfh8PiZNmsTixYvPyXsUQgghOhLTDWOv8jLvCwEm3+zDG6y/kawYNmQGX/jM/3LXbT9pUjwBiB8YRWTHVNJtHes4mi0LYqx7JXbu30AHdeuPsxkyI1UgqV8pYdbd6O/RK8L181Y0O8eJxaj9cAUl9/+F2vcWpy2edGaTrvcTyFEt7svdOz+1qL8iTIu9SwyleOtH1fzX3FIOb0klq7aVOt5Opv589w+1LH4sSrRKY2w+dvbeSCckMb4QQgjRvtw+mPCxVIw/4WNe3KnWcChlMHrkpdzzhQe45YbvNSmeAER3TiV2YCTaaR5vaUez4tkoO5d0nq1jT/ap3+bQa2SqQFIfk9bH+gMHVjJ/+oZm59jhCDXvLabk/r8QXrQibfGkU0u+isaCDFtzAfQpUCRsqI3pFnuXGErRt9fvCOQ/jzJ61z9a96cJKJT3myj3pSijC8r/h7P1LkQnc95XoIwaNYr33nuv4d+meaK6OHToUH7/+98zcOBAotEov/3tb7nyyivZs2cPXbp0Sft6L7zwAonEiR/uZWVljBs3jttvv73hsWeeeYb77ruPBx54gFmzZvHggw9yzTXXsG3bNvr2zbzsTgghhLiQTfiYl7t/lUMo32iYQZWIalY/Vkjw4Ffo2mVAxnMrq4p54ztxus4Jc+mXfGQVpn5fRyodFv41wpu/rcXpfIskgNTMtJl3Z27AaRiaEQMOkxMKU1UbxIlECa9YS2TVRnS88yVULm9qG4Tx1/jwBBRHd1gseTxC8b7UB0i5oPsUD1O/GEDr1P7G6Sil8LrB44KDZQ75ofQz1GxLU3XcYd3LMewk/Ne1ZYye72XSjT4COQbF+yyW/T3Kke2dcxbguSIxvhBCCNE+Zn3Szy0/ysKfdSLGj9Y4rPpLbwoqv0J+Xs+M55aWFPHKPRYDrq1lzmf8BHJSN5+rS2wW/CnCe3/qvE3iC/qajL3Si0qzchnAMGDiiD18sHos8YQHu6aW8NLVRNdtRic7X1ypdQSSb6GtpaATYI5EeW5GGalJNLYTo7RiMR7rKbJ9OmNzQqUUoboC4MFSzcjemeb+m2AMQrmnp1aih54G6wN08gPQETAHodw3o8y+TV5biNNx3gsoLperyYy0xj7+8Y83+fdvfvMbHn74YTZt2sTll1+e9pz8/Pwm/3766acJBAJNkqvf/OY3fOELX+CLX/wiAPfffz9vv/02f/zjH/nFL35xJm9HCCGE6JDGXOHliw/mNvy7/ma/x6+YdU8Z1Uu2U7umeQGlvOIoS5c/w+atH+A4NqyHdx6ooftgF0rB8b0WVuedlAbAgIluXJ6Wg3GloE/+QQ69UEx0zSZ0MtlOV9ex5Pc2ue+5PAr7uRoS/GGzPVz+5QDvPBzhULmm91wv3myDYDfVpq7vu16KcGBRgp3jXNz+H9loJzUz0LE1yoDqYoff3VmOXTfkjg2b3o6z6e3OV7xqTxLjCyGEEOfejLv8fOK/cxr+XR/j+7MM5n77KBXv7CO6rXkBpbjkIxYve4odO5ehtcOmjfD6b2roNtCF46RifKfz1QCaGDLDk7F4Us/lcugRPMjGFz8iun4r2J1zRtno4R507c2gy0kF8BrsVejE36h17uJQaSXFFe9j22FG9lJk+xQtBfpaQ7+en6UgdxZ4VkPiYVIrSmxSK0wcMHqjAr9tKIoo5QH3VSj3Vef8/YrO57wXUHbv3k3Pnj3xer1MmzaN//zP/2TgwIHNjkskEvz5z38mJyeHcePGtfn1H374Ye666y6CwWDD66xdu5bvf//7TY678sorWbZsWcbXicfjxBvNEq2urm7zNQghhBDn283/LwsNaXs/AISmvUJ446XopB+A0rJDLFn2DFu3f9isaaRjwdEdnTyjquPq1oXQvJHAzlaPrXl3EZHlnXcWnzLg60/lkdcrtRLh5G0QrvpSkM2HbEprUseX12r6FGTebdaxNYe3Wqz+bWpMi9cm2fJegtmf9NNnjJtkTLPp7ThrXo6S7Lxbd583EuMLIYQQ55bhgpt+GMrYC05ryJ79HNEd08FJ3f47dnwvi5c+xc7dKzh5CyUrjqzIrePu05PQ7EHA7laPrX7lHaJrOu9Wxn6/4u1neoGurHuk/nPloDUE1JNEwk5DbamsFrrltNS70EC5ZjC47zfrHpmEdl+JTr4I9j5QQZT7cnBdhlLuc/SuhGjqvBZQpk2bxmOPPcbQoUM5fvw4P/vZz5g5cyZbt26loKAAgNdee4277rqLSCRCjx49ePfddyksLGzT669atYotW7bw8MMPNzxWWlqKbdt069atybHdunXj2LHM+13/4he/4N///d9P410KIYQQ51evkS66D2n5V77hTuIbuJGDS3uweNnTbN+xpFnhRJxgFuYTmjcD/6hhlLhj2M4uTCPz/rwA+1Z23sQKYNRlXroPzvw5dLSmb4FBaU3qc1ceTu17HPCm9jc+mWEq3v6/2iaPlR20efk/a5sdK9qXxPhCCCHEuTdslqdhW910lAIzUIOn1y72rzRZvOwp9uxd3Y5XeOFx9ehK1qWz8A4ZQJFVRWsFFCuhObChc69qvvumLLp1MWnaED5FKXA09CkwqDqcer6kWhPvqnG7FOnm9ikclPdTTR8zB6LM756LyxeiTc5rE/lrrrmGW2+9lTFjxjB//nxef/11AB599NGGYy699FI2bNjAsmXLuPrqq7njjjsoLi5u0+s//PDDjB49mqlTpzZ77uTqfKaKfb0f/OAHVFVVNfx36NChNl2DEEIIcT75fCFmzEm/JU5j2lFs3vMCDz78NbZtXyTFkwzM3BxybryKwq98Gv+oYQBEYj627O6Hk6b5JqR6cGx9P0bJ/s65pL/euI95se2Wm0DmBBRmXXRaujnJ339STdmB1Lg5defWN39/+Rc1rH+tcyesHZXE+EIIIcS5FQzmMXXWpW06dvnGR/jr49+R4kkLXF0KyL39egq//Em8Q1LbGpdV5rD3UHfsFmL8Vc9HCZe3PInqYnfLx0K00OcdQykKQvX/UuRkTaXauRelChoeqzsSMFC+f0W5Jp2z6xXidJz3LbwaCwaDjBkzht27dzd5bPDgwQwePJjp06czZMgQHn74YX7wgx+0+FqRSISnn36an/70p00eLywsxDTNZjPRiouLm81Ya8zr9eL1ek/jXQkhhBDtLytUwNQpNzFx3NUEutYAG1s8Xhma7ev2cPJSfpFiZIUIXTIN/4TRKLP5TL+3lk6mS04FPbpVoZ1Ubw/tpMay9CObx77VSbcFUtBtspshN/npf4UP1YapOzueDLPrtRiRY6ki3panooy/zsf4a334QoqinRZLn4xwbHfnLkhdSCTGF0IIIc6O3JzuzJh2C+PGXEGg2wFai/EBdqzbc+4v7AJl5uUSmjcD35jhaSdcvPzBDD7zsbfJz42g0RjGiT57hzYnee5HNefhqs8/ZUDPmR7+5+YeTJ4SoLXe7EophvT7Nt0Krsbr6QKA1p+A5Dtoa1Fd0/nhdU3nm/fsEeJ861AFlHg8zvbt25kzZ07GY7TWTfYpzuTZZ58lHo/zyU9+ssnjHo+HSZMm8e6773LzzTc3PP7uu+9y4403nv7FCyGEEB1AXl5PZk67lTGjLsflSu0Ja1cFiB8ZjKfHXlSabaYcRxOp1GxZILP5T2YE/ARnTyUwZRzKlT5scqIxShes5r9+sY8pN7qY9Qk/+b1Mqoodlj8dZfnTUeLhi68w5Q0qpt/hZ8otPgK5Bsf3WCx5PMLW9xO4gor+V/kYfKOPrN6pcauJQUvpkHY0FUUOG/4SafK4lYA1L8ZY82Ln3gLtQiYxvhBCCHFmunbpz8zptzNy+BwMIzWZJ3F0MFZlF8zs0vQxvq0p+chm/9pke19uh2dkhwhdMj01OcpIP8PHrg1z9M2V/OznB5lxu4eZd/vJKjSoOGqz5Ikoq56PYl2E6VMwTzHjLj8Tb/DhCxoc2ZZk8WNRdi1L4MlWDLzOx6Dr/QS6pT6HNVFNYailniYKZY6gb4+TtuVSfvDciPJInCY6vvNaQPmnf/onrr/+evr27UtxcTE/+9nPqK6u5jOf+QzhcJif//zn3HDDDfTo0YOysjIeeOABDh8+zO23397wGp/+9Kfp1asXv/jFL5q89sMPP8xNN93UsM9yY9/5znf41Kc+xeTJk5kxYwZ//vOfOXjwIPfee+85f89CCCHEudCt60BmzbiDEcNmodJM86/+8G4K7/glGqtJguU4GgU884Nq7E6YWwVyFbM+EWDabT6CeQbF+22WPB5h3dsa/7TJBKZNwPB40p7rxBNEVqwjvHwtuu7G79Inkyx98uLvWJ7f2+DbL+STX9cQXhmKLv1Nxl3tY++2JPujCtPfNJEqrtIM7qYwjQyNToEPHgq3x+WLc0xifCGEEOLs6NNrJDOn386Qwc23rQRF1fufIv+m+9GObrLS17E1WsPT3++cq6CzuxjM+UyAb92YT1bIYOvOOPsfS7B5kUlg9lQCk8a2ODkqvHQ1kVXr0UkLgIUPWyx8OJL2+ItJj2Eu7ns+j2CugVJ1Mf4Ak0k3+tm2PslRpTA9TeP4okpN/y4KMmybqtAoz53t9RaEOCfOawHl8OHD3H333ZSWltKlSxemT5/OihUr6NevH7FYjB07dvDoo49SWlpKQUEBU6ZMYfHixYwaNarhNQ4ePIhxUrV4165dLFmyhHfeeSft173zzjspKyvjpz/9KUVFRYwePZo33niDfv36ndP3K4QQQpxtffuMZtb0Oxg0MPM+sY5js/6D/Xz0iuKy78QZPPVEQaB4n82L/1HD5ncuwulTrSjoa/KdF/PJ6WagjNTS8qxCgyHTc7nkQFeefmcytt18uy6dtIis3kDt0tXoyMVfLEnnnkfyyO1hohp1fjRdqb8PHOFClWgOlDadCWlr2LDbZsJgE9ANx9dvg7D1vTgfdILEtDOQGF8IIYQ4M4MGTmbW9Nvp22d0xmMsK8m6Vw5x7BXNVf+UpM9od8Nzh7daPP+TGnYvT7TH5XYovUa6uO+5fPzZCsNMxZtdC02umBtk884+vLRwPFo3n3DmxONElq8jvGItOt75xs1wwdeezCOQYzSMG5yI8UdOcGMcdSiqbBrjJyxYs8tiylA3GhNF/Ta7BuCA+3pwX9NO70KIc+O8FlCefvrpjM/5fD5eeOGFVl9j4cKFzR4bOnQouqUORsBXv/pVvvrVr7b6+kIIIcT5EsxXzLw7wNgrvbi8sH9tksWPRinaZTNk8FRmTr+dPr1GZDzfshJs3Pwuy1e+QGVVqi/Ahg+hywCT/F4m4QqHw1ut9no7Hc6XH84lu2vTBKH+7wP6FjNv8iYWrJzQ8Jy2bSLrNhNetBKntvOulBg01U2fMe6Mzyul6J0PB0t1Q0edqn0Wu1+KcnBBjDf7urjsywEmXu/D7VMc222x8JEIK56J4khbk4uCxPhCCCFEZjndDWZ/MsDIeR4+a+SyaHmUBx+rQh00GDl8DjOn30a3rgMznp9IRFm74U1WrX6JmtoyANa9DT2GusjuZlB93KFoV+eM8Q0TvvpYHr4s1STGd9UVAUYPPURR2U5WbDqRQ+lkkvCqDYSXrkZHO++WsWOv8jasLk9Ha02fAtWkgLJ9e4yXXqpm0Ye1xMuWouN/B2sxYIE5LLXyxHVV2pUpQlxIOlQPFCGEEEKk9J/g5utP5+ELqobVEb1HuZn7uSBHXr8KY88dGc+NxyOsXf8Gq9a8RG24otnzJfttSvZ37jvVA6e4m8zSO5mhYPKo3Xy4dgzJhEF04zbCH67Aruqc2yA0NnSWB8fWTZLSk3lcCp9Ls/v9BLtfjFK66cT+cEW7LJ78p2qe/CcZSyGEEEJ0LiPmebj3r3mY7tTEnQHAxDFevn1PHkUv3oZxOPNM/UikilVrX2HNuteIxWqbPV+0y6Jo1zm8+AvA2Ku85LVQBACYNmYnKzYNR1s2kbWbCS9eiROWVdDDZnuwrROrxE+mlCLoBcPW7FsQZ89LUX6580SuqcxRqMDP2+tyhWhXUkARQgghOhhfluJrf8/DG1Bpl0/3/tjblD43hsThpqtPwuFKVq15mTXrXyce77wrJNpi0BQPjp2apZaJ12ORXb6RnY9twi5rXojqbJQJ/a70MfRWf2pFfisW/6CK/cs6YWMdIYQQQog0cnsYTYon9VwuhdbQ65bnKfn7aKzSPk3Oq64uYfmqF9iw6W2Syc637e6pGDTVg5UEV4Z5UkpBTlYE9/51HHlpHU51TfteYAdkeGDgx/z0u9JHmlaazbx3bzll+5xzf2FCdCBSQBFCCCE6mGm3+Qlkqyb9JRrTjkFo0tuU1xVQKquOs3zl82zc/B6WJUlVazwD++Gf2gfUXqDl7YBqFizFLuucWyDUqy+cjPxEgGAPk4gJRivL8MMVDgdXS/FECCGEEKLe7E8FMFykXcWrFGhHERz/HlXvfQ6A0rJDLFvxHFu2LcRxOnc82hbe4YPxjS1AGQdpLcavfmcxTnXnLgLUF06G3+XHX2ASdhRGhvwTwHE0pQdsKZ6ITkkKKEIIIUQHM+ay7BafV4aDt+92SkoPsGzFP9i6fRGONI9olbtXd0KXz8Y7oC+HasswjD0tHh+ucCja0XmT1ZMLJ/UqIxCOafze9IUUx9EsfCSCLfUTIYQQQogG4+ZnYboy39hXpoOv/xa2F+1i6Yp/sHPXclorBAjw9O9D6PLZeHr34GDFEWaZBzIe6ziasoM2Vcc6bxHg5MJJvZJqTTypcbvSx/hKwYI/yS4HonOSAooQQgjRQfTpPYrpU25mwIBVoDa1eKzWFg8+/DUkqWqdWZhP1mWz8I0Y0vBYUUkBh44V0LNrOabRfAwdR7Pw4QhWoj2vtH15A4opt/oYfbkX06M4tCnJkiciVBQ5aQsnjW0+7DCul4HXq1GAMlTDnslb34vz5v3N9+UWQgghhOiMBg6YxPSpN9Ol6yvAwRaPjcWreeSxb7fPhV3gXD26knX5bLyD+jc8tudQD8qrQuRkhdPG+IaheO+PF3cRwJ+jmH6Hn+FzPBimYu/qBMuejFJb5TDwurrCSWHzGF8Dmw45jOtt4DJP9Dusj/GXPx1lyePRdn43QnQMUkARQgghziOlDIYPm8n0KbfQq+cwAJJFFfgGbAaVvjhiW5p9a5JI8aRlRnYWoXkz8I8biTKab+j73Ltz+PS175CfH0E7qSShPkHY8Hrsoi4C9Bzu4pvP5pFVaKB1KpkcPsfDlV8PsmmHTUULW3SVbk2y7dEwz+21mPXxAFNv9RHINSjeZ7Ho0Qgb3oijO++kPiGEEEIITNPF6JHzmDblZrp26Q9A4shO3F0Oo4z0gZKd1GxfcnHf3D8bzPxcQpfOwj96WLPntDZ46o15fOq6d8gKJdBoDEORTGrcbsWiRyMsfuziLQIMnOLma0/k4Q0pFICCEXM9XPudEBt2WdS00OTk2JoE2x4L83yJw5xPBZh0ow9vUHFkW5JFf4uyZYFsFS06LymgCCGEEOeBx+Nn/NgrmTr5RnJzujV5LrJ1NlnTX0GrJOnuY5suxQcPSXKVifL7CM2ZSmDKeJQrfahjV9Vw+OVl/MdP9jPlFh9Tb/UTylcU77NZ8niEbR8k0Bdpfcrth288k0cwz0Ap1fAZM10KrTXjRpqs/8ih6qTcsmxbkq1/C3N87Ym9ud59IMy7D8hnUQghhBACwOcLMWn8tUyedD1Zofwmz4U3zSM4/j20Jn2M71Z8+Eikna70wmNkhQjNnY5/wui0k6MArLIK9vxjCT/58SFm3Omnz01uskIGm7cnKHosye7lF+/y8qxCg68/mYcn0LSXiTJBGZqJI12s3usQOWkI6gsnZVtPbF38+q9ref3XF+9kMiFOlRRQhBBCiHaUlVXAlIk3MHH81fh8obTHONFsjr/4Wbre/BccHExX0+XT7z4QZsMbnXcGkGHC2Ku8DJ7uQWvYsyLB5nfiaMNNYMZEgjMnY3i9ac91IlFqF68ksnoj2Km+MUufiLL0iYt3JtrJptzsJ7tLqnhyMqUUjtb0KTCoOpyaHZmucCKEEEIIIU7Iy+3O1Mk3MW7MFXg8vrTH2JXdOf7anXT72NPYtm6I8etXR7zw02r2ruq88ZbLA+Ov8zFgohvbgu0fxtnxYQK8PoKzpxCcOgHlzjA5qrqW2g+XE92wFZxUDPvBXyI8+JeahmPuIatd3sf5MusT/lTxxEwf42ut6Z2v2HUsNUssXeFECJGeFFCEEEKIdtCt60CmT7mZkSMuwTQz//qtrDzGyjUvs3Hzu+T9LsG8zwcYd7UP0wMfrUvy4V9TqyM6q57DXXz1iTzye5lYyVTwf/mXg1QUG/z9jbmUxXqkPc9JJImsWEt42Rp0vPOOH8DIS70ZZz5CqmlkQUhL4UQIIYQQohW9e41g2pSbGT50BqqF7ZFKyw6xcvWLbN76AT1+7zDvC0FGzvMQMzSLlkf5/SOVjFrpbscr71gGTnZzz19zySo0sRIaFMy/N8jxQy6eevdyqhMFac9zojHCS1YRXrUBrM5dCBg930sLH8FUjJ8Fx16LS+FEiFMkBRQhhBDiHBo0cBLTp9zCgP7jWzzuyNGdrFj1Ajt2LUPXNZA4vgee+dcanvnXmhbP7SxCBYr7nsvHn5O68+9yn6gAZBdqPnvnMh545jqisROz/rRtE1m7ifCilThh2RLBm6coGO7KWDxpoOH9b1S2xyUJIYQQQlxQlDIYNmQ606beQp9eI1o89qMDG1mx6kX27FtDff/CQ5vh8fuqAHiQE3H+KDpnAaWgr8k3ns7D7auL8T0nAtXCXjafuW0Jf3zmOiz7xC1MnUwSXrEuNTkq1nlX5tcLdDPI6WemXWHemBXWLP5eVTtdlRAXDymgCCGEEKep/wQ3l90TYPTlXgxT8dH6BB/8JcKWd2xGj7yU6VNvpkthv4zna+2wa/dKVqx6gUNHtrXjlV+YZn0iQCA3/bJ009D4vXEmDN/Hsg0j0VoT27Sd2oXLsSslSTDcMOQWPyM+EcDObmFqGuDYmoObZNWJEEIIITqnobM8XH5PgKEzPaBS28W+/+cIe5YZjBtzBdMm30heXvpVzwCOY7Nt+yJWrH6RY8f3tuOVX5gu+1IAlzdzjJ+XHWbU4INs3DkQbdtE122mdtFKnFrpw2f6YPhdAYbdGSBqprbiNTIUUWxLs29l516JL8TpkgKKEEIIcRqm3e7jU/fnoO1Uw0eAQVM9DJ3ppWLlbKLLPwukD16TyRgbNy9g1ZqXKK842n4XfYGbdIMPZWSeVaUUjB78Ee8/46X2/aVYxaXteHUdV89ZHsbdEyLUywSgqFLTv4sCrdPOUjNMxQd/kdU6QgghhOh8Lr8nwK0/yW7oPQgw/BIvoy7zUbbwOuIbbsl4bjweYd3Gt1i95hWqa0ra65IveJNu9DWMdTqOAyMHHmTFcwlqP1iGXVHZfhfXUSnoe7mXsV8K4i9MxfhHKjS98jKPo+lSfPCwxPhCnA4poAghhBCnKL+3ySd/k4NSYDTaRqo+8M+btgRdPI7Y3olNzqsNV7Bm3WusXf8G0Wh1u17zhc7VoxuB7j6UyrxEXylwxSqpfPrldryyjit7gMn4r4ToNsnT5PGEBduPaEb2UqkGpnWz/er/vvTvEVa/EDsflyyEEEIIcd70Gevi1p9kAzS5oV//94J5r1NyfCzJosFNzquqLmbVmpdZv/FtEolo+13wRcDdrzfebAdwMh5jGGCUHaHqhXXtd2EdWP4IF+O/FqJgRNMt3yJx2H1MM7SHwrF1w4qe+mLgW7+rZediWYEixOmQAooQQghximZ/yg+QcY9Z7RgEx7/XUEApKT3Y0DTStmVrpFNhFuaTdeksfCOHUFLzITl5RzENnfZY29Ic2Sx7IHuyFaM+G2TQx3yoNFshAKz6R5S3V8SZc6efMVd6cXkUBzcmWfhIhDUvSfFECCGEEJ3P3M8EsJO6YXX5ybRtEBy3gMq6AsrRot2sXP0i23cuwXHs9rzUC56rR1eyLpuNd3B/SqveokdhOUaGXWZTMb4UpvyFBmO+FKTffF/a5x1bs/DhCG9tTzL3UwFGzPWiFOxdneCDhyJsflfyJCFOlxRQhBBCiFPg8fgZe0kPTFfmxu7KcHB338/+jzawYvWL7N23lvqmkaJtzJxsQvNm4Bs7AlWXTa3ZOoRh/Y9kPselWPRY512WrkwYdKOfUZ8O4MlKn4GWbkmy4YFaKnZaAOxZJLPQhBBCCCH8vixGXVKA6c58o16ZDp4ee9m1J9XD8OChLe14hReH1OSomfhGDm14bM3Wodx46YrM57gUSx7vvDG+4YFhdwQYflcAlz99ce/YqgQb/lRLzYFUIW/H+xLjC3E2SQFFCCGEaIOC/N5Mnvgxxo6+nPzcP6H1VjIsQAEgEUvw5DM/bL8LvEgYwQDBOdMITB6LMs0mz+091IN12wcyYfg+tKZhlprjaAxDsfTJCNsXXtzJgj9bMe02P86IQKqHSVkYw4SukzyMuzdIdr/0oV2k2GbTn8Mc+kBmngkhhBBC1OvWdSBTJl3PqBFzCfh+DmSerANQWVHGs8//tH0u7iJi5GQRmjsD/7iRDZOj6m3a1Z8RAw4ypF+qN2R9jlW/DdWb99dyeKvV3pfcrkIFBtPv8NFrhJtEVLPxrRjbFyboNdfL2C8HCXYz055Xc8hiwx/DHJPm8EKcU1JAEUIIITJQymDwwMlMmXQ9Awec6GcS/2gM3n5bM55nJzWb3pFtkE6F8noJzppMYNpEDI877TFONM7T/y/OruG1zP+Sj8K6YkHZQZsFfwqz+LGLe2n/6PlevvhgLu5Gq/Z1zxx+sc1hy3FNLM3ucFZMs/OZCDufiWBL7UQIIYQQAsMwGT50JlMmXU+f3qMaHo/tG4crvwhlpO/HYVuaDW913pUQpyM1OWoqgUljUa70tyCt6ggP3Zdk5pRaLv2Cn9zuqWLBsd0W7/w+zKrnL+68atrtPj7xPzkYJmgNaJjz6QAVFQ7bijWJNLvDJWodtj0eYc9LUfTFXVsSokOQAooQQghxEp83xLixVzB54sfIy+3e7PnI9llkTX8VPBHUSf04tKNRBrz/ULi9LveCptwuAlMnEJw1BcOfYT/fRILIinWEl61BxxMsWgqLHq4lu2tq9lp1ceamkxeLXiNd3PNILsoEZTRd+hTMUoz3KVbtdXAafRwPLoix6aEw0ZKLf3yEEEIIIVoTDOQyYfzVTBx/DdlZhc2ej2yeR2jCu2h0sxjfsTWODR/+VQoobaG8XoIzJxGYPhHD40l7jBONEV6yivCqDWBZvLsS3nsgFeM7FtSUXvwx7NBZHj59fw6o5v01c3IVY32KNftPjIO2NfveiLHlr2ESVbJFtBDtRQooQgghRJ0uhf2YMukGxoyah9ud/mY+gB31sva3lzP6q6/iy0oFrspQ2Fbq749+s4qDG2UqEIBWMOE6L9Pu8JPT1aDssMPypyJs+9DCP3EMwTnTMLNC6c+1LCJrNhFevBIn0nx1SWconNSbf28QFBhG833jDKXwe6BLtuJ4laZ8R5INf6ilbJt8BoUQQgghevYYxpSJH2PE8Dm4XOlXOgMkKrNZ83+XMO4rC3B5UpOiALQDVgL+/MUKyg5Ks3gAlxcm3eBj8s1+QnmK43ttlj4ZZfdqh+C0tk6OWouON10irR2oOtZ5YvyrvhnEcVJ9Xk5mKEWWH/KCUBGG4vUJNjxQS9U++QwK0d6kgCKEEKJT0/rEEv5+fce2eGwkUsX6jW+zbsMbVFWX4PurYvrtfkZe5sF0KfavS7L0iQgVRztP0N8SbRro8T350qV+bEtjuhS9R2smfszHzj1deO79edhO8/18teMQ3biN2oXLcaprzsOVdzzjr/WmTazqaa3J88Krv6rmwLtxkAlpQgghhOjETNPFyOFzmDzxenr1HNbisTU1Zazb8CbrNr5FOFxB8GHFzLsDDJ3lQSnYvTzB0iej1JZJjA+Q3cXgW8/l02Ooq6FPSe/Rmqm3+tmwpTevLp2F1kaz8xomRy1ZhROWlTxuP4y4xNviMY7W5Bjw+o+rOLJE+pwIcb5IAUUIIUSnZFs5hMuvJ1x2E7fd3LXFY4uO7WHNulfZun0RlnUicI3VaBY+EmHhI5IApKOHd4Xs1Myz+pv/9X8OGVTC5ZENvLNsUpNzolt3UvvBMuyyiva92A7M9IHbl7l4Uq98c5ID70ijEyGEEEJ0XlmhAiZOuIYJ464mFMxr8dhDh7eyeu2r7Ni1DMc5Mas/XK559w9h3v2DbMmbzhf/nEvXgalJUIbZNMYfN+owZbXbWbrhRG+ZhslRHy7HqZLJUfUCBc2LTCfTDhQtjUvxRIjzTAooQgghLjq9R7uY/YkAXQaaRCod1r4SY9PbcRwLuncbzJRJ11O0fQ7ozDN+bNtix86lrF73KoePbG/Hq784aK8LuoZApb/xbyiYNHIPH64ZQzzhIb57PzUfLMUqKm7nK+3Yes70MOHrIcJJCBm62d7I9RwbDm9J00VeCCGEEOIiMXCymxl3+cnvY1JT6rDq+SjbP0igNfTpPYopk65n+NCZGEbzFc71ksk4W7d/yOq1r3K8eF87Xv3Foc8YF4Onp+9pAqnQf/q4HSzfNALHMYht3UXNB0tlctRJ+l3hZew9IeJJjcfVvP9JPaXgiGzLK8R5JwUUIYQQF5Vbf5LF5fcEG7aMsi3NpBv8lOzxcuiJL9A9t27FQ4YtjmprK1i38U3WbXiT2try9rvwi4zO9WcsntRzu2y6qZ2s/+s2kgePtNOVXRgCXQ3Gfz1Er1mpIt+Rcs2wHpnHUxmw5InmfWKEEEIIIS50hgmfuj+Habf5sZMa052K8afe4ufoxiDFL3yVrnnDW3yNqqpi1qx/nQ0b3yYak1UQp2v4HC+Onfp/kknQHye3dju7nlgvk6NOktXXZOK3QnQdnypCHanQDOiSYYKUo7GTsPIfEuMLcb5JAUUIIcRF45LP+Ln8niDQfMuowoFJsr+wgLLnJ6U99/CR7axZ9xrbdizBcWSWz5nwDO7Pooq+XMKuVo8Nv/chyYOyJL2eMmHIrX5GfTqIy38imSqq1BSEFIVZGjSo+mbyjgZD8Y9/q5GmpkIIIYS4KF37nRBTb6nbFtbdNMbvMSZKrvdDKt9KX0D56MBGVq99lV17VqK19DA5E96RQwjN7IZWe2mt4V7N2wuwiiSnqmd4YMQnAgy/M4DhPhHjHyrT5AcVOYHUeNavRLEtjTLgsW9VEamU5oZCnG9SQBFCCHFRUAZc+Y0Q2tEnbi43ed7B22cn7i4HSJb0q3swQSD3ff7v/jcpOranna/44uMZ3J/Q3Bl4evdgy+GqVgsotqU5uEkSq3oFo1xMui+LnIHpw7P3X4nhO2Yz8zYfXfrXHVMV5fdfj7HtfSlCCSGEEOLi4/bDpV8KpI3vIRXj+4etpmbpbdg1BQAkEjE2b13A6nWvUVp6sD0v96LkHTGE0NwZuLsVcjR8HNNoOW+K1Toc2y0xfr1uU9xM/GYWoZ7Nl+04Gl7/e5TciMOsO/zk9jDRjmb7wjhv/z7M3pWyRa8QHYEUUIQQQlwU+o7IIb9XC2vJAe0YePtvoWxvgN5DXySY/xqmq5KiY1ntdJUXp8aFk3qllTnsP9KVvj1KMI3ms6ZsS7P25Rg1pTIT0JOtGPPFIAOv86d9PlbhsOGBWg69n2oQ//ava/nj07WplSiOZtv78vkVQgghxMVpxIwC/FktN9tWSuPtu43DSwaxZt3rbNz8LvG4NIA/U40LJ/UOHO1KSXk2+bk1aWN8x9YseTxKUnadwldgMP4rQfpc6kv7fPiYzfr/q6VoRWoi1Ou/rMUbVFiJ1NZdQoiOQwooQgghLmh9eo9i0vhrGDOrP/CzFo/VGrbv/oDH/vQn/vhEVbtc38XMM6g/oXlNCyeNvfT+TL5w09uEglEUqZVB2kklWkW7LJ75YXV7Xm6buLyQVagYMdfHuKu9dB/sIquLgeFSRCodDmxI8sZvazl0llbO9LvSy7h7Qnhzm98Y0I5m76sxtjwSJlnbNEFVtizlF0IIIcTFSjFwwAQmjruGMZdnAfe3eLTWsGbDS7zw5520trWUaF26wskJimffmcNnrn+HgC/Z0AvFsVNbTu1ZmeTV/+p4PWb8fkV+ocGY+T7GXOGh60AXWYUGyoDaCs3elQnevL+WY7vOwpa4Bgy+wcfozwdxB5vH+I6l2flslO1PhrFjTZ+Lh+XzK0RHJAUUIYQQFxyfN8SY0Zcxcfw1dCnsm3qwNo6T8GJ44hnPM0yHte/tk/2Pz1BrhROAPHc5c0OLyFq3lZcWd2Hm3X6yCg0qjtosfSLKsqeiJKLnP0FQCvJ7m/QYajL9Tj/jrvFhuhRa60bHpLaMcHczGHe1j3FX+9i3JsFvbyk/7dlhJzeQPFnF7iTr7q+lfIdsfyCEEEKIziEYyGXcmCuYMO4q8vJScaZdVo12DJSROX5XCtYs2IMUT85MqnAyHXe3LhmPSR4vZc+zy/mPnx/hks8EmHq7j0COQekBi8WPRln5XLRDrJ4wzFSMf8uoIJ+7O4erLwtgGOlj/DyfZsrNfqbc7GfzezH++KnK0/66eUNdTLwvRP4wd9rnSzYnWffbGqoPSO9CIS4kUkARQghxwejVcziTxl/DiOFzcLu9TZ7TlpfI5rkEJ7yLyrBlVNUxh60fZC6wiJa1pXBilVcSXrSC//fPqzCVBhve/UOYd//Q8bZRuOQzfuZ/NUhh31Q4pLVuSKTq/2ys8WMDJrn5tw8K+Y+5pTgZ8h+3D0bM9RLKNyg7ZLNraaKhgeSwO5o2kKyXjDhs/WuEPS9FkTqfEEIIIS5+iv79xjJx/DUMGzId02x649mJZhPdNRn/0DVpiyi2pTm8JcnBjTLp5HS1tXBS++Fy4tt3AxAHXv91La//uradrrJtDBMuvzfIZV8KkNMttTzmVGL8MfN9fPeVfH59Q3nGr+ENKkbO8+DPNji+12LvqiSuoGL054IMvtGXtl9PvNph04NhPno7JnU+IS5AUkARQgjRoXk9AUaPupSJ46+hW9cBLR5bseQ6rNx15AwoRaMx6oJX29IkopoHv1AhN6Vb0GOoi2C+ovywQ/nhE1UBz6B+qR4nfXpmPLe+cBLdtB20ThVPOpjuQ0zmfi7AmCt8BPIUvqDRsKUYpE+oMlFK0XWgyaVfCrDgT5Fmz8/7QoDr/yWEP/vEsv2qEpsdhx0i3vT7eB9eFGfDH2qJSl8YIYQQQlzkAv5sxo6Zz8RxV5Of36vFY0vfvZW87O0Eu9WgjBM3w21LE65weOSrsjVvJkpBzxEu/NmKko9sqo6diDNPp3DSEfUZ62Le5wIMv8RLIFfh8TeN6U8lxgcYNMXDxBu8rHul6cQ7peDq+4Jc+fUg3sCJeL7sqM2uEoeYO32Mv//NKJv+HCZR3fHyIyFE20gB5TzRaCpxWLITvC4Y2PV8X9HFRaOpQrN0J7hd0D/d1p3ijFThsHQnmAb0k/E962pwWLYrFaT1zj/fV3N+9Og+hEkTrmXk8EvweNI33qtXVnaYdRvfYtOWBSR/W82cTwWY85kAhX1NYrWaVc9Hef/PkYaiQC0Oy3en9kvumdce76ZjGz3fy03/FqJno6XmO5fGefmhENW9ZrWtcLJ5BziphCyMw8o9YNnQPfdcX33Leo1wESow6D7U5LZ/zwbAdJ1IotLNEGsrpRTX3BdqVkC57MuBhq/VWHahwdRCg40HHSoaLcgJF9ms+79ajq1MtOnrRnFYtReSFhRmpX7nKU7/fYimYmjW7j/fVyEuVE5djB9H40KRjYFXvj/PmvocKobGrBtfn4zvWVOfQ0VxMFFkofDTcvNu0XYaTXXd+Kq68Q10wvHt22c0E8dfw/Chs3C50m9zVO948T7WbXiLLVs/QP0uyiWfDTD7k35ye5iEKx2WPx1l4V8iVJekYtBqHCJoFBBEEeqE49vY5Jt9XP8vIbr0T936cxzN1gVxXn60gPiQmadcOKnFobZu+UQQRdZ5Gl+loPcYF4Fsg34T3Nz4/RCODWaa1d2n66Z/DTUroNzwgxBXfj3YrCCT38NganeDdR851DbqaVL1kcW6+2sp3dy2Pc3CdeOrgUDd7zhx9hw/XszWHTvO92WIC5TSjTcAFG1WXV1NTk4OnyOE5xSC9jiaXSTZSpIqTlT+XQb0c1yMwk13TLkRcpqSaHbXjW95o/E1FPTVqfHtJeN72iw0e7DYSoLSRuOrgN6YjMJDXxnf02aj2YfFVpIcp+meQD0xGYWb/rgwLvDxNUwwXGCl2UnL4/EzesRcJoy/hh7dB7f4OradZMeuZazb8BYHDm5q9es6aD6qG9+jJ41vt7rxHYgL8wIf31M18XofX/hTDhoaVuxAqhZi2SZ/felKjpc1rzKdXDjRaA5is5UEh04a30IMRuFhMC5c7TS+oy7zcMuPs+kx9MRckcbL98+mbw04RrIuWfIGFb/c1KXJrLTGtNbUxmDNfudEA8knwtit7Cyn0RzBZitJDmA1Wfmfh8Eo3AzBfUoxiThBozmGzTYs9isLuy48rqqqIju7eTFMXLxON8aP4rCDJNtINtxcAjCBQbgYjYcumOfgis+OBznR8Pcess7jlaQXR7OzLsavbhzjAwOpz6E67tzAjj6+ibocagtJKk+K8fvXjW/PDhzjd/TxTaLZWze+ZTRdZdq3LofqcxGMr+ECwwArzXwQny/E2NHzmTj+agoL+rT49ZLJGNt2LGbdhjc5cnRnq9dno9lbl6MWnzS+vepi/H4dOIc6V5/fSz4b4K5fZKMd3WTCkG0r4kk3f3n+aiprQs3OSxbXFU62pQondqMcquikGL973fgOaMccavJNPm74QahhC95zxbE1X+99vOHfOd0Nfr6mC4aZ/n06WlNeC5sPOVgxzbbHw+x6LopuZWc5p1EOdfik8e1Sl0MNascc6lQ1/vzqcOX5u5AMtNa8u+ADHnjoL7z6xls4dRP+JMYXp6rjRpkXoVJs3iRKDE0vV4BxniAB5cJGU2LF2JuoZa+OMhw3c/B22F/wHVUlDm8QoRZNf1eQGZ4csg0XDnDMirI5UcXrTpSBuLgUX4f9BdRR1eDwBlEqccgzXAx3BfCr1A3CGsfmuBXjLR2lDyZX4Mct43tKIji8SZRSHHINF8PMIAEjdaMl7Ngcs+K8q2N0x+Qq/BfkbMuhMz1c8fUgI+d6UIbi+F6LD/4SYcnjEboUDGTi+GsYPXIeXm+gxdepqChi3ca32Lj5XSKRti3Xj6N5iyjHsMlWJkNdQYJ14xvVDsesGO87MTZhcA3+TjMb0OWBu36ZChyNk1ZiGAa4cLhy5loef3V+w+NWeSXhxStTW3XVBaBJNO8S5RA2IWUy2BUkq258Y3Xj+6ETYyMG1+I/J7PVXF7oOTz1k72wv8nnHshtdsy5KJ4A+EKKZCx1w3Tc1d5m2wacfA1ZfojtT/Lhf7StgaSN5gNi7MUiqAwGugJkGakbATFtc9yKs8SJs4EE1+InrwPfpO2IHDRLiLOdJAP79eNnX/oS48eN45rrrz/flyYuEEexeJsYNpo+riCTPUF8ysRCc9yKsjdRyy4dYTwepuLpsDdJO6qSuhwqjmaQK8Q8TzZBw42NwxErypZ4JS/rKCNxM0tyqFNWgc3rRImgyTfcjHQF8CkTB021Y3HMirFfRxmMi3n4Ot1EkzNVXZdDVeGQb7gZ4Qrga8ihLI5Zcd7UUfpiMv8CzaHGXOHliq8GGTzdA8DhrUkWPBhm5T9i9O41gonjr2Hk8Dm4XJ4WX6ek9ADrNrzJ5i0fEIu3ra9GuG58y+tyqMY5am1djvqOjtGjLofqLCsC/TmKW3+SKsacvNraNDVeleTSqRt5ccGshsdPLpxAalXuW0Q5jk22cjXJoSKOzTE7zgInRpe6HOpcrFjzBhTdh7pwHE3/CW7u/mVOky14zxV10luZfGPLOyIYSlEQ0pSvj7P8f2qJHGt9S95EXQ51GJssZTLEFSTUKEc9bsVY2CiH6uwrqk5VNBrl01+8l+deepnRo0bx6//6L0aOGMFV1113vi9NXICkgNJOKrB5lShBw8VlgS4EjKZDn2d6GOLJYn8yzNpYOQ6aefgkwWqjGhxeJYLXcPHxQE9yzabBWaHpZZQnhz3JWhZEj7OAGFfgkwSrjSI4vEIEC8UEbzbBkz6/QcNFd5eXcjvBzkQtbxHlWvySYLVRHM1rRAmjGefNJivN+HZ1eamyk+xI1PIGEa4ncEElWDPv9vOJ/8nGcU4E8V0GmNz582yu+sREogu+BzpzQOg4Njt3L2fdhjfZ/9FGTqXzXhLN60SoRDPak0XuSY0pg0Ch6aHGsdger+FVotxEoFMkWKPnpxqcZ2IYmgG9isnNqqX0gNWscAKpm/tv1xWnRnpC5J/08zcIFJgeIo7NtngNrxDhZgJnrUhluODa74SY9/kAgZzUa2pHgzp3BZOT2Y1mluX2NtE6tbVAS3Y8HGlT8cRB8x4xDmIxzB2k0PQ0eV8BTPJNDzHHZluihld0lFsInLctFS40Gs1i4uw2HP73f37Dpz/5SQzDoLqmpvWThQCOY/MGUQpMLzP8hXiNpgXMfNPDME82uxI1bIhXAjAN73m40gtTOTavESXP9HBNoGezGLSL6WOcJ5etiWoWxYrRwBy8kkO1UTUOrxDFVAaTPCF8J31+Q4aLHqaXEjvB7mQYhxjzJUdts3BdDuUoxURPTsPkqHpBw0U300u5k2RXopZ3iHL1BZZDXfn1IDf9MAvbOhGb9xzu4jO/y+W6T00gsfRr0ML7sawE23csYd2GNzl0ZNspfe0YmlfrJqiO92YTSpNDdXN5qTwph+oMEykn3+jDbGF3NNPQjBx4kDcWT6H2cHWzwgmcyKGq0IzxZJFzcg5luOji8lLtWOyI1/AaUW4kcNZWQ7v9cMP3s5j9SX/Dyu76DXTOZAvetjp5r568vmarGahSii1/CrepeGLXFadKsBnlCZGXJocqND2EHYvt8dqGHEq2VWwb27a589Of470PPuTRRx7hxuuvRyklMb44bVJAaQcazfvE8Bkmc4Pd8Jxcyq6jlGKgJ4SJYmWsjH5YDKTlPUFFyiJimMrkpmDvZsWpekophniycCnFG5EidpJkBC3PghEpS4mTAMZ6s5olVo3lmx5GerLYkqhhMwnGyw2CNllFnBo0Y73ZzRKrxnJMN6O8WWyOV7OOxAVzAya3h8Hd/5UNqmnvifoVD7mj9qCOLyKyeV6zcyurjrN+49ts3PQOteGK0/r660lQhsOYNMWpxrIMF6O92WyKV7OSOJfQ8iyjC55p0m16bxwnjNFKHO7auJDSJ/c0KZzU21K3JdqoNMWpxgKGyWhvFpvi1SwlzhX4z/QdoBR86c+5jLnK22QFTXskVfXClTaRylTBpv/VPvrf4m+2miedyqLWiycAu7D4CIsRnhAFZubfWT7DZIw3m42xaj4kxsdoeSWXSPkIix0k+dP//YG777zzfF+OuMCkCpypm/tzAl0xM1RODaUY7s1GARvilfTFpIekYa2qz6GyDDc3BHu3mEON9uZgKng/WkxfXPSX8W2ThcTqxi8Ldwvj29XlxVCKHYladmMxVHLUNllCnCQwzpuNt4XxLTA9jPBksTVRw1aSjL1ActReI13c9MPUKocmMX7dFkeFU9ZTfmw9sb0Tm52b6l/4Jps2LyAaO70bmiuIE6nLofwt5FC5jXKo9SSYcoHkUKdLuV10n94TR0cwWrjlb5oaZ/EblL21L+3za4hTUZdDnVycaizbcDWM7yrizD4LOZTLA994Kp+Bk91Ntsxqr8lRAGUHU7G6MmDwzX56zve1mjM5tm7ox9OaTSQ4XpdDnVycaixouBjtzWJjvJplxLn8LORQncFDf32U1996h2f//neumD+/9ROEaIVElu2gBIdSHOZ4CzIG/o318wTZm6xhq52UAkobVOJwGJv5vm4ZiyeNDXCH6O8KsNWKMRy3zKBqRRiH/VgMcAdaLJ7UyzHddDE8bHVSwb+s8mlZfV+kni5/i8WTeqG6mWrb7QST8FwQM6hmfTyAamk1gFYExy1oKKA4js3uvatZt+FN9u1fh9ZtC0LTsdFsI0l309ti8aRewDDp6fKxy4oyDe9FuQpFedz4J40lOGMSelAxSq1o9Zzy1fvSFk80mi0kKDQ8LRZP6vkMk95uP/uTEcI4BE9xBlV+b5MZd/np0t8kUulQUWQz7pqzW+hqmNnWxgRtwxtxcgaZTPxWFoWj3FTZYNka00j/Go6t2b8uSclHrRdQNJrNJMg33C0WT+q5lUFft59dyTAV2O2+lZcyUquapt/hJ7e7QfkRm+XPRNn+QaLZLL6OYpthM2X8JCmeiNNyEJtaNNN9+RmLJ40N9WSxL1HLVp2UAkobHMOmDIcbfIVtyqFGeHLYEq9iq5OQAkoblGNThM0wVzBj8aSxQtNDnuFii5OQAkob1OJwAIuB7kDG4kljuaabQsPNVifBmAskR53z6QC2pZsUTxrTjkFw3PsNBZSG/oXr3+TAoc1n9LVjaPaQpLfL32LxpF5WoxxqIp4LapVPWym/j8DU8QSnTsDusR9DbWz1nMo1H6V93EKzgyTdXb4Wiyf1goaLHi4fu6wYU/Ge8iqUboNNpt/hJ6+nSU2ZQyLiMGiq+6wWTE41xl/+TJSCUS4mfiuL3EEuSqMwlMzrqWxLs/GtONGq1oNeB81WknQxPS0WT+r5DJPeLh/7rCgzcdp9FYrphvHX+Jhyq4+sAoOS/TZL/x5h9/Jku15HW2mt+cODD3HdtddK8UScNRJZtoOtJAgqk26utt/kGezJYkW07LzcALnQbCOBD4NB7uYN0DIZ7cnlNesoxTh0k/Ft0U6SGEDXNty8q9fD7WNjPNUEra/8mGnRbpLYQDdX22dCdXf5OGrH2Y/FkA6ewPbuNYJJlwVQxpGMxyhD4yo4SnX1cdZvepcNm96hpqbsrHz9fVjE0XQ/hZ+/3V1eDllRdpNk9AUyA7AtVMBPcNoEAlPGY/hT47HzIw+2Y+Ay0xepHEdzfI/N0R3pux8eqrt5ONDd9vHtano4kIywgySTTmEG4NXfCnL9v4RO1HE0mG7VrDHm6dBa49ip2ZPJuMbja1tS4tiaXYdtrvhjHqpudpyjYc9xzfCeRrOm9Y6d+jrP/6RtMy2LcSjHYaSr7atJCk0P+5MRtpNkZjv9fjNMCOQovvhQLkNnehtupvQdp5l0g5+t78d48POVWPF2uZw2q8ThsJPkx1/64vm+FHGB2lZX4Dx568JMlFIM8oTYFK8keh5ugFxotpEkR7npfQo/A8d4c1kQPU4VDjkyvi3aRhIPqk0F+nrdXT62J2opwaaL5FAt2t6QQ51ajL85UcMRbHp36BxK0b/fWMZdYmG6MsfsynBwdzlIecVR1m94i41b3mtz/8LW7CKJw6nmUF6K7DgfYTGog+dQp8LIChGcMQn/pDEYntT389Y9/bh82oaM5ziWZtfyBDWl6XOAvVgkgO6n8vk1vRyyYuwhycg25lBKwS0/yeLyLwdPbANXH+Ofhdk3WmssC9xuRSyu8XnbljMkYg5lHsVlv8treCxpw/5izaBuzV/DtjTJqObVX7Utxj+ITRjNkFPIUbu6vBywouwgyYR2WkVluCC7q+Irj+bTZ7Qbx9YYpqLvWM3U2/ysfC7KQ9+qSTfP7rxaunwFW7Zt5+c/+/n5vhRxEenIv5UvCPc/VEt2KzH9qH+G7iUhjFOonvdwpZbl3fS1CHfPPJMrvPhd8lPosy+Eqw0ze+r1dQUwFVzxmQhfveIcXtxF4Obfwp71rlMa35Ay8ZmKmTdH+bebz+HFXQS+8GfYstRs08y0egHDJMtlMP6KGL/+ZOwcXt3psa0cIhVXES7/GFa8P9nBB0EfBdVCEOzA8Fl3MXK2zSfO4rX805Ow6h2jTat76nmUQY7LZMjMOH+6p4Pd8T0NlclsllXMZF3VRCzdNFmMJzwsWTeKeVPSzALUGkNBz2gxf3oynPa1//NleP95RZZq+/i6lEGO6aLX+AR/+k6iTefoHtnoEXVbRJz0rXLKxZPGDUrqe6WUhTHDCUg6eAYV0KYmJsCxCpv+H2seBBRVakLxCL16eMB3ItQyInHMXSV8/7tt+77943vw8l8hz2h7km8oRa7pJmtggj/95NzOCtPZXnS/fCgMpsarLtGtn4la/+eoS738brEPY3fJOb2eU/XMcnjm93DVVVed70sRF6gSnFOawAOpGH9DvJJyHHrJDf4WleLQ3519SjOQ+7uCAJRhSwGlFSXY5JruU8pR8+t+H5VKAaVVpdjkGO42rU6rl224cNWd2xELKN1DhcwacxPjx15JXm53fO5foXVZiyFTuDbKA3/+MqfSv7AtSuuabrdldVq9oOHCh0EpDoPO6tWcH2ZBHsGZk/GPG4kym34/VtUGWbN1CJNH7W72/8exNRp47b9rM752KTYBZbRpdU89r2ESUialp7B7wBVfC3L5l1M/t09eyXSqq08aT1yqL8ZsfifGm3uixOOaH/9Tfptfa98xh/5XNd8q62CZ5vjmOGMmuMgqODE2B9Yneep71Rzf07Ytekux8aDatLqnnlsZZBsuStuhWjF0locrvx5kxCUelHGimFW/nZrpTv059RYf39+bx3/ef3pbbZ8ra9dvwOfzMXfOnPN9KeIi0vF+K1+EwnHwneIP//ptecIX/r27c642Bu5TTJCUUrgNRW2sg+4p0oGEY2DoU/v8KqVwKfn8tkU4zmltc2agqO1A46u1Il47mXD5dUSr50CjG/XxfeMIDFuV+WRHo0prMVTbAs5TEUlwWum90uqC//wWxwtZWjGLzdVjcFoYhUPbAlRkOeQN5UTRQCmwHNTOYlRZ+uIJpD6/rtNo1m5gUB1N/5z2ulI35F0GhBPosjD0z29zUaNF9a8RSaSKJ5VR1JEqVDiBAzCrf+q4Vr6O1pqEDTuLmx/nt5IMqy6lIBFF7wdyfOA2IZZE1batYFQvEk8Nw6mOr4mi9hzVVrWhwOtCZ/tgRLfUg40/N+koBb2y0fvLUFbHmaJW/z0eDEi/GHF6LPQpb6VZPyGlY2560bFYaFyn+PPPXXe8jG/rLDjlrUqVUhjI+LZFEk6pOAWp8TVRHWp8DcPkqkGzuXPsdVw2cDpmoxvqsb0T8PTaTabiiG1p1rxck/H5M2HBKRWn6pkKkh11X9E2cvXoSmj2VLwjhrQYI7781zzCk2DO7RrDTO3Ga7oUNaUOj3+7in2rM3/SLDitbc5Sn9/041vYz2TMFV7cPsXhbUl2L09w5deCp/w10nGc1Ncs+cgiHtbsWJRg8WMRSg/YPOav5dimgUDrMbXWmkgCiiLNj6vcY7Huf2so22ZhuGDQFA/+bEXxPotju08tj02iT+vza6Dq1l6dfd6gIrurwajLPNz+02wc58REtUzjpgzFt7+cx/88UEki0XG+ryKRKAG/v1175oiLnxRQ2kFuAKqqT+2HXLyuap8jOX2r8kOwT5/aLyxLO8RtTe7Z+X19UcsNgt3SyoE0tNYkHC2f3zbIDYB9ikGQ1pqkdsjtAONrJboSqbiWcPm12MnuaY+J7p5M1swXMbPKUcZJ71XXrQA4eG5mreT4U0nSyVsptcZWDjkXaH++w9FeLC6fzc7w8BaPGx7azuy8pfT2H4GjoIuNVOHCbULMgtIwqpUEMzcACefUx9fCIf+kn79agR7aFXpm1z0AGAoSFnhOM1ypL5jU/2k5qF0lqONNl9drgLE9wNv6So/6GVhbDzf9LBvaoX9tJX3DVZh1iaMCqDr9SkZOAJIO2PrUkqwkDvmnNim+VdptogcWQPesE8uATqWoZRipb8gWCnLtrT4GKC0tpXv39D+/hGiJB9UQs7dVvC5mvbhbGJ8dHhTRU4zxIzK+beZBkTjFz6+tNQ6nXnjpjLwooqc4vo7WJNEdYnzz8noyfuyVjBs9n1AoL+0xkW2zCE19HcMbaRbjO7bGsWDhI5Fzcn0eTr0QksqhOsb4ng5P/z4EZ0/FO6hfxmO04xDbvIPwsjVYxaU8+3d44z8Nxl3txRdSFO+z2fp+HKeVH63143uqMX4SB89JE7c8fsWn7s9m0g3+1OoXnSrkVJfYBHLPbKVg/ZZSNSUOj3+nim3vN52sZLhg4Qu9CYVa/zpap1bmnBzjJ8MOW/4WYe9LUeq/pR0Ldi8/tYlRjXlRpzW+lnbO+uc3v7fB9f+SxaQbfbg8qdfWOnNvo2bn55mMHeFhzcaOM/swJyeb6poa4vE4Xq9EBOLskALKGbrvS6FWG2Qp4hwhguXLa/M2SAeSYQzg1d8FWSDLz1tUS5yDhIk5dpuanAPsTtaigQ8eDrLuYRnflhwnQSXxUxrfcidJwoHVzwS49xlZ3t+SfSSpJkbYtAi2cQlvtWMRsTVbX/Nz72vt/2PcMFwMHTyV8eOuYtCAiahWfq6VlxWz6l/6M+eHxRT0NbCTGmUACuwk/O1rlax/3QPnoN/IYSwiRKk2rTY16AMIOxbVlsP+hT7uXXjh7I/sGdgvlVQN6JPxGG3bRDdtJ7xsDcdKy1kIQNZJR9mkbv23fge+FJskEcqdZJv3UI85NpW2RfFqL/d+4sQ5n/ptNtMu8Z+YrVn3h3a1Pv8tXfJhW5qqYoc3fl2LN6AoP2KzdUEcKwEnv+eZH/fxycvaXnE4VK6panQ/oGhFnPW/ryVc5NCWcWurahwgTKmdaPMe30ntUGEniWz3cO8nzjxhCOQq/FmKbz2XT143E9NsNM6nOKvrT/f72fhWx/mdG8XBVFH+8fzzfONrXzvflyMuQL0xOZQMM9qb0+aZ5geTETwoCmX7o1b1wmR3opY5vi5tzqF2J2swge6S5raqNybrnQSWdto8viV2HAX0lM9vq3phcsCJE9dOm7fqLXdSc8t7nafxdbm8jBg2k/Fjr6Rf37GtHn/8cAkr/7k/l/1oE9ldjYZtkwwDElHNg5+rpGT/2V9hDtALFzt1jIhjt3mr3irHIoE+b+N7urzDBxOcNQVP7x4Zj9FJi8j6LUSWr8GurG7yXG2Zw9InMyz9zqAXLjaRpEbbZKu2/TytdSwi2qH3STndl/6Sw4i5qZjUaBRHZuWfXkxoW5rifRbv/TGMN2hQ+pHNtoXpi0JXfTPIpHFti4eVUuw55jTZheDg+zE2/ilMrOzsrvrohYvVJKhwkm3uoxZzbKq1zQTa3jclE6VSMX6o0OA7L+QTyDWaFExOdeWGq43FlvYy/9J5WJbFy6+8wh23336+L0dcJCSybAcjcLOBBAeTEQZ6Wr+xorVmb6KWAbgISPGkVcNws5oE25JVTPS2vq+l1prN8Ur6YMreyG0wGDfLiXPMjtPfaNuShyIrRhcM2Ru5Dfrhwo+iyIozuI2z7IusGNmosx78u/3Qf7wbw0wtqw6XN53VVVDQh/Fjr2TsqMsIBnNbfK1kMs6OnUvZsOkdDhxK9dd47w0Ye5WXMfO9uDyKQ5uTLH822uzrnE296r7Pi6xYmwsoRVYcP4oBHehXZKjAYOptPgp6m4QrHNa8FKN4nw1K4R0xmNCsqbh7dst4vpNIEl23mfDytTjVbWtu2BaFmHStG9+2FlCO2XHcwJBGzTu7DDCZcVf6ny+pfXdbvldfH+Q3ntV2ZKvFn79YSfnhlhP3wn4md/0ip80zwGLJVANJgMhxm/V/qOXo0tOfgdaSbAz6YFJkxehqetp0fcfrOrUPP4PmqKYbLvtSkHlfCJDXM/Vz5lRnyJ3McTQHNnakTUnAj8FAbfLQQ3/hq/fei2nK7yxxakbhYZeOcMyK0tPdeoxka83+RC3DcOG+QGdAt6eReNhMmD3JWoZ7sls93tGaLfEqBuHCJ+PbquG4WUuC43aCXm1oZKy15pgVpy8usiSHatVQ3KwkzjErRr82/HyAVIzfDZOCsxzj+0KKvmPdoODgpiSxmqaxd7euA5kw7ipGj5yHz9fy/Yp4PMLW7YvYsOkdjhbtBOD912DSDT6Gz/GiTNi3Osmq56LEas9djD8QF8tQFFkxBnnatq1EkRUjF4MeHShHzetp8L1b8+jR1cWxEgued6g44oBh4B8znOCsKbi6FGQ834nFiKzeSGTlepzw2Vvt0weTLBRFyRjZ3rZNDiqyYgRQ9GuUQw2c4mbUZel/viiz9Ri/nm1plEoVYPasSPDwvVXUtlLU6DPGxXXfbfvEpqqI5khdXlp90GL972opXn9uYteuGBTU5VBtLaAU2XE8wKAzyFE9fsUVXwtyyWf8ZBWaqZX1+jR6SjYSiTps3XlucqHTNXTIYOZfOo+HHnmE22+7TbbyEmdFx7k7dBHLxmAALjbFKig0vWS3cBNPa82GeCVhbTGGDrA/zwXAj8FQ3KyOldPbDNC1lQRgTbycEifOtVyg+/O0MzeKkXjYZMXINdzktnIT+qgVo9KxuPwszIzoDEwUY3Czyo6TZ7tbvQldbMUpdZLMwYs6SzcHDBOu/W6IS78YwJ+VSojtpGb1izFe+o84/bvPZsK4K+nTe1Srr3Xs+D7Wb3yLrds+JBZv2pjQsWDD63E2vN5+y3sVirG4WezEKbbidG1lFn+ZneCYHWcKntPa9/dcuPyeADf9WxZKgWODMuBj/5zFyne8vLl2HkZeC0lVNEZk1XrCK9ejo+emKcZYPLznxDhqxejZys/fYA+Hr90V5MrpXQg5Bts/jLP0ySiTbvThWBojw+yllmJex9ZUlzj8+fMVDJ7mAQV7Vib5aF3rCY8y4FvP5TUsV2+N7WjW7nOwkppd/4iy7Ykw9jnqNVJvLB5e11EOWTH6ulv+vVXrWByyogzBjf80b24ZLvjKo3kMn+tpMu5nknjYlmbjW3EqizpO/5N6o3Hz0uHD/PBHP+IXP/uZJFjilHTBoDsma2MV5JoeAi2sJNVaszpaRhKHURKDtkkuBv0wWRotobvpI7eFGElrzeJoCbXaYrTkUG0SxGAILvYmI+QYrlabGR+0otRqm3ny+W0TD4oRuNlal0O1NpHnSDJKlWMx7SzmUG4f3PTDLGZ9IoDHX9cfKKZZ+vcIb/yXw9ABc5kw7ip6dB/c6mutObKFpze+Rpcdq0kmmwY/VhxW/iPGyn+c46CoERPFaNysrcuhWrsJfdyKU+YkmYvvrOVQZ+rGfw1xxdeCODoV4xsmGN+DRS+HWLhrHkZOTsZz7dowkeVriazdhI6f/ZvXqRzKw1InTr4Vp0srOVRWf5vvfzybyycEcMcVW96LsfzpKJNv9GEndUPT8WZfR2XeEda2NEW7LJ7512oGTvLg2JodixMc2Wa1ev0ev+Jb/8jHaENhQGuNZcOGAw5WXLPtiQi7/hHBOYfzfhSKcXh434lRZMXo0UoOVWknOWrFGI/ntCdgePyKb7+QR58x7oaVQEopzuTbwbY0f32qmprajhfjf/vrX+W6W+/gN//7v3z3vvvO9+WIi4AUUNrJXHy8TIT3w8eZ4s+nh8vfbKl/1LHZHKvkIyvMLLx060AzIzq6mXgpx+Gl8GHm+bsyyJ3VbL/4qGOzJl7OpkQlU/DQRz7+bTYFD6XYbEvUMNAdoKvpbfb5tbTDYSvGYSvGWNwMPoPZz53NODyU4LAjUUt/d4DuprfZ59fSmiIrxgErylBcjDiL4/uZ/8th0o2+JgGm6VZMvTXAxEsHUvbsV9DJzEFdLB5my9aFbNj0DseO7zlr13W2jMBNMQ47k2Hi2qGHy9esKa2tNcftOPuTEfrjYvw52E7sdEy/w8+tPzkx67bxDgVTr4ijeuzjraXNCyh2dS3h5WuIrtuMTpzbWf+DcFOMzaZkhIR26O3yNdsKxNGaSdca/Pf/FqI4scx74GQ3V38zROUyjdKtR+/1+xzXs63U/toP31vJR+stPlrfekLV2Cf+J5uC3m3/XbDnmObIugTrfldLzYFzsyXFyXrjYgoeVltRktqhr9uP+6Tx1VpTaifYmwyTj8GsU9j9XykYfYWXOZ/y03WQC9MF+b3NMyok1K9W0U5qL+mS/TZPf7/qtF/vXOqKySw8/PHBB6mqquJHP/whPXpk3iJDiMYUivn4eEnXx/gFdDW9zb5/wo7FhlgFR60ol+OTFdCnYB5+XibCC+FDXOrvRn9XsNn41joWK2Kl7EzWMAevrIA+BbPxUU6ELfFqBrmDFKZZ7ZjQDoeSUYrsONPw0EtyqDabhpdSnLocKkgX09Msh0rW5VBH6m6ODjhLMb5hwlcey2PoTE+T2MntU8z9bIjpVwyi/MV7wMn8/zMSqWLTlgX866YX2V12AIB7mm39ev5MqMuhtidqGeAO0C1DDnXUinHQijIcN8M6yOf3iq8FueobqdURBtD4x9bcm8Lo1YdYvK55AcUqryS8bDXRDdvAPrex6Ki6GL9xDnXy+Npac/nHXfz4P/JxnFSMr7Vm8HQ3192XRWQrrRYxlKLZRCrb0sQjmke/XsWR7RZ7V55aPvPlv+bgz25b8UQpxY4im8NL46z/Qy2RY+1TDBiMi2LcbKnLoXplyKGK7Tj7khF6YTLpFHJUwwUTrvMx8+N+CvuamG5Fbg+jTUWl1jiORgEHNyb5wc9Lz/j1zoVrr76SH//r9/j3n/2MstJSvvvtb1NQkHnioRCtUbq+G6o4JdXV1eTk5PA5Wu+BUi+G5j2iHMEmoEz6u4MEDBc2mlI7xuFkFJNUIDtMbj6fsiSa94nxERZBZTLMk02O4cbRmmN2jN3JGhSpQHZMB7k5eiGx0HxIjD1YuFF0dXnxKwNNKnEtsVMzXybiYSKeDjOz50Jho1lKnO0kcaHoYnoIGqlW1GHHpsSO4wBjcDP9LK4+GTzdzXdezBxIaK2oXnQ74fVXNXvu4KEtrN/4Ntt3LsWyOk7TuHQ0mpUk2EQCA+hiegkaqTUmEcem2E5goRmBm1l4O8TqE6XgP1Z3Ia+HkXFZte0o7n/8JsLR1GxQq6yC8NLVRDdtP+dJVWMazXoSrCX1c6CL6SFkuFBAVDsUDtKseq8PhtE8idIOaBuUmVoRkomV0Cx8OMKMu/wE8wyspGb9qzHe/r8wR3ecWuEEoM9YF99/K/XZb0ux4GiJw2PfruLggvPzWd9CghWkfg4UGh6yzdT4xrRDsRUngaYfLi7D1+a4xHDBF/6Uy4TrfNhWqllkfVh4pisxElFN+WGbpU9GWPJElHi4Y4ebO0myzEhiK7jummuYOnUq//ajH1FVVUV2dutbB4mLx+nE+GEc3iZKCQ5ZykU/TxCfMrHRHEtGKbJjeFBcipf+HTTGf5AT2zt2pBukkOpX9B4xjpLai3+YJ5uQ4cLWmsNWhP1WGBepHGqojO8pS6BZQJSD2HhRdHF58dXF+NW2RamTip1m4GVUB82hOvL4WmgWEmNvmhyqxrEorcuhJuNh/FnMoSZe7+OLf85t8ZiKN79EdOf0Jo9p7bDvo/Vs2PgOu/aswLatDj2+NpolxNlBEnddDhVIk0ONw8PUDpKjun3wy01dG1b+pxNPuPjNY7eQtFIFn+SxYsJLVhPbtiu1ZKOdOGhWEGcLSUxSOVSgLocKOzbDpxq890LvtOdqG7QFypWK8zOJVDosfzbKrLv9+LIMkjHNyuejvPN/YUpPY8LSmCs8fOWx/DZvP7v3oM3f76ui6Ayawp8ujWYtCdbV5aiFppdQ3fhG62L8JJohuJiLr805qtsPX3sij6EzvQ0T0M50O976HCER1ZTst1nyeIRlT0f5Q/zEzwcdrjzt1z8XtNb89v/+wA9+/FOUUtx8442MGT2aH0qML06DFFBO0+kkV/WKsdlKgo+wSaBxGTCkO+Qf9TIEN94O8Ev9QlaGzVaS7McihsZU0L8LdCn2Mgy37Il8hiqw2UaSPVjE0RgKeudD1zIPw3FL354zVI3DNpLsIkmM1F6v3XOge6WHEbgJneXx/fT9OUy51Y+ZYTKW1mBVdqPk0f8EoDZcwabNC9iw+R3Ky4+c1WtpD7U4bCfJTpJEVapfRpcs6FHjZgSeDjUruM8YFz94p7DFY7SG1xdNZeWCLGqXrCK+Y0+7JlUni+CwgyQ7SBJRGkdDfgge+FF3br471KQ5YWO6LjfKlFzZlmbVc1Ee/3Y1SoEnoEjGdNpmkW3146UFdBvYthttkVqHH00rIXIO+/W0RQzNTpJsJ0mt4WA7kBuAHhE3o3C3ac/0/N4GQ2d5MUzoPcrFJZ8NnJ2ZaHZqbLSGZ39YzeLHTq1ZaUcQR7ObJDtdDhVOEttBkqtO6HRjfI2mqC4GPYRFktSs4nwMRuFmEO4O3fekI98ghdT4FuOwrVEOZZDa5msEbobiPuWcrD119PEFKK37/O4j1WhbkdqKemTd+HbkHOpCGN+KuvHdW5ejKiBUt83X8DPYejOTbzyTz7BZHjL1V9eOInF0CGXPfQ+AqupiNm56l42b36WquqTJsRfC+FbV/XzYjUW0bnwDKIbjZgRugh0oxh95mYevP9l679an37yELYugdskqEns+OvcX1oKaxjkUqRXGfhRvPNqTWZf5M8f4DqAyb8drW5r3/hjm5f+sRSnwBhXxiE6dd5p+taULWQWtx8RaaypLHX48tQSr/XafSyvcKIcK142vD8UQXIzEQ24bPr9dB5kMnupBaxg228Pkm3xNVp+dDq11Kk8zwE7C375eyfrXmk4ma/zzoaMVUOqVlpbxyGNP8Je/Pcbe/ftxHEdifHHKOsb6xU6mKyZd6/aO/cPjNRh1v1Du/UTHnNFzoSnA5BJMLkHG91zIw2QWJrOABx6vQTWMb9u3jBGZZWMwHS/T8fLA46lgxDDO/vjm5/di3JgrGDN9J6Zrf8bjlAJXqJzde1axYdM77N67CudM7lqfZyEMpuBlCl4eeKzx+Hagnj1K4R02iC63DgQ2tXio1mBtXEvZQ+e/mJXdxeCK24N8cUCq0f1VU8ugJoFhQOWIQMbEClKFk8Qx8HQH7egmK25sS1Nb7vDqf6V66mjNGa9mGDLD3ebiiWNrfnN9+XkvnkAqkRqHh3F4+ONjNTgazDZ+fn1Zik/+OpsJ1/nOqFHkyRxbU3bYZv/aJMd2WSx7Kkp1ccfbB7ktvChG42G0Bb/6c5LcL5/vKxIXEoWiJy561qVXTt0NvI4w2/lioFB0w6RbXQ4l43v2FWIyF5O5yPieC3mYzMZkNud2fLt2GcC4sfMZNHo5hpl5ax1laMzsErbtWMKGTe+w/6P16DO5a32e5WAwAx8zoO72cwf8/BoGvlFDKby+N7Cl1cMTyxZT/reic39drcjvbXDN7UHyeprUlDqsfD7C8T02CsXMuZmLJ/USB8HbL32MX3bQ5t0HwkAqxo/Vnlm8Pflmb5uKJ5AqCPz62vLzXjyBVE+qSXiZhPeUP79ZhQaf+b8cRs47u/cLHEdzfLfFoS0WhzYnWfFslHDF+c+HTkdhYQH/8p1v8S/f+RZVVVXk9ux3vi9JXICkgHKemR1nIsRFScb33DJkfM+psz2+Ho+fkcPnMG7MFfTpPTL1NeIPoJ0DKCNzwlRVmuCZ5//97F5MB9DRPr/K48E/YRSBaRNw5eVS7Y+g9aYWG6gbBhxeWZL5gHZy2ZcD3Pz/6hrdO3W9CN0hrL1Rin5m0ON/Wk9kKsssXv1xLR/7lxDdBtXdgLQ0G96I8cJPa85qA/I7fpHd5mXs7/3p9LYIO9eUgrZOKjNc8PW/59FvvPusFE9sK5U8mS7FhjdjPPrNKpIX3oKTFkkveXGmjI524+4iI+N7bsn4nltne3z9vixGjZzHuDHzGxrC69g2tFOGMtLf8NQOHP2ojBde/sVZvZaOoKMVTpTfR2DSWAJTxmNmh6g0KmlLAeVIB4jxb/h+iCu/EUxtuVvX7P2a+0JseTZBxf+amK0Fo0pzaG+Slb+Pcs19IfJ7pXICK6FZ/UKUF39WQ6Ty7N2Uv+Xf276i4NkfVlF+uONNDDyVz683oPjOi/kU9j87vb/spAaVyjGXPRnl6X+txul4adAZOdNtikXnJQUUIYS4qCn69R3DuDHzGTFsFm5305nqkR0z8Q9dm/Fs29Iseyp8ri+yUzNzswlMnYB/4mgM74mZQ7WRADs/6sWQfkcx0yS/jq2pOu6wfWH779fb2OSbfdz27+kb3Zv9/eR8AiKbIGtOag/kdGxLs3V5nLWvxFj7SozuQ018IYPSAza1ZWevcOLNU0z6apCeQ11tCp6tpObVX9aeta/fXkIFipl3Bxgx14MyFOFym4GTz3wVpm1pwuUOq1+MEalyWP96jGO7Ol7iKYQQQlzslDIYOGAi48ZcwdDB03C5mq6sjW6bhafH3hZeQbPsqQsvxrmQmIX5BKdPxD92BMp94v9PcXkuR47n06NLBUaaGN+2NEe3WxzafH7vXF/25QBXfyvV6P7kHaRG3eah1NJI2wABAABJREFUQkN0G/hHZd6GVzuwdWWcpU9EWfZklJ7DXbh9iuP7LKJVZ69wEuhuMOd7IXK7tK2QEKtxWPJEB1h6copyexjM/mSAwdPdaCe1Kr/rQPOMJ0jZlqb8iM3GN+OEKxzWvBSj7KDE+EI0JgUUIYS4COVkd2XsmMsZO3o+ebndMx4X3z+W+JHBeHrsbTZDrX7rpA//GjnXl9spufv2IjhtIt7hg1AZlsO8vWwSvbuW4PclMBvlA7aV2hv40W9UndEewWfDdd8NNVuSX0+ZkHU5HP2pIvvSzEmSMmDRoyc+Z6mb8mcvaDfcMPQ2P8M/HmBIv7bP0HrjN7XYF9isqyEzPHz18VzcPoUyUrOstNan3TjStlK9glxuxfG9Fn/4eAUVRy/cLT6EEEKIC1nDNryjLiU7K3OvvOiO6QQnvIsr9xjKbB7jlx6wWfnsRbZ8tIPwDOqXivGHDMh4zKsfTudzN76Ny2U3i/GTMc3/Z++sw+Oq0j/+OfeOz8Sb1N0ldYcKWrRYcXfbxZdddhf5sbCwCyywsEhxt+JeoQVKS71N6pK6xHV87j2/PybSNJm0aWNtz+d5+jS5NufOTGa+57zv+33fuau4CUYaG91KVfCkFoQGiedC9pMC18BYVU4SIwLz3o++z6SEnWsaVlhbnII+l7joNcVJ/84Hbi/wwX0lDTqOpmDQqXaufSkRTaeyKfyhYEQkSNCtgq3Lw7x4ReFha9GlUDQFKoCiUCgUhxFdhlgZf5WLrsOsREKSjB+D/Pq2j6LdJhaLnT69xjIo/US6dhm832uVeQvJXDWbdR9s49S/+xh8miPqvSRBaILtK8O8flMxpXlqsbTBKPc+do8eirVd7MAWQHjXHrb+vpTHntnF6Xe6GHGeE6tdIE3J6tlBvn2qjG0rmnd1v3UPvdJuKyYmWFvBjhclHW4WGBFZ6ZVshCVCh/fuLiF7Y+NkOXUYb2PgDR7cbaOz07S4Awsi5G2L8MMzh1f1VXyqxi3vJmK1i2pNIw82cFKSY7J6dpBISJI5M8ia2SEOca6mUCgUCoWiFnqNtTHuSicdB1gJ+iTLvgkw910/ZflmrTa8dVFSkkvGylls/GA35zwapO9Ee3SxtVzjb/w9xBu3FhP0qS/1BsNiwTmwL65RQ7CmxQ5sAYS27mDdR0t57LlsTr/LzeAzHVgtgkhEsvzbAN89VcaeDc2b/d9tuBVPct0BCc0K0pDs/lDS9qKaGh/gtRuLGmcuqUGXSQ7Sr3HjKB9nikccUMJQ1uIQiz49vKpPWvfQue7lRIQOWnnS2sFaURkRSe4Wg6yFIYI+yfLvgmyY37yOBgrF4YAKoCgUCsVhwqTb3Jx1X1w1cdq2l4UTbvSw5NnxtBZTcNjddV7DMCJs3LSI5Zkz2JS1uLIh/CvXQ0rHMvqMt6HpsGV5mO0Zh1nqfTNjscHg0xy072ch5JdkTg+yY1X0OdzX+zgWUkqCazfi/X0p4W3RxvAB4N27S/jo7yXEpej4S0z8JU0z4U1sq3H8DW5GX+DElSAo2m3y6zs+fn7dR5ppY0KX2PdSiZRsDAV4/99FdJ9h47jrXPQYbUNKyZo5IWa/4mVrIwSCEntaGHyrh9T06pYWTvuBTTienVLY4GNqSKQQ0CYO2S6eR5faKM01Kc4xagRPDvh65RNOaUZbV5bkmPznnAJVvq9QKBQKRSMz5eE4jr/ejRGW6NboInD7vh5Oujmepc9MooPrzBo2vPsSiYRYt34+KzJnsHnrisqG8M9dHF187TnGhhCw8fcwu9crjV8fbE7B0DMdtO6hEyiTLPs2QM6mqD7SPG5cIwbhGj4IzeWMeQ1pGARWrsO7YCmR3TkA5ABv3FLMe3/aSUqSTn6hwaXeA9DWDUBqV50TbnQz4hwHdrcgd6vBL2/6mPu2j45WB8d3ijug62T6fXx1Zwn9v7Ez4VoXXYZYMcLRJL/Zr/rYva7h32utBloZfIubpJ7VNb7Vsn+NL6Xk2QsKGnxMDYndJRh1gZOxFzuJS9Uo3GkQDlT0Jjl4jW+aEgHkbjZ4+twClSSpUNQTFUBRKBSKw4B+x9k4676okK0InkC0fNdqF4y6awHZr01BBms/Pyd3CysyZ5C5ajY+X+0l4fnbDX57T5XyHwx9xtu45sVEPMkakbBECDjz3jjW/Gby0Uf9ET0HVPM+3hczGMS/bCW+Bcsximp/fcJ+mrTRYZteOnd9noIzXlS+55Laa5x5r4eTLvKw8zYdCkGGTUTsW0NYBCtX+jGBDfNDjZ7h5EjRGHCNmy4n22vYiukaB9SWMRwyyd/ecgMHdrdADm0P8dHFlKQEQWJrjY7iwHq77Is0JdlZBlY7+IolC6b5mf+Bv8kCdQqFQqFQHK2MOt/B8ddHE6B0a1VmudDBEScYfc98sl8/O6az6c5d61iROZPVa34hEKy9p0n2RoPsjUrjHwxDzrBz+dMJ2N0CIxy1rjrrvjiW/CD54rtBWHr3Reix7WFNnx/fkgx8C5djltVe2VzmlZR5my6o1WWolds/ScJiq9L4qV10pjwUxynnx7H7Hh3LHoD9L7BnZvqRwMpZQVbOijERbSDcbTUG3uChw3h7jX2OAwieAPhLTMIt+E/Bk6Jx1+fJtO4efU8JTZCQplXa8h4MezZEsLs0SnIN5n/oZ8EnAUJ+pfEVivqiAigKhUJxGHDCje5qlSd7IzQJ1hCufr/hXXZy5XZ/oIxVq+ewInMGu/dsbMrhHlV06G/hlneSKpunW6xVr1HvMTpXdc3j7a9q/7qNFBbhW7AM/7JVyFDLKp2+9qXEasETqJrQOztB2h9M9jymUzIL4k+M0SBeSggbZExv2AmVJ0WQ1i1a6bNzdQRpgmaD3ue76HOxC4uz9gmGsyiCEDUnXdWHLCne3bIzsi54JC4aPNlrInWwzSONiGT3ughPnlmgJlMKhUKhUDQxJ93ixjRkrdWjQjPR3cU4eyzFv25U5fYKG96MzJnk5m1tyuEeVfQ6xsa1LycCUQ1ssVXtG3KywNGjiE9n1h48ieTm4/19Kf6MNRBpORU/mgVueK2m3WtFZYOnH6RcKcmbquFdBK4htWt8IyLJyTLIWhRu0PEltNZo1VnHXyLZtTb6vFlcgr6Xuuh5rhPdVrvejQ8YQN19DqWU7Gkky+CG4sr/xpPatXpT+IOpLAcwDcmG30M8d2EhZsu+bYXisEAFUBQKhaIFIyWEfP3ofYqBZqlrUVdi67COsqUnkrV5GSsyZ7Buw+8YRsOKWkVNJv3RjdBqF7eaJunSLpfObXPYurt15fbQ1h14f19KcN0mWmJTiW4jrLTvG7usROgQfwLkviDJfVnDMdDEmibR9g7wmdH7EquyMSMH3ri9LuLTNM57KI6hZzoqAzsFOw1+/y6A2cOKu3Xtj1O2yyDj5TKue3z/dgRCCLatbDl/N12HWTnmUidte1nwFZlkzgwy8jxnteDJgWKaUf/ziveqEZEs/iLAx38rUcEThUKhUCiaFEHPPv1o1ye/zqOkoUU1/uphtdrwKhqP0+/xVNNNe6Np0L/HNn5eXExeUULl9uDGLXh/X0po05YmHOmBM/BkO4ltYutyoUPiZEn+m5LspzU6/s9Ej6uu8Y2IJBKUvHVbUYONq1VnnSkPxzHgRHtlMCc7K8LvPwaxDbThSKq9H0vx5ggrXizjrreS9vsYQgg2tqBeH72OsXHMJU5addYpyTNZ92uI/sfXbdUXi301fjgomfe+j88eLlXBE4WigVABFIVCoWiBxMWlUJIzGV/hKUSCnWmr3bDfc/Lzt/Hci1dRWlr3REzRcGg6DD7dUWtlUAWGIejXYxtbdrQisGo93t+XEtmd3YSjrD/9hzqQpqyzqkFYINQhwpxZZWw/2c/Jd3gYc5ETh0fDNCVavhexpQBRGgQOzEe5LjwpGn/6NoXENlq15zupncZp17vJyjHZmlc9CBD2mqx5z8eGz/y0620hrduByZ6lX7WMxpIXPBLHxGurqs9MQ9L/hIObWEE0u/CFywoIh0C3wLaMCGX5LbvaRqFQKBSKI4mkxLYMHHAC6QOOJyktDvjjfs/ZuWsNU1+4IqYNr6LhiWul0XO0rc5jDFPQr/s2fv69L/6M1fgWLCOS27LnYf2GOjDDEs0aW+PrHihNDjN3SRl5JwWZdIeHUVOcWB3RRvFLvwrw/TMN1+g+paPOvd9FbYP37vGR1lXnrJvdrN1lsruousYPFpusfMPL5m8D9DvORlxK3Q3vK1j6TfNrfE2Hq55PYPjZzkqNbxiSQZMOXuML4KlzCrC7BUjYsiysrHgVigZGBVAUCoWihWCx2OnTaywD00+ga+dBlOypEoKhnT2xdViP0Gpf7JRSsuC7LZSW+ppquEc3moajbw8Sx/ZHt8yv81AhQC/cTe6zr2GW1u5N3ZQkd9CYeI2b4WdHm0Zmb4rwy5t+Fn7qp5PDztCkOAbEW0HsX3R/t62QrOJotcYn95fy2cOluBM1AmWS/75a0qDjnnSbu0bwBKr8gLumCvYUSYKRaE+Pzd8FWPmml2ChxGKDOz7Zf2YaRM9dOaP5s9PGX+Vi4rXlnujl91yfEv697UAqJmdf/7uUlbOa/94UCoVCoTiasNtc9O1zLAMHnECnjgMqt8ugJJzfFkvSnqglby0I3WTe1+vx+Zp/4feowGLB2b8XbSb1An6v81ApQezZQs7TvyL9zf/6pHXXOf46N4NPt2O1C3asijDndS/LvwnS3eNgWHIcfVwWxAFo/C+3FJBXYkAJvP+nEj7+WwmuRC3aQ6SBb/Wsv3pq2AZDVONLKenZRpBTIjFMMCOSDZ/7WfOOj7BX4koQ3PBqYmWj9FhIKTEM2J7Z/HZqp93lYejkaLCk4p71g9X4YYmmw4f3lTS4nZpCoahOswZQHnroIf7v//6v2rbWrVuzZ8+eyv0ffvgh27dvx2azMWzYMB599FFGjRpV2+UqKSoq4m9/+xufffYZhYWFdO3alaeeeorTTjvtgB5XoVAoGpL2fS30nWBD6IItS0NsmF9d3HTq0J+B6SfSt/ex2O2uWq9RtvRkUjqtrXWfaUjCQcn8j1pwR7wjBC3eg2vYQJxD09E9bkDi9S/F7ayjx4c02TV/N2Zp7Y0jm5LOg63c/nESVmfVJKXTQCtXPGvjjAvjyb1fB0PgWySBuidX3kKTbRnV38tGGEpyG76iQdPhmIuddVb6ALRJFCyaEWT5i2UUb4pmxQkBf/ggCVfigdmI7d4YaXI7K7tbMPI8B50HWYmEYfWcICff6t5vFVAspClZ9VOQ7iNtCAGbFoaY/aqPNT+r4ImiaVAaX6FQHA10GWql52gbUko2zA+zdXmVLhJCo2vnQQxMP5HePcdgtdbWg01QtmQSSSe/Wev1jYjEW2iy9OvmX5w/0tGTEnENH4hzyAA0p4OAJUI4sgirJXaVhS5Mdv66o0UET/qMt3Hz29GejBV6ufsIKz3HJJH7raTgSR2kwLtA0urq2DpXmpLcrQZ5W6vfdyQEJTkNr/GdCYIhZ8Su5hdCoCFJixcs/jZAxlQvZTuiY9OtcNcXyVgdB1Z9MnehH9nEhdeuRMHoC5y062MhHJCsnBXkuOtd1Spt6oMRlqydG6TbMBtSwtpfgvw01UfWYhU8USgam2avQOnfvz8zZ86s/F3XqxY4evXqxfPPP0+3bt3w+/08/fTTnHzyyWzcuJHU1NRarxcKhTjppJNIS0tj2rRpdOjQge3btxMXV90+pK7HVSgUiobAkyK49sVEeo+zYxoSKaOCdte6MB/dYaGN+3gGDjiRpMQ2+73W7qWt2BnozMCLtlZrJm9EJEYYXrqqCF+RKtNtLGzdOuEaPhh7724IbW+RLliyqifHDl2FFiNzEGDeB80f3NIscNObidicopqPcUUGU9JogXGxpOBdQXi3oPRniBsX9ULeFykls172Emmi9XhPmsARV/fkSEooyQzz8z3V7S0u/nc8PcfUbcGwNx//rWErZ/ZHv+NsXDc1EbtbYEaiYavxV9YeSN0bKWtvg2JEJCtnBnn56qIGH6tCUR+UxlcoFEcqyR00rn81kc6DbBgRiRBRPbV5aYhp97ro0upE0vsfR3xcq/1ea+vPHcgOt6bP6dnVNL5pSII+yQuXFzaZ3jrqEAJ7r264hg/C3qNLtV3hiIWM9V0Z3GcTei0aX5qScAAWf978wRNHnOCG1xPRLdWrlSv0fqvTBMZqSfG3gsBa8GWAs1/tzeGFJpj+XNMlfbXqqu83QUpKyJ0bZN4D1TX6dVMTaNv7wJY0hRDc8uccJnLwNln1ZfjZDi5/JgHdCrI8HjXhavd+z4ul8U1D8tv7fj78S9POVRQKRZRmD6BYLBbatKl98fCSSy6p9vt//vMfXnvtNTIyMjjhhBNqPef111+noKCAefPmYbVGG+B27ty5Xo+rUCgUh4puhds+TqZtr+jH7N5itk0PG7d96iH33TMxfQmxLoHQynAl/oQr6Qce+ddWALq9b2XC1S66DbMSCcGKHwL88pafgh2qO1xDIxx2nIP74xo+CEtKbPuneSv60qvzNlKTS9h7na6ivPrzf5RStLv5+0wMmmQnIUaTdQChQdK5koIPJBiCrEeh9aMR2o60VPnzhiW6VfDbe35+/G/jT66EBbqd5mDAFe79l+YbkLuueln+2X/3cOxlLqQ8sOBi7pYI6+c2XQZX294Wbnozmi0ohEC31uPkitlV+f8V77ddayO8c6fySFc0P0rjKxSKIxFHnODOz6M92YBqi79dBtm589NEct89Axl2xryG11fMqtVzyFg5iz3Zm+B16DvBxvgrXXQYYCHolSz7Jsiv7/gaJev/aEdzu3AOHYBr2ED0hPiYx81ZlE739juJ8/hraHwh4IO/FBMoa/4EtpHnObE7ReyqZQlJUyTF3wII1t4n6fSkSau+epXGL///h2fLmiTxS7dDj7OdDLx8/0lDSMhds3d1F1z5XAKDTon9N7YvC5b4Wbcx3GQBlB6jrVz1vwQE0aAUB1YkU44EqrR9xWuzcUGIT/9PBU8Uiuai2QMoGzZsoF27dtjtdkaNGsU///lPunXrVuO4UCjE1KlTSUhIYNCgQTGv99VXXzFmzBhuvfVWvvzyS1JTU7nkkkv485//XC0D7UAft4JgMEgwWGXRUlKiPrgUCkVshpzuoEO/2ldDNV0iHWW4B/1E6fxzqu0zTYPNW5azYuVM/vjXGQitIuUsmmGbtShM1iK1OHqodBthxRzQBpLdIOCPH4WZPdXHyllBLG3TcI0YjHNAb4S17hXt0NYdFC1awb+f2MSZ97gYe7ETuzuqkPdsjPD9016WfNn8mWkA/Ufuv2mkJRnK4iPMX13GulIf5tnQZ4KNkec68SRr5O8wmPeBj20rGtk/WEDH4+wMuNqNp130uzunRJIaD1qMIIpuFSz+IjrhExqce38cJ9wUzfKqK/ACVAZYXrupqIFuoHY6DbIwcJIDm0Owc02Y3sfaEFr9eptUIDQBWwogzs6eQjslOQbzP/Sz5KsAkToc5RSKpkJpfIVCcSQy9mInSe20Wi14hC7R4/Nw9puHb0X1YLBhRNiwaSEZK2excdNiTLO6llrzc0hZbTYAfSfYOP4GFz1GRS2O1s0N8dNULxvmh7F2ao9r+CAc/Xoi9lOdGNy4hcLFK3jsqW1M/rObkVOcWO3R13xbRphvnyxj1U8t4/XqP9IezaeJsV9oYO8KuTLEot1lbCz1I06C9JPtDD3TgTNekJNl8Nu7fnavb1yNL3TocoqD/le4cLaKvgZFXkmCqw69LmBJuY2dxQaXPpnAiHMPLBAipcSUcPkfshtk/LHoMdpKv4l2dKtg6/IwYy9xIE2qVf0fKEIIvn2ylJ5jbcSn6RTsMPjtPR8rvg9iqpxJhaLZaNYAyqhRo3j77bfp1asX2dnZPPLII4wdO5ZVq1aRkpICwDfffMNFF12Ez+ejbdu2zJgxg1atYpfCZmVl8dNPP3HppZfy3XffsWHDBm699VYikQgPPPDAAT/uvjz22GM1PJUVCoUiFmMvSMQ0QYuRbSI0ibPvvMoASm7eVjIyZ5G5ejZlZQXlx7QMUX6kcezlTi5+vDzbrHzy22usjb7j7cyZ05lf1h5T5/lmMEQgYzW+xRlEcvIqt39yfylf/LOU5PY64YCkYEfTZQwmtdcYNtkRDXJsN1j8ZQB/cTQo0MUdbQzf22M9oKaRn27No6ikauxr5oRYM6fp3ottRtpIv9ZNYo/qEmVrnqRVnEBSsxLFNCTLvw+yPTOCZoHrX0lk0CmO/Vat7M3PbzReYMiZILh+aiJ9xtsxwlE7P4tNHEDDy9g2XXo4gsjKRwAPXxpX8yCFohlRGl+hUBypjL0wYb96ytVnfmUAZfeejazInMmqNT/j96sAbWNyyh1uJv85rpoV2oAT7Qw6xcG33/dmydZhdZ5v+gP4l6/EtzgDo6AIgCDw3j0lTHuwlKR2GoEy2aSV5WnddIac4cAZJ8jeZLD0qwBBn0RAZWP4Tk4L4gCqrT/anItRXsghDVjxfZAV3zdR1o2ADuPtDLjGRVyH6ho/K9dkSGetVl0sTckvb/oo3GlidcIfP0ym+4gDL9kWQnD/Y7ls2tI4FeYJrTVuejORzoNtUY0PWKyHpvF3rArz7VNeeKr5+2cqFIoqmjWAcuqpp1b+nJ6ezpgxY+jevTtvvfUWd911FwDHHXccy5cvJy8vj1deeYULLriABQsWkJaWVus1TdMkLS2NqVOnous6w4YNY9euXTzxxBOVk6sDedx9ue+++6rtKykpoWPHjof8HCgUiiMHm81Jvz7jGJR+It36fIGmZdV5vGb3smjJ12SsnMXuPRuaaJRHN6176Fz0eHyNEveKSdbEiVvZUdaNrB1ta5wbzsnDt2gFgYw1yFDtAYWwH7I3Nl1qkNBgyv/FMeEaF0gwjWivkykPxzP/3wEs39lJsUcnGb7FkpRL6m4ambPZaDa7sZR+FtKvd5M6sPZ+Jd4g/PR9kBHDrSS2jloOiPIA5cJpft7/cwmeFI0rn0ug38ToNQ40eLJrbZhPHyptkPuojZvfSqLrsOjroFerAKp7fFGHLhnNYNOr+h4FvRL3ul37OVuhaD6UxlcoFEcSTmc8/ftOYFD6iaR1mIoQ+TGPFQKwFzN/wadkrJxFbt7WphvoUUz3UVYm/zmaULK3rVrFz6efuo4dn3QjO7+mLW9o5x78i5bjX7UeIrUn0wS9kj0bmk7jW+xw2VMJjDzPiRGJakHdChc8EsevDwaJn+cgwRZdzvMuMkk4Jfa1jIhk8+JwZfCkqWk9zEr6dW6SetUe+Cj2wU/fBhk11oYnOWpZpWlgmjDndR+fPxwNXl03NZEuQ60HrO8B1s4N8u/nixroTqpTYdmd1k0v/71qXPsfYzShCknlvNQ0JKV5Jq/eoNwmFIqWSLNbeO2N2+0mPT2dDRs2VNvWo0cPevTowejRo+nZsyevvfYa9913X63XaNu2LVartVopf9++fdmzZw+hUAibrebCTG2Puy92ux273X4Id6dQKI5EhNDo0mkgA9NPpE+vMVit0XLiSOE8rK23ILTaF6NNE3Zt9PLjzJeacrhHPeOvdCFNYvrQGqZgxIB1lQEUaRgEVm/At3gF4W07m26gB8g5f49j4jWuSuGtlX/1aXYYf7+T3ZqgZEZ0m28pBLPA1il208gZ/2u8TCebU9C2lx5976+NVE7i4rvoDLjGTftjYn/H5q0Kk/mKl7zMMF9o0HeijXa9LIT8ksyZQQp3mnQZYuWPHybhiDvwSZWUEl+x5InTCxpsUulOEow8z0nrHlEP8/xtEXqMqj0otFcLk1oxIpK1v4bwJAvSuloIlEkWfurn5zd8PP6kqlBTHD4oja9QKA43NE2ne9dhDEw/kV49RqKXNyozilLRPQWIWhqLA5gR2LB8N7PmvN6Uwz3qmXi1q1rlyb4YpmB4/w18+8tIAGQ4gn/lWnyLVxDZ1bj2TgfDZU8lMPzs6Lxy73uyOQUnPOFkx70avkXRbWW/CMK5EktS7RpftwhmvNB4Gt8RJ2jd3YIRluxcE4nOtYDkPhbSr3OTNqR2HQywZ1GIzNe8FG2I8LkF0k+0k9pVJ1AmWfF9kNI8k74TbNz0ZhIW+4EnR0kpKdxp8PxFhRxgK8T9Ep+mMep8J6066fiKTXxFZmW/09rHEFvjSxMyfgyQ2sVCckcdb6HJ7x/5+eUtH2X5zd9XR6FQ1KRFBVCCwSBr1qxh3LhxMY+RUlbzKd6XY445hvfffx/TNNHKvXPWr19P27Zta51YHejjKhSKowtXomD0hU56jIz6567/LcSCaX4CpVFBk5zUjoEDTmTggOOJj0+tcb5v1Xhc/X6PeX2B5Ne3VVluU6KnJNHj+Hh0S+zvEF2TdGidj1Fcgm9JBv6lKzG9viYc5YHjThYcd50rZsNIKSHlGknJTAlSAIL1f4LOT5vEdRSVVQ0VjeFnvuhtlKaRUhOc91Acx15W1R+mrMDk1/d9ZBuCTifYY95D8eYIma952T2/KlggTVj9U4jVe/lO9xxt5db3k7HWc2IV8kv+c1YBoQa67dEXOLnk3/Fo1mg1kCCajSZNGfMe6xqupsHHfyshd7MyPFYc3iiNr1AoWgrxqRpjL3HSebAVIwyrZwdZ9IWfcLkWSEvtwsD0ExnQbyIed81qBW/mROyd1sa8vmaBue+2TO14pGJpk0r3cXZ0S2wrVl2TdGyTSyS/EN/iFfiXr0YGWkafwn1J7aoz8rzaG6QLLWq/1epqk22LogkFMixYe4ek+zMSZ4pAAppW1Xz883+Ukjmj4a26nAmCc/4ex6jzq/rDFO0x+Pk9PyUejQ7jYicn5K8Jk/mql9zlVRlMZgRW/FB9nINPs3PtS4lolgPX+ADeQslTZxc0WM+QE29ycdbf4hAimghZqfHrsOqKHTyRmAa896cSvAUqWKJQHC40awDlnnvu4cwzz6RTp07k5OTwyCOPUFJSwpVXXonX6+XRRx9l8uTJtG3blvz8fF544QV27NjB+eefX3mNK664gvbt2/PYY48BcPPNN/Pcc89x++2388c//pENGzbwz3/+k9tuu+2AHlehUCh6j7Nx0xuJWJ3lqkfC4FPtTP5LHNMf7Ekb/Sw6duhX5zVCO3tRsmI4cQMX1xBPpiHZvCTM/A8bfrFasQ8WC45+PXENTcfWuQO4piNlsM5F64g3RO6zr9Fg6UqNxMCTHWh1fIsLAba2YO8Bu1aGWVpQxrr1PrQJMOwsJ8MmR5tG7loX4bd3fGxthP4fUoAc3I7jxjmrNUr3JGuccqub7GLJml01n2fvHoNVb3rZOisIdTiKuRIFN7yWSK+x9nr1O5FSEgnB4yfnk72pYWZW/Y6zccWzCZXjqNb/6ADGtXeQxTQkmi749OFSFTxRHJYoja9QKFoiQ86wc/X/EtH0qirQIWfYmXxfPLMeGkCnuMm0bdOjzmsENg6jbENv3N3XVVqJVmCakpUzgmT82ER9JY5ihM2KY0AfXMPSsbZrg7R8CdStZUO5JeQ9/0bTDPAQGHqGo1IL1obQwdkPLK0kO7eHWVJYxsZ1fuxjBSOnOBl8qh2rU7A9M8yvb/vZva7hNb7dLbj7i2Ra97BUq5BJaK1x1t0etuWbbMquqfFLtkZY+bqXnXPrrqRObKtx81tJdEy31lvjB8ok/5iYS2luw8zlRp3v4NwH4yt/16oKYfc7Llk+n6w4rsKC+L17ilXwRKE4zDigAMp///vfel/46quvJi6u7qamO3bs4OKLLyYvL4/U1FRGjx7N77//TufOnQkEAqxdu5a33nqLvLw8UlJSGDFiBL/++iv9+/evvMa2bdsqs9AAOnbsyPTp07nzzjsZOHAg7du35/bbb+fPf/7zAT2uQqE4uknpqHPL20no1mjmzt44PIIz/7WDnDfbYcZILDOMCBs3LWLFyplsemoxJ95s5/gb3cSlRD+ngj6T397z89VjZUSUA0+jYUlrhXNYOs70vmhOR+X2DVvb0z4tr07LpIzvfS06eCKAbh4Hozt5wBSg1338PF8xc7dUVTsZAfj9Iz+/f9QEAbw28ZDgRKvlCRdC0CZRsKfYoLB8eIFCkzXv+cj6xo+5H0stix1u/ySJdn2sldc7UEI+yXMXFR508MRigyFnOBg5xUl8qkb+NoM2PfWYk939DS1QZlJWYNKqU1SWbV4aZvrzXjKnqwUYReOiNL5CoTha6DjQwjUvJiK0Ko1f8fUcl6Ix+d/byHmzAzKG/giHg6zf8DsrVs5k+9PLOfUuFxOucuGMj35O+YpN5rzu47v/lFVaGCkaHmv7NjiHpuMY0Bttr+rD9VvbM7z/BvRY1mqGJOPbsqYa5kFhAXrHORnawY04AI0/o7iAjG1VVTSBsmjD9V/ebPwKqOOuc9Gmp6WG7q3Q451SNPYUGXjLpawvx2DVWz62Tg/s9+/DlSC46/Nkktrr1a55IHiLTJ4+u/CggydWJ4w4x8mIcxy4EjWyN0boOcZWZzV5LExTUpZvIk1IaB29l/W/hfjxv17Wz1MLAQrF4cYBBVDuuOMOOnToUM1zuC62b9/OGWecsd/J1Ycffhhzn8Ph4LPPPtvvY82ZM6fGtjFjxvD777Gtc+p6XIVCcXQz4RoXmoXaF0E1CZYgrvRfKFswudq+PdmbWJE5k1Wr5+Dzl1Ru//G5CDNf8tK2twVdhz0bDIK+lrs439Jp01Nn+DlOPMkaBTsMFkzzU7wnqsKF1YpjQG+cQ9OxdajZBB5g6ZruHDNkFVZLpHqFAFGRCzDntea1Xeg5xsoJN7rpN9GO0KOL6bNf8ZL5bYh+CS6GJHlItFlwZkuEXvcMRJqSVWubr9JJtk9AErtVuiklbRMFObkG6z72s2Gan4i/7r8PqxNOv8vDhKtdlZZgBzweGW3O+MjEPMoOMuvLlSi47eNkOqVbKwMm7fpYYnpu7w/TkMx62ce3T5bhTBAYIQjt5zlQKBoKpfEVCsXRwgk3uEHWTJACEJqJ5irF2ed3fJkTq+3bvnMNGZkzWb32V4LBqoSUrx4r4/uny2jb24KUsHtdhIjKezhoOqZbGHqmA2e8Rs7mCAs+8Vdm6AuHHefAvjiHpmNtXdM6GWDRyl4M77exvFqh+j7TkESC8Os7zavxB5xg5/gbXZW98TbMDzFrqhfPHI0LEhK5NCmJtlYrlt0mWOrWgpGQZN3m5nvDjbvCVaMCa28qNP6qDQZr3vOx6cv9J0c5EwRn3uvh2MtcWGz109XSlORuMXh8Uj6BsoPT0YltNe74NJnULnql1fGhaHwBfPtkGXPf8eOIF0RCstIqUKFQHH4csIXX4sWLSUtLO6Bj9zepUigUipaI1epgxOREdEtsdSc0iaPbMsoWTMbrLWLl6jlkrJxFdk5WzHOMMOxY2fCl00cTuhUufTKB0Rc4MSKyXNTC5L94+O4lmLt8AI4BfdHssZsUApTmGbz2rzZcc+d2HO7yjUJgGlEv2tdvKWqUMvcDZdwVTi7+V0K1Jphdh1rp8UoSudOg4HmNinCEdxFE8kBPptYJjBGRrP0lSOGu5kmDDAsNXDb0OrLGNCHQfCbfXVZAqHj/kx2LHW77MJmuw6wxbQ1qo6J8Pn+7wbNTCusdPPGkaLgSBSXZJlf+N4H2faPyqWIMBzqx2jd7zYhIdq2NMPPF6IKM/wCeA4WioVEaX6FQHOk47B4Gn+pGt9ahiaTA0SUDX+ZESkpyyVz1EytWzqKgYGfMU8IB2NYIFqhHEzan4JqXEhh4sgMjLJEyqvHP/mscn/5HY/nWQTj69UJY6166yt0mePupVC67fQ+6pUobSxPCQcmLVxRVJl01B6fe6ebMe+Oqafxex9joO8HOOVOTKXu/KpGhdI6g9W0S7LE1/sJP/QS9zaMbHcmCpHZ1J14IIJJt8N1lBUQOYJyOOME9X6WQ1k2vV8Ciwt5r17oIz55fWO/gSUJrDbtbULTb5MY3EknpqCOEQJTf3gFr/H1sxkxDsmF+iHkf+JFSaXyF4kjggAIoDz74IB6P54Av+te//pXk5OSDHpRCoVA0JR3b92PQwJPo12ccnrj7gcI6jw8ZJXz06cNsylqM2VCd6RR1MuXhOEZOiVpx7Stkz7gV+NnF0jW1B0+klIQ2bcW3NJPguk3kmiZ/f1/w1FcaMtkFQvD96yZz3/M168QqrZvOhY9F/XX3vseKn1OnQHApeOeV7zAEux/X6PC4iSmrW0cZEUmgVPLx30ubbPwVWD2Cnuc5mZeazDBT4KrjWNOQ5K6L7Dd4IgT0mWDj9Ls8dB1urVcpf/R8wc9vevns4dJ6ZX51H2nljHs99D4m2gQzEpL1zoirQEpJ4W6T5HI7gkCpydz3/Hz3VFmzTYAVCqXxFQrFkYuga5dBDEo/iT69xmK1/ZG6GqsJTVIWyOa9j/7Glq0ZSOXD1SRc9XwCA06I6izdWqWxNB0u/IuEH+JYt6X2ZStpmgTXZeFbmklo0xZypWTduxpjL3XSc7QNKWHd3BDzP/RRlt98WqvbcCtn3htNQKhN47e/AbYukwTWRH+XfsGeJwRt7zcxDWpo/JJsk68eb3o7MnuSoPeFLrqf6SRiSCx1JDOZBuzJCO83eKLpkH6yndPv9tCmh15vmywhBN8+VcoPz3ox9lPhsjf9jrdx+t0eug6Nzh/DQYnVfnAaH6B4j0li26jGLysw+eVNHz/8t6xeY1IoFC2bAw6g1If77rvvoAajUCgUDYXVCW17lZfUr43U6DcS50khfcDxDEo/iZTk9pXbQ9ldcbiLEVrtkyYjIsn4eRcbNq5tzOEr9iI+VePYy1y1Wi5AtF3J+OErWba2O1JWpWkZJWX4l6/Ev3QlRnFJtXN8RRKxvQixvQiAb59q/qzqcVe4op7AMcrhZQSSzjHxzouK85xAiKVflRFZF+H0ez30GRedfBoRybJvAnz1eBl5W5suwGeNE/Q6z0nPc5xYPRoRILtI0iU1tnexpgsWflp3RMOTIrj1vWQ6D7JWVpIcKBXZYDNfjAZP6kP/423c9FZStW0Wm6hXI8sKTFMSDkj+MSEPh0dgdQiK9hjK6kPR7CiNr1AoDjfsbkGbnpbKKk5znwKQxIQ2DEo/kYEDTiAhoaq6LpzTCWubzVFL3lowIpIlP21k85aW3SfjSKJNL53Bpzli7jdNmDA8k3VbOrC3IWyksAj/0pX4l6/CLPNWO6ck1+SHZ7z8gJeWwoSrXdUqT/ZFRiDxbJM9a6Iaf5cvyJJ3yrCvNjn9Tx66DYsu8kdCkoXT/Hz1rzJKcpouwGdPEvS5yEW3M5xYHNF7yC6WtE2i1j6HEA0OLf4iUOu+CpI76PzxwyRad7fUW19XHP/ZwyXMfLF+1myjzndwxTMJ1VpeWu0HqfGNqD3w30fkktBaQ7cKCnYaNT6XFArF4c8BW3hV4Pf7kVLickVzSrdu3crnn39Ov379OPnkkxt8gAqFQlEfLDY4408exl/pwhFX3tSxyGT2az6mPxege5dRDE4/iW5dh6JpNUuPvctPwNljaczr6xbBL281r3/u0Ub6mfF12jUJAfFuP21bFbIzO4nghs34l2YS3LC5RTeD3xuLEPQbbq+zTFxYwNEXNpcFWFpYyg5feVRwMfz3gkLiWmm4kwTF2Sb+kqa7b2ucoNeU8sDJPj1JdhZK2iULrLqsMcEyIpLsTRGWfl335Ormt5Lo0D8qV+o7screGOGT+0tZ8/P+GzW27W1h7CVOWnXS8ZeYDDzFgRA1+yHVd2JlRKJe3G/fVkzQK1W1iaLFojS+QqFoydjdgrP/5mHMRS5szuh3cUmuwcwXvLz9WohTe03ggvTTOKbz0FrPL1t+IsmnTa11X0XfjF/fVg0KmpIh5ySWV1jUvl/ToE2rIuI9PoqLHQTWbMS/NJPQ5m1NO9BDwKYJeo88AI3fD34oKaGoMEB2oLxs4WdY83MBCW00nHGCwl1mk+pIR7JG74ucdD/Dib5Pdca2fEnrBAFa7Ro/a3GYtb/E1t+aBW77KImUTvVvFC+lZOvyMNMeLCVr0f5LPIYPsnPlhfF0aGuhVZHGiHOcIGr2QzoYjS9NeOPWYkyDZrNNVigUTUO9AyhnnXUW5557LjfddBNFRUWMGjUKq9VKXl4e//nPf7j55psbY5wKhUKxXzQdbnoriT7jbNUWPV2JGqfd6WHCGWMo+f42Yqb4A4FtPdn242A6TVpeLVOo4ucvHi1VXsdNgaZh790d5+D+pJwaRLIsZiPyCiIrl5P73ibM0paVOWhzCoad5aBNTwshn2T5dwF2rom+h9y6xsAkD+kJLuJFNN5Tl3YPBE2+2plf677SPJPSvIYff3IHjbGXuGjf10LIL8n4Icjy7wPozmjgpMfZNQMnFYQjkm1ry4hzOmnT3VIZTNB0waaFIV67sbjWKoykdhon3uxm7CVO7K76NYqH6N/rztURnj6ngKBv/xPNcx+M48Sb3BhhiWaJ2g4cSlP4oFfijI+Oe93cED88W8bG31UNv6JlozS+QqFoqVidcMe0JDoMsFb7fo5P1Tn3wXiOO/NU/L9cU+c1vGuG4E/oSftjNmAaVdanRkSiafD+n0oo2KGseRsdiwVH3544h/QnaXwBkjVA3VotvHA+Od9uQPpaVoDLGS8YfraD1C4WfMUmS78OkJMVfQ/FW3UGJ3rol+DCbu5fi27xhbhr9y5upGZVfPEek+I9DT580rrpHHOJk7TuFgJlkqVfBVg5K4g9SaPPRU66nV4zcFKBLyD59n0/xx5nJ6WDXk3jr5wV5K0/Fteax5bWTefEW9yMmuI8KMss05Csmxvif5cV7rfKQ9PhsqcTeOF8J+GwxGKhsjn8wRAOSkxDYndpmKYkc0aQ758pY3uGWhtQKI4G6h1AWbp0KU8//TQA06ZNo3Xr1ixbtoxPP/2UBx54QE2uFApFszF0soN+E+217hMaeHpnElybSXDzoBr78/N3sDxzBpmrfqKsrIBBp9g5/kY33YZbAdgwP8TMl7ys/mn/meyK2DgTBG17WgiHJDtXRdi3hYwlrRXOIf1xpvdFc0ezoHML97A/O1zTlGz9PBOztGVl/gw+zc4VzyZgdwuMcPR9ePo9HtbNDLHhQUk3i7Oyybp3nolrsCRWpMgIS5b9UHe1RkMz7gonF/4zPtrQU4taKYw4x0lRvknGTgPDUntwQ5qS1kEvXb2FeCJhbro0ju6jrHQbbkMakrW/htixqvbJRpueOnd9kYIzXhxUECPoM/nlDR/fPe2NGTzxpGgMOMGOzSVo3V3nuOvcQJX3tl5vdRTFiEjmf+Tnw7+U4EnWCPlkvZtZKhTNhdL4CoWipTLuchcdB1pj2rkmDf2NyNrjCed0qbFvT3YWKzKns3L1z/ifLGHkeQ6Ouy56PTMCq2cHmfGil00LVKLDoeBJ0UjrphPyRZNY9l08t7Zrg3NIfxwD+qA5ovO13EIDXa9bJ4X8kl3fZiIPICGmKRl7iZMLH43HYgMjEtX4k/8Sx4rPguz6t6CL3VFZmVE218R2oaxsTL4vkYhk2vdNmwC2d1N7TY8mD42a4iRvt8GqPIkZI8hgRiRbpgdY+74P726T6QL6jLfRMd1KJCRZOStIzqbaA5Fdhlq5/ZMkLLaD0/jeYpPZU71Mf94bM3iS1E6j70Q7Fit0HmJl1HlRizhrucaP9RrsD9OUzHjBy/dPl+FJ1giUygNK0lIoFEcO9V4i8Pl8xMVFo+LTp0/n3HPPRdM0Ro8ezdatWxt8gAqFQnGgjLvcVWcZuDQ1XAN+rgygBIM+Vq/9lRWZM9ixc021Y1f8EGTFD6pBQUPhThKc+2AcI85xVjbhLs42mP68lznvGDgG9MY1ZADW9m1qnLt5Z2sKS9wkeLxotazXGxHJyplBirNbVvCkx2gr101NRIhoSbhlrx73vY6z0d4DO/9SNXko/kGQcqVEc9UU96YZDazMebXp7OP6TrRx8b8Sqm3Ty5//+GTBMI+FhZuqP+fSlGyfE2T1uz6e+GdRtX2bFoT3uzjRebCVa15MOKjgiRGR5GQZ/OuUPEIxEhQ1C0x5KI5xV7rQLQLTlGjawXkeQ/R+hSYwjWjW3fbMMJ8+WIoZoUm9qRWKhkBpfIVC0VIZd4ULUUctsjQ1XOm/UDyrCwB+fykrV89hecZ0snOyqh278NMACz9t2oSUI5nEthrnPRTHkNMcaOXaLX97hG+f9LLgG3AO7Itz8ACsrVvVOHdNVkdOOXYxDlu41gpsIyJZ8Im/xS1UDzrVzmVPJVTqx701/sCz7XS2Q/YTVTdU9KUg6byolhf7zGVMQxIKSaa+U9xEo4eRUxw1mtpXJA8lt9EYlADLtlTXsWZEsuXHAGve9+HbU7VPSljzc6hOu1yhQbfhVm58PRGLXaDXswLENCSbl4R5+tyCGsl3FVidcMm/ExhxbtSCF0m9G9LHemxNF6z5OcT3T0ebwre0OadCoWga6h1A6dGjB1988QXnnHMOP/74I3feeScAOTk5xMfHN/gAFQqFYn/Ex6UyaOCJdOm/GE2P3ShaaCaWpGy2bstgReZM1qybSzisgiSNjSNOcPeXKaR21avbLqTpnP+PeNqf04uZC4fXcQXB5z8O5/KzfkFqslp1gBGRlBWYfHJ/SezTm4lT7/BEKzdqmSQIHTyjwd5LElwf3W+WCRbeEmbQf3WcCQJJ1M5LmmBG4LWbi9i1tulKxCf90Y0ZkZWT4b3RhMBthxQP5JdFAwnbfgqy5j0fpdvqb38xcJKdcx+MI61r/Us/Kiavm5eEmXptUY3gidUBPUbbsLsEI6c4GTjJXpnBWvH/wTSF9xaalOVL4lI0CnYa/PqOjwWf+FVjeMVhi9L4CoWipZGc1I5BA08mtfMMhBZbXwjNRE/IZnbW7xRkzmb9hgUYhqooaWzi0zTu/TaFuFStml5Mbm/himcTaHvhIOZn9I95fsSw8PkPw7nojPmYsnqTdSMiyd9m8NW/Ys/tmosz/+ypTMLZF6FBwqmQ/7Ykkh3dH9oDC28PM/QpCxZnVbG5JFphc8YVu9ixq+k0/im3xx6/JgSJLohzQGkgGjjZ/EO04sR3EIGDUec7mHxfHElt61f6IctLmIQQrJod5I2bi2sETxweQY9RNnQbHH+Dm+4j9qpSO8jYiWnIaBN4I2rRlpNl8OvbPhZ/HogZvFEoFEcH9V6peOCBB7jkkku48847Of744xkzZgwQzVQbMmRIgw9QoVAoakPXLfTqOZrBA0+mW5chCKFBaD1SlsbsISFN2Jm1h3c+uK9pB3uUc/z1LtK66bU0447+P3boelZs6EFuYWKNc0NbduBbvpLs1evZ/RKceqeHwafa0XRByB/NSvvu6TKK97SsTCBHnKDvhNrt5CqQEYibKPGuhTUlPpYXllGwLsLHIwQjz3PQd4IdTYfNS8PMe99PaV7T3aPVAb3G1j1+U0pS3IKlX/hZ866P0u0HN6sYfLqd66cm7sf9unakKdnwe4jPHy5l6z69iYSASbe5OelWN864+vdRqQtNE3x0XylLv1YZrIojB6XxFQpFS8BqtdO397EMHngynToOAECGfgNL7IV0w4DpKzO44pOva+0hoWgcTrvLQ1yqVqNquKLK4oTRGWRs6IbX76y2X0pJaNNW/MtWMnfdJna9qnHqnW76TbQjNEGgzOS39/388EwZ3sKWVX2S2lWnXW/rfo+LGyfZ85FkdbGP5UVllKw3mPazYPSFTnqOjpasbJgfYv5Hfn4ubrreLskdNNr0qHsZ0JSSFJdg+Se+aODkIKuqx13h5OJ/JVQGQ+pL5owgX/6zjN3rqmt8zQKT/+xh4rVubM5DrzKpoKLi/927Slj/m7LtVigU1al3AGXKlCkce+yx7N69m0GDqvoInHDCCZxzzjkNOjiFQnH0oekw6nwnE65y0aZXtGn10q8C/PSKl5wsg9RWnRk86GTS+x2Hy1XdXsi3Zizxx04jZiNCIZn3ccurVDjSGXelu85mfYYpGNwnixnzh0Z/LynDv2IV/uWrMAqKKo/buRpevb4Iu0vgiBN4i8xmy/bvOcZGWnedYJlk1U9B/CXlWVJAF7eDUT3c+72GlJCjhXgtq5CAUTUxCXolv77t59e3m6dRZkJ3nfQrXPs/UMLu+SEWPnZwmYGpXXVGne/kxJuijxXL17zWh5YSacKWZWH+d1kh4fKnSgjoPspKQprO4NPtDD3TcVDWXPtiGrK8sTxEwvDJ/SUqeKI44lAaX6FQNCYWO4y92MX4K5206mwhUGqy8LMAs1/1UrjTpF3bXgweeDL9+07Abq+uQ/xrxuAeMhOh1b6Qq+vw5id5TXEbinIsNhh9oXM/lquSQb03M295PwAihUX4l63Cv2IVZklVz4+sxQb/u7QIh0dgdwvKCkyao4BIaNF+HikddbyFJqtmhQj5oxpfA3rEOTnmQDS+Kdkmg7ybVURorwbyviLJTy/7+OnlprPk3ZuUfhZG3HQg44fN3/tZ+szB9WVp18fCqAucHH9d9O+4PlrcNCUCWDkryNRriiqrPjQ9Ov/yJGuMudhJ3/G2BrPoMg3QrRDySd65s1gFTxQKRa0cVJvUNm3aUFZWxowZMxg/fjxOp5MRI0Y0yCKFQqE4etEscMOriaSfbEeaUesjm1NwzGVOxl7sZuMbFxIfOCnm+b6V4/AMnonmKkLs05Cwogx84TS16NlU2Lp0xD2kLwlpGXUepwlJoqeUwOr1+JatIrRpCzU6T+5F0Nd8Tfu6jbByxbMJpHW1VFpHhQOS2S972ToVBiW4SbBZICQxvCZ6XXMUXZK50l8teNKctEq30udiJ21HRStP/CGJwxp70iOArN/rP8EQGlzwSBwTrnZX+grXl+I9Jj+/6eOnqV7C5X/Sg06xc/4/4knucJDdIWvBiEiKsw1+fcuPK1Ejb2uExV8EKgNmCsWRhtL4CoWiMbA64bYPk+k2PJq5LzSBzalz3HUuxl0Wz+Y3riHeGB3z/LJlJ+HqPxes/lo1/pLMIN/M8DbqPSjKEQJb9860Ht8TmyOzzkOlFCS6S/GvWI1/+SpCW7bXeXygTBIoax6NNeAEO5c8EU9iW71S4wfKTGY87SX/I430BDceq45WKJERE1HHSppmEaxY6a8WPGlOWo+w0vdiF6mDbAgBEUNiqUN/67oga379I1gWG1zxbALDz3ZG+wPWowC84jnP32Yw5zUfP7/pqwyejDrfwTn3xxGf2rAaf9faCMu/C+BwC/ZsNFjyZaAyYKZQKBT7Uu8ASn5+PhdccAGzZ89GCMGGDRvo1q0b1113HYmJiTz11FONMU6FQnEUcPz1LgacZEcIUa2Jtm4RSA16XfUVe16ZAIatxrmBoJdVy+aw5ZsgZz8eomO6FSMSbeys6YKty8O8cn2REkWHiDNBMOZCJ/0m2tEssHlJmLnv+ijcGQ0C6EmJOAf1wzmoL3piAiAJhVdhs8a2dzINKFi8maJPljTRXRwcHdMt3P5JcmUPlooFRatDcNJtHgrbQe7/yt+4EUHxt9GGkfs2hIfoJMEMw8JPm6bKxO4S9Jlgw+ERZG8y2LK0alLUZpSNvhe7aJVe3Y5gZ4Gke+vaJ1fSlIQDsOCT+o//zD97GH9ledVJPYMn0pT88KyXr/8dzYhr28tC58FWOvS3cNx1B1A1s7/r79VM3ohIwn7Jy1cXsT2z6XypFYrmQml8hULRWJz5pzi6DrPWyBjXLQLNJelxxefkvDGSaJ5/dby+YjIX/cyu70Kc/0SY1t0t1TT+2l+DnHbLTgzVn+CQiGulccylTnqOqbKX+u29KgvZ1NRUBg8eTGr6QPQ4D8IaxpSZ1FkEICW5c1ZS/EXTNUg/GHofa+OmtxIrf6/Qgg6Pxpn3x5HbWlDwfvS9aZYKSudA3ERqDaKYpsRfIlnxQ9Mk7TkTBH3G2bA5BTtXR9ixqlyzatBhnJ0+FztJ6lml8aWEnYWSTim1J0mZRrTP38GM/6J/xTP0TEf04eup8YUQfPjXYn55Izq36DjQQod+VroOs3LsZa6DtgGrDSMi8RWZvHp9Eblb1AeHQqE4MOodQLnzzjuxWq1s27aNvn37Vm6/8MILufPOO9XkSqFQHBRCwHHXuWP2LxGaRDh8OHstwr/mmMrtW7ZmsCJzOmvWzSNS7ue05mToOsxKj1E2pJSsnxdi2wq1AHqodBlq5Q8fJOHwCATR7MFeY22c/Ac3HzwVz9riodg6td/nLEHG+q4M6bsJXatd+OoWWPTxwZWINyVn3utB02M0hReQdB4UfiKJ5ET3578jcI2W2NpVb8ReUXXx4X3F+IoaN6AnBEy63c2kP7ixu6sWJXavC/Pju34SRtpJ7F67FNhRIElwQKuE6GSrwmLLiETH/PotRQdciWGxw/irXEy82kVKJ73e2exGJNpYdO57fr55ooyk9hpXPZ9Y6SEN1YMfB4NpSMIBid0tCJSaLJjmZ+ZLPvK3qYmV4uhAaXyFQtEYWJ1w7OXOmAuqQjOxJORh77yK4NZ0AKQ02bR5KcszprN+wwJMM6rj/+9Y6HWMjc6Do4lSa2aH2L0+QiEto5r3cKXfcTZueC0Ji62qf0nvY22ccruHt/6VzPXmINq1a1ftnFDYyvot7enVeRdaHRp/8bSWXxl0zv3Rvjmx3qMpV0qKvpSY3uj+3Jc1HINNLInVNX5FYO/t24uJNLILlKbD2X+LY8I1Lqz2qjFsXRFi5icBUsfbietQu8bfkitJsEO8m8o5HYARlhgReOX6ogO2UHN4BBOvczHhKhcJretfIVKh8X94toxf3vDTppfOVc8l0mlg9cSuQ9L4psQfkLhdGt5Ck/kf+pn1spfibPW5oVAoDpx6B1CmT5/Ojz/+SIcOHapt79mzJ1u3bm2wgSkUiqMHTdMZNHwYSe221XmcNHRsbTaTvbA3GZmzWJE5g8Ki3bUeu3lJmM1LmsE89wjFlSiiwRO3qNarQtMFUsIlfyrl1c+c7KnFfnr+ir6k99yC0CNo++hq05BsmB9i/byW7TXrShT0P95et9euhPgTJAUfCHICIZbv9rLjFD+n3u1hzMVO7K7ojHTbijDf/cfLylmN38Bl8n0eJv3RU2N7614WLv+/OJZsNvHWMoxgscmGT/18+a2fkZMdTLzWTZseOpEwLP8uwMyXvGzPOLCgpNQEd3ySTJdhVoSo3wRISknIJ5n3gZ8lXwaIS9U49nInp9/jwZ1UPUv1UCZWRkRSVmDy+KR8SrLNuhzkFIojFqXxFQpFQ6PrVsYcPxSHp+7PEGloWNtsZs+KVFZkTCdj5SxKSmvvabL+t5DqUdCApHTUufGNJHRL9QCC0MHigKv/Xoz/o3iKaml598uSdHp02g2mRNuneMg0JIu/DLB7fctOYkvrrtdYrN8XYQPPOEnJD4JdviDLV3jJOynI6X/yMOI8Z2UAY+OCEN89VcaGg7C/qi+X/SeBUVMcNeYmHdOtXDHAyuIsk0Atw/DlGqz/xM+XM/0cc5GLCVe7aNXZQtBnsvjzALNe9rJnw4ElD7mTBHd9kULr7nq97LogWlXuLZLM/9DPsm/9JLWLWvqdca+nQRvDGxFJ1rYwo0/bTnGJyQ0yrsGurVAoji7qHUDxer24XDVtMvLy8rDb7Q0yKIVCcXSQktKRweknkT7geOJSrMDtdR4vpcm6dYt47cWPkFJljDQlYy9y4vCIWht9CwGmFIxKX8uXs8dW2xfOzmPr9FU8/VER1zzjIK1rle2CELDi+wBv31HSVLdRKxLof7yNASfa0W2C7RlhFn4aIOiNrqK3c9oY08uz30aF0oQSV5iPt5Ww2181sf/476V8/kgpiW11gl5JSU7TvHcT22qcdEvtTVg0ITCRdE3VWLmjajy+bIN1n/jZ/L0fo7xyv6KhvRB1tqapFRlnR/ZKpWtcTduO/Z5b7hv91h+L6TDAym0fJzfYhGrvahVpSlbPDvLRX0sp3qM+VxRHL0rjKxSKhqJ1WjcGDzyZAf2PI65dCXB/ncdLJMuXzeTDl6cSVWaKpmL8Va6YFdaaADTJ8P4bmPn7kGr7Qjv3sP67VTz/WQlXPeUksa0e1fgaIGH+h34++mvzanzNAoMm2ek9zo6mw6aFIZZ+Hajsn9fZZWdC75qJRjUwIc8RYtqWEnKD5VGJUnj37hI+ub+U+NYa/hJJWX7T6Mj2/SyMvsBZ6z5Niwr2TimC9Xuq/pZKd0RY+6GfbTMDmOW3MOtlH7Ne9h2Uxu85xsoFj8bTuode6/ywLkxDIiW8ckMhg09xcNfnKVhsDa/xjYhk2TcBzvj7boqKlcZXKBSHRr0DKOPHj+ftt9/mH//4BxDN+DRNkyeeeILjjjuuwQeoUCgOP9r3szDxGhf9jrejCVg/P8Sc13xsXhLGZnPSr884Bg08mY7tqyxCZEASyumItdUORIwycM0imfflNhU8aWK0OA/p5yQjROxsP12T9Oy8CwDT58efuRb/8lVE9uQAsA34v2PK6HWMjY4DLERCsHJWkLytzWuPJO0W5OB23Hq8HSMskcAxlzg55/44fro7QEKGg1Z2K1pk/w0j0SRLN/iqBU8qCAcgd3PT3uvwsx117teEoFWcxKJBwZYIaz/0sW1WEBkjUbA+EytnvMAc3B6SXXCQ1lplhSazX/Ey6FQHI8+rmWF3sBiRaFXLe/cU4SuWZG+MULhLfaYoFErjKxSK/dF1mJWJ17roNcaGKWH1T0HmvO5j5+oIDruHAf0nMnjgybRp3b3ynEihC6M0Ec1TFNOqV9Mlv32xFRU8aVj2tzCuJ8Yz8Kx4dEvsKhFNk/TsvJOZvw+htLQUkRHV+EZeAQDrgb8NL6P/cXba9rYQ9JpkTA9StLt5tVWbXjq3vpdMSgedSDj6JBx7mYspD5nM/EOANlucJNosWLwS9mMBJ3RYtM5bFTzZi6BPNrnGHzXFWWl9VRuaELRJhPV7JIUbwqx938eOuaGYt1kfjR+fqnHz24l0Hmw7aPvcklyTGS94Oekmd3S9oAE1flm+yQd/LiHok+xaE6E0zyQXZcerUCgOnXoHUJ544gkmTpzI4sWLCYVC3HvvvaxatYqCggJ+++23xhijQqE4jBg5xcEVzyQgTdCtUTE09EwHI85xsvqDwbi2X4fNVlvGjKBs8Wkkn/Zyrdc1IlFxuma2KtlvKAZOsnPCjW66j4yWrW9cEGLmiz5WzgwibFbsfXrgHNgPW7dO2FrNRIjcOq+nSYPCD78kuGEzmDUVupSwbm6IdXNbxmsoBcgh7cERvf+K9ytEm66f+ryLrTdpBDeB6RWU/gJx42tvGAnRCpRFnzVNU/j9kdjTQu8znFFj4zoQQrDyxVIypwX2N3c8YGxOwZ2fJUGSteJBDvhc05AU7jYIlEra97Uy+S/xhzyefSd3O1dHePv2YnatbdmWEgpFU6M0vkKhqIvjb3Ax5f/iqy3cjr7AyZiLXKx66xgSCi7DYrHVPFFqlC05lYSJH9R6XSMiyVoUZnum+l5uKEac6+D46110HGhFmrBmTpCZL/pYPy+EcNhx9O+FM70vts4dsHq+AuruRRgJB3j33XfJysriBlmzYkOa0cSoprCnPRAccYLbP0nGkxz1lbLspfFdCRpnvuZi81UakWyI7BH4loMzPRoo2RcpJYEyyYofm6Yp/P5olW6l24n2GrbI+6JrggX/V8y2Xxpu3uVOEvzp22QS20UfvD7BE9OQ5GRFEELQuoeF8x9ueI2ftTjM27cVk79dBUwUCkXDU+8ASr9+/cjIyOCFF15A13W8Xi/nnnsut956K23btm2MMSoUisOEtG46lz+dgNCql4FXTLL6Xbyc3I92Et7do9bzN/zkRstNY8SVOZWTs4qG24W7DJ6/pFD1JmggzrjXw2l3ejAisvK16j7SRq+xdmZ83YZ5W8YhrFV+wDuyW9GxTV7MJpFGRJK1wEdw3c4mGX+DkOoBVy0TfaINNKUJSReY7HksOknIe03DPcJEOKs3jKwQ71//u4yy/MZ/g1rs0QCPr1hSrRhLQJuRNnpf4CRtsA1bsthv7MKISDb+EGyQ4Immw+n3eDjhRvdBWW1VVIbEp+oktjn08UDUnktoghkvlLFzTYTd6yJqgUahiIHS+AqFIhZdh1mZ8n/RBc+9s951a7QX3oCr5pHz9ukYRa1rPT/zi2TiCxIZeG4RRliiW6s0/u71EV65vqgpbuOo4JIn4jn2Mlf0+dUEaNB3op0BJzr44uPOrMgZhbBULQNt25NKQpwXvQ6NP312Hps2ZTfVLRwyYy50Et9Kq7V6WeiADZLOluS+HN2f84JGp+dMJLLaHLZC4097oIRwE+RIORwCl0PgL5bV5rxCg/bj7PQ630lKXyt6kkBSd55U0GuyvYGS1ix2OOfvcYy70lUtGHWgGBGJr8gkrVu9lx9jUmED9sOzZeRuibA9I9Li++0oFIrDm4P6BGvTpg0PP/xwQ49FoVAc5oy7MuqdHisbRRoa7sGzKNorgFLmLSRj5SxWZMwgv2AHAD+8YWHc5U7a9bUQKIt6l+7tV6s4NLqPsnLandHssWqT4PKfTzpzD9s+K2ZnTqvKfUtW92TMoDVIWXtBgW4RzHnV17gDrydCQKvOOroN8rYaRPZJijPi4xHlC+y1nm+JVpzseQwKQxEylpWRf0aQc/8ZR+9jqvoBlOaafPtUGb++3bgzqw4DLJxyu4dBp9jRLQJ/icncd/3MeLGM1JF2ek1xEt+56ms9p1jSo3XsSY4Rkaz4PoC/pGGCPlc9H8+wyc6DstqSMhowdcQBkgaz6yrKNpn2QAnLvmkZGZEKRUtHaXyFQlEbE691xbQMitpECdwDZ1Pyy0WV24tLcliROZMVGTMoLsmBj6DzVAvHXOYirZuOt1Cy5MsAK34IYDR+z+2jgiGn2zn2suh8rLZktsnnb2X7BwMpLKlqpL14ZS8G994c85q6RfDCG0WNM+CDRGiQ2iXauDxvq1Hj/TPizNr7g1Ser0PccZLclyEvGGbFL2X4zw5z3qNxdBlalVxVsMPgi0fLWPJl405Cjxnp4K+3J3PyRBeaJijNN/jlTT8/veal/UQHvc5z4m5bVXKyp0jSuVXsru1GJNqcvSFcr4WAW95NpNcYe619cvaHaUY/NzwpWvn1Gkbj520z+PAvJaxtwAobhUKhqIuDCqD8+uuvvPzyy2RlZfHJJ5/Qvn173nnnHbp27cqxxx7b0GNUKBSHAcnJ7Rl6kgvdUhrzGKGb2NuvwzQNNm5azPKM6WzMWoRpVi+z3b0uwsd/j30dxaEx8erYk2AAwxQM77++WgClIM/Kp2934LwrdmAaVedWXGfG/8paTNk+wDGXOpn0RzetygMK/lKTue/4+f7JMjrodtIT3fh2WHF3rPs6wib5fHse23zl91YIz04pJLWLTlo3nYBXsnlxGLORK8V7H2vj1veSEFrVJNgZr3HCjS7GXu1i2TaT8D5jCBmwJVfSNa3m62xEJOGA5Ot/123ZcCB0GWLlgn/G0WVw7dU8dSFNCeX+3EKUT6oOYV5lmpJNC8PMfcdHcbbJhvmhBpk8KhRHC0rjKxSKfUlL7cqAiSa6JbbOE5qJrcM6IpEw6zbMZ0XGdDZvXVGjb+HWFRG2rmjexuJHMhOvc1dW9tSKFAzrt7FaQ/gdW118+3Eap1+QU21+UPHzpw+VsHhFy9D4QsBxN7g48UY3ieUBhbICkzmveZn5vJfuDhcDEl20SbJEm9nXgWmTfLwtt6p34XL49+kFtOml06qjhbJCk63Lwo3ufjDkDDvPvdQaKansBRKXonPqnW6OvdHFiu0SY58x+EKwo8CkfZKoEZCoqPaY/j/vIY+t9zgbF/4znjY96r9sWKHxKzjUwImUkszpQZZ8FaBgh8GmhSrqqlAompZ6fxJ++umnXH755Vx66aUsXbqUYDD6ZVpaWso///lPvvvuuwYfpEKhaD50K5iR2pvLmYYTf/FEvAWnccv1g3A7HwbqDnwEg37+++JVlJUVNMp4j2Y8KYLxV7oYdYETd6JG/naDX9/28ftHfiIh0NwuHAN60218IboldiaVrkk6tM5HmibBjVsIZKwmsC6LnEiErI+sHH+DiwEnRL13s5aEmfOqj8wZLWNiBXDWXz1M+qMH06x60zrjyoMN493svEtDhgTBzSbuURJieAibZrTBeGXwZC9ytxjkbmkaf13NAle/kICmU2NCrOkCp0PSLU2wbnf1P1J/vsHXrwXokCyYdIsbd1LVTHLrijAf/KmE7I2Hdg+9j7Vx6/tJ6PvxYd6XSs/i8qDJwc6p9vY+DvklP7/h46vHS1Umq0JxECiNr1AcXehWYn5fOuwe+vebwKD0k2jXtic2yz1A3VqvpDiPZ/93Of6ASoJqaBLbaky42sWIc5zYPYLsjRF+ecvH4s8DmAZoCXE4B/Sh89BdaHpsbadpknap+chIhOD6LPwZawhu2My3psmGj2wcf4OLXsdEE2LW/xbip6nRvikthcv+E8/oC6tXl3iSNU6/28O4sXHsuV8DUxDcYGDvGrtvoRGRbF4Vqgqe7MWe9QZ71jeNxnfECa58NhEhQN9X42uCeDd0agWbc6trfO8eg49f8NOnh87x17lweKo0/ob5Id67p4Si3YeWQTT0LDvXvJBYL40uyxcMGlrj+0tMZr7k5YdnvMrOW6FQNBv1DqA88sgjvPTSS1xxxRV8+OGHldvHjh2rSv4ViiME3Qrjr3Qx8VoXqV0sGBFJ5owg05/3smVpmA7t+zIo/SR2rxmHNF2V5wW3DcCath2h1S7YjLBk+Y9FlJWpzLOGJrWLzl1fJhOXolUusjs8gov/Fc+YK1N4673hiA5dEJqGwddA3aXooSI/uU+9jOmrbku1dXmYN24pbqzbOGTa9rYw6Y9RezJNqxlscPWDxMmSwmmC4m8EyRfHVuECmPN689uSDTzZTnxq7AiFJgRtEmBjtsQwoXhzhPWf+Nj2UxAzDGuBOVO9dB9lwxknyN5ksHvdoXkECw1OusXN5L946l3OLxto5mNEJEGv5NP/K6F4j0HWojCBMjWrUigOFqXxFYojH5tTcNz1LsZf5SKprU4kJFn6dYAZ//Oyc41Bl84DGZx+Er17jcVqrbIrDWztj6vfvNgaPyJZ/F0O/sChV7YqqtMx3cId05KxuURldUiXIVa6DU9kxOU2PvpyJJaOnQAw5CdA7MV/0wT/7kJynnwZGaweEFs/L9SigiX70vtYG2MuctW6T2iChGPAO1FS+pOg6CuNhNNiBxB0i+CXN5tf448814HVEdu6VghB++RoRbkECtaGWfexn52/BpEmbAR+/G8ZPUfbsDoEu9ZGyN18aMEf3Qpn/MnDybe6D8lS91AqToyIpCzf5LOHSynNM9m0MKSsvBUKRbNT7wDKunXrGD9+fI3t8fHxFBUVNcSYFApFM6Jb4ea3k+gzvsqOR7cI0k+yM2iSg20fn491zykANaxxfJkT8Az9ESnMGtkmUkqEBrNfa36xeiRy/auJeJK1aovZFT937mtw6sUF/PhbNwDWbelIcsKamA3hTUOy7LOiGsGTloIQ4EwQhAOyhpg+9jJnnfZkAIlnSQqnQXi3IO8VSL2RanYH0oxOUtbMCfLb+837HOgO6H+WA9OUNQJCe6NpAt/GMAumesleVDOdNBKCdb823KT4+lcSGXSqvd6To72zyeDQJlebl4Z5/55i9mxomixBheJIR2l8heLIxu4S3PFpEh3TrZX2RhabYNhZDoZNdrHj/auxFh5T67ne5Sfi6vdbrb3wTFNiGvDrO0rjNzSaDje9mVQteBLdHv2574gQEylh7tLo9nWbO5Dea0vMhvACyYpP82sET1oKQgNXgiDokzV6Fx57ed0aXxrRJKnSnyCwVrD7bWh7RXWNb5oSIWDBtADLv2ve58DqFvQ93bHfZvBWXZC/NMiKt/3kZdbU+GE/rJ7dMBpf0+H2T5LoPsJW7+DJvhr/UM5dNzfEe3cXU7hL+fAqFIqWQ70DKG3btmXjxo106dKl2va5c+fSrVu3hhqXQqFoJo671kWf8bYai7W6RSAldJryOXteORYZ9NQ4t2SPzsb/DGbU7YsRenUPXSHg7TuK2bn60DLfj1ZSOun0m2hDtwq2Lg+zeUmVgO423EqH/taY52qaZGjfTcxeOIhQ2MriVT0ZOWAdYKDt4w9sGtHeGC1xEmxzCk661c34K53EtdKRpmT1nCA/POtly6Iw3T1O0vs56wyeCA2s7WCnL8iIS/OJ61qKWOFic6gV3UdEg4ZFe0zmvOZj1lQvZiO+XT0pGmMuctK+n4WwX7LihyCrfopmlLnSNLqf7aTbaQ5ad9EPqPz998dKyclq3GBCQhuNm99KotPA2O+3WBzKxKqCue/6WDMnyO4NkSazV1AojhaUxlcojmxOu9tDhwHWGpWjukUgTeh4wUfseXUkGDW/4wuyHGT9rx8jb1mFKatrfNOAV64tonCnWuw8GNr00uk11o4QsGlhiB2rqsRn+sl2ktrVVYUMIwes47dl/ZBSY0FmH9J7bcE0qaHxjYjEV2yycFrLS5ByJQom/dHDsZc5ccZrmEZUF3//TBl7Vhn0inPSu5+jbo2vg60TbPUGyCzysvnPAYb+7uCkW9x0HBB9T+dtMZj1spe57zTuc5DULqrx07pbCJZFq7zWzY0GOTwddHqe46TLJAdJXbQD6v037x+l+Esat8o6rZvOLe8mkdb1IPqdHKLGF0Iw86UyshaH2bEyQt5WpfEVCkXLo96fjjfeeCO33347r7/+OkIIdu3axfz587nnnnt44IEHGmOMCoWiCZl4rRsRQ8kJAVI3cPWbh3fZyeVbDRxxC3jnrZ/YsGkRphnhu480xl3hou/EaPbKhnkhfnnLd8glxUcjUteQfdN4eH40YCWJVhvsWBXmtZtLKDTb0feKZExzd42J0t5YLQZpyUVs25bAnhVbeXmBxnWPhbG7BLL8wkJA0Ct54YpCive0rEmwzSm487No1mTFxF9ogj7j7fSbYGfLQ4LQrzo2v4k0JKKOnhyBMpNp2/M4Mb3cozvfy1OXatjdAosNvIWNbwM16nwHlz4Z7WsiJSDhmEtdZG+O8OuvYZKHWBHl95lXKunROvaLK01Jzmaj0YMnrXvq/OnrFJzxBzdBOpiJlWlEK9ciQfjmyTJmNEBDTIVCUTtK4ysURy4WWzSDP9YCtNAkwunF2WMJ/nWjATCMMOs2/M7yjBls3rIMKU2+/0Bn/JUueo61IU3Jmjkhfn3Hp4InB4EnRePq/yXQd4K9sm+fpgk2LQzx+q2l+Nyd6HOxG8PIRddja1OPK0iCx0dBjoXN07fz5mLBFQ+bYCmfu8loApG30OS5CwtbnN2pO1nwp69TSOmkV74/NV0wcJKdgSfZ2XqvILxcR/MaSJM6m8MXFkX4Ykd+5e+LPw+w+PMAjjiBpoOvqPHv/fgbXZx7f1xVrw4J465wsX1NmN+XRWg1uMrlIa9E0ikl9g0ZEUnW4nCjB0+6Drdw28fJ2BxNq/E1XRAoM/n0oVJ+e6/lBfYUCoVib+odQLn33nspLi7muOOOIxAIMH78eOx2O/fccw9/+MMfGmOMCoWiCbDbXAwaegzJHTLrPlAKrKnbyS/YSdd+3+BO+gHdms+6DXGVhxTuMvnq8TK+eryRB32EIwE5qC0kOCuFaYU8bdvHyp9+bMtLn5yKpd02ELv3e72SGfPI+XorRCIUA3+bLhh1vpOeY2xICRvmhVgwzU+gtGVNrAAm3eauFjypoCJrsvPfYNN5ktLZgvgTYo/fiEgWfla7QA96JcEmWJ/vOcbGFc8kVDZX3JvULjqntNVZlFW1EOEPQU6xSWq8qHWCIjTB9083ruf4kDPsXPNSIpp2aLZbB0pFluTsqT6Ksk2Wfxdoke9LheJIQml8heLIxOWMZ8yJY3DGrajzOGnoWFO3s+XX1izPmM7K1XPw+6v3LczdbPDpQ6pJ/KFidcAdnybRunt0OWbvyv8uw2z8aWZHXv70VPSU1UDufq9X9OV0cuZtB8NgCbDuW42xFzvpMsSKEZGsnh1i8Zd+wi1wjfqsv8ZVC55UUKHxOz0Im6ZISmcJnANja0HTkPweo7qmqTTkkDPsTHkovtZ97ftYOKGjhRXbqjR+sR+KfJJ4Z7Sn4d5IKdE0+OGZxtX44650ctE/42udlzQGRkRStNvgl7f8FO02WPF9kJBfaXyFQtHyqVcAxTAM5s6dy913383f/vY3Vq9ejWma9OvXD4+npp2PQqFofpI76Bx7mZO2vS2E/JKMH4Is/z6AEQYQdOk8kEHpJ9Gn1xisDh24qc7rSSlZt3YJr7zyGS+9pyZQDUGbnjqdB1sxIrD+txAlOeXCOsUFibU3S9R1cNjDjEpfR8b6ruzPptZbZJL17SbYy5LKXyKZ85qPOS2kL43NKUjtohMJS3I2GZWZW5oezdyK1axcaIAd4k+UFH0jCGwAe1cQ+3zDGRFJJCj5aWrz3u+k29yYJrVmgWpC4HFAsgcK9pov/fRlgKF9LfQaYcMIR5+Yigy8Lx4tZeGnjdNZUQg4/5E4JlztatRJVUVjedOIPi9Fuw3+e0EhuVtU1ZpC0RQojV+TNzh6m2G/jNJ3jUlDPb+9e1i57tIEena1Ulxq8slXZXw3yxvVGEJnQtcRXDjwdE7sMRZHQilQdwDFxOT9pT9w8xvPNcj4mouW9P4dPMDOoH42/AHJjF98FBZFNf7VZ8fTtpelVm2l65AQ72NIn01s3tmGY4eujnl905Rs3hbm4bkbqioeAPLhqeeLG/p2gIN7fuM8Gl07WfD5JRs3h6tt/8+UtDoqo8CSBJ5joHiGIPkSid5Kou1zfCQiKSw2uP7tXHJpPu24/K4kDEOi1zJn0YQg2QMeB5SVy3bDkLz8QSmTRtsY3N9BKCwRRO3XDANuvjeHN38uqXGthsBqhbefa835k+OaRONHDLBaBKs3hDjlop3syWme16klfT4ciQh3YnMPQaFoNOoVQNF1nUmTJrFmzRqSk5MZPnx4Y41LoVA0ABOvcTHlH3FIM7oIbRow4hwneZsl8/51DD3ankFiQuuqEwwIbO2LveM6hFZ7Kb6mS+Z/vqeJ7uDIJqmdxpX/TaDXMfbKbWZEsmCanw//VkpZq7Y4a/EwrkDTJIN6ZzFrwRCydrSmc7ucWptGSlMy+xUvkYbrId6g2N2CyX/xMPYSJ3ZX9Gbzt0f48TkvC98LMKSrC09yHfX6ABGwdYXtJSHmXObjhGcd9Bhtw4hIpASLVVCaazL12qJmXZS32KHvBFudExVTSlrFCbKzDbb8GGDjFwHKdhr8AnQebGX42Q6c8YK8rQbzP/I3mt2aJ0Xjto+SaN+v9gl+QyKEYMuyEDmbDTKnB1n+XUWQV6FQNAVK4ysUhxcP/SmZ++9KIRyRWPToYutlU+JZucrkq2cmcGqnM2gd16ryeLMsiXBeOyzJuxExGozruuS1z7Y11S0c0fTpaeXN/7ZhxGBH5bZgSPLSW0X85ZECrr8iDSlFnT3uBvXO4uVPTiM7P4FWSSW1anxNEzz5QmH14EkLIiVZ47G/tuLSKXE47FEtv3ZjiIefzOfHb/zcmp5UuT0WMgLWLpI53/l4+MJS/vS/eAYNcBAuTyiyWgVbtoc5+6rd5OY3n8bv1MFCel97ncdUaPxdORG+/aaEr78uISfH4K/AhDFOzjnNg8ctWL0+xFsfl5Bf0Dgav1MHCz992oEuHZtG4/+6wMfmrRE+/66Mb2d6MVR+lEKhOAypt4VXeno6WVlZdO3atTHGo1AoGogBJ9i54NHyEuJyXaqX/8WndNY59dHN5L6TWuO8ssWnYe+0JuqXu4+eMiKSnCyDVT8FG3HkRwfuJMHdX6WQsE9vC80iGHWBi7QxndljanTXsuu8jtMeIrRjN2/9DW64L0L7Pnqlp6wRluhWweIvA/zwbMvsHWF1wh3TkugwwFot+yy5vc4l/07gpEEJFH2gAXVPIKSQrMz28dmOaJbWinN8dB5kod/xdiw2wbYVYTJnBDEbUbB7UgQTrnYz5iInnmSN4myDue/6+fUtH6YGXU5x0Pts5/4nKhKK1kX45tJCIr7qM+Kty8NsXd74kYX0k+1c93Ii1oP0Qj5QjEi0Ee3Pb3r56D6VEaZQNCdK4ysUhwdXXRjP/XelANGMbgBLucbv39dCzwezyZ/Wap+zBKULzyD5tKm1XjMckcxb6GfxCqXxD5VOHSz8+mVH4uKqa3y7TfDHa5OYcGw67VuXoGmxKwuEAJcjyJYtW7npzybPPBimUwc9Wl2kC8JhidUq+O+rhUx9p3EqFA6V5CSNed90pHNHa+X7FKBXNyvvv9SWXc9BYMGBafyXdxXw0M5ob5MPTipm3GgHxx3jQtNg3qIAM372NWoQqX1bC7ddl8hlU+JIiNPYvC3MS28X8+p7JbjdGqedHseFUxL2ex0pYcliH1fcvIdgsPqAf57v5+f5je+xdtVFcbz0ROtqr0ljEI5IrBbBQ0/k84//FDTqYykUCkVTUO8AyqOPPso999zDP/7xD4YNG4bb7a62Pz6+ds9HhULRtJx8m7tycXJfhGZiTdmNvctKglsGVm43jAgrZhYSWZ/EiX8qqAygSBm11cnZbPDcRQVI1SfygPGkCLoOtYGALUvDlOZFn7wJV7tIbKPVakuladC9cy4btrXFMEWtGWcA0oTC3QYFr30AwL/mwODTHYw8z0FcikbOZoN57/tZN7eFlp4AE65y1drbRJR7kqVeCmUzwLcCnAOI2RxeswgWfld90rF1RYStKyK1n9DApHTUufvLZOLTql7TVp10zvqrh+NucbNip4lZvj0QltgtdfsMr/0hUCN40hQIAde8lMDQMx2NlpEmTYkkaiG3bUWYOa/7yJyuFmwUiuZGafzqXI0HG427wNSS2NvW5Ebi6jhScTA05PP70O0pSFNWaqW9EZqJvcN6rGlbCOd0qdweDgdZ+bkPW5aHCbeUYprlDcZN0K2CHRlhvrmu9LB97fd+fqW3qEkeU5q5YKwGNLAMQojoZ6TpfxzCX0AtVlKaBoP77mDrrlRMU6DF0vhS4HJ3580Xni3/3Q/hHxHhGSDLsDq7IWzncMddA7njrka6wb3Y25bnQJ9fM/AMhD5g3wBJRb+XtrfAptmS0Hawto/dHF7TBQ889hMP/rtz/QfeAEhjA9J7I+Cj4jXt19vBs484ePzBHizJKiFiGmgCIobEEsNyGEDXBOef+x8uuPDUatsP5vmtL1KGkb7bwFjcKNevQgM8WB2DEbaLePgfI3j4H438kPuhKZ7fo5nD7fktKSkhoW2n5h6G4jCk3gGUU045BYDJkydXW1yRUiKEwFD1eApFs+NOcNBjpK3OY6Sh4+iaQXDLQLJzNrMicwYrV83GV94scs5HGmMudtK+j4VQADJ+DJA5vXEz+I8k7C7BlH/EMfp8J7o1+llpRCSLvwjw0V9LGHt5HFqMYACAYQo0YcYMnkD0c/fXN6oqSyIhWPx5gMWfN04/jIPFlSgYcIIdu1uQvclgw7xQZZbY+CtdddoXyAgknCHJf0ejwxNm5XfN3hgRyZalYTYtbD7Pp6v+l0BcavWAmNAEAohPgj66xuqd0ZveWSDpllb7TUtTYobh94+bvsunK0Hw4LxWeJK0RgueGBEJEl68qpDVP7XcwJ5CcTSiNL5C0fJp19NDWte6p/DS1LB3zSCc04Udu9aSkTGDVWt/JRj0wjcw622dsZc4SeumEyiVLP0mwNqfQy3WBqqlIc0iZOBfEPmJquCAFWk9G6y3Yoa+RhOxPy8NUxAIWWMGTwCEkFgcU/b63Qm2sxG2sxvkHhoKaeZBZD4QBK0n6AMRQiBlBEJfsL/qkoRTIO8tQbu/x3ouNLBMROjNFDyRJtJ3L+Cl+r1IhACntZguqZKN2WBK2FUk6ZgcK0lKAB6wHN8kY98bM7ITfBcCjZmwpAMWhOslhGVAIz6OQqFQNA/1DqDMnj27McahUCgOAM0CAyfZ6TbMhmlI1vwcqlZd0DqtG0MGncKgYSOBv+znapK8wizeevN29mRvrLG3ONvkh2dapu1TS0ezwK3vJdFtRPXKCt0iGHGOkw7HtCGuVRm1ZaZVHqtJdN1k7fo29O65p1Y7teyNEX55q2U0gK8NocHkv3g44UY3FpuozJbM2xbhoztKca6zktJRrzWDshIdrO0kGbODZPw5zKRHXGi6rKyC0q2CrcvCvHRVYdPcVC2072uh+4jYAUtNCNLiYeMeSciA7QWSeA1aRd03Ku/fiEQnY2/fUYy3sGlXMRxxgsczUrHY9tNr5mAo9wM0TcmqWUG+f8bbJDZkCoWifiiNr1A0HxY7DDndQcd0K5GQJHN6kM1Lqr4r27frw9DBpzBwbE9gP+ncEnbtWcn7r35HXv72Grvztxt8/a+yBr6DowMpfUjfjWBupfqCehgZmsa2rXPp3K7uBBEBhMMWtmd3pUPaFoTYV/NpoA8E66QGHn3DIWUIGXgSwl9S7XnQuhIpu53i7xaTPGU/80gJtg4akcJJhHMdWFO/KN9RMS8wQB+NcD7U4OM/YIxFIHfE3C2EoF0SZOVITAlbciWt4pw4raF9XlcdEAjXPxGi7j4pDY0Z2QG+cxr5UXSwnICwX4PQuzfyYykUCkXzUO8AyoQJExpjHAqFYj90GmThpjeTSGyjEylvmnfyHzzsWmsw55/96dlmMu3b9Y4eLCVGaRKapzB2dr8wmPd9Bnuymz7T/UhCCNBtENkroWfoGdEG5rWh6dCuTTG+gB2LbsR8fQwD2srtOHZsB0sy3uQkXInRxe1ISLLocz/THiwl6G256YJT/i+Oide4KgMEFf+ntNe5+aMktt2qYfpNdHfsa0hDsn5PkG93FcE78PN3ZYw+30mbXhZCPsmyb4NsmN+4lQxp3XWOu9bF4NMc0X4qmWF+ecPHih+CWFyCYVe69nsNIQQuC2z4McCmL/18tjHCxGtdTLzGTXIHHdOUrJ4dZPrz3mappPnTN8mNEzwxJUQMHjuziOwNBiF/y32/KhRHO0rjKxTNQ+9jbVw3NRF3kkYkFE2mOOU2D5uXRJj/1DD6djmT1mnlvYl8YcyQA80Wu9pY6CY/f72YvHxlj3koSGkAkeoL3qEvwNwM1NQzQkg6t9tNOKJjtdRRsScEvXqOwh53BzL4EoSmARXzMTtYz0I4/ogQ1oa7mQZG+u+HyGz2fR5kZDPIOyj+VpB0TmzrXQA0jfhTzyXponuj55rXQvgbpLkDRBzCchLo/Ru1ybk01iGDH4Exl2jAZiDCdhHCMopwuIiy4veIt9bsC7o3uibwOOx44k6jQ+vzcbs6Qeg9ZGgayAKiwYXjEParEHrvRruXmPiuaaQL60BrcP0HobdHCEcjPY5CoVC0DOodQMnIyKh1uxACh8NBp06dsNubNqquUBzpJLXXuP2TZGzO8kaR1ioV17aXlQueyyP3nS7IynYPgrLlJxJ/7DRqE/imIQkFJAs/bVlWT4cTHfpbOPkPbgaf7sBiFRTtNvjlLR8/TfUx9hIXpkFMiy4pIRzRKxLza0XXwZKTF83B2lLAX44L02mgFd0q2LU23OQVCvUluYNeLXiyN6KiR8jVJqUzBQmnS0SMbyPNIljweVWQryxfMvOlpqu66TvRxk1vJqHpVPYT6jXWRt/xdtauCLM9IujQ5sACD/MfLWHl91WLGTNf9DHzRR9WJxhhMJumXUsN4lI12vSstxyISaXNmmnCnlLE5gK2Zzgb7PoKhaJxUBpfoWh62vWxcMu7SejlX8MWW5Vu6jLERvtnCsj7oHOVnDes+DLH4x4yE6HVtEcyDUlpnql6ix0CMrICGXoTIvMAEynaI2wXgO18jODnCClj6nfTFJR6nSTGeWNadGnCxO4+DyFsCMdtSPv1YKwFJOi9EMLTWLfWIEhjVbl9WU2EBpodks6TlM0DzxhianyhmQj3GXv9ngb2a5qs85QM/4j0P0C04qU84BWZj4zMJaesK6u2b6VjcoT4NAH7GdXgvi9itQ2u2mC/HmzXAQHAioj1JDQyZmQd0BhV+k6wnomwX4/QEhvh+gqFQtHyqPcn+eDBg+vMArBarVx44YW8/PLLOBwqCq1QNAQTr3Zhc4qYDeH1+DycvRfiWzWucnvpkuOIJM8nue8OJLKyYZ9RXr3y+o3FLbp6oSXTd4KNm99OQmhVi+oJbTTO+FMcQy5Kw5Wooemxy9Y1LTp5Kih0kZToQ98n0GKakowfgwyxVwUOIiHIWtyybI/cSYIxFzrpPsqGlLD+txALPvHjL5GMOMcRDRDFOFfo4B4FW2+C+JMAISsDKxUYEcn2zDCrfmqeRQBnvOCG1xLRLdSwYgPoM8iKudOk0Ctr7c2yN0GvyYafa6+UCTdzEdjo8xumYbxpRj9PdqwM8+Yfinnw4WKEqT5jFIrDBaXxFYqm58Sb3VFdWEvjaaGZ2NK2Y++cSXDLoMrtRb+djpG8lLjOeQhkNStQIwyvXF+kehYeJDI8Hen/O9FG2OUBKrkLM/AM2bu/JNG9E0cdcWRNk4TCFgJBJw5HAE3U0gPEem41myMhnGAZ0qD3cahIMw/CXyKN1YDOdZfG8/5npfj8Ehn4DmlqtQbwIBowiT8Jtt0u8IyO2u7WbBCvgWUsQu/X2LdSK9LchfQ/SM0eLdE/nFTPZpJcBvll0L31fhKlRCss1po9P6Lfp82cQBT+rIEuJAAJ2jBw/g2hpTW5FZlCoVA0N/X26/j888/p2bMnU6dOZfny5SxbtoypU6fSu3dv3n//fV577TV++ukn/v73vzfGeBWKo5IR57prDZ5UIgWOXgsBKCnN45e57/H8Czfy4CmL+fC+YrI3GkhTEvJLlnwZ4F+n5rNylspMOxisDrjmpcRqFQkQFcmaDu07BbDoErOOnommCYVb/Px7whYyfghULjwDhPyS2a/4eO3GoibLwDoY+oy38cjiVM6+P46BJ9sZOMnO+Q/H8ejiVCafmMCobnEIs+47EBqs2xPgjUuLKdoTfcKMsIw2GicakHn+ksLKfieNgQRkgoPjb3Ax/ioXqV2rolmjL3Bic4haFzUgWmnRMVkQjEB2cTSIUhumKZnzuo+gr2UGE+yeQ3unSRl9zbI3RJj2QClPnVXAng2GCp4oFIcZSuMrFE3PsMkOdGvs72FpaDh7LQagsHA3s+a8wbPP3sgDJ6zki3+UkLc9uuAbKDOZ94Gff56UR9ailpVwc7ggzSKk/yGi6nDvCJRECEnrpCwMUyOG3APAlILk5L64Uz9Es4zYZ68LYb8B4fhzg4+9IZHhGciyM5HBqRD5BSJzeOmJNDYv6MoTY1tT+tOX7E+ca3ZwDz2bSMmfEXpi+VYLlctPlokI5z8b8zaiDeAjC5DBqJ2WNPdU7Qt9jqzFpaECU0o6JGt4g1BYJjHreNGF7fJmqzDZPw3hNmEBrRfC8TeE+3k0vaMKnigUiqOSen/SP/roozz77LNMmlTV1GzgwIF06NCB+++/n4ULF+J2u7n77rt58sknG3SwCsWRSEonnd7H2BA6ZC0Ks3tdlY9Pm9Y9GDl8MvFJn1PljVsToUlCMo+Ppv0fG7MWI/cStb++7efXt1Wfk/qiWaDfRDtJ7TTK8k1W/hQk7IchZzhwJ8aOPWuaxOkIotURnhZCMu+dEsryTV65rojEthod062YEcmmRWECpS174Tmlk87NbyWhW6msbKqY+ttdgpOnOsn/QIBe930YYckPq4sIeiVLR/oZcIKdTgOjzVNXzgqyc3XjelpJlxU5oC147Jw7OFouo2nxrPghwOf/KWPIhc46K/aFEMQ5o31aZn8aZMxIK13SrRgRiW4RGGGJbhUs+ybA1/9uuc1aV88Jcdqd9TtHSgky2tdm4bQA791TTKRxW9EoFIpGRml8haJhadNLp/uIaJXuzHkBNm2pCmx07NCfUSPPwOp4q+6LaCZlwR289+Hf2Lx1BXtb8858ydektqZHClIGIfJbtD+FSI1WQggrhL9GEqkzgUkTJpLY8lATErvrHITWFuF+PtrPw9gEwgb6kBbfJ0Iaa8orcCRV77VolXVKss5tr8ZTMj1Ym0P0PrhIu/svCKEh5VkQ+RlpZEXv3zIeoXdpzNtAGquQvr+C3EU0aCOBfyMtp1JqnIUe+hqXNXYQSBOCBJdEEzZyfOOIc29EYwdVlUk6YID1PLBd1Kj3ckjoIyD83UGcWP4Ot16AcNyJqLOZjUKhUBwd1DuAkpmZSefOnWts79y5M5mZmUDUAmD37t2HPjqF4gjGmSC4/OkEBk2yIzRRaQG0YX6IX//Ti/6dz6Vjh/4ARAp/x9p6MyKGl64Rkayct4UNm0qa8haOWIacbueix+OJa6Ujzag1QqDU5KunAqQNScMwvOh1BAdsVoPs/HhaJZbUsOcyIpLsTREWfFKVEVS026Rod8usCHImCKQBgbKq+51wtQvNEsNuQgdsoLlkdH4RI5BkRCRLvgpU2shJEzJnBMmc0TTPQ0IbDTm0I1iiA9z7XtJPttNlvB1/WNY5SYZoIOGbi/MJ5EvmatBvoo1R5zuJT9Mo2GEy/0MfG+a37EzQrIVhSvMNPMnafq28Kj6nCncazPvAz6LPAuRuUT4hCsWRgNL4CkXDkNBa46rnE+h9rL2yOvUykcD3s3xM+18/ru11MW3b9AAgUvwNenx+7J4ahmTpr6vZvLXlJmIcTsjQ58jAf4G9n894/OIPFBfMIzWhNrupKEKA0xGmsMRDgseHVsPCSgN9IFiqLJWF1gG0Dg19G4dM9H1ZQrQ/h6tqe/B9osq3ZnBB6KAngumL3dckig62sxHlT6QQVrCeiLA23PjrQhqbkd6bgIrMnqp7keHvCJR+i0UHp4U6da/QHBw79Bus1kSkjESDQOEfQJaA1hFhOweh92/cmzlEhPV0ZOCfQD3mIqIT2CYjrJMQWptGG5tCoVAcbtQ7gNKnTx8ef/xxpk6dis1mAyAcDvP444/Tp08fAHbu3Enr1q0bdqQKxRGEboXbPkqmQ39LpW9xhYDrMdJB11dLyX2/C7J8LdmbcRxJk7JiX88imPuuqjJpCNJPtnPd1MTK3yteH0ecxgUPudi0zQMidn+TCqZesovT/6gz+DRHZZWGNCWrZgV5565iQv6WW2UiBBx7uZPjb3TTulv0a2J7ZpgZL3hZ8kWAYac66rSUEzq4h0Hea4LUG2v2BzEikkCZ5JsnGn8xwO4WDD7NTmIbneIck+XfBQiUSo6/3h0NntTS5F7TBAkuKMmXaHVMrIyIZOOCEIH8qiDQqp9CrPrp8CvFePnqQu76PAW0mr1cKhZ/pAmbl4aZ+aKXzOlB5a+uUBxhKI2vUBw6Do/gzs+TSekYzaDZ+zv1lOM8nDgwQu6HnSsdorwZxxN/zDQQMRqOa/Dbe0rjNwQy9GX5YvI+22UJDv7Jbm8aMmE/15DgTHodjafAWLDXHg0sJyOc97VgOyeQMgyhD5GhD0HmRLfpAxG2q5ByFDIwG2GpQ+BJcPSBgo8FyRfU9p7VQaQgbFc0zg3sPRSzCCKzQRaB1gYsxyGEAxl8g2jAoJYgkIDUeMGOfJNEV11JQzq6dSKaNbH8PAtYT0BYT2j4G2lEhBBI5yPg359tnAb6MIT9MtBHVwa/FAqFQlFFvb/d//e//zF58mQ6dOjAwIEDEUKQkZGBYRh88803AGRlZXHLLbc0+GAViiOFIac76Dyo9jQcoZvocQW4B/xC2ZJTAfCvHYW9xwKcXVdWy4oyzWhz+Fkve9myrGVnuR8unPtAHJIqa6p96dg2Fz1GJRBEMwV3romwO6OMV6+HpPal9BhlQwjYtDBM/vaWv+p8+bMJjJriqObx3L6fhWteTOTU0eA5gH6IId3kuccK6b3Rwul3e0hsU1WKs35eiI/+WkLe1sZ9LiZe4+Lsv8dhdYAZidqyXfRYPN88UcqYi521Bk8qkFJis0AoIrHqtWeo6RbBzBf2H0w7HMhaFOFfp+Rz7dREUrvolfcrpaQ42+Tn1338/IavWiWSQqE4slAaX6E4dMZc7KRVZ71WHSk0E2vqDpy9FuJfcwwA3uXHY++2CHubLeztkmMaEk0XfPlYGfnbWr52bOlIGS6vPKmJENHASFpKUZ0aHzSEZRQud1fgeaSxDYyV0ZIVfRhCS22UsTcUUkaQvrvB+J29PbhkJBOMu8h9xUXKFcE6q0uEBrZObbD3+i/CPhcZfJNoJQuAAMsxCMe9CC2lEe9DQujV8kBJhGi5uwG4kLY/IsPTESL234wpJUKAYYJeS+JQ+VEI+8WNcwNNjGY9HlO8CL4HgNzqO0UbsF+GsJ7V4u3lFAqFormpdwBl7NixbNmyhXfffZf169cjpWTKlClccsklxMXFAXD55Zc3+EAViiOJUec7MA3QYtmJComz/1zKlpxKSWkeS5Z9x4r/LeTYawwmXuMiPi16Yt4WgxkveFVmWj0RGvQZZyO1q4VAqUnmjCD+EknHgRZad6/7Y9FmNcgtiCclsRStlkmWpgt+eKaqsqJwp8mizxqigV/TMPg0O6PPj0ZI9p5PVFhctb0SvEvAkhy7fN+ISFYuCJAXDJP3bpj5H/jpMsSK3SPI2WQ0SRDpmEudXPBofOXvenm80uaEcx+Ij9nwvQIhBLop+fwlH2dc5sRVfimhicoeJ589XHJYVpvEYvvKCA+NzcOTImjdw4IRkexcHSGsPl4UiqMCpfEVikNnzIVORB3mn9IUuPr9hn/NMRQW7WHRkq9Z/XwGx9+qMf4KF67yPnu71kX48VkvS746fDRkS8BiARn+BeQeEIlgGYcQTogspGqhvyZCgNsZoqjURZzbHyOQYiLsV1ado3cCvVOD30OjEf4CjPk1Novy6qdW1/oIrAdHT4jV8iISkdi6TkJzdAW6gu3CaBCJEGhdEVoTVCiGXo82uK8kOq+Q0ocI/SumHd7e2Kxu8gIn0to9AwhSFVDSAYlw/L3F23PVB80yHOK/Q5p5SHML4EToPVQzeIVCoagHB1Vf6vF4uOmmmxp6LArFEUNyB40uQ2yYpmTj72HK8qMlxEJo9O45mi69y9D0nJjnCwHYi/j8q3+zZt1czHKvnB+ehenPe0lqp2MaksJdsZvfKWqn9zgblz+dQHL7qv4m4YBk1hsRdgW6AjvqPF9KWDTHTb+eJXRJjzZCr6wKEvDZw6Us+7Zl9jPZm86DrQw/24EzXpC72WD+R35KckzGX+WqDBDUhoyAGarb+1i3CH55q6qpqWlA1uLGqZBq18fCxGtdDDjBjmaBrEVhfnnTx+S/ePZ77r7WYntjRCRrvw3w86OlLHyujNEXOhl0ih2rQ7BtRZhf3/aza23jNrlvLsryJWX5qqJNoTgaURpfoaib1K46ndKtRMKS9fNC+IujC6+aZqF/3/G07rgNocW2KBWaxLDm8NGnD7Nx0yKkjGr5rx6Db58sI7GtTiQYrf5U1I/zTvfw/OOpSP/dRPt4SMBJaeQyNmTlM6TX/q+xNfsk+ndbQnQ+oFO1sK5FF9Utwxpp9A2DlBKMpcjIbJB+hNYNrKcjtERk6GOkFJUBk5onQyQHRJ/Y1xYChO3cym1C2MAytBHupLwRfPBDMBZFN+gjwDoZgm/Ueny0kkiW/1yH1bDQSU25GM1xM9L8A4S/REbmARHQByFs5yG0jg19Oy0CobVCaK2aexgKhUJxWHJQAZR33nmHl19+maysLObPn0/nzp15+umn6datG2eddVZDj1GhOGzwpAgufSKBgeWN4SG6ELvosxDrPhjFsIHnkZzUDs3/PNLMQ9RoPhhFmrA7q5RVa36usc80OCxsoFoiXYdZ+cN7SZUBj4rXyOoQTLrJyrK1tv1eQwjY8vlqvp0VpM94G0POdOBwC7I3Gcz7wEfhzpY94bW7BNe+nMCAEx0Y4fJJhgZn3Ovh53/76TrAVnd/EwtYU2DL6yZdrtGqBVsqfv78kVK2rWj84MKQM+xc82IiQOUY0k/WGHza/kvQhRB1VqHoFsG896OlF/4SyexXfMx+xRfzeIVCoTgSUBpfoaidpPYalz+dQJ9xVRnb4aBk3rshtn83geGDzyE+rhXS+yjS40XEsIKKRCRZK3ezYeOaGvuMMMqu6yA5/UQ3H07du+F1xfPvx2N5BSPU44CuM3jQOaD9BSJzkZGfQYYQeg+wTm5UW6qGQJpFSP9dYGQSDf6AxITg//BnnY29y2bqbG2hRf+V/Z6KZ3Ru+YbovCYclug63HhPDq+/1q6R7wRkaBoy8C+i91H+NxGZgYz8UEd9F9UsaGMFUQQSYTsz+rOWDParEfarG27wCoVCoTgiqXcA5cUXX+SBBx7gjjvu4JFHHsEwol9oSUlJPPPMM2pypThqsbsEd36WQlo3vXJhHqILsaOmOBgy1kf+p61Bgm/lOJw9lsW+mJD89q5arG1oJt/nQWhVdlR7IwQM7r2Z7PxEUpOK0GqZYEhTUlZg/j979x0eRfU1cPx7Z7amJ0DovXcFlaYCYsPeC3bA3rv+7L13X1QUAbtiL1goKgqiSJXeew/p2Tpz3z82AQKpkLJJzud5fEx2Z2dPJiE5d86997D4twBaw5Lfgyz5vWZt4XTpq4l0GRwZ/JvOwtfhmP/FEM4o+fXa1mxND/Hsfbvo/pubIdfE0PYIF1rDihlBJr+Zy5LfKv6aNO3soM+5XhJSDTK3Wiz+LcjwUUmR7+c+/97KKhjSuJz7z1LTWjPjI5/0FRJC1CmS4wtRtLh6Bnd8W4+E1MLJodOtOPoKD/6jQ6T/ELm5nvvf0SQ1Wl3suRwOxfSPZG/MivbMg5FZ9cX1MOzRcQ2ZOV4SYn3FbPGkwGgJRpdIXugchHIOqrR4K5rWOrLyxlqc/4i113Mh3K0noEOgSporphWxR/THrPcShH+OrP6wlwAmP0xO58U305n+j593x1Rs3FiL0OGfQGeCagJmN/A/u9/XAVZkXVEJxZECYduBw7CLXm3jugJlNKuoL0EIIUQdUe4Cymuvvcbbb7/NGWecwdNPP7378cMOO4w77rijQoMToibpP8xLo3aFiycFlKFxN1uOp808/Kt6E1jbHf/qHrhb/bffDDUrrNm4KMzMz2RwdaCUAS6PIpC359ompBp0HFDaPq+atZtSqZ+UiW3rQkUU29Yo4NP/ZWPXgJ2b3DGKTke7cMcqtiwPs+G/MA3bmRx6cvGrM7QNKNBW8XsfA/zzXWQ/7v8mBfhvUuVuV2aYcNHzCfS7ICayYiZ/R4bjro/bvQXbgXIv3gyp8dAoYXdD+ZxdNlPeyuWX12pHc3ghhCgryfGFKNoxV8WQkGoUOUlDGRpv+9nkNF5FaEs7fMv6Ett9Gs6Ga/bP8S3N1D/zWPBz9G/1Gq0MExwuRdC359o26+qgc/uSV5G7nBazFrak/yFLi9jGShHZouuuUm/MRwOtsyA8i0jfkY4osw1Y88BaUOTxKj+3t3JAJRS/Da8yNEbiyfkFpBNRzhN3FyvOHp5UCV+HH+37H4T/YM92aQqw0CV0EirL98gZ9xaEPoPwZApW0aDqo9zDwXlOhcQvhBCibil3AWXNmjUceuih+z3udrvJzZUbTqLu6n+hF0prGtn1T/yrerNl62q+vjaPjmfmctRlXlzeyOvCQc0/X/j4/MFsQtIzstwatjM54YY4DjvDg8OtyE23+fODPCaPDlJ/UEdgR4mv11qRu3YnLz+Zxzn3OmjZ07n7uR1rLL56LDvqB71KwUm3xXHsdTG4Y/ZUgDb8F2LN3yFsSxe5AgcihSdHItj5P3v7FlGssCZ3l12pxb3kJgZ9zvOS0tQkZ5dNQoPI57D/ipnSiifFzVCzLc3OdRYNd/lQu3zolTt5/sUkrCBsWBjCkoUnQog6SHJ8IYo2YJi3xBWu2jKI6TKdzC3tWL92GV9eGuSQy3Lpe54XhyvyOp/PZvQHmdz7RBqX26X3aROFNe/u4IQbY+k51IPpUGRtt/h9XB6/jg9Tf2BHoPjekhDpYZia2pWAeQUe3gB77Z4njbYoz+0ox2GV+jUcLK1DaP+rEPoC2JOsarMntr8BylTFbh2nTHCmRHoZapsitvIyI6s/HIMKv64CC0raWo8OTQSdBqoB2MshPD3/2cJb1ymK32YXSlqFYoDZHcPZE5w90fbtYK8D5QajA6qkJo5CCCFECcr9F6R169bMmzePli1bFnr8xx9/pEuXLhUWmBDRpl5zk0NPceNNMNi+Oszc7wMEfRqlDNq3O4LUlltRRvFVD2Vowq5NvP/xvaxbH5khtHABfP98Nq0OdWKYsP6/ELm7Sk4YRdFa9XJy84RkHC61e5Abm2xw3HVxHH5JLB//eAS2/UORW3MVMJTN1j/XsOp3H8/8Do07OkhuapCTZldJT4+KcPYj8QweGbPfoKJpFwdNOzoprm/k3n59KI++93iITTYIhyIrb0ynInObzevDduHPrpyf0ZNvj2PobbFoOzLQVap8W3IVZd+CkW1ptA0f3pHF7TdEHlNhm1V/S9VECFG3SY4v6qpG7U16nujB6VVsWRZm/o9+wkEwDJMunY4kvv6yEl+vTJs8vZp337uNzVsixy6+E75+IpsWPZxoDQ/PSycrO7r75EWrLse4uGZspIdhQV6YkGpy8h3x9L48ie+n9QJ+KvEcSkGHdv1QzoFoPThy897eCUYqGO2ifuVJZIuuh/JXVBTOw3VwfmSRRWQhTYn8K87G23ki4N/rYAuM5qiY11DKWcKrDzR2C+1/AUITKOjNEvkaDubfg8pfpbL3tTAAF8pz556jjBQwUg7ifYQQQoiIchdQ7rzzTq6//nr8fj9aa/755x8+/vhjnnrqKd55553KiFGIamU64YKnE+h/gRetI03cTSec/yTMeK0VDXwjqJfSFHwPomM2FbOvLthhWLNkE+vWZxR6PJCrWfZnzeqjEW2UghFvJuJwK8x9VlcYJiQm5HFkr0UsX9eMDi03YRTX2DMIs7/ZUwTbsizMlpLHzNWqcUcHTTo6CORplk8PEt/AYPCI/YsnEOn7oil5ay6INET94ctsvv0si16neiL9TWxYOi3A/J8DFbZ9meGAnie46TnUg8urcLoVXYfkb7FWyuCvLKyQZvmMAA6XQft+e7Z1WD07xNePZ7N6VghuOPj3EUKI2kJyfFHXuGMUl72WyCEnebDCGq3B4YysYJ7xcheamZeRmJCKlXcLZkx2seexwrBswXI2b8kq9HhehmbptEiOn3VQN4vrLqcHho9KwjD372FoGNCofibd2q1j47Z6NGmwq5gcX0X2rnL0j3ymFJgdI/9FIa11pPeIvRFUHJiHgbUcwpOKPF6ZRIonpdWAVCIxR9wB3Aihn9DWEsCJchwJjr6o0gYJZY4/AKHJ6PAMIAQ6C6zZ+c9aJb20jEyU8yiwt+X3aCl4+DCU5xaU2b4C3kMIIYQorNwFlCuuuIJwOMxdd91FXl4ew4YNo2nTprzyyitccMEFlRGjENXqgqcT6HeBF2VE9mI18nNLdywMvmcdu75OJ7CuKXkLjyJh4CfFnsdwwF+fSF+TytDpaBf1mhf/68w0NN3arWPcN8fSquk2XGZo9/cR9iwD/+rxbHxZ0b8CqFEHk0teTKR17z2FAX+Ozbp5oWKW5UcoM7KyA130MVZY8/fnPvw5kWvw9wQ/f0+o+L3kkpsY3PhpCo3aObDC+b1mKnjin2HCd8/msnZOiJRmBokNTbK226RtqIiBmxBC1D6S44u6ZuToRDoPikze2HvFa0yiybEPrmDnZ7mEtkHewqOIO+wnlFF0EcR0wMxPJcevDL1O9RCTWPzMGsPQ9Oq8ko8nDuSSU6ei0Zj7Ha7z+5tU/OqKiqbDC9H+x8Fetdej8WC0QWsDpYr+GVRGJMcvfhxggPPs/C2sHOA6u6JT70j81lp03vWgt0fes8ILh5GolftGlNkCbW8AOx2MVJTRqILfSwghhNjjgDaBvPLKK7nyyivZuXMntm2Tmppa0XEJERXqNTfpn1882ZdSkb4m8f2+JrCuG3mLjiKm++84krahzMLJom1pVv4divr+GdEuqbFBXD2DzK022Tv3XOPmh8VjWxQqiuzLNDWhDZt46ZIQZ98coEP/PQ3l0zfbfPdMdqUUCypavRYmd3xbD3ds4Z9JT5xBhwEu0CUPh5QCO6yx7cI3C6ywJm29xTdPFj/D8kB5ExUDLvRy2FleYhIVcSnG7r4/B7tFF0T+fSkjMqPQCkc+/ujOLNbOiWzLtWujza6NMvNTCCFKIzm+qCtaHuKk6xBPkc8pQ6NtTdwR35P+3Y3kzj2OmM4zMGKy9s/xbc28H/ys/le2Aj0YKc1MYpIU6ZssctP3TGZqflgC4bDC4Sh+gpPHHeLfuRv4/ItsHrrN5Ihee31fVXOU5yaUc1AlRl8xtLUMnXc1sO9y72yw55f6eqUiG2PtX2gxIs3m3ZdVYLQR2k6D0Ffo0GSwc4Fd7In/4HLvSEv5vYswBmCgvE+izBYAKKM5GM0P6n2EEEKIsjioLlr169evqDiEiEq9TvWgtSp2ho4yNK5GazDidrF5VToTR8Zw2FU+up/gwsgvulihyKz+z+7LxpbJ7wekzeFOTv9fPO37RlZcaFuzaGqA70aZZDXug+sIwJhT6nl2fT+NjQvDvDwN6rc0adDKxJelWTc/snIj2mhDQWocOt7NGfc5WTglQL/zvbhjVZGFB6VUqSs5wkHNS+ekcezVcfQ80Y1hKnxZNn9+4OPn13LIy6iYFTgOFySkGsTVN7jm3WQSGhqR3QVKafxeHlZYs3ZukMW/Buk6xI3pgFX/hJg2Po/tq+QfmxBCHCjJ8UVt1/t0D1Y4snqkKMqw8bSZj3IEWLdiAz9cEUf/m7bR+eg9E3BCAc208Xl8/XjFTz6pKzoPcnHaPfG07BlZHWKFNfMm+vlutIdguz44u+aijMWlnuebb39kyzaLn6aAnTUX9FZQyZHCQRT2N9E6F0K/oO1VgBflHIz2v0Gk+HCgg5I4jNjn0YFxYP1NZMl5MjjPQbkvQSlvBcXuB70LbW+GvLuA3IOIuTgmyuwPZhsIz4o85DgM5TobZTSp4PcSQgghSlemAsqhhx5a5sRjzpzSb2IKES3a93My+MpYOg5wgYIVM4JMHZ3Hqr9tunYeSL8jE1H8TWn7tf449Wlm/boIgNkzIbmpQeteLmxbs3JmiJy0KLw7X0N0PMrFDR8mFyoMKEPRebCHDgMdjP26ISs3OFEU/7tHa03GVptNi/fM6Nq5zmLnuui9yd7xSBd6QGtwmmBrhlwNx98Qh7Z1iUWIgubrRbHCmtnf+FkzK8zbszJwuMEdq8jL0BVWQPImKE66LY4Bw7x44o38mHSFD16tsCYvw2b8jVnsXGfx40u5FXp+IYSoCyTHF7VVtyFuBl8ZQ+veTmwLFk0NMHV0HpsXGfTodiy9DtMYah4l3fhVSvPJV/ewYvFyAGZPhwatTVp0dxIOapbPCNaIrV+jVa9TPYx4MzGyvWw+06E45GQvnY5zM+bLRixbG+Co3ouKPYdtaTYtDrNl256cXpmtgdaVGPnB0aEpaN8jgI/I7RiNDo4rMYeHkp8DA1xnohy9UY7e+UUOP6gEVHF7+5ZTwwYmD91RD519LFCZuyoYoFJR3v+hDCnmCyGEiA5lKqCcccYZuz/2+/2MGjWKLl260K9fPwBmzpzJokWLuO666yolSCEqwzFXx3DOwwlYYb17Nn/XIW56nOBh++STCS88C3foTzBmlHgeK6RZOLvwzKj0TTbpm6J/O6hopxRc8mIiyti/caRpglIWQ4+cxbhvjmfRypZ0abu+yOaRSil+ejknKleZFKVxRwfXfZC85ze0oXbv51zqCo7Ievf9WGFNIE8z8cWc3Y+FAxAOHPzAP7mpQe9TPSQ2Muh9upf4+kahFTIHWzyxLE0gV+NwKFwxikCezV8f+/jl/3LJ2FJDvqlCCBGFJMcXtdHp/4vjhBvjCuX4vU71cNjpXnZMHEZ45RAc/omg5pZ4Hl+Wzaplyws9tmONxY410TsBp6ZwemDY8wlois7xPe4gx/ady+eTjmLNplRaNt5RZI5vmIofX87Z7/FopcNz0b7/EUnYYe/tukpLl7UNqKKOM0Elo1zD9jqXB1TRW9SVK15rHYSn8vLj9bnorAQS4g0qtniigCQgBwgBcZFCkOtSlJFUge8jhBBCHJwyFVAeeuih3R+PHDmSm266iccee2y/YzZs2FCx0QlRSZr3cHDOwwlA4R4MBR+nHvsDO3Ycgn/54ehBH4EzUGRSWzCjX2afVY4OA1ykNCu+sYlhaFo03klKYhbf/HIo5oAddD4kDyukdxcRDAN+ejWXP96LzuaeCQ0MjrzES+/TvXjiFJuXhjCdKr+xevkLD7atWTE9SMueTrwJe2acrZsb4sM7stixtmIG/coApxvOuC+eo6+I2T0OLOhFcqD2Xa1ihTVWCF6/MJ1180K4YxSBvIpbMSOEEHWZ5PiitulyjIsTbowD9s/xtYYGJ33M9nE9yFs8gPj+X7HnRnZhVljz5wc+2X63khxykoeYhOJXRpiGplPrjXg9fj775nDOHzKJVh2Du3P8glTxi0eymTcxOntMansLOvg5hH4FgmB2BntrwbPlP6EC5egD1jwKFTHM3ijv/RW2WkNrC6194H8awj8DBtddnoRxsDk++87xMoEYVOxb+X1M/JHPK2jFjBBCCFGRyt0DZcKECfz777/7PX7xxRdz2GGH8e6771ZIYEJUpoGXx2CFNKaz6CRQ2waxPaeS8ctIMqdcRtKJo7HtyM34AlZYk5Nm83UlNN0WEY16Jpa6nB3Au24WS95axmuP+2nd28nhZ3qITTZI22Ax42Nf1G7V1ayrg5s/T8Ebr3bPvktINUptrF7SNTEdio/uzCJzm0X7/i7cMYqtyy22LN+3IeWBadXLyfE3xNL9OHf+zYhK2J4r/9+mFdbM/d7Pjy/l7o7fnyPFSiGEqAyS44vaYPDI2EIrT/amFGitiO3xG1l/nkvWtPNJHPQx2o5MAClghTU711n8/FrNWdlQ0zTqkYRlKUyz+LzOMDTOhX+yYsISnn0sRIcBLnqf5sEdp9i2Msxfn/iidiWyDs9G591MZFVFfozhHZTWK6SkHF8pB8r7OCgnhOdEzm22jzRSr5CY/0EH3gPrHwoXeGxM8+Bz/cgZCprCO8FxIsozHGU0yz8i7qDfQwghhKgs5S6geL1e/vzzT9q3b1/o8T///BOP5+CXiQpREbwJiiPO9mJ38oKtUWm5KCOy9NnjiaPbwBRMZ/FbbCnDxtVkBWvXLeDvz3/C+X46p9wZS6tDI03MrZDm36/9fPNUdtQm7jVBaluTvud6SWxkkrXd4u/PfWxdbmHWTyFuYD/MPh6Uml7qeXb9uRjtDwGwZnaINbNDlR36QTMccO17yXjiVKGtC0ornhQoqheK1prfxuTtLhgtnho86DiVgk4DXfQ8wUPDdiYd+ruw7T1xVlTxxLY1ClgyLcjoEel4Yg182TYh2QlPCCGqhOT4oiaIq6foe66Xxh0dBPI0834IsHxGJN+JjU2m/RExmI7iJ84ow8bZeCUrVs3i70+mktIjg5Nuj6VJx0gT85BfM3OCj2+fyiYvQyZtHKhmXR0cfpaXuHoG6Zss/vrUR9p6C0fjVOIG9Ud1C6KM0vsqpf2xCB2MfD+XTw+yfPrB57aVTescdN7tQJB9CxFle33RRRTlvnLPtlbOow4yStA6DOE/0OG/wFoF9gIiBY6D/7kvvNpERR5xnACe+1DkgopHKfdBv48QQghRVcpdQLnlllu49tprmT17Nn379gUi+yO/++67PPjgg+U618MPP8wjjzxS6LGGDRuydevW3c9/8sknbNiwAZfLRe/evXniiSfo06dPiefNyMjgvvvu48svvyQ9PZ3WrVvzwgsvcNJJJ+0+ZtSoUTz33HNs2bKFrl278vLLL3PUUQefiIjq1/NEN1f8XxLOvcb6ulkSD/2uWDDqJNo3Pgmv+3FgS4nnychI44NP7o18sgoW/xoguamBN94gfbMl23YdBKXg3MfiGTQiMkuwIMs+4cY4/vkzhZ/+OxaUg5XrQ4TCJs5iBsIFzeHXzo3ugonDHdl7+9CTPfnbdIXZuc4iuUnx25OVNAPNtjQ5O20SG+15fSDXZvIbeYV6nByshFSDGz5KpllXJ1ZIY+T/xShrkac0WmtsK3K+HWssfn83jz/ez8MKQTBPCpNCCFGVJMcX0a7fBV4ufCYBw4zkSWgYNDyWjQtMlr97Fu2bD8Fh3A7kFnsOrWHTxpV8+vmfAKxdB3O+81OvhYnLq9i10SKQKzn+gTKdcOkriRx+pjey3RaAgqG3xPL7lCZMWzUIUCxZncfx/eYU2bcP9jSHT1sfnavIC2idB6Gf0KFpRLbp6gTKC+RxwNt0qXqg0/Z6MB7lHgmuCysmaEDbG9C5N4LexJ5VIVDWIk9pCq02MdqhXOeD89T87bm8FfIeQgghRFUqdwHlnnvuoU2bNrzyyit89NFHAHTu3Jlx48Zx3nnnlTuArl27Mnny5N2fm+aeG4IdOnTg9ddfp02bNvh8Pl566SWOP/54Vq5cSYMGDYo8XzAY5LjjjiM1NZXPP/+cZs2asWHDBuLj43cf8+mnn3LLLbcwatQoBgwYwFtvvcXQoUNZvHgxLVq0KPfXIKJHi54ORr6dv0frPrPzG7RRDLx/Njs+OI3Amp44krehjKKTRCusmffj/oOv9E026RWUWNZlQ2+NZeDwGGD/m/GHD9hFMGYhU/85hGDIyZ9zujD4iP+KPI9Siu+eju7m8MlNDW6ekEJqawe2pTFMRbu+rsj2V5ZGFbMkvqSFHYYBL565C5dX0aiDg6BPs/zPIIG8ihvwKwNu+DiZxh0ifyaK2+7uQBRsrTH7Gz/jbshEa6L6eyiEEHWB5PgimnUe5OKSlxKL3Dq0aTdNgzvnkjbhBPxreuDt+DfKLDqx0Foz7+f9t9+N9hv1NcW5jybQ+/TILLZ9c8dBx20hELOMv//rRHZuDP8ubs/hXVfsl/NqW6MUfPdMdG+hpq3V6Lzr8osd+assrNno/KT2QBZpK5wQ8zGKzWBvBOLAcViFrtbQ2o/OvRb0zvxHKjIJNwELnOeC+w6U0ihV/IQxIYQQoqYodwEF4LzzzjuggVSRATgcNGrUqMjnhg0bVujzF198kTFjxrBgwQKGDBlS5Gveffdddu3axYwZM3A6I0uxW7Zsud95RowYwciRIwF4+eWX+fnnn3njjTd46qmnDvZLEtXouGtjgf2LJ5HHbJwpW/G0mUfugkHEHjIZjUYZhW8623akQfXv4/KqJOa6xuVVHHttbLFbPykFfXos48+5XQmGnPw+oz3WxvUMPjUDZRJZsWBCKABfPZbNzM+iszk8RL6W6z9Ipl7zyMChYKuu3dtflXM/4YICzDdP5exuBr9pScX0NtlX18FumnVxVtj5bEsTzNNk77LZtiLMH+/5WDg5EJlBKoQQIipIji+i1Yk3x2FZusheDMqwcTddiavxSnLnHoe308wiV/LaliaQq/nr0+jNHWuyhAYGAy72YhQxDitwZK9FzFrUAds2+PGXzoQ2bKLfCbmgyd8iFgK5mo/uzmLhlOhsDg+gdQCddwPojIJH8v9vl6lwsv/PZ2S1hvLcgzKTgWQwu1ZgxHsJ/QJ6WwWeUAFxoBLA7IBynQPm4RXeI1EIIYSoTgdUQKlIK1asoEmTJrjdbvr06cOTTz5JmzZt9jsuGAwyevRoEhMT6dmzZ7Hn+/bbb+nXrx/XX38933zzDQ0aNGDYsGHcfffdmKZJMBhk9uzZ3HPPPYVed/zxxzNjxoxizxsIBAgE9iRxWVlZB/DVisrWc6inxO2FtG3gaTuX3GWHMPf/BtL9mimYDr27caS2wQrB6BHpMhOtkrTv58QTZ5R4jNNh0arhRuZ8tI3cv2bzpT/ALw8a9DrVQ3z9yBZqc77z48+OrrvvphOSGpkEfZrsnTadjnbRpNOBFSFsW2NYdmQ85ooUYDYvDfPTK7nM+a7yG4P0GOre3cz9QGitIytLrMgMxKV/BHnnqoyo+54JIYSoHJLji4riTVC07+sq8RhtRXL8Xb+dwfy3+9B9xEwgsuK1ICcJ5Gr+76J0cndJLlIZuhzjLnWb11hvgMbxm1n6xRry/pnHh6EQE5sYHHKyh5gEgx3rwsz9wU8oympcWgfyV2zERvqQhCaD3lHC8SWtQFEooz7oPHZvN2d2Q7mGo5wDKjbwomILTWX3ipkDpogUfSxwHIvyPiQ9TYQQQtRqZSqgpKSksHz5curXr1+mk7Zo0YI//vhjv1lh++rTpw/vvfceHTp0YNu2bTz++OP079+fRYsWUa9ePQC+//57LrjgAvLy8mjcuDGTJk0qMY7Vq1czdepULrroIiZOnMiKFSu4/vrrCYfDPPjgg+zcuRPLsmjYsGGh1+29L3NRnnrqqf32chbRRRngcJVys1fZpGWu4rU3ryAnZxcJYwz6X+SlQ//IoGzFX0Gmf+Aja4fsJ1RZXN6y3ZD3T5lMzq97tljISbOZFqWrgtyxiqG3xHLkJTHEJEaKQ+vmBcncah9wEcIwFGr5TtiSBW4Hd18TW6U/ly6vKnZf6tJYYU0ooJn3vZ+MrTZzJ/rZsKByVsoIIYQ4cJLjS45fE5Q1d9y0fQGjR32Fz5dF8tsGR10SQ5vDnFhhWPJbgBmf+KQxfCVyeVVkAlAJK1AAcr/7ntzpe3L69M02v74dnTm+tjPQgdEQ+g6ITGDS5qFgK7St9tvJoIBSJRVRNMpzFzj652//5UEZyZX1JRTBx4EWT0JhjdORAM5jQDVAOY9DmfsXxoUQQojapkwFlIyMDH788UcSExPLdNK0tDQsq/TZ+0OHDt39cffu3enXrx9t27Zl/Pjx3HbbbQAMHjyYefPmsXPnTt5++23OO+88/v77b1JTU4s8p23bpKamMnr0aEzTpHfv3mzevJnnnnuuUAPMfZeUFrWf7t7uvffe3TFBZHZa8+bNS/0aRdXRNmxbFaZBa7PYxF3bmgXT15CTE9lTN2uHzU8v5/LTy8U3mxQVa/Oyst1I37QgyqaeFcMdo7j1yxSadnEUmnXXvLuTlocodBkWMtn5ez0rpXYXXKaNy2Ngi6xIDcMfrvKi3uYlYQ47vWzH7v370wpr5n7v55uncmQVlxBCRDnJ8SXHrwmyd9rk7LKJSylhBbOymPP7Uny+SP6Yvsnm26eju4dGbbN5aajU4olta7YsqfyV1BVB2+no3CtAbwX2/N7ToXmgSi9AKAUaA7W7x0h+fxDXlSjnoPyDGldw1GVgdgBrPnt/TWXhD9h89EU2I676KbKCRgghhKhDyryF12WXXVaZcQAQGxtL9+7dWbFiRaHH2rVrR7t27ejbty/t27dnzJgx3HvvvUWeo3HjxjidzkKNKjt37szWrVsJBoPUr18f0zT3m4m2ffv2/Was7c3tduN2y7LUaPf7u3mc+1h8icfM+Cg6ZzjVFdtWWqz4K0ibw51FLvO3wpoN/4XYtLhmrFgYck0Mzbo6dvc3KVDweUl9E7XWZG23mfJWLr1O9eCJM9i0JMQf7/lYPj3IoA8rM/KS/fWJj1PvikMbRd94KtgOAx2ZYff1Y1ks/i1IxjYLX6bM7hRCiJpCcnzJ8aOdbcEf7+Vxwo2x++VbELkpH/bDrC9rxo352mrlzBDbVoWp39IsNsdfODlA5taasdJfB97ar3gCoIxIv8ySV2orUK0wXCegQ78BfjC6oFznoBzdKy3mslDOs9DBT0o7Kv//TvDcSbc+V7FhU4icXM3Ia6R4IoQQou4puRFBPtu2y/1fUXsclyYQCLBkyRIaNy5+JobWutA+xfsaMGAAK1euxLb3JGbLly+ncePGuFwuXC4XvXv3ZtKkSYVeN2nSJPr371/umEV0mfZeHkumBfMbwe91Ezf/40//l0X65pqRtNdmH9yeiS9TY4UL32i3whp/jua9WzKrKbLSubwKc6+2JkdfHlPkYL6A1pHVUcU99+s7eUx+I49nT9rFo0fvZMzVmSyfHqzgqMsve6fNh3dmgabQ90lrjW1psnbYzP3ez/fP53Bf7x1MGZ3HluVhKZ4IIUQNIjm+qCl+eS2XDf+FsK39c0c0jL8pA3+O5CDVbez1GYQDRef42TtsPrsvOnsMRSYG5aF1OP9zP4S+p7hVGrv7Zxb7I6dR7otR7hEYce9jxE3AiHmk2osnAMpsjXLfmP9ZEbeDVCNwDEG5b0LF/YDhOoMly4Pk5Mq/LyGEEHVXtTaRv+OOOzj11FNp0aIF27dv5/HHHycrK4vLLruM3NxcnnjiCU477TQaN25MWloao0aNYuPGjZx77rm7z3HppZfStGlTnnrqKQCuvfZaXnvtNW6++WZuvPFGVqxYwZNPPslNN920+zW33XYbl1xyCYcddhj9+vVj9OjRrF+/nmuuuabKr4GoWHYY3rg0ncEjYxg0IpaUpvmzFDN9vH69n8W/Vv+NaQE71lg8dcJOTrgxjr7neXF5FaGA5u/Pffz8am7Ubf1kOGDgFTEMHhFD/ZYOtK1ZMi3ItHdzSWhQwhITiIy7lMYKs3s2nm1plAGLfw0w+c3o3T5u5qc+0jdZHH9jLJ2PjszOzdxq8/vYPKa8lUtY/jkJIYQoguT4oqIF8jQvnZXOsdfGcPTlMSQ0MCP52G8Bfn4tl1X/hKo7RAGsnx/m6RPTOOHGOA47w4PDpQjk2sz42MfPr+WStT26JrJp7YfgR+jghPwm8QbacRTYxwDFF3QBtBUppGgMlCr4ugzABsdJ4DylkqM/cMp9KRgt0MH3wPov/8GmKNcF4DoXVdISeiGEEKIOqtYCysaNG7nwwgvZuXMnDRo0oG/fvsycOZOWLVvi9/tZunQp48ePZ+fOndSrV4/DDz+cP/74g65du+4+x/r16zGMPTMnmjdvzi+//MKtt95Kjx49aNq0KTfffDN333337mPOP/980tLSePTRR9myZQvdunVj4sSJpTbEFDWDFYLJb0Rm9b/xaS7YGmVrFv9a8tZeomqlb7L55J4sPrsvC0+8wp+jsaNw1y7DAdeMTaLLMXu291CGotORLjoPdKHtPbPQimJrzexvfPizoffpHlxexdaVYX4fm8fMT33Y0VUr2s+yP4Ms+zOI0wMOl8KXJbPPhBBClExyfFEZgj7NxBdz+fGlXDwJipBfEy75HreoBttWWrx3cyYf3pGJO1bhz9ZRme9q7UPnXgv2YvY0VbfRwWmgfy9xG14AZRoo15mg/RD+HQiB2QHlOg8cx6NKGiBEAeUchHIOQmsfkRlfsSX2ixJCCCHqsmotoHzySfF7b3o8Hr788stSz/Hbb7/t91i/fv2YOXNmia+77rrruO6660o9v6jZVDi6ZjmJ/dkW5GVE7035Iy+OoesxbtQ+TTENh4os21f5M9CKGWSZTsWMj/wsnxHkk3ujc9uCsgj5IeSP3u+TEEKI6CE5vqhMWiNbhtYAVii6c3wdGA/2EvYUTyIKepzo/KJPcTm+UjbKdS7KbFu5gVYypbzVHYIQQggR9aq1gCKEENFu0IiYYp9T+cUTFEWuRLHCmrVzQyyfIXtdCSGEEEIIEQ20DkPoc6DoyXbK2NPfpOjV5gY4jq7xxRMhhBBClI0UUIQQAvAmKrof68YTb7BjTZilfwRRChq1K+XXpIKMBTbetuCOU1ihSGHFdCpW/RNk9IiMKolfCCGEEEIIUZi20yA8A/CD0RbMQ0HvAp1Z8gvDEFifiLtNXuQTTCKrVSxwHIXyPlrpsQshhBAiOhxQAWXVqlWMHTuWVatW8corr5CamspPP/1E8+bNC+1dLIQQ0U4pOOWuOI69NhanW6FtjTIUGZsslj5mo8OgSvhNqW3NilUBPjwrk96neWnaxUHIr5n/Y4B186ShqRBCiJpDcnwhRG2hdQjtfxFCXxHp8RFhhxqxc2wyqVeVcgKHiafzKSj3SAj9hLbXAbEo57Eos11lhi6EEEKIKFPuzma///473bt35++//+bLL78kJycHgAULFvDQQw9VeIBCCFGZzrg/nhNvjhRPgN29ThIbm/R5zUnef6BLaG5vOBTzf/QT8sHMT3188VA23z6VI8UTIYQQNYrk+EKI2kT7HoXQF+xdPAFQxlbqX7IE/4o9fU6KopSFcgxEqTiU6xwMz+0YnmukeCKEEELUQeUuoNxzzz08/vjjTJo0CZfLtfvxwYMH89dff1VocEIIUZkSGxoMuToGpdR+zykDMMDwsLvHyb6ssGb76jDzfw5UeqxCCCFEZZIcXwhRW2hrBYR/Yt8G8RBpCq+cYGUX3yAeTDC7gXlIJUYphBBCiJqi3AWU//77jzPPPHO/xxs0aEBaWlqFBCWEEFWh9xmeEp9XJng7w4bnwQppbFtjhTVWKDIY27nW4tXzd2GXsEJFCCGEqAkkxxdC1BY69BORniVFUw6I6QE7xsSj7fxZUxh7XmN0QHlfLHKSlRBCCCHqnnL3QElKSmLLli20bt260ONz586ladOmFRaYEEJUpLh6CodLkbXdxs5frt8w1Qk2JY2vAPjop52kjbfoc56X5t2chAOa/yYFWDg5sPtcQgghRE0mOb4QoiZKaGDQxDTZut3Czl8xHt6xEjPOKmGFSaSI0uDqj1AeB4S+Q9urgRiU8xgwD0epcs81FUIIIUQtVe4CyrBhw7j77ruZMGECSils22b69OnccccdXHrppZURoxBCHLCeQ92ceFMsLQ+JbEeSs8vmr/d85Hxs0t7vRZn7L+3fm21pdm61yMvQTH0rrypCFkIIIaqc5PhCiJqkz7kejr8hjsYdHDxNKpu2hhn/bhYb770XV+O/qHdJaWfwoLz1UcoB7iuQtSZCCCGEKI7SWpd893AfoVCIyy+/nE8++QStNQ6HA8uyGDZsGOPGjcM0S5nKXUtkZWWRmJjIFcThKme6lYHNYoJsMDW2y8bthI6NwbnMRRscOCR9OyjZ2CwmxFoVxnbbOE1o1wg8q9y0xYlTru9BycVmCSFWEcby2DgMaFUfYta76YCz3P8eKtPgK2M499EEbEtjmHvi0hb4l8CmBxVtPtEYrqJfb4U1838K8M6VGVUTMODDZikhVjvA8lgoBc1TFDHrTDrgxBNF17cmCqBZRoiVDo3ltdAamiQrYjcYdMKJt/w7W4q9BNGsIMQKUxOOtQlbmkaJitjNBl1wEivX96CE0KwizHLTJhRrE7I0DRIUcVsi1zderu9BsdCsJswy0yYQZ7Ez0yIzM5OEhITqDq1KSI4fcTA5fhoWiwmxydT4tY1DGaTYik7apBUOjCj+G/4W2bs/vpr4aoykeBnYLCLIBmXh1xpTQZKO/P1ugwNTru9BycofQ60hjB+NASQSub7tomyMevr/4jjhxjhsW2MYkbi01qAVuX/B9lGK1h9oit+BywTnWRjeu6os5o2bNjH63XF8+vlXbNuxHYfpoE3rVgy/9GIuOv9c4uOj8+cCQMUm7f5Y52ZUWxwl2bZtO2Pee58PP5nA5q1bMJRBi+bNuPziYVx20YUkJSVVd4jFqgnXNy1tF+M++JD3PvqEDRs3AdC0SWMuvuB8Rlx2CfXr16vmCItXE65vZmYm73/8KWPf/5B16zdg2RaNUhty4Xlnc+Xll9G4caPqDrFYNeH65ubm8tFnnzNm/PusWLmKXenpdSrHFxWj3AWUAqtWrWLu3LnYts2hhx5K+/btKzq2qHYgg6sQmt9VgFU6RGJMDKcO7EeT+ikEw2H+WbSEGQuWEmOYHGk7aY2zkr+C2sdC8wd+lhPGaxoMbpRII68LS2sWZ+Yya2cuLhT9idzoF+Vjo/mLAIsI4UDRwZlAsuHEBrbbflaFcnAAR+CmG8VUJKpQSjODR/9usHtQtS9tw463FDoMDW/UaFuj9jrWCmsCeZpnh6axfXXl79Ol0cwiyAIVxuFwcMYZp9O5c2e01ixc+B/ffPsdaE0v28EhuFBRNIitCTSa+QSZY4TRSnHqKafQo0cPlFIsW7qUL7/6mnA4RHft5Ai5vgdkEUH+McJYaE484QR69+6NaRisXLWKz7/4gkAgQBftoC/uqL7JFa2WE+IvM0TAthkyaDB9+/XF6XCwbv16JkyYQE5uLh2UiyO1K6puctUUawnxhxkmzwpz9IAB9OnTh+defLFODq4kxy9/ju9H86sKsF6HqJ8Qz6kD+5GanIQvEGTanAXMW7GaeMNkkO2iSfk3AKgS0XyDP4jmN/ysIUy8w+SYRok08DgJ2pp5u3JYkJFHDIqj8NBKrm+5hfcaQ7kx6OhMIMFwYqPZFM5jnZWHG8WRuGkXBWOo5j0c3Ptz/RKP2fKkwtUC6l1c1K0OE1QyKvY9lNGgcoLcSygU4qY77ubtsePxej2cdcaZtG3ThrBlMWfOHH78+WdiY2N57olHuXrEFZUez4GI5huklmXxv4ce5aXXR2GaJmeefjodO3ZEa838BQv4/ocfcDqdPHLfvdxxy41R2dcmmq+v1ponnn2eJ559Adu2Oe2UU+jatSsAS5Ys4ZvvvgPgrltv4uH77sUwom8yTzRfX4BXR73J/x5+DL/fz8knncQhPXtiGgYrVq7ky6+/JhgMcv3VV/L8k4/hcETf37hov77j3v+QW+6+l6ysbE447ji6d+/Ocy+8UCdzfHFwDriAUteVd3AVQvOD4SfLYfDAyIs49ai+uF2FE9DVm7bw/PufM2XWXAbhkZv85WCh+QkfW5XNVe0bcnyTZDxm4T/eW31B3l+9nSlbMxkQJTf5awobzWT8rCNMf3d9uruScO+zqXC2HWJWYBcLQhkchoveuKsp2ohT7ozjhJtiMR3FF1DC22HpeYr0o3x0v95JcpM9X9Oy6QE+/V8WW5dXTfFkGgGWqTB333EHV195JSkpKYWO2b59O6+NGsWrr79Od5z0x1PpcdUmf+FnASFuuO46br7hBlJTUws9vys9ndFvv83Tzz1HB+1gIG4popTDHALMIsjwyy/njttuo2mTJoWez8rOZtz48Tz82GO0sA2O1e6onokdbRYR5E8CnHv22dx37720btWq0PO5ubl89Mkn3Hf/AzSwNCfaUqQqjxWE+BU/Q088kUceeogO7duTlZ1N89atZXBVB5U3x/ej+c7wY3tdPHz1pRzXpxfOfW5wLFm7nqfe/ZhZi5dzvPbQIgpv8kfrDf4gmh/wkW1oruvUmIENE3Dtc4NufW6Ad1du5e+dORyDJypu8u8rWq9vGM2P+NiOzdGeVDo7E3Du0/sjww4yw7+T5eFsjsJNl2oeQ134bAL9L/BiOovJ8S3wL4ON9yTR7JleeDvPATLyn1XgGIDy3I0yKn9Gdzgc5qwLL+anSVN4+IEHuOySS/ZbabJx0yaeff55xr//Pk8/+jB3335LpcdVXtF6g9S2bS6/6lo+/HQC9951F1eOHEnyPitNtm3bxiuvvcb/vfkmd916M888/kj1BFuCaL2+WmtuuuNuXn9zNLfcdBM3XHstDRoULjqmpaXxxujRPPfCC1x5xWW89drLUVekitbrC/DwE0/xyJPPcNXIkdx28800bty40POZWVmMGTuWx598krNPP42Px4+JuiJVNF/fl18fxa13/49hF1zAPXfdRcsWLSTHFwesTAWU2267rcwnfPHFFw8qoJqivIOrX/Gz3gUfPnYP3du1LvY427b53/+N5evfZ3Cm9lK/tO7WAoDp+FmqQjxxaCt6JscWe5zWmtErtvH1hjROwRu1swCjzb8EmEOQU7xNaeuMK/HYvwM7+SuQxgl4q3UW4MjRSRxysrvYFSgF7m61neyAjTKg5SFOvPGK7Wss0tZXXXf4hQSZToC3Ro3igvPOK/HYt8eM4Y6772awFFnLbHn+zdFnn3qKq6+8ssRjP5swgSuvvZZ+uOkhRdYyWUeYn/Bx7113cc9dJW+F8dPPP3PhJZdwiO3g8GoustYUWwjzHT6uufpqnnr88RIHpX9On86Z55xD+xAcKUXWMknD4ivl47zzzmPUa6/tHpTWlcGV5Pj7K2+OP1H5yY5x8unT99O6SfE3ZEPhMDc8+zrT5yzkHO2Nui33ovUG/xR8bDQsXjisNW3jvcUeZ2nN84s2MW1bJmcRQ0qUjaGi9fr+gZ9lhDkrphlNHTHFHqe15jf/dhaEMjiNGBpV4/W949sU2hxeco5mBx3g+AlHUiJah8FaBPjBaFklhZMC9z38GM+8+DKffvghxx17bLHHaa154umnee6FF/jxq8858fjij60O0XqD9IVXXuOO/z3AmNGjOeess0o8dtSbb3Lv/ffz8bgxXHDu2VUUYdlE6/V9d/z7jLjuRl56/nmGX355icd++PHHXHfjjfzfS89z3VUjqybAMorW6/v1d99z5gUX8+D993P7LbeUeOx3P/zAJZdfzmMP3sd9d91RNQGWUbRe319/n8YxJ53GTTfcwKMPPbR7DFVXcnxR8cpUQBk8eHChz2fPno1lWXTs2BGA5cuXY5omvXv3ZurUqZUTaZQpz+AqB5uPyeW+ERdxyUlDSj13KBzm2GvvJn5XNoMpfqAgIgJoPiCHC1s34KI2qaUeb2vNtTNXofIsTpDrW6owmg/IpYsriYGe0q+v1prP8zZgWUFOp/iBWEVSCvb+TdbY4+Kq15JJPVGhSqjhhIOam1puq/wAS2Cj+dQMcNLZZ/LWqFFles0FF13ErMlTOcuSVRKl0Wi+NAMcdswgPv344zK95robb+S7zz7nfEtWSZTF94afpr168suPP5Zpxtl9DzzAmNFvM8zyyFZTZfCL8uNq14qZ06eXacbZcy++yNNPP83Fdgxuub6l+g0/WQ1TWDB3Li7XnhtydWVwJTn+/sqT46dh8Tl5vHL7tQztf3ip5871+Tly5K2092v6RFkRORpv8Gfnj6Fu6NiYk5ullHp8yLa59M/lNAoZHB1lReRovL4+bD4kl77u+hzuLr1/ga01H+SsIUlrjquiMdS+OX6LGDfXfJhE4hEKVdKfRFUPI/6nSo+vJLm5uTRt35nLL72MRx96qNTjtdYcN3QoCXGxTP7hmyqIsOyi8QZpKBSiVeceHDtkCK+9/HKZXnPuBRewY8d2Zk//PapWSUTj9dVa06VXHzp07Mj7Y8eW6TVXXnMN/87+lxUL5kTVKolovL4A/Y85DofTzXdffVWmn8c777mHr77+mg3LF+F2R08OEa3X95Szz2Pjpi38NmVKoZ/HupLji4pXpt9qv/766+7/Tj31VAYNGsTGjRuZM2cOc+bMYcOGDQwePJiTTz65suOtkZYQwu1ycebg/mU63ulwMGzoMaxWFn5kh7XSLCOEVjC0aXKZjjeU4rTmKawjTDZ2JUdX860mTABNT1dSmY5XStHTlcxWLNKovFUcTTs7uOzVRF5Z05D/29yIR2bU5/irYjmuWRLntWxAaLpZYvHECmnmfu+vtPjKaj0WWVao1JURe7v6qqvYaYXYWonXt7bYisVOK8TVV19d5tdcNXIkWVaI9YQrMbLaYRcWm+wQ11x9dZkHoiOGD8dnhVkl17dUOdis1WGuvuqqMg9EL7/kElCKZYQqObqaL4BmlWExcuTIQsWTukRy/IOziBD1ExM4rk+vMh0f6/Vw7rFHs9ywsCTHL9ViQnhNgyGNk8p0vNMwOKVZCisJEZDrW6qCvxPdnIllOt5Qih7uZNYSJrcSx1Ctejm58p0kXl0XyfHv/7Uex1waw9CmyZzZvD7+aQYl1zZNcJ5QafGV1ccTviArK5uRw4eX6XilFFeNGMGU335n6bLllRxdzfftDxPZvGULV40s+2qHq0aOZO78Bfzz7+xKjKx2+G3aHyxdvpyry3l9V69Zy8+TplRiZLXD3Hnz+evvWVx95ZVlHkNdOWIEO3bu5Iuvv63k6Gq+NWvXMvHnSVw5cmRUFfNEzVbun6QXXniBp556iuTkPTerk5OTefzxx3nhhRcqNLjaYpOhOa5vb+K8ZZ+pc/rA/oS1ZrPcYCrVRsL0SokjxV327YyOaZS4+7WiZOsJ09jwkGSU/eZSW0ccThQbKun6dh7o4u6f6nHYmR6cnkjCUb+lyekPxXPC2x6US5P7N/hXgC4iBNvSaA2TRuVWSnzlsYEwbVu3ptehh5b5NQOPOooG9eqxXgoopdqARf2UFAYdfXSZX3NIz560b9NWrm8ZbMDC43ZzajlurrZp3ZojDjtMClRlsBELjea8c84p82saNGjAsUOGsMGQCQKl2UyYsG2XunViXSE5fvltMjWnD+yPwyz7dkanD+xPnm2xXf7GlGqjCnNkasJ+fQ1LMqRxEiFgi1zfUm3AopUjDq9R9i13OzsTsIn8faoMvU/3cMe3KfQ4wY3DFcnxG3dwcPbTCQx60Q2GJmuKIrS16Bw/HNaAC+Wq/t/rP/4yiQH9+tGiefMyv+b0007D4/Hw06TJlRhZ7fDjL5Pp1rUr3bt1K/NrhhxzDPXr12fiz79UYmS1w8SfJ9GsaVMG9C/bJGCAw3r3pk2b1kz8Ra5vaX6aNIWE+HiGnlD2Ym+H9u3p3asXE3+eVImR1Q4/T56KYRicfeaZ1R2KqEXK3aAgKyuLbdu20bVr10KPb9++nezs7GJeVXu9/HYOCaXsUjTpNpPU5LLN7ClQcPz5V/oZMaj6Z8lHs8Pvg3rB8v0oex0mMU7FKecEuPOUQCVFVjsc/xSsWVq+bRBMpYhzmhwzNMiT5wcrNB5tKPSRrcEksq4/n8rvdeLtDikXatLGG2y8y6D5s2Hc7Q2w82ciKjC0jbl4K/f/L69CYzsQF74Om8q5F7NhGDRp3IA+PdN4c0TFXt/a5rqxYG1pUO6ZJ02aNqJhg1W8eZPM4i/J/Z/BplkNyz17v3GTJiR0m82b99a9vKE8XvgB5nzj3a/hbGkaNmzIjlaaNx+T61uSsb/DL6OhUcOG1R1KVJAcv/z82qZBOXP8+kmR7SLkr3fpgkCKu3w5forLkf9aWYFSmgCa+iUt1y6CW5mYqEq5vnH1DC57NRGlwDD3z/HjjoLEUzSZ3xpsvNWg4VMWsa0V4ZDG1uByKXZlWDRs8TrKaFrh8ZVXenoGDcv598XtdpOclERGZmYlRVV7pGeU//oahkGD+vVJz8ionKBqkfSMDFJTU8u11ZlSikapDcnIkJ/f0qRnZNCgQX0cjvL9Dm6Ymkp6RnolRVV7pKdnkJiQQExM1WwpL+qGchdQzjzzTK644gpeeOEF+vbtC8DMmTO58847OauUxl11ldcF/mD5bsIVHO+VHtGl8roh4CtfEq+1JmhpYurmjh3lEuOG8AEs0w9rG29lXN+G8WAahYone1MmJJ2hSf/Uov7hO3GvS0dledD1Y8EwUDkB2JaNsqNjYO11gS+7/IUcn89PTPRsfRq1vE7I8/nK/Tq/z0c5Fg3WWV4X5PnKX+T3+/KIcUXHv8Fo5nWBLxBEa12uAazf78cr17dUBX+jfD5fuYtUtZHk+OXnUAp/sHylkEB+jh9dLc6jkwkEy5mvBfKPL/cgtw4yUeXO8bXWWOhK+fntf6EXw9xTMNn/zSH5LM3Wr2wmzc1kyYA8Og100Xmgm8WOIH/P9vPFDzkEM3pUQnTl5/V68PsPIEfy+/F6JAktjdfjZeu2HeV+nd/vJ8YrN1VLc6A/vz6/H68Mokrl9XrIyyv/GNXn91OvnBM36iKv14PP7y/3GEqIkpR7C68333yTk08+mYsvvpiWLVvSsmVLLrroIoYOHcqoMjZArmt6NreYPn8BWpd9APDHvIUAdCv7it86q0cLmJ+ZQ7gcA6wFGXmEbLm+ZdGjBWy1fQR12QdY2y0/2WGb7pVwfXWcm9JCcSRDm1vWk9I3HcMAlenHWJWGsWIHaktW1BRPALo3hwX/LWLHjrIPANauW8eK1evo1qwSA6slujeHVWs2sGbt2jK/Ji0tjbnzF1TKz29t0705pKVnMm/+/DK/Jjc3l7/+miG/f8uge3MIhy2m/fFHmV8TCoWYNu1XujeT7WtKU/BvfOpvv1VrHNFCcvzyS7YV0+YsKNdr/py3CANILv8wrM5J1gb/7swp1xhqdlpO5LVyfUuVgsH6cB52Oa7veisv/7UVX0Jp3r3kspcywN0KPtiwjcVZeWgNS34L8uUj2dz6wE4++TqHUBQtHO7etSsz/voLXzkm8syeM4f0jAy6d+1SiZHVDt27dmHOvHnsSi/7bPxVq1axZu1aunXpXImR1Q49unVj6bJlbNy0qcyv2bZtG/8tXCg/v2XQvWtXtmzdyuIlS8r8mqzsbGb9O0t+fsugR7eu+Hw+Zv79d3WHImqRck/OiYmJYdSoUTz33HOsWrUKrTXt2rUjNja2MuKLerdcGYer5C52ZBNmDTv4678l9O9Rtj8mH06cTGPDwah7pXpfmjQsdpHHjB1ZHN2wbNX47zakkYzBR4/H8HEp37+6LhubALksC2XRvYyN5BcEM4hBMfGlWH6qwOvrNQ2ueTKOdsNKP+e9d7jJSYv+JUZ+NLaRx/sffcRtN99cpteMHT+ehIR4zn9iCdTR371ldd7xedz6WWfGjh/Pow89VKbXvP/hhyjD5LKnlkH9epUcYc120ilhmn7SgzFjx/Layy+X6TUTvviC7FwfVz41H1q2rNwAa7gjtabLhH68M3YsA8vYx2fiTz+xZdtOrv76D+jRvZIjrNm6AgO+PoG3x4zh9FNPre5wqp3k+OXXWTuYvGwVy9ZtpGPL0mc1aK35YOJkWuIgVm7wl6ozTn7I87EwI4/uyWX7OfxuYxpNMEmWNT6l6oKTpTqPNeEc2jrLtgpvfjCdFAwaVvDPb7zDpJHDhdIl5/i2pfEFa0aPryuvuIxnXnyZL7/+mosuvLBMrxkzdiwtWzTnhOOGVHJ0Nd8Vl1zEA489wUcff8wN111Xpte8O24cKcnJnHPm6ZUcXc13wTlncfu99zPuvfe4/957y/Sa9z74AKfTySUXnl/J0dV8p508lEYNGzJm7FheePbZMr3m088+w+fzM+KySyo5uppv0NFH0b5tW95591365a+qFuJgHXDmExsbS48ePejZs6cMrErRGJN6hoPn3vsMX6D0fhtTZs1l5qJldLZl8XlZ1MOkCSbvrdpOTqj0Gbfzd+UyY0c2XXCipHhSqngMWuLgn0AauXbpTZ+3WX6WhLLoghPjAK+v6QTnPrXDrokxXNq6Ie45Lkrartm2NOvmBclJi55VJiXxoGhjG7z22musW7++1OOXLV/Ou2PHcvlFw+R3bxnExMQw/JKLGTtuHEuXLSv1+PUbNvD6G29w/tlnUl+KJ6VyOBxcM/IKPp0wgdlz5pR6/Pbt23nhpZc4+cTjaSXFk1Ippbj+6pH8MHEiv0+bVurxGZmZPPn00wzo14eeUjwpk+uvupI//vyT7ydOrO5Qoobk+GXXCgdxhslTYz8mFC49R5ow5Q9WbtpCF2SP3rJoikmyMnhnxTYCVuk3zf/cnsWiTJ9c3zJqgEkqJjMCOwno0sdQ68K5rAnn0vUgxlAOFzj3aq2ogEOTY7m4dSrqX0eJOb4V1iycEqAcC2aqVds2rRl6/LE8+8IL7Ny5s9TjZ/37LxO++IJrRgzHNKUAWJrU1Aacd9YZvPp/r5dplcTiJUsY9/57jLjsEjye8vX3rIvi4+O57KILePudd1i5cmWpx69Zu5Y3Ro9m2PnnkpSUVPkB1nAul4urhl/Ghx9/XKaV/Fu3buWlV17h9JNPolnT6u/xFO0Mw+C6q0bw9bffMuOvv6o7HFFLKF2eNdHA4MGDS9xDburUqQcdVE2QlZVFYmIiV1D6ChSAHVh8p/wc0qkd/3f3DSTFxxV53M9//cvtL4+mWRiG4DngG9B1TToW3+KjWZybRw5pQT130QOn2Wk5PLZgPfVtgxPxYsr1LZNsbL4mD6/h5LSYZiQaRV/fzeE8vs3bRAKKU/DiLOf17XiUi+NviKXTkS6Uodi+JszfY/3ETfLQxF3Q8EPT8i0bd1uKHWSNHpnOvB9KL1ZGCx8235pBEho35IsJE+jQvn2Rxy347z/OHzaM5KRE/pz8kySnZZSZmcmRx57IzrRdfPrRRxzSs2eRx61YsYJzhw0DbfPX1Ek0bJhaxZHWTD6fjyEnn8ayFav46L33ip3ls37DBs4fNoxdu3Yx87dJtGzRooojrZlCoRAnn3UeM/+ZxbgxYzh2SNGzUrdt28aFl1zCqtWrmDHlFzp36ljFkdZMtm1zwaXD+e7Hn3hr1CjOOO00ILJNQvPWrcnMzCQhIaGao6wakuNHlDfH30iYH5WfwYf15IVbribGs3+DMq01E6b8wYNvjqeTdnAk7qibxPMW2bs/vpro6Qm0DYvvyaNbciz3d29OnLPoG8u/b8vkuUWbaKVNjsEj17eMdmHxDT5SDDenxTQlxig6uV4TymGibzONiIyhyjtG7Xmim+Oui6XN4ZHV4ZsWh5j1boB6f3pJ9eSvGHdoWr9v42ywf46vtQYNL529i5Uz99+na+/rq3MzyhVbZVqzdi19Bx1Hamoqn370UbE3PqfPmMFFl15Kl84dmfz9N1F3g1/FJu3+OJqu79at2+g7+FhMh4PPP/6Etm3bFnncnLlzueDii2iUmsofk36Mur5n0Xp909MzGDDkBLKys/ns44/p1rVrkcctXbaM8y68EKfTwV9TJ0XdJLRovb65ubkMOvEU1q7fwCcffMDhhx1W5HFr163jvAsvJCcnh5m/TYq6Akq0Xt9gMMiJp5/N7LnzeG/cOAYPHAjUzRxfVIxyF1BuvfXWQp+HQiHmzZvHwoULueyyy3jllVcqNMBoVd7BFcAWwvxiBMBhcuagAZw95Cga10shGArxz+JlvP/DZBauXkcbnAzGjSPKEv9otwOLn5WPIDCoUSJDmyTT0OvE0polmT6+3ZDGokwfzTE5Fm+Zv28iIh2LH/GTi017RzzdXUkkGy5sNNssPwuCGay38miEyQl48ZTz+h55iZdhzyZihTWmI/JabWtAkTMdNj9kgB153EzRNH3Oxts2MhvNMMC2wTDgy0ezmfJW+ZuyV7dsbH4yg2Rqi5OGDmX4FVfQqWPkBujChQsZM3YsP0+axKE9e/D955/SuHGjao64Ztm6dRunnHM+c+bN5/hjj2XEFVfQrVs3DKVYunw5744bxw8TJ9K+bVsmfvUZrVu1qu6Qa5Rdu9I584KLmDZ9BoMGDmTk8OEcesghOEyTlatWMf799/n6229p3KghE7+cQJfOnao75BolJyeH8y+9gok/T6J/376MGD6cPkccgdPhYN369bz34Yd8/sUXJCUm8v0Xn9L70EOqO+Qaxe/3c/lV1/LpF1/Ru1cvRg4fziE9e9LvqKPq1OBKcvyIA8nx1xFmigrg8bg459ijOX1gfxokJeIPBvlz3kI++GEyK/JXngzAHZUTpKL1Bj/AZsL8gh9lwHFNkjmucRL13Q5CtmZ+ei7fbtjFyhw/7XAwCE9UTpCK5uu7HYuf8BECOjrj6epMItFwYqHZbPmYH0xni+WnJSZDDmCC1NBbYzn1rvjCOb6lUaYi4zvY9oIB+ed0NtU0fd7G3XhPjq915L8Pb89i5mdF9xOJ1gIKwKLFSxh65jls276DM08/ncsuuYS2bdoQtixmz5nDO+++y7Q//mDQUUfy1ScfROUEqWi9QQqwes1ahp55DqvXrOWUk0/missuo2P79tha899//zFm7FgmTZnCYb0O5bsJn0TlBKlovr6bt2zhpDPP5b9Fiznx+OMZfvnldM0vpCxZupR3x41j4o8/0rljByZ+NYEWzaOvyWE0X9+dO9M4/fwLmTHzH4YccwwjLr+cQw45BEMpVq5axdjx4/n2++9p3qwpP371OR3at6vukPcTzdc3KyuLcy++nF+mTOXI/v0ZMXw4XTp3ps+AAXUqxxcVo9wFlOI8/PDD5OTk8Pzzz1fE6aLegQyuAHKxWUKIZYZFjl14qXQL5aSzNmmJI+pmTdUUPmyWEmKJCpO9T6fxJph0xkkbHFE5cK0JAmiWEWIRIbIofH1TMemKk7Y4yj1wTWlm8OjMBhhm0a/TGrY9r8j8IbLr4LKsPP5My6TtMU4OOdmDO1axdUWY6R/4SNtQcxsnh/Kv71LTJs0qPLvukB7duf7qK7no/HPxeqU30oHw+Xx89NkE/u+td5g7v3DT3y6dOnHdVSO4dNgFUTcrraYIBoN89sVXjHr7Hf76e1ah59q2ac21I4cz/NJLSE5Oqp4AazjLsvji62954+0x/PbHn4Wea9G8GVePuIIrL7+MBg3qV1OENZtt23z/40+MGj2GnydP2f24DK4kxy/z67BZTJDlho1vrxxfAa2Uky7aQVPMqM3xo/kGP0TGUIsJsVSFyNtr+KqA5ph0xkVLub4HzJc/Rl1CiBwK3x5okp/jtzqAMVTz7g7u/aXkv0sb/2eQOyNy3v8ycpmZmUmXoW66H+vG6VFsWBhixsc+MrcWv41bNBdQIDKTf8z493njnTGsXrO20HMD+vXh2pEjOO/sM3E6o3P7uWi+QQqQnZ3NuA8+YtToMSxdvrzQc70PPYTrrhzBsPPPjbqVPQWi/frm5eXxwSefMWr0O8z/b2Gh57p16cx1V43k0mEXRO22n9F+fQOBAJ9M+IJRb4/hn39nF3qufdu2XHfVCK645CISE8vW77eqRfv1DYfDfP7VN7zx9himTZ+x+3HJ8UV5VVgBZeXKlRxxxBHs2rWrIk4X9Q50cFXAQrMDmxG35+F2QIfG8PQt0ZdM11R2/vUdfnseLge0TYXnb5frW1E0mp3YXHF7Hg4TWtaHV+468Ot7yl1xnHBj7O5Zafu9nw3BtTD/Ys2v2zNYl1tztuc6EBpNGjZX3JGHUtA8BbrdmF7i1iqi7LTWLFq8hPUT+qM1NEmGQ26W61uRli5bztpPjiBsQcNE6H3rLgxDGiZXlJWrVrPqw14Ew9AgHg6/LU32S69Aa9etY97bPTnzJRlcgeT45RVGswOLAOAAkjFqRMP4aL/BX8DKv75+Itc3EYN4ub4VpmAM5UNjAgkYJB7E9R32XAL9zvdiOovJ8cOQNxfm32QzZVsGW3zBA3qfaC+gFLBtm9lz57Ft+3YcpoPWrVrSsUPRW/dGk2i/QVpAa83cefPZsm0bhjJo0bwZXbt0ru6wSlWTru9/CxexcdNmNJpmTZrQo3u3qB9D1ZTrC7B4yVLWb9hI2ArTuFEjDu3ZI+rHUDXp+q5YuYr/Fi3m7GGXSI4vyq3CupT/9ddfUVvRj0YmikaYnNqruiOpnQwUDeX6VhqFogEmp1TQ9W3WxYFRwr0/ZYCrleaDtdsJ15TOkQdBoaiPycmH7v1gdCemNYlSim5du9BtRaEHqy2e2qhTxw502rvVTJQn/jVNu7ZtaNdjrwekeFKhWrVsSUqX6o4iekiOXz4OFI0rbogl9hEZQ8n1rSwFY6iK0qKHs9jiCUR6nZhtbT5au53i15fUHoZhcHhvGaBWFqUUvWQb00qjlKJH92706N6tukOptbp07iRbHVei9u3a0jC1QXWHIWqocmefZ511VqHPtdZs2bKFf//9lwceeKDCAhNC1A313Q4aGq5If5MSxmvhIHWieCKEEEJUB8nxhRAVqbHHRZLtQOuS56nk+XSdKJ4IIYQQouYqdwElISGh0BI9wzDo2LEjjz76KMcff3yFBieEqL2cStGnfjyHJsdh/a1RxxVfHLFCmnk/+qswOiGEEKJukRxfCFER3IZiQINEuifF4p9uE99DU9xueFZYM/d7yfGFEEIIEd3KXUAZN25cJYQhhKitWh7ipGE7k0COZum0IIE8TZs4D4NSE4l3Rn4F5fwOwREaZ4PIUv692XZk0DX5zdxqiF4IIYSoGyTHF0KUR9s+Tuq3MMlN1yz9I0A4AJ0SvBzVIJEYR2RZeeaPipSLNGY8qH1WmtuWxgrBb+/mVUP0QgghhBBlV+4CSps2bZg1axb16tUr9HhGRga9evVi9erVFRacEKLmatHTwSUvJdK0s3P3Y4Fczbr3LPRnLtB7pqLpkGLjbQZNnrPwNFNYoUjRRBlgBeHd6zLYsCBcHV+GEEIIUSdIji+EKIsOA1wMey6B1NZ7biX4Mm3Wv63heyd7Lzexc/Jz/GctXPUVVjiy4twwI+OCt67IIG29VdVfghBCCCFEuZS7gLJ27Vosa/8kJxAIsGnTpgoJSghRszXu4ODWL1NwuAqv13fHKtpf4yA9SbPjrT3PhW3NzP+ymdM/m67Huek2xI3DrVi/IMTMz3zkZUjvEyGEEKIySY4vhChN2yOc3PhxMsoo/Lg30aDjHbA9RpP+2Z4cP2jbTJuZxcLDcjn0VA8dj3RjGLD63yD/fOEnkCs5vhBCCCGiX5kLKN9+++3uj3/++WcSExN3f25ZFlOmTKFVq1YVGpwQomY65a44HC6F6dh/w2OlIPl8TfqXmvAOxfpcP79uyyQjFFlhMm9igHkTA1UdshBCCFEnSY4vhCirM++PRxlgmEU3Nak/QpP5vcbOU6zM9vH79kxywpHC7D+f+/nnc+l3IoQQQoiap8wFlDPOOAMApRSXXXZZoeecTietWrXihRdeqNDghBA1jyde0fNEd7EDKwA0eIfYTHgxk2XZvqoLTgghhBCFSI4vhCiLei1M2hzuKvEY5QJzgMXXYzNZkyvFEiGEEELUDmUuoNi2DUDr1q2ZNWsW9evXr7SghBA1V3yyUXLxBNC2ZoUjT4onQgghRDWTHF8IURbJDY1Sj9GWZqHKkeKJEEIIIWqVcvdAWbNmTWXEIYSoBZp5XQyJS0JboMwSDjQgbbM0jBRCCCGiheT4QojitI71cIwjsdTjlAm7tkiOL4QQQojapUwFlFdffZWrrroKj8fDq6++WuKxN910U4UEJoSoOUJZDoY2TqZDQgxYkP27RfzRoIr5DaM1zPpSZqYJIYQQ1UlyfCFESZKcJgNTk2gV54FdkDffwtut+IlSQZ9mvvQyFEIIIUQtU6YCyksvvcRFF12Ex+PhpZdeKvY4pZQMroSopdwxirZ9nDhcik2Lw6RtsLDDil0zk9n5R306JOxZ1r9zrEFsHxtDFT3A+vnVXDK32VUYvRBCCCH2JTm+EMKbqGh7mAtlwvr5ITK32TiU4oh68RyaHIfD2LM17443DJq/Fsnh987xtdYopfjqsRwCebqqvwQhhBBCiEpVpgLK3kv6ZXm/EHWLYcLJd8RxzJUxuGMjRRJta9b8EWb9Bw3wrdi/mWRog2LuVRaN7tA0O3TPr5m8DJsfX85hylt5VRa/EEIIIYomOb4QdZfDDWc9EM+Ai2NwuiNFEtvSrPwlRN5rTrx5+98q8C9VzLkmTPM7oWGnPc9n77T59qkcZnws/Q2FEEIIUfuUuwfKo48+yh133EFMTEyhx30+H8899xwPPvhghQUnhKh+F72QQN9zvai9Zp8pQ9F6gJNwF1h3pcbK2POc37KZsSOThcvy0FOhcUcHDduZBHI0K/4KEg5Wx1chhBBCiJJIji9E3aEUXDUmiS6D3BjmnjzeMBXtj3cR7AzrrtVo357ncsIWf27PZNkyH0yE5t0d1G9hkpuhWfl3EDtcHV+JEEIIIUTlM0o/pLBHHnmEnJyc/R7Py8vjkUceqZCghBDRoXkPB/3OjylUPCmgHOBIgeTzIsv0tdb8l5HL+DXb+C8zj4LF+1uWhZn3Q4Alv0vxRAghhIhWkuMLUXd0Geyi2xBPoeJJAWWCqwUknRzJ5i2tmb0rm/dWb2NZ9p4VJhv+CzP3hwDLp0vxRAghhBC1W7lXoBTsb7qv+fPnk5KSUiFBCSGiQ7/zvFghjenc/988RAZYSSdrcn7wMXZ6NtsDoSqOUAghhBAVQXJ8IeqOfhd4scIa01F0jg+QeKpm/ng/v23PJD0oFRIhhBBC1F1lLqAkJyejlEIpRYcOHQoNsCzLIicnh2uuuaZSghRCVI8mzZwYRTSB35uZCC1HrGP71PiqCUoIIYQQFUZyfCHqnsYtnCUWT5QBpGi+2phWdUEJIYQQQkSpMhdQXn75ZbTWDB8+nEceeYTExMTdz7lcLlq1akW/fv0qJUghRNVKdTs5skEiDXxOsHXJm/2FrfLvBSiEEEKIqCA5vhB1RxOvi6MaJBKXZaKtyGryomitydxhVW1wQgghhBBRqswFlMsuuwyA1q1b079/f5xOZ6UFJYSoXIYJbY9wEZeiSNtosX5+ZFl+gtOkX/0EOiVEGshm/aJJPkMXfyJbw+asqghZCCGEEJVAcnwhag/TCe37ufDGK7atsti8NJLjp7gcDGiQQJs4LwBZP2vij7KLPY+2YfpHvmKfF0IIIYSoS8rdA2XgwIG7P/b5fIRChXseJCQkHHxUQohK0+dcD6f/L56kRnumnG1dFmLh0xaNV8Xg2KthvH8xZP8OcUflL+XfixXWmLaFWp9eVaELIYQQopJIji9EzTZ4ZAxDb40jLmVP0r5+XojlT9k03erF2Gt7vpwZkDcfvN32X4VihTXpmyz+fD+vqkIXQgghhIhq5d55Jy8vjxtuuIHU1FTi4uJITk4u9J8QInr1H+blsleTSGxY+J9+w3ZOhrztIb7Hvq9QLH9Is+CjAOFg4ZUo6+aFULM3ooKyvF8IIYSo6STHF6LmOvHmWM59LKFQ8QSgeXcnx4xz42mzzwtsxcLbbJZ8F8S2Cuf4y6cHeeGMXfiySliFLoQQQghRh5R7Bcqdd97Jr7/+yqhRo7j00kv5v//7PzZt2sRbb73F008/XRkxCiEqgNMLZz8cj9a6UINYiMw80xY0uM5m/XWRaWgBy2bWrmzmpedg3QmxTyk6HenG4YaNC8NsWhLmzQ9DRb2VEEIIIWoYyfGFqJni6hmcfHtckc8pE3BC/eE2mx+I5Ph5YYuZadksysjFvhYSHzZo39+F6YA1s0NsXy2To4QQQggh9lbuAsp3333He++9x6BBgxg+fDhHHXUU7dq1o2XLlnz44YdcdNFFlRGnEOIg9TjOgze++EVnygRvFzCb2sz6L49Zadn47T17I+fu0sz+1l8VodZ5Zu/OLJ/TjOMuLih02bw2eT6d+vas1riEEELUXpLjC1EzHXaGZ7+tdvemHBA3AOw4i1lrc5m9K4eQ3rO6JHObzb9fSY5fFa47+mRWzGkI7MnxP1r9DA1SU6szLCGEEEKUotxbeO3atYvWrVsDkb2Qd+3aBcCRRx7JtGnTKjY6IUSFadvCjbZKX4o/NZzOHzsyCxVPRNU49kYPq9QQls9pTuFfzyY3HvsqQ1Mura7QhBBC1HKS4wtR8yigTQsXlJK2KwO+z01jZlp2oeKJqBrbV4/kuLgrWDGnEfvm+MPa3MuZzUZWV2hCCCGEKINyF1DatGnD2rVrAejSpQufffYZEJm1lpSUVJGxCSHKocMAF0NvjeXEm2Np1cu5+/HWsR4ubNmADlYMylQlnCFi6xbZlquqKQVPzqnH+HF9gL07eSr2zFCDcNDJyze8UdXhCSGEqAMkxxci+igDug1xc9JtsZxwYyxNu0Q2kFBAx3gvl7ROpUXQW2qOr23N9u3hKohY7M22AthZ/bioZ4jCt14K5/g5GZq5f8yv6vCEEEIIUUbl3sLriiuuYP78+QwcOJB7772Xk08+mddee41wOMyLL75YGTEKIUrQsJ3J1e8m06i9AyukQcFp9yi2LAiz7j5FcrYLgJwZGtunMbxFn8e2NBsXhdm6QvY9rkrt+zu46dN6pGco/Dnu/EeLGgRHHvth3Cxuef3aKotPCCFE3SA5vhDRpUVPB1e9k0xKM3N3jn/6/+JZNyPEtkdMEgORCVNZUzUNri1+VYkV1iz+NUDuLll5UpXswM8QuJ8PXgR0wW2X4nP8u4a+zKScsVUVnhBCCCHKodwFlFtvvXX3x4MHD2bp0qX8+++/tG3blp49ZX9+IapSXD3FrV+mEJscmdFkOvck5Y26OKj3JqwdodF+hfYrdoxWNLx5/8GTbWm0hi8fza6y2AWMfCeRQ0/yoJTi7Yfr5z9a0gxCXcrzQgghxIGRHF+I6FGvhcktn6fg9ETyvr1z/BZHOEl9BdZfp8FWWLsUaR8q6l9adI5vh+G7Z3OqLPa6zrZDkHsd6HkAJNQrmL1WWo5f7s1BhBBCCFFFDvqvdIsWLTjrrLNISUlh+PDhFRGTEKKMjro0hrgUA9Oxf0KuHOBsAglD9gymVn1iMfnBPHLTC2+UvGuTxaiL01k+PVjpMQto1cvJiytS6XWyF6Ui37s2Hcty7aV4IoQQompIji9E9RlydQxOjyo2x/d2gti+ex5bPCrM78/78OcUzvG3rbJ46exdbFwo23dVBTs0A3KO3l08AUhPN5EcXgghhKjZyr0CpTi7du1i/PjxvPvuuxV1SiFEKY4424sqqQyqIf5YzdqvQvy9M5vl2T702/Dt+Cw6Hukirp7Bro0WK2eGkH6Slc/phYtfSOSwMzz7Pff7xILHSlplIt8kIYQQVUtyfCGq3hFne4ssnhTQFiQM1qydGuKvndmsyfXDC/DVKEWno114ExTbVlqsnSu9DauCbWdD3l1g/7vfc1vWOpFV5EIIIUTNVmEFFCFE5YhNUSQ3McnLsNm1cc+sslS3k6Rkc/cKhqIoA/K8Fu+v2VHo1ns4CIumymqTqtT7dDeXvJyIy1N0xWvUj9s5oUlDSl4YqACZQSiEEEIIUdMlNDBIaGiQvdMmc+ueHL+J14U3ruSb7cqEnc4gH61LK/R40KdZ8HOgUuIV+9Nao4MTIPAiUHQfyXteTufXz5rlf1b899UVIwUWIYQQIlpJAUWIKFW/pcmZD8TT80Q3hhlJqNfODfLb8z4aLPXSLt6LtclCJ0YGUUWxwpr1y4OybqEaJTVWXDMumRY9XOhSlvkcOngjc39tnv/Z3oOogllrmkk54yonUCGEEEIIUemadnZwxgPxdBnoQhmRfG/5jAB/POenxcYYWsR6CG21cDam2JXmVlizbqVMhqpOtrUW8m4FvbHUYw87ZjP/Tm3K/itR9uT4P2wfUylxCiGEEOLgSacyIaJQg9Ymd/9Yjx4n7CmeALTs4eSy9xM55KTIdk+Z36piiycApkMx/UNfZYcriuD0wpkPxPH4rFRa9HABlLhaCODpD9M5pP8GIoOpfYstNl9sfqlSYhVCCCGEEJWvVw83d35fj05H7SmeALTv42L4Z4l0HOAGIOObknNG06GY8ZHk+NVB6yzsvCcg99wyFU8AnvggjZ79NhecYZ9nLSblyBaJQgghRDQr8wqUs846q8TnMzIyyv3mDz/8MI888kihxxo2bMjWrVt3P//JJ5+wYcMGXC4XvXv35oknnqBPnz7FnnPcuHFcccUV+z3u8/nweDxlel8hqtvZD8Xjid+/caQyFdqGRnfarJppkDVVkXCcJuaw/WeoaVvzz5d+lk6T2WlVrX1/J8NHJZHQwCg0OC6LZz5PB9K5fZiTtXNbow3NmIcnUm9ERqXEKoQQom6THF+IqvPGM6k4XGAUleMTyfHXXGSQ8Y0i/hiNp71G7TWZStsaZSgmjcpl0xLZ1rUqaW2jw9PA9yiQXe7XP/vFTmAnN54Wy8blTXE6bT5f93GFxymEEEKIilfmAkpiYmKpz1966aXlDqBr165Mnjx59+emuWc6fYcOHXj99ddp06YNPp+Pl156ieOPP56VK1fSoEGDYs+ZkJDAsmXLCj1WMLAqy/sKUZ0SUg26HefGKObGuzLATIDY/rBjquazq3JocjkcdXkMMUmRKkrWDospb+Ux+Y3cKoxceOIUV72bRKej3GitS11xUpKHXvORsOhHjLBd+sFCCCHEAZIcX4iq0a2Ti8MO8RT7vDLB1RS8PWDHHJsPL8qm7TUG/Yd5ccdGcvz0zTY/v5bDH+/J6pOqpO00dN4tYC896HO99m0cxL6NYcYcfGBCCCGEqBJlLqCMHTu2cgJwOGjUqFGRzw0bNqzQ5y+++CJjxoxhwYIFDBkypNhzKqWKPWdZ3leI6lSvuVls8aSADsPWJD/vr04naGt4Bn54KYfUNg60DdtWh7FlUlqVcccq+g/zcsqdcXjym34eaPEkHNR8eEcGf08I8OaHUjwRQghRuSTHF6JqdGjlLNNxa+Jz+Xx1JpaGOQ/CN0/l0KC1iRXSbFtpUUpLPVGBtJ2BDn4JwTHAwa7qd4L7GQz3URURmhBCCCGqULU3kV+xYgVNmjTB7XbTp08fnnzySdq0abPfccFgkNGjR5OYmEjPnj1LPGdOTg4tW7bEsiwOOeQQHnvsMQ499NADel8hKoM7VnHE2R4OOcmDO1axcWGYP97Lw1pjMCi25JmgABia5Vt9keJJvnAQNi+VqklVS2hgcOtXKTRoXXrhqyRaa/6b7OedKzMJByowQCGEEKIaSI4v6qKYJEW/8710O9aNw61YOyfEH+/l0W9rDLd5G5bpHEu3+LH2KpIEfZpNiyXHr2ra3ojOvRL0zoM/mWMoyvsQqqTmlUIIIYSIWtVaQOnTpw/vvfceHTp0YNu2bTz++OP079+fRYsWUa9ePQC+//57LrjgAvLy8mjcuDGTJk2ifv36xZ6zU6dOjBs3ju7du5OVlcUrr7zCgAEDmD9/Pu3bty/z++4rEAgQCOy5q5mVlVWBV0LUJQ3bmdw8IYXEhgZag2EoWh7i5OjLY9gxRrHrfUVgjY2r5f59TQrYNsybKHfZq1NqW5MhV8fS/wIvhuPAVpwUbPO1fU2Yd67MYOMiGRwLIYSo+STHF3VRy54ObvgkBW+CQgHKULQ61MkxV8ZwzUsGmRMV4V02jpTiz+HPsVnym/QvrE7aWob2fwDWz+zf8L2cVHvwPoXhaFkhsQkhhBCielRrAWXo0KG7P+7evTv9+vWjbdu2jB8/nttuuw2AwYMHM2/ePHbu3Mnbb7/Neeedx99//01qamqR5+zbty99+/bd/fmAAQPo1asXr732Gq+++mqZ33dfTz311H5NKYUoL8MBN3yUTHx9A6UUBffcC5rFNxihCa5T7HzHoOkTNlrDvvflta35bUwe2Ttle6fq0q6vkxs+SsF07vneHYhgnuaz+zP56xN/BUYnhBBCVC/J8UVd44lT3PBxCt44VWhFckGe2PC2/Bx/jKLRncXflP/x5VyCPtmjq7ro0G9o3z1ECicH832IA88DGK5jKigyIYQQQlSnYua3V4/Y2Fi6d+/OihUrCj3Wrl07+vbty5gxY3A4HIwZM6bM5zQMg8MPP7zQOcvyvvu69957yczM3P3fhg0byhyDEAV6nOCmXnNHsTfdtQUpF9rkTFeseNQmlKfRWhMOaWwr8t+vY/L48tHsKo5cKAP6nOvh7p9SuPXLFJyeAy+e2JZm6uhc7u6+Q4onQgghaj3J8UVtd8Q5XmISFUZxuaEFyefZZP5gsOolm7Bfo+38HN/WhIOa75/LZtL/5VZt4AKtg+jg59jZ56J9dwIWcKAT1QxwDkfF/yLFEyGEEKIWqfYeKHsLBAIsWbKEo44qvrGa1rrQMvvSaK2ZN28e3bt3P6j3dbvduN3uMr+vEEXpMsiNFdKYzqIHV8oEb2eYkZPB7DdycYxTHHqKm/otHeRl2Mz5zk/mNll5UtUME0a8lcShJ3uwbX1Q23Vt+C/EG5enk7FZvo9CCCHqBsnxRW3XeaALDRSXISoHxByuuX/rFlKftfG8qeh1qoekxibZOyxmf+cnd5esPKlqWvvReTeDNefgT2YcAjHPYhjJB38uIYQQQkSVai2g3HHHHZx66qm0aNGC7du38/jjj5OVlcVll11Gbm4uTzzxBKeddhqNGzcmLS2NUaNGsXHjRs4999zd57j00ktp2rQpTz31FACPPPIIffv2pX379mRlZfHqq68yb948/u///q9M7ytEZYpzmfttyVWU/7LysIk0jfx7gqxQqC5tDncyaEQM3Ya4ccdGvnEH0ihe25qcXTZjrs1g+Z+hig5TCCGEiCqS44u6Jt5tljrBxlLwZWYmVxOPL0sz/UNfFUUn9qXDM9HBTyE8CzjIvpKqIXifwXB0rZDYhBBCCBF9qrWAsnHjRi688EJ27txJgwYN6Nu3LzNnzqRly5b4/X6WLl3K+PHj2blzJ/Xq1ePwww/njz/+oGvXPcnJ+vXrMYw9O5FlZGRw1VVXsXXrVhITEzn00EOZNm0aRxxxRJneV4iD5Y5RHHWplyMviSG5iUluhs2sz/z4vjZotM6DMoufXWbbmp1rLfzZMgOtuh1zVQznPJJQ4oqhsgj5NVNG5/LL67nyfRVCCFEnSI4vaqOYJMXAK2Lof2EMCQ0MsnbY/P2xD35wEr/aBUdrMIt+bTis+XuuTIqKBrb/dQiOJ7Kb+cGsCI9BuS8D1zCU8lRQdEIIIYSIRtVaQPnkk0+Kfc7j8fDll1+Weo7ffvut0OcvvfQSL7300gG/rxAHw5uouPXLFJp0dKAUKEOR1Mjk2OtjsC5WbLgD7FwwvJHtuvalgKmjZe/j6tK8u4OBl8fQaaCLlKaRX48HUjwp2K5r+YwAoy5OJygTDIUQQtQhkuOL2iaxkcEd36aQ3MTEMCO5YUozg6G3xxG6GDbdD/UuAVSkb96+HA7Fq29nVGnMYg8dnocOToDwbCAt/9GDKJ6Yg8D7JMpwVkB0QgghhIh2UdUDRYia7pxH4mncwbF7YFVAmQozARrfo9l0v6LZM5Hm8AWNJq2wxnQo/v3Gzx/vyd326jBoRAznPX7wK04ANiwM8+NLOfz3SwDbqqAAhRBCCCFEtbjkxUSSGpuFcnylFJjgTIUGV2m2PGbQ5CEb294/x395dDpf/pBTXeHXabb/DQi+S2R50EEm5kZPlGc4mP0OqCeiEEIIIWomKaAIUUFikxWHn+nFdBTTIN4Bng4Q8mk+PT2HRudEmkc6vYrNS8L8PjaPOd/60bLLU5VJbmrQ73wvrQ9z0XVwpIHsgRZPbEtjmIrvns3mx5dkFZEQQgghRG1Qv6VJl/w8sSjKAbF9YMOLNr+dmU2rC0x6nODGdCrWzQvx6zt53D55ZxVGLLS1Hh36Hqx5YM3Nf/RAiycGoFGeu1CucyomQCGEEELUKFJAEaKCNOnkxOEq+ea7tjWLUnP449tcmA8THsiuoujEvo67PpbT/xeHtiNbLRRsu1Ve2tYE/ZFGoH9+kMfW5bLkRAghhBCitmjZs/RtmpSCf1My+esbH9P/hQ/vqILARJFs/8sQ/JAKWXFCHLjOQrnORBnNDj44IYQQQtRIUkARooIYZdxGNydwMM0KxcFyeqHPOV7OvD8+8kAR+1SXhbY1KEjfbPPyObvYuU4KJ0IIIYQQtY1Dl22CTZ7k+NUqNkZx85VJ+cUTOPDiiQI0GG1QMf+HMupXTIBCCCGEqLGkgCJEOXniFP2Heel3vpf4Bgbpmy0WfBKk0exYrBww40p+/ZLfg1UTqCik41EuTrwplo5HRrZgOOAVJ1qjNSyfHmTWl37+/cZHSNrWCCGEELXKWOpuv4q3qJsrpOulGFx5cSKXnJNAcpLByjUhJn/io9PKBHQIVAkLUQJBzX0zd5FehsbkdfX6VpbTT4xl+g3N6Nvbe1DnsW2NZcMvv+Xw4efZfDlxBaFQuwqKsvZQsUnVHUKtJte3csn1rVxyfUVtJgUUIcohIdXgtq9TqN/SBMAwFPH1DFr0cBFYDhnfQMqFkS2h9mWFNf/9EiBtvaxUqGr9LvBy8QsJ2HuNaQ+keGJbGisMo4ens2iqFMKEEEIIIWqDdq2d/PZVM1LrmxhGJE9skGIy4Agvuf9C5k+QeBIoc//XWpbmnQ8ySc+QFShV7c7rk3n6/vqErQNvIqm1xrYhN09z0rBN/PWvvwIjFEIIIURtIAUUIcrhslcTqdfcxDD23HxX+R+720FgNWRNgsQTIgUT06F2/3/tnBDv3ZJZXaHXScqA+i1Mhj2XAApMx4GvONm4KMzCyQH+fD+PjC0yQBZCCCGEqC0+H9OY+vVMTHNPrmjkfxzTC3Z9BrmzIK4vhMMah0MRCmucDsWPU/O481FpEl+VTBN6dXfz9P2R7bUc5gFMjLIjhZN/5/v59udcxnyUxc40megmhBBCiP1JAUWIMmrYzqTzQHexzysTEo6D6SeHWfBmNoec56Z+S5PsHTb/fOFn4ZQAWu67V4mkxgbHXx9Lvwu8uGONA96uywprtA2jR2SwcHKgEiIVQgghRDS6gjhclD93qKn23lbqauKrMZKq166vk+6dS8jxDUg6FaaeGGJ1sxwOPcdDUmOD9M02Mz/zsfzPIJfrkvfwrcvXtyI1aG1ywg2xHH62F6dbHXCODwaG4caMe5X+gw+h/2B4+ukKD7fW2HtbHp2bUW1x1FZyfSuXXN/KVdOub1ZWFomNW1R3GKIGkgKKEGXU5jBXqccoByyon8XCqUEWzpQb7tWhfkuTO79PISbJ2L3ipDwDK50/G23HWouFkwNMG5cnDeKFEEIIIWqptoe7dq8YL44ZC7M8mWz8Lcz83yTHrw7Nujm47csUnF51QDl+hAOM5uAYjHKdhTIaVnygQgghhKh1pIAiRBmpMm6ta8kqk2p10QsJhYon5WGFNbYF/zcsneUzpMeJEEIIIURtZ2goy314WUlevYaPSipUPCkfE3CjYkejzI4VHZoQQgghajkpoAixD6Wg8yAX/S/0Uq+5SdYOmwVfBemwIRZdygAr5NesnROqumAFEFnO3/c8L407OOg4oPgtGIpSsPTfCmvmfu/n59dy2bQ4XEmRCiGEEEKI6mCY0OMEN33O85LUMLIF16IvgrReE7e730lxcnbZbF0h+WFVa9LJQZ9zPDTp7KRR+wO9deEE54ko1+UoU7ZtEUIIIUT5SQFFiL2YThg5OomeJ3p2L+W3LU334zz4lkDuXxDbJ9LvZF+2pZn+YR6+rDIuVREV4qwH4zn22lissKa8W5XbtgYNr16wixUzg9gyLhZCCCGEqHXcsYrrP0imXd8923U176Y55CQPubPAtxg8HSLb8e5L25qpo3OxZI5UlTEccNHzCfQ7PwYrpFEG5ex3ogATYt5BmR1RRX1jhRBCCCHKyKjuAISIJqfdE0/34yMrGAqWhxfMSPN0AK0gsDJyrG1FCiVWOPL/ZX8G+erxbETVOe66WI69NhaIfL/MUmYPFrAtjW1rrCCMuSaDZX9K8UQIIYQQora64OkE2hzuBPbK8fP/H9MLAusgtAW0zp9gw54cf/a3kRXKouqccV88fc/1AmA6FYapylQ8CYcLJrJ5UTEvYzi6SvFECCGEEAdNsgkh8rljFEdf7sUwik7OlQlxfWHuBTYrGubS42wXCakGuzZazPjIx4JfArI3chVyuOD4G2LL/TorrJn9jZ9180LMnODDlykrhoQQQgghaqvEhgaHn+kpdpsuZULCsfD3mRabOufR40wXsUkG21ZbTP8wjyW/SV+8qhSTpBg0PAZVzJisOD6/zadfZ3PF5U9HtuxSMZUUoRBCCCHqGimgCJGv5aFO3DElL8pSCpY1z+GPD/P4fYLMRKtqDVqZDBoRQ8+hHtyxEJtUvkV0tq2ZOjqPrx6TlUJCCCGEEHVB+36uUnucGE5YUC+L+R8EmPqB5PhVrUknB4NGxtDtGDeuGIXDVf5G8Q8+k8aLb2Yw/KqzKiFCIYQQQtRlUkARIp9RRF+TfWmt0YasWKgOnQe6uGZ8Moa5Z+uF0mit0TZoO7L8/+8JPr55UoonQgghhBB1RVly/MiBlRqGKEbv0z1c/noi6Ei+Xla2pdE6Mi548c10Xnwzo/KCFEIIIUSdJgUUUSfVa2Fy5MVeGndwEMjT/PdjgMarvegQKGfxr1NKsXqWdJCsat5ExVXvJmE6KHUG4d6UUiz5I8DmJWH+nuBj0xJpdCKEEEIIUVs16mAyYFgMqa1N8rI087/103pz6Vs52ZZm7TzJ8ataveYml7+eiGFQ7i27/pscYMuyMH994uPxNRmVE6AQQgghBFJAEXXQMVfHcPaD8dh2ZEaatuDwM70E1kP2nxB/dGQv5H1ZYc2a2SE2L5Wb8FWt3/lenB5VbH+aolhhzbaVYV6/ML0SIxNCCCGEENHg9P/FccKNcVhhjWGCbUGfc7z4lkDuHIjpAUX1E7fCmnkT/WRulWaGVe3ISyKN4stTPLHCmuUzgrx1eUYlRSWEEEIIUZgUUESd0uMEN+c8nACAmb9Mv2Ag5WoSKaYEVoO7LYBGGWr3NlCZ22zGXp9RHWHXOSnNDAZeHsOhp3hwegoGVOUbWIV8mnE3ZFZOgEIIIYQQImoMuNjLCTfGAXu2ejXzc3xPe/AthNA2cDaGghzftjUK2LYqzCf3ZFVL3HVNaluTQcNj6HG8B8MBDpcq89a8EMnxc9NtPrpTvl9CCCGEqDpSQBF1ygk3xmJbushtoJQDPK1hzV2wOiaPjuc6SWlmkpNm89cnPv54P4+8DOl/Utna9nFyw0fJhQZUtg1GKftSa61RShEOaP750sfPr+WyY41VBRELIYQQQojqohSceFMs2tZFrmRQDog5BJZfCxta5NH1HBcJqQYZWyymf+hjxkc+AnmS41e27se7ufLtJJSxp8ily3DZC3L8QF5kTPbL67lkbJHVQkIIIYSoOlJAEXWGN0HRurerxGPskGZLJz9f3JcFb1VRYGI3l1dx7fhknG5VqMhVWvHECmtWzgwyemQGgVyNLbusCSGEEELUCaltTeo1L3lYqy3Nqpa5fPdKDl+8WkWBid0SUg1Gjo70M9y7yKVKWXxihTSzv/Xz6X1ZBHI0tsyNEkIIIUQ1kAKKqDNMZ+nLw23AcsgMtOpy+FkevAkKVcxoSuuiB1qmQzHpjVx8mTXve9eoo8Epd8ZiKPj26Ry2rqh5X4MQQgghRHVxlCHHt2ywZeRbbQZc5N2veLK3onJ8rTXKhKlv18wc3/b9C6GxgAfct2C4m1d3SEIIIYQ4QJJGilrJ6YFep3qw27kjGfmOXNrYXkI7wVGv+NlOpgPWzQ9VbbB1WFJjg8PP8pLUyCBru03zHg5sS+3es3pfBd+3gqX8VlhjOhRfPprF4qnBqgv8IBkmPPRnCvVbOgF2F4x6Do0B4Jc3s/nm0bxqi29vzzzzDJMfW7Hf45Ny3qmGaIQQQghRl7ljFYed6aFxBwfBPM3ciX6a7/Ji+8DwFv86h1OxfoHk+FWlfkuTw8/yEJdisGujRccBrhIbxStVuIhihTVKwQe3Z7F+fs1ZWm6HcyDvFCC38BOBadgBgJswEi6phsj2Jzm+EEIIUXZSQBG1TqejXYx4K4nYJAPs/NlKLVO4bAJk/ahIuUgX2Y/ctjSBPM2/X/mrNuA66tS74zjhxlgAbCtSVFCGQmsFlDzLbO2cEA6XYu28ENPG5bFpcc0ZWJ3xQBzHXRtb5CqbgseOvyae46+Jx6Zh5Imduaj8olFVOi5u5F6f6f2ekwGWEEIIIarKoae4ufSVRFxehRUCZcCJN8eR+w9k/gxJp4Iy93+dFdZkbbdZOCVQ9UHXMYYJ5z2ewFGXerFt0PaeHL80VkizYWEI06FY+XeQaePz2L6qZuzZpbVG59wLekopR76KnbXXHnLmCRixj1dqbEWJ5PiayKC4IMePfCw5vhBCCLE/KaCIWqVJJwfXvZ+MUTB42itZ93QE5dbkzYWYQwH2NJq0QhqtYczVGQR9NW+JeE1z7LUxDL0lbvfnxl6DXaWKv/6WpVk/L8Rzp+yqzPAqRe/T3VzyUiIubykNXWD/QkmDOHR2H3TcDAyjan5tX3/6/yg8oNo7Jo0MsIQQQghRVdr3czLirSQgkic59mprGNMbMCGwEtztoVCOH9aEA5q3R2agpe94pTvjvniOutSLMhRm6SnvblZYs3BKgNHDMyottspi+z6G0EuUNgGsSNbP2FlTUfHTq2yi1J7iSYF931dyfCGEEGJfUkARtcpx18WiDAo1IC+gHOBpBxvvVyz+KUDz8wwatjUJ+WHO936mvJnLpiU1ZyVDTeVwR2YLlqTYXiemYvIbufs/EaXccTD05jgGjojBXYbCSck05JwECb9USGylWT5lO0Uu1QIKz1YTQgghhKhcJ94Sh7Yjfe/2pUyI7Q1rb4TtLQO0OdekXnOTQK7mny/9THkrlx1rasZKhposNkUxaERMiX1OoPh+hr++XXNyfNtOB/8oCH8HHOzPVgidcxEq/qOKCK2MJMcXQgghykMKKKJW6XWqp8iBVQEdhsxeAcZevwter8LAxG4d+ruISSy5mKBUZMk/Kr/XSUhjOhUTX8xh7g/Rv/1CfH2DC5+Jp8eJHowybFlQdunYdrjKVqHsWdpflPxl/g1HMmmbzFATQgghROXwxCs6H+0u8Rgdhs3dfHzwcCa8UEWBiUK6DXHjcJXc5wTAtsHIHwpYYY1hwIQHslnxV/T3qLHtjeB7EqxZFXtivX8vkspVeo4vhBBCiD2kgCJqDWWA01PyzWptaEIeWb9fndwxZSso/PuNj3otTNxexfr/Qkwb52PdvOgeWDlccN5T8fS/IKaCCyd7Cc8CV7/KOXe5qf16ZAohhBBCVKSy5I6W1oTdctO3OrljDbStS+138s8XeTRq78DhVKz+N9LPcPPS6N4FwLZzwPcYWFMr8T0yMYzESjt/YVXbV1EIIYSo6aSAImoNbcPOdWHqNTeLXzpuw9aV0Z2g13ZbV5ZtmfuUt3JZP7/mfK+OvtzLmQ/E44452K26ShMtRaTITYpjH+hQzXEIIYQQojbLTrPxZdl4E4rPsQxTcvzqtm1luNTiibY13z+bw66NNWNCm9ZhdOA9CL4NVPbPV1UWAEtagSKFSCGEEGJflX2nT4gqNW1c3u79dYtiGDD9Q1/VBST2s2VZmDWzg1jhor9RdlizcVGoxhRPGrQ2uefnFC54KrEKiieA2afy36PMFHfffXd1ByGEEEKIWswOw58f+IrNHbXWWCH45wvJ8avT8ulBdq4PY1tFf5+ssGbx78EaUzyxw8vROedB8A0qv3gCSlXV6hMofQWKrFARQggh9iYFFFGr/DY2jzVzQvsn7vlVla8ezyZtvTSRrG4f3pFF0Kf3GwhbYU0ooHn/1sxqiqx8TrkzjkdmNKBFD1cVvaMDwyx5D/CKMinnHfYMnvYdCMvMNCGEEEJUnZ9eyWH7amu/3NG2NGj4+K4s8jIkP6lOWsP4mzKxwhSZ4/syNZ/9L6uaois7rW1s39OQdxHoDVX0rokoVTVFi0iOX6CoHF+KJ0IIIcS+pIAiapVwAF49bxc/v5ZLzq69ZjflBHj7ynQmv5FXfcGJ3TYvDfPM0DTmfOffPcCywpr5P/p55qQ0NvwX3atP2vdzcucPKZx0W1zVvrFnUpW+XeEBVoGCgZUq5nkhhBBCiIrly9I8f2oav43Jw5+9J8dfMyfE/12czszPZPVJNFj1d4jnTklj0ZQAth3J8cNBzawv/Dx9Yho71kbvRDatNTo8A517PoS+qNo3j/25St/u2AfaF/HonuKJ5MNAErkAAI73SURBVPhCCCFEYdIDRdQ6IT9890wOP7yQw/996gNbo4IWc7+Pr+7QxF62r7IYe10mH92ZRVyKQW66jT8n+mcOnvNoPMdcGYsuaa+4iqQ12DbETsdweavmPfdSMIA6Lm5k/iNSOBFCCCFE1fNlab54OJtvnswmIdUk6LPJSYv+3LGu2bgwzJuXZ+BNUMQkGmTvtAn6ovv7pLWF9j0I4V+q/s1jZ2KYZpW+5d13383dd8MzzzzD5MdW5MehmLRNcnwhhBCiKFJAEbWWHQblj+6VDAICuZpAbvTORivQvIeDU++Mo9uxHoADWmavtUYphdaajK0WSY3MIs9TUJxRoTDGn2sjD55R9cWTvUnRRAghhBDRIByEXRujP3es63xZGl9WdH+ftNZgzUMHRoE1r4LOGg9kl3KMGyPhzwp6vwNXUEgRQgghRMmkgCKEECVwxypGvpVI1yGeyNL+/CJIeRS8JhzUzP7Gx+cPZ5OXrnG44JG/6pHUeM+vYtvSfPtMFpNe9/Pmh6UNvoQQQgghhBDlpe10tO92sP6rgLO5wXkyuG/GMGKwg2ngPwvYe/toBa57MDxnVcD7CSGEEKIqSQFFCCFKMPzNRDoNjDRuP9DCSdZ2m4/vyWTBT8FCz4eDcF/vtAqLVQghhBBCCFEyrW103s1gLz+4E6km4HkAw3lYoYcNVz1w/X5w5xZCCCFE1JACihBC7KNRB5Njroyl16keYhKNcr++oHCSl6H5+O4M5nwXqIQohRBCCCGEEGWlrcXowMcQ/h3wHcSZUiDmUQxHn4oKTQghhBBRTAooQgixly7HuLhmbDJKgek8gD4ntsa24Ltns5j8Rh52dG/9LIQQQgghRK2ngxPR/kcAxf+zd9/hUZRdH8e/syWbXum9dwQEBLEjIqgoijRRURF7xYoV++Pr89gV6UWqFAG7WFBsoBRFpPceano2uzvz/hGItCSbkM1mw+9zXVHYnZmc3JOEc8+5CxQ3QQ8D10MYYT0xjKIPshIREZHQpAKKiMhhEbEGg0fFY7ODzV68TeJ/m5HF1+9msGe9KiciIiIiIsFmmbsOF0/MYl7BAOe1GK4bMGxVSzI0ERERCQEqoIjIaS082qBj3wg69A6nQi07YRFGkfc6MX0W2ekWb/U5wLa/vAGKVERERERE/GGZh8AzF8vzJZi7KH7xJBEiR2Jz1C7B6ERERCSUqIAiIqet+Ko2hnycSFJNOwCGzcCy/D/fsiyyUi0WjMlk4cRMUvYUt2MmIiIiIiIlwfJtxsq8DaxDQBGS+6MZCRhh/cF5NYYtvgSjExERkVCjAoqInLYGjYgnobodw/bvjBN/J5/4vBZ7N/v4b4/9ZB4qZsdMRERERERKjGX5sDIfBCuV4hVPbGBrihH1AYYRXtLhiYiISAhSAUVETivRSQZVGzlIrGGnfvuwYl0jO83k5ylZfP5GOlkpKp6IiIiIiART1cp2GtULw8qZDtb2Yl4lFsKuxXDdpOKJiIiI5FEBRUROC9FJBr2fj+XMK8OxO3KnmViWVeT9Tsbfe4glc7PxeQIRpYiIiIiI+Cuxho3ZL1SlR9cobDYD3G9gAUXL8IGI1zEcZ2MYekQiIiIix1J2ICLlXkScwcPzkkiqZc8rngB+F098XgubDWY9l8bimdmBClNERERERPwUV8XGI58lEZloyy2eHOF3BcUGgBH+DIbzvECEKCIiIuWACigiUu5dfFvUCcUTf/i8FpuWetiy3MNPH2ayZ70vQBGKiIiIiEhRXDYkmuhE2wk5fuFjpJxgbwH2MzDCrsGwVQtYjCIiIhL6VEARkXIptpKNmAo2UpNNzr0hosjFE9Nn8e0HGcx5KT1AEYqIiIiISFEkVLMRGW8jfb+Pjr2LnuMDGK67MVwDAhCdiIiIlEcqoIhIuVKrlYOrnoih6fkuACzTwrAV3LGyLIDc/VB8Xgu7w+CfBW4+fU3FExERERGRYGvUKYwrH4+mXvswIHewk83uR45vHFnNyw74wHEZhPUPcLQiIiJSnqiAIiLlRv2znNz3USI2+7+vGTYDyyp4Kr9lWqQfMHFnWOzd5OOnyZn8+YUbywx8zCIiIiIikr+Wl7i4fVz8Ma/Z7IXn+IZhgJEIRIC9HobzGnB08nsfRBERERFQAUVEypHr/xeH3cEJo9EMgwI7WDa7wZjbD7HuV08pRCkiIiIiIv6wO+H6N2LB4NiN4ik8xwcLI3I4hr1uwOMUERGR8ksFFBEpF+q1c1K5Qf6/0vLrWJk+i9ULc1Q8EREREREpY1p0cRGTZM/3/fyLKAY4uqt4IiIiIqdMBRQRCTkOF7S9Mpwze4QTEWtj9zovB3f5/D7f9Fm5nS3gj7nZTHk4NXDBioiIiIhIoVyRBu17hdO6ezhhkQbbVnjwesDnA3v+NZS84onPZ2G3G4AdnD0xwh8qlbhFRESkfFMBRURCSnxVG/fPSKRyfUfe5pF12zqxO/xby3jGM6lggcdtsfI7Nwd3aKMTEREREZFgqlTfzgMzEomrYsOycpfrqts2DLvj8Gbwhbj94T1ERtp48//eBMe5GLYKAY9ZRERETg8qoASBhcUOfGzGy3XvgssJjatCJiaR2IIdXsizsNiNj414GfAeOO1QvzKkYxKt9i0RyfjYgIcB74HdBnUqQiomsaXQvneMT6BC7dwhaEf2OvG3eJK23+TH8Zn4yvhqXfvxsQ4P178PBlAzCW5osoamTRoHO7RyYfWatUycMo1tv+bOQqoWDwPqraDVGS2DHVq5sHHTZiZMnsLmn8Drg8px0K/GEtq3PVObtpaA7Tt2MH7SFNZ/Dx4fVIiBXhV+5rxztCluSdizJ5nxk6bw15fBjkRCkYnFVnxsw4sbCweQiJ1GOAlHP5+nysJiOz62HG5fG5CAjUY41YcqARYWu/CxCS/Zh9s3DhuNcRIV4Pa1OeDeaYnEVLRhGEbejBL74acVBf3zZpkWazd5GD05d0b5W2/2DGisxWVZFot+/4PpM2eTvHcfDoedunVqM3BAf+rWqRPs8MqF5X/+xeTpM9i1ew82m0HNGjUYOKA/jRo2CHZo5cI/q1bz4dTpbN+xA4BqVatyfb8+tGzRPMiRlQ/rN2xkwuQpbNm6DdO0qFypIv37XEu7M9sEO7RyYeu2bYyfNIXVa9cFOxQJUYZl+TOeQ46XmppKXFwcNxNNWBE6RGvwsBQ3qViEYyPCYcPCIt30YZpQFwcdcBGjTkCxbMTDEnI4gEm84aCCw4mJxS6fm2zTovbh9o1X+xbLVrwswU0yJgl2O9XCc9t3mzuHdK9FLeychYskCphjfwoadHQy5OOkfN83LbAV8OM47fEUfpyQFYDISsZOvPxh97HLl0NSQiJNGjfAsizWrFvL/gMpdL7gfF4a9jQdz2of7FBD0uI/ljD0mef47ocfSUxMpEnD+hiGwbr160jed5BOHc/ixWee4qILzg92qCHprxV/M/TZ5/ji62+Ii42laeOG2O12Nm7ayM7de2nbpjXPPTWUy7tdGuxQQ9K69Rt47Klnmff5F0REhNO8SWOcTidbt21h6/bdtGjWlKcff5Q+va4Odqghadv27Tz65DPMmvsJDoeDZo0bsmT5X6SkpBAbGxvs8KQUFSfHt7D4Gw9/kkMGFpGGDadhw7Qs0i0fNqABTjoQRkQZzUFHkJb359uJCWIkJ7KwWIOH5XhIwSTJcBJvc+KxTHaabkws6h3O8cvqYKmy3L4A6/Gw7HAfqoLDQSWnA49lsdWdQ45lURcHZ+EiLkDt2+YKF4NHJeT7vmnlDio6vpBiWRaGYdDn1l3M+iw997WMQwGJ8VR88vkXPPviKyz78y+qV6tG3Tp18Pp8rFq1itS0NC679BL+8/wwWjRvFuxQT8qIis/7c1ls32+//4GnX3iRXxf9TuXKlWhQrz6WZbFqzRoOHjxIl4su5OXnnqF92zODHepJlfX2/eW3RTw57AUWLPyJpKQkGjdsCMC6DRvYu3cv53U6mxeffYrzzz0nyJGeXFlv32XL/2Tos8/z1TffkhAfT5MmTbDbbGzYuJFdu3dzVru2PPfkULp17RLsUE+qrLfv6jVreezpZ/n0i6+IioykUePGLFmyRDm+FJlmoJQSC4tF5PAnOSTZnLR0hBNrc+SNFvVaJnt8OWz3ZLGTTK4ggsQAPYQur5bhZjE5NHZE0SsskQaOKGyH2zfb8rEsJ5UF7v3MtTLpTgSV1L5FspIcfsZNs8hwbklMoHV0JPbD7es2TX5JTWfu/oPMy8mkKxFUL4FfL2ERBmGRkHnIwvRB0wtceD0WDufJH2gcKZ54vWCzWZje3JFrPi/M+09amS6erMPDAsNNmzNa8+p993FZt244nU4A3G43n3z6KW+9+y4XdruCjz4cx5WXXxbkiEPLp198Se/rb6Jhw4aM/uADruzRA5fLBYDH4+GLr77inffe45IeVzN+xPtc379vkCMOLQt+XEiP3v2pXq0a7771Ftf07ElkZCQAPp+Pb779lneHD6fHtf149/XXuOu2W4MccWj5Y+kyLr3yGmLj4vi/V16hb+/exMTkPoAzTZMfFi5k+Acf0PfGm1m/cSNPPKI134ti1eo1XHz5VdhsNp5/9ln69+uH3W6nZl1tPCyFs7BYQDZr8VLJFkYDZzgxtn9zoBzLZI/XzUZvNjvx0oNIDZQqAguLX3GzAg9nOGI415VIHXtEXh8q0/Txh+cQC9z7mWNlcjkRJCjHL5IluPmDHNpGR3JPYjwtIo9qX5/JwpQ05u4/yFxvbh+qYgm0ryvKwBkOGQcsLAuaXujC6wGH8+THH8nxTR9Abr/A7oScLIsZT6XmFU/Korff/4D7H3mcCy+4gJnTpnFx587YbLm/AzIyMpj18ce8/e67nNPlUj6dOZ3zzukU5IhDy4RJUxh01720b9eOSRMm0P3SS3E4cn8HZ2dnM3fePN55/30uuPRyZk6awGXdugY54tDy8bxP6DdwEM2aNmXMyJFcecUVhIWFAbl9qE8//5x33nuPLlf05MPRI+h77TVBjji0fPPdAq7qex21a9Vi+LvvcvVVVxEREQHk9qG+nj+fd99/n8uu6c2Id95k8M0DgxxxaPlt8e90v/paEhMSef211+jdqxemZSnHl2LRDJRiKurotBXk8Atu6jojqe4Iz/e4HMtkpTsNLJNeRJbZUWplzVo8fE82XVwV6OqqkO8yJpmWjzEZW0n2ublGHVi/bcbL12TRLSGOmypXyCtMHS/LNHlt2y7WZGbRk8hid2DrtXPS7YEoml/kwrAZZB4y+WFKDpm163Nlt1047QXvW/Jqt33UbhNGbCUbKbt9LJmXTeahsvurbidePjOy6dunD+++9VZe0n88t9vNoNtvZ/4337Bw/heazuunJcuWc26XbnTp3JkxI0cSHn7y38Fer5f7HnyQaR99xNfzZtP5wgtKOdLQtGbtOs66oDNtWrdhysSJREdHn/Q40zR58umneX/ECD6eNomePa4o5UhD07bt22l7zoXUrl2bmdOnkxAff9LjLMvi1dde45X/+z/GffAeN90woHQDDVH79u2n7bkXEB0dw5yZM6lcuTIAqWlp1KxbV6PTTkNFzfEX4WY5OTRyRlHJ4cr3uGzTx9/uNMKBa4jEWcaW9CqrMyT+JIffcNMzvDLnuBLzPS7F9DAyYytZppdriCxzS6aV1fZdTQ4/4KZfxUSuSUrItw+V5vXx4tad7HbncA2RxV7Sq+kFYVx6XzSNOuU+gE1N9vHdJC8RZ9Xl4k67cdgKzvGHnbOX5he7iEqwsX+rj6WfZOPOsI5p37I0AnrWnLlcO2Ag99x1Fy8+91z+7ZuWRv/rr2fFyr9Z/MN3NGxQv5QjLVhZHWH+zXcL6NazF9f168dbr7+O3X7yvmdWVhY333orC378kV++/YrWrc4o5UgLVlbbd9Hvf3DBpZfTvVs3Rg0fnlc4OZ7H4+Gue+/l47lz+fazuWWuCFhW23flP6voeNEldDjrLCaNH583+Ox4pmnyyOOPM2bcOD6ZOa3MzeYvq+27ecsW2p17EQ0bNmT6lCnEx8UByvGl+IL69HjYsGGH1zj996NKlSrHvN+kSROioqJISEigS5cuLFq0qMBrjh8//oRrGoZBdnb2Mce9//771K1bl/DwcNq2bcvChQsD8jUCeLD4AzdV7K4CiycAYYaNZq4YsrFYSRnfqKGMMLH4HTetHDEFFk8AIg07t0TWxG4Y/EVOKUYZuqzD7XtGVESBxROACJuNR2pUJdbhYFkx27dVNxdDPk6k6QW5xROAyHgbXe+IoON5GYUWT9IPmGxb6eXH8Zl8+n/pLJyYVaaLJwB/2Ly0ad26wOIJgMvlYvQHH1Cvbl2GvfRKKUYY2oa99Ap169QpsHgC4HA4ePuNN2jXti1PPf9iKUYY2l5+7X/ExcYxecKEfIsnADabjZdeeIFLunRh6DPPo/Eb/vnfW+9iWhYfTZmSb/EEwDAMHnvkEXr36sWTz72Ix6Mcwh/vjxrNvv0HmDl9el7xRE7d6ZLjZ2LyFznUckQUWDwBCLfZaeaKIQWTdcrx/ZKDxVJyODcsocDiCUCczcmtUbXIwuIf5fh+8WHxOzmcHxdTYPEEIMZh54laVTFsxe9Ddeofwb3TEmlw1r/TTGIr2enxQDiNm7uxGfnn+JZpsWeDl+SNPr4flZvj/zotC3dG2c0lTNNk6DPP0/3SSwssngDExMQw+cMPiYqM4pX/vVGKUYa2J4Y9T4f27QssngBEREQwbvRoataowfOv/F8pRhjann3xFRo1bMjI99/Pt3gC4HQ6ef+dd2jZogVPP/9SKUYY2l589TUqVKjAxLFj8y2eQG4f6rX//IcLzj+fJ55VH8pfr735DnaHg6mTJuUVT0RORdCH3zdv3pxdu3blfaxYsSLvvUaNGvHuu++yYsUKfvrpJ+rUqUPXrl3Zu3dvgdeMjY095pq7du065qHZ9OnTeeCBB3jyySdZtmwZ5513Ht27d2fr1q0B+Ro34CUHqFFI8eQIl2Gjot3FP3jwoV+OhdmCl3QsLgovuHhyRJTNQYewBNbixaP2LdQufBzApGdSQoHFkyMi7Da6J8axES9ZFFzsOF5YhMGNb8dh2E7cGN5us6gcfYiMnDC85snjMH0WP4zNxPQW6dMG1X587DI93H/ffQUWT44IDw/nzttv5/Ov5rNp8+bABxjiNm/Zwmdffs2dt99eYPHkCIfDwb13382vi35n2fI/SyHC0LZv336mz/qYW2+5JW9JqYLYbDbuv+ceVq9dy4IfA/dQs7zIyMhg/OQp3Hj99SQl5b//0xGGYXD/vfeyc9cuPvn8i1KIMLR5PB5GjBlPn2uvpXq1asEOp9w5HXL81YcLIdUKKZ4cEWmzk2hz8jceLOWghVqPBw8WF7gK//0HkGBz0sYZyyo8mGrfQm3CSyYWPZPi/epDxTkcdI6PZS1evEVs39iKNvr/XyyWZWE7SY5fM24/Hp8DM58cHwO+G5lRpM8ZbN9+/wPrNmzggfvu8699Y2O55eabmfrRTA4ePBT4AEPc70uW8vuSpdx3zz0FFk+OiIiI4I7bbmPuZ5/nbYIu+Vu/YSNfffMtd995Z96yxwVxOp3cc9dd/PDTz6z8Z1UpRBjadu/ew6y5n3D7rbcWOADtCJvNxn333MNff6/kl98KHnAiubP6Jk6Zxs033khiQv77a4kURdALKA6HgypVquR9VKxYMe+96667ji5dulCvXj2aN2/O66+/TmpqKn/99VeB1zwyyu3oj6O9/vrrDBo0iFtvvZWmTZvy5ptvUrNmTYYPHx6Qr3EtHhJsDsJt/i9nVMXhIguLnfgCElN5sg4vNW3hVLf7V6AC6BiWQA4WWwihJ+1Bsg4vlZ0OmkdG+H3ORXG5UyE3FrF92/UMJzzayJt5cjyHDQzDItsbhu+oHw3TZ2FZFqsX5vDVO2V3DeSTWYeHCgmJXNatm9/nXHvNNURHRTF1xqwARlY+TP1oFlFRkVx7jf/r8Xa/9FKqVK7M5OkzAhhZ+TBr7jx8Ph/XX3ed3+ece845NGzQgEnTPgpgZOXDZ19+TUpKKjfdeKPf57Rs0YL27drx4ZTpAYysfPhh4c/s3LWLmwdqPelAOB1y/HV4qWALw2H436Wq4nBxEJMDRRxkcjpah5cmjmjibflsjHESHcMSSMdit/pQhVqPh8YR4dT04+HoEZckxJKNxdYi5vhn94/AMMi3kGAzID3Hhce04T3q1vl8uYWaP+Zk89OHZXcvw5OZNG06TZs0ocNZZ/l9zo0DBuDxeJg9b14AIysfJk/7iGpVq9L1kkv8PqfPtdcSHh7OtBmzAxhZ+TDloxnEx8Vx9VVX+X1Oj8svp0KFCupD+WHGx3MwDIP+/fr5fc5FF1xAnTp11Ifyw7zPviA9PZ2BRehDiRQm6JvIr1u3jmrVquFyuejQoQMvv/wy9erVO+G4nJwcRo4cSVxcHK1atSrwmunp6dSuXRufz0fr1q154YUXaNOmTd51lixZwuOPP37MOV27duWXX37J95putxu3253399TUVADeHJVObP6z7QCY/wAYB/1/uA+5S00B9L4ti5u0DH+BOjwF1vaoIp2TYHPishlc1j+bIZdlF37CaeyyVyFmY6RfI6eOiHHYSXTZubC7mxd6u096jBXhhHAH5PggIwcDyK4fjWnasNvzH9UW6fSw45dsomtkQeUYsNuwZeVgbE+huZXKu+OK+hUG1/XvQ7SvQd6G8f6IjIykds2q7PjpBWj4QgCjC307f4HaNRoQFeX/7wiHw0HD+nXZ+fu7MOfdAEYX+nZ+D5UqVKBChQp+n2MYBo0bN2bH8skwZ1IAowt9O7+GyAgXdWrXLtJ5jRs3Zu2i6TAnPjCBlRM7D0+CatqkSXADKadCPcf3RwYm8UUYIAX/5vgZWPg3r+L0lYlFU7v/D/cBqhw+PkMzUAqViUUjV/7L8pxMFacT++Fz81O1kYOYijYO7faRvCG3GlK5WQRWAfvSGAYkRWbwzFVeulyTQ5vLXTjDDXas8vLDuEyWzMkm1Fat2blrN40bNy5SH6pSpUokJSWxc9fuAEZWPuzcvZtGjRr5NfvkiJiYGGpUr86OnTsDGFn5sGPnLurUru3XDP4jwsLCqF+vHjt37QpgZOXDzl27qVa1aoHL8x7PZrPRuGFDff/6YcfOXcTFxmqGuZSooBZQOnTowMSJE2nUqBF79uzhxRdfpFOnTqxcuTJvqYpPP/2Ufv36kZmZSdWqVZk/f36BD2qaNGnC+PHjadmyJampqbz11lucc845/PnnnzRs2JB9+/bh8/lOWOe6cuXK7N6df6Lyyiuv8NxzzxXr6yxCzlSi554uDINij+FT+xaupL9/rdhwrIYVIO7fGS1Weg7fLq3H5j31uKnmT1BIp7eGbyfGeh+s31f84MoIA4q1jqllWfr+9YPaN7AMo3jti2VhGCH2JCQIit2+6N83fxxpIq0lXfJOmxy/WGdJIOmn2X8GRom2V5Pzw+j1bAzVm/07KGjTMi9vTz+DzbUjactS7AX02kyfxYEl+5i2GKY9nu9hIaMohZOj5eag+u1SGMMwTiFHUvsWRt+/gaXv38BSG0kgBHUJr+7du9OrVy9atmxJly5d+OyzzwCYMGFC3jEXXXQRy5cv55dffqFbt2706dOH5OTkfK/ZsWNHrr/+elq1asV5553HRx99RKNGjXjnnXeOOe74H6jCftEPHTqUlJSUvI9t27b5/XXWrgDZVtGmOWdYuaN1ahS8X6IAtSvCbrKL9A/QPl8ObtOiptq3UDWTYJsnB7MI7XvI6+VAju+E718rNhzrzBoQe+xIFisyjM7n7WBXVgIOWwHlMMuClGwMT/lZlqFmEqxZt/aY0a+FSUtLY/PW7dTU0NVC1UyCzVu3k5qW5vc5OTk5rFm7Vr9//VAzCZL3HWTPnj1+n2OaJitX/qXfv36omQRZ2Tls2LChSOetXPEnNRO0RGVhjvwOXfnPP8ENpBw6XXL8KGxkmEXLSY7k+NEqvxQqCoOdvqLNFD9yvNq3cJEYbM72P/8E2JHjwQdEH/cYoUUXF/dMSaBq42PHZ9Zq5eTVl9awKbUqTnv+Ob7Pa7Fivpsi/jiVaTVrVOfvv/8uUh91565d7N+/nxoaNV2omtWrs3rNajwej9/nHEpJYdv27dSsUT2AkZUPNWtUZ8PGjWRk+L/3UHZ2NuvXr6dGdX3/FqZmjers3LWLffv8HxDq8/lYtXo1NWvUCGBk5UPNGtVJSU1l85YtwQ5FypGgL+F1tKioKFq2bMm6deuOea1BgwY0aNCAjh070rBhQ8aMGcPQoUP9uqbNZqN9+/Z516xQoQJ2u/2EkWjJycknjFg7msvlOunmWQ8MjiaskATdwsMBsskyfUT4Oc1/tzebKAymvxLFDHUACpSKl+1ksS0sm1oO//bp+DXnIOEYfPl2FN+ofQu0Gx+7yeSvjExaR/u3DNJ3h1IxLPh1TDRLx/zbvo9/lUQNC2zH7XFis4FpWdzW9nt+3NKITjXXn1BIOfIA5P17svj7m8I3qw4VB/GxnxQ++fRTru3Vy69zps+YQbbbw4DnV0J1dQAK0r/9DoZ+dAbTZ8xg8C23+HXOJ599xt79B7nx2V+hWdMARxjael14iHsnNWXipEk88tBDfp3z/Q8/sGnLdgaO+RLO7hjgCEPbZd2ySZzQlLHjx/PSC/4t17dk6VKW/fU3z8+cBt3931vpdHReDx+1P2zNmHHjaHvmmcEOp1wLxRzfH41xssh0U88ycfq5D8pur5sK2EgI/laUZV4jnPzgzeCAmUOizb+lpn7LOUgsNqpQtKXVTkeNcPB1djabst3UDffvZ+DrgylEYlDzqPY1bND/1VgwTszx7TYLTJOeTf/gn+RqNKqw+4Qc3zRzF/f6+t3Q2iS+MDde14+xEyex8KefOP+88/w6Z8LEiURERHDNVT0CHF3ou6F/X/739rt8/uWXXNXDv/aaNn06Ho+H/r2vDXB0oe/6fn14+vmXmDl7NgNvuMGvc+bMm8eBgwe5ob//+3qcrnpf3ZMHH3uCSVOm8MB99/l1zvxvvmHrtm0MHNA/wNGFvisv705cXCzjJ05k2NNPBzscKSfKVObudrtZtWoVVatWzfcYy7KKNFLbsiyWL1+ed82wsDDatm3L/Pnzjzlu/vz5dOrUqXiBF6IeDlwYbPNm+TUCJdv0sdeXQzOc2PRwv1A1sRODje/c+/xq31TTw+85h2iEA4fat1CVsVEBGx/vO4jPj/ZN9/n48kAK9XHiOqp9qzVxUOsMJzZ7/ptHVo5OZcpfnVi2NnejWZ/HwuuxMH0WPg9MfiSFv78p2ki5si4BOzVsTt58+22/frdlZGQwfMQIrrysOzVUPClUjerVueryyxj+wQekp6cXerzb7ebtd9/lgnPPobmKJ4WKj4/nur69GTNuHAcOHiz0eJ/PxxtvvcUZLZrTqWOHUogwtIWHhzNo4A1MmjKFXX6sJ21ZFq+/9Ra1a9Wke1f/N1U9Xdntdu4YdAuzPv6YjZs2BTuccq285viNcWIAO7z+zZJIN70cMD00JwxDOWih6h/uQ32Xvd+v4/f6cvjTk0oznGpfP9TGQTQGs/cd8KsPtd/jZcGhVBrjxH5U+zY6J4yEavYTiidH2G0WTSvu4qUfe7B+ayzwb45vmRbebBh9xyE2LfF/JkEoOP/cc2jWpAmvv/UWPl/hU2v279/PuIkTuKF/X2JjY0shwtDW6oyWnHN2B9565x1ycnIKPT4tLY0PRo2i11U9qFIl/6K65KpdqxZXdL+U94YPJzMzs9Djs7Ozeff997mk80U0atigFCIMbRUqJNG319WMGjOGQykphR7v9Xp58513aHdmG9q31aCfwkRGRnLz9QOY8OGHBc5uFimKoBZQHn74YX744Qc2bdrEokWLuPbaa0lNTWXgwIFkZGTwxBNP8Ntvv7FlyxaWLl3Krbfeyvbt2+ndu3feNW688cZjRqo999xzfPXVV2zcuJHly5czaNAgli9fzh133JF3zJAhQxg9ejRjx45l1apVPPjgg2zduvWYY0qSA4MOhJHsy2Gbt+ClprJNHytz0ojGoDlF29TvdGXDoCNhrPSm80l2coFLTaWZXkZnbMOGxRlqX78YGHTAxaqsbD7YlVxgESXd5+N/u3bSvoOLWy6JoVK9f0enRTeM8+vztf1zOuMu+pPXrtjPgrGZ/PZRFh+/kMYTZybz86SsU/56yqJ2ppNVq1Yx6LbbCnx4lJGRwY233MLuPXsY9mQ5WBy6lDz31FD2JCdzw803F1hEcbvdDL7zTv5ZtYqXn3umFCMMbU8+MoScnBz6DRjAwUOH8j3O6/Vy/5Ah/PzLL/zfi89rbVo/Dbn3bqKiori2X78Cl0ozTZOnnnmGTz/7jP978fkibap6Orvj1pupWaM61/bry9YiLN0kBTtdcvxwDNoSxnZvNrsKKaJkmj7+caeRhI0GZWsRgDLLiUF7wljkOcR32QUPlDpg5jA6Yysx2GiCM9/j5F82DM7CxW9pGUxK3l9g+x70ePlv8k4uPjeCAV2iSazx72OE6Eb+rcnZ9sexvH32at7qfYAfJ2Ty2/Qspj+ZxuOtk1n+WfkaIAW5ywm+9tLz/PDjjwx55JECiygHDhygz3XXYfpMHn/ogdILMsT95/lh/LViBbffdVeBRZS0tDQGDBzI/v37eGboY6UXYIh7/qkn2LZ9OwNvuaXAIkp2djaDbruNdevX89Iwjfb311OPPUJGZgb9BwwgJTU13+M8Hg/33H8/v//xB6++MKz0AgxxDz9wL2FOJ9f261ekpdJE8hPU7H379u3079+fffv2UbFiRTp27Mhvv/1G7dq1yc7OZvXq1UyYMIF9+/aRlJRE+/btWbhwIc2bN8+7xtatW7HZ/k3gDh06xG233cbu3buJi4ujTZs2/Pjjj5x11ll5x/Tt25f9+/fz/PPPs2vXLlq0aMHnn39O7dq1A/a1NiWMLCx+92aRanqo5ggnwebMe4Dktkz2eN3s8mbjAi4j8pjR+1Kwejg5B4uFOQfY5sviPFcizR0x2A+3b7rp5XfPIRa6D+CzTC4jgqiyNQGrTKuBgwsJ54eUNLZm53BFUjwdY6JxHh5plu7z8UNKGlWvMvnu/uokJf774G71b15emXEOP53Zlgd4v9DPZW3aCcCmJZ5yNxItP5Wxc7EZxhdffMEFF3Xm7rvvotfVVxMZGQnkJv0fzZzJ8BEj2LlrF3OmTeaMli2CHHXoaNG8GXOnT+aqvgO44OKLufP22+nbuzcxMblLwWVmZjJ7zhyGjxjBuvXrmT5xrGZHFEHdOnX4/OMZdO95LRd07swdt91G/379SIiPB3ILU/M++YT3R4zgz7/+YtwH73HpJRcHN+gQUqVKZb6cM5OuV17DBRdfzG2DB3PjgAF5m217PB4+//JLPhgxgl8XLeLt/75Kn15XBznq0BEfH8+Xc2bR5YqruLBLF24bNIiBN9xAVHR0sEMLaadTjt/mcI7/tyeTQz4PVR3hxNkceTl+tuljt8/Nbm82Mdi4jAjNgC6C5ofb9wv3XjZ4MznXlUhjRxS2w+2bYnpYlHOIn90HcACXE6E+VBE0xEkWFvMOHGJdVjaXJ8bTLiYqrw+V4vXyfWoqzW4w+P22GsTG5Ob4lmnx148mL8y9hMXtazGI8YV+LnNz7vJ6a37KYc1Phc8YKA8u69aV0e+9zeB77ufvlSu58/bbufKKKwgLyx3Id+DgQaZMncoHI0eSmZnJl3NnUbtWrSBHHTrO7XQ2U8eP5rqbB9O5a1fuvP12runZk4iI3GW9U9PSmP7RRwwfMYLkvXuZ99EUmjVtEuSoQ0frVmfw8dRJXN3/+rw+VJ9rryX6cI6UkZHBzNmzGT5iBJs2b2bGpPGaHVEEDRvU59OZ07m8Vx/O79yZO2+7jX59+xIflzvwNDs7m7nz5vH+iBH8vXIlE0d9QOcLLwhy1KGjerVqeX2o8zt35vbBg7n+uutwhmkgtRSPYRVlVzPJk5qaSlxcHDdT+B4oR9uIh2XksA+TMAwiHDYswyLda2KzcpPYdoQRqYf7xbIVL8vIYTc+IrGR6HRgYpHs9WBZuUsBtMNFjNq3WHbiZSk57MBHpM2gSrgDnwW73R4efzCRZx4+cVdzr2mQkRNOz6kP8mGv4VSLOUg+M/zJSjN5/IxkPEXbL7TcSMbHUpuHraaHqMhI6tSuAVhs2rKNrOwcrrr8MoY9+biKJ8W04u+VDHvpP8z97HPCw8OpU7MaNpvBlq3bScvIonvXLjz7xOOc1a5tsEMNSevWb+DZF19m5px52O126tWugcNhZ9v2HRxMSafzBefz9OOPcOH5/q0DLsfatn07Tz//EtNnfYxpmtSvUwOnM4wdu3ax/0AK55zdgScfeZjul2rpruLYsyeZZ196hUnTPiI7O5t6tWuybuNmUlJStJTKaaY4Ob6FxVq8LCeHQ5i4MHAaNkwsMi0TJ9AEJ21xldmH+yNIy/vz7ZS9veY24GH54T5UtGEn1nDgxWKvmYMDg4Y4aEcYEWU0xy/r7bvl8PfvbnxE22wkORx4LYvdHg/v/qcig2+IwzgugfeaNvZmxND7o/v4/PrXiHWdPIG3LIuDO02ebr+XQD15OLp9rYxDgfkkp+D7H37khf+8xvc/LiQhPp6aNWvi9XrZuGkTpmlybc8ref7pJ6lfr26wQz0pIyo+789lsX1/W/w7z738H76c/y1xsbHUqlUL0zTZtHkzbrebnldcznNPDS2zy/OW9fZd/udfDHv5P3zy+ZdERkZQp3YdALZs2UJ6RgaXd+vKsCeH0rZN66DGmZ+y3r6r16zl2RdfYfa8T3A6ndSrWxebzca2bds4lJLCJZ0v4pmhj3Jup7ODHepJlfX23bxlC8+88DIfzZ4DQJ3atVmzdq1yfCkyFVCKqbgFlCOS8bEZLx0uzsHlhMZVYfG46DLbqQo1+/GxES9nXZxDmAPqV4KlH0YTrvYtEYcw2YCH9l1ysNugeT07g56si91x8vb1mjY+Wd2Gbza14L3LJ2BanLSI8tFTqSwYU/gaq+VdKibrD7evYUDNJLjuub+pWaNGsEMrF7bv2MHkaTPYtnAYlgXVEqD/s8upV7dOsEMrF/bsSWby9I/Y/P1TeE2oHAt9n1pMk8aNgh1auXDgwEEmT/+I9fMfI8cLFWOh16MLaXVGy2CHVi6kpKQwdcYs/vxkCB98gzpXp6FTyfEtLHbhYxs+3Fg4gETs1MdxeLeUsqusP+CH3PZNxmQzXtxY2IEEbDTAWaz+WGkKhfYF2IePTXjJxsIGtGniYvz3+e9d5DVtjF16ATtSE3mu86wT3rcsC8MwGHPHIZbMDdwIqbJeQDnin1Wr+Wj2x+xJ3ovT6aBu7doM6NuHSpUqBju0ApX1B6RHbNi4iakzZrJr9x5sNoOa1WswoF9vqlerFuzQChQq7bt12zamTJ/J9p07sSyL6tWqcl2fa6kTwFmeJSFU2nfXrt1Mnj6DLdu24vOZVKlciX7X9irze8qESvvu27efydM/YtWaNYwYM145vhSZCijFdKoFlCM+mPxvsnfHgLKbTIcqtW9gHWlfq1YCvrpJ+W4QD+Dx2TjzvefpFzadB/r/RVScgemzsNkN3Bkmn/xfOt+NVPHkaEd//9LzUNDiKLfmxP/7Z7VvyVP7BpbaN6BSp8QTN1gFlNNRSeX4oSZUHvCHqlBt32uejeGiQZHYnfn/LKS6wznz7WE8UHE0t/ZeR3jUvzl+5iGTGc+ksmhGYKeXh0oBJVSFygPSUKX2DSy1b2CFWvumpqYSV7WWcnwpMu1gKCJ+i4g1SKppJzvdYt+WfzdC3GGrQkXLxIaZ77lOu8mlc59gxz/JDH0FWlziIqGanbS9Jiu+duPOVC1XRERERKS0RSUaJFSzk3nI5MD23HzeAiIaVQB79uG/nVysK5uLJzzIP/sP8vjzBmdc6iKmoo1DO32s+MaNt/ztDy8iIiKnGRVQRKRQcZVt9HwyhrZXheMIyx2BtmOVh00ZlXlq+U20Dk/m/jpfFngN02dhbt0LgDcHln+m3pSIiIiISLBUrGPnqidjaN3dlTeTfNOSHCaPTWRW5A10TFxBB+sXCiqguDNN7PsPApCTZfHHnNN0M0MREREpt8rmLnsiUmbEVrLx6GdJtLv63+IJQNXGTmq3M6hRJ4u5q9tiM/LvWPm8Fn9+6SY7XbNMRERERESCrWJdO49+nkSrbq5jluGt1SaMoe9kcNb5bj5e1Q6HPf8Z5j6vxa/TskojXBEREZGgUQFFRAp0+cPRxFa2nbBBvM0GlgXDLpxNqjuCicvP5WQ7Kpk+C18OfPbf9FKKWERERERECtJrWAzhMcYJOb7dBoZh8Z8u01i1txqfr22FaZ24B4rPa5GdZvHN8IzSCllEREQkKFRAEZF8OSOgY++IEzpWRxgGOO0+rmq8lNc+O58Z05LwZB9bRUne6OONXgfYudpbGiGLiIiIiEgBYivZaNHFlW+ObzMgISKTLvVW8sS0S/hybjQ+z7E5/o6VXv531f68PVNEREREyivtgSIiALgiDeKq2shOtUjdm9sRiq3swBl+8o7VET7T4NpqC9g9YiQLvB5+e9ag+UUuXFEGu9d52fiHpzTCFxERERGR44THGMRWspF5yCR9f24RJLGOE5ut4Bzf67PRLvlLfCP+5lPTx4Ikgybnu3C6DLb/42HbXxocJSIiIqcHFVBETnOxlWz0eDSas66NwOnK7UitX5zDlA8r8m3lfsCIAs93GD7OCFuL3ZtbKMlOs1gyT5tHioiIiIgES1ItO1c+Hs2ZPcLzZpr8s8DN+Kk1+anFFTzK2ALPtxs+XKvXYjN9AKTvt/jjY+X4IiIicvrREl4ip7G4yjYe+zyJjn3/LZ4A1G3r4qm3U2nROptftjbAa+Y/Qs2wGZCcVhrhioiIiIhIISrVs/P4l0nHFE8AGp8Xzkvv7yemqot1+ytjnmT/wiNME/78wl0K0YqIiIiUbSqgiJzGrhwac9IN4u12C7D4zyXTGP57Fww4eQfLsmB3KkamlukSERERESkL+rwUe/IN4u0WNsPkv5dO4fVfu2MzctP541mmxfejM0nbp/1NRERERFRAETlNhccYtL86vMDNI6PD3FSKTuXByT3ITMs9zuuxMH0WlmnB7jSM1cmlGbaIiIiIiOQjsYaNZhfmv0G83WZRNSaFTI+LZ6ZfhDsLLMvKy/FNn8X3YzL5+AXNMBcREREB7YEiclowbFCrpQNXlI3kTV4O7TJJqGbHEVbI5pGmjbP2f8WCx/7hiactWnULp0pDB9lpJss/d/PSfw6VzhcgIiIiIiLHsDuh1hlOHGEGu9Z6Sd9vUqFO4V1804Rzt81g6Sv/MPQJg9aXu6hQ20HmIZOln2STskczT0RERESOUAFFpJzrdF0Elz8UTUI1OwCmafHnjwbvL+0KfF3guXZ8hG3YjGFZeN2wZK42jhQRERERCbaLb4+k673RxCTlLirh81os/sbO5C1dgS8LPNdmg7D1GzEAd6bFohnK8UVERETyowKKSDl2yd1RXP1UDNZRixvbbAYtz7fxylm/sGZfFRok7sFuO/kOkja7wbLP1KESERERESkreg2L4eLbo455ze4waN8VqqUuZk96LBWjUrHlM9ncm2Px9zfaIF5ERETEH9oDRaSciq1o48rHowEwjGN7Tw6bSXx4JsnpsRiGddIN4k2fxaIZWezb4iuNcEVEREREpBBVGtlPKJ4c4bCZVI89yN/JNfItnlimxfejMsg4ePIBVCIiIiJyLBVQRMqps3qFYxSwxYnDZtKh5gae/ewKPG4Dy7Tw5lj4vLmdqT/mZDP5kZRSilZERERERApzdt/IvHz9ZBw2izOrbuY/X16M15O7fK835/AG8abFgrGZzHk5vRQjFhEREQltWsJLpByof5aTdj3DiYy3sX+bj1+nZRFXNxKfZcNG/h2sMLsPz8tTGPpgFm17hlOpjp2sNIuln2STvFEzT0REREREgsEwoPF5YbS5IpzwKIM9G7yHc/wIjPymlxyWEJHJtns+YmiYl3Y9I0isYSf9gMmSuVkc2K4N4kVERESKQgUUkRAWFmEweHQczTuH4/NYuXPKLOh2XzSLt9bGsG3LfSEfpmmRszeL7HSLnydllVrcIiIiIiJycpHxBndNSqBe27BjcvzuD8WwbGdtfNY2bORfCMnJsrAyPGRkwA/jMksvcBEREZFySAUUkRA24H+xNL3ABYDdeexItLNqbSnwXJ/XYuW3brLTtf5xsBg2sDQIUERERESOctuYeGq3cgIn5vjtahSe4y+aqYFRwWKaJlg+bHZnsEMRERGREqICikiISqppp91V4flO4bcsyPI4CXd6TthE0vRZmD747H9a/7i0PfJpPHXOzC16GYaBZeUWsLatzOE/lxwMZmgiIiIiEmS1Wztp1MmV7/s+EzI9LiKdOdhtxw6E8nktcrIs5r+XEegw5SimaUL65cC+f1/L+1MbbLEjgxCViIiIlBQVUERCgCvSoN014dRu7cT0wj/fu0mqaccC8lsB2TAgMszDN4uqcdGZO7A5cmc72OwGh3aZTLjvENtWeEvzyzitXTU0iq73RmMYx96xI3+v2TyMd3dUOuZ9MzUe/tyBzatpKiIiIiLlTUScQcfeEVRv6iAn22LF124adAzD5wV7Pj11uw1iXG4WLKrE+e33YBi5A6dsNoO9m32MveMQ+7ZoL8PSYFkmVvqzYH1ZwFHLMFPbH/uS7UyIfB2bLSqg8YmIiEjJUAFFpIxrcn4Yg0fHEx5tYB6ud5w/MJJDaQ4sfBS0xwnAshdW8PVmH2d0deGKMti9zsvqH3OwtHJXwMVWsnHH+DhqtwordLNPwzBOKK4QFw7n1cNcvAVbAOMUERERkdLV5goXN70Tjz0MrMP1jgtvieJAahim4cVewB4nAN/et5L5XotmnV04XQbbV3pY/5unFCIX09wK6UOAgpdTy/8CSyH9Qsyoz7HZK5ZobCIiIlLyVEARKcOqNLRz58QE7I7cB+xHL6UbE+U7Ydr+8Xwei+SNXjIOWvwyVWshlxZnONwzNYEGHcJOLIoA+3ZBTDyEhef+/SSH/MswoH3tgMQpIiIiIqWvXjsngz6IByN35sjRI2Xioj2F5vhZqSYpu314c+DnScrxS4tppkDGHWCtP+n7e7ZDQkVwhhWS3x+RcTXE/lSyQYqIiEiJUwFFpAyp0tBOpXoOstMtNizOofNtUdjsuctuHe9Ix8pnGiftZPm8Fr9/nE3GQU01KU0d+4Yz4L9x2B0n7zVt32inel2ff52qI2wGpvs7bK7OJROkiIiIiJSaM5qFUbeWkwOHfBiLoeu9UVgW2AvI8U2LE/YxhNy9DH/6MBNvTqCjlqOZ2WMhZ3i+7+/ZZqdSjSLm+LgxveuwORqecnwiIiISOCqgiJQBVRs7uO61WOq3D8t7Lf2ASViEke+DeMjdRBLA6zNw2P8tlPi8Fvu3+pj9fGrAYpZjRcQaPDg7kRrNnXkbwx9vx0YH1et6i9ixOswzCVRAEREREQkZdds66fefWGq2+Hca+aFdPuIq2wpc3tXrM7AZ4DXJy/Ety8IyYdvfXj5/XZvElxbTTIb0QcDufI/Zus5JzQbFXD7NMw0cTxfvXBERESkVKqCIBFmlenYenpdIWOSxnajoxMJ3vbDbYP0yk+TVWbS/JgKnyyD9gMlPkzL5ZngGmYc0+6Q0nHt9BH1ficVmz/37yZbtAoivUMziCQDe4p4oIiIiIqWsdmsnD8xKPGEz+Lgq9kLzQQOLFT/48KTm0ObycOwOg9Rkkx/GZ/LdiExyspTjB5plWVg548Cd/6yTIyrX8hQ/x7eU44uIiJR1KqCIlCKbHZpf7KLWGU58Hou/v3XT9Z4owiLzn2liWfmvoevzWmxZnMmsYWlMfigVZ7ihDlUpik40uH92ItUb5846ya9wckRkzCl8MmfvUzhZRERERALF7oRW3cKp1sRBTpbFn19m0+vZGOwnWYr3SLpYUI5vYLHx50zmv5eBYUvB4QKPtjopNaZvB2TcDuwp9FivB8LCCj0sf86+p3CyiIiIlAYVUERKSZ02TgaPjiehmh2vx8Iw4MrHY/x68J4fu8Pgp0mZQG4nTMWT0nPxHZFc/VQMxuGJQsW9h36xLGyuHoG7voiIiIgUS9MLwrj5vXiik2x4PRY2G/R8svijZo4s1fXb9NyKiWWqeFKazOx3IGei/8ebUMCKy4UwsDmbFfdkERERKSUqoIiUgop17Nw/IwFHeG527XD+m2UX9uDdOvwfywLb4Yf1Pp+F3W7w8Qtp7FnvC1DUcjIV69oZPCqeGs2dhR98HJ8HHEUdoWZZsHQHXFTkTyciIiIiAVSrlYO7PkzIG1BzdI5fGIvDs1D4dzCVz5tbgJn8SCpp+8wARCz5sXxrsDIfA2tHkc4Lc4HpI28p3yIJn1qMk0RERKS0qYAiEgA1Wjg465oIopNsHNjho0ItOw6Xgd1ejOFJpsWKb9xUa+qgQq3cH9ktyzzMfy+DP790l3Dkkh9nOFx6bxTd7o/O6yQX1e4dDmrU9W+dY8uyMCwLFm/FllnMTSlFREREpMTUa+ek7VXhRMTaSN7kpf5ZTjBOXKbLHwYWyz7Npv5ZYcRVzn36vu7XHL56J4M1C3NKOnTJh2WlY2UPB89Hxb5G8i4bVWoUseDlmostrFqxP6eIiIiUHhVQREqQIwxufDuOdldF4PMcXk7LyB2RVNBMk4LWQAaYNjSVQ7tMIuIMTC+4M7RUV2mqdYaDO8YnEFclt3JS3OW6qtbykJluEBmd/zGWZeHzWQzrlMzL/0kr1ucRERERkZLjijK4bUw8TS9w5eX4hgHGKeT4nmyYNCQVd4ZFRJyB163leEub6V0EmU8Aqad0nUrVTHLcubNRCmX7DFt0pVP6fCIiIlK6VEARKUG9X4jlzB7hANiLMIUfTt7BsiyL70ZmcmhX7oimrBR1qkqTKwpu+SCell3CT2mvGsuyWDIvm3F3pWCa8PQvVahS+3DH28i99wArvs7kg5tOrQMnIiIiIiXrpvfiaHRO7jqsJZHjA3z6f2lkp+cmgZmHlOOXJtM8AJmPgPnXqV/McS32iEfB4yZ118XExOfk3e8jOb5hvxxb9LBT/1wiIiISFCqgiJyi8GiD6CQbNjt0ui4Cm63oD9lNn0V2ukVU/L9rQ+VkWcx/L4PPX08vyXDFDzYHdL8/mq73RuF05d7P4hZP9m728nbfA+zfmlsEM4AXO+3O/Tz23FlLOdoYVERERKRMiYgziIq3ERlv0OrS8GJdwzItstMsIo/K8bNSTT59LZ3vR2eWVKjiJ8vKxnIPh5xpwCnuMWNrABHvYbMnAuAICye+9s8AmD43YGK3R5za5xAREZEyQQUUkWKqVN9Oj0ejaX1ZOHaHgWlaxSqeANgdBv+7ah+RsTYq1XfgTjf5Z0GOluoqZXYntOkRzrXPxRCTZCt20QTA47aYNSyVH8fnXx0xfSqeiIiIiJQlNVs6uOKRaJpf7MJmMzB9FpZpYRQjz7cseOGCfSxukEPdWk72H/RR6wcbnuwABC75sqxsrJzPwP0OkHGKV3NB+NPYwi7N9wib3Z+1vERERCRUqIAiUgxVGzt4+JNEwiIM7I7czpTNZhS6l8nxjhRdvnonnd1rfYCPjX9ow/BgaHi2kxvejKNCrVP7tWhZFn995WbSQylkHFABTERERCRU1D/LyX0fJWKzkzcwymY38pZi8teRHH/282mkJJssSM5iwS+5o2ZuJ6akw5Z8WJaF5V0A2f8B68CpX9DRHSPiMQwj6tSvJSIiIiFDBRSRYhjwv9hjiidHFFY8sSyLnCwLV2TuNP4D23189U4GP0/SNIRgqVTPzi0fxFOrpROrqL3j46Ts8TH+nhTW/JRTQtGJiIiISGkwDBj4dhx2R27R5Pj3CuLzWpg+8pZ+3bPex+f/S2fJPE01CRbTuwqyngJrawlcrRpG5EsYjhYlcC0REREJNSqgiBRRlUZ26rUNK/J5Pq/F39+4GXvXISrWduD1WOzd6CvyiDYpGTXPcND9gShadQvPW6qruEt2mabFj+MzmfF0GtYpLqcsIiIiIqWv4dlhVKhd9O6xz2vx8+QsPn4hjaSadnKyLPZt8QUgQvGH5V2K5R4JviUlcDUbhN2E4brjlJb2FRERkdCmAoqIH6o0tHPR4Chad3cRFln05NnntUjba/LRk6l4smDnam8AohR/RCcZXPl4DJ2ui8Cg+EUTy7IwDIN9W7y81fcA+7eociIiIiISSmqe4aDzrVG06OLCGf5vfucvn9di7yYf8/6ThjvDUo4fRNWq2PnvsxWwMm8vmQva6kPke9hsSSVzPREREQlZKqCIFKJZ5zDuGJeAYeOEJbsK4vNa2B0G2ekmv0zN4ut3Mkjdq4fswXTpfVFc8XA0tsO/+U6leOJxW3z0ZAq/Tc/G1CBDERERkZByVq9wbnwrDssqWo5v+ixsdoOMgyY/Tcrk6/cyyErRlPJgMQx47ZkK3D84HputJK4YCeFPYzg7YxglckEREREJcSqgiBQgIs7gtlEJuRtJ2v3vWLkzTZ5osxcMyE6ztKxTEBk2OGdABJc/FE1cZfspX88yLX6ZlsWnr6WTsls3VkRERCTUJNW0c8ObcRg2sPk5oMayLFL3mDxz9l4cYUZujq+6SdA4wuD8myPp/kAUUfGnnuODAc6+GOG3YhhxJXA9ERERKS9UQBEpQMc+ETjCwWbzv3hiWRZfv5tBVqp6VMFWq7WDG9+Mo2qjU/tVd2Q5hx2rPIy69RDJGzXlRERERCRUnXtDBFC02ciGYfDZ6+l4ssGTrTw/mBqd4+SG1+NIrFkShRPA1gIi/oPNXrlkriciIiLligooIicREWvQ+Nww2l4ZDn70j7w5FjY7YMC3H2Ty5ZsZAY9R8pdYw8Ytw+Op1y6syGtZH8+yLFKTTT58MIV/vs8pwShFREREpDRFJ9loeLaTVt1chS7bZVng8+Tm+JYJn/xfOj99mFVKkcrJVGloZ9CIeKo3dZ5yjg+AUQ0iXsDmOKNkAhQREZFySQUUkaPYHNDziRguuDkSZ7if0/lNix8nZJKyx+SPj7M4uFPLOgVL1UYOLn8kmjaXu/I6VKeyz0nGQZO5r6SzeFYWHvWXRUREREKSMwL6vBBLxz4R2J3+5YaebJOFH2ZxcIePxbOySd+vHD9Yard2csWjUTS78NRz/NyTK2K47gHnJRiGs4SiFBERkfJKBRSRo9zwRhxnXROO4eeSXT6vxfrfcpj5TFqAI5OCNL0gjEvvi6JhxzAwTrFDBbgzTL4Znsnnb6Rr/xoRERGREGYYcPvYBJqcF+b3noY+j8Xyz9zMelY5frAYBpxxqYtuD0RR6wzn4ddOccYJMRiuQRB2XQlcS0RERE4XKqCIHFazpYMO10YU6Ry7w2D++1quKxjCIgzaXR1Ot/ujqFDLcUrT+K3DO4BaJnw3MoN5r6bjdZdktCIiIiISDE0vCqPZhS6/j7csC8MO341Wjh8MEbEGHftE0PWeKOIq20tmqS5s4BqMEXYThqFHICIiIlI0yh5EDuvYJwKfxypwWr9l5Y6G8nktbDaY9Vya9sUoZRGxBhcNjqTLnVG4Io1TX6rLtLAsWDQzi09fS+fgDk05ERERESkvOvaJwOe18t3z5PA4mrwcH+DDB1PY+qe3tEIUIDrJ4NJ7ozh/YBSOo+pdp1Y8sYPzWgzXzRi2pFOOUURERE5PKqDIaS08xuDsvhGceWU4VRs7sBXyE2EYsPGPHLYs97BwYia71/lKJ1ABoOu9kVzxUAz2sNy/n+poNMuy+GeBm3mvprPtL3WSRURERMqDqESDc66LpFV3F9WaOArcMN4wwPRZbPjDw4bFOfz0YRb7tynHLy2GDXo+GU3n26Kw2Q+/VhLLazk6Y7juxLDXOfVriYiIyGlNBRQ5bVWqZ+eBWYnEVbIBYNiMvBFo+clOM/lvjwOlEJ0c7YxLXfR9OZaEavZTvtaRZQAO7vIy8pZDbFmuwomIiIgcaxzpwQ4haEYQ2vt+tG3l4stp1YmLsWGz5T6MPzKL/GQsy2LTNg+Ne24plfhCvX1L0g29Y3jt2QpUTCq5xxJrN+bQc+BO1qwfAYwosetKLiMqPtghlGtq38BS+waW2lfKMxVQ5LRk2OCuDxOIqWA7ZsP4ggY7+bwWP0/NKoXo5IjwaINrn4/h7H5F25smP5ZpkXHIZOazaSyZm43PUyKXFREREZEyICLC4LPJ1YiNtmG3+5fjmyaMnpxaCtHJEYkJNkb9rxI9u8fk7UV4KkzTYtceL/c9uZd5X2VgakVeERERKUEqoMhpqflFLirV8//b3+e1yDhg8o02jC81VRraGfJxElGJp7bHyREet8UP4zL57LV03Jmn3lETERERkbKl31UxVEi0+503erwWW7Z5GDExJcCRyRFntw/niynViY4qmRw/PcPk9Q8O8srbB8nJUY4vIiIiJU8FFDmtVG/q4IxuLlp0cRW4meTx1v+Ww6QhqaTs0XCm0tB5cCRXPxPj9/05mSOj2SwTfpqUycxn0/C6SypCERERKc9uJpowSmAfhhBx9LJStxMTxEiKp04bJ80uCuPMHuFYJhh+rPpqmRarvnUz+eFU+qVGBTS+o9vXyjgU0M9VVlmWF8s9GnLGAiVR6LCB8wZiqtzOc/+t+O/nOU3bN5COXpZH7Vvy1L6BpfYNrFBr39TUVOKq1gp2GBKCVECR04Jlt3HXpHhaXByOz2thGGCzF94pnvJoCmt/ziF5ozaSLA02B9w5IZ7mncOLfQ3LssACrwd+npTJV+9mkLJbhS8RERGR8iamgo3bxsZTv31Ybo5vA5ut8Bx/9O0H2bzUw4HtyhFLg2lmQeYdYP5TAlcLh7C+GGEDMGwJJXA9ERERkYKpgCLlngVYZ1SlaYwLwK9ZDZZpcWi3yc+TsgrdWF5KRs2WDu6ZmkBMUvE2ij+yOXxmisU3wzP4eXIW6fvVKRYREREpj2wOuO+jBKo0zO3S+pPjmz6LbSs8LJ2nacmlxfL+AZlDgFPdSzIRXAMxwnpgGKE3S0pERERClwooUv7Fh0NCJEV9LP/tyAwVT0qBzQFd747iikei/ZoVdLwjS3Xt2+Ljs/+l8/vsbCzVTURERETKtVbdXFRv6izSOTa7wbcjMwMUkRzNsrKwsoeDZ+qpXchWH8N1GzguOuX9UkRERESKQwUUKZdsdmje2YVVx4mVGAmmBX5M5z+yL8qSedl8P0qdq0CLrmDwwMxEqjYq/q+inau9zHw2jTULc0owMjnaJdG3HvtCFMzfMzo4wYiIiMhpy+6EMy51UbWRg9aXhWP6LL8G4BzJ8b8fncEfH2eXQqSnN9O3PXfJLmtP8S9ia4kR/iCGo2XJBSbHOD7Hb3RxJd6b+3KQohERESm7bMH85MOGDcMwjGM+qlSpcsz7TZo0ISoqioSEBLp06cKiRYv8vv60adMwDIOePXsW6fNKaKvb1skLiyty58QErDqJWHHhfhVPUvf6WPtLDiMHHWTcXSmaxRBgXe6I5JVllajayJH3c1gU2RkmE+47xEud96t4EiCXRN96VMfKIm/DzwzrxKKKiIjIYcrxJRCaXRTGK8sqMXhUAt0eiKZ6M0ehxRPLskjZ4+Of7928e90BZjydVuDxcmosy8TMfg8yrjmF4kkMRLyGLXqsiicBkl+Ov/bbPcrxRURETiLoM1CaN2/ON998k/d3u/3fhZYaNWrEu+++S7169cjKyuKNN96ga9eurF+/nooVKxZ43S1btvDwww9z3nnnFfnzSuiqVN/OfR8l4HQd7kzZDPx5LJ9+wGRoq71asquUnD8wgmuejS3yeUf2OVnzs5t3+x/E5wlAcALAq6++evhPFmAc/jhabhFlfrpmooiIyImU40tJqtPGyZ0TEjAOD/9zOP3b03D3eh8vXLAvwNHJEZZ7FOSML/4F7BdBxMvYbEF/TFFu5RZIjnR6leOLiIj4I+iZicPhyHdk2HXXXXfM319//XXGjBnDX3/9xcUXX5zvNX0+HwMGDOC5555j4cKFHDp0qEifV0LXJXdG4XAaRdpLw/RZLJyYqeJJKbE74YpHi77xo2VZmD6Y/kQKP0/K0v0KsG9eWHf4Tyf7WTL4t+MlIiJyIuX4UpIuGxIFBkXeL+/H8VqSt7RYVhrkTCjm2U6IeA7D0UX7nJSK/NpYOb6IiMjJBHUJL4B169ZRrVo16tatS79+/di4ceNJj8vJyWHkyJHExcXRqlWrAq/5/PPPU7FiRQYNGnTKn/cIt9tNamrqMR9S9rS/OgJ7ASPSjn/o7vNa7F7nZf77GQGOTI5oeHYY0YlF/9WTutfk1W77+elDFU9KT0ENndvB6tVycGkFIyIiIUQ5vpQUV5RB884u7A7/c3zTZ7Hhdw8/T1YBpdR4FgLFmB5u1MCIno7NeYmKJ6Wm8BxfRERE/hXUAkqHDh2YOHEiX331FaNGjWL37t106tSJ/fv35x3z6aefEh0dTXh4OG+88Qbz58+nQoUK+V7z559/ZsyYMYwaNeqUPu/xXnnlFeLi4vI+atasWbwvWgLGsEFYpP9JtzvTZOGETP531QGy05QklpaI2KJ3jP78Mpsn2uxl+0pvACKS4jNI3aSfHREROZZyfClJ4TEGhh/7GR6RlWoy//0M3ul3AK+2yStF6eQ/syEfzisxomdj2PRzV7pUqBIRESmKoC7h1b1797w/t2zZkrPPPpv69eszYcIEhgwZAsBFF13E8uXL2bdvH6NGjaJPnz4sWrSISpUqnXC9tLQ0rr/+ekaNGlVgB8yfz3u8oUOHHvNeamqqOlhljGXCwZ0+4qva8h29ZPosfpmaxfejMti/3Ycnq5SDFPZu9vl9rDfHYvqTqfw8STeqbLLo8nSjYAchIiJljHJ8KUnp+03cGSauqPzH/lmmxVfvprN4Vjb7tvhUOAkGWw38n7kQgRHxFIazayAjknwd2eMwv/dERETkaEHfA+VoUVFRtGzZknXr1h3zWoMGDWjQoAEdO3akYcOGjBkzhqFDh55w/oYNG9i8eTM9evTIe800TSB3PeQ1a9ZQv359vz7v8VwuFy6X61S+PCkFCydmcsUj0Rj57Bdqdxh8OyKD5A3+P8SXkrX9by/b/vZQvanjpOtYH9koPnmTl7euPcDBnWYQopTC5Xa8HnvssWAHIiIiZZxyfDkVPg/8MjWL82+KzHcZL8uE70Zlkb5feWPQ2DuAURGsfRT4EN5oBJHvYtgTSi00OV5hM1A0Q0VERORoQd8D5Whut5tVq1ZRtWrVfI+xLAu3233S95o0acKKFStYvnx53seVV16ZN8Itv9Fk/nxeCQ3fj8pk52ovPu9xSfvhhZG/eDNdxZMyYMojqfg8nHCfLNPCMmHuK2k8f94+FU+CaH76aP7tPB3fCdbINBER8Z9yfDlVX7yZzsGdvhNyR9PM/fusYWkqngSZYdgxIp4m9xHDyR4z2MH1GEb0h9hUPAma3Bz/COX4IiIi/ghqAeXhhx/mhx9+YNOmTSxatIhrr72W1NRUBg4cSEZGBk888QS//fYbW7ZsYenSpdx6661s376d3r17513jxhtvzBupFh4eTosWLY75iI+PJyYmhhYtWhAWFlbo55XQ5s60eP3qAyycmElO1lEJYLaXyQ+n8Mmr6cELTvJsWe7htR77WfPTsesrrPk5h9euOMBXb2dgqs4VdMd2sI44MuXfyOd9ERE53SnHl5KWvt/itcsPsGhGFt6cf3P8Pet9jLn9EAvGarP4ssBwnI0RORzsLY9+FRznYURNwea6FsMoU2M4T0tdnm54kleV44uIiOQnqEt4bd++nf79+7Nv3z4qVqxIx44d+e2336hduzbZ2dmsXr2aCRMmsG/fPpKSkmjfvj0LFy6kefPmedfYunUrNlvRkrCCPq+Evuw0i4+eTGPuS+m8OTUbTAsyPfw8OSbYoclRtv/t5d3+B4mtZCOuso3UvSYpuzVysKyZnz6aV199lW9eOLL8iTpVIiJSMOX4Eghp+0wmDUll5rNpVKhtx51hsXeTRtyUNYajDYZjNJa5G6xDYFTEsCUFOyw5ymOPPcZjj0GvloNJ3XSkIKkcX0REJD9BLaBMmzYt3/fCw8OZPXt2oddYsGBBge+PHz++SJ9Xyg93poWRrh0ky7rUZJPUZBVOyrIjnSwRERF/KMeXQMpOs9j+tzfYYUghDFsVoEqww5ACzFoxKtghiIiIhATNnxURERERERERERERETmOCigiIiIiIiIiIiIiIiLHUQFFRERERERERERERETkOCqgiIiIiIiIiIiIiIiIHEcFFBERERERERERERERkeOogCIiIiIiIiIiIiIiInIcFVBERERERERERERERESOowKKiIiIiIiIiIiIiIjIcVRAEREREREREREREREROY4KKCIiIiIiIiIiIiIiIsdRAUVEREREREREREREROQ4KqCIiIiIiIiIiIiIiIgcRwUUERERERERERERERGR46iAIiIiIiIiIiIiIiIichwVUERERERERERERERERI6jAoqIiIiIiIiIiIiIiMhxVEARERERERERERERERE5jgooIiIiIiIiIiIiIiIix1EBRURERERERERERERE5DgqoIiIiIiIiIiIiIiIiBxHBRQREREREREREREREZHjqIAiIiIiIiIiIiIiIiJyHBVQREREREREREREREREjqMCioiIiIiIiIiIiIiIyHFUQBERERERERERERERETmOCigiIiIiIiIiIiIiIiLHUQFFRERERERERERERETkOCqgiIiIiIiIiIiIiIiIHEcFFBERERERERERERERkeOogCIiIiIiIiIiIiIiInIcR7ADOF15sNiFj0k/gcsJTaoGO6LyxXu4fSf/DE47NKgMFhYGRrBDKxd8R7Wv3QZ1K6p9S5KJxW58TPkZDANqJkEn08RmU827JJimya+LFrP1F7AsqJYA5/XwYbfbgx1auWBZFov/WMLmX8FrQpU4OP9yD06nM9ihlQuWZbFs+Z+s/w08PqgQAxd0yyY8PDzYoZUbK/5eydI/gh2FhCr34X/D3Vg4gETsxGvMWok50ofKxsIOJGAjEf37XVKys7P5YeHP7N23j7CwMBrWr0frVmdgGMrxS0JOTg4//vQLe5KTcTgc1K1Tm/Ztz1T7lhCv18tPv/zKzl27sdls1KpZg45ntVcfqoSYpskvvy1i2/YdAFSrWoVzO52tPlQJsSyLRb//weYtWzFNkyqVK3HeOZ3UhyohlmWxdPmfrFj5T7BDkRClAkopS8Xkb3JYZ3jJtiy+GP7ve5WNTJpZThrgwKYH0cWSjslKPKwxPGRZFp+//+97FQ63byOc2NW+xZJ5uH3X2k3SfV4+O6p9kxxumnhtNMaJU+1bLNlY/EMOa+wWqT4PnxzVvvUnteXOW29h8M0DiY2NDV6QISw1NZXR4ycyfPRY1m/YeMx7tSa24vZBN3P7LTeTlJQYpAhDW2ZmJuM+nMz7I8fwz+rVx7xXZWwLBt98I3cNvpUqVSoHKcLQlpOTw8Qp03h/5GiW/fnXMe8ljWrGoIE3cM8dg6lZo0aQIgxtXq+XqR/N5P1RY/ht8e/BDkdC0AF8/I2H9YYXj2Ud8151w04zy0ldHBpsUkwpR/pQeHFzbPtWwU4znNRXH6rYtm7bxrsfjGLsxEnsP3DgmPfatmnNXYMHcX3/voSFhQUpwtC2a9du3h81mlHjJrInOfmY91o0a8qdgwdx8w0DiIiICFKEoW3fvv18MGYsI8aMY/uOnce817B+fe4cfAu33nQjMTExQYowtKWkpDBy7AQ+GDOWjZs2H/Ne7Vo1uWPQLdw+6GYSEuKDEl+oy8jIYMyEDxk+aiyr16495r1qVaty2y0DufPWQVSqVDFIEYa27OzsvD7Unyv+DnY4EsIMyzouwxe/pKamEhcXx81EE+Znor4NL98Y2YQ7HVzZvBaXNa5BlegIcnwmy3fuZ9bfm/l9x35q4aAL4XoIXUS78fIV2djtBt1qJdGtZiJVIl34TIuVBzOYt3kfi/emUgU7XYkgXO1bJPvw8ZU9B9PppH//fgy84QYa1K+PzzRZtmwZo8eO5bPPPyfJsHOpL4xIjbYskkOYfGnPIdtm0Lv3tdxy0000btQIgL9XrmTs+PF8PHcu9erU4Ys5M6hTu3aQIw4tW7ZupXvP3mzYtImeV17JLTfdRIvmzTEMgzVr1zJuwgRmzp5NpYoV+HLOLJo0bhTskEPKnj3JXN6rD8v/WsEVl1/OoJtuok2bNthtNjZs3MiEDz9k2kfTiYqM4vPZH3Fmm9bBDjmkHDx4iJ59r2PhL79y6SWXMOjmm+nQoQNOh4MtW7fy4aRJTJ46FcNmMHf6FM47p1OwQw4pGRkZ9LnhJj7/aj4XXXght95yC2e0bEnLNm1ISUlR0fo0U5wcfz0eFpBNfEQYPZvXoVuj6iRFusj2+li8bS+z/t7Mij2HaICDCwkvkwN5RpCW9+fbKVsPGbfg5VuyiHTauaxWBbrWTKRiuJMc0+TP/enM27yPZfvTqY2di4kok32oo9vXyjgUvEBO4oeFP3FV3+uwGTYGXHcdNwwYQK2aNfF4vfz222+MGTeOr7/5hgvOPYePp00iPj4+2CGfwIiKz/tzWWvfP5Yu4/Jr+pCVlUX/fv248frrqVe3Lj7TZMnSpYwZN47Pv/iCM1u34tOZ08vkQ9Ky3L7/rFpNt5692Lf/AL179eKmG2+kcaNGWJbFXytWMHb8eOZ+8gmNGtTnizkzy+RAk7Lcvps2b6Zbz2vZvGUr1/TsyS033UTzZs0AWLV6NeMmTGDWxx9TrWoVvpwzi4YN6gc54hOV5fbduWsXl13dm5WrVtPj8ssZdPPNtG7VCpvNxrr165nw4YdMnzGDuNhYPp/9Ea3OaBnskE9Qltt3//4DXNmnH78t/oPul17KLTffTJPGjWneqpVyfCkyFVCKqaidq914+Yws2tesyPNdzyTSefLJP4u37WXol39Q0WfQjQiNovLTfnzMI4vGCZE8174uMfm07z8HM3hq8UaivHA5ETjUvn5JwWSu3U2jZk2ZOX06lSpVOulxK/7+m2uu7Y158BA9fC6/Hzyc7jIOt2/VOrWZPWtWvon9hg0buKZvXxx2G79+N58KFZJKOdLQtG/ffjpd3BWPx8vMadNo2LDhSY/bvmMH1/btS0pKCr8tmF8mO1hlUVpaGud3vYzde5KZMW0aZ7Q8eWK/d+9e+g4YwObNm/nlu69p1LBBKUcamrKzs7nkip6sXL2GaZMm0bFDh5MedyglhesHDmTZ8uX8+NVntGndqpQjDU1er5er+vTnx59/YeK48Vx80UUApKalUbNuXXWuTkNFzfE34+VrsujasDpDLzwDp/3kA0i+27CL575ZRl3LzkWEl7mZKGW1gLITL5+TRYfKsQxtU4fwfNr39+RUnluyiSqmja5lsA9VVgsoS5Yt5/yul9G+XTs+HD+euHx+3/3y66/0v/56WrVswVfzZuNyuUo50oKV1Qd4q9espdPFXalfrz7TJ0+mQoUKJz1u+Z9/0rt/f2pUq8oPX31GdHR0KUdasLLavlu3baPDBV1ISkpixrRpVK9W7aTHrV23jl59+hARHs4v331NYmJCKUdasLLavsnJe+l4URcMm42Z06ZTv169kx63ZetWru3bl6ysTH5b8A3Vqpat9enLavumpKRwbpduHDh4iJnTp+cVpo63Z88e+vTvz46dO/ltwTfUq1undAMtRFlt36ysLDpfdiXrNmzkoylTaNe2LaAcX4pPQ8RLgYXFj4abppUTeLlb23yLJwBn1azIf7q3Zzs+1uItxShD20LcVI928dJZ9fItngA0S4jipbPqsdfwsRJPKUYY2n4xcqhcvRpzZs/Ot3gC0LJFC+bN+ZgMp53l5JRihKHtN3KITEhg3pw5BT60r1+/PnNmzmT/gYM88+LLpRhhaBv28n/Yt/8Ac2bNyrd4AlCjenXmzpoFwKNPPlNa4YW8/3vjLdau38DsGTPyLZ4AVKxYkVkffUR8fDz3PvRoKUYY2oaPGsOiP5YwY+rUfIsnAPFxcUyfPJl6dety+30PlmKEoW3S1Ol8/tX8Y4onIv7yYbHQyOac2pV4qnOrfIsnAJ3rV+Wpzq1Yh5dt+EoxytBlYvGD4aZ5QhRPnZl/8QSgfaVYnmlbly342KA+lF8sy2Lw3ffRqGFDpk2alG/xBKDT2WczfcoUfv5tESPHji+9IEPc3Q8+TMUKuflPfsUTgNatWjH7o49YtWYtr7/zXilGGNoeevwpHA4Hc2bOzLd4AtCoYUPmzJrFnuRknn/l1VKMMLQ99fyLpKalM3fW7HyLJwC1a9Vi7uzZ5Hg8DH3muVKMMLS98t832LJ1G3Nmzcq3eAJQuXJlZs+YQVRUFPc/8lgpRhja3n5/BEuX/8nMadPyiicip0IFlFKwAx8HLZM7OjYhzI8NttrXqMBZNSqwytADfn/sxccefNzUuCoRjsLbt2lCFOdXjWeV4cFCE7AKk4LJVsvDo488QmJC4aN1mjZpwg3XX89au4lP7VuoTEw2GV7uu+9eqvoxWqdunToMvuUWPpw6nbS0tEKPP92lpaUxcco0br3lFurWqVPo8ZUrV+beu+9m1txP2L17T+ADDHE5OTmMGjeR6/r1KzDxPyIhPp6Hhwzh62+/Y936DaUQYWgzTZPho8ZyVY8etG/XrtDjo6KieOKxx/h9yVL+WLqsFCIMfe+PGsPFnTureCLFshEvmZbFXWc3xebHJtBdGlSjYWIM/2gQj1+24yPVMhnUtBpOPzaBPqtSLK0To9W+flr0+x8s+/Mvnho6lMjIyEKP79ihA1dcfjnDR41Fi1gUbvWatXz3w488+tBDxMfFFXp8yxYt6Nu7NyPGjMfj0fdwYXbu2sXHn3zK/ffeW+AAvyPq16vHzTfdxPjJU8jIyCiFCENbSkoKk6fP4I7Bg6lVs2ahx1erWpW7br+D6bM+Zt++/aUQYWjLzs5mzIQPuWHAgLxluwuSlJTEg/ffz2dffs3mLVtKIcLQ5vP5+GDMWK695hrObNMm2OFIOaECSilYhYc68VG0quL/VNFeLeuQbPnYqxFqhVqFhwouBx0q+T/97qraFUmxTHaofQu1Gg+x0TFc07On3+cMuvlmMnxeNmsEYKHW4sHhcHJd//5+n3PTwIFkZWUxdcasAEZWPkybOZuMjAxuuvFGv8/p368fDoeD8ZOmBDCy8uGTz79gT3Iyg26+2e9zrr7qKhISEhg9fmIAIysfFvy4kHUbNnDrLbf4fU7XSy6hZo0ajBgzPnCBlRPL//yL35csZXAR2lfkaKsND2dWS6J2vH/L7RiGQa+WddiKl3TMAEcX+lbhoX5MOE3jC3+4f8SVdSqwGx8HlOMXasSYcdSpXZuLO3f2+5xbb76ZVWvW8NMvvwYwsvJh1LgJVKhQgSt79PD7nEE338zOXbv4/KuvAxhZ+TB24iTCw8Pp26eP3+fcPHAgqalpzJg9J3CBlROTp88gJyeHG6+/3u9zbhgwAICJU6YGKqxy4+N5n7Jv/35uuekmv8/p3asXsTExjJnwYeACKye++W4Bm7dsLVIfSqQw+a91JH55c1Q6sYXk9M0fMWiWWBHDj5FpR7StljvF95q7MhlwzqlEWP6d9xxUS0/AbvO/fZslRBJmN+h2fRb3dA1gcOXAVf+DSonnERER4fc5TRo3pnLFRM47/wDPXJMdwOhC380jwMxo7dfsniOqV6tGg7q1WPXZA5D4QMBiKw9WfQb169amRvXqfp+TEB9PqxbNWPXNc9BA09ALsupjqJAYR7OmTf0+JyIigg7t27Hqh7dgzlsBjC70rfoanE57gUt3Hc9ut3NOp06s+nUSzJkQwOhC36pfcv9/3rnnBjcQCVmHsLiietH2IzuzegUs4BAm0RrLVqAUw+TiCjFF6kO1qZBbzDqISSKFz0w/na1as5ZzzzkHmx+ze444p1MnbDYb/6xew3nndApgdKFv1Zo1dDzrrCLtF3NGy5YkJiSwavVarrri8gBGF/pWrV5L6zPOKHDpuePVrlWLunXqsGrN2gBGVj78s3oNjRs1okqVKn6fk5SURPNmzdS+fli1Zg3VqlYtcHnp40VFRdG2bVu1rx/+Wb2ayMhIzT6REqWsvRS4vRBWwJq9J3NkDeVszd4tVHYOhNmLtlGkYRg4bQZZ2qajUG6vgSvc/+LJEeGuMH3/+iHbA+HFad9wl75//eD2QER4eJHPc4WHk632LVR2sds3gqycsrXBb1nk9kJ4WFiRHh4CuFwusj1q38Ic+TeqrG2GLKHDi4XLj+Vjj3akT6D5EYXzUfQ+VJhN7esvt9tNeBH/DbfZbISFhZGdrQFShcnOdhfr3xeXy0W2W+1bGHeOm/AiDPA7wuVykZWdFYCIyhe3u3jfv+Eul34/+CE7201ERNH7UOEuF1lZ+v4tjNudQ7jLVeQ+lEhBVEApBYnRsDejaL/k9mbk/qOTGBWIiMqXpFjYW8QnnRkeH5kekyT/Vlw4rSVGWezcsa1I57jdbvbuP0ii2rdQSdGwY8f2Iq0l7fP52LV7D0kxAQysnEiMhp279uDz+f8oxbIsdu7coe9fPyTFwL4DB4vcUdq5YxtJ0Vo/vTCJUZCWkcWhlJQinbdz5w4So/T4sDBHcoCdu3YFNxAJWeEY7Ekv2u+/vYePd6FOfWFcGEXO8fceroyqfQuXmJDAjh07inTOgQMHyM7OLtLM6dNVUlJikf99yczM5MDBg2pfPxTn+9fr9bInOZmkxMQARVV+JCYksGvXLkzT/+UmLcti565d+v71Q1JiIsnJe8nJKdq/cTt37tT3rx8SExM4lJKiPWOlRGkJr1P0wOBowgpN0N38YNtDmttDjMvp13U/X7Mdp2Ew780ovlIHoEAZ5LCUdPZm5VAxIsyvc+ZvP4ABfD8qisWjVEcsSDIelvAna9au9WuDM4C58+aRmeXmjylR3DFF7VuQbXjZyDYW//47Hc46y69zvv3uO5L3HeTKB7+B9oVvLH0661FjCS/OuZhvvv2WS7v6t17fH0uWsG7DZt56bQZcekmAIwxtlzdfz5BJ7Zgzbx79/FyDes3atfy+ZBkPjB0FPXsHOMLQdmmH3TjGtmDa9Onccdttfp2za9cuvlvwA2+99n/Qc3CAIwxtF3ZOJWpEU6ZMncrQxx4LdjgSgmpadr5eu527OjbJmz1emC/WbifKsFHRUn5UmJqWnYU7D3F3sxpEOf2b6fP19gO4MKim5bsK1eOybjz61LPs2bOHypUr+3XOlGnTCAsL49IuFwc4utDXo3s3Bt52Jxs2bqR+vXp+nTN7zhxycnK4onu3AEcX+npc1o1R4yawZOlS2p55pl/nfPX11xw4cIAeat9CXXl5d/7vjbdY8OOPdL7wQr/O+eXXX9m8ZQtXXn5ZYIMrB67ofimPPzOMTz77jF5XX+3XOX+vXMnyv/7iyUcfCnB0oe+ySy/BMAw+mjmzSHt1ihREmXspaIITn2ny6Wr/RvG7vT7mrNxMA8uh0VN+aIgTBwafbNnv1/E+02Lu5n3UwUGUfgQKVRcHUXYHI0aN8ut40zQZPmIENW1O4tW+haqBnXi7k+EjRvh1vGVZfDBqFGe2bsVZ7doGOLrQd1a7trQ7sw0fjBrl9yyfD0aOpF7dOlx6iR4OFKZRwwZc0vkiRowa5fcItZGjR1OxQgV69bwywNGFvqpVq9Drqh6MHjsWr9fr1zljxo8nPDycG/r3DXB0oS82NpYb+vdl/MSJWm5CiqU5Tg65PXy3Yadfx6e6PXy+ehuNLQd25fiFaoqTHNPi6+0H/Do+22fy2ZZ9NMSBU+1bqJuuvw6Hw8G4Cf7tl+XxeBgzfhy9r76KSpUqBji60Nen19UkJiQwaswYv443TZNRo0fTvWsX6tWtE9jgyoHLLu1K7Vo1GTl6tF/HH+lDdTyrPWe2aR3Y4MqBTh07cEaL5owYOdLvcz4YNYrGDRvS+cLzAxhZ+dC8WVMuPO9cRo4e7XcfdcSoUVStUoWrrlCBqjA1qlfnysu6M3rs2CKtRCFSED3dLAWR2GiMkxGLVrN8Z8EP+b2myYvfLScly0NL/JutcroLw6AZTqZv2MOiPQUvc2JaFm/9vY2dmW7OwL/ZKqc7OwYtfHbGjBvHjJkzCzzWsiyeff55li5fzhmmJrj5w8DgDJ+Nj+fOZfTYsYUe/8bbb/Ptd9/x+EMPak1PPz3+0AN89/33/O/NNws9dsy4ccycPZvHhjxQpE1VT2ePDXmAZcuX8/SwYYV2AGZ9/DGjx45lyL13a98JPz10/71s2ryZBx56qNAi1fxvvuGNt97i7ttuJbYIm6qezu6/6w5SUlO57a678Hi0cZcUTQJ26uDgvwv/Zv3+1AKPdXt9PPnVEjAtminH90s0NhriYPTqnaw8kFHgsV7T4j/LtpDp8dFCOb5f4uPjuePWW3jt9df59vvvCzzW5/Nx/5AhbNu2nSH33l1KEYa28PBwhtx3Nx+MHMmcefMKPNayLJ58+mn+XLGCRx64r5QiDG12u51HH7yfaR99xIQPPyz0+P/773/5ceFCHhtyfylEF/oMw2Dow0P48uuvefvddws9fsSoUcz75BMef+gB9VH99NiQB/ht0SKef+mlQvtQ0z76iImTJvHw/ffgdCqH8MfDD9zLmrVreeTxx4u0FJ1IfvR0qJR0wkUly8YDny5i+l+bSHef2ElflXyIhz5bzIKNu+mMiwRNPfdbe8KojYNn/9jElPV7SM05caTuptQsnluyiS+3HeA8wqms9vVbK5w0wsngO+/khZdfJjk5+YRj1q1bx+A77uDtd9/lbFzU0AqBfmuCkxY4eejRRxn65JPs2HniSNbNW7bwwEMP8dwLL/DsE4/R+5qepR9oiOrV8yqee2ooL7z0Evc9+CCbNm8+4ZgdO3fyxFNPMeSRR7jnjtsYfPPA0g80RF180QW8+X+v8O777zP4jjtYt27dCcckJyfz4iuvMOi227ihf18eVefVb+3bnsmY999h0pQpDLjxRv5eufKEYw4cPMj/3nyTftdfz2WXXsJLw54OQqShqUnjRkwdP5rPPv+ca/v1Y8nSpcEOSULMRYQT5YU7P/6Fef9sJdtz7EhHy7JYvnM/98z9lb92HeASK1wzoIvgXMKpYNp4dNF65mzaS8ZJ2nf1oQweX7SBX/ek0JkI4tS+fnv1hWFc2qUzfa+7jjfefpuDhw6dcMxfK1Zw3Q03MHX6dMZ98J5G7xfB0IeH0O/aa7j51lt5+T//Ye/evSccs2btWm4ZPJj3R4zg3ddf48LzzwtCpKHpzsGDuHPwIO578EGefOaZk+45s3HTJu65/35efvVVXnz2KXr2uCIIkYamfr178cQjD/H0sGEMeeQRtmzdesIx27Zv59GhQ3l06FAeuu8ebrphQBAiDU3dunbhvy+/wOtvvskdd9/N+vXrTzhmz549PPfii9xx993cfOP1PKgCtt86dezAiHfeYMy4cdx4yy38s2pVsEOSEGdYRdm5WPKkpqYSFxfHzfizB0ouLxY/42YtHsLsNi6sX5XK0RHk+Ez+3LWPf5JTiTFsnG/p4XNxmFj8iptVeLAZBudWiaNqlAuvabEqJZ0V+zOJMgzOsVzU1ci/IrOw+IMcVti8WIbBZd2707BhQ3w+H0uX/sGPP/1CpN1BB5+DRmrfIrOw+JMcltl8+LC4pEsXmjVrhmVZ/P33X3zz3QJiY2N46dmnuft27WtQHMNHjeGJYc+TkpLKxZ0707JFCwzDYM3qVXw5/xsiIiJ48pGHeEwjp4pl0tTpDHn8Sfbu28f5553HmW3aYLfbWb9+HZ9/+RV2u50h997NC888qdk9xTD308+48/6H2LV7Nx07dOCs9u0JCwtj8+bNfPr555imye2DbuZ/r7yokWnF8M13C7j17nvZsnUbbVq35qyzzmLEyJGkpKRoNs9ppjg5fg4WP5LNRrxEOh1cVL8qSZEu3F4fv21JZnNKBgmGjQutcCqV0QE8I/h3o9XbiQliJCfyYvET2azDS5jN4Lxq8VQKDyPHNFm2N531aVnEHu5DVS+jfaij29fKOBS8QE7C4/Hw4GNPMHLseBwOB1dcdhm1a9cmJyeHRYsXs2jxYqpXq8bwt/5Hj8u6BzvckzKi4vP+XNba1+fz8dRzL/Lme8MxTZPLu3enXr16eL1eli5dysKff6ZSxYq88erLXNe3bO4NV5bb17IsXn7tf7zy3zfIzs6m+6WX0qhRIyzL4q8VK/j2u+9ISIjnP88P47Zbbgp2uCdVltsX4J3hI3j6hZdITU3jkosvpnnz5hiGwapVq/hq/nyioqJ4duijDLnvnjLZhyrr7Ttu4iQeefIZ9h84wIUXXEDrVq2w2+2sW7+ez7/4AqfTyaMP3sczQx8rk32ost6+Mz+ey70PPcruPXvo1LEjZ7RqxQcjRijHlyJTAaWYitO5OiIDk1V42Gr4CE8wcTmgcTUL7/IIamHHpjV7T0kWJqvxsNnw4Yr3EeYwqFfZgr/DqY3WnD5VbizW4GGT3cKVZGE3oE4FH6wMo57a95TlYLEODxsOt69hQI0EHwPve5P+va8lMjIy2CGGtMzMTKbNmMWEyVPZtv53LAuqxptcf+erXN+vj5KoU+R2u5n58VzGTpzEljW/4jWhcqxJv1ufZ+CA60hMTAh2iCHN4/Ew77PPGTVuIhtW/kiOFyrGWPS68QkGDbxBa9KfIp/Pxxdfz2fEmHH8s+xbNu72qnN1GjqVHD/1cI6/3fCRY1jYMUgwDZripDp2jDKcI5XlAsoR6Xl9KC9uwAHEWgZNCaNmGe9DleUCyhF79iQzZuKHzJozj3379xMWFkaDenUZfPNArrz8MhyOslmcgrL/AA9g//4DjJ80memzPmZPcjJOp5M6tWoxaOANXHNVjzK9tGkotG9qaiofTp3O5OkfsWv3Hmw2GzWrV+em66+j77XXEBEREewQ8xUK7ZuRkcHUGbOYMGkKO3btwrIsqlWtwg39+3F9vz5ER0cHO8R8hUL7ZmdnM2P2HMZ9OJkt27bh8/moUrky/Xv3YuCA/sTHxwc7xHyFQvvm5OQw55PPGD1+Ius3bmTT5i3K8aXIVEApplPpXB3tg8n/JtN3DCibnZVQpvYNLLVvYB3dvvQ8FLQ4yq058f/+We1b8tS+gaX2DajUKfHEDUadq9NQSeX4oSYUCiihLBQKKKEsFB7ghTK1b2CpfQNL7RtYoda+qampxFWtpRxfiqzszf8SEREREREREREREREJMhVQREREREREREREREREjqMCioiIiIiIiIiIiIiIyHFUQBERERERERERERERETmOCigiIiIiIiIiIiIiIiLHUQFFRERERERERERERETkOCqgiIiIiIiIiIiIiIiIHEcFFBERERERERERERERkeOogCIiIiIiIiIiIiIiInIcFVBERERERERERERERESOE9QCyrBhwzAM45iPKlWqHPN+kyZNiIqKIiEhgS5durBo0SK/rz9t2jQMw6Bnz54nvPf+++9Tt25dwsPDadu2LQsXLiyJL0lERERE5LSmHF9ERERERMqLoM9Aad68Obt27cr7WLFiRd57jRo14t1332XFihX89NNP1KlTh65du7J3795Cr7tlyxYefvhhzjvvvBPemz59Og888ABPPvkky5Yt47zzzqN79+5s3bq1RL82EREREZHTkXJ8EREREREpD4JeQHE4HFSpUiXvo2LFinnvXXfddXTp0oV69erRvHlzXn/9dVJTU/nrr78KvKbP52PAgAE899xz1KtX74T3X3/9dQYNGsStt95K06ZNefPNN6lZsybDhw8v8a9PREREROR0oxxfRERERETKA0ewA1i3bh3VqlXD5XLRoUMHXn755ZN2iHJychg5ciRxcXG0atWqwGs+//zzVKxYkUGDBp0wbT8nJ4clS5bw+OOPH/N6165d+eWXX/K9ptvtxu125/09JSUl93pYhX6NBUnNPCq2U7yWnEjtG1hq38A6un1JTQ1aHOWW2jew1L6BpfYNqNSs3P9blv5tK67TPccPZafz114aUvU7O6DUvoGl9g0stW9gqX0DKxTaNzUtDVCOL0UX1AJKhw4dmDhxIo0aNWLPnj28+OKLdOrUiZUrV5KUlATAp59+Sr9+/cjMzKRq1arMnz+fChUq5HvNn3/+mTFjxrB8+fKTvr9v3z58Ph+VK1c+5vXKlSuze/fufK/7yiuv8Nxzz53w+mQy/PhK8zdu8NF/Sz+la8mJ1L6BpfYNrGPbt1awwjhNqH0DS+0bWGrfQNm/fz9xcXHBDiPkKMcPbeOU0wVUXFX9zg4ktW9gqX0DS+0bWGrfwAql9lWOL0UV1AJK9+7d8/7csmVLzj77bOrXr8+ECRMYMmQIABdddBHLly9n3759jBo1ij59+rBo0SIqVap0wvXS0tK4/vrrGTVqVIEdMADDMI75u2VZJ7x2tKFDh+bFBHDo0CFq167N1q1b9UNXhqWmplKzZk22bdtGbGxssMORfOg+lX26R6FB9yk06D6VfSkpKdSqVYvExMRghxKSlONLoOn3aNmnexQadJ9Cg+5T2ad7FBqU40txBX0Jr6NFRUXRsmVL1q1bd8xrDRo0oEGDBnTs2JGGDRsyZswYhg4desL5GzZsYPPmzfTo0SPvNdM0gdx1mNesWUPNmjWx2+0njERLTk4+YcTa0VwuFy6X64TX4+Li9MsxBMTGxuo+hQDdp7JP9yg06D6FBt2nss9mC/p2geWCcnwJFP0eLft0j0KD7lNo0H0q+3SPQoNyfCmqMvUd43a7WbVqFVWrVs33GMuyjlmn+GhNmjRhxYoVLF++PO/jyiuvzBvhVrNmTcLCwmjbti3z588/5tz58+fTqVOnEv16REREREROd8rxRUREREQkVAV1BsrDDz9Mjx49qFWrFsnJybz44oukpqYycOBAMjIyeOmll7jyyiupWrUq+/fv5/3332f79u307t077xo33ngj1atX55VXXiE8PJwWLVoc8zni4+MBjnl9yJAh3HDDDbRr146zzz6bkSNHsnXrVu64445S+bpFRERERMor5fgiIiIiIlJeBLWAsn37dvr378++ffuoWLEiHTt25LfffqN27dpkZ2ezevVqJkyYwL59+0hKSqJ9+/YsXLiQ5s2b511j69atRZ561bdvX/bv38/zzz/Prl27aNGiBZ9//jm1a9f2+xoul4tnn332pFP+pezQfQoNuk9ln+5RaNB9Cg26T2Wf7tGpUY4vgab7VPbpHoUG3afQoPtU9ukehQbdJykuw7IsK9hBiIiIiIiIiIiIiIiIlCVlag8UERERERERERERERGRskAFFBERERERERERERERkeOogCIiIiIiIiIiIiIiInIcFVBERERERERERERERESOowJKPnbs2MH1119PUlISkZGRtG7dmiVLlhR4znvvvUfTpk2JiIigcePGTJw4sZSiPT3VqVMHwzBO+Lj77rvzPeeHH36gbdu2hIeHU69ePT744INSjPj0VNT7tGvXLq677joaN26MzWbjgQceKN2AT0NFvUezZ8/mkksuoWLFisTGxnL22Wfz1VdflXLUp5+i3qeffvqJc845h6SkJCIiImjSpAlvvPFGKUd9+inOv01H/PzzzzgcDlq3bh34QE9jRb1HCxYsOOnxq1evLuXIpSQoxy/7lOOXfcrvQ4Ny/NCgHD80KMcv+5TjSyA5gh1AWXTw4EHOOeccLrroIr744gsqVarEhg0biI+Pz/ec4cOHM3ToUEaNGkX79u1ZvHgxgwcPJiEhgR49epRe8KeR33//HZ/Pl/f3v//+m0suuYTevXuf9PhNmzZx2WWXMXjwYCZNmsTPP//MXXfdRcWKFenVq1dphX3aKep9crvdVKxYkSeffFKJYCkp6j368ccfueSSS3j55ZeJj49n3Lhx9OjRg0WLFtGmTZvSCvu0U9T7FBUVxT333MMZZ5xBVFQUP/30E7fffjtRUVHcdtttpRX2aaeo9+mIlJQUbrzxRi6++GL27NkT6DBPa8W9R2vWrCE2Njbv7xUrVgxYjBIYyvFDg3L8sk/5fWhQjh8alOOHBuX4ZZ9yfAkkw7IsK9hBlDWPP/44P//8MwsXLvT7nE6dOnHOOefw2muv5b32wAMP8Mcff/DTTz8FIkw5zgMPPMCnn37KunXrMAzjhPcfe+wx5s2bx6pVq/Jeu+OOO/jzzz/59ddfSzPU01ph9+loF154Ia1bt+bNN98sneAEKNo9OqJ58+b07duXZ555JsDRyRHFuU/XXHMNUVFRfPjhhwGOTo7w9z7169ePhg0bYrfbmTNnDsuXLy+9IE9zhd2jBQsWcNFFF3Hw4MECH7RL2accPzQpxy/7lN+HBuX4oUE5fmhQjl/2KceXkqQlvE5i3rx5tGvXjt69e1OpUiXatGnDqFGjCjzH7XYTHh5+zGsREREsXrwYj8cTyHAFyMnJYdKkSdxyyy35/uP166+/0rVr12Neu/TSS/njjz90j0qJP/dJgqs498g0TdLS0khMTAxwdHJEce7TsmXL+OWXX7jgggsCHJ0c4e99GjduHBs2bODZZ58txegEivaz1KZNG6pWrcrFF1/M999/X0oRSklSjh96lOOXfcrvQ4Ny/NCgHD80KMcv+5TjS0lTAeUkNm7cyPDhw2nYsCFfffUVd9xxB/fdd1+B6x1feumljB49miVLlmBZFn/88Qdjx47F4/Gwb9++Uoz+9DRnzhwOHTrETTfdlO8xu3fvpnLlyse8VrlyZbxer+5RKfHnPklwFece/e9//yMjI4M+ffoELjA5RlHuU40aNXC5XLRr1467776bW2+9NfABCuDffVq3bh2PP/44kydPxuHQyqqlzZ97VLVqVUaOHMmsWbOYPXs2jRs35uKLL+bHH38svUClRCjHDz3K8cs+5fehQTl+aFCOHxqU45d9yvGlpOmn+CRM06Rdu3a8/PLLQG41cuXKlQwfPpwbb7zxpOc8/fTT7N69m44dO2JZFpUrV+amm27i//7v/7Db7aUZ/mlpzJgxdO/enWrVqhV43PGV5yMr2Gm0VOnw9z5J8BT1Hk2dOpVhw4Yxd+5cKlWqFODo5Iii3KeFCxeSnp7Ob7/9xuOPP06DBg3o379/KUQphd0nn8/Hddddx3PPPUejRo1KOToB/36WGjduTOPGjfP+fvbZZ7Nt2zb++9//cv7555dGmFJClOOHHuX4ZZ/y+9CgHD80KMcPDcrxyz7l+FLSVEA5iapVq9KsWbNjXmvatCmzZs3K95yIiAjGjh3LiBEj2LNnT14lMyYmhgoVKgQ65NPali1b+Oabb5g9e3aBx1WpUoXdu3cf81pycjIOh4OkpKRAhij4f58keIp6j6ZPn86gQYOYMWMGXbp0CXB0ckRR71PdunUBaNmyJXv27GHYsGHqXJUCf+5TWloaf/zxB8uWLeOee+4Bch/wWpaFw+Hg66+/pnPnzqUV8mnnVP5d6tixI5MmTQpAVBJIyvFDi3L8sk/5fWhQjh8alOOHBuX4ZZ9yfAkEFVBO4pxzzmHNmjXHvLZ27Vpq165d6LlOp5MaNWoAMG3aNK644gpsNq2UFkjjxo2jUqVKXH755QUed/bZZ/PJJ58c89rXX39Nu3btcDqdgQxR8P8+SfAU5R5NnTqVW265halTp+qelrJT+VmyLAu32x2AqOR4/tyn2NhYVqxYccxr77//Pt999x0zZ87M6xhLYJzKz9KyZcuoWrVqAKKSQFKOH1qU45d9yu9Dg3L80KAcPzQoxy/7lONLIKiAchIPPvggnTp14uWXX6ZPnz4sXryYkSNHMnLkyLxjhg4dyo4dO/LWTF67di2LFy+mQ4cOHDx4kNdff52///6bCRMmBOvLOC2Ypsm4ceMYOHDgCetKHn+P7rjjDt59912GDBnC4MGD+fXXXxkzZgxTp04NRuinlaLcJ4Dly5cDkJ6ezt69e1m+fDlhYWEnjBqVklOUezR16lRuvPFG3nrrLTp27Jg36jMiIoK4uLhSj/10UpT79N5771GrVi2aNGkCwE8//cR///tf7r333lKP+3Tj732y2Wy0aNHimPcrVapEeHj4Ca9LySrKz9Kbb75JnTp1aN68ed6GlLNmzSpw1oKUTcrxQ4dy/LJP+X1oUI4fGpTjhwbl+GWfcnwJGEtO6pNPPrFatGhhuVwuq0mTJtbIkSOPeX/gwIHWBRdckPf3f/75x2rdurUVERFhxcbGWldddZW1evXqUo769PPVV19ZgLVmzZoT3jv+HlmWZS1YsMBq06aNFRYWZtWpU8caPnx4KUV6eivqfQJO+Khdu3bpBHuaKso9uuCCC056jwYOHFh6AZ+minKf3n77bat58+ZWZGSkFRsba7Vp08Z6//33LZ/PV4oRn56K+jvvaM8++6zVqlWrwAUnlmUV7R69+uqrVv369a3w8HArISHBOvfcc63PPvusFKOVkqQcPzQoxy/7lN+HBuX4oUE5fmhQjl/2KceXQDEs6/AOeyIiIiIiIiIiIiIiIgKAFu4VERERERERERERERE5jgooIiIiIiIiIiIiIiIix1EBRURERERERERERERE5DgqoIiIiIiIiIiIiIiIiBxHBRQREREREREREREREZHjqIAiIiIiIiIiIiIiIiJyHBVQREREREREREREREREjqMCiohIGbV582YMw2D58uUBub5h/H979x9TdfXHcfx1ReXX1fytiIChAbkSxEExEVFxkSagm9lGA1JrzkL6MX+VU+jXVibaH5XkKH+spS2FpoMImQhhopE/otTAYCphtjKVRDHv+f7hvF8/IAouQ/P52O4f93zO55zzOXeD99k5n3Nsys3Nven7i4uLZbPZZLPZlJCQcN280dHRev7552+6rttJdHS087lv1W8DAACA/yZi/NsTMT4AoDVMoADANaSkpNxwwHCr+fj4qL6+Xg888ICk/w9m/vzzzw5tV3OHDx/WmjVrOroZ/5rNmzdr9+7dHd0MAAAAtBMxftsR4wMAcFnnjm4AAODaXFxcNGDAgI5uxg3169dPPXr06Ohm6OLFi+rSpcstr6dXr146c+bMLa8HAAAA/z3E+O1DjA8A6Gi8gQIAN2HHjh0KDw+Xq6urvLy8tHDhQv3999/O69HR0Zo7d67mz5+vXr16acCAAUpPT7eUcejQIUVGRsrNzU3Dhg3Ttm3bLK/cX/16f21trcaOHStJ6tmzp2w2m1JSUiRJgwcP1sqVKy1lh4SEWOqrqqpSVFSUs67CwsIWz1RXV6fp06erZ8+e6t27t+Lj41VbW9vuvvnrr7+UlJQku90uLy8vLV++vEWepqYmzZ8/X97e3vL09NRDDz2k4uJiS57Vq1fLx8dHHh4emjJlijIzMy2DuPT0dIWEhOijjz6Sv7+/XF1dZYzR6dOn9cwzz6hfv37q3r27xo0bp/3791vK3rJli0aOHCk3Nzf5+/srIyPD8vulp6fL19dXrq6uGjhwoObOndvufgAAAMCdhRi/dcT4AIC7FRMoANBOdXV1mjhxosLCwrR//3598MEHys7O1uuvv27Jt3btWnl6eqq8vFxvv/22Xn31VeegxuFwKCEhQR4eHiovL9eHH36oV155pdU6fXx8tGnTJkmXX6evr6/Xu+++26b2OhwOTZ06VS4uLtq1a5dWrVqlBQsWWPKcO3dOY8eOld1uV0lJib7++mvZ7XbFxsaqqampPd2jefPmafv27crJydFXX32l4uJiVVRUWPI89dRTKisr04YNG3TgwAFNmzZNsbGxqqqqkiSVlZVp9uzZSktL0759+zRhwgS98cYbLeqqrq7WZ599pk2bNjn3Kp40aZJOnDihvLw8VVRUKDQ0VOPHj9cff/whSSooKNCTTz6puXPn6scff1RWVpbWrFnjLP/zzz/XihUrlJWVpaqqKuXm5urBBx9sVx8AAADgzkKMf33E+ACAu5YBALSQnJxs4uPjr3nt5ZdfNoGBgcbhcDjT3nvvPWO3282lS5eMMcaMGTPGREZGWu4LCwszCxYsMMYYk5+fbzp37mzq6+ud1wsLC40kk5OTY4wxpqamxkgye/fuNcYYs337diPJnDp1ylKun5+fWbFihSUtODjYLF261BhjTEFBgXFxcTHHjh1zXs/Pz7fUlZ2d3eKZLly4YNzd3U1BQcE1++Fa7Tl79qzp2rWr2bBhgzPt999/N+7u7iYtLc0YY0x1dbWx2Wymrq7OUt748ePNokWLjDHGTJ8+3UyaNMlyPTEx0dxzzz3O70uXLjVdunQxJ0+edKYVFRWZ7t27m/Pnz1vuHTJkiMnKyjLGGDN69Gjz5ptvWq6vX7/eeHl5GWOMWb58uQkICDBNTU3XfG5jWv42AAAAuP0R4xPjE+MDANqLM1AAoJ0OHjyoiIgI2Ww2Z9qoUaPU0NCg48ePy9fXV5I0fPhwy31eXl46efKkpMsrzHx8fCz7H4eHh9+y9vr6+mrQoEHOtIiICEueiooKVVdXq1u3bpb08+fP68iRI22u68iRI2pqarKU36tXLwUGBjq/f/fddzLGKCAgwHLvhQsX1Lt3b0mX+2fKlCmW6+Hh4dq6daslzc/PT3379rU8R0NDg7OcKxobG53PUVFRoT179lhWu126dEnnz5/XuXPnNG3aNK1cuVL+/v6KjY3VxIkTNXnyZHXuzL9MAACA/ypi/NYR4wMA7mb8pwCAdjLGWAZWV9IkWdKbH3Zos9nkcDhaLeNmderUyVn/FRcvXmzRtuZtuZrD4dDIkSP1ySeftMh79eDlRq5VV3MOh0MuLi6qqKiQi4uL5ZrdbneW01ofX83T07NF2V5eXi32Wpbk3FvZ4XAoIyNDU6dObZHHzc1NPj4+Onz4sAoLC7Vt2zbNmTNHy5Yt044dO/6VAywBAADw7yPGbx0xPgDgbsYECgC007Bhw7Rp0ybLAGDnzp3q1q2bvL2921RGUFCQjh49ql9//VX9+/eXJO3Zs+e693Tt2lXS5ZVUV+vbt6/q6+ud38+cOaOamhpLe48ePapffvlFAwcOlCR98803ljJCQ0O1ceNG56GMN2vo0KHq0qWLdu3a5Vyld+rUKf30008aM2aMJGnEiBG6dOmSTp48qdGjR1+znKCgIO3evduS9u23396w/tDQUJ04cUKdO3fW4MGDW81z+PBhDR06tNVy3N3dFRcXp7i4OD377LMKCgrS999/r9DQ0Bu2AQAAAHceYvzWEeMDAO5mHCIPAK04ffq09u3bZ/kcPXpUc+bM0bFjx5SamqpDhw7piy++0NKlS/Xiiy+qU6e2/VmdMGGChgwZouTkZB04cEBlZWXOAyZbW7Xm5+cnm82mrVu36rffflNDQ4Mkady4cVq/fr1KS0tVWVmp5ORky6qvmJgYBQYGKikpSfv371dpaWmLwywTExPVp08fxcfHq7S0VDU1NdqxY4fS0tJ0/PjxNveZ3W7XzJkzNW/ePBUVFamyslIpKSmWfgkICFBiYqKSkpK0efNm1dTUaM+ePXrrrbeUl5cnSUpNTVVeXp4yMzNVVVWlrKws5efn33BFX0xMjCIiIpSQkKCCggLV1tZq586dWrx4sXNwtmTJEq1bt07p6en64YcfdPDgQW3cuFGLFy+WJK1Zs0bZ2dmqrKzUzz//rPXr18vd3V1+fn5t7gcAAADcnojxifGJ8QEA7cEECgC0ori4WCNGjLB8lixZIm9vb+Xl5Wn37t0KDg7W7NmzNXPmTGdw3hYuLi7Kzc1VQ0ODwsLCNGvWLOf9bm5u17zH29tbGRkZWrhwofr376/nnntOkrRo0SJFRUXpscce08SJE5WQkKAhQ4Y47+vUqZNycnJ04cIFhYeHa9asWZa9gSXJw8NDJSUl8vX11dSpU3X//fdrxowZamxsbPdqtWXLlikqKkpxcXGKiYlRZGSkRo4cacnz8ccfKykpSS+99JICAwMVFxen8vJy+fj4SLq83/SqVauUmZmp4OBgffnll3rhhRda7ZsrbDab8vLyFBUVpRkzZiggIEBPPPGEamtrnasAH3nkEW3dulWFhYUKCwvTww8/rMzMTOfgqUePHlq9erVGjRql4cOHq6ioSFu2bGmx5zIAAADuPMT4xPjE+ACA9rCZtmxmCQC45crKyhQZGanq6mrL4Oh2VVxcrLFjx+rUqVPOvYdvpaefflqHDh1SaWnpLa/rRmpra3Xvvfdq7969CgkJ6ejmAAAA4DZFjH99xPgAgNsdZ6AAQAfJycmR3W7Xfffdp+rqaqWlpWnUqFF3xMDqaoMGDdLkyZP16aef/qPlvvPOO5owYYI8PT2Vn5+vtWvX6v333/9H67gZjz76qEpKSjq6GQAAALgNEeNfHzE+AOBOwxsoANBB1q1bp9dee03Hjh1Tnz59FBMTo+XLl98xr5E3Njaqrq5O0uV9kQcMGPCPlv/444+ruLhYZ8+elb+/v1JTUzV79ux/tI6bUVdXp8bGRkmSr6+v8+BPAAAAgBj/+ojxAQB3GiZQAAAAAAAAAAAAmuEQeQAAAAAAAAAAgGaYQAEAAAAAAAAAAGiGCRQAAAAAAAAAAIBmmEABAAAAAAAAAABohgkUAAAAAAAAAACAZphAAQAAAAAAAAAAaIYJFAAAAAAAAAAAgGaYQAEAAAAAAAAAAGiGCRQAAAAAAAAAAIBm/gcy6Ya8zzPj1QAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(18, 7))\n", "fig.suptitle(\"Figure 3. SMOC A-grid\", fontsize=16)\n", @@ -640,22 +598,11 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": { "hide_input": true }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAs4AAAJJCAYAAAC6WbFMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAADwsUlEQVR4nOydd3wU1frGn00PLZRAINTQCUUhINJEUKoNFEHxYgOVi0iz0i7KRRH1akQpegX7FVQEGwJBBSkRfnRpghBICEFIgEAoqfP743B2Z7NtZnc2u5t9vp/PfmYye3bmzGRm95l3nvO+JkVRFBBCCCGEEEKcEuLrDhBCCCGEEBIIUDgTQgghhBCiAQpnQgghhBBCNEDhTAghhBBCiAYonAkhhBBCCNEAhTMhhBBCCCEaoHAmhBBCCCFEAxTOhBBCCCGEaIDCmRBCCCGEEA1QOBO3uPnmm2EymbBu3Tpfd4UYgMlkgslk8nU3goL33nsP1113HaKiomAymdCoUSNfdyngOHbsGI+dF+Hx1U+jRo1gMplw7NgxzZ95+OGHYTKZ8NFHH1kt/+ijj2AymfDwww8b2kdiDBTOxIy88J29kpOTfd1Nv2XatGnm4zRr1ixD1ilvUPS+iH/y3//+F6NHj8bevXvRvHlzdOvWDZ06dfJ1t8qUFStW4MUXX8SuXbsctklOTsaLL76I8+fPl1m//IEXX3wRL774oq+7QQhxQpivO0D8j2bNmqFWrVp236tbty4AoEGDBmjRogUqVKhQll3zWw4cOIDXX3/d8PW2bdsWRUVFNss3bdoEAGjTpg1iYmIM3y7xDgsWLAAAfPnll7jnnnt83BvfsGLFCnz88cdo1KgRrr/+erttkpOTcfz4cTz88MOoWrWqzfvh4eFo0aKF+fuovPDSSy8BAMVzkBMTE4MWLVqgTp06vu4KsQOFM7FhypQpLh8RffLJJ2XTmQBAURQ88cQTCA8PR/fu3fHLL78Ytu533nnH7nIZVX7nnXdw8803G7Y94l0OHjwIABg4cKCPexLY1K1b13wsCSlvDB48GIMHD/Z1N4gDaNUgxEMWLVqEDRs24F//+hfq16/v6+4QP+bKlSsAgOjoaB/3hBBCiDtQOBO3cDY4sKCgAK+88gpatGiBqKgo1K1bF6NHj8aZM2fw4osvwmQy2TyKdDRIQuLoc+rlZ86cwdixY9GoUSOEh4fbRM1Xr16NO++8E3FxcYiMjES9evXwyCOP4MiRI24fhzNnzuD5559HYmIiJk6c6PZ6jKSwsBDvvPMObrjhBlSpUgUVK1bEddddh5dffhmXL1/WvT5FUbBkyRL06dMHNWrUQGRkJBo3boxx48bh1KlTNu3XrVsHk8mEm2++GUVFRXjttdfQtm1bVKhQwWqw0d69ezFjxgx06dIFderUQUREBOrUqYO7774bmzdvttsX9aCZ/Px8vPjii2jatCmioqJQv359TJo0CZcuXXK4L5mZmZg0aRISExNRsWJFxMTEoG3btnjmmWdw+PBhm/aXL1/GnDlz0LFjR1SpUgUVKlTA9ddfj9dffx35+fmaj6EcPyBR+9FLn/M//vgj+vfvj9jYWERGRiIhIQFjxoxBRkaG03UfO3YMv/76KwYMGIDY2Fhdg3cVRcHChQtx3XXXITo6GnFxcRg+fDiOHj3qcqDSiRMnMG7cODRv3hzR0dGoWrUqevXqha+//tqqnRxw9vHHHwMAHnnkEavj8OKLL5q3dfz4cQBAQkKCVRu5P84Gr6l9/j/99BNuuukmVK5cGTExMRgwYAB27tzp8DgcOXIE999/P2rWrGn+Xy9cuNDmOGvl0qVLmDlzJtq1a4eKFSuaz9Obb74Zr776KgoLCwFYvsdK74N8yW06+h6UuPpf6T3/7VFQUIB77rkHJpMJnTt3xtmzZzUfD2+j3v9Lly5hypQpaN68OaKiomyezG3duhX33Xcf6tati4iICMTFxeHee+91en4cP34c//jHP1CrVi1UqFAB7dq1w7x586Aoitf2Q436u7WkpARvv/022rRpg6ioKMTFxWHkyJE4c+aMw/WePXsWU6dORZs2bVCxYkVUrlwZN954I/773/+ipKTE0H0o1yiEXKNhw4YKAOXDDz902bZnz54KAOXXX3+1Wl5YWKj069dPAaAAUFq0aKFcf/31SlhYmNKoUSPlqaeeUgAoM2bMsPrcQw895HTbM2bMsPs5uXzMmDFKgwYNlNDQUKVdu3ZKu3btlEcffdTcbvz48eY+1apVS2nfvr1SpUoVBYBSpUoVZdOmTRqOkC0PPPCAAkBZt26d1X78+9//dmt9WpH7Uvr4X758Wendu7f5/VatWint2rVTQkJCFADK9ddfr2RnZztcX2kKCgqUe++91/x+fHy8ct111ykVKlRQACh16tRR/vzzT6vP/PrrrwoA5aabblJuu+02BYDSpEkTJSkpSWndurW53S233KIAUKpWraq0atVK6dChgxIbG6sAUEJDQ5XPP//cpj8ffvihAkAZPny4ctNNNykmk0lp3bq10qJFC/M+9unTx+4xW7t2rfl/Hh4errRr105p06aNeV9Kn1snTpxQEhMTFQBKWFiY0rRpU6VVq1ZKWFiYAkDp3r27cvnyZUf/IiuGDBmidOvWzXwcu3XrZn6tXLnS3O6FF14wt6lXr56SlJRk7l+1atWU//u//7NZt7xuX3nlFSUkJESpVq2a0qlTJ6VevXo254cjHn30UfN2ExISlKSkJCUqKkqpVq2aMm3aNAWA8tBDD9l8bt26dUpMTIwCQImOjlbatm2r1K9f37yup59+2tw2KytL6datm1KrVi0FgNKsWTOr47Bo0SJl5cqVSrdu3ZTIyEgFgNKxY0erNjt27FAURVHS0tIUAErDhg1t+iS3vWDBAsVkMil16tRROnTooFSsWFEBoFSqVEk5cOCAzed2796tVK1a1bwvSUlJ5mM7btw483xaWpqmY1pYWKjceOONCgAlJCREadGihdKxY0clPj7efK6eO3dOURRFWbRokcPzo1u3bkpWVpaiKI6/ByXy+rD3v9Jz/js6vpcuXVL69u2rAFBuvvlm5cKFC5qORVkh93/o0KFKhw4dFJPJpLRq1Upp37690rdvX3O7N998UzGZTAoApXr16kr79u2VGjVqmI/NsmXLbNa9f/9+c5uoqCglKSlJadCggfn3R+/5oSiOf/cc/R/ld2vPnj2V4cOHm6+j1q1bm7+XWrdurVy9etVmW3v37lXq1q2rAFAiIiKUxMREpUmTJubjMGTIEKWkpERz34MZCmdixgjh/Prrr5u/jNRiND09XWnfvr0SHh7uFeEcGhqqdOnSRcnIyDC/d+XKFUVRFGXhwoVmQaDub1FRkTJr1iyzSJHttbJ27VoFgPKPf/zDZj98JZyffvpps8Ddvn27efnhw4eVli1bmn9UHK2vNFLItW/fXtm5c6d5+eXLl5UxY8aYxY0a+eUeGhqq1KpVS9m8ebP5PfUx/uqrr5Q9e/ZYfbakpERZsWKFUqlSJaVKlSo2P8zyByU8PFxJTEy0Eu2pqalmYfDTTz9Zfe748eNmgffggw8qOTk55veKi4uVH374Qfnuu++slnXt2lUBoNx3333KqVOnzO9lZGQoPXr0UAAozzzzjM0xc4aj46woivL999+bRfpnn31mXp6bm6sMHjxYAaA0atTIRqzL6zY0NFR56aWXlMLCQkVRxLG09wNamq+++koBoERGRiorVqwwL8/JyVH69u1rvmZL/4hnZmYq1atXV0wmk/LKK69YbWvTpk3mH+nvv//e6nOurnX1PjkSIVqEc4UKFay2ceHCBfPN2rBhw6w+U1xcrLRt21YBoAwYMEA5e/as+b2vv/5aiYyMNB8HrcLo66+/VgAo1113ndX3kqIoyunTp5Xk5GTl0qVLdvvuCHeFs97z397xPX/+vNK9e3cFgHL77bfr/r4cO3aszQ2Blpe8adCC3P/Q0FClefPmyv79+83vyf7+9NNPislkUmJjY20E8gcffKCEhYUplStXVk6ePGleXlJSonTo0EEBoPTr18/q+H3xxRdKeHi4WbiWhXAODw9X4uPjlS1btpjf+/PPP5V69eqZbxrV5OXlKU2aNDHfBObm5prf27dvn9K6dWsFgPLuu+9q7nswQ+FMzMgfK0evnj17mtvaE87FxcXmH0v1D7/k8OHDSmhoqFeEc2RkpJKZmWnzufz8fKV27dpKaGioOVpVmnvuuUcBoHzyySd237fHlStXlKZNmyoxMTFWosqXwjk3N9ccPVq+fLnNZ7Zu3aoAUEwmk/LXX3/ZXZ+a06dPK5GRkUqVKlVsfvgVRfy/O3XqpABQfvvtN/Ny+eUOwG7kRgsyylk66ix/UEwmk93o66RJk8w/DmqkyL/llls0RVW+++47BYDSqVMnsxBVc/LkSaVSpUpKpUqVNEedFcW5MJIRx/Hjx9u8d+nSJXM0ftGiRVbvyev2jjvu0NwPNTIqOmvWLJv3zp49a47Clv4Rl8d64sSJdtcrbwR69+5ttbyshPNTTz1l896ePXsUAEpMTIzV8lWrVikAlBo1aijnz5+3+Zz8ntEjjGbPnq0AUN5++21N7dV9d4S7wlnv+V/6+J45c0Zp3769+UayoKBA6y6Zkb8Zel96hKjcfwBWgQM1UgB/++23dt+XwYeZM2eal8kgSXR0tHLmzBmbz4wbN86t/rornB19t86dO1cBoNx55512lw8ePNhuP3bv3q2YTCalcePGmvsezNDjTGxo1qwZunXrZvNq27at08/t378fmZmZqFixIu69916b95s2bYoePXp4pc+33nor4uPjbZanpqbi1KlT6NChA9q3b2/3s3feeScAYP369Zq3N2vWLPz11194+eWXERcX516nDWbjxo24fPkyGjRogLvuusvm/U6dOqFLly5QFAUpKSku17dy5Urk5+ejX79+qFevns37ISEhuP322wHYP3YxMTF2+6EmPT0dr776KoYOHYrevXuje/fu6N69O5YuXQoA2L17t93PXX/99ejYsaPdfQSAo0ePWi3/9ttvAQDPPvuspjzX33zzDQDhvQ8Ls00+VKdOHXTq1Al5eXnYvn27y/W5Ii8vD6mpqQCAp556yub9ChUq4LHHHgMArFmzxu46HnzwQd3bvXjxIrZs2QJAeI5LU61aNQwaNMjuZ+UxGjVqlN33+/fvj4iICGzevNluSkVvY69fbdu2RVRUFHJzc5GTk2NeLq+Hu+++2256R3vHxhVyoPCPP/7o1tgCI9F7/qvJzMzETTfdhJ07d+Kxxx7D559/jvDwcN19WLduHRQRrNP1cqcIS+vWrdGhQweb5cePH8eOHTtQq1Yt8/d+aez9HqxevRoAcO+99yI2NtbmM2PGjNHdR0+oVq0a7r77bpvljr7/XF2r7dq1Q6NGjXD06FGcOHHC4N6WP5iOjtigJR2dPeTgkpYtWyIiIsJum3bt2nml2mCrVq3sLv/jjz8AiMFE3bt3t9tGFlnIzMzUtC2Zs7lDhw745z//qb+zXuLQoUMAxPF39OPYunVrpKammts6Qx6733//3eGx+/vvvwHYP3bNmjVDaGiow/V//PHHGD16NK5eveqwjaOBR02aNLG7XOYfz8vLMy+7ePGiuX833nijw22pkfu+YMEC/O9//7PbRh5DreeNM/766y+UlJSYB17ao3Xr1lbbLY2ja8DVdhVFQY0aNezeeALimi1NXl6eecDa448/7nQbV69eRU5OTpnfYDo6R2rWrImMjAzk5eWhRo0aACzfXfb2FQAaNmyIKlWq4MKFC5q3P2jQIDRq1Ahr1qxBfHw8+vfvjx49euDmm282/y/LAnfOf8mFCxfQvXt3HDt2DE8//TTeeOMNb3TRcFz9Hly9etXhd5r8PlJf1/Kac7TeZs2aISwsrMxuEPV8/wGW/f7Xv/6FV155xe5ns7OzAYj9thcoIRYonIlhyGwGlStXdtjG2XueULFiRbvLc3NzAYjsF85GGwOWVGGuGDNmDIqKirBgwQKEhPjPQxv5ZemoeA0As3i5ePGiy/XJY5eRkeEwo4PE3rFz9D8BRPaCxx57DIWFhXj66afxj3/8A02aNEGlSpVgMpnwwQcfmN+3h6N1y/+HohrlrhY7WovFyH3fu3evy7ZazxtnyP9dzZo1Hd70uPrfOTvejnD3mpXHB7AU43GGEcdIL3rOEa3HQY9wrlixojlN5ddff42lS5ean6QkJiZizpw55ic23sSd819y5coV87np6ImdP+Lq9+DChQsuz1v1Oau+Pu0REhKC2NhYu1mGvIGecxuw7LeWp2O+uFYDDQpnYhjyYi59t6vG0Y++FAulL3iJsxRjzqhUqRIA4IEHHsBnn33m1jpKs3PnTphMJruP+uQX1Jw5c/Duu++ifv36+L//+z9DtusKua+nT5922EZGiLXcwMj1TZ061bAS4pIvv/wShYWFuO++++xGsVwJdT2o9zU3N1eTeJD7npKSgltvvdWwvrja3pkzZ6Aoil3xrOd/pxV3r1nZX0CkJ3Pn0b0/4cl3lzPq1auHxYsX4/3338f27duxbt06fP3119i2bRsGDRqETZs2oXPnzprX5873pDvnvyQuLg5vvvkmhg0bhoceegiRkZEYMmSI5s+reeqpp5ymenPE119/jdq1a7u1zdLI87Zbt27YuHGj7s85Cr6UlJRYWX/8jUqVKuH8+fM4fPgwmjZt6uvuBDwUzsQwmjdvDkBURyssLLT7YyofGZVG/nA5+mL666+/3OpTYmIiAG2RQz0UFxebhYw98vLykJeXh6ioKEO36wx5/A8cOOBQfO3bt8+qrTO8dewAmB/zd+3a1e77jrzN7lClShXUq1cPJ06cwO+//45+/fq5/ExiYiJ27dqFvXv3lolwbtq0KUJCQpCfn4+jR4/afRSr53+nd7vZ2dnIysqyW+LX3jUbExOD+Ph4nDx5Evv27XNYOtseWjy2en24niKP6Z49e+y+n56erivaXJqwsDB07twZnTt3xvPPP4/7778fS5YsweLFi3UJZ3e+J905/9Xcfffd+PTTT/GPf/wDw4cPR0REhEN/sDP++OMPTU8nSuPMyqUX+Z124MABlJSUaH5iqP5ts8dff/3l8OmYP5CYmIjNmzdj7969FM4G4D/PmUnA06pVK9StWxd5eXk2xQ8AMWBhw4YNdj8rfZ32orMnTpwwD87QS48ePRAbG4vdu3cb5q0+f/68w4EsDz30EADg3//+NxRF0VUswVO6d++OChUqICMjwzwYSM22bduQmpoKk8mEPn36uFzfbbfdhoiICKxcuVJzcQStyMp59m4+Dh48iO+//97Q7ckBbv/5z380tZcDb9577z1Df7gdUalSJfNNhL0y61euXMEHH3wAALqFjzMqV65sFm72ig/l5uZixYoVdj8rj1FycrKubcr/vbNHwlraGIm8Hr755hu7kWVHhZncRXqNT548abXc1X47+568dOkSlixZYvdzes//0tx3331YvHgxiouLce+992LVqlW611GWgwMd0axZM7Rp0wZnz57FJ598ovlzffv2BQB89dVXdiPL8+fPN6yP3kBeq3PnzjW8WEswQuFMDCMkJAQTJkwAAIwbNw6///67+b0TJ05g6NChDiNJAwYMAACsWLECK1euNC/PysrCAw884Pagi6ioKMycOROAGBG9fPlymy+OvXv34vnnn3crGqKX5ORkNGrUCPfdd5/h665SpYp5sOLYsWOtHoseOXLELOqHDh3qcHCJmvj4eEyYMAGFhYXo16+fzY2HoijYunUr/vnPf9qM4naFHJgzf/587Nq1y7z80KFDuPfeex0OLnWXZ599FjExMUhJScHIkSNx7tw583slJSVYuXIlfvjhB/OywYMH48Ybb8TBgwdxxx132ETy8vPz8eOPP+LRRx81rI/PP/88AHFM1AMSL168iAcffBBnzpzxyrkzadIkAOJmT33Dcu7cOdx3330O7QvPP/88qlevjo8//hiTJk0yD7KVnD17FosXL7ax+Ujx99tvvzn8EZdt9GS68YRbb70V7dq1Q3Z2NoYPH261LytWrMDs2bN121HeeustJCcn29wcpqenm2+CSmd+cLXfvXr1QlRUFLZt24b333/fvPz8+fN4+OGHHdoF9J7/9njwwQfx3nvvobCwEIMHD8bPP//stL2/MmfOHJhMJjz55JP44IMPbH5bjh49ipdfftmciQIAbrnlFrRv3x6XL1/GiBEjrI7fl19+iQULFtjNvuMvPPHEE2jcuDF+/fVXPPDAA8jKyrJ6Py8vD19++aX5u4C4wBs57khgYlTlQFlZCoDSsmVLpX379jaVA9U5MiUjR440fy4hIcFccbBly5bmyn+O8jg7ymsqUVdkq169utKpUyelQ4cOSvXq1c3LSxfNcAdXeZxlf9U5sd1B9tle5cBevXqZ309MTFSuu+46c/7s6667TlflwMLCQuUf//iH+f3atWsrN9xwg3LdddcplStXNi9XV2JTV7dyhLqqWmhoqNKqVSulTZs25kpvsjBN6Tymziqjudp2SkqKuc/h4eHKddddp7Rt29ZcUa70OXTy5Elz7loAStOmTZXOnTsriYmJSkREhAJAiYuLc7iP9nB0nCXq87R+/fpKx44dzf2rVq2asnXrVpvPuFOxrDTqyoGNGzdWOnbsqERHRyvVqlVTpk6dqgCwqsQp2bhxozm/dHh4uNK2bVulc+fOSuPGjc0VyUoXG/nrr7/Mx69hw4ZKjx49lJ49e1p973zyySfm/rRp00bp2bOn0rNnT3MRHi15nB3h6HipKwdWqFBB6dixo9KoUSNzTmj5ufT0dE3HVF2ttFGjRsoNN9ygtGzZ0nwttmnTxiZn9MyZM83XRPv27c37rS4C8u9//9u83rp16ypJSUlKdHS0EhcXp7z44osOrw8957+z4ztv3jzzMVLnb/cHXH0/SN59913z/6Fy5cpKUlKS0rFjRyUuLs58bEsXEdm7d6/59yI6Olrp2LGj+ZzwReVAezj7vx04cEBJSEhQAFHJslWrVkrnzp2V5s2bm49F586dNfc9mGHEmRhKWFgYvv/+e8yaNQvNmjXD0aNHcerUKTz00EPYsmULIiMjAdgf4LRw4ULMnDkTTZo0QWZmJs6cOYMnnngCqampqFq1qkf9mj17NjZt2oThw4ejYsWK2L17N44dO4Z69erh0UcfxY8//ohbbrnFo234A9HR0Vi9ejXefvttdOzYEcePH8ehQ4eQmJiIWbNmYfPmzeYUXFoICwvDp59+ih9//NH8uHfnzp3IyspC8+bNMXbsWKxbt0637zYsLAyrV6/GU089hbi4OPz11184f/48Ro4cie3bt6Nu3bq61qeFW2+9FXv37sXYsWPRsGFDHDx4EBkZGWjSpAmeffZZjBgxwqp9nTp1kJqaivnz5+Omm25CTk4Odu7ciYsXL+KGG27ASy+9hF9//dXQPs6ePRvff/89+vTpg7y8POzZswexsbEYPXo0du/ebc7TajT//e9/MX/+fLRt2xaZmZk4fvw47rjjDmzdutXse7Z3zXbr1g379+/H1KlTkZiYiLS0NOzZswchISHo378/5s+fj7ffftvqM02aNMH333+Pnj174ty5c9i4cSPWr19vZWsaMWIE3n77bbRr1w5HjhzB+vXrsX79epuotpG0a9cO27Ztw3333Yfo6Gjs3bsXlStXxrvvvou5c+dqyryhZvTo0XjxxRdx0003obCwELt27cK5c+fQqVMnvPPOO9i6davNQL0XXngBM2bMQNOmTbF//37zfqvtQtOmTcO8efOQmJiIM2fOICMjA0OGDMG2bdvQsGFDh/3Re/47YsyYMXjzzTdx+fJl3HbbbVZPFgOFJ598Ert27cKoUaNQs2ZN7Nu3D4cPH0ZsbCzuv/9+fPXVVzZ50Vu3bo1t27Zh+PDhqFChAvbu3YsqVargnXfewbvvvuujPdFOy5YtsXv3brz66qvo1KkTMjMzsWvXLhQUFKBnz5544403HFp9iDUmRaHhhZQdd9xxB3744QcsX77cYWEFQoj/8NRTT+Hdd9/FW2+9ZbZiBRs5OTmIjY1F1apVrR7TE0KCD0acSZlx4sQJpKSkIDQ0VHcifkJI2aMe6NutWzcf98Z3fPjhhwAcZ4EhhAQPFM7EcGbNmmWTheHPP//EXXfdhfz8fNx1112G5eUkhHhOcnKy1SBNQFQQu+eee8wl671lE/EX/vjjD7z//vtWgyEVRcFnn32G6dOnAxD2C0JIcEOrBjGcRo0a4fjx44iNjUWjRo2Qm5trFtKNGzfGb7/95hUPKyHEPW6++WasX78eMTExaNy4MfLz83Hw4EGUlJQgNjYWv/76K9q0aePrbnqVdevWoVevXggNDUXDhg1Ro0YNHD161Jyp4oknnsDChQt93EtCiK+hcCaGs2jRInz11VfYu3cvcnJyEBISgoSEBAwaNAhPP/00qlWr5usuEkJULF++HJ988gl27Nhhrl5Yv359DBgwAM8991xQ3OiePn0a//nPf7BmzRpkZGQgNzcXVapUQfv27fHYY49h2LBhvu4iIcQPoHAmhBBCCCFEA/Q4E0IIIYQQogEKZ0IIIYQQQjRA4UwIIYQQQogGKJwJIYQQQgjRAIUzIYQQQgghGqBwJoQQQgghRAMUzoQQQgghhGiAwpkQQgghhBANUDgTQgghhBCiAQpnQgghhBBCNEDhTAghhBBCiAYonAkhhBBCCNEAhTMhhBBCCCEaoHAmhBBCCCFEAxTOhBBCCCGEaIDCmRBCCCGEEA1QOBNCCCGEEKIBCmdCCCGEEEI0QOFMCCGEEEKIBiicCSGEEEII0QCFMyGEEEIIIRqgcCaEEEIIIUQDFM6EEEIIIYRogMKZEEIIIYQQDVA4E0IIIYQQogEKZ0IIIYQQQjRA4UwIIYQQQogGKJwJIYQQQgjRAIUzIYQQQgghGqBwJoQQQgghRAMUzoQQQgghhGiAwpkQQgghhBAN+Fw4z58/HwkJCYiKikJSUhI2bNjgtP369euRlJSEqKgoNG7cGAsXLrRps2zZMiQmJiIyMhKJiYlYvny57u3m5eVh7NixqFevHqKjo9GqVSssWLDAs50lhBBCCCEBi0+F89KlSzFhwgRMnToVO3fuRI8ePTBgwACkp6fbbZ+WloaBAweiR48e2LlzJ6ZMmYJx48Zh2bJl5japqakYNmwYRowYgd27d2PEiBEYOnQotmzZomu7EydOxKpVq/DZZ5/hwIEDmDhxIp566il8++233jsghBBCCCHEbzEpiqL4auOdO3dGhw4drCK5rVq1wqBBgzB79myb9s8//zy+++47HDhwwLxs9OjR2L17N1JTUwEAw4YNw4ULF/DTTz+Z2/Tv3x/VqlXDF198oXm7bdq0wbBhwzB9+nRzm6SkJAwcOBD//ve/DToChBBCCCEkUAjz1YYLCgqwfft2vPDCC1bL+/bti82bN9v9TGpqKvr27Wu1rF+/fli0aBEKCwsRHh6O1NRUTJw40aZNcnKyru12794d3333HR599FHEx8dj3bp1OHToEN5++22H+5Sfn4/8/Hzz3yUlJTh79ixq1KgBk8nk+GAQQgghhBCfoCgKLl68iPj4eISEODdj+Ew4Z2dno7i4GHFxcVbL4+LicOrUKbufOXXqlN32RUVFyM7ORp06dRy2kevUut25c+fiscceQ7169RAWFoaQkBB88MEH6N69u8N9mj17Nl566SXXO08IIYQQQvyKjIwM1KtXz2kbnwlnSelIrKIoTqOz9tqXXq5lna7azJ07F7///ju+++47NGzYEL/99hvGjBmDOnXq4NZbb7Xbt8mTJ2PSpEnmv3Nzc9GgQQNkZGSgSpUqDvfJXzlzBmjaVMz/9RdQs6Zv+1NemDkT+M9/gCeeAF57rey3n58P1Kol5tPSgOrVjVnvE08AS5aI/Rs/3ph1lldefx2YNQt48EHgnXeAli2BrCxg3TqgfXvrtq++Ckjn2vXXA++9J9qrKSgAVqwAVq4EUlKAvDyxPDoaSE8HIiIc96VXL2DHDuCLL4CBA43ZvwcfBL79VpzfTzxh/V7p809RgFatxPLVq4EbbxTvbdgA3H470KwZsG2b8+2dPw80bCjmz5xxvr/+xl9/AUlJQJUqQEaGts/MnQtMnw4MHQr897+273foABw5Is6Hbt1cr09RgKpVxXzv3sAvv4j5p54S5+fgwcBHH4llixcDEycCt90G/O9/2vpLiL9z4cIF1K9fH5UrV3bZ1mfCOTY2FqGhoTbR5dOnT9tEgyW1a9e22z4sLAw1atRw2kauU8t2r1y5gilTpmD58uW47bbbAADt2rXDrl278MYbbzgUzpGRkYiMjLRZXqVKlYAUzlevWuYrVxZf7MRzrp2qKCjw3TGtVg04dw64fBlo1MiYdcbGiqkv9ytQiIkRU0URx6pqVSGcS0psj93w4cCqVcBddwFTpgDh4bbre/5565uw2rWBCxfE//fwYaBLF8d9uXBBTOvWNe7/5upcUJ9/K1YI0ZyUBPTpA5SOm1Sp4rpf8kYhNFRcX4HkjIuPF9OLF8X3rJa+N28upllZ9o9NXJwQzleuaP+fhoUBRUXW25fnWnS0ZT3ypiQyktc5KX9osdX6LKtGREQEkpKSkJKSYrU8JSUFXbt2tfuZLl262LRfs2YNOnbsiPBrV7ijNnKdWrZbWFiIwsJCG59LaGgoSkpKdO4pIdbIG1r5Y+8LatcWUweuKLeQP6JSiBHHyPtrOSTC2bFr00ZEhGfMsC+aS0qAzz4T8088Afz+O5CZCfTrJ5b99pvzvpw7J6bVqunbB2fIG4PcXPvvy9hIRgYwf76YHz/eWrRduiSmFSu63t7ly2JaoUJgiWbA8r9XFMs+u6JBAzF1kIDKfOOSna29H/LcKi62LJOpA8JUITb5Exgaqn3dhJQnfJqObtKkSfjggw+wePFic8q39PR0jB49GoCwPjz44IPm9qNHj8bx48cxadIkHDhwAIsXL8aiRYvwzDPPmNuMHz8ea9aswZw5c3Dw4EHMmTMHa9euxYQJEzRvt0qVKujZsyeeffZZrFu3Dmlpafjoo4/wySefYPDgwWVzcEi5pVIlMb140Xd9oHD2LVFRYqpFOLti82bg5EmxjrffBjp3BkJCgJtuEu87E86KImwOQNkKZ3n+zZ8vRH5cnLAdqHFXOAca0dEWEar1/y+F84kT1kJXYpRwliJZLZzl+y7GTxFSbvGpx3nYsGHIycnBzJkzkZWVhTZt2mDlypVoeM2slpWVZZVbOSEhAStXrsTEiRMxb948xMfHY+7cubjnnnvMbbp27YolS5Zg2rRpmD59Opo0aYKlS5eic+fOmrcLAEuWLMHkyZPxwAMP4OzZs2jYsCFefvlls7gmxF0YcSYy4iztUJ4cuy+/FNNBgyzrBSzCeeNGIXbsRQgvXrQIIW8IZ0f7I8+/774T03/+07rvQPAIZ5NJ/P/PnRPHS1o3nFG7thC6hYXCrlF6LJM3hTMjziTY8fngwDFjxmDMmDF23/tIjkZQ0bNnT+zYscPpOocMGYIhQ4a4vV1AeKU//PBDp+sgxB1kxLm8CmdHUUZiQY9VwxnFxcDXX4v50hHb664TN2kXLgB79tgOOgQsNo2ICBH5NApX54J6GEtEBGAvHiE/q8VHG8jCGbAWzloICRFiOS1N2DW8JZzlvD3hzIgzCVZ46hNSxpRXq4arKCOxYJRw3rRJRByrVhUD69SEhgIye6Yju4ba32ykN1irVQMA7rvPWkhLzpwRUy3ZfMqDcAb0/f+d+Zw9Ec5FRZZl9jzOUkwz4kyCFQpnQsoYWjVIaeHsSmg6YulSMR082H4KNlc+Z2/4mwF9wtlR6kIp+qQIdEZ5Ec56/v/eEs6MOBPiHJ76hJQx5TXiTOGsHSMGBzqzaUjUwllGD9V4I6MG4Fo4d+ggItz9+ol5ewRTxNmdpzVlIZydDQ5kxJkEKz73OBMSbMiI8+XLjgdteRsKZ99ixODA334DTp8WoveWW+y36dhRiPTsbODgQVFoRI2vhHO7dsChQ84HwknhHEwRZz3///r1xdRo4azOuMqIMyG28NQnpIyREWdAe95Wo5HCOTvb2tPoCfLH/9Il+ymyiAUjPM4ym8bdd9vP7wwI+4YsfmLPruFt4XzxorUQU9O0qXOhK0VfMEScjfY4yyJLFy9azjFXMKsGIdqgcCakjImKskRrfOVzrlFD/PApiiWy5ynq7Ae+tKEEAp4K56IiYNkyMT9smPO20q6xYYPte94Szp6eC+rzksLZPs6Ec9Wqlu+YnBxt69MacWYeZxLs8NQnpIwxmXw/QDA0FKhVS8wbZdeIiLB4d5mSzjmeCud164SwrFED6NXLeVspnNevt/U5S+Fctaq27WolKsoyWNGdc+HyZYuNhVYN+0irxrlztjcnISGWqLNWu4a9rBrOIs4UziRY4alPiA/gAMHgRt5guOtxljaNe+6xFjX2uPFG0ebECeD4cev3vBVxBtzPFAJYos2RkdbWJkcEo3CuUsVyw5ORYfu+Xp+z1qwaHBxIgh0KZ0J8gK8jzgBQp46YZmYat04KZ23IiHNBgYgC68mqUFICfPONmHeUTUNNhQpAp05ivrTP2V+FszoVnZb80sEonAFjM2twcCAh2uCpT4gP8IeIs7MfXXehcNaGurx0QYHluOXnux7MdeyY8K1GRgI9e2rbnqN8zt7K4wwYE3HW4m8GLINsA1046z1Wzq5hvTfn9oSztG2oB58y4kyCHQpnQnyAP0ScKZx9h1o45+dbzgfA9bHbu1dMW7VybdOQ9Oghpr6IOLtzLujJqAFYIs4VK+rflj/g7rFydg3LEupXrmhblzyXWACFEOfw1CfEB8iIM4VzcFJaOIeGWkSfVuHcurX27XXrJiwPhw+LEt0Sbwpnd6OogL4czgCtGkYIZ71WDUacSbBC4UyIDyivVg1PoozBhMlkyTqhd4Dgvn1i2qaN9u1VrQpcd52Ynz1b+KoVxX89znqtGhTOtu95SzgzHR0JdnjqE+ID/MGq0bChmGZkOC5SoRdPoozBhrsp6WTEWY9wBoDJk8X0nXeAl18WYrOwUCzzN+GsHhyohfIknO2VRneEM+Esj4U8Nq5gxJkQbbDkNiE+wB8izvHxImpUUAD8/bcly4Yn0KqhnchI68puWo5dYaEonQ3oF85DhwqbxoQJwPTplgF1YWHe8QYz4qwd+b8vLhYRYq37IYXziRPis2oxy4gzId6Bpz4hPsAfIs5hYUDdumLeKLsGhbN23Ik4//WXuNGpWNEimvQwfjwwY4aYf/VVMa1WTVvKN4nWpxOMOGunYkXL/0DPtVOnjhDLhYXi5leNEcJZZtVQC2d7ywgJJiicCfEB/hBxBiziq3RhDHehcNZO6SIoWvzh0t/curX7Eb8ZM4CnnrL8rcemUVwsCqq0bWuxeTjCk3Mh2CLOJpN7x8vZza+nwjkkxL5ItheFJiSYoHAmxAf4Q1YNwOJzZsS57HEUcXYWoXXX36zGZAKSk4F//EP8Xa+e9s9u2wb83/+Jfhw96rytERHnYBHOgPG5nN0VztJj7Ug4M+JMgh2e+oT4AH+wagDGZ9agcNaOO1YNI4QzIETR4sXArbeKCLJWVq2yzB85ArRo4bitu8K5qAg4e1bMa7FqlJRYovblQTgblVlDHgujI85yGQcHkmCFwpkQH+BvVg2jhLMnUcZgwxPhrCeHsyPCw4GHHtL3mdLC2Rnungs5OWJqMgHVq7turxaGgSycjS6CIiPOerNqMOJMiHNo1SDEB/hbxJke57JHr3C+elUMDgQ8jzi7Q04OsHWr5W9vWTWkTaNaNW3iTC0MpVgMRIyOOHvLqkGPMwl2KJwJ8QH+EnGmx9l3lB4c6OrY/fmnEC3VqhmTOlAva9daZ1zQGnHWm5vY3YGBUVGBnSLN34RzaCgjzoTYI4C/ZggJXPxlcKD80T171pi+yB//vDxLZIrYR2/EWW3T0JM+ziikTaNdOzF1JZzVuYm12gWA4BwYCHgunDMyrJd7e3AgPc4kWKFwJsQH+ItVo0oVS2TQiKiz/PEHfL9v/k5p4ezK42rUwEB3UBSLcB4zRkyPHnWe07liRYu40mPXkBHnYMnhLPFUOGdn27et0KpBiLFQOBPiA2TEuaBAvHyJkQMEIyOBiAgxT7uGc/RGnGUOZ18I5z17gFOnhDh94AEhiK9eFcscoc5NrEc4M+Ks73MxMZYbcXXU2d2S2xwcSIhzKJwJ8QFSOAO+j8wa7XN2NztAsOHI4+xIZPoy4iyjzb16iXNXnjPeyKyhN+IsS4cHq3AG7N/8GuFxlkVu5HsArRqEUDgT4gPCwy0RR18PEPRWLmempHOOnohzXh6QlibmjUhFpxcpnPv3F9PGjcXUG8LZ3YhzxYrat+GPeHLduBLOWgZnyggyI86EOIfCmRAf4S8+Z6ak8w2OhPPVq7b2nQMHxDQuTnsk1iguXgQ2bRLzUjg3aSKm/hBxLi9WDU+e1DgTzoqizQ6mjioDjrNq0ONMgh0KZ0J8BFPSBTelhbO8kQJszwlf2jR+/VU8sm/SBGjaVCyTwtlVLmd3zgV309EFunD2llUD0GbXoMeZEG1QOBPiI/wtJR2Fc9lSWjiHh1vETulj5w/+ZhltBrwbcebgQP2ftXcNR0RY8lprGSCoNeJMjzMJdiicCfER/mbVOHHCmNzLFM7aKD04EHD8uN7IUtt6UBTgp5/EfFkIZ0UJXquG0cLZZNI3QLC0cDaZaNUgxB4UzoT4CH+xatSpI34Ei4qArCzP1+duqeVgo3TEGXAsnnyViu7wYeDYMRG9vPlmy3I5ODA727nQ03su5OVZ/LjBHHHWU2kRAOrXF9OMDOvPeiKc1RFlWjUIsUDhTIiP8JeIc2goUK+emDeyCAojzs7RKpzPnQMyM8V8WUecf/lFTLt3t06hWLmyRdg6izrrFc4y2hwdrV0IlzfhXFhofU5ooW5dMc3PB3JyLMs9jThLaNUgxAKFMyE+wl8izoCxPmcKZ204E85qoSmjzfXrW1dmLAvkE4jmzW3f0zJAUG+KNb3+ZqD8CGf1jYneayciAqhVS8yfOGFZzogzIcZD4UyIj/CXwYGAsSnpaNXQhtaI8+7dYuqLgYFnz4pp9eq272nxOetNsaY3owZQfoRzSIjlKZQ71458aqQWznqqB5YWziEqdUCPMyEWKJwJ8RHyR5IR5+DE3uBAe8dODs7r1q1s+qXm3DkxtSectRRBcdeqoSdXdXkRzoBnuZztCWdvWjUonEmwQuFMiI/wp4izkbmcGXHWhpaIc14esHatmL/rrrLrm0RGnKtVs31PT8SZVg1teHLTabRwVkec1fP0OJNgh8KZEB/hL4MDAUacfYEW4bx6tXi/SRPflNrWYtVw5nFmxFkf/iScZcQ5LMw6+kyrBgl2KJwJ8RH+ODiQHueyw55wLv2o/ttvxfSuu6zFS1khrRrOIs7p6SIThD0YcdaHPwlnGVEuLZBp1SDBDoUzIT7Cn6waUjjn5noueBlx1oYUzo48zoWFwA8/iL99YdMAnEeca9cWwqy42PENl9yfggLr/XQEI85i6g/CWR1xVkOrBgl2KJwJ8RH+NDiwUiWLOMrI8Gxd8sf/0iXLjyyxRQ4OdGTV2LhRRHxjY4GuXcu+f4rifHCgyeR6gKA8xwFtYpARZzH1VDjLIihGZNUovZwRZxLsUDgT4iP8KeIMGOdzVuca9oebAn/FVR5nadO4/XbfiJSLFy1+VntWDcC1zzk0VF+KtWBORwd4JpxlEZRLlyyf90bEmR5nEuxQOBPiI/xpcCBgnM85IsISTaXP2TGuhPOKFWJ+0KCy7JUFadOIjLQIsNIYnVlDRpz1WDUuXRLTihW1f8Zf0VswRk2FCpYnA9KuYbRwVhQKZ0IonAnxEf40OBAwNrOGJ/logwVnwvnIEXEDEx0N9OlT9n0DrAcGOhqYaGQu58JC4Px5Ma814qwojDirKe1z1iOcHQlhe8VPAHqcSfBC4UyIj1BHnKUn0ZcYmcvZk8hZsCCj8sXFFt+oPG4lJWLat6/vBKGzgYESIyPOMtocEuLYGlKaggLLsSoPwtnTG05p1zAi4iw9zo6EMyPOJFjxuXCeP38+EhISEBUVhaSkJGzYsMFp+/Xr1yMpKQlRUVFo3LgxFi5caNNm2bJlSExMRGRkJBITE7F8+XLd2zWZTHZfr7/+umc7TMg1ZMRZHTXzJd5ISceIs2NkxBmwRJ3lcZP4KpsG4HxgoETtcXZ086f1JkoK5xo1rAtuOEN93ZQH4Wx0xNmTwYESe1UDSy8nJJjwqXBeunQpJkyYgKlTp2Lnzp3o0aMHBgwYgHQHIa+0tDQMHDgQPXr0wM6dOzFlyhSMGzcOy5YtM7dJTU3FsGHDMGLECOzevRsjRozA0KFDsWXLFl3bzcrKsnotXrwYJpMJ99xzj/cOCAkq1D/0/uBz9kYRFEacHWNPOKuzUISEiIGBvsJZ1UBJo0bCxnHpEnD6tP02Wm+iPElFFxbmWPgFEr60apS2XtjzOKuFM60aJFjxqXB+8803MXLkSIwaNQqtWrVCcnIy6tevjwULFthtv3DhQjRo0ADJyclo1aoVRo0ahUcffRRvvPGGuU1ycjL69OmDyZMno2XLlpg8eTJuueUWJCcn69pu7dq1rV7ffvstevXqhcbS1EeIh4SE+JfPWQrnzEzP08gx4uyasDBLZFUKZ/XAym7d9GWXMBotEeeICKB+fTHvyK6h16oRrBk1AN8KZ5PJfhSZEWdCrPGZcC4oKMD27dvRt29fq+V9+/bF5s2b7X4mNTXVpn2/fv2wbds2FF4rXeWojVynO9v9+++/8eOPP2LkyJFO9yk/Px8XLlywehHiDH9KSVe7tojalZQAJ096ti4WQdGGsyIovrRpANoizoBrn7NW4RzsqegA3wpnwFoM24s4qz3OWu00hJQ3fHbqZ2dno7i4GHFxcVbL4+LicOrUKbufOXXqlN32RUVFyL4WrnDURq7Tne1+/PHHqFy5Mu6++26n+zR79mzExMSYX/VlKIYQB/hTSrqQEEv00FOfM8tua8NeEZQePYTPd9gw3/RJomVwIGDJrJGWZv99vRHnYK0aCPiXcLa3TF38xBcl4AnxB3x+z2gqdfUpimKzzFX70su1rFPPdhcvXowHHngAUfJXzgGTJ09Gbm6u+ZXhaQk2Uu7xJ6sGYHwRFEacnWMvJd1XX4njL0WQr9Bi1QDEkwrAInxLo9Xvzoiz5Vjl51ufE1qR58z588J3LoWz1sHHriLOLLdNCOAzl1JsbCxCQ0NtorynT5+2iQZLateubbd9WFgYatSo4bSNXKfe7W7YsAF//vknli5d6nKfIiMjEake8UOIC/xNOBuVko6DA7VhTzibTP4hBLVaNWSE2JFwLovBgf5wvIygdIlyvR73KlXEOi5eFGMV5HExKuLM4ieE+DDiHBERgaSkJKSkpFgtT0lJQdeuXe1+pkuXLjbt16xZg44dOyL82pBqR23kOvVud9GiRUhKSsJ1112nbwcJ0YAUmP4inI1KScfBgdqwJ5z9Ba0RZ63CmYMDXRMaarmZNsKuYbTHWW3VICRY8alVY9KkSfjggw+wePFiHDhwABMnTkR6ejpGjx4NQFgfHnzwQXP70aNH4/jx45g0aRIOHDiAxYsXY9GiRXjmmWfMbcaPH481a9Zgzpw5OHjwIObMmYO1a9diwoQJmrcruXDhAr766iuMGjXKuweCBC3+5gU22qrhL/vlr9gbHOgvGB1xplVDG0b6nL3lcaZVgwQzPr1vHDZsGHJycjBz5kxkZWWhTZs2WLlyJRpee16clZVllVs5ISEBK1euxMSJEzFv3jzEx8dj7ty5VrmVu3btiiVLlmDatGmYPn06mjRpgqVLl6Jz586atytZsmQJFEXB/fff7+UjQYIVfxPORlk1GHHWhr3Bgf6C1sGB11xyHglnRbGcc3XqaO9jeRXOJ08aUz1QLZwVxfWAPj2DAwkJVnx++o8ZMwZjxoyx+95HH31ks6xnz57YsWOH03UOGTIEQ4YMcXu7kscffxyPP/640zaEeIK/CWe1VUPLD60jGHHWhr9aNQoLLZleysKqkZ4u3g8PB5o3197P8iqcAWMjzoA4x1yMb7cbSabHmRBrfJ5Vg5Bgxt+Es0xHl5cnRua7CyPO2vBX4Sz9zQBQtarztlI4X7liP3uDFIKXLwtBbo89e8S0VStRVEUrFM62qIWz+rhoyayhFsSyhLq6IiMjzoRQOBPiU/xNOFeoYPGYemLXYMRZG/7qcZbCOSbGtZ+1UiWL2LUXdZbnOOB4EOzu3WKqdww2hbMtauEcHm75/+ktu810dITYh8KZEB/ib8IZMGaAoNyvggL/i6b6E/7qcdY6MBAQAsuZXSM83GIZcHSey4hzu3b6+nnpkphSOFvwpAiKvYgzrRqEWEPhTIgPkQLTE1uE0RiRkk6m1AL866bA3/B3q4Yrf7PEU5+zjDjrFc7Sh60+3wIdT5/WSOF85ow4r/QIZ3tltDk4kBBrKJwJ8SH+GHE2IrNGaKilmAN9zo7xV+GsNaOGxBPhfPkycPiwmNdr1ZDWD3XhkEDH0/EB1atbnmScPKlPOKstGPYizrRqEELhTIhP8UfhzFzOZYe/C2ctVg3AM+G8b58QabVqAQ6KxjqkPApnT68bk8n+AEG9gwPtLWPEmRAKZ0J8ilpQyAiPrzGqeqCnXs1gwN8HB+qNOOfk2H9f5nq2dzPm7sBAwHJulSfh7OomRAvuFkFxFXGmx5kQCmdCfIoUzoWF/iOeWASl7CgPgwMB12KvRw8xXbvW9j13BwYCloizvEkrD8isNqdPu78OI4SzhBFnQqyhcCbEh1SubEn75C+WBhlxzsoSWTHchVYN1/irVcPowYF9+ojpL7/Y5nI2QjiXp4hzrVpiKkuQu4O3Is70OBNC4UyITwkJsfzo+4vArFlTCDpFATIz3V8PI86u8VfhbPTgwPbthV3j4kVg61bLckXxzKpRHoWzOuLsrn3LUdltV9CqQYhrKJwJ8TH+NkDQZDLG58yIs2v81eOs16ohPcyOhHNoKHDrrWJ+zRrL8hMnRCrGsDCgZUt9fVSU8i2c8/Mt6fb0Yi/irGVwoDodnbOIM4UzCWYonAnxMf4mnAFjfM6MOLvGXyPORls1AKBvXzFVC2d1qW15LLRy9aolAlqehHPFipZMGO76nO1l1aBVgxBjoHAmxMf4o3A2IiUdI86uKY+DAx3ZC6TPeetWizB3t/AJYF2+uzwVQAE89zlL4ZyVZSmHrrcACiPOhNiHwpkQH+PPwtkTqwYjzq7xx4izorgfcS4ocGwvqF9f2DFKSsQgQcCzgYHyvKpUyX7Fu0BGCmd3I861aglxqygWAUyPMyHGUM6+bggJPPxROBth1WDE2TX+KJwvXbJkvtAqnCtUsHhp9dg1ODDQPp6mpAsJsQwQlJlxGHEmxBgonAnxMf4onI20ajDi7Bhp1fCnwYHSphEebvHHakGvz/nKFeDQIfE3U9FZY0RKOimc5U2ZlsGB9iLO4eGWZfQ4E0LhTIjP8WfhfPy4+ymx/HG//A095ZDLCrVNQ+YY14IW4dyzpxBix44B330nbBs1awK1a+vvZ3kWzkYUQZFPC/RYNdQR55ISMaVVgxBrKJwJ8TH+KDDr1xfTK1ccl1F2BSPOrqlYUUwvXfJtP9TozeEs0SKcK1UCunUT86+/Lqbt2ukT6JLyLJyNiDjLAZNSANOqQYgxUDgT4mP8UThHRlqigO7aNfxxv/wNKZzdzdfrDWTEWWtGDYkW4QxYsmts3y6m7tg0gPItnI2IOMtzy13hbC/iTKsGIRTOhPgcfxWYnvqc1RFnd+0e5R0ZFSxPEWdXTyikz1nizsBAoHwLZyMjztJeQasGIcZA4UyIj/FX4Swza7ibkk7uV0mJfwlDf0Jt1fCXmwtvR5xl+W2JuxFnaQGSN2jlCU/T0QEW4SyjxFqEs9oyQ6sGIfahcCbEx/ircPY04lyhguWRLn3O9pHCWVG0CZuywJseZ8C6/HZoKJCYqG87kvIccZZWjTNn3L+hKi2c9ZbcdmbVoHAmwQyFMyE+prwKZ5OJAwRdoU735i9ReXeFs4wiuxLOgMWu4U6pbUkwCOfCQve/F+RNmZ48zuqIMz3OhNiH942E+Bh/Fc6eWjUAIZzPnfO/ffMXQkNF4ZArV4RwloLJl3jbqgEADzwA7NsHDByobxtqyrNwjooS+3XxorBrVK2qfx0y4uxuARR6nAmxDyPOhPgYKZwLCvyrEIYRRVBYdts1/pZZw9tWDUBEmf/zH+CWW/RtQ015Fs6A5wMEpXCWBVCMjDhTOJNgRtPpP2nSJN0rnjZtGqrr/eYlJAhR//Dn5lqqyfkaKZz//lsIenf6xbLbrqlYUYhNf7FqGBFxVhT3cjProbwL55o1gSNH3B8gKG/I5M04rRqEGIMm4ZycnIwuXbogIiJC00o3btyIsWPHUjgTooHQUCEwL1wQAjMuztc9ElSvLn58L10CMjKAZs30r4MeZ9f4W0o6Tz3OxcXiPHbHXqCH8i6cjYo4S+F89aoQwyFOnjPTqkGIazSf/suXL0cteSW7oHJ5/SYjxEvExFiEs79gMomo84EDwufsjnD2V/+2P+Fv1QPdFc5RUUKs5eWJqLO3hXN5TkcHeJ6STgpndTaNq1etB6SWhlYNQlyjyeP84YcfIkb+AmrgvffeQ5y/hM0ICQD8VWA2aiSm7g4QZMTZNf7kcS4qsvyv9Fo1AH0+Z08p7xFndUo6d7D3JENPykMKZ0Lso0k4P/TQQ4jUkTNo+PDhqCh/DQghLvF34XzsmHuf99f98if8yapx/rxlnsLZt3gacVbfkElPsivhrI4427Nl0ONMiBtZNTIyMnDixAnz31u3bsWECRPw/vvvG9oxQoIJfxWYMiWdu8KZEWfX+JNVQw4MrFzZvahiWQnnoiKLCCyvwllGnD21ahQXi5SHgGvhrC62Qo8zIfbRLZyHDx+OX3/9FQBw6tQp9OnTB1u3bsWUKVMwc+ZMwztISDDgr8LZU6uGv+6XP+FPVg13/c2SshLO6mNVXoWzp4MD1Q99ZUYcV9UD7Qnn8HDLMlo1CHFDOO/duxc33HADAODLL79EmzZtsHnzZvzvf//DRx99ZHT/CAkK/FVgemrVYMTZNf4UcQ4U4SxtGuHh7lce9Hc8jTiHhVmOjRTOejzOtGoQYh/dwrmwsNDsd167di3uvPNOAEDLli2RlZVlbO8ICRL8XThnZoryv3rx1/3yJ/zJ4+xuDmeJFM45Ocb0xxHl3d8MWCLO2dmW6K9e5LklM8m6Es7q7dgTzrRqEOKGcG7dujUWLlyIDRs2ICUlBf379wcAnDx5EjVkIk9CiC78VWDWqiWiVSUlgGpog2YYcXZNebJqyJ8Ab0ecy3sqOsByE1JcbLmh0YsUztJu4anHmVYNQtwQznPmzMF7772Hm2++Gffffz+uu+46AMB3331ntnAQQvThr8LZZPJsgKC/7pc/4U9WDaMizmVl1SjPEeeICEsubE99zlLo6hHO9kQyhTMhOgqgSG6++WZkZ2fjwoULqKb6dn388cdRwVlmdUKIQ/xZYDZqBPz5p3vCmRFn1/iTVSPQPM7lWTgD4onP+fPC59yypf7Py3PLHeFMjzMh9tEdcQYARVGwfft2vPfee7h47RssIiKCwpkQN/Fn4exJxFkK57w8yw8xscYfI84Uzv6BUSnppNB1lVWDHmdCXKP79D9+/Dj69++P9PR05Ofno0+fPqhcuTJee+01XL16FQsXLvRGPwkp1/izcPYkJZ264OjFi94vwxyI+KPH2VOrxtmzQmR5KzIZLMLZ05R0UjiHXAuR6Yk4S2jVIMQa3RHn8ePHo2PHjjh37hyiZVZ1AIMHD8bPP/9saOcICRYCQTi7E3GOjLSM6Kddwz7lyaohBweWlFhXITSaYBHOnkac5U2ZrAioJ6uGhFYNQqzRfd+4ceNGbNq0CRHy1/AaDRs2RGZmpmEdIySYKK/CGRD7duaMf+6bP+CPVg13I87h4eL/nZsr7BreSrQULMLZqIizUcKZVg1C3Ig4l5SUoNiOWfHEiROoXN6/xQjxElI45+eLlz8hPc4nTlgiTnrgAEHnlCerBlA2PudgSEcHWISzpx5nacEwKuJM4UyCGd3CuU+fPkhOTjb/bTKZkJeXhxkzZmDgwIFG9o2QoEF9z+lvkdnatYXdorhYFELRiz9H0/0Bf7JqeBpxBspGOAdLxFlaNTxNRycFsavBgfYG8NKqQYg1uoXzW2+9hfXr1yMxMRFXr17F8OHD0ahRI2RmZmLOnDne6CMh5Z7QUIsI8DeBGRJiTGYNRpztI8XN1au+zTxy5YrlaQeFs39gVMRZCmd3Is4hKpXAiDMhbnic4+PjsWvXLnzxxRfYsWMHSkpKMHLkSDzwwANWgwUJIfqIiRGCwN+EMyB8zocPC+Hcs6e+zzLi7BwpnAERdfaV/UBGm0NCPBOkFM7GYVQ6Oq3CubQVKyzM4o8G6HEmBHAzj3N0dDQeffRRvPvuu5g/fz5GjRrltmieP38+EhISEBUVhaSkJGzYsMFp+/Xr1yMpKQlRUVFo3Lix3fR3y5YtQ2JiIiIjI5GYmIjly5e7td0DBw7gzjvvRExMDCpXrowbb7wR6enpbu0nIa7wZ4EpI87upKRjxNk5UVEWceJLu4YUzlWrWkcZ9ULhbBwy4pyT497TCCmcCwvF1B3hbO99CmcSzLj19fjpp5+ie/fuiI+Px/Frv6RvvfUWvv32W13rWbp0KSZMmICpU6di586d6NGjBwYMGOBQnKalpWHgwIHo0aMHdu7ciSlTpmDcuHFYtmyZuU1qaiqGDRuGESNGYPfu3RgxYgSGDh2KLVu26NrukSNH0L17d7Rs2RLr1q3D7t27MX36dERFRenaR0K04s/C2ZPMGv68X/6AyeQfPmcj/M2AJZNGTo5n63FGsAhneSwVxb3jKZ9mSMGrVziHh9t/nx5nEszoFs4LFizApEmTMGDAAJw7d86cYaNatWpWgwa18Oabb2LkyJEYNWoUWrVqheTkZNSvXx8LFiyw237hwoVo0KABkpOT0apVK4waNQqPPvoo3njjDXOb5ORk9OnTB5MnT0bLli0xefJk3HLLLVZ907LdqVOnYuDAgXjttdfQvn17NG7cGLfddhtqyRAAIQbjzwLTE+HMiLNr/CElnVHCuSwjzuU9q0ZYmEU8uzNAUN6QFRSIqd7BgaUjy7RqEOKGcH7nnXfw3//+F1OnTkWY6urp2LEj/vjjD83rKSgowPbt29G3b1+r5X379sXmzZvtfiY1NdWmfb9+/bBt2zYUXnsW5aiNXKeW7ZaUlODHH39E8+bN0a9fP9SqVQudO3fGihUrnO5Tfn4+Lly4YPUiRCv+LJyNsGr44375C/6Qki6QhLP8ai3vEWfAswGCpYUzrRqEeI5u4ZyWlob27dvbLI+MjMQlHeGS7OxsFBcXIy4uzmp5XFwcTp06Zfczp06dstu+qKgI2de+pR21kevUst3Tp08jLy8Pr776Kvr37481a9Zg8ODBuPvuu7F+/XqH+zR79mzExMSYX/Xr19dwJAgR+LNwlhHn9HT9Xku5X7yPdEx5smp4WzgrSvBYNQDPUtLJGzKZLcUo4UyrBglmdAvnhIQE7Nq1y2b5Tz/9hMTERN0dMKmH7AJQFMVmmav2pZdrWaezNiXXhiDfddddmDhxIq6//nq88MILuP322+0ORpRMnjwZubm55ldGRobDtoSUxp+Fc506wu9YVAScPKnvs7RquKY8WjXczT3siitXLFkigkE4GxFxloKZEWdCPEf36f/ss8/iySefxNWrV6EoCrZu3YovvvgCs2fPxgcffKB5PbGxsQgNDbWJLp8+fdomGiypXbu23fZhYWGocc0I5qiNXKeW7cbGxiIsLMzmRqBVq1bYuHGjw32KjIxEZGSkw/cJcYY/C+fQUKBBA+DIEeFz1vMwxZ/3y18oT1YN+fncXCFwPcnQYQ8ZbQasU/mVVzyJOEvhfPWqmHoqnOlxJsSNiPMjjzyCGTNm4LnnnsPly5cxfPhwLFy4EG+//Tbuu+8+zeuJiIhAUlISUlJSrJanpKSga9eudj/TpUsXm/Zr1qxBx44dEX5t+K+jNnKdWrYbERGBTp064c8//7Rqc+jQITSUZk9CDMbfBaa7PmdGnF1Tnqwa8vOK4p1zWQrnSpWMF+X+iCcR59KVAxlxJsRzdJ3+RUVF+Pzzz3HHHXfgscceQ3Z2NkpKStzONDFp0iSMGDECHTt2RJcuXfD+++8jPT0do0ePBiCsD5mZmfjkk08AAKNHj8a7776LSZMm4bHHHkNqaioWLVqEL774wrzO8ePH46abbsKcOXNw11134dtvv8XatWutIsWutguIyPqwYcNw0003oVevXli1ahW+//57rFu3zq19JcQV/i6c3c2s4e/75Q+UJ6tGZCRQoYLI4HDunOfrK00w+ZsBz4qglI7Iu8qqQY8zIa7RJZzDwsLwz3/+EwcOHAAgLA2eMGzYMOTk5GDmzJnIyspCmzZtsHLlSnNUNysryyq3ckJCAlauXImJEydi3rx5iI+Px9y5c3HPPfeY23Tt2hVLlizBtGnTMH36dDRp0gRLly5F586dNW8XAAYPHoyFCxdi9uzZGDduHFq0aIFly5ahe/fuHu0zIY7wd4FJ4ew9/MGqcf68mBohdKtXFyLt7FmgcWPP16cmWFLRSWRcyh2rRmgoEB1tiTQXFAi7hSPhKwulSGjVIMQW3ad/586dsXPnTsMsC2PGjMGYMWPsvvfRRx/ZLOvZsyd27NjhdJ1DhgzBkCFD3N6u5NFHH8Wjjz7qtA0hRuHvAtNdq0bVqmKany+8lqwhZEt5ijjLdZw4YVmnkQRTKjrAM6sGICwtaovG1auOveHOIs6KQuFMCOCGcB4zZgyefvppnDhxAklJSahY6gps166dYZ0jJJjwd+HsbsS5cmVRHU9RRFSzdm2DO1YOKE8eZ/U6zp71fF2lCVarhrtZSipWtP7slSvuCWd1GkpaNUgwo1s4Dxs2DAAwbtw48zKTyWRO51asN8krIQRA4Ajn48f1ZUsICRGP1XNzxYvC2ZbyFnGuXt16nUYSbMJZRpzPnhVWitJlsF0hb8pCQ4X4dTZA0JlwVr/HiDMJZnSf/mlpad7oByFBjxTOV68KL2JEhG/7U5r4ePGDWVgIZGUBdetq/2zVqkI0Sx8tscbXHuf8fIugYsTZv6heXVx3RUXAqVP6UkECFuEcESH+x84GCDrzOKtjYhTOJJjRffozHRsh3kE92Ck31/KI1l8ICwPq1RNWjePH9QlneVNA4WwfX1s1ZGTYZDJm0B0jzsYREiJyqB89qj+HOmC5KZPC2VnEufQDY0acCbFF9+n/3Xff2V1uMpkQFRWFpk2bIiEhweOOERJshIYKAZWX55/CGRB2jWPHxMtBunW7yAGC/mpD8TW+tmpIgVu1qjG5kWXEmcLZGBo1sgjnHj30fVbelEmxa4RVgx5nEszoFs6DBg0ye5rVqH3O3bt3x4oVK1DN6ASehJRzYmKEcPbXyKy7AwSlcPbX/fI1vrZqGOlvBiwRZ29aNYIlHR3g/nUHGCec1dHoYCg8Q4gjdJ/+KSkp6NSpE1JSUpCbm4vc3FykpKTghhtuwA8//IDffvsNOTk5eOaZZ7zRX0LKNYEyQJDC2Vj8xaphlHD2ZsQ52NLRAYB8iOuJcJZiV49wVg9EVFcNNJn094OQ8oLuiPP48ePx/vvvW5XFvuWWWxAVFYXHH38c+/btQ3JyMvMfE+IG/m5paNBATDMy9H3O328IfI2/WDWMFs4cHGgMnkSc5bklhbOzwYFarBq0aZBgR3fE+ciRI6hi5xlZlSpVcPToUQBAs2bNkJ2d7XnvCAky/F1g1qsnpnqFMyPOzimvVg16nI3BCKuGjBI7ijiXlIhc62rsCWcODCTBjm7hnJSUhGeffRZnVBnVz5w5g+eeew6dOnUCABw+fBj15C8sIUQz/i6c5Yh+Cmdj8ZeIs/w/eQoHBxqLFM7p6baZL1yhVTjbW689jzOFMwl2dAvnRYsWIS0tDfXq1UPTpk3RrFkz1KtXD8eOHcMHH3wAAMjLy8P06dMN7ywh5Z1AEc4XLli8plrw9/3yNVLcFBWJHN5ljbciznl5trmBPSUYhXOdOsJvXFQEnDyp77PypkxGkx0J59I2DYARZ0LsofsSaNGiBQ4cOIDVq1fj0KFDUBQFLVu2RJ8+fRByzUQ1aNAgo/tJSFDg7wKzYkUhrs6dA06cABITtX2OEWfnqEsg5+VZhGdZYbRwluexXLesfmcEwSicQ0PF+IIjR/TncpY3ZSUlYupuxJkeZ0IEbt07mkwm9O/fHzfffDMiIyNh4hBbQgzB34UzIHzO584JuwaFszGEh4tXYaGwawS6cA4NFedybq4YIOgN4RxM6egAYdeQwllPLufSwtnR4EBXEWdaNQgR6LZqlJSU4N///jfq1q2LSpUqmUtwT58+HYsWLTK8g4QEE4EgnN3xObNyoGt8mZLOaOEMeGeAYFGRJWIaTBFnwP0BgvJphhS+tGoQ4hm6hfOsWbPw0Ucf4bXXXkNERIR5edu2bc0eZ0KIe5RX4ezvafb8AV8OEPSGcPbGAEEZbQYonLWi9s8DngtnWjVIsKNbOH/yySd4//338cADDyBUdQW1a9cOBw8eNLRzhAQbgRCZ9UQ45+XZ/4Emvk1J582Is5G5nKVwjogQr2DCU+EsB2ky4kyIZ+gWzpmZmWjatKnN8pKSEhQaPXyakCDDm/lvjUJmmjxxQvtn1IPFGHW2T3mzangz4hxs0WbA98KZHmdCBLqFc+vWrbFhwwab5V999RXat29vSKcICVZq1BBTb1RcMwp3Is7h4UCFCmKewtk+vrJqFBRYBox5Qzh7I+IczMJZby5neV7JNIeMOBPiGbovgRkzZmDEiBHIzMxESUkJvvnmG/z555/45JNP8MMPP3ijj4QEDTLifP68+HH0Rz+hWjgriqWwgiuqVhUCzZ9tKL7EV1YNdURY/WTAU7zx9CSYhbPM5VxYCGRmivR0WpARZ5nH2d2sGvQ4EyLQHXG+4447sHTpUqxcuRImkwn/+te/cODAAXz//ffo06ePN/pISNAgo3SK4r8CU1o1Ll3S10empHOOr6waUtjGxBgrirxp1Qi2VHSAJZczoM+uIZ/0SGjVIMQz3LoE+vXrh379+hndF0KCnvBwEU27eFE84pbWDX8iOhqIjQWys0XUWevj/UDIGOJLfGXV8Ia/GfDO4EBZrTIYI86AdS7nm27S9pmQECGeZaT56lX77WjVIEQbuiPOhBDvEgg+Z3cGCDLi7BxfWzWMFs4cHGg8ng4QBBxntaFVgxBtaLp3rFatmubqgGf9+deekACgenXxw5iT4+ueOKZ+fWDXLvdS0lE426e8RZw5ONB4PBHOp0+LeUfJr+wJ5/Bw2/cZcSbBjqZLIDk52Tyfk5ODWbNmoV+/fujSpQsAIDU1FatXr8b06dO90klCgglvPOI2Gk+qB9KqYR9fe5y9ZdVgxNk4jIg46xHO9DgTYoumS+Chhx4yz99zzz2YOXMmxo4da142btw4vPvuu1i7di0mTpxofC8JCSICwarhSREURpztU54jznqyrziDwllM3S27DXhu1aBwJsGObo/z6tWr0b9/f5vl/fr1w9q1aw3pFCHBjIzU+bNVgx5n4ylvHmd5HhcUOM7koJdgzqoBWIRzRoa+CpxGRJzpcSZEoFs416hRA8uXL7dZvmLFCtTwxxQAhAQYtGoEJ+XNqlGpkkVkGWXXCPaIs8zlXFQEnDyp/XO0ahBiHLovgZdeegkjR47EunXrzB7n33//HatWrcIHH3xgeAcJCTYCTThrfQzPiLNzyptVw2QS5/KZM+JcrlvX83UGezq60FCgYUPgr7+EXUNrERS1VcPTiDOFMwl2dEecH374YWzevBlVq1bFN998g2XLliEmJgabNm3Cww8/7IUuEhJcyAc3/mzVkCLo6lXt/aRwdk55s2qo18mIs3G443NmOjpCjMOte8fOnTvj888/N7ovhBAERsQ5MhKoVUukuMrIEAVRXEHh7JzyZtVQr9Ooc5nC2XPhzIgzIZ6hKeJ8QT4f08hF+e1GCNFNIAhnwGLX0DpAkB5n55Q3qwZgfEo6Cmf3hLMRVg16nAkRaBLO1apVw2mZPV0DdevWxdGjR93uFCHBTCCkowP0DxCUEefcXKCkxCtdCmho1XANhbMxEWdFsW0jhbEaRpwJsUXTJaAoCj744ANUUl99Tih0dEtLCHGJjNKdPy9+zPzVU+iucC4pEeIwWFOKOUIK58uXjct77IrCQkuE25sRZyNuAhWF6egAz4UzIK7B0t8r9DgTog1NwrlBgwb473//q3mltWvXRri6VichRDNSwCiKEM/+muVRr3COihKptAoLRdQ5mMWPPaS4URSR97hCBe9vUx0JllYaIzEy4nzxouVJhTf6GihI4ZyeLsSslghwaeFcWKhfONOqQYhA0yVwTG+ZIkKI24SHi0fRFy+KSJ2/CmdZBEWrcDaZRNT5zBlxQyCFNxGohfKlS2UrnCtX9o4gMnJwoHQLVqxYNsfGX5G5nAsLgcxMkZ7OFWqPMyA+GxVlvYyDAwnRhu50dIQQ7xMIKen0Dg4EmFnDGSEhQHS0mC8rn7M3/c2AsYMDz5wR01q1PF9XIBMSYhHLWmNapSPO9kQyrRqEaIPCmRA/JBAya6iFs9bBfsys4ZyyTknnbeFspFVDRpxr1vR8XYGOXp+zPatGaWjVIEQbFM6E+CGBIJzj44X9oqDAEg10BSPOzinrlHRlFXE20qoR7BFnwCKc09K0tbdn1SiNPeGsHqpEqwYhAgpnQvyQQLBqhIcDtWuLeb2ZNSic7VPWKenk/yEQIs60alho3FhMjxzR1t7diHNIiO37FM4k2KFwJsQPCYSIM6Df56zO5UxsKc9WDU9zd9OqYaFJEzF1Vzhr9Tjbe58eZxLsaLp33LNnj+YVtmvXzu3OEEIEgSSct27VHnGWHmdGnO1T3qwacr0lJSJLjCdp5BhxttC0qZh6O+KsLpRCjzMhAk2XwPXXXw+TyQRFUWBykZW/2F75IUKILgJJOAO0ahhFWVs1vC2co6NF2rOrV8W2PBHOjDhbkBHn06fFDYmrSorR0WI8ghTCWoWz+ueeVg1CBJqsGmlpaTh69CjS0tKwbNkyJCQkYP78+di5cyd27tyJ+fPno0mTJli2bJm3+0tIUBAIHmfAs7LbxJbyFnEGjLsJZMTZQkyM5TtCS9TZZLIeIOhOxJlWDUIEmu4dG6oyrN97772YO3cuBg4caF7Wrl071K9fH9OnT8egQYMM7yQhwUagRJz1FkGhVcM55c3jLNd98qTnAwQZcbamSRNxY33kCHD99a7bV6pkeZKh1eNMqwYhtugeHPjHH38gISHBZnlCQgL2799vSKcICXYCRTi7OziQwtk+5THibET1QEVhxLk0en3O7kSc7b1P4UyCHd3CuVWrVpg1axauXr1qXpafn49Zs2ahVatWhnaOkGAl0KwamZmWiJQzKJydU948zoAx1QPPn7cIN0acBZ5k1vDEqkHhTIId3cJ54cKFWLt2LerXr49bb70Vt956K+rVq4eUlBQsXLhQdwfmz5+PhIQEREVFISkpCRs2bHDafv369UhKSkJUVBQaN25sd5vLli1DYmIiIiMjkZiYiOXLl+ve7sMPPwyTyWT1uvHGG3XvHyHuIMXG+fPaBKmvqFNHeB6LioC//3bdnpUDnVNerRqAZxFnadOoUgWIjPS8T+UBKZz/+ktbe6OEMz3OJNjRLZxvuOEGpKWl4eWXX0a7du3Qtm1bvPLKK0hLS8MNN9yga11Lly7FhAkTMHXqVOzcuRM9evTAgAEDkJ6ebrd9WloaBg4ciB49emDnzp2YMmUKxo0bZzUoMTU1FcOGDcOIESOwe/dujBgxAkOHDsWWLVt0b7d///7Iysoyv1auXKlr/whxF7WQ8efobGiopQhKZqbr9uqIs/pHmQjK0qpRVCQyMgD+H3GWNg1Gmy3ojTirrRr0OBPiPm5dAhUqVMDjjz/u8cbffPNNjBw5EqNGjQIAJCcnY/Xq1ViwYAFmz55t037hwoVo0KABkpOTAQjbyLZt2/DGG2/gnnvuMa+jT58+mDx5MgBg8uTJWL9+PZKTk/HFF1/o2m5kZCRqS1VASBkSHi6iaxcuiEidtG74I/XqCdF84gTQqZPztlI4FxSIFGXR0V7vXkBRllYN9Q2Z/L94AyOqB7Lcti3S45yRIa6niAjn7WnVIMQY3Koc+Omnn6J79+6Ij4/H8ePHAQBvvfUWvv32W83rKCgowPbt29G3b1+r5X379sXmzZvtfiY1NdWmfb9+/bBt2zYUXvsmcNRGrlPPdtetW4datWqhefPmeOyxx3Bafns7ID8/HxcuXLB6EeIuMlLn7z5nmVlDS8S5UiVLGV/aNWwpS6uGFLKVKokbNW9hxEBXDgy0JS5O3GiVlADHjrlu745wVld7pFWDEIFu4bxgwQJMmjQJAwYMwLlz58wFT6pVq2aOBGshOzsbxcXFiIuLs1oeFxeHU6dO2f3MqVOn7LYvKipCdna20zZynVq3O2DAAHz++ef45Zdf8J///Af/93//h969eyM/P9/hPs2ePRsxMTHmV305cooQNwiUzBp164qplswaISEikg74twXFV5SlVaMs/M3q9RsRcaZVw4LJBDRuLOa1+JzVwlmrVUMtnGnVIESgWzi/8847+O9//4upU6ciTHUFdezYEX/88YfuDpSuROiqOqG99qWXa1mnqzbDhg3DbbfdhjZt2uCOO+7ATz/9hEOHDuHHH3902LfJkycjNzfX/MrQmtyWEDsEinCWEWempPOcsrRqlLVwZsTZePT4nF2lo7M3CFktpmnVIESg+xJIS0tD+/btbZZHRkbiko4wSWxsLEJDQ22iy6dPn7aJBktq165tt31YWBhqXDOBOmoj1+nOdgGgTp06aNiwIQ4fPuywTWRkJCI55JsYRKCkpNNj1QBYPdAZZRlxlv8vbw/jMGJwICPO9tGTy9kdqwaFMyG26I44JyQkYNeuXTbLf/rpJyQmJmpeT0REBJKSkpCSkmK1PCUlBV27drX7mS5duti0X7NmDTp27IjwayY9R23kOt3ZLgDk5OQgIyMDderU0baDhHhIoESc9Vg1AFYPdEZZepzT0sTUTj0rQzHCqsGIs330pKRzRzir29HjTIhA973js88+iyeffBJXr16FoijYunUrvvjiC8yePRsffPCBrnVNmjQJI0aMQMeOHdGlSxe8//77SE9Px+jRowEI60NmZiY++eQTAMDo0aPx7rvvYtKkSXjssceQmpqKRYsWmbNlAMD48eNx0003Yc6cObjrrrvw7bffYu3atdi4caPm7ebl5eHFF1/EPffcgzp16uDYsWOYMmUKYmNjMXjwYL2HjBC3CBThrLZqKIrwXjqDVg3HlGXEWQ4oa9TIu9uR5/GFC0J8uROxZMTZPu5aNbR6nNXCmR5nQgS6L4FHHnkERUVFeO6553D58mUMHz4cdevWxdtvv4377rtP17qGDRuGnJwczJw5E1lZWWjTpg1WrlyJhg0bAgCysrKscisnJCRg5cqVmDhxIubNm4f4+HjMnTvXnIoOALp27YolS5Zg2rRpmD59Opo0aYKlS5eic+fOmrcbGhqKP/74A5988gnOnz+POnXqoFevXli6dCkqV66s95AR4haBYtWIjxfTq1dFVFEKJUfQquEYKW6uXhVCxZvRvbKKOKtT3Z0/D8TG6l8H09HZRwrntDQxkC/EyTNkWjUIMQa3LoHHHnsMjz32GLKzs1FSUoJaHnybjRkzBmPGjLH73kcffWSzrGfPntixY4fTdQ4ZMgRDhgxxe7vR0dFYvXq1088T4m0CJeIcFSXEUHa2iDq7Es60ajhGLW4uXbJkIPEGZRVxDgsDKlcWxVbOntUvnEtKxLkFMOJcmgYNxPHNzxeedWeJnFwNDqRVgxBtuJXHWRIbG+uRaCaEOCZQhDOgb4AgrRqOiYy0RA29adfIzwdOnhTz3o44A54NEDx71pIWzZ1odXkmLMxy4+PK56wet+6OcKZVgxCBpkugffv2TlPEqXEVDSaEaCPQhPOuXdoGCNKq4RiTSUQGL170bkq648eFH71ChbKJ4larJrbpjnCWAwOrVnVdHS8YadJEiOYjR4BevRy3Uxe50epxplWDEFs0XQKDBg3ycjcIIaUJFI8zoC+zBiPOzqlUSQhnb0ac1TYNjTERj5A3gVIE64H+ZudoHSCoFs6eWDUonEmwo+kSmDFjhrf7QQgphRQb5897f6CYp+ixatDj7JyaNYGsLGGluP5672yjrAYGSq6Nu9ZUGro0TEXnHK25nNXRenqcCXEfjzzOhBDvoa7o5u8iU0/1QEacndOsmZg6qbXkMWU1MFCiJ21aaZiKzjlaczl7atWgx5kQgaZLoFq1apo9zmcDwZBJSAAQHi6yKly4IOwa0rrhj7hj1aDH2T7Nm4vpoUPe20ZZR5w9Ec6MODtHfWyd5VGnVYMQY9B0CSQnJ3u5G4QQe1SvLoSzv9+P0qphHOU54qylwl1pGHF2TuPGYipvsB1lHjFKONOqQYIdTcL5oYce8nY/CCF2qF5diBx/F84y4nz+vMgGoc5HXBoZcb50Sfwwq3/QSdkIZ19FnE+dEv93dU5hV3BwoHOio8X1l5kpos6OhLM7HmdaNQixxS2P85EjRzBt2jTcf//9OH3tW23VqlXYt2+foZ0jJNiRAwT9PbNGlSqiyAXgOuosI86AiJIRa6RwPn5c5Fs2msuXLWK0rIRz9eoWz/7Ro/o+K60ajDg7RktE3x2PM60ahNiiWzivX78ebdu2xZYtW/DNN98g71qy0T179jD7BiEGI33N/h5xBrTbNcLCLBFH2jVsqVVL3IgoinueYFdIm0aVKtblsL2Nuz5nRpxdo+XYumPVsJfHmVYNEuzoFs4vvPACZs2ahZSUFESonv306tULqamphnaOkGAnkIqgMJezMZhM3rVrqG0aZZHDWeKucGbE2TVajq3aqmHvSQYjzoRoQ7dw/uOPPzB48GCb5TVr1kSOvz9PJiTACCTh7E5KOmbWsI83hXNZDwyUuCOci4stNiVGnB2jJZezOuJcUGD7vjPhrCiWsucUziTY0S2cq1atiqysLJvlO3fuRF0ZciKEGEIgVQ90J7OGOyWYgwFvpqQr64GBEneEc06OEG2Af6dj9DV6Pc56rRpyYCBA4UyIbuE8fPhwPP/88zh16hRMJhNKSkqwadMmPPPMM3jwwQe90UdCgpZAijjrsWrI/aJwtg8jzgLpb65Rg4LNGfLY/v23yGpjD0+sGur36HEmwY5u4fzyyy+jQYMGqFu3LvLy8pCYmIibbroJXbt2xbRp07zRR0KClkASznqsGjJlVna29/oTyJSVx7kskeLu2DH7EU97sPiJNqpVs0TkHUWd1YLXnlVDHVWWyP8TI86EWNB9CYSHh+Pzzz/HzJkzsXPnTpSUlKB9+/ZoJr/pCSGGESjp6AB9Vg0pnKUwItbIr9PMTP15j10hI85lLZzj44GoKODqVSA93SKkncHiJ9pp2lR8T/z1F3D99bbvm0xCPBcX2xfOzuwb6ogzhTMJdtxKRwcATZo0wZAhQzB06FCKZkK8RCClo5NWjb//tv/DrEYKIUac7VO9uusIojuoq1CWtVUjJMRS5U6rXYOp6LQjBwg6O1+k6C1tyygpsXjJ1dCqQYgtuoVznz590KBBA7zwwgvYu3evN/pECLmGjDifP2//Uao/ERtr8VHaGT9s0xagcHaGN+wa0qZRo4alYE1ZotfnzFR02tEjnEvf2Dr6brEnnEPcKptGSPlB9yVw8uRJPPfcc9iwYQPatWuHdu3a4bXXXsMJLcZGQoguZLU1wP9zHptM2n3OtGq4xhvC2VcDAyV6hTMjztrRI5xL2zLsDQxUL1eX2y7L3N+E+CO6hXNsbCzGjh2LTZs24ciRIxg2bBg++eQTNGrUCL179/ZGHwkJWsLDRYU3IDB8zloza9Cq4RpvpKTz1cBACSPO3kPeaLlj1XAknEtHnOlvJsQN4awmISEBL7zwAl599VW0bdvW7H8mhBhHeRwgSKuGa7wZcQ4U4cyIs3ZkxDkzE7h82X4bmcvZWcRZHVEuLZzpbybEA+G8adMmjBkzBnXq1MHw4cPRunVr/PDDD0b2jRACi2gIBFuDXqvGxYv2c8oS73qc/cGqYW8wWmkYcdZO9eqWipxHj9pvo0U4qz3M9qwahAQ7uoXzlClTkJCQgN69e+P48eNITk7GqVOn8Nlnn2HAgAHe6CMhQY0UDTL65s9otWrExFiiV4w620cK59OnjStN7uuIc6NGQphdvgycOuW6PSPO2jGZXPuctVg11MKZVg1CbNEtnNetW4dnnnkGmZmZ+PHHHzF8+HBUqFDBG30jhMAiGgJBOGu1aoSE0K7hisqVgdq1xbwRUWdF8X3EOSICaNBAzLuyaxQWWipLMuKsDVfCWUacS2fRcBVxplWDEAu6hfPmzZvx5JNPIlb+6hFCvEp5tGoAFM5aMNKuce6csMYAvhPOgHafszwvQkIsPn/iHCmcHZ0vMl2kVqsGI86E2OL2ZbB//36kp6ejoFRCyDvvvNPjThFCLASiVePkSVFUwVnOV6akc03z5sCGDcYIZxltjosDoqM9X5+7NGkC/Pyza+Esz/fYWEY6tWJ0xLl0yW0KZ0LcEM5Hjx7F4MGD8ccff8BkMkG5NsLDdG0obrG/V2kgJMAIJKtG7drih7eoSPRXWg3swZR0rpERZyNS0vk6FZ1Ea8SZAwP14yolnYw4O/M4q7NqlLZqUDgT4oZVY/z48UhISMDff/+NChUqYN++ffjtt9/QsWNHrFu3zgtdJCS4CSThHBYG1Kkj5rVm1qBwdoyRVg1fDwyUaBXOHBioHxlxzsgArl61fV8KZ70RZ3qcCbGgWzinpqZi5syZqFmzJkJCQhASEoLu3btj9uzZGDdunDf6SEhQE0geZ0B7Zg1aNVyjjjhrSd/mDF8PDJRoFc7p6WJK4aydmjXFoFL1QFA1WoSzvTzOtGoQYkG3cC4uLkalSpUAiCqCJ0+eBAA0bNgQf/75p7G9I4SYH1WfOSN8w/4Oi6AYh4wgnj/veQGc/fvF1F8iztnZztPsLV8upt26eb9P5QVXKemkcAasxTOtGoRoR7dwbtOmDfbs2QMA6Ny5M1577TVs2rQJM2fOROPGjQ3vICHBjhTORUVCQPk7MuLsSjjT4+ya6Gigfn0x74ldIy0NkIVde/f2vF+eULmyJYrsKOp89CiwdauwDdx7b9n1rTygVTirM2uwciAh2tEtnKdNm4aSa2GvWbNm4fjx4+jRowdWrlyJuXPnGt5BQoKdyEhRMAQIDJ+z9DhnZTlvR6uGNozwOb//vnh837evJeLrS1zZNZYuFdNevZwPMCW2OBPOkZGWebVYLj1YUMJ0dITYovsy6Nevn3m+cePG2L9/P86ePYtq1aqZM2sQQoylVi3xWPvMGaBlS1/3xjlSOF9zcTmEVg1tNG8O/PKL+8K5oABYtEjMjx5tXL88oUkTIDXVsXBeskRM77uv7PpUXtAqnLVEnFlymxBbdEWci4qKEBYWhr1791otr169OkUzIV4kkHI5x8eLqauIs9qq4enAt/KMvFGSVgu9LF8ubrji44HbbzeuX57gLOK8fz+wZ4/IOXz33WXbr/KAp1YNNYw4E2KLLuEcFhaGhg0bMlczIWVMIKWk02rVqFFDTAsLLRXtiC1Dhghv6YYNwB9/6P/8woViOmqUpQCGr5HCeds22wGv0qbRrx8rBrqDtPYcOyaeNqhxZNVQ/6TT40yIc9zyOE+ePBlnz571Rn8IIXYIpJR0UjhnZ9v+cKupUEG8gMDYL19Rty4waJCYnz9f32cPHADWrROD7EaNMrpn7tO7t/jf79oFvPeeZbmi0KbhKbVri2NbUmLJ3S1R3zhpiTjTqkGILbqF89y5c7FhwwbEx8ejRYsW6NChg9WLEGI8gWTVqFHD8gN96pTztvQ5a+PJJ8X000+dp3ArjRSld9xhyc7hD9StC8yeLeafe84i8HbtEjmro6KAO+/0Ve8CG2cp6bQIZ7VtqqREvGjVIMSC7svgrrvuop+ZkDImkKwaJpOIemVkCLtGgwaO29asKQpdUDg75+abgcRE4f/95BPgqadcf+byZeDjj8W8vwwKVDN2LPDVV8DGjcBjjwFr1liizbffLtLWEfdo2lT4xN0RzqUpKqJVgxA1uoXziy++6IVuEEKcEUjCGRAD0aRwdgZT0mnDZALGjBFic/58MXUVv/jyS5H3u1EjkYbO3wgJARYvBtq1A9auBf77X9o0jMJRxFk9OFBLOjpACGxGnAmxoNuq0bhxY+TYKWF1/vx5FkAhxEsEkscZ0J/LmRFn14wYAVSqBBw8CPz6q+v2CxaI6RNPCJHqjzRrBrz8spgfO1Y8fahUCRg40Lf9CnSMsmrIdvQ4E2JB99fpsWPH7GbVyM/Px4kTJwzpFCHEmkDyOAPahTOrB2qnShUhngFg3jznbX/8UVTeCw8HHnnE+33zhPHjgS5dLEJu0CBRMZG4j5HCWW3VoHAmRIdV47vvvjPPr169GjGylBmA4uJi/Pzzz0hISDC2d4QQAJaIc06O+BHz9x8wvUVQAiWS7muefFJEkr/9FjhxAqhXz7bN2bPCMwwIL3RcXNn2US+hocKycf31QH4+cP/9vu5R4COFc1qa9feFljzO9iLO9DgTYkHzz++ga/mQTCYTHnroIav3wsPD0ahRI/znP/8xtHOEEEGNGsLTqihCPPu7GKJVwzu0bg307CmKobz3HvDvf9u2GT9eHPcWLYBZs8q+j+7QsiXw/ffAvn3AgAG+7k3gU7euyExy9aqwv0gXpTri7MjjLIVzWJhYTqsGIdZotmqUlJSgpKQEDRo0wOnTp81/l5SUID8/H3/++Sdu95eyVISUM8LCLAVDAiE6q7V6IIWzfmRqugULhB1DzYoVwGefCU/zxx8HluWhTx9gwgTXgx6Ja0JCLEVm1KXa9Vg1pEimVYMQa3R7nNPS0hArf+0IIWVGIPmc6XH2HoMGidR0OTlA165icF1xsTiGTzwh2jz3HNC5s0+7SXyMTAOZmWlZpseqIUUyrRqEWOPzsdbz589HQkICoqKikJSUhA0bNjhtv379eiQlJSEqKgqNGzfGQllPVsWyZcuQmJiIyMhIJCYmYvny5R5t94knnoDJZEJycrLu/SPEKAIpJZ0UzqdPO091RY+zfsLDRe7joUOFYJ42DejVC3j4YXG827QBmDWUyHLl585ZlmmxasgS6PaEMyPOhPhYOC9duhQTJkzA1KlTsXPnTvTo0QMDBgxAenq63fZpaWkYOHAgevTogZ07d2LKlCkYN24cli1bZm6TmpqKYcOGYcSIEdi9ezdGjBiBoUOHYsuWLW5td8WKFdiyZQvi5bNnQnxEIKWkq1lTPC4uKXEu9KVwPnfOucAm1lSrJnIef/yxSN+2YYPIpBEaKpZFRvq6h8TXVKsmpo6Es6uIs2xbVESPMyFqfCqc33zzTYwcORKjRo1Cq1atkJycjPr162OBTEBaioULF6JBgwZITk5Gq1atMGrUKDz66KN44403zG2Sk5PRp08fTJ48GS1btsTkyZNxyy23WEWLtW43MzMTY8eOxeeff45w9TcOIT4gkCLOoaGWAYzO7BrVq1s8rWfPer9f5QmTCXjwQVGm+sYbxbKXXgI6dPBpt4if4K5wZsSZEOf4TDgXFBRg+/bt6FuqpFXfvn2xefNmu59JTU21ad+vXz9s27YNhde+BRy1kevUut2SkhKMGDECzz77LFq3bq1pn/Lz83HhwgWrFyFGEUgeZ0DbAMGwMMsPfCBE0v2RJk2EdePoUWDqVF/3hvgL9oSzFo+zM+FMjzMhbgrnI0eOYNq0abj//vtx+tqv+KpVq7Bv3z7N68jOzkZxcTHiSuXViouLw6lTp+x+5tSpU3bbFxUVIfva6CJHbeQ6tW53zpw5CAsLw7hx4zTv0+zZsxETE2N+1a9fX/NnCXFFIEWcAaakK0tCQwGm0SdqXEWcXXmcadUgxD66hfP69evRtm1bbNmyBd988w3y8vIAAHv27MGMGTN0d8BUKveQoig2y1y1L71cyzqdtdm+fTvefvttfPTRR077UprJkycjNzfX/MrIyND8WUJcEUgeZ0B/ERQKZ0KMQwpntQVKj1VDtqVVgxBrdAvnF154AbNmzUJKSgoiVM99evXqhdTUVM3riY2NRWhoqE10+fTp0zbRYEnt2rXttg8LC0ONa0luHbWR69Sy3Q0bNuD06dNo0KABwsLCEBYWhuPHj+Ppp59Go0aNHO5TZGQkqlSpYvUixCgCzaqhNyVdoNwQEBIIuGvVsDc4kFYNQizoFs5//PEHBg8ebLO8Zs2ayMnJ0byeiIgIJCUlISUlxWp5SkoKunbtavczXbp0sWm/Zs0adOzY0Tx4z1EbuU4t2x0xYgT27NmDXbt2mV/x8fF49tlnsXr1as37SIiR0KpBCNGKu4MDJWqPM60ahFjQfRlUrVoVWVlZSChlqNu5cyfq1q2ra12TJk3CiBEj0LFjR3Tp0gXvv/8+0tPTMXr0aADC+pCZmYlPPvkEADB69Gi8++67mDRpEh577DGkpqZi0aJF+OKLL8zrHD9+PG666SbMmTMHd911F7799lusXbsWGzdu1LzdGjVqmCPYkvDwcNSuXRstWrTQtY+EGIUUzrm5QH6+/6ccY/VAQnyHWjgrisjCosXjLJHRaVo1CLFG92UwfPhwPP/88/jqq69gMplQUlKCTZs24ZlnnsGDDz6oa13Dhg1DTk4OZs6ciaysLLRp0wYrV65Ew4YNAQBZWVlWuZUTEhKwcuVKTJw4EfPmzUN8fDzmzp2Le+65x9yma9euWLJkCaZNm4bp06ejSZMmWLp0KTqrymi52i4h/kjVquKHq6hIiEyd96llDq0ahPgOKZyLi4G8PKByZccRZxlRViOFM0tuE2KN7svg5ZdfxsMPP4y6detCURQkJiaiuLgYw4cPx7Rp03R3YMyYMRgzZozd9z766CObZT179sSOHTucrnPIkCEYMmSI29u1x7FjxzS3JcQbhISI6OypU8KuESjC+dQpMeAoxIExjBFnQoynQgUhlAsLRdS5cmVtHmeJvcGB9DgT4oZwDg8Px+eff45///vf2LFjB0pKStC+fXs0a9bMG/0jhKioVcsinP2duDjxeFhGyKXVpDQUzoQYj8kkCgz9/bcQzg0a6PM4q4UzPc6EWHD7MmjcuDEaN25sZF8IIS4IpAGC4eFCFJ85I+waFM6ElC3VqlmEM6Dd4xwWRqsGIY7QnVVjyJAhePXVV22Wv/7667j33nsN6RQhxD6BlstZywBBepwJ8Q6lM2uorRoFBZb50sI5PJyVAwlxhFsFUG677Tab5f3798dvv/1mSKcIIfYpj7mcZcT5yhXg8mXv94mQYKG0cFZHnPPzLfP2Is60ahBiH93COS8vz6rwiSQ8PBwXLlwwpFOEEPsEklUD0FY9UD3an3YNQozDmXB2FnFWC2daNQixRrdwbtOmDZYuXWqzfMmSJUhMTDSkU4QQ+wSaVUNLxNlkol2DEG/gScTZnlWDwpkQNwYHTp8+Hffccw+OHDmC3r17AwB+/vlnfPHFF/jqq68M7yAhxEKgRpy1FEE5eZIRZ0KMRArns2fF1B2rBktuE2KNbuF85513YsWKFXjllVfw9ddfIzo6Gu3atcPatWvRs2dPb/SREHKN8uhxBphZgxBvUDriHBIiXiUlrq0aLLlNiH3cugxuu+02uwMECSHeJdAizjKrhjOPM2ARzrRqEGIcpYUzIKLGJSXO8ziXHhxIqwYhFty+DAoKCnD69GmUlJRYLW/QoIHHnSKE2EcK58uXgUuXgIoVfdsfV6gjzooi/Mz2kJF0RpwJMQ5Hwrmw0L3BgbRqEOKGcD58+DAeffRRbN682Wq5oigwmUwotlf0nhBiCJUqAZGRwp945oz/C+fatcW0oED8eFevbr8drRqEGI+83tTCWUaN1cJZHX2WbWjVIMQ+ui+Dhx9+GGFhYfjhhx9Qp04dmByFkAghhmMyiahzRoawazRq5OseOScqSkS9zp0TUWcKZ0LKDkcRZ8C1cKZVgxD76L4Mdu3ahe3bt6Nly5be6A8hxAVq4RwI1KljEc6tW9tvw3R0hBiPWjhLq5Q6kixhHmdCtKM7j3NiYiKyGRYixGcEWi5nLQME4+LE1FX2DUKIdqRwLi4G8vLEvD3h7MqqQY8zIRZ0C+c5c+bgueeew7p165CTk4MLFy5YvQgh3qU8pqSrW1dMMzNFZIwQ4jnR0YAs9CvtGlqFM0tuE2If3ZfBrbfeCgC45ZZbrJZzcCAhZUOgpaTTI5wvXwZyc4GqVb3eLULKPSaTiDr//bcQzg0aOLdqmEzixpVWDUIco/sy+PXXX73RD0KIRqRw/vtv3/ZDK1qEc4UKQiyfPy+izhTOhBiDWjgDlgi02tcs50NCRHSZVg1CHKNbOLM6ICG+RQpRV0VF/AWt1QPr1rUIZ0eDCAkh+iidWUMKYnvCOTTUIpxp1SDEPm5fBpcvX0Z6ejoK1DltALRr187jThFCHCNtDYEinLVWD6xbF9i3TwhnQogxlBbOaguGRArjkBBLG1o1CLGP7svgzJkzeOSRR/DTTz/ZfZ8eZ0K8i3ogXSCgjpA7qx4YaPtFSCAghfPZs2LqyqoBOLZqUDgT4kZWjQkTJuDcuXP4/fffER0djVWrVuHjjz9Gs2bN8N1333mjj4QQFVJg5uUBgZDIRgrnK1ec95fCmRDj0RJxLu1hZsltQhyj+/7xl19+wbfffotOnTohJCQEDRs2RJ8+fVClShXMnj0bt912mzf6SQi5RsWKQEyMyD6RmQlUqeLrHjlH3d+TJ8W8PSicCTGe0mW3pSBWPxyW82rhzJLbhNhHd8T50qVLqHVtWH/16tVx5loVhrZt22LHjh3G9o4QYhfpGw4UkanF50zhTIjxlI44a7FqhIay5DYhjtAtnFu0aIE///wTAHD99dfjvffeQ2ZmJhYuXIg68pksIcSrlMcBghTOhBiPI+FcUmJpU3pwYGQkrRqEOEL3/eOECROQdS2v1IwZM9CvXz98/vnniIiIwEcffWR0/wghdgg0kalHOJ8+LaJc8oebEOI+WiLOUjjLgbuRkdZWDSmyGXEmxA3h/MADD5jn27dvj2PHjuHgwYNo0KABYmNjDe0cIcQ+5VE416wpxHJhocj53KBB2fSNkPJMaeEcGSmmUgyrI8/2Is5Xrljep3AmxA2rxsyZM3H58mXz3xUqVECHDh1QsWJFzJw509DOEULsUx6Fc0iIJQNHoOwXIf6OI+Eso8zqyLOMOEdFWYTz1auW9ymcCXFDOL/00kvIy8uzWX758mW89NJLhnSKEOKc8iicAaBePTENlP0ixN9RC2dFsVg1ABFtVgtnidqqoRbO9DgT4oZwVhQFJjsVDHbv3o3qMu8NIcSrlMesGkDg3RAQ4u9I4VxcLHK/y4gzYJ0xA7D2ONOqQYh9NF8G1apVg8lkgslkQvPmza3Ec3FxMfLy8jB69GivdJIQYo0UmKdOiR9Ef48EqYUzqwcSUnZER4soc0GBiDo7E84StXCmVYMQazRfBsnJyVAUBY8++iheeuklxKiqGERERKBRo0bo0qWLVzpJCLEmLk6I5eJi4O+/LcLUX5HeZfnj7ejhFIUzIcZiMomo899/i2svKsryniPhHBVlEcn5+ZblIbqfURNS/tAsnB966CEAQEJCArp164Yw3noS4jNCQ4HatYXAzMz0f+EcGQnUqAHk5IioM4UzIWVH9epCOJ89ax1xVudoVqOOOEv4k0+IQPf9Y+XKlXHgwAHz399++y0GDRqEKVOmoKCgwNDOEUIcE2giU08u5xMnvN8fQoIF9QBB9eDA0hFnRRFT9eBAidHCOSsL2L3b2HUSUhboFs5PPPEEDh06BAA4evQohg0bhgoVKuCrr77Cc889Z3gHCSH2KY8DBNU3A/JHnBDiGVqFs8zprE5HJzFyHMX33wMtWgDt2wM//2zcegkpC3QL50OHDuH6668HAHz11Vfo2bMn/ve//+Gjjz7CsmXLjO4fIcQB5bHstmxz9aol7ywhxDPUwlktiEtbNdQRZ29YNRQFeOUV4K67gIsXxd/jx9u3ixDir7iVjq7k2m3p2rVrMXDgQABA/fr1kZ2dbWzvCCEOKY9Wjehoi/85UPaLEH/HkXB2FHH2hlXj8mXg/vuBqVOFYH7sMXGt79sHvP++Z+smpCzRLZw7duyIWbNm4dNPP8X69etx2223AQDS0tIQFxdneAcJIfYpj8IZCLz9IsTf0Suc7Vk1PBHOFy8CPXoAS5eK9bz3nhDLstjwv/4lBi4SEgjoFs7JycnYsWMHxo4di6lTp6Jp06YAgK+//hpdu3Y1vIOEEPsEmsCkcCbEN+j1ONuzanjicf74Y2DHDiA2VniaH39cLH/iCaB1a5Fth4WHSaCg+x6yXbt2+OOPP2yWv/766wj19yoMhJQjyuPgQIDCmRCjceZxVhcjKi4WU6OtGl9+KaaTJwM33WS9zrfeAvr2BebNA0aPBlq1cn87hJQFhqUzj4qKQnjpW1RCiNeQAvPCBVFK19+RwjkryxLZsgeFMyHGotWqIYWzkVaNrCxg40YxP2SI7ft9+gB33im2PXEis+kQ/0eTcK5evbp54F+1atVQvXp1hy9CSNlQpQpQqZKYD4TMGnFxIrpVVAQ4G0dM4UyIsWi1aqgjzqGh1tFodx8oL1smxPCNNwINGthv88YbQqivXg2sXOnedggpKzTdQ7711luoXLkyAOFxJoT4B3XrAn/+KURm8+a+7o1zwsOBWrVEBbOTJ8W8PSicCTEWZxFndYRXimhZXTAsTLSR8+4gbRr33uu4TbNmIi3dG2+I17WcA4T4JZouBVluu/Q8IcS3qIVzIBAfbxHO19LB20DhTIixyIfB585ZC+DS+ZPVWTUAIbI9Ec6ubBpqxo4Vonn9elE5tF49/dsjpCzQZNW4cOGC5hchpOwINJGpp3rgmTNAfr73+0RIeUdGnIuLLUIYsLVqSNQRZ4k7wlmLTUPSsCHQvbtov2SJ/m0RUlZouhSqVq0Kk9rs5IRiaZIihHid8phZIzZW+DALCkTEqlGjMukaIeWW6GghhvPzRVVOSWGhtY9ZIoWz2tbhjsdZ2jSGDtXW/oEHRIT688+BZ57Rvz1CygJNEedff/0Vv/zyC3755RcsXrwYtWrVwnPPPYfly5dj+fLleO655xAXF4fFixfr7sD8+fORkJCAqKgoJCUlYcOGDU7br1+/HklJSYiKikLjxo2xcOFCmzbLli1DYmIiIiMjkZiYiOXLl+ve7osvvoiWLVuiYsWKqFatGm699VZs2bJF9/4R4k3KY8TZZAq8/SLE35FR5ytXLMtKl9wGxPUnBbNaOOuNOJ886dym8eOPogCKeqDwvfeK7ezaBezfr297hJQVmoRzz549za9PPvkEb775JmbPno0777wTd955J2bPno033ngDH374oa6NL126FBMmTMDUqVOxc+dO9OjRAwMGDEB6errd9mlpaRg4cCB69OiBnTt3YsqUKRg3bhyWLVtmbpOamophw4ZhxIgR2L17N0aMGIGhQ4daiV4t223evDneffdd/PHHH9i4cSMaNWqEvn374syZM7r2kRBvIgVmIGTVAJjLmRBfIYXz5cuWZfasGpGRlii0J1YNadPo0gWoX9/6vRUrRAq6GTPEwMC5c0VfatQABgwQbf73P33bI6TMUHQSHR2tHDp0yGb5n3/+qURHR+ta1w033KCMHj3aalnLli2VF154wW775557TmnZsqXVsieeeEK58cYbzX8PHTpU6d+/v1Wbfv36Kffdd5/b21UURcnNzVUAKGvXrnW+U3Y+k5ubq/kz/sTffyuK+OoT88T/+P138f+pX9/XPdHG99+L/iYlOW83bJho9+abZdMvQso7XbuKa+rtty3f64sXK8r//mf5G1CUmBjLZxISLMt79tS3vR497F/DGzcqSlSUeK9GDcv6W7VSlNWrFeWLL8TfCQmKUlLi6V4Tog09ek13AZT69evbtUe89957qF/6ttIJBQUF2L59O/r27Wu1vG/fvti8ebPdz6Smptq079evH7Zt24bCayMeHLWR63RnuwUFBXj//fcRExOD6667zuE+5efnc7AkKVNkZNZVURF/gRFnQnyDjDhfumRZZi/iLDNqAO5bNRzZNPbvB+64Q/isb79dXN/vvSfGNRw4APTrJ2walSoBaWlAaqr2bRJSVugWzm+99Rbmz5+PNm3aYNSoURg1ahTatGmD+fPn46233tK8nuzsbBQXFyMuLs5qeVxcHE6dOmX3M6dOnbLbvqioyFygxVEbuU492/3hhx9QqVIlREVF4a233kJKSgpiY2Md7tPs2bMRExNjfum5kSDEHdRFRU6f9nVvXCOF899/2x/NL6FwJsRYpHBWVxm153GWAwMB960a9mwaJ04A/fuLlHg33ggsXSq29fjjwOHDIo8zAMyZA3TqJOY//1z7NgkpK3QL54EDB+Lw4cO46667cPbsWeTk5OCuu+7CoUOHMHDgQN0dKJ2tQ1EUpxk87LUvvVzLOrW06dWrF3bt2oXNmzejf//+GDp0KE47USeTJ09Gbm6u+ZWRkeGwLSFGEB4uxDMQGCKzZk0xOr+kxLnQp3AmxFjsCWdHHmeJuxHnH38UUxltvnRJeJczMoAWLYAffgAqVLC0r1oVSE4GnnpK/L19u5h++aV1+jxC/AG3agHVq1cPL7/8skcbjo2NRWhoqE2U9/Tp0zbRYEnt2rXttg8LC0ONGjWctpHr1LPdihUromnTpmjatCluvPFGNGvWDIsWLcLkyZPt9i8yMhKR6m8dQsqAunWBU6fE49GkJF/3xjmhoUDt2kIQnzxpiUCXhsKZEGORwvniRcuy/HzrEtyAY6uGnnR0e/eKadeuYvrVV2JZ7drAqlViEKA9Xn8d2LxZCOfwcJFxIyUFcCMmR4jX0B1xNoqIiAgkJSUhJSXFanlKSgq6yqutFF26dLFpv2bNGnTs2BHh165wR23kOt3ZrkRRFOSzIgPxMwJNZOopgpKZaV0SmBDiHrJ6oHrozdWrxls1cnMt30WtWonp2rViOnKk87zskZHCwlGliiXSTLsG8Td8JpwBYNKkSfjggw+wePFiHDhwABMnTkR6ejpGjx4NQFgfHnzwQXP70aNH4/jx45g0aRIOHDiAxYsXY9GiRXhGlSl9/PjxWLNmDebMmYODBw9izpw5WLt2LSZMmKB5u5cuXcKUKVPw+++/4/jx49ixYwdGjRqFEydO4N577y2bg0OIRsqjcJZt8vOBs2e93ydCyjsy4pyba1mWn2+8VePgQTGtUweIiRE3vj//LJbdeqvrzzdpAixaZPl72TLrAY2E+Bq3rBpGMWzYMOTk5GDmzJnIyspCmzZtsHLlSjRs2BAAkJWVZZVbOSEhAStXrsTEiRMxb948xMfHY+7cubjnnnvMbbp27YolS5Zg2rRpmD59Opo0aYKlS5eic+fOmrcbGhqKgwcP4uOPP0Z2djZq1KiBTp06YcOGDWjdunUZHR1CtFEehXNkpBhpn50tBhU5erRLCNFG1apiqo442xPOaquGWixrtWocOCCmiYliun+/sJJFR4vBgloYMgR48klg3jzRx6+/Bh56SNtnCfE2PhXOADBmzBiMGTPG7nsfffSRzbKePXtix44dTtc5ZMgQDLFXqkjjdqOiovDNN984/Twh/kJ5LLsNAAkJQjj/9RfgJAskIUQDcjCeunKgNyLOsuJfaZvGTTdZr9sV//kPsGQJkJMDvPoqhTPxH9yyahQVFWHt2rV47733cPHaSIOTJ08iTz1clxBSJpTHiDMgRt8DwJ9/erc/hAQD0dFieuWKJXrsDeFcOuIshbMWm0bpfkyZIuYPHuT3APEfdAvn48ePo23btrjrrrvw5JNPmktQv/baa1ZeY0JI2VBey25TOBNiHOqIsxTOBQXarRruRJwLC4F168TfeoUzIHI7y6wf//yn/s8T4g10C+fx48ejY8eOOHfuHKLlLSyAwYMH42c5AoAQUmZI4XzuHHD5sm/7ogW9wvnQIe/2h5BgQP5cX74MhFz75S8oAIqLrds5ijhr8ThfuSIq/gFCOG/dKvJGx8YC7drp73NoKDB4sJj/9VdRVZAQX6NbOG/cuBHTpk1DRKnkjw0bNkRmoDwrJqQcERMj0jcBwPHjvu2LFqRwPnNG/HA7Qh1xZko6QjyjLKwahw6Ja7V6daBWLYtNo3dvi1jXi3oo0rPPurcOQoxE96lcUlKC4tK3qABOnDiBypUrG9IpQoh2TCagcWMxf+SIb/uihRo1LD/IpeoQWdGsmdi3c+fEIEFCiPtI4Xz1qkXE2qsc6IlVQ23TMJnc9zer6dbNklVn7VpREIUQX6JbOPfp0wfJycnmv00mE/Ly8jBjxgy3Sm4TQjxHCuejR33bDy2YTNrsGtHRQIMGYp4+Z0I8Q+WsNIvgggLbktaeWDXUAwMvXgR+/1387YlwDg0F1OUTnn8eKClxf32EeIpu4fzWW29h/fr1SExMxNWrVzF8+HA0atQImZmZmDNnjjf6SAhxQSAJZ0B7Cj0OECTEGNTCWT04UKtw1hJxlsK5VSvgt99ENLtxY5Fa0hNkqQaTCdi5E/jyS8/WR4gn6BbO8fHx2LVrF5599lk88cQTaN++PV599VXs3LkTtWrV8kYfCSEuaNJETANFONevL6aq+kZ2oXAmxBjCwixCWG3VKD3OwAirRmKiMTYNSc+ewjctxzrMm+f5OglxF93C+bfffkN4eDgeeeQRvPvuu5g/fz5GjRqF8PBw/Pbbb97oIyHEBYHkcQaARo3E9Ngx5+0onAkxDhl1lsK5qMhWOLsbcS4sBA4fFvOtWukrs+2K8HBg0CAxbzIBGzdaotuElDW6hXOvXr1w9uxZm+W5ubno1auXIZ0ihOhDbdUIhAwU8tGtTF3lCApnQoxDCme1VcOZcNZTcvvIESGeK1YUQvePP4TINUoWSLuGTOj1wQfGrJcQvegWzoqiwGQy2SzPyclBxYoVDekUIUQfDRuKKNLVq84zVfgLMuKsVTjLH2VCiPuUjjgXFtpeV2qrhp6Is9rf/OuvYr59e5HD2QhuuUWk3czPF39//LFlnpCyRGMtIODuu+8GILJoPPzww4hU3ZYWFxdjz5496Nq1q/E9JIS4JDxcZKA4dkyIzDp1fN0j58iI87FjIkJu514cgCjuEh1tKazQvHmZdZGQcoesHqi2ahg1OFAtnI30N6v7dccdwOefA5UqATk5wLffAkOHGrcNQrSgOeIcExODmJgYKIqCypUrm/+OiYlB7dq18fjjj+Ozzz7zZl8JIU4IpMwaDRuKaV6e+AF0REiIRSzTrkGIZzjzOMubV3etGuqBgdu2ifkePTzrb2nuvFNMZR//+19j10+IFjRHnD/88EMAQKNGjfDMM8/QlkGIn9G4MfDLL4EhnKOiRFQ8K0tEnZ09zm3RAti9WwjnO+4osy4SUu6wJ5yNtmo0b265yW3Txv2+2qNvXyHgc3IsBVaOHrUEDQgpC3R7nGfMmEHRTIgfEmgp6fT6nBlxJsQzpHCW0eWiIkvlQHsRZ63CuaTEIpyjo0UUu0IFSwEjo6haVVQSBCzfC4sWGbsNQlyhOeKs5uuvv8aXX36J9PR0FJQakrtjxw5DOkYI0UegpaRLSABSU7WnpDt0yOtdIqRcoyXi7Miq4Uw4p6eLcQgREcJ+BQjLRoju0JxrBg4UxVXkvnz4IfDSS9ryTBNiBLpP67lz5+KRRx5BrVq1sHPnTtxwww2oUaMGjh49igEDBnijj4QQDQSSxxlgSjpCyho5OFBSXGyJOEscWTWceZzVNo2DB8V869bu99MZt90mpvv3C4tXVhawcqV3tkWIPXQL5/nz5+P999/Hu+++i4iICDz33HNISUnBuHHjkJub640+EkI0IK0ap04Bly/7ti9a0GrVkIMD//4b4FcMIe5jz6phRFYN9cDAffss896gdWtReTQ/H7jpJrGMgwRJWaJbOKenp5vTzkVHR+PixYsAgBEjRuCLL74wtneEEM1UqyY8gEBgRJ3VKemcUaWKJb0eo86EuI8UzhJ7EWd3rBrqVHRSRHsr4mwyCbsGYOnrqlW8qSZlh27hXLt2beRcyx/VsGFD/P777wCAtLQ0KIFQsoyQckwg2TXUZbddfXXQrkGI55SOOKuFs7wGPbVqyGvUW8IZsNg1UlOBli3FPqxe7b3tEaJGt3Du3bs3vv/+ewDAyJEjMXHiRPTp0wfDhg3D4MGDDe8gIUQ7gSSc69e3VDv8+2/nbSmcCfEcKZylSLYnnPVGnBXFEmWuVMl7GTXU9O4t+nnsGNCli1h2TZYQ4nV0j0N9//33UVJSAgAYPXo0qlevjo0bN+KOO+7A6NGjDe8gIUQ7gZSSLiJCVAbMyBA+59q1HbelcCbEc+TgQCmSS0qcWzW0eJz//hs4f17cBMuxFd7KqCGpWBG4+WYRZZYR8pUrxY2Aq0IthHiK7lM7JCQEYaoraOjQoZg7dy7GjRuHiIgIQztHCNFHIKakA7SnpKNwJsR97EWci4ut2+gtgPLXX2LasCFw+LCY96ZNQyJ9zvv3i/EdZ88K6wYh3satzIdXr17Fnj17cPr0aXP0WXKnrIlJCClzAsmqAQif82+/aU9Jd/iwiJJ5M5pFSHlFCmf5s11SYiuc9ZbcltduQoL3M2qoGTgQGD8e2LQJGDwY+Oor4IcfgO7dvb9tEtzoFs6rVq3Cgw8+iOzsbJv3TCYTiktfhYSQMkNaNdLSAkNgao04N2wool9Xr4piC3JgISFEO/aEs9qqYTJZi2UtEWe1cN6yRcyXRcS5aVMxGPHQIWH5AoTP+dVXvb9tEtzo/lkdO3Ys7r33XmRlZaGkpMTqRdFMiG+pX19EhvLzRWEAf0drEZSwMPFDCdCuQYi7lBbOgLVwjoqyZNwA9AnnBg3KJqOGGpld4/Rp8b23f3/gPG0jgYtu4Xz69GlMmjQJcXFx3ugPIcQDwsJEdBYIDJ+z1iIoAH3OhHiKHByojnEVFFjm1TYNQJ9Vo0IFUUylYkXvZtRQI33OP/9ssWj88EPZbJsEL7qF85AhQ7Bu3TovdIUQYgSB5HOWEef0dFuvZWkonAnxDBlxVkeZ1ZUDSwtnPRFnKcBbtSo7i1iPHkKw//030KGDWEbhTLyNbo/zu+++i3vvvRcbNmxA27ZtEa6+sgCMGzfOsM4RQvTTpAmwdm1gCOe6dcUPcmEhcPKksJo4Qg442ru3bPpGSHnDlXBWZ9QAXAvnwkLgxAkxf/68mJaVTQMQQr93byGWpVhftw64cEFUHCXEG+gWzv/73/+wevVqREdHY926dTCpDFEmk4nCmRAfE0gp6UJDxWPdo0fFAEFnwvm668R0926RTkvtxSSEuMaecFb7nZ1ZNewJ5/R08fnoaDEPlK1wBoB+/YRw3rEDaNZMZN5JSQHuuads+0GCB90PVKZNm4aZM2ciNzcXx44dQ1pamvl1NBBCXISUcwLJqgFo9zm3aiUiYLm5wPHjXu8WIeUOKZzVvmY1zqwa9jzO8ppt1KhsU9Gp6ddPTDduBPr2FfOsIki8iW7hXFBQgGHDhiHE3/NcERKkBFL1QEB7SrqICMuP8u7dXu0SIeUSOThQbc9QU9qq4SriLIVzw4Zln1FD0rSpCBYUFgJ16ohlsoogId5At/p96KGHsHTpUm/0hRBiADLifPo0kJfn275oQU9mDbVdgxCiDxlxdiSc9Q4OlNds9epln1FDYjJZos4ZGUBMDHDmDLB1a9n2gwQPuj3OxcXFeO2117B69Wq0a9fOZnDgm2++aVjnCCH6iYkRP2Rnz4qoc7t2vu6Rc7TmcgYonAnxBCmcHeGuVUOK6rLMqKGmf39gwQIxKHrAAGDJEmDFCqBLl7LvCyn/6D7F//jjD7Rv3x4hISHYu3cvdu7caX7t2rXLC10khOglkHzOWq0aAIUzIZ7gSji7a9XIzxfTsrZpSHr1Ev07csQilr/5RgwiJsRodEecf/31V2/0gxBiIE2aANu2BUZmDWnVyMgQj3tLPcSyQgrnI0eAixeBypW93j1Cyg0hIWKsgDuDA+0JZ3mze+6cmPpKOFeuLAqgrFsnvkMiI4G//hIDFtu08U2fSPmFI/wIKYfIYiFypLs/U7u2+KErKbHkhHVEbCwQHy/m//jD+30jpLwhBwjaQ49wvnxZFB4BxE0vUPYZNdRIn/P69UCfPmL+m2981x9SftEUcb777rvx0UcfoUqVKrj77rudtv2GZyohPuf668U0ENxTISFiVP6hQ+LRr7RuOOK660SxlF27gK5dy6SLhJQboqMtxUpK48yqUdrjLKPNVaqI6C7gu4gzIITz5MnAL78Ab70lcjt/8w3wr3/5rk+kfKIp4hwTE2MudBITE+P0RQjxPdLSsG+f4xH0/oQen7O8KaDPmRD9OPM5l444R0aKpzyVKtnaoqS/OT7edxk11Fx3HRAXB1y6BNSsKYT+7t2BMc6DBBaaIs4ffvih3XlCiH/SqJGIBF24ABw8CLRt6+seOYcp6QgpG/QI55AQUViksNA2Gi2v1apVxbR5c99k1JCEhIgCKJ9+Cvz+O9Czp4g+L18OPP207/pFyh+6T/N9TkyTq1at8qgzhBBjCAmxpKELBLuGOynp/viDRQ4I0Yse4QyI8RL2BtjJazUiQkybNfO8b57Sv7+YrloFDB4s5ukeJUajWzh37NgR77zzjtWy/Px8jB07FoPlmUoI8TmBZGmQEWctj1WbNRM//pcvB0bWEEL8CWeDA0tHlZ0hhbO8eW3e3P0+GUWfPqIgyu7dlrR0qalAVpZv+0XKF7qF8+eff46XXnoJAwYMwKlTp7Br1y60b98ev/zyCzZt2uSNPhJC3CCQBgi2aiWm+/a5zr0aGmqJgAXCTQEh/oTeiLMjpHC+eFFM/SHiXLMmkJQk5vfsATp3Ft8n337r236R8oVu4Xz33Xdjz549KCoqQps2bdClSxfcfPPN2L59Ozp06OCNPhJC3EDtBfb3QgAtW4oR/BcuAOnprtvT50yIexgtnE+fFlN/iDgDwMCBYvrDD7RrEO/glpW/uLgYBQUFKC4uRnFxMWrXro1IPVccIcTrtG4torPZ2SJ9mz8TEWGJOmvJzyyFcyBE0wnxJ5wJZ61WjXPngNxcMX/qlJj6Q8QZAO64Q0zXrAFuu03M//qrpUgLIZ6iWzgvWbIE7dq1Q0xMDA4dOoQff/wR77//Pnr06IGjzPtCiN8QHW0phBIIkVk5mHHPHtdtA8m/TYg/YUTEWUabq1cX02rVgBo1POuXUXToANSpA+TlAZmZwtZVVCQi0IQYgW7hPHLkSLzyyiv47rvvULNmTfTp0wd79uxB3bp1cb38NdPB/PnzkZCQgKioKCQlJWHDhg1O269fvx5JSUmIiopC48aNsXDhQps2y5YtQ2JiIiIjI5GYmIjly5fr2m5hYSGef/55tG3bFhUrVkR8fDwefPBBnPT3sB0hpQgkn7NMmadFOEuRfeIEcPas9/pESHlDT+VAR0jhLMWyv9g0AJFR6Pbbxfz33wOyZtuyZb7rEylf6BbOO3bswD//+U+rZdWrV8eXX36JefPm6VrX0qVLMWHCBEydOhU7d+5Ejx49MGDAAKQ7MDmmpaVh4MCB6NGjB3bu3IkpU6Zg3LhxWKa6IlJTUzFs2DCMGDECu3fvxogRIzB06FBs2bJF83YvX76MHTt2YPr06dixYwe++eYbHDp0CHfeeaeu/SPE1wSSpUFPxLlKFUsKO0adCdGOEVYNKZzluvzFpiGRdo3vvweGDBHzK1cK2xohHqO4ybZt25RPP/1U+eyzz5Tt27e7tY4bbrhBGT16tNWyli1bKi+88ILd9s8995zSsmVLq2VPPPGEcuONN5r/Hjp0qNK/f3+rNv369VPuu+8+t7erKIqydetWBYBy/Phx5zulIjc3VwGg5Obmav6MP/H334oihpWJeRJ4rF4t/n/Nm/u6J645cUL0NTRUUa5ccd1+0CDR/q23vN41QsoN//qX5Xu99Ovbb7WtY8wY0b5tWzGdOdO7fdbLpUuKEhUl+rZ7t6J06CDm337b1z0j/ooevaY74nz69Gn07t0bnTp1wrhx4zB27Fh07NgRt9xyC86cOaN5PQUFBdi+fTv69u1rtbxv377YvHmz3c+kpqbatO/Xrx+2bduGwmt1hR21ket0Z7sAkJubC5PJhKqyTJId8vPzceHCBasXIb5ERpwPHxalaP2Z+HjhmSwuBg4ccN2emTUI0Y+MEptMtu/ptWpcviym/hZxrlABuPVWMf/998Ajj4j5jz7yWZdIOUK3cH7qqadw4cIF7Nu3D2fPnsW5c+ewd+9eXLhwAePGjdO8nuzsbBQXFyMuLs5qeVxcHE7JYbqlOHXqlN32RUVFyL72DMZRG7lOd7Z79epVvPDCCxg+fDiqVKnicJ9mz56NmJgY86t+/foO2xJSFsTFAbVri3iSlmwVvsRk0udzpnAmRD/OhLNeq0ZOjpj6k8dZorZr3H+/yNyzcye/L4jn6BbOq1atwoIFC9BK5o4CkJiYiHnz5uGnn37S3QFTqatXURSbZa7al16uZZ1at1tYWIj77rsPJSUlmD9/vpM9ASZPnozc3FzzKyMjw2l7QsqC8upzlvu1bx9QUOC9PhFSnvB0cKCiAMeOifnz58XU3yLOgGWA4NatIquGHKL04Ye+6xMpH+gWziUlJQgPD7dZHh4ejpKSEs3riY2NRWhoqE2U9/Tp0zbRYEnt2rXttg8LC0ONa8N7HbWR69Sz3cLCQgwdOhRpaWlISUlxGm0GgMjISFSpUsXqRYivCaTUbVI4a4mOJySIUf0FBcC2bd7tFyHlBU/T0Z06BVy9aolY164NVK5sTN+MJD4e6NhRCP0ff7TYNT7/nDfaxDN0C+fevXtj/PjxVqnZMjMzMXHiRNxyyy2a1xMREYGkpCSkpKRYLU9JSUHXrl3tfqZLly427desWYOOHTuaxbyjNnKdWrcrRfPhw4exdu1aszAnJNAIpJR0eiLOJhPQq5eY//ln7/WJkPKEp1aN0jmc/THaLFHbNfr2Ffmds7OFkCbEbfSOPExPT1fat2+vhIeHK40bN1aaNGmihIeHKx06dFAyMjJ0rWvJkiVKeHi4smjRImX//v3KhAkTlIoVKyrHjh1TFEVRXnjhBWXEiBHm9kePHlUqVKigTJw4Udm/f7+yaNEiJTw8XPn666/NbTZt2qSEhoYqr776qnLgwAHl1VdfVcLCwpTff/9d83YLCwuVO++8U6lXr56ya9cuJSsry/zKz8/XvH/MqkH8gf37xf+wQgVFKSrydW+ck5enKCaT9nNuwQLRtmdPr3eNkHLBjz9asteUzqpx5Ijrz3/2mWjbsKGYjhzp9S67zY4dlu++K1cU5bnnxN933unrnhF/Q49eczsd3Zo1a5S5c+cqb7/9tpKSkuLuapR58+YpDRs2VCIiIpQOHToo69evN7/30EMPKT1L/SKuW7dOad++vRIREaE0atRIWbBggc06v/rqK6VFixZKeHi40rJlS2XZsmW6tpuWlqYAsPv69ddfNe8bhTPxB4qKFCU6Wvwf//zT171xTdOmoq9r17pue+iQaBsRIVJQEUKc88svjoXziROuPz9rlmjbuLGYvvqq9/vsLiUlilKvnujnypWWIEJoqKKcOuXr3hF/Qo9eMynKtdF1GigqKkJUVBR27dqFNm3aGB/+LmdcuHABMTExyM3NDUi/8+nTIisDAPz9N1Crlm/7Q9znhhuA//s/YOlSYOhQX/fGOffcA3zzDfDmm8DEic7bKgrQoIGoILhmDdCnT9n0kZBAZcsW4MYbRYW90sOSsrNdl84eNQpYtEh4iE+eFBX5ZHU+f+Sf/wQWLhTT+fPFvm/ZAvznP8CkSb7uHfEX9Og1XR7nsLAwNGzYEMXFxR51kBBStgTiAEGtPmc5tII+Z0Jc4+ngQOlxlhk1/DEVnRqZTWPFCpEj/uGHxd8ffihuvAnRi+7BgdOmTcPkyZNx9uxZb/SHEOIFAiklnZ5czgCFMyF6kMLZnmjUIpxlKjpZ/KRJE0O65TVuuQWoWhXIygI2bgTuu0/s5969wA8/+Lp3JBDRLZznzp2LDRs2ID4+Hi1atECHDh2sXoQQ/0NGnHfs8P8oi4w4798v8q+6QgrnHTuAc+e81y9CygOOhHNICBAW5vyzxcVAerrl7wYNnEew/YGICGDwYDG/dKkQ0WPHir9HjhQ2REL04OIysWXQoEFe6AYhxJt06CBSTZ06JQRp69a+7pFjGjcWRRouXwb++gto2dJ5+/h40ebgQWD9eoBfUYQ4xpHQjYy0n6JOTWamuJkNDRUi2p9T0akZNkxYM5YtA+bOBWbNAlJSxFOtRx4R6elc7TshEt3CecaMGd7oByHEi0RHAz17AqtXi5c/C+eQEKBNG1Hxa88e18IZAHr3FsL5558pnAlxhqPKgXr8zVWqiKc7/u5vlvTuLQY9nj4tbq5vuQX43/9EgZSffgLmzbNEoQlxhW6rhmTbtm349NNP8dlnn2H79u1G9okQ4gX69RPTVat82w8t6KkgCNDnTIhWHBU50VL8RPqbZfHgQIk4h4dbMn8sXSqmrVsDr78u5p95Bti3zzd9I4GHbuF84sQJ9OjRAzfccAPGjx+PcePGoVOnTujevTsyMjK80UdCiAH07y+mv/1mGdjjr+jJrAEAN98sHrUeOCAGARHiC7KyLNkm/BWTyb5I1hNxlmMPAiXiDAi7BiDsGoWFYv7JJ4GBA4H8fGD4cFFKnBBX6BbOjz76KAoLC3HgwAGcPXsWZ8+exYEDB6AoCkaOHOmNPhJCDKBlS6B+ffEjsX69r3vjHL3CuXp14eMGgF9+8U6fCHHGsmVAo0ZAvXrAtGn+LaDt+Zz1ZNS4eFFMAyXiDAirWs2awNmzlu8IkwlYvFgs37MHGDECuHLFt/0k/o9u4bxhwwYsWLAALVq0MC9r0aIF3nnnHWzYsMHQzhFCjMNkskSdV6/2bV9cIVPSHTsGXLig7TO9e4sp7RqkrFm8WBQWKigALl0CXn4ZSEgQ0/PnhQ3g88+BZ58V12DPnuJ87dNH/D12rPhsWWFPOGuxasiIc2GhGCCYkGBsv7xJWBgwZIiYl3YNQBT5+vhj8f7XXwM33SQGQRLiCN3CuUGDBiiUzzlUFBUVoW7duoZ0ihDiHaTP2d+Fc/XqInIHADt3avuM2ufs7yn3SPnhzTdFWrOSElFVb9ky4Z89f15EnqtVE4Nd//EP4I03xLX322/Ar78Ca9eKv+fNA774ouz6bG+AoJ6IMyBEs/Q6BwrSrrF8ufWNyoAB4n9RowawbRvQqZMYnEyIPXQL59deew1PPfUUtm3bBlmte9u2bRg/fjzeeOMNwztICDGOW24RkaKDB4Hjx33dG+d07Sqmv/2mrX337uKHPD0dOHrUe/0iBBA3Z9OnA08/Lf5+9lng/ffFILTdu0WEuWlT8V6lSkC3bsJT+/77IuL5v/8Bn34q0qEBQjyXFe5YNQoLRWl7SSDZNCTduwO1a4ubmpQU6/d69hRiuXVr4VW/6SZgwQIgN9cnXSV+jElR9MVmqlWrhsuXL6OoqAhh17Kly/mKFStatQ326oJ6ap/7I6dPi8dYgEgSX6uWb/tDjKF7d2DTJuC994DHH/d1bxyzYAEwZox4pK3VftGzpxDaCxYAo0d7t38k+Dh9Wvhj164V56SMwL7yCvDCC7a5gIuLxXdn7doizaI9zpwRT1cKCoAtW4AbbvDqLgAAOne2jajeequtmFRz9KioEihzOI8fDyQne7WbXmHcOOCdd4Sf+ZNPbN+/cAF44AFLVcGwMKBHD+D224G+fUUqPjWxsY5T/JHAQY9e053HOTkQrxRCiJl+/YRwXrXKv4Vzz55impoqREVEhOvP3HabEM4ffkjhTIyjqAi4/37hgVUTGQm89Rbwz3/a/1xoqCjQ44yaNYWF4NNPRdS5LISzOxFn6W+OihI+7kDKqKFm2DAhnP+/vTuPi6r8/gD+GYZFAUEQBUlRNBX3BVJxL03ctxaX3LJcKhc0cynNzN3McjfLr7Yp/lI0KzNxF6U0BDU1VxQXkEwFBQGB5/fH6XJnZJv9zgzn/XrNay7DnXufuQwz5z73POfZsYOqaDyd2+3hQb9bsgTYuJGuzh04QLfCqFR0ZaFhQ7qFhFDeekmzMDLbpXePM9Md9zgza3TiBH05e3gAd+9ab56iEPT+++cfIDqaLnWXJCWFeu+ePKHXGRJi/nYy+7d8OfWwAkDjxpTy1LEjXc53dzd++3/8AbRsScHrjRsUTJtT164F67n360f52UVZv55yuKVZPffulccV2JK8PKp+cuMGsHYtMHp08etfuUIzC/78M53ES6X4APqMysoq+Jzq1Sl15/XXrX9Kckb0idcMmgAlNzcXW7duxZw5czB37lxs27YNOZrvJsaY1WrWjAbBpKXRF7a1UqkoMAF0L59XqRLwyiu0vGaNedrFSpfbt4EPPqDlwECgbl26+nHzJhAbS4GYsZo3p5O8rCwKUM2tsNSCkqpqSD3OUrk2jcJaNsXBQc5Lnzu35NrNNWtSeseePVSG7/Fj+ZaZCSQnU4rL0qXA8OF00nPtGuWzV68OLFhAvdaFBdjMNukdOP/111+oXbs2hg0bhu3btyMyMhLDhg1DrVq1cEbXab4YY4pRq6kMFmD9swh26ED3Bw/q/py336b7TZtoWmDGjPHuu8CjR7SckABERAALF1JPZYcOQK9eupdMLIpKRYEWQCd8ubnGba8khqRqSPncQgBuboAtF9EaPZraf/Mm8OWXxm3L15fywydOpBSx69eBlSuBatXoCtj779PJVtmyVEe/Qwdg0iQ6IWO2Se/A+c0330T9+vVx8+ZNnDx5EidPnsSNGzfQqFEjjLLmhEnGWD5bqecs5TkfOybP9lWSVq1oApXMTMpRZMxQUVEUKEsWLKDc17FjKZ++TBm6jN+yJXD5snH76t+fyjAmJsoD08zFmBxngPKbnx4IaUvKlJGvIsyfb9pJT8qWpZOgS5do8GHLlpTOIwQF6ocOUV587drAnDnWP4srK0jvwPnUqVNYsGABvLy88h/z8vLCvHnzEB8fb8q2McbMpHNnuo+NpRxia1W/PgUT6enUVl2oVHKv85o1prmUzkqfzEy5VBxAQc60adQDvWIFBbfR0dRzef48pVsYM/lO2bKUQwyYvzSdIROgaNZwttU0DU1vvEG9wsnJ5knrcnKiyh0xMXRF4s4d6gCQgun0dODDD+lYfvcdf07ZEr0D5zp16uDOnTsFHk9JScGzUtFKxphVq1yZBjkJYd29zg4Ocq+zPtOEv/YaUK4c9frwTILMEFOnyjPIvfyy3EOpKTiYBqG2aEFpQWFhlOc6aRLVeF64kMo+/v67br2aY8bQiV9UFHDhgklfjhZ9e5wzM7VTC+whcHZ2pr8RQH8nKR3HHFQqGn8RGkrB9LFjNOFNQAD1Qg8ZQsF0dLT52sBMR+/Aef78+Rg/fjy2bt2Kmzdv4ubNm9i6dSvCw8OxaNEipKWl5d8YY9are3e6/+knZdtREilw1ifP2d0dGDaMllevNnmTmJ2Lj6deZYAGh33zTdGpCZUr03tzyBDKTf76a7oUP3cuMH06BcOhoXQi16gRMGIE9UIWJjCQ6gUDFHCbi74zByYm0r1Ui9oeAmcAGDqU/r7//EN5yZaiUgEDBtCgwfnz6fPqxAmqF/3yy1TJg1kvvcvROWhUcVf990kibULzZ5VKhVxzj3CwclyOjlkzqQRWuXJUlk6XOslKiI8HmjalL5f793Wvj3ruHKV6ODjQZeaqVc3ZSmZPWrak/w8XF5r4o6RazABdvdm+HfjrL7oMn55O+atJScDJk/R5KnFyAr76igK3p+3cCfTuTWUVExPNk0u8eDH1qGuaP58C/cL89huNi5AmP4mNpeo89uDbb+nv4O1NedxKfFXfuUNpG199RSkbTk501eLjj633c9nemHUClANFVQFnjNmU556jGc2Sk6nHTMp7tjYNGwLly9M0uXFx1G5d1KtHI9gPHqRpjufMMV8bmf148gT4809aHjtWt6AZoAC3Xz+6PU0ISvuIjaUBqzt20BWRa9coXUAzOO7cmapW3LxJ7dD1/a4PfVM1pPxmqS/MVic/KcygQXTS8PffNPhzwQLLt8HXl64wjBtHOfR79gCLFgFHjgA//KD7e5BZht6pGu3bty/y5unpqfUzY8x6OTgAPXvS8s6dyralOGq1/vWcJdIgwS++oB5AxkqyfDkFiCqVnANrLJWKepB796ZJRqTe3lmzaABidra8bpkychpVZKRp9v80fQNnzYoazzxjmklfrIVaTYEzQMGqkiU6GzSg3v3ISMDTk3KhmzXT/3OPmZdBE6BoSk1NxerVq9GsWTMEBwebok2MMQvp1Yvud+6kXjFrZUieMwD06QPUqGH5HEZmu6QKC3XqUPBiag4ONBht7VoK2r7+mmby0xycJvVab9tmnv9Lfatq2FtFjaf17Uu56EJQD7Tm61WqPX/+SVfb7tyhGRqXLrXuz+jSxODAef/+/Rg8eDAqV66MFStWoFu3bvhTur7FGLMJHTvSQKEbN4BTp5RuTdGkwPnIEf0mh3Byol49gHqTUlNN3zZmP5KS5IFZY8ead1+jR9PAXHd3YP9+6mWWrop060a5rZcuUa6+qek7OFCzx9keA2cA+PxzKil4/z7w0kslzyhobs8+S4NIBw2iz7x33wU+/VTZNjGiV+B88+ZNzJ07FzVq1MDAgQPh5eWFJ0+eYNu2bZg7dy6aNm1qrnYyxsygbFk5t9ma0zWaNKFBO2lp+gf4r70GBAXRF+Lnn5ujdcxeSHnwajUwcqT599e1KwXNHh7A4cNUUSM9nQbsSv+X5kjXMDTHGbDfwNnFBdi6FfDxocGc5j5x0oWbG9V4lvKuZ82imQmZsnQOnLt164Z69erh3LlzWLFiBW7fvo0VUr0expjNktI1fvxR2XYUR62mUk2A/vl+ajUwezYtL10K3Ltn2rYx+yCEPEtgixaWq2bw3HM0GKxcOUpF6tmTqnFI6RqWCpyLStVIT9euCGKvgTNAlXc2b6Z0mvXrqcqF0lQqyolv25beF+HhSreI6Rw479mzB2+++SZmz56N7t27Q61Wm7NdjDEL6d6dPpxPnqSR/NaqQwe6N2TClpdfphq6aWk0ZTJjTztyhK5KAHRZ3JJatKBBae7uwIEDNIiwUyc66YuPp5J4pqRPj/PTPZz2HDgDdNylKw+jRgETJ5p3chRdqFRUj97RkSqymHtKdlY8nQPnI0eO4OHDhwgJCUGLFi2wcuVK/GPNc/UyxnQizWgFWPdkKFIFkP379c9VdnCQvwyXLdPuQWMMkC+Hu7jI7zVLatWKgmc3N2DvXkorkqrJbN9u2n3pEzhr5je7uNBsd/Zu2jRK1RGC/g4NGihbbQOgNkycSMvjxlHvM1OGzoFzaGgovvzySyQlJWH06NGIiIjAM888g7y8PERFReHhw4fmbCdjzIx696Z7a85zrlMHqFuX6uz+8ov+z+/Zky6LZ2RQVQPGJA8fUrAKUG6xk5My7WjdmlIEAErR6NtXXjalwgYHFpWqoZnfXKsW9YLbOwcHqv2+ezdQrRr1unftSrNDKnnS/eGHVNbw2jVl6k0zondVDVdXV4wYMQLR0dE4c+YM3n33XSxcuBCVKlVCLylZkjFmU6R/3f37KYiwVlIgYUgPnEpF0yADdNnz1i3TtYvZtk2bgJwcWh43Ttm29OhB+dXXrlE5MoDq+SYlmW4fhvY423uaxtPCwmgmyIkTKZj+7js6efj0U+3a25bi7k5XzACa/fHCBcu3gRlZx7lOnTpYvHgxbt68ic2bN5uqTYwxC6tTh74QsrMNyyG2FClw/vVX4PFj/Z//4os0yCYri754GAPkYMTNDXj+eWXb4uYmp2jEx1P+M2Dawbv6BM6loaJGcdzdaVBxTAwQHEzjJCZPppOaXbss356+fan3OzubesC5A8DyjJ4ABQDUajX69OmDndZ8nZcxViSVSu513rFD0aYUKziYRr6npwNRUfo/X6Wiy50AXYq9c8e07WO25/x5ugFUv9fRUdn2AECXLnS/e7d5qmvoU1WjNPc4a2reHDh+nFJpKlUCLl6kgdU9ewKJiZZrh0oFrFhBAf2JExTAb9liuf0zEwXOjDHb99JLdL9tG3D3rrJtKYpKZVy6BkCTvrRoQRMcLF1qurYx27Rhg7w8fLhizdDStSvdHzokLxsyKLYoLi70v/T0Y4Up7T3OmhwcgBEjaGKayZMpF/7nn4F69eiqhT6TMxmjZk0KmkNCqBLMgAFUr16qCsPMiwNnxhgAoGVL6tHNzKTpgK2VFDjv3CnnpepDpQJmzKDl1auBf/81XduYbcnJAf73P1p2c5NrhSutbl26spKZSZfia9akoOzYMdNsX6Uq2MNcWOB8/7523fPSHjhLPDyATz6hyZjatKErYOHhVBnl9GnLtCEoiN4PH35IAzY3baKSmydOWGb/pRkHzowxAPRlOmkSLa9cqfyUs0Vp04Zm97p3j2ZbM0T37kDjxlSfdfly07aP2Y6oKPnEqXt360jTAOh/UTNdQwrojxwx3T6eTtcoLFVDSmEBKD2hfHnT7d8e1K1LVwXWrqVg+vhx6nxYvpxK2ZmbkxNN7hQdTVN037wJtG9v3ZNZ2QMOnBlj+V55hcod3blDM2hZI0dHOR/b0HQNzV7n5ctNdwmc2ZaNG+VlaysKZenAubAeZ83AmXubC+fgAIweTceqb1+6ijFhAqV0WKrzoWVLmsCqSxcaNN23rzzglZkeB86MsXxOTsD48bS8dKllek0MoZnnnJdn2Db69aMeowcPgFWrTNY0ZiPu3ZMHwmr28FqLjh3pEvyFC0D16vTY8eOmC8Y0A2eVqvDedg6cdefvT+NDli6lYHrjRur9tVTVi3LlaAKr0aPpczs8nD7LLZV3XZpw4MwY0zJyJOV7/vWXPCmEtenUiUaV37oF/PmnYdtwcADef5+Wly6lPEVWekREyLV4W7UCKlRQtj1P8/SkdgHA338Dfn7U3uPHTbN9zUlQnJ0LX4cDZ/2oVFTz+bffAG9vOXXDVLnpJXF0BNaskUttrlhBV1IePLDM/ksLDpwZY1rKlwfeeIOWrbXqRJkyQLdutGzMdMQDBtDAq3//te4Bkcz0NNM0evRQrBnFkipq/Pab6dM1NAPnomZK5MDZMJ06yaXi7twBXnjBcqlvKhXw3nvADz/Q5+SuXVRK79w5y+y/NODAmTFWwIQJ1CO7ezdw9qzSrSmc5nTEhqaUODoC06bR8qef0sQozP6dPatdfaB7d+XaUhwpfWTfPiA0lJZNFThrpmoUFjhnZHANZ2PUqEGTpvTtS58rgwbRzKWWSn97+WXg6FEgIIDK57VoYd01+m0JB86MsQJq1JAD088+U7YtRenWjXpULl6kWqqGGjoUeOYZmtL4m29M1z5mvTR7mwMCgAYNFGtKsRo3Bnx9KY3I3Z0eO3rUsDKMT9MMnAtL1dCcztnJCQgMNH6fpY2bG/X8vvsu/TxzJvD665abrrtZM0pl69CBKgj17UttMMX7pzTjwJkxViipNN2331JQaW08POSBjJMnA0+eGLYdZ2f5i23xYh5MY+9ycug9LenRo+BkINbCwQEIC6Plixcp7/nRI6ofbKySAmfNNI1atYpO52DFU6uBJUso91itBr7+mv6mlso7rlgR2LOHriIC1Ovdti29n5hhOHBmjBUqNJQGJ2Vn04etNfrgA/piuHiRvpgMNXIkDea5fJlGxjP7FRVFeacO/337WWuahkRK19izB2jdmpZNka6hT+Bct67x+yvtxowBfvmFql8cPAi0awfcvm2ZfTs5AZ9/Dnz/PXU4/P470KQJleI0tCpRacaBM2OsUCoVMH8+La9bR3ly1sbDA5gzh5Y/+kh7ljN9uLsD48bR8oIF1luGjxkvMpLu8/IoeHz+eWXbU5IXX6T/xdOngaZN6TFTBM6agwNLquFcr57x+2PU03zkCFVIOXOGOiY0U2LMbdAgqpbUqRPVe54wgZa591k/igfOq1evRmBgIMqUKYPg4GAcKeET4dChQwgODkaZMmVQo0YNrC1kKPy2bdtQr149uLi4oF69etheyLD7kvYbGRmJsLAw+Pj4QKVSIT4+3qjXyZgtat+ecolzcuQJQ6zNG29Qjur9+3IQbYhx4yiYiI+n3j1mf3Jzaap2SceOBScCsTY+PkDt2rTs7U33R44Yf3Kn+boLmxGQe5zNo3FjKk9XqxZw/TpdRTBViUFdVK1Kn2+rV9Pn3YEDdGL0+uvA1auWa4ctUzRw3rJlC8LDw/HBBx8gLi4Obdu2RdeuXZGYmFjo+gkJCejWrRvatm2LuLg4vP/++xg/fjy2aVxbjYmJQf/+/TFkyBCcOnUKQ4YMwauvvoo//vhDr/2mp6ejdevWWLhwofkOAGM2YMEC6vH6v/8zvGayOTk6ymXzVq40vPekQgVg1ChaXrDANG1j1iUmBkhJoVxTwHrL0D0tOJjuHz2iAbH//GN8T6Vm4KzZ+wzQibLm/xEHzqYVGEiDPENCqBTmCy8Av/5quf2rVMBbb1GufI8edEK5cSNVThk5Erh2zXJtsUlCQc2bNxdjxozReiwoKEhMmzat0PWnTJkigoKCtB4bPXq0aNmyZf7Pr776qujSpYvWOmFhYWLAgAEG7TchIUEAEHFxcTq9Jk2pqakCgEhNTdX7udbgzh0hqF+DllnpNWQIvQ9eeEGIvDylW1O4bt2ojb16Gb6NxEQhnJxoO8eOma5tzDpMmiR/pgH097YFS5ZQe/v1E6J9e1pet864bc6eLR+HHj20f/f33/LvVCohMjKM2xcr3MOHQnTuTMfZwUGIZcuU+Xz94w8hunTR/pt37SpEZKQQ2dmWb48S9InXFOtxzs7ORmxsLDp37qz1eOfOnXGsiGl2YmJiCqwfFhaGP//8E0/+G1Jf1DrSNg3Zr66ysrKQlpamdWPMHnz8MQ0g2r+fBldZoyVLqCdx507DB/hVrQoMHkzLfLFJmxBUXUV6D1y/blsDi4TQniynUSP6e9sCqcc5NlaeCOXwYeO2qdnj/HSOs2aaRmCg9aez2Cp3d5ome8QI+l+aMAF4+23DKwQZqnlz6vE+ehTo3Jn+V379FejXj8o1Tp9uuanDbYFigfPdu3eRm5sLX19frcd9fX2RnJxc6HOSk5MLXT8nJwd3794tdh1pm4bsV1cLFiyAp6dn/q2qrXwqM1aC6tWBd96h5alTrTNgqlsXGDuWll991fAqG1Om0KXMnTspUCltpNzZnByaAGf0aBrE5OUF+PtTXnDnzvSecHOjAHTAAEAjG84qnT5NE3pI1TReflnZ9uhDGhR4/TpVQwCMHyBY3OBAzm+2HGdn4KuvgE8+oc+dtWtpxsj79y3fllataJbKixfpc97XF0hOpk6EmjWp/KelKoFYM8UHB6qeKqAphCjwWEnrP/24LtvUd7+6mD59OlJTU/NvN27cMGp7jFmT99+nKhbx8UBEhNKtKdzixTTIJS+Pem4mT9Y/yA8KAgYOpOW33y49dZ1PnqTZxVxdqZfR25u+wNeto9zg1FQKOmvVomDKyQnIzKTqAFu2UPnCUaMoZ9MaSb3N0onBK68o1xZ9eXoCzz5Ly46OdGXl+nXAmK8YzV7kMmW0f8eBs2WpVPRZtWMHnYzu2we0bKncrK21alGwfOMGVaFp3ZpmP1yxgibHmjDBOmv7W4pigbOPjw/UanWBXt6UlJQCvcESPz+/Qtd3dHREhQoVil1H2qYh+9WVi4sLPDw8tG6M2QsfH+qFAKhX9uFDZdtTGGdnYP16ue70p59SgJSRod92liyheqvHj1NvkD1KSKBaspUqUeAUHEyvNzOTBgdJf19vbzoZiY2lGewuXgTOnaNjevky1aYdOpQC0i+/pAFG69db31UJzcC5YUM6QbIlUrrG+fNyD7Qx6Rq6pmpwKTrL6dWL0iWqVqX/s+bNgc2blWuPkxPNNnjkCKVntWpFAfTy5RRAl9beZ8UCZ2dnZwQHByPqqYTJqKgotGrVqtDnhIaGFlh/z549CAkJgdN/0xoVtY60TUP2yxgjEyfSB+atW5T3bI1UKpoYZdMmCqQjIym14NEj3bdRubIcfE+fTpUY7MmTJ9SrfuQIVWjIypJ/5+hIgWW9etSzee8esGED8NJL1LMs9cA7OtLl227daDa0w4fpef/+C7z5JtWsTU9X5vU97epVStWQLiraUm+zRDPPuV07Wj50yPDtFRU4CwH8/bf8M/c4W1bjxvQ37tSJTk4HDaIUCUtN010YlYraEx1NpexCQ6m+uL+/cm1SlJkHKhYrIiJCODk5ifXr14tz586J8PBw4ebmJq5duyaEEGLatGliyJAh+etfvXpVuLq6iokTJ4pz586J9evXCycnJ7F169b8dY4ePSrUarVYuHChOH/+vFi4cKFwdHQUv//+u877FUKIf//9V8TFxYlffvlFABAREREiLi5OJCUl6fz6uKoGs0e//ELvCbVaiDNnlG5N8Q4fFqJ8eWpvp05CZGbq/twnT4Ro0oSeO2yY2ZqoiBkztKtLVKpEVRpu3RIiPV1e7949IVauFKJyZXndoCAhvvhCiNhYIR4/1t5udrYQS5cK4eYmV2GxhooMUlUKlYruz59XukX627eP2h4YKMTOnbRcq5bh29u9W/6bTp0qP56YqP3eePDA+LYz/eXkCPHBB/LfITRUiORkpVtF8vKESEtTuhWmpU+8pmjgLIQQq1atEtWqVRPOzs6iWbNm4tChQ/m/GzZsmGjfvr3W+gcPHhRNmzYVzs7Oonr16mLNmjUFtvnDDz+IOnXqCCcnJxEUFCS2bdum136FEGLDhg0CQIHbrFmzdH5tHDgze9W3L70v2ra13vJ0kt9/lwO5vn0pINbnuVKw9dRHhM06eFA7MBo4sOTgKD1diMWLhfD21n6uWk2B9IABQuzZI78Xjh0Twt2d1uncuWCAbWlt2shtbthQ2bYY6t49+TVcu0blywAhbt40bHuHD8vb0/xa++03+fHKlU3SdGaEnTuF8PSUT0Rzc5VukX2yqcDZnnHgzOzV9etCuLrSe+Prr5VuTcn27RPCxUXuPdbny2fUKHpe/fq2X9P03j0h/P3l/+v27fV7TQ8eCDFnjhAdOghRoYJ2EA0IERwsxNatdHwPH5bfI92769fbb0rJyfLJD0Dtt1U1atBr2LtXiJAQWv72W8O2deKEfEzmz5cf//xz+fGOHU3Tbmacs2fl/6VFi5RujX2yiTrOjDHbFRAAfPghLU+erEzpJH288ALl56rVlI8bHq77lMULFtDAyLNngc8+M2szzUoImhVMGtDj70/H5L/hITrx9KSp1w8coNzoW7eoZN348ZQzGxtLZd7q1aP3xC+/0OO//AL072/5+rQAlRXU/FvbYn6zRDPP+fnnafnAAcO2VVSOM1fUsD716tGAPIDGb1jjDK6lCQfOjDGDTJxIX6z//EPBlLXr3ZumlQWorNKnn+r2PG9vqrEKALNmGT6lt9L+9z95YhhHR1o2ppCQSkXBd1gYsGwZlUebMQMoX56mg+7bF0hLo8DVxQX48Ue5VKClCEEDGyWNGlHVD1ulGTh36EDLBw8atq2iytFx4GydRoygAbo5OTRgUJ/Bzsy0OHBmjBnE2RlYtYqW16yhEmbWbvBgudd46lTqLdXFsGFUmSMzk77AbK2284kTwFtvyT+vWEF1Yk2pYkVgzhwKoIcOpQB5wACqSxsZScH699/TFQpde/uNFRFBNajVavrZlnubAaBZM7o/eZJmEFSrqWJIYqL+2yqqx/ncOXmZS9FZD5WKaqpXqQJcukRXzZgyOHBmjBns+eepTJFUw9cWTJgAvPGGHNjp0oOsUtHrc3enOqsrV5q/naZy5w7Vh5XSJIYNo9kAzcXDg+o4d+8OPH4M9OhBJQylnt/PPqOJaswtPR147z1atsVJTwojBc6XL9P7NySEfjYkXaOwmQPv3qWbhHucrYu3N/Ddd/R5tH49sHWr0i0qnThwZowZZcwYul+/Xtlao7pSqainPDSUZsPr3ZtSCkoSECCnbEyfDly5Yt52mkJ2Nl3eleZ7atSIrg4YOUlqiRwdKX+6eXOqA92lC03VLaXHTJumnUJhDgsWUA62jw8FmbaepgEAFSrQVOcA9Tobk+dcWKqGZpqGlxdNjsOsS/v29PkDUOqTtU91b484cGaMGaVXL8DPj3o2f/xR6dboxsWFcnyfeYYme3jtNd1yb0eNotzSx49pkg9rmx3vaZMmUQ85QAP7duzQDpjMyc0N+Plnmr73+nWavnvkSJp1EqDln382z76vXqXZHwF5kgZb722WaKZrSIGzIXnOTk40hTog9zg/nd9s7hMsZpiPPqIT0UeP6KQ0Pl7pFpUuHDgzxozi5ERBJACsXatsW/RRuTJNw+ziQgGcLjMhOjhQz7qrKwUrX3xh9mYabP16OQddpaKpewMDLduGihUpj9zXFzh1Chg7Fli4EBg+nPLER46kkxBTmzyZZkMMDZVnDHztNdPvRwmaAwRbtaLe/evXaQp1fahU8kmUFDj/9Zf8e85vtl5OTtRJ0bo18OABzeKnedLDzIsDZ8aY0UaOpKBy/36qqGArnnsO+OorWp43T3tgVFFq1KA0AIByaOPizNc+Q50/L6fQAFQNpGtXZdpSowb17js4AN98QykcX3wBVKtGKSSmPtnau5dOiNRqoHZteqxrV8ufNJiLZuDs7k7pMIBx6RpSqsaZM/LvOL/Zurm5UZnH4GDKS+/Y0TbSx+wBB86MMaMFBNBgMIBGftuSwYMp3SQnh3pEdan4MHYsDYpMT6fBbzdumL+duhKCKn/k5NDPXboAM2cq26bWreWShWPGAElJ8s+LFgEZGabZT04ODf4EaADkzp20rFlRxNZJqRoXL1JuvjF5zuXL0325cvS+4cDZtnh6Ar/9BjRoQP9THTtS6hkzLw6cGWMmIfVwbthgnsvv5rRsGfW6HThAJcxK4uAA/PADUL8+TSjSvbtuAwwtYepU4PffablqVSoB52AFn/QzZ1IJvNRUYMgQOmEJDKTc+DVrTLOPXbvoqoG3N/1t7t+nnm2letvNoWJF+rsClNuqmeesb5m/zz6jiYyaNKHe/3//lX/HqRq2oUIFICqKrq5cv06VVjZtUrpV9s0KPk4ZY/YgLIyClPv3Kai0JdWr04xcAPDuu7oFweXL06VSPz/qqXvllZJnxjtxgipK7N1LvaP37lFudUyMsa+ABipOny5X/ggIoBH33t7Gb9sUpDrO5coBR45QhQ3NXuf0dOP3IVXqeP11SgsBaECnVMfZXkjpGidOUB63kxNw86b+l+p79ABmz6Z8Z83eZldXOThn1s/PDzh8mE6i0tMpn/+tt6juPDM9DpwZYyahVlOQAtjWIEHJe+8Bzz5LlzxnzdLtOdWq0cBCV1dgzx7qdT91CoiOpkFxW7fKedO3blHP56JFNJjHx4eC21mz6OdLlwxve1oaldVbuJB+9vCgQKhyZcO3aQ41asgDFmfNovJwNWvS7JPS44ZKSZGrdLRsSScNTk5Us9vetGlD91FR9N6TJrMxdPptQHtgYFCQdVylYLrz9aX3w8yZdCK0di0NHjXmc4UVjv81GGMmM2IE9SzGxFAAaUtcXOSJTVasoGoMuggOpgFvDg40rXWTJjSrW9eu1Atdvz7lQ3ftSpfCq1WjYCc1Ve5lTU+nL7mYGMNm1Zs2Tbu025YtFDxbo8GDaeKZ3FwK9gcOpMc/+cS4aYS//5568Z97jk5iAKBfP+OmFbdW3brR/cGD9N4xJs9ZotnjzGkatkmtpitYv/5KJ+ZxcUDjxjThUElXw5juOHBmjJmMnx/Qty8tT59uuamVTSUsjCYMyc0F3nlH9zrNPXpQ+Td/fzoGzz4LNG0KtGhBAfW+fRSYqFQ0sYQ0GK5WLXmA1t27FDw3bEhVJ3Q9dhkZNJuYpG9fGhBoraTesJAQOpFYsoR6xu/eNXxGRiHopAWgoPz772nZngYFagoKovzwrCx6b0mB8/79htcW1wycn3vO+DYy5YSFUdDcsSONN5k6lf6mf/6pdMvsAwfOjDGT+vhjwNmZej00Azpb8dln1CMcHQ3MmaP784YPp3SMpCS6PHryJA3Si4iQJ5IQggZ0ubsD335LlRFSUijPVHL2LKV8bN+u2363bQMePqTlsmWBzz/Xvc1K8fSk3tLu3SkPU5rZ8JNPqC6tvmJjKdWgTBnqdc7IoF7Tdu1M2WrroVLJVWx27aI8Zw8PGmh5/Lj+28vN1U7VkErcMdtVpQqlbmzcSOMcTp2iE/nwcLraxQzHgTNjzKSCguQc4fBw+jK3JVWryj2fH31Egamh7t+nwYZCAP37A0uXUoB98iSlLACUh/vhh/JAOUdHuv/4Y916nb/8Ul6eOZPypm2BmxvNZDhypPw6792jnn59SYMC+/YFvv6alt96y75nvpPSNX75hU5UpZ937NB/W1euUO81QO/HJk1M0UKmNJUKGDaM6roPGkRXI5Ytoytd69bRCRMzgGBmk5qaKgCI1NRUpZtikDt3hKCvNFpmTFfZ2UI0aULvnZdfVro1hgkPp/a7ugoRF6f/83NzhejXj7bx7LNCpKUVv35OjhAdOtD6Dg50v2NH8c+5fFn+Hw0IECIzU/92Ki0vT4i5c+XXAQixaZPuz3/8WIjy5el5n34q/80ePDBfm61BRoYQZcvS6z11SoiICFquXZuOqT62bpWPfUiIedrLlLd7txB16sh/68aNhThwQOlWWQd94jXucWaMmZyTE+WcqtVUWcKYXlulfPIJ5QpmZNAEKfr0nOfk0EDJyEg6FhERVIatOGo11V+tVEnOUy2p13nZMnn5s8/kqZNtiUpFpQAXLZIfGzUKSEzU7fk7dlB6R0AApWwANODQ09PULbUuZctSDitA6Rpdu1LP88WL+k+/rJnfzGka9issjP7Wn39OYytOnaL8+M6daUCtrY1JUQoHzowxs2jalAalAHT5/d49ZdujL0dHCnhr16aZAfv1ky9nFycrC3j1VUoZUKspjUCqu1uSypVpYKDk5Em6FF+Y3FwakAjQLG/SoExbNXkyleUDqLrG4MG6XUqW0jReeUU+QRs92jxttDaa6RoeHlS9BdA/XYMD59LDyYlm17x0iT6X1WrKhQ4Lowoc33wDZGcr3UrrxoEzY8xsZs6knOc7d4Bx42yvR6N8eeCnn+j+2DGqeLFsWdED2NLTgZ49aWCfszMFcq+9pt8++/ShwFsye3bhx235crk6x4YNtp/P6+BAJxteXvTzkSOUE16cGzfoSx+ggYFZWZSfGxJi1qZaDWmA4LFjdGLapw/9rOvAUolm6cUWLUzSNGblfHxoLMflyxRIu7nRCdSwYVQy8/339Z9Qp7RQCWFrX2W2Iy0tDZ6enkhNTYWHtRZVLUZKilwD9c4duoTMmL5iYmjChrw8Gmyn6+Qi1mTfPipTJ41Gd3WlHtFu3ahXNDubbmvX0ut1cwN+/FG+lK6vlBQ64bh/n36WLsVL8vLoi+/+faoecfasca/Pmvz8M518ANQbdvw40KxZ4evOmAHMmwe0b0/H7Px5YPVq+y1DV5iGDakixubNdNm9cmU60UpM1G32v4wMer8ClE704AFPflIa3b9PV7uWLZOr3AD0Gfbmm3RFyxZTwXSlV7xm9ozrUowHBzJGVq+W30tffKF0awyTlkavo3597YFsT9+8vIT4/Xfj9/fdd/I2GzXSHvC1apX8u6go4/dlbd5+W359FSsK8fffBdc5d04IZ2da5+OP5UGBNvpxa7ApU+i1Dx5MP7dpQz+vWKHb80+ckI91x47mayezDVlZNFg0LEwIlUp+b3h7CzFhghCnTyvdQvPgwYGMMavy1ltyubW33jKsZJbSypWjtp85QzO0DRhAKQGtW1NPX1gYDUo7fNg0l7sHDZJzVk+fprJtI0ZQzd5x4+hxf395HXuyZAn1uAM0HXeHDtpTB+flUS9Ydjb1+l+4QI8PHGi9Myaai5Su8euvdPVD33QNzm9mmpyd6era7t1AQgKVyqxShVKBli0DGjWiz7d162hyldKIUzXMiFM1GJMJQcHf+vWUjxoVRSkcrGi3bgE1ahQ9WGfpUmDiRMu2yVL++gto2VKeltzfHzh0iGZlXLmSTh7c3YGjRyngy8oC/vij9AV/OTmUtpOaSmlCFSvSMVKr6TPc27v450+aRBVZADqh7d3b7E1mNiY3lz6vv/qKUtBycuh/LymJ7u2BPvEa9zgzxixCmmq5Z0+aLa5nT54CtiTPPEODAAGq8uHqKv/OwwMYOlSZdllCgwY0uFKtpp9v36ae/SNHaDp3gErYHTggDwosjVNFOzrS1Q6AqmvUrEl5z7m5lC9ekrg4ebm0nXQw3ajVQJcuVFr01i0q1Tlliv0EzfriwJkxZjFSibdWrWgQUocOVD+UFW30aOo5zMyk3te0NJrK+/RpoEIFpVtnXmFhdLIluXkTeOEFKlfXqBHVe163jn43apTtVxYxlJSuIQXKUmlCXdI1Tp2i+0qVaGAhY8WpVIlKR86cqXRLlMOBM2PMolxdKX+uUycKBLt3p4k/WNEqVpR7XsuVoxzDatWUbZOlvPkmTZAiycmh+9OngerVgXPn6D2lb9k/e9KtG9XnjY+n2t9S4Pzbb3LJwsL8849cuSU01OzNZMwucODMGLO4cuXosvKAARQIvfZayTV7Wek1Z452YNy0KZVQu3WLfh4woPQNCtTk40MTwADAqlU0kUW1ajR4q7heZ82Bga1ambeNjNkLDpwZY4pwdga+/x4ID6ef332Xpphm7GkqFQ0qHTUKGD6cBgHeuUNXKiZPBhYuVLqFynvnHbrftIkqILzxBv08axbw5Enhz+GKGozpj6tqmBFX1WCsZELQYJOpUylA2r+fcp8ZY7oTgiaKiY+n/6cxY2igYEoK9UK//XbB5wwaRBOnAJQ7X66cRZvMmNXgqhqMMZuhUtEI7TffpC//oUOLntKaMVY4lQoYO5aW16wBypalGrwATdv+6JH2+rm5NFU3QDMMctDMmG44cGaMWYXPPqMeshs35MvOjDHdDRwIeHkBV6/SANyRI+VeZ80xBEIA48cD16/Tz5zfzJjuOHBmjFkFd3fgu++oesSmTfIlZMaYblxdaXZJgNIznJ2BefPo508+oQAaoMdWr5af9/zzlm0nY7aMA2fGmNVo2VJ7au7ERGXbw5iteestStv49Vfg8mWqthEcTKka8+bR7G9SDV4nJ7rnHmfGdMeBM2PMqnzwAdUpTk2lfOfUVKVbxJjtqFkT6NqVltesARwcaIZFgHqZR4+m5Z49qdpGnTo0SyNjTDccODPGrIqTE/Dtt1Sn99AhCgSWLQOys5VuGWO2QRoj8L//0QQoHTsCL75INdPz8iidQypRN3Bg6Z1xkTFDcODMGLM6tWrR9MF16wL//ku1nuvWpem68/KUbh1j1q1LF6BGDapO8/XX9NiSJVQ545VXgLlzgagoenzgQPO3Rwjg9m2+esTsA9dxNiOu48yYcXJygA0bqKxWcjI9Vrs2ld0aNqx0zxbHWHFWrKDKGYGBwMWLgKMjlaBzcADWrqW6zsHBwJ9/mn7ft29TjvWpU3Q7fVouMenpSbMaVqsGPPMMUL483Tw9qSJI06Z04sy94MyS9InXOHA2Iw6cGTON9HQqp7VkCU3UAFAVjmHDKACoV0/Z9jFmbTIygOrVgX/+oWo1mlOWt20LREfT/9O775pmf0JQXegVK4Bt2+ikV5ODg+5Xi3x9gXbtgPbt6b5+fXo+Y+bCgbOV4MCZMdN6+JDyn1euBM6flx8PCQGGDAEGDOD3KWOS+fNpsG2DBtTz6+BAlWqqVaMe3cREoEoV4/aRnU3lI5cto1kLJS1bAq1bA40aAY0bA0FBFExfvy7fkpIofSM1lXqk79wBTp4EsrK09+HlRcF+u3Z036gRUKaMce1mTBMHzlaCA2fGzEMIYN8+CqB/+UXu3VKrgbAwyvFs1w5o2JB7qljp9eABEBBAJ5w//gj06kX1nKdMod7cgwcN33ZmJg0+XLRILhtZtiz1bI8dS8Gyods9fhw4fJgGB8fE0BUnTWo1VQORgvLnnqNA3c3N8NfDSjcOnK0EB86Mmd8//9CgwW++KZivWb480KYN0KQJXbaWcisDAgAXFwUay5iFTZ8OLFxIgeWxY0CzZtQzvHatXJpOH+npwBdfUAAujTvw8wMmTgTefBPw9jZp8/HkCRAXR4H04cP0Gv79t+B6jo505UlK8WjdmvKmGdMFB85WwiYDZ41T+5QUILAGLSdc5cCZWb8LF4CdOyl/8/ffgUfpha/nqKZBSK1b06Xfli0pyGbM3ty5Q2MAMrOAZZ8DE8Lp/X/1KlChgu7bSUujgHnlSuDuf4FrlWcoR3roUMulTghBKR5nzgB//UUDD2NigFu3tddTgXqk27ShCV5q1KDBxJ6edK9WW6a9zDakpaXB09+fA2el2WTgzEOZGWOMMVaKpAHwBHSK1zj7jzHGGGOMMR04Kt2A1atX45NPPkFSUhLq16+Pzz//HG3bti1y/UOHDmHSpEk4e/Ys/P39MWXKFIwZM0ZrnW3btmHmzJm4cuUKatasiXnz5qFv37567VcIgdmzZ2PdunW4f/8+WrRogVWrVqF+/fqmPQDW5tGj/EVO1WClxZ07dOlXuvx75gxw6RKQ/aT456kdqK50gwY0EDEoqOAl6ypVaB1rupiTnQ3cugXcvFlwRsZ//pGPwZkzwJ0U4/YVUBXo3h3o0IEGjxXHy4sGe1nqMroQwN27wI0b9Fqjo4GjR4HriZbZPwC4u9H7plo1oGpVyr+vWrXkHHwHB6ByZVrf1bXk/bz5JrA5AihbBrh2jco5FiY3l6pkzJkjpz80bABMnQr07m37g22zs6mKx6VLlC8dHU2pHkWldRniGX/6PGjYkD4bvLyM36aTE9Xd5gGQZpKWBvj767SqoqkaW7ZswZAhQ7B69Wq0bt0aX3zxBb766iucO3cOAQEBBdZPSEhAgwYNMHLkSIwePRpHjx7F22+/jc2bN+Oll14CAMTExKBt27aYM2cO+vbti+3bt+PDDz9EdHQ0WrRoofN+Fy1ahHnz5mHjxo2oXbs25s6di8OHD+PChQsoV66cTq/PJlM1NPDgQFaa5eXR+16zfNbTt4cPddtWxYo0aKldO8qn9vGhnGoPDxrUZC7371MOqDQJxfnzFDQlJVHQqCs/PwrspAGWXl7Fnwjk5lIwsncvVUnQR8WKQI8eVAHixRdNEyjk5FD+u3QczpyhHN/ERKp3/DT1fznwVatSTqw0SYcp8nhzcyloO30aOHu2YOk1Q/j40N9Fs9JE48b0d5P+TpcvU8WZgQNp5sCn3bsHbNkCrF5NJ04ABeXz5gGDBtl+wFycnBz637h7Vy6N9+BByX8b6cRL+jy4do1OPM3FxQXo1In+N3r00DnOYzqwmcGBLVq0QLNmzbBmzZr8x+rWrYs+ffpgwYIFBdafOnUqdu7cifMaBVzHjBmDU6dOISYmBgDQv39/pKWl4ddff81fp0uXLvDy8sLmzZt12q8QAv7+/ggPD8fUqVMBAFlZWfD19cWiRYswWsehyPYUOP/1F32hMcaIEFRV4OxZ4Nw5ur96VXuSh7w84MqV4r+A3dyoN8nU8vLkyWIK4+JCM7c93Vvp6kqDyerVo4kngoKK7p0sSUYGVUL47TcKFEuSmKjdZicn+tyRBnR5eFAPfmgonYBIn08SIShwuXCBAqGzZ+mz6+LFgj3rmipVosFjLVrQQLKQEMNfsz6ePKH3x+XLdAXgxg26JSVRgF2c7GyaoU/jImEBXl4U/FepIt/7+NDU29LxvHoV+OEHmoJbKuvo6UlVMl5/nesl6ystTf48OHuW3ov6njwW5t49+ntr8vRU7kqWpye9d+zlhEqveE0oJCsrS6jVahEZGan1+Pjx40W7du0KfU7btm3F+PHjtR6LjIwUjo6OIjs7WwghRNWqVcXSpUu11lm6dKkICAjQeb9XrlwRAMTJkye11unVq5cYOnRoka8pMzNTpKam5t9u3LghAIjU1NQin2PN7twRgr6K+MY3vvGNb3zjG9/k2507SkcpppOamip0jdcUO1e4e/cucnNz4ftUl4Gvry+SpeKQT0lOTi50/ZycHNy9e7fYdaRt6rJf6V6ftgHAggUL4OnpmX+rWrVqkevaAqlngjHGGGOMWcHgQNVT1xmEEAUeK2n9px/XZZumWkfT9OnTMWnSpPyf09LSbDp4dnCgPK//zkkYY8xqpKbSDHN//03pHFWq0M3fH3B2Vrp1jNk/Hx+lW6AMxQJnHx8fqNXqAj24KSkpBXp6JX5+foWu7+joiAr/VXIvah1pm7rs18/PDwD1PFeuXFmntgGAi4sLXOxsOjIHBx4UyBizPpUqAbVqKd0Kxlhpo1iqhrOzM4KDgxEVFaX1eFRUFFq1alXoc0JDQwusv2fPHoSEhMDpv9E1Ra0jbVOX/QYGBsLPz09rnezsbBw6dKjItjHGGGOMMfumaKrGpEmTMGTIEISEhCA0NBTr1q1DYmJifl3m6dOn49atW/jmm28AUAWNlStXYtKkSRg5ciRiYmKwfv36/GoZADBhwgS0a9cOixYtQu/evfHjjz9i7969iI6O1nm/KpUK4eHhmD9/PmrVqoVatWph/vz5cHV1xaBBgyx4hBhjjDHGmLVQNHDu378//v33X3z88cdISkpCgwYNsGvXLlSrVg0AkJSUhMREuRJ9YGAgdu3ahYkTJ2LVqlXw9/fH8uXL82s4A0CrVq0QERGBGTNmYObMmahZsya2bNmSX8NZl/0CwJQpU/D48WO8/fbb+ROg7NmzR+cazowxxhhjzL4oWsfZ3tl6HWfGGGOMMXunT7xmJ6WrGWOMMcYYMy8OnBljjDHGGNMBB86MMcYYY4zpgANnxhhjjDHGdKD4zIH2TBp3mZaWpnBLGGOMMcZYYaQ4TZd6GRw4m9HDhw8BwKan3WaMMcYYKw0ePnwIT0/PYtfhcnRmlJeXh9u3b6NcuXJQqVRKN6dEaWlpqFq1Km7cuMHl88yEj7F58fE1Pz7G5sfH2Lz4+JqfrR1jIQQePnwIf39/ODgUn8XMPc5m5ODggCpVqijdDL15eHjYxBvdlvExNi8+vubHx9j8+BibFx9f87OlY1xST7OEBwcyxhhjjDGmAw6cGWOMMcYY0wEHziyfi4sLZs2aBRcXF6WbYrf4GJsXH1/z42NsfnyMzYuPr/nZ8zHmwYGMMcYYY4zpgHucGWOMMcYY0wEHzowxxhhjjOmAA2fGGGOMMcZ0wIEzY4wxxhhjOuDAmeVbvXo1AgMDUaZMGQQHB+PIkSNKN8kmLViwAM899xzKlSuHSpUqoU+fPrhw4YLWOkIIfPTRR/D390fZsmXRoUMHnD17VqEW27YFCxZApVIhPDw8/zE+vsa7desWBg8ejAoVKsDV1RVNmjRBbGxs/u/5GBsnJycHM2bMQGBgIMqWLYsaNWrg448/Rl5eXv46fIx1d/jwYfTs2RP+/v5QqVTYsWOH1u91OZZZWVkYN24cfHx84Obmhl69euHmzZsWfBXWrbhj/OTJE0ydOhUNGzaEm5sb/P39MXToUNy+fVtrG/ZwjDlwZgCALVu2IDw8HB988AHi4uLQtm1bdO3aFYmJiUo3zeYcOnQI77zzDn7//XdERUUhJycHnTt3Rnp6ev46ixcvxtKlS7Fy5UqcOHECfn5+ePHFF/Hw4UMFW257Tpw4gXXr1qFRo0Zaj/PxNc79+/fRunVrODk54ddff8W5c+fw6aefonz58vnr8DE2zqJFi7B27VqsXLkS58+fx+LFi/HJJ59gxYoV+evwMdZdeno6GjdujJUrVxb6e12OZXh4OLZv346IiAhER0fj0aNH6NGjB3Jzcy31Mqxaccc4IyMDJ0+exMyZM3Hy5ElERkbi4sWL6NWrl9Z6dnGMBWNCiObNm4sxY8ZoPRYUFCSmTZumUIvsR0pKigAgDh06JIQQIi8vT/j5+YmFCxfmr5OZmSk8PT3F2rVrlWqmzXn48KGoVauWiIqKEu3btxcTJkwQQvDxNYWpU6eKNm3aFPl7PsbG6969uxgxYoTWY/369RODBw8WQvAxNgYAsX379vyfdTmWDx48EE5OTiIiIiJ/nVu3bgkHBwexe/dui7XdVjx9jAtz/PhxAUBcv35dCGE/x5h7nBmys7MRGxuLzp07az3euXNnHDt2TKFW2Y/U1FQAgLe3NwAgISEBycnJWsfbxcUF7du35+Oth3feeQfdu3dHp06dtB7n42u8nTt3IiQkBK+88goqVaqEpk2b4ssvv8z/PR9j47Vp0wb79u3DxYsXAQCnTp1CdHQ0unXrBoCPsSnpcixjY2Px5MkTrXX8/f3RoEEDPt4GSk1NhUqlyr9SZS/H2FHpBjDl3b17F7m5ufD19dV63NfXF8nJyQq1yj4IITBp0iS0adMGDRo0AID8Y1rY8b5+/brF22iLIiIicPLkSZw4caLA7/j4Gu/q1atYs2YNJk2ahPfffx/Hjx/H+PHj4eLigqFDh/IxNoGpU6ciNTUVQUFBUKvVyM3Nxbx58zBw4EAA/D42JV2OZXJyMpydneHl5VVgHf4e1F9mZiamTZuGQYMGwcPDA4D9HGMOnFk+lUql9bMQosBjTD9jx47F6dOnER0dXeB3fLwNc+PGDUyYMAF79uxBmTJlilyPj6/h8vLyEBISgvnz5wMAmjZtirNnz2LNmjUYOnRo/np8jA23ZcsWfPfdd9i0aRPq16+P+Ph4hIeHw9/fH8OGDctfj4+x6RhyLPl46+/JkycYMGAA8vLysHr16hLXt7VjzKkaDD4+PlCr1QXO+FJSUgqcoTPdjRs3Djt37sSBAwdQpUqV/Mf9/PwAgI+3gWJjY5GSkoLg4GA4OjrC0dERhw4dwvLly+Ho6Jh/DPn4Gq5y5cqoV6+e1mN169bNHyzM72Hjvffee5g2bRoGDBiAhg0bYsiQIZg4cSIWLFgAgI+xKelyLP38/JCdnY379+8XuQ4r2ZMnT/Dqq68iISEBUVFR+b3NgP0cYw6cGZydnREcHIyoqCitx6OiotCqVSuFWmW7hBAYO3YsIiMjsX//fgQGBmr9PjAwEH5+flrHOzs7G4cOHeLjrYOOHTvizJkziI+Pz7+FhITgtddeQ3x8PGrUqMHH10itW7cuUELx4sWLqFatGgB+D5tCRkYGHBy0v4LVanV+OTo+xqajy7EMDg6Gk5OT1jpJSUn466+/+HjrSAqaL126hL1796JChQpav7ebY6zUqERmXSIiIoSTk5NYv369OHfunAgPDxdubm7i2rVrSjfN5rz11lvC09NTHDx4UCQlJeXfMjIy8tdZuHCh8PT0FJGRkeLMmTNi4MCBonLlyiItLU3BltsuzaoaQvDxNdbx48eFo6OjmDdvnrh06ZL4/vvvhaurq/juu+/y1+FjbJxhw4aJZ555Rvz8888iISFBREZGCh8fHzFlypT8dfgY6+7hw4ciLi5OxMXFCQBi6dKlIi4uLr+igy7HcsyYMaJKlSpi79694uTJk+KFF14QjRs3Fjk5OUq9LKtS3DF+8uSJ6NWrl6hSpYqIj4/X+u7LysrK34Y9HGMOnFm+VatWiWrVqglnZ2fRrFmz/PJpTD8ACr1t2LAhf528vDwxa9Ys4efnJ1xcXES7du3EmTNnlGu0jXs6cObja7yffvpJNGjQQLi4uIigoCCxbt06rd/zMTZOWlqamDBhgggICBBlypQRNWrUEB988IFWkMHHWHcHDhwo9HN32LBhQgjdjuXjx4/F2LFjhbe3tyhbtqzo0aOHSExMVODVWKfijnFCQkKR330HDhzI34Y9HGOVEEJYrn+bMcYYY4wx28Q5zowxxhhjjOmAA2fGGGOMMcZ0wIEzY4wxxhhjOuDAmTHGGGOMMR1w4MwYY4wxxpgOOHBmjDHGGGNMBxw4M8YYY4wxpgMOnBljzA599NFHaNKkidLNYIwxu8KBM2OM2RiVSlXsbfjw4Zg8eTL27dunaDs5eGeM2RtHpRvAGGNMP0lJSfnLW7ZswYcffogLFy7kP1a2bFm4u7vD3d1dieYxxpjd4h5nxhizMX5+fvk3T09PqFSqAo893ds7fPhw9OnTB/Pnz4evry/Kly+P2bNnIycnB++99x68vb1RpUoV/O9//9Pa161bt9C/f394eXmhQoUK6N27N65du5b/+4MHD6J58+Zwc3ND+fLl0bp1a1y/fh0bN27E7NmzcerUqfye8I0bNwIAUlNTMWrUKFSqVAkeHh544YUXcOrUqfxtSm3/4osvULVqVbi6uuKVV17BgwcPzHhUGWOsZBw4M8ZYKbF//37cvn0bhw8fxtKlS/HRRx+hR48e8PLywh9//IExY8ZgzJgxuHHjBgAgIyMDzz//PNzd3XH48GFER0fD3d0dXbp0QXZ2NnJyctCnTx+0b98ep0+fRkxMDEaNGgWVSoX+/fvj3XffRf369ZGUlISkpCT0798fQgh0794dycnJ2LVrF2JjY9GsWTN07NgR9+7dy2/r5cuX8X//93/46aefsHv3bsTHx+Odd95R6tAxxhgATtVgjLFSw9vbG8uXL4eDgwPq1KmDxYsXIyMjA++//z4AYPr06Vi4cCGOHj2KAQMGICIiAg4ODvjqq6+gUqkAABs2bED58uVx8OBBhISEIDU1FT169EDNmjUBAHXr1s3fn7u7OxwdHeHn55f/2P79+3HmzBmkpKTAxcUFALBkyRLs2LEDW7duxahRowAAmZmZ+Prrr1GlShUAwIoVK9C9e3d8+umnWttjjDFL4h5nxhgrJerXrw8HB/lj39fXFw0bNsz/Wa1Wo0KFCkhJSQEAxMbG4vLlyyhXrlx+zrS3tzcyMzNx5coVeHt7Y/jw4QgLC0PPnj2xbNkyrfzrwsTGxuLRo0eoUKFC/jbd3d2RkJCAK1eu5K8XEBCQHzQDQGhoKPLy8rRyuRljzNK4x5kxxkoJJycnrZ9VKlWhj+Xl5QEA8vLyEBwcjO+//77AtipWrAiAeqDHjx+P3bt3Y8uWLZgxYwaioqLQsmXLQtuQl5eHypUr4+DBgwV+V758+SLbLvV4S/eMMaYEDpwZY4wVqlmzZtiyZUv+IL6iNG3aFE2bNsX06dMRGhqKTZs2oWXLlnB2dkZubm6BbSYnJ8PR0RHVq1cvcpuJiYm4ffs2/P39AQAxMTFwcHBA7dq1TfLaGGPMEJyqwRhjrFCvvfYafHx80Lt3bxw5cgQJCQk4dOgQJkyYgJs3byIhIQHTp09HTEwMrl+/jj179uDixYv5ec7Vq1dHQkIC4uPjcffuXWRlZaFTp04IDQ1Fnz598Ntvv+HatWs4duwYZsyYgT///DN/32XKlMGwYcNw6tQpHDlyBOPHj8err77K+c2MMUVx4MwYY6xQrq6uOHz4MAICAtCvXz/UrVsXI0aMwOPHj+Hh4QFXV1f8/fffeOmll1C7dm2MGjUKY8eOxejRowEAL730Erp06YLnn38eFStWxObNm6FSqbBr1y60a9cOI0aMQO3atTFgwABcu3YNvr6++ft+9tln0a9fP3Tr1g2dO3dGgwYNsHr1aqUOBWOMAQBUQgihdCMYY4wxyUcffYQdO3YgPj5e6aYwxpgW7nFmjDHGGGNMBxw4M8YYY4wxpgNO1WCMMcYYY0wH3OPMGGOMMcaYDjhwZowxxhhjTAccODPGGGOMMaYDDpwZY4wxxhjTAQfOjDHGGGOM6YADZ8YYY4wxxnTAgTNjjDHGGGM64MCZMcYYY4wxHXDgzBhjjDHGmA7+H6vL9frV9xa7AAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(8, 6))\n", "fig.suptitle(\"Figure 4. Tolerance for getting stuck = red line\", fontsize=16)\n", @@ -695,7 +642,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": { "hide_input": true, "slideshow": { @@ -731,7 +678,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": { "hide_input": true }, @@ -752,25 +699,14 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { "hide_input": true, "slideshow": { "slide_type": "subslide" } }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwMAAAI1CAYAAACKdiYnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAADsPUlEQVR4nOzdd1wT9xsH8E9IGAKCCxBwLxDErQwXAlatWkdxb+3PXVdtFWsr7trhrqtqce9Rte6BW5wobhQUFVFxsAkkud8flEhkI3CJfN6vV14md5fLk8eQ3HP3HRJBEAQQEREREVGRoyd2AEREREREJA4WA0RERERERRSLASIiIiKiIorFABERERFREcVigIiIiIioiGIxQERERERURLEYICIiIiIqolgMEBEREREVUSwGiIiIiIiKKBYDRIXM3d0dEokE/v7+YodCOszPzw8SiQQDBgzI1fMeP34MiUSCSpUqFUhcRESkW1gMEOWDSpUqQSKRZHlbsGCB2GFqhQEDBmSbq8TERFFii4mJwbx58+Dp6Qlra2sYGBjA3NwcdevWxejRo3Ht2jVR4tI1jx8/hq+vL/z8/MQOJcd8fX3h6+srdhhERIVOJnYARJ+T6tWrw9LSMsN1tra2AIAKFSrAzs4OxsbGhRma1skqV3p6hX+e4uDBg+jXrx8iIyMBpPx/1alTB3Fxcbh//z5u3LiBxYsXY+TIkViyZEmhx/cxc3Nz2NnZwdraWuxQ0nn8+DGmTZuGFi1a5PrKhVimTZsGACwIiKjIYTFAlI8mT56c7cHPunXrCicYLZeTXBWWffv2oXPnzlAqlejRowd8fX1hZ2enXh8XF4d//vkH06dPx9mzZ0WM9IPOnTujc+fOYodBREQ6js2EiKhIe/XqFfr37w+lUokffvgBmzdv1igEAMDExAS9evXCjRs3MHDgQJEiJSIiyn8sBogKWVYdiJOSkjB79mzY2dnByMgItra2GDZsGF6/fg1fX19IJJJ0zRhS2+Bn1j47s+elXf769WuMGjUKlSpVgr6+froz9ocPH8ZXX30FKysrGBoaoly5chg4cCAePXqU90RoiSVLluDdu3dwdHTErFmzstzW0NAQY8aMydX+X716haFDh8LGxgZGRkawt7fHnDlzoFAoMv0spF0eGBgIb29vWFlZQU9PT/3/nF0H4lOnTsHLywtmZmYwNzdHy5YtcfTo0VzFntaTJ08wdOhQVKlSBYaGhihevDiqVKmCzp07Y8uWLRqxt2zZUh1D2r4gaTstp/3choaGYsCAAbC1tYVMJlN/VjP77KbKLgfPnz/H+PHj4eDgABMTE5ibm8PJyQkTJkxAcHCwxmuk+rj/yuPHjz8plrTL4+LiMHnyZNSoUQNGRkZwd3fX2PbSpUvo0aMHbG1tYWBgACsrK3Tt2hXXr1/P8DWJiPIDmwkRaQmFQoGvvvoKhw8fBgDY2dmhWLFiWL16NQ4fPowOHToUyOu+fv0aDRs2xPPnz+Ho6Ahzc3NIpVL1+rFjx2LhwoUAAEtLSzg6OuLRo0fw8/PDrl27cPDgQbi5ueX6dXfs2IE9e/YgOjoalpaWaNKkCfr16wdzc/N8e285kXogO2TIEMhk+fuV+OzZMzRp0gRhYWHQ19dHrVq11AeEAQEB2T7/9OnTmD17NvT19WFnZwdTU9Mcve6WLVvQu3dvqFQqlC5dGpUrV8bNmzfRpk0bzJ49O9fv4/Hjx2jUqBEiIyNhbGwMOzs7SKVShIWFYc+ePQgNDUWPHj0AAE5OTnjz5g1u3boFMzMzODk5qfeTUf+G+/fvY9y4cUhISICjoyPMzMw0Ds7z6vjx4+jSpQuio6Ohr6+PmjVrQqVSISQkBH/88QdMTU3h6+uLChUqoEmTJjh37hwAoEmTJhr7MTIy+uRYACAhIQHNmzfH9evXYW9vDwcHBxgaGqrXz58/H9999x0EQUCpUqVQq1YthIWFYceOHfjnn3+wZcsWdOnSJV9iISLSIBDRJ6tYsaIAQPj777+z3bZFixYCAOHkyZMay3/77TcBgFCqVCnh3Llz6uVhYWFCvXr1BH19fQGAMHXqVI3n9e/fP8vXnjp1aobPS10ulUoFV1dX4enTp+p1CQkJgiAIwvLlywUAQuXKlTXiVSgUwsyZMwUAQrly5dTb50RqvBndSpYsKRw8eDDH+/pUr1+/Vr92YGBgvu+/Xbt2AgChYcOGGvk9ffq0UKJECfX/6cefhdTPiFQqFYYMGSLExcWp18XHxwuCIAh///23AEDo37+/xnOfPXsmmJqaCgCESZMmCcnJyYIgCEJSUpIwbtw49WtWrFgxx+9j1KhR6teKiYnRWHf37l1hxYoVGstOnjwpABBatGiR6T5TPwdSqVT46quvhDdv3qjXpX6eMvvspsosB0+ePBHMzc0FAEK/fv009q1UKoX9+/cLe/fu1XhO6ucgM3mNJXW5VCoVatSoIdy5cyfd+zx48KAgkUiEMmXKCDt37tR4/qpVqwSZTCYUL15cCA8PzzQ+IqK8YjMhonw0cODADIfK/Lg5wMdUKpV66NFFixZpnGkvX748tm3bBpVKVSAxy2Qy7NixA+XKlVMvMzIyQlJSEnx9fSGVSrFz506N9yCVSvHjjz/i66+/xrNnz7B9+/Ycv17VqlUxe/Zs3LhxA9HR0YiJicGRI0fg7OyMd+/eoVOnTrhy5Up+vsVMPX/+XH2/cuXK+brv+/fv499//4W+vj62bdumkd9mzZph/vz5SE5OznIftWrVwrJlyzRGnipWrFiWz1m+fDliY2PRqFEjzJkzR321Q19fH/PmzUPNmjVz/V5Sm9SMHz8+3dUJe3t7DBkyJNf7TGVhYYFNmzahVKlS6mWfejZ+7ty5iIqKgqenJ/z8/DT2raenh3bt2hXYlbbMKJVKbN68WSP/qe/zxx9/hCAIWL16dbqz/4MHD8aYMWMQExODVatWFWrMRFQ0sBggykfVq1dHkyZN0t3SNpXIyJ07d/D8+XOYmJiga9eu6dZXq1YNzZo1K5CYvby8YGNjk275hQsXEBERgfr166NevXoZPverr74CkNI2PKd++ukn+Pj4oHbt2ihevDhMTU3RqlUrnD59Go0bN4ZcLsfEiRPz9mZyKSYmRn3fxMQkX/ed2j7f3d09w0KjR48e2R7Y9+nTJ9fDrKY2Mxs+fHiG60eMGJGr/QEpBSmQ0rRLEIRcPz8rX3/9db7n/p9//gEAfP/99/nS5Cg/ODo6on79+umWP3nyBNeuXYOlpaX67+ljefk7IyLKKfYZIMpHeR0uM/XMq729PQwMDDLcpnbt2gUya3FmZ4qDgoIApLQXb9q0aYbbvH//HoDmGfa8MjAwwIwZM9C6dWv4+/vj3bt3KFmy5CfvNyvFixdX34+Li4OZmVm+7Tv1/7R27doZrjcyMkL16tVx8+bNTPeRl7P4Dx48yPK5ednnyJEjsXbtWsyYMQPr1q1DmzZt0KxZM7Rs2TLDQjI38hJPVmJiYtSfRxcXl3zd96fI7u8sMTEx07+z1En48uPvjIjoYywGiLRAXFwcAM2D049lte5TZHZWNioqCkBKB+PXr19nuY+EhIR8icXV1RUA1B09GzRokO1zZs+ejQMHDqRbvnjx4kyvaKRKnQgOAEJDQ1GnTp1cRpy5/Pg/zcsZ89jYWAApzW8yYmVllet91q1bF6dPn8bUqVNx4sQJrFixAitWrIBEIkGrVq2wYMGCPB/U5/dVgejoaPX9wu6MnpXs/s6io6PVnZgzk19/Z0REabEYINICqQcKqQdyGUnbpCWt1GYQmTXfSD0oza3UtuG9e/fGhg0b8rSP3NLX11ffVygUOXrOgwcPMjyISj3IykqZMmVQvXp1BAcH49SpU/laDHzK/+mnMDU1RVRUFF6/fo2qVaumW//q1as87dfFxQWHDx9GbGwszp07h5MnT2LTpk04cuQIWrVqhVu3bqFEiRKfGL2mvHy20xZYUVFR+VYQFPTfWZMmTbRmQjsiKlrYZ4BIC9SoUQMAcO/evUw7laY2J/hY6kFnZmfvHz58mKeYHBwcAAC3bt3K0/Pz4vbt2+r7aTvcZsXPzw+CIKS7ZddpO1X37t0BACtXroRSqcx1zJlJ/T/NrBmQXC5XNyXKT2k/Sxm5e/fuJ+3f1NQUrVu3xi+//IJ79+6hatWqeP78OQ4ePKjeJr/a6efls21mZqb+7Fy8eDFf4shrLDmR+nd29+7dAhskgIgoKywGiLRAzZo1YWtri9jYWOzYsSPd+pCQEJw5cybD51apUgUAcPny5XTrnj17pu5QmlvNmjVDmTJlcOPGjQLpq5CRP/74A0BK34m0TXgK0qhRo1CiRAncvn0bP/74Y5bbyuVyLFq0KEf7bdWqFQDg5MmTePLkSbr1W7duLZBmH1988QWAlFGFMrJs2bJ8ey1jY2N15/jw8HD18tSO0Z/6/rL6bMfFxWlMdpZWp06dAHz4POVEdjHnNZbsVK9eHbVq1cLbt2+xbt26PO2DiOhTsBgg0gJ6enoYO3YsAGD06NEaZzSfPXuGbt26ZXq2tW3btgCAPXv2aLSdf/HiBXr37p3j5jYfMzIywvTp0wEAXbt2xe7du9M1kbh16xYmTpyYbVvnVEePHoWPjw9CQ0M1lkdFRWH06NHYvHkzAODnn3/OU8x5YWVlhb///htSqRRz585Fr169cP/+fY1tEhISsG3bNtSrVw9r1qzJ0X5r1KiBdu3aITk5Gd26ddM4WD537hzGjRun0SwqvwwbNgwmJiYICAjATz/9pP7/T05Oxvfff69x9SWnhg8fjq1btyI+Pl5j+enTp3H8+HEA0BgpJ3X0pDt37mTb3yQrLVu2hJGREa5cuYKVK1eql79//x4DBgzAmzdvMnze999/D3Nzcxw9ehSDBw/Gu3fv1OtUKhUOHDiA/fv3azwn9WA/sxF78hpLTsydOxcSiQQjR47EqlWr0v3NhoSEYNasWdi1a1eeX4OIKFMizW9A9FnJj0nHkpOThS+++EI9+ZG9vb1Qr149QSaTCZUqVRK+/fZbAYAwffr0dPscPHiw+nmVK1cW6tatK8hkMsHe3l4YM2ZMlpOOZTaJUqpJkyap912qVCmhUaNGQv369YVSpUqpl+d0orDdu3ern2Nrays0atRIqFu3rmBgYCAAECQSSbbxFJR9+/YJpUuXVsdXvnx5oVGjRoKDg4NgZGSkjm/06NE53ufTp0+FChUqCAAEfX19oX79+oKdnZ0AQPjqq6+E5s2bCwCE06dPazwvs89IWplNciUIgrBhwwZBIpEIAIQyZcoIjRo1EkqVKiXo6ekJv/zyS64nHatTp44AQJDJZELNmjWFxo0bqz/zAIQ+ffqke46Hh4cAQChevLjg7OwstGjRQujevbt6fXaT5aWaMWOGxmemQYMGQrFixQQrKyvB19c30xwcPXpUKF68uDr3derUEZycnAQTE5MMP/fTp09XTw5Wr149oUWLFkKLFi2EFy9efFIsWf0/pbVkyRJBKpWqc9agQQOhYcOGgpWVlfo1ly1bluU+iIjyglcGiLSETCbDvn37MHPmTFSvXh0hISGIiIhA//79ERAQAENDQwAZj0CzfPlyTJ8+Xd1++/Xr1xg6dCguXLjwyZ0658yZg3PnzqFXr14wMTHBjRs38PjxY5QrVw6DBg3Cv//+C09Pzxztq0GDBvjxxx/h4eEBqVSKW7du4d69e7C1tUW/fv1w4cIF+Pr6flK8edW+fXuEhITgt99+Q8uWLZGUlITAwEA8ffoU9vb2GDNmDAIDA7Fw4cIc77NcuXK4dOkShgwZgtKlS+P27dtQqVSYPn06duzYoT7Tnt8jRfXu3RsnTpxAy5YtkZiYiHv37sHJyQkHDx5U95HIjfnz52PMmDGoXbs2IiMjERgYCABo3bo19u7dm2Hzlk2bNmHAgAEwMzPD1atXcerUqTy14Z8yZQr+/PNPODg44PXr13j69Cm8vb1x5coVVKxYMdPneXl54datWxg1ahQqVqyIe/fu4enTp6hatSq+//579O3bV2P7SZMmYerUqahWrRru3LmDU6dO4dSpU+phPT8llpwYOXIkAgMD8c0338DCwgK3b99GcHAwypQpg549e2L79u3o16/fJ70GEVFGJIKQzzPIEFGB6NChA/bv34/du3er20ST7lKpVChVqhSioqLw9u3bAp9TgYiIKCO8MkCkA549e4ajR49CKpVq1URKlHe7du1CVFQUHBwcWAgQEZFoWAwQaZGZM2emG27y/v376NixI+RyOTp27IiyZcuKFB3l1suXL/Hrr7+m61x66NAhDBs2DADU/xIREYmBzYSItEilSpXw5MkTlClTBpUqVUJUVJS6OKhSpQpOnz5daENu0qd7/PgxKleuDIlEgnLlyqFs2bJ49uwZXrx4AQBo164d/vnnH0ilUpEjJSKioorFAJEWWb16NbZv345bt27hzZs30NPTQ+XKldGpUyd89913bE6iY+Lj4/Hrr7/i0KFDCA0Nxbt372BsbIxatWqhb9++GDx4MGQyTgRPRETiYTFARERERFREsc8AEREREVERxWKAiIiIiKiIYjFARERERFREsRggIiIiIiqiWAwQERERERVRLAaIiIiIiIooFgNEREREREUUiwEiIiIioiKKxQARERERURHFYoCIiIiIqIhiMUBEREREVESxGCAiIiIiKqJYDBARERERFVEsBoiIiIiIiigWA0RERERERRSLASIiIiKiIorFABERERFREcVigIiIiIioiGIxQERERERURLEYICIiIiIqolgMEBEREREVUSwGiIiIiIiKKBYDRERERERFFIsBIiIiIqIiisUAEREREVERxWKAiIiIiKiIYjFARERERFREsRggIiIiIiqiWAwQERERERVRLAaIiIiIiIooFgNEREREREVUrooBX19fSCQSjVvZsmUz3Hbo0KGQSCRYsGBBtvvduXMnHBwcYGhoCAcHB+zevTs3YRERERERUR7k+sqAo6MjXrx4ob4FBQWl22bPnj0ICAiAjY1Ntvu7cOECunfvjr59++LGjRvo27cvunXrhoCAgNyGRkREREREuZDrYkAmk6Fs2bLqm4WFhcb658+fY9SoUdi4cSP09fWz3d+CBQvQqlUr+Pj4wN7eHj4+PvD09MzRFQUiIiIiIso7WW6fEBwcDBsbGxgaGsLZ2RmzZ89GlSpVAAAqlQp9+/bF999/D0dHxxzt78KFCxg3bpzGstatW2dbDMjlcsjlcvVjlUqFt2/fonTp0pBIJLl7U0RERERU4ARBQExMDGxsbKCnJ17XVaVSieTkZNFev6Dp6+tDKpXmaNtcFQPOzs5Yt24datSogZcvX2LmzJlwc3PD7du3Ubp0acydOxcymQyjR4/O8T4jIiJgZWWlsczKygoRERFZPm/OnDmYNm1absInIiIiIi3w9OlTlCtXrtBfVxAERERE4P3794X+2oWtRIkSKFu2bLYnyXNVDLRt21Z938nJCa6urqhatSrWrl2LFi1aYOHChbh27Vquz8x/vL0gCNnuw8fHB+PHj1c/joqKQoUKFXL1uoVBT6oHjy9bYtZi3xxt//PY6Ti67zhUSlXBBvaZmbt5NmrWrZHtdtHvotHHbVAhRPR50StpCPNO1XK0bULgKyRef13AEX2GapWEnrVJtpsJggDBPxxQCIUQ1OfDuLgxVp9eBpl+9j97Z/49h0UTlxZCVJ8PiZ4E/Uf2wf/G5+z7ddBXQ3E/6EEBR/X5CboVpG6e/fr1a7i5uiEmJgYVKlTAmbNnYGhoCAC4fv062rZpm9WuRFe8eHFRXje1ELC0tISxsfFn2ZpEEATEx8fj1atXAABra+sst891M6G0TExM4OTkhODgYOjp6eHVq1caB+RKpRLfffcdFixYgMePH2e4j7Jly6a7CvDq1at0Vws+ZmhoqP7Qf2zmseDcvZECdGbrSpxYuxAKhQIlSpXIctuo99E4efA0PPuPQ4tewwonwBya4lVdfX/O8YciRqJJpVTi977uOLnHHw2b1ct2+/0bDkJmYIBJW87CxLxUIUSYcz6eHw62/zj1SMRINN08fRhrfxoBZXQSZGWKZbmtoBKgeBiDRm290WPS3EKKMGe+a1FVff93f+3JLwD8Obo7njy/DUmFHPw4RsRDUAgY99c+2FZ3KPjgcmGC+4cc/3pSe3L84tE9zP+mHW5euIWm7dyy3f7knjOo7NQAwxdtK4TocueHlh9yvORsqIiRaNo0dxIO7DiCb6eMgEyW9aFF8J2HuB/0AIOmL0F9j3aFFGHOjGpaWX1fELSn4H7z5g3KlSuH3bt2Y8L3EwAAZmZmuHb9GmJjY1GyZEmNPpzbtm2Dra0tHj9+nO3/R2FLPfgW4yBcqVSqC4HSpUsX+usXpmLFUn6vX716BUtLyyybDH1SYy25XI67d+/C2toaffv2xc2bNxEYGKi+2djY4Pvvv8fhw4cz3YerqyuOHj2qsezIkSNwc8v+C1sX1G/9NQRBwF/z12S77aoFf0OpVKFB266FENnnQU8qRaN2PXFijz+eBIdluW3U2yjsWrMXTi2+1LpCQJs5unnCtFQZJF59le2Po/z+WyhiEuHWsXchRfd5aNK5H1RvEiBEJma5naAUgJBYlLevrXWFgDazrmqPSrXqY+ufOyFPlGe57c0LtxB0IQguHfsUUnSfh2ad+uDVi5fYtf6fLLcTBAHL5q6EeWkL1Gn+RSFFp/tKly6NHj16YNnyZeqzvQBga2sLOzs7WFpaqpc9ePAAW7dsxZAhQ7SuEBBbah8BY2NjkSMpHKnvM7u+EbkqBiZMmIBTp04hNDQUAQEB8Pb2RnR0NPr374/SpUujVq1aGjd9fX2ULVsWdnZ26n3069cPPj4+6sdjxozBkSNHMHfuXNy7dw9z587FsWPHMHbs2NyEprVMSpSG18Dx8PtzPZb//heUSmW6bVQqFf6avxprFvnBo/8YmJb8vKvV/ObaqS9KWlfED72m4NGdjM+URUa8wQ89pyAxUQWv/mMKOULdJpXJ8PW46Uh6Eo34088hZNCETRAEyB+8Q8LZF2j8pTcq1KwtQqS6y6lZa1Sr7wbh+ttMCwIhWQVcfwNJnBKdvv25kCPUfR1G/oSnD8Mx45tfEBcdl+E2N84HYcb/fkG1+m6o3UK7m1hom/J2tdDkq574ZdLv2Lt5f4YnDpKTkjFj/Bwc338SX4+ZCqks+xEH6QNfX1+olCp06NABz549y3Cb27dvo0P7DqhYsWKu+m8WNZ9j06CM5PR95qpkfPbsGXr27InIyEhYWFjAxcUFFy9eRMWKFXO8j7CwMI3e425ubtiyZQumTJmCn376CVWrVsXWrVvh7Oycm9C0WpOug5EkT8Di2Yuwc8M/6D7wa9Rp6ASJRIKbV25hy9878PzJM7TsOwrNewwRO1ydY2RSHIPm+sFv8iAMbT0Szh6N8UVXT5QpWxoxUbE4ufc0Tu07A2OzEhg01w+lrMuLHbLOqd28NXpO+hVbf52E6LBY6NuVgL6tKaAngfJdIpLvvkdyZBwatO4M7+9mih2uzpHKZBgwcxn8pgzHw0vnoVe6GATbYpAY6wNKFYRXCUB4ImRSGQbOWYWKjtk3iSNN5e1rY8CslVj/83D0dxkCjy7N4draGYbFjBARFoHDW47jVsAtVKvvhn7Tl/JANQ+6jZ8OpSIZP42ahnVLN6HbwC6o5lANimQFLp2+jB3r9iDqXRR6+/yqdc2DdEHFihVx7NgxtGnTBrUca6FLly7w7uqNUiVLISIiAhs3bcTBAwfh4OCAgwcPokSJEmKHTDpCImhTo7hPEB0dDXNzcwDa1WcgrWf3buLiP+tx69QBKJKSAAAyfX3UavElnL/qjfIO2vsDr619BtJKSkzAjeN7cXHvBoQ/vKteXsq6HJw79EbDtl1hbFZCvACzoa19BtJ6FRaCc7vX49KhHUiKj09ZKJGgpos7mnbpB7tGzbT2jIs29xlIpVQocOvsEZzdvQ6hNy6rlxubl4Brh15w/aoXSlhm3RFMTNraZyCtqNcRuLhvEy79uwUxb9+ol1ep0wiuHfuiVvPWkEq1t2mFtvYZSCUIAu5dPoMzuzcg6NxxCKqUK4lGJiZo3OZrNO/cF2Ur5WwwAjFoa5+BtN69e4c1a9Zg2bJlePTow99Z7dq1MXLkSPTp00erm8Gk/kZERUXBzMysUF87MTERoaGhqFy5MoyMjAr1tcWQ0/fLYkAE8vhYRL9JafNnVtoShsamIkeUPV0oBlIJgoDoyJdIiI2GYTFjmFuKO5ZxTulCMZAqWZ6I969fQKlQwKyUhVYXWal0oRhIK+ZdJOLev4XMwBAlrWx04ky1LhQDqZSKZLx/9QLJ8kSYmJdC8VJlxA4pR7S9GEgrPjoK0W9fQ08qRQlLaxgYav/Bly4UA6lUKhXCwsIQGxuLEiVKwNbWVmtPxqT1WRQDSiVw5gzw4gVgbQ00awbkcEz/wpTT96u9pz8+Y4bGprDQgQJAV0kkEphblIW5RVmxQ/ls6RsawaJc5ew3pDwrXrIMipfUjQNUXSSV6aO0jfYNR/05MTYzh7GZudhhfLb09PRQqVIlscMoenbtAsaMAdL22yhXDli4EOjSpUBe0t3dHXXr1k03Ie+ePXvQuXPnTy5ctf90KRERERGR2HbtAry9NQsBAHj+PGX5rl3ixPWJWAwQEREREWVFqUy5IpDRWfjUZWPHpmynY1gMEBERERFl5cyZ9FcE0hIE4OnTlO10DIsBIiIiIqKsvHiRv9tpERYDRERERERZsc7hsM453U6LsBggIiIiIspKs2YpowZlNnyrRAKUL5+yXT4zMzNDVFRUuuXv37/Pl+FZWQwQEREREWVFKk0ZPhRIXxCkPl6woEDmG7C3t8eVK1fSLb98+TLs7Ow+ef8sBoiIiIiIstOlC7BjB2Brq7m8XLmU5QU0z8CIESPw6NEjjBw5Ejdu3MCDBw/w559/YvXq1fj+++8/ef+cdIyIiIiIKCe6dAE6dizUGYgrVaqEM2fO4Mcff8QXX3yBxMRE1KhRA35+fujatesn75/FABERERFRTkmlgLt7ob5kgwYNcOjQoQLZN5sJEREREREVUSwGiIiIiIiKKBYDRERERERFFIsBIiIiIqIiisUAEREREVERxWKAiIiIiKiIYjFARERERFREsRggIiIiIiqiWAwQERERERVRLAaIiIiIiHJIqVLC/7E/Ngdthv9jfyhVygJ7rQ4dOsDLyyvDdRcuXIBEIsG1a9c+6TVkn/RsIiIiIqIiYtfdXRhzaAyeRT9TLytnVg4L2yxEl5pd8v31Bg8ejC5duuDJkyeoWLGixro1a9agbt26qF+//ie9Bq8MEBERERFlY9fdXfDe5q1RCADA8+jn8N7mjV13d+X7a7Zv3x6Wlpbw8/PTWB4fH4+tW7di8ODBn/waLAaIiIiIiLKgVCkx5tAYCBDSrUtdNvbQ2HxvMiSTydCvXz/4+flBED689vbt25GUlITevXt/8muwGCAiIiIiysKZsDPprgikJUDA0+inOBN2Jt9fe9CgQXj8+DH8/f3Vy9asWYMuXbqgZMmSn7x/FgNERERERFl4EfMiX7fLDXt7e7i5uWHNmjUAgEePHuHMmTMYNGhQvuyfxQARERERURasi1vn63a5NXjwYOzcuRPR0dH4+++/UbFiRXh6eubLvlkMEBERERFloVmFZihnVg4SSDJcL4EE5c3Ko1mFZgXy+t26dYNUKsWmTZuwdu1aDBw4EBJJxrHkFosBIiIiIqIsSPWkWNhmIQCkKwhSHy9oswBSPWmBvL6pqSm6d++OyZMnIzw8HAMGDMi3fbMYICIiIiLKRpeaXbCj2w7YmtlqLC9nVg47uu0okHkG0ho8eDDevXsHLy8vVKhQId/2y0nHiIiIiIhyoEvNLuho1xFnws7gRcwLWBe3RrMKzQrsikBarq6uGsOL5hcWA0REREREOSTVk8K9krvYYeQbNhMiIiIiIiqiWAwQERERERVRLAaIiIiIiIooFgNEREREREUUiwEiIiIioiKKxQARERERURHFYoCIiIiIqIhiMUBEREREVESxGCAiIiIiKqJYDBARERER5ZRKCbz0Bx5vTvlXpSywl5JIJFneBgwY8MmvIfv0MImIiIiIioCnu4CrY4D4Zx+WGZcDGiwEynfJ95d78eKF+v7WrVvx888/4/79++plxYoV++TX+CyLgWf3bsDWrjYkEkm+7VMQBDy8chblHerCyKT4J+0r9l0kQgMDIE+Ig2ExE1Su6wzTkmXyKdL89ezeTVzatwn6/z1WATizbRXqt/4aJuYl8+11IkIfQCKRwLJitXz5f4t5G4nQGwGQx8fC0NgUles4o3gp7ctxUmICbpzYhxtHd0P/v/etEATcv3wG1Rs0gZ5exhfvot+8xpvwJ6joUA96UmlhhgwgJb8PAy9CHh8HQ2MTVKvropX5BYBXYSE4/89G6OvpARIJBEHAoTXz4dK+B0pYWosdXqZi3kbiUZocV9XSHCsVybh97jgu79+i/p5QArjpfwCOTVtBKtPP6ulqCbExeP4gCJVrN8rxcz6FOr//fQ9ra34B4P3rF7i0fyvunz+W8jkGkKxSIeLJI0AQoFIpYV25Rr7+5uWH6LevEXz9w/dw9XrOMCtlIXZY6ahUKjy4eh7n9m6Cvr6+etmqVavQs2dPmJiYiBxhxl6+fAl/f3/ExMSgePHicHd3h5WVldhhZejt27fw8/PD9u3bIZPJoFAoxA4pb57uAs54AxA0l8c/T1nebEe+FwRly5ZV3zc3N4dEItFYlh8kgiAI2W+m/aKjo2Fubg5rAC8AVKnVAN2m/gnTkqXz7TWOrPod53asQaXajWDv6gE7Fw+Usi6f4+dHhNzH6c3LcPvMISgVHy4pSWVSODZrg+Y9h6NsFbt8i/dTxL1/g23TvsWjoMsoL5XiK6USJgBCAPwjkQBSGVp9MwFNvQflyw/Q+1fh+L2fJ8zLlIW9qydqunqgklNDyPQNcrWfiJD78N+0DLfPHIQiTY5lMikcm7WFey/tyfGtM4ex57dJiI+LwRdlLFDbxBgKQcDhN29wJy4O1hWqoN+sFbCsUCXdc1VKJX7t3xrx0VGo6dICDq4esGvc7JML1ey8eHQfxzcuRdCp9Pl1atEWnr1HwLqqduQ3KTEB2+dOwrUT+1Ha1BRf166NOLkcj9++xfXwcCQmK9C0Sz+0H+4jSkGVmRch93Fiw1IEnc4gx83bwqPPCFhryWf48e1r2PjzSLx78wqupqZwMzKCBMC5uDhcSEhAiVIW6Om7BJWdGma7L0EQsPTbbnj5OBh2jZujpqsn7J1bwNisRL7G/CLkPk5uXIpbGeS3VvO2aNlbe/KrUipxYOVcnN3xN4rJZPi6ShVYGxvjnVyO7Q8f4p1cDqcmnrh35RzMSpWBo5sHnJp4olpdZ+gbGIoW9/NH93B0/VIE+h9Il+O67l+iVd8RsK1qL1p8ab16GorVU4bj+aP7cKxVC194eUEmkyEoKAiHjxyBubk5Vq5cia5du4odqlpQUBDmzJ6NHTt3IDn5w0G1vr4M3l97w2fyZDg5OYkYoaaFCxdi0qRJUCqV6PjVV7C1tcXCRYsQFRUFMzOzQo0lMTERoaGhqFy5MoyMjHL3ZJUS2FtJ84qABknKFYKvQgG9gvlN8fPzw9ixY/H+/fscbZ/T9/vZFQMvAZwDMEwqBaxs8c3iHTDOpzPYcVFv8UfvlkhKjFcvs6xUHfYuHrBzaYnyNetmelARfPkMNvsOg20JJb5tpUSfJkBpU+BNLLDhHLD4qBTP30vR03c5qjdqli/x5lVCTBRWjfKG8sVTrFIp0Q5A2nf1GsAcAAsAeA0YC8++o/Lldf9ZOBUX925UPzY0MUWNhs1SCq/G7tleiXhw+TQ2TR0GmyxyHP5eil7TlqNGo+b5EnNe3Tz5L7bMGosulpb4rXp1VE5zmU8QBJx7/x7/u38fz6GHkct3wqJc5XT7uHr0H2yaOV79WCrTR5U6jeHo5gEHNw+UtqmQrzHfu3Qa66YMzTa//WaugH1jcfOrSE7C6h8G4emta1jydRf0btgQhjIZYhITUXn6dLyNj0f5EiXw9P171HRpiQGzVmR6FaYw3b90Gut+ykGOZ6yAncg5fnzrKlaM6wNnQwP8WbYsan90qTooMRGjXkTgQmIivpm3IUcFwYMrZ7Hq+/7qxxI9PVSq1QA1XT3g4OYJi/JVPunkw/1Lp7Hh5+zz22e6+PkVBAE7fpuEq4d2YpaLC0bUrg0zgw8nR+RKJTY/eICRp0/D0LwU3r2OUK8zLGaCms7NUMvNE46uLVE8H0+KZedOwCms/nEobMwVmec4SobBs1bAwblFocWVkdfPn2D+cG+UtSiNVStWoGnTphqfr8ePH2OSjw+2btuGjRs3olevXiJGm+Lw4cPo0rkTrM0VGOmlSJffP4/J8CJKhl2796B169Zih4s5c+Zg8uTJGP3tt/hx8mRYWlqmHK+VLKl7xcBLf+B4y+y38zwJWLnnJbxsaUUx4Ovri2nTpmkss7KyQkREhHr9li1b8PTpUxgYGKBBgwaYNWsWnJ2dM92nn58fBg4cmG55QkJCrv6jUouBSABmAB4CaKonRXn3L9F18rwc7yc7R1b9jtNbVmS4zti8JGo0doe9a0tUa9BUfZY2IuQ+Vn7bBV41k7F9tADjDE7YxMuBroskOHZXH0MW7xL17PXOuT8g9PheXFApkVUUMwH8DGD4kh2oULPuJ79u6tUBZXJyunUSPT1UdKgPe5eWsHf1SNecKCLkPpaP6gzPHOT4+F19DFuyW7Qcx7yNxG+9mqNrmdJY7+gIvUwObt4kJcH16jUkl6uEb1fsSbc+9erA66ehGT7fqlJ1OLh5wNHN45ObE714dB+Lh3fKcX6/XbZH1CsER9ctwfG1i3Fs+HA0r1ZNY90vR4/CZ/9+jWUm5iVR16M9HFw9ULWuM2QinFV9EXIfS3KR41HL9oh2BluRnIS53ZvDMSkBRytWhFEmhZRcpULrJ2EIlOlj4taz2eY19erAk9vXMlxf2rZiSmHg6pHr5kQvQu5j6Yic53fEUvHyCwCBJ/Zj04wxWNeqFfraZ34W/Wx4ODz27IESEqiU6ZteSCQSVHKsh1pNPOHUxLNAmxM9f3QP84Z2gqd9UvY5vmeA8Sv2iHqFYP5wbyAhChfPnUOZMhk3EVOpVBg0eDA2b9mC0NBQ2NjYFHKUHwQFBcHFuTFa2sux7dvM89ttsQQn7xniYsAlUa8QXLlyBY0aNcLPP/2Eab6+6uU6Www83gycz0FB6LYJqNQzbwFmQ2uKgR07duDYsWPqZVKpFBYWKW0AN23aBEtLS1SpUgUJCQmYP38+tm/fjocPH6q3yeiNjRkzRqMzBIBct4dKLQYuATD9b9k6AL/q6eF/C7bA2LxUrvaXmfiot/hrXK8Mv3TTksr01c2JHl09B3noadyao8zwj1e9bzlQy0cKM8e26Dp5fr7Em1tx79/gt+5NMVupwISP1oUDiE/zWAXAU08PZs7u+HL45Hx5/cN//YZbZw5nu10p6/IazYl2zP0B0XcO5jjH5o5t0f3HBfkSc26d3LgUp9cuQnizpiip/+FgJlmlwpPERI1tT7x9i6F376L/9KWwyeDgOvDkARxc9Ue2r2lsXhI1nVvA0c0zT82JNkwfg/e3cp7fkk5fovdPC3L1GvlFqUjG7G7N0N2uOpZ3755uferVgTdxcRk+37CYCWo0agoHVw/Yu7ijeCH159k4fQze3855jkvUEi/HgSf/xYZpo3GrenU4fvQD81Au13j8SC5HmydP0H7EZDi4eWa77+Cr57F7/k/ZbmdkUlzdnMiucfNsrxxumjEGUbnMb88pC7KNo6AsG9UVFaNf42SnThrL38vliExI0FjmGxCAbY8fIzkpKdv9lrYuV2DNifx8R+NN0IEc57h07XYYMHVhvr1+bjy9fwtzB3fAnl270LFjxyy3jYqKgk25cpg4cSJ+/vnnQoowvV49e+KS/w7cnK3INr+1J8vg3LIrNm7aVHgBfmTAgAE4deoUHj54AGmak1E6WwzwykAKX19f7NmzB4GBgTnaPvUA/dixY/D0zPhHILdvLLvX0lZW5sCA5kCHeoBLdUCaSYuEeQeAH7ZK8f3mc/na3yGnzu34G8dXzMFzQcDHr94ewIFCjyh7hsVMkJQYj56uAhb1A0pnc5w77wAwcasUE7ecFyXHv/dshq9keljj6KCx/FF8PKqdO1fgr5/anMjBrSUc3TyzbU4U8zYSM7u64dceSoxrm/3+U/M7Zcf5QjuQTuv2ueNYM3kIAn/4AXVsbTXWTTt4EGsCAvAqNhaJGVyB+phEIkGFmnXh4JbSTKVsAZ1VjXkbiVndcp/jH7eLk+O/xveFRXAQzlSqlG6dXlDQx13rClx2zYli3kZiTvfc53fytvOiDO7wKuwRfu//Bba3bQvvj65sLblxA9+ePp0vr2NYzAT2jZvBqYknHF0/rfCNfvsaP3dxzXWOZ+y+KMpneOvvP+HR5ZN4EhICmSxlLJV79+6hY+fOEAQB48eOxbBhw9TbDxk6FIcOH0ZYWFihxwqkdBYuX74c5nZX5Di/k7bJ8OzZc1haWhZ8gB+JiYmBhYUFfKdOxaSJE9XLp/z0EzZv2YKQkBDdKwbUfQaeI10HYgC63Gcg141kg4ODYWNjg8qVK6NHjx4ICQnJcLukpCSsXLkS5ubmqFOnTpb7jI2NRcWKFVGuXDm0b98e169fzzYOuVyO6OhojZs2exkFzN0HNJ0OlB0B9F8ObA8AouM1t+vTBFAqlAi9ESBKnG/Dn6CGnjRdIaDN5AlxEAQBm84DlsOBptNScn3nGZBRqdunCaBQKBFy42Khx6pUKvDm1Qs0KSFe4apUJCP46jn8s3gmZvdsiV/7t8H+Fb8iNOgKVMr0YyU/DLwIhSKl7W9OpOb30XVxPsORz5+gmIFhukIAAN4lJCDs3bscFQJASrOVJ3eu4+CqP/DHoC8xu0cL7Frgi/uXTkORJM9+Bzn0KK85DhTpe+JZKJrm9oe0AAkqFUJvXsaBFXPxe/8v8GsfD+z9cyYeXjsPpSJZ5/Ib+fwJAKCJdcGOdiVPiMONU4ewYfb3mPxVY/wx7GscXvcnnj+6h9x2Jwy+HpCnHAdfK/zvYQB4/fwxXJ2d1YUAAIwbPx4PHjxAcHAwfH78EZGRkep1Tdzc8PTpUyTl4OpLQfD390dysiJX+U1OVsDf379A48rM8+fPIZfL4ebqql529+5dzP3110yPG7WenjRl+FAAwMcnhf573GBBgRUCBSlXxYCzszPWrVuHw4cP46+//kJERATc3Nzw5s0b9Tb79++HqakpjIyMMH/+fBw9ejTTtngAYG9vDz8/P+zduxebN2+GkZERmjRpguDg4CxjmTNnDszNzdW38uVzPqqP2BKSgOgEICYBSPjomKTMf2e15fGxhR8YUg5+tGx0ulxRCUBMYkpuYxIzLgbUOY4TJ8dA+q8RMcnjYyGPj0NiXGyGzd/k8SnNacrksGVR6naJIn2GUYCfYXlCPOQJsUiMj4MiOf8OCvKaY7E+w4IgaNVn+GPyhHjI4+Mgj4+DMjkZ8gTd+wwX/ksKSIxL+WzL4+NyXQyk/mbpUo4/vsqXmKaJm1Kp1Bj+MnVbscZciYmJAZD7/Ip1ojQ1T2lzLJfLoVKpRIkn35TvkjJ8qPFHJ5uMyxXIsKKFJVfzDLRt++HalJOTE1xdXVG1alWsXbsW48enjGrSsmVLBAYGIjIyEn/99Re6deuGgICATC9Tubi4wMXFRf24SZMmqF+/PhYvXoxFixZlGouPj4/6NYGUD7w2FwS2JYGODYAO9QH3moBRJiNmRqb8vcPQ2DTjDQpYybLlcFOpwnsAJUSJIPf0pFKolEr80gPo4QJUzGYYa3WOTQo/x1KpDCVLW+JSVBQGZXDmurBUqFnnv87FnrCuap9l0xdD45QxtiNjAIscXNFNza+RSJ/hUjblES+X405EBBw+6ntUTF8fJYoVQ6xcDkUOf5SsKlWHg2vKCE0FNa9DXnMsxmcYAEraVEBAyF1RXjszNtUcUNPVAzVdPVDOzkljdCjDYjr2GbYuBwC49PIlOlZJP7RwfpHK9FG9njNqNfFELTdPlLHJ+29o6m+WruS4tE0FXLpyHkqlUt2efeH8+Wjdti0EQcD3EyZo9F28dPkyrK2tYWgozpCtxYunHN3nNr+F3Qwnla2tLfT19XHp8mU0a5YyQmLdunUxauRIbN6yBa9fvxYlrnxRvgtg2xF4fQZIeAEUswYsmhXKFYEBAwbky4zDH/ukScdMTEzg5OSkcRbfxMQE1apVQ7Vq1eDi4oLq1atj9erV8PHxydE+9fT00KhRo2yvDBgaGmb4R3kcQOr0IDsA/AEJ+s7+CyYl8qfhS2JsNNb6DM62A7FEIoGtXW1UruuMc9tXYfyXKoz/Mvv9bziXMu9A5TqZj8BUkOp6dcSx1b9jrQCM+WjdfABpx5ISAHTR04NRXRe0+d8P+fL6Jzb8iTvnjma7nWmJ0rBzaYmarh4oW9keCwa1goFMmW0hAKTkWCaTokodl+w3LgD123XH+k3L8GuNGjBLc4m6nJERrnw08taF9+/x7f376PbDHNhUq5luX3fOn8ARv8yL5lQGRsVQo2FTOLh5oqaLO8xK53zin2p1XSCTSbHhXM7aAqfmt2o9cT7DNV3cYVaiFJadPYvF3t4a6+Z06ICfWrdGlenT8fK/M20f+9CnImXUmvweojUjVfOa47ri5Lhhu+7YPPs73JfLYffR9/Dlj9q4P01KQuewMHj1Hw0HV49s9/046Ar2/jkz2+1k+gaoWt8VDq6eqOnaEiUsMx/lRdfyW7ayHSrUqIWlt26lKwa6Va8O14+aD/1+7Rp2hD6GQpF98zfTEqXg6NoStdw8YN+4GYrl09wk1es55ynH1euL8z3s2q4rzu3djMOHD+PLL1N+nGvXro0Xz5+n2zYmJgbr1q/H6NGjCztMNXd3d+jry7DhXM76DGw4lzLvgLu7e4HHlhEzMzN07doVy1eswLixY9XF+cIFCzBj+nSYl8y/SUtFoSctsE7CYvikYkAul+Pu3bvqqi8jgiBALs9521pBEBAYGJjn4bDqIGVo0TAA66VSOLp6okbj/BvL+PjaRZkWAvpGxVCtQVPYu7SEnUtLdcezqJfPseTYIQzzzH6EhSXHUia+EaNjKwAUL20Jh2ZtMPvMYXRUKVEpzbrqH227AMAzlQpD+o6CbY1an/zaMW9f48HlzDvGla1ij5quHrB39UA5u9oaZ/4cm7XF4qMHMdRD+3Pc6Mvu8N+4DBMeBGNFzQ9n5Q319NAgzVmcaIUCA+7eRbkqdmj8Zdd0Z+9VKhW2/jIRmSlhaa0+o12tniv083hGq3ipMnBqkbv81nb/UpROgUDKQWLjr3pi1Za/0K9RIzSqWFFj/Ypz59IVAgbFjOHUvDUcXD1h16hpgU/e9rHipcrAqXnucuzUQrwc127RFv8umYlvX0Tg34oV1LNnA0CDNPMNKAQBU169gqmpGVr2HAp9w+z7Gfy74pdM15mWLKMeWrR6gyYwKGaco3iLlyqDWnnIr5gzw7t07odtc3/ArocP0SVNgWVpbAxL4w/v++qrV9gTGgohi6t71pVrqIcWreSQ+Xw4n8KslAXqun+JxUcP5DjHdVu2E+0zXNGhLiraO2HCxIlo0qRJpgOQCIKAST4+iI+Px5AhQwo5yg+srKzg/bU3/jy2A0M9sh9NaOlxGbp6dxWl83CqkSNHYtOmTfhj3jx8P+Hj8QlJm+Sqz8CECRNw6tQphIaGIiAgAN7e3oiOjkb//v0RFxeHyZMn4+LFi3jy5AmuXbuGb775Bs+ePdOYua9fv34aVwmmTZuGw4cPIyQkBIGBgRg8eDACAwM1evHnhgDgNICWUimSS5ZBu9G+edpPRhJio3Fhl5/GMnMLazh/1Rv9Zq/G5F2X0XvaUjRo21XjR6R5z+F4/l6KroskiM+kLkode/n5eyma9cjbe88v7Ub9BFVpSzSTSnES6fvMRwOYCmA8gObd/ofKtRvny+ue2rJSo1OmVF8fNRo1x1ffTsUPm05hzF/78cWg8ahQs266CaLcew1HeA5zHP5eihY9h+dLzHlhblEWHcdOx1/Pn2HQnTt4mUGxfDMmBi2uXcOjZAV6/DQ/w2Y8t84cwYsQzSF5K9SsgzaDx+G71fsxZdsZfD1+Omq6uOe5EEjl2XtELvIrg0cv8fILAF59RsC6mgO8li3H9uvXofyvSVB8UhLmHj8OALA2M4OeRIKqdRpj+t5r6OnzO+q4ty30QiCVR59c5ri3eDnWNzREz6kLcTI+Du3DwhCSQafK0KQkfBUWhqOxcejx86IcFQKPAgPw6Lpmh1Kbag7w7DsSo5buwpQdF9D1+zlwbNoqx4VAqpa5/Ay7i/wZrv9FZ9Rx/xI9jhzBnzdvIlGheRJKqVJh58OH8PznHxial9KYn0Uq04d9o6bwHjsVvttO48f1h9Fx2A+o4tSgQGfbbtV3BMKjZDnLcZQMrfqIl2OJRII+P/6BsKfP0bxlS9y4cSPdNq9evcKQoUOxdNkyLF26FBUqFPxVwqz4TJ6MF1EydFucdX67LZbgRZQMk3LYIqOguLm5YdKkSfhh4kRM+eknREVFiRoPZS5XQ4v26NEDp0+fRmRkJCwsLODi4oIZM2bAwcEBiYmJ6NWrFwICAhAZGYnSpUujUaNGmDJlCho1aqTeh7u7OypVqgQ/Pz8AwLhx47Br1y5ERETA3Nwc9erVg6+vL1zT9EDPidShRashZcKxclXs0HPWXzC3yL/RGI6vXQT/DUtga1cbdv9NflW2StbtrVOlnYF4lFfKiAtliqe069twLuUsibbMQAwA0ZER2PzjEDx9dBc1pVJ0UiphAiAEwFY9PSQIQMu+I+HZb3S+DLUY8/Y1fu3tDiNjU3Xzn2oNmqjb+uZE2hmIM8uxtsxADABXD+/C3gU/QVAko5OFJWqbmiBZEHA4MhIB0dEobWGNAb/8lWHzIJVKhXmD2+NNeFiem//kVtoZiDPPrwz9Zi4XfQZiAEiMi8HG6WNx56I/ypUqhe516iA6MRH3Xr7EzYgIRMXHo/GXXdFl3HTI9DPpxFPI0s5AnGWOZywXfYZcAAi+eg4bp45CXGw0vjAzg6uRESQAzsfH40hsLIxNi6Pnz4tRI4ffaSvG98aTW9dy3Pwnt9LOQJxVfvtM1478KhXJ2L1gKi79uxUlixmjV7WqsDExwTu5HJsfPMDzuDjY1XPB4/tB0DcwLJDmP7mVdgbiTHOsJTMQAykTpa3yGYLX4U/h4uqKL7y8oK+vj6CgIOzeswcymQxLlizBoEGDxA4VgOYMxCM8Fenyu/S4ds1ALAgCZs6ciWnTpsHIyAjdunaFra0tZs6apXtDi+qgAplnQJulnWdgwFw/VK3vlq/jgQuCgDtnj6BirQZ5vnQcEXIfZ7Ysx63TB6FUfBjCUSpLabbSrMcwUWce/pggCAgJvIhL/2zAg7NH1FcImvcdhcbtesDcIncTw2Ul/OEdKJLkKGdfJ91Z/9yICLmPU5uX4dbpg1CkybHsvxy36Dlcq3KcEBOFq0d24cahnYgIvQ8JAKUgoO/0P+HYxDPTGVaj37zC8+A7n9T8Jy9ePLqPE5uW4ab/gXT5re3+JTx6DRd15uGMPL13E+f2bETg4V0QkDKSk0vnfnDt2BuWFQquc2ZevQi5jxMblyHoVPocO7X4Eh69h4s6M+7HkuWJuH5iPy7v3YyndwMB/Nef6PtfUMejPQyMimX5/FQJsTF4FHgBNRo0zfVZ/9x4EXIf/psyz697L+3KLwC8fhqKi3s34f65o3gb8QwSiQTJKhW+/2sPZAaGkMfHFVjzn7x4/ugejm5YhsCT/6bLcd2W7dCqz3BRZx7+mFKhQNC5Yzi3ZxMeBl5Uj4Qzd+5cDBgwAKVK5c+kpfklKCgIv8yZg+07tiM5+cMVI339lKZBk3x8RJ15OCPPnz/HqlWrsHXrVjx48ABKpZLFQCEo0sXAzGNZdz4WW+y7Nwi9EQB5fCwMjU1RuY6zaO3Xc2qK14ceA3OOPxQxkpyJffcGITcuQh4XC0MTU1Sp46L1Ofbx/NAu+I9Tj0SMJHsx7yLx6HoAEuNjYWRsiqr1nEVr+5tT37Woqr7/u7925xf4L8eBAerPcNW62p/jCe4fcvzrSe3Ocex/+VV/hus6i9pHIKd+aPkhx0vOhooYSfZi3kUi+NpFdY6r13fR+s/wqKaV1fe1/fDo1atX8Pf3R3R0NMzMzODu7i5qH4GcSj1RK2YxULFiRRgbF9xJB20RHx+PJ0+eZFsMfFIHYsob05Kl4eSeg6GFKM9MS5ZGbfd2Yofx2SpesgzqejC/Bal4yTKo25I5LiimJcugDvNboIqXLIP6nu3FDuOzZWlpiW7duokdhk4xMDCAnp4ewsPDYWFhAQMDgwKZVV5sgiAgKSkJr1+/hp6eHgwMsm4Ky2KAiIiIiD57enp6qFy5Ml68eIHw8HCxwylwxsbGqFChQrbNr1kMEBEREVGRYGBggAoVKkChUECpVGb/BB0llUohk8lydOWDxQARERERFRkSiQT6+vrQ1894kI6iJu/DthARERERkU5jMUBEREREVESxGCAiIiIiKqJYDBARERERFVEsBoiItNSLkPtih0BERJ85FgNERFrq+Po/EfU6QuwwiIjoM8ZigIhICymSk3Dv0incuXBC7FCIiOgzxmKAiEgLhd68jMS4WNw5z2KAiIgKDosBIiItlFoEBF87j6TEBJGjISKizxWLASIiLSMIgrp5kCJJjuBr50WOiIiIPlcsBoiItMyrsEd4Ex6mfnzn/HERoyEios8ZiwEiIi3z8cH/3QsnoVKpRIqGiIg+ZywGiIi0zMedhqPfvEJ48G2RoiEios8ZiwEiIi0SF/UOj29fS7f8NkcVIiKiAsBigIhIi9wL8IeQQZOgOxfYb4CIiPIfiwEiIi2S2SRjzx/c5mzERESU71gMEBFpCUVyEu5fOp3pes5GTERE+Y3FABGRlkiddTgzdy6cLMRoiIioKGAxQESkJT4eRehjwVfPcTZiIiLKVywGiIi0QNpZhzPD2YiJiCi/sRggItICH886nBnORkxERPmJxQARkRbI6UH+3QsnIQhCAUdDRERFBYsBIiItkF1/gVTRb17h+YNbBRwNEREVFSwGiChPFMlJeHL7uthhfBY+nnXY0NhUY72eVAaZvoH6MWcjJiKi/MJigIjy5FHgJVw7tlfsMD4LqbMOl7evjcG/rEKrfqM01hcvWQY+m06iaZd+kOkbcDZiIiLKNywGiChP7pw/jjvnT7D9ej6IeRuJwb+swuhlu1DTpSUgkaTbxtyiLDqNngqfzf6o4tQIce/fihApERF9bmRiB0BEukcQBNw5fwJvI54hIvQBrKvYiR2STnPv8b8cb2texgodv/2pAKMhIqKihFcGiCjXIkIf4G3EMwCcFZeIiEiXsRggolxLWwBw3HsiIiLdxWKAiHItbQHw5PZ1xL5/I2I0RERElFcsBogoV2Lfv9EYUlQQBNy96C9eQERERJRnLAaIKFfuXvRPN4LQnfPsN0BERKSLWAwQUa5kNFPu/ctnoEhOEiEaIiIi+hQsBogoxxTJSbh/6Uy65fL4WDwKvCRCRERERPQpWAwQUY49CrwEeUJchus4qhAREZHuYTFARDmW1QE/ZyMmIiLSPSwGiChHUmcdzszbiGd4+Ti4ECMiIiKiT8VigIhyJO2sw5m5nUWxQERERNqHxYAIlIpkvH/5HO8inkGpSBY7nM+SPD4W71+FIyEmik1X8klWVwU+bMN+AwWDn+H8JggC4qLe4v3rF0hKiBc7nM9ScpIc719HIPrta6iUSrHD+ewIgoB3797h6dOniI6OFjsc0mEysQMoSl49CcalvZsReHQXEuNTOmEaGZugjlcnNP6qN6wqVRc5Qt2mVCTj9pkjCNi7ASE3L6uXW1e1h3OHXqjr1RGGxUxEjFC33bmQfTGQOhuxaYnShRDR50elUuHB5TO4dGC7xvLot69xcvMKNG7bFSYlSokU3echLuodLh/cjkv7NiMyPAwAIJFIYO/SEq4de6NGo+bQ0+N5sk8Reus6zuxej+snDyA5SQ4AMCtZGi7tu6Npx54oVbacyBHqtri4OGzcuBFLly7FjRs31MubNWuGESNGoEuXLjAwMBAxQtI1LAYKyfldfji4bDZKlimFgSP64P7tBxAEATWd7LHFbzsu7duE1kMmomnXwWKHqpPiot5i/ZQheHInEI2bNMawP+fg3Knz8GjdEvt3HcDeRb44s3Ul+s9ZA4vyVcQOV+fEvn+Dx2lmHc6MIAi4c+EkGrf1LoSoPi/J8kRsmDEWt88ehcRQ86tZgIADq37H8Y3LMHjOKlR2aihSlLrtye1rWDtlKOTxsfD2/hod2v8CYxNjhIaG4u+//bBm0mA4NvFCzykLYGBUTOxwdY5KpcKuxTPhv/1vVKxUGT//NAWOtRyhUCjgf9If69dvwMmtq9F3yh+o79FO7HB10sOHD9GmTRuEhoai7ZdtMW7cOJQoWQIvX77Epo2b0LNnTzRu3Bj79u2DpaWl2OGSjmAxUAgu7duEA0tn4ZvRgzDup9HQ19eHZ902UKmUWLHlT4z8YRgWzV6CFfN/gczAEC4d+4gdsk5JSoiH36RBiH/7AjuPbkX9xvUglydh2sSZ+O7HsfjKuz0eP3qCwT2GYc0P/TBs0Q6YW5QVO2ydcmLjCiCHza2Or1/KYiCXVCoV1k8bjbsB/kDtUhDiFcDDNJf99SUQnC0hv/UeK7/vj1GLt8O2uoNo8eqiFyH3sXriQNSr7YRNmzfByspKY/2QIUPw77//on+/Adg0Ywz6TV8GPalUpGh1056lc3Bqhx/+mPcHhg4dqnGFpX379vCd5otRo0bBz3c0DIyKoZabh4jR6p4XL17Aw8MDxYoVQ+CNQFSrVk1jfd++fXHp0iV079Ydbdq0wenTp2FqaipStKRLcnUt1NfXFxKJRONWtmxZjfX29vYwMTFByZIl4eXlhYCAgGz3u3PnTjg4OMDQ0BAODg7YvXt37t+JlkqIicLB5XPQa3APTJwxAQYGBnj0IARPHz/F87BwBN99CAMDA0zwHY++Q3rh0Io5iI96J3bYOuXivk14+fg+1u9ejfqN6wEAAs5eQlxsHI4dOgkAqFS1Ijbt9YMMShxbu1DMcHWOSqnE+X82qh+bWhVPt03aZZHPn+DpvZuFEtvn4s65Y7hz/jiEWuaAZTFAksFGBlIIdUpCYSBg9yLfQo5Q9+3/cwYqVSiPf/b+k64QAFKaCrVv3x4bN23AnfPHcfvsURGi1F3hIfdxYssqzJkzB8OHD8+wqZWpqSlWr14Nr1atsO2Pn6BUKESIVHf5+vpCLpfj3wP/pisEUjVu3Bh79+3FnTt3sGTJkkKOkHRVrhtGOjo64sWLF+pbUFCQel2NGjWwZMkSBAUF4ezZs6hUqRK++OILvH79OtP9XbhwAd27d0ffvn1x48YN9O3bF926dctREaELrh/ZBUGlxLeTRqiXnTjon+b+SfX9kRNHQAIB147sKswQdZpKpcKlfRvRrlNbONT+cKb0+KGU9u3HD35o525lbYX+Q/rg5ol9SIiJKvRYddXtc8eQLE+EcWljuI1ujg6LuqTbpsGAxmj9S3tY17EBABz+mwVXbpzdvR6SEkaARTZNU6R6ECoa43HQVUSEPiic4D4DL588RPC1C5j4ww8aZ0pfv36N8PBwxMd/6EDcpk0bOLu44uLeDWKEqrPO7N4ASysrDBs+TL0sKSkJ4eHhePHihXqZVCrF1Kk/4+3LcNzOQT8kShEVFYUNGzZgyNAhsLW1VS9/9+4dwsPDNToQOzk5oWvXrlixYgWU7LhNOZDrYkAmk6Fs2bLqm4WFhXpdr1694OXlhSpVqsDR0RHz5s1DdHQ0bt7M/CzhggUL0KpVK/j4+MDe3h4+Pj7w9PTEggUL8vSGtE3QyX3waueBMpZl1MtOHvpQAJw45K++X7pMKXzRoRWCTuwtzBB12rP7N/Em/Cl6DuyuXiYIAo7/l+NL5y4jJjpWva57/65ITpLjzrljhR6rrrr473aYlDFF55XdUdWjOvSkGX9tWNpbwWtaW1RpWR3B185zFKccin3/Bg+vnYdgY5SzJ1gUg56hPq4f31ewgX1Gbpz8FyVKlkSnzp3Uy+7du4eqVaqiWtVq6NG9h8b233wzCMHXLiDmbeYnskjTteP70K9fX42Oq5N9JqNa1WqoWqUqDh48qF5er1491K1XD1eO8rcup/bt24f4+HgMGDBAvezt27dwquWEalWroXmz5khO/jA64aBBg/D48WNcvHhRhGhJ1+S6z0BwcDBsbGxgaGgIZ2dnzJ49G1WqpO+QmZSUhJUrV8Lc3Bx16tTJdH8XLlzAuHHjNJa1bt0622JALpdDLperH6etiqd4ac+oPDJ9Gdq3d1M/lifK0aq9F6rXrA6VUoWqdlWQmJAIo2IpBwJVqlfC4X+OaNV7+JiPZ8aXJ8VUpfqHz2Dkq0j879tB+GfbPrTt2BphoWFwrJNy1cDCsgyMTYyx47eJ2PHbRLHCzdZ3LaqKHcIHEqCiW+UPRYAEKGNnobGJgamh+r51XRuEnAzGBHft+5ykmuCuRflNZZzm69hQCpjrf3isn6btup4EKgPg+IalOL5haeHFl0s/tNSuHDs6OsLQ8MPn9Oeffobiv2Yqx44dw7Fjx+Dl5QUAqF495ft3xtcuhR9oLoxqWlnsEDSk5g0AQkNDsXLlSvXjyT6T0bZtW/Vjuxo1sGPHDq17D2lJJBm11xOPsbExbGxs1I9//+13vH37FgDw4MEDrFmzBkOHDgUA1LCrAQBo2rRp4QdKOidXxYCzszPWrVuHGjVq4OXLl5g5cybc3Nxw+/ZtlC6dMpTg/v370aNHD8THx8Pa2hpHjx5FmTJlMt1nREREuvabVlZWiIiIyDKWOXPmYNq0abkJXzRJ8iT1fUMjQwwaNSDTbeWJSRm3F6YsyRM/FIYWVhboP6Qv+g/pm247QRCgSObcDrkiAMrkD5ea9aR6aDv3q0w3VybxsnSeqNLcL2uccsuMklddcivtySMAcHFxwf79+wEAxYsXR61atTLdlnImbd5sbGxQoUIFhISEAAAaOzfW2DYxMREqlQqUc8nJyRAEQV2kpM2pnp4eGjf+8DgxMbHQ4yPdlatmQm3btsXXX38NJycneHl54d9//wUArF27Vr1Ny5YtERgYiPPnz6NNmzbo1q0bXr16leV+P66+037YM+Pj44OoqCj17enTp7l5K4VGqVDi+IETOWoyIQgCjh88AaWCB1O55X/kVI62Czh7CfI0xRnlTMTNcCQn5qyIenY5DBI9VrS5FpnDH+8EBRDPjpe59ejRIzx+/Fj9eNS3o9C3X194e3vjj3l/aAyGcfjQYUg5klCuyGQyHDzwoSmQoaEhFi1eBG9vb3Tt2hXTp09Xr4uPj8eJEzn7XaQPkpOT4e/vr37cqVMnjBkzBt7e3pg2bRrq1aunXnfo0CERIiRd9UlDi5qYmMDJyQnBwcEay6pVq4Zq1arBxcUF1atXx+rVq+Hj45PhPsqWLZvuKsCrV68yHO0hLUNDQ41LvmktPBOSy3dScB5cPY8/x/ZBwJlLcGnunOW2Vy5cxaP7IRg+by3sGzUrpAhzZkyzD81w5p/WnvwCwOrJQ7D2r43oObB7tpMFrftrI8pWrIof1h3RukvA45prZ47fvniGGT1aIPTUI9RobZ/ltnGvY/H8ylN0GeOLpp3TX5kRU9r8/nkuVMRI0tu1ZDZO7vwbqqrFgUz6ZKg9j4NBMWP8su8yDItlcfVABCObfGjyoU0HevHx8bC1tcXKFSsxe85sAICBgQFWrFiRbtuEhASsXbsWo0ePxrx58wo71Gyl/d7SphyvXLkSw4cPx5MnT1CxYkUAgIeHBzw80g8fun37dsTGxuLhw4eoWlW7mpNpa34FQYCTkxOWL1uOli1bqpfP+WVOhtuuWLEC7du3x7592te3SNt+eykPHYjTksvluHv3LqytrTPdRhCELC+5urq64uhRzSHcjhw5Ajc3t0yeoVuq13dF+RqOmDTqJ0SEv8x0u1cRrzFx+I+wrWaPGg2aFGKEus+92zcIvvsAc6f+nuWX99Z123Hwn0No3m0wv4xyoZR1OdRp0QbX113Fu8dvM90uOSEZZ+edgrFZCTT8olPhBfgZaN6lLySCHnDnPaDK4gDkTSIkYfFo0aWv1hUC2szY2BjDhw/HkiVL0v3epKVQKDBs6DDExsZixIgRmW5H6fXq1QsWFhbo368/YmJiMt3uzp07mOwzGZ06ddK6QkCbSSQSfPfdd9i3bx9Wr16d6XaCIGDqz1MRdDMoXX9MoszkqhiYMGECTp06hdDQUAQEBMDb2xvR0dHo378/4uLiMHnyZFy8eBFPnjzBtWvX8M033+DZs2fo2rWreh/9+vXTuEowZswYHDlyBHPnzsW9e/cwd+5cHDt2DGPHjs23NykmiUSCQbOWIz5Bga5evbBz424kJnxoDpCYkIhdm/bA27MHYuKSMHjWimzPbpOmqnUbo9OoKVi5aBVG9h+DoOu3NNY/fvQEU7+fjknf/gi3jr3g0r57JnuizHT/YQ4sbCrjyI8HcHfvLSTFfijwVUoVwi4+xuHJBxD1JBrfzFkFI5P0cxFQ5srYlMfg6YshiUyCJPAt8FauOcmbXAmERENy4x3sGjZBhyHfiResjpo2bRpat24N76+9MWPGDISHh6vXCYKAU6dO4asOX2HXrl3YuHFjpuO4U8ZMTU2xb98+3Lt3D54envjnn3/UHbQB4P3791j651J4eXqhfPnyWLNmjYjR6qYBAwZgxIgR+HbUtxg7dqxGqwwAuH79Ovr364/ff/8dv//+e4ZXZYgyIhFycR2sR48eOH36NCIjI2FhYQEXFxfMmDEDDg4OSExMRK9evRAQEIDIyEiULl0ajRo1wpQpU9CoUSP1Ptzd3VGpUiX4+fmpl+3YsQNTpkxBSEgIqlatilmzZqFLl/RjmWclOjoa5ubmALSrmVCq968jsPW3ybhzwR9mJcxhX8sOEokE927dQ9S7KNR0bo7u389GSSub7HcmAm1uJpTq6pE9+Pev3/Du5QtUs68OK2tLRL2Lwq3AWzAxL4GWPYbAo9dQrb0qoK3NhFIlxsVg5/ypuHZ8H/RkeihdzQISqQQxz6MR9yYGFRzqoNuE2bCtVlPsUDOkzc2EUt27cg5b//gJr8JCoWdiCMFIAokKUEXJIZMZoHnnPug4/AfI9A2y35kItLWZUKrk5GT4+Phg+fLlkMvlaNiwIUxMTBAaGoqQkBDUrFkTCxcuRKtWrcQONVPa2owlVVBQEIYOHYoLFy7A2sYa9nb2SE5OxrVr15CUlITu3bvjzz//VP9eaxttz68gCPjjjz/wyy+/4M2bN6hXvx5KlSyFiIgI3L59G+XKlcPs2bPRt692NdNMKzXHUVFRMDMzEzkaAnJZDGgzbS8GUkU+f4KL/27Hm/AwAEAp6/Jw/tIbluW1d3g1QDeKAQBQKhS4e9Eft88fR3xMFAyLmaBaPWfU9WgPA8McjuMuEm0vBlJFv3mNgAPbEBEaDKVSAfMyVmj4RWeUt6uV/ZNFpAvFAJDyY/8wMABXj/+L2PdvIDMwRMWateHc5msYF9fuH05tLwZSRUVFYf369bh06RISEhJgYWGBrl27wt3dXWtPFqTS9oPVVNevX8f69evx/PlzyGQyODg4YNCgQVk2K9YGupLfxMREbNu2DSdOnEBsbCxKlCiB9u3bo3379pDJPqk7aIFjMaB9WAxQjuhKMaDLdKUY0FW6UgzoMl0pBnSZrhys6irmt+CxGNA+bJxORERERFREsRggIiIiIiqiWAwQERERERVRLAaIiIiIiIooFgNEREREREUUiwEiIiIioiKKxQARERERURHFYoCIiIiIqIhiMUBEREREVESxGCAiIiIiKqJYDBARERERFVEsBoiIiIiIiigWA0RERERERRSLASIiIiKiIorFABERERFREcVigIiIiIioiGIxQERERERURLEYICIiIiIqolgMEBEREREVUSwGiIiIiIiKKBYDRERERERFFIsBIiIiIqIiisUAEREREVERxWKAiIiIiKiIYjFARERERFREsRggIiIiIiqiWAwQERERERVRLAaIiIiIiIooFgNEREREREUUiwEiIiIioiKKxQARERERURHFYoCIiIiIqIhiMUBEREREVESxGCAiIiIiKqJYDBARERERFVEsBoiIiIiIiigWA0RERERERRSLASIiIiKiIorFABERERFREcVigIiIiIioiGIxQERERERURLEYICIiIiIqomRiB0Da782LZxqPk+Vy6BsaihTN50elVCIk6IrYYXzWYt5FajxOiI1GMVMzkaL5/AiCgCd3b6RbJpFIRIro8xMdHY1Tp06JHcZn7fbt2xqPlUolpFKpSNF8fuRyOfz9/cUOgzIgEQRBEDuI/BAdHQ1zc3MAgINzC7Ts+T/UaOAmclQZi377Gg+vB0AeHwdDYxNUq+cMs1IWYoeVTvD1izi5aQXuBJxG2o+JkbExXNr3hGefYTAtUVrECDMXk5rjhDgYFkvJcXEty3GSPBGnt/+Ni3s24M2rFxrrKtWsA0hlqNHADY5uHihn5wQ9Pe25kKcL+QWA5w/v4sTG5bh56iAUCoV6uZFRMTRs3Rmteg9FGdsKIkaYuei3rxF8LQCJ8bEwMjZF9fra9z2hUipxbt9WnNm1Ds8f3ddY5+DggFGjRmHIkCFaeUD18uVL+Pv7IyYmBsWLF4e7uzusrKzEDiudx48fY+7cudiwYQNiY2PVyyUSCbp164aJEyeiXr16IkaYOV3J8Y4dO7BgwQKcO3dOY3mFChUwdOhQjB07FsbGxiJFlzldyW9kZCR+//13rF69GpGRH07MREVFwcyMJ2W0wWdXDCz93//w14kTuP7oETqP/gnuXQeKHZpa+KN7OLZhKW74H4RCoVQvl8mkqOPeFl59RsCmqr2IEX5weuc67Fo4DbWtrTG6USN0tLeHQqlEjcWLES2XAwAMDI3wxcAxaNz2axQvWUbkiFOEP7qH4xuW/nfwp5nj2i3awlNLchwfE4VVEwbgefBt9LKzwzAnJziVKQOFSoXjT59iyY0bOBEWpt7erLQlHFxbwtHNEzUaNoGBUTFR4taV/ALArbPHsN53FMqZm2OUqyt61KuHZ+/fw3P5cpQvUQLPoqOh1JNh+Py1qOyoPQdTzx/dw5F1SxHofyBdjuu6f4kv+o2ArRbkWJGchL99x+Dm6SPo2LEjRgwbBhcXF0gkEly8eBHLli/H7j170KFDB2zbtg0GBgZihwwACAoKwpzZs7Fj5w4kJ38oEPX1ZfD+2hs+kyfDyclJxAg/uHz5Mtq2bQt9fX0MHTIE/fv1g7W1Nd69e4dt27fjz6VLERYWhs2bN6Nz585ih6umKzkWBAHfffcd5s+fDw8PD4wcPhxeXl6QyWS4ffs2VqxciY2bNqF27do4ePAgSpUqJXbIAHQnv0BKMevl5YXXr19j0MCB+GbwYJQpUwZlbWxYDGiRz64YODdrFpyrV8ekDRvw+969GDBtMep5tBM7PNwNOI2/pwyFjbkC37ZSok8ToLQp8CYW2HAOWHxUivAoGQbOXIGazs1FjTXQ/yD+/mkkxrm64vcvvtA4Iz3D3x8/nzypsb1EIkEFh7pwdPWAYxMPWFexF6V5wL1Lp+H341DYlMgix+9lGDBrBewbi5djlUqF5WN7I/L+TRzp1AkNy5bNcLulgYEY+VGuAUDfwBDV6rvCsYknHF09UMLSuqBDBqA7+QWAsLs3sGRUd3SoaY9NvXvDUPahRaT32rXYefOm+rGeVAqPHt/AuU1nWFeuIWrTljsBp7BqcvbfE9/MXgEH5xaixQkAm+b64PKhXdixbRs6dOiQ4Tb//vsvunh7o3evXljz99+FHGF6hw8fRpfOnWBtrsBIL0W6/P55TIYXUTLs2r0HrVu3FjXWsLAwNGjQANWqVcO/+/ZleCAql8vRt18//LN3L06dOgUXFxcRItWkSzn+9ddfMXHiRCxZvBgjR4zIcJtr167hizZt4OjoiJMnT4p+hVaX8hsbG4uGDRsiOTkZx44cQeXKlQH8d7xWsiSLAS2Sq2LA19cX06ZN01hmZWWFiIgIJCcnY8qUKThw4ABCQkJgbm4OLy8v/PLLL7Cxscl0n35+fhg4MP3Z+4SEBBgZGeX4jaRtJlTRwgLtGjTAtZAQhMQlwmfTCVH/gMMf3cOCYZ3haZ+E7aMFGGfQ3D5eDnRdJMHxewYYu3y3aGdXBUHAL729UL+YPvb36pXuwCgqMRGV5s/H+8TETPdR0soGjm6ecGziiWp1nSEzKPj+BeGP7mHRsM7wrJmDHN81wGgRc3z/8hks/64/DnXujNaVKmW57Ze7d+Pg48dZbmNb3RGObh4F2pxIl/ILAKsmDobw+B6ujR2rUQgAwM3wcNT5448Mn1fapjxquXnAqYknqtdzhky/8M5mP390D38M6ZTj74nvVu4R7QrB62dP4NvdPcuDqFTLly/H8JEjcf/+fdSoUaOQIkwvKCgILs6N0dJejm3fZp7fboslOHnPEBcDLol6dnXcuHFYv3497t+9i9KlM2+OmZSUhMYuLrCxscGBAwcKMcL0dCnHsbGxsLW1xcABA7Bg/vwstz127BhatW6NAwcOoG3btoUUYXq6lF8AWLp0KUaPHo3bQUGws7NTL2cxoH1yXQzs2LEDx44dUy+TSqWwsLBAVFQUvL298b///Q916tTBu3fvMHbsWCgUCly5knnnSD8/P4wZMwb372u2Ny2bydnSzKQtBj5W2akBXNp1g6NbS1Gas6ybNhpvgw7i1hxlhn+8qeLlQC0fKUo5fYl+UxcWXoBpPLh6Hn+O7QP/gQPR4qMD1Xnnz+NGRAROP3mCx+/f52h/BsWMYdewKRybeMLBteDyv37aaLy7lbsc9/lZnByv8RkC4cFN3OytWWy9jIvDd6dPa2wbk5SEvSEhOd538VIWcHTzgIOrB2o0bALDYvnTzlWX8vsm/Clm9XTHX127YrCzs8a6syEhCIqIwG8nTyL07dss92NkbAr7xk3h1MQLjq7uKF6yYPvH/D11NN4EHchxjsvUbocBvuLkeNeS2bh2aCeePw1DsWIpTdbev3+vPhht27YtSpYsCQBITExE+YoV0bdvX8ybN0+UeAGgV8+euOS/AzdnK7LNb+3JMji37IqNmzYVXoBpxMXFwdbWFsOGDsUvc+aol1+6dAkPHz6EpaUlvLy81Mv9/Pww6JtvEBwcjKpVq4oRMgDdyvGKFSswYsQIhD56hAoVUvoNKRQKbN++HYIgoGnTpurlgiCgQaNGsLW1xb59+0SJF9Ct/AqCgFq1aqGmvT12bN+uXn7nzh2cv3AB/xsyhMWAFsn1aEIymSzDA3Vzc3McPXpUY9nixYvRuHFjhIWFqf+oMiKRSHJ98J/Vvj6ub0KDriI06GpKc5aadVCriScc3TxgU7Xgm7NEv32NG/4H8WuPrH/gAcDYEBjlpcTErQcQM/onUQqXuwGnYVuiBJpXrJhu3fGQEBwIDs7V/pIS4hF05giCzhxR5z/lqkH+NSeKefsaN0/lPscdvy38HAuCgHuXTmOWi3O69x6bnIyN9+590v5j3r7Gxf1bcXH/1nxrTqRL+QWA+1fOQgKgR9266dbtuHkTC8+cydF+EuNjEeh/CIH+hyCRSFC5Vv2UqwZNPfO9OVH029cI9D+Qyxz/i6/HiJPjewGn0NX7a3UhAAA/T52KxUuWAABGDB+OP/+7b2RkhG5du+LAgQOiFQMvX77Ejp07MLd71gdRQEp+R3gqMGnbdsxfsACWlpaFE2Qaly5dQlRUFPr07q1e9vbtW7Rt1w5v376FVCrFjevX4ejoCADo3r07/jd0KA4fPowR2VypKSi6luNDhw6hRYsWGscmy5Yvx+gxYwAAX7RqhcOHDgFIOa7o26cPfpg4UbRRsnQtv8+ePcOdO3cwa8YM9TKFQgHvbt1w9+7dQo+Hspbr9gTBwcGwsbFB5cqV0aNHD4RkcdYyKioKEokEJUqUyHKfsbGxqFixIsqVK4f27dvj+vXr2cYhl8sRHR2tcQOQrhBISxAEPLkTiH//+gO/DmyHP/7XEY9vB2b7Wp/i4fUAKBQpbX9zok8TQKFQ4uH1gAKNKzOJcTGwMjEtkC+71PwfWPUHfhvYDvOGdMSTO4GfvF9dyrEyOQnJyUmwKoSRKZKT5Lh70R87/vgJ07ybwO/nkXj3MjzX+9Gl/AIpn2FTIyOY5OPwt4IgICToKvau+A2z+rbB70O64Mndm9k/MYeCr+Utxw+uXcy3GHIjIS5GY9SSuLg4rPzrL/Xjv1atUn8nA4ClpSWioqIKNca0/P39kZysyFV+k5MVog2DmJqrtDn2W7sWb/+7mqVUKrFw0SL1umLFisHMzIw5zoWoqChYfXSQPC9Nc6EjR4/i1q1b6sdWlpZQKBSIj48vtBjT0sX8Apqf4QMHDrAQ0FK5ujLg7OyMdevWoUaNGnj58iVmzpwJNzc33L59O12bxsTEREyaNAm9evXK8jKQvb09/Pz84OTkhOjoaCxcuBBNmjTBjRs3UL169UyfN2fOnHT9F3KibKXqcGzigVpunqjkWA96BTzknTw+DgBQpnjOtk/dLjEuNusNC4ihsQmexccX2NkPq0rVU9q3N/FEJYf8yb88IW85lscXfo6l+gaQyWSITEgo8NeS6Omhcq0GKVcG3DxhWaFKnv5PdSm/QMpnOE4uR0JyMorp6+fbfm2q2KFWE084NfVEpZp18vW7I/G/XOnK94SRsYnGEIEmJibo17cv/lq1CgDQp3dvje/9N2/eiNocICYmBkDu85u2oClMxYunBBAZGQkLi5ThZPv07o1p06cjOjoaenp6GDZ0qHp7uVyuHl5SLLqY47SfYQAYPmwYJk6aBABo3rw5atWqpV4X+eYNpFKpxtWwwqSL+QWgkePWrVujatWqePTokSgxUeZyVQyk7Tjj5OQEV1dXVK1aFWvXrsX48ePV65KTk9GjRw+oVCosXbo0y326uLhojIDQpEkT1K9fH4sXL8aiNGc+Pubj46PxmtHR0ShfvnyG29pWqwnndl3h6OaBMjaFO6a4obEJACAyBrDIwW9hZMrfO4xMTAswqszZNWyCk1tW4eKzZ3D9KJ+u5cvDQCrFlfBwPMvhF4xUpo+qdRvD0c0TDgWUf8NiecuxoXHh51gikaBGAzesv/8A4+rX1zg4N5bJ0P6/0RZSJSgUOP70aY73b2RiCvvGLeDYxBM1nVvAxLzkJ8esS/kFgBr13aBUqbD9xg30a9hQY10HBwdYm5lh2fnzePLuXZb7kcr0UaO+S0oB0MQTpa3LFVjMRv/lSle+J2o0bIrtO3Zi/rx5MPzvCszsWbNQ/7/x7r/++mv1tklJSdi2fbvGssKmPjDJZX7FKmAaN24MU1NTbNq8GTOmTweQcnXln927ce/ePVhZWaF+/frq7Xfs2IHk5GSNfgSFTddy7OXlhXHjxiE8PFw9yMnYMWNgbmYGQRDS5XLjpk3w8PAQbTASXctv+fLlUaNGDWzavFk92pihoSG2bdmCU6dOYfyECaLERRn7pBmITUxM4OTkhOA07ciTk5PRrVs3hIaG4sSJE7n+IOrp6aFRo0Ya+8yIoaGh+kfoY6WLF8eX9erhYUQE7r+PwYRVewv8CkBmqtVzhkwmxYZzSozLwSAEG86ljCderZ5z9hsXALtGzWBhXQ6/nTuPnd27aRysTmnRArFyOSovWJDlPkzMS6Kmizsc3Txh37gZjEwK9myVruXYrUs/rJr4DU4/f44W5T4cYFqbmmJfp04a236dg85qZWwrwsEt5WpXlTqNIJXl39lwQPfya1G+MuwbNcWCM2fQq149yNL87XvWqAFbc3P4ZDLqimmJUnB0bQmnJp6o2bhZoR1sV6+ftxzXqC/OUJLNOveB/3Y/bNiwAYMHDwYAlClTBsOGDUu37aZNm/Dy5UvR2rIDgLu7O/T1ZdhwTpHj/Orry+Du7l7gsWWkePHi6NevH/5atQrfT5ig/h11d3dPF5NCocDCxYvh6ekJe3vxRvDStRz369cPPj4+WLR4sbqTtoGBAYamueKS6uzZs7h06RL27NlTyFF+oGv51dPTw/Dhw/HDDz/g8ePHqPTfgCT169dHtWrVWAxomU8qceVyOe7evQtr65SOiamFQHBwMI4dO5blcGiZEQQBgYGB6n3m1qEpUxCxahWq29jgwoMHaPvNeNEKAQAwK2WBOu5tsfioFPHyrLeNlwNLjklRx/1L0Sbx0tPTQ+vB47H77h34njyZrg/G0suXEZlBm0mrStXh0Wsovv1zG6bvuYTeP/6Bui2/LPBCAEgZQad2C93Jcc3GLVC5Zh10PXAQtz66TJ3W+jt3sOvhw3TLJXp6qFK7EdoPm4hJ645g8qYT6PztT6jewC3fCwFA9/ILAF79RuHmixcYtG0bkpVKjXUzjh7V+FxLJBI07dgL363YiTl7L6HflN9Rr2XbQj3rblbKAnXdv8xVjuu1bCdajstWrIpGX3TEqDFjcOLEiUy38/f3x8hvv0X37t3VnV3FYGVlBe+vvfHnMVmO8rv0uAxdvbuK0vEy1fjx45GYmIhOXbqom4h8TKFQYMjQobh27RqmTJlSyBFq0rUcm5ub47vvvsOvv/2GdevWZbrdnTt30K1HDzRq1Ajt2ok3Z5Gu5RcABg4cCBsbG7Tr0AHh4bnvr0aFJ1fFwIQJE3Dq1CmEhoYiICAA3t7eiI6ORv/+/VN6iXt748qVK9i4cSOUSiUiIiIQERGBpKQk9T5Sq/FU06ZNw+HDhxESEoLAwEAMHjwYgYGBGZ5hyolXUVHwmjEDP2/Zgi+/GY/GbcW7NJ3Kq88IhEfJ0HWRJNM/4tTxw8OjZPDqM7xwA/xIo9ad0H7IBEw/dQot/Pyw/fZtJCkUiElMxNyzZ9XbyfT14dl7GH7c4o9J6w6jw7CJqOLUUJTiy7PPCIS/z2GO38vg0Vu8HOtJpRj4y18wsLKBy9ZtGHPyJO6+eQNBEKBUqXDsyRN03rcP/Q4fVj/HyMQUdVu2Q+8p8zDjn8v4dslWePYaCqtK1QplZAtdyi8AVK3TGL1+/AObrl9H/QULsOriRcTK5bj38iV2BQXBzsICpUxMYGBohNELN6LnD7NQpVZ9UU8cfNEvd98TrfqKm+Nek35BFaeGaN22LfoPHIiAgACoVCqoVCpcvnwZAwcNwhdt2sDV1RVr1qwRNVYA8Jk8GS+iZOi2OOv8dlsswYsoGSal+Z0SQ9WqVbF3715cvXoVderVwx/z5qnbX8fFxWHNmjVo5OyMdevXw8/PT7QzwGnpWo6nTp2KQQMHov/AgejUuTOOHj0KpVKZMurbvXsYN348XNzcULp0aezbtw8y2Sc1pvhkupZfc3NzHDp0CFFRUahbvz5+njoVYWFhWQ70QuLI1TwDPXr0wOnTp9WdmlxcXDBjxgw4ODjg8ePH6tnlPnby5En1F5W7uzsqVaoEPz8/ACkTq+zatQsREREwNzdHvXr14OvrC1dX11y9kbTzDFR1aoCWPYfAqVmrXO2jIKWdgXiUV8qoIWWKp7Tr23Au5UyftsxAnOrWueM4sXE5HgVdBQDoSSRQCQL09Q1Q/4uOaDNwbKHNfpsTaWfIzTTHWjJDLpAy6s3xjcsRsG8LYqLeQe+/YXEFANYVqkLP0BBV6zrD0c0DVWo3KtQJsDKia/kFUoYVPr5hKe5c9IcgCJBKJFAKAmQyGeq6t0Xr/qNgU0W8ibA+lnYG4qy+J7RhBmIAUCqScWLrGpzdsxGR4U/V7alVKhUqVqyI4cOHY9y4cTAwEPezmyrt7K0jPBXp8rv0uPbM3prq7t27mDVrFrZv346kpCTIZDIoFAoAwJdffgkfHx80bdpU5Cg/0LUcC4KAv//+GwsWLEBQUBAkEgn09PSgVCpRpkwZfPPNN5g0aVKm8xgVNl3LLwCEh4dj1qxZWLduHWJjY6GnpweVSsV5BrRIrooBbZa2GFh4JueTNBWm8Ef3cGzDMtzwPwCF4kPTBZkspVmFV5/hos7ampnwR/cwd8CX6sdzDt4olOY/eRH+6B5ObMw8xx69tS/HiiQ57l06g9WTh6iX/eH/EBKJRJTxrLOii/kFUiYim9njw8HznH2XYFbKQsSIMvf80T0cXb8M10/+my7H9Vq2Q6u+w0WbeTgzKqUS96+ex5Jx/dTLFAoFpCJeaclMUFAQfpkzB9t3bEdyskK9XF8/pVnFJB8fUWdtzcyrV69w9OhR9OnTR71MW3++dTHHgiDgwoULaNLkw9idCQkJMDIyEjGqjOlifoGUEZEOHjyI7t27AwCLAS3CYkAEMe8i8fB6ABLjYmFkYopq9ZxFbV+dE2OaVVHfn39au/MLfMixPD4Whsa6keNxzXUnx7qe3z/PhYoYSc7EvIvEg2sX1d8TNeq7aH2ORzb5cHVY239aXr16BX9/f0RHR8PMzAzu7u6itq/OqbQnCJjj/Mf8FrzUHLMY0B4sBihHdK0Y0EW6VAzoIl0rBnSRLhUDukqXDlZ1EfNb8FgMaB9xBswlIqJsJf43aSEREVFBYTFARKSljm1aiWR5NuMIEhERfQIWA0REWurqsX24f/W82GEQEdFnjMUAEZEWehkWgldPQxF07rjYoRAR0WeMxQARkRZKLQJunT/BjoxERFRgWAwQEWmhW/8VA+9fvcCz4LsiR0NERJ8rFgNERFomPjoKj25eUT++de6YiNEQEdHnjMUAEZGWuRNwCirlh9mH2W+AiIgKCosBIiIt8/HB/5O7NxEV+UqkaIiI6HPGYoCISIsoFcm4fdE/3fLbF04WfjBERPTZYzFARKRFHt28ioSY6HTL2VSIiIgKAosBIiItEpRJZ+F7l89yNmIiIsp3LAaIiLTIrXMnMlyelJjA2YiJiCjfsRggItISqbMOZ4ZNhYiIKL+xGCAi0hLZHexzNmIiIspvLAaIiLTErWyKAc5GTERE+Y3FABGRFvh41uHMcDZiIiLKTywGiIi0wO2L/hqzDmeG/QaIiCg/sRggItICt85nPIrQx57cvYmoN68LOBoiIioqWAwQEYkss1mHM3M7h4UDERFRdlgMEBGJLO2sw/U8voRbh+4a64uXLI0u3/6I4iVLA2BTISIiyj8ysQMgIirqbp0/gXoeX+LLgaNhU8UOxzb/pbFeKtOHZ49v0KxTb5zZsxGnd65HslwOfUNDkSImIqLPBYsBIiKRteo9VH3WPysGRsXURYFSqYA+WAwQEdGnYTFARHkmCAIkEonYYei8nBQCaRkYFSugSIiIqKhhnwEiypPE+FjczUWnVyIiItI+LAaIKE8eXD6LG/4HxA6DiIiIPgGLASLKk9vnj+POhZxNlEVERETaicUAEeWaSqnEnQv+iH3/BmH3boodDhEREeURiwEiyrWwezcR+/4NgJQrBERERKSbWAwQUa6lLQBucwIsIiIincVigIhyLW0B8CLkPt5GPBcxGiIiIsorFgNElCtvI57jRch9jWW8OkBERKSbWAwQUa5kdOB/58IJESIhIiKiT8VigIhyJaMOw8HXLyIxPlaEaIiIiOhTsBggohxLjI/Fw8CAdMuVyUl4cPmsCBERERHRp2AxQEQ59uDyWSiTkzJcxyFGiYiIdA+LASLKsawO+O9c8IdKpSrEaIiIiOhTsRggohxJnXU4M7Hv3yDs7o3CC4iIiIg+GYsBkcTHRCMu+r3YYRDlWNjdG+pZhzPDpkJERES6hcWASO4FnMLdi/5ih0GUY7dzMHwo5xsgIiLSLSwGRHLr/HHcOsex2QsS26/nr5wc6HM2YiIiIt0iEzuAoiYq8hUuHdyJG/6HIAgCjqz7E85fesO8jJXYoX0WBEHAw+sXcef8CYTduwnb6o6oVs8Zjm6ekMr4cc+rjGYdzsyd88fRtEu/Ao7o8/b+VYTG46TEBCTJE2FgaCRSRJ+XhIQEbN++HZcuXUJiYiLKlCmDrl27okGDBmKH9tl4+PAhNm7ciGfPnkEmk8HR0RG9e/dGyZIlxQ7ts6BQKLB//36cPHkSsbGxMDc3R/v27dGyZUtIJBKxwyMdwysDhST23Rus9R2NaV2b4rDfQiiSk6BUJOPI2kXw9W4Kv6mjEPMuUuwwddqts8fwa/8vsHRsb9w9+y/C7l5H6NXj+HvKcMzs3gzn9myAIAhih6mTctP85/Z5XvHKq9Bb1zF38Fc4uW2NxvL4mCj4dGiEf1cvgEqpFCk63adUKjF9+nSUK1cO/fv3h7+/P27evIm1a9eiYcOGcHZ2xvnz58UOU6cFBwejTZs2qF69OhYsWIDr16/jwsULGD9+PGxtbTF8+HDEx8eLHaZOW7lyJSpXrozOnTvj4MGDCAoKws6dO+Hp6QkHBwfs2bNH7BBJx7AYKARRka+wYIQ3Qm+cw9hpI9G5bwf1uq96t8f4Gd/icdBFLBj+NaIiX4oYqe66uH8r1vw4FNWrWmP9vjVYvPYPKJIV+HbiMOw5vQMtvVywY97P2L98rtih6qSgs0fU902sTNOtN7Uurr4ffO08ZyPOg7sBpzF/VHc8ffEAsC6mudJAD4mlgQN/L8Lqn0axIMgDpVKJ3r17Y9q0aejVqxeCbgXh8pXLOHX6FIIfBmP7ju0QBAEeHh44ePCg2OHqpKCgILi6uuLhw4f4a9VfeBTyCGfOnsGFCxdw/8F9fP/D91i/fj08PT0RG8vviLyYPHkyhg4diubNm+Pc+XO4cfMGTp0+hbv37uLI0SOoWKkiOnfujBUrVogdKumQXBUDvr6+kEgkGreyZcsCAJKTkzFx4kQ4OTnBxMQENjY26NevH8LDw7Pd786dO+Hg4ABDQ0M4ODhg9+7deXs3WkgQBPj9PAKCIh6r/12Obt94I+DUZfX6AP/L8B7UBWsOLIdEJcfqH4fx7HUuPbkTiG2//4juA7rir+1L4dysMU4ePgUAOHnoFBxq22PuslmYPHsiTmxeiStH9ogbsI5JjI/Fw2sXIdGToN5QZ3j+1j7dNg7d68Lzt/YwNDOCUqFgR+JcevcyHCsmD4PKXAahfmnAVF9zAwmAGuaAU0kEnj6Mg36LRYlTl82ZMwfbt2/Hho0b8Otvv6Jq1arqdVKpFO3atcORo0fg6eWJrl274smTJyJGq3sSEhLQvn172Nja4NTpU+jduzeKFftQ1JYtWxaTJk3CocOHcOvWLQwdOlTEaHXTli1bMGfOHMyZMwerVq9CvXr11OskEgmaNm2KnTt3YtiwYRgxYgSvclGO5frKgKOjI168eKG+BQUFAQDi4+Nx7do1/PTTT7h27Rp27dqFBw8e4KuvvspyfxcuXED37t3Rt29f3LhxA3379kW3bt0QEBCQt3ekZUKDriIk6BqmzJ8I20o2CAt5iicPw9Trn4U+w5OHYbCpYI2fF/rgyZ0beHTjchZ7pI/5b12FilUqYurvP0JPL+UjfeKgPwDgzIlzSEpKBgAMGNEXLdu4w3/LShZcuRD+8C4ECKjVtz4qtqia6XbFbc3QfForAMDz4DuFFd5n4cyejVAokyHUKgFIs2jva1kMKG+CE9vWIEmeWGjx6brExEQsXLgQQ4cORadOnTLdztDQEH5+ftDX18eyZcsKL8DPwNatWxEWFoYNGzagVKlSmW7XoEEDzJw1E1u2bEFYWFim25EmQRAwd+5cfNH6C4wZOybT7fT09PDb77/Bzs4O8+bNK8QISZfluhiQyWQoW7as+mZhYQEAMDc3x9GjR9GtWzfY2dnBxcUFixcvxtWrV7P8g1+wYAFatWoFHx8f2Nvbw8fHB56enliwYEGe35Q2ObtnI8pVLg9n90YAgHNH0lfqZ4+mLGvUvAEqVK2As7vXF2qMuiz6zWsEnTmCPt90h1QqBQCEP32B+7cfAADiYuJw+fwV9fZ9h/TE84f3EHrrqijx6qIHV85BZqiPCs2qZLutiVVxWNWzxYOrZwshss+DIjkJZ/7ZBKGsISDLwVdyORMkxsbg2vF/Cz64z8TOnTsRGRmJYcOHqZcpFAp8P+F7jBw5Ert27lIvNzU1RZ8+fbBq1SrI5XIxwtVJy5YtQ6svWqF69erqZefPncfIkSMxatQovHnzYY6SXr16wcTEBCtXrhQjVJ106dIlBAYGYvjw4RrLZ8+ejZEjR2L58uXqZVKpFP8b8j/s2bMnR60ziCDkwtSpUwVjY2PB2tpaqFSpktC9e3fh0aNHmW5/9OhRQSKRCFFRUZluU758eWHevHkay+bNmydUqFAhy1gSExOFqKgo9e3p06cCAK27yfRlQq9h3YWAl2eEgJdnhKat3IQ+I3sKEolEACD0HdVLcPNyUa/vM7KnINOXiR63rt1O3DgsPHh/S3jw/pbg+8cUoXYDJwGA4FjHQRg4sr963b23NwUDAwPR49W1W9l6tkKnTb2ETpt6CV+t65FufeOxzdTr637TWPR4dfJWr7QAL9uUW3UzzXWGeh/WedkKMOZ3RG5vVapUEeIT4tW333//Xb2uRIkSQtjTMPW6g4cOih6vLt4WLFygzmF0TLRgb2+vXjdk6BCN/Hfo0EH9O8hbzm4ymUyIjYtV53D3nt3qdVKpVLh85bJ63YPgB6LHm90tq2NDKly5GmvR2dkZ69atQ40aNfDy5UvMnDkTbm5uuH37NkqXLq2xbWJiIiZNmoRevXrBzMws031GRETAykpzWE0rKytERERk8owUc+bMwbRp03ITvmgMi30YDnDqkikwK1EcjZo3BAQBLi2dEf0+Rr3eqJgRm7DkgbHJh7ap7b5ui47dv8K1gOuo6WQHfYMP7a/19PSgb6CPpKQkMcLUTRJAaij98FBPAteJ7hqbmFf6MFyg1EAKyoO0zYMsi2n2G/h4qMCsmhJRhoyNjTUeHzt+TH3//fv3uHLlCtq0aQMAGm3dKefS5vjJkyd48OCB+vHxY8fTbaunpwclO8PnmIGBgbopLAAcO/rhM6xUKnHK/xQcHR0BpP+8E2UlV82E2rZti6+//hpOTk7w8vLCv/+mXKZeu3atxnbJycno0aMHVCoVli5dmu1+Px4TVxCEbMfJ9fHxQVRUlPr29OnT3LyVQiMIAp6FPlM/NiuRMuqKi3tjuLR01lgGQGNbyrknIR+aopmXMIeJqTGaeTZBGcsyMC9hrl739s07xMdxWLtcEYDYFx8KVomeBFZ1bDRuRuYfDp7iXsWmdHil3ElIc1BUTAaUNvpwK2X4YZ1KABIVhR+fjnv67CmSk5PVj319fdUHVk2bNlUXAgAQGhJa6PHpOqlUipCQEPXjqlWrov+A/urH06dP19g+ODiYhUAuxcfH49WrV+rH3//wvfpka6VKlTD4m8HqdWn/L4iy80mzMJmYmMDJyQnBwcHqZcnJyejWrRtCQ0Nx4sSJLK8KACkjDHx8FeDVq1fprhZ8zNDQEIaGhhmuW3RWe/4Ijm1cgYOr5yPqbRTMS5lnuW30+xic2H8abQePwxd9RxRShDkzuumH9uK/nnwkYiSaVEol5vZ2x7Z1O1Gvcd1st9+1cTdk+vqYvO0cTMwz7+Qmhh9afuicO+vYQxEj0XT7zGFsmjYS7x+/Q4lKWU8YJKhUCPN/jPpffI2vv9euYVx/9Kqmvr/wjPZ8RwDAwlHdEPr0NgTrHJzNi0wEkgV8v2Y/ylV3KPjgcmFMmn4l2nSF8+bNm6hTpw7279uPzl06AwBq166NW7dvQS6Xp/u98fPzQ9OmTXHmzBkxws1S2hNl2pTjb775BuvXrcfkyZMh+2+Cx99++w2jR4+GRCJBjRo11NveunUL165dw7Zt29C1a1exQs6Qtub3zZs3KFeuHNatXYcJ308AAFhaWuLqtauIjY1FyZIlNY6J/v77b9ja2uLx48fq/w9twUnRtM8nzTMgl8tx9+5dWFtbA/hQCAQHB+PYsWPpmg5lxNXVFUePHtVYduTIEbi5uX1KaFrD+UvvlOFFF23Idtt1izdAqVTCtX23Qojs86AnlaJx+x7Yt/0AHt7Pukh5++Yd1i7fBKcWX2pdIaDN7N08Uby0Be7vDIKgyvrH8Yl/COIjY+DcoXchRfd5aN6lP4S3CcCbbEYIUgqQPIlD+Zq1ta4Q0Ga1a9dGkyZN8OtvvyIhIUG9vFKlSrCzs0OJEiXUy06fPo1Tp05hxAjtOiGj7UaMGIHnz5/j77//Vi8zNjaGnZ2dRiEgCAJmzZyFsmXLZjmyE2kqXbo0evTogWXLl2lcHbC1tYWdnR0sLS3Vyx48eICtW7ZiyJAhWlcIkHbKVTEwYcIEnDp1CqGhoQgICIC3tzeio6PRv39/KBQKeHt748qVK9i4cSOUSiUiIiIQERGh0T67X79+8PHxUT8eM2YMjhw5grlz5+LevXuYO3cujh07hrFjx+bbmxRT8ZKl0e5/E7Bp2Rasmbc2w8uiKpUKfgvXY/2STfhy8DgUL1lGhEh1V5PO/VDKpgIGdh6Ke7fuZ7jNyxevMLDTEMQnJOOLgWMLN0AdJ5XK0GGUL15ce47AVZegTE7/GRYEAU/PhuLG31dQv403ytnXFiFS3VW7eWtUb+AGya33mRcEChUkQe+gF6+C95iphRrf52D+/Pl4cP8BunfrjqioqAy3OXXqFLp36w5PT094e3sXcoS6rX79+vjf//6H78Z/hw0bMp7tPSkpCd9++y3++ecfLFq0CPr6+hnsiTLj6+sLlVKFDh064NmzjJsU3759Gx3ad0DFihUxevToQo6QdFWuSsZnz56hZ8+eiIyMhIWFBVxcXHDx4kVUrFgRjx8/xt69ewEAdevW1XjeyZMn4e7uDgAICwvT6ADj5uaGLVu2YMqUKfjpp59QtWpVbN26Fc7Ozp/2zrSIR89vkCRPwIq5C7B38wF06fcVajVwgEQiwa1rd7Br7T8IfxKONgO/hVefYdnvkDQYmRTH4F/X4u9Jg9CxmTdafNEcXXp1hGVZC0S9j8aBXYdwcM9hFCteEoN/XYtS1uXFDlnnODZrDe/vf8WuPyYh4voLVHSvDItaZaEnlSD6WRSeHA/B+ydvULdVJ3QaO0PscHWOVCbDN7OXY9XkYQi+eh6SUsUglDUCjKWAUgBeJ0LyMhEyqT6+mbsKlRzrZb9T0tCoUSPs27cPnTt3Ro3qNdCzV0906NABJsYmCH0cCr+//XDmzBl4enpi165dPFDNg6VLlyI5ORlD/jcEixctxuBvBqOWYy0kK5Jx8uRJ+P3thzdv3mDNmjVa1zxIF1SsWBHHjh1DmzZtUMuxFrp06QLvrt4oVbIUIiIisHHTRhw8cBAODg44ePCgxhUvoqxIBG1qFPcJoqOjYW6e0iZfm/oMpPXk7g2c2bkO10/8i+T/rpbI9PVRz6Mdmnbui8q1tPcHXlv7DKSVlJiA68f34uI/6/E8+K56eWmbcnDu0BuNv+wGY7MS4gWYDW3tM5DW66chCPhnA64d2Ql5fFzKQokEds7ucO3YF9UaNtPa9qDa3GcglVKhwM0zR3B651qEpJl80Ni8BJp27I0mHXuhhKW1iBFmTVv7DKT1/PlzLF++HH/99RdevnypXt68eXOMHDkSXbp00eqmFdrapj2VIAg4evQoli5din379kGlUgEAihcvjv79+2PEiBGoWbOmyFFmTtvzCwDv3r3DmjVrsGzZMjx69OH3uHbt2hg5ciT69Omj1aMJpeY4Kioq236lVDhYDIggMT4WUZEpbf7My1jCyNhU5IiypwvFQCpBEBAd+RIJsVEwKGaCEpY2GlejtJUuFAOpkuWJiHodAZUyGaYlLbS6yEqlC8VAWjHvIhH7/i30DQxR0soGUpn2n6nWhWIgVXJyMp4+fYqEhASUKVMm20ErtIUuHKymevfuHSIiIiCTyVCuXDmdGLJVl/KrUqkQFhaG2NhYlChRAra2tlp7MiYtFgPaR3tPf3zGjIxNYVRB+wsAXSWRSGBuURbmFmXFDuWzpW9ohDLlKokdxmeteMky7D9UgPT19VGlSvazalPelSxZEiVLZj0CGeWdnp4eKlWqJHYY9BnQ/tOlRERERERUIFgMEBEREREVUSwGiIiIiIiKKBYDRERERERFFIsBIiIiIqIiisUAEREREVERxWKAiIiIiKiIYjFARERERFREsRggIiIiIiqiWAwQERERERVRLAaIiIiIiIooFgNEREREREUUiwEiIiIioiKKxQARERERURHFYoCIiIiIqIhiMUBEREREVESxGCAiIiIiKqJYDBARERERFVEsBoiIiIiIiigWA0RERERERRSLASIiIiKiIorFABERERFREcVigIiIiIioiGIxQERERERURLEYICIiIiIqolgMEBEREREVUSwGiIiIiIiKKBYDRERERERFFIsBIiIiIqIiisUAEREREVERxWKAiIiIiKiIYjFARERERFREsRggIiIiIiqiWAwQERERERVRLAaIiIiIiIooFgNEREREREUUiwEiIiIioiKKxQARERERURHFYoCIiIiIqIhiMUBEREREVESxGCAiIiIiKqJYDBARERERFVEysQMoCE/u3ECFmrUhkUjEDiVD0W9f4+H1ACTGx8HI2ATV6jnDrJSF2GFl6MndGzi7eyP09fQgCAJUgoBT21ahYeuvYWJeUuzwMhXzNhKPAi9CnhAHw2Im+H979x3XxP0GcPwTpoqKC0Hcde+tCFYRt7WtWnfdHY66a2u1/qrWqrXD2rqtbd17Vds666p7YnGAqDgRlQ0CAZL7/UGJICBDyCXwvF+vvDR3x+XJQ7jcc/cdleq7UKhYCbXDSiE2JhrPv3fjuW871v8tiwd8z/9DpYZuWFi8Wr1+98oFijiVxr6E0yvHmlRkSCC3Pc+gjY7ENn9BXqvfjIJFTS+/AE/v3+bs7vWG/CrAXyt+wPWtPhQpWSrT+9PrdHif+4fK9Zthky9/tsaaVOJxQhv1DFsTPk7o4uPwOn6QM39uwdo6Ics6nY4tW7bQtWtXwzJT8/jxY44cOUJERASFChXC3d0dR0dHtcNK1YMHD/j555/5448/DPmMi4vD29ub6tWrqxxd2swlx3q9nkOHDrFs2TJDfvV6PStWrKBv377Y2dmpHGHqzCW/AMHBwaxcuZItW7ZgZWVFfHy82iGJJDSKoihqB5EdwsPDsbe3x7lECfwDA6lSvymDZy6kkAmdoPjf8ubAmsVcPrKH+HidYbmVlSX13DvRbsBInCuZxoE9IiSIVV+M4salM5QtWpS3q1QhKCqKDVeuoAE0lpa83mMonT789JVPWLPTo9s+HF63mCvHUua4dstOtH53JKVeq6ZihM95HdvH9rmfEhUVSXtra+qSUAjs0+m4ptfjVKYifWYuw6Hsa1l+DZ8zR1j9+fs4V6lFdRcPqjdvQ6nKNbP8Owu47cPRDUu4+s8edEnya2llSa3XO9Gq7wicTCS/sTHR7PzuMy4f+ZNiVtb0sLWhqIUFATod27SxRCl6WvYYzNsjJ2NhaZmpfW/4+jMuHPidKo1cqeXqQW1XjywVFqnxv+XNwbVpHyfa9jed44TflYusnjaa4CePaO7qiquLCxqNhhMnTnDq9GlKly7Nxo0badGihdqhGnh5eTFn9my2bttKXNzzExJrayt6vNODyVOmUKdOHRUjfE6n0zFp0iTmz59P/vz56d6tG6VKlSIkJIQtW7cSEhJCr169+O233yhQoIDa4RqYU459fX3p3r07V65coU6dOrRt0wYrKyu8vLzYt38/9vb2LF++nJ49e6odqoE55Rfgxx9/5LPPPkOn0/H2W29RunRpfvzpJ8LCwihcuLDa4QlyYTEQfOAAxy9f5v05c7Cws2fski0mcQX7+plj/Pr5MJzt4xndTkd/NyheEIIiYe0JWHDAEv8wK4bOWkaNZi1VjTUqPIwfh79DfPATVrz5Jm9UrYrlfyePrX/7jSN37hi2zV+wMA3bd6Omaxsq1m2ClbWNSlGDz9ljrP1iGM5FdGnnONSS/l8uo1pTdXPseegPNswcR3drK761saFikpNzRVE4odPxQXw8D2zz88HC7ZQoUyFLr6MoCktGvcNDn38NywoVd6RaM3eqN/egUgPXDF/d9j13jA3Th6eb377Tl1Klibr5jY+LZc1nQ3jodZ6F9oV5184O2yR3CiP0epZERjIlPJxG7bvS7/PvMnUnMdD/HrP6tUWve/5FXKZKLWq5eVDbrQ1lqtbOUsF1/cwxfpua/nFiyFfqHyf8vC6wePwAmjZpzKIFC6hbt26y9V5eXoweO5bTp09z8OBBkygI9u3bR/duXSllH89HbeNT5HfRQSsehVmxfcdOOnTooGqsiqLw/nvvsXLVKmZ99RUjR4xIduKk1WrZsGEDo8aMoUmTJuzduxdbW1sVI05gTjm+desWrq6uFCtWjOVLl9KiRYtkx4E7d+7w2eTJbNq8mXXr1tGvXz8Vo01gTvkFmDNnDlOmTGHM6NF8PmUKJUuWTDhfK1pUigETkqliYPr06cyYMSPZMkdHRwICAgDYvn07y5Yt48KFCwQFBXHp0iXq16//0n2uXLmSIUOGpFgeHR1Nvnz5MhqaoRgI+/tvChcsyM3793F5/30qNm3FwC9+yPB+coL/LW9+GNaNNtVj2TJGoUAqx+soLfT8ScPf3jaMX7ZD1St/a7+aiO+xvZx67z2qlUh+Z+WInx+tV65M9edsCxSkapPXqdncg+ou7tjZFzNCtAke3fZh8ciutKkRl36Or1szcvFO1e4QRAQH8nWfFvQE1tjaYpHGSWiQotA8Rov2tWoMW7wzy6+XeHcgNVY2tlRq6Ep1Fw+qubROszlRwG0flo/uluH8frhgh6p3CA6vXcTR1T9ysHhxWr7kOLLh2TP6BQcz4H/zaNy+a6ZeY8PXn3H6z82pritcvCS1mremllsbqjV2y1DB5X/Lm/nDM36cGLdUveNEfFwsX/Vxp1bVyhzYty/NY7VWq6Vj5854e3tz584dVU9Wvby8cGnWlNbVtWwenXZ+ey3QcNjbltNnzqp6dXXTpk306dOH1StXMmDAgDS3O378OG3bt2fy5MlMmzbNiBGmZG45dnNz4+nTp5w8fpwSJVJvRaDX6xn63nts2LgRPz8/nJ2djRzlc+aW3/Pnz9OkSRO++N//mDF9umG5FAOmJ9PFwNatWzl48KBhmaWlJQ4OCe1Y16xZY/hj+eCDDzJcDIwdOxYfH59ky52cMtfGObEY2PnNN3RydcXG2pr5GzbwycJFTN9+XNW2tqumjyHYaw9X5uhS/eNNFKWF2pMtKV63MwOn/Wi8AJOICAliWjdX5ni0ZqKbW7J1jyMjiY6Lo/umTVx69Oil+9FoNJSr2YCarm2o0dwDxwpVcrQPx/qZYwm7mvEcF6ndmb5T5+dYPC/z99pFHP1tPv4FClA0SU7iFIW7L/w5HoqPZ5hWS79pi7J8cq0osGbqBwQ+8Et328TmRNVcPHCuUstwdXvTrHFEXMt4fgvX6kSvKfOzFO+r0sXH8X3fFvSJjWFpseQF6VOdjjC9PtmyQSGh3CtdnsGzlmTqdYL877Pk40HpbmdtY5uh5kSrZ2TuOFGsjnrHiUuH/mTltNFc+fdfatWq9dJtvb29qVGrFuvXr6dv375GijClfn37cvbIVv6dHZ9ufutOsaJZ656sW7/eeAG+oEWLFtja2vL3gQPpbvvRqFFs37GDu3fvYmOj3t1Zc8rxxYsXadSoETu3b+ftt99+6bZhYWE4lynDpEmT+OKLL4wUYUrmlF+AwYMHc/ToUW7euIFlkqaYUgyYnkwXAzt37sTT0/Ol2925c4eKFStmuBgYN24coaGhGQ0jVYnFAEBhOzs6uLjg0agR4+b/SMf3J9Cm3wevtP8sxxX8lOndXfmmj47xndLfft5fMGmTJTN2nFKlv8PhTb/w55K5+H/8McVfaIP6xtq1/OXrm6X9FitVlhouranh2obX6jXN1uZEEcGBzOmd+RxP2XxSlU6vc3u58VZoEL++cDX1ll5P5WfPjB5PWgoVL0m1Zq2pUKcx27+bxHd99RnO76ebLPl0w0kKFi2e84G+4Pqpv1n7v2F4OjpS74UTo3EhIfwYGWn0mJJKbE5Uy9WDstXqYGFhQXjwU2a8k/nP8PTt6hwnlkwYiEM+DceOHDEs279/P6PGjAHgxx9+oFOn52/Eo21bAA4dOmTUOBM9fvyYsmXLMLd3fIbz+9lmKx48eEjJkiVzPsAXeHt7U6NGDbZs2kSPHj0MywcMHMiZs2dxdnbmwL59hs6uV65coU69euzYsYOuXbsaPV4wvxyPHDmS3bt343frFlZWCWOpeHt783a3biiKwoRx4xg+fLhh+w+HDWPvvn3cu3fP6LGC+eU3IiICBwcHpk+bxmeTJhmWT/3f/9iwcSO3b9+WYsCEZLpRq6+vL87OzlSsWJE+ffpw+/btVw4iMjKS8uXLU6ZMGbp06cKlS5fS/RmtVkt4eHiyR6LwZ8/Y8vffjPjmG7SxWg5vXMGBtUt55OeLsbtI3Lx0hvj4hLa/GdHfDeLjdfhePJOzgaXh6YO7VHNwSFEIvKrgR/c5sWM1Kz4ZxIyuTVgzfRQX9m0nMjTolfd9y/N0lnJ8y9P4Odbp4gl6GoCbCXW6TktE0BPO/7WJrXM/Qa/Ts8cTlv0ND4Nf/nP93UAXr8Pv8mmjxPmi4Id3yW9hmaIQMBUPfK+yb+UC5n3YjWndmrNx7mQObViRpc/wzUvqHCeC/O/h5upqeB4fH8+4CRPw9fXF19eXcRMmEBcXZ1jv2rw5N2/eVCNUAI4cOUJcXHym8hsXF8+RJMWOMSXmyi3J3dk9e/awdt06fH19OXr0KAsXLTKsq127NoUKFZIcZ8LNmzdp1rSpoRAAGD9hAjdu3MDX15fJn39OYGCgYZ2bqyv3798nNjZWjXDNLr8PHz5Eq9Xi2ry5Ydn169eZ+8032XLeKLJXps5ImjVrxurVq9m3bx8///wzAQEBuLq6EhSU9RO66tWrs3LlSnbt2sWGDRvIly8fbm5u+KZzBXrOnDnY29sbHmXLlk1z2/j4OLRRz9BGPTN6MRATlXClt0ShjG2fuF1MlEpXLxUFDTk7JGt8XCzaZ5HEREUSFxPzyvvTRptZjsFkh719GW08RMRAZDq/MrXzq6BgLumNi40hJuoZ0RFhQBY+w89UyrGiJPsM6/X6ZCdJsbGx6HTPR0LSaDRGP/YmFRERAWQ+v0kvMhlTarmKeeFY+eJzyXHmvPgZBojRag3/1+l0yYa/TNxWrRybY34h+XedVqtF/0IzTWEaMjXPQNLbvnXq1KF58+ZUqlSJVatWMWHChCwF4OLigouLi+G5m5sbDRs2ZMGCBfz0009p/tzkyZOTvWZ4eLihILCxtsajcWPaNmnC1GXLaNP3A9oNGJGl+F5VvgIJ4xMHRoBDBu6GBUYk/lzBHIwqbcWdy3I+8Cmh0dEUyZ99Y6jbFSmW0EyoeRuqNHbL1vdnm998cmxpaUWx4iU5Gx7CUBMdfz1RPrtCVG3aivyFi3Lm9zVsHWv6+QUoVqocUTod1+LiqGmCOS5RunxC/wG3NlSq1wRLK2su/v0Hp//cnPnPsJ1KOXYqw5mzZw3PbWxsmPfdd3z4X7OK77/9Nlmn4nPnzlGxYkWjx5moUKGEM6PM5letJgyJuTp79qyhPXu3bt146803Dc2EJowfb9jex8eH8PBwyXEmvPbaa+zfvx+dTmdoz/7jDz/QoVMnFEXhk4kTk/VdPHvuHKVKlVKtE7y55bd06dJYW1tz9tw5Xn/9dQDq16/PqI8+YsPGjTx9+lSVuETqXmnSMTs7O+rUqZPuVfzMsLCwoEmTJunu09bWNtU/yrUzZvB2y5YULFCARVu2EBsfT5OO3bItvsyq3KAZVlaWrD2RsbbAa08kjCdepWGznA8uFY3bd+WPZd+yytOTsUlu7wEsfOMNIrRaBu/cmW4HYgCn16pRs7kHNVzbULZa3UyP5Z5Rleq7ZCnHleqrk+OGXfqwZs1CvlEUCie5alJGo+H8C82zTul0jNZq6fbxHEpVqpGl11MUhc2zxxP08E662xYvXf6/+Qg8KF+7MZZW1kSGBHL+z/WZyq+llSUV67mkv3EOqNq0FYUKF2FJZCQLiiYfVvjjQoUY8MIEQmNCw7jt4MS70+Zn6o5NyONH/PL58HS301hY8FqdRtRybUNttzaULPdaitfJ6nGicgN1PsNNO/dk7VcT8PHxoVq1hI7tb731Fm+99VaKbW/evMm+/ftZmcYoZMbg7u6OtbUVa09krL312hMJY7a7u7vneGypqV27Nk2aNGHJ0qXJOrf+vnNnqtsvWbqUEiVK0KVLFyNFmJK55Xjo0KEsX76cffv20blzZwDq1q3Lo4cPU2wbERHB6jVrGPNfnxg1mFt+CxcuTM+ePVm6bBnjx40zDEbx4/z5zPzyS+xfODYLdb1SMaDVarl+/bqh6ssOiqLg6emZ5eGw3mzRgoIFCnAvIICZK1dS7/X2FHHI3tlXM6NwMQfquXdiwYE9DPNIf5SQhQctqd+6s2qTpdmXKEm9Vh2ZfeIYb1evToUkf7AVixbl9P37aRYCltY2VKrfjBrNPajR3INiTmWMEnOhYiWo3TJzOa7TqrNqM+Y2e6M3h9cuYqJWyzJbW8OJoa1GQ6OkIy4oCoNj4yhdsSqNOvbIctOiWxdPplkIaCwsKF+7EdVd2lDdpTUlyqY8US1YtAS1Xs9cfmu37KRK52EAK2sbGr35Lis2LGVggQI0SXLRoKyVFUkbFP4eHc0pbQx9+g+nXPW6KXf2Eqf/3JLmunx2BanRrBW1XNtQ06VVunOdZOU4Uc9dveNEffdO7Fo8m9Fjx/Ln7t1pzjIcHx/PmLFjKV68OL169TJylM85OjrS450eLDq4lWEe6Y/EsvhvK3r26KlKx8tEH330EYMHD2b79u107949ze0uXLjAzytWMHbs2EwNx53dzC3HTZs2pVGjRnz62We4ubkZBiB5kaIofDZ5MlFRUXz44YdGjvI5c8svJHyG169fz/fz5vHJxImqxSHSl6k+AxMnTuTo0aP4+flx5swZevToQXh4OIMGJQyvFxwcjKenJ9euXQMSbl16enoa5iEAGDhwIJMnTzY8nzFjBvv27eP27dt4enry3nvv4enpmawXf2YowNGLF2kxbDjxVra8M356lvaTndoNGIl/mBU9f9IQpU19m8Txw/3DrGjbX50mTYm6j/sCxa4wLVau5LCfX7I2kjNe6IxkbZuPxh3fYcCMxUzbeY73v1mJW7eBRisEErV+dyT+oZYZy3GoFe791MuxvYMT3cZ/xc9xcQzVanmcShvKf3U6WsVouWVlzTtTMnfFOilFUfh7dfLmdvnsClG3dRd6Tv6eKVvP8sG8Dbze630cylVK83Va9R2Rifxa0rKPup9h934jcKxai7ZBwWyJikL3QjtfraKwNDKSnsHB1GvZgaadeqSxp9SFPPbn1B/J5xgoUbo8rXoO4aP5a5n9xwUGz1hAkw5dMzzpYdv+5nOcsLa1pf//fuDw4SN0eeutVDsE+vn58XbXrhw4eJD169eTPxubHWbF5ClTeBRmRa8FL89vrwUaHoVZ8VmS7yk1DBgwgF69etGnXz8WLV6coo+ATqdj27ZttG3fntq1azN16lSVIn3OnHKs0WhYvXo1Dx8+xN3Dg8uXL6fY5smTJ3w4bBiLlyxh8eLFlCtXToVInzOn/AK4urry2Wef8emkSUz93/8ICwtTNR6RtkwNLdqnTx+OHTtGYGAgDg4OuLi4MHPmTGrWrAmkPYHYtGnTmP7fhBPu7u5UqFDBcMt4/PjxbN++nYCAAOzt7WnQoAHTp0+n+QtNVNKTOLRolbJl8b1/n3JVa/He18spmsaY3saWdAbiUW0TRg0pUSihXd/aEwlX+kxlBmKA0KcB/PLZh9z1uUINR0e6Va1KUHQ0y86fN3RUa9ypJ+9M+ApLq1e6wZRtks5AnGaOQ63o/+VS1WcgBji/dxs7501FiY+jq5UVdTUa4oB98fGc0espVsKJfrN+znLzIEi4K/DrpwNTbf6TWUlnIE47v6YxAzFAzLMItnw1Du9zRyljY0NvW1uKWVjwSKdjQ4yWoPg4XN7oSc+PZ2Z6qNst877gxO/r023+k1lJZyB+2XHCFGYgBvA5f4LV08fwLDyU9u3b09zFBY1Gw8lTp9i/fz9FixZlw4YNtG/fXu1QgeSzt45sE58iv4v/Nq3ZW+Pi4vho5Eh+XrGC4sWL06d3b5ydnQkJCWHDxo08fPiQjh07snHjxjSvbBubueXYy8uLt99+Gz8/P1xdXWnbpg3W1tZ4eXmxY+dOrKysWLhwIUOHDlU7VMD88qsoCl999RUzZswgX7589OrZk9KlS/PVrFkytKgJyVQxYMqSzjPw0Q+rqdrYzeRGbPG/5c3BtUvwPPwX8fHPR9qwskpoGtS2/whVZx5+kaIo+F48xfHta7j6zwH0/31UWg8YRbMufbBXsflVWh7d9uHI+iV4HU2Z4zqtOuPeb4RqMw+nJioijAv7tnPpry0E+PmgAXRA7y8WUsO1TZZO2pO6dekUhYuXTLX5T1YE3Pbh2MYlXDm2B12S/FpaJTQNatlnhKozD6fmgY8XZ3atxWvfNhRAA7j2HIxb1/44lnst0/vT63RcPraPqg2bZ/iqf2YkHicuH0n5Ga7nbnrHiVhtDBcP7ubMn5u5dz3h6qqiKCxfvpw+ffpQIJuHKX5VXl5efD1nDlu2biEu7vloMdbWCc0qPps8WdVZW1Nz48YNli5dyu7du7lz5w4ajYa4uDjOnj1LkyZN1A4vBXPLcXx8PLt27WLp0qUcOXLEcDd87ty5DB48mGIvTF6oNnPLLyQMNbpixQo2bdrEjRs30Ol0UgyYkFxZDPx03LTHsI0ICcT34hlioiLJV6AgVRo2U63tb0aNafH8pOmbw7dUjCRjIkMCueX5PMeV6jdTrY9ARn3aupLh/7MOqjdeeEZEhgThd/m0Ib8V67mo1kcgoz5vW9nw/x//Me1jBCQcJ25eOkPMs0jy2RWkcgPTP06Mff35ccLUv1qePHnCkSNHCA8Pp3Dhwri7u6vavjqjkhb1kuPsJ/nNeYk5lmLAdEgxIDLE3IoBc2ROxYA5MrdiwByZUzFgrszpZNUcSX5znhQDpsf0p0EVQgghhBBC5AgpBoQQQgghhMijpBgQQgghhBAij5JiQAghhBBCiDxKigEhhBBCCCHyKCkGhBBCCCGEyKOkGBBCCBMVGRqsdghCCCFyOSkGhBDCRB1Ys5iYqEi1wxBCCJGLSTEghBAmSFEUPI/swefccbVDEUIIkYtJMSCEECbI/5Y3oU8eceXE32qHIoQQIheTYkAIIUzQ1ZOHALh26gh6nU7laIQQQuRWUgwIIYQJSrwjEBkaxN3rl1WORgghRG4lxYAQQpiY8OCn3EtSAEhTISGEEDlFigEhhDAx104dRlEUw/PEJkNCCCFEdpNiQAghTMyLJ/+PbvsQHPBQpWiEEELkZlIMCCGECYnTavFOZThRaSokhBAiJ0gxIIQQJuSm52lio6NSLL8qxYAQQogcIMWAECJLdPFx+PteVTuMXCetOwC+nmdkNmIhhBDZTooBIUSW3L1yAc+/f1c7jFxFUZQ0iwFdXKzMRiyEECLbSTEghMgS79OH8D4lo9xkp8RZh9Mi/QaEEEJkNykGhBBZ4n3qEEEP7/D0/m21Q8k10htCVGYjFkIIkd2kGBBCZNrT+7cJengHAJ/Tcncgu6R35V9mIxZCCJHdpBgQQmRa0uZB0lQoe7w463BaZAIyIYQQ2UmKASFEpiW9G3D3ygWiI8JUjCZ3eHHW4bRIvwEhhBDZSYoBIUSmREeEcffKBcNzvV7HjbNHVYwod7hyImNX/GU2YiGEENlJigEhRKbcOHsUvT55J1Zv6TfwSuK0WnzO/ZPh7eXugBBCiOwixYAQIlNSO/G/ce4Yuvg4FaLJHW56niY2JhprG1vcew3Fo88HydYXLl6SwTMW4FShCiD9BoQQQmQfKQaEEBmmi49LtUlQTGR4sqZDInNunD+Je6+hfLH5GN1GT6VQcYdk6zUWFjTweINJq/YweMYCIkODZTZiIYQQ2cJK7QCEEObj7pULxDyLSHWd9+lDvFbfxcgR5Q6d3h+PjW2+dLez+K8oqOfeCb3ciRFCCJEN5M6AECLDXtY3QIYYzbqMFAJJWVhYYGVjm0PRCCGEyEukGBBCZNjLTviDHt4h8IGfEaMRQgghxKuSYkAIkSFJZx1Oi/cpGeVGCCGEMCdSDAghMiQjzYCkqZAQQghhXqQYELlWWOBjtUPIVbxPp3/VX2YjFkIIIcyLFAMqCXnsT9CjB2qHkav9ufRrFEVRO4xcISo8lHtXLqa7ncxGLIQQQpgXKQZUcuXkIZk4KAdFRYTx7+E/eXjjitqh5Aq+546lmHU4Ld6nD+dwNEIIIYTILlIMqOTqib+5ckI6W+YUn7NH0et1XJM27Nki6ZCidkWKp1ifdNmNc0dlNmIhhBDCTEgxoAJtdBQ3Lp7C99IZmUU0h1z/767L9ZNScL2qxFmHCxZzoPOIz5mw6mCKbd4aM4OBs1ZQulpdmY1YCCGEMCMyA7EKfM4dJz42FgDvs/9Q372TyhHlLrr4OHz+a7f+0PcqYU8DsHdwUjkq8xX4wA+PgWNo2qUv1rb5Ur3qr9FoqNbMnapNW3Hj3DEigp6oEKkQQgghMkvuDKjgSpK+AtJvIPvduXKR6Mhww/Pr0ob9lThWqIrbO0OwzsAsuRqNhmpNW1GvzVtGiEwIIYQQr0qKASPT6/XJCoCrJ4+g12WsY6bImOsvTHx1XfoNCCGEEEKkSooBI7vv7UVEcKDheWRoEHevX1YxotznxU7DvhdOEBsTrVI0QghTpCgKgYGBPHjwgGfPnqkdTq6k1Wp5+PAhjx8/RicXvbKdoiiEhIRw//59wsPD0/8BIdIgxYARPfLzZcu8L1Is3zJvGo9u31AhotxFFx/HsS2/EnjfL9ny+FgtfyyZgzZavvBfVegTfw6unJ9i+Yntv3H3avrzEIiX0+v1XD9zlNN/bk62PDzoCX+vW0ZkaLBKkeUeQUFBfPvtt1SuXBkHBwfKli1LoUKFePPNN9mzZw96vV7tEM3e6dOnGThwIPb29pQpUwYnJydKlSrFlClTuHv3rtrhmb1nz56xfPlyGjRoQLFixShXrhz29va0bNmSjRs3Evtfn0QhMkqKASM5svk3vh7YkQe+V1Os8791na8HdeLQhhUqRJY7PAsLZsnYPvyxeFaq60/vWscP73Xmyb3bRo4s97j6zz7mDWrLP9t/SbHuwe1/WT62F7sXzJBmb1kUq43h16kjWDpxCE8e3Um2TkFh98/fMrNva27/e16dAHOBU6dOUb16daZOnYqLiwvr169n5+87mffDPO4/uE/nzp3p1q0bUVFRaodqlvR6PePGjaN58+YcP36cqVOnsn3HdjZv2UzPnj1ZtGgR1apVY8uWLWqHarZu3rxJvXr1GDFiBGXKlmHlypXs/H0ny5Yvw8LCgr59+/L666/z5IkM4iAyTkYTMoLjO9ex/aeZtOvrwYENKduv63V62vVrw85Fs7GysaHlOwNViNJ8xUZH8cungwkPekCFmuW5cy3llafCxQphm1/HzxP7M2rRdhldKJNunD3Khpmjsa1ShIKtyxK4NHnTNrvWpVGidJzetRYLS0veGDlVpUjNk16vZ+W00Vw7cwTqFkOJioebSW77W2tQmpVEeyWUxR8PZNzirZSpUlO1eM2Rl5cXHTp0oE6dOqxbvw5HR8dk6z/88EP+/PNPBg8aTJ8+fdixYweWlpYqRWuePv30U3766Se+n/c9w4YNw8Li+fXGLl26MH3GdEaPGk2fPn0oUKAAb7zxhorRmp9Hjx7h4eFB/vz58bzsSeXKlZOtHzBgAGfPnqV3r9507NiRY8eOUbBgQZWiFeYkU3cGpk+fjkajSfZwcnp+UrV9+3Y6dOhAiRIl0Gg0eHp6Zmi/27Zto2bNmtja2lKzZk127NiRqTdhyqLCw9ixYBbt321L+Rrl09yubJUydBzQnp2LZvMsLMSIEZq/U7vWEeDnw5gfR3DP536q24QHRzBgSh9QtOxPpZmLSJtep2PH/M+xKVeIwh0rYGGT8gRJg4YC9Rwo1LI0J7ev5NGt6ypEar6uHD/I1RN/o9Syh5L5QZPKRjaWKPWKEm+jsHX+dGOHaPbGjRtH2bJl2fn7zhSFACSMhNWlSxfWrlvL7t272blzp/GDNGNXrlzh+++/Z86cOYwYMSJZIZCoYMGCrPhlBe3at2PEiBHEx8erEKn5mj59Olqtlj//+jNFIZCoadOm7Nq9i2vXrrFw4UIjRyjMVaabCdWqVYtHjx4ZHl5eXoZ1z549w83Nja+//jrD+zt16hS9e/dmwIABXL58mQEDBtCrVy/OnDmT2dBM0pm929Dr4uk5pjsX/k67TfWFQxfpMbobKHrO/LXNiBGaN71ez+ld62jWqQkhT0LQ69Ju73vT8zbtB3jg+fcuoiLCjBilebtx7ijhTwKwa14KjUVqZ6nP5a9XEqtC+Tize72Rossdjm1fjaZIPnDI//INLS1QyhfA79/zPPKTfkYZdf36dQ4dOsQnn3yS7Erp06dP8ff3T9YsqGPHjjRv3pzFixerEarZWrJkCU5OTgwfMdywLDY2Fn9/fx49emRYZmlpyRdffMH9+/f5888/1QjVLIWFhbF27Vo+HPYhpUuXNiwPCQnB398/WQfiOnXq0LNnT5YtWyYdt0WGZLoYsLKywsnJyfBwcHAwrBswYABffPEFbdu2zfD+5s+fT7t27Zg8eTLVq1dn8uTJtGnThvnz52c2NJN04cDvNGnXiHwFbLly6hplq5ShYev6hvUN3OtTrlpZrp65jo2tNU07NOH8gZ2qxWtuHnj/S5D/fTx6u3PxkCf57PLRdeSbWNs8bwH35oedKeJgz8XDnrTu2ZL42FiunTigYtTm5d9Df2BdsiDWTnbpbqux1GBbswief+9EURQjRGf+IkOC8L1wEsU5/XkcAHDIj4WtNRcP7s7ZwHKRTZs2UaxYMbp262pY5u3tTaXXKlG5UmX69O6TbPuh7w3l0KFDBAQEGDlS87Vhwwb6D+iPjY2NYdmUyVOoXKkylV6rxJ49ewzLGzRoQIOGDVi/Xi4aZNTu3buJiopi8ODBhmXBwcHUqV2HypUq0/L1lsTFPZ8QcujQody5c4fTp0+rEK0wN5nuM+Dr64uzszO2trY0a9aM2bNn89prr2U5gFOnTjF+/Phkyzp06JBuMaDVatFqtYbnSaviMS2yHk92s7SypHHrLjy+94TR34+gWccmnNh9iojQSABcOzejZbcWnN1/nsf3n1D6tVKc2XvWpN7Diz5tXUntEFJwqujIa7UrMviL/hQsUhCfC77EaRMOjJ0Gt6f7qLc5tPkoNvlssC1gy+a5k9g8d5LKUaft87ap3wJWhQZsqxRN9ty6VPLCwCLf80OJZdF8xEUHMLVdFWNFmGljXzfBv68CSQ7HtpZgb/38uXWSplkWGvQ2sH/1IvavXmS8+DJJo3n5XSRjq1WrFra2tobnX/zvC0MzlYMHD3Lw4EHDhawqVRI+u6VKlTJ+oJlgajlOzBuAn58fy5cvNzyfMnkKnTp1MjyvWqUqW7duNbn3kJSpxVagQAGcnZ0Nz7/79juCgxNGGLtx4wa//vorw4YNA6BqtaoAtGjRwviBCrOTqWKgWbNmrF69mqpVq/L48WO++uorXF1duXr1KsWLF89SAAEBASnabzo6OqZ7RWbOnDnMmDEjS69pbHGx8ZSvXo7y1csB8Prbbrz+tluybVw6NgXg+O5TRo8vN4iPjafz0A6G51PXpDzR7ziwHYqioIuT26aZogBJml9pLDQU61M97e11ckcgS5K2cHMqkPBIi+Q405JePAJwcXHhjz/+AKBQoULUrl07zW1FxiTNm7OzM+XKleP27YQR3Jo2a5ps25iYGBnGNZPi4uJQFMVQpCTNqYWFBU2bPn8eExNj9PiE+cpUM6FOnTrxzjvvUKdOHdq2bWto77dq1apXCuLF6jvphz0tkydPJiwszPC4fz/1jqNq0+l0nD94IUNNJhRF4fzBC9LGLws8j/6boe2un/UhLjYu/Q1FMrH3IlAyWERpb4em3gFWvFxgBr+8o+MhSjpeZtatW7e4c+eO4fmo0aMYMHAAPXr04Pt53ycbDGPf3n0yklAmWVlZseev502BbG1t+WnBT/To0YOePXvy5ZdfGtZFRUVx6NAhaUqYSXFxcRw5csTwvGvXrowdO5YePXowY8YMGjRoYFi3d+9eFSIU5uqVhha1s7OjTp06+Pr6ZnkfTk5OKe4CPHnyJNXRHpKytbVNdss3qVkHb2Y5nux269Ipfv1kAFdPX6N281ov3db7vA8Pb/kzZO5KKjcyrVt7SZutfHkg67/vnLB+2nAOrD2ER+9WqY5gkdSBtX/jUK4io1bsM7lbwF8kaVZjSjkOCXjADwM9iL4eTIG6Di/dVhcRi/Z2OF1GTafpW+8aKcKMSZrfH46Z1nwTuxbP4ej239BXKgSW6VyjefgMm/wF+HLnWWzzv+TugQrGt3ze/MqUTvSioqIoXbo0y5ctZ/ac2QDY2NiwbNmyFNtGR0ezatUqxowZw7x584wdarqSHrdMKcfLly9nxIgR3L17l/LlE0bO8/DwwMPDI8W2W7ZsITIykps3b1Kpkmk1OzXV/CqKQp06dVi6ZCmtW7c2LJ/z9ZxUt122bBldunRh927T61tkat+94hUnHdNqtVy/fv2V2lU2b96cAweSd+bcv38/rq6urxKayXitvgvOlWuw+LMVBAWkPXtoyJMQFn26HKfXqvFag9zx3o3F9Z2hPPB9wMbvtr704H1kyzHO7jtP83fek4NRJhR1KkPNFh14duIRcU/TnoxJH6sjfM9d8heyp26bt4wYoflz69ofjaKBa6Ggf8kJSFAMmntRtOja3+QKAVNWoEABRowYwcKFC1N83yQVHx/P8GHDiYyMZOTIkUaM0Pz169cPBwcHBg0cRERERJrbXbt2jSmTp9C1a1eTKwRMmUaj4eOPP2b37t388kvKiR8TKYrCtC+m4fWvV4r+mEKkJVPFwMSJEzl69Ch+fn6cOXOGHj16EB4ezqBBg4CEnu2enp5cu3YNAB8fHzw9PZNd+R84cCCTJ082PB87diz79+9n7ty5eHt7M3fuXA4ePMi4ceOy4e2pT6PR0G/GUmK1Gj7vMYPDW4+ijXk+Vbg2JpYj244x+Z3pREcpvDtjabpXt0VyFeo2peOIKfy5Yg8/jVmM35U7ydYH3H3Mqi/X8vPnv9GkS18adeqlTqBmrOvHs3Eo/RqhW2/y7OJj9DHPm6koeoWYm6GEbvFFCY6j/8zl5LMrpGK05qe4c1kGTV+A5mksGs9gCNZC0sJWq4Pb4Wguh1ClkRudP/hYvWDN1IwZM+jQoQM93unBzJkz8ff3N6xTFIWjR4/y1ptvsX37dtatW5fmOO4idQULFmT37t14e3vTxqMNv//+e7J5BEJDQ1m8aDFt27SlbNmy/PrrrypGa54GDx7MyJEjGT1qNOPGjUvRKuPSpUsMGjiI7777ju+++y7VuzJCpEajZOI+WJ8+fTh27BiBgYE4ODjg4uLCzJkzqVkzYSbMlStXMmTIkBQ/N23aNKZPnw6Au7s7FSpUYOXKlYb1W7duZerUqdy+fZtKlSoxa9Ysunfvnqk3Eh4ejr29PWBazYQShQUG8PsPn+Nz5ih2hQtSvkY5NBq4c/0+z8IiqNrkdd4eP4siJZ3T35kKTLmZUKLLf//OwV+/I+xJAKUrl6Gooz3PwqLwu+JHgcL2uPX8gBa9PzTZuwKm2kwoUcyzCP5YOAOvw3+gsQBrRzuw0KAL0RIfEUPp6nV5e9xXOFWqoXaoqTLlZkKJblw4wdYfvuDpPT8s7GxR8mnQ6EEfpsXKyga3ru/SZdinWFnbpL8zFZhqM6FEcXFxTJ48maVLl6LVamncuDF2dnb4+flx+/ZtatSowY8//ki7du3UDjVNptqMJZGXlxfDhg3j1KlTlHIuRfVq1YmLi+PixYvExsbSu3dvFi1aZPi+NjWmnl9FUfj+++/5+uuvCQoKokHDBhQrWoyAgACuXr1KmTJlmD17NgMGDFA71DQl5jgsLIzChQurHI2ATBYDpszUi4FEQf53ubB3KyGPEjo8F3UqQ8MOPShRpoK6gaXDHIoBAJ0uHt8zR/E5fYjoyDBs8hWgYr1m1HZ/A2vbDI7jrhJTLwYSRQQ/5eLerTy964suPp7CJRyp17YrzlVe3idGbeZQDEDCl/2ty2fxPPQHkaHBWNnYUq56XZp06E7+Qqb9xWnqxUCisLAw1qxZw9mzZ4mOjsbBwYGePXvi7u5ushcLEpn6yWqiS5cusWbNGh4+fIiVlRU1a9Zk6NChZjVcqynnNyYmhs2bN3Po0CEiIyMpUqQIXbp0oUuXLlhZvVJ30BwnxYDpkWJAZIi5FAPmzFyKAXNlLsWAOTOXYsCcmcvJqrmS/OY8KQZMjzROF0IIIYQQIo+SYkAIIYQQQog8SooBIYQQQggh8igpBoQQQgghhMijpBgQQgghhBAij5JiQAghhBBCiDxKigEhhBBCCCHyKCkGhBBCCCGEyKOkGBBCCCGEECKPkmJACCGEEEKIPEqKASGEEEIIIfIoKQaEEEIIIYTIo6QYEEIIIYQQIo+SYkAIIYQQQog8SooBIYQQQggh8igpBoQQQgghhMijpBgQQgghhBAij5JiQAghhBBCiDxKigEhhBBCCCHyKCkGhBBCCCGEyKOkGBBCCCGEECKPkmJACCGEEEKIPEqKASGEEEIIIfIoKQaEEEIIIYTIo6QYEEIIIYQQIo+SYkAIIYQQQog8SooBIYQQQggh8igpBoQQQgghhMijpBgQQgghhBAij5JiQAghhBBCiDxKigEhhBBCCCHyKCkGhBBCCCGEyKOkGBBCCCGEECKPkmJACCGEEEKIPEqKASGEEEIIIfIoKQaEEEIIIYTIo6QYEEIIIYQQIo+SYkAIIYQQQog8SooBIYQQQggh8igpBoQQQgghhMijpBgQQgghhBAij5JiQAghhBBCiDzKSu0AhOkLCXiQ7HlcrBZrG1uVosl99Dodd6+cVzuMXC0yJCjZ8+jIcPIXLKxSNLmPoijcu/5vimUajUaliHKf8PBwjh49qnYYudrVq1eTPdfpdFhaWqoUTe6j1Wo5cuSI2mGIVGgURVHUDiI7hIeHY29vD0C1xq/j1vtDKjVonun9hAUGsHPe51Rp0pLqLh4UK1U2u0MlMiSQ255n0EZHYpu/IK/Vb0bBoiWy/XVe1W3P0xzftJwb5/5B4fnHxM6uEA3e6INbz/ewK1L8lV9HURS2f/Mp9iVLUc3Fg9LV6mJh8Wo3rSJDAvG7fIbYqGfYFLCjYj3Ty3GcNoZTO1Zx4fc1hAQ+TrauXLW6uPR8j1otOxn1hEqv17Pjm08p4lSaqs1ap/m7MIf8AgTcus4/G5dx7Z+96HQ6w3JbG1saduyOR79hlHAul22v9/juLXYtnk1NVw9qNfegSMlSWd5XRPBTbl46gzb6Gbb57ajcoBmFijlkW6zZQa/TcfqPTZzYsQb/2z7J1tWsWZNRo0bx4YcfmuQJ1ePHjzly5AgREREUKlQId3d3HB0d1Q4rhTt37jB37lzWrl1LZGSkYblGo6FXr15MmjSJBg0aqBhh2swlx1u3bmX+/PmcOHEi2fJy5coxbNgwxo0bR4ECBVSKLm3mkt/AwEC+++47fvnlFwIDAw3Lw8LCKFxYLsqYglxXDCwuXJiftVouabW8MXIqrt0HZ3pf27+fzIU9WwAoWaEK1V08qO7iQdka9bF4hS+1gNs+HN2whKv/7EEX//zExNLKklqvd6JV3xE4vVYty/vPTqd2rubPhTOpa2HBaL2OtwE74DbwC/CLhSXWxUsy4Pu1FCv16idT1/7Zx8YvRwFgV6Q4VZu5U83Fg0qN3LDNb5fh/Tz28+HYhiUJJ38v5Ljm6x1p2XcEjhXVz3F0RBhrJw/h8Y2rvK3o6QdUB+KBE8BqCwtO6vW4dB1Ip5FTjVoQXDm6h81fjQGgYNESz38XDd0ICbhvFvkF8D75N1tmjqaMomekTkcvoCgQAKwFllla8ixfAd7/fhXla9bPttf9Zcowrhw/AEDpKrWo5ZZQGJSpVidDRa7/LW/+XruYf4/uIT5Jjq2sLKnbqhNt+o/EuVL1bIs3q+LjYlnz5Viu/HOAt99+m5HDh+Pi4oJGo+H06dMsWbqUHTt38uabb7J582ZsbGzUDhkALy8v5syezdZtW4mLizcst7a2osc7PZg8ZQp16tRRMcLnzp07R6dOnbC2tmbYhx8yaOBASpUqRUhICJu3bGHR4sXcu3ePDRs20K1bN7XDNTCXHCuKwscff8wPP/yAh4cHH40YQdu2bbGysuLq1assW76cdevXU7duXfbs2UOxYsXUDhkwn/xCQjHbtm1bnj59ytAhQ3j/vfcoUaIETs7OUgyYkFxXDIQ5OlJQo2FSRATfPXtGn6k/Usf9jUztK9j/Hj8MaY9eF59seQH7olRr6k41l9ZUafw6+ewKZXifvueOsWH6cJyL6BjdTkd/NyheEIIiYe0JWHDAEv9QS/pOX0qVJi0zFW92u3JsLxu+HMU44DtS71hyF2hrYUl4yVJ8sHRXpnKRGr1ez5IRb/P4tney5ZbW1lSs35xqzVpTrbkHRUo6p7kP33P/sGnGcEq/JMcPQy3pPW0pVZq8/krxvgq9Xs/qif0JunqRNXodddPYbi0wFWg79GNa9h1u1PgWD+vCkzu+yZZbWFmh6HQUKwgj2yqMbm+a+QV46PMvv47rzRvxOtagkFqjthCgq4UFXgXsGP/LnxQrVSZbXvvBjat8//6bKZYXKuZALVcPajb3oGpjN2zzp7zS6H32GCs/H4ZzkfiXHCesGDxrGdWbqnuc2PTtFC7s2862zZt5882U7xfgzz//pHuPHrzbrx+//vabkSNMad++fXTv1pVS9vF81DY+RX4XHbTiUZgV23fspEOHDqrGeu/ePRo1akTlypX5c/fuVE9EtVotAwYO5Pdduzh69CguLi4qRJqcOeX4m2++YdKkSSxcsICPRo5MdZuLFy/SvmNHatWqxeHDh1/5rvWrMqf8RkZG0rhxY+Li4ji4fz8VK1YE/jtfK1pUigETkqliYPr06cyYMSPZMkdHRwICAoCEKnvGjBksX76ckJAQmjVrxqJFi6hVq1aa+1y5ciVDhgxJsTw6Opp8+fJlNLRkxUBhCwsURaFraCinijgwZvXfmf4DTnp3IDWWVtZUqNuU6s090m1OFHDbh+Wju9GmRhxbxigUSOXMJEoLPX/S8Pd1az5csEO1OwSKovDToDY09r/PbhRedj36JlBTo6H9yKm4dB34yq+d9O5AWhxfq041l9ZUa9aa0tXrGX6vj/18+Hl0d9pmIMcHr1vzwYLtql3BvnnhOKs/G8IqoFU6234FrLHNx8TNp7AtUNAI0SVIencgLfXKQZcG8GZDaPIaxMSZRn4B1n3+Phbnj3NWr0u1EEgUAtS0tKRm1/50Hzst214/6d2B1Fjb2FK5YXNqubUxNCfyv+XNT8O70aZGbAaOEzaMWbpDtTsEgQ/vMqtv65eeRCVaunQpIz76CB8fH6pWrWqkCFPy8vLCpVlTWlfXsnl02vnttUDDYW9bTp85q+rV1fHjx7NmzRp8rl+nePG0m2PGxsbS1MUFZ2dn/vrrLyNGmJI55TgyMpLSpUszZPBg5v/ww0u3PXjwIO06dOCvv/6iU6dORoowJXPKL8DixYsZM2YMV728qFbt+feBFAOmJ9PFwNatWzl48KBhmaWlJQ4OCe1Y586dy6xZs1i5ciVVq1blq6++4tixY/j4+FCoUOpXjleuXMnYsWPx8Une3tTJySlTbySxGOhla4v1f00qnur17I+N5bUGzTPd1jYi+Cm3L53K8PYly1dOaE7UvE2K5kSbZo0j4toerszRpfrHmyhKC7UnW1K4Vid6TZmfqXizy61Lp/j1kwEcJuWJ6nfA5ReW/QM8zm9HteZteGnlkAGKXs+Vo3+h6PUZ2t7QnKhZa/49vJvoGwcznONCNTvRY8rLvwByyob/DUN/9ih79bpkKXsKzHph22hgH1C6Wh2Kl6lotBgVvZ4rR/4ko4cHR3t4oz60qw2fbbbAvnZn1fIb8ug+8we2YSkKL15mWAu8eIp+GfCxsKROq45YWmXPmArBAQ/w87qQ4e1LV6mJLi4Oi/Bb+Hyjp2D+tLdN/AwXq9OZ/l/8mA3RZt6uxXPw3LeNh/fvkT9/QrChoaGGk9FOnTpRtGhRAGJiYihbvjwDBgxg3rx5qsQL0K9vX84e2cq/s+PTPUbUnWJFs9Y9Wbd+vfECTOLZs2eULl2a4cOG8fWcOYblZ8+e5ebNm5QsWZK2bdsalq9cuZKh77+Pr68vlSpVUiNkwLxyvGzZMkaOHInfrVuUK5fQ1DU+Pp4tW7agKAotWrQwLFcUhUZNmlC6dGl2796tSrxgXvlVFIXatWtTo3p1tm55fmH12rVrnDx1ig8+/FCKAROS6WJg586deHp6plinKArOzs6MGzeOSZMmAQm3MB0dHZk7dy7Dhg1LdZ8rV65k3LhxhIaGZukNJEragVhtSZsTOVeuxY/vtefbPjrGZ+CCwry/4NNNlny64SQFi75659zM2rt8Lre3/cY9XXyKc/sugLrXnV6uWikY3T7hanX5l9R+iTn+eP0Jo+dYURRmdq7FJ/FxvPgXcZf07xSYAysLiFeg3dCJ1PF486VNu3LC+T838sf8/xFEQj+XpD4GFhg1msxzKgJd6id8jtvWBrtUbpDO+wsmbbLki22nKKRCx+1vB3ekS5tWLFu61LBszNixLFi4EICRI0aw6L//A3w0ahR/HzqEt7d3in0Zw+PHjylbtgxze8dn+Dj82WYrHjx4SMmSJXM+wBccPnwYDw8PvC5fpnbt2gAEBwdTpVo1goODsbS05PKlS4a77tHR0RQuUoQff/yRkencqckp5pbjbt26ERYWxqEkFzcXLFzImLFjAWjfrh379u41rPth/nw+nTSJ2NhYVUbJMrf83r9/n3LlyrFj2za6du0KJBRbdevX5/r164B0IDYlmW785uvri7OzMxUrVqRPnz7cvn0bAD8/PwICAmjfvr1hW1tbW1q1asXJkydfus/IyEjKly9PmTJl6NKlC5cuXUo3Dq1WS3h4eLKHqYgKC+HSgR1snDmG+UM7oIvX0b1Jxn62vxvo4nX4XT6ds0GmIeZZBCV55Yv8qvB5BKNWQYVx0HUe3Hma+naJOb7z7xmjxgegi4slPj4O0xt3J/vE6wEFDvzyHfPebcWG6SMJffzQaK8f8ywCOwvLFIWAuQgIhRVHoOsP4DgSvtkNscm7L9HfDeLjddy8ZPzPMCTkOOmoJc+ePWP5zz8bnv+8YkWyY3LJkiUJCwszaoxJHTlyhLi4hPbVGdHfDeLi4lUbBjExV0lzvHLVKoKDg4GEIS9//Oknw7r8+fNTuHBhyXEmhIWF4fjCSfK8JM2F9h84wJUrVwzPHUuWJD4+nqioKKPFmJQ55heSf4b/+usvQyEgTEumioFmzZqxevVq9u3bx88//0xAQACurq4EBQUZ+g28OKxV0j4FqalevTorV65k165dbNiwgXz58uHm5oavr2+aPwMwZ84c7O3tDY+yZbN/CNCssslXgBpu7ej28Rzav/8JAOUyeAG6xH+tqWKiIl++YQ6xLWBHEGCOvcpdq8Cc3nBlLuwYDxXSuDuQmGPtM+Pn2NLaBktLS0KM/srGY/FfJVmzRQdG/fwXfaYtoohjaaO9vm1+O6L0eqKN9orZq3B+6NUM1oyAuz/Cp2+CzQutlwyfYbWOE/ntkg0RaGdnx8ABAwzP+7/7brIrfkFBQapeAYyIiACe5y09idupdZEpsVlt0hwnzamFhQXDk9xt12q1huEl1WKOOU6aX4ARw58P1NCyZUvDXRmAwKAgLC0tDc3ijM0c8wvJP8MdOnRQtRmbSFumGsgm7ThTp04dmjdvTqVKlVi1apVhFIMXb5+lN/GMi4tLshEQ3NzcaNiwIQsWLOCnJFc+XjR58mQmTJhgeB4eHk7ZsmXpYGNj6DMQqtdzPC6O0tXqZro5SFRYCPeve2Z4e3uHUobOxBXruxgm5fr38J8ABEaAQwa+CwMT/t7JZ8TOoklVauDK8S2/cBp4cZaGJqSsHi8CT21sqdjA9dVvJygKvueOZbjPgE1+Oyo3boFdkeKc272enRMyl2NbO+PnWKPRUKmBK9svnuS9F/oM5AfavLC9FjgOOJSvTNEcmPMiTYqC79mjGe4zUCgfdKj7vDNxzU+htntnSlaoksOBpvRaA1d0KGwFBrywribQ+YVlvsAtjQVVm7TAIpv6DIQHPuHBjSvpb/ifQkVLEBESyLaxCTm0TicMw2dYpeNE5UYt2LJ1Gz/Mm4etbcKxbvasWTT8b7z7d955x7BtbGwsm7dsSbbM2AwnJpk8DqtVwDRt2pSCBQuyfsMGZn75JZBwd+X3HTvw9vbG0dGRhg0bGrbfunUrcXFxyfoRGJu55bht27aMHz8ef39/nJ0TmjKOGzsW+8KFURQlRS7XrV+Ph4eHaqMJmVt+y5YtS9WqVVm/YYNhtDFbW1s2b9zI0aNHmTBxoipxidS90jefnZ0dderUwdfX19AmLCAggFKlnk+08+TJk0xNgmFhYUGTJk3SvTNga2tr+BJKanPRoobRhPqEhlK8SHGG/7Ql0/MD7Ppp2kuLAY1GQ5lqdanm4kH15h44vVY91aLntfrNsLSyZO2JjPUZWHsiYcz2ivXUGSKucuPXKVHSme+e+LOV5Of3L461cg+ootHgMXg8bj3fe+XXvnHmCDfOHHnpNkWcyiSMJuTiQYU6TbCysSUyJJCLezZlOscV6jZ75ZizoknXAaw7/w9ngKS/5ZIkzOGQ1HfAWWsb3p+/yagz5nqf+jvd30VFh4QT1zcbQsvqz69ez/tL3fwWL1OBKg1c+enyafrq9ckOcu/990gUQcJoQs3e6EWviS923866VdNGv7QY0FhYULF2I2q6elDbtQ35CxVmZk837gbp0i0EIOEzbGVlSeUG6uTYreu7/LNtJWvXruW99xIyWqJECYYPTzkE7vr163n8+LFqbdkB3N3dsba2Yu2JjLW3XnsiYcx2d3f3HI8tNYUKFWLgwIH8vGIFn0ycaDihc3d3TxFTfHw8Py5YQJs2baheXb35J8wtxwMHDmTy5Mn8tGCBoZO2jY1Nqv0bjx8/ztmzZ9m5c6eRo3zO3PJrYWHBiBEj+PTTT7lz5w4VKlQAoGHDhlSuXFmKARPzSiWuVqvl+vXrlCpViooVK+Lk5MSBA8/H6oiNjeXo0aO4urpmeJ+KouDp6ZmsoMgsRVH4KjKSzTExuA+ZkOlCIPSJP+f3bE6x3DpffkPzn882n2L4wm207v8RpSrVSPPuR8GiJaj1eicWHLAkSvvy143SwsKDltRu2UmVzsOQ8AfceugEdgDTSbu5UADQ2cKSgsUcaNixxyu/rqIoHF6TsmunRqOhbM2GtH1vIh8t/5Pxqw/xxkdfULlRC6z+u/tSsGgJar7eMVM5rvW6ejmu0rglZavW4SMLS3xest1OYBHg0vM9oxYCaf0uAJpXhq/7JDTFuvUD/DgwoZNrYiFgCvkFeH3AKK4AHwBxaWwTCfTUaAi3tqF17/ez7bUf3fbh8pGUXe3z2RWkfus3eHfqPGb+fo7RCzfRpt8wHCtUpnDxktRtlbnjRD33zqp0HgZwLF+JRu3eYtTYsRw6dCjN7Y4cOcJHo0fTu3fvlw4xndMcHR3p8U4PFh20ylB+F/9tRc8ePVXpeJlowoQJxMTE0LV7d0MTkRfFx8fz4bBhXLx4kalTpxo5wuTMLcf29vZ8/PHHfPPtt6xevTrN7a5du0avPn1o0qQJb7yRuTmLspO55RdgyJAhODs788abb+Lv769aHCJ9mSoGJk6cyNGjR/Hz8+PMmTP06NGD8PBwBg0ahEajYdy4ccyePZsdO3Zw5coVBg8eTIECBejXr59hH4nVeKIZM2awb98+bt++jaenJ++99x6enp6pXmHKiN9jYmgdGsoXkZG0HTyehu27Z3ofxzYuQxeXcAph71CKZm+9y8DZv/D59vP0n7GExp16UjATX8Kt+o7AP9SSnj9p0vwjThw/3D/UkpZ9RmQ65uxUv21X2g/9mJlAKwsLtgCxJBQGD0goEupaWPKwcBHenbuS/IVefRQn37NHeejzL5DQ/Kfm6x3o9slcPt18ig9+3ETLPsNwrFg1zaKrZd8RPMxgjh+GWvK6ESfxepGFpSV9v/oZm7IV6WZhwXQS5mxQAB0JzYI+1GgYB9Rv1x2PQeOMGp/P6UM88r0KJPQhqfV6R9oMGY+1jTVFC2oY3R5qlYEXfxWmkl+ACnWa0G3Sd2y0sKCphSW/knDyDxAE/Ag0tLTkpI0tQ75egUPZ7Bu2df+qhYbmVSVKl6dlzyGM+GENM3edZ9CMBTRu3xU7+6Ipfq5N/5H4h1pl8Dhhhce76h4nen36NRXqNKZDp04MGjKEM2fOoNfr0ev1nDt3jiFDh9K+Y0eaN2/Or7/+qmqsAJOnTOFRmBW9Frw8v70WaHgUZsVnSb6n1FCpUiV27drFhQsXqNegAd/Pm2dof/3s2TN+/fVXmjRrxuo1a1i5cqVqV4CTMrccT5s2jaFDhjBoyBC6duvGgQMH0Ol0KIqCt7c34ydMwMXVleLFi7N7926ssqkZYVaZW37t7e3Zu3cvYWFh1G/YkC+mTePevXsZbn4qjCdTQ4v26dOHY8eOERgYiIODAy4uLsycOZOaNWsCzycdW7ZsWbJJx5J2wnF3d6dChQqsXLkSSJhYZfv27QQEBGBvb0+DBg2YPn06zZu/2GL95ZIOLVqhRn3c+gyjplu7TO0DICwwgM2zxlO5UYuXNv/JrKQzEI9qmzCzaIlCCe361p5IuNJnKjMQJ7p+6m9ObFiK37WE0Z2sgHggn20+6rTvTsu+w7F3yPodnESKorBl1jjsihZP1vwns5LOQJxWjk1lhlxIGJHln43LufTnBiIjwrAgoSBQAMcyFXHp+T4NO/U06jB2iqKw+auxFCrmQLXmHpSv0wQraxvA/PILcO/qRf5Zv5gbZ4+hoBg+w1aWltRt1Ym2g0ZRqmL2TYT1+O4ttnz3OTWat6a2axtKlq+Uqd9f0hmI0z5OmMYMxAC6+DiObvmNUzvXEfjovqE9tV6vp3z58owYMYLx48djY2OjcqQJks7eOrJNfIr8Lv7bdGZvTXT9+nVmzZrFli1biI2NxcrKivj4hOGlOnfuzOTJk2nRooXKUT5nbjlWFIXffvuN+fPn4+XlhUajwcLCAp1OR4kSJXj//ff57LPPTGbocnPLL4C/vz+zZs1i9erVREZGYmFhgV6vl6FFTUimigFTlrQYmHXwZpb3k16H51cRcNuHYxuXcOXYHnTxOsNyS6uEpkEt+4xQbebhlwm47cOCD5/fHp2y8yL57LJv1IrEj2B25P2xnw//bFjK1X9S5rjW6514ve9wVWfGTU18rJab54+zftrzq+kz9t9QZSzr9H4X5phfSJiI7IeBHobnX+48k+mJCDMiO44f/re8ObRuCZeP/EV8khxbWSU0DfJ4d4RqMw+nRa/T4XvxJEs/HmRYFh8fj2Umm2gag5eXF1/PmcOWrVuIi3s+Zqu1dUKzis8mT1Z11ta0PHnyhAMHDtC/f3/DMlP9+jbHHCuKwqlTp3Bzez52Z3R0NPnypTLRh8rMMb+QMCLSnj176N27NyDzDJgSKQZUEBkShN/l08RERZKvQEEq1nNRtX11RnzetrLh/18eeHnnblMQGRLEnX/PoH0Wia1dQSrUbWbyOf6i3fORd0w9x+ae3x+O3VYxkoyJCAnk5qUzaKMisS1QkMoNmqnWRyCjxrd8zfB/U/9qefLkCUeOHCE8PJzChQvj7u6uavvqjEpabEqOs5/kN+cl5liKAdOhbgO4PKpg0eLUcVevI1JeULBocWq3enEQSZFdJL85r1DREjTwkONETilZsiS9evVSO4xcTXKcsyS/IruoM2CuEEIIIYQQQnVSDAghhBBCCJFHSTEghBBCCCFEHiXFgBBCCCGEEHmUFANCCCGEEELkUVIMCCGEEEIIkUdJMSCEEEIIIUQeJcWAEEIIIYQQeZQUA0IIIYQQQuRRUgwIIYQQQgiRR0kxIIQQQgghRB4lxYAQQgghhBB5lBQDQgghhBBC5FFSDAghhImKjghXOwQhhBC5nBQDQghhog6uW4I2OkrtMIQQQuRiUgwIIYQJUhQFz8N/ceP8CbVDEUIIkYtJMSCEECbo8d2bBD+6z7VTh9QORQghRC4mxYAQQpigqyf+Tvj35CH0er3K0QghhMitpBgQQggTdPVkQjEQEfyUBz5eKkcjhBAit5JiQAghTExkaDB3rl4yPL96UpoKCSGEyBlSDAghhIm5fvoISpKmQVIMCCGEyClSDAghskzasueMxCZCiR76XiX0ySOVohFCCJGbSTEghMiSmGcReJ84oHYYuU58XCzeZ/9JsfyqjCokhBAiB0gxIITIEt9zx7h2Yr/aYeQ6ty6fRRsVmWJ54uhCQgghRHaSYkAIkSU+pw/he/YYOl282qHkKldPpH4HwPfiSZmNWAghRLaTYkAIkWk6XTy+Z48RHRHK/WuX0v8BkSGKoqToL5AoPjYW3wsnjRyREEKI3E6KASFEpt2/donoiFAg4Q6ByB4Bd3wJfnQ/zfVpFQpCCCFEVkkxIHKtJ3d91Q4h10paAPhIx9Zsk16/AJmNWAghRHaTYkDkWn8t/gpdfJzaYeRKSQuAwPu3CXp4V8Voco9r6RRWMhuxEEKI7CbFgMiVwgMfc/viSe5dvah2KLlO0MO7BN6/nWyZzxm5O/CqXpx1OC0yxKgQQojsJMWAyJVunD0CSBOWnJDaib/PqcMqRJK7vDjrcFrSGm1ICCGEyAopBlSi1+vR63Rqh5FrJRYBPmfkJDW7pXbif9frHDHPIlSIJvfIaOdgmY1YCCFEdpJiQCUPvC9z/7qn2mHkSnHaGG5fShiCMeiBH4EP/FSOKPeIeRbBXa9zKZbrdfHcPJ9y1lyRMWnNOpwWaSokhBAiu0gxoBKf04fxliEZc8TtSyeJ08YYnktToezje+4Y+jQmGZM8Z13irMMWlla4dOnN6+8MSra+ULES9P50DsWcygAyG7EQQojsI8WASrxPH5JiIIe8OO69jIOffV6Wyxtnj8psxFnkfeYYLl16M2Xd3/T+dA5FHUsnW59YJExZn7A++NEDmY1YCCFEtrBSO4C8KOTxQwJuewMQ/Og+xUqVVTmi3ENRFHxOH0m27N6VC0RHhJG/kL06QeUSibMOpyVxNuIKdZoYMarcocPg0eSzK5TudpZW1rh06U2Tjt3RSZ8jIYQQ2UDuDKgg6dVVuTuQvR7dvEZE0ONky/R6Hb7njqoUUe6RdNbhtMhdmKzJSCGQlKWVNTa2+XIoGiGEEHmJFAMq8E7Sttpb2llnq7RORn1Oy6hCryojJ/o3JM9CCCGEWZFiwMi00c+4ffm04fmdf8/KkIzZKK1OrL7njslsxK8oIx2En967RbC/zEYshBBCmAspBozs5oUT6OKen5Tq4uO4eeG4ihHlHuGBj/H3vZLqupjIcJmN+BWkNutwWqTpmxBCCGE+pBgwstSaBUlToeyROOtwWmToy6xLbdbhNLeV2YiFEEIIsyGjCRmRXq/H+3TK8cG9Tx9Gr9NhYWmpQlS5R3on+z6nD9Fx+GQjRZO7JJ7gazQaqru25fqJA8nWl6/TmMe3fQyTksU8i8h0p1jxXOjT5DMMx8ZEE6uNkU7D2SQ6OpotW7Zw9uxZYmJiKFGiBD179qRRo0Zqh5Zr3Lx5k3Xr1vHgwQOsrKyoVasW7777LkWLFlU7tFwhPj6eP/74g8OHDxMZGYm9vT1dunShdevWaDQatcMTZkbuDBjJs9AgVn42mKiwkBTroiNC+W3SICJDglSILHeI08Zw88LLZ3ANeniHpxls6iKei3kWwf2rF6jVqjO13d/gRiojM931Oo9jpRo0e3sANvnyy2zEWXTn6iXmffg2x7b8lmx5dEQY07o1Ze+v89HLkKJZptPp+PLLLylTpgyDBg3iyJEj/Pvvv6xatYrGjRvTrFkzTp48qXaYZs3X15eOHTtSpUoV5s+fz6VLlzh1+hQTJkygdOnSjBgxgqgomSPjVSxfvpyKFSvSrVs39uzZg5eXF9u2baNNmzbUrFmTnTt3qh2iMDNSDBhBeNATlo3tyf1r59Pc5oH3JZaNeYfwwMdpbiPStn/Ft8n6YqRl949fGCGa3CU6PJT3528i7Kk/107spUy7iim2Kd26Ik8fe3P50O+8O3MZhR1KqRCpefM++w8Lx/ThUeAtrF4rnGydJp8lurLW7Fu1gFXTR0lBkAU6nY53332XGTNm0K9fP7yueHHu/DmOHjuK701ftmzdgqIoeHh4sGfPHrXDNUteXl40b96cmzdv8vOKn7l1+xb/HP+HU6dO4XPDh08+/YQ1a9bQpk0bIiMj1Q7XLE2ZMoVhw4bRsmVLTpw8weV/L3P02FGue19n/4H9lK9Qnm7durFs2TK1QxVmJFPFwPTp09FoNMkeTk5OhvWKojB9+nScnZ3Jnz8/7u7uXL16Nd39btu2jZo1a2Jra0vNmjXZsWNH5t+JiVIUhQ1ffoQuLoJipdK+PVrU0R5FH8W66SNQFMWIEZq/+9c9ObNzdYa2vXP5DJcP/p7DEeUuRUuV5dSOlTy6dZW645pTrlPVFNvYVylB/U/csC5qyeZZY3GqWE2FSM1XyGN/fp06HE1JW/K1K4NlEdvkG1hoyNfIkXwtnfn32H72r1qgTqBmbM6cOWzZsoW169byzbffUKlSJcM6S0tL3njjDfYf2E+btm3o2bMnd+/KqFiZER0dTZcuXXAu7czRY0d59913yZ8/v2G9k5MTn332GXv37eXKlSsMGzZMxWjN08aNG5kzZw5z5sxhxS8raNCggWGdRqOhRYsWbNu2jeHDhzNy5Ei5yyUyLNN3BmrVqsWjR48MDy8vL8O6b775hnnz5rFw4ULOnTuHk5MT7dq1IyIi7aEzT506Re/evRkwYACXL19mwIAB9OrVizNnzmTtHZmYe1cvcu/qJbqPfZMAv7Sv+j+++4Tu497kgfe/3PE6Z8QIzd+Jrb+gscz4R/nYxiVScGVC2NNH/HtoNxXfrk7hisXS3M7azoYa7zciIjgQryN/GjFC83dy13p0+jjyuZV66WfZumwhrKsX4ejW34jVxhgxQvMWExPDjz/+yLBhw+jatWua29na2rJy5Uqsra1ZsmSJ8QLMBTZt2sS9e/dYu3YtxYqlfZxo1KgRX836io0bN3Lv3j0jRmjeFEVh7ty5tO/QnrHjxqa5nYWFBd9+9y3VqlVj3rx5RoxQmLNMFwNWVlY4OTkZHg4ODkDCB3X+/Pl8/vnndO/endq1a7Nq1SqioqJYv359mvubP38+7dq1Y/LkyVSvXp3JkyfTpk0b5s+fn+U3ZUrO7F5HyXKORD9L+OK2yWeNvYO9Yb19icLY5LMG4FlYFI4VnDiza60qsZqjiOCnXD++H0WnB6BKy6pUaZn8yrVz7dLU6VIPC6uEj/vTu7dkmNFMuLBnCxY2lji6lE132/wOdhSv7ciZXWuMEFnuEB8Xy8ld67GsWAiNTfqDCNhULUpMZASeh6Tgyqht27YRGBjI8BHDDcvi4+P5ZOInfPTRR2zftt2wvGDBgvTv358VK1ag1WrVCNcsLVmyhHbt21GlShXDspMnTvLRRx8xatQogoKe94nr168fdnZ2LF++XI1QzdLZs2fx9PRkxIgRyZbPnj2bjz76iKVLlxqWWVpa8sGHH7Bz5078/f2NHaowR0omTJs2TSlQoIBSqlQppUKFCkrv3r2VW7duKYqiKLdu3VIA5eLFi8l+5q233lIGDhyY5j7Lli2rzJs3L9myefPmKeXKlXtpLDExMUpYWJjhce/ePQUwuYeFpYXSuk8rpa57HaV131bKrD+nK43aNzSsb9C2vjLrrxmKRz93pU7L2kqbd1srFpYWqsdtbo9yjcorveb3UYbv+Ehp8E6jZOsqNntNGb7jI6X/8kFKzQ61VI/VHB9FazoobvM6K27zOivNv+2YYn21wQ0N6yv1qq16vOb4yNeqtFKwVxWlYK8qik294snX57c0rCvYq4pCIWvV4zW3R/kK5ZWAxwGGx6xZswzr7O3tlavXrhrWbd22VfV4zfHx9dyvDTl88PCBUqVKFcO6QYMHJct/p06dVI/X3B6WlpaK/yN/Qw7XrV9nWGdhYaEcPnLYsO7ixYuqx5veIzQ0NDOnoCIHZaoY+Ouvv5StW7cq//77r3LgwAGlVatWiqOjoxIYGKicOHFCAZSHDx8m+5kPPvhAad++fZr7tLa2VtatW5ds2bp16xQbG5uXxjJt2jTVP8jykIc85CEPechDHvLI/CPxYrJQX6bmGejUqZPh/3Xq1KF58+ZUqlSJVatW4eLiApBifFtFUdId8zYrPzN58mQmTJhgeB4aGkr58uW5d+8e9vb2GXo/IuPCw8MpW7Ys9+/fp3Dhwun/gMg0yXHOkvzmPMlxzpMc5yzJb84LCwujXLlyL+1bIozrlSYds7Ozo06dOvj6+ho6ZQUEBFCq1PNhBZ88eYKjo2Oa+3ByciIgICDZsvR+BhI6etna2qZYbm9vL3/AOahw4cKS3xwmOc5Zkt+cJznOeZLjnCX5zXkWFjK6val4pd+EVqvl+vXrlCpViooVK+Lk5MSBA89nJo2NjeXo0aO4urqmuY/mzZsn+xmA/fv3v/RnhBBCCCGEEK8uU3cGJk6cyJtvvkm5cuV48uQJX331FeHh4QwaNAiNRsO4ceOYPXs2VapUoUqVKsyePZsCBQrQr18/wz4GDhxI6dKlmTNnDgBjx46lZcuWzJ07l7fffpvff/+dgwcPcvz48ex9p0IIIYQQQohkMlUMPHjwgL59+xIYGIiDgwMuLi6cPn2a8uXLA/Dpp58SHR3NyJEjCQkJoVmzZuzfv59ChQoZ9nHv3r1kt4ZcXV3ZuHEjU6dO5X//+x+VKlVi06ZNNGvWLFNvxNbWlmnTpqXadEi8OslvzpMc5yzJb86THOc8yXHOkvzmPMmx6dEoisy+JIQQQgghRF4kvTeEEEIIIYTIo6QYEEIIIYQQIo+SYkAIIYQQQog8SooBIYQQQggh8igpBoQQQgghhMijTLoYOHbsGG+++SbOzs5oNBp27tyZbL2iKEyfPh1nZ2fy58+Pu7s7V69eTbaNu7s7Go0m2aNPnz5GfBemLTtyDHDq1Ck8PDyws7OjSJEiuLu7Ex0dbaR3YbpeNb937txJ8flNfGzZssXI78Y0ZcdnOCAggAEDBuDk5ISdnR0NGzZk69atRnwXpis78nvr1i26deuGg4MDhQsXplevXjx+/NiI78K0pZfj7du306FDB0qUKIFGo8HT0zPFPrRaLaNHj6ZEiRLY2dnx1ltv8eDBA+O8AROXHfldvnw57u7uFC5cGI1GQ2hoqFFiNxevmuPg4GBGjx5NtWrVKFCgAOXKlWPMmDGEhYUZ703kYSZdDDx79ox69eqxcOHCVNd/8803zJs3j4ULF3Lu3DmcnJxo164dERERybb74IMPePTokeGxbNkyY4RvFrIjx6dOnaJjx460b9+es2fPcu7cOUaNGiVTjfPq+S1btmyyz+6jR4+YMWMGdnZ2dOrUyZhvxWRlx2d4wIAB+Pj4sGvXLry8vOjevTu9e/fm0qVLxnobJutV8/vs2TPat2+PRqPh0KFDnDhxgtjYWN588030er0x34rJSi/Hz549w83Nja+//jrNfYwbN44dO3awceNGjh8/TmRkJF26dEGn0+VU2GYjO/IbFRVFx44dmTJlSk6FadZeNcf+/v74+/vz3Xff4eXlxcqVK9m7dy/vvfdeToYtEilmAlB27NhheK7X6xUnJyfl66+/NiyLiYlR7O3tlaVLlxqWtWrVShk7dqwRIzVfWc1xs2bNlKlTpxozVLOU1fy+qH79+srQoUNzMlSzldUc29nZKatXr062r2LFiikrVqzI8ZjNSVbyu2/fPsXCwkIJCwszbBMcHKwAyoEDB4wWu7l4McdJ+fn5KYBy6dKlZMtDQ0MVa2trZePGjYZlDx8+VCwsLJS9e/fmYLTmJyv5Terw4cMKoISEhORIfLnBq+Y40ebNmxUbGxslLi4uewMUKZjtpVs/Pz8CAgJo3769YZmtrS2tWrXi5MmTybZdt24dJUqUoFatWkycODHFnQORuozk+MmTJ5w5c4aSJUvi6uqKo6MjrVq14vjx42qFbTYy8xlOdOHCBTw9PeVqSQZlNMctWrRg06ZNBAcHo9fr2bhxI1qtFnd3dxWiNh8Zya9Wq0Wj0SSbbTRfvnxYWFjIcSKbXLhwgbi4uGS/B2dnZ2rXrp3msUQIUxcWFkbhwoWxsrJSO5Rcz2yLgYCAAAAcHR2TLXd0dDSsA3j33XfZsGEDR44c4X//+x/btm2je/fuRo3VXGUkx7dv3wZg+vTpfPDBB+zdu5eGDRvSpk0bfH19jRuwmcnoZzipX375hRo1auDq6prj8eUGGc3xpk2biI+Pp3jx4tja2jJs2DB27NhBpUqVjBqvuclIfl1cXLCzs2PSpElERUXx7NkzPvnkE/R6PY8ePTJ6zLlRQEAANjY2FC1aNNnylx1LhDBlQUFBzJw5k2HDhqkdSp5gtsVAIo1Gk+y5oijJln3wwQe0bduW2rVr06dPH7Zu3crBgwe5ePGisUM1Wy/LcWKb32HDhjFkyBAaNGjADz/8QLVq1fj111+NHqs5Su8znCg6Opr169fLXYEsSC/HU6dOJSQkhIMHD3L+/HkmTJhAz5498fLyMnaoZull+XVwcGDLli3s3r2bggULYm9vT1hYGA0bNsTS0lKNcPOMtI4lQpiy8PBw3njjDWrWrMm0adPUDidPMNtiwMnJCSDFVY8nT56kuEqVVMOGDbG2tpar1hmQkRyXKlUKgJo1aybbpkaNGty7d88IUZqvzH6Gt27dSlRUFAMHDjRKfLlBRnJ869YtFi5cyK+//kqbNm2oV68e06ZNo3HjxixatMjoMZuTjH6G27dvz61bt3jy5AmBgYGsWbOGhw8fUrFiRaPGm1s5OTkRGxtLSEhIsuXpfR8KYWoiIiLo2LEjBQsWZMeOHVhbW6sdUp5gtsVAxYoVcXJy4sCBA4ZlsbGxHD169KVNKK5evUpcXJzhJFakLSM5rlChAs7Ozvj4+CT72Rs3blC+fHmjxmtuMvsZ/uWXX3jrrbdwcHAwZphmLSM5joqKAkgx+pWlpaWMdpOOzH6GS5QoQZEiRTh06BBPnjzhrbfeMma4uVajRo2wtrZO9nt49OgRV65ckSaFwmyEh4fTvn17bGxs2LVrF/ny5VM7pDzDpHtlREZGcvPmTcNzPz8/PD09KVasGOXKlWPcuHHMnj2bKlWqUKVKFWbPnk2BAgXo168fkHDFb926dXTu3JkSJUpw7do1Pv74Yxo0aICbm5tab8ukvGqONRoNn3zyCdOmTaNevXrUr1+fVatW4e3tLeO08+r5TXTz5k2OHTvGX3/9Zey3YPJeNcfVq1encuXKDBs2jO+++47ixYuzc+dODhw4wB9//KHW2zIZ2fEZ/u2336hRowYODg6cOnWKsWPHMn78eKpVq6bGWzI56eU4ODiYe/fu4e/vD2C4+OLk5ISTkxP29va89957fPzxxxQvXpxixYoxceJE6tSpQ9u2bVV5T6bkVfMLCXe/AgICDPvx8vKiUKFClCtXjmLFihn5HZmeV81xREQE7du3JyoqirVr1xIeHk54eDiQ0NRQmhTmMDWHMkpP4hBeLz4GDRqkKErCsHbTpk1TnJycFFtbW6Vly5aKl5eX4efv3buntGzZUilWrJhiY2OjVKpUSRkzZowSFBSk0jsyPa+a40Rz5sxRypQpoxQoUEBp3ry58s8//xj5nZim7Mrv5MmTlTJlyig6nc7I78D0ZUeOb9y4oXTv3l0pWbKkUqBAAaVu3bophhrNq7Ijv5MmTVIcHR0Va2trpUqVKsr333+v6PV6Fd6NaUovx7/99luq66dNm2bYR3R0tDJq1CilWLFiSv78+ZUuXboo9+7dU+cNmZjsyO+0adNS3ea3335T5T2ZmlfNcVo/Dyh+fn6qva+8QqMoivKqBYUQQgghhBDC/JhtnwEhhBBCCCHEq5FiQAghhBBCiDxKigEhhBBCCCHyKCkGhBBCCCGEyKOkGBBCCCGEECKPkmJACCGEEEKIPEqKASGEEEIIIfIoKQaEEEIIIYTIo6QYEEIIIYQQIo+SYkAIIYQQQog8SooBIYQQQggh8qj/A+vMfA4o/EKFAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(8, 6))\n", "fig.suptitle(\"Figure 5 - C grid structure\", fontsize=16)\n", @@ -884,7 +820,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": { "hide_input": true }, @@ -903,21 +839,11 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": { "hide_input": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WARNING: File /Users/erik/Library/Caches/parcels/NemoNorthSeaORCA025-N006_data/coordinates.nc could not be decoded properly by xarray (version 2023.9.0). It will be opened with no decoding. Filling values might be wrongly parsed.\n", - "INFO: Output files are stored in Cgrid-stuck.zarr.\n", - "100%|██████████| 864000.0/864000.0 [00:05<00:00, 172187.26it/s]\n" - ] - } - ], + "outputs": [], "source": [ "filenames = {\n", " \"U\": {\"lon\": mesh_mask, \"lat\": mesh_mask, \"depth\": wfiles[0], \"data\": ufiles},\n", @@ -940,7 +866,7 @@ "time = np.zeros(npart)\n", "\n", "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=lon, lat=lat, time=time\n", + " fieldset=fieldset, pclass=parcels.Particle, lon=lon, lat=lat, time=time\n", ")\n", "\n", "output_file = pset.ParticleFile(name=\"Cgrid-stuck.zarr\", outputdt=timedelta(hours=1))\n", @@ -955,7 +881,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": { "hide_input": true }, @@ -966,7 +892,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": { "hide_input": true }, @@ -980,22 +906,11 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": { "hide_input": true }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6), constrained_layout=True)\n", "fig.suptitle(\n", @@ -1075,22 +990,11 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": { "hide_input": true }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(8, 6))\n", "fig.suptitle(\"Figure 8. Tolerance for getting stuck = red line\", fontsize=16)\n", @@ -1117,22 +1021,11 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": { "hide_input": true }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(8, 6))\n", "fig.suptitle(\"Figure 9. - B grid structure\", fontsize=16)\n", @@ -1211,13 +1104,13 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": { "hide_input": true }, "outputs": [], "source": [ - "LandParticle = parcels.JITParticle.add_variable(\"on_land\")\n", + "LandParticle = parcels.Particle.add_variable(\"on_land\")\n", "\n", "\n", "def Sample_land(particle, fieldset, time):\n", @@ -1228,7 +1121,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": { "hide_input": true }, @@ -1242,20 +1135,11 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": { "hide_input": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in Cgrid-diffusion.zarr.\n", - "100%|██████████| 864000.0/864000.0 [00:06<00:00, 143406.54it/s]\n" - ] - } - ], + "outputs": [], "source": [ "filenames = {\n", " \"U\": {\"lon\": mesh_mask, \"lat\": mesh_mask, \"depth\": wfiles[0], \"data\": ufiles},\n", @@ -1309,7 +1193,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": { "hide_input": true }, @@ -1320,7 +1204,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": { "hide_input": true }, @@ -1331,22 +1215,11 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": { "hide_input": true }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(14, 8))\n", "fig.suptitle(\"Figure 10. Diffusion added to C grid advection\", fontsize=16)\n", diff --git a/docs/examples/documentation_unstuck_Agrid.ipynb b/docs/examples/documentation_unstuck_Agrid.ipynb index 629b71b15..bbdfe7650 100644 --- a/docs/examples/documentation_unstuck_Agrid.ipynb +++ b/docs/examples/documentation_unstuck_Agrid.ipynb @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -83,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -130,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -149,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -158,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -176,20 +176,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/IAAAIBCAYAAADqE4Q7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hUVfrA8e+dlknvFUhCDRB6B0EQECyoiIhYEcu6NlQUxbWAP11lRQVsu+oKiKLoSpEmKAiKNEHphB46AQLpZer5/ZFkZEhC7kAwlPfzPHme5M6975y5czLnnjnnvkdTSimEEEIIIYQQQghxUTDUdAGEEEIIIYQQQgihn3TkhRBCCCGEEEKIi4h05IUQQgghhBBCiIuIdOSFEEIIIYQQQoiLiHTkhRBCCCGEEEKIi4h05IUQQgghhBBCiIuIdOSFEEIIIYQQQoiLiHTkhRBCCCGEEEKIi4h05IUQQgghhBBCiIuIdOSFEEL8ZTRNQ9M0li5dWtNFEZeR5ORkNE1j8uTJNV2U827y5MlomkZycnJNF0UIIcR5JB15IYQQZ2X06NGejnlVP0KfjIwMvvnmG0aOHMnVV19NZGTkX/rlR1mH99577z3vzyWEEEKIs2eq6QIIIYS4+MXGxuraLyUlBYCAgIDzWZyL1n/+8x9eeeWVmi6GEEIIIS5w0pEXQghxzjIyMnTtt23btvNckoubpmnUqVOHNm3a0KZNGxISEnjwwQdrulhCCCGEuMBIR14IIYS4QLz44ouMGjXK8/fevXtrrjBCCCGEuGDJPfJCCCH+MlXd752ZmclTTz1FvXr1sFqtxMfHc+utt/LHH3+c8Xg9Cb727t3rOf70DvLpxy9ZsoT+/fsTHx+P0Wgsd894cXEx7777Lt27dycqKgqLxUJcXBz9+/dnwYIFPpwRb0aj8ayPrUnbt29n7Nix9O7dm/r16+Pv709ISAitW7fmxRdfJDMzs9JjT01EZ7fbGTt2LC1btiQwMJDQ0FB69uxZ5TktKiritddeo2nTpvj7+xMTE8N1113H4sWLz3jc6XVi3759PPjggyQmJmK1Wqlfvz4vvvgiBQUFnmM2b97MXXfdRZ06dbBarTRs2JDXXnsNh8NR4XPk5OQwbdo07rzzTpo3b05ERARWq5WkpCTuuOMOVq1adcYyrl69mjvvvJO6detitVoJDAwkKSmJ7t278+qrr3Lw4MEzHl/Ra05JSUHTNNq0acPRo0d9Ol4IIcQFQgkhhBBnYdSoUQpQvjQlZfsvWbKk3GPbt29XCQkJnn38/PxUSEiIApTFYlGzZ8+u9PhJkyYpQCUlJVX63Onp6Z7j09PTKz1+woQJStM0BajQ0FBlNpvVkCFDPPvu2LFDNWzY0BNL0zQVGhrq+RtQDz/8sO5zcianlrmic1bdkpKSFOD1en05rux8hIWFec4hoGrVqqW2bdt2xmPfe+891bFjRwUos9msgoKCvGJ++umnFR5/4sQJ1bp1a8++JpNJhYWFeY778MMPPc8xadIkr2NPPb/Tp0/3HBcSEqKMRqPnsW7duim73a7mzp2rAgICPHXj1Nd42223VVi+U/9PABUUFKT8/Py8XtuECRMqPHby5Mlez3Hq/0TZz+mv6Uz/C+vXr1fx8fEKUL169VK5ubkVPq8QQogLn4zICyGEqHEOh4OBAwdy+PBhoqKimDFjBgUFBeTk5JCWlkbXrl0ZMmTIeS/H0aNHGT58OEOGDGH//v1kZ2dTVFTESy+9BEB2djZ9+vRh586d9OzZk19++YWioiKys7PJzs7mnXfeISgoiH//+99MmDDhvJf3QtGpUyfee+89du3aRXFxMVlZWRQXF7No0SI6dOjAoUOHuOOOO84Y4+WXX+bgwYPMmjWLgoIC8vLy2LZtG506dUIpxRNPPEFOTk654x544AHWrVuHn58f//nPf8jLyyMrK4u9e/fSv39/nnjiCY4fP17la7j//vtp27YtW7ZsIScnh7y8PN59912MRiPLli3j//7v/7jzzju54YYb2Lt3L9nZ2eTm5vLCCy8A8PXXX7No0aJycePi4njqqadYtWoVWVlZ5OXlUVRUxJ49e3jiiScAGD58OOvWrfM6rrCwkMcffxylFHfddZfn3Obk5JCfn8/atWsZMWIEMTExVb42KJllcuWVV3LkyBEGDx7M/PnzCQ4O1nWsEEKIC1BNf5MghBDi4nTqSGNsbGylP5s3b/YcU7b/6aPLn3/+uWd08pdffin3XEVFRapx48bnfUQeUAMGDKg0xjPPPKMA1bNnT+VwOCrcZ8aMGQpQUVFRle6j18UyIn8meXl5KjY2VgFq2bJllT6nn5+fSktLK/f4sWPHlNVqVYD64osvvB5bvXq15/xUNGLvdDpV165dKx29PvX8pqamquLi4nIx7r77bs8+V199tXK73eX26datmwLU/fffX9XpKOfRRx+t8Niy1xYYGOhTParof+Hrr79WFotFAerJJ5+s8DUIIYS4uMiIvBBCiHN29OjRSn8qu3f4VP/73/8AuPLKK+nWrVu5x61WKyNGjKj2clfk+eefr3C7UoqJEycC8PTTT2MyVZwvtn///oSEhJCZmcnvv/9+3sp5sQgKCqJ79+4A/Prrr5XuN3DgQBo3blxue3R0NJ07dwZg48aNXo9NmzYNgDp16jB06NByxxqNRs9siqo89dRT+Pn5ldvet29fz+8jR45E07RK9zm9fHpcf/31QPlzExYWBoDdbufEiRM+xy3z7rvvMnjwYBwOB2PGjGHcuHEVvgYhhBAXF8laL4QQ4pwppc7p+LJkdmUdvor06NHjnJ5DD39/f9q0aVPhY1u3buXkyZMA3HvvvRgMlX8Xnp+fD8C+ffvo2LFj9Rf0AjR37lw+//xz1qxZw9GjRyksLCy3z5kSs53pPCUkJAB4zn+ZtWvXAiV1o7LO6ZVXXonJZMLpdJ6x/B06dKhwe2xsrOf39u3bn3GfrKysCh/fs2cPH374IUuWLGH37t3k5eXhdru99jn93NSvX5/GjRuzbds2OnbsyMMPP0zfvn1p3ry57qSIzz//PGPGjMFkMvHpp59yzz336DpOCCHEhU868kIIIWpc2T3MZR22itSqVeu8lyMyMrLSDvrhw4c9v+u55xqosDN7qXG73dx111189dVXnm0mk4nw8HAsFgtQkrm9uLjYK/v76c50v3bZ7IfTZ3ccO3YMOHPdsFqtREZGVpmdvbLnP3XmRVX7VDT7ZObMmdx+++3YbDbPtpCQEKxWK5qmYbfbycrKKndujEYj06ZN4+abbyY9PZ2RI0cycuRIAgIC6NKlCwMGDGDIkCEEBARUWKZ9+/YxZswYAN544w3pxAshxCVGptYLIYS4YNT0lN8zjXS6XC7P7xkZGSilqvw5fdm6S9Gnn37KV199hdFo5OWXX2bnzp3YbDZOnjxJRkYGGRkZDBw4EDj3mRuVqel6U5kTJ05w7733YrPZ6NmzJ0uXLqWwsJCcnByOHj1KRkaG57aSirRs2ZJt27Yxffp0/va3v9GsWTOKiopYtGgRjzzyCI0bN2bTpk0VHhsXF0evXr0AeO2111i9evV5eY1CCCFqhnTkhRBC1Ljo6GjAe9T7dIcOHar0sbIR0eLi4kr3qSjjuS/i4uI8v1fWebocld2n/sADD/DKK6/QoEGDcrMaMjIyzstzl2VsP9OUfZvNdk73mJ+L+fPnk5ubS3h4OHPmzKF79+74+/t77VPVubFYLAwYMICPPvqITZs2cfz4cf7zn/8QERHBgQMHKl3Nwc/Pjzlz5tCnTx9ycnLo06cPK1eurLbXJoQQomZJR14IIUSNK7svfenSpZXuc6bHwsPDgZKp1qdOYT7VuY5INmvWjJCQEODPzquAAwcOANC6desKH8/Pzz9vo8Ht2rUD4Oeff650tP+XX36p8v7486Xs3KSkpFQ6Bb6iJevOJDIykoceeoh//etfAKxbt67SLyr8/f357rvvuPbaa8nNzaVv374sX77cp+cTQghxYZKOvBBCiBpXNvX6l19+qbCjYbPZeOuttyo9vmXLlkDJ1O2ZM2eWe7yoqIhx48adUxlNJhP33XcfAJ999tkZM7BD+cRsl6rQ0FAANmzYUOHjr776Knl5eefluW+77TYA9u/fz2effVbucbfbzWuvvXZenluPsnOzY8eOCmeLrF+/ni+//LLCYyv7QqrMqSP7Z7olxGq1MnPmTPr160deXh7XXHMNv/zyi57iCyGEuIBJR14IIUSNu+2220hNTUUpxYABA/juu+8896Rv376dfv36nXEKcu3atenatSsAw4cPZ9GiRZ7jf//9d3r37u1JjHYuXnrpJerXr4/T6eSaa67hnXfe8Up8l5OTw4IFCxgyZEiFy+hVxe12k5mZ6fk5NQt6Tk6O12MVdfTKsrcnJyef1esrY7PZvJ6rop+yjuk111wDwCeffMLHH3+M3W4HSqaMP/XUU7z55ptERkaeU3kq07FjR2688UYAHn74YT755BPPedm/fz+33XYbK1eurHQ0/Hzr06cPBoOBkydPcuedd3puD7Hb7XzzzTf06dOn0gR606ZN44orruCjjz5iz549nu0ul4uFCxcycuRIADp37uxZqq4yfn5+TJ8+nZtuuon8/Hyuu+46lixZUj0vUgghRM2ogbXrhRBCXAJGjRqlAOVLU1K2/5IlS8o9lpaWpuLi4jz7+Pn5qdDQUM/vc+bM8Ty2cuXKcsevW7dOBQcHe/axWq0qMDBQASo2NlbNmzfP81h6errXsZMmTVKASkpKqvI17NmzR7Vs2dITC1BhYWEqJCTEa1uDBg10n5cy6enpXjHO9DNp0qRyx3fv3l3366hIUlKS7ucfN26cUkqprKws1bhxY892g8GgwsLClKZpClAPPfSQGjJkiALUkCFDKn3Oil5PmTMdn5mZ6fV+mM1mFRYWpgClaZr64IMPKn2OU8/36XWizJIlS6qs52eqP88995zXeQsNDVVms1kBqm7dumrq1KkVxi+Leer/Q2RkpDIYDJ5tCQkJKi0tTXdZ7Ha7GjBggAKUv7+/WrRoUaWvSQghxIVNRuSFEEJcEBo3bszGjRsZNmwYycnJKKWwWq0MGjSIVatWccUVV3j2rWgEslWrVvz2228MHjyYmJgY3G43UVFRPProo6xfv56mTZtWSznr1q3L2rVrmTJlCv369SM+Pp6CggLsdjt169bl5ptvZuLEiZdNYrGwsDBWrFjBk08+SXJyMkajEZPJRI8ePfjqq6/4z3/+c16fPzIykhUrVvDKK6/QuHFjDAYDJpOJa665hh9//JFHHnnkvD5/VcaMGcOUKVPo0KED/v7+OBwOGjRowD/+8Q/WrVtX6ZKLN954I1OmTGHo0KG0bNmS0NBQcnJyCA4OpkOHDrz66qts2bKFxo0b6y6L2Wzm66+/ZtCgQRQVFdGvXz9++OGH6nqpQggh/kKaUudpLRghhBCiGv3444/06dMHPz8/8vLyMJvNNV0kIYQQQogaISPyQgghLnhKKU+W7l69ekknXgghhBCXNenICyGEuCAsWbKEJ598krVr11JUVASUdOB///13brjhBhYvXoymaTz77LM1XFIhhBBCiJolU+uFEEJcEGbNmsXNN9/s+Ts8PJyioiJPdnRN03jrrbcYPnx4TRVRCCGEEOKCIB15IYQQF4SMjAz++9//snjxYvbs2cPx48dRSpGQkEC3bt147LHHaNeuXU0XUwghhBCixklHXgghhBBCCCGEuIjIPfJCCCGEEEIIIcRFRDryQgghhBBCCCHERUQ68kIIIYQQQgghxEVEOvJCCCGEEEIIIcRFRDryQgghhBBCCCHERUQ68kIIIYQQQgghxEVEOvJCCCGEEEIIIcRFRDryQgghhBBCCCHERUQ68kIIIYQQQgghxEVEOvJCCCGEEEIIIcRFRDryQgghhBBCCCHERUQ68kIIIYQQQgghxEVEOvJCCCGEEEIIIcRFRDryQgghhBBCCCHERUQ68kIIIYQQQgghxEVEOvJCCCGEEEIIIcRFRDryQgghhBBCCCHERUQ68kIIIYQQQgghxEVEOvJCCCGEEEIIIcRFRDryQgghhBBCCCHERUQ68uKy0aZNGzRNY+nSpeUey8vLIyIiguXLl1cZZ+/evWiaxrfffnseSnnp+uOPP+jUqRMBAQFomkZ2dnZNF4mlS5eiaRpr166t6aJUC6mbQlzeRo8ejaZpnh9/f39SU1MZP348SinPfr60eRe7vXv3Mnr0aA4fPuzTccOHD0fTNEaPHn1+ClaBHj160K9fvyr3CwoK+kvLdSkYPXo0K1asOKtjZ82axYcfflhhzKCgoHMtmm7Vec0yefJkr8+K8PBwOnfuzOzZs6uhpNWnrJyZmZk1XZQLknTkxWVh27ZtrFu3DoCpU6eWezw4OJhHH32U559//q8u2mXj0UcfxeVyMW/ePFauXElwcHBNF0kIIS45/v7+rFy5kpUrVzJv3jxuuOEGnnrqKT744APPPpdTm7d3715eeeUVnzrybrebr7/+Gqj4muF8+fDDD3n77bf/sue7nLzyyivV3pF/4IEHWLJkybkWTbc2bdqwcuVKmjRpUm0xFyxYwMqVK5kyZQpWq5WbbrqJBQsWVFt8cX5JR15cFqZOnYrRaKRXr158++232O32cvvcd999LFu2zNPhF9UrLS2Na6+9lquuuopOnTphNBprukjVRimFzWar6WIIIQQGg4FOnTrRqVMnevbsyZgxY7jqqquYMWOG134XQptXVFTk0/a/ypIlSzh8+DB9+/Zl165d/Pbbb+f1+cpeb9OmTUlJSTkvz2G323G73ecldpnLrS2sXbs27du3/8ueLyQkhE6dOhEYGFhtMdu2bUunTp244YYbmD17NmFhYbz//vvnFLO4uLiaSieqIh15cVn48ssv6dmzJ8OHDyc7O5v58+eX26du3bq0bduWzz77zOf4U6ZMoWvXrkRERBAeHk6PHj3KNfynTmE69Wf06NFs3LgRTdNYtGiR1zFut5vExESGDx9e6XNXNBVv7dq15W4jmDhxIqmpqfj7+xMZGUnXrl1Zs2aN53GlFG+99RaNGjXCz8+PevXqMW7cOF2vf9asWbRu3Rqr1UpcXByPPvoo+fn5wJ9TwXJycnj11VfRNI0ePXpUGkvTNMaMGcOzzz5LdHQ0wcHB3HvvveTl5Xntl52dzeOPP07t2rXx8/Ojbt265UaXPv74Y5o0aYKfnx+JiYm8+OKLOJ3OM76W4uJinn76aWrVqoWfnx/Nmzfnyy+/9Nrn3nvvpVmzZsyfP5+WLVvi5+fH7NmzPdPsfv/9dzp27Ii/vz+tW7fm999/p7i4mIcffpiIiAhq167N+PHjyz33ypUr6dmzJ4GBgYSGhnLHHXdw7Ngxr33GjBlDgwYNsFqtxMTE0Lt3b9LT08u9hscee4zw8HDi4+N55plnqnzdQohLV3BwMA6Hw2ubL21edXzelk2RXblyJVdffTWBgYE888wznjZi3rx5DBw4kJCQEG699VbP8z7yyCPEx8fj5+dH27Zt+eGHH8qVb968eVxxxRUEBAR42uB169axdOlSrrrqKgDat2/vaXerMnXqVIKDg5k0aRIWi6VcG1CZnJwc7rrrLoKDg4mOjubZZ59lzJgxXs95ptdbUXv+3Xff0bhxY6xWKx06dPBqt88kOTmZxx57jLFjx5KUlIS/vz8nTpwASt6LFi1aYLVaqVWrFi+88EKF79WqVavo2bMnAQEBJCcnM3HiRK/nqKwthOppz2w2G//4xz9ISkrCz8+PJk2aVNoeL126lNatWxMYGEiHDh34/fffPfuUnf8RI0Z46kDZ9dHbb79N+/btCQ0NJSYmhn79+rFjxw6v+J999hlbtmzxHHvvvfcCFU+t379/P7feeithYWEEBATQs2fPclPhy96b999/n6SkJEJDQ+nfvz/Hjx8/43ta0dR6TdN48803GTVqFLGxsURFRTF06FAKCgrOGKsiwcHBNGzY0PMe6Lm2LTsHv/32G507d8ZqtfLee+8BJQM4AwYMICIigoCAAFq2bMlXX33lOfZsrzv1XAddNpQQl7iVK1cqQE2cOFE5HA4VFRWlBg4cWOG+w4YNU02bNj1jvPT0dAWo//3vf55tr7zyivroo4/UokWL1Pz589Vdd92l/Pz81Pbt273KcerPK6+8ogD15ZdfKqWU6tixoxo8eLDXc33//fcKUJs3b660PN27d1fXX3+917Y1a9YoQC1ZskQppdTPP/+sAPXMM8+on376Sc2dO1e9/PLL6ocffvAc8/jjjyt/f3/12muvqR9//FG98sorymw2q3//+99nPB/fffed0jRNDRo0SM2fP1+9//77Kjg4WPXq1UsppVROTo5auXKl8vf3V/fff79auXKl2rJlS6XxAJWQkKD69eun5s2bp95//30VFBSkbrvtNs8+xcXFqnXr1io8PFyNHz9eLV68WE2ePFk98MADnn3effddBahHHnlELViwQP3zn/9UZrNZ3XfffZ59lixZogC1Zs0az7YBAwYoq9Wq3nrrLbVgwQJ17733KkBNmTLFs8+QIUNUeHi4atCggZo8ebJavHix2rFjhxo1apSyWCyqRYsWatKkSWrevHmqWbNmKjExUd1xxx3qqaeeUj/88IN69NFHFaCWL1/uiblixQplsVhU//791Zw5c9S0adNUgwYNVMeOHT37fPbZZ8pkMqnXX39dLVmyRM2aNUs9/fTTav369UqpP+tmYmKievzxx9UPP/ygRo0apYAq30chxMVv1KhRKjAwUDkcDuVwOFROTo763//+pywWixo/fny5/fW0edX1eTtp0iQFqLp166o33nhD/fTTT2rlypWez+FatWqp5557Ti1atEj99NNPymazqXbt2qk6deqoTz/9VC1YsEDdddddymQyqY0bN3riTps2TWmapvr3769mzpyp5s2bp/7xj3+oOXPmqJycHPXBBx8oQE2aNMnT/lb1ekNDQ9U999yjlFLqpptuUrGxscrpdFZ5/m+++WYVGhqqPvzwQzVv3jx14403qtq1a6tTL7cre71KlW/P161bp4xGo6c9fO+991RycrKyWCxq1KhRZyxLUlKSiouLU1deeaWaOXOmmj17tsrPz1dvv/22MhqN6plnnlE//PCDmjBhggoKClLPPfdcufcqKSlJvf76615t4ffff+/Zr7K2sDraM6WUuvHGG1VERISaMGGC+uGHH9STTz6pNE1T8+fP9ypDZGSkat68uZo6daqaM2eOSk1NVXXq1FF2u10p9ed14OOPP+6pAzk5OUoppZ588kk1efJktWTJEvXdd9+pa6+9VkVGRqoTJ04opZTatWuXuu6661S9evU8x+7atUsp9ef/W5nc3FyVnJyskpKS1BdffKFmzZqlunTpogIDA1VaWprXe1OnTh3Vp08fNWfOHDVp0iQVGhrqdZ1TkYquWQBVp04ddccdd6jvv/9ejR8/XlksFq/3syJl7/Hx48c925xOp4qLi1O9e/dWSum7th01apQym82qQYMG6oMPPlBLlixR69evVzt27FChoaGqWbNm6vPPP1c//vijGjdunBozZoznWD3XnaeXU0+9uZxIR15c8h577DHl5+ensrOzlVJKPfLII8pqtXo+xE81ceJEpWmays3NrTReRR35U7lcLuVwOFRKSop6/vnnK9xnx44dKjw83OtC6L///a+yWq3q5MmTnm233nqrV8NXET0d+bFjx6qIiIhKY+zatUtpmqY++ugjr+0jRoxQcXFxyuVyVXps69atVYcOHby2ffnll17Pr5RSgYGBVV54KKU8F3qnXjT997//VZqmeRrCjz/+WAFqxYoVFcZwOp0qKipK3XrrrV7bX3/9daVpmtq9e7dSqnyjuGHDBgWoDz74wOu4Pn36qKSkJM/fQ4YMUYBavXq1135lneZTL3TmzJmjAK8G2ul0qpiYGPXkk096tl155ZWqS5cuyu12e7Zt3rxZaZqm5s2bp5RS6tFHH1Vt2rSp5Mz9WTdPf91XXHGF54sVIcSlq+wz6PSfe++91+uzpYyeNq+6Pm/LLsjffPNNr/3KPocfeeSRcmUzmUzlvvjt0KGD57ncbreqXbu26tu3b6Xlr6jzcybffvutAtSCBQuUUkp98803ClALFy4843Fbtmwp96Wv0+lU9erVq7Ajf/rrVap8e37bbbeVaw8/+ugjBejqyEdFRamCggLPttzcXBUUFFTu2uSDDz5Q/v7+KjMzUyn153v10ksvee3XrVs31blzZ8/flbWF1dGe/fTTTxWe91tvvVW1b9/eqwyapnkNePz4448KUMuWLfNsA9TYsWMrfT6lSt6vwsJCFRQU5HU9NGTIEJWamlpu/9M78hMmTChXlry8PBUREaGGDBni2ZaUlKRq166tiouLPdteeOEFZTabz3i9VVlH/tTzoZRSd955p6pfv/4ZX2vZe5yRkaEcDoc6fPiwZ5Dh9GtBpSq/ti37zPnmm2+89r/jjjtUdHR0hdfaSum/7jy9I19VvbncyNR6cUlzuVx88803XH/99YSGhgJw5513UlxcXO5+QYCoqCiUUhw9etSn50lLS+Pmm28mNjYWo9GI2Wxm+/btXtOzyuTm5nLTTTfRuHFjr+RDgwcPxmw2e6aNnThxgtmzZ3P//ff7VJaKtGnThpMnT3Lvvffy448/UlhY6PV42ZT+W265BafT6fnp1asXGRkZHDhwoMK4+fn5rF+/nkGDBnltv/XWWzGZTCxbtuysynvDDTd43UM/YMAAlFKeKV2LFy+mSZMmdO7cucLjt23bRmZmJrfddpvX9ttvvx2lVKWZmsvKW9Fx+/bt8zoPUVFRdOjQoVwMg8FAz549PX83atQIgN69e3u2GY1G6tev74lXWFjI8uXLufXWW3G5XJ7zn5KSQnx8vGcqZZs2bVi3bh3Dhw/n119/LTdVtkyfPn28/m7atCkHDx6scF8hxKXF39+fNWvWsGbNGn799VcmTJjAzJkz+fvf/15uXz1tXnV/3l533XUVxjl9+w8//EDz5s1p1KhRuXap7DNx+/btHDx4kPvuu6/S8vtq6tSpnum6UNIehYSEVDm9vqxMN954o2eb0WisNAt9ZefhVKtXry7XHg4cOLDK48r06NGDgIAAz98rVqwgPz+fW2+91euc9uzZk6KiIjZv3ux1/M0331zu77Vr1+JyuTzbTm8Lq6s9++GHH4iIiKBnz57l3v9169Z5lSEhIYHU1FTP302bNgXQ1e6tWrWKq6++msjISEwmEwEBAeTn51d4/VaVZcuWkZqa6lWWoKAgbrjhhnLXQ927d8fPz8+rzA6Ho9ztB3qcS5sfFxeH2WwmISGBiRMn8uKLL/Lggw8Cvl3bnl6fFy9e7Ll1pCJne92p9zrociEdeXFJ+/HHHzl27Bg33HAD2dnZZGdn07RpU2rXrl1hJlqr1Qr4lmgnLy+PPn36sG/fPt555x2WLVvGmjVraNmyZbmEH263mzvvvJPs7GymT5+OxWLxPBYYGMjtt9/Op59+CsAXX3yByWRi8ODBZ/PSvfTs2ZPPP/+cLVu20LdvX6Kiorjnnns4efIkAJmZmSiliIqKwmw2e36uueYagEo/ULOzs1FKERcX57XdZDIRGRnpie+rmJgYr7/Dw8Mxm80cOXIEKPmSIyEhodLjs7KyAMqVq+zvysqVlZXlKXtVx51exjL+/v5e72vZ72FhYV77WSwWT/3IysrC5XLx1FNPeZ1/s9nM4cOHPef/3nvvZdy4cSxcuJBu3boRHR3NE088Ua6+num5hBCXNoPBQLt27WjXrh1XXHEFw4YN46WXXuLjjz9my5YtXvvqafOq+/O2ss/O07dnZmaybt26cp+Jb7zxhuczseye7zOVzxc5OTnMnz+fG264gby8PLKzsykuLubaa69lxowZZzxPR44cwWw2ewYNKntdVW0/Pebp+0VERGAymXS8morPKZR0hk49p2VZ0E9v608/PiYmBofD4bUU2On7VFd7lpmZycmTJ8vF+Pvf/47T6fRcD0DFbR5UnXRt//799OnTB5fLxUcffcTy5ctZs2YNMTExZ9VmZmVllfs/gJL/hdP/D862zBWpKJbepIOLFi1izZo17Nq1i9zcXE8uI1+ubQMCAsol4Kvqc+Nsrzv1XgddLvR9EghxkSrrrA8dOpShQ4d6PXb48GEyMjK8PnTLLkhO78idycqVKzl48CBz586lZcuWnu05OTnUrl3ba98XXniBH374gZ9//pn4+PhysR588EE+/vhj1q9fz6RJk7j11lurXKbNarWWy8JfUUf1rrvu4q677iIzM5PvvvvO08h++umnREREoGkav/76q1cntExlWXTDwsLQNK3caI7T6eTEiRNEREScseyVOf0b6aysLBwOh+ecRUZGsnHjxkqPL3ve08uVkZHh9XhFxzmdTk6ePOm1T0XH6UmYpFfZefzHP/5B//79yz0eFRUFlFygP/HEEzzxxBMcOnSIadOmMXLkSKKionjppZeqrTxCiEtL2Qjl5s2bvUYL9bR51f15W9ln5+nbIyIiaNGihefL7crKBvi8Rnxlvv32W2w2G59++mmFzztnzpxyM9DKxMfH43A4yMnJ8erMVzbCqqcNiY+PL3f8yZMndScvreicAsyYMYM6deqU279u3bpefx87doxatWp5/W02mz1tUkXPUV3tWUREBNHR0RUmJwZ9X4RUZcGCBeTn5zNjxgxPZ7jsGuBsREREsG3btnLbMzIyzvp66Hxr2bKl1/tZxpdr24rqcmRk5Bn/L8/2ulOug7zJiLy4ZBUWFjJr1iz69+/PkiVLvH6++eYb3G4306ZN8zomPT2d0NDQCr9RrUzZt4CnfhCtWLGCvXv3eu03bdo0xowZw4cffkinTp0qjNWuXTtatWrFE088wYYNG3RNq69duzbbt29HKeXZ9uOPP1a6f1RUFPfffz9XX301aWlpAPTq1Qso+Qa1bCTn1J/KvkwICgqiVatWfPPNN17bp0+fjtPppFu3blWWvyJz5szxmjY3Y8YMNE3zLPPSu3dv0tLSWLVqVYXHp6SkEB0dXa5cX3/9NZqm0bVr1wqPK9te0XFJSUkVXvhUh8DAQDp37kxaWlqF5z85ObncMbVq1eLpp5+mRYsWnvdRCCEqUjZl+vQLdj1t3vn6vK1K79692bNnDwkJCRV+LpY9d+3atZk0aVKlcXwZ6Zw6dSrJycnlrhmWLFlCQkLCGafXl7VP3333nWeby+Vizpw5ul5vRTp06FCuPfz222/POl6XLl0ICAjg4MGDFZ7T07/QmTlzZrm/27Zte8blY6urPevduzfHjx/HYrFUGKeizt+ZmM3mcnWgqKgITdMwm82ebd988025L0r0zmrr2rUrmzdvZuvWrZ5tBQUFzJ0796yvh2qK3mvbyvTu3Ztvv/223IpDZc72uvNUch0kI/LiEjZ79mzy8/MZNmxYhcudtW/fnqlTp/Lkk096tq1Zs4YuXbpgMOj/jqtTp04EBQXx6KOPMnLkSA4dOsTo0aO9vsXes2cP9913H1dddRWpqaleF0S1a9f2+nbzwQcf5NFHH6VRo0a6LoAGDhzIp59+yuOPP07//v1Zvnx5ufv/R40axYkTJ+jRowcxMTFs2rSJBQsWeJa1a9SoEY8++ih33303I0aMoGPHjjgcDnbs2MGSJUuYNWtWpc8/evRo+vfvz+23386QIUPYs2cPzz//PL169TrjMnNnYrPZ6N+/P4888gjp6ek899xzDBw40DP97+677+bDDz+kX79+jBo1imbNmnHo0CF++eUXPv74Y4xGIy+//DKPP/440dHR3HDDDfzxxx+MGjWKoUOHlht1KNOiRQtuueUWhg8fTmFhIampqXzzzTcsWLCAKVOmnNVr0Wvs2LH07NmT2267jcGDBxMeHs7Bgwf58ccfGTp0KD169OChhx4iPDycTp06ER4ezvLly9mwYQOPPPLIeS2bEOLi4Xa7PW2M3W7n999/57XXXqNp06ZceeWVXvvqafPO1+dtVe655x4++ugjevTowTPPPEOjRo3Izs5m3bp12O123njjDTRN46233uL222/nlltu4Z577sHPz4+VK1fSvn17+vXrR6NGjTAajUycONFzn2/ZFwGnOnz4MD///DMvvvhihW3XnXfeyYQJE8jKyiI8PLzc402bNuXmm29m2LBhFBYWkpSUxH/+8x8cDsdZz+AaOXIk7du397SHe/bs4a233vK5E1smNDSU//u//+PZZ5/l4MGDXHXVVRgMBvbs2cN3333H9OnTve6pnzJlCv7+/rRp04Zp06axbNky5s2bV+XzVEd7dvXVV3PDDTdwzTXX8Oyzz9KiRQsKCgrYsmULu3bt4r///a9Pr71JkyZ89913dOvWjcDAQFJSUjz5bIYOHcpDDz3E1q1beeutt8pNVW/SpAkTJ07kq6++omHDhkRFRVX4hcTQoUMZN24c/fr147XXXiMoKIg333yToqIiRo4c6VN5a5qea9szGTVqFHPnzqVr1648++yzxMfHs3XrVgoLC3n22WfP+rpTroNOU2Np9oQ4z/r166cSExMrzNSrlFLvv/++AjzLaNhsNhUWFqY+/fTTM8atKGv9999/r1JTU5XValUtWrRQ8+fP98o+W5ZptKKf0zPPHj58WAHqX//6l+7X+uabb6o6deqowMBANWjQILVw4UKvrPFz5sxRvXr1UtHR0crPz0/Vr19fjRo1SjkcDk8Mt9ut3nvvPdWsWTNlsVhUeHi46tSpk3rnnXeqfP4ZM2aoVq1aKYvFomJiYtQjjzyi8vLyvPbxJWv9G2+8oYYPH64iIiJUUFCQuvvuu8tlPj158qR6+OGHVVxcnLJYLKpevXrqhRde8NrnP//5j0pJSVFms1nVrl1bvfDCC16vuaIMsEVFRWr48OEqPj5emc1mlZqaqr744guvuHoz2CpV+SoHla02cN1116nQ0FDl7++vGjZsqP7+97+rAwcOKKWUmjx5srriiitURESEslqtqmnTpurdd9+t8rkeffRRr6z7QohL0+lZ600mk6pbt6565JFH1NGjR7321dvmKVU9n7cVLXel1Jmzyufk5KinnnpKJSYmKrPZrOLj49V1112n5s6d67Xf7NmzVceOHZXValVhYWGqZ8+eat26dV5lq1evnjKZTKqyS9+33npLAZ6lxU63efPmSjN6l8nKylJ33nmnCgwMVJGRkWr48OFq5MiRKiwsTNfrrahdmDFjhmrUqJHy8/NTbdu2VatWrdLVniYlJalHH320wse++uor1b59e+Xv769CQkJU69at1UsvveR5v8reqxUrVqju3bsrq9WqEhMT1ccff+wVp7K2UKlzb8+UKqmjr7zyimrYsKGyWCwqOjpaXXXVVeWWgz29DMePH/csOVhm2bJlqk2bNsrf39/r+uizzz5T9erVU1arVXXq1En99ttv5c5dTk6OGjx4sIqMjFSAJwN9RW3+vn371MCBA1VISIjy9/dXPXr0UL/99pvXPhW9N//73/8UoNLT0ys8n0pVnrX+9Gz8Y8eOrbSel6ns//FUVV3bKlXxOSizZcsWdeONN6qQkBAVEBCgWrVqpaZNm+Z5XM915+nl1FNvLieaUqfMxxXiMjZ79mzuvvtuDh06RFBQUI2VY+LEiTz00EMcOHDApyn+lwpN0xg7dizPPPNMTRdFCCEuWRdKm3ep69q1K2azmSVLltR0UXSbPHkyQ4cO5fjx4xXePy2EuDDI1HohSo0bN46nn366xi5o9u7dy86dO3n11Ve57bbbLstOvBBCiL9GTbd5l6Lp06ezf/9+zzTwL7/8kuXLl5e711wIIaqDdOSFoGQ99B49evDUU0/VWBlGjx7Nl19+SZcuXXj77bdrrBxCCCEubRdCm3cpCgoK4vPPP2fnzp3Y7XYaN27MF198UWH2diGEOFcytV4IIYQQQgghhLiIyPJzQgghhBBCCCHERUQ68kIIIYQQQgghxEVEOvJCCCGEEEIIIcRFRJLdVcDtdnP48GGCg4PRNK2miyOEEEKglCIvL4+EhAQMBvkevjpIey+EEOJC4ktbLx35Chw+fJg6derUdDGEEEKIcg4cOEDt2rVruhiXBGnvhRBCXIj0tPXSka9AcHAwAHcSiAX5hl4IIUTNs6OYSoGnjRLnTtp7IYQQFxJf2nrpyFegbHqdBU0adiGEEBcUmQJefaS9F0IIcSHS09ZLR95H5sBAghPi0OT+xMuScrvJO5yBo6CgposihBDifNE0AqIisYaHomnS3l9ulHJTnJVDYeYJUKqmiyOEEBWSjrwPanVsR99xr2O0mGu6KKIGuewOFj71Dw6tXlvTRRFCCFHNgmvF02P088S1bl7TRRE1LGPdRpaOHkPeoSM1XRQhhChHOvI6mQMD6TvudcIiwkmoVUsyBl+m3G43hw8dou+41/n86ptlZF4IIS4hBrOZgdMm4hcYQGJSEn5+fnIrw2VIKYXNZsNoMHDLtE+Z0vMm3A5HTRdLCCG8SEdep+CEOIwWMwm1ahEUFFTTxRE1KKFWLfLy8wlOiOPkzt01XRwhhBDVJCypDiZ/Kw0aNpS2/jIXGBiIxWJh+/bthCbWJmt3ek0XSQghvEhHXqeye+LPdSReKcWJEyfIz88nKCiIyMhI+bb/IlNWB07Pk+BEsQMH+3ABikRMpGDG5EMCJTuKbTg4iBMDGnUx0RATBh9iFKPYip0M3JiA+piohwnNhxgFuNmCg+OaC4vSSMFMHYw+xcjFzRbsnNTc+CuNxphJ8PEjJwsXm3GQq7kJVAZSMRON0acYx3GxFQf5mpuQ0hgRPsY4gpM0HBRpinBloBkWQtD/WaBQHMDFDhzYNEW0MpKKmUAfY6TjZBdOHCjiMdIEM/4+xHCj2IWTPThxo6iNicaYfUryJfXc24VSz0X10Iwl513aegF/1gODSS6XhRAXHpkf/hfJzs5mwoQJNElpRHR0NHXr1iU6OpomKY2YMGEC2dnZNV1EcQ6cKL7XiliOjUa1w2hUO5wV2JivFeFEX6IcG4o5WhFrNDvNkiJIig9hKcX8SDFunTEKcDNLK2STwUmrupFExwSxiGJ+philM0Y2bmZqRew0uehQL5qgSH++p4jfsOs6HuAYLmZohRywKDrVi0EL9WMORWz0IcYBnMygkEx/jS71YygKMjKTQnagf3rjThzMpJCCQCNd6sdwwl9jBoXsx6k7xibszKYIQi10qhfDQYtiulbIUVy6Y6zBzvcUERDhT4d60ew0uZipFZKlM4ZC8Qs2fqSYqJhA2tSNYpPByXdaEfm4dcVwo1hEMUsoJjE+mGZJEazR7MzRirDprBtSz71dKPVcXDikrRdCCPFXka8Y/wILFy5k0K0DKSwoZEC9OEb3aU24n5ksm4OZe47yzPDhvPzSi3zzv2/p27dvTRf3kqJpGjNnzqR///7n9XnScHAUF0sGdKZLfAQAqzKy6DFjJWk4aI6lyhgbsFNoUKy9tRupkSVrR87fe5Sb5q1lD04aUHWSxbXYsfgZ+f3WriSFBAAwOe0AD/60kYa4qKXjX341NmKC/Fh+6xVE+/sB8Obvu3hh1XYaYtI1mr1Cs9E0MpjFN3cm2GJCKcUzy9N4f0M6DTARUMV3iG4UyzUb3WtF8l2/9vgZjbjciqGL1jNj1xHqKhPmKkZNHShWaDYG1Y9n8tWtMBkM2Fwu+s9by/KDJ6mtjFWOABfiZjU2HmuRzDtdm6JpGvl2J71mrWRFZgH9lX+Vo7dZuFiHnf/r2IiRbRugaRqZRXa6fruc1bl2rsH/jMcDHMHFNhz856rm3N80EYADeUV0/OZX1hbb6KEjRjpO0nEy87p29KsbC0DayTw6/2856512OuJXZYxtUs+9XAj1XFw4pK2vOX9VWy+EEBcSGZHXyaVzlOd0CxcupF+/6+kaGUj63Vcx9epWDKwfT6/aUQysH8/Uq1uRfvdVdI0MpF+/61m4cGE1l/zyduTIEa699lrd+0+ePJmwsDCfn2ef5uSaxBhP5wagU1w41yXFsFfTN/q73+BicEotT+cG4LrkWNrHhJKucwR5n+bkgdQkT+cGYEjj2iQGWXXFcKLYh5MnWtXzdG4AnmxVj2Czkb06YuTj5qhy8WzbBgRbSjpUmqbxUvuGJWXUEeMEbnKUmxfaN8SvdKqr0aDxcodG2JTikI6R7MO4KFaKlzs2wlQ6PdLPaOSFdg3JVW4ydYxk78eFG3i5fSPPtNggi4nn2jbgmHKRr+NzIR0ngSYjw1vX88SI8rfwRKu67C+dJq8nRu1AK/c1qePZVifYn781S2Svpm9UPx0nbaNDPZ14gCYRwdzeqBb7Dfpi7JV67nGh1HNxYZC2vmb9VW29EEJcSKQjfx5lZ2cz6NaB9KkdxfS+rYkLqHjEKy7Aj+l9W9OndhSDbh0oU++qUVxcHH5+VY80nisFWIzl/50sRk33V0AKsFRwX6af0aBz8jS4KyuHweBbOU6LYdQ0jJqmqxxlz2MxeI8kmg0amoaucpQ9j/m081FWLj3Tp/8sh3cMv9IYel5L2VRv82mvpSymnteiAKNWcg69Yhh9e09OLwOUvJZzeV9LyqHpno4u9dz7+JLnrNl6LmqetPU1769q64UQ4kIiHXmdjGcxvfGzzz6jsKCQj7o384wIVsZkMPCfK1MpLChkypQpZ1vMcmw2G8OGDSMmJgar1UrXrl1Zs2aN1z5btmzh+uuvJyQkhODgYLp168bu3X9mY580aRJNmjTBarXSuHFjPvzwQ6/jn3vuORo1akRAQAD16tXjpZdewnHKMi2jR4+mVatWfP755yQnJxMaGsrgwYPJy8urtNxl35bPmjWLRo0aYbVaufrqqzlw4IDXfv/+97+pX78+FouFlJQUPv/8c6/HNU1j1qxZAOzduxdN05gxYwZXXXUVAQEBtGzZkpUrVwKwdOlShg4dSk5ODpqmoWkao0eP1nWeaysj8/YeZevJP19T2sk85qYfpY7Sl7SqltvAV9sPsT+vyLNtZUYWy49kkaTzLpg6ysh/t+zjRPGf9+jO3XuMXbmFJOqIYUKjtmbkg43pFDj+HFGclHaAbLtTVzmC0IjUjIxfvwe7688u0fj16bgV1NERIwoDQZqBd9btwa1KOjNKKd5atxuzpulKJhaPEYum8da63ajSGG6leHvdbgI1A9E6Pv7Kyjpu/R7PNrvLzYT16URqRoJ1fC4kYiLX4eLTrX/W3QKHk/c37KWWZtQ1dToRE+l5RXyXftSz7WSxnY8379ddvxIxldank55tB/OL+HL7IWq59cWoI/Xc40Kp56LmSVtf4nJo64UQ4kIiVwnniVKKf3/wPgPqxVX67fzp4gOt3Fwvjg/ff4/HH3+8WjLcPvvss0yfPp3PPvuMpKQk3nzzTfr27cuuXbuIiIjg0KFDXHnllfTo0YOffvqJkJAQli9fjtNZcnH7ySefMGrUKN5//31at27NunXrePDBBwkMDGTIkCEABAcHM3nyZBISEti0aRMPPvggwcHBPPvss55y7N69m1mzZjF37lyysrIYNGgQY8aM4Z///GelZS8sLOSf//wnn332GRaLhUceeYTBgwezfPlyAGbOnMkTTzzB+PHj6d27N3PnzmXo0KHUrl2bq666qtK4L7zwAm+99RYNGzbkhRde4Pbbb2fXrl106dKF8ePH8/LLL7N9+3YA3csPpWJhj3LR8etfGdAgHk2D6buOEKwMNNVx3zBAKyzsdxbR8sufuaVBPAUOF9/tySBOM9JQ6ftXbYcfswsLafrFUgbUj+doYTHz9h4jGROJOrNgd1B+zM0qoPHnS+lfP47dOQX8eCCTxjozaWtodFIWFhzJoukXS7m+bgwbjueyPCOL1lgI1tGBNqLRUVmYtSeDll/+TK860aw8cpI/MnPpgh9+Ojq/fmi0VxY+2ryf1RnZXBEfwU8HMtmWnU9PrLq+nAvGQGss/N+anSw6kEmr6BDm7z3Ggbwi+lL1/fEA0aXZ5R/7eTOzdmfQICyQ7/ZkcKLITj9V9b3tAHUwUhcTt33/O9clxxAXYGXm7iMU2Z3cSEDVAYAGmNihGek9cxU31Ysl2GJi+q4jaE5FKx332AM0xcJuqefAhVPPRc2Stv7yauuFEOJCoqmyoSrhkZubS2hoKEMJ8izLFJnSkAFTP6ZJkyYEBFR94ZyZmUl0dDRf9WnNwPrxup/7f7uOcMeP68jMzCQyMvKsXwNAQUEB4eHhTJ48mTvuuAMAh8NBcnIyTz75JCNGjOAf//gH06ZNY/v27ZjN5ZNMJSYm8q9//Yvbb7/ds+21115j/vz5rFixosLnHTt2LF9//TVr164FSr6lHzt2LBkZGQQHl9wX++yzz/LLL7+watWqCmNMnjyZoUOHsmrVKjp27AjAtm3baNKkCatXr6ZDhw5cccUVpKam8vHHH3uOGzRoEAUFBcybNw/wToCzd+9e6taty3//+1/uv/9+ALZu3UpqaippaWk0btyYyZMn8+STT55xymNhYSFpaWnMuPNvnNi+07PdhmIzdg5oJRkV6igjzbH4dDFeiJtNODhscKEpSFZGUrH4lPAqDzcbsXPU4MakoJ4y0QSzT7NKsnGzATuZBjd+ChooMyk+Lu2ViYuN2MkyKPyVRoryfXmwIzhLluUyKALdGk0x6xpxPdUBnCXLzxkUwW6N5piJ9yFG2bJv2zRnyfJzbo3mWHxaHkyh2IGTnZoDmwZRbgMtMBPuQwxX6ZJtuzUnTg1i3QZa6OwwlnGi2IKDvZoTlwa13EaaY64yKduppJ57+yvruR3FJPLJyckhJCREd3xRudPbe2nrpa0/VWXtvRBCnC++tPUyIn+e5OfnAxDuV3UG5lOF+5W8JXl5eefcuO/evRuHw8EVV1zh2WY2m+nQoQNpaWkArF+/nm7dulXYsB8/fpwDBw5w//338+CDD3q2O51OQkNDPX9/++23jB8/nl27dpGfn4/T6SxX8ZKTkz0NO0B8fDzHjh07Y/lNJhPt2rXz/N24cWPCwsJIS0vzvIa//e1vXsdcccUVTJgw4YxxW7Ro4VUOgGPHjtG4ceMzHlcVPzTa4kfbc/hqLABDSfZwvTcLVyAYA1dgPacYYRjofo4xojDSE/9zihGPqaTTfQ4x6mAqmeZ8ljE0NOphpp4y67vxuZIYKZhJOYcYRjRSsZCqLGcdw4RGSyy0PIcYUs+9XSj1XNQMaesvv7ZeCCEuFNKRP0/Kpmll2XxbCzjLVjLN7dSG8GyVTbY4fdqeUsqzzd+/8im1bnfJVeUnn3zi+aa8jLE0w/KqVasYPHgwr7zyCn379iU0NJRp06bx9ttve+1/+sWDpmme+GdS0ZTDU7ed6bVV5tSylO2rpyxCCCHEqaStl7ZeCCFqiiS7O08iIyNJadiAmXuOVr3zKWamHyWlYQMiIiKq3rkKDRo0wGKx8Ouvv3q2ORwO1q5dS5MmTYCSb6yXLVvmlbCmTGxsLLVq1WLPnj00aNDA66du3boALF++nKSkJF544QXatWtHw4YN2bdv3zmXHUpGA8qm7AFs376d7Oxsz7fpTZo08XptACtWrPC8trNhsVhwuWTJJyGEEFWTtv7cSVsvhBBnR0bkzxNN03j40cd4ZvhwMgptupLgHCkoZuaeDN4eN65akt8EBgby8MMPM2LECCIiIkhMTOTNN9+ksLDQc9/YY489xnvvvcfgwYN5/vnnCQ0NZdWqVXTo0IGUlBRGjx7NsGHDCAkJ4dprr8Vms7F27VqysrIYPnw4DRo0YP/+/UybNo327dszb948Zs6cec5lh5Jv0x9//HHeffddzGYzjz32GJ06daJDhw4AjBgxgkGDBtGmTRt69erFnDlzmDFjBosWLTrr50xOTiY/P5/FixfTsmVLAgICdN0nKYQQ4uJVstSk7+2utPXn7lJt6zNxcRQXfmgkYfIpBwiU5FY5iptMXASikYjJ5xWUFIrDuMjCTQgGamPE4GMMN4qDuMjFTRgGamH0KQcIlOR42Y+TAhRRGIg9ixgOFPtwYkMRg9GnPDVl7Cj24sSBIgGjT3lqyhThZj8uXChqYyLkLMZEC3Czn5JZOYmYCDyLGLm4OYgTAxpJGPE/ixhZuDiMC3NpHT2bBKtSz/9UHfXcV9KRP4+GDBnCyy+9yEM/b2Z639ZnXJbG6Xbz91+2EBAYwD333FNtZRgzZgxut5u7776bvLw82rVrx8KFCwkPDwdKRhN++uknRowYQffu3TEajbRq1cpzr90DDzxAQEAAY8eO5dlnnyUwMJDmzZvz5JNPAnDTTTfx1FNP8dhjj2Gz2bj++ut56aWXqmUpl4CAAJ577jnuuOMODh48SNeuXZk4caLn8f79+zNhwgTGjh3LsGHDqFu3LpMmTaJHjx5n/ZxdunTh73//O7fddhsnTpxg1KhRsiyNEEJc4r6jkL4EcDZ3q0tbf24uhrb+EE6sOmM7UfxEMek4MWrgUuCvafRSVmrpvOy2ofhRK+KQcmHSNJxKEawZuFpZdXdgC3Dzg1bMsVNihGsG+ih/wnR2+nJws1ArIku5PTGiNSN9lVV35/M4Ln7Uisk7JUYtzcjVyl93x/EQTn7SiilUynNOkzHRCysmnTHScbBUs2E/JUYjTHTHqrvTtw07y7HhpGRKs8JGM8x0xk93h209NtZg96Sp0bDRDgut0bfqhUKxChubcKBRklrFBHTBjyY6V49xo/iFYrbjxFAaw6JpdFd+1ENfvg+p596qo56fjRrNWj969GheeeUVr22xsbFkZGSU2/ehhx7i448/Zty4cZ6GpSKffPIJU6ZMYfPmzQC0bduW119/3fPNrh7VkbW+zMKFC+nX73r61I7iP1emEh9Yvik4UlDM33/Zwg8HM5k3bz59+vTRHf9SpTejbE2QLLZCiJogWeurX1l7Xy/En5w8O39r1IJbpn4ibf1f5EJu6+HP9v6eO++k5faDukZfV1LMDoOLT3q1YGCDeA7kF/P3JRtZfugkg1UgVh0X9T9RxDEzfNanFdcmxbAtK5+hi9azMzOf21SArhHL+VoRDquRqX1b0y0hgj+O53L3D39wMtfGLarq5VMViplaEaHBfkzp05p2MaH8euQkdy5ch7HIxfU6lk91ofhaK6RBZBCTr25F4/AgFu47zj0/riPaTkmi0CrYUHylFdA5IYKPrmpBYrCV6bszeGDRBhq6jXTR8RVLHm6+poAb68Uxrlsq0f4WPtt2kMd/3kQ7ZaGVjk50Ji5mUMjQpnV4rVMKgSYTH27ay/Mrt9EDKyk6OsAHcDKfIp5pXY+RbRsA8OYfu3nzj91ci7+uVXl24GAJxbzeuTGPNk+m0OnipVXb+XTrfm4mQFcHeD121mo23r2yGUOa1OZEsYPhy7Ywa3cGgwiUel4D9fxUvrT1NX6PfGpqKkeOHPH8bNq0qdw+s2bNYvXq1SQkJFQZb+nSpdx+++0sWbKElStXkpiYSJ8+fTh06ND5KH6V+vbty9y58/j1RAH1vljKHT+u53+7jrDowPHS5WfWU++Lpfx6okAadiGEEKIGjOuWygnl4uRZLh0gbf2lzWoysp2qExq6UezQnDzeqi6DG9XCZDBQNySAKVe3xgns1hHDhmI3Tl7s0JDrk2MxaBpNI4KZ3LsVecrNvtIp2WeSg5sDysnYrk24slYkmqbRNiaUf1/VghOqZCp0VY7i5rhy8eFVzWkfG4amaXRLiGRs16YcVE5ydPyv7MdJnnIz+epWNI0IxqBpXJscw0sdGrEbJ8U6lk/ZjQMn8PnVragXGoDJYOC2hgk80aouOzQnLh0xtuPA32RkUu+W1AqyYjEaeDA1kbtSarNdq/p8AqThICHAjw+7Nyfa348As5Fn2tSnb2I02zV9yS7TcNAyMpjXOzcm1M9MqJ+Zf3ZuTKuoELbpqBsA2zQHfepEM6JNfQLMRqL8LbzfvRm1Aq2k6YyxQ3NwZ0ot/tYsCT+jkYRAK5/2akmAWep5TdXzs1XjHXmTyURcXJznJzo62uvxQ4cO8dhjjzF16tQKl0053dSpU3nkkUdo1aoVjRs35pNPPsHtdrN48eLz9RKq1LdvX/btP8Db48axUQvgjh/Xce3cNdzx4zo2agG8PW4c+w8clIZdCCGEqAHNIkpGPYrO4YJL2vpLV+1gfwp11A0nUKwUzSO9VyOIDfAjxmqhQEeMYhRuoGWU90hc4/AgzAZNVzkKSzsfzSO9Y7Qo/VtPOSqLUVauAh0dnAIUJk2jcXhQuRhu0NXBKUARZTUTd9oslxZRIdiU0tHdK4lRNySAQLP3iHfLqBDylL4v7wpQpEaGYDR4j/C2igqhUNP3uVGsKVpGh5bLjdEqOoQinTGKNEXLaO/3xGjQaBEVous9AchTqtz7Gmg2UT80UOp5qb+6np+tGu/I79y5k4SEBOrWrcvgwYPZs2eP57Gy+71GjBhBamrqWcUvLCzE4XBUS2bYcxEWFsawYcNI276DzMxM0tPTyczMJG37DoYNG+a1VquAe++994KdaieEEOLSMn9fSdb50HO8LJK23jcXS1u/KzufSB11wwyEaQbmpnuvYrDueA5HimxE6YgRiIa/pjHntBg/7D+Ow610lSMMAyZg7l7vGLPTS25djdQx/bpsn9NjzEk/ihEI11GOKAw4lWLhvuPlYlg1jSAdU6cjMXC0yM7aY9le22fvySBUM+i6KzwKA1uz8tibW+jZppTiuz0ZRGv67sWOxMCvR05wstju2eZyK+amHyXcre9zI0wZWLjvGEXOP0eKi50uFu47TpjSFyPcbWDunqM4T1lKMavYwc+HThCl877yKM3AnPSjnHp39b7cQjadyJV6Xuqvrudnq0aT3XXs2JEpU6bQqFEjjh49ymuvvUaXLl3YsmULkZGR/Otf/8JkMjFs2LCzfo6RI0dSq1YtevfuXek+NpsNm83m+Ts3N/esn68qmqYRGRlJZOTZpNQRQgghRHUb8etW6mEiuJrGN6Stv7RYMdBQxz3QGhotlJlvdh0h0LyR2xslsCe3kFdW7yBSM5Kkqr7sNqHRTJl5f+NeNE3jxrqxbMzM5dXfdpCgGYlTVXdO/DHQGDOjV++g0OmiV+0oVh/N5tXfdlAPk64kYKEYqI+JYT9v5mihjc5x4fx0MJN//b6bxph1ZUmPxUgtzcg9P67jpQ6NaBkVwpz0o7y7IZ22WHQlqkvCRKRm5Oa5axnVsRH1QwOYtvMwX+86QjedSeYaYmYDDvrMWsVLHRoRF+DHxK0H+PnwSfroTGPYFDNpLge9Zq7i+XYNCDab+GDjXtKy8umn8x7o5piZWVxE31mreLpNfTTgrXV7OF5op5vOGC2wMCc7nxvnruGxFskUOFy8sXYXLpebpjpfS0tlYeHhk9y+8A/ub5rI0SIbr/62kwCp5zVWz89WjSa7O11BQQH169fn2WefpXv37lx//fX88ccfnnvjk5OTefLJJ8+Y7O5Ub775JmPGjGHp0qW0aNGi0v0qSroHVEuyO3HpkWR3QoiaIMnuql9ZsruGmOiGlbiURtLWC4+y9v6zOx/Avn23rmMUii04WK85KFBuNEqWGOuGn+4M2ArFOuxs0hwUK4UBqIeJK7DqSiIGJQm4fsPGNs2JXSlMQAPMdMFP9xJhDhQrsbGz9D51i6bRWJnogJ/uJcJsKH6lmD04cQNWraQD1waL7kzvBbj5FRv7cKKAQM1AS2WmGWbdMXJw86tWzEFVMhoeohloqyw00pmlHUoS3i3XbGSUxgjXDHRQfiT7MC56GCcrNTuZpTGiNCOdlYUEH2Lsxclvmo2s0tsCYjUjVyg/n5bk24GD3zU7uaUxamtGrlBW3ZnepZ57q456XsaXtv6CWn6ubLmTnTt3YjAYOHbsGImJiZ7HXS4XTz/9NOPHj2fv3r1njPXWW2/x+uuvs2jRojN24gGef/55hg8f7vk7NzeXOnXqnNNrEUIIIcTFoStWn9c/FpePYAyc0LmvhkYzLDRRZvJQ+IHPa3xraLTBjxbKQj4KK5rujk0ZIxqdsdJOKQpQ+KP5vAyWGY0rsdIJPwpwE6QMPv+f+KHRC3+uQFGMIkhpPo9QBmKgL/4U4cYGBCvN57XGQzFwvQqgADfO0hi+rjUehZGbVAD5uHEBIUrzuZOWgIkBykg+ClVaDl9jJGMiSRnJRWEEgnROyz9VI8w0UCbyKOn8BvoYQ+q5t+qo52fjgurI22w20tLS6NatG3fffXe56fB9+/bl7rvvZujQoWeMM3bsWF577TUWLlxIu3btqnxePz8//Pz0rd8ohBBCCCHEmRjRCDvHC3lTNcQwV0MMCxoWH0Z7K3I2nbTT+WPwcSGv8vSOFp9J0DnG0NAIPsdzoaEReo4xDNUQQ+q5t+qo576o0Y78M888ww033EBiYiLHjh3jtddeIzc3lyFDhlR4b5nZbCYuLo6UlBTPtnvuuYdatWrxxhtvACXT6V966SW+/PJLkpOTPWvSBwUFERTknU2wJiilOHHiBPn5+QQFBREZGVkue6UQQgghLl7S1gshhDjfajRr/cGDB7n99ttJSUlhwIABWCwWVq1aRVJSku4Y+/fv58iRI56/P/zwQ+x2OwMHDiQ+Pt7z89Zbb52Pl6BbdnY2EyZMoEmTJkRHR1O3bl2io6Np0qQJEyZMuCiytgp9ikun1ZwthSqdPnbuMeznGKMQN45ziOEujeE8hxiu0hh61oo9nzGcpTHc5xDDURpDnUMMe+l7ey4xbNUQQ+r5ny6Uei5qnrT1Qggh/io1OiI/bdo0n/av6L74pUuXVrlPTVu4cCGDBg2isLCQW/rfyKsvPk94WBhZ2dlM/242zzzzDC+//DLffPMNffv2rdbn7tGjB61atWL8+PHVGvd0o0ePZtasWaxfv/68Po+vCQ//SsdxsUqzcbg0gUmCZqSj8iPGh2k6h3Hym2bnaGmMOpjojIVwH2Lsxclazc4J5UKj5F6qzvj5lI15Bw7WaXaylRsjJclHOuOn+/6nsiQoGzUHecqNWdNooEpi6L3vqCwJyhbNQaFS+GkaKT4mH3GhWFOaBMWmFAGaRlNlpjUW3ffGOVCswsZOzYlDKYI0Ay18TLJTjGJFaRIUFyXLtrRSFlJ8SLKTj5sV2Nhb2l2M1Iy0VWbq+hAjGzcrsbG/dOXdGM1IB2Whlg9NgdTzP1VWzzvh50mUqifGudZzcWGQtr76XMhtvRBCXCguqHvkL0ULFy6kX79+9O3di/9+8C5xcbFej986oD8ZGUd54NFh9OvXj7lz51Z7A38pWbNmDYGBgbr3X7p0KVdddRVZWVmEhYWdt3Ll4GaeVkTD8CBebV0PgAnr9zD/ZD43qwBdaxMfx8V8imgfE8bY0iVF3vpjN/Pyihmg/AnQEeMgTn6giF61org/NZGjhTbe/H0X84uKGKACdHWid+JgCcXcXDeO2xslkJ5byL9+380CezE3KX9dHeBNOFiJjXtSanNT3Vg2nchj7B+7KXAVc42y6uoA/4adjdh5uFkyvepEsToji3Hr91Dshqt0LrGyjGL2aC6ebF3Ps6TIhxv3YkfRWUcMhWKRVkym0c0/2jSkRWQwc/YeZXLaQdxASx0r2LpRLNCKsJs1/tm2MfXDApm24xDTd2egga6MuQ4U87UirP5m3mnbiLgAK5O27ufHA5lcg0aijo/yItzM1YqIDbbyYZsmBJuN/HvTPr7PyOJGAnR1xKWee7tQ6rmoedLWV68Lta0XQogLiXTkdTqbKajZ2dkMGjSIvr17MevrqZhMFZ/uuLhYZn09lf633cmgQYPYt2+fNESViI6OrukiVGgTdoItJn65pQvBlpL3eUC9OBp9/hObiu101XFBvgE7ySEBLL65MxZjSWfmxrqxNJjyE2kuB22pOiHjOs1Oh5gw5t3YAUPp/Zh9EqNpNnUpO3HQtIqOp0KxXrNzY3IsX1/TxnNPZ+f4CK6cvoL9OEmuouPpQrFRc/BAk0T+fVXzktdRL47UyGBu/f53juEmtopOow3FFs3BP9o2ZFTHRgDcUDeWOsH+PP7zZtpiIaSKDl8ebnbgZEK3VB5unuyJEeFn5o21u2itVJUJSY7jZr9y8nXvNgyoH+95LX5GA59vOUAzZa5y1HQ/Lo4qF0uu70zXhAgAbqoby63f/84ve4/TUJmq7PDtwkG2crOpfydSwktyfQyoH0eP6SvYcCyPRB1rtqbhwGWAX27pQmyAX2mMeFp99TMbcuxcrSOF0Gap5x4XSj2/GFS0xGtsbKwnh82pHnroIT7++GPGjRt3xtHYTz75hClTprB582YA2rZty+uvv06HDh2qtex6SFtf/S7Utl4IIS4kF/8Vwl/EeRbHfPbZZxQWFvLfD96ttGEvYzKZ+OT9CRQWFjJlypSzK6QOX3zxBe3atSM4OJi4uDjuuOMOjh075nl86dKlaJrG4sWLadeuHQEBAXTp0oXt27d7xRkzZgyxsbEEBwdz//33U1xcfMbnLYs7b948WrZsidVqpWPHjmzatMlrv+nTp5Oamoqfnx/Jycm8/fbbXo8nJyd7TR3UNI3//ve/3HzzzQQEBNCwYUNmz54NlNxmcdVVVwEQHh6Opmnce++9vp4yXU5obq6tG+vp3AAEWUxcmxzLCc2tL4bBzc314zydG4CYAD+urBXJcVy6YhzHzS0N4j2dG4CGYYE0jwzmOFWXwwGcVG5uqR/vlZipc1w4cf4WjumIkY+iQLm5tUG81/Yb68Zi0jRdr+UkLhxKcctpMQY2iEeBrhjHS+82HnhajFsaxONQipM6YhzDhVGDm+rGeZejfjyFSpGn4wu+47iIsVo8nXgoqbcDG8STpdzYq4xQ8r42iwjydOIBDJrGLQ0TOKb0141uCRGeTjyAxWjg5vrxnDDoq6OZldTz66See/zV9fxikZqaypEjRzw/p3/2A8yaNYvVq1eTkJBQZbylS5dy++23s2TJElauXEliYiJ9+vTh0KFD56P4ZyRt/Z8u9bZeCCEuJNKR18nXqQtKKf79739zS/8by02xq0x8fBwDbrqBDz/8EKXOT8Iju93Oq6++yoYNG5g1axbp6ekVNngvvPACb7/9NmvXrsVkMnHfffd5Hvvmm28YNWoU//znP1m7di3x8fF8+OGHup5/xIgRvPXWW6xZs4aYmBhuvPFGHA4HAL///juDBg1i8ODBbNq0idGjR/PSSy8xefLkM8Z85ZVXGDRoEBs3buS6667jzjvv5OTJk9SpU4fp06cDsH37do4cOcKECRP0nSgfWZVG2om8ctu3n8zHT+m7z9WqNLZl5XttcyvF9qx83ffsBqCxI6vAa1ux08W+vCL8dUzzNQEWTWNHtnc5ThTbOWFz6IrhVzq+vO20GOm5hTh1jILDn2uRnl6O7aXnR085yvbZftr52JFdoDtGABouBXtyC73LkV2ABjrGjkue56TNQWaRd5d9R3YBZk3T9dnij8b+vGKKnN4dux1Z+QRo+uqGtbRuuE/7bNmWlY/VhzpaUT3fJvXc46+u5xcLk8lEXFyc5+f0EddDhw7x2GOPMXXqVMzmqm83mTp1Ko888gitWrWicePGfPLJJ7jdbhYvXny+XkKFpK2v2KXa1gshxIVEOvI66U1qVebEiRNs376dW2660afjbrnpRrZv387Jkyd9Ok6v++67j2uvvZZ69erRqVMn3n33Xb7//nvy870vJP/5z3/SvXt3mjZtysiRI1mxYoXnm/jx48dz33338cADD5CSksJrr71G06ZNdT3/qFGjuPrqq2nevDmfffYZR48eZebMmQC888479OrVi5deeolGjRpx77338thjjzF27Ngzxrz33nu5/fbbadCgAa+//joFBQX89ttvGI1GIiJKRkFjYmKIi4sjNDTU11OmSwom1h7PYczaXRQ7XRQ7Xbz5+y5WH8smRefXQA2Vibl7j/HR5n04XG7y7U5Grkhjb16R7qRoDZWJyWkHmLbjEC63IqvYwWM/bybH7tR1L7aBkmRd49en8/3eYyilOFZo42+LN4IbGuh4LVY06mLi1dU7+PXwSZRS7M8r4oHFGwjQNJJ1xAjDQIJmZMSvW1l/PAco6ew8tnQz4ZqBeB33c8dhJEIz8PjPmz0do/XHcxjx61biNaOuxGqJmAjQNB78aQP784pQSvHr4ZO8sno7yZh0dTzrY0IDHvxpA0cLbSilWLjvGO+s20NDZdKV0KwRZvIcTh5duomsYgcut+KbnYeZtPUADXVMqwdojJl9+UU8tzyNfLsTh8vNx5v3MSf9KI10xpB6/qcLpZ5fLHbu3ElCQgJ169Zl8ODB7Nmzx/OY2+3m7rvvZsSIEaSmpp5V/MLCQhwOh+czvzI2m43c3Fyvn3MhbX3FLtW2XgghLiRyj/x5UtZYhvt4/1vZ/nl5eURGRlZzqWDdunWMHj2a9evXc/LkSdzukimk+/fv92qgW7Ro4fk9Pr5k2uexY8dITEwkLS2Nv//9715xO3fuzJIlS6p8/s6dO3t+j4iIICUlhbS0NADS0tK46aabvPa/4oorGD9+PC6XC6Ox4ovaU8saGBhIcHCw1xTCv0ISJlph4aXV2/nn2p1oQJHLTSssui7oAZpg5jhuHvt5M88u34rTrXC4FZ3wI07nBX0rLJxUbu7+cT0PL9lEscuNUoruWAnT+b1dJ/zIdRVx47w1hJiNFDhdGNDoiVX3iGlX/FhgL+aqmSsJs5jIsTuxahpXK2tpt7ZqPZSVBQVFtP/mV8IsJrLtToI1A311JhHT0OiprCzMKqDZlz97YoRrBq5RVd8PDmCipMw/ZGTTYMpPhJbGiNGMdNOZiMwfA72UlR/2HSdp8iICTUZyHS5qaUY66hrTh1AMdMfKl9sP8dWOw1iNBvKdLupiorWOhHsAsRjpjB8TNqTz4aa9mAwahU43jTHTRGcHWuq5twuhnl8MOnbsyJQpU2jUqBFHjx7ltddeo0uXLmzZsoXIyEj+9a9/YTKZGDZs2Fk/x8iRI6lVqxa9e/c+435vvPFGufv1z4W09RW7VNt6IYS4kEhH/jwJCiq5lzXLxzVjy/YPDg6u5hJBQUEBffr0oU+fPnzxxRdER0ezf/9++vbti93uPe331KmNZfeQll0IVLey+Eopr/tVy7ZV5fRpmJqmnbeyVkZDoyN+NMbMXldJRoUkTLo7FWUxumOlGWYOOJ0YSkf8fFlOy4hGb6wcw81hpxMzJuph0pUJvIwZjeuUP0dwkeFwYcVEPcy6pgqX8cfATcqfg7jItLsIxEpdZdK9JBdAMAYGqAD24yTL7ia4NIbeDhJAJEYGqQD24iTX7iYMK0k6R8HLxGHidhXIHpwU2N1E4U9tZdS9fB2U1IU7VCB7cFDkUMRiIUEZfeqoNcJMbYzsUU4cTkUCfsRg8ClGCyzUw0S624nLraiDiUgfRn2lnnu7UOr5he7aa6/1/N68eXM6d+5M/fr1+eyzz+jevTsTJkzgjz/+KPf5r9ebb77JV199xdKlS7Faz/wF2/PPP8/w4cM9f+fm5lKnTp2zel6Qtt4Xl0JbL4QQFxLpyJ8nkZGRpKSkMP272dw6oL/u46Z/N5uUlJQqpweejW3btpGZmcmYMWM8Fy5r1671OU6TJk1YtWoV99xzj2fbqlWrdB27atUqEhMTAcjKymLHjh00btwYgKZNm/Lrr7967b9ixQoaNWpU6Tf0VbFYSkYrXa6/JmlUKAZdS5KdSSRGnzpXp9PQiMVYZcbsqmIkYCLhHD4iDKXLoulZGq0yRjTqYqbuWUcoGVVv4MNa6xUxo/m05ntF/NBoco51IwADzc4xRhAGmp9jDKnnf7pQ6vnFJDAwkObNm7Nz504MBoNnBLiMy+Xi6aefZvz48ezdu/eMsd566y1ef/11Fi1a5DViWxk/Pz/8/PTNhNFD2vqKXeptvRBCXAjkHvnzRNM0Hn74YabPmk1GxlFdxxw5ksGM7+bwyCOPnPXIxJkkJiZisVh477332LNnD7Nnz+bVV1/1Oc4TTzzBxIkTmThxIjt27GDUqFFs2bJF17H/93//x+LFi9m8eTP33nsvUVFR9O/fH4Cnn36axYsX8+qrr7Jjxw4+++wz3n//fZ555hmfy1gmKSkJTdOYO3cux48fL3d/oBBCiL+WzWYjLS2N+Ph47r77bjZu3Mj69es9PwkJCYwYMYKFCxeeMc7YsWN59dVXWbBgAe3atfuLSu9N2vqKSVsvhBDnn3Tkz6MhQ4YQEBDAA48Ow+k88wJ2TqeTBx97goCAAK9vv6tTdHQ0kydP5n//+x9NmzZlzJgxvPXWWz7Hue2223j55Zd57rnnaNu2Lfv27ePhhx/WdeyYMWN44oknaNu2LUeOHGH27Nmeb9LbtGnDN998w7Rp02jWrBkvv/wy//d//3dOy8jUqlWLV155hZEjRxIbG8tjjz121rGEEEL47plnnuHnn38mPT2d1atXM3DgQHJzcxkyZAiRkZE0a9bM68dsNhMXF0dKSoonxj333MPzzz/v+fvNN9/kxRdfZOLEiSQnJ5ORkUFGRkaNdOCkrS9P2nohhDj/NHW+1j65iOXm5hIaGspQgjz3OkamNGTA1I9p0qQJAQEBumMtXLiQfv360bd3Lz55fwLx8XHl9jlyJIMHH3uChYsWM2/ePPr06VNtr+VCsXTpUq666iqysrII8zEp0IWmsLCQtLQ0Ztz5N05s31nTxRFCXCbsKCaRT05ODiEhITVdHN0GDx7ML7/8QmZmJtHR0XTq1IlXX3210gzoycnJPPnkkzz55JOebT169CA5OdmzRFlycjL79u0rd+yoUaMYPXq07rKVtffXYaUOZmnrz9Gl1NbDn+399Dsf5OT2XbqPy8PNZuxkam4sSqMRJpIx+ZTTJBs3m7CTpbnxVxpNMFPbx1t4TuBiEw7yNDcBSiMVM3E+xsjAxVbsFGiKYKXRDAtRPt7SdBAnaTgo0hThquT2Ll9yqygUe3GyAyd2TRGlSm4z8yW3ikKxCye7cOLUFHHKSCpmn3KruFBsx8FeXLg1RYIykooFPx/eVweKbTjYr5V86VdHmWiCGbMPMWwotmLnoObCiEayMpKC2af8P0W42YyDDM2FSUF9zDTA5FP+H6nn3s61npfxpa2Xe+TPs759+zJ37lwGDRpEYuNmDLjpBm656UbCw8LIys5m+nezmfHdHAICAi7Zhl0IIcTla9q0aT7tX9F98UuXLq1yn3Mxn2K6A1ec5fHS1l/a1mKnLkpXB+UkLuZqRfiZjVyTFMuenEJ+OJZNc8x00bnaSQYu5mtFhPmZ6ZMUx4bjOcw7mU9HLLTSudrJPpz8SBHxgVZ61o5hdUYWs3MKuRIrjXXmfNmOg58ppn5IAD3jw/n54AlmFhRyNf66VypZj53V2GgWEUTn6FB+2HecGbZCrlVW4nXGWIWNjThoHxNKg7BAvt97jJ2OQq5X/rpyrSgUSylmB066xoeTEGhl3t5j7HQ5uUH56/pCwI3iR4rZj5NedaIINpuYv/cou5WTfspf12onDhTztSKO4+aaxGgAFuw/zh6cXK/8dXXmi1HM1YrI19xcmxxDvsPF4gOZ7MNFH6y6OvN5uJmjFeEyQr/kWI4U2Fhy5CQHMXEV+lZMkXrurTrq+dmQjvxfoG/fvuzbt48pU6bw4Ycf8s30mZ7HUlJSePvttxkyZIiseyqEEELUgMEN45m5K4MOnP0kRWnrL137cWLBpWukcDU2aocEsHzgFYRbSzoS49bv4dnlaaRgrrLjqVCs1Gy0ig5hUf/OBJiNKKX4x8ptvLNuDw0xE1hFp9GNYoVm4+o60cy4rh1mowG3Ujz40wa+3n6YejpW13CUluPORrX4tFdLDJqGw+Vm4PdrWbb/BIk6Vm8pwM0abAxvVY8xXRqjaRqFDhd9vlvFymN53Kxj9ZaTuNiIg391aczw1vUByCp20PXb5azOsXEdVS8nexgXO3AyqXdL7kqpDcCRgmLaf72MtUU2rtIRYw9O9uFk/g0duLq0E74zu4CO3yxjg8NOJx2d1zQcZOLm14FdaBcTBsDvx3Lo+u1ytuLQlUR2A3ZsRvjjtitpFFayasaiA8e5dvZv7MZJIx2d17XY8Lea+G1QN2oFlZT7y+2HGLJoPY2kntdIPT9bco/8XyQsLIxhw4aRlpZGZmYm6enpZGZmkpaWxrBhwy75hr1Hjx4opS6JqXZCCCEuLSNaN8CmFJmcW9ZzaesvzbY+IcBKOmfOfwDgRHEAF4+3TPZ0bgAea55MiNnIXh0x8lEcUy6eaVOfAHNJZ0jTNJ5v1wAoGYGsSiZucpWb59o2wGwsudQ3aBovtGuETSkO64hxGBc2pXihXUMMpUkZzUYDI9s1JE+5OU7VS/8dwIkC/tGugSexY4DZyDNt6nNcucjX8cXZXpwEmYw81uLPdT3CrWaGtarLAZw4dMZIDLJyZ6Nanm3xgVYeapbEPk3f/3w6TtrHhHo68QANwwK5vVEtDhj0LYO4T3NybVKMpxMP0DYmlOuTYzxT7auy3+BicKNank48QO860XSKDdNVvwD2ay7+lprk6cQD3N4ogeQgf6nn1Ew9P1syIv8X0zSNyMhIIiMja7ooQgghhADKksdX1+WWtPWXFoMPg2kKPB2CMpqGzyNy5WKcxYje6eU2+FDPy/Y5vRyG0x7XE+P0xRl8iVF2/Omv/vRyVVWOivY2aJpP//MVPWdJDP1RKqpLvryWymL4ugJGxeXQf7zU8/IxzrWenw0ZkRdCCCHEZW3c+j1YNI1oH5MbicvDwYJiXffKmtCog4n3N6STa3d4tn+8ZT85DidJOmIEoRGtGRm3bg/Fzj9Hi99atxuARB0xojAQrBkY+8dunO6SEUWlFGN+34VF06ilI0YCRiyaxr/+2EVZXmyXWzH2j90EaQaidXQhEjGhAWP/2O3ZVux08c66PURpRoJ1dNqSMJHncPGfzX8mt8y1O3hvQzp1NJOu+8qTMbEvv5j/7Tri2Xas0MbHm/eRpPT9zydhYvXRbH4+dMKzbW9uIV9uP0Qdt74YicrE/L3H2JCZ69m2MTOXuXuPUkfpG1ut7Tbw1Y5D7Mkp9Gz75dAJVmZk6b6fO1EZ+WTLfo4W2jzbZuzOYE9ekdRzaqaeny3JWl+BirLWRzSqzy1f/pfGjRsTGBhYwyUUNamgoIBt27Yx/Y4HOLljd9UHCCFENbhYs9ZfyMrae4Bu+NG1YRNu+eq/pKSkEBQUVMXR4lKXn5/P9u3befb2u2iw86Cu0cITpUnAgiwm+tWLZXd2IcuOnKQpZrrpTAJ2GCcLKCY6wMK1yTFsOJ7L2uM5tMNCW51JwNJxsIhikoP96VknmpVHTrIlK59u+NFUx73YAFuxswwbTcOD6BIfwU8HMtmbV0gvrNTTmUjsD2yswU7b6BBaRYfy/d5jHCu0cQ3+ujpaAL9SzBYcdI0Pp0FYIPPSj5JrK0kypyezuEKxmGL24KRX7Sjig6zM3p2B0+nmRuVPiI7OmgvFAq2II7i4NimGYIuJWbsz8HPDDcpfV/Z7R2miuizNzQ3JsWgazEk/Sqgy0E/5V3k/N5Rkm5+jFVFsgJvqxVHgcDJ/3zHiMXKN8teV7C63NIbBZODGerEcLbSx6EAm9TDRS2eyO6nn3qqjnpfxpa2XjnwFKurIB0RHcef3/6Nu3bpERETUcAlFTTp58iTp6elMvWYghZknqj5ACCGqgXTkq19Ze98XK8mYsQQHMWTJHGrVqkVcXPkl5MTlJSMjg0OHDjGpRz+c+QW6j8vFzUbsZBpKl+VSJur7uCzXydIltcqW5UrBrHvEtcwxXGzGTq6mPMty+dqpOIyTLTg8y3I1x0KMjzNX9uFkW+myXGHKQAvMRPgQQ6HYjZOdOLEZFFHukqW9Qn2YWOxGsQMHuzUnDiBWGWiBpcqEaqdyoUjDQbrmxA0kKCPNMOvKWF/GXrp03P7Se/MTlZGmWHR14ssUo9iMnUOaCwOQXLqEncmHGAWly75laG7MQD1lIgWzT8vPST33dq71vIwsP3ceFGaeIGPdJowGAxaLBYNB7kq4HLndbvbv28eRPzZSeOJkTRdHCCFENUgovRyy5+WzbeZcVP/rAQgKCpL2/jLkdrvJz8/n4MGDbJ81z6dOPEAIBrpiRUeerEpFYKQ7xnO6wTYGIz3xP6cYCZhK/j/OIUYSppLp1mcZQ0OjAWYaYD7rc2pAozEWGit9o7QVMVKyvnizc4hhQaMVfrQ6h/NpRaMdfrQ7hxiBGEoy7Z9DDKnn3s61np8N6cjrpRRLR7/BwGkT2b59e02XRtQgR1ERP78yBmQyixBCXHKWvf4OANrN/Wq4JKKmbZ81z1MfhBDiQiNT6ytQ0dT6MgazmdDE2hhM8h3I5cjtdJKz/yBuh6PqnYUQohrJ1Prqd6b23hIUSFB8HJqMyF92lNtN/pEM7D6OxAshxLmSqfXnkcthJ233Lo7hwopGMiaf7muBknt9DuPiBG4CSmP4cl8LlNzrcxAX2bgJQiMJk64EF6dyodiPkzwUoRiog9Gne2OgZC3JvTgpRBGJgQSMPi8dYS+NUYwiBiOxGHyOUYxiLw7slGSg1JP85HSFuNmLExdQGyPhZxEjD7dn7cskTASfxcIQ2bg5gBNjaQxf7t8qcwIXh3BhBupixnoWdfQobqnnpaSee5N67h3jQqjnovrZ8ws4uVMSmgohhLgwSUfeBw4Ui7Ri9isnVqMBm8uNRdPopazU0Xkqi1Es1IrIUC78jQaKXG4CNI0+yp9YnRfU+bhZoBVz4pQYoZqBvsqq+6I8CxcLtWJylNsTI1Iz0ldZdV+UH8PFD1oxBafEiNOM9FX+ui+oD+DkJ60Ym1L4GQ0Uu2zU0Uxcray6lhQB2IWDX7DhQmE2GFjpttEAEz2w6r4Y3oKdldhAK1lLcoVb0RQzXfHT3dn6HRu/Y8dYupDkCmWjDRba6cy8qVAsx8YWHJgNGm6lWK5sdMaPZjozb7pQLKWYXTjxMxhwuN2swEZ3rCX3lukg9dyb1HNvUs//dKHUcyGEEEJcfmS+mA9+w8Zxg5v/XduWnIeuYc+QnvSoE8UirZginZkellOMzayx4MaO5Dx0Ddvu6kHzmFB+1Ipx6syOsFSzYQ0wseyWLuT+/VrWDb6ShNAAFmk2lI4YCsVizUZ8qD9/DO5G7t+v5ddbuuAfYOZnrVhXGVwoftSKSY0OIe3OHuQ8dA0Lb+yI3WLgV/TFKC69kO5WO5I9Q3qS89A1fHttWzINblZjqzoAJRkzl1DMgAZxHBjam+yH+jKxV0vSNRcbsOuKcQwXv2Ljb82TyLi/D1l/68s7XZuyFQfb0DeFfh9O1mLnH+0akPlgHzIf7MOL7RvyO3b2lo5cVmV7acbMt7o2Jetvfcm4vw9/b57EcmwcxVV1AGAjdtI1F//t2YLsh/py8L7eDGyYwBKKydFZR6We/0nquTep594uhHouhBBCiMuTdOR1cqPYqTl5olVd+teLw6Bp1A7yZ1LvlriB3TouYotR7MHJSx0a0atOFJqmUT80kIm9W1Kg/pyqeiY5uDmknIy9oimd4sIBaBYZzIdXNeekcnFEx4XwUVycUC4+6NGc5pEl9150jAvnra5NOaRKpndWZR9O8pWbT3u3pEFYIJqm0bNOFKM6NiK9dPpwVXbjwAVM7t2K2kH+GDSNm+rF8VTreuzUnLh0xNiOg0CzkY97tiQmwA+TwcDdjWtzb5PabNf0dSy24aBOoJVxXVMJ8zPjZzTyeMu6XJ8cww4fYrSOCmF0xxQCzSYCzSZe7tCIdtGhbNfZSdqhObg2KZonWtbFz2gkzM/MuG6pJAZZdXe0dmhO7mlciyFN6mAyGIj29+Pjni0INpt0lUPquTep5+XLIfW8xIVSz4UQQghxeZKOvE5OwKYUTSOCvbZH+/sRZTVTqONi3IbCDaSeFqNBaCBmg0aRjhiFpZ2PJqfFaBoRBKAzhio9puIYhTo6OIUojBo0Cgv0jhEehBt0dXAKUUT6mYkJ8J6S2zQiGLtSusb3ilAkB/sTYPaegto0IpgCpW9UrQhFk4hgjAbvqcWpEcEUafpGxIo1RbOo8gkpUiODKdYZo0hT5eqGQdNoGhGs6z0BKCh9LafyNxlJDvHXVTeknpePIfX8lBhSzz0ulHouhBBCiMuTdOR1MgPhmoFZuzO8tq85mk1GkZ1oHacyCI0ATWNWuneM7/cdw+FWuhJXhWPEBHy3xzvGrNK/9cSILN1nVgUxTEC4jtcSjRGXgnl7j50W4yj+mkaQjvttozBwrNjO6ows7xi7MwjTDLrulo3CwJaT+ezO+TOzrFKKmbuPEKPpu780CgPLDp/geNGf05ydbjez92QQ4db3LxKhDCzYe4wCx5/dskKHiwX7jhGh9MUIdxuYk34Uh+vPzkxmkZ1fDp8gWue9slGU1NFTF6PYk1PIphN5ROl4X6Wee5N67k3q+Z8ulHouhBBCiMuTLD9XgcqWo9mOg6UUc3vDBG5vVIs9uYX8c81OlM1Ff+WvK+HUemysxs7fUhO5qV4cmzJz+efanYQ4Na5XVl0Jp1ZQzFbNwRMt69G7ThSrj2bzr7W7qO020At/Xa/xJ4rYb3DxbNsGdI4L56eDmYxbv4emykwXrFUer1DM14rIMcE/2jWkRVQIs9Mz+GjzfjpgobWOxFduFLO0IvAz8I/2DakfEsjXuw4zdfshumOlsY6kVQ4U07VCQgIs/KN9Q+IC/Ji49QBz9h7lGvxJ0pG0qhA307VC6oQG8FzbBgRbTHywYS+/HD7BDQQQp+NiOhs3M7VCmkUFM7x1fTRg3Lo9bMjM5Wblrytp1VFczKaQbgkRPNoimQKni3+t3cX+nEIGqABdWb334+R7irg+KYb7UxM5VmTj9TU7yS6wc4sK0JWRW+r5n6See5N67u2vruey/Fz1O9Pyc0IIIcRfzZe2XjryFThTw56GnfWag1zlxgAkY+IK/AjQOblBodiAg82agwLlxgjUx0QXrPjpvIhwo1iLnTTNQbFSWDSNhspEJ/x0L3vkRLEaGzs0J3alsGoaTZSZdlh0L81lR7GiNHO0CwjUDDRTJlpi0Z0Buwg3v2JjL07cQLBmoJUy01Rn9mooWQrrV2wcKE0vFaYZaKssurNXA5zExQrNxiFVck9qpGakg7KQ6MPCDhm4WKXZOFoaI1Yz0kn56eoglTmAk980O5mlMRI0I12Un2d0WY/dOPhds5NVOuU6ESNXYCXEhwk4Us//JPXcm9TzP/3V9Vw68tVPOvJCCCEuJNKRP0dVNexuFAUoLGi6L9ZO50JRiMIP7awvHpwoilBY0XQvYXU6B4piFP5oPq99XMaOwoYiAO2s1z62obCjCETzeY3vMsUoHCiC0Hxen7tMEe6Szto5xCgove/1bNbFhpLOQQEKI+B/DjHyUZjRfF5bu4zUc29Sz71JPf/TX1XPpSNf/aQjL4QQ4kLiS1sv68ifBQMawefY4BurIYapGmKYz6FzVMZyDhevZfzO4SK6jPUcLubLnG2H4lRn27Epo6Hv3uuqYpxr3ZB67k3quTep53+6UOq5EEIIIS4fkuxOCCGEEEIIIYS4iEhHXgghhBDiLDhQ5OEuzVxxduylMVznEMNWGsN9DjGKS2Ooc4hRhJv8c4xRgNtz687ZKLltx03ROcbIx61ridHKuEvPp+0cYrhKY9jPIYazNIbjHGJIPfcm9fxPUs+9VUc994VMrRdCCCHEZW0lxVyB1edEmts1J44aTqS5HBvp55hIczk29p+SSLOdslD/HBJpRpUm0qzjw2XmUVysrOZEmrU0I53POZFmSRLMvzqR5kYcbDolkWYDTHT2MZHm79jZWg0JY6Wel7iU6vkeHKyVeg5cOPX8bMiIvBBCCCEua+mai58p1r3/L9jYaXAysl0D5t3QgUdb1WWjZmclNl3HKxQ/akUcNite69yYuf3ac1dqbVZjZz12XTHcKL7Xism1arzdrSmzr2/PDQ3jWYaNbTh0xXCgmKcV4Q408UGP5sy4rh3dkqJZRDH7cOqKUYibeVoRQaFWJvZqyTfXtKFZfBgLKOIoLl0xsnEzXyuiVlQgX/RpzRd9WlM7Koj5WhHZOkccj+JiIUU0jQ/l62vaMLFXS4JDrczXinSPfO7HySKK6ZIYxYzr2vHvHs0hyMR8rUj3aOF2HPyCjesbxPHd9e14p1sqeVaN77Vi3aN0G7CzCht3Nq3N3H7t+Wfnxhw2KxZpxbpHgVdjY4Nm55GWdZl3Qweeb9+Q3Qap51LPS+r5j1LPPS6Een62ZEReCCGEEJe1MV2b8NSyrbTDTWgVYxy5uNmJgw+vbM6DqYkA9EmMJtRi4pXVO2iLX5UJKY/h5qByMb13W26sFwdA36QYTJqBiZv30VxZqhxN2o+T48rFsus70ikuHIBrk2OwuVws3nOMFGWqciRoJw7ylJtV/TvRICwQgH7JMfScuZINGbkkqaovE9NwoAwaSwZ0JtrfrzRGLG2m/cKGbBt98K8yxibshPqZ+enmzgSaS57zhuRYGn3+E5uK7HTDWmWMjdipHxrIghs7YjaWvIfXJsVQf8pi0pwO2uFXZYwNmp0useHMuL4dBq3k3PWsHUXTqUvYiYPUKkaAFYoNmp2b68YxpU9rz/YOsWF0+XY5+3FSt4oRYBeKTZqDv6cm8V73ZkBJ3UgJD+Lm+Ws5irvK0dtiFFtx8FL7RrzQviFQUkfjA/34+5JNUs+Rei71vERV9bwNlioTBFdHPT9bMiIvhBBCiMvaDcmxAGTqGFkr2+fm0gu2Mv3rxeGiZPptVY7jwqhBv7qxp8WIpUiVLKtYdQw3MVaLp3NT5ub68WQrt65xoEzcpEYEeTo3AJqmcXP9eI4pfaOMmbjplhDp6dwAmI0GbqwXx0mDvhHCk5qba5JjPJ0bgACzkWuSYjip6YxhcHNjvVhP5wYgyt/ClQmRHNc5YnocNzfXj/N0bgDqhQbQLCKYTB2jnQ4gS5XEOFX72DDi/C0c1xEjH0WhUuXq13XJMZgNmq46moULJ3DTaTHKYko9l3ou9RyvfSqr51k6Xkt11POzJR15IYQQQlzWtmXlA+CvY9QkoHSftKw8r+1bT+aXPl71pVUAGi4FO7MLvGNk5WMAXUtMBqBxwubgWKH39M+tJ/OwaJquKZf+aOzNK6LQ4X3Bu/VkHoGavktEfzTSTubhcntfrG45mYe/0jcKZVUaWzJzy23fciIPq84Y/kpjy0nv98StFFtP5um+ZzcQjbTSulCmyOlib26RrrphAvw0jbST3jGOF9nILHZ46s6Z+KFhALaeVr925xTicCuddbTk9aadrLiOSj3/M4bU8xJSz2u2np8t6cgLIYQQ4rI2fNlWIjQD8TqSRcViJFIz8siSTWw6UXJRvjoji2d+3UqCZiRMx6VVEiaCNAP3LdrAruwClFL8dCCT/1u9g7qYdF341ceMERi6aAMH84twK8V3ezIYt24PDZUJo44YKZgpcLj4208bOFZow+l28/m2g0xOO0iKjunGAI0xc6CgmKd+3UK2zYHN5eK9DenM23uMRj7E+CMzl1dW76DA4aTA4eT/ftvB2uM5pOhMRtZImfh+33EmbEjH5nKRbXMwfNlW9ucX01hnjIbKxGdpB/ks7QBOt5vjRTYe+mkjeQ6nrnIYKEm0NX79HmbtycCtFAfzixi6aAMGoL6ObqcVjXqYePW3nSw+kIlSit05BQxdtJ5ATSNJR4xQDNTSjIxYvpVVGVkAbD6RxyNLNkk9l3ou9fwUF0o9P1uaUuqvyY9/EcnNzSU0NJShBGE5jydfCCGE0MuOYhL55OTkEBISUtPFuSSUtffBaFyLP+E6sz5n4WKhVkyOchNgMlDodBOpGemrrATrHCM5iosftSIKlMLfaKDI5SZOM9JHWau8J7PMAZws1oqxK4W1NEaiZqK3smLWef2yCwe/aDZcSmExGih2uWmAiR5YdXWSADZTkhhK0zSMGtjdiqaY6Yqf7ozNa7HxB3aMpdN9XUrRGgvtddzzCyX37S7HxhYcWAwlI2RKKTrjRzOd2c1dKJaWZp72MxhwuEuycV+JlYY6O0kOSpJ17VdO/EvPp0XT6KmsJOpMTVWMYqFWRIZyeepGgKbRR/kTq7OO5uNmgVbMCeXy1NEQzcA1yir1XOq51PNTXCj1vIwvbb105CsgHXkhhBAXGunIV7+y9v4eAn2+2HKh2IeTPBRhGKiDUfdSRWWcKPbipABFJAZqYfR5qSJ7aYxiFDEYicXgc4xiFOk4cAAJGInyYRmrMgW42Ve69FJtjLovok+VVxoDSka59F5EnyoLFwdxeZbDCjyLGJm4OIwLM1AXs88jagrFUdwcw4UfGnUx+Xw9qVAcxkUmbgLRSMbkc8IsN4qDuMjCTTAlo5x6O61lpJ57k3r+J6nn3qqjnoN05M+ZdOSFEEJcaKQjX/2kvRdCCHEh8aWtl3vkhRBCCCGEEEKIi4h05IUQQgghhBBCiIuIvmwE58no0aN55ZVXvLbFxsaSkZFRbt+HHnqIjz/+mHHjxvHkk0+eMe706dN56aWX2L17N/Xr1+ef//wnN998c7WUORc3G7GTaXBjURqNlIn6mHy6B+IkLjbhIEtz4680UjCT7ONbcQwXm7GTqykClUZTzNTyMcZhnGzBQYGmCFYazbEQ4+O9Pvtwsg0HRZoiTBlogZkIH2IoFLtxshMnNoMiym2gORZCffiOyY1iBw52a04cQKwy0AKLT/cLuVCk4SBdc+IGEpSRZph9umfSgWILdvZrJcub1FFGUrH4NF2zGMUm7BzWSu97UiaaYPbpfqEC3GzCzlHNjQmop0ykYPbpXh+p596knv9J6rm3C6WeCyGEEOLyUuMj8qmpqRw5csTzs2nTpnL7zJo1i9WrV5OQkFBlvJUrV3Lbbbdx9913s2HDBu6++24GDRrE6tWrz7msJ3AxUyvkqB9cmxJPclwIiynmV2xVH1zqME5mUkRugIHrmyQQFR3IQor43YcY6Tj4jkJcwWZuaFIL/3ArcyliK3bdMdKwM4cirOFWbmhSCxVi4TsK2YNDd4w/sLGAIiKjA7i+SQL5AQZmUsih0gQeeqzAxmKKSYwP5tqUeI5ZYZZWSCauqg+mpIP0E8X8go3GtcLpkxLPPrNiplZELm5dMVwoFmhFrNJstEmKpEeDWNKMTmZrRRTpjOFAMVcrYp3BQZd60XSpF816g4N5WhF29KWhKMLNbK2QNKOTHg1iaZsUyWrNxkKtCJfOGLm4maUVkW5W9G4UR5Pa4SzDxk8Uo3TGkHruTer5n6See7tQ6rkQQgghLj81/pW/yWQiLi6u0scPHTrEY489xsKFC7n++uurjDd+/Hiuvvpqnn/+eQCef/55fv75Z8aPH89XX311TmVdjZ3k0ACW33oFIZaS5Rk+2LiXJ5dtoQnmKrNfKhSrNDvtY0L5oX8nrKaS/Uet3s4ba3eRgpmgKr5bcaFYqdm5LimG/13bFpPBgFKKh5du4vO0gzRQ5ipHxuyl5RjauA4fXdUcTdNwuRWDFvzOT3uPk6RjXc4C3PyOnZFt6/Nqp8YA2Fwu+s5azaqjuQxQVWdqPIGLzTh4p2tTHm9ZF4Bcu4Ou367gt+xirlP+Zzwe4BAuduNkap/WDGpY8kXPsc6Naf/1MtYW2uhJ1TF24+SgcvHjTR3pUTsKgL25hbSdtoz1DjudsVYZYysOsnCz8tautIwqSUyx6UQuHb/5la3KQSsdS4Ksx47TpLH+tiupFxoAwC+HTtBr1ip246SRjiVBfsdGsL+ZNbd1IzagZCmTb3cd4faFf5CCizo6/uWlnv9J6rk3qed/ulDquRBCCCEuTzU+Ir9z504SEhKoW7cugwcPZs+ePZ7H3G43d999NyNGjCA1NVVXvJUrV9KnTx+vbX379mXFihWVHmOz2cjNzfX6OZ0TxQGcPNayrueiD+ChZomEmk2eZSTOJB/FceVieJv6nos+gGda10cD9uuIcQI3ecrNiDb1MRlK3j5N0xjZtgF2pXSNEh7GhV0pRrZtgFa6jqXRoPFsm/rkKzeZOkbn9uNEASPa1Pds8zMaGd66HpnKRZ6OUbF9OAk2G/l7syTPthCLmcdb1uWAcuLQEWMvTpKCrNzaIN6zLSbAj781S2Kfpm+0cx9OOsaGeTo3AMkhAdyRUosDBn0jlfs1J9clx3g6NwDNI0PolxzLAU3fyO1Bg5vbG9XydG4ArqwVSee4cPbqHP3dr7l4MDXR07kBuKV+HPWC/XXFkHruTeq5N6nnf7pQ6rkQQgghLk812pHv2LEjU6ZMYeHChXzyySdkZGTQpUsXTpw4AcC//vUvTCYTw4YN0x0zIyOD2NhYr22V3Xdf5o033iA0NNTzU6dOnQr30wD3aav1KYXuqZxlysXw8fiSGBX/rWfspmyf08uh71Le2+mLF5bF0DuGVHL+Tovhw4qIGuWPL4vhyzhWRc/pewx9cf+fvfOOr7o6//j73JW9gCwgkxFWGCIbQWSJgjgRbd242zprtdVq62xti7a2rp9t3bg3yBABUdmEDUkgQBaQBLLv/H7P74+bXLiA5twQNJbzfr14vczh3g/n5n685zz3Oed5QtUItUPk8eeh/nzt82PRPj/y8Wq6oWponx/7s87FazQajUaj+S5+1EB+ypQpXHTRReTm5jJhwgQ+++wzAF5++WXWrl3L008/zX//+99ANk2Vox8vpfxejfvuu4+amprAn+Li4mMeY0OQhpW/byjikOvw/dp/btpNrddQKm4UjSBJWPnLup00eo3A3B5fUwhAhoJGJyzECgt/WluI1/CHE6aUPLomnzAh6Kyg0RkrYULw6JqCwCbUa5g8saaAGGEhUcEW6U1lqR5bUxjYgDd6Df66bieJwkq0whY0Exv1PoNnNhYFxqrdXv6eV0QaNuyKGnvrXbyeXxoYK29w8fzmPWRItWJkWdhYfaCGhXsrAmOF1Q28mV9Kmqn2v0iGtDF3zwHWHKgOjK2rqOGz3QdIl2o3WNJNK3PyS8mvrg+MfVFcyYr91crFs9KllRe27KGswRUYm1NQxu56J1kKGtrnwWifB6N9fpj24nONRqPRaDSnJkKGmgY5yUycOJHu3buTk5PDnXfeicVyeINpGAYWi4W0tDR279593Oenp6dzxx13cMcddwTGZs+ezVNPPcWePXuU5lBbW0tcXBzXEB10P/EgBp8KJ2F2K1Myk9hZ3ciqA9XkYmekwv1SgH34mCtcxIfZmZSRyMaKWjYdrGMYDgYS1rIA/iOyC3GSGhXOmV07snLfIQprGhlDOL0U7pcC7MDLUlx0i41keGoCS0uqKG1wMZEI5c10Hh5W4qZfh2gGJMaxYE8F1W4vU2Q4qYoa3+JiI16GJMXRPT6KebsP4PYanCsj6KhQFVwiWYKLfHyckdqB1KgwPtt9AIshmSYjiFEI1kwk83FRjI/xXTsR47Axd/d+oqRgqoxQqujtRTJXOKnA5Oz0RISAeXsq6ISFc2WEUrDmQvKJcNIgTM7JTKbO62NxcSVdhY1JMrzF+9wAdZh8IpwYVpiamUx5g5uvyg/SAxvjCFeqxq19Hoz2+WG0z4P5oX3uQfIf6qmpqSE2NvY7FDWh8F3rvUaj0Wg0PwahrPXtKpB3u91069aNG264gVtvvZXy8vKgv588eTJXXHEF11xzDTk5OcfVuPTSS6mrq2Pu3LmBsSlTphAfH69c7O77FvY6TDbjoUKYhElBD2xkhdiuqLpJ45AwCZeCXtiVijMdSWVTAa06YRIpBX2xkxKixj4MtuKhXkhipaAfjhYLPB1NCT624cXV1JYrFwfxIRz0kEh24yMfH24hSZQW+uFQCkyO1CjERyE+fEKSIq30xU5kiG258vFShIEhJF2llT44CAvhffUi2Y6XvcJ/rzq9qaWWSnDTjBvJVjyUCgMLgkxpJQe7UnDTTCMmW/CyTxjYpKAbNrpjC6ktl/Z5MNrnh9E+D+aH9LkO5NseHchrNBqNpj3xkwnk7777bqZNm0Z6ejoHDhzgkUceYenSpWzatImMjIxjHp+Zmcntt98e1Ef+yiuvpEuXLjz++OMAfPPNN4wZM4ZHH32U6dOn89FHH3H//fezfPlyhg0bpjQvvbBrNBqNpr2hA/m2R6/3Go1Go2lPhLLW/6gX8EpKSrjsssuorKwkMTGR4cOHs2LFiuMG8d/F3r17g47fjxw5kjlz5nD//ffzwAMP0K1bN9566y3lIF6j0Wg0Go1Go9FoNJr2TLs6Wt9e0N/QazQajaa9oTPybY9e7zUajUbTnghlrf/R+8hrNBqNRqP53+Whhx5CCBH0JyUl5biPvfHGGxFC8NRTT7Wo+95779GnTx/CwsLo06cPH3zwQavn6GtF20AfkkK8rMPNLrwYrdDwItnRpLEXH2YrNJprTqzHTSm+VrVAbGyq9bAeN/sxWqVRh8kmPOThpgoj5OcD1GCyAQ8b8FDdqmahUIVBHm424qGuFRoSyX4M1uNmMx4aW6lRho/1uNmKB1dr2lIi2YuPdbjZgRdPKzQMJEVN/irEq32ufR5A+zyY9uLzUNG9bTQajUaj0ZxU+vbty6JFiwI/W63HFpz88MMPWblyJZ07d25R79tvv+XSSy/l4Ycf5oILLuCDDz5gxowZIdXDOZIPaORs1LpIgH8TPV+4qJMm8Q4b1R4PCcLC2TKCWMUcyT58LBAuXFISa7ex2ushSVg5W4YrdZEAf9eDxcKFgSTSZmWV10MXYWWSjFA+YZCPl2W4EEIQbrWwyuchCxvjUesiAbARDytwY7cIrEKw0vDQCztjCFMqHimRrMJDHh7Crf7XvsJwMxAHQ3Eoa3yFm214ibBaMKRkhelmGGEMwKH0Ogwki3GxCx9RNituw2SFdHMG4eQodkvxIlkgnJRIgxi7lUafwUo8jJPhyt1SnJh8LlwckAZxdhu1Xg8rhWBiCN1S6jCZJ5wcOsKjMcLCZBmufa59rn1+BO3F561BZ+Q1Go1Go9GcVGw2GykpKYE/iYmJQX9fWlrKL37xC15//XXs9pY3kk899RQTJ07kvvvuo1evXtx3332MHz9eKZN/PNITovhCuJQydBLJYuEiIyGKzZePpeL6yayeMZq46DCWCJfSv+dDski4OS0lnsIrz6Li+kksuXAEMszCctxKGk5MvhAuJmUksufqCVRdP5lPpg6h2gorFTVqMFmKi8tzulB27USqbpjM65MGUSIM1uNR0tiPwbe4uW1AFvuvm0TV9ZP559h+7MDLNrxKGnvwkYeHh4flUDFrEhWzJvHI8Bzy8LAbn5LGNrxsx8szY/tRdf1k9l83idsHZrECN/sUM6d5eNgrDF6bNIiq6ydTdu1Eft6rK0txKWdOV+LmkBU+PncIVddPZs/VEzg7I4nFuHAqaizHjemw8OUFI6i4fhKFV57F4JR4FgmXcrZxiXARE+Vg1YzRVFw/mS0/G0um9rn2OdrnR9JefN5adCCv0Wg0Go3mpFJQUEDnzp3Jyspi5syZ7Nq1K/B3pmlyxRVX8Otf/5q+ffsq6X377bdMmjQpaGzy5Ml888033/s8t9tNbW1t0B+Av4zuzSFpUq6wEd6HwUFp8o+x/chJiAZgYGIcT47uQ7k0OKSgsRcfDdLkxbMGkB4TgRCCUakdeHBYDkX4lDbCO5u2ui+eNYDkyDCEEJydkcSdg7IpED6lo6H5eImx2/jXmbkkhNuxCMGMHp25pk8aBUItsNiOl4zoCP40qjfRDht2q4Ub+mUwLSuZfEWNHfg4PTGOe0/vTrjNSrjNym8Gd2doUjw7FAOcAuHj3MwkbuyXgd1qIdph44mRvcmMiWCHYqBVIHxc3TuNS3t0xmoRJITbeWZsP+IcNvIVNEwkBcLH7QOzmJKZhBCC5MgwXhjfHyxQqPBaXEiK8PHAsJ6M7twBIQTpMRH83/gBNEqpFPBVY1ImDZ4c3YdBiXEA9IyP5pkz+2mfa59rnx9Be/F5a9GBvEaj0Wg0mpPGsGHDeOWVV5g/fz4vvvgi+/btY+TIkVRVVQHwpz/9CZvNxq9+9StlzX379pGcnBw0lpyczL59+773eY8//jhxcXGBP2lpaQD0iPdv4JwKQUHzY3ISooLGe8ZHKWs0IrEKyI6NDBrPiY9CglIOx4mkQ5idThHBx2l7xkfhlVIpLHAiSY8JJ9wWfAS1Z0I0jVJt8+lC0jMhCosIPhbcKyEal1DLqrmEpHfHmGPGe3WIxh2CRq+mjXgzFiHISYhW3kg3Nr2WIwm3WcmIiVB6X32AR0p6xgfPo2O4g45hdiUNd1MesddRGlmxkdiEULqH3Px6j55Hc6Cifd6koX0eQPv8x/V5a9GBvEaj0Wg0mpPGlClTuOiii8jNzWXChAl89tlnALz88susXbuWp59+mv/+978IEVrV+KMfL6VsUeO+++6jpqYm8Ke4uBiAD3ftQwCJCncqE5tu1L5bWB40/l5hOXYh6KCgkYQVQ8LHRcFfPLy7s5xIIYhRuCubiJUDLg9flx8MjEkpebewnARhUbotm4iFzQfr2XGoPjBmSsl7BWUkCbX7pYlY+KrsIPsbD29XPYbJBzvL6WiqbTM7SgvzivZT5zkcltV7fMzbvZ+OUlHDtPDBzn14jMPBzIFGN8tKq5Te1+bX8l5hOeYRDZ0KqhvYVFVHosKW2Q50EH6NI5tCfbvvEPucHpIUNKIRRAkL7+4M9tcnRfvxSan0WjpgxS4E7x3l0XcLy7XPm9A+1z6H9uPz1qKL3Wk0Go1Go/nBiIqKIjc3l4KCAiwWCwcOHCA9PT3w94ZhcNddd/HUU0+xe/fu42qkpKQck30/cODAMVn6owkLCyMsLOyY8d9+s40e2JUKG8VgoSc27vpqK8X1LkakJLC4pJJ/bdxNP+yEKwUnFtKFjasX5bHlYD39O8bwye79/HdbCcMJUyq+lY6VJGHlws/W8JvB3ciOi2JOfikfFe1nHOFKhbO6Y2ej8DLxwxXcM7gbKZHh/GfrXlbsr+ZsIlp8PkBv7Gw1fYx57xvuPq0bMXYrz27aw66aRs4jsmUBIBcHhZ5Gxr73DbcPykYAT+XtotbtY7yixgAcfFTbyIQPvuXm/pk0eA3+sm4nFtM/RxUGSQdz91cz9ZNVXNsnnf2Nbv68tpBYYaGHbFlDIBgoHXy8ez8zP1/HZTldKKpp5Im1hSQJK+my5W23FUF/aefFLXtxGybTs5LZVFXHk+t2ki5sJCkEfGEI+kg7j60p4JDby/i0Tqzcd4jZebu0z7XPtc+PoL34vLXoPvLHQfeV1Wg0Gk1743+lj7zb7aZbt27ccMMN3HrrrZSXB2dCJk+ezBVXXME111xDTk7OcTUuvfRS6urqmDt3bmBsypQpxMfH8+abbyrPpXm974uNESFUrzaQrMbNduHDLSWRwr+hHIQDi6KGF8kK3BQIH14piREWcqWdftiVghPwH/f9pqn6tAHECwsDpUO58jRAPSbf4GZ3013kjsLKYGknKwSN6iaN4qaDzknCylDpoEsI+aIKDFYIN2XSfye1s7AyTIaRpJhlBCjFx2rhYX+TRho2RuAgIQSN3XhZI7xUSQMBZGJjBGHEhHCINR8v64WHamliBbKbNFSrV0skW/CyUXipkyZ2Iegu/Rp2RW9IJOvxsEV4aZSSMCHIkTaGhhBYaJ8Ho30ejPb5YdrC582EstbrQP446EBeo9FoNO2Nn2ogf/fddzNt2jTS09M5cOAAjzzyCEuXLmXTpk1kZGQc8/jMzExuv/12br/99sDYlVdeSZcuXXj88ccB+OabbxgzZgyPPvoo06dP56OPPuL+++8Puf3cia73BhIXknBEq7MuPiSeJg3VTePReJF4kUQgQt40NuNBYjTNo7UabiTmCWo0341VyYR9F05MLAjCWqkhm95XK6LV+0CJxInEjlAOSo7GbJqHA4GtlRoGEjeSsBPwqPZ5MNrnwRra54dpC5+Hstbro/UajUaj0WhOGiUlJVx22WVUVlaSmJjI8OHDWbFixXGD+O9i7969WCyHszwjR45kzpw53H///TzwwAN069aNt956q1U95E8EK4KoE/zC33YCm9dmTmQT3Yx/I39iGmFtoHEigU0zJ9q3WSCIOMF5CASRJ6hhaQMNaxtpaJ8fRvs8WEP7/DBt4fNQ0Bn546Az8hqNRqNpb/xUM/LtGb3eazQajaY9Ecpar6vWtwIDSTXmCfUF9DVpqLRX+C68TRruE9BwN2l4T0DD1aThOwENJybVmEr9QL+LBkxqMDFPQKO+SUO2UkMiqcOk7gQ1ajCpPwF/mU0aDSegoX0ejPb5YbTPg2kvPtdoNBqNRnPqoI/Wh0BzUYY84aVBmgggAxujCSMqhMIO6/GwSXhxSYkFf3GIUYQrH7MxkKxqKsrgkRIb/oqcI0MoDuFF8i1uCvDiAxxC0CvE4hBuJMubio+YQLgQ9JN2TsOhfGeoAZPluNnTFB5FCQsDQiwOUYPJcuGipKnoR6ywMFg66BlCAZNKDL4WbvY1aSQIC0NlGJkh/C9Sho8VwkNFk0YnYWWEdNA5BI09+Fgp3Bxq6muaIqyMlGHKLUXAX3xkrfBQ26TRVVgZJcOJD7H4iPa5H+3zYLTPgzXag881Go1Go9GceuiMfAhsx8vXuJnRqwvzzxvGs+NycUVYmSdcyhm29XhYg4cb+mey6Pzh/PWMPlQ6YKFwKme2VuBmi/Bx9+BufHH+cB4e0Ys9VoOluJRfy1Jc7LYa/GF4Dl+cP5xfD+7GVuHjW9wtPxn/BnahcFLpgL+M7sOi84dzY/9M1uJhHR4lDQPJPOHCGWHhX2fmsmD6MC7t3YVvcLMNr5KGB8lnwok92sG/xw9g7rShTMpO5ktcFClqNGAyVzjplBDJG5MG8fG5QxjatSMLcVKOr2UB4BAGnwsX3ZJieHfKYN6dMpgeybHMw8UhDCWNfRgswMnpXTvw0bmn88akQSQmRDJXOJUzjrvx8SUuJmQnMXfaUP4zYQCOmDDmCqdypk/7/DDa58Ecz+c9tc9/dJ9rNBqNRqM59dAZeUUkko3Cy4xuqbxwVv/A+GmJcQx9ezl78JHdQmbMh2Sz8PKL3Ez+OroPAGO7dKRHXBRTP13NPgxSW3hLnJhsx8sfhuXwm8HdARjTpSOJEQ5mLd7I6ZgtZqRqMNmJjxfG9OeaPmkBjSi7jQe+3c5gHC0W0NiPQak0+HjiEKZkJgVeC8DzG3czQDpaLPawBx9V0uDbqcM5PSkegHFdO9Hg8fH5zv30li1nKwvw0ojJgvOHkxnr78E5Ia0TFR+62VBeQ5ZCP8xteBFWwRcXDKdDuAOASemJDJ6zjI2HXC2+JwCb8NIh3M6C84cTYfNnFSenJ9Lz1S/Z2OhlrEKmcSMecuKj+XjqEGxNRZ0mpCWS9fIXbPV5GcKxvY+P0RAexqR2YM7k0xDC/7s7I7UDOa99SQFe+uH43udrnwejfR6M9vlh2ovPNRqNRqPRnJroHYIiXqBamkzNSg4aH5QYR2pEGJUKmaQGJE4pmXaUxqT0ROwWQZWChv+OLkzNDNY4LysFgCqFrFjzY46ex7SsZAzgkMI8KjGxCcHkjMRjNFxSUq+QjarCJDnCEQhumjkvO4UaaSrlOysx6ZMQEwhuAIQQTM9OoVKqZQgrMRmd2jEQ3ABYLYKpWckcsqhlCKuFyeSMpEBwAxBuszI5I5FqoaZxyGIyNTs5ENwAJITbGdulI5WK2c4KaTItKzkQ3ABkxEaS2zFWyV/a58FonwejfX6Y9uJzjUaj0Wg0pyY6kFfEhv9u7KaquqDx/Y1uDrg8Su0K/D0FYUNlbdD49kP1eE2p1DYhsukt21QVrLGx6ecT0Wiel8r90CgEPinZdrD+GA0Lam01ohBUujyUNwQfId1YWUuYEErHRaIQFNU20uANPhq8obKWaKFm7ygEm6tqMczgoCyvspZIqXZHNVwK8ipqOLoJRF5FLRGKGhFSsKEi+D0xTMmGyhrlO7sxQhzzvjZ4feysaVDyhvZ5MNrnwWifH6a9+Fyj0Wg0Gs2piQ7kFbEg6Clt/COviDn5pfhMk101jVy5cD02oJtCwakwBN2w8ciqAj7bvR9TSrYerOPqRXlECwsZClv6OCykCRu/Xr6NpaVVSClZe6CGm7/cSEdhJUXhaGsyFjoJK7d8uYk1B6qRUvJVWRW/Xr6VrsJGnIIt0rERIyxcsyiPrQfrMKVk7u79PLwqn2xsSgFON+zYEFy5MI9dNY34TJO3C8p4Oq+IntKmVIwsBztOn8E1izZQWu/CY5j835a9vLajhBypdnOkF3bKG93csmQTlU4PjV6Dv6zbyfy9FeQoHFkG6I2djVV1/Pbb7dS4vdS4vfzu2+3kVdbSS7EYWS9pZ0FxBU+u20mj16DS6eEXSzdT2uCmt6JGT2nn9R2lvLB5D27DoKzBxXVfbKDRa5CjoKF9Hoz2eTDa54dpLz7XaDQajUZzaqL7yB+H7+or60OyGBdF+LAKMCRECMF4GU4XxXID7qbiWaXSwCb82b4YYWGiDFeu2NyAyQLh4sARGgnCwiQZoXyfsgaT+cLJIWkGNBKFlckyXDkrVoHBQuGi7giNLsLKRBlBmGImqRQfXwgXTikDGpnYGE94i3ePmynCyxLhxiNl4H3piY2xhGNR1NiGh29w48P/7ZYE+mFnBGHKVcXzcLMaT+CwtQAG4+A0hTu/4L+3uwI3m/AiABN/5nAEYfRp4c5vMyaSZbjYcYRHHUIwVoa1eOe3Ge3zYLTPg9E+P8wP7XPdR77t0X3kNRqNRtOeCGWt14H8cWhpYa/AYD8G4QgysIXcIkgi2Y9JJQZRCNJRy8odrVGGwSFMYrCQhlV5M9+MiaQEg9qmgkpdsCpv5psxkOzFRwOSTlhIboWGt0nDiSQZa0gtqJrxINmNDy+SzlhJaIWGC8kefBhIumIjthUHVhow2dtUATwdm3KweCS1mJTgw4IgA2uLBdmOxyEMyjCwN3lUNeA8Eu3zw2ifB6N9fpgf0uc6kG97dCCv0Wg0mvaEDuRPEL2wazQajaa9oQP5tkev9xqNRqNpT4Sy1us78hqNRqPRaDQajUaj0fyE0IG8RqPRaDQajUaj0Wg0PyHUKvpoNBqNRqPR/I9SjE+pW8HRz9mKl3qLJMYU5GInNYRtlURShI/twodTSBJMQS6OkOpnSCT5+CgQXjwCOpoW+mMPqX6GgWQ7XnYKHz4ByaaF/jiICSHX40OyGS+7hQ8pINW00h97oMWiCm4km/FQLAwAukoruThCqn3hxGQjXsosBkJCprTSF0dItS/qMNmIh/0WE5uEbGmjN/aQal9UY7IBD1UWE4eEHtJOT2wh1VapxGAjHg5ZJBFS0EvayApRYx8+NuGl1iKJMgV9sJMe4tZf+/ww2ufBaJ8fpi183hp0Rl6j0Wg0Gs0pzSJcbMKj/PjNeJiLk4ROkVzaN43w+HA+wUkhXmWNNXhYiIv05Bhm9O2KN8bORzRS0lRIUoWvcLMEF727JHBRn67URFr4UDipwFB6vkTyBS6+wc3gjI5M79WF8jD4UDRSg6mkYSCZJ5ysFR7OyE7inJxUdtkNPhZOGhQ1PEg+FU42W3yM75HC+B4pbLH6+FQ4caNWyqkRk4+Ek512gyk9UzkjO4l1wsvnwomhqFGDyYeikbIwmN6rC6dndORb3CzChVTUqMDgA9FIdYSFC/t0oU/XBJbgYhlupecDlODjQxrxxtiZ0bcrGSkxLMTF6hA8uhMvH+PEER/GpX3T6JQYyTyc2ufa59rnR9FefN4adEZeo9FoNBrNKc11fdJ4ZVsJPaW9xcyYG8lq4eHGvun8Y0w/hBCYUnL5/HV8vusAWbLlzgV1mKzHwwNDevD7oT0BeHKUyTkfr2RFeQ0XyZY7Y1RgsA0vz4ztx439MgB4YmQvRr/7DasONXKujGzxdRdjUISPd6YM5vzsFAAeGZHDkDlfsabBzXgiWtQoxEeZNFhy4QhGpXYA4PdDenLanGXkeTyMIrxFja14qBUmq2acQd+OMQD8ZnA3hr71FVulh0EK7S3z8IDNQt5lY0iP8c/7m/KDnPn+txTgo5fCiYs1uEmIdLDm0jF0ivC3w/x41z4umreWYgylLN8q4aZHQhTLLxpFtMP/+Be37OWWJZvog73FDJ1EskJ4GJmSwOfTh+Ow+nNuj64u4A+r8umNvcUsstGkcX5WCnPOPg2LEEgpue2rLfzf5r3a52ifa5/7aS8+by06I6/RaDQajeaU5he5mXilpEwhe1KOgUdK7hrUDSH8mzOLENw5qBsN0qRCITtX3PTv3DkwOzDmsFq4fWA2VdKgTiErthcfsXYr1/VJC4xF2W3c2j+TEmngVdTIiolgelZyYKxjuINZ/dLZK9SynXvxMSI5PhDcAKTFRHB5ThdKLWqZymJhcG5mciC4AejTIYapWcmBI8gtUWoxuSynSyC4ARiZ2oGRKQnsUcyKFQuDWX0zAsENwLSsZLrHRipp+JCUSINbcjMDwQ3Atb3TiHfYlDTqkVRJg9sHZgeCG4DbB2ZhEYe9831UYlIvTe4clI2lyaNCCO4amK193oT2ufY5tB+ftxYdyGs0Go1Gozml8TV14lXJmjQ/wmsGb/Caf1bZWFmaVLxm8AbP06ShkrsRgCnBOKqLsNc0lXM/4jhzAPAaMiQNz3E0PKFqGMdumEPWMI+jYZrKm10Lx76vzRon8js1pMSQUmkezf/O0b9TrymRUs0bzf/OsR7VPg/S0D4/RkP7PPhntXmcuM9biw7kNRqNRqPRnNL8aU0hYULQRaEwUWeshAvBH1fm42vaqLkNg0dWFxArLHRS2FqlY8UC/HF1PrIpQKn3+Pjz2p0kCSvRClu/LGzU+wxmry8KaFQ6PTydV0QaNqXCV1nYKGlw8Z9txYGx4jonz2/eQ4ZUK9KUiY21FTV8tnt/YGzbwTrezC8l3VTTyJA2Pt97gG/KDwbGVuw7xNw9B8iQardA000rc3aUsqWqLjA2b/cBVh+oIUvxJmmGtPHi5j3sqW0MjL28vYS99S4lDRuCdGw8nbeLSufhO7pP5e2izmuQqaARjYVkYeXPawup8/gzfVJKHl5d4J+jgkZHLMQJC4+uLsBt+DO9hin546p87fMmQvV5lvZ5gFPJ54k/kM9bi5BSnrx8/0+U2tpa4uLiuIZoHCf1exSNRqPRaNTwIPkP9dTU1BAbG/tjT+d/gub1HmAc4fRUrFxfgJcvcZEWHc7wlASWllZR6fQwiQjlasmb8PANbnrERTIwMY5Feyto8BqcIyNIVqx0vAo36/GQ2yGGHglRLNhTgWmYTJURShW9JZJluNmOlyFJcaRGhbNgbwVhJkyVEUQrbGJNJAtxsRsfZ6QmEOOws2BvBXFYmCojCFfYR/maContkwbjunZEIFhcUkmysHKOjMCmoOFuKiRWjcnE9E7Ue3x8VX6ITGxMJDyQNfs+GjD5RDhxC5iYkcj+BjerDlSTg42xhCtl+Kox+UQ0YrFamJSRSGF1Axur6hiIg2EKd6ABDmAwVziJtFuZkJ7Ihopa8msaGEEY/XG0LID/uO8CnHSIcHBml46s2HeI4noXZ2qfa59rnwfRXnzeTChrvQ7kj4MO5DUajUbT3tCBfNvTvN5PI4LOIdb/rcBgC14ahEmstNAXOx1C3LCV42MbXn+7ImmhHw5iQzgsKZEUY5CPF7eQJEorfbETFaJGET4K8eFFkoqV3tiJCEHDRFKIj134MJF0xUYv7CHtoXxI8vEG7tdmYKMndqXgphlPU4uxEnxYEGRhozstF6s6EheSrXgox8COoBs2skNsh9WAyRa8VAgDhxTkYCeN0Ape1WKyBQ8Hhelvy4U9ZI8ewmAzXmqFSZQU9G1FOyzt88NonwejfR7Mifq8GR3InyA6kNdoNBpNe0MH8m2PXu81Go1G054IZa3Xd+Q1Go1Go9FoNBqNRqP5CaEDeY1Go9FoNBqNRqPRaH5ChHYJQRO4p7Mfg3AE3bGFdL8G/Hds9uCjEpMoBN2wExbikT6j6a7PIUxisNBNsXLnkXiR7MJHLSbxWMjCFtIdHfAX3diJlwYknbCQgU2p0MaRODHZiQ8nkmSsId+vAajHZBc+PEg6YyW1FRo1mBThxQDSsJEU4t0YgIMY7G6695SJLeT7NeAv/lGMDyuQhZ24EP0lkZRjUHbEvSeVQi5Ha2ifH0b7PBjt88O0F59rNBqNRqM5tdB35I/Dd92ZcyOZL5yUS4OOYXZqvT6kKRlHONmKlREbMZknXFRKg6RwB1VuDzYEE2U4XRS/V6nBZJ5wUiNNkiMcHHB6iBQWJstw5eIOlRh8Llw0SpOkCAf7nR7ihIUpMkJ5Q12Gj4XChRdJxzAHB1weOgorU2S4cgGSIrwsxoWwCOLsNirdXlKFlckyQnkzvB0PX+HGbhFE2mwc8njJwMYEwpUDtvW4WY2HcKsFh8VCjddHD2ycqVgBVCJZgZuNeIm2+d+Dep9BLnZGEKYUbJlIluIiHx9xdhse08RpmAzBwWmKFUB9SBbhYg8+Ehx2nD4Dj2kyijD6KFYA1T4PRvv8MNrnwfzQPtd35NsefUdeo9FoNO2JUNZ6nZEPgZW4qbfBgnOGcWaXjhxye7llySY+2rmPFKxEKmzql+PGEm7l63OHMzQ5nn0NLq5cmMcXZQe5TEYpZWGWCBcdY8JZdu7p9OkQw+7aRmbMW8sXVfXMkJEtbshNJF8IFz06RvP2lMFkxUay7WAdF3y2hiV1LqbLyBbn4G3SGN65A69MHEhqVDhrDlRz/qerWe50M5mIFjWcmCzGxbTsFJ4bl0tCmJ2lpVVcNHctK7xuxhLeokY1Jstwc22fNJ4c1Ydou5VPivZz+fx1rDc9DFEIDPbhYxUe7jmtG/cP6YHDYuH1/FKu/2IDSXjppxAYFOFjI17+PLI3t/bPRAD/3LSbX3+9jRSsSoHBNrwU4uPFs/pzRU5XPKbJY2sKeGLtTlKwKlXxXI+HcovBO5MHMz0rmXqvwW++2cb/bdlLKlalNi3a54fRPg9G+zyY9uBzjUaj0Wg0pyb6jrwiJpJC4eOOgdmM69oJIQQdwh08e2Z/LBbBzqZjpt+HE5Pd+Pj90J4MTY4HICUqnOfP6o9TykAriu/jEAb7pMGfRvWmT4cYADJjI/nH2H7USJNyjBY19mFQLU3+PrYfWbH+YKZ3hxj+PKo3+6TBIQWNvfholJLnxuWSGuUPRE5PiufBYTnswYcTs0WNQnwIi+DZcbl0CHcghODMrp24c1A2O4UPg5YPi+TjJc5h4+kxfYlx2BBCcF52Ctf0SadAtPz7BNiBj6yYCB4enkOEzYrVIriyV1emZycra+TjY1hSPHcMysZhtWC3Wrh9YDYjkuPJV3hfAQqEj2lZyVzdOw2rRRBhs/LHYTl0i40kH6+SRqHwcU2fNM7PTkEIQYzDxuwz+pDgsCvNQ/s8GO3zYAq0zwO0F59rNBqNRqM5NdGBvCI+wCsl2XHBWbyEcDsJYXacCptxDyCB7nFRQePp0RHYhMCloOFueky3o+bRrUlTRaP5Md1ij6+h8lpcSKwCMmOCNbrHRSIBd4sKfo14h50OYcFZvOy4SLxSKoUFLiRdosIJswZn4LrFReKULQdZzRrd4qOwiODMV/f4aNxC7eaJR0h6JEQdM94jQV3DLaB7fLCGEIJu8VFK7yv437tuscEaYVYrXaLDlTS0z4/V0D4/jFv7PEB78blGo9FoNJpTEx3IK2IHOgorb+WXcWRZgeVlB9nv9JCscJQzGkGUsDCnoDRo/MNd+/BJqaSRgBWHELxdUBY0/lZBGQKUClclYkU0PedI3i4swy4EHRU0krBiSHhvZ/kx84gSFmIUjoMmY6XC5WFZ2cHAmJSSt/LL6CCsSjddk7Cy9VA9W6rqAmOGKXm7oIxkoXaPOgkLX5VWUdbgCoy5DYP3CsvpZKr9L9JRWpi7+wA17sMZxVqPl8+K9tNJqml0MgXvF5bj8h3OwpU3uFhWUqVckCwZC28VlGGYhz267WAdmw/Wkazwv7v2eTDa58F00j4P0F58rtFoNBqN5tREF7s7Dt9V/GYnXhbh4tyMJGb27ExRbSN/XbeLcJ/kPBmhdJdxMx6+xs2l3VOZnp3Cpqo6nsrbRZJh4WyF+7YAq3CTh4dr+6QxIS2RlfsO8czG3XSXNqX7tgBLcVEgfNzaP5MRKQksLqnk/7bsZQAOhikWnJqPk31Wk9sHZtG/YywfF+1nTkEZIwkjVyE8MZF8Ipw02gR3nZZNdmwkbxWU8enuA4wnnO4K9219SD4QjVjDbNx9WjbJkWH8d2sJS8uqOIcIuirct3UheV80khDl4I5B2cTYbTy3aQ95FTWcR6RSYbVaTD4QjWTERfKrAVkIIfjHhiKKqhu4QEYSqxBcVGLwEU76J8Zwc24mDV6D2et3UdXg5kIZoVRNuxQfn+HkjM4duKZPGhWNHv6yfic+l4/zZaTSnV3t82C0zw+jfR7MD+1zXeyu7dHF7jQajUbTnghlrdeB/HH4voW9EC/rhZeD0sDW1PJoBGHKlaclkm142Si81EgThxD0lDaGEqbcbkgi2YCXLcJLvTSJEIJe0s5gHE05yJYxkKzDwzbhxSkl0cJCX2ljAA7ldlY+JKtwky98uKUkTljoL+30xq6s4W6qgl2IFx/QQVgYJB1KwU0zDZiswE0RPgwgUVg5XTpID6GWY02Txh58SCBVWBkiHaSGoFGFwUrhoVj6D0unCRtDpYNOIWTV9uFjlfBQLg0EkIGN4YSF1JprLz7WCg8HpIEFyGryqGqFddA+PxLt82C0zw/zQ/tcB/Jtjw7kNRqNRtOe0IH8CdLSwi6RePCX/FcNKE6GhonEi/+YaGsrG7eFhoH/nq8DQu5p3ZYaPiQGhNzD+Ui8SCSc0IbO23Sv9UT6QHuQiBPUcCOxQsg905vRPg9G+/xYDdA+bysNFY/qQL7t0YG8RqPRaNoToaz1P+od+YceegghRNCflJSUoL/v1asXUVFRJCQkMGHCBFauXNmi7lNPPUVOTg4RERGkpaVxxx134HK5WnyeKgJBGKLVG7a20rA0aZxIe6K20LA2abQ2MGkrDVuTxolgR5zwZs6OOKHABPwB1olqhCFaHdyA9vnRaJ8fq6F93nYabeFRjUaj0Wg0pw5K5yn//ve/hyx8zTXXEBMT0+Lj+vbty6JFiwI/W4+oytyzZ0+eeeYZsrOzcTqdzJ49m0mTJlFYWEhiYuJx9V5//XXuvfde/v3vfzNy5Ejy8/O5+uqrAZg9e3bIr0Oj0Wg0mlOBk7nWazQajUajaVuUAvnbb7+drl27BgXZ30dxcTFTp05VWtxtNltQFv5ILr/88qCf//a3v/HSSy+xceNGxo8ff9znfPvtt4waNSrw3MzMTC677DJWrVqlNHeNRqPRaE5FTuZa/7+KC0kDJtFYWn1SphETJ5JYLK0+odKAiQtJHJZWn1Cpw8SDJB5Lq06XSCS1SIwmjdacLpFIapDIJo3WnF4ykdRgYkEQ28oTUEaThh1BTCsPr/qaNMIQRLdSw4ukFpMIBJGt1HAjqcckCgvhrfSG9vlhtM+D0T4Ppi18HgrKFY7WrFlDUlKS0mNDWdQLCgro3LkzYWFhDBs2jMcee4zs7OxjHufxeHjhhReIi4tjwIAB36k3evRoXnvtNVatWsXQoUPZtWsXc+fO5aqrrvrO57jdbtzuwx2ha2trleev0Wg0Gs3/CidrrW/vLMPJGCKUr5x4kSzHRSE+TMDeVOhwBGHKwYETk+VNBSwlECYEfaSd03EoBwf1mCwT7kDxyQgh6C8dDAihGOchDL4SbsqlvyVktLBwmrTTW6k5pp8DGHwt3Bxo0ogTFoZKB9khFPQswce3wsPBJo0OwsIIGabUlaOZXXhZJTzUSBPwFwUdLcNCauW4HS9rhYf6Jo1UYeUMGUaCooZEshEvG4QHZ1MZqjRh4wwZphwsSSRr8LBFeHFLfy2RLGyMJkypswf4g7QVuNkhfHilxAJ0x8YowrXP0T7XPj9Me/F5a1D6LT344INER0cri/72t7+lQ4cOLT5u2LBhvPLKK8yfP58XX3yRffv2MXLkSKqqqgKP+fTTT4mOjiY8PJzZs2ezcOFCOnXq9J2aM2fO5OGHH2b06NHY7Xa6devGuHHjuPfee7/zOY8//jhxcXGBP2lpacqvVaPRaDSa/wVO1lr/U6DcKlmCei2dJbgosZn8aVRvvrpoJA8M7UGBxcfXuFt+Mv4N7ELhoiZM8MzYfiy7aCS3DcpmAx7W4lHSMJDME07MSCv/Hj+AJReO4Op+6azEzRa8ShpuJHOFi+jYcF6fNIgvzh/O9J6pLMPNLkWNekzmCSddOkbx3pTBzD9vGGMyElmEizJ8ShoHMZiPk36pcXwydQifTB1Cbmo883FShaGkUYaPRbgYnd6Jz88bxntTBpPWKYq5wkk9ppLGLrwsxcW0Hil8cf5w3pg0iJjYcOYKF27UakNvxcsK3FzVN50vLxjBfyYMQEba+Fw4MRQ11uIhDw+/GpTNsotG8s8zc6kJEywQrqZSpS3zTVNwc//QHnx10UieHN2HUpv2ufa59vnRtAeft5Z2VbW+oaGBbt26cc8993DnnXcGxsrLy6msrOTFF19k8eLFrFy58jszBkuWLGHmzJk88sgjDBs2jMLCQm677Tauv/56HnjggeM+53gZ+bS0NF3FVqPRaDTtBl21vu1prlr/7Jn9uHnJZmYQ2WJGqhqTt2jg3+MHcEWvroHx2et3ce832/gZUS0eDy3Hx8c4+WzaUCalH675c+832/hnXhGXy6gWj2XuxMsiXKyeMZqBiXGB8asX5vFJQTkzZWSL2crNeFghPBRcMY60mAgApJSc8/EqNpUe4nwZ+b3PB1iNm3ybQdHV44kP82cmTSkZ8tZX1FQ5OZuIFjWW4qIm0kLBleMIa7ra4TYMcl75kphGk7GEt6gxHyfRHcJZc+kYrBb/665xe8l6+Qu6e60MJaxFjY9EI707xzN/+jCE8GuU1Dvp/sqXDJMOclvI3kokb4lGzumewiuTBgXGN1bWMvitrxhPeIttR31IXhcN3NQ/kydH9wmMf1Fcydkfr2QaEXRuIXvrxOR1Gnh0RC/uOq1bYPz1HSVcvWiD9jna59rnftqLz4/kpFatdzqdNDY2Bn7es2cPTz31FAsWLAhV6hiioqLIzc2loKAgaKx79+4MHz6cl156CZvNxksvvfSdGg888ABXXHEFs2bNIjc3lwsuuIDHHnuMxx9/HNM8/jdVYWFhxMbGBv3RaDQajeZU5WSu9e2RSWn+5MBBhYzWwabM2TmZwQmFKZlJmPg3hi1RhYlNCCamBZ8wnJKRhEtKGhSyUQcxSY5wBAU3zfOqlaZSHqgKkz4J0YHgBkAIwTmZSVRKtQxhFSajOncIBDcAFiGYkpFEtUUtQ1gjTCamJwaCG4Awq5WJGYlUCzWNaovJlMzkQHADEBdm54zOHZWznZXS5Nys5EBwA9A1OoLcjjFK3vACNdI8xhv9O8WSGhGmpNGAxCXlMRpnde2I3SKUNKoxMYCzM4I1zslIBrTPQftc+5ymx7QPn7cW9QsZTUyfPp0LL7yQm266ierqaoYNG4bdbqeyspK//e1v3Hzzza2ejNvtZtu2bZxxxhnf+RgpZVD2/GgaGxuxWIK/n7BarUgpaUeHDzQazRE811B8who3RekrMRpNW3Ey1/r2yIbKGgCiFPIbzY/Jq6hl/BEbt/UV6hrRWPBJyeaDdeR2PJw8WF9RgxWIUMjeRCGodLkprXfRJfpwJm99RQ3hQmBX2PJEI9hW20idx0eM4/CWcH1FDTHCgsr+MxrBxspafKaJ7Yj917qKGiKlWhYqQgrWHahGShkILqSUrDtQQ4SiRmSTxpH4TJO8ihriFfNWMUKQ1/Q+NlPv8VFY3UCOwt1hGxAuBHmVtczs2SUwXt7g4oDLTXeFbGk4Ait+f43rethfWw/W4zUlUUreaPJoZQ19Ox6uZRGKR7XPj9XQPvejfR5MW/i8tYSckV+3bl0g0H733XdJTk5mz549vPLKKyG3rrn77rtZunQpRUVFrFy5kosvvpja2lquuuoqGhoa+O1vf8uKFSvYs2cP69atY9asWZSUlHDJJZcENK688kruu+++wM/Tpk3j2WefZc6cORQVFbFw4UIeeOABzjvvPOVKvBqNRqPRnMq05Vr/U+COr7aQKKwkK2yLkrCQJKzc9OVGlpcdxDAlC/dWcPfyraQJG3EKGmlYiRUWrlqQx7qKGnymyQc7y/njqny6YVOqmNwNO3YEP1uwjm0H63AbBq9sL+HvG4roKW1KBZZysOP2GVyxYD1FtY00eg2e2VjE6ztK6SXVCnj1xs6+RjfXL95IWYOLWo+XR1cXsLC4MiSNzQfruWv5ViqdHqpcHu7+ehsbq+rorVhIrJe080VJFQ+vyqfG7aWswcUNizdS3ugOSeONHaX8fUMRjV6DotpGrly4HpfPIEdBw4IgR9r5x4YiXt5WjNsw2H6onp/NX48dQTcFjTAE3bDxx1X5vL+zHJ9psr6ihisXridGWEhXyMHFYiFd2Pj18m0s2FuBYUq+Lj/ITV9u1D7XPtc+P4L24vPWEvId+cjISLZv3056ejozZsygb9++PPjggxQXF5OTkxN0FK8lZs6cybJly6isrCQxMZHhw4fz8MMP06dPH1wuF5dffjkrV66ksrKSjh07MmTIEO6//36GDBkS0DjzzDPJzMzkv//9LwA+n49HH32UV199ldLSUhITE5k2bRqPPvoo8fHxSvNqvjOn78hrND8MOiOv0bTMD3lHvi3X+vZM83qfgIWziSBWMb9Ri8kC4aLqiGO5KcLKRBmu3D6pCsNfIEkePrqZJmyMl+HKG79yfHwh3DQcodENG2cSrtyeaw8+lggXriO2g72xM5ow5WrL+XhZLtx4mzQsQH8cDMWhXFV8Ix5W4Q4cDrYCQwhjgGJVcYlkNR424AkchrULwSgZphScgL+l19e42YY3kKQNF4KxMpxMxUOsBpIvcbHziAJoUcLCeBlGqqKGB8kXwsVeeVgjTliYKMPpqFhVvBGThcLFviM82lFYmSTDtc+b0D7XPof24/NmQlnrQw7k+/fvz6xZs7jgggvo168fn3/+OSNGjGDt2rWce+657Nu3L6TJtkd0IK/R/LDoQF6jaZkfMpA/FdZ6OLzeX00UYSEeUpRISjGowyQeCylYQ+7lbCIpwaABk05YSQyhfVQzBpJifLiQJGGlQys0vEj24sMLpGJVykIdjbtpHgbQBWureko7MSluCnHSsCq3oDqSekxKMbAA6a3MhtVgUo6BvUmjNf2gD2JwAIMwBOnYWtWzvAKDSgyisNAVa8htrCSS/RgcwiQGC11a4VHt82C0z4PRPj9MW/gcTnKxu9///vfcfffdZGZmMnToUEaMGAHAggULGDRoUAvP1mg0Go1G095py7X+oYceQggR9CclJSXo73v16kVUVBQJCQlMmDCBlStXtqj71FNPkZOTQ0REBGlpadxxxx24XOoth44k1A1b83O6YqM3DlKxtUrD0rT57Y2j1Zs+K4JM7PTC0argBggch+2FvVXBDfiPynbHTg72VgU3ABFY6ImdnthbFdyA/75qDnZ6YG/1kdY4LPTCHjjW3Ro6YKUXDrKwtyq4AUjESm8cpKN2hPxoBIKUJn91baVHtc+D0T4PRvv8MG3h81AJudjdxRdfzOjRoykvL2fAgAGB8fHjx3PBBRe06eQ0Go1Go9H88LT1Wt+3b18WLVoU+PnImjU9e/bkmWeeITs7G6fTyezZs5k0aRKFhYUkJiYeT47XX3+de++9l3//+9+MHDmS/Px8rr76agBmz54d8vw0Go1Go/mpEXIgD5CSkkJ9fT0LFy5kzJgxREREMGTIkKA2BhqNRqPRaH66tOVab7PZgrLwR3L55ZcH/fy3v/2Nl156iY0bNzJ+/PjjPufbb79l1KhRgedmZmZy2WWXsWrVqpDnptFoNBrNT5GQA/mqqipmzJjBl19+iRCCgoICsrOzmTVrFvHx8fz1r389GfNsNxzEYAMeKi0Sh4Qe0kYv7CEdBdmPwUY8HLJIIiTkSDs9QjzGUYqPzXipsUiipaCPtJGpWOSimd342Cq81AtJrCnoh52uIVhCIinExw7hpVFAginoj4PkEI6TmEi246VQ+HAL6GgKBuBQLnIB/ntTW/CyS/jwCkgyLQzEEdKxKS+STXjYLQxMAalNGiptJ5pxIdmAhxKL/95TV9PKAByEh/C+NmCSh4dyi4lFQoa00h9HSEeeajDZgIf9FhObhGxpo1+IR57ai88XL1nK7Gf+xbYd+WRlZPCLm65n+tRzlZ8P2udHon0eTHvxeVt8nrc1bb3WFxQU0LlzZ8LCwhg2bBiPPfYY2dnZxzzO4/HwwgsvEBcXF3QS4GhGjx7Na6+9xqpVqxg6dCi7du1i7ty5XHXVVSG/Vo1Go9FofoqEfDHjjjvuwG63s3fvXiIjIwPjl156KZ9//nmbTq69sR+DD4UTZ5SNK3LTOT2jI8txsxQXUqUJJbAXHx/TiDXOwdX90+ndJZ4vcbESt/I88vHyGU7iOkZw7YAM0pJjmI+LDXiUNTbiYT5OuiRFc+2ADBI6RfIZTvLxKmuswsNiXOR0jufq/unY4sL4mEb2HlHBsiWW4mI5bgZndOSK3HTc0TY+Ek72Y7T8ZPxB1kJcrBIezshO4vJ+aRyKEHwkGjmkqOFDMlc42WjxMqlHChf36UKpQ/KRcFKP2bIA/uInnwonBTaD83p15rxenSmwGXwinLgVvdGAyUfCSYlDcnGfLkzumcImi5e5wolPUaMak49EI1URgsv6pjG2WxKrhYcFuDAVNdqLz1978y0mTD2fsvJ9XHjeNNweN+df+jP+8tQ/lDXai8+XaZ8HOBV8vuIH/jw/GbTlWj9s2DBeeeUV5s+fz4svvsi+ffsYOXIkVVVVgcd8+umnREdHEx4ezuzZs1m4cCGdOnX6Ts2ZM2fy8MMPM3r0aOx2O926dWPcuHHce++93zsXt9tNbW1t0B+NRqPRaH6KhFy1PiUlhfnz5zNgwABiYmLYsGED2dnZFBUVkZubS319/cma6w/Gd1Wt/1Q00rFDJMsvHkWEzZ9Je3lbMbMWb+QCIklqIbsmkbwrnAzoHM9n04Zit/q/R/nz2kLuX7GDmUS12CrBQPKmaOTcbsm8OmkQlqYjjnct38qzG3ZzOVEtZsbcSF4XDdyYm8HfRvdBCIGUkisX5vFJ4T4uk5EtZrXqMHmTBv44LId7T+8OgM80mfrJKtaXHuJiGdliRuoABh/QyPPjcrm2TzoATp/B2Pe+YX9VA9Nk5Pc+H/ztRD7HyYfnns65mckAVLu9nD7nK6z1XiYS0aLGdjwsw83yi0cxNDkegPIGFwPfXEaqG0YT3qLGOtxstHhZd9kYesZHA1BQ3cBpby4j17RxGmEtanyNi1KHJO/ysXSO8v+bq/dXM+rdrzmDMHortCZZhBNvtI01l44hIdyf0ft8zwGmfbqayUQotRX5MXx+dNV6t9tNek4/zho7htf/8yIWi//xd9xzH8+99B9KC7bRoUNC0HOOrlqvfR6M9nkwP8XP8x+yav3JXOsbGhro1q0b99xzD3feeWdgrLy8nMrKSl588UUWL17MypUrSUpKOq7GkiVLmDlzJo888gjDhg2jsLCQ2267jeuvv54HHnjgO//thx56iD/84Q/HjOsuNRqNRqNpD5zUqvUNDQ1B3843U1lZSVhYy5u4nypeJKXS4ObczMCmD+DnOV1JcNiUsnN1SA5Kg18OyAps+gB+0T8Li4BiBY1KTBqkya8GZAU2fQC3D8jCi6RMQaMcH14puX1AVuCuoxCC2wZm0SBNKhSyc8X4EMAvB2QGxmwWC78akMVBaVKrkNEqxkec3cZVvQ4HYBE2KzflZlAmjSO6W343e/HRLTaSczIOb/biw+zM6ptOsVDLVO7FYGRKQiC4AUiNCufynC6UWdQ0SoTBuVnJgeAGoEd8FNOykylRnEepxWRmTpdAcAMwJDme0akd2KuYdS0RBtf1TQ8ENwBnZyTRIy5SyaPtxefrN2zkQEUFt//i5kAQD3Dnr27F5XKx5KuvWtTQPj9a48R9Xqp9HqC9fJ6fLE7mWh8VFUVubi4FBQVBY927d2f48OG89NJL2Gw2Xnrppe/UeOCBB7jiiiuYNWsWubm5XHDBBTz22GM8/vjjmOZ3/7993333UVNTE/hTXHzirS81Go1Go/kxCDmQHzNmDK+88krgZyEEpmny5JNPMm7cuDadXHtCNP1x+oI3mj5p4jWl0i+y+TFHa7gNE1OidFu2WcNlBG9UnIZfU+V+aPP9T+dRGi6fGfRvtKRhHmcejU0aqq/FK028R226nD4z8PtW0XD6jGNCIadhKN8+tgCNvmMDiEafoXzP1QI4vcfR8BrK/5NZ5LHeaJ6HsgbHakgpcflMpd9He/G53e4P0JxOZ9C40+lvLeVwtJy11T4/VkP73E978XlbfJ6fLE7mWu92u9m2bRupqanf+RgpJW73d19RaGxsDPqSD/yV8KWUfN9Bw7CwMGJjY4P+aDQajUbzUyTkQP7JJ5/k+eefZ8qUKXg8Hu655x769evHsmXL+NOf/nQy5tgusCHIxMZTebvY1+APJqSUPLluF/U+gyyFo5zRWEgRVp5YU0i1239H15SSB1ftwAJkKGh0wkK8sPDHVfk0Nm2ovYbJgyvyCReCzgrbx85YiRCCB1fswNu0gXT6DP6wKp84YaGTgi0ysGIFHly5A7Np01Tj9vLEmkJShFWpt2YWdhp9Jn9auzOw8drf6OapvF1kYMOmsInNxkZZo5vnN+8JjO2qaeSFTXvIlGoFzbKxsb6ylvd3lgfGNlbW8uaOUjJMtTApU9pYUFzBstLDdz6Xlx3k870HlOeRIa3MyS8jr6ImMPbhrn2sraghW7E4W6a08eLmveysaQiMvbBlL8UNLiWPthefDxrQn+ysTP74+J9pbGwEwOv18sDDjxIfH8dZY8e0qKF9fqyG9rmf9uLztvg8P1m05Vp/9913s3TpUoqKili5ciUXX3wxtbW1XHXVVTQ0NPDb3/6WFStWsGfPHtatW8esWbMoKSnhkksuCWhceeWV3HfffYGfp02bxrPPPsucOXMoKipi4cKFPPDAA5x33nlBre00Go1Go/lfJeQ78gD79u3jX//6F+vWrcM0TU477TRuvfXW7/12/afEd92Rr8HkU+HEsMC4rp3YWdPAjuoGBuPgdIW7oQAVGMwVTuw2C2d26cTGylr21DsZTRh9Fe6Ggr/C8XzhItZhY1TnDqzeX83+RjdnEU43xUrHu/DyBS6SIsIYmhLP12UHqXH7mEy4ckXvrXj4CjcZ0RH07xTLktJKvD6Tc2QEiYob0LW4WYOHnnFR9EiIYnFxJVYTpsoIpWrcEsnXuNmCl/4dY0iJDOfL0kqipGCqjFCqxm0iWYyLnfg4PSmOWLuNpWVVdMDKuTKCMIVAy0DyuXBSIg1GpyYggOXlh+gsrJwtI5SCNQ+Sz4STKgzGdu5IndfH6gP+4GY84UqVtBubPFovJOO6dGJfo4uNVXX0wc5owpQyrz+Gz4++Iw/+ivVTL55JdFQUI4cPZe36DZTv28cb//k/Zlx0bB/ro+/Ig/b5kWifB/NT/Dz/Ie/IQ9ut9TNnzmTZsmVUVlaSmJjI8OHDefjhh+nTpw8ul4vLL7+clStXUllZSceOHRkyZAj3338/Q4YMCWiceeaZZGZm8t///hcAn8/Ho48+yquvvkppaSmJiYlMmzaNRx99lPj4eOW5fdd6r9FoNBrNj0Eoa32rAvn/db5vYXdishUvBzAIQ9AzxFZWAPVNGlUYRGKhF/aQWlmBfxO6BQ81mERjoQ/2kFpZAVRhsBUvdZjEY6FviK2swF/5eTteGjHpgJW+2JWylEdSio8deHEjScJKb+xEhqAhkezFoAAvXiSd8beQUglMmjGRFOFjFz4MJGnY6Ik9pHZYRlObst1N91ozsNEDW0jHY71I8vFSjA8LgmxsZGMLqR2Wu6nVWRk+7Ai6YycDa0jtsH5onx8vkAcoKNzJsy++xPb8AjIz0rnpumvon9vvuI89XiAP2udHon0ezE/t8/yHDuRPBXQgr9FoNJr2xEkP5L/66iuef/55du3axTvvvEOXLl149dVXycrKYvTo0a2eeHtBL+wazQ/LdwXyofBdgbxG87/CDx3I/6+v9aDXe41Go9G0L05q1fr33nuPyZMnExERwbp16wLFaOrq6njsscdaN2ONRqPRaDTtBr3WazQajUbTvgk5kH/kkUd47rnnePHFFwOVpQFGjhzJunXr2nRyGo1Go9Fofnj0Wq/RaDQaTfsmtMuAwI4dOxgz5tiK0bGxsVRXV7fFnDQajUaj0fyInGprvRsZ8tF6N5KdeKlFEo+FbthCqjcB/joNhfhoQNIJC1kh1psAaMCkAF9T/Q0LGSHWmwCoxaQQL178HT+6hlhvAuAQRlP9DUjDSkorNCowAvU3MrEpFxRtRiLZh0Ex/naW2djo0AqNEgzKMLAD3bCHXFfFRLIXH/sxCUPQHVvIdVWMppomlZhENWlEhKjhRbILH4cwiUXQLcS6KqB9fjTa54fRPg+mLXweKiEH8qmpqRQWFpKZmRk0vnz5crKzs9tqXhqNRqPRaH4kTrW1/n0aOJtI5UKFBzCYL5y4kXSJCmdjvYt1wsIUGU6CokYJPhYKF1JASkQYGxpcJAgL58gI5c1wIV6W4MJusdAx3E5eo4skYWWKjCBccQO5BQ9f4ybSZiXGbiXP6aSrsDJJRihvZNfgZi0eYu1WHFYL611OsrFxFuFKG1mJZDlutuIlwWEDBOs8jSF1ojiyM0encDsew2St18NpOBii2InCi2ShcFEsfSRHOKj3GqzxeRhJGP0UO1G4kcwTTvZLgy6RYVS5vKwx3ZxJON0VOws1YDJXODkoTdKiwtnqdLNGepggw0lT3LofwmCecFEvTdKiw9nc4O+eMllG/PA+t7iRFgspSYlsKCung9XOFMOhfa59/r/l8xP8PG8NISvfeOON3HbbbaxcuRIhBGVlZbz++uvcfffd3HLLLSdjjhqNRqPRaH5ATrW1vm+nOBYLFyYt1/81kSwWLvp0imXnlePZedV4tv38TDrHRbBUuJEKGt4mjbFdO7L36gnsuno862aeQUSEneW4lebciMkSXFzcPZXS6yaw+5oJLL1wBB67YAUuJY1DGHyNm5tzMyi7diJ7r5nAp1OHUCkk6/AoaZThYy0eHhjSg/LrJlF67URemzSIPcLHVrxKGrvwP/bpMX0pu24i5ddN5B9j+7EVLzubMpctsRUvRfh4deJASq+dSPl1k3hoaE/W4aFUUWM9Hg4Ig0+mDqH4mgmUXTuRW/tn8jVuDmIoaazAjcsmWHLhCHZfM4HS6yYwo0dnluCiAVNJYzluwiLsrLn0DHZdPZ69V0/gzK6dWCxceBX8JZEsFW5SYyPY+rMz2XnVeHZddRa5iT+Cz60exo0bS9nOHewt2MbGlV8TkdiR5RY1f2mfB6N9fpiT7fMlP+DneWsJOZC/5557OP/88xk3bhz19fWMGTOGWbNmceONN/KLX/ziZMxRo9FoNBrND8ipttY/MaoXtdKkTGETW45BjTR5akxfukSHA9AtLoo/jerNfmlwSGETuwcfTin515m5dIrwZ8ByO8by4LCe7MWHU0FjJz6sFsE/xuYS6/BnwEamduDOQdnsxMBQ2IDm4yPBYefJUX2ItFsRQjA5I4nr+qZTKNSCgny8dIuN5IEhPXBYLViE4NIenbkgO1VZowAfI5LjuSU3E5vFgtUiuKlfBqNTEyhQDJIKhY/zs1OY2bMLFiFwWC389vTu9IiLJD8EjWv7pnN2RhJCCCLtVv40sjcdw+zkKwRJBpKdwscdg7IZldoBgFiHnb+P7YfNIpSCNScme/DxwNCeDOjkr1jdKcLBs+NycUkZOJL9fVRjsl8aPDGqN93jowDoHBXOU2P6/vA+Nwye+8dTdOrUEYDcfn35w+9/y17Tq32ufd6ufX7gB/w8by0hHa03DIPly5dz11138bvf/Y6tW7dimiZ9+vQhOjr6ZM1Ro9H8j9NeWse1RRs8TdvSXrxxKnEqrvXpMRGA/7hoSzQ/JjM2Mmg8I8b/s0tRwyqga9PGsZnMmEgk4AYiWtBwIYm124gPC97KZcRE4kPigxYPhbqRpEaF4bAG53UyYiNwSbXNpxvoFhuBEMHHgjNjI1goJAq/DjxCkt20ET+SrLgoCvfVKmm4xbHviRCCzNhI8mvUsmIuJJkxwb95h9VC56iwQOeG78MAvFKSERusEeewEeew43a1/EI8+F9u1lEanaPCsAmBW6FrdLMHM456LZmxP4LPLRa6dukSPI/0DO3zI9A+P8xP1ucn+HneWkLKyFutViZPnkxNTQ2RkZGcfvrpDB069H92YddoNBqN5lTjVFzr3yksRwBJCvchk7BiAd7ILw0afyO/FIcQdFTQSMGKIeHtgvKg8dfzS4kWFmIU7sqmYKXS7WVxSVVgTErJGztK6SSsSjddU7Cy5VA9GytrA2M+02ROfikpQu1uaDJWvio7yN46Z2DM6TN4t7CcRFNtm5koLXxWtJ+DrsPHnA+5vHy6ax+JUlHDFLxbWEaj93AWrqTeydLSKlIU77mmYOXN/DJ85uHgbnNVHZsO1itp2IFOwsobO0qRRwQiS0qrOODyKN3ZjUYQLSy8viPYX+8WluOTUmkeHbHiEOI4Hi374X1umrz17vtB46/NeYtoq037HO3z/xmfn+DneWsJudhdbm4uu3btIisr62TMR6PRaDQazY/MqbbW/37FDnpjJ0YhvxGNhd7Yue+bbRRWNzAiNYHFxZW8uqOU03AoVUvuiJVsbFy/eAPrK2ro3ymWT4r288GufYwmTKlwVlesdBZWLpq7htsGZpEdG8mcgjIWFVcykXClwlnZ2NgorEz8cAW3DcwiOTKMl7cWk1dRy7mKOaRe2NkmvZzx7tf8akAW0Q4bz2/aQ2m9i+mKGv1wUOhtZOQ7X3Nr/0yEgGc27MblNcglsmUBYAAOPmpwMurdr7kxN4NGr4+n84oIk4JeigW8Bkk7n1bWMu79b7m6TxoHGt08nVdER2Glm2x5yywQnCbtLCiu5JyPVzGzZ2eKaht5Oq+IVGElTbYcFFgRDJJ2XttRSr3Hx3nZKWyqquVfG3eThY1OCoGFA0F/aeev63exv9HN+LROrNxXzYtb9vzwPhcOrr3pVtblbWBAbj8++nQu73/8yU/O5721zwNonwfTFp/nrUVIqXB24QgWLFjAb37zGx5++GEGDx5MVFTwEZHY2Ng2neCPQW1tLXFxcVxDdMjtaDQazU8XfbS+/aGP1h/Gg+Q/1FNTU3PS19pTYa2Hw+v9adgZTJhyOysTSR4etgkf9dIkVljoJ+30w67cispAsgYPO4QXp5R0EBb6Swc5ihWfwe+JVbgpED48UpIorAySdrJC0HBisgI3u/DhA1KElcHSQdcQcj11mKzETRE+TKCrsDJEhillxJo5hMEqPOxpuhubgY0hOEJqq3UAg9XCTYn0t+XKwsYwwpQ29M2U4mOt8FAuDWz4g8DhhIXUEqsIL+uFlwpp4BCC7tI/j1D2lPl42SA8HJQmEULQU9o5HQc2RQ2JZAteNgsvNdIkSljoI20MxPHj+Nxq4jR8dLDa6W9Ytc+1z4H/QZ+fwOd5M6Gs9SEH8hbL4Tf4yHsiUkqEEBiGWrXD9owO5DWaUxMdyLc/dCB/mB8ykD8V1no48fVeNt3R9TeSat1+QSIx8N/zPVEN1c3v8TCRmG2gIeGEMlDNxct+bA0fEguE3Ku8LTXa0hsnqqF9Hqyhfd52GtrnwYSy1od8tP7LL79s1aQ0Go1Go9H8NNBrvRoC0Yp8y7EaIW/GToKGBXHC3Y5PJBhopi2OobaFxokEem2l0V68oX1+rMaJon1+mPbijfbi81AI+d8aO3bsyZiHRqPRaDSadoJe6zUajUajad+EHMhv3LjxuONCCMLDw0lPTycsLOyEJ9ae8SI5hEkYgrhWfq/nRlKDSQQipDstR+LEpA5JFIKoVmo0YNKAJAYR0r2YI6nHpBFJHBalohDHoxYTF5IELNhbebyxBom3SaM13w7KpvfVADpgadU3nWaTBkACllZ9a2sgOYiJtUmjNUdzfE3zsAHxrdTQPg+muKSE8n376dm9G/Hx8a3S2FW0m6qDB+md07NVFcCllOQXFFJXX0+/Pr0JDw9v+UnH0diydRsej4fcfn2x20P//tkwDDZv2QpAv759sFrV7/Y14/V62bR5Cw6Hg759eh/T0kcF7fOTh17rNRqNRqNp34QcyA8cOPB7N1x2u51LL72U559/vlWbzPaMRLIeDxuFN9DfsLOwMlaGE6u48TKRrMTNNuHD26SRIWyMkWFEKmr4kHyDm3y8GIDAX6TiDMKVA2k3kuW42Imv6Z4P9MDOKMKUg+BGTJbhDhTssAtB76ZCF6oBbC0my4SLUum/bxkmBLnSzmk4lDflVRh8Jdzsb9KIEILTpIN+itU7AfZhsFy4qWrSiBYWhkoHPUI4ZLMXH98KN9VNPUnjhIURMoyMEP43K8TLSuGhvkmjg7AyWjpIDUFjCx7WCQ+NTf5KElbGyDClFhqgfX40+/cf4Nqbf8Hc+QsACA8P55brr+NPj/wBm03tfSnavZurb7yFZcu/ASAmJoZf3/5L7v/Nr5UD2E2bt3DNTbeydn0eAB06JPCH393HL266Qen5AN+sWMn1v7iNrdu2A5CaksKTj/6Rn82coawxb/5Cbr3zbop27wEgMyOdZ/72JOeePVlZ48233+Wu++6nfN8+AHrl9OTFZ55m9MgRyhra5yeXU3mt12g0Go3mp0DIX/t/8MEH9OjRgxdeeIG8vDzWr1/PCy+8QE5ODm+88QYvvfQSixcv5v777z8Z8/1R2YyX1Xi4uX8m314yijcnn4Yj2sE84WwKE1pmDR62CC/3nt6dVTNG8+/xA3CGW1ggXE2lM1rma9zssvh4bGQvVs8YzTNj+1Fhhy+FS/m1LBEu9tslfx/bj9UzRvP4yN7sthgsR01DIlkgXDSGW3hp/ABWzRjNfad3Z4vw/45UMJDME05sUQ7emDSIFZeM5pYBmazBwya8ShpuJPOEi47xEbw3ZTDLLxrJ5b278jVuChU16jCZJ5x0T4rhs2lDWXLhCM7OTmYxLkqavqRoiSoMFuDk9C4dWDh9GAunD2No1w4sxEklakWhSvGxGBeTspL48oIRfDZtKDlJMXwuXNRhtiyA/4uA5bi5tFdXll80kvfPOZ3E+AjmCScuRX9pnx9GSsm0S2ayLm8D/33+X6z7ein33nU7T//rOR7446NKGm63m4nTLqCktIy3XvkPa5Yv4YZrruL3Dz/G0/98Vknj0KFqJkw9H4/Hw4dvvc6KJYu4aPp5/PKue3jz7XeVNPYWFzN5+kXEx8Xx+YfvsXzR55wxagQ/v+4GFi1eoqSxYeMmpl96OT26dWPx3I9ZPPdjevXsyQUzf876vA1KGouXLOVn117PqBHD+GrhPD7/8D06dujA2edfzO49e5Q0tM9PPqfyWq/RaDQazU+BkDPyjz76KE8//TSTJx/OvvTv35+uXbvywAMPsGrVKqKiorjrrrv4y1/+0qaT/TGRSDYLL1f07MKTo/sAcHpSPH06RDPgzWXsxkf3FrK3XiRbhZc7Bmbz+6E9ARiUGEd6TAQTPlxBGQZdWnhLGjHJx8ufRvTm9oHZAAxMjCM+zM7PFqznIEaLLSwOYbBb+njlzIFc1rNLQMNqEfx6+VaGYraYTSrHYL80mD/pdM5K6xR4LW7D5Kn1uzhNOlo8Il+Ej2pp8uXUIfTrGAPA4KQ4Drm9vLe9jFzZctuHfLz+YH76MDpH+bNCw1ISKKl3sb74IN1lyxn1rXgJs1mYe95QYh3+x49ISWDn2w1sqmxUak2yCQ+pUeF8NHUIDqv/dzcqtQO9XvuSzfUezlToMboJLwM6xfLm2adhacqEjUhJIOu/X7DV62UYLR9j3Sy8TOzaiefH5QayaacnxZH98mLy8dK/hVMK2ufBLP1qOavXrmPRpx8xfpz/zvCggQNwuz088/yL3P+bu49py3U0H3z8KTt3FbFp1Tf06+v/nQ4eNJBD1dX85eln+NUtNwVVCD8er7zxJoeqq1n/7TI6p6YCMGzI6ZSWlfPkU3/nshkXf+/zAZ77v/9gtVqY98E7gSqoI4YNZVfRbv7692eYcNaZLWr8/dnn6ZyawifvzsHh8Htp9MgR5Aw8nb8/+zz/ef5fLWr89e//5LSBA3jrlf8EXvfI4UPJ6J3Lc//3H554+KEWNbTPTz6n6lqv0Wg0Gs1PhZAz8ps2bSIjI+OY8YyMDDZt2gT4j+SVl5ef+OzaEV6gVppMSk8MGu/TIYbOkWEcVMiYNiJxS8nkozTGdO6A3SKUNGowMeGYeTT/fEhBo/kxx9MwgWoFjYOY2IRgXNeOx2i4paRecR4pEY5AEB/QSEukTppKef2DmPTpEB0I4puZnJ4YOCavMo+RqR0CQTyARQgmZyRSY1HLhNcKyfi0ToEgHsButTA+LZFqoZaZq7H4/WU54jhrjMPG6C4dOKiY1a+SJpMzkoKOxKZGhdOvY4ySN7TPg9mybTs2m42zzhwTND55wlnU1dVRXFLaosbW7dvp0rlzIIg/rDGe0rIyampqleaR27dPIIg/ch5bmo7Jt6yxjZHDhgW1MrFYLEwaH4rGds4aOyYQxIP/iPVZY8ewees2JY2t27cz8axxQV9exMTEMGr4MLZsU9PQPj/5nKprvUaj0Wg0PxVCDuR79erFE088gcdzOMzyer088cQT9OrVC4DS0lKSk5PbbpbtABv+u9drDtQEjZfUO9nvdBOtcJcxHIEVWH2UxsaqOrymVCqSFN30mKPnsXp/ddDfK2k0Pac1GjFY8EnJhsrgIGT1/mqsoHQ/NBrBAaeH4jpnsMaBaiKEWguIGAQF1Q3UuIOP0a/eX02sULN3DIL1FTV4jOBN88p91URJtTuqkVKwal81Uh4O2qWUrNp3SFkjSgpWHfWeeA2TNfurlQtoxQrLMe9rrcdLfnW9kke1z4PJSE/D5/OxYeOmoPFVa9bhcDhISU5qUSM9LY3yffsoLik5SmMtCQnxxMS0XPQuIz2NHQWF1NQE/z5WrVlHRrpan/WM9DTyNm4K+uxunkcoGqvXrj/G56vXriMzI11JIz2tK6vXrgsa83q9rMvbSEa6mob2+cnnVF3rNRqNRqP5qRDyLuGf//wnn376KV27dmXChAlMnDiRrl278umnn/Lss/77nrt27eKWW25p88n+mFgQ9JJ2/rlxN89v3kOtx0teRQ0zP1+HA9HiMUyAMAQ9sPPI6nze2FFKg9fHt/sOccX89cQJC2kKRyhjsJCJjXuWb+XjXfto9Bp8WVLJjYs3kiysJCm8pYlYSBZWbvpyE18UV9LoNfi0aD/3LN9KhrApFXpKw0qcsHDFgvV8U36QBq+PN/NLeXh1Ad2xKRVp6oadcCGY+fk61lfUUOvx8uKWvTyzYTc50q5UMC8HOz5DMvPzdWw7WMchl5e/rd/JnIIyeiscqwfojZ1Kp4erF+Wxq6aRCqebB1Zs58vSKmWNPtjZVl3PrUs3U1LvpLTexS+XbWbLoXr6KBbM6y3tLCmt4v5vt3Og0U1RbSPXLMqjwumht7KGjbcKynhy3U4OujxsP1TPZZ+vx2tIchQ0tM+DOXviBLIyM/j5dTfyzYqVNDQ08MZb7/Dwn57kZ5deolS9/tKLLiAhIZ5Lr7yW9XkbqK2t5YV//5d/PPcCN157jVLBvKt/fjmmaXLpldeybfsODh2q5i9P/YM33n6HW2+Y1eLzAW645moOVFRw5fU3satoNxUVlfzuoYdZ9OUSZY2bZ13L5q1bufm2OykpLaW0rIxb77ibjZu3cMv11ylp3HrD9XyxZCm/ffCPHDhQQdHu3Vx1/c3sP3CAG665SklD+/zkc6qu9RqNRqPR/FQQ8sjUiiL19fW89tpr5OfnI6WkV69eXH755cTExLT85J8AtbW1xMXFcQ3ROI4IJg0ky3CRf0QBtBhhYbwMJ1nxHqMXyZe4KDpCI0FYmCjDSVDUcGLyxRGV3gEShZWJMlw5c1uPyULh4sARGl2ElfEyXLk91yEMFgoXh+ThTHYmNs4iXLmF3H4MvhAu6o7Q6ImdMYQpt38rxscS4QpUrxZAX+yMJEy58n0hXpYLd6B6tRUYiIPBIVTP34KHlcITqF5tF4KhIVTPl0jW4WE9nsBB+jAhGC3DlAKLZo1vcbMZb6DUVqQQjJXhpCuWxDiVff5cQ/ExY9u27+D8mT8jv6AwMDZ1ymTe/O9Lyi3kVq5ew8U/u4qS0sNH8X8+cwYvPftM0DH172PBosX87LrrqaysAvzH4m+9cRZP/fmJFu/YN/PWu+9zwy9vp7bWf5LGbrfzu3vu4vf3/Ua5ev6zL77EXffdj9PpP0kTERHBk4/+kVtvvF7p+VJKHvnTkzz8xJN4vf6TNLGxsTz39N+Oe9f/pqhjTwucqj73IPkP9dTU1ARdkThZ/K+v9fDd671Go9FoND8Goaz1rQrk/9dpaWGvweQABmEIumBtVb/xgxhUYhKFoDPWVvU/rsDgECYxCFJaoSGR7Megtqn3eqdW9GGWSMowaEDSEYty66cjMZo0XEiSsLaql7MPSQkGXiQpWFvVy9mLpAQfBtAZq3L7qCNxN2kAdFU8mXA0TkxKMbAAadiUvxQ5knpMyjGwI+iKVbnV2pGcij4/XiAPYJomS5Z9RVn5Pgbk9iO3X9+QX4fX62XxkmVUVlUx9PTB9OjeLWQNl8vFwsVfUldXz+iRw0lPUzsSfyT19fUsXPwlbreHcWPOIFnhesDRHDpUzaIvlwAwYdyZJCTEh6xx4EAFi5cuw+GwM2n8Wd/5pcjxAvlmTjWf/9CB/KmADuQ1Go1G05446YH8q6++yvPPP8+uXbv49ttvycjIYPbs2WRnZzN9+vRWT7y9oBd2jebU5LsCec2Px/cF8qcaP3Qg/7++1oNe7zUajUbTvghlrQ855fjss89y5513MmXKFA4dOoRh+I8DJiQk8NRTT7VqwhqNRqPRaNoPeq3XaDQajaZ9E3Ig/49//IMXX3yR3/3ud0FFmk4//fRASxqNRqPRaDQ/XfRar9FoNBpN+0atKtARFBUVMWjQoGPGw8LCaGhoaJNJaTQajUaj+fE41db6XXjppViYtJmdeNkqvNQLSawU5EqHcrFF8Nfv2IGPHcJLo5B0MC30x05qCBomki14KRQ+3ELS0bQwEAeJIdSr8SHZhIddwsArJMlNGqoFG8F/FDQPD3uEgSkkqaaVQThCqlfjxCQPD8UWf/HbrqaFQTiUC/AC1DVplFkMLFKQIa0MwBFSvZpqTNbjZr/FxIYg27TSH0dINTgqMcjDQ6XFJEwKuksbfVHrxtNMOT424uWgxSRSCnKkjRzsIdXg2IuPzcJLjTCJloLe0q5cPLeZ/zmf28ArINkrGYi9dT63gSkg1Stb73O7/33s2qTRKp/bBRYJGT5a6XMP++0Cu4QsH63zufBSaROESejuE9rnJ+Dz1hByRj4rK4u8vLxjxufNm0efPn3aYk4ajUaj0Wh+RE61tX4pbtbhVn58Hm4W4aJn53h+cVo2nRNjmIeTbXiUNb7FzVJcnJbekVsHZRPdIZxPcLIbr9LzZVPXhBW4GZOdxE0Ds7DEOviYRsqP6KTwfZhIFggX64WXyT1SmDUgk8YoGx8JJwcxWhbAHyB9Jpxst/q4oHdnrsrNoDIcPhJO6jBbFgBcSD4RTnbbJTP7dmVm367stUs+Fk5cqJVyqsfkY+GkIhyuzM3ggt6d2W71MVc4j+hv8f0cxOAj0UhDlJVZAzKZ0iOFPOFlvnBiKmrsw8fHOCHWwY0DsxjbLYmVws2XuJCKGrvx8SlOojuEc+ugbAZndGQpbr4JwaPb8TIPJ6mJ0fzitGx6dY7nC1ynrs8tbtbbTM6+5AJuuPUmnJ0T+cjqDs3nVjfbwy1cdMVlXHPjLCo7xPCR1R2az60edkeHcfm1V3H5tVexNyacj62e0HxudVPRIYarb7iOi664jO3hFuZa3aH53OqiMbUTN9x6E1MuuZA8m8l8izs0n1tciMwu3PyrWznzvHNYafHypXBrn7fC560l5K8Jfv3rX3PrrbficrmQUrJq1SrefPNNHn/8cf7v//7vZMxRo9FoNBrND8ipttb/sn8mz27cTR8chLeQCXIhWSe83DEgiz+P8n+p8dDQnlz3xQbeyy+jh7S3mNWqxWQzXp4Y0Yu7TvN3sHhwaE/O/2w1K4uryJC2FjNSBzApxMd/Jgzg5zldAXhgaA/OfO9bVlfWc55seYu3F4Ni6WPutKFMTE8E4Hen9+D0t75iTa2HSUS0qJGPl0pp8O1FozktMQ6Ae07rxsA3l5Ln8nAG4S1qbMGDU8CGS88gOy4SgDsGZjPgjaVsMTwMJqxFjTw8hDmsrL9sLMmR/sff1C+DYW8vpwAvfRROXKzFQ2p0OGtmnkGsw5/R+3lOV87+eCV78JGlkOVbLTzkdoph6YUjCbf5s71v7CjlqkV59MUkpYUMsESySrgZ37UTn0wditXi98HsvF3c8/U2+uFosbuPgWS1cPOzHl34z4QBgfai932zjafW7zo1fW56mf/B+0yacJZf495fM2j4GazZU8ok2XJWvgAvlaaP1YsWctqggQDce9cd9Bs8jLyDdeo+twq2rFhOdlYmAHf96lb6Dh4eks/DY2PYtGZFoOvMLddfx+BRYynAouhzL527dmH9iuWBYmpXXj6TidPOZw9WNZ9bffTPzWX5F/MJD/e/9tfnvM3Pr7uBvti1z0P0eWsJOSN/zTXX8OCDD3LPPffQ2NjI5ZdfznPPPcfTTz/NzJkzT8YcNRqNRqPR/ICcamv9DX0z8AFlChm+cnx4peSX/bMCY0IIfjEgi0YpqVTI8JXgQwA352YGxqwWwS25mRySJrUKGa0SfMQ7bFzWo0tgLMxq5cbcDMqlgUdBoxgf3WMjA0E8QIzDxnV90igRapnKEgxGpSYEgniApMgwZvbsQplFTaNMGEzNSg4E8QBZsZGcl51CqeI8yi0mM3t2CQTxAAMT4zijcweKFbOuJcLg2j7pgSAeYHxaJ3LiopQ0vEjKpMGN/TICQTzAzJ6dSXDYKVbwVx2SQ9Lk1v6ZgeAG/F9KWAWBFrffRwUmjVJya//MQHAD8Iv+Waeuz7MyA0E8QExMDLOuuUrZ58UYjB4xPBDEAyQlJXL5zBmU2dWCtDIrTJt6TiCIB8jKzGT61HMpVTzhX24XXDbzkqDWsQMH9GfM6JHKPi+1mFx3zVVBFdEnnHUmOd27qfvc8HLzDdcFgniAy2ZcTIe4OO1zQvd5a2nVwf3rr7+e66+/nsrKSkzTJCkp9D7EGk1raIv2YLqd1WF0uzVNe6e9ePRU/Nw4ldb6ep9/w2dVyJo0P6bOG7xJrPOEpmECDT4fkfbDO/hmTZU9vRXwGCYe0yTCcoSGx7+pVMnUWIEGn4EpJZYjNsK1Hp/yBtHa9PijqfP6lH4X4J/r8TRq3V7ljJOFY98TmnRVb0HbgNqjNEwpqff6SFCcg38ewZv/5vfJpjCT5kfUHfX7aPAamFLVX37qj/ao9xT2eWMjpmlisRx+Rm1dHdFxsTxXsrtFjcuvnsWOgoJjxuvq60nJzuS5data1Cg45zzq64+tMVJXX0/OqKE8N+/TFjWWnz6Curr6Y8brGxoZdvF5PPfyv1vUeDc9m9rauqAx0zRxut2cf/O1PP2XP33v891uNy8ndj5mHh6PB7fXq/TZoX3eNoSckT+STp06/U8v7BqNRqPRnOqcCmv9w6vyiRCCLgpbrs5YiRSC+7/djsvnD9jqPT7+sHIH8cJCJ4WtVQY2bMDvvt2Oz/Tfr61yeXhsTQGpwkq0gkYWdpyGySOrCzClP+NTUu9k9vpdZGJTKlqVjZ3yRjd/31CEbNLYcaieFzbvIVPhyLJfw8aGqjrezC8NjK05UM2cHWVkmGpb2CxpY1FxBQv3VgTGviiuZP7eCrIU55FhWnk7v4xV+6sDY28VlLG+spZsxa8lMqWNFzfvYfshf4AipeSZjbspbXTTTUHDiiADG7PX76K4zgn4vwh4dE0BDT6DbIUjy1FYSBVWHl9TSKXTf0fXZ5r8bsV2rECGgkc7YSFBWHhoZX4gIHEbBvd/u/3U9fn+Azz9z2cP+zy/gBf+819mXHhBi88HmHHR+azL28Abb70TGFuzbj1vvvMeMy48X0njkgvPZ/6iL1iwaHFgbNHiJcxbsFB5HpdcOJ233vuAVWvWBsbmvPMea9atV57HjAsv4MX/vsz2HfmA3+f/ePZ59haXMOOilucRFhbG9KnnMPuZf1FcUgL4vwh4+IknaWhs1D4ndJ+3FiGbHf09DBo0KOjIwvexbt065X/8oYce4g9/+EPQWHJyMvv27Qv8/Zw5cyguLsbhcDB48GAeffRRhg0b9r261dXV/O53v+P999/n0KFDZGVl8de//pVzzjlHaV61tbXExcVxDdE4TtKdBk3r0Bn5tqW9ZDs1mvZOe/jc8CD5D/XU1NQEHYlsK07WWt+eaV7vLcAEwpXuhgLsxssiXMSH2RmcFM+KfYdw+gzOluF0Vgwat+NlGS5SIsPo1zGG5WUHwZScIyPopJjDycPNSjxkxkSQHRvJ8vKDhEnBVBlBrOLm8RtcbMJLz7goUqPCWF5+iDj8GiqVtJuLkRXgI7dDDLEOG9/sO0SSsHKOjFDaRxlIFuBiLz4GJ8YhBKw5UEOasDFZhitlxbxI5gon+6XB8JQEGrw+NlbV0R0bZxGudEfVicmnwkUNBqNSO7C/0c2O6gb6YWeUwh1o8FcU/0Q4cQvJ6NQO7KptZHedk6E4GKRwBxqgCoO5wom0CEZ37sDmqjr2Nbo5gzB6K3ZXKMPHfOEi3GZleEoCaw9UU+32Mv4U93lOt2507tKZr775lm7ZWSybP5ekpMQWn2+aJlfOuonX33qbgf1ziYmJZvk3Kzj9tEF88dlHxMTEtKjh8XiYPuNyPl+4iKGnD0YIwcrVa5g0/iw+eXcODkfL7219fT0Tpp7PqjVrGTViOA0NDazfsJHLLrmY1/79QtCJg++ioqKSsWefS35BIWeMGsGBikq2btvOr26+scVsfDO79+zhjInnUFFZyRkjR7Bz506K9hZrn5+Az5sJZa1XCuSPDLZdLhf/+te/6NOnDyNGjABgxYoVbNmyhVtuuYXHH39ceaIPPfQQ7777LosWLQqMWa1WEhP9/0O98cYbJCUlkZ2djdPpZPbs2bzzzjsUFhYGHnM0Ho+HUaNGkZSUxG9/+1u6du1KcXExMTExDBgwQGleOpBvv+hAvm3RgbxGo0Z7+Nw42YH8yVrr2zPN6/0FRJAU4m3Daky24qEOSTwW+mAPqQ0V+Ns3bcdLA5KOWOiNnagQNfZhsAMvLiTJWOilUODpSCSSUgwK8OLFn6HqiT2k/Y9EsgcfO/FhAmlY6U7LRaKOxESyCx+7m+61ZmIjC5vy8XzwVxYvxEcxPiz4TwtkElqhKQ+SfLyUYWAHumOnK9aQNFxItuNlPwbhCHKwkRKivxox2YaXSkwiEfTGHnJAUIfJVrxUYxLTpBFKuzX43/R5v+lTOPOM0Vz988uVAvBmTNPkk7nzeOf9j3B73Jw9cTw/u3RG0D3xlvD5fLzz/od89NlcAKafew4XXzAdu129XZrL5eKNt95h3sJFOOwOLrlwOuede45SEN9MXV0dL7/+Jl8u+4qY6Ggun3EJE8ePU/4yF+DgwUO89PKrfLtqFds+nq993gY+h5MQyB/JrFmzSE1N5eGHHw4af/DBBykuLubf/275bkYzDz30EB9++OFxW9wcj+YFd9GiRYwfP/64j3nuued48skn2b59e0j/Uxzv39GBfPtDB/Jtiw7kNRo12sPnxskO5I+kLdf69oxe7zWaUw+992l72sMa+b9CKGt9yF8TvPPOO1x55ZXHjP/85z/nvffeC1WOgoICOnfuTFZWFjNnzmTXrl3HfZzH4+GFF14gLi7uezPrH3/8MSNGjODWW28lOTmZfv368dhjj2EYapUcNRqNRqM51WnrtV6j0Wg0Gk3bEnIgHxERwfLly48ZX758eUhHSwCGDRvGK6+8wvz583nxxRfZt28fI0eOpKqqKvCYTz/9lOjoaMLDw5k9ezYLFy6kU6dO36m5a9cu3n33XQzDYO7cudx///389a9/5dFHH/3O57jdbmpra4P+aDQajUZzqtKWa71Go9FoNJq2J+T2c7fffjs333wza9euZfjw4YD/3ty///1vfv/734ekNWXKlMB/5+bmMmLECLp168bLL7/MnXfeCcC4cePIy8ujsrKSF198kRkzZrBy5crvrKDb3CLnhRdewGq1MnjwYMrKynjyySe/c36PP/74MUX3vgsDSRG+wL2nHtiVC20040OyEx+VGEQ1aYR6h8KDpBAvhzCJwUIPbEpFaY7EhaQAL7WYxGOhR4h34gAaMCkI3Aex0g0b9hA16po0nEiSsYZ8Jw5g+4583nznXWpr6xg39gzOPXsyVmto92MqMZru90nSsNElxDtxEsl+zKb7fZJMbCS3QqMUo+l+nyAbG4kh3vMxkezFoAwfdgTdsYV8V8jj8fDBx5/y7cpVdOzYgZ/PnEFWZmZIGk6nk7fefZ/1GzbSpXNnfn7ZDDqnpoakUVtbyxtvv8u27TvIyszg5zMvpVOnjiFpVFUd5LU5b7GraDe9cnrys0svCflYcnn5Pl598y1Ky8oY2D+XSy++kMjIyJafeAS79+zhtTlvU1lZxfChQ7hw+jSlwjZH0hY+z9uwkbff/xC3283ZEycwftzYkO7VSSn5duUqPvp0LlJKpk89h5HDh4V0r05KyRdfLuXzhYtwOBxcfP55Qb15VTAMg7nzF/Dl0q+Ijo7isksupnevnJA02sLn7eXzvK1py7Veo9FoNBpN2xPyHXmAt99+m6effppt27YB0Lt3b2677TZmzJhxwhOaOHEi3bt359lnnz3u3/fo0YNrr72W++6777h/P3bsWOx2e1ABvXnz5nHOOefgdruPu3F2u9243e7Az7W1taSlpR1zZ86JyTzhokIaZMdEsN/pwekzGEs4PRUrI9ZhMlc4qZEm3WIjKWlw4TNMJhBBhuL3KgcxmCdcODHJjo1kd50Ti4SzZbhykYl9GMwXTgwBmTER7KptJBwLU2Q4HRWDvj34+EK4sApB1+hwdtY2EissnCsjlAtE5ONlKS4ibFaSI8LYVddIorAyRYYfdyN7vHtNs//xT+6893ckJMSTEB/PrqLdjB45gnkfvEN0dPQxjz/ePZ6VuMnDQ4cwOxFWC6WNbjKxMQG1arkSyTLcbMdLUrgDIWC/00MONsYqVss1kHyBiyJ8dIkMw2WYVLm9DMDBMBxKGl4knwsnZdIgIzqcarePGq+P4YQx4DgVQI/3+6ysrGLC1Ols2LSZHt27sW//ARobG/n3s89w5c8ua3EOAHv27uWsc86jaPcecnr2YM/eYqSUvPPaf5k65WwljS1btzFh6vlUVFbSs0d3du4qIjw8nLnvv82oEcOVNL5ZsZJzLrwEp9NFt+ws8gsK6dSxIws/+YDcfn2VND77fD6X/PxqADLS09iRX0BmRjqL535MZkaGksarb8zhmptuJTIyktSUZPILCunfry+LPv2IxMTvPmF0JKH6/Hj89sE/8vhf/kZip05ERISzt7iEaeeczbuvv6L0pYJpmtzwi9t46eVXSU1JQQhBWXk511zxM/7vX/9Q+kLA6/Vyyc+v4qNP55Ke1hWXy82BigruueM2nnj4IaUvBBoaGjjnwktYtvwbsrMyOVRdzaFD1fzlsYe567ZfKv0uQvX58T43fujP8x/yjjyc3LW+vaDvyGs0px76jnzbo+/Itx0n9Y48wIwZM/j66685ePAgBw8e5Ouvv26Thd3tdrNt2zZSvydrJ6UMCrqPZtSoURQWFmI29fEDyM/PJzU19Ts3qmFhYcTGxgb9OR4rcWM4LHx7ySh2XHkWpddO4IpeXVmKi3rM4z7naJbjJjrSwcbLx7LtinGUXDOBszOT+FK48NDydyoSyVLhJi0+kvwrzmLrz8ex5+rxDE6OZ7FwYyhomEi+FC4GJcez+6rxbP35OPKvOIvM+EiWCjdSQcPbpDEpPZHiayew7YpxbLp8LLFRDpaL735/jqQBk2W4+FlOF0qvncCOK8ex4pLRmA4LK1DT2LxlK3fe+zvu/OWtlO/cwc7NeXw57xPWb9jIHx//s5JGKT7y8PDo8BxKr51A0dXjeXfKYIqFwWa8ShqF+NiOl+fG5VJ87QT2XjOBF8b1Zwc+Cpsq8LbEFrzsFT7ePvs0iq4eT8m1E3h8RC824KEUtRoP6/Bw0CJZMH0YhVeNp/S6Cdw5MJsVuKlS1Pj17x6gtLyc1V99Sf6GtZTv3M6Vl8/kult+SUlpacsCwE2/uhPDMNi6diXb1q2ifOd2Jo0fx+XXXE9dXV2Lz5dScsWsG+nUsSO7tuSxde1KSvK3MiC3L5deeS1eb8vvi8/n47KrryO3b1+Kd2xh69qV7NqSR3JSIlfMuhGV7zDr6+u5/JrrmTBuLGWF29i2bhXb1q1CSslNv7pT6XdRVl7Odbf8kp/PnEH5zu3syFvDmuVLKN+3n7t/e7+SRlv4fPGSpTz+l7/x+B8epGzndnZv28QHc15j3oJF/OPZ55U03nr3fV56+VVe/OffKSnYSnH+Fl761z/4z6uv8+bb7yppPPPcC3w6bz7vvfEKu7dtorRwG396+A/8efbTfPHlUiWNh594kjXr8vjis4/YuTmP8p07uPu2X3L3bx9g46bNShpt4fP28Hl+MjlZa71Go9FoNJoT50c9u3f33XezdOlSioqKWLlyJRdffDG1tbVcddVVNDQ08Nvf/pYVK1awZ88e1q1bx6xZsygpKeGSSy4JaFx55ZVB2fmbb76ZqqoqbrvtNvLz8/nss8947LHHuPXWW09orgaSnRjcMTCb05PiAYiy2/jbGX1wWCzsVAjWnJjsxccDQ3vQK8GfQYsLs/OPsf1wSxloufJ9HMLkgDR4fGQv0mMiAEiMCGP2mL7USZNyhWCtHINaafK3M/qQFOnv9ZgeE8ETo3pTIQ0OKnwpsRsfbin5x9h+xIf5TyPkJETz4NCe7JU+GhU0duLDZhHMPqMvUXZ/5mlwUhx3DspmJz6lTexrc94msVMnnnj4IcLC/K/lzDFncP3VV/LKG3NafD74TwX0jIvi16d1w2axIIRgenYKF3dLYadQC8IL8TI6NYHr+qRjEQKLEFzTJ42xnTtQoBjI7xQ+LshO5YJuqQghsFks3DUom5z4KPIVv1DYKXzM6pvOuK7+LG+Y1cojw3PoFG5X0vB6vcx5933u+MUtnH7aIACioqJ46s+PY7fbeevd91vUOHCggs8XLuKBe39Nr5yeAMTFxfHP2X+hrq6Ojz6d26LG1m3bWb9hI4//8fekp/m/5U1M7MRTf3qc0rIyliw79u7u0Sxb/jV7i0uY/afHAj1i09PSeOKPD7Fh02Y2b9naosbHn82jtraWf87+C/Hx8QDk9OzBg/f9hvmLvmD//gMtarz17vtYrVaefvIJoqKiABg8aCB3/vJW5rz7/vd+MdlMW/j81TffonevHH5z1+3YbDaEEJw/bSqXXHA+r775lpLGK2/MYewZo5h19ZVYLBYsFgvXXnUFZ40dE9I8Ljr/PC6cfp7f5zYbv77jV/Tp3YtX3nhTWWPWVVdw1pljAf+XsY/94fckJyUpvZa28Hl7+TzXaDQajUZzaqIUyHfo0IHKykpl0fT0dPbs2dPi40pKSrjsssvIycnhwgsvxOFwsGLFCjIyMrBarWzfvp2LLrqInj17MnXqVCoqKvjqq6/o2/fwkdi9e/dSXl4e+DktLY0FCxawevVq+vfvz69+9Stuu+027r33XuX5Hw8T/13ILtHBRX5i7DZiHDal7IuneY7REUHjKZFh2IRQ1PA/putRGl2j/PNyK2g0P6b5Oc00vzYVDQ8Sq/DPPWgeTfPyHO9Jx5lHtN1GrCP4+GiX6HAMUAp/q2tqSElOOqbVYNcunamuqVFQ8M+1a3T4MUd6u8ZE4BFqGTGvgPSYY+9Mp8VE4FXU8AhIiwl+T4QQpMVEKHkD/HUPjn5f7VYLKRFhau+J243L5aJr585B4zExMcTFxir9TmubMu5pXboGjackJ2O325U0mh+T1qVL0HjXpp9D0Tj6tXTt4v/5UHW1kobVaiUlOfm486hRKIxZXVNDbEzMMSd9unbpjMfjweVyKWmcqM+ra2rokpp6rM+7dFb6XTRrHP2etGYeR2sIIejaOTSNrkdp2O12UpKTlDTawuft5fO8LTlZa71Go9FoNJq2R+kSX3V1NfPmzSMuLk5JtKqqSqnd25w5353BCQ8P5/33W86KLFmy5JixESNGsGLFihafGwp2BInCymvbS/hZThcsTZvhRcWVVLg8DCGiBQWIQRAjLLy8vZgJaZ0CG+o388vwSUmqwt30jlgJE4JXt5cwYHSfwPir20uwAMkKGslYsQCv7ijl16d1C9IIE4JOsmWNFKwYEt7IL+Wq3v6MqZSSV7aXECMsxMqW7xqmYmWd28n8vRWcneEvXmhKyavbS+gkrDgU9rBnjBzB8y/9h7X/z955h0VxdXH4nd2lg4WigL1hw957jbH33ns3xWiMxhhN1BQ1JiYxMUZj7733rmBHQVFQQKUqvS1b5/sDWUXRnVWTD3Xe5+F59Lr3552dw71z5t5zzlU/ajxOlqXT6Vi7cTON6tczL/B4HKej4glNTqdEnkxnPE2nZ1NQJAWM0g6tFBAV7AmNIVatxdUuM4QjLkPL7pAYiokSNYwCm4OjmFHLC8fHLzfCktM5GRFH9Rzi23O8FlHJ2tsRTKhSAmtl5v979VESAQmpNMN8pmlHR0eqVPJm9fqN9O/TyxTzfPjocaJjYmhUv75ZjeLFilLI05MVa9bxQYtmJjtft3EzOp1O0n2pUskbJycnVq5dz0+VK5naV65dj1KppF6dWmY16tauhVKpZOXa9Uz57JNsGo6OjlSrUtmsRqP69TAYDKzdsInBA/oBmXa+cu06PD08KFmiuASN+nzz3Y8cOHSENh9+AGTGmq9at4FKFStIinV+E3beqH49pn79DaFhYaaEbmlpaWzevoPGDczf1yyNpStWEhsbZ0o6GBcXz+79Bxg6oL9kjS07djLzyy9Msf1h9+5x4vQZZs+QFmrQqH491m3azMfjRptCpq76XeOafwATJ5g/ffUm7Dy3zOdvkn9rrZeRkZGRkZF580hKdmdJRuMs7ty5h063SgABAABJREFUQ8mSJV9pUP9vXpT8Jgw9h1DT0CM/vbwKEZqczuLrYTgbBdqJdpKSkd16nNztw6JudCrpjn9cMn8H3KeoqKSlhJcBAFfRcAEt3Ut50LKoK75RCay6FU55rGgowVkDOEsGN9AxoFwh6ns4c/RBLJvvRFELa6pjY14AOIqaMMHA8IpFqeKah10h0ey//4jG2FBeguMpIrJPUBOnEBlTqTgl89qzKSiS01HxtMKW4jkkEHw2QYlGo6Fu05bce/CAsSOG4+FekJVr1+N33Z9j+3bRMAcn59mEHBpEdgjpWNuoGFelOA5WKpYG3CM0KZ1Ooh3OEh6m0zCyXVDj4mDNmErFEYA//O8Rm5ZBZ9EeRwmHXxIwsENQUyKvPSO8i5Gm0/P79TA0GXq6iPbYSLCvaAzsIZ3KrnkYVL4ID9UaFl8Pw0on0lG0Q/WMRk4JX3bv20+nnn1p3LA+vbt3IyQ0jMVLl1GzelWO7dstaT5YvnI1w8ZOoO2HrejUvi3XA26w9J+VdGrflk2rV5jtD/DdvJ+YNvMbenbrwgfNm+Fz/gIr1qxj7Mhh/LpgniSNTyZ/waI/ljCoXx8a1KvLkeMn2LhlG7O/ns6Xn0+SpNFn0DC27tzFiCGDqFq5Ejv37GPvgYMs/X0Rwwc/X2f7WYxGIx+078z5S5cZM3wopUqWYOPWbZw8fZbtG9bQqX07sxqvYufPkpiYSI2GTUlPVzNu1HAcHRxYumIV9+4/4PyJI1SsUN6sRkRkJNXrN8HBwZ7Rw4YiCAJ/LltOSkoql8+eoEjhwmY1bgbeok7TlhQtUpgRgweSmpbG4r+WYWNjzZWzp8ifP59ZjXO+52nWpgOVvSsyqF8fYh4+ZPHSZRT29OT8yaOSyqNZauc5JfL5r+fzfzvZ3fu21oOc7E5G5n1ETnb35pGT3b05LFnrXylr/bvOyxb2++i5KmiJFg3YCQKlRRW1sLGo5NoddFwXdDwSDTgICsqKKqpjLbnkmohIIDpuCHriRQN5BAXlRSuqYCW51JmIyHV03BR0JItG8gsKvEUrylugYUDkKlpuC3pSRSOugpIqohWlJWbwh8ykeZfQECzoUYsiBQUl1UTrF2Z8zmnyjY9PYNrMb1i7cTNpaWk0blifb6ZPo3HDBjlq5DTZpGHkAhpC0GMAiqCiJtYWlX5Leqxx73FQQDEybSOfBakoYjFwCS330aMESqCiNjaSXgRkEYWey4KWSNGAlSBQSszUsM3hvr5oMdt/8DCzvvuB8xcvkT9/Pgb368s3X02TnB0dYMPmrXw3/yeuB9ygYIECjBw6iOlTJksuuSaKIkv/WcmCRb8RFHyHIoULM2H0SD77eLxkh8NoNPLTot/59c8l3H8QTpnSpfjso/GMHDpYcrk0rVbL3HkLWLJsBdExMVSqWIGpkybSp2d3Sf0hc+d7xrdzWbF2HfHxCdSuWYMZUz+nXesPJWtYauc5EREZydQZs9i8fSdarZYPW7Zg9owvLSr9FnznLlO/nsWuvfsB6NiuDXNnzsCrTGnJGlf9rjH9mznZys99983Xzx2Xfxlnzvnw1bdzOHn6LA4ODvTt2Z25M2fg4uIsWcMSO3/RQ8p/OZ//11nr3xQzZ858rsRrwYIFiY6ONv37hg0bePDgAdbW1tSoUYM5c+ZQp06dl+omJiby5Zdfsm3bNhISEihRogQLFiygbdu2kscmO/IyMu8fsiP/5pEd+TeH7Mi/JlIW9qzM7pbUCH8WIyKK13xwyC0aIuJrfRdSv8+XTb6iKCKKolkn72WTzZu4r2+ThrnFzGg0IgiCRTXCn8VgMFhc6zy3ahiNxlfatcxCqo2+Lxpvwr7+Kw1zDyn/xVz8NjvyW7ZsyVYWVqlU4uaWmYRy3bp1FChQgJIlS6JWq1m4cCGbN2/mzp07ps88i1arpUGDBhQoUIBp06ZRuHBhHjx4gJOTE1WqVJE8NtmRl5F5/5Ad+TeP7Mi/OSxZ66UVupV5jtdxsLJ43Ye+3KTxut/Hm/g+X/dh/o2N4x3SeB0nLYvXdZ5zk8brfh9vxEbfIY03YV+5RiOXzMW5FZVKhbu7e47/1rdv32x//+mnn1i2bBnXr1+nRYsWOfZZvnw58fHxnDt3zpQEslixYm920DIyMjIyMrmY/2v5ORkZGRkZGZl3n+DgYDw9PSlRogS9e/cmJCQkx89ptVr++usv8ubN+9Kd9V27dlGvXj3GjRtHwYIF8fb2Zu7cuWaT72k0GpKTk7P9yMjIyMjIvI3IjryMjIyMjIzMv0adOnVYtWoVBw8eZOnSpURHR1O/fn3i4uJMn9mzZw+Ojo7Y2tqycOFCDh8+jKur6ws1Q0JC2LJlCwaDgX379jF9+nQWLFjAnDlzXjqW7777jrx585p+ihR5veOgKRiJRE8axlfWSHqsoX4NjQQMRKF/5ZKFIiJxjzV0r6HxCAPRGNC/ooYRkYcYiMGA8RU1DIhEY+ARBlOImaXoEIlGT9xraGgQiUJPAq9e2UH92DaSXsM20h5rpLyGxrtm52fO+ZCWlvZKGkajkctX/Tjne15S+dic0Ov1XLh0mfMXL6HXSym2/DwajQaf8xe4fNUPo/HVvtO0tDTO+vhy7bo/rxppnZSUxOmz52Q7f8ybsHNLkGPkc0COmcu9vIm4JjmO5wlynJiMjDRyw7zxtsbIP0taWhqlSpXi888/Z+LEiaa2qKgoYmNjWbp0KceOHeP8+fMUKFAgRw0vLy8yMjIIDQ01hc389NNPzJs3j6ioqBf+3xqNBo1GY/p7cnIyRYoUoShKmmGXY1LQHHUQOUkGoY+TmyqA0ljR0ILkt2kYOSFkEC5mPgCrgLJYUQ8byckSkx5rRD/WsBYEKopW1MJacnhVLAZOChpiH2vYCALVRGuqSCx7ChCJntOChkQx8+HVXhCoJdpQzoLkt2Ho8FEZSNbrAHBSWVFPr6SEBRq30XFR0JL2eBz5BAUNRRsKWRBJeh0tVwUtGY8fj10FJY1FG8nJb0VELqElQNChfazhLihpItpKTn5rQMQXDbfQkeXmFRZUNBVtcJCooUPkjKDhDnqMj8dRXGFNE6O1ZXau0BJq1AKgEIRMOxetLbLzkwodDx5rqBQKyhqVltu5Uke0IVPDWqGkolFpuZ2rdMQ+tq88efIw44vJfPbxBEn9AU6ePsOwsRO4GxIKgKurCz9+O4shA6WVXwXYuWcv4yd+TnhEBACFPD357acf6dyhvWSNlWvWMfnLGTyKjQWgVMkSLP3tF5o1aSxZY+GvvzPrux9ISso8lVSxfHlWLv3DVOLWHKIo8vXsuSxY9Dvp6ekAuCutaWKwstDOtdwS9Ogf/84WVlrT1GD139t5LpjPs7BkrX+lHfm7d+8yffp0+vTpw8OHDwE4cOAAN27ceBU5GRkZGRkZmVzGv7XWOzg4UKlSJYKDg7O1lS5dmrp167Js2TJUKhXLli17oYaHhwdeXl7Zcl+UL1+e6OhotFrtC/vZ2NiQJ0+ebD8AyVZwTJC+u3ZMyCDBGv5qVpnrfRqzsHFFHigNnEFjvjOZzt4hIQO9rYo1rapxrU9jZtUty21BzwWJGnpE9gtqHJxs2NqmBld7N2Zi9ZL4oeU6OkkaGY81Cjnbs7dDbS71asQw76L4oiFIokYyRg4IGVRyz8uRznXx6dGAzmU8OEkGD5C22/gIA4cFDY1aNOPs0YOcO3aIph+04Iig4ZHEnb5w9Jwgg46l3fHp0YCjnetS2T0fB4UMyTt9wejwQcPgikW52LMhezvUprCLA/sFteQdNn90XEHLp9VKcrV3Y7a1rYmjkw37BbXkkwoX0RAo6JlZtyzX+jRmbatqGOyUHBQyJJ8QOCNoeGCt4Od533Pz8nn++fN3kpzsOKZ48e/HsxxTaElwtGXZ4l+5efk8ixb8SLiNgjOCNA0RkUNKLXrXfKxfsYwbl3z59uuvuK00WmbnSi2ORT3ZsXEt/hfOMemzT/ATdJbZuVJL4fJlObBjK34+pxnYtxeTpn3F6nUbJGmEhoXRtmtPChfy5Pj+3Vw8fZzWLVswdMx4Dh4+KknjylU/uvcbRNXK3iY7r1GtCt37DeLSlauSNA4fPc7gUWNp1aI5F08f58SBPRQpXIh23XqZXjCYY+2GTUz84kv69erJ1XOnOLBjK7a2NrTq2IXY2DjzAmS+CPj2+3l8PHY0/hfOsXPTOpyKFWK/UmuZnSsNfPP1dG5c8mXDyuUYXfNzUKn9b+08F8znr4rFye5OnjxJmzZtaNCgAadOnWLOnDkUKFCA69ev8/fff7Nly5Z/Y5wyMjIyMjIy/xH/5lqv0WgIDAykUaNGL/yMKIrZds6fpUGDBqxbty5bJYmgoCA8PDwkl7h8mp8aezP06DXiMOBiZuc1HgP3RT3rmlajRxlPAMo7OyGK8OnpG9TG2uxuUiQGHooGjn5Yi8aFXACo4OxEmt7A/Mt3qSmKZneCQtGTJBo53a4m5Z2dAPB2KccjtZaNgRFUFs2Xkw1Ch06APR1q4+5gC8Avjb25l6zmwv04vETzu+GB6LBXKdnVvjaO1pmPlStaViUoIQ3/2DSKiOYfNQPQUaSQJzs2rUOlyvz8tg1r8PKuRsCDaJpJ2A33R0cNtzys/KCqKRHnrg61KLHiKDe1Wupha34cgo42Rd34tYm3qa2Kax5KrDxKkKg3e0pBRCRA0DGkXBFm1ysHgLeLE175HPBed5IQ9HiZOWGgQyRQ0DO5ekmm1Mgs61nB2QlPB1uabfchAgOFzTy+p2HkDnp+nvM9E8aMAqB8ubI4OjrSo/8g4lBJs3Ojlo2/LaFnty4mDVEU+eizKdTG/K5pJAYeGnScWLWcJo0aZl5L+XKkpafx47yF1DRKtHODDp8tGylfriwAcypW4FFsLOtXr6Oy3nzVpCw7379jK+7uBQH4dcE87t1/wPxffmVA394v7Q+wZNkKbGys2bNlo6lE6aq/lxB8N4Sffv2dDz/IOTHn0yz6YwlFChdi+4a1Jjvfum415arVYtHiP1n19xKzGj/9+ju1a9Zg9bIlJjvfs2UjxcpX4s+/lzNv7rdmNRYs+o32bT7k94XzTW1VK1eiaDlvVqxZx6RPXn5KwWg08tOvixk2aABzZ80AwLtiBcqWKUO5arUIQSnJzm8pjEyZ+AlTJ2eezKpQvhyeHu40btWWCFT/nZ3ngvn8VbF4R/6LL75g9uzZHD58ONti2axZM3x8fN7o4GRkZGRkZGT+e97kWj9p0iROnjxJaGgo58+fp3v37iQnJzNo0CDS0tKYNm0avr6+3Lt3jytXrjB8+HDCw8Pp0aOHSWPgwIFMnTrV9PcxY8YQFxfHxx9/TFBQEHv37mXu3LmMGzfula636eOHr0QJu65Zn2leJHsMf8siroggafc3ASMqQaCRp3O29haFXdGKIqkSx+FuZ21y4p/WSBWNSNmPSsBI+fyOJic+i5ZFXYkXpe2EJ2Ckrkd+kxMPmVUtWhZ1JVmQtoudohJo3qypybmBzEoHzZs3JUkl7QE4WWGkRRG3bNU0HKxU1Pd0lnRfAeLFTI2nKWhvg7ezkyQNHZAiGmle2CVbe9n8jnja20jSSEdEK4q0KJzdvhp45MdKIZAgQSMZI0ZRpEXTJtnaWzbL/Lsldv6sxgfNmyEiSrdzpZLGDRs8M46maI0G6Xbu5mZy4p/WSNXrJNt5hbJlTU58Fh80b8atoOAX9MpO4O3b1K1Vy+TEQ6adt2jahMDbQZI0bgUF07RRw+fsvGmjhhZoBNG8SePsdu7gQL3atbgVJE0j8HbQc/e1YMECVKnkLUkjNTWViMjI5zTKepXBs2BByXauMRpMNplFw/r1sFKp/nM7/3/P56+KxTvy/v7+rFu37rl2Nze3bIlrZGT+DXJDnKqMjIzMu86bXOvDw8Pp06cPsbGxuLm5UbduXXx9fSlWrBgZGRncunWLlStXEhsbi4uLC7Vq1eL06dNUrFjRpHH//v1sZQKLFCnCoUOH+PTTT6lcuTKFChXi448/ZsqUKa90vRdjEgFwkrC/kfWZ89EJtC3+xDHwiU6QrJEHBXpR5PKjJGoWyGdq941OQAXYSxxHjDqDsOR0iuexf6IRk4idIGAl4WRqHgT8E9NIyNCR3/bJDppPVAJ5BSVSTrc6IXD5YSIagwGbp0IdzkUl4ChKc8Lt9SLnzvlmO2FhNBo5d84XR4O0I7YOogKfqIRsbVqDkQvRiRSUuG+VV1BwPjoBqpQwtSVqdNxKSMVbwiOzFZn5Ac7HJNLbq5Cp/X6Kmuh0DWWwMathh4AK8I1OpOlTzvzV2GR0RpE8Eq7F8fFnfC9cpEL5cqZ2n/MXAZh7ah+1alR/qcblq34cbtgU34sXadf6Q1P7Od/zAPwaeJ5iRYu+VGPfgUO069aTy1f9qFm9WrZx2NjY8FdoIHnz5n2pxvKVqxk+7iPC7t2j+FMlJn3OX8DZOT9/h90xW172u3k/MfvH+SQkJJI/f76nruUCJYpLK1tZolgxNmzZhkajwcbmyX30OX+BEsVf/j1kUbxYUXwvXnrOzn0vXKJihXJmej+tcTFbm1ar5dIVP3p07STtWooXw/fipWxtiYmJ3Lx1m07t25rt7+joiKurC74XLtKnZ3dT+/0HD4h+9IhvFv/MsEEDX6qRnJzM9uJl8LlwMVts/1W/a+j0eqZuWUP7Nq1fqnH/wQN2lav0Qjt/m+bzV8Vi5Xz58uWYSObq1asUKlQohx4yMjIyMjIybxNvcq3fsGEDkZGRaLVaIiIi2Lp1KxUqVADA1taWbdu2ERERgUajITIykp07d1KrVq1sGidOnGDFihXZ2urVq4evry8ZGRncvXuXadOmmX2gfxEfnwrAXVDiJuGxyBUFHoKS0cf92RsWQ0KGji13ovj8zE1KoJL04FcYJfkFBQMOXuV4eCzxGVpWBD5g9sVgymCFjYRjmKVQYScI9Nx/Gd/oBB6pNfx6LZTfr4dRXrRCIUHDCysMRpEe+y9x9VES0WkZzL0UzKY7UZSXcCQeoAJWJGTo6HfwKoHxKTxIUfP52ZucioyngoSj+QAVUXH77l2GjRnP3ZBQQkLDGD52AoHBwVSQOg5RxemoeCaducmDFDWB8Sn0O3iFuAwt5SUmzCsvqth8J4rZF4OJSsvA71ESPfZfxmAUKStBQ0CgnGjFH/73WHQtlEdqDeejE+i5/zK2gkBJCRrWCJTBirmXgvnn5gPiMrScCI+l/8Er5BMUFJEQZuCEghIKaz774ks2bd1OQkIi+w4cYtRHn1K7Zo1sTvWLqF61CvXq1Gb0RxPZs/8ACQmJbN62g8nTZ9CxXRuzTjxAq5bNKVO6FP2HjeTYiZPExyfwz6o1zP5xPgP79jbrxAP07NYFVxcXevQfjO+Fizx6FMuixX/y25KljB0xTNLv/OD+fREEge79BnLV7xrR0THM/mEeG7ZsZfyoEWb7A4waNoT4hAT6DB5G4K3bPAgPZ9LU6Rw/dZoJo0dJ0hg3cjiBt24z/HHCvJDQMEaM+4gbgYGMGzlcksaE0SM5ceoME6dM40F4OIG3btNn8DBi4+IYNXSIZI2NW7bxzXc/EBUVjd+163TvNwjI/K7MoVAoGDtiGIuXLuOX3//g0aNYzl+8RI/+g3F2zk/Prl3MauTJk4fB/fsy58cFLF+5mri4eI6fPEW/YSMpVbIErT9oaVajaJEidO7QjsnTZ2Sz8xFjJ+CutH7t+bz4fzifvyoWZ63//PPP8fHxYfPmzXh5eXHlyhViYmIYOHAgAwcO5Ouvv/63xvqfIWetl3lfkLPWy8hIIzecBvovs9a/D2s9PFnvC6CgFXaSMyWnYeSokEHUU8fPiwgqmou2kjMlJ2HkiJBhyhYPmc55E2wlx1M+wsAxIcOULV4gM1NyQwsyJUeg54SgIfWxhgKohBV1sJGcETwUHacFDerHj5RWgkB10YqqEnags7iFFl+FHo3xcQZ+hZK6RhXlLcie74eWK2hNJfTsBIGGoo0kBxoyY9wvoOU6WtNhWEdBQRPRxmy8bhZGRM48zjif9YCdT1DQXLSVnPle9ziL9t2nkgW6CEpaWpD5XoPIMYWW+8Ynh8/r1KrJ1nWrKOTpKUkjMiqK7v0G4XP+gqntg+bN2LByOc7O+SVpBN+5S9c+Awi4edPU1r1LJ1b+9Qf29vYv6fmEK1f96DFgMCGhYUDmkfZhgwaw+OcFWFlJu7fHT56i39CRREVHA5lH2j8dP5YfZs/Kdkz9ZWzftZvh4z4iPj5zt9bW1paZ075gymefSOoPsGzlKj6d8iUpKSlA5u72T9/PYcSQQZI15i1cxIzZc03l75yd8/PXrz/TrbO0HXlRFJk6YxYLFv1mKn/nXrAga5b9RYtnjrq/CL1ez9hPPmPZytWm8nclihdj85qVkjPfp6enM3jUWDZv22Fqq1i+PNvWr8arTGlJGgkJifQZPIyDR54kHHRXWtPSgsz3uWU+z8KStd5iR16n0zF48GA2bNiAKIqoVCoMBgN9+/ZlxYoVr/w2PDchO/Iy7wuyIy8jI433zZF/H9Z6eLLeD8YBGwsPKYqIxGIkGSP5UJhNqvQijRgMpCHiglKyk/Y0xsd10zMQcUMpaQfpWQyIRGJAh0hBlJIfgJ9G/1jDgIgHKskPwE+jfawB4InylZ7BMh7Xb1cgUAglqlfQSMdINAasEPBEaXH5KMisSf0IAzYIeKCUdELiWRIxEocBBwQKopT8YuVp4jCQiJG5p/ZRs3o1yU5rFqIocvmqH6Fh9yjnVYZK3hXNd8pB45zveSKjoqlSyVuyk/Y0BoOB02fPERsXT60a1SSdCHgWnU7H8ZOnSUlNoX6dOnh4uFusoVarOX7yNBqthsYNGuDi4my+0zOkpKRw/NRpAJo1boSTk5OZHs8TH5/AyTNnsLa2pnmTxtjZ2VmsER0dw1lfX5wcnWjauOErJQq9d/8+Fy9fxcU5P40bNniltSEo+A7X/APw9HCnft06FtsogH/ADW4FBbN+wFjcUFj8u5Jb5nP4lx35LO7evcvVq1cxGo1Uq1aNMmXKvNJgcyOyIy/zviA78jIy0njfHPks3uW1HuT1Xub9QV7vZd4HcsNa/bpYstZbnOwui1KlSlGqVKlX7S4jIyMjIyOTy5HXehkZGRkZmdyJJEd+4sSJkgV/+umnVx6MjIyMjIyMzP8Hea2XkZGRkZF5e5DkyF+9ejXb3y9fvozBYKBs2cyajkFBQSiVSmrUqPHmR5jLiMGAH1oeCUZsESgtKqmEtUXxU+HouS7oiMeIPQJeooqKWFkUzxGGDn9BRxIijghUEK0og0qyhohIMHoCBR0piORFwFu0ooTEhDBZGjfRcVvQk46IMwoqi1aSE8JAZlyeP1qCBQMaRNxEBVWxpqAFsSk6RPzQEiro0QLuooJqWFsU36JB5Aoa7gkGDICnqKA6NuS1IL4lDSNX0BIuZMb3FRaVVMfaoljDZIxcRkOkYEQJFBOVVMPGoljDeAxcQUu0YMQaKCGqqIq1Rck2zl+8xNx5C/A5fxEXF2cG9+vLpxPGWhQ/dfT4SX746WeuXr+Op7s7I4cOZsyIYdlKSJlj5569LFj0G4G3gyhRrBjjR41gQN/ekuOnRFFkzfqN/LZkKSFhYZTz8mLihLF06dhB8hiMRiN//r2cv5avICIqiqqVKjFl4ie0bN5UsoZOp2Phr4v5Z81a4uLiqVu7JtMmf0bd2rXMd35Meno6P/z0M2s3biYlJZWmjRsy/fNJFsUrJiQkMnfeAjZv34FGo6X1By2YPmUypUqWMN/5MVFR0cz+cT479+wDoGO7NkyfMglPDw/JGiGhYXz7/Y8cOHwUa2srenTpzLTJn0lOngQQcOMms3+cz/GTp3FycqRvz+5MmfgJDg4OkjXehJ3nhvn8TSGv9TIyMjIyMm8Pkp6ojx8/bvrp0KEDTZs2JTw8nCtXrnDlyhUePHhAs2bNaNeu3b893v8rkejZTTp2+Wz5rGYp2ni5c0nQcZQMRCnFVoEQdOxDjZuLPZNrlaZxCTfOoeEMGsnjuImWg2RQyj0vU2qXpnpRZ46TwWW05js/5gpajpNBlSLOTKldmtIeeTlEBjcs0DiDhrNoaFTCjcm1SlPA1YF9qAlBJ6m/iMgxMrgk6GhTxp3PapbCPr8tu0kn4qlMrS/DiMhBQc0NhY6u5QvxSY2SGJ2s2CWoicVgXoDMFwF7BTUhKiP9vIswtloJku2U7BLSSTblrX05aozsFtRE28CwKsUYVqUY0TawW1CjlqiRgpGdQjrJdkrGVitBf++ihKiM7BXUT+W+fTlxGNgpqDE4WfFxjZJ0K1+Ymwo9BwQ1RokaJ0+fodEHbQgJvce4UcOpXaM607+ZTe9BQ5GaUmPbzl180KEziUlJfDRmFGW9yjDhs88Z9+kkSf0Bliz7h869+qFUKvlk3BgKFnBj0MgxzJr7vWSNb7//kYEjRuPq4sIn48ZgpVLRtc8A/li6TLLGhM8+Z/zEyZQpXYqPxowiOSWFVh27sGX7Tkn9RVGkz+BhfDnrW2pVr8a4UcMJu3efxq3acvzkKUkaer2etl178OPCRTRv0phRwwZzxe8a9Zq3wu/adUkaaWlpNG3djr/+WUmHtq0Z3L8vh4+doG6zloSGhUnSiI2No36LVmzatp3e3bvSu3tXNm/fQf3mrXj0KFaSRti9e9Rt2pLDx04wuH9fOrVvy9IVq2jauh2pqamSNK77B1CveSsuXbnKyKGDaNG0CfN/+Y02XbqbMvCa403YeW6Zz98U8lovIyMjIyPz9mBxsrtChQpx6NAhKlbMvgsUEBBAq1atiIyMfKMD/H/wouQ3u4R0Crs5cqJrfayVme9ANgdH0vfQVTpih4eZnWgRkU1COvWLurK9XU0Uj3cVf7seyqenb9ILB7MZDvWIrBPS6Fm2EEubVzbtTM7wvc28y3foiwN2ZjTUGFlHGp9VL8XseuUyxyaKjDruz4Zb4fQVHcxmeU3CyAbSWNCwAh9VydzNM4oi3fZd4sy9WHqK9mZ3k6LRsxM1a1pVo1eZzFIoOoOR5tt9CHuYQifRfFmSEHQcJoPDnerQtLArAGk6PbU2nkGXpOFDzGfxvIGWc2i41LsRlVwyk0rEZWipvO4kzmqRJtia1biIhkClHv++TSiWJ3PcD1LUeK87QTm9iloSSvCcIoNYW4HrfZvgape5IxgQl0LNjaeoK9rgLaEEzyHUKPJYc6lXIxytM+3xVEQcLXb48gG2z5XgySn5Tf3mrRBFkZMH95p2Jjdt3U6vgUM4dWgfjRrUf+kYjEYjXlVqUL6sFzs3rTftwP/6xxI+mjSFW1cvUtbr5Qmz1Go1hb0q0KldW5b98ZvJzqfPms28nxfx4PYNChRwe6lGbGwchb0qMHHCOObOmgFk2vmIcR+xbdduIoIDzWZ5Db5zF68qNfj5x+/4eNwY0/V16d2PgJuBBF+/YvaEwVkfXxq2bM36Fcvo3aMbkLlD37R1ewwGA74njry0P2S+GOnWdyDH9u2iWZPGQKZjXrNRM7xKl2LnpvVmNf5YuozxEyfj53PatIsfFxdPpdr1ad/mQ/767RezGjPnfMf8X37jxiUfU8bgB+HhVKhRl0/Hj+Gbr740qzH6o0/ZuWcf/hfO4erqAmTurlet14hf5n3POAk1fbv07sfNW7e5fOYEjo6OQKZj3rR1ezavWUn3LuZL8Fhq588m0Pl/zOf/ZbK792GtBznZncz7g5zsTuZ94H1LdmdxXvzk5GRiYmKea3/48KGpJuK7iA6RKNHAiIrFTE48QLfSHjjbWBEuYfc3BZFE0cho72Kmhz6A4RWKohIESbvQsRhRiyJjKhXPdrx4TKVi6IEoCeOIxoAeGF2pmKlNEATGVCqGWhR5JEEjAj0KYGTFJ+U/FILAaO9iJIpGkiXs/oZjIL+1ih6lnxzJtVIqGOFdjGjRgFaCRgQGvPLam5x4AAcrFUMqFCFCkLYjH4GBhp7OJicewMXWmj5ehYhWSNOIEgx0LOlucuIBijjZ0bGEO1ESxxGtMNLby9PkxAN4uzjR2NOFCImnCyIEA0MqFDE58QCNC7lQLp+DJBtNS0vD5/wFRgwemO14cfcunXBzdeXI8RNmNcLu3eduSChjhmc/Rj9iyCBUKhVHT5w0q+F33Z/4+ATGjRqRzc7HjRyOVqvl9LlzZjXO+Pig0WgYO3KYqU0QBMaNHE5CQiKXr/qZ1Th64iQKhYJRw4aY2hQKBWOGDyMkNMxU0/ZlHDl+AhcXZ3p262Jqs7KyYuSQQZy/eEnSvHnk+EnKlytrcuIBHBwcGNwvc1ddCkeOn6Bxw/rZjuK7uDjTu3tXDh87Lknj8LETdGjTOlvZnyKFC9OxbRuLxtGrWxeTEw/gXbECTRs1lDyOI8dPMrhfX5MTD9CkUUMqli8vSeNN2Hlumc//Ld7XtV5GRkZGRuZtwWJHvkuXLgwZMoQtW7YQHh5OeHg4W7ZsYdiwYXTt2vXfGGOuQPH4J1GT/dh4ht5Iht4gKSo8K2I7XpP9yGSyVo9eFCXF2Wf9P8+OIz5D9/jfpWhkfibhGY0sTSkaSgSMQJI2+8NqgknDPCogw2BErc/+sBqfoTV931I0krR6DMbsTn+CRic5Ul/Jk+/vWQ2puQ+UQJz6+aOwcRlayZH6SvH5e2KphhXCcxoGo0iSVi9JQ6VSoVKpSEhMzNaekZGBOiMDO1vzJxzsbDNPMMQnJGRrT05OQa/Xm/5dikZCQvZxZGlKG4ddjhpZ12Yvoeaqna0tRqORpKTkHDXs7KRcix1qdQZqtTpbe3xCAkqlEisr83kp7GxtSUpKxmDI/ruSkJgoaQxZ43j2u8jSsLc3f/olaxzP3lfTOCTcV9M4nrEvyPw+pNzXrHE8q2EwGEhKTpY0jjdh57llPv+3eF/XehkZGRkZmbcFix35P//8k3bt2tG/f3+KFStGsWLF6NevH23atGHx4sX/xhhzBUoESqBioV8IocnpQKaDNOtCEGqD8bkjyznhgAJPQcnci3eITssAQGsw8sW5QFRAcQmupwsKnAUFM3xvmx7+0nUGpvkEYi8IeEpw1zxR4iAomHruFmm6TEc8UaNjhu9tnAUlrhLMojgqrBCYcjYQrSEzBjwmXcOci8F4CkpJCd5KYkWGwcjM80EmRzwsOZ2FV0MojkrSQ2wprIhRa1lw9a4prjUgLoW//O9RQpTmypfGioD4FFYEPjBpnIuKZ2NQBCWM0lzokqKKo+Gx7Al9soO1LyyGIw9iJY+jhKhkU3AkZyLjgcxj4KtuhXM9LoXSEl9LlBCVLA24z/XYZJPGQr8QotI1lJZgozY2NnTp2J6ff//TFDdtMBj4evZ3pKWl0aNrZ7MaHh7uNG5Yn7nzfyI6OvP70Gq1fD59Bra2tnRs19asRpXKlSjrVYYZs+eS+NjZSk9P54sZM3F1daF508YvFwCaNm5IATc3vpgxi7S0NAASExOZMfs7vMqUpmqVymY1OrZri52dHZO//AqtNtNhi4l5yJwfF9Cwfj0KeXqa1ejRtRNqtZoZ3841OeJh9+6x8Lc/6NyhHbYSHM9e3bsSGRXFvIWLntj5jZv89c8KenfvZrY/QO8eXbnmH8A/q9Y8sXPf82zYso3e3aU5Zr17dOPwsePs3rff1Lb3wEEOHD5iChuQMo6NW7dz5pwPkGmjK9es4+q16/TuIXUcXVm6YiXX/QNMGgt++Y3wiAhJ43gTdp5b5vN/i/d1rZeRkZGRkXlbsDhGPou0tDTu3s10nkqXLm1RpuDczoti5lLJTDyWgkidgvkIS04nMl1DXWyoIiF+GSABA3uFDHSCSO2C+biVkEpcho6m2OIlMWN8NAYOCGqUSoEabvm4HptMmk5PS+woJtHhu4+ew6hxsFJR2TUPlx8lYjCItBZtcZeoEYSOk2SQ38aK8s6OXIxJRCVCW9EOZ4kPoNfR4oMGT3sbiuex53xMIo4ItBPtcJL4nuk8GvzQUtzRjgL2Nlx8mIiLoKSdaCcp27uIyCk03EKHV14HHK2UXIlNxkNQ0ka0k5Tt3YDIETIIQ4+3c+Zx34D4VIqjoiW2knbndIgcENREigaqueYhTWcgKCmNsqhogq2kDNYZjxP3xYkGahXIx0O1hrAUNVWwpm4Ocfo5xcw9CA+nyYfteBAeQb06tQi794AH4eHMn/stn308wewYAG4G3qJZmw4kJSdTt3ZNbt0O5lFsLP/8+TsD+/WRpOFz/gKtO3fHaDRSs3pVrvkHkJ6uZuu6VbRr/aEkjf0HD9OlT3/s7e2oUsmbS1f8EASB/ds306BeXUkaa9ZvZPCosbg4O1O+nBfnL17GydGR4/t3U7FCeUkaP/+2mE+nTKNI4cIUL1YEn/MXKeTpwalD+yhaRFo819QZs/h+wUJKlSxBATc3fC9cpGL58pw4sAcXF2ez/UVRZPjYCSxftYby5cri6ODAxctXaFCvLgd3bpU0h+t0Orr3G8iuvfupUskbgGv+AbRv8yHb1q+RdLogPT2dDzt148w5H2pWr0ZaejqBt24zuH9flv3xm6SqBnFx8TRr056Am4HUrV2Lh48ecTcklM8//ZgfZs8y2x8st/Oc4u7+6/n8v4yRz+JdXutBjpGXeX+QY+Rl3gfetxj5V3bk32VetrBrEAlCRwwGbBEoixVuFu6aqDFyGx2xGHF4rCHV8c0iDSOB6EjEiBMKymFlUak0yCx1FoiOFIzkQ0F5rCwqlQaZD7K30JGGiCsKymJlNtneszzCwG10ZCBSECVeWGFj4QNVFHqC0aNDxBMlpbGyqNyaiEg4BkLQo0ekKCpKorKorKARkXvoCXscG1sMFcVRobBAw4BICHoeoEeBQElUFEFpURkqHSJ30BGJASsESqPC8wUvZ160sCclJbFy7Xp8zl/E1dWZQf36UrN6NcljgMxkc8tXreHqtet4ergzdGB/yY5vFhGRkfy9YhW3bgdTvFhRhg8eaFGpNMgsdfb3ilWPy8+VYcSQQZJ20p/mZuAtlq1cTWRUNFUrV2LowP64ubma7/gUl65cZeXadcTGZpafG9y/L3nz5rVI4/TZc9nKz/Xr1UPysXjIdOYPHTnG5u07yMjQ0KZVS3p07WxRuTWDwcCuvfvYuWcfoijSqX1bOrVvh1IpfQ7TarVs3raDA4ePYG1tTffOnWjdqqXksoKQ+UJg3aYt2crPNW7YQHJ/sMzOX/Rw8F/O5/8PR/5dR3bkZd4XZEde5n1AduTN0KxZs5c+bB07dswSuVyJvLDLvC/IC7uMjDRyw8PBf+nIvw9rPcjrvcz7g7zey7wP5Ia1+nWxZK2Xmg/MRNWqVbP9XafT4efnR0BAAIMGDbJUTkZGRkZGRiaXIa/1MjIyMjIyuRuLHfmFCxfm2D5z5kxSU1Nfe0AyMjIyMjIy/1/ktV5GRkZGRiZ3Y7Ej/yL69+9P7dq1mT9//puSlJGRkZGRkclFvKtrfTpGrC3MbZCOkSB0JCOSDwVeWElKsPo0KY81svLMlMbK4iP+iY81NIgUQEkpiVVfniYOQ7Y8M8UtzBEDEIOBEHQYgCKP87tYkiNGRCQSQ7Y8M4UszBFjROQBhsd5ZjKr47hbeF8NiIShN+WZKYMKFws19I/z3cRgwAYBL6zIZ2H+IO3jfDdZ+Te8sJKcBDiLDESC0ZGAkR8W/Mygfn1wdy9okUZMzENWrl1vyjMzsG8fnJ3zW6Rx/8EDVq5dT0RkFFUrV6Jfrx44OTlZpBEUfIdV6zYQFx9P3Vo16dmtC3YSysg+zbXr/qzbtIWU1FSaNmpIl47tJSVpfRrfCxfZvG0HGq2W1h+0oE2rDyzKESOKIsdPnmLnnn1AZnWc5k0bW5QjxmAwsP/QYQ4cPoq1lRU9unamXp3aFl2HTqdjx+69HD91GidHR/r06Capms/TZGRksGnrdnwuXMTF2ZkBfXpR1quMRRopKSms27TFlE9pUL8+FCta1CKN+PgEVq/fQODtIPzQ4IUV9hb+ruSW+dxS3liyu9WrVzNlyhQiIyPfhNz/FTlmTuZ9QY6Zk5GRRm6Iu8sNye7epbUenqz3VsCH2FFI4v5GJHoOChkoBIEy+RwITEjFGmgj2uEq0ekLRcdRMrBVKSnuZEdgQiqOgoK2op3k5LW30HIKDXmtVXg42BKYkIqLoKStaCv5QfYqGi6gxcXGCldba24npVFQUNJWtJP0DCQi4oMGf3S421ljr1ISkqKmKCpaSazaYkTkJBkEoaeIQ2ZJzgdpGZRGRTNsJb0QMCBymAzuoaekkx3pegPRai3eWFEfG0kvBLSI7BfURIsGvPLaE6/REZuhoxbWVM+h8ktOpGNkn5BBnGigfH5HotIySNLqaYQN5SVWOEp+XCUpVTRSPr8jYSlqMvQGmmMrqdwxQCwG9iu1aBGpULYswaGhKJVKdm1aR7Mm5ku4Apw8fYb23XtjMBgo51WGgJuB5MnjxOFd26lWtYokjR2799Br4FBsbGwoWbwY/jduUsjTk+P7d0tOXrts5SpGjv+EfPnyUsjDA/8bNylfrizH9u6S/GLi+/kLmfr1LAq4ueHq6sLNwFvUrlmDw7u3S5pPRVHksy++ZOFviynk6Ym9vR3Bd+7yYcsW7Ny0Dhsb8/ZhMBgYPHIMazZsonixTGc17N59+vTozuplSyS9ENBoNHTp3Z/9hw5TpnQp0tPVRERG8tGYUfw873tJLwSSk5P5sFM3fC9cpHy5ssTHJxDz8CFzZn7FtMmfme0PmS94mrfryM3AW1SqWIGIqCgSE5P4c9FCRgyRFn4VEhpGszbtCY+IpFLFCoSE3UOj0bB+xd907dRRkobftet80LELSUnJeFcoT2DgLYx6A62M1m/dfJ6FJWu9xXXku3btmu2nS5cu1K1blyFDhjBq1ChL5WRkZGRkZGRyGe/bWl/bPT8nBA0GzO9tGBA5IWio656fe0NacKVPY0IGNaeMsyMnBQ2iBA0tIicFDR1KFCR8SEv8+jbh1oBmuDjacEbIkDTmVIycRsPQCkV4MKQl1/s24WrvxihsFPigkaQRh4ELaJlSvRQPhrQkoH9TTnWrT6oSLknUCMeAPzrmNSjPvSEtuT2wObvb1yJSMOCPVpLGHfQEoWdFyyrcHdScu4Oas+qDqtx5XJFGCgHoiBAM7GpXi9sDm3NvSEsWNKxAADoeYJCkcRkNyQqRE13rcaN/M+4PbsnUGqW5iJZYiRq+aBCsFVzp3YjrfZsQPrQlwysW5QwaUjBK0jgjaMjvYMPN/k3x69uE8CEt6VTSnZOCBo0E+xIROaXSU7qcF/dv3+DaxXNEBAdSu0Z1+g0diU6nM6uh0+noN3QkNatXJTzoJlfOneJeoD/FihRh4IgxSNkHTE5OZuCIMbRv8yGRdwLx8z3DHf8r2NhYM2rCJ1K+CsIjIhj90USGDRpARHAg1y+cw//COeLjE/hs6nRJGteu+zP161lMnTSR8OCb3Ljky7ljhwi8HcTMOd9L0jhy7AQLf1vMT9/P4f7tAIKuXWbfts0cO3mKX37/U5LGuo2bWbNhE6v/XkLIjWuE3LjG2uVLWb95C2vWb5Sk8esff3Hk+An2bt1E0LXL3L8dwM8/fseiP5Zw8PBRSRrffj+PgJuBnDlygJuXz/Mg6AZffj6JL2d+y1W/a5I0Jk2bTmxsHNfPn+X6hXNE3rnFiCGDGPPxRO4/kLZJNPqjT1GpVARdu4yf7xki7wTSsV0bBo0cS1JSktn+oigyaOQYCnt6ci/QnyvnThEZEkT9BvU4odS9VfP5q2KxI58nTx7y5s1r+nF2dqZp06bs27ePr7/++t8Yo4yMjIyMjMx/yPu21s+uV5ZU0UikBGctCgMpopH5jSrgbJu5w+rhYMvc+uWJFQ3ES3DW7qFHI4r83NgbR+vMXaMSeez5qrYX4aKBNAkad9FjrVAwr0EFbFWZu0beLk5MrFaKUPSSHmKD0eFqa8XMOl5YKTMfCeu552dExaKECNIc1zvoKJfPgY+rlEDxeDewdbEC9CjtYYGGniaezvQrWxhBEBAEgT5ehWhWyIW7gjRH/q6gp1spd9oULwCAQhCYULk45fM5cgfzjitAiGBghHcxGng4A2ClVDCjdhkK2FoTLEEjq4TsxOqlqOSSuZNmo1TyY/3y2CgV3JXwUiIdIw9EPV/VLkOpvA4AOFqr+LlxRbRiZplbc8Rj5JFey/ffzsLDwx2A/PnzseC72URFR3P85GmzGidPnyUiMpKfvptjOkrv4eHO3JkzCLh5k+v+AWY1du87QEpKCovm/4CjoyMAJYoX56spkzl64iRRUdFmNTZu2YaVlRULvpuNrW3maQ3vihWYOGEcm7fvQKMx/8Jp7cbNFCxQgG++mmY6Sl+vTm1GDB7I2o2bzfYHWLNhIxXLl+eT8WNRKDJ/V9p8+AE9u3ZhzQZpTviaDZto3qQx/fv0Mtl53149aNmsKWs2bJI8ju6dO9G2dSsAFAoFH40djXeFCqzdKFVjEyMGD6RBvboAWFlZMfPLL/Bwd5f0fWi1WjZt28HECeOo5F0RABsbG+bP/RYbGxs2btluViMm5iGHjx3nqymTTSczHB0dWTTvB1JTU02hBy8j4MZNrgfcYO7MGdnsfOEPc0k16N+q+fxVsThGfsWKFf/CMN5N3sSx5dxwnBPkI9jPkhvui3xPZGT+O96l+VwK79ta726f6SDoJO6+ZPbJfpQ26+9aiRpKAdzssh+19nCweTwO8+gQsbdS4miV/einu4MNBkAPZg+FagFXW2tUiuz7Oh4ONmgkRl5qgRIOts8d6fVwsEUriEj4OtALIh6Pj9Q/qxFIoqRx6AUR92c0BEHA09GWO4nSdsU0iM/dV5VCgZudNdoM8w6jETAABZ/RcLBS4mClRGcw/2Vk3ftnx+Fqa41KENBKuC9ZduxesEC2dg/3TGcnOSXFrEZySvJjjexH1z0eH2WXppGCUqnEzdU1x3GkpKbiYUYjJTUVRwcH04uAp8eh0+nIyMgwe6w9OSUFVxcXVKrsbo+Hu7uk68jScC9Y4Hk7dy/IGR8fSRopqamUKFbsuXb3ggUIunNXssaz91UQBDzcC1p4Ldnvq0qlws3VRZKGVqtFq9U+Nw4HBwecHB1NtvMyUtPSgOfty9U18z5Jta9MjZzt/G2az18Vi3fkS5YsSVxc3HPtiYmJlCxZ8o0MSkZGRkZGRub/x/u21q+5FY4CKCghHtIdJQrgn8DsL3f+CXyAjSBIiqn0RIlBhNW3w01toiiy/OYD8ggK8kiI5/ZASbxGx96wh6Y2g1Fkxc0HuAlKbCRoeKLkVmIa56MTTG0ag4FVt8LxlPiI6IGSU5HxBCemmdpStHo2BkdQ0ChNo6CoZE9oDDHpT5zlh+ka9oTGUFCUFqNawKhgU3Akydonj813k9I4GRGHp8Q4V09Ryepb4WgMT3byLsYkciMhVZKGFQIFBCUrAx9gMD5xAPbfe0hshg4PCRpOCOQRFPwT+CDb8fU1tyPQi6KkcbigxEapZPnqNdnal61ajUqlon5d84nR6tepg0qlYtmq1dk1Vq7GycmJahISozVp2ACDwcCqdRtMbaIosmzVaooULkzJEsUlaTyKjWXP/gOmNoPBwD+r11K1ciXy5s1rVqNpo4bcCAzk/MVLpjaNRsPq9Rto0rCB2f5ZGifPnCX4KYc7JSWFTdu207RRQ0kaTRo2YM+Bg8TEPPmdffjwEXsOHLRIY/P2nSQnP3GW74aEcuL0GYuuZc2GjdlOM1y8fIXrATckaTg6OlK9ahVWrF2H4anflX0HDxHz8CFNGzUyq1G8WFGKFinM8tVrstn56nUb0Ov1kr6PqpUrkSdPnhztXCEIb9V8/qpYnOxOoVAQHR1NgQLZ337ExMRQtGhRSUdccjtvKtndu7SDI+/+Zic33Bf5nsjIvF287rzxXya7ex/Weniy3gNUxop6PL8rnBO+ZHANHb1Ke1DPw5mjD2LZHRZDHWyoKjGh2XHU3BUMDCxXmMquTuwKieF4RBxNsaWshIRmIiIHyCBGYWB4xWKUzGvPxqBILj5MpDV2FJVw6NKAyG5BTZoSRnoXw93ehlW3wrkVn0J77CU9CGsR2SGko7BWMtK7GE7WKv6+cZ+IFDWdRDvyS9BIw8gOQY2TnRWjvIshCLDE/x7Jah2dRTscJLxUSMTITiEdTyc7hlUoQprewBL/exi1BjqJ9pJebDzEwG7SKevsyKByRYhRa1jifw97A3QU7SQl7ruPngOoqVkgL729ChGanM7fAfdxExW0EW0lJd0LQsdxMmhayIVOJQviH5fCysBwSopKmiMtU/s1tPiioWPb1nzQojm+Fy6xbtNmPh0/lgXfz5Gk8fmXM5j38yL69OhO/bq1OXriJDt27+XH2d8w+dOPJGkMHD6K9Zu3MqhfH6pU8mbX3v0cOX6CFUsWM6h/X7P9RVGkTefunDxzlhFDBlKqRAk2bt3O+YuX2L15g+mI+cvQarU0aPEhQXfuMnLIINwLFmD1+o3cCgrmxIE91K1dy6xGcnIyNRs1IzExiZFDB+Pk6MiyVauJefiI8yeOUK6sl1mNqKhoajRsilKpZOTQQQiCwF/LV6LT6bh89gSeHubOJ2Rm76/dpDkF3NwYOqA/aelpLFm2grx583Dp9HFJLzYuXLpM41ZtKVumNAP79ibm4SOWLF9BmVIlOXv0oKTEfQcOHaFdt57UrlmD3t27EhIaxtIVq2hYry4Hd22TlHRvzfqNDBg+ihZNm9CpfVuuB9xgxZp19OrWlTXL/zLbH2DBL78yadpXdGrflpbNmuJz/gLrN2+lkqh6q+bzp7FkrZfsyO/atQuAzp07s3LlymyGYjAYOHr0KIcPH+b27dsWDTY3IjvyzyM7jdnJDfdFvicyMm8Xb4Mj/z6t9fBkva+DNVWwllzqTETkBjoCBT2JogFnQYm3aIUXKskaRkSuoeW2oCdVNOIqKKkiWlHCgoc+PSJX0HJH0JMuGikoKKkmWlPYgshJDSKX0BAi6NGKIp6oqI61JCc+i3SMXERLmKBHL4oUQUVNrHG2QCMZI5fQcO9xXH0xUUlNbMhjweHReAxcQku4YEAJFBdV1MLaolJUMRi4goZIDFgLCko+HoeUFwFZhKPHT9ASLRqwExSUFlXUwNqisoCh6Lgu6HgkGnAUFHiJKqpibVFJvyB0BKiMxBt0lCxVkgmjRzJu1AhTjLc5RFHk9yVL+fXPvwgJDaN8WS8++2g8A/v1kVwuTa/XM//nX1my/B9T+bmpkz6lS8cOkq9DrVYz+4f5rFizjkexsdSrU4uvpnxOy+ZNJWskJSXx9ezvWLtpMykpmeXnZn75hSQnPouYmId89e0cNm3bjkajpU2rlnwzfRreFStI1ggNC+Orb+ayc+8+RFGkc/t2fPPVNEmnE7K4cTOQGbPnsv/QEaytrejRpTPffvWlRaUFz1+8xMw532eWn3NypG+P7syaPpV8+fJJ1jh6/CTf/vAj53wv4OriwuD+ffnqi8kWlQXcsXsP381faCo/N3LoYD7/9OPnwiBexqq161mw6DcCbwfhKEIFvYKKWL1183kW/4ojn/VLLwjCc5kqraysKF68OAsWLKB9+/YWDzi3ITvyzyM7jdnJDfdFvicyMm8Xb4Mj/z6t9SCXm5V5f5CfGWTeB3LD8/nrYslaL/l1h9GYmXGvRIkSXLx4EddnElfIyMjIyMjIvN3Ia72MjIyMjMzbgcVZ60NDQ/+NccjIyMjIyMjkEuS1XkZGRkZGJncjyZFftGgRI0eOxNbWlkWLFr30sx99JC35xduMGiNxGLFFwAWF5PiJp4mKiibgZiCeHu5UrFD+lcaRgpEkjDihIK/lBQgASMJICkbyosDpFTVu3AwkMiqaihXKSUrU8SyiKOJ37Tpx8QlUrVwJV1cXizWMRiOXrlwlJSWVmtWrSkr28Sx6vZ7zFy+h1WqpXbMGDg4OFmsYEIl5XLeyIEpJiXGeRYfIQzLj+wqgtCgeLoukpCQuXfHD0dGBWjWqS46He5rY2Dj8rvvj4pyfqlUqS46He5o3Yef37t8nKPguxYsVpUzpUq+kEXznLmH37uNVphTFihZ9JQ3Zzp+g0WhM2X/r1KopKTHOs6Snp3P+4iWsra2pU6umRfFwWbxLdv4m5vPXRV7rZWRkZGRk3h4kPTktXLiQfv36YWtry8KFC1/4OUEQ3unFXUTkPBpuoEP/uM1NUNJMtJGUlRUyM2eOnziZ5avWmEo21K9bh/Ur/qZoEWlxHTpETpJBCHpTdcOigoqmog12Eh8A1Rg5IWi4L2ZeiQCUREVjbCXHCT4ID6fP4OGc9fEFQKlUMrh/X35fOF/yg33grdv0GTyMa/4BAFhbWzNh9Eh+nPON5IfyC5cu03/YSFNJEHt7e6ZNnsi0yZ9Jfig/fPQ4w8ZO4EF4ZumIvHnz8P03Mxk9fKik/gB30eEjaEkTM4+mOggK6orWlLYg0cVNtFwUtGQ8jk11EhQ0Em0oIvHwjCiKfD9/IXPmLSDtcY3O0qVKsvrvJZITuhiNRr74aiaL/lhiykxd2bsi61cso0L5cpI03oSdp6amMmzsBDZv22GK1W3Vojlrlv2Fm5u0476xsXEMGD6KA4ePAJlzVLfOHVn+x284OTlJ0pDtPDubt+1g/MTJPHz0CAA3V1d+XfAjvbp3layxZNk/fDFjJomJSQAULlSIv39fxIcftJDUP7fb+bp/lkp+YfQm5vM3hbzWy8jIyMjIvD1IekoIDQ3FxcXF9OcX/YSEhPyrg/1/cw0t19HxZW0vbvZryr4OtXHNa8d+IQMd0qr4ffHVTFauXc+8Od9wN8CPHRvXEhkVRdsuPbPVYnwZp8ggWiWyuGklggY0Y02raqRbCxwTpJcDOiZoSLMWWPVBVYIGNOOPZpWIVomcJkNSf6PRSLuuPQmPiGD7hjXcDfBj/txvWbNhE1Omfy1JQ61W06pjV/R6Awd2bCX4+hWmT5nEwt8W88OCnyVpPHoUy4eduuKcPz/H9+8m8MoFxo4YxvRZs/ln1RrzAmTW3+zYsw/lvMrgc/ww/hfO0aNLZ8Z8PJG9Bw5K0niIgaNk0KpEAc73bMj5ng1pXbIAx8gw7dCb4z56TqOhd7lCXOndiNPd6lOnkDOHUJOEUZLGyjXrmDbzG0YNHUzglQucOLAHVxcXWnfuxsOHjyRpzFu4iPm//Mq0yRMJunaZgzu3YTSKtOrYlfT0dEkab8LOR47/hP2HjrDk158JueHH+hXL8LvuT8+BgyX1B+g1cAiXr/qxdvlSQm748ddvv3DwyDFGjP9YUn/ZzrNz8fIVeg8aSqMG9bh85gSXz5ygaeOG9B0yPFt93pex78AhRn/0KV07duD6+bP4HD9MhXJl6dSrb7b6vC8jt9t5u669/tP5/E0hr/UyMjIyMjJvDxbXkf/mm2+YNGkS9vb22drVajXz5s1jxowZb3SA/w9yymIrIrJOSKdPhcIsblrJ9Nk7iWlUWHuCptji9czO67MZQlNTUylYwotJH49n1vRppnaf8xeo37wVB3ZsfW5H6tnsi2kYWUsai5p4M9q7mKl9Z0g03fdfphv2uJo5HRCHgS2ks6l1dbqUenJE+K+Ae4w/GUBfHHB85h3Ps9dy+OhxWnXswpkjB2hQr66pfdbc7/lx4SKiQ26b3fFcvW4DA0eM5rbfJbzKlDa1j/3kM7bt3E3EnUCUypdfy/yff2X6N7N5cPtGtl3abn0HEBR8F/+L517aH2DytK/4Z81a7t8KMNm1KIo0+qANtjY2HNm787k+z96XY6jRO1kR2L8ZSkWmzRiMIhXXnkCRrJVU93WfoMbDzZEz3eubdljVegPFVxylsIbn6mHmlIG2Sp0GlCxRnO0b1praYmPjKFK2IrO+nMrnE1/uwBqNRgqXqUDHdm34c9GTHbk7d0PwqlKDFUsWM7Bfn5dqvIqdP0tkVBRFvCry20/zGDNimKl9x+49dOndn6vnTlG1SuWXalz3D6BK3YZsXbeKrp06mtqXLPuHsZ98xr1b/hQuVOilGu+7nT/LwOGj8LlwkVtXL5rGbDAYqFCjDrWqV5dU97VVhy6kpqVx9ujBJ3auVlO0nDcD+/SWVN/4bbXz153P/8s68u/DWg9y1nqZ9wc5a73M+8D7lrXe4nN7s2bNIjU19bn29PR0Zs2aZancW4MOSBWNNCmUPa61dD4HPOxtSJSwYxoVHUN6ejpNGzXM1l63di2sra25HRxsViMZIyLQ2NM5W3vWuKTs3GZ95tlraVLIBfHx/2GOoDt3UKlU1K9bJ1t700YNSU9PJyIyyqxG8N27FPL0zObcZGnEPHxIcnKKpHFULF/uuaPWTRs1JOjOHbP9szTq1KyZ7YFVEASaNGxAkMQdwlRBpHEhF5MTD6BUCDQu5EKyIO1dWYpgpGlhl2zHpO1USup55JdkX5nXcpcmDRtka3N1daFSxQqSvo/U1FSioqOfs9HSpUpSuFAhbgeb13gTdh4SGobRaHzuWrI0pdyXrM80bdToOQ2j0cjdEPPJvGQ7f1bjLo3q18v24kGpVNKofj1J9xUyv48mDRtkt3M7O+rWqmnBtbwbdv4m5vN/i/d1rZeRkZGRkXlbsNiRF0Uxx3jMa9eu4ezsnEOPFzNz5kwEQcj24+7unu3fy5Urh4ODA/nz56dly5acP39esv6GDRsQBIHOnTtbNK6csCIz5vlsVHy29tDkdKLSNeSR8FW6FyyAnZ0dZx7H2mZx6cpVtFotpUuWNKvh9Dj12dmohGztWeOSMo6szzyrcSYqHuHx/2GOUiVKoNfruXDpcnYNH19sbW3x9HB/Qc/sGpFRUc85VGd8fHBzdSVPHvMxzKVLluTmrdvExWW/L6fP+VCqZAmz/bM0Ll6+QkbGk7ACURQ54+NDaYkaDqLA2ch4jE8dcDGKImcj43ESpe3yOIoCpyPistVu1hgMnI9KkHRfs67lrG/235H4+AQCbgZSqoT5a3F0dKSAm9tzNhoaFkZ4RISk7+NN2HnxYkURBOE5jay/S7m3WWM94+OTrf30OR8EQaBE8WI5dcuGbOfZKVWiBOfOXzCVKIPM3e1z5y9Iuq9ZGmd8fLPbuUbDhUtXJNlo1rW8C3b+Jubzf4s3udbLyMjIyMjIvHkkPyXkz58fZ2dnBEHAy8sLZ2dn00/evHn54IMP6Nmzp8UDqFixIlFRUaYff39/0795eXnx22+/4e/vz5kzZyhevDitWrXi0SPzMZD37t1j0qRJNHpmN+5VERCoIKr4K+Ae867c5UGKmlMRcXTfdwl7QUEpCcnInJycGDaoP3Pn/cTiv/4mMiqKA4eO0HfIcMp6lZGU6MkRBSVRMeXsTVbfCicqLYMdIdGMPHYdT0GJq4Rb6oqSQoKSUceus+1uFFFpGay9Hc7nZwIpgUqSI/9Bi2aUK+tFv6Ej2H/wMJFRUfyxdBlzflzA0IH9JR377NG1M+4FC9Kt7wBOnDrNg/Bw5i1cxOK/ljF+9Aizx40BBvfvi7W1NZ1798P3wkXC7t3jq29ms3nbDj4eO9psf4BRw4aQlJxM936DuOp3jTt3Q/ho0uecOnOOj8aOkqRREWvuJqcz6LAfN+JSuBmfwuDDfgQnpVERa2kaojU+MYl8dOoGwYlp+D1Kouf+yyRodFSQmDDv43Gj2bJ9J9O+/obQsDDOX7xElz79UKlUDBnQz2x/hULBhDEj+fPv5fyw4GcehIdz8vQZuvUdSAE3N3p262JW403YeeFChejepROfT5/BqrXriYqKZvuu3Ywc/wkN6tWletUqZjWqVqlM44b1GTXhU7bu2ElUVDRr1m9k8pdf0aVje0lJ92Q7z8740SMICr7DgGGjuHEzkJuBtxg4fDS3bgcxYcxISRofjR3FmXM+jJ84meA7d/G7dp3u/QaSmJQkOeneu2Lnb2I+f9P8W2u9jIyMjIyMzJtFcoz8ypUrEUWRoUOH8vPPP2cre2RtbU3x4sWpV6+eRf/5zJkz2bFjB35+fpI+nxXLduTIEVq0ePFDksFgoEmTJgwZMoTTp0+TmJjIjh07JI/rRTFzRkR80HATnenAo7OgoLloi0sOcek5xSNlZGQwcvzHrNmwybQjVb1qFTavWUnJEsWf+3xOsR5aRE6QQagpdz4UEpQ0F22xl/jgl46R44KGcPGJRnFUNMUWmxziBHO6ltCwMHr0H8zlq35A5jHdvj178PfiRdja2j73+ZzwD7hBz4FDuHU7CACVSsWoYUP4Zd73khwcgLM+vvQbOoJ79zPHaGNjw+RPJvDNV19Kzua998BBho2ZQMzDh0Dmjt23X03jk/Fjc/x8TvclCB2+ggb14/tqJwjUFW2ey53wMvzRcknQon2s4SAoaCjaUDyHF0U53RNRFJk193u+X/CzKRN30SKFWbPsLxo1qC9pDAaDgU+nTOWPpcvR6zPto6xXGTauXE6VypXM9M7EUjvPieTkZAYMH8WuvftNbU0aNWDDiuW4uxeUpBET85Deg4dy4tQZU1uHtq1Z/fcSyaXb3mc7z4k16zfy0eQpJCQkApA/fz5+/uE7szHlT7No8Z98OWu26eh2wQIFWPr7L3Ro20ZS/7fVzl93Pv8vYuT/jbU+NyPHyMu8L8gx8jLvA+9bjLzFye5OnjxJ/fr1sbKS7py8iJkzZzJv3jzy5s2LjY0NderUYe7cuZTM4UiiVqtl0aJFzJ49mzt37uDq+uLyU19//TXXr19n+/btDB482Kwjr9FoTA+DkLmwFylS5IULexpGYjFig0DBl9SRf9mkee/+fa4H3MDTw4PqVau88EH8ZQaZhJEEjDgh5PgiQQrxGEhGJB8K8r3kJcCLrkUURa76XSMiKopKFStQvJj548o5aZy/eInYuDhqVK2Kh4Tjys9iMBg46+NLSmoqdWrWfKUa3VqtljPnfNBotDSoV+elvzwvui96RKIeZ6l3R4nVKzwYahGJxoAC8HhJLfqX2VdcXDy+Fy/i5OhIg3p1JTuLTxMVFc1lPz9cnJ2pU6vmK9XolmrnLyP4zl1uBQVRvGhRKnlXtLg/QMCNm4Teu0fZMmWei1WXwvtq5y9CrVZz+mxmyELD+nWfS4gmheTkZM76nMfa2ppGDephbS3t5MrTvG12/rrz+X+Z7O5NrvW5GdmRl3lfkB15mfcB2ZG3ALVajU6ny9ZmycPF/v37SU9Px8vLi5iYGGbPns2tW7e4ceOGqQTOnj176N27N+np6Xh4eLBjxw5q1XpxneCzZ8/Sq1cv/Pz8cHV1leTIz5w5M8fkPa+7sL+JSTO3GKS8AGQnN9wX+Z7IyLxdvO688V868k/zumt9bkZ25GXeF+RnBpn3gdzwfP66/KtZ69PT0xk/fjwFChTA0dGR/PnzZ/uxhDZt2tCtWzcqVapEy5Yt2bt3L5B5tC+LZs2a4efnx7lz52jdujU9e/bk4eNjoc+SkpJC//79Wbp06Ut37J9l6tSpJCUlmX4ePJAnOxkZGRmZ95c3udbLyMjIyMjIvHksduQnT57MsWPHWLx4MTY2Nvz999/MmjULT09PVq1a9VqDcXBwoFKlSgQ/VbbHwcGB0qVLU7duXZYtW4ZKpWLZsmU59r979y5hYWF06NABlUqFSqVi1apV7Nq1C5VKxd27OZdYsrGxIU+ePNl+ZGRkZGRk3lf+zbVeRkZGRkZG5vWx2JHfvXs3ixcvpnv37qhUKho1asT06dOZO3cua9eufa3BaDQaAgMD8fDweOFnRFHMFs/+NOXKlcPf3x8/Pz/TT8eOHU27+kUkZKmWkZGRkZF53/k31/rcyC20iEiPNBQRCUTLNpWGFcp0dig13EFnvuNTGBG5jpbNQjorhFR2C+ncfyrpoRQMiFxGw0YhjZVCKvsENZEWamgROY+G9aoMVirVHBIyePQ414tU1Bg5QwZrVRmsUqo5SgaJGM13fIpUjJwkg9UqNatVak6QQYqFGokYOUrmGNaqMjhDBmoLNWIxcAg1K4VU1glp+KJBa4FtAEShZ99jjY1CGpfRYLBQ4z56disz7WuzSsN1tBgt1LiLjh2PNSrXrs9fy1dgSUStKIr8vWIVVeo0II97EWo1asbGLdssGoPBYGDhr79Trlot8rgXoXGrNuw7cMgiDY1Gw7ff/0jJilXI61GUVh26cOrMWYs0UlJS+OKrmRTxqkg+z6J07tWXK4+T2EolNjaOCZ9Nxr2EF86Fi9Nn0DBuBwWb7/gUD8LDGT52Am7FSuFWrBTDxoznvoUngYOC79B38HCcCxfHvYQX4ydO5tGjWIs0rvpdo0vvfuTzLErhMhWYMv1rUlJSLNI4ffYcH3bsSl6PopSsWIVvvvvhhT7ai9h/8DCNW7Uhj3sRylWrxU+LfsNgsGz+2bR1O7UbNyePexG2qjTcfEvn81fBYkc+Pj6eEo/r9ObJk4f4+Mx6tw0bNuTUqVMWaU2aNImTJ08SGhrK+fPn6d69O8nJyQwaNIi0tDSmTZuGr68v9+7d48qVKwwfPpzw8HB69Ohh0hg4cCBTp04FwNbWFm9v72w/+fLlw8nJCW9v71dKpiQjIyMjI/O+8SbX+rcBH7RcQCv585fQcgoNDdt8wOxvZlK1aQOOkoG/BRqn0XAeDa3LFGRW3bIUL5iH/aglP0CKiBwhg2uCjm7lCzGjbllcXOzZi5pwiQ+QBkQOKDXctlUwcPhgpk//AutSRdmtkO7M6xDZq9QS7mTL6HGjmfLFJLSFCrBLmUGSRCdajZHdSi3xLnn45NOP+eTTj0lwycNupZZ0iRpJGNml1KAt5MbnUz5j9LjRROSxY49SK9kRf4SBXYIaVV4bptUuw0DvogQp9ewX1JId8XD07EFNfhc7vqrjRffyhbkm6DhMhmTn4g469qOmeM2qfDvra9p278x5QctppDtJAWg5QgaVmzRg9jczKetVhlETPuHLmd9K1pjx7RxGjPuI0qVKMuOLz3F1caH3oKH88vsfkjVGf/Qpk6Z9Ra3q1fhqymQA2nXryfpNWyT1F0WRHv0HMfuH+bRs1pRpkyYSn5BA87YdOXz0uCQNnU5H687d+W3JUjp3aMvkTz4i6M5dGn7QhktXrkrSSE1NpUnrdqzduJkBfXrx8djR+F68SL3mHxB8J+cTv8/y8OEjGrRozd4Dhxg5ZDAjhwxm38HDNGjRmujoGEkad0NCqdf8A3wuXOCjMaMY0KcX6zdvofGHbSU74leu+tHwgzbcCgpm8icf0bVTe37/629adez6XD6UF3H0+Emat+3Io9hYpn72KR80b8acHxfQre9AyS+LNm7ZRtuuPRBF+GrKZGrXqM7kL2cwcvzHkvoD/PrHEnoNHIJz/vzM+OJzmrT7kNNo3rr5/FWxONld5cqV+fXXX2nSpAmtWrWicuXKzJ8/n0WLFvHjjz8SHh4uWat3796cOnWK2NhY3NzcqFu3Lt9++y0VKlQgIyODvn37cv78eWJjY3FxcaFWrVpMnz49W7K7pk2bUrx4cVasWJHj/yEl2d2zvKnkN3Kyu3eX3HBf5HsiI/N28TYlu3uTa31uJmu9n1K9JPOvhNAXB7NlXNUYWSeomfbFJGZNn2ZqH/PxRFb8s5K+BjuzFUsSMbKRNBY1rsiYSsWBTIel5/7LHA97RE/RHoUZjUj07EbNxtbV6Voq8ySj3mjkgx2+BEUn00U0X03iLjqOkMHpw/tpWD+zrKBaraZG/cakB4fRWjRfYjMALb4KHf4XfShfrmzm9SUmUqFabfI8TKAp5jUuoCHITsnt65cp5OmZeX1RUZStXIPS6XrqYGNW4yQZJLrl4+bVi+TPnw+AW7eD8K5VjzoGFZUwv5lzEDXWeW242KsR9laZ1SPORcXTZJsPLbCltIRysjuEdEoWzMOxLnVRPa6CsSMkmh77L9MBOzxzKCf7NEZENqs0NGn9Ads3rDVVwfjz7+WM+XgiPbEnv5lKRTpE1iszGDCoP0t+/dnUPmvu98z5cQH3bwWYLeP68OEjipStyBefffKcna/fvIWI4EAcHBxeqnE7KJhy1Wrx+8L5jB05HMi08+79BnL5qh93A/zMVhs5deYsTT5sx5a1K+nWuRMAer2eFu06kpaWzqUzJ17aH2Dzth30HDD4OTuv1ag5xYoWYe+2TWY1fvvzLz75fCr+F85ls3PvWvX5sGVzlv3xm1mN6bNm88viP7l19UI2Oy9fvQ7jRg5n7qwZZjVGjPuIfQcPE3DRJ5udV6pdn/lzv+XjcWPManTs0Zs7IaFcOn3cVHXmnO95GrT4kPUrltG7RzezGnWatMDa2prj+3ejUmXa9PZdu+naZwDH9++maeNGL+1vMBgoU7k6VSp5s239mufs/Obl86bv+UWkp6dT2KsCPbp0fs7Ov537A31F+7dmPn+afzXZ3ZAhQ7h27RqQmSQuK37u008/ZfLkyRZpbdiwgcjISLRaLREREWzdupUKFSoAmbvr27ZtIyIiAo1GQ2RkJDt37nwuY/2JEyde6MQDrFixwiInXkZGRkZG5n3nTa71bwODyhXBAERL2IWOxoBeNDJq2JBs7aOHDSHDYCBWgkYEehTA0ApPXu4IgsAI72IkiUZSJOzcRmIgv7UVnUs+KWWpUigYWqEoD0WDpF3oSAyULV3K5NwA2NnZMWTgACIEaTvyERho3LB+tofufPny0adXD2KspD28RiuhY/t2JucGwNPDg04d2hMtsapkjJVA757dTc4NQLmyXjRt1JAIiacLIgUDg8oXNjnxAPU9nKmQ31GShg6RGNHAsApFTE48QKcSBXGxsZKkkYJIol7HqKFDspWyHDqwPyqlUpJGHEbUBj2jhg7O1j5q6BB0Oh1nfHzNapz19UWr1eZo50lJyVy9dt2sxrGTp1AoFAwbNMDUJggCI4cM5t79B4SEhknScHV1oUvHDqY2lUrFsIEDuHzVj+TkZEkaFcqXe87OB/Xrw7GT0k4YHTt5iiYNGzxn5726dbFIo0Ob1s/ZeYc2rS3S6Nm1c452Ll3jNAP79M5WOrZ+3TpUqlhBkkZaWhoXLl1m2MD+JiceoHOH9hRwc5OkEXbvPqFh9xg5ZPDzdq5SSdLwu+5PQkJijnZuEMW3aj5/VV7+WjAHPv30U9OfmzVrxq1bt7h06RKlSpWiSpUqb3Rw/29+jrr5f098J++65k5e9768iR39N6Eh25eMzH/H6/6+JScn849H0Tc0mpfzJtf6nEq8FixYkOjoaNO/b9iwgQcPHmBtbU2NGjWYM2cOderUkaS/YcMG+vTpQ6dOnV75xX2sJvMIpUrCrknWZx49isXzqZw+j2LjAMzu3mR9xgjEZ+jwcHjiNMaqs8ZhHhUCGQY96ToDjtZPesSqtSiQtlOjAmITk9Dr9dkeyB/FxpLPOT9/3jN/ZHjAsJFc8w9AFMVsD+SxcXEUKl2KPy/5mNW4274zj2Kfj/F9FBtLxUb1+HPvTrMa52rXJzYu7rn2hw8fSthHz8QKgdiM7MdpDUaRuAwtBST0VwBKntzHLNL1BtL1Bqwk3NmssT77fSQkJKI3GLCScDVZn4iNi8/WnqXpaGYnHcDBPvMzL7JzB3vzJz4cHRwwGo3Exyfg4fHkhVPWfXJwMK/hYO9Aerqa9PR0HB0ds12LSqWSFDbrYG+f+f3lYOeOjua/iyyNO3dDcrTzrO9KisaL7FzKPcnSyMnOH8XGUrF8+VfWMBgMxMUnSBqHlZUVVlZWJlvIIj09nbT0dBwdHF/QM/sYssb9NFn3SZqNZmq8yM4nbl9D61YtX6px6MgxDnXq+n+fz18Vi3fkn6Vo0aJ07doVZ2dnhg4d+ibGJCMjIyMjI5OLeN21vmLFikRFRZl+/P39Tf/m5eXFb7/9hr+/P2fOnKF48eK0atWKR48emdW9d+8ekyZNolGjlx/jNMcMn9s4CAoKmTmyDOCJEkeliklTp5t2A2Nj45g6YybOSitcJDxaFUOFtSAw6cxN1PrMHZ/wVDXfXgiikKDEQYJGKVRkGIxM872FzpAZRx6UmMqCq3cpgUrSS4nSWPEwNpY5P843JZi6ctWPv/5ZQR8Jx2sB+vTojv+Nm/z593JTbOzxk6fYuHU7fXt1l6TRt2d3jhw/wZbtOxFFEVEU2bpjJ4ePHadPT2nj6NuzB5u27eDo8ZNA5tHWJcv+wf9moKQj8QAlRSVLA+5z6WEikOnEf3/5DjFqrSQNJQIlUPGTXwi3E1IB0BmMTPe9TYbBSEkJGvYoKKyw4tvvfuDB4xCWjIwMPvl8KlYKBcUluAXOKHBRWTHt61nEPnZIUlJSmPzlDAq4udGsifnfl6aNG+JesCCTv5yRzc6/nPUt5cp6UbVKZbMaHdq2xsHBgYlffIlarQYgPCKCb3+YR5NGDbI5Ti+iZ7fOZGRk8MWMWab47aDgO/z062K6duqAra350I0+PbsTFR39Wnbet2ePXG3n1/wDLNDoztIVq0z5AQwGA3PnLSAyKoo+Pc1fi7W1Nd06dWThb4tNyf50Oh3Tvv4GtVpNj66dzGq4uxekWeNGzJm3IJudfzplGvb29nRs19asRuVK3lQoX47p38x+43b+X8/nr4rFMfIv4tq1a1SvXt3iTIO5kayYuaSo+//3HXmZd5PcEGMP8o68jMzbRHJyMnk9iv4nMfIv4lXW+pkzZ7Jjxw78/PwkfT5rDT5y5AgtWrR44ecMBgNNmjRhyJAhnD592uJ8OE//XyqgFXYUkbh3Eo6eQwoN1ra2VCxfjuv+AWAw0MZgQwEJLwMgMz79GBk4WanwyufA1dhkbBFoK9qajYHO4gZazqDB1daKoo52+MUmk0dQ0F60k/zweAkNl9HiUbAAHh4eXPG7RtXKlTi2b3e247svQhRFxn06iT+WLqNkieI4OjhwPeAGTRs3ZN+2zdjZ2ZnV0Ov19Bk8jC3bd1KurBeQGffbtVMHNq76J9su6otQq9W079aLYydPUaliBZKTkrkXHk55rGiEDYKEFxsaRPYJah6KBio7OxGboSUyXUN1rKklIU4fIA0jewU1SaKRqq55uJ+qJjZDRwNs8JYQpw+ZMbf7lBrUiFSrUpngO3dJTkmhmWgj+aXEIwzsV2owKpVUqeRNYFAwer2eHRvW0qplc0kaR46doGPPPqhUKrwrlMfvuj82NtYc3LmN2jVrSNLYtHU7/YaOwMnJkbJlynD5qh+uLi4c27fLdK/Nsfivvxn36SQKFihA0SKFuXzVjxLFi3Hy4N5sx9Rfxsw53zFr7g8ULlSIAm6u74ydp6WnExIaxsihg/lz0cJspwVeRGJiIi3adeKK3zWqValMbFw8D8LD+eqLyXzz1Zdm+0NmbH/T1u25GxJKjWpVuf8gnJiHD/l1wY+MHz1SkkZQ8B2atenAo9hYalSrStCdOyQlJbNm2V+S4vQBLl25SquOXVCrM6hWpTIBNwNfy87Le5X5v83nWVgSIy878jkgO/Iy/zayIy8jI2Mpb7MjP2/ePPLmzYuNjQ116tRh7ty5lCxZ8rnParVaFi1axOzZs7lz5w6urq4v1P3666+5fv0627dvl5zYVqPRZCuPlJycTJEiRSQlEHuWVIzcQkcKRvKhoBxW2Fm485KEkdvoSMOIC0rKYoWNhUl24zAQhI4MRAqipAxWko6DPs1DDASjo9aAnjRt1JCe3bpI2unMQhRFTp4+w+btO9FoNLT+oCWdO7ST5JhkYTQaOXDoCDv37gOgU7u2tG7VEoVC+neq1+vZuWcv+w8dwWflBkqiwhOlJCc+CwMid9ETiR4rBEpjRUELbUOHSDA6YjBgi4AXVrhYqKFBJAgdsRiwf2xfeS20L/Vj+0rASJ9pnzFs0ACKFC5skcaD8HCWr1pDaNg9ynl5MXRgfwoUcLNI487dEP5ZvZaIyEiqVq7EoH59JTnPT+MfcINV6zYQGxdH3dq16NerR7aj9lK4cOkyazdsIiU19Z2xc2tra3p06UTTxo0kOfFZaDQaNm3dzvFTp3FydKRvrx7UqVVTcn/IjJVfu3EzPucv4OLszKB+fajkXdEijcTERFauXc/Va9fx9PBgyIB+lCldyiKNhw8f8c/qtQTevk3xYkVfy87XzZn/f53PQXbkXxvZkZf5t5EdeRkZGUt5Wx35/fv3k56ejpeXFzExMcyePZtbt25x48YNXFxcANizZw+9e/cmPT0dDw8PduzY8Vxy26c5e/YsvXr1ws/PD1dXV8mOfE7x+sBrV6l5V3iX1oTcss7mFt6leysj82+RG+aNfzVrvYyMjIyMjIyMVNq0aUO3bt2oVKkSLVu2ZO/evQCsXLnS9JlmzZrh5+fHuXPnaN26NT179uThw4c56qWkpNC/f3+WLl360h37nJg6dSpJSUmmnwcPZOdGRkZGRubtRPJZkK5du7703xMTE193LDIyMjIyMjL/R/6Ltd7BwYFKlSoRHBycra106dKULl2aunXrUqZMGZYtW8bUqVOf63/37l3CwsLo0OFJOSqjMTPZm0ql4vbt25QqlfPRTBsbG2xspMU6y8jIyMjI5GYkO/J58+Y1++8DBw587QHldt50PEghT0+GDOhH6VLPxwq+jKfjQUoUL8bQgf0tjgcJj4hg+ao1hISGvXLc092QUJavWmOKexrcvy/58uWzSCPgxk1Wrl1vinvq37snDhLLcGRx8fIV1m7YlJkMpnEjenbrYtHDmiiKnDpzlk3bdrxW3NPBw0fZuXcfoii+UtyTEZEw9DzAgAJeM77PgBVQBivJyTqykO08O7KdP+FN2HlWfN+Bw0extrame+eOrxTft3nbDo6fOo2jgwP9eveUnHwpi3fJzt8U/8Var9FoCAwMfGmmeVEUs8WyP025cuWyZb0HmD59OikpKfzyyy8UKfL/PxopIyMjIyPzb/PGYuTfJV4UI/90hsbqVavwIDyCmIcP+e2neYwbNUKSdlaGxoePHlGjWlWC794lOTmF1X8veaUMjVUrV+JG4K1XytDYqVdfFAqFKROpra3NK2ci9Spdmit+13B1ceH4/t2U9SojSeOPpcsY+8lnFHBzo1jRIly+6kfJEsU5cWCP5Eyks+Z+z8w531O4UCHcXF24eu061apU5ujeXZIzkY6fOJnFf/1NieLFcHRwwP/GTZo1bsTebZskZSI1GAz0GTyMzdt2mK79dlAw3Tp3ZMPK5c85SjnF4OgROSioCRcNlM/nQLrewL3UDCpgRcNXzLj7KENL1Esy7uYUMyfbeXZkO3+CpXaeE2q1mg7de3P0xEm8K1QgXZ2ZcXfUsCH88ctPkjPutmzfmctX/ahWpTKPYuMIj4hgxtTPmTV9mtn+8HbaeW6IkX8VJk2aRIcOHShatCgPHz5k9uzZnDx5En9/f1xdXZkzZw4dO3bEw8ODuLg4Fi9ezJo1a7h8+TIVK2a+WBk4cCCFChXiu+++y/H/kBoj/yxZ670cI5/JuxRHnRtiXXMT79K9lZH5t8gN84YcI/8vMWnqV6SmpnHjki8XTx/nQdANJowZyUeTphB2754kjdEffYqDgz0hN/zwPXGEiOBAenTpzLCxE0hISDTbXxRFBo8cS6kSJbh/KwCf44eJCL5J4wb1GThiNFqt1qyGVqtlwPBRNKhbh4jgm/gcP8yD2zfwKl2awaPGIuXdTlJSEkPHjKdb545EBAfie+IIITf8yJPHidEffyrlq+De/fuMnziZcaNGEB58kwunjhF45QLp6Wo+mzpdksaVq37MnPM9X0+bQljgda6cO8WlMycICQtj5pycH/ie5cChIyz+629+XzifuwF+XL9wjqN7d3Lu/AUW/rZYksaqtevZvG0Hm1avIPDKBQKvXGDL2pVs27mbVWvXS9LwR0sMRg52rMP1fk0JHtic35t4cxMd95GWWOoyGtKV4NOjAZf7NCZ0UAtm1vbiCloeSdSQ7fwJsp1nZ/W6Da9t57/8/ienz/lwZM9O/C+e447/Vf5ctJAly/5h38FDkjRmzf2B4LshXDx9nCvnThEWeJ1vvprGN9/9aKqLa453xc7fBsLDw+nTpw9ly5ala9euWFtb4+vrS7FixVAqldy6dYtu3brh5eVF+/btefToEadPnzY58QD3798nKirq/3gVMjIyMjIyuQvZkZeIVqtly46dfDp+rKn2o5WVFd/N+ho7Ozs2bd1hViM6Oobjp04z/fNJpmOTtra2LPxhLunp6ex6XIriZfgH3OBGYCBzvv4KN7fMJD9OTk7Mm/MNMQ8fcuzEKbMaJ0+fJTomhnlzvjG96XF1dWHO118ReOs2fteum9XYtXc/aWlpLPx+rmknr3ChQkz/fBInTp0hUsID1+ZtO7G1teX7b77GyiqzLqpXmdJMnDCWrTt2kZGRYVZj/eateLi789UXn6NUZh4fr1GtKiOHDGbd5i1m+2dqbKFSxQqMGTHMtBvYvGkTenbtzLqNUjW20rJZU3p07YwgCAiCQLfOnfigeTPWbZKmESoY6FHGg+ZFMu+rIAiM9C6Gt7MTd9BJ1hjhXZSaBfIBoFQIfFGjNAXtrAmWoCHbeXZkO8/Ouk1bXtvO12/eQs+unWnRrAmQaeejhg2hSiVvi37fRgweSM3q1QBQKpVMm/wZnh4erNu42Wz/d8nO3wY2bNhAZGQkWq2WiIgItm7dSoUKFYDM72zbtm1ERESg0WiIjIxk586dz2WsP3HiBCtWrHjh/7FixQqLd+NlZGRkZGTeZmRHXiI6nQ6dToebq0u2dnt7exzs7UlNSzWrkZaeDoDbM1l28+fPh0qlIjUtzaxG1mdcXZyztWdpStPIHGvWg+MTDRcLNNJQKBQ4O+fP1l7ALTP2OC0tXdI47O3tnosTdnN1Ra/XS9qNSk1LI3/+fCbn5mmN1FTz15Gl4ebq+tyR3gJubpLu69Maz+Lm6irp+wTQCyKuds8ffy9gZy3Rjc88juP2jIZSIeBiK01DtvPnxyHb+fMaz1LATbqdp6al4eri8lx75u/Kq49DqVTi4pxf0jjeJTuXkZGRkZGReT+RHXmJODg4UKtGdZatWoNerze179yzl4ePHtG8SWOzGsWLFaV4saL89c+KbMd6/1m9Fr1eL0mjauVK5MuXl7/+WZmtfcnyf7CysqJhvbpmNRrUrYuVlRV/LV/xjMYK8ubNQ/WqVcxqNGvcCKPRyPJVa0xtoijy1z8rKFa0CCVLFDer0bxJY2Jj49i+a7epTa/Xs2zVampUqyopBrR5k8bcDLzFmXM+pja1Ws3KteslfZ9ZGqfOniPw1m1TW2JiIhu2bKNF0yaSNfYcOEhEZKSpLSoqmt37D0geR0Gjko1BESRkPHG5byekcjIynkISk9V5ikpWBj5ArX9yjN4nOoGbCamSNGQ7z45s589r5GTnu/ZJt/PmTRqzaduObEfPbwcFc+L0GQs0GrFq/QbUarWpzef8Bfxv3JSk8S7ZuYyMjIyMjMz7iZzsLgdelOzuyLETtOnSncreFenZtQshYWGsWLOOls2asmfrRklJmjZu2UbvQUNpWL8eHdu24XpAAOs2bWFQvz4s//N3SeP79Y8lfDRpCh+2bMEHzZvic+EiW3fs4ovPPuW7b76WpDF91mzm/DifLh3b06BuHY4cP8mBw0dY+MNcPhk/VpLG8LET+Gf1Wvr06E7VypXYtW8fp8/6sHb5Uvr26mG2vyiKdOzRm0NHjzOoXx9KlSjB5u078Lvuz75tmyUlNNPpdDT5sB3XA24wZEBfPNzdWbNhE2H37nPq0D7T0duXkZqaSp2mLYmKjmbYwAE4OjqwYs06kpKTOX/iKGVK51zG6GliYh5Ss1Ez9Ho9Qwf2RxAElq9ag0Kh4NLp47i7F8z2+ZySaSRhZKeQjou9DUMrFCFVZ2D5zfsodCKdRDtJiZgeYWC3oKZ4HnsGlCtETLqW5Tfvk9co0F60Q/mMRk7Jb2Q7z86bsPNOPftw8Mix987Oc+JuSCi1mzTHydGRIQP6kZqaxvLVayjg5saFk0dxcnIyq3Hlqh+NWrWlaJHC9O/dk5iHD1m+ai3eFcpz6tA+rK2tzWq8jXb+tia7y83Iye6y8y4lRMsNSatyE+/SvZWR+bfIDfOGJcnuZEc+B17kyAOcPnuO2T/Mx+fCRVyc8zO4f1+++OxTi0pA7TtwiO9/WsjVa/54ergzcsggPhk/9rljsy9j45ZtLFj0G4G3gyhetCgTxoxkxJBBkss3iaLIspWrWbT4T0Lv3aecVxk++2i85EzLkJnBetHiP1myfAURkVFUrVyJLz77hHatP5SsodFo+HHhL/yzei2xcfHUrVWT6VMm0bhhA8kaKSkpzP5hPms3biYlNZWmjRowY+oUalSrKlkjNjaOWd99z+ZtO9FoNbRu2ZKvp00xxc9K4UF4ODPnfM/Ox7Gxndq15etpUyiaQymkF00UiRi5jIZwwYASgeKikhpYY2fB4ZlYDFxBS6RgwBqBkqKS6tjk+JD6ooVdtvMnyHaeHUvs/EXcDgpm1twf2H/4MNZW1vTo2pmvp055LgziZVz1u8as737g+KkzODk60rdnd776YrKkFwFZvG12Ljvybx7Zkc/Ou+Ts5YYH8tzEu3RvZWT+LXLDvCE78q/Jyxx5GZk3QW6YKEBe2GVk3iZkR/7NIzvy2XmX1oTcss7mFt6leysj82+RG+YNufycjIyMjIyMjIyMjIyMjMw7iuzIy8jIyMjIyMjIyMjIyMi8Raj+3wOQkZGRkZGRkXkbicdAMiL5UZD3FfZGRERiMZKGiAsKnF5R4yFGMhBxRYHDK2gYEYnBwN4DB6lbqxYuz5RElIJWq+XMOR80Gi0N6tV5pfAPtVrNmXO+iKJIw/p1sbe3t1gjOTmZc74XiECPO8rnkrxKIQORhxhQAe4oUbyCRjpGHmHEBoGCKBBeQSMFI3EYcUDA9RU1kjCSgJGAGzfxrljB4v4AN24GEhIWRjkvL0mJUZ9FFEWu+l0jIiqKyt4VKVa06CtpnL94idi4OGpUrYqHh7vFGgaDgXO+50lOSXln7Nza2oqG9etJSvL6LHFx8Zy/eAlHRwca1KtrUW6XLKKjY7h09Souzs7UqVUThcLy+ef+gwdc8w+gkIcH1apWkZwH6WmC79zlVlAQJYoVey07D0P/f53PLUV25GVkZGRkZGTeaw4oNLQ0WmMv8cErHSPHlTrCDVpTW3GFNU2N1thIdLaSMXJMqSXGkFlyVADKCNY0Eq1RSdSIw8BxpY64xxoKQaCCqKIeNpKdz2j0nFDqSTLo2NWtFzY2Nnz+6UfMmj5N8gP1vgOHGDZ2AtExMQA4Ojoye8aXfDxujKT+AGs3bOKjyVOIj08AIH/+fPzy4/cM6Ntbssavfyxh2sxvSU1NBcBBqaKRwYpiEh93RUQuo+W6Qo/OaAQgr9KKJgYVHhI1jIj4oOEmOoyP25wFJc1FG1wklpLVI3IaDcHoyEpkVVBQ0ly0JY9EG9UickKhJdSYaaMHa9enSaMGbFixXFKFEcisVNJn8DCOnzptauvQtjWr/15C3rx5JWmEhoXRc8AQLl25CoAgCPTr1YOlvy/C1tZWkoZ/wA16DRpqKp+qUqkYPXwIP//4vWTn86yPL/2HjSTs3n2Ad8rOCxYowN+LF9G+TWtJ/UVRZNbc7/nhp1/IyMgAoFjRIqz+ewmNGtSXpGEwGJg4ZRqLly4zlXEtV9aLjSuXU7mStySNjIwMRk34hNXrN5rKuNaoVpVNq1dIKu8LmS80Bo4Yzc49+0xtb8LO/x/z+asgH62XkZGRkZGRea/R53PiqFKHiLT8v8eUOrT5nNiydiURdwJZ/fcS4u2tOS1ozXcm09k7pNRiX8idfds2Ex58k99/XsA9K/BBI0lDh8gBpRbPsqU5vn83928H8N03MwlUGLiKtHGoMXJAoaVizWr4HD9M6M1rTPp4At9+P4+l/6yUpBEUfIcuffpTvWoVrpw9SdC1ywzq14dPPp/Kzj17JWn4nL/AgOGj+LBFCwIu+nDjki9tW7Vi0MgxnPM9L0lj9779fDRpCgP69CLo2mWunjtF05bNOSxoSMAgSeMWOi6jZdLETwi54YfP8cN416rOQYWWdJNb/nL80HITHbPrlSNkYHOOdq5Lofz2HBAynnLLX44vGu4p9PzSuCJhg1qwp30t7B2tOSioMUrUOCVoibWzYuVffxBxJ5Bt61cTFHyX7v0HITXPdc+Bgwm8HZTNzk+f82HY2AmS+hsMBtp160VCYuITO184ny07dvHZ1OmSNNLT0/mwUzesraxMdj7n66/4Y+ly5vw4X5LGw4ePaNu1J4ULFXon7bxWjWp06zuQW7eDJGksW7maWXN/4NPxY012XrRIYdp160V0dIwkje8XLOS3JUuZPWM6928HcOLAHmxtbPiwUzfS0tIkaUz+8is2bdvBbz/NIzz4Jvu3byEpOZm2XXtgMEj7nR0+7iNOnD7zxu38v57PXxU5a30OyFnrZf5tckNWTJCz2MrIvE3IWevfPFnr/YaVy+g9aBhdscfNzK5pLAa2ks6OjWvp1L6dqf3vFasYOe4j+uKAo5l9kgfo2Yca3xNHqFOrpql9zo/zmfXtXPob7c1m0b+NjpOChuDrVyhVsoSpfcJnk/ln6T/0Ndia3ZX3Q4OfNUTcuZXtmHHPAYMJuBnIzcvmnYvPvviS1es3cv92gGmHVRRFmrZuh1Kh5Nj+3WY1+g0ZwWU/P25ePm86mms0GvGuVY8q3t6sX7nMrEbLdp3QaLWcOrTPtMOakZFB0TIVKBifQgPM7/5uVWlo3LYVW9evMbXFxydQqFRZKmuhGi8vTSkisk5Ip3/FIvza5MmuZGhyOmVXH6cxtpTD6qUaOkRWC2lMq1WG6bXKmNovxiRSf8tZ2mBHUTOnA1Ixso40/vz1Z0YOHWxq371vPx179OHSmRNmS5f6XbtOtfqNc7bz8R9z75Y/RQoXfqnGwcNHad25W452PvuH+cSEBpmdy1auWceQ0eNytPONW7YTFXLb7K78jz/9wtdzviM86OY7a+fFy1emd/eu/Dzve7MalWrVp6xXabasXWVqi49PoLBXBb6aMpmpkye+tL/RaMSzVDm6de7I7wufvEwJDQujlHc1li3+lSED+79UIzU1lQLFy/DFZ58wY+oUU/vFy1eo3bg5e7duom3rVi/VCI+IoGhZb/5ctPDfsfNxH9EHB7NH5N/EfP40lmStl4/Wy8j8H3gTDvSbeBnwJjTklwEyMjJvO/Xq1Aag16rf6dmty0s/u2X7Trb2H0Sj+tmPoDaqXw8RGHFgI00aNXypxu9LlnLo86nUrlkjW3vDenXRGY18fuUY5cp6vVRjxrdzCF61NptzkzmO+vz251J+CA8gf/58L9UYOf5jdFf9nosVblS/Xrajqi/jTkgItWpUz3ZMWhAEGtarx+r1GyVp3A0NpX6d2tniaxUKBfXr1Oaaf4Bkjd7du2U7Jm1ra0udOrUA+HOL+bGsdHF/7mixs3N+KpQrR/L1QLP9dUCqaKShZ/bvs0QeezzsbUhON7+rn46IThRp6JE/W3vNAnmxUggkGc1rpDzet29Yr2629kb16wHwRcPWlDLzQiEE3eM+Odi5KBISGmbWkb8TEoJKpcrRzjMyMoiMijbrqNwNDcXTw+OFdp6cnGLWzu+EhFChXNl32s5r1ajG3dBQydcybFB2R9vZOT/eFcpL0khNTSXm4UOTPWVRonhxChcqxJ0Q8xpR0TGo1ernNGpWr4a1tTV3QkLMaoSG3cvMM/ACO78bEmrWkc8a64vm85H/0Xz+NMnJyfzjIS2PhHy0XkZGRkZGRua95sw5HwC8JCTyyvrMidOns7WfOH0GQRCeczhy1iiNXq9/7jjtyTNnsbe3p5Cnh1mNMqVKEREZSVDwnefGUbBAAfLkcZI0jhuBt3j0KPY5Da/Spc32z9I4f+kS6enppjZRFDl55qyk7xOgTKmSnD7nk+04rcFg4PQ5H8qWKfOSnk9rlOLkmbPZjtOq1Wp8L16y4FoyNZ4mNjaOG7dukVfCjpoV4CgoOBkRl639TmIaUekaSQm07BGwEgRORsRna/eNSURnFMknQSPP48R4z17LidNnACSNI+szsp0/0XjX7dz/xk1JGo6OjrgXLGiypyzu3A0hPCJC0vfh4V4Qe3v75zR8L1xEq9VK+j5KlSyBQqF4oZ2/TfP5qyI78jIyMjIyMjLvNR9PnkqTRg2oWqWy2c9WruRN8yaNGf3RRNZu2ETYvXv8vWIVn0//mh5dO1O4UCGzGi2aNcG7QgX6DR3B9l27CQ0L4+ffFjN33k8MHzQAJyfzzkn3Lp0oXKgQXfsM4ODho9y5G8K33//IkmX/8NHYUZKSgA3q1wc7O1s69OjNiVOnuR0UzORpX7Ft524+GT/abH+AUcOGkJaWTude/fC9cJGAGzcZOf5jzvr48sl4aUnAJowZRUhoGL0GDuHKVT+u+l2jz+Bh3LkbwoQxIyVpfDJuDD7nLzB87AQCbtzE98JFOvfqR0pKKqOHD5Wk8en4sezYvZfPvviSW7eDOHn6DO279UQwGChrZgcbQCAz2eDfN+4z+2IwdxLTOHz/EV33XsJRUFBSwkFYKwTKiSp+uHyHn/1CCElKZ2dINP0OXMFFUFJIQsI8BxSUElRMnvYVS/9ZSdi9e6zftIURYydQSGmNqwQNF5QUVlozctzHsp3z7tt5x559sLGxZnD/vmb7KxQKPh47mr+Wr+Cb737gzt0QDh05Rpfe/fFwd6dH185mNRwdHRk5ZBDfL/iZhb/+TkhoGDt276HvkOFUKF+Ols2bmtXw9PCgV7euTPlqZjY7HzXh07duPn9V5Bj5HJBj5GXeBuQ4exmZ9ws5Rv7Nk7XeN2/SmA0rl+Pm5iqpX2xsHAOGj+LA4SNA5hHbbp07svyP3yQ/tN1/8IC+Q0Zw1scXAKVSyeD+ffl94XxsbF4ei51F4K3b9B40lOsBNwCwtrZmwuiR/DjnG8lloC5cukz/YSMJvnMXAHt7e6ZNnsi0yZ9JzuZ9+Ohxho4ZT3hEBAB58+bhu1lfM2bEMEn9ATZt3c74iZN5FJu5a+rm6sqi+T/Qu0c3yRpLlv3DlK++JikpGYDChQrx9++L+PCDFpL6i6LI9/MXMmfeAlPCrvwqK5rorSgoMeO8iIgvGm6gM6XYcxOUNBNtyC9Rw4DIGTQEPZX53kNQ0ky0lVzSSofIKYWWu0atKT1eUaU1TQ1W2EnUUGPkhELH/ceZ72U7f3ftvHSpkqz+ewl1a9eSpGE0Gpky/WsW/bEErTbTPip7V2T9imVUKF9OkoZWq2Xcp5P4Z/Va0ymFenVqs37F35JLFKampjJs7AQ2b9thOqXQqkVz1iz7662bz7OwZK2XHfkckB15mbcB2ZGXkXm/kB35N8/rrvdBwXcIu3cfrzKlKF6s2CuNIeDGTSKjovGuWB5PD8uPYIqiiN+168TGxVO1ciXJD69PYzQauXj5CikpqdSsXpV8+fJZrKHX6zl/8RIajYY6tWri4OBgsYZGo8H3wkUA6tauZfEDMEBaWhrnL17C2tqaurVroVJZng4qKSmJi5ev8nuHvhR4xfrt6sc14G1eowZ8GkbiH9eRd5b4EuBZUjCSiBEnFJKO5edEIkaG7lwt2znvpp07OTlSq0b1V6oBHxsbx9Vr13Fxzv/KNeAjo6IIuBGIp4f7K9eAD7t3j6DguxQvVhSvMtJCDJ4lN8znIDvyr43syMu8DciOvIzM+4XsyL955PVe5mXklnU2NyCv9TIy/w2WrPVyjLyMjIyMjIyMjIyMjIyMzFuE7MjLyMjIyMjIyMjIyMjIyLxFyI68hRw9fpKmrdthk78AnqXKMe3rb1Cr1RZp7Ni9hzpNWmCdz43i5Ssxd94CdDqdRRqr1q6nSp0GWOdzo2zVmvz6xxKMEmqLZiGKIr/9+RflqtXCOp8blWvXZ+WadVgSaaHX6/lu3k+UqFAZ63xu1G7cnO27dlt0HWq1mi9nfotnqXLY5C9Akw/bcuTYCYs0kpKS+GTyF7gVK4Wtc0Fad+pmij2SSkzMQ0aO/5j8hYph7+pB1z79Cbhx0yKNsHv36D90JE4FC+NUsDD9howgJDTMIo0bNwPp2qc/9q4e5PMsyohxHxEdHWORxkMM7CedZaSwWkjlLBlosCyCJhw9e4R0/iaFtUIa59Ggt1BDtvMnyHaenTdh5xcuXaZN5+7YOhfErVgpPp405X/t3XVcFPkfx/EXCogKBiZ2Ynd3gd2FWFjnGaeeZ3vm2XHq2d3d3QGiCHomKthIi6iIgOTO7w+O1VVkB8/fuern+Xj4h8PMm5ndz+x3v8zM90tISEiyMr6Xz3MhhBBC/HikI58Mx0+epmHLNkRFRTNryiTat2nJgiXLaNWxs+qOweZtO2jTqSsW5ubMnT4F2/r1mDh1Br36DVS9H/MWLsahb3/y58vLvJnTqFS+PENGjGbk7xNUZ4weP4lBw0ZSvkwZ5s2cRsEC+enx8wDmLlikOqN3/1+YMHU6DerWYe70KaRPl4629t3YuGWbqu0VRaFNp67MW7SEdq1bMGvKJGJiYmnUqi1Hj59UlREdHY1tizas27yVHl06M23iOAKfPaNu4+a4XflbVUZoaCi1GzVl/6EjDOz7ExNGj+T2XQ9q2DTm3v0HqjICAgKpXr8RThcuMnLoYEYOHYyzyyVqNGiEf0CAqoz7Dx5Sw6YR7nfuMmH0SAb168uBw0ep1bAJr1+/VpURRByHeItFxtRMq16U/mXz42Ws4ajRW+JUdsS9ieUob8mRxZxZNYvjUDIPniliOWkUiaIyQ+r8HUVRaGvfTer8H1+izq9cvUadRs3wDwhg6oRx9OzahfVbtmHTvLV29Fx9vqfPcyGEEEL8eGSwu0R8avCbijXrYm6eljNHDmrnrTx87Dgt2nfi9OEDNKhXJ8ncuLg4CpQoQ+WKFdi5ab12ZMc1GzbSZ8Bg3C+76B2tMTw8nJyFi9G1kx2L583RLp8+508mTp3BU093vaMkBgY+I0/RkkwYM5Jxo0Zolw8ePpINW7bj9+Au5ubmSWbc9fCkRMWqrFz8Fz/1dADiOyz2PXrj4nqZx3du6B1B85zTeeo3bcmBnVtp2awpEP8a2TZvTcjr11xzOZ/k9gDbd+3BvkdvXB1PU6VSRSB+NNDKteuTw8qKY/t36834a8kyho8dz92rbhQuVBCAN2/eUKJiNerXqcX6lcv0ZoyZMJmlq9Zw7/oVsmfPBkBQ0HOsy1agX+9ezJwySW9Gr34DOXXWkTt/X9LW3cNHjyleoQqzpkxi6CDdzkFig/Ac5y1pMppxxa4mqf6p0SvPQqi++yL1MaOwinlw9xtFYJ09HadaVyNlivgaPeL1jNZH/qYZqcn1wTy4Hw6AI3Wu63uq87ET/2DJytX/aZ0nplnbjnj7+PL3hXPa0X6vXL1G5dr12bJ2FZ3tOujN+BY/z2Wwuy9PBrsTSZHB7t6Rwe6E+G/IYHf/B2FhYVy9foOeXbtov/QBNGvciGxZs+Lo7Kw3w+upN94+vvTu3k1neobune0xNjbG0fmC3oyb7rd5/TqU3t276izv3b0bsbGxuLhe1pvh4uZGTEwMvbt301nex6E7oaGhXL95S2+G04WLpEyZEocu9tplRkZG9OrWFR9fX1W32jpduEiWzJlp0bSJdlnKlCnp2a0L12/eUnV1ztH5AiWKFdN2bgBSpUpFN/tOql7PhIw6NWtoOzcAFhYWdGzbWnWG04WLNG/cSNu5AciaNQstmjTm3Hn9tZGQ0aFNK52TtlDBAtStVVP1fvgbxdG9aC5tJx6gUrYMlMhojr92RttPi0HhmRJHj+J5tJ14gKZ5s5LZzIQAFRlS5x9nfC917uh8wSDq3NH5At3s7XSm7KlUoTylS5ZQlfE9fZ4LIYQQ4sckHXmVTE1NMTU1JfBZkM7y8PBw3oSFkc5C/1/yzf+ZazLwme6zoM+Dg4mNjSWdhYXeDIt/riB+uB8JmRZ6rjAC2n39cD8C/nlGVe1+xMXF8Tw4+LP3w8LcnLDwcMLCwj7ICMLExAQzMzO9GeksLAh+8YLY2Fid5QGBgar2ISEj8FnQR7fTBj4LUvVaQPyxfPh6fl6G7vuqKAqBz55hYa4uIxVGBEZE6SyL1Wh4/jYaUxXbpwBSAs8+yAiPiSM8Jg4TFfPgSp1/nCF1/mHGv6vz+GPR3Y/Y2FieB79Q9Xp8T5/nQgghhPgxSUdeJVNTUzq2bc28RUtwv30HiL+1dcTvE4iKisKufRu9GdmyZcWmXl2mzp6rvZIXFhbGkBGjSZs2La2aN9WbUbJEcUqXLMHvk6cQEBAIwKtXIQwbMw6r7NmpV6eW3ow6tWqQM0cOho0Zx8uXr4D425DHTvqDksWLU7pUSb0ZLZs1wdzcnMHDR2k7KE+8vJgyaw4N6tbByiq73oyO7doQHR3NsDHjiIyMBOD2nbv8uXAxHdq01rna9imdO7bnWVAQE6ZM1w4w5Xr5CqvWb6Rrp456twfoYteROx4e/LVkmXaAqeMnT7Nz7z662KnN6MBZp/Ns3rYDRVFQFIWtO3Zx+pxjsvZj9/4D2uemNRoNi5atwP3OXdUZBZSUrLr9FJeAl0B8J37KlQcERUZTSMVt9SkxogDGzLv2CPcXoQBExcUxysWDqDgNBUn6NnKQOv9Qx3ZtiImJ+S7qvGunjgZR513sOrBq/UZcXN2A+E785OkzCQgMpIuK2+q/p89zIYQQQvyY5Bn5RHzqmblnz4Ko36wldz08KV2yBL7+/rx6FcKKRQu0z8/q8/iJF/WaNMfXz5/SJUvw2Ospb9++ZfuGNbRt1VJVxo2bt7Bt2YbXr0MpWbwY9x48xMjIiEO7tlGvTm1VGU7OF2jevhNxcXEUtS7MHQ9PLCzMOXlgL+XLlVWVsf/QYey69yJVqlQUzJ8P9zt3yWFlxdmjBylUsICqjDUbNtL3l1/JkCE9uXLk4NbtOxQtYs25o4d0bt9Nysy58xkzcTLZsmYlUyZL7np4UrliBU4e3Ev69On1bq8oCr+NGsuCJcvImSMHadOm4f6DhzRsUJ+Du7ap6mhpNBq69+nHlh07yZc3D0ZGRjzxeop9h/ZsWrNC5/bdT4mKiqK1XReOnzqNdeFCRES8xdfPj8H9f2bBnJk6t+9C4s/uRaNwzOgtgUocRdKn5UVUNMGRMVTClPLoPw6ACDQcNYrkhRJH8Yzm+IdH8jo6llqkolgi1/UTe25O6lyX1Pk7ya3zxISGhtLon1H7ixcryosXL3kWFMTUieP4feRwvdvDt/l5Ls/If3nyjLxIijwj/448Iy/EfyM5bb105BORVMP+9u1bdu7Zx6XLV8icKRPd7O0oYl04Wflv3rxh687dXL95ixxW2eneuRP58uZNVsbLl6/YuHUbnvcfkC9PHhy62Ku6Ovi+wMBnbNiyjcdeXhS1LoxDl85YWmZMVsZTb282bNmGf0AgZUuXootdByxU3mKb4N79B2zatoPgFy+oWqkidu3bkjp16mRl3Lzlztadu3kTFkbdWjVp3aIZpqZqbiZ/x/XyFXbt3U9kVBRNGtrQpKGtqo5JAkVROOd0ngOHj6Kg0KpZM+rXra2qY5IgLi6OYydPcfzUGUxNTGjfphXVq1ZJdN1PfcGIQ8GLWPyJvxW+EMZkRv1xAMSi8IhYnhGHGUZYY0KGT9zA86nGXepcl9T5O8mp80+JiYlh/6EjnDvvjIW5OfYd2lG2TOlkZXxrn+fSkf/ypCMvkiId+XekIy/Ef0M68v+SNOziW2AoXzCkcRfivyEd+S9P2nuRFENpZw2BtPVC/Ddk1HohhBBCCCGEEOI7JR15IYQQQgghhBDiG6J/CGohhBBCiO/Yk6felFExk4XONl5erF6/icdPvChapDB9enQnZ44cycq46+HJ2o2b8fMPoGzpUvR26EbmzJmSlXH1+g3Wb97CixevqFq5Ig5d7FUNgPk+54subNmxizdvwqhbuyZd7DqQJk0a1dsrisLJ02fZtW8/UVFRNLa1oUPb1skawyMuLo6DR45y4PBRIH7WkFbNmyVrDI/o6Gh27d3P8VOnMTU1pUOb1jSybZCsMTwiIiLYunM355ycuU4khTAmRzK/LkejcJ8YnhFHKowogglZkjlWzVs03COGYDSk/SfDMpkZ4WjwJIZXaLAgBcUwIV0yr+GF/pNh79Bb6vw7rXMLC3M6d2xP7Zo1VG8P8beAb9iyjUtuV8iUKSMOXTpTsXy5ZGUEB79g7cbN2nFmenXvSonixZKV4R8QwOr1G/HwvE/+fHnp06M7BfLnS1aGoXyeJ5c8I58IeWZOfAsM5dk9eW5OiP+GPCP/5SW096ampuzdtolmjRup2u7YiVO0se9KmjSpKVOqJH9fu4GRkRHH9+9WPXDj5m076PHzADJZWlKsqDVuV65iYW7OuWOHVH+RXbB4KUNHjSVXzpzkz5eHS25XyJUzB04njpAnt7o2YuzEP5gxdx4F8ucjW9asuF6+QolixXA8fphMmSz1bq8oCn0GDGLtxs0ULWKNhbk5V65eo0a1qpw4sIe0adPqzYiNjaV9l+4cOHxU+weVm+63ad6kEXu3bcbERP/0qRERETRu3Q7ni5eoWL4c4REReHjeo0fXzqxdvkRVJ+fly1fUa9Ic9zt3qVq5EgH+AXj5+FAGU6qqnPklDA1HUkbzBg1VKlbA6+lT/AOfUY1UlE5k5pfEvCKOI0aRxBgpVM6WAc9XYbyIjKEuZlirmEoW4BlxHDN6S8oURlTImoFbwaGEx8RiQ2ryqvzDhDexnEoRRdq0aSlXrozU+Xda50HPn/Po8RNGDh3CrKmT9W4P4OPrS51GzfDx9aNq5Uo89fbBx9eXP2dM5bfBv6jK8PC8R93GzXkdGkrVyhXxvPeA58HBrFu+hO5d7FVluF6+QqNW7dBoNFQsX5ab7reJiHjLnq0bv7nP8wTfzDPykyZNwsjISOdf9uzZdX5etGhR0qZNS8aMGbGxscHNzS3JzFWrVlGrVi0yZsyo3eby5cv/70MRQgghxDeqXu1a9Px5IFFRUXrXjYqKosfPA2hQtw4+9+5w7thhfO7dplSJ4vTsNxCNRqM349WrEPoO+pXOHdvjc/8OjseP4HX3FlmyZKb/r7+p2ucnXl4MGzOOob8MwMvjFudPHuP+zb+Ji9MwbMw4VRlXrl5jxtx5TJ80gQe3ruFy9iQ3XS/gF+DPxGkzVGUcPnactRs3s2bpIu5edePy+bNcOH2cq9dvMG/RElUZ6zdv5eCRYxzYuZUbrhe44XqBQ7u3c+T4SdZv3qoqY/7ipVz++xrOp45xxfkcd/52Zd3yJazfvJVDR4+pypg0fQbevr7cuOSMy9mTPPa4xawpk7lJNM+IU5XhahRN6kwZuX/zKhfPnsT7/l2GDf4FV6J4jf7aALhgFEXOdKl52L0+59pW52kPG7oWyYkzkUSi//qbgsJ5oyhKZ0mHVw8bzrathndPGxrmzYKzUSRxKjLiUDifMgbbBvXxe+T5w9f5keMnvts6f3DrGrOmTGb2/L9wu/K3qoxhY8YRHR3DvRt/43zqGE/u3mTY4F8YPnY8jx4/UZXRb8hQMmWy5MmdmzgeP4L3vdt0s7fj58FDefnyld7tFUWhZ7+BFC9aBG/P25w7dhjf+3exrV/3m/s8/1xf/Rn5EiVKEBAQoP3n7u6u/Zm1tTWLFy/G3d2dCxcukC9fPho2bMjz588/mefo6Ii9vT3nzp3j0qVL5MmTh4YNG+Ln5/dfHI4QQgghvjGTfx/D8+Bgzjqe17uu4/kLBD1/zsw/JmqvwmXIkIEp48dy/8FDbty8pTfj0NFjvH37ljnTpmhvy82WLSvjRg7H+eIl/Pz99Wbs2nsAMzMzpk4cp70tN3++fAz9pT/7Dh4mMjJSb8b2XXvIYWXFyN+GkCJF/FfCUiVL0LdnD7bv3qN3e4Adu/dRplRJejl0014NrFGtKp3at2X77r2qMrbv2oNt/Xq0bNZUu6x5k8Y0trVh287dKjP2YteuDTWrVwPAyMiIHt26UK5MabbvUrsfe/mphwOl/7laamRkxLAhv2CVLSuPiNG7fRwKT4hl2K+DtLf2pkyZkj/GjyV16tQ8VpERjgZ/JY6xlQphldYMANOUKZhVoxixgBexejNeoOGlEseUqkXJaBZ/lTeNSUqmVytGuKLgp+KPEv7EER4Xy6ypk6XOia+N773Oc+XMyfZd+l+PqKgo9h08zNBf+n9U52nTpmXX3v16MwICAjl/wYWxw3/TTrdqamrKnGlTiIyM5MDhI3ozbt5yx/PefaaM/52MGTMAkCZNGmb+Memb+zz/XF/9GXljY2Odq/Dv69y5s87/582bx5o1a7h16xYNGjRIdJstW7bo/H/VqlXs3r2bM2fO0L179y+z00IYALmlXQghvoyMGTIAEPE2Qu+6CeskfHH8OOOtioy3pEiRgnTpLBLNePtWf+fkbeRbUqc2w8zMTGe5ZcaMxMXFER0d/dHPEtuP9OnTffR8bsYMGYiI0H8c8RkRH70W7zL0v54AbyMjyZMrV6IZj728VGa81b5+77PMmFHV+wrxr8eHGSlTpsTSMhPVmjVl+aIFSW4fHh7O6qw5P8owMzMjdapUxKrYj4QutmUq3dvwLUyMMTYyIk7FE7EJXf0MqXRv1bb8p1Mfq+KKfMI6UucJGd9/nadPl07V+xobG0tsbGzidW5mxttI/Rlv//kDjGXGjDrLLSzMMTY21v48KQn7+uH7kpD5LX2ef66vfkX+wYMH5MiRg/z589OpUyceP36c6HrR0dGsXLmS9OnTU6ZMGdX5ERERxMTEYGn56edfoqKiCA0N1fknhBBCiB/DqvUbMDU1pVb16nrXrVW9OqlSpWLpyjXaZYqisHTVGjJmzECFcmX1ZjSoWweNRsPKteu1yzQaDctWryF/vryqBmqyqVeXFy9esnPPPu2ymJgYVq7bQOWKFVSNo2Bbvy4envdwPO+sXRYeHs76LVuxqVdH7/bxGfU4f8EF99t3tMtevnzF9t17sa1fT1WGTb06HDp2HG+fd3+g9vH15eDRY6r3w6ZeXXbs2ceLFy+1y+7c9cDR+QI29eqqyrCtX5cNW7cRHh6uXXb+wkXueHioykibNi3VqlRm1fqNREdHa5fv2X+QFyEh5FIxWJ0FRmQwSsHy20/RvNdpX33Xm1hFIaeKa3CZSUFqIyOW3/bi/aGwlrk/xRiwUrEf2UmJcYoUUufaDKnzBEnV+fPgYFUZ+fLmoWCB/CxbvUbn9vVV6zYQGxtLg7r6X49yZUpjaZmRpStX69T5kpWrv9jnefmy+vucX6LOP9dXHezu2LFjREREYG1tzbNnz5g6dSqenp7cuXOHTJniR/k7fPgwnTp1IiIiAisrK/bv30+lSpVU/46BAwdy4sQJbt++/cm/2E2aNInJkz8e3EEGuxNCCGEoZLC7Ly9hsDuACWNGMnncWFXb/TFjFhOnzqBpo4ZUr1qZM+ecOHfemSXz5zKgbx9VGQN+Hcby1Wtp17olZUqV5NDR41y5eo2dm9bTvk0rvdsrikL7Lt05eOQYnTu2p2CB/OzedwDP+w84cWAP9erU1psRGxuLTfNWuF25Sjd7O7Jny8q2XXsICHzGhVPHKFumtN6M8PBwqtdviJe3D90722FhbsGmbTuIjIrEzfGMqi+xwcEvqFS7HmHh4Th0tsfIyIgNW7aRJk1qrpw/R5YsmfVmeD19SuXaDTA1NaWbvR3hEeFs2LKdPLlycencSczNzfVm3LzlTk3bJmTLmoXOHdvzLOg5m7btoGL5spw5clDVYGROzhewbdGGIoUL06FtKx499mLLjp3k0aTAVkmFEfoHI3tMDKeJpFzmdLQqmJ1bwaHsfRRIMUyoRdJXnxPcJRpnoqhlZYltnsxcCnzFsafPKY8plVQO3HeVKP4mmia2DahRvZrUudS51od1/viJF1t27NIO3Kdm0L29Bw7SvosDFcuXo2WzJty6fYfd+w7Qt1cPli+cr3d7gBVr1tFv8FDq1q6JTb26uF6+wuFjJ765z/P3JaetN6hR68PDwylYsCAjR47kt99+0y4LCAggODiYVatWcfbsWdzc3MiaNavevNmzZzNz5kwcHR0pXfrTJ2lUVJTOgAihoaHkzp1bOvJCCCEMhnTkv7yEjvzyv+bRt3dP1dM3KYrC5m07WLR8JY+9vChWpAi/DRpAm5YtVP9ujUbDijXrWL56Lf6BgZQtVYpRv/2KTf26qjNiYmKYv2gp67ds5XlwMNUqV2LsiGFUraz+gkdERASz5i3QmZZr3MjhlCpZQnXGq1chTJ/zJzv37iMqKpomDW0YN2oEBQvkV50REBDI1NlzOXD4KIqi0LpFM34fOYwcVlaqMx4/8WLqrDkcO3kaU1MTOrRpzdgRw7C0zKh/43/cvnOXqbPn6kzLNeq3X1WNSp7A7crfTJ/zJy5ul1FC3lAoFkphSkoVnfgEvsRyyyiGl2hIgxHWijElMFH1h4AEXsTgbhTDaxTMMaK4YkJhjFVnKCg8IJa7KTXEZjD/V3W+Ys06/AICpM6/0zrPnCkTPbp0ZuigAcmaju/MOSdmzVvA9Vu3yJE9O3179aD/T721YxmoceDwEf5cuBiPe/fJlycPg/r1pVvnTl/l8/zf1HmCb7YjD2Bra0uhQoVYtmxZoj8vXLgwvXr1YsyYMUnmzJ07l6lTp3L69GkqVqyYrH2Q6eeEEEIYGunIf3nS3ov/N0OZKvbfknF5hPhvfDPTz30oKioKDw8PrJL4q5SiKHqnE5gzZw5Tpkzh+PHjye7ECyGEEEIIIYQQhuyrduSHDx+Ok5MTT548wc3Njfbt2xMaGoqDgwPh4eGMHTsWV1dXnj59yrVr1+jTpw++vr506NBBm9G9e3edq/OzZ89m3LhxrF27lnz58hEYGEhgYCBhYWFf4xCFEEIIIYQQQogv6qtOP+fr64u9vT3BwcFkyZKFqlWr4urqSt68eYmMjMTT05MNGzYQHBxMpkyZqFSpEs7OzpQo8e55Fm9vb53nKJYuXUp0dDTt27fX+V0TJ05k0qRJX2S/vX18uHL1GpksLalVo/pH01mo8eDhI2663yaHVXaqVams+jmO992+cxfP+w/IlzcPFcqVTXaGoihcu3GTJ15PKWpdmJIliid7HxRF4ZLbZfwDAilTqiSFCxVMdkZcXBzOF1148fIlFcuXI2+ePMnOiImJwfH8Bd6EvaF6lSpkz54t2RmRkZGcdTxPdEw0tWvUSNazRgnevHmDo/MFAOrWqomFhYWeLT728uUrzl+8iKmJKfXq1CJ16tTJznj2LIiLrq6YpzWnbu2ayXpeKYHUuW6G1Pk7Uue6DKHOhRBCCPFj+aod+e3bt3/yZ2ZmZuzdu1dvhqOjo87/vVTOw/g5YmNjGTh0OKvXb9ROlZA/X152bd6gahoOgLdv39Lj5wE602iULF6cPVs3Yl24kKqMV69CsO/RmxOnz2iXVa1cid1bNpAzRw5VGf4BAbTv4sAlt8vaZbb167F9w1rVX+wfPHxEu87dcL9zV7usfZtWbFi5jDRp0qjKuHb9Bh269eDxEy8AUqRIQa/uXVm64E9Vo2YCOJ53pkuvvvgHBABgbGzM0F8GMGvqZNVfhvcdPMRPvwzRTudhZmbGpLGjGTXsV1XbA6zdsIlfR43lzZs3AJibmzN/1nT69OiuOmPO/IVMmDqdyIT5NS0zsmrxX7Rt1VLV9oqiMGbCZOYtWkJMTAwAVtmzs3nNCuqrmMoDpM4/JHWuS+r8HUOpcyGEEEL8eAzqGXlDN3XWHNZu3My8mdN49uQBro6nyZwpE01at9d+qdXnt9G/c/jYCdYsXUSw92POHTtEbFwsTdt2IDY2VlVGr/4DuXLtGjs2ruOFzxOO7t2Fn38A7Tp3R83YhfFTeTjg4+vH4T07eOHzhJ2b1nPt5k169hugah9iY2Np1q4j0TExnD16kGDvx6xdtpijJ04xdJS66R7CwsJo0qYDlhkzcuncKYK8HjJ/1nTWb97KlJmzVWUEBj6jeftOFLUuzLWLTvg/9GTi2FHMWbCQpStXq8rw8LxHx249qV2jOnevuuF97zYD+/Zh9IRJ7N53QFXGBZdL9B4wiHatWvDQ/ToP3a/TsW1rfho4mPMXLqrK2HvgICPHTaB/n1489XTn7lU36taqiV33Xty566EqY/nqtcyat4Bxo4bj/9CT6y7nKV60CC07dtZ2APWROn9H6lyX1LkuQ6hzIYQQQvyYDG7UekOQ2Ci2Go2GbPkL07lDe/6aO0u7rrePD/mLl2Hl4gX0dkj6ilRoaCjZ8lszfvQIxo4Ypl1+7foNKtSsy6Hd22nepHGSGT6+vuQtWorVSxbSy6GbdvmxE6do2rYDl8+fpVKF8klmJPy+w3t20KxxI+3ydRs306v/L3h53NJ72+/R4ydp1q4jf19w1Ll6NXPufCZNn8mzJ/e1c/N+yrqNm+k9YBCP79wgX9682uVDR45h0/YdPHvyQO9trjPnzmfKrDn4PbhLhgwZtMvtHXpz/dYtPK9fSXL7hN+3bdcennq6kyrVu7lV6zdpQZwmDqcTR/Vm2Dv05ubt29y+ckn7qIeiKJSqVJ0SxYuyY+M6vRn1m7RAQeHcscPaZdHR0eQtWooObVuxcK7+Tl+JilUpVaI42zes1S4LCQkhl3UJxgwfyu8jhye5vdS5LqlzXVLn73yNOv9WR62fNGkSkydP1lmWLVs2AgMDtT/fvn07Pj4+mJqaUqFCBaZNm0aVKlU+mblq1So2btzI7du3AahQoQLTp0+ncuXKydo3GbVe/L/JqPVCiOT4ZketN2RhYWEEB7+gWhXdLwl5cucmZ44cPH7yVG/Gs6DnREZGUu2DeS/LlS2Dqamp9rbbpDz19kFRlI/mzqxWJf7/T7z078fjf9ap9sEXnupV4780eT311pvx5OlTjI2NKV+2zEf7ERUVRUDgM1UZOaysdDo38RmVefHiJaGh+q+KPfbyoqh1YZ3ODUD1qpVVvRYJGRXKldXp3CTsxxMv/a8FxB9L1UoVdcZrMDIyomrliqre13cZuu+rqakpFcuXVX8sT7yoWkl3poYMGTJQvGgRVRlS57qkznVJnb9jKHX+rShRogQBAQHaf+7u7tqfWVtbs3jxYtzd3blw4QL58uWjYcOGPH/+/JN5jo6O2Nvbc+7cOS5dukSePHlo2LAhfn5+/8XhCCGEEF+ddORVMjc3J4eVFWccnXSW37v/AB9fX4oVsdabkcMqO+bm5pxxPK+z/OIlV6KjoylWpIjejIL585MyZcqP9iPh/0WtC+vNSFjnw4zT5xxJkSKFqoG8ilpbExsbi/NFl4/2I23atOTKqf/ZzqLW1vj5++Phee+jDKvs2UmfXv/VkWJFrLl914PADzpUp885qnot4jOK4Hrlis7MBoqicNbpvKr3FeJfU0fnCzq308bGxuLofCEZGdacdTqvcztteHg4ly5foai1uoxiReIz3hcU9Jxbt++oypA6/zBD6vx9UufvGEqdfyuMjY3Jnj279l+WLFm0P+vcuTM2NjYUKFCAEiVKMG/ePEJDQ7l169Yn87Zs2cKAAQMoW7YsRYsWZdWqVWg0Gs6cOfPJbYQQQojviXTkVUqRIgW/DRrA6vUbGTvxD27fucvBI0dp3akLeXLnol1r/YM0pU2blv59ejFr3gJmzJmHh+c9duzei32PPpQpVZIG9fQP0mRllZ0udh0YPWEyi5atwPPefdZv2sLPg4diU68upUuV1JtRskRxGtk0oN+QoazdsAnPe/dZsmIVo8ZPwr5De3JYWenNqFenFmVLl6JLr75s37UHD897zJw7n5l/LqBf756Ym5vrzWjbqgV58+SmdacuHDh8hNt37jJu8lRWrdvA0F8G6Fz1+5Tune2xsDCnWbuOnDh1hpu33Bk8fCQHjxxj2OBf9G4P8HPvHkRGRtG8vR2O5525ev0GDj/1w/XyFYb+ou5Z6sH9f8bH14+29l1xcXXjkttl2nXuhtdTbwYP6KcqY+gvA7j891W69f6Zv69dx8n5Ai3adyIi4i39+vRSlTFs8C8cOnqcgUOHc+PmLU6ePkuzdh1JmzYNPbp21ru91LkuqXNdUufvGEqdfysePHhAjhw5yJ8/P506deLx48eJrhcdHc3KlStJnz49ZcqUSXSdxERERBATE4OlpWWS60VFRREaGqrzTwghhPgWyTPyifjUM3OKojBhyjTmLVpKREQEAJUqlGfzmpWqRyiOiYnht9FjWbl2A9HR0QDUq12LTWtWqB6hOCIign6Dh7J1527i4uIAaNmsCeuWL1U9EverVyH07DeAA4fjn4tNkSIFnTu2Z/nC+aRNm1ZVhn9AAN16/6y9MmZqakqfHt1ZMHuG6pG4Hzx8RNfefbn891UAUqdOzdBfBjBlwu+qOjgQ/0yqQ98B3L4bP6p4unTpGD9qBMN/HaRqe4gfEbzPwME8evwEgMyZMzHrj0k6z63qc+DwEQYOHYGfvz8AOaysWDxvNm1atlCdsX7TFkaMm0Bw8AsACuTPx6rFf6keiRtg/qIlTJ4xi9ev47+gFi9WlI2rlqseiVvqXJfUuS6p83f+6zr/Vp+RP3bsGBEREVhbW/Ps2TOmTp2Kp6cnd+7cIVOmTAAcPnyYTp06ERERgZWVFfv376fSB49gJGXgwIGcOHGC27dvY2Zm9sn1EnteH5Bn5MX/jTwjL4RIjuS09dKRT4S+wW9CQkJwv3OXTJaWFC9W9LN+x/PnwXjcu4dV9uyfNSc1xHcwHj56TN48uT9rTmqAp97ePPX2oVDBAqquUCbm4aPH+AcEUKxIEbJkyfxZGXc9PHnx8iWlShT/6DlgNRRF4Zb7bd6EhVG2dClVV0o/pNFouH7zFlFRUZQvWybJL4OfEhsby9XrNwAoX7aM6o7e+6Kiorh6/QampqaUL1tGdUfvfeHh4Vy/eQsLc3NKlyr5WXNSS53rkjp/R+pc139V599qR/5D4eHhFCxYkJEjR/Lbb79plwUEBBAcHMyqVas4e/Ysbm5uZM2aVW/e7NmzmTlzJo6OjpQuXTrJdaOiooiKitL+PzQ0lNy5c0tHXvzfSEdeCJEc0pH/l2QUWyGEEIbme+nIA9ja2lKoUCGWLVuW6M8LFy5Mr169GDNmTJI5c+fOZerUqZw+fZqKFSsmuW5ipL0X/2/SkRdCJIeMWi+EEEIIgxQVFYWHhwdWSdwdoyiKzpXzxMyZM4cpU6Zw/Pjxz+rECyGEEN8y6cgLIYQQ4v9m+PDhODk58eTJE9zc3Gjfvj2hoaE4ODgQHh7O2LFjcXV15enTp1y7do0+ffrg6+tLhw4dtBndu3fXuTo/e/Zsxo0bx9q1a8mXLx+BgYEEBgbqzMrwX9FoNF89Q1GU7yrj394sqtFoDCeDf5fxb7f/UhlS518+w2Bq1EAy/q3vKUMt6cgLIYQQ4v/G19cXe3t7ihQpQtu2bTE1NcXV1ZW8efOSMmVKPD09adeuHdbW1jRv3pznz5/j7OxMiRIltBne3t4EBARo/7906VKio6Np3749VlZW2n9z5879rH38a8nyZH350mg0/PnXIvIVK0VKC0usy1Rg5dr1yfoyGx0dzaRpM7AqUISUFpaUqVKD7bv2JGu/w8PDGT5mHJnzFCClhSVV6jTg6PGTycp4+fIV/Yf8RnqrPBiny0S9Js0/mnJTHz9/f7r3+Zm0WXJgmiELTdt04PqNm8nKePDwER26OpAqY1ZSZcxK+y7duf/gYbIybty8RbO2HTHNkIU0ma3o1rsvvn5+ycq44HKJ+k1aYJwuE+my56bf4KG8ePEyWRnHTpyial0bUlpYsillJJeIJCaZnemHxLDXOIqVhLHFOJIrRBGXjAwFBQ+i2WUcyUrC2G4cyQ2ik9WpV1C4STTbjSOlzpE6/9D7dZ45TwGGjf492X9M3bF7L2Wq1CClhSVWBYowcep07eCxaiiKwqp1GyhStiIpLSzJW7Qkc+Yv/CY/zz+HPCOfCHlmTgghhKH5np6RNxQJ7b2RkRG/9PuJhXNnq9pu6Mgx/LV0OT26dqZalcqccXRix+69TJ04jt9HDleVYe/Qmz0HDtK3Vw9KlyzBwSPHOHL8BKuXLqS3Q3e922s0Gmybt8bt76v079OLggXys333Hs5fcGH/ji20bNZUb0ZUVBRV69rw1MeHAT/1IXu2rGzcup0bt9w5d+wQNapV1ZsREhJChZp1iYh4y8Cf+2CeNi2r1m/E28cX13OnKFG8mN4MP39/ylevQ5o0qenfpzcAy9esJSwsnGsuTuTKmVNvhofnParUtSF3rpz0cehGeEQES1euIVUqU65dPE/GjBn0Zlxyu0zdxs0pVaI4Pbp25llQEEtXrSF3zpy4Op5WNTjo4WPHadnBnlo1qtGpfTueeD1lyfKVZIyOo5kmFUboH5TTkxiciKSJrQ2tWzbH/c4dVqxeR544I2wUdQOUXieKy0TToU0rbBvUx/XyFdZv2kJxxZgaqMtwIZLbRrE4dLGnetUqUudS51qJ1fnSVWuoVKEcZ44cVDWA7bqNm+nV/xeaNmpIq+ZNcb9zh5VrN9C6RTN2bFynd3uAmXPnM2biZDq2a4NNvbq4XfmbdZu2MPDnPt/U5/n7ZLC7f0k68kIIIQyNdOS/vIT2/o9xY5k8YxZeHrf0fpn2DwggT5GSTJ0wjtHDh2qXDxv9OyvXbcD/oQcWFhZJZrjfvkPpKjVYu2wxPbt3BeKvLHXr/TPnzjvz1NMdY2PjJDNOn3XEtkVrjuzZSdPGDYH4Tk/jVu14FhTEDdcLemdy2LJ9J1179+XvC47aqRtjYmKoUqcBmTNl4uShfUluDzBv4WJGT5jMvRtXyJ8vHxB/BbVkpWrUrFaVTWtW6s0Y+fsEVq3fwP0bV7WzggQHv8C6bAV6d+/GnOlT9GY4/NQPpwsXuX3lknZGD6+nTylSthLTJo5XNVVn41btCHz2jMvnz2JqagrA9Rs3KV+jDhtXLadb5056M8pVq0UmS0tOHtqn7cycOHWGxq3b0ZTU5Cbp91WDwnbjKJq1acnWdau17+HGLdtw6Nuf9qQhEymTzIhBYUvKt/Tv15f5s2dol8+Zv5DR4ydir6TBXM9NueFo2GoUwbRJE6TOkTr/UFJ1fuLAXhra1E9y+9jYWPIVK03tGtXZsm7VR3V+45IzZUqXSjIjLCyMHIWK0bt714/qfMzEyV/k89zvwV297e2XqPP3yWB3QgghhBAqde7Ynri4OFwv/613XdfLV4iLi6NH1846y3t07UxYWBg3brnrzXB2uUTKlCnpam+nXWZkZESPrp3xDwjg8RMvFRkuZM2ShSaNbLXLUqRIQffOnbh1+w6hoaGq9qNUieLazg2AiYkJXew64OxySe/2CRl1atbQdm4A0qZNS4c2rZOV0axRI52pPTNnzkTzxo04r/L2Z2eXS7Rv3UpnWs58efNSt1ZNnF3UZ3Sx66jt3ACUK1uGMqVKqjqWhPe/e+dOOlckG9rUJ0umTAQSpzfjDQpvYmPo0aWzTgfVvmN7jI2NCVCR8YI4ohKpUYcu9mgUhSAVGc+IQ6MoUufvZUidx0uqzrNny6ZqP7yeeuPn749DF/uP6tzExETVftx0v82bN28SrfMv9Xl+0/223owvUeefS/2fB4QQQgghvkN+/zx/n17FnQ4Z0qcHwNffn+zZs2mX+/r5JysjLi6OwGfPyJ0r13sZfsnKCH3zRntXwfv7YWpqqur22Azp0/Ms6DkxMTGYmJjoZKjZh4SMew8eoiiKzhfy5Gb4Bfh/tNzPP0D7eqvJ8PXXzVAUBV9/fyqULaM+44NnjWNiYgh8FqTqWFKlSkWqVKk+2o83b94QFhFB5+njGTYk6SumQUHP2Z6/MH4fZDwLCiI2NpZ+q5fodBgSc+euBwcqVcPX31/nqmbCsY04uA3bBvWSzDjr6MSpZq2kzt/LkDqPl1Sdvw4NVXUs6f65myOxOo+JiVGV8f5ncWJ1/i19nn8uuSIvhBBCiB/amImTyZkjB/Xq1NK7bu2aNcidKxdDR40lKOg5AD6+voyeMIkypUpSqmQJPQnQomlj0qVLx8Chw3n9+jUA9+4/4I+Zs2nYoD7ZsmXVm2HXvi1xcXEMGTGaiIgIAK5dv8G8RUuwa9eGVKlS6c3o2qkjQc+fM2bCZO10f07OF1i1fiPd9HQW32XY4eF5j1l/LiA2NhZFUThw+Ai79u2nm73+W3QButnb4Xj+Ams2bESj0aDRaFi7YRNnnc6r3o9u9nbs2X+QfQcPoSgKsbGxzF2wiLsensnaj9UbNnHO6TwQ/2z175Om8CwoiK6dOurd3sTEhE7t2zJ/8VKuXr8BQEREBENHjSUmJga79m31ZmTNmoXGtjb8MXM2nvfuA/D69Wt++W0EFhYWtGqu/5nw4sWKUq5MacZMmIy3T/z878+fBzN09Fip88+s8272UucJpM51fYk6/1zyjHwi5Bl5IYQQhkaekf/yEtp7CwsLju7dSc3q1VRt5+LqRtO2HXj7NpJCBQtw7/4DMmfKxKlD+1R98QM4cvwE7bs4YGRkRL68efC8d598efNw9uhB8uXNqypj09bt9Ow3kDRp0mCVPRv3HzykVIninDlyUOf23aTMW7iYYWPGkTFjBiwzZuTR4yfUqFaV4/t369y++ymKojB24h/M/HM+WbNkIXVqM556+9C8SSP2bN2kc/vup2g0Gn4aOJi1GzeTw8oKiH92tUfXzqxZtljVwFnR0dF06OrAwSPHyJM7F5GRUQQ9f86IXwcza+pkvc9RQ/wtw03bdsD54iUKFsjPq5AQXr58xZxpU1Q9ewzxzzw3aNaSW7fvYF24EIHPgggPD2fN0kU4fHD77qc89famftOWPPF6StEi1jz19kGj0bBz0zpaNG2iKuP2nbvYtmjD8+BgilgX5uGjx5iZmXFkzw6pc6lzqfP3GEqdJ5DB7v4l6cgLIYQwNNKR//IS2vvHt2+QP3++ZG374sVLNm3brv0S2sWuQ7Lfl4CAQDZt24Gfvz9lS5fCrn1b0qRJk6wMr6dP2bx9J8HBL6hauRJtW7VQ1al4n+e9+2zduYs3b8KoW7smzRo3StbgTBA/WNaufQeIioqisa0NDerVUdUxSaAoCi6ubhw4fBSAVs2bUr1qFVUdkwQajYazjuc5dvIUpqamdGjTivLvPRetRlxcHEeOn+CckzMWFubYd2hPsaJFkpURHR3NvoOHueR2mUyZLOnaqaPOs9VqREREsHPPPq7fvEUOKyu6dbbTdv7UCg0NZevO3Xh43iNf3jx0s+9E5syZkpUhda5L6vwdqXNdX6LOQTry/5p05IUQQhga6ch/edLeCyGEMCQyar0QQgghhBBCCPGdko68EEIIIYQQQgjxDZHp55Lp5ctXrNmwiUuXL5PJ0pKe3bpQvWqVZGUEBj5j5br1XL95i5w5ctC7e1fKqZwyIsFTb29WrFmPx7175M+bl769elC0iHWyMu7df8DKtet57OVFUWtrfu7dI9kDMty85c6q9Ru1z4P07dkDK6vsycpwcXVj/eatBL94QdVKlejTozuWlhlVb68oCmfOObFlx05C37yhXu1aOHSxx+KfqS3U0Gg0HD52nJ179hMVHUVj2wZ0seuoalqTBLGxsezed4ADh4+ioNCqWVPat2mlM9WJPpGRkWzdsYvjp89gamJK+zYtadmsabKevwoLC2PDlm2cO++Medq0dLHriE39usl6/krqXJfU+TtS57oMpc6FEEII8WORK/LJ4PX0KWWr1WLcH1MJDX3DufPO1GjQiBlz5qnOcL99h5KVqzF7/kIiIt5y4PBRKtSsy5oNG1VnOF90oUTFaixbvYa3byPZsmMXpavUYP+hw6ozDh45SqnK1dm0bQdv30ayfM1aSlaqjpPzBdUZ6zZuplz12uw/dISIiLfMWbCIkpWrcfOWu+qMWX8uoEaDRpxxdOLNmzAmTJ1Omao1eeLlpTpj+Jhx2LZojdvfV3n56hVDR42lcp0G2mkk9NFoNDj81I9WHTtzx8ODwGdB/DRwCHUaNePNmzeqMqKjo2nRvhP2PXrz2MuLJ15P6dyzDy3adyI6OlpVRlhYGHUbN6fPwMH4BwRyx8ODNp260q33z2g0GlUZz58HU7lOA4aMGM2Lly+5fPUaDVu2YejIMaq2B6nzD32JOp897y+p83/8CHW+ev1/W+dCCCGE+PFIRz4Zho0Zh5ERPHS/xukjB7h/8ypjhv/G2El/8ODhI1UZ/X8dhlW27HjdvcWJg3t5cvcmvR26MXDoCIKDX+jdXqPR0HvAIMqVKY23522OH9iD973bNG/SiN4DBvH27Vu9GZGRkfQeMIimjWzxvhef4XPvDhXKlaH3gEGqvky/ePGSAUOH07NbF7w84o/lqYc7uXLkoP+vw1S9Fo8eP2HMxMmM+u1XHty6xqnD+3nofg1j45T8Nvp3VRmul68wb9ES/pwxlTt/u3Lu2GFuX7nE8+BgJkydrirj0NFjbN6+k81rVnL9kjPOp47h5nQG9zt3mfvXIlUZ6zZt4eSZsxzfvwc3pzO4OZ3h1KH9nDp7jjUbNqnKmLdoCbdu38HV8TQXTh/n+iVntq5bzdadu1R/qZ80fSbPgoJwv+zCuWOHufO3K/NnTeevpcu5eMlVVYbU+Ttfqs5HT5gkdf6PH6HOf/ntv6tzIYQQQvyYpCOvUlRUFAcOH+XXgf3JnSsXAClSpGDCmJFYWFiwe98BvRn+AQFcvOTK2BG/aadFMDY2ZsbkiURHR3PwyFG9GTdvufPg4SMm/z5ae0ttqlSpmDZxPC9fvuKs03m9GY7nLxAc/IJpE8drb6k1Nzdn8u9jePT4Cddu3NSbcejoMSIjI5n5xyTt1B2ZMlkydsQwLrldxtfPT2/G7n0HSJMmDRPHjtLeUpsrZ05+Hdifg0eOqfoSu3PPvvhtfhmgvaW2iHVh+vbswc69+/RuH5+xn3JlStOlU0ftskoVymPfoR079+5XmbGPRjYNaGTbQLvMpn5dmjS0TdZ+2LVrQ+WKFbTL7Du2p0K5sur3Y+8+furhoJ1CxMjIiMED+pEndy527tG/H1LnuqTOP94PqfN4hlLnQgghhPgxSUdepbi4OOLi4kiXTvd5VFNTU1KlMiUyKlJvRlRUFAAWFuY6y9OmTUOKFCmI/OfnSWb8c/vqh8/FJuxXlIqMhH398FjSWajPiIqOJkWKFKRNqzs/ooV5/LFFRqrJiCJVKtOP5gFNZ2GBRqMhNjZWb0ZkVJT29fswIypK3a2+kVGRH70WEH8sal4LiH89PnxfEzLUvBbxGVGJZsQfi7qMyMioj44lRYoUmJuba2snKVLnH++H1Pk7UufvGEqdCyGEEOLHJB15ldKkSUONalVZsWa9zperbTt3Exz8gkY2DZLYOl7ePHkoXKggS1asJi4uTrt82ao1xMXF0bBBfb0ZZUuXInPmTCxatgJFUbTLFy5dQapUqahdo4bejFrVq2NmZsbCpSu0yxRFYeGyFWTKZEmFcmX1ZtjUq4tGo2HpyjXaZXFxcSxZuZpCBQtQIH8+vRkNG9Tn5ctXbN2xS7ssKiqK5WvWUb1qFVWDeDWyqc+9+w84efqsdtmbN29Yu2kzjWz0v57xGQ1wvniJ6+9doQ0Kes62XXtUva/xx1KPQ0eP8/iJl3bZEy8vDh49RmNbtRn12bF7H8+eBWmX3bh5C6cLF1XvRyOb+qzbtIXQ0FDtstNnHbnr4anq9ZA61yV1/uGxSJ0nMJQ6F0IIIcSPyUh5/9uDACA0NJT06dPzOsCbdOnSaZdfvORKg2atyJsnN+1ateSxlxe79x2gXeuWbN+wVtVoyQePHKWtfTdKFCtKi6ZNuHX7NoeOHmdQ/74snDtb1f6t3bCJ3gMGUa1KZWzq1eGS2xVOn3Nk6sRx/D5yuKqMmXPnM2biZOrXqU2NalU4fc6JS26XWbVkIX16dFeV8euI0fy1dDnNmzSibOlSHDp6HPc7d9mzdSOtWzTXu72iKHTu0Yede/fRvk0rCubPz96Dh/B66s2pQ/uoVaO63oy4uDgat2rH+Ysu2LVrg1X27GzfvYeQ16FcOHWMUiVL6M14+/YttWyb4Hn/AZ07tsc8bVq27twNgJvTafLmyaM34+XLV1Sp24DgFy/oYtcRIyPYsmMXlhkz4uZ4hkyZLPVmePv4UKWODRqNhi52HQgLD2frzt1YFyrIhdPHSZMmjd6MO3c9qGHTiPTp0mHXri3PgoLYvnsvNatV5cTBvdrbw5Mida5L6vwdqXNd/3Wdh4aGkt4qD69fv9Zpm8Tn+1R7L4QQQnwNyWnrpSOfiKQa9mvXbzBz3gIuuV0hk2VGenTtzC/9+qr64pjA+aILs+f/xfWb7uSwyk7fXj3o7dAtWdMmHTtxinmLluBx7z758uZhUL++2LVvq3p7iH/eddHylTzxekpR68L8NmggTRs3VL29oiis27iZFWvX4+cfQNnSpRg5dDC1a6q/ihQbG8vSlatZt2kLwS9eUrVyRUYPG6rqammCyMhI5i1awpYdu3jzJoy6tWowZvhv2udn1QgNDWX2/IXs2refqKgoGtvaMGb4UFWdmwRBQc+Z+ed8DvzzbGyrZk0Z9duvZMuWVXWGt48PM+bO59jJU5iamtKhTWtGDh1M+vTpVWfcu/+A6XP+5Nz5C1hYmNO5Y3t+GzSQ1KlTq86QOn9H6lyX1Lmu/7LOpSP/5UlHXgghhCGRjvy/JA27EEIIQyMd+S9P2nshhBCGJDltvTwjL4QQQgghhBBCfEOkIy+EEEIIIYQQQnxD1D8IKIQQQgjxHfqcpwwVReGS22UeP/GiaBFrKpQrm6yxEQA0Gg1Ozhfw8w+gXJnSlCheLNn7ERsby5lzTgS/eEGVShUpVLBAsjMiIyM5fc6R0NA31KpRjdy5ciU7IywsjFNnzxEVFU292rWSNW5GgpCQEE6fc0JRFGzq1SVjxgzJzggKes65886YmppgW78e5uYfT3epj6+fH84XL2Funhbb+vUwMzNLdsajx09wvXyFTJaWNKhXBxMTk2Rn3LnrwfWbt8iZw4o6tWp+NAWpGlev38DD8x758+WletUqya5RqXNdUue6pM7f+RJ1nlzSkRdCCCHED612w6Yc2r2dPLlzq1rfx9eX1nZduPbedI51atVg9+aNZM6cSVWGh+c92th35d79B9plLZo2Zuu61aq/lF/++yrtuzjg4+urXdbN3o7VSxdhamqqKuPUmXN06fUTz4ODAUiRIgW//PwT82fPUP2FeueeffQdNITXr+OnhDQxMWHcqOGMHz1S9Zfh5avXMmzMOCIiIgBInTo1c6dPYUDfPqq2VxSFabPn8seM2cTExACQLl06ViycT6cO7VRlaDQaho3+nYXLVqDRaADInDkTm1evpJHKKTZjYmL4aeBgNmzZpl2WK2dOdm1eT9XKlVRlhIeH06XXTxw4fFS7zLpwIfZt20zxYkVVZbx48ZL2XbvjeP6Cdlm5MqXZv2OL1DlS51Ln7xhKnX8OubVeCCGEED+0kNevaWvfTdWVeUVRaN/FgRcvX3Lq0H7Cgvw4uGsbdz3u4dC3v6rfFxsbS/P2dhinNObimRO8eebLlrWrcHS+yJARo1VlvHnzhqZtO5AzhxXXLjrxOsCb5Qvns2PPPiZNm6kqw8/fn1Z2nSlftgx3r7rx0teLmX9MYtHylSxatkJVxu07d+ncsw+NbW14dPsGz548YMSvg5k4dQY7du9VleHkfIH+Q36jm70dPvfv4PvgLg5d7Bk4dDjnnM6ryti1dz/j/5jGsMG/8OzJAx7fuUHThrZ07d0X99t3VGUsWbGKv5YuZ/qkCbzwecLdq25ULFeONvZd8fXzU5Uxefostu7czbK/5vE6wJvrLufJkzsXzdp1JDQ0VFXGryPHcMbxPJvXrOTNM19czp7E1MSUZu06ajtv+vT4uT+373qwf8cWwoL8OHPkAK9CQqTOP7PO79z1kDp/j9T5O1+izj+XjFqfCBnFVgghhKGRUeu/vIT2fu+2zbS174qr42mqVKqY5DZXrl6jcu36HNu3m8YNbbTLN27ZhkPf/jy+c4P8+fIlmXH42HFatO/EdZfzlC1TWrt8zvyFjPtjKs+e3CdDhgxJZqzZsJG+v/yKl8ctnVuEh48Zx9pNmwnyeqh3KsVps+cyY+58/B7c1Zn+sWuvvly+epX7N68muT3A4OEj2b3vIE893XVuq7Vt3prIqCicTx3Tm2HXvSd3Pe5x6/JF7ZVNRVEoW7Um1oULsWvzBr0ZdRs3wzilMaePHNAui4mJIV+x0rRp2ZzF8+bozSharhIVypZly7pV2mWhoaHkLFyckUMHM370yCS3j4uLI2u+Qjh0tmferOna5b5+fuQrVpplf83jp54OSWaEhoaSJW8h/hg3llHDftUuv3nLnbLVanFg51ZaNmuaZMZTb2/yFSvN+hVLcejaWbv85OmzNGrVVur8H1LnUueGUufvk1HrhRBCCCFUqlCuDABPvX30rpuwTqUK5XWWJ3xh9Pbx/WibxDKMjY0pU7qUzvLKFcsTHR1N4LMgVRlW2bN/9Jxv5YoVePUqhDdvwlRlFClcSKdzA1ClUgVVr0VCRtnSpT56NrZyxeRlVKpQTuf2ZCMjIypVKI/XU+9kZOi+JyYmJpQvW5qn3snJKKezLF26dBQrYq3qWMLDw3n58tVH+5ErZ05yWFmpOpZnQc+Jjo6mckXdjNKlSmJqaqoqI6EGP9yPhEyp83hS5+9InX/dOv9c0pEXQgghxA/tjGP8ba3FixbRu26Jf57dPHnmrM7y46dOkzJlSqwLFVKVERsb+9HttCdOn8XCwoLcuXLqzShetCh+/v7cvnP3g4wz5MyRg/Tp9d+1UaJYUdzv3MU/IOCDYzmj6rWIzyjGpcuXdW6n1Wg0nDxzVvta6VO8aBHOOp0nOjpauywmJoazTueTkVGUk2fOap/5hfjbsi+6ulG8qLqMEsWKcvLMOZ1bcgMCArnpflvV6xH/3uX6qDbuenji4+ur6lhy5rDCwsKCE6d1M5ycLxAdHU2JYvoH0LIuVAhjY2NOnD6jszwhU+o84VikzhNInX/dOv9cMtidEEIIIX5oQ0eNobGtDSVLFNe7brGiRWjWuBEDhg7jVUgINapW4fQ5R8ZPmU43ezusrLLrzahTqyYVy5ejS6++zJg8gbKlS3HgyFHmLFjIsMG/kDZtWr0ZbVo2p0D+fLSy68yMyRMpWCA/23buZu3GzcybOU3VAF7dO9szfc48Grdqx5QJv2OVPTur12/k6ImTbF23Wu/2AD/37sGi5Stp0qYDE0aPxNw8LQuXreDva9c5dWi/qowhA/qxeftOWnawZ9RvQzAyMmLWvL/w9fNnyIB+qjKGDR6ITfPW2HXvya8D+xMWFs6UWXOIjo6h/0+9VGWM+HUwnRx68dPAwfzU04FnQUFMmDKd9OnS0aNrF73bGxkZMWzwQH4dOQbLjBnpbNeBx0+8GDvpD/Lny0vbVi30ZqRJk4Zffv6J2fP/wswsFa2aNeXW7TuMmfgH5cuWoV6dWnozsmXLSvfOnRg7aQpxcRps69fl0uUrjJk4Wepc6lzq/D2GUuefS56RT4Q8Iy+EEMLQyDPyX15Ce9+6RTPWr1j60a23n/L69Wt+HjyUXXv3o9FoMDY2xqGLPYv+nE3q1KlVZTx7FkSv/r9w9MRJAMzMzBjwU29mTZ2s95nfBE+8vOjx8wDOX3AB4q+Ujfh1EONGjVA9irb77Tv0+HmAdsRmS8uMTP59DL/066tqe4CLl1zpM3AwnvfuA2CVPTtzpv1Bl04dVWccO3GKAUOHaW+pzZc3D4vnzaFZ40aqM7bu2MXwseMJCAwEoGgRa1Yt/oua1aupzli6cjUTpk7nxYuXQPwI2OuWL/nottlPSRhVfPb8hbx58waAmtWrsWHlMgrkz6cqIzY2ltHjJ7Fk5WoiIyMBaGxrw7rlS8iePZuqjMjISAYPH8X6zVuJiYkhRYoUtGvdklWL/5I6R+pc6vwdQ6nzBMlp66UjnwjpyAshhDA00pH/8v5tex8QEIi3ry8F8uUjS5bMn7UP3j4+BAQ+w7pQoc+aTxri53J+8fIlxYsW+aypjhRF4d79B7wJC6Nk8WKqv7x+mHHnrgdR0dGULlnis+aTjouL0468XapkCVKmTJnsjJiYGG7dvoOpiQklSxRP9lzQEN85cL9zFwtzc4pYF/6sjLCwMO563iOTpSUFC+RP9vYQP9/4vQcPscqeTfVUWh96/jyYx15e5M4V//zy55A6182QOn9H6lzXl6hz6cj/S9KRF0IIYWikI//lSXsvhBDCkMio9UIIIYQQQgghxHdKOvKfKTIykri4uM/eXlEU3r59qzPq5Odm/JubKr5Ehkaj+dcZcXFx2udj/k1GVFTUv8qIjY391xkxMTHExMT8q4zo6Oh/nREVFfWvahSkzt8nda5L6vwdQ6lzIYQQQvw4vmpHftKkSRgZGen8y549u87PixYtStq0acmYMSM2Nja4ubnpzd2zZw/FixcnVapUFC9enH379n2xfT5w+AjlqtUidabsZMiRl4FDh+tMRaHGxi3bKFa+MmkyW5E5TwFGjZuYrC/3iqKwaNkK8hcvTZrMVuQoWJSps+YQGxurOiMuLo5ps+eSo2BR0mS2Il+xUixcujxZXyKjoqIYPX4SWfIWJE1mK4qWq8SGzVtVbw/xU2b88tsIMubMR+pM2SlbtSb7Dh5KVsbz58H0/HkA5llzYmaZjWr1bDlzzilZGU+9vbHr3pM0ma0ws8xGg6Ytufz31WRleHjeo0V7O8wss2FmmY3m7ey46+GZrIwrV6/RoGlLUmXMSprMVnTs1gOvp0+TlXHW0Ynq9RtiZpkN86w56dG3P0FBz5OVIXX+jtS5LqlzXYZQ50IIIYT48Xz1K/IlSpQgICBA+8/d3V37M2traxYvXoy7uzsXLlwgX758NGzYkOfPP/1l7dKlS9jZ2dGtWzdu3rxJt27d6Nixo6o/AOiz7+AhWtt1IUvmzKxdtphfB8ZPI9G0bUfVV2JWrl2PQ9/+FC9ahPUrltKrW1cWLltB5559VO/HlJmzGTx8FHVq1mDjquW0bdWCSdNmMmjYSNUZg4ePYuLUGbRu0YyNq5ZTr3YthowYzeTpM1VndOn1EwuWLKNHl86sX7GUUiWK0+PnASxfvVbV9hqNhmbtOrJx63YG9/+ZtcsWky1rVtrad2PP/gOqMiIjI6nftCWHj5/g95HDWLVkISlTpqRRq7Y4OV9QlfHqVQi1GzbFxfUy0yaOZ+mCP3n56hV1GzfnlvttVRnePj7UatiEew8eMn/WdObPms6DR4+o1bAJT729VWXcvnOXuo2b8+LlS5Yu+JMZkyfievlvajdsph1VVB/niy40atUOIyMjVi7+i3GjhnP0xCnqNW3B27dvVWVIneuSOn/Hx9dX6vw9hlLnQgghhPjxfNXB7iZNmsT+/fu5ceOGqvUTBqU5ffo0DRo0SHQdOzs7QkNDOXbsmHZZ48aNyZgxI9u2bUvW73l/8BtFUShTpQY5rKw4tn+3dmTHs45ONGjWimP7dtO4oU2SuTExMeQtWgqbenXYuHqFdvm2nbvp3LMPVy84Ur5cWb37lqNQMQb81JvZ0/7QLp+/aAnDx47nyd2bekd89PXzI2/RUsyeOplhQwZpl48eP4nFK1bh9+Cu3ikbbt5yp2y1WmxavYKu9nba5T1/HsDxU2fwvndb70ieJ06doXHrdpw8uA/bBvWA+Ne5WduOePv44n7FRe8Imhu3bMOhb39uXHLWTpkRGxtLtXq2pLOw4MzRg0luDzBn/kLGT5nG/Zt/a1+7t2/fUqpydSpXqMDW9frnGB02+nfWb9nKg5vXsLTMCMR3nAqXKU93+07MmzVdb0bXXn1xcXPj9pVLpEmTBojvOBUuXYHJv49h1LBf9WbYNm/Nq5AQXB1Pa6e7cL99h9JVarBu+RJ6dEt6flCpc11S57qGjxnHus1bpM75OnUug919eTLYnRBCCEPyTQ129+DBA3LkyEH+/Pnp1KkTjx8/TnS96OhoVq5cSfr06SlTpswn8y5dukTDhg11ljVq1AgXF5dPbhMVFUVoaKjOvw+FhYXhfucuXew66HzprlenNlbZs3PR1VXfofLU24eAwEC62XfSWd6hbWtMTExwcbusN8P9zl3Cw8Pp+sGclV072aHRaHC7ov82Wbcrf6PRaOjayU5neddOHQkPD+emiqtzF13dSJkyJZ06tPtoPwKfPeOJl/7bZF3c3MiWNSs29etqlxkZGdHFrgN3PDxU3eJ60dWN0iVL6Mx7aWxsjH2Hdlx0VXcXxkVXV2rXqK7zhTl16tS0a9VS1fsafyyXadaoobZzA5AxYwaaN26kej9c3Nxo16qltnMDkDtXLurWqql6Py66utGpfTudOStLlSxB2dKlVO2H1LkuqfOP90PqPJ6h1LkQQgghfkxftSNfpUoVNm7cyIkTJ1i1ahWBgYFUr16dFy9eaNc5fPgw5ubmmJmZMX/+fE6dOkXmzJ+e2y8wMJBs2bLpLMuWLRuBgYGf3GbGjBmkT59e+y93Ilf6zMzMSJ06NU99fHSWh4aG8iokBMuMGT/a5kPp06XDyMgIrw9uQfUPCCAmJkZVRsI6H2Yk7FdyMj48loRMtRlxcXH4+vl9kPEUIyMjMui50pmQEfL6NSEhr3WWP/Xx0b7eajL8AwOJjo7+YD+8VR1HQsZTH5+PnptObsaH78mXyFAUhac+Psk8Ft2M6Oho/PwDVGVInX+cIXWumyF1Hs9Q6lwIIYQQP6av2pFv0qQJ7dq1o1SpUtjY2HDkyBEANmzYoF2nXr163LhxAxcXFxo3bkzHjh0JCgpKMvfD21QVRUny1tUxY8bw+vVr7T+fD77cAZiYmNC5Y3vmLVqCyz9XfEJDQ/nltxHExcXRqX27j7b5UJYsmWnWuCF/zJitfSb1xYuX9B8yjPTp09GyWRO9GUWLWFOpQnlGT5jMo8dPgPgvjoOHjyJP7lzUqVVDb0btmjXIlzcPQ0aMxs/fH4DHT7wYPX4yFcqVpUTxYnozWjRtTMaMGeg/ZBjBwfF/eHG/fYc/ZsymSUNbsmbNojfDrl1bFEXhl99GaK9KXnK7zJ8LF2PfoR2mpqZ6M7rZ2/HixUuGjfmdiIgIFEXhxKkzrF6/CYcu9nq3B3DoYs/9Bw/5Y8YsoqOjURSFHbv3smf/wWRlOF+8xJIVq4iLiyMuLo7lq9fi5HwxWRn7Dh5m287daDQaoqOjmTprDp737qvO6NG1M2s2bObYiVPaUbBHjB3P8+Bgutnb6d1e6lyX1PnHGVLn8QylzoUQQgjxY/qqz8gnxtbWlkKFCrFs2bJEf164cGF69erFmDFjEv15njx5GDp0KEOHDtUumz9/PgsWLOCpylGRP/XM3KtXITRs2Ya/r10nb57cPA9+QUxMDBtWLsO+Y3tV2b5+ftg0b829+w/Iny8vfv4BGBsbs3frJhrZJv7c/4c8793HtkUb/Pz9yZ8vL94+vqRLZ8HRvbuoUqmiqozLf1+ladsOhIS8Jm+e3DzxekoOKytOHdpHsaJFVGWcPH2Wtp27ERMTQ84cVjzxeop14UKcPryf3LlyqcrYsXsv3fr8jLGxMVmzZOaptw8VypXl5MF9OrfvJmXJilUMHj6KtGnTkj5dOnz9/KhfpzaHdm/XuX03KZOmzWDy9FlkyJAes1RmBD57RrvWLdm2fo3eZ6ABbUdt6crVZM6cCYDg4Bf83Lsny/6ap/cZaIh/5rlzzz7s2ruf7NmyERUdxatXIYwfPYI/xv+u6jgiIiJo1bEzp885kjNHDkLfvCEsLIy/5sxkUP+fVWVIneuSOn9H6lzXf13n8oz8lyfPyAshhDAkyWnrDaojHxUVRcGCBenbty8TJkxIdJ1ChQrRtWtXJk2alOjP7ezsePPmDUePHtUua9KkCRkyZPhXg90liI2N5cjxE7i4XiZzpkx0tmtPzhw51B3gP6Kioth38DDXb94ih1V2OnfsQJYsn35cIDERERHs3LMPj3v3yZc3D507ttc7cNeHXr9+zbZde3j8xItiRazp2K4NadOmTVZGcPALtuzYiX9AIGVLl6JtqxakSpUqWRl+/v5s27mH58HBVKtSieZNGus8+6rG4ydebN+9hzdvwqhbqya2DeqRIkXybji56+HJ7v0HiIyMoklDG2pWr6aqY/K+q9dvcODwERRFoVXzZlQsXy5Z2yuKwsVLrhw7eRpTUxPat26l6srx+zQaDafPOnLuvDMWFubYtWtLwQL5k5Uhda5L6lyX1Pk7/2WdS0f+y5OOvBBCCEPyzXTkhw8fTosWLciTJw9BQUFMnToVJycn3N3dyZw5M9OmTaNly5ZYWVnx4sULli5dyubNm7l69SolSpQAoHv37uTMmZMZM2YA4OLiQu3atZk2bRqtWrXiwIEDjBs3jgsXLlClShVV+yUNuxBCCEMjHfkvT9p7IYQQhiQ5bX3yLgd9Yb6+vtjb2xMcHEyWLFmoWrUqrq6u5M2bl8jISDw9PdmwYQPBwcFkypSJSpUq4ezsrO3EA3h7e+tckapevTrbt29n3LhxjB8/noIFC7Jjxw7VnXghhBBCCCGEEMKQGdSt9YZC/kIvhBDC0MgV+S9P2nshhBCG5Ju5Ii+EEEKI79ukSZOYPHmyzrL3p4WdNGkS27dvx8fHB1NTUypUqMC0adP03km3Z88exo8fz6NHjyhYsCDTpk2jTZs2n7WPt+96UL1q8u7cc799h+Vr1vHE6ylFChdiQN8+FC5UMFkZl/++ysq167Xjb/T/qZfqQTQTnHM6z7pNW3jx8hVVKlWgX+9eqmbUSKAoCkeOn2DL9l28CYsff6NPj25kyJBBdUZcXBy79x1g1779REdH08imAT26dk7WeCTR0dFs3bGLA0fixzhq2bQJXTp1VDWzR4KIiAjWb97K8VOnMTU1pX3rVnRo25qUKVOqznj9+jWr12/k3PkLmJunpYtdB5o3aZyssUSePw9m+Zq1uF7+m0yWGenRtTP169ZRvT2Aj68vy1at5cYtd3JYZeenng6qB3pN8PDRY5auXI3n/Qfky5uHfr17UrpUyWRlSJ2/I3WuS+pc15eo8+T6qtPPCSGEEOL7V6JECQICArT/3N3dtT+ztrZm8eLFuLu7c+HCBfLly0fDhg15/vz5J/MuXbqEnZ0d3bp14+bNm3Tr1o2OHTvi5ub2WftXy7YJO/fsU73+7n0HKF+jDvsPHcHU1IQtO3ZRukoNTp91VJ2xfPVaqtRpwFmn85iYGLN01WpKVa7O1es3VGdMmTmb+k1b8vf1G6RIYcSseX9RpmpNHjx8pGp7RVEYNGwkLdp3wvP+feLi4vh98hQq1qpHQECgqgyNRoN9j950cuiFr58/b99GMmTEaGrZNuH169eqMqKiomjapgM9+w3k5atXvHz1il79f6Fxq3ZERkaqyggNDaWWbRMGDRtJRMRb/PwDsO/RG7vuPYmLi1OVERj4jIq16jF20hTi4uK4/+AhLTvYM+DXYai9gfXR4yeUqVqTmX8uwMjIiL+v36BBs1ZMnj5T1fYA167foHSVGixZuRoTE2POnXemal0blq5crTrjrKMTpavUYNP2HZiamnDwyDHK16gjdS51TmDgMyrVri91/g9DqfPPIbfWJ0JutRNCCGFovtVb6ydNmsT+/fu5ceOGqvUT2uDTp0/ToEHi0/jZ2dkRGhrKsWPHtMsaN25MxowZVc9Q8/7vatOyOefOO+P3wEPvdI5v374ll3Vx6tepzdZ1qzExMSEiIoKWHex59OQJD92v670y9vx5MLmsi9Ore1eWzJ9LihQpCAkJoUGzVhgbG+PmdEbvvt9/8JAiZSsyfvQIJo8bi5GREYGBz6hh04gSxYpycNd2vRkXXC5Ry7YJi+fNYeDPPwHxs2NUrWtDq+ZNWbVkod6MPfsP0L6LA7s2b6B9m1YA3LzlTg2bxvw6sD9TJ47Tm5EwveaZIweoW7sWAOcvXKR+05YsmD2DX/r11ZsxYco0/ly4hIunj1O2TGkA9h08RFv7buzctJ4ObVvrzfh50K/sPXgI13OntbNgLFu1hgG/DsPpxBFq16yhN6O1XWdu3b7DxdMnsLLKjqIo/DFjFpOmzcTj2mWKFrHWm1G1rg1RUVGcO3aIDBkyoNFoGDRsJKvXb8Tn3h29V6I1Gg2FS5cnb+7cHN6zgzRp0hATE0PX3n05eeas1DlS51Ln8Qylzt+XnLZersgLIYQQ4v/qwYMH5MiRg/z589OpUyceP36c6HrR0dGsXLmS9OnTU6ZMmU/mXbp0iYYNG+osa9SoES4uLknuR1RUFKGhoTr/AMaNHE5IyGvOOp3XeyznnJx5+fIVU8b/jomJCQBp0qRhwpiReD315tqNm3ozDh87TnR0NFMnjNMO2JshQwZGDxvK5b+v4uPrqzdjz/6DmJubM3bEMO3tsNmzZ2PoLwM4fOwEb9++1Zuxe98BcufKRf+femuXFcifj769erB7/wG928dnHKRi+XLazg1AmdKlsO/QTn3G/gM0aWir7dwA1K5Zg6aNbJORcZBO7dtqOzcAbVq2oHLFCsnaj596OOhMZflz757kzZNbVUZkZCSHjh7n14H9sbLKDoCRkRGjhw0lXbp07D14SG+Gr58fblf+ZvSwodrbvlOkSMGU8b8TExPDoff+ePUp12/e4vETLyaMGantyJiYmDBl/O9S5/+QOpc6B8Op888lHXkhhBBC/N9UqVKFjRs3cuLECVatWkVgYCDVq1fnxYsX2nUOHz6Mubk5ZmZmzJ8/n1OnTpE5c+ZPZgYGBpItWzadZe8/d/8pM2bMIH369Np/uXPnBsAstRkQ/4cEfWJiYwBI/c82CRK+SMbExKjIiCVFihSYmaX6ICP1P/uhJiMGExNj7ZfPBKlTm6EoiqrbbGNiY0md2kxn9p+E/VCzDwn78eFrAZAmdWpVrwVATExs4hlp0qjfj5gY7ev3vtSpzVS9rwn78WFGihQpSJ1a3euh0WjQaDSkTq2bYWxsjImJsbr6ikm8vszMUpEiRQp1tfFPxodXI1NLnX+0H1Ln8aTOE69zdRn/vs4/l3TkhRBCCPF/06RJE9q1a0epUqWwsbHhyJEjAGzYsEG7Tr169bhx4wYuLi40btyYjh07EhQUlGTuh4MyKYqid6CmMWPG8Pr1a+0/Hx8fAJasWI2ZmRl1a9VKcnuA2jVqkDp1auYvWqp9nlRRFOYvWkqWzJmpUK6s3oyGDeqhKAoLl67QLouNjWXh0hUUsS5Mgfz59GY0aWjLq1chbNi8Vbvs7du3LFu1llo1qmFubq4iw4b7Dx5y5PgJ7bKQkBDWbNhE00a2erdPyLjg4srlv69qlwUEBLJ11+5kZRw+doL7Dx5qlz14+IiDR44lK2P77r34BwRol/197TrnL7jQtFHDJLbUzVi7cTMhISHaZcdOnMLz3n1V+5EmTRrq1KrBslVrdK4Ub9q6nRcvXqraj3x581K0iDWLlq0kNjZWu3zRspVoNBoa2yb+uMn7ypUpTdYsWZi/aCkajUa7fP6ipVLn/5A6lzoH/XVesXw5vRlfos4/lzwjnwh5Rl4IIYSh+VafkU+Mra0thQoVYtmyZYn+vHDhwvTq1YsxY8Yk+vM8efIwdOhQhg4dql02f/58FixYwNOnT1XvR0J7DzBn2hSG/zpI1XbzFi5m2Jhx1KhWlepVKnPW6TxXr99g/YqlOHTtrCpj1LiJzJ7/F7b161GmVEmOnjzF/QcP2b9jC80aN1KV0aNvfzZu3U7LZk0omD8/+w4dJvBZEGeOHKBalcp6t9doNLRo34mTZ87StlULsmfNyu79B3kb+ZaLp09QrGgRvRmRkZHUa9KCG7fc6dCmFRYWFuzYsxezVGa4Op4iV86cejNCQkKo3qARvn7+2LVrg5GREdt37yWHVXYunT1FxowZ9Gb4+ftTta4tEW8jsGvXlvDwcHbu3U/pkiVwPH74o6uHifG8d5/qDRpilsqMDm1a8ez5c/bsP0iDunU4snenqlHB3a78Tf2mLcmWNQttWjTnsZcXBw4fpYtdBzauXqFqVPBjJ07RsqM9hQsVpFmjhty6fYeTZ84yfMgg5kyfond7gM3bdtD9p36UK1OaBnXr4HrlCs4XL0mdS53jee8+NWwakco0ldQ5hlPnCZLT1ktHPhHSkRdCCGFovpeOfFRUFAULFqRv375MmDAh0XUKFSpE165dmTRpUqI/t7Oz482bNxw9elS7rEmTJmTIkOGzBrvbum4V9h07JOs4Dh45yqJlK3ns5UWxIkUY+ssAGtRTP/WSoihs27mb5WvWaqcrGj5kEFUrV1KdERcXx+r1G1m/eSvPg4OpVrkSI4cOoVTJEqozoqOjWbx8JVt2vJuWa+TQIRQqWEB1RlhYGAuWLGPnnn1ERUfTxNaGEUMHkzNHDtUZL1++Yu5fizhw5CiKotC6eTOGDf6FTJksVWf4BwQwZ/5Cjp06jamJCR3atmboLwNUXbVN8OjxE2bP/4tz552xMDenc8f2/NKvL6lSpdK/8T9u37nL7Pl/4eJ2mcyZMtGja2d+6umQrOnB3K78zdy/FnH95i1yWGWnb88edOnUMVnTg511dGL+4qV43LtPvjx5GNS/L62aN1O9PXy5Ol+xdh1+/gFS51LnOqTOPyYd+X9JOvJCCCEMzbfakR8+fDgtWrQgT548BAUFMXXqVJycnHB3dydz5sxMmzaNli1bYmVlxYsXL1i6dCmbN2/m6tWrlCgR/0W9e/fu5MyZkxkzZgDg4uJC7dq1mTZtGq1ateLAgQOMGzeOCxcu6J1//n3S3gshhDAkyWnrjf+jfRJCCCHED8jX1xd7e3uCg4PJkiULVatWxdXVlbx58xIZGYmnpycbNmwgODiYTJkyUalSJZydnbWdeABvb2+dgaqqV6/O9u3bGTduHOPHj6dgwYLs2LEjWZ14IYQQ4lsmV+QTIX+hF0IIYWi+1SvyhkzaeyGEEIZErsj/n9318MT18hUyZbKksa1Nsp4nSXDt+g2u37pFjuxW2Daoh7Fx8t4KRVFwcXXD8/598uXJS706tT6aVkMfjUaD43lnnjx9SpHChalRrWqynkmB+FEZT505h39gAGVLl1Y1iumHoqKiOH7qNC9evKRKpYqUKF4s2Rnh4eEcO3maN2/eULtmDZ25MdV6/fo1R0+cIjo6mgb16qgauORDz58Hc+L0GQAa2TQgS5ZPT5/0Kb5+fpw554SpqSlNGtpo59dMjsdPvHByvoC5uTlNG9mSNm3aZGdInb8jda5L6lyXIdS5EEIIIX4s0pFPhqioKBz69mfH7r3aZdmyZmXX5vXUqlFdVUZoaCgdu/XUfgkGyJsnNwd3bqN0qZKqMoKCntPKrjOul69olxUvVpRDu7arnuLgiZcXLdrbc8fDQ7usSqWKHNixlWzZsqrKcL99h1Z2nXni9W6EYNv69di9ZYPqKxsXL7nSrnN3nr03zVCHtq3ZtHqF6i/UR46foGvvvoSEvNYu69urB0sX/Kl6wI1NW7fT/9dhhIeHA5AyZUpGDh3CtEnjVXf6Fixeyqjxk7RzTpqamjJj8gR+G/yLqu0VRWH8H9OY+ed87byoadKkYen8uapHzYyLi+OX30awYs067TQa6dOnY9PqFbRo2kRVhtS5LqlzXVLn73yqzg/s2EqZ0qVUZXyJOhdCCCHEj0f+5J8ME6ZMZ/+hI6xbvoTIl8+4e9WNokUK06JDJ525GJMyePgoLl2+wu4tG4gOec61i05YZsxI8/adtF+M9XHo258nXk85vn8PsaEvuHjmBNHR0bS174qaJyUURaFd5+5ERkXifOoYsaEvOHFgL94+vnT/qZ+qfYiJiaF5ezvSp0vH1QuORIc8Z8/WjVy+epVffhuhKuP169c0b29HEetC3L3qRuTLZ6xfsZSDR44xbvJUVRk+vr6069ydWtWr8fjODcKf+7Nw7ixWr9/IgsVLVWXccr9Nj58H0LZlc/weevA6wJuJY0cxY+48tmzfqSrjzDknho4aS7/ePXn+9BHPnz5iwE+9GTZmHKfOnFOVsW3nbqbNnsv40SMI8X+K30MPOrRpRc9+A7l+46aqjIVLl7Ny7Xrmz5pOWJAfj+/coG6tmnTo2oOn3t6qMqTO3/lSdd6iQyep83/8CHXeooP9f1bnQgghhPgxyTPyiUjsmbm4uDiy5C1I7+7ddOY2DAgIJHeREiyeN4d+fXolmRsSEkLWfIWZPmmCztyGt+/cpVTl6uzbvpnWLZonmfHEy4sCJcqyafUKutrbaZefOeeETfNWuJw9qXdOTbcrf1O1rg0nD+7DtkE97fIt23fStXdfHrpf13vL7sEjR2nVsTO33C7qTP8xb+FiRk+YzLMnD/TOh7ly7XoG/DqMp57uOlN3jBo3kRVr1xHs/VjvLapTZs5m9vyF+D/0wMLCQrvc4ad+XHR146H79SS3B/jltxHsP3QEL49bOr+vcat2vAkL4+KZE3oz2nfpzsNHj7l+yVl7ZVNRFCrUqEP+fHnZs3WT3oxatk1Ikzo1Jw6+u0IYGxtLgRJlad6kEUsX/Kk3w7pMBapWqsjG1Su0y8LCwshRqBjDBg9k4tjRSW4vda5L6lxXh64OPHj4SOqcr1Pn8oz8lyfPyAshhDAkyWnr5Yq8SuHh4bx6FUL5smV0lltZZSeHlRW+fv56M54HvyAmJobyZUvrLC9RvBimpqb4+PrpzfDzDwCgXBndjIT9UpORsM6Hx5Lw3K+vn7oMY2NjSpYo/lFGTEwMQc+f683w9fMjW9asH82/Wb5sGV6/DiUsLEzVfhQuWECnc5OwH2pei/gMX0qXLPFRZyo5Gb5+/pQrU1rn9mQjIyPKlSmdjAy/j95XY2NjSpcsgY+vr6oMH1+/j95Xc3NzihQupGo/pM4/zpA6192PxOq8fNkyUuf/+K/rXAghhBA/JunIq2RhYUHePLk5euKkznL323fw8fWl1Adf9BOTK2cO0qdPx9ETp3SWnznnRHR0tKqMIoULY2Ji8lFGwn6pyUhY58NjOXL8BMbGxhS1ttabUbpkCe0AYLoZJ0mXLh25c+kfQKtUiRL4BwRw4+YtneVHT5wkd65cqq6OlC5ZAvc7d3U6AIqicPTEKVWvRULGRVc3ndtpNRoNx06eovR7V2GTPpbinHE8T1RUlHZZVFQUp885qt6PUiWKc/zUae1zwxB/W/aFS5coVULdfpQuWYKjJ07p3JLr6+fHTffbqvZD6lyX1PnHGYnV+amz56TO//Ff17kQQgghfkwy2J1KRkZGjPrtVwb8Oox06dLRuWN7Hj/xYvyUaRQuVJA2LZO+hRIgderUDBnQj6mz5mJsbEzrFs24dfsO4yZPpUqlitSpVVNvRpYsmenVvSvj/phKVHQUtvXr4Xr5CuOnTKdF08YUK1pEb0YR68K0btGMgb+NIPjFC6pXrcIZRyf+mDGbnt26qBoErGb1alSrUpmuvfsyZcLvlClVkgOHj/LnwsWMHfEbadKk0ZvRqnlTrAsXopVdZ6aM/52CBfKzffceNm7dzqI/Z6satbmbvR3T58yjUat2TBo7muzZsrJmwyZOnD7Dzk3r9W4P8HPvnixavhLbFm0YN2o4FubmLFy2ghu33Jk3c5qqjCED+rFp2w4at27HyF+HYGRkxJwFCwl8FsSQAeqexx4+ZBD1mrSgrX1XBvfvR3hEONNm/4miQL8+PVVljPptCO06d6d7n5/p06M7Qc+DmTR9JpksLene2V7v9lLnur5UnRexLvxd1Png/j+zcet2qXMMp86FEEII8WOSZ+QT8aln5hRF4c+/FjPjz3m8fPkKAJt6dVmzbBF5cudWlR0XF8fEqTP4a+lywsLCMDIyolXzpqxc9JfqKZyio6MZNuZ3Vq/fRGRkJMbGxth3aMeS+XM/uvX2U8LCwhg4dDhbd+4mNjYWMzMzejt0488ZU1WPoh0c/IK+g4aw/9ARFEXB3NycQf3iOzxqR9H28fWld/9BnDobf8UzY8YMjP5tKCOGDlY9iraH5z36DByMi6sbED/y9JQJv/NTTwdV2wNcuXqNvr8M4cYtdyB+5Ok506bQoW1r1Rmnzzryy7AR3Lv/AADrwoVY/Occneez9dmz/wDDxozjqbcPAGVKlWTFogVUqVRRdcaaDRsZN3kagc+eAVCtSmVWL1lI8WJFVW0vda5L6lyX1Pk7/3WdyzPyX548Iy+EEMKQJKetl458IvQ17G/fvuXBw0dYWmb8rDmYIb6D8ejxE7JlzUr27Nk+KyMkJISn3j7kzJGDzJkzfVZGcPAL/Pz9yZsn92fN4wwQGPiMZ0FBFCyQH3Nz88/K8PXz4+XLVxQuVJDUqVN/VobX06e8eRNGEevCmJqaJnt7RVF49PgJUVFRFC1irbqT9mFGQgeniHXhZM9XDvGdA8979zE1NaVQwQKflREdHc29+w+wsDAnX968yd4epM4/JHWumyF1/s5/VefSkf/ypCMvhBDCkEhH/l+Shl0IIYShkY78lyftvRBCCEMio9YLIYQQQgghhBDfKenICyGEEEJ8hri4OF69CkGj0Xx2RkxMDK9ehfBvbpCMjo4mJOTfZURGRvL69evP3h7iH1V58+bNv8oIDw8nPDz8X2W8efOGt2/f/quM0NBQIiMjP3t7RVEICQkhOjr6X2W8ehVCTEzMZ2doNBpevQrRmSkkuaTOdUmdvyN1rutL1HlySEdeCCGEED+0KTPnJOtLZExMDBOmTCNb/sJY5spHzkLFmDN/YbK+AL59+5ahI8eQKXcBLHPlo0CJMqxYsy5ZXwBDQkL4aeBgMuTIS8ac+SheoQo7du9VvT3Ej//RuUcf0mXPTYYceSlfvTbHPpgSUZ9Hj5/QqqM95llzki57bmo0aMQFl0vJyrjlfpuGLdpgnjUn5llzYtu8NTf/GZhTLRdXN2raNCZd9tyYZ81Jyw6dePjocbIyjp88TYUadUhvlQeLbLmwd+hNQEBgsjJ27tlH8QpVyJgzH+mt8tBnwCBevQpRvb2iKKxat4ECJcpgmSsfmXIX4NcRo4mIiFCdodFomLtgEbkKF8cyVz6y5ivEuMlTpc6lzgGp8/cZSp1/DunICyGEEOKHtmDJMvoNHqp6/YFDhzNj7ny6dbJjx8Z1tGzWhFHjJzL+D3VTOQLYde/JirXrGdSvL9s3rKV6lSr0GzyURctWqNo+Li6OJm06sHv/AcaO+I2t61ZTuGABOjn0YvuuPaoy3r59S72mLTh33plpE8ezcdVyMqRPT/P2dpw556QqIzj4BXUaNcP9zl0WzJ7B2mWLiY2NxaZ5a67fuKkqw+vpU+o0boZfQADLF85n+cL5BAQ+o07jZjx+4qUq48bNWzRo1oro6GjWLF3EgtkzuH3Xg9oNm/L8ebCqjHNO52ne3o506SzYuGo5MyZPxOnCReo2aa66c7Fr737suvekUIH8bFm7inGjhrP34CEat26n+mrhkhWr6PvLEKpVrsz2DWsZ3P9nVq3fSMdu6qboBJg4dTojfh9P8yaN2LFxHT26dGb2/L+kzj+zzl+8eCl1/h6pc13/ts4/lwx2lwgZ/EYIIYShkcHuvryE9n72tD8YNW4ij+/c0DsDgrePD/mLl2H+rOkMHtBPu3zc5KnMW7QE/4ceemfHuHb9BhVq1mX7hrXYtW+rXf7TwMEcPHIMn/t39M5KcfT4SZq168i5Y4eoW7sWEH+Fq1VHex48eszdq256Z4NYt3EzvQcMwv2yCyWKFwPiO041bRqTKpUpjsePJLk9wMy585k8YxYP3a+RM0cOAKKioihVuTrlypRmx8Z1ejN+HTGaLTt38fDWNdKnTw/A69evKVy6AvYd2vHX3Fl6M+wdevP39eu4X3bBzMwMgICAQAqWKse4UcMZO2KY3oz6TVoQHhGBy9mT2hk9PDzvUaJiVVYt+YveDt2T3F5RFEpWqkb+vHk5tHu79vU/f+EidRo149Du7TRv0jjJjJiYGHJbl6BZ44asWbZYu3zX3v107NaDK87nqFi+XJIZr1+/JkehYgwZ0I/pkydoly9evpLBw0dJnSN1LnUeT1+d+z3wIGPGDElmfIk6f19y2npj1ak/kIS/bYT+y+dfhBBCiC8loU2Sv79/OQmvZaMG9Rn5+wScLrhgmTFjkts4OV9Eo9HQrFFDQkNDtctbNGnMtNlzueR2hRrVqiSZcc75AilSpKBhg3o6GS2bNWH1+o24375D4UIFk8w4f/EiWbNkoVyZ0h9kNOWngYPx8fUlwz+dhU9nuFCiWFFy58qpm9G0MZOmz9JZ9inOLi5Ur1IZC3NznfWbNWrI7v0HVGVcdLuMTb26GBkZadc3MjLCtn49LlxyVZVx6fJlWjVrSnR0tPZ53bRp01CjahWcL14i9Gc1GVcYN3KYzrPLOXNYUapEcc5fcKFDm9ZJbv8mLIy7Hp78OqCfzjPUZUuXInu2bDg5X6R2jepJZjx64sWzoCBaNmuqc9w29epgbGzMWafzWOupDdfLV4iIiKBFk8YfvSeDho2UOk/IkDrXLpM6T7zOXS//N3X+vuS09XJFPhG+vr7kzp37a++GEEII8REfHx9y5cr1tXfju/D48WMKFlT/BUsIIYT4L6hp66UjnwiNRoO/vz8WFhafvF0nNDSU3Llz4+Pj803f4vi9HAfIsRiq7+VYvpfjADkWQ6XvWBRF4c2bN+TIkYMUKWSImy8hJCSEjBkz4u3trb3V9Vv0I50H35Lv5Vi+l+MAORZD9b0cy5c4juS09XJrfSJSpEih+mpHunTpvumCS/C9HAfIsRiq7+VYvpfjADkWQ5XUsXzLnU1DlPAlKX369N9F/fwo58G35ns5lu/lOECOxVB9L8fyb49DbVsvf9IXQgghhBBCCCG+IdKRF0IIIYQQQgghviHSkf9MqVKlYuLEiaRKlepr78q/8r0cB8ixGKrv5Vi+l+MAORZD9T0dy7fie3nNv5fjADkWQ/S9HAfIsRiq7+VY/uvjkMHuhBBCCCGEEEKIb4hckRdCCCGEEEIIIb4h0pEXQgghhBBCCCG+IdKRF0IIIYQQQgghviHSkRdCCCGEEEIIIb4h0pEH/Pz86Nq1K5kyZSJNmjSULVuWq1evfnL9vXv3YmtrS5YsWUiXLh3VqlXjxIkTOuusX78eIyOjj/5FRkYa1LE4Ojomup+enp466+3Zs4fixYuTKlUqihcvzr59+/6vxwHJP5YePXokeiwlSpTQrvM13pd8+fIl+jsHDhz4yW2cnJyoUKECZmZmFChQgOXLl3+0zn/9niT3OAz5PEnusRjyeZLcYzHU8yQ2NpZx48aRP39+UqdOTYECBfjjjz/QaDRJbmeI58rnHIshny/fCmnLDfMz6ntoy7+XdhykLTfU80TacsM7X76Jtlz5wb18+VLJmzev0qNHD8XNzU158uSJcvr0aeXhw4ef3GbIkCHKrFmzlMuXLyv3799XxowZo5iYmCjXrl3TrrNu3TolXbp0SkBAgM4/QzuWc+fOKYBy7949nf2MjY3VruPi4qKkTJlSmT59uuLh4aFMnz5dMTY2VlxdXQ3qWEJCQnSOwcfHR7G0tFQmTpyoXedrvC9BQUE6v+vUqVMKoJw7dy7R9R8/fqykSZNGGTJkiHL37l1l1apViomJibJ7927tOl/jPUnucRjqefI5x2Ko58nnHIuhnidTp05VMmXKpBw+fFh58uSJsmvXLsXc3FxZsGDBJ7cx1HPlc47FkM+Xb4G05Yb5GfW9tOXfSzv+OcdiqOfJ5xyLoZ4nn3MshnieKIq05f/1+fLDd+RHjRql1KxZ81/nFC9eXJk8ebL2/+vWrVPSp0//r3OT43OOJeFD7dWrV59cp2PHjkrjxo11ljVq1Ejp1KnT5+ymKl/ifdm3b59iZGSkeHl5aZd9jfflQ0OGDFEKFiyoaDSaRH8+cuRIpWjRojrLfv75Z6Vq1ara/3+N9+RD+o4jMYZwniRG37EY6nmSmOS+L4ZynjRr1kzp1auXzrK2bdsqXbt2/eQ2hnqufM6xJMZQzxdDJG25YX5Gfa9t+ffSjiuKtOUf+lbfF0M5T6Qt/9j/83z54W+tP3jwIBUrVqRDhw5kzZqVcuXKsWrVqmRlaDQa3rx5g6Wlpc7ysLAw8ubNS65cuWjevDnXr1//krv+kX9zLOXKlcPKyooGDRpw7tw5nZ9dunSJhg0b6ixr1KgRLi4uX2zfP/Ql3pc1a9ZgY2ND3rx5dZb/1+/L+6Kjo9m8eTO9evXCyMgo0XU+9Xr//fffxMTEJLnO//M9eZ+a4/iQoZwnH0rOsRjaefKhz3lfDOU8qVmzJmfOnOH+/fsA3Lx5kwsXLtC0adNPbmOo58rnHMuHDPV8MVTSlscztM+o77Et/17acZC23FDOkw9JW24Y58s30ZZ/kT8HfMNSpUqlpEqVShkzZoxy7do1Zfny5YqZmZmyYcMG1RmzZ89WLC0tlWfPnmmXXbp0Sdm0aZNy48YN5fz580q7du2U1KlTK/fv3/9/HIaiKJ93LJ6ensrKlSuVq1evKi4uLkr//v0VIyMjxcnJSbuOiYmJsmXLFp3ttmzZopiamhrUsbzP399fSZkypbJjxw6d5V/jfXnfjh07lJQpUyp+fn6fXKdw4cLKtGnTdJZdvHhRARR/f39FUb7Oe/I+NcfxIUM5Tz6k5lgM9Tz5UHLfF0M6TzQajTJ69GjFyMhIMTY2VoyMjJTp06cnuY2hniufcywfMtTzxVBJW26Yn1HfY1v+vbTjiiJtuaGcJx+SttwwzpdvoS3/4TvyJiYmSrVq1XSWDRo0SOd2jqRs3bpVSZMmjXLq1Kkk14uLi1PKlCmjDBo06LP3VZ9/eywJmjdvrrRo0UInd+vWrTrrbN68WUmVKtXn76we//ZYpk+frmTKlEmJiopKcr3/4n15X8OGDZXmzZsnuU7hwoU/+qC4cOGCAmifofka78n71BzH+wzpPPlQco8lgSGcJx9K7rEY0nmybds2JVeuXMq2bduUW7duKRs3blQsLS2V9evXf3IbQz1XPudY3mfI54uhkrb8Y4bwGfU9tuXfSzuuKNKWK4phnCcfkrbcMM6Xb6Et/+FvrbeysqJ48eI6y4oVK4a3t7febXfs2EHv3r3ZuXMnNjY2Sa6bIkUKKlWqxIMHD/7V/ibl3xzL+6pWraqzn9mzZycwMFBnnaCgILJly/b5O6vHvzkWRVFYu3Yt3bp1w9TUNMl1/4v3JcHTp085ffo0ffr0SXK9T73exsbGZMqUKcl1/p/vSQK1x5HA0M6T9yX3WN5nCOfJ+5J7LIZ2nowYMYLRo0fTqVMnSpUqRbdu3Rg6dCgzZsz45DaGeq58zrEkMOTzxZBJW/4xQ/iM+t7a8u+lHQdpyxMYwnnyPmnL4xnC+fIttOU/fEe+Ro0a3Lt3T2fZ/fv3P3rG5EPbtm2jR48ebN26lWbNmun9PYqicOPGDaysrP7V/iblc4/lQ9evX9fZz2rVqnHq1CmddU6ePEn16tU/f2f1+DfH4uTkxMOHD+ndu7fedf+L9yXBunXryJo1q956+dTrXbFiRUxMTJJc5//5niRQexxgmOfJ+5JzLB8yhPPkfck9FkM7TyIiIkiRQrdJSpkyZZLTvBjqufI5xwKGf74YMmnLP2YIn1HfW1v+vbTjIG15AkM4T94nbXk8Qzhfvom2PNnX8L8zly9fVoyNjZVp06YpDx48ULZs2aKkSZNG2bx5s3ad0aNHK926ddP+f+vWrYqxsbGyZMkSnWkDQkJCtOtMmjRJOX78uPLo0SPl+vXrSs+ePRVjY2PFzc3NoI5l/vz5yr59+5T79+8rt2/fVkaPHq0Ayp49e7TrXLx4UUmZMqUyc+ZMxcPDQ5k5c+b/fcqHzzmWBF27dlWqVKmSaO7XeF8UJf62mTx58iijRo366GcfHkfCNBxDhw5V7t69q6xZs+ajaTi+xnuS3OMw1PPkc47FUM+TzzmWBIZ2njg4OCg5c+bUTvOyd+9eJXPmzMrIkSM/eSyGeq58zrEY+vli6KQtN8zPqO+pLf9e2vHkHouhniefcyyGep58zrEkMLTzRNry//Z8+eE78oqiKIcOHVJKliyppEqVSilatKiycuVKnZ87ODgoderU0f6/Tp06CvDRPwcHB+06v/76q5InTx7F1NRUyZIli9KwYUPFxcXF4I5l1qxZSsGCBRUzMzMlY8aMSs2aNZUjR458lLtr1y6lSJEiiomJiVK0aFGdD73/l+Qei6LEz6uZOnXqj9ZN8LXelxMnTmjnLv1QYsfh6OiolCtXTjE1NVXy5cunLFu27KPtvsZ7kpzjMOTzRFGSdyyGfJ4oSvLryxDPk9DQUGXIkCFKnjx5FDMzM6VAgQLK77//rvPM37dyrnzOsRj6+fItkLbcMD+jvpe2/HtpxxVF2nJDPE8URdpyQztfvoW23EhRFCX51/GFEEIIIYQQQgjxNfzwz8gLIYQQQgghhBDfEunICyGEEEIIIYQQ3xDpyAshhBBCCCGEEN8Q6cgLIYQQQgghhBDfEOnICyGEEEIIIYQQ3xDpyAshhBBCCCGEEN8Q6cgLIYQQQgghhBDfEOnIC/Gd8fLywsjIiBs3bvxf8o2MjNi/f/9nb+/o6IiRkRFGRka0bt06yXXr1q3Lr7/++tm/y5DUrVtXe9z/r/dGCCHEj0Pae8Mk7b34r0hHXogvqEePHnobq/+33LlzExAQQMmSJYF3DWlISMhX3a8P3bt3j/Xr13/t3fjP7N27l8uXL3/t3RBCCPEFSHuvnrT3Qvx/GH/tHRBCfFkpU6Yke/bsX3s39MqaNSsZMmT42rtBTEwMJiYm//ffY2lpSWho6P/99wghhPgxSHufPNLei++NXJEX4j/k5ORE5cqVSZUqFVZWVowePZrY2Fjtz+vWrcvgwYMZOXIklpaWZM+enUmTJulkeHp6UrNmTczMzChevDinT5/Wuf3t/VvtvLy8qFevHgAZM2bEyMiIHj16AJAvXz4WLFigk122bFmd3/fgwQNq166t/V2nTp366Jj8/Pyws7MjY8aMZMqUiVatWuHl5ZXs1yY8PJzu3btjbm6OlZUVf/7550frREdHM3LkSHLmzEnatGmpUqUKjo6OOuusWrWK3LlzkyZNGtq0acO8efN0vkBMmjSJsmXLsnbtWgoUKECqVKlQFIXXr1/Tt29fsmbNSrp06ahfvz43b97UyT506BAVKlTAzMyMAgUKMHnyZJ33b9KkSeTJk4dUqVKRI0cOBg8enOzXQQghxLdP2vtPk/ZeiC9DOvJC/Ef8/Pxo2rQplSpV4ubNmyxbtow1a9YwdepUnfU2bNhA2rRpcXNzY/bs2fzxxx/aBlWj0Xct2/IAAAlCSURBVNC6dWvSpEmDm5sbK1eu5Pfff//k78ydOzd79uwB4m9tCwgI4K+//lK1vxqNhrZt25IyZUpcXV1Zvnw5o0aN0lknIiKCevXqYW5uzvnz57lw4QLm5uY0btyY6Ojo5Lw8jBgxgnPnzrFv3z5OnjyJo6MjV69e1VmnZ8+eXLx4ke3bt3Pr1i06dOhA48aNefDgAQAXL16kX79+DBkyhBs3bmBra8u0adM++l0PHz5k586d7NmzR/v8WrNmzQgMDOTo0aNcvXqV8uXL06BBA16+fAnAiRMn6Nq1K4MHD+bu3busWLGC9evXa/N3797N/PnzWbFiBQ8ePGD//v2UKlUqWa+BEEKIb5+090mT9l6IL0QRQnwxDg4OSqtWrRL92dixY5UiRYooGo1Gu2zJkiWKubm5EhcXpyiKotSpU0epWbOmznaVKlVSRo0apSiKohw7dkwxNjZWAgICtD8/deqUAij79u1TFEVRnjx5ogDK9evXFUVRlHPnzimA8urVK53cvHnzKvPnz9dZVqZMGWXixImKoijKiRMnlJQpUyo+Pj7anx87dkznd61Zs+ajY4qKilJSp06tnDhxItHXIbH9efPmjWJqaqps375du+zFixdK6tSplSFDhiiKoigPHz5UjIyMFD8/P528Bg0aKGPGjFEURVHs7OyUZs2a6fy8S5cuSvr06bX/nzhxomJiYqIEBQVpl505c0ZJly6dEhkZqbNtwYIFlRUrViiKoii1atVSpk+frvPzTZs2KVZWVoqiKMqff/6pWFtbK9HR0Yket6J8/N4IIYT4Nkl7L+29tPfia5Nn5IX4j3h4eFCtWjWMjIy0y2rUqEFYWBi+vr7kyZMHgNKlS+tsZ2VlRVBQEBD/V/bcuXPrPBNXuXLl/9v+5smTh1y5cmmXVatWTWedq1ev8vDhQywsLHSWR0ZG8ujRI9W/69GjR0RHR+vkW1paUqRIEe3/r127hqIoWFtb62wbFRVFpkyZgPjXp02bNjo/r1y5MocPH9ZZljdvXrJkyaJzHGFhYdqcBG/fvtUex9WrV7ly5YrOX/zj4uKIjIwkIiKCDh06sGDBAgoUKEDjxo1p2rQpLVq0wNhYPmaFEOJHIu39p0l7L8SXIxUnxH9EURSdRj1hGaCz/MOBWIyMjNBoNJ/M+FwpUqTQ/v4EMTExH+3bh/vyPo1GQ4UKFdiyZctH677fcOqT2O/6kEajIWXKlFy9epWUKVPq/Mzc3Fyb86nX+H1p06b9KNvKyuqj5+8A7fN2Go2GyZMn07Zt24/WMTMzI3fu3Ny7d49Tp05x+vRpBgwYwJw5c3BycvpPBtcRQghhGKS9/zRp74X4cqQjL8R/pHjx4uzZs0en8XFxccHCwoKcOXOqyihatCje3t48e/aMbNmyAXDlypUktzE1NQXi/5r8vixZshAQEKD9f2hoKE+ePNHZX29vb/z9/cmRIwcAly5d0skoX748O3bs0A4Y87kKFSqEiYkJrq6u2isVr1694v79+9SpUweAcuXKERcXR1BQELVq1Uo0p2jRoh9N+fL333/r/f3ly5cnMDAQY2Nj8uXL98l17t27R6FChT6Zkzp1alq2bEnLli0ZOHAgRYsWxd3dnfLly+vdByGEEN8Hae8/Tdp7Ib4cGexOiC/s9evX3LhxQ+eft7c3AwYMwMfHh0GDBuHp6cmBAweYOHEiv/32GylSqDsVbW1tKViwIA4ODty6dYuLFy9qB7/51F/u8+bNi5GREYcPH+b58+eEhYUBUL9+fTZt2oSzszO3b9/GwcFB5y/fNjY2FClShO7du3Pz5k2cnZ0/GminS5cuZM6cmVatWuHs7MyTJ09wcnJiyJAh+Pr6qn7NzM3N6d27NyNGjODMmTPcvn2bHj166Lwu1tbWdOnShe7du7N3716ePHnClStXmDVrFkePHgVg0KBBHD16lHnz5vHgwQNWrFjBsWPH9F7VsLGxoVq1arRu3ZoTJ07g5eWFi4sL48aN034xmDBhAhs3bmTSpEncuXMHDw8PduzYwbhx4wBYv349a9as4fbt2zx+/JhNmzaROnVq8ubNq/p1EEII8e2Q9l7ae2nvxVf13z6SL8T3zcHBQQE++ufg4KAoiqI4OjoqlSpVUkxNTZXs2bMro0aNUmJiYrTb16lTRzvYS4JWrVppt1cURfHw8FBq1KihmJqaKkWLFlUOHTqkAMrx48cVRUl8gJU//vhDyZ49u2JkZKTNev36tdKxY0clXbp0Su7cuZX169frDH6jKIpy7949pWbNmoqpqalibW2tHD9+XGfwG0VRlICAAKV79+5K5syZlVSpUikFChRQfvrpJ+X169eJvkafGoznzZs3SteuXZU0adIo2bJlU2bPnv3R6xEdHa1MmDBByZcvn2JiYqJkz55dadOmjXLr1i3tOitXrlRy5syppE6dWmndurUydepUJXv27NqfT5w4USlTpsxH+xUaGqoMGjRIyZEjh2JiYqLkzp1b6dKli+Lt7a1d5/jx40r16tWV1KlTK+nSpVMqV66srFy5UlEURdm3b59SpUoVJV26dEratGmVqlWrKqdPn9b5HTL4jRBCfB+kvZf2Xtp78bUZKYqKh1WEEAbr4sWL1KxZk4cPH1KwYMGvvTt6OTo6Uq9ePV69eqUz3+v/y08//YSnpyfOzs7/99+lj5eXF/nz5+f69euULVv2a++OEEKIb4i090mT9l78aOQZeSG+Mfv27cPc3JzChQvz8OFDhgwZQo0aNb6JRv19uXLlokWLFmzbtu2L5s6dOxdbW1vSpk3LsWPH2LBhA0uXLv2iv+NzNGnShPPnz3/t3RBCCPGNkPY+adLeix+dXJEX4huzceNGpkyZgo+PD5kzZ8bGxoY///zzo6lUDNXbt2/x8/MD4p+Ve39qnS+hY8eOODo68ubNGwoUKMCgQYPo16/fF/0dn8PPz4+3b98CkCdPHu2gREIIIURipL1PmrT34kcnHXkhhBBCCCGEEOIbIqPWCyGEEEIIIYQQ3xDpyAshhBBCCCGEEN8Q6cgLIYQQQgghhBDfEOnICyGEEEIIIYQQ3xDpyAshhBBCCCGEEN8Q6cgLIYQQQgghhBDfEOnICyGEEEIIIYQQ3xDpyAshhBBCCCGEEN8Q6cgLIYQQQgghhBDfkP8BayE059Q/894AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(12, 5))\n", "fig.suptitle(\"Figure 1. Landmask\", fontsize=18, y=1.01)\n", @@ -293,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -337,7 +326,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -395,7 +384,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -405,20 +394,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(10, 4), constrained_layout=True)\n", "fig.suptitle(\"Figure 2. Coast and Shore\", fontsize=18, y=1.04)\n", @@ -557,7 +535,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -622,7 +600,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -631,20 +609,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(7, 6), constrained_layout=True)\n", "fig.suptitle(\"Figure 3. Displacement field\", fontsize=18, y=1.04)\n", @@ -714,7 +681,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -739,7 +706,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -748,20 +715,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(6, 5), constrained_layout=True)\n", "\n", @@ -795,11 +751,11 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "DisplacementParticle = parcels.JITParticle.add_variables(\n", + "DisplacementParticle = parcels.Particle.add_variables(\n", " [\n", " parcels.Variable(\"dU\"),\n", " parcels.Variable(\"dV\"),\n", @@ -840,7 +796,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -853,7 +809,7 @@ "dimensions = {\"U\": dims, \"V\": dims}\n", "\n", "indices = {\n", - " \"lon\": range(lonmin, lonmax),\n", + " \"lon\": range(lonmin, lonmax), # TODO v4: Remove `indices` argument from this cell\n", " \"lat\": range(latmin, latmax),\n", "} # to load only a small part of the domain\n", "\n", @@ -872,7 +828,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -888,21 +844,12 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in SMOC.zarr.\n", - "100%|██████████| 360000.0/360000.0 [00:07<00:00, 45768.71it/s]\n" - ] - } - ], + "outputs": [], "source": [ "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=lons, lat=lats, time=time\n", + " fieldset=fieldset, pclass=parcels.Particle, lon=lons, lat=lats, time=time\n", ")\n", "\n", "kernels = parcels.AdvectionRK4\n", @@ -922,12 +869,15 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "fieldset = parcels.FieldSet.from_netcdf(\n", - " filenames, variables, dimensions, indices=indices\n", + " filenames,\n", + " variables,\n", + " dimensions,\n", + " indices=indices, # TODO v4: Remove `indices` argument from this cell\n", ")\n", "u_displacement = v_x\n", "v_displacement = v_y\n", @@ -955,7 +905,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -981,18 +931,9 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in SMOC-disp.zarr.\n", - "100%|██████████| 360000.0/360000.0 [00:09<00:00, 37981.51it/s]\n" - ] - } - ], + "outputs": [], "source": [ "pset = parcels.ParticleSet(\n", " fieldset=fieldset, pclass=DisplacementParticle, lon=lons, lat=lats, time=time\n", @@ -1017,7 +958,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1027,20 +968,9 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(16, 4), facecolor=\"silver\", constrained_layout=True)\n", "fig.suptitle(\"Figure 5. Trajectory difference\", fontsize=18, y=1.06)\n", @@ -1210,7 +1140,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1220,20 +1150,9 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(11, 6), constrained_layout=True)\n", "\n", @@ -1324,20 +1243,9 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "cells_x = np.array([[0, 0], [1, 1], [2, 2]])\n", "cells_y = np.array([[0, 1], [0, 1], [0, 1]])\n", @@ -1463,7 +1371,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1488,24 +1396,15 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in SMOC_partialslip.zarr.\n", - "100%|██████████| 360000.0/360000.0 [00:07<00:00, 48812.02it/s]\n" - ] - } - ], + "outputs": [], "source": [ "fieldset = parcels.FieldSet.from_netcdf(\n", " filenames,\n", " variables,\n", " dimensions,\n", - " indices=indices,\n", + " indices=indices, # TODO v4: Remove `indices` argument from this cell\n", " interp_method={\n", " \"U\": \"partialslip\",\n", " \"V\": \"partialslip\",\n", @@ -1513,7 +1412,7 @@ ")\n", "\n", "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=lons, lat=lats, time=time\n", + " fieldset=fieldset, pclass=parcels.Particle, lon=lons, lat=lats, time=time\n", ")\n", "\n", "kernels = pset.Kernel(parcels.AdvectionRK4)\n", @@ -1535,31 +1434,22 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in SMOC_freeslip.zarr.\n", - "100%|██████████| 360000.0/360000.0 [00:07<00:00, 50729.37it/s]\n" - ] - } - ], + "outputs": [], "source": [ "fieldset = parcels.FieldSet.from_netcdf(\n", " filenames,\n", " variables,\n", " dimensions,\n", - " indices=indices,\n", + " indices=indices, # TODO v4: Remove `indices` argument from this cell\n", " interp_method={\n", " \"U\": \"freeslip\",\n", " \"V\": \"freeslip\",\n", " }, # Setting the interpolation for U and V\n", ")\n", "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=lons, lat=lats, time=time\n", + " fieldset=fieldset, pclass=parcels.Particle, lon=lons, lat=lats, time=time\n", ")\n", "\n", "kernels = pset.Kernel(parcels.AdvectionRK4)\n", @@ -1579,7 +1469,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1590,20 +1480,9 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(18, 5), constrained_layout=True)\n", "fig.suptitle(\"Figure 8. Solution comparison\", fontsize=18, y=1.06)\n", @@ -1717,7 +1596,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "parcels", "language": "python", "name": "python3" }, @@ -1731,7 +1610,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/docs/examples/example_brownian.py b/docs/examples/example_brownian.py index 370bd843f..85c3cfb93 100644 --- a/docs/examples/example_brownian.py +++ b/docs/examples/example_brownian.py @@ -1,3 +1,4 @@ +import random from datetime import timedelta import numpy as np @@ -5,16 +6,13 @@ import parcels -ptype = {"scipy": parcels.ScipyParticle, "jit": parcels.JITParticle} - def mesh_conversion(mesh): return (1852.0 * 60) if mesh == "spherical" else 1.0 -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize("mesh", ["flat", "spherical"]) -def test_brownian_example(mode, mesh, npart=3000): +def test_brownian_example(mesh, npart=3000): fieldset = parcels.FieldSet.from_data( {"U": 0, "V": 0}, {"lon": 0, "lat": 0}, mesh=mesh ) @@ -30,13 +28,16 @@ def test_brownian_example(mode, mesh, npart=3000): ) # Set random seed - parcels.ParcelsRandom.seed(123456) + random.seed(123456) runtime = timedelta(days=1) - parcels.ParcelsRandom.seed(1234) + random.seed(1234) pset = parcels.ParticleSet( - fieldset=fieldset, pclass=ptype[mode], lon=np.zeros(npart), lat=np.zeros(npart) + fieldset=fieldset, + pclass=parcels.Particle, + lon=np.zeros(npart), + lat=np.zeros(npart), ) pset.execute( pset.Kernel(parcels.DiffusionUniformKh), runtime=runtime, dt=timedelta(hours=1) @@ -58,4 +59,4 @@ def test_brownian_example(mode, mesh, npart=3000): if __name__ == "__main__": - test_brownian_example("jit", "spherical", npart=2000) + test_brownian_example("spherical", npart=2000) diff --git a/docs/examples/example_dask_chunk_OCMs.py b/docs/examples/example_dask_chunk_OCMs.py deleted file mode 100644 index 27dd8c233..000000000 --- a/docs/examples/example_dask_chunk_OCMs.py +++ /dev/null @@ -1,790 +0,0 @@ -import math -from datetime import timedelta -from glob import glob - -import dask -import numpy as np -import pytest - -import parcels -from parcels.tools.statuscodes import DaskChunkingError - -ptype = {"scipy": parcels.ScipyParticle, "jit": parcels.JITParticle} - - -def compute_nemo_particle_advection(fieldset, mode): - npart = 20 - lonp = 2.5 * np.ones(npart) - latp = [i for i in 52.0 + (-1e-3 + np.random.rand(npart) * 2.0 * 1e-3)] - - def periodicBC(particle, fieldSet, time): # pragma: no cover - if particle.lon > 15.0: - particle_dlon -= 15.0 # noqa - if particle.lon < 0: - particle_dlon += 15.0 - if particle.lat > 60.0: - particle_dlat -= 11.0 # noqa - if particle.lat < 49.0: - particle_dlat += 11.0 - - pset = parcels.ParticleSet.from_list(fieldset, ptype[mode], lon=lonp, lat=latp) - kernels = pset.Kernel(parcels.AdvectionRK4) + periodicBC - pset.execute(kernels, runtime=timedelta(days=4), dt=timedelta(hours=6)) - return pset - - -@pytest.mark.parametrize("mode", ["jit"]) -@pytest.mark.parametrize("chunk_mode", [False, "auto", "specific", "failsafe"]) -def test_nemo_3D(mode, chunk_mode): - if chunk_mode in [ - "auto", - ]: - dask.config.set({"array.chunk-size": "256KiB"}) - else: - dask.config.set({"array.chunk-size": "128MiB"}) - data_folder = parcels.download_example_dataset("NemoNorthSeaORCA025-N006_data") - ufiles = sorted(glob(f"{data_folder}/ORCA*U.nc")) - vfiles = sorted(glob(f"{data_folder}/ORCA*V.nc")) - wfiles = sorted(glob(f"{data_folder}/ORCA*W.nc")) - mesh_mask = f"{data_folder}/coordinates.nc" - - filenames = { - "U": {"lon": mesh_mask, "lat": mesh_mask, "depth": wfiles[0], "data": ufiles}, - "V": {"lon": mesh_mask, "lat": mesh_mask, "depth": wfiles[0], "data": vfiles}, - "W": {"lon": mesh_mask, "lat": mesh_mask, "depth": wfiles[0], "data": wfiles}, - } - variables = {"U": "uo", "V": "vo", "W": "wo"} - dimensions = { - "U": { - "lon": "glamf", - "lat": "gphif", - "depth": "depthw", - "time": "time_counter", - }, - "V": { - "lon": "glamf", - "lat": "gphif", - "depth": "depthw", - "time": "time_counter", - }, - "W": { - "lon": "glamf", - "lat": "gphif", - "depth": "depthw", - "time": "time_counter", - }, - } - chs = False - if chunk_mode == "auto": - chs = "auto" - elif chunk_mode == "specific": - chs = { - "U": {"depth": ("depthu", 75), "lat": ("y", 16), "lon": ("x", 16)}, - "V": {"depth": ("depthv", 75), "lat": ("y", 16), "lon": ("x", 16)}, - "W": {"depth": ("depthw", 75), "lat": ("y", 16), "lon": ("x", 16)}, - } - elif chunk_mode == "failsafe": # chunking time and but not depth - filenames = { - "U": { - "lon": mesh_mask, - "lat": mesh_mask, - "depth": wfiles[0], - "data": ufiles, - }, - "V": { - "lon": mesh_mask, - "lat": mesh_mask, - "depth": wfiles[0], - "data": vfiles, - }, - } - variables = {"U": "uo", "V": "vo"} - dimensions = { - "U": { - "lon": "glamf", - "lat": "gphif", - "depth": "depthw", - "time": "time_counter", - }, - "V": { - "lon": "glamf", - "lat": "gphif", - "depth": "depthw", - "time": "time_counter", - }, - } - chs = { - "U": { - "time": ("time_counter", 1), - "depth": ("depthu", 25), - "lat": ("y", -1), - "lon": ("x", -1), - }, - "V": { - "time": ("time_counter", 1), - "depth": ("depthv", 75), - "lat": ("y", -1), - "lon": ("x", -1), - }, - } - - fieldset = parcels.FieldSet.from_nemo( - filenames, variables, dimensions, chunksize=chs - ) - - compute_nemo_particle_advection(fieldset, mode) - # Nemo sample file dimensions: depthu=75, y=201, x=151 - if chunk_mode != "failsafe": - assert len(fieldset.U.grid._load_chunk) == len(fieldset.V.grid._load_chunk) - assert len(fieldset.U.grid._load_chunk) == len(fieldset.W.grid._load_chunk) - if chunk_mode is False: - assert len(fieldset.U.grid._load_chunk) == 1 - elif chunk_mode == "auto": - assert ( - fieldset.gridset.size == 3 - ) # because three different grids in 'auto' mode - assert len(fieldset.U.grid._load_chunk) != 1 - elif chunk_mode == "specific": - assert len(fieldset.U.grid._load_chunk) == ( - 1 - * int(math.ceil(75.0 / 75.0)) - * int(math.ceil(201.0 / 16.0)) - * int(math.ceil(151.0 / 16.0)) - ) - elif chunk_mode == "failsafe": # chunking time and depth but not lat and lon - assert len(fieldset.U.grid._load_chunk) != 1 - assert len(fieldset.U.grid._load_chunk) == ( - 1 - * int(math.ceil(75.0 / 25.0)) - * int(math.ceil(201.0 / 171.0)) - * int(math.ceil(151.0 / 151.0)) - ) - assert len(fieldset.V.grid._load_chunk) != 1 - assert len(fieldset.V.grid._load_chunk) == ( - 1 - * int(math.ceil(75.0 / 75.0)) - * int(math.ceil(201.0 / 171.0)) - * int(math.ceil(151.0 / 151.0)) - ) - - -@pytest.mark.parametrize("mode", ["jit"]) -@pytest.mark.parametrize("chunk_mode", [False, "auto", "specific", "failsafe"]) -def test_globcurrent_2D(mode, chunk_mode): - if chunk_mode in [ - "auto", - ]: - dask.config.set({"array.chunk-size": "16KiB"}) - else: - dask.config.set({"array.chunk-size": "128MiB"}) - data_folder = parcels.download_example_dataset("GlobCurrent_example_data") - filenames = str( - data_folder / "200201*-GLOBCURRENT-L4-CUReul_hs-ALT_SUM-v02.0-fv01.0.nc" - ) - variables = { - "U": "eastward_eulerian_current_velocity", - "V": "northward_eulerian_current_velocity", - } - dimensions = {"lat": "lat", "lon": "lon", "time": "time"} - chs = False - if chunk_mode == "auto": - chs = "auto" - elif chunk_mode == "specific": - chs = { - "U": {"lat": ("lat", 8), "lon": ("lon", 8)}, - "V": {"lat": ("lat", 8), "lon": ("lon", 8)}, - } - elif chunk_mode == "failsafe": # chunking time but not lat - chs = { - "U": {"time": ("time", 1), "lat": ("lat", 10), "lon": ("lon", -1)}, - "V": {"time": ("time", 1), "lat": ("lat", -1), "lon": ("lon", -1)}, - } - - fieldset = parcels.FieldSet.from_netcdf( - filenames, variables, dimensions, chunksize=chs - ) - try: - pset = parcels.ParticleSet(fieldset, pclass=ptype[mode], lon=25, lat=-35) - pset.execute( - parcels.AdvectionRK4, runtime=timedelta(days=1), dt=timedelta(minutes=5) - ) - except DaskChunkingError: - # we removed the failsafe, so now if all chunksize dimensions are incorrect, there is nothing left to chunk, - # which raises an error saying so. This is the expected behaviour - if chunk_mode == "failsafe": - return - # GlobCurrent sample file dimensions: time=UNLIMITED, lat=41, lon=81 - if chunk_mode != "failsafe": # chunking time but not lat - assert len(fieldset.U.grid._load_chunk) == len(fieldset.V.grid._load_chunk) - if chunk_mode is False: - assert len(fieldset.U.grid._load_chunk) == 1 - elif chunk_mode == "auto": - assert len(fieldset.U.grid._load_chunk) != 1 - elif chunk_mode == "specific": - assert len(fieldset.U.grid._load_chunk) == ( - 1 * int(math.ceil(41.0 / 8.0)) * int(math.ceil(81.0 / 8.0)) - ) - elif chunk_mode == "failsafe": # chunking time but not lat - assert len(fieldset.U.grid._load_chunk) != 1 - assert len(fieldset.V.grid._load_chunk) != 1 - assert abs(pset[0].lon - 23.8) < 1 - assert abs(pset[0].lat - -35.3) < 1 - - -@pytest.mark.skip( - reason="Started failing around #1644 (2024-08-08). Some change in chunking, inconsistent behavior." -) -@pytest.mark.parametrize("mode", ["jit"]) -@pytest.mark.parametrize("chunk_mode", [False, "auto", "specific", "failsafe"]) -def test_pop(mode, chunk_mode): - if chunk_mode in [ - "auto", - ]: - dask.config.set({"array.chunk-size": "256KiB"}) - else: - dask.config.set({"array.chunk-size": "128MiB"}) - data_folder = parcels.download_example_dataset("POPSouthernOcean_data") - filenames = str(data_folder / "t.x1_SAMOC_flux.1690*.nc") - variables = {"U": "UVEL", "V": "VVEL", "W": "WVEL"} - timestamps = np.expand_dims( - np.array([np.datetime64(f"2000-{m:02d}-01") for m in range(1, 7)]), axis=1 - ) - dimensions = {"lon": "ULON", "lat": "ULAT", "depth": "w_dep"} - chs = False - if chunk_mode == "auto": - chs = "auto" - elif chunk_mode == "specific": - chs = {"lon": ("i", 8), "lat": ("j", 8), "depth": ("k", 3)} - elif chunk_mode == "failsafe": # here: bad depth entry - chs = {"depth": ("wz", 3), "lat": ("j", 8), "lon": ("i", 8)} - - fieldset = parcels.FieldSet.from_pop( - filenames, variables, dimensions, chunksize=chs, timestamps=timestamps - ) - - npart = 20 - lonp = 70.0 * np.ones(npart) - latp = [i for i in -45.0 + (-0.25 + np.random.rand(npart) * 2.0 * 0.25)] - pset = parcels.ParticleSet.from_list(fieldset, ptype[mode], lon=lonp, lat=latp) - pset.execute(parcels.AdvectionRK4, runtime=timedelta(days=90), dt=timedelta(days=2)) - # POP sample file dimensions: k=21, j=60, i=60 - assert len(fieldset.U.grid._load_chunk) == len(fieldset.V.grid._load_chunk) - assert len(fieldset.U.grid._load_chunk) == len(fieldset.W.grid._load_chunk) - if chunk_mode is False: - assert fieldset.gridset.size == 1 - assert len(fieldset.U.grid._load_chunk) == 1 - assert len(fieldset.V.grid._load_chunk) == 1 - assert len(fieldset.W.grid._load_chunk) == 1 - elif chunk_mode == "auto": - assert ( - fieldset.gridset.size == 3 - ) # because three different grids in 'auto' mode - assert len(fieldset.U.grid._load_chunk) != 1 - assert len(fieldset.V.grid._load_chunk) != 1 - assert len(fieldset.W.grid._load_chunk) != 1 - elif chunk_mode == "specific": - assert fieldset.gridset.size == 1 - assert len(fieldset.U.grid._load_chunk) == ( - int(math.ceil(21.0 / 3.0)) - * int(math.ceil(60.0 / 8.0)) - * int(math.ceil(60.0 / 8.0)) - ) - elif chunk_mode == "failsafe": # here: done a typo in the netcdf dimname field - assert fieldset.gridset.size == 1 - assert len(fieldset.U.grid._load_chunk) != 1 - assert len(fieldset.V.grid._load_chunk) != 1 - assert len(fieldset.W.grid._load_chunk) != 1 - assert len(fieldset.U.grid._load_chunk) == ( - int(math.ceil(21.0 / 3.0)) - * int(math.ceil(60.0 / 8.0)) - * int(math.ceil(60.0 / 8.0)) - ) - - -@pytest.mark.parametrize("mode", ["jit"]) -@pytest.mark.parametrize("chunk_mode", [False, "auto", "specific", "failsafe"]) -def test_swash(mode, chunk_mode): - if chunk_mode in [ - "auto", - ]: - dask.config.set({"array.chunk-size": "32KiB"}) - else: - dask.config.set({"array.chunk-size": "128MiB"}) - data_folder = parcels.download_example_dataset("SWASH_data") - filenames = str(data_folder / "field_*.nc") - variables = { - "U": "cross-shore velocity", - "V": "along-shore velocity", - "W": "vertical velocity", - "depth_w": "time varying depth", - "depth_u": "time varying depth_u", - } - dimensions = { - "U": {"lon": "x", "lat": "y", "depth": "not_yet_set", "time": "t"}, - "V": {"lon": "x", "lat": "y", "depth": "not_yet_set", "time": "t"}, - "W": {"lon": "x", "lat": "y", "depth": "not_yet_set", "time": "t"}, - "depth_w": {"lon": "x", "lat": "y", "depth": "not_yet_set", "time": "t"}, - "depth_u": {"lon": "x", "lat": "y", "depth": "not_yet_set", "time": "t"}, - } - chs = False - if chunk_mode == "auto": - chs = "auto" - elif chunk_mode == "specific": - chs = { - "U": {"depth": ("z_u", 6), "lat": ("y", 4), "lon": ("x", 4)}, - "V": {"depth": ("z_u", 6), "lat": ("y", 4), "lon": ("x", 4)}, - "W": {"depth": ("z", 7), "lat": ("y", 4), "lon": ("x", 4)}, - "depth_w": {"depth": ("z", 7), "lat": ("y", 4), "lon": ("x", 4)}, - "depth_u": {"depth": ("z_u", 6), "lat": ("y", 4), "lon": ("x", 4)}, - } - elif ( - chunk_mode == "failsafe" - ): # here: incorrect matching between dimension names and their attachment to the NC-variables - chs = { - "U": {"depth": ("depth", 7), "lat": ("y", 4), "lon": ("x", 4)}, - "V": {"depth": ("z_u", 6), "lat": ("y", 4), "lon": ("x", 4)}, - "W": {"depth": ("z", 7), "lat": ("y", 4), "lon": ("x", 4)}, - "depth_w": {"depth": ("z", 7), "lat": ("y", 4), "lon": ("x", 4)}, - "depth_u": {"depth": ("z_u", 6), "lat": ("y", 4), "lon": ("x", 4)}, - } - fieldset = parcels.FieldSet.from_netcdf( - filenames, - variables, - dimensions, - mesh="flat", - allow_time_extrapolation=True, - chunksize=chs, - ) - fieldset.U.set_depth_from_field(fieldset.depth_u) - fieldset.V.set_depth_from_field(fieldset.depth_u) - fieldset.W.set_depth_from_field(fieldset.depth_w) - - npart = 20 - lonp = [i for i in 9.5 + (-0.2 + np.random.rand(npart) * 2.0 * 0.2)] - latp = [i for i in np.arange(start=12.3, stop=13.1, step=0.04)[0:20]] - depthp = [ - -0.1, - ] * npart - pset = parcels.ParticleSet.from_list( - fieldset, ptype[mode], lon=lonp, lat=latp, depth=depthp - ) - pset.execute( - parcels.AdvectionRK4, - runtime=timedelta(seconds=0.2), - dt=timedelta(seconds=0.005), - ) - # SWASH sample file dimensions: t=1, z=7, z_u=6, y=21, x=51 - if chunk_mode not in [ - "failsafe", - ]: - assert len(fieldset.U.grid._load_chunk) == len( - fieldset.V.grid._load_chunk - ), f"U {fieldset.U.grid.chunk_info} vs V {fieldset.V.grid.chunk_info}" - if chunk_mode not in ["failsafe", "auto"]: - assert len(fieldset.U.grid._load_chunk) == len( - fieldset.W.grid._load_chunk - ), f"U {fieldset.U.grid.chunk_info} vs W {fieldset.W.grid.chunk_info}" - if chunk_mode is False: - assert len(fieldset.U.grid._load_chunk) == 1 - else: - assert len(fieldset.U.grid._load_chunk) != 1 - assert len(fieldset.V.grid._load_chunk) != 1 - assert len(fieldset.W.grid._load_chunk) != 1 - if chunk_mode == "specific": - assert len(fieldset.U.grid._load_chunk) == ( - 1 - * int(math.ceil(6.0 / 6.0)) - * int(math.ceil(21.0 / 4.0)) - * int(math.ceil(51.0 / 4.0)) - ) - assert len(fieldset.V.grid._load_chunk) == ( - 1 - * int(math.ceil(6.0 / 6.0)) - * int(math.ceil(21.0 / 4.0)) - * int(math.ceil(51.0 / 4.0)) - ) - assert len(fieldset.W.grid._load_chunk) == ( - 1 - * int(math.ceil(7.0 / 7.0)) - * int(math.ceil(21.0 / 4.0)) - * int(math.ceil(51.0 / 4.0)) - ) - - -@pytest.mark.parametrize("mode", ["jit"]) -@pytest.mark.parametrize("chunk_mode", [False, "auto", "specific"]) -def test_ofam_3D(mode, chunk_mode): - if chunk_mode in [ - "auto", - ]: - dask.config.set({"array.chunk-size": "1024KiB"}) - else: - dask.config.set({"array.chunk-size": "128MiB"}) - - data_folder = parcels.download_example_dataset("OFAM_example_data") - filenames = { - "U": f"{data_folder}/OFAM_simple_U.nc", - "V": f"{data_folder}/OFAM_simple_V.nc", - } - variables = {"U": "u", "V": "v"} - dimensions = { - "lat": "yu_ocean", - "lon": "xu_ocean", - "depth": "st_ocean", - "time": "Time", - } - - chs = False - if chunk_mode == "auto": - chs = "auto" - elif chunk_mode == "specific": - chs = { - "lon": ("xu_ocean", 100), - "lat": ("yu_ocean", 50), - "depth": ("st_edges_ocean", 60), - "time": ("Time", 1), - } - fieldset = parcels.FieldSet.from_netcdf( - filenames, variables, dimensions, allow_time_extrapolation=True, chunksize=chs - ) - - pset = parcels.ParticleSet(fieldset, pclass=ptype[mode], lon=180, lat=10, depth=2.5) - pset.execute( - parcels.AdvectionRK4, runtime=timedelta(days=10), dt=timedelta(minutes=5) - ) - # OFAM sample file dimensions: time=UNLIMITED, st_ocean=1, st_edges_ocean=52, lat=601, lon=2001 - assert len(fieldset.U.grid._load_chunk) == len(fieldset.V.grid._load_chunk) - if chunk_mode is False: - assert len(fieldset.U.grid._load_chunk) == 1 - elif chunk_mode == "auto": - assert len(fieldset.U.grid._load_chunk) != 1 - elif chunk_mode == "specific": - numblocks = [i for i in fieldset.U.grid.chunk_info[1:3]] - dblocks = 1 - vblocks = 0 - for bsize in fieldset.U.grid.chunk_info[3 : 3 + numblocks[0]]: - vblocks += bsize - ublocks = 0 - for bsize in fieldset.U.grid.chunk_info[ - 3 + numblocks[0] : 3 + numblocks[0] + numblocks[1] - ]: - ublocks += bsize - matching_numblocks = ublocks == 2001 and vblocks == 601 and dblocks == 1 - matching_fields = fieldset.U.grid.chunk_info == fieldset.V.grid.chunk_info - matching_uniformblocks = len(fieldset.U.grid._load_chunk) == ( - 1 - * int(math.ceil(1.0 / 60.0)) - * int(math.ceil(601.0 / 50.0)) - * int(math.ceil(2001.0 / 100.0)) - ) - assert matching_uniformblocks or (matching_fields and matching_numblocks) - assert abs(pset[0].lon - 173) < 1 - assert abs(pset[0].lat - 11) < 1 - - -@pytest.mark.parametrize("mode", ["jit"]) -@pytest.mark.parametrize( - "chunk_mode", - [ - False, - pytest.param( - "auto", - marks=pytest.mark.xfail( - reason="Dask v2024.11.0 caused auto chunking to fail. See #1762" - ), - ), - "specific_same", - "specific_different", - ], -) -@pytest.mark.parametrize("using_add_field", [False, True]) -def test_mitgcm(mode, chunk_mode, using_add_field): - if chunk_mode in [ - "auto", - ]: - dask.config.set({"array.chunk-size": "512KiB"}) - else: - dask.config.set({"array.chunk-size": "128MiB"}) - data_folder = parcels.download_example_dataset("MITgcm_example_data") - filenames = { - "U": f"{data_folder}/mitgcm_UV_surface_zonally_reentrant.nc", - "V": f"{data_folder}/mitgcm_UV_surface_zonally_reentrant.nc", - } - variables = {"U": "UVEL", "V": "VVEL"} - dimensions = { - "U": {"lon": "XG", "lat": "YG", "time": "time"}, - "V": {"lon": "XG", "lat": "YG", "time": "time"}, - } - - chs = False - if chunk_mode == "auto": - chs = "auto" - elif chunk_mode == "specific_same": - chs = { - "U": {"lat": ("YC", 50), "lon": ("XG", 100)}, - "V": {"lat": ("YG", 50), "lon": ("XC", 100)}, - } - elif chunk_mode == "specific_different": - chs = { - "U": {"lat": ("YC", 50), "lon": ("XG", 100)}, - "V": {"lat": ("YG", 40), "lon": ("XC", 100)}, - } - if using_add_field: - if chs in [False, "auto"]: - chs = {"U": chs, "V": chs} - fieldset = parcels.FieldSet.from_mitgcm( - filenames["U"], - {"U": variables["U"]}, - dimensions["U"], - mesh="flat", - chunksize=chs["U"], - ) - fieldset2 = parcels.FieldSet.from_mitgcm( - filenames["V"], - {"V": variables["V"]}, - dimensions["V"], - mesh="flat", - chunksize=chs["V"], - ) - fieldset.add_field(fieldset2.V) - else: - fieldset = parcels.FieldSet.from_mitgcm( - filenames, variables, dimensions, mesh="flat", chunksize=chs - ) - - pset = parcels.ParticleSet.from_list( - fieldset=fieldset, pclass=ptype[mode], lon=5e5, lat=5e5 - ) - pset.execute( - parcels.AdvectionRK4, runtime=timedelta(days=1), dt=timedelta(minutes=5) - ) - # MITgcm sample file dimensions: time=10, XG=400, YG=200 - if chunk_mode != "specific_different": - assert len(fieldset.U.grid._load_chunk) == len(fieldset.V.grid._load_chunk) - if chunk_mode in [ - False, - ]: - assert len(fieldset.U.grid._load_chunk) == 1 - elif chunk_mode in [ - "auto", - ]: - assert len(fieldset.U.grid._load_chunk) != 1 - elif "specific" in chunk_mode: - assert len(fieldset.U.grid._load_chunk) == ( - 1 * int(math.ceil(400.0 / 50.0)) * int(math.ceil(200.0 / 100.0)) - ) - if chunk_mode == "specific_same": - assert fieldset.gridset.size == 1 - elif chunk_mode == "specific_different": - assert fieldset.gridset.size == 2 - assert np.allclose(pset[0].lon, 5.27e5, atol=1e3) - - -@pytest.mark.parametrize("mode", ["jit"]) -def test_diff_entry_dimensions_chunks(mode): - data_folder = parcels.download_example_dataset("NemoNorthSeaORCA025-N006_data") - ufiles = sorted(glob(f"{data_folder}/ORCA*U.nc")) - vfiles = sorted(glob(f"{data_folder}/ORCA*V.nc")) - mesh_mask = f"{data_folder}/coordinates.nc" - - filenames = { - "U": {"lon": mesh_mask, "lat": mesh_mask, "data": ufiles}, - "V": {"lon": mesh_mask, "lat": mesh_mask, "data": vfiles}, - } - variables = {"U": "uo", "V": "vo"} - dimensions = { - "U": {"lon": "glamf", "lat": "gphif", "time": "time_counter"}, - "V": {"lon": "glamf", "lat": "gphif", "time": "time_counter"}, - } - chs = { - "U": {"depth": ("depthu", 75), "lat": ("y", 16), "lon": ("x", 16)}, - "V": {"depth": ("depthv", 75), "lat": ("y", 16), "lon": ("x", 16)}, - } - fieldset = parcels.FieldSet.from_nemo( - filenames, variables, dimensions, chunksize=chs - ) - compute_nemo_particle_advection(fieldset, mode) - # Nemo sample file dimensions: depthu=75, y=201, x=151 - assert len(fieldset.U.grid._load_chunk) == len(fieldset.V.grid._load_chunk) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_3d_2dfield_sampling(mode): - data_folder = parcels.download_example_dataset("NemoNorthSeaORCA025-N006_data") - ufiles = sorted(glob(f"{data_folder}/ORCA*U.nc")) - vfiles = sorted(glob(f"{data_folder}/ORCA*V.nc")) - mesh_mask = f"{data_folder}/coordinates.nc" - - filenames = { - "U": {"lon": mesh_mask, "lat": mesh_mask, "data": ufiles}, - "V": {"lon": mesh_mask, "lat": mesh_mask, "data": vfiles}, - "nav_lon": { - "lon": mesh_mask, - "lat": mesh_mask, - "data": [ - ufiles[0], - ], - }, - } - variables = {"U": "uo", "V": "vo", "nav_lon": "nav_lon"} - dimensions = { - "U": {"lon": "glamf", "lat": "gphif", "time": "time_counter"}, - "V": {"lon": "glamf", "lat": "gphif", "time": "time_counter"}, - "nav_lon": {"lon": "glamf", "lat": "gphif"}, - } - fieldset = parcels.FieldSet.from_nemo( - filenames, variables, dimensions, chunksize=False - ) - fieldset.nav_lon.data = np.ones(fieldset.nav_lon.data.shape, dtype=np.float32) - fieldset.add_field( - parcels.Field( - "rectilinear_2D", - np.ones((2, 2)), - lon=np.array([-10, 20]), - lat=np.array([40, 80]), - chunksize=False, - ) - ) - - class MyParticle(ptype[mode]): - sample_var_curvilinear = parcels.Variable("sample_var_curvilinear") - sample_var_rectilinear = parcels.Variable("sample_var_rectilinear") - - pset = parcels.ParticleSet(fieldset, pclass=MyParticle, lon=2.5, lat=52) - - def Sample2D(particle, fieldset, time): # pragma: no cover - particle.sample_var_curvilinear += fieldset.nav_lon[ - time, particle.depth, particle.lat, particle.lon - ] - particle.sample_var_rectilinear += fieldset.rectilinear_2D[ - time, particle.depth, particle.lat, particle.lon - ] - - runtime, dt = 86400 * 4, 6 * 3600 - pset.execute(pset.Kernel(parcels.AdvectionRK4) + Sample2D, runtime=runtime, dt=dt) - - assert pset.sample_var_rectilinear == runtime / dt - assert pset.sample_var_curvilinear == runtime / dt - - -@pytest.mark.parametrize("mode", ["jit"]) -def test_diff_entry_chunksize_error_nemo_complex_conform_depth(mode): - # ==== this test is expected to fall-back to a pre-defined minimal chunk as ==== # - # ==== the requested chunks don't match, or throw a value error. ==== # - data_folder = parcels.download_example_dataset("NemoNorthSeaORCA025-N006_data") - ufiles = sorted(glob(f"{data_folder}/ORCA*U.nc")) - vfiles = sorted(glob(f"{data_folder}/ORCA*V.nc")) - wfiles = sorted(glob(f"{data_folder}/ORCA*W.nc")) - mesh_mask = f"{data_folder}/coordinates.nc" - - filenames = { - "U": {"lon": mesh_mask, "lat": mesh_mask, "depth": wfiles[0], "data": ufiles}, - "V": {"lon": mesh_mask, "lat": mesh_mask, "depth": wfiles[0], "data": vfiles}, - "W": {"lon": mesh_mask, "lat": mesh_mask, "depth": wfiles[0], "data": wfiles}, - } - variables = {"U": "uo", "V": "vo", "W": "wo"} - dimensions = { - "U": { - "lon": "glamf", - "lat": "gphif", - "depth": "depthw", - "time": "time_counter", - }, - "V": { - "lon": "glamf", - "lat": "gphif", - "depth": "depthw", - "time": "time_counter", - }, - "W": { - "lon": "glamf", - "lat": "gphif", - "depth": "depthw", - "time": "time_counter", - }, - } - chs = { - "U": {"depth": ("depthu", 75), "lat": ("y", 16), "lon": ("x", 16)}, - "V": {"depth": ("depthv", 75), "lat": ("y", 4), "lon": ("x", 16)}, - "W": {"depth": ("depthw", 75), "lat": ("y", 16), "lon": ("x", 4)}, - } - fieldset = parcels.FieldSet.from_nemo( - filenames, variables, dimensions, chunksize=chs - ) - compute_nemo_particle_advection(fieldset, mode) - # Nemo sample file dimensions: depthu=75, y=201, x=151 - npart_U = 1 - npart_U = [npart_U * k for k in fieldset.U.nchunks[1:]] - npart_V = 1 - npart_V = [npart_V * k for k in fieldset.V.nchunks[1:]] - npart_W = 1 - npart_W = [npart_W * k for k in fieldset.V.nchunks[1:]] - chn = { - "U": { - "lat": int(math.ceil(201.0 / chs["U"]["lat"][1])), - "lon": int(math.ceil(151.0 / chs["U"]["lon"][1])), - "depth": int(math.ceil(75.0 / chs["U"]["depth"][1])), - }, - "V": { - "lat": int(math.ceil(201.0 / chs["V"]["lat"][1])), - "lon": int(math.ceil(151.0 / chs["V"]["lon"][1])), - "depth": int(math.ceil(75.0 / chs["V"]["depth"][1])), - }, - "W": { - "lat": int(math.ceil(201.0 / chs["W"]["lat"][1])), - "lon": int(math.ceil(151.0 / chs["W"]["lon"][1])), - "depth": int(math.ceil(75.0 / chs["W"]["depth"][1])), - }, - } - npart_U_request = 1 - npart_U_request = [npart_U_request * chn["U"][k] for k in chn["U"]] - npart_V_request = 1 - npart_V_request = [npart_V_request * chn["V"][k] for k in chn["V"]] - npart_W_request = 1 - npart_W_request = [npart_W_request * chn["W"][k] for k in chn["W"]] - assert npart_U != npart_U_request - assert npart_V != npart_V_request - assert npart_W != npart_W_request - - -@pytest.mark.parametrize("mode", ["jit"]) -def test_diff_entry_chunksize_correction_globcurrent(mode): - data_folder = parcels.download_example_dataset("GlobCurrent_example_data") - filenames = str( - data_folder / "200201*-GLOBCURRENT-L4-CUReul_hs-ALT_SUM-v02.0-fv01.0.nc" - ) - variables = { - "U": "eastward_eulerian_current_velocity", - "V": "northward_eulerian_current_velocity", - } - dimensions = {"lat": "lat", "lon": "lon", "time": "time"} - chs = { - "U": {"lat": ("lat", 16), "lon": ("lon", 16)}, - "V": {"lat": ("lat", 16), "lon": ("lon", 4)}, - } - fieldset = parcels.FieldSet.from_netcdf( - filenames, variables, dimensions, chunksize=chs - ) - pset = parcels.ParticleSet(fieldset, pclass=ptype[mode], lon=25, lat=-35) - pset.execute( - parcels.AdvectionRK4, runtime=timedelta(days=1), dt=timedelta(minutes=5) - ) - # GlobCurrent sample file dimensions: time=UNLIMITED, lat=41, lon=81 - npart_U = 1 - npart_U = [npart_U * k for k in fieldset.U.nchunks[1:]] - npart_V = 1 - npart_V = [npart_V * k for k in fieldset.V.nchunks[1:]] - npart_V_request = 1 - chn = { - "U": { - "lat": int(math.ceil(41.0 / chs["U"]["lat"][1])), - "lon": int(math.ceil(81.0 / chs["U"]["lon"][1])), - }, - "V": { - "lat": int(math.ceil(41.0 / chs["V"]["lat"][1])), - "lon": int(math.ceil(81.0 / chs["V"]["lon"][1])), - }, - } - npart_V_request = [npart_V_request * chn["V"][k] for k in chn["V"]] - assert npart_V_request != npart_U - assert npart_V_request == npart_V diff --git a/docs/examples/example_decaying_moving_eddy.py b/docs/examples/example_decaying_moving_eddy.py index 46bc10d5c..75de6ee78 100644 --- a/docs/examples/example_decaying_moving_eddy.py +++ b/docs/examples/example_decaying_moving_eddy.py @@ -1,12 +1,9 @@ from datetime import timedelta import numpy as np -import pytest import parcels -ptype = {"scipy": parcels.ScipyParticle, "jit": parcels.JITParticle} - # Define some constants. u_g = 0.04 # Geostrophic current u_0 = 0.3 # Initial speed in x dirrection. v_0 = 0 @@ -70,11 +67,9 @@ def true_values( return np.array([x, y]) -def decaying_moving_example( - fieldset, outfile, mode="scipy", method=parcels.AdvectionRK4 -): +def decaying_moving_example(fieldset, outfile, method=parcels.AdvectionRK4): pset = parcels.ParticleSet( - fieldset, pclass=ptype[mode], lon=start_lon, lat=start_lat + fieldset, pclass=parcels.Particle, lon=start_lon, lat=start_lat ) dt = timedelta(minutes=5) @@ -91,11 +86,10 @@ def decaying_moving_example( return pset -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_rotation_example(mode, tmpdir): +def test_rotation_example(tmpdir): outfile = tmpdir.join("DecayingMovingParticle.zarr") fieldset = decaying_moving_eddy_fieldset() - pset = decaying_moving_example(fieldset, outfile, mode=mode) + pset = decaying_moving_example(fieldset, outfile) vals = true_values( pset[0].time, start_lon, start_lat ) # Calculate values for the particle. @@ -105,10 +99,8 @@ def test_rotation_example(mode, tmpdir): def main(): - fset_filename = "decaying_moving_eddy" outfile = "DecayingMovingParticle.zarr" fieldset = decaying_moving_eddy_fieldset() - fieldset.write(fset_filename) decaying_moving_example(fieldset, outfile) diff --git a/docs/examples/example_globcurrent.py b/docs/examples/example_globcurrent.py index 292ed1bf7..543973568 100755 --- a/docs/examples/example_globcurrent.py +++ b/docs/examples/example_globcurrent.py @@ -7,16 +7,9 @@ import parcels -ptype = {"scipy": parcels.ScipyParticle, "jit": parcels.JITParticle} - def set_globcurrent_fieldset( filename=None, - indices=None, - deferred_load=True, - use_xarray=False, - time_periodic=False, - timestamps=None, ): if filename is None: data_folder = parcels.download_example_dataset("GlobCurrent_example_data") @@ -27,64 +20,38 @@ def set_globcurrent_fieldset( "U": "eastward_eulerian_current_velocity", "V": "northward_eulerian_current_velocity", } - if timestamps is None: - dimensions = {"lat": "lat", "lon": "lon", "time": "time"} - else: - dimensions = {"lat": "lat", "lon": "lon"} - if use_xarray: - ds = xr.open_mfdataset(filename, combine="by_coords") - return parcels.FieldSet.from_xarray_dataset( - ds, variables, dimensions, time_periodic=time_periodic - ) - else: - return parcels.FieldSet.from_netcdf( - filename, - variables, - dimensions, - indices, - deferred_load=deferred_load, - time_periodic=time_periodic, - timestamps=timestamps, - ) - + dimensions = {"lat": "lat", "lon": "lon", "time": "time"} + ds = xr.open_mfdataset(filename, combine="by_coords") -@pytest.mark.parametrize("use_xarray", [True, False]) -def test_globcurrent_fieldset(use_xarray): - fieldset = set_globcurrent_fieldset(use_xarray=use_xarray) - assert fieldset.U.lon.size == 81 - assert fieldset.U.lat.size == 41 - assert fieldset.V.lon.size == 81 - assert fieldset.V.lat.size == 41 - - if not use_xarray: - indices = {"lon": [5], "lat": range(20, 30)} - fieldsetsub = set_globcurrent_fieldset(indices=indices, use_xarray=use_xarray) - assert np.allclose(fieldsetsub.U.lon, fieldset.U.lon[indices["lon"]]) - assert np.allclose(fieldsetsub.U.lat, fieldset.U.lat[indices["lat"]]) - assert np.allclose(fieldsetsub.V.lon, fieldset.V.lon[indices["lon"]]) - assert np.allclose(fieldsetsub.V.lat, fieldset.V.lat[indices["lat"]]) + return parcels.FieldSet.from_xarray_dataset( + ds, + variables, + dimensions, + ) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize( "dt, lonstart, latstart", [(3600.0, 25, -35), (-3600.0, 20, -39)] ) -@pytest.mark.parametrize("use_xarray", [True, False]) -def test_globcurrent_fieldset_advancetime(mode, dt, lonstart, latstart, use_xarray): +def test_globcurrent_fieldset_advancetime(dt, lonstart, latstart): data_folder = parcels.download_example_dataset("GlobCurrent_example_data") basepath = str(data_folder / "20*-GLOBCURRENT-L4-CUReul_hs-ALT_SUM-v02.0-fv01.0.nc") files = sorted(glob(str(basepath))) - fieldsetsub = set_globcurrent_fieldset(files[0:10], use_xarray=use_xarray) + fieldsetsub = set_globcurrent_fieldset(files[0:10]) psetsub = parcels.ParticleSet.from_list( - fieldset=fieldsetsub, pclass=ptype[mode], lon=[lonstart], lat=[latstart] + fieldset=fieldsetsub, + pclass=parcels.Particle, + lon=[lonstart], + lat=[latstart], ) - fieldsetall = set_globcurrent_fieldset( - files[0:10], deferred_load=False, use_xarray=use_xarray - ) + fieldsetall = set_globcurrent_fieldset(files[0:10]) psetall = parcels.ParticleSet.from_list( - fieldset=fieldsetall, pclass=ptype[mode], lon=[lonstart], lat=[latstart] + fieldset=fieldsetall, + pclass=parcels.Particle, + lon=[lonstart], + lat=[latstart], ) if dt < 0: psetsub[0].time_nextloop = fieldsetsub.U.grid.time[-1] @@ -96,15 +63,15 @@ def test_globcurrent_fieldset_advancetime(mode, dt, lonstart, latstart, use_xarr assert abs(psetsub[0].lon - psetall[0].lon) < 1e-4 -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("use_xarray", [True, False]) -def test_globcurrent_particles(mode, use_xarray): - fieldset = set_globcurrent_fieldset(use_xarray=use_xarray) +def test_globcurrent_particles(): + fieldset = set_globcurrent_fieldset() lonstart = [25] latstart = [-35] - pset = parcels.ParticleSet(fieldset, pclass=ptype[mode], lon=lonstart, lat=latstart) + pset = parcels.ParticleSet( + fieldset, pclass=parcels.Particle, lon=lonstart, lat=latstart + ) pset.execute( parcels.AdvectionRK4, runtime=timedelta(days=1), dt=timedelta(minutes=5) @@ -114,72 +81,6 @@ def test_globcurrent_particles(mode, use_xarray): assert abs(pset[0].lat - -35.3) < 1 -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("rundays", [300, 900]) -def test_globcurrent_time_periodic(mode, rundays): - sample_var = [] - for deferred_load in [True, False]: - fieldset = set_globcurrent_fieldset( - time_periodic=timedelta(days=365), deferred_load=deferred_load - ) - - MyParticle = ptype[mode].add_variable("sample_var", initial=0.0) - - pset = parcels.ParticleSet( - fieldset, pclass=MyParticle, lon=25, lat=-35, time=fieldset.U.grid.time[0] - ) - - def SampleU(particle, fieldset, time): # pragma: no cover - u, v = fieldset.UV[time, particle.depth, particle.lat, particle.lon] - particle.sample_var += u - - pset.execute(SampleU, runtime=timedelta(days=rundays), dt=timedelta(days=1)) - sample_var.append(pset[0].sample_var) - - assert np.allclose(sample_var[0], sample_var[1]) - - -@pytest.mark.parametrize("dt", [-300, 300]) -def test_globcurrent_xarray_vs_netcdf(dt): - fieldsetNetcdf = set_globcurrent_fieldset(use_xarray=False) - fieldsetxarray = set_globcurrent_fieldset(use_xarray=True) - lonstart, latstart, runtime = (25, -35, timedelta(days=7)) - - psetN = parcels.ParticleSet( - fieldsetNetcdf, pclass=parcels.JITParticle, lon=lonstart, lat=latstart - ) - psetN.execute(parcels.AdvectionRK4, runtime=runtime, dt=dt) - - psetX = parcels.ParticleSet( - fieldsetxarray, pclass=parcels.JITParticle, lon=lonstart, lat=latstart - ) - psetX.execute(parcels.AdvectionRK4, runtime=runtime, dt=dt) - - assert np.allclose(psetN[0].lon, psetX[0].lon) - assert np.allclose(psetN[0].lat, psetX[0].lat) - - -@pytest.mark.parametrize("dt", [-300, 300]) -def test_globcurrent_netcdf_timestamps(dt): - fieldsetNetcdf = set_globcurrent_fieldset() - timestamps = fieldsetNetcdf.U.grid.timeslices - fieldsetTimestamps = set_globcurrent_fieldset(timestamps=timestamps) - lonstart, latstart, runtime = (25, -35, timedelta(days=7)) - - psetN = parcels.ParticleSet( - fieldsetNetcdf, pclass=parcels.JITParticle, lon=lonstart, lat=latstart - ) - psetN.execute(parcels.AdvectionRK4, runtime=runtime, dt=dt) - - psetT = parcels.ParticleSet( - fieldsetTimestamps, pclass=parcels.JITParticle, lon=lonstart, lat=latstart - ) - psetT.execute(parcels.AdvectionRK4, runtime=runtime, dt=dt) - - assert np.allclose(psetN.lon[0], psetT.lon[0]) - assert np.allclose(psetN.lat[0], psetT.lat[0]) - - def test__particles_init_time(): fieldset = set_globcurrent_fieldset() @@ -189,28 +90,28 @@ def test__particles_init_time(): # tests the different ways of initialising the time of a particle pset = parcels.ParticleSet( fieldset, - pclass=parcels.JITParticle, + pclass=parcels.Particle, lon=lonstart, lat=latstart, time=np.datetime64("2002-01-15"), ) pset2 = parcels.ParticleSet( fieldset, - pclass=parcels.JITParticle, + pclass=parcels.Particle, lon=lonstart, lat=latstart, time=14 * 86400, ) pset3 = parcels.ParticleSet( fieldset, - pclass=parcels.JITParticle, + pclass=parcels.Particle, lon=lonstart, lat=latstart, time=np.array([np.datetime64("2002-01-15")]), ) pset4 = parcels.ParticleSet( fieldset, - pclass=parcels.JITParticle, + pclass=parcels.Particle, lon=lonstart, lat=latstart, time=[np.datetime64("2002-01-15")], @@ -220,13 +121,11 @@ def test__particles_init_time(): assert pset[0].time - pset4[0].time == 0 -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("use_xarray", [True, False]) -def test_globcurrent_time_extrapolation_error(mode, use_xarray): - fieldset = set_globcurrent_fieldset(use_xarray=use_xarray) +def test_globcurrent_time_extrapolation_error(): + fieldset = set_globcurrent_fieldset() pset = parcels.ParticleSet( fieldset, - pclass=ptype[mode], + pclass=parcels.Particle, lon=[25], lat=[-35], time=fieldset.U.grid.time[0] - timedelta(days=1).total_seconds(), @@ -237,10 +136,19 @@ def test_globcurrent_time_extrapolation_error(mode, use_xarray): ) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) +@pytest.mark.v4alpha +@pytest.mark.skip( + reason="This was always broken when using eager loading `deferred_load=False` for the P field. Needs to be fixed." +) @pytest.mark.parametrize("dt", [-300, 300]) @pytest.mark.parametrize("with_starttime", [True, False]) -def test_globcurrent_startparticles_between_time_arrays(mode, dt, with_starttime): +def test_globcurrent_startparticles_between_time_arrays(dt, with_starttime): + """Test for correctly initialising particle start times. + + When using Fields with different temporal domains, its important to intialise particles + at the beginning of the time period where all Fields have available data (i.e., the + intersection of the temporal domains) + """ fieldset = set_globcurrent_fieldset() data_folder = parcels.download_example_dataset("GlobCurrent_example_data") @@ -253,7 +161,7 @@ def test_globcurrent_startparticles_between_time_arrays(mode, dt, with_starttime ) ) - MyParticle = ptype[mode].add_variable("sample_var", initial=0.0) + MyParticle = parcels.Particle.add_variable("sample_var", initial=0.0) def SampleP(particle, fieldset, time): # pragma: no cover particle.sample_var += fieldset.P[ @@ -283,17 +191,16 @@ def SampleP(particle, fieldset, time): # pragma: no cover ) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_globcurrent_particle_independence(mode, rundays=5): +def test_globcurrent_particle_independence(rundays=5): fieldset = set_globcurrent_fieldset() time0 = fieldset.U.grid.time[0] def DeleteP0(particle, fieldset, time): # pragma: no cover - if particle.id == 0: + if particle.trajectory == 0: particle.delete() pset0 = parcels.ParticleSet( - fieldset, pclass=ptype[mode], lon=[25, 25], lat=[-35, -35], time=time0 + fieldset, pclass=parcels.Particle, lon=[25, 25], lat=[-35, -35], time=time0 ) pset0.execute( @@ -303,7 +210,7 @@ def DeleteP0(particle, fieldset, time): # pragma: no cover ) pset1 = parcels.ParticleSet( - fieldset, pclass=ptype[mode], lon=[25, 25], lat=[-35, -35], time=time0 + fieldset, pclass=parcels.Particle, lon=[25, 25], lat=[-35, -35], time=time0 ) pset1.execute( @@ -313,15 +220,14 @@ def DeleteP0(particle, fieldset, time): # pragma: no cover assert np.allclose([pset0[-1].lon, pset0[-1].lat], [pset1[-1].lon, pset1[-1].lat]) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize("dt", [-300, 300]) @pytest.mark.parametrize("pid_offset", [0, 20]) -def test_globcurrent_pset_fromfile(mode, dt, pid_offset, tmpdir): +def test_globcurrent_pset_fromfile(dt, pid_offset, tmpdir): filename = tmpdir.join("pset_fromparticlefile.zarr") fieldset = set_globcurrent_fieldset() - ptype[mode].setLastID(pid_offset) - pset = parcels.ParticleSet(fieldset, pclass=ptype[mode], lon=25, lat=-35) + parcels.Particle.setLastID(pid_offset) + pset = parcels.ParticleSet(fieldset, pclass=parcels.Particle, lon=25, lat=-35) pfile = pset.ParticleFile(filename, outputdt=timedelta(hours=6)) pset.execute( parcels.AdvectionRK4, runtime=timedelta(days=1), dt=dt, output_file=pfile @@ -330,19 +236,21 @@ def test_globcurrent_pset_fromfile(mode, dt, pid_offset, tmpdir): restarttime = np.nanmax if dt > 0 else np.nanmin pset_new = parcels.ParticleSet.from_particlefile( - fieldset, pclass=ptype[mode], filename=filename, restarttime=restarttime + fieldset, + pclass=parcels.Particle, + filename=filename, + restarttime=restarttime, ) pset.execute(parcels.AdvectionRK4, runtime=timedelta(days=1), dt=dt) pset_new.execute(parcels.AdvectionRK4, runtime=timedelta(days=1), dt=dt) - for var in ["lon", "lat", "depth", "time", "id"]: + for var in ["lon", "lat", "depth", "time", "trajectory"]: assert np.allclose( [getattr(p, var) for p in pset], [getattr(p, var) for p in pset_new] ) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_error_outputdt_not_multiple_dt(mode, tmpdir): +def test_error_outputdt_not_multiple_dt(tmpdir): # Test that outputdt is a multiple of dt fieldset = set_globcurrent_fieldset() @@ -350,7 +258,7 @@ def test_error_outputdt_not_multiple_dt(mode, tmpdir): dt = 81.2584344538292 # number for which output writing fails - pset = parcels.ParticleSet(fieldset, pclass=ptype[mode], lon=[0], lat=[0]) + pset = parcels.ParticleSet(fieldset, pclass=parcels.Particle, lon=[0], lat=[0]) ofile = pset.ParticleFile(name=filepath, outputdt=timedelta(days=1)) def DoNothing(particle, fieldset, time): # pragma: no cover diff --git a/docs/examples/example_mitgcm.py b/docs/examples/example_mitgcm.py index 22e66faf5..c4a361545 100644 --- a/docs/examples/example_mitgcm.py +++ b/docs/examples/example_mitgcm.py @@ -1,16 +1,12 @@ from datetime import timedelta from pathlib import Path -from typing import Literal -import numpy as np -import xarray as xr +import pytest import parcels -ptype = {"scipy": parcels.ScipyParticle, "jit": parcels.JITParticle} - -def run_mitgcm_zonally_reentrant(mode: Literal["scipy", "jit"], path: Path): +def run_mitgcm_zonally_reentrant(path: Path): """Function that shows how to load MITgcm data in a zonally periodic domain.""" data_folder = parcels.download_example_dataset("MITgcm_example_data") filenames = { @@ -31,14 +27,14 @@ def run_mitgcm_zonally_reentrant(mode: Literal["scipy", "jit"], path: Path): def periodicBC(particle, fieldset, time): # pragma: no cover if particle.lon < 0: - particle_dlon += fieldset.domain_width # noqa + particle.dlon += fieldset.domain_width elif particle.lon > fieldset.domain_width: - particle_dlon -= fieldset.domain_width + particle.dlon -= fieldset.domain_width # Release particles 5 cells away from the Eastern boundary pset = parcels.ParticleSet.from_line( fieldset, - pclass=ptype[mode], + pclass=parcels.Particle, start=(fieldset.U.grid.lon[-5], fieldset.U.grid.lat[5]), finish=(fieldset.U.grid.lon[-5], fieldset.U.grid.lat[-5]), size=10, @@ -55,15 +51,10 @@ def periodicBC(particle, fieldset, time): # pragma: no cover ) -def test_mitgcm_output_compare(tmpdir): - def get_path(mode: Literal["scipy", "jit"]) -> Path: - return tmpdir / f"MIT_particles_{mode}.zarr" - - for mode in ["scipy", "jit"]: - run_mitgcm_zonally_reentrant(mode, get_path(mode)) - - ds_jit = xr.open_zarr(get_path("jit")) - ds_scipy = xr.open_zarr(get_path("scipy")) +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="Test uses add_periodic_halo(). Update to not use it.") +def test_mitgcm_output(tmpdir): + def get_path() -> Path: + return tmpdir / "MIT_particles.zarr" - np.testing.assert_allclose(ds_jit.lat.data, ds_scipy.lat.data) - np.testing.assert_allclose(ds_jit.lon.data, ds_scipy.lon.data) + run_mitgcm_zonally_reentrant(get_path()) diff --git a/docs/examples/example_moving_eddies.py b/docs/examples/example_moving_eddies.py index cff035ec5..5afa63631 100644 --- a/docs/examples/example_moving_eddies.py +++ b/docs/examples/example_moving_eddies.py @@ -1,4 +1,3 @@ -import gc import math from argparse import ArgumentParser from datetime import timedelta @@ -8,7 +7,6 @@ import parcels -ptype = {"scipy": parcels.ScipyParticle, "jit": parcels.JITParticle} method = { "RK4": parcels.AdvectionRK4, "EE": parcels.AdvectionEE, @@ -66,9 +64,9 @@ def cosd(x): dy = (lat[1] - lat[0]) * 1852 * 60 if mesh == "spherical" else lat[1] - lat[0] # Define arrays U (zonal), V (meridional), and P (sea surface height) on A-grid - U = np.zeros((lon.size, lat.size, time.size), dtype=np.float32) - V = np.zeros((lon.size, lat.size, time.size), dtype=np.float32) - P = np.zeros((lon.size, lat.size, time.size), dtype=np.float32) + U = np.zeros((time.size, lat.size, lon.size), dtype=np.float32) + V = np.zeros((time.size, lat.size, lon.size), dtype=np.float32) + P = np.zeros((time.size, lat.size, lon.size), dtype=np.float32) # Some constants corio_0 = 1.0e-4 # Coriolis parameter @@ -79,32 +77,32 @@ def cosd(x): dX = eddyspeed * 86400 / dx # Grid cell movement of eddy max each day dY = eddyspeed * 86400 / dy # Grid cell movement of eddy max each day - [x, y] = np.mgrid[: lon.size, : lat.size] + [y, x] = np.mgrid[: lat.size, : lon.size] for t in range(time.size): hymax_1 = lat.size / 7.0 hxmax_1 = 0.75 * lon.size - dX * t hymax_2 = 3.0 * lat.size / 7.0 + dY * t hxmax_2 = 0.75 * lon.size - dX * t - P[:, :, t] = h0 * np.exp( + P[t, :, :] = h0 * np.exp( -((x - hxmax_1) ** 2) / (sig * lon.size / 4.0) ** 2 - (y - hymax_1) ** 2 / (sig * lat.size / 7.0) ** 2 ) - P[:, :, t] += h0 * np.exp( + P[t, :, :] += h0 * np.exp( -((x - hxmax_2) ** 2) / (sig * lon.size / 4.0) ** 2 - (y - hymax_2) ** 2 / (sig * lat.size / 7.0) ** 2 ) - V[:-1, :, t] = -np.diff(P[:, :, t], axis=0) / dx / corio_0 * g - V[-1, :, t] = V[-2, :, t] # Fill in the last column + V[t, :, :-1] = -np.diff(P[t, :, :], axis=1) / dx / corio_0 * g + V[t, :, -1] = V[t, :, -2] # Fill in the last column - U[:, :-1, t] = np.diff(P[:, :, t], axis=1) / dy / corio_0 * g - U[:, -1, t] = U[:, -2, t] # Fill in the last row + U[t, :-1, :] = np.diff(P[t, :, :], axis=0) / dy / corio_0 * g + U[t, -1, :] = U[t, -2, :] # Fill in the last row data = {"U": U, "V": V, "P": P} dimensions = {"lon": lon, "lat": lat, "time": time} - fieldset = parcels.FieldSet.from_data(data, dimensions, transpose=True, mesh=mesh) + fieldset = parcels.FieldSet.from_data(data, dimensions, mesh=mesh) # setting some constants for AdvectionRK45 kernel fieldset.RK45_min_dt = 1e-3 @@ -114,7 +112,7 @@ def cosd(x): def moving_eddies_example( - fieldset, outfile, npart=2, mode="jit", verbose=False, method=parcels.AdvectionRK4 + fieldset, outfile, npart=2, verbose=False, method=parcels.AdvectionRK4 ): """Configuration of a particle set that follows two moving eddies. @@ -127,18 +125,19 @@ def moving_eddies_example( npart : Number of particles to initialise. (Default value = 2) - mode : - (Default value = 'jit') verbose : (Default value = False) method : (Default value = AdvectionRK4) """ - # Determine particle class according to mode start = (3.3, 46.0) if fieldset.U.grid.mesh == "spherical" else (3.3e5, 1e5) finish = (3.3, 47.8) if fieldset.U.grid.mesh == "spherical" else (3.3e5, 2.8e5) pset = parcels.ParticleSet.from_line( - fieldset=fieldset, size=npart, pclass=ptype[mode], start=start, finish=finish + fieldset=fieldset, + size=npart, + pclass=parcels.Particle, + start=start, + finish=finish, ) if verbose: @@ -160,17 +159,15 @@ def moving_eddies_example( return pset -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize("mesh", ["flat", "spherical"]) -def test_moving_eddies_fwdbwd(mode, mesh, tmpdir, npart=2): +def test_moving_eddies_fwdbwd(mesh, tmpdir, npart=2): method = parcels.AdvectionRK4 fieldset = moving_eddies_fieldset(mesh=mesh) - # Determine particle class according to mode lons = [3.3, 3.3] if fieldset.U.grid.mesh == "spherical" else [3.3e5, 3.3e5] lats = [46.0, 47.8] if fieldset.U.grid.mesh == "spherical" else [1e5, 2.8e5] pset = parcels.ParticleSet( - fieldset=fieldset, pclass=ptype[mode], lon=lons, lat=lats + fieldset=fieldset, pclass=parcels.Particle, lon=lons, lat=lats ) # Execte for 14 days, with 30sec timesteps and hourly output @@ -205,12 +202,11 @@ def test_moving_eddies_fwdbwd(mode, mesh, tmpdir, npart=2): assert np.allclose(pset.lat, lats) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize("mesh", ["flat", "spherical"]) -def test_moving_eddies_fieldset(mode, mesh, tmpdir): +def test_moving_eddies_fieldset(mesh, tmpdir): fieldset = moving_eddies_fieldset(mesh=mesh) outfile = tmpdir.join("EddyParticle") - pset = moving_eddies_example(fieldset, outfile, 2, mode=mode) + pset = moving_eddies_example(fieldset, outfile, 2) # Also include last timestep for var in ["lon", "lat", "depth", "time"]: pset.particledata.setallvardata( @@ -232,30 +228,32 @@ def fieldsetfile(mesh, tmpdir): return filename -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("mesh", ["flat", "spherical"]) -def test_moving_eddies_file(mode, mesh, tmpdir): - gc.collect() - fieldset = parcels.FieldSet.from_parcels( - fieldsetfile(mesh, tmpdir), extra_fields={"P": "P"} - ) +def test_moving_eddies_file(tmpdir): + data_folder = parcels.download_example_dataset("MovingEddies_data") + filenames = { + "U": str(data_folder / "moving_eddiesU.nc"), + "V": str(data_folder / "moving_eddiesV.nc"), + "P": str(data_folder / "moving_eddiesP.nc"), + } + variables = {"U": "vozocrtx", "V": "vomecrty", "P": "P"} + dimensions = {"lon": "nav_lon", "lat": "nav_lat", "time": "time_counter"} + fieldset = parcels.FieldSet.from_netcdf(filenames, variables, dimensions) outfile = tmpdir.join("EddyParticle") - pset = moving_eddies_example(fieldset, outfile, 2, mode=mode) + pset = moving_eddies_example(fieldset, outfile, 2) # Also include last timestep for var in ["lon", "lat", "depth", "time"]: pset.particledata.setallvardata( f"{var}", pset.particledata.getvardata(f"{var}_nextloop") ) - if mesh == "flat": - assert pset[0].lon < 2.2e5 and 1.1e5 < pset[0].lat < 1.2e5 - assert pset[1].lon < 2.2e5 and 3.7e5 < pset[1].lat < 3.8e5 - else: - assert pset[0].lon < 2.0 and 46.2 < pset[0].lat < 46.25 - assert pset[1].lon < 2.0 and 48.8 < pset[1].lat < 48.85 + assert pset[0].lon < 2.2e5 and 1.1e5 < pset[0].lat < 1.2e5 + assert pset[1].lon < 2.2e5 and 3.7e5 < pset[1].lat < 3.8e5 -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_periodic_and_computeTimeChunk_eddies(mode): +@pytest.mark.v4alpha +@pytest.mark.xfail( + reason="Calls fieldset.add_periodic_halo(). In v4, interpolation should work without adding halo." +) +def test_periodic_and_computeTimeChunk_eddies(): data_folder = parcels.download_example_dataset("MovingEddies_data") filename = str(data_folder / "moving_eddies") @@ -266,22 +264,25 @@ def test_periodic_and_computeTimeChunk_eddies(mode): fieldset.add_constant("halo_north", fieldset.U.grid.lat[-1]) fieldset.add_periodic_halo(zonal=True, meridional=True) pset = parcels.ParticleSet.from_list( - fieldset=fieldset, pclass=ptype[mode], lon=[3.3, 3.3], lat=[46.0, 47.8] + fieldset=fieldset, + pclass=parcels.Particle, + lon=[3.3, 3.3], + lat=[46.0, 47.8], ) def periodicBC(particle, fieldset, time): # pragma: no cover if particle.lon < fieldset.halo_west: - particle_dlon += fieldset.halo_east - fieldset.halo_west # noqa + particle.dlon += fieldset.halo_east - fieldset.halo_west elif particle.lon > fieldset.halo_east: - particle_dlon -= fieldset.halo_east - fieldset.halo_west + particle.dlon -= fieldset.halo_east - fieldset.halo_west if particle.lat < fieldset.halo_south: - particle_dlat += fieldset.halo_north - fieldset.halo_south # noqa + particle.dlat += fieldset.halo_north - fieldset.halo_south elif particle.lat > fieldset.halo_north: - particle_dlat -= fieldset.halo_north - fieldset.halo_south + particle.dlat -= fieldset.halo_north - fieldset.halo_south def slowlySouthWestward(particle, fieldset, time): # pragma: no cover - particle_dlon -= 5 * particle.dt / 1e5 # noqa - particle_dlat -= 3 * particle.dt / 1e5 # noqa + particle.dlon -= 5 * particle.dt / 1e5 + particle.dlat -= 3 * particle.dt / 1e5 kernels = pset.Kernel(parcels.AdvectionRK4) + slowlySouthWestward + periodicBC pset.execute(kernels, runtime=timedelta(days=6), dt=timedelta(hours=1)) @@ -292,13 +293,6 @@ def main(args=None): description=""" Example of particle advection around an idealised peninsula""" ) - p.add_argument( - "mode", - choices=("scipy", "jit"), - nargs="?", - default="jit", - help="Execution mode for performing RK4 computation", - ) p.add_argument( "-p", "--particles", type=int, default=2, help="Number of particles to advect" ) @@ -348,7 +342,7 @@ def main(args=None): from pstats import Stats runctx( - "moving_eddies_example(fieldset, outfile, args.particles, mode=args.mode, \ + "moving_eddies_example(fieldset, outfile, args.particles, \ verbose=args.verbose, method=method[args.method])", globals(), locals(), @@ -360,7 +354,6 @@ def main(args=None): fieldset, outfile, args.particles, - mode=args.mode, verbose=args.verbose, method=method[args.method], ) diff --git a/docs/examples/example_nemo_curvilinear.py b/docs/examples/example_nemo_curvilinear.py index dd751b433..c93302e55 100644 --- a/docs/examples/example_nemo_curvilinear.py +++ b/docs/examples/example_nemo_curvilinear.py @@ -1,6 +1,5 @@ """Example script that runs a set of particles in a NEMO curvilinear grid.""" -from argparse import ArgumentParser from datetime import timedelta from glob import glob @@ -9,11 +8,10 @@ import parcels -ptype = {"scipy": parcels.ScipyParticle, "jit": parcels.JITParticle} advection = {"RK4": parcels.AdvectionRK4, "AA": parcels.AdvectionAnalytical} -def run_nemo_curvilinear(mode, outfile, advtype="RK4"): +def run_nemo_curvilinear(outfile, advtype="RK4"): """Run parcels on the NEMO curvilinear grid.""" data_folder = parcels.download_example_dataset("NemoCurvilinear_data") @@ -31,11 +29,7 @@ def run_nemo_curvilinear(mode, outfile, advtype="RK4"): } variables = {"U": "U", "V": "V"} dimensions = {"lon": "glamf", "lat": "gphif"} - chunksize = {"lat": ("y", 256), "lon": ("x", 512)} - fieldset = parcels.FieldSet.from_nemo( - filenames, variables, dimensions, chunksize=chunksize - ) - assert fieldset.U.chunksize == chunksize + fieldset = parcels.FieldSet.from_nemo(filenames, variables, dimensions) # Now run particles as normal npart = 20 @@ -49,28 +43,31 @@ def run_nemo_curvilinear(mode, outfile, advtype="RK4"): def periodicBC(particle, fieldSet, time): # pragma: no cover if particle.lon > 180: - particle_dlon -= 360 # noqa + particle.dlon -= 360 - pset = parcels.ParticleSet.from_list(fieldset, ptype[mode], lon=lonp, lat=latp) + pset = parcels.ParticleSet.from_list(fieldset, parcels.Particle, lon=lonp, lat=latp) pfile = parcels.ParticleFile(outfile, pset, outputdt=timedelta(days=1)) kernels = pset.Kernel(advection[advtype]) + periodicBC pset.execute(kernels, runtime=runtime, dt=timedelta(hours=6), output_file=pfile) - assert np.allclose(pset.lat - latp, 0, atol=2e-2) + assert np.allclose(pset.lat - latp, 0, atol=1e-1) -@pytest.mark.parametrize("mode", ["jit"]) # Only testing jit as scipy is very slow -def test_nemo_curvilinear(mode, tmpdir): +def test_nemo_curvilinear(tmpdir): """Test the NEMO curvilinear example.""" outfile = tmpdir.join("nemo_particles") - run_nemo_curvilinear(mode, outfile) + run_nemo_curvilinear(outfile) def test_nemo_curvilinear_AA(tmpdir): """Test the NEMO curvilinear example with analytical advection.""" outfile = tmpdir.join("nemo_particlesAA") - run_nemo_curvilinear("scipy", outfile, "AA") + run_nemo_curvilinear(outfile, "AA") +@pytest.mark.v4alpha +@pytest.mark.xfail( + reason="The method for checking whether fields are on the same grid is going to change in v4 (i.e., not by looking at the dataFiles attribute)." +) def test_nemo_3D_samegrid(): """Test that the same grid is used for U and V in 3D NEMO fields.""" data_folder = parcels.download_example_dataset("NemoNorthSeaORCA025-N006_data") @@ -112,21 +109,8 @@ def test_nemo_3D_samegrid(): assert fieldset.U._dataFiles is not fieldset.W._dataFiles -def main(args=None): - """Run the example with given arguments.""" - p = ArgumentParser(description="""Chose the mode using mode option""") - p.add_argument( - "mode", - choices=("scipy", "jit"), - nargs="?", - default="jit", - help="Execution mode for performing computation", - ) - args = p.parse_args(args) - - outfile = "nemo_particles" - - run_nemo_curvilinear(args.mode, outfile) +def main(): + run_nemo_curvilinear("nemo_particles") if __name__ == "__main__": diff --git a/docs/examples/example_ofam.py b/docs/examples/example_ofam.py index 791d890ff..ec089b4a3 100644 --- a/docs/examples/example_ofam.py +++ b/docs/examples/example_ofam.py @@ -7,10 +7,8 @@ import parcels -ptype = {"scipy": parcels.ScipyParticle, "jit": parcels.JITParticle} - -def set_ofam_fieldset(deferred_load=True, use_xarray=False): +def set_ofam_fieldset(use_xarray=False): data_folder = parcels.download_example_dataset("OFAM_example_data") filenames = { "U": f"{data_folder}/OFAM_simple_U.nc", @@ -34,14 +32,12 @@ def set_ofam_fieldset(deferred_load=True, use_xarray=False): variables, dimensions, allow_time_extrapolation=True, - deferred_load=deferred_load, - chunksize=False, ) @pytest.mark.parametrize("use_xarray", [True, False]) def test_ofam_fieldset_fillvalues(use_xarray): - fieldset = set_ofam_fieldset(deferred_load=False, use_xarray=use_xarray) + fieldset = set_ofam_fieldset(use_xarray=use_xarray) # V.data[0, 0, 150] is a landpoint, that makes NetCDF4 generate a masked array, instead of an ndarray assert fieldset.V.data[0, 0, 150] == 0 @@ -53,12 +49,12 @@ def test_ofam_xarray_vs_netcdf(dt): lonstart, latstart, runtime = (180, 10, timedelta(days=7)) psetN = parcels.ParticleSet( - fieldsetNetcdf, pclass=parcels.JITParticle, lon=lonstart, lat=latstart + fieldsetNetcdf, pclass=parcels.Particle, lon=lonstart, lat=latstart ) psetN.execute(parcels.AdvectionRK4, runtime=runtime, dt=dt) psetX = parcels.ParticleSet( - fieldsetxarray, pclass=parcels.JITParticle, lon=lonstart, lat=latstart + fieldsetxarray, pclass=parcels.Particle, lon=lonstart, lat=latstart ) psetX.execute(parcels.AdvectionRK4, runtime=runtime, dt=dt) @@ -67,8 +63,7 @@ def test_ofam_xarray_vs_netcdf(dt): @pytest.mark.parametrize("use_xarray", [True, False]) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_ofam_particles(mode, use_xarray): +def test_ofam_particles(use_xarray): gc.collect() fieldset = set_ofam_fieldset(use_xarray=use_xarray) @@ -77,7 +72,11 @@ def test_ofam_particles(mode, use_xarray): depstart = [2.5] # the depth of the first layer in OFAM pset = parcels.ParticleSet( - fieldset, pclass=ptype[mode], lon=lonstart, lat=latstart, depth=depstart + fieldset, + pclass=parcels.Particle, + lon=lonstart, + lat=latstart, + depth=depstart, ) pset.execute( diff --git a/docs/examples/example_peninsula.py b/docs/examples/example_peninsula.py index a4e61b4f3..2f1aca1e3 100644 --- a/docs/examples/example_peninsula.py +++ b/docs/examples/example_peninsula.py @@ -1,4 +1,3 @@ -import gc import math # NOQA from argparse import ArgumentParser from datetime import timedelta @@ -8,7 +7,6 @@ import parcels -ptype = {"scipy": parcels.ScipyParticle, "jit": parcels.JITParticle} method = { "RK4": parcels.AdvectionRK4, "EE": parcels.AdvectionEE, @@ -101,7 +99,6 @@ def peninsula_example( fieldset, outfile, npart, - mode="jit", degree=1, verbose=False, output=True, @@ -117,8 +114,6 @@ def peninsula_example( Basename of the input fieldset. npart : int Number of particles to intialise. - mode : - (Default value = 'jit') degree : (Default value = 1) verbose : @@ -131,8 +126,7 @@ def peninsula_example( """ # First, we define a custom Particle class to which we add a # custom variable, the initial stream function value p. - # We determine the particle base class according to mode. - MyParticle = ptype[mode].add_variable( + MyParticle = parcels.Particle.add_variable( [ parcels.Variable("p", dtype=np.float32, initial=0.0), parcels.Variable("p_start", dtype=np.float32, initial=0), @@ -177,13 +171,12 @@ def peninsula_example( return pset -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize("mesh", ["flat", "spherical"]) -def test_peninsula_fieldset(mode, mesh, tmpdir): +def test_peninsula_fieldset(mesh, tmpdir): """Execute peninsula test from fieldset generated in memory.""" fieldset = peninsula_fieldset(100, 50, mesh) outfile = tmpdir.join("Peninsula") - pset = peninsula_example(fieldset, outfile, 5, mode=mode, degree=1) + pset = peninsula_example(fieldset, outfile, 5, degree=1) # Test advection accuracy by comparing streamline values err_adv = np.abs(pset.p_start - pset.p) assert (err_adv <= 1.0).all() @@ -200,44 +193,35 @@ def test_peninsula_fieldset(mode, mesh, tmpdir): assert (err_smpl <= 1.0).all() -@pytest.mark.parametrize( - "mode", ["scipy"] -) # Analytical Advection only implemented in Scipy mode @pytest.mark.parametrize("mesh", ["flat", "spherical"]) -def test_peninsula_fieldset_AnalyticalAdvection(mode, mesh, tmpdir): +def test_peninsula_fieldset_AnalyticalAdvection(mesh, tmpdir): """Execute peninsula test using Analytical Advection on C grid.""" fieldset = peninsula_fieldset(101, 51, "flat", grid_type="C") outfile = tmpdir.join("PeninsulaAA") pset = peninsula_example( - fieldset, outfile, npart=10, mode=mode, method=parcels.AdvectionAnalytical + fieldset, outfile, npart=10, method=parcels.AdvectionAnalytical ) # Test advection accuracy by comparing streamline values err_adv = np.array([abs(p.p_start - p.p) for p in pset]) - tol = {"scipy": 3.0e2, "jit": 1.0e2}.get(mode) - assert (err_adv <= tol).all() + assert (err_adv <= 3.0e2).all() -def fieldsetfile(mesh, tmpdir): - """Generate fieldset files for peninsula test.""" - filename = tmpdir.join("peninsula") - fieldset = peninsula_fieldset(100, 50, mesh=mesh) - fieldset.write(filename) - return filename - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("mesh", ["flat", "spherical"]) -def test_peninsula_file(mode, mesh, tmpdir): +def test_peninsula_file(tmpdir): """Open fieldset files and execute.""" - gc.collect() - fieldset = parcels.FieldSet.from_parcels( - fieldsetfile(mesh, tmpdir), - extra_fields={"P": "P"}, - allow_time_extrapolation=True, + data_folder = parcels.download_example_dataset("Peninsula_data") + filenames = { + "U": str(data_folder / "peninsulaU.nc"), + "V": str(data_folder / "peninsulaV.nc"), + "P": str(data_folder / "peninsulaP.nc"), + } + variables = {"U": "vozocrtx", "V": "vomecrty", "P": "P"} + dimensions = {"lon": "nav_lon", "lat": "nav_lat", "time": "time_counter"} + fieldset = parcels.FieldSet.from_netcdf( + filenames, variables, dimensions, allow_time_extrapolation=True ) outfile = tmpdir.join("Peninsula") - pset = peninsula_example(fieldset, outfile, 5, mode=mode, degree=1) + pset = peninsula_example(fieldset, outfile, 5, degree=1) # Test advection accuracy by comparing streamline values err_adv = np.abs(pset.p_start - pset.p) assert (err_adv <= 1.0).all() @@ -259,13 +243,6 @@ def main(args=None): description=""" Example of particle advection around an idealised peninsula""" ) - p.add_argument( - "mode", - choices=("scipy", "jit"), - nargs="?", - default="jit", - help="Execution mode for performing RK4 computation", - ) p.add_argument( "-p", "--particles", type=int, default=20, help="Number of particles to advect" ) @@ -309,17 +286,11 @@ def main(args=None): ) args = p.parse_args(args) - filename = "peninsula" if args.fieldset is not None: fieldset = peninsula_fieldset(args.fieldset[0], args.fieldset[1], mesh="flat") else: fieldset = peninsula_fieldset(100, 50, mesh="flat") - fieldset.write(filename) - # Open fieldset file set - fieldset = parcels.FieldSet.from_parcels( - "peninsula", extra_fields={"P": "P"}, allow_time_extrapolation=True - ) outfile = "Peninsula" if args.profiling: @@ -327,7 +298,7 @@ def main(args=None): from pstats import Stats runctx( - "peninsula_example(fieldset, outfile, args.particles, mode=args.mode,\ + "peninsula_example(fieldset, outfile, args.particles,\ degree=args.degree, verbose=args.verbose,\ output=not args.nooutput, method=method[args.method])", globals(), @@ -340,7 +311,6 @@ def main(args=None): fieldset, outfile, args.particles, - mode=args.mode, degree=args.degree, verbose=args.verbose, output=not args.nooutput, diff --git a/docs/examples/example_radial_rotation.py b/docs/examples/example_radial_rotation.py index 509e19764..3d65694f1 100644 --- a/docs/examples/example_radial_rotation.py +++ b/docs/examples/example_radial_rotation.py @@ -2,12 +2,9 @@ from datetime import timedelta import numpy as np -import pytest import parcels -ptype = {"scipy": parcels.ScipyParticle, "jit": parcels.JITParticle} - def radial_rotation_fieldset( xdim=200, ydim=200 @@ -50,12 +47,12 @@ def true_values(age): # Calculate the expected values for particle 2 at the end return [x, y] -def rotation_example(fieldset, outfile, mode="jit", method=parcels.AdvectionRK4): +def rotation_example(fieldset, outfile, method=parcels.AdvectionRK4): npart = 2 # Test two particles on the rotating fieldset. pset = parcels.ParticleSet.from_line( fieldset, size=npart, - pclass=ptype[mode], + pclass=parcels.Particle, start=(30.0, 30.0), finish=(30.0, 50.0), ) # One particle in centre, one on periphery of Field. @@ -74,11 +71,10 @@ def rotation_example(fieldset, outfile, mode="jit", method=parcels.AdvectionRK4) return pset -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_rotation_example(mode, tmpdir): +def test_rotation_example(tmpdir): fieldset = radial_rotation_fieldset() outfile = tmpdir.join("RadialParticle") - pset = rotation_example(fieldset, outfile, mode=mode) + pset = rotation_example(fieldset, outfile) assert ( pset[0].lon == 30.0 and pset[0].lat == 30.0 ) # Particle at centre of Field remains stationary. @@ -90,10 +86,7 @@ def test_rotation_example(mode, tmpdir): def main(): - filename = "radial_rotation" fieldset = radial_rotation_fieldset() - fieldset.write(filename) - outfile = "RadialParticle" rotation_example(fieldset, outfile) diff --git a/docs/examples/example_stommel.py b/docs/examples/example_stommel.py index d5c9d7583..26379e604 100755 --- a/docs/examples/example_stommel.py +++ b/docs/examples/example_stommel.py @@ -7,7 +7,6 @@ import parcels -ptype = {"scipy": parcels.ScipyParticle, "jit": parcels.JITParticle} method = { "RK4": parcels.AdvectionRK4, "EE": parcels.AdvectionEE, @@ -96,29 +95,22 @@ def simple_partition_function(coords, mpi_size=1): def stommel_example( npart=1, - mode="jit", verbose=False, method=parcels.AdvectionRK4, grid_type="A", outfile="StommelParticle.zarr", repeatdt=None, maxage=None, - write_fields=True, custom_partition_function=False, ): parcels.timer.fieldset = parcels.timer.Timer( "FieldSet", parent=parcels.timer.stommel ) fieldset = stommel_fieldset(grid_type=grid_type) - if write_fields: - filename = "stommel" - fieldset.write(filename) parcels.timer.fieldset.stop() - # Determine particle class according to mode parcels.timer.pset = parcels.timer.Timer("Pset", parent=parcels.timer.stommel) parcels.timer.psetinit = parcels.timer.Timer("Pset_init", parent=parcels.timer.pset) - ParticleClass = parcels.JITParticle if mode == "jit" else parcels.ScipyParticle # Execute for 600 days, with 1-hour timesteps and 5-day output runtime = timedelta(days=600) @@ -131,7 +123,7 @@ def stommel_example( parcels.Variable("next_dt", dtype=np.float64, initial=dt.total_seconds()), parcels.Variable("age", dtype=np.float32, initial=0.0), ] - MyParticle = ParticleClass.add_variables(extra_vars) + MyParticle = parcels.Particle.add_variables(extra_vars) if custom_partition_function: pset = parcels.ParticleSet.from_line( @@ -179,26 +171,21 @@ def stommel_example( @pytest.mark.parametrize("grid_type", ["A", "C"]) -@pytest.mark.parametrize("mode", ["jit", "scipy"]) -def test_stommel_fieldset(mode, grid_type, tmpdir): +def test_stommel_fieldset(grid_type, tmpdir): parcels.timer.root = parcels.timer.Timer("Main") parcels.timer.stommel = parcels.timer.Timer("Stommel", parent=parcels.timer.root) outfile = tmpdir.join("StommelParticle") psetRK4 = stommel_example( 1, - mode=mode, method=method["RK4"], grid_type=grid_type, outfile=outfile, - write_fields=False, ) psetRK45 = stommel_example( 1, - mode=mode, method=method["RK45"], grid_type=grid_type, outfile=outfile, - write_fields=False, ) assert np.allclose(psetRK4.lon, psetRK45.lon, rtol=1e-3) assert np.allclose(psetRK4.lat, psetRK45.lat, rtol=1.1e-3) @@ -228,13 +215,6 @@ def main(args=None): description=""" Example of particle advection in the steady-state solution of the Stommel equation""" ) - p.add_argument( - "mode", - choices=("scipy", "jit"), - nargs="?", - default="jit", - help="Execution mode for performing computation", - ) p.add_argument( "-p", "--particles", type=int, default=1, help="Number of particles to advect" ) @@ -265,12 +245,6 @@ def main(args=None): type=int, help="max age of the particles (after which particles are deleted)", ) - p.add_argument( - "-wf", - "--write_fields", - default=True, - help="Write the hydrodynamic fields to NetCDF", - ) p.add_argument( "-cpf", "--custom_partition_function", @@ -283,13 +257,11 @@ def main(args=None): parcels.timer.stommel = parcels.timer.Timer("Stommel", parent=parcels.timer.root) stommel_example( args.particles, - mode=args.mode, verbose=args.verbose, method=method[args.method], outfile=args.outfile, repeatdt=args.repeatdt, maxage=args.maxage, - write_fields=args.write_fields, custom_partition_function=args.custom_partition_function, ) parcels.timer.stommel.stop() diff --git a/docs/examples/images/homepage.gif b/docs/examples/images/homepage.gif index a76c535d1..4689dd893 100644 Binary files a/docs/examples/images/homepage.gif and b/docs/examples/images/homepage.gif differ diff --git a/docs/examples/parcels_tutorial.ipynb b/docs/examples/parcels_tutorial.ipynb index 3077dfe57..e50483cdc 100644 --- a/docs/examples/parcels_tutorial.ipynb +++ b/docs/examples/parcels_tutorial.ipynb @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -65,46 +65,24 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The first step to running particles with Parcels is to define a `FieldSet` object, which is simply a collection of hydrodynamic fields. In this first case, we use a simple flow of two idealised moving eddies. That field can be downloaded using the `download_example_dataset()` function that comes with Parcels. Since we know that the files are in what's called Parcels FieldSet format, we can call these files using the function `FieldSet.from_parcels()`.\n" + "The first step to running particles with Parcels is to define a `FieldSet` object, which is simply a collection of hydrodynamic fields. In this first case, we use a simple flow of two idealised moving eddies. That field can be downloaded using the `download_example_dataset()` function that comes with Parcels. Since we know that the files are in what's called Parcels FieldSet format, we can call these files using the function `FieldSet.from_netcdf()`.\n" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "
\n", - " fields:\n", - " \n", - " name : 'U'\n", - " grid : RectilinearZGrid(lon=array([ 0.00, 2010.05, 4020.10, ..., 395979.91, 397989.94, 400000.00], dtype=float32), lat=array([ 0.00, 2005.73, 4011.46, ..., 695988.56, 697994.25, 700000.00], dtype=float32), time=array([ 0.00, 86400.00, 172800.00, ..., 432000.00, 518400.00, 604800.00]), time_origin=0.0, mesh='flat')\n", - " extrapolate time: False\n", - " time_periodic : False\n", - " gridindexingtype: 'nemo'\n", - " to_write : False\n", - " \n", - " name : 'V'\n", - " grid : RectilinearZGrid(lon=array([ 0.00, 2010.05, 4020.10, ..., 395979.91, 397989.94, 400000.00], dtype=float32), lat=array([ 0.00, 2005.73, 4011.46, ..., 695988.56, 697994.25, 700000.00], dtype=float32), time=array([ 0.00, 86400.00, 172800.00, ..., 432000.00, 518400.00, 604800.00]), time_origin=0.0, mesh='flat')\n", - " extrapolate time: False\n", - " time_periodic : False\n", - " gridindexingtype: 'nemo'\n", - " to_write : False\n", - " \n", - " name: 'UV'\n", - " U: \n", - " V: \n", - " W: None\n" - ] - } - ], + "outputs": [], "source": [ "example_dataset_folder = parcels.download_example_dataset(\"MovingEddies_data\")\n", "\n", - "fieldset = parcels.FieldSet.from_parcels(f\"{example_dataset_folder}/moving_eddies\")\n", + "filenames = {\n", + " \"U\": str(example_dataset_folder / \"moving_eddiesU.nc\"),\n", + " \"V\": str(example_dataset_folder / \"moving_eddiesV.nc\"),\n", + "}\n", + "variables = {\"U\": \"vozocrtx\", \"V\": \"vomecrty\"}\n", + "dimensions = {\"lon\": \"nav_lon\", \"lat\": \"nav_lat\", \"time\": \"time_counter\"}\n", + "fieldset = parcels.FieldSet.from_netcdf(filenames, variables, dimensions)\n", "\n", "print(fieldset)" ] @@ -119,20 +97,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fieldset.computeTimeChunk()\n", "\n", @@ -148,18 +115,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The next step is to define a `ParticleSet`. In this case, we start 2 particles at locations (330km, 100km) and (330km, 280km) using the `from_list` constructor method, that are advected on the `fieldset` we defined above. Note that we use `JITParticle` as `pclass`, because we will be executing the advection in JIT (Just-In-Time) mode. The alternative is to run in `scipy` mode, in which case `pclass` is `ScipyParticle`\n" + "The next step is to define a `ParticleSet`. In this case, we start 2 particles at locations (330km, 100km) and (330km, 280km) using the `from_list` constructor method, that are advected on the `fieldset` we defined above. Note that we use `Particle` as `pclass`, which is the default choice for particle advection in Parcels.\n" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "pset = parcels.ParticleSet.from_list(\n", " fieldset=fieldset, # the fields on which the particles are advected\n", - " pclass=parcels.JITParticle, # the type of particles (JITParticle or ScipyParticle)\n", + " pclass=parcels.Particle, # the type of particles (Particle or a custom class)\n", " lon=[3.3e5, 3.3e5], # a vector of release longitudes\n", " lat=[1e5, 2.8e5], # a vector of release latitudes\n", ")" @@ -175,46 +142,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " fieldset :\n", - "
\n", - " fields:\n", - " \n", - " name : 'U'\n", - " grid : RectilinearZGrid(lon=array([ 0.00, 2010.05, 4020.10, ..., 395979.91, 397989.94, 400000.00], dtype=float32), lat=array([ 0.00, 2005.73, 4011.46, ..., 695988.56, 697994.25, 700000.00], dtype=float32), time=array([ 0.00, 86400.00]), time_origin=0.0, mesh='flat')\n", - " extrapolate time: False\n", - " time_periodic : False\n", - " gridindexingtype: 'nemo'\n", - " to_write : False\n", - " \n", - " name : 'V'\n", - " grid : RectilinearZGrid(lon=array([ 0.00, 2010.05, 4020.10, ..., 395979.91, 397989.94, 400000.00], dtype=float32), lat=array([ 0.00, 2005.73, 4011.46, ..., 695988.56, 697994.25, 700000.00], dtype=float32), time=array([ 0.00, 86400.00]), time_origin=0.0, mesh='flat')\n", - " extrapolate time: False\n", - " time_periodic : False\n", - " gridindexingtype: 'nemo'\n", - " to_write : False\n", - " \n", - " name: 'UV'\n", - " U: \n", - " V: \n", - " W: None\n", - " pclass : \n", - " repeatdt : None\n", - " # particles: 2\n", - " particles : [\n", - " P[0](lon=330000.000000, lat=100000.000000, depth=0.000000, time=not_yet_set),\n", - " P[1](lon=330000.000000, lat=280000.000000, depth=0.000000, time=not_yet_set)\n", - " ]\n" - ] - } - ], + "outputs": [], "source": [ "print(pset)" ] @@ -237,20 +167,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.pcolormesh(fieldset.U.grid.lon, fieldset.U.grid.lat, fieldset.U.data[0, :, :])\n", "plt.xlabel(\"Zonal distance [m]\")\n", @@ -271,17 +190,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ParticleFile(name='EddyParticles.zarr', particleset=, outputdt=3600.0, chunks=None, create_new_zarrfile=True)\n" - ] - } - ], + "outputs": [], "source": [ "output_file = pset.ParticleFile(\n", " name=\"EddyParticles.zarr\", # the file name\n", @@ -301,17 +212,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 518400.0/518400.0 [00:05<00:00, 95421.55it/s] \n" - ] - } - ], + "outputs": [], "source": [ "pset.execute(\n", " parcels.AdvectionRK4, # the kernel (which defines how particles move)\n", @@ -331,56 +234,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " fieldset :\n", - "
\n", - " fields:\n", - " \n", - " name : 'U'\n", - " grid : RectilinearZGrid(lon=array([ 0.00, 2010.05, 4020.10, ..., 395979.91, 397989.94, 400000.00], dtype=float32), lat=array([ 0.00, 2005.73, 4011.46, ..., 695988.56, 697994.25, 700000.00], dtype=float32), time=array([ 432000.00, 518400.00]), time_origin=0.0, mesh='flat')\n", - " extrapolate time: False\n", - " time_periodic : False\n", - " gridindexingtype: 'nemo'\n", - " to_write : False\n", - " \n", - " name : 'V'\n", - " grid : RectilinearZGrid(lon=array([ 0.00, 2010.05, 4020.10, ..., 395979.91, 397989.94, 400000.00], dtype=float32), lat=array([ 0.00, 2005.73, 4011.46, ..., 695988.56, 697994.25, 700000.00], dtype=float32), time=array([ 432000.00, 518400.00]), time_origin=0.0, mesh='flat')\n", - " extrapolate time: False\n", - " time_periodic : False\n", - " gridindexingtype: 'nemo'\n", - " to_write : False\n", - " \n", - " name: 'UV'\n", - " U: \n", - " V: \n", - " W: None\n", - " pclass : \n", - " repeatdt : None\n", - " # particles: 2\n", - " particles : [\n", - " P[0](lon=226905.562500, lat=82515.218750, depth=0.000000, time=518100.000000),\n", - " P[1](lon=260835.125000, lat=320403.343750, depth=0.000000, time=518100.000000)\n", - " ]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "print(pset)\n", "\n", @@ -411,20 +267,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds = xr.open_zarr(\"EddyParticles.zarr\")\n", "\n", @@ -444,7 +289,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -482,12799 +327,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "HTML(anim.to_jshtml())" ] @@ -13297,18 +352,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in EddyParticles_Bwd.zarr.\n", - "100%|██████████| 518400.0/518400.0 [00:02<00:00, 176426.86it/s]\n" - ] - } - ], + "outputs": [], "source": [ "output_file = pset.ParticleFile(\n", " name=\"EddyParticles_Bwd.zarr\", # the file name\n", @@ -13332,56 +378,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " fieldset :\n", - "
\n", - " fields:\n", - " \n", - " name : 'U'\n", - " grid : RectilinearZGrid(lon=array([ 0.00, 2010.05, 4020.10, ..., 395979.91, 397989.94, 400000.00], dtype=float32), lat=array([ 0.00, 2005.73, 4011.46, ..., 695988.56, 697994.25, 700000.00], dtype=float32), time=array([ 0.00, 86400.00]), time_origin=0.0, mesh='flat')\n", - " extrapolate time: False\n", - " time_periodic : False\n", - " gridindexingtype: 'nemo'\n", - " to_write : False\n", - " \n", - " name : 'V'\n", - " grid : RectilinearZGrid(lon=array([ 0.00, 2010.05, 4020.10, ..., 395979.91, 397989.94, 400000.00], dtype=float32), lat=array([ 0.00, 2005.73, 4011.46, ..., 695988.56, 697994.25, 700000.00], dtype=float32), time=array([ 0.00, 86400.00]), time_origin=0.0, mesh='flat')\n", - " extrapolate time: False\n", - " time_periodic : False\n", - " gridindexingtype: 'nemo'\n", - " to_write : False\n", - " \n", - " name: 'UV'\n", - " U: \n", - " V: \n", - " W: None\n", - " pclass : \n", - " repeatdt : None\n", - " # particles: 2\n", - " particles : [\n", - " P[0](lon=329983.281250, lat=100495.609375, depth=0.000000, time=300.000000),\n", - " P[1](lon=330289.968750, lat=280418.906250, depth=0.000000, time=300.000000)\n", - " ]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "print(pset)\n", "\n", @@ -13420,7 +419,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -13447,21 +446,15 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in EddyParticles_WestVel.zarr.\n", - "100%|██████████| 172800.0/172800.0 [00:00<00:00, 179532.85it/s]\n" - ] - } - ], + "outputs": [], "source": [ "pset = parcels.ParticleSet.from_list(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=[3.3e5, 3.3e5], lat=[1e5, 2.8e5]\n", + " fieldset=fieldset,\n", + " pclass=parcels.Particle,\n", + " lon=[3.3e5, 3.3e5],\n", + " lat=[1e5, 2.8e5],\n", ")\n", "\n", "output_file = pset.ParticleFile(\n", @@ -13485,20 +478,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds = xr.open_zarr(\"EddyParticles_WestVel.zarr\")\n", "\n", @@ -13511,9 +493,7 @@ { "attachments": {}, "cell_type": "markdown", - "metadata": { - "collapsed": true - }, + "metadata": {}, "source": [ "## Reading in data from arbritrary NetCDF files\n" ] @@ -13544,7 +524,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -13566,7 +546,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -13587,7 +567,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -13604,13 +584,13 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "pset = parcels.ParticleSet.from_line(\n", " fieldset=fieldset,\n", - " pclass=parcels.JITParticle,\n", + " pclass=parcels.Particle,\n", " size=5, # releasing 5 particles\n", " start=(28, -33), # releasing on a line: the start longitude and latitude\n", " finish=(30, -33), # releasing on a line: the end longitude and latitude\n", @@ -13627,18 +607,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in GlobCurrentParticles.zarr.\n", - "100%|██████████| 864000.0/864000.0 [00:00<00:00, 1072517.72it/s]\n" - ] - } - ], + "outputs": [], "source": [ "output_file = pset.ParticleFile(\n", " name=\"GlobCurrentParticles.zarr\", outputdt=timedelta(hours=6)\n", @@ -13661,20 +632,9 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds = xr.open_zarr(\"GlobCurrentParticles.zarr\")\n", "ds.traj.plot(margin=2)\n", @@ -13707,15 +667,20 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "example_dataset_folder = parcels.download_example_dataset(\"Peninsula_data\")\n", - "fieldset = parcels.FieldSet.from_parcels(\n", - " f\"{example_dataset_folder}/peninsula\",\n", - " extra_fields={\"P\": \"P\"},\n", - " allow_time_extrapolation=True,\n", + "filenames = {\n", + " \"U\": str(example_dataset_folder / \"peninsulaU.nc\"),\n", + " \"V\": str(example_dataset_folder / \"peninsulaV.nc\"),\n", + " \"P\": str(example_dataset_folder / \"peninsulaP.nc\"),\n", + "}\n", + "variables = {\"U\": \"vozocrtx\", \"V\": \"vomecrty\", \"P\": \"P\"}\n", + "dimensions = {\"lon\": \"nav_lon\", \"lat\": \"nav_lat\", \"time\": \"time_counter\"}\n", + "fieldset = parcels.FieldSet.from_netcdf(\n", + " filenames, variables, dimensions, allow_time_extrapolation=True\n", ")" ] }, @@ -13729,24 +694,11 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "SampleParticle = parcels.JITParticle.add_variable(\"p\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
\n", - "\n", - "Note that if you get a `AttributeError: type object 'JITParticle' has no attribute 'add_variables'` error, you are probably using an old version of Parcels. Please update to the latest version of Parcels using `conda update -c conda-forge parcels`.\n", - "\n", - "Alternatively, you can refer to the Parcels v3.0.1 documentation, which does not use the new `ParticleSet.add_variables()` method introduced in Parcels v3.0.2.\n", - "\n", - "
" + "SampleParticle = parcels.Particle.add_variable(\"p\")" ] }, { @@ -13759,20 +711,9 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "pset = parcels.ParticleSet.from_line(\n", " fieldset=fieldset,\n", @@ -13802,7 +743,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -13821,18 +762,9 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in PeninsulaPressure.zarr.\n", - "100%|██████████| 72000.0/72000.0 [00:00<00:00, 143717.52it/s]\n" - ] - } - ], + "outputs": [], "source": [ "output_file = pset.ParticleFile(\n", " name=\"PeninsulaPressure.zarr\", outputdt=timedelta(hours=1)\n", @@ -13854,20 +786,9 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds = xr.open_zarr(\"PeninsulaPressure.zarr\")\n", "\n", @@ -13914,7 +835,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -13928,7 +849,7 @@ " ),\n", "]\n", "\n", - "DistParticle = parcels.JITParticle.add_variables(extra_vars)" + "DistParticle = parcels.Particle.add_variables(extra_vars)" ] }, { @@ -13941,7 +862,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -13980,7 +901,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -14010,18 +931,9 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in GlobCurrentParticles_Dist.zarr.\n", - "100%|██████████| 518400.0/518400.0 [00:03<00:00, 136275.28it/s]\n" - ] - } - ], + "outputs": [], "source": [ "pset.execute(\n", " [parcels.AdvectionRK4, TotalDistance], # list of kernels to be executed\n", @@ -14043,17 +955,9 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[13.197482, 640.92773, 543.45953, 183.60716, 172.74182]\n" - ] - } - ], + "outputs": [], "source": [ "print([p.distance for p in pset])" ] @@ -14061,7 +965,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "parcels", "language": "python", "name": "python3" }, @@ -14075,7 +979,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/docs/examples/tutorial_Argofloats.ipynb b/docs/examples/tutorial_Argofloats.ipynb index 368a12068..3391156b1 100644 --- a/docs/examples/tutorial_Argofloats.ipynb +++ b/docs/examples/tutorial_Argofloats.ipynb @@ -13,61 +13,101 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This tutorial shows how simple it is to construct a Kernel in Parcels that mimics the [vertical movement of Argo floats](https://www.aoml.noaa.gov/phod/argo/images/argo_float_mission.jpg).\n" + "This tutorial shows how simple it is to construct a Kernel in Parcels that mimics the [vertical movement of Argo floats](https://www.aoml.noaa.gov/phod/argo/images/argo_float_mission.jpg).\n", + "\n", + "We first define the kernels for each phase of the Argo cycle." ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Define the new Kernel that mimics Argo vertical movement\n", - "def ArgoVerticalMovement(particle, fieldset, time):\n", - " driftdepth = 1000 # maximum depth in m\n", - " maxdepth = 2000 # maximum depth in m\n", - " vertical_speed = 0.10 # sink and rise speed in m/s\n", - " cycletime = 10 * 86400 # total time of cycle in seconds\n", - " drifttime = 9 * 86400 # time of deep drift in seconds\n", - "\n", - " if particle.cycle_phase == 0:\n", - " # Phase 0: Sinking with vertical_speed until depth is driftdepth\n", - " particle_ddepth += vertical_speed * particle.dt\n", - " if particle.depth + particle_ddepth >= driftdepth:\n", - " particle_ddepth = driftdepth - particle.depth\n", - " particle.cycle_phase = 1\n", - "\n", - " elif particle.cycle_phase == 1:\n", - " # Phase 1: Drifting at depth for drifttime seconds\n", - " particle.drift_age += particle.dt\n", - " if particle.drift_age >= drifttime:\n", - " particle.drift_age = 0 # reset drift_age for next cycle\n", - " particle.cycle_phase = 2\n", - "\n", - " elif particle.cycle_phase == 2:\n", - " # Phase 2: Sinking further to maxdepth\n", - " particle_ddepth += vertical_speed * particle.dt\n", - " if particle.depth + particle_ddepth >= maxdepth:\n", - " particle_ddepth = maxdepth - particle.depth\n", - " particle.cycle_phase = 3\n", - "\n", - " elif particle.cycle_phase == 3:\n", - " # Phase 3: Rising with vertical_speed until at surface\n", - " particle_ddepth -= vertical_speed * particle.dt\n", - " # particle.temp = fieldset.temp[time, particle.depth, particle.lat, particle.lon] # if fieldset has temperature\n", - " if particle.depth + particle_ddepth <= fieldset.mindepth:\n", - " particle_ddepth = fieldset.mindepth - particle.depth\n", - " # particle.temp = 0./0. # reset temperature to NaN at end of sampling cycle\n", - " particle.cycle_phase = 4\n", - "\n", - " elif particle.cycle_phase == 4:\n", - " # Phase 4: Transmitting at surface until cycletime is reached\n", - " if particle.cycle_age > cycletime:\n", - " particle.cycle_phase = 0\n", - " particle.cycle_age = 0\n", - "\n", - " if particle.state == StatusCode.Evaluate:\n", - " particle.cycle_age += particle.dt # update cycle_age" + "import numpy as np\n", + "\n", + "# Define the new Kernels that mimic Argo vertical movement\n", + "driftdepth = 1000 # maximum depth in m\n", + "maxdepth = 2000 # maximum depth in m\n", + "vertical_speed = 0.10 # sink and rise speed in m/s\n", + "cycletime = (\n", + " 10 * 86400\n", + ") # total time of cycle in seconds # TODO update to \"timedelta64[s]\"\n", + "drifttime = 9 * 86400 # time of deep drift in seconds\n", + "\n", + "\n", + "def ArgoPhase1(particles, fieldset):\n", + " dt = particles.dt / np.timedelta64(1, \"s\") # convert dt to seconds\n", + "\n", + " def SinkingPhase(p):\n", + " \"\"\"Phase 0: Sinking with vertical_speed until depth is driftdepth\"\"\"\n", + " p.ddepth += vertical_speed * dt\n", + " p.cycle_phase = np.where(p.depth + p.ddepth >= driftdepth, 1, p.cycle_phase)\n", + " p.ddepth = np.where(\n", + " p.depth + p.ddepth >= driftdepth, driftdepth - p.depth, p.ddepth\n", + " )\n", + "\n", + " SinkingPhase(particles[particles.cycle_phase == 0])\n", + "\n", + "\n", + "def ArgoPhase2(particles, fieldset):\n", + " dt = particles.dt / np.timedelta64(1, \"s\") # convert dt to seconds\n", + "\n", + " def DriftingPhase(p):\n", + " \"\"\"Phase 1: Drifting at depth for drifttime seconds\"\"\"\n", + " p.drift_age += dt\n", + " p.cycle_phase = np.where(p.drift_age >= drifttime, 2, p.cycle_phase)\n", + " p.drift_age = np.where(p.drift_age >= drifttime, 0, p.drift_age)\n", + "\n", + " DriftingPhase(particles[particles.cycle_phase == 1])\n", + "\n", + "\n", + "def ArgoPhase3(particles, fieldset):\n", + " dt = particles.dt / np.timedelta64(1, \"s\") # convert dt to seconds\n", + "\n", + " def SecondSinkingPhase(p):\n", + " \"\"\"Phase 2: Sinking further to maxdepth\"\"\"\n", + " p.ddepth += vertical_speed * dt\n", + " p.cycle_phase = np.where(p.depth + p.ddepth >= maxdepth, 3, p.cycle_phase)\n", + " p.ddepth = np.where(\n", + " p.depth + p.ddepth >= maxdepth, maxdepth - p.depth, p.ddepth\n", + " )\n", + "\n", + " SecondSinkingPhase(particles[particles.cycle_phase == 2])\n", + "\n", + "\n", + "def ArgoPhase4(particles, fieldset):\n", + " dt = particles.dt / np.timedelta64(1, \"s\") # convert dt to seconds\n", + "\n", + " def RisingPhase(p):\n", + " \"\"\"Phase 3: Rising with vertical_speed until at surface\"\"\"\n", + " p.ddepth -= vertical_speed * dt\n", + " p.temp = fieldset.thetao[p.time, p.depth, p.lat, p.lon]\n", + " p.cycle_phase = np.where(\n", + " p.depth + p.ddepth <= fieldset.mindepth, 4, p.cycle_phase\n", + " )\n", + " p.ddepth = np.where(\n", + " p.depth + p.ddepth <= fieldset.mindepth,\n", + " fieldset.mindepth - p.depth,\n", + " p.ddepth,\n", + " )\n", + "\n", + " RisingPhase(particles[particles.cycle_phase == 3])\n", + "\n", + "\n", + "def ArgoPhase5(particles, fieldset):\n", + " def TransmittingPhase(p):\n", + " \"\"\"Phase 4: Transmitting at surface until cycletime is reached\"\"\"\n", + " p.cycle_phase = np.where(p.cycle_age >= cycletime, 0, p.cycle_phase)\n", + " p.cycle_age = np.where(p.cycle_age >= cycletime, 0, p.cycle_age)\n", + " p.temp = np.nan # no temperature measurement when at surface\n", + "\n", + " TransmittingPhase(particles[particles.cycle_phase == 4])\n", + "\n", + "\n", + "def ArgoPhase6(particles, fieldset):\n", + " dt = particles.dt / np.timedelta64(1, \"s\") # convert dt to seconds\n", + " particles.cycle_age += dt # update cycle_age" ] }, { @@ -77,78 +117,69 @@ "source": [ "And then we can run Parcels with this 'custom kernel'.\n", "\n", - "Note that below we use the two-dimensional velocity fields of GlobCurrent, as these are provided as example_data with Parcels.\n", - "\n", - "We therefore assume that the horizontal velocities are the same throughout the entire water column. However, the `ArgoVerticalMovement` kernel will work on any `FieldSet`, including from full three-dimensional hydrodynamic data.\n", - "\n", - "If the hydrodynamic data also has a Temperature Field, then uncommenting the lines about temperature will also simulate the sampling of temperature.\n" + "Below we use the horizontal velocity fields of CopernicusMarine, which are provided as example_data with Parcels.\n" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in argo_float.zarr.\n", - "100%|██████████| 2592000.0/2592000.0 [00:20<00:00, 129080.81it/s]\n" - ] - } - ], + "outputs": [], "source": [ "from datetime import timedelta\n", "\n", - "import numpy as np\n", + "import xarray as xr\n", "\n", "import parcels\n", "\n", - "# Load the GlobCurrent data in the Agulhas region from the example_data\n", - "example_dataset_folder = parcels.download_example_dataset(\"GlobCurrent_example_data\")\n", - "filenames = {\n", - " \"U\": f\"{example_dataset_folder}/20*.nc\",\n", - " \"V\": f\"{example_dataset_folder}/20*.nc\",\n", - "}\n", - "variables = {\n", - " \"U\": \"eastward_eulerian_current_velocity\",\n", - " \"V\": \"northward_eulerian_current_velocity\",\n", - "}\n", - "dimensions = {\"lat\": \"lat\", \"lon\": \"lon\", \"time\": \"time\"}\n", - "fieldset = parcels.FieldSet.from_netcdf(filenames, variables, dimensions)\n", - "# uppermost layer in the hydrodynamic data\n", - "fieldset.mindepth = fieldset.U.depth[0]\n", + "# Load the CopernicusMarine data in the Agulhas region from the example_datasets\n", + "example_dataset_folder = parcels.download_example_dataset(\n", + " \"CopernicusMarine_data_for_Argo_tutorial\"\n", + ")\n", + "\n", + "ds = xr.open_mfdataset(f\"{example_dataset_folder}/*.nc\", combine=\"by_coords\")\n", "\n", + "# TODO check how we can get good performance without loading full dataset in memory\n", + "ds.load() # load the dataset into memory\n", + "\n", + "fieldset = parcels.FieldSet.from_copernicusmarine(ds)\n", + "fieldset.add_constant(\"mindepth\", 1.0)\n", "\n", "# Define a new Particle type including extra Variables\n", - "ArgoParticle = parcels.JITParticle.add_variables(\n", + "ArgoParticle = parcels.Particle.add_variable(\n", " [\n", - " # Phase of cycle:\n", - " # init_descend=0,\n", - " # drift=1,\n", - " # profile_descend=2,\n", - " # profile_ascend=3,\n", - " # transmit=4\n", " parcels.Variable(\"cycle_phase\", dtype=np.int32, initial=0.0),\n", - " parcels.Variable(\"cycle_age\", dtype=np.float32, initial=0.0),\n", + " parcels.Variable(\n", + " \"cycle_age\", dtype=np.float32, initial=0.0\n", + " ), # TODO update to \"timedelta64[s]\"\n", " parcels.Variable(\"drift_age\", dtype=np.float32, initial=0.0),\n", - " # if fieldset has temperature\n", - " # Variable('temp', dtype=np.float32, initial=np.nan),\n", + " parcels.Variable(\"temp\", dtype=np.float32, initial=np.nan),\n", " ]\n", ")\n", "\n", "# Initiate one Argo float in the Agulhas Current\n", "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=ArgoParticle, lon=[32], lat=[-31], depth=[0]\n", + " fieldset=fieldset,\n", + " pclass=ArgoParticle,\n", + " lon=[32],\n", + " lat=[-31],\n", + " depth=[fieldset.mindepth],\n", ")\n", "\n", "# combine Argo vertical movement kernel with built-in Advection kernel\n", - "kernels = [ArgoVerticalMovement, parcels.AdvectionRK4]\n", + "kernels = [\n", + " ArgoPhase1,\n", + " ArgoPhase2,\n", + " ArgoPhase3,\n", + " ArgoPhase4,\n", + " ArgoPhase5,\n", + " ArgoPhase6,\n", + " parcels.AdvectionRK4,\n", + "]\n", "\n", "# Create a ParticleFile object to store the output\n", - "output_file = pset.ParticleFile(\n", - " name=\"argo_float\",\n", + "output_file = parcels.ParticleFile(\n", + " store=\"argo_float.zarr\",\n", " outputdt=timedelta(minutes=15),\n", " chunks=(1, 500), # setting to write in chunks of 500 observations\n", ")\n", @@ -167,50 +198,77 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now we can plot the trajectory of the Argo float with some simple calls to netCDF4 and matplotlib\n" + "Now we can plot the trajectory of the Argo float with some simple calls to netCDF4 and matplotlib.\n", + "\n", + "First plot the depth as a function of time, with the temperature as color (only on the upcast)." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], + "source": [ + "ds_out = xr.open_zarr(\n", + " output_file.store, decode_times=False\n", + ") # TODO fix without using decode_times=False\n", + "x = ds_out[\"lon\"][:].squeeze()\n", + "y = ds_out[\"lat\"][:].squeeze()\n", + "z = ds_out[\"z\"][:].squeeze()\n", + "time = ds_out[\"time\"][:].squeeze() / 86400 # convert time to days\n", + "temp = ds_out[\"temp\"][:].squeeze()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", - "import xarray as xr\n", - "from mpl_toolkits.mplot3d import Axes3D\n", "\n", - "ds = xr.open_zarr(\"argo_float.zarr\")\n", - "x = ds[\"lon\"][:].squeeze()\n", - "y = ds[\"lat\"][:].squeeze()\n", - "z = ds[\"z\"][:].squeeze()\n", - "ds.close()\n", + "fig = plt.figure(figsize=(13, 6))\n", + "ax = plt.axes()\n", + "ax.plot(time, z, color=\"gray\")\n", + "cb = ax.scatter(time, z, c=temp, s=20, marker=\"o\", zorder=2)\n", + "ax.set_xlabel(\"Time [days]\")\n", + "ax.set_ylabel(\"Depth (m)\")\n", + "ax.invert_yaxis()\n", + "fig.colorbar(cb, label=\"Temperature (°C)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also make a 3D plot of the trajectory colored by temperature." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from mpl_toolkits.mplot3d import Axes3D\n", "\n", - "fig = plt.figure(figsize=(13, 10))\n", + "fig = plt.figure(figsize=(13, 8))\n", "ax = plt.axes(projection=\"3d\")\n", - "cb = ax.scatter(x, y, z, c=z, s=20, marker=\"o\")\n", + "ax.plot3D(x, y, z, color=\"gray\")\n", + "cb = ax.scatter(x, y, z, c=temp, s=20, marker=\"o\", zorder=2)\n", "ax.set_xlabel(\"Longitude\")\n", "ax.set_ylabel(\"Latitude\")\n", "ax.set_zlabel(\"Depth (m)\")\n", "ax.set_zlim(np.max(z), 0)\n", + "fig.colorbar(cb, label=\"Temperature (°C)\")\n", "plt.show()" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "parcels-v4", "language": "python", "name": "python3" }, @@ -224,7 +282,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.12.11" } }, "nbformat": 4, diff --git a/docs/examples/tutorial_NestedFields.ipynb b/docs/examples/tutorial_NestedFields.ipynb deleted file mode 100644 index 9ea16da61..000000000 --- a/docs/examples/tutorial_NestedFields.ipynb +++ /dev/null @@ -1,272 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# NestedFields\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In some applications, you may have access to different fields that each cover only part of the region of interest. Then, you would like to combine them all together. You may also have a field covering the entire region and another one only covering part of it, but with a higher resolution. The set of those fields form what we call nested fields.\n", - "\n", - "It is possible to combine all those fields with kernels, either with different if/else statements depending on particle position.\n", - "\n", - "However, an easier way to work with nested fields in Parcels is to combine all those fields into one `NestedField` object. The Parcels code will then try to successively interpolate the different fields.\n", - "\n", - "For each Particle, the algorithm is the following:\n", - "\n", - "1. Interpolate the particle onto the first `Field` in the `NestedFields` list.\n", - "\n", - "2. If the interpolation succeeds or if an error other than `ErrorOutOfBounds` is thrown, the function is stopped.\n", - "\n", - "3. If an `ErrorOutOfBounds` is thrown, try step 1) again with the next `Field` in the `NestedFields` list\n", - "\n", - "4. If interpolation on the last `Field` in the `NestedFields` list also returns an `ErrorOutOfBounds`, then the Particle is flagged as OutOfBounds.\n", - "\n", - "This algorithm means that **the order of the fields in the 'NestedField' matters**. In particular, the smallest/finest resolution fields have to be listed _before_ the larger/coarser resolution fields.\n", - "\n", - "Note also that `pset.execute()` can be _much_ slower on `NestedField` objects than on normal `Fields`. This is because the handling of the `ErrorOutOfBounds` (step 3) happens outside the fast inner-JIT-loop in C; but instead is delt with in the slower python loop around it. This means that especially in cases where particles often move from one nest to another, simulations can become very slow.\n", - "\n", - "This tutorial shows how to use these `NestedField` with a very idealised example.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import xarray as xr\n", - "\n", - "import parcels" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First define a zonal and meridional velocity field defined on a high resolution (dx = 100m) 2kmx2km grid with a flat mesh. The zonal velocity is uniform and 1 m/s, and the meridional velocity is equal to 0.5 _ cos(lon / 200 _ pi / 2) m/s.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "dim = 21\n", - "lon = np.linspace(0.0, 2e3, dim, dtype=np.float32)\n", - "lat = np.linspace(0.0, 2e3, dim, dtype=np.float32)\n", - "lon_g, lat_g = np.meshgrid(lon, lat)\n", - "V1_data = np.cos(lon_g / 200 * np.pi / 2)\n", - "U1 = parcels.Field(\"U1\", np.ones((dim, dim), dtype=np.float32), lon=lon, lat=lat)\n", - "V1 = parcels.Field(\"V1\", V1_data, grid=U1.grid)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now define the same velocity field on a low resolution (dx = 2km) 20kmx4km grid.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "xdim = 11\n", - "ydim = 3\n", - "lon = np.linspace(-2e3, 18e3, xdim, dtype=np.float32)\n", - "lat = np.linspace(-1e3, 3e3, ydim, dtype=np.float32)\n", - "lon_g, lat_g = np.meshgrid(lon, lat)\n", - "V2_data = np.cos(lon_g / 200 * np.pi / 2)\n", - "U2 = parcels.Field(\"U2\", np.ones((ydim, xdim), dtype=np.float32), lon=lon, lat=lat)\n", - "V2 = parcels.Field(\"V2\", V2_data, grid=U2.grid)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We now combine those fields into a `NestedField` and create the fieldset\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "U = parcels.NestedField(\"U\", [U1, U2])\n", - "V = parcels.NestedField(\"V\", [V1, V2])\n", - "fieldset = parcels.FieldSet(U, V)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in NestedFieldParticle.zarr.\n", - "100%|██████████| 14000.0/14000.0 [00:01<00:00, 9625.92it/s] \n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pset = parcels.ParticleSet(fieldset, pclass=parcels.JITParticle, lon=[0], lat=[1000])\n", - "\n", - "output_file = pset.ParticleFile(\n", - " name=\"NestedFieldParticle.zarr\", outputdt=50, chunks=(1, 100)\n", - ")\n", - "\n", - "pset.execute(parcels.AdvectionRK4, runtime=14000, dt=10, output_file=output_file)\n", - "\n", - "ds = xr.open_zarr(\"NestedFieldParticle.zarr\")\n", - "plt.plot(ds.lon.T, ds.lat.T, \".-\")\n", - "plt.plot([0, 2e3, 2e3, 0, 0], [0, 0, 2e3, 2e3, 0], c=\"orange\")\n", - "plt.plot([-2e3, 18e3, 18e3, -2e3, -2e3], [-1e3, -1e3, 3e3, 3e3, -1e3], c=\"green\");" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As we observe, there is a change of dynamic at lon=2000, which corresponds to the change of grid.\n", - "\n", - "The analytical solution to the problem:\n", - "\n", - "\\begin{align}\n", - "dx/dt &= 1;\\\\\n", - "dy/dt &= \\cos(x \\pi/400);\\\\\n", - "\\text{with } x(0) &= 0, y(0) = 1000\n", - "\\end{align}\n", - "\n", - "is\n", - "\n", - "\\begin{align}\n", - "x(t) &= t;\\\\\n", - "y(t) &= 1000 + 400/\\pi \\sin(t \\pi / 400)\n", - "\\end{align}\n", - "\n", - "which is captured by the High Resolution field (orange area) but not the Low Resolution one (green area).\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Keep track of the field interpolated\n", - "\n", - "For different reasons, you may want to keep track of the field you have interpolated. You can do that easily by creating another field that share the grid with original fields.\n", - "Watch out that this operation has a cost of a full interpolation operation.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# Need to redefine fieldset\n", - "fieldset = parcels.FieldSet(U, V)\n", - "\n", - "ones_array1 = np.ones((U1.grid.ydim, U1.grid.xdim), dtype=np.float32)\n", - "F1 = parcels.Field(\"F1\", ones_array1, grid=U1.grid)\n", - "\n", - "ones_array2 = np.ones((U2.grid.ydim, U2.grid.xdim), dtype=np.float32)\n", - "F2 = parcels.Field(\"F2\", 2 * ones_array2, grid=U2.grid)\n", - "\n", - "F = parcels.NestedField(\"F\", [F1, F2])\n", - "fieldset.add_field(F)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 1.0/1.0 [00:00<00:00, 528.52it/s]\n", - "Particle (1000, 500) interpolates Field #1\n", - "100%|██████████| 1.0/1.0 [00:00<00:00, 1368.01it/s]\n", - "Particle (1000, 500) interpolates Field #1\n" - ] - } - ], - "source": [ - "def SampleNestedFieldIndex(particle, fieldset, time):\n", - " particle.f = fieldset.F[time, particle.depth, particle.lat, particle.lon]\n", - "\n", - "\n", - "SampleParticle = parcels.JITParticle.add_variable(\"f\", dtype=np.int32)\n", - "\n", - "pset = parcels.ParticleSet(fieldset, pclass=SampleParticle, lon=[1000], lat=[500])\n", - "pset.execute(SampleNestedFieldIndex, runtime=1)\n", - "print(\n", - " f\"Particle ({pset[0].lon:g}, {pset[0].lat:g}) \"\n", - " f\"interpolates Field #{int(pset[0].f)}\"\n", - ")\n", - "\n", - "pset[0].lon = 10000\n", - "pset.execute(SampleNestedFieldIndex, runtime=1)\n", - "print(\n", - " f\"Particle ({pset[0].lon:g}, {pset[0].lat:g}) \"\n", - " f\"interpolates Field #{int(pset[0].f)}\"\n", - ")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.6" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/examples/tutorial_analyticaladvection.ipynb b/docs/examples/tutorial_analyticaladvection.ipynb index 02967db3c..e1a7ff995 100644 --- a/docs/examples/tutorial_analyticaladvection.ipynb +++ b/docs/examples/tutorial_analyticaladvection.ipynb @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -75,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -125,18 +125,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in radialAnalytical.zarr.\n", - "100%|██████████| 90000.0/90000.0 [00:00<00:00, 137242.58it/s]\n" - ] - } - ], + "outputs": [], "source": [ "def UpdateR(particle, fieldset, time):\n", " if time == 0:\n", @@ -146,7 +137,7 @@ " particle.radius = fieldset.R[time, particle.depth, particle.lat, particle.lon]\n", "\n", "\n", - "MyParticle = parcels.ScipyParticle.add_variables(\n", + "MyParticle = parcels.Particle.add_variables(\n", " [\n", " parcels.Variable(\"radius\", dtype=np.float32, initial=0.0),\n", " parcels.Variable(\"radius_start\", dtype=np.float32, initial=0.0),\n", @@ -176,29 +167,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Particle radius at start of run 4000.0\n", - "Particle radius at end of run 4002.281494140625\n", - "Change in Particle radius 2.281494140625\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds = xr.open_zarr(\"radialAnalytical.zarr\")\n", "plt.plot(ds.lon.T, ds.lat.T, \".-\")\n", @@ -220,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -286,22 +257,13 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in doublegyreAA.zarr.\n", - "100%|██████████| 3.0/3.0 [00:01<00:00, 1.51it/s] \n" - ] - } - ], + "outputs": [], "source": [ "X, Y = np.meshgrid(np.arange(0.15, 1.85, 0.1), np.arange(0.15, 0.85, 0.1))\n", "\n", - "psetAA = parcels.ParticleSet(fieldsetDG, pclass=parcels.ScipyParticle, lon=X, lat=Y)\n", + "psetAA = parcels.ParticleSet(fieldsetDG, pclass=parcels.Particle, lon=X, lat=Y)\n", "\n", "output = psetAA.ParticleFile(name=\"doublegyreAA.zarr\", outputdt=0.1)\n", "\n", @@ -323,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -363,14308 +325,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "HTML(anim.to_jshtml())" ] @@ -14679,19 +342,11 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 3.0/3.0 [00:00<00:00, 168.91it/s]\n" - ] - } - ], + "outputs": [], "source": [ - "psetRK4 = parcels.ParticleSet(fieldsetDG, pclass=parcels.JITParticle, lon=X, lat=Y)\n", + "psetRK4 = parcels.ParticleSet(fieldsetDG, pclass=parcels.Particle, lon=X, lat=Y)\n", "psetRK4.execute(parcels.AdvectionRK4, dt=0.01, runtime=3)" ] }, @@ -14705,20 +360,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.plot(psetRK4.lon, psetRK4.lat, \"r.\", label=\"RK4\")\n", "plt.plot(psetAA.lon, psetAA.lat, \"b.\", label=\"Analytical\")\n", @@ -14746,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -14819,13 +463,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "fieldsetBJ.add_constant(\"halo_west\", fieldsetBJ.U.grid.lon[0])\n", - "fieldsetBJ.add_constant(\"halo_east\", fieldsetBJ.U.grid.lon[-1])\n", - "fieldsetBJ.add_periodic_halo(zonal=True)\n", + "fieldsetBJ.add_constant(\n", + " \"halo_west\", fieldsetBJ.U.grid.lon[1]\n", + ") # TODO v4: Change index back to 0 when periodic interpolation is done\n", + "fieldsetBJ.add_constant(\n", + " \"halo_east\", fieldsetBJ.U.grid.lon[-2]\n", + ") # TODO v4: Change index back to -1 when periodic interpolation is done\n", "\n", "\n", "def ZonalBC(particle, fieldset, time):\n", @@ -14845,24 +492,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in bickleyjetAA.zarr.\n", - "100%|██████████| 86400.0/86400.0 [00:02<00:00, 36291.48it/s]\n" - ] - } - ], + "outputs": [], "source": [ "X, Y = np.meshgrid(np.arange(0, 19900, 100), np.arange(-100, 100, 100))\n", "\n", - "psetAA = parcels.ParticleSet(\n", - " fieldsetBJ, pclass=parcels.ScipyParticle, lon=X, lat=Y, time=0\n", - ")\n", + "psetAA = parcels.ParticleSet(fieldsetBJ, pclass=parcels.Particle, lon=X, lat=Y, time=0)\n", "\n", "output = psetAA.ParticleFile(name=\"bickleyjetAA.zarr\", outputdt=timedelta(hours=1))\n", "\n", @@ -14884,7 +520,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -14924,13061 +560,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "HTML(anim.to_jshtml())" ] @@ -27993,19 +577,11 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 86400.0/86400.0 [00:00<00:00, 2998038.18it/s]\n" - ] - } - ], + "outputs": [], "source": [ - "psetRK4 = parcels.ParticleSet(fieldsetBJ, pclass=parcels.JITParticle, lon=X, lat=Y)\n", + "psetRK4 = parcels.ParticleSet(fieldsetBJ, pclass=parcels.Particle, lon=X, lat=Y)\n", "\n", "psetRK4.execute(\n", " [parcels.AdvectionRK4, ZonalBC], dt=timedelta(minutes=5), runtime=timedelta(days=1)\n", @@ -28022,20 +598,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAGdCAYAAAAWp6lMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB9mElEQVR4nO3de3wU5dn4/8/MBhADRJFDgCEBTWoPaA+IENpKjK2xim2fVgSqVH4uJNiiKGdsn0ftt5UzyLd9qgmsh9YKYq19WvUrnlarEjCitFqrT6IkZDgIKgShCmTn/v0xu5s9TEIC2cPsXu/XKy/I7mQzkz3MNfd9XdetKaUUQgghhBAZTE/1DgghhBBCJJoEPEIIIYTIeBLwCCGEECLjScAjhBBCiIwnAY8QQgghMp4EPEIIIYTIeBLwCCGEECLjScAjhBBCiIyXk+odSBeWZbF792569+6Npmmp3h0hhBBCdIBSik8++YTBgwej622P40jAE7R7926GDh2a6t0QQgghxEloamrCMIw275eAJ6h3796A/Qfr06dPivdGCCGEEB1x6NAhhg4dGj6Pt0UCnqDQNFafPn0k4BFCCCFc5kTpKJK0LIQQQoiMJwGPEEIIITKeBDxCCCGEyHgS8AghhBAi40nAI4QQQoiMJwGPEEIIITKeBDxCCCGEyHgS8AghhBAi40nAI4QQQoiMJwGPEEIIITKeBDwpYJrg99v/CiGEECLxJOBJMt+KjyksVJSVQWEh+HwRd5om5sbN+Dful2BICCGE6EIS8CSRuXw9FfPysCx7gTPLgsrK4EiPz4ev4A4KJ46mbGJ/Cgus6GBICCGEcJF0m82QgCdZTJO6Beuw8ETdHAhAfc1+zOl3UKHuCd9vKZ3KShX9QpERICGEEC7Q7mxGikjAkyx1dRSrd9EJxNyhqH2umTp1jkMwpFFfH/xGRoCEEEKkqcjRHKfZjIoKqK1N7T5KwJMMpgn792Poe1jKAkBF3KmxaO05HOH0mNsBFLm59s93aARICCGESDKfj4jRHMWa+bviLuAtC0aPTu1IjwQ8iWa/EmDiRLAsRrIN0KI2CVgadRTH3Q4aR44Aa9awRs1sfwRICCGESDLThIrpVsRojsZKbnGYzQClIvJWUyAnNb82S5imPY5nWeGbiqlDJxAVvHh0i29Ym+Nv9yiKcvdirtjAShriHt6jK4qKYoMkIYQQIrFME+rqYP87H2Gps6LuU3hQWGhYqJhxlUAA6uvBMJK5tzYZ4UmkurqoYAfAYBfVVOChBQAPLVQtPciodZVUazNab9ctqqo0jMPvUEcRKmZ0B+CW2Vr0iyY4iWrW7kmrzHghhBCZIzRxUVYGk37aFw3LYSsdsNBiRno8HigqSspuxtGUUrGJI1np0KFD5OXl0dzcTJ8+fbrmQU3TflVEBj2aBrqOGcinXj+XoiXTMOZNDm9v1jRRTxFFJf3tYMY0MQvGUqh2RI3+6LqisTEi4FmxAhYswGdNpYJqLDzoOlRXg9fbNYcjhBAiuzme1ggAWtxoDsDca/ewev0gAgE72Kmq6vpzUkfP3xLwBCUk4AE7FK6sJOrZLi+3x/SKijo2rufz4Zu+hUp1NwFy7NGfar31RbN8Ocyfj8kQCmmMmRaDhobUDB8KFwqNUxcXy4tGCBHH77dHdpwpInNRPbTQsLEWSko6dcrrrI6evyWHJ9G8XucApzPPuteLt7yc8pra6NEfsE9QCxYAsIabnPv8pGi+VKQx08TcvJM6iikeG3w9+XzhnDNTG0rdnHsonnW5vHaEEECw4Pidj9A5I+5cY9MIBT0eWqjSbsAouQ2M9DgHyQhPUMJGeBItGG6bDKGAxrhcHxnhEXGCI4ahNge6ZlG97CDeBf3BsvBxfcS0qKK6WmsdTZQRICGykn09pLAsLZyz4zSFBbCam7lKfwyj+r+SklMhIzzZorgYdJ06q9g5sfkWOS9ltZiRHPbsYfO0p6ngoeieTvPPoLf6AcNpCAc7YJeYVlYoevfWGNu4HmPhtTICJESWCZeeKzvAsQOd0FhJ/DTWVbeNwJg2N+1OPjLCE+TaER4Anw+z4hcUWu/HJDZDY2PaveZEAkUNwGyKHsnRUIBq86oM7ORDp8AZQCdANRUAbY8ACSEyzsa7P2LiT85qZ4voaSzvztuSeuLp6PlbytIzgdeL0fgK1XPr8Hjs+NXjsSu0JNjJHtFr1yiWT3s3qju3aqOKIpId7DhfA1l4qKAqfgQohY3EhBCJ5fPZpeft01jNzTTo5+BdOyZtTzwywhPk6hGeCKbZuQIwkRnM5espnH919AhfTCPLzujsz27cCBMmhHZG8nyEyAROJeg2h2os7WyMrY/CqFHJ3EVARniylmFAaWkb55nQ6m61tUhnwgximtQtWBe/dk07ozUAOi3cTaVDYzDFFkrYyIS4+3RaHFvGT5yo7DVyIjuSpcsSyUKIk+LQOzcossO/YgkLMVQT9lpI6UsCnmwRcSIyL/wP/GW/wCwYKyekTFBXR7F61yEQib4Ksye17G08tFA94VlmeHysjez87YGqKo1R6yqZ4Hks7r7qyjeiOoWHH1lp9mK20+9o/YS0rNQunCOEOCW9jnzgeIETTeMCXkttC+UOkiqtbBCxpldkybGmAsyZtppZ5+/BGDUo1XspTlZxMYa+hynW73iAqUT2woim8TCT6K9/3Nrh22zAW19Pee5+6o8MipgKtftHxd3HIFh7P72tQ0zkkahHDwQ06jkbg6bwbWYgn7pHPqR4giGzW0K4iF2GPgAr6vMk/nPFQwtF+g67qW6av8klhycoU3J4HEX06ontxAyga4rqtVJp42ZOOTxx8+y6RcOGrRglQ0/tg6mNqkCPR9FgFdpD2xDTz0eWORHCLZxzd5yDnSoq8W68LCKJL/kkh0e0CvXqodgxEdVSUmnjVmbtHvyr3uCvH45xeG618HB0aJFaY0LJqV+FtVEVWFWlYSy7yd4vhsRUc8nslhBu4Zy7EztiDOuZjNfzAJSUJGW/TpVMaWUDw4DqaoorfoFuOVffyBIU7hEqgtr2260s+OMFWAzCKTnZQws1lHBE72NPYc2d3HU7YRh4l0P5rJiqQP9IAMfgWl5jQrhDcbE98m+p6BzA2MqsEmpgyRLXvKkl4MkWXi9GeTnVa+qoWHluzAvZFflmguj27nAhrR9ADkPN2g2Meni+ffWVoA8kI3aNnOBoYi/rME5D4Lm5CdkNIUQX2rQp+hJKwwp+b7+fdQJUUYnBLrjgghTs4cmRKa1sYhh4l3+exp0ac+faQQ60LuLukiA9a4Xbu1vOQU6k9do1dgOwCROS+8QGRxMP63mO+xeuWg21SJA5LiHSSqjGRUVcFCs0osMFRTmbXHelLAFPFjIMWL7cXlTU77f/lWTS9Lf5rx+F17Jpj0ezKNl6V+qeVK+X4i2/R9ejp9nCn43Sq0eItNWR/B2LHOopctV0FiQ44Fm8eDGjRo2id+/eDBgwgO9///u8++67Udsopbj99tsZPHgwPXv2pLS0lH/+859R2xw9epQbb7yRfv36kZuby3e/+13MmCvDAwcOMGXKFPLy8sjLy2PKlCkcPHgwkYfneu02KRRpxbfiYyb95EyHe1TUvx5aqFp2MOVtBoxRg6iu1uJHEWltkQBINrMQaSaUvxMt+nudAEXUu2o6CxIc8Lz44ov89Kc/ZcuWLTzzzDO0tLRw6aWXciSiG+OyZctYtWoVv/nNb6itrSU/P59vf/vbfPLJJ+Ftbr75Zh577DE2bNjAyy+/zOHDhxk/fjyBQGtDpB/96Eds376dp556iqeeeort27czZcqURB6eEElhLl9Pxbw8h3Ww7BwZjQC38kv8+iU0LHsE79wTrXuTHF6vwyii0+VjIABr1qRgD4UQsZzyd2IDHgWg6a6azgJAJdG+ffsUoF588UWllFKWZan8/Hy1ZMmS8DafffaZysvLU/fcc49SSqmDBw+qbt26qQ0bNoS32bVrl9J1XT311FNKKaXefvttBagtW7aEt6mpqVGAeueddzq0b83NzQpQzc3Np3ycQnSZpib1MFcrUO1+eXRLNb26O9V7e2JNTUrpetwBNGlD1fMP71NNTaneQSGyl9PbU6PF8TPHT6lKlzdsR8/fSc3haW5uBqBvX/sKdMeOHezdu5dLL700vE2PHj0YN24cmzdvBmDbtm0cP348apvBgwczYsSI8DY1NTXk5eUxevTo8DZjxowhLy8vvE2so0ePcujQoagvESQJpWnDt+Ywk3johNsFLI36Iy7olm0YMHt21E0+rqdQ7aBsYn9J6REihZwGYBUeIPpGe0qrzu4z4SJJC3iUUsyePZtvfOMbjBgxAoC9e/cCMHDgwKhtBw4cGL5v7969dO/enTPPPLPdbQYMGBD3OwcMGBDeJtbixYvD+T55eXkMHTr01A4wU0hCadowTahYdW7wA6eV0xCzhxaKcvckce9OwaxZoNlJkNKgUIj0UVwMWkz+jkb86qFundJKWsAzc+ZM/vGPf7B+/fq4+zQtOgNcKRV3W6zYbZy2b+9xFi1aRHNzc/irqanJcbusYkpCaTqpW/NkRAl6q8h+GKFblrAQ48i7cdumJcOAtWvB42mzQaGk9AiRTqJDBYWHenVOivbl5CUl4Lnxxhv5y1/+gt/vx4goCcrPzweIG4XZt29feNQnPz+fY8eOceDAgXa3+eCDD+J+7/79++NGj0J69OhBnz59or6yXlsJpS4btswIpknxyhlxKxXbV1+xb1uNC/Q33HW1FcxoLt54Z1z5OsCqVRJnC5FsdXXR/XeAYLFEfNVWLoddd25IaMCjlGLmzJn86U9/4vnnn2f48OFR9w8fPpz8/HyeeeaZ8G3Hjh3jxRdfZOzYsQCMHDmSbt26RW2zZ88e3nrrrfA2JSUlNDc38+qrr4a32bp1K83NzeFtRAcEu+RGMvUC/P/Kx9y4Wc5AyVRXxyb17WDDL5uGhXJY69dDC0XTL3ZffwHDwJhQwuzZ8aNYluW6z1IhXM8+BTiVpMe+RzWOaL3ddZEFia3SuuGGG1ReXp564YUX1J49e8Jf//73v8PbLFmyROXl5ak//elP6s0331STJ09WgwYNUocOHQpvM2PGDGUYhnr22WfV66+/rsrKytSXv/xl1dLSEt7msssuU+eff76qqalRNTU16rzzzlPjx4/v8L5KlVbQunVKeTxKgVqnTVO6FlCglE6LWqdNs+8XCdf06m6lx1RHtFUtMZdlaVMtcTKampTStJiqM4+rD0kI11r+swMKrJjPmfjvlzE3bd6kHT1/JzTgwQ4N477uu+++8DaWZanbbrtN5efnqx49eqiLLrpIvfnmm1GP8+mnn6qZM2eqvn37qp49e6rx48ernTt3Rm3z0UcfqWuuuUb17t1b9e7dW11zzTXqwIEDHd5XCXgiNDWppo2bla5Hv8g9HFdNekHavMgz2fMP72ujBD3+g+fVa+5K9e6esog4W3k8ElcLkSrPP99W+wuH80Hl/0n17iqlOn7+1pRyGCPPQocOHSIvL4/m5mbJ58GuSi8ri799FTczYeNEjAklyd+pLGJu3EzhxNFRCb06zivd++9+h9IZn0/m7iWEacasvB55R12dPd7utmk7IVzGNKGgQEXl8tiLh8ZnwPi1Mkp3/i7l78uOnr9lLS3hqK253NncReGkMVKtnmDG2AKqtRl4aAHsPJ0f8Cccy9HPOuDwCO7juNSJtEkQIg0otJgCClDUqq+5KtlOAh7hyF70WsOjh6q2WhPXLEuTavVEMwwoKcEK/c3ReJQfEluOvpAlGCUZ2kPKNGH69Og2CRUV8sITIoGcK7U8VFJN7KITC1lK7aM7k7p/p0ICHtEmrxcaGnVW/ddBYrP0pVo9sczaPVRsvi7cdFDhcRhS1riTRfg2nJ78HUyGzZvtdIFIlgU1NanZHyGyQFuj+5+QS/yq6R5G/+YafCs+Ttr+nQoJeES7DAMmTD8jtlodj8d9FYluUvfSXsd8nVgKD5Xzz5BBDyFElzAMWLqomdjRnD8whdglJiD4GbTAHZ9BEvCIE7Knt+wgB+x/q6pSnqeW0Yq/mR/XdFAn4DCPDgGlU7NyM/6738msfkljx4aXoAjTNMxh35Cl3oRIoJGXnIFT7x2bw2eQpVO/5okE79Wpk4BHdEiwMS5+v/2v15vqPcpsxqhBVI99IJy0rBNg+tnP8Zf/uN8xefDqu8ZQ9pPPUzhxNCuGrsE/70n3BwShJShCw4u6zoof1lA4ZpDkMAuRQMXFoGtOBdx6OKswmqJ2xYtpfxUiZelBUpYu0oppQmEhy61bmM8yQtcmGhZX8UceYQLxV2AhdoK5rimqlx3AO7dvknY6QYL16suf/TLzfxW9iLDHYwfgMtooRNdasQLmzXPqshwqU9ei7tMJsOWa3zDqwVnJ28kgKUsXws3q6jCtQSxkKZFvU4XOI1xF28EO4fsspVE5rw8bZzyf7hde7TMMzKJSFtx5ZtxdkjwvRGLMnQvLfnbQcRrdLqBwSGD+w0x8P9+RpD3sPAl4hEhHvXqxmZI2EpedFvNzFiCHiVVlFBYqVqzAtbkvdqls/O26LsnzQiTKvF+eydZb/+oY9Dh9Bik8VP5qKOby9YnfuZMgAY8Qaci3sTeT2dDOFhrOQY9zIGRZGvPmqWDui3JNGWmIw7q2ACxdKtNZQiTSqF99nznX7HO4R8MxgZkc1sw30/LKSgIeIdKMaULFqnM7UJauMYpX0YOJza3NIdsa/YloHDmvT9pehTmJrRTUdVi2zB52F0Ik1qwlg9AcStKdE5hhFbdgPr490bvVaRLwCJFm6ursoCRe/NXUNr7G//C9YAl76Ge04PdOw9ChR8rhkQWvYdbu6YpdTorISsHGRpg3L9V7JER2MAxYu/xguGo0ROFxzCa0yKH+hpVpV0YpAY8QacZ5+kYxjr/FbWuRw5N8J240yP4+ehmK2MebrVZSODof37x30nL42YnjeltCiITzzu3LQ5Xxn0HKIafQQwv76IdZ8Yu0+myRgEecOtN0bzZsGjIMOzclmsbL2jjiR20UdzMTp4Am8u2toRymvoKVXCuKMAvGpt3VmBAivYz9eVkb/Xlap9J1AljoTOQRCq338f0qfUaRJeARp0ZWs06IkSPjbwsonbnX7osYVo7skRH9gRNbMqrQ+Tm/5L+4Le6+ADnUq7ORFWGFEO0xDKhediCuC7xN4xZWogiN+tgjzZX3fDVt8gWl8WCQNB48CcHmeOHVrEE6wXWR9v60rF/PIwteY7ZaGfdzq698nq9fnseYn3wNS8VOaWnBqy+N6NGfADspBKBu1eMUT/iKO58+07QXHAV7WQpXHoQQ6a/2Z39m9J1Xhhc3DtEIxN0GsFGbyISdKxP2npTGgyLx7Oza6NukE1yXaG/9MmPeZCZsnRu3orHHo7jqt2WMmjGS6mUHHEeC4nN77O/WM4lCGimb/RVXlq3j80FBAUycaH8VFMhooxAJMupX32dt5euOScxOVaIT1UP41hxO0t61TUZ4ghI2wmOadmBQXJx5V5wywpNwwVUVKCqK/5P6fPYsVCDQGhBFrnFmLm97JChW7JWZhxYalj2CMW9yVx1K4pimHeDEfpTJa1GIxDFNNg6dw0QedrgzfkkKj0fR0KAl5O0oIzzpINPzW2QZ9YRrryrpRAu6tjUSFHsFpjsMQwfIoX7hOnfk9LTVhllGG4VIHMNg7LLvt5nPEysQ0FL+dpSAJ1FMEyoqWkc/LCszk0JjzrpmuVcKtpLoRGXaxqhBVFdrrTGprrjuig/DQ9EeWvghj+JUVpprHcL/yIfp/1wWF4Pm0A3E45F1J4RIIGPeZKp/trONoCdaOrwdJeBJlGzKbwmedX2bjIgBLRfmgWSoqJi0UeP+x/vTsOwR/Pol1FDCo/yQ2J49/8GjjGGLO3J6DAPWro0OenRdRhuFSALvL4ezxWG9Lbszc+ttlgWbNiV552JIDk9Ql+fwOOW36Dps2QKjRp3646cZx3QeN+WBZCPTxP/Ih5TN/krcXa7M6TFNqKmx/19SIsGOEEnkm1FLZdVXCZBD9DI3rRciiUqrkxyeVIvNbwE7GhgzJvNyeWhjQMtNeSDZyDAonvCVuBwf1+b0GAZMmGB/BT9RpSemEMnh/fkgahgbHOmJ7A/WKtWTHBLwJJLXa19xRg61Z2guj70cQnweSJH1bmZO42UIw4DqpQc6lNPjtucy02sGhEgrhsHhubc79uEJ0XXIzU3iPsX+/tT96ixx+HB8BUmqw9wEcDpxLmYhdfrnMXPPTfHeifZ45/Y9YU7PYhZiePamPuuwg0wTpk+PrhmoqMi46wwh0krxrMvbqQpVKZ/kkIAn0ZxWgkx1mJsgkSfOJSxkIUsps56lcMwgubpOc8a8yZQ2PsDhVWvjFiIFjVFsw1z8e/x1hiuChs2b468zLKs1xUcI0fUMA6pnv+vQ9DSi+WkKJzkk4Ek0w4AlS6KDnlSHuQlkzJtM0ZYHWaAvD584M3QWL/O0kdPjoYVaRlG4cFJrBV7mvXSFEF3AO6tX2ubySMCTaD4fLFwYn9GbwVFA3eFBWFZ6vMBF58ReoXloCY7WLQ4/p5alUVlhpfVLd+zY+NY8mmYXbwkhEqgDuTyp6skjAU8ixTYfjJWhUYDTLF46NJ0SHeOd1YsG7Wz8lNLAMEayLW6aK2Dp1NfsT9EenlioNU/odajr9vdSqS5E4jnn8thS2ZBfAp5EcqrVBkyG4KcUUy/IyChAVpxwOcPAWHsbpZ6XMdjFNi7AsWqL9A7WvV5obLTL0hsb45feEEIkhn0O0KK6soB94bFkSerei9J4MCghi4c6dOPzcT0VVGPhQdcsqtfqGftB3N7Cl8IFTBOzponCSWNipigVy1jAvKab5IkVQrSpthZGj44uIEhE80FpPJgOQkMdwXF1kyHhYAfAUnqmpvEAJ17nSaQ5w6CuX0lcPhZojCrvK0+sEKJd6daVRQKeRCsvDz/jdRTH50JkZhqPyBBtNZTMffox/Bv3Z2ywLoQ4demWzykBT6LV1YUDnmLq4laV9dBCUe6eVOyZECfkVLV1Lb9njNpM2cT+0sFYCNGmdMvnlByeoITk8EBcHo+P66mkigA56ARYygLm+sfbcz9CpCPTxCwYS706m1yOMIYtUSOVHo+ioUGTGS4hhKPQur5K2S0jZPHQTBUT4nq5l8UsRCOAhYcFLMX32vkp3kkh2hFRtXWYXg7Tshr1a55I0c6dgtpaWLXK/lcIkTCbNsGkSTBxYmrXtZMRnqCEjfCEBEuWzEe3UvibuTFXyF2ftS5El2ujastDCw36ORiNr7jnRTx1KjzwQOv3110H99+fqr0RImM5FCt3+TlPRnjSjWHAe+9R999PS+KycCfDwJhQwpRv7yVyQcBr+T2GtdM9L+La2uhgB+zvZaRHiC7n1I5OlpbIdMGuy8Xq3fjEZd3KxP6DIgOZJvz+mXwi18h5kCnuaqL50kvOt7/ySnL3Q4gskE6VWhLwJEswzDXYRTUVUVUvVaoSA6nvFenPfhnHrJNGDvWzf+ue6axvftP59q9/Pbn7IUQWSKdKrZzk/8osFQxzTWsQZ/M+NZRwhFyKqMdQu6D+GvecMETWKi4GXbOwVOu1kkezKJp1RQr3qpNGjbJzdmJzeEaNSt0+CZHBvF67JV2qO+/LCE+yGAa+KS9QSCNl+BnDFt7jHAx2ycqawjUMTKqpjFtNvW6zy5oQ3n8/vPoqrF5t/ysJy0IkVDp03pcqraBEV2k5ZqrTwkPatYxd+j2MeZO7/HemLdO050aKi2VUy238figrw2QI9RRRywUsZKm9NpxuD127bW242lo7reeb35RBHiHcSKq00oxjpjo5TFQbKFw4OXu61fp8duRXVpbahgzi5ASnZg12UUR9ONgB+/XttrXhpk6FCy+EOXPsf6dOTfUeCSESRQKeJHFakyjEjSeKkxKsVAtHfllz4BkkIgPR7WvDSXW6ENlFAp4kiV2TKJabThQnLZ0aMoiT5/VCQwPFG+90XFi0qHZ9inasc6Q6XYjsIgFPEnln9aJBO5uNTEDLxkVE06khgzg1wSaE1UsPRLdYoBJj0RRXjNpJdboQ2UUCnmQKrklUom1lDivRY08UR95N8Q4mWDo1ZBBdwjvy79RQwipupoYSvNzrmlG7UHV6JKlOFyJzSZVWUMLX0gry+aCiQmFZGjoBZrOSWfxfDM/e7FlQK7iuWEobMogu4VvxMRXz8uwqLQJUU4HX84CrXsu1tfY01te/LsGOEG7U0fO3BDxByQh42ipNb9DPwaj+L/fV854iqU53tzZfz8seya42C0KIlJKy9DTUVml6zX+/nnXBjlSnu19br+f6URLsCCHSjwQ8SRRqyx9r4k/OyqoTvlSnZwan17MshCuESFcS8CRRbFv+EKWy64Qv1emZwXGZCeXCZSaEEFlBAp5kqqvDq9bxEPFD/tl0wpfq9AwRfD03MAw/pSxmIQvUYsom9pdpSiFE2pGAJ5mCZ/qx1KDH9uHJoqkAqU7PEBm2zIQQIrNJwJNMoTO97mF2bB8eVYlB9pwdgs168fvtf73lpv2NnCHdI4OWmRBCZD4JeJLMh5dC1cAK5gMac1lGA8PwqnVZd3YwDCgtBWOTlGy5VnvLTMg0pRAijUjAk0Th6iSlAWDhYTWz7Tuz9ewgJVvuZxgYh96mWlW0JjDrlvunKU0ZdRQikyQ04Pnb3/7GlVdeyeDBg9E0jT//+c9R9yuluP322xk8eDA9e/aktLSUf/7zn1HbHD16lBtvvJF+/fqRm5vLd7/7XcyYD6ADBw4wZcoU8vLyyMvLY8qUKRw8eDCRh3ZS2uxbop+bvUksUrLlfsGgNTKBuYHh9jSlW0mjKCEyTkIDniNHjvDlL3+Z3/zmN473L1u2jFWrVvGb3/yG2tpa8vPz+fa3v80nn3wS3ubmm2/mscceY8OGDbz88sscPnyY8ePHEwi0Jv3+6Ec/Yvv27Tz11FM89dRTbN++nSlTpiTy0E6KY3WSrija8mDWNR4Mk5It94sIWg12UcqLGNZO9watTqOOFRX2GhRCCPdSSQKoxx57LPy9ZVkqPz9fLVmyJHzbZ599pvLy8tQ999yjlFLq4MGDqlu3bmrDhg3hbXbt2qV0XVdPPfWUUkqpt99+WwFqy5Yt4W1qamoUoN55550O719zc7MCVHNz88keYoesu+5vSqdF2d13lNIIqHXrEvor09+6dUp5PPYfxONR8gdxmaYmpXRdNTFEPU+pamKI/Tw2NaV6z07O88+r8Bs08kvX5bUpRBrq6Pk7ZTk8O3bsYO/evVx66aXh23r06MG4cePYvHkzANu2beP48eNR2wwePJgRI0aEt6mpqSEvL4/Ro0eHtxkzZgx5eXnhbZwcPXqUQ4cORX0lnGlS/rtriEztVOhUVqrsThOIK9nK0tEutzIMfFNeoJBGyvBTSCO+a/3unaJ1GnUEyS8TwuVSFvDs3bsXgIEDB0bdPnDgwPB9e/fupXv37px55pntbjNgwIC4xx8wYEB4GyeLFy8O5/zk5eUxdOjQUzqeDqmro06dg4or39VcO/rfZQwDs6gUf50h5xOXMU2o+P03W3vw4KHywW+693kMt49w+HiU/DIhXCvlVVqapkV9r5SKuy1W7DZO25/ocRYtWkRzc3P4q6mpqZN7fhKKiynW3otvOuhRWZ+yIjmi7pWReedeL2zZIvllQmSQlAU8+fn5AHGjMPv27QuP+uTn53Ps2DEOHDjQ7jYffPBB3OPv378/bvQoUo8ePejTp0/UV8IZBsba26jWZkStP1R17cuuHf3vClKZ7m7Fr613COIzIC4YNUpagguRQVIW8AwfPpz8/HyeeeaZ8G3Hjh3jxRdfZOzYsQCMHDmSbt26RW2zZ88e3nrrrfA2JSUlNDc38+qrr4a32bp1K83NzeFt0kp5OV58EeW7w/A+eHFWn90zcoQgW5gmxsJrqaYiOohf8nFmxAXB/DJz42b8D+3BLJf8MiHcKieRD3748GHqI85aO3bsYPv27fTt25eCggJuvvlm7rzzToqLiykuLubOO+/k9NNP50c/+hEAeXl5eL1e5syZw1lnnUXfvn2ZO3cu5513Ht/61rcA+MIXvsBll13G9OnTqaqqAqCiooLx48dz7rnnJvLwToq5eSd1ahzF1FHKi/aNAeyze0acITovlCMaGfRkxAhBNghGq17upZxN1FCCAsYWzgZKUr13XcK3yaCiwsCyQNNg6VKYNy/VeyWE6LRElor5/X4FxH1dd911Sim7NP22225T+fn5qkePHuqiiy5Sb775ZtRjfPrpp2rmzJmqb9++qmfPnmr8+PFq586dUdt89NFH6pprrlG9e/dWvXv3Vtdcc406cOBAp/Y1GWXp69YppeuWXeFKi1rH9a2l2G4t4e0iUpnuUsGSdAVqHdeHWy7oupURz2HE4UV9LV+e6j0TQoR09PytKaVUO/FQ1jh06BB5eXk0NzcnJJ/HNO1k3KhRDFpo0M/BqP4vKcXG/hvV19sjO1k62OVOPh9mxS8otN6PWkDU47G7DLj5ufT77UT6WLoOjY3uPjYhMkVHz98JndISrdpcVmLDaxgT+qdmp9KMYcgJxJW8Xup6fxdrovNq6W5+TouL7Wms2MtCy3L/sQmRbVJelp4tiotB16IjHo9mUVQiwY5wv+Kx/TOygtsw7JydWJlwbEJkGwl4ksTApJrKqPJdS8GmDR+ncK+E6BqGAdVTXoppt/BSRoyAzJsHy5e3tuSR6nQh3ElyeIISncOD349ZNoUCGqM6LXt0RUOjJh+ewt2CSWqmNYh6iiiiHsOz1/1JPBEkx0yI9CQ5POmmuJg67VyUislzsDTJBRDuF0xSM9iFwS77tgxrtyA5ZkK4m0xpJYthULx0WmZ2pBWiuBhTG4qfUkyG2LfJi1sIkUYk4EkiY95kqq96JiPzHER2820yKKShdbV0bZokuggh0ork8AQlPIcHsiLPQWQfxx5THkVDg+SmCSESr6PnbxnhSSJz80781kUAlPKinesgi0YJl3NeC02Tl7UQIq1IwJMkPh8UTi5pHfLnevsOyXMQLhdaCy2SvKyFEOlGAp4kME2oqADL0gCw8FBJFaZeIHkOwvUMA6qr7SAHsqhPjWnaa0+YZqr3RAjRAVKWngSyrITIdN5yk/KHdlKvFVNU0j/zgx2fL3QVYw9vVVfLenhCpDkZ4UmCNof8ZVkJkQl8PigsxJj4dUon5WNs8qV6jxKrdcjW/t6yoLJSRnqESHMS8CRBJrfdTziZNkhv2Xjyd87Shpqa1OyPEKJDJOBJBtPE+/tSaihhFTdTQwneBy/O7JNCVwiOHFBWZv/ry/CRAzdq6+SfySVaTkO2AJMmyWtUiDQmAU8y1NXhs6Yyhi3M5i7GsAVf4LrMPimcqmwcOXCjiJO/yRC707JekNklWqEs7digR16jQqQ1CXiSwOz1eSqoxgouGhqu0so9N8V7lsayceTAjYInf582jUIa7bYLage+TRk+X+v1wvr18bfLa1SItCUBTxLUHR4UDnZCAuRQf2RQivbIBaS5i2uY5V4qtIiAXunZMdAxdqy8RoVwEQl4kkDO3SchormLyRD8+iWYi3+fBc1d3McejNOibsuKgY7ga9TUC1qn8rKiAZEQ7iQBTxK0nrvtZcs8HiWfix3h9eJbso9CvYky61kKF06WnNA0lM0BvQ9vxKKpDfiQXjxCpCsJeJLEi48GqxA/pTRYhXiRM/eJmCZULOjb2qFackLTUrZ2Wo7roG5pVFTI61OISOnUWUQCnmQIfjIaqsleNFQ1yZm7AyRv2T285SYND23Gv3E/DQ3Z0XTY6fVpWbBmTWr2R4h0k26dRSTgSQY5c5+UbJ4qcZVs67QcVFwMmhZ/++rVci0jRDp2FpGAJxnkzH1SsnWqxFXS8VMtSQwD5syJv12uZYRIz+t8CXiSQc7cJ83rhYYGew44W6ZKXCUdP9WSaNYsuZYRwkk6XudLwJMscuY+aYYBpaUSH6aldPxUSyK5lhHCWTq+NzSllErdr08fhw4dIi8vj+bmZvr06ZPq3RHCPXw+exorEGj9VMuygN407UGtoiIJdoSIZNbuof7lvRR9Ix9jVGKa7Xb0/C0BT5AEPEKcHNOEus37KdbqMUqGyhlfCGHz+Vpz/HTdHvJJwMVQR8/fMqWVBOnUh0CIrhQuO53Yn8JJJZm/hpYQomPSsKBBAp4ES7c+BEJ0lTT8PBNCpIs0LGiQgCeB5ISQADJcljbS8PNMCJEu0rCgQQKeBJITQheT4bK0koafZ0KIdJGGZVoS8CSQnBC6UHC4zLQG2StTW4NkuCzF0vDzLH3ISKQQadeORQKeBJITQheqq8NnTaWQxuDK1I34AtfJcFmKZeMaWickI5FCREuTYnApSw9KZFm69Og4dWbtHgovHICFJ3ybhxYaXt2fsN4O4gSSVHLqKqZpBzmRc9kej311K2/+hAi3RaAOY3g3OHzYHl6Xv3fqSVl69pFOwaeu7vCgqGAHIEAO9Uck2EkJych3Jol7SWOaMG/GJxQWWJRN7E/BxNHMu9BPbdl8/EN/jDnjl/J6TCGzdg/+6Q/Z6QeQFp8REvAIV5B8qDQjJ3ZnTi9UgNdeS/6+ZDDfio8pGGqxoqo3lrL/3goPK5jPhbxKGc9TULWIeUM3YC5fn+K9zT4+HxSOyadMPWenH3C9fYeUpQtxYpIPlWYkAnVmGLBkSfztCxfKaEMXqf3Zn6mYl4dq8/SlAaEAaC6F86/G9/MdydvBLNc6+Gs/DxYeKqnCZEjKPyMk4BGukWYJ/9lNItC2XXABACZD7IpChqT8yjZT+FZ8zOg7r4yb3m6PhYeKXxVQ+7M/J27HRJjj4C851OvnpvwzQpKWg2QtLSFOgmTkxzNNfAV3UKHuwcKDToBqbQbenbfJ3+gU1NbCmAstrJO8TtcJUL28Ge/cvl28ZyKSY96+rmjYsjfli4fKCI8Q4uRJRn4cE4MKqsKjEBYeKrUqTORvdLJ8Phg9WjkGOxoBynkKjxY6wzpfw1t4qJx/BmbtngTuqTAMqF76MR7dfh48Hqiq1tKimlYCHiGE6EJ1dYQTaUMCli4zWifJNKFiuoVSWtx9OgG2XvJznmoaQcNOHb8fXn1VY+61e9AJxG0fUDqPXLhcEpkTyefDu6A/DdZQ/FoZDYvXp036gQQ8QoiTIs2EnUmhVtfa/NeP4gJIsIOdpSzkcMVsard3o27jG+Q2/JPDL73BrIkfsOWa3zgEPYrZrLITmVd8nJwDyCYR7SoMdlGq/BiLpqTNh4Tk8ARJDo8QHSc9B9u3fDnMnx99m/Qf7DyfD6ZPUyiiR3d0AixkCUu0RcFgSGFXZ9n/agSYw0oGso+FLCWAJ2Ibm0ezaNj6QVpMtWQMv9/uMO50e2lpwn6t5PAIIRJCeg6eWLBQK4oUanVOeCorJtjx0MIiFrOERREjP1rUv6GePAtYygLu5AZ+AzGPE1A69aOvkaU/ulKat6uQgEcI0SnSc/DE0vxz3xXamsqaxlru5NYOVWtZeLiTn3M3M4lNZtZpYZ/qh1nxC4nWu0qat6uQgEcI0SlyMj+xNP/cT3s+H0z6aXz5uE6AairbaTroJHL0RwX/F0ChM5GNFFrv41tz+JT3WQR5vZg1TfhXvYFZ05RWc90S8AghOkVO5h0jjTJPTmjKNLYqS8PCQmsj2FEx/7ZF4xZWBkMf+3EsPFSuPlcGebqIvazEIMpmf4XCMYPSasZQkpaDJGlZiM6RnoMiEdrKe4UAOHRY1gnwP3yXXlePJ/c7F7Hxqd6sfmQoAas1iTmSPboT/zj+jfspndC/Kw4hazk2HUxCsn5Hz985idsFIUQmMwwJdETXK+61B50BUctH6AQcl5MIdbEev/V2GDUKgFFTYdYKOxh/7U9NLPj1YKyIU51yqtiihaKJI+HQbTIUdwray+9Lh88KmdISQnSeNOERCbJpY3NUZVZoKiuWToAtlOBdOyYc7ISEGoDP/b8FrK940eG3tObzeGhhMQupU+dIAvMpSvf8Pgl4hBCd4/PZ49ZlZfa/6TRJn64kQOwQ04SKVedG5enYwU/0qcpDC9XaDEa9+t8nHJEZ+5+XoOtOmRtasJ/PYhaylDL8ksDcBWZPP4SuRSwrkUb5fRLwCCE6TprwdJ4EiB1mT4nEjubEj+6s165xHNlxYifZa45Bj4WHxdwave7Zqs/JelsnweeDwgKLFVV9QFnMZXlaLSsBEvAIITpDmvB0jlOAWFFhL/0t4vQ68oHjGliRPLRQ8pdFncq18XphyxYtPPIQojnkBgUsaUjYWfbLXIX7Jll4WM0tsHBhWl0MScAjhOi4dJ+kTzdOAaJlwZgxckKN4fPBmO+FkpWdi4c9tFBFJUavg51+/FGjoHqthke3nw+7Wit+9MhDC0Xqf2XkshOcRuYC5FBvDU+riyEJeIQQHSdNeDqnrZVEZSowSutAWPQSEbHWMxmv54GTDrC9XmjY8gEbuTr4G6KfG50WbmGV/Y2MXHaY/TKPDlI9tFCk70iriyEJeIS7STJoUpkm+M+2O6lKR70OCAWIuo7JEPyUYjLEvk9OqGFOA2GxPLRQor96ygG2MWoQ/eZOdSxzV+isYD6FNOLTpqXVyTqdGQZULz2AR7OfRA8tVGk3YFT/V1pdDGVUwPPb3/6W4cOHc9pppzFy5EheeumlVO+SSCRJBk2qqD/3mEH43itNqw+ztOX14ltUTyGNdiUQjfi4XqYCIxS/tj4ud0fDQqcFCJ5AJ/oxGl/pkgC7eNblDknMKrr7MlWYe+KDIuHA58O7oD8NqgC/VkZD5RK8O9Owp5HKEBs2bFDdunVTa9euVW+//baaNWuWys3NVY2NjR36+ebmZgWo5ubmBO+p6BJNTUrpulLQ+uXx2LeLLid/7pPn9LfTaVGv3vpYqnctPTQ1qSZtqJrLMuXhePBvZCl7cYkWNZelqkkv6PIX27p1Snl0K+r3xX75tYvtDUXb0uDDoaPn74wZ4Vm1ahVer5dp06bxhS98gbvuuouhQ4dy9913p3rXRCJItVBSyZ/75DnmLeNhzJLvy6Ak4FtzmEK1gxXMCzYYtAjl8Cg8rGY2LFnS5aOJXi/U/M++4MiSJC+fNBd9OGREwHPs2DG2bdvGpZdeGnX7pZdeyubNm1O0VyKhpFooqeTPffIkb7ltoUaDoXwae9mH6D9WgBzqR01OyO8/nDuwzSUrFrOQOooxA/lpefJOGy76cMiIgOfDDz8kEAgwcODAqNsHDhzI3r17HX/m6NGjHDp0KOpLuIhUCyWV/LlPXkTecpw0vRBOGudGg9E8HpWwc6fTuVonwCLubO2+TCO+185PzA5kAhd9OGREwBOiadFvHKVU3G0hixcvJi8vL/w1dOjQZOyi6EpeLzQ0YG7cjP+hPZjlaZYgl2GCf24pzjoJduM711wIJ41TsrK9mIR9m4cWqm55N2HnztZzdeu6Wgu5M7778sK+WT0Sd0Iu+XDIiICnX79+eDyeuNGcffv2xY36hCxatIjm5ubwV1NTUzJ2VXQx3yaDwkkllE3sL4VaSRBalDENL97S3qhRrrkQTg7TxFh4LUtZQHSjQQ0NxUYm0KCfg3dWr4TuhtcLDQ/V4KeUJSyMCnZCAgGor9mf0P1wM9MEf52BWVSa1i/ojAh4unfvzsiRI3nmmWeibn/mmWcYO3as48/06NGDPn36RH0Jd5FlnZJMeh6dMpdcCCeFuXknfusiCmgkNmnYIof++sdJ6+NijC2gSHufBSwN5hFF89BC0cSRckXlwFXdQZJTNJZ4obJ0n8+n3n77bXXzzTer3Nxc1dDQ0KGfl7J093n++fgyUlDK70/1nmWgdetaS091XUp1xSmxX05WuERfIxBd1awFVNOru5O6T8/PfcLx80SnRa3jeunF4CANKtKVUllYlj5x4kTuuusufvGLX/CVr3yFv/3tbzz55JMUFhametdEgrioOMDdZCit62XxaFnsMhKh6aOoJoNUYgxqfxHRrubUjFAnwBbGUM4mu0u2VGxFcVFFOpAhU1ohP/nJT2hoaODo0aNs27aNiy66KNW7JBLIRcUB7ua2T7V056o5gK7n9HJS6FhozGUZDQzDq9Yl/fVlf55oUQnM1VTwD86P7pItFVthbrvo1JRSzsvSZplDhw6Rl5dHc3Oz5PO4jGnan41FRRLsJIRp2ifmyLOUx2MnocgfvHOc/pa6Do2NWfO3NE0oLLCwHCYYPLTQwDAMz96Uvb7MjZupn3grRdSzh0GMYUtUErO89FuZJqz55SFWVffGUlr4ojPZuWkdPX9n1AiPyE5SOZRgMpTWdRzbLluwZk1q9icFDEyqqXQoRw82GdTPTenryxhbQKn+EpsoZ3RMsANSsRXi89mB64qqPqAs5rKchsXr0zoRX0Z4gmSER4gTkKG0U2eaUFCAqQZTRzHF1GGwK6uGDcyNm6mb+DOOcDrf5S9RVVEeXdGwZS/GqEEp3EMwl6+ncP7Vjl2YPbTQoJ2NsTYNF8dMEnugUkU1jfTQQoN+jr3Aa5JfxzLCI4ToWjKUduoMA9+lG+JXTs+SnCifDwonl1CGn+/xF37M7/CEkpU1i6pqLeXBDkDdBZPbXHKiikoM1ZTViftOHbID5FBvDU/r13FOqndACCGyhWlCxTMTgotk2hVKFVRzvvYWo9I107OLOFVnPcgUaijhCLkUaTswyl8BUh9Qh5Jxo1KtghVbo3jNviEUpGbhBYD994kf4SnSd6RvxjIywiMySRaX+gp3cLoytvAwhi34NmX2idOx2I8cjpBLKS9iWDvTZnQgdskJnRZmsxLALk9nSHqXIyWYYUD10gN4NPsJ9dBClXZD0hpFniwJeERmyPJSX+EOba6crrSMnyEJjQpEU9Rygf3fNAsgQktOzGUZoLGC+VzIq61Tkdf60/rknlA+H94F/WlQBfi1Mhoql+Ddmf45TZK0HCRJyy4mZdPCRXy+6D6Okfx+O00qI/l8rJj2DvOCAURIONm1+r/S7oRp1u6h8MIBzsnL2foRk4aft5K0LLJHcKzcZEjrcHOWJIEK98nKldODCTwjeY3YdbMC5FC/4bW0C3YA6g4Pcgx2IIvL013ciFQCHuF+xcX4tGnRlS/atAw+ewi3a105PdjV16MyurVRaKHQXhyO67/j8UBRSf8U7Vn72pqChCxeUNRt7ZUjSMAjXM/EoIKq8JWYhYdKrQozDao9MoHkgieGFx8NViF+SmmwCvGSmSfOyFL0MWxhSmQpOi1ULfk4bQO92ORlaF12ImvL013ciFRyeIIkh8e9/H47V9np9ozNh0iSyHwTXbc/59Jw5sF90jAPIhEcD5OW1lJ06jH8D6b9GzW03EQuR8L7DbQ2j3TBMXS5NGpEKjk8Imu4eIQ1rcki6Qnk4jyIzmirFH0jE+xSdM9eV7xRQ8tNjOI1iqhnDbOyekFR0wR/nYFZVJryYKczJOARrufiEda0liXn5NQIRulRifYAr72W2v3qYsWvrXdcM2sVszH1Ave8UYMfMj5tGgU0soJ50VPoC/tmzYWAmzuAyJRWkExpuV8ajbBmhCyZdUkZ34SnqPjjt7HwoBOgmgq8ngcy5w8cfAHNs5awgnlxd/s37qd0QnomKztxWj8qktuO52TU1sLo0RAZNaTDZ4JMaYmsI0s9dS0ZOUsc04SKP5VHjRJUUE1t4KsZM4QWqsy6mo1oLqrMaotTl+yQbKjY8vlgzJjoYAfcNeorAY8Qok1er3315vfb/0rCctdod4mJDMgHia3Milsk1IWBs3On6Oyo2IrN54vkpnxJCXiEEO2SkbOu1+YSExmQD9LeIqF+SmnQhuMtd98BGgZUz343HLhptHA16/kz3+Ns3s/ohqdO+Xxgv4bdFLxKwCOEEEkWmi50Cnrcfs500yKhneWd1YsG7WzmsgwNjY1M5koez/iGp04Buq7bHcPdNOorAY8Qwpl0HEyoTF1iorgYtJhUF51AuHeNqw/QMGDpUlYxJ2LJidaRrExteGoYUP2Dp6IaRlZPeYlRo1K8Y50kAY8QIp6ba09dZNQoqF76MR49tMSEu6YIHO3ZQ6gjcUj4uww4wLoLJre9vpalZ+b6WitW4P3jd2hgmD0tyTC8D17suoshCXiEENGk42Dy+Hx4F/SnwRqKXyujYfF6V00RxPH5qBt9LUpFD/EoPNSvfjwjMt+zbn0t04QFCwAw2GVPS7LLlXOvEvCIzCNTMadGOg4mR0RgabCLUuXHWHit3ezEjYLHU6zedV4g9KqvuHpkJyTr1tdqL2PZZVOTEvCIzCJTMadO1upIjuCJJKrbsmXZzU5c+LoN9d0BqKYieoHQa1/KhFgnzOuFhodq8FPKXxnPKm6mhhLK2WQ/l4H8zLlAaGtIa8kS1wWwEvCIzCFTMV1DOg4mR3ExPm1a9JpMXO/K121k351CGgFcn+9xIsbYAt7Tivkef2E2dzGarRSwM/PW14r9PNB1WL4c5sV3z053srREkCwtkQFk2fQuYZr24ENxrz0YR96VtToSxDShsMDCUq3XnToBtjCGUbzmmtdtWyuiNzDMzvUIccnxdJTT8xcpHZZc6FJpvHaPLC0hso9MxZyyqBnBMYPwvVeadh9umaKujriTZbjbsov6ubTVd6eeiP3PwPeh0/MXKePS3jKgA6kEPCJzyFTMKZEZweRqt9uyi/q5OB+HopYL7f9m6PuwvWotCFZs1a5P3g6JE5KAR2SW4OJP5sbN+B/ag1nu7hLYZJLirORqt9uypbvm724YsHTRQaJ772gs8izF3Lg5I0rRncRWa2kE0LDfQOGKrUVT5IohjUjAIzKOb5NB4aQSyib2l0KtTpAZweQLd1vWolMpXfV39/kYeecPCXUcDgkENOr7l2TcyE6kULWWvdQEKHQ0Aixgsb2+VgZUa2VSlw8JeERGkWmZkyczgqkx6h++6DJuzaJqycdp/3c3TfBv3I85/Y62e++4JWg7FcOHRy01ofBwJz93fbWWadqFWAUFmdPlQ6q0gqRKKzNIodapS+NijMwTUeJkMoR6iiiiHkPfY0efaToV5PO1XljoBKimAoBKqgiQg0dXVFVr6br7Xaqtz5wQN1ZrRT6/kdL1WDp6/paAJ0gCnszgWCKbpm9SIUJnS5Mh1FFMMXWtpdxp+sJtrwwdoF77HEVb/4AxalBqdjDJnP4esdx0wXWi40nHY5GydJGVZFpGuEpM88ECGpnHUrvrcppmjLdXhm6vtfQCxqCA8w9nIMMILgAbnJKMXTjVbdVaba0kAe6fppSAR2ScYKEWfn/GFoiIDGFiUEFVVP7HCubbuR9p2ovHMbmdFooIBmdKpWWglkjekX+ngWFsZAKV3BO9rIbLqrXs5zd+4kfXLNdfPErAIzJSBvTISr5MKsdwibaa16VzL57QiEZkZZmFzibK7W/cPgxwMoqL2aR9h0lsoIobsNCYyzJqKHFdtZaxyUe1il4LbS7LaNSG4y1392eD5PAESQ5PBgqvkVAskc+JRGWh6mmdMJtJ3Jgvgc+HOf0OCtQOVHBkCoJ5PPo5GNX/lXWvHadlJuy+PHbwqhOgenkz3rl9U7eTHdFWEn0orywtX5CSwyOynaya3nFSy58yrc0H468703KgJPhaqVPnRAU7EMzj2fBa1gU74DxSp/CEpyotPFQuPDP931IRCTx2PtaL0Un0afeC7BwJeETmkRN450iL5ZTy4qNRFTKXZa3TCB6VlvkS5uad+K2L6MVh5747Jf1TtGepdaJlJiDYiHHNE8nZoZPV1oHoekZUf0jAIzKPnMA7R1osp04oOFcWl/P/qKGEjUzgocAkyj9Or8oenw8KJ5dQhp8xbGEKv0v7AC1ZwtWhemiZiZbwMhMhHlooWvWT9L7wcipznTsXGhszYuQuJ9U7IESXC53AY5vxyAncWehDrrLSDgyllj956urwWVOpoBoLT/gkqdDR5weo1j5Oi7yP1kFTe/kICw8PMoUaSjhCL4pqHsqavjtt8Xqh/Py9rLnwQVYxGwsdu0RdQ6eFW1gFVvDCK53fW14vlJdnZPdRGeERmSfiKsVkCH79EszFv8+oN26Xk1r+lDB7fT4c7IAd6Kjgx7KFh8oF6ZH30VbvnSPk2n13jrybmh1LN4MGsUprXWYCtGAQq7W2G0jzpSZME/x1BmZRacZ9ZkrAIzKT14tvyT4K9SbKrGcpXDhZ8pZPRGr5k67u8KCIk2O8gKWlxUxscTFo0WuDohOwe+/I6GmYc/Ky7ork5UxcOyuWBDwiI5kmVCzo2zoEL3nLIg2dKNk1bWKJPXuI7SCsAHSZ/ozk1uTlUFHrihV230jIzM9MCXhERpK8ZeEGhgHVU14KJ/9qBNCDeTxpkwjs81E3+lqUih7iUXiytgy9LW5MXo4tao2UaZ+ZkrQsMpLkLQtXME28vy/lfL7Gy3ydb/AKgP3/wGZGUQmkJqAwTajbvJ/i6XdQrCx0AlHTb9lcht6e9pOXAyxmIYa1M22SlzN57axYMsIjMlJ4Qb/glZYUHom0FKzSGsMWZnMXo9nKaLYym7sYQw2+6VtSMhIQ7ts5sT+FagebKKeaiOUG9DQZfUpXDsnLoLDwsJClabVOWvFr6+N6KkHGtN6JIktLBMnSEhkmuFSCaQ2iXvscRUunY8ybnOq9EiKKWbuHwgsHtJm47KGFho21GBNKkrdPDstdeGihgWEA9vtp6x+yvgy9PX6/nfjbFo9m0bBTT30wEXyyfdZUKqkiQA4eWriF1cx69VrXPMeytITIXhGT0ga7KFV+V61WLLLHCau0yKGe5I4EtFWCXk9RcLmBFzAGxY8IiFYnSl4OKD09EpeDT7aXe2lgGH5KaWAYy5mfka0GJOARmSfiE9tkCH5KXbVascgeJ6zS0q2k58nY+xQ98O+hxS5BB7uMR95L7QpPqQenAGMr3NImcTniBRi1dpaup82UW1eSgEdknuCb2Mf1FNJIGX5XNPwS2SdUpaW3VaVVnfxpD2OTjynW72g9SSuu5fcZtYhkMnhH/p0lLAzmx9g5PEB84nIqta5e23qbptm3pXy+retJDk+Q5PBkFnP5egrnXx1XVdLQkJHvY+FWpomv4A4q1D1YeNAJsJA76ccBvnHrRYz61feTvj9mwVgK1Y7o904wh8fw7LUzWaUU/YSc87Naq7WqtRl4d96WHh9Ipgk1Nfb/S0rSY586oaPnbylLFxmp7oLJxFZaBlywjE0ymaY9+1dcLH+TVDE37wwHO2B34r2TnwMa+p0Bqs9M3lpapgl1G/ezX42OyysKkEP96scxruonL5YOsvOzYrWuRVap7qZ8/SMpK6aIfv8bMGFCSvYjmWRKS2QkWQC8feGy4wxtIe8WdRQ7JC1HnBSTtJZW+PUw56tMZkN8szyPouiqr0iw0wlOuVCRAuRQv3BdatsOZNn7XwIekZEi1g8FpA9PpNjOqpnYQt4tisf2R9fa6PpGctbSins94EFDhfOKPLpFVZUm751OMgyonv1um4nLOgFyrUNJz+Oxn2+Vle9/CXhExpIFwJ3JshvpwzCgetlBPHroCYmp5knCqKTT68HCwwYm46/cQEOjLu+dk+Sd1YslLIpLXA41IRzDFnzPFiZ1n+rWPBleYzAkW97/EvCIjCYLgMeT6b404vNRPv8rPGRNYiMTmMAjRFVHXZv4125xrz2OZegl1FC67loMsuDSP0FMDBZoS+M6LkdNW/5qKOby9UnaIZNeK24nNrAGRW5ucnYhlSTgESLLyHRfmjBNfNO3UKh2MJGNTGQDf+QqQidD0HjwQZWwqQbTBP+8J2H0aKZY9+NYhp4tl/4JUlcHloo9zcaMriQzl6eujsPkxu0DaBw5kvhfn2oJDXh+9atfMXbsWE4//XTOOOMMx2127tzJlVdeSW5uLv369eOmm27i2LFjUdu8+eabjBs3jp49ezJkyBB+8YtfEFtN/+KLLzJy5EhOO+00zj77bO65555EHZZwG9O057WyYZK6g2S6L/ViK7QUHlTMR3IgkJgcHjtpVVG24nIK1Q5+x3VEBVpMwWSIDP2dIufE5fjvX7O+mpzAsriYYurj1s7yeFRWPM0JDXiOHTvGhAkTuOGGGxzvDwQCXHHFFRw5coSXX36ZDRs28OijjzJnzpzwNocOHeLb3/42gwcPpra2ll//+tesWLGCVatWhbfZsWMHl19+Od/85jd54403uPXWW7npppt49NFHE3l4wg18PsyCsfjLfoFZMDZ7yhE6QKb7Usu5QitaIk5ErUnKrdMqcYEWOdTr58rQ3ymyOy4fQIsKMBTRQY/GQpZg5p6b0H0xTfBv7gEQvRAsLVQtOZAdT7NKgvvuu0/l5eXF3f7kk08qXdfVrl27wretX79e9ejRQzU3NyullPrtb3+r8vLy1GeffRbeZvHixWrw4MHKsiyllFLz589Xn//856Meu7KyUo0ZM6bD+9jc3KyA8O8VGaCpSa3TpimdFgVK6bSoddo0pZqaUr1nQqimJqV0LaDstRpCXwEFVvD/lrpu7Ltd/nuff17F/M74L49uqaZXd3f5785G9vNsnfBv7p/7eML2Yd06pXRdtX4Ocr1qYojyM041MUQpvz9hvzsZOnr+TmkOT01NDSNGjGDw4MHh28rLyzl69Cjbtm0LbzNu3Dh69OgRtc3u3btpaGgIb3PppZdGPXZ5eTmvvfYax48fd/zdR48e5dChQ1FfIrM4NXWrVHdj1jSleM9STKb40oKByRT1eyJzZ+wxl4ippc1nY9bu6dLf65SkrBNoLUP3QFW15pqVstOdnccTmzMTTU/g2lpxZeh4qKQKwF47y7M3a6YtUxrw7N27l4EDB0bdduaZZ9K9e3f27t3b5jah70+0TUtLCx9++KHj7168eDF5eXnhr6FDh3bJMYn04TRlkIrVp9NKtnYcS0Pm5p38nmuJDHAcp5Ze+aBrfl9EknK1NS1qSqOaShpvXSs5XQnglMejEYia5lLobLK+lZA8Hscy9NDnYJZVLHQ64Ln99tvRNK3dr9dee63Dj6dp8ZGvUirq9thtVDBhubPbRFq0aBHNzc3hr6amLL/qz0BOTd1Ssfp02pCOg2mlQzk8tFD09YHtbtMRsUnKBziTh5jMRibQwDC8+DCW3khpkZkt576kccrjscfytIjvdSqpwnz2na795aZJ8coZ8UnKuqJo4+Ksi247vZbWzJkzmTRpUrvbDBs2rEOPlZ+fz9atW6NuO3DgAMePHw+P2OTn54dHckL27dsHcMJtcnJyOOussxx/d48ePaKmyUTmCTV1q1xwBgFLt1efrkr+6tNpo72Og1n7R0mdUEAeXbZsQfhkqLiWP2AMuuSUfo9TkvI8lhNexJIKvNwrr4UEKp/UF22+orW4WI+r1QqQQ/3iRzBmjO+656CuDkM1UU0FlVQRIMdOUp5djzGhpGt+h4t0eoSnX79+fP7zn2/367TTTuvQY5WUlPDWW2+xZ0/rHPXTTz9Njx49GDlyZHibv/3tb1Gl6k8//TSDBw8OB1YlJSU888wzUY/99NNPc8EFF9CtW7fOHqLIFD4f3gX9abAK8GtlNCzekE0XM/Gk42Ba6VAOD9eccs6ZU5wb1fiOKilBT7CO5PEkpDw94j1vhZ9zDQYO6Lrf4SaJzJxubGxUb7zxhrrjjjtUr1691BtvvKHeeOMN9cknnyillGppaVEjRoxQl1xyiXr99dfVs88+qwzDUDNnzgw/xsGDB9XAgQPV5MmT1Ztvvqn+9Kc/qT59+qgVK1aEt3n//ffV6aefrm655Rb19ttvK5/Pp7p166b++Mc/dnhfpUorwzQ1KaXrqokh6nlK7UoEjyerK7SampR6fu4TqkkvCJbieOzyDZESTQ+/Eq4gbLd6Z+O+U/s9r+5Wut5+lZBfL5PXQgLZH0exz4EVUZEXfEtyXDX97O4u+53PP6/Uq5ffFvc6y7SPwo6evxMa8Fx33XWhhgNRX/6IErjGxkZ1xRVXqJ49e6q+ffuqmTNnRpWgK6XUP/7xD/XNb35T9ejRQ+Xn56vbb789XJIe8sILL6ivfvWrqnv37mrYsGHq7rs796KRgCfDPP+8Wsf10SXpXO/68suTFVWWqltq3dx/ZdYnngs9//C+EwY7YKnly0/+dzQte0g9r5Wpn/GLiJNezElWStCTYtnPPo7727cZfJ7ie3Pd8o/CAVZbQXUmfRR29PytKRXTsjhLHTp0iLy8PJqbm+nTp0+qd0ecIrN2D4UXDohKCvXQQsOr+7Ou3NY07YKsyGkNj8fOV5R0jdQxl6+nYP7EmMqsyBwem8ejaGjo/GrlvhUfUzEvL/gesNdv0gjwQ/7IY/zQzucIFulk9VRvkvj9dnFk+xTLmcfcjaNhwoST+j3m8vUUzr86JiG+df0usJOWGxo7/5pKVx09f8taWiIj1R0e5FySfiS7gh2Q1dHTkmnCggVxN2sxJyY4ieUlTBNz42Yq5p8Zs2ilvXzFY/yQGkrw65fQULNHgp0kcV5mIoBj1+WJc06uZYRpUrdgnUP1nxau1PLQQtXSLOmsHEMCHpGRJD+3lfwt0lBdHXXqnLi+OwoPGrEZxh1fydpcvh5/wXVsnnhXm0myAXI4Qi6l1vMYR949iZ0XJ8MwoHr2uzHLTESP5oH9/NSo0XZpXSdaRpi1e/DfWUMvdSi+DJ0WtjDGDnKXPYJ3bt9TOBL3koBHZCRZEbyV/C3SUBuLOIa6HUfTGDOm7Qv+UOPsFT8/SOH8qylTzzGJ9Q6Bk81DC0XUS9SbAuVX58WENzrxi4nCJDbgs6bCmjUdelzf1JcovHAAZXdPYAxbGENNxOMqrr3iAKP8yyltfABj3uRTOgY3kxyeIMnhyUymaU/dFBXJCV7+FmnENKGggKnKxwNMJdR351Ke4mm+4/gjug6NjdHPnc8X2UsyejpMI4COIkBO+D4PLVRRidfzgCTvpEBbeTwaAVTMNJROC43a2RhbH4VRo5wf0DQx//oGhT+5vP2cnQzP2ZMcHiGwe52UKj8G0k1YVkdPI3V1mGowv+fHRPbdeZZvx436hFgW/PKX9kmzthY2boxunB07NaLwMI1q/FzMq7f+j71sxKv78fqnZF2H3XThnMej+BF/iNvWIoc5ahnmhT+AefPip7d8PsyCsWz8yfOOOTuRJGfPJiM8QTLCk4GCl7+mNYg67VyKl07L6uFckUZME//QH1PG83F3zWUZq5iN5dgIP3TlHp/c7ESnhUaG2QtEZvIlvoss//kB5v/qDKJH41qwuy/Hj0FoBJjDSmbxa6isZHPBJNi3j51rHmMBS6Kq8FpldlVWLBnhEdkt2E/fZ02lkEbK1HMUzr8a34qPU71nQgDQi0+Iz99QXM0jNDKM8fyPw09pMf+2zwotEimX+GnjgkvOJH40LoeROK9BqfCwgvkU0MjQqluZ+LMiJq4ZyzyWxVThqaifkqqseBLwiMxUV4dpDaKC6vCHgoWHygVnylqZIvXq6jhML+IDF40jlXMw2MUUh2mOE4sOoCRBOf0UF4OmxU+svM7X2pzOBIKjP5Gn7PjXTis7GXqjNjGrq7JiScAjMlOvXtRp58b34rE62dNEiEQoLqZYe8/hBKd4rWgSVFYyls1tVlrF/kyr1iv9UIKy4dkrZXlpxDBgTsUncbdb5FBBdRuVep1nkUP/h38j0/gRJOARmcfngzFjKFbvxvejyJYL3VCtsgxnpSfDwFh6I0tYQGzAsmCBonb8HRj6HtYyHU/wBGhXXYVez/bP2N/HX+mv5mYa7n5KEpTT1Kyf90F3GOWppoIlLGTuxJ2O98drDW5jg2OPrigq6d8Vu5sxJOARmSWYuxMqXZnNqvAJI2v6z/h89loSZWX2vyfTsVUk3gUXcAHbiA1YLEtjzPcG4pvyAl7PAzQwDD+l7KSQLYzhajZA8ORmL0QRc6Kjhav0xzDGf0XK8tKUYUD1Wi0uqLHwsJAlzMr5LY1b9zJ3rh24gB3wRj/XoeVCLBZza1RwLHk7zqRKK0iqtDJEsNGFj+vD+TsaAeZcvYtZKwsy/wNAFs5yD9PEHFpCIQ0OZcV2350t//MBgz59n7oPz2TbP7ox/56zUTEBUmS/HQ8tVGk34F07RkZ1XGDjRpg4Mf72q9nASuZhzJ2EOe4a6usURWd+BH//O4/f9b/cwG8hcp1AzaJBGw5WgHr9XIqWZFdFakfP3xLwBEnAkyFME7NgLIVqR/TCoSe5AKPrtNXZzO+3r/ZFepk3z17kMyK5PpKGAg2Uar8UfSMT6M9+im67FmPaZRLcuoTdf1IFn99ooXL0q3mEw/SimDrAfq7nsDpue//G/ZT2/2dWdhaVgKeTJODJHP55T1K24vL427PhnC8jPO4S7Lj8uPoOV/I4HS03j+ShhQbpteNa82YcYkVVe+ec1qkr+zud+E7KWXJB1wbpwyOyVvGsy+O6mWZNsrIsnOUuhgFz5pDLvznZYEcqsdytrQTmVqGV7iMbE0ZU4+kWVVXZG+x0hgQ8IuPY53wte8/5Xq99pe/3S4WOG8ya1UaJupNQdVYLc1lOw1/fkkoslwsnMMctOXEiGqtvO0hDoy5PfQfJlFaQTGlhD6/X1dmdsdweHZgm5uad1GvFFJX0d/3hiAzn8+GbvoVKdXfUYp92ZY5dveOhhcUsZBSvUaTvwKj+LwlyMohp2oujr1qpsBxyemLJTHUryeHppKwPeCKXXdZ1e1rErR+mmXQsInuYJuYv76d+rZ9c6xBHyLW7JAP1FNlBzpKZ9srZWZiYmi1Cgc/qVYqA1Zqsrml2fZ6ltPCotXys2STg6aRsDnjM2j3Ujb6WYvUuBrvsG3UdtmyxP1zdpLYWc/QP2axGAxpj2SzJnMJdTNNe9yo3F44caf1XgpysEvsyCOUg1tfLSyFWR8/fTsvxiizi80HF9Hws9Rw6AaqpwMu99ujImDHuGh3x+fBNq2E6DeHkPg2LtYHpeOvr5RNCuINhyGtVtPkykJfGyZMRnqBsHOExTSgssLBUa+56uMQ1NNLjloniYP+dArUDFdPPxEMLDa/uxxg1KEU7J4QQIlGkLF2cUN3m/VHBDkCAHGooibghgCtW26yro06dExfsgH1M9UcyO9iRpbOEEKJ9EvBksW3PNxO9cKFtEhvwcb39jVsa2ARXn9YcSnvdcggnS5bOEkKIE5OAJ0uZJiyoPhunZmcWHiqpwtQL4JZbkr9zJ8MwMNbexlptRlTQo+uZ3YMnZq1ULAsqK2WkRwghYknAk6WcprMiBcih3hoOK1a4Z9igvBzvhm+z9U4//3VzM3ffDY2N7sm5Phl1ddGrSIB7ZiGFECKZpEorS9nTWf1oq529h5ZwDxAsyx5GOHYMrrzSvi3dGhQGe+/4rKnhhRh1Hbp1y+yAp7jYHsWKXTork6fwhBDiZMgITxZyns5StObzKK7l962VWoBpDcL/k42YQ8dAQUH6JIyYJmzcCBUVmNagqFWns2F6R5bOEkKIjpGAJws5T2dptAZAGg8yBZMhAPi4nkIaKcNPIY341P9nb5bqiMLnwywYi3/i3ZjWIOooDgc7IdkwvSNLZwkhxIlJwJOFiqlDw2p3mwA51FNMLRcwPXLUJJTQHAyGUhZRmCa+6VsoVDvCgdhrjIxbgDFbpncMA0pLZWRHCCHaIgFPNho+/ISbeGjhmaurGM2WuN42djAUjCJSFFGYm3dSoe6JCsQWsYSlLMBDS3jXZHpHCCEESNJyVtrs+xeKthvx6bTwg5E7uXPj5xzvDyc0a1rKIgrH6StyuOC28TRcsZ/6I4NkvRkhhBBhEvBkGd+Kj6moGtfuNv+9oImfLj/b8T6dAFVU2gnNugfKyxOxm20zTairo3j459G1mGUxdIuiaaX2GjTJ3SshhBBpTqa0sohpQsWCM+NGRiJpBOjb499xvV1C921hDOVswk8pZiA/ufk7wZbCZtkU6kZfy5KvbWydvqKFqimvZMeIjqwjIYQQnSYBTxaxm9Q5990J0YDho/qhx70yFEtZwD84P7pi69nCtk++XXliDrYU9llT7d+vnmPBtglMYy0bmUADw/A+eHHmBwGyjoQQQpwUWS09KBtWSzdN+xzpNHoTyb9xP+81eqic14cAOegEWMoCJrGBQhqjRojCq6vre2DpUhg50u6Gt2lT65oHum43izmZeungFBb792NOnB33+8GeZqumAi/32gFWaWnnf48bOD2BblnNXgghEkRWSxdxwk3qdPuEqdMCMeXpoYRk78i/08Aw/JTSSCFzWdlmovBavJjWIJg3r3XkYfr0U1/gKXI0Y/Jk6vic43Rc1NpfGVyDbm7eid+6qLUlAGRHoyEhhOgCEvBkGW+5SYOyA5mlLIzqtawRoEq7AaNkKBQXY+h7KOVFAPyU8hxlOK2u/gvuoICdrSusWxbEDhw6nZjbm/IKTmGZ1iA7X8gaRDF1cX12wg9PDvWzf5uxIx0+HxROLmmdSnTbavZCCJFiEvBkm7o6DNVELkdYwFJUxEtAR1GunrKno4LDQT5tWjhn51f8nLbW3lLoVFBFLRfYAUpwFMJkiP197OhLW7kooSBo8+bWfB38FNDIGm5kCQuCI1PRPB5F0awruuzPlE5aV0S3//ZRI1rSaEgIITpEcniCsiGHB7A7FBfcwXR1T1xDQbBHcko9L0NDAyYGhYXqhInOkTQCKDzoBJjC7/g9P7YX8tQUS29tZu4lb0CvXjBmDFgWJkOoo5hi/X1YuJC6xX+kWL0Lmk6h2uGYr7OUBXyg5bNam0PA0sINBjN1SQW/344L427fuJ/SCf2Tv0NCCJFGOnr+loAnKFsCHtOEwgLLYS0tAMVy5jGXleD341eljifatiniFySN/n4Z85inrwbLwsf14cU+Q0tdKHR0AsxmFSuY5/hbQonSbHyE+v4lGd9gUHKVhRCibZK0LBzV1dFGsAOgsZAlmBhQVERxMQ7l6TadQMx6XBbx013x3y9kKaY1CJMhUSubK/Tw9JqFh9XcAu3l6+jnYpQMzYr1o2RFdCGEOHUS8GQZO4hpe1Avcp0spxPt8uX2FEvjso0s0xZGBD0dm/ay8FBPkWPFV+x+aG08pocWipZMy6ozvqyILoQQp0amtIKyZUoLYOrVh3ngkVzsICV+2mk585g7V7OjG+wplfp6oqaO7GmWzuX3QMR0FFBAo2MeUWg/nKbHPLqiaukBvHP7dur3ulaoD1FxcVYFeEII0VEypSUcmSb8/tFetAYToaCH8PcLWYK5amO4XNwwiJs66kjX5lb243toCa/DtYlyIgMaDQstOIVl/xs/HbZ6NTQ0atkT7EhXZSGE6DIS8GQZO1CJvTU6uAiQQ701vN2Gdu3m9+it93loYTnz8FNKA8MoZxMbmcB0qmNK4i1u5U70YJVXbL8fjweuuiqLBjlaa9Ht70+2eaMQQghAAp6s4xyoxM5qKl7TLmy3oV1sfk+Ix2Pf3thol003aGczl5WU8iKbKKeQRiayMW4qK0AOd3JrRF6PFvWYWZek6xSZSldlIYQ4aZLDE5RNOTw+H0yfrlAqFFSEKqwiggzdoqFRP2GQEcrvyc2FI0eILxH3+aCyEjOQ77gOVohOwPG+1auzbGQnRGrRhRCiQySHR7SpvBw0LXIaSyduWsvSOzSYEMrvGTUqPs8HCJcX1a16vM1gx+OBpT/7JK56LOumsSJJLboQQnQpCXiykHMeTzQPLRTVru+aX2gYFE/4StxUmscDGzfagxZzf3kG1dWanN8jSS26EEJ0GZnSCsqmKS2n2ZJIoeUb5nru6tIplODsFoEAbS4H4VQCL4QQQrRFlpbopGwKeMAOPiKLgGLpBKimAq9/ij1X1UUkoBFCCNGVJODppGwLeABqa8NreDry0ELDq/sxRg1K7o4JIYQQHSRJy+KERo1yLi0PCZBD/REJdoQQQrifBDxZLpQXu3FjfH8ej6fdVjyiC5mmnZssfQWFECIxJOARGAZMmCBV0KkiK0gIIUTiSQ5PUDbm8DiRpOLkkv6CQghxaiSHR5wUA5NS5cdA5laSQVaQEEKI5JCAR7SSuZWkc1rbTHKnhBCi6yUs4GloaMDr9TJ8+HB69uzJOeecw2233caxY8eittu5cydXXnklubm59OvXj5tuuilumzfffJNx48bRs2dPhgwZwi9+8QtiZ+JefPFFRo4cyWmnncbZZ5/NPffck6hDy0zB1blNaxB+SjGtQbI6dxLIChJCCJEcOYl64HfeeQfLsqiqqqKoqIi33nqL6dOnc+TIEVasWAFAIBDgiiuuoH///rz88st89NFHXHfddSil+PWvfw3Yc3Pf/va3ufjii6mtreV///d/mTp1Krm5ucyZMweAHTt2cPnllzN9+nQefPBBXnnlFX7yk5/Qv39/fvjDHybqEDNLXR0+ayoVVGPhsRsPBirw1tfL2TfBvF57fTPJnRKi6wQCAY4fP57q3RBdoFu3bnja6p/SCUlNWl6+fDl3330377//PgD/7//9P8aPH09TUxODBw8GYMOGDUydOpV9+/bRp08f7r77bhYtWsQHH3xAjx49AFiyZAm//vWvMU0TTdNYsGABf/nLX/jXv/4V/l0zZszg73//OzU1NR3at2xPWjZr91B44YCoBT6l8WCCmKadvFNcLNGNEF1MKcXevXs5ePBgqndFdKEzzjiD/Pz8mIWvbR09fydshMdJc3Mzffv2DX9fU1PDiBEjwsEOQHl5OUePHmXbtm1cfPHF1NTUMG7cuHCwE9pm0aJFNDQ0MHz4cGpqarj00kujfld5eTk+n4/jx4/TrVu3uH05evQoR48eDX9/6NChrjxU16k7PIjYhsuhxoNySu4apgl1a56keOUMDNVkJ+9UV8uioEJ0oVCwM2DAAE4//XTHE6RwD6UU//73v9m3bx8Agwad/AV40gKe9957j1//+tesXLkyfNvevXsZOHBg1HZnnnkm3bt3Z+/eveFthg0bFrVN6Gf27t3L8OHDHR9n4MCBtLS08OGHHzr+gRYvXswdd9zRFYeWEULJs7Hl0ZI82zXstcsUlnU5Ojvsdcqse+08qfJyGekRogsEAoFwsHPWWWelendEF+nZsycA+/btY8CAASc9vdXppOXbb78dTdPa/Xrttdeifmb37t1cdtllTJgwgWnTpkXd5xR9K6Wibo/dJjQL19ltIi1atIjm5ubwV1NT04kOPaNJ8mziBPPBsSz7tWjhoZIqTIZIDboQXSiUs3P66aeneE9EVws9p6eSl9XpEZ6ZM2cyadKkdreJHJHZvXs3F198MSUlJVRXV0dtl5+fz9atW6NuO3DgAMePHw+P2OTn54dHe0JCQ1sn2iYnJ6fNKL9Hjx5R02RCkmcTxbHXDjnUU4Th2SvDaEJ0MZnGyjxd8Zx2OuDp168f/fr169C2u3bt4uKLL2bkyJHcd9996DENR0pKSvjVr37Fnj17wtNOTz/9ND169GDkyJHhbW699VaOHTtG9+7dw9sMHjw4HFiVlJTw17/+Neqxn376aS644ALH/B3RNsOICXQkwfaUOU4X0kKRvkOG0YQQIkkS1odn9+7dlJaWMnToUFasWMH+/fvZu3dv1EjMpZdeyhe/+EWmTJnCG2+8wXPPPcfcuXOZPn16ONP6Rz/6ET169GDq1Km89dZbPPbYY9x5553Mnj07HPHNmDGDxsZGZs+ezb/+9S/uvfdefD4fc+fOTdThZQefD7NgLP6yX2AWjJVGhCfDNDHq/FQv/ThiulBRNbceo/EVSVgWQohkUQly3333KcDxK1JjY6O64oorVM+ePVXfvn3VzJkz1WeffRa1zT/+8Q/1zW9+U/Xo0UPl5+er22+/XVmWFbXNCy+8oL761a+q7t27q2HDhqm77767U/vb3NysANXc3HxyB5xpXn1VrdOmKZ0WBUrptKh12jSlHn5YqaamVO+dO6xbp5SuK/sPqKumZQ8pv1/+fEIkyqeffqrefvtt9emnn6Z6VzrtuuuuC58jPR6PGjp0qJoxY4b6+OOPw9sUFhaq1atXh7+3LEvNnj1b9erVSz333HNxj1lRUaGAqJ9xq/ae246evxNWpTV16lSmTp16wu0KCgp4/PHH293mvPPO429/+1u724wbN47XX3+9M7so2uLzYU67nQoawn15LDxUqrs5f2IJh7U+FC+dhjFvcop3NI21Zirb31sWxqIpGA3flCksIYSjyy67jPvuu4+Wlhbefvttrr/+eg4ePMj69evjtg0EAkyfPp2//vWvPP/884waNSrq/j//+c9s3bo1qu1LtktqHx7hAsETdR0XRTUhBDvRdgxbsJQHfX6Aau1jvHP7tvFAWa69VUEl4BHCHZKcw9ijRw/y8/MBMAyDiRMncv/998dtd/ToUSZPnkxtbS1/+9vf+MIXvhB1/65du5g5cyabNm3iiiuuSPh+u4UsHiqiBU/UrzESe3Q1kooe8Vlwpiy11RZZFVQId0vxYsrvv/8+Tz31VFzhzeHDh7niiiv45z//ySuvvBIX7FiWxZQpU5g3bx5f+tKXkrnLaU9GeES04mJMbSgL1VIgsgxQxXwPAUuTAYu2hBobVVbaIzvS2EgI93CYkk5Gk9DHH3+cXr16EQgE+OyzzwBYtWpV1Db/5//8H3r37s3bb7/NgAED4h5j6dKl5OTkcNNNNyVsP91KRnhENMOgbs49cdNZdrATPeLj0ZUMWLTH64WGBvD77X+lIksId2hvSjqBLr74YrZv387WrVu58cYbKS8v58Ybb4za5tJLL+XIkSPceeedcT+/bds21qxZw/333y+9iBxIwCPiFM+6HF2Pn86KHfFZsqhZBixOxDCgtFRGdoRwkxRNSefm5lJUVMT555/P//2//5ejR4/GLYF0ySWX8Je//IXq6uq4YOill15i3759FBQUkJOTQ05ODo2NjcyZMyduiaZsJAGPiGPPxmjhvjH2+z72akHjgm+dkdwdS2OmaQ/kSE6TEBkgTdbaue2221ixYgW7d++Ouv3b3/42jz/+OPfeey8//elPw0spTZkyhX/84x9s3749/DV48GDmzZvHpk2bkrrv6UhyeISjyGUmcnNhzBhZWLQt9sKg9t9HFkAXIkOkwVo7paWlfOlLX+LOO+/kN7/5TdR9ZWVlPPHEE4wfPx6lFP/93//NWWedFbecUrdu3cjPz+fcc89N5q6nJRnhEW0KzcaMGpUWFztpqa3cRhnpESIDpMGU9OzZs1m7dq3jAtelpaU8+eST/P73v+eGG24Ij/QIZ5qSvxAAhw4dIi8vj+bm5vCyFiKaacrCorH8frtq1en20tKk744QWe2zzz5jx44dDB8+nNNOOy3VuyO6UHvPbUfP3zKlJTosbmHRLBTuQ9ZrD8bhdyju9Xl0fZBM9wkhRJqTKS1xarIoWzeqD9mFA/CVPYgxxqB6yksy3SeEEGlOAh5x8oIRgFk2BX/BdZjL49d7yRRxuTp4qKQK0xqE98GLaajZI+12hBAijcmUljg5wQjAZ02lguro9bUm/Tup688knGlSt3E/lvXVqJsD5FBPEUZgF8aRdzFKB6VoB4UQQpyIjPCIk7NmDaY1yA52ItfXmn8GZsHYzBn1CY5iFc+5Ep1A1F0eWiiiXpJ2hBDCBSTgEZ1nmrByJWu4KX5FdaWzRs2kkEbK1HMUzr8a34qPU7SjpyhiHstgF9VU4KEFsIOdKioxPHslaUcIIVxAAh7ReXV1mGowK5kTd5dOC6uYEz/q48ac5pj1dLzcSwPD8K/eTsOr+/H6p0jSjhBCuIQEPKLzioup085FxS0wClfxR8dRn/qa/cnau67jsJ6O4dlL6VX9MEYNSnlDMiGEEB0nAY/oPMOgeOm0uJwWXYe513zQdq6L26TJejpCCCFOnQQ84qQY8yZTvbwZT3BVdY/Hjg1GLfkh1VSGc110AizRbsUoGZrK3e0Qx5ZCXq89bSU150KIDDBs2DDuuuuuU3qMF154AU3TOHjwYJfsU0NDA5qmsX379i55vLZIwCNOmnduXxoatehYwDDwrithMbeiEcDCwwKW4NsUMSqSBs0KTRP8G/djbtwMphndVLDQLs4KS4P1dIQQ2WHz5s14PB4uu+yyVO8KYK/XdfPNN0fdNnbsWPbs2UNeXl5qduokScAjTolTLGCWe1moLw3n+FhKb11QM5XNCoOBlm/FxxQWWJRN7E/hxNGsGLqGiumWLAAqhEi5e++9lxtvvJGXX36ZnTt3pnp3HHXv3p38/Hw0TUv1rnSKBDyiy9nFTdFvhEAAO3E52Kwwsmx93oxPEh9cRARaFfPysJT90g+NQIW+j9pfF6YdCSG6TrIHo48cOcLGjRu54YYbGD9+PPfff3/4vtA00nPPPccFF1zA6aefztixY3n33XfD27z33nt873vfY+DAgfTq1YtRo0bx7LPPtvn7rr/+esaPHx91W0tLC/n5+dx7771MnTqVF198kTVr1qBpGpqm0dDQ4Dil9corrzBu3DhOP/10zjzzTMrLyzlw4AAATz31FN/4xjc444wzOOussxg/fjzvvfde1/zROkECHtHlHIqb7N58qs6xWeGKqt4UFERMI3X1p0xEP506iuOqyCw8aLGJ1tJLUIis1u40d4I8/PDDnHvuuZx77rlce+213HfffSilorb52c9+xsqVK3nttdfIycnh+uuvD993+PBhLr/8cp599lneeOMNysvLufLKK9scKZo2bRpPPfUUe/bsCd/25JNPcvjwYa6++mrWrFlDSUkJ06dPZ8+ePezZs4ehQ+PzMbdv384ll1zCl770JWpqanj55Ze58sorCQTsz9UjR44we/Zsamtree6559B1nf/4j//Ailx1ORmUUEop1dzcrADV3Nyc6l3JCOvWKeXxKAX2v+vWKaWamtTzWpkC5fjl8SjVtOwhpXRdKVBN2lD1/NwnVFNTO7+oqUk1PfyKev7hfW1v9/zz4V/SxBCl0xL9ezmuljFPeTxW9P4KIVzl008/VW+//bb69NNPT+lxmprCH0PRn0/tfRZ1gbFjx6q77rpLKaXU8ePHVb9+/dQzzzyjlFLK7/crQD377LPh7Z944gkFtHu8X/ziF9Wvf/3r8PeFhYVq9erVUfcvXbo0/P33v/99NXXq1PD348aNU7NmzYp6zNC+HDhwQCml1OTJk9XXv/71Dh/nvn37FKDefPNNpZRSO3bsUIB644032vyZ9p7bjp6/ZYRHJIRjcZNhUFxxcVzZekggAPUL1oJl4eN6CtUOylZcTmGBYt48hwEfnw9fwR0UThxt5+MUWKz4+cH4waGIISfHjsnaDcxbdy4NDZoUYwkhYnuOAomf5n733Xd59dVXmTRpEgA5OTlMnDiRe++9N2q7888/P/z/QYPs9fv27dsH2CMp8+fP54tf/CJnnHEGvXr14p133mk3F2jatGncd9994cd54oknokaNOiI0wtOW9957jx/96EecffbZ9OnTh+HDhwMkPUdJFg8VCWMY8YVNxs+nUl1VSSX3EIh5+Xl0RZH1v5gMiZ72UhorVsDKlbB2bTAYMU3M6XdQoXZEbKcz71d58Cs7vqmubg20qK62M5EDAbyeByhf/C3qh32LIuoxSm4Dw8BACrGEEK3XSJFBT6KnuX0+Hy0tLQwZMiR8m1KKbt26hXNhALp16xb+fyhpODQ1NG/ePDZt2sSKFSsoKiqiZ8+eXHXVVRw7dqzN3/vjH/+YhQsXUlNTQ01NDcOGDeOb3/xmp/a9Z8+e7d5/5ZVXMnToUNauXcvgwYOxLIsRI0a0u1+JICM8IrmCZesN+jnMZRl6aKTFA1VLD2DoexzzbMAeWA5XT9XVUafOcdgu9AEQU2kVM+RkzJtM6YT+GBNKJMoRQkRJds/RlpYWfve737Fy5Uq2b98e/vr73/9OYWEhf/jDHzr0OC+99BJTp07lP/7jPzjvvPPIz8+noaGh3Z8566yz+P73v899993Hfffdx//3//1/Ufd37949nIvTlvPPP5/nnnvO8b6PPvqIf/3rX/z85z/nkksu4Qtf+EJUAJdMMsIjks/rxSgvZ3l9PbNy91N/ZBBFRWAYfeHMaoqn34GuAo5BT2hY2Sguplh7r83torYNfUg5DTkJIYQDrxfKy+3PEPvzKXG/6/HHH+fAgQN4vd643jZXXXUVPp+P1atXn/BxioqK+NOf/sSVV16Jpmn853/+Z4cSg6dNm8b48eMJBAJcd911UfcNGzaMrVu30tDQQK9evejbt2/czy9atIjzzjuPn/zkJ8yYMYPu3bvj9/uZMGECffv25ayzzqK6uppBgwaxc+dOFi5ceMJ9SgQZ4RGpEWzgY4waFN3Hx+vF2PpoVLfmSOFhZcPAWHsb1dqMiO2U87ZCCHESktVz1Ofz8a1vfcuxkd8Pf/hDtm/fzuuvv37Cx1m9ejVnnnkmY8eO5corr6S8vJyvfe1rJ/y5b33rWwwaNIjy8nIGDx4cdd/cuXPxeDx88YtfpH///o55N5/73Od4+umn+fvf/86FF15ISUkJ//M//0NOTg66rrNhwwa2bdvGiBEjuOWWW1i+fPkJ9ykRNKViat6y1KFDh8jLy6O5uZk+ffqkeneEz4dZ8QvWWD9lFbOxyAkPK0clFJsm5i/vp776eWrV11jEEgJtbSuEyGifffYZO3bsYPjw4Zx22mmp3h3X+Pe//83gwYO59957+cEPfpDq3XHU3nPb0fO3BDxBEvCkIdOE+nrM3HMjpr26YFshREaSgKdzLMti7969rFy5kj/+8Y+899575OSkZ6ZLVwQ86XlkQkA458YAThi7dGZbIYQQ7Ny5k+HDh2MYBvfff3/aBjtdJbOPTgghhBCOhg0bFtfJOZNJ0rIQQgghMp4EPEIIIYTIeBLwCCGEyChJX5RSJFxXPKeSwyOEECIjdO/eHV3X2b17N/3796d79+7h5ReEOymlOHbsGPv370fXdbp3737SjyUBjxBCiIyg6zrDhw9nz5497N69O9W7I7rQ6aefTkFBAbp+8hNTEvAIIYTIGN27d6egoICWlpYTrgEl3MHj8ZCTk3PKo3US8AghhMgomqbRrVu3qJXFhZCkZSGEEEJkPAl4hBBCCJHxJOARQgghRMaTHJ6gUHvtQ4cOpXhPhBBCCNFRofP2iZbJkIAn6JNPPgFg6NChKd4TIYQQQnTWJ598Ql5eXpv3ayqbVg5rh2VZ7N69m969e3dpo6pDhw4xdOhQmpqa2l223q3k+NxNjs/d5PjcTY6vayil+OSTTxg8eHC7fXpkhCdI13UMw0jY4/fp0ycjX9AhcnzuJsfnbnJ87ibHd+raG9kJkaRlIYQQQmQ8CXiEEEIIkfEk4EmwHj16cNttt9GjR49U70pCyPG5mxyfu8nxuZscX3JJ0rIQQgghMp6M8AghhBAi40nAI4QQQoiMJwGPEEIIITKeBDxCCCGEyHgS8CTYb3/7W4YPH85pp53GyJEjeemll1K9S1EWL17MqFGj6N27NwMGDOD73/8+7777btQ2U6dORdO0qK8xY8ZEbXP06FFuvPFG+vXrR25uLt/97ncxTTNqmwMHDjBlyhTy8vLIy8tjypQpHDx4MKHHd/vtt8fte35+fvh+pRS33347gwcPpmfPnpSWlvLPf/7TFccWMmzYsLhj1DSNn/70p4D7nr+//e1vXHnllQwePBhN0/jzn/8cdX8yn7OdO3dy5ZVXkpubS79+/bjppps4duxYwo7v+PHjLFiwgPPOO4/c3FwGDx7Mj3/8Y3bv3h31GKWlpXHP6aRJk9L++CC5r8dUHJ/Te1HTNJYvXx7eJl2fv46cD1z9/lMiYTZs2KC6deum1q5dq95++201a9YslZubqxobG1O9a2Hl5eXqvvvuU2+99Zbavn27uuKKK1RBQYE6fPhweJvrrrtOXXbZZWrPnj3hr48++ijqcWbMmKGGDBminnnmGfX666+riy++WH35y19WLS0t4W0uu+wyNWLECLV582a1efNmNWLECDV+/PiEHt9tt92mvvSlL0Xt+759+8L3L1myRPXu3Vs9+uij6s0331QTJ05UgwYNUocOHUr7YwvZt29f1PE988wzClB+v18p5b7n78knn1Q/+9nP1KOPPqoA9dhjj0Xdn6znrKWlRY0YMUJdfPHF6vXXX1fPPPOMGjx4sJo5c2bCju/gwYPqW9/6lnr44YfVO++8o2pqatTo0aPVyJEjox5j3Lhxavr06VHP6cGDB6O2ScfjUyp5r8dUHV/kce3Zs0fde++9StM09d5774W3SdfnryPnAze//yTgSaALL7xQzZgxI+q2z3/+82rhwoUp2qMT27dvnwLUiy++GL7tuuuuU9/73vfa/JmDBw+qbt26qQ0bNoRv27Vrl9J1XT311FNKKaXefvttBagtW7aEt6mpqVGAeuedd7r+QIJuu+029eUvf9nxPsuyVH5+vlqyZEn4ts8++0zl5eWpe+65RymV3sfWllmzZqlzzjlHWZallHL38xd7Qknmc/bkk08qXdfVrl27wtusX79e9ejRQzU3Nyfk+Jy8+uqrCoi6UBo3bpyaNWtWmz+TzseXrNdjujx/3/ve91RZWVnUbW55/mLPB25//8mUVoIcO3aMbdu2cemll0bdfumll7J58+YU7dWJNTc3A9C3b9+o21944QUGDBjA5z73OaZPn86+ffvC923bto3jx49HHevgwYMZMWJE+FhramrIy8tj9OjR4W3GjBlDXl5ewv8edXV1DB48mOHDhzNp0iTef/99AHbs2MHevXuj9rtHjx6MGzcuvE/pfmyxjh07xoMPPsj1118ftQium5+/SMl8zmpqahgxYgSDBw8Ob1NeXs7Ro0fZtm1bQo8zUnNzM5qmccYZZ0Td/oc//IF+/frxpS99iblz5/LJJ5+E70v340vG6zEdnr8PPviAJ554Aq/XG3efG56/2POB299/snhognz44YcEAgEGDhwYdfvAgQPZu3dvivaqfUopZs+ezTe+8Q1GjBgRvv073/kOEyZMoLCwkB07dvCf//mflJWVsW3bNnr06MHevXvp3r07Z555ZtTjRR7r3r17GTBgQNzvHDBgQEL/HqNHj+Z3v/sdn/vc5/jggw/45S9/ydixY/nnP/8Z/r1Oz1FjY2N4v9P12Jz8+c9/5uDBg0ydOjV8m5ufv1jJfM727t0b93vOPPNMunfvnrRj/uyzz1i4cCE/+tGPohZfvOaaaxg+fDj5+fm89dZbLFq0iL///e8888wz4X1P1+NL1usxHZ6/Bx54gN69e/ODH/wg6nY3PH9O5wO3v/8k4EmwyKtssF9Esbeli5kzZ/KPf/yDl19+Oer2iRMnhv8/YsQILrjgAgoLC3niiSfi3siRYo/V6bgT/ff4zne+E/7/eeedR0lJCeeccw4PPPBAOFHyZJ6jdDg2Jz6fj+985ztRV0Vufv7akqznLJXHfPz4cSZNmoRlWfz2t7+Num/69Onh/48YMYLi4mIuuOACXn/9db72ta8B6Xt8yXw9pvo1e++993LNNddw2mmnRd3uhuevrfOB0+91y/tPprQSpF+/fng8nrhIdN++fXFRazq48cYb+ctf/oLf78cwjHa3HTRoEIWFhdTV1QGQn5/PsWPHOHDgQNR2kcean5/PBx98EPdY+/fvT+rfIzc3l/POO4+6urpwtVZ7z5Gbjq2xsZFnn32WadOmtbudm5+/ZD5n+fn5cb/nwIEDHD9+POHHfPz4ca6++mp27NjBM888EzW64+RrX/sa3bp1i3pO0/n4IiXq9Zjq43vppZd49913T/h+hPR7/to6H7j+/XdSmT+iQy688EJ1ww03RN32hS98Ia2Sli3LUj/96U/V4MGD1f/+7/926Gc+/PBD1aNHD/XAAw8opVqT1B5++OHwNrt373ZMUtu6dWt4my1btiQ9sfezzz5TQ4YMUXfccUc4AW/p0qXh+48ePeqYgOeGY7vttttUfn6+On78eLvbuen5o42k5WQ8Z6Gkyd27d4e32bBhQ8KTXo8dO6a+//3vqy996UtRFYXtefPNN6OSS9P5+GIl6vWY6uO77rrr4qrr2pIuz9+Jzgduf/9JwJNAobJ0n8+n3n77bXXzzTer3Nxc1dDQkOpdC7vhhhtUXl6eeuGFF6JKJP/9738rpZT65JNP1Jw5c9TmzZvVjh07lN/vVyUlJWrIkCFxZYiGYahnn31Wvf7666qsrMyxDPH8889XNTU1qqamRp133nkJL92eM2eOeuGFF9T777+vtmzZosaPH6969+4dfg6WLFmi8vLy1J/+9Cf15ptvqsmTJzuWWKbjsUUKBAKqoKBALViwIOp2Nz5/n3zyiXrjjTfUG2+8oQC1atUq9cYbb4SrlJL1nIXKYi+55BL1+uuvq2effVYZhnHKZc3tHd/x48fVd7/7XWUYhtq+fXvUe/Lo0aNKKaXq6+vVHXfcoWpra9WOHTvUE088oT7/+c+rr371q2l/fMl8Pabi+EKam5vV6aefru6+++64n0/n5+9E5wOl3P3+k4Anwf77v/9bFRYWqu7du6uvfe1rUeXe6QBw/LrvvvuUUkr9+9//Vpdeeqnq37+/6tatmyooKFDXXXed2rlzZ9TjfPrpp2rmzJmqb9++qmfPnmr8+PFx23z00UfqmmuuUb1791a9e/dW11xzjTpw4EBCjy/UI6Jbt25q8ODB6gc/+IH65z//Gb7fsqzwyEiPHj3URRddpN58801XHFukTZs2KUC9++67Ube78fnz+/2Or8nrrrtOKZXc56yxsVFdccUVqmfPnqpv375q5syZ6rPPPkvY8e3YsaPN92Sor9LOnTvVRRddpPr27au6d++uzjnnHHXTTTfF9bJJx+NL9usx2ccXUlVVpXr27BnXW0ep9H7+TnQ+UMrd7z8teJBCCCGEEBlLkpaFEEIIkfEk4BFCCCFExpOARwghhBAZTwIeIYQQQmQ8CXiEEEIIkfEk4BFCCCFExpOARwghhBAZTwIeIYQQQmQ8CXiEEEIIkfEk4BFCCCFExpOARwghhBAZTwIeIYQQQmS8/x8geYcXclsVQwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.plot(psetRK4.lon, psetRK4.lat, \"r.\", label=\"RK4\")\n", "plt.plot(psetAA.lon, psetAA.lat, \"b.\", label=\"Analytical\")\n", @@ -28046,7 +611,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "parcels-dev", "language": "python", "name": "python3" }, @@ -28060,7 +625,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.10.15" } }, "nbformat": 4, diff --git a/docs/examples/tutorial_croco_3D.ipynb b/docs/examples/tutorial_croco_3D.ipynb index df621724e..0bd0a9e59 100644 --- a/docs/examples/tutorial_croco_3D.ipynb +++ b/docs/examples/tutorial_croco_3D.ipynb @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -74,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -112,18 +112,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in croco_particles3D.zarr.\n", - "100%|██████████| 50000.0/50000.0 [00:00<00:00, 131009.03it/s]\n" - ] - } - ], + "outputs": [], "source": [ "X, Z = np.meshgrid(\n", " [40e3, 80e3, 120e3],\n", @@ -138,7 +129,7 @@ "\n", "\n", "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=X, lat=Y, depth=Z\n", + " fieldset=fieldset, pclass=parcels.Particle, lon=X, lat=Y, depth=Z\n", ")\n", "\n", "outputfile = pset.ParticleFile(name=\"croco_particles3D.zarr\", outputdt=5000)\n", @@ -160,24 +151,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "tags": [ "nbsphinx-thumbnail" ] }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots(1, 1, figsize=(6, 4))\n", "ds = xr.open_zarr(\"croco_particles3D.zarr\")\n", @@ -211,28 +191,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in croco_particles_noW.zarr.\n", - "100%|██████████| 50000.0/50000.0 [00:00<00:00, 132723.16it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import copy\n", "\n", @@ -240,7 +201,7 @@ "fieldset_noW.W.data[:] = 0.0\n", "\n", "pset_noW = parcels.ParticleSet(\n", - " fieldset=fieldset_noW, pclass=parcels.JITParticle, lon=X, lat=Y, depth=Z\n", + " fieldset=fieldset_noW, pclass=parcels.Particle, lon=X, lat=Y, depth=Z\n", ")\n", "\n", "outputfile = pset.ParticleFile(name=\"croco_particles_noW.zarr\", outputdt=5000)\n", diff --git a/docs/examples/tutorial_delaystart.ipynb b/docs/examples/tutorial_delaystart.ipynb index 456581501..ca460bb1a 100644 --- a/docs/examples/tutorial_delaystart.ipynb +++ b/docs/examples/tutorial_delaystart.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -45,13 +45,19 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "example_dataset_folder = parcels.download_example_dataset(\"Peninsula_data\")\n", - "fieldset = parcels.FieldSet.from_parcels(\n", - " f\"{example_dataset_folder}/peninsula\", allow_time_extrapolation=True\n", + "filenames = {\n", + " \"U\": str(example_dataset_folder / \"peninsulaU.nc\"),\n", + " \"V\": str(example_dataset_folder / \"peninsulaV.nc\"),\n", + "}\n", + "variables = {\"U\": \"vozocrtx\", \"V\": \"vomecrty\"}\n", + "dimensions = {\"lon\": \"nav_lon\", \"lat\": \"nav_lat\", \"time\": \"time_counter\"}\n", + "fieldset = parcels.FieldSet.from_netcdf(\n", + " filenames, variables, dimensions, allow_time_extrapolation=True\n", ")" ] }, @@ -81,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -93,7 +99,7 @@ "time = np.arange(0, npart) * timedelta(hours=1).total_seconds()\n", "\n", "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=lon, lat=lat, time=time\n", + " fieldset=fieldset, pclass=parcels.Particle, lon=lon, lat=lat, time=time\n", ")" ] }, @@ -107,18 +113,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in DelayParticle_time.zarr.\n", - "100%|██████████| 86400.0/86400.0 [00:02<00:00, 35968.90it/s]\n" - ] - } - ], + "outputs": [], "source": [ "output_file = pset.ParticleFile(\n", " name=\"DelayParticle_time.zarr\", outputdt=timedelta(hours=1)\n", @@ -142,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -182,9840 +179,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "HTML(anim.to_jshtml())" ] @@ -10038,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -10048,7 +214,7 @@ "repeatdt = timedelta(hours=3) # release from the same set of locations every 3h\n", "\n", "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=lon, lat=lat, repeatdt=repeatdt\n", + " fieldset=fieldset, pclass=parcels.Particle, lon=lon, lat=lat, repeatdt=repeatdt\n", ")" ] }, @@ -10062,19 +228,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in DelayParticle_releasedt.zarr.\n", - " 0%| | 0/86400.0 [00:00\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "HTML(anim.to_jshtml())" ] @@ -21246,24 +311,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in DelayParticle_releasedt_9hrs.zarr.\n", - " 0%| | 0/32400.0 [00:00\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "HTML(anim.to_jshtml())" ] @@ -32211,26 +398,16 @@ "source": [ "## Synced `time` in the output file\n", "\n", - "Note that, because the `outputdt` variable controls the JIT-loop, all particles are written _at the same time_, even when they start at a non-multiple of `outputdt`.\n", + "Note that, because the `outputdt` variable controls the Kernel-loop, all particles are written _at the same time_, even when they start at a non-multiple of `outputdt`.\n", "\n", "For example, if your particles start at `time=[0, 1, 2]` and `outputdt=2`, then the times written (for `dt=1` and `endtime=4`) will be\n" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[ 0 2 4]\n", - " [ 2 4 'NaT']\n", - " [ 2 4 'NaT']]\n" - ] - } - ], + "outputs": [], "source": [ "outtime_expected = np.array(\n", " [[0, 2, 4], [2, 4, np.datetime64(\"NaT\")], [2, 4, np.datetime64(\"NaT\")]],\n", @@ -32241,24 +418,15 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in DelayParticle_nonmatchingtime.zarr.\n", - "100%|██████████| 4.0/4.0 [00:00<00:00, 57.38it/s]\n" - ] - } - ], + "outputs": [], "source": [ "outfilepath = \"DelayParticle_nonmatchingtime.zarr\"\n", "\n", "pset = parcels.ParticleSet(\n", " fieldset=fieldset,\n", - " pclass=parcels.JITParticle,\n", + " pclass=parcels.Particle,\n", " lat=[3e3] * 3,\n", " lon=[3e3] * 3,\n", " time=[0, 1, 2],\n", @@ -32286,19 +454,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[ 0 2 4]\n", - " [ 2 4 'NaT']\n", - " [ 2 4 'NaT']]\n" - ] - } - ], + "outputs": [], "source": [ "outtime_infile = xr.open_zarr(outfilepath).time.values[:]\n", "print(outtime_infile.astype(\"timedelta64[s]\"))\n", @@ -32319,28 +477,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in DelayParticle_nonmatchingtime.zarr.\n", - "100%|██████████| 4.0/4.0 [00:00<00:00, 65.51it/s]\n", - "[[ 0 2 4]\n", - " [ 2 4 'NaT']]\n", - "INFO: Output files are stored in DelayParticle_nonmatchingtime.zarr.\n", - "100%|██████████| 3.0/3.0 [00:00<00:00, 95.96it/s]\n", - "[[1 3 4]]\n" - ] - } - ], + "outputs": [], "source": [ "for times in [[0, 2], [1]]:\n", " pset = parcels.ParticleSet(\n", " fieldset=fieldset,\n", - " pclass=parcels.JITParticle,\n", + " pclass=parcels.Particle,\n", " lat=[3e3] * len(times),\n", " lon=[3e3] * len(times),\n", " time=times,\n", @@ -32379,58 +523,11 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n", - "INFO: Output files are stored in growingparticles.zarr.\n" - ] - } - ], + "outputs": [], "source": [ - "GrowingParticle = parcels.JITParticle.add_variables(\n", + "GrowingParticle = parcels.Particle.add_variables(\n", " [\n", " parcels.Variable(\"mass\", initial=0),\n", " parcels.Variable(\"splittime\", initial=-1),\n", @@ -32440,8 +537,10 @@ "\n", "\n", "def GrowParticles(particle, fieldset, time):\n", + " import random\n", + "\n", " # 25% chance per timestep for particle to grow\n", - " if ParcelsRandom.random() < 0.25:\n", + " if random.random() < 0.25:\n", " particle.mass += 1.0\n", " if (particle.mass >= 5.0) and (particle.splittime < 0):\n", " particle.splittime = time\n", @@ -32476,27 +575,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The 'trick' is that we place the `pset.execute()` call in a for-loop, so that we leave the JIT-mode and can add Particles to the ParticleSet.\n", + "The 'trick' is that we place the `pset.execute()` call in a for-loop, so that we leave the Kernel-loop and can add Particles to the ParticleSet.\n", "\n", "Indeed, if we plot the mass of particles as a function of time, we see that new particles are created every time a particle reaches a mass of 5.\n" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds = xr.open_zarr(\"growingparticles.zarr\")\n", "plt.plot(ds.time.values[:].astype(\"timedelta64[s]\").T, ds.mass.T)\n", @@ -32509,7 +597,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "parcels", "language": "python", "name": "python3" }, @@ -32523,7 +611,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/docs/examples/tutorial_diffusion.ipynb b/docs/examples/tutorial_diffusion.ipynb index a14dd466d..273b141d9 100644 --- a/docs/examples/tutorial_diffusion.ipynb +++ b/docs/examples/tutorial_diffusion.ipynb @@ -106,10 +106,11 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ + "import random\n", "from datetime import timedelta\n", "\n", "import matplotlib.pyplot as plt\n", @@ -117,12 +118,14 @@ "import trajan as ta\n", "import xarray as xr\n", "\n", - "import parcels" + "import parcels\n", + "from parcels.grid import GridType\n", + "from parcels.tools.converters import Geographic, GeographicPolar, UnitConverter" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -162,20 +165,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.plot(Kh_meridional, y)\n", "plt.ylabel(\"y\")\n", @@ -195,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -223,14 +215,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def get_test_particles():\n", " return parcels.ParticleSet.from_list(\n", " fieldset,\n", - " pclass=parcels.JITParticle,\n", + " pclass=parcels.Particle,\n", " lon=np.zeros(100),\n", " lat=np.ones(100) * 0.75,\n", " time=np.zeros(100),\n", @@ -248,19 +240,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Compiled ParcelsRandom ==> /var/folders/1n/500ln6w97859_nqq86vwpl000000gr/T/parcels-504/parcels_random_4217ba4c-0bce-4de3-8bfc-a59aaf457cca.c\n", - "INFO: Output files are stored in M1_out.zarr.\n", - "100%|██████████| 0.3/0.3 [00:01<00:00, 5.11s/it] \n" - ] - } - ], + "outputs": [], "source": [ "dt = 0.001\n", "testParticles = get_test_particles()\n", @@ -268,8 +250,6 @@ " name=\"M1_out.zarr\", chunks=(len(testParticles), 50), outputdt=timedelta(seconds=dt)\n", ")\n", "\n", - "parcels.ParcelsRandom.seed(1636) # Random seed for reproducibility\n", - "\n", "testParticles.execute(\n", " parcels.AdvectionDiffusionM1,\n", " runtime=timedelta(seconds=0.3),\n", @@ -280,7 +260,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -297,20 +277,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots(1, 2)\n", "fig.set_figwidth(12)\n", @@ -345,25 +314,16 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in EM_out.zarr.\n", - "100%|██████████| 0.3/0.3 [00:01<00:00, 5.10s/it] \n" - ] - } - ], + "outputs": [], "source": [ "dt = 0.001\n", "testParticles = get_test_particles()\n", "output_file = testParticles.ParticleFile(\n", " name=\"EM_out.zarr\", chunks=(len(testParticles), 50), outputdt=timedelta(seconds=dt)\n", ")\n", - "parcels.ParcelsRandom.seed(1636) # Random seed for reproducibility\n", + "random.seed(1636) # Random seed for reproducibility\n", "testParticles.execute(\n", " parcels.AdvectionDiffusionEM,\n", " runtime=timedelta(seconds=0.3),\n", @@ -374,7 +334,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -383,20 +343,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots(1, 2)\n", "fig.set_figwidth(12)\n", @@ -449,7 +398,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -472,12 +421,8 @@ " A = A / sq_deg_to_sq_m\n", " Kh = fieldset.Cs * A * math.sqrt(dudx**2 + 0.5 * (dudy + dvdx) ** 2 + dvdy**2)\n", "\n", - " dlat = parcels.ParcelsRandom.normalvariate(0.0, 1.0) * math.sqrt(\n", - " 2 * math.fabs(particle.dt) * Kh\n", - " )\n", - " dlon = parcels.ParcelsRandom.normalvariate(0.0, 1.0) * math.sqrt(\n", - " 2 * math.fabs(particle.dt) * Kh\n", - " )\n", + " dlat = random.normalvariate(0.0, 1.0) * math.sqrt(2 * math.fabs(particle.dt) * Kh)\n", + " dlon = random.normalvariate(0.0, 1.0) * math.sqrt(2 * math.fabs(particle.dt) * Kh)\n", "\n", " particle_dlat += dlat\n", " particle_dlon += dlon" @@ -493,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -521,15 +466,47 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = fieldset.U.grid.lon\n", "y = fieldset.U.grid.lat\n", "\n", + "\n", + "def calc_cell_edge_sizes(grid):\n", + " \"\"\"Calculate cell sizes based on numpy.gradient method.\n", + "\n", + " Currently only works for Rectilinear Grids. Operates in place adding a `cell_edge_sizes`\n", + " attribute to the grid.\n", + " \"\"\"\n", + " assert grid._gtype in (GridType.RectilinearZGrid, GridType.RectilinearSGrid), (\n", + " f\"_cell_edge_sizes() not implemented for {grid._gtype} grids. \"\n", + " \"You can provide cell_edge_sizes yourself by in, e.g., \"\n", + " \"NEMO using the e1u fields etc from the mesh_mask.nc file.\"\n", + " )\n", + "\n", + " cell_edge_sizes_x = np.zeros((grid.ydim, grid.xdim), dtype=np.float32)\n", + " cell_edge_sizes_y = np.zeros((grid.ydim, grid.xdim), dtype=np.float32)\n", + "\n", + " x_conv = GeographicPolar() if grid.mesh == \"spherical\" else UnitConverter()\n", + " y_conv = Geographic() if grid.mesh == \"spherical\" else UnitConverter()\n", + " for y, (lat, dy) in enumerate(zip(grid.lat, np.gradient(grid.lat), strict=False)):\n", + " for x, (lon, dx) in enumerate(\n", + " zip(grid.lon, np.gradient(grid.lon), strict=False)\n", + " ):\n", + " cell_edge_sizes_x[y, x] = x_conv.to_source(dx, grid.depth[0], lat, lon)\n", + " cell_edge_sizes_y[y, x] = y_conv.to_source(dy, grid.depth[0], lat, lon)\n", + " return cell_edge_sizes_x, cell_edge_sizes_y\n", + "\n", + "\n", + "def calc_cell_areas(grid):\n", + " cell_edge_sizes_x, cell_edge_sizes_y = calc_cell_edge_sizes(grid)\n", + " return cell_edge_sizes_x * cell_edge_sizes_y\n", + "\n", + "\n", "cell_areas = parcels.Field(\n", - " name=\"cell_areas\", data=fieldset.U.cell_areas(), lon=x, lat=y\n", + " name=\"cell_areas\", data=calc_cell_areas(fieldset.U.grid), lon=x, lat=y\n", ")\n", "fieldset.add_field(cell_areas)\n", "\n", @@ -546,7 +523,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -554,7 +531,7 @@ "lon = [29] * len(time)\n", "lat = [-33] * len(time)\n", "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=lon, lat=lat, time=time\n", + " fieldset=fieldset, pclass=parcels.Particle, lon=lon, lat=lat, time=time\n", ")" ] }, @@ -568,18 +545,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in Global_smagdiff.zarr.\n", - "100%|██████████| 604800.0/604800.0 [00:02<00:00, 222140.27it/s]\n" - ] - } - ], + "outputs": [], "source": [ "def DeleteParticle(particle, fieldset, time):\n", " if particle.state == parcels.StatusCode.ErrorOutOfBounds:\n", @@ -590,7 +558,7 @@ " name=\"Global_smagdiff.zarr\", outputdt=timedelta(hours=3), chunks=(1, 57)\n", ")\n", "\n", - "parcels.ParcelsRandom.seed(1636) # Random seed for reproducibility\n", + "random.seed(1636) # Random seed for reproducibility\n", "\n", "pset.execute(\n", " [parcels.AdvectionRK4, smagdiff, DeleteParticle],\n", @@ -610,20 +578,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds = xr.open_zarr(\"Global_smagdiff.zarr\")\n", "\n", @@ -657,7 +614,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "parcels-dev", "language": "python", "name": "python3" }, @@ -671,7 +628,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.10.15" } }, "nbformat": 4, diff --git a/docs/examples/tutorial_interaction.ipynb b/docs/examples/tutorial_interaction.ipynb index 8ceee2d6a..d5934c268 100644 --- a/docs/examples/tutorial_interaction.ipynb +++ b/docs/examples/tutorial_interaction.ipynb @@ -3,7 +3,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "6ad92baa", + "id": "0", "metadata": {}, "source": [ "# Particle-Particle interaction\n" @@ -12,7 +12,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "fe5d7b1c", + "id": "1", "metadata": {}, "source": [ "In this notebook, we show an example of the new 'particle-particle-interaction' functionality in Parcels. Note that this functionality is still in development, and the implementation is fairly rudimentary and slow for now. Importantly:\n", @@ -39,7 +39,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "66b91c29", + "id": "2", "metadata": {}, "source": [ "## Pulling particles\n", @@ -49,8 +49,8 @@ }, { "cell_type": "code", - "execution_count": 1, - "id": "da408a23", + "execution_count": null, + "id": "3", "metadata": {}, "outputs": [], "source": [ @@ -66,8 +66,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "9485e2e9", + "execution_count": null, + "id": "4", "metadata": {}, "outputs": [], "source": [ @@ -115,21 +115,10 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "451638ae", + "execution_count": null, + "id": "5", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in InteractingParticles.zarr.\n", - " 0%| | 0/60.0 [00:00 /var/folders/1n/500ln6w97859_nqq86vwpl000000gr/T/parcels-504/parcels_random_fec11e5e-713b-43cc-b561-8d45de86d6f2.c\n", - "WARNING: Some InteractionKernel was not completed succesfully, likely because a Particle threw an error that was not captured.\n", - "100%|██████████| 60.0/60.0 [00:02<00:00, 28.27it/s]\n" - ] - } - ], + "outputs": [], "source": [ "npart = 11\n", "\n", @@ -145,7 +134,7 @@ "\n", "# Create custom particle class with extra variable that indicates\n", "# whether the interaction kernel should be executed on this particle.\n", - "InteractingParticle = parcels.ScipyParticle.add_variable(\n", + "InteractingParticle = parcels.Particle.add_variable(\n", " \"attractor\", dtype=np.bool_, to_write=\"once\"\n", ")\n", "\n", @@ -176,8 +165,8 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "36c8f905", + "execution_count": null, + "id": "6", "metadata": {}, "outputs": [], "source": [ @@ -271,30521 +260,10 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "cc7ced7f", + "execution_count": null, + "id": "7", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "HTML(anim.to_jshtml())" ] @@ -30793,7 +271,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "60e8c799", + "id": "8", "metadata": {}, "source": [ "## Merging particles\n", @@ -30805,19 +283,10 @@ }, { "cell_type": "code", - "execution_count": 6, - "id": "62d34645", + "execution_count": null, + "id": "9", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in MergingParticles.zarr.\n", - "100%|██████████| 60.0/60.0 [00:04<00:00, 12.63it/s]\n" - ] - } - ], + "outputs": [], "source": [ "npart = 800\n", "\n", @@ -30834,7 +303,7 @@ "\n", "# Create custom InteractionParticle class\n", "# with extra variables nearest_neighbor and mass\n", - "MergeParticle = parcels.ScipyInteractionParticle.add_variables(\n", + "MergeParticle = parcels.InteractionParticle.add_variables(\n", " [\n", " parcels.Variable(\"nearest_neighbor\", dtype=np.int64, to_write=False),\n", " parcels.Variable(\"mass\", initial=1, dtype=np.float32),\n", @@ -30863,8 +332,8 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "f3f9a0d9", + "execution_count": null, + "id": "10", "metadata": {}, "outputs": [], "source": [ @@ -30920,30912 +389,10 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "004014a8", + "execution_count": null, + "id": "11", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "HTML(anim.to_jshtml())" ] @@ -61833,7 +400,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "cbaf5190", + "id": "12", "metadata": {}, "source": [ "## Interacting with the FieldSet\n", diff --git a/docs/examples/tutorial_interpolation.ipynb b/docs/examples/tutorial_interpolation.ipynb index e41e5b064..73fcb2cd7 100644 --- a/docs/examples/tutorial_interpolation.ipynb +++ b/docs/examples/tutorial_interpolation.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -70,11 +70,11 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "SampleParticle = parcels.JITParticle.add_variable(\"p\", dtype=np.float32)\n", + "SampleParticle = parcels.Particle.add_variable(\"p\", dtype=np.float32)\n", "\n", "\n", "def SampleP(particle, fieldset, time):\n", @@ -91,20 +91,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 1.0/1.0 [00:00<00:00, 639.38it/s]\n", - "100%|██████████| 1.0/1.0 [00:00<00:00, 663.66it/s]\n", - "100%|██████████| 1.0/1.0 [00:00<00:00, 832.70it/s]\n", - "100%|██████████| 1.0/1.0 [00:00<00:00, 532.47it/s]\n" - ] - } - ], + "outputs": [], "source": [ "pset = {}\n", "interp_methods = [\"linear\", \"linear_invdist_land_tracer\", \"nearest\", \"cgrid_tracer\"]\n", @@ -130,20 +119,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots(1, 4, figsize=(18, 5))\n", "for i, p in enumerate(pset.keys()):\n", @@ -180,20 +158,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.scatter(\n", " pset[\"linear\"].lon,\n", diff --git a/docs/examples/tutorial_jit_vs_scipy.ipynb b/docs/examples/tutorial_jit_vs_scipy.ipynb deleted file mode 100644 index 5db839c87..000000000 --- a/docs/examples/tutorial_jit_vs_scipy.ipynb +++ /dev/null @@ -1,314 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# JIT-vs-Scipy Particles" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This tutorial is meant to highlight the potentially very big difference between the computational time required to run Parcels in **JIT** (Just-In-Time compilation) versus in **Scipy** mode. It also discusses how to more efficiently sample in Scipy mode.\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Short summary: JIT is faster than scipy\n", - "\n", - "In the code snippet below, we use `AdvectionRK4` to advect 100 particles in the peninsula `FieldSet`. We first do it in JIT mode (by setting `ptype=JITParticle` in the declaration of `pset`) and then we also do it in Scipy mode (by setting `ptype=ScipyParticle` in the declaration of `pset`).\n", - "\n", - "In both cases, we advect the particles for 1 hour, with a timestep of 30 seconds.\n", - "\n", - "To measure the computational time, we use the `timer` module.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 3600.0/3600.0 [00:01<00:00, 1843.14it/s]\n", - "100%|██████████| 3600.0/3600.0 [00:00<00:00, 533400.25it/s]\n", - "(100%) Timer root : 3.165e+00 s\n", - "( 3%) ( 3%) Timer fieldset creation : 9.443e-02 s\n", - "( 65%) ( 65%) Timer scipy : 2.073e+00 s\n", - "( 32%) ( 32%) Timer jit : 9.969e-01 s\n" - ] - } - ], - "source": [ - "from datetime import timedelta\n", - "\n", - "import parcels\n", - "\n", - "parcels.timer.root = parcels.timer.Timer(\"root\")\n", - "\n", - "parcels.timer.fieldset = parcels.timer.Timer(\n", - " \"fieldset creation\", parent=parcels.timer.root\n", - ")\n", - "\n", - "example_dataset_folder = parcels.download_example_dataset(\"Peninsula_data\")\n", - "fieldset = parcels.FieldSet.from_parcels(\n", - " f\"{example_dataset_folder}/peninsula\", allow_time_extrapolation=True\n", - ")\n", - "parcels.timer.fieldset.stop()\n", - "\n", - "ptype = {\"scipy\": parcels.ScipyParticle, \"jit\": parcels.JITParticle}\n", - "ptimer = {\n", - " \"scipy\": parcels.timer.Timer(\"scipy\", parent=parcels.timer.root, start=False),\n", - " \"jit\": parcels.timer.Timer(\"jit\", parent=parcels.timer.root, start=False),\n", - "}\n", - "\n", - "for p in [\"scipy\", \"jit\"]:\n", - " pset = parcels.ParticleSet.from_line(\n", - " fieldset=fieldset,\n", - " pclass=ptype[p],\n", - " size=100,\n", - " start=(3e3, 3e3),\n", - " finish=(3e3, 45e3),\n", - " )\n", - "\n", - " ptimer[p].start()\n", - " pset.execute(\n", - " parcels.AdvectionRK4, runtime=timedelta(hours=1), dt=timedelta(seconds=30)\n", - " )\n", - " ptimer[p].stop()\n", - "\n", - "parcels.timer.root.stop()\n", - "parcels.timer.root.print_tree()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As you can see above, even in this very small example **Scipy mode took more than 2 times as long** (2.1 seconds versus 1.0 seconds) as the JIT mode. For larger examples, this can grow to hundreds of times slower.\n", - "\n", - "This is just an illustrative example, depending on the number of calls to `AdvectionRK4`, the size of the `FieldSet`, the size of the `pset`, the ratio between `dt` and `outputdt` in the `.execute` etc, the difference between JIT and Scipy can vary significantly. However, JIT will almost always be faster!\n", - "\n", - "So why does Parcels support both JIT and Scipy mode then? Because Scipy is easier to debug when writing custom kernels, so can provide faster development of new features.\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "_As an aside, you may wonder why we use the `time.time` module, and not the `timeit` module, to time the runs above. That's because it affects the AST of the kernels, causing errors in JIT mode._\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Further digging into Scipy mode: adding `particle` keyword to `Field`-sampling\n", - "\n", - "Sometimes, you'd want to run Parcels in Scipy mode anyways. In that case, there are ways to make Parcels a bit faster.\n", - "\n", - "As background, one of the most computationally expensive operations in Parcels is the [Field Sampling](https://docs.oceanparcels.org/en/latest/examples/tutorial_sampling.html). In the default sampling in Scipy mode, we don't keep track of _where_ in the grid a particle is; which means that for every sampling call, we need to again search for which grid cell a particle is in.\n", - "\n", - "Let's see how this works in the simple Peninsula FieldSet used above. We use a simple Euler-Forward Advection now to make the point. In particular, we use two types of Advection Kernels\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "def AdvectionEE_depth_lat_lon_time(particle, fieldset, time):\n", - " (u1, v1) = fieldset.UV[time, particle.depth, particle.lat, particle.lon]\n", - " particle.lon += u1 * particle.dt\n", - " particle.lat += v1 * particle.dt\n", - "\n", - "\n", - "def AdvectionEE_depth_lat_lon_time_particle(particle, fieldset, time):\n", - " (u1, v1) = fieldset.UV[\n", - " time,\n", - " particle.depth,\n", - " particle.lat,\n", - " particle.lon,\n", - " particle, # note the extra particle argument here\n", - " ]\n", - " particle.lon += u1 * particle.dt\n", - " particle.lat += v1 * particle.dt\n", - "\n", - "\n", - "kernels = {\n", - " \"dllt\": AdvectionEE_depth_lat_lon_time,\n", - " \"dllt_p\": AdvectionEE_depth_lat_lon_time_particle,\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 0%| | 0/3600.0 [00:00\n", - "\n", - "__Note__ that the variables `particle_dlon`, `particle_dlat`, and `particle_ddepth` are defined by the wrapper function that Parcels generates for each Kernel. This is why you don't have to define these variables yourself when writing a Kernel. See [here](https://github.com/OceanParcels/parcels/blob/daa4b062ed8ae0b2be3d87367d6b45599d6f95db/parcels/kernel.py#L277-L294) for the implementation of the wrapper functions.\n", - "" + "In order to make sure that the displacements of a particle in the different Kernels can be summed, all Kernels add to a _change_ in position (`particles.dlon`, `particles.dlat`, and `particles.ddepth`). This is important, because there are situations where movement kernels would otherwise not commute. Take the example of advecting particles by currents _and_ winds. If the particle would first be moved by the currents and then by the winds, the result could be different from first moving by the winds and then by the currents. Instead, by adding the changes in position, the ordering of the Kernels has no consequence on the particle displacement." ] }, { @@ -52,29 +42,25 @@ "source": [ "Below is a structured overview of the Kernel loop is implemented. Note that this is for longitude only, but the same process is applied for latitude and depth.\n", "\n", - "1. Define an extra variable `particle.lon_nextloop` for each particle, which is the longitude at the end of the Kernel loop. Inititalise it to `particle.lon`.\n", + "1. Initialise an extra Variable `particles.lon=0` and `particles.time_nextloop = particles.time`\n", "\n", - "2. Also define an extra variable `particle.time_nextloop` for each particle, which is the time at the end of the Kernel loop. Inititalise it to `particle.time`.\n", + "2. Within the Kernel loop, for each particle:
\n", "\n", - "3. Within the Kernel loop, for each particle:
\n", + " 1. Update `particles.lon += particles.dlon`
\n", "\n", - " 1. Update `particle.lon` with `particle.lon_nextloop`
\n", + " 2. Set variable `particles.dlon = 0`
\n", "\n", - " 2. Update `particle.time` with `particle.time_nextloop`
\n", - "\n", - " 3. Set local variable `particle_dlon = 0`
\n", + " 3. Update `particles.time = particles.time_nextloop`\n", "\n", " 4. For each Kernel in the list of Kernels:\n", " \n", " 1. Execute the Kernel\n", " \n", - " 2. Update `particle_dlon` by adding the change in longitude, if needed
\n", + " 2. Update `particles.dlon` by adding the change in longitude, if needed
\n", "\n", - " 5. Update `particle.lon_nextloop` with `particle.lon + particle_dlon`
\n", - " \n", - " 6. Update `particle.time_nextloop` with `particle.time + particle.dt`
\n", + " 5. Update `particles.time_nextloop += particles.dt`
\n", "\n", - " 7. If `outputdt` is a multiple of `particle.time`, write `particle.lon` and `particle.time` to zarr output file
\n", + " 6. If `outputdt` is a multiple of `particle.time`, write `particle.lon` and `particle.time` to zarr output file
\n", "\n", "Besides having commutable Kernels, the main advantage of this implementation is that, when using Field Sampling with e.g. `particle.temp = fieldset.Temp[particle.time, particle.depth, particle.lat, particle.lon]`, the particle location stays the same throughout the entire Kernel loop. Additionally, this implementation ensures that the particle location is the same as the location of the sampled field in the output file." ] @@ -95,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -118,14 +104,16 @@ " \"V\": \"northward_eulerian_current_velocity\",\n", "}\n", "dimensions = {\"lat\": \"lat\", \"lon\": \"lon\", \"time\": \"time\"}\n", - "fieldset = parcels.FieldSet.from_netcdf(filenames, variables, dimensions)\n", + "fieldset = parcels.FieldSet.from_netcdf(\n", + " filenames, variables, dimensions, allow_time_extrapolation=True\n", + ")\n", "# uppermost layer in the hydrodynamic data\n", "fieldset.mindepth = fieldset.U.depth[0]" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -137,11 +125,15 @@ " lon=fieldset.U.lon,\n", " lat=fieldset.U.lat,\n", " mesh=\"spherical\",\n", - " fieldtype=\"U\",\n", ")\n", "VWind = parcels.Field(\n", - " \"VWind\", np.zeros((ydim, xdim), dtype=np.float32), grid=UWind.grid, fieldtype=\"V\"\n", + " \"VWind\",\n", + " np.zeros((ydim, xdim), dtype=np.float32),\n", + " grid=UWind.grid,\n", ")\n", + "UWind.units = parcels.tools.converters.GeographicPolar()\n", + "VWind.units = parcels.tools.converters.Geographic()\n", + "\n", "fieldset_wind = parcels.FieldSet(UWind, VWind)\n", "\n", "fieldset.add_field(fieldset_wind.U, name=\"UWind\")\n", @@ -157,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -179,23 +171,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in advection_then_wind.zarr.\n", - "100%|██████████| 432000.0/432000.0 [00:00<00:00, 1059409.81it/s]\n" - ] - } - ], + "outputs": [], "source": [ "lons = 26.0 * np.ones(10)\n", "lats = np.linspace(-37.5, -34.5, 10)\n", "\n", - "pset = parcels.ParticleSet(fieldset, pclass=parcels.JITParticle, lon=lons, lat=lats)\n", + "pset = parcels.ParticleSet(fieldset, pclass=parcels.Particle, lon=lons, lat=lats)\n", "output_file = pset.ParticleFile(\n", " name=\"advection_then_wind.zarr\", outputdt=timedelta(hours=6)\n", ")\n", @@ -216,21 +199,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in wind_then_advection.zarr.\n", - "100%|██████████| 432000.0/432000.0 [00:00<00:00, 1317764.47it/s]\n" - ] - } - ], + "outputs": [], "source": [ "pset_reverse = parcels.ParticleSet(\n", - " fieldset, pclass=parcels.JITParticle, lon=lons, lat=lats\n", + " fieldset, pclass=parcels.Particle, lon=lons, lat=lats\n", ")\n", "output_file_reverse = pset_reverse.ParticleFile(\n", " name=\"wind_then_advection.zarr\", outputdt=timedelta(hours=6)\n", @@ -252,20 +226,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the resulting particle trajectories overlapped for both cases\n", "advection_then_wind = xr.open_zarr(\"advection_then_wind.zarr\")\n", @@ -291,12 +254,12 @@ "### 1. Avoid updating particle locations directly in Kernels\n", "It is better not to update `particle.lon` directly in a Kernel, as it can interfere with the loop above. Assigning a value to `particle.lon` in a Kernel will throw a warning. \n", "\n", - "Instead, update the local variable `particle_dlon`.\n", + "Instead, update the local variable `particle.dlon`.\n", "\n", "### 2. Be careful with updating particle variables that do not depend on Fields.\n", "While assigning the interpolated value of a `Field` to a Particle goes well in the loop above, this is not necessarily so for assigning other attributes. For example, a line like `particle.age += particle.dt` is executed directly so may result in the age being `dt` at `time = 0` in the output file. \n", "\n", - "A workaround is to either initialise the age to `-dt`, or to increase the `age` only when `particle.time > 0` (using an `if` statement).\n", + "A workaround is to either initialise the age to `-dt`, or to increase the `age` only when `particle.time > 0` (using an `np.where` statement).\n", "\n", "\n", "### 3. The last time is not written to file\n", @@ -321,27 +284,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Success = 0\n", - "Evaluate = 10\n", - "Repeat = 20\n", - "Delete = 30\n", - "StopExecution = 40\n", - "StopAllExecution = 41\n", - "Error = 50\n", - "ErrorInterpolation = 51\n", - "ErrorOutOfBounds = 60\n", - "ErrorThroughSurface = 61\n", - "ErrorTimeExtrapolation = 70\n" - ] - } - ], + "outputs": [], "source": [ "from parcels import StatusCode\n", "\n", @@ -362,7 +307,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -385,7 +330,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -404,7 +349,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -426,7 +371,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "parcels", "language": "python", "name": "python3" }, @@ -440,7 +385,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/docs/examples/tutorial_nemo_3D.ipynb b/docs/examples/tutorial_nemo_3D.ipynb index 2afae2464..a31cab269 100644 --- a/docs/examples/tutorial_nemo_3D.ipynb +++ b/docs/examples/tutorial_nemo_3D.ipynb @@ -42,17 +42,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 345600.0/345600.0 [00:00<00:00, 55244158.02it/s]\n" - ] - } - ], + "outputs": [], "source": [ "import warnings\n", "from datetime import timedelta\n", @@ -108,7 +100,7 @@ "\n", "pset = parcels.ParticleSet.from_line(\n", " fieldset=fieldset,\n", - " pclass=parcels.JITParticle,\n", + " pclass=parcels.Particle,\n", " size=10,\n", " start=(1.9, 52.5),\n", " finish=(3.4, 51.6),\n", @@ -121,41 +113,15 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Level[8] depth is: [10.7679 12.846]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1n/500ln6w97859_nqq86vwpl000000gr/T/ipykernel_56153/3089997373.py:8: UserWarning: The input coordinates to pcolormesh are interpreted as cell centers, but are not monotonically increasing or decreasing. This may lead to incorrectly calculated cell edges, in which case, please supply explicit cell edges to pcolormesh.\n", - " plt.pcolormesh(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "depth_level = 8\n", "print(\n", " f\"Level[{int(depth_level)}] depth is: \"\n", " f\"[{fieldset.W.grid.depth[depth_level]:g} \"\n", - " f\"{fieldset.W.grid.depth[depth_level+1]:g}]\"\n", + " f\"{fieldset.W.grid.depth[depth_level + 1]:g}]\"\n", ")\n", "\n", "plt.pcolormesh(\n", @@ -178,7 +144,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -187,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -196,7 +162,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -233,7 +199,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "parcels", "language": "python", "name": "python3" }, @@ -247,7 +213,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.5" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/docs/examples/tutorial_nemo_curvilinear.ipynb b/docs/examples/tutorial_nemo_curvilinear.ipynb index 0b4b807e2..6d99e3930 100644 --- a/docs/examples/tutorial_nemo_curvilinear.ipynb +++ b/docs/examples/tutorial_nemo_curvilinear.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -53,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -89,28 +89,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1n/500ln6w97859_nqq86vwpl000000gr/T/ipykernel_24135/4022207771.py:1: UserWarning: The input coordinates to pcolormesh are interpreted as cell centers, but are not monotonically increasing or decreasing. This may lead to incorrectly calculated cell edges, in which case, please supply explicit cell edges to pcolormesh.\n", - " plt.pcolormesh(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.pcolormesh(\n", " fieldset.U.grid.lon,\n", @@ -133,17 +114,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(u, v) = (1.000, -0.000)\n" - ] - } - ], + "outputs": [], "source": [ "u, v = fieldset.UV.eval(0, 0, 60, 50, applyConversion=False)\n", "print(f\"(u, v) = ({u:.3f}, {v:.3f})\")\n", @@ -159,25 +132,16 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in nemo_particles.zarr.\n", - "100%|██████████| 2592000.0/2592000.0 [00:00<00:00, 4185822.54it/s]\n" - ] - } - ], + "outputs": [], "source": [ "# Start 20 particles on a meridional line at 180W\n", "npart = 20\n", "lonp = -180 * np.ones(npart)\n", "latp = [i for i in np.linspace(-70, 85, npart)]\n", "\n", - "pset = parcels.ParticleSet.from_list(fieldset, parcels.JITParticle, lon=lonp, lat=latp)\n", + "pset = parcels.ParticleSet.from_list(fieldset, parcels.Particle, lon=lonp, lat=latp)\n", "pfile = parcels.ParticleFile(\"nemo_particles\", pset, outputdt=timedelta(days=1))\n", "\n", "pset.execute(\n", @@ -198,20 +162,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds = xr.open_zarr(\"nemo_particles.zarr\")\n", "\n", @@ -231,18 +184,18 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "pset = parcels.ParticleSet.from_list(fieldset, parcels.JITParticle, lon=lonp, lat=latp)\n", + "pset = parcels.ParticleSet.from_list(fieldset, parcels.Particle, lon=lonp, lat=latp)\n", "pset.populate_indices()" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "parcels", "language": "python", "name": "python3" }, @@ -256,7 +209,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.4" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/docs/examples/tutorial_output.ipynb b/docs/examples/tutorial_output.ipynb index 31ab1360d..febef5d32 100644 --- a/docs/examples/tutorial_output.ipynb +++ b/docs/examples/tutorial_output.ipynb @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -39,13 +39,20 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "example_dataset_folder = parcels.download_example_dataset(\"Peninsula_data\")\n", - "fieldset = parcels.FieldSet.from_parcels(\n", - " f\"{example_dataset_folder}/peninsula\", allow_time_extrapolation=True\n", + "example_dataset_folder = parcels.download_example_dataset(\"Peninsula_data\")\n", + "filenames = {\n", + " \"U\": str(example_dataset_folder / \"peninsulaU.nc\"),\n", + " \"V\": str(example_dataset_folder / \"peninsulaV.nc\"),\n", + "}\n", + "variables = {\"U\": \"vozocrtx\", \"V\": \"vomecrty\"}\n", + "dimensions = {\"lon\": \"nav_lon\", \"lat\": \"nav_lat\", \"time\": \"time_counter\"}\n", + "fieldset = parcels.FieldSet.from_netcdf(\n", + " filenames, variables, dimensions, allow_time_extrapolation=True\n", ")\n", "\n", "npart = 10 # number of particles to be released\n", @@ -56,7 +63,7 @@ "time = np.arange(npart) * timedelta(hours=2).total_seconds()\n", "\n", "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=lon, lat=lat, time=time\n", + " fieldset=fieldset, pclass=parcels.Particle, lon=lon, lat=lat, time=time\n", ")\n", "\n", "output_file = pset.ParticleFile(name=\"Output.zarr\", outputdt=timedelta(hours=2))" @@ -71,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -80,18 +87,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in Output.zarr.\n", - "100%|██████████| 86400.0/86400.0 [00:01<00:00, 82356.55it/s]\n" - ] - } - ], + "outputs": [], "source": [ "pset.execute(\n", " parcels.AdvectionRK4,\n", @@ -113,34 +111,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Size: 3kB\n", - "Dimensions: (trajectory: 10, obs: 12)\n", - "Coordinates:\n", - " * obs (obs) int32 48B 0 1 2 3 4 5 6 7 8 9 10 11\n", - " * trajectory (trajectory) int64 80B 0 1 2 3 4 5 6 7 8 9\n", - "Data variables:\n", - " lat (trajectory, obs) float32 480B dask.array\n", - " lon (trajectory, obs) float32 480B dask.array\n", - " time (trajectory, obs) timedelta64[ns] 960B dask.array\n", - " z (trajectory, obs) float32 480B dask.array\n", - "Attributes:\n", - " Conventions: CF-1.6/CF-1.7\n", - " date_created: 2024-11-20T11:07:47.494911\n", - " feature_type: trajectory\n", - " ncei_template_version: NCEI_NetCDF_Trajectory_Template_v2.0\n", - " parcels_kernels: JITParticleAdvectionRK4\n", - " parcels_mesh: flat\n", - " parcels_version: 3.1.1.dev4\n" - ] - } - ], + "outputs": [], "source": [ "import xarray as xr\n", "\n", @@ -150,20 +123,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Size: 80B\n", - "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n", - "Coordinates:\n", - " * trajectory (trajectory) int64 80B 0 1 2 3 4 5 6 7 8 9\n" - ] - } - ], + "outputs": [], "source": [ "print(data_xarray[\"trajectory\"])" ] @@ -192,26 +154,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[ 0. 2. 4. 6. 8. 10. 12. 14. 16. 18. 20. 22.]\n", - " [ 2. 4. 6. 8. 10. 12. 14. 16. 18. 20. 22. nan]\n", - " [ 4. 6. 8. 10. 12. 14. 16. 18. 20. 22. nan nan]\n", - " [ 6. 8. 10. 12. 14. 16. 18. 20. 22. nan nan nan]\n", - " [ 8. 10. 12. 14. 16. 18. 20. 22. nan nan nan nan]\n", - " [10. 12. 14. 16. 18. 20. 22. nan nan nan nan nan]\n", - " [12. 14. 16. 18. 20. 22. nan nan nan nan nan nan]\n", - " [14. 16. 18. 20. 22. nan nan nan nan nan nan nan]\n", - " [16. 18. 20. 22. nan nan nan nan nan nan nan nan]\n", - " [18. 20. 22. nan nan nan nan nan nan nan nan nan]]\n" - ] - } - ], + "outputs": [], "source": [ "np.set_printoptions(linewidth=160)\n", "one_hour = np.timedelta64(1, \"h\") # Define timedelta object to help with conversion\n", @@ -241,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -261,20 +206,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4), constrained_layout=True)\n", "\n", @@ -300,22 +234,9 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlEAAAGwCAYAAACJjDBkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAADzzElEQVR4nOzdZ3RU1RqH8WcmvQ4pJCEhCS3U0FGa0pvSbICAUem9IwgqTao0kd6kKBJERAGl99576C2FFNImfeq5H4YbSYCQRKaA+7dW1s3M7DPnTeQyf/bZ590ySZIkBEEQBEEQhAKRm7sAQRAEQRCEV5EIUYIgCIIgCIUgQpQgCIIgCEIhiBAlCIIgCIJQCCJECYIgCIIgFIIIUYIgCIIgCIUgQpQgCIIgCEIhWJu7gNeJXq/n4cOHuLi4IJPJzF2OIAiCIAj5IEkSqamp+Pr6Ipfnf35JhKiX6OHDh/j7+5u7DEEQBEEQCiEiIoLixYvne7wIUS+Ri4sLYPiP4OrqauZqBEEQBEHIj5SUFPz9/bM/x/NLhKiX6P+X8FxdXUWIEgRBEIRXTEGX4oiF5YIgCIIgCIUgQpQgCIIgCEIhiBAlCIIgCIJQCCJECYIgCIIgFIIIUYIgCIIgCIUgQpQgCIIgCEIhiBAlCIIgCIJQCCJECYIgCIIgFIIIUYIgCIIgCIUgQpQgCIIgCEIhiBAlCIIgCIJQCCJECYIgCIIgFIIIUYIgCIIgWLxMtY4TdxPMXUYO1uYuQBAEQRAE4Xky1FrWnQhn6aG7pGZpODyqMV6u9uYuCxAhShAEQRAEC5Sh1vLT8QcsP3yX+DQ1TmTS3PUhEUl1RIgSBEEQBEHILV2lZe3j8JSYrgbgA8UNvpUvw1Gbgsy1PeBm3iIfEyFKEARBEASzS1NpWXPsPisO3yUpQwNAJXc98z02USpis2FQkQDIiAe3QDNW+g8RogRBEARBMJvULI0hPB25R/Lj8FTS04kpFSKoe30KsohoQAa1+0CTb8DO2bwFP0GEKEEQBEEQTC4lS8OqI/dZeeQuKVlaAEp5OjHibU/eiZiL/PRvhoEeZaDdAgisa8Zqn02EKEEQBEEQTEaZqeHHI/f48eg9Uh+Hp9JFnRjcNIg21qex2t4T0h+BTA51B0LjsWDjYOaqn02EKEEQBEEQjC45Q82PR+6x6uh9UlWG8BTk5cygpkG0LmmF1faRcG2LYXDRCtB+IRSvacaKX0yEKEEQBEEQjCYpXc3KI/dYfew+aY/DUzlvFwY1LcO7lXyQX9kIi0dDZhLIreGt4dBgJFjbmbnyFxMhShAEQRCEly4xXc2Kw3dZc+w+6WodAOV9XBjSNIiWlXyQp0XDhs5wc4fhAJ/K0H4RFKtixqoLRoQoQRAEQRBemoQ0FcsO3+Wn4w/IeByeKhZzZXDTIFpU9EYuA87/BDu/AlUKWNlCw1FQfyhY2Zi19oISIUoQBEEQhH8tPk3FskOG8JSpMYSnSr6uDGkaRPOK3shkMkgOhy2D4e5+w0F+NQ1rn7wqmLHywhMhShAEQRCEQotLzWLZwbv8fPIBWRo9AFWKKxjcJIimFbwM4Umvh9MrYM8EUKeBtT00/grqDgC5lXl/gH9BhChBEARBEAosLiWLJQfvsu7kA1RaQ3iq6l+EoU2DaFSuqCE8ASTcgS2D4MFRw+OAuoa+T55lzFT5yyNClCAIgiAI+RajzGLJwTusPxWeHZ6qBxRhSNMgGpZ9IjzpdXByCez9FrSZYOMEzSbAGz1BLjffD/ASiRAlCIIgCMILRSszWXzgDqGnI1A/Dk81A90Y0jSIt4M8/wlPAI9uwJ8DIPK04XHJhtDuB3ArYfrCjUiEKEEQBEEQnisqOZPFB27z6+lI1DpDeHqzhDtDmgVRr7RHzvCk08KxeXBgOujUYOsCLSdDjc/gyXGvCRGiBEEQBEF4SmRSBosO3GHjmQg0OgmA2iUN4aluqVzhCSDmsmH2Kfqi4XFQC2gzFxTFTVy56YgQJQiCIAhCtojEDBYduM1vZyOzw1PdUh4MaRZEnVIeTx+gVcPh2XB4Fui1YF8E3pkBVTq9lrNPTxIhShAEQRAEwhMyWLD/Fr+fi0KrN4Sn+mU8GNK0LG+WdH/2QVHn4M+BEHfV8Lh8G2g9B1y8TVS1eYkQJQiCIAj/Yffj01mw/zabz0ehexye3g7yZEjTIGqVeE540mTBgWlw7AeQ9ODoAe/Ogkrvv/azT08SIUoQBEEQ/oPuxaczf98t/rzwMDs8NSxblMFNg6gZ6Pb8A8NPGtY+JdwyPA7+yHD5zsnTBFVbFhGiBEEQBOE/JF2l5dttYfx6JoLH2YnG5QzhqXpAHuFJnQ77JsOJxYAEzj7QZg6Ub22Sui2RCFGCIAiC8B9xMzaVfj+f5c6jdACalvdicNMgqvoXyfvAe4dhy0BIum94XK0rtJwCDnmErpfsSNQRzsWeY3CNwSY754uIECUIgiAI/wGbz0cy9vcrZGp0eLva8cPH1an9rLvtnqRKhd3j4cxKw2PX4tB2HgQ1M37Bj0mSxNqwtcw5Owe9pKeSZyWaBjQ12fnzIkKUIAiCILzGsjQ6Jm4NY/2pcADeKuPJ9x9Xw9PZLu8Db++BrUNBGWF4XKs7NJsI9q7GLfgJap2aSccn8eedPwF4v8z7vO33tsnO/yJm3bymRIkSyGSyp74GDBgAGNLnhAkT8PX1xcHBgUaNGnH16tUc76FSqRg0aBCenp44OTnRrl07IiMjc4xJSkoiJCQEhUKBQqEgJCSE5OTkHGPCw8Np27YtTk5OeHp6MnjwYNRqtVF/fkEQBEEwpvCEDD5cfIz1p8KRyWBI0yDWdH8z7wCVmQR/DICfPzQEqCKB8OkWQ+NMEwao+Mx4euzswZ93/kQukzP6jdFMrDcRWytbk9XwImYNUadPnyY6Ojr7a/fu3QB06NABgO+++445c+awYMECTp8+jY+PD82bNyc1NTX7PYYOHcrmzZsJDQ3lyJEjpKWl0aZNG3Q6XfaYLl26cOHCBXbs2MGOHTu4cOECISEh2a/rdDpat25Neno6R44cITQ0lE2bNjFixAgT/SYEQRAE4eXaeTWG1vMPc/VhCu5Otqzp9ibDmpfFSp5HC4Lrf8PCOnDhZ0AGtftB/+NQqqHJ6ga4lnCNzn915sKjC7jYurC46WI+qfjJ013SzU2yIEOGDJFKly4t6fV6Sa/XSz4+PtL06dOzX8/KypIUCoW0ZMkSSZIkKTk5WbKxsZFCQ0Ozx0RFRUlyuVzasWOHJEmSFBYWJgHSiRMnssccP35cAqTr169LkiRJf//9tySXy6WoqKjsMevXr5fs7OwkpVL53HqzsrIkpVKZ/RURESEBeR4jCIIgCMak1uqkKX+FSYGjt0mBo7dJ7y88Ij1Mzsj7oLR4SfqthySNdzV8/VBDkh4cN03Buey8t1N64+c3pODVwVKb39tI95LvGf2cSqWyUJ/fZp2JepJarebnn3+me/fuyGQy7t27R0xMDC1atMgeY2dnR8OGDTl27BgAZ8+eRaPR5Bjj6+tLcHBw9pjjx4+jUCioXbt29pg6deqgUChyjAkODsbX1zd7TMuWLVGpVJw9e/a5NU+bNi37EqFCocDf3//l/DIEQRAEoRBilFl0WX6CZYfuAtDjrZJs6FOXYgqH5x90dTMsfBMubwSZHOoPgb5HIKCOiao20Et6Fl1YxIiDI8jUZlLftz7rWq+jhKKESesoCItZWP7HH3+QnJzM559/DkBMTAwA3t45W8d7e3vz4MGD7DG2tra4ubk9Neb/x8fExODl5fXU+by8vHKMyX0eNzc3bG1ts8c8y5gxYxg+fHj245SUFBGkBEEQBLM4ciueIaHnSUhX42JnzcwOVWgVXOz5B6TGwt8j4doWw+OiFeC9heBX0zQFPyFDk8HXR79m9wPDsp5PK37KsJrDsJZbTEx5JoupbuXKlbzzzjs5ZoOAp65/SpL0wmuiucc8a3xhxuRmZ2eHnd0L7m4QBEEQBCPS6yXm77vN93tvIklQoZgri7vWoISn0/MPuvybIUBlJoHcGt4eYfiyNv1nWnRaNIP3D+Z64nWs5daMqzOO94PeN3kdhWERIerBgwfs2bOH33//Pfs5Hx8fwDBLVKzYP0k6Li4ue9bIx8cHtVpNUlJSjtmouLg46tWrlz0mNjb2qXM+evQox/ucPHkyx+tJSUloNJqnZqgEQRAEwVIkpqsZuuECh24+AuDjN/yZ0K4S9jZWzz5Ar4f9k+HwbMNjnyrw3iLwqWyiinM6H3eeofuHkpiViLu9O983/p7qXtXNUkthWMSaqFWrVuHl5UXr1v+0ji9ZsiQ+Pj7Zd+yBYd3UwYMHswNSzZo1sbGxyTEmOjqaK1euZI+pW7cuSqWSU6dOZY85efIkSqUyx5grV64QHR2dPWbXrl3Y2dlRs6bppzUFQRAE4UXOPkii9Q+HOXTzEfY2cmZ1qMr0D6s8P0BpsuD3nv8EqLeGQ699ZgtQm29tpvvO7iRmJVLevTyhrUNfqQAFFjATpdfrWbVqFZ999hnW1v+UI5PJGDp0KFOnTiUoKIigoCCmTp2Ko6MjXbp0AUChUNCjRw9GjBiBh4cH7u7ujBw5ksqVK9OsmaGbaoUKFWjVqhW9evVi6dKlAPTu3Zs2bdpQrlw5AFq0aEHFihUJCQlh5syZJCYmMnLkSHr16oWrq+l6YgiCIAjCi0iSxI9H7zPt72to9RKlPJ1Y9EkNyvvk8XmVkQihXSD8uOHyXdsfoHpX0xX9BK1ey5yzc/gp7CcAmgc2Z3L9yTjaOJqlnn/D7CFqz549hIeH071796deGzVqFJmZmfTv35+kpCRq167Nrl27cHFxyR4zd+5crK2t6dixI5mZmTRt2pTVq1djZfVPEl+3bh2DBw/OvouvXbt2LFiwIPt1Kysr/vrrL/r370/9+vVxcHCgS5cuzJo1y4g/uSAIgiAUTEqWhtG/XWL7FcNNT62rFGPGh1Vwtsvj4zzhDqzrAIl3wE4BndZCqUamKTiXFHUKow6O4ujDowD0r9qfPlX7IJdZxIWxApNJkiSZu4jXRUpKCgqFAqVSKWawBEEQhJcq7GEK/ded5X5CBjZWMr5uXZFP6wbmfbNV+EkI7QwZCaDwh64bwauC6Yp+wn3lfQbtG8T9lPs4WDswuf5kWpRo8eIDTaCwn99mn4kSBEEQBCFvv56O4Js/r6DS6vEr4sDCrjWo5l8k74Oubobf+4BOBb7VofMGcDHPzVLHoo4x8uBIUjWp+Dj5ML/JfMq7lzdLLS+TCFGCIAiCYKEy1Tq++fMKv5017AnbuFxR5nSshptTHvvHSRIcnQd7xhsel3sXPlwBtnm0PDASSZL4+drPzDozC72kp1rRasxtPBdPB0+T12IMIkQJgiAIggW6+yiN/uvOcT0mFbkMRrQoR7+GpZHntfedTmvo/3R2leFx7X7QcgrIn3PHnhGpdWomn5jM5tubAXivzHt8U+cbi9pA+N8SIUoQBEEQLMy2Sw8Z/dsl0tU6PJ3t+KFzNeqVfsHsjSoVNn4Ot/cAMmg1Der0M0W5T0nITGDYgWGcjzuPXCZnRM0RhFQMsbwNhP8lEaIEQRAEwUKotXqm/n2N1cfuA1C7pDvzO1fHy9U+7wOVUfBLJ4i9DNYO8NFKKN8672OM5HridQbvG0x0ejQuNi581/A73vJ7yyy1GJsIUYIgCIJgASKTMhjwy3kuRiQD0K9RaUY0L4u11Qtu/4++BL90hNRocPKCLqFm2f8OYM+DPYw9MpZMbSaBroHMbzKfkoqSZqnFFESIEgRBEAQz238jjmEbLpCcoUHhYMOcjlVpWiEfd9Ld2m24hKdOg6Llocuv4BZo9HpzkySJJZeWsOjCIgDqFqvLzIYzUdgpTF6LKYkQJQiCIAhmotXpmbvnJgv33wGgSnEFC7vUwN89H927z/wIf40ESQclG0DHn8ChiHELfoZMbSZfH/maXQ92AfBJhU8YUWsE1vLXP2K8/j+hIAiCIFiguNQshqy/wPG7CQB8WjeQr1pXwM76BXfS6fWwd4KhjQFA1S7Qdh5Ym/6ut5j0GAbvG8y1xGtYy635ps43fBD0gcnrMBcRogRBEATBxE7eTWDg+vM8SlXhaGvF9A+r0K6q74sP1GTC5r4Q9ofhceOvoMEXYIa73i7EXWDo/qEkZCXgbu/O3EZzqeFdw+R1mJMIUYIgCIJgInq9xNJDd5m16wY6vURZb2cWda1JGS/nFx+cHg/rO0PkKZDbQPuFULWT8Yt+hj9v/8nE4xPR6DWUdSvL/Cbz8XXORwh8zYgQJQiCIAgmoMzQMPzXC+y9HgfAB9X9mPx+MI62+fgojr8N6z6EpPtgXwQ+XgclTN82QKfXMffsXNaErQGgaUBTpr41FUebfKzheg2JECUIgiAIRnYpMpn+684RmZSJrbWcie0q8fEb/vlrPvngGIR2gcwkKBIIXX+DomWNX3QuqepUvjj0BUejjgLQt2pf+lXth1z2ghYMrzERogRBEATBSCRJ4ueT4Xy7NQy1Tk+AuyOLutYg2C+ft/5f2gh/9gedGvxqQedQcC5q3KKf4UHKAwbtG8Q95T3sreyZ/NZkWpZoafI6LI0IUYIgCIJgBOkqLWN+v8yWiw8BaFHRm5kdqqJwsHnxwZIEh2fBvsmGxxXawvvLwNb0l82OPzzOyIMjSVGn4O3ozQ9NfqCiR0WT12GJRIgSBEEQhJfsZmwq/X4+y51H6VjJZYx5pzw93iqZv8t3Og1sGwrnfzY8rjsQmn8LctNeNpMkiV+u/8LM0zPRSTqqFq3K942/x9PhBXv4/YeIECUIgiAIL9Hm85GM/f0KmRodPq72LOhSnVol3PN3cJYSfv0U7h4AmRze+Q7e7GXUep9Fo9Mw5eQUNt3aBEC70u0YX3c8tlam70VlyUSIEgRBEISXIEujY+LWMNafCgfg7SBPvu9UDQ9nu/y9QXKEYQ+8uDCwcYKPfoRyrYxY8bMlZiUybP8wzsWdQy6TM7zmcD6t+Gn+ZtH+Y0SIEgRBEIR/6UFCOv3XnePqwxRkMhjcJIjBTYOwkuczeDw8D790grRYcPaBLhvAt5pRa36WG4k3GLxvMA/TH+Js48x3Db7j7eJvm7yOV4UIUYIgCILwL+y6GsOIjRdJzdLi7mTL952q0aBsAe6gu7EdfusOmgzwqgRdfwVFceMV/Bx7w/cy5vAYMrWZBLgEML/JfEoVKWXyOl4lIkQJgiAIQiHtvxFH35/PopegZqAbC7pUp5jCIf9vcHIZ7BgNkh5KNYaOa8He1XgFP4MkSSy7tIwFFxYAUKdYHWY1nIXCLp9tGExEn5GBNjER2+KmD5jPI0KUIAiCIBTC7bg0Bv9yHr0EH9TwY8aHVbCxyucddHod7PoGTiw0PK7xKbSeA1b5aH/wEmVqMxl3dBw77u8AoEv5LnzxxhdYyy0rHujS0ojo0xdNVBSBP/9kMUHKsn5LgiAIgvAKUGZq6L32DKkqLW+UcGP6BwUIUOoM+L0XXN9meNx0HLw13OSbCMekxzBk/xDCEsKwllnzVZ2v+KjsRyatIT90SiXhvXqTdekSchcXdImJIEKUIAiCILx6dHqJQevPczc+Hb8iDiz+pCa21vkMUGlxsP5jiDoLVrbw3mKobPrgcvHRRYbuH0p8Zjxudm7MaTSHWj61TF7Hi2iTkgjv0QNV2DWsFAr8f1yJQ6VK5i4rmwhRgiAIglAA07df49DNRzjYWLHs05p45reFwaMbsO4jSA4HBzf4eD0E1jVusc9wOuY0/ff0J0uXRZBbEPObzMfP2c/kdbyINj6e8G7dUd26hZWHBwE//oh9OdPvGZgXEaIEQRAEIZ82nY1k+eF7AMzqUJVKvvlcfH3vEGz4xNBM062kYRNhzzJGrPTZLsRdYMDeAWTpsqjvV585DefgaGP6rWReRBMbS/jn3VDfu4d10aIErFmNXSnLu1NQhChBEARByIdz4UmM+f0yAIObBtG6SrH8HXhhPWwZBHoN+NeGj38BJ9NvnXIl/gr99vQjU5tJ3WJ1mdd4HnZW+ZxFMyFNVBQPPu+GJiICa99iBK5ahW1goLnLeiYRogRBEAThBWKUWfT56SxqnZ6WlbwZ2jToxQdJEhycAQemGR5Xeh/eWwI29sYt9hmuJVyj9+7epGnSeMPnDeY1scwApX7wgAfduqF9GI2Nvz+Bq1dh42d5lxr/T4QoQRAEQchDlkZH75/O8ChVRXkfF+Z0rIb8RZ3ItWrYOhgurjc8rj8Umo43+SbCADeTbtJ7d29S1alU96rOgiYLcLAuQC8rE1HdvUv4593QxsVhW6IEAWtWY+Ptbe6y8iRClCAIgiA8hyRJfLnpEpcilbg52rD801o42b3gozMzCTaEwP3DILOC1rOhVjfTFJzLXeVdeu3qRbIqmcqelVnUdJFFroHKunGT8O7d0SUkYBdUhoAff8S6aAG6vpuJCFGCIAiC8BxLD93ljwsPsZbLWNS1Jv7uLwggSfdhXQeIvwm2ztBhDQQ1M0mtuT1IeUDPnT1JzEqkgnsFFjdbjLOts1lqyUvm1atEdO+BTqnErmIFAlauxNrNzdxl5YsIUYIgCILwDPuuxzJjx3UAxrerRN3SHnkfEHkW1neC9Efg4mvYA8+nsgkqfUYpqZH02NmDR5mPCHILYmnzpRa3jQtA5oULhPfqjT41FfsqVQhYvgwrheXV+TwiRAmCIAhCLrfjUhmy/gKSBF1qBxBS5wV3h13bBpt6gjbTEJy6/AquvqYpNpfotGh67upJbEYsJRUlWd58OW72ljezk3HmDBG9+6DPyMChZk38ly7BytnyZsryYvoVboIgCIJgwZQZGnquMWzp8mZJdya0fUGH7BOLDT2gtJlQpjl02262ABWXEUePXT2ISosiwCWAFS1W4OHwghk0M0g/ftwwA5WRgWOdOoYZqFcsQIEIUYIgCIKQTavTM3D9Oe4nZBi2dOlaI+8tXc6ugR1fAhLU6g6dQ8HOxWT1Pik+M56eu3oSkRqBn7MfK1uuxMvRyyy15CXt4EEi+vRFyszE6e238V+yGLmj5S12zw8RogRBEAThsWnbr3P4VjwONlYs/7QWHnlt6XL3APw13PD9W8Oh9RywMs8qmaSsJHrt6sU95T18nHxY2XIlPk4+ZqklL6l79hAxcBCSWo1z06YUX7gAub3p+2a9LCJECYIgCAKw8UwEK48YtnSZ07EqFX1dnz847jps+BT0Wgj+CJqOA9kLekcZiVKlpPfu3txOvo2XgxcrW6y0yL3wUv7+m8ghQ0GjweWdVhT/fi5yW1tzl/WvmD1ERUVF8cknn+Dh4YGjoyPVqlXj7Nmz2a9LksSECRPw9fXFwcGBRo0acfXq1RzvoVKpGDRoEJ6enjg5OdGuXTsiIyNzjElKSiIkJASFQoFCoSAkJITk5OQcY8LDw2nbti1OTk54enoyePBg1Gq10X52QRAEwTKcfZDEV5uvADCkaRDvVM5jS5e0OPilA6iU4F8H2i80W4BKVafSd3dfridex8Peg+UtlxPgGmCWWvKSvPkPokZ+ATodivbt8Js5E5mNjbnL+tfMGqKSkpKoX78+NjY2bN++nbCwMGbPnk2RIkWyx3z33XfMmTOHBQsWcPr0aXx8fGjevDmpqanZY4YOHcrmzZsJDQ3lyJEjpKWl0aZNG3Q6XfaYLl26cOHCBXbs2MGOHTu4cOECISEh2a/rdDpat25Neno6R44cITQ0lE2bNjFixAiT/C4EQRAE84hWZmZv6dKqkg9D8trSRZMJ6ztDcrhhI+GPfzHLNi4A6Zp0+u/pz5WEKxSxK8LyFssppbC8TXqTNvxK9NixoNdTpMNHFJs2DZn1a9IcQDKj0aNHS2+99dZzX9fr9ZKPj480ffr07OeysrIkhUIhLVmyRJIkSUpOTpZsbGyk0NDQ7DFRUVGSXC6XduzYIUmSJIWFhUmAdOLEiewxx48flwDp+vXrkiRJ0t9//y3J5XIpKioqe8z69eslOzs7SalU5uvnUSqVEpDv8YIgCIJ5Zaq1UpsfDkuBo7dJLecelNKyNM8frNNJ0oZPJWm8qyRNC5CkRzdNV2guGZoM6fPtn0vBq4Oler/Uk64lXDNbLXlJWPuTFFauvBRWrrwUPelbSa/TmbukZyrs57dZZ6K2bNlCrVq16NChA15eXlSvXp3ly5dnv37v3j1iYmJo0aJF9nN2dnY0bNiQY8eOAXD27Fk0Gk2OMb6+vgQHB2ePOX78OAqFgtq1a2ePqVOnDgqFIseY4OBgfH3/uS21ZcuWqFSqHJcXn6RSqUhJScnxJQiCILwaJEli1G+XuBylxN3J9sVbuuz7FsL+ALkNdPoZPPOxCbERqHQqBu8bzJnYMzjbOLO0+VLKu5c3Sy15SVixgtgpUwBw794d76+/QmaGvQONyaw/zd27d1m8eDFBQUHs3LmTvn37MnjwYNauXQtATEwMAN65NiD09vbOfi0mJgZbW1vccrWIzz3Gy+vp2zy9vLxyjMl9Hjc3N2xtbbPH5DZt2rTsNVYKhQJ/f/+C/goEQRAEM1l88A5bLv5/S5caeW/pcu4nODLH8H27+VDybdMUmYtap2bo/qGciD6Bg7UDi5stJtgz2Cy1PI8kSTxauJC4WbMB8OzfD68vRiIz07oxYzJriNLr9dSoUYOpU6dSvXp1+vTpQ69evVi8eHGOcbl/8ZIkvfA/Ru4xzxpfmDFPGjNmDEqlMvsrIiIiz5oEQRAEy7AnLJaZO28AMKFdJeqUyqMh5d0DsG2o4fsGX0C1zkav71k0eg0jD47kSNQR7K3sWdR0EdW8qpmllueRJIlHc78nfv4CAIoOHUrRwYNfywAFZg5RxYoVo2LFijmeq1ChAuHh4QD4+Bh6XOSeCYqLi8ueNfLx8UGtVpOUlJTnmNjY2KfO/+jRoxxjcp8nKSkJjUbz1AzV/9nZ2eHq6prjSxAEQbBst2JTGbrBsKXLJ3UC+CSvLV0e3XiilcGH0Pgr0xX6BK1ey+hDo9kfsR9buS0/NPmBWj61zFLL80iSRNz06SQsWwaA1+jRePbtY+aqjMusIap+/frcuHEjx3M3b94kMNDwB7pkyZL4+Piwe/fu7NfVajUHDx6kXr16ANSsWRMbG5scY6Kjo7ly5Ur2mLp166JUKjl16lT2mJMnT6JUKnOMuXLlCtHR0dljdu3ahZ2dHTVr1nzJP7kgCIJgDskZanquPUOaSkudUu6Mz2tLl7RHsO7/rQxqQ/tFZmlloNPr+OrIV+x+sBsbuQ3fN/6eur51TV5HXiS9nphJk0hcY1iO4z3uGzy6fW7eokzhJS9wL5BTp05J1tbW0pQpU6Rbt25J69atkxwdHaWff/45e8z06dMlhUIh/f7779Lly5elzp07S8WKFZNSUlKyx/Tt21cqXry4tGfPHuncuXNSkyZNpKpVq0parTZ7TKtWraQqVapIx48fl44fPy5VrlxZatOmTfbrWq1WCg4Olpo2bSqdO3dO2rNnj1S8eHFp4MCB+f55xN15giAIlkuj1Uldl5+QAkdvk+pP3yslpKmeP1idIUnLmxruxPu+iiSlPTJdoU/Q6XXSV4e/koJXB0vV1lST9j3YZ5Y68qLXaqWoMWMNd+GVryAl/fabuUsqsMJ+fps1REmSJG3dulUKDg6W7OzspPLly0vLli3L8bper5fGjx8v+fj4SHZ2dlKDBg2ky5cv5xiTmZkpDRw4UHJ3d5ccHBykNm3aSOHh4TnGJCQkSF27dpVcXFwkFxcXqWvXrlJSUlKOMQ8ePJBat24tOTg4SO7u7tLAgQOlrKysfP8sIkQJgiBYrglbrkiBo7dJFb7ZLoU9zOPvaZ1Okn797HErA39JirthshqfpNfrpYnHJkrBq4OlqmuqSjvv7TRLHXnRazRS5IiRhgBVoaKUvGWLuUsqlMJ+fsskSZLMOxf2+khJSUGhUKBUKsX6KEEQBAvy6+kIRm26BMCST2rSKjiPfeX2ToLDs0FuDSGboWQDE1X5D0mSmHF6BuuurUOGjGlvT6N1qdYmryMvklpN1MgvSN21C6yt8Zs1C9dWLc1dVqEU9vP7NWkZKgiCIAjPduZ+Il/9cRmAYc3K5h2gzv9sCFAAbX8wW4Cae3Yu666tA2BS/UkWF6D0KhVRQ4aSduAAMhsb/ObNw6VJY3OXZXIiRAmCIAivrajkTPr+fBaNTuLdyj4MalLm+YPvHoStQwzfvz0Sqnc1TZG5LLiwgFVXVwEwru443ivznlnqeB59ZiaRAwaSfuwYMjs7ii9YgPPbb5m7LLMQIUoQBEF4LWWqdfRee4b4NDUVirkyq0NV5PLn3F336Cb8GmJoZVDpA7O1Mlh6cSnLLhlaBHz55pd0KNvBLHU8jz49nYi+/cg4fRqZoyP+ixbhVKf2iw98TYkQJQiCILx2JEnii98ucvVhCh5Otiz/tCaOts/5yEuPh3UfQZYSir8J7y0GM2xPsurKKhZcMDSpHFFzBF0rmGcm7Hl0qalE9OpN5oULyJ2c8F++DMcaNcxdllmJECUIgiC8dhYduMO2S9FYy2Us/qQmxd2es6WLJgvWd4bkB+BWAjqvBxt7k9YK8HPYz8w5a9hWZlD1QXwe/LnJa8iLLjmZ8J69yLpyBbmrKwErV+BQubK5yzI7EaIEQRCE18rusFhm7TI0cp7UPpg3S7o/e6BeD3/0g8hTYK+ALhvBydOElRr8euNXZpyeAUCfKn3oXaW3yWvIizYxkfBu3VHduIGVmxsBP67EvkIFc5dlEUSIEgRBEF4bN2NTGRp6HkmCT+sG0qV2wPMH758CV383tDLo+BMULWu6Qh/bfGsz3574FoBuwd0YUG2AyWvIiyYujvBu3VHfuYNVUU8Cf/wRu6Agc5dlMUSIEgRBEF4LSelqeq45Q7paR91SHnzTpuLzB59fB4dnGb5vOw9KNTRNkU/Yemcr44+NB+CTCp8wrMYwi9qoVxMdzYPPP0fzIBxrb28CVq/CrmRJc5dlUUSIEgRBEF55Gp2eAb+cIzwxA393BxZ2rYGN1XMWh9879EQrgxFQ/RPTFfrYjvs7+Pro10hIdCrXiVFvjLKoAKWOjCT8s8/RREVh4+dHwOpV2Pr7m7ssi5OvEDV8+PACv/HXX3+Nu/tzrkMLgiAIwks05a9rHLuTgJOtFSs+fQN3J9tnD3x0EzZ8AnrN41YGX5u2UGBv+F6+PPQleknPB0EfMLb2WIsKUKp79wjv1h1tTAw2gQEErl6NTbFi5i7LIuVr2xe5XE7dunWxtX3OH8pcjhw5wo0bNyhVqtS/LvBVIrZ9EQRBML3QU+F8+buhI/mykJq0qPScjuTp8bCiKSTdh+JvwGdbwcbBdIUChyIPMWT/ELR6LW1LteXb+t9iJbcyaQ15Ud2+zYNu3dA9ise2dGkCVv2IjZeXucsyOqNv+7J582a88vmLdHFxyXcBgiAIglBYp+8n8s2fVwAY0bzs8wOUJgtCuxgCVJFA+Hi9yQPUsYfHGLZ/GFq9lpYlWjKp/iSLClBZ164R3r0HuqQk7MqVI+DHlVh7eJi7LIuWr25iq1atQqFQ5PtNly5dire3d6GLEgRBEIQXiUrOpO9Phi1dWlcuxsDnbemi18Of/SHiJNgpoOtGcC5q0lpPx5xmyL4hqPVqmvg3Ydrb07CWW86y5MzLl3nweTd0SUnYV6pE4JrVIkDlQ74u5wn5Iy7nCYIgmEaGWstHi48TFp1CxWKu/Nav7vM7ku+bDIdmGloZfPK7ye/EOx93nj67+5CpzeRtv7f5vvH32Frlb3mMKWScO0dE7z7o09JwqFYN/+XLsPqPXVEy+uW8Z0lLS0Ov1+d4ToQHQRAEwZgkSeKLjZcIi368pctntZ4foC78YghQAG2+N3mAuvzoMv329CNTm0ndYnWZ23iuRQWo9JOniOjXDykjA8datSi+ZAlWzk7mLuu5JEmyqEX4Bd4c6N69e7Ru3RonJycUCgVubm64ublRpEgR3NzcjFGjIAiCIGRbsO82f12OxsZKxpKQmvgVec7apnuHYctgw/dvDYMaIaYrEghLCKPPnj6ka9J5w+cN5jWZh52VnUlryEva4SNE9O6NlJGBU716hhkoCw5QF/dFsHfNNfR6y7mAVuCZqK5dDRsi/vjjj3h7e1tUIhQEQRBeb7uuxjB7900Avm0fzBslntNKJ/7WP60MKr4HTcaZrkjgZtJNeu/uTao6lepe1VnQZAEO1qZdyJ6X1H37iRoyBEmjwblhQ/x+mIfcznICXm4X90Vw5NdbAJSo7EmZmpZxx2CBQ9SlS5c4e/Ys5cqVM0Y9giAIgvBM12NSGLbhAgCf1yvBx28+Z0uX9ARY1wGykg2tDN5fAvICX3gptLvJd+m1qxdKlZLKnpVZ1HQRjjbP2QDZDNIOHyFyyBDQaHBp3hy/2bOQ5bOFkTlc2v9PgKrZKpDSNUx7U0BeCvyn6o033iAiIsIYtQiCIAjCMyWmq+m11rClS73SHnzV+jkb4Ga3MrgHRQJM3srgQcoDeu7qSWJWIhXcK7C42WKcbZ1Ndv4XyTh7lshBgwwBqmVL/ObOsfgAdXiDIUDVaBVI7falLOoKWIFnolasWEHfvn2JiooiODgYGxubHK9XqVLlpRUnCIIgCBqdngHrzhGRmEmAuyMLuzxnSxdJgi0DIeKEoZVBF9O2MohMjaTHzh48ynxEkFsQy5ovQ2GX//ZAxpZ59SoRffoiZWXh1OBt/GZ+h8zactos5HZpf2SOAFXHwgIUFCJEPXr0iDt37tCtW7fs52QyWfaKeZ1O91ILFARBEP7bvt0WxvG7j7d0+awWbs/b0uXANLi80dDKoOMa8Cpvshqj06LpuasnsRmxlFKUYnnz5RSxL2Ky87+I6u5dInr2MrQxqFWT4vPmWfgMVCSHNxjWvtVoaZkBCgoRorp370716tVZv369WFguCIIgGNUvJ8NZe/wBMhl8/3F1yno/p3/RhfVwcIbh+zZzoXRjk9UYlxFHj109iEqLIsAlgBUtVuDhYDmNKtWRUYR3625opFmxIv6LFyN3sJxF7rldPvBkgAqgznuWGaCgECHqwYMHbNmyhTJlntMZVhAEQRBegpN3Exj3eEuXkS3K0bzic3bCuH8EtgwyfF9/KNT41DQFAslZyfTc1ZOI1Aj8nP1Y2XIlRR0tZ+Gz9tEjwnt0Rxsbi23p0vivXGHRjTQvH4jkUOiTAaq0xQYoKMTC8iZNmnDx4kVj1CIIgiAIAEQmZdBv3Tm0eok2VYrRv1HpZw+Mvw2hXR+3MmgPTcebrEaVTsXg/YO5p7yHj5MPK1uuxMfpOXv3mYEuOZnw7j3QPAjHxs/PsBeeBfdzfDJAVW9h+QEKCjET1bZtW4YNG8bly5epXLnyUwvL27Vr99KKEwRBEP57MtRaeq09S2K6mkq+rsz8qOqzP0zTE+CXx60M/GrB+0tN1spAL+kZe3gs5+PO42LjwuKmi/Fz9jPJufNDl5ZOeJ8+qG7dwqqoJwGrfsTGgve0zR2g6r5v+QEKCrF3njyPP6D/9YXlYu88QRCEf0evlxjwyzm2X4nB09mWLQPfwvdZHcm1KljbHsKPG1oZ9NwLzqZrwDjnzBxWXV2Ftdyapc2W8maxN0127hfRq1RE9OlLxokTWCkUBPy0FvuyZc1d1nNdORjJwfWPA1TzAOp+YPoAZbK983LvlScIgiAIL8v8fbfZfiXGsKXLJzWfHaAkCf4cYAhQdq6PWxmYLkCFXg9l1dVVAEyqN8miApSk0RA1bDgZJ04gd3TEf/kyEaCMyHQtXAVBEAQhD/uuxzJ3j+EDdcp7lan1vC1dDkx/opXBWpO2MjgQcYBpp6YBMKj6INqWbmuyc7+IpNfzcOxXpO3bh8zWluKLF+Ngwb0brxyKyg5Q1V7BAAX5DFE//PADWVlZ+X7TJUuWkJqaWuiiBEEQhP+WyKQMhm0w3LT0ad1AOr7h/+yBFzfAwemG71vPMWkrg6vxVxl1aBR6Sc+HQR/Sq3Ivk537RSRJIubbb0nZuhWsrfGb9z1OtS1nhiy3K4eiOPjLDcAQoOq9ggEK8hmihg0bVqBQNGrUKB49elToogRBEIT/DrVWz8BfzqPM1FC1uOL5W7rcP2roSA5QfwjU/MxkNUamRtJ/b38ytZnU963PV3W+sqgP/Udzvyd5fSjIZPhOn45LY9OFy4LKEaCa+b+yAQryuSZKkiSaNm2KdT7bw2dmZv6rogRBEIT/junbr3MhIhlXe2sWdKmBnbXV04MS7sCGrqBTQ4V20HSCyepTqpT039ufxKxEyrmVY1bDWdjIbV58oInEL19OwrJlAPhMmICiTWszV/R8TwWoD8u8sgEK8hmixo8vWN+N9u3b4+7+nGvZgiAIgvDYjivR/Hj0HgCzO1bD393x6UEZibDuI8hMAr+aJm1loNapGbp/KPeU9/B29GZh04UWtaFwUmgoj2bPAcDri5G4depo5oqe7+rhfwJU1dcgQIGRQpQgCIIgvMj9+HS+2HgJgD4NSj27I7lWZWimmXgXFAHQORRsnxG0jEAv6fn66NeciT2Ds40zi5otwtvJcnotKbduI2biJAA8+vTBo0cPM1f0fFcPR3Fg3eMA1dSf+q9BgAJxd54gCIJgBlkaHf3XnSNVpaVWoBsjW5Z7epAkGbZzCT9maGXQ9VeTtjKYf34+2+9tx1pmzZxGcyjrZjmtAlL37efhl1+CJOHWpQtFhw4xd0nP9VSA+uj1CFAgQpQgCIJgBpO2hREWnYK7ky3zu1THxuoZH0cHZ8ClDSCzgo5rwOs5C86NYOPNjay4vAKA8fXGU9e3rsnO/SLpJ04QNXQo6HQo2rfD+2vLWuT+pBwBqsnrFaBAhChBEATBxP44H8UvJ8ORyeD7TtUopnhGQ81Lv8IBQz8m2syB0k1MVt/hyMNMOTEFgH5V+/FemfdMdu4Xybx4kYj+A5DUapybNaXYlCnITLQ+rKCeClAdXq8ABSJECYIgCCZ0Oy6VsZsvAzCoSRANyhZ9etCDY4aO5AD1BkPNz01WX1hCGCMOjkAn6WhXuh39qvYz2blfJOvGTcJ790HKyMCxbh38Zs9Gls+75k0t7MjD7ABVpUnx1zJAgZlD1IQJE5DJZDm+fHz+2QFbkiQmTJiAr68vDg4ONGrUiKtXr+Z4D5VKxaBBg/D09MTJyYl27doRGRmZY0xSUhIhISEoFAoUCgUhISEkJyfnGBMeHk7btm1xcnLC09OTwYMHo1arjfazC4Ig/NdkqLX0X3eODLWOeqU9GNI06OlBCXcMC8l1aqjQFppNNFl90WnRDNg7gExtJrWL1WZC3QkW88GvfvCA8J490CuVOFStiv+CBcjt7Mxd1jOFHXnI/p+vA4YA9VaHIIv5Pb5s+Yqww4cPz/cbzpkzp0AFVKpUiT179mQ/trL6pz/Id999x5w5c1i9ejVly5Zl8uTJNG/enBs3buDi4gLA0KFD2bp1K6GhoXh4eDBixAjatGnD2bNns9+rS5cuREZGsmPHDgB69+5NSEgIW7duBUCn09G6dWuKFi3KkSNHSEhI4LPPPkOSJObPn1+gn0cQBEF4miRJfP3HFW7GplHUxY55H1fHSp7rgzUjEdZ1gMxE8K0B7y8zWSuDFHUK/ff2Jz4znjJFyjC30VxsrCyjF5QmJobwbt3RPYrHrlw5/JctRe7kZO6ynins6H8nQEE+Q9T58+dzPD579iw6nY5y5Qx3U9y8eRMrKytq1qxZ8AKsrXPMPv2fJEl8//33fPXVV3zwwQcArFmzBm9vb3755Rf69OmDUqlk5cqV/PTTTzRr1gyAn3/+GX9/f/bs2UPLli25du0aO3bs4MSJE9SuXRuA5cuXU7duXW7cuEG5cuXYtWsXYWFhRERE4OvrC8Ds2bP5/PPPmTJlSoF2dBYEQRCetvFMJL+fi0Iug/mdq1PUJdcsik4DGz+HxDug8DdpKwONTsOw/cO4nXwbLwcvFjdbjIuti0nO/SLaxETCu/dA8/AhNoEBBKxcgZVCYe6ynilHgGr8+gcoyOflvP3792d/tW3blkaNGhEZGcm5c+c4d+4cERERNG7cmNatC94l9datW/j6+lKyZEk+/vhj7t69C8C9e/eIiYmhRYsW2WPt7Oxo2LAhx44dAwxhTqPR5Bjj6+tLcHBw9pjjx4+jUCiyAxRAnTp1UCgUOcYEBwdnByiAli1bolKpOHv27HNrV6lUpKSk5PgSBEEQcroWncI3f14BYESLctQp5fH0oJ1j4d5BsHEyBCgX0/RjkiSJ8cfGcyrmFI7WjixsthAfp6f/YW8OutRUwnv2RH33LtbFihH4449Ye3qau6xnyg5Q0uMA1fH1D1BQiDVRs2fPZtq0abi5uWU/5+bmxuTJk5k9e3aB3qt27dqsXbuWnTt3snz5cmJiYqhXrx4JCQnExMQA4O2d8/9I3t7e2a/FxMRga2ubo5ZnjfHyerqviJeXV44xuc/j5uaGra1t9phnmTZtWvY6K4VCgb//czbMFARB+I9KzdLQf905VFo9jcoVpV/D0k8POr0SThm2LeGDZeATbLL6Fl5YyNa7W7GSWTG70WzKu5c32bnzos/MJKJvP1Rh17Bydydg5Ups/PzMXdYzPRmgKv+HAhQUIkSlpKQQGxv71PNxcXEF2qQY4J133uHDDz+kcuXKNGvWjL/++gswXLb7v9z/ISRJeuF/nNxjnjW+MGNyGzNmDEqlMvsrIiIiz7oEQRD+SyRJYszvl7kXn46vwp65Hashz70O6t5h2D7K8H2Tb6BCG5PVt/nWZpZeWgrAN3W+4S2/t0x27rxIajWRg4eQefYschcXAlauwK5USXOX9UzXjuUMUG//hwIUFCJEvf/++3Tr1o3ffvuNyMhIIiMj+e233+jRo0f22qXCcnJyonLlyty6dSt7nVTumaC4uLjsWSMfHx/UajVJSUl5jnlW6Hv06FGOMbnPk5SUhEajeWqG6kl2dna4urrm+BIEQRAMfjrxgG2XorGWy5jfpQZuTrY5ByTeg19DQK+F4I/g7REmq+1Y1DEmHjfc+derci8+LPuhyc6dF0mnI+qLUaQfPozMwQH/pUuwr2C6JqMFce3YQ/b99DhANfrvBSgoRIhasmQJrVu35pNPPiEwMJDAwEC6du3KO++8w6JFi/5VMSqVimvXrlGsWDFKliyJj48Pu3fvzn5drVZz8OBB6tWrB0DNmjWxsbHJMSY6OporV65kj6lbty5KpZJTp05ljzl58iRKpTLHmCtXrhAdHZ09ZteuXdjZ2RVqsbwgCMJ/3cWIZL7dFgbAl++Up2ZgzmUXZKXA+o8Nmwr71oD2C8BEH8A3Em8w/OBwdJKO1qVaM6j6IJOc90UkvZ7oceNI3bkTmY0NxefPx7FGDXOX9UzXjkX/E6Aa+vF2p/9egAKQSZIkFebA9PR07ty5gyRJlClTBqdC3G45cuRI2rZtS0BAAHFxcUyePJmDBw9y+fJlAgMDmTFjBtOmTWPVqlUEBQUxdepUDhw4kKPFQb9+/di2bRurV6/G3d2dkSNHkpCQkKPFwTvvvMPDhw9ZutQwbdu7d28CAwNztDioVq0a3t7ezJw5k8TERD7//HPee++9ArU4SElJQaFQoFQqxayUIAj/WcoMDa3nHyYyKZOWlbxZ8knNnB+weh2s7wy3doJLMei1H1yLmaS2mPQYuv7dlbiMON7weYMlzZZga2X74gONTJIk4qZPJ3HNWpDL8ft+Lq5P3DRlSQwB6to/Aerjsq98gCrs53ehW51GR0cTHR1NgwYNcHBwyNdapdwiIyPp3Lkz8fHxFC1alDp16nDixAkCAwMBGDVqFJmZmfTv35+kpCRq167Nrl27sgMUwNy5c7G2tqZjx45kZmbStGlTVq9enaPf1Lp16xg8eHD2XXzt2rVjwYIF2a9bWVnx119/0b9/f+rXr4+DgwNdunRh1qxZhf31CIIg/CdJksSIjReJTMokwN2R7z6q+vRnw96JhgBlbQ8frzNZgEpTpzFg7wDiMuIopSjF3EZzLSJAAcQvXGQIUECxKVMsNkBdP/5PgAp+TQLUv1HgmaiEhAQ6duzI/v37kclk3Lp1i1KlStGjRw+KFClS4Dv0XidiJkoQhP+65YfuMuXva9hayfm9fz2C/XL1NLqwHv7oa/j+w5VQ+SOT1KXRaxiwZwDHo4/jYe/Butbr8HO2jLvdEtesIXbadAC8x47F/dMQM1f0bNePR7N37T8BqsFrFKAK+/ld4DVRw4YNw8bGhvDwcBwd/2mE1qlTp+yO4IIgCMJ/z5n7iUzfYWi2OK5txacDVMQp2DrY8P3bI00WoCRJYtLxSRyPPo6DtQMLmy20mACVvGlTdoDyHDzo1QhQDV6vAPVvFPhy3q5du9i5cyfFixfP8XxQUBAPHjx4aYUJgiAIr46ENBUDfzmPTi/RrqovXWsH5BygjPxnT7zybaDxVyarbemlpfxx+w/kMjkzG8ykkkclk507Lyk7dhL9zTgA3Lt1w7Of5Wx2/KTrJ3IFqM4iQP1fgWei0tPTc8xA/V98fDx2FroZoiAIgmA8er3EsF8vEpOSRamiTkz9oHLOD1l1umEheXoceAfD+0tNtifeljtbWHhhIQBf1f6Khv4NTXLeF0k7fJioL74AvZ4iHT7Ca9QXFhlMbpyIZu8aMQP1PAX+U9ygQQPWrl2b/Vgmk6HX65k5cyaNGzd+qcUJgiAIlm/RgdscuvkIexs5i7rWwNnuiYscej380Q9iLoGjJ3ReD3bOJqnrRPQJxh8dD0C34G50LNfRJOd9kYyzZ4kcNBg0GlzeaYXPhAkWGUxunIhmz+MAVen/ASp3s9T/uAJfzps5cyaNGjXizJkzqNVqRo0axdWrV0lMTOTo0aPGqFEQBEGwUMfuxDNn900Avm0fTHmfXItyD30HYX+C3AY6/QxFAp7xLi/fraRbDNs/DK2kpVWJVgytMdQk532RzKtXiejTFykrC6cGb+M3YwayJ+4mtxQ3TsbkCFANRYB6pgLPRFWsWJFLly7x5ptv0rx5c9LT0/nggw84f/48pUs/Y08kQRAE4bUUl5rF4PUX0EvQoWZxOtTKtX/o1c1wYJrh+zZzIbCuaerKiKP/3v6kadKo4VWDyW9NRi4zzeXDvKju3iWiZy/0aWk41qpF8XnzkNlaRouFJ904GcOe1WGGAPW2rwhQeShUnygfHx8mTpz4smsRBEEQXhFanZ7B688Tn6ainLcLk9rn2jT44QXY/HihdJ0BUMM0d52la9IZsHcAMekxlHAtwbzG87CzMv96XXVkFOHduqNLSsK+UiWKL1mM3MHB3GU95cbJGPY+GaA6lxMBKg/5ClGXLl3K9xtWqVKl0MUIgiAIr4bv99zixN1EnGytWPRJDRxsn7gklRoLoV1AmwllmkHzSSapSavXMuLgCK4nXsfd3p1FzRZRxL6ISc6dF01cHOHdu6ONjcW2dGn8VyzHytk068IK4v8BSpKgoghQ+ZKvEFWtWjVkMhkv6sspk8nQ6XQvpTBBEATBMu2/EceC/bcBmPZhFUoXfSIQaLJgQ1dIiQKPIENDTatCb46Rb5IkMfnEZI5GHcXeyp4FTRbg7+L/4gONTJecTESPnmjCw7EpXpyAH1di7eb24gNNLEeAesuXRiJA5Uu+/mTfu3fP2HUIgiAIr4CHyZkM33ABgJA6gbSr6vvPi5IEW4dA5GmwLwJdNoBDEZPUtfLKSjbd2oQMGTMazKBy0comOW9edGnphPfug+rWLayLFiVg1Y/YeHubu6yn3DyVK0B1EQEqv/IVov6/l50gCILw36XR6Rn4yzmSMjRU9lPwdZsKOQcc+wEuhYLMCjqsBg/T3Gz0192/mHduHgCj3xxNk4AmJjlvXvQqFZEDB5J16RJWCgUBP67E1t/8M2O53TwVw55VjwNU/WIWHaB0Wg1ZaWk4FbGcmbx8hagtW7bk+w3btWtX6GIEQRAEy/XdjuucC0/Gxd6ahV1qYGf9xDqoGztgt6EnE62mQ2nT9A08HXOab45+A8CnFT+la4WuJjlvXiSNhqhhw8k4cQK5kxP+K5ZjFxRk7rKe8lSA6lreYgOURq1i29zpJEU/pNOE6RYTpPIVot577718vZlYEyUIgvB62nU1huWHDUs7ZnWoSoDHEztXxF2DTT0ACWp2gzd7maSmu8l3GbJ/CBq9huaBzRlRa4RJzpsXSa/n4divSNu3D5mdHcUXL8KhsvkvLeZ28/SrE6DUmRn8MXMyEVcvYW1rR2JUxKsVovR6vbHrEARBECxUeEIGIzZeBKDnWyVpWcnnnxfTE2D9x6BOgxJvw7szwQTdt+Mz4+m3px+p6lSqFq3K1Lemmr0XlCRJxHz7LSlbt4K1NX7zvsfpzTfNWtOzPLmIvIKFB6jMtFQ2T5tA9O0b2Do48P7o8RSvEPziA03kX90ykZWVhb29/cuqRRAEQbAwKq2OAb+cIzVLS42AIox+p/w/L2rV8OunkHQfigRChzVgZWP0mjI0GQzYO4CH6Q8JcAlgfpP52Fub/7Po0Zy5JK8PBZkM3xnTcWnUyNwlPeX68X82E65QvxiNLThApScnsWnKNzwKv4+9swsfjp2ET2nLuixa4Niu0+n49ttv8fPzw9nZmbt37wLwzTffsHLlypdeoCAIgmA+U/66xuUoJW6ONizoUgMbq8cfG5IE20fBgyNg62y4E8/Jw+j1aPVaRh0aRVhCGEXsirC42WLc7M1/aSd+2XISli8HwGfCBBStW5u5oqeFHX2YHaAqNfCz6ACVEh/Hhglf8ij8Pk5F3Og0fprFBSgoRIiaMmUKq1ev5rvvvsP2iXb1lStXZsWKFS+1OEEQBMF8tl58yNrjDwCY06kavkWe6LB9egWcXQXIDL2gvCo8+01eIkmSmH5qOgcjD2JnZcf8JvMJcDXNXnx5SQoN5dGcOQB4ffEFbp0sY6PjJ105FMX+n66DBJUbFadhZ8vdyiUp5iGh40eTFB2Fa1EvOk2cgWdACXOX9UwFDlFr165l2bJldO3aFasnNk2sUqUK169ff6nFCYIgCOZx51EaX24y7FYxoHFpGpfz+ufFuwdg+2jD980mQLlWJqlp9dXVbLixARkypr09jWpe1Uxy3rwkb/qdmImGjuweffvg0aO7mSt62uUDkRz85QYAVZoU5+1OQchMsG6tMOLD77Nh/GhS4x/hVsyPThNm4Obj++IDzaTAa6KioqIoU6bMU8/r9Xo0Gs1LKUoQBEEwn0y1jgHrzpGu1lG7pDvDmpX958WEO/DrZyDpoMrHUH+ISWracX8Hc84aZntG1hpJ88DmJjlvXpR//kn011+DJOEWEkLRIab5XRTExb0RHNl4C4BqzQOo90Fpiw1QMbdvsmnaeLLSUikaWJKPvvoWR0URc5eVpwLPRFWqVInDhw8/9fzGjRupXr36SylKEARBMJ/xW65wPSYVT2c75neujvX/10FlJsMvnSArGYq/AW3nmeROvHOx5xh7eCwAXcp3IaSiaTYzzoty2188HDMWJIkinT/Ge+wYiwsn53eHZweoGi0DLTpARYZdYePkr8hKS6VYmXJ0HDfN4gMUFGImavz48YSEhBAVFYVer+f333/nxo0brF27lm3bthmjRkEQBMFENp6J4Nczkchl8EPnani5Pr7rTa8z9IJKuAWuftBpHdgY/464e8p7DN4/GI1eQ2P/xox6Y5TZg0DKjh08HD0a9HqKdPgIn2++MXtNuZ3b+YDjm+8AUOvdErzZtqTF1fh/9y6cZcusKWg1avwrVeG9L77G1sHxxQdagALPRLVt25YNGzbw999/I5PJGDduHNeuXWPr1q00b27+6VVBEAShcG7EpPLNn1cAGNasLPVKe/7z4u5xcHsPWDvAx7+Ai/H3gEvITKD/nv4oVUoqe1ZmRoMZWMmtXnygEaXs3k3UyC9Ap0Px/vv4TJyITG7e/lS5nfn7XnaAerNtSWq3K2WxAermyaP88d23aDVqStV4gw++nPDKBCgoZJ+oli1b0rJly5ddiyAIgmAm6Sot/dadJUujp0HZogxo/MTa13M/wfEFhu/fXwy+1YxeT6Y2k0H7BhGZFomfsx/zm8zHwdrhxQcaUeq+/UQNHwFaLa7t2lJs8rcWFaAkSeL0tnuc/us+ALXblaLWuyXMWlNerh7cy87F85AkPeXqvs07A0dgZf2v2leaXIH/63fr1o29e/ciSZIx6hEEQRBMTJIkxm6+zN1H6fi42jO3Y1Xk/7/9/cFx2DbM8H3DL6HS+0avR6fX8eWhL7kcfxmFnYLFzRbj4WD8HlR5STt0iKghQ0CjwfXdd/GdNg2ZlXlnxZ4kSRKntv4ToOq+X9qiA9T5ndvYsWgukqQnuHEL3h088pULUFCIEJWQkEDr1q0pXrw4I0aM4Pz588aoSxAEQTCRX06F8+eFh1jJZSzoUh0PZzvDC8nhsOET0GugYntoONok9cw8M5N9Efuwkdswr/E8SipKmuS8z5N25CiRAwchaTS4tGyJ73czLC5AnfjjDmf+vg9A/Y/KUKNloHmLysPJzb+y78clANR4tz0t+gxCbubLtIVV4BC1ZcsWYmJiGD9+PGfPnqVWrVpUrFiRqVOncv/+fSOUKAiCIBjLlSglE7eEATC6VTlqlXA3vKBKg/WdISMefKrAe4vBBJeufgr7iXXX1gEw9a2p1PSuafRz5iX9xAkiBwxAUqtxbtYUv1kzkVnQjIkkSRzbdJtzO8MBeKtjENWamb8B6bNIksThX1ZzJHQtAHU+7EyjT3ta7Hqt/JBJ//K6XGRkJOvXr+fHH3/k1q1baLXal1XbKyclJQWFQoFSqcTV1dXc5QiCIOQpJUtDmx+OEJ6YQbMKXiz/tJbhA02vh19D4Po2cPKC3vtBUdzo9Wy9s5WvjnyFhMSwmsPoHmzexpXpp04R0bsPUlYWzo0bU3ze98ie2KnD3CRJ4sjGW1zaFwlAg4/LUrmR8f87FYak17Nv9VIu7PwLgAafdOeNth+Yuap/FPbz+1/FaY1Gw5kzZzh58iT379/H29v4d2sIgiAI/54kSXyx8SLhiRkUd3Ngdodq/8wIHJhqCFBWtvDxOpMEqB33dvD10a+RkOhcvjPdKnUz+jnzknH2LBF9+yFlZeHU4G38LC1A6SUObbjJlYNRADTqWo5Kb/uZuapn0+t07Fr6A1cP7gWZjOY9B1ClmWm63BtboeZm9+/fT69evfD29uazzz7DxcWFrVu3EhER8bLrEwRBEIzgx6P32Xk1FhsrGQu71EDhaGN44fJvcGim4fu2P4D/m0avZc+DPXx5+Ev0kp4Pgz7kyze/NOslnswLF4jo1RspIwOnevUoPn8+cgsLUAfX3zAEKBk0DilvsQFKp9Wwbd4Mrh7ci0wu590Bw1+bAAWFmIkqXrw4CQkJtGzZkqVLl9K2bVvs7Y3fcE0QBEF4Oc6FJzHt72sAfN26IlX9ixheiDoLfw4wfF9vMFTrbPRaDkYc5ItDX6CTdLQt1ZZxdcchl5mvbUDm5cuE9+yFPiMDx9q1Kb5wAXI7O7PVk5ukl9i/7jrXjkaDDJp+VoHydYqZu6xn0qiy2DJnGvcvnMXK2po2Q7+kzBt1zF3WS1XgEDVu3Dg6dOiAm5ubMeoRBEEQjCgpXc3AdefQ6iVaVy7Gp3Uf38WVEg2hXUGbBUEtDRsLG9mxqGMMOzAMrV5LqxKtmFR/knkD1NWrhPfoiT4tDcdatfBfvAi5g3l7Uz1Jr5fYv/Ya10/EIJNBs24VKfumj7nLeiZVRgZ/fDeJyGtXsLazo/3IrylR5fXbGq7AIap3797GqEMQBEEwMr1eYvivF3iozKKkpxPTP6xsuGymyYTQLpAaDUXLw4crwMi3nJ+KPpW9nUvTgKZMfXsq1nLz3fWWdf064d17oE9JwaFGDfyXLkHuaDmds/U6PXvXXOPmqVhkchnNu1ckqJZlrkPOTE1h09TxxN69ha2DIx98OQG/8hXNXZZRFOpP7OnTp9m4cSPh4eGo1eocr/3+++8vpTBBEATh5Vpy6A77bzzCzlrOwi41cLG3AUmCPwfCw3Pg4AadQ8HeuHcXn4s9x8B9A1HpVDQo3oCZDWZiI7cx6jnzknXzJuHduqNXKnGoWhX/ZUuROzmZrZ7c9Do9u1eFcftMHHK5jBY9K1G6hpe5y3qmtKREfpv8NQmR4Ti4uPLh2El4lyrz4gNfUQWeNw0NDaV+/fqEhYWxefNmNBoNYWFh7Nu3D4VCYYwaBUEQhH/pxN0EZu28AcCk9pWo6Ps4KB2ZA1d+A7k1dFwL7sZtbHnp0SX67+1PpjaTer71mNNoDjZW5gtQqtu3Cf+8G7qkJOwrV8Z/xXKsnJ3NVk9uOp2eXSuvGgKUlYyWvYMtNkClPIpjw4TRJESG4+zmTqcJM17rAAWFCFFTp05l7ty5bNu2DVtbW+bNm8e1a9fo2LEjAQGW2eBLEAThv+xRqorB68+jl+CDGn50rOVveOH6X7B3kuH7d2dCyQZGreNqwlX67u5LuiadN33e5PvG32NnZb5F26q793jweTd0iYnYV6xIwIrlWLm4mK2e3HRaPbuWX+XOuUfIrWW806cypaoVNXdZz5T4MIr140eRHBONwsubThO/w6O4v7nLMroCh6g7d+7QunVrAOzs7EhPT0cmkzFs2DCWLVv20gsUBEEQCk+nlxi64TxxqSqCvJyZ/F6wYR1UzBXY1Msw6I1eUMu4jS1vJN6gz+4+pGpSqe5V3ewbCqsfPCD888/RxcdjV748/itXYGVBV1N0Gj07ll3h7oVHWFnLebdvFUpU8TR3Wc8Ud/8uGyaMJi0hHnc/fzpNnEERb8tc8P6yFThEubu7k5qaCoCfnx9XrlwBIDk5mYyMjJdbnSAIgvCv/LD3FkdvJ+BgY8XiT2rgaGsN6fGGLV006VCyIbSaZtQa7iTfodeuXihVSqp4VmFR00U42phv0bY6IoIHn32ONi4Ou6AyBPy4EmsLuuNcq9Gxfell7l+Kx8pGzrv9KxMYbN4NmJ/n4c3r/DppDBnKZLxKlKbThOm4uFtm2DOGAoeot99+m927dwPQsWNHhgwZQq9evejcuTNNmzYtdCHTpk1DJpMxdOjQ7OckSWLChAn4+vri4OBAo0aNuHr1ao7jVCoVgwYNwtPTEycnJ9q1a0dkZGSOMUlJSYSEhKBQKFAoFISEhJCcnJxjTHh4OG3btsXJyQlPT08GDx781KJ5QRCEV8nhW4/4Yd8tAKZ+EEwZLxfQqg2bCivDwb0UdFgNRlyTdF95n567epKkSqKCewUWN1+Ms6351hypI6N48NlnaGNisC1dmoBVq7B2dzdbPblp1Tr+XnyZB1cSsLaR03pAFQIqWmaACr9yid8mf40qPR3fshXoMG4Kjq6WM5tnCgUOUQsWLODjjz8GYMyYMYwcOZLY2Fg++OADVq5cWagiTp8+zbJly6hSpUqO57/77jvmzJnDggULOH36ND4+PjRv3jx7Jgxg6NChbN68mdDQUI4cOUJaWhpt2rRBp9Nlj+nSpQsXLlxgx44d7NixgwsXLhASEpL9uk6no3Xr1qSnp3PkyBFCQ0PZtGkTI0aMKNTPIwiCYG734tMZGnoBSYLObwbwfvXihjvx/hoO4cfBzhU6bwBH4wWIiJQIeuzqQXxmPGXdyrKs+TJcbc23r6gmOprwzz9H+zAa2xIlCFj1I9aeljNrolHr+GvRJSLCErG2s6LNwKr4l7ecgPeku+dOs3n6BDSqLAIqV+Ojr77F3slyFuSbjFQAGo1GWr16tRQdHV2Qw/KUmpoqBQUFSbt375YaNmwoDRkyRJIkSdLr9ZKPj480ffr07LFZWVmSQqGQlixZIkmSJCUnJ0s2NjZSaGho9pioqChJLpdLO3bskCRJksLCwiRAOnHiRPaY48ePS4B0/fp1SZIk6e+//5bkcrkUFRWVPWb9+vWSnZ2dpFQq8/2zKJVKCSjQMYIgCC/b+fAkqfqkXVLg6G3SO98fkjLVWsMLxxdJ0nhXSZpQRJJu7jJqDVGpUVLzjc2l4NXBUvvN7aX4jHijnu9F1DEx0q3mLaSwcuWlW81bSOqYGLPWk5sqUyNtnn1WWtBnr7R08AEp6maSuUt6ruvHDklzOreTZnVsLW3+7ltJo1KZu6R/rbCf3wWaibK2tqZfv36oVKqXFuIGDBhA69atadasWY7n7927R0xMDC1atMh+zs7OjoYNG3Ls2DEAzp49i0ajyTHG19eX4ODg7DHHjx9HoVBQu3bt7DF16tRBoVDkGBMcHIyvr2/2mJYtW6JSqTh79uxza1epVKSkpOT4EgRBMKf9N+LovOwEielqKvspWNvjTextrOD2Htg51jCoxWQIam60GmLTY+mxswfR6dEEugayvMVyPBzMd0lKExdH+GefowkPx6Z4cQLXrMbG23IaVaqztGxbcJGom8nY2FvRdnA1fIOKmLusZ7q8fxd/zZuJXqejfP2GtB32JdYWtK+gqRW42Wbt2rU5f/48gYGB//rkoaGhnDt3jtOnTz/1WkxMDADeuf6ge3t78+DBg+wxtra2T21B4+3tnX18TEwMXl5P99Tw8vLKMSb3edzc3LC1tc0e8yzTpk1j4sSJL/oxBUEQTOK3s5GM3nQJnV7i7SBPlnxSEyc7a4i/BRu7g6SH6p9Anf5GqyE+M56eu3oSmRZJcefirGixgqKO5rstXxsfT3i37qjv38fG19cQoIpZzl5z6kwtW+dfJOauElsHa9oOropPSctcV3Tu7z/Zv2Y5AFWataJZj/7I5ObbpscSFDhE9e/fnxEjRhAZGUnNmjVxytXVNfe6pueJiIhgyJAh7Nq1K88NjHPv5C1J0gt398495lnjCzMmtzFjxjB8+PDsxykpKfj7v/59MQRBsCySJLH44B2+22Fopvl+dT9mfFgFW2s5ZCbBL51ApQT/OtB6Drzg79DCSsxKpOfOntxPuU8xp2KsbLkSHyfz3equTUwkvFs31HfuYO3jQ8Ca1dj4+ZmtntxUGRq2zr9I7L0U7BytaTekGl6B5lsz9jySJHHy9w0c/fVnAGq1/YAGXbu98LP4v6DAIapTp04ADB48OPs5mUyWHTieXNCdl7NnzxIXF0fNmjWzn9PpdBw6dIgFCxZw44bhL4OYmBiKPfGvhri4uOxZIx8fH9RqNUlJSTlmo+Li4qhXr172mNjY2KfO/+jRoxzvc/LkyRyvJyUlodFonpqhepKdnR12FrS7tyAI/z16vcSkbWGsPnYfgD4NSzG6ZXnkchnotLDxc0i8Awp/6PQzWBvn7yylSknvXb25o7yDl4MXK1usxNfZ98UHGok2KYnwbt1R3bqNtZcXgWtWY2tB/8jNStew9YcLxD1Ixc7JmvZDqlM0wHIaff6fJEkcWreKM1sNW7rV69iVOh98LALUYwWeh7t3795TX3fv3s3+3/xq2rQply9f5sKFC9lftWrVomvXrly4cIFSpUrh4+OT3U4BQK1Wc/DgweyAVLNmTWxsbHKMiY6O5sqVK9lj6tati1Kp5NSpU9ljTp48iVKpzDHmypUrREdHZ4/ZtWsXdnZ2OUKeIAiCJVFpdQwKPZ8doL5pU5Ex71QwBCgwrIG6ewBsnKDzenA2zmW1FHUKvXf35kbSDTzsPVjRcgX+ruYLLDqlkvAePVDduIFVUU8CVq/G9iUsQXlZstI0/Pn9eeIepGLvbMN7wyw0QOn17F25KDtANfq0F3U/7CwC1BMKPBP14MED6tWrh7V1zkO1Wi3Hjh3L91opFxcXgoODczzn5OSEh4dH9vNDhw5l6tSpBAUFERQUxNSpU3F0dKRLly4AKBQKevTowYgRI/Dw8MDd3Z2RI0dSuXLl7IXqFSpUoFWrVvTq1YulS5cC0Lt3b9q0aUO5cuUAaNGiBRUrViQkJISZM2eSmJjIyJEj6dWrF66ulje1KgiCkJKloffaM5y4m4iNlYzZHavRrurjmR9Jgv1T4JTh7zw+WAo+lY1SR7omnX57+hGWEIabnRsrWqygpMK4++/lRZeSQniPnqjCrmHl4UHgqlXYlTJfPbllpqr58/sLJESl4eBiQ/uh1fHws7zWAHqdjh2L5nLtyAGQyWjRexCVm7R44XH/NQUOUY0bNyY6OvqpxdpKpZLGjRvn+3JefowaNYrMzEz69+9PUlIStWvXZteuXbg8sbfR3Llzsba2pmPHjmRmZtK0aVNWr16NlZVV9ph169YxePDg7Lv42rVrx4IFC7Jft7Ky4q+//qJ///7Ur18fBwcHunTpwqxZs17azyIIgvCyxKZk8dmPp7gek4qznTVLQ2pSv8zjfkd6PWz/Ak6vMDxu/i1UaGuUOjI0GfTf059Ljy7hauvK8hbLKeNmvg1ndWlphPfqRdaVK1i5uRGw6kfsyljOBrgZKWr+/P48iQ/TcXS1pf2w6rgXc3rxgSam1Wj4a94Mbp8+gdzKincGjqB8PePuq/iqkkmSJBXkALlcTmxsLEWL5pwWvnnzJrVq1fpP3+afkpKCQqFAqVSKGSxBEIzizqM0Pl15iqjkTDyd7Vjd7Q2C/R7fzaXTwB/94PJGQAatZ8EbPY1SR5Y2i4F7B3Iy5iTONs6saLGCSp6VjHKu/NCnpxPeqzeZ585hpVAQsGY19uXLm62e3NKVKv6ce56kmAwcFba8N6w6bj6WF6A0WVn8OXsKDy6dx8rGhrbDxlC65pvmLsvoCvv5ne+ZqA8++AAwLCL//PPPcyyo1ul0XLp0KXuNkSAIgvDynQ9Povvq0yRlaCjp6cTa7m/i7/54Dzp1hmER+a2dILeG95dC5Y+MUodKp2Lo/qGcjDmJo7UjS5ovMW+Aysggok9fMs+dQ+7qiv+PKy0rQCWr+GPueZJjM3B2s6P90OoU8Tbf3oHPo8pI5/fpE3l4IwwbO3veG/UNAcFVzV2WRct3iFI83t1akiRcXFxwcPhn921bW1vq1KlDr169Xn6FgiAIAvuux9J/3TmyNHqqFlfw4+dv4OH8+B+zWUr45WMIPwbW9tDxJyhrnPUrGp2GEQdGcPThURysHVjUbBFVi5rvg1afmUlEv/5knDmD3NmZgJUrcKhkvkCXW1pSFn/MPY8yLhNndzveG1YDRVGHFx9oYhkpSjZNHUfcvTvYOTnxwZcT8S1rOUHUUuU7RK1atQqAEiVKMHLkyKf6QwmCIAjG8evpCMZsvoxOL9GoXFEWdqlhaKIJkBYHP38AMZfBTgFdNkBgXaPUodVrGXVoFAcjD2JnZcf8JvOp6W2+O5j1KhWRAwaScfIkcicnAlYsx6GycRbQF0ZqYhZ/zDlHSnwWLh72vDesOq6elheg0hIT2Dj5axKjInBwVfDRV9/iVaKUuct6JRR4TZTwfGJNlCAIL5MkSSzcf5tZu24C8GGN4kz/sDI2Vo+70ySHw9r3DH2gnIrCJ79Dsfw1PC4onV7HmMNj2H5/OzZyG+Y3mU99v/pGOVd+6NVqIgcMJP3wYWSOjgSsWI5jjRpmqye3lPhM/ph7ntSELFw97XlveA1c3J/fWNpclHExbJz8NcrYGJw9POnw9WTcfYubu6xnkiQJSaVDbl/ge+JeyOhrogRBEATT0eklJm69ytrjhm2u+jcqzRcty/3To+fRDfjpfUiJAkUAfPoHeJQ2Si16Sc+4Y+PYfn871jJr5jSaY9YAJanVRA0eYghQ9vb4L1lsUQFK+SiDP+aeJy1RhaKoA+8Nr46zm+UFqITICH6b/BVpSYkU8S7GR19PRuFlOXsKPknS6kn6/Raa6HSK9q2C3M4y4otlVCEIgiBky9LoGLbhAtuvxCCTwfg2Ffm8/hO9jqLOwc8fQmYieJaDkM2gMM52JnpJz6Tjk9hyZwtWMiu+a/gdjfwbGeVc+SFpNEQOH07agQPI7OzwX7IYpzct5+6x5NgM/vz+PGlJKop4O/LesOo4FbG8nS1i791h05RvyExNwaN4AB99PRlnN3dzl/VM+iwtCT9fQ3U7GeSgupeCQ3nLqFWEKEEQBAuizNTQa+0ZTt1LxNZKzpxOVWlT5YntU+4dgvWdQZ0GvtWh6yZw8jBKLZIkMe3kNDbd2oRcJmfqW1NpHtjcKOfKVz1aLVEjvyBtz15ktrYUX7QQpzp1zFZPbkkx6fwx9zwZSjVuPo60H1YdJ4XlBajwK5f4c9Zk1JkZeJcK4sOxE3FwscwlKFqlioRVV9DEZCCzlePetQIO5SwjQMG/DFFZWVl5bh4sCIIg5F+M0tBE80ZsKi521iz9tCb1Snv+M+D6X7CxG+hUUOJtw1YudsbZLkSSJGadmUXojVBkyJhUbxLvlnrXKOfKVz1aLQ9HjSZ1505kNjYUXzAf5/rmu6SYW+LDdP74/jyZKWrcfZ1oP7Q6jq625i7rKdePHmT7wrnodVqKVwjmvVHjsHO0vHYLAOrodBJWXUGXokbuYoPn58HYWlh39wLvnafX6/n222/x8/PD2dk5e7+8b775hpUrV770AgVBEP4Lbsel8sGio9yITcXLxY4NfermDFAX1sOGEEOAKtcauv5m1AD1w/kfWBu2FoBxdcfRvkx7o5wrX/XodDwcO5aUv/8GGxv85s3DuYHldNBOiErjj7nnyExR41HcmfeGW16AkiSJM1t/568fZqLXaSlb5y0+HDvJYgNU1q0kHi25iC5FjbWXA179q1lcgIJChKjJkyezevVqvvvuO2xt//lDUrlyZVasWPFSixMEQfgvOPsgiY+WHOehMotSnk5s6lePir5PXF45sRj+6AuSDqp2gY5rwcZ4VwGWXFzCisuGv8/H1h7LR2WN07QzPyS9nuivvyFly1awtsZvzmxcmjQ2Wz25xd5L4Y8558lM1eDp78x7Q6vj4GxhAUqv58Ca5Rz8+UcAarzbnjZDRmFta1l1/l/6mVjiV11FUumwLanAq29VrC1wYT4U4nLe2rVrWbZsGU2bNqVv377Zz1epUoXr16+/1OIEQRBed3vCYhm43tBEs5p/EX78/A3cnR5/uEkSHJgGB2cYHtfuBy2ngrzA//7NtxWXV7Do4iIARtYaSefynY12rheR9Hpixo9HuXkzWFnhN2sWrs3NtyYrt/uX49m5/ApatR6vQBfaDq6GvZONucvKQatWs33hHG6eOAJAw0+6U6vtB2au6tkkSSJ1bzgpe8IBcKhaFPcOZZFZG+/P+79V4BAVFRVFmWds6KjX69FoNC+lKEEQhP+C0FPhjN18Gb0EjcsVZWHXGjjaPv5rWa+HHV/CqaWGx42/ggZfwP9bHBjB2qtrmXduHgBDagzhs0qfGe1cLyJJEjHffkvyxt9ALsf3uxm4tmpptnpyCzv6kAPrbiDpJQIqutOydzC2Ruhf9G9kpaXx56zJRF67gtzKmlYDhlGhfkNzl/VMkk5P0ubbZJyJBcClYXFcW5ZAJjfen/eXocD/xStVqsThw4cJDAzM8fzGjRupXr36SytMEAThdSVJEvP33WbObkMTzQ41izP1gyeaaOo08OcAuLTB8PidmVC7t1FrCr0eyswzMwHoV7UfPSsbZ+Pi/JAkidgpU0leHwoyGb7Tp6Fo3dps9TxJkiTObr/PyS33AChXx4fGIeWxsrKs2ZKU+Ef8Pm08CZHh2Do40n7kVxa7D55epSVh3XVUN5NABkXal8a5ju+LD7QABQ5R48ePJyQkhKioKPR6Pb///js3btxg7dq1bNu2zRg1CoIgvDZ0eolxf15h3UnDJYuBjcswokXZf5poajINGwnf3AEyK3h/CVTpaNSaNt3cxJSTUwDoEdyDflX7GfV8eZEkibjpM0j6+WeQySg2ZQqKdu3MVs+T9HqJQ6E3uXooCoAarQKp077UP//tLMSj8Pv8Pm08aYkJOLu588GYiRQNLPniA81Al6IiftVVNNHpyGzkuHcpj0MF47TsMIYCh6i2bduyYcMGpk6dikwmY9y4cdSoUYOtW7fS3IKuVQuCIFiaLI2OIaHn2Xk1FpkMJrarxKd1SzwxQGnoAfXgqGEj4Q5roFwro9a05c4WJh6fCEBIxRCG1BhitlAgSRKPZs8mcc0aAHwmTaTIB++bpZbctGodu1Ze5d7FeJDB2x3LUqWx5W2P8mQPKI/iAXwwZgKunl7mLuuZNLHpxP94FZ1ShdzZBs/PKmHrb5w7To1F7J33Eom98wRBeB5lhoaea09z+n4StlZyvv+4Gu9WLvbPgPR4w0bC0RfBzhU6h0IJ4/ZB2nFvB6MPj0Yv6fm43MeMrT3WfAFKqyVm4iSSN24EwGf8ONw6m29R+5Oy0jX8tfASMXeVWFnLad69IqVrWF4wuX70IDsWzUWn1eJXvhLvffEN9s6W1xYAIOtOMgk/hSFl6bAu6oBnt2Cszbi3oMn2zjt9+jR6vZ7atWvneP7kyZNYWVlRq1atgr6lIAjCa+1hciafrzrFzdg0XOytWf5pLeqUeuKSRXKEYR+8hFvg6AmfbALfakatac+DPXx5+Ev0kp4Pgz5kTO0xZgtQ+vR0IocPJ/3gIZDL8Rn3DW4ff2yWWnJLSchk2/yLJMVkYOdozbv9quAbVMTcZT3lzLbNHPzJ0KuxbO36vDNwhMW2MMg4H0fibzdBJ2FbwhWPkIpYWdhdjflV4JVwAwYMICIi4qnno6KiGDBgwEspShAE4XVxKzaVDxcf42ZsGt6udmzsWzdngIq/BT+2MgQo1+LQfYfRA9TBiIN8cegLdJKOtqXaMq7uOOQy8yyM1sbH8+DTz0g/eAiZvT3F5/9gMQEqPjKN3787S1JMBs5udrw/sobFBShJr2f/muXZAarGO+1oM3S0RQYoSZJI2R9O4oYboJNwqOJJ0R6VX9kABYWYiQoLC6PGM3bLrl69OmFhYS+lKEEQhNfBmfuJ9FhzBmWmhtJFnVjT/U2Kuz3RIfrhBcMlvIwE8AiCT/8AhXHX2RyNOsqwA8PQ6rW0KtGKSfUnmS1Aqe7eI6J3bzSRkVi5ueG/eBEO1aqZpZbcom4k8ffiS6izdLj7OtFmYFVczHi56Vm0ajXbF83l5vHDgKEHVM0271vcQncASSeR/Odt0k/FAODcwA9Fq5IW38LgRQocouzs7IiNjaVUqVI5no+Ojsba2rJ6ZAiCIJjLzqsxDF5/HpVWT42AIqz87A3cnJ6YHbh/BH75GNSpUKwqfPI7OHk+/w1fgpPRJxmyfwgavYamAU2Z+vZUrOXm+Xs749w5Ivv1R6dUYhMQQMDyZdjmap1jLrfOxLJndRh6rYRvUBHe6VvZ4ppovko9oPQqHYm/XCPrxuMWBm1L41zv1Whh8CIF/n9P8+bNGTNmDH/++ScKhQKA5ORkxo4dK+7OEwRBANadfMA3f1xBL0GzCl7M71wDB1urfwbc2G5oY6DNgsC3DBsJ2xv3ZpSzsWcZtG8QKp2KhsUbMrPBTGzk5gkGKTt38fCLL5DUauyrVMF/yWKs3d3NUktuF/dGcOS3WyBB6epFada9ItY2Vi8+0IRepR5QulQ18auvoolKA2s5Hp3L4VDJuP9YMKUCh6jZs2fToEEDAgMDs5trXrhwAW9vb3766aeXXqAgCMKrQpIkvt9zi3l7bwHQqZY/U94PxvrJRowXN8Af/Qz74JV9BzqsAhsHo9Z18dFF+u/pT6Y2k3q+9ZjdaDY2VuYJUIlr1xI7bTpIEs6NG+M3ZzZyB+P+/Pkh6SWObb7Dhd2G/l2VGxXnrY5ByC3sctOr1ANKE5dB/I9X0CWrkDtZ4/FZJewCXq871wscovz8/Lh06RLr1q3j4sWLODg40K1bNzp37oyNjWVNdwqCIJiKVqfnmz+vsv6U4UN4cJMyDGteNuf6lJNLYfsow/dVOkH7hWDkMHM14Sr9dvcjQ5vBmz5vMq/xPOys7Ix6zmeR9HrivptJ4urVABTp/DE+X3+NzMr8szw6rZ59a69x85Rhy5E675WiRstAi1tb9Cr1gFLdVRL/UxhSphZrD3tDCwNP84fll61QF8OdnJzo3du4WxAIgiC8KrI0OgatP8/uMEMTzUntgwmp88T6HkmCg9/BgamGx2/2gVbTjbqRMMCNxBv02d2HVE0qNbxqML/JfOytTb84Wq9S8XD0l6Tu2AFA0RHD8ejZ0yJCijpLy/Yll4m8noRcLqPxp+UpX6fYiw80sVepB1TGxTgSf33cwiDABY/PKr3Sd+DlpVAh6ubNmxw4cIC4uDj0en2O18aNG/dSChMEQXgVJGeo6bHmDGcfJGFrLeeHj6vRKviJD2G9HnaOgZNLDI8bjYGGo426kTDA5UeXGbhvIEqVkiqeVVjYdCGONo4vPvAl0yUnEzFgIJlnz4KNDb5Tp6Jo28bkdTxLulLFtgUXiY9Iw9rOila9gwmsZHlbjrwqPaAkSSLtUBTK7YZ9Be0reeDxcTlkFram7GUqcIhavnw5/fr1w9PTEx8fnxz/kvj/NjCCIAj/BQ+TM/n0x1PcjkvD1d6aFZ+9wZsln1ggrdPCloFwcb3hcasZUKev0evadncb44+OR61XU9GjIoubL8bZ1vSzFurIKCJ690Z99y5yZ2eKL1iAU53aLz7QBJJjM9g6/wIp8Vk4uNjQZmBVvAIta72OpNdz4KeVnPv7T8DQA6rRpz2RGXkGszAkvUTyljukn4gGwLm+L4rWpV75FgYvUuAQNXnyZKZMmcLo0aONUY8gCMIr4UZMKp/9eIqYlCx8XO1Z0/1Nyvk8se+XJgt+6wY3/jZsJPzeIqhq3CaSeknPD+d+YOUVw6xFo+KNmPb2NLMEqMyrV4no2xfdo3isfXzwX7YU+7JlTV7Hs8TcU/LXwktkpWlwLepAu8FVURQ1/SxdXl6lHlB6tY7E9dfJupYIMlC0LoXLW37mLsskChyikpKS6NChgzFqEQRBeCWcvJtAr7VnSMnSUsbLmbXd38S3yBOLZrNSILQL3D8MVnbQYTWUf9eoNaWp0xhzeAwHIg8A0LNyTwZVH2SWRppphw8TOWQoUkYGduXK4b9sKTbe3iav41nuX4pn5/IraDV6vAJdaD2gKo6ulnVp7FXqAaVLVRO/5iqaSEMLA/dO5XCs/Pq0MHiRAoeoDh06sGvXLvr2Nf6UtCAIgqXZcSWawaEXUGv11Ap0Y8VntSji+MSHcHo8/PwhRF8AWxdDD6iSbxu1pojUCAbvG8zt5NvYym2ZWH8ibUqZZ91R8qZNRI8bDzodjnXrUPyHH7BycXnxgSYQdvQhB9bdQNJLBFRyp2WvYGztLatJ9KvUA0rzKIP4VVfRJWYhd3zcwsDCLokaW4H/9JQpU4ZvvvmGEydOULly5afaGgwePPilFScIgmBJfjrxgHF/XkGSoHlFb+Z3ro79k4tmlZGGjYTjb4KDu2EjYb+nt8l6mU5Fn2L4weEoVUqKOhTlhyY/EOwZbNRzPoskScQvWEj8woUAKNq3o9i33yKzgAXQkiRx5u/7nNpqWPBcvo4PjULKY2VlWWuLXqUeUKr7ShLWhqHP0GLlbo9nt0rYWNglUVOQSZIkFeSAkiWf/x9UJpNx9+7df13UqyolJQWFQoFSqcTV9b+VxgXhdabXS8zdc5P5+24D0PnNAL5tXylnE8342/DTe6CMAFc/CNkMRcsZta4N1zcw/dR0tJKWYI9g5jWZh5ej6fsGSRoN0eMnoPz9dwA8+vah6JAhFrF+R6+XOLT+BlcPPwSgZqtAarcvZRG1PelV6gGVcfmRYRNhrYSNvwuen1XEytn8YfnfKOznd4Fnou7du1fQQwRBEF5Zx27HM237dS5HKQEY2iyIIU2Dcn4IR1+Enz6AjHhwL23YSLhIgNFq0ug1zDg1gw03NgDwbsl3mVhvoll6QOnS0okaOpT0I0dALsdn/HjcOnU0eR3PolXr2LXyKvcuxoMMGnQqS+VGxt3guTCuHzvEjoVzXokeUKmHo1D+fRcksK/gjnvn8shtX98WBi9iWReDBUEQLMS16BSmb7/OwZuPAHCytWJc24p0eiNXOHpwDH7pBKoU8KkMn2wG56JGqys5K5kRB0dwKuYUMmQMrjGYHsE9zDKzoomLI6JvX1Rh15A5OOA3ZzYujRubvI5nyUrT8NeiS8TcVWJlLad5j4qUrm55MzuvTA8ovYTyr7ukHTXM6DnVLUaRtqVf+xYGL1KoEBUZGcmWLVsIDw9HrVbneG3OnDkvpTBBEARzeJicyexdN/n9fCSSBNZyGV1rBzCoaRCezrm2S7m5E3791LCRcEA96BIK9gqj1XY76TaD9g0iMi0SR2tHZjSYQSP/RkY7X15Ud+4Q3qsX2ofRWHl44L9kMQ6VK5ulltxSEjLZNv8iSTEZ2Dla826/KvgGFTF3WTlIej0Hf17J2b9egR5QGh0JoTfIupoAgOLdkji/7Wdxl0TNocAhau/evbRr146SJUty48YNgoODuX//PpIkUaOGcRdQCoIgGIsyU8OiA7dZdfQ+aq1hJ4bWlYvxRctylPB0evqASxvhj76g10JQS0MbA1vjLaw9GHGQ0YdHk65Jx8/Zj/lN5hPkFmS08+Ul4/RpIgYMRJ+Sgm1gIP4rlmPr72+WWnKLj0xl6/yLZCjVOLvZ0WZQVTx8LevSmFajYfvCOa9EDyhdmpqEtWGow1PBSoZ7x3I4VjXeTOurpsAhasyYMYwYMYJJkybh4uLCpk2b8PLyomvXrrRq1coYNQqCIBiNSqvjp+MPmL/vNspMDQBvlnRnzDvlqR7g9uyDTi2Hv78AJKjcAd5bbLSNhCVJ4scrPzLv3DwkJN7weYPZDWfjZv+c2owsZft2Ho4ajaTR4FCtGsUXL8LazTy15BZ5I4ntiy+hztLh7utE20FVcXYz/TqxvGSlP+4BFWb5PaC08ZnEr7qCNiELmYM1np9WxK6k8WZaX0UFDlHXrl1j/XrDFgbW1tZkZmbi7OzMpEmTaN++Pf369XvpRQqCILxser3ElosPmbXrBpFJmQAEeTnz5TvlaVLe69mzApIEh2bB/smGx2/0gne+M9pGwiqdignHJrDt7jYAOpbtyJe1v8RGbvrNXCVJInHVauK++w4Al+bN8J05E7m9ZYSUW2di2bM6DL1WwjeoCO/2q4ydo2Vtevsq9YBShaeQsOYq+nQtVm52eHYLxsbrv9fC4EUKHKKcnJxQqVQA+Pr6cufOHSpVqgRAfHz8y61OEATBCI7cimfa9mtcfZgCgLerHcObl+XDGsVzti14kl4Pu76GE4Y+SDQYBY3HGm0j4biMOIbuH8rl+MtYyaz48s0v+bi8cbeNeR5JpyN2+gySfvoJALeQELy/HI3MyjLuyrq4N4IjG28BULpGUZp1q4i1hW16+yr1gMq8Ek9C6A3Q6rHxc8bz80pYuVjeYndLUOB/PtWpU4ejR48C0Lp1a0aMGMGUKVPo3r07derUKdB7LV68mCpVquDq6oqrqyt169Zl+/bt2a9LksSECRPw9fXFwcGBRo0acfXq1RzvoVKpGDRoEJ6enjg5OdGuXTsiIyNzjElKSiIkJASFQoFCoSAkJITk5OQcY8LDw2nbti1OTk54enoyePDgpxbNC4Lwagt7mMKnP57ik5UnufowBWc7a75oWY4DIxvT6Y2A5wconcawkfD/A1TLadDkK6MFqKvxV+m8rTOX4y+jsFOwtPlSswUofVYWUUOHZgcor9Gj8R47xiIClKSXOPrbrewAVblxcVr0DLa4ABVx9RIbxo8mLTEBdz9/Ok+eZbEBKu1oFAnrroFWj315d4r2riICVB4KPBM1Z84c0tLSAJgwYQJpaWls2LCBMmXKMHfu3AK9V/HixZk+fTplypQBYM2aNbRv357z589TqVIlvvvuO+bMmcPq1aspW7YskydPpnnz5ty4cQOXx9sIDB06lK1btxIaGoqHhwcjRoygTZs2nD17FqvH/yfv0qULkZGR7NixA4DevXsTEhLC1q1bAdDpdLRu3ZqiRYty5MgREhIS+Oyzz5Akifnz5xf0VyQIgoWJSs5k9q4bbD4fhSSBjZWMrrUDGdSkDB6577jLLe4abO5j6AUlk0O7BVC9q9Fq/fvu34w7Ng6VTkUpRSkWNFmAv6t5Fm1rk5KI7NefzAsXkNnY4DtjOq7vGncPwPzSafXsXXONW6djAaj7fmmqtwiwuMXZuXtAtf/iaxycLWMbnCdJegnl3/dIOxIFgFNtH4q0K4PMyrJ+n5amwB3Ljc3d3Z2ZM2fSvXt3fH19GTp0KKNHjwYMs07e3t7MmDGDPn36oFQqKVq0KD/99BOdOnUC4OHDh/j7+/P333/TsmVLrl27RsWKFTlx4gS1a9cG4MSJE9StW5fr169Trlw5tm/fTps2bYiIiMDX1xeA0NBQPv/8c+Li4p7bvVSlUmVf2gRDx1N/f3/RsVwQLIQyQ8PCA7dZfeyfO+7aVDHccRfo8Yw77p6k18GJRbD3W9CpwL4IvL8Eyr1jlFr1kp4F5xew/PJyABoUb8CMt2fgbGueO8vUERFE9OqN+v595K6u+C9cgOMbb5illtzUmVq2L71M5PUk5HIZTT4tT7k6xcxd1lNemR5QGj2Jv94g87JhSY5rqxK4NCxucYHUmArbsbzAl/NKlSpFQkLCU88nJydTqlSpgr5dNp1OR2hoKOnp6dStW5d79+4RExNDixYtssfY2dnRsGFDjh07BsDZs2fRaDQ5xvj6+hIcHJw95vjx4ygUiuwABYZLkgqFIseY4ODg7AAF0LJlS1QqFWfPnn1uzdOmTcu+RKhQKPC3kFt8BeG/LkujY9mhOzSYuZ9lh+6i1uqpU8qdPwfUZ0GXGi8OUEn3YXUbwxoonQrKNIf+J4wWoNI16QzdPzQ7QHUL7sYPjX8wW4DKvHyZ+x93Rn3/Pta+xSjxyzqLCVDpShWb55wj8noS1nZWtB5QxeIClKTXc2Dt8uwAVf2dtrQeOsoiA5QuXcOjFZcNAcpKhvvH5XBt5P+fClD/RoEv592/fx+dTvfU8yqViqioqAIXcPnyZerWrUtWVhbOzs5s3ryZihUrZgccb2/vHOO9vb158OABADExMdja2uKW6/Zab29vYmJissd4eT3dpdbLyyvHmNzncXNzw9bWNnvMs4wZM4bhw4dnP/7/TJQgCOah10v8eTGKWTtvEpVsuOOurLczY96pQKNyRV/8wSBJcG4N7PwK1Glg6wwtp0CNz4y2/ikyNZJB+wZxO/k2tnJbJtSbQNvSbY1yrvxIPXCAqGHDkTIzsatYAf8lS7B5xt+h5pAcm8GWHy6QmpCFg4sNbQZWxSvQsmb9c/eAavBJd2pZaA8obUIm8auvon2UiczeCo+QitiXLmLusp7r8uXL3L9/nzZt2ljM7zPfIWrLli3Z3+/cuROF4p9eETqdjr1791KiRIkCF1CuXDkuXLhAcnIymzZt4rPPPuPgwYPZr+f+RUmS9MJfXu4xzxpfmDG52dnZYWf3gvUUgiCYxOFbj5j293XCog133Pm42jO8heGOO6v8bE2RGgNbBsGtXYbHAfXgvUXgbrwFwKdjTjP8wHCSVcl4Ongyr/E8qhStYrTzvUjShl+JmTgR9Hqc3noLv++/x8r5BbN2JhJzV8lfCy+Rla5BUdSBtoOroihqWbfcP9UDqv9QKrzVyNxlPZM6IpX4NVfRp2mwUtjh2b0SNt6W8d86N71ez/79+zl82BBMS5Uqld0VwNzyHaLee+89wBA2Pvvssxyv2djYUKJECWbPnl3gAmxtbbMXlteqVYvTp08zb9687HVQMTExFCv2z1RtXFxc9qyRj48ParWapKSkHLNRcXFx1KtXL3tMbGzsU+d99OhRjvc5efJkjteTkpLQaDRPzVAJgmBZrkQpmbHjOodvGdZzuNhZ069xabrVK4lDfjdGvbIJ/hoBmUlgZQdNv4E6/UFuvLu8Nt7cyNQTU9FKWip6VGRe43n4OPkY7Xx5kSSJR/PmkbBkKQCKDz6g2MQJyGwso8/S/Uvx7Fx+Ba1Gj1egC60HVMXR1bIujb1KPaAyLj0iaeNNJI0em2JOeHarhJWrZU4IqFQqNm/ezPXr1wF46623qFChgpmr+ke+Q5Reb1iUWbJkSU6fPo2np6dRCpIkCZVKRcmSJfHx8WH37t1Ur14dALVazcGDB5kxYwYANWvWxMbGht27d9Oxo2HX8OjoaK5cucJ3jxvC1a1bF6VSyalTp3jzzTcBOHnyJEqlMjto1a1blylTphAdHZ0d2Hbt2oWdnR01a9Y0ys8pCMK/E5mUwexdN9l83rCMwMZKRkidEgxsUgZ3p3x+wGYkGsLT1d8Nj4tVhfeXgpfx/pLW6DXMPD2T9dcNTYvfKfEOk+pPwt7aPE0rJbWa6G++Qfmn4WqD54ABeA4cYDGXS8KOPOTAuutIEgRU8qBlr0rY2hdq21ejeVV6QEl6iZS94aTuDQfAvpwb7l3KI7ezrN/n/yUnJ7N+/XpiY2OxsrKiXbt2VK1qWcG0wL+5e/fuPfVccnIyRYoUKfDJx44dyzvvvIO/vz+pqamEhoZy4MABduzYgUwmY+jQoUydOpWgoCCCgoKYOnUqjo6OdOnSBQCFQkGPHj0YMWIEHh4euLu7M3LkSCpXrkyzZs0AqFChAq1ataJXr14sXWr4V1bv3r1p06YN5cqVA6BFixZUrFiRkJAQZs6cSWJiIiNHjqRXr17iLjtBsDDJGWoW7r/NmmMPUOsM/7hrV9WXkS3KEeBRgMs7N3cZej+lxYLMChqMhAZfGG37FgClSsmIAyM4GWOY+R5UfRC9KvcyW2DRpaYSOXgwGcdPgJUVxSZOoMhHH5mlltwkSeLM3/c5tdXwmVO+rg+NPimP1fN6eZnJvQtn2fb9DNSZGbj7+fPh2Im4elrGGrIn6dU6kjbezL4Dz/ktPxTvlkSWn0vdZhAeHk5oaCgZGRk4OTnx8ccfW+Sa4wKHqBkzZlCiRInslgIdOnRg06ZNFCtWjL///rtAKTE2NpaQkBCio6NRKBRUqVKFHTt20Lx5cwBGjRpFZmYm/fv3Jykpidq1a7Nr167sHlEAc+fOxdramo4dO5KZmUnTpk1ZvXp1do8ogHXr1jF48ODsu/jatWvHggULsl+3srLir7/+on///tSvXx8HBwe6dOnCrFmzCvrrEQTBSLI0OtYcu8/C/bdJydICULeUB2PeLU+V4kXy/0aqVMPC8XNrDI89yxpaF/gZd9b5bvJdBu4bSERqBA7WDkx/ezpNApoY9Zx50cTGEtG7D6obN5A5OlJ83vc4v/222ep5kl6n52DoTcIOPwSg5juB1G5XymJmx8AQ8s7+9QeHfl6FJOktugeUVqkiYW0Ymqg0sJLh9l4ZnN4wz6Xj/Dh//jxbt25Fr9fj4+ND586dc6zDtiQF7hNVqlQpfv75Z+rVq5d9GW3Dhg38+uuvhIeHs2vXLmPVavEK22dCEITn0+kl/jgfxZzd/9xxV97HhdHvlKdR2Xzccfek+0fhj36QbLjDlzr9oek4sHEwQuX/OBR5iFGHRpGuScfP2Y8fmvxAWbeyRj1nXrJu3iSidx+0MTFYFfXEf8kSHCxkoa5GrWPXiqvcvxQPMmjQqSyVGxU3d1k5aNVq9qxYyNWDewGo3KQFTXv0w8raMtaQPUkVnkLCT2HoUzXInazxCKmIXQnLDCR6vZ7du3dz/PhxwHAl6f3338fWBK0hCvv5XeCZqOjo6OwptW3bttGxY0datGhBiRIlcvRiEgRB+DckSeLQrXimb7/Otcd33BVT2DO8eVk+yO8dd/+nyYJ938LxhYAEigDDnXcljTvzIkkSq6+uZu7ZuUhI1PSuyZxGc3C3dzfqefOSfuIkkYMGoU9NxbZUKfyXLcO2uJ/Z6nlSRoqa7UsuEXM3BStrOS16VKJU9aLmLiuH9OQk/pw1mehbN5DJ5TT6tBfVW1nOLfdPSj8fR9Kmm6CVsPFxxOPTSli7W8aG0bllZWWxadMmbt0ybOHTsGFDGjZsiNxIm3u/LAUOUW5ubkRERODv78+OHTuYPNmwm7kkSc/sHyUIglBQV6KUTNt+jaO3DY19Xeyt6d+oDN3ql8C+oPuiPTwPm/vCI8PdPVT/xLD3nb1xZ4tVOhUTj01k613D9lIflf2IsW+OxcaIa65eRLl1Gw/HjoX/tXff4VFUXwPHv7vZ9N4rIQmQEEjovRdpUgUpogg/O2JBQWkqqDQBsStWwAoivYNI752QSkkI6aT3rfP+MSQvJSBGYCd4P8/Do5vsJmcyuzt37z33HL0e2xbNqfX551hUI5/1Xsi6VMjmRVEU52mxttPw8IuN8KvrYu6wrpN58TxrFsykOCcbG3sH+o2fTO1GTcwd1k0kk0ThtiSKdsl9ZG3C3XAbEabYBPLc3Fx+/fVXsrOz0Wg0DBo0iIiICHOHdUf+8V908ODBjBw5knr16pGTk0OfPnIF31OnTlWWKhAEQaiOy7mlLNgWz9pTci6MlYWaJ9vWZlzXurje6Y67CkY97F0Ie+aByQD2XjDg03tWdfxaV0qvMH7neM5kn8FCZcGbLd/ksfqPmW22QpIkcr79jisLFwLg2Ls3fh/MRa2QOnfxh9LZ+Us8Rr0JF287Hh4biauPsmoWxR3Yw9avPsGg0+LmF8CgN9/G1VcZM3jXMmkN5C6Lpzw2FwDHLrVw6llbsQnkiYmJ/P7775SVleHo6Mhjjz12XfcQpfvHg6iPPvqIoKAgLl++zLx583BwkNsSpKen8+KLL971AAVBePDllej4fOd5fjr4/zvuBjXxY0LPMGq5VaOg4pV4uWlw2kn5doOB0PcjsHe/i1FXLTonmlf+eoWs0iycrJz4sMuHtPFtc89/761IRiMZM2eS/9syANzGjMHrzTdQKWCZxGQ0cWDVBU7vuAxAUKQ7Dz3VEGtb5cyYSCYTB1b8wqFVywEIbtqCvq+8gbWdsgZ5AIbccnJ+jEafUQoaFW5DQrFrqrydghWOHTvGpk2bMJlM+Pv7M2LEiOs2jtUEimtAXJOJxHJB+GfK9UYW70/iy13nKbq64659XXem9Aknwr8aya8mExxeBDveBUM52DjDwx9C5KP3rG3LtbYkbuHt/W9Tbiwn2DmYz7p9Rm2n2vf8996KqayM1AkTKf7rL1Cp8J4yGbcnnzRbPNcqK9ax9dtoUuPzAGjxcBCt+ilry72uvIzNn3/I+aOHAGjRfzAdR45GfQ+LsFaXNrGAnJ9jMJUYUDtaygnkgcq8DhmNRrZu3cqRI0cAiIyMZMCAAViasbjrPU0sX7duHX369MHS0vK69i9VGTBgwB3/ckEQ/puMJolVJ1JYuD2B9IJyAMJ9nZjcpz6d6nlUb9kr7xKsHQdJcmsI6nSHgZ+D071fGjBJJr449QXfnPkGgI7+Hfmg0wc4WpnvU7U+K4uUl1+m/PQZVNbW+M2bh1Ovnn//wPsgO6WITV9FUZRTjsbagodGh1OnmbJmTAqyMlgzfybZyUlYaDT0eO5lGnbubu6wqlRyNIO8NefBKGHp74D7kw3QOCtjqfZGZWVlrFixgosXLwLQvXt3OnTooMjE/DtxRzNRarW6spHv7TLlVSrVfzq5XMxECcLtGU0SW6Mz+HTHOeIyigDwc7ZhQs8wBjX1/2c77ipIEpz8CbZMBV0RWNpBz5nQ4qn7MvtUqi9l6r6p7EiWt7uPaTiG8c3GY2HG2YqSw0dInTABY3Y2Fs7OBHz1JXbNmpktnmudO5bJXz/GYtCZcPKw4eGxjXD3dzB3WNe5HBPF+oVzKCsqxN7FlQETpuEXWt/cYd1EMkoUbE6keJ9ctd820gPXoaGo77Td0X125coVfvvtN3Jzc7G0tGTIkCHUr6+Mv+s9nYmqaPly4/8LgiDcCa3ByKoTqXyz5yKJ2SUAONloGNe1LqPbVWPHXYWiTFj/CiRskW/XagOPfAVuIXcp8ttLLU7l5b9e5lzeOSzVlkxvO52BdQfel99dFclkIue777ny8cdgMmEdGkrAp59gVY3m8HebySRxeO1FTmyVa3TVauBGz6cbYmOvrNpKZ/7cwo4fvsJkNOIdUpeBE9/C0f3etDn7N0zlBnJ+jUObIC+HOj0UiGP3QMXO6Jw/f54VK1ag1Wpxdnbmsccew8dHuQU/75RysvcEQXjgFJXr+eVwMj/sSySrSAuAs60lo9sF8VT7IFzs/kURveg1sOE1KMsFCyvoOg3avXxPmwZf61jGMV7f9Tp52jzcbdz5pNsnNPY0X18vY0EBaZOnULxzJwDOgwbhM/0d1Lb3tpDonSgv0bP9h2iSo+UdY017BtJmUB3UCsp/MhoM7PrxO05t3QBAWLtO9Br7KpZWylsW02eXkbM0GsOVMlSWalyHhWIXqax6WhUkSeLw4cNs3boVSZIIDAxk2LBhlZvSarp/NIgymUwsWbKEVatWkZSUhEqlIjg4mEcffZRRo0YpdgQsCML9daVIy+L9ifx06FJlwrivsw3PdAxhRMta2P+bejVlebDpDYhaId/2iZSbBnvfv4rbKxNWMvPwTAwmA+Fu4Xza7VN87M33qbosOprUV8ejT0lBZWWF91vTcBk6VBHvyTlpxWz+KoqCK2VoLNV0ezKcei29zR3WdcqKCtnw8VySz54BoMOIJ2k1SBl/vxuVn88j55c4pDIDFs5WuD/ZECuFLYdWMBgMbNq0iRMnTgDQpEkT+vXrh0bz4Mzf3PGRSJLEgAEDKvvjRUZGIkkSsbGxjBkzhlWrVrFmzZp7GKogCEp3KaeEb/ZcZMXxFHQGeem/rpcDz3cKYWATf6w0/3Jb/fk/Ye1LUJQOKjV0nACd3gTNvW8LAWAwGZh/dD6/xv0KQK+gXrzf/n1sNeaZ7ZEkifwVK8icOQtJp8MyIAD/Tz5WTAuXi6eu8OfiGPRaIw5u1jz8QiM8A5W1hT0nJZk1894nPzMdSxtbHn5pAnVbmq8kxe0UH0wjf/0FMIFVLUfcRzXAwun+PPf/qZKSEn7//XcuXbqESqWiZ8+etGnTRpED03/jjgdRS5YsYc+ePezYsYOuXbte972//vqLQYMG8eOPP/KkQrbPCoJw/0SnFbBo90U2nknDdHWrStNAF8Z2rsND4d7/ftlGWwzb34ZjP8i33evKs08BLf7dz/0HCrQFTNw9kUPp8nb3l5q8xHONnjPbRcFUVkbGu+9RcPXDq0PXrvjNnYOFAhq1SiaJoxsTOboxCQD/UBd6PRuBraOyLvgXjh9h02fz0ZWV4eTpzaA338YzMMjcYd1EMprIX3+RkkPpANg19cJ1cD1Uluav9VWVzMxMfvvtN/Lz87G2tubRRx+lXr165g7rnrjjOlE9e/akW7duTJ48ucrvz549m927d7N169a7GmBNInbnCf8lkiRx8GIOi3ZfZE/ClcqvdwnzZGznOrQKdrs7A4xLB2HNC5CXJN9u9Tw8NAOsqlGEs5ric+OZsHsClwovYauxZU6HOXSvbb7t7rqkJFJeHY82Ph7UajzHj8f9macVUUBTV2Zg++IYuYEw0KhbAO2G1MXCwvyxVZAkiaPrVrL3t6UgSQQ0iKD/a1OwczL/APRGplI9Ob/Eor1QACpw6hWEY+cAxc7oxMfHs3LlSnQ6Ha6urowcORJPT2Xma13rnjcgPnPmDPPmzbvl9/v06cOnn356x79YEISayWSS2BaTyVe7L3D6cj4AahX0a+THC53r0MDvLn2A0JfDzllw4DNAAqcAGPQFhHS5Oz//DpgkEz9G/8inJz9Fb9LjZ+/Hp90+Jcwt7L7FcKPCbdtInzIVU0kJFu7u+H/4IfZtlNH8PT+zlE1fnSEvoxQLjZrOI8MIb+dr7rCuo9dp2f71Z8Tu2wVA4x596DrmeSwUmKejzyole2k0xpxyVFYWuI0Iw7bBva+6Xx2SJHHgwAG2b98OQHBwMEOHDsXO7v592DGHO37W5Obm4u1962RAb29v8vLy7kpQgiAoj85gYs3JVBbtucDFK3KZAmuNmmEtavFsxxAC3e/im2X6GbltS1aMfLvJ49B7jlyB/D7JKMlg2r5pHMmQqyp3rdWVGe1m4Gbjdt9iuJak15O18CNyFy8GwLZFc/w/XIiltzKKVCZFZbP9hxh0ZQbsXazp83wk3sHKmpEvzs1h7YKZZFw4h0qtptv/XqBJz4fNHVaVyuJzyf01DklrxMLVGo/RDbFUWD/BCnq9ng0bNnD69GkAWrRoQZ8+fbCwUGa9qrvpjgdRRqPxthn1FhYWGAyGuxKUIAjKUaw18NvhZL7fl0hGoVxd3MlGw5NtgxjTPggPh7u4BdxogP0fwa65V5sGe0L/T6B+37v3O+7AlsQtvHfoPYp0RdhqbJnUchKD6w022xKKPjOL1Ndfp+z4cQDcnnoKr9fGozJjm4wKkiRxYuslDq29CBL41nGm13MR2CusYnbG+QTWLphJcV4uNg6O9H9tCoERjcwd1k0kSaJ4XxoFm+S/p1WQE+5PhGPhoKx8sgpFRUUsX76clJQUVCoVffr0oVWrVuYO6775R7vzxowZg/Utun5rtdq7FpQgCOaXU6xlyYEklh5IovBqmQJvJ2ue7hDMY60CcbS5yxfw7HOw+gVIPSbfDu8P/T4G+/tX6LBIV8Tsw7PZcFGuFRTpEcmcjnPM2v+u5NBhufp4Tg5qBwd858zGqUcPs8VzLb3WyI6lsVw4kQVAw45+dBweisW/3YV5l8Xu28XWRZ9g1OtxDwhk0Btv4+KjrGVGAMlgIm/NeUqPZQJg18Ib10F1USns71khPT2d3377jcLCQmxsbBg2bBghIfen0K1S3PEgavTo0X97H7EzTxBqvsu5pXy79yK/H7tMuV4uUxDiYc/znUMY1NQfa81dnqI3meDIN/DnDDCUgbUzPDwfGg27L21bKhzPPM7UvVNJK0lDrVLzXKPneK7Rc1iqzTPbI5lM5Hz7HVc++USuPh4WRsAnHyui+jhAwZUyNi86Q05qCWoLFR2HhxLRyd/cYV3HZDKyf9lPHFn7BwAhzVvx8EsTsVZgno6xWEfOz7HokgpBBc59Q3Bo76fYBPKYmBhWr16NXq/H3d2dkSNH4u6uzHyte+mOB1GLr67DC4LwYIpNL2TR7gtsOJOO8WqdgsYBzoztUoceDXyq19fu7+RfhrUvQuIe+XZIV7lpsHPA3f9dt6A36vny9Jd8H/U9EhIBDgHM6TiHJl5N7lsMNzIWFJA2aTLFu3YB4PzII/i887Yiqo8DXI7NZet3Z9GWGLB1sqLPcxH41nUxd1jX0ZaWsumz+Vw8cRSAVoOG0n74E6jN2NPwVnTpJeQsjcaYr0VlbYH7yPrYhJkn9+7vSJLEnj172Hm1Mn6dOnV49NFHsVXIc/N+U952BEEQ7htJkjialMdXu86zM/7/yxR0rOfB2M51aFvH/d58EpYkOPUrbJkM2kLQ2ELP96HlM/d19uliwUWm7J1CTI6cwD6o7iAmt5qMvaX5Enhvqj7+9lu4PPqoImYkJEni9I7LHFh5HkkCryAn+jwfiYOrsvKf8jPSWTP/fXJSktFYWtHzhVcI79DF3GFVqSw6h9zlcUg6Exp3G9xHN8TSS3kzZQA6nY61a9cSHR0NQJs2bejRo8d/IoH8VsQgShD+g0wmiR1xWXy16zwnkvMBuUxBn0hfxnauQ4T/PdwFV5QBG16H+I3y7YBW8MgicK9z737nDSRJ4vf431lwbAHlxnKcrZ2Z3nY6PWqbL9dIkiTyf19B5ixlVh836Izs/CWOhMNyvk79tj50HhmGprrNo++R5LOnWf/RXMqLi3BwdWPgxLfwqRtq7rBuIkkSRbtSKNyWBBJY13HG/fFw1Hbm3yxQlcLCQn777TfS09NRq9X07duX5s2bmzsssxODKEH4D9EbTaw9lcbXuy9wLqsYACuNmkebB/BcxxCCPO7hDIzRAEe/g79mgq4I1JbQdSq0f/W+NQ0GyC7LZvqB6exJkZcQ2/q25f327+Ntb75+bqayMjJmvEvB2rUAOHTrht+c2YqoPg5QlFvO5kVRXEkuQqVW0WFoXSK7KKvgoyRJnN62ib+WfI1kMuFTN5SBE6bh4Ka8PB1JbyJvZQKlp+TZX/s2vrj0D0GloIKk10pJSWHZsmUUFxdjZ2fHsGHDCFJIbp65iUGUIPwHlOoMLDtyme/2XiStQC5T4Git4Ym2tflf+yC8HG3ubQApx2DDa5AhN3jFv7lcusAn8t7+3hvsuryL6Qemk1uei5Xaiteav8bI8JGoVea7eGkTE0l9dTzahAS5+vhr43F/WhnVxwHSzuWx5ZuzlBXpsXGwpPezEfiHuZo7rOsYDXr+Wvw1Z/7cAkB4hy70eP5lLK2UtcwIYCzUkf1TDPrLRaAGl/51cGjrZ+6wbikqKoq1a9diMBjw8vLisccew9VVWeffnMQgShAeYLklOpYeSGLpwSTyS/UAeDrKZQpGtg7E6W6XKbhRaS7seBeOLwUkuVjmQzOg2ej7OvtUqi9lwbEFrEhYAUCoayhzO86lnqt5+3kVbt1G+tSr1cc9POTq462VUWNHkiTO7k5l3+/nMJkkPGo50OeFSJzclZVAXFpYwPqP5pAScxZUKjo+NpqWA4Yoapasgi6liJwfYzAW6lDZanB/PBwbhSXkVzCZTOzcuZO9e/cCEBoaypAhQ25Z5ui/SgyiBOEBlJpfxrd7LrL86GXK9EYAarvb8XynOgxu5o/Nvc5jqUgc3/42lObIX2s8Enq8Bw73t49WdHY0k/dOJqkwCYDRDUbzSrNXsLIwX/FCSa8na8GH5C5dClytPr5wIZZeyqg+btSb2P1bPLEH5Ia39Vp603VUfSytlJX/dCU5iTXz3qfwSiZWtrb0feVNQpq1NHdYVSo9c4W8FQlIehMaT1s8RjdE46GsAWkFrVbL6tWriYuLA6BDhw5069YNtUJmR5VEDKIE4QGSkFnEot0XWHcqDcPVMgUR/k6M7VyX3hH3qEzBjTJjYOPrkHxQvu0ZDn0/hKD29/53X8NoMvL92e/56tRXGCQDXnZezOowiza+be5rHDfSZ2aS+trrlJ04AYDb00/h9dprqBTSu60kX8vmr6PITCxEpYK2g+vS5KFaipvZOX/0EJs+/xB9eRku3r4MevNt3AMCzR3WTSSTROGOZIp2JANgHeqK+8j6qG2Ucb5vlJ+fz2+//UZmZiYWFhYMGDCAxo0bmzssxVLmWRQE4R85lpTLot0X+DM2q/Jr7eu6M7ZzXdrXvUdlCm6kLYbdc+HglyAZwdIOukyGNi+Cxf3dcZRSlMLUfVM5mXUSgF5BvXi7zds4W5s3Ubvk0CFSJ0ysrD7uN3cOjg89ZNaYrpVxsYDNi6IoLdRhbaeh5zMNCVRYw1tJkji8+nf2L/8JgMCIRvQbPxlbR2X16QMw6YzkrUigLCobAIcO/jg/HIzqfnyYqYbk5GSWL19OSUkJ9vb2jBgxglq1apk7LEUTgyhBqKEkSWL/+Rw+2ZHA0SS5+bdKBb0b+vBC5zo0ruVyvwKB2PVyzafCVPlr9ftB77ngcn/fgCVJYv3F9cw+PJsSfQn2lvZMaz2NfiH9zDqTIplM5HzzLVc+/VSuPl6/vlx9vLb52sncKGZfGrt/i8dklHDzs+fhsZE4eyqrXpFeW87Wrz4h/qCcp9OkVz+6PPkMFgqZxbuWoUBLzo8x6FOLwUKF66C62Lf0MXdYt3Ty5Ek2bNiA0WjEx8eHxx57DGeF7A5VMuU98wRB+FvHL+Uyf2s8hy7mAmBpoWJIswCe6xRCiKfD/QskNxE2vwnntsm3XWrLLVtCe92/GK4q0Bbw3sH32HZJjqWZVzNmd5yNv4N5W5EY8/Pl6uO7dwPgPHiwXH3c5h7viLxDRoOJfSvOcXa3PAAOaepJ99HhWClsuakoJ5u1C2aSefE8agsLuj81lkYP9TZ3WFXSJheS81MMpiI9ansN7qMaYB2kzAGJyWTizz//5MCBAwCEh4fzyCOPYGWlzIbHSqOsV4kgCLcVnVbAh9sS+CtOXrazslAzsnUgL3Sug4/zfbwoG7Sw/xPY+yEYyuWaTx3GQ4fXwer+z14cSj/EtH3TyCrNQqPS8GKTF3kq4ikszNzio+xsNKmvvoo+NRWVtTU+77yNy5AhZo3pWqWFOrZ8E0X6+QJQQev+ITTvU1tx+U9pCXGsXTCT0oJ8bB2dGPD6VAIaRJg7rCqVnMwib2UCGCQsfexwf7IhGjdlDJhvVF5ezsqVKzl37hwAnTt3pnPnzopNIDeZtJSVpWJvr5wmx2IQJQg1wPmsYj76M4GNZ+TdUhZqFUObB/By93r4u9znHT4XdsLGCZB7Qb4d3FlOHPe4/+UCtEYtn574lB9jfgQgyCmIuR3n0tDDvFW+K6uPz5yJpNdjWasWAZ9+gk14uFnjulbWpUI2L4qiOE+LlY0FPZ5qSFAjD3OHdZPo3TvY/s1nGA0GPAKDGPTG2zh7ma8w6q1IJonCbUkU7UoBwCbcDbcRYaitlXmZzc3N5bfffuPKlStoNBoGDRpERIQyB6YAWm0mZ6LGUV6eQquWa7G2VsZzQJlnVxAEAC7nlvLJjnOsOpGCSZJznvo38uO1HqEE38vq4lUpTIetUyF6lXzbwRt6zYaIIfe1312Fc3nnmLR3Eufy5E/Rw0KHMaHFBOwszZvHI1cfn0HB2nUAOHTvLlcfd1JO4nP8oXR2/hKPUW/CxduOh8dG4upjvn6BVTGZjOz9dSnH1svPt7ot29DnpQlY2SivLIBJayB3WTzlsfLyumOXWjj1rK3YBPILFy7wxx9/UFZWhqOjI4899hh+fsot+JlfcJyoqHHodFfQaJwoK7ssBlGCINxaVmE5n+88z29HktEb5VIFD4V7M6FnKOG+9/libDTA0W/hr1lyuxaVGlo9J7dssbn/eR4mycQvsb/w8fGP0Zl0uNm48V679+hcq/N9j+VG2sREUl95Fe25c2Bhgddr43F7+mnFLI+ZjCYOrLrA6R2XAQhq5MFD/2uAta2yLgXa0hI2fDKPpFPHAWgzeDjthj6umCru1zJkl5H9UwyGzFLQqHAbEopdU2XU+7qRJEns37+fHTt2IEkS/v7+jBgxAkdHR3OHdkupqb8Rn/AukqTH3r4ejSIXYWcXZO6wKinrlSMI/3F5JToW7bnA0gNJlOtNAHSo68GEnqE0DTRDq4XLR2Hja5ARJd/2bw59F4Jfk/sfC5BVmsVb+97iYLpcg6pTQCfebfcuHrbmX4Yq3LKV9GnT5Orjnlerj7dSRvVxgLJiHVu/jSY1Xt7J2eLhIFr1U952+7z0VFbPe5+8tBQ0Vtb0Gvsq9dt1MndYVSqLyyV3WRxSuRG1gyXuTzbAOlA5M47X0ul0rF27lujoaACaNm1K37590ShwZyPI+U/xCe+RlrYMAC/PPoSHf4BGo6wZU2X+9QThP6aoXM/3+xL5fm8iRVoDAM0CXZjYK4x2dcwwQLipXYvLNe1azDMbsP3Sdt49+C4F2gJsLGx4o+UbDA0davZZnhurj9u1aIHfwg8VU30cIDuliE1fRVGUU47G2oKHxoRTR4GzJRdPHGXT5wvQlpTg4O7BoIlv4R1S19xh3UQySRT9lUzhjmSQwCrQEffHw7FwVmZLlNzcXJYtW0ZWVhZqtZqHH36Y5s2bm/21cytabRZRUS9SUHgSUFEnZAK1a7+gyHjFIEoQzKhcb+THg0l8tesCeVd724X7OvFGr1C6hnnd/zcNkwlO/wrb3/n/di1NHoeH3r3v7VoqlOhLmHN4DmsvrAWggXsD5nacS7BzsFniuZY+M5PU8a9RdlIu6qm06uMA545l8tfSWAx6E06etjz8QiTu/vexDMYdMJmMHFzxK4dWLQfAt14YAye+hb2L8hrdmsoM5C6PpzxOzn+yb+OLS78QVBrlLTUCnDt3jpUrV1JeXo6DgwPDhg0jMFB5ld0rFBSc4EzUOHS6LDQaJxo2/AgP9y7mDuuWlPNKF4T/EJ3BxPJjl/lsxzmyirQAhHja83qPUB6O8EVtjiWWzGh519217Vr6LYTa7e5/LFedyjrFlL1TSClOQYWKZyKfYWzjsVje5wroVSk5eFCuPp6bi9rREb85sxVVfdxkkji89iIntl4CILCBGz2eboiNvfn/dtcqLSxg02cLuHRGHog26dX3agFNZcUJoM8oIeenGAw55aC5WkCzhTILaEqSxL59+9ixYwcAAQEBDBs2DCcFbXC4UWrqMuITZig2/6kqZh06z5kzh5YtW+Lo6IiXlxeDBg0iPj7+uvtIksSMGTPw8/PD1taWLl26VK7pVtBqtbz88st4eHhgb2/PgAEDSElJue4+eXl5jBo1CmdnZ5ydnRk1ahT5+fnX3Sc5OZn+/ftjb2+Ph4cHr7zyCjqd7p4cu/DfZDRJ/HE8he4Ld/H2mrNkFWnxd7Fl3qON2Da+E/0a+d3/AZS2GLa9BYs6ygMoS3vo8T68sNdsAyi9Sc/nJz9n9JbRpBSn4Gfvx+Lei3ml2StmH0BJJhPZixaR/PQzGHNzsa5fn+CVfyhqAFVSoGXdxycrB1BNewbS96XGihtApZ+L5+fJ47l05iQaa2sefmkC3Z8aq8gBVOnpK2R9cQpDTjkWLtZ4vdBYsQMorVbL77//XjmAat68OWPGjFHsAMpk0hEX9xZx8dOQJD2enr1o0fwPxQ+gwMwzUbt372bcuHG0bNkSg8HAtGnT6NmzJzExMdjby8lj8+bNY+HChSxZsoTQ0FBmzpxJjx49iI+Pr9xRMH78eNavX8+yZctwd3dnwoQJ9OvXj+PHj2NhIRfbGzlyJCkpKWzZsgWA5557jlGjRrF+/XoAjEYjffv2xdPTk3379pGTk8Po0aORJInPPvvMDH8d4UFiMklsic5g4fYEzmcVA+DpaM1LXesyolUtrDVmKAopSRC7DrZM+f92LeH95XYtzgH3P56rLhVeYsreKURly8ns/UP6M6X1FBytzL+DyJifT+qkSZTs3gOA85DB+LytnOrjAJfjctn+QwxlhTosrS3o+kR96rVUxnbwCpIkcXrbJnYu/RaT0YCrrz8DXp+CR2CQuUO7iWSUKNiSSPFe+TViXdcFt8fqY6GwAWmFnJwcli1bxpUrV7CwsKjMf1IqrTaLqLPjKCg4gZz/9Dq1a49VZP5TVVSSJEnmDqLClStX8PLyYvfu3XTq1AlJkvDz82P8+PFMmjQJkEfY3t7efPDBBzz//PMUFBTg6enJTz/9xPDhwwFIS0ujVq1abNq0iV69ehEbG0uDBg04dOgQrVu3BuDQoUO0bduWuLg4wsLC2Lx5M/369ePy5cuV9TKWLVvGmDFjyMrKuqMRfGFhIc7OzhQUFCh2xC/cX5IksSvhCh9ui+dsaiEAzraWjO1Sh9Ftg7C1MlNF7dyLsOlNOL9dvu1SGx5eAKE9zRMP8t9q5bmVzDs6jzJDGY5WjrzT5h16ByujtUdZ1Fm5+nhamiKrj5tMEsc2JnJ0UxJI4O5vT69nIxRX/0mvLWf7t18Qu3cnAPVataPX2PFY2ymrTx+AsVhH7q9xaC8WAODYOQCnnkGoLJR5gU9ISGDlypVotVocHR0ZNmyYohsIFxScJCpqHFpdJhqNIw0bfISHR1ezxFLd67eicqIKCuQnqpubGwCJiYlkZGTQs+f/v7FbW1vTuXNnDhw4wPPPP8/x48fR6/XX3cfPz4+IiAgOHDhAr169OHjwIM7OzpUDKIA2bdrg7OzMgQMHCAsL4+DBg0RERFxXcKxXr15otVqOHz9O1643n1itVotWq628XVhYePf+GEKNd/hiDvO3xnPskryl3N7Kgqc7hvBMx2CcbMz0KfbGdi0WVtB+PHR8HSzNV8QwtzyXGQdmsPOyfGFt7dOamR1m4mNv/uUSSZLI++lnsubPl6uPBwYS8MnHiqo+XlKgZfsPMZXlCxp08KPjsHpozDVIv4W89FTWLZxDdnISKrWajiPH0KLfI4qcddBdLiLn5xiMBTpUVha4Dq2HXaR5Nlf8HZPJxN69e9m5U3791KpVi2HDhim7/lPacuLjZyBJuqv5T19hZ2f+zSL/lGIGUZIk8frrr9OhQ4fK0vMZGRkAeHtfPxXt7e3NpUuXKu9jZWWFq6vrTfepeHxGRgZeVWw39vLyuu4+N/4eV1dXrKysKu9zozlz5vDuu+/+00MVHnBnUvKZvzWeveeyAbDWqBndLogXOtfBzd6MTT0v/AUbJyqiXcu19qbs5e39b5NTnoOl2pJXm73KqAajUKvMv9vJkJ1N2tSplOzZC4DDQ93xm62s6uMpcblsu7p8p7G2oMvIMMJam3/weaNzRw6w5cuP0ZWVYufsQr/xk6jVINLcYVWp5EgGeWvPg1FC42GL+6hwLL2VNaNXoby8nNWrV1fmE7ds2ZJevXopuP6TjoRzM0lN/QUAT8+eNAifj0ajrB2jd0oxf+WXXnqJM2fOsG/fvpu+d+OnFEmS/vaTy433qer+1bnPtaZMmcLrr79eebuwsFDRU6fCvZWQWcSH2+LZGp0JgEatYkSrWrzUtd79bQ58I4W1a6lQZihj4bGFLIuXi+nVdanL3I5zCXMLM1tM1yreu5e0yVMw5uSgsrbG6803cB05UjGzJiaTxPHNSRzdkIgkgZufPb2fU97yncloZN+yHzm6biUA/vUb0O/VSTi4uZs5sptJBhP56y5QckT+4GzTwB23YaGobRRzqbzOlStXWL58OdnZ2VhYWNCvXz+aNm1q7rBuSau9cjX/6TigIiTkNYJqj0WlgA9M1aWIZ8bLL7/MunXr2LNnDwEB/5/Q6uMjf5rKyMjA19e38utZWVmVs0Y+Pj7odDry8vKum43KysqiXbt2lffJzMy86fdeuXLlup9z+PDh676fl5eHXq+/aYaqgrW1NdbWyiyuJtw/l3JK+PjPc6w5lYokgVoFg5r6M757KIHuZszzMBrgyDewc7Yi2rVcKzYnlsl7J3Ox4CIAT4Q/wavNXsVGY/4EbZNWy5WFC8ldKjc1tq5XD78PF2ATGmrmyP5faaGO7T9EkxInL9+Ft/el4/BQLBW2fFeSn8fGT+ZxOUbeJNC87yA6jhyDhQJnSQz5WnJ+iUV/uQhU4NSzNo6daymuonuFuLg4Vq1ahU6nw8nJieHDh+Pv72/usG6poOAUUVEvotVlYmHhQETDj82W/3Q3mfWZLEkSL7/8MqtXr2bXrl0EB1+/HhocHIyPjw/bt2+vHF3rdDp2797NBx98AMhbNy0tLdm+fTvDhg0DID09nbNnzzJv3jwA2rZtS0FBAUeOHKHV1TYMhw8fpqCgoHKg1bZtW2bNmkV6enrlgG3btm1YW1sremeDYD7pBWV8uuM8K45dxmCS92f0ifDh9R6h1PM2cy7C5SOw4XXIrGjX0kKu+eTb2KxhGUwGfjj7A1+d/gqDyYCnrScz28+knb/5alFdS3v+PKkTJqK9ujTiOmoUXhMnoFbQh6XU+Dy2fR9NaaEOjZWaziPDqN/G9+8feJ+lxsWw/uO5lOTlYmljS68XXiWsbQdzh1Wl8gv55P4ah6lEj8pWg/tj9bEJVV6hT5Dzn3bv3s3u3bsBqF27NkOHDsXBQbnLYWlpK4iLfwdJ0mFnV5fGjRbVyPynqph1d96LL77Ir7/+ytq1awkL+/8pfGdnZ2xt5STXDz74gDlz5rB48WLq1avH7Nmz2bVr13UlDsaOHcuGDRtYsmQJbm5uTJw4kZycnOtKHPTp04e0tDS+/vprQC5xULt27etKHDRp0gRvb2/mz59Pbm4uY8aMYdCgQXdc4kDszvtvyCnW8uWuC/x06BI6g9zfrnOoJxN7hhEZYN4ZHkpz4c/pcEKeRVFCu5YKF/IvMG3fNKJz5Dpv3QO7M73tdFxtzH+xkiSJ/GXLyJz7AZJWi4WbG76zZ+HYpYu5Q6skmSSOb0niyPr/X77r9WwEbr7KWr6TJIkTm9ax55cfMBmNuPnXYsCEqbj7Ky/VQZIkivelUrA5EUxg6WuP+xPhaNzNt8nidsrLy1m1ahUJCQkAtG7dmp49e1Ze55RGzn+aRWrqzwB4evSgQYP5aDTKS3iv7vXbrIOoW+UWLF68mDFjxgDyk/zdd9/l66+/Ji8vj9atW/PFF19UJp+D/MR64403+PXXXykrK6N79+58+eWX1+Un5ebm8sorr7Bu3ToABgwYwOeff46Li0vlfZKTk3nxxRf566+/sLW1ZeTIkSxYsOCOl+zEIOrBVlCm57u9F/l+XyKlOiMArYLceKN3GC2D3MwbnMkEp36R27WUye0oaPI49HgP7M3bnNdoMrI0Zimfn/wcvUmPo5UjU1pNoV9IP0XkFxny8kif9hbFf/0FgH2HDvjNmY3GUzk7sUoLdfy5OJrLsfLyXf12vnQaHoqltbIunrqyUrZ+/RkJB+VE/LB2nej5/MtY2ShvUGLSGcn7I4GyM/IGELumXrg8Uhe1wpZEK2RlZbFs2TJyc3PRaDT069ePJk2amDusW9LqsomKGkdBwTFARUjwqwQFjVNs/lONHEQ9aMQg6sFUqjOweH8SX+++QGG53Bw40t+Zib3C6FTPw/wDgYyzcruWy4fk214N5F13ZmzXUiGxIJG39r/FmStnAOgU0InpbafjZaeM5rclBw+S9uYkDFeuoLK0xGviBFxHjUJl5lm7a6UmXF2+K9Chsby6fNdWect3OSmXWbdwNrmpl1FbWNB51DM07a2MgfKNDNllZP8UgyGzFNQqXPoGY9/OT5GxAsTExLBmzRp0Oh3Ozs4MHz78unI8SlNQeFrOf9JmXM1/+ggPj27mDuu2Hog6UYKgJFqDkV8PJ/PFzgtkF8v1wOp5OTChZyi9GvqY/w1XVwK75sDBL0Eyyu1auk6B1i+AmVujGE1Gfo79mc9OfobWqMXB0oFJrSYxsM5A8//dAEmnI+uTT8j9YTFIElZ16uC/YL6iaj9JJonjWy9xZN1FJAlcfe3p9WxD3P2Ul/sSf3AvW7/6BL22HAdXN/q9NgX/MOX8La9VFptD7vJ4pHIjakdL3B8PxzrIzMvwt2Aymdi5cyd798oze0FBQQwdOrSyo4cSpaX9QXzC25hMOuzs6tAochH29iHmDuueEYMoQbiBwWhi5YkUPt1xntT8MgAC3ex4rUc9BjT2x0IJu3XiN8OmN6DgsnxbAe1aKlwqvMTb+9/mZJbcULa9X3tmtJuhiMKZANrERNImvkH51R6cLiOG4z1pEmpb5Sw5lRXp+HNxDMkx8tJsWBsfOj8WprjlO6PBwJ6ff+DEZjlNolbDRvR79U3snF3MG1gVJJNE4Y5kinYkA2BV2wn3x+tj4aScTQPXKisrY+XKlZw/fx6QC0T36NFDwflPes6dm0VK6k8AeHg8RMMGCxSZ/3Q3iUGUIFxlMklsiErno+0JJGaXAODjZMPL3esyrEUtLC0UsMRTkApbJkGsvCEC50DouwBCe5k3LsAkmfgt7jc+Pv4x5cZy7C3teaPFGwyuN1gZs0+SRMHKlWTMmo1UVoaFszO+s2YqqnEwQNq5fLZ9d5aSq8t3nR4LI7yd8pbvinNzWP/xB6TFxwDQauCjtB8+CrUCL/KmMgO5y+Mpj5MHpfZtfHHpF4JKo4DXdBUyMzNZtmwZeXl5aDQaBgwYQKNGjcwd1i1pddmcjXqJ/IKjAAQHjydYwflPd5MYRAkCcPxSHu+uj+ZMytXWQ/ZWvNilDk+0qY2NpQIuCiYjHPkW/nofdMWgsoB2L0HnSWBl/qn9y0WXeXv/2xzPPA5Aa9/WvNfuPfwclJG3YSwoIP2d6RRt3QqAXZs2+H0wF8tb1IAzB8kkcWLbJQ6vS0QySbj62NHr2Qjc/ZW3fHc5+gwbPplHaUE+VrZ29Bn3OnVbtjF3WFXSZ5SQ/VMMxpxy0KhwHVQP+xbKOe83io6OZs2aNej1elxcXBg+fPh1dRKVprDwDGeixlbmPzVsuBBPj+7mDuu+EYMo4T8tq7CcuVviWHVC7tDuYK3h+U4h/K9DMA7WCnl5pJ2E9eMh/ZR8O6Al9PsYfCJu86D7wySZ+D3+dxYeX0iZoQxbjS0TW0xkaOhQRcw+AZQePUrqm5MwpKeDRoPX+Fdxe+opRSWPlxVfXb6LlmdKQlt70/mxMKwUVilbkiSOrlvJvt9+RJJMeAYG0X/CVFx9lDFYvlHp6Szy/jiHpDdh4WKN+6gGWClwUApy/tOOHTvYv38/ACEhITz66KPYKbAxc4W09D+Ij6/IfwqhUeTXD3T+U1WU9QoVhPtEZzCxeH8in+44R8nVcgVDmwfwRu8wvBzNXzUbAG0R/DULjnwNkgmsnaHHDGg2xuw1nwBSi1OZvn86hzPkSv8tfVryXrv3CHA0f14WgKTXc+WLL8j5+hs5ebx2bfwWLMA20vyDz2uln89n63fRlORrsbBU02lEKOHtfBUzCK2gLS1hy5cfcf6ovAu0QaduPPTMi1haK+T1cg3JKFGwOZHiffKHI+u6Lrg9Vh8Le/NuuLiV0tJSVq5cyYULcl/Ldu3a0b17d2XnP52fTUqKXI/uv5L/VBUxiBL+c3bGZ/H++hguXs17alzLhXcHNKRJLRfzBlZBkuScp82ToChN/lrEo3K/O0fzL0NIksQf5/5gwdEFlBpKsdXYMr7ZeEbUH6GIpsEAuuRkUt94g/LTcmkF5yGD8Zk6FbWCdjVJJomT25M5tPYikknCxduO3s8pc/nuyqVE1i2cTX5GOhYaDV3HPE+jh3orbqAHYCzWkftrHNqL8tK8Y5cAnHoGKbZ9S0ZGBsuWLSM/Px9LS0sGDhx4XR1EpdHpsok6+zL5+UcACA5+leCgl/4T+U9VEYMo4T8jKbuE9zfEsCMuCwAPB2sm9Q5jSLMA1Ep5g81Phk1vQsJm+bZrEPRdCHWVkWOQUZLBO/vf4WD6QQCaeTXj/fbvE+gUaObI/l/B2rVkvPseptJS1I6O+L73Lk59+pg7rOuUF+v5c0kMl87mABDaypvOI5W3fAcQs3cn27/5HINOi6OHJwNem4JPXeX0EbyWNrmQ3J9jMRbqUFlZ4Do0FLtI8xabvZ2oqCjWrl2LwWDA1dWV4cOHV/aMVaKb8p8afIinp7I2ZtxvynvFCsJdVqI18PnO83y/NxGd0YRGreKpDsG83K0ujjYKmd43GuDwV3KzYH0pqC2h/avQaSJYmn/rvSRJrDm/hnlH51GsL8bawppXm73KyPojsVArY8nBWFRExrvvUbhhAwC2LZrjP28elgorSph+oYBt352lOE+LhUZNx+H1aNBBeYUeDXo9u5Z+y+ntmwCo3agpD788ETsnZdZUKj6STv7aC2CU0Hja4j6qAZZeyswnMhqN7NixgwMHDgBQp04dhgwZouj8p/T0VcTFT7sm/2kR9vZ1zB2W2YlBlPDAkiSJNadSmbs5jsxCuVhmp1BP3unXgLpeCloySTkmJ45XNAsObAf9PgKv+mYNq0JmSSbvHnyXvalywb/Gno15v/37BDsrp4Fo6YmTpL3xBvrUVLCwwPOlcbg/9xwqBeWUSCaJk38mc2jN/y/f9Xq2IR4ByssjKczOYv1Hc8k4L/doazPkMdo+OgK1QgbM15L0JvLXXaDkaAYANg3ccRsWilqBs3oAJSUl/PHHHyQmJgLQoUMHunXrhloBeY5VkfOf5pCSshQAD/duNGy48D+Z/1QVZT7LBOFfikopYMb6aI5fknuNBbrZ8U6/BnQP91LOJ/7yAtjxHhz9HpDA1hV6vC/3vFPAG6okSWy4uIE5R+ZQpCvCSm3Fy01fZlSDUYqZfZIMBrK//prsL78CoxHLgAD8F8zHVmE9xcpL9OxYEkNSlLx8V6+FF12eqK/I5bukMyfZ+Ol8yosKsbF3oM/LEwhp2tLcYVXJkK8l5+cY9CnFoAKnnkE4dg5QbP5Teno6y5Yto6CgAEtLSwYNGkTDhg3NHdYtyflPr5CfL28eCQ56meDgV/6z+U9VUd4rWBD+hZxiLQu2xbPs6GUkCWwtLXipW12e7hCsjHpPICeOR6+GLZOhOFP+WuPHoOdMszcLrpBdls27B99l1+VdAES4RzCzw0zquChn+l6fmkrqm5MoOy7XpnIa0B+fd97BwkFBs4xAxsUCtn53luJcZS/fSSYTh1f/zv4Vv4Ak4R1Sl/6vTcHZy/ybGapSfiGf3F/jMJXoUdtpcBtRH5tQV3OHdUunT59m/fr1lflPI0aMwFtBdcpuVFgYdTX/Kf1q/tN8PD17mjssxRGDKOGBoDea+PnQJRZuT6DoapPggU38mNynPr7O5s8pqpSbCJsmwvk/5dvudeXE8ZDO5o3rKkmS2Jy4mdlHZlOgLUCj1jCuyTjGNByDRq2ct4vCTZtInz4DU1ERant7fGZMx7l/f3OHdR1Jkjj152UOrb6AySTh7GlLr+ci8KylvGWQ8uJiNn/xIRdPyBWnI7v3otuY59FYWZk5sptJkkTx3lQKNieCBJa+9riPaoDGTXmlFkDOf9q+fTuHDsmlIerVq8fgwYOxVVCboRtdn/8UfDX/qa65w1Ik5bwrCkI17T+fzbvro0nILAagga8T7w5sSMsgNzNHdg2jHg58Brs/AEM5WFhBxwnQfjxYKuPNP6csh5mHZvJnsjzAC3cLZ2aHmYS6KmcnlrG4hMxZsyhYvRoA28aN8VswH6tatcwc2fXKS/TsWBpL0plsAOq28KLr4/WxslXeW27mxfOs/2gOBVmZaCyt6P70WCK69jB3WFUyaY3krUyg7Orf1a6pFy6P1EVtpZBZ5hsUFxfzxx9/kJSUBECnTp3o0qWLovOfzp+fy+WUJYDIf7oTyntFC8IdupxbyqyNsWyJlhNKXe0smdgrjBEtA5XRJLhC8iE5cfxKrHw7qKOcOO5Rz6xhXWtr0lZmHZpFnjYPjUrD842f5+nIp7FUK2T3IlB25gypE99An5wMajUeLzyPx4svotIo620sI7GAbd9GU5RbjlqjouPQejTs5K+45TuAqL+2seOHrzDq9Th7+9D/tSl4BytnyfZa+uwycn6KwZBZCmoVLv1DsG+jvKKkFVJTU1m+fDmFhYVYWVnxyCOPEB4ebu6wbkmny7la/0nOfwoKeomQ4FdF/tPfUNa7jyDcgTKdka92X+Dr3RfQGkxYqFWMalOb1x4KxdlOORd9SnPhzxlwQt7Vgp27XDCz0XBQyBt/Xnkesw7PYmuS3FMuzDWMmR1mUt9NGTsDASSjkZzvf+DKp5+CwYDG1xf/+fOwa9HC3KFdR5IkzvyVwoFV5zEZJZw8ben9bASegcr7FG/Q6djxwyLO7twGQEizlvQZNwEbheWTVSiLySF3eTyS1oja0RL3x8OxDlJmqQWAU6dOsX79eoxGI+7u7owYMQJPT09zh3VLhUVniTozlnJtGhYW9jRoMB8vT/M3Na8JxCBKqDEkSWJTVAazNsaQVlAOQNsQd6YPaEB9HyczR3cNSYKoFbBlCpTKyw40HQU93gM75Swx7ri0g/cOvUdueS4WKguebfQsz0U+h6WFcgai+owM0iZNpvSw/OnYsU9vfGfMwMJZWRfQ8hI9f/0YS+Jp+XzXaeZFt1HKXL4ryMpg3cI5ZCVeQKVS0374E7Qa+KiieglWkEwShTuSKdqRDIBVbSfcHw/Hwkl5uVog5z9t3bqVI0fkat6hoaEMHjwYGxtlLNlXJT1jDXFxUzGZtNjaBtGo0SIc7JUzS650ynuFC0IV4jIKmbEumkMX5Qat/i62TOsbTp8IH2VN5+dcgI2vw8Vd8m2PMOj/MdRuZ86orpNfns+cI3PYlCgXUazrUpeZHWbS0F1ZW60Lt20j/e13MBUUoLKzw2faNJwHP6Ks8w1kJhay9buzFOXIy3cdHq1HRGdlLt9dPHmUzZ99SHlJMbaOTvR95U1qN2pi7rCqZCrVk7s8nvJ4uUyJfVtfXPqGoNIob7AHcv7T77//TnKyPODr0qULnTp1UnD+k4HzF+Zy+fJiANzdu9KwwUIsLRX0gfQGscVlnCwsZaSfu7lDqSQGUYKi5Zfq+Gh7Aj8duoRJAmuNmhc61+GFznWwVVIyqUEL+z+BPQvAqAWNDXR6A9q9AhrlfGrembyT9w69R3ZZNmqVmqcinmJs47FYWSgnRlNpKZlzPyD/998BsImIwH/BfKyCgswb2A1uWr7zsKHXsxF41VbeRchkMnLwj984tHIZAL51w+j32mScPJS5xKRLLyHnpxiMueWgUeP6SF3smyu3HEBKSgrLly+nqKgIa2trHnnkEerXV86S+I10umzOnn2VvHx5x2BQ0DhCgscrOv9pTWYer8VdRmsyEWhrRQdXZSyTi0GUoEhGk8RvR5L5cFs8eaV6APpE+DD14XBquSmsNULSPjlxPOecfLtON+j7IbiFmDWsaxVoC5h3dB7rLqwDINg5mFntZxHpGWnmyK5XHhND6oSJ6BITQaXC/Zln8Hz5JVQK22qvLdXz149xXDx1BYA6TT3p+mQ41gpcvistLGDTZwu4dOYkAE169aXLk89goVHOsu21Sk9lkbfyHJLehIWrNe5PNMBKgU2ZQR5IHz9+nM2bN2M0GvHw8GDEiBF4eCij3ltVCgpOEXV23NX+d/Y0CJ+Pl5dy85/0JomZF9L4OkV+rXV0daC+vXLKQyjvFS/85x1JzGXGumhi0gsBCPV2YHr/hrSvq7A3ppIc2P42nPpFvm3vBb3nQMQQxSSOA+xN2cuMAzPIKstChYoxDccwruk4rC2szR1aJclkInfpj2QtXAh6PRovL/zmfYB9mzbmDu0mWZcK2frtWQqzy1FbqGj/aD0iuyhz+S79fDzrF86lKOcKGitrej73EuEdu5o7rCpJBhP5Gy9ScjAdAOt6LriNqI+FvTIHezqdjo0bN3L69GkA6tevz6BBgxSb/yRJEqlpv5GQ8B6SpL/a/+4rRdd/uqLT81x0EgfzSwB4KdCLycG+aBS0+1oMogTFSC8oY86mONadTgPAyUbDaz1CeaJNbSwtFDTNLElw6lfY9haUyTlatHgKuk8HWxezhnatIl0RC44tYNW5VQDUdqrNzPYzaeLVxLyB3UCflUX6lKmU7N8PgMND3fF9/300rsqqPi1JElG7Utj/h/KX7yRJ4tTWDez+6XuMBgOuvn70f30qnoFB5g6tSoa8cnJ+jUN/uQgAxy61cOpZW7HtW3Jycvj999/JzMxEpVLRvXt32rdvr8iBNIDRWE58/NukZ8jvBZ6evWkQPlfR9Z+OF5Tw9NkkMnR67C3UfFI/kH5eLuYO6yZiECWYXbneyPf7Evn8r/OU6Y2oVDCiZSATe4bi7qCc2RIAriTAhtfg0j75tldDOXG8ViuzhnWjA2kHmH5gOhklGahQ8USDJ3i56cvYapQzDQ5QtHMn6VOnYczLQ2Vjg/eUKbgMG6q4i5G2VM/On+K4cFJeUghp4km3J+tjraSSGldpS0vYuugTzh0+AEC9Vu3oNXY81nYKWwa/qiw+l7zl8ZhKDahsNbgNC8U2XDmJwzeKi4tj9erVaLVa7O3tefTRRwkOVk4z7huVlSVzJmocxcUxgJq6dd8ksNYzinuNVZAkiaVpObx9LhW9JFHPzprvI4IJtVfmDJ8YRAlmI0kSf8Zm8f6GGJJzSwFoXtuVdwc0JMJfWVvY0ZfD3g9h30dg0oPGFrpOgTYvgoJKApToS/jw2IesSFgBQC3HWrzf/n2aezc3c2TXM5WXkzVvPnm//gqAdXg4/gvmY11HeYUeMy4WsO27q8UzLVS0G1yXRt0CFHkRyrhwjg2ffEBBZgZqCw2dRz1F0979FRmrZJIo3H6Jop2XAbAMcMB9ZLii27fs3LmTffvkD1C1atVi6NChODkpbyayQnb2TqJjXsdgKMTS0o2IiE9xc21r7rBuqcxoYnJCCssz5Bn+vp7OfFI/EAeNgjYR3UAMogSzOJ9VzHsbYtiTIH+y93K0ZurD4QxsorzGrFzYKZctyL0o367XEx5eAK61zRvXDQ6nH+ad/e+QViIvh46sP5JXm72KnaWyZiDK4xNImzgR7Tk5Ed9tzBg8X38NtcKSxyWTxIltlzi8LhHJJC/f9Xw6Au9g5V00JUni5BZ5+c5kNODk6U3/8ZPwqauclj3XMhbpyF0Wh/ZCAQD2bXxx6afs8gXXtm9p06YNPXr0wMJCmRd3STKRmPgZiUmfARJOTk2IjPgcGxtfc4d2S8llWp45m8SZ4jLUwNQQX8YFeinvenADMYgS7qvCcj2f7TjH4v1JGEwSVhZqnu4YzLiudXGwVtjTsfgKbJ0KUfJWexx8oM8H0GCgohLHS/WlfHT8I5bFy9vX/R38eb/9+7T0aWnmyK4nmUzk/vgjVz5ciKTXY+Hhgd+cOTh07GDu0G5Skq/lzyUxpMTJNYrqtfSmy8gwRRbPLC8pZtuiTzl3RF6+q9uyLb3GvoqNvTJ3tGkTC8j5NQ5TkQ6VlRrXwfWwa+Jl7rBuKTk5mRUrVlBUVISlpSUDBw4kIiLC3GHdkl6fT3TM6+Tk7AbA3/8JQutNRa1WWGrENXblFjI2+hJ5BiNulhZ83SCIjm7Kzde6lvLeEYQHkskk8ceJFOZtiSO7WAdA9/pevNWvAcEe9maO7gYmE5z8Eba/A+UFgApaPQvd3gIbZS0zHss4xtv73yalOAWAYaHDmNBiguJmn/SZmaRNnkzpQbkujUPXrvjOfB+Nu/JyX5KistmxNJbyYj0aKzWdRoRSv60ye7RlXDjHho/nUpCVqfzlO0mieE8qBVsTwQQaLzvcnwjH0ktZz9UKkiRx+PBhtm3bhslkwsPDg+HDhyu6fUtRUTRnosZRXn4Ztdqa+mEz8fUdbO6wbskkSXx2KYu5ielIQGNHW76PCCbARlmz0rcjBlHCPXcyOY8Z62M4fTkfgGAPe97p14Cu9RX46TMzRk4cvyxf7PFpJCeO+ysrp6jcUM4nJz7hl9hfkJDwsffh3Xbv0s5POZXRKxRu2Ur69Oly5XEbG7wnT8Zl+DDFXeiNehMH11zg9A45R8c9wIFezzTE1Udhg3xq3vKdqcxA7ooEymNyALBr4onL4HqolVQw9xparZb169dz9uxZABo2bMiAAQOwtlbubE56+kri4t+W27fYBBIZ+QWOjg3MHdYtFRqMvBJ7iS3Zcimbx33dmFUvABsl7cS+A2IQJdwzWUXlzNsSzx/H5VkSeysLXulej/+1D8ZKabkP+nLYMx/2fwwmA1jaQ7dp0Op5sFDWy+T0ldO8te8tkgqTABhcbzBvtHgDBytlLd8Yi4vJnDWbgtWrAbnyuN+8eViHKG8nU35mKdu+j+ZKsrzFvlHXANoOroPGUnkX+Zq2fKdLLSbnl1i5+riFCpf+dbBvrbB2Tde4cuUKy5cvJzs7G7VaTc+ePWndurVi4zWZtCScm0lqqrxJQ27f8iGWlsqaNb9WXEkZT0clcaFMi5VKxezQAJ5QUCuXf0JZVwfhgWA0SSw9kMTC7QkUaw0ADGkWwKTeYXg5KXDnzeUjsHYcZCfIt+v3k3OfnAPMG9cNdEYdX576ksXRizFJJjxtPZnRbgadAjqZO7SblJ44Sdqbb6JPSQG1GvfnnsVz3DhUlsrZyVgh7lA6u39LwKA1YmNvSbfR4QQ3Ulhh16tq2vJdyZEM8tdfAIMkVx9/PByrAOXmukRHR7N27Vp0Oh2Ojo4MHTqUwMBAc4d1S+XlaUSdfYnCwtOAiuDgVwkOGqfo9i1rs+T2LaVGE/7WlnwbEUQzJ+XN9t4pMYgS7qrotAKmrIriTIq866ZRgDMzBjSkWaCyCicCoCuBHe/D4UWAJFcc77tAThxXmJicGKbtm8b5/PMA9A3py5RWU3C2VtanTUmvJ/urr8he9DWYTFj6++M37wPsmitrORRAV25g92/xJBzOBMCvngs9nmqIg6vylmxuXL5z9vKm36sKXr7TGclffZ7Sk1kA2IS74TY0FLUC62qBXL5g+/btHDpU0UsuiEcffRQHB2XO7gHk5u7nbPR49PpcNBpnGjZciId7F3OHdUsGk8TMi2ksuizvyO7g4sCihkF4WNXsYUjNjl5QjDKdkY93JPDd3kSMJglHGw2T+9TnsZaBqJVYdfjCTlj/CuTLHddp8jj0nAl2buaN6wZ6k57vznzHN2e+wSAZcLNx450279C9dndzh3YTXVISqW9OovzMGQCcBw7E+61pWDgqb+Yh61Ih276LpuBKGSoVtOwXTPM+QYp8rt64fFevVTt6vvCKYpfv9Fml5PwSiyGzFNTg3CsIh44Biq0+XlhYyB9//EFysvxe0L59e7p166bg8gUSl5K/4cKFBYAJR4eGREZ+ga1tLXOHdktXdHqej77EgfxiAMYFejFFYe1bqksMooR/bd+5bKaujqosmPlwpA8z+jdU5tJdWb7cruXkT/Jt51py4njdh8wZVZXO551n6r6pxObGAtCjdg/eavMWbjbKGuhJkkT+ihVkzpmLVFaG2skJ33dn4NSnj7lDu4lkkji14zKH1lzAZJRwcLOm51MN8a3rYu7QqpRxPkEunlm5fPc0TXv3U+TyHUDp6SzyVp5H0hlRO1ri/lg41iHKmi29VlJSEitWrKCkpARra2sGDRpEeHi4ucO6JYOhiJjYN7lyZRsAvj5DCAt7DwsLBb7XXnWioISno5NI1yq7fUt1iUGUUG25JTpmboxh1YlUAHycbHh/UAQ9GnibObJbiNskF80skhuc0vJZeGg6WCtrpsRoMrIkeglfnPoCvUmPk5UT01pPo09wH8VdPA25uaS//Q7FO3YAYNemDX5z52Dp42PmyG5WWqhjx9IYkqPlasghTT3p+kR9bBTY4FZevlvP7p9+qBHLdzc1Dw5xxu2x+lg4KnOruiRJHDhwgD///BNJkvDy8mL48OG4K7DkRoXi4gSizr5IaWkiKpUVoaFv4+/3mOLeEypIksRPaTm8dS4VnSRR186aHxTcvqW6xCBK+MckSWLNqVTe3xBLbokOlQqebFObib3CcLRR3gWJkmzY9AZEy803casDAz+H2sorB5BUkMRb+9/i9BW5M3yngE5MbzsdLzvllYMo3ruXtKlTMV7JRmVpiedrr+E2ZjQqtfKSWi/H5vLn4hhKC3VYWKrpMLQeDTsqsDo+8vLd1q8+4fzRg4Dyl+8MeeXk/BKLPkVeqnHsWgunh2qjslDe3xagvLycNWvWEBcXB0CjRo3o168fVgqrmH+tzMwNxMZNwWgsxdrah8jIL3F2amzusG6p3GhiyrkUfkuXP7A87OHMJ+GBOCq4fUt1iUGU8I8k55QybU0Ue89lAxDm7cicIZHKTByXJIj6Aza/CWW5oFJDu5ehyxSwVFYjXpNk4tfYX/nkxCeUG8uxt7RnUstJDKo7SHEXelN5OVnzF5D3yy8AWNeri9/8+djUr2/myG5mNJo4si6RE9sugQSuvvb0eqYh7v7KHJDUtOW7srhccpfHI5VdbR48PAzb+spabr5WZmYmy5cvJzc3FwsLC3r37k2LFi0U+/c1mfScvzCPy5d/AMDVtS0RDT/Bykq5M2aXy3U8fTaRM0Vy+5YpIb68VAPat1SXGEQJd8RgNPHD/kQWbk+gXG/CSqPm1e71eLZjiPJqPgEUpslFMxO2yLe9I2DAZ+DfzLxxVSGlKIV3DrzD0YyjALTxbcN77d7D10F5fa7KY2JIfeNNdBcuAOD65Ci8Xn8dtY3ypugLs8vY9n00mYlyMb+GHf1oP7Qelgos8Fjl8t34yfjUqWfu0KokGSUK/6w5zYMBzpw5w/r169Hr9Tg5OTFs2DACApRVxuRaWu0Vzp59mfwC+X2hdu0XCAl+DbVauZft3blFjI1JIlcvt29Z1CCITjWkfUt1mfXqt2fPHvr374+fnzytvmbNmuu+L0kSM2bMwM/PD1tbW7p06UJ0dPR199Fqtbz88st4eHhgb2/PgAEDSElJue4+eXl5jBo1CmdnZ5ydnRk1ahT5+fnX3Sc5OZn+/ftjb2+Ph4cHr7zyCjqd7l4cdo0TlVLAwC/2M3tTHOV6E21C3NjyakfGda2rvAGUJMHxJfBFa3kApbaErtPg2Z2KG0BJksSKhBUMWTeEoxlHsdXY8lbrt/imxzeKG0BJRiM5331H4vAR6C5cwMLTg1rffovP1KmKHECdO5bJ8plHyEwsxNpOQ69nI+jyeH1FDqDKS4pZ9+Fsdi75BpPRQL1W7Xhi7ieKHUAZi3Rkfx9VOYCyb+uL1wuNFTuAMhgMbNy4kVWrVqHX6wkJCeH5559X9AAqP/8YR44OIL/gKBYWDkRGfkndOm8odgAlSRKfXcrksdMXyNUbaeRoy9YWYQ/8AArMPBNVUlJC48aN+d///seQIUNu+v68efNYuHAhS5YsITQ0lJkzZ9KjRw/i4+NxvLptevz48axfv55ly5bh7u7OhAkT6NevH8ePH6/cojpy5EhSUlLYskWelXjuuecYNWoU69evB+QaIX379sXT05N9+/aRk5PD6NGj5SfGZ5/dp7+G8pTqDCzclsAP+xMxSeBsa8m0h8MZ2iJAmVOzuRdh3SuQtFe+7d9Czn3yUt5um4ySDGYcmMH+tP0ANPNqxsz2M6nlpLxtyvq0NNImT6H0yBEAHHs8hM9776FxVd4Srl5rZO/vCcTulxOcfUKc6fF0A5zclbV8WyHjfALrP/6Awivy8l2XJ5+mSS/lLt9pLxaQ89s1zYOH1MOusfLy9SoUFBTw+++/k5oqb37p3LkznTt3Rq3AvD2QByMpKUs5d34OkmTA3r4ejSK/ws5OeVX+KxQZjLwam8ymbLk24EhfN2bXwPYt1aWSJEkydxAAKpWK1atXM2jQIEB+Mvn5+TF+/HgmTZoEyLNO3t7efPDBBzz//PMUFBTg6enJTz/9xPDhwwFIS0ujVq1abNq0iV69ehEbG0uDBg04dOgQrVu3BuDQoUO0bduWuLg4wsLC2Lx5M/369ePy5cv4+fkBsGzZMsaMGUNWVhZOTk53dAyFhYU4OztTUFBwx49Rql3xWUxbfZbU/DIA+jf2451+DfB0VF4hQkxGuWDmjvfBUAYaW+j+NrR+AdTKmnmQJIn1F9cz9/BcivRFWKmteKXZKzwR/gQWCosVoGDjRjJmvIupqAiVnR0+U6fgPGSIIi/y2SlFbPsumryMUlBBiz5BtOwbhFqBb+aSJHFy8zp2/7y4ZizfSRLFe1Io2JpUI5oHA1y4cIE//viDsrIybGxsGDx4MKGhytzdCGA0lhIbN43MzHUAeHn1Jbz+HDQa5Vbzji8p5+mziZwvrfntW6p7/Vbm3CCQmJhIRkYGPXv2rPyatbU1nTt35sCBAzz//PMcP34cvV5/3X38/PyIiIjgwIED9OrVi4MHD+Ls7Fw5gAJo06YNzs7OHDhwgLCwMA4ePEhERETlAAqgV69eaLVajh8/TteuXauMUavVotVqK28XFhbezT+BWWQXa3l/QwxrT6UB4O9iy8xBEcpsFgyQFQfrXoIUOW+AoI4w4FNwCzFvXFXILsvm3YPvsuvyLgAiPSKZ2WEmIc7Ki9VYWEjG+zMpvDpba9O4Ef7z5mFVu7aZI7uZJElE7UrlwMrzGA0m7J2teOiphgSEKW+mDKC8uJitiz7m/FG5Ona91u3o+bxyd9+ZSvVy8+BYeaeVXVMvXB6pq9jmwSaTiX379vHXX38B4Ovry7Bhw3BV4MxphdLSRM5EvUhJSQIqlQV1606hVsAYRX5YqbA+K59X45IpNZrws7bkuxrevqW6FDuIysjIAMDb+/qaQ97e3ly6dKnyPlZWVje9OLy9vSsfn5GRgZfXzQMALy+v6+5z4+9xdXXFysqq8j5VmTNnDu++++4/PDJlkiSJP46nMGtTLPmletQq+F/7YF7vEYq9tQKfJkY97PtIbhps1IG1E/R8H5qNBgW+8WxJ2sKsQ7PI1+ajUWt4sfGL/C/if2gUmONQevQoqZMmYUhLBwsLPF54AY+xL6DSKC/W8mI9f/0US+JpebdoUKQ73UaHY+ugzO3q6efj2fDxvBqzfKdLKSLn17j/bx48oA72rZTbPLisrIxVq1Zx7tw5AJo1a0afPn2wVGDPxgpXrmwnOmYiRmMxVlaeRER8hqtLS3OHdUsGk8Tsi+l8eVlu6dPexYFFDWvjaaXcv/G9pLx3xRvc+GKVJOlvX8A33qeq+1fnPjeaMmUKr7/+euXtwsJCatVSXk7L30nKLmHq6igOXMgBINzXibmDI2lcy8W8gd1K2klY+xJknpVvh/aGvgvB2d+8cVUhrzyPWYdnsTVpKwD13eozs/1MwtzCzBzZzSSdjiuffU7Od9+BJGFZq5bc965pU3OHVqW0c3ls/yGG4jwtao2Kdo/UpVE3Zebr1cTlu5IjGeSvuwBGCQs3G9xH1ld08+D09HSWL19Ofn4+FhYW9O3bl2bNlLWZ5FqSZOTixY9IuvQVAM7OzYmM+Bxra4XO+iO3b3kh+hL7r7ZvebGWF1NDHoz2LdWl2EGUz9WKxxkZGfj6/v9OpaysrMpZIx8fH3Q6HXl5edfNRmVlZdGuXbvK+2RmZt70869cuXLdzzl8+PB138/Ly0Ov1980Q3Uta2trrK0VmCN0h/RGE9/sucinO86hNZiw1qh5rUcoT3cIxlKBeSToy2DXXDjwGUhGsHWDPvMg8lFFzj7tTN7JuwffJac8BwuVBc9EPsPzjZ7H0kJ5n9i0Fy+SNvENymNiAHAeMhjvKVOxcFDe9LzJaOLYpiSObUpCksDF246eTzfEM1CZF/gat3xXw5oHA5w4cYKNGzdiNBpxcXFh+PDh1103lEanyyU6+jVy8/YBEBAwmnp1p6BWK/hvXFjCM2eTSNPqsbNQ83H9QAY8QO1bqkuxg6jg4GB8fHzYvn07Ta9+EtbpdOzevZsPPvgAgObNm2Npacn27dsZNmwYIH8aOXv2LPPmzQOgbdu2FBQUcOTIEVq1agXA4cOHKSgoqBxotW3bllmzZpGenl75wtu2bRvW1tY0V2D3+bvhZHIeU1ZFEZdRBECHuh7MeiSC2u7Ku2gCcOmgnPuUc16+HTEEen8ADp7mjasKhbpCPjjyAesuyAmiIc4hzO4wm4YeDc0c2c0kSSJ/2TIyP5iHVF6OhbMzPu+/h9M1eYZKUpRbzvYfokk/L+8Eqt/Wh47DQ7GyUeZb2bXLdxYauXimkpfvbm4eHIxDJ3/lxqvXs3nzZk6cOAFAvXr1GDx4MLa2ytyNCVBYeIaoqHGUa9NQq20Jrz8bH58B5g7rtn5Oy2FqQgo6SaKOrTU/RAYT9oC1b6kus77zFBcXc/78+crbiYmJnDp1Cjc3NwIDAxk/fjyzZ8+mXr161KtXj9mzZ2NnZ8fIkSMBcHZ25umnn2bChAm4u7vj5ubGxIkTiYyM5KGH5Iay4eHh9O7dm2effZavv/4akEsc9OvXj7AweUmlZ8+eNGjQgFGjRjF//nxyc3OZOHEizz77bI3fZXejYq2BBVvjWXpQ/hTvamfJ2/0a8EhThb5Raotgx3tw5FtAAgcf6PcR1H/Y3JFVaX/qft458A5ZpVmoUDGm4RjGNR2HtYXyZiwN2dmkT3uL4t27AbBv1w7fOXOw9FbmcsLFk1f466dYtKUGLG0s6DIyjNBWyuvRBzVv+Q4qmgefQ9KZUDta4f5YfUU3D87Ly+P3338nPT0dlUpF165d6dChg2LLFwCkpi0nPn4GkqTD1rY2jSK/wsFBeUv7FcqNJqaeS+HX/0D7luoy6yDq2LFj1+18q8gvGj16NEuWLOHNN9+krKyMF198kby8PFq3bs22bdsqa0QBfPTRR2g0GoYNG0ZZWRndu3dnyZIllTWiAH755RdeeeWVyl18AwYM4PPPP6/8voWFBRs3buTFF1+kffv22NraMnLkSBYsWHCv/wT31Y7YTN5ec5a0gnIABjf1Z1rfcNwdlHeBB+D8Dlj/KhTIRf1oOgp6zgRbF7OGVZUSfQkLji3gj4Q/AAh0DGRmh5k09VJmPlHRXztJf+stjLm5qKys8Jo4AdcnnlBk3zuDzsj+lec5u1uu9eNV25GezzTE2VOZ2+tr2vJdTWseDJCQkMCqVasoLy/Hzs6OIUOGUKdOHXOHdUtGo5aEhBmkpf8OgIfHQzRssACNRplL0AApV9u3nP6PtG+pLsXUiXoQKLVOVFZROe+ui2FjlPwmWcvNllmDIukUqrylMADK8mDrNDgl92bDJRD6fwp1qi41YW5HM47y9v63SS2WL/Ij64/k1WavYmepvIu8qbSUzA/mkb98OQDWYWH4zZ+HjULr5+SmlbDt+7PkpJYA0LRHIK0HhmChtEr5V9W05TtDbjk5v97QPLhHbVQKTRQ2mUzs2rWLPXv2AODv78+wYcNwdlbujFlZWQpRZ8dRVHQWUFMn5HVq134elUqZz2GAPblFvHBN+5avGgTR+QGvPv7A1YkS/j2TSWL5scvM2RRLYbkBC7WKZzoEM/6hUGwVWuOFmHWwaSIUZwIquWBmt7fAWnmf4ssMZXx64lN+jv0ZAD97P95r/x6tfVv/zSPNoyzqLGlvvIEuKQkAt//9D8/XxqNWYPd6SZKI2ZfGvt/PYdCbsHW05KExDQhsqMxCfpIkcWLTOvb8cnX5ztuH/uMn4x1S19yh3dK1zYPVdhpchym7eXBJSQmrVq3iwtW+jS1btqRXr15oFFh6o0JOzh7ORr+GwZCPpaUrDRt+jLtbB3OHdUuSJPF5chZzLqZjAho52vJ9RDC1bJT3HqEUyn32Cf/K+axipq6O4kiivJYd6e/MnMGRRPgr9BNbcZY8eIpZK9/2CIUBn0OgMgckp7JO8db+t7hUKNcsG1JvCBNbTMTBSnmDPcloJOfb77jy+edgMKDx9sZv7hzs27Y1d2hV0pbq2flzPBdOyLvDaoW70n1MA+ydlbnsXNXyXa8XXsXaTpmbNG5qHlzLEfeR9dG4KjdROCUlhd9//53CwkI0Gg0DBgygUaNG5g7rliTJRFLSl1xM/BiQcHSMpFHkl9jY+P3dQ82myGBkfFwyG6/ImzYe83Vjzn+ofUt1iUHUA0ZnMLFo9wU+/+s8OqMJW0sLJvQMZUy7IDRKfDFIEpxZDlsmy8t4KgvoMB46vQmWyntT1xl1fHHqC5ZEL8EkmfCy9WJGuxl0DOho7tCqpEtJJW3SJMqOHwfAsXdvfGdMx8LFxbyB3ULGxQK2fRdNUW45arWK1gNDaNojULHLS/Ly3QcUXsmSl++efIYmPfsqdvnOWKQj97c4tBflC6V9W19c+oagUujyqCRJHDt2jM2bN2MymXBzc2P48OG3LT1jbnp9ITExE8jOkSum+/mNILTeO1gocHNJhYSr7VvOlWqxVKmYHerPE77uin0eK4kYRD1Ajl/KZfLKKM5lyfkNnUM9mTkoglpuysvNAaAgBdaPh/Pb5ds+kTDwC/BtbNawbiU6J5q39r3F+Xx5R2n/kP5MajUJZ2vlze5JkkThunVkvPc+ppIS1Pb2eL/9Fs4DByryjdFkkjix9RJH1icimSScPGzo8XRDfIKV97eFmrl8JzcPjsVUpEdlZXG1ebBC8yKRS9ps2LCBM2fOAPJO64EDB2Jjo7wPVxWKiuOIihpLWVkyarUVYaHv4ec31Nxh3daGq+1bSowmfK0t+b5hEM2clTmLqkRiEPUAKCzXM29LHL8cTkaSwN3einf6N2BAYz9FXjAxmeD4Ytg+HXRFYGENXSZBu1dAgYUo9SY93575lm/OfINRMuJm48Y7bd+he2B3c4dWJWNBAekzZlC0eQsAtk2b4jd/HlYBAWaOrGol+Vq2L44hNT4PgHotvek8MgxrW2W+PZUXF7Plq4+5cExevgtt3Z6eL7yi3OU7k0Tx3muaB3vb4f64spsH5+TksHz5crKyslCpVDz00EO0a9dOme9nV6VnrCEubhomUzk2Nv5ERnyBk1OkucO6JYNJYk5iOl8ky8vm7Vwc+Po/3L6lupT5LiXcsS1nM5i+7iyZhXIj5GEtApj6cDgudgpNBMy5AOtegUtypV5qtZZznzyVuTssIS+Bt/a9RWxuLAA9avfgrTZv4WajzATckkOHSJs8BUNGBmg0eL40DvdnnlFk3zuApKhsdiyNpbxYj8ZKTacRodRv66vYi2VNW76rac2DAWJjY1mzZg1arRZ7e3uGDh1KUFCQucO6JZNJx7nzs0lJ+QkAN7eORDT8CEtL5TY8ztYZGBuTxN48edVibC1PpoX4/afbt1SXMt9Zhb+VUVDO9HVn2Rott7QJcrdj9uBI2tXxMHNkt2A0wKEvYecsMJSDpT08NB1aPgNq5b2hG0wGlkQv4ctTX6I36XG2dmZa62n0DuqtyAumSafjysefkLt4MUgSVrVr47dgPraRyvwkbNSbOLjmAqd3yMnN7gEO9HqmIa4+Cp3NqYHLd7qUInJ+icWYpwXN1ebBLZXbPBjgzJkzrFq1CoDAwEAeffRRRZWLqUpe3qHKAVRQ0EuEBL+CSqW897RrlRiNRBWVYWeh5qP6tRjopdwBn9KJQVQNYzJJ/HIkmXmb4yjSGtCoVTzfOYSXu9XDxlKhL9zMaLlhcJrcmoGQLnLdJ9faZg3rVhILEnlr31ucyZZzMToHdGZ62+l42ikzf0R77hypb7yJNi4OAJdhw/CePAm1nTKXa/IzS9n2fTRXkuWWQ426BtB2cB00Sn3+Ant/W8rRtXIhVaUv31Uw5JZjzNPKzYMfD8fKX3k7R28UGhqKu7s7oaGhPPTQQ9cVTVYqd/dOBAW9hJNTIzw9lLnEf6PattZ8FxGEh5WG+vbKbZFTE4him3fRvS62mZBZxJRVURy/JOeONKnlwpzBkYT7KvSTmkEHez+U/5n0YO0MvWZB0ycU2TDYJJn4JfYXPjnxCVqjFgdLBya1msTAOspMxgbI/elnsubPR9LpsHB1xXfWTBy7dTN3WLe1fXE0CYczsbG3pNvocIIbKXT29Bp56an89vYbtB06UtHLdzcqOZqBbYQHaoXml1VFq9XW6MbuQs0kim0+wMr1Rr7ceZ6vdl9Ab5Swt7Lgzd71eaJNbSyUuoadelyefcqKkW/X7wcPLwAnZXZWN0kmXtj+AgfTDwLQ1rct77V/Dx97ZfZmq6C7dAlJp8O+U0f8Zs1C46nM2bJrdRwWChK0faQuDq4142Lp6uvPM59/j5VNzfrUbt9S2c/fqogBlFCTiEGUwhWU6nnkq/1cvCK3vXgo3Iv3Bkbg56LgN3ODFn4bCcUZYOcBD8+Hho8ocvapglqlpoVPC05dOcXEFhMZGjq0Rsw2eE2cgE1EQ8WWLqiKjb0lPZ5qaO4w/rGaNoASBOHeE8t5d9G9Ws4b+/Nxjl3K490BDekToezE0ErRayBuI/SeC/bKbNVxI4PJQGZpJv4O/uYORRAEQbiPqnv9FoOou+heDaJyirVoLNQ424r6HYIgCIJwt4mcqAeYu4PIERAEQRAEpVFmwyRBEARBEASFE4MoQRAEQRCEahCDKEEQBEEQhGoQgyhBEARBEIRqEIMoQRAEQRCEahCDKEEQBEEQhGoQgyhBEARBEIRqEIMoQRAEQRCEahCDKEEQBEEQhGoQgyhBEARBEIRqEIMoQRAEQRCEahCDKEEQBEEQhGoQgyhBEARBEIRq0Jg7gAeJJEkAFBYWmjkSQRAEQRDuVMV1u+I6fqfEIOouKioqAqBWrVpmjkQQBEEQhH+qqKgIZ2fnO76/Svqnwy7hlkwmE2lpaTg6OqJSqcwSQ2FhIbVq1eLy5cs4OTmZJYZ77UE/xgf9+ODBP0ZxfDXfg36M4viuJ0kSRUVF+Pn5oVbfeaaTmIm6i9RqNQEBAeYOAwAnJ6cH8oVxrQf9GB/044MH/xjF8dV8D/oxiuP7f/9kBqqCSCwXBEEQBEGoBjGIEgRBEARBqAYxiHrAWFtbM336dKytrc0dyj3zoB/jg3588OAfozi+mu9BP0ZxfHeHSCwXBEEQBEGoBjETJQiCIAiCUA1iECUIgiAIglANYhAlCIIgCIJQDWIQJQiCIAiCUA1iEFWDzJkzh5YtW+Lo6IiXlxeDBg0iPj7+to/ZtWsXKpXqpn9xcXH3Kep/ZsaMGTfF6uPjc9vH7N69m+bNm2NjY0NISAiLFi26T9H+c0FBQVWej3HjxlV5/5pw/vbs2UP//v3x8/NDpVKxZs2a674vSRIzZszAz88PW1tbunTpQnR09N/+3JUrV9KgQQOsra1p0KABq1evvkdHcHu3Oz69Xs+kSZOIjIzE3t4ePz8/nnzySdLS0m77M5csWVLleS0vL7/HR3Ozvzt/Y8aMuSnONm3a/O3PVcr5g78/xqrOhUqlYv78+bf8mUo6h3dybajJr8O/Oz5zvg7FIKoG2b17N+PGjePQoUNs374dg8FAz549KSkp+dvHxsfHk56eXvmvXr169yHi6mnYsOF1sUZFRd3yvomJiTz88MN07NiRkydPMnXqVF555RVWrlx5HyO+c0ePHr3u2LZv3w7A0KFDb/s4JZ+/kpISGjduzOeff17l9+fNm8fChQv5/PPPOXr0KD4+PvTo0aOy12RVDh48yPDhwxk1ahSnT59m1KhRDBs2jMOHD9+rw7il2x1faWkpJ06c4O233+bEiROsWrWKhIQEBgwY8Lc/18nJ6bpzmp6ejo2Nzb04hNv6u/MH0Lt37+vi3LRp021/ppLOH/z9Md54Hn744QdUKhVDhgy57c9Vyjm8k2tDTX4d/t3xmfV1KAk1VlZWlgRIu3fvvuV9du7cKQFSXl7e/QvsX5g+fbrUuHHjO77/m2++KdWvX/+6rz3//PNSmzZt7nJk98arr74q1alTRzKZTFV+v6adP0BavXp15W2TyST5+PhIc+fOrfxaeXm55OzsLC1atOiWP2fYsGFS7969r/tar169pBEjRtz1mP+JG4+vKkeOHJEA6dKlS7e8z+LFiyVnZ+e7G9xdUNXxjR49Who4cOA/+jlKPX+SdGfncODAgVK3bt1uex+lnkNJuvna8KC9Du/k2ne/XodiJqoGKygoAMDNze1v79u0aVN8fX3p3r07O3fuvNeh/Svnzp3Dz8+P4OBgRowYwcWLF29534MHD9KzZ8/rvtarVy+OHTuGXq+/16H+Kzqdjp9//pmnnnrqbxtW16Tzd63ExEQyMjKuO0fW1tZ07tyZAwcO3PJxtzqvt3uMUhQUFKBSqXBxcbnt/YqLi6lduzYBAQH069ePkydP3p8Aq2HXrl14eXkRGhrKs88+S1ZW1m3vX5PPX2ZmJhs3buTpp5/+2/sq9RzeeG140F6Hd3Ltu1+vQzGIqqEkSeL111+nQ4cORERE3PJ+vr6+fPPNN6xcuZJVq1YRFhZG9+7d2bNnz32M9s61bt2aH3/8ka1bt/Ltt9+SkZFBu3btyMnJqfL+GRkZeHt7X/c1b29vDAYD2dnZ9yPkaluzZg35+fmMGTPmlvepaefvRhkZGQBVnqOK793qcf/0MUpQXl7O5MmTGTly5G2bntavX58lS5awbt06fvvtN2xsbGjfvj3nzp27j9HemT59+vDLL7/w119/8eGHH3L06FG6deuGVqu95WNq6vkDWLp0KY6OjgwePPi291PqOazq2vAgvQ7v5Np3P1+Hmn98BIIivPTSS5w5c4Z9+/bd9n5hYWGEhYVV3m7bti2XL19mwYIFdOrU6V6H+Y/16dOn8v8jIyNp27YtderUYenSpbz++utVPubGWRzpahH+v5vdMbfvv/+ePn364Ofnd8v71LTzdytVnaO/Oz/VeYw56fV6RowYgclk4ssvv7ztfdu0aXNdcnb79u1p1qwZn332GZ9++um9DvUfGT58eOX/R0RE0KJFC2rXrs3GjRtvO9Coaeevwg8//MDjjz/+t3kxSj2Ht7s2PAivw7+79t3v16GYiaqBXn75ZdatW8fOnTsJCAj4x49v06aN2T8t3Sl7e3siIyNvGa+Pj89Nn4qysrLQaDS4u7vfjxCr5dKlS/z5558888wz//ixNen8VeysrOoc3fgJ98bH/dPHmJNer2fYsGEkJiayffv22376rYparaZly5Y14rz6+vpSu3bt28Za085fhb179xIfH1+t16USzuGtrg0Pyuvw76595ngdikFUDSJJEi+99BKrVq3ir7/+Ijg4uFo/5+TJk/j6+t7l6O4NrVZLbGzsLeNt27Zt5Q63Ctu2baNFixZYWlrejxCrZfHixXh5edG3b99//NiadP6Cg4Px8fG57hzpdDp2795Nu3btbvm4W53X2z3GXCreuM+dO8eff/5ZrcG7JEmcOnWqRpzXnJwcLl++fNtYa9L5u9b3339P8+bNady48T9+rDnP4d9dG2r66/BOrn1mex3+q7R04b4aO3as5OzsLO3atUtKT0+v/FdaWlp5n8mTJ0ujRo2qvP3RRx9Jq1evlhISEqSzZ89KkydPlgBp5cqV5jiEvzVhwgRp165d0sWLF6VDhw5J/fr1kxwdHaWkpCRJkm4+vosXL0p2dnbSa6+9JsXExEjff/+9ZGlpKf3xxx/mOoS/ZTQapcDAQGnSpEk3fa8mnr+ioiLp5MmT0smTJyVAWrhwoXTy5MnKXTFz586VnJ2dpVWrVklRUVHSY489Jvn6+kqFhYWVP2PUqFHS5MmTK2/v379fsrCwkObOnSvFxsZKc+fOlTQajXTo0CFFHZ9er5cGDBggBQQESKdOnbrudanVam95fDNmzJC2bNkiXbhwQTp58qT0v//9T9JoNNLhw4cVdXxFRUXShAkTpAMHDkiJiYnSzp07pbZt20r+/v415vxJ0t8/RyVJkgoKCiQ7Ozvpq6++qvJnKPkc3sm1oSa/Dv/u+Mz5OhSDqBoEqPLf4sWLK+8zevRoqXPnzpW3P/jgA6lOnTqSjY2N5OrqKnXo0EHauHHj/Q/+Dg0fPlzy9fWVLC0tJT8/P2nw4MFSdHR05fdvPD5JkqRdu3ZJTZs2laysrKSgoKBbvgkqxdatWyVAio+Pv+l7NfH8VZRhuPHf6NGjJUmSt1dPnz5d8vHxkaytraVOnTpJUVFR1/2Mzp07V96/wooVK6SwsDDJ0tJSql+/vtkGjrc7vsTExFu+Lnfu3Fn5M248vvHjx0uBgYGSlZWV5OnpKfXs2VM6cODA/T846fbHV1paKvXs2VPy9PSULC0tpcDAQGn06NFScnLydT9DyedPkv7+OSpJkvT1119Ltra2Un5+fpU/Q8nn8E6uDTX5dfh3x2fO16HqaoCCIAiCIAjCPyByogRBEARBEKpBDKIEQRAEQRCqQQyiBEEQBEEQqkEMogRBEARBEKpBDKIEQRAEQRCqQQyiBEEQBEEQqkEMogRBEARBEKpBDKIEQRAEQRCqQQyiBEEwu127dqFSqVCpVCQlJZktji5dulTGoVKp+PjjjwGYMWMGKpWKoKAgs8X2TyQlJV13HCqVytwhCcIDSQyiBEG4b8aMGYNKpaJLly7Xfd3JyYnWrVvTunVrrK2tzRPcNfz9/WndunWNaAhcFWtra1q3bk14eLi5QxGEB5rG3AEIgiA0a9aMQ4cOmTuMSs888wwzZswwdxhV0ul0WFlZ3fY+vr6+HDp0iF27dtG1a9f7FJkg/PeImShBEO6LoKAgli5dCsDu3bsrl5l27dpV5XJexaxVxeNq1aqFk5MT48ePp6ysjPHjx+Ps7Ezt2rVZtGjRdb8rLS2Np556Cj8/P6ysrAgJCeH999/HYDD86+NYu3YtDRo0wN7enk6dOhEfH3/d99etW0eHDh1wcHDA1taWZs2a8cMPP1x3n4pjXbJkSeXXKpYSx4wZA1y/JPfdd9/RvXt3bGxsmD17NkajkSlTphASEoKNjQ0uLi40a9aM+fPn/+vjEwThzolBlCAI90XTpk3x8PAAwNHRsXL5zsnJ6baPS09P58UXX8Ta2pqioiI++eQTmjdvzuLFi3F2diY5OZlx48YRGxsLQHZ2Nm3atGHx4sUUFxcTHh7O5cuXeeedd3juuef+1TGkp6czfPhwJEmirKyMvXv38tRTT1V+/+eff2bgwIHs378fBwcHvL29OXnyJE8//TSzZs2q9u8dN24cp06dol69elhYWPDFF18wd+5ckpOTCQsLw9PTk+joaDZu3Pivjk8QhH9GDKIEQbgvVq9eTd++fYH/X747dOgQzZo1u+3jdDod27ZtIyEhgVq1agFw/vx5Tp8+TWxsLDY2NphMJnbv3g3AF198weXLl/H29ubChQucPn2aP/74A4AlS5Zw/vz5ah+DTqdjxYoVxMbGMn78eAAOHDhAWVkZANOmTQOgdevWXLp0icTERB555BEAZs2aRWlpabV+b+vWrUlJSSEqKoqpU6dy7tw5AJ544glOnz7NuXPnyMnJETNRgnCfiUGUIAiK5urqSvv27VGr1QQGBgIQERFBUFAQ9vb2eHl5AZCZmQnAkSNHKm97eXmhUqkYNGgQAJIkcfjw4WrH4uzsTP/+/QFo0KBB5dezsrLIysoiOTkZgMGDB2NtbY1KpWLEiBEAlJWVER0dXa3fO3bsWGxtbQGwsLCgX79+qFQqli5dip+fH127dmXmzJm4ublV+9gEQfjnRGK5IAiKdu1yn0ajuelrFdv3JUm67r+Ojo7XDXQq2NnZVTsWFxeXm2K59nfeGNPfMRqNlf9fUFBwy/v5+Phcd7tXr16cOHGCFStWcPr0aU6ePMmuXbsqZ9ocHBzu6PcLgvDviJkoQRDum4oBTElJyT37Ha1atQLkQc6yZcsqlw23b9/Oiy++WLm8drd5eXlVzpStXLkSrVaLJEksW7YMAFtbWxo2bFh5X4CEhAQA4uPjiYqKuuXPvnFQdubMGby8vJg1axYbNmyo3NmYmZl5U6K7IAj3jhhECYJw39SvXx+AY8eOERkZSZs2bSrzie6WcePG4e/vT15eHmFhYTRp0oQ6derg7u7O6NGj7+rvulFF8vjhw4epXbs2wcHBrF69GpDzpSoGkd27dwdg4cKFdO3alTZt2tw0m3U7v//+OwEBAQQGBtK8efPKvDI7Ozvq1KlzNw9JEITbEIMoQRDum6eeeoohQ4bg7OzM2bNnOXz48HVLWneDp6cnhw4d4n//+x/u7u5ER0dTVlZGx44d+eijj+7q77rRE088wZo1a2jXrh1FRUVkZGTQpEkTvv/++8qkc5AHT3379sXGxoYLFy4wdepUOnTocMe/p1OnTvTu3RuTycTZs2cxmUx069aNzZs3X7fkKAjCvaWS/snHH0EQhAdYly5d2L17N/7+/gQEBPDaa68xfPhwc4f1j6Wnp/PII49QWFhYWfpBvNULwt0nEssFQRBukJqaSmpqKunp6eYOpVq0Wu2/2oUoCMKdETNRgiAIgiAI1SByogRBEARBEKpBDKIEQRAEQRCqQQyiBEEQBEEQqkEMogRBEARBEKpBDKIEQRAEQRCqQQyiBEEQBEEQqkEMogRBEARBEKpBDKIEQRAEQRCqQQyiBEEQBEEQquH/AN5M8/+ePhclAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plt.figure()\n", "ax = plt.axes()\n", @@ -336,7 +257,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -364,20 +285,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure()\n", "ax = plt.axes()\n", @@ -414,20 +324,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, (ax1, ax2, ax3, ax4) = plt.subplots(\n", " 1, 4, figsize=(16, 3.5), constrained_layout=True\n", @@ -469,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -488,7 +387,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -528,5443 +427,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "HTML(anim.to_jshtml())" ] @@ -5973,7 +438,7 @@ "metadata": { "celltoolbar": "Metagegevens bewerken", "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "parcels", "language": "python", "name": "python3" }, @@ -5987,7 +452,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/docs/examples/tutorial_parcels_structure.ipynb b/docs/examples/tutorial_parcels_structure.ipynb index dbd751f4f..8784d70ae 100644 --- a/docs/examples/tutorial_parcels_structure.ipynb +++ b/docs/examples/tutorial_parcels_structure.ipynb @@ -25,7 +25,7 @@ "source": [ "1. [**FieldSet**](#1.-FieldSet). Load and set up the fields. These can be velocity fields that are used to advect the particles, but it can also be e.g. temperature.\n", "2. [**ParticleSet**](#2.-ParticleSet). Define the type of particles. Also additional `Variables` can be added to the particles (e.g. temperature, to keep track of the temperature that particles experience).\n", - "3. [**Kernels**](#3.-Kernels). Define and compile kernels. Kernels perform some specific operation on the particles every time step (e.g. interpolate the temperature from the temperature field to the particle location).\n", + "3. [**Kernels**](#3.-Kernels). Kernels perform some specific operation on the particles every time step (e.g. interpolate the temperature from the temperature field to the particle location).\n", "4. [**Execution and output**](#4.-Execution-and-Output). Execute the simulation and write and store the output in a Zarr file.\n", "5. [**Optimising and parallelising**](#5.-Optimising-and-parallelising). Optimise and parallelise the code to run faster.\n", "\n", @@ -68,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -109,7 +109,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -130,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -188,18 +188,18 @@ "metadata": {}, "source": [ "1. The `FieldSet` object in which the particles will be released.\n", - "2. The type of `Particle`: Either a `JITParticle` or `ScipyParticle`.\n", + "2. The type of `Particle`: A default `Particle` or a custom `Particle`-type.\n", "3. Initial conditions for each `Variable` defined in the `Particle`, most notably the release locations in `lon` and `lat`.\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Define a new particleclass with Variable 'age' with initial value 0.\n", - "AgeParticle = parcels.JITParticle.add_variable(parcels.Variable(\"age\", initial=0))\n", + "AgeParticle = parcels.Particle.add_variable(parcels.Variable(\"age\", initial=0))\n", "\n", "pset = parcels.ParticleSet(\n", " fieldset=fieldset, # the fields that the particleset uses\n", @@ -217,7 +217,6 @@ "### For more advanced tutorials on how to setup your `ParticleSet`:\n", "\n", "- [**Releasing particles** at different times](https://docs.oceanparcels.org/en/latest/examples/tutorial_delaystart.html)\n", - "- [The difference between **JITParticles and ScipyParticles**](https://docs.oceanparcels.org/en/latest/examples/tutorial_jit_vs_scipy.html)\n", "\n", "For more information on how to implement `Particle` types with specific behaviour, see the [section on writing your own kernels](#For-more-advanced-tutorials-on-writing-custom-kernels-that-work-on-custom-particles:).\n" ] @@ -243,7 +242,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -283,33 +282,8 @@ "source": [ "- Every Kernel must be a function with the following (and only those) arguments: `(particle, fieldset, time)`\n", "\n", - "- In order to run successfully in JIT mode, Kernel definitions can only contain the following types of commands:\n", - " - Basic arithmetical operators (`+`, `-`, `*`, `/`, `**`) and assignments (`=`).\n", + "- ISome tips for writing Kernels:\n", "\n", - " - Basic logical operators (`<`, `==`, `!=`, `>`, `&`, `|`). Note that you can use a statement like `particle.lon != particle.lon` to check if `particle.lon` is NaN (since `math.nan != math.nan`).\n", - "\n", - " - `if` and `while` loops, as well as `break` statements. Note that `for`-loops are not supported in JIT mode.\n", - " \n", - " - Interpolation of a `Field` from the `FieldSet` at a `[time, depth, lat, lon]` point, using square brackets notation.\n", - " For example, to interpolate the zonal velocity (U) field at the particle location, use the following statement:\n", - " ```python\n", - " value = fieldset.U[time, particle.depth, particle.lat, particle.lon]\n", - " ```\n", - " or simply\n", - " ```python\n", - " value = fieldset.U[particle]\n", - " ```\n", - " \n", - " - Functions from the maths standard library.\n", - " \n", - " - Functions from the custom `ParcelsRandom` library at the `parcels.rng` module. Note that these have to be used as `ParcelsRandom.random()`, `ParcelsRandom.uniform()` etc for the code to compile.\n", - " \n", - " - Simple `print` statements, such as:\n", - " - `print(\"Some print\")`\n", - " - `print(particle.lon)`\n", - " - `print(f\"particle id: {particle.id}\")`\n", - " - `print(f\"lon: {particle.lon}, lat: {particle.lat}\")`\n", - " \n", " - Local variables can be used in Kernels, and these variables will be accessible in all concatenated Kernels. Note that these local variables are not shared between particles, and also not between time steps.\n", " \n", " - It is advised _not_ to update the particle location (`particle.lon`, `particle.lat`, `particle.depth`, and/or `particle.time`) directly, as that can negatively interfere with the way that particle movements by different kernels are vectorially added. Use `particle_dlon`, `particle_dlat`, `particle_ddepth`, and/or `particle_dtime` instead. See also the [kernel loop tutorial](https://docs.oceanparcels.org/en/latest/examples/tutorial_kernelloop.html).\n", @@ -319,7 +293,7 @@ "
\n", " A note on Field interpolation notation\n", "\n", - " Note that for the interpolation of a `Field`, the second option (`value = fieldset.U[particle]`) is not only a short-hand notation for the (`value = fieldset.U[time, particle.depth, particle.lat, particle.lon]`); it is actually a _faster_ way to interpolate the field at the particle location in Scipy mode, as described in [this section of the JIT-vs-Scipy tutorial](https://docs.oceanparcels.org/en/latest/examples/tutorial_jit_vs_scipy.html#Further-digging-into-Scipy-mode:-adding-particle-keyword-to-Field-sampling).\n", + " Note that for the interpolation of a `Field`, the second option (`value = fieldset.U[particle]`) is not only a short-hand notation for the (`value = fieldset.U[time, particle.depth, particle.lat, particle.lon]`); it is actually a _faster_ way to interpolate the field at the particle location in Scipy mode.\n", " \n", "
" ] @@ -360,18 +334,9 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in GCParticles.zarr.\n", - "100%|██████████| 2073600.0/2073600.0 [00:04<00:00, 444884.89it/s]\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "output_file = pset.ParticleFile(\n", " name=\"GCParticles.zarr\", # the name of the output file\n", @@ -453,26 +418,6 @@ "- [Optimising the partitioning of the particles with a user-defined partition function](https://docs.oceanparcels.org/en/latest/examples/documentation_MPI.html#Optimising-the-partitioning-of-the-particles-with-a-user-defined-partition_function)\n", "- [Future developments: load balancing](https://docs.oceanparcels.org/en/latest/examples/documentation_MPI.html#Future-developments:-load-balancing)" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Another good way to optimise Parcels and speed-up execution is to chunk the `FieldSet` with `dask`, using the `chunksize` argument in the `FieldSet` creation. This will allow Parcels to load the `FieldSet` in chunks. \n", - "\n", - "Using chunking can be especially useful when working with large datasets _and_ when the particles only occupy a small region of the domain.\n", - "\n", - "Note that the **default** is `chunksize=None`, which means that the `FieldSet` is loaded in its entirety. This is generally the most efficient way to load the `FieldSet` when the particles are spread out over the entire domain.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### For more tutorials chunking and dask:\n", - "\n", - "- [Chunking the FieldSet with dask](https://docs.oceanparcels.org/en/latest/examples/documentation_MPI.html#Chunking-the-FieldSet-with-dask)" - ] } ], "metadata": { diff --git a/docs/examples/tutorial_particle_field_interaction.ipynb b/docs/examples/tutorial_particle_field_interaction.ipynb index c8c2f7196..793c92ca6 100644 --- a/docs/examples/tutorial_particle_field_interaction.ipynb +++ b/docs/examples/tutorial_particle_field_interaction.ipynb @@ -3,7 +3,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "202f4da1", + "id": "0", "metadata": {}, "source": [ "# Particle-Field interaction\n", @@ -12,7 +12,7 @@ "\n", "The concept is similar to that of [Field sampling](https://docs.oceanparcels.org/en/latest/examples/tutorial_sampling.html): here instead, on top of reading the field value at their location, particles are able to alter it as defined in the `Kernel`. To do this, it is important to keep in mind that:\n", "\n", - "- Particles have to be defined as `ScipyParticles`\n", + "- Particles have to be defined as `Particles`\n", "- `Field` writing at each `outputdt` is not default and has to be enabled\n", "- The time of the `Field` to be saved has to be updated within a `Kernel`\n", "\n", @@ -30,7 +30,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "c6d39d45", + "id": "1", "metadata": {}, "source": [ "## Particle altering a Field during advection\n" @@ -38,8 +38,8 @@ }, { "cell_type": "code", - "execution_count": 1, - "id": "b5f35c63", + "execution_count": null, + "id": "2", "metadata": {}, "outputs": [], "source": [ @@ -56,7 +56,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "068921eb", + "id": "3", "metadata": {}, "source": [ "In this specific example, particles will be advected by surface ocean velocities stored in netCDF files in the folder `GlobCurrent_example_data`. We will store these in a `FieldSet` object, and then add a `Field` to it to represent the tracer field. This latter field will be initialized with zeroes, as we assume that this tracer is absent on the ocean surface and released by particles only. Note that, in order to conserve mass, it is important to set `interp_method='nearest'` for the tracer Field.\n", @@ -66,8 +66,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "a64ed4f0", + "execution_count": null, + "id": "4", "metadata": {}, "outputs": [], "source": [ @@ -103,7 +103,7 @@ "# For mass conservation, interp_method='nearest'\n", "fieldC = parcels.Field(\"C\", dataC, grid=field_for_size.U.grid, interp_method=\"nearest\")\n", "\n", - "# aad C field to the velocity FieldSet\n", + "# add C field to the velocity FieldSet\n", "fieldset.add_field(fieldC)\n", "\n", "# enable the writing of Field C during execution\n", @@ -113,7 +113,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "6caf2eb7", + "id": "5", "metadata": {}, "source": [ "Some global parameters have to be defined, such as $a$ and $b$ of Eq.1, and a weight that works as a conversion factor from $\\Delta c_{particle}$ to $C_{field}$.\n", @@ -122,8 +122,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "54ec0e6f", + "execution_count": null, + "id": "6", "metadata": {}, "outputs": [], "source": [ @@ -135,10 +135,10 @@ { "attachments": {}, "cell_type": "markdown", - "id": "470c2e80", + "id": "7", "metadata": {}, "source": [ - "We will now define a new particle class. A `VectorParticle` is a `ScipyParticle` having a `Variable` to store the current tracer concentration `c` associated with it. As in this case we want our particles to release a tracer into a clean field, we will initialize `c` with an arbitrary value of `100`.\n", + "We will now define a new particle class. A `VectorParticle` is a `Particle` having a `Variable` to store the current tracer concentration `c` associated with it. As in this case we want our particles to release a tracer into a clean field, we will initialize `c` with an arbitrary value of `100`.\n", "\n", "We also need to define the `Kernel` that performs the particle-field interaction. In this Kernel, we will implement Eq.1, so that $\\Delta c_{particle}$ can be used to update $c_{particle}$ and $C_{field}$ at the particle location, and thus get their values at the current time $t$.\n", "\n", @@ -147,14 +147,12 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "203a82eb", + "execution_count": null, + "id": "8", "metadata": {}, "outputs": [], "source": [ - "VectorParticle = parcels.ScipyParticle.add_variable(\n", - " \"c\", dtype=np.float32, initial=100.0\n", - ")\n", + "VectorParticle = parcels.Particle.add_variable(\"c\", dtype=np.float32, initial=100.0)\n", "\n", "\n", "def Interaction(particle, fieldset, time):\n", @@ -163,10 +161,9 @@ " with a and b as the rate constants\"\"\"\n", " deltaC = fieldset.a * fieldset.C[particle] - fieldset.b * particle.c\n", "\n", - " xi, yi = (\n", - " particle.xi[fieldset.C.igrid],\n", - " particle.yi[fieldset.C.igrid],\n", - " )\n", + " ei = fieldset.C.unravel_index(particle.ei)\n", + " xi, yi = ei[2], ei[1]\n", + "\n", " if abs(particle.lon - fieldset.C.grid.lon[xi + 1]) < abs(\n", " particle.lon - fieldset.C.grid.lon[xi]\n", " ):\n", @@ -199,7 +196,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "2a6783bf", + "id": "9", "metadata": {}, "source": [ "Three things are worth noticing in the code above:\n", @@ -210,15 +207,13 @@ "\n", "Because `fieldset.C[particle]` interpolates the $C_{field}$ value from the nearest grid cell to the particle, it is important to also write to that same grid cell. That is not completely trivial to do in Parcels, which is why lines 7-11 in the cell above calculate which `xi` and `yi` are closest to the particle longitude and latitude (this extends trivially to depth too). Our first guess is `particle.xi[fieldset.C.igrid]`, the location in the particular grid, but it could be that `xi+1` is closer, which is what the `if`-statements are for.\n", "\n", - "The new indices are then used in `fieldset.C.data[0, yi, xi]` to access the field value in the cell where the particle is found, that can be different from the result of the interpolation at the particle's coordinates. Note that here we need to use `fieldset.C.data[0, yi, xi]` both for calculating `deltaC` and for the consequent update of the cell value for consistency between the forcing (the seawater-particle gradient) and its effect (the exchange, and consequent alteration of the field).\n", - "\n", - "Remember that reading and writing `Fields` at particle location through particle indices is only possible for `ScipyParticles` (and returns an error if `JITParticles` are used).\n" + "The new indices are then used in `fieldset.C.data[0, yi, xi]` to access the field value in the cell where the particle is found, that can be different from the result of the interpolation at the particle's coordinates. Note that here we need to use `fieldset.C.data[0, yi, xi]` both for calculating `deltaC` and for the consequent update of the cell value for consistency between the forcing (the seawater-particle gradient) and its effect (the exchange, and consequent alteration of the field).\n" ] }, { "attachments": {}, "cell_type": "markdown", - "id": "93994a91", + "id": "10", "metadata": {}, "source": [ "Now we are going to execute the advection of the particle and the simultaneous release of the tracer it carries. We will thus add the `interactionKernel` defined above to the built-in Kernel `AdvectionRK4`.\n", @@ -230,19 +225,10 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "d20fcba8", + "execution_count": null, + "id": "11", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in interaction.zarr.\n", - "100%|██████████| 2160000.0/2160000.0 [00:00<00:00, 2741732.73it/s]\n" - ] - } - ], + "outputs": [], "source": [ "output_file = pset.ParticleFile(name=r\"interaction.zarr\", outputdt=timedelta(days=1))\n", "\n", @@ -264,7 +250,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "42182927", + "id": "12", "metadata": {}, "source": [ "We can see that $c_{particle}$ has been saved along with particle trajectory, as expected.\n" @@ -272,32 +258,10 @@ }, { "cell_type": "code", - "execution_count": 6, - "id": "a6d869e8", + "execution_count": null, + "id": "13", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[80. 64. 51.2 40.96 32.767998 26.214397\n", - " 20.971518 16.777214 13.421771 10.737417 8.858369 7.5430355\n", - " 6.3699727 5.0959783 4.0767827 3.2614262 2.6906767 2.1525414\n", - " 1.7220331 1.4206773 1.1365418 0.93764704 0.75011766 0.60009414\n", - " 0.49882826]]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "pset_traj = xr.open_zarr(r\"interaction.zarr\")\n", "\n", @@ -310,7 +274,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "3fcc6dca", + "id": "14", "metadata": {}, "source": [ "But what about `fieldset.C`? We can see that it has been accordingly modified during particle motion. Using `fieldset.C` we can access the field as resulting at the end of the run, with no information about the previous time steps.\n" @@ -318,21 +282,10 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "184d6860", + "execution_count": null, + "id": "15", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Copy the final field data in a new array\n", "c_results = fieldset.C.data[0, :, :].copy()\n", @@ -385,7 +338,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "52a42fbe", + "id": "16", "metadata": {}, "source": [ "When looking at tracer concentrations, we see that $c_{particle}$ decreases along its trajectory (right to left), as it is releasing the tracer it carries. Accordingly, values of $C_{field}$ provided by particle interaction progressively reduce along the particle's route.\n", @@ -396,21 +349,10 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "e2ce3270", + "execution_count": null, + "id": "17", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+wAAALBCAYAAADCnCvUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACyQUlEQVR4nOzdd3yN5//H8fdJZJOIhMSm9p5FbLWpotUaLb5Fly6rLeWL6tCp1UGXVlWLtnRotcQstYmtqC0SJEFCZJ7794ev83Oa4SRyBuf1fDzuxyO57mt87nMjPrnu+7pMhmEYAgAAAAAALsXD2QEAAAAAAICsSNgBAAAAAHBBJOwAAAAAALggEnYAAAAAAFwQCTsAAAAAAC6IhB0AAAAAABdEwg4AAAAAgAsiYQcAAAAAwAWRsAMAAAAA4IJI2AEAAAAAcEEk7AAAAAAAuCASdgAAgHxav369Jk+erAsXLji0/9mzZ8tkMunYsWN2GRcA4BpI2AEAAPJp/fr1eumll+yasGfXf/fu3bVhwwaVLFnSLuMCAFxDIWcHAAAA4C6Sk5Pl7+9/0/0UL15cxYsXL4CIAACujBl2AAAcaO3aterdu7dKlCghX19fVapUSc8//7yzwypQf//9t/r376+wsDD5+PioXLlyGjRokFJTU63qrVu3Tu3bt1eRIkXk7++v5s2b67fffrOqM3nyZJlMJu3du1f9+/dXUFCQwsLCNGTIEF28eDHP4x46dEgDBgxQiRIl5OPjoxo1auijjz7Kcg22jDt58mQ999xzkqSKFSvKZDLJZDJp9erVVn1s375dffr0UXBwsCpVqiRJ+ueff/Twww+rSpUq8vf3V+nSpdWjRw/t3r3bKoac+s/pkfiC/kwBAM7FDDsAAA4ybdo0jRkzRr1799b777+v0NBQ7dy5U3///bezQyswO3fuVMuWLRUaGqopU6aoSpUqiomJ0S+//KK0tDT5+PhIktasWaOOHTuqbt26mjVrlnx8fDRjxgz16NFD8+bNU9++fa36ve+++9S3b18NHTpUu3fv1rhx4yRJX3zxhc3j7tu3T82bN1e5cuX0zjvvKDw8XEuXLtUzzzyjuLg4TZo0Kcv15DbusGHDlJCQoA8++ECLFi2yPJ5es2ZNqz7uvfde9evXT48//rguX74sSTp9+rRCQkL0+uuvq3jx4kpISNBXX32lpk2bKioqStWqVcu1/+zeXS/ozxQA4AIMAABgd7///rshyXjrrbccMp7ZbDaKFClixMTEWMpSUlKMsLAw48KFC7m2K1y4sHHmzJl8jXvXXXcZRYsWNc6ePZtrvWbNmhklSpQwkpKSLGUZGRlG7dq1jTJlyhhms9kwDMOYNGmSIcl48803rdoPHz7c8PX1tdSzZdzOnTsbZcqUMS5evGhV/tRTTxm+vr5GQkKCpczWcd966y1DknH06NEs413rY+LEibl+FteuPS0tzahSpYoxcuRIS3lO/X/55ZdZygv6MwUAOB+PxAMA4AAvvviiGjdurDFjxth9rIyMDB07dkw+Pj4KDw+3lPv4+Cg2NlZBQUE5tj106JACAwNVokSJPI+bnJysNWvW6IEHHsj1/erLly9r06ZN6tOnjwoXLmwp9/T01MCBA3Xq1CkdOHDAqs0999xj9X3dunWVkpKis2fP2jRuSkqKVqxYod69e8vf318ZGRmWo1u3bkpJSdHGjRuztMttXFvdd999WcoyMjL02muvqWbNmvL29lahQoXk7e2tQ4cOaf/+/Tb3fU1Bf6YAANdAwg4AgJ3FxMQoKipK/fv3z7XeJ598og4dOqhr164qVqyYateurX379kmSTp48qa5du6p48eIqWrSoHn30UZnNZknS9OnTdd9992nAgAEqUqSIZsyYoRo1auj8+fMqXLiwGjVqZKk3bNgwy3iff/656tSpoyJFiqhOnTo6fvy4tm/frgYNGkiSzGazpk2bpqpVqyo4OFiDBw9WWlpajvGfP39emZmZKlOmTK7Xef78eRmGke0K56VKlZIkxcfHW5WHhIRYfX/t0forV67YNG58fLwyMjL0wQcfyMvLy+ro1q2bJCkuLi5Lu9zGtVV21zlq1Cj997//Va9evbR48WJt2rRJW7ZsUb169fLU9zUF/ZkCAFwD77ADAGBn0dHRkqTSpUvnWm/Pnj3asmWLvvvuO9111116/PHHNWHCBC1atEhJSUkaN26cIiIidPr0abVs2VIrVqxQx44dtWvXLq1Zs0Y//PCD5s6dq8zMTKWkpOjYsWOaMWOGpf9du3apbt26kqRXXnlFP//8s7777jtVrVpVf/31l4oXL66oqCg1bNhQkjRx4kStXbtWq1atUlBQkHr27KnPPvtMTz75ZLbxFytWTJ6enjp16lSu1xkcHCwPDw/FxMRkOXf69GlJUmhoaK595HXc4OBgy2xzTvFXrFjR5jHzwmQyZSmbO3euBg0apNdee82qPC4uTkWLFs3zGAX9mQIAXAMz7AAA2Nm1RH3Xrl251tuzZ48mTJigzp07y8vLSw8++KAOHjwo6epCY61bt5aXl5fKly+vZs2a6fz585Z+J06cqLZt28rDw0NeXl7atWuX6tWrZ9X/tYT9zJkzeuutt/Ttt9+qRo0a8vT0VOvWreXv76+oqCg1aNBAMTExmj59uubNm6fSpUurcOHC6t+/v7Zt25Zj/H5+fmrTpo2+//77bGerrwkICFDTpk21aNEiq9lcs9msuXPnqkyZMqpatWruH2oex/X391e7du0UFRWlunXrqnHjxlmOf8842yK/s9Imk8nS9prffvvN8sudvPZf0J8pAMA1MMMOAICdlSxZUp07d9a0adPk5+en5s2bKykpSRs2bFCNGjU0ePBgSdLevXs1a9YsS7uzZ89aZkW//fZbTZ8+XYcPH1ZGRoYuXbqkF198UWazWfv27cvynvTOnTv11FNPWb6/Vq9u3br6/fff1axZM1WpUiVLrNcS9uXLlyslJcVqxfPMzEyrR+qzM23aNLVs2VJNmzbV2LFjVblyZZ05c0a//PKLPvnkExUpUkSSNHXqVHXs2FHt2rXTmDFj5O3trRkzZmjPnj2aN29etrPSNzvu9OnT1bJlS7Vq1UpPPPGEKlSooKSkJP3zzz9avHixVq5cmacxJalOnTqSrr5uMHjwYHl5ealatWqW68zJ3XffrdmzZ6t69eqqW7eutm3bprfeeivLY/059Z+dgv5MAQDOxww7AAAOMG/ePD322GP64osv1LVrVz3yyCPauXOnGjduLOlqcn7u3Dmrxd5+/PFHde3aVcuWLdPLL7+szz77TGfOnNGhQ4fk6+urWrVq6Z9//lGRIkWsHrdPS0vTwYMHLcmedHXf76CgIIWEhCg+Pj7bx65PnjypzMxMVahQQQkJCXrooYd04cIFy5GUlKR333031+usV6+eNm/erEaNGmncuHHq0qWLXnjhBfn4+Mjb29tSr02bNlq5cqUCAgL0n//8R/369dPFixf1yy+/ZNl+zBa2jFuzZk1t375dtWvX1oQJE9SpUycNHTpUP/zwg9q3b5/nMSWpbdu2GjdunBYvXqyWLVvqzjvvzPUphGumT5+uhx56SFOnTlWPHj30yy+/aNGiRZZ92vPTf0F/pgAA5zMZhmE4OwgAANzdihUr1LlzZ3388ccaPHiw5syZo5dfflk7d+7Up59+qpUrV+qHH35QQkKChg0bppiYGO3atUs//PCDPvvsMy1dutTSV3x8vEqWLKkzZ84oODhYkvTDDz/o888/1x9//KHVq1frgQce0Lp161S5cmXt2rVLxYsX17Zt2zR9+nStWLFCa9euVd++fbVixQrVqFFD8fHx2rJli7p06eKsjwgAALfDDDsAAC5gz549GjJkiObPn6+QkBDNnTtXkZGRCgoK0oMPPqj4+HiVKFFCgwYNUs2aNS3vp+/evduykNw1ISEhGjBggMqVK6cmTZpkqde2bVs988wzatu2rYKCgvTII4+oUKFClsfhJalVq1YaOXKkOnXqpMKFC6tJkyY3fAcfAAAULGbYAQBwAY888ogaN26sxx57zNmhAAAAF8EMOwAALmDPnj2qXr26s8MAAAAuhBl2AABcQFBQkA4ePKiwsDBnhwIAAFwECTsAAAAAAC6IR+IBAAAAAHBBJOwAAAAAALggEnYAAAAAAFwQCTsAAAAAAC7ILRP2GTNmqGLFivL19VWjRo20du1aZ4d0W/vzzz/Vo0cPlSpVSiaTST/99JPVecMwNHnyZJUqVUp+fn5q27at9u7d65xgb1NTp07VnXfeqSJFiqhEiRLq1auXDhw4YFWH+2B/M2fOVN26dRUYGKjAwEBFRETo999/t5znHjjH1KlTZTKZNGLECEsZ98L+Jk+eLJPJZHWEh4dbznMPHCc6OloPPfSQQkJC5O/vr/r162vbtm2W89wLx6hQoUKWvxMmk0lPPvmkJO6DI2RkZGjChAmqWLGi/Pz8dMcdd2jKlCkym82WOtwHOJrbJewLFizQiBEjNH78eEVFRalVq1bq2rWrTpw44ezQbluXL19WvXr19OGHH2Z7/s0339S0adP04YcfasuWLQoPD1fHjh2VlJTk4EhvX2vWrNGTTz6pjRs3KjIyUhkZGerUqZMuX75sqcN9sL8yZcro9ddf19atW7V161bddddd6tmzp+UHPffA8bZs2aJPP/1UdevWtSrnXjhGrVq1FBMTYzl2795tOcc9cIzz58+rRYsW8vLy0u+//659+/bpnXfeUdGiRS11uBeOsWXLFqu/D5GRkZKk+++/XxL3wRHeeOMNffzxx/rwww+1f/9+vfnmm3rrrbf0wQcfWOpwH+Bwhptp0qSJ8fjjj1uVVa9e3Rg7dqyTInIvkowff/zR8r3ZbDbCw8ON119/3VKWkpJiBAUFGR9//LETInQPZ8+eNSQZa9asMQyD++BMwcHBxueff849cIKkpCSjSpUqRmRkpNGmTRvj2WefNQyDvw+OMmnSJKNevXrZnuMeOM4LL7xgtGzZMsfz3AvnefbZZ41KlSoZZrOZ++Ag3bt3N4YMGWJVdu+99xoPPfSQYRj8fYBzuNUMe1pamrZt26ZOnTpZlXfq1Enr1693UlTu7ejRo4qNjbW6Jz4+PmrTpg33xI4uXrwoSSpWrJgk7oMzZGZmav78+bp8+bIiIiK4B07w5JNPqnv37urQoYNVOffCcQ4dOqRSpUqpYsWK6tevn44cOSKJe+BIv/zyixo3bqz7779fJUqUUIMGDfTZZ59ZznMvnCMtLU1z587VkCFDZDKZuA8O0rJlS61YsUIHDx6UJO3cuVPr1q1Tt27dJPH3Ac5RyNkBOFJcXJwyMzMVFhZmVR4WFqbY2FgnReXern3u2d2T48ePOyOk255hGBo1apRatmyp2rVrS+I+ONLu3bsVERGhlJQUFS5cWD/++KNq1qxp+UHPPXCM+fPna/v27dqyZUuWc/x9cIymTZtqzpw5qlq1qs6cOaNXXnlFzZs31969e7kHDnTkyBHNnDlTo0aN0osvvqjNmzfrmWeekY+PjwYNGsS9cJKffvpJFy5c0H/+8x9J/LvkKC+88IIuXryo6tWry9PTU5mZmXr11VfVv39/SdwHOIdbJezXmEwmq+8Nw8hSBsfinjjOU089pV27dmndunVZznEf7K9atWrasWOHLly4oIULF2rw4MFas2aN5Tz3wP5OnjypZ599VsuWLZOvr2+O9bgX9tW1a1fL13Xq1FFERIQqVaqkr776Ss2aNZPEPXAEs9msxo0b67XXXpMkNWjQQHv37tXMmTM1aNAgSz3uhWPNmjVLXbt2ValSpazKuQ/2tWDBAs2dO1fffvutatWqpR07dmjEiBEqVaqUBg8ebKnHfYAjudUj8aGhofL09Mwym3727NksvymDY1xbEZh74hhPP/20fvnlF61atUplypSxlHMfHMfb21uVK1dW48aNNXXqVNWrV0/Tp0/nHjjQtm3bdPbsWTVq1EiFChVSoUKFtGbNGr3//vsqVKiQ5fPmXjhWQECA6tSpo0OHDvH3wYFKliypmjVrWpXVqFHDshgv98Lxjh8/ruXLl2vYsGGWMu6DYzz33HMaO3as+vXrpzp16mjgwIEaOXKkpk6dKon7AOdwq4Td29tbjRo1sqy6eU1kZKSaN2/upKjcW8WKFRUeHm51T9LS0rRmzRruSQEyDENPPfWUFi1apJUrV6pixYpW57kPzmMYhlJTU7kHDtS+fXvt3r1bO3bssByNGzfWgw8+qB07duiOO+7gXjhBamqq9u/fr5IlS/L3wYFatGiRZZvPgwcPqnz58pL4+eAMX375pUqUKKHu3btbyrgPjpGcnCwPD+v0yNPT07KtG/cBTuGcte6cZ/78+YaXl5cxa9YsY9++fcaIESOMgIAA49ixY84O7baVlJRkREVFGVFRUYYkY9q0aUZUVJRx/PhxwzAM4/XXXzeCgoKMRYsWGbt37zb69+9vlCxZ0khMTHRy5LePJ554wggKCjJWr15txMTEWI7k5GRLHe6D/Y0bN874888/jaNHjxq7du0yXnzxRcPDw8NYtmyZYRjcA2e6fpV4w+BeOMLo0aON1atXG0eOHDE2btxo3H333UaRIkUsP4+5B46xefNmo1ChQsarr75qHDp0yPjmm28Mf39/Y+7cuZY63AvHyczMNMqVK2e88MILWc5xH+xv8ODBRunSpY1ff/3VOHr0qLFo0SIjNDTUeP755y11uA9wNLdL2A3DMD766COjfPnyhre3t9GwYUPL1lawj1WrVhmSshyDBw82DOPqFhmTJk0ywsPDDR8fH6N169bG7t27nRv0bSa7z1+S8eWXX1rqcB/sb8iQIZZ/e4oXL260b9/ekqwbBvfAmf6dsHMv7K9v375GyZIlDS8vL6NUqVLGvffea+zdu9dynnvgOIsXLzZq165t+Pj4GNWrVzc+/fRTq/PcC8dZunSpIck4cOBAlnPcB/tLTEw0nn32WaNcuXKGr6+vcccddxjjx483UlNTLXW4D3A0k2EYhlOm9gEAAAAAQI7c6h12AAAAAABuFSTsAAAAAAC4IBJ2AAAAAABcEAk7AAAAAAAuiIQdAAAAAAAX5JYJe2pqqiZPnqzU1FRnh+LWuA+ugfvgGrgProH74Bq4D66B++AauA+ugfsAZ3HLbd0SExMVFBSkixcvKjAw0NnhuC3ug2vgPrgG7oNr4D64Bu6Da+A+uAbug2vgPsBZ3HKGHQAAAAAAV0fCDgAAAACACyrk7ACcKTEx0dkhuLVrnz/3wbm4D66B++AauA+ugfvgGrgProH74Br4/OEsbvkO+8WLFxVSNESZynR2KAAAAABuAYULF9apU6cUFBTk7FDgRtxyht1kMilTmWqpbiokL8n0/28GmDxM/6qcwznTdV/nUG7y8Mihfg7l17e9btyc+repT0m6/lsb4pYtYytvn4VhVSeHeHL62ub2OdTP4fptqpPDWEZOn2lOMfwr7pzGzqlfq9+qXV/HI6eYbOgzj/VzbeORQ3kufd24/s2U53Bvc2lTYHHIhjrXl+dQ35a2uZ6zpf1NXLNNMdha56auwbChji395NCncpDrfTCyr2fDeDnHmn0dU17HVQ51JJlM2V+tKY9jm6y+vnF8VvVzGDfHH33/itlkQxweOdTxkC1xXFffhnKrPnOq869ryOmcyYY6OX6tnOqYcxgrp7b/X98zh/6z9vv/5Z5Wn0f2Y1v3m0OdnMqv6/P6a/C0Guu6a8gh5n/HanU9NsRkNV5OcVzfj9W4OcWa02ef/bhZx8g+Ds8c7nVOdUw5XXMOf8auL7euc32c18dgzdPqz48p23qepuvLb/y1dX2PHOpkLU9MMqt8o2My5fT/GcBO3DJhv6aQvFTI9K+EPUuym8M5Ux6TblvaeuTQ9qYT9hz/p3Pj+GwZ22US9ryNd0sl7Dn95/sWTdgLLjHPqTyHe5tLG3vEcVsn7DbGZ1Odm4rDzgl7Tv8vy/U+3AYJu8mW8uzHzjnRvpmE/cbJd37a5Jiw21LfwQl7zkl3wSfsttS3PWHPKWGzb8KeY6KcU7JqY8Ke49g3kbB7WvXz/3/4PK77g3h9ufVndH259V9q6wTXyLaedcJ+fUzKvo5VrLbUuXHC7mmnhN26fvafk20JO0t+wbn4EwgAAAAAgAsiYQcAAAAAwAWRsAMAAAAA4IJI2AEAAAAAcEEk7AAAAAAAuCASdgAAAAAAXBAJOwAAAAAALoiEHQAAAAAAF0TCDgAAAACACyJhBwAAAADABZGwAwAAAADggkjYAQAAAABwQSTsAAAAAAC4IBJ2AAAAAABcEAk7AAAAAAAuiIQdAAAAAAAXRMIOAAAAAIALImEHAAAAAMAFkbADAAAAAOCCSNgBAAAAAHBBJOwAAAAAALggEnYAAAAAAFwQCTsAAAAAAC6IhB0AAAAAABdEwg4AAAAAgAsiYQcAAAAAwAWRsAMAAAAA4IJI2AEAAAAAcEEk7AAAAAAAuCASdgAAAAAAXBAJOwAAAAAALoiEHQAAAAAAF0TCDgAAAACACyJhBwAAAADABZGwAwAAAADgggo5OwBnylC6ZEjX/97CZJj+VSunc9d9nUO5yfDItlw5lZuva2vKoY4ph6+v/92L6V/XYBVeDtdg1a8NY+dUbmRfbljVySGeHK/N1vY51DdnX9/Ioa1VHY8cynP6THOKQbK6RTmNnVO/11+yVaweOcVkQ595rJ9rm5z+qOfS143r30x5Dvc2lzYFFodsqJPDH+e8xpPrOVva38Q12xSDrXVu6hoMG+rY0k8OfSoHud4HI/t6NoyXc6zZ1zHldVzlUEeSyZT91ZryOLbJ6usbx2dVP4dxc/rxYPwrZpMNcRg51DGUfRzmHOp72FDuIRvq/OsacjpnsqFOjl8rpzrmbMtNyqnt/9f3zKH/rP3+f7mn1eeR/djW/eZQJ6fy6/q8/ho8rca67hpyiPnfsVpdjw0xWY2XUxzX92M1bk6x5vTZZz9u1jGyj8Mzh3udUx1TTtecw5+x68ut61wf5/UxWPO0+vNjyraep+n68ht/bV1fOdTJGl9ikvXnCziKWybs3t7eCg8P17rYJVcLrv85k+mUkAAAAAC4sPDwcHl7ezs7DLgZk2EYOU4g3M5SUlKUlpbm7DAAAAAA3AK8vb3l6+vr7DDgZtw2YQcAAAAAwJWx6BwAAAAAAC6IhB0AAAAAABdEwg4AAAAAgAsiYQcAAAAAwAWRsAMAAAAA4IJI2AEAAAAAcEEk7AAAAAAAuCASdgAAAAAAXBAJOwAAAAAALoiEHQAAAAAAF0TCDgAAAACACyJhBwAAAADABZGwAwAAAADggkjYAQAAAABwQSTsAAAAAAC4IBJ2AAAAAABcEAk7AAAAAAAuiIQdAAAAAAAXRMIOAAAAAIALImEHAAAAAMAFkbADAAAAAOCCSNgBAAAAAHBBJOwAAAAAALggEnYAAAAAAFwQCTsAAAAAAC6IhB0AAAAAABdEwg4AAAAAgAuya8J+zz33qFy5cvL19VXJkiU1cOBAnT59Otu68fHxKlOmjEwmky5cuJBrv23btpXJZLI6+vXrZ4crAAAAAADY24wZM1SxYkX5+vqqUaNGWrt2bY51Fy1apI4dO6p48eIKDAxURESEli5dmqXewoULVbNmTfn4+KhmzZr68ccfb2pcZ7Brwt6uXTt99913OnDggBYuXKjDhw+rT58+2dYdOnSo6tata3PfjzzyiGJiYizHJ598UlBhAwAAAAAcZMGCBRoxYoTGjx+vqKgotWrVSl27dtWJEyeyrf/nn3+qY8eOWrJkibZt26Z27dqpR48eioqKstTZsGGD+vbtq4EDB2rnzp0aOHCgHnjgAW3atCnf4zqDyTAMw1GD/fLLL+rVq5dSU1Pl5eVlKZ85c6YWLFigiRMnqn379jp//ryKFi2aYz9t27ZV/fr19d5779k0bmpqqlJTUy3fm81mJSQkKCQkRCaTKb+XAwAAAMANGIahpKQklSpVSh4et+ZbxSkpKUpLS3PYeIZhZMm1fHx85OPjk6Vu06ZN1bBhQ82cOdNSVqNGDfXq1UtTp061abxatWqpb9++mjhxoiSpb9++SkxM1O+//26p06VLFwUHB2vevHkFNq7dGQ4SHx9vPPDAA0aLFi2syvfu3WuEh4cbx48fN1atWmVIMs6fP59rX23atDFCQ0ONkJAQo2bNmsbo0aONxMTEHOtPmjTJkMTBwcHBwcHBwcHBwZHv4+TJkwWRGjnclStXjPASng79rAoXLpylbNKkSVliS01NNTw9PY1FixZZlT/zzDNG69atbbq+zMxMo2zZssYHH3xgKStbtqwxbdo0q3rTpk0zypUrV2DjOkIh2dkLL7ygDz/8UMnJyWrWrJl+/fVXy7nU1FT1799fb731lsqVK6cjR47Y1OeDDz6oihUrKjw8XHv27NG4ceO0c+dORUZGZlt/3LhxGjVqlOX7ixcvqly5clq+fLkCAgJu7gIBAAAA3NYuX76sDh06qEiRIs4OJV/S0tIUezZTx7dVUGAR+z8hkJhkVvlGx3Ty5EkFBgZayrObXY+Li1NmZqbCwsKsysPCwhQbG2vTeO+8844uX76sBx54wFIWGxuba58FMa4j5Dlhnzx5sl566aVc62zZskWNGzeWJD333HMaOnSojh8/rpdeekmDBg3Sr7/+KpPJpHHjxqlGjRp66KGH8hTDI488Yvm6du3aqlKliho3bqzt27erYcOGWern9OhFQECAChcunKexAQAAALinW/112sJFTCpcxP7XYNbVMQIDA60S9tz8+7M1snmkPjvz5s3T5MmT9fPPP6tEiRJ57jO/4zpKnhP2p5566oYrsleoUMHydWhoqEJDQ1W1alXVqFFDZcuW1caNGxUREaGVK1dq9+7d+uGHHyRd/XCutRk/fvwNfzFwTcOGDeXl5aVDhw5lm7ADAAAAAFxPaGioPD09s8xqnz17Nsvs978tWLBAQ4cO1ffff68OHTpYnQsPD8+1z5sZ15HynLBfS8Dz41pCfm0BuIULF+rKlSuW81u2bNGQIUO0du1aVapUyeZ+9+7dq/T0dJUsWTJfcQEAAADA7S7TMCvTcMw4tvL29lajRo0UGRmp3r17W8ojIyPVs2fPHNvNmzdPQ4YM0bx589S9e/cs5yMiIhQZGamRI0daypYtW6bmzZvf1LiOZrd32Ddv3qzNmzerZcuWCg4O1pEjRzRx4kRVqlRJERERkpQlKY+Li5N0dWW+a6vER0dHq3379pozZ46aNGmiw4cP65tvvlG3bt0UGhqqffv2afTo0WrQoIFatGhhr8sBAAAAANjBqFGjNHDgQDVu3FgRERH69NNPdeLECT3++OOSrq5JFh0drTlz5ki6mqwPGjRI06dPV7NmzSyz5H5+fgoKCpIkPfvss2rdurXeeOMN9ezZUz///LOWL1+udevW2TyuK7Bbwu7n56dFixZp0qRJunz5skqWLKkuXbpo/vz52b5PnpP09HQdOHBAycnJkq7+JmTFihWaPn26Ll26pLJly6p79+6aNGmSPD097XU5AAAAAAA76Nu3r+Lj4zVlyhTFxMSodu3aWrJkicqXLy9JiomJsdob/ZNPPlFGRoaefPJJPfnkk5bywYMHa/bs2ZKk5s2ba/78+ZowYYL++9//qlKlSlqwYIGaNm1q87iuwKH7sLuKxMREBQUFacOGDSw6BwAAACBXly5dUkREhC5evGjzImqu5Fr+E3ugnMNWiQ+vduKW/bxcif3vFgAAAAAAyDO778MOAAAAAHA+s8yyfTm4mxsHBYMZdgAAAAAAXBAz7AAAAADgBjINQ5kOWMLMEWO4C2bYAQAAAABwQcywAwAAAIAbMMuQWfaf/XbEGO6CGXYAAAAAAFwQM+wAAAAA4AbMMpTJDPsthRl2AAAAAABcEDPsAAAAAOAGeIf91sMMOwAAAAAALogZdgAAAABwA+zDfuthhh0AAAAAABfEDDsAAAAAuAHz/w5HjIOCwQw7AAAAAAAuiIQdAAAAAAAXxCPxAAAAAOAGMmUo0wFbrjliDHfBDDsAAAAAAC6IGXYAAAAAcAOZxtXDEeOgYDDDDgAAAACAC2KGHQAAAADcANu63XqYYQcAAAAAwAUxww4AAAAAbsAskzJlcsg4KBjMsAMAAAAA4IKYYQcAAAAAN2A2rh6OGAcFgxl2AAAAAABcEDPsAAAAAOAGMh30DrsjxnAXzLADAAAAAOCCmGEHAAAAADfADPuthxl2AAAAAABcEDPsAAAAAOAGzIZJZsMB+7A7YAx3wQw7AAAAAAAuiIQdAAAAAAAXxCPxAAAAAOAGWHTu1sMMOwAAAAAALogZdgAAAABwA5nyUKYD5mwz7T6C+2CGHQAAAAAAF8QMOwAAAAC4AcNB27oZbOtWYJhhBwAAAADABTHDDgAAAABugFXibz3MsAMAAAAA4IKYYQcAAAAAN5BpeCjTcMAq8Ybdh3AbzLADAAAAAOCCmGEHAAAAADdglklmB8zZmsUUe0Fhhh0AAAAAABfEDDsAAAAAuAFWib/1MMMOAAAAAIALYoYdAAAAuE3UDL3X2SHkyb64Rc4Owa04bpV43mEvKMywAwAAAADggphhBwAAAOBYHiGSKUheXl7KyMiQwYwskC0SdgAAAAAO4Cv5dZfJf4BMXnUkSdWKS5mZaTp/PlEJCQlKS0tzcoy3t6vbutl/QThHjOEuSNgBAAAA2FehqjIFfyp5hEupf8p8eYSUeVYy+cjDu7lCgvsqJKSKzpw5o7i4OGdHC7gMEnYAAAAA9uN5h0zF5kqZp2UkDJIyT1idNtL+ki69L1PhJxQePlwmk0nnzp1zUrC3N7M8lOmAZczM4hWHgkLCDgAAAMBuTEXflTLPykgYKBlJOdRKlXHpPRlGqsLCRurSpUu6cuWKQ+MEXBEJOwAAAAD78Gosk1cNmRMG5ZKsX+fyxzL73aeQkGI6dSra/vG5GbZ1u/WwrRsAAAAAuzD5D5CRcURK22hjC0NKnqugoEB5enraNTbgVkDCDgAAAMA+vOtLKcvz1iY1UiaTp/z8/OwSkjszy8NhBwoGnyQAAAAA+zAFyLDlUfjrma/W9/AgVXEnM2bMUMWKFeXr66tGjRpp7dq1OdaNiYnRgAEDVK1aNXl4eGjEiBFZ6rRt21YmkynL0b17d0udyZMnZzkfHh5uj8vLN/4WAAAAALAP8yWZPILy1uZ/9c1msx0Ccm+ZhslhR14sWLBAI0aM0Pjx4xUVFaVWrVqpa9euOnHiRLb1U1NTVbx4cY0fP1716tXLts6iRYsUExNjOfbs2SNPT0/df//9VvVq1aplVW/37t15it3eWHQOAAAAgH2kb5F8OktJb0uyMQH37SazOYNV4m8DiYmJVt/7+PjIx8cnS71p06Zp6NChGjZsmCTpvffe09KlSzVz5kxNnTo1S/0KFSpo+vTpkqQvvvgi27GLFStm9f38+fPl7++fJWEvVKiQy82qX48ZdgAAAAB2YSR/K1OhspJPaxtbeMjk96AuXkxUZmamXWNzR5n/24fdEYcklS1bVkFBQZYju+Q7LS1N27ZtU6dOnazKO3XqpPXr1xfYtc+aNUv9+vVTQECAVfmhQ4dUqlQpVaxYUf369dORI0cKbMyCwAw7AAAAAPtI3yUjLUqmIv+Vkb5bMsfnWt1U5HnJM0zx8YcdFCDs6eTJkwoMDLR8n93selxcnDIzMxUWFmZVHhYWptjY2AKJY/PmzdqzZ49mzZplVd60aVPNmTNHVatW1ZkzZ/TKK6+oefPm2rt3r0JCQgpk7JtFwg4AAADAbowLI2UKWSBTsXkyLoySMvZkrWQKlAqPkilggE6fPq2UlBTHB+oGzIaHzA7Yh938v33YAwMDrRL23JhM1u+9G4aRpSy/Zs2apdq1a6tJkyZW5V27drV8XadOHUVERKhSpUr66quvNGrUqAIZ+2aRsAMAAACwH/NpGQkDZAr+RB6hi2Sk7ZBx5SfJfEYy+UreLWTy7SGZCik6Olrnz593dsRwoNDQUHl6emaZTT979myWWff8SE5O1vz58zVlypQb1g0ICFCdOnV06NChmx63oJCwAwAAALCvzJMy4nrI8Gkrk/8AeQRNtpxKT7+ihHMXlJCQwHvrdnb9++X2Hcewua63t7caNWqkyMhI9e7d21IeGRmpnj173nQs3333nVJTU/XQQw/dsG5qaqr279+vVq1a3fS4BYWEHQAAAIADZEqpK2SkrpAhL8mjiP6O+4Lt26BRo0Zp4MCBaty4sSIiIvTpp5/qxIkTevzxxyVJ48aNU3R0tObMmWNps2PHDknSpUuXdO7cOe3YsUPe3t6qWbOmVd+zZs1Sr169sn0nfcyYMerRo4fKlSuns2fP6pVXXlFiYqIGDx5sv4vNIxJ2AAAAAA6WLpkTSNYhSerbt6/i4+M1ZcoUxcTEqHbt2lqyZInKly8vSYqJicmyJ3uDBg0sX2/btk3ffvutypcvr2PHjlnKDx48qHXr1mnZsmXZjnvq1Cn1799fcXFxKl68uJo1a6aNGzdaxnUFJOwAAAAA4AbMkjKNglnI7Ubj5NXw4cM1fPjwbM/Nnj07S5lh3Pix+6pVq+Zab/78+TbH5yzsww4AAAAAgAtihh0AAAAA3IBZHjI7YM7WEWO4Cz5JAAAAAABcEDPsAAAAAOAGMg0PZRoO2NbNAWO4Cz5JAAAAAABcEDPsAAAAAOAGzDLJLEesEm//MdwFM+wAAAAAALggZtgBAAAAwA3wDvuth08SAAAAAAAXxAw7AAAAALiBTHko0wFzto4Yw13wSQIAAAAA4IKYYQcAAAAAN2A2TDIbDlgl3gFjuAtm2AEAAAAAcEHMsAMAAACAGzA76B12M/PCBYZPEgAAAAAAF0TCDgAAAACAC+KReAAAAABwA2bDQ2bDAY/EO2AMd8EnCQAAAACAC2KGHQAAAADcQKZMypT9t1xzxBjughl2AAAAAABcEDPsAAAAAOAGeIf91sMnCQAAAACAC2KGHQAAAADcQKYc8355pt1HcB/MsAMAAAAA4IKYYQcAAAAAN8A77LcePkkAAAAAAFwQM+wAAAAA4AYyDQ9lOmD22xFjuAs+SQAAAAAAXBAz7AAAAADgBgyZZHbAKvGGA8ZwF3adYb/nnntUrlw5+fr6qmTJkho4cKBOnz5tVcdkMmU5Pv7441z7TU1N1dNPP63Q0FAFBATonnvu0alTp+x5KQAAAAAAOJRdE/Z27drpu+++04EDB7Rw4UIdPnxYffr0yVLvyy+/VExMjOUYPHhwrv2OGDFCP/74o+bPn69169bp0qVLuvvuu5WZyY5/AAAAAJCda++wO+JAwbDrI/EjR460fF2+fHmNHTtWvXr1Unp6ury8vCznihYtqvDwcJv6vHjxombNmqWvv/5aHTp0kCTNnTtXZcuW1fLly9W5c+eCvQgAAAAAAJzAYb/6SEhI0DfffKPmzZtbJeuS9NRTTyk0NFR33nmnPv74Y5nN5hz72bZtm9LT09WpUydLWalSpVS7dm2tX78+2zapqalKTEy0OgAAAAAAcGV2X3TuhRde0Icffqjk5GQ1a9ZMv/76q9X5l19+We3bt5efn59WrFih0aNHKy4uThMmTMi2v9jYWHl7eys4ONiqPCwsTLGxsdm2mTp1ql566aWCuSAAAADkiclkUtGiRVU0OEi+vr6SyaQrmZe0/+JmbU5YqtNXjjg7xFz195ji7BBsti9ukbNDgAszGyaZDfsvCOeIMdxFnmfYJ0+enO1CcdcfW7dutdR/7rnnFBUVpWXLlsnT01ODBg2SYRiW8xMmTFBERITq16+v0aNHa8qUKXrrrbfyfCGGYchkyv4Pxrhx43Tx4kXLcfLkyTz3DwAAgLwLDAxUtepVVbJUSZ1I368/Yufo1+jPtTU+UlWK1NeTVd7Wfyr+V36ehZ0dKgC4nDzPsD/11FPq169frnUqVKhg+To0NFShoaGqWrWqatSoobJly2rjxo2KiIjItm2zZs2UmJioM2fOKCwsLMv58PBwpaWl6fz581az7GfPnlXz5s2z7dPHx0c+Pj42XB0AAAAKStGiRVWmTBntPL9Wy2Ln6kL6OavzK87MV43AJupZ5nENu+NlfXZ4vFLMyU6KFrj9ZcpDmQ54K9oRY7iLPCfs1xLw/Lg2s56amppjnaioKPn6+qpo0aLZnm/UqJG8vLwUGRmpBx54QJIUExOjPXv26M0338xXXAAAAChYvr6+KlW6lDbHL9PP0dlv2WuWWXsTN+rs4ZN6tNJrurfsU/r2OP+fA4Br7PYO++bNm7V582a1bNlSwcHBOnLkiCZOnKhKlSpZZtcXL16s2NhYRUREyM/PT6tWrdL48eP16KOPWmbEo6Oj1b59e82ZM0dNmjRRUFCQhg4dqtGjRyskJETFihXTmDFjVKdOHcuq8QAAAHCuYsWKKSn9vBZHf3rDuudSo/VHzFe6t+xTKuYdpoS0Mw6IEHA/vMN+67Hbswp+fn5atGiR2rdvr2rVqmnIkCGqXbu21qxZY0nGvby8NGPGDEVERKhu3bqaPn26pkyZonfeecfST3p6ug4cOKDk5P9/POrdd99Vr1699MADD6hFixby9/fX4sWL5enpaa/LAQAAgI08PT0VVDRIG+N/l1k57/5zvZ0X1ik5I0lNQtiiFwCusdsMe506dbRy5cpc63Tp0kVdunTJtU6FChWsFqmTrj5i9cEHH+iDDz646TgBAABQsPz9/eXp4amdF/60uU2Gkaa9FzeqcuH6kubYLTbAnZnlIbMD3i93xBjugk8SAAAABeraU4+XMi7kqd2ljAvy9QywQ0QAcGuy+z7sAAAAcC9m89XH4L09fHUl85LN7bw9fJVuTrFXWIDbyzRMynTA++WOGMNdMMMOAACAApWScjXprlqkYZ7aVQ1sqJiUY3aICABuTSTsAAAAKFBpaWlKSkpUREg3m9tUKlxXxX1Ka3P8UjtGBri3a6vEO+JAwSBhBwAAQIFLSDivsgFVVa9o6xvW9fbwVZeSgxR75biOXd7ngOgA4NbAO+wAAAAocElJSUpISNB9ZZ9WIVMhbTuf/e5BAZ5BGlDheRXzDtdnhyc4OErAvRiGh8yG/edsDQeM4S5I2AEAAGAXp0+flmTo3rJPqVXx3toYv0RHLu1RhpGmIK9QNQxupzpFWyrNfEWzj05RLO+vA4AVEnYAAADYzenTMbp4MVHBxYLVvdRQeZj+f+YtIe2MVpxZoG0Jy5WcmeTEKAH3kCmTMuWAVeIdMIa7IGEHAACAXV2+fFmXL1+Wp6envL29tVpf6UrmJcWmnJAhs7PDAwCXRcIOAAAAh8jMzNSVK1d0xLzH2aEAwC2BhB0AAAAA3IDZkEO2XDMbdh/CbbB8HwAAAAAALogZdgAAAABwA2YHbevmiDHcBZ8kAAAAAAAuiBl2AAAAAHADZplkdsCWa44Yw10www4AAAAAgAtihh0AAAAA3ECmYVKmA1aJd8QY7oIZdgAAAACAU82YMUMVK1aUr6+vGjVqpLVr1+ZYNyYmRgMGDFC1atXk4eGhESNGZKkze/ZsmUymLEdKSkq+x3UGEnYAAAAAcAPXVol3xJEXCxYs0IgRIzR+/HhFRUWpVatW6tq1q06cOJFt/dTUVBUvXlzjx49XvXr1cuw3MDBQMTExVoevr2++x3UGEnYAAAAAQIFLTEy0OlJTU7OtN23aNA0dOlTDhg1TjRo19N5776ls2bKaOXNmtvUrVKig6dOna9CgQQoKCspxfJPJpPDwcKvjZsZ1BhJ2AAAAAHADZplkNhxw/G+V+LJlyyooKMhyTJ06NUtMaWlp2rZtmzp16mRV3qlTJ61fv/6mrvfSpUsqX768ypQpo7vvvltRUVEOGbcgsegcAAAAAKDAnTx5UoGBgZbvfXx8stSJi4tTZmamwsLCrMrDwsIUGxub77GrV6+u2bNnq06dOkpMTNT06dPVokUL7dy5U1WqVLHbuAWNhB0AAAAA3IDhoH3Yjf+NERgYaJWw58Zkso7LMIwsZXnRrFkzNWvWzPJ9ixYt1LBhQ33wwQd6//337TZuQeOReAAAAACAU4SGhsrT0zPLrPbZs2ezzH7fDA8PD9155506dOiQQ8e9WSTsAAAAAOAGHPL++v8OW3l7e6tRo0aKjIy0Ko+MjFTz5s0L7NoNw9COHTtUsmRJh457s3gkHgAAAADgNKNGjdLAgQPVuHFjRURE6NNPP9WJEyf0+OOPS5LGjRun6OhozZkzx9Jmx44dkq4uLHfu3Dnt2LFD3t7eqlmzpiTppZdeUrNmzVSlShUlJibq/fff144dO/TRRx/ZPK4rIGEHAAAAADhN3759FR8frylTpigmJka1a9fWkiVLVL58eUlSTExMlr3RGzRoYPl627Zt+vbbb1W+fHkdO3ZMknThwgU9+uijio2NVVBQkBo0aKA///xTTZo0sXlcV2AyDMNwdhCOlpiYqKCgIG3YsEGFCxd2djgAAABuZZ55orNDyJP+HlOcHQKc7NKlS4qIiNDFixdtXkTNlVzLf3pHPiyvAG+7j5d+OU0/dvzylv28XAnvsAMAAAAA4IJ4JB4AAAAA3EBeF4S7mXFQMJhhBwAAAADABTHDDgAAAABuwCyTzHLADLsDxnAXzLADAAAAAOCCmGEHAAAAADfAO+y3HmbYAQAAAABwQcywAwAAAIAbYIb91sMMOwAAAAAALogZdgAAAABwA8yw33qYYQcAAAAAwAUxww4AAAAAboAZ9lsPM+wAAAAAALggZtgBAAAAwA0Yksyy/+y3YfcR3Acz7AAAAAAAuCASdgAAAAAAXBCPxAMAAACAG2DRuVsPM+wAAAAAALggZtgBAAAAwA0ww37rIWEHAOA6PVYvdXYIebK4bWdnh2Cz/ke+d3YIeTLvjvudHcJtq7/HFGeHAAC3BBJ2AAAAAHADzLDfeniHHQAAAAAAF8QMOwAAAAC4AWbYbz3MsAMAAAAA4IKYYQcAAAAAN2AYJhkOmP12xBjughl2AAAAAABcEDPsAAAAAOAGzDLJLAe8w+6AMdwFM+wAAAAAALggZtgBAAAAwA2wSvythxl2AAAAAABcEDPsAAAAAOAGWCX+1sMMOwAAAAAALoiEHQAAAAAAF8Qj8QAAAADgBlh07tbDDDsAALhlFDJ5KtjbXwGFfJwdCgAAdscMOwAAcGkmmdSyRGX1rXCnWoZVkafp6nzDmSuJWnhimxYe36azKUlOjhIAXB+Lzt16SNgBAIDLCvMN1PtN+qtm0VLad+G03tzzh2KvXJSXh6fuDK2o/1RqrkertNa0fZH6+sgGZ4cLAECBImEHAAAuKcSnsGa3GCJPk0mD1s1SVMIJq/NLT+/Vu/si9XjVNnq+dhf5eBbS54fWOilaAHB9hoPeYWeGveCQsAMAAJf0aoPe8vLw1EPrPlfslYvZ1rmckap39i3T5Yw0PVujg6LiT2hbwnEHRwoAgH2w6BwAAHA5dxQurhYlKuudfUtzTNav9/HB1fon8awG3NHUAdEBwK3JkGQYDjicfaG3ERJ2AADgcvpWuFPxqZcUeXq/zW0WHNuiu8Krq4RvETtGBgCA45CwAwAAl9MopLxWxvytDCPT5jbLTu9VIQ9P1Qsua8fIAODWZZbJYQcKBgk7AABwOQGFvHUx/Uqe2lxIS/5fW/ZoBwDcHlh0DgAAuJwrmekqnMfEu7CX7//aptkjJAC45bEP+62HGXYAAOBydp4/pbbh1eRpsv2/Ku1L1pDZMGv3+Wg7RgYAgOOQsAMAAJfz3bEtCvcLUpuwqja36VfhTq09c0inr1ywX2AAcAsz/28fdkccKBgk7AAAwOXsvxij7fHHNbpWJwV7+9+w/oCKTVWzaCl9e3STA6IDAMAxSNgBAIBLejFqkfw9vfVli4d1R+Hi2dYpZPLU0MotNa5ON83+5y+tP3fYwVECwK3DIXuw/+9AwWDROQAA4JKiky9o8F9faEbTh/TzXU9p/dl/9PPJHYq9clHeHoV0Z2gF3Ve+kUJ8CuvTg2v0wd8rnR0yAAAFioQdAAC4rBOXE3Tv6hnqVKqm+la4U2806mM5l5Seol9O7tB3x7bqyKVzTowSAAD7IGEHAAAuLc2coV9P7dKvp3apmHeAgrz9lGbO0LmUS0ozZzg7PAC4ZbCt262HhB0AANwyEtIuKyHtsrPDAADAIUjYAQAAAMANMMN+62GVeAAAAAAAXBAz7AAA3AR/Ly/dVeEOhQUUliTFXkrSimNHlJLBu9UAANdiNkwyOWD228wMe4EhYQcAIB9KFS6iRxo01r3VaynQx0dJaakyyaTC3t66kHJFP+zfq892bNXZy7xvDQAA8oeEHQCAPKpbIkxf9LhXhiF9vTtK8/buUnRSkiSpbGCQBtSqq7616qhH1ep6+JdF2h/PlmMAAOczjKuHI8ZBweAddgAA8qBCUFHNvuc+Hb94QZ2+na23N/5lSdYl6WTiRb2xYa06fTtb5y5f1lf33KfSRYo4MWIAAFzfjBkzVLFiRfn6+qpRo0Zau3ZtjnVjYmI0YMAAVatWTR4eHhoxYkSWOp999platWql4OBgBQcHq0OHDtq8ebNVncmTJ8tkMlkd4eHhBX1pN4WEHQCAPHi+eSslpqbq4cWLdD7lSo714pKT9Z/FC5VhmDW6aUsHRggAQPauzrCbHHDkLa4FCxZoxIgRGj9+vKKiotSqVSt17dpVJ06cyLZ+amqqihcvrvHjx6tevXrZ1lm9erX69++vVatWacOGDSpXrpw6deqk6Ohoq3q1atVSTEyM5di9e3fegrczEnYAAGwUHlBYHStW1udRW5WYmnrD+vFXrmj2zu3qVqWqgn39HBAhAACuIzEx0epIzeFn57Rp0zR06FANGzZMNWrU0HvvvaeyZctq5syZ2davUKGCpk+frkGDBikoKCjbOt98842GDx+u+vXrq3r16vrss89kNpu1YsUKq3qFChVSeHi45ShevPjNXbSk3bt3KzIyUlu2bFFycvJN9UXCDgCAje6rXkspGRn66cB+m9t8v3+vZEi9qtWwY2QAANyYY2bX/3+v97JlyyooKMhyTJ06NUtMaWlp2rZtmzp16mRV3qlTJ61fv77Arj05OVnp6ekqVqyYVfmhQ4dUqlQpVaxYUf369dORI0fyPcaqVatUuXJl1atXT507d1bTpk1VrFgx9e7dW9u2bctXnyw6BwCAjcoXLaoD8XG6lJ5mc5vzKVd09MJ5lQ8qar/AAABwQSdPnlRgYKDlex8fnyx14uLilJmZqbCwMKvysLAwxcbGFlgsY8eOVenSpdWhQwdLWdOmTTVnzhxVrVpVZ86c0SuvvKLmzZtr7969CgkJyVP/+/btU/fu3RUQEKAnnnhC5cuXV0xMjHbs2KHFixfr119/1fjx4zV58uQ89UvCDgCAjbw8PJRpNue5XbrZLC8PHmoDADiX8b/DEeNIUmBgoFXCnhuTyXrvdsMwspTl15tvvql58+Zp9erV8vX1tZR37drV8nWdOnUUERGhSpUq6auvvtKoUaPyNMbrr7+u4sWLa+vWrVkeq//nn380YcIETZkyRampqdk+aZAT/vcAAICN4q9cUenAQOXlvw+eJpNKFi6i+Cs39w4bAAC3o9DQUHl6emaZTT979myWWff8ePvtt/Xaa69p2bJlqlu3bq51AwICVKdOHR06dCjP46xatUrPPfdctu/AV65cWfPnz9eUKVP05ptvZlmtPjck7AAA2GjJPwdVukigWpUrb3ObDhUrKdTfX7//k/cf/gAAFCRHv8NuC29vbzVq1EiRkZFW5ZGRkWrevPlNXe9bb72ll19+WX/88YcaN258w/qpqanav3+/SpYsmeexzp07p5o1a+ZaZ8KECWrZsqU+/vhjm/slYQcAwEbbY09r37mzGlKvkU31TZKG1GukrTHR2h9/zr7BAQBwixo1apQ+//xzffHFF9q/f79GjhypEydO6PHHH5ckjRs3ToMGDbJqs2PHDu3YsUOXLl3SuXPntGPHDu3bt89y/s0339SECRP0xRdfqEKFCoqNjVVsbKwuXbpkqTNmzBitWbNGR48e1aZNm9SnTx8lJiZq8ODBeb6GokWLKjMz84b1Bg8erDVr1tjcL++wAwCQB+9v2aCPu/XU6KYt9M6mv3Kt+2LLNmpcqrSGLF7koOgAALj19O3bV/Hx8ZoyZYpiYmJUu3ZtLVmyROXLX32iLSYmJsue7A0aNLB8vW3bNn377bcqX768jh07JkmaMWOG0tLS1KdPH6t2kyZNsiz8durUKfXv319xcXEqXry4mjVrpo0bN1rGzYty5cpp9+7d6tixY671KlWqpJiYGJv7JWEHACAPlh75R6//9afGtmitCkWD9fH2zdp77qxVnXolwvVEoybqXKmKJq1ZoTUnjjknWAAArufoVefyYPjw4Ro+fHi252bPnp11CCP3Qa4l7rmZP3++LaHZpF27dlqwYMENF6tLSkqSp6enzf2SsAMAkEefRG3R2eRLGt2spX7tO1A7z8TqUEKcJKl6SHHVLhGmk4kX9eTvi7Xk8EEnRwsAAOxtwIAB2rx5s1auXKm77rorx3pLly694bvu1yNhBwAgH348sF+/HPxbd1W4Q72r1VTFosVkyNCxixf0zqa/9OeJYzLf4Lf/AAA4VB4XhLuZcdxNvXr1tGrVqlzrHDhwQF988YUmTpxoc792XXTunnvuUbly5eTr66uSJUtq4MCBOn36tFUdk8mU5bjRqnlt27bN0qZfv372vBQAALLINAxFHj2s4X8sVp+F83T/wvl6eumvWn38KMk6AABu4NSpU9mWX758Oduy8ePH68knn7S5f7vOsLdr104vvviiSpYsqejoaI0ZM0Z9+vTR+vXrrep9+eWX6tKli+X7oKCgG/b9yCOPaMqUKZbv/fz8Ci5wAAAAALjNGMbVwxHjuIv69evLbDarTp06qlOnjurWrau6deuqY8eOSkpKsqrbsGFDNWzYME/92zVhHzlypOXr8uXLa+zYserVq5fS09Pl5eVlOVe0aFGFh4fnqW9/f/88twEAAAAAoKDExcXp9OnT2r17t3bt2qW1a9dqxowZunLliurWravp06erXbt2+e7fYfuwJyQk6JtvvlHz5s2tknVJeuqppxQaGqo777xTH3/8scxm8w37++abbxQaGqpatWppzJgxWX57cb3U1FQlJiZaHQAAAADgToz/vcPuiMOdlCpVSp07d9Zzzz2nr7/+Wjt27JC/v79eeumlHFe+t5XdF5174YUX9OGHHyo5OVnNmjXTr7/+anX+5ZdfVvv27eXn56cVK1Zo9OjRiouL04QJE3Ls88EHH1TFihUVHh6uPXv2aNy4cdq5c6ciIyOzrT916lS99NJLBXpdyNmohq85O4Q8MTIznR1Cnry787/ODgEuYNAH2f9756pSQp0dge0W9+/s7BBuW/PuuN/ZIQAAUKAmT55seRS+cuXKMpmu/rKiQ4cO6t27t4YMGXJT/ed5hn3y5MnZLhR3/bF161ZL/eeee05RUVFatmyZPD09NWjQIKs98yZMmKCIiAjVr19fo0eP1pQpU/TWW2/lGsMjjzyiDh06qHbt2urXr59++OEHLV++XNu3b8+2/rhx43Tx4kXLcfLkybxeNgAAAADc2gyT4w43kZKSolmzZqldu3YqUqSImjRpomHDhqlt27aSruaiNyPPM+xPPfXUDVdkr1ChguXr0NBQhYaGqmrVqqpRo4bKli2rjRs3KiIiItu2zZo1U2Jios6cOaOwsDCbYmrYsKG8vLx06NChbF/i9/HxkY+Pj019AQAAAABgi9dff93y9fnz57Vr1y7LIUnvvfeenn/++Xz3n+eE/VoCnh/XZtZTU1NzrBMVFSVfX18VLVrU5n737t2r9PR0lSxZMl9xAQAAAMDtjlXi7WPdunXavn27ihUrpg4dOqhNmzaWcwcOHLipvu32DvvmzZu1efNmtWzZUsHBwTpy5IgmTpyoSpUqWWbXFy9erNjYWEVERMjPz0+rVq3S+PHj9eijj1pmxKOjo9W+fXvNmTNHTZo00eHDh/XNN9+oW7duCg0N1b59+zR69Gg1aNBALVq0sNflAADsyNerkDrXrqrqJYvLz6uQElNSte7gMW0+mv3epgAAAK7gnXfe0bvvvqvOnTtr7ty58vHx0TPPPKOXX35ZJpNJRYoUuan+7Zaw+/n5adGiRZo0aZIuX76skiVLqkuXLpo/f74lGffy8tKMGTM0atQomc1m3XHHHZoyZYrVRvLp6ek6cOCAkpOTJUne3t5asWKFpk+frkuXLqls2bLq3r27Jk2aJE9PT3tdDgDADgJ8vDW8XVPd26i2ivj66GhcglLSMxRS2F/DWt+pw2fj9eW6bVq0ba+zQwUA4NZn/O9wxDhuYvr06Vq+fLmqV6+uH3/8Ufv27VP//v317rvvatSoUTfdv90S9jp16mjlypW51unSpYu6dOmSa50KFSpYLVJXtmxZrVmzpkBiBAA4T7EAP33+8L0qExyk+Zt36bvNu3Xq/EXL+TsrltGApvX0yr2dVKt0mF7+JfefKQAAAI524cIFVa9eXdLVV8DDw8M1b948tWnTxrUTdgAAcuLl6akZA3sqtHCABnyyQP+cjc9SZ8vRU9py9JTu++e4Xu7dUQmXkvXRyo1OiBYAgNuDo/ZId6d92MPCwhQfH6+QkBBLWWBgoOLi4gqk/zxv6wYAwM3qWqeq6pYtqeFf/5xtsn69hVv3aMbKjXqkzZ0qFuDnoAgBAABu7LHHHrNsa242mzVr1iz17NlT99xzT4H0T8IOAHC4/k3rad2hY9oTfcam+l+v3y6zId3bqLadIwMAALDdmDFj1LlzZ0nSsGHDtGHDBt1777367LPPCqR/HonHba1inbIKr1BCnoU8dOFsovZtPCRzptnZYQFurXxIUdUrV1JPf/OLzW0uXknV77sPqGeDGvr8zy12jA4AgNucGy0I52jvvPNOgfdJwo7bjpd3Id3Vv4V6PN5RVRvdYXXu7Ik4/fb5Ci35fKUuxiU5KULAvZUMurq9yYGYvL3bdSDmnDrXqmKPkAAAAPJlypQpatCggRo0aKAyZcoUeP8k7LitFClWWC8tHKWaEVW15Y8dmnDPGzqw+R9lZmSqdJWS6jr0LvUf20s9HuuoCT3f1JFdJ5wdMuB2TKarC9EY+fkVv8l9FrEBAKCgsehcwbt06ZLef/99RUVFycPDw5K8N2jQQA0bNlSVKjc32UDCjtuGj5+3Xvn5OZW8I0wjWk7U/k2HrM7/vfkf/b35H3016Tu9/MsLev33FzWizWRFH4h2UsSAezqbeEmSVLlEiKLPJ9rcrlKJEJ37X1sAAABX8Oabb1q+PnHihKKiohQVFaVvvvlGY8aM0cWLF5WYaPv/d/6NhB23jXuf7ao76pbXqDaTdHDbkRzrJcRe0NjOr+iDDa/qqfcGa1zX1xwYJYDD5xK07/QZPdCkrtYcOGpTm8I+3upet5pmrd1q5+gAALiNGXLMO+xu9J68YRj6448/dODAAYWGhqp9+/bq2bOn5fzNbu/GKvG4LXh4eqj7sPZa8c3aXJP1a5LOX9bcVxepcad6Kl053AERArjevE271KZqRVUNC7Wpfv+m9eRVyFM/bN1j58gAAABsN3ToUD388MPatGmT5syZo+rVq2v06NHKzMyUJIWG2vZ/nZyQsOO2cGfneipRLlSLP460uc2a7zYoMT5J3R5pb8fIAGTn1x37dfBMnGYO6qlyxYJyrdulTlU907G5vl4fpXNJlx0UIQAAtyOTAw/3sGjRIm3evFnz5s3TsmXLdOTIEe3fv1+TJk0qkP5J2HFbqFCrjBLjk/RPlG2P10pSemq6dq/7W+VrFvxqjgByl5qRqSfm/KSU9AzNf6K/HmvbRKGF/a3q1CxVQq/c21HT+nXXbzsPaNrSdU6KFgAAIHtlypSRv////x8mJCREc+bM0Zdfflkg/fMOO24L3r7eSktJz3O7tCtp8i+S++weAPs4k3hJAz5ZoJGdW+rRNk00/K5m2n/6rK6kZyi0sL8qlQhRzIVEvf7ban29IUqGG70PBwCAXfAOe4Fr3769HnroIc2ZM0clSpSQJKWnpysgIKBA+idhx20h6fxlBYYUlpePl9JTbU/cQ0oVU1JCklr3aaYyVUvJy9tTF+OStP6XrTp74uYWiABwYxevpGjyT8v1zh9r1bNBDVUND5Wvl5eOnEvQu8vWac2Bo8o0u9FPfQAAcEtZu3at9u3bpwoVKqhVq1YqXry4/vrrL73++usF0j8JO24Lm//YoeHTBqnN/c20fO5am9qUvCNMtVtW05VLKWrRq4nOn7mgjPRMBYUW0RPvDtamJVFa8MbP2rv+gJ2jB5CUkqq5G3Y4OwwAAG5vzLAXuO3btys9PV179+7V9u3bFRUVpdKlS2vYsGF6+umn1bhxYy1ZsiTf/ZOw47Zw+p9YbV22U/cM72xzwn7PE51kzjRr+dd/6uePlurkgdOSJF9/H7Xr30I9n+yid1ZN0ruPfaqls1fbMXoAAAAAtyovLy/Vr19f9evXtyo/cOCAoqKibqpvFp3DbeP7ab+pRtMqGvpa/xvWjejRSPc+202/frJcHz7zpSVZl6SU5FT9Pmulht85Vn98uUqjPntMEfc0tmfoAAAAgP0ZJscdULVq1dSvX7+b6oOEHbeNqJV79Mlzc9XvhV567osnFF6xRJY6hYsGqN8LvTR54RhtX75bM0fOzrE/c6ZZ05/4XJuWRGn4u4Pl4cE/PAAAAAAch0ficVtZOH2JEhMu6bG3HlKHga21ddlOHdh8WJkZmSpVOVyt+zSTt4+XTuyP1vger8t8g8WsDMPQ3JcX6qNNr+nOrg206bftDroSAAAAoGAZhhyy6wo7uxQcZthx24n8+k89WPEpTXv0M/kV9lOXIe10z/DOqlS/glYv2CAPTw+9PWymzJlmm/o7uPWwDm49rC4Pt7Nz5AAAAADw/5hhx20p9Uqals1Zo2Vz1liVdx3STp0Gt9bBrUfy1N/fWw6rZrMqBRkiAAAAAOSKGXa4Fc9CnjLMhow8PqdjzjTLs5CnnaICAAAAHMBw4OHGUlJSdPr0aV25cuWm+yJhh1s5f+aCPAt5ZrsgXW5KVwnX+TMX7RQVAAAAgFvdrl271KFDBxUpUkRlypRRYGCg2rdvr507d+a7TxJ2uJVtkbt16cJldRvW3uY2YeWLq1HHulr93Xo7RgYAAADYGdu62c2BAwfUqlUr7dixQ8OGDdPLL7+sRx55RDt27FCrVq104MCBfPVLwg63kpKcqmVz/lTXoXcpIMjfpjb3PttNyYlXtGreX3aODgAAAMCtaNKkSSpevLgOHjyomTNnavz48ZoxY4YOHTqk4sWLa/Lkyfnql4QdbufHD36Xh6eHJi8cI98An1zrdn64re59tpvmv/GzUpJTHRMgAAAAYAcmw3GHu1m5cqXGjh2rYsWKWZUXK1ZM48aN06pVq/LVLwk73M6Z43GadO87qtKooqave1ltHohQIS/rBeUq1CqrER8/ojGfP6HFHy/Tgjd/dlK0AAAAAFxdUlKSKleunO25ypUr68KFC/nql23d4Jb2rj+gUe1e0vBpgzVh3gglxF7Q/k2HlJ6arrDyxVWjaRXFx5zXzFFfadH0Jc4OFwAAALh5jlrB3Q1n2MPDwxUbG5vtuZiYGIWFheWrXxJ2uK2ju0/quY6vqFy1kuo2rL1KVwmXb4CPYo+d0w/v/qr1P21RRnqms8MEHCYowFdVSofKz8dLl1PS9PeJs0pOTXd2WAAAAC6vffv2Wrx4sfr165fl3C+//KJ27drlq18Sdri94/tOaeaor5wdBuA0tSqEqW/b+urYuKp8vP7/x8KlK6n6beN+fbd6p47GJjgxQgAAUCActYK7G64SP3PmTKWlpWV77vPPP5e3t3e++iVhx23NZDLJP9BPkpSceEWG4YbP5wC5GNqtiZ7s2UKnzl3UzF/Wa83OI7p8JU1BhX3VqXFV9W5ZR/e2rqNXvl6uxRv2OTtcAAAAl+Tl5SUvLy9JUnJyss6fP6/g4GD5+/srICAg3/2SsOO2VLFOWd39aEe1H9BC/kX+l7AnXdHKeX9p8SeROrr7pJMjBJzvP53v1JM9W2jmL+v1+ZJNuv73WXGJlzXzlw367LdNGtv/Lr30n85Ky8jU0i3520MUAAC4AN5ht6s///xT48aN06ZNm2Q2m2UymdSkSRO9/vrratOmTb76JGHHbcXLu5BGzBymjgNbK/50gn58/3cd3XNCklSxdjl1ebit7n60gyLn/qn3Hv9c6WkZzg0YcJIKYcF65t6W+uy3jfrst0051svINOuVucvlXchTEwd21Pq9x5TEFocAAABW1q9fr06dOikkJERPPPGESpYsqdjYWH3//ffq1KmTVqxYoZYtW+a5XxJ23DY8PD303/nPqmGHOpr26CeK/PpPZWb8/6Jxf/6wUXNfWaiOA1vrqfcfVpGiAZp8/7vKzGRhObifPm3qKSExWZ8v2WxT/emL1qrzndV0d7Oamrcyys7RAQAAu2CG3W4mTZqkBg0aaPXq1fLx8bGUv/HGG2rbtq0mTZqkFStW5Llf9mHHbeOB0Xfrzi71Nfm+d/THl6uskvVrMjMy9ceXqzT5vnd0Z5f6emBMDydECjiXj5enejSvqZ/+2qP0bP6eZCc+MVkrth9SnzZ17RwdAADArWfTpk0aM2aMVbIuSX5+fnr++ee1ZcuWfPVLwo7bgmchT93zRCf98eUqbV2284b1ty7bqd+/WKl7Hu8oz0KeDogQcB3hxQJVxM9H6/cey1O7DfuOq2J4MRXy5EcHAAC3JMOBh5sxm82WRef+zdvbO99P9fK/LtwWIno0VGjpYvpl5jKb2/z6SaRCSxdT856N7RgZ4Hqubd2Wksc1HFLTr9b39eJtKgAAgOvVq1dPM2bMyLIrldls1owZM1S/fv189cv/unBbqNuqhk7+Ha2ju0/Y3ObIrhM6+Xe06rSqobULc150C7jdJCWnSJJCg/K2xUhIYIAyzWZdTs1+j1EAAAB3NWHCBPXo0UP16tXTQw89pNKlS+v06dP6+uuvtXfvXi1evDhf/ZKw47bgH+inxPOX89wuMeGSAoL87RAR4LpiEpJ0NCZe3ZrW0J+7jtjcrlvT6lq/95gMN3zMDQCA24Jhuno4Yhw307VrV82fP1+jR4/WuHHjLOVlypTR/Pnz1a1bt3z1S8KO28KVS6kK+N9+63kREOivK0lX7BAR4Nq+W7NLo+5vrRJFC+vshUs3rF+7QrhqVQjXMx/8ZP/gAAAAbkF9+vRRnz59dOjQIcXFxSkkJERVq1a9qT55hx23hb+3/KMKtcuqVOVwm9uUrlJSFWqX1d9bDtsxMsA1/bZhnxIvp+iNR7vL1zv3390WK+KvV4Z00T/RcXleqA4AALgOk+G4w51VqVJFERERN52sS8yw4zbx5w+b9MTbA9XjsY765LmvbWpz96MdlBifpDXfbbBzdIDruZSSphEf/ayPR/bRZ6Pv15vzV2n30VirOiaT1LR6OY17sL18vb305JsLZOZ5eAAAgCxeeumlXM8bhqHJkyfnuV8SdtwW0lPTtWTWSvV+uqvWfL9Bf2/+J9f61ZtUVvdHO+inj5YqPTXdQVECrmXvsTMa9vZ3euOR7vpqbH/tP3FGf+48okspaSoa4KuOjaqqXFiw9h6L1ePvLlRMfKKzQwYAADfDUVuuueHv96dMmZLjuWsrx5Oww619/fIi1W5RTa/9Nk6vD/pQm3+PyrbenV3qa9zXT+ufqKP6espCB0cJuJYDJ8+p96TZiqhZXve3qaf7WteVv4+XLqekacuBk5o4e6l2HYlxdpgAAAAu7dy5c1nK4uPjtXjxYn3++ef64Ycf8tUvCTtuG+mp6Zpwz1sa/+0zeuWXF3Rk93H99ulyHd19UpJUsU5ZdX+0g+6oU15bl+3UK/3fZ3YdkGQY0vq9x7V+73FnhwIAAHBLKlasWLZlo0aNUlJSkl555RV9++23ee6XRedwW0lOuqIJ97ypsV1fU8zhsxr+3sOatnqypq2erOHvPazYI2c1rttUje/xppJZHR4AAABwCTNmzFDFihXl6+urRo0aae3atTnWjYmJ0YABA1StWjV5eHhoxIgR2dZbuHChatasKR8fH9WsWVM//vjjTY2bX61atdKSJUvy1ZYZdtx2DMPQ9hV7tH3FHgUE+atYeFFJUkLsBV2+mOzc4AAAAAAnMckxK7jndRf2BQsWaMSIEZoxY4ZatGihTz75RF27dtW+fftUrly5LPVTU1NVvHhxjR8/Xu+++262fW7YsEF9+/bVyy+/rN69e+vHH3/UAw88oHXr1qlp06b5Gje/du/eLV9f33y1JWHHbe3yxWSSdAAAAMAJEhOtF6z18fGRj49PlnrTpk3T0KFDNWzYMEnSe++9p6VLl2rmzJmaOnVqlvoVKlTQ9OnTJUlffPFFtmO/99576tixo8aNGydJGjdunNasWaP33ntP8+bNy9e4ufnqq6+ylKWmpmrXrl2aNWuWBgwYkKf+riFhR4Ezed1af6ymbX/R2SHARTw9+jdnh2Az36Bb6+/ZnKc7OzsEAABgmK4ejhhHUtmyZa2KJ02alGWl9LS0NG3btk1jx461Ku/UqZPWr1+f7xA2bNigkSNHWpV17txZ7733nl3GHTJkSLblvr6+evDBB3N8EuBGbq3/8QEAAAAAbgknT55UYGCg5fvsZtfj4uKUmZmpsLAwq/KwsDDFxsbme+zY2Nhc+yzocY8ePZqlzM/PT8WLF89zX9cjYQcAAAAAd+DgfdgDAwOtEvbcmEzWM/+GYWQpyytb+iyocQvynffrkbDDJRUJDlDLXneqeOmr2yPEnT6vtT9tUVLCJSdHBgAAAKCghIaGytPTM8us9tmzZ7PMfudFeHh4rn3aa1xJSklJUUJCgoKDg+Xn53dTfbGtG1xKyYolNHLGUH1zaLqefm+wOg1spU4DW+nJaQP17aH3NPrjR1S6crizwwQAAABuPYYDDxt5e3urUaNGioyMtCqPjIxU8+bN83WZkhQREZGlz2XLlln6tMe4u3btUocOHVSkSBGVKVNGgYGBat++vXbu3Jm/ixAz7HAhNZpU1pSFo5R6OVXfvLpIf8xerQtnr64sGRRaRJ3/01Y9Huug5j0aatL972rP+oNOjhgAAADAzRo1apQGDhyoxo0bKyIiQp9++qlOnDihxx9/XNLVFd6jo6M1Z84cS5sdO3ZIki5duqRz585px44d8vb2Vs2aNSVJzz77rFq3bq033nhDPXv21M8//6zly5dr3bp1No+bFwcOHFCrVq3k5eWlYcOGqUyZMoqOjtaCBQvUqlUrbdmyRdWqVctzvyTscAllqoTr5UWjdWzPCU28950sW7FdjEvSd28v1q+fLtfk70dpyg+jNLL9yzq+P9pJEQMAAAAoCH379lV8fLymTJmimJgY1a5dW0uWLFH58uUlSTExMTpx4oRVmwYNGli+3rZtm7799luVL19ex44dkyQ1b95c8+fP14QJE/Tf//5XlSpV0oIFCyx7sNsybl5MmjRJxYsX1+bNm1WsWDFL+SuvvKI777xTkydPtmwnlxck7HAJ/5nUR0kJl7JN1q+XnHhFk+57Rx9ufEX/mdxHL/Wd7sAoAQAAgFuXybh6OGKcvBo+fLiGDx+e7bnZs2dnKTOMGw/Sp08f9enTJ9/j5sXKlSv12muvWSXrklSsWDGNGzdOEyZMyFe/vMMOpysWXlTNezTSovd/zzVZv+bKpRQtfHeJmnZtoBJlQxwQIQAAAADkLCkpSZUrV872XOXKlXXhwoV89UvCDqfrMKCF0lLStXzuWpvbrJz/l1IupajDgJZ2jAwAAAC4jbjgonO3i+xWpb8mJiYm3yvPk7DD6cLKherUoRglJ12xuU3K5VSd+DtaYeVD7RgZcOuoU62UOrWsrq5taqppvQry9vJ0dkgAAABuo3379lq8eHG253755Re1a9cuX/3yDjuczrOQp8yZ5jy3M2ea5eHJ75zgvnx9CqnHXXV0b6f6Kl/a+n2p84nJWrxit374Y4fizl9yUoQAAMClOGr22w1n2GfOnKm0tLRsz33++efy9vbOV78k7HC6hDMXFXF3Q3kW8lRmRqZNbTw8PRResYT2bjxk5+gA11QsyF9vj7tXlcuFavWmQ3rj00jtPxyrzEyzypYMVo/2ddS7Uz31aF9Hz73+o/b9k/0jWgAAALh5Xl5e8vLykiRduXJF58+fV0hIiHx8fBQQEJDvfpmehNOtWbhRRYsHqkWvxja3ada9oUJKBmvNwk12jAxwTX5+3po2/j6FFA3QkHHfaOL037Rj/ymlpmUoI9Oso6fi9f5Xq3X/07N08vR5TXvxPlX41ww8AABwP9dWiXfE4Y7279+vTp06KTAwUGXKlFGRIkXUpUsX7du3L999krDD6Y7vi9budX/r3me6ycPDdMP6JpNJ9z7TVfs2HdI/O447IELAtfS7v4nKhgdr5KsL9c/xcznWS7yUotFTFyn+wmWNHtregRECAAC4lxMnTqhVq1aKi4vToEGDZDKZNHz4cO3fv18tWrTQP//8k69+SdjhEr5+7UdVa3yHnv5gSK5Ju8lk0vB3B6tWi2qa+9pPjgsQcBGenh7q3rWefl+zV0dOxt2w/uUraZq9cKMa1S6X5T13AADgZgyT4w438/LLL6ty5cravHmznnrqKRmGoXfeeUf79u1T+fLlNXHixHz1S8IOl7BzzX6999QX6jKknV77bZwatq8tk8n6L3r9drX06uIX1OPxDvrg2dnatny3k6IFnCeiaSWFFCusRct22txm9aZDOn8xWT3b17FjZAAAAO5r6dKleuKJJ1SoUCEZxv+/ExAQEKDnn39eK1asyFe/LDoHl7Hs67VKOHNRw17uq9d/f1HRh2J1bN9JSVK5GqVVtmopHdt3SpMfeE+bft/h3GABJylfLkQXEpNtml2/Jj0jU7sPnla5UsywAwDg1lgl3m7Onj2rChUqZHsuLCxMFy9ezFe/JOxwKVuX7dLWZbtUK6KqOgxoodD/PcK7Z/1BTX/6S+1ed8DJEQLO5eVVSOnptu2mcL20tAwFBPnbISIAAAAULVpUSUlJ2Z5bunSp7rjjjnz1S8IOl7R3w0Ht3XDQ2WEALicx8YqCAv3k411IqWkZNrcLCw3U2YTsf4gAAAD34KgV3N1xlfgqVaro0CHrLaeXLVum33//XTNmzND777+fr355hx0AbiEbNv2jQp6e6tCius1typcqpjrVSmntlvytTgoAAIDcde/eXb/++qvle5PJpO7du2vWrFmaNGmShg8fnq9+mWEHgFtITOxFbdpyRH0619fvq/fKbNz4V9j3damv84nJWrXx0A3rAgCA2xjvsNvN2LFjNXbsWElSxYoVNWfOHIWGhqpZs2YKCgrKd7/MsAPALWbB95tUuUJxPfuftjes26F5NfXp0kDzF29Tekbe330HAABA3gQHB+vBBx9U586dbypZl5hhB4Bbzs7dJ/XOrBV6/pGOCikaoC9+2KAjJ+Ot6hQL8tf9XRtoYK+m+n3NXs39ZbOTogUAALj9vfTSS7meNwxDkydPznO/JOwAcAv6KXKXEi+laMR/2mnuO//Rjn2ntP9wrDLNZpUOL6pWjSopPcOs2Ys2atb362XDk/MAAOB256BF59zxkfgpU6bkeO7avuwk7ADgRlZuOKg1m/9R6zsr6+52tdW84R3y9DQp4UKyPvh6jX5fs0+XklOdHSYAAMBt79y5c1nK4uPjtXjxYn3++ef64Ycf8tUvCTsA3MIyM81atfGgVm1kG0QAAHADLDpnN8WKFcu2bNSoUUpKStIrr7yib7/9Ns/9sugcAAAAAAB20qpVKy1ZsiRfbZlhBwAAAAB3wAy7U+zevVu+vr75akvCDrvxL+KrhnfVVmBIEWWkZyj6nzPau4HHdgEAAADcXr766qssZampqdq1a5dmzZqlAQMG5KtfEnYUuDJVwtX7yc5q37+F/Ar7KjPTLE/Pq29fnPg7Wos/W6nfv1yt9NR0J0cKAAAAuA+Tg1aJd8hK9C5myJAh2Zb7+vrqwQcf1LRp0/LVLwk7ClThwoX10V8v6/LFZP3w7m/6Y/ZqnTsZL89CnqrdoprufqyDHnu9v9r2aapJ97+rpPOXnR0yAAAAANyUo0ePZinz8/NT8eLFb6pfEnYUGH9/f5UtU1ab/9ih1x78QKlX0iznMjMytXPNPu1cs0/VGlfSyz8/p5d+GKUXur3OTDsAAACAW1q5cuXs0i+rxKPAhIeF68DWI3ql33SrZP3fDmw9rP/2fEvVGlVU96HtHBghAAAAADjW6dOn9dJLL+WrLTPsKBD+/v7yD/DX7IkLlJ6WccP6B7Ye1roft+juYXfppxnLHBAhAAAA4OZYJd6u1qxZo927dys1NdWq/MSJE/rggw8UEBAgk8mk5s2bKyIiwqY+SdhRIIKDg3XqUIx2rN5nc5vFH0fqnZUTVadlNe1ed8CO0QGuy8PDpPLlQlSksK9S0zIUffq8Ll1KvXFDAAAAuIwJEybotddek8lkyva8yWTSCy+8IEmaOHEiCTscy8vTS7vWROWpzZ6/DshsNqtM5ZIk7HA7QUF+6ta5ru7p3kDh4UGW8rS0DK1as18/LY7S3wdinBghAAC43bBKvP189dVXeuyxxzRixAj5+flZnduxY4d69eqlY8eOSZKKFi1qc78k7CgQJpPJpkfhr2cYhjLSM1XI29NOUQGuqU7tMnpl8r3y8S6klav3a9m0vYqPvyQfn0Jq3LCC7rm7gTp3rKP532/Sp7NWy3DDH3oAAAC3ktjYWA0ePFjVqlXL9pyUv4XpSNhRIDINs8LKh+apTXBYkLx9vJSYcMlOUQGup3q1knrz1Qe0/8BpvfTqz7p48YrV+X8On9V3C7fo3p6N9MSjd8nDw6SZn65yUrQAAOC2w0SAXZjNZnl5eeV4PqdH5W+EhB0F4tKlJN3ZuZ6KhRdVQuwFm9p0/k9bpSSnatvy3fYNDnARHh4mTRjbQ/8cOauxE35QWg5PpZjNhn74cavMZkNPD++g9Rv/0c5dJx0cLQAAAGy1atWqbGfXJalmzZpatSp/EzAk7CgQFy5cUIniJdTj8Y76avL3N6zv5eOl7sPu0urvN+rShWQHRAg4352NKqp0qWC9+vriHJP16y36eZt6dK+vXj0akrADAAC4sFWrVuWalBuGodatW+e5XxJ2FAiz2azzF86r3ws9dWDLYW38bXuOdT0Leer5L59Q0RJBWvThHw6MEnCuHt3r6+ChWO3Pw2JyP/8apaceb69ixQKUkHDZjtEBAIDbHtu62c2UKVOyLTeuW4xo8uTJee7XI78BAf925swZJSUlatL3IzXwv/epaInALHVqRlTV1N/GqkXPxnr94Zk6vi/aCZECzlG1Srg2bj6cpzYbNv0jT08P3VGhuJ2iAgAAwM06d+6c1XH27Fnt3LlTkydPVoUKFbRt27Z89csMOwrUqVOntG/Zcd0/+m71e6GnNv8epTPHzqmQdyHValFNleqWV/Q/sRrf6+087dkO3A58fbx0JSU9T22uXLla39c350VMAAAAbMG2bvZTrFixLGUhISGqXbu2UlJS9Nprr+n772/86vC/kbCjwM367wIteGexOj7YSi16NlaZqqWUkZ6h6H/O6PMJCxS1cq/VoyGAu7h8OVVFg/zz1Ca4qL+lLQAAAG49HTp00Mcff5yvtiTssItLF5L140dL9eNHS50dCuAytkYdU7s21fXprNUym237pVWHu2rq0uXUPL33DgAAkC3eYXeKy5cvy8/PT1euXJGfn1+e2vIOOwA4yC+/RqlE8UA1b1bZpvpeXp7q1qWelkXuVkoeH6UHAACAa+jRo4eio6PznKxLJOwA4DCH/jmj7TuO69mnOiosm0UZr2cySaOf7azCAT76aXGUgyIEAAC3s2vvsDvicDeJiYn6z3/+o9DQUIWEhOiZZ55RZmamJGnt2rU6fDhvCw9fQ8IOAA70yuuLlZaWqQ+mPaQ7G1WUyZS1TlhYoCaN76WO7WvrjXeW6OSpBMcHCgAAAJuNGTNG3333nR544AH17t1bM2fO1BtvvCFJWrx4sV599dV89cs77ADcRuHCheXj4yMPDw9lZGTo0qVLSk937KPm589f1tOj5uql//bWm689oJOnErR85V7FJ1yWj3chNWpYQc2aVNLly6ma9PKPWrf+kEPjAwAAtzHeYbebxYsXa+rUqXr22WclSSVLltQ333yjF198Uc2bN9fzzz+fr35J2AHc1kwmk0JDQxUUWFS+fj66kpyq9LQMBYT4ylTSQ0mJiYpPiFdycrLDYkpIuKynR85V7Zql1bNHA91/750qXNhXaWkZOnL0nN557w+tXL1fKam8tw4AAHAruHTpkurWrWv5vnXr1nrzzTclSaGhoYqOjs5Xv3ZN2O+55x7t2LFDZ8+eVXBwsDp06KA33nhDpUqVsqo3e/ZsTZs2TQcPHlTRokXVp08fffjhhzn2m5qaqjFjxmjevHm6cuWK2rdvrxkzZqhMmTL2vBwAtxhPT0+VLVtOPt4+Wvnzdv32zQYd2nNKkuTr7612PRronsEtVaFyRcXEnHZ4fHv2RWvPvqv/eJtMErsdAgAAu2KG3W4aNmyorVu3ql27dpKk4OBgpaeny2w2KyEhQcHBwfnq167vsLdr107fffedDhw4oIULF+rw4cPq06ePVZ1p06Zp/PjxGjt2rPbu3asVK1aoc+fOufY7YsQI/fjjj5o/f77WrVunS5cu6e6777a81A8AJpNJZcuUlTldGnn/h3pv3PeWZF2SUpLT9PuCTXry7mn69Zv1Kl26tNq2ru60eEnWAQAAbl1Tp07V22+/rd9++02S5OFxNdU2m8366quv1LBhw3z1a9cZ9pEjR1q+Ll++vMaOHatevXopPT1dXl5eOn/+vCZMmKDFixerffv2lrq1atXKsc+LFy9q1qxZ+vrrr9WhQwdJ0ty5c1W2bFktX778hsk+APdQtGhR+Qf4a+R9H+jw3pwfQTKbDc186ScVCy2ip59or3XrDyojw+zASAEAABzDUSu4u+Mq8RMmTJCvr6969Oih0qVLKzQ0VCaTSbVq1VJ0dLQ2btyYr34dtkp8QkKCvvnmGzVv3lxeXl6SpMjISJnNZkVHR6tGjRoqU6aMHnjgAZ08eTLHfrZt26b09HR16tTJUlaqVCnVrl1b69evz7ZNamqqEhMTrQ4At7eiRYO1acU+Hdx96saVJX39/jIVK1ZYrVpUtXNkAAAAuN2YTCZVqlRJbdu2VZUqVRQcHKwuXbqoR48eioqKUu3atfPVr90XnXvhhRf04YcfKjk5Wc2aNdOvv/5qOXfkyBGZzWa99tprmj59uoKCgjRhwgR17NhRu3btkre3d5b+YmNj5e3tneUdgLCwMMXGxmYbw9SpU/XSSy8V7IU52JgW05wdgkXleuV0V9/mKl766j2Ij7mgld9t0MHtx5wbGFzOkLeWOWXcGhXD9NXk2vr1mw02tzlx6Ix2bTqsrl3qasVfB+wYXcH4dCJPEwEAgDziHXa7WbFihV36zfMM++TJk2UymXI9tm7daqn/3HPPKSoqSsuWLZOnp6cGDRok438va5rNZqWnp+v9999X586d1axZM82bN0+HDh3SqlWr8hSXYRgyZbehsaRx48bp4sWLliO3GXzkrG7LapoW+aI+/HOyWvduLP/CvvIv7KsWPRrq/VUTNX3lBDVoW9PZYQIqXTxIkvT3juN5andgxwmVCguyR0gAAABAnuV5hv2pp55Sv379cq1ToUIFy9ehoaEKDQ1V1apVVaNGDZUtW1YbN25URESESpYsKUmqWfP/k7zixYsrNDRUJ06cyLbv8PBwpaWl6fz581az7GfPnlXz5s2zbePj4yMfHx9bLxHZaH3vnXr+00d0cOsRTb5/mjYtiZI58+p7vh4eJt3Zpb7uH3W3Xlk4Uu88/plWzMv+9QTAETw9r/4uMjOP76JnZGTKs5CnPUICAACAmzp9+rQ+++wzTZo0Kc9t85ywX0vA8+PazHpqaqokqUWLFpKkAwcOWLZkS0hIUFxcnMqXL59tH40aNZKXl5ciIyP1wAMPSJJiYmK0Z88eyz53KFi1mlXRc588ojU/bNQ7j3yqzAzr1fjNZkOblkRpyx879OyMYRr98SOKiz6vnX/ud1LEcDXlwooqNLiwDMPQmfgknY6z7zoS5xOv7qleslyIjh3M/lWZ7JQsH6oLFxy3HzsAAIBD8Ui8Xa1Zs0a7d++25LvXnDhxQh988IECAgJkMpnUvHlzRURE2NSn3d5h37x5szZv3qyWLVsqODhYR44c0cSJE1WpUiVLcFWrVlXPnj317LPP6tNPP1VgYKDGjRun6tWrW/avi46OVvv27TVnzhw1adJEQUFBGjp0qEaPHq2QkBAVK1ZMY8aMUZ06dSyrxqNgPTT2Hh3dfSLbZP16ZrOh6U/OUrlqpTRowr0a3elVB0YJV2MymXR3q1rq066ealYKtzq3ff9J/bByp1Zt+0eZmQW/InvUgWglXLyszg800Sev/GJTm8BgfzXvVFuzvl5X4PEAAADg9jZhwgS99tprOb6mbTKZ9MILL0iSJk6c6PyE3c/PT4sWLdKkSZN0+fJllSxZUl26dNH8+fOtHk+fM2eORo4cqe7du8vDw0Nt2rTRH3/8YVlJPj09XQcOHFBy8v/Per377rsqVKiQHnjgAV25ckXt27fX7Nmz5enJo6wFrUyVcDVoV0uv/+ejXJP1a8yZZi18/3f9d96zqlCrjI7ttW2FbtxeChUqpLJly2lCjZrauu6gprwbqROHz0qSKtcspa59m+q1J+9W1N8n9dz7i5V4OaVAx0/PyNTPf+7RA/fdqW8/XK4kG2bN736wuWRIvy/fXaCxAAAAuAq2dbOfr776So899phGjBghPz8/q3M7duxQr169dOzYMUlXtx+2ld0S9jp16mjlypU3rBcYGKhZs2Zp1qxZ2Z6vUKGC5VH6a3x9ffXBBx/ogw8+KJBYkbO29zVVUsIlrVu02eY2GxZv0/kzF9XugQh9Oel7O0YHV+Tp6any5SrocmKqnnvwMx09YP1IevSxOK1Zsku1GlXQfz98SNNH99YTr3+vlLSMAo3j++U71Kt1HU385D+aNHSWki+l5lg3okMtDXiqg777aasuJl4p0DgAAABw+4uNjdXgwYNVrVq1bM9JUrly5fLcr8P2YcetqVh4kGKOnlV6HpKpzIxMnT5yRsXCi9ovMLissLAwZaSb9fygT7Mk69fbu+2Yxg/9QneUCtHDPZoWeBxxFy5r9PSfVb56Sb3z/VNq1a2uCnlZP4UTViZYw8berQkfDdL+Y2d08J9Y3VE+f2t0AAAAuDzDgYebMZvNlqfEs5PTo/I3Yvd92HFrM5sNmTzy/ofLZDLJMLvh31Q35+npqaDAIH01PVIxJxNuWP/wvtNa+v0W9exZX5//vFHpNrx2kRd7DsfokVcX6PmBd+nF9wcq/lyi9m45qrTUDBUvWVR1mtwhs9ksD08P1a5cSrXH9pQk7d0frR9/i9LKNfuVyZ9jAAAA3MCqVauynV2Xru6Kltdty68hYUeuzkUn6K4Hmsk3wEcpl3N+pPh63r5eKlutlLav3GPn6OBqihYtKsOQli3aanOb3+ZvUq9BLdSucWUt23igwGM6Eh2vx1//XneUDlHvtnVVoVwxlQ7yV/mSxXTlSpp++3G7liyO0rkzifLy9lS9huXV497GmjDmbt3Vurpeen2xUlLTCzwuAAAAR+Mddvs5evSojh49mmud1q1bKz4+Xr/++qsGDx5sU788Eo9crVywQT7+Prqrfwub27S5P0IBQX5a/u1fdowMrsjX11eH9p7SxYTLNrc5dfScTp9MUNVyJVSxVDH1bltHD3ZtpHvb1VWVsgX3ePqR6Hi9880qffHLRpUND9bmjYfVr8d7+mzGCkWfTFBaWoYuX0rV+j8PatyIbzVu5LdqULucJo+9R575eMoEAAAAtpsxY4YqVqwoX19fNWrUSGvXrs21/po1a9SoUSP5+vrqjjvu0Mcff2x1vm3btjKZTFmO7t27W+pMnjw5y/nw8PB/D2WTIUOG5Ho8/PDDkqTDhw9ryJAhNvfLDDtyde5UgjYuidK9z3TVynl/3XCW3cfPW/c9201bI3cr5uhZB0UJV+Hh4aErl9Py3C41JU1dIqprUPc7lZlp1pUrafLz9ZZnIQ/tPBit75bvUOSmm599N5mkCUM6af/uaL384g/KyMh5S7mtm47opRd/0OvvDVCHtjW1dOXemx4fAADAqVx0H/YFCxZoxIgRmjFjhlq0aKFPPvlEXbt21b59+7JdqO3o0aPq1q2bHnnkEc2dO1d//fWXhg8fruLFi+u+++6TJC1atEhpaf///9L4+HjVq1dP999/v1VftWrV0vLlyy3f53fnsRvNrl/ToEEDm+tKJOywwZxXf9K0ZS9q0ncjNaXve7pyKfstuHz8fTT+m6dVsmIJvfXopw6OEq7AbDarWPEieW5XLLSIUlPS9drz32n9yv3KyMiUh6eHmrWuprv7NtGrw7vrzppl9frsFTIb+f8p07R2BZUND9ZbE3/KNVm/ZtvmI9qy8bB6dm9Awg4AAJBHiYmJVt/7+PhYbfF9zbRp0zR06FANGzZMkvTee+9p6dKlmjlzpqZOnZql/scff6xy5crpvffekyTVqFFDW7du1dtvv21J2IsVK2bVZv78+fL398+SsBcqVCjfs+rXs3UFeC8vrzytFs8j8bih4/uj9dKAD1TtzsqaselV9XqyswKC/C3n/QP9dM/jHfXRxldUt1UNvdR/ug7vPO7EiOEsSUlJqlA1XOUql7C5Tf1mlRQUHKC3JizSn8v2KON/C8+ZM81av2q/Xnz8K73930Xq0aq2RvRvc1Px9W5bR4cOxmr/nmib2yxetFW1qpdSpYrFb2psAAAAp3PwKvFly5ZVUFCQ5cgu+U5LS9O2bdvUqVMnq/JOnTpp/fr12V7Ghg0bstTv3Lmztm7dqvT07NcemjVrlvr166eAgACr8kOHDqlUqVKqWLGi+vXrpyNHjmTbPi+Sk5MVHR2t5OTkm+6LhB022bX2b43s8KoO7jiuR14foHnHPtLnu97W57ve1rxjH+nxtwfq6N5ojer0mravYLE5d5WUlKTU1DT1GBBhc5seAyJ07J8z2r3tWI51li/eoU/f/l39OjdU5Zt4r71iyWLauT3ncbKzY/vVXz6VKxOS73EBAADc0cmTJ3Xx4kXLMW7cuCx14uLilJmZqbCwMKvysLAwy/7l/xYbG5tt/YyMDMXFxWWpv3nzZu3Zs8cyg39N06ZNNWfOHC1dulSfffaZYmNj1bx5c8XHx+f1UiVJf/75p1q0aKHAwECVLVtWRYoUUUREhNasWZOv/iQeiUcenDhwWq8P+UTBJQLV5r6mCi0dLJNMio85r9ULNysh9oKzQ4STGYah8+cT1K1vE21de1CbVu3PtX7nPo3VvGMtvTPpxxv2/ev3W3T/w63U5656ev2rFfmKz6uQp9JT87Z1XHpahiTJx4d/LgEAwK3N9L/DEeNIUmBgoAIDA21r8699yg3DyHXv8uzqZ1cuXZ1dr127tpo0aWJV3rVrV8vXderUUUREhCpVqqSvvvpKo0aNsinua9avX69OnTopJCRETzzxhEqWLKnY2Fh9//336tSpk1asWKGWLVvmqU+JhB35cP5son6aGensMOCi4uLi5Ovrq/++/6Bmvf2Hfv9+s1KSrReiKxzoq96DW2rA8PZavGCTIn+OumG/mRlm/bFom+4d3ELvfrtGqekZeY4t8XKKiofZ9kPjmtASV+snJl7J83gAAADIXWhoqDw9PbPMpp89ezbLLPo14eHh2dYvVKiQQkKsn4pMTk7W/PnzNWXKlBvGEhAQoDp16ujQoUN5vApp0qRJatCggVavXm31nv4bb7yhtm3batKkSVqxIu+TTiTsAArcqVOnVLJkSQ17vpsefKq9VvwcpZNHzsrDZNIdNUqqTff68vYupD+X7tZHU3+zud+9O07oocfbKTjQT7HxSXmOa+3OIxrYpbH8A3yUfIMdD67p1LWukpNTFbX7ZJ7HAwAAcCkuuEq8t7e3GjVqpMjISPXu3dtSHhkZqZ49e2bbJiIiQosXL7YqW7ZsmRo3biwvLy+r8u+++06pqal66KGHbhhLamqq9u/fr1atWtl+Af+zadMmffnll1kW1fPz89Pzzz9v2dYtr3iHHYBdxMTEqNeYz/Xdyp26s2NNPTr2bg15vptqNq+s+ZFR8vAwacVvu/LUZ+b/FqTzKpS/7TZ+Wr1bXl6e6ty9nk31vb0LqVvPhlq6cq+uXMn7dnUAAAC4sVGjRunzzz/XF198of3792vkyJE6ceKEHn/8cUnSuHHjNGjQIEv9xx9/XMePH9eoUaO0f/9+ffHFF5o1a5bGjBmTpe9Zs2apV69eWWbeJWnMmDFas2aNjh49qk2bNqlPnz5KTEzU4MGD83wNZrM5yy8LrvH29lZmZt5ey7yGGXYAdhMbn6SZC//SzIV/WZV7FfLUwG6NFV4mOE/9hZe+Wv9CUv4eT4+7cFm/rdunoU+008G/Y7R3V86z5p6eHnphUk8FFPbRwl+252s8AAAA3Fjfvn0VHx+vKVOmKCYmRrVr19aSJUtUvnx5SVcngk6cOGGpX7FiRS1ZskQjR47URx99pFKlSun999+3bOl2zcGDB7Vu3TotW7Ys23FPnTql/v37Ky4uTsWLF1ezZs20ceNGy7h5Ua9ePc2YMUM9evSweo/ebDZrxowZql+/fp77lEjYkU8+ft4KLRUsb18vJSZcUnzMBWeHhFtIekam1kYdVufeDfXztxttbte5dyNt3nNcScm2Pc6enbfmrlSZsKJ6Y/oAzZq5Skt/3aHkf71jX61GKQ15vJ3q1C+nSa//rJPRCfkeDwAAwFWYjKuHI8bJq+HDh2v48OHZnps9e3aWsjZt2mj79twnVapWrWpZjC478+fPz1OMuZkwYYJ69OihevXq6aGHHlLp0qV1+vRpff3119q7d2+WR/htRcKOPKlYq4y6D22n9n0j5FfY11J+KOqYfvtilVb9sEkpiXlfDAzu54eVO/Xh831Uv8kd2rH5xvtdVq1dWrXql9Pz7/9yU+OmpWfq2XcW6fmBd+nRpzvo4cfaau2qv3XubKK8vDxVr1F5VateSjGxF/TcxO8VtevEjTsFAACAW+vatavmz5+v0aNHW21fV6ZMGc2fP1/dunXLV78k7LCJyWTSfybeq76juis+5rx+eG+Jdq7Zr7TUdBUvHaxOA1vrmemD1W9MD0287x0d3x/t7JDh4rbsO6GdB6P1/NQ+eu7hWYo+kfN+lyVKBmnC2/108PhZrY06fNNjp6Vn6pUvIvXJjxvUs01tta5fSXWbVFB6SoZOnIrXF5N/0OZtR2U2O2JVFgAAAAdxwUXnbid9+vRRnz59dOjQIcXFxSkkJERVq1a9qT5J2GGTYS8/oN5PdtTn4+dr0ft/WBb/kqQDW6R1P21VqTtK6L/zntVbf7yoEXdN0enDZ5wYMVydYUjPvf+LPhn7gKbNeURfz1ihlb/tslq93cfXS+261tHAJ9srJTNTo979SZkFmESfO39Jn/+0UZ//dPWxfL84ng4BAADAzalSpYqqVKlSIH2RsOOGGt5VS/c93VkfjZqjX3LZf/30kbN6vstrmrbyvxr7xeN6ps1LDowSt6ILSVc07NX5emFwez3+QncNGdFJ2/46pKSLVxRQxFeNmleRf4CP1kYd1mtfRup8PhebKwg+PoVUqUJx+fv76EpKmo4dj9PlZFaOBwAAtxg3nf22t5deyj33Mf6vvTuPr/nK/zj+vrJdQmKJSpSgi61oiZYgVGlQRk0XVJvqVLVmqorhh25UO6WbqtqGUjXTUWppVQ2S1lohRaw1agixJKOxRRKy3e/vD+NOr+xxV/f1fDzO4yHfe77nnO/JaWY+9/P9nq9haMKECWVul4AdJer9fBcdTjxWbLB+zaXzmZo7bpHeWjFKjSJu06GdJT+bDO92KStbr81arVu+3KQ+97fQPXfWVsjtIcq8kqOlG/dqxfq9SklLd9n4bq1dTX0eukc9ujZTlSoVrccvX85R3MaDWrFql44k/eqy8QEAAMD1Jk6cWORn1za+I2CH3d1St4bu69ZCH784v9Tn7Fi3V6nHflWvwV0I2FFqZ85naM6Kra4eho2u9zfV2OE9lJVxRWv+vlUbv03UpQtZqhQYoMhuzdXjqXb6Xfe7NXPeei1e/pOrhwsAAFAsd94l3tP9+mvBBM7Zs2f17bff6tNPP9XSpUvL1S4BO4p1Z8v6qlChguJXlf491BaLofjvdqnVA80cODLAsTp3aKTXR/fSuiXbNf3Vr5Sbbft8+7FDKVo8I04xI7vrTy9Fy2Ix9NXXO1w0WgAAALhS9erVCz02cuRIXbp0SW+//bb+8Y9/lLldAnYUy1wpQJKUlV62Z4ez0i+rYuUARwwJcLjKgQEaM7yHflixQx+NWlRkPUu+RZ+/v1o+vj760wsPaOv2f+tUygXnDRQAAKAs2CXeJaKiovTRRx+V69wKdh4LbjJZ/93kq0qNymU6L6h6ZWWlX3HEkACH6961mXx9K+jTt78pVf2/TfmnMi5m6eGHWjp4ZAAAAPA0+/btk9lsLte5ZNhRrIMJR5Sbk6dOj7bRiulrS3WOr5+P2j/cWlu+4fZgeKaHe9yjH1fv1flfL5Wqfm52ntYu3qYeA9rp04WblJObX/JJAAAATsYz7I7z+eefFziWnZ2tvXv3at68eRowYEC52iVgR7Eu/JquLSt3qNfzXfT1jHXWHQ6L077PvaoeWlWr5n7vhBEC9uXv56PwujX01UdrynTezg3/0uNDuqhmSBVuiwcAAPAyzz77bKHHzWaznnzyyXLfEk/AjhKtnP29Pop7Vc+8+bg+e2NJsXVvCa+hF94doJ1x+3T84CknjRCwH/+Aq38Wr5TxHevX6gcE+Nl9TAAAAHbBM+wOk5SUVOBYxYoVVbNmzRtql4AdJTr40xHNeeVLPf9Of1WqYtbCict06XxmgXrNOzTWmM+GKOdKrt5/fo4LRgrcuKysHFkshqqGVCnTeVVrXt3nITMz2xHDAgAAgBsLDw93SLsE7CiV5TPWKftKjl6Y9IS6DeykDUvitWfjQeVk56pmnep68Kko3dY8XId2JWnC4x/p/H8uunrIQLlYLIZ27T6mzr+P0KqFW0p9Xuc+rXU8OU3/+TXdgaMDAAAoP55h9zwE7Ci17+Zt0JZvdqr701Hq8cz96jawkyQpPy9f2/65W3NfX6LdGw7Kkpvr4pECN2bFd4n6y+uP6PZmdXRk/8kS61evFaT23Vtoxrz1ThgdAAAAvAUBO8rkYtolLZ6yWounrJZfgK/8zX7KSr9Sqs3oAE8Rn3BEySfOavTHT2n0o9N06UJWkXUDzH4aN+MZZWRe0drv9ztxlAAAALjZ8R52lFtudp4yL14mWMdNJ99iaNzE5QoKqaIPvx6u5m3vKLTeHc3raNLiF3V78zp65a0VyizjRnUAAABOZTixwC7IsANAIU6ePq8XR3+ht17po/eWDNXxX1K16dtEpZ/PVKUqZkV2a67G99RTSsoFvTz2Sx36d6qrhwwAAICbDAE7ABThVMoFPfvSArVsEa4+PVuq93OdFBgYoMuXc/TzoRSNm7hc2386onwLXyMDAAAPwGvdPA4BOwCUIHFvshL3Jrt6GAAAAPAyBOwAAAAA4AV4rZvnIWCH3fgF+Krj7+/T3R0aqlKVirqSla1DO44qbtGPykq/7OrhAQAAAIBHIWDHDfPx9dFTY3ur56DOCqpeWb/sSlL6uQxVD62q+x9vq2cn9lXcP37U/DcWK+vSFVcPFwAAAPBOPMPucQjYcUP8Anw14cthatGhsVbOjtWqud/r9NEz1s+rh1ZVj2c66dFhPXRX5J0a03Oy0s9muHDEAAAAAOAZeA87bsjIGc/qrrZ36tWH39eccYtsgnVJOpd6QV9M/kYjur6larWCNWHxcFXwYdkBAAAAzmYyDKcV2AeRE8qtQbO66vx4W00f8bn2bDpYbN3jP5/S209N112RDdWmxz3OGSAAAAAAeDACdpRbr0H3K+30Of3wZXyp6u//8ZAOJvxbv3u+i4NHBgAAAKAAw4kFdkHAjnK7/7G2Wrtws/Lz8kt9zur56xXRpbmCa1Zx4MgAAAAAwPMRsKNczIEBCgyqqBOHTpfpvOR/Xa1fvVZVB4wKAAAAQFGuvYfdGQX2QcCOcjEs//2v0FS280ymqydYLBY7jwgAAAAAbi4E7CiX7Ms5unj2ku64u16Zzrv97nrKz7foXMoFxwwMAAAAQOF4ht3jELCj3OL+sVXRT3WUv9mv1Of0GvyAtn23S5fOZzpwZAAAAADg+QjYUW7fzV+voBqV1fO5B0pVv+1DLdXgrrpaNfd7B48MAAAAADyfr6sHgNL54MeRrh5CodLS0jT4nSd09vR5bVqeUGS9Zu0aasz8IdoWu097Ek+pQtVgJ46yeKM7T3f1EMrG18fVIyi1+bF/dPUQAAAA8F/O2hCOTefsh4AdNyQ1NVU+Pj569W9D1aHPNq2cHaf9W3+xfn5b87rqNbiLHnwqSj//dFTv/mmBDIP/ggEAAACgJATsuGGnTp3S5cuXdW+Pu9Xp0bZKO31e6ecyVKlKRYXWC1FaygUt+nitls6MU15u6d/ZDgAAAMCOnLUhHPk5uyFgh12cO3dO586dU2BgoLZ/+4sqVTbrcma2ftmTrO2x+5Sfx2vcAAAAAKAsCNhhV5mZmfr83VWuHgYAAACA6/AMu+chYIdbaB55h+o1DJNfgK8uXcjSzg0Hdf5MuquHBQAAAAAuQ8AOl/Hz91XPpzuoZ0wH1bmjlvJy85RzJU+VqpiVl5uvH/+5W8v/ul6/7D7u6qECAAAAno9n2D0OATtcIjCoot6YP1hNWzfQlm926KMX5+lA/OGrnwVXVNcn2qvXcw/ow69H6OP/W6S4JdtdPGIAAAAAcC4Cdjidr5+PXv/0OTVoXFuje7yrgwn/tvk88+JlfTM7Tt/O/UFDp8RoxIcDlJV+WVvX7HXRiAEAAICbA8+Xe5YKrh4AvM8Dj9yr5pF3aEK/jwsE679lybfok+ELFf9dol58p698fFmuAAAAALwHERCcrtczUdoRu08Hth0usa5hGPrbX75W9VrBiuzewgmjAwAAAG5ShuG8ArsgYIdT3XbXrbqzRbhWzVtf6nOO/XxS+348pO5PtHPgyAAAAADAvRCww6lq168pSfq5FNn13/p5+78VVj/EEUPCDQio6Keat1ZT9VrB8vXzcfVwAAAAUIxr72F3RoF9sOkcnMrH92pQl5ebX6bz8vPy5efHcnUHJpNJLTs2Us9nOqrNg83l43P1e7/Lmdn6YVmCVi3YpGMHT7t4lAAAAIDnIwKCU6Wfy5AkhdarqWM/nyz1ebXCQ3Tx3CVHDQulVKVaoF6f/7yat71DRw+c1Jw3lurk0TPyqVBBDVvWU/cn26vn01H67vPNmvnqElcPFwAAAL/Fe9g9DgE7nGp/whFdOHtJ0TEdNGfcl6U6p3LVSmrfO0JfTlvn4NGhOJUqmzX5q2GqERqscX2naffmQzaf//TDAX358Rp1f7K9hrz1uMyBAS4aKQAAAHBz4Bl2OFVudp7W/iNe0U9FqXLVSqU6p8cz98vH10drF8U7eHQozgsTH9Mtdarr/x75uECwfk1+nkXffb5Z7w9doC6P3adq1ao5eZQAAADAzYOAHU636vPNsuRb9MYXL5WYhY3o2kxPv/Z7rf7bFl1I45Z4VwmqHqjOj7TWlx+vVfIvKSXW37Ryl7au2aOqwQTsAAAA7sJkcV6BfXBLPJwuLeWCJj47VxP//kd9sGac/v7O10pYu0cWy/8edqkeWlU9B92vfiN7aseGg5o7cUWp2m7Q9Fb1GthBkd1aKKhaoHJz8nXy6H+05h/x+mFpgi5nZjvqsm5q0f0jZRhS7OLS3+Xw3YJNatf9blWqVElZWVkOHB0AAABwcyJgh0sc+OmoRj8yVS9N7q8Ji1/Wf5LTtHfLIeVeyVXIrdUU0aWZcrJz9fWnG/TZpG9lyS/+a7pKVcwa/cnTavtgc6WdPq91X/yoMyfOys/fV80i79QfJz6qP4z7nWa9tlTfL01w0lXePJree7v2xh9W+rnMUp+TuOmQLmdeIWAHAABwF2w653EI2OEyRw+c0ojffag7W9RV9yfbq17DUPkF+OrShSzNmbBccUsTlHXpSontVAwM0OQlLyk0vIYmDfqrtqzcpfy8/7027uvZcQqpXU0DX+2jUR/HyBwYoO8+3+zIS7vpVAwMKPMjCYZhKOvSFVWowJM3AAAAQHkQsMPlDu89ocN7S7djfGGGTu6n2vVralTPd5W0v/BXxaWdPq8PX/xMGRez9Me3HtO/9ybrUOLxcvfpbS5nZpd6k8BrTCaTKlUx62IpvnQBAACA45mMq8UZ/cA+SH3Bo4WEVVWnhyO04K3lRQbrvzXn1SVKOXpGfZ673/GDu4n8/NMRtYi8U0HVA0t9TsuOjVQx0Mzt8AAAAEA5EbDDo/V4sp2yL+co7sutpapvGIZWzd+g9g/do2o1qzh0bCaTSeENw3RXm9t1593hqhxctgy1O1n35dXN5h7sF1nqc3o+01GZGVkE7AAAAO7CMJxXYBcE7PBorTo10bbVu3U5o/S7v6//apv8/H3VPPJOh4ypSrVAPfrig5q3faL++uN4fbBqtKbFvaIv9r+rP09/Ro0jGjikX0dKP5epDSt2qP/L3RTeMKzE+h17t1K77nfrwsXzThgdAAAAPN3MmTPVoEEDmc1mRUREaPPm4vec2rhxoyIiImQ2m3Xbbbdp9uzZNp8vWLBAJpOpQLlyxfZxzbL262wE7PBogUFmnT+TXqZzLp7NkMViUWBQRbuPp3FEA83dOkEDx/XWgYQjGvfoVD3fboKGPvAXLZy0Unfdd7s+WjNGz7/1uCpUMNm9f0f66xtLdebkOb23/GW17Ni40Do+vhXUc2CU/m/GM/p+aYLOnydgBwAAcBfXnmF3RimLxYsXa/jw4Xr11VeVmJioqKgo9ejRQ8nJyYXWT0pK0kMPPaSoqCglJibqlVde0bBhw7Rs2TKbekFBQUpJSbEpZrO53P26ApvOwaNlX86VOdC/TOf4m/1UoUIFXcmy7zvZb29eV+8se1lH9p3QX56dowu/2u6qfmTfCS2fFaffDeqk59/uqwo+Js1+ZYldx+BIWRlXNPbxaXp9/vN6Z/FLSvr5lNZ88aNOJf2qChVMatSyvro/2U41Qqtq1YJNmvXaV3p3zQuuHjYAAABcJD3dNrEWEBCggICAAvWmTJmiQYMG6bnnnpMkTZ06VWvXrtWsWbM0adKkAvVnz56t8PBwTZ06VZLUpEkT7dixQx988IEeffRRaz2TyaTQ0NAix1fWfl2BgB0e7ciBk2rdpZkqVDDJYindV3n3PthckpT08ym7jcNkMun/Zj+rE7+k6rV+nyg7K6fQeoZhaOWnG5SXm6+XPnhSCev2adeGg3Ybh6NdOp+pMY9M1T1RjdTrmSg9P/Ex+fhcvVHncma2fliaoFWfb9Kxg6ddPFIAAAAU4OT3sNetW9fm8Pjx4zVhwgSbYzk5Odq5c6fGjh1rczw6Olpbtxa+T1V8fLyio6NtjnXr1k3z5s1Tbm6u/Pz8JEkZGRmqV6+e8vPzdc899+itt95Sy5Yty92vKxCww6OtXrhF3fpHqvWDzZWwdm+pzuk1qLMOJBzRsX+l2G0cd0c1UnjDMI363QdFBuu/tfrzzXromY7q9ez9HhWwS1e/dEjc9C8lbvqXAir6qUq1QOXnWXTpfKbycvNdPTwAAAC4iRMnTigoKMj6c2HZ9bS0NOXn56tWrVo2x2vVqqXU1NRC201NTS20fl5entLS0hQWFqbGjRtrwYIFat68udLT0/Xxxx+rffv22rNnj+68885y9esKPMMOj/bLnmQdSjymZ8c/qkqleCa9/e9aqWWnJvp2gX03k+j5h45K+vmUDmz7d6nP+W7+Rt0X3Vw1b61m17E4U/blXKWdvqDzZ9IJ1gEAANycs59hDwoKsimFBezWsZls93cyDKPAsZLq//Z427Zt9dRTT+nuu+9WVFSUlixZooYNG+qTTz65oX6djYAdHm/KiC9UI6yaJi0fqeqhwUXW6/x4G42ZO1jrV+zQppW77DqGO5qH66e4fWU6Z/u6ffLxqaAGTevYdSwAAACApwgJCZGPj0+BrPaZM2cKZL+vCQ0NLbS+r6+vatSoUeg5FSpU0L333qvDhw+Xu19XIGCHx0s+nKpx/T5RzTrVtWD3ZP3fX5/T3VGNFVa/psIbhemhP3TSrC0TNGbOYG3+NlFTRvzd+g2cvQRU9NflzLJtYnflv/XLumkeAAAAcLPw9/dXRESEYmNjbY7HxsaqXbt2hZ4TGRlZoP66devUunVr6/Pr1zMMQ7t371ZYWFi5+3UFnmHHTeHI/pN64YF3FN2vrXrGdNADfdtaP8vPt2jb2r2a+9bXStx8yCH9Z166rKohVcp0TnDNq/Uz0y87YkgAAACALcO4WpzRTxmMHDlSMTExat26tSIjIzVnzhwlJydryJAhkqRx48bp1KlTWrhwoSRpyJAhmj59ukaOHKnBgwcrPj5e8+bN06JFi6xtvvnmm2rbtq3uvPNOpaena9q0adq9e7dmzJhR6n7dAQE7bhoZF7K0/K8/aMWc9arXOExB1QKVl5OnlONpOn/dK9bsbffGfymqd4TmvrFU+XmWUp3T+ZF7dSUzW//akeTQsQEAAADurF+/fjp79qwmTpyolJQUNWvWTKtXr1a9evUkSSkpKTbvRm/QoIFWr16tESNGaMaMGapdu7amTZtm80q3Cxcu6Pnnn1dqaqqCg4PVsmVLbdq0Sffdd1+p+3UHJsPe9wZ7gPT0dAUHBys+Pl6VK1d29XBuOqO7/dXVQyibnNwbbqJ+k9qatekNTRo8V5u+3llifR/fClqw6x0lrNurT0b9o2yd+fqUc5TO937sH109BAAAgBuWkZGhyMhIXbx40WbXc09xLf6J7DFRvn5mh/eXl3tF8f98w2Pny53wDDtgB8cOntau9T/rhb/0VWi9kBLrv/jeAFUNqaJv521w/OAAAAAAeCQCdsBO3vvTZ7qcka0Pvxute7s2K/R1ECG1q2nMXwepR0wHfTzy7zp28LQLRgoAAACvZDixwC54hh2wk4tplzSq1/t6df7zmrhoqE4nndH3i7cpLfWC/AP81LJjE7Xp3kJXMrP1znNztfmbkm+dBwAAAOC9CNgBO7rw6yWN/t2HanLvber1h0565E8PKjCoonJz8pR86LRmjlmkH5YmWF/pBgAAADiLybhanNEP7IOAHXCAgz8d1cGfjkqSKlQwyWLhrxYAAACAsiFgBxyMYB0AAABuwWJcLc7oB3bBpnMAAAAAALghMuwAAAAA4A2ctYM7CXa7IcMOAAAAAIAbIsMOAAAAAF7AJCftEu/4LrwGGXYAAAAAANwQGXYAAAAA8AaGcbU4ox/YBRl2AAAAAADcEAE7AAAAAABuiFviAQAAAMALmAwnbTrHHfF2Q4YdAAAAAAA35NCAvXfv3goPD5fZbFZYWJhiYmJ0+vTpAvUWLFigFi1ayGw2KzQ0VEOHDi223fvvv18mk8mm9O/f31GXAQAAAACez3BigV049Jb4zp0765VXXlFYWJhOnTqlUaNG6bHHHtPWrVutdaZMmaIPP/xQ77//vtq0aaMrV67o6NGjJbY9ePBgTZw40fpzxYoVHXINAAAAAAC4gkMD9hEjRlj/Xa9ePY0dO1Z9+vRRbm6u/Pz8dP78eb322mv69ttv1aVLF2vdu+66q8S2K1WqpNDQ0FKNIzs7W9nZ2daf09PTy3AVAAAAAOD5TIYhkxNeueaMPryF0zadO3funL744gu1a9dOfn5+kqTY2FhZLBadOnVKTZo00aVLl9SuXTt9+OGHqlu3brHtffHFF/r73/+uWrVqqUePHho/fryqVKlSaN1JkybpzTfftPs1oXDvr33B1UMAAAAAAI/n8E3nxowZo8DAQNWoUUPJycn65ptvrJ8dPXpUFotF77zzjqZOnaqlS5fq3LlzevDBB5WTk1Nkm08++aQWLVqkDRs26PXXX9eyZcv0yCOPFFl/3LhxunjxorWcOHHCrtcIAAAAAG7P4sQCuyhzwD5hwoQCG75dX3bs2GGtP3r0aCUmJmrdunXy8fHR008/LeO/t0hYLBbl5uZq2rRp6tatm9q2batFixbp8OHDWr9+fZFjGDx4sLp27apmzZqpf//+Wrp0qeLi4rRr165C6wcEBCgoKMimAAAAAADgzsp8S/zQoUNL3JG9fv361n+HhIQoJCREDRs2VJMmTVS3bl1t27ZNkZGRCgsLkyQ1bdrUWr9mzZoKCQlRcnJyqcfUqlUr+fn56fDhw2rVqlXZLggAAAAAvADPsHueMgfs1wLw8riWWb+2AVz79u0lSYcOHVKdOnUkXX3WPS0tTfXq1St1uwcOHFBubq71CwAAAAAAADydw55hT0hI0PTp07V7924dP35c69ev14ABA3T77bcrMjJSktSwYUM9/PDDevnll7V161bt379fAwcOVOPGjdW5c2dJ0qlTp9S4cWMlJCRIko4cOaKJEydqx44dOnbsmFavXq3HH39cLVu2tH4BAAAAAAC4Du9h9zgOC9grVqyo5cuXq0uXLmrUqJGeffZZNWvWTBs3blRAQIC13sKFC9WmTRv17NlTnTp1kp+fn9asWWPdST43N1eHDh1SVlaWJMnf31/ff/+9unXrpkaNGmnYsGGKjo5WXFycfHx8HHU5AAAAAAA4lckwvO8Bg/T0dAUHBys+Pl6VK1d29XAAAAAAuLGMjAxFRkbq4sWLHrmB9bX4p2P71+Xra3Z4f3l5V7Tpx7c8dr7cicNf6wYAAAAAAMquzJvOAQAAAAA8j8m4WpzRD+yDDDsAAAAAAG6IgB0AAAAAADfELfEAAAAA4A0M42pxRj+wCzLsAAAAAAC4ITLsAAAAAOAFTJarxRn9wD7IsAMAAAAA4IbIsAMAAACAN+AZdo9Dhh0AAAAAADdEhh0AAAAAvIHx3+KMfmAXZNgBAAAAAHBDZNgBAAAAwAuYDEMmJzxf7ow+vAUZdgAAAAAA3BAZdgAAAADwBuwS73HIsAMAAAAA4IbIsAMAAACANzAkWZzUD+yCDDsAAAAAAG6IDDsAAAAAeAF2ifc8ZNgBAAAAAHBDBOwAAAAAALghbokHAAAAAG9gyEmvdXN8F96CDDsAAAAAAG6IDDsAAAAAeAPDcFKGnRS7vZBhBwAAAADADZFhBwAAAABvYJFkclI/sAsy7AAAAAAAuCEy7AAAAADgBUyGIZMTni93Rh/eggw7AAAAAABuiAw7AAAAAHgDdon3OGTYAQAAAAAuNXPmTDVo0EBms1kRERHavHlzsfU3btyoiIgImc1m3XbbbZo9e7bN53PnzlVUVJSqVaumatWqqWvXrkpISLCpM2HCBJlMJpsSGhpq92u7EQTsAAAAAOANrmXYnVHKYPHixRo+fLheffVVJSYmKioqSj169FBycnKh9ZOSkvTQQw8pKipKiYmJeuWVVzRs2DAtW7bMWmfDhg164okntH79esXHxys8PFzR0dE6deqUTVt33XWXUlJSrGXfvn1ln1cH4pZ4AAAAAIDdpaen2/wcEBCggICAAvWmTJmiQYMG6bnnnpMkTZ06VWvXrtWsWbM0adKkAvVnz56t8PBwTZ06VZLUpEkT7dixQx988IEeffRRSdIXX3xhc87cuXO1dOlSff/993r66aetx319fd0uq/5bZNgBAAAAwBs4OcNet25dBQcHW0thwXdOTo527typ6Ohom+PR0dHaunVroZcRHx9foH63bt20Y8cO5ebmFnpOVlaWcnNzVb16dZvjhw8fVu3atdWgQQP1799fR48eLfV0OgMZdgAAAACA3Z04cUJBQUHWnwvLrqelpSk/P1+1atWyOV6rVi2lpqYW2m5qamqh9fPy8pSWlqawsLAC54wdO1a33nqrunbtaj3Wpk0bLVy4UA0bNtR//vMfvf3222rXrp0OHDigGjVqlOlaHYWAHQAAAAC8gUWSyUn9SAoKCrIJ2ItjMtkOzDCMAsdKql/YcUl67733tGjRIm3YsEFms9l6vEePHtZ/N2/eXJGRkbr99tv1+eefa+TIkaUat6MRsAMAAAAAXCIkJEQ+Pj4FsulnzpwpkEW/JjQ0tND6vr6+BTLjH3zwgd555x3FxcWpRYsWxY4lMDBQzZs31+HDh8txJY7BM+wAAAAAAJfw9/dXRESEYmNjbY7HxsaqXbt2hZ4TGRlZoP66devUunVr+fn5WY+9//77euutt7RmzRq1bt26xLFkZ2fr4MGDhd5S7yoE7AAAAADgBUyG4bRSFiNHjtSnn36q+fPn6+DBgxoxYoSSk5M1ZMgQSdK4ceNsdnYfMmSIjh8/rpEjR+rgwYOaP3++5s2bp1GjRlnrvPfee3rttdc0f/581a9fX6mpqUpNTVVGRoa1zqhRo7Rx40YlJSVp+/bteuyxx5Senq6BAwfe4EzbD7fEAwAAAABcpl+/fjp79qwmTpyolJQUNWvWTKtXr1a9evUkSSkpKTbvZG/QoIFWr16tESNGaMaMGapdu7amTZtmfaWbJM2cOVM5OTl67LHHbPoaP368JkyYIEk6efKknnjiCaWlpalmzZpq27attm3bZu3XHZgMo4xff9wE0tPTFRwcrPj4eFWuXNnVwwEAAADgxjIyMhQZGamLFy+WehM1d3It/ul65wj5+hTcqd3e8vKzFXf4I4+dL3fCLfEAAAAAALghbokHAAAAAG9gMSSTE26wtnjdTdwOQ4YdAAAAAAA3RIYdAAAAALyBYVwtzugHdkGGHQAAAAAAN0SGHQAAAAC8gpMy7CLDbi9k2AEAAAAAcENk2AEAAADAG/AMu8chww4AAAAAgBsiww4AAAAA3sBiyCnPl/Medrshww4AAAAAgBsiww4AAAAA3sCwXC3O6Ad2QYYdAAAAAAA3RMAOAAAAAIAb4pZ4AAAAAPAGvNbN45BhBwAAAADADZFhBwAAAABvwGvdPA4ZdgAAAAAA3BAZdgAAAADwBjzD7nHIsAMAAAAA4IbIsAMAAACANzDkpAy747vwFmTYAQAAAABwQ2TYAQAAAMAb8Ay7xyHDDgAAAACAGyLDDgAAAADewGKRZHFSP7AHMuwAAAAAALghMuwAAAAA4A14ht3jkGEHAAAAAMANkWEHAAAAAG9Aht3jkGEHAAAAAMANEbADAAAAAOCGuCUeAAAAALyBxZDkhNvVLdwSby9k2AEAAAAAcENk2AEAAADACxiGRYZhcUo/sA8y7AAAAAAAuCEy7AAAAADgDQzDOc+X81o3uyHDDgAAAACAGyLDDgAAAADewHDSLvFk2O2GDDsAAAAAAG6IDDsAAAAAeAOLRTI5YQd3dom3GzLsAAAAAAC4ITLsAAAAAOANeIbd45BhBwAAAADADZFhBwAAAAAvYFgsMpzwDLvBM+x2Q4YdAAAAAAA3RIYdAAAAALwBz7B7HDLsAAAAAAC4IQJ2AAAAAADcELfEAwAAAIA3sBiSiVviPQkZdgAAAAAA3BAZdgAAAADwBoYhyQmvXCPDbjdk2AEAAAAAcENk2AEAAADACxgWQ4YTnmE3yLDbDRl2AAAAAADcEBl2AAAAAPAGhkXOeYbdCX14CTLsAAAAAAC4ITLsAAAAAOAFeIbd8zg0w967d2+Fh4fLbDYrLCxMMTExOn36tPXzBQsWyGQyFVrOnDlTZLvZ2dl66aWXFBISosDAQPXu3VsnT5505KUAAAAAABxk5syZatCggcxmsyIiIrR58+Zi62/cuFEREREym8267bbbNHv27AJ1li1bpqZNmyogIEBNmzbVihUrbrhfZ3NowN65c2ctWbJEhw4d0rJly3TkyBE99thj1s/79eunlJQUm9KtWzd16tRJt9xyS5HtDh8+XCtWrNCXX36pLVu2KCMjQ7169VJ+fr4jLwcAAAAAPJdhcV4pg8WLF2v48OF69dVXlZiYqKioKPXo0UPJycmF1k9KStJDDz2kqKgoJSYm6pVXXtGwYcO0bNkya534+Hj169dPMTEx2rNnj2JiYtS3b19t37693P26gslw4v0KK1euVJ8+fZSdnS0/P78Cn//666+69dZbNW/ePMXExBTaxsWLF1WzZk397W9/U79+/SRJp0+fVt26dbV69Wp169atwDnZ2dnKzs62aSM8PFxxcXEKDAy009UBAAAAuBllZmaqa9euunDhgoKDg109nDJLT09XcHCwOugh+apgHGZvecrVFq3WiRMnFBQUZD0eEBCggICAAvXbtGmjVq1aadasWdZjTZo0UZ8+fTRp0qQC9ceMGaOVK1fq4MGD1mNDhgzRnj17FB8fL+lqcjg9PV3//Oc/rXW6d++uatWqadGiReXq1yUMJzl79qzRt29fo3379kXW+eCDD4zg4GAjKyuryDrff/+9Ick4d+6czfEWLVoYb7zxRqHnjB8/3pBEoVAoFAqFQqFQKOUuJ06cKF8w5GKXL182QkNDnTpXlStXLnBs/PjxBcaWnZ1t+Pj4GMuXL7c5PmzYMKNjx46FXk9UVJQxbNgwm2PLly83fH19jZycHMMwDKNu3brGlClTbOpMmTLFCA8PL3e/ruDwTefGjBmj6dOnKysrS23bttWqVauKrDt//nwNGDBAFStWLLJOamqq/P39Va1aNZvjtWrVUmpqaqHnjBs3TiNHjrT+bLFYdO7cOdWoUUMmk6mMV+R86enpqlu3boFvqHDjmFvHYW4dh7l1HObWcZhbx2J+HYe5dRxPmlvDMHTp0iXVrl3b1UMpF7PZrKSkJOXk5DitT8MwCsRahWXX09LSlJ+fr1q1atkcLy6+S01NLbR+Xl6e0tLSFBYWVmSda22Wp19XKHPAPmHCBL355pvF1vnpp5/UunVrSdLo0aM1aNAgHT9+XG+++aaefvpprVq1qsAvLz4+Xj///LMWLlxY1iFJKnxBXFPYrRdVq1YtVz+uFBQU5PZ/zDwVc+s4zK3jMLeOw9w6DnPrWMyv4zC3juMpc+uJt8L/ltlsltlsdvUwinR9LFdcfFdU/euPl6bNsvbrbGUO2IcOHar+/fsXW6d+/frWf4eEhCgkJEQNGzZUkyZNVLduXW3btk2RkZE253z66ae65557FBERUWzboaGhysnJ0fnz522y7GfOnFG7du3KejkAAAAAABcJCQmRj49Pgaz2mTNnCmS/rwkNDS20vq+vr2rUqFFsnWttlqdfVyjzLvEhISFq3LhxsaWob26ufevx2w3gJCkjI0NLlizRoEGDSuw/IiJCfn5+io2NtR5LSUnR/v37CdgBAAAAwIP4+/srIiLCJr6TpNjY2CLju8jIyAL1161bp9atW1s3Ny+qzrU2y9OvKzjsGfaEhAQlJCSoQ4cOqlatmo4ePao33nhDt99+e4Hs+uLFi5WXl6cnn3yyQDunTp1Sly5dtHDhQt13330KDg7WoEGD9Oc//1k1atRQ9erVNWrUKDVv3lxdu3Z11OW4VEBAgMaPH1/oMx+4Mcyt4zC3jsPcOg5z6zjMrWMxv47D3DoOc4trRo4cqZiYGLVu3VqRkZGaM2eOkpOTNWTIEElX9yQ7deqU9fHpIUOGaPr06Ro5cqQGDx6s+Ph4zZs3z7r7uyS9/PLL6tixo9599109/PDD+uabbxQXF6ctW7aUul+34Kjd7Pbu3Wt07tzZqF69uhEQEGDUr1/fGDJkiHHy5MkCdSMjI40BAwYU2k5SUpIhyVi/fr312OXLl42hQ4ca1atXNypWrGj06tXLSE5OdtSlAAAAAAAcaMaMGUa9evUMf39/o1WrVsbGjRutnw0cONDo1KmTTf0NGzYYLVu2NPz9/Y369esbs2bNKtDmV199ZTRq1Mjw8/MzGjdubCxbtqxM/boDp76HHQAAAAAAlE6Zn2EHAAAAAACOR8AOAAAAAIAbImAHAAAAAMANEbADAAAAAOCGCNidaNKkSbr33ntVpUoV3XLLLerTp48OHTpkU8cwDE2YMEG1a9dWxYoVdf/99+vAgQPFtrtgwQKZTKYC5cqVK468HLdSmrldvny5unXrppCQEJlMJu3evbtUbS9btkxNmzZVQECAmjZtqhUrVjjgCtybo+aXtVvy3Obm5mrMmDFq3ry5AgMDVbt2bT399NM6ffp0iW17+9p11Nyybkv3N2HChAlq3LixAgMDVa1aNXXt2lXbt28vsW3WrWPmlnVburn9rRdeeEEmk0lTp04tsW3WrWPmlnULELA71caNG/Xiiy9q27Ztio2NVV5enqKjo5WZmWmt895772nKlCmaPn26fvrpJ4WGhurBBx/UpUuXim07KChIKSkpNsVsNjv6ktxGaeY2MzNT7du31+TJk0vdbnx8vPr166eYmBjt2bNHMTEx6tu3b6n+T+fNxFHzK7F2S5rbrKws7dq1S6+//rp27dql5cuX65dfflHv3r2LbZe167i5lVi3pfmb0LBhQ02fPl379u3Tli1bVL9+fUVHR+vXX38tsl3WrePmVmLdlmZur/n666+1fft21a5du8R2WbeOm1uJdQs47D3sKNmZM2cMSdZ3/VksFiM0NNSYPHmytc6VK1eM4OBgY/bs2UW289lnnxnBwcGOHq5HuX5ufyspKcmQZCQmJpbYTt++fY3u3bvbHOvWrZvRv39/ew3VI9lrflm7BRU3t9ckJCQYkozjx48XWYe1W5C95pZ1W1Bp5vbixYuGJCMuLq7IOqzbguw1t6zbgoqa25MnTxq33nqrsX//fqNevXrGRx99VGw7rNuC7DW3rFvAMMiwu9DFixclSdWrV5ckJSUlKTU1VdHR0dY6AQEB6tSpk7Zu3VpsWxkZGapXr57q1KmjXr16KTEx0XED9wDXz215xcfH2/w+JKlbt24l/j5udvaaX4m1e73SzO3FixdlMplUtWrVIuuwdguy19xKrNvrlTS3OTk5mjNnjoKDg3X33XcX2Q7rtiB7za3Eur1eYXNrsVgUExOj0aNH66677ipVO6zbguw1txLrFiBgdxHDMDRy5Eh16NBBzZo1kySlpqZKkmrVqmVTt1atWtbPCtO4cWMtWLBAK1eu1KJFi2Q2m9W+fXsdPnzYcRfgxgqb2/JKTU0t8+/jZmfP+WXt2irN3F65ckVjx47VgAEDFBQUVGRbrF1b9pxb1q2t4uZ21apVqly5ssxmsz766CPFxsYqJCSkyLZYt7bsObesW1tFze27774rX19fDRs2rNRtsW5t2XNuWbeA5OvqAXiroUOHau/evdqyZUuBz0wmk83PhmEUOPZbbdu2Vdu2ba0/t2/fXq1atdInn3yiadOm2W/QHqK4uS2Psv4+bnb2nF/Wrq2S5jY3N1f9+/eXxWLRzJkzS2yPtfs/9pxb1q2t4ua2c+fO2r17t9LS0jR37lzrc7233HJLke2xbv/HnnPLurVV2Nzu3LlTH3/8sXbt2lXmNce6/R97zi3rFiDD7hIvvfSSVq5cqfXr16tOnTrW46GhoZJU4BvZM2fOFPjmtjgVKlTQvffe65XfPhY1t+UVGhp6w7+Pm4m95/d6rN2i5zY3N1d9+/ZVUlKSYmNji80AS6zd37L33F6PdVv03AYGBuqOO+5Q27ZtNW/ePPn6+mrevHlFtse6/R97z+31WLcF53bz5s06c+aMwsPD5evrK19fXx0/flx//vOfVb9+/SLbY93+j73n9nrevG7hvQjYncgwDA0dOlTLly/XDz/8oAYNGth83qBBA4WGhio2NtZ6LCcnRxs3blS7du3K1M/u3bsVFhZmt7G7u5LmtrwiIyNtfh+StG7dujL9Pm4Gjprfwvph7Rac22sB5eHDhxUXF6caNWqU2C5r13FzW1g/rNvS/U0wDEPZ2dlFfs66ddzcFlafdWs7tzExMdq7d692795tLbVr19bo0aO1du3aIttl3Tpubgvrx9vWLcAu8U70xz/+0QgODjY2bNhgpKSkWEtWVpa1zuTJk43g4GBj+fLlxr59+4wnnnjCCAsLM9LT0611YmJijLFjx1p/njBhgrFmzRrjyJEjRmJiovGHP/zB8PX1NbZv3+7U63Ol0szt2bNnjcTEROO7774zJBlffvmlkZiYaKSkpFjrXD+3P/74o+Hj42NMnjzZOHjwoDF58mTD19fX2LZtm1Ovz9UcNb+s3ZLnNjc31+jdu7dRp04dY/fu3TZ1srOzre2wdgty1Nyybkue24yMDGPcuHFGfHy8cezYMWPnzp3GoEGDjICAAGP//v3Wdli3BTlqblm3pfvfsusVtpM567YgR80t6xYwDAJ2J5JUaPnss8+sdSwWizF+/HgjNDTUCAgIMDp27Gjs27fPpp1OnToZAwcOtP48fPhwIzw83PD39zdq1qxpREdHG1u3bnXSVbmH0sztZ599Vmid8ePHW+tcP7eGYRhfffWV0ahRI8PPz89o3LixsWzZMudclBtx1Pyydkue22uvySusrF+/3toOa7cgR80t67bkub18+bLx+9//3qhdu7bh7+9vhIWFGb179zYSEhJs2mHdFuSouWXdlu5/y65XWFDJui3IUXPLugUMw2QYhlGezDwAAAAAAHAcnmEHAAAAAMANEbADAAAAAOCGCNgBAAAAAHBDBOwAAAAAALghAnYAAAAAANwQATsAAAAAAG6IgB0AAAAAADdEwA4AAAAAgBsiYAcAAAAAwA0RsAMAAAAA4IYI2AEAAAAAcEP/D3kdaU+iTirmAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "x_centers, y_centers = np.meshgrid(\n", " fieldset.U.lon - np.diff(fieldset.U.lon[:2]) / 2,\n", @@ -447,7 +389,7 @@ { "attachments": {}, "cell_type": "markdown", - "id": "ad657e8f", + "id": "18", "metadata": {}, "source": [ "Finally, to see the `C` field in time we have to load the `.nc` files produced during the run. In the following plots, particle location and field values are shown at each time step.\n" @@ -455,21 +397,10 @@ }, { "cell_type": "code", - "execution_count": 9, - "id": "53b8979a", + "execution_count": null, + "id": "19", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots(5, 5, figsize=(30, 20))\n", "\n", @@ -535,7 +466,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "parcels", "language": "python", "name": "python3" }, @@ -549,7 +480,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.13.2" } }, "nbformat": 4, diff --git a/docs/examples/tutorial_peninsula_AvsCgrid.ipynb b/docs/examples/tutorial_peninsula_AvsCgrid.ipynb index f084997a3..71a2a55e9 100644 --- a/docs/examples/tutorial_peninsula_AvsCgrid.ipynb +++ b/docs/examples/tutorial_peninsula_AvsCgrid.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -88,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -101,7 +101,7 @@ " particle.delete()\n", "\n", "\n", - "ptype = parcels.ScipyParticle.add_variables({\"p\": np.float32})" + "ptype = parcels.Particle.add_variables({\"p\": np.float32})" ] }, { @@ -113,28 +113,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in Trajs_A_linear.zarr.\n", - "100%|██████████| 100000.0/100000.0 [00:02<00:00, 39963.33it/s]\n", - "INFO: Output files are stored in Trajs_A_freeslip.zarr.\n", - "100%|██████████| 100000.0/100000.0 [00:02<00:00, 43447.65it/s]\n", - "INFO: Output files are stored in Trajs_C_cgrid_velocity.zarr.\n", - "100%|██████████| 100000.0/100000.0 [00:02<00:00, 43567.63it/s]\n", - "INFO: Output files are stored in Trajs_C_analytical.zarr.\n", - "100%|██████████| 100000.0/100000.0 [00:02<00:00, 44213.00it/s]\n", - "INFO: Output files are stored in Trajs_A_cgrid_velocity.zarr.\n", - "100%|██████████| 100000.0/100000.0 [00:02<00:00, 43377.32it/s]\n", - "INFO: Output files are stored in Trajs_C_linear.zarr.\n", - "100%|██████████| 100000.0/100000.0 [00:02<00:00, 44363.31it/s]\n" - ] - } - ], + "outputs": [], "source": [ "@dataclass\n", "class Experiment:\n", @@ -207,7 +188,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -235,20 +216,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axs = plt.subplots(1, len(exps), figsize=(15, 4), sharey=\"row\")\n", "\n", @@ -272,7 +242,7 @@ " # Set the same limits for all subplots\n", " ax.set_xlim([fieldset.U.lon.min(), fieldset.U.lon.max()])\n", " ax.set_ylim([0, 23e3])\n", - " m2km = lambda x, _: f\"{x/1000:.1f}\"\n", + " m2km = lambda x, _: f\"{x / 1000:.1f}\"\n", " ax.xaxis.set_major_formatter(m2km)\n", " ax.yaxis.set_major_formatter(m2km)\n", " ax.set_xlabel(\"x [km]\")\n", @@ -296,20 +266,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots(1, 1, figsize=(5, 4))\n", "ax.pcolormesh(lonplot, latplot, lmask.mask, cmap=\"Blues\")\n", @@ -347,7 +306,7 @@ "ax.set_ylim([0, 23e3])\n", "ax.set_ylabel(\"y [km]\")\n", "ax.set_xlabel(\"x [km]\")\n", - "m2km = lambda x, _: f\"{x/1000:.1f}\"\n", + "m2km = lambda x, _: f\"{x / 1000:.1f}\"\n", "ax.xaxis.set_major_formatter(m2km)\n", "ax.yaxis.set_major_formatter(m2km)\n", "\n", @@ -364,20 +323,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots(1, 1, figsize=(6, 4))\n", "\n", @@ -410,7 +358,7 @@ ], "metadata": { "kernelspec": { - "display_name": "parcels-dev", + "display_name": "parcels", "language": "python", "name": "python3" }, @@ -424,7 +372,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.15" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/docs/examples/tutorial_periodic_boundaries.ipynb b/docs/examples/tutorial_periodic_boundaries.ipynb index 00dd42c9f..bd6968581 100644 --- a/docs/examples/tutorial_periodic_boundaries.ipynb +++ b/docs/examples/tutorial_periodic_boundaries.ipynb @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -81,13 +81,19 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "example_dataset_folder = parcels.download_example_dataset(\"Peninsula_data\")\n", - "fieldset = parcels.FieldSet.from_parcels(\n", - " f\"{example_dataset_folder}/peninsula\", allow_time_extrapolation=True\n", + "filenames = {\n", + " \"U\": str(example_dataset_folder / \"peninsulaU.nc\"),\n", + " \"V\": str(example_dataset_folder / \"peninsulaV.nc\"),\n", + "}\n", + "variables = {\"U\": \"vozocrtx\", \"V\": \"vomecrty\"}\n", + "dimensions = {\"lon\": \"nav_lon\", \"lat\": \"nav_lat\", \"time\": \"time_counter\"}\n", + "fieldset = parcels.FieldSet.from_netcdf(\n", + " filenames, variables, dimensions, allow_time_extrapolation=True\n", ")" ] }, @@ -105,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -125,7 +131,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -146,22 +152,13 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in PeriodicParticle.zarr.\n", - "100%|██████████| 86400.0/86400.0 [00:00<00:00, 202338.06it/s]\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "pset = parcels.ParticleSet.from_line(\n", " fieldset,\n", - " pclass=parcels.JITParticle,\n", + " pclass=parcels.Particle,\n", " size=10,\n", " start=(20e3, 3e3),\n", " finish=(20e3, 45e3),\n", @@ -187,20 +184,9 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "ds = xr.open_zarr(\"PeriodicParticle.zarr\")\n", "\n", @@ -229,7 +215,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "parcels", "language": "python", "name": "python3" }, @@ -243,7 +229,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/docs/examples/tutorial_sampling.ipynb b/docs/examples/tutorial_sampling.ipynb index e568d969a..50ef615bc 100644 --- a/docs/examples/tutorial_sampling.ipynb +++ b/docs/examples/tutorial_sampling.ipynb @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -61,27 +61,21 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Velocity and temperature fields\n", "example_dataset_folder = parcels.download_example_dataset(\"Peninsula_data\")\n", - "fieldset = parcels.FieldSet.from_parcels(\n", - " f\"{example_dataset_folder}/peninsula\",\n", - " extra_fields={\"T\": \"T\"},\n", - " allow_time_extrapolation=True,\n", + "filenames = {\n", + " \"U\": str(example_dataset_folder / \"peninsulaU.nc\"),\n", + " \"V\": str(example_dataset_folder / \"peninsulaV.nc\"),\n", + " \"T\": str(example_dataset_folder / \"peninsulaT.nc\"),\n", + "}\n", + "variables = {\"U\": \"vozocrtx\", \"V\": \"vomecrty\", \"T\": \"T\"}\n", + "dimensions = {\"lon\": \"nav_lon\", \"lat\": \"nav_lat\", \"time\": \"time_counter\"}\n", + "fieldset = parcels.FieldSet.from_netcdf(\n", + " filenames, variables, dimensions, allow_time_extrapolation=True\n", ")\n", "\n", "# Particle locations and initial time\n", @@ -114,11 +108,11 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "SampleParticle = parcels.JITParticle.add_variable(\"temperature\")\n", + "SampleParticle = parcels.Particle.add_variable(\"temperature\")\n", "\n", "pset = parcels.ParticleSet(\n", " fieldset=fieldset, pclass=SampleParticle, lon=lon, lat=lat, time=time\n", @@ -139,18 +133,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in SampleTemp.zarr.\n", - "100%|██████████| 108000.0/108000.0 [00:03<00:00, 35058.76it/s]\n" - ] - } - ], + "outputs": [], "source": [ "pset = parcels.ParticleSet(\n", " fieldset=fieldset, pclass=SampleParticle, lon=lon, lat=lat, time=time\n", @@ -176,20 +161,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "Particle_data = xr.open_zarr(\"SampleTemp.zarr\")\n", "\n", @@ -231,25 +205,16 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WARNING: Sampling of velocities should normally be done using fieldset.UV or fieldset.UVW object; tread carefully\n", - "0it [00:00, ?it/s]\n" - ] - } - ], + "outputs": [], "source": [ "def SampleVel_wrong(particle, fieldset, time):\n", " u = fieldset.U[particle]\n", "\n", "\n", "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=lon, lat=lat, time=time\n", + " fieldset=fieldset, pclass=parcels.Particle, lon=lon, lat=lat, time=time\n", ")\n", "\n", "pset.execute(SampleVel_wrong)" @@ -265,24 +230,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0it [00:00, ?it/s]\n" - ] - } - ], + "outputs": [], "source": [ "def SampleVel_correct(particle, fieldset, time):\n", " u, v = fieldset.UV[particle]\n", "\n", "\n", "pset = parcels.ParticleSet(\n", - " fieldset=fieldset, pclass=parcels.JITParticle, lon=lon, lat=lat, time=time\n", + " fieldset=fieldset, pclass=parcels.Particle, lon=lon, lat=lat, time=time\n", ")\n", "\n", "pset.execute(SampleVel_correct)" @@ -298,11 +255,11 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "SampleParticle = parcels.JITParticle.add_variables(\n", + "SampleParticle = parcels.Particle.add_variables(\n", " [\n", " parcels.Variable(\"U\", dtype=np.float32, initial=np.nan),\n", " parcels.Variable(\"V\", dtype=np.float32, initial=np.nan),\n", @@ -344,11 +301,11 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "SampleParticleOnce = parcels.JITParticle.add_variable(\n", + "SampleParticleOnce = parcels.Particle.add_variable(\n", " \"temperature\", initial=0, to_write=\"once\"\n", ")\n", "\n", @@ -359,18 +316,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in WriteOnce.zarr.\n", - "100%|██████████| 86400.0/86400.0 [00:01<00:00, 47197.59it/s] \n" - ] - } - ], + "outputs": [], "source": [ "output_file = pset.ParticleFile(name=\"WriteOnce.zarr\", outputdt=timedelta(hours=1))\n", "\n", @@ -392,20 +340,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "Particle_data = xr.open_zarr(\"WriteOnce.zarr\")\n", "\n", @@ -433,7 +370,7 @@ "metadata": { "celltoolbar": "Raw-celnotatie", "kernelspec": { - "display_name": "Python 3", + "display_name": "parcels", "language": "python", "name": "python3" }, @@ -447,7 +384,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.12.3" }, "pycharm": { "stem_cell": { diff --git a/docs/examples/tutorial_stommel_uxarray.ipynb b/docs/examples/tutorial_stommel_uxarray.ipynb new file mode 100644 index 000000000..bb0b3fd6a --- /dev/null +++ b/docs/examples/tutorial_stommel_uxarray.ipynb @@ -0,0 +1,387 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Stommel Gyre on Unstructured Grid\n", + "This tutorial walks a simple example of using Parcels for particle advection on an unstructured grid. The purpose of this tutorial is to introduce you to the new way fields and fieldsets can be instantiated in Parcels using UXArray DataArrays and UXArray grids.\n", + "\n", + "We focus on a simple example, using constant-in-time velocity and pressure fields for the classic barotropic Stommel Gyre. This example dataset is included in Parcels' new `parcels._datasets` module. This module provides example XArray and UXArray datasets that are compatible with Parcels and mimic the way many general circulation model outputs are represented in (U)XArray. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading the example dataset\n", + "Creating a particle simulation starts with defining a dataset that contains the fields that will be used to influence particle attributes, such as position, through kernels. In this example, we focus on advection. Because of this, the dataset we're using will provide velocity fields for our simulation.\n", + "\n", + "Parcels now includes pre-canned example datasets to demonstrate the schema of XArray and UXArray datasets that are compatible with Parcels. For unstructured grid datasets, you can use the `parcels._datasets.unstructured.generic.datasets` dictionary to see which datasets are available for unstructured grids." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from parcels._datasets.unstructured.generic import datasets as datasets_unstructured" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "datasets_unstructured.keys()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, we'll be using the stommel_gyre_delaunay example dataset. This dataset is created by generating a delaunay triangulation of a uniform grid of points in a square domain $x \\in [0,60^\\circ] \\times [0,60^\\circ]$. There is a single vertical layer that is 1000m thick. This layer is defined by the layer surfaces $z_f = 0$ and $z_f = 1000$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ds = datasets_unstructured[\"stommel_gyre_delaunay\"]\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"lon\", ds.uxgrid.face_lon.min().data[()], ds.uxgrid.face_lon.max().data[()])\n", + "print(\"lat\", ds.uxgrid.face_lat.min().data[()], ds.uxgrid.face_lat.max().data[()])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the dataset, we have the following dimensions\n", + "\n", + "* `time: 1` - The number of time levels that the variables in this dataset are defined at. \n", + "* `nz1: 1` - The number of vertical layers. The `nz1` dimension is associated with the `nz1` coordinate that defines the vertical position of the center of each vertical layer. The `nz1` coordinate consists of non-negative values that are assumed to increase with `nz1` dimension index.\n", + "* `n_face: 721` - The number of 2-d unstructured grid faces in the `UXArray.grid`\n", + "* `nz: 2` - The number of vertical layer interfaces. The `nz` dimension is associated with the `nz` coordinate that defines the vertical positions of the interfaces of each vertical layer. The `nz` coordinate consists of non-negative values that are assumed to increase with `nz` dimension index. Note that the number of layer interfaces is always the number of layers plus one.\n", + "* `n_node: 400` - The number of corner node vertices in the grid.\n", + "\n", + "Whenever you are building a UXArray dataset for use in Parcels, its important to keep in mind that these dimensions and coordinates are assumed to exist for your dataset. Further, it is highly recommended that you use UXArray when possible to load unstructured general circulation model data when possible. This ensures that other characteristics, such as the counterclockwise ordering of vertices for each element, are defined properly for use in Parcels." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining a Grid, Fields, and Vector Fields\n", + "\n", + "A `UXArray.Dataset` consists of multiple `UXArray.UxDataArray`'s and a `UXArray.UxGrid`. Parcels views general circulation model data through the `Field` and `VectorField` classes. A `Field` is defined by its `name`, `data`, `grid`, and `interp_method`. A `VectorField` can be constructed by using 2 or 3 `Field`'s. The `Field.data` attribute can be either an `XArray.DataArray` or `UXArray.UxDataArray` object. The `Field.grid` attribute is of type `Parcels.XGrid` or `Parcels.UXGrid`. Last, the `interp_method` is a dynamic function that can be set at runtime to define the interpolation procedure for the `Field`. This gives you the flexibility to use one of the pre-defined interpolation methods included with Parcels v4, or to create your own interpolator. \n", + "\n", + "The first step to creating a `Field` (or `VectorField`) is to define the Grid. For an unstructured grid, we will create a `Parcels.UXGrid` object, which requires a `UxArray.grid` and the vertical layer interface positions. Setting the `mesh` to `\"spherical\"` is a legacy feature from Parcels v3 that enables unit conversion from `m/s` to `deg/s`; this is needed in this case since the grid locations are defined in units of degrees." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from parcels.uxgrid import UxGrid\n", + "\n", + "grid = UxGrid(grid=ds.uxgrid, z=ds.coords[\"nz\"], mesh=\"spherical\")\n", + "# You can view the uxgrid object with the following command:\n", + "grid.uxgrid" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the `UxGrid` object defined, we can now define our `Field` objects, provided we can align a suitable interpolator what that `Field`. Aligning an interpolator requires you to be cognizant of the location that each `DataArray` is associated with. Since Parcels v4 provides flexibility to customize your interpolation scheme, care must be taken when pairing an interpolation scheme with a field. On unstructured grids, data is typically registered to \"nodes\", \"faces\", or \"edges\". For example, with FESOM2 data, `u` and `v` velocity components are face registered while the vertical velocity component `w` is node registered.\n", + "\n", + "In Parcels, grid searching is conducted with respect to the faces. In other words, when a grid index `ei` is provided to an interpolation method, this refers the face index `fi` at vertical layer `zi` (when unraveled). Within the interpolation method, the `field.grid.uxgrid.face_node_connectivity` attribute can be used to obtain the node indices that surround the face. Using these connectivity tables is necessary for properly indexing node registered data.\n", + "\n", + "For the example Stommel gyre dataset in this tutorial, the `u` and `v` velocity components are face registered (similar to FESOM). Parcels includes a nearest neighbor interpolator for face registered unstructured grid data through `Parcels.application_kernels.interpolation.UXPiecewiseConstantFace`. Below, we create the `Field`s `U` and `V` and associate them with the `UxGrid` we created previously and this interpolation method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from parcels.application_kernels.interpolation import UXPiecewiseConstantFace\n", + "from parcels.field import Field\n", + "\n", + "U = Field(\n", + " name=\"U\",\n", + " data=ds.U,\n", + " grid=grid,\n", + " interp_method=UXPiecewiseConstantFace,\n", + ")\n", + "V = Field(\n", + " name=\"V\",\n", + " data=ds.V,\n", + " grid=grid,\n", + " interp_method=UXPiecewiseConstantFace,\n", + ")\n", + "P = Field(\n", + " name=\"P\",\n", + " data=ds.p,\n", + " grid=grid,\n", + " interp_method=UXPiecewiseConstantFace,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we've defined the `U` and `V` fields, we can define a `VectorField`. The `VectorField` is created in a similar manner, except that it is initialized with `Field` objects. You can optionally define an `interp_method` on the `VectorField`. When this is done, the `VectorField.interp_method` is used for interpolation; otherwise, evaluation of the `VectorField` is done component-wise using the `interp_method` associated with each component separately." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from parcels.field import VectorField\n", + "\n", + "UV = VectorField(name=\"UV\", U=U, V=V)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining the FieldSet\n", + "With all of the fields defined, that we want for this simulation, we can now create the `FieldSet`. As the name suggests, the `FieldSet` is the set of all `Field`s that will be used for a particle simulation. A `FieldSet` is initialized with a list of `Field` objects" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from parcels.fieldset import FieldSet\n", + "\n", + "fieldset = FieldSet([UV, UV.U, UV.V, P])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setting your own custom interpolator\n", + "You may be wondering how to set your own custom interpolator. In Parcels v4, this is as simple as defining a function that matches a specific API. The API you need to match is defined in the `field.py` module in the `Field._interp_template` and `VectorField._interp_template`. Specifically,\n", + "\n", + "```python\n", + "def _interp_template(\n", + " self, # Field or VectorField\n", + " ti: int, # Time index\n", + " ei: int, # Flat grid index\n", + " bcoords: np.ndarray, # Barycentric coordinates relative to the cell vertices\n", + " tau: np.float32 | np.float64, # Time interpolation weight\n", + " t: np.float32 | np.float64, # Current simulation time\n", + " z: np.float32 | np.float64, # Current particle depth\n", + " y: np.float32 | np.float64, # Current particle y-position\n", + " x: np.float32 | np.float64, # Current particle x-position\n", + " ) -> np.float32 | np.float64 # For `Field`, returns a float value.\n", + "```\n", + "\n", + "So long as your function matches this API, you can define such a function and set the `Field.interp_method` to that function.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "\n", + "def my_custom_interpolator(\n", + " self,\n", + " ti: int,\n", + " ei: int,\n", + " bcoords: np.ndarray,\n", + " tau: np.float32 | np.float64,\n", + " t: np.float32 | np.float64,\n", + " z: np.float32 | np.float64,\n", + " y: np.float32 | np.float64,\n", + " x: np.float32 | np.float64,\n", + ") -> np.float32 | np.float64:\n", + " \"\"\"Custom interpolation method for the P field.\n", + " This method interpolates the value at a face by averaging the values of its neighboring faces.\n", + " While this may be nonsense, it demonstrates how to create a custom interpolation method.\"\"\"\n", + "\n", + " zi, fi = self.grid.unravel_index(ei)\n", + " neighbors = self.grid.uxgrid.face_face_connectivity[fi]\n", + " f_at_neighbors = self.data.values[ti, zi, neighbors]\n", + " # Interpolate using the average of the neighboring face values\n", + " if len(f_at_neighbors) > 0:\n", + " return np.mean(f_at_neighbors)\n", + " # If no neighbors, return the value at the face itself\n", + " else:\n", + " return self.data.values[ti, zi, fi]\n", + "\n", + "\n", + "# Assign the custom interpolator to the P field\n", + "P.interp_method = my_custom_interpolator" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Understanding the context inside an interpolator method\n", + "Providing the `Field` object as an input to an interpolator exposes you to a ton of useful information and methods for building complex interpolators. Particularly, the `Field.grid` attribute gives you access to connectivity tables and metric terms that you may find useful for constructing an interpolator. For context, the `Parcels.UXGrid` class is built on top of the `Parcels.BaseGrid` class (much likes it's structured grid `Parcels.XGrid` counterpart). The `Parcels.UXGrid` class combines a `UXArray.grid` object alongside the vertical layer interfaces, which provides sufficient information to define the API that the `BaseGrid` class demands. This includes\n", + "\n", + "* `search` - A method for returning a flat grid index `ei` for a position `(x,y,z)`\n", + "* `ravel_index` - A method for converting a face index `fi` and a vertical layer index `zi` into a single flat grid index `ei`\n", + "* `unravel_index` - A method for converted a single flat grid index `ei` into a face index `fi` and a vertical layer index `zi`\n", + "\n", + "The `ravel/unravel` methods are a necessity for most interpolators. For unstructured grids, the `Field.grid.uxgrid` attribute give you access to all of the attributes associated with a `UxArray.grid` object (See https://uxarray.readthedocs.io/en/latest/api.html#grid for more details.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Running the forward integration" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from parcels import AdvectionEE, AdvectionRK4" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import datetime, timedelta\n", + "\n", + "from parcels import Particle, ParticleSet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "num_particles = 2\n", + "\n", + "pset = ParticleSet(\n", + " fieldset,\n", + " lon=np.random.uniform(3.0, 57.0, size=(num_particles,)),\n", + " lat=np.random.uniform(3.0, 57.0, size=(num_particles,)),\n", + " depth=50.0 * np.ones(shape=(num_particles,)),\n", + " time=0.0\n", + " * np.ones(\n", + " shape=(num_particles,)\n", + " ), # important otherwise initialization appears to take forever?\n", + " pclass=Particle,\n", + ")\n", + "print(len(pset), \"particles created\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from tqdm import tqdm\n", + "\n", + "from parcels import FieldOutOfBoundError\n", + "\n", + "# for capturing positions\n", + "_lon = [pset.lon]\n", + "_lat = [pset.lat]\n", + "\n", + "# output / sub-experiment time stepping\n", + "output_dt = timedelta(minutes=10)\n", + "endtime = output_dt\n", + "\n", + "# run 40 x 6 hours and capture positions after each iteration\n", + "for num_output in tqdm(range(40)):\n", + " # if one particle errors, let's top all of them\n", + " try:\n", + " pset.execute(\n", + " endtime=endtime,\n", + " dt=timedelta(seconds=60),\n", + " pyfunc=AdvectionEE,\n", + " verbose_progress=False,\n", + " )\n", + " except FieldOutOfBoundError:\n", + " print(\"out of bounds, stopping (all particles)\")\n", + " break\n", + "\n", + " # on to the next sub experiment\n", + " endtime += output_dt\n", + " _lon.append(pset.lon)\n", + " _lat.append(pset.lat)\n", + "\n", + "# merge captured positions\n", + "lon = np.vstack(_lon)\n", + "lat = np.vstack(_lat)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot as plt\n", + "\n", + "plt.plot(lon, lat, \"-\");" + ] + } + ], + "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.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/examples/tutorial_timestamps.ipynb b/docs/examples/tutorial_timestamps.ipynb deleted file mode 100644 index 28f3cc709..000000000 --- a/docs/examples/tutorial_timestamps.ipynb +++ /dev/null @@ -1,196 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# TimeStamps and calendars\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import warnings\n", - "from glob import glob\n", - "\n", - "import numpy as np\n", - "\n", - "import parcels" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Some NetCDF files, such as for example those from the [World Ocean Atlas](https://www.nodc.noaa.gov/OC5/woa18/), have time calendars that can't be parsed by `xarray`. These result in a `ValueError: unable to decode time units`, for example when the calendar is in 'months since' a particular date.\n", - "\n", - "In these cases, a workaround in Parcels is to use the `timestamps` argument in `Field` (or `FieldSet`) creation. Here, we show how this works for example temperature data from the World Ocean Atlas in the Pacific Ocean\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The following cell raises an error, since the calendar of the World Ocean Atlas data is in \"months since 1955-01-01 00:00:00\"\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "tags": [ - "raises-exception" - ] - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\asche\\Desktop\\po-code\\parcels_dev\\parcels\\parcels\\field.py:502: FileWarning: File C:\\Users\\asche\\AppData\\Local\\parcels\\parcels\\Cache\\WOA_data\\woa18_decav_t01_04.nc could not be decoded properly by xarray (version 2024.6.0). It will be opened with no decoding. Filling values might be wrongly parsed.\n", - " with _grid_fb_class(\n", - "C:\\Users\\asche\\Desktop\\po-code\\parcels_dev\\parcels\\parcels\\field.py:330: FileWarning: File C:\\Users\\asche\\AppData\\Local\\parcels\\parcels\\Cache\\WOA_data\\woa18_decav_t01_04.nc could not be decoded properly by xarray (version 2024.6.0). It will be opened with no decoding. Filling values might be wrongly parsed.\n", - " with _grid_fb_class(\n" - ] - }, - { - "ename": "RuntimeError", - "evalue": "Xarray could not convert the calendar. If you're using from_netcdf, try using the timestamps keyword in the construction of your Field. See also the tutorial at https://docs.oceanparcels.org/en/latest/examples/tutorial_timestamps.html", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", - "File \u001b[1;32mc:\\Users\\asche\\miniconda3\\envs\\parcels_dev\\Lib\\site-packages\\xarray\\coding\\times.py:322\u001b[0m, in \u001b[0;36mdecode_cf_datetime\u001b[1;34m(num_dates, units, calendar, use_cftime)\u001b[0m\n\u001b[0;32m 321\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 322\u001b[0m dates \u001b[38;5;241m=\u001b[39m \u001b[43m_decode_datetime_with_pandas\u001b[49m\u001b[43m(\u001b[49m\u001b[43mflat_num_dates\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43munits\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcalendar\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 323\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mKeyError\u001b[39;00m, OutOfBoundsDatetime, OutOfBoundsTimedelta, \u001b[38;5;167;01mOverflowError\u001b[39;00m):\n", - "File \u001b[1;32mc:\\Users\\asche\\miniconda3\\envs\\parcels_dev\\Lib\\site-packages\\xarray\\coding\\times.py:256\u001b[0m, in \u001b[0;36m_decode_datetime_with_pandas\u001b[1;34m(flat_num_dates, units, calendar)\u001b[0m\n\u001b[0;32m 255\u001b[0m time_units, ref_date \u001b[38;5;241m=\u001b[39m _unpack_netcdf_time_units(units)\n\u001b[1;32m--> 256\u001b[0m time_units \u001b[38;5;241m=\u001b[39m \u001b[43m_netcdf_to_numpy_timeunit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtime_units\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 257\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m 258\u001b[0m \u001b[38;5;66;03m# TODO: the strict enforcement of nanosecond precision Timestamps can be\u001b[39;00m\n\u001b[0;32m 259\u001b[0m \u001b[38;5;66;03m# relaxed when addressing GitHub issue #7493.\u001b[39;00m\n", - "File \u001b[1;32mc:\\Users\\asche\\miniconda3\\envs\\parcels_dev\\Lib\\site-packages\\xarray\\coding\\times.py:118\u001b[0m, in \u001b[0;36m_netcdf_to_numpy_timeunit\u001b[1;34m(units)\u001b[0m\n\u001b[0;32m 117\u001b[0m units \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00munits\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124ms\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m--> 118\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m{\u001b[49m\n\u001b[0;32m 119\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mnanoseconds\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mns\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 120\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmicroseconds\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mus\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 121\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmilliseconds\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mms\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 122\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mseconds\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43ms\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 123\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mminutes\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mm\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 124\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mhours\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mh\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 125\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdays\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mD\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 126\u001b[0m \u001b[43m\u001b[49m\u001b[43m}\u001b[49m\u001b[43m[\u001b[49m\u001b[43munits\u001b[49m\u001b[43m]\u001b[49m\n", - "\u001b[1;31mKeyError\u001b[0m: 'months'", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "File \u001b[1;32mc:\\Users\\asche\\miniconda3\\envs\\parcels_dev\\Lib\\site-packages\\xarray\\coding\\times.py:216\u001b[0m, in \u001b[0;36m_decode_cf_datetime_dtype\u001b[1;34m(data, units, calendar, use_cftime)\u001b[0m\n\u001b[0;32m 215\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 216\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mdecode_cf_datetime\u001b[49m\u001b[43m(\u001b[49m\u001b[43mexample_value\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43munits\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcalendar\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43muse_cftime\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 217\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", - "File \u001b[1;32mc:\\Users\\asche\\miniconda3\\envs\\parcels_dev\\Lib\\site-packages\\xarray\\coding\\times.py:324\u001b[0m, in \u001b[0;36mdecode_cf_datetime\u001b[1;34m(num_dates, units, calendar, use_cftime)\u001b[0m\n\u001b[0;32m 323\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mKeyError\u001b[39;00m, OutOfBoundsDatetime, OutOfBoundsTimedelta, \u001b[38;5;167;01mOverflowError\u001b[39;00m):\n\u001b[1;32m--> 324\u001b[0m dates \u001b[38;5;241m=\u001b[39m \u001b[43m_decode_datetime_with_cftime\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 325\u001b[0m \u001b[43m \u001b[49m\u001b[43mflat_num_dates\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mastype\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mfloat\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43munits\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcalendar\u001b[49m\n\u001b[0;32m 326\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 328\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[0;32m 329\u001b[0m dates[np\u001b[38;5;241m.\u001b[39mnanargmin(num_dates)]\u001b[38;5;241m.\u001b[39myear \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m1678\u001b[39m\n\u001b[0;32m 330\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m dates[np\u001b[38;5;241m.\u001b[39mnanargmax(num_dates)]\u001b[38;5;241m.\u001b[39myear \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2262\u001b[39m\n\u001b[0;32m 331\u001b[0m ):\n", - "File \u001b[1;32mc:\\Users\\asche\\miniconda3\\envs\\parcels_dev\\Lib\\site-packages\\xarray\\coding\\times.py:240\u001b[0m, in \u001b[0;36m_decode_datetime_with_cftime\u001b[1;34m(num_dates, units, calendar)\u001b[0m\n\u001b[0;32m 238\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m num_dates\u001b[38;5;241m.\u001b[39msize \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m 239\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m np\u001b[38;5;241m.\u001b[39masarray(\n\u001b[1;32m--> 240\u001b[0m \u001b[43mcftime\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum2date\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnum_dates\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43munits\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcalendar\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43monly_use_cftime_datetimes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[0;32m 241\u001b[0m )\n\u001b[0;32m 242\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "File \u001b[1;32msrc\\\\cftime\\\\_cftime.pyx:587\u001b[0m, in \u001b[0;36mcftime._cftime.num2date\u001b[1;34m()\u001b[0m\n", - "File \u001b[1;32msrc\\\\cftime\\\\_cftime.pyx:101\u001b[0m, in \u001b[0;36mcftime._cftime._dateparse\u001b[1;34m()\u001b[0m\n", - "\u001b[1;31mValueError\u001b[0m: 'months since' units only allowed for '360_day' calendar", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "File \u001b[1;32mc:\\Users\\asche\\miniconda3\\envs\\parcels_dev\\Lib\\site-packages\\xarray\\conventions.py:440\u001b[0m, in \u001b[0;36mdecode_cf_variables\u001b[1;34m(variables, attributes, concat_characters, mask_and_scale, decode_times, decode_coords, drop_variables, use_cftime, decode_timedelta)\u001b[0m\n\u001b[0;32m 439\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 440\u001b[0m new_vars[k] \u001b[38;5;241m=\u001b[39m \u001b[43mdecode_cf_variable\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 441\u001b[0m \u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 442\u001b[0m \u001b[43m \u001b[49m\u001b[43mv\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 443\u001b[0m \u001b[43m \u001b[49m\u001b[43mconcat_characters\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconcat_characters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 444\u001b[0m \u001b[43m \u001b[49m\u001b[43mmask_and_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmask_and_scale\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 445\u001b[0m \u001b[43m \u001b[49m\u001b[43mdecode_times\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdecode_times\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 446\u001b[0m \u001b[43m \u001b[49m\u001b[43mstack_char_dim\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstack_char_dim\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 447\u001b[0m \u001b[43m \u001b[49m\u001b[43muse_cftime\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cftime\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 448\u001b[0m \u001b[43m \u001b[49m\u001b[43mdecode_timedelta\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdecode_timedelta\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 449\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 450\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", - "File \u001b[1;32mc:\\Users\\asche\\miniconda3\\envs\\parcels_dev\\Lib\\site-packages\\xarray\\conventions.py:291\u001b[0m, in \u001b[0;36mdecode_cf_variable\u001b[1;34m(name, var, concat_characters, mask_and_scale, decode_times, decode_endianness, stack_char_dim, use_cftime, decode_timedelta)\u001b[0m\n\u001b[0;32m 290\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m decode_times:\n\u001b[1;32m--> 291\u001b[0m var \u001b[38;5;241m=\u001b[39m \u001b[43mtimes\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mCFDatetimeCoder\u001b[49m\u001b[43m(\u001b[49m\u001b[43muse_cftime\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cftime\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecode\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvar\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 293\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m decode_endianness \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m var\u001b[38;5;241m.\u001b[39mdtype\u001b[38;5;241m.\u001b[39misnative:\n", - "File \u001b[1;32mc:\\Users\\asche\\miniconda3\\envs\\parcels_dev\\Lib\\site-packages\\xarray\\coding\\times.py:987\u001b[0m, in \u001b[0;36mCFDatetimeCoder.decode\u001b[1;34m(self, variable, name)\u001b[0m\n\u001b[0;32m 986\u001b[0m calendar \u001b[38;5;241m=\u001b[39m pop_to(attrs, encoding, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcalendar\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m--> 987\u001b[0m dtype \u001b[38;5;241m=\u001b[39m \u001b[43m_decode_cf_datetime_dtype\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43munits\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcalendar\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43muse_cftime\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 988\u001b[0m transform \u001b[38;5;241m=\u001b[39m partial(\n\u001b[0;32m 989\u001b[0m decode_cf_datetime,\n\u001b[0;32m 990\u001b[0m units\u001b[38;5;241m=\u001b[39munits,\n\u001b[0;32m 991\u001b[0m calendar\u001b[38;5;241m=\u001b[39mcalendar,\n\u001b[0;32m 992\u001b[0m use_cftime\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39muse_cftime,\n\u001b[0;32m 993\u001b[0m )\n", - "File \u001b[1;32mc:\\Users\\asche\\miniconda3\\envs\\parcels_dev\\Lib\\site-packages\\xarray\\coding\\times.py:226\u001b[0m, in \u001b[0;36m_decode_cf_datetime_dtype\u001b[1;34m(data, units, calendar, use_cftime)\u001b[0m\n\u001b[0;32m 221\u001b[0m msg \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m 222\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124munable to decode time units \u001b[39m\u001b[38;5;132;01m{\u001b[39;00munits\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m with \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mcalendar_msg\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m. Try \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 223\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mopening your dataset with decode_times=False or installing cftime \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 224\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mif it is not installed.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 225\u001b[0m )\n\u001b[1;32m--> 226\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(msg)\n\u001b[0;32m 227\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "\u001b[1;31mValueError\u001b[0m: unable to decode time units 'months since 1955-01-01 00:00:00' with 'the default calendar'. Try opening your dataset with decode_times=False or installing cftime if it is not installed.", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "File \u001b[1;32m~\\Desktop\\po-code\\parcels_dev\\parcels\\parcels\\tools\\converters.py:281\u001b[0m, in \u001b[0;36mconvert_xarray_time_units\u001b[1;34m(ds, time)\u001b[0m\n\u001b[0;32m 280\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 281\u001b[0m da2 \u001b[38;5;241m=\u001b[39m \u001b[43mxr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecode_cf\u001b[49m\u001b[43m(\u001b[49m\u001b[43mda2\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 282\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m:\n", - "File \u001b[1;32mc:\\Users\\asche\\miniconda3\\envs\\parcels_dev\\Lib\\site-packages\\xarray\\conventions.py:581\u001b[0m, in \u001b[0;36mdecode_cf\u001b[1;34m(obj, concat_characters, mask_and_scale, decode_times, decode_coords, drop_variables, use_cftime, decode_timedelta)\u001b[0m\n\u001b[0;32m 579\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcan only decode Dataset or DataStore objects\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m--> 581\u001b[0m \u001b[38;5;28mvars\u001b[39m, attrs, coord_names \u001b[38;5;241m=\u001b[39m \u001b[43mdecode_cf_variables\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 582\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mvars\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 583\u001b[0m \u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 584\u001b[0m \u001b[43m \u001b[49m\u001b[43mconcat_characters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 585\u001b[0m \u001b[43m \u001b[49m\u001b[43mmask_and_scale\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 586\u001b[0m \u001b[43m \u001b[49m\u001b[43mdecode_times\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 587\u001b[0m \u001b[43m \u001b[49m\u001b[43mdecode_coords\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 588\u001b[0m \u001b[43m \u001b[49m\u001b[43mdrop_variables\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdrop_variables\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 589\u001b[0m \u001b[43m \u001b[49m\u001b[43muse_cftime\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cftime\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 590\u001b[0m \u001b[43m \u001b[49m\u001b[43mdecode_timedelta\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdecode_timedelta\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 591\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 592\u001b[0m ds \u001b[38;5;241m=\u001b[39m Dataset(\u001b[38;5;28mvars\u001b[39m, attrs\u001b[38;5;241m=\u001b[39mattrs)\n", - "File \u001b[1;32mc:\\Users\\asche\\miniconda3\\envs\\parcels_dev\\Lib\\site-packages\\xarray\\conventions.py:451\u001b[0m, in \u001b[0;36mdecode_cf_variables\u001b[1;34m(variables, attributes, concat_characters, mask_and_scale, decode_times, decode_coords, drop_variables, use_cftime, decode_timedelta)\u001b[0m\n\u001b[0;32m 450\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m--> 451\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;28mtype\u001b[39m(e)(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFailed to decode variable \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mk\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00me\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[0;32m 452\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m decode_coords \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;28;01mTrue\u001b[39;00m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcoordinates\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mall\u001b[39m\u001b[38;5;124m\"\u001b[39m]:\n", - "\u001b[1;31mValueError\u001b[0m: Failed to decode variable 'time': unable to decode time units 'months since 1955-01-01 00:00:00' with 'the default calendar'. Try opening your dataset with decode_times=False or installing cftime if it is not installed.", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[1;31mRuntimeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[2], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m example_dataset_folder \u001b[38;5;241m=\u001b[39m parcels\u001b[38;5;241m.\u001b[39mdownload_example_dataset(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWOA_data\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m----> 2\u001b[0m tempfield \u001b[38;5;241m=\u001b[39m \u001b[43mparcels\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mField\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_netcdf\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mglob\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43mf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mexample_dataset_folder\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m/woa18_decav_*_04.nc\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mt_an\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlon\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlon\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlat\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlat\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtime\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtime\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 6\u001b[0m \u001b[43m)\u001b[49m\n", - "File \u001b[1;32m~\\Desktop\\po-code\\parcels_dev\\parcels\\parcels\\field.py:540\u001b[0m, in \u001b[0;36mField.from_netcdf\u001b[1;34m(cls, filenames, variable, dimensions, indices, grid, mesh, timestamps, allow_time_extrapolation, time_periodic, deferred_load, **kwargs)\u001b[0m\n\u001b[0;32m 535\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMultiple files given but no time dimension specified\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 537\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m grid \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 538\u001b[0m \u001b[38;5;66;03m# Concatenate time variable to determine overall dimension\u001b[39;00m\n\u001b[0;32m 539\u001b[0m \u001b[38;5;66;03m# across multiple files\u001b[39;00m\n\u001b[1;32m--> 540\u001b[0m time, time_origin, timeslices, dataFiles \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcollect_timeslices\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 541\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimestamps\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata_filenames\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_grid_fb_class\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdimensions\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindices\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnetcdf_engine\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnetcdf_decodewarning\u001b[49m\n\u001b[0;32m 542\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 543\u001b[0m grid \u001b[38;5;241m=\u001b[39m Grid\u001b[38;5;241m.\u001b[39mcreate_grid(lon, lat, depth, time, time_origin\u001b[38;5;241m=\u001b[39mtime_origin, mesh\u001b[38;5;241m=\u001b[39mmesh)\n\u001b[0;32m 544\u001b[0m grid\u001b[38;5;241m.\u001b[39mtimeslices \u001b[38;5;241m=\u001b[39m timeslices\n", - "File \u001b[1;32m~\\Desktop\\po-code\\parcels_dev\\parcels\\parcels\\field.py:333\u001b[0m, in \u001b[0;36mField.collect_timeslices\u001b[1;34m(timestamps, data_filenames, _grid_fb_class, dimensions, indices, netcdf_engine, netcdf_decodewarning)\u001b[0m\n\u001b[0;32m 329\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m fname \u001b[38;5;129;01min\u001b[39;00m data_filenames:\n\u001b[0;32m 330\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m _grid_fb_class(\n\u001b[0;32m 331\u001b[0m fname, dimensions, indices, netcdf_engine\u001b[38;5;241m=\u001b[39mnetcdf_engine, netcdf_decodewarning\u001b[38;5;241m=\u001b[39mnetcdf_decodewarning\n\u001b[0;32m 332\u001b[0m ) \u001b[38;5;28;01mas\u001b[39;00m filebuffer:\n\u001b[1;32m--> 333\u001b[0m ftime \u001b[38;5;241m=\u001b[39m \u001b[43mfilebuffer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtime\u001b[49m\n\u001b[0;32m 334\u001b[0m timeslices\u001b[38;5;241m.\u001b[39mappend(ftime)\n\u001b[0;32m 335\u001b[0m dataFiles\u001b[38;5;241m.\u001b[39mappend([fname] \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mlen\u001b[39m(ftime))\n", - "File \u001b[1;32m~\\Desktop\\po-code\\parcels_dev\\parcels\\parcels\\fieldfilebuffer.py:221\u001b[0m, in \u001b[0;36mNetcdfFileBuffer.time\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 219\u001b[0m \u001b[38;5;129m@property\u001b[39m\n\u001b[0;32m 220\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtime\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m--> 221\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtime_access\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32m~\\Desktop\\po-code\\parcels_dev\\parcels\\parcels\\fieldfilebuffer.py:231\u001b[0m, in \u001b[0;36mNetcdfFileBuffer.time_access\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 228\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m np\u001b[38;5;241m.\u001b[39marray([\u001b[38;5;28;01mNone\u001b[39;00m])\n\u001b[0;32m 230\u001b[0m time_da \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdataset[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdimensions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtime\u001b[39m\u001b[38;5;124m\"\u001b[39m]]\n\u001b[1;32m--> 231\u001b[0m \u001b[43mconvert_xarray_time_units\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtime_da\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdimensions\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtime\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 232\u001b[0m time \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m 233\u001b[0m np\u001b[38;5;241m.\u001b[39marray([time_da[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdimensions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtime\u001b[39m\u001b[38;5;124m\"\u001b[39m]]\u001b[38;5;241m.\u001b[39mdata])\n\u001b[0;32m 234\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(time_da\u001b[38;5;241m.\u001b[39mshape) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[0;32m 235\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m np\u001b[38;5;241m.\u001b[39marray(time_da[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdimensions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtime\u001b[39m\u001b[38;5;124m\"\u001b[39m]])\n\u001b[0;32m 236\u001b[0m )\n\u001b[0;32m 237\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(time[\u001b[38;5;241m0\u001b[39m], datetime\u001b[38;5;241m.\u001b[39mdatetime):\n", - "File \u001b[1;32m~\\Desktop\\po-code\\parcels_dev\\parcels\\parcels\\tools\\converters.py:283\u001b[0m, in \u001b[0;36mconvert_xarray_time_units\u001b[1;34m(ds, time)\u001b[0m\n\u001b[0;32m 281\u001b[0m da2 \u001b[38;5;241m=\u001b[39m xr\u001b[38;5;241m.\u001b[39mdecode_cf(da2)\n\u001b[0;32m 282\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m:\n\u001b[1;32m--> 283\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[0;32m 284\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mXarray could not convert the calendar. If you\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mre using from_netcdf, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 285\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtry using the timestamps keyword in the construction of your Field. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 286\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSee also the tutorial at https://docs.oceanparcels.org/en/latest/examples/tutorial_timestamps.html\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 287\u001b[0m )\n\u001b[0;32m 288\u001b[0m ds[time] \u001b[38;5;241m=\u001b[39m da2[time]\n", - "\u001b[1;31mRuntimeError\u001b[0m: Xarray could not convert the calendar. If you're using from_netcdf, try using the timestamps keyword in the construction of your Field. See also the tutorial at https://docs.oceanparcels.org/en/latest/examples/tutorial_timestamps.html" - ] - } - ], - "source": [ - "example_dataset_folder = parcels.download_example_dataset(\"WOA_data\")\n", - "tempfield = parcels.Field.from_netcdf(\n", - " glob(f\"{example_dataset_folder}/woa18_decav_*_04.nc\"),\n", - " \"t_an\",\n", - " {\"lon\": \"lon\", \"lat\": \"lat\", \"time\": \"time\"},\n", - ")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "However, we can create our own numpy array of timestamps associated with each of the 12 snapshots in the netcdf file\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "timestamps = np.expand_dims(\n", - " np.array([np.datetime64(f\"2001-{m:02d}-15\") for m in range(1, 13)]), axis=1\n", - ")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And then we can add the `timestamps` as an extra argument\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "with warnings.catch_warnings():\n", - " warnings.simplefilter(\"ignore\", parcels.FileWarning)\n", - " tempfield = parcels.Field.from_netcdf(\n", - " glob(f\"{example_dataset_folder}/woa18_decav_*_04.nc\"),\n", - " \"t_an\",\n", - " {\"lon\": \"lon\", \"lat\": \"lat\", \"time\": \"time\"},\n", - " timestamps=timestamps,\n", - " )" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note, by the way, that adding the `time_periodic` argument to `Field.from_netcdf()` will also mean that the climatology can be cycled for multiple years.\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Furthermore, note that we used `warnings.catch_warnings()` with `warnings.simplefilter(\"ignore\", parcels.FileWarning)` to wrap the `FieldSet.from_nemo()` call above. This is to silence an expected warning because the time dimension in the `coordinates.nc` file can't be decoded by `xarray`." - ] - } - ], - "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.12.4" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/examples/tutorial_timevaryingdepthdimensions.ipynb b/docs/examples/tutorial_timevaryingdepthdimensions.ipynb index 8f89b89be..7185cdac8 100644 --- a/docs/examples/tutorial_timevaryingdepthdimensions.ipynb +++ b/docs/examples/tutorial_timevaryingdepthdimensions.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -84,17 +84,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WARNING: Flipping lat data from North-South to South-North. Note that this may lead to wrong sign for meridional velocity, so tread very carefully\n" - ] - } - ], + "outputs": [], "source": [ "fieldset = parcels.FieldSet.from_netcdf(\n", " filenames, variables, dimensions, mesh=\"flat\", allow_time_extrapolation=True\n", @@ -113,20 +105,11 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Output files are stored in SwashParticles.zarr.\n", - "100%|██████████| 0.25/0.25 [00:00<00:00, 1.61it/s] \n" - ] - } - ], + "outputs": [], "source": [ - "pset = parcels.ParticleSet(fieldset, parcels.JITParticle, lon=9.5, lat=12.5, depth=-0.1)\n", + "pset = parcels.ParticleSet(fieldset, parcels.Particle, lon=9.5, lat=12.5, depth=-0.1)\n", "\n", "pfile = pset.ParticleFile(\"SwashParticles\", outputdt=timedelta(seconds=0.05))\n", "\n", @@ -135,20 +118,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAGsCAYAAADXKAMrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABS8ElEQVR4nO3deVhU5/k+8Hv2AYRBFllUBlAD4g64QGNME4OaJtGYBExSql1STZsYzCYurek3bcRsan9xSazZ2ia4EMzWGEmjxAWIGMAFFwTcQQRh2HSGmXl/f1gnTkBklOGw3J/rmj94z3Pe85w5zjW3Z86ckQkhBIiIiIgIACCXugEiIiKizoThiIiIiOgaDEdERERE12A4IiIiIroGwxERERHRNRiOiIiIiK7BcERERER0DYYjIiIiomswHBERERFdg+GIiIiI6BoMRx3knXfewZ133gkPDw/IZDLU1NTccJ2lS5di9OjRcHd3R58+fTBt2jQcPXr0uvWzZ8+GTCbDihUr7MaLi4vx4IMPwtfXFx4eHoiPj8f58+ftan744Qfcc8898PT0hLe3N37/+9+jvr7eoX387rvvcP/99yMwMBAymQxbtmxxaH0iIqLOgOGoHd155514//33W1zW2NiIyZMnY+HChW2eLzMzE3/84x+RnZ2NjIwMmM1mxMXFoaGhoVntli1bkJOTg8DAQLvxhoYGxMXFQSaT4dtvv8Xu3bthMplw//33w2q1AgDOnTuHiRMnYuDAgcjJycHWrVtx6NAhzJo1q829Xt3WiBEj8NZbbzm0HhERUaciqN1MmDBBvPfee63WbN++XQAQ1dXVDs9fUVEhAIjMzEy78TNnzoi+ffuKgwcPCr1eL5YvX25b9vXXXwu5XC4MBoNt7OLFiwKAyMjIEEII8fbbb4s+ffoIi8Viq8nLyxMARFFRkW3s0KFDYsqUKcLNzU306dNH/PKXvxQXLlxosVcAIj093eF9JCIikhrPHHUhBoMBAODl5WUbs1qtSExMxAsvvIAhQ4Y0W8doNEImk0Gj0djGtFot5HI5du3aZatRq9WQy3/85+Di4gIAtpqysjJMmDABI0eORG5uLrZu3Yrz588jPj6+/XeUiIhIQgxHXYQQAs8++yxuv/12DB061Da+bNkyKJVKzJ07t8X1xo0bBzc3N8yfPx+NjY1oaGjACy+8AKvVirKyMgDAXXfdhfLycrz22mswmUyorq62ffx3tWbNmjWIjIzEK6+8gvDwcIwaNQrvvvsutm/fjmPHjjl574mIiDoOw9EteOWVV9CrVy/bY+fOnZgzZ06zsfbw1FNPYf/+/fj4449tY/v27cPKlSvx/vvvQyaTtbier68vNm3ahM8//xy9evWCTqeDwWBAZGQkFAoFAGDIkCH44IMP8MYbb8DV1RX+/v4IDQ2Fn5+frWbfvn3Yvn273b6Fh4cDuHLBNxERUXehlLqBrmzOnDl2Hys9/vjjeOihhzB9+nTbWN++fW95O08//TQ+++wzfPfdd+jXr59tfOfOnaioqEBQUJBtzGKx4LnnnsOKFStw4sQJAEBcXByKi4tRWVkJpVIJT09P+Pv7IyQkxLbeY489hsceewznz5+Hm5sbZDIZ3nzzTVuN1WrF/fffj2XLljXrLyAg4Jb3kYiIqLNgOLoFXl5edtf/uLi4oE+fPhg4cGC7zC+EwNNPP4309HTs2LHDLswAQGJiIiZOnGg3NmnSJCQmJuLXv/51s/l8fHwAAN9++y0qKirwwAMPNKvx8/MDALz77rvQarW45557AACRkZFIS0tDcHAwlEr+syEiou6L73IdpLy8HOXl5Th+/DgA4MCBA3B3d0dQUJAtYN1999148MEH8dRTTwEA/vjHP+Kjjz7Cp59+Cnd3d5SXlwMAdDodXFxc4O3tDW9vb7vtqFQq+Pv7IywszDb23nvvYfDgwfD19UVWVhaeeeYZzJs3z67mrbfeQmxsLHr16oWMjAy88MILSElJgaenp62XdevW4dFHH8ULL7wAHx8fHD9+HKmpqVi3bh0UCgXq6+tt+wcApaWlyM/Ph5eXl93ZLSIiok5N6q/LdSetfZV/yZIlAkCzx7X1er1eLFmyxPZ3S/U/XeenfvpVfiGEmD9/vvDz8xMqlUoMGjRIvPHGG8JqtdrVJCYmCi8vL6FWq8Xw4cPFhx9+2GzuY8eOiQcffFB4enoKFxcXER4eLpKSkmxzXb1NwU8fM2fObO1pIyIi6lRkQgjR8ZGMiIiIqHPit9WIiIiIrsFwRERERHQNXpDtIKvVinPnzsHd3f269xYiIiKizkUIgbq6OgQGBtr9IkRLGI4cdO7cOfTv31/qNoiIiOgmnD592u6egS1hOHKQu7s7gCtProeHh8TdEBERUVvU1taif//+tvfx1jAcOejqR2keHh4MR0RERF1MWy6J4QXZRERERNdgOCIiIiK6BsMRERER0TUYjoiIiIiuwXBEREREdA2GIyIiIqJrMBwRERERXYPhiIiIiOgaDEdERERE17ipcLR69WqEhIRAq9UiKioKO3fubLU+MzMTUVFR0Gq1CA0Nxdq1a5vVpKWlISIiAhqNBhEREUhPT7db/t133+H+++9HYGAgZDIZtmzZ0mwOIQReeuklBAYGwsXFBXfeeScOHTpkV2M0GvH000/Dx8cHbm5ueOCBB3DmzBnHnwQiIiLqlhwORxs2bEBSUhIWLVqEvLw8jB8/HlOmTMGpU6darC8tLcW9996L8ePHIy8vDwsXLsTcuXORlpZmq8nKykJCQgISExNRUFCAxMRExMfHIycnx1bT0NCAESNG4K233rpub6+++irefPNNvPXWW9i7dy/8/f1xzz33oK6uzlaTlJSE9PR0pKamYteuXaivr8d9990Hi8Xi6FPR7soMl7CnuBJlhktSt0JERNRzCQeNGTNGzJkzx24sPDxcJCcnt1j/4osvivDwcLux2bNni3Hjxtn+jo+PF5MnT7armTRpkpgxY0aLcwIQ6enpdmNWq1X4+/uLlJQU29jly5eFTqcTa9euFUIIUVNTI1QqlUhNTbXVnD17VsjlcrF169br7LE9g8EgAAiDwdCm+rZK/f6kCEn+QujnfyFCkr8Qqd+fbNf5iYiIejJH3r8dOnNkMpmwb98+xMXF2Y3HxcVhz549La6TlZXVrH7SpEnIzc1FU1NTqzXXm7MlpaWlKC8vt5tHo9FgwoQJtnn27duHpqYmu5rAwEAMHTr0utsyGo2ora21e7S3MsMlLPjkAKziyt9WASz45ADPIBEREUnAoXBUWVkJi8UCPz8/u3E/Pz+Ul5e3uE55eXmL9WazGZWVla3WXG/O623n6nrXm6e8vBxqtRq9e/du87aWLl0KnU5ne/Tv37/NPbVVaWWDLRhdZRXA0x/l4b3dpThSXgvrTwuIiIjIKZQ3s5JMJrP7WwjRbOxG9T8dd3TO9urtRjULFizAs88+a/u7tra23QNSiI8b5DI0C0i5J6uRe7IaAODlpsa4UC/EhHojZoA3Bvj2uqnnh4iIiFrnUDjy8fGBQqFodpaloqKi2Rmbq/z9/VusVyqV8Pb2brXmenNebzvAlbNDAQEBLc7j7+8Pk8mE6upqu7NHFRUViI2NbXFejUYDjUbT5j5uRoDOBUunD8PCTw7CIgTkMuDJCQPgplUiq7gKuSeqcbHBhP8cKMd/Dlx5nnzdNRgX6m0LS8HergxLRERE7cChcKRWqxEVFYWMjAw8+OCDtvGMjAxMnTq1xXViYmLw+eef241t27YN0dHRUKlUtpqMjAzMmzfPruZ6gaUlISEh8Pf3R0ZGBkaNGgXgyjVSmZmZWLZsGQAgKioKKpUKGRkZiI+PBwCUlZXh4MGDePXVV9u8LWdIGB2EO27zxYnKRgT7uCJA5wIA+MOdA2EyW7H/TA2yiquQVVKFfSercaHOiM8LzuHzgnMAAH8PLWIG/BiW+nu5Srk7REREXZbDH6s9++yzSExMRHR0NGJiYvDOO+/g1KlTmDNnDoArH0OdPXsWH374IQBgzpw5eOutt/Dss8/iiSeeQFZWFtavX4+PP/7YNuczzzyDO+64A8uWLcPUqVPx6aef4ptvvsGuXbtsNfX19Th+/Ljt79LSUuTn58PLywtBQUGQyWRISkrCK6+8gkGDBmHQoEF45ZVX4OrqisceewwAoNPp8Nvf/hbPPfccvL294eXlheeffx7Dhg3DxIkTb+4ZbEcBOhdbKLqWWilHdLAXooO98PTdg3C5yYL80z+GpfxTNSivvYz0vLNIzzsLAOjr6WIXlgI9m89LRERELbiZr8OtWrVK6PV6oVarRWRkpMjMzLQtmzlzppgwYYJd/Y4dO8SoUaOEWq0WwcHBYs2aNc3m3LRpkwgLCxMqlUqEh4eLtLQ0u+Xbt28XAJo9Zs6caauxWq1iyZIlwt/fX2g0GnHHHXeIAwcO2M1z6dIl8dRTTwkvLy/h4uIi7rvvPnHq1Kk277uzvsp/KxqNZrGr6IJ4besRMX31bjFgwZdCP/8Lu8cdr34r5m8uEFvyzojzhktSt0xERNShHHn/lgkh+DUoB9TW1kKn08FgMMDDw0PqdlrUYDQj92S17czSgTM1zS72DvV1s51VGhfqDZ9ezr2uioiISEqOvH8zHDmoK4Sjn6q73IS9Jy7awtKhc7X46VG/za+XLSyNDfFGbze1NM0SERE5AcORE3XFcPRThsYm5JRWYU9xFbJLqnCkvM5uuUwGhPt72MLSmBAv6FxUEnVLRER06xiOnKg7hKOfqqo3Iqf0xzNLxyvq7ZbLZcCQQJ3tAu/RIV7opbmpW2QRERFJguHIibpjOPqpirrLyC65EpayS6pQWtlgt1whl2FY3x/DUnRwb7iqGZaIiKjzYjhyop4Qjn6q3HAZWSWVtjNLpy/a/+abSiHDiH6etrAUqe8NrUohUbdERETNMRw5UU8MRz91prrRFpSyi6twznDZbrlaKUdkkCdiQn0QM8AbI/rroFEyLBERkXQYjpyI4cieEAKnLv4YlrKKq1BRZ7Sr0arkiNZ72W4bMLyfDiqFQ795TEREdEsYjpyI4ah1QgiUVDbYwlJOSRUq6012Na5qBUYHe9k+hhsS6AElwxIRETkRw5ETMRw5RgiBoor6K2GpuArZpVWoaWyyq3HXKDEm5MczSxEBHpDL+SO6RETUfhiOnIjh6NZYrQJHyutsH8HllFah7rLZrkbnosLY/4WlmAHeuK2PO8MSERHdEoYjJ2I4al8Wq0DhuVrbt+H2nqhGvdE+LHm5qTEu1Mt2U8oBvr0gkzEsERFR2zEcORHDkXOZLVYcOGuwnVnKPVGNS00Wuxpfdw3GhXrbwlKwtyvDEhERtYrhyIkYjjqWyWzF/jM1tgu8952shtFstavx99DaLu6OGeCN/l6uEnVLRESdFcOREzEcSetykwX5p38MS/mnamCy2Ielvp4udmEp0NNFom6JiKizYDhyIoajzuWSyYIfTlXbwlLB6RqYrfb/pPXerragFBPqjT4eWom6JSIiqTAcORHDUefWYDQj9+SPYenAmRr8JCsh1NfNFpbGhXrDp5dGmmaJiKjDMBw5EcNR11J3uQl7T1y0haVD52rx03/xt/n1soWlsSHe6O2mlqZZIiJyGoYjJ2I46toMjU3IKf3xp06OlNfZLZfJgHB/D1tYGhPiBZ2LSqJuiYiovTAcORHDUfdyscGEnJIfw1JRRb3dcrkMGBKos12vNDrEC700Som6JSKim8Vw5EQMR93bhTojsv8XlrKLq1BS2WC3XCGXYVjfH8NSdHBvuKoZloiIOjuGIydiOOpZyg2Xr4Sl/12zdOpio91ylUKGEf08bT91EhnUG1qVQqJuiYjoehiOnIjhqGc7U92I7JKL2FNcieziKpwzXLZbrlbKERnkiZhQH8QM8MaI/jpolAxLRERSYzhyIoYjukoIgVMXG21nlbKKq1BRZ7Sr0arkiNZ72W4bMLyfDiqFXKKOiYh6LoYjJ2I4ousRQqCkssEWlnJKqlBZb7KrcVUrMDrYy3bN0pBADygZloiInI7hyIkYjqithBAoqqi/EpaKq5BdWoWaxia7GneNEmNCfjyzFBHgAbmcP6JLRNTeGI6ciOGIbpbVKnCkvM72EVxOaRXqLpvtanQuKoz9X1iKGeCN2/q4MywREbUDhiMnYjii9mKxChSeq0VWSSWyiquw90Q16o32YcnLTY1xoV62m1IO8O0FmYxhiYjIUQxHTsRwRM5itlhx4KzBdmYp90Q1LjVZ7Gp83TUYF+ptC0vB3q4MS0REbcBw5EQMR9RRTGYr9p+psV3gve9kNYxmq12Nv4fWdnF3zABv9PdylahbIqLOjeHIiRiOSCqXmyzIP/1jWMo/VQOTxT4s9fV0sQtLgZ4uEnVLRNS5MBw5EcMRdRaXTBb8cKraFpYKTtfAbLV/Oeu9XW1BKSbUG308tBJ1S0QkLYYjJ2I4os6qwWhG7skfw9KBMzX4SVZCqK+bLSyNC/WGTy+NNM0SEXUwhiMnYjiirqLuchP2nrhoC0uHztXip6/22/x62cLS2BBv9HZTS9MsEZGTMRw5EcMRdVWGxibklP74UydHyuvslstkQLi/hy0sjQnxgs5FJVG3RETti+HIiRiOqLu42GBCTsmPYamoot5uuVwGDAnU2a5XGh3ihV4apUTdEhHdGoYjJ2I4ou7qQp0R2f8LS9nFVSipbLBbrpDLMKzvj2EpOrg3XNUMS0TUNTAcORHDEfUU5YbLV8LS/65ZOnWx0W65SiHDiH6etp86iQzqDa1KIVG3REStYzhyIoYj6qnOVDciu+Qi9hRXIru4CucMl+2Wq5VyRAZ5IibUBzEDvDGivw4aJcMSEXUODEdOxHBEBAghcOpio+2sUlZxFSrqjHY1WpUc0Xov220DhvfTQaWQS9QxEfV0DEdOxHBE1JwQAiWVDbawlFNShcp6k12Nm1qB6GAv2zVLQwI9oGRYIqIOwnDkRAxHRDcmhEBRRf2VsFRchezSKtQ0NtnVuGuUGBPy45mliAAPyOX8EV0icg6GIydiOCJynNUqcKS8zvYRXE5pFeoum+1qdC4qjP1fWIoZ4I3b+rgzLBFRu2E4ciKGI6JbZ7EKFJ6rRVZJJbKKq7D3RDXqjfZhyctNjXGhXrabUg7w7QWZjGGJiG4Ow5ETMRwRtT+zxYoDZw22M0u5J6pxqcliV+PrrsG4UG9bWAr2drWFpTLDJZRWNiDExw0BOhcpdoGIOjmGIydiOCJyPpPZiv1namwXeO87WQ2j2WpX4++hRcwAbyhkMnySdwZWceWu3kunD0PC6CCJOieizorhyIkYjog6ntFsQd6pH8NS/qkamCzWFmsVMhl2Jf+cZ5CIyI4j79+89z8RdXoapQLjQq98q20egMtNFuw7WY1NuaexJf+cXa1FCJyobGQ4IqKbxpuMEFGXo1Up8LOBPpg/JRwtfaHt+9Kqjm+KiLoNhiMi6rICdC5YOn0YFP+7MPtqTlr+TRHe3HYUvGqAiG4GP1Yjoi4tYXQQ7rjNFycqG6H3dsHmfWfxZsYx/P3b47hQb8Jfpw2FgvdLIiIHMBwRUZcXoHOxXWM09+5B8O6lxuItB/Hx96dQ3WDCihkjoVXxR3CJqG34sRoRdTuPj9Vj9WORUCvk2HqoHLPe+x51l5tuvCIRERiOiKibmjIsAO//ZjR6aZTILrmIGe9k40KdUeq2iKgLYDgiom4rdoAPUn8/Dj691Dh0rhYPr92DU1WNUrdFRJ0cwxERdWtD++qweU4s+nu54GRVIx5auweF52qlbouIOjGGIyLq9oJ93JA2Jxbh/u64UGdEwttZyCnhvZCIqGUMR0TUI/Tx0GLD7BiMCfZCndGMxHe/x7ZD5VK3RUSdEMMREfUYOhcVPvztGNwT4QeT2Yo5/9qHDXtPSd0WEXUyDEdE1KNoVQqseTwS8dH9YBXA/LQDWL3jOO+mTUQ2NxWOVq9ejZCQEGi1WkRFRWHnzp2t1mdmZiIqKgparRahoaFYu3Zts5q0tDRERERAo9EgIiIC6enpDm/3/PnzmDVrFgIDA+Hq6orJkyejqKjIrqa8vByJiYnw9/eHm5sbIiMjsXnz5pt4Foioq1Iq5Fj20HA8eecAAMCrW4/i5S8Ow2plQCKimwhHGzZsQFJSEhYtWoS8vDyMHz8eU6ZMwalTLZ+aLi0txb333ovx48cjLy8PCxcuxNy5c5GWlmarycrKQkJCAhITE1FQUIDExETEx8cjJyenzdsVQmDatGkoKSnBp59+iry8POj1ekycOBENDQ22eRITE3H06FF89tlnOHDgAKZPn46EhATk5eU5+lQQURcmk8kwf3I4Fv9iMADg3d2leHZjPposVok7IyLJCQeNGTNGzJkzx24sPDxcJCcnt1j/4osvivDwcLux2bNni3Hjxtn+jo+PF5MnT7armTRpkpgxY0abt3v06FEBQBw8eNC23Gw2Cy8vL7Fu3TrbmJubm/jwww/t5vHy8hL/+Mc/rrvP1zIYDAKAMBgMbaonos7vkx9OiwELvhT6+V+IX63PEQ3GJqlbIqJ25sj7t0NnjkwmE/bt24e4uDi78bi4OOzZs6fFdbKysprVT5o0Cbm5uWhqamq15uqcbdmu0Xjlzrdarda2XKFQQK1WY9euXbax22+/HRs2bMDFixdhtVqRmpoKo9GIO++8s8X+jUYjamtr7R5E1L08OKof1s2MhlYlR+axC3hsXQ6qG0xSt0VEEnEoHFVWVsJiscDPz89u3M/PD+XlLX8ltry8vMV6s9mMysrKVmuuztmW7YaHh0Ov12PBggWorq6GyWRCSkoKysvLUVZWZltnw4YNMJvN8Pb2hkajwezZs5Geno4BAwa02P/SpUuh0+lsj/79+9/oaSKiLujnYX3w79+Ng85FhfzTNXjk7Sycq7kkdVtEJIGbuiBbJpPZ/S2EaDZ2o/qfjrdlztZqVCoV0tLScOzYMXh5ecHV1RU7duzAlClToFD8+GvcixcvRnV1Nb755hvk5ubi2WefxSOPPIIDBw602PuCBQtgMBhsj9OnT193P4moa4vS98bmOTEI0GlxvKIeD63Zg+MVdVK3RUQdTOlIsY+PDxQKRbOzRBUVFc3O6lzl7+/fYr1SqYS3t3erNVfnbOt2o6KikJ+fD4PBAJPJBF9fX4wdOxbR0dEAgOLiYrz11ls4ePAghgwZAgAYMWIEdu7ciVWrVrX4LTqNRgONRnPD54aIuodBfu7Y/GQsfrU+B8UXGvDw2iy8N2s0RgX1lro1IuogDp05UqvViIqKQkZGht14RkYGYmNjW1wnJiamWf22bdsQHR0NlUrVas3VOR3drk6ng6+vL4qKipCbm4upU6cCABobr/zgpFxuv9sKhQJWK7+hQkRX9PV0waY5sRjR3xM1jU14bF0OMo9dkLotIuoojl7tnZqaKlQqlVi/fr0oLCwUSUlJws3NTZw4cUIIIURycrJITEy01ZeUlAhXV1cxb948UVhYKNavXy9UKpXYvHmzrWb37t1CoVCIlJQUcfjwYZGSkiKUSqXIzs5u83aFEGLjxo1i+/btori4WGzZskXo9Xoxffp023KTySQGDhwoxo8fL3JycsTx48fF66+/LmQymfjyyy/btP/8thpRz1F/uUkkrs8R+vlfiAELvhRb8s5I3RIR3SRH3r8dDkdCCLFq1Sqh1+uFWq0WkZGRIjMz07Zs5syZYsKECXb1O3bsEKNGjRJqtVoEBweLNWvWNJtz06ZNIiwsTKhUKhEeHi7S0tIc2q4QQqxcuVL069dPqFQqERQUJBYvXiyMRqNdzbFjx8T06dNFnz59hKurqxg+fHizr/a3huGIqGcxNlnE0x/9IPTzvxD6+V+Id3eVSN0SEd0ER96/ZULwnvmOqK2thU6ng8FggIeHh9TtEFEHsFoF/u+LQry/5wQA4I8/H4Dn48Ja/SIKEXUujrx/87fViIhuQC6XYcn9EXhhUhgAYNX2Yiz45ADMvJs2UbfEcERE1AYymQx//PlALJ0+DHIZkLr3NP7w7x9wuckidWtE1M4YjoiIHPDomCCsfjwKaqUc2wrPY+a736P2cpPUbRFRO2I4IiJy0OSh/vjg12PgrlEip/QiEt7ORkXdZanbIqJ2wnBERHQTYgZ4I3X2OPj00uBwWS0eXpOFk1UNUrdFRO2A4YiI6CYNCdQh7ckYBHm54tTFRjy0JgsHzxqkbouIbhHDERHRLdB7u2HzkzEYHOCBynojHn0nG1nFVVK3RUS3gOGIiOgW9XHXYsPscRgb4oU6oxkz3/seWw+WSd0WEd0khiMionbgoVXhg9+MQVyEH0xmK/7w7x/w8fenpG6LiG4CwxERUTvRqhRY/XgkZozuD6sAFnxyAG99WwT+EAFR18JwRETUjpQKOZZOH4anfj4QAPD6tmP4y+eFsFoZkIi6CoYjIqJ2JpPJ8PykMCy5PwIA8P6eE0jakA+TmT83QtQVMBwRETnJr38WgpUzRkIpl+GzgnP47Qd70WA0S90WEd0AwxERkRNNHdkX/5gZDReVAjuLKvHYP3JwscEkdVtE1AqGIyIiJ7szrA8+emIsPF1VKDhdg4fX7sHZmktSt0VE18FwRETUAUYF9cbmOTEI1GlRcqEBD6/Zg6LzdVK3RUQtYDgiIuogA/u4Y/OTsRjYpxfKDJfxyNtZ2HeyWuq2iOgnGI6IiDpQoKcLNs2OwaggT9Q0NuGX/8jB9qMVUrdFRNdgOCIi6mC93dT49+/GYsJtvrjUZMETH+RiS95Zqdsiov9hOCIikoCrWol/zIzGtJGBMFsFkjbkY/2uUqnbIiIwHBERSUalkOPN+JH4zc9CAAAvf1GIZVuP8OdGiCTGcEREJCG5XIY/3TcYL04OAwCs2VGM+Wn7YbbwbtpEUmE4IiKSmEwmwx/uHIhlDw2DXAZszD2DJ//9Ay43WaRujahHYjgiIuokEkYHYc0vo6BWypFReB6/Wv89DJeapG6LqMdhOCIi6kQmDfHHP38zBu4aJb4/cREJb2ehovay1G0R9SgMR0REnczYUG9smB0DX3cNjpTX4aG1e3CiskHqtoh6DIYjIqJOKCLQA2lzYqH3dsXpi5fw8No9OHjWIHVbRD0CwxERUScV5O2KzXNiERHggcp6E2a8k409xZVSt0XU7TEcERF1Yr7uGqTOHodxoV6oN5ox6929+OpAmdRtEXVrDEdERJ2ch1aF9389BpOH+MNkseIPH/2Af+eclLotom6L4YiIqAvQqhRY9XgkHh0TBCGARekH8ff/FvFu2kROwHBERNRFKOQyvPLgUMy9ayAA4M2MY3jps0OwWhmQiNoTwxERURcik8nwbFwYXro/AjIZ8EHWSTyzIR8mM39uhKi9MBwREXVBs34WgpUzRkGlkOHzgnP47Qd70WA0S90WUbfAcERE1EU9MCIQ62eOhqtagZ1FlXhsXTaq6o1St0XU5TEcERF1YXfc5ouPnhiH3q4qFJwx4JG3s3CmulHqtoi6NIYjIqIubmR/T2yaE4u+ni4oudCAh9dk4dj5OqnbIuqyGI6IiLqBgX16YfOTMRjUpxfKay/jkbVZ2HfyotRtEXVJDEdERN1EgM4Fm+bEIDLIE4ZLTXj8Hzn49sh5qdsi6nIYjoiIuhFPVzX+/btx+HmYLy43WfHEh/uQtu+M1G0RdSkMR0RE3YyLWoF3fhWN6aP6wmIVeG5TAdZ9VyJ1W0RdBsMREVE3pFLI8fojI/C720MAAH/7z2Es/eowf26EqA0YjoiIuim5XIZFvxiM5CnhAIC3M0vw4ub9MFt4N22i1jAcERF1YzKZDHMmDMCrDw+HXAZs2ncGc/61D5ebLFK3RtRpMRwREfUA8dH98XZiNDRKOb45XIHE9TkwNDZJ3RZRp8RwRETUQ9wT4Yd//nYs3LVK7D1RjYR3snC+9rLUbRF1OgxHREQ9yJgQL2ycHYM+7hocKa/DQ2v2oORCvdRtEXUqDEdERD3M4AAPpD0Zi2BvV5ypvoRH1mbhwBmD1G0RdRoMR0REPVB/L1dsfjIWQ/t6oKrBhBnvZGH38Uqp2yLqFBiOiIh6KJ9eGnz8xDjEDvBGg8mCX7+3F1/uL5O6LSLJMRwREfVg7loV3vv1aNw7zB8mixVPffwD/pl9Uuq2iCTFcERE1MNplAr8v0cj8fjYIAgB/GnLQaz45hjvpk09FsMRERFBIZfhr9OG4pm7BwEAVnxThD9/eggWKwMS9TwMR0REBODK3bTn3XMb/m/qEMhkwD+zT2Juah6MZt5Nm3oWhiMiIrLzq5hg/L9HR0GlkOHL/WX4zft7UW80S90WUYdhOCIiombuGx6I92aNgatagd3Hq/DoO9moqjdK3RZRh2A4IiKiFt0+yAepvx8HLzc1Dpw14OG1WTh9sVHqtoicjuGIiIiua3g/T2yeE4O+ni4orWzAQ2v24Eh5rdRtETnVTYWj1atXIyQkBFqtFlFRUdi5c2er9ZmZmYiKioJWq0VoaCjWrl3brCYtLQ0RERHQaDSIiIhAenq6w9s9f/48Zs2ahcDAQLi6umLy5MkoKipqNk9WVhbuuusuuLm5wdPTE3feeScuXbrk4LNARNQzhPr2QtqTsQjzc0dFnRHxa7Ow98RFqdsichqHw9GGDRuQlJSERYsWIS8vD+PHj8eUKVNw6tSpFutLS0tx7733Yvz48cjLy8PChQsxd+5cpKWl2WqysrKQkJCAxMREFBQUIDExEfHx8cjJyWnzdoUQmDZtGkpKSvDpp58iLy8Per0eEydORENDg922Jk+ejLi4OHz//ffYu3cvnnrqKcjlPIlGRHQ9/jotNs6OQbS+N2ovm/HLf+Tgm8LzUrdF5BQy4eBdvsaOHYvIyEisWbPGNjZ48GBMmzYNS5cubVY/f/58fPbZZzh8+LBtbM6cOSgoKEBWVhYAICEhAbW1tfjqq69sNZMnT0bv3r3x8ccft2m7x44dQ1hYGA4ePIghQ4YAACwWC/r06YNly5bhd7/7HQBg3LhxuOeee/Dyyy87sts2tbW10Ol0MBgM8PDwuKk5iIi6qksmC5766Af890gFFHIZUqYPwyPR/aVui+iGHHn/duh0iclkwr59+xAXF2c3HhcXhz179rS4TlZWVrP6SZMmITc3F01NTa3WXJ2zLds1Gq98i0Kr1dqWKxQKqNVq7Nq1CwBQUVGBnJwc9OnTB7GxsfDz88OECRNsy1tiNBpRW1tr9yAi6qlc1AqsTYzCQ5H9YLEKvLB5P97OLJa6LaJ25VA4qqyshMVigZ+fn924n58fysvLW1ynvLy8xXqz2YzKyspWa67O2ZbthoeHQ6/XY8GCBaiurobJZEJKSgrKy8tRVnblhxRLSkoAAC+99BKeeOIJbN26FZGRkbj77rtbvDYJAJYuXQqdTmd79O/P/yERUc+mUsjx+iPDMfuOUADA0q+O4JX/HIaVd9OmbuKmLrSRyWR2fwshmo3dqP6n422Zs7UalUqFtLQ0HDt2DF5eXnB1dcWOHTswZcoUKBQKAIDVagUAzJ49G7/+9a8xatQoLF++HGFhYXj33Xdb7H3BggUwGAy2x+nTp6+7n0REPYVMJsOCewdjwZRwAMA735Xghc370WSxStwZ0a1TOlLs4+MDhULR7CxRRUVFs7M6V/n7+7dYr1Qq4e3t3WrN1Tnbut2oqCjk5+fDYDDAZDLB19cXY8eORXR0NAAgICAAABAREWE3z+DBg697QblGo4FGo2lxGRFRTzd7wgB499Jgftp+pP1wBtWNJqx6LBIuaoXUrRHdNIfOHKnVakRFRSEjI8NuPCMjA7GxsS2uExMT06x+27ZtiI6OhkqlarXm6pyOblen08HX1xdFRUXIzc3F1KlTAQDBwcEIDAzE0aNH7eqPHTsGvV5/o90nIqIWPBzVD+8kRkGjlOPbIxX45focGBqbpG6L6OYJB6WmpgqVSiXWr18vCgsLRVJSknBzcxMnTpwQQgiRnJwsEhMTbfUlJSXC1dVVzJs3TxQWFor169cLlUolNm/ebKvZvXu3UCgUIiUlRRw+fFikpKQIpVIpsrOz27xdIYTYuHGj2L59uyguLhZbtmwRer1eTJ8+3a7/5cuXCw8PD7Fp0yZRVFQkFi9eLLRarTh+/Hib9t9gMAgAwmAwOPrUERF1a3tLq8SwJVuFfv4X4p43d4iymktSt0Rk48j7t8PhSAghVq1aJfR6vVCr1SIyMlJkZmbals2cOVNMmDDBrn7Hjh1i1KhRQq1Wi+DgYLFmzZpmc27atEmEhYUJlUolwsPDRVpamkPbFUKIlStXin79+gmVSiWCgoLE4sWLhdFobDbP0qVLRb9+/YSrq6uIiYkRO3fubPO+MxwREV3fkbJaMeZvGUI//wsRu/S/4nhFndQtEQkhHHv/dvg+Rz0d73NERNS60xcbMfPd71FS2QAvNzXemzUaI/p7St0W9XBOu88RERHRjfT3csWmOTEY3k+Hiw0mPLouGzuLLkjdFlGbMRwREVG78+6lwUdPjMPtA33QaLLgN+/vxecF56Rui6hNGI6IiMgpemmUWD8rGr8YHoAmi8Dc1Dx8mHVC6raIbojhiIiInEajVODvM0bhVzF6CAH8+dNDeDPjGHi5K3VmDEdERORUCrkMf3lgCOZNvA0A8Pf/FmHxloOw8OdGqJNiOCIiIqeTyWR4ZuIg/HXaUMhkwL9zTuHpj3+A0WyRujWiZhiOiIiow/xynB6rHouEWiHHfw6U49fv7UXdZd5NmzoXhiMiIupQ9w4LwPu/Hg03tQJ7iqvw6LpsVNYbpW6LyIbhiIiIOlzsQB+k/j4G3m5qHDxbi4fX7MHpi41St0UEgOGIiIgkMqyfDpufjEW/3i44UdWI6Wv24HBZrdRtETEcERGRdEJ83JD2ZCzC/d1xoc6I+Lez8H3pRanboh6O4YiIiCTl56HFhtkxGB3cG3WXzUhcn4OMwvNSt0U9GMMRERFJTueiwj9/OxYTB/eB0WzFnH/tw8bc01K3RT0UwxEREXUKWpUCa38ZhUei+sFiFXhx836szSzm3bSpwzEcERFRp6FUyPHqw8MxZ8IAAEDKV0fwty8Pw8q7aVMHYjgiIqJORSaTIXlKOBb/YjAA4B+7SvH8pgI0WawSd0Y9hVLqBoiIiFryu/Gh8HJT44XN+/FJ3llUN5rwp/siUF57GSE+bgjQuUjdInVTDEdERNRpTY/sh96uajz5733YfvQCth/NBADIZcDS6cOQMDpI4g6pO+LHakRE1Kn9PLwP/j5jlN2YVQALPzmIMsMlibqi7ozhiIiIOr1e2uYfdFiEwIlK/uQItT+GIyIi6vRCfNwgl9mPyWRAsI+rNA1Rt8ZwREREnV6AzgVLpw+DQvZjQlIr5OA3/MkZGI6IiKhLSBgdhF3JP8e/fjsGEQEeMJqteG5jPu+BRO2O4YiIiLqMAJ0Lbh/ki1WPR8JVrUB2yUWs21kidVvUzTAcERFRlxPi44Y/3xcBAHh921EcOmeQuCPqThiOiIioS0oY3R9xEX5osggkpebjcpNF6paom2A4IiKiLkkmkyHloeHwddegqKIeKV8dkbol6iYYjoiIqMvyclPjtYeHAwDe33MCmccuSNwRdQcMR0RE1KXdGdYHs2KDAQDPbyrAxQaTtA1Rl8dwREREXV7ylHAM7NMLF+qMSE7bDyH49X66eQxHRETU5WlVCqycMRIqhQzbCs9jY+5pqVuiLozhiIiIuoUhgTo8HxcGAPjL54U4UdkgcUfUVTEcERFRt/G78aEYF+qFRpMFSRvyYbZYpW6JuiCGIyIi6jYUchneiB8Jd60S+adr8P++PS51S9QFMRwREVG30tfTBX97cBgA4K3tx7HvZLXEHVFXw3BERETdzgMjAjFtZCAsVoFnN+aj3miWuiXqQhiOiIioW/rL1KHo6+mCk1WN+L/PD0ndDnUhDEdERNQt6VxUeDN+BGQyYGPuGWw9WCZ1S9RFMBwREVG3NTbUG3MmDAAAJH9yAOdrL0vcEXUFDEdERNStzZt4G4b29UBNYxOe31QAq5V3z6bWMRwREVG3plbKsSJhFLQqOXYWVeKDrBNSt0SdHMMRERF1ewP79MKiewcDAJZ+dQTHztdJ3BF1ZgxHRETUI/xynB4/D/OFyWzF3I/zYDRbpG6JOimGIyIi6hFkMhlefXgEvN3UOFJehze2HZO6JeqkGI6IiKjH8HXXIOWh4QCAdTtLsOd4pcQdUWfEcERERD3KPRF+eHRMEIQAnttUAENjk9QtUSfDcERERD3On+4bjBAfN5QZLmPhlgMQgl/vpx8xHBERUY/jqlZiRcJIKOQyfLm/DFvyz0rdEnUiDEdERNQjjejviaS7BwEA/rzlEE5fbJS4I+osGI6IiKjH+sPPByJa3xt1RjOe3ZgPC++eTWA4IiKiHkwhl2F5wkj00iix90Q11mYWS90SdQIMR0RE1KP193LFSw8MAQAszziG/WdqpG2IJMdwREREPd5DkX1x7zB/mK0CSan5aDSZpW6JJMRwREREPZ5MJsMrDw6Dn4cGJZUNeOU/h6VuiSTEcERERATA01WNNx4ZCQD4V/Yp/PfweWkbIskwHBEREf3P7YN88NvbQwAAL27ejwt1Rok7IikwHBEREV3jhUlhCPd3R1WDCclp+3n37B6I4YiIiOgaWpUCK2aMhFohx3+PVODfOaekbok62E2Fo9WrVyMkJARarRZRUVHYuXNnq/WZmZmIioqCVqtFaGgo1q5d26wmLS0NERER0Gg0iIiIQHp6usPbPX/+PGbNmoXAwEC4urpi8uTJKCoqarEnIQSmTJkCmUyGLVu2tH3niYio2wv398CLk8MAAH/9shDFF+ol7og6ksPhaMOGDUhKSsKiRYuQl5eH8ePHY8qUKTh1quVkXVpainvvvRfjx49HXl4eFi5ciLlz5yItLc1Wk5WVhYSEBCQmJqKgoACJiYmIj49HTk5Om7crhMC0adNQUlKCTz/9FHl5edDr9Zg4cSIaGhqa9bVixQrIZDJHd5+IiHqI3/wsBLcP9MHlJiuSUvPRZLFK3RJ1FOGgMWPGiDlz5tiNhYeHi+Tk5BbrX3zxRREeHm43Nnv2bDFu3Djb3/Hx8WLy5Ml2NZMmTRIzZsxo83aPHj0qAIiDBw/alpvNZuHl5SXWrVtnt15+fr7o16+fKCsrEwBEenr6Dfb6RwaDQQAQBoOhzesQEVHXVFZzSQx/6Wuhn/+FeHXrYanboVvgyPu3Q2eOTCYT9u3bh7i4OLvxuLg47Nmzp8V1srKymtVPmjQJubm5aGpqarXm6pxt2a7ReOUbBVqt1rZcoVBArVZj165dtrHGxkY8+uijeOutt+Dv73/DfTYajaitrbV7EBFRz+Cv02Lp9GEAgNU7ivF96UWJO6KO4FA4qqyshMVigZ+fn924n58fysvLW1ynvLy8xXqz2YzKyspWa67O2ZbthoeHQ6/XY8GCBaiurobJZEJKSgrKy8tRVlZmW2fevHmIjY3F1KlT27TPS5cuhU6nsz369+/fpvWIiKh7uHdYAB6O6gchgHkb8lF7uUnqlsjJbuqC7J9eqyOEaPX6nZbqfzreljlbq1GpVEhLS8OxY8fg5eUFV1dX7NixA1OmTIFCoQAAfPbZZ/j222+xYsWKNuzlFQsWLIDBYLA9Tp8+3eZ1iYioe1hyfwT6e7ngbM0lvPTpIanbISdzKBz5+PhAoVA0O0tUUVHR7KzOVf7+/i3WK5VKeHt7t1pzdc62bjcqKgr5+fmoqalBWVkZtm7diqqqKoSEXLmh17fffovi4mJ4enpCqVRCqVQCAB566CHceeedLfav0Wjg4eFh9yAiop7FXavC8viRkMuAT/LO4vOCc1K3RE7kUDhSq9WIiopCRkaG3XhGRgZiY2NbXCcmJqZZ/bZt2xAdHQ2VStVqzdU5Hd2uTqeDr68vioqKkJuba/sILTk5Gfv370d+fr7tAQDLly/He++918ZngYiIeqLoYC889fOBAIBF6QdQZrgkcUfkNI5e7Z2amipUKpVYv369KCwsFElJScLNzU2cOHFCCCFEcnKySExMtNWXlJQIV1dXMW/ePFFYWCjWr18vVCqV2Lx5s61m9+7dQqFQiJSUFHH48GGRkpIilEqlyM7ObvN2hRBi48aNYvv27aK4uFhs2bJF6PV6MX369Fb3B/y2GhERtZHJbBEP/L+dQj//C/HoO1nCYrFK3RK1kSPv3w6HIyGEWLVqldDr9UKtVovIyEiRmZlpWzZz5kwxYcIEu/odO3aIUaNGCbVaLYKDg8WaNWuazblp0yYRFhYmVCqVCA8PF2lpaQ5tVwghVq5cKfr16ydUKpUICgoSixcvFkajsdV9YTgiIiJHFFfUifDFXwn9/C/EO5nFUrdDbeTI+7dMCP5ojCNqa2uh0+lgMBh4/RERUQ/18fensOCTA1Ar5Njyx58hIpDvB52dI+/f/G01IiIiB80Y3R8TB/vBZLEiaUMeLjdZpG6J2hHDERERkYNkMhmWPTQMPr00OHa+Hsu2HpG6JWpHDEdEREQ3wbuXBq89MhwA8N7uE/ju2AWJO6L2wnBERER0k34e1ge/itEDAJ7fVICLDSaJO6L2wHBERER0CxZMGYwBvm6oqDNi4ScHwO85dX0MR0RERLfARa3AyhmjoFLIsPVQOTbtOyN1S3SLGI6IiIhu0dC+Ojx7TxgA4C+fHcLJqgaJO6JbwXBERETUDn5/RyjGhHihwWRB0oZ8mC1WqVuim8RwRERE1A4UchmWJ4yEu1aJvFM1WLW9WOqW6CYxHBEREbWTvp4u+Ou0oQCAv39bhLxT1RJ3RDeD4YiIiKgdTR3ZFw+MCITFKjBvQz4ajGapWyIHMRwRERG1s5enDUWgTosTVY14+YtCqdshBzEcERERtTOdiwpvxI+ETAak7j2Nrw+VS90SOYDhiIiIyAliBnjj93eEAgCS0/ajovayxB1RWzEcEREROclz94QhIsAD1Y1NeH7zft49u4tgOCIiInIStVKOlTNGQqOU47tjF/Bh1kmpW6I2YDgiIiJyokF+7lh472AAwCv/OYyi83USd0Q3wnBERETkZL+K0WPCbb4wmq14JjUfRrNF6paoFQxHRERETiaTyfDaI8Ph5aZGYVkt3sw4JnVL1AqGIyIiog7Qx12LlOnDAADvfFeCrOIqiTui62E4IiIi6iBxQ/zx6Jj+EAJ4dmM+DI1NUrdELWA4IiIi6kCLfxGBYG9XlBku40+fHpS6HWoBwxEREVEHctMosTxhJBRyGT4rOIcteWelbol+guGIiIiog40K6o1n7h4EAPjTloM4U90ocUd0LYYjIiIiCfzhzgGIDPJEndGMZzcWwGLl3bM7C4YjIiIiCSgVcqxIGAU3tQLfl17E298VS90S/Q/DERERkUSCvF3x0gNDAABvbjuGg2cNEndEAMMRERGRpB6O6ocpQ/1htgo8k5qHSybePVtqDEdEREQSkslkeOXBYejjrkHxhQa88p/DUrfU4zEcERERSay3mxpvxI8AAPwz+yS2H6mQuKOejeGIiIioExg/yBe/+VkIAOCFzQWorDdK3FHPxXBERETUSbw4OQy3+fVCZb0JyWn7IQS/3i8FhiMiIqJOQqtSYOWMUVAr5PjmcAU+/v601C31SAxHREREncjgAA+8ODkMAPDyF4UouVAvcUc9D8MRERFRJ/Obn4UgdoA3LjVZMG9DPposVqlb6lEYjoiIiDoZuVyGN+JHQOeiQsEZA/7+3yKpW+pRGI6IiIg6oQCdC155cBgAYNX248g9cVHijnoOhiMiIqJO6hfDAzA9si+sAkjakI+6y01St9QjMBwRERF1Yn95YAj69XbBmepLeOmzQqnb6REYjoiIiDoxd60KyxNGQi4D0n44gy/3l0ndUrfHcERERNTJjQ72wh/uHAgAWJh+AGWGSxJ31L0xHBEREXUBz0wchOH9dDBcasLzmwpgtfLu2c7CcERERNQFqBRyrEgYCReVAruPV+Hd3aVSt9RtMRwRERF1EaG+vbD4vsEAgFe3HsXhslqJO+qeGI6IiIi6kMfGBGHi4D4wWaxISs3H5SaL1C11OwxHREREXYhMJkPKQ8Ph00uNo+fr8NrXR6VuqdthOCIiIupifHpp8OrDwwEA63eVYmfRBYk76l4YjoiIiLqgu8L98MtxQQCA5zcVoLrBJHFH3QfDERERURe16N4IhPq64XytEQvTD0AIfr2/PTAcERERdVEuagVWJoyCUi7DVwfLsXnfGalb6hYYjoiIiLqwYf10mHfPbQCAlz47hFNVjRJ31PUxHBEREXVxcyYMwJhgLzSYLJi3MR9mi1Xqlro0hiMiIqIuTiGX4Y34EXDXKLHvZDVW7yiWuqUujeGIiIioG+jv5Yr/mzYEALDyv0XIP10jbUNdGMMRERFRNzFtZF/cPyIQFqtAUmoeGoxmqVvqkhiOiIiIugmZTIa/Th2KAJ0WJ6oa8dcvC6VuqUtiOCIiIupGdK4qvBE/AjIZ8PH3p7HtULnULXU5DEdERETdTOwAH/x+fCgAIPmTA6iouyxxR13LTYWj1atXIyQkBFqtFlFRUdi5c2er9ZmZmYiKioJWq0VoaCjWrl3brCYtLQ0RERHQaDSIiIhAenq6w9s9f/48Zs2ahcDAQLi6umLy5MkoKiqyLb948SKefvpphIWFwdXVFUFBQZg7dy4MBsPNPA1ERESd1rNxt2FwgAcuNpjwwqb9vHu2AxwORxs2bEBSUhIWLVqEvLw8jB8/HlOmTMGpU6darC8tLcW9996L8ePHIy8vDwsXLsTcuXORlpZmq8nKykJCQgISExNRUFCAxMRExMfHIycnp83bFUJg2rRpKCkpwaeffoq8vDzo9XpMnDgRDQ0NAIBz587h3LlzeP3113HgwAG8//772Lp1K3772986+jQQERF1ahqlAitnjIRGKUfmsQv4Z/ZJqVvqOoSDxowZI+bMmWM3Fh4eLpKTk1usf/HFF0V4eLjd2OzZs8W4ceNsf8fHx4vJkyfb1UyaNEnMmDGjzds9evSoACAOHjxoW242m4WXl5dYt27ddfdn48aNQq1Wi6ampuvWXMtgMAgAwmAwtKmeiIhISu/tKhH6+V+I2xb9RxSdr5W6Hck48v7t0Jkjk8mEffv2IS4uzm48Li4Oe/bsaXGdrKysZvWTJk1Cbm4umpqaWq25Omdbtms0GgEAWq3WtlyhUECtVmPXrl3X3SeDwQAPDw8olcoWlxuNRtTW1to9iIiIuopfxQTjjtt8YTRb8UxqPkxm3j37RhwKR5WVlbBYLPDz87Mb9/PzQ3l5y1fDl5eXt1hvNptRWVnZas3VOduy3fDwcOj1eixYsADV1dUwmUxISUlBeXk5ysrKWuytqqoKL7/8MmbPnn3dfV66dCl0Op3t0b9//+vWEhERdTZyuQyvPzwcvV1VOHSuFm9mHJO6pU7vpi7Ilslkdn8LIZqN3aj+p+NtmbO1GpVKhbS0NBw7dgxeXl5wdXXFjh07MGXKFCgUimY91dbW4he/+AUiIiKwZMmS6/a+YMECGAwG2+P06dPXrSUiIuqM+nhosXT6cADA298VI7ukSuKOOjeHwpGPjw8UCkWzs0QVFRXNzupc5e/v32K9UqmEt7d3qzVX52zrdqOiopCfn4+amhqUlZVh69atqKqqQkhIiN16dXV1mDx5Mnr16oX09HSoVKrr7rNGo4GHh4fdg4iIqKuZPNQfCdH9IQTw3MYCGC41Sd1Sp+VQOFKr1YiKikJGRobdeEZGBmJjY1tcJyYmpln9tm3bEB0dbQsl16u5Oqej29XpdPD19UVRURFyc3MxdepU27La2lrExcVBrVbjs88+s7tGiYiIqDv78/0R0Hu74mzNJfz504NSt9N5OXq1d2pqqlCpVGL9+vWisLBQJCUlCTc3N3HixAkhhBDJyckiMTHRVl9SUiJcXV3FvHnzRGFhoVi/fr1QqVRi8+bNtprdu3cLhUIhUlJSxOHDh0VKSopQKpUiOzu7zdsV4so3z7Zv3y6Ki4vFli1bhF6vF9OnT7ctr62tFWPHjhXDhg0Tx48fF2VlZbaH2Wxu0/7z22pERNSV7Tt5UYQu+FLo538htuSdkbqdDuPI+7fD4UgIIVatWiX0er1Qq9UiMjJSZGZm2pbNnDlTTJgwwa5+x44dYtSoUUKtVovg4GCxZs2aZnNu2rRJhIWFCZVKJcLDw0VaWppD2xVCiJUrV4p+/foJlUolgoKCxOLFi4XRaLQt3759uwDQ4qO0tLRN+85wREREXd3yjKNCP/8LMXTJVnGmulHqdjqEI+/fMiF4y0xH1NbWQqfT2W4BQERE1NWYLVY88nYW8k7VYGyIFz56YhwU8ut/sao7cOT9m7+tRkRE1MMoFXKsSBgJV7UCOaUXsW5nidQtdSoMR0RERD2Q3tsNL90/BADwxrajOHiWvzN6FcMRERFRD/VIdD9MGuKHJotA0oZ8XDJZpG6pU2A4IiIi6qFkMhmWTh+OPu4aHK+oR8pXh6VuqVNgOCIiIurBvNzUeO2REQCAD7JOYvvRCok7kh7DERERUQ834TZfzIoNBgC8sGk/quqN0jYkMYYjIiIiQvKUcNzm1wuV9UYkf3IAPflOPwxHREREBK1KgRUJo6BWyJFReB4b9vbcH1pnOCIiIiIAQESgB56fdBsA4C+fF6K0skHijqTBcEREREQ2v7s9FDGh3rjUZEHShnw0WaxSt9ThGI6IiIjIRi6X4Y34EfDQKlFwugb/79vjUrfU4RiOiIiIyE6gpwv+9uAwAMBb3xZh38mLEnfUsRiOiIiIqJn7RwTiwVF9YRVA0oZ81BvNUrfUYRiOiIiIqEV/mToEfT1dcPriJfzls0NSt9NhGI6IiIioRR5aFZYnjIRMBmzadwZfHSiTuqUOwXBERERE1zUmxAtPThgAAFiQfgDlhssSd+R8DEdERETUqqSJt2FYXx1qGpvwwuYCWK3d++7ZDEdERETUKrVSjuUJI6FVybGzqBLv7TkhdUtOxXBERERENzSwTy8s+kUEAGDZ1iM4Ul4rcUfOw3BEREREbfLLsUG4K7wPTGYrklLzcbnJInVLTsFwRERERG0ik8mw7KHh8HZT40h5HV7/+qjULTkFwxERERG1ma+7Bq8+PBwA8I9dpdh9vFLijtofwxERERE55O7Bfnh8bBAA4LmNBahpNEncUftiOCIiIiKHLfrFYIT6uKG89jIWpR+EEN3n6/0MR0REROQwV7USK2aMhFIuw5cHyvDJD2elbqndMBwRERHRTRnezxPz7rkNALDks0M4fbFR4o7aB8MRERER3bQ5EwYgWt8b9UYz5m3Ih9lilbqlW8ZwRERERDdNIZdhecJI9NIokXuyGmszi6Vu6ZYxHBEREdEt6e/liv+bOgQAsOKbIhScrpG2oVvEcERERES37MFRffGL4QEwWwXmbchHo8ksdUs3jeGIiIiIbplMJsPfpg2Fv4cWJZUN+OuXh6Vu6aYxHBEREVG78HRV4834EQCAj3JO4ZvC8xJ3dHMYjoiIiKjdxA70wRPjQwAA89P240KdUeKOHMdwRERERO3q+UlhCPd3R1WDCS9uLuhyd89mOCIiIqJ2pVEqsHLGKKiVcmw/egH/yjkldUsOYTgiIiKidhfm747kyeEAgL99WYjjFfUSd9R2DEdERETkFLNigzF+kA8uN1mRtCEPJnPXuHs2wxERERE5hVwuw+uPjICnqwoHz9ZixTfHpG6pTRiOiIiIyGn8PLRImT4MALAmsxg5JVUSd3RjDEdERETkVJOHBuCRqH4QAnh2YwFqLzdJ3VKrGI6IiIjI6ZY8MARBXq44W3MJSz49JHU7rWI4IiIiIqfrpVFiecJIyGVAet5ZfFZwTuqWrovhiIiIiDpElL43nrprEABgUfoBnK25JHFHLWM4IiIiog7z9F0DMbK/J+oum/HcxnxYrZ3v7tkMR0RERNRhVAo5lieMhKtageySi/jHrhKpW2qG4YiIiIg6VIiPG/58XwQA4LWvj+LQOYPEHdljOCIiIqIOlzC6P+Ii/NBkEUhKzcflJovULdkwHBEREVGHk8lkSHloOHzdNSiqqEfKV0ekbsmG4YiIiIgk4eWmxmsPDwcAvL/nBDKPXZC4oysYjoiIiEgyd4b1wazYYADA85sKcLisFnuKK1FmkO5r/krJtkxEREQEIHlKOHYdr8TxinpMWbkTACCXAUunD0PC6KAO74dnjoiIiEhSWpUCf/rFYLsxqwAWfnJQkjNIDEdEREQkOZWyeSSxCIETlY0d3gvDEREREUkuxMcNcpn9mEImQ7CPa4f3wnBEREREkgvQuWDp9GFQyK4kJIVMhlemD0WAzqXDe+EF2URERNQpJIwOwh23+eJEZSOCfVwlCUYAwxERERF1IgE6F8lC0VX8WI2IiIjoGjcVjlavXo2QkBBotVpERUVh586drdZnZmYiKioKWq0WoaGhWLt2bbOatLQ0REREQKPRICIiAunp6Q5v9/z585g1axYCAwPh6uqKyZMno6ioyK7GaDTi6aefho+PD9zc3PDAAw/gzJkzN/EsEBERUXfkcDjasGEDkpKSsGjRIuTl5WH8+PGYMmUKTp061WJ9aWkp7r33XowfPx55eXlYuHAh5s6di7S0NFtNVlYWEhISkJiYiIKCAiQmJiI+Ph45OTlt3q4QAtOmTUNJSQk+/fRT5OXlQa/XY+LEiWhoaLDNk5SUhPT0dKSmpmLXrl2or6/HfffdB4ul8/zgHREREUlIOGjMmDFizpw5dmPh4eEiOTm5xfoXX3xRhIeH243Nnj1bjBs3zvZ3fHy8mDx5sl3NpEmTxIwZM9q83aNHjwoA4uDBg7blZrNZeHl5iXXr1gkhhKipqREqlUqkpqbaas6ePSvkcrnYunXrDfddCCEMBoMAIAwGQ5vqiYiISHqOvH87dObIZDJh3759iIuLsxuPi4vDnj17WlwnKyurWf2kSZOQm5uLpqamVmuuztmW7RqNRgCAVqu1LVcoFFCr1di1axcAYN++fWhqarKbJzAwEEOHDr1u/0ajEbW1tXYPIiIi6r4cCkeVlZWwWCzw8/OzG/fz80N5eXmL65SXl7dYbzabUVlZ2WrN1Tnbst3w8HDo9XosWLAA1dXVMJlMSElJQXl5OcrKymzbUavV6N27d5v7X7p0KXQ6ne3Rv3//6z4/RERE1PXd1AXZMpn9LSyFEM3GblT/0/G2zNlajUqlQlpaGo4dOwYvLy+4urpix44dmDJlChQKRav701r/CxYsgMFgsD1Onz7d6lxERETUtTl0nyMfHx8oFIpmZ1kqKiqandW5yt/fv8V6pVIJb2/vVmuuztnW7UZFRSE/Px8GgwEmkwm+vr4YO3YsoqOjbdsxmUyorq62O3tUUVGB2NjYFvvXaDTQaDTXfU6IiIioe3HozJFarUZUVBQyMjLsxjMyMq4bLmJiYprVb9u2DdHR0VCpVK3WXJ3T0e3qdDr4+vqiqKgIubm5mDp1KoAr4UmlUtnNU1ZWhoMHD163fyIiIuphHL3aOzU1VahUKrF+/XpRWFgokpKShJubmzhx4oQQQojk5GSRmJhoqy8pKRGurq5i3rx5orCwUKxfv16oVCqxefNmW83u3buFQqEQKSkp4vDhwyIlJUUolUqRnZ3d5u0KIcTGjRvF9u3bRXFxsdiyZYvQ6/Vi+vTpdv3PmTNH9OvXT3zzzTfihx9+EHfddZcYMWKEMJvNbdp/fluNiIio63Hk/dvhcCSEEKtWrRJ6vV6o1WoRGRkpMjMzbctmzpwpJkyYYFe/Y8cOMWrUKKFWq0VwcLBYs2ZNszk3bdokwsLChEqlEuHh4SItLc2h7QohxMqVK0W/fv2ESqUSQUFBYvHixcJoNNrVXLp0STz11FPCy8tLuLi4iPvuu0+cOnWqzfvOcERERNT1OPL+LRPif1dHU5sYDAZ4enri9OnT8PDwkLodIiIiaoPa2lr0798fNTU10Ol0rdbyh2cdVFdXBwD8Sj8REVEXVFdXd8NwxDNHDrJarTh37hzc3d1bvX3BzbiaanlWqnPhcel8eEw6Jx6XzonH5QohBOrq6hAYGAi5vPXvo/HMkYPkcjn69evn1G14eHj06H/AnRWPS+fDY9I58bh0TjwuuOEZo6tu6iaQRERERN0VwxERERHRNRiOOhGNRoMlS5bwjtydDI9L58Nj0jnxuHROPC6O4wXZRERERNfgmSMiIiKiazAcEREREV2D4YiIiIjoGgxHRERERNdgOGondXV1SEpKgl6vh4uLC2JjY7F3797r1u/YsQMymazZ48iRI3Z1aWlpiIiIgEajQUREBNLT05vNtXr1aoSEhECr1SIqKgo7d+5s9/3rqqQ6Li+99FKzOfz9/Z2yj12NM47JoUOH8NBDDyE4OBgymQwrVqxocS6+Vq5PquPC10rrnHFc1q1bh/Hjx6N3797o3bs3Jk6ciO+//77ZXD359cJw1E5+97vfISMjA//85z9x4MABxMXFYeLEiTh79myr6x09ehRlZWW2x6BBg2zLsrKykJCQgMTERBQUFCAxMRHx8fHIycmx1WzYsAFJSUlYtGgR8vLyMH78eEyZMgWnTp1y2r52JVIdFwAYMmSI3RwHDhxwyj52Nc44Jo2NjQgNDUVKSsp131j5WmmdVMcF4GulNc44Ljt27MCjjz6K7du3IysrC0FBQYiLi7Obs8e/XgTdssbGRqFQKMQXX3xhNz5ixAixaNGiFtfZvn27ACCqq6uvO298fLyYPHmy3dikSZPEjBkzbH+PGTNGzJkzx64mPDxcJCcnO7gX3Y+Ux2XJkiVixIgRN917d+WsY3ItvV4vli9f3mycr5Xrk/K48LVyfR1xXIQQwmw2C3d3d/HBBx/Yxnr664VnjtqB2WyGxWKBVqu1G3dxccGuXbtaXXfUqFEICAjA3Xffje3bt9sty8rKQlxcnN3YpEmTsGfPHgCAyWTCvn37mtXExcXZanoyqY7LVUVFRQgMDERISAhmzJiBkpKSW9ib7sFZx+RG+FppnVTH5Sq+VlrWUcelsbERTU1N8PLyAsDXC8CP1dqFu7s7YmJi8PLLL+PcuXOwWCz417/+hZycHJSVlbW4TkBAAN555x2kpaXhk08+QVhYGO6++2589913tpry8nL4+fnZrefn54fy8nIAQGVlJSwWS6s1PZlUxwUAxo4diw8//BBff/011q1bh/LycsTGxqKqqso5O9tFOOuY3AhfK62T6rgAfK20pqOOS3JyMvr27YuJEycC4OsFAD9Way/Hjx8Xd9xxhwAgFAqFGD16tHj88cfF4MGD2zzHfffdJ+6//37b3yqVSnz00Ud2Nf/617+ERqMRQghx9uxZAUDs2bPHruavf/2rCAsLu4W96T6kOC4tqa+vF35+fuKNN95wfCe6GWcck2u19PENXys3JsVxaQlfK/acfVyWLVsmevfuLQoKCmxjfL3wY7V2M2DAAGRmZqK+vh6nT5/G999/j6amJoSEhLR5jnHjxqGoqMj2t7+/f7OUXlFRYUvzPj4+UCgUrdb0dFIcl5a4ublh2LBhdvP0VM44JjfC18qNSXFcWsLXij1nHpfXX38dr7zyCrZt24bhw4fbxvl64cdq7c7NzQ0BAQGorq7G119/jalTp7Z53by8PAQEBNj+jomJQUZGhl3Ntm3bEBsbCwBQq9WIiopqVpORkWGroSs68ri0xGg04vDhw3bz9HTteUxuhK+VtuvI49ISvlZa1t7H5bXXXsPLL7+MrVu3Ijo62m4ZXy/gx2rtZevWreKrr74SJSUlYtu2bWLEiBFizJgxwmQyCSGESE5OFomJibb65cuXi/T0dHHs2DFx8OBBkZycLACItLQ0W83u3buFQqEQKSkp4vDhwyIlJUUolUqRnZ1tq0lNTRUqlUqsX79eFBYWiqSkJOHm5iZOnDjRcTvfiUl1XJ577jmxY8cOUVJSIrKzs8V9990n3N3deVyEc46J0WgUeXl5Ii8vTwQEBIjnn39e5OXliaKiIlsNXyutk+q48LXSOmccl2XLlgm1Wi02b94sysrKbI+6ujpbTU9/vTActZMNGzaI0NBQoVarhb+/v/jjH/8oampqbMtnzpwpJkyYYPt72bJlYsCAAUKr1YrevXuL22+/XXz55ZfN5t20aZMICwsTKpVKhIeH2/0Dv2rVqlVCr9cLtVotIiMjRWZmplP2sSuS6rgkJCSIgIAAoVKpRGBgoJg+fbo4dOiQ0/azK3HGMSktLRUAmj2unUcIvlZaI9Vx4Wuldc44Lnq9vsXjsmTJEru6nvx6kQkhRMeeqyIiIiLqvHjNEREREdE1GI6IiIiIrsFwRERERHQNhiMiIiKiazAcEREREV2D4YiIiIjoGgxHRERERNdgOCIiIiK6BsMRERER0TUYjoiIiIiuwXBEREREdA2GIyIiIqJr/H+fdaIbCH6vEwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds = xr.open_zarr(\"SwashParticles.zarr\")\n", "\n", @@ -167,7 +139,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "parcels", "language": "python", "name": "python3" }, @@ -181,7 +153,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/docs/examples/tutorial_unitconverters.ipynb b/docs/examples/tutorial_unitconverters.ipynb index 74eb85fc8..838c21e5a 100644 --- a/docs/examples/tutorial_unitconverters.ipynb +++ b/docs/examples/tutorial_unitconverters.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -68,20 +68,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fieldset = parcels.FieldSet.from_data(data, dims, mesh=\"spherical\")\n", "plt.pcolormesh(fieldset.U.lon, fieldset.U.lat, fieldset.U.data[0, :, :], vmin=0, vmax=1)\n", @@ -99,18 +88,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1.1747725785927634e-05, 8.999280057595393e-06)\n", - "20.0\n" - ] - } - ], + "outputs": [], "source": [ "print(fieldset.UV[0, 0, 40, -5])\n", "print(fieldset.temp[0, 0, 40, -5])" @@ -128,19 +108,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "U: \n", - "V: \n", - "temp: \n" - ] - } - ], + "outputs": [], "source": [ "for fld in [fieldset.U, fieldset.V, fieldset.temp]:\n", " print(f\"{fld.name}: {fld.units}\")" @@ -158,17 +128,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0000000000000002\n" - ] - } - ], + "outputs": [], "source": [ "u, v = fieldset.UV[0, 0, 40, -5]\n", "print(v * 1852 * 60)" @@ -184,17 +146,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1.0, 1.0)\n" - ] - } - ], + "outputs": [], "source": [ "print(fieldset.UV.eval(0, 0, 40, -5, applyConversion=False))" ] @@ -217,30 +171,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Velocities: (1.0, 1.0)\n", - "U: \n", - "V: \n", - "temp: \n" - ] - } - ], + "outputs": [], "source": [ "fieldset_flat = parcels.FieldSet.from_data(data, dims, mesh=\"flat\")\n", "\n", @@ -285,18 +218,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Kh_zonal: 1.380091e-08 \n", - "Kh_meridional: 8.098704e-09 \n" - ] - } - ], + "outputs": [], "source": [ "kh_zonal = 100 # in m^2/s\n", "kh_meridional = 100 # in m^2/s\n", @@ -332,17 +256,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100.0\n" - ] - } - ], + "outputs": [], "source": [ "deg_to_m = 1852 * 60\n", "print(fieldset.Kh_meridional[0, 0, 40, -5] * deg_to_m**2)" @@ -378,17 +294,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], + "outputs": [], "source": [ "fieldset.add_field(\n", " parcels.Field(\n", @@ -408,18 +316,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.1747725785927634e-05\n", - "0.9999999999999999\n" - ] - } - ], + "outputs": [], "source": [ "from parcels.tools.converters import GeographicPolar\n", "\n", @@ -427,82 +326,6 @@ "print(fieldset.Ustokes[0, 0, 40, -5])\n", "print(fieldset.Ustokes[0, 0, 40, -5] * 1852 * 60 * np.cos(40 * np.pi / 180))" ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Alternatively, the UnitConverter can be set when the `FieldSet` or `Field` is created by using the `fieldtype` argument (use a dictionary in the case of `FieldSet` construction.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.1747725785927634e-05\n" - ] - } - ], - "source": [ - "fieldset.add_field(\n", - " parcels.Field(\n", - " \"Ustokes2\",\n", - " np.ones((ydim, xdim), dtype=np.float32),\n", - " grid=fieldset.U.grid,\n", - " fieldtype=\"U\",\n", - " )\n", - ")\n", - "print(fieldset.Ustokes2[0, 0, 40, -5])" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Using velocities in units other than m/s\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Some OGCM store velocity data in units of e.g. cm/s. For these cases, Field objects have a method `set_scaling_factor()`.\n", - "\n", - "If your data is in cm/s and if you want to use the built-in Advection kernels, you will therefore have to use `fieldset.U.set_scaling_factor(100)` and `fieldset.V.set_scaling_factor(100)`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "fieldset.add_field(\n", - " parcels.Field(\n", - " name=\"Ucm\",\n", - " data=0.01 * np.ones((ydim, xdim), dtype=np.float32),\n", - " grid=fieldset.U.grid,\n", - " )\n", - ")\n", - "fieldset.Ucm.set_scaling_factor(100)\n", - "print(fieldset.Ucm[0, 0, 40, -5])" - ] } ], "metadata": { diff --git a/docs/index.rst b/docs/index.rst index 8ebfb0b59..0961a73b5 100755 --- a/docs/index.rst +++ b/docs/index.rst @@ -1,9 +1,11 @@ Parcels documentation ===================== -Welcome to the documentation of Parcels. **Parcels** (Probably A Really Computationally Efficient Lagrangian Simulator) is a set of Python classes and methods to create customisable particle tracking simulations using output from Ocean Circulation models. Parcels can be used to track passive and active particulates such as water, plankton, `plastic `_ and `fish `_. + +Welcome to the documentation of Parcels. **Parcels** provides a set of Python classes and methods to create customisable particle tracking simulations using gridded output from (ocean) circulation models. Parcels can be used to track passive and active particulates such as water, plankton, `plastic `_ and `fish `_. .. figure:: _static/homepage.gif + :class: dark-light *Animation of virtual particles carried by ocean surface flow in the global oceans. The particles are advected with Parcels in data from the* `NEMO Ocean Model `_. @@ -16,9 +18,9 @@ If you need more help with Parcels, try the `Discussions page on GitHub + v4 Installation Tutorials & Documentation API reference - Release Notes - Contributing + Contributing, Release Notes and more OceanParcels website diff --git a/docs/installation.rst b/docs/installation.rst index f5775847a..f891ab00a 100644 --- a/docs/installation.rst +++ b/docs/installation.rst @@ -36,9 +36,6 @@ The steps below are the installation instructions for Linux, macOS and Windows. python example_peninsula.py --fieldset 100 100 -.. note:: - If you are on macOS and get a compilation error, you may need to accept the Apple xcode license ``xcode-select --install``. If this does not solve the compilation error, you may want to try running ``export CC=gcc``. If the compilation error remains, you may want to check `this solution `_. - *Optionally:* if you want to run all the examples and tutorials, start Jupyter and open the tutorial notebooks: .. code-block:: bash @@ -59,21 +56,4 @@ The steps below are the installation instructions for Linux, macOS and Windows. Installation for developers =========================== -If you would prefer to have a development installation of Parcels (i.e., where the code can be actively edited), you can do so by setting up Miniconda (as detailed in step 1 above), cloning the Parcels repo, installing dependencies using the environment file, and then installing Parcels in an editable mode such that changes to the cloned code can be tested during development. - -**Step 1:** Same as `step 1 above`_. - -**Step 2:** Clone the Parcels repo and create a new environment with the development dependencies: - -.. code-block:: bash - - git clone https://github.com/OceanParcels/parcels.git - cd parcels - conda env create -n parcels-dev -f environment.yml - -**Step 3:** Activate the environment and install Parcels in editable mode: - -.. code-block:: bash - - conda activate parcels-dev - pip install --no-build-isolation --no-deps -e . +See the `development section in our contributing guide <./community/contributing.rst#development>`_ for development instructions. diff --git a/docs/reference.rst b/docs/reference.rst index 67062e6cf..caecbd39a 100644 --- a/docs/reference.rst +++ b/docs/reference.rst @@ -11,5 +11,4 @@ Parcels API User-defined Kernels Particle-particle interaction Gridsets and grids - C Code Generation Miscellaneous diff --git a/docs/reference/code_generation.rst b/docs/reference/code_generation.rst deleted file mode 100644 index 94337f149..000000000 --- a/docs/reference/code_generation.rst +++ /dev/null @@ -1,16 +0,0 @@ -C Code Generation -================= - -parcels.compilation.codegenerator module ----------------------------------------- - -.. automodule:: parcels.compilation.codegenerator - :members: - :show-inheritance: yes - -parcels.compilation.codecompiler module ---------------------------------------- - -.. automodule:: parcels.compilation.codecompiler - :members: - :show-inheritance: yes diff --git a/docs/reference/grids.rst b/docs/reference/grids.rst index 9c9a54e07..e8d47a118 100644 --- a/docs/reference/grids.rst +++ b/docs/reference/grids.rst @@ -1,13 +1,6 @@ Gridsets and grids ================== -parcels.gridset module ----------------------- - -.. automodule:: parcels.gridset - :members: - :show-inheritance: - parcels.grid module ------------------- diff --git a/docs/reference/misc.rst b/docs/reference/misc.rst index a8a195f78..0e379d463 100644 --- a/docs/reference/misc.rst +++ b/docs/reference/misc.rst @@ -1,13 +1,6 @@ Miscellaneous ============= -parcels.rng module ------------------- - -.. automodule:: parcels.rng - :members: - :undoc-members: - parcels.tools.statuscodes module -------------------------------- diff --git a/docs/v4/TODO.md b/docs/v4/TODO.md new file mode 100644 index 000000000..2936c15cd --- /dev/null +++ b/docs/v4/TODO.md @@ -0,0 +1,11 @@ +# TODO + +List of tasks that are important to do before the release of version 4 (but can't be done now via code changes in `v4-dev`). + +- [ ] Make migration guide for v3 to v4 +- [ ] Just prior to release: Update conda feedstock recipe dependencies (Python 3.11+, remove cgen and compiler dependencies, add pooch as dependency and remove platformdirs). Make sure that recipe is up-to-date. +- [x] Revamp the oceanparcels.org landing page, and perhaps also consider new logo/branding? +- [ ] Rerun all the tutorials so that their output is in line with new v4 print statements etc +- Documentation + - [ ] Look into xarray and whether users can create periodic datasets without increasing the size of the original dataset (i.e., no compromise alternative to `time_periodic` param in v3). Update docs accordingly. + - [ ] Look into xarray and whether users can create datasets from snapshots assigning different time dimensions without increasing the size of the original dataset (i.e., no compromise alternative to `timestamps` param in v3). Update docs accordingly. diff --git a/docs/v4/api.md b/docs/v4/api.md new file mode 100644 index 000000000..a7a925286 --- /dev/null +++ b/docs/v4/api.md @@ -0,0 +1,52 @@ +# API design document + +## Field data input + +Here is the proposed API for Field data ingestion into Parcels. + +```{mermaid} + +classDiagram + class Fieldset{ + +List[Field] fields + } + class Field{ + +xr.Dataset|xr.DataArray|ux.Dataset|ux.DataArray data + +parcels.Grid|ux.Grid grid + +Interpolator interpolator + +eval(t, z, y, x, particle=None, applyConversion=True) + } + + class Interpolator{ + +assert_is_compatible(Field) + +interpolate(Field, rid, t, z, y, x ) + } + + + <> Interpolator + + Fieldset ..> Field : depends on + Field ..> Interpolator : depends on + Interpolator <|.. ScalarInterpolator : Realization of + Interpolator <|.. VectorInterpolator : Realization of + Interpolator <|.. etc : Realization of +``` + +Here, important things to note are: + +- Interpolators (which would implement the `Interpolator` protocol) are responsible for the actual interpolation of the data, and performance considerations. There will be interpolation and indexing utilities that can be made available to the interpolators, allowing for code re-use. + - Interpolators of the data should handle spatial periodicity and, for the case of rectilinear structured grids, without pre-computing a halo for the FieldSet and Grid ([issue](https://github.com/OceanParcels/Parcels/issues/1898)). + +- In the `Field` class, not all combinations of `data`, `grid`, and `interpolator` will logically make sense (e.g., a `xr.DataArray` on a `ux.Grid`, or `ux.DataArray` on a `parcels.Grid`). It's up to the `Interpolator.assert_is_compatible(Field)` to define what is and is not compatible, and raise `ValueError` / `TypeError` on incompatible data types. The `.assert_is_compatible()` method also acts as developer documentation, defining clearly for the `.interpolate()` method what assumptions it is working on. The `.assert_is_compatible()` method should be lightweight as it will be called on `Field` initialisation. + +- The `grid` object, in the case of unstructured grids, will be the `Grid` class from UXarray. For structured `Grid`s, it will be an object similar to that of `xgcm.Grid` (note that it will be very different from the v3 `Grid` object hierarchy). + +- The `Field.eval` method takes as input the t,z,y,x spatio-temporal position as required arguments; the `particle` is optional and defaults to `None` and the `applyConversion` argument is optional and defaults to `True`. Initially, we will calculate the element index for a particle. As a future optimization, we could pass via the `particle` object a "cached" index value that could be used to bypass an index search. This will effectively provide `(ti,zi,yi,xi)` on a structured grid and `(ti,zi,fi)` on an unstructured grid (where `fi` is the lateral face id); within `eval` these indices will be `ravel`'ed to a single index that can be `unravel`'ed in the `interpolate` method. The `ravel`'ed index is referred to as `rid` in the `Field.Interpolator.interpolate` method. In the `interpolate` method, we envision that a user will benefit from knowing the nearest cell/index from the `ravel`'ed index (which can be `unravel`'ed) in addition the exact coordinate that we want to interpolate onto. This can permit calculation of interpolation weights using points in the neighborhood of `(t,z,y,x)`. + +## Changes in API + +Below a list of changes in the API that are relevant to users: + +- `starttime`, `endtime` and `dt` in `ParticleSet.execute()` are now `numpy.timedelta64` or `numpy.datetime64` objects. This allows for more precise time handling and is consistent with the `numpy` time handling. + +- `pid_orig` in `ParticleSet` is removed. Instead, `trajectory_ids` is used to provide a list of "trajectory" values (integers) for the particle IDs. diff --git a/docs/v4/index.md b/docs/v4/index.md new file mode 100644 index 000000000..4b85ef095 --- /dev/null +++ b/docs/v4/index.md @@ -0,0 +1,26 @@ +# Parcels v4 development + +Supported by funding from the [WarmWorld](https://www.warmworld.de) [ELPHE](https://www.kooperation-international.de/foerderung/projekte/detail/info/warmworld-elphe-ermoeglichung-von-lagranian-particle-tracking-fuer-hochaufloesende-und-unstrukturierte-gitter) project and an [NWO Vici project](https://www.nwo.nl/en/researchprogrammes/nwo-talent-programme/projects-vici/vici-2022), the Parcels team is working on a major update to the Parcels codebase. + +The key goals of this update are + +1. to support `Fields` on unstructured grids; +2. to allow for user-defined interpolation methods (somewhat similar to user-defined kernels); +3. to make the codebase more modular, easier to extend, and more maintainable; +4. to align Parcels more with other tools in the [Pangeo ecosystem](https://www.pangeo.io/#ecosystem), particularly by leveraging `xarray` more; and +5. to improve the performance of Parcels. + +The timeline for the release of Parcels v4 is not yet fixed, but we are aiming for a release of an 'alpha' version in September 2025. This v4-alpha will have support for unstructured grids and user-defined interpolation methods, but is not yet performance-optimised. + +Collaboration on v4 development is happening on the [Parcels v4 Project Board](https://github.com/orgs/OceanParcels/projects/5). + +The pages below provide further background on the development of Parcels v4. You can think of this page as a "living" document as we work towards the release of v4. + +```{toctree} +installation +api +nojit +TODO +Parcels v4 Project Board +Parcels v4 migration guide <../community/v4-migration> +``` diff --git a/docs/v4/installation.md b/docs/v4/installation.md new file mode 100644 index 000000000..b7756f225 --- /dev/null +++ b/docs/v4/installation.md @@ -0,0 +1,20 @@ +# Install an alpha version of Parcels v4 + +During development of Parcels v4, we are uploading versions of the package to an [index on prefix.dev](https://prefix.dev/channels/parcels/packages/parcels). This allows users to easily install an unreleased version without having to do a [development install](../installation.rst)! Give it a spin! + +```{warning} +Before installing an alpha version of Parcels, we *highly* recommend creating a new environment so that doesn't affect package versions in your current environment (which you may be using for your research). + +You can see what your current environment is by doing `conda env list` and seeing which environment has a `*` next to it. At any point, you can use `conda activate ...` (replacing `...` with the name that had the `*` next to it) to return to your environment with version 3 of Parcels. + +``` + +Do the following to create a new environment (called `parcels-v4-alpha`) with an alpha version of Parcels installed: + +```sh +conda create -n parcels-v4-alpha python=3.11 +conda activate parcels-v4-alpha +conda install -c https://repo.prefix.dev/parcels parcels +``` + +During the development of Parcels v4 we will be occasionally releasing these alpha package versions so that users can try them out. If you're installing Parcels normally (i.e., via Conda forge) you will receive version 3 of Parcels as usual until version 4 is officially released. diff --git a/docs/v4/nojit.md b/docs/v4/nojit.md new file mode 100644 index 000000000..2959f81b4 --- /dev/null +++ b/docs/v4/nojit.md @@ -0,0 +1,16 @@ +# Rationale for dropping JIT support in v4 + +Parcels v4 will not support Just-In-Time (JIT) compilation. This means that the `JITParticle` class will be removed from the codebase. This decision was made for the following reasons: + +1. We want to leverage the power of `xarray` and `uxarray` for data handling and interpolation. These libraries are not compatible with the JIT compilation in v3. +2. We want to make the codebase more maintainable and easier to understand. The JIT compilation pre-v4 adds complexity to the codebase and makes it harder to debug and maintain. +3. We have quite a few features in Parcels (also v3) that only work in Scipy mode (particle-particle interaction, particle-field interaction, etc.). +4. We want users to write more flexible/complex kernels. JIT doesn't support calling functions, or using methods from `numpy` or `scipy`, while this is possible in Scipy mode. + +Essentially, the only advantage of JIT was its speed. But now that the ecosystem for just-in-time compilation with python has matured in the last 10 years, we want to leverage other packages and methods (`cython`, `numba`, `jax`?) and Python internals for speed-up. + +Furthermore, we think we have some good ideas how to speed up Parcels itself without JIT compilation, such as relying more on vectorized operations. + +In short, we think that the disadvantages of JIT in Parcels v3 outweigh the advantages, and we want to make Parcels v4 a more modern and maintainable codebase. + +In our development of v4, we will first focus on making the codebase more modular and easier to extend. Once we have a working codebase, we will release this as `v4-alpha`. After that, we will start working on performance improvements. diff --git a/environment.yml b/environment.yml deleted file mode 100644 index 04eaad6b9..000000000 --- a/environment.yml +++ /dev/null @@ -1,48 +0,0 @@ -name: parcels -channels: - - conda-forge -dependencies: - - python>=3.10 - - cgen - - ffmpeg>=3.2.3 - - jupyter - - matplotlib-base>=2.0.2 - - netcdf4>=1.1.9 - - numpy>=1.9.1 - - platformdirs - - psutil - - pymbolic - - scipy>=0.16.0 - - tqdm - - xarray>=0.10.8 - - cftime>=1.3.1 - - dask>=2.0 - - scikit-learn - - zarr>=2.11.0,!=2.18.0,<3 - - # Notebooks - - trajan - - # Testing - - nbval - - pytest - - pytest-html - - coverage - - # Typing - - mypy - - types-tqdm - - types-psutil - - # Linting - - pre_commit - - # Docs - - ipython - - numpydoc - - nbsphinx - - sphinx - - pandoc - - pydata-sphinx-theme - - sphinx-autobuild - - myst-parser diff --git a/parcels/__init__.py b/parcels/__init__.py index 25a65ba12..3eb58c2fb 100644 --- a/parcels/__init__.py +++ b/parcels/__init__.py @@ -2,15 +2,90 @@ __version__ = version -import parcels.rng as ParcelsRandom # noqa: F401 -from parcels.application_kernels import * -from parcels.field import * -from parcels.fieldset import * -from parcels.grid import * -from parcels.gridset import * -from parcels.interaction import * -from parcels.kernel import * -from parcels.particle import * -from parcels.particlefile import * -from parcels.particleset import * -from parcels.tools import * +import warnings as _stdlib_warnings + +from parcels._core.basegrid import BaseGrid +from parcels._core.converters import ( + Geographic, + GeographicPolar, + GeographicPolarSquare, + GeographicSquare, + UnitConverter, +) +from parcels._core.field import Field, VectorField +from parcels._core.fieldset import FieldSet +from parcels._core.kernel import Kernel +from parcels._core.particle import ( + KernelParticle, # ? remove? + Particle, + ParticleClass, + Variable, +) +from parcels._core.particlefile import ParticleFile +from parcels._core.particleset import ParticleSet +from parcels._core.statuscodes import ( + AllParcelsErrorCodes, + FieldInterpolationError, + FieldOutOfBoundError, + FieldSamplingError, + KernelError, + StatusCode, + TimeExtrapolationError, +) +from parcels._core.uxgrid import UxGrid +from parcels._core.warnings import ( + FieldSetWarning, + FileWarning, + KernelWarning, + ParticleSetWarning, +) +from parcels._core.xgrid import XGrid +from parcels._logger import logger +from parcels._tutorial import download_example_dataset, list_example_datasets + +__all__ = [ # noqa: RUF022 + # Core classes + "BaseGrid", + "Field", + "VectorField", + "FieldSet", + "Kernel", + "Particle", + "ParticleClass", + "ParticleFile", + "ParticleSet", + "Variable", + "XGrid", + "UxGrid", + # Converters + "Geographic", + "GeographicPolar", + "GeographicPolarSquare", + "GeographicSquare", + "UnitConverter", + # Status codes and errors + "AllParcelsErrorCodes", + "FieldInterpolationError", + "FieldOutOfBoundError", + "FieldSamplingError", + "KernelError", + "StatusCode", + "TimeExtrapolationError", + # Warnings + "FieldSetWarning", + "FileWarning", + "KernelWarning", + "ParticleSetWarning", + # Utilities + "logger", + "download_example_dataset", + "list_example_datasets", + # (marked for potential removal) + "KernelParticle", +] + +_stdlib_warnings.warn( + "This is an alpha version of Parcels v4. The API is not stable and may change without deprecation warnings.", + UserWarning, + stacklevel=2, +) diff --git a/parcels/_compat.py b/parcels/_compat.py index 416ed2905..0abe9753d 100644 --- a/parcels/_compat.py +++ b/parcels/_compat.py @@ -19,15 +19,22 @@ pass -def add_note(e: Exception, note: str, *, before=False) -> Exception: # TODO: Remove once py3.10 support is dropped - """Implements something similar to PEP 678 but for python <3.11. - - https://stackoverflow.com/a/75549200/15545258 +# for compat with v3 of parcels when users provide `initial=attrgetter("lon")` to a Variable +# so that particle initial state matches another variable +class _AttrgetterHelper: + """ + Example usage + + >>> _attrgetter_helper = _AttrgetterHelper() + >>> _attrgetter_helper.some_attribute + 'some_attribute' + >>> from operator import attrgetter + >>> attrgetter('some_attribute')(_attrgetter_helper) + 'some_attribute' """ - args = e.args - if not args: - arg0 = note - else: - arg0 = f"{note}\n{args[0]}" if before else f"{args[0]}\n{note}" - e.args = (arg0,) + args[1:] - return e + + def __getattr__(self, name): + return name + + +_attrgetter_helper = _AttrgetterHelper() diff --git a/parcels/_core/basegrid.py b/parcels/_core/basegrid.py new file mode 100644 index 000000000..a05ea6dfc --- /dev/null +++ b/parcels/_core/basegrid.py @@ -0,0 +1,269 @@ +from __future__ import annotations + +from abc import ABC, abstractmethod +from enum import IntEnum +from typing import TYPE_CHECKING + +import numpy as np + +from parcels._core.spatialhash import SpatialHash + +if TYPE_CHECKING: + import numpy as np + + +class GridType(IntEnum): + RectilinearZGrid = 0 + RectilinearSGrid = 1 + CurvilinearZGrid = 2 + CurvilinearSGrid = 3 + + +class BaseGrid(ABC): + @abstractmethod + def search(self, z: float, y: float, x: float, ei=None) -> dict[str, tuple[int, float | np.ndarray]]: + """ + Perform a spatial (and optionally vertical) search to locate the grid element + that contains a given point (x, y, z). + + This method delegates to grid-type-specific logic (e.g., structured or unstructured) + to determine the appropriate indices and barycentric coordinates for evaluating a field. + + Parameters + ---------- + z : float + Vertical coordinate of the query point. If `search2D=True`, this may be ignored. + y : float + Latitude or vertical index, depending on grid type and projection. + x : float + Longitude or horizontal index, depending on grid type and projection. + ei : int, optional + A previously computed encoded index (e.g., raveled face or cell index). If provided, + the search will first attempt to validate and reuse it before falling back to + a global or local search strategy. + search2D : bool, default=False + If True, perform only a 2D search (x, y), ignoring the vertical component z. + + Returns + ------- + dict + A dictionary mapping spatial axis names to tuples of (index, barycentric_coordinates). + The returned axes depend on the grid dimensionality and type: + + - 3D structured grid: {"Z": (zi, zeta), "Y": (yi, eta), "X": (xi, xsi)} + - 2D structured grid: {"Y": (yi, eta), "X": (xi, xsi)} + - 1D structured grid (depth): {"Z": (zi, zeta)} + - Unstructured grid: {"Z": (zi, zeta), "FACE": (fi, bcoords)} + + Where: + - index (int): The cell position of the particles along the given axis + - barycentric_coordinates (float or np.ndarray): The coordinates defining + the particles positions within the grid cell. For structured grids, this + is a single coordinate per axis; for unstructured grids, this can be + an array of coordinates for the face polygon. + + Raises + ------ + FieldOutOfBoundError + Raised when the queried point lies outside the bounds of the grid. + NotImplementedError + Raised if the search method is not implemented for the current grid type. + """ + ... + + def ravel_index(self, axis_indices: dict[str, np.ndarray]) -> np.ndarray: + """ + Convert a dictionary of axis indices to a single encoded index (ei). + + This method takes the individual indices for each spatial axis and combines them + into a single integer that uniquely identifies a grid cell. This encoded + index can be used for efficient caching and lookup operations. + + Parameters + ---------- + axis_indices : dict[str, np.ndarray(int)] + A dictionary mapping axis names to their corresponding indices. + The expected keys depend on the grid dimensionality and type: + + - 3D structured grid: {"Z": zi, "Y": yi, "X": xi} + - 2D structured grid: {"Y": yi, "X": xi} + - 1D structured grid: {"Z": zi} + - Unstructured grid: {"Z": zi, "FACE": fi} + + Returns + ------- + np.ndarray(int) + The encoded indices (ei) representing the unique grid cells or faces. + + Raises + ------ + KeyError + Raised when required axis keys are missing from axis_indices. + ValueError + Raised when index values are out of bounds for the grid. + NotImplementedError + Raised if the method is not implemented for the current grid type. + """ + dims = np.array([self.get_axis_dim(axis) for axis in self.axes], dtype=int) + indices = np.array([axis_indices[axis] for axis in self.axes], dtype=int) + return _ravel(dims, indices) + + def unravel_index(self, ei: int) -> dict[str, int]: + """ + Convert a single encoded index (ei) back to a dictionary of axis indices. + + This method is the inverse of ravel_index, taking an encoded index and + decomposing it back into the individual indices for each spatial axis. + + Parameters + ---------- + ei : int + The encoded index representing a unique grid cell or face. + + Returns + ------- + dict[str, int] + A dictionary mapping axis names to their corresponding indices. + The returned keys depend on the grid dimensionality and type: + + - 3D structured grid: {"Z": zi, "Y": yi, "X": xi} + - 2D structured grid: {"Y": yi, "X": xi} + - 1D structured grid: {"Z": zi} + - Unstructured grid: {"Z": zi, "FACE": fi} + + Raises + ------ + ValueError + Raised when the encoded index is out of bounds or invalid for the grid. + NotImplementedError + Raised if the method is not implemented for the current grid type. + """ + dims = np.array([self.get_axis_dim(axis) for axis in self.axes], dtype=int) + indices = _unravel(dims, ei) + return dict(zip(self.axes, indices, strict=True)) + + @property + @abstractmethod + def axes(self) -> list[str]: + """ + Return a list of axis names that are part of this grid. + + This list must at least be of length 1, and `get_axis_dim` should + return a valid integer for each axis name in the list. + + Returns + ------- + list[str] + List of axis names, e.g. ["Z", "Y", "X"] for a 3D structured grid or ["Z", "FACE"] for an unstructured grid. + """ + ... + + @abstractmethod + def get_axis_dim(self, axis: str) -> int: + """ + Return the dimensionality (number of cells/faces) along a specific axis. + + Parameters + ---------- + axis : str + The name of the axis to get the dimensionality for. Must be one of the values returned by self.axes. + + Returns + ------- + int + The number of cells/edges along the specified axis. + + Raises + ------ + ValueError + If the specified axis is not part of this grid. + """ + ... + + def get_spatial_hash( + self, + reconstruct=False, + ): + """Get the SpatialHash data structure of this Grid that allows for + fast face search queries. Face searches are used to find the faces that + a list of points, in spherical coordinates, are contained within. + + Parameters + ---------- + global_grid : bool, default=False + If true, the hash grid is constructed using the domain [-pi,pi] x [-pi,pi] + reconstruct : bool, default=False + If true, reconstructs the spatial hash + + Returns + ------- + self._spatialhash : parcels.spatialhash.SpatialHash + SpatialHash instance + + """ + if self._spatialhash is None or reconstruct: + self._spatialhash = SpatialHash(self) + + return self._spatialhash + + +def _unravel(dims, ei): + """ + Converts a flattened (raveled) index back to multi-dimensional indices. + + Args: + dims (1d-array-like): The dimensions along each axis + ei (int): The flattened index to convert + + Returns + ------- + array-like: Indices along each axis corresponding to the given flattened index + + Example: + >>> dims = [2, 3, 4] + >>> ei = 9 + >>> unravel(dims, ei) + array([0, 2, 1]) + # Calculation: + # i0 = 9 // (3*4) = 9 // 12 = 0 + # remainder = 9 % 12 = 9 + # i1 = 9 // 4 = 2 + # i2 = 9 % 4 = 1 + """ + strides = np.cumprod(dims[::-1])[::-1] + + indices = np.empty((len(dims), len(ei)), dtype=int) + + for i in range(len(dims) - 1): + indices[i, :] = ei // strides[i + 1] + ei = ei % strides[i + 1] + + indices[-1, :] = ei + return indices + + +def _ravel(dims, indices): + """ + Converts indices to a flattened (raveled) index. + + Args: + dims (1d-array-like): The dimensions along each axis + indices (array-like): Indices along each axis to convert + + Returns + ------- + int: The flattened index corresponding to the given indices + + Example: + >>> dims = [2, 3, 4] + >>> indices = [0, 2, 1] + >>> ravel(dims, indices) + 9 + # Calculation: 0 * (3 * 4) + 2 * (4) + 1 = 0 + 8 + 1 = 9 + """ + strides = np.cumprod(dims[::-1])[::-1] + ei = 0 + for i in range(len(dims) - 1): + ei += indices[i] * strides[i + 1] + + return ei + indices[-1] diff --git a/parcels/compilation/__init__.py b/parcels/_core/constants.py similarity index 100% rename from parcels/compilation/__init__.py rename to parcels/_core/constants.py diff --git a/parcels/_core/converters.py b/parcels/_core/converters.py new file mode 100644 index 000000000..35fddc18b --- /dev/null +++ b/parcels/_core/converters.py @@ -0,0 +1,104 @@ +from __future__ import annotations + +from math import pi + +import numpy as np +import numpy.typing as npt + +__all__ = [ + "Geographic", + "GeographicPolar", + "GeographicPolarSquare", + "GeographicSquare", + "UnitConverter", + "_convert_to_flat_array", + "_unitconverters_map", +] + + +def _convert_to_flat_array(var: npt.ArrayLike) -> npt.NDArray: + """Convert lists and single integers/floats to one-dimensional numpy arrays + + Parameters + ---------- + var : Array + list or numeric to convert to a one-dimensional numpy array + """ + return np.array(var).flatten() + + +class UnitConverter: + """Interface class for spatial unit conversion during field sampling that performs no conversion.""" + + source_unit: str | None = None + target_unit: str | None = None + + def to_target(self, value, z, y, x): + return value + + def to_source(self, value, z, y, x): + return value + + +class Geographic(UnitConverter): + """Unit converter from geometric to geographic coordinates (m to degree)""" + + source_unit = "m" + target_unit = "degree" + + def to_target(self, value, z, y, x): + return value / 1000.0 / 1.852 / 60.0 + + def to_source(self, value, z, y, x): + return value * 1000.0 * 1.852 * 60.0 + + +class GeographicPolar(UnitConverter): + """Unit converter from geometric to geographic coordinates (m to degree) + with a correction to account for narrower grid cells closer to the poles. + """ + + source_unit = "m" + target_unit = "degree" + + def to_target(self, value, z, y, x): + return value / 1000.0 / 1.852 / 60.0 / np.cos(y * pi / 180) + + def to_source(self, value, z, y, x): + return value * 1000.0 * 1.852 * 60.0 * np.cos(y * pi / 180) + + +class GeographicSquare(UnitConverter): + """Square distance converter from geometric to geographic coordinates (m2 to degree2)""" + + source_unit = "m2" + target_unit = "degree2" + + def to_target(self, value, z, y, x): + return value / pow(1000.0 * 1.852 * 60.0, 2) + + def to_source(self, value, z, y, x): + return value * pow(1000.0 * 1.852 * 60.0, 2) + + +class GeographicPolarSquare(UnitConverter): + """Square distance converter from geometric to geographic coordinates (m2 to degree2) + with a correction to account for narrower grid cells closer to the poles. + """ + + source_unit = "m2" + target_unit = "degree2" + + def to_target(self, value, z, y, x): + return value / pow(1000.0 * 1.852 * 60.0 * np.cos(y * pi / 180), 2) + + def to_source(self, value, z, y, x): + return value * pow(1000.0 * 1.852 * 60.0 * np.cos(y * pi / 180), 2) + + +_unitconverters_map = { + "U": GeographicPolar(), + "V": Geographic(), + "Kh_zonal": GeographicPolarSquare(), + "Kh_meridional": GeographicSquare(), +} diff --git a/parcels/_core/field.py b/parcels/_core/field.py new file mode 100644 index 000000000..d582e5b3c --- /dev/null +++ b/parcels/_core/field.py @@ -0,0 +1,469 @@ +from __future__ import annotations + +import warnings +from collections.abc import Callable +from datetime import datetime + +import numpy as np +import uxarray as ux +import xarray as xr + +from parcels._core.converters import ( + UnitConverter, + _unitconverters_map, +) +from parcels._core.index_search import GRID_SEARCH_ERROR, LEFT_OUT_OF_BOUNDS, RIGHT_OUT_OF_BOUNDS, _search_time_index +from parcels._core.particle import KernelParticle +from parcels._core.statuscodes import ( + AllParcelsErrorCodes, + StatusCode, +) +from parcels._core.utils.time import TimeInterval +from parcels._core.uxgrid import UxGrid +from parcels._core.xgrid import XGrid, _transpose_xfield_data_to_tzyx +from parcels._reprs import default_repr +from parcels._typing import VectorType +from parcels.interpolators import ( + UXPiecewiseLinearNode, + XLinear, + ZeroInterpolator, + ZeroInterpolator_Vector, +) +from parcels.utils._helpers import _assert_same_function_signature + +__all__ = ["Field", "VectorField"] + + +def _deal_with_errors(error, key, vector_type: VectorType): + if isinstance(key, KernelParticle): + key.state = AllParcelsErrorCodes[type(error)] + elif isinstance(key[-1], KernelParticle): + key[-1].state = AllParcelsErrorCodes[type(error)] + else: + raise RuntimeError(f"{error}. Error could not be handled because particles was not part of the Field Sampling.") + + if vector_type and "3D" in vector_type: + return (0, 0, 0) + elif vector_type == "2D": + return (0, 0) + else: + return 0 + + +_DEFAULT_INTERPOLATOR_MAPPING = { + XGrid: XLinear, + UxGrid: UXPiecewiseLinearNode, +} + + +class Field: + """The Field class that holds scalar field data. + The `Field` object is a wrapper around a xarray.DataArray or uxarray.UxDataArray object. + Additionally, it holds a dynamic Callable procedure that is used to interpolate the field data. + During initialization, the user can supply a custom interpolation method that is used to interpolate the field data, + so long as the interpolation method has the correct signature. + + Notes + ----- + The xarray.DataArray or uxarray.UxDataArray object contains the field data and metadata. + * dims: (time, [nz1 | nz], [face_lat | node_lat | edge_lat], [face_lon | node_lon | edge_lon]) + * attrs: (location, mesh, mesh) + + When using a xarray.DataArray object, + * The xarray.DataArray object must have the "location" and "mesh" attributes set. + * The "location" attribute must be set to one of the following to define which pairing of points a field is associated with. + * "node" + * "face" + * "x_edge" + * "y_edge" + * For an A-Grid, the "location" attribute must be set to / is assumed to be "node" (node_lat,node_lon). + * For a C-Grid, the "location" setting for a field has the following interpretation: + * "node" ~> the field is associated with the vorticity points (node_lat, node_lon) + * "face" ~> the field is associated with the tracer points (face_lat, face_lon) + * "x_edge" ~> the field is associated with the u-velocity points (face_lat, node_lon) + * "y_edge" ~> the field is associated with the v-velocity points (node_lat, face_lon) + + When using a uxarray.UxDataArray object, + * The uxarray.UxDataArray.UxGrid object must have the "Conventions" attribute set to "UGRID-1.0" + and the uxarray.UxDataArray object must comply with the UGRID conventions. + See https://ugrid-conventions.github.io/ugrid-conventions/ for more information. + + """ + + def __init__( + self, + name: str, + data: xr.DataArray | ux.UxDataArray, + grid: UxGrid | XGrid, + interp_method: Callable | None = None, + ): + if not isinstance(data, (ux.UxDataArray, xr.DataArray)): + raise ValueError( + f"Expected `data` to be a uxarray.UxDataArray or xarray.DataArray object, got {type(data)}." + ) + if not isinstance(name, str): + raise ValueError(f"Expected `name` to be a string, got {type(name)}.") + if not isinstance(grid, (UxGrid, XGrid)): + raise ValueError(f"Expected `grid` to be a parcels UxGrid, or parcels XGrid object, got {type(grid)}.") + + _assert_compatible_combination(data, grid) + + if isinstance(grid, XGrid): + data = _transpose_xfield_data_to_tzyx(data, grid.xgcm_grid) + + self.name = name + self.data = data + self.grid = grid + + try: + self.time_interval = _get_time_interval(data) + except ValueError as e: + e.add_note( + f"Error getting time interval for field {name!r}. Are you sure that the time dimension on the xarray dataset is stored as timedelta, datetime or cftime datetime objects?" + ) + raise e + + try: + if isinstance(data, ux.UxDataArray): + _assert_valid_uxdataarray(data) + # TODO: For unstructured grids, validate that `data.uxgrid` is the same as `grid` + else: + pass # TODO v4: Add validation for xr.DataArray objects + except Exception as e: + e.add_note(f"Error validating field {name!r}.") + raise e + + # Setting the interpolation method dynamically + if interp_method is None: + self._interp_method = _DEFAULT_INTERPOLATOR_MAPPING[type(self.grid)] + else: + _assert_same_function_signature(interp_method, ref=ZeroInterpolator, context="Interpolation") + self._interp_method = interp_method + + self.igrid = -1 # Default the grid index to -1 + + if self.grid._mesh == "flat" or (self.name not in _unitconverters_map.keys()): + self.units = UnitConverter() + elif self.grid._mesh == "spherical": + self.units = _unitconverters_map[self.name] + + if self.data.shape[0] > 1: + if "time" not in self.data.coords: + raise ValueError("Field data is missing a 'time' coordinate.") + + @property + def units(self): + return self._units + + @units.setter + def units(self, value): + if not isinstance(value, UnitConverter): + raise ValueError(f"Units must be a UnitConverter object, got {type(value)}") + self._units = value + + @property + def xdim(self): + if type(self.data) is xr.DataArray: + return self.grid.xdim + else: + raise NotImplementedError("xdim not implemented for unstructured grids") + + @property + def ydim(self): + if type(self.data) is xr.DataArray: + return self.grid.ydim + else: + raise NotImplementedError("ydim not implemented for unstructured grids") + + @property + def zdim(self): + if type(self.data) is xr.DataArray: + return self.grid.zdim + else: + if "nz1" in self.data.dims: + return self.data.sizes["nz1"] + elif "nz" in self.data.dims: + return self.data.sizes["nz"] + else: + return 0 + + @property + def interp_method(self): + return self._interp_method + + @interp_method.setter + def interp_method(self, method: Callable): + _assert_same_function_signature(method, ref=ZeroInterpolator, context="Interpolation") + self._interp_method = method + + def _check_velocitysampling(self): + if self.name in ["U", "V", "W"]: + warnings.warn( + "Sampling of velocities should normally be done using fieldset.UV or fieldset.UVW object; tread carefully", + RuntimeWarning, + stacklevel=2, + ) + + def eval(self, time: datetime, z, y, x, particles=None, applyConversion=True): + """Interpolate field values in space and time. + + We interpolate linearly in time and apply implicit unit + conversion to the result. Note that we defer to + scipy.interpolate to perform spatial interpolation. + """ + if particles is None: + _ei = None + else: + _ei = particles.ei[:, self.igrid] + + tau, ti = _search_time_index(self, time) + position = self.grid.search(z, y, x, ei=_ei) + _update_particles_ei(particles, position, self) + _update_particle_states_position(particles, position) + + value = self._interp_method(self, ti, position, tau, time, z, y, x) + + _update_particle_states_interp_value(particles, value) + + if applyConversion: + value = self.units.to_target(value, z, y, x) + return value + + def __getitem__(self, key): + self._check_velocitysampling() + try: + if isinstance(key, KernelParticle): + return self.eval(key.time, key.depth, key.lat, key.lon, key) + else: + return self.eval(*key) + except tuple(AllParcelsErrorCodes.keys()) as error: + return _deal_with_errors(error, key, vector_type=None) + + +class VectorField: + """VectorField class that holds vector field data needed to execute particles.""" + + def __init__( + self, name: str, U: Field, V: Field, W: Field | None = None, vector_interp_method: Callable | None = None + ): + self.name = name + self.U = U + self.V = V + self.W = W + self.grid = U.grid + self.igrid = U.igrid + + if W is None: + _assert_same_time_interval((U, V)) + else: + _assert_same_time_interval((U, V, W)) + + self.time_interval = U.time_interval + + if self.W: + self.vector_type = "3D" + else: + self.vector_type = "2D" + + # Setting the interpolation method dynamically + if vector_interp_method is None: + self._vector_interp_method = None + else: + _assert_same_function_signature(vector_interp_method, ref=ZeroInterpolator_Vector, context="Interpolation") + self._vector_interp_method = vector_interp_method + + def __repr__(self): + return f"""<{type(self).__name__}> + name: {self.name!r} + U: {default_repr(self.U)} + V: {default_repr(self.V)} + W: {default_repr(self.W)}""" + + @property + def vector_interp_method(self): + return self._vector_interp_method + + @vector_interp_method.setter + def vector_interp_method(self, method: Callable): + _assert_same_function_signature(method, ref=ZeroInterpolator_Vector, context="Interpolation") + self._vector_interp_method = method + + def eval(self, time: datetime, z, y, x, particles=None, applyConversion=True): + """Interpolate field values in space and time. + + We interpolate linearly in time and apply implicit unit + conversion to the result. Note that we defer to + scipy.interpolate to perform spatial interpolation. + """ + if particles is None: + _ei = None + else: + _ei = particles.ei[:, self.igrid] + + tau, ti = _search_time_index(self.U, time) + position = self.grid.search(z, y, x, ei=_ei) + _update_particles_ei(particles, position, self) + _update_particle_states_position(particles, position) + + if self._vector_interp_method is None: + u = self.U._interp_method(self.U, ti, position, tau, time, z, y, x) + v = self.V._interp_method(self.V, ti, position, tau, time, z, y, x) + if "3D" in self.vector_type: + w = self.W._interp_method(self.W, ti, position, tau, time, z, y, x) + else: + w = 0.0 + + if applyConversion: + u = self.U.units.to_target(u, z, y, x) + v = self.V.units.to_target(v, z, y, x) + + else: + (u, v, w) = self._vector_interp_method(self, ti, position, tau, time, z, y, x, applyConversion) + + for vel in (u, v, w): + _update_particle_states_interp_value(particles, vel) + + if applyConversion and ("3D" in self.vector_type): + w = self.W.units.to_target(w, z, y, x) if self.W else 0.0 + + if "3D" in self.vector_type: + return (u, v, w) + else: + return (u, v) + + def __getitem__(self, key): + try: + if isinstance(key, KernelParticle): + return self.eval(key.time, key.depth, key.lat, key.lon, key) + else: + return self.eval(*key) + except tuple(AllParcelsErrorCodes.keys()) as error: + return _deal_with_errors(error, key, vector_type=self.vector_type) + + +def _update_particles_ei(particles, position, field): + """Update the element index (ei) of the particles""" + if particles is not None: + if isinstance(field.grid, XGrid): + particles.ei[:, field.igrid] = field.grid.ravel_index( + { + "X": position["X"][0], + "Y": position["Y"][0], + "Z": position["Z"][0], + } + ) + elif isinstance(field.grid, UxGrid): + particles.ei[:, field.igrid] = field.grid.ravel_index( + { + "Z": position["Z"][0], + "FACE": position["FACE"][0], + } + ) + + +def _update_particle_states_position(particles, position): + """Update the particle states based on the position dictionary.""" + if particles: # TODO also support uxgrid search + for dim in ["X", "Y"]: + if dim in position: + particles.state = np.maximum( + np.where(position[dim][0] == -1, StatusCode.ErrorOutOfBounds, particles.state), particles.state + ) + particles.state = np.maximum( + np.where(position[dim][0] == GRID_SEARCH_ERROR, StatusCode.ErrorGridSearching, particles.state), + particles.state, + ) + if "Z" in position: + particles.state = np.maximum( + np.where(position["Z"][0] == RIGHT_OUT_OF_BOUNDS, StatusCode.ErrorOutOfBounds, particles.state), + particles.state, + ) + particles.state = np.maximum( + np.where(position["Z"][0] == LEFT_OUT_OF_BOUNDS, StatusCode.ErrorThroughSurface, particles.state), + particles.state, + ) + + +def _update_particle_states_interp_value(particles, value): + """Update the particle states based on the interpolated value, but only if state is not an Error already.""" + if particles: + particles.state = np.maximum( + np.where(np.isnan(value), StatusCode.ErrorInterpolation, particles.state), particles.state + ) + + +def _assert_valid_uxdataarray(data: ux.UxDataArray): + """Verifies that all the required attributes are present in the xarray.DataArray or + uxarray.UxDataArray object. + """ + # Validate dimensions + if not ("nz1" in data.dims or "nz" in data.dims): + raise ValueError( + "Field is missing a 'nz1' or 'nz' dimension in the field's metadata. " + "This attribute is required for xarray.DataArray objects." + ) + + if "time" not in data.dims: + raise ValueError( + "Field is missing a 'time' dimension in the field's metadata. " + "This attribute is required for xarray.DataArray objects." + ) + + # Validate attributes + required_keys = ["location", "mesh"] + for key in required_keys: + if key not in data.attrs.keys(): + raise ValueError( + f"Field is missing a '{key}' attribute in the field's metadata. " + "This attribute is required for xarray.DataArray objects." + ) + + _assert_valid_uxgrid(data.uxgrid) + + +def _assert_valid_uxgrid(grid): + """Verifies that all the required attributes are present in the uxarray.UxDataArray.UxGrid object.""" + if "Conventions" not in grid.attrs.keys(): + raise ValueError( + "Field is missing a 'Conventions' attribute in the field's metadata. " + "This attribute is required for uxarray.UxDataArray objects." + ) + if grid.attrs["Conventions"] != "UGRID-1.0": + raise ValueError( + "Field has a 'Conventions' attribute that is not 'UGRID-1.0'. " + "This attribute is required for uxarray.UxDataArray objects." + "See https://ugrid-conventions.github.io/ugrid-conventions/ for more information." + ) + + +def _assert_compatible_combination(data: xr.DataArray | ux.UxDataArray, grid: ux.Grid | XGrid): + if isinstance(data, ux.UxDataArray): + if not isinstance(grid, UxGrid): + raise ValueError( + f"Incompatible data-grid combination. Data is a uxarray.UxDataArray, expected `grid` to be a UxGrid object, got {type(grid)}." + ) + elif isinstance(data, xr.DataArray): + if not isinstance(grid, XGrid): + raise ValueError( + f"Incompatible data-grid combination. Data is a xarray.DataArray, expected `grid` to be a parcels Grid object, got {type(grid)}." + ) + + +def _get_time_interval(data: xr.DataArray | ux.UxDataArray) -> TimeInterval | None: + if data.shape[0] == 1: + return None + + return TimeInterval(data.time.values[0], data.time.values[-1]) + + +def _assert_same_time_interval(fields: list[Field]) -> None: + if len(fields) == 0: + return + + reference_time_interval = fields[0].time_interval + + for field in fields[1:]: + if field.time_interval != reference_time_interval: + raise ValueError( + f"Fields must have the same time domain. {fields[0].name}: {reference_time_interval}, {field.name}: {field.time_interval}" + ) diff --git a/parcels/_core/fieldset.py b/parcels/_core/fieldset.py new file mode 100644 index 000000000..bbc064a19 --- /dev/null +++ b/parcels/_core/fieldset.py @@ -0,0 +1,369 @@ +from __future__ import annotations + +import functools +from collections.abc import Iterable +from typing import TYPE_CHECKING + +import cf_xarray # noqa: F401 +import numpy as np +import xarray as xr +import xgcm + +from parcels._core.converters import Geographic, GeographicPolar +from parcels._core.field import Field, VectorField +from parcels._core.utils.time import get_datetime_type_calendar +from parcels._core.utils.time import is_compatible as datetime_is_compatible +from parcels._core.xgrid import _DEFAULT_XGCM_KWARGS, XGrid +from parcels._logger import logger +from parcels._typing import Mesh + +if TYPE_CHECKING: + from parcels._core.basegrid import BaseGrid + from parcels._typing import TimeLike +__all__ = ["FieldSet"] + + +class FieldSet: + """FieldSet class that holds hydrodynamic data needed to execute particles. + + Parameters + ---------- + ds : xarray.Dataset | uxarray.UxDataset) + xarray.Dataset and/or uxarray.UxDataset objects containing the field data. + + Notes + ----- + The `ds` object is a xarray.Dataset or uxarray.UxDataset object. + In XArray terminology, the (Ux)Dataset holds multiple (Ux)DataArray objects. + Each (Ux)DataArray object is a single "field" that is associated with their own + dimensions and coordinates within the (Ux)Dataset. + + A (Ux)Dataset object is associated with a single mesh, which can have multiple + types of "points" (multiple "grids") (e.g. for UxDataSets, these are "face_lon", + "face_lat", "node_lon", "node_lat", "edge_lon", "edge_lat"). Each (Ux)DataArray is + registered to a specific set of points on the mesh. + + For UxDataset objects, each `UXDataArray.attributes` field dictionary contains + the necessary metadata to help determine which set of points a field is registered + to and what parent model the field is associated with. Parcels uses this metadata + during execution for interpolation. Each `UXDataArray.attributes` field dictionary + must have: + * "location" key set to "face", "node", or "edge" to define which pairing of points a field is associated with. + * "mesh" key to define which parent model the fields are associated with (e.g. "fesom_mesh", "icon_mesh") + + """ + + def __init__(self, fields: list[Field | VectorField]): + for field in fields: + if not isinstance(field, (Field, VectorField)): + raise ValueError(f"Expected `field` to be a Field or VectorField object. Got {field}") + assert_compatible_calendars(fields) + + self.fields = {f.name: f for f in fields} + self.constants: dict[str, float] = {} + + def __getattr__(self, name): + """Get the field by name. If the field is not found, check if it's a constant.""" + if name in self.fields: + return self.fields[name] + elif name in self.constants: + return self.constants[name] + else: + raise AttributeError(f"FieldSet has no attribute '{name}'") + + @property + def time_interval(self): + """Returns the valid executable time interval of the FieldSet, + which is the intersection of the time intervals of all fields + in the FieldSet. + """ + time_intervals = (f.time_interval for f in self.fields.values()) + + # Filter out Nones from constant Fields + time_intervals = [t for t in time_intervals if t is not None] + if len(time_intervals) == 0: # All fields are constant fields + return None + return functools.reduce(lambda x, y: x.intersection(y), time_intervals) + + def add_field(self, field: Field, name: str | None = None): + """Add a :class:`parcels.field.Field` object to the FieldSet. + + Parameters + ---------- + field : parcels.field.Field + Field object to be added + name : str + Name of the :class:`parcels.field.Field` object to be added. Defaults + to name in Field object. + + + Examples + -------- + For usage examples see the following tutorials: + + * `Unit converters <../examples/tutorial_unitconverters.ipynb>`__ (Default value = None) + + """ + if not isinstance(field, (Field, VectorField)): + raise ValueError(f"Expected `field` to be a Field or VectorField object. Got {type(field)}") + assert_compatible_calendars((*self.fields.values(), field)) + + name = field.name if name is None else name + + if name in self.fields: + raise ValueError(f"FieldSet already has a Field with name '{name}'") + + self.fields[name] = field + + def add_constant_field(self, name: str, value, mesh: Mesh = "flat"): + """Wrapper function to add a Field that is constant in space, + useful e.g. when using constant horizontal diffusivity + + Parameters + ---------- + name : str + Name of the :class:`parcels.field.Field` object to be added + value : + Value of the constant field + mesh : str + String indicating the type of mesh coordinates and + units used during velocity interpolation, see also `this tutorial <../examples/tutorial_unitconverters.ipynb>`__: + + 1. spherical (default): Lat and lon in degree, with a + correction for zonal velocity U near the poles. + 2. flat: No conversion, lat/lon are assumed to be in m. + """ + ds = xr.Dataset({name: (["time", "lat", "lon", "depth"], np.full((1, 1, 1, 1), value))}) + grid = XGrid(xgcm.Grid(ds, **_DEFAULT_XGCM_KWARGS)) + self.add_field( + Field( + name, + ds[name], + grid, + interp_method=None, # TODO : Need to define an interpolation method for constants + ) + ) + + def add_constant(self, name, value): + """Add a constant to the FieldSet. Note that all constants are + stored as 32-bit floats. + + Parameters + ---------- + name : str + Name of the constant + value : + Value of the constant (stored as 32-bit float) + + + Examples + -------- + Tutorials using fieldset.add_constant: + `Analytical advection <../examples/tutorial_analyticaladvection.ipynb>`__ + `Diffusion <../examples/tutorial_diffusion.ipynb>`__ + `Periodic boundaries <../examples/tutorial_periodic_boundaries.ipynb>`__ + """ + if name in self.constants: + raise ValueError(f"FieldSet already has a constant with name '{name}'") + if not isinstance(value, (float, np.floating, int, np.integer)): + raise ValueError(f"FieldSet constants have to be of type float or int, got a {type(value)}") + self.constants[name] = np.float32(value) + + @property + def gridset(self) -> list[BaseGrid]: + grids = [] + for field in self.fields.values(): + if field.grid not in grids: + grids.append(field.grid) + return grids + + def from_copernicusmarine(ds: xr.Dataset): + """Create a FieldSet from a Copernicus Marine Service xarray.Dataset. + + Parameters + ---------- + ds : xarray.Dataset + xarray.Dataset as obtained from the copernicusmarine toolbox. + + Returns + ------- + FieldSet + FieldSet object containing the fields from the dataset that can be used for a Parcels simulation. + + Notes + ----- + See https://help.marine.copernicus.eu/en/collections/9080063-copernicus-marine-toolbox for more information on the copernicusmarine toolbox. + The toolbox to ingest data from most of the products on the Copernicus Marine Service (https://data.marine.copernicus.eu/products) into an xarray.Dataset. + You can use indexing and slicing to select a subset of the data before passing it to this function. + Note that most Parcels uses will require both U and V fields to be present in the dataset. This function will try to find out which variables in the dataset correspond to U and V. + To override the automatic detection, rename the appropriate variables in your dataset to 'U' and 'V' before passing it to this function. + + """ + ds = ds.copy() + ds = _discover_copernicusmarine_U_and_V(ds) + expected_axes = set("XYZT") # TODO: Update after we have support for 2D spatial fields + if missing_axes := (expected_axes - set(ds.cf.axes)): + raise ValueError( + f"Dataset missing axes {missing_axes} to have coordinates for all {expected_axes} axes according to CF conventions." + ) + + ds = _rename_coords_copernicusmarine(ds) + grid = XGrid( + xgcm.Grid( + ds, + coords={ + "X": { + "left": "lon", + }, + "Y": { + "left": "lat", + }, + "Z": { + "left": "depth", + }, + "T": { + "center": "time", + }, + }, + autoparse_metadata=False, + **_DEFAULT_XGCM_KWARGS, + ) + ) + + fields = {} + if "U" in ds.data_vars and "V" in ds.data_vars: + fields["U"] = Field("U", ds["U"], grid) + fields["V"] = Field("V", ds["V"], grid) + fields["U"].units = GeographicPolar() + fields["V"].units = Geographic() + + if "W" in ds.data_vars: + ds["W"] -= ds[ + "W" + ] # Negate W to convert from up positive to down positive (as that's the direction of positive depth) + fields["W"] = Field("W", ds["W"], grid) + fields["UVW"] = VectorField("UVW", fields["U"], fields["V"], fields["W"]) + else: + fields["UV"] = VectorField("UV", fields["U"], fields["V"]) + + for varname in set(ds.data_vars) - set(fields.keys()): + fields[varname] = Field(varname, ds[varname], grid) + + return FieldSet(list(fields.values())) + + +class CalendarError(Exception): # TODO: Move to a parcels errors module + """Exception raised when the calendar of a field is not compatible with the rest of the Fields. The user should ensure that they only add fields to a FieldSet that have compatible CFtime calendars.""" + + +def assert_compatible_calendars(fields: Iterable[Field | VectorField]): + time_intervals = [f.time_interval for f in fields if f.time_interval is not None] + + if len(time_intervals) == 0: # All time intervals are none + return + + reference_datetime_object = time_intervals[0].left + + for field in fields: + if field.time_interval is None: + continue + + if not datetime_is_compatible(reference_datetime_object, field.time_interval.left): + msg = _format_calendar_error_message(field, reference_datetime_object) + raise CalendarError(msg) + + +def _datetime_to_msg(example_datetime: TimeLike) -> str: + datetime_type, calendar = get_datetime_type_calendar(example_datetime) + msg = str(datetime_type) + if calendar is not None: + msg += f" with cftime calendar {calendar}'" + return msg + + +def _format_calendar_error_message(field: Field, reference_datetime: TimeLike) -> str: + return f"Expected field {field.name!r} to have calendar compatible with datetime object {_datetime_to_msg(reference_datetime)}. Got field with calendar {_datetime_to_msg(field.time_interval.left)}. Have you considered using xarray to update the time dimension of the dataset to have a compatible calendar?" + + +_COPERNICUS_MARINE_AXIS_VARNAMES = { + "X": "lon", + "Y": "lat", + "Z": "depth", + "T": "time", +} + + +def _rename_coords_copernicusmarine(ds): + try: + for axis, [coord] in ds.cf.axes.items(): + ds = ds.rename({coord: _COPERNICUS_MARINE_AXIS_VARNAMES[axis]}) + except ValueError as e: + raise ValueError(f"Multiple coordinates found for Copernicus dataset on axis '{axis}'. Check your data.") from e + return ds + + +def _discover_copernicusmarine_U_and_V(ds: xr.Dataset) -> xr.Dataset: + # Assumes that the dataset has U and V data + + cf_UV_standard_name_fallbacks = [ + ( + "eastward_sea_water_velocity", + "northward_sea_water_velocity", + ), # GLOBAL_ANALYSISFORECAST_PHY_001_024, MEDSEA_ANALYSISFORECAST_PHY_006_013, BALTICSEA_ANALYSISFORECAST_PHY_003_006, BLKSEA_ANALYSISFORECAST_PHY_007_001, IBI_ANALYSISFORECAST_PHY_005_001, NWSHELF_ANALYSISFORECAST_PHY_004_013, MULTIOBS_GLO_PHY_MYNRT_015_003, MULTIOBS_GLO_PHY_W_3D_REP_015_007 + ( + "surface_geostrophic_eastward_sea_water_velocity", + "surface_geostrophic_northward_sea_water_velocity", + ), # SEALEVEL_GLO_PHY_L4_MY_008_047, SEALEVEL_EUR_PHY_L4_NRT_008_060 + ( + "geostrophic_eastward_sea_water_velocity", + "geostrophic_northward_sea_water_velocity", + ), # MULTIOBS_GLO_PHY_TSUV_3D_MYNRT_015_012 + ( + "sea_surface_wave_stokes_drift_x_velocity", + "sea_surface_wave_stokes_drift_y_velocity", + ), # GLOBAL_ANALYSISFORECAST_WAV_001_027, MEDSEA_MULTIYEAR_WAV_006_012, ARCTIC_ANALYSIS_FORECAST_WAV_002_014, BLKSEA_ANALYSISFORECAST_WAV_007_003, IBI_ANALYSISFORECAST_WAV_005_005, NWSHELF_ANALYSISFORECAST_WAV_004_014 + ("sea_water_x_velocity", "sea_water_y_velocity"), # ARCTIC_ANALYSISFORECAST_PHY_002_001 + ( + "eastward_sea_water_velocity_vertical_mean_over_pelagic_layer", + "northward_sea_water_velocity_vertical_mean_over_pelagic_layer", + ), # GLOBAL_MULTIYEAR_BGC_001_033 + ] + cf_W_standard_name_fallbacks = ["upward_sea_water_velocity", "vertical_sea_water_velocity"] + + if "W" not in ds: + for cf_standard_name_W in cf_W_standard_name_fallbacks: + if cf_standard_name_W in ds.cf.standard_names: + ds = _ds_rename_using_standard_names(ds, {cf_standard_name_W: "W"}) + break + + if "U" in ds and "V" in ds: + return ds # U and V already present + elif "U" in ds or "V" in ds: + raise ValueError( + "Dataset has only one of the two variables 'U' and 'V'. Please rename the appropriate variable in your dataset to have both 'U' and 'V' for Parcels simulation." + ) + + for cf_standard_name_U, cf_standard_name_V in cf_UV_standard_name_fallbacks: + if cf_standard_name_U in ds.cf.standard_names: + if cf_standard_name_V not in ds.cf.standard_names: + raise ValueError( + f"Dataset has variable with CF standard name {cf_standard_name_U!r}, " + f"but not the matching variable with CF standard name {cf_standard_name_V!r}. " + "Please rename the appropriate variables in your dataset to have both 'U' and 'V' for Parcels simulation." + ) + else: + continue + + ds = _ds_rename_using_standard_names(ds, {cf_standard_name_U: "U", cf_standard_name_V: "V"}) + break + return ds + + +def _ds_rename_using_standard_names(ds: xr.Dataset, name_dict: dict[str, str]) -> xr.Dataset: + for standard_name, rename_to in name_dict.items(): + name = ds.cf[standard_name].name + ds = ds.rename({name: rename_to}) + logger.info( + f"cf_xarray found variable {name!r} with CF standard name {standard_name!r} in dataset, renamed it to {rename_to!r} for Parcels simulation." + ) + return ds diff --git a/parcels/_core/index_search.py b/parcels/_core/index_search.py new file mode 100644 index 000000000..43ee60bb3 --- /dev/null +++ b/parcels/_core/index_search.py @@ -0,0 +1,320 @@ +from __future__ import annotations + +from datetime import datetime +from typing import TYPE_CHECKING + +import numpy as np + +from parcels._core.statuscodes import _raise_time_extrapolation_error + +if TYPE_CHECKING: + from parcels._core.field import Field + from parcels.xgrid import XGrid + + +GRID_SEARCH_ERROR = -3 +LEFT_OUT_OF_BOUNDS = -2 +RIGHT_OUT_OF_BOUNDS = -1 + + +def _search_1d_array( + arr: np.array, + x: float, +) -> tuple[int, int]: + """ + Searches for particle locations in a 1D array and returns barycentric coordinate along dimension. + + Assumptions: + - array is strictly monotonically increasing. + + Parameters + ---------- + arr : np.array + 1D array to search in. + x : float + Position in the 1D array to search for. + + Returns + ------- + array of int + Index of the element just before the position x in the array. Note that this index is -2 if the index is left out of bounds and -1 if the index is right out of bounds. + array of float + Barycentric coordinate. + """ + # TODO v4: We probably rework this to deal with 0D arrays before this point (as we already know field dimensionality) + if len(arr) < 2: + return np.zeros(shape=x.shape, dtype=np.int32), np.zeros_like(x) + index = np.searchsorted(arr, x, side="right") - 1 + # Use broadcasting to avoid repeated array access + arr_index = arr[index] + arr_next = arr[np.clip(index + 1, 1, len(arr) - 1)] # Ensure we don't go out of bounds + bcoord = (x - arr_index) / (arr_next - arr_index) + + # TODO check how we can avoid searchsorted when grid spacing is uniform + # dx = arr[1] - arr[0] + # index = ((x - arr[0]) / dx).astype(int) + # index = np.clip(index, 0, len(arr) - 2) + # bcoord = (x - arr[index]) / dx + + index = np.where(x < arr[0], LEFT_OUT_OF_BOUNDS, index) + index = np.where(x >= arr[-1], RIGHT_OUT_OF_BOUNDS, index) + + return np.atleast_1d(index), np.atleast_1d(bcoord) + + +def _search_time_index(field: Field, time: datetime): + """Find and return the index and relative coordinate in the time array associated with a given time. + + Parameters + ---------- + field: Field + + time: datetime + This is the amount of time, in seconds (time_delta), in unix epoch + Note that we normalize to either the first or the last index + if the sampled value is outside the time value range. + """ + if field.time_interval is None: + return np.zeros(shape=time.shape, dtype=np.float32), np.zeros(shape=time.shape, dtype=np.int32) + + if not field.time_interval.is_all_time_in_interval(time): + _raise_time_extrapolation_error(time, field=None) + + ti = np.searchsorted(field.data.time.data, time, side="right") - 1 + tau = (time - field.data.time.data[ti]) / (field.data.time.data[ti + 1] - field.data.time.data[ti]) + return np.atleast_1d(tau), np.atleast_1d(ti) + + +def curvilinear_point_in_cell(grid, y: np.ndarray, x: np.ndarray, yi: np.ndarray, xi: np.ndarray): + xsi = eta = -1.0 * np.ones(len(x), dtype=float) + invA = np.array( + [ + [1, 0, 0, 0], + [-1, 1, 0, 0], + [-1, 0, 0, 1], + [1, -1, 1, -1], + ] + ) + + px = np.array([grid.lon[yi, xi], grid.lon[yi, xi + 1], grid.lon[yi + 1, xi + 1], grid.lon[yi + 1, xi]]) + py = np.array([grid.lat[yi, xi], grid.lat[yi, xi + 1], grid.lat[yi + 1, xi + 1], grid.lat[yi + 1, xi]]) + + a, b = np.dot(invA, px), np.dot(invA, py) + aa = a[3] * b[2] - a[2] * b[3] + bb = a[3] * b[0] - a[0] * b[3] + a[1] * b[2] - a[2] * b[1] + x * b[3] - y * a[3] + cc = a[1] * b[0] - a[0] * b[1] + x * b[1] - y * a[1] + det2 = bb * bb - 4 * aa * cc + + with np.errstate(divide="ignore", invalid="ignore"): + det = np.where(det2 > 0, np.sqrt(det2), eta) + eta = np.where(abs(aa) < 1e-12, -cc / bb, np.where(det2 > 0, (-bb + det) / (2 * aa), eta)) + + xsi = np.where( + abs(a[1] + a[3] * eta) < 1e-12, + ((y - py[0]) / (py[1] - py[0]) + (y - py[3]) / (py[2] - py[3])) * 0.5, + (x - a[0] - a[2] * eta) / (a[1] + a[3] * eta), + ) + + is_in_cell = np.where((xsi >= 0) & (xsi <= 1) & (eta >= 0) & (eta <= 1), 1, 0) + + return is_in_cell, np.column_stack((xsi, eta)) + + +def _search_indices_curvilinear_2d( + grid: XGrid, y: np.ndarray, x: np.ndarray, yi: np.ndarray | None = None, xi: np.ndarray | None = None +): + """Searches a grid for particle locations in 2D curvilinear coordinates. + + Parameters + ---------- + grid : XGrid + The curvilinear grid to search within. + y : np.ndarray + Array of latitude-coordinates of the points to locate. + x : np.ndarray + Array of longitude-coordinates of the points to locate. + yi : np.ndarray | None, optional + Array of initial guesses for the j indices of the points to locate. + xi : np.ndarray | None, optional + Array of initial guesses for the i indices of the points to locate. + + Returns + ------- + tuple + A tuple containing four elements: + - yi (np.ndarray): Array of found j-indices corresponding to the input coordinates. + - eta (np.ndarray): Array of barycentric coordinates in the j-direction within the found grid cells. + - xi (np.ndarray): Array of found i-indices corresponding to the input cooordinates. + - xsi (np.ndarray): Array of barycentric coordinates in the i-direction within the found grid cells. + """ + if np.any(xi): + # If an initial guess is provided, we first perform a point in cell check for all guessed indices + is_in_cell, coords = curvilinear_point_in_cell(grid, y, x, yi, xi) + y_check = y[is_in_cell == 0] + x_check = x[is_in_cell == 0] + zero_indices = np.where(is_in_cell == 0)[0] + else: + # Otherwise, we need to check all points + yi = np.full(len(y), GRID_SEARCH_ERROR, dtype=np.int32) + xi = np.full(len(x), GRID_SEARCH_ERROR, dtype=np.int32) + y_check = y + x_check = x + coords = -1.0 * np.ones((len(y), 2), dtype=np.float32) + zero_indices = np.arange(len(y)) + + # If there are any points that were not found in the first step, we query the spatial hash for those points + if len(zero_indices) > 0: + yi_q, xi_q, coords_q = grid.get_spatial_hash().query(y_check, x_check) + # Only those points that were not found in the first step are updated + coords[zero_indices, :] = coords_q + yi[zero_indices] = yi_q + xi[zero_indices] = xi_q + + xsi = coords[:, 0] + eta = coords[:, 1] + + return (yi, eta, xi, xsi) + + +def uxgrid_point_in_cell(grid, y: np.ndarray, x: np.ndarray, yi: np.ndarray, xi: np.ndarray): + """Check if points are inside the grid cells defined by the given face indices. + + Parameters + ---------- + grid : ux.grid.Grid + The uxarray grid object containing the unstructured grid data. + y : np.ndarray + Array of latitudes of the points to check. + x : np.ndarray + Array of longitudes of the points to check. + yi : np.ndarray + Array of face indices corresponding to the points. + xi : np.ndarray + Not used, but included for compatibility with other search functions. + + Returns + ------- + is_in_cell : np.ndarray + An array indicating whether each point is inside (1) or outside (0) the corresponding cell. + coords : np.ndarray + Barycentric coordinates of the points within their respective cells. + """ + if grid._mesh == "spherical": + lon_rad = np.deg2rad(x) + lat_rad = np.deg2rad(y) + x_cart, y_cart, z_cart = _latlon_rad_to_xyz(lat_rad, lon_rad) + points = np.column_stack((x_cart.flatten(), y_cart.flatten(), z_cart.flatten())) + + # Get the vertex indices for each face + nids = grid.uxgrid.face_node_connectivity[yi].values + face_vertices = np.stack( + ( + grid.uxgrid.node_x[nids.ravel()].values.reshape(nids.shape), + grid.uxgrid.node_y[nids.ravel()].values.reshape(nids.shape), + grid.uxgrid.node_z[nids.ravel()].values.reshape(nids.shape), + ), + axis=-1, + ) + else: + nids = grid.uxgrid.face_node_connectivity[yi].values + face_vertices = np.stack( + ( + grid.uxgrid.node_lon[nids.ravel()].values.reshape(nids.shape), + grid.uxgrid.node_lat[nids.ravel()].values.reshape(nids.shape), + ), + axis=-1, + ) + points = np.stack((x, y), axis=-1) + + M = len(points) + + is_in_cell = np.zeros(M, dtype=np.int32) + + coords = _barycentric_coordinates(face_vertices, points) + is_in_cell = np.where(np.all((coords >= -1e-6) & (coords <= 1 + 1e-6), axis=1), 1, 0) + + return is_in_cell, coords + + +def _triangle_area(A, B, C): + """Compute the area of a triangle given by three points.""" + d1 = B - A + d2 = C - A + if A.shape[-1] == 2: + # 2D case: cross product reduces to scalar z-component + cross = d1[..., 0] * d2[..., 1] - d1[..., 1] * d2[..., 0] + area = 0.5 * np.abs(cross) + elif A.shape[-1] == 3: + # 3D case: full vector cross product + cross = np.cross(d1, d2) + area = 0.5 * np.linalg.norm(cross, axis=-1) + else: + raise ValueError(f"Expected last dim=2 or 3, got {A.shape[-1]}") + + return area + + +def _barycentric_coordinates(nodes, points, min_area=1e-8): + """ + Compute the barycentric coordinates of a point P inside a convex polygon using area-based weights. + So that this method generalizes to n-sided polygons, we use the Waschpress points as the generalized + barycentric coordinates, which is only valid for convex polygons. + + Parameters + ---------- + nodes : numpy.ndarray + Polygon verties per query of shape (M, 3, 2/3) where M is the number of query points. The second dimension corresponds to the number + of vertices + The last dimension can be either 2 or 3, where 3 corresponds to the (z, y, x) coordinates of each vertex and 2 corresponds to the + (lat, lon) coordinates of each vertex. + + points : numpy.ndarray + Spherical coordinates of the point (M,2/3) where M is the number of query points. + + Returns + ------- + numpy.ndarray + Barycentric coordinates corresponding to each vertex. + + """ + M, K = nodes.shape[:2] + + # roll(-1) to get vi+1, roll(+1) to get vi-1 + vi = nodes # (M,K,2) + vi1 = np.roll(nodes, shift=-1, axis=1) # (M,K,2) + vim1 = np.roll(nodes, shift=+1, axis=1) # (M,K,2) + + # a0 = area(v_{i-1}, v_i, v_{i+1}) + a0 = _triangle_area(vim1, vi, vi1) # (M,K) + + # a1 = area(P, v_{i-1}, v_i); a2 = area(P, v_i, v_{i+1}) + P = points[:, None, :] # (M,1,2) -> (M,K,2) + a1 = _triangle_area(P, vim1, vi) + a2 = _triangle_area(P, vi, vi1) + + # clamp tiny denominators for stability + a1c = np.maximum(a1, min_area) + a2c = np.maximum(a2, min_area) + + wi = a0 / (a1c * a2c) # (M,K) + + sum_wi = wi.sum(axis=1, keepdims=True) # (M,1) + # Avoid 0/0: if sum_wi==0 (degenerate), keep zeros + with np.errstate(invalid="ignore", divide="ignore"): + bcoords = wi / sum_wi + + return bcoords + + +def _latlon_rad_to_xyz( + lat, + lon, +): + """Converts Spherical latitude and longitude coordinates into Cartesian x, + y, z coordinates. + """ + x = np.cos(lon) * np.cos(lat) + y = np.sin(lon) * np.cos(lat) + z = np.sin(lat) + + return x, y, z diff --git a/parcels/_core/kernel.py b/parcels/_core/kernel.py new file mode 100644 index 000000000..cbcc5d2cd --- /dev/null +++ b/parcels/_core/kernel.py @@ -0,0 +1,291 @@ +from __future__ import annotations + +import math # noqa: F401 +import random # noqa: F401 +import types +import warnings +from typing import TYPE_CHECKING + +import numpy as np + +from parcels._core.basegrid import GridType +from parcels._core.statuscodes import ( + StatusCode, + _raise_field_interpolation_error, + _raise_field_out_of_bound_error, + _raise_field_out_of_bound_surface_error, + _raise_general_error, + _raise_grid_searching_error, + _raise_time_extrapolation_error, +) +from parcels._core.warnings import KernelWarning +from parcels.kernels import ( + AdvectionAnalytical, + AdvectionRK4, + AdvectionRK45, +) +from parcels.utils._helpers import _assert_same_function_signature + +if TYPE_CHECKING: + from collections.abc import Callable + +__all__ = ["Kernel"] + + +ErrorsToThrow = { + StatusCode.ErrorTimeExtrapolation: _raise_time_extrapolation_error, + StatusCode.ErrorOutOfBounds: _raise_field_out_of_bound_error, + StatusCode.ErrorThroughSurface: _raise_field_out_of_bound_surface_error, + StatusCode.ErrorInterpolation: _raise_field_interpolation_error, + StatusCode.ErrorGridSearching: _raise_grid_searching_error, + StatusCode.Error: _raise_general_error, +} + + +class Kernel: + """Kernel object that encapsulates auto-generated code. + + Parameters + ---------- + fieldset : parcels.Fieldset + FieldSet object providing the field information (possibly None) + ptype : + PType object for the kernel particle + pyfunc : + (aggregated) Kernel function + + Notes + ----- + A Kernel is either created from a object + or an ast.FunctionDef object. + """ + + def __init__( + self, + fieldset, + ptype, + pyfuncs: list[types.FunctionType], + ): + for f in pyfuncs: + if not isinstance(f, types.FunctionType): + raise TypeError(f"Argument pyfunc should be a function or list of functions. Got {type(f)}") + _assert_same_function_signature(f, ref=AdvectionRK4, context="Kernel") + + if len(pyfuncs) == 0: + raise ValueError("List of `pyfuncs` should have at least one function.") + + self._fieldset = fieldset + self._ptype = ptype + + self._positionupdate_kernels_added = False + + for f in pyfuncs: + self.check_fieldsets_in_kernels(f) + + # # TODO will be implemented when we support CROCO again + # if (pyfunc is AdvectionRK4_3D) and fieldset.U.gridindexingtype == "croco": + # pyfunc = AdvectionRK4_3D_CROCO + + self._pyfuncs: list[Callable] = pyfuncs + + @property #! Ported from v3. To be removed in v4? (/find another way to name kernels in output file) + def funcname(self): + ret = "" + for f in self._pyfuncs: + ret += f.__name__ + return ret + + @property + def ptype(self): + return self._ptype + + @property + def fieldset(self): + return self._fieldset + + def remove_deleted(self, pset): + """Utility to remove all particles that signalled deletion.""" + bool_indices = pset._data["state"] == StatusCode.Delete + indices = np.where(bool_indices)[0] + # TODO v4: need to implement ParticleFile writing of deleted particles + # if len(indices) > 0 and self.fieldset.particlefile is not None: + # self.fieldset.particlefile.write(pset, None, indices=indices) + if len(indices) > 0: + pset.remove_indices(indices) + + def add_positionupdate_kernels(self): + # Adding kernels that set and update the coordinate changes + def Setcoords(particles, fieldset): # pragma: no cover + import numpy as np # noqa + + particles.lon += particles.dlon + particles.lat += particles.dlat + particles.depth += particles.ddepth + + particles.dlon = 0 + particles.dlat = 0 + particles.ddepth = 0 + + particles.time = particles.time_nextloop + + def UpdateTime(particles, fieldset): # pragma: no cover + particles.time_nextloop = particles.time + particles.dt + + self._pyfuncs = (Setcoords + self + UpdateTime)._pyfuncs + + def check_fieldsets_in_kernels(self, pyfunc): # TODO v4: this can go into another method? assert_is_compatible()? + """ + Checks the integrity of the fieldset with the kernels. + + This function is to be called from the derived class when setting up the 'pyfunc'. + """ + if self.fieldset is not None: + if pyfunc is AdvectionAnalytical: + if self._fieldset.U.interp_method != "cgrid_velocity": + raise NotImplementedError("Analytical Advection only works with C-grids") + if self._fieldset.U.grid._gtype not in [GridType.CurvilinearZGrid, GridType.RectilinearZGrid]: + raise NotImplementedError("Analytical Advection only works with Z-grids in the vertical") + elif pyfunc is AdvectionRK45: + if not hasattr(self.fieldset, "RK45_tol"): + warnings.warn( + "Setting RK45 tolerance to 10 m. Use fieldset.add_constant('RK45_tol', [distance]) to change.", + KernelWarning, + stacklevel=2, + ) + self.fieldset.add_constant("RK45_tol", 10) + if self.fieldset.U.grid._mesh == "spherical": + self.fieldset.RK45_tol /= ( + 1852 * 60 + ) # TODO does not account for zonal variation in meter -> degree conversion + if not hasattr(self.fieldset, "RK45_min_dt"): + warnings.warn( + "Setting RK45 minimum timestep to 1 s. Use fieldset.add_constant('RK45_min_dt', [timestep]) to change.", + KernelWarning, + stacklevel=2, + ) + self.fieldset.add_constant("RK45_min_dt", 1) + if not hasattr(self.fieldset, "RK45_max_dt"): + warnings.warn( + "Setting RK45 maximum timestep to 1 day. Use fieldset.add_constant('RK45_max_dt', [timestep]) to change.", + KernelWarning, + stacklevel=2, + ) + self.fieldset.add_constant("RK45_max_dt", 60 * 60 * 24) + + def merge(self, kernel): + if not isinstance(kernel, type(self)): + raise TypeError(f"Cannot merge {type(kernel)} with {type(self)}. Both should be of type {type(self)}.") + + assert self.fieldset == kernel.fieldset, "Cannot merge kernels with different fieldsets" + assert self.ptype == kernel.ptype, "Cannot merge kernels with different particle types" + + return type(self)( + self.fieldset, + self.ptype, + pyfuncs=self._pyfuncs + kernel._pyfuncs, + ) + + def __add__(self, kernel): + if isinstance(kernel, types.FunctionType): + kernel = type(self)(self.fieldset, self.ptype, pyfuncs=[kernel]) + return self.merge(kernel) + + def __radd__(self, kernel): + if isinstance(kernel, types.FunctionType): + kernel = type(self)(self.fieldset, self.ptype, pyfuncs=[kernel]) + return kernel.merge(self) + + @classmethod + def from_list(cls, fieldset, ptype, pyfunc_list): + """Create a combined kernel from a list of functions. + + Takes a list of functions, converts them to kernels, and joins them + together. + + Parameters + ---------- + fieldset : parcels.Fieldset + FieldSet object providing the field information (possibly None) + ptype : + PType object for the kernel particle + pyfunc_list : list of functions + List of functions to be combined into a single kernel. + *args : + Additional arguments passed to first kernel during construction. + **kwargs : + Additional keyword arguments passed to first kernel during construction. + """ + if not isinstance(pyfunc_list, list): + raise TypeError(f"Argument `pyfunc_list` should be a list of functions. Got {type(pyfunc_list)}") + if not all([isinstance(f, types.FunctionType) for f in pyfunc_list]): + raise ValueError("Argument `pyfunc_list` should be a list of functions.") + + return cls(fieldset, ptype, pyfunc_list) + + def execute(self, pset, endtime, dt): + """Execute this Kernel over a ParticleSet for several timesteps. + + Parameters + ---------- + pset : + object of (sub-)type ParticleSet + endtime : + endtime of this overall kernel evaluation step + dt : + computational integration timestep from pset.execute + """ + compute_time_direction = 1 if dt > 0 else -1 + + pset._data["state"][:] = StatusCode.Evaluate + + if not self._positionupdate_kernels_added: + self.add_positionupdate_kernels() + self._positionupdate_kernels_added = True + + while (len(pset) > 0) and np.any(np.isin(pset.state, [StatusCode.Evaluate, StatusCode.Repeat])): + time_to_endtime = compute_time_direction * (endtime - pset.time_nextloop) + + if all(time_to_endtime <= 0): + return StatusCode.Success + + # adapt dt to end exactly on endtime + if compute_time_direction == 1: + pset.dt = np.maximum(np.minimum(pset.dt, time_to_endtime), 0) + else: + pset.dt = np.minimum(np.maximum(pset.dt, -time_to_endtime), 0) + + # run kernels for all particles that need to be evaluated + evaluate_particles = (pset.state == StatusCode.Evaluate) & (pset.dt != 0) + for f in self._pyfuncs: + f(pset[evaluate_particles], self._fieldset) + + # check for particles that have to be repeated + repeat_particles = pset.state == StatusCode.Repeat + while np.any(repeat_particles): + f(pset[repeat_particles], self._fieldset) + repeat_particles = pset.state == StatusCode.Repeat + + # revert to original dt (unless in RK45 mode) + if not hasattr(self.fieldset, "RK45_tol"): + pset._data["dt"][:] = dt + + # Reset particle state for particles that signalled success and have not reached endtime yet + particles_to_evaluate = (pset.state == StatusCode.Success) & (time_to_endtime > 0) + pset[particles_to_evaluate].state = StatusCode.Evaluate + + # delete particles that signalled deletion + self.remove_deleted(pset) + + # check and throw errors + if np.any(pset.state == StatusCode.StopAllExecution): + return StatusCode.StopAllExecution + + for error_code, error_func in ErrorsToThrow.items(): + if np.any(pset.state == error_code): + inds = pset.state == error_code + if error_code == StatusCode.ErrorTimeExtrapolation: + error_func(pset[inds].time) + else: + error_func(pset[inds].depth, pset[inds].lat, pset[inds].lon) + + return pset diff --git a/parcels/_core/particle.py b/parcels/_core/particle.py new file mode 100644 index 000000000..4d3ff0945 --- /dev/null +++ b/parcels/_core/particle.py @@ -0,0 +1,278 @@ +from __future__ import annotations + +import enum +import operator +from keyword import iskeyword +from typing import Literal + +import numpy as np + +from parcels._compat import _attrgetter_helper +from parcels._core.statuscodes import StatusCode +from parcels._core.utils.time import TimeInterval +from parcels._reprs import _format_list_items_multiline + +__all__ = ["KernelParticle", "Particle", "ParticleClass", "Variable"] +_TO_WRITE_OPTIONS = [True, False, "once"] + +_SAME_AS_FIELDSET_TIME_INTERVAL = enum.Enum("_SAME_AS_FIELDSET_TIME_INTERVAL", "VALUE") + + +class Variable: + """Descriptor class that delegates data access to particle data. + + Parameters + ---------- + name : str + Variable name as used within kernels + dtype : + Data type (numpy.dtype) of the variable + initial : + Initial value of the variable. Note that this can also be a Field object, + which will then be sampled at the location of the particle + to_write : bool, 'once', optional + Boolean or 'once'. Controls whether Variable is written to NetCDF file. + If to_write = 'once', the variable will be written as a time-independent 1D array + attrs : dict, optional + Attributes to be stored with the variable when written to file. This can include metadata such as units, long_name, etc. + """ + + def __init__( + self, + name, + dtype: np.dtype | _SAME_AS_FIELDSET_TIME_INTERVAL = np.float32, + initial=0, + to_write: bool | Literal["once"] = True, + attrs: dict | None = None, + ): + if not isinstance(name, str): + raise TypeError(f"Variable name must be a string. Got {name=!r}") + _assert_valid_python_varname(name) + + try: + dtype = np.dtype(dtype) + except (TypeError, ValueError) as e: + if dtype is not _SAME_AS_FIELDSET_TIME_INTERVAL.VALUE: + raise TypeError(f"Variable dtype must be a valid numpy dtype. Got {dtype=!r}") from e + + if to_write not in _TO_WRITE_OPTIONS: + raise ValueError(f"to_write must be one of {_TO_WRITE_OPTIONS!r}. Got {to_write=!r}") + + if attrs is None: + attrs = {} + + if not to_write: + if attrs != {}: + raise ValueError(f"Attributes cannot be set if {to_write=!r}.") + + self._name = name + self.dtype = dtype + self.initial = initial + self.to_write = to_write + self.attrs = attrs + + @property + def name(self): + return self._name + + def __repr__(self): + return f"Variable(name={self._name!r}, dtype={self.dtype!r}, initial={self.initial!r}, to_write={self.to_write!r}, attrs={self.attrs!r})" + + +class ParticleClass: + """Define a class of particles. This is used to generate the particle data which is then used in the simulation. + + Parameters + ---------- + variables : list[Variable] + List of Variable objects that define the particle's attributes. + + """ + + def __init__(self, variables: list[Variable]): + if not isinstance(variables, list): + raise TypeError(f"Expected list of Variable objects, got {type(variables)}") + if not all(isinstance(var, Variable) for var in variables): + raise ValueError(f"All items in variables must be instances of Variable. Got {variables=!r}") + + self.variables = variables + + def __repr__(self): + vars = [repr(v) for v in self.variables] + return f"ParticleClass(variables={_format_list_items_multiline(vars)})" + + def add_variable(self, variable: Variable | list[Variable]): + """Add a new variable to the Particle class. This returns a new Particle class with the added variable(s). + + Parameters + ---------- + variable : Variable or list[Variable] + Variable or list of Variables to be added to the Particle class. + If a list is provided, all variables will be added to the class. + """ + if isinstance(variable, Variable): + variable = [variable] + + for var in variable: + if not isinstance(var, Variable): + raise TypeError(f"Expected Variable, got {type(var)}") + + _assert_no_duplicate_variable_names(existing_vars=self.variables, new_vars=variable) + + return ParticleClass(variables=self.variables + variable) + + +class KernelParticle: + """Simple class to be used in a kernel that links a particle (on the kernel level) to a particle dataset.""" + + def __init__(self, data, index): + self._data = data + self._index = index + + def __getattr__(self, name): + return self._data[name][self._index] + + def __setattr__(self, name, value): + if name in ["_data", "_index"]: + object.__setattr__(self, name, value) + else: + self._data[name][self._index] = value + + def __getitem__(self, index): + self._index = index + return self + + def __len__(self): + return len(self._index) + + +def _assert_no_duplicate_variable_names(*, existing_vars: list[Variable], new_vars: list[Variable]): + existing_names = {var.name for var in existing_vars} + for var in new_vars: + if var.name in existing_names: + raise ValueError(f"Variable name already exists: {var.name}") + + +def _assert_valid_python_varname(name): + if name.isidentifier() and not iskeyword(name): + return + raise ValueError(f"Particle variable has to be a valid Python variable name. Got {name=!r}") + + +def get_default_particle(spatial_dtype: np.float32 | np.float64) -> ParticleClass: + if spatial_dtype not in [np.float32, np.float64]: + raise ValueError(f"spatial_dtype must be np.float32 or np.float64. Got {spatial_dtype=!r}") + + return ParticleClass( + variables=[ + Variable( + "lon", + dtype=spatial_dtype, + attrs={"standard_name": "longitude", "units": "degrees_east", "axis": "X"}, + ), + Variable( + "lat", + dtype=spatial_dtype, + attrs={"standard_name": "latitude", "units": "degrees_north", "axis": "Y"}, + ), + Variable( + "depth", + dtype=spatial_dtype, + attrs={"standard_name": "depth", "units": "m", "positive": "down"}, + ), + Variable("dlon", dtype=spatial_dtype, to_write=False), + Variable("dlat", dtype=spatial_dtype, to_write=False), + Variable("ddepth", dtype=spatial_dtype, to_write=False), + Variable( + "time", + dtype=_SAME_AS_FIELDSET_TIME_INTERVAL.VALUE, + attrs={"standard_name": "time", "units": "seconds", "axis": "T"}, + ), + Variable("time_nextloop", dtype=_SAME_AS_FIELDSET_TIME_INTERVAL.VALUE, to_write=False), + Variable( + "trajectory", + dtype=np.int64, + to_write="once", + attrs={ + "long_name": "Unique identifier for each particle", + "cf_role": "trajectory_id", + }, + ), + Variable("obs_written", dtype=np.int32, initial=0, to_write=False), + Variable("dt", dtype="timedelta64[s]", initial=np.timedelta64(1, "s"), to_write=False), + Variable("state", dtype=np.int32, initial=StatusCode.Evaluate, to_write=False), + ] + ) + + +Particle = get_default_particle(np.float32) + + +def create_particle_data( + *, + pclass: ParticleClass, + nparticles: int, + ngrids: int, + time_interval: TimeInterval, + initial: dict[str, np.array] | None = None, +): + if initial is None: + initial = {} + + variables = {var.name: var for var in pclass.variables} + + assert "ei" not in initial, "'ei' is for internal use, and is unique since is only non 1D array" + + time_interval_dtype = _get_time_interval_dtype(time_interval) + + dtypes = {} + for var in variables.values(): + if var.dtype is _SAME_AS_FIELDSET_TIME_INTERVAL.VALUE: + dtypes[var.name] = time_interval_dtype + else: + dtypes[var.name] = var.dtype + + for var_name in initial: + if var_name not in variables: + raise ValueError(f"Variable {var_name} is not defined in the ParticleClass.") + + values = initial[var_name] + if values.shape != (nparticles,): + raise ValueError(f"Initial value for {var_name} must have shape ({nparticles},). Got {values.shape=}") + + initial[var_name] = values.astype(dtypes[var_name]) + + data = {"ei": np.zeros((nparticles, ngrids), dtype=np.int32), **initial} + + vars_to_create = {k: v for k, v in variables.items() if k not in data} + + for var in vars_to_create.values(): + if isinstance(var.initial, operator.attrgetter): + name_to_copy = var.initial(_attrgetter_helper) + data[var.name] = data[name_to_copy].copy() + else: + data[var.name] = _create_array_for_variable(var, nparticles, time_interval) + return data + + +def _create_array_for_variable(variable: Variable, nparticles: int, time_interval: TimeInterval): + assert not isinstance(variable.initial, operator.attrgetter), ( + "This function cannot handle attrgetter initial values." + ) + if (dtype := variable.dtype) is _SAME_AS_FIELDSET_TIME_INTERVAL.VALUE: + dtype = _get_time_interval_dtype(time_interval) + return np.full( + shape=(nparticles,), + fill_value=variable.initial, + dtype=dtype, + ) + + +def _get_time_interval_dtype(time_interval: TimeInterval | None) -> np.dtype: + if time_interval is None: + return np.timedelta64(1, "ns") + time = time_interval.left + if isinstance(time, (np.datetime64, np.timedelta64)): + return time.dtype + else: + return object # cftime objects needs to be stored as object dtype diff --git a/parcels/_core/particlefile.py b/parcels/_core/particlefile.py new file mode 100644 index 000000000..f3ae6c041 --- /dev/null +++ b/parcels/_core/particlefile.py @@ -0,0 +1,379 @@ +"""Module controlling the writing of ParticleSets to Zarr file.""" + +from __future__ import annotations + +import os +from datetime import datetime, timedelta +from pathlib import Path +from typing import TYPE_CHECKING, Literal + +import cftime +import numpy as np +import xarray as xr +import zarr +from zarr.storage import DirectoryStore + +import parcels +from parcels._core.particle import _SAME_AS_FIELDSET_TIME_INTERVAL, ParticleClass +from parcels.utils._helpers import timedelta_to_float + +if TYPE_CHECKING: + from parcels._core.particle import Variable + from parcels._core.particleset import ParticleSet + from parcels._core.utils.time import TimeInterval + +__all__ = ["ParticleFile"] + +_DATATYPES_TO_FILL_VALUES = { + np.dtype(np.float16): np.nan, + np.dtype(np.float32): np.nan, + np.dtype(np.float64): np.nan, + np.dtype(np.bool_): np.iinfo(np.int8).max, + np.dtype(np.int8): np.iinfo(np.int8).max, + np.dtype(np.int16): np.iinfo(np.int16).max, + np.dtype(np.int32): np.iinfo(np.int32).max, + np.dtype(np.int64): np.iinfo(np.int64).max, + np.dtype(np.uint8): np.iinfo(np.uint8).max, + np.dtype(np.uint16): np.iinfo(np.uint16).max, + np.dtype(np.uint32): np.iinfo(np.uint32).max, + np.dtype(np.uint64): np.iinfo(np.uint64).max, +} + + +class ParticleFile: + """Initialise trajectory output. + + Parameters + ---------- + name : str + Basename of the output file. This can also be a Zarr store object. + particleset : + ParticleSet to output + outputdt : + Interval which dictates the update frequency of file output + while ParticleFile is given as an argument of ParticleSet.execute() + It is either a timedelta object or a positive double. + chunks : + Tuple (trajs, obs) to control the size of chunks in the zarr output. + create_new_zarrfile : bool + Whether to create a new file. Default is True + + Returns + ------- + ParticleFile + ParticleFile object that can be used to write particle data to file + """ + + def __init__(self, store, outputdt, chunks=None, create_new_zarrfile=True): + if isinstance(outputdt, timedelta): + outputdt = np.timedelta64(int(outputdt.total_seconds()), "s") + + if not isinstance(outputdt, np.timedelta64): + raise ValueError(f"Expected outputdt to be a np.timedelta64 or datetime.timedelta, got {type(outputdt)}") + + self._outputdt = outputdt + + _assert_valid_chunks_tuple(chunks) + self._chunks = chunks + self._maxids = 0 + self._pids_written = {} + self.metadata = {} + self._create_new_zarrfile = create_new_zarrfile + + if not isinstance(store, zarr.storage.Store): + store = _get_store_from_pathlike(store) + + self._store = store + + # TODO v4: Enable once updating to zarr v3 + # if store.read_only: + # raise ValueError(f"Store {store} is read-only. Please provide a writable store.") + + # TODO v4: Add check that if create_new_zarrfile is False, the store already exists + + def __repr__(self) -> str: + return ( + f"{type(self).__name__}(" + f"outputdt={self.outputdt!r}, " + f"chunks={self.chunks!r}, " + f"create_new_zarrfile={self.create_new_zarrfile!r})" + ) + + def set_metadata(self, parcels_grid_mesh: Literal["spherical", "flat"]): + self.metadata.update( + { + "feature_type": "trajectory", + "Conventions": "CF-1.6/CF-1.7", + "ncei_template_version": "NCEI_NetCDF_Trajectory_Template_v2.0", + "parcels_version": parcels.__version__, + "parcels_grid_mesh": parcels_grid_mesh, + } + ) + + @property + def outputdt(self): + return self._outputdt + + @property + def chunks(self): + return self._chunks + + @property + def store(self): + return self._store + + @property + def create_new_zarrfile(self): + return self._create_new_zarrfile + + def _convert_varout_name(self, var): + if var == "depth": + return "z" + else: + return var + + def _extend_zarr_dims(self, Z, store, dtype, axis): + if axis == 1: + a = np.full((Z.shape[0], self.chunks[1]), _DATATYPES_TO_FILL_VALUES[dtype], dtype=dtype) + obs = zarr.group(store=store, overwrite=False)["obs"] + if len(obs) == Z.shape[1]: + obs.append(np.arange(self.chunks[1]) + obs[-1] + 1) + else: + extra_trajs = self._maxids - Z.shape[0] + if len(Z.shape) == 2: + a = np.full((extra_trajs, Z.shape[1]), _DATATYPES_TO_FILL_VALUES[dtype], dtype=dtype) + else: + a = np.full((extra_trajs,), _DATATYPES_TO_FILL_VALUES[dtype], dtype=dtype) + Z.append(a, axis=axis) + zarr.consolidate_metadata(store) + + def write(self, pset: ParticleSet, time, indices=None): + """Write all data from one time step to the zarr file, + before the particle locations are updated. + + Parameters + ---------- + pset : + ParticleSet object to write + time : + Time at which to write ParticleSet (same time object as fieldset) + """ + pclass = pset._ptype + time_interval = pset.fieldset.time_interval + particle_data = pset._data + time = timedelta_to_float(time - time_interval.left) + particle_data = _convert_particle_data_time_to_float_seconds(particle_data, time_interval) + + self._write_particle_data( + particle_data=particle_data, pclass=pclass, time_interval=time_interval, time=time, indices=indices + ) + + def _write_particle_data(self, *, particle_data, pclass, time_interval, time, indices=None): + # if pset._data._ncount == 0: + # warnings.warn( + # f"ParticleSet is empty on writing as array at time {time:g}", + # RuntimeWarning, + # stacklevel=2, + # ) + # return + nparticles = len(particle_data["trajectory"]) + vars_to_write = _get_vars_to_write(pclass) + if indices is None: + indices_to_write = _to_write_particles(particle_data, time) + else: + indices_to_write = indices + + if len(indices_to_write) == 0: + return + + pids = particle_data["trajectory"][indices_to_write] + to_add = sorted(set(pids) - set(self._pids_written.keys())) + for i, pid in enumerate(to_add): + self._pids_written[pid] = self._maxids + i + ids = np.array([self._pids_written[p] for p in pids], dtype=int) + self._maxids = len(self._pids_written) + + once_ids = np.where(particle_data["obs_written"][indices_to_write] == 0)[0] + if len(once_ids) > 0: + ids_once = ids[once_ids] + indices_to_write_once = indices_to_write[once_ids] + + store = self.store + if self.create_new_zarrfile: + if self.chunks is None: + self._chunks = (nparticles, 1) + if (self._maxids > len(ids)) or (self._maxids > self.chunks[0]): # type: ignore[index] + arrsize = (self._maxids, self.chunks[1]) # type: ignore[index] + else: + arrsize = (len(ids), self.chunks[1]) # type: ignore[index] + ds = xr.Dataset( + attrs=self.metadata, + coords={"trajectory": ("trajectory", pids), "obs": ("obs", np.arange(arrsize[1], dtype=np.int32))}, + ) + attrs = _create_variables_attribute_dict(pclass, time_interval) + obs = np.zeros((self._maxids), dtype=np.int32) + for var in vars_to_write: + dtype = _maybe_convert_time_dtype(var.dtype) + varout = self._convert_varout_name(var.name) + if varout not in ["trajectory"]: # because 'trajectory' is written as coordinate + if var.to_write == "once": + data = np.full( + (arrsize[0],), + _DATATYPES_TO_FILL_VALUES[dtype], + dtype=dtype, + ) + data[ids_once] = particle_data[var.name][indices_to_write_once] + dims = ["trajectory"] + else: + data = np.full(arrsize, _DATATYPES_TO_FILL_VALUES[dtype], dtype=dtype) + data[ids, 0] = particle_data[var.name][indices_to_write] + dims = ["trajectory", "obs"] + ds[varout] = xr.DataArray(data=data, dims=dims, attrs=attrs[var.name]) + ds[varout].encoding["chunks"] = self.chunks[0] if var.to_write == "once" else self.chunks # type: ignore[index] + ds.to_zarr(store, mode="w") + self._create_new_zarrfile = False + else: + Z = zarr.group(store=store, overwrite=False) + obs = particle_data["obs_written"][indices_to_write] + for var in vars_to_write: + dtype = _maybe_convert_time_dtype(var.dtype) + varout = self._convert_varout_name(var.name) + if self._maxids > Z[varout].shape[0]: + self._extend_zarr_dims(Z[varout], store, dtype=dtype, axis=0) + if var.to_write == "once": + if len(once_ids) > 0: + Z[varout].vindex[ids_once] = particle_data[var.name][indices_to_write_once] + else: + if max(obs) >= Z[varout].shape[1]: # type: ignore[type-var] + self._extend_zarr_dims(Z[varout], store, dtype=dtype, axis=1) + Z[varout].vindex[ids, obs] = particle_data[var.name][indices_to_write] + + particle_data["obs_written"][indices_to_write] = obs + 1 + + def write_latest_locations(self, pset, time): + """Write the current (latest) particle locations to zarr file. + This can be useful at the end of a pset.execute(), when the last locations are not written yet. + Note that this only updates the locations, not any of the other Variables. Therefore, use with care. + + Parameters + ---------- + pset : + ParticleSet object to write + time : + Time at which to write ParticleSet. Note that typically this would be pset.time_nextloop + """ + for var in ["lon", "lat", "depth"]: + pset._data[f"{var}"] += pset._data[f"d{var}"] + pset._data["time"] = pset._data["time_nextloop"] + self.write(pset, time) + + +def _get_store_from_pathlike(path: Path | str) -> DirectoryStore: + path = str(Path(path)) # Ensure valid path, and convert to string + extension = os.path.splitext(path)[1] + if extension != ".zarr": + raise ValueError(f"ParticleFile name must end with '.zarr' extension. Got path {path!r}.") + + return DirectoryStore(path) + + +def _get_vars_to_write(particle: ParticleClass) -> list[Variable]: + return [v for v in particle.variables if v.to_write is not False] + + +def _create_variables_attribute_dict(particle: ParticleClass, time_interval: TimeInterval) -> dict: + """Creates the dictionary with variable attributes. + + Notes + ----- + For ParticleSet structures other than SoA, and structures where ID != index, this has to be overridden. + """ + attrs = {} + + vars = [var for var in particle.variables if var.to_write is not False] + for var in vars: + fill_value = {} + if var.dtype is not _SAME_AS_FIELDSET_TIME_INTERVAL.VALUE: + fill_value = {"_FillValue": _DATATYPES_TO_FILL_VALUES[var.dtype]} + + attrs[var.name] = {**var.attrs, **fill_value} + + attrs["time"].update(_get_calendar_and_units(time_interval)) + + return attrs + + +def _to_write_particles(particle_data, time): + """Return the Particles that need to be written at time: if particle.time is between time-dt/2 and time+dt (/2)""" + return np.where( + ( + np.less_equal( + time - np.abs(particle_data["dt"] / 2), + particle_data["time_nextloop"], + where=np.isfinite(particle_data["time_nextloop"]), + ) + & np.greater_equal( + time + np.abs(particle_data["dt"] / 2), + particle_data["time_nextloop"], + where=np.isfinite(particle_data["time_nextloop"]), + ) # check time - dt/2 <= particle_data["time"] <= time + dt/2 + | ( + (np.isnan(particle_data["dt"])) + & np.equal(time, particle_data["time_nextloop"], where=np.isfinite(particle_data["time_nextloop"])) + ) # or dt is NaN and time matches particle_data["time"] + ) + & (np.isfinite(particle_data["trajectory"])) + & (np.isfinite(particle_data["time_nextloop"])) + )[0] + + +def _convert_particle_data_time_to_float_seconds(particle_data, time_interval): + #! Important that this is a shallow copy, so that updates to this propogate back to the original data + particle_data = particle_data.copy() + + particle_data["time"] = ((particle_data["time"] - time_interval.left) / np.timedelta64(1, "s")).astype(np.float64) + particle_data["time_nextloop"] = ( + (particle_data["time_nextloop"] - time_interval.left) / np.timedelta64(1, "s") + ).astype(np.float64) + particle_data["dt"] = (particle_data["dt"] / np.timedelta64(1, "s")).astype(np.float64) + return particle_data + + +def _maybe_convert_time_dtype(dtype: np.dtype | _SAME_AS_FIELDSET_TIME_INTERVAL) -> np.dtype: + """Convert the dtype of time to float64 if it is not already.""" + if dtype is _SAME_AS_FIELDSET_TIME_INTERVAL.VALUE: + return np.dtype( + np.uint64 + ) #! We need to have here some proper mechanism for converting particle data to the data that is to be output to zarr (namely the time needs to be converted to float seconds by subtracting the time_interval.left) + return dtype + + +def _get_calendar_and_units(time_interval: TimeInterval) -> dict[str, str]: + calendar = None + units = "seconds" + if isinstance(time_interval.left, (np.datetime64, datetime)): + calendar = "standard" + elif isinstance(time_interval.left, cftime.datetime): + calendar = time_interval.left.calendar + + if calendar is not None: + units += f" since {time_interval.left}" + + attrs = {"units": units} + if calendar is not None: + attrs["calendar"] = calendar + + return attrs + + +def _assert_valid_chunks_tuple(chunks): + e = ValueError(f"chunks must be a tuple of integers with length 2, got {chunks=!r} instead.") + if chunks is None: + return + + if not isinstance(chunks, tuple): + raise e + if len(chunks) != 2: + raise e + if not all(isinstance(c, int) for c in chunks): + raise e diff --git a/parcels/_core/particleset.py b/parcels/_core/particleset.py new file mode 100644 index 000000000..bdeef9ae7 --- /dev/null +++ b/parcels/_core/particleset.py @@ -0,0 +1,667 @@ +import datetime +import sys +import warnings +from collections.abc import Iterable +from typing import Literal + +import numpy as np +import xarray as xr +from tqdm import tqdm +from zarr.storage import DirectoryStore + +from parcels._core.converters import _convert_to_flat_array +from parcels._core.kernel import Kernel +from parcels._core.particle import KernelParticle, Particle, create_particle_data +from parcels._core.statuscodes import StatusCode +from parcels._core.utils.time import TimeInterval, maybe_convert_python_timedelta_to_numpy +from parcels._core.warnings import ParticleSetWarning +from parcels._logger import logger +from parcels._reprs import particleset_repr +from parcels.kernels import AdvectionRK4 + +__all__ = ["ParticleSet"] + + +class ParticleSet: + """Class for storing particles and executing kernel over them. + + Please note that this currently only supports fixed size particle sets, meaning that the particle set only + holds the particles defined on construction. Individual particles can neither be added nor deleted individually, + and individual particles can only be deleted as a set procedurally (i.e. by changing their state to 'StatusCode.Delete' + during kernel execution). + + Parameters + ---------- + fieldset : + mod:`parcels.fieldset.FieldSet` object from which to sample velocity. + pclass : parcels.particle.Particle + Optional object that inherits from :mod:`parcels.particle.Particle` object that defines custom particle + lon : + List of initial longitude values for particles + lat : + List of initial latitude values for particles + depth : + Optional list of initial depth values for particles. Default is 0m + time : + Optional list of initial time values for particles. Default is fieldset.U.grid.time[0] + repeatdt : datetime.timedelta or float, optional + Optional interval on which to repeat the release of the ParticleSet. Either timedelta object, or float in seconds. + lonlatdepth_dtype : + Floating precision for lon, lat, depth particle coordinates. + It is either np.float32 or np.float64. Default is np.float32 if fieldset.U.interp_method is 'linear' + and np.float64 if the interpolation method is 'cgrid_velocity' + trajectory_ids : + Optional list of "trajectory" values (integers) for the particle IDs + partition_function : + Function to use for partitioning particles over processors. Default is to use kMeans + periodic_domain_zonal : + Zonal domain size, used to apply zonally periodic boundaries for particle-particle + interaction. If None, no zonally periodic boundaries are applied + + Other Variables can be initialised using further arguments (e.g. v=... for a Variable named 'v') + """ + + def __init__( + self, + fieldset, + pclass=Particle, + lon=None, + lat=None, + depth=None, + time=None, + trajectory_ids=None, + **kwargs, + ): + self._data = None + self._repeat_starttime = None + self._kernel = None + self._interaction_kernel = None + + self.fieldset = fieldset + lon = np.empty(shape=0) if lon is None else _convert_to_flat_array(lon) + lat = np.empty(shape=0) if lat is None else _convert_to_flat_array(lat) + time = np.empty(shape=0) if time is None else _convert_to_flat_array(time) + + if trajectory_ids is None: + trajectory_ids = np.arange(lon.size) + + if depth is None: + mindepth = 0 + for field in self.fieldset.fields.values(): + if field.grid.depth is not None: + mindepth = min(mindepth, field.grid.depth[0]) + depth = np.ones(lon.size) * mindepth + else: + depth = _convert_to_flat_array(depth) + assert lon.size == lat.size and lon.size == depth.size, "lon, lat, depth don't all have the same lenghts" + + if time is None or len(time) == 0: + # do not set a time yet (because sign_dt not known) + if fieldset.time_interval is None: + time = np.timedelta64("NaT", "ns") + else: + time = type(fieldset.time_interval.left)("NaT", "ns") + elif type(time[0]) in [np.datetime64, np.timedelta64]: + pass # already in the right format + else: + raise TypeError("particle time must be a datetime, timedelta, or date object") + time = np.repeat(time, lon.size) if time.size == 1 else time + + assert lon.size == time.size, "time and positions (lon, lat, depth) do not have the same lengths." + + if fieldset.time_interval: + _warn_particle_times_outside_fieldset_time_bounds(time, fieldset.time_interval) + + for kwvar in kwargs: + if kwvar not in ["partition_function"]: + kwargs[kwvar] = _convert_to_flat_array(kwargs[kwvar]) + assert lon.size == kwargs[kwvar].size, ( + f"{kwvar} and positions (lon, lat, depth) don't have the same lengths." + ) + + self._data = create_particle_data( + pclass=pclass, + nparticles=lon.size, + ngrids=len(fieldset.gridset), + time_interval=fieldset.time_interval, + initial=dict( + lon=lon, + lat=lat, + depth=depth, + time=time, + time_nextloop=time, + trajectory=trajectory_ids, + ), + ) + self._ptype = pclass + + # update initial values provided on ParticleSet creation # TODO: Wrap this into create_particle_data + particle_variables = [v.name for v in pclass.variables] + for kwvar, kwval in kwargs.items(): + if kwvar not in particle_variables: + raise RuntimeError(f"Particle class does not have Variable {kwvar}") + self._data[kwvar][:] = kwval + + self._kernel = None + + def __del__(self): + if self._data is not None and isinstance(self._data, xr.Dataset): + del self._data + self._data = None + + def __iter__(self): + self._index = 0 + return self + + def __next__(self): + if self._index < len(self): + p = self.__getitem__(self._index) + self._index += 1 + return p + raise StopIteration + + def __getattr__(self, name): + """ + Access a single property of all particles. + + Parameters + ---------- + name : str + Name of the property + """ + return self._data[name] + + def __getitem__(self, index): + """Get a single particle by index.""" + return KernelParticle(self._data, index=index) + + def __setattr__(self, name, value): + if name in ["_data"]: + object.__setattr__(self, name, value) + elif isinstance(self._data, dict) and name in self._data.keys(): + self._data[name][:] = value + else: + object.__setattr__(self, name, value) + + @staticmethod + def lonlatdepth_dtype_from_field_interp_method(field): + # TODO update this when now interp methods are implemented + if field.interp_method == "cgrid_velocity": + return np.float64 + return np.float32 + + @property + def size(self): + return len(self) + + def __repr__(self): + return particleset_repr(self) + + def __len__(self): + return len(self._data["trajectory"]) + + def add(self, particles): + """Add particles to the ParticleSet. Note that this is an + incremental add, the particles will be added to the ParticleSet + on which this function is called. + + Parameters + ---------- + particles : + Another ParticleSet containing particles to add to this one. + + Returns + ------- + type + The current ParticleSet + + """ + assert particles is not None, ( + f"Trying to add another {type(self)} to this one, but the other one is None - invalid operation." + ) + assert type(particles) is type(self) + + if len(particles) == 0: + return + + if len(self) == 0: + self._data = particles._data + return + + if isinstance(particles, type(self)): + if len(self._data["trajectory"]) > 0: + offset = self._data["trajectory"].max() + 1 + else: + offset = 0 + particles._data["trajectory"] = particles._data["trajectory"] + offset + + for d in self._data: + self._data[d] = np.concatenate((self._data[d], particles._data[d])) + + # Adding particles invalidates the neighbor search structure. + self._dirty_neighbor = True + return self + + def __iadd__(self, particles): + """Add particles to the ParticleSet. + + Note that this is an incremental add, the particles will be added to the ParticleSet + on which this function is called. + + Parameters + ---------- + particles : + Another ParticleSet containing particles to add to this one. + + Returns + ------- + type + The current ParticleSet + """ + self.add(particles) + return self + + def remove_indices(self, indices): + """Method to remove particles from the ParticleSet, based on their `indices`.""" + for d in self._data: + self._data[d] = np.delete(self._data[d], indices, axis=0) + + def _active_particles_mask(self, time, dt): + active_indices = (time - self._data["time"]) / dt >= 0 + non_err_indices = np.isin(self._data["state"], [StatusCode.Success, StatusCode.Evaluate]) + active_indices = np.logical_and(active_indices, non_err_indices) + self._active_particle_idx = np.where(active_indices)[0] + return active_indices + + def _compute_neighbor_tree(self, time, dt): + active_mask = self._active_particles_mask(time, dt) + + self._values = np.vstack( + ( + self._data["depth"], + self._data["lat"], + self._data["lon"], + ) + ) + if self._dirty_neighbor: + self._neighbor_tree.rebuild(self._values, active_mask=active_mask) + self._dirty_neighbor = False + else: + self._neighbor_tree.update_values(self._values, new_active_mask=active_mask) + + def _neighbors_by_index(self, particle_idx): + neighbor_idx, distances = self._neighbor_tree.find_neighbors_by_idx(particle_idx) + neighbor_idx = self._active_particle_idx[neighbor_idx] + mask = neighbor_idx != particle_idx + neighbor_idx = neighbor_idx[mask] + if "horiz_dist" in self._data._ptype.variables: + self._data["vert_dist"][neighbor_idx] = distances[0, mask] + self._data["horiz_dist"][neighbor_idx] = distances[1, mask] + return True # TODO fix for v4 ParticleDataIterator(self.particledata, subset=neighbor_idx) + + def _neighbors_by_coor(self, coor): + neighbor_idx = self._neighbor_tree.find_neighbors_by_coor(coor) + neighbor_ids = self._data["trajectory"][neighbor_idx] + return neighbor_ids + + def populate_indices(self): + """Pre-populate guesses of particle ei (element id) indices""" + for i, grid in enumerate(self.fieldset.gridset): + position = grid.search(self.depth, self.lat, self.lon) + self._data["ei"][:, i] = grid.ravel_index( + { + "X": position["X"][0], + "Y": position["Y"][0], + "Z": position["Z"][0], + } + ) + + @classmethod + def from_particlefile(cls, fieldset, pclass, filename, restart=True, restarttime=None, **kwargs): + """Initialise the ParticleSet from a zarr ParticleFile. + This creates a new ParticleSet based on locations of all particles written + in a zarr ParticleFile at a certain time. Particle IDs are preserved if restart=True + + Parameters + ---------- + fieldset : parcels.fieldset.FieldSet + mod:`parcels.fieldset.FieldSet` object from which to sample velocity + pclass : + Particle class. May be a parcels.particle.Particle class as defined in parcels, or a subclass defining a custom particle. + filename : str + Name of the particlefile from which to read initial conditions + restart : bool + BSignal if pset is used for a restart (default is True). + In that case, Particle IDs are preserved. + restarttime : + time at which the Particles will be restarted. Default is the last time written. + Alternatively, restarttime could be a time value (including np.datetime64) or + a callable function such as np.nanmin. The last is useful when running with dt < 0. + repeatdt : datetime.timedelta or float, optional + Optional interval on which to repeat the release of the ParticleSet. Either timedelta object, or float in seconds. + **kwargs : + Keyword arguments passed to the particleset constructor. + """ + raise NotImplementedError( + "ParticleSet.from_particlefile is not yet implemented in v4." + ) # TODO implement this when ParticleFile is implemented in v4 + + def Kernel(self, pyfunc): + """Wrapper method to convert a `pyfunc` into a :class:`parcels.kernel.Kernel` object. + + Conversion is based on `fieldset` and `ptype` of the ParticleSet. + + Parameters + ---------- + pyfunc : function or list of functions + Python function to convert into kernel. If a list of functions is provided, + the functions will be converted to kernels and combined into a single kernel. + """ + if isinstance(pyfunc, list): + return Kernel.from_list( + self.fieldset, + self._ptype, + pyfunc, + ) + return Kernel( + self.fieldset, + self._ptype, + pyfuncs=[pyfunc], + ) + + def InteractionKernel(self, pyfunc_inter): + from parcels.interaction.interactionkernel import InteractionKernel + + if pyfunc_inter is None: + return None + return InteractionKernel(self.fieldset, self._ptype, pyfunc=pyfunc_inter) + + def data_indices(self, variable_name, compare_values, invert=False): + """Get the indices of all particles where the value of `variable_name` equals (one of) `compare_values`. + + Parameters + ---------- + variable_name : str + Name of the variable to check. + compare_values : + Value or list of values to compare to. + invert : + Whether to invert the selection. I.e., when True, + return all indices that do not equal (one of) + `compare_values`. (Default value = False) + + Returns + ------- + np.ndarray + Numpy array of indices that satisfy the test. + + """ + compare_values = ( + np.array([compare_values]) if type(compare_values) not in [list, dict, np.ndarray] else compare_values + ) + return np.where(np.isin(self._data[variable_name], compare_values, invert=invert))[ + 0 + ] # TODO check if this can be faster with xarray indexing? + + @property + def _error_particles(self): + """Get indices of all particles that are in an error state. + + Returns + ------- + indices + Indices of error particles. + """ + return self.data_indices("state", [StatusCode.Success, StatusCode.Evaluate], invert=True) + + @property + def _num_error_particles(self): + """Get the number of particles that are in an error state. + + Returns + ------- + int + Number of error particles. + """ + return np.sum(np.isin(self._data["state"], [StatusCode.Success, StatusCode.Evaluate], invert=True)) + + def update_dt_dtype(self, dt_dtype: np.dtype): + """Update the dtype of dt + + Parameters + ---------- + dt_dtype : np.dtype + New dtype for dt. + """ + if dt_dtype not in [np.timedelta64, "timedelta64[ns]", "timedelta64[ms]", "timedelta64[s]"]: + raise ValueError(f"dt_dtype must be a numpy timedelta64 dtype. Got {dt_dtype=!r}") + + self._data["dt"] = self._data["dt"].astype(dt_dtype) + + def set_variable_write_status(self, var, write_status): + """Method to set the write status of a Variable. + + Parameters + ---------- + var : + Name of the variable (string) + write_status : + Write status of the variable (True, False or 'once') + """ + self._data[var].set_variable_write_status(write_status) + + def execute( + self, + pyfunc=AdvectionRK4, + endtime: np.timedelta64 | np.datetime64 | None = None, + runtime: datetime.timedelta | np.timedelta64 | None = None, + dt: datetime.timedelta | np.timedelta64 | None = None, + output_file=None, + verbose_progress=True, + ): + """Execute a given kernel function over the particle set for multiple timesteps. + + Optionally also provide sub-timestepping + for particle output. + + Parameters + ---------- + pyfunc : + Kernel function to execute. This can be the name of a + defined Python function or a :class:`parcels.kernel.Kernel` object. + Kernels can be concatenated using the + operator (Default value = AdvectionRK4) + endtime (np.datetime64 or np.timedelta64): : + End time for the timestepping loop. If a np.timedelta64 is provided, it is interpreted as the total simulation time. In this case, + the absolute end time is the start of the fieldset's time interval plus the np.timedelta64. + If a datetime is provided, it is interpreted as the absolute end time of the simulation. + runtime (np.timedelta64): + The duration of the simuulation execution. Must be a np.timedelta64 object and is required to be set when the `fieldset.time_interval` is not defined. + If the `fieldset.time_interval` is defined and the runtime is provided, the end time will be the start of the fieldset's time interval plus the runtime. + dt (np.timedelta64): + Timestep interval (as a np.timedelta64 object) to be passed to the kernel. + Use a negative value for a backward-in-time simulation. (Default value = 1 second) + output_file : + mod:`parcels.particlefile.ParticleFile` object for particle output (Default value = None) + verbose_progress : bool + Boolean for providing a progress bar for the kernel execution loop. (Default value = True) + + Notes + ----- + ``ParticleSet.execute()`` acts as the main entrypoint for simulations, and provides the simulation time-loop. This method encapsulates the logic controlling the switching between kernel execution, output file writing, reading in fields for new timesteps, adding new particles to the simulation domain, stopping the simulation, and executing custom functions (``postIterationCallbacks`` provided by the user). + """ + # check if particleset is empty. If so, return immediately + if len(self) == 0: + return + + if not isinstance(pyfunc, Kernel): + pyfunc = self.Kernel(pyfunc) + + self._kernel = pyfunc + + if output_file is not None: + output_file.set_metadata(self.fieldset.gridset[0]._mesh) + output_file.metadata["parcels_kernels"] = self._kernel.funcname + + if dt is None: + dt = np.timedelta64(1, "s") + + try: + dt = maybe_convert_python_timedelta_to_numpy(dt) + assert not np.isnat(dt) + sign_dt = np.sign(dt).astype(int) + assert sign_dt in [-1, 1] + except (ValueError, AssertionError) as e: + raise ValueError(f"dt must be a non-zero datetime.timedelta or np.timedelta64 object, got {dt=!r}") from e + + # Check if particle dt has finer resolution than input dt + particle_resolution = np.timedelta64(1, np.datetime_data(self._data["dt"].dtype)) + input_resolution = np.timedelta64(1, np.datetime_data(dt.dtype)) + + if input_resolution >= particle_resolution: + self._data["dt"][:] = dt + else: + raise ValueError( + f"The dtype of dt ({dt.dtype}) is coarser than the dtype of the particle dt ({self._data['dt'].dtype}). Please use ParticleSet.set_dt_dtype() to provide a dt with at least the same precision as the particle dt." + ) + + if runtime is not None: + try: + runtime = maybe_convert_python_timedelta_to_numpy(runtime) + except ValueError as e: + raise ValueError( + f"The runtime must be a datetime.timedelta or np.timedelta64 object. Got {type(runtime)}" + ) from e + + start_time, end_time = _get_simulation_start_and_end_times( + self.fieldset.time_interval, self._data["time_nextloop"], runtime, endtime, sign_dt + ) + + # Set the time of the particles if it hadn't been set on initialisation + if np.isnat(self._data["time"]).any(): + self._data["time"][:] = start_time + self._data["time_nextloop"][:] = start_time + + outputdt = output_file.outputdt if output_file else None + + # Set up pbar + if output_file: + logger.info(f"Output files are stored in {_format_output_location(output_file.store)}") + + if verbose_progress: + pbar = tqdm(total=(end_time - start_time) / np.timedelta64(1, "s"), file=sys.stdout) + + next_output = start_time + sign_dt * outputdt if output_file else None + + time = start_time + while sign_dt * (time - end_time) < 0: + if next_output is not None: + f = min if sign_dt > 0 else max + next_time = f(next_output, end_time) + else: + next_time = end_time + + self._kernel.execute(self, endtime=next_time, dt=dt) + + if next_output: + if np.abs(next_time - next_output) < np.timedelta64(1000, "ns"): + if output_file: + output_file.write(self, next_output) + if np.isfinite(outputdt): + next_output += outputdt + + if verbose_progress: + pbar.update((next_time - time) / np.timedelta64(1, "s")) + + time = next_time + + if verbose_progress: + pbar.close() + + +def _warn_outputdt_release_desync(outputdt: float, starttime: float, release_times: Iterable[float]): + """Gives the user a warning if the release time isn't a multiple of outputdt.""" + if any((np.isfinite(t) and (t - starttime) % outputdt != 0) for t in release_times): + warnings.warn( + "Some of the particles have a start time difference that is not a multiple of outputdt. " + "This could cause the first output of some of the particles that start later " + "in the simulation to be at a different time than expected.", + ParticleSetWarning, + stacklevel=2, + ) + + +def _warn_particle_times_outside_fieldset_time_bounds(release_times: np.ndarray, time: TimeInterval): + if np.isnat(release_times).all(): + return + + if isinstance(time.left, np.datetime64) and isinstance(release_times[0], np.timedelta64): + release_times = np.array([t + time.left for t in release_times]) + if np.any(release_times < time.left) or np.any(release_times > time.right): + warnings.warn( + "Some particles are set to be released outside the FieldSet's executable time domain.", + ParticleSetWarning, + stacklevel=2, + ) + + +def _get_simulation_start_and_end_times( + time_interval: TimeInterval, + particle_release_times: np.ndarray, + runtime: np.timedelta64 | None, + endtime: np.datetime64 | None, + sign_dt: Literal[-1, 1], +) -> tuple[np.datetime64, np.datetime64]: + if runtime is not None and endtime is not None: + raise ValueError( + f"runtime and endtime are mutually exclusive - provide one or the other. Got {runtime=!r}, {endtime=!r}" + ) + + if runtime is None and time_interval is None: + raise ValueError("The runtime must be provided when the time_interval is not defined for a fieldset.") + + if sign_dt == 1: + first_release_time = particle_release_times.min() + else: + first_release_time = particle_release_times.max() + + start_time = _get_start_time(first_release_time, time_interval, sign_dt, runtime) + + if endtime is None: + endtime = start_time + sign_dt * runtime + + if time_interval is not None: + if type(endtime) != type(time_interval.left): # noqa: E721 + raise ValueError( + f"The endtime must be of the same type as the fieldset.time_interval start time. Got {endtime=!r} with {time_interval=!r}" + ) + if endtime not in time_interval: + msg = ( + f"Calculated/provided end time of {endtime!r} is not in fieldset time interval {time_interval!r}. Either reduce your runtime, modify your " + "provided endtime, or change your release timing." + "Important info:\n" + f" First particle release: {first_release_time!r}\n" + f" runtime: {runtime!r}\n" + f" (calculated) endtime: {endtime!r}" + ) + raise ValueError(msg) + + return start_time, endtime + + +def _get_start_time(first_release_time, time_interval, sign_dt, runtime): + if time_interval is None: + time_interval = TimeInterval(left=np.timedelta64(0, "s"), right=runtime) + + if sign_dt == 1: + fieldset_start = time_interval.left + else: + fieldset_start = time_interval.right + + start_time = first_release_time if not np.isnat(first_release_time) else fieldset_start + return start_time + + +def _format_output_location(zarr_obj): + if isinstance(zarr_obj, DirectoryStore): + return zarr_obj.path + return repr(zarr_obj) diff --git a/parcels/_core/spatialhash.py b/parcels/_core/spatialhash.py new file mode 100644 index 000000000..f7c551c62 --- /dev/null +++ b/parcels/_core/spatialhash.py @@ -0,0 +1,599 @@ +import numpy as np + +from parcels._core.index_search import ( + GRID_SEARCH_ERROR, + _latlon_rad_to_xyz, + curvilinear_point_in_cell, + uxgrid_point_in_cell, +) +from parcels._python import isinstance_noimport + + +class SpatialHash: + """Custom data structure that is used for performing grid searches using Spatial Hashing. This class constructs an overlying + uniformly spaced rectilinear grid, called the "hash grid" on top parcels.XGrid. It is particularly useful for grid searching + on curvilinear grids. Faces in the Xgrid are related to the cells in the hash grid by determining the hash cells the bounding box + of the unstructured face cells overlap with. + + Parameters + ---------- + grid : parcels.XGrid + Source grid used to construct the hash grid and hash table + + Note + ---- + Does not currently support queries on periodic elements. + """ + + def __init__( + self, + grid, + bitwidth=1023, + ): + if isinstance_noimport(grid, "XGrid"): + self._point_in_cell = curvilinear_point_in_cell + elif isinstance_noimport(grid, "UxGrid"): + self._point_in_cell = uxgrid_point_in_cell + else: + raise ValueError("Expected `grid` to be a parcels.XGrid or parcels.UxGrid") + + self._source_grid = grid + self._bitwidth = bitwidth # Max integer to use per coordinate in quantization (10 bits = 0..1023) + + if isinstance_noimport(grid, "XGrid"): + self._coord_dim = 2 # Number of computational coordinates is 2 (bilinear interpolation) + if self._source_grid._mesh == "spherical": + # Boundaries of the hash grid are the unit cube + self._xmin = -1.0 + self._ymin = -1.0 + self._zmin = -1.0 + self._xmax = 1.0 + self._ymax = 1.0 + self._zmax = 1.0 # Compute the cell centers of the source grid (for now, assuming Xgrid) + lon = np.deg2rad(self._source_grid.lon) + lat = np.deg2rad(self._source_grid.lat) + x, y, z = _latlon_rad_to_xyz(lat, lon) + _xbound = np.stack( + ( + x[:-1, :-1], + x[:-1, 1:], + x[1:, 1:], + x[1:, :-1], + ), + axis=-1, + ) + _ybound = np.stack( + ( + y[:-1, :-1], + y[:-1, 1:], + y[1:, 1:], + y[1:, :-1], + ), + axis=-1, + ) + _zbound = np.stack( + ( + z[:-1, :-1], + z[:-1, 1:], + z[1:, 1:], + z[1:, :-1], + ), + axis=-1, + ) + # Compute centroid locations of each cells + self._xlow = np.min(_xbound, axis=-1) + self._xhigh = np.max(_xbound, axis=-1) + self._ylow = np.min(_ybound, axis=-1) + self._yhigh = np.max(_ybound, axis=-1) + self._zlow = np.min(_zbound, axis=-1) + self._zhigh = np.max(_zbound, axis=-1) + + else: + # Boundaries of the hash grid are the bounding box of the source grid + self._xmin = self._source_grid.lon.min() + self._xmax = self._source_grid.lon.max() + self._ymin = self._source_grid.lat.min() + self._ymax = self._source_grid.lat.max() + # setting min and max below is needed for mesh="flat" + self._zmin = 0.0 + self._zmax = 0.0 + x = self._source_grid.lon + y = self._source_grid.lat + + _xbound = np.stack( + ( + x[:-1, :-1], + x[:-1, 1:], + x[1:, 1:], + x[1:, :-1], + ), + axis=-1, + ) + _ybound = np.stack( + ( + y[:-1, :-1], + y[:-1, 1:], + y[1:, 1:], + y[1:, :-1], + ), + axis=-1, + ) + # Compute bounding box of each face + self._xlow = np.min(_xbound, axis=-1) + self._xhigh = np.max(_xbound, axis=-1) + self._ylow = np.min(_ybound, axis=-1) + self._yhigh = np.max(_ybound, axis=-1) + self._zlow = np.zeros_like(self._xlow) + self._zhigh = np.zeros_like(self._xlow) + + elif isinstance_noimport(grid, "UxGrid"): + self._coord_dim = grid.uxgrid.n_max_face_nodes # Number of barycentric coordinates + if self._source_grid._mesh == "spherical": + # Boundaries of the hash grid are the unit cube + self._xmin = -1.0 + self._ymin = -1.0 + self._zmin = -1.0 + self._xmax = 1.0 + self._ymax = 1.0 + self._zmax = 1.0 # Compute the cell centers of the source grid (for now, assuming Xgrid) + # Reshape node coordinates to (nfaces, nnodes_per_face) + nids = self._source_grid.uxgrid.face_node_connectivity.values + lon = self._source_grid.uxgrid.node_lon.values[nids] + lat = self._source_grid.uxgrid.node_lat.values[nids] + x, y, z = _latlon_rad_to_xyz(np.deg2rad(lat), np.deg2rad(lon)) + _xbound, _ybound, _zbound = _latlon_rad_to_xyz(np.deg2rad(lat), np.deg2rad(lon)) + + # Compute bounding box of each face + self._xlow = np.atleast_2d(np.min(_xbound, axis=-1)) + self._xhigh = np.atleast_2d(np.max(_xbound, axis=-1)) + self._ylow = np.atleast_2d(np.min(_ybound, axis=-1)) + self._yhigh = np.atleast_2d(np.max(_ybound, axis=-1)) + self._zlow = np.atleast_2d(np.min(_zbound, axis=-1)) + self._zhigh = np.atleast_2d(np.max(_zbound, axis=-1)) + + else: + # Boundaries of the hash grid are the bounding box of the source grid + self._xmin = self._source_grid.uxgrid.node_lon.min().values + self._xmax = self._source_grid.uxgrid.node_lon.max().values + self._ymin = self._source_grid.uxgrid.node_lat.min().values + self._ymax = self._source_grid.uxgrid.node_lat.max().values + # setting min and max below is needed for mesh="flat" + self._zmin = 0.0 + self._zmax = 0.0 + # Reshape node coordinates to (nfaces, nnodes_per_face) + nids = self._source_grid.uxgrid.face_node_connectivity.values + lon = self._source_grid.uxgrid.node_lon.values[nids] + lat = self._source_grid.uxgrid.node_lat.values[nids] + + # Compute bounding box of each face + self._xlow = np.atleast_2d(np.min(lon, axis=-1)) + self._xhigh = np.atleast_2d(np.max(lon, axis=-1)) + self._ylow = np.atleast_2d(np.min(lat, axis=-1)) + self._yhigh = np.atleast_2d(np.max(lat, axis=-1)) + self._zlow = np.zeros_like(self._xlow) + self._zhigh = np.zeros_like(self._xlow) + + # Generate the mapping from the hash indices to unstructured grid elements + self._hash_table = self._initialize_hash_table() + + def _initialize_hash_table(self): + """Create a mapping that relates unstructured grid faces to hash indices by determining + which faces overlap with which hash cells + """ + # Quantize the bounding box in each direction + xqlow, yqlow, zqlow = quantize_coordinates( + self._xlow, + self._ylow, + self._zlow, + self._xmin, + self._xmax, + self._ymin, + self._ymax, + self._zmin, + self._zmax, + self._bitwidth, + ) + + xqhigh, yqhigh, zqhigh = quantize_coordinates( + self._xhigh, + self._yhigh, + self._zhigh, + self._xmin, + self._xmax, + self._ymin, + self._ymax, + self._zmin, + self._zmax, + self._bitwidth, + ) + xqlow = xqlow.ravel().astype(np.int32, copy=False) + yqlow = yqlow.ravel().astype(np.int32, copy=False) + zqlow = zqlow.ravel().astype(np.int32, copy=False) + xqhigh = xqhigh.ravel().astype(np.int32, copy=False) + yqhigh = yqhigh.ravel().astype(np.int32, copy=False) + zqhigh = zqhigh.ravel().astype(np.int32, copy=False) + nx = (xqhigh - xqlow + 1).astype(np.int32, copy=False) + ny = (yqhigh - yqlow + 1).astype(np.int32, copy=False) + nz = (zqhigh - zqlow + 1).astype(np.int32, copy=False) + num_hash_per_face = (nx * ny * nz).astype( + np.int32, copy=False + ) # Since nx, ny, nz are in the 10-bit range, their product fits in int32 + total_hash_entries = int(num_hash_per_face.sum()) + + # Preallocate output arrays + morton_codes = np.zeros(total_hash_entries, dtype=np.uint32) + + # Compute the j, i indices corresponding to each hash entry + nface = np.size(self._xlow) + face_ids = np.repeat(np.arange(nface, dtype=np.int32), num_hash_per_face) + offsets = np.concatenate(([0], np.cumsum(num_hash_per_face))).astype(np.int32)[:-1] + + valid = num_hash_per_face != 0 + if not np.any(valid): + # nothing to do + pass + else: + # Grab only valid faces to avoid empty arrays + nx_v = np.asarray(nx[valid], dtype=np.int32) + ny_v = np.asarray(ny[valid], dtype=np.int32) + nz_v = np.asarray(nz[valid], dtype=np.int32) + xlow_v = np.asarray(xqlow[valid], dtype=np.int32) + ylow_v = np.asarray(yqlow[valid], dtype=np.int32) + zlow_v = np.asarray(zqlow[valid], dtype=np.int32) + starts_v = np.asarray(offsets[valid], dtype=np.int32) + + # Count of elements per valid face (should match num_hash_per_face[valid]) + counts = (nx_v * ny_v * nz_v).astype(np.int32) + total = int(counts.sum()) + + # Map each global element to its face and output position + start_for_elem = np.repeat(starts_v, counts) # shape (total,) + + # Intra-face linear index for each element (0..counts_i-1) + # Offsets per face within the concatenation of valid faces: + face_starts_local = np.cumsum(np.r_[0, counts[:-1]]) + intra = np.arange(total, dtype=np.int32) - np.repeat(face_starts_local, counts) + + # Derive (zi, yi, xi) from intra using per-face sizes + ny_nz = np.repeat(ny_v * nz_v, counts) + nz_rep = np.repeat(nz_v, counts) + + xi = intra // ny_nz + rem = intra % ny_nz + yi = rem // nz_rep + zi = rem % nz_rep + + # Add per-face lows + x0 = np.repeat(xlow_v, counts) + y0 = np.repeat(ylow_v, counts) + z0 = np.repeat(zlow_v, counts) + + xq = x0 + xi + yq = y0 + yi + zq = z0 + zi + + # Vectorized morton encode for all elements at once + codes_all = _encode_quantized_morton3d(xq, yq, zq) + + # Scatter into the preallocated output using computed absolute indices + out_idx = start_for_elem + intra + morton_codes[out_idx] = codes_all + + # Sort face indices by morton code + order = np.argsort(morton_codes) + morton_codes_sorted = morton_codes[order] + face_sorted = face_ids[order] + j_sorted, i_sorted = np.unravel_index(face_sorted, self._xlow.shape) + + # Get a list of unique morton codes and their corresponding starts and counts (CSR format) + keys, starts, counts = np.unique(morton_codes_sorted, return_index=True, return_counts=True) + + hash_table = { + "keys": keys, + "starts": starts, + "counts": counts, + "i": i_sorted, + "j": j_sorted, + } + return hash_table + + def query(self, y, x): + """ + Queries the hash table and finds the closes face in the source grid for each coordinate pair. + + Parameters + ---------- + y : array_like + y-coordinates in degrees (lat) to query of shape (N,) where N is the number of queries. + x : array_like + x-coordinates in degrees (lon) to query of shape (N,) where N is the number of queries. + + Returns + ------- + j : ndarray, shape (N,) + j-indices of the located face in the source grid for each query. If no face was found, GRID_SEARCH_ERROR is returned. + i : ndarray, shape (N,) + i-indices of the located face in the source grid for each query. If no face was found, GRID_SEARCH_ERROR is returned. + coords : ndarray, shape (N, 2) + The local coordinates (xsi, eta) of the located face in the source grid for each query. + If no face was found, (-1.0, -1.0) + """ + keys = self._hash_table["keys"] + starts = self._hash_table["starts"] + counts = self._hash_table["counts"] + i = self._hash_table["i"] + j = self._hash_table["j"] + + y = np.asarray(y) + x = np.asarray(x) + if self._source_grid._mesh == "spherical": + # Convert coords to Cartesian coordinates (x, y, z) + lat = np.deg2rad(y) + lon = np.deg2rad(x) + qx, qy, qz = _latlon_rad_to_xyz(lat, lon) + else: + # For Cartesian grids, use the coordinates directly + qx = x + qy = y + qz = np.zeros_like(qx) + + query_codes = _encode_morton3d( + qx, qy, qz, self._xmin, self._xmax, self._ymin, self._ymax, self._zmin, self._zmax + ).ravel() + num_queries = query_codes.size + + # Locate each query in the unique key array + pos = np.searchsorted(keys, query_codes) # pos is shape (num_queries,) + + # Valid hits: inside range with finite query coordinates and query codes give exact morton code match. + valid = (pos < len(keys)) & np.isfinite(x) & np.isfinite(y) + # Clip pos to valid range to avoid out-of-bounds indexing + pos = np.clip(pos, 0, len(keys) - 1) + # Further filter out false positives from searchsorted by checking for exact code match + valid[valid] &= query_codes[valid] == keys[pos[valid]] + + # Pre-allocate i and j indices of the best match for each query + # Default values to -1 (no match case) + j_best = np.full(num_queries, GRID_SEARCH_ERROR, dtype=np.int32) + i_best = np.full(num_queries, GRID_SEARCH_ERROR, dtype=np.int32) + + # How many matches each query has; hit_counts[i] is the number of hits for query i + hit_counts = np.where(valid, counts[pos], 0).astype(np.int32) # has shape (num_queries,) + if hit_counts.sum() == 0: + return ( + j_best.reshape(query_codes.shape), + i_best.reshape(query_codes.shape), + np.full((num_queries, self._coord_dim), -1.0, dtype=np.float32), + ) + + # Now, for each query, we need to gather the candidate (j,i) indices from the hash table + # Each j,i pair needs to be repeated hit_counts[i] times, only when there are hits. + + # Boolean array for keeping track of which queries have candidates + has_hits = hit_counts > 0 # shape (num_queries,), True for queries that had candidates + + # A quick lookup array that maps all candindates back to its query index + q_index_for_candidate = np.repeat( + np.arange(num_queries, dtype=np.int32), hit_counts + ) # shape (hit_counts.sum(),) + # Map all candidates to positions in the hash table + hash_positions = pos[q_index_for_candidate] # shape (hit_counts.sum(),) + + # Now that we have the positions in the hash table for each table, we can gather the (j,i) pairs for each candidate + # We do this in a vectorized way by using a CSR-like approach + # starts[pos[q_index_for_candidate]] gives the starting point in the hash table for each candidate + # hit_counts gives the number of candidates for each query + + # We need to build an array that gives the offset within each query's candidates + offsets = np.concatenate(([0], np.cumsum(hit_counts))).astype(np.int32) # shape (num_queries+1,) + total = int(offsets[-1]) # total number of candidates across all queries + + # Now, for each candidate, we need a simple array that tells us its "local candidate id" within its query + # This way, we can easily take the starts[pos[q_index_for_candidate]] and add this local id to get the absolute index + # We calculate this by computing the "global candidate number" (0..total-1) and subtracting the offsets of the corresponding query + # This gives us an array that goes from 0..hit_counts[i]-1 for each query i + intra = np.arange(total, dtype=np.int32) - np.repeat(offsets[:-1], hit_counts) # shape (hit_counts.sum(),) + + # starts[pos[q_index_for_candidate]] + intra gives a list of positions in the hash table that we can + # use to quickly gather the (i,j) pairs for each query + source_idx = starts[hash_positions].astype(np.int32) + intra + + # Gather all candidate (j,i) pairs in one shot + j_all = j[source_idx] + i_all = i[source_idx] + + # Now we need to construct arrays that repeats the y and x coordinates for each candidate + # to enable vectorized point-in-cell checks + y_rep = np.repeat(y, hit_counts) # shape (hit_counts.sum(),) + x_rep = np.repeat(x, hit_counts) # shape (hit_counts.sum(),) + + # For each query we perform a point in cell check. + is_in_face, coordinates = self._point_in_cell(self._source_grid, y_rep, x_rep, j_all, i_all) + + coords_best = np.full((num_queries, coordinates.shape[1]), -1.0, dtype=np.float32) + + # For each query that has hits, we need to find the first candidate that was inside the face + f_indices = np.flatnonzero(is_in_face) # Indices of all faces that contained the point + # For each true position, find which query it belongs to by searching offsets + # Query index q satisfies offsets[q] <= pos < offsets[q+1]. + q = np.searchsorted(offsets[1:], f_indices, side="right") + + uniq_q, q_idx = np.unique(q, return_index=True) + keep = has_hits[uniq_q] + + if keep.any(): + uniq_q = uniq_q[keep] + pos_first = f_indices[q_idx[keep]] + + # Directly scatter: the code wants the first True inside each slice + j_best[uniq_q] = j_all[pos_first] + i_best[uniq_q] = i_all[pos_first] + coords_best[uniq_q] = coordinates[pos_first] + + return ( + j_best.reshape(query_codes.shape), + i_best.reshape(query_codes.shape), + coords_best.reshape((num_queries, coordinates.shape[1])), + ) + + +def _dilate_bits(n): + """ + Takes a 10-bit integer n, in range [0,1023], and "dilates" its bits so that + there are two zeros between each bit of n in the result. + + This is a preparation step for building a 3D Morton code: + - One axis (x, y, or z) is dilated like this. + - Then the three dilated coordinates are bitwise interleaved + to produce the full 30-bit Morton code. + + Example: + Input n: b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 + Output: b9 0 0 b8 0 0 b7 0 0 ... b0 0 0 + """ + n = np.asarray(n, dtype=np.uint32) + + # Step 1: Keep only the lowest 10 bits of n + # Mask = 0x3FF = binary 11 1111 1111 + n &= np.uint32(0x000003FF) + + # Step 2: First spreading stage + # Shift left by 16 and OR with original. + # This spreads the bits apart, but introduces overlaps. + # Mask 0xff0000ff clears out the unwanted overlaps. + n = (n | (n << np.uint32(16))) & np.uint32(0xFF0000FF) + + # Step 3: Second spreading stage + # Similar idea: shift left by 8, OR, then mask. + # Now the bits are further separated. + n = (n | (n << np.uint32(8))) & np.uint32(0x0300F00F) + + # Step 4: Third spreading stage + # Shift by 4, OR, mask again. + # At this point, there are 1 or 2 zeros between many of the bits. + n = (n | (n << np.uint32(4))) & np.uint32(0x030C30C3) + + # Step 5: Final spreading stage + # Shift by 2, OR, mask. + # After this, each original bit is isolated with exactly two zeros + # between it and the next bit, ready for 3D Morton interleaving. + n = (n | (n << np.uint32(2))) & np.uint32(0x09249249) + + # Return the dilated value. + return n + + +def quantize_coordinates(x, y, z, xmin, xmax, ymin, ymax, zmin, zmax, bitwidth=1023): + """ + Normalize (x, y, z) to [0, 1] over their bounding box, then quantize to 10 bits each (0..1023). + + Parameters + ---------- + x, y, z : array_like + Input coordinates to quantize. Can be scalars or arrays (broadcasting applies). + xmin, xmax : float + Minimum and maximum bounds for x coordinate. + ymin, ymax : float + Minimum and maximum bounds for y coordinate. + zmin, zmax : float + Minimum and maximum bounds for z coordinate. + + Returns + ------- + xq, yq, zq : ndarray, dtype=uint32 + The quantized coordinates, each in range [0, 1023], same shape as the broadcasted input coordinates. + """ + # Convert inputs to ndarray for consistent dtype/ufunc behavior. + x = np.asarray(x) + y = np.asarray(y) + z = np.asarray(z) + + # --- 1) Normalize each coordinate to [0, 1] over its bounding box. --- + # Compute denominators once (avoid division by zero if bounds equal). + dx = xmax - xmin + dy = ymax - ymin + dz = zmax - zmin + + # Normalize to [0,1]; if a range is degenerate, map to 0 to avoid NaN/inf. + with np.errstate(invalid="ignore"): + xn = np.where(dx != 0, (x - xmin) / dx, 0.0) + yn = np.where(dy != 0, (y - ymin) / dy, 0.0) + zn = np.where(dz != 0, (z - zmin) / dz, 0.0) + + # --- 2) Quantize to (0..bitwidth). --- + # Multiply by bitwidth, round down, and clip to be safe against slight overshoot. + xq = np.clip((xn * bitwidth).astype(np.uint32), 0, bitwidth) + yq = np.clip((yn * bitwidth).astype(np.uint32), 0, bitwidth) + zq = np.clip((zn * bitwidth).astype(np.uint32), 0, bitwidth) + + return xq, yq, zq + + +def _encode_quantized_morton3d(xq, yq, zq): + xq = np.asarray(xq) + yq = np.asarray(yq) + zq = np.asarray(zq) + + # --- 3) Bit-dilate each 10-bit number so each bit is separated by two zeros. --- + # _dilate_bits maps: b9..b0 -> b9 0 0 b8 0 0 ... b0 0 0 + dx3 = _dilate_bits(xq).astype(np.uint32) + dy3 = _dilate_bits(yq).astype(np.uint32) + dz3 = _dilate_bits(zq).astype(np.uint32) + + # --- 4) Interleave the dilated bits into a single Morton code. --- + # Bit layout (from LSB upward): x0,y0,z0, x1,y1,z1, ..., x9,y9,z9 + # We shift z's bits by 2, y's by 1, x stays at 0, then OR them together. + # Cast to a wide type before shifting/OR to be safe when arrays are used. + code = (dz3 << 2) | (dy3 << 1) | dx3 + + # Since our compact type fits in 30 bits, uint32 is enough. + return code.astype(np.uint32) + + +def _encode_morton3d(x, y, z, xmin, xmax, ymin, ymax, zmin, zmax, bitwidth=1023): + """ + Quantize (x, y, z) to 10 bits each (0..1023), dilate the bits so there are + two zeros between successive bits, and interleave them into a 3D Morton code. + + Parameters + ---------- + x, y, z : array_like + Input coordinates to encode. Can be scalars or arrays (broadcasting applies). + xmin, xmax : float + Minimum and maximum bounds for x coordinate. + ymin, ymax : float + Minimum and maximum bounds for y coordinate. + zmin, zmax : float + Minimum and maximum bounds for z coordinate. + + Returns + ------- + code : ndarray, dtype=uint32 + The resulting Morton codes, same shape as the broadcasted input coordinates. + + Notes + ----- + - Works with scalars or NumPy arrays (broadcasting applies). + - Output is up to 30 bits returned as uint32. + """ + # Convert inputs to ndarray for consistent dtype/ufunc behavior. + x = np.asarray(x) + y = np.asarray(y) + z = np.asarray(z) + + xq, yq, zq = quantize_coordinates(x, y, z, xmin, xmax, ymin, ymax, zmin, zmax, bitwidth) + + # --- 3) Bit-dilate each 10-bit number so each bit is separated by two zeros. --- + # _dilate_bits maps: b9..b0 -> b9 0 0 b8 0 0 ... b0 0 0 + dx3 = _dilate_bits(xq).astype(np.uint32) + dy3 = _dilate_bits(yq).astype(np.uint32) + dz3 = _dilate_bits(zq).astype(np.uint32) + + # --- 4) Interleave the dilated bits into a single Morton code. --- + # Bit layout (from LSB upward): x0,y0,z0, x1,y1,z1, ..., x9,y9,z9 + # We shift z's bits by 2, y's by 1, x stays at 0, then OR them together. + # Cast to a wide type before shifting/OR to be safe when arrays are used. + code = (dz3 << 2) | (dy3 << 1) | dx3 + + # Since our compact type fits in 30 bits, uint32 is enough. + return code.astype(np.uint32) diff --git a/parcels/tools/statuscodes.py b/parcels/_core/statuscodes.py similarity index 59% rename from parcels/tools/statuscodes.py rename to parcels/_core/statuscodes.py index 437c83e0d..9b41ba033 100644 --- a/parcels/tools/statuscodes.py +++ b/parcels/_core/statuscodes.py @@ -7,9 +7,12 @@ "KernelError", "StatusCode", "TimeExtrapolationError", + "_raise_field_interpolation_error", "_raise_field_out_of_bound_error", "_raise_field_out_of_bound_surface_error", - "_raise_field_sampling_error", + "_raise_general_error", + "_raise_grid_searching_error", + "_raise_time_extrapolation_error", ] @@ -24,21 +27,20 @@ class StatusCode: StopAllExecution = 41 Error = 50 ErrorInterpolation = 51 + ErrorGridSearching = 52 ErrorOutOfBounds = 60 ErrorThroughSurface = 61 ErrorTimeExtrapolation = 70 -class DaskChunkingError(RuntimeError): - """Error indicating to the user that something with setting up Dask and chunked fieldsets went wrong.""" +class FieldInterpolationError(RuntimeError): + """Utility error class to propagate NaN field interpolation.""" pass -class FieldSamplingError(RuntimeError): - """Utility error class to propagate erroneous field sampling.""" - - pass +def _raise_field_interpolation_error(z, y, x): + raise FieldInterpolationError(f"Field interpolation returned NaN at (depth={z}, lat={y}, lon={x})") class FieldOutOfBoundError(RuntimeError): @@ -47,20 +49,16 @@ class FieldOutOfBoundError(RuntimeError): pass +def _raise_field_out_of_bound_error(z, y, x): + raise FieldOutOfBoundError(f"Field sampled out-of-bound, at (depth={z}, lat={y}, lon={x})") + + class FieldOutOfBoundSurfaceError(RuntimeError): """Utility error class to propagate out-of-bound field sampling at the surface.""" pass -def _raise_field_sampling_error(z, y, x): - raise FieldSamplingError(f"Field sampled at (depth={z}, lat={y}, lon={x})") - - -def _raise_field_out_of_bound_error(z, y, x): - raise FieldOutOfBoundError(f"Field sampled out-of-bound, at (depth={z}, lat={y}, lon={x})") - - def _raise_field_out_of_bound_surface_error(z: float | None, y: float | None, x: float | None) -> None: def format_out(val): return "unknown" if val is None else val @@ -70,12 +68,36 @@ def format_out(val): ) +class FieldSamplingError(RuntimeError): + """Utility error class to propagate field sampling errors.""" + + pass + + +class GridSearchingError(RuntimeError): + """Utility error class to propagate grid searching errors.""" + + pass + + +def _raise_grid_searching_error(z, y, x): + raise GridSearchingError(f"Grid searching failed at (depth={z}, lat={y}, lon={x})") + + +class GeneralError(RuntimeError): + """Utility error class to propagate general errors.""" + + pass + + +def _raise_general_error(z, y, x): + raise GeneralError(f"General error occurred at (depth={z}, lat={y}, lon={x})") + + class TimeExtrapolationError(RuntimeError): """Utility error class to propagate erroneous time extrapolation sampling.""" def __init__(self, time, field=None): - if field is not None and field.grid.time_origin and time is not None: - time = field.grid.time_origin.fulltime(time) message = ( f"{field.name if field else 'Field'} sampled outside time domain at time {time}." " Try setting allow_time_extrapolation to True." @@ -83,31 +105,26 @@ def __init__(self, time, field=None): super().__init__(message) +def _raise_time_extrapolation_error(time: float, field=None): + raise TimeExtrapolationError(time, field) + + class KernelError(RuntimeError): - """General particle kernel error with optional custom message.""" + """General particles kernel error with optional custom message.""" - def __init__(self, particle, fieldset=None, msg=None): - message = ( - f"{particle.state}\n" - f"Particle {particle}\n" - f"Time: {_parse_particletime(particle.time, fieldset)}\n" - f"timestep dt: {particle.dt}\n" - ) + def __init__(self, particles, fieldset=None, msg=None): + message = f"{particles.state}\nParticle {particles}\nTime: {particles.time}\ntimestep dt: {particles.dt}\n" if msg: message += msg super().__init__(message) -def _parse_particletime(time, fieldset): - if fieldset is not None and fieldset.time_origin: - time = fieldset.time_origin.fulltime(time) - return time - - AllParcelsErrorCodes = { - FieldSamplingError: StatusCode.Error, + FieldInterpolationError: StatusCode.ErrorInterpolation, FieldOutOfBoundError: StatusCode.ErrorOutOfBounds, FieldOutOfBoundSurfaceError: StatusCode.ErrorThroughSurface, + GridSearchingError: StatusCode.ErrorGridSearching, TimeExtrapolationError: StatusCode.ErrorTimeExtrapolation, KernelError: StatusCode.Error, + GeneralError: StatusCode.Error, } diff --git a/parcels/_core/utils/__init__.py b/parcels/_core/utils/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/parcels/_core/utils/time.py b/parcels/_core/utils/time.py new file mode 100644 index 000000000..8cc34acf4 --- /dev/null +++ b/parcels/_core/utils/time.py @@ -0,0 +1,146 @@ +from __future__ import annotations + +from datetime import datetime, timedelta +from typing import TYPE_CHECKING, TypeVar + +import cftime +import numpy as np + +if TYPE_CHECKING: + from parcels._typing import TimeLike + +T = TypeVar("T", bound="TimeLike") + + +class TimeInterval: + """A class representing a time interval between two datetime or np.timedelta64 objects. + + Parameters + ---------- + left : np.datetime64 or cftime.datetime or np.timedelta64 + The left endpoint of the interval. + right : np.datetime64 or cftime.datetime or np.timedelta64 + The right endpoint of the interval. + + Notes + ----- + For the purposes of this codebase, the interval can be thought of as closed on the left and right. + """ + + def __init__(self, left: T, right: T) -> None: + if not isinstance(left, (np.timedelta64, datetime, cftime.datetime, np.datetime64)): + raise ValueError( + f"Expected right to be a np.timedelta64, datetime, cftime.datetime, or np.datetime64. Got {type(left)}." + ) + if not isinstance(right, (np.timedelta64, datetime, cftime.datetime, np.datetime64)): + raise ValueError( + f"Expected right to be a np.timedelta64, datetime, cftime.datetime, or np.datetime64. Got {type(right)}." + ) + if left >= right: + raise ValueError(f"Expected left to be strictly less than right, got left={left} and right={right}.") + + if not is_compatible(left, right): + raise ValueError(f"Expected left and right to be compatible, got left={left} and right={right}.") + + self.left = left + self.right = right + + def __contains__(self, item: T) -> bool: + return self.left <= item <= self.right + + def is_all_time_in_interval(self, time): + item = np.atleast_1d(time) + return (self.left <= item).all() and (item <= self.right).all() + + def __repr__(self) -> str: + return f"TimeInterval(left={self.left!r}, right={self.right!r})" + + def __eq__(self, other: object) -> bool: + if not isinstance(other, TimeInterval): + return False + return self.left == other.left and self.right == other.right + + def __ne__(self, other: object) -> bool: + return not self.__eq__(other) + + def intersection(self, other: TimeInterval) -> TimeInterval | None: + """Return the intersection of two time intervals. Returns None if there is no overlap.""" + if not is_compatible(self.left, other.left): + raise ValueError("TimeIntervals are not compatible.") + if not is_compatible(self.right, other.right): + raise ValueError("TimeIntervals are not compatible.") + + start = max(self.left, other.left) + end = min(self.right, other.right) + + return TimeInterval(start, end) if start <= end else None + + +def is_compatible( + t1: datetime | cftime.datetime | np.timedelta64, t2: datetime | cftime.datetime | np.timedelta64 +) -> bool: + """ + Defines whether two datetime or np.timedelta64 objects are compatible in the context + of being left and right sides of an interval. + """ + # Ensure if either is a timedelta64, both must be + if isinstance(t1, np.timedelta64) ^ isinstance(t2, np.timedelta64): + return False + + try: + t1 - t2 + except Exception: + return False + else: + return True + + +def get_datetime_type_calendar( + example_datetime: TimeLike, +) -> tuple[type, str | None]: + """Get the type and calendar of a datetime object. + + Parameters + ---------- + example_datetime : datetime, cftime.datetime, or np.datetime64 + The datetime object to check. + + Returns + ------- + tuple[type, str | None] + A tuple containing the type of the datetime object and its calendar. + The calendar will be None if the datetime object is not a cftime datetime object. + """ + calendar = None + try: + calendar = example_datetime.calendar + except AttributeError: + # datetime isn't a cftime datetime object + pass + return type(example_datetime), calendar + + +_TD_PRECISION_GETTER_FOR_UNIT = ( + (lambda dt: dt.days, "D"), + (lambda dt: dt.seconds, "s"), + (lambda dt: dt.microseconds, "us"), +) + + +def maybe_convert_python_timedelta_to_numpy(dt: timedelta | np.timedelta64) -> np.timedelta64: + if isinstance(dt, np.timedelta64): + return dt + + try: + dts = [] + for get_value_for_unit, np_unit in _TD_PRECISION_GETTER_FOR_UNIT: + value = get_value_for_unit(dt) + if value != 0: + dts.append(np.timedelta64(value, np_unit)) + + if dts: + return sum(dts) + else: + return np.timedelta64(0, "s") + except Exception as e: + raise ValueError(f"Could not convert {dt!r} to np.timedelta64.") from e diff --git a/parcels/_core/utils/unstructured.py b/parcels/_core/utils/unstructured.py new file mode 100644 index 000000000..26a339a6d --- /dev/null +++ b/parcels/_core/utils/unstructured.py @@ -0,0 +1,26 @@ +DIM_TO_VERTICAL_LOCATION_MAP = { + "nz1": "center", + "nz": "face", +} + + +def get_vertical_location_from_dims(dims: tuple[str, ...]): + """ + Determine the vertical location of the field based on the uxarray.UxDataArray object variables. + + Only used for unstructured grids. + """ + vertical_dims_in_data = set(dims) & set(DIM_TO_VERTICAL_LOCATION_MAP.keys()) + + if len(vertical_dims_in_data) != 1: + raise ValueError( + f"Expected exactly one vertical dimension ({set(DIM_TO_VERTICAL_LOCATION_MAP.keys())}) in the data, got {vertical_dims_in_data}" + ) + + return DIM_TO_VERTICAL_LOCATION_MAP[vertical_dims_in_data.pop()] + + +def get_vertical_dim_name_from_location(location: str): + """Determine the vertical location of the field based on the uxarray.UxGrid object variables.""" + location_to_dim_map = {v: k for k, v in DIM_TO_VERTICAL_LOCATION_MAP.items()} + return location_to_dim_map[location] diff --git a/parcels/_core/uxgrid.py b/parcels/_core/uxgrid.py new file mode 100644 index 000000000..11da6daff --- /dev/null +++ b/parcels/_core/uxgrid.py @@ -0,0 +1,121 @@ +from __future__ import annotations + +from typing import Literal + +import numpy as np +import uxarray as ux + +from parcels._core.basegrid import BaseGrid +from parcels._core.index_search import GRID_SEARCH_ERROR, _search_1d_array, uxgrid_point_in_cell +from parcels._typing import assert_valid_mesh + +_UXGRID_AXES = Literal["Z", "FACE"] + + +class UxGrid(BaseGrid): + """ + Extension of uxarray's Grid class that supports point-location search + for interpolation on unstructured grids. + """ + + def __init__(self, grid: ux.grid.Grid, z: ux.UxDataArray, mesh="flat") -> UxGrid: + """ + Initializes the UxGrid with a uxarray grid and vertical coordinate array. + + Parameters + ---------- + grid : ux.grid.Grid + The uxarray grid object containing the unstructured grid data. + z : ux.UxDataArray + A 1D array of vertical coordinates (depths) associated with the layer interface heights (not the mid-layer depths). + While uxarray allows nz to be spatially and temporally varying, the parcels.UxGrid class considers the case where + the vertical coordinate is constant in time and space. This implies flat bottom topography and no moving ALE vertical grid. + mesh : str, optional + The type of mesh used for the grid. Either "flat" (default) or "spherical". + """ + self.uxgrid = grid + if not isinstance(z, ux.UxDataArray): + raise TypeError("z must be an instance of ux.UxDataArray") + if z.ndim != 1: + raise ValueError("z must be a 1D array of vertical coordinates") + self.z = z + self._mesh = mesh + self._spatialhash = None + + assert_valid_mesh(mesh) + + @property + def depth(self): + """ + Note + ---- + Included for compatibility with v3 codebase. May be removed in future. + TODO v4: Evaluate + """ + try: + _ = self.z.values + except KeyError: + return np.zeros(1) + return self.z.values + + @property + def axes(self) -> list[_UXGRID_AXES]: + return ["Z", "FACE"] + + def get_axis_dim(self, axis: _UXGRID_AXES) -> int: + if axis not in self.axes: + raise ValueError(f"Axis {axis!r} is not part of this grid. Available axes: {self.axes}") + + if axis == "Z": + return len(self.z.values) + elif axis == "FACE": + return self.uxgrid.n_face + + def search(self, z, y, x, ei=None, tol=1e-6): + """ + Search for the grid cell (face) and vertical layer that contains the given points. + + Parameters + ---------- + z : float or np.ndarray + The vertical coordinate(s) (depth) of the point(s). + y : float or np.ndarray + The latitude(s) of the point(s). + x : float or np.ndarray + The longitude(s) of the point(s). + ei : np.ndarray, optional + Precomputed horizontal indices (face indices) for the points. + + TO BE IMPLEMENTED : If provided, we'll check + if the points are within the faces specified by these indices. For cells where the particles + are not found, a nearest neighbor search will be performed. As a last resort, the spatial hash will be used. + tol : float, optional + Tolerance for barycentric coordinate checks. Default is 1e-6. + """ + x = np.asarray(x, dtype=np.float32) + y = np.asarray(y, dtype=np.float32) + z = np.asarray(z, dtype=np.float32) + + zi, zeta = _search_1d_array(self.z.values, z) + + if np.any(ei): + indices = self.unravel_index(ei) + fi = indices.get("FACE") + is_in_cell, coords = uxgrid_point_in_cell(self.uxgrid, y, x, fi, fi) + y_check = y[is_in_cell == 0] + x_check = x[is_in_cell == 0] + zero_indices = np.where(is_in_cell == 0)[0] + else: + # Otherwise, we need to check all points + fi = np.full(len(y), GRID_SEARCH_ERROR, dtype=np.int32) + y_check = y + x_check = x + coords = -1.0 * np.ones((len(y), 3), dtype=np.float32) + zero_indices = np.arange(len(y)) + + if len(zero_indices) > 0: + _, face_ids_q, coords_q = self.get_spatial_hash().query(y_check, x_check) + coords[zero_indices, :] = coords_q + fi[zero_indices] = face_ids_q + + return {"Z": (zi, zeta), "FACE": (fi, coords)} diff --git a/parcels/tools/warnings.py b/parcels/_core/warnings.py similarity index 68% rename from parcels/tools/warnings.py rename to parcels/_core/warnings.py index 7dbcbbbc9..908b3518e 100644 --- a/parcels/tools/warnings.py +++ b/parcels/_core/warnings.py @@ -1,5 +1,3 @@ -import warnings - __all__ = ["FieldSetWarning", "FileWarning", "KernelWarning", "ParticleSetWarning"] @@ -38,14 +36,3 @@ class KernelWarning(RuntimeWarning): """ pass - - -def _deprecated_param_netcdf_decodewarning(): - warnings.warn( - "The 'netcdf_decodewarning' argument is deprecated in v3.1.0 and will be removed completely in a future release. " - "The parameter no longer has any effect, please use the Python warnings module to control warnings, " - "e.g., warnings.filterwarnings('ignore', category=parcels.FileWarning). " - "See also https://docs.oceanparcels.org/en/latest/examples/tutorial_nemo_3D.html", - DeprecationWarning, - stacklevel=2, - ) diff --git a/parcels/_core/xgrid.py b/parcels/_core/xgrid.py new file mode 100644 index 000000000..d20d53f8b --- /dev/null +++ b/parcels/_core/xgrid.py @@ -0,0 +1,499 @@ +from collections.abc import Hashable, Mapping, Sequence +from functools import cached_property +from typing import Literal, cast + +import numpy as np +import numpy.typing as npt +import xarray as xr +import xgcm + +from parcels._core.basegrid import BaseGrid +from parcels._core.index_search import _search_1d_array, _search_indices_curvilinear_2d +from parcels._typing import assert_valid_mesh + +_XGRID_AXES = Literal["X", "Y", "Z"] +_XGRID_AXES_ORDERING: Sequence[_XGRID_AXES] = "ZYX" + +_XGCM_AXIS_DIRECTION = Literal["X", "Y", "Z", "T"] +_XGCM_AXIS_POSITION = Literal["center", "left", "right", "inner", "outer"] +_XGCM_AXES = Mapping[_XGCM_AXIS_DIRECTION, xgcm.Axis] + +_FIELD_DATA_ORDERING: Sequence[_XGCM_AXIS_DIRECTION] = "TZYX" + +_DEFAULT_XGCM_KWARGS = {"periodic": False} + + +def get_cell_count_along_dim(ds: xr.Dataset, axis: xgcm.Axis) -> int: + first_coord = list(axis.coords.items())[0] + _, coord_var = first_coord + + return ds[coord_var].size - 1 + + +def get_time(ds: xr.Dataset, axis: xgcm.Axis) -> npt.NDArray: + return ds[axis.coords["center"]].values + + +def _get_xgrid_axes(grid: xgcm.Grid) -> list[_XGRID_AXES]: + spatial_axes = [a for a in grid.axes.keys() if a in ["X", "Y", "Z"]] + return sorted(spatial_axes, key=_XGRID_AXES_ORDERING.index) + + +def _drop_field_data(ds: xr.Dataset) -> xr.Dataset: + """ + Removes DataArrays from the dataset that are associated with field data so that + when passed to the XGCM grid, the object only functions as an in memory representation + of the grid. + """ + return ds.drop_vars(ds.data_vars) + + +def _transpose_xfield_data_to_tzyx(da: xr.DataArray, xgcm_grid: xgcm.Grid) -> xr.DataArray: + """ + Transpose a DataArray of any shape into a 4D array of order TZYX. Uses xgcm to determine + the axes, and inserts mock dimensions of size 1 for any axes not present in the DataArray. + """ + ax_dims = [(get_axis_from_dim_name(xgcm_grid.axes, dim), dim) for dim in da.dims] + + if all(ax_dim[0] is None for ax_dim in ax_dims): + # Assuming its a 1D constant field (hence has no axes) + assert da.shape == (1, 1, 1, 1) + return da.rename({old_dim: f"mock{axis}" for old_dim, axis in zip(da.dims, _FIELD_DATA_ORDERING, strict=True)}) + + # All dimensions must be associated with an axis in the grid + if any(ax_dim[0] is None for ax_dim in ax_dims): + raise ValueError( + f"DataArray {da.name!r} with dims {da.dims} has dimensions that are not associated with a direction on the provided grid." + ) + + axes_not_in_field = set(_FIELD_DATA_ORDERING) - set(ax_dim[0] for ax_dim in ax_dims) + + mock_dims_to_create = {} + for ax in axes_not_in_field: + mock_dims_to_create[f"mock{ax}"] = 1 + ax_dims.append((ax, f"mock{ax}")) + + if mock_dims_to_create: + da = da.expand_dims(mock_dims_to_create, create_index_for_new_dim=False) + + ax_dims = sorted(ax_dims, key=lambda x: _FIELD_DATA_ORDERING.index(x[0])) + + return da.transpose(*[ax_dim[1] for ax_dim in ax_dims]) + + +class XGrid(BaseGrid): + """ + Class to represent a structured grid in Parcels. Wraps a xgcm-like Grid object (we use a trimmed down version of the xgcm.Grid class that is vendored with Parcels). + + This class provides methods and properties required for indexing and interpolating on the grid. + + Assumptions: + - If using Parcels in the context of a spatially periodic simulation, the provided grid already has a halo + + """ + + def __init__(self, grid: xgcm.Grid, mesh="flat"): + self.xgcm_grid = grid + self._mesh = mesh + self._spatialhash = None + ds = grid._ds + + # Set the coordinates for the dataset (needed to be done explicitly for curvilinear grids) + if "lon" in ds: + ds.set_coords("lon") + if "lat" in ds: + ds.set_coords("lat") + + if len(set(grid.axes) & {"X", "Y", "Z"}) > 0: # Only if spatial grid is >0D (see #2054 for further development) + assert_valid_lat_lon(ds["lat"], ds["lon"], grid.axes) + + assert_valid_mesh(mesh) + self._ds = ds + + @classmethod + def from_dataset(cls, ds: xr.Dataset, mesh="flat", xgcm_kwargs=None): + """WARNING: unstable API, subject to change in future versions.""" # TODO v4: make private or remove warning on v4 release + if xgcm_kwargs is None: + xgcm_kwargs = {} + + xgcm_kwargs = {**_DEFAULT_XGCM_KWARGS, **xgcm_kwargs} + + ds = _drop_field_data(ds) + grid = xgcm.Grid(ds, **xgcm_kwargs) + return cls(grid, mesh=mesh) + + @property + def axes(self) -> list[_XGRID_AXES]: + return _get_xgrid_axes(self.xgcm_grid) + + @property + def lon(self): + """ + Note + ---- + Included for compatibility with v3 codebase. May be removed in future. + TODO v4: Evaluate + """ + try: + _ = self.xgcm_grid.axes["X"] + except KeyError: + return np.zeros(1) + return self._ds["lon"].values + + @property + def lat(self): + """ + Note + ---- + Included for compatibility with v3 codebase. May be removed in future. + TODO v4: Evaluate + """ + try: + _ = self.xgcm_grid.axes["Y"] + except KeyError: + return np.zeros(1) + return self._ds["lat"].values + + @property + def depth(self): + """ + Note + ---- + Included for compatibility with v3 codebase. May be removed in future. + TODO v4: Evaluate + """ + try: + _ = self.xgcm_grid.axes["Z"] + except KeyError: + return np.zeros(1) + return self._ds["depth"].values + + @property + def _datetimes(self): + try: + axis = self.xgcm_grid.axes["T"] + except KeyError: + return np.zeros(1) + return get_time(self._ds, axis) + + @property + def time(self): + return self._datetimes.astype(np.float64) / 1e9 + + @cached_property + def xdim(self) -> int: + return self.get_axis_dim("X") + + @cached_property + def ydim(self) -> int: + return self.get_axis_dim("Y") + + @cached_property + def zdim(self) -> int: + return self.get_axis_dim("Z") + + def get_axis_dim(self, axis: _XGRID_AXES) -> int: + if axis not in self.axes: + raise ValueError(f"Axis {axis!r} is not part of this grid. Available axes: {self.axes}") + + return get_cell_count_along_dim(self._ds, self.xgcm_grid.axes[axis]) + + def localize(self, position: dict[_XGRID_AXES, tuple[int, float]], dims: list[str]) -> dict[str, tuple[int, float]]: + """ + Uses the grid context (i.e., the staggering of the grid) to convert a position relative + to the F-points in the grid to a position relative to the staggered grid the array + of interest is defined on. + + Uses dimensions of the DataArray to determine the staggered grid. + + WARNING: This API is unstable and subject to change in future versions. + + Parameters + ---------- + position : dict + A mapping of the axis to a tuple of (index, barycentric coordinate) for the + F-points in the grid. + dims : list[str] + A list of dimension names that the DataArray is defined on. This is used to determine + the staggering of the grid and which axis each dimension corresponds to. + + Returns + ------- + dict[str, tuple[int, float]] + A mapping of the dimension names to a tuple of (index, barycentric coordinate) for + the staggered grid the DataArray is defined on. + + Example + ------- + >>> position = {'X': (5, 0.51), 'Y': ( + 10, 0.25), 'Z': (3, 0.75)} + >>> dims = ['time', 'depth', 'YC', 'XC'] + >>> grid.localize(position, dims) + {'depth': (3, 0.75), 'YC': (9, 0.75), 'XC': (5, 0.01)} + """ + axis_to_var = {get_axis_from_dim_name(self.xgcm_grid.axes, dim): dim for dim in dims} + var_positions = { + axis: get_xgcm_position_from_dim_name(self.xgcm_grid.axes, dim) for axis, dim in axis_to_var.items() + } + return { + axis_to_var[axis]: _convert_center_pos_to_fpoint( + index=index, + bcoord=bcoord, + xgcm_position=var_positions[axis], + f_points_xgcm_position=self._fpoint_info[axis], + ) + for axis, (index, bcoord) in position.items() + } + + @property + def _z4d(self) -> Literal[0, 1]: + """ + Note + ---- + Included for compatibility with v3 codebase. May be removed in future. + TODO v4: Evaluate + """ + return 1 if self.depth.shape == 4 else 0 + + @property + def zonal_periodic(self): ... # ? hmmm, from v3, do we still need this? + + @property + def _gtype(self): + """This class is created *purely* for compatibility with v3 code and will be removed + or changed in future. + + TODO: Remove + """ + from parcels.grid import GridType + + if len(self.lon.shape) <= 1: + if self.depth is None or len(self.depth.shape) <= 1: + return GridType.RectilinearZGrid + else: + return GridType.RectilinearSGrid + else: + if self.depth is None or len(self.depth.shape) <= 1: + return GridType.CurvilinearZGrid + else: + return GridType.CurvilinearSGrid + + def search(self, z, y, x, ei=None): + ds = self._ds + + if "Z" in self.axes: + zi, zeta = _search_1d_array(ds.depth.values, z) + else: + zi, zeta = np.zeros(z.shape, dtype=int), np.zeros(z.shape, dtype=float) + + if ds.lon.ndim == 1: + yi, eta = _search_1d_array(ds.lat.values, y) + xi, xsi = _search_1d_array(ds.lon.values, x) + return {"Z": (zi, zeta), "Y": (yi, eta), "X": (xi, xsi)} + + yi, xi = None, None + if ei is not None: + axis_indices = self.unravel_index(ei) + xi = axis_indices.get("X") + yi = axis_indices.get("Y") + + if ds.lon.ndim == 2: + yi, eta, xi, xsi = _search_indices_curvilinear_2d(self, y, x, yi, xi) + + return {"Z": (zi, zeta), "Y": (yi, eta), "X": (xi, xsi)} + + raise NotImplementedError("Searching in >2D lon/lat arrays is not implemented yet.") + + @cached_property + def _fpoint_info(self): + """Returns a mapping of the spatial axes in the Grid to their XGCM positions.""" + xgcm_axes = self.xgcm_grid.axes + f_point_positions = ["left", "right", "inner", "outer"] + axis_position_mapping = {} + for axis in self.axes: + coords = xgcm_axes[axis].coords + edge_positions = [pos for pos in coords.keys() if pos in f_point_positions] + assert len(edge_positions) == 1, f"Axis {axis} has multiple edge positions: {edge_positions}" + axis_position_mapping[axis] = edge_positions[0] + + return axis_position_mapping + + def get_axis_dim_mapping(self, dims: list[str]) -> dict[_XGRID_AXES, str]: + """ + Maps xarray dimension names to their corresponding axis (X, Y, Z). + + WARNING: This API is unstable and subject to change in future versions. + + Parameters + ---------- + dims : list[str] + List of xarray dimension names + + Returns + ------- + dict[_XGRID_AXES, str] + Dictionary mapping axes (X, Y, Z) to their corresponding dimension names + + Examples + -------- + >>> grid.get_axis_dim_mapping(['time', 'lat', 'lon']) + {'Y': 'lat', 'X': 'lon'} + + Notes + ----- + Only returns mappings for spatial axes (X, Y, Z) that are present in the grid. + """ + result = {} + for dim in dims: + axis = get_axis_from_dim_name(self.xgcm_grid.axes, dim) + if axis in self.axes: # Only include spatial axes (X, Y, Z) + result[cast(_XGRID_AXES, axis)] = dim + return result + + +def get_axis_from_dim_name(axes: _XGCM_AXES, dim: str) -> _XGCM_AXIS_DIRECTION | None: + """For a given dimension name in a grid, returns the direction axis it is on.""" + for axis_name, axis in axes.items(): + if dim in axis.coords.values(): + return axis_name + return None + + +def get_xgcm_position_from_dim_name(axes: _XGCM_AXES, dim: str) -> _XGCM_AXIS_POSITION | None: + """For a given dimension, returns the position of the variable in the grid.""" + for axis in axes.values(): + var_to_position = {var: position for position, var in axis.coords.items()} + + if dim in var_to_position: + return var_to_position[dim] + return None + + +def assert_all_dimensions_correspond_with_axis(da: xr.DataArray, axes: _XGCM_AXES) -> None: + dim_to_axis = {dim: get_axis_from_dim_name(axes, dim) for dim in da.dims} + + for dim, direction in dim_to_axis.items(): + if direction is None: + raise ValueError( + f"Dimension {dim!r} for DataArray {da.name!r} with dims {da.dims} is not associated with a direction on the provided grid." + ) + + +def assert_valid_field_array(da: xr.DataArray, axes: _XGCM_AXES): + """ + Asserts that for a data array: + - All dimensions are associated with a direction on the grid + - These directions are T, Z, Y, X and the array is ordered as T, Z, Y, X + """ + assert_all_dimensions_correspond_with_axis(da, axes) + + dim_to_axis = {dim: get_axis_from_dim_name(axes, dim) for dim in da.dims} + dim_to_axis = cast(dict[Hashable, _XGCM_AXIS_DIRECTION], dim_to_axis) + + # Assert all dimensions are present + if set(dim_to_axis.values()) != {"T", "Z", "Y", "X"}: + raise ValueError( + f"DataArray {da.name!r} with dims {da.dims} has directions {tuple(dim_to_axis.values())}." + "Expected directions of 'T', 'Z', 'Y', and 'X'." + ) + + # Assert order is t, z, y, x + if list(dim_to_axis.values()) != ["T", "Z", "Y", "X"]: + raise ValueError( + f"Dimension order for array {da.name!r} is not valid. Got {tuple(dim_to_axis.keys())} with associated directions of {tuple(dim_to_axis.values())}. Expected directions of ('T', 'Z', 'Y', 'X'). Transpose your array accordingly." + ) + + +def assert_valid_lat_lon(da_lat, da_lon, axes: _XGCM_AXES): + """ + Asserts that the provided longitude and latitude DataArrays are defined appropriately + on the F points to match the internal representation in Parcels. + + - Longitude and latitude must be 1D or 2D (both must have the same dimensionality) + - Both are defined on the left points (i.e., not the centers) + - If 1D: + - Longitude is associated with the X axis + - Latitude is associated with the Y axis + - If 2D: + - Lon and lat are defined on the same dimensions + - Lon and lat are transposed such they're Y, X + """ + assert_all_dimensions_correspond_with_axis(da_lon, axes) + assert_all_dimensions_correspond_with_axis(da_lat, axes) + + dim_to_position = {dim: get_xgcm_position_from_dim_name(axes, dim) for dim in da_lon.dims} + dim_to_position.update({dim: get_xgcm_position_from_dim_name(axes, dim) for dim in da_lat.dims}) + + for dim in da_lon.dims: + if get_xgcm_position_from_dim_name(axes, dim) == "center": + raise ValueError( + f"Longitude DataArray {da_lon.name!r} with dims {da_lon.dims} is defined on the center of the grid, but must be defined on the F points." + ) + for dim in da_lat.dims: + if get_xgcm_position_from_dim_name(axes, dim) == "center": + raise ValueError( + f"Latitude DataArray {da_lat.name!r} with dims {da_lat.dims} is defined on the center of the grid, but must be defined on the F points." + ) + + if da_lon.ndim != da_lat.ndim: + raise ValueError( + f"Longitude DataArray {da_lon.name!r} with dims {da_lon.dims} and Latitude DataArray {da_lat.name!r} with dims {da_lat.dims} have different dimensionalities." + ) + if da_lon.ndim not in (1, 2): + raise ValueError( + f"Longitude DataArray {da_lon.name!r} with dims {da_lon.dims} and Latitude DataArray {da_lat.name!r} with dims {da_lat.dims} must be 1D or 2D." + ) + + if da_lon.ndim == 1: + if get_axis_from_dim_name(axes, da_lon.dims[0]) != "X": + raise ValueError( + f"Longitude DataArray {da_lon.name!r} with dims {da_lon.dims} is not associated with the X axis." + ) + if get_axis_from_dim_name(axes, da_lat.dims[0]) != "Y": + raise ValueError( + f"Latitude DataArray {da_lat.name!r} with dims {da_lat.dims} is not associated with the Y axis." + ) + + if not np.all(np.diff(da_lon.values) > 0): + raise ValueError( + f"Longitude DataArray {da_lon.name!r} with dims {da_lon.dims} must be strictly increasing." + ) + if not np.all(np.diff(da_lat.values) > 0): + raise ValueError(f"Latitude DataArray {da_lat.name!r} with dims {da_lat.dims} must be strictly increasing.") + + if da_lon.ndim == 2: + if da_lon.dims != da_lat.dims: + raise ValueError( + f"Longitude DataArray {da_lon.name!r} with dims {da_lon.dims} and Latitude DataArray {da_lat.name!r} with dims {da_lat.dims} must be defined on the same dimensions." + ) + + lon_axes = [get_axis_from_dim_name(axes, dim) for dim in da_lon.dims] + if lon_axes != ["Y", "X"]: + raise ValueError( + f"Longitude DataArray {da_lon.name!r} with dims {da_lon.dims} and Latitude DataArray {da_lat.name!r} with dims {da_lat.dims} must be defined on the X and Y axes and transposed to have dimensions in order of Y, X." + ) + + +def _convert_center_pos_to_fpoint( + *, index: int, bcoord: float, xgcm_position: _XGCM_AXIS_POSITION, f_points_xgcm_position: _XGCM_AXIS_POSITION +) -> tuple[int, float]: + """Converts a physical position relative to the cell edges defined in the grid to be relative to the center point. + + This is used to "localize" a position to be relative to the staggered grid at which the field is defined, so that + it can be easily interpolated. + + This also handles different model input cell edges and centers are staggered in different directions (e.g., with NEMO and MITgcm). + """ + if xgcm_position != "center": # Data is already defined on the F points + return index, bcoord + + bcoord = bcoord - 0.5 + if bcoord < 0: + bcoord += 1.0 + index -= 1 + + # Correct relative to the f-point position + if f_points_xgcm_position in ["inner", "right"]: + index += 1 + + return index, bcoord diff --git a/parcels/_datasets/__init__.py b/parcels/_datasets/__init__.py new file mode 100644 index 000000000..29db98c5f --- /dev/null +++ b/parcels/_datasets/__init__.py @@ -0,0 +1,48 @@ +""" +Datasets compatible with Parcels. + +This subpackage uses xarray to generate *idealised* structured and unstructured hydrodynamical datasets that are compatible with Parcels. The goals are three-fold: + +1. To provide users with documentation for the types of datasets they can expect Parcels to work with. When reporting bugs, users can use these datasets to reproduce the bug they're experiencing (allowing developers to quickly troubleshoot the problem). +2. To supply our tutorials with hydrodynamical datasets. +3. To offer developers datasets for use in test cases. + +Note that this subpackage is part of the private API for Parcels. Users should not rely directly on the functions defined within this module. Instead, if you want to generate your own datasets, copy the functions from this module into your own code. + +Developers, note that you should only add functions that create idealised datasets to this subpackage if they are (a) quick to generate, and (b) only use dependencies already shipped with Parcels. No data files should be added to this subpackage. Real world data files should be added to the `OceanParcels/parcels-data` repository on GitHub. + +Parcels Dataset Philosophy +------------------------- + +When adding datasets, there may be a tension between wanting to add a specific dataset or wanting to add machinery to generate completely parameterised datasets (e.g., with different grid resolutions, with different ranges, with different datetimes etc.). There are trade-offs to both approaches: + +Working with specific hardcoded datasets: + +* Pros + * the example is stable and self-contained + * easy to see exactly what the dataset is, there is little to no dependency on other functions defined in the same module + * datasets don't "break" due to changes in other functions (e.g., grid edges becoming out of sync with grid centres) +* Cons + * inflexible for use in tests where you want to test a large range of datasets, or you want to test a specific resolution + +Working with generated datasets is the opposite of all the above. + +Most of the time we only want a single dataset. For example, for use in a tutorial, or for testing a specific feature of Parcels - such as (in the case of structured grids) checking that the grid from a certain (ocean) circulation model is correctly parsed, or checking that indexing is correctly picked up. As such, one should often opt for hardcoded datasets. These are more stable and easier to see exactly what the dataset is. We may have specific examples that become the default "go to" dataset for testing when we don't care about the details of the dataset. + +Sometimes we may want to test Parcels against a whole range of datasets varying in a certain way - to ensure Parcels works as expected. For these, we should add machinery to create generated datasets. + +Structure +-------- + +This subpackage is broken down into structured and unstructured parts. Each of these have common submodules: + +* ``circulation_model`` -> hardcoded datasets with the intention of mimicking dataset structure from a certain (ocean) circulation model. If you'd like to see Parcel support a new model, please open an issue in our issue tracker. + * exposes a dict ``datasets`` mapping dataset names to xarray datasets +* ``generic`` -> hardcoded datasets that are generic, and not tied to a certain (ocean) circulation model. Instead these focus on the fundamental properties of the dataset + * exposes a dict ``datasets`` mapping dataset names to xarray datasets +* ``generated`` -> functions to generate datasets with varying properties +* ``utils`` -> any utility functions necessary related to either generating or validating datasets + +There may be extra submodules than the ones listed above. + +""" diff --git a/parcels/_datasets/structured/__init__.py b/parcels/_datasets/structured/__init__.py new file mode 100644 index 000000000..ceb94d0af --- /dev/null +++ b/parcels/_datasets/structured/__init__.py @@ -0,0 +1,7 @@ +"""Structured datasets.""" + +_N = 30 +X = _N +Y = 2 * _N +Z = 3 * _N +T = 13 diff --git a/parcels/_datasets/structured/circulation_models.py b/parcels/_datasets/structured/circulation_models.py new file mode 100644 index 000000000..7933db367 --- /dev/null +++ b/parcels/_datasets/structured/circulation_models.py @@ -0,0 +1,1264 @@ +"""Datasets mimicking the layout of real-world hydrodynamic models""" + +import numpy as np +import xarray as xr + +from . import T, X, Y, Z + +__all__ = ["T", "X", "Y", "Z", "datasets"] + +TIME = np.datetime64("2000-01-01") + np.arange(T) * np.timedelta64(1, "D") + + +def _copernicusmarine(): + """Copernicus Marine Service dataset as retrieved by the `copernicusmarine` toolkit""" + return xr.Dataset( + { + "uo": ( + ["time", "depth", "latitude", "longitude"], + np.random.rand(T, Z, Y, X), + { + "valid_max": 5.0, + "unit_long": "Meters per second", + "units": "m s-1", + "long_name": "Eastward velocity", + "standard_name": "eastward_sea_water_velocity", + "valid_min": -5.0, + }, + ), + "vo": ( + ["time", "depth", "latitude", "longitude"], + np.random.rand(T, Z, Y, X), + { + "valid_max": 5.0, + "unit_long": "Meters per second", + "units": "m s-1", + "long_name": "Northward velocity", + "standard_name": "northward_sea_water_velocity", + "valid_min": -5.0, + }, + ), + }, + coords={ + "depth": ( + ["depth"], + np.linspace(0.49, 5727.92, Z), + { + "unit_long": "Meters", + "units": "m", + "axis": "Z", + "long_name": "Depth", + "standard_name": "depth", + "positive": "down", + }, + ), + "latitude": ( + ["latitude"], + np.linspace(-90, 90, Y), + { + "unit_long": "Degrees North", + "units": "degrees_north", + "axis": "Y", + "long_name": "Latitude", + "standard_name": "latitude", + }, + ), + "longitude": ( + ["longitude"], + np.linspace(-180, 180, X), + { + "unit_long": "Degrees East", + "units": "degrees_east", + "axis": "X", + "long_name": "Longitude", + "standard_name": "longitude", + }, + ), + "time": ( + ["time"], + TIME, + { + "unit_long": "Hours Since 1950-01-01", + "axis": "T", + "long_name": "Time", + "standard_name": "time", + }, + ), + }, + ) + + +def _copernicusmarine_waves(): + """Copernicus Marine Service GlobCurrent dataset (MULTIOBS_GLO_PHY_MYNRT_015_003)""" + return xr.Dataset( + { + "VSDX": ( + ["time", "depth", "latitude", "longitude"], + np.random.rand(T, Z, Y, X), + { + "units": "m s-1", + "standard_name": "sea_surface_wave_stokes_drift_x_velocity", + "long_name": "Stokes drift U", + "WMO_code": 215, + "cell_methods": "time:point area:mean", + "missing_value": -32767, + "type_of_analysis": "spectral analysis", + }, + ), + "VSDY": ( + ["time", "depth", "latitude", "longitude"], + np.random.rand(T, Z, Y, X), + { + "units": "m s-1", + "standard_name": "sea_surface_wave_stokes_drift_y_velocity", + "long_name": "Stokes drift V", + "WMO_code": 216, + "cell_methods": "time:point area:mean", + "missing_value": -32767, + "type_of_analysis": "spectral analysis", + }, + ), + }, + coords={ + "depth": ( + ["depth"], + np.linspace(-0.0, 15, Z), + { + "standard_name": "depth", + "long_name": "Depth", + "units": "m", + "unit_long": "Meters", + "axis": "Z", + "positive": "down", + }, + ), + "latitude": ( + ["latitude"], + np.linspace(-90, 90, Y), + { + "unit_long": "Degrees North", + "units": "degrees_north", + "axis": "Y", + "long_name": "Latitude", + "standard_name": "latitude", + }, + ), + "longitude": ( + ["longitude"], + np.linspace(-180, 180, X), + { + "unit_long": "Degrees East", + "units": "degrees_east", + "axis": "X", + "long_name": "Longitude", + "standard_name": "longitude", + }, + ), + "time": ( + ["time"], + TIME, + { + "axis": "T", + "long_name": "Time", + "standard_name": "time", + }, + ), + }, + ) + + +def _NEMO_MOI_U(): + """NEMO model dataset (U component) as serviced by Mercator Ocean International""" + return xr.Dataset( + { + "vozocrtx": ( + ["deptht", "y", "x"], + np.random.rand(Z, Y, X), + { + "units": "m s-1", + "valid_min": -10.0, + "valid_max": 10.0, + "long_name": "Zonal velocity", + "standard_name": "sea_water_x_velocity", + "short_name": "vozocrtx", + "online_operation": "N/A", + "interval_operation": 86400, + "interval_write": 86400, + "associate": "time_counter deptht nav_lat nav_lon", + }, + ), + "sotkeavmu1": ( + ["y", "x"], + np.random.rand(Y, X), + { + "units": "m2 s-1", + "valid_min": 0.0, + "valid_max": 100.0, + "long_name": "Vertical Eddy Viscosity U 1m", + "standard_name": "ocean_vertical_eddy_viscosity_u_1m", + "short_name": "sotkeavmu1", + "online_operation": "N/A", + "interval_operation": 86400, + "interval_write": 86400, + "associate": "time_counter nav_lat nav_lon", + }, + ), + }, + coords={ + "nav_lon": ( + ["y", "x"], + np.tile(np.linspace(-179, 179, X, endpoint=False), (Y, 1)), # note that this is not curvilinear + { + "units": "degrees_east", + "valid_min": -179.99984754002182, + "valid_max": 179.999842386314, + "long_name": "Longitude", + "nav_model": "Default grid", + "standard_name": "longitude", + }, + ), + "nav_lat": ( + ["y", "x"], + np.tile(np.linspace(-75, 85, Y).reshape(-1, 1), (1, X)), # note that this is not curvilinear + { + "units": "degrees_north", + "valid_min": -77.0104751586914, + "valid_max": 89.9591064453125, + "long_name": "Latitude", + "nav_model": "Default grid", + "standard_name": "latitude", + }, + ), + "x": ( + ["x"], + np.arange(X, dtype="int32"), + { + "standard_name": "projection_x_coordinate", + "axis": "X", + "units": "1", + }, + ), + "y": ( + ["y"], + np.arange(Y, dtype="int32"), + { + "standard_name": "projection_y_coordinate", + "axis": "Y", + "units": "1", + }, + ), + "deptht": ( + ["deptht"], + np.linspace(1, 5500, Z, dtype="float64"), + { + "units": "m", + "positive": "down", + "valid_min": 0.4940253794193268, + "valid_max": 5727.91650390625, + "long_name": "Vertical T levels", + "standard_name": "depth", + "axis": "Z", + }, + ), + }, + ) + + +def _NEMO_MOI_V(): + """NEMO model dataset (V component) as serviced by Mercator Ocean International""" + return xr.Dataset( + { + "vomecrty": ( + ["deptht", "y", "x"], + np.random.rand(Z, Y, X), + { + "units": "m s-1", + "valid_min": -10.0, + "valid_max": 10.0, + "long_name": "Meridional velocity", + "standard_name": "sea_water_y_velocity", + "short_name": "vomecrty", + "online_operation": "N/A", + "interval_operation": 86400, + "interval_write": 86400, + "associate": "time_counter deptht nav_lat nav_lon", + }, + ), + }, + coords={ + "nav_lon": ( + ["y", "x"], + np.tile(np.linspace(-179, 179, X, endpoint=False), (Y, 1)), # note that this is not curvilinear + { + "units": "degrees_east", + "valid_min": -179.9999951021171, + "valid_max": 180.0, + "long_name": "Longitude", + "nav_model": "Default grid", + "standard_name": "longitude", + }, + ), + "nav_lat": ( + ["y", "x"], + np.tile(np.linspace(-75, 85, Y).reshape(-1, 1), (1, X)), # note that this is not curvilinear + { + "units": "degrees_north", + "valid_min": -77.00110752801133, + "valid_max": 89.95529158641207, + "long_name": "Latitude", + "nav_model": "Default grid", + "standard_name": "latitude", + }, + ), + "x": ( + ["x"], + np.arange(X, dtype="int32"), + { + "standard_name": "projection_x_coordinate", + "axis": "X", + "units": "1", + }, + ), + "y": ( + ["y"], + np.arange(Y, dtype="int32"), + { + "standard_name": "projection_y_coordinate", + "axis": "Y", + "units": "1", + }, + ), + "deptht": ( + ["deptht"], + np.linspace(1, 5500, Z, dtype="float64"), + { + "units": "m", + "positive": "down", + "valid_min": 0.4940253794193268, + "valid_max": 5727.91650390625, + "long_name": "Vertical T levels", + "standard_name": "depth", + "axis": "Z", + }, + ), + }, + ) + + +def _CESM(): + """CESM model dataset""" + return xr.Dataset( + { + "UVEL": ( + ["time", "z_t", "nlat", "nlon"], + np.random.rand(T, Z, Y, X).astype("float32"), + { + "long_name": "Velocity in grid-x direction", + "units": "centimeter/s", + "grid_loc": "3221", + "cell_methods": "time: mean", + }, + ), + "VVEL": ( + ["time", "z_t", "nlat", "nlon"], + np.random.rand(T, Z, Y, X).astype("float32"), + { + "long_name": "Velocity in grid-y direction", + "units": "centimeter/s", + "grid_loc": "3221", + "cell_methods": "time: mean", + }, + ), + "WVEL": ( + ["time", "z_w_top", "nlat", "nlon"], + np.random.rand(T, Z, Y, X).astype("float32"), + { + "long_name": "Vertical Velocity", + "units": "centimeter/s", + "grid_loc": "3112", + "cell_methods": "time: mean", + }, + ), + }, + coords={ + "time": ( + ["time"], + np.linspace(0, 5000, T), + { + "long_name": "time", + "bounds": "time_bound", + }, + ), + "z_t": ( + ["z_t"], + np.linspace(0, 5000, Z, dtype="float32"), + { + "long_name": "depth from surface to midpoint of layer", + "units": "centimeters", + "positive": "down", + "valid_min": 500.0, + "valid_max": 537500.0, + }, + ), + "z_w_top": ( + ["z_w_top"], + np.linspace(0, 5000, Z, dtype="float32"), + { + "long_name": "depth from surface to top of layer", + "units": "centimeters", + "positive": "down", + "valid_min": 0.0, + "valid_max": 525000.9375, + }, + ), + "ULONG": ( + ["nlat", "nlon"], + np.tile(np.linspace(-179, 179, X, endpoint=False), (Y, 1)), # note that this is not curvilinear + { + "long_name": "array of u-grid longitudes", + "units": "degrees_east", + }, + ), + "ULAT": ( + ["nlat", "nlon"], + np.tile(np.linspace(-75, 85, Y).reshape(-1, 1), (1, X)), # note that this is not curvilinear + { + "long_name": "array of u-grid latitudes", + "units": "degrees_north", + }, + ), + }, + ) + + +def _MITgcm_netcdf(): + """MITgcm model dataset in netCDF format""" + return xr.Dataset( + # + { + "U": ( + ["T", "Z", "Y", "Xp1"], + np.random.rand(T, Z, Y, X + 1).astype("float32"), + { + "units": "m/s", + "coordinates": "XU YU RC iter", + }, + ), + "V": ( + ["T", "Z", "Yp1", "X"], + np.random.rand(T, Z, Y + 1, X).astype("float32"), + { + "units": "m/s", + "coordinates": "XV YV RC iter", + }, + ), + "W": ( + ["T", "Zl", "Y", "X"], + np.random.rand(T, Z, Y, X).astype("float32"), + { + "units": "m/s", + "coordinates": "XC YC RC iter", + }, + ), + "Temp": ( + ["T", "Z", "Y", "X"], + np.random.rand(T, Z, Y, X).astype("float32"), + { + "units": "degC", + "coordinates": "XC YC RC iter", + "long_name": "potential_temperature", + }, + ), + }, + coords={ + "T": ( + ["T"], + np.arange(0, T, dtype="float64"), + { + "long_name": "model_time", + "units": "s", + }, + ), + "Z": ( + ["Z"], + np.linspace(-25, -5000, Z, dtype="float64"), + { + "long_name": "vertical coordinate of cell center", + "units": "meters", + "positive": "up", + }, + ), + "Zl": ( + ["Zl"], + np.linspace(0, -4500, Z, dtype="float64"), + { + "long_name": "vertical coordinate of upper cell interface", + "units": "meters", + "positive": "up", + }, + ), + "Y": ( + ["Y"], + np.linspace(500, 5000, Y, dtype="float64"), + { + "long_name": "Y-Coordinate of cell center", + "units": "meters", + }, + ), + "Yp1": ( + ["Yp1"], + np.linspace(0, 4500, Y + 1, dtype="float64"), + { + "long_name": "Y-Coordinate of cell corner", + "units": "meters", + }, + ), + "X": ( + ["X"], + np.linspace(500, 5000, X, dtype="float64"), + { + "long_name": "X-coordinate of cell center", + "units": "meters", + }, + ), + "Xp1": ( + ["Xp1"], + np.linspace(0, 4100, X + 1, dtype="float64"), + { + "long_name": "X-Coordinate of cell corner", + "units": "meters", + }, + ), + }, + ) + + +def _MITgcm_mds(): + """MITgcm model dataset in native MDS format""" + return xr.Dataset( + { + "U": ( + ["time", "Z", "YC", "XG"], + np.random.rand(T, Z, Y, X).astype("float32"), + { + "standard_name": "sea_water_x_velocity", + "mate": "V", + "long_name": "Zonal Component of Velocity", + "units": "m s-1", + }, + ), + "V": ( + ["time", "Z", "YG", "XC"], + np.random.rand(T, Z, Y, X).astype("float32"), + { + "standard_name": "sea_water_y_velocity", + "mate": "U", + "long_name": "Meridional Component of Velocity", + "units": "m s-1", + }, + ), + "W": ( + ["time", "Zl", "YC", "XC"], + np.random.rand(T, Z, Y, X).astype("float32"), + { + "standard_name": "sea_water_z_velocity", + "long_name": "Vertical Component of Velocity", + "units": "m s-1", + }, + ), + "S": ( + ["time", "Z", "YC", "XC"], + np.random.rand(T, Z, Y, X).astype("float32"), + { + "standard_name": "sea_water_salinity", + "long_name": "Salinity", + "units": "g kg-1", + }, + ), + "T": ( + ["time", "Z", "YC", "XC"], + np.random.rand(T, Z, Y, X).astype("float32"), + { + "standard_name": "sea_water_potential_temperature", + "long_name": "Potential Temperature", + "units": "degree_Celcius", + }, + ), + }, + coords={ + "time": ( + ["time"], + np.arange(T) * np.timedelta64(1, "D"), + { + "standard_name": "time", + "long_name": "Time", + "axis": "T", + "calendar": "gregorian", + }, + ), + "Z": ( + ["Z"], + np.linspace(-25, -5000, Z, dtype="float64"), + { + "standard_name": "depth", + "long_name": "vertical coordinate of cell center", + "units": "m", + "positive": "down", + "axis": "Z", + }, + ), + "Zl": ( + ["Zl"], + np.linspace(0, -4500, Z, dtype="float64"), + { + "standard_name": "depth_at_lower_w_location", + "long_name": "vertical coordinate of lower cell interface", + "units": "m", + "positive": "down", + "axis": "Z", + "c_grid_axis_shift": -0.5, + }, + ), + "YC": ( + ["YC"], + np.linspace(500, 5000, Y, dtype="float64"), + { + "standard_name": "latitude", + "long_name": "latitude", + "units": "degrees_north", + "coordinate": "YC XC", + "axis": "Y", + }, + ), + "YG": ( + ["YG"], + np.linspace(0, 5000, Y, dtype="float64"), + { + "standard_name": "latitude_at_f_location", + "long_name": "latitude", + "units": "degrees_north", + "coordinate": "YG XG", + "axis": "Y", + "c_grid_axis_shift": -0.5, + }, + ), + "XC": ( + ["XC"], + np.linspace(500, 5000, X, dtype="float64"), + { + "standard_name": "longitude", + "long_name": "longitude", + "units": "degrees_east", + "coordinate": "YC XC", + "axis": "X", + }, + ), + "XG": ( + ["XG"], + np.linspace(0, 5000, X, dtype="float64"), + { + "standard_name": "longitude_at_f_location", + "long_name": "longitude", + "units": "degrees_east", + "coordinate": "YG XG", + "axis": "X", + "c_grid_axis_shift": -0.5, + }, + ), + }, + ) + + +def _ERA5_wind(): + """ERA5 10m wind model dataset""" + return xr.Dataset( + { + "u10": ( + ["time", "latitude", "longitude"], + np.random.rand(T, Y, X).astype("float32"), + { + "long_name": "10 metre U wind component", + "units": "m s**-1", + }, + ), + "v10": ( + ["time", "latitude", "longitude"], + np.random.rand(T, Y, X).astype("float32"), + { + "long_name": "10 metre V wind component", + "units": "m s**-1", + }, + ), + }, + coords={ + "time": ( + ["time"], + TIME, + { + "long_name": "time", + }, + ), + "latitude": ( + ["latitude"], + np.linspace(90, -90, Y), # Note: ERA5 uses latitudes from 90 to -90 + { + "long_name": "latitude", + "units": "degrees_north", + }, + ), + "longitude": ( + ["longitude"], + np.linspace(0, 360, X, endpoint=False), + { + "long_name": "longitude", + "units": "degrees_east", + }, + ), + }, + ) + + +def _FES_tides(): + """FES tidal model dataset""" + return xr.Dataset( + { + "Ug": ( + ["lat", "lon"], + np.random.rand(Y, X).astype("float32"), + { + "long_name": "Eastward sea water velocity phaselag due to non equilibrium ocean tide at m2 frequency", + "units": "degrees", + "grid_mapping": "crs", + }, + ), + "Ua": ( + ["lat", "lon"], + np.random.rand(Y, X).astype("float32"), + { + "long_name": "Eastward sea water velocity amplitude due to non equilibrium ocean tide at m2 frequency", + "units": "cm/s", + "grid_mapping": "crs", + }, + ), + }, + coords={ + "lat": ( + ["lat"], + np.linspace(-90, 90, Y), + { + "long_name": "latitude", + "units": "degrees_north", + "bounds": "lat_bnds", + "axis": "Y", + "valid_min": -90.0, + "valid_max": 90.0, + }, + ), + "lon": ( + ["lon"], + np.linspace(0, 360, X, endpoint=False), + { + "long_name": "longitude", + "units": "degrees_east", + "bounds": "lon_bnds", + "axis": "X", + "valid_min": 0.0, + "valid_max": 360.0, + }, + ), + }, + ) + + +def _hycom_espc(): + """HYCOM ESPC model dataset from https://data.hycom.org/datasets/ESPC-D-V02/data/daily_netcdf/2025/""" + return xr.Dataset( + { + "water_u": ( + ["time", "depth", "lat", "lon"], + np.random.rand(T, Z, Y, X).astype("float32"), + { + "long_name": "Eastward Water Velocity", + "standard_name": "eastward_sea_water_velocity", + "units": "m/s", + "NAVO_code": 17, + "actual_range": np.array([-3.3700001, 3.6840003], dtype="float32"), + "cell_methods": "time: mean", + }, + ), + "tau": ( + ["time"], + np.linspace(0, 24, T, dtype="float64"), + { + "long_name": "Tau", + "units": "hours since analysis", + "time_origin": "2024-12-31 12:00:00", + "NAVO_code": 56, + "cell_methods": "time: mean", + }, + ), + }, + coords={ + "time": ( + ["time"], + np.arange(0, T, dtype="float64"), + { + "long_name": "Valid Time", + "units": "hours since 2000-01-01 00:00:00", + "time_origin": "2000-01-01 00:00:00", + "calendar": "standard", + "axis": "T", + "NAVO_code": 13, + "cell_methods": "time: mean", + }, + ), + "depth": ( + ["depth"], + np.linspace(0, 5000, Z, dtype="float32"), + { + "long_name": "Depth", + "standard_name": "depth", + "units": "m", + "positive": "down", + "axis": "Z", + "NAVO_code": 5, + }, + ), + "lat": ( + ["lat"], + np.linspace(-80, 90, Y), + { + "long_name": "Latitude", + "standard_name": "latitude", + "units": "degrees_north", + "point_spacing": "even", + "axis": "Y", + "NAVO_code": 1, + }, + ), + "lon": ( + ["lon"], + np.linspace(0, 360, X, endpoint=False), + { + "long_name": "Longitude", + "standard_name": "longitude", + "units": "degrees_east", + "modulo": "360 degrees", + "axis": "X", + "NAVO_code": 2, + }, + ), + }, + ) + + +def _ecco4(): + """ECCO V4r4 model dataset (from https://podaac.jpl.nasa.gov/dataset/ECCO_L4_OCEAN_VEL_LLC0090GRID_DAILY_V4R4#capability-modal-download)""" + tiles = 13 + lon_grid = np.tile( + np.tile(np.linspace(-179, 179, X, endpoint=False), (Y, 1)), (tiles, 1, 1) + ) # NOTE this grid is not correct, as duplicates for each tile + lat_grid = np.tile( + np.tile(np.linspace(-89, 89, Y), (X, 1)).T, (tiles, 1, 1) + ) # NOTE this grid is not correct, as duplicates for each tile + return xr.Dataset( + { + "UVEL": ( + ["time", "k", "tile", "j", "i_g"], + np.random.rand(T, Z, tiles, Y, X).astype("float32"), + { + "long_name": "Horizontal velocity in the model +x direction", + "units": "m s-1", + "mate": "VVEL", + "coverage_content_type": "modelResult", + "direction": ">0 increases volume", + "standard_name": "sea_water_x_velocity", + "comment": "Horizontal velocity in the +x direction at the 'u' face of the tracer cell on the native model grid. Note: in the Arakawa-C grid, horizontal velocities are staggered relative to the tracer cells with indexing such that +UVEL(i_g,j,k) corresponds to +x fluxes through the 'u' face of the tracer cell at (i,j,k). Do NOT use UVEL for volume flux calculations because the model's grid cell thicknesses vary with time (z* coordinates); use UVELMASS instead. Also, the model +x direction does not necessarily correspond to the geographical east-west direction because the x and y axes of the model's curvilinear lat-lon-cap (llc) grid have arbitrary orientations which vary within and across tiles. See EVEL and NVEL for zonal and meridional velocity.", + "valid_min": -2.139253616333008, + "valid_max": 2.038635015487671, + }, + ), + "VVEL": ( + ["time", "k", "tile", "j_g", "i"], + np.random.rand(T, Z, tiles, Y, X).astype("float32"), + { + "long_name": "Horizontal velocity in the model +y direction", + "units": "m s-1", + "mate": "UVEL", + "coverage_content_type": "modelResult", + "direction": ">0 increases volume", + "standard_name": "sea_water_y_velocity", + "comment": "Horizontal velocity in the +y direction at the 'v' face of the tracer cell on the native model grid. Note: in the Arakawa-C grid, horizontal velocities are staggered relative to the tracer cells with indexing such that +VVEL(i,j_g,k) corresponds to +y fluxes through the 'v' face of the tracer cell at (i,j,k). Do NOT use VVEL for volume flux calculations because the model's grid cell thicknesses vary with time (z* coordinates); use VVELMASS instead. Also, the model +y direction does not necessarily correspond to the geographical north-south direction because the x and y axes of the model's curvilinear lat-lon-cap (llc) grid have arbitrary orientations which vary within and across tiles. See EVEL and NVEL for zonal and meridional velocity.", + "valid_min": -1.7877743244171143, + "valid_max": 1.9089667797088623, + }, + ), + "WVEL": ( + ["time", "k_l", "tile", "j", "i"], + np.random.rand(T, Z, tiles, Y, X).astype("float32"), + { + "long_name": "Vertical velocity", + "units": "m s-1", + "coverage_content_type": "modelResult", + "direction": ">0 decreases volume", + "standard_name": "upward_sea_water_velocity", + "comment": "Vertical velocity in the +z direction at the top 'w' face of the tracer cell on the native model grid. Note: in the Arakawa-C grid, vertical velocities are staggered relative to the tracer cells with indexing such that +WVEL(i,j,k_l) corresponds to upward +z motion through the top 'w' face of the tracer cell at (i,j,k). WVEL is identical to WVELMASS.", + "valid_min": -0.0023150660563260317, + "valid_max": 0.0016380994347855449, + }, + ), + }, + coords={ + "time": ( + ["time"], + TIME, + { + "long_name": "center time of averaging period", + "standard_name": "time", + "axis": "T", + "bounds": "time_bnds", + "coverage_content_type": "coordinate", + }, + ), + "tile": ( + ["tile"], + np.arange(tiles, dtype="int32"), + { + "long_name": "lat-lon-cap tile index", + "coverage_content_type": "coordinate", + "comment": "The ECCO V4 horizontal model grid is divided into 13 tiles of 90x90 cells for convenience.", + }, + ), + "k": ( + ["k"], + np.arange(Z, dtype="int32"), + { + "long_name": "grid index in z for tracer variables", + "axis": "Z", + "swap_dim": "Z", + "coverage_content_type": "coordinate", + }, + ), + "k_l": ( + ["k_l"], + np.arange(Z, dtype="int32"), + { + "long_name": "grid index in z corresponding to the top face of tracer grid cells ('w' locations)", + "axis": "Z", + "swap_dim": "Zl", + "coverage_content_type": "coordinate", + "c_grid_axis_shift": -0.5, + "comment": "First index corresponds to the top surface of the uppermost tracer grid cell. The use of 'l' in the variable name follows the MITgcm convention for ocean variables in which the lower (l) face of a tracer grid cell on the logical grid corresponds to the top face of the grid cell on the physical grid.", + }, + ), + "j": ( + ["j"], + np.arange(Y, dtype="int32"), + { + "long_name": "grid index in y for variables at tracer and 'u' locations", + "axis": "Y", + "swap_dim": "YC", + "coverage_content_type": "coordinate", + "comment": "In the Arakawa C-grid system, tracer (e.g., THETA) and 'u' variables (e.g., UVEL) have the same y coordinate on the model grid.", + }, + ), + "j_g": ( + ["j_g"], + np.arange(Y, dtype="int32"), + { + "long_name": "grid index in y for variables at 'v' and 'g' locations", + "axis": "Y", + "swap_dim": "YG", + "c_grid_axis_shift": -0.5, + "coverage_content_type": "coordinate", + "comment": "In the Arakawa C-grid system, 'v' (e.g., VVEL) and 'g' variables (e.g., XG) have the same y coordinate.", + }, + ), + "i": ( + ["i"], + np.arange(X, dtype="int32"), + { + "long_name": "grid index in x for variables at tracer and 'v' locations", + "axis": "X", + "swap_dim": "XC", + "coverage_content_type": "coordinate", + "comment": "In the Arakawa C-grid system, tracer (e.g., THETA) and 'v' variables (e.g., VVEL) have the same x coordinate on the model grid.", + }, + ), + "i_g": ( + ["i_g"], + np.arange(X, dtype="int32"), + { + "long_name": "grid index in x for variables at 'u' and 'g' locations", + "axis": "X", + "swap_dim": "XG", + "c_grid_axis_shift": -0.5, + "coverage_content_type": "coordinate", + "comment": "In the Arakawa C-grid system, 'u' (e.g., UVEL) and 'g' variables (e.g., XG) have the same x coordinate on the model grid.", + }, + ), + "Z": ( + ["k"], + np.linspace(-5, -5900, Z, dtype="float32"), + { + "long_name": "depth of tracer grid cell center", + "standard_name": "depth", + "units": "m", + "positive": "up", + "bounds": "Z_bnds", + "coverage_content_type": "coordinate", + "comment": "Non-uniform vertical spacing.", + }, + ), + "Zl": ( + ["k_l"], + np.linspace(0, -5678, Z, dtype="float32"), + { + "long_name": "depth of the top face of tracer grid cells", + "standard_name": "depth", + "units": "m", + "positive": "up", + "coverage_content_type": "coordinate", + "comment": "First element is 0m, the depth of the top face of the first tracer grid cell (ocean surface). Last element is the depth of the top face of the deepest grid cell. The use of 'l' in the variable name follows the MITgcm convention for ocean variables in which the lower (l) face of a tracer grid cell on the logical grid corresponds to the top face of the grid cell on the physical grid. In other words, the logical vertical grid of MITgcm ocean variables is inverted relative to the physical vertical grid.", + }, + ), + "YC": ( + ["tile", "j", "i"], + lat_grid, + { + "long_name": "latitude of tracer grid cell center", + "standard_name": "latitude", + "units": "degrees_north", + "coordinate": "YC XC", + "bounds": "YC_bnds", + "coverage_content_type": "coordinate", + "comment": "nonuniform grid spacing", + }, + ), + "YG": ( + ["tile", "j_g", "i_g"], + lat_grid, + { + "long_name": "latitude of 'southwest' corner of tracer grid cell", + "standard_name": "latitude", + "units": "degrees_north", + "coordinate": "YG XG", + "coverage_content_type": "coordinate", + "comment": "Nonuniform grid spacing. Note: 'southwest' does not correspond to geographic orientation but is used for convenience to describe the computational grid. See MITgcm dcoumentation for details.", + }, + ), + "XC": ( + ["tile", "j", "i"], + lon_grid, + { + "long_name": "longitude of tracer grid cell center", + "standard_name": "longitude", + "units": "degrees_east", + "coordinate": "YC XC", + "bounds": "XC_bnds", + "coverage_content_type": "coordinate", + "comment": "nonuniform grid spacing", + }, + ), + "XG": ( + ["tile", "j_g", "i_g"], + lon_grid, + { + "long_name": "longitude of 'southwest' corner of tracer grid cell", + "standard_name": "longitude", + "units": "degrees_east", + "coordinate": "YG XG", + "coverage_content_type": "coordinate", + "comment": "Nonuniform grid spacing. Note: 'southwest' does not correspond to geographic orientation but is used for convenience to describe the computational grid. See MITgcm dcoumentation for details.", + }, + ), + }, + ) + + +def _CROCO_idealized(): + """CROCO idealized model dataset""" + return xr.Dataset( + { + "u": ( + ["time", "s_rho", "eta_rho", "xi_u"], + np.random.rand(T, Z, Y, X - 1).astype("float32"), + { + "long_name": "u-momentum component", + "units": "meter second-1", + "field": "u-velocity, scalar, series", + "standard_name": "sea_water_x_velocity_at_u_location", + }, + ), + "v": ( + ["time", "s_rho", "eta_v", "xi_rho"], + np.random.rand(T, Z, Y - 1, X).astype("float32"), + { + "long_name": "v-momentum component", + "units": "meter second-1", + "field": "v-velocity, scalar, series", + "standard_name": "sea_water_y_velocity_at_v_location", + }, + ), + "w": ( + ["time", "s_rho", "eta_rho", "xi_rho"], + np.random.rand(T, Z, Y, X).astype("float32"), + { + "long_name": "vertical momentum component", + "units": "meter second-1", + "field": "w-velocity, scalar, series", + "standard_name": "upward_sea_water_velocity", + "coordinates": "lat_rho lon_rho", + }, + ), + "h": ( + ["eta_rho", "xi_rho"], + np.random.rand(Y, X).astype("float32"), + { + "long_name": "bathymetry at RHO-points", + "units": "meter", + "field": "bath, scalar", + "standard_name": "model_sea_floor_depth_below_geoid", + }, + ), + "zeta": ( + ["time", "eta_rho", "xi_rho"], + np.random.rand(T, Y, X).astype("float32"), + { + "long_name": "free-surface", + "units": "meter", + "field": "free-surface, scalar, series", + "standard_name": "sea_surface_height", + }, + ), + "Cs_w": ( + ["s_w"], + np.random.rand(Z + 1).astype("float32"), + { + "long_name": "S-coordinate stretching curves at W-points", + }, + ), + "hc": ( + [], + np.array(0.0, dtype="float32"), + { + "long_name": "S-coordinate parameter, critical depth", + "units": "meter", + }, + ), + }, + coords={ + "time": ( + ["time"], + np.arange(0, T, dtype="float64"), + { + "long_name": "time since initialization", + "units": "second", + "field": "time, scalar, series", + "standard_name": "time", + "axis": "T", + }, + ), + "s_rho": ( + ["s_rho"], + np.linspace(-0.95, 0.05, Z, dtype="float32"), + { + "long_name": "S-coordinate at RHO-points", + "standard_name": "ocean_s_coordinate_g1", + "positive": "up", + "axis": "Z", + "formula_terms": "s: sc_r C: Cs_r eta: zeta depth: h depth_c: hc", + }, + ), + "s_w": ( + ["s_w"], + np.linspace(-1, 0, Z + 1, dtype="float32"), + { + "long_name": "S-coordinate at W-points", + "standard_name": "ocean_s_coordinate_g1_at_w_location", + "positive": "up", + "axis": "Z", + "c_grid_axis_shift": -0.5, + "formula_terms": "s: sc_w C: Cs_w eta: zeta depth: h depth_c: hc", + }, + ), + "eta_rho": ( + ["eta_rho"], + np.arange(Y, dtype="float32"), + { + "long_name": "y-dimension of the grid", + "standard_name": "y_grid_index", + "axis": "Y", + "c_grid_dynamic_range": f"2:{Y}", + }, + ), + "eta_v": ( + ["eta_v"], + np.arange(Y - 1, dtype="float32"), + { + "long_name": "y-dimension of the grid at v location", + "standard_name": "x_grid_index_at_v_location", + "axis": "Y", + "c_grid_axis_shift": 0.5, + "c_grid_dynamic_range": f"2:{Y - 1}", + }, + ), + "xi_rho": ( + ["xi_rho"], + np.arange(X, dtype="float32"), + { + "long_name": "x-dimension of the grid", + "standard_name": "x_grid_index", + "axis": "X", + "c_grid_dynamic_range": f"2:{X}", + }, + ), + "xi_u": ( + ["xi_u"], + np.arange(X - 1, dtype="float32"), + { + "long_name": "x-dimension of the grid at u location", + "standard_name": "x_grid_index_at_u_location", + "axis": "X", + "c_grid_axis_shift": 0.5, + "c_grid_dynamic_range": f"2:{X - 1}", + }, + ), + "x_rho": ( + ["eta_rho", "xi_rho"], + np.tile(np.linspace(-179, 179, X, endpoint=False), (Y, 1)), # note that this is not curvilinear + { + "long_name": "x-locations of RHO-points", + "units": "meter", + "standard_name": "plane_x_coordinate", + "field": "x_rho, scalar", + }, + ), + "y_rho": ( + ["eta_rho", "xi_rho"], + np.tile(np.linspace(-89, 89, Y), (X, 1)).T, # note that this is not curvilinear + { + "long_name": "y-locations of RHO-points", + "units": "meter", + "standard_name": "plane_y_coordinate", + "field": "y_rho, scal", + }, + ), + }, + ) + + +datasets = { + "ds_copernicusmarine": _copernicusmarine(), + "ds_copernicusmarine_waves": _copernicusmarine_waves(), + "ds_NEMO_MOI_U": _NEMO_MOI_U(), + "ds_NEMO_MOI_V": _NEMO_MOI_V(), + "ds_CESM": _CESM(), + "ds_MITgcm_netcdf": _MITgcm_netcdf(), + "ds_MITgcm_mds": _MITgcm_mds(), + "ds_ERA5_wind": _ERA5_wind(), + "ds_FES_tides": _FES_tides(), + "ds_hycom_espc": _hycom_espc(), + "ds_ecco4": _ecco4(), + "ds_CROCO_idealized": _CROCO_idealized(), +} diff --git a/parcels/_datasets/structured/generated.py b/parcels/_datasets/structured/generated.py new file mode 100644 index 000000000..4454cc58e --- /dev/null +++ b/parcels/_datasets/structured/generated.py @@ -0,0 +1,286 @@ +import math + +import numpy as np +import xarray as xr + + +def simple_UV_dataset(dims=(360, 2, 30, 4), maxdepth=1, mesh="spherical"): + max_lon = 180.0 if mesh == "spherical" else 1e6 + + return xr.Dataset( + {"U": (["time", "depth", "YG", "XG"], np.zeros(dims)), "V": (["time", "depth", "YG", "XG"], np.zeros(dims))}, + coords={ + "time": (["time"], xr.date_range("2000", "2001", dims[0]), {"axis": "T"}), + "depth": (["depth"], np.linspace(0, maxdepth, dims[1]), {"axis": "Z"}), + "YC": (["YC"], np.arange(dims[2]) + 0.5, {"axis": "Y"}), + "YG": (["YG"], np.arange(dims[2]), {"axis": "Y", "c_grid_axis_shift": -0.5}), + "XC": (["XC"], np.arange(dims[3]) + 0.5, {"axis": "X"}), + "XG": (["XG"], np.arange(dims[3]), {"axis": "X", "c_grid_axis_shift": -0.5}), + "lat": (["YG"], np.linspace(-90, 90, dims[2]), {"axis": "Y", "c_grid_axis_shift": 0.5}), + "lon": (["XG"], np.linspace(-max_lon, max_lon, dims[3]), {"axis": "X", "c_grid_axis_shift": -0.5}), + }, + ) + + +def radial_rotation_dataset(xdim=200, ydim=200): # Define 2D flat, square fieldset for testing purposes. + lon = np.linspace(0, 60, xdim, dtype=np.float32) + lat = np.linspace(0, 60, ydim, dtype=np.float32) + + x0 = 30.0 # Define the origin to be the centre of the Field. + y0 = 30.0 + + U = np.zeros((2, 1, ydim, xdim), dtype=np.float32) + V = np.zeros((2, 1, ydim, xdim), dtype=np.float32) + + omega = 2 * np.pi / 86400.0 # Define the rotational period as 1 day. + + for i in range(lon.size): + for j in range(lat.size): + r = np.sqrt((lon[i] - x0) ** 2 + (lat[j] - y0) ** 2) + assert r >= 0.0 + assert r <= np.sqrt(x0**2 + y0**2) + + theta = np.arctan2((lat[j] - y0), (lon[i] - x0)) + assert abs(theta) <= np.pi + + U[:, :, j, i] = r * np.sin(theta) * omega + V[:, :, j, i] = -r * np.cos(theta) * omega + + return xr.Dataset( + {"U": (["time", "depth", "YG", "XG"], U), "V": (["time", "depth", "YG", "XG"], V)}, + coords={ + "time": (["time"], [np.timedelta64(0, "s"), np.timedelta64(10, "D")], {"axis": "T"}), + "depth": (["depth"], np.array([0.0]), {"axis": "Z"}), + "YC": (["YC"], np.arange(ydim) + 0.5, {"axis": "Y"}), + "YG": (["YG"], np.arange(ydim), {"axis": "Y", "c_grid_axis_shift": -0.5}), + "XC": (["XC"], np.arange(xdim) + 0.5, {"axis": "X"}), + "XG": (["XG"], np.arange(xdim), {"axis": "X", "c_grid_axis_shift": -0.5}), + "lat": (["YG"], lat, {"axis": "Y", "c_grid_axis_shift": 0.5}), + "lon": (["XG"], lon, {"axis": "X", "c_grid_axis_shift": -0.5}), + }, + ) + + +def moving_eddy_dataset(xdim=2, ydim=2): # TODO check if this also works with xdim=1, ydim=1 + """Create a dataset with an eddy moving in time. Note that there is no spatial variation in the flow.""" + f, u_0, u_g = 1.0e-4, 0.3, 0.04 # Some constants + + lon = np.linspace(0, 25000, xdim, dtype=np.float32) + lat = np.linspace(0, 25000, ydim, dtype=np.float32) + + time = np.arange(np.timedelta64(0, "s"), np.timedelta64(7, "h"), np.timedelta64(1, "m")) + + U = np.zeros((len(time), 1, ydim, xdim), dtype=np.float32) + V = np.zeros((len(time), 1, ydim, xdim), dtype=np.float32) + + for t in range(len(time)): + U[t, :, :, :] = u_g + (u_0 - u_g) * np.cos(f * (time[t] / np.timedelta64(1, "s"))) + V[t, :, :, :] = -(u_0 - u_g) * np.sin(f * (time[t] / np.timedelta64(1, "s"))) + + return xr.Dataset( + {"U": (["time", "depth", "YG", "XG"], U), "V": (["time", "depth", "YG", "XG"], V)}, + coords={ + "time": (["time"], time, {"axis": "T"}), + "depth": (["depth"], np.array([0.0]), {"axis": "Z"}), + "YC": (["YC"], np.arange(ydim) + 0.5, {"axis": "Y"}), + "YG": (["YG"], np.arange(ydim), {"axis": "Y", "c_grid_axis_shift": -0.5}), + "XC": (["XC"], np.arange(xdim) + 0.5, {"axis": "X"}), + "XG": (["XG"], np.arange(xdim), {"axis": "X", "c_grid_axis_shift": -0.5}), + "lat": (["YG"], lat, {"axis": "Y", "c_grid_axis_shift": 0.5}), + "lon": (["XG"], lon, {"axis": "X", "c_grid_axis_shift": -0.5}), + }, + attrs={ + "u_0": u_0, + "u_g": u_g, + "f": f, + }, + ) + + +def decaying_moving_eddy_dataset(xdim=2, ydim=2): + """Simulate an ocean that accelerates subject to Coriolis force + and dissipative effects, upon which a geostrophic current is + superimposed. + + The original test description can be found in: N. Fabbroni, 2009, + Numerical Simulation of Passive tracers dispersion in the sea, + Ph.D. dissertation, University of Bologna + http://amsdottorato.unibo.it/1733/1/Fabbroni_Nicoletta_Tesi.pdf + """ + u_g = 0.04 # Geostrophic current + u_0 = 0.3 # Initial speed in x dirrection. v_0 = 0 + gamma = 1.0 / (2.89 * 86400) # Dissipitave effects due to viscousity. + gamma_g = 1.0 / (28.9 * 86400) + f = 1.0e-4 # Coriolis parameter. + + time = np.arange(np.timedelta64(0, "s"), np.timedelta64(1, "D") + np.timedelta64(1, "h"), np.timedelta64(2, "m")) + lon = np.linspace(0, 20000, xdim, dtype=np.float32) + lat = np.linspace(5000, 12000, ydim, dtype=np.float32) + + U = np.zeros((time.size, 1, lat.size, lon.size), dtype=np.float32) + V = np.zeros((time.size, 1, lat.size, lon.size), dtype=np.float32) + + for t in range(time.size): + t_float = time[t] / np.timedelta64(1, "s") + U[t, :, :, :] = u_g * np.exp(-gamma_g * t_float) + (u_0 - u_g) * np.exp(-gamma * t_float) * np.cos(f * t_float) + V[t, :, :, :] = -(u_0 - u_g) * np.exp(-gamma * t_float) * np.sin(f * t_float) + + return xr.Dataset( + {"U": (["time", "depth", "YG", "XG"], U), "V": (["time", "depth", "YG", "XG"], V)}, + coords={ + "time": (["time"], time, {"axis": "T"}), + "depth": (["depth"], np.array([0.0]), {"axis": "Z"}), + "YC": (["YC"], np.arange(ydim) + 0.5, {"axis": "Y"}), + "YG": (["YG"], np.arange(ydim), {"axis": "Y", "c_grid_axis_shift": -0.5}), + "XC": (["XC"], np.arange(xdim) + 0.5, {"axis": "X"}), + "XG": (["XG"], np.arange(xdim), {"axis": "X", "c_grid_axis_shift": -0.5}), + "lat": (["YG"], lat, {"axis": "Y", "c_grid_axis_shift": 0.5}), + "lon": (["XG"], lon, {"axis": "X", "c_grid_axis_shift": -0.5}), + }, + attrs={ + "u_0": u_0, + "u_g": u_g, + "f": f, + "gamma": gamma, + "gamma_g": gamma_g, + }, + ) + + +def peninsula_dataset(xdim=100, ydim=50, mesh="flat", grid_type="A"): + """Construct a fieldset encapsulating the flow field around an idealised peninsula. + + Parameters + ---------- + xdim : + Horizontal dimension of the generated fieldset + ydim : + Vertical dimension of the generated fieldset + mesh : str + String indicating the type of mesh coordinates and + units used during velocity interpolation: + + 1. spherical: Lat and lon in degree, with a + correction for zonal velocity U near the poles. + 2. flat (default): No conversion, lat/lon are assumed to be in m. + grid_type : + Option whether grid is either Arakawa A (default) or C + + The original test description can be found in Fig. 2.2.3 in: + North, E. W., Gallego, A., Petitgas, P. (Eds). 2009. Manual of + recommended practices for modelling physical - biological + interactions during fish early life. + ICES Cooperative Research Report No. 295. 111 pp. + http://archimer.ifremer.fr/doc/00157/26792/24888.pdf + """ + domainsizeX, domainsizeY = (1.0e5, 5.0e4) + La = np.linspace(1e3, domainsizeX, xdim, dtype=np.float32) + Wa = np.linspace(1e3, domainsizeY, ydim, dtype=np.float32) + + u0 = 1 + x0 = domainsizeX / 2 + R = 0.32 * domainsizeX / 2 + + # Create the fields + P = np.zeros((ydim, xdim), dtype=np.float32) + U = np.zeros_like(P) + V = np.zeros_like(P) + x, y = np.meshgrid(La, Wa, sparse=True, indexing="xy") + P[:, :] = u0 * R**2 * y / ((x - x0) ** 2 + y**2) - u0 * y + + # Set land points to zero + landpoints = P >= 0.0 + P[landpoints] = 0.0 + + if grid_type == "A": + U[:, :] = u0 - u0 * R**2 * ((x - x0) ** 2 - y**2) / (((x - x0) ** 2 + y**2) ** 2) + V[:, :] = -2 * u0 * R**2 * ((x - x0) * y) / (((x - x0) ** 2 + y**2) ** 2) + U[landpoints] = 0.0 + V[landpoints] = 0.0 + Udims = ["YC", "XG"] + Vdims = ["YG", "XC"] + elif grid_type == "C": + U = np.zeros(P.shape) + V = np.zeros(P.shape) + V[:, 1:] = (P[:, 1:] - P[:, :-1]) / (La[1] - La[0]) + U[1:, :] = -(P[1:, :] - P[:-1, :]) / (Wa[1] - Wa[0]) + Udims = ["YG", "XG"] + Vdims = ["YG", "XG"] + else: + raise RuntimeError(f"Grid_type {grid_type} is not a valid option") + + # Convert from m to lat/lon for spherical meshes + lon = La / 1852.0 / 60.0 if mesh == "spherical" else La + lat = Wa / 1852.0 / 60.0 if mesh == "spherical" else Wa + + return xr.Dataset( + { + "U": (Udims, U), + "V": (Vdims, V), + "P": (["YG", "XG"], P), + }, + coords={ + "YC": (["YC"], np.arange(ydim) + 0.5, {"axis": "Y"}), + "YG": (["YG"], np.arange(ydim), {"axis": "Y", "c_grid_axis_shift": -0.5}), + "XC": (["XC"], np.arange(xdim) + 0.5, {"axis": "X"}), + "XG": (["XG"], np.arange(xdim), {"axis": "X", "c_grid_axis_shift": -0.5}), + "lat": (["YG"], lat, {"axis": "Y", "c_grid_axis_shift": 0.5}), + "lon": (["XG"], lon, {"axis": "X", "c_grid_axis_shift": -0.5}), + }, + ) + + +def stommel_gyre_dataset(xdim=200, ydim=200, grid_type="A"): + """Simulate a periodic current along a western boundary, with significantly + larger velocities along the western edge than the rest of the region + + The original test description can be found in: N. Fabbroni, 2009, + Numerical Simulation of Passive tracers dispersion in the sea, + Ph.D. dissertation, University of Bologna + http://amsdottorato.unibo.it/1733/1/Fabbroni_Nicoletta_Tesi.pdf + """ + a = b = 10000 * 1e3 + scalefac = 0.05 # to scale for physically meaningful velocities + dx, dy = a / xdim, b / ydim + + # Coordinates of the test fieldset (on A-grid in deg) + lon = np.linspace(0, a, xdim, dtype=np.float32) + lat = np.linspace(0, b, ydim, dtype=np.float32) + + # Define arrays U (zonal), V (meridional) and P (sea surface height) + U = np.zeros((lat.size, lon.size), dtype=np.float32) + V = np.zeros((lat.size, lon.size), dtype=np.float32) + P = np.zeros((lat.size, lon.size), dtype=np.float32) + + beta = 2e-11 + r = 1 / (11.6 * 86400) + es = r / (beta * a) + + for j in range(lat.size): + for i in range(lon.size): + xi = lon[i] / a + yi = lat[j] / b + P[j, i] = (1 - math.exp(-xi / es) - xi) * math.pi * np.sin(math.pi * yi) * scalefac + if grid_type == "A": + U[j, i] = -(1 - math.exp(-xi / es) - xi) * math.pi**2 * np.cos(math.pi * yi) * scalefac + V[j, i] = (math.exp(-xi / es) / es - 1) * math.pi * np.sin(math.pi * yi) * scalefac + if grid_type == "C": + V[:, 1:] = (P[:, 1:] - P[:, 0:-1]) / dx * a + U[1:, :] = -(P[1:, :] - P[0:-1, :]) / dy * b + Udims = ["YC", "XG"] + Vdims = ["YG", "XC"] + else: + Udims = ["YG", "XG"] + Vdims = ["YG", "XG"] + + return xr.Dataset( + {"U": (Udims, U), "V": (Vdims, V), "P": (["YG", "XG"], P)}, + coords={ + "YC": (["YC"], np.arange(ydim) + 0.5, {"axis": "Y"}), + "YG": (["YG"], np.arange(ydim), {"axis": "Y", "c_grid_axis_shift": -0.5}), + "XC": (["XC"], np.arange(xdim) + 0.5, {"axis": "X"}), + "XG": (["XG"], np.arange(xdim), {"axis": "X", "c_grid_axis_shift": -0.5}), + "lat": (["YG"], lat, {"axis": "Y", "c_grid_axis_shift": 0.5}), + "lon": (["XG"], lon, {"axis": "X", "c_grid_axis_shift": -0.5}), + }, + ) diff --git a/parcels/_datasets/structured/generic.py b/parcels/_datasets/structured/generic.py new file mode 100644 index 000000000..1b1cd7d81 --- /dev/null +++ b/parcels/_datasets/structured/generic.py @@ -0,0 +1,224 @@ +import numpy as np +import xarray as xr + +from . import T, X, Y, Z + +__all__ = ["T", "X", "Y", "Z", "datasets"] + +TIME = xr.date_range("2000", "2001", T) + + +def _rotated_curvilinear_grid(): + XG = np.arange(X) + YG = np.arange(Y) + LON, LAT = np.meshgrid(XG, YG) + + angle = -np.pi / 24 + rotation = np.array([[np.cos(angle), -np.sin(angle)], [np.sin(angle), np.cos(angle)]]) + + # rotate the LON and LAT grids + LON, LAT = np.einsum("ji, mni -> jmn", rotation, np.dstack([LON, LAT])) + + return xr.Dataset( + { + "data_g": (["time", "ZG", "YG", "XG"], np.random.rand(T, Z, Y, X)), + "data_c": (["time", "ZC", "YC", "XC"], np.random.rand(T, Z, Y, X)), + "U (A grid)": (["time", "ZG", "YG", "XG"], np.random.rand(T, Z, Y, X)), + "V (A grid)": (["time", "ZG", "YG", "XG"], np.random.rand(T, Z, Y, X)), + "U (C grid)": (["time", "ZG", "YC", "XG"], np.random.rand(T, Z, Y, X)), + "V (C grid)": (["time", "ZG", "YG", "XC"], np.random.rand(T, Z, Y, X)), + }, + coords={ + "XG": (["XG"], XG, {"axis": "X", "c_grid_axis_shift": -0.5}), + "YG": (["YG"], YG, {"axis": "Y", "c_grid_axis_shift": -0.5}), + "XC": (["XC"], XG + 0.5, {"axis": "X"}), + "YC": (["YC"], YG + 0.5, {"axis": "Y"}), + "ZG": ( + ["ZG"], + np.arange(Z), + {"axis": "Z", "c_grid_axis_shift": -0.5}, + ), + "ZC": ( + ["ZC"], + np.arange(Z) + 0.5, + {"axis": "Z"}, + ), + "depth": (["ZG"], np.arange(Z), {"axis": "Z"}), + "time": (["time"], TIME, {"axis": "T"}), + "lon": ( + ["YG", "XG"], + LON, + {"axis": "X", "c_grid_axis_shift": -0.5}, # ? Needed? + ), + "lat": ( + ["YG", "XG"], + LAT, + {"axis": "Y", "c_grid_axis_shift": -0.5}, # ? Needed? + ), + }, + ) + + +def _cartesion_to_polar(x, y): + r = np.sqrt(x**2 + y**2) + theta = np.arctan2(y, x) + return r, theta + + +def _polar_to_cartesian(r, theta): + x = r * np.cos(theta) + y = r * np.sin(theta) + return x, y + + +def _unrolled_cone_curvilinear_grid(): + # Not a great unrolled cone, but this is good enough for testing + # you can use matplotlib pcolormesh to plot + XG = np.arange(X) + YG = np.arange(Y) * 0.25 + + pivot = -10, 0 + LON, LAT = np.meshgrid(XG, YG) + + new_lon_lat = [] + + min_lon = np.min(XG) + for lon, lat in zip(LON.flatten(), LAT.flatten(), strict=True): + r, _ = _cartesion_to_polar(lon - pivot[0], lat - pivot[1]) + _, theta = _cartesion_to_polar(min_lon - pivot[0], lat - pivot[1]) + theta *= 1.2 + r *= 1.2 + lon, lat = _polar_to_cartesian(r, theta) + new_lon_lat.append((lon + pivot[0], lat + pivot[1])) + + new_lon, new_lat = zip(*new_lon_lat, strict=True) + LON, LAT = np.array(new_lon).reshape(LON.shape), np.array(new_lat).reshape(LAT.shape) + + return xr.Dataset( + { + "data_g": (["time", "ZG", "YG", "XG"], np.random.rand(T, Z, Y, X)), + "data_c": (["time", "ZC", "YC", "XC"], np.random.rand(T, Z, Y, X)), + "U (A grid)": (["time", "ZG", "YG", "XG"], np.random.rand(T, Z, Y, X)), + "V (A grid)": (["time", "ZG", "YG", "XG"], np.random.rand(T, Z, Y, X)), + "U (C grid)": (["time", "ZG", "YC", "XG"], np.random.rand(T, Z, Y, X)), + "V (C grid)": (["time", "ZG", "YG", "XC"], np.random.rand(T, Z, Y, X)), + }, + coords={ + "XG": (["XG"], XG, {"axis": "X", "c_grid_axis_shift": -0.5}), + "YG": (["YG"], YG, {"axis": "Y", "c_grid_axis_shift": -0.5}), + "XC": (["XC"], XG + 0.5, {"axis": "X"}), + "YC": (["YC"], YG + 0.5, {"axis": "Y"}), + "ZG": ( + ["ZG"], + np.arange(Z), + {"axis": "Z", "c_grid_axis_shift": -0.5}, + ), + "ZC": ( + ["ZC"], + np.arange(Z) + 0.5, + {"axis": "Z"}, + ), + "depth": (["ZG"], np.arange(Z), {"axis": "Z"}), + "time": (["time"], TIME, {"axis": "T"}), + "lon": ( + ["YG", "XG"], + LON, + {"axis": "X", "c_grid_axis_shift": -0.5}, # ? Needed? + ), + "lat": ( + ["YG", "XG"], + LAT, + {"axis": "Y", "c_grid_axis_shift": -0.5}, # ? Needed? + ), + }, + ) + + +datasets = { + "2d_left_rotated": _rotated_curvilinear_grid(), + "ds_2d_left": xr.Dataset( # MITgcm indexing style + { + "data_g": (["time", "ZG", "YG", "XG"], np.random.rand(T, Z, Y, X)), + "data_c": (["time", "ZC", "YC", "XC"], np.random.rand(T, Z, Y, X)), + "U (A grid)": (["time", "ZG", "YG", "XG"], np.random.rand(T, Z, Y, X)), + "V (A grid)": (["time", "ZG", "YG", "XG"], np.random.rand(T, Z, Y, X)), + "U (C grid)": (["time", "ZG", "YC", "XG"], np.random.rand(T, Z, Y, X)), + "V (C grid)": (["time", "ZG", "YG", "XC"], np.random.rand(T, Z, Y, X)), + }, + coords={ + "XG": ( + ["XG"], + 2 * np.pi / X * np.arange(0, X), + {"axis": "X", "c_grid_axis_shift": -0.5}, + ), + "XC": (["XC"], 2 * np.pi / X * (np.arange(0, X) + 0.5), {"axis": "X"}), + "YG": ( + ["YG"], + 2 * np.pi / (Y) * np.arange(0, Y), + {"axis": "Y", "c_grid_axis_shift": -0.5}, + ), + "YC": ( + ["YC"], + 2 * np.pi / (Y) * (np.arange(0, Y) + 0.5), + {"axis": "Y"}, + ), + "ZG": ( + ["ZG"], + np.arange(Z), + {"axis": "Z", "c_grid_axis_shift": -0.5}, + ), + "ZC": ( + ["ZC"], + np.arange(Z) + 0.5, + {"axis": "Z"}, + ), + "lon": (["XG"], 2 * np.pi / X * np.arange(0, X)), + "lat": (["YG"], 2 * np.pi / (Y) * np.arange(0, Y)), + "depth": (["ZG"], np.arange(Z)), + "time": (["time"], TIME, {"axis": "T"}), + }, + ), + "ds_2d_right": xr.Dataset( # NEMO indexing style + { + "data_g": (["time", "ZG", "YG", "XG"], np.random.rand(T, Z, Y, X)), + "data_c": (["time", "ZC", "YC", "XC"], np.random.rand(T, Z, Y, X)), + "U (A grid)": (["time", "ZG", "YG", "XG"], np.random.rand(T, Z, Y, X)), + "V (A grid)": (["time", "ZG", "YG", "XG"], np.random.rand(T, Z, Y, X)), + "U (C grid)": (["time", "ZG", "YC", "XG"], np.random.rand(T, Z, Y, X)), + "V (C grid)": (["time", "ZG", "YG", "XC"], np.random.rand(T, Z, Y, X)), + }, + coords={ + "XG": ( + ["XG"], + 2 * np.pi / X * np.arange(0, X), + {"axis": "X", "c_grid_axis_shift": 0.5}, + ), + "XC": (["XC"], 2 * np.pi / X * (np.arange(0, X) - 0.5), {"axis": "X"}), + "YG": ( + ["YG"], + 2 * np.pi / (Y) * np.arange(0, Y), + {"axis": "Y", "c_grid_axis_shift": 0.5}, + ), + "YC": ( + ["YC"], + 2 * np.pi / (Y) * (np.arange(0, Y) - 0.5), + {"axis": "Y"}, + ), + "ZG": ( + ["ZG"], + np.arange(Z), + {"axis": "Z", "c_grid_axis_shift": 0.5}, + ), + "ZC": ( + ["ZC"], + np.arange(Z) - 0.5, + {"axis": "Z"}, + ), + "lon": (["XG"], 2 * np.pi / X * np.arange(0, X)), + "lat": (["YG"], 2 * np.pi / (Y) * np.arange(0, Y)), + "depth": (["ZG"], np.arange(Z)), + "time": (["time"], TIME, {"axis": "T"}), + }, + ), + "2d_left_unrolled_cone": _unrolled_cone_curvilinear_grid(), +} diff --git a/parcels/_datasets/unstructured/__init__.py b/parcels/_datasets/unstructured/__init__.py new file mode 100644 index 000000000..2fa5f48f0 --- /dev/null +++ b/parcels/_datasets/unstructured/__init__.py @@ -0,0 +1 @@ +"""Unstructured datasets.""" diff --git a/parcels/_datasets/unstructured/generic.py b/parcels/_datasets/unstructured/generic.py new file mode 100644 index 000000000..1d5b456dc --- /dev/null +++ b/parcels/_datasets/unstructured/generic.py @@ -0,0 +1,318 @@ +import math + +import numpy as np +import uxarray as ux +import xarray as xr + +__all__ = ["Nx", "datasets"] + +T = 13 +Nx = 20 +vmax = 1.0 +delta = 0.1 +TIME = xr.date_range("2000", "2001", T) + + +def _stommel_gyre_delaunay(): + """ + Stommel gyre on a Delaunay grid. the naming convention of the dataset and grid is consistent with what is + provided by UXArray when reading in FESOM2 datasets. + This dataset is a single vertical layer of a barotropic ocean gyre on a square domain with closed boundaries. + The velocity field provides a slow moving interior circulation and a western boundary current. All fields are placed + on the vertices of the grid and at the element vertical faces. + """ + lon, lat = np.meshgrid(np.linspace(0, 60.0, Nx, dtype=np.float32), np.linspace(0, 60.0, Nx, dtype=np.float32)) + lon_flat = lon.ravel() + lat_flat = lat.ravel() + zf = np.linspace(0.0, 1000.0, 2, endpoint=True, dtype=np.float32) # Vertical element faces + zc = 0.5 * (zf[:-1] + zf[1:]) # Vertical element centers + nz = zf.size + nz1 = zc.size + + # mask any point on one of the boundaries + mask = ( + np.isclose(lon_flat, 0.0) | np.isclose(lon_flat, 60.0) | np.isclose(lat_flat, 0.0) | np.isclose(lat_flat, 60.0) + ) + + boundary_points = np.flatnonzero(mask) + + uxgrid = ux.Grid.from_points( + (lon_flat, lat_flat), + method="regional_delaunay", + boundary_points=boundary_points, + ) + uxgrid.attrs["Conventions"] = "UGRID-1.0" + + # Define arrays U (zonal), V (meridional) and P (sea surface height) + U = np.zeros((1, nz1, uxgrid.n_face), dtype=np.float64) + V = np.zeros((1, nz1, uxgrid.n_face), dtype=np.float64) + W = np.zeros((1, nz, lat.size), dtype=np.float64) + P = np.zeros((1, nz1, uxgrid.n_face), dtype=np.float64) + + for i, (x, y) in enumerate(zip(uxgrid.face_lon, uxgrid.face_lat, strict=False)): + xi = x / 60.0 + yi = y / 60.0 + + P[0, 0, i] = -vmax * delta * (1 - xi) * (math.exp(-xi / delta) - 1) * np.sin(math.pi * yi) + U[0, 0, i] = -vmax * (1 - math.exp(-xi / delta) - xi) * np.cos(math.pi * yi) + V[0, 0, i] = vmax * ((2.0 - xi) * math.exp(-xi / delta) - 1) * np.sin(math.pi * yi) + + u = ux.UxDataArray( + data=U, + name="U", + uxgrid=uxgrid, + dims=["time", "nz1", "n_face"], + coords=dict( + time=(["time"], [TIME[0]]), + nz1=(["nz1"], zc), + ), + attrs=dict( + description="zonal velocity", units="m/s", location="node", mesh="delaunay", Conventions="UGRID-1.0" + ), + ) + v = ux.UxDataArray( + data=V, + name="V", + uxgrid=uxgrid, + dims=["time", "nz1", "n_face"], + coords=dict( + time=(["time"], [TIME[0]]), + nz1=(["nz1"], zc), + ), + attrs=dict( + description="meridional velocity", units="m/s", location="node", mesh="delaunay", Conventions="UGRID-1.0" + ), + ) + w = ux.UxDataArray( + data=W, + name="W", + uxgrid=uxgrid, + dims=["time", "nz", "n_node"], + coords=dict( + time=(["time"], [TIME[0]]), + nz=(["nz"], zf), + ), + attrs=dict( + description="meridional velocity", units="m/s", location="node", mesh="delaunay", Conventions="UGRID-1.0" + ), + ) + p = ux.UxDataArray( + data=P, + name="p", + uxgrid=uxgrid, + dims=["time", "nz1", "n_face"], + coords=dict( + time=(["time"], [TIME[0]]), + nz1=(["nz1"], zc), + ), + attrs=dict(description="pressure", units="N/m^2", location="node", mesh="delaunay", Conventions="UGRID-1.0"), + ) + + return ux.UxDataset({"U": u, "V": v, "W": w, "p": p}, uxgrid=uxgrid) + + +def _fesom2_square_delaunay_uniform_z_coordinate(): + """ + Delaunay grid with uniform z-coordinate, mimicking a FESOM2 dataset. + This dataset consists of a square domain with closed boundaries, where the grid is generated using Delaunay triangulation. + The bottom topography is flat and uniform, and the vertical grid spacing is constant with 10 layers spanning [0,1000.0] + The lateral velocity field components are non-zero constant, and the vertical velocity component is zero. + The pressure field is constant. + All fields are placed on location consistent with FESOM2 variable placement conventions + """ + lon, lat = np.meshgrid(np.linspace(0, 60.0, Nx, dtype=np.float32), np.linspace(0, 60.0, Nx, dtype=np.float32)) + lon_flat = lon.ravel() + lat_flat = lat.ravel() + zf = np.linspace(0.0, 1000.0, 10, endpoint=True, dtype=np.float32) # Vertical element faces + zc = 0.5 * (zf[:-1] + zf[1:]) # Vertical element centers + nz = zf.size + nz1 = zc.size + + # mask any point on one of the boundaries + mask = ( + np.isclose(lon_flat, 0.0) | np.isclose(lon_flat, 60.0) | np.isclose(lat_flat, 0.0) | np.isclose(lat_flat, 60.0) + ) + + boundary_points = np.flatnonzero(mask) + + uxgrid = ux.Grid.from_points( + (lon_flat, lat_flat), + method="regional_delaunay", + boundary_points=boundary_points, + ) + uxgrid.attrs["Conventions"] = "UGRID-1.0" + + # Define arrays U (zonal), V (meridional) and P (sea surface height) + U = np.ones( + (T, nz1, uxgrid.n_face), dtype=np.float64 + ) # Lateral velocity is on the element centers and face centers + V = np.ones( + (T, nz1, uxgrid.n_face), dtype=np.float64 + ) # Lateral velocity is on the element centers and face centers + W = np.zeros( + (T, nz, uxgrid.n_node), dtype=np.float64 + ) # Vertical velocity is on the element faces and face vertices + P = np.ones((T, nz1, uxgrid.n_node), dtype=np.float64) # Pressure is on the element centers and face vertices + + u = ux.UxDataArray( + data=U, + name="U", + uxgrid=uxgrid, + dims=["time", "nz1", "n_face"], + coords=dict( + time=(["time"], TIME), + nz1=(["nz1"], zc), + ), + attrs=dict( + description="zonal velocity", units="m/s", location="face", mesh="delaunay", Conventions="UGRID-1.0" + ), + ) + v = ux.UxDataArray( + data=V, + name="V", + uxgrid=uxgrid, + dims=["time", "nz1", "n_face"], + coords=dict( + time=(["time"], TIME), + nz1=(["nz1"], zc), + ), + attrs=dict( + description="meridional velocity", units="m/s", location="face", mesh="delaunay", Conventions="UGRID-1.0" + ), + ) + w = ux.UxDataArray( + data=W, + name="w", + uxgrid=uxgrid, + dims=["time", "nz", "n_node"], + coords=dict( + time=(["time"], TIME), + nz=(["nz"], zf), + ), + attrs=dict( + description="vertical velocity", units="m/s", location="node", mesh="delaunay", Conventions="UGRID-1.0" + ), + ) + p = ux.UxDataArray( + data=P, + name="p", + uxgrid=uxgrid, + dims=["time", "nz1", "n_node"], + coords=dict( + time=(["time"], TIME), + nz1=(["nz1"], zc), + ), + attrs=dict(description="pressure", units="N/m^2", location="node", mesh="delaunay", Conventions="UGRID-1.0"), + ) + + return ux.UxDataset({"U": u, "V": v, "W": w, "p": p}, uxgrid=uxgrid) + + +def _fesom2_square_delaunay_antimeridian(): + """ + Delaunay grid that crosses the antimeridian with uniform z-coordinate, mimicking a FESOM2 dataset. + This dataset consists of a square domain with closed boundaries, where the grid is generated using Delaunay triangulation. + The bottom topography is flat and uniform, and the vertical grid spacing is constant with 10 layers spanning [0,1000.0] + The lateral velocity field components are non-zero constant, and the vertical velocity component is zero. + The pressure field is constant. + All fields are placed on location consistent with FESOM2 variable placement conventions + """ + lon, lat = np.meshgrid( + np.linspace(-210.0, -150.0, Nx, dtype=np.float32), np.linspace(-40.0, 40.0, Nx, dtype=np.float32) + ) + # wrap longitude from [-180,180] + lon_flat = lon.ravel() + lat_flat = lat.ravel() + zf = np.linspace(0.0, 1000.0, 10, endpoint=True, dtype=np.float32) # Vertical element faces + zc = 0.5 * (zf[:-1] + zf[1:]) # Vertical element centers + nz = zf.size + nz1 = zc.size + + # mask any point on one of the boundaries + mask = ( + np.isclose(lon_flat, -210.0) + | np.isclose(lon_flat, -150.0) + | np.isclose(lat_flat, -40.0) + | np.isclose(lat_flat, 40.0) + ) + + boundary_points = np.flatnonzero(mask) + + uxgrid = ux.Grid.from_points( + (lon_flat, lat_flat), + method="regional_delaunay", + boundary_points=boundary_points, + ) + uxgrid.attrs["Conventions"] = "UGRID-1.0" + + # Define arrays U (zonal), V (meridional) and P (sea surface height) + U = np.ones( + (T, nz1, uxgrid.n_face), dtype=np.float64 + ) # Lateral velocity is on the element centers and face centers + V = np.ones( + (T, nz1, uxgrid.n_face), dtype=np.float64 + ) # Lateral velocity is on the element centers and face centers + W = np.zeros( + (T, nz, uxgrid.n_node), dtype=np.float64 + ) # Vertical velocity is on the element faces and face vertices + P = np.ones((T, nz1, uxgrid.n_node), dtype=np.float64) # Pressure is on the element centers and face vertices + + u = ux.UxDataArray( + data=U, + name="U", + uxgrid=uxgrid, + dims=["time", "nz1", "n_face"], + coords=dict( + time=(["time"], TIME), + nz1=(["nz1"], zc), + ), + attrs=dict( + description="zonal velocity", units="m/s", location="face", mesh="delaunay", Conventions="UGRID-1.0" + ), + ) + v = ux.UxDataArray( + data=V, + name="V", + uxgrid=uxgrid, + dims=["time", "nz1", "n_face"], + coords=dict( + time=(["time"], TIME), + nz1=(["nz1"], zc), + ), + attrs=dict( + description="meridional velocity", units="m/s", location="face", mesh="delaunay", Conventions="UGRID-1.0" + ), + ) + w = ux.UxDataArray( + data=W, + name="w", + uxgrid=uxgrid, + dims=["time", "nz", "n_node"], + coords=dict( + time=(["time"], TIME), + nz=(["nz"], zf), + ), + attrs=dict( + description="vertical velocity", units="m/s", location="node", mesh="delaunay", Conventions="UGRID-1.0" + ), + ) + p = ux.UxDataArray( + data=P, + name="p", + uxgrid=uxgrid, + dims=["time", "nz1", "n_node"], + coords=dict( + time=(["time"], TIME), + nz1=(["nz1"], zc), + ), + attrs=dict(description="pressure", units="N/m^2", location="node", mesh="delaunay", Conventions="UGRID-1.0"), + ) + + return ux.UxDataset({"U": u, "V": v, "W": w, "p": p}, uxgrid=uxgrid) + + +datasets = { + "stommel_gyre_delaunay": _stommel_gyre_delaunay(), + "fesom2_square_delaunay_uniform_z_coordinate": _fesom2_square_delaunay_uniform_z_coordinate(), + "fesom2_square_delaunay_antimeridian": _fesom2_square_delaunay_antimeridian(), +} diff --git a/parcels/_datasets/utils.py b/parcels/_datasets/utils.py new file mode 100644 index 000000000..15afeca46 --- /dev/null +++ b/parcels/_datasets/utils.py @@ -0,0 +1,217 @@ +import copy +from typing import Any + +import numpy as np +import xarray as xr + +_SUPPORTED_ATTR_TYPES = int | float | str | np.ndarray + + +def _print_mismatched_keys(d1: dict[Any, Any], d2: dict[Any, Any]) -> None: + k1 = set(d1.keys()) + k2 = set(d2.keys()) + if len(k1 ^ k2) == 0: + return + print("Mismatched keys:") + print(f"L: {k1 - k2!r}") + print(f"R: {k2 - k1!r}") + + +def assert_common_attrs_equal( + xr_attrs_1: dict[str, _SUPPORTED_ATTR_TYPES], xr_attrs_2: dict[str, _SUPPORTED_ATTR_TYPES], *, verbose: bool = True +) -> None: + d1, d2 = xr_attrs_1, xr_attrs_2 + + common_keys = set(d1.keys()) & set(d2.keys()) + if verbose: + _print_mismatched_keys(d1, d2) + + for key in common_keys: + try: + if isinstance(d1[key], np.ndarray): + np.testing.assert_array_equal(d1[key], d2[key]) + else: + assert d1[key] == d2[key], f"{d1[key]} != {d2[key]}" + except AssertionError as e: + e.add_note(f"error on key {key!r}") + raise + + +def assert_common_variables_common_attrs_equal(ds1: xr.Dataset, ds2: xr.Dataset, *, verbose: bool = True) -> None: + if verbose: + print("Checking dataset attrs...") + + assert_common_attrs_equal(ds1.attrs, ds2.attrs, verbose=verbose) + + ds1_vars = set(ds1.variables) + ds2_vars = set(ds2.variables) + + common_variables = ds1_vars & ds2_vars + if len(ds1_vars ^ ds2_vars) > 0 and verbose: + print("Mismatched variables:") + print(f"L: {ds1_vars - ds2_vars}") + print(f"R: {ds2_vars - ds1_vars}") + + for var in common_variables: + if verbose: + print(f"Checking {var!r} attrs") + assert_common_attrs_equal(ds1[var].attrs, ds2[var].attrs, verbose=verbose) + + +def dataset_repr_diff(ds1: xr.Dataset, ds2: xr.Dataset) -> str: + """Return a text diff of two datasets.""" + repr1 = repr(ds1) + repr2 = repr(ds2) + import difflib + + diff = difflib.ndiff(repr1.splitlines(keepends=True), repr2.splitlines(keepends=True)) + return "".join(diff) + + +def _dicts_equal(d1, d2): + # compare two dictionaries, including when their entries are lists or arrays ( == throws an error then) + if d1.keys() != d2.keys(): + return False + for k in d1: + v1, v2 = d1[k], d2[k] + # Compare lists or arrays element-wise + if isinstance(v1, (list, np.ndarray)) and isinstance(v2, (list, np.ndarray)): + if not np.array_equal(np.array(v1), np.array(v2)): + return False + else: + if v1 != v2: + return False + return True + + +def compare_datasets(ds1, ds2, ds1_name="Dataset 1", ds2_name="Dataset 2", verbose=True): + print(f"Comparing {ds1_name} and {ds2_name}\n") + + def verbose_print(*args, **kwargs): + if verbose: + print(*args, **kwargs) + + verbose_print("Dataset Attributes Comparison:") + if ds1.attrs == ds2.attrs: + verbose_print(" Dataset attributes are identical.") + else: + print(" Dataset attributes differ.") + for attr_name in set(ds1.attrs.keys()) | set(ds2.attrs.keys()): + if attr_name not in ds1.attrs: + print(f" Attribute '{attr_name}' only in {ds2_name}") + elif attr_name not in ds2.attrs: + print(f" Attribute '{attr_name}' only in {ds1_name}") + elif ds1.attrs[attr_name] != ds2.attrs[attr_name]: + print(f" Attribute '{attr_name}' differs:") + print(f" {ds1_name}: {ds1.attrs[attr_name]}") + print(f" {ds2_name}: {ds2.attrs[attr_name]}") + verbose_print("-" * 30) + + # Compare dimensions + verbose_print("Dimensions Comparison:") + ds1_dims = set(ds1.dims) + ds2_dims = set(ds2.dims) + if ds1_dims == ds2_dims: + verbose_print(" Dimension names are identical.") + else: + print(" Dimension names differ:") + print(f" {ds1_name} dims: {sorted(list(ds1_dims))}") + print(f" {ds2_name} dims: {sorted(list(ds2_dims))}") + + # For common dimensions, compare order (implicit by comparing coordinate values for sortedness) + # and size (though size is parameterized and expected to be different) + for dim_name in ds1_dims.intersection(ds2_dims): + verbose_print(f" Dimension '{dim_name}':") + # Sizes will differ due to DIM_SIZE, so we don't strictly compare them. + verbose_print(f" {ds1_name} size: {ds1.dims[dim_name]}, {ds2_name} size: {ds2.dims[dim_name]}") + # Check if coordinates associated with dimensions are sorted (increasing) + if dim_name in ds1.coords and dim_name in ds2.coords: + check_val = ( + np.timedelta64(0, "s") if isinstance(ds1[dim_name].values[0], (np.datetime64, np.timedelta64)) else 0.0 + ) + is_ds1_sorted = ( + np.all(np.diff(ds1[dim_name].values) >= check_val) if len(ds1[dim_name].values) > 1 else True + ) + is_ds2_sorted = ( + np.all(np.diff(ds2[dim_name].values) >= check_val) if len(ds2[dim_name].values) > 1 else True + ) + if is_ds1_sorted == is_ds2_sorted: + verbose_print(f" Order for '{dim_name}' is consistent (both sorted: {is_ds1_sorted})") + else: + print( + f" Order for '{dim_name}' differs: {ds1_name} sorted: {is_ds1_sorted}, {ds2_name} sorted: {is_ds2_sorted}" + ) + verbose_print("-" * 30) + + # Compare variables (name, attributes, dimensions used) + verbose_print("Variables Comparison:") + ds1_vars = set(ds1.variables.keys()) + ds2_vars = set(ds2.variables.keys()) + + if ds1_vars == ds2_vars: + verbose_print(" Variable names are identical.") + else: + print(" Variable names differ:") + print(f" {ds1_name} vars: {sorted(list(ds1_vars - ds2_vars))}") + print(f" {ds2_name} vars: {sorted(list(ds2_vars - ds1_vars))}") + print(f" Common vars: {sorted(list(ds1_vars.intersection(ds2_vars)))}") + + for var_name in ds1_vars.intersection(ds2_vars): + verbose_print(f" Variable '{var_name}':") + var1 = ds1[var_name] + var2 = ds2[var_name] + + # Compare attributes + if _dicts_equal(var1.attrs, var2.attrs): + verbose_print(" Attributes are identical.") + else: + print(" Attributes differ.") + for attr_name in set(var1.attrs.keys()) | set(var2.attrs.keys()): + if attr_name not in var1.attrs: + print(f" Attribute '{attr_name}' only in {ds2_name}'s '{var_name}'") + elif attr_name not in var2.attrs: + print(f" Attribute '{attr_name}' only in {ds1_name}'s '{var_name}'") + elif var1.attrs[attr_name] != var2.attrs[attr_name]: + print(f" Attribute '{attr_name}' differs for '{var_name}':") + print(f" {ds1_name}: {var1.attrs[attr_name]}") + print(f" {ds2_name}: {var2.attrs[attr_name]}") + + # Compare dimensions used by the variable + if var1.dims == var2.dims: + verbose_print(f" Dimensions used are identical: {var1.dims}") + else: + print(" Dimensions used differ:") + print(f" {ds1_name}: {var1.dims}") + print(f" {ds2_name}: {var2.dims}") + verbose_print("=" * 30 + " End of Comparison " + "=" * 30) + + +def from_xarray_dataset_dict(d) -> xr.Dataset: + """Reconstruct a dataset with zero data from the output of ``xarray.Dataset.to_dict(data=False)``. + + Useful in issues helping users debug fieldsets - sharing dataset schemas with associated metadata + without sharing the data itself. + + Example + ------- + >>> import xarray as xr + >>> from parcels._datasets.structured.generic import datasets + >>> ds = datasets['ds_2d_left'] + >>> d = ds.to_dict(data=False) + >>> ds2 = from_xarray_dataset_dict(d) + """ + return xr.Dataset.from_dict(_fill_with_dummy_data(copy.deepcopy(d))) + + +def _fill_with_dummy_data(d: dict[str, dict]): + assert isinstance(d, dict) + if "dtype" in d: + d["data"] = np.zeros(d["shape"], dtype=d["dtype"]) + del d["dtype"] + del d["shape"] + + for k in d: + if isinstance(d[k], dict): + d[k] = _fill_with_dummy_data(d[k]) + + return d diff --git a/parcels/_decorators.py b/parcels/_decorators.py new file mode 100644 index 000000000..697696a19 --- /dev/null +++ b/parcels/_decorators.py @@ -0,0 +1,60 @@ +"""Utilities to help with deprecations.""" + +from __future__ import annotations + +import functools +import warnings +from collections.abc import Callable + +PACKAGE = "Parcels" + + +def deprecated(msg: str = "") -> Callable: + """Decorator marking a function as being deprecated + + Parameters + ---------- + msg : str, optional + Custom message to append to the deprecation warning. + + Examples + -------- + ``` + @deprecated("Please use `another_function` instead") + def some_old_function(x, y): + return x + y + + @deprecated() + def some_other_old_function(x, y): + return x + y + ``` + """ + if msg: + msg = " " + msg + + def decorator(func): + @functools.wraps(func) + def wrapper(*args, **kwargs): + msg_formatted = ( + f"`{func.__qualname__}` is deprecated and will be removed in a future release of {PACKAGE}.{msg}" + ) + + warnings.warn(msg_formatted, category=DeprecationWarning, stacklevel=3) + return func(*args, **kwargs) + + _patch_docstring(wrapper, f"\n\n.. deprecated:: {msg}") + return wrapper + + return decorator + + +def deprecated_made_private(func: Callable) -> Callable: + return deprecated( + "It has moved to the internal API as it is not expected to be directly used by " + "the end-user. If you feel that you use this code directly in your scripts, please " + "comment on our tracking issue at https://github.com/OceanParcels/Parcels/issues/1695.", + )(func) + + +def _patch_docstring(obj: Callable, extra: str) -> None: + obj.__doc__ = f"{obj.__doc__ or ''}{extra}".strip() diff --git a/parcels/_index_search.py b/parcels/_index_search.py deleted file mode 100644 index ada8ff98f..000000000 --- a/parcels/_index_search.py +++ /dev/null @@ -1,337 +0,0 @@ -from __future__ import annotations - -from typing import TYPE_CHECKING - -import numpy as np - -from parcels._typing import ( - GridIndexingType, - InterpMethodOption, -) -from parcels.tools.statuscodes import ( - FieldOutOfBoundError, - FieldOutOfBoundSurfaceError, - _raise_field_out_of_bound_error, - _raise_field_out_of_bound_surface_error, - _raise_field_sampling_error, -) - -from .grid import GridType - -if TYPE_CHECKING: - from .field import Field - from .grid import Grid - - -def search_indices_vertical_z(grid: Grid, gridindexingtype: GridIndexingType, z: float): - if grid.depth[-1] > grid.depth[0]: - if z < grid.depth[0]: - # Since MOM5 is indexed at cell bottom, allow z at depth[0] - dz where dz = (depth[1] - depth[0]) - if gridindexingtype == "mom5" and z > 2 * grid.depth[0] - grid.depth[1]: - return (-1, z / grid.depth[0]) - else: - _raise_field_out_of_bound_surface_error(z, None, None) - elif z > grid.depth[-1]: - # In case of CROCO, allow particles in last (uppermost) layer using depth[-1] - if gridindexingtype in ["croco"] and z < 0: - return (-2, 1) - _raise_field_out_of_bound_error(z, None, None) - depth_indices = grid.depth < z - if z >= grid.depth[-1]: - zi = len(grid.depth) - 2 - else: - zi = depth_indices.argmin() - 1 if z > grid.depth[0] else 0 - else: - if z > grid.depth[0]: - _raise_field_out_of_bound_surface_error(z, None, None) - elif z < grid.depth[-1]: - _raise_field_out_of_bound_error(z, None, None) - depth_indices = grid.depth > z - if z <= grid.depth[-1]: - zi = len(grid.depth) - 2 - else: - zi = depth_indices.argmin() - 1 if z < grid.depth[0] else 0 - zeta = (z - grid.depth[zi]) / (grid.depth[zi + 1] - grid.depth[zi]) - while zeta > 1: - zi += 1 - zeta = (z - grid.depth[zi]) / (grid.depth[zi + 1] - grid.depth[zi]) - while zeta < 0: - zi -= 1 - zeta = (z - grid.depth[zi]) / (grid.depth[zi + 1] - grid.depth[zi]) - return (zi, zeta) - - -def search_indices_vertical_s( - grid: Grid, - interp_method: InterpMethodOption, - time: float, - z: float, - y: float, - x: float, - ti: int, - yi: int, - xi: int, - eta: float, - xsi: float, -): - if interp_method in ["bgrid_velocity", "bgrid_w_velocity", "bgrid_tracer"]: - xsi = 1 - eta = 1 - if time < grid.time[ti]: - ti -= 1 - if grid._z4d: # type: ignore[attr-defined] - if ti == len(grid.time) - 1: - depth_vector = ( - (1 - xsi) * (1 - eta) * grid.depth[-1, :, yi, xi] - + xsi * (1 - eta) * grid.depth[-1, :, yi, xi + 1] - + xsi * eta * grid.depth[-1, :, yi + 1, xi + 1] - + (1 - xsi) * eta * grid.depth[-1, :, yi + 1, xi] - ) - else: - dv2 = ( - (1 - xsi) * (1 - eta) * grid.depth[ti : ti + 2, :, yi, xi] - + xsi * (1 - eta) * grid.depth[ti : ti + 2, :, yi, xi + 1] - + xsi * eta * grid.depth[ti : ti + 2, :, yi + 1, xi + 1] - + (1 - xsi) * eta * grid.depth[ti : ti + 2, :, yi + 1, xi] - ) - tt = (time - grid.time[ti]) / (grid.time[ti + 1] - grid.time[ti]) - assert tt >= 0 and tt <= 1, "Vertical s grid is being wrongly interpolated in time" - depth_vector = dv2[0, :] * (1 - tt) + dv2[1, :] * tt - else: - depth_vector = ( - (1 - xsi) * (1 - eta) * grid.depth[:, yi, xi] - + xsi * (1 - eta) * grid.depth[:, yi, xi + 1] - + xsi * eta * grid.depth[:, yi + 1, xi + 1] - + (1 - xsi) * eta * grid.depth[:, yi + 1, xi] - ) - z = np.float32(z) # type: ignore # TODO: remove type ignore once we migrate to float64 - - if depth_vector[-1] > depth_vector[0]: - if z < depth_vector[0]: - _raise_field_out_of_bound_error(z, None, None) - elif z > depth_vector[-1]: - _raise_field_out_of_bound_error(z, None, None) - depth_indices = depth_vector < z - if z >= depth_vector[-1]: - zi = len(depth_vector) - 2 - else: - zi = depth_indices.argmin() - 1 if z > depth_vector[0] else 0 - else: - if z > depth_vector[0]: - _raise_field_out_of_bound_error(z, None, None) - elif z < depth_vector[-1]: - _raise_field_out_of_bound_error(z, None, None) - depth_indices = depth_vector > z - if z <= depth_vector[-1]: - zi = len(depth_vector) - 2 - else: - zi = depth_indices.argmin() - 1 if z < depth_vector[0] else 0 - zeta = (z - depth_vector[zi]) / (depth_vector[zi + 1] - depth_vector[zi]) - while zeta > 1: - zi += 1 - zeta = (z - depth_vector[zi]) / (depth_vector[zi + 1] - depth_vector[zi]) - while zeta < 0: - zi -= 1 - zeta = (z - depth_vector[zi]) / (depth_vector[zi + 1] - depth_vector[zi]) - return (zi, zeta) - - -def _search_indices_rectilinear( - field: Field, time: float, z: float, y: float, x: float, ti=-1, particle=None, search2D=False -): - grid = field.grid - - if grid.xdim > 1 and (not grid.zonal_periodic): - if x < grid.lonlat_minmax[0] or x > grid.lonlat_minmax[1]: - _raise_field_out_of_bound_error(z, y, x) - if grid.ydim > 1 and (y < grid.lonlat_minmax[2] or y > grid.lonlat_minmax[3]): - _raise_field_out_of_bound_error(z, y, x) - - if grid.xdim > 1: - if grid.mesh != "spherical": - lon_index = grid.lon < x - if lon_index.all(): - xi = len(grid.lon) - 2 - else: - xi = lon_index.argmin() - 1 if lon_index.any() else 0 - xsi = (x - grid.lon[xi]) / (grid.lon[xi + 1] - grid.lon[xi]) - if xsi < 0: - xi -= 1 - xsi = (x - grid.lon[xi]) / (grid.lon[xi + 1] - grid.lon[xi]) - elif xsi > 1: - xi += 1 - xsi = (x - grid.lon[xi]) / (grid.lon[xi + 1] - grid.lon[xi]) - else: - lon_fixed = grid.lon.copy() - indices = lon_fixed >= lon_fixed[0] - if not indices.all(): - lon_fixed[indices.argmin() :] += 360 - if x < lon_fixed[0]: - lon_fixed -= 360 - - lon_index = lon_fixed < x - if lon_index.all(): - xi = len(lon_fixed) - 2 - else: - xi = lon_index.argmin() - 1 if lon_index.any() else 0 - xsi = (x - lon_fixed[xi]) / (lon_fixed[xi + 1] - lon_fixed[xi]) - if xsi < 0: - xi -= 1 - xsi = (x - lon_fixed[xi]) / (lon_fixed[xi + 1] - lon_fixed[xi]) - elif xsi > 1: - xi += 1 - xsi = (x - lon_fixed[xi]) / (lon_fixed[xi + 1] - lon_fixed[xi]) - else: - xi, xsi = -1, 0 - - if grid.ydim > 1: - lat_index = grid.lat < y - if lat_index.all(): - yi = len(grid.lat) - 2 - else: - yi = lat_index.argmin() - 1 if lat_index.any() else 0 - - eta = (y - grid.lat[yi]) / (grid.lat[yi + 1] - grid.lat[yi]) - if eta < 0: - yi -= 1 - eta = (y - grid.lat[yi]) / (grid.lat[yi + 1] - grid.lat[yi]) - elif eta > 1: - yi += 1 - eta = (y - grid.lat[yi]) / (grid.lat[yi + 1] - grid.lat[yi]) - else: - yi, eta = -1, 0 - - if grid.zdim > 1 and not search2D: - if grid._gtype == GridType.RectilinearZGrid: - try: - (zi, zeta) = search_indices_vertical_z(field.grid, field.gridindexingtype, z) - except FieldOutOfBoundError: - _raise_field_out_of_bound_error(z, y, x) - except FieldOutOfBoundSurfaceError: - _raise_field_out_of_bound_surface_error(z, y, x) - elif grid._gtype == GridType.RectilinearSGrid: - (zi, zeta) = search_indices_vertical_s(field.grid, field.interp_method, time, z, y, x, ti, yi, xi, eta, xsi) - else: - zi, zeta = -1, 0 - - if not ((0 <= xsi <= 1) and (0 <= eta <= 1) and (0 <= zeta <= 1)): - _raise_field_sampling_error(z, y, x) - - if particle: - particle.xi[field.igrid] = xi - particle.yi[field.igrid] = yi - particle.zi[field.igrid] = zi - - return (zeta, eta, xsi, zi, yi, xi) - - -def _search_indices_curvilinear(field: Field, time, z, y, x, ti=-1, particle=None, search2D=False): - if particle: - xi = particle.xi[field.igrid] - yi = particle.yi[field.igrid] - else: - xi = int(field.grid.xdim / 2) - 1 - yi = int(field.grid.ydim / 2) - 1 - xsi = eta = -1.0 - grid = field.grid - invA = np.array([[1, 0, 0, 0], [-1, 1, 0, 0], [-1, 0, 0, 1], [1, -1, 1, -1]]) - maxIterSearch = 1e6 - it = 0 - tol = 1.0e-10 - if not grid.zonal_periodic: - if x < grid.lonlat_minmax[0] or x > grid.lonlat_minmax[1]: - if grid.lon[0, 0] < grid.lon[0, -1]: - _raise_field_out_of_bound_error(z, y, x) - elif x < grid.lon[0, 0] and x > grid.lon[0, -1]: # This prevents from crashing in [160, -160] - _raise_field_out_of_bound_error(z, y, x) - if y < grid.lonlat_minmax[2] or y > grid.lonlat_minmax[3]: - _raise_field_out_of_bound_error(z, y, x) - - while xsi < -tol or xsi > 1 + tol or eta < -tol or eta > 1 + tol: - px = np.array([grid.lon[yi, xi], grid.lon[yi, xi + 1], grid.lon[yi + 1, xi + 1], grid.lon[yi + 1, xi]]) - if grid.mesh == "spherical": - px[0] = px[0] + 360 if px[0] < x - 225 else px[0] - px[0] = px[0] - 360 if px[0] > x + 225 else px[0] - px[1:] = np.where(px[1:] - px[0] > 180, px[1:] - 360, px[1:]) - px[1:] = np.where(-px[1:] + px[0] > 180, px[1:] + 360, px[1:]) - py = np.array([grid.lat[yi, xi], grid.lat[yi, xi + 1], grid.lat[yi + 1, xi + 1], grid.lat[yi + 1, xi]]) - a = np.dot(invA, px) - b = np.dot(invA, py) - - aa = a[3] * b[2] - a[2] * b[3] - bb = a[3] * b[0] - a[0] * b[3] + a[1] * b[2] - a[2] * b[1] + x * b[3] - y * a[3] - cc = a[1] * b[0] - a[0] * b[1] + x * b[1] - y * a[1] - if abs(aa) < 1e-12: # Rectilinear cell, or quasi - eta = -cc / bb - else: - det2 = bb * bb - 4 * aa * cc - if det2 > 0: # so, if det is nan we keep the xsi, eta from previous iter - det = np.sqrt(det2) - eta = (-bb + det) / (2 * aa) - if abs(a[1] + a[3] * eta) < 1e-12: # this happens when recti cell rotated of 90deg - xsi = ((y - py[0]) / (py[1] - py[0]) + (y - py[3]) / (py[2] - py[3])) * 0.5 - else: - xsi = (x - a[0] - a[2] * eta) / (a[1] + a[3] * eta) - if xsi < 0 and eta < 0 and xi == 0 and yi == 0: - _raise_field_out_of_bound_error(0, y, x) - if xsi > 1 and eta > 1 and xi == grid.xdim - 1 and yi == grid.ydim - 1: - _raise_field_out_of_bound_error(0, y, x) - if xsi < -tol: - xi -= 1 - elif xsi > 1 + tol: - xi += 1 - if eta < -tol: - yi -= 1 - elif eta > 1 + tol: - yi += 1 - (yi, xi) = _reconnect_bnd_indices(yi, xi, grid.ydim, grid.xdim, grid.mesh) - it += 1 - if it > maxIterSearch: - print(f"Correct cell not found after {maxIterSearch} iterations") - _raise_field_out_of_bound_error(0, y, x) - xsi = max(0.0, xsi) - eta = max(0.0, eta) - xsi = min(1.0, xsi) - eta = min(1.0, eta) - - if grid.zdim > 1 and not search2D: - if grid._gtype == GridType.CurvilinearZGrid: - try: - (zi, zeta) = search_indices_vertical_z(field.grid, field.gridindexingtype, z) - except FieldOutOfBoundError: - _raise_field_out_of_bound_error(z, y, x) - elif grid._gtype == GridType.CurvilinearSGrid: - (zi, zeta) = search_indices_vertical_s(field.grid, field.interp_method, time, z, y, x, ti, yi, xi, eta, xsi) - else: - zi = -1 - zeta = 0 - - if not ((0 <= xsi <= 1) and (0 <= eta <= 1) and (0 <= zeta <= 1)): - _raise_field_sampling_error(z, y, x) - - if particle: - particle.xi[field.igrid] = xi - particle.yi[field.igrid] = yi - particle.zi[field.igrid] = zi - - return (zeta, eta, xsi, zi, yi, xi) - - -def _reconnect_bnd_indices(yi: int, xi: int, ydim: int, xdim: int, sphere_mesh: bool): - if xi < 0: - if sphere_mesh: - xi = xdim - 2 - else: - xi = 0 - if xi > xdim - 2: - if sphere_mesh: - xi = 0 - else: - xi = xdim - 2 - if yi < 0: - yi = 0 - if yi > ydim - 2: - yi = ydim - 2 - if sphere_mesh: - xi = xdim - xi - return yi, xi diff --git a/parcels/_interpolation.py b/parcels/_interpolation.py index a533fd9d5..e38f0d0d0 100644 --- a/parcels/_interpolation.py +++ b/parcels/_interpolation.py @@ -4,6 +4,7 @@ import numpy as np from parcels._typing import GridIndexingType +from parcels.utils._helpers import should_calculate_next_ti @dataclass @@ -14,6 +15,8 @@ class InterpolationContext2D: ---------- data: np.ndarray field data of shape (time, y, x) + tau: float + time interpolation coordinate in unit length eta: float y-direction interpolation coordinate in unit cube (between 0 and 1) xsi: float @@ -28,6 +31,7 @@ class InterpolationContext2D: """ data: np.ndarray + tau: float eta: float xsi: float ti: int @@ -45,6 +49,8 @@ class InterpolationContext3D: field data of shape (time, z, y, x). This needs to be complete in the vertical direction as some interpolation methods need to know whether they are at the surface or bottom. + tau: float + time interpolation coordinate in unit length zeta: float vertical interpolation coordinate in unit cube eta: float @@ -65,6 +71,7 @@ class InterpolationContext3D: """ data: np.ndarray + tau: float zeta: float eta: float xsi: float @@ -110,7 +117,11 @@ def decorator(interpolator: Callable[[InterpolationContext3D], float]): def _nearest_2d(ctx: InterpolationContext2D) -> float: xii = ctx.xi if ctx.xsi <= 0.5 else ctx.xi + 1 yii = ctx.yi if ctx.eta <= 0.5 else ctx.yi + 1 - return ctx.data[ctx.ti, yii, xii] + ft0 = ctx.data[ctx.ti, yii, xii] + if not should_calculate_next_ti(ctx.ti, ctx.tau, ctx.data.shape[0]): + return ft0 + ft1 = ctx.data[ctx.ti + 1, yii, xii] + return (1 - ctx.tau) * ft0 + ctx.tau * ft1 def _interp_on_unit_square(*, eta: float, xsi: float, data: np.ndarray, yi: int, xi: int) -> float: @@ -128,7 +139,11 @@ def _interp_on_unit_square(*, eta: float, xsi: float, data: np.ndarray, yi: int, @register_2d_interpolator("partialslip") @register_2d_interpolator("freeslip") def _linear_2d(ctx: InterpolationContext2D) -> float: - return _interp_on_unit_square(eta=ctx.eta, xsi=ctx.xsi, data=ctx.data[ctx.ti, :, :], yi=ctx.yi, xi=ctx.xi) + ft0 = _interp_on_unit_square(eta=ctx.eta, xsi=ctx.xsi, data=ctx.data[ctx.ti, :, :], yi=ctx.yi, xi=ctx.xi) + if not should_calculate_next_ti(ctx.ti, ctx.tau, ctx.data.shape[0]): + return ft0 + ft1 = _interp_on_unit_square(eta=ctx.eta, xsi=ctx.xsi, data=ctx.data[ctx.ti + 1, :, :], yi=ctx.yi, xi=ctx.xi) + return (1 - ctx.tau) * ft0 + ctx.tau * ft1 @register_2d_interpolator("linear_invdist_land_tracer") @@ -142,6 +157,13 @@ def _linear_invdist_land_tracer_2d(ctx: InterpolationContext2D) -> float: land = np.isclose(data[ti, yi : yi + 2, xi : xi + 2], 0.0) nb_land = np.sum(land) + def _get_data_temporalinterp(*, ti, yi, xi): + dt0 = data[ti, yi, xi] + if not should_calculate_next_ti(ctx.ti, ctx.tau, ctx.data.shape[0]): + return dt0 + dt1 = data[ti + 1, yi, xi] + return (1 - ctx.tau) * dt0 + ctx.tau * dt1 + if nb_land == 4: return 0 elif nb_land > 0: @@ -154,9 +176,9 @@ def _linear_invdist_land_tracer_2d(ctx: InterpolationContext2D) -> float: if land[j][i] == 1: # index search led us directly onto land return 0 else: - return data[ti, yi + j, xi + i] + return _get_data_temporalinterp(ti=ti, yi=yi + j, xi=xi + i) elif land[j][i] == 0: - val += data[ti, yi + j, xi + i] / distance + val += _get_data_temporalinterp(ti=ti, yi=yi + j, xi=xi + i) / distance w_sum += 1 / distance return val / w_sum else: @@ -166,7 +188,11 @@ def _linear_invdist_land_tracer_2d(ctx: InterpolationContext2D) -> float: @register_2d_interpolator("cgrid_tracer") @register_2d_interpolator("bgrid_tracer") def _tracer_2d(ctx: InterpolationContext2D) -> float: - return ctx.data[ctx.ti, ctx.yi + 1, ctx.xi + 1] + ft0 = ctx.data[ctx.ti, ctx.yi + 1, ctx.xi + 1] + if not should_calculate_next_ti(ctx.ti, ctx.tau, ctx.data.shape[0]): + return ft0 + ft1 = ctx.data[ctx.ti + 1, ctx.yi + 1, ctx.xi + 1] + return (1 - ctx.tau) * ft0 + ctx.tau * ft1 @register_3d_interpolator("nearest") @@ -174,25 +200,52 @@ def _nearest_3d(ctx: InterpolationContext3D) -> float: xii = ctx.xi if ctx.xsi <= 0.5 else ctx.xi + 1 yii = ctx.yi if ctx.eta <= 0.5 else ctx.yi + 1 zii = ctx.zi if ctx.zeta <= 0.5 else ctx.zi + 1 - return ctx.data[ctx.ti, zii, yii, xii] + ft0 = ctx.data[ctx.ti, zii, yii, xii] + if not should_calculate_next_ti(ctx.ti, ctx.tau, ctx.data.shape[0]): + return ft0 + ft1 = ctx.data[ctx.ti + 1, zii, yii, xii] + return (1 - ctx.tau) * ft0 + ctx.tau * ft1 + + +def _get_cgrid_depth_point(*, zeta: float, data: np.ndarray, zi: int, yi: int, xi: int) -> float: + f0 = data[zi, yi, xi] + f1 = data[zi + 1, yi, xi] + return (1 - zeta) * f0 + zeta * f1 @register_3d_interpolator("cgrid_velocity") -def _cgrid_velocity_3d(ctx: InterpolationContext3D) -> float: +def _cgrid_W_velocity_3d(ctx: InterpolationContext3D) -> float: # evaluating W velocity in c_grid if ctx.gridindexingtype == "nemo": - f0 = ctx.data[ctx.ti, ctx.zi, ctx.yi + 1, ctx.xi + 1] - f1 = ctx.data[ctx.ti, ctx.zi + 1, ctx.yi + 1, ctx.xi + 1] + ft0 = _get_cgrid_depth_point( + zeta=ctx.zeta, data=ctx.data[ctx.ti, :, :, :], zi=ctx.zi, yi=ctx.yi + 1, xi=ctx.xi + 1 + ) elif ctx.gridindexingtype in ["mitgcm", "croco"]: - f0 = ctx.data[ctx.ti, ctx.zi, ctx.yi, ctx.xi] - f1 = ctx.data[ctx.ti, ctx.zi + 1, ctx.yi, ctx.xi] - return (1 - ctx.zeta) * f0 + ctx.zeta * f1 + ft0 = _get_cgrid_depth_point(zeta=ctx.zeta, data=ctx.data[ctx.ti, :, :, :], zi=ctx.zi, yi=ctx.yi, xi=ctx.xi) + if not should_calculate_next_ti(ctx.ti, ctx.tau, ctx.data.shape[0]): + return ft0 + + if ctx.gridindexingtype == "nemo": + ft1 = _get_cgrid_depth_point( + zeta=ctx.zeta, data=ctx.data[ctx.ti + 1, :, :, :], zi=ctx.zi, yi=ctx.yi + 1, xi=ctx.xi + 1 + ) + elif ctx.gridindexingtype in ["mitgcm", "croco"]: + ft1 = _get_cgrid_depth_point(zeta=ctx.zeta, data=ctx.data[ctx.ti + 1, :, :, :], zi=ctx.zi, yi=ctx.yi, xi=ctx.xi) + return (1 - ctx.tau) * ft0 + ctx.tau * ft1 @register_3d_interpolator("linear_invdist_land_tracer") def _linear_invdist_land_tracer_3d(ctx: InterpolationContext3D) -> float: land = np.isclose(ctx.data[ctx.ti, ctx.zi : ctx.zi + 2, ctx.yi : ctx.yi + 2, ctx.xi : ctx.xi + 2], 0.0) nb_land = np.sum(land) + + def _get_data_temporalinterp(*, ti, zi, yi, xi): + dt0 = ctx.data[ti, zi, yi, xi] + if not should_calculate_next_ti(ctx.ti, ctx.tau, ctx.data.shape[0]): + return dt0 + dt1 = data[ti + 1, zi, yi, xi] + return (1 - ctx.tau) * dt0 + ctx.tau * dt1 + if nb_land == 8: return 0 elif nb_land > 0: @@ -206,9 +259,11 @@ def _linear_invdist_land_tracer_3d(ctx: InterpolationContext3D) -> float: if land[k][j][i] == 1: # index search led us directly onto land return 0 else: - return ctx.data[ctx.ti, ctx.zi + k, ctx.yi + j, ctx.xi + i] + return _get_data_temporalinterp(ti=ctx.ti, zi=ctx.zi + k, yi=ctx.yi + j, xi=ctx.xi + i) elif land[k][j][i] == 0: - val += ctx.data[ctx.ti, ctx.zi + k, ctx.yi + j, ctx.xi + i] / distance + val += ( + _get_data_temporalinterp(ti=ctx.ti, zi=ctx.zi + k, yi=ctx.yi + j, xi=ctx.xi + i) / distance + ) w_sum += 1 / distance return val / w_sum else: @@ -253,9 +308,15 @@ def _z_layer_interp( def _linear_3d(ctx: InterpolationContext3D) -> float: zdim = ctx.data.shape[1] data_3d = ctx.data[ctx.ti, :, :, :] - f0, f1 = _get_3d_f0_f1(eta=ctx.eta, xsi=ctx.xsi, data=data_3d, zi=ctx.zi, yi=ctx.yi, xi=ctx.xi) + fz0, fz1 = _get_3d_f0_f1(eta=ctx.eta, xsi=ctx.xsi, data=data_3d, zi=ctx.zi, yi=ctx.yi, xi=ctx.xi) + if should_calculate_next_ti(ctx.ti, ctx.tau, ctx.data.shape[0]): + data_3d = ctx.data[ctx.ti + 1, :, :, :] + fz0_t1, fz1_t1 = _get_3d_f0_f1(eta=ctx.eta, xsi=ctx.xsi, data=data_3d, zi=ctx.zi, yi=ctx.yi, xi=ctx.xi) + fz0 = (1 - ctx.tau) * fz0 + ctx.tau * fz0_t1 + if fz1_t1 is not None and fz1 is not None: + fz1 = (1 - ctx.tau) * fz1 + ctx.tau * fz1_t1 - return _z_layer_interp(zeta=ctx.zeta, f0=f0, f1=f1, zi=ctx.zi, zdim=zdim, gridindexingtype=ctx.gridindexingtype) + return _z_layer_interp(zeta=ctx.zeta, f0=fz0, f1=fz1, zi=ctx.zi, zdim=zdim, gridindexingtype=ctx.gridindexingtype) @register_3d_interpolator("bgrid_velocity") @@ -277,4 +338,8 @@ def _linear_3d_bgrid_w_velocity(ctx: InterpolationContext3D) -> float: @register_3d_interpolator("bgrid_tracer") @register_3d_interpolator("cgrid_tracer") def _tracer_3d(ctx: InterpolationContext3D) -> float: - return ctx.data[ctx.ti, ctx.zi, ctx.yi + 1, ctx.xi + 1] + ft0 = ctx.data[ctx.ti, ctx.zi, ctx.yi + 1, ctx.xi + 1] + if not should_calculate_next_ti(ctx.ti, ctx.tau, ctx.data.shape[0]): + return ft0 + ft1 = ctx.data[ctx.ti + 1, ctx.zi, ctx.yi + 1, ctx.xi + 1] + return (1 - ctx.tau) * ft0 + ctx.tau * ft1 diff --git a/parcels/tools/loggers.py b/parcels/_logger.py similarity index 100% rename from parcels/tools/loggers.py rename to parcels/_logger.py diff --git a/parcels/_python.py b/parcels/_python.py new file mode 100644 index 000000000..91f5b4645 --- /dev/null +++ b/parcels/_python.py @@ -0,0 +1,28 @@ +# Generic Python helpers + + +def isinstance_noimport(obj, class_or_tuple): + """A version of isinstance that does not require importing the class. + This is useful to avoid circular imports. + """ + return ( + type(obj).__name__ == class_or_tuple + if isinstance(class_or_tuple, str) + else type(obj).__name__ in class_or_tuple + ) + + +def test_isinstance_noimport(): + class A: + pass + + class B: + pass + + a = A() + b = B() + + assert isinstance_noimport(a, "A") + assert not isinstance_noimport(a, "B") + assert isinstance_noimport(b, ("A", "B")) + assert not isinstance_noimport(b, "C") diff --git a/parcels/_reprs.py b/parcels/_reprs.py new file mode 100644 index 000000000..6ea42992a --- /dev/null +++ b/parcels/_reprs.py @@ -0,0 +1,83 @@ +"""Parcels reprs""" + +from __future__ import annotations + +import textwrap +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from parcels import Field, FieldSet, ParticleSet + + +def field_repr(field: Field) -> str: # TODO v4: Rework or remove entirely + """Return a pretty repr for Field""" + out = f"""<{type(field).__name__}> + name : {field.name!r} + data : {field.data!r} + extrapolate time: {field.allow_time_extrapolation!r} +""" + return textwrap.dedent(out).strip() + + +def _format_list_items_multiline(items: list[str], level: int = 1) -> str: + """Given a list of strings, formats them across multiple lines. + + Uses indentation levels of 4 spaces provided by ``level``. + + Example + ------- + >>> output = _format_list_items_multiline(["item1", "item2", "item3"], 4) + >>> f"my_items: {output}" + my_items: [ + item1, + item2, + item3, + ] + """ + if len(items) == 0: + return "[]" + + assert level >= 1, "Indentation level >=1 supported" + indentation_str = level * 4 * " " + indentation_str_end = (level - 1) * 4 * " " + + items_str = ",\n".join([textwrap.indent(i, indentation_str) for i in items]) + return f"[\n{items_str}\n{indentation_str_end}]" + + +def particleset_repr(pset: ParticleSet) -> str: + """Return a pretty repr for ParticleSet""" + if len(pset) < 10: + particles = [repr(p) for p in pset] + else: + particles = [repr(pset[i]) for i in range(7)] + ["..."] + + out = f"""<{type(pset).__name__}> + fieldset : +{textwrap.indent(repr(pset.fieldset), " " * 8)} + ptype : {pset._ptype} + # particles: {len(pset)} + particles : {_format_list_items_multiline(particles, level=2)} +""" + return textwrap.dedent(out).strip() + + +def fieldset_repr(fieldset: FieldSet) -> str: # TODO v4: Rework or remove entirely + """Return a pretty repr for FieldSet""" + fields_repr = "\n".join([repr(f) for f in fieldset.fields.values()]) + + out = f"""<{type(fieldset).__name__}> + fields: +{textwrap.indent(fields_repr, 8 * " ")} +""" + return textwrap.dedent(out).strip() + + +def default_repr(obj: Any): + if is_builtin_object(obj): + return repr(obj) + return object.__repr__(obj) + + +def is_builtin_object(obj): + return obj.__class__.__module__ == "builtins" diff --git a/parcels/tools/exampledata_utils.py b/parcels/_tutorial.py similarity index 55% rename from parcels/tools/exampledata_utils.py rename to parcels/_tutorial.py index 7a1192f3d..00dc3bae6 100644 --- a/parcels/tools/exampledata_utils.py +++ b/parcels/_tutorial.py @@ -1,13 +1,33 @@ import os from datetime import datetime, timedelta from pathlib import Path -from urllib.request import urlretrieve -import platformdirs +import pooch +import xarray as xr -__all__ = ["download_example_dataset", "get_data_home", "list_example_datasets"] +from parcels._v3to4 import patch_dataset_v4_compat -example_data_files = { +__all__ = ["download_example_dataset", "list_example_datasets"] + +# When modifying existing datasets in a backwards incompatible way, +# make a new release in the repo and update the DATA_REPO_TAG to the new tag +DATA_REPO_TAG = "main" + +DATA_URL = f"https://github.com/OceanParcels/parcels-data/raw/{DATA_REPO_TAG}/data" + +# Keys are the dataset names. Values are the filenames in the dataset folder. Note that +# you can specify subfolders in the dataset folder putting slashes in the filename list. +# e.g., +# "my_dataset": ["file0.nc", "folder1/file1.nc", "folder2/file2.nc"] +# my_dataset/ +# ├── file0.nc +# ├── folder1/ +# │ └── file1.nc +# └── folder2/ +# └── file2.nc +# +# See instructions at https://github.com/OceanParcels/parcels-data for adding new datasets +EXAMPLE_DATA_FILES: dict[str, list[str]] = { "MovingEddies_data": [ "moving_eddiesP.nc", "moving_eddiesU.nc", @@ -25,10 +45,20 @@ f"{date.strftime('%Y%m%d')}000000-GLOBCURRENT-L4-CUReul_hs-ALT_SUM-v02.0-fv01.0.nc" for date in ([datetime(2002, 1, 1) + timedelta(days=x) for x in range(0, 365)] + [datetime(2003, 1, 1)]) ], + "CopernicusMarine_data_for_Argo_tutorial": [ + "cmems_mod_glo_phy-cur_anfc_0.083deg_P1D-m_uo-vo_31.00E-33.00E_33.00S-30.00S_0.49-2225.08m_2024-01-01-2024-02-01.nc", + "cmems_mod_glo_phy-thetao_anfc_0.083deg_P1D-m_thetao_31.00E-33.00E_33.00S-30.00S_0.49-2225.08m_2024-01-01-2024-02-01.nc", + ], "DecayingMovingEddy_data": [ "decaying_moving_eddyU.nc", "decaying_moving_eddyV.nc", ], + "FESOM_periodic_channel": [ + "fesom_channel.nc", + "u.fesom_channel.nc", + "v.fesom_channel.nc", + "w.fesom_channel.nc", + ], "NemoCurvilinear_data": [ "U_purely_zonal-ORCA025_grid_U.nc4", "V_purely_zonal-ORCA025_grid_V.nc4", @@ -76,24 +106,32 @@ } -example_data_url = "http://oceanparcels.org/examples-data" +def _create_pooch_registry() -> dict[str, None]: + """Collapses the mapping of dataset names to filenames into a pooch registry. + + Hashes are set to None for all files. + """ + registry: dict[str, None] = {} + for dataset, filenames in EXAMPLE_DATA_FILES.items(): + for filename in filenames: + registry[f"{dataset}/{filename}"] = None + return registry -def get_data_home(data_home=None): - """Return a path to the cache directory for example datasets. +POOCH_REGISTRY = _create_pooch_registry() - This directory is used by :func:`load_dataset`. - If the ``data_home`` argument is not provided, it will use a directory - specified by the ``PARCELS_EXAMPLE_DATA`` environment variable (if it exists) - or otherwise default to an OS-appropriate user cache location. - """ +def _get_pooch(data_home=None): if data_home is None: - data_home = os.environ.get("PARCELS_EXAMPLE_DATA", platformdirs.user_cache_dir("parcels")) - data_home = os.path.expanduser(data_home) - if not os.path.exists(data_home): - os.makedirs(data_home) - return data_home + data_home = os.environ.get("PARCELS_EXAMPLE_DATA") + if data_home is None: + data_home = pooch.os_cache("parcels") + + return pooch.create( + path=data_home, + base_url=DATA_URL, + registry=POOCH_REGISTRY, + ) def list_example_datasets() -> list[str]: @@ -106,7 +144,7 @@ def list_example_datasets() -> list[str]: datasets : list of str The names of the available example datasets. """ - return list(example_data_files.keys()) + return list(EXAMPLE_DATA_FILES.keys()) def download_example_dataset(dataset: str, data_home=None): @@ -130,21 +168,30 @@ def download_example_dataset(dataset: str, data_home=None): Path to the folder containing the downloaded dataset files. """ # Dev note: `dataset` is assumed to be a folder name with netcdf files - if dataset not in example_data_files: + if dataset not in EXAMPLE_DATA_FILES: raise ValueError( - f"Dataset {dataset!r} not found. Available datasets are: " + ", ".join(example_data_files.keys()) + f"Dataset {dataset!r} not found. Available datasets are: " + ", ".join(EXAMPLE_DATA_FILES.keys()) ) + odie = _get_pooch(data_home=data_home) - cache_folder = get_data_home(data_home) - dataset_folder = Path(cache_folder) / dataset + cache_folder = Path(odie.path) + dataset_folder = cache_folder / dataset - if not dataset_folder.exists(): - dataset_folder.mkdir(parents=True) - - for filename in example_data_files[dataset]: - filepath = dataset_folder / filename - if not filepath.exists(): - url = f"{example_data_url}/{dataset}/{filename}" - urlretrieve(url, str(filepath)) + for file_name in odie.registry: + if file_name.startswith(dataset): + should_patch = dataset == "GlobCurrent_example_data" + odie.fetch(file_name, processor=_v4_compat_patch if should_patch else None) return dataset_folder + + +def _v4_compat_patch(fname, action, pup): + """ + Patch the GlobCurrent example dataset to be compatible with v4. + + See https://www.fatiando.org/pooch/latest/processors.html#creating-your-own-processors + """ + if action == "fetch": + return fname + xr.load_dataset(fname).pipe(patch_dataset_v4_compat).to_netcdf(fname) + return fname diff --git a/parcels/_typing.py b/parcels/_typing.py index b64603209..7c2e12b8f 100644 --- a/parcels/_typing.py +++ b/parcels/_typing.py @@ -6,16 +6,13 @@ """ -import ast -import datetime import os from collections.abc import Callable +from datetime import datetime from typing import Any, Literal, get_args - -class ParcelsAST(ast.AST): - ccode: str - +import numpy as np +from cftime import datetime as cftime_datetime InterpMethodOption = Literal[ "linear", @@ -35,12 +32,9 @@ class ParcelsAST(ast.AST): PathLike = str | os.PathLike Mesh = Literal["spherical", "flat"] # corresponds with `mesh` VectorType = Literal["3D", "3DSigma", "2D"] | None # corresponds with `vector_type` -ChunkMode = Literal["auto", "specific", "failsafe"] # corresponds with `chunk_mode` GridIndexingType = Literal["pop", "mom5", "mitgcm", "nemo", "croco"] # corresponds with `gridindexingtype` -UpdateStatus = Literal["not_updated", "first_updated", "updated"] # corresponds with `_update_status` -TimePeriodic = float | datetime.timedelta | Literal[False] # corresponds with `time_periodic` NetcdfEngine = Literal["netcdf4", "xarray", "scipy"] - +TimeLike = datetime | cftime_datetime | np.datetime64 KernelFunction = Callable[..., None] diff --git a/parcels/_v3to4.py b/parcels/_v3to4.py new file mode 100644 index 000000000..b888cc49c --- /dev/null +++ b/parcels/_v3to4.py @@ -0,0 +1,27 @@ +""" +Temporary utilities to help with the transition from v3 to v4 of Parcels. + +TODO v4: Remove this module. Move functions that are still relevant into other modules +""" + +from collections.abc import Callable + +import xarray as xr + + +def Unit_to_units(d: dict) -> dict: + if "Unit" in d: + d["units"] = d.pop("Unit") + return d + + +def xarray_patch_metadata(ds: xr.Dataset, f: Callable[[dict], dict]) -> xr.Dataset: + """Convert attrs""" + for var in ds.variables: + ds[var].attrs = f(ds[var].attrs) + return ds + + +def patch_dataset_v4_compat(ds: xr.Dataset) -> xr.Dataset: + """Patches an xarray dataset to be compatible with v4""" + return ds.pipe(xarray_patch_metadata, Unit_to_units) diff --git a/parcels/application_kernels/__init__.py b/parcels/application_kernels/__init__.py deleted file mode 100644 index d308bcb1e..000000000 --- a/parcels/application_kernels/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from .advection import * -from .advectiondiffusion import * -from .interaction import * diff --git a/parcels/application_kernels/advectiondiffusion.py b/parcels/application_kernels/advectiondiffusion.py deleted file mode 100644 index 461063ac7..000000000 --- a/parcels/application_kernels/advectiondiffusion.py +++ /dev/null @@ -1,112 +0,0 @@ -"""Collection of pre-built advection-diffusion kernels. - -See `this tutorial <../examples/tutorial_diffusion.ipynb>`__ for a detailed explanation. -""" - -import math - -import parcels - -__all__ = ["AdvectionDiffusionEM", "AdvectionDiffusionM1", "DiffusionUniformKh"] - - -def AdvectionDiffusionM1(particle, fieldset, time): # pragma: no cover - """Kernel for 2D advection-diffusion, solved using the Milstein scheme at first order (M1). - - Assumes that fieldset has fields `Kh_zonal` and `Kh_meridional` - and variable `fieldset.dres`, setting the resolution for the central - difference gradient approximation. This should be (of the order of) the - local gridsize. - - This Milstein scheme is of strong and weak order 1, which is higher than the - Euler-Maruyama scheme. It experiences less spurious diffusivity by - including extra correction terms that are computationally cheap. - - The Wiener increment `dW` is normally distributed with zero - mean and a standard deviation of sqrt(dt). - """ - # Wiener increment with zero mean and std of sqrt(dt) - dWx = parcels.rng.normalvariate(0, math.sqrt(math.fabs(particle.dt))) - dWy = parcels.rng.normalvariate(0, math.sqrt(math.fabs(particle.dt))) - - Kxp1 = fieldset.Kh_zonal[time, particle.depth, particle.lat, particle.lon + fieldset.dres] - Kxm1 = fieldset.Kh_zonal[time, particle.depth, particle.lat, particle.lon - fieldset.dres] - dKdx = (Kxp1 - Kxm1) / (2 * fieldset.dres) - - u, v = fieldset.UV[time, particle.depth, particle.lat, particle.lon] - bx = math.sqrt(2 * fieldset.Kh_zonal[time, particle.depth, particle.lat, particle.lon]) - - Kyp1 = fieldset.Kh_meridional[time, particle.depth, particle.lat + fieldset.dres, particle.lon] - Kym1 = fieldset.Kh_meridional[time, particle.depth, particle.lat - fieldset.dres, particle.lon] - dKdy = (Kyp1 - Kym1) / (2 * fieldset.dres) - - by = math.sqrt(2 * fieldset.Kh_meridional[time, particle.depth, particle.lat, particle.lon]) - - # Particle positions are updated only after evaluating all terms. - particle_dlon += u * particle.dt + 0.5 * dKdx * (dWx**2 + particle.dt) + bx * dWx # noqa - particle_dlat += v * particle.dt + 0.5 * dKdy * (dWy**2 + particle.dt) + by * dWy # noqa - - -def AdvectionDiffusionEM(particle, fieldset, time): # pragma: no cover - """Kernel for 2D advection-diffusion, solved using the Euler-Maruyama scheme (EM). - - Assumes that fieldset has fields `Kh_zonal` and `Kh_meridional` - and variable `fieldset.dres`, setting the resolution for the central - difference gradient approximation. This should be (of the order of) the - local gridsize. - - The Euler-Maruyama scheme is of strong order 0.5 and weak order 1. - - The Wiener increment `dW` is normally distributed with zero - mean and a standard deviation of sqrt(dt). - """ - # Wiener increment with zero mean and std of sqrt(dt) - dWx = parcels.rng.normalvariate(0, math.sqrt(math.fabs(particle.dt))) - dWy = parcels.rng.normalvariate(0, math.sqrt(math.fabs(particle.dt))) - - u, v = fieldset.UV[time, particle.depth, particle.lat, particle.lon] - - Kxp1 = fieldset.Kh_zonal[time, particle.depth, particle.lat, particle.lon + fieldset.dres] - Kxm1 = fieldset.Kh_zonal[time, particle.depth, particle.lat, particle.lon - fieldset.dres] - dKdx = (Kxp1 - Kxm1) / (2 * fieldset.dres) - ax = u + dKdx - bx = math.sqrt(2 * fieldset.Kh_zonal[time, particle.depth, particle.lat, particle.lon]) - - Kyp1 = fieldset.Kh_meridional[time, particle.depth, particle.lat + fieldset.dres, particle.lon] - Kym1 = fieldset.Kh_meridional[time, particle.depth, particle.lat - fieldset.dres, particle.lon] - dKdy = (Kyp1 - Kym1) / (2 * fieldset.dres) - ay = v + dKdy - by = math.sqrt(2 * fieldset.Kh_meridional[time, particle.depth, particle.lat, particle.lon]) - - # Particle positions are updated only after evaluating all terms. - particle_dlon += ax * particle.dt + bx * dWx # noqa - particle_dlat += ay * particle.dt + by * dWy # noqa - - -def DiffusionUniformKh(particle, fieldset, time): # pragma: no cover - """Kernel for simple 2D diffusion where diffusivity (Kh) is assumed uniform. - - Assumes that fieldset has constant fields `Kh_zonal` and `Kh_meridional`. - These can be added via e.g. - `fieldset.add_constant_field("Kh_zonal", kh_zonal, mesh=mesh)` - or - `fieldset.add_constant_field("Kh_meridional", kh_meridional, mesh=mesh)` - where mesh is either 'flat' or 'spherical' - - This kernel assumes diffusivity gradients are zero and is therefore more efficient. - Since the perturbation due to diffusion is in this case isotropic independent, this - kernel contains no advection and can be used in combination with a separate - advection kernel. - - The Wiener increment `dW` is normally distributed with zero - mean and a standard deviation of sqrt(dt). - """ - # Wiener increment with zero mean and std of sqrt(dt) - dWx = parcels.rng.normalvariate(0, math.sqrt(math.fabs(particle.dt))) - dWy = parcels.rng.normalvariate(0, math.sqrt(math.fabs(particle.dt))) - - bx = math.sqrt(2 * fieldset.Kh_zonal[particle]) - by = math.sqrt(2 * fieldset.Kh_meridional[particle]) - - particle_dlon += bx * dWx # noqa - particle_dlat += by * dWy # noqa diff --git a/parcels/compilation/codecompiler.py b/parcels/compilation/codecompiler.py deleted file mode 100644 index 4237c8752..000000000 --- a/parcels/compilation/codecompiler.py +++ /dev/null @@ -1,314 +0,0 @@ -import os -import subprocess -from struct import calcsize - -from parcels._compat import MPI - -_tmp_dir = os.getcwd() - - -class Compiler_parameters: - def __init__(self): - self._compiler = "" - self._cppargs = [] - self._ldargs = [] - self._incdirs = [] - self._libdirs = [] - self._libs = [] - self._dynlib_ext = "" - self._stclib_ext = "" - self._obj_ext = "" - self._exe_ext = "" - - @property - def compiler(self): - return self._compiler - - @property - def cppargs(self): - return self._cppargs - - @property - def ldargs(self): - return self._ldargs - - @property - def incdirs(self): - return self._incdirs - - @property - def libdirs(self): - return self._libdirs - - @property - def libs(self): - return self._libs - - @property - def dynlib_ext(self): - return self._dynlib_ext - - @property - def stclib_ext(self): - return self._stclib_ext - - @property - def obj_ext(self): - return self._obj_ext - - @property - def exe_ext(self): - return self._exe_ext - - -class GNU_parameters(Compiler_parameters): - def __init__(self, cppargs=None, ldargs=None, incdirs=None, libdirs=None, libs=None): - super().__init__() - if cppargs is None: - cppargs = [] - if ldargs is None: - ldargs = [] - if incdirs is None: - incdirs = [] - if libdirs is None: - libdirs = [] - if libs is None: - libs = [] - libs.append("m") - - Iflags = [] - if isinstance(incdirs, list): - for dir in incdirs: - Iflags.append("-I" + dir) - Lflags = [] - if isinstance(libdirs, list): - for dir in libdirs: - Lflags.append("-L" + dir) - lflags = [] - if isinstance(libs, list): - for lib in libs: - lflags.append("-l" + lib) - - cc_env = os.getenv("CC") - mpicc = None - if MPI: - mpicc_env = os.getenv("MPICC") - mpicc = mpicc_env - mpicc = "mpicc" if mpicc is None and os._exists("mpicc") else None - mpicc = "mpiCC" if mpicc is None and os._exists("mpiCC") else None - self._compiler = mpicc if MPI and mpicc is not None else cc_env if cc_env is not None else "gcc" - opt_flags = ["-g", "-O3"] - arch_flag = ["-m64" if calcsize("P") == 8 else "-m32"] - self._cppargs = ["-Wall", "-fPIC", "-std=gnu11"] - self._cppargs += Iflags - self._cppargs += opt_flags + cppargs + arch_flag - self._ldargs = ["-shared"] - self._ldargs += Lflags - self._ldargs += lflags - self._ldargs += ldargs - if len(Lflags) > 0: - self._ldargs += [f"-Wl, -rpath={':'.join(libdirs)}"] - self._ldargs += arch_flag - self._incdirs = incdirs - self._libdirs = libdirs - self._libs = libs - self._dynlib_ext = "so" - self._stclib_ext = "a" - self._obj_ext = "o" - self._exe_ext = "" - - -class Clang_parameters(Compiler_parameters): - def __init__(self, cppargs=None, ldargs=None, incdirs=None, libdirs=None, libs=None): - super().__init__() - if cppargs is None: - cppargs = [] - if ldargs is None: - ldargs = [] - if incdirs is None: - incdirs = [] - if libdirs is None: - libdirs = [] - if libs is None: - libs = [] - self._compiler = "cc" - self._cppargs = cppargs - self._ldargs = ldargs - self._incdirs = incdirs - self._libdirs = libdirs - self._libs = libs - self._dynlib_ext = "dynlib" - self._stclib_ext = "a" - self._obj_ext = "o" - self._exe_ext = "exe" - - -class MinGW_parameters(Compiler_parameters): - def __init__(self, cppargs=None, ldargs=None, incdirs=None, libdirs=None, libs=None): - super().__init__() - if cppargs is None: - cppargs = [] - if ldargs is None: - ldargs = [] - if incdirs is None: - incdirs = [] - if libdirs is None: - libdirs = [] - if libs is None: - libs = [] - self._compiler = "gcc" - self._cppargs = cppargs - self._ldargs = ldargs - self._incdirs = incdirs - self._libdirs = libdirs - self._libs = libs - self._dynlib_ext = "so" - self._stclib_ext = "a" - self._obj_ext = "o" - self._exe_ext = "exe" - - -class VS_parameters(Compiler_parameters): - def __init__(self, cppargs=None, ldargs=None, incdirs=None, libdirs=None, libs=None): - super().__init__() - if cppargs is None: - cppargs = [] - if ldargs is None: - ldargs = [] - if incdirs is None: - incdirs = [] - if libdirs is None: - libdirs = [] - if libs is None: - libs = [] - self._compiler = "cl" - self._cppargs = cppargs - self._ldargs = ldargs - self._incdirs = incdirs - self._libdirs = libdirs - self._libs = libs - self._dynlib_ext = "dll" - self._stclib_ext = "lib" - self._obj_ext = "obj" - self._exe_ext = "exe" - - -class CCompiler: - """A compiler object for creating and loading shared libraries. - - Parameters - ---------- - cc : - C compiler executable (uses environment variable ``CC`` if not provided). - cppargs : - A list of arguments to the C compiler (optional). - ldargs : - A list of arguments to the linker (optional). - """ - - def __init__(self, cc=None, cppargs=None, ldargs=None, incdirs=None, libdirs=None, libs=None, tmp_dir=None): - if tmp_dir is None: - tmp_dir = _tmp_dir - if cppargs is None: - cppargs = [] - if ldargs is None: - ldargs = [] - - self._cc = os.getenv("CC") if cc is None else cc - self._cppargs = cppargs - self._ldargs = ldargs - self._dynlib_ext = "" - self._stclib_ext = "" - self._obj_ext = "" - self._exe_ext = "" - self._tmp_dir = tmp_dir - self._incdirs = incdirs - self._libdirs = libdirs # only possible for already-compiled, external libraries - self._libs = libs # only possible for already-compiled, external libraries - - def compile(self, src, obj, log): - pass - - def _create_compile_process_(self, cmd, src, log): - with open(log, "w") as logfile: - try: - subprocess.check_call(cmd, stdout=logfile, stderr=logfile) - except OSError: - raise RuntimeError(f"OSError during compilation. Please check if compiler exists: {self._cc}") - except subprocess.CalledProcessError: - with open(log) as logfile2: - raise RuntimeError( - f"Error during compilation:\n" - f"Compilation command: {cmd}\n" - f"Source/Destination file: {src}\n" - f"Log file: {logfile.name}\n" - f"Log output: {logfile2.read()}\n" - f"\n" - f"If you are on macOS, it might help to type 'export CC=gcc'" - ) - return True - - -class CCompiler_SS(CCompiler): - """Single-stage C-compiler; used for a SINGLE source file.""" - - def __init__(self, cc=None, cppargs=None, ldargs=None, incdirs=None, libdirs=None, libs=None, tmp_dir=None): - super().__init__( - cc=cc, cppargs=cppargs, ldargs=ldargs, incdirs=incdirs, libdirs=libdirs, libs=libs, tmp_dir=tmp_dir - ) - - def __str__(self): - output = "[CCompiler_SS]: " - output += f"('cc': {self._cc}), " - output += f"('cppargs': {self._cppargs}), " - output += f"('ldargs': {self._ldargs}), " - output += f"('incdirs': {self._incdirs}), " - output += f"('libdirs': {self._libdirs}), " - output += f"('libs': {self._libs}), " - output += f"('tmp_dir': {self._tmp_dir}), " - return output - - def compile(self, src, obj, log): - cc = [self._cc] + self._cppargs + ["-o", obj, src] + self._ldargs - with open(log, "w") as logfile: - logfile.write(f"Compiling: {cc}\n") - self._create_compile_process_(cc, src, log) - - -class GNUCompiler_SS(CCompiler_SS): - """A compiler object for the GNU Linux toolchain. - - Parameters - ---------- - cppargs : - A list of arguments to pass to the C compiler - (optional). - ldargs : - A list of arguments to pass to the linker (optional). - """ - - def __init__(self, cppargs=None, ldargs=None, incdirs=None, libdirs=None, libs=None, tmp_dir=None): - c_params = GNU_parameters(cppargs, ldargs, incdirs, libdirs, libs) - super().__init__( - c_params.compiler, - cppargs=c_params.cppargs, - ldargs=c_params.ldargs, - incdirs=c_params.incdirs, - libdirs=c_params.libdirs, - libs=c_params.libs, - tmp_dir=tmp_dir, - ) - self._dynlib_ext = c_params.dynlib_ext - self._stclib_ext = c_params.stclib_ext - self._obj_ext = c_params.obj_ext - self._exe_ext = c_params.exe_ext - - def compile(self, src, obj, log): - lib_pathfile = os.path.basename(obj) - lib_pathdir = os.path.dirname(obj) - obj = os.path.join(lib_pathdir, lib_pathfile) - - super().compile(src, obj, log) - - -GNUCompiler = GNUCompiler_SS diff --git a/parcels/compilation/codegenerator.py b/parcels/compilation/codegenerator.py deleted file mode 100644 index 9119eb402..000000000 --- a/parcels/compilation/codegenerator.py +++ /dev/null @@ -1,1067 +0,0 @@ -import ast -import collections -import math -import random -import warnings -from copy import copy - -import cgen as c - -from parcels.field import Field, NestedField, VectorField -from parcels.grid import Grid -from parcels.particle import JITParticle -from parcels.tools.statuscodes import StatusCode -from parcels.tools.warnings import KernelWarning - - -class IntrinsicNode(ast.AST): - def __init__(self, obj, ccode): - self.obj = obj - self.ccode = ccode - - -class FieldSetNode(IntrinsicNode): - def __getattr__(self, attr): - if isinstance(getattr(self.obj, attr), Field): - return FieldNode(getattr(self.obj, attr), ccode=f"{self.ccode}->{attr}") - elif isinstance(getattr(self.obj, attr), NestedField): - if isinstance(getattr(self.obj, attr)[0], VectorField): - return NestedVectorFieldNode(getattr(self.obj, attr), ccode=f"{self.ccode}->{attr}") - else: - return NestedFieldNode(getattr(self.obj, attr), ccode=f"{self.ccode}->{attr}") - elif isinstance(getattr(self.obj, attr), VectorField): - return VectorFieldNode(getattr(self.obj, attr), ccode=f"{self.ccode}->{attr}") - else: - return ConstNode(getattr(self.obj, attr), ccode=f"{attr}") - - -class FieldNode(IntrinsicNode): - def __getattr__(self, attr): - if isinstance(getattr(self.obj, attr), Grid): - return GridNode(getattr(self.obj, attr), ccode=f"{self.ccode}->{attr}") - elif attr == "eval": - return FieldEvalCallNode(self) - else: - raise NotImplementedError("Access to Field attributes are not (yet) implemented in JIT mode") - - -class FieldEvalCallNode(IntrinsicNode): - def __init__(self, field): - self.field = field - self.obj = field.obj - self.ccode = "" - - -class FieldEvalNode(IntrinsicNode): - def __init__(self, field, args, var, convert=True): - self.field = field - self.args = args - self.var = var # the variable in which the interpolated field is written - self.convert = convert # whether to convert the result (like field.applyConversion) - - -class VectorFieldNode(IntrinsicNode): - def __getattr__(self, attr): - if attr == "eval": - return VectorFieldEvalCallNode(self) - else: - raise NotImplementedError("Access to VectorField attributes are not (yet) implemented in JIT mode") - - def __getitem__(self, attr): - return VectorFieldEvalNode(self.obj, attr) - - -class VectorFieldEvalCallNode(IntrinsicNode): - def __init__(self, field): - self.field = field - self.obj = field.obj - self.ccode = "" - - -class VectorFieldEvalNode(IntrinsicNode): - def __init__(self, field, args, var, var2, var3, var4, convert=True): - self.field = field - self.args = args - self.var = var # the variable in which the interpolated field is written - self.var2 = var2 # second variable for UV interpolation - self.var3 = var3 # third variable for UVW interpolation - self.var4 = var4 # extra variable for sigma-scaling for croco - self.convert = convert # whether to convert the result (like field.applyConversion) - - -class NestedFieldNode(IntrinsicNode): - def __getitem__(self, attr): - return NestedFieldEvalNode(self.obj, attr) - - -class NestedFieldEvalNode(IntrinsicNode): - def __init__(self, fields, args, var): - self.fields = fields - self.args = args - self.var = var # the variable in which the interpolated field is written - - -class NestedVectorFieldNode(IntrinsicNode): - def __getitem__(self, attr): - return NestedVectorFieldEvalNode(self.obj, attr) - - -class NestedVectorFieldEvalNode(IntrinsicNode): - def __init__(self, fields, args, var, var2, var3, var4): - self.fields = fields - self.args = args - self.var = var # the variable in which the interpolated field is written - self.var2 = var2 # second variable for UV interpolation - self.var3 = var3 # third variable for UVW interpolation - self.var4 = var4 # extra variable for sigma-scaling for croco - - -class GridNode(IntrinsicNode): - def __getattr__(self, attr): - raise NotImplementedError("Access to Grids is not (yet) implemented in JIT mode") - - -class ConstNode(IntrinsicNode): - def __getitem__(self, attr): - return attr - - -class MathNode(IntrinsicNode): - symbol_map = {"pi": "M_PI", "e": "M_E", "nan": "NAN"} - - def __getattr__(self, attr): - if hasattr(math, attr): - if attr in self.symbol_map: - attr = self.symbol_map[attr] - return IntrinsicNode(None, ccode=attr) - else: - raise AttributeError(f"Unknown math function encountered: {attr}") - - -class RandomNode(IntrinsicNode): - symbol_map = { - "random": "parcels_random", - "uniform": "parcels_uniform", - "randint": "parcels_randint", - "normalvariate": "parcels_normalvariate", - "expovariate": "parcels_expovariate", - "vonmisesvariate": "parcels_vonmisesvariate", - "seed": "parcels_seed", - } - - def __getattr__(self, attr): - if hasattr(random, attr): - if attr in self.symbol_map: - attr = self.symbol_map[attr] - return IntrinsicNode(None, ccode=attr) - else: - raise AttributeError(f"Unknown random function encountered: {attr}") - - -class StatusCodeNode(IntrinsicNode): - def __getattr__(self, attr): - statuscodes = [c for c in vars(StatusCode) if not c.startswith("_")] - if attr in statuscodes: - return IntrinsicNode(None, ccode=attr.upper()) - else: - raise AttributeError(f"Unknown status code encountered: {attr}") - - -class PrintNode(IntrinsicNode): - def __init__(self): - self.obj = "print" - - -class ParticleAttributeNode(IntrinsicNode): - def __init__(self, obj, attr): - self.ccode = f"{obj.ccode}->{attr}[pnum]" - self.attr = attr - - -class ParticleXiYiZiTiAttributeNode(IntrinsicNode): - def __init__(self, obj, attr): - warnings.warn( - f"Be careful when sampling particle.{attr}, as this is updated in the kernel loop. " - "Best to place the sampling statement before advection.", - KernelWarning, - stacklevel=2, - ) - self.obj = obj.ccode - self.attr = attr - - -class ParticleNode(IntrinsicNode): - def __init__(self, obj): - super().__init__(obj, ccode="particles") - - def __getattr__(self, attr): - if attr in ["xi", "yi", "zi", "ti"]: - return ParticleXiYiZiTiAttributeNode(self, attr) - if attr in [v.name for v in self.obj.variables]: - return ParticleAttributeNode(self, attr) - elif attr in ["delete"]: - return ParticleAttributeNode(self, "state") - else: - raise AttributeError( - f"Particle type {self.obj.name} does not define attribute '{attr}. " - f"Please add '{attr}' as a Variable in {self.obj.name}." - ) - - -class IntrinsicTransformer(ast.NodeTransformer): - """AST transformer that catches any mention of intrinsic variable - names, such as 'particle' or 'fieldset', inserts placeholder objects - and propagates attribute access. - """ - - def __init__(self, fieldset=None, ptype=JITParticle): - self.fieldset = fieldset - self.ptype = ptype - - # Counter and variable names for temporaries - self._tmp_counter = 0 - self.tmp_vars = [] - # A stack of additional statements to be inserted - self.stmt_stack = [] - - def get_tmp(self): - """Create a new temporary variable name.""" - tmp = f"parcels_tmpvar{self._tmp_counter:d}" - self._tmp_counter += 1 - self.tmp_vars += [tmp] - return tmp - - def visit_Name(self, node): - """Inject IntrinsicNode objects into the tree according to keyword.""" - if node.id == "fieldset" and self.fieldset is not None: - node = FieldSetNode(self.fieldset, ccode="fset") - elif node.id == "particle": - node = ParticleNode(self.ptype) - elif node.id in ["StatusCode"]: - node = StatusCodeNode(math, ccode="") - elif node.id == "math": - node = MathNode(math, ccode="") - elif node.id in ["ParcelsRandom", "rng"]: - node = RandomNode(math, ccode="") - elif node.id == "print": - node = PrintNode() - elif (node.id == "pnum") or ("parcels_tmpvar" in node.id): - raise NotImplementedError(f"Custom Kernels cannot contain string {node.id}; please change your kernel") - elif node.id == "abs": - raise NotImplementedError("abs() does not work in JIT Kernels. Use math.fabs() instead") - return node - - def visit_Attribute(self, node): - node.value = self.visit(node.value) - if isinstance(node.value, IntrinsicNode): - return getattr(node.value, node.attr) - else: - if node.value.id in ["np", "numpy"]: - raise NotImplementedError( - "Cannot convert numpy functions in kernels to C-code.\n" - "Either use functions from the math library or run Parcels in Scipy mode.\n" - "For more information, see https://docs.oceanparcels.org/en/latest/examples/tutorial_parcels_structure.html#3.-Kernels" - ) - elif node.value.id in ["random"]: - raise NotImplementedError( - "Cannot convert random functions in kernels to C-code.\n" - "Use `import parcels.rng as ParcelsRandom` and then ParcelsRandom.random(), ParcelsRandom.uniform() etc.\n" - "For more information, see https://docs.oceanparcels.org/en/latest/examples/tutorial_parcels_structure.html#3.-Kernels" - ) - else: - raise NotImplementedError(f"Cannot convert '{node.value.id}' used in kernel to C-code") - - def visit_Subscript(self, node): - node.value = self.visit(node.value) - node.slice = self.visit(node.slice) - - # If we encounter field evaluation we replace it with a - # temporary variable and put the evaluation call on the stack. - if isinstance(node.value, FieldNode): - tmp = self.get_tmp() - # Insert placeholder node for field eval ... - self.stmt_stack += [FieldEvalNode(node.value, node.slice, tmp)] - # .. and return the name of the temporary that will be populated - return ast.Name(id=tmp) - elif isinstance(node.value, VectorFieldNode): - tmp = self.get_tmp() - tmp2 = self.get_tmp() - tmp3 = self.get_tmp() if "3D" in node.value.obj.vector_type else None - tmp4 = self.get_tmp() if "3DSigma" in node.value.obj.vector_type else None - # Insert placeholder node for field eval ... - self.stmt_stack += [VectorFieldEvalNode(node.value, node.slice, tmp, tmp2, tmp3, tmp4)] - # .. and return the name of the temporary that will be populated - if tmp3: - return ast.Tuple([ast.Name(id=tmp), ast.Name(id=tmp2), ast.Name(id=tmp3)], ast.Load()) - else: - return ast.Tuple([ast.Name(id=tmp), ast.Name(id=tmp2)], ast.Load()) - elif isinstance(node.value, NestedFieldNode): - tmp = self.get_tmp() - self.stmt_stack += [NestedFieldEvalNode(node.value, node.slice, tmp)] - return ast.Name(id=tmp) - elif isinstance(node.value, NestedVectorFieldNode): - tmp = self.get_tmp() - tmp2 = self.get_tmp() - tmp3 = self.get_tmp() if "3D" in list.__getitem__(node.value.obj, 0).vector_type else None - tmp4 = self.get_tmp() if "3DSigma" in list.__getitem__(node.value.obj, 0).vector_type else None - self.stmt_stack += [NestedVectorFieldEvalNode(node.value, node.slice, tmp, tmp2, tmp3, tmp4)] - if tmp3: - return ast.Tuple([ast.Name(id=tmp), ast.Name(id=tmp2), ast.Name(id=tmp3)], ast.Load()) - else: - return ast.Tuple([ast.Name(id=tmp), ast.Name(id=tmp2)], ast.Load()) - else: - return node - - def visit_AugAssign(self, node): - node.target = self.visit(node.target) - if isinstance(node.target, ParticleAttributeNode) and node.target.attr in ["lon", "lat", "depth", "time"]: - warnings.warn( - "Don't change the location of a particle directly in a Kernel. Use particle_dlon, particle_dlat, etc.", - KernelWarning, - stacklevel=2, - ) - node.op = self.visit(node.op) - node.value = self.visit(node.value) - stmts = [node] - - # Inject statements from the stack - if len(self.stmt_stack) > 0: - stmts = self.stmt_stack + stmts - self.stmt_stack = [] - return stmts - - def visit_Assign(self, node): - node.targets = [self.visit(t) for t in node.targets] - node.value = self.visit(node.value) - if isinstance(node.value, ConstNode) and len(node.targets) > 0 and isinstance(node.targets[0], ast.Name): - if node.targets[0].id == node.value.ccode: - raise NotImplementedError( - f"Assignment of fieldset.{node.value.ccode} to a local variable {node.targets[0].id} with same name in kernel. This is not allowed." - ) - stmts = [node] - - # Inject statements from the stack - if len(self.stmt_stack) > 0: - stmts = self.stmt_stack + stmts - self.stmt_stack = [] - return stmts - - def visit_Call(self, node): - node.func = self.visit(node.func) - node.args = [self.visit(a) for a in node.args] - node.keywords = {kw.arg: self.visit(kw.value) for kw in node.keywords} - - if isinstance(node.func, ParticleAttributeNode) and node.func.attr == "state": - node = IntrinsicNode(node, "particles->state[pnum] = DELETE") - - elif isinstance(node.func, FieldEvalCallNode): - # get a temporary value to assign result to - tmp = self.get_tmp() - # whether to convert - convert = True - if "applyConversion" in node.keywords: - k = node.keywords["applyConversion"] - if isinstance(k, ast.Constant): - convert = k.value - - # convert args to Index(Tuple(*args)) - args = ast.Index(value=ast.Tuple(node.args, ast.Load())) - - self.stmt_stack += [FieldEvalNode(node.func.field, args, tmp, convert)] - return ast.Name(id=tmp) - - elif isinstance(node.func, VectorFieldEvalCallNode): - # get a temporary value to assign result to - tmp1 = self.get_tmp() - tmp2 = self.get_tmp() - tmp3 = self.get_tmp() if "3D" in node.func.field.obj.vector_type else None - tmp4 = self.get_tmp() if "3DSigma" in node.func.field.obj.vector_type else None - # whether to convert - convert = True - if "applyConversion" in node.keywords: - k = node.keywords["applyConversion"] - if isinstance(k, ast.Constant): - convert = k.value - - # convert args to Index(Tuple(*args)) - args = ast.Index(value=ast.Tuple(node.args, ast.Load())) - - self.stmt_stack += [VectorFieldEvalNode(node.func.field, args, tmp1, tmp2, tmp3, tmp4, convert)] - if tmp3: - return ast.Tuple([ast.Name(id=tmp1), ast.Name(id=tmp2), ast.Name(id=tmp3)], ast.Load()) - else: - return ast.Tuple([ast.Name(id=tmp1), ast.Name(id=tmp2)], ast.Load()) - - return node - - -class TupleSplitter(ast.NodeTransformer): - """AST transformer that detects and splits Pythonic tuple assignments into multiple statements for conversion to C.""" - - def visit_Assign(self, node): - if isinstance(node.targets[0], ast.Tuple) and isinstance(node.value, ast.Tuple): - t_elts = node.targets[0].elts - v_elts = node.value.elts - if len(t_elts) != len(v_elts): - raise AttributeError("Tuple lengths in assignment do not agree") - node = [ast.Assign() for _ in t_elts] - for n, t, v in zip(node, t_elts, v_elts, strict=True): - n.targets = [t] - n.value = v - return node - - -class KernelGenerator(ast.NodeVisitor): - """Code generator class that translates simple Python kernel functions into C functions. - - Works by populating and accessing the `ccode` attribute on nodes in the Python AST. - """ - - # Intrinsic variables that appear as function arguments - kernel_vars = ["particle", "fieldset", "time", "output_time", "tol"] - array_vars: list[str] = [] - - def __init__(self, fieldset=None, ptype=JITParticle): - self.fieldset = fieldset - self.ptype = ptype - self.field_args = collections.OrderedDict() - self.vector_field_args = collections.OrderedDict() - self.const_args = collections.OrderedDict() - if isinstance(fieldset.U, Field) and fieldset.U.gridindexingtype == "croco" and hasattr(fieldset, "H"): - self.field_args["H"] = fieldset.H # CROCO requires H field - self.field_args["Zeta"] = fieldset.Zeta # CROCO requires Zeta field - self.field_args["Cs_w"] = fieldset.Cs_w # CROCO requires CS_w field - self.const_args["hc"] = fieldset.hc # CROCO requires hc constant - - def generate(self, py_ast, funcvars: list[str]): - # Replace occurrences of intrinsic objects in Python AST - transformer = IntrinsicTransformer(self.fieldset, self.ptype) - py_ast = transformer.visit(py_ast) - - # Untangle Pythonic tuple-assignment statements - py_ast = TupleSplitter().visit(py_ast) - - # Generate C-code for all nodes in the Python AST - self.visit(py_ast) - self.ccode = py_ast.ccode - - # Insert variable declarations for non-intrinsic variables - # Make sure that repeated variables are not declared more than - # once. If variables occur in multiple Kernels, give a warning - used_vars: list[str] = [] - funcvars_copy = copy(funcvars) # editing a list while looping over it is dangerous - for kvar in funcvars: - if kvar in used_vars + ["particle_dlon", "particle_dlat", "particle_ddepth"]: - if kvar not in ["particle", "fieldset", "time", "particle_dlon", "particle_dlat", "particle_ddepth"]: - warnings.warn( - kvar + " declared in multiple Kernels", - KernelWarning, - stacklevel=2, - ) - funcvars_copy.remove(kvar) - else: - used_vars.append(kvar) - funcvars = funcvars_copy - for kvar in self.kernel_vars + self.array_vars: - if kvar in funcvars: - funcvars.remove(kvar) - self.ccode.body.insert(0, c.Statement("int parcels_interp_state = 0")) - if len(funcvars) > 0: - for f in funcvars: - self.ccode.body.insert(0, c.Statement(f"type_coord {f} = 0")) - if len(transformer.tmp_vars) > 0: - for f in transformer.tmp_vars: - self.ccode.body.insert(0, c.Statement(f"float {f} = 0")) - - return self.ccode - - @staticmethod - def _check_FieldSamplingArguments(ccode): - if ccode == "particles": - args = ("time", "particles->depth[pnum]", "particles->lat[pnum]", "particles->lon[pnum]") - elif ccode[-1] == "particles": - args = ccode[:-1] - else: - args = ccode - return args - - def visit_FunctionDef(self, node): - # Generate "ccode" attribute by traversing the Python AST - for stmt in node.body: - self.visit(stmt) - - # Create function declaration and argument list - decl = c.Static(c.DeclSpecifier(c.Value("StatusCode", node.name), spec="inline")) - args = [ - c.Pointer(c.Value(self.ptype.name + "p", "particles")), - c.Value("int", "pnum"), - c.Value("double", "time"), - ] - for field in self.field_args.values(): - args += [c.Pointer(c.Value("CField", f"{field.ccode_name}"))] - for field in self.vector_field_args.values(): - for fcomponent in ["U", "V", "W"]: - try: - f = getattr(field, fcomponent) - if f.ccode_name not in self.field_args: - args += [c.Pointer(c.Value("CField", f"{f.ccode_name}"))] - self.field_args[f.ccode_name] = f - except: - pass # field.W does not always exist - for const, _ in self.const_args.items(): - args += [c.Value("float", const)] - - # Create function body as C-code object - body = [] - for coord in ["lon", "lat", "depth"]: - body += [c.Statement(f"type_coord particle_d{coord} = 0")] - body += [c.Statement(f"particles->{coord}[pnum] = particles->{coord}_nextloop[pnum]")] - body += [c.Statement("particles->time[pnum] = particles->time_nextloop[pnum]")] - - body += [stmt.ccode for stmt in node.body] - - for coord in ["lon", "lat", "depth"]: - body += [c.Statement(f"particles->{coord}_nextloop[pnum] = particles->{coord}[pnum] + particle_d{coord}")] - body += [c.Statement("particles->time_nextloop[pnum] = particles->time[pnum] + particles->dt[pnum]")] - body += [c.Statement("return particles->state[pnum]")] - node.ccode = c.FunctionBody(c.FunctionDeclaration(decl, args), c.Block(body)) - - def visit_Call(self, node): - """Generate C code for simple C-style function calls. - - Please note that starred and keyword arguments are currently not - supported. - """ - pointer_args = False - parcels_customed_Cfunc = False - if isinstance(node.func, PrintNode): - # Write our own Print parser because Python3-AST does not seem to have one - if isinstance(node.args[0], ast.Str): - node.ccode = str(c.Statement(f'printf("{node.args[0].s}\\n")')) - elif isinstance(node.args[0], ast.Name): - node.ccode = str(c.Statement(f'printf("%f\\n", {node.args[0].id})')) - elif isinstance(node.args[0], ast.BinOp): - if hasattr(node.args[0].right, "ccode"): - args = node.args[0].right.ccode - elif hasattr(node.args[0].right, "id"): - args = node.args[0].right.id - elif hasattr(node.args[0].right, "elts"): - args = [] - for a in node.args[0].right.elts: - if hasattr(a, "ccode"): - args.append(a.ccode) - elif hasattr(a, "id"): - args.append(a.id) - else: - args = [] - s = f'printf("{node.args[0].left.s}\\n"' - if isinstance(args, str): - s = s + f", {args})" - else: - for arg in args: - s = s + (f", {arg}") - s = s + ")" - node.ccode = str(c.Statement(s)) - else: - raise RuntimeError("This print statement is not supported") - else: - for a in node.args: - self.visit(a) - if a.ccode == "parcels_customed_Cfunc_pointer_args": - pointer_args = True - parcels_customed_Cfunc = True - elif a.ccode == "parcels_customed_Cfunc": - parcels_customed_Cfunc = True - elif isinstance(a, FieldNode) or isinstance(a, VectorFieldNode): - a.ccode = a.obj.ccode_name - elif isinstance(a, ParticleNode): - continue - elif pointer_args: - a.ccode = f"&{a.ccode}" - ccode_args = ", ".join([a.ccode for a in node.args[pointer_args:]]) - try: - if isinstance(node.func, str): - node.ccode = node.func + "(" + ccode_args + ")" - else: - self.visit(node.func) - rhs = f"{node.func.ccode}({ccode_args})" - if parcels_customed_Cfunc: - node.ccode = str( - c.Block( - [ - c.Assign("parcels_interp_state", rhs), - c.Assign( - "particles->state[pnum]", "max(particles->state[pnum], parcels_interp_state)" - ), - c.Statement("CHECKSTATUS_KERNELLOOP(parcels_interp_state)"), - ] - ) - ) - else: - node.ccode = rhs - except: - raise RuntimeError( - "Error in converting Kernel to C. See https://docs.oceanparcels.org/en/latest/examples/tutorial_parcels_structure.html#3.-Kernel-execution for hints and tips" - ) - - def visit_Name(self, node): - """Catches any mention of intrinsic variable names such as 'particle' or 'fieldset' and inserts our placeholder objects.""" - if node.id == "True": - node.id = "1" - if node.id == "False": - node.id = "0" - node.ccode = node.id - - def visit_NameConstant(self, node): - if node.value is True: - node.ccode = "1" - if node.value is False: - node.ccode = "0" - - def visit_Expr(self, node): - self.visit(node.value) - node.ccode = c.Statement(node.value.ccode) - - def visit_Assign(self, node): - self.visit(node.targets[0]) - self.visit(node.value) - if isinstance(node.value, ast.List): - # Detect in-place initialisation of multi-dimensional arrays - tmp_node = node.value - decl = c.Value("float", node.targets[0].id) - while isinstance(tmp_node, ast.List): - decl = c.ArrayOf(decl, len(tmp_node.elts)) - if isinstance(tmp_node.elts[0], ast.List): - # Check type and dimension are the same - if not all(isinstance(e, ast.List) for e in tmp_node.elts): - raise TypeError("Non-list element discovered in array declaration") - if not all(len(e.elts) == len(tmp_node.elts[0].elts) for e in tmp_node.elts): - raise TypeError("Irregular array length not allowed in array declaration") - tmp_node = tmp_node.elts[0] - node.ccode = c.Initializer(decl, node.value.ccode) - self.array_vars += [node.targets[0].id] - elif isinstance(node.value, ParticleXiYiZiTiAttributeNode): - raise RuntimeError( - f"Add index of the grid when using particle.{node.value.attr} (e.g. particle.{node.value.attr}[0])." - ) - else: - node.ccode = c.Assign(node.targets[0].ccode, node.value.ccode) - - def visit_AugAssign(self, node): - self.visit(node.target) - self.visit(node.op) - self.visit(node.value) - node.ccode = c.Statement(f"{node.target.ccode} {node.op.ccode}= {node.value.ccode}") - - def visit_If(self, node): - self.visit(node.test) - for b in node.body: - self.visit(b) - for b in node.orelse: - self.visit(b) - # field evals are replaced by a tmp variable is added to the stack. - # Here it means field evals passes from node.test to node.body. We take it out manually - fieldInTestCount = node.test.ccode.count("parcels_tmpvar") - body0 = c.Block([b.ccode for b in node.body[:fieldInTestCount]]) - body = c.Block([b.ccode for b in node.body[fieldInTestCount:]]) - orelse = c.Block([b.ccode for b in node.orelse]) if len(node.orelse) > 0 else None - ifcode = c.If(node.test.ccode, body, orelse) - node.ccode = c.Block([body0, ifcode]) - - def visit_Compare(self, node): - self.visit(node.left) - assert len(node.ops) == 1 - self.visit(node.ops[0]) - assert len(node.comparators) == 1 - self.visit(node.comparators[0]) - node.ccode = f"{node.left.ccode} {node.ops[0].ccode} {node.comparators[0].ccode}" - - def visit_Index(self, node): - self.visit(node.value) - node.ccode = node.value.ccode - - def visit_Tuple(self, node): - for e in node.elts: - self.visit(e) - node.ccode = tuple([e.ccode for e in node.elts]) - - def visit_List(self, node): - for e in node.elts: - self.visit(e) - node.ccode = "{" + ", ".join([e.ccode for e in node.elts]) + "}" - - def visit_Subscript(self, node): - self.visit(node.value) - self.visit(node.slice) - if isinstance(node.value, FieldNode) or isinstance(node.value, VectorFieldNode): - node.ccode = node.value.__getitem__(node.slice.ccode).ccode - elif isinstance(node.value, ParticleXiYiZiTiAttributeNode): - ngrid = str(self.fieldset.gridset.size if self.fieldset is not None else 1) - node.ccode = f"{node.value.obj}->{node.value.attr}[pnum*{ngrid}+{node.slice.ccode}]" - elif isinstance(node.value, IntrinsicNode): - raise NotImplementedError(f"Subscript not implemented for object type {type(node.value).__name__}") - else: - node.ccode = f"{node.value.ccode}[{node.slice.ccode}]" - - def visit_UnaryOp(self, node): - self.visit(node.op) - self.visit(node.operand) - node.ccode = f"{node.op.ccode}({node.operand.ccode})" - - def visit_BinOp(self, node): - self.visit(node.left) - self.visit(node.op) - self.visit(node.right) - if isinstance(node.op, ast.BitXor): - raise RuntimeError( - "JIT kernels do not support the '^' operator.\n" - "Did you intend to use the exponential/power operator? In that case, please use '**'" - ) - elif node.op.ccode == "pow": # catching '**' pow statements - node.ccode = f"pow({node.left.ccode}, {node.right.ccode})" - else: - node.ccode = f"({node.left.ccode} {node.op.ccode} {node.right.ccode})" - node.s_print = True - - def visit_Add(self, node): - node.ccode = "+" - - def visit_UAdd(self, node): - node.ccode = "+" - - def visit_Sub(self, node): - node.ccode = "-" - - def visit_USub(self, node): - node.ccode = "-" - - def visit_Mult(self, node): - node.ccode = "*" - - def visit_Div(self, node): - node.ccode = "/" - - def visit_Mod(self, node): - node.ccode = "%" - - def visit_Pow(self, node): - node.ccode = "pow" - - def visit_BoolOp(self, node): - self.visit(node.op) - for v in node.values: - self.visit(v) - op_str = f" {node.op.ccode} " - node.ccode = op_str.join([v.ccode for v in node.values]) - - def visit_Eq(self, node): - node.ccode = "==" - - def visit_NotEq(self, node): - node.ccode = "!=" - - def visit_Lt(self, node): - node.ccode = "<" - - def visit_LtE(self, node): - node.ccode = "<=" - - def visit_Gt(self, node): - node.ccode = ">" - - def visit_GtE(self, node): - node.ccode = ">=" - - def visit_And(self, node): - node.ccode = "&&" - - def visit_Or(self, node): - node.ccode = "||" - - def visit_Not(self, node): - node.ccode = "!" - - def visit_While(self, node): - self.visit(node.test) - for b in node.body: - self.visit(b) - if len(node.orelse) > 0: - raise RuntimeError("Else clause in while clauses cannot be translated to C") - body = c.Block([b.ccode for b in node.body]) - node.ccode = c.DoWhile(node.test.ccode, body) - - def visit_For(self, node): - raise RuntimeError("For loops cannot be translated to C") - - def visit_Break(self, node): - node.ccode = c.Statement("break") - - def visit_Pass(self, node): - node.ccode = c.Statement("") - - def visit_FieldNode(self, node): - """Record intrinsic fields used in kernel.""" - self.field_args[node.obj.ccode_name] = node.obj - - def visit_NestedFieldNode(self, node): - """Record intrinsic fields used in kernel.""" - for fld in node.obj: - self.field_args[fld.ccode_name] = fld - - def visit_VectorFieldNode(self, node): - """Record intrinsic fields used in kernel.""" - self.vector_field_args[node.obj.ccode_name] = node.obj - - def visit_NestedVectorFieldNode(self, node): - """Record intrinsic fields used in kernel.""" - for fld in node.obj: - self.vector_field_args[fld.ccode_name] = fld - - def visit_ConstNode(self, node): - self.const_args[node.ccode] = node.obj - - def visit_Return(self, node): - self.visit(node.value) - node.ccode = c.Statement(f"return {node.value.ccode}") - - def visit_FieldEvalNode(self, node): - self.visit(node.field) - self.visit(node.args) - args = self._check_FieldSamplingArguments(node.args.ccode) - if "croco" in node.field.obj.gridindexingtype and node.field.obj.name != "H" and node.field.obj.name != "Zeta": - # Get Cs_w values directly from fieldset (since they are 1D in vertical only) - Cs_w = [float(self.fieldset.Cs_w.data[0][zi][0][0]) for zi in range(self.fieldset.Cs_w.data.shape[1])] - statements_croco = [ - c.Statement(f"float cs_w[] = {*Cs_w, }".replace("(", "{").replace(")", "}")), - c.Statement( - f"{node.var} = croco_from_z_to_sigma(time, {args[1]}, {args[2]}, {args[3]}, U, H, Zeta, &particles->ti[pnum*ngrid], &particles->zi[pnum*ngrid], &particles->yi[pnum*ngrid], &particles->xi[pnum*ngrid], hc, &cs_w)" - ), - ] - args = (args[0], node.var, args[2], args[3]) - else: - statements_croco = [] - ccode_eval = node.field.obj._ccode_eval(node.var, *args) - stmts = [ - c.Assign("parcels_interp_state", ccode_eval), - c.Assign("particles->state[pnum]", "max(particles->state[pnum], parcels_interp_state)"), - ] - - if node.convert: - ccode_conv = node.field.obj._ccode_convert(*args) - conv_stat = c.Statement(f"{node.var} *= {ccode_conv}") - stmts += [conv_stat] - - node.ccode = c.Block(statements_croco + stmts + [c.Statement("CHECKSTATUS_KERNELLOOP(parcels_interp_state)")]) - - def visit_VectorFieldEvalNode(self, node): - self.visit(node.field) - self.visit(node.args) - args = self._check_FieldSamplingArguments(node.args.ccode) - if "3DSigma" in node.field.obj.vector_type: - # Get Cs_w values directly from fieldset (since they are 1D in vertical only) - Cs_w = [float(self.fieldset.Cs_w.data[0][zi][0][0]) for zi in range(self.fieldset.Cs_w.data.shape[1])] - statements_croco = [ - c.Statement(f"float cs_w[] = {*Cs_w, }".replace("(", "{").replace(")", "}")), - c.Statement( - f"{node.var4} = croco_from_z_to_sigma(time, {args[1]}, {args[2]}, {args[3]}, U, H, Zeta, &particles->ti[pnum*ngrid], &particles->zi[pnum*ngrid], &particles->yi[pnum*ngrid], &particles->xi[pnum*ngrid], hc, &cs_w)" - ), - ] - args = (args[0], node.var4, args[2], args[3]) - else: - statements_croco = [] - ccode_eval = node.field.obj._ccode_eval( - node.var, node.var2, node.var3, node.field.obj.U, node.field.obj.V, node.field.obj.W, *args - ) - if node.convert and node.field.obj.U.interp_method != "cgrid_velocity": - ccode_conv1 = node.field.obj.U._ccode_convert(*args) - ccode_conv2 = node.field.obj.V._ccode_convert(*args) - statements = [c.Statement(f"{node.var} *= {ccode_conv1}"), c.Statement(f"{node.var2} *= {ccode_conv2}")] - else: - statements = [] - if node.convert and "3D" in node.field.obj.vector_type: - ccode_conv3 = node.field.obj.W._ccode_convert(*args) - statements.append(c.Statement(f"{node.var3} *= {ccode_conv3}")) - conv_stat = c.Block(statements) - node.ccode = c.Block( - [ - c.Block(statements_croco), - c.Assign("parcels_interp_state", ccode_eval), - c.Assign("particles->state[pnum]", "max(particles->state[pnum], parcels_interp_state)"), - conv_stat, - c.Statement("CHECKSTATUS_KERNELLOOP(parcels_interp_state)"), - ] - ) - - def visit_NestedFieldEvalNode(self, node): - self.visit(node.fields) - self.visit(node.args) - cstat = [] - args = self._check_FieldSamplingArguments(node.args.ccode) - for fld in node.fields.obj: - ccode_eval = fld._ccode_eval(node.var, *args) - ccode_conv = fld._ccode_convert(*args) - conv_stat = c.Statement(f"{node.var} *= {ccode_conv}") - cstat += [ - c.Assign("particles->state[pnum]", ccode_eval), - conv_stat, - c.If( - "particles->state[pnum] != ERROROUTOFBOUNDS ", - c.Block([c.Statement("CHECKSTATUS_KERNELLOOP(particles->state[pnum])"), c.Statement("break")]), - ), - ] - cstat += [c.Statement("CHECKSTATUS_KERNELLOOP(particles->state[pnum])"), c.Statement("break")] - node.ccode = c.While("1==1", c.Block(cstat)) - - def visit_NestedVectorFieldEvalNode(self, node): - self.visit(node.fields) - self.visit(node.args) - cstat = [] - args = self._check_FieldSamplingArguments(node.args.ccode) - for fld in node.fields.obj: - ccode_eval = fld._ccode_eval(node.var, node.var2, node.var3, fld.U, fld.V, fld.W, *args) - if fld.U.interp_method != "cgrid_velocity": - ccode_conv1 = fld.U._ccode_convert(*args) - ccode_conv2 = fld.V._ccode_convert(*args) - statements = [c.Statement(f"{node.var} *= {ccode_conv1}"), c.Statement(f"{node.var2} *= {ccode_conv2}")] - else: - statements = [] - if "3D" in fld.vector_type: - ccode_conv3 = fld.W._ccode_convert(*args) - statements.append(c.Statement(f"{node.var3} *= {ccode_conv3}")) - cstat += [ - c.Assign("particles->state[pnum]", ccode_eval), - c.Block(statements), - c.If( - "particles->state[pnum] != ERROROUTOFBOUNDS ", - c.Block([c.Statement("CHECKSTATUS_KERNELLOOP(particles->state[pnum])"), c.Statement("break")]), - ), - ] - cstat += [c.Statement("CHECKSTATUS_KERNELLOOP(particles->state[pnum])"), c.Statement("break")] - node.ccode = c.While("1==1", c.Block(cstat)) - - def visit_Print(self, node): - for n in node.values: - self.visit(n) - if hasattr(node.values[0], "s"): - node.ccode = c.Statement(f'printf("{n.ccode}\\n")') - return - if hasattr(node.values[0], "s_print"): - args = node.values[0].right.ccode - s = f'printf("{node.values[0].left.ccode}\\n"' - if isinstance(args, str): - s = s + f", {args})" - else: - for arg in args: - s = s + (f", {arg}") - s = s + ")" - node.ccode = c.Statement(s) - return - vars = ", ".join([n.ccode for n in node.values]) - int_vars = ["particle->id", "particle->xi", "particle->yi", "particle->zi"] - stat = ", ".join(["%d" if n.ccode in int_vars else "%f" for n in node.values]) - node.ccode = c.Statement(f'printf("{stat}\\n", {vars})') - - def visit_Constant(self, node): - if node.value == "parcels_customed_Cfunc_pointer_args": - node.ccode = node.value - elif isinstance(node.value, str): - node.ccode = "" # skip strings from docstrings or comments - elif isinstance(node.value, bool): - node.ccode = "1" if node.value is True else "0" - else: - node.ccode = str(node.value) - - -class LoopGenerator: - """Code generator class that adds type definitions and the outer loop around kernel functions to generate compilable C code.""" - - def __init__(self, fieldset, ptype=None): - self.fieldset = fieldset - self.ptype = ptype - - def generate(self, funcname, field_args, const_args, kernel_ast, c_include): - ccode = [] - - pname = self.ptype.name + "p" - - # ==== Add include for Parcels and math header ==== # - ccode += [str(c.Include("parcels.h", system=False))] - ccode += [str(c.Include("math.h", system=False))] - ccode += [str(c.Assign("const int ngrid", str(self.fieldset.gridset.size if self.fieldset is not None else 1)))] - - # ==== Generate type definition for particle type ==== # - vdeclp = [c.Pointer(c.POD(v.dtype, v.name)) for v in self.ptype.variables] - ccode += [str(c.Typedef(c.GenerableStruct("", vdeclp, declname=pname)))] - - if c_include: - ccode += [c_include] - - # ==== Insert kernel code ==== # - ccode += [str(kernel_ast)] - - # Generate outer loop for repeated kernel invocation - args = [ - c.Value("int", "num_particles"), - c.Pointer(c.Value(pname, "particles")), - c.Value("double", "endtime"), - c.Value("double", "dt"), - ] - for field, _ in field_args.items(): - args += [c.Pointer(c.Value("CField", f"{field}"))] - for const, _ in const_args.items(): - args += [c.Value("double", const)] # are we SURE those const's are double's ? - fargs_str = ", ".join(["particles->time_nextloop[pnum]"] + list(field_args.keys()) + list(const_args.keys())) - # ==== statement clusters use to compose 'body' variable and variables 'time_loop' and 'part_loop' ==== ## - sign_dt = c.Assign("sign_dt", "dt > 0 ? 1 : -1") - - # ==== check if next_dt is in the particle type ==== # - dtname = "next_dt" if "next_dt" in [v.name for v in self.ptype.variables] else "dt" - - # ==== main computation body ==== # - body = [] - body += [c.Value("double", "pre_dt")] - body += [c.Statement("pre_dt = particles->dt[pnum]")] - body += [c.If("sign_dt*particles->time_nextloop[pnum] >= sign_dt*(endtime)", c.Statement("break"))] - body += [ - c.If( - f"fabs(endtime - particles->time_nextloop[pnum]) < fabs(particles->{dtname}[pnum])-1e-6", - c.Statement(f"particles->{dtname}[pnum] = fabs(endtime - particles->time_nextloop[pnum]) * sign_dt"), - ) - ] - body += [c.Assign("particles->state[pnum]", f"{funcname}(particles, pnum, {fargs_str})")] - body += [ - c.If( - "particles->state[pnum] == SUCCESS", - c.Block( - [ - c.If( - "sign_dt*particles->time[pnum] < sign_dt*endtime", - c.Block([c.Assign("particles->state[pnum]", "EVALUATE")]), - c.Block([c.Assign("particles->state[pnum]", "SUCCESS")]), - ) - ] - ), - ) - ] - body += [c.If("particles->state[pnum] == STOPALLEXECUTION", c.Statement("return"))] - body += [c.Statement("particles->dt[pnum] = pre_dt")] - body += [ - c.If( - "(particles->state[pnum] == REPEAT || particles->state[pnum] == DELETE)", - c.Block([c.Statement("break")]), - ) - ] - - time_loop = c.While("(particles->state[pnum] == EVALUATE || particles->state[pnum] == REPEAT)", c.Block(body)) - part_loop = c.For("pnum = 0", "pnum < num_particles", "++pnum", c.Block([time_loop])) - fbody = c.Block( - [ - c.Value("int", "pnum"), - c.Value("double", "sign_dt"), - sign_dt, - part_loop, - ] - ) - fdecl = c.FunctionDeclaration(c.Value("void", "particle_loop"), args) - ccode += [str(c.FunctionBody(fdecl, fbody))] - return "\n\n".join(ccode) diff --git a/parcels/field.py b/parcels/field.py deleted file mode 100644 index 4fc13a563..000000000 --- a/parcels/field.py +++ /dev/null @@ -1,2170 +0,0 @@ -import collections -import math -import warnings -from collections.abc import Iterable -from ctypes import POINTER, Structure, c_float, c_int, pointer -from pathlib import Path -from typing import TYPE_CHECKING, Literal - -import dask.array as da -import numpy as np -import xarray as xr - -import parcels.tools.interpolation_utils as i_u -from parcels._compat import add_note -from parcels._interpolation import ( - InterpolationContext2D, - InterpolationContext3D, - get_2d_interpolator_registry, - get_3d_interpolator_registry, -) -from parcels._typing import ( - GridIndexingType, - InterpMethod, - Mesh, - TimePeriodic, - VectorType, - assert_valid_gridindexingtype, - assert_valid_interp_method, -) -from parcels.tools._helpers import default_repr, deprecated_made_private, field_repr, timedelta_to_float -from parcels.tools.converters import ( - TimeConverter, - UnitConverter, - unitconverters_map, -) -from parcels.tools.statuscodes import ( - AllParcelsErrorCodes, - FieldOutOfBoundError, - FieldOutOfBoundSurfaceError, - FieldSamplingError, - TimeExtrapolationError, - _raise_field_out_of_bound_error, -) -from parcels.tools.warnings import FieldSetWarning, _deprecated_param_netcdf_decodewarning - -from ._index_search import _search_indices_curvilinear, _search_indices_rectilinear -from .fieldfilebuffer import ( - DaskFileBuffer, - DeferredDaskFileBuffer, - DeferredNetcdfFileBuffer, - NetcdfFileBuffer, -) -from .grid import CGrid, Grid, GridType, _calc_cell_areas, _calc_cell_edge_sizes - -if TYPE_CHECKING: - from ctypes import _Pointer as PointerType - - from parcels.fieldset import FieldSet - -__all__ = ["Field", "NestedField", "VectorField"] - - -def _isParticle(key): - if hasattr(key, "obs_written"): - return True - else: - return False - - -def _deal_with_errors(error, key, vector_type: VectorType): - if _isParticle(key): - key.state = AllParcelsErrorCodes[type(error)] - elif _isParticle(key[-1]): - key[-1].state = AllParcelsErrorCodes[type(error)] - else: - raise RuntimeError(f"{error}. Error could not be handled because particle was not part of the Field Sampling.") - - if vector_type and "3D" in vector_type: - return (0, 0, 0) - elif vector_type == "2D": - return (0, 0) - else: - return 0 - - -def _croco_from_z_to_sigma_scipy(fieldset, time, z, y, x, particle): - """Calculate local sigma level of the particle, by linearly interpolating the - scaling function that maps sigma to depth (using local ocean depth H, - sea-surface Zeta and stretching parameters Cs_w and hc). - See also https://croco-ocean.gitlabpages.inria.fr/croco_doc/model/model.grid.html#vertical-grid-parameters - """ - h = fieldset.H.eval(time, 0, y, x, particle=particle, applyConversion=False) - zeta = fieldset.Zeta.eval(time, 0, y, x, particle=particle, applyConversion=False) - sigma_levels = fieldset.U.grid.depth - z0 = fieldset.hc * sigma_levels + (h - fieldset.hc) * fieldset.Cs_w.data[0, :, 0, 0] - zvec = z0 + zeta * (1 + (z0 / h)) - zinds = zvec <= z - if z >= zvec[-1]: - zi = len(zvec) - 2 - else: - zi = zinds.argmin() - 1 if z >= zvec[0] else 0 - - return sigma_levels[zi] + (z - zvec[zi]) * (sigma_levels[zi + 1] - sigma_levels[zi]) / (zvec[zi + 1] - zvec[zi]) - - -class Field: - """Class that encapsulates access to field data. - - Parameters - ---------- - name : str - Name of the field - data : np.ndarray - 2D, 3D or 4D numpy array of field data. - - 1. If data shape is [xdim, ydim], [xdim, ydim, zdim], [xdim, ydim, tdim] or [xdim, ydim, zdim, tdim], - whichever is relevant for the dataset, use the flag transpose=True - 2. If data shape is [ydim, xdim], [zdim, ydim, xdim], [tdim, ydim, xdim] or [tdim, zdim, ydim, xdim], - use the flag transpose=False - 3. If data has any other shape, you first need to reorder it - lon : np.ndarray or list - Longitude coordinates (numpy vector or array) of the field (only if grid is None) - lat : np.ndarray or list - Latitude coordinates (numpy vector or array) of the field (only if grid is None) - depth : np.ndarray or list - Depth coordinates (numpy vector or array) of the field (only if grid is None) - time : np.ndarray - Time coordinates (numpy vector) of the field (only if grid is None) - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation: (only if grid is None) - - 1. spherical: Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat (default): No conversion, lat/lon are assumed to be in m. - timestamps : np.ndarray - A numpy array containing the timestamps for each of the files in filenames, for loading - from netCDF files only. Default is None if the netCDF dimensions dictionary includes time. - grid : parcels.grid.Grid - :class:`parcels.grid.Grid` object containing all the lon, lat depth, time - mesh and time_origin information. Can be constructed from any of the Grid objects - fieldtype : str - Type of Field to be used for UnitConverter (either 'U', 'V', 'Kh_zonal', 'Kh_meridional' or None) - transpose : bool - Transpose data to required (lon, lat) layout - vmin : float - Minimum allowed value on the field. Data below this value are set to zero - vmax : float - Maximum allowed value on the field. Data above this value are set to zero - cast_data_dtype : str - Cast Field data to dtype. Supported dtypes are "float32" (np.float32 (default)) and "float64 (np.float64). - Note that dtype can only be "float32" in JIT mode - time_origin : parcels.tools.converters.TimeConverter - Time origin of the time axis (only if grid is None) - interp_method : str - Method for interpolation. Options are 'linear' (default), 'nearest', - 'linear_invdist_land_tracer', 'cgrid_velocity', 'cgrid_tracer' and 'bgrid_velocity' - allow_time_extrapolation : bool - boolean whether to allow for extrapolation in time - (i.e. beyond the last available time snapshot) - time_periodic : bool, float or datetime.timedelta - To loop periodically over the time component of the Field. It is set to either False or the length of the period (either float in seconds or datetime.timedelta object). - The last value of the time series can be provided (which is the same as the initial one) or not (Default: False) - This flag overrides the allow_time_extrapolation and sets it to False - chunkdims_name_map : str, optional - Gives a name map to the FieldFileBuffer that declared a mapping between chunksize name, NetCDF dimension and Parcels dimension; - required only if currently incompatible OCM field is loaded and chunking is used by 'chunksize' (which is the default) - to_write : bool - Write the Field in NetCDF format at the same frequency as the ParticleFile outputdt, - using a filenaming scheme based on the ParticleFile name - - Examples - -------- - For usage examples see the following tutorials: - - * `Nested Fields <../examples/tutorial_NestedFields.ipynb>`__ - """ - - allow_time_extrapolation: bool - time_periodic: TimePeriodic - _cast_data_dtype: type[np.float32] | type[np.float64] - - def __init__( - self, - name: str | tuple[str, str], - data, - lon=None, - lat=None, - depth=None, - time=None, - grid=None, - mesh: Mesh = "flat", - timestamps=None, - fieldtype=None, - transpose: bool = False, - vmin: float | None = None, - vmax: float | None = None, - cast_data_dtype: type[np.float32] | type[np.float64] | Literal["float32", "float64"] = "float32", - time_origin: TimeConverter | None = None, - interp_method: InterpMethod = "linear", - allow_time_extrapolation: bool | None = None, - time_periodic: TimePeriodic = False, - gridindexingtype: GridIndexingType = "nemo", - to_write: bool = False, - **kwargs, - ): - if kwargs.get("netcdf_decodewarning") is not None: - _deprecated_param_netcdf_decodewarning() - kwargs.pop("netcdf_decodewarning") - - if not isinstance(name, tuple): - self.name = name - self.filebuffername = name - else: - self.name = name[0] - self.filebuffername = name[1] - self.data = data - if grid: - if grid.defer_load and isinstance(data, np.ndarray): - raise ValueError( - "Cannot combine Grid from defer_loaded Field with np.ndarray data. please specify lon, lat, depth and time dimensions separately" - ) - self._grid = grid - else: - if (time is not None) and isinstance(time[0], np.datetime64): - time_origin = TimeConverter(time[0]) - time = np.array([time_origin.reltime(t) for t in time]) - else: - time_origin = TimeConverter(0) - self._grid = Grid.create_grid(lon, lat, depth, time, time_origin=time_origin, mesh=mesh) - self.igrid = -1 - self.fieldtype = self.name if fieldtype is None else fieldtype - self.to_write = to_write - if self.grid.mesh == "flat" or (self.fieldtype not in unitconverters_map.keys()): - self.units = UnitConverter() - elif self.grid.mesh == "spherical": - self.units = unitconverters_map[self.fieldtype] - else: - raise ValueError("Unsupported mesh type. Choose either: 'spherical' or 'flat'") - self.timestamps = timestamps - self._loaded_time_indices: Iterable[int] = [] # type: ignore - if isinstance(interp_method, dict): - if self.name in interp_method: - self.interp_method = interp_method[self.name] - else: - raise RuntimeError(f"interp_method is a dictionary but {name} is not in it") - else: - self.interp_method = interp_method - assert_valid_gridindexingtype(gridindexingtype) - self._gridindexingtype = gridindexingtype - if self.interp_method in ["bgrid_velocity", "bgrid_w_velocity", "bgrid_tracer"] and self.grid._gtype in [ - GridType.RectilinearSGrid, - GridType.CurvilinearSGrid, - ]: - warnings.warn( - "General s-levels are not supported in B-grid. RectilinearSGrid and CurvilinearSGrid can still be used to deal with shaved cells, but the levels must be horizontal.", - FieldSetWarning, - stacklevel=2, - ) - - self.fieldset: FieldSet | None = None - if allow_time_extrapolation is None: - self.allow_time_extrapolation = True if len(self.grid.time) == 1 else False - else: - self.allow_time_extrapolation = allow_time_extrapolation - - self.time_periodic = time_periodic - if self.time_periodic is not False and self.allow_time_extrapolation: - warnings.warn( - "allow_time_extrapolation and time_periodic cannot be used together. allow_time_extrapolation is set to False", - FieldSetWarning, - stacklevel=2, - ) - self.allow_time_extrapolation = False - if self.time_periodic is True: - raise ValueError( - "Unsupported time_periodic=True. time_periodic must now be either False or the length of the period (either float in seconds or datetime.timedelta object." - ) - if self.time_periodic is not False: - self.time_periodic = timedelta_to_float(self.time_periodic) - - if not np.isclose(self.grid.time[-1] - self.grid.time[0], self.time_periodic): - if self.grid.time[-1] - self.grid.time[0] > self.time_periodic: - raise ValueError("Time series provided is longer than the time_periodic parameter") - self.grid._add_last_periodic_data_timestep = True - self.grid.time = np.append(self.grid.time, self.grid.time[0] + self.time_periodic) - self.grid.time_full = self.grid.time - - self.vmin = vmin - self.vmax = vmax - - match cast_data_dtype: - case "float32": - self._cast_data_dtype = np.float32 - case "float64": - self._cast_data_dtype = np.float64 - case _: - self._cast_data_dtype = cast_data_dtype - - if self.cast_data_dtype not in [np.float32, np.float64]: - raise ValueError( - f"Unsupported cast_data_dtype {self.cast_data_dtype!r}. Choose either: 'float32' or 'float64'" - ) - - if not self.grid.defer_load: - self.data = self._reshape(self.data, transpose) - self._loaded_time_indices = range(self.grid.tdim) - - # Hack around the fact that NaN and ridiculously large values - # propagate in SciPy's interpolators - lib = np if isinstance(self.data, np.ndarray) else da - self.data[lib.isnan(self.data)] = 0.0 - if self.vmin is not None: - self.data[self.data < self.vmin] = 0.0 - if self.vmax is not None: - self.data[self.data > self.vmax] = 0.0 - - if self.grid._add_last_periodic_data_timestep: - self.data = lib.concatenate((self.data, self.data[:1, :]), axis=0) - - self._scaling_factor = None - - # Variable names in JIT code - self._dimensions = kwargs.pop("dimensions", None) - self.indices = kwargs.pop("indices", None) - self._dataFiles = kwargs.pop("dataFiles", None) - if self.grid._add_last_periodic_data_timestep and self._dataFiles is not None: - self._dataFiles = np.append(self._dataFiles, self._dataFiles[0]) - self._field_fb_class = kwargs.pop("FieldFileBuffer", None) - self._netcdf_engine = kwargs.pop("netcdf_engine", "netcdf4") - self._creation_log = kwargs.pop("creation_log", "") - self.chunksize = kwargs.pop("chunksize", None) - self.netcdf_chunkdims_name_map = kwargs.pop("chunkdims_name_map", None) - self.grid.depth_field = kwargs.pop("depth_field", None) - - if self.grid.depth_field == "not_yet_set": - assert ( - self.grid._z4d - ), "Providing the depth dimensions from another field data is only available for 4d S grids" - - # data_full_zdim is the vertical dimension of the complete field data, ignoring the indices. - # (data_full_zdim = grid.zdim if no indices are used, for A- and C-grids and for some B-grids). It is used for the B-grid, - # since some datasets do not provide the deeper level of data (which is ignored by the interpolation). - self.data_full_zdim = kwargs.pop("data_full_zdim", None) - self._data_chunks = [] # type: ignore # the data buffer of the FileBuffer raw loaded data - shall be a list of C-contiguous arrays - self._c_data_chunks: list[PointerType | None] = [] # C-pointers to the data_chunks array - self.nchunks: tuple[int, ...] = () - self._chunk_set: bool = False - self.filebuffers = [None] * 2 - if len(kwargs) > 0: - raise SyntaxError(f'Field received an unexpected keyword argument "{list(kwargs.keys())[0]}"') - - def __repr__(self) -> str: - return field_repr(self) - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def dataFiles(self): - return self._dataFiles - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def chunk_set(self): - return self._chunk_set - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def c_data_chunks(self): - return self._c_data_chunks - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def data_chunks(self): - return self._data_chunks - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def creation_log(self): - return self._creation_log - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def loaded_time_indices(self): - return self._loaded_time_indices - - @property - def dimensions(self): - return self._dimensions - - @property - def grid(self): - return self._grid - - @property - def lon(self): - """Lon defined on the Grid object""" - return self.grid.lon - - @property - def lat(self): - """Lat defined on the Grid object""" - return self.grid.lat - - @property - def depth(self): - """Depth defined on the Grid object""" - return self.grid.depth - - @property - def cell_edge_sizes(self): - return self.grid.cell_edge_sizes - - @property - def interp_method(self): - return self._interp_method - - @interp_method.setter - def interp_method(self, value): - assert_valid_interp_method(value) - self._interp_method = value - - @property - def gridindexingtype(self): - return self._gridindexingtype - - @property - def cast_data_dtype(self): - return self._cast_data_dtype - - @property - def netcdf_engine(self): - return self._netcdf_engine - - @classmethod - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def get_dim_filenames(cls, *args, **kwargs): - return cls._get_dim_filenames(*args, **kwargs) - - @classmethod - def _get_dim_filenames(cls, filenames, dim): - if isinstance(filenames, str) or not isinstance(filenames, collections.abc.Iterable): - return [filenames] - elif isinstance(filenames, dict): - assert dim in filenames.keys(), "filename dimension keys must be lon, lat, depth or data" - filename = filenames[dim] - if isinstance(filename, str): - return [filename] - else: - return filename - else: - return filenames - - @staticmethod - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def collect_timeslices(*args, **kwargs): - return Field._collect_timeslices(*args, **kwargs) - - @staticmethod - def _collect_timeslices( - timestamps, data_filenames, _grid_fb_class, dimensions, indices, netcdf_engine, netcdf_decodewarning=None - ): - if netcdf_decodewarning is not None: - _deprecated_param_netcdf_decodewarning() - if timestamps is not None: - dataFiles = [] - for findex in range(len(data_filenames)): - stamps_in_file = 1 if isinstance(timestamps[findex], (int, np.datetime64)) else len(timestamps[findex]) - for f in [data_filenames[findex]] * stamps_in_file: - dataFiles.append(f) - timeslices = np.array([stamp for file in timestamps for stamp in file]) - time = timeslices - else: - timeslices = [] - dataFiles = [] - for fname in data_filenames: - with _grid_fb_class(fname, dimensions, indices, netcdf_engine=netcdf_engine) as filebuffer: - ftime = filebuffer.time - timeslices.append(ftime) - dataFiles.append([fname] * len(ftime)) - time = np.concatenate(timeslices).ravel() - dataFiles = np.concatenate(dataFiles).ravel() - if time.size == 1 and time[0] is None: - time[0] = 0 - time_origin = TimeConverter(time[0]) - time = time_origin.reltime(time) - - if not np.all((time[1:] - time[:-1]) > 0): - id_not_ordered = np.where(time[1:] < time[:-1])[0][0] - raise AssertionError( - f"Please make sure your netCDF files are ordered in time. First pair of non-ordered files: {dataFiles[id_not_ordered]}, {dataFiles[id_not_ordered + 1]}" - ) - return time, time_origin, timeslices, dataFiles - - @classmethod - def from_netcdf( - cls, - filenames, - variable, - dimensions, - indices=None, - grid=None, - mesh: Mesh = "spherical", - timestamps=None, - allow_time_extrapolation: bool | None = None, - time_periodic: TimePeriodic = False, - deferred_load: bool = True, - **kwargs, - ) -> "Field": - """Create field from netCDF file. - - Parameters - ---------- - filenames : list of str or dict - list of filenames to read for the field. filenames can be a list ``[files]`` or - a dictionary ``{dim:[files]}`` (if lon, lat, depth and/or data not stored in same files as data) - In the latter case, time values are in filenames[data] - variable : dict, tuple of str or str - Dict or tuple mapping field name to variable name in the NetCDF file. - dimensions : dict - Dictionary mapping variable names for the relevant dimensions in the NetCDF file - indices : - dictionary mapping indices for each dimension to read from file. - This can be used for reading in only a subregion of the NetCDF file. - Note that negative indices are not allowed. (Default value = None) - mesh : - String indicating the type of mesh coordinates and - units used during velocity interpolation: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - timestamps : - A numpy array of datetime64 objects containing the timestamps for each of the files in filenames. - Default is None if dimensions includes time. - allow_time_extrapolation : bool - boolean whether to allow for extrapolation in time - (i.e. beyond the last available time snapshot) - Default is False if dimensions includes time, else True - time_periodic : bool, float or datetime.timedelta - boolean whether to loop periodically over the time component of the FieldSet - This flag overrides the allow_time_extrapolation and sets it to False (Default value = False) - deferred_load : bool - boolean whether to only pre-load data (in deferred mode) or - fully load them (default: True). It is advised to deferred load the data, since in - that case Parcels deals with a better memory management during particle set execution. - deferred_load=False is however sometimes necessary for plotting the fields. - gridindexingtype : str - The type of gridindexing. Either 'nemo' (default), 'mitgcm', 'mom5', 'pop', or 'croco' are supported. - See also the Grid indexing documentation on oceanparcels.org - chunksize : - size of the chunks in dask loading - netcdf_decodewarning : bool - (DEPRECATED - v3.1.0) Whether to show a warning if there is a problem decoding the netcdf files. - Default is True, but in some cases where these warnings are expected, it may be useful to silence them - by setting netcdf_decodewarning=False. - grid : - (Default value = None) - **kwargs : - Keyword arguments passed to the :class:`Field` constructor. - - Examples - -------- - For usage examples see the following tutorial: - - * `Timestamps <../examples/tutorial_timestamps.ipynb>`__ - - """ - if kwargs.get("netcdf_decodewarning") is not None: - _deprecated_param_netcdf_decodewarning() - kwargs.pop("netcdf_decodewarning") - - # Ensure the timestamps array is compatible with the user-provided datafiles. - if timestamps is not None: - if isinstance(filenames, list): - assert len(filenames) == len( - timestamps - ), "Outer dimension of timestamps should correspond to number of files." - elif isinstance(filenames, dict): - for k in filenames.keys(): - if k not in ["lat", "lon", "depth", "time"]: - if isinstance(filenames[k], list): - assert len(filenames[k]) == len( - timestamps - ), "Outer dimension of timestamps should correspond to number of files." - else: - assert ( - len(timestamps) == 1 - ), "Outer dimension of timestamps should correspond to number of files." - for t in timestamps: - assert isinstance(t, (list, np.ndarray)), "timestamps should be a list for each file" - - else: - raise TypeError( - "Filenames type is inconsistent with manual timestamp provision." + "Should be dict or list" - ) - - if isinstance(variable, str): # for backward compatibility with Parcels < 2.0.0 - variable = (variable, variable) - elif isinstance(variable, dict): - assert ( - len(variable) == 1 - ), "Field.from_netcdf() supports only one variable at a time. Use FieldSet.from_netcdf() for multiple variables." - variable = tuple(variable.items())[0] - assert ( - len(variable) == 2 - ), "The variable tuple must have length 2. Use FieldSet.from_netcdf() for multiple variables" - - data_filenames = cls._get_dim_filenames(filenames, "data") - lonlat_filename = cls._get_dim_filenames(filenames, "lon") - if isinstance(filenames, dict): - assert len(lonlat_filename) == 1 - if lonlat_filename != cls._get_dim_filenames(filenames, "lat"): - raise NotImplementedError( - "longitude and latitude dimensions are currently processed together from one single file" - ) - lonlat_filename = lonlat_filename[0] - if "depth" in dimensions: - depth_filename = cls._get_dim_filenames(filenames, "depth") - if isinstance(filenames, dict) and len(depth_filename) != 1: - raise NotImplementedError("Vertically adaptive meshes not implemented for from_netcdf()") - depth_filename = depth_filename[0] - - netcdf_engine = kwargs.pop("netcdf_engine", "netcdf4") - gridindexingtype = kwargs.get("gridindexingtype", "nemo") - - indices = {} if indices is None else indices.copy() - for ind in indices: - if len(indices[ind]) == 0: - raise RuntimeError(f"Indices for {ind} can not be empty") - assert np.min(indices[ind]) >= 0, ( - "Negative indices are currently not allowed in Parcels. " - + "This is related to the non-increasing dimension it could generate " - + "if the domain goes from lon[-4] to lon[6] for example. " - + "Please raise an issue on https://github.com/OceanParcels/parcels/issues " - + "if you would need such feature implemented." - ) - - interp_method: InterpMethod = kwargs.pop("interp_method", "linear") - if type(interp_method) is dict: - if variable[0] in interp_method: - interp_method = interp_method[variable[0]] - else: - raise RuntimeError(f"interp_method is a dictionary but {variable[0]} is not in it") - - _grid_fb_class = NetcdfFileBuffer - - if "lon" in dimensions and "lat" in dimensions: - with _grid_fb_class( - lonlat_filename, - dimensions, - indices, - netcdf_engine, - gridindexingtype=gridindexingtype, - ) as filebuffer: - lat, lon = filebuffer.latlon - indices = filebuffer.indices - # Check if parcels_mesh has been explicitly set in file - if "parcels_mesh" in filebuffer.dataset.attrs: - mesh = filebuffer.dataset.attrs["parcels_mesh"] - else: - lon = 0 - lat = 0 - mesh = "flat" - - if "depth" in dimensions: - with _grid_fb_class( - depth_filename, - dimensions, - indices, - netcdf_engine, - interp_method=interp_method, - gridindexingtype=gridindexingtype, - ) as filebuffer: - filebuffer.name = filebuffer.parse_name(variable[1]) - if dimensions["depth"] == "not_yet_set": - depth = filebuffer.depth_dimensions - kwargs["depth_field"] = "not_yet_set" - else: - depth = filebuffer.depth - data_full_zdim = filebuffer.data_full_zdim - else: - indices["depth"] = [0] - depth = np.zeros(1) - data_full_zdim = 1 - - kwargs["data_full_zdim"] = data_full_zdim - - if len(data_filenames) > 1 and "time" not in dimensions and timestamps is None: - raise RuntimeError("Multiple files given but no time dimension specified") - - if grid is None: - # Concatenate time variable to determine overall dimension - # across multiple files - if "time" in dimensions or timestamps is not None: - time, time_origin, timeslices, dataFiles = cls._collect_timeslices( - timestamps, data_filenames, _grid_fb_class, dimensions, indices, netcdf_engine - ) - grid = Grid.create_grid(lon, lat, depth, time, time_origin=time_origin, mesh=mesh) - grid.timeslices = timeslices - kwargs["dataFiles"] = dataFiles - else: # e.g. for the CROCO CS_w field, see https://github.com/OceanParcels/Parcels/issues/1831 - grid = Grid.create_grid(lon, lat, depth, np.array([0.0]), time_origin=TimeConverter(0.0), mesh=mesh) - grid.timeslices = [[0]] - data_filenames = [data_filenames[0]] - elif grid is not None and ("dataFiles" not in kwargs or kwargs["dataFiles"] is None): - # ==== means: the field has a shared grid, but may have different data files, so we need to collect the - # ==== correct file time series again. - _, _, _, dataFiles = cls._collect_timeslices( - timestamps, data_filenames, _grid_fb_class, dimensions, indices, netcdf_engine - ) - kwargs["dataFiles"] = dataFiles - - chunksize: bool | None = kwargs.get("chunksize", None) - grid.chunksize = chunksize - - if "time" in indices: - warnings.warn( - "time dimension in indices is not necessary anymore. It is then ignored.", FieldSetWarning, stacklevel=2 - ) - - if grid.time.size <= 2: - deferred_load = False - - _field_fb_class: type[DeferredDaskFileBuffer | DaskFileBuffer | DeferredNetcdfFileBuffer | NetcdfFileBuffer] - if chunksize not in [False, None]: - if deferred_load: - _field_fb_class = DeferredDaskFileBuffer - else: - _field_fb_class = DaskFileBuffer - elif deferred_load: - _field_fb_class = DeferredNetcdfFileBuffer - else: - _field_fb_class = NetcdfFileBuffer - kwargs["FieldFileBuffer"] = _field_fb_class - - if not deferred_load: - # Pre-allocate data before reading files into buffer - data_list = [] - ti = 0 - for tslice, fname in zip(grid.timeslices, data_filenames, strict=True): - with _field_fb_class( # type: ignore[operator] - fname, - dimensions, - indices, - netcdf_engine, - interp_method=interp_method, - data_full_zdim=data_full_zdim, - chunksize=chunksize, - ) as filebuffer: - # If Field.from_netcdf is called directly, it may not have a 'data' dimension - # In that case, assume that 'name' is the data dimension - filebuffer.name = filebuffer.parse_name(variable[1]) - buffer_data = filebuffer.data - if len(buffer_data.shape) == 4: - errormessage = ( - f"Field {filebuffer.name} expecting a data shape of [tdim={grid.tdim}, zdim={grid.zdim}, " - f"ydim={grid.ydim - 2 * grid.meridional_halo}, xdim={grid.xdim - 2 * grid.zonal_halo}] " - f"but got shape {buffer_data.shape}. Flag transpose=True could help to reorder the data." - ) - assert buffer_data.shape[0] == grid.tdim, errormessage - assert buffer_data.shape[2] == grid.ydim - 2 * grid.meridional_halo, errormessage - assert buffer_data.shape[3] == grid.xdim - 2 * grid.zonal_halo, errormessage - - if len(buffer_data.shape) == 2: - data_list.append(buffer_data.reshape(sum(((len(tslice), 1), buffer_data.shape), ()))) - elif len(buffer_data.shape) == 3: - if len(filebuffer.indices["depth"]) > 1: - data_list.append(buffer_data.reshape(sum(((1,), buffer_data.shape), ()))) - else: - if type(tslice) not in [list, np.ndarray, da.Array, xr.DataArray]: - tslice = [tslice] - data_list.append(buffer_data.reshape(sum(((len(tslice), 1), buffer_data.shape[1:]), ()))) - else: - data_list.append(buffer_data) - if type(tslice) not in [list, np.ndarray, da.Array, xr.DataArray]: - tslice = [tslice] - ti += len(tslice) - lib = np if isinstance(data_list[0], np.ndarray) else da - data = lib.concatenate(data_list, axis=0) - else: - grid._defer_load = True - grid._ti = -1 - data = DeferredArray() - data.compute_shape(grid.xdim, grid.ydim, grid.zdim, grid.tdim, len(grid.timeslices)) - - if allow_time_extrapolation is None: - allow_time_extrapolation = False if "time" in dimensions else True - - kwargs["dimensions"] = dimensions.copy() - kwargs["indices"] = indices - kwargs["time_periodic"] = time_periodic - kwargs["netcdf_engine"] = netcdf_engine - - return cls( - variable, - data, - grid=grid, - timestamps=timestamps, - allow_time_extrapolation=allow_time_extrapolation, - interp_method=interp_method, - **kwargs, - ) - - @classmethod - def from_xarray( - cls, - da: xr.DataArray, - name: str, - dimensions, - mesh: Mesh = "spherical", - allow_time_extrapolation: bool | None = None, - time_periodic: TimePeriodic = False, - **kwargs, - ): - """Create field from xarray Variable. - - Parameters - ---------- - da : xr.DataArray - Xarray DataArray - name : str - Name of the Field - dimensions : dict - Dictionary mapping variable names for the relevant dimensions in the DataArray - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - allow_time_extrapolation : bool - boolean whether to allow for extrapolation in time - (i.e. beyond the last available time snapshot) - Default is False if dimensions includes time, else True - time_periodic : bool, float or datetime.timedelta - boolean whether to loop periodically over the time component of the FieldSet - This flag overrides the allow_time_extrapolation and sets it to False (Default value = False) - **kwargs : - Keyword arguments passed to the :class:`Field` constructor. - """ - data = da.data - interp_method = kwargs.pop("interp_method", "linear") - - time = da[dimensions["time"]].values if "time" in dimensions else np.array([0.0]) - depth = da[dimensions["depth"]].values if "depth" in dimensions else np.array([0]) - lon = da[dimensions["lon"]].values - lat = da[dimensions["lat"]].values - - time_origin = TimeConverter(time[0]) - time = time_origin.reltime(time) # type: ignore[assignment] - - grid = Grid.create_grid(lon, lat, depth, time, time_origin=time_origin, mesh=mesh) - kwargs["time_periodic"] = time_periodic - return cls( - name, - data, - grid=grid, - allow_time_extrapolation=allow_time_extrapolation, - interp_method=interp_method, - **kwargs, - ) - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def reshape(self, *args, **kwargs): - return self._reshape(*args, **kwargs) - - def _reshape(self, data, transpose=False): - # Ensure that field data is the right data type - if not isinstance(data, (np.ndarray, da.core.Array)): - data = np.array(data) - if (self.cast_data_dtype == np.float32) and (data.dtype != np.float32): - data = data.astype(np.float32) - elif (self.cast_data_dtype == np.float64) and (data.dtype != np.float64): - data = data.astype(np.float64) - lib = np if isinstance(data, np.ndarray) else da - if transpose: - data = lib.transpose(data) - if self.grid._lat_flipped: - data = lib.flip(data, axis=-2) - - if self.grid.xdim == 1 or self.grid.ydim == 1: - data = lib.squeeze(data) # First remove all length-1 dimensions in data, so that we can add them below - if self.grid.xdim == 1 and len(data.shape) < 4: - if lib == da: - raise NotImplementedError( - "Length-one dimensions with field chunking not implemented, as dask does not have an `expand_dims` method. Use chunksize=None" - ) - data = lib.expand_dims(data, axis=-1) - if self.grid.ydim == 1 and len(data.shape) < 4: - if lib == da: - raise NotImplementedError( - "Length-one dimensions with field chunking not implemented, as dask does not have an `expand_dims` method. Use chunksize=None" - ) - data = lib.expand_dims(data, axis=-2) - if self.grid.tdim == 1: - if len(data.shape) < 4: - data = data.reshape(sum(((1,), data.shape), ())) - if self.grid.zdim == 1: - if len(data.shape) == 4: - data = data.reshape(sum(((data.shape[0],), data.shape[2:]), ())) - if len(data.shape) == 4: - errormessage = ( - f"Field {self.name} expecting a data shape of [tdim, zdim, ydim, xdim]. " - "Flag transpose=True could help to reorder the data." - ) - assert data.shape[0] == self.grid.tdim, errormessage - assert data.shape[2] == self.grid.ydim - 2 * self.grid.meridional_halo, errormessage - assert data.shape[3] == self.grid.xdim - 2 * self.grid.zonal_halo, errormessage - if self.gridindexingtype == "pop": - assert data.shape[1] == self.grid.zdim or data.shape[1] == self.grid.zdim - 1, errormessage - else: - assert data.shape[1] == self.grid.zdim, errormessage - else: - assert data.shape == ( - self.grid.tdim, - self.grid.ydim - 2 * self.grid.meridional_halo, - self.grid.xdim - 2 * self.grid.zonal_halo, - ), ( - f"Field {self.name} expecting a data shape of [tdim, ydim, xdim]. " - "Flag transpose=True could help to reorder the data." - ) - if self.grid.meridional_halo > 0 or self.grid.zonal_halo > 0: - data = self.add_periodic_halo( - zonal=self.grid.zonal_halo > 0, - meridional=self.grid.meridional_halo > 0, - halosize=max(self.grid.meridional_halo, self.grid.zonal_halo), - data=data, - ) - return data - - def set_scaling_factor(self, factor): - """Scales the field data by some constant factor. - - Parameters - ---------- - factor : - scaling factor - - - Examples - -------- - For usage examples see the following tutorial: - - * `Unit converters <../examples/tutorial_unitconverters.ipynb>`__ - """ - if self._scaling_factor: - raise NotImplementedError(f"Scaling factor for field {self.name} already defined.") - self._scaling_factor = factor - if not self.grid.defer_load: - self.data *= factor - - def set_depth_from_field(self, field): - """Define the depth dimensions from another (time-varying) field. - - Notes - ----- - See `this tutorial <../examples/tutorial_timevaryingdepthdimensions.ipynb>`__ - for a detailed explanation on how to set up time-evolving depth dimensions. - - """ - self.grid.depth_field = field - if self.grid != field.grid: - field.grid.depth_field = field - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def calc_cell_edge_sizes(self): - _calc_cell_edge_sizes(self.grid) - - def cell_areas(self): - """Method to calculate cell sizes based on cell_edge_sizes. - - Only works for Rectilinear Grids - """ - return _calc_cell_areas(self.grid) - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def search_indices_vertical_z(self, *_): - raise NotImplementedError - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def search_indices_vertical_s(self, *args, **kwargs): - raise NotImplementedError - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def reconnect_bnd_indices(self, *args, **kwargs): - raise NotImplementedError - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def search_indices_rectilinear(self, *_): - raise NotImplementedError - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def search_indices_curvilinear(self, *_): - raise NotImplementedError - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def search_indices(self, *_): - raise NotImplementedError - - def _search_indices(self, time, z, y, x, ti=-1, particle=None, search2D=False): - if self.grid._gtype in [GridType.RectilinearSGrid, GridType.RectilinearZGrid]: - return _search_indices_rectilinear(self, time, z, y, x, ti, particle=particle, search2D=search2D) - else: - return _search_indices_curvilinear(self, time, z, y, x, ti, particle=particle, search2D=search2D) - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def interpolator2D(self, *_): - raise NotImplementedError - - def _interpolator2D(self, ti, z, y, x, particle=None): - """Impelement 2D interpolation with coordinate transformations as seen in Delandmeter and Van Sebille (2019), 10.5194/gmd-12-3571-2019..""" - (_, eta, xsi, _, yi, xi) = self._search_indices(-1, z, y, x, particle=particle) - ctx = InterpolationContext2D(self.data, eta, xsi, ti, yi, xi) - - try: - f = get_2d_interpolator_registry()[self.interp_method] - except KeyError: - if self.interp_method == "cgrid_velocity": - raise RuntimeError( - f"{self.name} is a scalar field. cgrid_velocity interpolation method should be used for vector fields (e.g. FieldSet.UV)" - ) - else: - raise RuntimeError(self.interp_method + " is not implemented for 2D grids") - return f(ctx) - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def interpolator3D(self, *_): - raise NotImplementedError - - def _interpolator3D(self, ti, z, y, x, time, particle=None): - """Impelement 3D interpolation with coordinate transformations as seen in Delandmeter and Van Sebille (2019), 10.5194/gmd-12-3571-2019..""" - (zeta, eta, xsi, zi, yi, xi) = self._search_indices(time, z, y, x, ti, particle=particle) - ctx = InterpolationContext3D(self.data, zeta, eta, xsi, ti, zi, yi, xi, self.gridindexingtype) - - try: - f = get_3d_interpolator_registry()[self.interp_method] - except KeyError: - raise RuntimeError(self.interp_method + " is not implemented for 3D grids") - return f(ctx) - - def temporal_interpolate_fullfield(self, ti, time): - """Calculate the data of a field between two snapshots using linear interpolation. - - Parameters - ---------- - ti : - Index in time array associated with time (via :func:`time_index`) - time : - Time to interpolate to - """ - t0 = self.grid.time[ti] - if time == t0: - return self.data[ti, :] - elif ti + 1 >= len(self.grid.time): - raise TimeExtrapolationError(time, field=self) - else: - t1 = self.grid.time[ti + 1] - f0 = self.data[ti, :] - f1 = self.data[ti + 1, :] - return f0 + (f1 - f0) * ((time - t0) / (t1 - t0)) - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def spatial_interpolation(self, *args, **kwargs): - return self._spatial_interpolation(*args, **kwargs) - - def _spatial_interpolation(self, ti, z, y, x, time, particle=None): - """Interpolate horizontal field values using a SciPy interpolator.""" - try: - if self.grid.zdim == 1: - val = self._interpolator2D(ti, z, y, x, particle=particle) - else: - val = self._interpolator3D(ti, z, y, x, time, particle=particle) - - if np.isnan(val): - # Detect Out-of-bounds sampling and raise exception - _raise_field_out_of_bound_error(z, y, x) - else: - if isinstance(val, da.core.Array): - val = val.compute() - return val - - except (FieldSamplingError, FieldOutOfBoundError, FieldOutOfBoundSurfaceError) as e: - e = add_note(e, f"Error interpolating field '{self.name}'.", before=True) - raise e - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def time_index(self, *_): - raise NotImplementedError - - def _time_index(self, time): - """Find the index in the time array associated with a given time. - - Note that we normalize to either the first or the last index - if the sampled value is outside the time value range. - """ - if ( - not self.time_periodic - and not self.allow_time_extrapolation - and (time < self.grid.time[0] or time > self.grid.time[-1]) - ): - raise TimeExtrapolationError(time, field=self) - time_index = self.grid.time <= time - if self.time_periodic: - if time_index.all() or np.logical_not(time_index).all(): - periods = int( - math.floor((time - self.grid.time_full[0]) / (self.grid.time_full[-1] - self.grid.time_full[0])) - ) - if isinstance(self.grid.periods, c_int): - self.grid.periods.value = periods - else: - self.grid.periods = periods - time -= periods * (self.grid.time_full[-1] - self.grid.time_full[0]) - time_index = self.grid.time <= time - ti = time_index.argmin() - 1 if time_index.any() else 0 - return (ti, periods) - return (time_index.argmin() - 1 if time_index.any() else 0, 0) - if time_index.all(): - # If given time > last known field time, use - # the last field frame without interpolation - return (len(self.grid.time) - 1, 0) - elif np.logical_not(time_index).all(): - # If given time < any time in the field, use - # the first field frame without interpolation - return (0, 0) - else: - return (time_index.argmin() - 1 if time_index.any() else 0, 0) - - def _check_velocitysampling(self): - if self.name in ["U", "V", "W"]: - warnings.warn( - "Sampling of velocities should normally be done using fieldset.UV or fieldset.UVW object; tread carefully", - RuntimeWarning, - stacklevel=2, - ) - - def __getitem__(self, key): - self._check_velocitysampling() - try: - if _isParticle(key): - return self.eval(key.time, key.depth, key.lat, key.lon, key) - else: - return self.eval(*key) - except tuple(AllParcelsErrorCodes.keys()) as error: - return _deal_with_errors(error, key, vector_type=None) - - def eval(self, time, z, y, x, particle=None, applyConversion=True): - """Interpolate field values in space and time. - - We interpolate linearly in time and apply implicit unit - conversion to the result. Note that we defer to - scipy.interpolate to perform spatial interpolation. - """ - (ti, periods) = self._time_index(time) - time -= periods * (self.grid.time_full[-1] - self.grid.time_full[0]) - if self.gridindexingtype == "croco" and self not in [self.fieldset.H, self.fieldset.Zeta]: - z = _croco_from_z_to_sigma_scipy(self.fieldset, time, z, y, x, particle=particle) - if ti < self.grid.tdim - 1 and time > self.grid.time[ti]: - f0 = self._spatial_interpolation(ti, z, y, x, time, particle=particle) - f1 = self._spatial_interpolation(ti + 1, z, y, x, time, particle=particle) - t0 = self.grid.time[ti] - t1 = self.grid.time[ti + 1] - value = f0 + (f1 - f0) * ((time - t0) / (t1 - t0)) - else: - # Skip temporal interpolation if time is outside - # of the defined time range or if we have hit an - # exact value in the time array. - value = self._spatial_interpolation(ti, z, y, x, self.grid.time[ti], particle=particle) - - if applyConversion: - return self.units.to_target(value, z, y, x) - else: - return value - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def ccode_eval(self, *args, **kwargs): - return self._ccode_eval(*args, **kwargs) - - def _ccode_eval(self, var, t, z, y, x): - self._check_velocitysampling() - ccode_str = ( - f"temporal_interpolation({t}, {z}, {y}, {x}, {self.ccode_name}, " - + "&particles->ti[pnum*ngrid], &particles->zi[pnum*ngrid], &particles->yi[pnum*ngrid], &particles->xi[pnum*ngrid], " - + f"&{var}, {self.interp_method.upper()}, {self.gridindexingtype.upper()})" - ) - return ccode_str - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def ccode_convert(self, *args, **kwargs): - return self._ccode_convert(*args, **kwargs) - - def _ccode_convert(self, _, z, y, x): - return self.units.ccode_to_target(z, y, x) - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def get_block_id(self, *args, **kwargs): - return self._get_block_id(*args, **kwargs) - - def _get_block_id(self, block): - return np.ravel_multi_index(block, self.nchunks) - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def get_block(self, *args, **kwargs): - return self._get_block(*args, **kwargs) - - def _get_block(self, bid): - return np.unravel_index(bid, self.nchunks[1:]) - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def chunk_setup(self, *args, **kwargs): - return self._chunk_setup(*args, **kwargs) - - def _chunk_setup(self): - if isinstance(self.data, da.core.Array): - chunks = self.data.chunks - self.nchunks = self.data.numblocks - npartitions = 1 - for n in self.nchunks[1:]: - npartitions *= n - elif isinstance(self.data, np.ndarray): - chunks = tuple((t,) for t in self.data.shape) - self.nchunks = (1,) * len(self.data.shape) - npartitions = 1 - elif isinstance(self.data, DeferredArray): - self.nchunks = (1,) * len(self.data.data_shape) - return - else: - return - - self._data_chunks = [None] * npartitions - self._c_data_chunks = [None] * npartitions - self.grid._load_chunk = np.zeros(npartitions, dtype=c_int, order="C") - # self.grid.chunk_info format: number of dimensions (without tdim); number of chunks per dimensions; - # chunksizes (the 0th dim sizes for all chunk of dim[0], then so on for next dims - self.grid.chunk_info = [ - [len(self.nchunks) - 1], - list(self.nchunks[1:]), - sum(list(list(ci) for ci in chunks[1:]), []), # noqa: RUF017 # TODO: Perhaps avoid quadratic list summation here - ] - self.grid.chunk_info = sum(self.grid.chunk_info, []) # noqa: RUF017 - self._chunk_set = True - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def chunk_data(self, *args, **kwargs): - return self._chunk_data(*args, **kwargs) - - def _chunk_data(self): - if not self._chunk_set: - self._chunk_setup() - g = self.grid - if isinstance(self.data, da.core.Array): - for block_id in range(len(self.grid._load_chunk)): - if g._load_chunk[block_id] == g._chunk_loading_requested or ( - g._load_chunk[block_id] in g._chunk_loaded and self._data_chunks[block_id] is None - ): - block = self._get_block(block_id) - self._data_chunks[block_id] = np.array( - self.data.blocks[(slice(self.grid.tdim),) + block], order="C" - ) - elif g._load_chunk[block_id] == g._chunk_not_loaded: - if isinstance(self._data_chunks, list): - self._data_chunks[block_id] = None - else: - self._data_chunks[block_id, :] = None - self._c_data_chunks[block_id] = None - else: - if isinstance(self._data_chunks, list): - self._data_chunks[0] = None - else: - self._data_chunks[0, :] = None - self._c_data_chunks[0] = None - self.grid._load_chunk[0] = g._chunk_loaded_touched - self._data_chunks[0] = np.array(self.data, order="C") - - @property - def ctypes_struct(self): - """Returns a ctypes struct object containing all relevant pointers and sizes for this field.""" - - # Ctypes struct corresponding to the type definition in parcels.h - class CField(Structure): - _fields_ = [ - ("xdim", c_int), - ("ydim", c_int), - ("zdim", c_int), - ("tdim", c_int), - ("igrid", c_int), - ("allow_time_extrapolation", c_int), - ("time_periodic", c_int), - ("data_chunks", POINTER(POINTER(POINTER(c_float)))), - ("grid", POINTER(CGrid)), - ] - - # Create and populate the c-struct object - allow_time_extrapolation = 1 if self.allow_time_extrapolation else 0 - time_periodic = 1 if self.time_periodic else 0 - for i in range(len(self.grid._load_chunk)): - if self.grid._load_chunk[i] == self.grid._chunk_loading_requested: - raise ValueError( - "data_chunks should have been loaded by now if requested. grid._load_chunk[bid] cannot be 1" - ) - if self.grid._load_chunk[i] in self.grid._chunk_loaded: - if not self._data_chunks[i].flags["C_CONTIGUOUS"]: - self._data_chunks[i] = np.array(self._data_chunks[i], order="C") - self._c_data_chunks[i] = self._data_chunks[i].ctypes.data_as(POINTER(POINTER(c_float))) - else: - self._c_data_chunks[i] = None - - cstruct = CField( - self.grid.xdim, - self.grid.ydim, - self.grid.zdim, - self.grid.tdim, - self.igrid, - allow_time_extrapolation, - time_periodic, - (POINTER(POINTER(c_float)) * len(self._c_data_chunks))(*self._c_data_chunks), - pointer(self.grid.ctypes_struct), - ) - return cstruct - - def add_periodic_halo(self, zonal, meridional, halosize=5, data=None): - """Add a 'halo' to all Fields in a FieldSet. - - Add a 'halo' to all Fields in a FieldSet, through extending the Field (and lon/lat) - by copying a small portion of the field on one side of the domain to the other. - Before adding a periodic halo to the Field, it has to be added to the Grid on which the Field depends - - See `this tutorial <../examples/tutorial_periodic_boundaries.ipynb>`__ - for a detailed explanation on how to set up periodic boundaries - - Parameters - ---------- - zonal : bool - Create a halo in zonal direction. - meridional : bool - Create a halo in meridional direction. - halosize : int - Size of the halo (in grid points). Default is 5 grid points - data : - if data is not None, the periodic halo will be achieved on data instead of self.data and data will be returned (Default value = None) - """ - dataNone = not isinstance(data, (np.ndarray, da.core.Array)) - if self.grid.defer_load and dataNone: - return - data = self.data if dataNone else data - lib = np if isinstance(data, np.ndarray) else da - if zonal: - if len(data.shape) == 3: - data = lib.concatenate((data[:, :, -halosize:], data, data[:, :, 0:halosize]), axis=len(data.shape) - 1) - assert data.shape[2] == self.grid.xdim, "Third dim must be x." - else: - data = lib.concatenate( - (data[:, :, :, -halosize:], data, data[:, :, :, 0:halosize]), axis=len(data.shape) - 1 - ) - assert data.shape[3] == self.grid.xdim, "Fourth dim must be x." - if meridional: - if len(data.shape) == 3: - data = lib.concatenate((data[:, -halosize:, :], data, data[:, 0:halosize, :]), axis=len(data.shape) - 2) - assert data.shape[1] == self.grid.ydim, "Second dim must be y." - else: - data = lib.concatenate( - (data[:, :, -halosize:, :], data, data[:, :, 0:halosize, :]), axis=len(data.shape) - 2 - ) - assert data.shape[2] == self.grid.ydim, "Third dim must be y." - if dataNone: - self.data = data - else: - return data - - def write(self, filename, varname=None): - """Write a :class:`Field` to a netcdf file. - - Parameters - ---------- - filename : str - Basename of the file (i.e. '{filename}{Field.name}.nc') - varname : str - Name of the field, to be appended to the filename. (Default value = None) - """ - filepath = str(Path(f"{filename}{self.name}.nc")) - if varname is None: - varname = self.name - # Derive name of 'depth' variable for NEMO convention - vname_depth = f"depth{self.name.lower()}" - - # Create DataArray objects for file I/O - if self.grid._gtype == GridType.RectilinearZGrid: - nav_lon = xr.DataArray( - self.grid.lon + np.zeros((self.grid.ydim, self.grid.xdim), dtype=np.float32), - coords=[("y", self.grid.lat), ("x", self.grid.lon)], - ) - nav_lat = xr.DataArray( - self.grid.lat.reshape(self.grid.ydim, 1) + np.zeros(self.grid.xdim, dtype=np.float32), - coords=[("y", self.grid.lat), ("x", self.grid.lon)], - ) - elif self.grid._gtype == GridType.CurvilinearZGrid: - nav_lon = xr.DataArray(self.grid.lon, coords=[("y", range(self.grid.ydim)), ("x", range(self.grid.xdim))]) - nav_lat = xr.DataArray(self.grid.lat, coords=[("y", range(self.grid.ydim)), ("x", range(self.grid.xdim))]) - else: - raise NotImplementedError("Field.write only implemented for RectilinearZGrid and CurvilinearZGrid") - - attrs = {"units": "seconds since " + str(self.grid.time_origin)} if self.grid.time_origin.calendar else {} - time_counter = xr.DataArray(self.grid.time, dims=["time_counter"], attrs=attrs) - vardata = xr.DataArray( - self.data.reshape((self.grid.tdim, self.grid.zdim, self.grid.ydim, self.grid.xdim)), - dims=["time_counter", vname_depth, "y", "x"], - ) - # Create xarray Dataset and output to netCDF format - attrs = {"parcels_mesh": self.grid.mesh} - dset = xr.Dataset( - {varname: vardata}, - coords={"nav_lon": nav_lon, "nav_lat": nav_lat, "time_counter": time_counter, vname_depth: self.grid.depth}, - attrs=attrs, - ) - dset.to_netcdf(filepath, unlimited_dims="time_counter") - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def rescale_and_set_minmax(self, *args, **kwargs): - return self._rescale_and_set_minmax(*args, **kwargs) - - def _rescale_and_set_minmax(self, data): - data[np.isnan(data)] = 0 - if self._scaling_factor: - data *= self._scaling_factor - if self.vmin is not None: - data[data < self.vmin] = 0 - if self.vmax is not None: - data[data > self.vmax] = 0 - return data - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def data_concatenate(self, *args, **kwargs): - return self._data_concatenate(*args, **kwargs) - - def _data_concatenate(self, data, data_to_concat, tindex): - if data[tindex] is not None: - if isinstance(data, np.ndarray): - data[tindex] = None - elif isinstance(data, list): - del data[tindex] - lib = np if isinstance(data, np.ndarray) else da - if tindex == 0: - data = lib.concatenate([data_to_concat, data[tindex + 1 :, :]], axis=0) - elif tindex == 1: - data = lib.concatenate([data[:tindex, :], data_to_concat], axis=0) - else: - raise ValueError("data_concatenate is used for computeTimeChunk, with tindex in [0, 1]") - return data - - def computeTimeChunk(self, data, tindex): - g = self.grid - timestamp = self.timestamps - if timestamp is not None: - summedlen = np.cumsum([len(ls) for ls in self.timestamps]) - if g._ti + tindex >= summedlen[-1]: - ti = g._ti + tindex - summedlen[-1] - else: - ti = g._ti + tindex - timestamp = self.timestamps[np.where(ti < summedlen)[0][0]] - - rechunk_callback_fields = self._chunk_setup if isinstance(tindex, list) else None - filebuffer = self._field_fb_class( - self._dataFiles[g._ti + tindex], - self.dimensions, - self.indices, - netcdf_engine=self.netcdf_engine, - timestamp=timestamp, - interp_method=self.interp_method, - data_full_zdim=self.data_full_zdim, - chunksize=self.chunksize, - cast_data_dtype=self.cast_data_dtype, - rechunk_callback_fields=rechunk_callback_fields, - chunkdims_name_map=self.netcdf_chunkdims_name_map, - ) - filebuffer.__enter__() - time_data = filebuffer.time - time_data = g.time_origin.reltime(time_data) - filebuffer.ti = (time_data <= g.time[tindex]).argmin() - 1 - if self.netcdf_engine != "xarray": - filebuffer.name = filebuffer.parse_name(self.filebuffername) - buffer_data = filebuffer.data - lib = np if isinstance(buffer_data, np.ndarray) else da - if len(buffer_data.shape) == 2: - buffer_data = lib.reshape(buffer_data, sum(((1, 1), buffer_data.shape), ())) - elif len(buffer_data.shape) == 3 and g.zdim > 1: - buffer_data = lib.reshape(buffer_data, sum(((1,), buffer_data.shape), ())) - elif len(buffer_data.shape) == 3: - buffer_data = lib.reshape( - buffer_data, - sum( - ( - ( - buffer_data.shape[0], - 1, - ), - buffer_data.shape[1:], - ), - (), - ), - ) - data = self._data_concatenate(data, buffer_data, tindex) - self.filebuffers[tindex] = filebuffer - return data - - -class VectorField: - """Class VectorField stores 2 or 3 fields which defines together a vector field. - This enables to interpolate them as one single vector field in the kernels. - - Parameters - ---------- - name : str - Name of the vector field - U : parcels.field.Field - field defining the zonal component - V : parcels.field.Field - field defining the meridional component - W : parcels.field.Field - field defining the vertical component (default: None) - """ - - def __init__(self, name: str, U: Field, V: Field, W: Field | None = None): - self.name = name - self.U = U - self.V = V - self.W = W - if self.U.gridindexingtype == "croco" and self.W: - self.vector_type: VectorType = "3DSigma" - elif self.W: - self.vector_type = "3D" - else: - self.vector_type = "2D" - self.gridindexingtype = U.gridindexingtype - if self.U.interp_method == "cgrid_velocity": - assert self.V.interp_method == "cgrid_velocity", "Interpolation methods of U and V are not the same." - assert self._check_grid_dimensions(U.grid, V.grid), "Dimensions of U and V are not the same." - if W is not None and self.U.gridindexingtype != "croco": - assert W.interp_method == "cgrid_velocity", "Interpolation methods of U and W are not the same." - assert self._check_grid_dimensions(U.grid, W.grid), "Dimensions of U and W are not the same." - - def __repr__(self): - return f"""<{type(self).__name__}> - name: {self.name!r} - U: {default_repr(self.U)} - V: {default_repr(self.V)} - W: {default_repr(self.W)}""" - - @staticmethod - def _check_grid_dimensions(grid1, grid2): - return ( - np.allclose(grid1.lon, grid2.lon) - and np.allclose(grid1.lat, grid2.lat) - and np.allclose(grid1.depth, grid2.depth) - and np.allclose(grid1.time_full, grid2.time_full) - ) - - @deprecated_made_private # TODO: Remove 6 months after v3.2.0 - def dist(self, *args, **kwargs): - raise NotImplementedError - - @deprecated_made_private # TODO: Remove 6 months after v3.2.0 - def jacobian(self, *args, **kwargs): - raise NotImplementedError - - def spatial_c_grid_interpolation2D(self, ti, z, y, x, time, particle=None, applyConversion=True): - grid = self.U.grid - (_, eta, xsi, zi, yi, xi) = self.U._search_indices(time, z, y, x, ti, particle=particle) - - if grid._gtype in [GridType.RectilinearSGrid, GridType.RectilinearZGrid]: - px = np.array([grid.lon[xi], grid.lon[xi + 1], grid.lon[xi + 1], grid.lon[xi]]) - py = np.array([grid.lat[yi], grid.lat[yi], grid.lat[yi + 1], grid.lat[yi + 1]]) - else: - px = np.array([grid.lon[yi, xi], grid.lon[yi, xi + 1], grid.lon[yi + 1, xi + 1], grid.lon[yi + 1, xi]]) - py = np.array([grid.lat[yi, xi], grid.lat[yi, xi + 1], grid.lat[yi + 1, xi + 1], grid.lat[yi + 1, xi]]) - - if grid.mesh == "spherical": - px[0] = px[0] + 360 if px[0] < x - 225 else px[0] - px[0] = px[0] - 360 if px[0] > x + 225 else px[0] - px[1:] = np.where(px[1:] - px[0] > 180, px[1:] - 360, px[1:]) - px[1:] = np.where(-px[1:] + px[0] > 180, px[1:] + 360, px[1:]) - xx = (1 - xsi) * (1 - eta) * px[0] + xsi * (1 - eta) * px[1] + xsi * eta * px[2] + (1 - xsi) * eta * px[3] - assert abs(xx - x) < 1e-4 - c1 = i_u._geodetic_distance(py[0], py[1], px[0], px[1], grid.mesh, np.dot(i_u.phi2D_lin(0.0, xsi), py)) - c2 = i_u._geodetic_distance(py[1], py[2], px[1], px[2], grid.mesh, np.dot(i_u.phi2D_lin(eta, 1.0), py)) - c3 = i_u._geodetic_distance(py[2], py[3], px[2], px[3], grid.mesh, np.dot(i_u.phi2D_lin(1.0, xsi), py)) - c4 = i_u._geodetic_distance(py[3], py[0], px[3], px[0], grid.mesh, np.dot(i_u.phi2D_lin(eta, 0.0), py)) - if grid.zdim == 1: - if self.gridindexingtype == "nemo": - U0 = self.U.data[ti, yi + 1, xi] * c4 - U1 = self.U.data[ti, yi + 1, xi + 1] * c2 - V0 = self.V.data[ti, yi, xi + 1] * c1 - V1 = self.V.data[ti, yi + 1, xi + 1] * c3 - elif self.gridindexingtype in ["mitgcm", "croco"]: - U0 = self.U.data[ti, yi, xi] * c4 - U1 = self.U.data[ti, yi, xi + 1] * c2 - V0 = self.V.data[ti, yi, xi] * c1 - V1 = self.V.data[ti, yi + 1, xi] * c3 - else: - if self.gridindexingtype == "nemo": - U0 = self.U.data[ti, zi, yi + 1, xi] * c4 - U1 = self.U.data[ti, zi, yi + 1, xi + 1] * c2 - V0 = self.V.data[ti, zi, yi, xi + 1] * c1 - V1 = self.V.data[ti, zi, yi + 1, xi + 1] * c3 - elif self.gridindexingtype in ["mitgcm", "croco"]: - U0 = self.U.data[ti, zi, yi, xi] * c4 - U1 = self.U.data[ti, zi, yi, xi + 1] * c2 - V0 = self.V.data[ti, zi, yi, xi] * c1 - V1 = self.V.data[ti, zi, yi + 1, xi] * c3 - U = (1 - xsi) * U0 + xsi * U1 - V = (1 - eta) * V0 + eta * V1 - rad = np.pi / 180.0 - deg2m = 1852 * 60.0 - if applyConversion: - meshJac = (deg2m * deg2m * math.cos(rad * y)) if grid.mesh == "spherical" else 1 - else: - meshJac = deg2m if grid.mesh == "spherical" else 1 - - jac = i_u._compute_jacobian_determinant(py, px, eta, xsi) * meshJac - - u = ( - (-(1 - eta) * U - (1 - xsi) * V) * px[0] - + ((1 - eta) * U - xsi * V) * px[1] - + (eta * U + xsi * V) * px[2] - + (-eta * U + (1 - xsi) * V) * px[3] - ) / jac - v = ( - (-(1 - eta) * U - (1 - xsi) * V) * py[0] - + ((1 - eta) * U - xsi * V) * py[1] - + (eta * U + xsi * V) * py[2] - + (-eta * U + (1 - xsi) * V) * py[3] - ) / jac - if isinstance(u, da.core.Array): - u = u.compute() - v = v.compute() - return (u, v) - - def spatial_c_grid_interpolation3D_full(self, ti, z, y, x, time, particle=None): - grid = self.U.grid - (zeta, eta, xsi, zi, yi, xi) = self.U._search_indices(time, z, y, x, ti, particle=particle) - - if grid._gtype in [GridType.RectilinearSGrid, GridType.RectilinearZGrid]: - px = np.array([grid.lon[xi], grid.lon[xi + 1], grid.lon[xi + 1], grid.lon[xi]]) - py = np.array([grid.lat[yi], grid.lat[yi], grid.lat[yi + 1], grid.lat[yi + 1]]) - else: - px = np.array([grid.lon[yi, xi], grid.lon[yi, xi + 1], grid.lon[yi + 1, xi + 1], grid.lon[yi + 1, xi]]) - py = np.array([grid.lat[yi, xi], grid.lat[yi, xi + 1], grid.lat[yi + 1, xi + 1], grid.lat[yi + 1, xi]]) - - if grid.mesh == "spherical": - px[0] = px[0] + 360 if px[0] < x - 225 else px[0] - px[0] = px[0] - 360 if px[0] > x + 225 else px[0] - px[1:] = np.where(px[1:] - px[0] > 180, px[1:] - 360, px[1:]) - px[1:] = np.where(-px[1:] + px[0] > 180, px[1:] + 360, px[1:]) - xx = (1 - xsi) * (1 - eta) * px[0] + xsi * (1 - eta) * px[1] + xsi * eta * px[2] + (1 - xsi) * eta * px[3] - assert abs(xx - x) < 1e-4 - - px = np.concatenate((px, px)) - py = np.concatenate((py, py)) - if grid._z4d: - pz = np.array( - [ - grid.depth[0, zi, yi, xi], - grid.depth[0, zi, yi, xi + 1], - grid.depth[0, zi, yi + 1, xi + 1], - grid.depth[0, zi, yi + 1, xi], - grid.depth[0, zi + 1, yi, xi], - grid.depth[0, zi + 1, yi, xi + 1], - grid.depth[0, zi + 1, yi + 1, xi + 1], - grid.depth[0, zi + 1, yi + 1, xi], - ] - ) - else: - pz = np.array( - [ - grid.depth[zi, yi, xi], - grid.depth[zi, yi, xi + 1], - grid.depth[zi, yi + 1, xi + 1], - grid.depth[zi, yi + 1, xi], - grid.depth[zi + 1, yi, xi], - grid.depth[zi + 1, yi, xi + 1], - grid.depth[zi + 1, yi + 1, xi + 1], - grid.depth[zi + 1, yi + 1, xi], - ] - ) - - u0 = self.U.data[ti, zi, yi + 1, xi] - u1 = self.U.data[ti, zi, yi + 1, xi + 1] - v0 = self.V.data[ti, zi, yi, xi + 1] - v1 = self.V.data[ti, zi, yi + 1, xi + 1] - w0 = self.W.data[ti, zi, yi + 1, xi + 1] - w1 = self.W.data[ti, zi + 1, yi + 1, xi + 1] - - U0 = u0 * i_u.jacobian3D_lin_face(pz, py, px, zeta, eta, 0, "zonal", grid.mesh) - U1 = u1 * i_u.jacobian3D_lin_face(pz, py, px, zeta, eta, 1, "zonal", grid.mesh) - V0 = v0 * i_u.jacobian3D_lin_face(pz, py, px, zeta, 0, xsi, "meridional", grid.mesh) - V1 = v1 * i_u.jacobian3D_lin_face(pz, py, px, zeta, 1, xsi, "meridional", grid.mesh) - W0 = w0 * i_u.jacobian3D_lin_face(pz, py, px, 0, eta, xsi, "vertical", grid.mesh) - W1 = w1 * i_u.jacobian3D_lin_face(pz, py, px, 1, eta, xsi, "vertical", grid.mesh) - - # Computing fluxes in half left hexahedron -> flux_u05 - xx = [ - px[0], - (px[0] + px[1]) / 2, - (px[2] + px[3]) / 2, - px[3], - px[4], - (px[4] + px[5]) / 2, - (px[6] + px[7]) / 2, - px[7], - ] - yy = [ - py[0], - (py[0] + py[1]) / 2, - (py[2] + py[3]) / 2, - py[3], - py[4], - (py[4] + py[5]) / 2, - (py[6] + py[7]) / 2, - py[7], - ] - zz = [ - pz[0], - (pz[0] + pz[1]) / 2, - (pz[2] + pz[3]) / 2, - pz[3], - pz[4], - (pz[4] + pz[5]) / 2, - (pz[6] + pz[7]) / 2, - pz[7], - ] - flux_u0 = u0 * i_u.jacobian3D_lin_face(zz, yy, xx, 0.5, 0.5, 0, "zonal", grid.mesh) - flux_v0_halfx = v0 * i_u.jacobian3D_lin_face(zz, yy, xx, 0.5, 0, 0.5, "meridional", grid.mesh) - flux_v1_halfx = v1 * i_u.jacobian3D_lin_face(zz, yy, xx, 0.5, 1, 0.5, "meridional", grid.mesh) - flux_w0_halfx = w0 * i_u.jacobian3D_lin_face(zz, yy, xx, 0, 0.5, 0.5, "vertical", grid.mesh) - flux_w1_halfx = w1 * i_u.jacobian3D_lin_face(zz, yy, xx, 1, 0.5, 0.5, "vertical", grid.mesh) - flux_u05 = flux_u0 + flux_v0_halfx - flux_v1_halfx + flux_w0_halfx - flux_w1_halfx - - # Computing fluxes in half front hexahedron -> flux_v05 - xx = [ - px[0], - px[1], - (px[1] + px[2]) / 2, - (px[0] + px[3]) / 2, - px[4], - px[5], - (px[5] + px[6]) / 2, - (px[4] + px[7]) / 2, - ] - yy = [ - py[0], - py[1], - (py[1] + py[2]) / 2, - (py[0] + py[3]) / 2, - py[4], - py[5], - (py[5] + py[6]) / 2, - (py[4] + py[7]) / 2, - ] - zz = [ - pz[0], - pz[1], - (pz[1] + pz[2]) / 2, - (pz[0] + pz[3]) / 2, - pz[4], - pz[5], - (pz[5] + pz[6]) / 2, - (pz[4] + pz[7]) / 2, - ] - flux_u0_halfy = u0 * i_u.jacobian3D_lin_face(zz, yy, xx, 0.5, 0.5, 0, "zonal", grid.mesh) - flux_u1_halfy = u1 * i_u.jacobian3D_lin_face(zz, yy, xx, 0.5, 0.5, 1, "zonal", grid.mesh) - flux_v0 = v0 * i_u.jacobian3D_lin_face(zz, yy, xx, 0.5, 0, 0.5, "meridional", grid.mesh) - flux_w0_halfy = w0 * i_u.jacobian3D_lin_face(zz, yy, xx, 0, 0.5, 0.5, "vertical", grid.mesh) - flux_w1_halfy = w1 * i_u.jacobian3D_lin_face(zz, yy, xx, 1, 0.5, 0.5, "vertical", grid.mesh) - flux_v05 = flux_u0_halfy - flux_u1_halfy + flux_v0 + flux_w0_halfy - flux_w1_halfy - - # Computing fluxes in half lower hexahedron -> flux_w05 - xx = [ - px[0], - px[1], - px[2], - px[3], - (px[0] + px[4]) / 2, - (px[1] + px[5]) / 2, - (px[2] + px[6]) / 2, - (px[3] + px[7]) / 2, - ] - yy = [ - py[0], - py[1], - py[2], - py[3], - (py[0] + py[4]) / 2, - (py[1] + py[5]) / 2, - (py[2] + py[6]) / 2, - (py[3] + py[7]) / 2, - ] - zz = [ - pz[0], - pz[1], - pz[2], - pz[3], - (pz[0] + pz[4]) / 2, - (pz[1] + pz[5]) / 2, - (pz[2] + pz[6]) / 2, - (pz[3] + pz[7]) / 2, - ] - flux_u0_halfz = u0 * i_u.jacobian3D_lin_face(zz, yy, xx, 0.5, 0.5, 0, "zonal", grid.mesh) - flux_u1_halfz = u1 * i_u.jacobian3D_lin_face(zz, yy, xx, 0.5, 0.5, 1, "zonal", grid.mesh) - flux_v0_halfz = v0 * i_u.jacobian3D_lin_face(zz, yy, xx, 0.5, 0, 0.5, "meridional", grid.mesh) - flux_v1_halfz = v1 * i_u.jacobian3D_lin_face(zz, yy, xx, 0.5, 1, 0.5, "meridional", grid.mesh) - flux_w0 = w0 * i_u.jacobian3D_lin_face(zz, yy, xx, 0, 0.5, 0.5, "vertical", grid.mesh) - flux_w05 = flux_u0_halfz - flux_u1_halfz + flux_v0_halfz - flux_v1_halfz + flux_w0 - - surf_u05 = i_u.jacobian3D_lin_face(pz, py, px, 0.5, 0.5, 0.5, "zonal", grid.mesh) - jac_u05 = i_u.jacobian3D_lin_face(pz, py, px, zeta, eta, 0.5, "zonal", grid.mesh) - U05 = flux_u05 / surf_u05 * jac_u05 - - surf_v05 = i_u.jacobian3D_lin_face(pz, py, px, 0.5, 0.5, 0.5, "meridional", grid.mesh) - jac_v05 = i_u.jacobian3D_lin_face(pz, py, px, zeta, 0.5, xsi, "meridional", grid.mesh) - V05 = flux_v05 / surf_v05 * jac_v05 - - surf_w05 = i_u.jacobian3D_lin_face(pz, py, px, 0.5, 0.5, 0.5, "vertical", grid.mesh) - jac_w05 = i_u.jacobian3D_lin_face(pz, py, px, 0.5, eta, xsi, "vertical", grid.mesh) - W05 = flux_w05 / surf_w05 * jac_w05 - - jac = i_u.jacobian3D_lin(pz, py, px, zeta, eta, xsi, grid.mesh) - dxsidt = i_u.interpolate(i_u.phi1D_quad, [U0, U05, U1], xsi) / jac - detadt = i_u.interpolate(i_u.phi1D_quad, [V0, V05, V1], eta) / jac - dzetdt = i_u.interpolate(i_u.phi1D_quad, [W0, W05, W1], zeta) / jac - - dphidxsi, dphideta, dphidzet = i_u.dphidxsi3D_lin(zeta, eta, xsi) - - u = np.dot(dphidxsi, px) * dxsidt + np.dot(dphideta, px) * detadt + np.dot(dphidzet, px) * dzetdt - v = np.dot(dphidxsi, py) * dxsidt + np.dot(dphideta, py) * detadt + np.dot(dphidzet, py) * dzetdt - w = np.dot(dphidxsi, pz) * dxsidt + np.dot(dphideta, pz) * detadt + np.dot(dphidzet, pz) * dzetdt - - if isinstance(u, da.core.Array): - u = u.compute() - v = v.compute() - w = w.compute() - return (u, v, w) - - def spatial_c_grid_interpolation3D(self, ti, z, y, x, time, particle=None, applyConversion=True): - """Perform C grid interpolation in 3D. :: - - +---+---+---+ - | |V1 | | - +---+---+---+ - |U0 | |U1 | - +---+---+---+ - | |V0 | | - +---+---+---+ - - The interpolation is done in the following by - interpolating linearly U depending on the longitude coordinate and - interpolating linearly V depending on the latitude coordinate. - Curvilinear grids are treated properly, since the element is projected to a rectilinear parent element. - """ - if self.U.grid._gtype in [GridType.RectilinearSGrid, GridType.CurvilinearSGrid]: - (u, v, w) = self.spatial_c_grid_interpolation3D_full(ti, z, y, x, time, particle=particle) - else: - if self.gridindexingtype == "croco": - z = _croco_from_z_to_sigma_scipy(self.fieldset, time, z, y, x, particle=particle) - (u, v) = self.spatial_c_grid_interpolation2D(ti, z, y, x, time, particle=particle) - w = self.W.eval(time, z, y, x, particle=particle, applyConversion=False) - if applyConversion: - w = self.W.units.to_target(w, z, y, x) - return (u, v, w) - - def _is_land2D(self, di, yi, xi): - if self.U.data.ndim == 3: - if di < np.shape(self.U.data)[0]: - return np.isclose(self.U.data[di, yi, xi], 0.0) and np.isclose(self.V.data[di, yi, xi], 0.0) - else: - return True - else: - if di < self.U.grid.zdim and yi < np.shape(self.U.data)[-2] and xi < np.shape(self.U.data)[-1]: - return np.isclose(self.U.data[0, di, yi, xi], 0.0) and np.isclose(self.V.data[0, di, yi, xi], 0.0) - else: - return True - - def spatial_slip_interpolation(self, ti, z, y, x, time, particle=None, applyConversion=True): - (zeta, eta, xsi, zi, yi, xi) = self.U._search_indices(time, z, y, x, ti, particle=particle) - di = ti if self.U.grid.zdim == 1 else zi # general third dimension - - f_u, f_v, f_w = 1, 1, 1 - if ( - self._is_land2D(di, yi, xi) - and self._is_land2D(di, yi, xi + 1) - and self._is_land2D(di + 1, yi, xi) - and self._is_land2D(di + 1, yi, xi + 1) - and eta > 0 - ): - if self.U.interp_method == "partialslip": - f_u = f_u * (0.5 + 0.5 * eta) / eta - if self.vector_type == "3D": - f_w = f_w * (0.5 + 0.5 * eta) / eta - elif self.U.interp_method == "freeslip": - f_u = f_u / eta - if self.vector_type == "3D": - f_w = f_w / eta - if ( - self._is_land2D(di, yi + 1, xi) - and self._is_land2D(di, yi + 1, xi + 1) - and self._is_land2D(di + 1, yi + 1, xi) - and self._is_land2D(di + 1, yi + 1, xi + 1) - and eta < 1 - ): - if self.U.interp_method == "partialslip": - f_u = f_u * (1 - 0.5 * eta) / (1 - eta) - if self.vector_type == "3D": - f_w = f_w * (1 - 0.5 * eta) / (1 - eta) - elif self.U.interp_method == "freeslip": - f_u = f_u / (1 - eta) - if self.vector_type == "3D": - f_w = f_w / (1 - eta) - if ( - self._is_land2D(di, yi, xi) - and self._is_land2D(di, yi + 1, xi) - and self._is_land2D(di + 1, yi, xi) - and self._is_land2D(di + 1, yi + 1, xi) - and xsi > 0 - ): - if self.U.interp_method == "partialslip": - f_v = f_v * (0.5 + 0.5 * xsi) / xsi - if self.vector_type == "3D": - f_w = f_w * (0.5 + 0.5 * xsi) / xsi - elif self.U.interp_method == "freeslip": - f_v = f_v / xsi - if self.vector_type == "3D": - f_w = f_w / xsi - if ( - self._is_land2D(di, yi, xi + 1) - and self._is_land2D(di, yi + 1, xi + 1) - and self._is_land2D(di + 1, yi, xi + 1) - and self._is_land2D(di + 1, yi + 1, xi + 1) - and xsi < 1 - ): - if self.U.interp_method == "partialslip": - f_v = f_v * (1 - 0.5 * xsi) / (1 - xsi) - if self.vector_type == "3D": - f_w = f_w * (1 - 0.5 * xsi) / (1 - xsi) - elif self.U.interp_method == "freeslip": - f_v = f_v / (1 - xsi) - if self.vector_type == "3D": - f_w = f_w / (1 - xsi) - if self.U.grid.zdim > 1: - if ( - self._is_land2D(di, yi, xi) - and self._is_land2D(di, yi, xi + 1) - and self._is_land2D(di, yi + 1, xi) - and self._is_land2D(di, yi + 1, xi + 1) - and zeta > 0 - ): - if self.U.interp_method == "partialslip": - f_u = f_u * (0.5 + 0.5 * zeta) / zeta - f_v = f_v * (0.5 + 0.5 * zeta) / zeta - elif self.U.interp_method == "freeslip": - f_u = f_u / zeta - f_v = f_v / zeta - if ( - self._is_land2D(di + 1, yi, xi) - and self._is_land2D(di + 1, yi, xi + 1) - and self._is_land2D(di + 1, yi + 1, xi) - and self._is_land2D(di + 1, yi + 1, xi + 1) - and zeta < 1 - ): - if self.U.interp_method == "partialslip": - f_u = f_u * (1 - 0.5 * zeta) / (1 - zeta) - f_v = f_v * (1 - 0.5 * zeta) / (1 - zeta) - elif self.U.interp_method == "freeslip": - f_u = f_u / (1 - zeta) - f_v = f_v / (1 - zeta) - - u = f_u * self.U.eval(time, z, y, x, particle, applyConversion=applyConversion) - v = f_v * self.V.eval(time, z, y, x, particle, applyConversion=applyConversion) - if self.vector_type == "3D": - w = f_w * self.W.eval(time, z, y, x, particle, applyConversion=applyConversion) - return u, v, w - else: - return u, v - - def eval(self, time, z, y, x, particle=None, applyConversion=True): - if self.U.interp_method not in ["cgrid_velocity", "partialslip", "freeslip"]: - u = self.U.eval(time, z, y, x, particle=particle, applyConversion=False) - v = self.V.eval(time, z, y, x, particle=particle, applyConversion=False) - if applyConversion: - u = self.U.units.to_target(u, z, y, x) - v = self.V.units.to_target(v, z, y, x) - if "3D" in self.vector_type: - w = self.W.eval(time, z, y, x, particle=particle, applyConversion=False) - if applyConversion: - w = self.W.units.to_target(w, z, y, x) - return (u, v, w) - else: - return (u, v) - else: - interp = { - "cgrid_velocity": { - "2D": self.spatial_c_grid_interpolation2D, - "3D": self.spatial_c_grid_interpolation3D, - }, - "partialslip": {"2D": self.spatial_slip_interpolation, "3D": self.spatial_slip_interpolation}, - "freeslip": {"2D": self.spatial_slip_interpolation, "3D": self.spatial_slip_interpolation}, - } - grid = self.U.grid - (ti, periods) = self.U._time_index(time) - time -= periods * (grid.time_full[-1] - grid.time_full[0]) - if ti < grid.tdim - 1 and time > grid.time[ti]: - t0 = grid.time[ti] - t1 = grid.time[ti + 1] - if "3D" in self.vector_type: - (u0, v0, w0) = interp[self.U.interp_method]["3D"]( - ti, z, y, x, time, particle=particle, applyConversion=applyConversion - ) - (u1, v1, w1) = interp[self.U.interp_method]["3D"]( - ti + 1, z, y, x, time, particle=particle, applyConversion=applyConversion - ) - w = w0 + (w1 - w0) * ((time - t0) / (t1 - t0)) - else: - (u0, v0) = interp[self.U.interp_method]["2D"]( - ti, z, y, x, time, particle=particle, applyConversion=applyConversion - ) - (u1, v1) = interp[self.U.interp_method]["2D"]( - ti + 1, z, y, x, time, particle=particle, applyConversion=applyConversion - ) - u = u0 + (u1 - u0) * ((time - t0) / (t1 - t0)) - v = v0 + (v1 - v0) * ((time - t0) / (t1 - t0)) - if "3D" in self.vector_type: - return (u, v, w) - else: - return (u, v) - else: - # Skip temporal interpolation if time is outside - # of the defined time range or if we have hit an - # exact value in the time array. - if "3D" in self.vector_type: - return interp[self.U.interp_method]["3D"]( - ti, z, y, x, grid.time[ti], particle=particle, applyConversion=applyConversion - ) - else: - return interp[self.U.interp_method]["2D"]( - ti, z, y, x, grid.time[ti], particle=particle, applyConversion=applyConversion - ) - - def __getitem__(self, key): - try: - if _isParticle(key): - return self.eval(key.time, key.depth, key.lat, key.lon, key) - else: - return self.eval(*key) - except tuple(AllParcelsErrorCodes.keys()) as error: - return _deal_with_errors(error, key, vector_type=self.vector_type) - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def ccode_eval(self, *args, **kwargs): - return self._ccode_eval(*args, **kwargs) - - def _ccode_eval(self, varU, varV, varW, U, V, W, t, z, y, x): - ccode_str = "" - if "3D" in self.vector_type: - ccode_str = ( - f"temporal_interpolationUVW({t}, {z}, {y}, {x}, {U.ccode_name}, {V.ccode_name}, {W.ccode_name}, " - + "&particles->ti[pnum*ngrid], &particles->zi[pnum*ngrid], &particles->yi[pnum*ngrid], &particles->xi[pnum*ngrid]," - + f"&{varU}, &{varV}, &{varW}, {U.interp_method.upper()}, {U.gridindexingtype.upper()})" - ) - else: - ccode_str = ( - f"temporal_interpolationUV({t}, {z}, {y}, {x}, {U.ccode_name}, {V.ccode_name}, " - + "&particles->ti[pnum*ngrid], &particles->zi[pnum*ngrid], &particles->yi[pnum*ngrid], &particles->xi[pnum*ngrid]," - + f" &{varU}, &{varV}, {U.interp_method.upper()}, {U.gridindexingtype.upper()})" - ) - return ccode_str - - -class DeferredArray: - """Class used for throwing error when Field.data is not read in deferred loading mode.""" - - data_shape = () - - def __init__(self): - self.data_shape = (1,) - - def compute_shape(self, xdim, ydim, zdim, tdim, tslices): - if zdim == 1 and tdim == 1: - self.data_shape = (tslices, 1, ydim, xdim) - elif zdim > 1 or tdim > 1: - if zdim > 1: - self.data_shape = (1, zdim, ydim, xdim) - else: - self.data_shape = (max(tdim, tslices), 1, ydim, xdim) - else: - self.data_shape = (tdim, zdim, ydim, xdim) - return self.data_shape - - def __getitem__(self, key): - raise RuntimeError( - "Field is in deferred_load mode, so can't be accessed. Use .computeTimeChunk() method to force loading of data" - ) - - -class NestedField(list): - """NestedField is a class that allows for interpolation of fields on different grids of potentially varying resolution. - - The NestedField class is a list of Fields where the first Field that contains the particle within the domain is then used for interpolation. - This induces that the order of the fields in the list matters. - Each one it its turn, a field is interpolated: if the interpolation succeeds or if an error other - than `ErrorOutOfBounds` is thrown, the function is stopped. Otherwise, next field is interpolated. - NestedField returns an `ErrorOutOfBounds` only if last field is as well out of boundaries. - NestedField is composed of either Fields or VectorFields. - - Parameters - ---------- - name : str - Name of the NestedField - F : list of Field - List of fields (order matters). F can be a scalar Field, a VectorField, or the zonal component (U) of the VectorField - V : list of Field - List of fields defining the meridional component of a VectorField, if F is the zonal component. (default: None) - W : list of Field - List of fields defining the vertical component of a VectorField, if F and V are the zonal and meridional components (default: None) - - - Examples - -------- - See `here <../examples/tutorial_NestedFields.ipynb>`__ - for a detailed tutorial - - """ - - def __init__(self, name: str, F, V=None, W=None): - if V is None: - if isinstance(F[0], VectorField): - vector_type = F[0].vector_type - for Fi in F: - assert isinstance(Fi, Field) or ( - isinstance(Fi, VectorField) and Fi.vector_type == vector_type - ), "Components of a NestedField must be Field or VectorField" - self.append(Fi) - elif W is None: - for i, Fi, Vi in zip(range(len(F)), F, V, strict=True): - assert isinstance(Fi, Field) and isinstance( - Vi, Field - ), "F, and V components of a NestedField must be Field" - self.append(VectorField(f"{name}_{i}", Fi, Vi)) - else: - for i, Fi, Vi, Wi in zip(range(len(F)), F, V, W, strict=True): - assert ( - isinstance(Fi, Field) and isinstance(Vi, Field) and isinstance(Wi, Field) - ), "F, V and W components of a NestedField must be Field" - self.append(VectorField(f"{name}_{i}", Fi, Vi, Wi)) - self.name = name - - def __getitem__(self, key): - if isinstance(key, int): - return list.__getitem__(self, key) - else: - for iField in range(len(self)): - try: - if _isParticle(key): - val = list.__getitem__(self, iField).eval(key.time, key.depth, key.lat, key.lon, particle=None) - else: - val = list.__getitem__(self, iField).eval(*key) - break - except tuple(AllParcelsErrorCodes.keys()) as error: - if iField == len(self) - 1: - vector_type = self[iField].vector_type if isinstance(self[iField], VectorField) else None - return _deal_with_errors(error, key, vector_type=vector_type) - else: - pass - return val diff --git a/parcels/fieldfilebuffer.py b/parcels/fieldfilebuffer.py deleted file mode 100644 index 8c3a55495..000000000 --- a/parcels/fieldfilebuffer.py +++ /dev/null @@ -1,862 +0,0 @@ -import datetime -import math -import warnings - -import dask.array as da -import numpy as np -import psutil -import xarray as xr -from dask import config as da_conf -from dask import utils as da_utils -from netCDF4 import Dataset as ncDataset - -from parcels._typing import InterpMethodOption -from parcels.tools.converters import convert_xarray_time_units -from parcels.tools.statuscodes import DaskChunkingError -from parcels.tools.warnings import FileWarning - - -class _FileBuffer: - def __init__( - self, - filename, - dimensions, - indices, - timestamp=None, - interp_method: InterpMethodOption = "linear", - data_full_zdim=None, - cast_data_dtype=np.float32, - gridindexingtype="nemo", - **kwargs, - ): - self.filename = filename - self.dimensions = dimensions # Dict with dimension keys for file data - self.indices = indices - self.dataset = None - self.timestamp = timestamp - self.cast_data_dtype = cast_data_dtype - self.ti = None - self.interp_method = interp_method - self.gridindexingtype = gridindexingtype - self.data_full_zdim = data_full_zdim - if ("lon" in self.indices) or ("lat" in self.indices): - self.nolonlatindices = False - else: - self.nolonlatindices = True - - -class NetcdfFileBuffer(_FileBuffer): - def __init__(self, *args, **kwargs): - self.lib = np - self.netcdf_engine = kwargs.pop("netcdf_engine", "netcdf4") - super().__init__(*args, **kwargs) - - def __enter__(self): - try: - # Unfortunately we need to do if-else here, cause the lock-parameter is either False or a Lock-object - # (which we would rather want to have being auto-managed). - # If 'lock' is not specified, the Lock-object is auto-created and managed by xarray internally. - self.dataset = xr.open_dataset(str(self.filename), decode_cf=True, engine=self.netcdf_engine) - self.dataset["decoded"] = True - except: - warnings.warn( - f"File {self.filename} could not be decoded properly by xarray (version {xr.__version__}). " - "It will be opened with no decoding. Filling values might be wrongly parsed.", - FileWarning, - stacklevel=2, - ) - - self.dataset = xr.open_dataset(str(self.filename), decode_cf=False, engine=self.netcdf_engine) - self.dataset["decoded"] = False - for inds in self.indices.values(): - if type(inds) not in [list, range]: - raise RuntimeError("Indices for field subsetting need to be a list") - return self - - def __exit__(self, type, value, traceback): - self.close() - - def close(self): - if self.dataset is not None: - self.dataset.close() - self.dataset = None - - def parse_name(self, name): - if isinstance(name, list): - for nm in name: - if hasattr(self.dataset, nm): - name = nm - break - if isinstance(name, list): - raise OSError("None of variables in list found in file") - return name - - @property - def latlon(self): - lon = self.dataset[self.dimensions["lon"]] - lat = self.dataset[self.dimensions["lat"]] - if self.nolonlatindices and self.gridindexingtype not in ["croco"]: - if len(lon.shape) < 3: - lon_subset = np.array(lon) - lat_subset = np.array(lat) - elif len(lon.shape) == 3: # some lon, lat have a time dimension 1 - lon_subset = np.array(lon[0, :, :]) - lat_subset = np.array(lat[0, :, :]) - elif len(lon.shape) == 4: # some lon, lat have a time and depth dimension 1 - lon_subset = np.array(lon[0, 0, :, :]) - lat_subset = np.array(lat[0, 0, :, :]) - else: - xdim = lon.size if len(lon.shape) == 1 else lon.shape[-1] - ydim = lat.size if len(lat.shape) == 1 else lat.shape[-2] - if self.gridindexingtype in ["croco"]: - xdim -= 1 - ydim -= 1 - self.indices["lon"] = self.indices["lon"] if "lon" in self.indices else range(xdim) - self.indices["lat"] = self.indices["lat"] if "lat" in self.indices else range(ydim) - if len(lon.shape) == 1: - lon_subset = np.array(lon[self.indices["lon"]]) - lat_subset = np.array(lat[self.indices["lat"]]) - elif len(lon.shape) == 2: - lon_subset = np.array(lon[self.indices["lat"], self.indices["lon"]]) - lat_subset = np.array(lat[self.indices["lat"], self.indices["lon"]]) - elif len(lon.shape) == 3: # some lon, lat have a time dimension 1 - lon_subset = np.array(lon[0, self.indices["lat"], self.indices["lon"]]) - lat_subset = np.array(lat[0, self.indices["lat"], self.indices["lon"]]) - elif len(lon.shape) == 4: # some lon, lat have a time and depth dimension 1 - lon_subset = np.array(lon[0, 0, self.indices["lat"], self.indices["lon"]]) - lat_subset = np.array(lat[0, 0, self.indices["lat"], self.indices["lon"]]) - - if len(lon.shape) > 1: # Tests if lon, lat are rectilinear but were stored in arrays - rectilinear = True - # test if all columns and rows are the same for lon and lat (in which case grid is rectilinear) - for xi in range(1, lon_subset.shape[0]): - if not np.allclose(lon_subset[0, :], lon_subset[xi, :]): - rectilinear = False - break - if rectilinear: - for yi in range(1, lat_subset.shape[1]): - if not np.allclose(lat_subset[:, 0], lat_subset[:, yi]): - rectilinear = False - break - if rectilinear: - lon_subset = lon_subset[0, :] - lat_subset = lat_subset[:, 0] - return lat_subset, lon_subset - - @property - def depth(self): - if "depth" in self.dimensions: - depth = self.dataset[self.dimensions["depth"]] - depthsize = depth.size if len(depth.shape) == 1 else depth.shape[-3] - if self.gridindexingtype in ["croco"]: - depthsize -= 1 - self.data_full_zdim = depthsize - self.indices["depth"] = self.indices["depth"] if "depth" in self.indices else range(depthsize) - if len(depth.shape) == 1: - return np.array(depth[self.indices["depth"]]) - elif len(depth.shape) == 3: - if self.nolonlatindices: - return np.array(depth[self.indices["depth"], :, :]) - else: - return np.array(depth[self.indices["depth"], self.indices["lat"], self.indices["lon"]]) - elif len(depth.shape) == 4: - if self.nolonlatindices: - return np.array(depth[:, self.indices["depth"], :, :]) - else: - return np.array(depth[:, self.indices["depth"], self.indices["lat"], self.indices["lon"]]) - else: - self.indices["depth"] = [0] - return np.zeros(1) - - @property - def depth_dimensions(self): - if "depth" in self.dimensions: - data = self.dataset[self.name] - depthsize = data.shape[-3] - self.data_full_zdim = depthsize - self.indices["depth"] = self.indices["depth"] if "depth" in self.indices else range(depthsize) - if self.nolonlatindices: - return np.empty((0, len(self.indices["depth"])) + data.shape[-2:]) - else: - return np.empty((0, len(self.indices["depth"]), len(self.indices["lat"]), len(self.indices["lon"]))) - - def _check_extend_depth(self, data, di): - return ( - self.indices["depth"][-1] == self.data_full_zdim - 1 - and data.shape[di] == self.data_full_zdim - 1 - and self.interp_method in ["bgrid_velocity", "bgrid_w_velocity", "bgrid_tracer"] - ) - - def _apply_indices(self, data, ti): - if len(data.shape) == 1: - if self.indices["depth"] is not None: - data = data[self.indices["depth"]] - elif len(data.shape) == 2: - if self.nolonlatindices: - pass - else: - data = data[self.indices["lat"], self.indices["lon"]] - elif len(data.shape) == 3: - if self._check_extend_depth(data, 0): - if self.nolonlatindices: - data = data[self.indices["depth"][:-1], :, :] - else: - data = data[self.indices["depth"][:-1], self.indices["lat"], self.indices["lon"]] - elif len(self.indices["depth"]) > 1: - if self.nolonlatindices: - data = data[self.indices["depth"], :, :] - else: - data = data[self.indices["depth"], self.indices["lat"], self.indices["lon"]] - else: - if self.nolonlatindices: - data = data[ti, :, :] - else: - data = data[ti, self.indices["lat"], self.indices["lon"]] - else: - if self._check_extend_depth(data, 1): - if self.nolonlatindices: - data = data[ti, self.indices["depth"][:-1], :, :] - else: - data = data[ti, self.indices["depth"][:-1], self.indices["lat"], self.indices["lon"]] - else: - if self.nolonlatindices: - data = data[ti, self.indices["depth"], :, :] - else: - data = data[ti, self.indices["depth"], self.indices["lat"], self.indices["lon"]] - return data - - @property - def data(self): - return self.data_access() - - def data_access(self): - data = self.dataset[self.name] - ti = range(data.shape[0]) if self.ti is None else self.ti - data = self._apply_indices(data, ti) - return np.array(data, dtype=self.cast_data_dtype) - - @property - def time(self): - return self.time_access() - - def time_access(self): - if self.timestamp is not None: - return self.timestamp - - if "time" not in self.dimensions: - return np.array([None]) - - time_da = self.dataset[self.dimensions["time"]] - convert_xarray_time_units(time_da, self.dimensions["time"]) - time = ( - np.array([time_da[self.dimensions["time"]].data]) - if len(time_da.shape) == 0 - else np.array(time_da[self.dimensions["time"]]) - ) - if isinstance(time[0], datetime.datetime): - raise NotImplementedError( - "Parcels currently only parses dates ranging from 1678 AD to 2262 AD, which are stored by xarray as np.datetime64. If you need a wider date range, please open an Issue on the parcels github page." - ) - return time - - -class DeferredNetcdfFileBuffer(NetcdfFileBuffer): - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - - -class DaskFileBuffer(NetcdfFileBuffer): - _static_name_maps = { - "time": ["time", "time_count", "time_counter", "timer_count", "t"], - "depth": [ - "depth", - "depthu", - "depthv", - "depthw", - "depths", - "deptht", - "depthx", - "depthy", - "depthz", - "z", - "z_u", - "z_v", - "z_w", - "d", - "k", - "w_dep", - "w_deps", - "Z", - "Zp1", - "Zl", - "Zu", - "level", - ], - "lat": ["lat", "nav_lat", "y", "latitude", "la", "lt", "j", "YC", "YG"], - "lon": ["lon", "nav_lon", "x", "longitude", "lo", "ln", "i", "XC", "XG"], - } - _min_dim_chunksize = 16 - - """ Class that encapsulates and manages deferred access to file data. """ - - def __init__(self, *args, **kwargs): - """ - Initializes this specific filebuffer type. As a result of using dask, the internal library is set to 'da'. - The chunksize parameter is popped from the argument list, as well as the locking-parameter and the - rechunk callback function. Also chunking-related variables are initialized. - """ - self.lib = da - self.chunksize = kwargs.pop("chunksize", "auto") - self.lock_file = kwargs.pop("lock_file", True) - self.chunk_mapping = None - self.rechunk_callback_fields = kwargs.pop("rechunk_callback_fields", None) - self.chunking_finalized = False - self.autochunkingfailed = False - super().__init__(*args, **kwargs) - - def __enter__(self): - """ - This function enters the physical file (equivalent to a 'with open(...)' statement) and returns a file object. - In Dask, with dynamic loading, this is the point where we have access to the header-information of the file. - Hence, this function initializes the dynamic loading by parsing the chunksize-argument and maps the requested - chunksizes onto the variables found in the file. For auto-chunking, educated guesses are made (e.g. with the - dask configuration file in the background) to determine the ideal chunk sizes. This is also the point - where - due to the chunking, the file is 'locked', meaning that it cannot be simultaneously accessed by - another process. This is significant in a cluster setup. - """ - if self.chunksize not in [False, None, "auto"] and type(self.chunksize) is not dict: - raise AttributeError( - "'chunksize' is of wrong type. Parameter is expected to be a dict per data dimension, or be False, None or 'auto'." - ) - if isinstance(self.chunksize, list): - self.chunksize = tuple(self.chunksize) - - init_chunk_dict = None - if self.chunksize not in [False, None]: - init_chunk_dict = self._get_initial_chunk_dictionary() - try: - # Unfortunately we need to do if-else here, cause the lock-parameter is either False or a Lock-object - # (which we would rather want to have being auto-managed). - # If 'lock' is not specified, the Lock-object is auto-created and managed by xarray internally. - if self.lock_file: - self.dataset = xr.open_dataset( - str(self.filename), decode_cf=True, engine=self.netcdf_engine, chunks=init_chunk_dict - ) - else: - self.dataset = xr.open_dataset( - str(self.filename), decode_cf=True, engine=self.netcdf_engine, chunks=init_chunk_dict, lock=False - ) - self.dataset["decoded"] = True - except: - warnings.warn( - f"File {self.filename} could not be decoded properly by xarray (version {xr.__version__}). " - "It will be opened with no decoding. Filling values might be wrongly parsed.", - FileWarning, - stacklevel=2, - ) - if self.lock_file: - self.dataset = xr.open_dataset( - str(self.filename), decode_cf=False, engine=self.netcdf_engine, chunks=init_chunk_dict - ) - else: - self.dataset = xr.open_dataset( - str(self.filename), decode_cf=False, engine=self.netcdf_engine, chunks=init_chunk_dict, lock=False - ) - self.dataset["decoded"] = False - - for inds in self.indices.values(): - if type(inds) not in [list, range]: - raise RuntimeError("Indices for field subsetting need to be a list") - return self - - def __exit__(self, type, value, traceback): - """Function releases the file handle. - - This function releases the file handle. Hence access to the dataset and its header-information is lost. The - previously executed chunking is lost. Furthermore, if the file access required file locking, the lock-handle - is freed so other processes can now access the file again. - """ - self.close() - - def close(self): - """Teardown FileBuffer object with dask. - - This function can be called to initialise an orderly teardown of a FileBuffer object with dask, meaning - to release the file handle, deposing the dataset, and releasing the file lock (if required). - """ - if self.dataset is not None: - self.dataset.close() - self.dataset = None - self.chunking_finalized = False - self.chunk_mapping = None - - @classmethod - def add_to_dimension_name_map_global(cls, name_map): - """ - [externally callable] - This function adds entries to the name map from parcels_dim -> netcdf_dim. This is required if you want to - use auto-chunking on large fields whose map parameters are not defined. This function must be called before - entering the filebuffer object. Example: - DaskFileBuffer.add_to_dimension_name_map_global({'lat': 'nydim', - 'lon': 'nxdim', - 'time': 'ntdim', - 'depth': 'nddim'}) - fieldset = FieldSet(..., chunksize='auto') - [...] - Note that not all parcels dimensions need to be present in 'name_map'. - """ - assert isinstance(name_map, dict) - for pcls_dim_name in name_map.keys(): - if isinstance(name_map[pcls_dim_name], list): - for nc_dim_name in name_map[pcls_dim_name]: - cls._static_name_maps[pcls_dim_name].append(nc_dim_name) - elif isinstance(name_map[pcls_dim_name], str): - cls._static_name_maps[pcls_dim_name].append(name_map[pcls_dim_name]) - - def add_to_dimension_name_map(self, name_map): - """ - [externally callable] - This function adds entries to the name map from parcels_dim -> netcdf_dim. This is required if you want to - use auto-chunking on large fields whose map parameters are not defined. This function must be called after - constructing an filebuffer object and before entering the filebuffer. Example: - fb = DaskFileBuffer(...) - fb.add_to_dimension_name_map({'lat': 'nydim', 'lon': 'nxdim', 'time': 'ntdim', 'depth': 'nddim'}) - with fb: - [do_stuff} - Note that not all parcels dimensions need to be present in 'name_map'. - """ - assert isinstance(name_map, dict) - for pcls_dim_name in name_map.keys(): - self._static_name_maps[pcls_dim_name].append(name_map[pcls_dim_name]) - - def _get_available_dims_indices_by_request(self): - """Returns a dict mapping 'parcels_dimname' -> [None, int32_index_data_array]. - - This dictionary is based on the information provided by the requested dimensions. - Example: {'time': 0, 'depth': None, 'lat': 1, 'lon': 2} - """ - result = {} - neg_offset = 0 - tpl_offset = 0 - for name in ["time", "depth", "lat", "lon"]: - i = list(self._static_name_maps.keys()).index(name) - if name not in self.dimensions: - result[name] = None - tpl_offset += 1 - neg_offset += 1 - elif ( - (type(self.chunksize) is dict) - and ( - name not in self.chunksize - or ( - type(self.chunksize[name]) is tuple - and len(self.chunksize[name]) == 2 - and self.chunksize[name][1] <= 1 - ) - ) - ) or ( - (type(self.chunksize) is tuple) and name in self.dimensions and (self.chunksize[i - tpl_offset] <= 1) - ): - result[name] = None - neg_offset += 1 - else: - result[name] = i - neg_offset - return result - - def _get_available_dims_indices_by_namemap(self): - """ - Returns a dict mapping 'parcels_dimname' -> [None, int32_index_data_array]. - This dictionary is based on the information provided by the requested dimensions. - Example: {'time': 0, 'depth': 1, 'lat': 2, 'lon': 3} - """ - result = {} - for name in ["time", "depth", "lat", "lon"]: - result[name] = list(self._static_name_maps.keys()).index(name) - return result - - def _get_available_dims_indices_by_netcdf_file(self): - """ - [File needs to be open (i.e. self.dataset is not None) for this to work - otherwise generating an error] - Returns a dict mapping 'parcels_dimname' -> [None, int32_index_data_array]. - This dictionary is based on the information provided by the requested dimensions. - Example: {'time': 0, 'depth': 5, 'lat': 3, 'lon': 1} - for NetCDF with dimensions: - timer: 1 - x: [0 4000] - xr: [0 3999] - y: [0 2140] - yr: [0 2139] - z: [0 75] - """ - if self.dataset is None: - raise OSError("Trying to parse NetCDF header information before opening the file.") - result = {} - for pcls_dimname in ["time", "depth", "lat", "lon"]: - for nc_dimname in self._static_name_maps[pcls_dimname]: - if nc_dimname not in self.dataset.sizes.keys(): - continue - result[pcls_dimname] = list(self.dataset.sizes.keys()).index(nc_dimname) - return result - - def _is_dimension_available(self, dimension_name): - """ - This function returns a boolean value indicating if a certain variable (name) is available in the - requested dimensions as well as in the actual dataset of the file. If any of the two conditions is not met, - if returns 'False'. - """ - if self.dimensions is None or self.dataset is None: - return False - return dimension_name in self.dimensions - - def _is_dimension_chunked(self, dimension_name): - """ - This functions returns a boolean value indicating if a certain variable is available in the requested - dimensions, the NetCDF file dataset, and is also required to be chunked according to the requested - chunksize dictionary. If any of the two conditions is not met, if returns 'False'. - """ - if self.dimensions is None or self.dataset is None or self.chunksize in [None, False, "auto"]: - return False - dim_chunked = False - dim_chunked = ( - True - if (not dim_chunked and type(self.chunksize) is dict and dimension_name in self.chunksize.keys()) - else False - ) - dim_chunked = True if (not dim_chunked and type(self.chunksize) in [None, False]) else False - return (dimension_name in self.dimensions) and dim_chunked - - def _is_dimension_in_dataset(self, parcels_dimension_name, netcdf_dimension_name=None): - """ - [File needs to be open (i.e. self.dataset is not None) for this to work - otherwise generating an error] - This function returns the index, the name and the size of a NetCDF dimension in the file (in order: index, name, size). - It requires as input the name of the related parcels dimension (i.e. one of ['time', 'depth', 'lat', 'lon']. If - no hint on its mapping to a NetCDF dimension is provided, a heuristic based on the pre-defined name dictionary - is used. If a hint is provided, a connections is made between the designated parcels-dimension and NetCDF dimension. - """ - if self.dataset is None: - raise OSError("Trying to parse NetCDF header information before opening the file.") - k, dname, dvalue = (-1, "", 0) - dimension_name = parcels_dimension_name.lower() - dim_indices = self._get_available_dims_indices_by_request() - i = dim_indices[dimension_name] - if netcdf_dimension_name is not None and netcdf_dimension_name in self.dataset.sizes.keys(): - value = self.dataset.sizes[netcdf_dimension_name] - k, dname, dvalue = i, netcdf_dimension_name, value - elif self.dimensions is None or self.dataset is None: - return k, dname, dvalue - else: - for name in self._static_name_maps[dimension_name]: - if name in self.dataset.sizes: - value = self.dataset.sizes[name] - k, dname, dvalue = i, name, value - break - return k, dname, dvalue - - def _is_dimension_in_chunksize_request(self, parcels_dimension_name): - """ - This function returns the dense-array index, the NetCDF dimension name and the requested chunsize of a requested - parcels dimension(in order: index, name, size). This only works if the chunksize is provided as a dictionary - of tuples of parcels dimensions and their chunk mapping (i.e. dict(parcels_dim_name => (netcdf_dim_name, chunksize)). - It requires as input the name of the related parcels dimension (i.e. one of ['time', 'depth', 'lat', 'lon']. - """ - k, dname, dvalue = (-1, "", 0) - if self.dimensions is None or self.dataset is None: - return k, dname, dvalue - parcels_dimension_name = parcels_dimension_name.lower() - dim_indices = self._get_available_dims_indices_by_request() - i = dim_indices[parcels_dimension_name] - name = self.chunksize[parcels_dimension_name][0] - value = self.chunksize[parcels_dimension_name][1] - k, dname, dvalue = i, name, value - return k, dname, dvalue - - def _netcdf_DimNotFound_warning_message(self, dimension_name): - """Helper function that issues a warning message if a certain requested NetCDF dimension is not found in the file.""" - display_name = dimension_name if (dimension_name not in self.dimensions) else self.dimensions[dimension_name] - return f"Did not find {display_name} in NetCDF dims. Please specifiy chunksize as dictionary for NetCDF dimension names, e.g.\n chunksize={{ '{display_name}': , ... }}." - - def _chunkmap_to_chunksize(self): - """ - [File needs to be open via the '__enter__'-method for this to work - otherwise generating an error] - This functions translates the array-index-to-chunksize chunk map into a proper fieldsize dictionary that - can later be used for re-chunking, if a previously-opened file is re-opened again. - """ - if self.chunksize in [False, None]: - return - self.chunksize = {} - chunk_map = self.chunk_mapping - timei, timename, timevalue = self._is_dimension_in_dataset("time") - depthi, depthname, depthvalue = self._is_dimension_in_dataset("depth") - lati, latname, latvalue = self._is_dimension_in_dataset("lat") - loni, lonname, lonvalue = self._is_dimension_in_dataset("lon") - if len(chunk_map) == 2: - self.chunksize["lon"] = (latname, chunk_map[0]) - self.chunksize["lat"] = (lonname, chunk_map[1]) - elif len(chunk_map) == 3: - chunk_dim_index = 0 - if depthi is not None and depthi >= 0 and depthvalue > 1 and self._is_dimension_available("depth"): - self.chunksize["depth"] = (depthname, chunk_map[chunk_dim_index]) - chunk_dim_index += 1 - elif timei is not None and timei >= 0 and timevalue > 1 and self._is_dimension_available("time"): - self.chunksize["time"] = (timename, chunk_map[chunk_dim_index]) - chunk_dim_index += 1 - self.chunksize["lat"] = (latname, chunk_map[chunk_dim_index]) - chunk_dim_index += 1 - self.chunksize["lon"] = (lonname, chunk_map[chunk_dim_index]) - elif len(chunk_map) >= 4: - self.chunksize["time"] = (timename, chunk_map[0]) - self.chunksize["depth"] = (depthname, chunk_map[1]) - self.chunksize["lat"] = (latname, chunk_map[2]) - self.chunksize["lon"] = (lonname, chunk_map[3]) - dim_index = 4 - for dim_name in self.dimensions: - if dim_name not in ["time", "depth", "lat", "lon"]: - self.chunksize[dim_name] = (self.dimensions[dim_name], chunk_map[dim_index]) - dim_index += 1 - - def _get_initial_chunk_dictionary_by_dict_(self): - """ - [File needs to be open (i.e. self.dataset is not None) for this to work - otherwise generating an error] - Maps and correlates the requested dictionary-style chunksize with the requested parcels dimensions, variables - and the NetCDF-available dimensions. Thus, it takes care to remove chunksize arguments that are not in the - Parcels- or NetCDF dimensions, or whose chunking would be omitted due to an empty chunk dimension. - The function returns a pair of two things: corrected_chunk_dict, chunk_map - The corrected chunk_dict is the corrected version of the requested chunksize. The chunk map maps the array index - dimension to the requested chunksize. - """ - chunk_dict = {} - chunk_index_map = {} - neg_offset = 0 - if "time" in self.chunksize.keys(): - timei, timename, timesize = self._is_dimension_in_dataset( - parcels_dimension_name="time", netcdf_dimension_name=self.chunksize["time"][0] - ) - timevalue = self.chunksize["time"][1] - if timei is not None and timei >= 0 and timevalue > 1: - timevalue = min(timesize, timevalue) - chunk_dict[timename] = timevalue - chunk_index_map[timei - neg_offset] = timevalue - else: - self.chunksize.pop("time") - if "depth" in self.chunksize.keys(): - depthi, depthname, depthsize = self._is_dimension_in_dataset( - parcels_dimension_name="depth", netcdf_dimension_name=self.chunksize["depth"][0] - ) - depthvalue = self.chunksize["depth"][1] - if depthi is not None and depthi >= 0 and depthvalue > 1: - depthvalue = min(depthsize, depthvalue) - chunk_dict[depthname] = depthvalue - chunk_index_map[depthi - neg_offset] = depthvalue - else: - self.chunksize.pop("depth") - if "lat" in self.chunksize.keys(): - lati, latname, latsize = self._is_dimension_in_dataset( - parcels_dimension_name="lat", netcdf_dimension_name=self.chunksize["lat"][0] - ) - latvalue = self.chunksize["lat"][1] - if lati is not None and lati >= 0 and latvalue > 1: - latvalue = min(latsize, latvalue) - chunk_dict[latname] = latvalue - chunk_index_map[lati - neg_offset] = latvalue - else: - self.chunksize.pop("lat") - if "lon" in self.chunksize.keys(): - loni, lonname, lonsize = self._is_dimension_in_dataset( - parcels_dimension_name="lon", netcdf_dimension_name=self.chunksize["lon"][0] - ) - lonvalue = self.chunksize["lon"][1] - if loni is not None and loni >= 0 and lonvalue > 1: - lonvalue = min(lonsize, lonvalue) - chunk_dict[lonname] = lonvalue - chunk_index_map[loni - neg_offset] = lonvalue - else: - self.chunksize.pop("lon") - return chunk_dict, chunk_index_map - - def _failsafe_parse_(self): - """['name' need to be initialised]""" - # ==== fail - open it as a normal array and deduce the dimensions from the variable-function names ==== # - # ==== done by parsing ALL variables in the NetCDF, and comparing their call-parameters with the ==== # - # ==== name map available here. ==== # - init_chunk_dict = {} - self.dataset = ncDataset(str(self.filename)) - refdims = self.dataset.dimensions.keys() - max_field = "" - max_dim_names = () - max_coincide_dims = 0 - for vname in self.dataset.variables: - var = self.dataset.variables[vname] - coincide_dims = [] - for vdname in var.dimensions: - if vdname in refdims: - coincide_dims.append(vdname) - n_coincide_dims = len(coincide_dims) - if n_coincide_dims > max_coincide_dims: - max_field = vname - max_dim_names = tuple(coincide_dims) - max_coincide_dims = n_coincide_dims - self.name = max_field - for nc_dname in max_dim_names: - pcls_dname = None - for dname in self._static_name_maps.keys(): - if nc_dname in self._static_name_maps[dname]: - pcls_dname = dname - break - nc_dimsize = None - pcls_dim_chunksize = None - if pcls_dname is not None and pcls_dname in self.dimensions: - pcls_dim_chunksize = self._min_dim_chunksize - if isinstance(self.chunksize, dict) and pcls_dname is not None: - nc_dimsize = self.dataset.dimensions[nc_dname].size - if pcls_dname in self.chunksize.keys(): - pcls_dim_chunksize = self.chunksize[pcls_dname][1] - if ( - pcls_dname is not None - and nc_dname is not None - and nc_dimsize is not None - and pcls_dim_chunksize is not None - ): - init_chunk_dict[nc_dname] = pcls_dim_chunksize - - # ==== because in this case it has shown that the requested chunksize setup cannot be used, ==== # - # ==== replace the requested chunksize with this auto-derived version. ==== # - return init_chunk_dict - - def _get_initial_chunk_dictionary(self): - """ - Super-function that maps and correlates the requested chunksize with the requested parcels dimensions, variables - and the NetCDF-available dimensions. Thus, it takes care to remove chunksize arguments that are not in the - Parcels- or NetCDF dimensions, or whose chunking would be omitted due to an empty chunk dimension. - The function returns the corrected chunksize dictionary. The function also initializes the chunk_map. - The chunk map maps the array index dimension to the requested chunksize. - Apart from resolving the different requested version of the chunksize, the function also test-executes the - chunk request. If this initial test fails, as a last resort, we execute a heuristic to map the requested - parcels dimensions to the dimension signature of the most-parameterized NetCDF variable, and heuristically - try to map its parameters to the parcels dimensions with the class-wide name-map. - """ - # ==== check-opening requested dataset to access metadata ==== # - # ==== file-opening and dimension-reading does not require a decode or lock ==== # - self.dataset = xr.open_dataset( - str(self.filename), decode_cf=False, engine=self.netcdf_engine, chunks={}, lock=False - ) - self.dataset["decoded"] = False - # ==== self.dataset temporarily available ==== # - init_chunk_dict = {} - init_chunk_map = {} - if isinstance(self.chunksize, dict): - init_chunk_dict, init_chunk_map = self._get_initial_chunk_dictionary_by_dict_() - elif self.chunksize == "auto": - av_mem = psutil.virtual_memory().available - chunk_cap = av_mem * (1 / 8) * (1 / 3) - if "array.chunk-size" in da_conf.config.keys(): - chunk_cap = da_utils.parse_bytes(da_conf.config.get("array.chunk-size")) - else: - predefined_cap = da_conf.get("array.chunk-size") - if predefined_cap is not None: - chunk_cap = da_utils.parse_bytes(predefined_cap) - else: - warnings.warn( - "Unable to locate chunking hints from dask, thus estimating the max. chunk size heuristically. " - "Please consider defining the 'chunk-size' for 'array' in your local dask configuration file (see https://docs.oceanparcels.org/en/latest/examples/documentation_MPI.html#Chunking-the-FieldSet-with-dask and https://docs.dask.org).", - FileWarning, - stacklevel=2, - ) - loni, lonname, lonvalue = self._is_dimension_in_dataset("lon") - lati, latname, latvalue = self._is_dimension_in_dataset("lat") - if lati is not None and loni is not None and lati >= 0 and loni >= 0: - pDim = int(math.floor(math.sqrt(chunk_cap / np.dtype(np.float64).itemsize))) - init_chunk_dict[latname] = min(latvalue, pDim) - init_chunk_map[lati] = min(latvalue, pDim) - init_chunk_dict[lonname] = min(lonvalue, pDim) - init_chunk_map[loni] = min(lonvalue, pDim) - timei, timename, timevalue = self._is_dimension_in_dataset("time") - if timei is not None and timei >= 0: - init_chunk_dict[timename] = min(1, timevalue) - init_chunk_map[timei] = min(1, timevalue) - depthi, depthname, depthvalue = self._is_dimension_in_dataset("depth") - if depthi is not None and depthi >= 0: - init_chunk_dict[depthname] = max(1, depthvalue) - init_chunk_map[depthi] = max(1, depthvalue) - # ==== closing check-opened requested dataset ==== # - self.dataset.close() - # ==== check if the chunksize reading is successful. if not, load the file ONCE really into memory and ==== # - # ==== deduce the chunking from the array dims. ==== # - if len(init_chunk_dict) == 0 and self.chunksize not in [False, None, "auto"]: - self.autochunkingfailed = True - raise DaskChunkingError( - f"[{self.__class__.__name__}]: No correct mapping found between Parcels- and NetCDF dimensions! Please correct the 'FieldSet(..., chunksize=...)' parameter and try again.", - ) - else: - self.autochunkingfailed = False - try: - self.dataset = xr.open_dataset( - str(self.filename), decode_cf=True, engine=self.netcdf_engine, chunks=init_chunk_dict, lock=False - ) - if isinstance(self.chunksize, dict): - self.chunksize = init_chunk_dict - except: - warnings.warn( - f"Chunking with init_chunk_dict = {init_chunk_dict} failed - Executing Dask chunking 'failsafe'...", - FileWarning, - stacklevel=2, - ) - self.autochunkingfailed = True - if not self.autochunkingfailed: - init_chunk_dict = self._failsafe_parse_() - if isinstance(self.chunksize, dict): - self.chunksize = init_chunk_dict - finally: - self.dataset.close() - self.chunk_mapping = init_chunk_map - self.dataset = None - # ==== self.dataset not available ==== # - return init_chunk_dict - - @property - def data(self): - return self.data_access() - - def data_access(self): - data = self.dataset[self.name] - - ti = range(data.shape[0]) if self.ti is None else self.ti - data = self._apply_indices(data, ti) - if isinstance(data, xr.DataArray): - data = data.data - - if isinstance(data, da.core.Array): - if not self.chunking_finalized: - if self.chunksize == "auto": - # ==== as the chunksize is not initiated, the data is chunked automatically by Dask. ==== # - # ==== the resulting chunk dictionary is stored, to be re-used later. This prevents ==== # - # ==== the expensive re-calculation and PHYSICAL FILE RECHUNKING on each data access. ==== # - if data.shape[-2:] != data.chunksize[-2:]: - data = data.rechunk(self.chunksize) - self.chunk_mapping = {} - chunkIndex = 0 - startblock = 0 - for chunkDim in data.chunksize[startblock:]: - self.chunk_mapping[chunkIndex] = chunkDim - chunkIndex += 1 - self._chunkmap_to_chunksize() - if self.rechunk_callback_fields is not None: - self.rechunk_callback_fields() - self.chunking_finalized = True - else: - self.chunking_finalized = True - else: - da_data = da.from_array(data, chunks=self.chunksize) - if self.chunksize == "auto" and da_data.shape[-2:] == da_data.chunksize[-2:]: - data = np.array(data) - else: - data = da_data - if not self.chunking_finalized and self.rechunk_callback_fields is not None: - self.rechunk_callback_fields() - self.chunking_finalized = True - - return data.astype(self.cast_data_dtype) - - -class DeferredDaskFileBuffer(DaskFileBuffer): - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) diff --git a/parcels/fieldset.py b/parcels/fieldset.py deleted file mode 100644 index 8a2e8ffbe..000000000 --- a/parcels/fieldset.py +++ /dev/null @@ -1,1691 +0,0 @@ -import importlib.util -import os -import sys -import warnings -from copy import deepcopy -from glob import glob - -import dask.array as da -import numpy as np - -from parcels._compat import MPI -from parcels._typing import GridIndexingType, InterpMethodOption, Mesh, TimePeriodic -from parcels.field import DeferredArray, Field, NestedField, VectorField -from parcels.grid import Grid -from parcels.gridset import GridSet -from parcels.particlefile import ParticleFile -from parcels.tools._helpers import deprecated_made_private, fieldset_repr -from parcels.tools.converters import TimeConverter, convert_xarray_time_units -from parcels.tools.loggers import logger -from parcels.tools.statuscodes import TimeExtrapolationError -from parcels.tools.warnings import FieldSetWarning - -__all__ = ["FieldSet"] - - -class FieldSet: - """FieldSet class that holds hydrodynamic data needed to execute particles. - - Parameters - ---------- - U : parcels.field.Field - Field object for zonal velocity component - V : parcels.field.Field - Field object for meridional velocity component - fields : dict mapping str to Field - Additional fields to include in the FieldSet. These fields can be used - in custom kernels. - """ - - def __init__(self, U: Field | NestedField | None, V: Field | NestedField | None, fields=None): - self.gridset = GridSet() - self._completed: bool = False - self._particlefile: ParticleFile | None = None - if U: - self.add_field(U, "U") - # see #1663 for type-ignore reason - self.time_origin = self.U.grid.time_origin if isinstance(self.U, Field) else self.U[0].grid.time_origin # type: ignore - if V: - self.add_field(V, "V") - - # Add additional fields as attributes - if fields: - for name, field in fields.items(): - self.add_field(field, name) - - self.compute_on_defer = None - self._add_UVfield() - - def __repr__(self): - return fieldset_repr(self) - - @property - def particlefile(self): - return self._particlefile - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def completed(self): - return self._completed - - @staticmethod - def checkvaliddimensionsdict(dims): - for d in dims: - if d not in ["lon", "lat", "depth", "time"]: - raise NameError(f"{d} is not a valid key in the dimensions dictionary") - - @classmethod - def from_data( - cls, - data, - dimensions, - transpose=False, - mesh: Mesh = "spherical", - allow_time_extrapolation: bool | None = None, - time_periodic: TimePeriodic = False, - **kwargs, - ): - """Initialise FieldSet object from raw data. - - Parameters - ---------- - data : - Dictionary mapping field names to numpy arrays. - Note that at least a 'U' and 'V' numpy array need to be given, and that - the built-in Advection kernels assume that U and V are in m/s - - 1. If data shape is [xdim, ydim], [xdim, ydim, zdim], [xdim, ydim, tdim] or [xdim, ydim, zdim, tdim], - whichever is relevant for the dataset, use the flag transpose=True - 2. If data shape is [ydim, xdim], [zdim, ydim, xdim], [tdim, ydim, xdim] or [tdim, zdim, ydim, xdim], - use the flag transpose=False (default value) - 3. If data has any other shape, you first need to reorder it - dimensions : dict - Dictionary mapping field dimensions (lon, - lat, depth, time) to numpy arrays. - Note that dimensions can also be a dictionary of dictionaries if - dimension names are different for each variable - (e.g. dimensions['U'], dimensions['V'], etc). - transpose : bool - Whether to transpose data on read-in (Default value = False) - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation, see also `this tutorial <../examples/tutorial_unitconverters.ipynb>`__: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - allow_time_extrapolation : bool - boolean whether to allow for extrapolation - (i.e. beyond the last available time snapshot) - Default is False if dimensions includes time, else True - time_periodic : bool, float or datetime.timedelta - To loop periodically over the time component of the Field. It is set to either False or the length of the period (either float in seconds or datetime.timedelta object). (Default: False) - This flag overrides the allow_time_extrapolation and sets it to False - **kwargs : - Keyword arguments passed to the :class:`Field` constructor. - - Examples - -------- - For usage examples see the following tutorials: - - * `Analytical advection <../examples/tutorial_analyticaladvection.ipynb>`__ - - * `Diffusion <../examples/tutorial_diffusion.ipynb>`__ - - * `Interpolation <../examples/tutorial_interpolation.ipynb>`__ - - * `Unit converters <../examples/tutorial_unitconverters.ipynb>`__ - """ - fields = {} - for name, datafld in data.items(): - # Use dimensions[name] if dimensions is a dict of dicts - dims = dimensions[name] if name in dimensions else dimensions - cls.checkvaliddimensionsdict(dims) - - if allow_time_extrapolation is None: - allow_time_extrapolation = False if "time" in dims else True - - lon = dims["lon"] - lat = dims["lat"] - depth = np.zeros(1, dtype=np.float32) if "depth" not in dims else dims["depth"] - time = np.zeros(1, dtype=np.float64) if "time" not in dims else dims["time"] - time = np.array(time) - if isinstance(time[0], np.datetime64): - time_origin = TimeConverter(time[0]) - time = np.array([time_origin.reltime(t) for t in time]) - else: - time_origin = kwargs.pop("time_origin", TimeConverter(0)) - grid = Grid.create_grid(lon, lat, depth, time, time_origin=time_origin, mesh=mesh) - if "creation_log" not in kwargs.keys(): - kwargs["creation_log"] = "from_data" - - fields[name] = Field( - name, - datafld, - grid=grid, - transpose=transpose, - allow_time_extrapolation=allow_time_extrapolation, - time_periodic=time_periodic, - **kwargs, - ) - u = fields.pop("U", None) - v = fields.pop("V", None) - return cls(u, v, fields=fields) - - def add_field(self, field: Field | NestedField, name: str | None = None): - """Add a :class:`parcels.field.Field` object to the FieldSet. - - Parameters - ---------- - field : parcels.field.Field - Field object to be added - name : str - Name of the :class:`parcels.field.Field` object to be added. Defaults - to name in Field object. - - - Examples - -------- - For usage examples see the following tutorials: - - * `Nested Fields <../examples/tutorial_NestedFields.ipynb>`__ - - * `Unit converters <../examples/tutorial_unitconverters.ipynb>`__ (Default value = None) - - """ - if self._completed: - raise RuntimeError( - "FieldSet has already been completed. Are you trying to add a Field after you've created the ParticleSet?" - ) - name = field.name if name is None else name - - if hasattr(self, name): # check if Field with same name already exists when adding new Field - raise RuntimeError(f"FieldSet already has a Field with name '{name}'") - if isinstance(field, NestedField): - setattr(self, name, field) - for fld in field: - self.gridset.add_grid(fld) - fld.fieldset = self - else: - setattr(self, name, field) - self.gridset.add_grid(field) - field.fieldset = self - - def add_constant_field(self, name: str, value: float, mesh: Mesh = "flat"): - """Wrapper function to add a Field that is constant in space, - useful e.g. when using constant horizontal diffusivity - - Parameters - ---------- - name : str - Name of the :class:`parcels.field.Field` object to be added - value : float - Value of the constant field (stored as 32-bit float) - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation, see also `this tutorial <../examples/tutorial_unitconverters.ipynb>`__: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - """ - self.add_field(Field(name, value, lon=0, lat=0, mesh=mesh)) - - def add_vector_field(self, vfield): - """Add a :class:`parcels.field.VectorField` object to the FieldSet. - - Parameters - ---------- - vfield : parcels.VectorField - class:`parcels.field.VectorField` object to be added - """ - setattr(self, vfield.name, vfield) - for v in vfield.__dict__.values(): - if isinstance(v, Field) and (v not in self.get_fields()): - self.add_field(v) - vfield.fieldset = self - if isinstance(vfield, NestedField): - for f in vfield: - f.fieldset = self - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def add_UVfield(self, *args, **kwargs): - return self._add_UVfield(*args, **kwargs) - - def _add_UVfield(self): - if not hasattr(self, "UV") and hasattr(self, "U") and hasattr(self, "V"): - if isinstance(self.U, NestedField): - self.add_vector_field(NestedField("UV", self.U, self.V)) - else: - self.add_vector_field(VectorField("UV", self.U, self.V)) - if not hasattr(self, "UVW") and hasattr(self, "W"): - if isinstance(self.U, NestedField): - self.add_vector_field(NestedField("UVW", self.U, self.V, self.W)) - else: - self.add_vector_field(VectorField("UVW", self.U, self.V, self.W)) - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def check_complete(self): - return self._check_complete() - - def _check_complete(self): - assert self.U, 'FieldSet does not have a Field named "U"' - assert self.V, 'FieldSet does not have a Field named "V"' - for attr, value in vars(self).items(): - if type(value) is Field: - assert value.name == attr, f"Field {value.name}.name ({attr}) is not consistent" - - def check_velocityfields(U, V, W): - if (U.interp_method == "cgrid_velocity" and V.interp_method != "cgrid_velocity") or ( - U.interp_method != "cgrid_velocity" and V.interp_method == "cgrid_velocity" - ): - raise ValueError("If one of U,V.interp_method='cgrid_velocity', the other should be too") - - if "linear_invdist_land_tracer" in [U.interp_method, V.interp_method]: - raise NotImplementedError( - "interp_method='linear_invdist_land_tracer' is not implemented for U and V Fields" - ) - - if U.interp_method == "cgrid_velocity": - if U.grid.xdim == 1 or U.grid.ydim == 1 or V.grid.xdim == 1 or V.grid.ydim == 1: - raise NotImplementedError( - "C-grid velocities require longitude and latitude dimensions at least length 2" - ) - - if U.gridindexingtype not in ["nemo", "mitgcm", "mom5", "pop", "croco"]: - raise ValueError("Field.gridindexing has to be one of 'nemo', 'mitgcm', 'mom5', 'pop' or 'croco'") - - if V.gridindexingtype != U.gridindexingtype or (W and W.gridindexingtype != U.gridindexingtype): - raise ValueError("Not all velocity Fields have the same gridindexingtype") - - if U.cast_data_dtype != V.cast_data_dtype or (W and W.cast_data_dtype != U.cast_data_dtype): - raise ValueError("Not all velocity Fields have the same dtype") - - if isinstance(self.U, NestedField): - w = self.W if hasattr(self, "W") else [None] * len(self.U) - for U, V, W in zip(self.U, self.V, w, strict=True): - check_velocityfields(U, V, W) - else: - W = self.W if hasattr(self, "W") else None - check_velocityfields(self.U, self.V, W) - - for g in self.gridset.grids: - g._check_zonal_periodic() - if len(g.time) == 1: - continue - assert isinstance( - g.time_origin.time_origin, type(self.time_origin.time_origin) - ), "time origins of different grids must be have the same type" - g.time = g.time + self.time_origin.reltime(g.time_origin) - if g.defer_load: - g.time_full = g.time_full + self.time_origin.reltime(g.time_origin) - g._time_origin = self.time_origin - self._add_UVfield() - - ccode_fieldnames = [] - counter = 1 - for fld in self.get_fields(): - if fld.name not in ccode_fieldnames: - fld.ccode_name = fld.name - else: - fld.ccode_name = fld.name + str(counter) - counter += 1 - ccode_fieldnames.append(fld.ccode_name) - - for f in self.get_fields(): - if isinstance(f, (VectorField, NestedField)) or f._dataFiles is None: - continue - if f.grid.depth_field is not None: - if f.grid.depth_field == "not_yet_set": - raise ValueError( - "If depth dimension is set at 'not_yet_set', it must be added later using Field.set_depth_from_field(field)" - ) - if not f.grid.defer_load: - depth_data = f.grid.depth_field.data - f.grid._depth = depth_data if isinstance(depth_data, np.ndarray) else np.array(depth_data) - self._completed = True - - @classmethod - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def parse_wildcards(cls, *args, **kwargs): - return cls._parse_wildcards(*args, **kwargs) - - @classmethod - def _parse_wildcards(cls, paths, filenames, var): - if not isinstance(paths, list): - paths = sorted(glob(str(paths))) - if len(paths) == 0: - notfound_paths = filenames[var] if isinstance(filenames, dict) and var in filenames else filenames - raise OSError(f"FieldSet files not found for variable {var}: {notfound_paths}") - for fp in paths: - if not os.path.exists(fp): - raise OSError(f"FieldSet file not found: {fp}") - return paths - - @classmethod - def from_netcdf( - cls, - filenames, - variables, - dimensions, - indices=None, - fieldtype=None, - mesh: Mesh = "spherical", - timestamps=None, - allow_time_extrapolation: bool | None = None, - time_periodic: TimePeriodic = False, - deferred_load=True, - chunksize=None, - **kwargs, - ): - """Initialises FieldSet object from NetCDF files. - - Parameters - ---------- - filenames : - Dictionary mapping variables to file(s). The - filepath may contain wildcards to indicate multiple files - or be a list of file. - filenames can be a list ``[files]``, a dictionary ``{var:[files]}``, - a dictionary ``{dim:[files]}`` (if lon, lat, depth and/or data not stored in same files as data), - or a dictionary of dictionaries ``{var:{dim:[files]}}``. - time values are in ``filenames[data]`` - variables : dict - Dictionary mapping variables to variable names in the netCDF file(s). - Note that the built-in Advection kernels assume that U and V are in m/s - dimensions : dict - Dictionary mapping data dimensions (lon, - lat, depth, time, data) to dimensions in the netCF file(s). - Note that dimensions can also be a dictionary of dictionaries if - dimension names are different for each variable - (e.g. dimensions['U'], dimensions['V'], etc). - indices : - Optional dictionary of indices for each dimension - to read from file(s), to allow for reading of subset of data. - Default is to read the full extent of each dimension. - Note that negative indices are not allowed. - fieldtype : - Optional dictionary mapping fields to fieldtypes to be used for UnitConverter. - (either 'U', 'V', 'Kh_zonal', 'Kh_meridional' or None) (Default value = None) - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation, see also `this tutorial <../examples/tutorial_unitconverters.ipynb>`__: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - timestamps : - list of lists or array of arrays containing the timestamps for - each of the files in filenames. Outer list/array corresponds to files, inner - array corresponds to indices within files. - Default is None if dimensions includes time. - allow_time_extrapolation : bool - boolean whether to allow for extrapolation - (i.e. beyond the last available time snapshot) - Default is False if dimensions includes time, else True - time_periodic : bool, float or datetime.timedelta - To loop periodically over the time component of the Field. It is set to either False or the length of the period (either float in seconds or datetime.timedelta object). (Default: False) - This flag overrides the allow_time_extrapolation and sets it to False - deferred_load : bool - boolean whether to only pre-load data (in deferred mode) or - fully load them (default: True). It is advised to deferred load the data, since in - that case Parcels deals with a better memory management during particle set execution. - deferred_load=False is however sometimes necessary for plotting the fields. - interp_method : str - Method for interpolation. Options are 'linear' (default), 'nearest', - 'linear_invdist_land_tracer', 'cgrid_velocity', 'cgrid_tracer' and 'bgrid_velocity' - gridindexingtype : str - The type of gridindexing. Either 'nemo' (default), 'mitgcm', 'mom5', 'pop', or 'croco' are supported. - See also the Grid indexing documentation on oceanparcels.org - chunksize : - size of the chunks in dask loading. Default is None (no chunking). Can be None or False (no chunking), - 'auto' (chunking is done in the background, but results in one grid per field individually), or a dict in the format - ``{parcels_varname: {netcdf_dimname : (parcels_dimname, chunksize_as_int)}, ...}``, where ``parcels_dimname`` is one of ('time', 'depth', 'lat', 'lon') - netcdf_engine : - engine to use for netcdf reading in xarray. Default is 'netcdf', - but in cases where this doesn't work, setting netcdf_engine='scipy' could help. Accepted options are the same as the ``engine`` parameter in ``xarray.open_dataset()``. - **kwargs : - Keyword arguments passed to the :class:`parcels.Field` constructor. - - - Examples - -------- - For usage examples see the following tutorials: - - * `Basic Parcels setup <../examples/parcels_tutorial.ipynb>`__ - - * `Argo floats <../examples/tutorial_Argofloats.ipynb>`__ - - * `Timestamps <../examples/tutorial_timestamps.ipynb>`__ - - * `Time-evolving depth dimensions <../examples/tutorial_timevaryingdepthdimensions.ipynb>`__ - - """ - # Ensure that times are not provided both in netcdf file and in 'timestamps'. - if timestamps is not None and "time" in dimensions: - warnings.warn( - "Time already provided, defaulting to dimensions['time'] over timestamps.", - FieldSetWarning, - stacklevel=2, - ) - timestamps = None - - fields: dict[str, Field] = {} - if "creation_log" not in kwargs.keys(): - kwargs["creation_log"] = "from_netcdf" - for var, name in variables.items(): - # Resolve all matching paths for the current variable - paths = filenames[var] if type(filenames) is dict and var in filenames else filenames - if type(paths) is not dict: - paths = cls._parse_wildcards(paths, filenames, var) - else: - for dim, p in paths.items(): - paths[dim] = cls._parse_wildcards(p, filenames, var) - - # Use dimensions[var] and indices[var] if either of them is a dict of dicts - dims = dimensions[var] if var in dimensions else dimensions - cls.checkvaliddimensionsdict(dims) - inds = indices[var] if (indices and var in indices) else indices - fieldtype = fieldtype[var] if (fieldtype and var in fieldtype) else fieldtype - varchunksize = ( - chunksize[var] if (chunksize and var in chunksize) else chunksize - ) # -> {: (, ) } - - grid = None - dFiles = None - # check if grid has already been processed (i.e. if other fields have same filenames, dimensions and indices) - for procvar, _ in fields.items(): - procdims = dimensions[procvar] if procvar in dimensions else dimensions - procinds = indices[procvar] if (indices and procvar in indices) else indices - procpaths = filenames[procvar] if isinstance(filenames, dict) and procvar in filenames else filenames - procchunk = chunksize[procvar] if (chunksize and procvar in chunksize) else chunksize - nowpaths = filenames[var] if isinstance(filenames, dict) and var in filenames else filenames - if procdims == dims and procinds == inds: - possibly_samegrid = True - if procchunk != varchunksize: - for dim in varchunksize: - if varchunksize[dim][1] != procchunk[dim][1]: - possibly_samegrid &= False - if not possibly_samegrid: - break - if varchunksize == "auto": - break - if "depth" in dims and dims["depth"] == "not_yet_set": - break - processedGrid = False - if (not isinstance(filenames, dict)) or filenames[procvar] == filenames[var]: - processedGrid = True - elif isinstance(filenames[procvar], dict): - processedGrid = True - for dim in ["lon", "lat", "depth"]: - if dim in dimensions: - processedGrid *= filenames[procvar][dim] == filenames[var][dim] - if processedGrid: - grid = fields[procvar].grid - if procpaths == nowpaths: - dFiles = fields[procvar]._dataFiles - break - fields[var] = Field.from_netcdf( - paths, - (var, name), - dims, - inds, - grid=grid, - mesh=mesh, - timestamps=timestamps, - allow_time_extrapolation=allow_time_extrapolation, - time_periodic=time_periodic, - deferred_load=deferred_load, - fieldtype=fieldtype, - chunksize=varchunksize, - dataFiles=dFiles, - **kwargs, - ) - - u = fields.pop("U", None) - v = fields.pop("V", None) - return cls(u, v, fields=fields) - - @classmethod - def from_nemo( - cls, - filenames, - variables, - dimensions, - indices=None, - mesh: Mesh = "spherical", - allow_time_extrapolation: bool | None = None, - time_periodic: TimePeriodic = False, - tracer_interp_method: InterpMethodOption = "cgrid_tracer", - chunksize=None, - **kwargs, - ): - """Initialises FieldSet object from NetCDF files of Curvilinear NEMO fields. - - See `here <../examples/tutorial_nemo_curvilinear.ipynb>`__ - for a detailed tutorial on the setup for 2D NEMO fields and `here <../examples/tutorial_nemo_3D.ipynb>`__ - for the tutorial on the setup for 3D NEMO fields. - - See `here <../examples/documentation_indexing.ipynb>`__ - for a more detailed explanation of the different methods that can be used for c-grid datasets. - - Parameters - ---------- - filenames : - Dictionary mapping variables to file(s). The - filepath may contain wildcards to indicate multiple files, - or be a list of file. - filenames can be a list ``[files]``, a dictionary ``{var:[files]}``, - a dictionary ``{dim:[files]}`` (if lon, lat, depth and/or data not stored in same files as data), - or a dictionary of dictionaries ``{var:{dim:[files]}}`` - time values are in ``filenames[data]`` - variables : dict - Dictionary mapping variables to variable names in the netCDF file(s). - Note that the built-in Advection kernels assume that U and V are in m/s - dimensions : dict - Dictionary mapping data dimensions (lon, - lat, depth, time, data) to dimensions in the netCF file(s). - Note that dimensions can also be a dictionary of dictionaries if - dimension names are different for each variable. - Watch out: NEMO is discretised on a C-grid: - U and V velocities are not located on the same nodes (see https://www.nemo-ocean.eu/doc/node19.html). :: - - +-----------------------------+-----------------------------+-----------------------------+ - | | V[k,j+1,i+1] | | - +-----------------------------+-----------------------------+-----------------------------+ - |U[k,j+1,i] |W[k:k+2,j+1,i+1],T[k,j+1,i+1]|U[k,j+1,i+1] | - +-----------------------------+-----------------------------+-----------------------------+ - | | V[k,j,i+1] | | - +-----------------------------+-----------------------------+-----------------------------+ - - To interpolate U, V velocities on the C-grid, Parcels needs to read the f-nodes, - which are located on the corners of the cells. - (for indexing details: https://www.nemo-ocean.eu/doc/img360.png ) - In 3D, the depth is the one corresponding to W nodes - The gridindexingtype is set to 'nemo'. See also the Grid indexing documentation on oceanparcels.org - indices : - Optional dictionary of indices for each dimension - to read from file(s), to allow for reading of subset of data. - Default is to read the full extent of each dimension. - Note that negative indices are not allowed. - fieldtype : - Optional dictionary mapping fields to fieldtypes to be used for UnitConverter. - (either 'U', 'V', 'Kh_zonal', 'Kh_meridional' or None) - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation, see also `this tutorial <../examples/tutorial_unitconverters.ipynb>`__: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - allow_time_extrapolation : bool - boolean whether to allow for extrapolation - (i.e. beyond the last available time snapshot) - Default is False if dimensions includes time, else True - time_periodic : bool, float or datetime.timedelta - To loop periodically over the time component of the Field. It is set to either False or the length of the period (either float in seconds or datetime.timedelta object). (Default: False) - This flag overrides the allow_time_extrapolation and sets it to False - tracer_interp_method : str - Method for interpolation of tracer fields. It is recommended to use 'cgrid_tracer' (default) - Note that in the case of from_nemo() and from_c_grid_dataset(), the velocity fields are default to 'cgrid_velocity' - chunksize : - size of the chunks in dask loading. Default is None (no chunking) - **kwargs : - Keyword arguments passed to the :func:`Fieldset.from_c_grid_dataset` constructor. - - """ - if "creation_log" not in kwargs.keys(): - kwargs["creation_log"] = "from_nemo" - if kwargs.pop("gridindexingtype", "nemo") != "nemo": - raise ValueError( - "gridindexingtype must be 'nemo' in FieldSet.from_nemo(). Use FieldSet.from_c_grid_dataset otherwise" - ) - fieldset = cls.from_c_grid_dataset( - filenames, - variables, - dimensions, - mesh=mesh, - indices=indices, - time_periodic=time_periodic, - allow_time_extrapolation=allow_time_extrapolation, - tracer_interp_method=tracer_interp_method, - chunksize=chunksize, - gridindexingtype="nemo", - **kwargs, - ) - if hasattr(fieldset, "W"): - fieldset.W.set_scaling_factor(-1.0) - return fieldset - - @classmethod - def from_mitgcm( - cls, - filenames, - variables, - dimensions, - indices=None, - mesh: Mesh = "spherical", - allow_time_extrapolation: bool | None = None, - time_periodic: TimePeriodic = False, - tracer_interp_method: InterpMethodOption = "cgrid_tracer", - chunksize=None, - **kwargs, - ): - """Initialises FieldSet object from NetCDF files of MITgcm fields. - All parameters and keywords are exactly the same as for FieldSet.from_nemo(), except that - gridindexing is set to 'mitgcm' for grids that have the shape:: - - +-----------------------------+-----------------------------+-----------------------------+ - | | V[k,j+1,i] | | - +-----------------------------+-----------------------------+-----------------------------+ - |U[k,j,i] | W[k-1:k,j,i], T[k,j,i] |U[k,j,i+1] | - +-----------------------------+-----------------------------+-----------------------------+ - | | V[k,j,i] | | - +-----------------------------+-----------------------------+-----------------------------+ - - For indexing details: https://mitgcm.readthedocs.io/en/latest/algorithm/algorithm.html#spatial-discretization-of-the-dynamical-equations - Note that vertical velocity (W) is assumed positive in the positive z direction (which is upward in MITgcm) - """ - if "creation_log" not in kwargs.keys(): - kwargs["creation_log"] = "from_mitgcm" - if kwargs.pop("gridindexingtype", "mitgcm") != "mitgcm": - raise ValueError( - "gridindexingtype must be 'mitgcm' in FieldSet.from_mitgcm(). Use FieldSet.from_c_grid_dataset otherwise" - ) - fieldset = cls.from_c_grid_dataset( - filenames, - variables, - dimensions, - mesh=mesh, - indices=indices, - time_periodic=time_periodic, - allow_time_extrapolation=allow_time_extrapolation, - tracer_interp_method=tracer_interp_method, - chunksize=chunksize, - gridindexingtype="mitgcm", - **kwargs, - ) - return fieldset - - @classmethod - def from_croco( - cls, - filenames, - variables, - dimensions, - hc: float | None = None, - indices=None, - mesh="spherical", - allow_time_extrapolation=None, - time_periodic=False, - tracer_interp_method="cgrid_tracer", - chunksize=None, - **kwargs, - ): - """Initialises FieldSet object from NetCDF files of CROCO fields. - All parameters and keywords are exactly the same as for FieldSet.from_nemo(), except that - in order to scale the vertical coordinate in CROCO, the following fields are required: - the bathymetry (``h``), the sea-surface height (``zeta``), the S-coordinate stretching curves - at W-points (``Cs_w``), and the stretching parameter (``hc``). - The horizontal interpolation uses the MITgcm grid indexing as described in FieldSet.from_mitgcm(). - - In 3D, when there is a ``depth`` dimension, the sigma grid scaling means that FieldSet.from_croco() - requires variables ``H: h`` and ``Zeta: zeta``, ``Cs_w: Cs_w``, as well as the stretching parameter ``hc`` - (as an extra input) parameter to work. - - See `the CROCO 3D tutorial <../examples/tutorial_croco_3D.ipynb>`__ for more infomation. - """ - if "creation_log" not in kwargs.keys(): - kwargs["creation_log"] = "from_croco" - if kwargs.pop("gridindexingtype", "croco") != "croco": - raise ValueError( - "gridindexingtype must be 'croco' in FieldSet.from_croco(). Use FieldSet.from_c_grid_dataset otherwise" - ) - - dimsU = dimensions["U"] if "U" in dimensions else dimensions - croco3D = True if "depth" in dimsU else False - - if croco3D: - if "W" in variables and variables["W"] == "omega": - warnings.warn( - "Note that Parcels expects 'w' for vertical velicites in 3D CROCO fields.\nSee https://docs.oceanparcels.org/en/latest/examples/tutorial_croco_3D.html for more information", - FieldSetWarning, - stacklevel=2, - ) - if "H" not in variables: - raise ValueError("FieldSet.from_croco() requires a bathymetry field 'H' for 3D CROCO fields") - if "Zeta" not in variables: - raise ValueError("FieldSet.from_croco() requires a free-surface field 'Zeta' for 3D CROCO fields") - if "Cs_w" not in variables: - raise ValueError( - "FieldSet.from_croco() requires the S-coordinate stretching curves at W-points 'Cs_w' for 3D CROCO fields" - ) - - interp_method = {} - for v in variables: - if v in ["U", "V"]: - interp_method[v] = "cgrid_velocity" - elif v in ["W", "H"]: - interp_method[v] = "linear" - else: - interp_method[v] = tracer_interp_method - - # Suppress the warning about the velocity interpolation since it is ok for CROCO - warnings.filterwarnings( - "ignore", - "Sampling of velocities should normally be done using fieldset.UV or fieldset.UVW object; tread carefully", - ) - - fieldset = cls.from_netcdf( - filenames, - variables, - dimensions, - mesh=mesh, - indices=indices, - time_periodic=time_periodic, - allow_time_extrapolation=allow_time_extrapolation, - interp_method=interp_method, - chunksize=chunksize, - gridindexingtype="croco", - **kwargs, - ) - if croco3D: - if hc is None: - raise ValueError("FieldSet.from_croco() requires the hc parameter for 3D CROCO fields") - fieldset.add_constant("hc", hc) - return fieldset - - @classmethod - def from_c_grid_dataset( - cls, - filenames, - variables, - dimensions, - indices=None, - mesh: Mesh = "spherical", - allow_time_extrapolation: bool | None = None, - time_periodic: TimePeriodic = False, - tracer_interp_method: InterpMethodOption = "cgrid_tracer", - gridindexingtype: GridIndexingType = "nemo", - chunksize=None, - **kwargs, - ): - """Initialises FieldSet object from NetCDF files of Curvilinear NEMO fields. - - See `here <../examples/documentation_indexing.ipynb>`__ - for a more detailed explanation of the different methods that can be used for c-grid datasets. - - Parameters - ---------- - filenames : - Dictionary mapping variables to file(s). The - filepath may contain wildcards to indicate multiple files, - or be a list of file. - filenames can be a list ``[files]``, a dictionary ``{var:[files]}``, - a dictionary ``{dim:[files]}`` (if lon, lat, depth and/or data not stored in same files as data), - or a dictionary of dictionaries ``{var:{dim:[files]}}`` - time values are in ``filenames[data]`` - variables : dict - Dictionary mapping variables to variable - names in the netCDF file(s). - dimensions : dict - Dictionary mapping data dimensions (lon, - lat, depth, time, data) to dimensions in the netCF file(s). - Note that dimensions can also be a dictionary of dictionaries if - dimension names are different for each variable. - Watch out: NEMO is discretised on a C-grid: - U and V velocities are not located on the same nodes (see https://www.nemo-ocean.eu/doc/node19.html ). :: - - +-----------------------------+-----------------------------+-----------------------------+ - | | V[k,j+1,i+1] | | - +-----------------------------+-----------------------------+-----------------------------+ - |U[k,j+1,i] |W[k:k+2,j+1,i+1],T[k,j+1,i+1]|U[k,j+1,i+1] | - +-----------------------------+-----------------------------+-----------------------------+ - | | V[k,j,i+1] | | - +-----------------------------+-----------------------------+-----------------------------+ - - To interpolate U, V velocities on the C-grid, Parcels needs to read the f-nodes, - which are located on the corners of the cells. - (for indexing details: https://www.nemo-ocean.eu/doc/img360.png ) - In 3D, the depth is the one corresponding to W nodes. - indices : - Optional dictionary of indices for each dimension - to read from file(s), to allow for reading of subset of data. - Default is to read the full extent of each dimension. - Note that negative indices are not allowed. - fieldtype : - Optional dictionary mapping fields to fieldtypes to be used for UnitConverter. - (either 'U', 'V', 'Kh_zonal', 'Kh_meridional' or None) - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation, see also `this tutorial <../examples/tutorial_unitconverters.ipynb>`__: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - allow_time_extrapolation : bool - boolean whether to allow for extrapolation - (i.e. beyond the last available time snapshot) - Default is False if dimensions includes time, else True - time_periodic : bool, float or datetime.timedelta - To loop periodically over the time component of the Field. It is set to either False or the length of the period (either float in seconds or datetime.timedelta object). (Default: False) - This flag overrides the allow_time_extrapolation and sets it to False - tracer_interp_method : str - Method for interpolation of tracer fields. It is recommended to use 'cgrid_tracer' (default) - Note that in the case of from_nemo() and from_c_grid_dataset(), the velocity fields are default to 'cgrid_velocity' - gridindexingtype : str - The type of gridindexing. Set to 'nemo' in FieldSet.from_nemo(), 'mitgcm' in FieldSet.from_mitgcm() or 'croco' in FieldSet.from_croco(). - See also the Grid indexing documentation on oceanparcels.org (Default value = 'nemo') - chunksize : - size of the chunks in dask loading. (Default value = None) - **kwargs : - Keyword arguments passed to the :func:`Fieldset.from_netcdf` constructor. - """ - if "U" in dimensions and "V" in dimensions and dimensions["U"] != dimensions["V"]: - raise ValueError( - "On a C-grid, the dimensions of velocities should be the corners (f-points) of the cells, so the same for U and V. " - "See also https://docs.oceanparcels.org/en/latest/examples/documentation_indexing.html" - ) - if "U" in dimensions and "W" in dimensions and dimensions["U"] != dimensions["W"]: - raise ValueError( - "On a C-grid, the dimensions of velocities should be the corners (f-points) of the cells, so the same for U, V and W. " - "See also https://docs.oceanparcels.org/en/latest/examples/documentation_indexing.html" - ) - if "interp_method" in kwargs.keys(): - raise TypeError("On a C-grid, the interpolation method for velocities should not be overridden") - - interp_method = {} - for v in variables: - if v in ["U", "V", "W"]: - interp_method[v] = "cgrid_velocity" - else: - interp_method[v] = tracer_interp_method - if "creation_log" not in kwargs.keys(): - kwargs["creation_log"] = "from_c_grid_dataset" - - return cls.from_netcdf( - filenames, - variables, - dimensions, - mesh=mesh, - indices=indices, - time_periodic=time_periodic, - allow_time_extrapolation=allow_time_extrapolation, - interp_method=interp_method, - chunksize=chunksize, - gridindexingtype=gridindexingtype, - **kwargs, - ) - - @classmethod - def from_pop( - cls, - filenames, - variables, - dimensions, - indices=None, - mesh: Mesh = "spherical", - allow_time_extrapolation: bool | None = None, - time_periodic: TimePeriodic = False, - tracer_interp_method: InterpMethodOption = "bgrid_tracer", - chunksize=None, - depth_units="m", - **kwargs, - ): - """Initialises FieldSet object from NetCDF files of POP fields. - It is assumed that the velocities in the POP fields is in cm/s. - - Parameters - ---------- - filenames : - Dictionary mapping variables to file(s). The - filepath may contain wildcards to indicate multiple files, - or be a list of file. - filenames can be a list ``[files]``, a dictionary ``{var:[files]}``, - a dictionary ``{dim:[files]}`` (if lon, lat, depth and/or data not stored in same files as data), - or a dictionary of dictionaries ``{var:{dim:[files]}}`` - time values are in ``filenames[data]`` - variables : dict - Dictionary mapping variables to variable names in the netCDF file(s). - Note that the built-in Advection kernels assume that U and V are in m/s - dimensions : dict - Dictionary mapping data dimensions (lon, - lat, depth, time, data) to dimensions in the netCF file(s). - Note that dimensions can also be a dictionary of dictionaries if - dimension names are different for each variable. - Watch out: POP is discretised on a B-grid: - U and V velocity nodes are not located as W velocity and T tracer nodes (see http://www2.cesm.ucar.edu/models/cesm1.0/pop2/doc/sci/POPRefManual.pdf ). :: - - +-----------------------------+-----------------------------+-----------------------------+ - |U[k,j+1,i],V[k,j+1,i] | |U[k,j+1,i+1],V[k,j+1,i+1] | - +-----------------------------+-----------------------------+-----------------------------+ - | |W[k:k+2,j+1,i+1],T[k,j+1,i+1]| | - +-----------------------------+-----------------------------+-----------------------------+ - |U[k,j,i],V[k,j,i] | |U[k,j,i+1],V[k,j,i+1] | - +-----------------------------+-----------------------------+-----------------------------+ - - In 2D: U and V nodes are on the cell vertices and interpolated bilinearly as a A-grid. - T node is at the cell centre and interpolated constant per cell as a C-grid. - In 3D: U and V nodes are at the middle of the cell vertical edges, - They are interpolated bilinearly (independently of z) in the cell. - W nodes are at the centre of the horizontal interfaces. - They are interpolated linearly (as a function of z) in the cell. - T node is at the cell centre, and constant per cell. - Note that Parcels assumes that the length of the depth dimension (at the W-points) - is one larger than the size of the velocity and tracer fields in the depth dimension. - indices : - Optional dictionary of indices for each dimension - to read from file(s), to allow for reading of subset of data. - Default is to read the full extent of each dimension. - Note that negative indices are not allowed. - fieldtype : - Optional dictionary mapping fields to fieldtypes to be used for UnitConverter. - (either 'U', 'V', 'Kh_zonal', 'Kh_meridional' or None) - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation, see also `this tutorial <../examples/tutorial_unitconverters.ipynb>`__: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - allow_time_extrapolation : bool - boolean whether to allow for extrapolation - (i.e. beyond the last available time snapshot) - Default is False if dimensions includes time, else True - time_periodic : bool, float or datetime.timedelta - To loop periodically over the time component of the Field. It is set to either False or the length of the period (either float in seconds or datetime.timedelta object). (Default: False) - This flag overrides the allow_time_extrapolation and sets it to False - tracer_interp_method : str - Method for interpolation of tracer fields. It is recommended to use 'bgrid_tracer' (default) - Note that in the case of from_pop() and from_b_grid_dataset(), the velocity fields are default to 'bgrid_velocity' - chunksize : - size of the chunks in dask loading (Default value = None) - depth_units : - The units of the vertical dimension. Default in Parcels is 'm', - but many POP outputs are in 'cm' - **kwargs : - Keyword arguments passed to the :func:`Fieldset.from_b_grid_dataset` constructor. - - """ - if "creation_log" not in kwargs.keys(): - kwargs["creation_log"] = "from_pop" - fieldset = cls.from_b_grid_dataset( - filenames, - variables, - dimensions, - mesh=mesh, - indices=indices, - time_periodic=time_periodic, - allow_time_extrapolation=allow_time_extrapolation, - tracer_interp_method=tracer_interp_method, - chunksize=chunksize, - gridindexingtype="pop", - **kwargs, - ) - if hasattr(fieldset, "U"): - fieldset.U.set_scaling_factor(0.01) # cm/s to m/s - if hasattr(fieldset, "V"): - fieldset.V.set_scaling_factor(0.01) # cm/s to m/s - if hasattr(fieldset, "W"): - if depth_units == "m": - fieldset.W.set_scaling_factor(-0.01) # cm/s to m/s and change the W direction - warnings.warn( - "Parcels assumes depth in POP output to be in 'm'. Use depth_units='cm' if the output depth is in 'cm'.", - FieldSetWarning, - stacklevel=2, - ) - elif depth_units == "cm": - fieldset.W.set_scaling_factor(-1.0) # change the W direction but keep W in cm/s because depth is in cm - else: - raise SyntaxError("'depth_units' has to be 'm' or 'cm'") - return fieldset - - @classmethod - def from_mom5( - cls, - filenames, - variables, - dimensions, - indices=None, - mesh: Mesh = "spherical", - allow_time_extrapolation: bool | None = None, - time_periodic: TimePeriodic = False, - tracer_interp_method: InterpMethodOption = "bgrid_tracer", - chunksize=None, - **kwargs, - ): - """Initialises FieldSet object from NetCDF files of MOM5 fields. - - Parameters - ---------- - filenames : - Dictionary mapping variables to file(s). The - filepath may contain wildcards to indicate multiple files, - or be a list of file. - filenames can be a list ``[files]``, a dictionary ``{var:[files]}``, - a dictionary ``{dim:[files]}`` (if lon, lat, depth and/or data not stored in same files as data), - or a dictionary of dictionaries ``{var:{dim:[files]}}`` - time values are in ``filenames[data]`` - variables : dict - Dictionary mapping variables to variable names in the netCDF file(s). - Note that the built-in Advection kernels assume that U and V are in m/s - dimensions : dict - Dictionary mapping data dimensions (lon, - lat, depth, time, data) to dimensions in the netCF file(s). - Note that dimensions can also be a dictionary of dictionaries if - dimension names are different for each variable. :: - - +-------------------------------+-------------------------------+-------------------------------+ - |U[k,j+1,i],V[k,j+1,i] | |U[k,j+1,i+1],V[k,j+1,i+1] | - +-------------------------------+-------------------------------+-------------------------------+ - | |W[k-1:k+1,j+1,i+1],T[k,j+1,i+1]| | - +-------------------------------+-------------------------------+-------------------------------+ - |U[k,j,i],V[k,j,i] | |U[k,j,i+1],V[k,j,i+1] | - +-------------------------------+-------------------------------+-------------------------------+ - - In 2D: U and V nodes are on the cell vertices and interpolated bilinearly as a A-grid. - T node is at the cell centre and interpolated constant per cell as a C-grid. - In 3D: U and V nodes are at the middle of the cell vertical edges, - They are interpolated bilinearly (independently of z) in the cell. - W nodes are at the centre of the horizontal interfaces, but below the U and V. - They are interpolated linearly (as a function of z) in the cell. - Note that W is normally directed upward in MOM5, but Parcels requires W - in the positive z-direction (downward) so W is multiplied by -1. - T node is at the cell centre, and constant per cell. - indices : - Optional dictionary of indices for each dimension - to read from file(s), to allow for reading of subset of data. - Default is to read the full extent of each dimension. - Note that negative indices are not allowed. - fieldtype : - Optional dictionary mapping fields to fieldtypes to be used for UnitConverter. - (either 'U', 'V', 'Kh_zonal', 'Kh_meridional' or None) - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation, see also the `Unit converters tutorial <../examples/tutorial_unitconverters.ipynb>`__: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - allow_time_extrapolation : bool - boolean whether to allow for extrapolation - (i.e. beyond the last available time snapshot) - Default is False if dimensions includes time, else True - time_periodic: - To loop periodically over the time component of the Field. It is set to either False or the length of the period (either float in seconds or datetime.timedelta object). (Default: False) - This flag overrides the allow_time_extrapolation and sets it to False - tracer_interp_method : str - Method for interpolation of tracer fields. It is recommended to use 'bgrid_tracer' (default) - Note that in the case of from_mom5() and from_b_grid_dataset(), the velocity fields are default to 'bgrid_velocity' - chunksize : - size of the chunks in dask loading (Default value = None) - **kwargs : - Keyword arguments passed to the :func:`Fieldset.from_b_grid_dataset` constructor. - """ - if "creation_log" not in kwargs.keys(): - kwargs["creation_log"] = "from_mom5" - fieldset = cls.from_b_grid_dataset( - filenames, - variables, - dimensions, - mesh=mesh, - indices=indices, - time_periodic=time_periodic, - allow_time_extrapolation=allow_time_extrapolation, - tracer_interp_method=tracer_interp_method, - chunksize=chunksize, - gridindexingtype="mom5", - **kwargs, - ) - if hasattr(fieldset, "W"): - fieldset.W.set_scaling_factor(-1) - return fieldset - - @classmethod - def from_a_grid_dataset(cls, filenames, variables, dimensions, **kwargs): - """ - Load a FieldSet from an A-grid dataset, which is the default grid type. - - Parameters - ---------- - filenames : - Path(s) to the input files. - variables : - Dictionary of the variables in the NetCDF file. - dimensions : - Dictionary of the dimensions in the NetCDF file. - **kwargs : - Additional keyword arguments for `from_netcdf()`. - - Returns - ------- - FieldSet - A FieldSet object. - """ - return cls.from_netcdf(filenames, variables, dimensions, **kwargs) - - @classmethod - def from_b_grid_dataset( - cls, - filenames, - variables, - dimensions, - indices=None, - mesh: Mesh = "spherical", - allow_time_extrapolation: bool | None = None, - time_periodic: TimePeriodic = False, - tracer_interp_method: InterpMethodOption = "bgrid_tracer", - chunksize=None, - **kwargs, - ): - """Initialises FieldSet object from NetCDF files of Bgrid fields. - - Parameters - ---------- - filenames : - Dictionary mapping variables to file(s). The - filepath may contain wildcards to indicate multiple files, - or be a list of file. - filenames can be a list ``[files]``, a dictionary ``{var:[files]}``, - a dictionary ``{dim:[files]}`` (if lon, lat, depth and/or data not stored in same files as data), - or a dictionary of dictionaries ``{var:{dim:[files]}}`` - time values are in ``filenames[data]`` - variables : dict - Dictionary mapping variables to variable - names in the netCDF file(s). - dimensions : dict - Dictionary mapping data dimensions (lon, - lat, depth, time, data) to dimensions in the netCF file(s). - Note that dimensions can also be a dictionary of dictionaries if - dimension names are different for each variable. - U and V velocity nodes are not located as W velocity and T tracer nodes (see http://www2.cesm.ucar.edu/models/cesm1.0/pop2/doc/sci/POPRefManual.pdf ). :: - - +-----------------------------+-----------------------------+-----------------------------+ - |U[k,j+1,i],V[k,j+1,i] | |U[k,j+1,i+1],V[k,j+1,i+1] | - +-----------------------------+-----------------------------+-----------------------------+ - | |W[k:k+2,j+1,i+1],T[k,j+1,i+1]| | - +-----------------------------+-----------------------------+-----------------------------+ - |U[k,j,i],V[k,j,i] | |U[k,j,i+1],V[k,j,i+1] | - +-----------------------------+-----------------------------+-----------------------------+ - - In 2D: U and V nodes are on the cell vertices and interpolated bilinearly as a A-grid. - T node is at the cell centre and interpolated constant per cell as a C-grid. - In 3D: U and V nodes are at the midlle of the cell vertical edges, - They are interpolated bilinearly (independently of z) in the cell. - W nodes are at the centre of the horizontal interfaces. - They are interpolated linearly (as a function of z) in the cell. - T node is at the cell centre, and constant per cell. - indices : - Optional dictionary of indices for each dimension - to read from file(s), to allow for reading of subset of data. - Default is to read the full extent of each dimension. - Note that negative indices are not allowed. - fieldtype : - Optional dictionary mapping fields to fieldtypes to be used for UnitConverter. - (either 'U', 'V', 'Kh_zonal', 'Kh_meridional' or None) - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation, see also `this tutorial <../examples/tutorial_unitconverters.ipynb>`__: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - allow_time_extrapolation : bool - boolean whether to allow for extrapolation - (i.e. beyond the last available time snapshot) - Default is False if dimensions includes time, else True - time_periodic : bool, float or datetime.timedelta - To loop periodically over the time component of the Field. It is set to either False or the length of the period (either float in seconds or datetime.timedelta object). (Default: False) - This flag overrides the allow_time_extrapolation and sets it to False - tracer_interp_method : str - Method for interpolation of tracer fields. It is recommended to use 'bgrid_tracer' (default) - Note that in the case of from_pop() and from_b_grid_dataset(), the velocity fields are default to 'bgrid_velocity' - chunksize : - size of the chunks in dask loading (Default value = None) - **kwargs : - Keyword arguments passed to the :func:`Fieldset.from_netcdf` constructor. - """ - if "U" in dimensions and "V" in dimensions and dimensions["U"] != dimensions["V"]: - raise ValueError( - "On a B-grid, the dimensions of velocities should be the (top) corners of the grid cells, so the same for U and V. " - "See also https://docs.oceanparcels.org/en/latest/examples/documentation_indexing.html" - ) - if "U" in dimensions and "W" in dimensions and dimensions["U"] != dimensions["W"]: - raise ValueError( - "On a B-grid, the dimensions of velocities should be the (top) corners of the grid cells, so the same for U, V and W. " - "See also https://docs.oceanparcels.org/en/latest/examples/documentation_indexing.html" - ) - - interp_method = {} - for v in variables: - if v in ["U", "V"]: - interp_method[v] = "bgrid_velocity" - elif v in ["W"]: - interp_method[v] = "bgrid_w_velocity" - else: - interp_method[v] = tracer_interp_method - if "creation_log" not in kwargs.keys(): - kwargs["creation_log"] = "from_b_grid_dataset" - - return cls.from_netcdf( - filenames, - variables, - dimensions, - mesh=mesh, - indices=indices, - time_periodic=time_periodic, - allow_time_extrapolation=allow_time_extrapolation, - interp_method=interp_method, - chunksize=chunksize, - **kwargs, - ) - - @classmethod - def from_parcels( - cls, - basename, - uvar="vozocrtx", - vvar="vomecrty", - indices=None, - extra_fields=None, - allow_time_extrapolation: bool | None = None, - time_periodic: TimePeriodic = False, - deferred_load=True, - chunksize=None, - **kwargs, - ): - """Initialises FieldSet data from NetCDF files using the Parcels FieldSet.write() conventions. - - Parameters - ---------- - basename : str - Base name of the file(s); may contain - wildcards to indicate multiple files. - indices : - Optional dictionary of indices for each dimension - to read from file(s), to allow for reading of subset of data. - Default is to read the full extent of each dimension. - Note that negative indices are not allowed. - fieldtype : - Optional dictionary mapping fields to fieldtypes to be used for UnitConverter. - (either 'U', 'V', 'Kh_zonal', 'Kh_meridional' or None) - extra_fields : - Extra fields to read beyond U and V (Default value = None) - allow_time_extrapolation : bool - boolean whether to allow for extrapolation - (i.e. beyond the last available time snapshot) - Default is False if dimensions includes time, else True - time_periodic : bool, float or datetime.timedelta - To loop periodically over the time component of the Field. It is set to either False or the length of the period (either float in seconds or datetime.timedelta object). (Default: False) - This flag overrides the allow_time_extrapolation and sets it to False - deferred_load : bool - boolean whether to only pre-load data (in deferred mode) or - fully load them (default: True). It is advised to deferred load the data, since in - that case Parcels deals with a better memory management during particle set execution. - deferred_load=False is however sometimes necessary for plotting the fields. - chunksize : - size of the chunks in dask loading (Default value = None) - uvar : - (Default value = 'vozocrtx') - vvar : - (Default value = 'vomecrty') - **kwargs : - Keyword arguments passed to the :func:`Fieldset.from_netcdf` constructor. - """ - if extra_fields is None: - extra_fields = {} - if "creation_log" not in kwargs.keys(): - kwargs["creation_log"] = "from_parcels" - - dimensions = {} - default_dims = {"lon": "nav_lon", "lat": "nav_lat", "depth": "depth", "time": "time_counter"} - extra_fields.update({"U": uvar, "V": vvar}) - for vars in extra_fields: - dimensions[vars] = deepcopy(default_dims) - dimensions[vars]["depth"] = f"depth{vars.lower()}" - filenames = {v: str(f"{basename}{v}.nc") for v in extra_fields.keys()} - return cls.from_netcdf( - filenames, - indices=indices, - variables=extra_fields, - dimensions=dimensions, - allow_time_extrapolation=allow_time_extrapolation, - time_periodic=time_periodic, - deferred_load=deferred_load, - chunksize=chunksize, - **kwargs, - ) - - @classmethod - def from_xarray_dataset( - cls, ds, variables, dimensions, mesh="spherical", allow_time_extrapolation=None, time_periodic=False, **kwargs - ): - """Initialises FieldSet data from xarray Datasets. - - Parameters - ---------- - ds : xr.Dataset - xarray Dataset. - Note that the built-in Advection kernels assume that U and V are in m/s - variables : dict - Dictionary mapping parcels variable names to data variables in the xarray Dataset. - dimensions : dict - Dictionary mapping data dimensions (lon, - lat, depth, time, data) to dimensions in the xarray Dataset. - Note that dimensions can also be a dictionary of dictionaries if - dimension names are different for each variable - (e.g. dimensions['U'], dimensions['V'], etc). - fieldtype : - Optional dictionary mapping fields to fieldtypes to be used for UnitConverter. - (either 'U', 'V', 'Kh_zonal', 'Kh_meridional' or None) - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation, see also `this tutorial <../examples/tutorial_unitconverters.ipynb>`__: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - allow_time_extrapolation : bool - boolean whether to allow for extrapolation - (i.e. beyond the last available time snapshot) - Default is False if dimensions includes time, else True - time_periodic : bool, float or datetime.timedelta - To loop periodically over the time component of the Field. It is set to either False or the length of the period (either float in seconds or datetime.timedelta object). (Default: False) - This flag overrides the allow_time_extrapolation and sets it to False - **kwargs : - Keyword arguments passed to the :func:`Field.from_xarray` constructor. - """ - fields = {} - if "creation_log" not in kwargs.keys(): - kwargs["creation_log"] = "from_xarray_dataset" - if "time" in dimensions: - if "units" not in ds[dimensions["time"]].attrs and "Unit" in ds[dimensions["time"]].attrs: - # Fix DataArrays that have time.Unit instead of expected time.units - convert_xarray_time_units(ds, dimensions["time"]) - - for var, name in variables.items(): - dims = dimensions[var] if var in dimensions else dimensions - cls.checkvaliddimensionsdict(dims) - - fields[var] = Field.from_xarray( - ds[name], - var, - dims, - mesh=mesh, - allow_time_extrapolation=allow_time_extrapolation, - time_periodic=time_periodic, - **kwargs, - ) - u = fields.pop("U", None) - v = fields.pop("V", None) - return cls(u, v, fields=fields) - - @classmethod - def from_modulefile(cls, filename, modulename="create_fieldset", **kwargs): - """Initialises FieldSet data from a file containing a python module file with a create_fieldset() function. - - Parameters - ---------- - filename: path to a python file containing at least a function which returns a FieldSet object. - modulename: name of the function in the python file that returns a FieldSet object. Default is "create_fieldset". - """ - # check if filename exists - if not os.path.exists(filename): - raise OSError(f"FieldSet module file {filename} does not exist") - - # Importing the source file directly (following https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly) - spec = importlib.util.spec_from_file_location(modulename, filename) - fieldset_module = importlib.util.module_from_spec(spec) - sys.modules[modulename] = fieldset_module - spec.loader.exec_module(fieldset_module) - - if not hasattr(fieldset_module, modulename): - raise OSError(f"{filename} does not contain a {modulename} function") - fieldset = getattr(fieldset_module, modulename)(**kwargs) - if not isinstance(fieldset, FieldSet): - raise OSError(f"Module {filename}.{modulename} does not return a FieldSet object") - return fieldset - - def get_fields(self) -> list[Field | VectorField]: - """Returns a list of all the :class:`parcels.field.Field` and :class:`parcels.field.VectorField` - objects associated with this FieldSet. - """ - fields = [] - for v in self.__dict__.values(): - if type(v) in [Field, VectorField]: - if v not in fields: - fields.append(v) - elif isinstance(v, NestedField): - if v not in fields: - fields.append(v) - for v2 in v: - if v2 not in fields: - fields.append(v2) - return fields - - def add_constant(self, name, value): - """Add a constant to the FieldSet. Note that all constants are - stored as 32-bit floats. While constants can be updated during - execution in SciPy mode, they can not be updated in JIT mode. - - Parameters - ---------- - name : str - Name of the constant - value : - Value of the constant (stored as 32-bit float) - - - Examples - -------- - Tutorials using fieldset.add_constant: - `Analytical advection <../examples/tutorial_analyticaladvection.ipynb>`__ - `Diffusion <../examples/tutorial_diffusion.ipynb>`__ - `Periodic boundaries <../examples/tutorial_periodic_boundaries.ipynb>`__ - """ - setattr(self, name, value) - - def add_periodic_halo(self, zonal=False, meridional=False, halosize=5): - """Add a 'halo' to all :class:`parcels.field.Field` objects in a FieldSet, - through extending the Field (and lon/lat) by copying a small portion - of the field on one side of the domain to the other. - - Parameters - ---------- - zonal : bool - Create a halo in zonal direction (Default value = False) - meridional : bool - Create a halo in meridional direction (Default value = False) - halosize : int - size of the halo (in grid points). Default is 5 grid points - """ - for grid in self.gridset.grids: - grid.add_periodic_halo(zonal, meridional, halosize) - for value in self.__dict__.values(): - if isinstance(value, Field): - value.add_periodic_halo(zonal, meridional, halosize) - - def write(self, filename): - """Write FieldSet to NetCDF file using NEMO convention. - - Parameters - ---------- - filename : str - Basename of the output fileset. - """ - if MPI is None or MPI.COMM_WORLD.Get_rank() == 0: - logger.info(f"Generating FieldSet output with basename: {filename}") - - if hasattr(self, "U"): - self.U.write(filename, varname="vozocrtx") - if hasattr(self, "V"): - self.V.write(filename, varname="vomecrty") - - for v in self.get_fields(): - if isinstance(v, Field) and (v.name != "U") and (v.name != "V"): - v.write(filename) - - def computeTimeChunk(self, time=0.0, dt=1): - """Load a chunk of three data time steps into the FieldSet. - This is used when FieldSet uses data imported from netcdf, - with default option deferred_load. The loaded time steps are at or immediatly before time - and the two time steps immediately following time if dt is positive (and inversely for negative dt) - - Parameters - ---------- - time : - Time around which the FieldSet chunks are to be loaded. - Time is provided as a double, relatively to Fieldset.time_origin. - Default is 0. - dt : - time step of the integration scheme, needed to set the direction of time chunk loading. - Default is 1. - """ - signdt = np.sign(dt) - nextTime = np.inf if dt > 0 else -np.inf - - for g in self.gridset.grids: - g._update_status = "not_updated" - for f in self.get_fields(): - if isinstance(f, (VectorField, NestedField)) or not f.grid.defer_load: - continue - if f.grid._update_status == "not_updated": - nextTime_loc = f.grid._computeTimeChunk(f, time, signdt) - if time == nextTime_loc and signdt != 0: - raise TimeExtrapolationError(time, field=f) - nextTime = min(nextTime, nextTime_loc) if signdt >= 0 else max(nextTime, nextTime_loc) - - for f in self.get_fields(): - if isinstance(f, (VectorField, NestedField)) or not f.grid.defer_load or f._dataFiles is None: - continue - f._loaded_time_indices = [] # reset loaded time indices - g = f.grid - if g._update_status == "first_updated": # First load of data - if f.data is not None and not isinstance(f.data, DeferredArray): - if not isinstance(f.data, list): - f.data = None - else: - for i in range(len(f.data)): - del f.data[i, :] - - lib = np if f.chunksize in [False, None] else da - if f.gridindexingtype == "pop" and g.zdim > 1: - zd = g.zdim - 1 - else: - zd = g.zdim - data = lib.empty( - (g.tdim, zd, g.ydim - 2 * g.meridional_halo, g.xdim - 2 * g.zonal_halo), dtype=np.float32 - ) - f._loaded_time_indices = range(2) - for tind in f._loaded_time_indices: - for fb in f.filebuffers: - if fb is not None: - fb.close() - fb = None - data = f.computeTimeChunk(data, tind) - data = f._rescale_and_set_minmax(data) - - if isinstance(f.data, DeferredArray): - f.data = DeferredArray() - f.data = f._reshape(data) - if not f._chunk_set: - f._chunk_setup() - if len(g._load_chunk) > g._chunk_not_loaded: - g._load_chunk = np.where( - g._load_chunk == g._chunk_loaded_touched, g._chunk_loading_requested, g._load_chunk - ) - g._load_chunk = np.where(g._load_chunk == g._chunk_deprecated, g._chunk_not_loaded, g._load_chunk) - - elif g._update_status == "updated": - lib = np if isinstance(f.data, np.ndarray) else da - if f.gridindexingtype == "pop" and g.zdim > 1: - zd = g.zdim - 1 - else: - zd = g.zdim - data = lib.empty( - (g.tdim, zd, g.ydim - 2 * g.meridional_halo, g.xdim - 2 * g.zonal_halo), dtype=np.float32 - ) - if signdt >= 0: - f._loaded_time_indices = [1] - if f.filebuffers[0] is not None: - f.filebuffers[0].close() - f.filebuffers[0] = None - f.filebuffers[0] = f.filebuffers[1] - data = f.computeTimeChunk(data, 1) - else: - f._loaded_time_indices = [0] - if f.filebuffers[1] is not None: - f.filebuffers[1].close() - f.filebuffers[1] = None - f.filebuffers[1] = f.filebuffers[0] - data = f.computeTimeChunk(data, 0) - data = f._rescale_and_set_minmax(data) - if signdt >= 0: - data = f._reshape(data)[1, :] - if lib is da: - f.data = lib.stack([f.data[1, :], data], axis=0) - else: - if not isinstance(f.data, DeferredArray): - if isinstance(f.data, list): - del f.data[0, :] - else: - f.data[0, :] = None - f.data[0, :] = f.data[1, :] - f.data[1, :] = data - else: - data = f._reshape(data)[0, :] - if lib is da: - f.data = lib.stack([data, f.data[0, :]], axis=0) - else: - if not isinstance(f.data, DeferredArray): - if isinstance(f.data, list): - del f.data[1, :] - else: - f.data[1, :] = None - f.data[1, :] = f.data[0, :] - f.data[0, :] = data - g._load_chunk = np.where( - g._load_chunk == g._chunk_loaded_touched, g._chunk_loading_requested, g._load_chunk - ) - g._load_chunk = np.where(g._load_chunk == g._chunk_deprecated, g._chunk_not_loaded, g._load_chunk) - if isinstance(f.data, da.core.Array) and len(g._load_chunk) > 0: - if signdt >= 0: - for block_id in range(len(g._load_chunk)): - if g._load_chunk[block_id] == g._chunk_loaded_touched: - if f._data_chunks[block_id] is None: - # file chunks were never loaded. - # happens when field not called by kernel, but shares a grid with another field called by kernel - break - block = f.get_block(block_id) - f._data_chunks[block_id][0] = None - f._data_chunks[block_id][1] = np.array(f.data.blocks[(slice(2),) + block][1]) - else: - for block_id in range(len(g._load_chunk)): - if g._load_chunk[block_id] == g._chunk_loaded_touched: - if f._data_chunks[block_id] is None: - # file chunks were never loaded. - # happens when field not called by kernel, but shares a grid with another field called by kernel - break - block = f.get_block(block_id) - f._data_chunks[block_id][1] = None - f._data_chunks[block_id][0] = np.array(f.data.blocks[(slice(2),) + block][0]) - # do user-defined computations on fieldset data - if self.compute_on_defer: - self.compute_on_defer(self) - - # update time varying grid depth - for f in self.get_fields(): - if isinstance(f, (VectorField, NestedField)) or not f.grid.defer_load or f._dataFiles is None: - continue - if f.grid.depth_field is not None: - depth_data = f.grid.depth_field.data - f.grid._depth = depth_data if isinstance(depth_data, np.ndarray) else np.array(depth_data) - - if abs(nextTime) == np.inf or np.isnan(nextTime): # Second happens when dt=0 - return nextTime - else: - nSteps = int((nextTime - time) / dt) - if nSteps == 0: - return nextTime - else: - return time + nSteps * dt diff --git a/parcels/grid.py b/parcels/grid.py deleted file mode 100644 index 244afe149..000000000 --- a/parcels/grid.py +++ /dev/null @@ -1,854 +0,0 @@ -import functools -import warnings -from ctypes import POINTER, Structure, c_double, c_float, c_int, c_void_p, cast, pointer -from enum import IntEnum - -import numpy as np -import numpy.typing as npt - -from parcels._typing import Mesh, UpdateStatus, assert_valid_mesh -from parcels.tools._helpers import deprecated_made_private -from parcels.tools.converters import Geographic, GeographicPolar, TimeConverter, UnitConverter -from parcels.tools.warnings import FieldSetWarning - -__all__ = [ - "CGrid", - "CurvilinearSGrid", - "CurvilinearZGrid", - "Grid", - "GridCode", - "GridType", - "RectilinearSGrid", - "RectilinearZGrid", -] - - -class GridType(IntEnum): - RectilinearZGrid = 0 - RectilinearSGrid = 1 - CurvilinearZGrid = 2 - CurvilinearSGrid = 3 - - -# GridCode has been renamed to GridType for consistency. -# TODO: Remove alias in Parcels v4 -GridCode = GridType - - -class CGrid(Structure): - _fields_ = [("gtype", c_int), ("grid", c_void_p)] - - -class Grid: - """Grid class that defines a (spatial and temporal) grid on which Fields are defined.""" - - def __init__( - self, - lon: npt.NDArray, - lat: npt.NDArray, - time: npt.NDArray | None, - time_origin: TimeConverter | None, - mesh: Mesh, - ): - self._ti = -1 - self._update_status: UpdateStatus | None = None - if not lon.flags["C_CONTIGUOUS"]: - lon = np.array(lon, order="C") - if not lat.flags["C_CONTIGUOUS"]: - lat = np.array(lat, order="C") - time = np.zeros(1, dtype=np.float64) if time is None else time - if not time.flags["C_CONTIGUOUS"]: - time = np.array(time, order="C") - if not lon.dtype == np.float32: - lon = lon.astype(np.float32) - if not lat.dtype == np.float32: - lat = lat.astype(np.float32) - if not time.dtype == np.float64: - assert isinstance( - time[0], (np.integer, np.floating, float, int) - ), "Time vector must be an array of int or floats" - time = time.astype(np.float64) - - self._lon = lon - self._lat = lat - self.time = time - self.time_full = self.time # needed for deferred_loaded Fields - self._time_origin = TimeConverter() if time_origin is None else time_origin - assert isinstance(self.time_origin, TimeConverter), "time_origin needs to be a TimeConverter object" - assert_valid_mesh(mesh) - self._mesh = mesh - self._cstruct = None - self._cell_edge_sizes: dict[str, npt.NDArray] = {} - self._zonal_periodic = False - self._zonal_halo = 0 - self._meridional_halo = 0 - self._lat_flipped = False - self._defer_load = False - self._lonlat_minmax = np.array( - [np.nanmin(lon), np.nanmax(lon), np.nanmin(lat), np.nanmax(lat)], dtype=np.float32 - ) - self.periods = 0 - self._load_chunk: npt.NDArray = np.array([]) - self.chunk_info = None - self.chunksize = None - self._add_last_periodic_data_timestep = False - self.depth_field = None - - def __repr__(self): - with np.printoptions(threshold=5, suppress=True, linewidth=120, formatter={"float": "{: 0.2f}".format}): - return ( - f"{type(self).__name__}(" - f"lon={self.lon!r}, lat={self.lat!r}, time={self.time!r}, " - f"time_origin={self.time_origin!r}, mesh={self.mesh!r})" - ) - - @property - def lon(self): - return self._lon - - @property - def lat(self): - return self._lat - - @property - def depth(self): - return self._depth - - def negate_depth(self): - """Method to flip the sign of the depth dimension of a Grid. - Note that this method does _not_ change the direction of the vertical velocity; - for that users need to add a fieldset.W.set_scaling_factor(-1.0) - """ - self._depth = -self._depth - - @property - def mesh(self): - return self._mesh - - @property - def meridional_halo(self): - return self._meridional_halo - - @property - def lonlat_minmax(self): - return self._lonlat_minmax - - @property - def time_origin(self): - return self._time_origin - - @property - def zonal_periodic(self): - return self._zonal_periodic - - @property - def zonal_halo(self): - return self._zonal_halo - - @property - def defer_load(self): - return self._defer_load - - @property - def cell_edge_sizes(self): - return self._cell_edge_sizes - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def ti(self): - return self._ti - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def cstruct(self): - return self._cstruct - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def lat_flipped(self): - return self._lat_flipped - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def cgrid(self): - return self._cgrid - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def gtype(self): - return self._gtype - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def z4d(self): - return self._z4d - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def update_status(self): - return self._update_status - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def load_chunk(self): - return self._load_chunk - - @staticmethod - def create_grid( - lon: npt.ArrayLike, - lat: npt.ArrayLike, - depth, - time, - time_origin, - mesh: Mesh, - **kwargs, - ): - lon = np.array(lon) - lat = np.array(lat) - - if depth is not None: - depth = np.array(depth) - - if len(lon.shape) <= 1: - if depth is None or len(depth.shape) <= 1: - return RectilinearZGrid(lon, lat, depth, time, time_origin=time_origin, mesh=mesh, **kwargs) - else: - return RectilinearSGrid(lon, lat, depth, time, time_origin=time_origin, mesh=mesh, **kwargs) - else: - if depth is None or len(depth.shape) <= 1: - return CurvilinearZGrid(lon, lat, depth, time, time_origin=time_origin, mesh=mesh, **kwargs) - else: - return CurvilinearSGrid(lon, lat, depth, time, time_origin=time_origin, mesh=mesh, **kwargs) - - @property - def ctypes_struct(self): - # This is unnecessary for the moment, but it could be useful when going will fully unstructured grids - self._cgrid = cast(pointer(self._child_ctypes_struct), c_void_p) - cstruct = CGrid(self._gtype, self._cgrid.value) - return cstruct - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def child_ctypes_struct(self): - return self._child_ctypes_struct - - @property - def _child_ctypes_struct(self): - """Returns a ctypes struct object containing all relevant - pointers and sizes for this grid. - """ - - class CStructuredGrid(Structure): - # z4d is only to have same cstruct as RectilinearSGrid - _fields_ = [ - ("xdim", c_int), - ("ydim", c_int), - ("zdim", c_int), - ("tdim", c_int), - ("z4d", c_int), - ("mesh_spherical", c_int), - ("zonal_periodic", c_int), - ("chunk_info", POINTER(c_int)), - ("load_chunk", POINTER(c_int)), - ("tfull_min", c_double), - ("tfull_max", c_double), - ("periods", POINTER(c_int)), - ("lonlat_minmax", POINTER(c_float)), - ("lon", POINTER(c_float)), - ("lat", POINTER(c_float)), - ("depth", POINTER(c_float)), - ("time", POINTER(c_double)), - ] - - # Create and populate the c-struct object - if not self._cstruct: # Not to point to the same grid various times if grid in various fields - if not isinstance(self.periods, c_int): - self.periods = c_int() - self.periods.value = 0 - self._cstruct = CStructuredGrid( - self.xdim, - self.ydim, - self.zdim, - self.tdim, - self._z4d, - int(self.mesh == "spherical"), - int(self.zonal_periodic), - (c_int * len(self.chunk_info))(*self.chunk_info), - self._load_chunk.ctypes.data_as(POINTER(c_int)), - self.time_full[0], - self.time_full[-1], - pointer(self.periods), - self.lonlat_minmax.ctypes.data_as(POINTER(c_float)), - self.lon.ctypes.data_as(POINTER(c_float)), - self.lat.ctypes.data_as(POINTER(c_float)), - self.depth.ctypes.data_as(POINTER(c_float)), - self.time.ctypes.data_as(POINTER(c_double)), - ) - return self._cstruct - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def check_zonal_periodic(self, *args, **kwargs): - return self._check_zonal_periodic(*args, **kwargs) - - def _check_zonal_periodic(self): - if self.zonal_periodic or self.mesh == "flat" or self.lon.size == 1: - return - dx = (self.lon[1:] - self.lon[:-1]) if len(self.lon.shape) == 1 else self.lon[0, 1:] - self.lon[0, :-1] - dx = np.where(dx < -180, dx + 360, dx) - dx = np.where(dx > 180, dx - 360, dx) - self._zonal_periodic = sum(dx) > 359.9 - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def add_Sdepth_periodic_halo(self, *args, **kwargs): - return self._add_Sdepth_periodic_halo(*args, **kwargs) - - def _add_Sdepth_periodic_halo(self, zonal, meridional, halosize): - if zonal: - if len(self.depth.shape) == 3: - self._depth = np.concatenate( - (self.depth[:, :, -halosize:], self.depth, self.depth[:, :, 0:halosize]), - axis=len(self.depth.shape) - 1, - ) - assert self.depth.shape[2] == self.xdim, "Third dim must be x." - else: - self._depth = np.concatenate( - (self.depth[:, :, :, -halosize:], self.depth, self.depth[:, :, :, 0:halosize]), - axis=len(self.depth.shape) - 1, - ) - assert self.depth.shape[3] == self.xdim, "Fourth dim must be x." - if meridional: - if len(self.depth.shape) == 3: - self._depth = np.concatenate( - (self.depth[:, -halosize:, :], self.depth, self.depth[:, 0:halosize, :]), - axis=len(self.depth.shape) - 2, - ) - assert self.depth.shape[1] == self.ydim, "Second dim must be y." - else: - self._depth = np.concatenate( - (self.depth[:, :, -halosize:, :], self.depth, self.depth[:, :, 0:halosize, :]), - axis=len(self.depth.shape) - 2, - ) - assert self.depth.shape[2] == self.ydim, "Third dim must be y." - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def computeTimeChunk(self, *args, **kwargs): - return self._computeTimeChunk(*args, **kwargs) - - def _computeTimeChunk(self, f, time, signdt): - nextTime_loc = np.inf if signdt >= 0 else -np.inf - periods = self.periods.value if isinstance(self.periods, c_int) else self.periods - prev_time_indices = self.time - if self._update_status == "not_updated": - if self._ti >= 0: - if ( - time - periods * (self.time_full[-1] - self.time_full[0]) < self.time[0] - or time - periods * (self.time_full[-1] - self.time_full[0]) > self.time[1] - ): - self._ti = -1 # reset - elif signdt >= 0 and ( - time - periods * (self.time_full[-1] - self.time_full[0]) < self.time_full[0] - or time - periods * (self.time_full[-1] - self.time_full[0]) >= self.time_full[-1] - ): - self._ti = -1 # reset - elif signdt < 0 and ( - time - periods * (self.time_full[-1] - self.time_full[0]) <= self.time_full[0] - or time - periods * (self.time_full[-1] - self.time_full[0]) > self.time_full[-1] - ): - self._ti = -1 # reset - elif ( - signdt >= 0 - and time - periods * (self.time_full[-1] - self.time_full[0]) >= self.time[1] - and self._ti < len(self.time_full) - 2 - ): - self._ti += 1 - self.time = self.time_full[self._ti : self._ti + 2] - self._update_status = "updated" - elif ( - signdt < 0 - and time - periods * (self.time_full[-1] - self.time_full[0]) <= self.time[0] - and self._ti > 0 - ): - self._ti -= 1 - self.time = self.time_full[self._ti : self._ti + 2] - self._update_status = "updated" - if self._ti == -1: - self.time = self.time_full - self._ti, _ = f._time_index(time) - periods = self.periods.value if isinstance(self.periods, c_int) else self.periods - if ( - signdt == -1 - and self._ti == 0 - and (time - periods * (self.time_full[-1] - self.time_full[0])) == self.time[0] - and f.time_periodic - ): - self._ti = len(self.time) - 1 - periods -= 1 - if signdt == -1 and self._ti > 0 and self.time_full[self._ti] == time: - self._ti -= 1 - if self._ti >= len(self.time_full) - 1: - self._ti = len(self.time_full) - 2 - - self.time = self.time_full[self._ti : self._ti + 2] - self.tdim = 2 - if prev_time_indices is None or len(prev_time_indices) != 2 or len(prev_time_indices) != len(self.time): - self._update_status = "first_updated" - elif functools.reduce( - lambda i, j: i and j, map(lambda m, k: m == k, self.time, prev_time_indices), True - ) and len(prev_time_indices) == len(self.time): - self._update_status = "not_updated" - elif functools.reduce( - lambda i, j: i and j, map(lambda m, k: m == k, self.time[:1], prev_time_indices[:1]), True - ) and len(prev_time_indices) == len(self.time): - self._update_status = "updated" - else: - self._update_status = "first_updated" - if signdt >= 0 and (self._ti < len(self.time_full) - 2 or not f.allow_time_extrapolation): - nextTime_loc = self.time[1] + periods * (self.time_full[-1] - self.time_full[0]) - elif signdt < 0 and (self._ti > 0 or not f.allow_time_extrapolation): - nextTime_loc = self.time[0] + periods * (self.time_full[-1] - self.time_full[0]) - return nextTime_loc - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def chunk_not_loaded(self): - return self._chunk_not_loaded - - @property - def _chunk_not_loaded(self): - return 0 - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def chunk_loading_requested(self): - return self._chunk_loading_requested - - @property - def _chunk_loading_requested(self): - return 1 - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def chunk_loaded_touched(self): - return self._chunk_loaded_touched - - @property - def _chunk_loaded_touched(self): - return 2 - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def chunk_deprecated(self): - return self._chunk_deprecated - - @property - def _chunk_deprecated(self): - return 3 - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def chunk_loaded(self): - return self._chunk_loaded - - @property - def _chunk_loaded(self): - return [2, 3] - - -class RectilinearGrid(Grid): - """Rectilinear Grid class - - Private base class for RectilinearZGrid and RectilinearSGrid - - """ - - def __init__(self, lon, lat, time, time_origin, mesh: Mesh): - assert isinstance(lon, np.ndarray) and len(lon.shape) <= 1, "lon is not a numpy vector" - assert isinstance(lat, np.ndarray) and len(lat.shape) <= 1, "lat is not a numpy vector" - assert isinstance(time, np.ndarray) or not time, "time is not a numpy array" - if isinstance(time, np.ndarray): - assert len(time.shape) == 1, "time is not a vector" - - super().__init__(lon, lat, time, time_origin, mesh) - self.tdim = self.time.size - - if self.ydim > 1 and self.lat[-1] < self.lat[0]: - self._lat = np.flip(self.lat, axis=0) - self._lat_flipped = True - warnings.warn( - "Flipping lat data from North-South to South-North. " - "Note that this may lead to wrong sign for meridional velocity, so tread very carefully", - FieldSetWarning, - stacklevel=2, - ) - - @property - def xdim(self): - return self.lon.size - - @property - def ydim(self): - return self.lat.size - - def add_periodic_halo(self, zonal: bool, meridional: bool, halosize: int = 5): - """Add a 'halo' to the Grid, through extending the Grid (and lon/lat) - similarly to the halo created for the Fields - - Parameters - ---------- - zonal : bool - Create a halo in zonal direction - meridional : bool - Create a halo in meridional direction - halosize : int - size of the halo (in grid points). Default is 5 grid points - """ - if zonal: - lonshift = self.lon[-1] - 2 * self.lon[0] + self.lon[1] - if not np.allclose(self.lon[1] - self.lon[0], self.lon[-1] - self.lon[-2]): - warnings.warn( - "The zonal halo is located at the east and west of current grid, " - "with a dx = lon[1]-lon[0] between the last nodes of the original grid and the first ones of the halo. " - "In your grid, lon[1]-lon[0] != lon[-1]-lon[-2]. Is the halo computed as you expect?", - FieldSetWarning, - stacklevel=2, - ) - self._lon = np.concatenate((self.lon[-halosize:] - lonshift, self.lon, self.lon[0:halosize] + lonshift)) - self._zonal_periodic = True - self._zonal_halo = halosize - if meridional: - if not np.allclose(self.lat[1] - self.lat[0], self.lat[-1] - self.lat[-2]): - warnings.warn( - "The meridional halo is located at the north and south of current grid, " - "with a dy = lat[1]-lat[0] between the last nodes of the original grid and the first ones of the halo. " - "In your grid, lat[1]-lat[0] != lat[-1]-lat[-2]. Is the halo computed as you expect?", - FieldSetWarning, - stacklevel=2, - ) - latshift = self.lat[-1] - 2 * self.lat[0] + self.lat[1] - self._lat = np.concatenate((self.lat[-halosize:] - latshift, self.lat, self.lat[0:halosize] + latshift)) - self._meridional_halo = halosize - self._lonlat_minmax = np.array( - [np.nanmin(self.lon), np.nanmax(self.lon), np.nanmin(self.lat), np.nanmax(self.lat)], dtype=np.float32 - ) - if isinstance(self, RectilinearSGrid): - self._add_Sdepth_periodic_halo(zonal, meridional, halosize) - - -class RectilinearZGrid(RectilinearGrid): - """Rectilinear Z Grid. - - Parameters - ---------- - lon : - Vector containing the longitude coordinates of the grid - lat : - Vector containing the latitude coordinates of the grid - depth : - Vector containing the vertical coordinates of the grid, which are z-coordinates. - The depth of the different layers is thus constant. - time : - Vector containing the time coordinates of the grid - time_origin : parcels.tools.converters.TimeConverter - Time origin of the time axis - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - """ - - def __init__(self, lon, lat, depth=None, time=None, time_origin=None, mesh: Mesh = "flat"): - super().__init__(lon, lat, time, time_origin, mesh) - if isinstance(depth, np.ndarray): - assert len(depth.shape) <= 1, "depth is not a vector" - - self._gtype = GridType.RectilinearZGrid - self._depth = np.zeros(1, dtype=np.float32) if depth is None else depth - if not self.depth.flags["C_CONTIGUOUS"]: - self._depth = np.array(self.depth, order="C") - self._z4d = -1 # only used in RectilinearSGrid - if not self.depth.dtype == np.float32: - self._depth = self.depth.astype(np.float32) - - @property - def zdim(self): - return self.depth.size - - -class RectilinearSGrid(RectilinearGrid): - """Rectilinear S Grid. Same horizontal discretisation as a rectilinear z grid, - but with s vertical coordinates - - Parameters - ---------- - lon : - Vector containing the longitude coordinates of the grid - lat : - Vector containing the latitude coordinates of the grid - depth : - 4D (time-evolving) or 3D (time-independent) array containing the vertical coordinates of the grid, - which are s-coordinates. - s-coordinates can be terrain-following (sigma) or iso-density (rho) layers, - or any generalised vertical discretisation. - The depth of each node depends then on the horizontal position (lon, lat), - the number of the layer and the time is depth is a 4D array. - depth array is either a 4D array[xdim][ydim][zdim][tdim] or a 3D array[xdim][ydim[zdim]. - time : - Vector containing the time coordinates of the grid - time_origin : parcels.tools.converters.TimeConverter - Time origin of the time axis - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - """ - - def __init__( - self, - lon: npt.NDArray, - lat: npt.NDArray, - depth: npt.NDArray, - time: npt.NDArray | None = None, - time_origin: TimeConverter | None = None, - mesh: Mesh = "flat", - ): - super().__init__(lon, lat, time, time_origin, mesh) - assert isinstance(depth, np.ndarray) and len(depth.shape) in [3, 4], "depth is not a 3D or 4D numpy array" - - self._gtype = GridType.RectilinearSGrid - self._depth = depth - if not self.depth.flags["C_CONTIGUOUS"]: - self._depth = np.array(self.depth, order="C") - self._z4d = 1 if len(self.depth.shape) == 4 else 0 - if self._z4d: - # self.depth.shape[0] is 0 for S grids loaded from netcdf file - assert ( - self.tdim == self.depth.shape[0] or self.depth.shape[0] == 0 - ), "depth dimension has the wrong format. It should be [tdim, zdim, ydim, xdim]" - assert ( - self.xdim == self.depth.shape[-1] or self.depth.shape[-1] == 0 - ), "depth dimension has the wrong format. It should be [tdim, zdim, ydim, xdim]" - assert ( - self.ydim == self.depth.shape[-2] or self.depth.shape[-2] == 0 - ), "depth dimension has the wrong format. It should be [tdim, zdim, ydim, xdim]" - else: - assert ( - self.xdim == self.depth.shape[-1] - ), "depth dimension has the wrong format. It should be [zdim, ydim, xdim]" - assert ( - self.ydim == self.depth.shape[-2] - ), "depth dimension has the wrong format. It should be [zdim, ydim, xdim]" - if not self.depth.dtype == np.float32: - self._depth = self.depth.astype(np.float32) - if self._lat_flipped: - self._depth = np.flip(self.depth, axis=-2) - - @property - def zdim(self): - return self.depth.shape[-3] - - -class CurvilinearGrid(Grid): - def __init__( - self, - lon: npt.NDArray, - lat: npt.NDArray, - time: npt.NDArray | None = None, - time_origin: TimeConverter | None = None, - mesh: Mesh = "flat", - ): - assert isinstance(lon, np.ndarray) and len(lon.squeeze().shape) == 2, "lon is not a 2D numpy array" - assert isinstance(lat, np.ndarray) and len(lat.squeeze().shape) == 2, "lat is not a 2D numpy array" - assert isinstance(time, np.ndarray) or not time, "time is not a numpy array" - if isinstance(time, np.ndarray): - assert len(time.shape) == 1, "time is not a vector" - - lon = lon.squeeze() - lat = lat.squeeze() - super().__init__(lon, lat, time, time_origin, mesh) - self.tdim = self.time.size - - @property - def xdim(self): - return self.lon.shape[1] - - @property - def ydim(self): - return self.lon.shape[0] - - def add_periodic_halo(self, zonal, meridional, halosize=5): - """Add a 'halo' to the Grid, through extending the Grid (and lon/lat) - similarly to the halo created for the Fields - - Parameters - ---------- - zonal : bool - Create a halo in zonal direction - meridional : bool - Create a halo in meridional direction - halosize : int - size of the halo (in grid points). Default is 5 grid points - """ - raise NotImplementedError( - "CurvilinearGrid does not support add_periodic_halo. See https://github.com/OceanParcels/Parcels/pull/1811" - ) - - -class CurvilinearZGrid(CurvilinearGrid): - """Curvilinear Z Grid. - - Parameters - ---------- - lon : - 2D array containing the longitude coordinates of the grid - lat : - 2D array containing the latitude coordinates of the grid - depth : - Vector containing the vertical coordinates of the grid, which are z-coordinates. - The depth of the different layers is thus constant. - time : - Vector containing the time coordinates of the grid - time_origin : parcels.tools.converters.TimeConverter - Time origin of the time axis - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - """ - - def __init__( - self, - lon: npt.NDArray, - lat: npt.NDArray, - depth: npt.NDArray | None = None, - time: npt.NDArray | None = None, - time_origin: TimeConverter | None = None, - mesh: Mesh = "flat", - ): - super().__init__(lon, lat, time, time_origin, mesh) - if isinstance(depth, np.ndarray): - assert len(depth.shape) == 1, "depth is not a vector" - - self._gtype = GridType.CurvilinearZGrid - self._depth = np.zeros(1, dtype=np.float32) if depth is None else depth - if not self.depth.flags["C_CONTIGUOUS"]: - self._depth = np.array(self.depth, order="C") - self._z4d = -1 # only for SGrid - if not self.depth.dtype == np.float32: - self._depth = self.depth.astype(np.float32) - - @property - def zdim(self): - return self.depth.size - - -class CurvilinearSGrid(CurvilinearGrid): - """Curvilinear S Grid. - - Parameters - ---------- - lon : - 2D array containing the longitude coordinates of the grid - lat : - 2D array containing the latitude coordinates of the grid - depth : - 4D (time-evolving) or 3D (time-independent) array containing the vertical coordinates of the grid, - which are s-coordinates. - s-coordinates can be terrain-following (sigma) or iso-density (rho) layers, - or any generalised vertical discretisation. - The depth of each node depends then on the horizontal position (lon, lat), - the number of the layer and the time is depth is a 4D array. - depth array is either a 4D array[xdim][ydim][zdim][tdim] or a 3D array[xdim][ydim[zdim]. - time : - Vector containing the time coordinates of the grid - time_origin : parcels.tools.converters.TimeConverter - Time origin of the time axis - mesh : str - String indicating the type of mesh coordinates and - units used during velocity interpolation: - - 1. spherical (default): Lat and lon in degree, with a - correction for zonal velocity U near the poles. - 2. flat: No conversion, lat/lon are assumed to be in m. - """ - - def __init__( - self, - lon: npt.NDArray, - lat: npt.NDArray, - depth: npt.NDArray, - time: npt.NDArray | None = None, - time_origin: TimeConverter | None = None, - mesh: Mesh = "flat", - ): - super().__init__(lon, lat, time, time_origin, mesh) - assert isinstance(depth, np.ndarray) and len(depth.shape) in [3, 4], "depth is not a 4D numpy array" - - self._gtype = GridType.CurvilinearSGrid - self._depth = depth # should be a C-contiguous array of floats - if not self.depth.flags["C_CONTIGUOUS"]: - self._depth = np.array(self.depth, order="C") - self._z4d = 1 if len(self.depth.shape) == 4 else 0 - if self._z4d: - # self.depth.shape[0] is 0 for S grids loaded from netcdf file - assert ( - self.tdim == self.depth.shape[0] or self.depth.shape[0] == 0 - ), "depth dimension has the wrong format. It should be [tdim, zdim, ydim, xdim]" - assert ( - self.xdim == self.depth.shape[-1] or self.depth.shape[-1] == 0 - ), "depth dimension has the wrong format. It should be [tdim, zdim, ydim, xdim]" - assert ( - self.ydim == self.depth.shape[-2] or self.depth.shape[-2] == 0 - ), "depth dimension has the wrong format. It should be [tdim, zdim, ydim, xdim]" - else: - assert ( - self.xdim == self.depth.shape[-1] - ), "depth dimension has the wrong format. It should be [zdim, ydim, xdim]" - assert ( - self.ydim == self.depth.shape[-2] - ), "depth dimension has the wrong format. It should be [zdim, ydim, xdim]" - if not self.depth.dtype == np.float32: - self._depth = self.depth.astype(np.float32) - - @property - def zdim(self): - return self.depth.shape[-3] - - -def _calc_cell_edge_sizes(grid: RectilinearGrid) -> None: - """Method to calculate cell sizes based on numpy.gradient method. - - Currently only works for Rectilinear Grids. Operates in place adding a `cell_edge_sizes` - attribute to the grid. - """ - if not grid.cell_edge_sizes: - if grid._gtype in (GridType.RectilinearZGrid, GridType.RectilinearSGrid): # type: ignore[attr-defined] - grid.cell_edge_sizes["x"] = np.zeros((grid.ydim, grid.xdim), dtype=np.float32) - grid.cell_edge_sizes["y"] = np.zeros((grid.ydim, grid.xdim), dtype=np.float32) - - x_conv = GeographicPolar() if grid.mesh == "spherical" else UnitConverter() - y_conv = Geographic() if grid.mesh == "spherical" else UnitConverter() - for y, (lat, dy) in enumerate(zip(grid.lat, np.gradient(grid.lat), strict=False)): - for x, (lon, dx) in enumerate(zip(grid.lon, np.gradient(grid.lon), strict=False)): - grid.cell_edge_sizes["x"][y, x] = x_conv.to_source(dx, grid.depth[0], lat, lon) - grid.cell_edge_sizes["y"][y, x] = y_conv.to_source(dy, grid.depth[0], lat, lon) - else: - raise ValueError( - f"_cell_edge_sizes() not implemented for {grid._gtype} grids. " # type: ignore[attr-defined] - "You can provide Field.grid.cell_edge_sizes yourself by in, e.g., " - "NEMO using the e1u fields etc from the mesh_mask.nc file." - ) - - -def _calc_cell_areas(grid: RectilinearGrid) -> np.ndarray: - if not grid.cell_edge_sizes: - _calc_cell_edge_sizes(grid) - return grid.cell_edge_sizes["x"] * grid.cell_edge_sizes["y"] diff --git a/parcels/gridset.py b/parcels/gridset.py deleted file mode 100644 index e3b619110..000000000 --- a/parcels/gridset.py +++ /dev/null @@ -1,69 +0,0 @@ -import numpy as np - -__all__ = ["GridSet"] - - -class GridSet: - """GridSet class that holds the Grids on which the Fields are defined.""" - - def __init__(self): - self.grids = [] - - def add_grid(self, field): - grid = field.grid - existing_grid = False - for g in self.grids: - if field.chunksize == "auto": - break - if g == grid: - existing_grid = True - break - sameGrid = True - if grid.time_origin != g.time_origin: - continue - for attr in ["lon", "lat", "depth", "time"]: - gattr = getattr(g, attr) - gridattr = getattr(grid, attr) - if gattr.shape != gridattr.shape or not np.allclose(gattr, gridattr): - sameGrid = False - break - - if (g.chunksize != grid.chunksize) and (grid.chunksize not in [False, None]): - for dim in grid.chunksize: - if grid.chunksize[dim][1] != g.chunksize[dim][1]: - sameGrid &= False - break - - if sameGrid: - existing_grid = True - field._grid = g # TODO: Is this even necessary? - break - - if not existing_grid: - self.grids.append(grid) - field.igrid = self.grids.index(field.grid) - - def dimrange(self, dim): - """Returns maximum value of a dimension (lon, lat, depth or time) - on 'left' side and minimum value on 'right' side for all grids - in a gridset. Useful for finding e.g. longitude range that - overlaps on all grids in a gridset. - """ - maxleft, minright = (-np.inf, np.inf) - for g in self.grids: - if getattr(g, dim).size == 1: - continue # not including grids where only one entry - else: - if dim == "depth": - maxleft = max(maxleft, np.min(getattr(g, dim))) - minright = min(minright, np.max(getattr(g, dim))) - else: - maxleft = max(maxleft, getattr(g, dim)[0]) - minright = min(minright, getattr(g, dim)[-1]) - maxleft = 0 if maxleft == -np.inf else maxleft # if all len(dim) == 1 - minright = 0 if minright == np.inf else minright # if all len(dim) == 1 - return maxleft, minright - - @property - def size(self): - return len(self.grids) diff --git a/parcels/include/index_search.h b/parcels/include/index_search.h deleted file mode 100644 index 388ba4fa5..000000000 --- a/parcels/include/index_search.h +++ /dev/null @@ -1,523 +0,0 @@ -#ifndef _INDEX_SEARCH_H -#define _INDEX_SEARCH_H -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include -#include - -#define CHECKSTATUS(res) do {if (res != SUCCESS) return res;} while (0) -#define CHECKSTATUS_KERNELLOOP(res) {if (res == REPEAT) return res;} -#define rtol 1.e-5 -#define atol 1.e-8 - -#ifdef DOUBLE_COORD_VARIABLES -typedef double type_coord; -#else -typedef float type_coord; -#endif - -typedef enum - { - LINEAR=0, NEAREST=1, CGRID_VELOCITY=2, CGRID_TRACER=3, BGRID_VELOCITY=4, BGRID_W_VELOCITY=5, BGRID_TRACER=6, LINEAR_INVDIST_LAND_TRACER=7, PARTIALSLIP=8, FREESLIP=9 - } InterpCode; - -typedef enum - { - NEMO = 0, MITGCM = 1, MOM5 = 2, POP = 3, CROCO = 4 - } GridIndexingType; - -typedef struct -{ - int gtype; - void *grid; -} CGrid; - -typedef struct -{ - int xdim, ydim, zdim, tdim, z4d; - int sphere_mesh, zonal_periodic; - int *chunk_info; - int *load_chunk; - double tfull_min, tfull_max; - int* periods; - float *lonlat_minmax; - float *lon, *lat, *depth; - double *time; -} CStructuredGrid; - - -typedef enum - { - SUCCESS=0, EVALUATE=10, REPEAT=20, DELETE=30, STOPEXECUTION=40, STOPALLEXECUTION=41, ERROR=50, ERRORINTERPOLATION=51, ERROROUTOFBOUNDS=60, ERRORTHROUGHSURFACE=61, ERRORTIMEEXTRAPOLATION=70 - } StatusCode; - -typedef enum - { - RECTILINEAR_Z_GRID=0, RECTILINEAR_S_GRID=1, CURVILINEAR_Z_GRID=2, CURVILINEAR_S_GRID=3 - } GridType; - -// equal/closeness comparison that is equal to numpy (double) -static inline bool is_close_dbl(double a, double b) { - return (fabs(a-b) <= (atol + rtol * fabs(b))); -} - -// customisable equal/closeness comparison (double) -static inline bool is_close_dbl_tol(double a, double b, double tolerance) { - return (fabs(a-b) <= (tolerance + fabs(b))); -} - -// numerically accurate equal/closeness comparison (double) -static inline bool is_equal_dbl(double a, double b) { - return (fabs(a-b) <= (DBL_EPSILON * fabs(b))); -} - -// customisable equal/closeness comparison (float) -static inline bool is_close_flt_tol(float a, float b, float tolerance) { - return (fabs(a-b) <= (tolerance + fabs(b))); -} - -// equal/closeness comparison that is equal to numpy (float) -static inline bool is_close_flt(float a, float b) { - return (fabs(a-b) <= ((float)(atol) + (float)(rtol) * fabs(b))); -} - -// numerically accurate equal/closeness comparison (float) -static inline bool is_equal_flt(float a, float b) { - return (fabs(a-b) <= (FLT_EPSILON * fabs(b))); -} - -static inline bool is_zero_dbl(double a) { - return (fabs(a) <= DBL_EPSILON * fabs(a)); -} - -static inline bool is_zero_flt(float a) { - return (fabs(a) <= FLT_EPSILON * fabs(a)); -} - -static inline StatusCode search_indices_vertical_z(type_coord z, int zdim, float *zvals, int *zi, double *zeta, int gridindexingtype) -{ - if (zvals[zdim-1] > zvals[0]){ - if ((z < zvals[0]) && (gridindexingtype == MOM5) && (z > 2 * zvals[0] - zvals[1])){ - *zi = -1; - *zeta = z / zvals[0]; - return SUCCESS; - } - if ((z > zvals[zdim-1]) && (z < 0) && (gridindexingtype == CROCO)){ - *zi = zdim-2; - *zeta = 1; - return SUCCESS; - } - if (z < zvals[0]) {return ERRORTHROUGHSURFACE;} - if (z > zvals[zdim-1]) {return ERROROUTOFBOUNDS;} - while (*zi < zdim-1 && z > zvals[*zi+1]) ++(*zi); - while (*zi > 0 && z < zvals[*zi]) --(*zi); - } - else{ - if (z > zvals[0]) {return ERRORTHROUGHSURFACE;} - if (z < zvals[zdim-1]) {return ERROROUTOFBOUNDS;} - while (*zi < zdim-1 && z < zvals[*zi+1]) ++(*zi); - while (*zi > 0 && z > zvals[*zi]) --(*zi); - } - if (*zi == zdim-1) {--*zi;} - - *zeta = (z - zvals[*zi]) / (zvals[*zi+1] - zvals[*zi]); - return SUCCESS; -} - -static inline StatusCode search_indices_vertical_s(double time, type_coord z, - int tdim, int zdim, int ydim, int xdim, float *zvals, - int ti, int *zi, int yi, int xi, double *zeta, double eta, double xsi, - int z4d, double t0, double t1, int interp_method) -{ - if (interp_method == BGRID_VELOCITY || interp_method == BGRID_W_VELOCITY || interp_method == BGRID_TRACER){ - xsi = 1; - eta = 1; - } - float zcol[zdim]; - int zii; - if (z4d == 1){ - float (*zvalstab)[zdim][ydim][xdim] = (float (*)[zdim][ydim][xdim]) zvals; - int ti1 = ti; - if (ti < tdim-1) - ti1= ti+1; - double zt0, zt1; - for (zii=0; zii < zdim; zii++){ - zt0 = (1-xsi)*(1-eta) * zvalstab[ti ][zii][yi ][xi ] - + ( xsi)*(1-eta) * zvalstab[ti ][zii][yi ][xi+1] - + ( xsi)*( eta) * zvalstab[ti ][zii][yi+1][xi+1] - + (1-xsi)*( eta) * zvalstab[ti ][zii][yi+1][xi ]; - zt1 = (1-xsi)*(1-eta) * zvalstab[ti1][zii][yi ][xi ] - + ( xsi)*(1-eta) * zvalstab[ti1][zii][yi ][xi+1] - + ( xsi)*( eta) * zvalstab[ti1][zii][yi+1][xi+1] - + (1-xsi)*( eta) * zvalstab[ti1][zii][yi+1][xi ]; - zcol[zii] = zt0 + (zt1 - zt0) * (float)((time - t0) / (t1 - t0)); - } - - } - else{ - float (*zvalstab)[ydim][xdim] = (float (*)[ydim][xdim]) zvals; - for (zii=0; zii < zdim; zii++){ - zcol[zii] = (1-xsi)*(1-eta) * zvalstab[zii][yi ][xi ] - + ( xsi)*(1-eta) * zvalstab[zii][yi ][xi+1] - + ( xsi)*( eta) * zvalstab[zii][yi+1][xi+1] - + (1-xsi)*( eta) * zvalstab[zii][yi+1][xi ]; - } - } - - if (zcol[zdim-1] > zcol[0]){ - if (z < zcol[0]) {return ERRORTHROUGHSURFACE;} - if (z > zcol[zdim-1]) {return ERROROUTOFBOUNDS;} - while (*zi < zdim-1 && z > zcol[*zi+1]) ++(*zi); - while (*zi > 0 && z < zcol[*zi]) --(*zi); - } - else{ - if (z > zcol[0]) {return ERRORTHROUGHSURFACE;} - if (z < zcol[zdim-1]) {return ERROROUTOFBOUNDS;} - while (*zi < zdim-1 && z < zcol[*zi+1]) ++(*zi); - while (*zi > 0 && z > zcol[*zi]) --(*zi); - } - if (*zi == zdim-1) {--*zi;} - - *zeta = (z - zcol[*zi]) / (zcol[*zi+1] - zcol[*zi]); - return SUCCESS; -} - -static inline void reconnect_bnd_indices(int *yi, int *xi, int ydim, int xdim, int onlyX, int sphere_mesh) -{ - if (*xi < 0){ - if (sphere_mesh) - (*xi) = xdim-2; - else - (*xi) = 0; - } - if (*xi > xdim-2){ - if (sphere_mesh) - (*xi) = 0; - else - (*xi) = xdim-2; - } - if (onlyX == 0){ - if (*yi < 0){ - (*yi) = 0; - } - if (*yi > ydim-2){ - (*yi) = ydim-2; - if (sphere_mesh) - (*xi) = xdim - (*xi); - } - } -} - - -static inline StatusCode search_indices_rectilinear(double time, type_coord z, type_coord y, type_coord x, - CStructuredGrid *grid, GridType gtype, - int ti, int *zi, int *yi, int *xi, double *zeta, double *eta, double *xsi, - double t0, double t1, int interp_method, - int gridindexingtype) -{ - int xdim = grid->xdim; - int ydim = grid->ydim; - int zdim = grid->zdim; - int tdim = grid->tdim; - float *xvals = grid->lon; - float *yvals = grid->lat; - float *zvals = grid->depth; - float *xy_minmax = grid->lonlat_minmax; - int sphere_mesh = grid->sphere_mesh; - int zonal_periodic = grid->zonal_periodic; - int z4d = grid->z4d; - - if (zonal_periodic == 0){ - if ((xdim > 1) && ((x < xy_minmax[0]) || (x > xy_minmax[1]))) - return ERROROUTOFBOUNDS; - } - if ((ydim > 1) && ((y < xy_minmax[2]) || (y > xy_minmax[3]))) - return ERROROUTOFBOUNDS; - - if (xdim == 1){ - *xi = 0; - *xsi = 0; - } - else if (sphere_mesh == 0){ - while (*xi < xdim-1 && x > xvals[*xi+1]) ++(*xi); - while (*xi > 0 && x < xvals[*xi]) --(*xi); - *xsi = (x - xvals[*xi]) / (xvals[*xi+1] - xvals[*xi]); - } - else{ - - float xvalsi = xvals[*xi]; - // TODO: this will fail if longitude is e.g. only [-180, 180] (so length 2) - if (xvalsi < x - 225) xvalsi += 360; - if (xvalsi > x + 225) xvalsi -= 360; - float xvalsi1 = xvals[*xi+1]; - if (xvalsi1 < xvalsi - 180) xvalsi1 += 360; - if (xvalsi1 > xvalsi + 180) xvalsi1 -= 360; - - int itMax = 10000; - int it = 0; - while ( (xvalsi > x) || (xvalsi1 < x) ){ - if (xvalsi1 < x) - ++(*xi); - else if (xvalsi > x) - --(*xi); - reconnect_bnd_indices(yi, xi, ydim, xdim, 1, 1); - xvalsi = xvals[*xi]; - if (xvalsi < x - 225) xvalsi += 360; - if (xvalsi > x + 225) xvalsi -= 360; - xvalsi1 = xvals[*xi+1]; - if (xvalsi1 < xvalsi - 180) xvalsi1 += 360; - if (xvalsi1 > xvalsi + 180) xvalsi1 -= 360; - it++; - if (it > itMax){ - return ERROROUTOFBOUNDS; - } - } - - *xsi = (x - xvalsi) / (xvalsi1 - xvalsi); - } - - if (ydim == 1){ - *yi = 0; - *eta = 0; - } - else { - while (*yi < ydim-1 && y > yvals[*yi+1]) ++(*yi); - while (*yi > 0 && y < yvals[*yi]) --(*yi); - *eta = (y - yvals[*yi]) / (yvals[*yi+1] - yvals[*yi]); - } - - StatusCode status; - if (zdim > 1){ - switch(gtype){ - case RECTILINEAR_Z_GRID: - status = search_indices_vertical_z(z, zdim, zvals, zi, zeta, gridindexingtype); - break; - case RECTILINEAR_S_GRID: - status = search_indices_vertical_s(time, z, tdim, zdim, ydim, xdim, zvals, - ti, zi, *yi, *xi, zeta, *eta, *xsi, - z4d, t0, t1, interp_method); - break; - default: - status = ERRORINTERPOLATION; - } - CHECKSTATUS(status); - } - else - *zeta = 0; - - if ( (*xsi < 0) && (is_zero_dbl(*xsi)) ) {*xsi = 0.;} - if ( (*xsi > 1) && (is_close_dbl(*xsi, 1.)) ) {*xsi = 1.;} - if ( (*eta < 0) && (is_zero_dbl(*eta)) ) {*eta = 0.;} - if ( (*eta > 1) && (is_close_dbl(*eta, 1.)) ) {*eta = 1.;} - if ( (*zeta < 0) && (is_zero_dbl(*zeta)) ) {*zeta = 0.;} - if ( (*zeta > 1) && (is_close_dbl(*zeta, 1.)) ) {*zeta = 1.;} - - if ( (*xsi < 0) || (*xsi > 1) ) return ERRORINTERPOLATION; - if ( (*eta < 0) || (*eta > 1) ) return ERRORINTERPOLATION; - if ( (*zeta < 0) || (*zeta > 1) ) return ERRORINTERPOLATION; - - return SUCCESS; -} - - -static inline StatusCode search_indices_curvilinear(double time, type_coord z, type_coord y, type_coord x, - CStructuredGrid *grid, GridType gtype, - int ti, int *zi, int *yi, int *xi, - double *zeta, double *eta, double *xsi, - double t0, double t1, int interp_method, - int gridindexingtype) -{ - int xi_old = *xi; - int yi_old = *yi; - int xdim = grid->xdim; - int ydim = grid->ydim; - int zdim = grid->zdim; - int tdim = grid->tdim; - float *xvals = grid->lon; - float *yvals = grid->lat; - float *zvals = grid->depth; - float *xy_minmax = grid->lonlat_minmax; - int sphere_mesh = grid->sphere_mesh; - int zonal_periodic = grid->zonal_periodic; - int z4d = grid->z4d; - - // NEMO convention - float (* xgrid)[xdim] = (float (*)[xdim]) xvals; - float (* ygrid)[xdim] = (float (*)[xdim]) yvals; - - if (zonal_periodic == 0){ - if ((x < xy_minmax[0]) || (x > xy_minmax[1])){ - if (xgrid[0][0] < xgrid[0][xdim-1]) {return ERROROUTOFBOUNDS;} - else if (x < xgrid[0][0] && x > xgrid[0][xdim-1]) {return ERROROUTOFBOUNDS;} - } - } - if ((y < xy_minmax[2]) || (y > xy_minmax[3])) - return ERROROUTOFBOUNDS; - - double a[4], b[4]; - - *xsi = *eta = -1; - int maxIterSearch = 1e6, it = 0; - double tol = 1e-10; - while ( (*xsi < -tol) || (*xsi > 1+tol) || (*eta < -tol) || (*eta > 1+tol) ){ - double xgrid_loc[4] = {xgrid[*yi][*xi], xgrid[*yi][*xi+1], xgrid[*yi+1][*xi+1], xgrid[*yi+1][*xi]}; - if (sphere_mesh){ //we are on the sphere - int i4; - if (xgrid_loc[0] < x - 225) xgrid_loc[0] += 360; - if (xgrid_loc[0] > x + 225) xgrid_loc[0] -= 360; - for (i4 = 1; i4 < 4; ++i4){ - if (xgrid_loc[i4] < xgrid_loc[0] - 180) xgrid_loc[i4] += 360; - if (xgrid_loc[i4] > xgrid_loc[0] + 180) xgrid_loc[i4] -= 360; - } - } - double ygrid_loc[4] = {ygrid[*yi][*xi], ygrid[*yi][*xi+1], ygrid[*yi+1][*xi+1], ygrid[*yi+1][*xi]}; - - a[0] = xgrid_loc[0]; - a[1] = -xgrid_loc[0] + xgrid_loc[1]; - a[2] = -xgrid_loc[0] + xgrid_loc[3]; - a[3] = xgrid_loc[0] - xgrid_loc[1] + xgrid_loc[2] - xgrid_loc[3]; - b[0] = ygrid_loc[0]; - b[1] = -ygrid_loc[0] + ygrid_loc[1]; - b[2] = -ygrid_loc[0] + ygrid_loc[3]; - b[3] = ygrid_loc[0] - ygrid_loc[1] + ygrid_loc[2] - ygrid_loc[3]; - - double aa = a[3]*b[2] - a[2]*b[3]; - double bb = a[3]*b[0] - a[0]*b[3] + a[1]*b[2] - a[2]*b[1] + x*b[3] - y*a[3]; - double cc = a[1]*b[0] - a[0]*b[1] + x*b[1] - y*a[1]; - if (fabs(aa) < 1e-12) // Rectilinear cell, or quasi - *eta = -cc / bb; - else{ - double det = sqrt(bb*bb-4*aa*cc); - if (det == det) // so, if det is nan we keep the xsi, eta from previous iter - *eta = (-bb+det)/(2*aa); - } - if ( fabs(a[1]+a[3]*(*eta)) < 1e-12 ) // this happens when recti cell rotated of 90deg - *xsi = ( (y-ygrid_loc[0]) / (ygrid_loc[1]-ygrid_loc[0]) + - (y-ygrid_loc[3]) / (ygrid_loc[2]-ygrid_loc[3]) ) * .5; - else - *xsi = (x-a[0]-a[2]* (*eta)) / (a[1]+a[3]* (*eta)); - if ( (*xsi < 0) && (*eta < 0) && (*xi == 0) && (*yi == 0) ) - return ERROROUTOFBOUNDS; - if ( (*xsi > 1) && (*eta > 1) && (*xi == xdim-1) && (*yi == ydim-1) ) - return ERROROUTOFBOUNDS; - if (*xsi < -tol) - (*xi)--; - if (*xsi > 1+tol) - (*xi)++; - if (*eta < -tol) - (*yi)--; - if (*eta > 1+tol) - (*yi)++; - reconnect_bnd_indices(yi, xi, ydim, xdim, 0, sphere_mesh); - it++; - if ( it > maxIterSearch){ - printf("Correct cell not found for (lat, lon) = (%f, %f) after %d iterations\n", y, x, maxIterSearch); - printf("Debug info: old particle indices: (yi, xi) %d %d\n", yi_old, xi_old); - printf(" new particle indices: (yi, xi) %d %d\n", *yi, *xi); - printf(" Mesh 2d shape: %d %d\n", ydim, xdim); - printf(" Relative particle position: (eta, xsi) %1.16e %1.16e\n", *eta, *xsi); - return ERROROUTOFBOUNDS; - } - } - if ( (*xsi != *xsi) || (*eta != *eta) ){ // check if nan - printf("Correct cell not found for (lat, lon) = (%f, %f))\n", y, x); - printf("Debug info: old particle indices: (yi, xi) %d %d\n", yi_old, xi_old); - printf(" new particle indices: (yi, xi) %d %d\n", *yi, *xi); - printf(" Mesh 2d shape: %d %d\n", ydim, xdim); - printf(" Relative particle position: (eta, xsi) %1.16e %1.16e\n", *eta, *xsi); - return ERROROUTOFBOUNDS; - } - if (*xsi < 0) *xsi = 0; - if (*xsi > 1) *xsi = 1; - if (*eta < 0) *eta = 0; - if (*eta > 1) *eta = 1; - - StatusCode status; - if (zdim > 1){ - switch(gtype){ - case CURVILINEAR_Z_GRID: - status = search_indices_vertical_z(z, zdim, zvals, zi, zeta, gridindexingtype); - break; - case CURVILINEAR_S_GRID: - status = search_indices_vertical_s(time, z, tdim, ydim, xdim, zdim, zvals, - ti, zi, *yi, *xi, zeta, *eta, *xsi, - z4d, t0, t1, interp_method); - break; - default: - status = ERRORINTERPOLATION; - } - CHECKSTATUS(status); - } - else - *zeta = 0; - - if ( (*xsi < 0) || (*xsi > 1) ) return ERRORINTERPOLATION; - if ( (*eta < 0) || (*eta > 1) ) return ERRORINTERPOLATION; - if ( (*zeta < 0) || (*zeta > 1) ) return ERRORINTERPOLATION; - - return SUCCESS; -} - -/* Local linear search to update grid index - * params ti, sizeT, time. t0, t1 are only used for 4D S grids - * */ -static inline StatusCode search_indices(double time, type_coord z, type_coord y, type_coord x, - CStructuredGrid *grid, - int ti, int *zi, int *yi, int *xi, - double *zeta, double *eta, double *xsi, - GridType gtype, double t0, double t1, int interp_method, - int gridindexingtype) -{ - switch(gtype){ - case RECTILINEAR_Z_GRID: - case RECTILINEAR_S_GRID: - return search_indices_rectilinear(time, z, y, x, grid, gtype, ti, zi, yi, xi, zeta, eta, xsi, - t0, t1, interp_method, gridindexingtype); - break; - case CURVILINEAR_Z_GRID: - case CURVILINEAR_S_GRID: - return search_indices_curvilinear(time, z, y, x, grid, gtype, ti, zi, yi, xi, zeta, eta, xsi, - t0, t1, interp_method, gridindexingtype); - break; - default: - printf("Only RECTILINEAR_Z_GRID, RECTILINEAR_S_GRID, CURVILINEAR_Z_GRID and CURVILINEAR_S_GRID grids are currently implemented\n"); - return ERROR; - } -} - -/* Local linear search to update time index */ -static inline StatusCode search_time_index(double *t, int size, double *tvals, int *ti, int time_periodic, double tfull_min, double tfull_max, int *periods) -{ - if (*ti < 0) - *ti = 0; - if (time_periodic == 1){ - if (*t < tvals[0]){ - *ti = size-1; - *periods = (int) floor( (*t-tfull_min)/(tfull_max-tfull_min)); - *t -= *periods * (tfull_max-tfull_min); - if (*t < tvals[0]){ // e.g. t=5, tfull_min=0, t_full_max=5 -> periods=1 but we want periods = 0 - *periods -= 1; - *t -= *periods * (tfull_max-tfull_min); - } - search_time_index(t, size, tvals, ti, time_periodic, tfull_min, tfull_max, periods); - } - else if (*t > tvals[size-1]){ - *ti = 0; - *periods = (int) floor( (*t-tfull_min)/(tfull_max-tfull_min)); - *t -= *periods * (tfull_max-tfull_min); - search_time_index(t, size, tvals, ti, time_periodic, tfull_min, tfull_max, periods); - } - } - while (*ti < size-1 && *t > tvals[*ti+1]) ++(*ti); - while (*ti > 0 && *t < tvals[*ti]) --(*ti); - return SUCCESS; -} - - -#ifdef __cplusplus -} -#endif -#endif diff --git a/parcels/include/interpolation_utils.h b/parcels/include/interpolation_utils.h deleted file mode 100644 index b92fd3327..000000000 --- a/parcels/include/interpolation_utils.h +++ /dev/null @@ -1,139 +0,0 @@ -#include -#include -#include - -typedef enum - { - ZONAL=0, MERIDIONAL=1, VERTICAL=2, - } Orientation; - - -static inline void phi2D_lin(double eta, double xsi, double *phi) -{ - phi[0] = (1-xsi) * (1-eta); - phi[1] = xsi * (1-eta); - phi[2] = xsi * eta ; - phi[3] = (1-xsi) * eta ; -} - - -static inline void phi1D_quad(double xsi, double *phi) -{ - phi[0] = 2*xsi*xsi-3*xsi+1; - phi[1] = -4*xsi*xsi+4*xsi; - phi[2] = 2*xsi*xsi-xsi; -} - - -static inline void dphidxsi3D_lin(double zeta, double eta, double xsi, double *dphidzeta, double *dphideta, double *dphidxsi) -{ - dphidxsi[0] = - (1-eta) * (1-zeta); - dphidxsi[1] = (1-eta) * (1-zeta); - dphidxsi[2] = ( eta) * (1-zeta); - dphidxsi[3] = - ( eta) * (1-zeta); - dphidxsi[4] = - (1-eta) * ( zeta); - dphidxsi[5] = (1-eta) * ( zeta); - dphidxsi[6] = ( eta) * ( zeta); - dphidxsi[7] = - ( eta) * ( zeta); - - dphideta[0] = - (1-xsi) * (1-zeta); - dphideta[1] = - ( xsi) * (1-zeta); - dphideta[2] = ( xsi) * (1-zeta); - dphideta[3] = (1-xsi) * (1-zeta); - dphideta[4] = - (1-xsi) * ( zeta); - dphideta[5] = - ( xsi) * ( zeta); - dphideta[6] = ( xsi) * ( zeta); - dphideta[7] = (1-xsi) * ( zeta); - - dphidzeta[0] = - (1-xsi) * (1-eta); - dphidzeta[1] = - ( xsi) * (1-eta); - dphidzeta[2] = - ( xsi) * ( eta); - dphidzeta[3] = - (1-xsi) * ( eta); - dphidzeta[4] = (1-xsi) * (1-eta); - dphidzeta[5] = ( xsi) * (1-eta); - dphidzeta[6] = ( xsi) * ( eta); - dphidzeta[7] = (1-xsi) * ( eta); -} - -static inline void dxdxsi3D_lin(double *pz, double *py, double *px, double zeta, double eta, double xsi, double *jacM, int sphere_mesh) -{ - double dphidxsi[8], dphideta[8], dphidzeta[8]; - dphidxsi3D_lin(zeta, eta, xsi, dphidzeta, dphideta, dphidxsi); - - int i; - for(i=0; i<9; ++i) - jacM[i] = 0; - - double deg2m = 1852 * 60.; - double rad = M_PI / 180.; - double lat = (1-xsi) * (1-eta) * py[0]+ - xsi * (1-eta) * py[1]+ - xsi * eta * py[2]+ - (1-xsi) * eta * py[3]; - double jac_lon = (sphere_mesh == 1) ? (deg2m * cos(rad * lat) ) : 1; - double jac_lat = (sphere_mesh == 1) ? deg2m : 1; - - for(i=0; i<8; ++i){ - jacM[3*0+0] += px[i] * dphidxsi[i] * jac_lon; // dxdxsi - jacM[3*0+1] += px[i] * dphideta[i] * jac_lon; // dxdeta - jacM[3*0+2] += px[i] * dphidzeta[i] * jac_lon; // dxdzeta - jacM[3*1+0] += py[i] * dphidxsi[i] * jac_lat; // dydxsi - jacM[3*1+1] += py[i] * dphideta[i] * jac_lat; // dydeta - jacM[3*1+2] += py[i] * dphidzeta[i] * jac_lat; // dydzeta - jacM[3*2+0] += pz[i] * dphidxsi[i]; // dzdxsi - jacM[3*2+1] += pz[i] * dphideta[i]; // dzdeta - jacM[3*2+2] += pz[i] * dphidzeta[i]; // dzdzeta - } -} - -static inline double jacobian3D_lin_face(double *pz, double *py, double *px, - double zeta, double eta, double xsi, - Orientation orientation, int sphere_mesh) -{ - double jacM[9]; - dxdxsi3D_lin(pz, py, px, zeta, eta, xsi, jacM, sphere_mesh); - - double j[3]; - - if (orientation == ZONAL){ - j[0] = jacM[3*1+1]*jacM[3*2+2]-jacM[3*1+2]*jacM[3*2+1]; - j[1] =-jacM[3*0+1]*jacM[3*2+2]+jacM[3*0+2]*jacM[3*2+1]; - j[2] = jacM[3*0+1]*jacM[3*1+2]-jacM[3*0+2]*jacM[3*1+1]; - } - else if (orientation == MERIDIONAL){ - j[0] = jacM[3*1+0]*jacM[3*2+2]-jacM[3*1+2]*jacM[3*2+0]; - j[1] =-jacM[3*0+0]*jacM[3*2+2]+jacM[3*0+2]*jacM[3*2+0]; - j[2] = jacM[3*0+0]*jacM[3*1+2]-jacM[3*0+2]*jacM[3*1+0]; - } - else if (orientation == VERTICAL){ - j[0] = jacM[3*1+0]*jacM[3*2+1]-jacM[3*1+1]*jacM[3*2+0]; - j[1] =-jacM[3*0+0]*jacM[3*2+1]+jacM[3*0+1]*jacM[3*2+0]; - j[2] = jacM[3*0+0]*jacM[3*1+1]-jacM[3*0+1]*jacM[3*1+0]; - } - - return sqrt(j[0]*j[0]+j[1]*j[1]+j[2]*j[2]); -} - -static inline double jacobian3D_lin(double *pz, double *py, double *px, - double zeta, double eta, double xsi, - int sphere_mesh) -{ - double jacM[9]; - dxdxsi3D_lin(pz, py, px, zeta, eta, xsi, jacM, sphere_mesh); - - double jac = jacM[3*0+0] * (jacM[3*1+1]*jacM[3*2+2] - jacM[3*2+1]*jacM[3*1+2]) - - jacM[3*0+1] * (jacM[3*1+0]*jacM[3*2+2] - jacM[3*2+0]*jacM[3*1+2]) - + jacM[3*0+2] * (jacM[3*1+0]*jacM[3*2+1] - jacM[3*2+0]*jacM[3*1+1]); - - - return jac; -} - -static inline double dot_prod(double *a, double *b, size_t n) -{ - double val = 0; - int i = 0; - for(i=0; i -#include -#include -#include -#include -#include "random.h" -#include "index_search.h" -#include "interpolation_utils.h" - -#define min(X, Y) (((X) < (Y)) ? (X) : (Y)) -#define max(X, Y) (((X) > (Y)) ? (X) : (Y)) - -typedef struct -{ - int xdim, ydim, zdim, tdim, igrid, allow_time_extrapolation, time_periodic; - float ****data_chunks; - CGrid *grid; -} CField; - -/* Bilinear interpolation routine for 2D grid */ -static inline StatusCode spatial_interpolation_bilinear(double eta, double xsi, - float data[2][2], float *value) -{ - *value = (1-xsi)*(1-eta) * data[0][0] - + xsi *(1-eta) * data[0][1] - + xsi * eta * data[1][1] - + (1-xsi)* eta * data[1][0]; - return SUCCESS; -} - -/* Bilinear interpolation routine for 2D grid for tracers with squared inverse distance weighting near land*/ -static inline StatusCode spatial_interpolation_bilinear_invdist_land(double eta, double xsi, - float data[2][2], float *value) -{ - int i, j, k, l, nb_land = 0, land[2][2] = {{0}}; - float w_sum = 0.; - // count the number of surrounding land points (assume land is where the value is close to zero) - for (i = 0; i < 2; i++) { - for (j = 0; j < 2; j++) { - if (is_zero_flt(data[i][j])) { - land[i][j] = 1; - nb_land++; - } - else { - // record the coordinates of the last non-land point - // (for the case where this is the only location with valid data) - k = i; - l = j; - } - } - } - switch (nb_land) { - case 0: // no land, use usual routine - return spatial_interpolation_bilinear(eta, xsi, data, value); - case 3: // single non-land point - *value = data[k][l]; - return SUCCESS; - case 4: // only land - *value = 0.; - return SUCCESS; - default: - break; - } - // interpolate with 1 or 2 land points - *value = 0.; - for (i = 0; i < 2; i++) { - for (j = 0; j < 2; j++) { - float distance = pow((xsi - j), 2) + pow((eta - i), 2); - if (is_zero_flt(distance)) { - if (land[i][j] == 1) { // index search led us directly onto land - *value = 0.; - return SUCCESS; - } - else { - *value = data[i][j]; - return SUCCESS; - } - } - else if (land[i][j] == 0) { - *value += data[i][j] / distance; - w_sum += 1 / distance; - } - } - } - *value /= w_sum; - return SUCCESS; -} - -/* Trilinear interpolation routine for 3D grid */ -static inline StatusCode spatial_interpolation_trilinear(double zeta, double eta, double xsi, - float data[2][2][2], float *value) -{ - float f0, f1; - f0 = (1-xsi)*(1-eta) * data[0][0][0] - + xsi *(1-eta) * data[0][0][1] - + xsi * eta * data[0][1][1] - + (1-xsi)* eta * data[0][1][0]; - f1 = (1-xsi)*(1-eta) * data[1][0][0] - + xsi *(1-eta) * data[1][0][1] - + xsi * eta * data[1][1][1] - + (1-xsi)* eta * data[1][1][0]; - *value = (1-zeta) * f0 + zeta * f1; - return SUCCESS; -} - -/* Trilinear interpolation routine for MOM surface 3D grid */ -static inline StatusCode spatial_interpolation_trilinear_surface(double zeta, double eta, double xsi, - float data[2][2][2], float *value) -{ - float f1; - f1 = (1-xsi)*(1-eta) * data[0][0][0] - + xsi *(1-eta) * data[0][0][1] - + xsi * eta * data[0][1][1] - + (1-xsi)* eta * data[0][1][0]; - *value = zeta * f1; - return SUCCESS; -} - -static inline StatusCode spatial_interpolation_trilinear_bottom(double zeta, double eta, double xsi, - float data[2][2][2], float *value) -{ - float f1; - f1 = (1-xsi)*(1-eta) * data[1][0][0] - + xsi *(1-eta) * data[1][0][1] - + xsi * eta * data[1][1][1] - + (1-xsi)* eta * data[1][1][0]; - *value = (1 - zeta) * f1; - return SUCCESS; -} - -/* Trilinear interpolation routine for 3D grid for tracers with squared inverse distance weighting near land*/ -static inline StatusCode spatial_interpolation_trilinear_invdist_land(double zeta, double eta, double xsi, - float data[2][2][2], float *value) -{ - int i, j, k, l, m, n, nb_land = 0, land[2][2][2] = {{{0}}}; - float w_sum = 0.; - // count the number of surrounding land points (assume land is where the value is close to zero) - for (i = 0; i < 2; i++) { - for (j = 0; j < 2; j++) { - for (k = 0; k < 2; k++) { - if(is_zero_flt(data[i][j][k])) { - land[i][j][k] = 1; - nb_land++; - } - else { - // record the coordinates of the last non-land point - // (for the case where this is the only location with valid data) - l = i; - m = j; - n = k; - } - } - } - } - switch (nb_land) { - case 0: // no land, use usual routine - return spatial_interpolation_trilinear(zeta, eta, xsi, data, value); - case 7: // single non-land point - *value = data[l][m][n]; - return SUCCESS; - case 8: // only land - *value = 0.; - return SUCCESS; - default: - break; - } - // interpolate with 1 to 6 land points - *value = 0.; - for (i = 0; i < 2; i++) { - for (j = 0; j < 2; j++) { - for (k = 0; k < 2; k++) { - float distance = pow((zeta - i), 2) + pow((eta - j), 2) + pow((xsi - k), 2); - if (is_zero_flt(distance)) { - if (land[i][j][k] == 1) { - // index search led us directly onto land - *value = 0.; - return SUCCESS; - } else { - *value = data[i][j][k]; - return SUCCESS; - } - } - else if (land[i][j][k] == 0) { - *value += data[i][j][k] / distance; - w_sum += 1 / distance; - } - } - } - } - *value /= w_sum; - return SUCCESS; -} - -/* Nearest neighbor interpolation routine for 2D grid */ -static inline StatusCode spatial_interpolation_nearest2D(double eta, double xsi, - float data[2][2], float *value) -{ - /* Cast data array into data[lat][lon] as per NEMO convention */ - int i, j; - if (xsi < .5) {i = 0;} else {i = 1;} - if (eta < .5) {j = 0;} else {j = 1;} - *value = data[j][i]; - return SUCCESS; -} - -/* C grid interpolation routine for tracers on 2D grid */ -static inline StatusCode spatial_interpolation_tracer_bc_grid_2D(double _eta, double _xsi, - float data[2][2], float *value) -{ - *value = data[1][1]; - return SUCCESS; -} - -/* C grid interpolation routine for tracers on 3D grid */ -static inline StatusCode spatial_interpolation_tracer_bc_grid_3D(double _zeta, double _eta, double _xsi, - float data[2][2][2], float *value) -{ - *value = data[0][1][1]; - return SUCCESS; -} - -static inline StatusCode spatial_interpolation_tracer_bc_grid_bottom(double _zeta, double _eta, double _xsi, - float data[2][2][2], float *value) -{ - *value = data[1][1][1]; - return SUCCESS; -} - -/* Nearest neighbor interpolation routine for 3D grid */ -static inline StatusCode spatial_interpolation_nearest3D(double zeta, double eta, double xsi, - float data[2][2][2], float *value) -{ - int i, j, k; - if (xsi < .5) {i = 0;} else {i = 1;} - if (eta < .5) {j = 0;} else {j = 1;} - if (zeta < .5) {k = 0;} else {k = 1;} - *value = data[k][j][i]; - return SUCCESS; -} - -static inline int getBlock2D(int *chunk_info, int yi, int xi, int *block, int *index_local) -{ - int ndim = chunk_info[0]; - if (ndim != 2) - exit(-1); - int i, j; - - int shape[ndim]; - int index[2] = {yi, xi}; - for(i=0; igrid->grid; - int *chunk_info = grid->chunk_info; - int ndim = chunk_info[0]; - int block[ndim]; - int ilocal[ndim]; - - int tii, yii, xii; - - int blockid = getBlock2D(chunk_info, yi, xi, block, ilocal); - if (grid->load_chunk[blockid] < 2){ - grid->load_chunk[blockid] = 1; - return REPEAT; - } - grid->load_chunk[blockid] = 2; - int zdim = 1; - int ydim = chunk_info[1+ndim+block[0]]; - int yshift = chunk_info[1]; - int xdim = chunk_info[1+ndim+yshift+block[1]]; - - if (((ilocal[0] == ydim-1) && (ydim > 1)) || ((ilocal[1] == xdim-1) && (xdim > 1))) - { - // Cell is on multiple chunks - for (tii=0; tii<2; ++tii){ - for (yii=0; yii<2; ++yii){ - for (xii=0; xii<2; ++xii){ - blockid = getBlock2D(chunk_info, yi+yii, xi+xii, block, ilocal); - if (grid->load_chunk[blockid] < 2){ - grid->load_chunk[blockid] = 1; - return REPEAT; - } - grid->load_chunk[blockid] = 2; - zdim = 1; - ydim = chunk_info[1+ndim+block[0]]; - yshift = chunk_info[1]; - xdim = chunk_info[1+ndim+yshift+block[1]]; - float (*data_block)[zdim][ydim][xdim] = (float (*)[zdim][ydim][xdim]) f->data_chunks[blockid]; - float (*data)[xdim] = (float (*)[xdim]) (data_block[ti+tii]); - cell_data[tii][yii][xii] = data[ilocal[0]][ilocal[1]]; - } - } - if (first_tstep_only == 1) - break; - } - } - else - { - float (*data_block)[zdim][ydim][xdim] = (float (*)[zdim][ydim][xdim]) f->data_chunks[blockid]; - for (tii=0; tii<2; ++tii){ - float (*data)[xdim] = (float (*)[xdim]) (data_block[ti+tii]); - int xiid = ((xdim==1) ? 0 : 1); - int yiid = ((ydim==1) ? 0 : 1); - for (yii=0; yii<2; yii++) - for (xii=0; xii<2; xii++) - cell_data[tii][yii][xii] = data[ilocal[0]+(yii*yiid)][ilocal[1]+(xii*xiid)]; - if (first_tstep_only == 1) - break; - } - } - return SUCCESS; -} - -static inline int getBlock3D(int *chunk_info, int zi, int yi, int xi, int *block, int *index_local) -{ - int ndim = chunk_info[0]; - if (ndim != 3) - exit(-1); - int i, j; - - int shape[ndim]; - int index[3] = {zi, yi, xi}; - for(i=0; igrid->grid; - int *chunk_info = grid->chunk_info; - int ndim = chunk_info[0]; - int block[ndim]; - int ilocal[ndim]; - - int tii, zii, yii, xii; - - int blockid = getBlock3D(chunk_info, zi, yi, xi, block, ilocal); - if (grid->load_chunk[blockid] < 2){ - grid->load_chunk[blockid] = 1; - return REPEAT; - } - grid->load_chunk[blockid] = 2; - int zdim = chunk_info[1+ndim+block[0]]; - int zshift = chunk_info[1]; - int ydim = chunk_info[1+ndim+zshift+block[1]]; - int yshift = chunk_info[1+1]; - int xdim = chunk_info[1+ndim+zshift+yshift+block[2]]; - - if (((ilocal[0] == zdim-1) && zdim > 1) || ((ilocal[1] == ydim-1) && ydim > 1) || ((ilocal[2] == xdim-1) && xdim >1)) - { - // Cell is on multiple chunks\n - for (tii=0; tii<2; ++tii){ - for (zii=0; zii<2; ++zii){ - for (yii=0; yii<2; ++yii){ - for (xii=0; xii<2; ++xii){ - blockid = getBlock3D(chunk_info, zi+zii, yi+yii, xi+xii, block, ilocal); - if (grid->load_chunk[blockid] < 2){ - grid->load_chunk[blockid] = 1; - return REPEAT; - } - grid->load_chunk[blockid] = 2; - zdim = chunk_info[1+ndim+block[0]]; - zshift = chunk_info[1]; - ydim = chunk_info[1+ndim+zshift+block[1]]; - yshift = chunk_info[1+1]; - xdim = chunk_info[1+ndim+zshift+yshift+block[2]]; - float (*data_block)[zdim][ydim][xdim] = (float (*)[zdim][ydim][xdim]) f->data_chunks[blockid]; - float (*data)[ydim][xdim] = (float (*)[ydim][xdim]) (data_block[ti+tii]); - cell_data[tii][zii][yii][xii] = data[ilocal[0]][ilocal[1]][ilocal[2]]; - } - } - } - if (first_tstep_only == 1) - break; - } - } - else - { - float (*data_block)[zdim][ydim][xdim] = (float (*)[zdim][ydim][xdim]) f->data_chunks[blockid]; - for (tii=0; tii<2; ++tii){ - float (*data)[ydim][xdim] = (float (*)[ydim][xdim]) (data_block[ti+tii]); - int xiid = ((xdim==1) ? 0 : 1); - int yiid = ((ydim==1) ? 0 : 1); - int ziid = ((zdim==1) ? 0 : 1); - for (zii=0; zii<2; zii++) - for (yii=0; yii<2; yii++) - for (xii=0; xii<2; xii++) - cell_data[tii][zii][yii][xii] = data[ilocal[0]+(zii*ziid)][ilocal[1]+(yii*yiid)][ilocal[2]+(xii*xiid)]; - if (first_tstep_only == 1) - break; - } - } - return SUCCESS; -} - - -/* Linear interpolation along the time axis */ -static inline StatusCode temporal_interpolation_structured_grid(double time, type_coord z, type_coord y, type_coord x, - CField *f, - GridType gtype, int *ti, int *zi, int *yi, int *xi, - float *value, int interp_method, int gridindexingtype) -{ - StatusCode status; - CStructuredGrid *grid = f->grid->grid; - int igrid = f->igrid; - - /* Find time index for temporal interpolation */ - if (f->time_periodic == 0 && f->allow_time_extrapolation == 0 && (time < grid->time[0] || time > grid->time[grid->tdim-1])){ - return ERRORTIMEEXTRAPOLATION; - } - status = search_time_index(&time, grid->tdim, grid->time, &ti[igrid], f->time_periodic, grid->tfull_min, grid->tfull_max, grid->periods); CHECKSTATUS(status); - - double xsi, eta, zeta; - - float data2D[2][2][2]; - float data3D[2][2][2][2]; - - // if we're in between time indices, and not at the end of the timeseries, - // we'll make sure to interpolate data between the two time values - // otherwise, we'll only use the data at the current time index - int tii = (ti[igrid] < grid->tdim-1 && time > grid->time[ti[igrid]]) ? 2 : 1; - - float val[2] = {0.0f, 0.0f}; - double t0 = grid->time[ti[igrid]]; - // we set our second time bound and search time depending on the - // index critereon above - double t1 = (tii == 2) ? grid->time[ti[igrid]+1] : t0+1; - double tsrch = (tii == 2) ? time : t0; - - status = search_indices(tsrch, z, y, x, grid, - ti[igrid], &zi[igrid], &yi[igrid], &xi[igrid], - &zeta, &eta, &xsi, gtype, - t0, t1, interp_method, gridindexingtype); - CHECKSTATUS(status); - - if (grid->zdim == 1) { - // last param is a flag, which denotes that we only want the first timestep - // (rather than both) - status = getCell2D(f, ti[igrid], yi[igrid], xi[igrid], data2D, tii == 1); CHECKSTATUS(status); - } else { - if ((gridindexingtype == MOM5) && (zi[igrid] == -1)) { - status = getCell3D(f, ti[igrid], 0, yi[igrid], xi[igrid], data3D, tii == 1); CHECKSTATUS(status); - } else if ((gridindexingtype == POP) && (zi[igrid] == grid->zdim-2)) { - status = getCell3D(f, ti[igrid], zi[igrid]-1, yi[igrid], xi[igrid], data3D, tii == 1); CHECKSTATUS(status); - } else { - status = getCell3D(f, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D, tii == 1); CHECKSTATUS(status); - } - } - - // define a helper macro that will select the appropriate interpolation method - // depending on whether we need 2D or 3D -#define INTERP(fn_2d, fn_3d) \ - do { \ - if (grid->zdim == 1) { \ - for (int i = 0; i < tii; i++) { \ - status = fn_2d(eta, xsi, data2D[i], &val[i]); \ - CHECKSTATUS(status); \ - } \ - } else { \ - for (int i = 0; i < tii; i++) { \ - status = fn_3d(zeta, eta, xsi, data3D[i], &val[i]); \ - CHECKSTATUS(status); \ - } \ - } \ - } while (0) - - if ((interp_method == LINEAR) || (interp_method == CGRID_VELOCITY) || - (interp_method == BGRID_VELOCITY) || (interp_method == BGRID_W_VELOCITY)) { - // adjust the normalised coordinate for flux-based interpolation methods - if ((interp_method == CGRID_VELOCITY) || (interp_method == BGRID_W_VELOCITY)) { - if ((gridindexingtype == NEMO) || (gridindexingtype == MOM5) || (gridindexingtype == POP)) { - // velocity is on the northeast of a tracer cell - xsi = 1; - eta = 1; - } else if ((gridindexingtype == MITGCM) || (gridindexingtype == CROCO)) { - // velocity is on the southwest of a tracer cell - xsi = 0; - eta = 0; - } - } else if (interp_method == BGRID_VELOCITY) { - if (gridindexingtype == MOM5) { - zeta = 1; - } else { - zeta = 0; - } - } - if ((gridindexingtype == MOM5) && (zi[igrid] == -1)) { - INTERP(spatial_interpolation_bilinear, spatial_interpolation_trilinear_surface); - } else if ((gridindexingtype == POP) && (zi[igrid] == grid->zdim-2)) { - INTERP(spatial_interpolation_bilinear, spatial_interpolation_trilinear_bottom); - } else { - INTERP(spatial_interpolation_bilinear, spatial_interpolation_trilinear); - } - } else if (interp_method == NEAREST) { - INTERP(spatial_interpolation_nearest2D, spatial_interpolation_nearest3D); - } else if ((interp_method == CGRID_TRACER) || (interp_method == BGRID_TRACER)) { - if ((gridindexingtype == POP) && (zi[igrid] == grid->zdim-2)) { - INTERP(spatial_interpolation_tracer_bc_grid_2D, spatial_interpolation_tracer_bc_grid_bottom); - } else { - INTERP(spatial_interpolation_tracer_bc_grid_2D, spatial_interpolation_tracer_bc_grid_3D); - } - } else if (interp_method == LINEAR_INVDIST_LAND_TRACER) { - INTERP(spatial_interpolation_bilinear_invdist_land, spatial_interpolation_trilinear_invdist_land); - } else { - return ERROR; - } - - // tsrch = t0 in the case where val[1] isn't populated, so this - // gives the right interpolation in either case - *value = val[0] + (val[1] - val[0]) * (float)((tsrch - t0) / (t1 - t0)); - - return SUCCESS; -#undef INTERP -} - -static double dist(double lat1, double lat2, double lon1, double lon2, int sphere_mesh, double lat) -{ - if (sphere_mesh == 1){ - double rad = M_PI / 180.; - double deg2m = 1852 * 60.; - return sqrt((lon2-lon1)*(lon2-lon1) * deg2m * deg2m * cos(rad * lat) * cos(rad * lat) + (lat2-lat1)*(lat2-lat1) * deg2m * deg2m); - } - else{ - return sqrt((lon2-lon1)*(lon2-lon1) + (lat2-lat1)*(lat2-lat1)); - } -} - -/* Linear interpolation routine for 2D C grid */ -static inline StatusCode spatial_interpolation_UV_c_grid(double eta, double xsi, - int yi, int xi, - CStructuredGrid *grid, GridType gtype, - float dataU[2][2], float dataV[2][2], - float *u, float *v) -{ - /* Cast data array into data[lat][lon] as per NEMO convention */ - int xdim = grid->xdim; - - double xgrid_loc[4]; - double ygrid_loc[4]; - int iN; - if( (gtype == RECTILINEAR_Z_GRID) || (gtype == RECTILINEAR_S_GRID) ){ - float *xgrid = grid->lon; - float *ygrid = grid->lat; - for (iN=0; iN < 4; ++iN){ - xgrid_loc[iN] = xgrid[xi+min(1, (iN%3))]; - ygrid_loc[iN] = ygrid[yi+iN/2]; - } - } - else{ - float (* xgrid)[xdim] = (float (*)[xdim]) grid->lon; - float (* ygrid)[xdim] = (float (*)[xdim]) grid->lat; - for (iN=0; iN < 4; ++iN){ - xgrid_loc[iN] = xgrid[yi+iN/2][xi+min(1, (iN%3))]; - ygrid_loc[iN] = ygrid[yi+iN/2][xi+min(1, (iN%3))]; - } - } - int i4; - for (i4 = 1; i4 < 4; ++i4){ - if (xgrid_loc[i4] < xgrid_loc[0] - 180) xgrid_loc[i4] += 360; - if (xgrid_loc[i4] > xgrid_loc[0] + 180) xgrid_loc[i4] -= 360; - } - - - double phi[4]; - phi2D_lin(eta, 0.,phi); - double U0 = dataU[1][0] * dist(ygrid_loc[3], ygrid_loc[0], xgrid_loc[3], xgrid_loc[0], grid->sphere_mesh, dot_prod(phi, ygrid_loc, 4)); - phi2D_lin(eta, 1., phi); - double U1 = dataU[1][1] * dist(ygrid_loc[1], ygrid_loc[2], xgrid_loc[1], xgrid_loc[2], grid->sphere_mesh, dot_prod(phi, ygrid_loc, 4)); - phi2D_lin(0., xsi, phi); - double V0 = dataV[0][1] * dist(ygrid_loc[0], ygrid_loc[1], xgrid_loc[0], xgrid_loc[1], grid->sphere_mesh, dot_prod(phi, ygrid_loc, 4)); - phi2D_lin(1., xsi, phi); - double V1 = dataV[1][1] * dist(ygrid_loc[2], ygrid_loc[3], xgrid_loc[2], xgrid_loc[3], grid->sphere_mesh, dot_prod(phi, ygrid_loc, 4)); - double U = (1-xsi) * U0 + xsi * U1; - double V = (1-eta) * V0 + eta * V1; - - double dphidxsi[4] = {eta-1, 1-eta, eta, -eta}; - double dphideta[4] = {xsi-1, -xsi, xsi, 1-xsi}; - double dxdxsi = 0; double dxdeta = 0; - double dydxsi = 0; double dydeta = 0; - int i; - for(i=0; i<4; ++i){ - dxdxsi += xgrid_loc[i] *dphidxsi[i]; - dxdeta += xgrid_loc[i] *dphideta[i]; - dydxsi += ygrid_loc[i] *dphidxsi[i]; - dydeta += ygrid_loc[i] *dphideta[i]; - } - double meshJac = 1; - if (grid->sphere_mesh == 1){ - double deg2m = 1852 * 60.; - double rad = M_PI / 180.; - phi2D_lin(eta, xsi, phi); - double lat = dot_prod(phi, ygrid_loc, 4); - meshJac = deg2m * deg2m * cos(rad * lat); - } - double jac = (dxdxsi*dydeta - dxdeta * dydxsi) * meshJac; - - *u = ( (-(1-eta) * U - (1-xsi) * V ) * xgrid_loc[0] + - ( (1-eta) * U - xsi * V ) * xgrid_loc[1] + - ( eta * U + xsi * V ) * xgrid_loc[2] + - ( -eta * U + (1-xsi) * V ) * xgrid_loc[3] ) / jac; - *v = ( (-(1-eta) * U - (1-xsi) * V ) * ygrid_loc[0] + - ( (1-eta) * U - xsi * V ) * ygrid_loc[1] + - ( eta * U + xsi * V ) * ygrid_loc[2] + - ( -eta * U + (1-xsi) * V ) * ygrid_loc[3] ) / jac; - - return SUCCESS; -} - - - -static inline StatusCode temporal_interpolationUV_c_grid(double time, type_coord z, type_coord y, type_coord x, - CField *U, CField *V, - GridType gtype, int *ti, int *zi, int *yi, int *xi, - float *u, float *v, int gridindexingtype) -{ - StatusCode status; - CStructuredGrid *grid = U->grid->grid; - int igrid = U->igrid; - - /* Find time index for temporal interpolation */ - if (U->time_periodic == 0 && U->allow_time_extrapolation == 0 && (time < grid->time[0] || time > grid->time[grid->tdim-1])){ - return ERRORTIMEEXTRAPOLATION; - } - status = search_time_index(&time, grid->tdim, grid->time, &ti[igrid], U->time_periodic, grid->tfull_min, grid->tfull_max, grid->periods); CHECKSTATUS(status); - - double xsi, eta, zeta; - - - if (ti[igrid] < grid->tdim-1 && time > grid->time[ti[igrid]]) { - float u0, u1, v0, v1; - double t0 = grid->time[ti[igrid]]; double t1 = grid->time[ti[igrid]+1]; - /* Identify grid cell to sample through local linear search */ - status = search_indices(time, z, y, x, grid, ti[igrid], &zi[igrid], &yi[igrid], &xi[igrid], &zeta, &eta, &xsi, gtype, t0, t1, CGRID_VELOCITY, gridindexingtype); CHECKSTATUS(status); - if (grid->zdim==1){ - float data2D_U[2][2][2], data2D_V[2][2][2]; - if (gridindexingtype == NEMO) { - status = getCell2D(U, ti[igrid], yi[igrid], xi[igrid], data2D_U, 0); CHECKSTATUS(status); - status = getCell2D(V, ti[igrid], yi[igrid], xi[igrid], data2D_V, 0); CHECKSTATUS(status); - } - else if ((gridindexingtype == MITGCM) || (gridindexingtype == CROCO)) { - status = getCell2D(U, ti[igrid], yi[igrid]-1, xi[igrid], data2D_U, 0); CHECKSTATUS(status); - status = getCell2D(V, ti[igrid], yi[igrid], xi[igrid]-1, data2D_V, 0); CHECKSTATUS(status); - } - status = spatial_interpolation_UV_c_grid(eta, xsi, yi[igrid], xi[igrid], grid, gtype, data2D_U[0], data2D_V[0], &u0, &v0); CHECKSTATUS(status); - status = spatial_interpolation_UV_c_grid(eta, xsi, yi[igrid], xi[igrid], grid, gtype, data2D_U[1], data2D_V[1], &u1, &v1); CHECKSTATUS(status); - - } else { - float data3D_U[2][2][2][2], data3D_V[2][2][2][2]; - if (gridindexingtype == NEMO) { - status = getCell3D(U, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_U, 0); CHECKSTATUS(status); - status = getCell3D(V, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_V, 0); CHECKSTATUS(status); - } - else if ((gridindexingtype == MITGCM) || (gridindexingtype == CROCO)) { - status = getCell3D(U, ti[igrid], zi[igrid], yi[igrid]-1, xi[igrid], data3D_U, 0); CHECKSTATUS(status); - status = getCell3D(V, ti[igrid], zi[igrid], yi[igrid], xi[igrid]-1, data3D_V, 0); CHECKSTATUS(status); - } - status = spatial_interpolation_UV_c_grid(eta, xsi, yi[igrid], xi[igrid], grid, gtype, data3D_U[0][0], data3D_V[0][0], &u0, &v0); CHECKSTATUS(status); - status = spatial_interpolation_UV_c_grid(eta, xsi, yi[igrid], xi[igrid], grid, gtype, data3D_U[1][0], data3D_V[1][0], &u1, &v1); CHECKSTATUS(status); - } - *u = u0 + (u1 - u0) * (float)((time - t0) / (t1 - t0)); - *v = v0 + (v1 - v0) * (float)((time - t0) / (t1 - t0)); - return SUCCESS; - } else { - double t0 = grid->time[ti[igrid]]; - status = search_indices(t0, z, y, x, grid, ti[igrid], &zi[igrid], &yi[igrid], &xi[igrid], &zeta, &eta, &xsi, gtype, t0, t0+1, CGRID_VELOCITY, gridindexingtype); CHECKSTATUS(status); - if (grid->zdim==1){ - float data2D_U[2][2][2], data2D_V[2][2][2]; - if (gridindexingtype == NEMO) { - status = getCell2D(U, ti[igrid], yi[igrid], xi[igrid], data2D_U, 1); CHECKSTATUS(status); - status = getCell2D(V, ti[igrid], yi[igrid], xi[igrid], data2D_V, 1); CHECKSTATUS(status); - } - else if ((gridindexingtype == MITGCM) || (gridindexingtype == CROCO)) { - status = getCell2D(U, ti[igrid], yi[igrid]-1, xi[igrid], data2D_U, 1); CHECKSTATUS(status); - status = getCell2D(V, ti[igrid], yi[igrid], xi[igrid]-1, data2D_V, 1); CHECKSTATUS(status); - } - status = spatial_interpolation_UV_c_grid(eta, xsi, yi[igrid], xi[igrid], grid, gtype, data2D_U[0], data2D_V[0], u, v); CHECKSTATUS(status); - } - else{ - float data3D_U[2][2][2][2], data3D_V[2][2][2][2]; - if (gridindexingtype == NEMO) { - status = getCell3D(U, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_U, 1); CHECKSTATUS(status); - status = getCell3D(V, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_V, 1); CHECKSTATUS(status); - } - else if ((gridindexingtype == MITGCM) || (gridindexingtype == CROCO)) { - status = getCell3D(U, ti[igrid], zi[igrid], yi[igrid]-1, xi[igrid], data3D_U, 1); CHECKSTATUS(status); - status = getCell3D(V, ti[igrid], zi[igrid], yi[igrid], xi[igrid]-1, data3D_V, 1); CHECKSTATUS(status); - } - status = spatial_interpolation_UV_c_grid(eta, xsi, yi[igrid], xi[igrid], grid, gtype, data3D_U[0][0], data3D_V[0][0], u, v); CHECKSTATUS(status); - } - return SUCCESS; - } -} - -/* Quadratic interpolation routine for 3D C grid */ -static inline StatusCode spatial_interpolation_UVW_c_grid(double zeta, double eta, double xsi, - int ti, int zi, int yi, int xi, - CStructuredGrid *grid, GridType gtype, - float dataU[2][2][2], float dataV[2][2][2], float dataW[2][2][2], - float *u, float *v, float *w, int gridindexingtype) -{ - /* Cast data array into data[lat][lon] as per NEMO convention */ - int xdim = grid->xdim; - int ydim = grid->ydim; - int zdim = grid->zdim; - - float xgrid_loc[4]; - float ygrid_loc[4]; - int iN; - if( gtype == RECTILINEAR_S_GRID ){ - float *xgrid = grid->lon; - float *ygrid = grid->lat; - for (iN=0; iN < 4; ++iN){ - xgrid_loc[iN] = xgrid[xi+min(1, (iN%3))]; - ygrid_loc[iN] = ygrid[yi+iN/2]; - } - } - else{ - float (* xgrid)[xdim] = (float (*)[xdim]) grid->lon; - float (* ygrid)[xdim] = (float (*)[xdim]) grid->lat; - for (iN=0; iN < 4; ++iN){ - xgrid_loc[iN] = xgrid[yi+iN/2][xi+min(1, (iN%3))]; - ygrid_loc[iN] = ygrid[yi+iN/2][xi+min(1, (iN%3))]; - } - } - int i4; - for (i4 = 1; i4 < 4; ++i4){ - if (xgrid_loc[i4] < xgrid_loc[0] - 180) xgrid_loc[i4] += 360; - if (xgrid_loc[i4] > xgrid_loc[0] + 180) xgrid_loc[i4] -= 360; - } - - float u0 = dataU[0][1][0]; - float u1 = dataU[0][1][1]; - float v0 = dataV[0][0][1]; - float v1 = dataV[0][1][1]; - float w0 = dataW[0][1][1]; - float w1 = dataW[1][1][1]; - - double px[8] = {xgrid_loc[0], xgrid_loc[1], xgrid_loc[2], xgrid_loc[3], - xgrid_loc[0], xgrid_loc[1], xgrid_loc[2], xgrid_loc[3]}; - double py[8] = {ygrid_loc[0], ygrid_loc[1], ygrid_loc[2], ygrid_loc[3], - ygrid_loc[0], ygrid_loc[1], ygrid_loc[2], ygrid_loc[3]}; - double pz[8]; - if (grid->z4d == 1){ - float (*zvals)[zdim][ydim][xdim] = (float (*)[zdim][ydim][xdim]) grid->depth; - for (iN=0; iN < 4; ++iN){ - pz[iN] = zvals[ti][zi][yi+iN/2][xi+min(1, (iN%3))]; - pz[iN+4] = zvals[ti][zi+1][yi+iN/2][xi+min(1, (iN%3))]; - } - } - else{ - float (*zvals)[ydim][xdim] = (float (*)[ydim][xdim]) grid->depth; - for (iN=0; iN < 4; ++iN){ - pz[iN] = zvals[zi][yi+iN/2][xi+min(1, (iN%3))]; - pz[iN+4] = zvals[zi+1][yi+iN/2][xi+min(1, (iN%3))]; - } - } - - double U0 = u0 * jacobian3D_lin_face(pz, py, px, zeta, eta, 0, ZONAL, grid->sphere_mesh); - double U1 = u1 * jacobian3D_lin_face(pz, py, px, zeta, eta, 1, ZONAL, grid->sphere_mesh); - double V0 = v0 * jacobian3D_lin_face(pz, py, px, zeta, 0, xsi, MERIDIONAL, grid->sphere_mesh); - double V1 = v1 * jacobian3D_lin_face(pz, py, px, zeta, 1, xsi, MERIDIONAL, grid->sphere_mesh); - double W0 = w0 * jacobian3D_lin_face(pz, py, px, 0, eta, xsi, VERTICAL, grid->sphere_mesh); - double W1 = w1 * jacobian3D_lin_face(pz, py, px, 1, eta, xsi, VERTICAL, grid->sphere_mesh); - - // Computing fluxes in half left hexahedron -> flux_u05 - double xxu[8] = {px[0], (px[0]+px[1])/2, (px[2]+px[3])/2, px[3], px[4], (px[4]+px[5])/2, (px[6]+px[7])/2, px[7]}; - double yyu[8] = {py[0], (py[0]+py[1])/2, (py[2]+py[3])/2, py[3], py[4], (py[4]+py[5])/2, (py[6]+py[7])/2, py[7]}; - double zzu[8] = {pz[0], (pz[0]+pz[1])/2, (pz[2]+pz[3])/2, pz[3], pz[4], (pz[4]+pz[5])/2, (pz[6]+pz[7])/2, pz[7]}; - double flux_u0 = u0 * jacobian3D_lin_face(zzu, yyu, xxu, .5, .5, 0, ZONAL, grid->sphere_mesh); - double flux_v0_halfx = v0 * jacobian3D_lin_face(zzu, yyu, xxu, .5, 0, .5, MERIDIONAL, grid->sphere_mesh); - double flux_v1_halfx = v1 * jacobian3D_lin_face(zzu, yyu, xxu, .5, 1, .5, MERIDIONAL, grid->sphere_mesh); - double flux_w0_halfx = w0 * jacobian3D_lin_face(zzu, yyu, xxu, 0, .5, .5, VERTICAL, grid->sphere_mesh); - double flux_w1_halfx = w1 * jacobian3D_lin_face(zzu, yyu, xxu, 1, .5, .5, VERTICAL, grid->sphere_mesh); - double flux_u05 = flux_u0 + flux_v0_halfx - flux_v1_halfx + flux_w0_halfx - flux_w1_halfx; - - // Computing fluxes in half front hexahedron -> flux_v05 - double xxv[8] = {px[0], px[1], (px[1]+px[2])/2, (px[0]+px[3])/2, px[4], px[5], (px[5]+px[6])/2, (px[4]+px[7])/2}; - double yyv[8] = {py[0], py[1], (py[1]+py[2])/2, (py[0]+py[3])/2, py[4], py[5], (py[5]+py[6])/2, (py[4]+py[7])/2}; - double zzv[8] = {pz[0], pz[1], (pz[1]+pz[2])/2, (pz[0]+pz[3])/2, pz[4], pz[5], (pz[5]+pz[6])/2, (pz[4]+pz[7])/2}; - double flux_u0_halfy = u0 * jacobian3D_lin_face(zzv, yyv, xxv, .5, .5, 0, ZONAL, grid->sphere_mesh); - double flux_u1_halfy = u1 * jacobian3D_lin_face(zzv, yyv, xxv, .5, .5, 1, ZONAL, grid->sphere_mesh); - double flux_v0 = v0 * jacobian3D_lin_face(zzv, yyv, xxv, .5, 0, .5, MERIDIONAL, grid->sphere_mesh); - double flux_w0_halfy = w0 * jacobian3D_lin_face(zzv, yyv, xxv, 0, .5, .5, VERTICAL, grid->sphere_mesh); - double flux_w1_halfy = w1 * jacobian3D_lin_face(zzv, yyv, xxv, 1, .5, .5, VERTICAL, grid->sphere_mesh); - double flux_v05 = flux_u0_halfy - flux_u1_halfy + flux_v0 + flux_w0_halfy - flux_w1_halfy; - - // Computing fluxes in half lower hexahedron -> flux_w05 - double xx[8] = {px[0], px[1], px[2], px[3], (px[0]+px[4])/2, (px[1]+px[5])/2, (px[2]+px[6])/2, (px[3]+px[7])/2}; - double yy[8] = {py[0], py[1], py[2], py[3], (py[0]+py[4])/2, (py[1]+py[5])/2, (py[2]+py[6])/2, (py[3]+py[7])/2}; - double zz[8] = {pz[0], pz[1], pz[2], pz[3], (pz[0]+pz[4])/2, (pz[1]+pz[5])/2, (pz[2]+pz[6])/2, (pz[3]+pz[7])/2}; - double flux_u0_halfz = u0 * jacobian3D_lin_face(zz, yy, xx, .5, .5, 0, ZONAL, grid->sphere_mesh); - double flux_u1_halfz = u1 * jacobian3D_lin_face(zz, yy, xx, .5, .5, 1, ZONAL, grid->sphere_mesh); - double flux_v0_halfz = v0 * jacobian3D_lin_face(zz, yy, xx, .5, 0, .5, MERIDIONAL, grid->sphere_mesh); - double flux_v1_halfz = v1 * jacobian3D_lin_face(zz, yy, xx, .5, 1, .5, MERIDIONAL, grid->sphere_mesh); - double flux_w0 = w0 * jacobian3D_lin_face(zz, yy, xx, 0, .5, .5, VERTICAL, grid->sphere_mesh); - double flux_w05 = flux_u0_halfz - flux_u1_halfz + flux_v0_halfz - flux_v1_halfz + flux_w0; - - double surf_u05 = jacobian3D_lin_face(pz, py, px, .5, .5, .5, ZONAL, grid->sphere_mesh); - double jac_u05 = jacobian3D_lin_face(pz, py, px, zeta, eta, .5, ZONAL, grid->sphere_mesh); - double U05 = flux_u05 / surf_u05 * jac_u05; - - double surf_v05 = jacobian3D_lin_face(pz, py, px, .5, .5, .5, MERIDIONAL, grid->sphere_mesh); - double jac_v05 = jacobian3D_lin_face(pz, py, px, zeta, .5, xsi, MERIDIONAL, grid->sphere_mesh); - double V05 = flux_v05 / surf_v05 * jac_v05; - - double surf_w05 = jacobian3D_lin_face(pz, py, px, .5, .5, .5, VERTICAL, grid->sphere_mesh); - double jac_w05 = jacobian3D_lin_face(pz, py, px, .5, eta, xsi, VERTICAL, grid->sphere_mesh); - double W05 = flux_w05 / surf_w05 * jac_w05; - - double jac = jacobian3D_lin(pz, py, px, zeta, eta, xsi, grid->sphere_mesh); - - double phi[3]; - phi1D_quad(xsi, phi); - double uvec[3] = {U0, U05, U1}; - double dxsidt = dot_prod(phi, uvec, 3) / jac; - phi1D_quad(eta, phi); - double vvec[3] = {V0, V05, V1}; - double detadt = dot_prod(phi, vvec, 3) / jac; - phi1D_quad(zeta, phi); - double wvec[3] = {W0, W05, W1}; - double dzetdt = dot_prod(phi, wvec, 3) / jac; - - double dphidxsi[8], dphideta[8], dphidzeta[8]; - dphidxsi3D_lin(zeta, eta, xsi, dphidzeta, dphideta, dphidxsi); - - *u = dot_prod(dphidxsi, px, 8) * dxsidt + dot_prod(dphideta, px, 8) * detadt + dot_prod(dphidzeta, px, 8) * dzetdt; - *v = dot_prod(dphidxsi, py, 8) * dxsidt + dot_prod(dphideta, py, 8) * detadt + dot_prod(dphidzeta, py, 8) * dzetdt; - *w = dot_prod(dphidxsi, pz, 8) * dxsidt + dot_prod(dphideta, pz, 8) * detadt + dot_prod(dphidzeta, pz, 8) * dzetdt; - - return SUCCESS; -} - -static inline StatusCode temporal_interpolationUVW_c_grid(double time, type_coord z, type_coord y, type_coord x, - CField *U, CField *V, CField *W, - GridType gtype, int *ti, int *zi, int *yi, int *xi, - float *u, float *v, float *w, int gridindexingtype) -{ - StatusCode status; - CStructuredGrid *grid = U->grid->grid; - int igrid = U->igrid; - - /* Find time index for temporal interpolation */ - if (U->time_periodic == 0 && U->allow_time_extrapolation == 0 && (time < grid->time[0] || time > grid->time[grid->tdim-1])){ - return ERRORTIMEEXTRAPOLATION; - } - status = search_time_index(&time, grid->tdim, grid->time, &ti[igrid], U->time_periodic, grid->tfull_min, grid->tfull_max, grid->periods); CHECKSTATUS(status); - - double xsi, eta, zeta; - float data3D_U[2][2][2][2]; - float data3D_V[2][2][2][2]; - float data3D_W[2][2][2][2]; - - - if (ti[igrid] < grid->tdim-1 && time > grid->time[ti[igrid]]) { - float u0, u1, v0, v1, w0, w1; - double t0 = grid->time[ti[igrid]]; double t1 = grid->time[ti[igrid]+1]; - /* Identify grid cell to sample through local linear search */ - status = search_indices(time, z, y, x, grid, ti[igrid], &zi[igrid], &yi[igrid], &xi[igrid], &zeta, &eta, &xsi, gtype, t0, t1, CGRID_VELOCITY, gridindexingtype); CHECKSTATUS(status); - status = getCell3D(U, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_U, 0); CHECKSTATUS(status); - status = getCell3D(V, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_V, 0); CHECKSTATUS(status); - status = getCell3D(W, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_W, 0); CHECKSTATUS(status); - if (grid->zdim==1){ - return ERROR; - } else { - status = spatial_interpolation_UVW_c_grid(zeta, eta, xsi, ti[igrid], zi[igrid], yi[igrid], xi[igrid], grid, gtype, data3D_U[0], data3D_V[0], data3D_W[0], &u0, &v0, &w0, gridindexingtype); CHECKSTATUS(status); - status = spatial_interpolation_UVW_c_grid(zeta, eta, xsi, ti[igrid]+1, zi[igrid], yi[igrid], xi[igrid], grid, gtype, data3D_U[1], data3D_V[1], data3D_W[1], &u1, &v1, &w1, gridindexingtype); CHECKSTATUS(status); - } - *u = u0 + (u1 - u0) * (float)((time - t0) / (t1 - t0)); - *v = v0 + (v1 - v0) * (float)((time - t0) / (t1 - t0)); - *w = w0 + (w1 - w0) * (float)((time - t0) / (t1 - t0)); - return SUCCESS; - } else { - double t0 = grid->time[ti[igrid]]; - status = search_indices(t0, z, y, x, grid, ti[igrid], &zi[igrid], &yi[igrid], &xi[igrid], &zeta, &eta, &xsi, gtype, t0, t0+1, CGRID_VELOCITY, gridindexingtype); CHECKSTATUS(status); - status = getCell3D(U, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_U, 1); CHECKSTATUS(status); - status = getCell3D(V, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_V, 1); CHECKSTATUS(status); - status = getCell3D(W, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_W, 1); CHECKSTATUS(status); - if (grid->zdim==1){ - return ERROR; - } - else{ - status = spatial_interpolation_UVW_c_grid(zeta, eta, xsi, ti[igrid], zi[igrid], yi[igrid], xi[igrid], grid, gtype, data3D_U[0], data3D_V[0], data3D_W[0], u, v, w, gridindexingtype); CHECKSTATUS(status); - } - return SUCCESS; - } -} - -static inline StatusCode calculate_slip_conditions_2D(double eta, double xsi, - float dataU[2][2], float dataV[2][2], float dataW[2][2], - float *u, float *v, float *w, int interp_method, int withW) -{ - float f_u = 1, f_v = 1, f_w = 1; - if ((is_zero_flt(dataU[0][0])) && (is_zero_flt(dataU[0][1])) && - (is_zero_flt(dataV[0][0])) && (is_zero_flt(dataV[0][1])) && eta > 0.){ - if (interp_method == PARTIALSLIP) { - f_u = f_u * (.5 + .5 * eta) / eta; - if (withW) { - f_w = f_w * (.5 + .5 * eta) / eta; - } - } else if (interp_method == FREESLIP) { - f_u = f_u / eta; - if (withW) { - f_w = f_w / eta; - } - } - } - if ((is_zero_flt(dataU[1][0])) && (is_zero_flt(dataU[1][1])) && - (is_zero_flt(dataV[1][0])) && (is_zero_flt(dataV[1][1])) && eta < 1.){ - if (interp_method == PARTIALSLIP) { - f_u = f_u * (1 - .5 * eta) / (1 - eta); - if (withW) { - f_w = f_w * (1 - .5 * eta) / (1 - eta); - } - } else if (interp_method == FREESLIP) { - f_u = f_u / (1 - eta); - if (withW) { - f_w = f_w / (1 - eta); - } - } - } - if ((is_zero_flt(dataU[0][0])) && (is_zero_flt(dataU[1][0])) && - (is_zero_flt(dataV[0][0])) && (is_zero_flt(dataV[1][0])) && xsi > 0.){ - if (interp_method == PARTIALSLIP) { - f_v = f_v * (.5 + .5 * xsi) / xsi; - if (withW) { - f_w = f_w * (.5 + .5 * xsi) / xsi; - } - } else if (interp_method == FREESLIP) { - f_v = f_v / xsi; - if (withW) { - f_w = f_w / xsi; - } - } - } - if ((is_zero_flt(dataU[0][1])) && (is_zero_flt(dataU[1][1])) && - (is_zero_flt(dataV[0][1])) && (is_zero_flt(dataV[1][1])) && xsi < 1.){ - if (interp_method == PARTIALSLIP) { - f_v = f_v * (1 - .5 * xsi) / (1 - xsi); - if (withW) { - f_w = f_w * (1 - .5 * xsi) / (1 - xsi); - } - } else if (interp_method == FREESLIP) { - f_v = f_v / (1 - xsi); - if (withW) { - f_w = f_w / (1 - xsi); - } - } - } - *u *= f_u; - *v *= f_v; - if (withW) { - *w *= f_w; - } - - return SUCCESS; -} - -static inline StatusCode calculate_slip_conditions_3D(double zeta, double eta, double xsi, - float dataU[2][2][2], float dataV[2][2][2], float dataW[2][2][2], - float *u, float *v, float *w, int interp_method, int withW) -{ - float f_u = 1, f_v = 1, f_w = 1; - if ((is_zero_flt(dataU[0][0][0])) && (is_zero_flt(dataU[0][0][1])) && (is_zero_flt(dataU[1][0][0])) && (is_zero_flt(dataU[1][0][1])) && - (is_zero_flt(dataV[0][0][0])) && (is_zero_flt(dataV[0][0][1])) && (is_zero_flt(dataV[1][0][0])) && (is_zero_flt(dataV[1][0][1])) && - eta > 0.){ - if (interp_method == PARTIALSLIP) { - f_u = f_u * (.5 + .5 * eta) / eta; - if (withW) { - f_w = f_w * (.5 + .5 * eta) / eta; - } - } else if (interp_method == FREESLIP) { - f_u = f_u / eta; - if (withW) { - f_w = f_w / eta; - } - } - } - if ((is_zero_flt(dataU[0][1][0])) && (is_zero_flt(dataU[0][1][1])) && (is_zero_flt(dataU[1][1][0])) && (is_zero_flt(dataU[1][1][1])) && - (is_zero_flt(dataV[0][1][0])) && (is_zero_flt(dataV[0][1][1])) && (is_zero_flt(dataV[1][1][0])) && (is_zero_flt(dataV[1][1][1])) && - eta < 1.){ - if (interp_method == PARTIALSLIP) { - f_u = f_u * (1 - .5 * eta) / (1 - eta); - if (withW) { - f_w = f_w * (1 - .5 * eta) / (1 - eta); - } - } else if (interp_method == FREESLIP) { - f_u = f_u / (1 - eta); - if (withW) { - f_w = f_w / (1 - eta); - } - } - } - if ((is_zero_flt(dataU[0][0][0])) && (is_zero_flt(dataU[0][1][0])) && (is_zero_flt(dataU[1][0][0])) && (is_zero_flt(dataU[1][1][0])) && - (is_zero_flt(dataV[0][0][0])) && (is_zero_flt(dataV[0][1][0])) && (is_zero_flt(dataV[1][0][0])) && (is_zero_flt(dataV[1][1][0])) && - xsi > 0.){ - if (interp_method == PARTIALSLIP) { - f_v = f_v * (.5 + .5 * xsi) / xsi; - if (withW) { - f_w = f_w * (.5 + .5 * xsi) / xsi; - } - } else if (interp_method == FREESLIP) { - f_v = f_v / xsi; - if (withW) { - f_w = f_w / xsi; - } - } - } - if ((is_zero_flt(dataU[0][0][1])) && (is_zero_flt(dataU[0][1][1])) && (is_zero_flt(dataU[1][0][1])) && (is_zero_flt(dataU[1][1][1])) && - (is_zero_flt(dataV[0][0][1])) && (is_zero_flt(dataV[0][1][1])) && (is_zero_flt(dataV[1][0][1])) && (is_zero_flt(dataV[1][1][1])) && - xsi < 1.){ - if (interp_method == PARTIALSLIP) { - f_v = f_v * (1 - .5 * xsi) / (1 - xsi); - if (withW) { - f_w = f_w * (1 - .5 * xsi) / (1 - xsi); - } - } else if (interp_method == FREESLIP) { - f_v = f_v / (1 - xsi); - if (withW) { - f_w = f_w / (1 - xsi); - } - } - } - if ((is_zero_flt(dataU[0][0][0])) && (is_zero_flt(dataU[0][0][1])) && (is_zero_flt(dataU[0][1][0])) && (is_zero_flt(dataU[0][1][1])) && - (is_zero_flt(dataV[0][0][0])) && (is_zero_flt(dataV[0][0][1])) && (is_zero_flt(dataV[0][1][0])) && (is_zero_flt(dataV[0][1][1])) && - zeta > 0.){ - if (interp_method == PARTIALSLIP) { - f_u = f_u * (.5 + .5 * zeta) / zeta; - f_v = f_v * (.5 + .5 * zeta) / zeta; - } else if (interp_method == FREESLIP) { - f_u = f_u / zeta; - f_v = f_v / zeta; - } - } - if ((is_zero_flt(dataU[1][0][0])) && (is_zero_flt(dataU[1][0][1])) && (is_zero_flt(dataU[1][1][0])) && (is_zero_flt(dataU[1][1][1])) && - (is_zero_flt(dataV[1][0][0])) && (is_zero_flt(dataV[1][0][1])) && (is_zero_flt(dataV[1][1][0])) && (is_zero_flt(dataV[1][1][1])) && - zeta < 1.){ - if (interp_method == PARTIALSLIP) { - f_u = f_u * (1 - .5 * zeta) / (1 - zeta); - f_v = f_v * (1 - .5 * zeta) / (1 - zeta); - } else if (interp_method == FREESLIP) { - f_u = f_u / (1 - zeta); - f_v = f_v / (1 - zeta); - } - } - *u *= f_u; - *v *= f_v; - if (withW) { - *w *= f_w; - } - - return SUCCESS; -} - -static inline StatusCode temporal_interpolation_slip(double time, type_coord z, type_coord y, type_coord x, - CField *U, CField *V, CField *W, - GridType gtype, int *ti, int *zi, int *yi, int *xi, - float *u, float *v, float *w, int interp_method, int gridindexingtype, int withW) -{ - StatusCode status; - CStructuredGrid *grid = U->grid->grid; - int igrid = U->igrid; - - /* Find time index for temporal interpolation */ - if (U->time_periodic == 0 && U->allow_time_extrapolation == 0 && (time < grid->time[0] || time > grid->time[grid->tdim-1])){ - return ERRORTIMEEXTRAPOLATION; - } - status = search_time_index(&time, grid->tdim, grid->time, &ti[igrid], U->time_periodic, grid->tfull_min, grid->tfull_max, grid->periods); CHECKSTATUS(status); - - double xsi, eta, zeta; - - if (ti[igrid] < grid->tdim-1 && time > grid->time[ti[igrid]]) { - float u0, u1, v0, v1, w0, w1; - double t0 = grid->time[ti[igrid]]; double t1 = grid->time[ti[igrid]+1]; - /* Identify grid cell to sample through local linear search */ - status = search_indices(time, z, y, x, grid, ti[igrid], &zi[igrid], &yi[igrid], &xi[igrid], &zeta, &eta, &xsi, gtype, t0, t1, interp_method, gridindexingtype); CHECKSTATUS(status); - if (grid->zdim==1){ - float data2D_U[2][2][2], data2D_V[2][2][2], data2D_W[2][2][2]; - status = getCell2D(U, ti[igrid], yi[igrid], xi[igrid], data2D_U, 0); CHECKSTATUS(status); - status = getCell2D(V, ti[igrid], yi[igrid], xi[igrid], data2D_V, 0); CHECKSTATUS(status); - if (withW){ - status = getCell2D(W, ti[igrid], yi[igrid], xi[igrid], data2D_W, 0); CHECKSTATUS(status); - status = spatial_interpolation_bilinear(eta, xsi, data2D_W[0], &w0); CHECKSTATUS(status); - status = spatial_interpolation_bilinear(eta, xsi, data2D_W[1], &w1); CHECKSTATUS(status); - } - - status = spatial_interpolation_bilinear(eta, xsi, data2D_U[0], &u0); CHECKSTATUS(status); - status = spatial_interpolation_bilinear(eta, xsi, data2D_V[0], &v0); CHECKSTATUS(status); - status = calculate_slip_conditions_2D(eta, xsi, data2D_U[0], data2D_V[0], data2D_W[0], &u0, &v0, &w0, interp_method, withW); CHECKSTATUS(status); - - status = spatial_interpolation_bilinear(eta, xsi, data2D_U[1], &u1); CHECKSTATUS(status); - status = spatial_interpolation_bilinear(eta, xsi, data2D_V[1], &v1); CHECKSTATUS(status); - status = calculate_slip_conditions_2D(eta, xsi, data2D_U[1], data2D_V[1], data2D_W[1], &u1, &v1, &w1, interp_method, withW); CHECKSTATUS(status); - } else { - float data3D_U[2][2][2][2], data3D_V[2][2][2][2], data3D_W[2][2][2][2]; - status = getCell3D(U, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_U, 0); CHECKSTATUS(status); - status = getCell3D(V, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_V, 0); CHECKSTATUS(status); - if (withW){ - status = getCell3D(W, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_W, 0); CHECKSTATUS(status); - status = spatial_interpolation_trilinear(zeta, eta, xsi, data3D_W[0], &w0); CHECKSTATUS(status); - status = spatial_interpolation_trilinear(zeta, eta, xsi, data3D_W[1], &w1); CHECKSTATUS(status); - } - status = spatial_interpolation_trilinear(zeta, eta, xsi, data3D_U[0], &u0); CHECKSTATUS(status); - status = spatial_interpolation_trilinear(zeta, eta, xsi, data3D_V[0], &v0); CHECKSTATUS(status); - status = calculate_slip_conditions_3D(zeta, eta, xsi, data3D_U[0], data3D_V[0], data3D_W[0], &u0, &v0, &w0, interp_method, withW); CHECKSTATUS(status); - - status = spatial_interpolation_trilinear(zeta, eta, xsi, data3D_U[1], &u1); CHECKSTATUS(status); - status = spatial_interpolation_trilinear(zeta, eta, xsi, data3D_V[1], &v1); CHECKSTATUS(status); - status = calculate_slip_conditions_3D(zeta, eta, xsi, data3D_U[1], data3D_V[1], data3D_W[1], &u1, &v1, &w1, interp_method, withW); CHECKSTATUS(status); - } - *u = u0 + (u1 - u0) * (float)((time - t0) / (t1 - t0)); - *v = v0 + (v1 - v0) * (float)((time - t0) / (t1 - t0)); - if (withW){ - *w = w0 + (w1 - w0) * (float)((time - t0) / (t1 - t0)); - } - - } else { - double t0 = grid->time[ti[igrid]]; - status = search_indices(t0, z, y, x, grid, ti[igrid], &zi[igrid], &yi[igrid], &xi[igrid], &zeta, &eta, &xsi, gtype, t0, t0+1, interp_method, gridindexingtype); CHECKSTATUS(status); - if (grid->zdim==1){ - float data2D_U[2][2][2], data2D_V[2][2][2], data2D_W[2][2][2]; - status = getCell2D(U, ti[igrid], yi[igrid], xi[igrid], data2D_U, 1); CHECKSTATUS(status); - status = getCell2D(V, ti[igrid], yi[igrid], xi[igrid], data2D_V, 1); CHECKSTATUS(status); - if (withW){ - status = getCell2D(W, ti[igrid], yi[igrid], xi[igrid], data2D_W, 1); CHECKSTATUS(status); - status = spatial_interpolation_bilinear(eta, xsi, data2D_W[0], w); CHECKSTATUS(status); - } - - status = spatial_interpolation_bilinear(eta, xsi, data2D_U[0], u); CHECKSTATUS(status); - status = spatial_interpolation_bilinear(eta, xsi, data2D_V[0], v); CHECKSTATUS(status); - - status = calculate_slip_conditions_2D(eta, xsi, data2D_U[0], data2D_V[0], data2D_W[0], u, v, w, interp_method, withW); CHECKSTATUS(status); - } else { - float data3D_U[2][2][2][2], data3D_V[2][2][2][2], data3D_W[2][2][2][2]; - status = getCell3D(U, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_U, 1); CHECKSTATUS(status); - status = getCell3D(V, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_V, 1); CHECKSTATUS(status); - if (withW){ - status = getCell3D(W, ti[igrid], zi[igrid], yi[igrid], xi[igrid], data3D_W, 1); CHECKSTATUS(status); - status = spatial_interpolation_trilinear(zeta, eta, xsi, data3D_W[0], w); CHECKSTATUS(status); - } - status = spatial_interpolation_trilinear(zeta, eta, xsi, data3D_U[0], u); CHECKSTATUS(status); - status = spatial_interpolation_trilinear(zeta, eta, xsi, data3D_V[0], v); CHECKSTATUS(status); - status = calculate_slip_conditions_3D(zeta, eta, xsi, data3D_U[0], data3D_V[0], data3D_W[0], u, v, w, interp_method, withW); CHECKSTATUS(status); - } - } - return SUCCESS; -} - -static inline StatusCode temporal_interpolation(double time, type_coord z, type_coord y, type_coord x, - CField *f, - int *ti, int *zi, int *yi, int *xi, - float *value, int interp_method, int gridindexingtype) -{ - CGrid *_grid = f->grid; - GridType gtype = _grid->gtype; - - if (gtype == RECTILINEAR_Z_GRID || gtype == RECTILINEAR_S_GRID || gtype == CURVILINEAR_Z_GRID || gtype == CURVILINEAR_S_GRID){ - return temporal_interpolation_structured_grid(time, z, y, x, f, gtype, ti, zi, yi, xi, value, interp_method, gridindexingtype); - } - else{ - printf("Only RECTILINEAR_Z_GRID, RECTILINEAR_S_GRID, CURVILINEAR_Z_GRID and CURVILINEAR_S_GRID grids are currently implemented\n"); - return ERROR; - } -} - -static inline StatusCode temporal_interpolationUV(double time, type_coord z, type_coord y, type_coord x, - CField *U, CField *V, - int *ti, int *zi, int *yi, int *xi, - float *valueU, float *valueV, int interp_method, int gridindexingtype) -{ - StatusCode status; - if (interp_method == CGRID_VELOCITY){ - CGrid *_grid = U->grid; - GridType gtype = _grid->gtype; - status = temporal_interpolationUV_c_grid(time, z, y, x, U, V, gtype, ti, zi, yi, xi, valueU, valueV, gridindexingtype); CHECKSTATUS(status); - return SUCCESS; - } else if ((interp_method == PARTIALSLIP) || (interp_method == FREESLIP)){ - CGrid *_grid = U->grid; - CField *W = U; - GridType gtype = _grid->gtype; - int withW = 0; - status = temporal_interpolation_slip(time, z, y, x, U, V, W, gtype, ti, zi, yi, xi, valueU, valueV, 0, interp_method, gridindexingtype, withW); CHECKSTATUS(status); - return SUCCESS; - } else { - status = temporal_interpolation(time, z, y, x, U, ti, zi, yi, xi, valueU, interp_method, gridindexingtype); CHECKSTATUS(status); - status = temporal_interpolation(time, z, y, x, V, ti, zi, yi, xi, valueV, interp_method, gridindexingtype); CHECKSTATUS(status); - return SUCCESS; - } -} - -static inline StatusCode temporal_interpolationUVW(double time, type_coord z, type_coord y, type_coord x, - CField *U, CField *V, CField *W, - int *ti, int *zi, int *yi, int *xi, - float *valueU, float *valueV, float *valueW, int interp_method, int gridindexingtype) -{ - StatusCode status; - if (interp_method == CGRID_VELOCITY){ - CGrid *_grid = U->grid; - GridType gtype = _grid->gtype; - if (gtype == RECTILINEAR_S_GRID || gtype == CURVILINEAR_S_GRID){ - status = temporal_interpolationUVW_c_grid(time, z, y, x, U, V, W, gtype, ti, zi, yi, xi, valueU, valueV, valueW, gridindexingtype); CHECKSTATUS(status); - return SUCCESS; - } - } else if ((interp_method == PARTIALSLIP) || (interp_method == FREESLIP)){ - CGrid *_grid = U->grid; - GridType gtype = _grid->gtype; - int withW = 1; - status = temporal_interpolation_slip(time, z, y, x, U, V, W, gtype, ti, zi, yi, xi, valueU, valueV, valueW, interp_method, gridindexingtype, withW); CHECKSTATUS(status); - return SUCCESS; - } - status = temporal_interpolationUV(time, z, y, x, U, V, ti, zi, yi, xi, valueU, valueV, interp_method, gridindexingtype); CHECKSTATUS(status); - if (interp_method == BGRID_VELOCITY) - interp_method = BGRID_W_VELOCITY; - if (gridindexingtype == CROCO) // Linear vertical interpolation for CROCO - interp_method = LINEAR; - status = temporal_interpolation(time, z, y, x, W, ti, zi, yi, xi, valueW, interp_method, gridindexingtype); CHECKSTATUS(status); - return SUCCESS; -} - - -static inline double croco_from_z_to_sigma(double time, type_coord z, type_coord y, type_coord x, - CField *U, CField *H, CField *Zeta, - int *ti, int *zi, int *yi, int *xi, double hc, float *cs_w) -{ - float local_h, local_zeta, z0; - int status, zii; - CStructuredGrid *grid = U->grid->grid; - float *sigma_levels = grid->depth; - int zdim = grid->zdim; - float zvec[zdim]; - status = temporal_interpolation(time, 0, y, x, H, ti, zi, yi, xi, &local_h, LINEAR, CROCO); CHECKSTATUS(status); - status = temporal_interpolation(time, 0, y, x, Zeta, ti, zi, yi, xi, &local_zeta, LINEAR, CROCO); CHECKSTATUS(status); - for (zii = 0; zii < zdim; zii++) { - z0 = hc*sigma_levels[zii] + (local_h - hc) *cs_w[zii]; - zvec[zii] = z0 + local_zeta * (1 + z0 / local_h); - } - if (z >= zvec[zdim-1]) - zii = zdim - 2; - else - for (zii = 0; zii < zdim-1; zii++) - if ((z >= zvec[zii]) && (z < zvec[zii+1])) - break; - - return sigma_levels[zii] + (z - zvec[zii]) * (sigma_levels[zii + 1] - sigma_levels[zii]) / (zvec[zii + 1] - zvec[zii]); -} - -#ifdef __cplusplus -} -#endif -#endif diff --git a/parcels/include/random.h b/parcels/include/random.h deleted file mode 100644 index 07a461cef..000000000 --- a/parcels/include/random.h +++ /dev/null @@ -1,111 +0,0 @@ -#ifndef _PARCELS_RANDOM_H -#define _PARCELS_RANDOM_H -#ifdef __cplusplus -extern "C" { -#endif - -/**************************************************/ - - -/**************************************************/ -/* Random number generation (RNG) functions */ -/**************************************************/ - -static inline void parcels_seed(int seed) -{ - srand(seed); -} - -static inline float parcels_random() -{ - return (float)rand()/(float)(RAND_MAX); -} - -static inline float parcels_uniform(float low, float high) -{ - return (float)rand()/(float)((float)(RAND_MAX) / (high-low)) + low; -} - -static inline int parcels_randint(int low, int high) -{ - return (rand() % (high-low)) + low; -} - -static inline float parcels_normalvariate(float loc, float scale) -/* Function to create a Gaussian random variable with mean loc and standard deviation scale */ -/* Uses Box-Muller transform, adapted from ftp://ftp.taygeta.com/pub/c/boxmuller.c */ -/* (c) Copyright 1994, Everett F. Carter Jr. Permission is granted by the author to use */ -/* this software for any application provided this copyright notice is preserved. */ -{ - float x1, x2, w, y1; - - do { - x1 = 2.0 * (float)rand()/(float)(RAND_MAX) - 1.0; - x2 = 2.0 * (float)rand()/(float)(RAND_MAX) - 1.0; - w = x1 * x1 + x2 * x2; - } while ( w >= 1.0 ); - - w = sqrt( (-2.0 * log( w ) ) / w ); - y1 = x1 * w; - return( loc + y1 * scale ); -} - -static inline float parcels_expovariate(float lamb) -//Function to create an exponentially distributed random variable -{ - float u; - u = (float)rand()/((float)(RAND_MAX) + 1.0); - return (-log(1.0-u)/lamb); -} - -static inline float parcels_vonmisesvariate(float mu, float kappa) -/* Circular data distribution. */ -/* Returns a float between 0 and 2*pi */ -/* mu is the mean angle, expressed in radians between 0 and 2*pi, and */ -/* kappa is the concentration parameter, which must be greater than or */ -/* equal to zero. If kappa is equal to zero, this distribution reduces */ -/* to a uniform random angle over the range 0 to 2*pi. */ -/* Based upon an algorithm published in: Fisher, N.I., */ -/* Statistical Analysis of Circular Data", Cambridge University Press, 1993.*/ -{ - float u1, u2, u3, r, s, z, d, f, q, theta; - - if (kappa <= 1e-6){ - return (2.0 * M_PI * (float)rand()/(float)(RAND_MAX)); - } - - s = 0.5 / kappa; - if (fabs(s) <= FLT_EPSILON * fabs(s)){ - return mu; - } - r = s + sqrt(1.0 + s * s); - - do { - u1 = (float)rand()/(float)(RAND_MAX); - z = cos(M_PI * u1); - - d = z / (r + z); - u2 = (float)rand()/(float)(RAND_MAX); - } while ( ( u2 >= (1.0 - d * d) ) && ( u2 > (1.0 - d) * exp(d) ) ); - - q = 1.0 / r; - f = (q + z) / (1.0 + q * z); - u3 = (float)rand()/(float)(RAND_MAX); - - if (u3 > 0.5){ - theta = fmod(mu + acos(f), 2.0*M_PI); - } - else { - theta = fmod(mu - acos(f), 2.0*M_PI); - } - if (theta < 0){ - theta = 2.0*M_PI+theta; - } - - return theta; -} - -#ifdef __cplusplus -} -#endif -#endif diff --git a/parcels/interaction/__init__.py b/parcels/interaction/__init__.py index 2ce3ced6e..71eee987a 100644 --- a/parcels/interaction/__init__.py +++ b/parcels/interaction/__init__.py @@ -1 +1 @@ -from .interactionkernel import InteractionKernel # noqa +# from .interactionkernel import InteractionKernel diff --git a/parcels/interaction/interactionkernel.py b/parcels/interaction/interactionkernel.py index 0e3979a2e..039297f5d 100644 --- a/parcels/interaction/interactionkernel.py +++ b/parcels/interaction/interactionkernel.py @@ -5,7 +5,7 @@ import numpy as np from parcels._compat import MPI -from parcels.field import NestedField, VectorField +from parcels.field import VectorField from parcels.kernel import BaseKernel from parcels.tools.statuscodes import StatusCode @@ -27,11 +27,7 @@ def __init__( ptype, pyfunc=None, funcname=None, - funccode=None, py_ast=None, - funcvars=None, - c_include="", - delete_cfiles: bool = True, ): if MPI is not None and MPI.COMM_WORLD.Get_size() > 1: raise NotImplementedError( @@ -54,11 +50,7 @@ def __init__( ptype=ptype, pyfunc=pyfunc, funcname=funcname, - funccode=funccode, py_ast=py_ast, - funcvars=funcvars, - c_include=c_include, - delete_cfiles=delete_cfiles, ) if pyfunc is not None: @@ -73,26 +65,14 @@ def __init__( else: self._pyfunc = [pyfunc] - if self._ptype.uses_jit: - raise NotImplementedError( - "JIT mode is not supported for InteractionKernels. Please run your simulation in SciPy mode." - ) - for func in self._pyfunc: self.check_fieldsets_in_kernels(func) numkernelargs = self.check_kernel_signature_on_version() - assert numkernelargs[0] == 5 and numkernelargs.count(numkernelargs[0]) == len( - numkernelargs - ), "Interactionkernels take exactly 5 arguments: particle, fieldset, time, neighbors, mutator" - - # At this time, JIT mode is not supported for InteractionKernels, - # so there is no need for any further "processing" of pyfunc's. - - @property - def _cache_key(self): - raise NotImplementedError + assert numkernelargs[0] == 5 and numkernelargs.count(numkernelargs[0]) == len(numkernelargs), ( + "Interactionkernels take exactly 5 arguments: particle, fieldset, time, neighbors, mutator" + ) def check_fieldsets_in_kernels(self, pyfunc): # Currently, the implemented interaction kernels do not impose @@ -111,24 +91,9 @@ def check_kernel_signature_on_version(self): numkernelargs.append(len(inspect.getfullargspec(func).args)) return numkernelargs - def remove_lib(self): - # Currently, no libs are generated/linked, so nothing has to be - # removed - pass - - def get_kernel_compile_files(self): - raise NotImplementedError - - def compile(self, compiler): - raise NotImplementedError - - def load_lib(self): - raise NotImplementedError - def merge(self, kernel, kclass): assert self.__class__ == kernel.__class__ funcname = self.funcname + kernel.funcname - # delete_cfiles = self.delete_cfiles and kernel.delete_cfiles pyfunc = self._pyfunc + kernel._pyfunc return kclass(self._fieldset, self._ptype, pyfunc=pyfunc, funcname=funcname) @@ -142,25 +107,6 @@ def __radd__(self, kernel): kernel = InteractionKernel(self.fieldset, self.ptype, pyfunc=kernel) return kernel.merge(self, InteractionKernel) - def __del__(self): - # Clean-up the in-memory dynamic linked libraries. - # This is not really necessary, as these programs are not that large, but with the new random - # naming scheme which is required on Windows OS'es to deal with updates to a Parcels' kernel.) - super().__del__() - - @staticmethod - def cleanup_remove_files(lib_file, all_files_array, delete_cfiles): - raise NotImplementedError - - @staticmethod - def cleanup_unload_lib(lib): - raise NotImplementedError - - def execute_jit(self, pset, endtime, dt): - raise NotImplementedError( - "JIT mode is not supported for InteractionKernels. Please run your simulation in SciPy mode." - ) - def execute_python(self, pset, endtime, dt): """Performs the core update loop via Python. @@ -170,8 +116,8 @@ def execute_python(self, pset, endtime, dt): InteractionKernel. """ if self.fieldset is not None: - for f in self.fieldset.get_fields(): - if isinstance(f, (VectorField, NestedField)): + for f in self.fieldset.fields.values(): + if isinstance(f, VectorField): continue f.data = np.array(f.data) @@ -211,7 +157,7 @@ def execute_python(self, pset, endtime, dt): for particle_idx in active_idx: p = pset[particle_idx] try: - for mutator_func, args in mutator[p.id]: + for mutator_func, args in mutator[p.trajectory]: mutator_func(p, *args) except KeyError: pass @@ -235,20 +181,7 @@ def execute(self, pset, endtime, dt, output_file=None): stacklevel=2, ) - if pset.fieldset is not None: - for g in pset.fieldset.gridset.grids: - if len(g._load_chunk) > g._chunk_not_loaded: # not the case if a field in not called in the kernel - g._load_chunk = np.where( - g._load_chunk == g._chunk_loaded_touched, g._chunk_deprecated, g._load_chunk - ) - - # Execute the kernel over the particle set - if self.ptype.uses_jit: - # This should never happen, as it is already checked in the - # initialization. - self.execute_jit(pset, endtime, dt) - else: - self.execute_python(pset, endtime, dt) + self.execute_python(pset, endtime, dt) # Remove all particles that signalled deletion self.remove_deleted(pset) # Generalizable version! @@ -268,7 +201,7 @@ def execute(self, pset, endtime, dt, output_file=None): pass else: warnings.warn( - f"Deleting particle {p.id} because of non-recoverable error", + f"Deleting particle {p.trajectory} because of non-recoverable error", RuntimeWarning, stacklevel=2, ) @@ -278,9 +211,6 @@ def execute(self, pset, endtime, dt, output_file=None): self.remove_deleted(pset) # Generalizable version! # Execute core loop again to continue interrupted particles - if self.ptype.uses_jit: - self.execute_jit(pset, endtime, dt) - else: - self.execute_python(pset, endtime, dt) + self.execute_python(pset, endtime, dt) n_error = pset._num_error_particles diff --git a/parcels/interpolators.py b/parcels/interpolators.py new file mode 100644 index 000000000..4a2f9ad29 --- /dev/null +++ b/parcels/interpolators.py @@ -0,0 +1,666 @@ +"""Collection of pre-built interpolation kernels.""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +import numpy as np +import xarray as xr +from dask import is_dask_collection + +import parcels.utils.interpolation_utils as i_u + +if TYPE_CHECKING: + from parcels._core.field import Field, VectorField + from parcels._core.uxgrid import _UXGRID_AXES + from parcels._core.xgrid import _XGRID_AXES + +__all__ = [ + "CGrid_Tracer", + "CGrid_Velocity", + "UXPiecewiseConstantFace", + "UXPiecewiseLinearNode", + "XFreeslip", + "XLinear", + "XNearest", + "XPartialslip", + "ZeroInterpolator", + "ZeroInterpolator_Vector", +] + + +def ZeroInterpolator( + field: Field, + ti: int, + position: dict[_XGRID_AXES, tuple[int, float | np.ndarray]], + tau: np.float32 | np.float64, + t: np.float32 | np.float64, + z: np.float32 | np.float64, + y: np.float32 | np.float64, + x: np.float32 | np.float64, +) -> np.float32 | np.float64: + """Template function used for the signature check of the lateral interpolation methods.""" + return 0.0 + + +def ZeroInterpolator_Vector( + vectorfield: VectorField, + ti: int, + position: dict[_XGRID_AXES, tuple[int, float | np.ndarray]], + tau: np.float32 | np.float64, + t: np.float32 | np.float64, + z: np.float32 | np.float64, + y: np.float32 | np.float64, + x: np.float32 | np.float64, + applyConversion: bool, +) -> np.float32 | np.float64: + """Template function used for the signature check of the interpolation methods for velocity fields.""" + return 0.0 + + +def _get_corner_data_Agrid( + data: np.ndarray | xr.DataArray, + ti: int, + zi: int, + yi: int, + xi: int, + lenT: int, + lenZ: int, + npart: int, + axis_dim: dict[str, str], +) -> np.ndarray: + """Helper function to get the corner data for a given A-grid field and position.""" + # Time coordinates: 8 points at ti, then 8 points at ti+1 + if lenT == 1: + ti = np.repeat(ti, lenZ * 4) + else: + ti_1 = np.clip(ti + 1, 0, data.shape[0] - 1) + ti = np.concatenate([np.repeat(ti, lenZ * 4), np.repeat(ti_1, lenZ * 4)]) + + # Depth coordinates: 4 points at zi, 4 at zi+1, repeated for both time levels + if lenZ == 1: + zi = np.repeat(zi, lenT * 4) + else: + zi_1 = np.clip(zi + 1, 0, data.shape[1] - 1) + zi = np.tile(np.array([zi, zi, zi, zi, zi_1, zi_1, zi_1, zi_1]).flatten(), lenT) + + # Y coordinates: [yi, yi, yi+1, yi+1] for each spatial point, repeated for time/depth + yi_1 = np.clip(yi + 1, 0, data.shape[2] - 1) + yi = np.tile(np.repeat(np.column_stack([yi, yi_1]), 2), (lenT) * (lenZ)) + + # X coordinates: [xi, xi+1, xi, xi+1] for each spatial point, repeated for time/depth + xi_1 = np.clip(xi + 1, 0, data.shape[3] - 1) + xi = np.tile(np.column_stack([xi, xi_1, xi, xi_1]).flatten(), (lenT) * (lenZ)) + + # Create DataArrays for indexing + selection_dict = { + axis_dim["X"]: xr.DataArray(xi, dims=("points")), + axis_dim["Y"]: xr.DataArray(yi, dims=("points")), + } + if "Z" in axis_dim: + selection_dict[axis_dim["Z"]] = xr.DataArray(zi, dims=("points")) + if "time" in data.dims: + selection_dict["time"] = xr.DataArray(ti, dims=("points")) + + return data.isel(selection_dict).data.reshape(lenT, lenZ, npart, 4) + + +def XLinear( + field: Field, + ti: int, + position: dict[_XGRID_AXES, tuple[int, float | np.ndarray]], + tau: np.float32 | np.float64, + t: np.float32 | np.float64, + z: np.float32 | np.float64, + y: np.float32 | np.float64, + x: np.float32 | np.float64, +): + """Trilinear interpolation on a regular grid.""" + xi, xsi = position["X"] + yi, eta = position["Y"] + zi, zeta = position["Z"] + + axis_dim = field.grid.get_axis_dim_mapping(field.data.dims) + data = field.data + + lenT = 2 if np.any(tau > 0) else 1 + lenZ = 2 if np.any(zeta > 0) else 1 + + corner_data = _get_corner_data_Agrid(data, ti, zi, yi, xi, lenT, lenZ, len(xsi), axis_dim) + + if lenT == 2: + tau = tau[np.newaxis, :, np.newaxis] + corner_data = corner_data[0, :, :, :] * (1 - tau) + corner_data[1, :, :, :] * tau + else: + corner_data = corner_data[0, :, :, :] + + if lenZ == 2: + zeta = zeta[:, np.newaxis] + corner_data = corner_data[0, :, :] * (1 - zeta) + corner_data[1, :, :] * zeta + else: + corner_data = corner_data[0, :, :] + + value = ( + (1 - xsi) * (1 - eta) * corner_data[:, 0] + + xsi * (1 - eta) * corner_data[:, 1] + + (1 - xsi) * eta * corner_data[:, 2] + + xsi * eta * corner_data[:, 3] + ) + return value.compute() if is_dask_collection(value) else value + + +def CGrid_Velocity( + vectorfield: VectorField, + ti: int, + position: dict[_XGRID_AXES, tuple[int, float | np.ndarray]], + tau: np.float32 | np.float64, + t: np.float32 | np.float64, + z: np.float32 | np.float64, + y: np.float32 | np.float64, + x: np.float32 | np.float64, + applyConversion: bool, +): + """ + Interpolation kernel for velocity fields on a C-Grid. + Following Delandmeter and Van Sebille (2019), velocity fields should be interpolated + only in the direction of the grid cell faces. + """ + xi, xsi = position["X"] + yi, eta = position["Y"] + zi, zeta = position["Z"] + + U = vectorfield.U.data + V = vectorfield.V.data + grid = vectorfield.grid + tdim, zdim, ydim, xdim = U.shape[0], U.shape[1], U.shape[2], U.shape[3] + + if grid.lon.ndim == 1: + px = np.array([grid.lon[xi], grid.lon[xi + 1], grid.lon[xi + 1], grid.lon[xi]]) + py = np.array([grid.lat[yi], grid.lat[yi], grid.lat[yi + 1], grid.lat[yi + 1]]) + else: + px = np.array([grid.lon[yi, xi], grid.lon[yi, xi + 1], grid.lon[yi + 1, xi + 1], grid.lon[yi + 1, xi]]) + py = np.array([grid.lat[yi, xi], grid.lat[yi, xi + 1], grid.lat[yi + 1, xi + 1], grid.lat[yi + 1, xi]]) + + if grid._mesh == "spherical": + px[0] = np.where(px[0] < x - 225, px[0] + 360, px[0]) + px[0] = np.where(px[0] > x + 225, px[0] - 360, px[0]) + px[1:] = np.where(px[1:] - px[0] > 180, px[1:] - 360, px[1:]) + px[1:] = np.where(-px[1:] + px[0] > 180, px[1:] + 360, px[1:]) + c1 = i_u._geodetic_distance( + py[0], py[1], px[0], px[1], grid._mesh, np.einsum("ij,ji->i", i_u.phi2D_lin(0.0, xsi), py) + ) + c2 = i_u._geodetic_distance( + py[1], py[2], px[1], px[2], grid._mesh, np.einsum("ij,ji->i", i_u.phi2D_lin(eta, 1.0), py) + ) + c3 = i_u._geodetic_distance( + py[2], py[3], px[2], px[3], grid._mesh, np.einsum("ij,ji->i", i_u.phi2D_lin(1.0, xsi), py) + ) + c4 = i_u._geodetic_distance( + py[3], py[0], px[3], px[0], grid._mesh, np.einsum("ij,ji->i", i_u.phi2D_lin(eta, 0.0), py) + ) + + lenT = 2 if np.any(tau > 0) else 1 + + # Create arrays of corner points for xarray.isel + # TODO C grid may not need all xi and yi cornerpoints, so could speed up here? + + # Time coordinates: 4 points at ti, then 4 points at ti+1 + if lenT == 1: + ti_full = np.repeat(ti, 4) + else: + ti_1 = np.clip(ti + 1, 0, tdim - 1) + ti_full = np.concatenate([np.repeat(ti, 4), np.repeat(ti_1, 4)]) + + # Depth coordinates: 4 points at zi, repeated for both time levels + zi_full = np.repeat(zi, lenT * 4) + + # Y coordinates: [yi, yi, yi+1, yi+1] for each spatial point, repeated for time/depth + yi_1 = np.clip(yi + 1, 0, ydim - 1) + yi_full = np.tile(np.repeat(np.column_stack([yi, yi_1]), 2), (lenT)) + # # TODO check why in some cases minus needed here!!! + # yi_minus_1 = np.clip(yi - 1, 0, ydim - 1) + # yi = np.tile(np.repeat(np.column_stack([yi_minus_1, yi]), 2), (lenT)) + + # X coordinates: [xi, xi+1, xi, xi+1] for each spatial point, repeated for time/depth + xi_1 = np.clip(xi + 1, 0, xdim - 1) + xi_full = np.tile(np.column_stack([xi, xi_1, xi, xi_1]).flatten(), (lenT)) + + for data in [U, V]: + axis_dim = grid.get_axis_dim_mapping(data.dims) + + # Create DataArrays for indexing + selection_dict = { + axis_dim["X"]: xr.DataArray(xi_full, dims=("points")), + axis_dim["Y"]: xr.DataArray(yi_full, dims=("points")), + } + if "Z" in axis_dim: + selection_dict[axis_dim["Z"]] = xr.DataArray(zi_full, dims=("points")) + if "time" in data.dims: + selection_dict["time"] = xr.DataArray(ti_full, dims=("points")) + + corner_data = data.isel(selection_dict).data.reshape(lenT, len(xsi), 4) + + if lenT == 2: + tau_full = tau[:, np.newaxis] + corner_data = corner_data[0, :, :] * (1 - tau_full) + corner_data[1, :, :] * tau_full + else: + corner_data = corner_data[0, :, :] + # # See code below for v3 version + # # if self.gridindexingtype == "nemo": + # # U0 = self.U.data[ti, zi, yi + 1, xi] * c4 + # # U1 = self.U.data[ti, zi, yi + 1, xi + 1] * c2 + # # V0 = self.V.data[ti, zi, yi, xi + 1] * c1 + # # V1 = self.V.data[ti, zi, yi + 1, xi + 1] * c3 + # # elif self.gridindexingtype in ["mitgcm", "croco"]: + # # U0 = self.U.data[ti, zi, yi, xi] * c4 + # # U1 = self.U.data[ti, zi, yi, xi + 1] * c2 + # # V0 = self.V.data[ti, zi, yi, xi] * c1 + # # V1 = self.V.data[ti, zi, yi + 1, xi] * c3 + # # TODO Nick can you help use xgcm to fix this implementation? + + # # CROCO and MITgcm grid indexing, + # if data is U: + # U0 = corner_data[:, 0] * c4 + # U1 = corner_data[:, 1] * c2 + # elif data is V: + # V0 = corner_data[:, 0] * c1 + # V1 = corner_data[:, 2] * c3 + # # NEMO grid indexing + if data is U: + U0 = corner_data[:, 2] * c4 + U1 = corner_data[:, 3] * c2 + elif data is V: + V0 = corner_data[:, 1] * c1 + V1 = corner_data[:, 3] * c3 + + U = (1 - xsi) * U0 + xsi * U1 + V = (1 - eta) * V0 + eta * V1 + + deg2m = 1852 * 60.0 + if applyConversion: + meshJac = (deg2m * deg2m * np.cos(np.deg2rad(y))) if grid._mesh == "spherical" else 1 + else: + meshJac = deg2m if grid._mesh == "spherical" else 1 + + jac = i_u._compute_jacobian_determinant(py, px, eta, xsi) * meshJac + + u = ( + (-(1 - eta) * U - (1 - xsi) * V) * px[0] + + ((1 - eta) * U - xsi * V) * px[1] + + (eta * U + xsi * V) * px[2] + + (-eta * U + (1 - xsi) * V) * px[3] + ) / jac + v = ( + (-(1 - eta) * U - (1 - xsi) * V) * py[0] + + ((1 - eta) * U - xsi * V) * py[1] + + (eta * U + xsi * V) * py[2] + + (-eta * U + (1 - xsi) * V) * py[3] + ) / jac + if is_dask_collection(u): + u = u.compute() + v = v.compute() + + # check whether the grid conversion has been applied correctly + xx = (1 - xsi) * (1 - eta) * px[0] + xsi * (1 - eta) * px[1] + xsi * eta * px[2] + (1 - xsi) * eta * px[3] + u = np.where(np.abs((xx - x) / x) > 1e-4, np.nan, u) + + if vectorfield.W: + data = vectorfield.W.data + # Time coordinates: 2 points at ti, then 2 points at ti+1 + if lenT == 1: + ti_full = np.repeat(ti, 2) + else: + ti_1 = np.clip(ti + 1, 0, tdim - 1) + ti_full = np.concatenate([np.repeat(ti, 2), np.repeat(ti_1, 2)]) + + # Depth coordinates: 1 points at zi, repeated for both time levels + zi_1 = np.clip(zi + 1, 0, zdim - 1) + zi_full = np.tile(np.array([zi, zi_1]).flatten(), lenT) + + # Y coordinates: yi+1 for each spatial point, repeated for time/depth + yi_1 = np.clip(yi + 1, 0, ydim - 1) + yi_full = np.tile(yi_1, (lenT) * 2) + + # X coordinates: xi+1 for each spatial point, repeated for time/depth + xi_1 = np.clip(xi + 1, 0, xdim - 1) + xi_full = np.tile(xi_1, (lenT) * 2) + + axis_dim = grid.get_axis_dim_mapping(data.dims) + + # Create DataArrays for indexing + selection_dict = { + axis_dim["X"]: xr.DataArray(xi_full, dims=("points")), + axis_dim["Y"]: xr.DataArray(yi_full, dims=("points")), + axis_dim["Z"]: xr.DataArray(zi_full, dims=("points")), + } + if "time" in data.dims: + selection_dict["time"] = xr.DataArray(ti_full, dims=("points")) + + corner_data = data.isel(selection_dict).data.reshape(lenT, 2, len(xsi)) + + if lenT == 2: + tau_full = tau[np.newaxis, :] + corner_data = corner_data[0, :, :] * (1 - tau_full) + corner_data[1, :, :] * tau_full + else: + corner_data = corner_data[0, :, :] + + w = corner_data[0, :] * (1 - zeta) + corner_data[1, :] * zeta + if is_dask_collection(w): + w = w.compute() + else: + w = np.zeros_like(u) + + return (u, v, w) + + +def CGrid_Tracer( + field: Field, + ti: int, + position: dict[_XGRID_AXES, tuple[int, float | np.ndarray]], + tau: np.float32 | np.float64, + t: np.float32 | np.float64, + z: np.float32 | np.float64, + y: np.float32 | np.float64, + x: np.float32 | np.float64, +): + """Interpolation kernel for tracer fields on a C-Grid. + + Following Delandmeter and Van Sebille (2019), tracer fields should be interpolated + constant over the grid cell + """ + xi, _ = position["X"] + yi, _ = position["Y"] + zi, _ = position["Z"] + + axis_dim = field.grid.get_axis_dim_mapping(field.data.dims) + data = field.data + + lenT = 2 if np.any(tau > 0) else 1 + + if lenT == 2: + ti_1 = np.clip(ti + 1, 0, data.shape[0] - 1) + ti = np.concatenate([np.repeat(ti), np.repeat(ti_1)]) + zi_1 = np.clip(zi + 1, 0, data.shape[1] - 1) + zi = np.concatenate([np.repeat(zi), np.repeat(zi_1)]) + yi_1 = np.clip(yi + 1, 0, data.shape[2] - 1) + yi = np.concatenate([np.repeat(yi), np.repeat(yi_1)]) + xi_1 = np.clip(xi + 1, 0, data.shape[3] - 1) + xi = np.concatenate([np.repeat(xi), np.repeat(xi_1)]) + + # Create DataArrays for indexing + selection_dict = { + axis_dim["X"]: xr.DataArray(xi, dims=("points")), + axis_dim["Y"]: xr.DataArray(yi, dims=("points")), + } + if "Z" in axis_dim: + selection_dict[axis_dim["Z"]] = xr.DataArray(zi, dims=("points")) + if "time" in field.data.dims: + selection_dict["time"] = xr.DataArray(ti, dims=("points")) + + value = data.isel(selection_dict).data.reshape(lenT, len(xi)) + + if lenT == 2: + tau = tau[:, np.newaxis] + value = value[0, :] * (1 - tau) + value[1, :] * tau + else: + value = value[0, :] + + return value.compute() if is_dask_collection(value) else value + + +def _Spatialslip( + vectorfield: VectorField, + ti: int, + position: dict[_XGRID_AXES, tuple[int, float | np.ndarray]], + tau: np.float32 | np.float64, + t: np.float32 | np.float64, + z: np.float32 | np.float64, + y: np.float32 | np.float64, + x: np.float32 | np.float64, + a: np.float32, + b: np.float32, +): + """Helper function for spatial boundary condition interpolation for velocity fields.""" + xi, xsi = position["X"] + yi, eta = position["Y"] + zi, zeta = position["Z"] + + axis_dim = vectorfield.U.grid.get_axis_dim_mapping(vectorfield.U.data.dims) + lenT = 2 if np.any(tau > 0) else 1 + lenZ = 2 if np.any(zeta > 0) else 1 + npart = len(xsi) + + u = XLinear(vectorfield.U, ti, position, tau, t, z, y, x) + v = XLinear(vectorfield.V, ti, position, tau, t, z, y, x) + if vectorfield.W: + w = XLinear(vectorfield.W, ti, position, tau, t, z, y, x) + + corner_dataU = _get_corner_data_Agrid(vectorfield.U.data, ti, zi, yi, xi, lenT, lenZ, npart, axis_dim) + corner_dataV = _get_corner_data_Agrid(vectorfield.V.data, ti, zi, yi, xi, lenT, lenZ, npart, axis_dim) + + def is_land(ti: int, zi: int, yi: int, xi: int): + uval = corner_dataU[ti, zi, :, xi + 2 * yi] + vval = corner_dataV[ti, zi, :, xi + 2 * yi] + return np.where(np.isclose(uval, 0.0) & np.isclose(vval, 0.0), True, False) + + f_u = np.ones_like(xsi) + f_v = np.ones_like(eta) + + if lenZ == 1: + f_u = np.where(is_land(0, 0, 0, 0) & is_land(0, 0, 0, 1) & (eta > 0), f_u * (a + b * eta) / eta, f_u) + f_u = np.where(is_land(0, 0, 1, 0) & is_land(0, 0, 1, 1) & (eta < 1), f_u * (1 - b * eta) / (1 - eta), f_u) + f_v = np.where(is_land(0, 0, 0, 0) & is_land(0, 0, 1, 0) & (xsi > 0), f_v * (a + b * xsi) / xsi, f_v) + f_v = np.where(is_land(0, 0, 0, 1) & is_land(0, 0, 1, 1) & (xsi < 1), f_v * (1 - b * xsi) / (1 - xsi), f_v) + else: + f_u = np.where( + is_land(0, 0, 0, 0) & is_land(0, 0, 0, 1) & is_land(0, 1, 0, 0) & is_land(0, 1, 0, 1) & (eta > 0), + f_u * (a + b * eta) / eta, + f_u, + ) + f_u = np.where( + is_land(0, 0, 1, 0) & is_land(0, 0, 1, 1) & is_land(0, 1, 1, 0) & is_land(0, 1, 1, 1) & (eta < 1), + f_u * (1 - b * eta) / (1 - eta), + f_u, + ) + f_v = np.where( + is_land(0, 0, 0, 0) & is_land(0, 0, 1, 0) & is_land(0, 1, 0, 0) & is_land(0, 1, 1, 0) & (xsi > 0), + f_v * (a + b * xsi) / xsi, + f_v, + ) + f_v = np.where( + is_land(0, 0, 0, 1) & is_land(0, 0, 1, 1) & is_land(0, 1, 0, 1) & is_land(0, 1, 1, 1) & (xsi < 1), + f_v * (1 - b * xsi) / (1 - xsi), + f_v, + ) + f_u = np.where( + is_land(0, 0, 0, 0) & is_land(0, 0, 0, 1) & is_land(0, 0, 1, 0 & is_land(0, 0, 1, 1) & (zeta > 0)), + f_u * (a + b * zeta) / zeta, + f_u, + ) + f_u = np.where( + is_land(0, 1, 0, 0) & is_land(0, 1, 0, 1) & is_land(0, 1, 1, 0 & is_land(0, 1, 1, 1) & (zeta < 1)), + f_u * (1 - b * zeta) / (1 - zeta), + f_u, + ) + f_v = np.where( + is_land(0, 0, 0, 0) & is_land(0, 0, 0, 1) & is_land(0, 0, 1, 0 & is_land(0, 0, 1, 1) & (zeta > 0)), + f_v * (a + b * zeta) / zeta, + f_v, + ) + f_v = np.where( + is_land(0, 1, 0, 0) & is_land(0, 1, 0, 1) & is_land(0, 1, 1, 0 & is_land(0, 1, 1, 1) & (zeta < 1)), + f_v * (1 - b * zeta) / (1 - zeta), + f_v, + ) + + u *= f_u + v *= f_v + if vectorfield.W: + f_w = np.ones_like(zeta) + f_w = np.where( + is_land(0, 0, 0, 0) & is_land(0, 0, 0, 1) & is_land(0, 1, 0, 0) & is_land(0, 1, 0, 1) & (eta > 0), + f_w * (a + b * eta) / eta, + f_w, + ) + f_w = np.where( + is_land(0, 0, 1, 0) & is_land(0, 0, 1, 1) & is_land(0, 1, 1, 0) & is_land(0, 1, 1, 1) & (eta < 1), + f_w * (a - b * eta) / (1 - eta), + f_w, + ) + f_w = np.where( + is_land(0, 0, 0, 0) & is_land(0, 0, 1, 0) & is_land(0, 1, 0, 0) & is_land(0, 1, 1, 0) & (xsi > 0), + f_w * (a + b * xsi) / xsi, + f_w, + ) + f_w = np.where( + is_land(0, 0, 0, 1) & is_land(0, 0, 1, 1) & is_land(0, 1, 0, 1) & is_land(0, 1, 1, 1) & (xsi < 1), + f_w * (a - b * xsi) / (1 - xsi), + f_w, + ) + + w *= f_w + else: + w = None + return u, v, w + + +def XFreeslip( + vectorfield: VectorField, + ti: int, + position: dict[_XGRID_AXES, tuple[int, float | np.ndarray]], + tau: np.float32 | np.float64, + t: np.float32 | np.float64, + z: np.float32 | np.float64, + y: np.float32 | np.float64, + x: np.float32 | np.float64, + applyConversion: bool, +): + """Free-slip boundary condition interpolation for velocity fields.""" + return _Spatialslip(vectorfield, ti, position, tau, t, z, y, x, a=1.0, b=0.0) + + +def XPartialslip( + vectorfield: VectorField, + ti: int, + position: dict[_XGRID_AXES, tuple[int, float | np.ndarray]], + tau: np.float32 | np.float64, + t: np.float32 | np.float64, + z: np.float32 | np.float64, + y: np.float32 | np.float64, + x: np.float32 | np.float64, + applyConversion: bool, +): + """Partial-slip boundary condition interpolation for velocity fields.""" + return _Spatialslip(vectorfield, ti, position, tau, t, z, y, x, a=0.5, b=0.5) + + +def XNearest( + field: Field, + ti: int, + position: dict[_XGRID_AXES, tuple[int, float | np.ndarray]], + tau: np.float32 | np.float64, + t: np.float32 | np.float64, + z: np.float32 | np.float64, + y: np.float32 | np.float64, + x: np.float32 | np.float64, +): + """ + Nearest-Neighbour spatial interpolation on a regular grid. + Note that this still uses linear interpolation in time. + """ + xi, xsi = position["X"] + yi, eta = position["Y"] + zi, zeta = position["Z"] + + axis_dim = field.grid.get_axis_dim_mapping(field.data.dims) + data = field.data + + lenT = 2 if np.any(tau > 0) else 1 + + # Spatial coordinates: left if barycentric < 0.5, otherwise right + zi_1 = np.clip(zi + 1, 0, data.shape[1] - 1) + zi_full = np.where(zeta < 0.5, zi, zi_1) + + yi_1 = np.clip(yi + 1, 0, data.shape[2] - 1) + yi_full = np.where(eta < 0.5, yi, yi_1) + + xi_1 = np.clip(xi + 1, 0, data.shape[3] - 1) + xi_full = np.where(xsi < 0.5, xi, xi_1) + + # Time coordinates: 1 point at ti, then 1 point at ti+1 + if lenT == 1: + ti_full = ti + else: + ti_1 = np.clip(ti + 1, 0, data.shape[0] - 1) + ti_full = np.concatenate([ti, ti_1]) + xi_full = np.repeat(xi_full, 2) + yi_full = np.repeat(yi_full, 2) + zi_full = np.repeat(zi_full, 2) + + # Create DataArrays for indexing + selection_dict = { + axis_dim["X"]: xr.DataArray(xi_full, dims=("points")), + axis_dim["Y"]: xr.DataArray(yi_full, dims=("points")), + } + if "Z" in axis_dim: + selection_dict[axis_dim["Z"]] = xr.DataArray(zi_full, dims=("points")) + if "time" in data.dims: + selection_dict["time"] = xr.DataArray(ti_full, dims=("points")) + + corner_data = data.isel(selection_dict).data.reshape(lenT, len(xsi)) + + if lenT == 2: + value = corner_data[0, :] * (1 - tau) + corner_data[1, :] * tau + else: + value = corner_data[0, :] + + return value.compute() if is_dask_collection(value) else value + + +def UXPiecewiseConstantFace( + field: Field, + ti: int, + position: dict[_UXGRID_AXES, tuple[int, float | np.ndarray]], + tau: np.float32 | np.float64, + t: np.float32 | np.float64, + z: np.float32 | np.float64, + y: np.float32 | np.float64, + x: np.float32 | np.float64, +): + """ + Piecewise constant interpolation kernel for face registered data. + This interpolation method is appropriate for fields that are + face registered, such as u,v in FESOM. + """ + return field.data.values[ti, position["Z"][0], position["FACE"][0]] + + +def UXPiecewiseLinearNode( + field: Field, + ti: int, + position: dict[_UXGRID_AXES, tuple[int, float | np.ndarray]], + tau: np.float32 | np.float64, + t: np.float32 | np.float64, + z: np.float32 | np.float64, + y: np.float32 | np.float64, + x: np.float32 | np.float64, +): + """ + Piecewise linear interpolation kernel for node registered data located at vertical interface levels. + This interpolation method is appropriate for fields that are node registered such as the vertical + velocity W in FESOM2. Effectively, it applies barycentric interpolation in the lateral direction + and piecewise linear interpolation in the vertical direction. + """ + k, fi = position["Z"][0], position["FACE"][0] + bcoords = position["FACE"][1] + node_ids = field.grid.uxgrid.face_node_connectivity[fi, :] + # The zi refers to the vertical layer index. The field in this routine are assumed to be defined at the vertical interface levels. + # For interface zi, the interface indices are [zi, zi+1], so we need to use the values at zi and zi+1. + # First, do barycentric interpolation in the lateral direction for each interface level + fzk = np.sum(field.data.values[ti, k, node_ids] * bcoords, axis=-1) + fzkp1 = np.sum(field.data.values[ti, k + 1, node_ids] * bcoords, axis=-1) + + # Then, do piecewise linear interpolation in the vertical direction + zk = field.grid.z.values[k] + zkp1 = field.grid.z.values[k + 1] + return (fzk * (zkp1 - z) + fzkp1 * (z - zk)) / (zkp1 - zk) # Linear interpolation in the vertical direction diff --git a/parcels/kernel.py b/parcels/kernel.py deleted file mode 100644 index 9b1c5035c..000000000 --- a/parcels/kernel.py +++ /dev/null @@ -1,711 +0,0 @@ -import _ctypes -import abc -import ast -import functools -import hashlib -import inspect -import math # noqa: F401 -import os -import random # noqa: F401 -import shutil -import sys -import textwrap -import types -import warnings -from copy import deepcopy -from ctypes import byref, c_double, c_int -from time import time as ostime - -import numpy as np -import numpy.ctypeslib as npct - -import parcels.rng as ParcelsRandom # noqa: F401 -from parcels import rng # noqa: F401 -from parcels._compat import MPI -from parcels.application_kernels.advection import ( - AdvectionAnalytical, - AdvectionRK4_3D, - AdvectionRK4_3D_CROCO, - AdvectionRK45, -) -from parcels.compilation.codegenerator import KernelGenerator, LoopGenerator -from parcels.field import Field, NestedField, VectorField -from parcels.grid import GridType -from parcels.tools.global_statics import get_cache_dir -from parcels.tools.loggers import logger -from parcels.tools.statuscodes import ( - StatusCode, - TimeExtrapolationError, - _raise_field_out_of_bound_error, - _raise_field_out_of_bound_surface_error, - _raise_field_sampling_error, -) -from parcels.tools.warnings import KernelWarning - -__all__ = ["BaseKernel", "Kernel"] - - -class BaseKernel(abc.ABC): - """Superclass for 'normal' and Interactive Kernels""" - - def __init__( - self, - fieldset, - ptype, - pyfunc=None, - funcname=None, - funccode=None, - py_ast=None, - funcvars=None, - c_include="", - delete_cfiles=True, - ): - self._fieldset = fieldset - self.field_args = None - self.const_args = None - self._ptype = ptype - self._lib = None - self.delete_cfiles = delete_cfiles - self._c_include = c_include - - # Derive meta information from pyfunc, if not given - self._pyfunc = None - self.funcname = funcname or pyfunc.__name__ - self.name = f"{ptype.name}{self.funcname}" - self.ccode = "" - self.funcvars = funcvars - self.funccode = funccode - self.py_ast = py_ast - self.src_file: str | None = None - self.lib_file: str | None = None - self.log_file: str | None = None - self.scipy_positionupdate_kernels_added = False - - # Generate the kernel function and add the outer loop - if self._ptype.uses_jit: - self.src_file, self.lib_file, self.log_file = self.get_kernel_compile_files() - - def __del__(self): - # Clean-up the in-memory dynamic linked libraries. - # This is not really necessary, as these programs are not that large, but with the new random - # naming scheme which is required on Windows OS'es to deal with updates to a Parcels' kernel. - try: - self.remove_lib() - except: - pass - self._fieldset = None - self.field_args = None - self.const_args = None - self.funcvars = None - self.funccode = None - - @property - def ptype(self): - return self._ptype - - @property - def pyfunc(self): - return self._pyfunc - - @property - def fieldset(self): - return self._fieldset - - @property - def c_include(self): - return self._c_include - - @property - def _cache_key(self): - field_keys = "" - if self.field_args is not None: - field_keys = "-".join( - [f"{name}:{field.units.__class__.__name__}" for name, field in self.field_args.items()] - ) - key = self.name + self.ptype._cache_key + field_keys + (f"TIME:{ostime():f}") - return hashlib.md5(key.encode("utf-8")).hexdigest() - - def remove_deleted(self, pset): - """Utility to remove all particles that signalled deletion.""" - bool_indices = pset.particledata.state == StatusCode.Delete - indices = np.where(bool_indices)[0] - if len(indices) > 0 and self.fieldset.particlefile is not None: - self.fieldset.particlefile.write(pset, None, indices=indices) - pset.remove_indices(indices) - - @abc.abstractmethod - def get_kernel_compile_files(self) -> tuple[str, str, str]: ... - - @abc.abstractmethod - def remove_lib(self) -> None: ... - - -class Kernel(BaseKernel): - """Kernel object that encapsulates auto-generated code. - - Parameters - ---------- - fieldset : parcels.Fieldset - FieldSet object providing the field information (possibly None) - ptype : - PType object for the kernel particle - pyfunc : - (aggregated) Kernel function - funcname : str - function name - delete_cfiles : bool - Whether to delete the C-files after compilation in JIT mode (default is True) - - Notes - ----- - A Kernel is either created from a compiled object - or the necessary information (funcname, funccode, funcvars) is provided. - The py_ast argument may be derived from the code string, but for - concatenation, the merged AST plus the new header definition is required. - """ - - def __init__( - self, - fieldset, - ptype, - pyfunc=None, - funcname=None, - funccode=None, - py_ast=None, - funcvars=None, - c_include="", - delete_cfiles=True, - ): - super().__init__( - fieldset=fieldset, - ptype=ptype, - pyfunc=pyfunc, - funcname=funcname, - funccode=funccode, - py_ast=py_ast, - funcvars=funcvars, - c_include=c_include, - delete_cfiles=delete_cfiles, - ) - - # Derive meta information from pyfunc, if not given - self.check_fieldsets_in_kernels(pyfunc) - - if (pyfunc is AdvectionRK4_3D) and fieldset.U.gridindexingtype == "croco": - pyfunc = AdvectionRK4_3D_CROCO - self.funcname = "AdvectionRK4_3D_CROCO" - - if funcvars is not None: - self.funcvars = funcvars - elif hasattr(pyfunc, "__code__"): - self.funcvars = list(pyfunc.__code__.co_varnames) - else: - self.funcvars = None - self.funccode = funccode or inspect.getsource(pyfunc.__code__) - self.funccode = ( # Remove parcels. prefix (see #1608) - self.funccode.replace("parcels.rng", "rng") - .replace("parcels.ParcelsRandom", "ParcelsRandom") - .replace("parcels.StatusCode", "StatusCode") - ) - - # Parse AST if it is not provided explicitly - self.py_ast = ( - py_ast or ast.parse(textwrap.dedent(self.funccode)).body[0] - ) # Dedent allows for in-lined kernel definitions - if pyfunc is None: - # Extract user context by inspecting the call stack - stack = inspect.stack() - try: - user_ctx = stack[-1][0].f_globals - user_ctx["math"] = globals()["math"] - user_ctx["ParcelsRandom"] = globals()["ParcelsRandom"] - user_ctx["rng"] = globals()["rng"] - user_ctx["random"] = globals()["random"] - user_ctx["StatusCode"] = globals()["StatusCode"] - except: - warnings.warn( - "Could not access user context when merging kernels", - KernelWarning, - stacklevel=2, - ) - user_ctx = globals() - finally: - del stack # Remove cyclic references - # Compile and generate Python function from AST - py_mod = ast.parse("") - py_mod.body = [self.py_ast] - exec(compile(py_mod, "", "exec"), user_ctx) - self._pyfunc = user_ctx[self.funcname] - else: - self._pyfunc = pyfunc - - numkernelargs = self.check_kernel_signature_on_version() - - if numkernelargs != 3: - raise ValueError( - "Since Parcels v2.0, kernels do only take 3 arguments: particle, fieldset, time !! AND !! Argument order in field interpolation is time, depth, lat, lon." - ) - - self.name = f"{ptype.name}{self.funcname}" - - # Generate the kernel function and add the outer loop - if self.ptype.uses_jit: - kernelgen = KernelGenerator(fieldset, ptype) - kernel_ccode = kernelgen.generate(deepcopy(self.py_ast), self.funcvars) - self.field_args = kernelgen.field_args - self.vector_field_args = kernelgen.vector_field_args - fieldset = self.fieldset - for f in self.vector_field_args.values(): - Wname = f.W.ccode_name if f.W else "not_defined" - for sF_name, sF_component in zip([f.U.ccode_name, f.V.ccode_name, Wname], ["U", "V", "W"], strict=True): - if sF_name not in self.field_args: - if sF_name != "not_defined": - self.field_args[sF_name] = getattr(f, sF_component) - self.const_args = kernelgen.const_args - loopgen = LoopGenerator(fieldset, ptype) - if os.path.isfile(self._c_include): - with open(self._c_include) as f: - c_include_str = f.read() - else: - c_include_str = self._c_include - self.ccode = loopgen.generate(self.funcname, self.field_args, self.const_args, kernel_ccode, c_include_str) - - self.src_file, self.lib_file, self.log_file = self.get_kernel_compile_files() - - @property - def ptype(self): - return self._ptype - - @property - def pyfunc(self): - return self._pyfunc - - @property - def fieldset(self): - return self._fieldset - - @property - def c_include(self): - return self._c_include - - @property - def _cache_key(self): - field_keys = "" - if self.field_args is not None: - field_keys = "-".join( - [f"{name}:{field.units.__class__.__name__}" for name, field in self.field_args.items()] - ) - key = self.name + self.ptype._cache_key + field_keys + (f"TIME:{ostime():f}") - return hashlib.md5(key.encode("utf-8")).hexdigest() - - def add_scipy_positionupdate_kernels(self): - # Adding kernels that set and update the coordinate changes - def Setcoords(particle, fieldset, time): # pragma: no cover - particle_dlon = 0 # noqa - particle_dlat = 0 # noqa - particle_ddepth = 0 # noqa - particle.lon = particle.lon_nextloop - particle.lat = particle.lat_nextloop - particle.depth = particle.depth_nextloop - particle.time = particle.time_nextloop - - def Updatecoords(particle, fieldset, time): # pragma: no cover - particle.lon_nextloop = particle.lon + particle_dlon # type: ignore[name-defined] # noqa - particle.lat_nextloop = particle.lat + particle_dlat # type: ignore[name-defined] # noqa - particle.depth_nextloop = particle.depth + particle_ddepth # type: ignore[name-defined] # noqa - particle.time_nextloop = particle.time + particle.dt - - self._pyfunc = (Setcoords + self + Updatecoords)._pyfunc - - def check_fieldsets_in_kernels(self, pyfunc): - """ - Checks the integrity of the fieldset with the kernels. - - This function is to be called from the derived class when setting up the 'pyfunc'. - """ - if self.fieldset is not None: - if pyfunc is AdvectionRK4_3D: - warning = False - if ( - isinstance(self._fieldset.W, Field) - and self._fieldset.W._creation_log != "from_nemo" - and self._fieldset.W._scaling_factor is not None - and self._fieldset.W._scaling_factor > 0 - ): - warning = True - if isinstance(self._fieldset.W, NestedField): - for f in self._fieldset.W: - if f._creation_log != "from_nemo" and f._scaling_factor is not None and f._scaling_factor > 0: - warning = True - if warning: - warnings.warn( - "Note that in AdvectionRK4_3D, vertical velocity is assumed positive towards increasing z. " - "If z increases downward and w is positive upward you can re-orient it downwards by setting fieldset.W.set_scaling_factor(-1.)", - KernelWarning, - stacklevel=2, - ) - elif pyfunc is AdvectionAnalytical: - if self.fieldset.particlefile is not None: - self.fieldset.particlefile._is_analytical = True - if self._ptype.uses_jit: - raise NotImplementedError("Analytical Advection only works in Scipy mode") - if self._fieldset.U.interp_method != "cgrid_velocity": - raise NotImplementedError("Analytical Advection only works with C-grids") - if self._fieldset.U.grid._gtype not in [GridType.CurvilinearZGrid, GridType.RectilinearZGrid]: - raise NotImplementedError("Analytical Advection only works with Z-grids in the vertical") - elif pyfunc is AdvectionRK45: - if not hasattr(self.fieldset, "RK45_tol"): - warnings.warn( - "Setting RK45 tolerance to 10 m. Use fieldset.add_constant('RK45_tol', [distance]) to change.", - KernelWarning, - stacklevel=2, - ) - self.fieldset.add_constant("RK45_tol", 10) - if self.fieldset.U.grid.mesh == "spherical": - self.fieldset.RK45_tol /= ( - 1852 * 60 - ) # TODO does not account for zonal variation in meter -> degree conversion - if not hasattr(self.fieldset, "RK45_min_dt"): - warnings.warn( - "Setting RK45 minimum timestep to 1 s. Use fieldset.add_constant('RK45_min_dt', [timestep]) to change.", - KernelWarning, - stacklevel=2, - ) - self.fieldset.add_constant("RK45_min_dt", 1) - if not hasattr(self.fieldset, "RK45_max_dt"): - warnings.warn( - "Setting RK45 maximum timestep to 1 day. Use fieldset.add_constant('RK45_max_dt', [timestep]) to change.", - KernelWarning, - stacklevel=2, - ) - self.fieldset.add_constant("RK45_max_dt", 60 * 60 * 24) - - def check_kernel_signature_on_version(self): - """Returns number of arguments in a Python function.""" - if self._pyfunc is None: - return 0 - return len(inspect.getfullargspec(self._pyfunc).args) - - def remove_lib(self): - if self._lib is not None: - self.cleanup_unload_lib(self._lib) - del self._lib - self._lib = None - - all_files: list[str] = [] - if self.src_file is not None: - all_files.append(self.src_file) - if self.log_file is not None: - all_files.append(self.log_file) - if self.lib_file is not None: - self.cleanup_remove_files(self.lib_file, all_files, self.delete_cfiles) - - # If file already exists, pull new names. This is necessary on a Windows machine, because - # Python's ctype does not deal in any sort of manner well with dynamic linked libraries on this OS. - if self._ptype.uses_jit: - self.src_file, self.lib_file, self.log_file = self.get_kernel_compile_files() - - def get_kernel_compile_files(self): - """Returns the correct src_file, lib_file, log_file for this kernel.""" - basename: str - if MPI: - mpi_comm = MPI.COMM_WORLD - mpi_rank = mpi_comm.Get_rank() - cache_name = ( - self._cache_key - ) # only required here because loading is done by Kernel class instead of Compiler class - dyn_dir = get_cache_dir() if mpi_rank == 0 else None - dyn_dir = mpi_comm.bcast(dyn_dir, root=0) - basename = cache_name if mpi_rank == 0 else None - basename = mpi_comm.bcast(basename, root=0) - basename = f"{basename}_{mpi_rank}" - else: - cache_name = ( - self._cache_key - ) # only required here because loading is done by Kernel class instead of Compiler class - dyn_dir = get_cache_dir() - basename = f"{cache_name}_0" - lib_path = "lib" + basename - - assert isinstance(basename, str) - - src_file = f"{os.path.join(dyn_dir, basename)}.c" - lib_file = f"{os.path.join(dyn_dir, lib_path)}.{'dll' if sys.platform == 'win32' else 'so'}" - log_file = f"{os.path.join(dyn_dir, basename)}.log" - return src_file, lib_file, log_file - - def compile(self, compiler): - """Writes kernel code to file and compiles it.""" - if self.src_file is None: - return - - with open(self.src_file, "w") as f: - f.write(self.ccode) - - compiler.compile(self.src_file, self.lib_file, self.log_file) - - if self.delete_cfiles is False: - logger.info(f"Compiled {self.name} ==> {self.src_file}") - - def load_lib(self): - self._lib = npct.load_library(self.lib_file, ".") - self._function = self._lib.particle_loop - - def merge(self, kernel, kclass): - funcname = self.funcname + kernel.funcname - func_ast = None - if self.py_ast is not None: - func_ast = ast.FunctionDef( - name=funcname, - args=self.py_ast.args, - body=self.py_ast.body + kernel.py_ast.body, - decorator_list=[], - lineno=1, - col_offset=0, - ) - delete_cfiles = self.delete_cfiles and kernel.delete_cfiles - return kclass( - self.fieldset, - self.ptype, - pyfunc=None, - funcname=funcname, - funccode=self.funccode + kernel.funccode, - py_ast=func_ast, - funcvars=self.funcvars + kernel.funcvars, - c_include=self._c_include + kernel.c_include, - delete_cfiles=delete_cfiles, - ) - - def __add__(self, kernel): - if not isinstance(kernel, type(self)): - kernel = type(self)(self.fieldset, self.ptype, pyfunc=kernel) - return self.merge(kernel, type(self)) - - def __radd__(self, kernel): - if not isinstance(kernel, type(self)): - kernel = type(self)(self.fieldset, self.ptype, pyfunc=kernel) - return kernel.merge(self, type(self)) - - @classmethod - def from_list(cls, fieldset, ptype, pyfunc_list, *args, **kwargs): - """Create a combined kernel from a list of functions. - - Takes a list of functions, converts them to kernels, and joins them - together. - - Parameters - ---------- - fieldset : parcels.Fieldset - FieldSet object providing the field information (possibly None) - ptype : - PType object for the kernel particle - pyfunc_list : list of functions - List of functions to be combined into a single kernel. - *args : - Additional arguments passed to first kernel during construction. - **kwargs : - Additional keyword arguments passed to first kernel during construction. - """ - if not isinstance(pyfunc_list, list): - raise TypeError(f"Argument function_list should be a list of functions. Got {type(pyfunc_list)}") - if len(pyfunc_list) == 0: - raise ValueError("Argument function_list should have at least one function.") - if not all([isinstance(f, types.FunctionType) for f in pyfunc_list]): - raise ValueError("Argument function_lst should be a list of functions.") - - pyfunc_list = pyfunc_list.copy() - pyfunc_list[0] = cls(fieldset, ptype, pyfunc_list[0], *args, **kwargs) - return functools.reduce(lambda x, y: x + y, pyfunc_list) - - @staticmethod - def cleanup_remove_files(lib_file: str | None, all_files: list[str], delete_cfiles: bool) -> None: - if lib_file is None: - return - - # Remove compiled files - if os.path.isfile(lib_file): - os.remove(lib_file) - - macos_debugging_files = f"{lib_file}.dSYM" - if os.path.isdir(macos_debugging_files): - shutil.rmtree(macos_debugging_files) - - if delete_cfiles: - for s in all_files: - if os.path.exists(s): - os.remove(s) - - @staticmethod - def cleanup_unload_lib(lib): - # Clean-up the in-memory dynamic linked libraries. - # This is not really necessary, as these programs are not that large, but with the new random - # naming scheme which is required on Windows OS'es to deal with updates to a Parcels' kernel. - if lib is not None: - try: - _ctypes.FreeLibrary(lib._handle) if sys.platform == "win32" else _ctypes.dlclose(lib._handle) - except: - pass - - def load_fieldset_jit(self, pset): - """Updates the loaded fields of pset's fieldset according to the chunk information within their grids.""" - if pset.fieldset is not None: - for g in pset.fieldset.gridset.grids: - g._cstruct = None # This force to point newly the grids from Python to C - # Make a copy of the transposed array to enforce - # C-contiguous memory layout for JIT mode. - for f in pset.fieldset.get_fields(): - if isinstance(f, (VectorField, NestedField)): - continue - if f.data.dtype != np.float32: - raise RuntimeError(f"Field {f.name} data needs to be float32 in JIT mode") - if f in self.field_args.values(): - f._chunk_data() - else: - for block_id in range(len(f._data_chunks)): - f._data_chunks[block_id] = None - f._c_data_chunks[block_id] = None - - for g in pset.fieldset.gridset.grids: - g._load_chunk = np.where( - g._load_chunk == g._chunk_loading_requested, g._chunk_loaded_touched, g._load_chunk - ) - if len(g._load_chunk) > g._chunk_not_loaded: # not the case if a field in not called in the kernel - if not g._load_chunk.flags["C_CONTIGUOUS"]: - g._load_chunk = np.array(g._load_chunk, order="C") - if not g.depth.flags.c_contiguous: - g._depth = np.array(g.depth, order="C") - if not g.lon.flags.c_contiguous: - g._lon = np.array(g.lon, order="C") - if not g.lat.flags.c_contiguous: - g._lat = np.array(g.lat, order="C") - - def execute_jit(self, pset, endtime, dt): - """Invokes JIT engine to perform the core update loop.""" - self.load_fieldset_jit(pset) - - fargs = [byref(f.ctypes_struct) for f in self.field_args.values()] - fargs += [c_double(f) for f in self.const_args.values()] - particle_data = byref(pset.ctypes_struct) - return self._function(c_int(len(pset)), particle_data, c_double(endtime), c_double(dt), *fargs) - - def execute_python(self, pset, endtime, dt): - """Performs the core update loop via Python.""" - if self.fieldset is not None: - for f in self.fieldset.get_fields(): - if isinstance(f, (VectorField, NestedField)): - continue - f.data = np.array(f.data) - - if not self.scipy_positionupdate_kernels_added: - self.add_scipy_positionupdate_kernels() - self.scipy_positionupdate_kernels_added = True - - for p in pset: - self.evaluate_particle(p, endtime) - if p.state == StatusCode.StopAllExecution: - return StatusCode.StopAllExecution - - def execute(self, pset, endtime, dt): - """Execute this Kernel over a ParticleSet for several timesteps.""" - pset.particledata.state[:] = StatusCode.Evaluate - - if abs(dt) < 1e-6: - warnings.warn( - "'dt' is too small, causing numerical accuracy limit problems. Please chose a higher 'dt' and rather scale the 'time' axis of the field accordingly. (related issue #762)", - RuntimeWarning, - stacklevel=2, - ) - - if pset.fieldset is not None: - for g in pset.fieldset.gridset.grids: - if len(g._load_chunk) > g._chunk_not_loaded: # not the case if a field in not called in the kernel - g._load_chunk = np.where( - g._load_chunk == g._chunk_loaded_touched, g._chunk_deprecated, g._load_chunk - ) - - # Execute the kernel over the particle set - if self.ptype.uses_jit: - self.execute_jit(pset, endtime, dt) - else: - self.execute_python(pset, endtime, dt) - - # Remove all particles that signalled deletion - self.remove_deleted(pset) - - # Identify particles that threw errors - n_error = pset._num_error_particles - - while n_error > 0: - error_pset = pset._error_particles - # Check for StatusCodes - for p in error_pset: - if p.state == StatusCode.StopExecution: - return - if p.state == StatusCode.StopAllExecution: - return StatusCode.StopAllExecution - if p.state == StatusCode.Repeat: - p.state = StatusCode.Evaluate - elif p.state == StatusCode.ErrorTimeExtrapolation: - raise TimeExtrapolationError(p.time) - elif p.state == StatusCode.ErrorOutOfBounds: - _raise_field_out_of_bound_error(p.depth, p.lat, p.lon) - elif p.state == StatusCode.ErrorThroughSurface: - _raise_field_out_of_bound_surface_error(p.depth, p.lat, p.lon) - elif p.state == StatusCode.Error: - _raise_field_sampling_error(p.depth, p.lat, p.lon) - elif p.state == StatusCode.Delete: - pass - else: - warnings.warn( - f"Deleting particle {p.id} because of non-recoverable error", - RuntimeWarning, - stacklevel=2, - ) - p.delete() - - # Remove all particles that signalled deletion - self.remove_deleted(pset) # Generalizable version! - - # Execute core loop again to continue interrupted particles - if self.ptype.uses_jit: - self.execute_jit(pset, endtime, dt) - else: - self.execute_python(pset, endtime, dt) - - n_error = pset._num_error_particles - - def evaluate_particle(self, p, endtime): - """Execute the kernel evaluation of for an individual particle. - - Parameters - ---------- - p : - object of (sub-)type (ScipyParticle, JITParticle) - endtime : - endtime of this overall kernel evaluation step - dt : - computational integration timestep - """ - while p.state in [StatusCode.Evaluate, StatusCode.Repeat]: - pre_dt = p.dt - - sign_dt = np.sign(p.dt) - if sign_dt * p.time_nextloop >= sign_dt * endtime: - return p - - try: # Use next_dt from AdvectionRK45 if it is set - if abs(endtime - p.time_nextloop) < abs(p.next_dt) - 1e-6: - p.next_dt = abs(endtime - p.time_nextloop) * sign_dt - except KeyError: - if abs(endtime - p.time_nextloop) < abs(p.dt) - 1e-6: - p.dt = abs(endtime - p.time_nextloop) * sign_dt - res = self._pyfunc(p, self._fieldset, p.time_nextloop) - - if res is None: - if sign_dt * p.time < sign_dt * endtime and p.state == StatusCode.Success: - p.state = StatusCode.Evaluate - else: - p.state = res - - p.dt = pre_dt - return p diff --git a/parcels/application_kernels/EOSseawaterproperties.py b/parcels/kernels/EOSseawaterproperties.py similarity index 100% rename from parcels/application_kernels/EOSseawaterproperties.py rename to parcels/kernels/EOSseawaterproperties.py diff --git a/parcels/application_kernels/TEOSseawaterdensity.py b/parcels/kernels/TEOSseawaterdensity.py similarity index 88% rename from parcels/application_kernels/TEOSseawaterdensity.py rename to parcels/kernels/TEOSseawaterdensity.py index 8234dd52f..255632671 100644 --- a/parcels/application_kernels/TEOSseawaterdensity.py +++ b/parcels/kernels/TEOSseawaterdensity.py @@ -6,7 +6,7 @@ def PolyTEOS10_bsq(particle, fieldset, time): # pragma: no cover - """Calculates density based on the polyTEOS10-bsq algorithm from Appendix A.2 of + """Calculates density based on the polyTEOS10-bsq algorithm from Appendix A.1 and A.2 of https://www.sciencedirect.com/science/article/pii/S1463500315000566 requires fieldset.abs_salinity and fieldset.cons_temperature Fields in the fieldset and a particle.density Variable in the ParticleSet @@ -27,10 +27,20 @@ def PolyTEOS10_bsq(particle, fieldset, time): # pragma: no cover SA = fieldset.abs_salinity[time, particle.depth, particle.lat, particle.lon] CT = fieldset.cons_temperature[time, particle.depth, particle.lat, particle.lon] - SAu = 40 * 35.16504 / 35 - CTu = 40 + SAu = 40.0 * 35.16504 / 35.0 + CTu = 40.0 Zu = 1e4 - deltaS = 32 + deltaS = 32.0 + + zz = -Z / Zu + R00 = 4.6494977072e01 + R01 = -5.2099962525e00 + R02 = 2.2601900708e-01 + R03 = 6.4326772569e-02 + R04 = 1.5616995503e-02 + R05 = -1.7243708991e-03 + r0 = (((((R05 * zz + R04) * zz + R03) * zz + R02) * zz + R01) * zz + R00) * zz + R000 = 8.0189615746e02 R100 = 8.6672408165e02 R200 = -1.7864682637e03 @@ -90,4 +100,6 @@ def PolyTEOS10_bsq(particle, fieldset, time): # pragma: no cover rz2 = (R022 * tt + R112 * ss + R012) * tt + (R202 * ss + R102) * ss + R002 rz1 = (((R041 * tt + R131 * ss + R031) * tt + (R221 * ss + R121) * ss + R021) * tt + ((R311 * ss + R211) * ss + R111) * ss + R011) * tt + (((R401 * ss + R301) * ss + R201) * ss + R101) * ss + R001 # fmt: skip rz0 = (((((R060 * tt + R150 * ss + R050) * tt + (R240 * ss + R140) * ss + R040) * tt + ((R330 * ss + R230) * ss + R130) * ss + R030) * tt + (((R420 * ss + R320) * ss + R220) * ss + R120) * ss + R020) * tt + ((((R510 * ss + R410) * ss + R310) * ss + R210) * ss + R110) * ss + R010) * tt + (((((R600 * ss + R500) * ss + R400) * ss + R300) * ss + R200) * ss + R100) * ss + R000 # fmt: skip - particle.density = ((rz3 * zz + rz2) * zz + rz1) * zz + rz0 + r = ((rz3 * zz + rz2) * zz + rz1) * zz + rz0 + + particle.density = r0 + r diff --git a/parcels/kernels/__init__.py b/parcels/kernels/__init__.py new file mode 100644 index 000000000..02e3e1f2f --- /dev/null +++ b/parcels/kernels/__init__.py @@ -0,0 +1,36 @@ +from .advection import ( + AdvectionAnalytical, + AdvectionEE, + AdvectionRK4, + AdvectionRK4_3D, + AdvectionRK4_3D_CROCO, + AdvectionRK45, +) +from .advectiondiffusion import ( + AdvectionDiffusionEM, + AdvectionDiffusionM1, + DiffusionUniformKh, +) +from .interaction import ( + AsymmetricAttraction, + MergeWithNearestNeighbor, + NearestNeighborWithinRange, +) + +__all__ = [ # noqa: RUF022 + # advection + "AdvectionAnalytical", + "AdvectionEE", + "AdvectionRK4_3D_CROCO", + "AdvectionRK4_3D", + "AdvectionRK4", + "AdvectionRK45", + # advectiondiffusion + "AdvectionDiffusionEM", + "AdvectionDiffusionM1", + "DiffusionUniformKh", + # interaction + "AsymmetricAttraction", + "MergeWithNearestNeighbor", + "NearestNeighborWithinRange", +] diff --git a/parcels/application_kernels/advection.py b/parcels/kernels/advection.py similarity index 50% rename from parcels/application_kernels/advection.py rename to parcels/kernels/advection.py index b11d9912f..8d2139290 100644 --- a/parcels/application_kernels/advection.py +++ b/parcels/kernels/advection.py @@ -2,7 +2,9 @@ import math -from parcels.tools.statuscodes import StatusCode +import numpy as np + +from parcels._core.statuscodes import StatusCode __all__ = [ "AdvectionAnalytical", @@ -14,92 +16,96 @@ ] -def AdvectionRK4(particle, fieldset, time): # pragma: no cover +def AdvectionRK4(particles, fieldset): # pragma: no cover """Advection of particles using fourth-order Runge-Kutta integration.""" - (u1, v1) = fieldset.UV[particle] - lon1, lat1 = (particle.lon + u1 * 0.5 * particle.dt, particle.lat + v1 * 0.5 * particle.dt) - (u2, v2) = fieldset.UV[time + 0.5 * particle.dt, particle.depth, lat1, lon1, particle] - lon2, lat2 = (particle.lon + u2 * 0.5 * particle.dt, particle.lat + v2 * 0.5 * particle.dt) - (u3, v3) = fieldset.UV[time + 0.5 * particle.dt, particle.depth, lat2, lon2, particle] - lon3, lat3 = (particle.lon + u3 * particle.dt, particle.lat + v3 * particle.dt) - (u4, v4) = fieldset.UV[time + particle.dt, particle.depth, lat3, lon3, particle] - particle_dlon += (u1 + 2 * u2 + 2 * u3 + u4) / 6.0 * particle.dt # noqa - particle_dlat += (v1 + 2 * v2 + 2 * v3 + v4) / 6.0 * particle.dt # noqa - - -def AdvectionRK4_3D(particle, fieldset, time): # pragma: no cover + dt = particles.dt / np.timedelta64(1, "s") # TODO: improve API for converting dt to seconds + (u1, v1) = fieldset.UV[particles] + lon1, lat1 = (particles.lon + u1 * 0.5 * dt, particles.lat + v1 * 0.5 * dt) + (u2, v2) = fieldset.UV[particles.time + 0.5 * particles.dt, particles.depth, lat1, lon1, particles] + lon2, lat2 = (particles.lon + u2 * 0.5 * dt, particles.lat + v2 * 0.5 * dt) + (u3, v3) = fieldset.UV[particles.time + 0.5 * particles.dt, particles.depth, lat2, lon2, particles] + lon3, lat3 = (particles.lon + u3 * dt, particles.lat + v3 * dt) + (u4, v4) = fieldset.UV[particles.time + particles.dt, particles.depth, lat3, lon3, particles] + particles.dlon += (u1 + 2 * u2 + 2 * u3 + u4) / 6.0 * dt + particles.dlat += (v1 + 2 * v2 + 2 * v3 + v4) / 6.0 * dt + + +def AdvectionRK4_3D(particles, fieldset): # pragma: no cover """Advection of particles using fourth-order Runge-Kutta integration including vertical velocity.""" - (u1, v1, w1) = fieldset.UVW[particle] - lon1 = particle.lon + u1 * 0.5 * particle.dt - lat1 = particle.lat + v1 * 0.5 * particle.dt - dep1 = particle.depth + w1 * 0.5 * particle.dt - (u2, v2, w2) = fieldset.UVW[time + 0.5 * particle.dt, dep1, lat1, lon1, particle] - lon2 = particle.lon + u2 * 0.5 * particle.dt - lat2 = particle.lat + v2 * 0.5 * particle.dt - dep2 = particle.depth + w2 * 0.5 * particle.dt - (u3, v3, w3) = fieldset.UVW[time + 0.5 * particle.dt, dep2, lat2, lon2, particle] - lon3 = particle.lon + u3 * particle.dt - lat3 = particle.lat + v3 * particle.dt - dep3 = particle.depth + w3 * particle.dt - (u4, v4, w4) = fieldset.UVW[time + particle.dt, dep3, lat3, lon3, particle] - particle_dlon += (u1 + 2 * u2 + 2 * u3 + u4) / 6 * particle.dt # noqa - particle_dlat += (v1 + 2 * v2 + 2 * v3 + v4) / 6 * particle.dt # noqa - particle_ddepth += (w1 + 2 * w2 + 2 * w3 + w4) / 6 * particle.dt # noqa - - -def AdvectionRK4_3D_CROCO(particle, fieldset, time): # pragma: no cover + dt = particles.dt / np.timedelta64(1, "s") + (u1, v1, w1) = fieldset.UVW[particles] + lon1 = particles.lon + u1 * 0.5 * dt + lat1 = particles.lat + v1 * 0.5 * dt + dep1 = particles.depth + w1 * 0.5 * dt + (u2, v2, w2) = fieldset.UVW[particles.time + 0.5 * particles.dt, dep1, lat1, lon1, particles] + lon2 = particles.lon + u2 * 0.5 * dt + lat2 = particles.lat + v2 * 0.5 * dt + dep2 = particles.depth + w2 * 0.5 * dt + (u3, v3, w3) = fieldset.UVW[particles.time + 0.5 * particles.dt, dep2, lat2, lon2, particles] + lon3 = particles.lon + u3 * dt + lat3 = particles.lat + v3 * dt + dep3 = particles.depth + w3 * dt + (u4, v4, w4) = fieldset.UVW[particles.time + particles.dt, dep3, lat3, lon3, particles] + particles.dlon += (u1 + 2 * u2 + 2 * u3 + u4) / 6 * dt + particles.dlat += (v1 + 2 * v2 + 2 * v3 + v4) / 6 * dt + particles.ddepth += (w1 + 2 * w2 + 2 * w3 + w4) / 6 * dt + + +def AdvectionRK4_3D_CROCO(particles, fieldset): # pragma: no cover """Advection of particles using fourth-order Runge-Kutta integration including vertical velocity. This kernel assumes the vertical velocity is the 'w' field from CROCO output and works on sigma-layers. """ - sig_dep = particle.depth / fieldset.H[time, 0, particle.lat, particle.lon] - - (u1, v1, w1) = fieldset.UVW[time, particle.depth, particle.lat, particle.lon, particle] - w1 *= sig_dep / fieldset.H[time, 0, particle.lat, particle.lon] - lon1 = particle.lon + u1 * 0.5 * particle.dt - lat1 = particle.lat + v1 * 0.5 * particle.dt - sig_dep1 = sig_dep + w1 * 0.5 * particle.dt - dep1 = sig_dep1 * fieldset.H[time, 0, lat1, lon1] - - (u2, v2, w2) = fieldset.UVW[time + 0.5 * particle.dt, dep1, lat1, lon1, particle] - w2 *= sig_dep1 / fieldset.H[time, 0, lat1, lon1] - lon2 = particle.lon + u2 * 0.5 * particle.dt - lat2 = particle.lat + v2 * 0.5 * particle.dt - sig_dep2 = sig_dep + w2 * 0.5 * particle.dt - dep2 = sig_dep2 * fieldset.H[time, 0, lat2, lon2] - - (u3, v3, w3) = fieldset.UVW[time + 0.5 * particle.dt, dep2, lat2, lon2, particle] - w3 *= sig_dep2 / fieldset.H[time, 0, lat2, lon2] - lon3 = particle.lon + u3 * particle.dt - lat3 = particle.lat + v3 * particle.dt - sig_dep3 = sig_dep + w3 * particle.dt - dep3 = sig_dep3 * fieldset.H[time, 0, lat3, lon3] - - (u4, v4, w4) = fieldset.UVW[time + particle.dt, dep3, lat3, lon3, particle] - w4 *= sig_dep3 / fieldset.H[time, 0, lat3, lon3] - lon4 = particle.lon + u4 * particle.dt - lat4 = particle.lat + v4 * particle.dt - sig_dep4 = sig_dep + w4 * particle.dt - dep4 = sig_dep4 * fieldset.H[time, 0, lat4, lon4] - - particle_dlon += (u1 + 2 * u2 + 2 * u3 + u4) / 6 * particle.dt # noqa - particle_dlat += (v1 + 2 * v2 + 2 * v3 + v4) / 6 * particle.dt # noqa - particle_ddepth += ( # noqa - (dep1 - particle.depth) * 2 - + 2 * (dep2 - particle.depth) * 2 - + 2 * (dep3 - particle.depth) + dt = particles.dt / np.timedelta64(1, "s") # TODO: improve API for converting dt to seconds + sig_dep = particles.depth / fieldset.H[particles.time, 0, particles.lat, particles.lon] + + (u1, v1, w1) = fieldset.UVW[particles.time, particles.depth, particles.lat, particles.lon, particles] + w1 *= sig_dep / fieldset.H[particles.time, 0, particles.lat, particles.lon] + lon1 = particles.lon + u1 * 0.5 * dt + lat1 = particles.lat + v1 * 0.5 * dt + sig_dep1 = sig_dep + w1 * 0.5 * dt + dep1 = sig_dep1 * fieldset.H[particles.time, 0, lat1, lon1] + + (u2, v2, w2) = fieldset.UVW[particles.time + 0.5 * particles.dt, dep1, lat1, lon1, particles] + w2 *= sig_dep1 / fieldset.H[particles.time, 0, lat1, lon1] + lon2 = particles.lon + u2 * 0.5 * dt + lat2 = particles.lat + v2 * 0.5 * dt + sig_dep2 = sig_dep + w2 * 0.5 * dt + dep2 = sig_dep2 * fieldset.H[particles.time, 0, lat2, lon2] + + (u3, v3, w3) = fieldset.UVW[particles.time + 0.5 * particles.dt, dep2, lat2, lon2, particles] + w3 *= sig_dep2 / fieldset.H[particles.time, 0, lat2, lon2] + lon3 = particles.lon + u3 * dt + lat3 = particles.lat + v3 * dt + sig_dep3 = sig_dep + w3 * dt + dep3 = sig_dep3 * fieldset.H[particles.time, 0, lat3, lon3] + + (u4, v4, w4) = fieldset.UVW[particles.time + particles.dt, dep3, lat3, lon3, particles] + w4 *= sig_dep3 / fieldset.H[particles.time, 0, lat3, lon3] + lon4 = particles.lon + u4 * dt + lat4 = particles.lat + v4 * dt + sig_dep4 = sig_dep + w4 * dt + dep4 = sig_dep4 * fieldset.H[particles.time, 0, lat4, lon4] + + particles.dlon += (u1 + 2 * u2 + 2 * u3 + u4) / 6 * dt + particles.dlat += (v1 + 2 * v2 + 2 * v3 + v4) / 6 * dt + particles.ddepth += ( + (dep1 - particles.depth) * 2 + + 2 * (dep2 - particles.depth) * 2 + + 2 * (dep3 - particles.depth) + dep4 - - particle.depth + - particles.depth ) / 6 -def AdvectionEE(particle, fieldset, time): # pragma: no cover +def AdvectionEE(particles, fieldset): # pragma: no cover """Advection of particles using Explicit Euler (aka Euler Forward) integration.""" - (u1, v1) = fieldset.UV[particle] - particle_dlon += u1 * particle.dt # noqa - particle_dlat += v1 * particle.dt # noqa + dt = particles.dt / np.timedelta64(1, "s") # TODO: improve API for converting dt to seconds + (u1, v1) = fieldset.UV[particles] + particles.dlon += u1 * dt + particles.dlat += v1 * dt -def AdvectionRK45(particle, fieldset, time): # pragma: no cover +def AdvectionRK45(particles, fieldset): # pragma: no cover """Advection of particles using adaptive Runge-Kutta 4/5 integration. Note that this kernel requires a Particle Class that has an extra Variable 'next_dt' @@ -109,7 +115,8 @@ def AdvectionRK45(particle, fieldset, time): # pragma: no cover Time-step dt is halved if error is larger than fieldset.RK45_tol, and doubled if error is smaller than 1/10th of tolerance. """ - particle.dt = min(particle.next_dt, fieldset.RK45_max_dt) + dt = particles.dt / np.timedelta64(1, "s") # TODO: improve API for converting dt to seconds + c = [1.0 / 4.0, 3.0 / 8.0, 12.0 / 13.0, 1.0, 1.0 / 2.0] A = [ [1.0 / 4.0, 0.0, 0.0, 0.0, 0.0], @@ -121,47 +128,63 @@ def AdvectionRK45(particle, fieldset, time): # pragma: no cover b4 = [25.0 / 216.0, 0.0, 1408.0 / 2565.0, 2197.0 / 4104.0, -1.0 / 5.0] b5 = [16.0 / 135.0, 0.0, 6656.0 / 12825.0, 28561.0 / 56430.0, -9.0 / 50.0, 2.0 / 55.0] - (u1, v1) = fieldset.UV[particle] - lon1, lat1 = (particle.lon + u1 * A[0][0] * particle.dt, particle.lat + v1 * A[0][0] * particle.dt) - (u2, v2) = fieldset.UV[time + c[0] * particle.dt, particle.depth, lat1, lon1, particle] + (u1, v1) = fieldset.UV[particles] + lon1, lat1 = (particles.lon + u1 * A[0][0] * dt, particles.lat + v1 * A[0][0] * dt) + (u2, v2) = fieldset.UV[particles.time + c[0] * particles.dt, particles.depth, lat1, lon1, particles] lon2, lat2 = ( - particle.lon + (u1 * A[1][0] + u2 * A[1][1]) * particle.dt, - particle.lat + (v1 * A[1][0] + v2 * A[1][1]) * particle.dt, + particles.lon + (u1 * A[1][0] + u2 * A[1][1]) * dt, + particles.lat + (v1 * A[1][0] + v2 * A[1][1]) * dt, ) - (u3, v3) = fieldset.UV[time + c[1] * particle.dt, particle.depth, lat2, lon2, particle] + (u3, v3) = fieldset.UV[particles.time + c[1] * particles.dt, particles.depth, lat2, lon2, particles] lon3, lat3 = ( - particle.lon + (u1 * A[2][0] + u2 * A[2][1] + u3 * A[2][2]) * particle.dt, - particle.lat + (v1 * A[2][0] + v2 * A[2][1] + v3 * A[2][2]) * particle.dt, + particles.lon + (u1 * A[2][0] + u2 * A[2][1] + u3 * A[2][2]) * dt, + particles.lat + (v1 * A[2][0] + v2 * A[2][1] + v3 * A[2][2]) * dt, ) - (u4, v4) = fieldset.UV[time + c[2] * particle.dt, particle.depth, lat3, lon3, particle] + (u4, v4) = fieldset.UV[particles.time + c[2] * particles.dt, particles.depth, lat3, lon3, particles] lon4, lat4 = ( - particle.lon + (u1 * A[3][0] + u2 * A[3][1] + u3 * A[3][2] + u4 * A[3][3]) * particle.dt, - particle.lat + (v1 * A[3][0] + v2 * A[3][1] + v3 * A[3][2] + v4 * A[3][3]) * particle.dt, + particles.lon + (u1 * A[3][0] + u2 * A[3][1] + u3 * A[3][2] + u4 * A[3][3]) * dt, + particles.lat + (v1 * A[3][0] + v2 * A[3][1] + v3 * A[3][2] + v4 * A[3][3]) * dt, ) - (u5, v5) = fieldset.UV[time + c[3] * particle.dt, particle.depth, lat4, lon4, particle] + (u5, v5) = fieldset.UV[particles.time + c[3] * particles.dt, particles.depth, lat4, lon4, particles] lon5, lat5 = ( - particle.lon + (u1 * A[4][0] + u2 * A[4][1] + u3 * A[4][2] + u4 * A[4][3] + u5 * A[4][4]) * particle.dt, - particle.lat + (v1 * A[4][0] + v2 * A[4][1] + v3 * A[4][2] + v4 * A[4][3] + v5 * A[4][4]) * particle.dt, + particles.lon + (u1 * A[4][0] + u2 * A[4][1] + u3 * A[4][2] + u4 * A[4][3] + u5 * A[4][4]) * dt, + particles.lat + (v1 * A[4][0] + v2 * A[4][1] + v3 * A[4][2] + v4 * A[4][3] + v5 * A[4][4]) * dt, ) - (u6, v6) = fieldset.UV[time + c[4] * particle.dt, particle.depth, lat5, lon5, particle] - - lon_4th = (u1 * b4[0] + u2 * b4[1] + u3 * b4[2] + u4 * b4[3] + u5 * b4[4]) * particle.dt - lat_4th = (v1 * b4[0] + v2 * b4[1] + v3 * b4[2] + v4 * b4[3] + v5 * b4[4]) * particle.dt - lon_5th = (u1 * b5[0] + u2 * b5[1] + u3 * b5[2] + u4 * b5[3] + u5 * b5[4] + u6 * b5[5]) * particle.dt - lat_5th = (v1 * b5[0] + v2 * b5[1] + v3 * b5[2] + v4 * b5[3] + v5 * b5[4] + v6 * b5[5]) * particle.dt - - kappa = math.sqrt(math.pow(lon_5th - lon_4th, 2) + math.pow(lat_5th - lat_4th, 2)) - if (kappa <= fieldset.RK45_tol) or (math.fabs(particle.dt) < math.fabs(fieldset.RK45_min_dt)): - particle_dlon += lon_4th # noqa - particle_dlat += lat_4th # noqa - if (kappa <= fieldset.RK45_tol) / 10 and (math.fabs(particle.dt * 2) <= math.fabs(fieldset.RK45_max_dt)): - particle.next_dt *= 2 - else: - particle.next_dt /= 2 - return StatusCode.Repeat + (u6, v6) = fieldset.UV[particles.time + c[4] * particles.dt, particles.depth, lat5, lon5, particles] + + lon_4th = (u1 * b4[0] + u2 * b4[1] + u3 * b4[2] + u4 * b4[3] + u5 * b4[4]) * dt + lat_4th = (v1 * b4[0] + v2 * b4[1] + v3 * b4[2] + v4 * b4[3] + v5 * b4[4]) * dt + lon_5th = (u1 * b5[0] + u2 * b5[1] + u3 * b5[2] + u4 * b5[3] + u5 * b5[4] + u6 * b5[5]) * dt + lat_5th = (v1 * b5[0] + v2 * b5[1] + v3 * b5[2] + v4 * b5[3] + v5 * b5[4] + v6 * b5[5]) * dt + + kappa = np.sqrt(np.pow(lon_5th - lon_4th, 2) + np.pow(lat_5th - lat_4th, 2)) + + good_particles = (kappa <= fieldset.RK45_tol) | (np.fabs(dt) <= np.fabs(fieldset.RK45_min_dt)) + particles.dlon += np.where(good_particles, lon_5th, 0) + particles.dlat += np.where(good_particles, lat_5th, 0) + increase_dt_particles = ( + good_particles & (kappa <= fieldset.RK45_tol / 10) & (np.fabs(dt * 2) <= np.fabs(fieldset.RK45_max_dt)) + ) + particles.dt = np.where(increase_dt_particles, particles.dt * 2, particles.dt) + particles.dt = np.where( + particles.dt > fieldset.RK45_max_dt * np.timedelta64(1, "s"), + fieldset.RK45_max_dt * np.timedelta64(1, "s"), + particles.dt, + ) + particles.state = np.where(good_particles, StatusCode.Success, particles.state) + + repeat_particles = np.invert(good_particles) + particles.dt = np.where(repeat_particles, particles.dt / 2, particles.dt) + particles.dt = np.where( + particles.dt < fieldset.RK45_min_dt * np.timedelta64(1, "s"), + fieldset.RK45_min_dt * np.timedelta64(1, "s"), + particles.dt, + ) + particles.state = np.where(repeat_particles, StatusCode.Repeat, particles.state) -def AdvectionAnalytical(particle, fieldset, time): # pragma: no cover + +def AdvectionAnalytical(particles, fieldset): # pragma: no cover """Advection of particles using 'analytical advection' integration. Based on Ariane/TRACMASS algorithm, as detailed in e.g. Doos et al (https://doi.org/10.5194/gmd-10-1733-2017). @@ -170,23 +193,22 @@ def AdvectionAnalytical(particle, fieldset, time): # pragma: no cover """ import numpy as np - import parcels.tools.interpolation_utils as i_u + import parcels.utils.interpolation_utils as i_u tol = 1e-10 I_s = 10 # number of intermediate time steps - direction = 1.0 if particle.dt > 0 else -1.0 - withW = True if "W" in [f.name for f in fieldset.get_fields()] else False - withTime = True if len(fieldset.U.grid.time_full) > 1 else False - ti = fieldset.U._time_index(time)[0] - ds_t = particle.dt + dt = particles.dt / np.timedelta64(1, "s") # TODO improve API for converting dt to seconds + direction = 1.0 if dt > 0 else -1.0 + withW = True if "W" in [f.name for f in fieldset.fields.values()] else False + withTime = True if len(fieldset.U.grid.time) > 1 else False + tau, zeta, eta, xsi, ti, zi, yi, xi = fieldset.U._search_indices( + particles.depth, particles.lat, particles.lon, particles=particles + ) + ds_t = dt if withTime: - tau = (time - fieldset.U.grid.time[ti]) / (fieldset.U.grid.time[ti + 1] - fieldset.U.grid.time[ti]) time_i = np.linspace(0, fieldset.U.grid.time[ti + 1] - fieldset.U.grid.time[ti], I_s) - ds_t = min(ds_t, time_i[np.where(time - fieldset.U.grid.time[ti] < time_i)[0][0]]) + ds_t = min(ds_t, time_i[np.where(particles.time - fieldset.U.grid.time[ti] < time_i)[0][0]]) - zeta, eta, xsi, zi, yi, xi = fieldset.U._search_indices( - -1, particle.depth, particle.lat, particle.lon, particle=particle - ) if withW: if abs(xsi - 1) < tol: if fieldset.U.data[0, zi + 1, yi + 1, xi + 1] > 0: @@ -210,9 +232,7 @@ def AdvectionAnalytical(particle, fieldset, time): # pragma: no cover yi += 1 eta = 0 - particle.xi[:] = xi - particle.yi[:] = yi - particle.zi[:] = zi + particles.ei[:] = fieldset.U.ravel_index(zi, yi, xi) grid = fieldset.U.grid if grid._gtype < 2: @@ -222,8 +242,8 @@ def AdvectionAnalytical(particle, fieldset, time): # pragma: no cover px = np.array([grid.lon[yi, xi], grid.lon[yi, xi + 1], grid.lon[yi + 1, xi + 1], grid.lon[yi + 1, xi]]) py = np.array([grid.lat[yi, xi], grid.lat[yi, xi + 1], grid.lat[yi + 1, xi + 1], grid.lat[yi + 1, xi]]) if grid.mesh == "spherical": - px[0] = px[0] + 360 if px[0] < particle.lon - 225 else px[0] - px[0] = px[0] - 360 if px[0] > particle.lat + 225 else px[0] + px[0] = px[0] + 360 if px[0] < particles.lon - 225 else px[0] + px[0] = px[0] - 360 if px[0] > particles.lat + 225 else px[0] px[1:] = np.where(px[1:] - px[0] > 180, px[1:] - 360, px[1:]) px[1:] = np.where(-px[1:] + px[0] > 180, px[1:] + 360, px[1:]) if withW: @@ -238,7 +258,7 @@ def AdvectionAnalytical(particle, fieldset, time): # pragma: no cover c4 = i_u._geodetic_distance(py[3], py[0], px[3], px[0], grid.mesh, np.dot(i_u.phi2D_lin(eta, 0.0), py)) rad = np.pi / 180.0 deg2m = 1852 * 60.0 - meshJac = (deg2m * deg2m * math.cos(rad * particle.lat)) if grid.mesh == "spherical" else 1 + meshJac = (deg2m * deg2m * math.cos(rad * particles.lat)) if grid.mesh == "spherical" else 1 dxdy = i_u._compute_jacobian_determinant(py, px, eta, xsi) * meshJac if withW: @@ -313,26 +333,26 @@ def compute_rs(r, B, delta, s_min): rs_x = compute_rs(xsi, B_x, delta_x, s_min) rs_y = compute_rs(eta, B_y, delta_y, s_min) - particle_dlon += ( # noqa + particles.dlon += ( (1.0 - rs_x) * (1.0 - rs_y) * px[0] + rs_x * (1.0 - rs_y) * px[1] + rs_x * rs_y * px[2] + (1.0 - rs_x) * rs_y * px[3] - - particle.lon + - particles.lon ) - particle_dlat += ( # noqa + particles.dlat += ( (1.0 - rs_x) * (1.0 - rs_y) * py[0] + rs_x * (1.0 - rs_y) * py[1] + rs_x * rs_y * py[2] + (1.0 - rs_x) * rs_y * py[3] - - particle.lat + - particles.lat ) if withW: rs_z = compute_rs(zeta, B_z, delta_z, s_min) - particle_ddepth += (1.0 - rs_z) * pz[0] + rs_z * pz[1] - particle.depth # noqa + particles.ddepth += (1.0 - rs_z) * pz[0] + rs_z * pz[1] - particles.depth - if particle.dt > 0: - particle.dt = max(direction * s_min * (dxdy * dz), 1e-7) + if particles.dt > 0: + particles.dt = max(direction * s_min * (dxdy * dz), 1e-7).astype("timedelta64[s]") else: - particle.dt = min(direction * s_min * (dxdy * dz), -1e-7) + particles.dt = min(direction * s_min * (dxdy * dz), -1e-7).astype("timedelta64[s]") diff --git a/parcels/kernels/advectiondiffusion.py b/parcels/kernels/advectiondiffusion.py new file mode 100644 index 000000000..6ad4ad258 --- /dev/null +++ b/parcels/kernels/advectiondiffusion.py @@ -0,0 +1,121 @@ +"""Collection of pre-built advection-diffusion kernels. + +See `this tutorial <../examples/tutorial_diffusion.ipynb>`__ for a detailed explanation. +""" + +import numpy as np + +__all__ = ["AdvectionDiffusionEM", "AdvectionDiffusionM1", "DiffusionUniformKh"] + + +def AdvectionDiffusionM1(particles, fieldset): # pragma: no cover + """Kernel for 2D advection-diffusion, solved using the Milstein scheme at first order (M1). + + Assumes that fieldset has fields `Kh_zonal` and `Kh_meridional` + and variable `fieldset.dres`, setting the resolution for the central + difference gradient approximation. This should be (of the order of) the + local gridsize. + + This Milstein scheme is of strong and weak order 1, which is higher than the + Euler-Maruyama scheme. It experiences less spurious diffusivity by + including extra correction terms that are computationally cheap. + + The Wiener increment `dW` is normally distributed with zero + mean and a standard deviation of sqrt(dt). + """ + dt = particles.dt / np.timedelta64(1, "s") # TODO: improve API for converting dt to seconds + # Wiener increment with zero mean and std of sqrt(dt) + dWx = np.random.normal(0, np.sqrt(np.fabs(dt))) + dWy = np.random.normal(0, np.sqrt(np.fabs(dt))) + + Kxp1 = fieldset.Kh_zonal[particles.time, particles.depth, particles.lat, particles.lon + fieldset.dres, particles] + Kxm1 = fieldset.Kh_zonal[particles.time, particles.depth, particles.lat, particles.lon - fieldset.dres, particles] + dKdx = (Kxp1 - Kxm1) / (2 * fieldset.dres) + + u, v = fieldset.UV[particles.time, particles.depth, particles.lat, particles.lon, particles] + bx = np.sqrt(2 * fieldset.Kh_zonal[particles.time, particles.depth, particles.lat, particles.lon, particles]) + + Kyp1 = fieldset.Kh_meridional[ + particles.time, particles.depth, particles.lat + fieldset.dres, particles.lon, particles + ] + Kym1 = fieldset.Kh_meridional[ + particles.time, particles.depth, particles.lat - fieldset.dres, particles.lon, particles + ] + dKdy = (Kyp1 - Kym1) / (2 * fieldset.dres) + + by = np.sqrt(2 * fieldset.Kh_meridional[particles.time, particles.depth, particles.lat, particles.lon, particles]) + + # Particle positions are updated only after evaluating all terms. + particles.dlon += u * dt + 0.5 * dKdx * (dWx**2 + dt) + bx * dWx + particles.dlat += v * dt + 0.5 * dKdy * (dWy**2 + dt) + by * dWy + + +def AdvectionDiffusionEM(particles, fieldset): # pragma: no cover + """Kernel for 2D advection-diffusion, solved using the Euler-Maruyama scheme (EM). + + Assumes that fieldset has fields `Kh_zonal` and `Kh_meridional` + and variable `fieldset.dres`, setting the resolution for the central + difference gradient approximation. This should be (of the order of) the + local gridsize. + + The Euler-Maruyama scheme is of strong order 0.5 and weak order 1. + + The Wiener increment `dW` is normally distributed with zero + mean and a standard deviation of sqrt(dt). + """ + dt = particles.dt / np.timedelta64(1, "s") + # Wiener increment with zero mean and std of sqrt(dt) + dWx = np.random.normal(0, np.sqrt(np.fabs(dt))) + dWy = np.random.normal(0, np.sqrt(np.fabs(dt))) + + u, v = fieldset.UV[particles.time, particles.depth, particles.lat, particles.lon, particles] + + Kxp1 = fieldset.Kh_zonal[particles.time, particles.depth, particles.lat, particles.lon + fieldset.dres, particles] + Kxm1 = fieldset.Kh_zonal[particles.time, particles.depth, particles.lat, particles.lon - fieldset.dres, particles] + dKdx = (Kxp1 - Kxm1) / (2 * fieldset.dres) + ax = u + dKdx + bx = np.sqrt(2 * fieldset.Kh_zonal[particles.time, particles.depth, particles.lat, particles.lon, particles]) + + Kyp1 = fieldset.Kh_meridional[ + particles.time, particles.depth, particles.lat + fieldset.dres, particles.lon, particles + ] + Kym1 = fieldset.Kh_meridional[ + particles.time, particles.depth, particles.lat - fieldset.dres, particles.lon, particles + ] + dKdy = (Kyp1 - Kym1) / (2 * fieldset.dres) + ay = v + dKdy + by = np.sqrt(2 * fieldset.Kh_meridional[particles.time, particles.depth, particles.lat, particles.lon, particles]) + + # Particle positions are updated only after evaluating all terms. + particles.dlon += ax * dt + bx * dWx + particles.dlat += ay * dt + by * dWy + + +def DiffusionUniformKh(particles, fieldset): # pragma: no cover + """Kernel for simple 2D diffusion where diffusivity (Kh) is assumed uniform. + + Assumes that fieldset has constant fields `Kh_zonal` and `Kh_meridional`. + These can be added via e.g. + `fieldset.add_constant_field("Kh_zonal", kh_zonal, mesh=mesh)` + or + `fieldset.add_constant_field("Kh_meridional", kh_meridional, mesh=mesh)` + where mesh is either 'flat' or 'spherical' + + This kernel assumes diffusivity gradients are zero and is therefore more efficient. + Since the perturbation due to diffusion is in this case isotropic independent, this + kernel contains no advection and can be used in combination with a separate + advection kernel. + + The Wiener increment `dW` is normally distributed with zero + mean and a standard deviation of sqrt(dt). + """ + dt = particles.dt / np.timedelta64(1, "s") + # Wiener increment with zero mean and std of sqrt(dt) + dWx = np.random.normal(0, np.sqrt(np.fabs(dt))) + dWy = np.random.normal(0, np.sqrt(np.fabs(dt))) + + bx = np.sqrt(2 * fieldset.Kh_zonal[particles]) + by = np.sqrt(2 * fieldset.Kh_meridional[particles]) + + particles.dlon += bx * dWx + particles.dlat += by * dWy diff --git a/parcels/application_kernels/interaction.py b/parcels/kernels/interaction.py similarity index 87% rename from parcels/application_kernels/interaction.py rename to parcels/kernels/interaction.py index db3c4e04e..2eb919ef9 100644 --- a/parcels/application_kernels/interaction.py +++ b/parcels/kernels/interaction.py @@ -2,7 +2,7 @@ import numpy as np -from parcels.tools.statuscodes import StatusCode +from parcels._core.statuscodes import StatusCode __all__ = ["AsymmetricAttraction", "MergeWithNearestNeighbor", "NearestNeighborWithinRange"] @@ -25,12 +25,12 @@ def NearestNeighborWithinRange(particle, fieldset, time, neighbors, mutator): # undesirable results. if dist < min_dist or min_dist < 0: min_dist = dist - neighbor_id = n.id + neighbor_id = n.trajectory def f(p, neighbor): p.nearest_neighbor = neighbor - mutator[particle.id].append((f, [neighbor_id])) + mutator[particle.trajectory].append((f, [neighbor_id])) return StatusCode.Success @@ -54,14 +54,14 @@ def merge_with_neighbor(p, nlat, nlon, ndepth, nmass): p.mass = p.mass + nmass for n in neighbors: - if n.id == particle.nearest_neighbor: - if n.nearest_neighbor == particle.id and particle.id < n.id: + if n.trajectory == particle.nearest_neighbor: + if n.nearest_neighbor == particle.trajectory and particle.trajectory < n.trajectory: # Merge particles: # Delete neighbor - mutator[n.id].append((delete_particle, ())) + mutator[n.trajectory].append((delete_particle, ())) # Take position at the mid point and sum of masses args = np.array([n.lat, n.lon, n.depth, n.mass]) - mutator[particle.id].append((merge_with_neighbor, args)) + mutator[particle.trajectory].append((merge_with_neighbor, args)) return StatusCode.Success else: @@ -101,6 +101,6 @@ def f(n, dlat, dlon, ddepth): n.lon_nextloop += dlon n.depth_nextloop += ddepth - mutator[n.id].append((f, d_vec)) + mutator[n.trajectory].append((f, d_vec)) return StatusCode.Success diff --git a/parcels/particle.py b/parcels/particle.py deleted file mode 100644 index d6cd98662..000000000 --- a/parcels/particle.py +++ /dev/null @@ -1,312 +0,0 @@ -from ctypes import c_void_p -from operator import attrgetter -from typing import Literal - -import numpy as np - -from parcels.tools.statuscodes import StatusCode - -__all__ = ["JITParticle", "ScipyInteractionParticle", "ScipyParticle", "Variable"] - -indicators_64bit = [np.float64, np.uint64, np.int64, c_void_p] - - -class Variable: - """Descriptor class that delegates data access to particle data. - - Parameters - ---------- - name : str - Variable name as used within kernels - dtype : - Data type (numpy.dtype) of the variable - initial : - Initial value of the variable. Note that this can also be a Field object, - which will then be sampled at the location of the particle - to_write : bool, 'once', optional - Boolean or 'once'. Controls whether Variable is written to NetCDF file. - If to_write = 'once', the variable will be written as a time-independent 1D array - """ - - def __init__(self, name, dtype=np.float32, initial=0, to_write: bool | Literal["once"] = True): - self._name = name - self.dtype = dtype - self.initial = initial - self.to_write = to_write - - @property - def name(self): - return self._name - - def __get__(self, instance, cls): - if instance is None: - return self - if issubclass(cls, JITParticle): - return instance._cptr.__getitem__(self.name) - else: - return getattr(instance, f"_{self.name}", self.initial) - - def __set__(self, instance, value): - if isinstance(instance, JITParticle): - instance._cptr.__setitem__(self.name, value) - else: - setattr(instance, f"_{self.name}", value) - - def __repr__(self): - return f"Variable(name={self._name}, dtype={self.dtype}, initial={self.initial}, to_write={self.to_write})" - - def is64bit(self): - """Check whether variable is 64-bit.""" - return True if self.dtype in indicators_64bit else False - - -class ParticleType: - """Class encapsulating the type information for custom particles. - - Parameters - ---------- - user_vars : - Optional list of (name, dtype) tuples for custom variables - """ - - def __init__(self, pclass): - if not isinstance(pclass, type): - raise TypeError("Class object required to derive ParticleType") - if not issubclass(pclass, ScipyParticle): - raise TypeError("Class object does not inherit from parcels.ScipyParticle") - self.name = pclass.__name__ - self.uses_jit = issubclass(pclass, JITParticle) - # Pick Variable objects out of __dict__. - self.variables = [v for v in pclass.__dict__.values() if isinstance(v, Variable)] - for cls in pclass.__bases__: - if issubclass(cls, ScipyParticle): - # Add inherited particle variables - ptype = cls.getPType() - for v in self.variables: - if v.name in [v.name for v in ptype.variables]: - raise AttributeError( - f"Custom Variable name '{v.name}' is not allowed, as it is also a built-in variable" - ) - if v.name == "z": - raise AttributeError( - "Custom Variable name 'z' is not allowed, as it is used for depth in ParticleFile" - ) - self.variables = ptype.variables + self.variables - # Sort variables with all the 64-bit first so that they are aligned for the JIT cptr - self.variables = [v for v in self.variables if v.is64bit()] + [v for v in self.variables if not v.is64bit()] - - def __repr__(self): - return f"{type(self).__name__}(pclass={self.name})" - - def __getitem__(self, item): - for v in self.variables: - if v.name == item: - return v - - @property - def _cache_key(self): - return "-".join([f"{v.name}:{v.dtype}" for v in self.variables]) - - @property - def dtype(self): - """Numpy.dtype object that defines the C struct.""" - type_list = [(v.name, v.dtype) for v in self.variables] - for v in self.variables: - if v.dtype not in self.supported_dtypes: - raise RuntimeError(str(v.dtype) + " variables are not implemented in JIT mode") - if self.size % 8 > 0: - # Add padding to be 64-bit aligned - type_list += [("pad", np.float32)] - return np.dtype(type_list) - - @property - def size(self): - """Size of the underlying particle struct in bytes.""" - return sum([8 if v.is64bit() else 4 for v in self.variables]) - - @property - def supported_dtypes(self): - """List of all supported numpy dtypes. All others are not supported.""" - # Developer note: other dtypes (mostly 2-byte ones) are not supported now - # because implementing and aligning them in cgen.GenerableStruct is a - # major headache. Perhaps in a later stage - return [np.int32, np.uint32, np.int64, np.uint64, np.float32, np.double, np.float64, c_void_p] - - -class ScipyParticle: - """Class encapsulating the basic attributes of a particle, to be executed in SciPy mode. - - Parameters - ---------- - lon : float - Initial longitude of particle - lat : float - Initial latitude of particle - depth : float - Initial depth of particle - fieldset : parcels.fieldset.FieldSet - mod:`parcels.fieldset.FieldSet` object to track this particle on - time : float - Current time of the particle - - - Notes - ----- - Additional Variables can be added via the :Class Variable: objects - """ - - lon = Variable("lon", dtype=np.float32) - lon_nextloop = Variable("lon_nextloop", dtype=np.float32, to_write=False) - lat = Variable("lat", dtype=np.float32) - lat_nextloop = Variable("lat_nextloop", dtype=np.float32, to_write=False) - depth = Variable("depth", dtype=np.float32) - depth_nextloop = Variable("depth_nextloop", dtype=np.float32, to_write=False) - time = Variable("time", dtype=np.float64) - time_nextloop = Variable("time_nextloop", dtype=np.float64, to_write=False) - id = Variable("id", dtype=np.int64, to_write="once") - obs_written = Variable("obs_written", dtype=np.int32, initial=0, to_write=False) - dt = Variable("dt", dtype=np.float64, to_write=False) - state = Variable("state", dtype=np.int32, initial=StatusCode.Evaluate, to_write=False) - - lastID = 0 # class-level variable keeping track of last Particle ID used - - def __init__(self, lon, lat, pid, fieldset=None, ngrids=None, depth=0.0, time=0.0, cptr=None): - # Enforce default values through Variable descriptor - type(self).lon.initial = lon - type(self).lon_nextloop.initial = lon - type(self).lat.initial = lat - type(self).lat_nextloop.initial = lat - type(self).depth.initial = depth - type(self).depth_nextloop.initial = depth - type(self).time.initial = time - type(self).time_nextloop.initial = time - type(self).id.initial = pid - type(self).lastID = max(type(self).lastID, pid) - type(self).obs_written.initial = 0 - type(self).dt.initial = None - - ptype = self.getPType() - # Explicit initialisation of all particle variables - for v in ptype.variables: - if isinstance(v.initial, attrgetter): - initial = v.initial(self) - else: - initial = v.initial - # Enforce type of initial value - if v.dtype != c_void_p: - setattr(self, v.name, v.dtype(initial)) - - def __del__(self): - pass # superclass is 'object', and object itself has no destructor, hence 'pass' - - def __repr__(self): - time_string = "not_yet_set" if self.time is None or np.isnan(self.time) else f"{self.time:f}" - p_string = f"P[{self.id}](lon={self.lon:f}, lat={self.lat:f}, depth={self.depth:f}, " - for var in vars(type(self)): - if var in ["lon_nextloop", "lat_nextloop", "depth_nextloop", "time_nextloop"]: - continue - if type(getattr(type(self), var)) is Variable and getattr(type(self), var).to_write is True: - p_string += f"{var}={getattr(self, var):f}, " - return p_string + f"time={time_string})" - - @classmethod - def add_variable(cls, var, *args, **kwargs): - """Add a new variable to the Particle class - - Parameters - ---------- - var : str, Variable or list of Variables - Variable object to be added. Can be the name of the Variable, - a Variable object, or a list of Variable objects - """ - if isinstance(var, list): - return cls.add_variables(var) - if not isinstance(var, Variable): - if len(args) > 0 and "dtype" not in kwargs: - kwargs["dtype"] = args[0] - if len(args) > 1 and "initial" not in kwargs: - kwargs["initial"] = args[1] - if len(args) > 2 and "to_write" not in kwargs: - kwargs["to_write"] = args[2] - dtype = kwargs.pop("dtype", np.float32) - initial = kwargs.pop("initial", 0) - to_write = kwargs.pop("to_write", True) - var = Variable(var, dtype=dtype, initial=initial, to_write=to_write) - - class NewParticle(cls): - pass - - setattr(NewParticle, var.name, var) - return NewParticle - - @classmethod - def add_variables(cls, variables): - """Add multiple new variables to the Particle class - - Parameters - ---------- - variables : list of Variable - Variable objects to be added. Has to be a list of Variable objects - """ - NewParticle = cls - for var in variables: - NewParticle = NewParticle.add_variable(var) - return NewParticle - - @classmethod - def getPType(cls): - return ParticleType(cls) - - @classmethod - def set_lonlatdepth_dtype(cls, dtype): - cls.lon.dtype = dtype - cls.lat.dtype = dtype - cls.depth.dtype = dtype - cls.lon_nextloop.dtype = dtype - cls.lat_nextloop.dtype = dtype - cls.depth_nextloop.dtype = dtype - - @classmethod - def setLastID(cls, offset): - ScipyParticle.lastID = offset - - -ScipyInteractionParticle = ScipyParticle.add_variables( - [Variable("vert_dist", dtype=np.float32), Variable("horiz_dist", dtype=np.float32)] -) - - -class JITParticle(ScipyParticle): - """Particle class for JIT-based (Just-In-Time) Particle objects. - - Parameters - ---------- - lon : float - Initial longitude of particle - lat : float - Initial latitude of particle - fieldset : parcels.fieldset.FieldSet - mod:`parcels.fieldset.FieldSet` object to track this particle on - dt : - Execution timestep for this particle - time : - Current time of the particle - - - Notes - ----- - Additional Variables can be added via the :Class Variable: objects - - Users should use JITParticles for faster advection computation. - """ - - def __init__(self, *args, **kwargs): - self._cptr = kwargs.pop("cptr", None) - if self._cptr is None: - # Allocate data for a single particle - ptype = self.getPType() - self._cptr = np.empty(1, dtype=ptype.dtype)[0] - super().__init__(*args, **kwargs) - - def __del__(self): - super().__del__() diff --git a/parcels/particledata.py b/parcels/particledata.py deleted file mode 100644 index 9f2eb5ccd..000000000 --- a/parcels/particledata.py +++ /dev/null @@ -1,525 +0,0 @@ -import warnings -from ctypes import POINTER, Structure -from operator import attrgetter - -import numpy as np - -from parcels._compat import MPI, KMeans -from parcels.tools._helpers import deprecated -from parcels.tools.statuscodes import StatusCode - - -def partitionParticlesMPI_default(coords, mpi_size=1): - """This function takes the coordinates of the particle starting - positions and returns which MPI process will process each particle. - - Input: - - coords: numpy array with rows of [lon, lat] so that coords.shape[0] is the number of particles and coords.shape[1] is 2. - - mpi_size=1: the number of MPI processes. - - Output: - mpiProcs: an integer array with values from 0 to mpi_size-1 specifying which MPI job will run which particles. len(mpiProcs) must equal coords.shape[0] - """ - if KMeans: - kmeans = KMeans(n_clusters=mpi_size, random_state=0).fit(coords) - mpiProcs = kmeans.labels_ - else: # assigning random labels if no KMeans (see https://github.com/OceanParcels/parcels/issues/1261) - warnings.warn( - "sklearn needs to be available if MPI is installed. " - "See https://docs.oceanparcels.org/en/latest/installation.html#installation-for-developers for more information", - RuntimeWarning, - stacklevel=2, - ) - mpiProcs = np.random.randint(0, mpi_size, size=coords.shape[0]) - - return mpiProcs - - -class ParticleData: - def __init__(self, pclass, lon, lat, depth, time, lonlatdepth_dtype, pid_orig, ngrid=1, **kwargs): - """ - Parameters - ---------- - ngrid : - number of grids in the fieldset of the overarching ParticleSet - required for initialising the - field references of the ctypes-link of particles that are allocated - """ - self._ncount = -1 - self._pu_indicators = None - self._offset = 0 - self._pclass = None - self._ptype = None - self._latlondepth_dtype = np.float32 - self._data = None - - assert pid_orig is not None, "particle IDs are None - incompatible with the ParticleData class. Invalid state." - pid = pid_orig + pclass.lastID - - self._sorted = np.all(np.diff(pid) >= 0) - - assert ( - depth is not None - ), "particle's initial depth is None - incompatible with the ParticleData class. Invalid state." - assert lon.size == lat.size and lon.size == depth.size, "lon, lat, depth don't all have the same lenghts." - - assert lon.size == time.size, "time and positions (lon, lat, depth) don't have the same lengths." - - # If a partitioning function for MPI runs has been passed into the - # particle creation with the "partition_function" kwarg, retrieve it here. - # If it has not, assign the default function, partitionParticlesMPI_default() - partition_function = kwargs.pop("partition_function", partitionParticlesMPI_default) - - for kwvar in kwargs: - assert ( - lon.size == kwargs[kwvar].size - ), f"{kwvar} and positions (lon, lat, depth) don't have the same lengths." - - offset = np.max(pid) if (pid is not None) and len(pid) > 0 else -1 - if MPI: - mpi_comm = MPI.COMM_WORLD - mpi_rank = mpi_comm.Get_rank() - mpi_size = mpi_comm.Get_size() - - if lon.size < mpi_size and mpi_size > 1: - raise RuntimeError("Cannot initialise with fewer particles than MPI processors") - - if mpi_size > 1: - if partition_function is not False: - if (self._pu_indicators is None) or (len(self._pu_indicators) != len(lon)): - if mpi_rank == 0: - coords = np.vstack((lon, lat)).transpose() - self._pu_indicators = partition_function(coords, mpi_size=mpi_size) - else: - self._pu_indicators = None - self._pu_indicators = mpi_comm.bcast(self._pu_indicators, root=0) - elif np.max(self._pu_indicators) >= mpi_size: - raise RuntimeError("Particle partitions must vary between 0 and the number of mpi procs") - lon = lon[self._pu_indicators == mpi_rank] - lat = lat[self._pu_indicators == mpi_rank] - time = time[self._pu_indicators == mpi_rank] - depth = depth[self._pu_indicators == mpi_rank] - pid = pid[self._pu_indicators == mpi_rank] - for kwvar in kwargs: - kwargs[kwvar] = kwargs[kwvar][self._pu_indicators == mpi_rank] - offset = MPI.COMM_WORLD.allreduce(offset, op=MPI.MAX) - - pclass.setLastID(offset + 1) - - if lonlatdepth_dtype is None: - self._lonlatdepth_dtype = np.float32 - else: - self._lonlatdepth_dtype = lonlatdepth_dtype - assert self._lonlatdepth_dtype in [ - np.float32, - np.float64, - ], "lon lat depth precision should be set to either np.float32 or np.float64" - pclass.set_lonlatdepth_dtype(self._lonlatdepth_dtype) - self._pclass = pclass - - self._ptype = pclass.getPType() - self._data = {} - initialised = set() - - self._ncount = len(lon) - - for v in self.ptype.variables: - if v.name in ["xi", "yi", "zi", "ti"]: - self._data[v.name] = np.empty((len(lon), ngrid), dtype=v.dtype) - else: - self._data[v.name] = np.empty(self._ncount, dtype=v.dtype) - - if lon is not None and lat is not None: - # Initialise from lists of lon/lat coordinates - assert self._ncount == len(lon) and self._ncount == len( - lat - ), "Size of ParticleSet does not match length of lon and lat." - - # mimic the variables that get initialised in the constructor - self._data["lat"][:] = lat - self._data["lat_nextloop"][:] = lat - self._data["lon"][:] = lon - self._data["lon_nextloop"][:] = lon - self._data["depth"][:] = depth - self._data["depth_nextloop"][:] = depth - self._data["time"][:] = time - self._data["time_nextloop"][:] = time - self._data["id"][:] = pid - self._data["obs_written"][:] = 0 - - # special case for exceptions which can only be handled from scipy - self._data["exception"] = np.empty(self._ncount, dtype=object) - - initialised |= { - "lat", - "lat_nextloop", - "lon", - "lon_nextloop", - "depth", - "depth_nextloop", - "time", - "time_nextloop", - "id", - "obs_written", - } - - # any fields that were provided on the command line - for kwvar, kwval in kwargs.items(): - if not hasattr(pclass, kwvar): - raise RuntimeError(f"Particle class does not have Variable {kwvar}") - self._data[kwvar][:] = kwval - initialised.add(kwvar) - - # initialise the rest to their default values - for v in self.ptype.variables: - if v.name in initialised: - continue - - if isinstance(v.initial, attrgetter): - self._data[v.name][:] = v.initial(self) - else: - self._data[v.name][:] = v.initial - - initialised.add(v.name) - else: - raise ValueError("Latitude and longitude required for generating ParticleSet") - - def __del__(self): - pass - - @property - def pu_indicators(self): - """ - The 'pu_indicator' is an [array or dictionary]-of-indicators, where each indicator entry tells per item - (i.e. particle) in the ParticleData instance to which processing unit (PU) in a parallelised setup it belongs to. - """ - return self._pu_indicators - - @property - def pclass(self): - """Class type of the particles allocated and managed in this ParticleData instance.""" - return self._pclass - - @property - def ptype(self): - """ - 'ptype' returns an instance of the particular type of class 'ParticleType' of the particle class of the particles - in this ParticleData instance. - - basically: - pytpe -> pclass().getPType() - """ - return self._ptype - - @property - def lonlatdepth_dtype(self): - """ - 'lonlatdepth_dtype' stores the numeric data type that is used to represent the lon, lat and depth of a particle. - This can be either 'float32' (default) or 'float64' - """ - return self._lonlatdepth_dtype - - @property - def data(self): - """'data' is a reference to the actual 'bare bone'-storage of the particle data.""" - return self._data - - def __len__(self): - """Return the length, in terms of 'number of elements, of a ParticleData instance.""" - return self._ncount - - @deprecated( - "Use iter(...) instead, or just use the object in an iterator context (e.g. for p in particledata: ...)." - ) # TODO: Remove 6 months after v3.1.0 (or 9 months; doesn't contribute to code debt) - def iterator(self): - return iter(self) - - def __iter__(self): - """Return an Iterator that allows for forward iteration over the elements in the ParticleData (e.g. `for p in pset:`).""" - return ParticleDataIterator(self) - - def __getitem__(self, index): - """Get a particle object from the ParticleData instance based on its index.""" - return self.get_single_by_index(index) - - def __getattr__(self, name): - """ - Access a single property of all particles. - - Parameters - ---------- - name : str - Name of the property to access - """ - for v in self.ptype.variables: - if v.name == name and name in self._data: - return self._data[name] - return False - - def get_single_by_index(self, index): - """Get a particle object from the ParticleData instance based on its index.""" - assert type(index) in [ - int, - np.int32, - np.intp, - ], f"Trying to get a particle by index, but index {index} is not a 32-bit integer - invalid operation." - return ParticleDataAccessor(self, index) - - def add_same(self, same_class): - """Add another ParticleData instance to this ParticleData instance. This is done by concatenating both instances.""" - assert ( - same_class is not None - ), f"Trying to add another {type(self)} to this one, but the other one is None - invalid operation." - assert type(same_class) is type(self) - - if same_class._ncount == 0: - return - - if self._ncount == 0: - self._data = same_class._data - self._ncount = same_class._ncount - return - - # Determine order of concatenation and update the sorted flag - if self._sorted and same_class._sorted and self._data["id"][0] > same_class._data["id"][-1]: - for d in self._data: - self._data[d] = np.concatenate((same_class._data[d], self._data[d])) - self._ncount += same_class._ncount - else: - if not (same_class._sorted and self._data["id"][-1] < same_class._data["id"][0]): - self._sorted = False - for d in self._data: - self._data[d] = np.concatenate((self._data[d], same_class._data[d])) - self._ncount += same_class._ncount - - def __iadd__(self, instance): - """Perform an incremental addition of ParticleData instances, such to allow a += b.""" - self.add_same(instance) - return self - - def remove_single_by_index(self, index): - """Remove a particle from the ParticleData instance based on its index.""" - assert type(index) in [ - int, - np.int32, - np.intp, - ], f"Trying to remove a particle by index, but index {index} is not a 32-bit integer - invalid operation." - - for d in self._data: - self._data[d] = np.delete(self._data[d], index, axis=0) - - self._ncount -= 1 - - def remove_multi_by_indices(self, indices): - """Remove particles from the ParticleData instance based on their indices.""" - assert ( - indices is not None - ), "Trying to remove particles by their ParticleData instance indices, but the index list is None - invalid operation." - assert ( - type(indices) in [list, dict, np.ndarray] - ), "Trying to remove particles by their indices, but the index container is not a valid Python-collection - invalid operation." - if type(indices) is not dict: - assert ( - len(indices) == 0 or type(indices[0]) in [int, np.int32, np.intp] - ), "Trying to remove particles by their index, but the index type in the Python collection is not a 32-bit integer - invalid operation." - else: - assert ( - len(list(indices.values())) == 0 or type(list(indices.values())[0]) in [int, np.int32, np.intp] - ), "Trying to remove particles by their index, but the index type in the Python collection is not a 32-bit integer - invalid operation." - if type(indices) is dict: - indices = list(indices.values()) - - for d in self._data: - self._data[d] = np.delete(self._data[d], indices, axis=0) - - self._ncount -= len(indices) - - def cstruct(self): - """Return the ctypes mapping of the particle data.""" - - class CParticles(Structure): - _fields_ = [(v.name, POINTER(np.ctypeslib.as_ctypes_type(v.dtype))) for v in self._ptype.variables] - - def flatten_dense_data_array(vname): - data_flat = self._data[vname].view() - data_flat.shape = -1 - return np.ctypeslib.as_ctypes(data_flat) - - cdata = [flatten_dense_data_array(v.name) for v in self._ptype.variables] - cstruct = CParticles(*cdata) - return cstruct - - def _to_write_particles(self, time): - """Return the Particles that need to be written at time: if particle.time is between time-dt/2 and time+dt (/2)""" - pd = self._data - return np.where( - ( - np.less_equal(time - np.abs(pd["dt"] / 2), pd["time"], where=np.isfinite(pd["time"])) - & np.greater_equal(time + np.abs(pd["dt"] / 2), pd["time"], where=np.isfinite(pd["time"])) - | ((np.isnan(pd["dt"])) & np.equal(time, pd["time"], where=np.isfinite(pd["time"]))) - ) - & (np.isfinite(pd["id"])) - & (np.isfinite(pd["time"])) - )[0] - - def getvardata(self, var, indices=None): - if indices is None: - return self._data[var] - else: - try: - return self._data[var][indices] - except: # Can occur for zero-length ParticleSets - return None - - def setvardata(self, var, index, val): - self._data[var][index] = val - - def setallvardata(self, var, val): - self._data[var][:] = val - - def set_variable_write_status(self, var, write_status): - """Method to set the write status of a Variable - - Parameters - ---------- - var : - Name of the variable (string) - write_status : - Write status of the variable (True, False or 'once') - """ - var_changed = False - for v in self._ptype.variables: - if v.name == var: - v.to_write = write_status - var_changed = True - if not var_changed: - raise SyntaxError(f"Could not change the write status of {var}, because it is not a Variable name") - - -class ParticleDataAccessor: - """Wrapper that provides access to particle data, as if interacting with the particle itself. - - Parameters - ---------- - pcoll : - ParticleData that the particle belongs to. - index : - The index at which the data for the particle is stored in the corresponding data arrays of the ParticleData instance. - """ - - _pcoll = None - _index = 0 - - def __init__(self, pcoll, index): - """Initializes the ParticleDataAccessor to provide access to one specific particle.""" - self._pcoll = pcoll - self._index = index - - def __getattr__(self, name): - """ - Get the value of an attribute of the particle. - - Parameters - ---------- - name : str - Name of the requested particle attribute. - - Returns - ------- - any - The value of the particle attribute in the underlying data array. - """ - if name in self.__dict__.keys(): - result = self.__getattribute__(name) - elif name in type(self).__dict__.keys(): - result = object.__getattribute__(self, name) - else: - result = self._pcoll.data[name][self._index] - return result - - def __setattr__(self, name, value): - """ - Set the value of an attribute of the particle. - - Parameters - ---------- - name : str - Name of the particle attribute. - value : any - Value that will be assigned to the particle attribute in the underlying data array. - """ - if name in self.__dict__.keys(): - self.__setattr__(name, value) - elif name in type(self).__dict__.keys(): - object.__setattr__(self, name, value) - else: - self._pcoll.data[name][self._index] = value - - def getPType(self): - return self._pcoll.ptype - - def __repr__(self): - time_string = "not_yet_set" if self.time is None or np.isnan(self.time) else f"{self.time:f}" - p_string = f"P[{self.id}](lon={self.lon:f}, lat={self.lat:f}, depth={self.depth:f}, " - for var in self._pcoll.ptype.variables: - if var.name in [ - "lon_nextloop", - "lat_nextloop", - "depth_nextloop", - "time_nextloop", - ]: # TODO check if time_nextloop is needed (or can work with time-dt?) - continue - if var.to_write is not False and var.name not in ["id", "lon", "lat", "depth", "time"]: - p_string += f"{var.name}={getattr(self, var.name):f}, " - return p_string + f"time={time_string})" - - def delete(self): - """Signal the particle for deletion.""" - self.state = StatusCode.Delete - - -class ParticleDataIterator: - """Iterator for looping over the particles in the ParticleData. - - Parameters - ---------- - pcoll : - ParticleData that stores the particles. - subset : - Subset of indices to iterate over. - """ - - def __init__(self, pcoll, subset=None): - if subset is not None: - if len(subset) > 0 and type(subset[0]) not in [int, np.int32, np.intp]: - raise TypeError( - "Iteration over a subset of particles in the particleset requires a list or numpy array of indices (of type int or np.int32)." - ) - self._indices = subset - self.max_len = len(subset) - else: - self.max_len = len(pcoll) - self._indices = range(self.max_len) - - self._pcoll = pcoll - self._index = 0 - - def __len__(self): - return len(self._indices) - - def __getitem__(self, items): - return ParticleDataAccessor(self._pcoll, self._indices[items]) - - def __iter__(self): - """Return the iterator itself.""" - return self - - def __next__(self): - """Return a ParticleDataAccessor for the next particle in the ParticleData instance.""" - if self._index < self.max_len: - self.p = ParticleDataAccessor(self._pcoll, self._indices[self._index]) - self._index += 1 - return self.p - - raise StopIteration diff --git a/parcels/particlefile.py b/parcels/particlefile.py deleted file mode 100644 index fb67f7f57..000000000 --- a/parcels/particlefile.py +++ /dev/null @@ -1,386 +0,0 @@ -"""Module controlling the writing of ParticleSets to Zarr file.""" - -import os -import warnings -from datetime import timedelta - -import numpy as np -import xarray as xr -import zarr - -import parcels -from parcels._compat import MPI -from parcels.tools._helpers import default_repr, deprecated, deprecated_made_private, timedelta_to_float -from parcels.tools.warnings import FileWarning - -__all__ = ["ParticleFile"] - - -def _set_calendar(origin_calendar): - if origin_calendar == "np_datetime64": - return "standard" - else: - return origin_calendar - - -class ParticleFile: - """Initialise trajectory output. - - Parameters - ---------- - name : str - Basename of the output file. This can also be a Zarr store object. - particleset : - ParticleSet to output - outputdt : - Interval which dictates the update frequency of file output - while ParticleFile is given as an argument of ParticleSet.execute() - It is either a timedelta object or a positive double. - chunks : - Tuple (trajs, obs) to control the size of chunks in the zarr output. - create_new_zarrfile : bool - Whether to create a new file. Default is True - - Returns - ------- - ParticleFile - ParticleFile object that can be used to write particle data to file - """ - - def __init__(self, name, particleset, outputdt, chunks=None, create_new_zarrfile=True): - self._outputdt = timedelta_to_float(outputdt) - self._chunks = chunks - self._particleset = particleset - self._parcels_mesh = "spherical" - if self.particleset.fieldset is not None: - self._parcels_mesh = self.particleset.fieldset.gridset.grids[0].mesh - self.lonlatdepth_dtype = self.particleset.particledata.lonlatdepth_dtype - self._maxids = 0 - self._pids_written = {} - self._create_new_zarrfile = create_new_zarrfile - self._vars_to_write = {} - for var in self.particleset.particledata.ptype.variables: - if var.to_write: - self.vars_to_write[var.name] = var.dtype - self._mpi_rank = MPI.COMM_WORLD.Get_rank() if MPI else 0 - self.particleset.fieldset._particlefile = self - self._is_analytical = False # Flag to indicate if ParticleFile is used for analytical trajectories - - # Reset obs_written of each particle, in case new ParticleFile created for a ParticleSet - particleset.particledata.setallvardata("obs_written", 0) - - self.metadata = { - "feature_type": "trajectory", - "Conventions": "CF-1.6/CF-1.7", - "ncei_template_version": "NCEI_NetCDF_Trajectory_Template_v2.0", - "parcels_version": parcels.__version__, - "parcels_mesh": self._parcels_mesh, - } - - # Create dictionary to translate datatypes and fill_values - self._fill_value_map = { - np.float16: np.nan, - np.float32: np.nan, - np.float64: np.nan, - np.bool_: np.iinfo(np.int8).max, - np.int8: np.iinfo(np.int8).max, - np.int16: np.iinfo(np.int16).max, - np.int32: np.iinfo(np.int32).max, - np.int64: np.iinfo(np.int64).max, - np.uint8: np.iinfo(np.uint8).max, - np.uint16: np.iinfo(np.uint16).max, - np.uint32: np.iinfo(np.uint32).max, - np.uint64: np.iinfo(np.uint64).max, - } - if issubclass(type(name), zarr.storage.Store): - # If we already got a Zarr store, we won't need any of the naming logic below. - # But we need to handle incompatibility with MPI mode for now: - if MPI and MPI.COMM_WORLD.Get_size() > 1: - raise ValueError("Currently, MPI mode is not compatible with directly passing a Zarr store.") - fname = name - else: - extension = os.path.splitext(str(name))[1] - if extension in [".nc", ".nc4"]: - raise RuntimeError( - "Output in NetCDF is not supported anymore. Use .zarr extension for ParticleFile name." - ) - if MPI and MPI.COMM_WORLD.Get_size() > 1: - fname = os.path.join(name, f"proc{self._mpi_rank:02d}.zarr") - if extension in [".zarr"]: - warnings.warn( - f"The ParticleFile name contains .zarr extension, but zarr files will be written per processor in MPI mode at {fname}", - FileWarning, - stacklevel=2, - ) - else: - fname = name if extension in [".zarr"] else f"{name}.zarr" - self._fname = fname - - def __repr__(self) -> str: - return ( - f"{type(self).__name__}(" - f"name={self.fname!r}, " - f"particleset={default_repr(self.particleset)}, " - f"outputdt={self.outputdt!r}, " - f"chunks={self.chunks!r}, " - f"create_new_zarrfile={self.create_new_zarrfile!r})" - ) - - @property - def create_new_zarrfile(self): - return self._create_new_zarrfile - - @property - def outputdt(self): - return self._outputdt - - @property - def chunks(self): - return self._chunks - - @property - def particleset(self): - return self._particleset - - @property - def fname(self): - return self._fname - - @property - def vars_to_write(self): - return self._vars_to_write - - @property - def time_origin(self): - return self.particleset.time_origin - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def parcels_mesh(self): - return self._parcels_mesh - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def maxids(self): - return self._maxids - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def pids_written(self): - return self._pids_written - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def mpi_rank(self): - return self._mpi_rank - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def fill_value_map(self): - return self._fill_value_map - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def analytical(self): - return self._is_analytical - - def _create_variables_attribute_dict(self): - """Creates the dictionary with variable attributes. - - Notes - ----- - For ParticleSet structures other than SoA, and structures where ID != index, this has to be overridden. - """ - attrs = { - "z": {"long_name": "", "standard_name": "depth", "units": "m", "positive": "down"}, - "trajectory": { - "long_name": "Unique identifier for each particle", - "cf_role": "trajectory_id", - "_FillValue": self._fill_value_map[np.int64], - }, - "time": {"long_name": "", "standard_name": "time", "units": "seconds", "axis": "T"}, - "lon": {"long_name": "", "standard_name": "longitude", "units": "degrees_east", "axis": "X"}, - "lat": {"long_name": "", "standard_name": "latitude", "units": "degrees_north", "axis": "Y"}, - } - - if self.time_origin.calendar is not None: - attrs["time"]["units"] = "seconds since " + str(self.time_origin) - attrs["time"]["calendar"] = _set_calendar(self.time_origin.calendar) - - for vname in self.vars_to_write: - if vname not in ["time", "lat", "lon", "depth", "id"]: - attrs[vname] = { - "_FillValue": self._fill_value_map[self.vars_to_write[vname]], - "long_name": "", - "standard_name": vname, - "units": "unknown", - } - - return attrs - - @deprecated( - "ParticleFile.metadata is a dictionary. Use `ParticleFile.metadata['key'] = ...` or other dictionary methods instead." - ) # TODO: Remove 6 months after v3.1.0 - def add_metadata(self, name, message): - """Add metadata to :class:`parcels.particleset.ParticleSet`. - - Parameters - ---------- - name : str - Name of the metadata variable - message : str - message to be written - """ - self.metadata[name] = message - - def _convert_varout_name(self, var): - if var == "depth": - return "z" - elif var == "id": - return "trajectory" - else: - return var - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def write_once(self, *args, **kwargs): - return self._write_once(*args, **kwargs) - - def _write_once(self, var): - return self.particleset.particledata.ptype[var].to_write == "once" - - def _extend_zarr_dims(self, Z, store, dtype, axis): - if axis == 1: - a = np.full((Z.shape[0], self.chunks[1]), self._fill_value_map[dtype], dtype=dtype) - obs = zarr.group(store=store, overwrite=False)["obs"] - if len(obs) == Z.shape[1]: - obs.append(np.arange(self.chunks[1]) + obs[-1] + 1) - else: - extra_trajs = self._maxids - Z.shape[0] - if len(Z.shape) == 2: - a = np.full((extra_trajs, Z.shape[1]), self._fill_value_map[dtype], dtype=dtype) - else: - a = np.full((extra_trajs,), self._fill_value_map[dtype], dtype=dtype) - Z.append(a, axis=axis) - zarr.consolidate_metadata(store) - - def write(self, pset, time: float | timedelta | np.timedelta64 | None, indices=None): - """Write all data from one time step to the zarr file, - before the particle locations are updated. - - Parameters - ---------- - pset : - ParticleSet object to write - time : - Time at which to write ParticleSet - """ - time = timedelta_to_float(time) if time is not None else None - - if pset.particledata._ncount == 0: - warnings.warn( - f"ParticleSet is empty on writing as array at time {time:g}", - RuntimeWarning, - stacklevel=2, - ) - return - - if indices is None: - indices_to_write = pset.particledata._to_write_particles(time) - else: - indices_to_write = indices - - if len(indices_to_write) == 0: - return - - pids = pset.particledata.getvardata("id", indices_to_write) - to_add = sorted(set(pids) - set(self._pids_written.keys())) - for i, pid in enumerate(to_add): - self._pids_written[pid] = self._maxids + i - ids = np.array([self._pids_written[p] for p in pids], dtype=int) - self._maxids = len(self._pids_written) - - once_ids = np.where(pset.particledata.getvardata("obs_written", indices_to_write) == 0)[0] - if len(once_ids) > 0: - ids_once = ids[once_ids] - indices_to_write_once = indices_to_write[once_ids] - - if self.create_new_zarrfile: - if self.chunks is None: - self._chunks = (len(pset), 1) - if pset._repeatpclass is not None and self.chunks[0] < 1e4: # type: ignore[index] - warnings.warn( - f"ParticleFile chunks are set to {self.chunks}, but this may lead to " - f"a significant slowdown in Parcels when many calls to repeatdt. " - f"Consider setting a larger chunk size for your ParticleFile (e.g. chunks=(int(1e4), 1)).", - FileWarning, - stacklevel=2, - ) - if (self._maxids > len(ids)) or (self._maxids > self.chunks[0]): # type: ignore[index] - arrsize = (self._maxids, self.chunks[1]) # type: ignore[index] - else: - arrsize = (len(ids), self.chunks[1]) # type: ignore[index] - ds = xr.Dataset( - attrs=self.metadata, - coords={"trajectory": ("trajectory", pids), "obs": ("obs", np.arange(arrsize[1], dtype=np.int32))}, - ) - attrs = self._create_variables_attribute_dict() - obs = np.zeros((self._maxids), dtype=np.int32) - for var in self.vars_to_write: - varout = self._convert_varout_name(var) - if varout not in ["trajectory"]: # because 'trajectory' is written as coordinate - if self._write_once(var): - data = np.full( - (arrsize[0],), - self._fill_value_map[self.vars_to_write[var]], - dtype=self.vars_to_write[var], - ) - data[ids_once] = pset.particledata.getvardata(var, indices_to_write_once) - dims = ["trajectory"] - else: - data = np.full( - arrsize, self._fill_value_map[self.vars_to_write[var]], dtype=self.vars_to_write[var] - ) - data[ids, 0] = pset.particledata.getvardata(var, indices_to_write) - dims = ["trajectory", "obs"] - ds[varout] = xr.DataArray(data=data, dims=dims, attrs=attrs[varout]) - ds[varout].encoding["chunks"] = self.chunks[0] if self._write_once(var) else self.chunks # type: ignore[index] - ds.to_zarr(self.fname, mode="w") - self._create_new_zarrfile = False - else: - # Either use the store that was provided directly or create a DirectoryStore: - if isinstance(self.fname, zarr.storage.Store): - store = self.fname - else: - store = zarr.DirectoryStore(self.fname) - Z = zarr.group(store=store, overwrite=False) - obs = pset.particledata.getvardata("obs_written", indices_to_write) - for var in self.vars_to_write: - varout = self._convert_varout_name(var) - if self._maxids > Z[varout].shape[0]: - self._extend_zarr_dims(Z[varout], store, dtype=self.vars_to_write[var], axis=0) - if self._write_once(var): - if len(once_ids) > 0: - Z[varout].vindex[ids_once] = pset.particledata.getvardata(var, indices_to_write_once) - else: - if max(obs) >= Z[varout].shape[1]: # type: ignore[type-var] - self._extend_zarr_dims(Z[varout], store, dtype=self.vars_to_write[var], axis=1) - Z[varout].vindex[ids, obs] = pset.particledata.getvardata(var, indices_to_write) - - pset.particledata.setvardata("obs_written", indices_to_write, obs + 1) - - def write_latest_locations(self, pset, time): - """Write the current (latest) particle locations to zarr file. - This can be useful at the end of a pset.execute(), when the last locations are not written yet. - Note that this only updates the locations, not any of the other Variables. Therefore, use with care. - - Parameters - ---------- - pset : - ParticleSet object to write - time : - Time at which to write ParticleSet. Note that typically this would be pset.time_nextloop - """ - for var in ["lon", "lat", "depth", "time"]: - pset.particledata.setallvardata(f"{var}", pset.particledata.getvardata(f"{var}_nextloop")) - - self.write(pset, time) diff --git a/parcels/particleset.py b/parcels/particleset.py deleted file mode 100644 index adeddc44b..000000000 --- a/parcels/particleset.py +++ /dev/null @@ -1,1281 +0,0 @@ -import os -import sys -import warnings -from collections.abc import Iterable -from copy import copy -from datetime import date, datetime, timedelta - -import cftime -import numpy as np -import xarray as xr -from scipy.spatial import KDTree -from tqdm import tqdm - -from parcels._compat import MPI -from parcels.application_kernels.advection import AdvectionRK4 -from parcels.compilation.codecompiler import GNUCompiler -from parcels.field import Field, NestedField -from parcels.grid import CurvilinearGrid, GridType -from parcels.interaction.interactionkernel import InteractionKernel -from parcels.interaction.neighborsearch import ( - BruteFlatNeighborSearch, - BruteSphericalNeighborSearch, - HashSphericalNeighborSearch, - KDTreeFlatNeighborSearch, -) -from parcels.kernel import Kernel -from parcels.particle import JITParticle, Variable -from parcels.particledata import ParticleData, ParticleDataIterator -from parcels.particlefile import ParticleFile -from parcels.tools._helpers import deprecated, deprecated_made_private, particleset_repr, timedelta_to_float -from parcels.tools.converters import _get_cftime_calendars, convert_to_flat_array -from parcels.tools.global_statics import get_package_dir -from parcels.tools.loggers import logger -from parcels.tools.statuscodes import StatusCode -from parcels.tools.warnings import ParticleSetWarning - -__all__ = ["ParticleSet"] - - -def _convert_to_reltime(time): - """Check to determine if the value of the time parameter needs to be converted to a relative value (relative to the time_origin).""" - if isinstance(time, np.datetime64) or (hasattr(time, "calendar") and time.calendar in _get_cftime_calendars()): - return True - return False - - -class ParticleSet: - """Class for storing particle and executing kernel over them. - - Please note that this currently only supports fixed size particle sets, meaning that the particle set only - holds the particles defined on construction. Individual particles can neither be added nor deleted individually, - and individual particles can only be deleted as a set procedurally (i.e. by 'particle.delete()'-call during - kernel execution). - - Parameters - ---------- - fieldset : - mod:`parcels.fieldset.FieldSet` object from which to sample velocity. - pclass : parcels.particle.JITParticle or parcels.particle.ScipyParticle - Optional :mod:`parcels.particle.JITParticle` or - :mod:`parcels.particle.ScipyParticle` object that defines custom particle - lon : - List of initial longitude values for particles - lat : - List of initial latitude values for particles - depth : - Optional list of initial depth values for particles. Default is 0m - time : - Optional list of initial time values for particles. Default is fieldset.U.grid.time[0] - repeatdt : datetime.timedelta or float, optional - Optional interval on which to repeat the release of the ParticleSet. Either timedelta object, or float in seconds. - lonlatdepth_dtype : - Floating precision for lon, lat, depth particle coordinates. - It is either np.float32 or np.float64. Default is np.float32 if fieldset.U.interp_method is 'linear' - and np.float64 if the interpolation method is 'cgrid_velocity' - pid_orig : - Optional list of (offsets for) the particle IDs - partition_function : - Function to use for partitioning particles over processors. Default is to use kMeans - periodic_domain_zonal : - Zonal domain size, used to apply zonally periodic boundaries for particle-particle - interaction. If None, no zonally periodic boundaries are applied - - Other Variables can be initialised using further arguments (e.g. v=... for a Variable named 'v') - """ - - def __init__( - self, - fieldset, - pclass=JITParticle, - lon=None, - lat=None, - depth=None, - time=None, - repeatdt=None, - lonlatdepth_dtype=None, - pid_orig=None, - interaction_distance=None, - periodic_domain_zonal=None, - **kwargs, - ): - self.particledata = None - self._repeat_starttime = None - self._repeatlon = None - self._repeatlat = None - self._repeatdepth = None - self._repeatpclass = None - self._repeatkwargs = None - self._kernel = None - self._interaction_kernel = None - - self.fieldset = fieldset - self.fieldset._check_complete() - self.time_origin = fieldset.time_origin - self._pclass = pclass - - # ==== first: create a new subclass of the pclass that includes the required variables ==== # - # ==== see dynamic-instantiation trick here: https://www.python-course.eu/python3_classes_and_type.php ==== # - class_name = pclass.__name__ - array_class = None - if class_name not in dir(): - - def ArrayClass_init(self, *args, **kwargs): - fieldset = kwargs.get("fieldset", None) - ngrids = kwargs.get("ngrids", None) - if type(self).ngrids.initial < 0: - numgrids = ngrids - if numgrids is None and fieldset is not None: - numgrids = fieldset.gridset.size - assert numgrids is not None, "Neither fieldsets nor number of grids are specified - exiting." - type(self).ngrids.initial = numgrids - self.ngrids = type(self).ngrids.initial - if self.ngrids >= 0: - for index in ["xi", "yi", "zi", "ti"]: - if index != "ti": - setattr(self, index, np.zeros(self.ngrids, dtype=np.int32)) - else: - setattr(self, index, -1 * np.ones(self.ngrids, dtype=np.int32)) - super(type(self), self).__init__(*args, **kwargs) - - array_class_vdict = { - "ngrids": Variable("ngrids", dtype=np.int32, to_write=False, initial=-1), - "xi": Variable("xi", dtype=np.int32, to_write=False), - "yi": Variable("yi", dtype=np.int32, to_write=False), - "zi": Variable("zi", dtype=np.int32, to_write=False), - "ti": Variable("ti", dtype=np.int32, to_write=False, initial=-1), - "__init__": ArrayClass_init, - } - array_class = type(class_name, (pclass,), array_class_vdict) - else: - array_class = locals()[class_name] - # ==== dynamic re-classing completed ==== # - _pclass = array_class - - lon = np.empty(shape=0) if lon is None else convert_to_flat_array(lon) - lat = np.empty(shape=0) if lat is None else convert_to_flat_array(lat) - - if isinstance(pid_orig, (type(None), bool)): - pid_orig = np.arange(lon.size) - - if depth is None: - mindepth = self.fieldset.gridset.dimrange("depth")[0] - depth = np.ones(lon.size) * mindepth - else: - depth = convert_to_flat_array(depth) - assert lon.size == lat.size and lon.size == depth.size, "lon, lat, depth don't all have the same lenghts" - - time = convert_to_flat_array(time) - time = np.repeat(time, lon.size) if time.size == 1 else time - - if time.size > 0 and type(time[0]) in [datetime, date]: - time = np.array([np.datetime64(t) for t in time]) - if time.size > 0 and isinstance(time[0], np.timedelta64) and not self.time_origin: - raise NotImplementedError("If fieldset.time_origin is not a date, time of a particle must be a double") - time = np.array([self.time_origin.reltime(t) if _convert_to_reltime(t) else t for t in time]) - assert lon.size == time.size, "time and positions (lon, lat, depth) do not have the same lengths." - if isinstance(fieldset.U, Field) and (not fieldset.U.allow_time_extrapolation): - _warn_particle_times_outside_fieldset_time_bounds(time, fieldset.U.grid.time_full) - - if lonlatdepth_dtype is None: - lonlatdepth_dtype = self.lonlatdepth_dtype_from_field_interp_method(fieldset.U) - assert lonlatdepth_dtype in [ - np.float32, - np.float64, - ], "lon lat depth precision should be set to either np.float32 or np.float64" - - for kwvar in kwargs: - if kwvar not in ["partition_function"]: - kwargs[kwvar] = convert_to_flat_array(kwargs[kwvar]) - assert ( - lon.size == kwargs[kwvar].size - ), f"{kwvar} and positions (lon, lat, depth) don't have the same lengths." - - self.repeatdt = timedelta_to_float(repeatdt) if repeatdt is not None else None - - if self.repeatdt: - if self.repeatdt <= 0: - raise ValueError("Repeatdt should be > 0") - if time[0] and not np.allclose(time, time[0]): - raise ValueError("All Particle.time should be the same when repeatdt is not None") - self._repeatpclass = pclass - self._repeatkwargs = kwargs - self._repeatkwargs.pop("partition_function", None) - - ngrids = fieldset.gridset.size - - # Variables used for interaction kernels. - inter_dist_horiz = None - inter_dist_vert = None - # The _dirty_neighbor attribute keeps track of whether - # the neighbor search structure needs to be rebuilt. - # If indices change (for example adding/deleting a particle) - # The NS structure needs to be rebuilt and _dirty_neighbor should be - # set to true. Since the NS structure isn't immediately initialized, - # it is set to True here. - self._dirty_neighbor = True - - self.particledata = ParticleData( - _pclass, - lon=lon, - lat=lat, - depth=depth, - time=time, - lonlatdepth_dtype=lonlatdepth_dtype, - pid_orig=pid_orig, - ngrid=ngrids, - **kwargs, - ) - - # Initialize neighbor search data structure (used for interaction). - if interaction_distance is not None: - meshes = [g.mesh for g in fieldset.gridset.grids] - # Assert all grids have the same mesh type - assert np.all(np.array(meshes) == meshes[0]) - mesh_type = meshes[0] - if mesh_type == "spherical": - if len(self) < 1000: - interaction_class = BruteSphericalNeighborSearch - else: - interaction_class = HashSphericalNeighborSearch - elif mesh_type == "flat": - if len(self) < 1000: - interaction_class = BruteFlatNeighborSearch - else: - interaction_class = KDTreeFlatNeighborSearch - else: - assert False, "Interaction is only possible on 'flat' and 'spherical' meshes" - try: - if len(interaction_distance) == 2: - inter_dist_vert, inter_dist_horiz = interaction_distance - else: - inter_dist_vert = interaction_distance[0] - inter_dist_horiz = interaction_distance[0] - except TypeError: - inter_dist_vert = interaction_distance - inter_dist_horiz = interaction_distance - self._neighbor_tree = interaction_class( - inter_dist_vert=inter_dist_vert, - inter_dist_horiz=inter_dist_horiz, - periodic_domain_zonal=periodic_domain_zonal, - ) - # End of neighbor search data structure initialization. - - if self.repeatdt: - if len(time) > 0 and time[0] is None: - self._repeat_starttime = time[0] - else: - if self.particledata.data["time"][0] and not np.allclose( - self.particledata.data["time"], self.particledata.data["time"][0] - ): - raise ValueError("All Particle.time should be the same when repeatdt is not None") - self._repeat_starttime = copy(self.particledata.data["time"][0]) - self._repeatlon = copy(self.particledata.data["lon"]) - self._repeatlat = copy(self.particledata.data["lat"]) - self._repeatdepth = copy(self.particledata.data["depth"]) - for kwvar in kwargs: - if kwvar not in ["partition_function"]: - self._repeatkwargs[kwvar] = copy(self.particledata.data[kwvar]) - - if self.repeatdt: - if MPI and self.particledata.pu_indicators is not None: - mpi_comm = MPI.COMM_WORLD - mpi_rank = mpi_comm.Get_rank() - self._repeatpid = pid_orig[self.particledata.pu_indicators == mpi_rank] - - self._kernel = None - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def repeat_starttime(self): - return self._repeat_starttime - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def repeatlon(self): - return self._repeatlon - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def repeatlat(self): - return self._repeatlat - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def repeatdepth(self): - return self._repeatdepth - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def repeatpclass(self): - return self._repeatpclass - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def repeatkwargs(self): - return self._repeatkwargs - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def kernel(self): - return self._kernel - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def interaction_kernel(self): - return self._interaction_kernel - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def repeatpid(self): - return self._repeatpid - - def __del__(self): - if self.particledata is not None and isinstance(self.particledata, ParticleData): - del self.particledata - self.particledata = None - - @deprecated( - "Use iter(pset) instead, or just use the object in an iterator context (e.g. for p in pset: ...)." - ) # TODO: Remove 6 months after v3.1.0 (or 9 months; doesn't contribute to code debt) - def iterator(self): - return iter(self) - - def __iter__(self): - return iter(self.particledata) - - def __getattr__(self, name): - """ - Access a single property of all particles. - - Parameters - ---------- - name : str - Name of the property - """ - for v in self.particledata.ptype.variables: - if v.name == name: - return getattr(self.particledata, name) - if name in self.__dict__ and name[0] != "_": - return self.__dict__[name] - else: - return False - - def __getitem__(self, index): - """Get a single particle by index.""" - return self.particledata.get_single_by_index(index) - - @staticmethod - def lonlatdepth_dtype_from_field_interp_method(field): - if isinstance(field, NestedField): - for f in field: - if f.interp_method == "cgrid_velocity": - return np.float64 - else: - if field.interp_method == "cgrid_velocity": - return np.float64 - return np.float32 - - def cstruct(self): - cstruct = self.particledata.cstruct() - return cstruct - - @property - def ctypes_struct(self): - return self.cstruct() - - @property - def size(self): - # ==== to change at some point - len and size are different things ==== # - return len(self.particledata) - - @property - def pclass(self): - return self._pclass - - def __repr__(self): - return particleset_repr(self) - - def __len__(self): - return len(self.particledata) - - def __sizeof__(self): - return sys.getsizeof(self.particledata) - - def add(self, particles): - """Add particles to the ParticleSet. Note that this is an - incremental add, the particles will be added to the ParticleSet - on which this function is called. - - Parameters - ---------- - particles : - Another ParticleSet containing particles to add to this one. - - Returns - ------- - type - The current ParticleSet - - """ - if isinstance(particles, type(self)): - particles = particles.particledata - self.particledata += particles - # Adding particles invalidates the neighbor search structure. - self._dirty_neighbor = True - return self - - def __iadd__(self, particles): - """Add particles to the ParticleSet. - - Note that this is an incremental add, the particles will be added to the ParticleSet - on which this function is called. - - Parameters - ---------- - particles : - Another ParticleSet containing particles to add to this one. - - Returns - ------- - type - The current ParticleSet - """ - self.add(particles) - return self - - def remove_indices(self, indices): - """Method to remove particles from the ParticleSet, based on their `indices`.""" - # Removing particles invalidates the neighbor search structure. - self._dirty_neighbor = True - if type(indices) in [int, np.int32, np.intp]: - self.particledata.remove_single_by_index(indices) - else: - self.particledata.remove_multi_by_indices(indices) - - def remove_booleanvector(self, indices): - """Method to remove particles from the ParticleSet, based on an array of booleans.""" - # Removing particles invalidates the neighbor search structure. - self._dirty_neighbor = True - self.remove_indices(np.where(indices)[0]) - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def active_particles_mask(self, *args, **kwargs): - return self._active_particles_mask(*args, **kwargs) - - def _active_particles_mask(self, time, dt): - active_indices = (time - self.particledata.data["time"]) / dt >= 0 - non_err_indices = np.isin(self.particledata.data["state"], [StatusCode.Success, StatusCode.Evaluate]) - active_indices = np.logical_and(active_indices, non_err_indices) - self._active_particle_idx = np.where(active_indices)[0] - return active_indices - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def compute_neighbor_tree(self, *args, **kwargs): - return self._compute_neighbor_tree(*args, **kwargs) - - def _compute_neighbor_tree(self, time, dt): - active_mask = self._active_particles_mask(time, dt) - - self._values = np.vstack( - ( - self.particledata.data["depth"], - self.particledata.data["lat"], - self.particledata.data["lon"], - ) - ) - if self._dirty_neighbor: - self._neighbor_tree.rebuild(self._values, active_mask=active_mask) - self._dirty_neighbor = False - else: - self._neighbor_tree.update_values(self._values, new_active_mask=active_mask) - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def neighbors_by_index(self, *args, **kwargs): - return self._neighbors_by_index(*args, **kwargs) - - def _neighbors_by_index(self, particle_idx): - neighbor_idx, distances = self._neighbor_tree.find_neighbors_by_idx(particle_idx) - neighbor_idx = self._active_particle_idx[neighbor_idx] - mask = neighbor_idx != particle_idx - neighbor_idx = neighbor_idx[mask] - if "horiz_dist" in self.particledata._ptype.variables: - self.particledata.data["vert_dist"][neighbor_idx] = distances[0, mask] - self.particledata.data["horiz_dist"][neighbor_idx] = distances[1, mask] - return ParticleDataIterator(self.particledata, subset=neighbor_idx) - - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def neighbors_by_coor(self, *args, **kwargs): - return self._neighbors_by_coor(*args, **kwargs) - - def _neighbors_by_coor(self, coor): - neighbor_idx = self._neighbor_tree.find_neighbors_by_coor(coor) - neighbor_ids = self.particledata.data["id"][neighbor_idx] - return neighbor_ids - - # TODO: This method is only tested in tutorial notebook. Add unit test? - def populate_indices(self): - """Pre-populate guesses of particle xi/yi indices using a kdtree. - - This is only intended for curvilinear grids, where the initial index search - may be quite expensive. - """ - for i, grid in enumerate(self.fieldset.gridset.grids): - if not isinstance(grid, CurvilinearGrid): - continue - - tree_data = np.stack((grid.lon.flat, grid.lat.flat), axis=-1) - IN = np.all(~np.isnan(tree_data), axis=1) - tree = KDTree(tree_data[IN, :]) - # stack all the particle positions for a single query - pts = np.stack((self.particledata.data["lon"], self.particledata.data["lat"]), axis=-1) - # query datatype needs to match tree datatype - _, idx_nan = tree.query(pts.astype(tree_data.dtype)) - - idx = np.where(IN)[0][idx_nan] - yi, xi = np.unravel_index(idx, grid.lon.shape) - - self.particledata.data["xi"][:, i] = xi - self.particledata.data["yi"][:, i] = yi - - @classmethod - def from_list( - cls, fieldset, pclass, lon, lat, depth=None, time=None, repeatdt=None, lonlatdepth_dtype=None, **kwargs - ): - """Initialise the ParticleSet from lists of lon and lat. - - Parameters - ---------- - fieldset : - mod:`parcels.fieldset.FieldSet` object from which to sample velocity - pclass : parcels.particle.JITParticle or parcels.particle.ScipyParticle - Particle class. May be a particle class as defined in parcels, or a subclass defining a custom particle. - lon : - List of initial longitude values for particles - lat : - List of initial latitude values for particles - depth : - Optional list of initial depth values for particles. Default is 0m - time : - Optional list of start time values for particles. Default is fieldset.U.time[0] - repeatdt : - Optional interval (in seconds) on which to repeat the release of the ParticleSet (Default value = None) - lonlatdepth_dtype : - Floating precision for lon, lat, depth particle coordinates. - It is either np.float32 or np.float64. Default is np.float32 if fieldset.U.interp_method is 'linear' - and np.float64 if the interpolation method is 'cgrid_velocity' - Other Variables can be initialised using further arguments (e.g. v=... for a Variable named 'v') - **kwargs : - Keyword arguments passed to the particleset constructor. - """ - return cls( - fieldset=fieldset, - pclass=pclass, - lon=lon, - lat=lat, - depth=depth, - time=time, - repeatdt=repeatdt, - lonlatdepth_dtype=lonlatdepth_dtype, - **kwargs, - ) - - @classmethod - def from_line( - cls, - fieldset, - pclass, - start, - finish, - size, - depth=None, - time=None, - repeatdt=None, - lonlatdepth_dtype=None, - **kwargs, - ): - """Create a particleset in the shape of a line (according to a cartesian grid). - - Initialise the ParticleSet from start/finish coordinates with equidistant spacing - Note that this method uses simple numpy.linspace calls and does not take into account - great circles, so may not be a exact on a globe - - Parameters - ---------- - fieldset : - mod:`parcels.fieldset.FieldSet` object from which to sample velocity - pclass : parcels.particle.JITParticle or parcels.particle.ScipyParticle - Particle class. May be a particle class as defined in parcels, or a subclass defining a custom particle. - start : - Start point (longitude, latitude) for initialisation of particles on a straight line. - finish : - End point (longitude, latitude) for initialisation of particles on a straight line. - size : - Initial size of particle set - depth : - Optional list of initial depth values for particles. Default is 0m - time : - Optional start time value for particles. Default is fieldset.U.time[0] - repeatdt : - Optional interval (in seconds) on which to repeat the release of the ParticleSet (Default value = None) - lonlatdepth_dtype : - Floating precision for lon, lat, depth particle coordinates. - It is either np.float32 or np.float64. Default is np.float32 if fieldset.U.interp_method is 'linear' - and np.float64 if the interpolation method is 'cgrid_velocity' - """ - lon = np.linspace(start[0], finish[0], size) - lat = np.linspace(start[1], finish[1], size) - if type(depth) in [int, float]: - depth = [depth] * size - return cls( - fieldset=fieldset, - pclass=pclass, - lon=lon, - lat=lat, - depth=depth, - time=time, - repeatdt=repeatdt, - lonlatdepth_dtype=lonlatdepth_dtype, - **kwargs, - ) - - @classmethod - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def monte_carlo_sample(self, *args, **kwargs): - return self._monte_carlo_sample(*args, **kwargs) - - @classmethod - def _monte_carlo_sample(cls, start_field, size, mode="monte_carlo"): - """Converts a starting field into a monte-carlo sample of lons and lats. - - Parameters - ---------- - start_field : parcels.field.Field - mod:`parcels.fieldset.Field` object for initialising particles stochastically (horizontally) according to the presented density field. - size : - - mode : - (Default value = 'monte_carlo') - - Returns - ------- - list of float - A list of longitude values. - list of float - A list of latitude values. - """ - if mode == "monte_carlo": - data = start_field.data if isinstance(start_field.data, np.ndarray) else np.array(start_field.data) - if start_field.interp_method == "cgrid_tracer": - p_interior = np.squeeze(data[0, 1:, 1:]) - else: # if A-grid - d = data - p_interior = (d[0, :-1, :-1] + d[0, 1:, :-1] + d[0, :-1, 1:] + d[0, 1:, 1:]) / 4.0 - p_interior = np.where(d[0, :-1, :-1] == 0, 0, p_interior) - p_interior = np.where(d[0, 1:, :-1] == 0, 0, p_interior) - p_interior = np.where(d[0, 1:, 1:] == 0, 0, p_interior) - p_interior = np.where(d[0, :-1, 1:] == 0, 0, p_interior) - p = np.reshape(p_interior, (1, p_interior.size)) - inds = np.random.choice(p_interior.size, size, replace=True, p=p[0] / np.sum(p)) - xsi = np.random.uniform(size=len(inds)) - eta = np.random.uniform(size=len(inds)) - j, i = np.unravel_index(inds, p_interior.shape) - grid = start_field.grid - lon, lat = ([], []) - if grid._gtype in [GridType.RectilinearZGrid, GridType.RectilinearSGrid]: - lon = grid.lon[i] + xsi * (grid.lon[i + 1] - grid.lon[i]) - lat = grid.lat[j] + eta * (grid.lat[j + 1] - grid.lat[j]) - else: - lons = np.array([grid.lon[j, i], grid.lon[j, i + 1], grid.lon[j + 1, i + 1], grid.lon[j + 1, i]]) - if grid.mesh == "spherical": - lons[1:] = np.where(lons[1:] - lons[0] > 180, lons[1:] - 360, lons[1:]) - lons[1:] = np.where(-lons[1:] + lons[0] > 180, lons[1:] + 360, lons[1:]) - lon = ( - (1 - xsi) * (1 - eta) * lons[0] - + xsi * (1 - eta) * lons[1] - + xsi * eta * lons[2] - + (1 - xsi) * eta * lons[3] - ) - lat = ( - (1 - xsi) * (1 - eta) * grid.lat[j, i] - + xsi * (1 - eta) * grid.lat[j, i + 1] - + xsi * eta * grid.lat[j + 1, i + 1] - + (1 - xsi) * eta * grid.lat[j + 1, i] - ) - return list(lat), list(lon) - else: - raise NotImplementedError(f'Mode {mode} not implemented. Please use "monte carlo" algorithm instead.') - - @classmethod - def from_field( - cls, - fieldset, - pclass, - start_field, - size, - mode="monte_carlo", - depth=None, - time=None, - repeatdt=None, - lonlatdepth_dtype=None, - ): - """Initialise the ParticleSet randomly drawn according to distribution from a field. - - Parameters - ---------- - fieldset : parcels.fieldset.FieldSet - mod:`parcels.fieldset.FieldSet` object from which to sample velocity - pclass : parcels.particle.JITParticle or parcels.particle.ScipyParticle - Particle class. May be a particle class as defined in parcels, or a subclass defining a custom particle. - start_field : parcels.field.Field - Field for initialising particles stochastically (horizontally) according to the presented density field. - size : - Initial size of particle set - mode : - Type of random sampling. Currently only 'monte_carlo' is implemented (Default value = 'monte_carlo') - depth : - Optional list of initial depth values for particles. Default is 0m - time : - Optional start time value for particles. Default is fieldset.U.time[0] - repeatdt : - Optional interval (in seconds) on which to repeat the release of the ParticleSet (Default value = None) - lonlatdepth_dtype : - Floating precision for lon, lat, depth particle coordinates. - It is either np.float32 or np.float64. Default is np.float32 if fieldset.U.interp_method is 'linear' - and np.float64 if the interpolation method is 'cgrid_velocity' - """ - lat, lon = cls._monte_carlo_sample(start_field, size, mode) - - return cls( - fieldset=fieldset, - pclass=pclass, - lon=lon, - lat=lat, - depth=depth, - time=time, - lonlatdepth_dtype=lonlatdepth_dtype, - repeatdt=repeatdt, - ) - - @classmethod - def from_particlefile( - cls, fieldset, pclass, filename, restart=True, restarttime=None, repeatdt=None, lonlatdepth_dtype=None, **kwargs - ): - """Initialise the ParticleSet from a zarr ParticleFile. - This creates a new ParticleSet based on locations of all particles written - in a zarr ParticleFile at a certain time. Particle IDs are preserved if restart=True - - Parameters - ---------- - fieldset : parcels.fieldset.FieldSet - mod:`parcels.fieldset.FieldSet` object from which to sample velocity - pclass : parcels.particle.JITParticle or parcels.particle.ScipyParticle - Particle class. May be a particle class as defined in parcels, or a subclass defining a custom particle. - filename : str - Name of the particlefile from which to read initial conditions - restart : bool - BSignal if pset is used for a restart (default is True). - In that case, Particle IDs are preserved. - restarttime : - time at which the Particles will be restarted. Default is the last time written. - Alternatively, restarttime could be a time value (including np.datetime64) or - a callable function such as np.nanmin. The last is useful when running with dt < 0. - repeatdt : datetime.timedelta or float, optional - Optional interval on which to repeat the release of the ParticleSet. Either timedelta object, or float in seconds. - lonlatdepth_dtype : - Floating precision for lon, lat, depth particle coordinates. - It is either np.float32 or np.float64. Default is np.float32 if fieldset.U.interp_method is 'linear' - and np.float64 if the interpolation method is 'cgrid_velocity' - **kwargs : - Keyword arguments passed to the particleset constructor. - """ - if repeatdt is not None: - warnings.warn( - f"Note that the `repeatdt` argument is not retained from {filename}, and that " - "setting a new repeatdt will start particles from the _new_ particle " - "locations.", - ParticleSetWarning, - stacklevel=2, - ) - - pfile = xr.open_zarr(str(filename)) - pfile_vars = [v for v in pfile.data_vars] - - vars = {} - to_write = {} - for v in pclass.getPType().variables: - if v.name in pfile_vars: - vars[v.name] = np.ma.filled(pfile.variables[v.name], np.nan) - elif ( - v.name - not in [ - "xi", - "yi", - "zi", - "ti", - "dt", - "depth", - "id", - "obs_written", - "state", - "lon_nextloop", - "lat_nextloop", - "depth_nextloop", - "time_nextloop", - ] - and v.to_write - ): - raise RuntimeError(f"Variable {v.name} is in pclass but not in the particlefile") - to_write[v.name] = v.to_write - vars["depth"] = np.ma.filled(pfile.variables["z"], np.nan) - vars["id"] = np.ma.filled(pfile.variables["trajectory"], np.nan) - - for v in ["lon", "lat", "depth", "time"]: - to_write[v] = True - - if isinstance(vars["time"][0, 0], np.timedelta64): - vars["time"] = np.array([t / np.timedelta64(1, "s") for t in vars["time"]]) - - if restarttime is None: - restarttime = np.nanmax(vars["time"]) - elif callable(restarttime): - restarttime = restarttime(vars["time"]) - else: - restarttime = restarttime - - inds = np.where(vars["time"] == restarttime) - for v in vars: - if to_write[v] is True: - vars[v] = vars[v][inds] - elif to_write[v] == "once": - vars[v] = vars[v][inds[0]] - if v not in ["lon", "lat", "depth", "time", "id"]: - kwargs[v] = vars[v] - - if restart: - pclass.setLastID(0) # reset to zero offset - else: - vars["id"] = None - - return cls( - fieldset=fieldset, - pclass=pclass, - lon=vars["lon"], - lat=vars["lat"], - depth=vars["depth"], - time=vars["time"], - pid_orig=vars["id"], - lonlatdepth_dtype=lonlatdepth_dtype, - repeatdt=repeatdt, - **kwargs, - ) - - def Kernel(self, pyfunc, c_include="", delete_cfiles=True): - """Wrapper method to convert a `pyfunc` into a :class:`parcels.kernel.Kernel` object. - - Conversion is based on `fieldset` and `ptype` of the ParticleSet. - - Parameters - ---------- - pyfunc : function or list of functions - Python function to convert into kernel. If a list of functions is provided, - the functions will be converted to kernels and combined into a single kernel. - delete_cfiles : bool - Whether to delete the C-files after compilation in JIT mode (default is True) - pyfunc : - - c_include : - (Default value = "") - """ - if isinstance(pyfunc, list): - return Kernel.from_list( - self.fieldset, - self.particledata.ptype, - pyfunc, - c_include=c_include, - delete_cfiles=delete_cfiles, - ) - return Kernel( - self.fieldset, - self.particledata.ptype, - pyfunc=pyfunc, - c_include=c_include, - delete_cfiles=delete_cfiles, - ) - - def InteractionKernel(self, pyfunc_inter, delete_cfiles=True): - if pyfunc_inter is None: - return None - return InteractionKernel( - self.fieldset, self.particledata.ptype, pyfunc=pyfunc_inter, delete_cfiles=delete_cfiles - ) - - def ParticleFile(self, *args, **kwargs): - """Wrapper method to initialise a :class:`parcels.particlefile.ParticleFile` object from the ParticleSet.""" - return ParticleFile(*args, particleset=self, **kwargs) - - def data_indices(self, variable_name, compare_values, invert=False): - """Get the indices of all particles where the value of `variable_name` equals (one of) `compare_values`. - - Parameters - ---------- - variable_name : str - Name of the variable to check. - compare_values : - Value or list of values to compare to. - invert : - Whether to invert the selection. I.e., when True, - return all indices that do not equal (one of) - `compare_values`. (Default value = False) - - Returns - ------- - np.ndarray - Numpy array of indices that satisfy the test. - - """ - compare_values = ( - np.array([compare_values]) if type(compare_values) not in [list, dict, np.ndarray] else compare_values - ) - return np.where(np.isin(self.particledata.data[variable_name], compare_values, invert=invert))[0] - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def error_particles(self): - return self._error_particles - - @property - def _error_particles(self): - """Get an iterator over all particles that are in an error state. - - Returns - ------- - iterator - ParticleDataIterator over error particles. - """ - error_indices = self.data_indices("state", [StatusCode.Success, StatusCode.Evaluate], invert=True) - return ParticleDataIterator(self.particledata, subset=error_indices) - - @property - @deprecated_made_private # TODO: Remove 6 months after v3.1.0 - def num_error_particles(self): - return self._num_error_particles - - @property - def _num_error_particles(self): - """Get the number of particles that are in an error state. - - Returns - ------- - int - Number of error particles. - """ - return np.sum(np.isin(self.particledata.data["state"], [StatusCode.Success, StatusCode.Evaluate], invert=True)) - - def set_variable_write_status(self, var, write_status): - """Method to set the write status of a Variable. - - Parameters - ---------- - var : - Name of the variable (string) - write_status : - Write status of the variable (True, False or 'once') - """ - self.particledata.set_variable_write_status(var, write_status) - - def execute( - self, - pyfunc=AdvectionRK4, - pyfunc_inter=None, - endtime=None, - runtime: float | timedelta | np.timedelta64 | None = None, - dt: float | timedelta | np.timedelta64 = 1.0, - output_file=None, - verbose_progress=True, - postIterationCallbacks=None, - callbackdt: float | timedelta | np.timedelta64 | None = None, - delete_cfiles: bool = True, - ): - """Execute a given kernel function over the particle set for multiple timesteps. - - Optionally also provide sub-timestepping - for particle output. - - Parameters - ---------- - pyfunc : - Kernel function to execute. This can be the name of a - defined Python function or a :class:`parcels.kernel.Kernel` object. - Kernels can be concatenated using the + operator (Default value = AdvectionRK4) - endtime : - End time for the timestepping loop. - It is either a datetime object or a positive double. (Default value = None) - runtime : - Length of the timestepping loop. Use instead of endtime. - It is either a timedelta object or a positive double. (Default value = None) - dt : - Timestep interval (in seconds) to be passed to the kernel. - It is either a timedelta object or a double. - Use a negative value for a backward-in-time simulation. (Default value = 1 second) - output_file : - mod:`parcels.particlefile.ParticleFile` object for particle output (Default value = None) - verbose_progress : bool - Boolean for providing a progress bar for the kernel execution loop. (Default value = True) - postIterationCallbacks : - Optional, array of functions that are to be called after each iteration (post-process, non-Kernel) (Default value = None) - callbackdt : - Optional, in conjecture with 'postIterationCallbacks', timestep interval to (latest) interrupt the running kernel and invoke post-iteration callbacks from 'postIterationCallbacks' (Default value = None) - pyfunc_inter : - (Default value = None) - delete_cfiles : bool - Whether to delete the C-files after compilation in JIT mode (default is True) - - Notes - ----- - ``ParticleSet.execute()`` acts as the main entrypoint for simulations, and provides the simulation time-loop. This method encapsulates the logic controlling the switching between kernel execution (where control in handed to C in JIT mode), output file writing, reading in fields for new timesteps, adding new particles to the simulation domain, stopping the simulation, and executing custom functions (``postIterationCallbacks`` provided by the user). - """ - # check if particleset is empty. If so, return immediately - if len(self) == 0: - return - - # check if pyfunc has changed since last compile. If so, recompile - if self._kernel is None or (self._kernel.pyfunc is not pyfunc and self._kernel is not pyfunc): - # Generate and store Kernel - if isinstance(pyfunc, Kernel): - self._kernel = pyfunc - else: - self._kernel = self.Kernel(pyfunc, delete_cfiles=delete_cfiles) - # Prepare JIT kernel execution - if self.particledata.ptype.uses_jit: - self._kernel.remove_lib() - cppargs = ["-DDOUBLE_COORD_VARIABLES"] if self.particledata.lonlatdepth_dtype else None - self._kernel.compile( - compiler=GNUCompiler(cppargs=cppargs, incdirs=[os.path.join(get_package_dir(), "include"), "."]) - ) - self._kernel.load_lib() - if output_file: - output_file.metadata["parcels_kernels"] = self._kernel.name - - # Set up the interaction kernel(s) if not set and given. - if self._interaction_kernel is None and pyfunc_inter is not None: - if isinstance(pyfunc_inter, InteractionKernel): - self._interaction_kernel = pyfunc_inter - else: - self._interaction_kernel = self.InteractionKernel(pyfunc_inter, delete_cfiles=delete_cfiles) - - # Convert all time variables to seconds - if isinstance(endtime, timedelta): - raise TypeError("endtime must be either a datetime or a double") - if isinstance(endtime, datetime): - endtime = np.datetime64(endtime) - elif isinstance(endtime, cftime.datetime): - endtime = self.time_origin.reltime(endtime) - if isinstance(endtime, np.datetime64): - if self.time_origin.calendar is None: - raise NotImplementedError("If fieldset.time_origin is not a date, execution endtime must be a double") - endtime = self.time_origin.reltime(endtime) - - if runtime is not None: - runtime = timedelta_to_float(runtime) - - dt = timedelta_to_float(dt) - - if abs(dt) <= 1e-6: - raise ValueError("Time step dt is too small") - if (dt * 1e6) % 1 != 0: - raise ValueError("Output interval should not have finer precision than 1e-6 s") - outputdt = timedelta_to_float(output_file.outputdt) if output_file else np.inf - - if callbackdt is not None: - callbackdt = timedelta_to_float(callbackdt) - - assert runtime is None or runtime >= 0, "runtime must be positive" - assert outputdt is None or outputdt >= 0, "outputdt must be positive" - - if runtime is not None and endtime is not None: - raise RuntimeError("Only one of (endtime, runtime) can be specified") - - mintime, maxtime = self.fieldset.gridset.dimrange("time_full") - - default_release_time = mintime if dt >= 0 else maxtime - if np.any(np.isnan(self.particledata.data["time"])): - self.particledata.data["time"][np.isnan(self.particledata.data["time"])] = default_release_time - self.particledata.data["time_nextloop"][np.isnan(self.particledata.data["time_nextloop"])] = ( - default_release_time - ) - min_rt = np.min(self.particledata.data["time_nextloop"]) - max_rt = np.max(self.particledata.data["time_nextloop"]) - - # Derive starttime and endtime from arguments or fieldset defaults - starttime = min_rt if dt >= 0 else max_rt - if self.repeatdt is not None and self._repeat_starttime is None: - self._repeat_starttime = starttime - if runtime is not None: - endtime = starttime + runtime * np.sign(dt) - elif endtime is None: - mintime, maxtime = self.fieldset.gridset.dimrange("time_full") - endtime = maxtime if dt >= 0 else mintime - - if (abs(endtime - starttime) < 1e-5 or runtime == 0) and dt == 0: - raise RuntimeError( - "dt and runtime are zero, or endtime is equal to Particle.time. " - "ParticleSet.execute() will not do anything." - ) - - if np.isfinite(outputdt): - _warn_outputdt_release_desync(outputdt, starttime, self.particledata.data["time_nextloop"]) - - self.particledata._data["dt"][:] = dt - - if callbackdt is None: - interupt_dts = [np.inf, outputdt] - if self.repeatdt is not None: - interupt_dts.append(self.repeatdt) - callbackdt = np.min(np.array(interupt_dts)) - - # Set up pbar - if output_file: - logger.info(f"Output files are stored in {output_file.fname}.") - - if verbose_progress: - pbar = tqdm(total=abs(endtime - starttime), file=sys.stdout) - - # Set up variables for first iteration - if self.repeatdt: - next_prelease = self._repeat_starttime + ( - abs(starttime - self._repeat_starttime) // self.repeatdt + 1 - ) * self.repeatdt * np.sign(dt) - else: - next_prelease = np.inf if dt > 0 else -np.inf - if output_file: - next_output = starttime + dt - else: - next_output = np.inf * np.sign(dt) - next_callback = starttime + callbackdt * np.sign(dt) - - tol = 1e-12 - time = starttime - - while (time < endtime and dt > 0) or (time > endtime and dt < 0): - # Check if we can fast-forward to the next time needed for the particles - if dt > 0: - skip_kernel = True if min(self.time) > (time + dt) else False - else: - skip_kernel = True if max(self.time) < (time + dt) else False - - time_at_startofloop = time - - next_input = self.fieldset.computeTimeChunk(time, dt) - - # Define next_time (the timestamp when the execution needs to be handed back to python) - if dt > 0: - next_time = min(next_prelease, next_input, next_output, next_callback, endtime) - else: - next_time = max(next_prelease, next_input, next_output, next_callback, endtime) - - # If we don't perform interaction, only execute the normal kernel efficiently. - if self._interaction_kernel is None: - if not skip_kernel: - res = self._kernel.execute(self, endtime=next_time, dt=dt) - if res == StatusCode.StopAllExecution: - return StatusCode.StopAllExecution - # Interaction: interleave the interaction and non-interaction kernel for each time step. - # E.g. Normal -> Inter -> Normal -> Inter if endtime-time == 2*dt - else: - cur_time = time - while (cur_time < next_time and dt > 0) or (cur_time > next_time and dt < 0): - if dt > 0: - cur_end_time = min(cur_time + dt, next_time) - else: - cur_end_time = max(cur_time + dt, next_time) - self._kernel.execute(self, endtime=cur_end_time, dt=dt) - self._interaction_kernel.execute(self, endtime=cur_end_time, dt=dt) - cur_time += dt - # End of interaction specific code - time = next_time - - # Check for empty ParticleSet - if np.isinf(next_prelease) and len(self) == 0: - return StatusCode.StopAllExecution - - if abs(time - next_output) < tol: - for fld in self.fieldset.get_fields(): - if hasattr(fld, "to_write") and fld.to_write: - if fld.grid.tdim > 1: - raise RuntimeError( - "Field writing during execution only works for Fields with one snapshot in time" - ) - fldfilename = str(output_file.fname).replace(".zarr", f"_{fld.to_write:04d}") - fld.write(fldfilename) - fld.to_write += 1 - - if abs(time - next_output) < tol: - if output_file: - if output_file._is_analytical: # output analytical solution at later time - output_file.write_latest_locations(self, time) - else: - output_file.write(self, time_at_startofloop) - if np.isfinite(outputdt): - next_output += outputdt * np.sign(dt) - - # ==== insert post-process here to also allow for memory clean-up via external func ==== # - if abs(time - next_callback) < tol: - if postIterationCallbacks is not None: - for extFunc in postIterationCallbacks: - extFunc() - next_callback += callbackdt * np.sign(dt) - - if abs(time - next_prelease) < tol: - pset_new = self.__class__( - fieldset=self.fieldset, - time=time, - lon=self._repeatlon, - lat=self._repeatlat, - depth=self._repeatdepth, - pclass=self._repeatpclass, - lonlatdepth_dtype=self.particledata.lonlatdepth_dtype, - partition_function=False, - pid_orig=self._repeatpid, - **self._repeatkwargs, - ) - for p in pset_new: - p.dt = dt - self.add(pset_new) - next_prelease += self.repeatdt * np.sign(dt) - - if time != endtime: - next_input = self.fieldset.computeTimeChunk(time, dt) - if verbose_progress: - pbar.update(abs(time - time_at_startofloop)) - - if verbose_progress: - pbar.close() - - -def _warn_outputdt_release_desync(outputdt: float, starttime: float, release_times: Iterable[float]): - """Gives the user a warning if the release time isn't a multiple of outputdt.""" - if any((np.isfinite(t) and (t - starttime) % outputdt != 0) for t in release_times): - warnings.warn( - "Some of the particles have a start time difference that is not a multiple of outputdt. " - "This could cause the first output of some of the particles that start later " - "in the simulation to be at a different time than expected.", - ParticleSetWarning, - stacklevel=2, - ) - - -def _warn_particle_times_outside_fieldset_time_bounds(release_times: np.ndarray, time_full: np.ndarray): - if np.any(release_times): - if np.any(release_times < time_full[0]): - warnings.warn( - "Some particles are set to be released before the fieldset's first time and allow_time_extrapolation is set to False.", - ParticleSetWarning, - stacklevel=2, - ) - if np.any(release_times > time_full[-1]): - warnings.warn( - "Some particles are set to be released after the fieldset's last time and allow_time_extrapolation is set to False.", - ParticleSetWarning, - stacklevel=2, - ) diff --git a/parcels/rng.py b/parcels/rng.py deleted file mode 100644 index 868f86bf2..000000000 --- a/parcels/rng.py +++ /dev/null @@ -1,194 +0,0 @@ -import _ctypes -import os -import sys -import uuid -from ctypes import c_float, c_int - -import numpy.ctypeslib as npct - -from parcels.compilation.codecompiler import GNUCompiler -from parcels.tools import get_cache_dir, get_package_dir -from parcels.tools.loggers import logger - -__all__ = ["expovariate", "normalvariate", "randint", "random", "seed", "uniform", "vonmisesvariate"] - - -class RandomC: - stmt_import = """#include "parcels.h"\n\n""" - fnct_seed = """ -extern void pcls_seed(int seed){ - parcels_seed(seed); -} -""" - fnct_random = """ -extern float pcls_random(){ - return parcels_random(); -} -""" - fnct_uniform = """ -extern float pcls_uniform(float low, float high){ - return parcels_uniform(low, high); -} -""" - fnct_randint = """ -extern int pcls_randint(int low, int high){ - return parcels_randint(low, high); -} -""" - fnct_normalvariate = """ -extern float pcls_normalvariate(float loc, float scale){ - return parcels_normalvariate(loc, scale); -} -""" - fnct_expovariate = """ -extern float pcls_expovariate(float lamb){ - return parcels_expovariate(lamb); -} -""" - fnct_vonmisesvariate = """ -extern float pcls_vonmisesvariate(float mu, float kappa){ - return parcels_vonmisesvariate(mu, kappa); -} -""" - _lib = None - ccode = None - src_file = None - lib_file = None - log_file = None - - def __init__(self): - self._lib = None - self.ccode = "" - self.ccode += self.stmt_import - self.ccode += self.fnct_seed - self.ccode += self.fnct_random - self.ccode += self.fnct_uniform - self.ccode += self.fnct_randint - self.ccode += self.fnct_normalvariate - self.ccode += self.fnct_expovariate - self.ccode += self.fnct_vonmisesvariate - self._loaded = False - self.compile() - self.load_lib() - - def __del__(self): - self.unload_lib() - self.remove_lib() - - def unload_lib(self): - # Unload the currently loaded dynamic linked library to be secure - if self._lib is not None and self._loaded and _ctypes is not None: - _ctypes.FreeLibrary(self._lib._handle) if sys.platform == "win32" else _ctypes.dlclose(self._lib._handle) - del self._lib - self._lib = None - self._loaded = False - - def load_lib(self): - self._lib = npct.load_library(self.lib_file, ".") - self._loaded = True - - def remove_lib(self): - # If file already exists, pull new names. This is necessary on a Windows machine, because - # Python's ctype does not deal in any sort of manner well with dynamic linked libraries on this OS. - if self._lib is not None and self._loaded and _ctypes is not None and os.path.isfile(self.lib_file): - [os.remove(s) for s in [self.src_file, self.lib_file, self.log_file]] - - def compile(self, compiler=None): - if self.src_file is None or self.lib_file is None or self.log_file is None: - basename = f"parcels_random_{uuid.uuid4()}" - lib_filename = "lib" + basename - basepath = os.path.join(get_cache_dir(), f"{basename}") - libpath = os.path.join(get_cache_dir(), f"{lib_filename}") - self.src_file = f"{basepath}.c" - self.lib_file = f"{libpath}.so" - self.log_file = f"{basepath}.log" - ccompiler = compiler - if ccompiler is None: - cppargs = [] - incdirs = [os.path.join(get_package_dir(), "include")] - ccompiler = GNUCompiler(cppargs=cppargs, incdirs=incdirs) - if self._lib is None: - with open(self.src_file, "w+") as f: - f.write(self.ccode) - ccompiler.compile(self.src_file, self.lib_file, self.log_file) - logger.info(f"Compiled ParcelsRandom ==> {self.src_file}") - - @property - def lib(self): - if self.src_file is None or self.lib_file is None or self.log_file is None: - self.compile() - if self._lib is None or not self._loaded: - self.load_lib() - # self._lib = npct.load_library(self.lib_file, '.') - return self._lib - - -_parcels_random_ccodeconverter = None - - -def _assign_parcels_random_ccodeconverter(): - global _parcels_random_ccodeconverter - if _parcels_random_ccodeconverter is None: - _parcels_random_ccodeconverter = RandomC() - - -def seed(seed): - """Sets the seed for parcels internal RNG.""" - _assign_parcels_random_ccodeconverter() - _parcels_random_ccodeconverter.lib.pcls_seed(c_int(seed)) - - -def random(): - """Returns a random float between 0.0 and 1.0.""" - _assign_parcels_random_ccodeconverter() - rnd = _parcels_random_ccodeconverter.lib.pcls_random - rnd.argtype = [] - rnd.restype = c_float - return rnd() - - -def uniform(low, high): - """Returns a random float between `low` and `high`.""" - _assign_parcels_random_ccodeconverter() - rnd = _parcels_random_ccodeconverter.lib.pcls_uniform - rnd.argtype = [c_float, c_float] - rnd.restype = c_float - return rnd(c_float(low), c_float(high)) - - -def randint(low, high): - """Returns a random int between `low` and `high`.""" - _assign_parcels_random_ccodeconverter() - rnd = _parcels_random_ccodeconverter.lib.pcls_randint - rnd.argtype = [c_int, c_int] - rnd.restype = c_int - return rnd(c_int(low), c_int(high)) - - -def normalvariate(loc, scale): - """Returns a random float on normal distribution with mean `loc` and width `scale`.""" - _assign_parcels_random_ccodeconverter() - rnd = _parcels_random_ccodeconverter.lib.pcls_normalvariate - rnd.argtype = [c_float, c_float] - rnd.restype = c_float - return rnd(c_float(loc), c_float(scale)) - - -def expovariate(lamb): - """Returns a random float of an exponential distribution with parameter lamb.""" - _assign_parcels_random_ccodeconverter() - rnd = _parcels_random_ccodeconverter.lib.pcls_expovariate - rnd.argtype = c_float - rnd.restype = c_float - return rnd(c_float(lamb)) - - -def vonmisesvariate(mu, kappa): - """Returns a random float of a Von Mises distribution - with mean angle mu and concentration parameter kappa. - """ - _assign_parcels_random_ccodeconverter() - rnd = _parcels_random_ccodeconverter.lib.pcls_vonmisesvariate - rnd.argtype = [c_float, c_float] - rnd.restype = c_float - return rnd(c_float(mu), c_float(kappa)) diff --git a/parcels/tools/__init__.py b/parcels/tools/__init__.py deleted file mode 100644 index 5a735ed00..000000000 --- a/parcels/tools/__init__.py +++ /dev/null @@ -1,8 +0,0 @@ -from .converters import * -from .exampledata_utils import * -from .global_statics import * -from .interpolation_utils import * -from .loggers import * -from .statuscodes import * -from .timer import * -from .warnings import * diff --git a/parcels/tools/_helpers.py b/parcels/tools/_helpers.py deleted file mode 100644 index 8701f58fe..000000000 --- a/parcels/tools/_helpers.py +++ /dev/null @@ -1,155 +0,0 @@ -"""Internal helpers for Parcels.""" - -from __future__ import annotations - -import functools -import textwrap -import warnings -from collections.abc import Callable -from datetime import timedelta -from typing import TYPE_CHECKING, Any - -import numpy as np - -if TYPE_CHECKING: - from parcels import Field, FieldSet, ParticleSet - -PACKAGE = "Parcels" - - -def deprecated(msg: str = "") -> Callable: - """Decorator marking a function as being deprecated - - Parameters - ---------- - msg : str, optional - Custom message to append to the deprecation warning. - - Examples - -------- - ``` - @deprecated("Please use `another_function` instead") - def some_old_function(x, y): - return x + y - - @deprecated() - def some_other_old_function(x, y): - return x + y - ``` - """ - if msg: - msg = " " + msg - - def decorator(func): - @functools.wraps(func) - def wrapper(*args, **kwargs): - msg_formatted = ( - f"`{func.__qualname__}` is deprecated and will be removed in a future release of {PACKAGE}.{msg}" - ) - - warnings.warn(msg_formatted, category=DeprecationWarning, stacklevel=3) - return func(*args, **kwargs) - - patch_docstring(wrapper, f"\n\n.. deprecated:: {msg}") - return wrapper - - return decorator - - -def deprecated_made_private(func: Callable) -> Callable: - return deprecated( - "It has moved to the internal API as it is not expected to be directly used by " - "the end-user. If you feel that you use this code directly in your scripts, please " - "comment on our tracking issue at https://github.com/OceanParcels/Parcels/issues/1695.", - )(func) - - -def patch_docstring(obj: Callable, extra: str) -> None: - obj.__doc__ = f"{obj.__doc__ or ''}{extra}".strip() - - -def field_repr(field: Field) -> str: - """Return a pretty repr for Field""" - out = f"""<{type(field).__name__}> - name : {field.name!r} - grid : {field.grid!r} - extrapolate time: {field.allow_time_extrapolation!r} - time_periodic : {field.time_periodic!r} - gridindexingtype: {field.gridindexingtype!r} - to_write : {field.to_write!r} -""" - return textwrap.dedent(out).strip() - - -def _format_list_items_multiline(items: list[str], level: int = 1) -> str: - """Given a list of strings, formats them across multiple lines. - - Uses indentation levels of 4 spaces provided by ``level``. - - Example - ------- - >>> output = _format_list_items_multiline(["item1", "item2", "item3"], 4) - >>> f"my_items: {output}" - my_items: [ - item1, - item2, - item3, - ] - """ - if len(items) == 0: - return "[]" - - assert level >= 1, "Indentation level >=1 supported" - indentation_str = level * 4 * " " - indentation_str_end = (level - 1) * 4 * " " - - items_str = ",\n".join([textwrap.indent(i, indentation_str) for i in items]) - return f"[\n{items_str}\n{indentation_str_end}]" - - -def particleset_repr(pset: ParticleSet) -> str: - """Return a pretty repr for ParticleSet""" - if len(pset) < 10: - particles = [repr(p) for p in pset] - else: - particles = [repr(pset[i]) for i in range(7)] + ["..."] - - out = f"""<{type(pset).__name__}> - fieldset : -{textwrap.indent(repr(pset.fieldset), " " * 8)} - pclass : {pset.pclass} - repeatdt : {pset.repeatdt} - # particles: {len(pset)} - particles : {_format_list_items_multiline(particles, level=2)} -""" - return textwrap.dedent(out).strip() - - -def fieldset_repr(fieldset: FieldSet) -> str: - """Return a pretty repr for FieldSet""" - fields_repr = "\n".join([repr(f) for f in fieldset.get_fields()]) - - out = f"""<{type(fieldset).__name__}> - fields: -{textwrap.indent(fields_repr, 8 * " ")} -""" - return textwrap.dedent(out).strip() - - -def default_repr(obj: Any): - if is_builtin_object(obj): - return repr(obj) - return object.__repr__(obj) - - -def is_builtin_object(obj): - return obj.__class__.__module__ == "builtins" - - -def timedelta_to_float(dt: float | timedelta | np.timedelta64) -> float: - """Convert a timedelta to a float in seconds.""" - if isinstance(dt, timedelta): - return dt.total_seconds() - if isinstance(dt, np.timedelta64): - return float(dt / np.timedelta64(1, "s")) - return float(dt) diff --git a/parcels/tools/converters.py b/parcels/tools/converters.py deleted file mode 100644 index bc2dec2e8..000000000 --- a/parcels/tools/converters.py +++ /dev/null @@ -1,284 +0,0 @@ -from __future__ import annotations - -import inspect -from datetime import timedelta -from math import cos, pi - -import cftime -import numpy as np -import numpy.typing as npt -import xarray as xr - -__all__ = [ - "Geographic", - "GeographicPolar", - "GeographicPolarSquare", - "GeographicSquare", - "TimeConverter", - "UnitConverter", - "convert_to_flat_array", - "convert_xarray_time_units", - "unitconverters_map", -] - - -def convert_to_flat_array(var: npt.ArrayLike) -> npt.NDArray: - """Convert lists and single integers/floats to one-dimensional numpy arrays - - Parameters - ---------- - var : Array - list or numeric to convert to a one-dimensional numpy array - """ - return np.array(var).flatten() - - -def _get_cftime_datetimes() -> list[str]: - # Is there a more elegant way to parse these from cftime? - cftime_calendars = tuple(x[1].__name__ for x in inspect.getmembers(cftime._cftime, inspect.isclass)) - cftime_datetime_names = [ca for ca in cftime_calendars if "Datetime" in ca] - return cftime_datetime_names - - -def _get_cftime_calendars() -> list[str]: - return [getattr(cftime, cf_datetime)(1990, 1, 1).calendar for cf_datetime in _get_cftime_datetimes()] - - -class TimeConverter: - """Converter class for dates with different calendars in FieldSets - - Parameters - ---------- - time_origin : float, integer, numpy.datetime64 or cftime.DatetimeNoLeap - time origin of the class. - """ - - def __init__(self, time_origin: float | np.datetime64 | np.timedelta64 | cftime.datetime = 0): - self.time_origin = time_origin - self.calendar: str | None = None - if isinstance(time_origin, np.datetime64): - self.calendar = "np_datetime64" - elif isinstance(time_origin, np.timedelta64): - self.calendar = "np_timedelta64" - elif isinstance(time_origin, cftime.datetime): - self.calendar = time_origin.calendar - - def reltime(self, time: TimeConverter | np.datetime64 | np.timedelta64 | cftime.datetime) -> float | npt.NDArray: - """Method to compute the difference, in seconds, between a time and the time_origin - of the TimeConverter - - Parameters - ---------- - time : - - - Returns - ------- - type - time - self.time_origin - - """ - time = time.time_origin if isinstance(time, TimeConverter) else time - if self.calendar in ["np_datetime64", "np_timedelta64"]: - return (time - self.time_origin) / np.timedelta64(1, "s") # type: ignore - elif self.calendar in _get_cftime_calendars(): - if isinstance(time, (list, np.ndarray)): - try: - return np.array([(t - self.time_origin).total_seconds() for t in time]) # type: ignore - except ValueError: - raise ValueError( - f"Cannot subtract 'time' (a {type(time)} object) from a {self.calendar} calendar.\n" - f"Provide 'time' as a {type(self.time_origin)} object?" - ) - else: - try: - return (time - self.time_origin).total_seconds() # type: ignore - except ValueError: - raise ValueError( - f"Cannot subtract 'time' (a {type(time)} object) from a {self.calendar} calendar.\n" - f"Provide 'time' as a {type(self.time_origin)} object?" - ) - elif self.calendar is None: - return time - self.time_origin # type: ignore - else: - raise RuntimeError(f"Calendar {self.calendar} not implemented in TimeConverter") - - def fulltime(self, time): - """Method to convert a time difference in seconds to a date, based on the time_origin - - Parameters - ---------- - time : - - - Returns - ------- - type - self.time_origin + time - - """ - time = time.time_origin if isinstance(time, TimeConverter) else time - if self.calendar in ["np_datetime64", "np_timedelta64"]: - if isinstance(time, (list, np.ndarray)): - return [self.time_origin + np.timedelta64(int(t), "s") for t in time] - else: - return self.time_origin + np.timedelta64(int(time), "s") - elif self.calendar in _get_cftime_calendars(): - return self.time_origin + timedelta(seconds=time) - elif self.calendar is None: - return self.time_origin + time - else: - raise RuntimeError(f"Calendar {self.calendar} not implemented in TimeConverter") - - def __repr__(self): - return f"{self.time_origin}" - - def __eq__(self, other): - other = other.time_origin if isinstance(other, TimeConverter) else other - return self.time_origin == other - - def __ne__(self, other): - other = other.time_origin if isinstance(other, TimeConverter) else other - if not isinstance(other, type(self.time_origin)): - return True - return self.time_origin != other - - def __gt__(self, other): - other = other.time_origin if isinstance(other, TimeConverter) else other - return self.time_origin > other - - def __lt__(self, other): - other = other.time_origin if isinstance(other, TimeConverter) else other - return self.time_origin < other - - def __ge__(self, other): - other = other.time_origin if isinstance(other, TimeConverter) else other - return self.time_origin >= other - - def __le__(self, other): - other = other.time_origin if isinstance(other, TimeConverter) else other - return self.time_origin <= other - - -class UnitConverter: - """Interface class for spatial unit conversion during field sampling that performs no conversion.""" - - source_unit: str | None = None - target_unit: str | None = None - - def to_target(self, value, z, y, x): - return value - - def ccode_to_target(self, z, y, x): - return "1.0" - - def to_source(self, value, z, y, x): - return value - - def ccode_to_source(self, z, y, x): - return "1.0" - - -class Geographic(UnitConverter): - """Unit converter from geometric to geographic coordinates (m to degree)""" - - source_unit = "m" - target_unit = "degree" - - def to_target(self, value, z, y, x): - return value / 1000.0 / 1.852 / 60.0 - - def to_source(self, value, z, y, x): - return value * 1000.0 * 1.852 * 60.0 - - def ccode_to_target(self, z, y, x): - return "(1.0 / (1000.0 * 1.852 * 60.0))" - - def ccode_to_source(self, z, y, x): - return "(1000.0 * 1.852 * 60.0)" - - -class GeographicPolar(UnitConverter): - """Unit converter from geometric to geographic coordinates (m to degree) - with a correction to account for narrower grid cells closer to the poles. - """ - - source_unit = "m" - target_unit = "degree" - - def to_target(self, value, z, y, x): - return value / 1000.0 / 1.852 / 60.0 / cos(y * pi / 180) - - def to_source(self, value, z, y, x): - return value * 1000.0 * 1.852 * 60.0 * cos(y * pi / 180) - - def ccode_to_target(self, z, y, x): - return f"(1.0 / (1000. * 1.852 * 60. * cos({y} * M_PI / 180)))" - - def ccode_to_source(self, z, y, x): - return f"(1000. * 1.852 * 60. * cos({y} * M_PI / 180))" - - -class GeographicSquare(UnitConverter): - """Square distance converter from geometric to geographic coordinates (m2 to degree2)""" - - source_unit = "m2" - target_unit = "degree2" - - def to_target(self, value, z, y, x): - return value / pow(1000.0 * 1.852 * 60.0, 2) - - def to_source(self, value, z, y, x): - return value * pow(1000.0 * 1.852 * 60.0, 2) - - def ccode_to_target(self, z, y, x): - return "pow(1.0 / (1000.0 * 1.852 * 60.0), 2)" - - def ccode_to_source(self, z, y, x): - return "pow((1000.0 * 1.852 * 60.0), 2)" - - -class GeographicPolarSquare(UnitConverter): - """Square distance converter from geometric to geographic coordinates (m2 to degree2) - with a correction to account for narrower grid cells closer to the poles. - """ - - source_unit = "m2" - target_unit = "degree2" - - def to_target(self, value, z, y, x): - return value / pow(1000.0 * 1.852 * 60.0 * cos(y * pi / 180), 2) - - def to_source(self, value, z, y, x): - return value * pow(1000.0 * 1.852 * 60.0 * cos(y * pi / 180), 2) - - def ccode_to_target(self, z, y, x): - return f"pow(1.0 / (1000. * 1.852 * 60. * cos({y} * M_PI / 180)), 2)" - - def ccode_to_source(self, z, y, x): - return f"pow((1000. * 1.852 * 60. * cos({y} * M_PI / 180)), 2)" - - -unitconverters_map = { - "U": GeographicPolar(), - "V": Geographic(), - "Kh_zonal": GeographicPolarSquare(), - "Kh_meridional": GeographicSquare(), -} - - -def convert_xarray_time_units(ds, time): - """Fixes DataArrays that have time.Unit instead of expected time.units""" - da = ds[time] if isinstance(ds, xr.Dataset) else ds - if "units" not in da.attrs and "Unit" in da.attrs: - da.attrs["units"] = da.attrs["Unit"] - da2 = xr.Dataset({time: da}) - try: - da2 = xr.decode_cf(da2) - except ValueError: - raise RuntimeError( - "Xarray could not convert the calendar. If you're using from_netcdf, " - "try using the timestamps keyword in the construction of your Field. " - "See also the tutorial at https://docs.oceanparcels.org/en/latest/examples/tutorial_timestamps.html" - ) - ds[time] = da2[time] diff --git a/parcels/tools/global_statics.py b/parcels/tools/global_statics.py deleted file mode 100644 index 317848786..000000000 --- a/parcels/tools/global_statics.py +++ /dev/null @@ -1,42 +0,0 @@ -import _ctypes -import os -import sys -from pathlib import Path -from tempfile import gettempdir -from typing import Literal - -USER_ID: int | Literal["tmp"] -try: - from os import getuid - - USER_ID = getuid() -except: - # Windows does not have getuid() - USER_ID = "tmp" - - -__all__ = ["cleanup_remove_files", "cleanup_unload_lib", "get_cache_dir", "get_package_dir"] - - -def cleanup_remove_files(lib_file, log_file): - if os.path.isfile(lib_file): - [os.remove(s) for s in [lib_file, log_file]] - - -def cleanup_unload_lib(lib): - # Clean-up the in-memory dynamic linked libraries. - # This is not really necessary, as these programs are not that large, but with the new random - # naming scheme which is required on Windows OS'es to deal with updates to a Parcels' kernel. - if lib is not None: - _ctypes.FreeLibrary(lib._handle) if sys.platform == "win32" else _ctypes.dlclose(lib._handle) - - -def get_package_dir(): - fpath = Path(__file__) - return fpath.parent.parent - - -def get_cache_dir(): - directory = os.path.join(gettempdir(), f"parcels-{USER_ID}") - Path(directory).mkdir(exist_ok=True) - return directory diff --git a/parcels/utils/__init__.py b/parcels/utils/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/parcels/utils/_helpers.py b/parcels/utils/_helpers.py new file mode 100644 index 000000000..0b078110e --- /dev/null +++ b/parcels/utils/_helpers.py @@ -0,0 +1,46 @@ +"""Internal helpers for Parcels.""" + +from __future__ import annotations + +import inspect +from collections.abc import Callable +from datetime import timedelta + +import numpy as np + +PACKAGE = "Parcels" + + +def timedelta_to_float(dt: float | timedelta | np.timedelta64) -> float: + """Convert a timedelta to a float in seconds.""" + if isinstance(dt, timedelta): + return dt.total_seconds() + if isinstance(dt, np.timedelta64): + return float(dt / np.timedelta64(1, "s")) + return float(dt) + + +def should_calculate_next_ti(ti: int, tau: float, tdim: int): + """Check if the time is beyond the last time in the field""" + return np.greater(tau, 0) and ti < tdim - 1 + + +def _assert_same_function_signature(f: Callable, *, ref: Callable, context: str) -> None: + """Ensures a function `f` has the same signature as the reference function `ref`.""" + sig_ref = inspect.signature(ref) + sig = inspect.signature(f) + + if len(sig_ref.parameters) != len(sig.parameters): + raise ValueError( + f"{context} function must have {len(sig_ref.parameters)} parameters, got {len(sig.parameters)}" + ) + + for param1, param2 in zip(sig_ref.parameters.values(), sig.parameters.values(), strict=False): + if param1.kind != param2.kind: + raise ValueError( + f"Parameter '{param2.name}' has incorrect parameter kind. Expected {param1.kind}, got {param2.kind}" + ) + if param1.name != param2.name: + raise ValueError( + f"Parameter '{param2.name}' has incorrect name. Expected '{param1.name}', got '{param2.name}'" + ) diff --git a/parcels/tools/interpolation_utils.py b/parcels/utils/interpolation_utils.py similarity index 88% rename from parcels/tools/interpolation_utils.py rename to parcels/utils/interpolation_utils.py index 71d316e7c..e4893a813 100644 --- a/parcels/tools/interpolation_utils.py +++ b/parcels/utils/interpolation_utils.py @@ -1,4 +1,3 @@ -import math from collections.abc import Callable from typing import Literal @@ -24,10 +23,10 @@ def phi1D_quad(xsi: float) -> list[float]: def phi2D_lin(eta: float, xsi: float) -> list[float]: - phi = [(1-xsi) * (1-eta), - xsi * (1-eta), - xsi * eta , - (1-xsi) * eta ] + phi = np.column_stack([(1-xsi) * (1-eta), + xsi * (1-eta), + xsi * eta , + (1-xsi) * eta ]) return phi @@ -179,18 +178,19 @@ def _geodetic_distance(lat1: float, lat2: float, lon1: float, lon2: float, mesh: if mesh == "spherical": rad = np.pi / 180.0 deg2m = 1852 * 60.0 - return np.sqrt(((lon2 - lon1) * deg2m * math.cos(rad * lat)) ** 2 + ((lat2 - lat1) * deg2m) ** 2) + return np.sqrt(((lon2 - lon1) * deg2m * np.cos(rad * lat)) ** 2 + ((lat2 - lat1) * deg2m) ** 2) else: return np.sqrt((lon2 - lon1) ** 2 + (lat2 - lat1) ** 2) def _compute_jacobian_determinant(py: np.ndarray, px: np.ndarray, eta: float, xsi: float) -> float: - dphidxsi = [eta - 1, 1 - eta, eta, -eta] - dphideta = [xsi - 1, -xsi, xsi, 1 - xsi] + dphidxsi = np.column_stack([eta - 1, 1 - eta, eta, -eta]) + dphideta = np.column_stack([xsi - 1, -xsi, xsi, 1 - xsi]) - dxdxsi = np.dot(px, dphidxsi) - dxdeta = np.dot(px, dphideta) - dydxsi = np.dot(py, dphidxsi) - dydeta = np.dot(py, dphideta) - jac = dxdxsi * dydeta - dxdeta * dydxsi - return jac + dxdxsi_diag = np.einsum("ij,ji->i", dphidxsi, px) + dxdeta_diag = np.einsum("ij,ji->i", dphideta, px) + dydxsi_diag = np.einsum("ij,ji->i", dphidxsi, py) + dydeta_diag = np.einsum("ij,ji->i", dphideta, py) + + jac_diag = dxdxsi_diag * dydeta_diag - dxdeta_diag * dydxsi_diag + return jac_diag diff --git a/parcels/tools/timer.py b/parcels/utils/timer.py similarity index 96% rename from parcels/tools/timer.py rename to parcels/utils/timer.py index cd6725fb2..ea1181a44 100644 --- a/parcels/tools/timer.py +++ b/parcels/utils/timer.py @@ -48,7 +48,7 @@ def print_tree_sequential(self, step=0, root_time=0, parent_time=0): if step > 0: print(f"({round(time / parent_time * 100):3d}%) ", end="") t_str = f"{time:1.3e} s" if root_time < 300 else datetime.timedelta(seconds=time) - print(f"Timer {(self._name).ljust(20 - 2*step + 7*(step == 0))}: {t_str}") + print(f"Timer {(self._name).ljust(20 - 2 * step + 7 * (step == 0))}: {t_str}") for child in self._children: child.print_tree_sequential(step + 1, root_time, time) diff --git a/pixi.toml b/pixi.toml new file mode 100644 index 000000000..58f5a6a5e --- /dev/null +++ b/pixi.toml @@ -0,0 +1,94 @@ +[workspace] +name = "Parcels" +preview = ["pixi-build"] +channels = ["conda-forge"] +platforms = ["win-64", "linux-64", "osx-64", "osx-arm64"] + +[package] +name = "parcels" +version = "dynamic" # dynamic versioning needs better support in pixi https://github.com/prefix-dev/pixi/issues/2923#issuecomment-2598460666 . Putting `version = "dynamic"` here for now until pixi recommends something else. + +[package.build] +backend = { name = "pixi-build-python", version = "==0.3.2" } + +[package.host-dependencies] +setuptools = "*" +setuptools_scm = "*" + +[environments] +test-latest = { features = ["test"], solve-group = "test" } +test-py311 = { features = ["test", "py311"] } +test-py312 = { features = ["test", "py312"] } +test-notebooks = { features = ["test", "notebooks"], solve-group = "test" } +docs = { features = ["docs"], solve-group = "docs" } +typing = { features = ["typing"], solve-group = "typing" } +pre-commit = { features = ["pre-commit"], no-default-feature = true } + +[dependencies] # keep section in sync with pyproject.toml dependencies +python = ">=3.11,<3.13" +netcdf4 = ">=1.1.9" +numpy = ">=1.9.1" +tqdm = "*" +xarray = ">=0.10.8" +uxarray = ">=2025.3.0" +dask = ">=2.0" +scikit-learn = "*" +zarr = ">=2.11.0,!=2.18.0,<3" +xgcm = ">=0.9.0" +cf_xarray = "*" +cftime = ">=1.3.1" +scipy = ">=0.16.0" #? Not sure if we rely on scipy internally anymore... +pooch = "*" + +[feature.py311.dependencies] +python = "3.11.*" + +[feature.py312.dependencies] +python = "3.12.*" + +[feature.test.dependencies] +nbval = "*" +pytest = "*" +hypothesis = "*" +pytest-html = "*" +pytest-cov = "*" + +[feature.test.tasks] +tests = "pytest" +tests-notebooks = "pytest --nbval-lax -k 'argo' docs/examples" + + +[feature.notebooks.dependencies] +jupyter = "*" +trajan = "*" +matplotlib-base = ">=2.0.2" + +[feature.docs.dependencies] +numpydoc = "!=1.9.0" +nbsphinx = "*" +ipython = "*" +sphinx = "*" +pandoc = "*" +pydata-sphinx-theme = "*" +sphinx-autobuild = "*" +myst-parser = "*" +sphinxcontrib-mermaid = "*" + +[feature.docs.tasks] +docs = "sphinx-build docs docs/_build" +docs-watch = 'sphinx-autobuild --ignore "*.zip" docs docs/_build' +docs-linkcheck = "sphinx-build -b linkcheck docs/ docs/_build/linkcheck" + +[feature.pre-commit.dependencies] +pre_commit = "*" + +[feature.pre-commit.tasks] +lint = "pre-commit run --all-files" + +[feature.typing.dependencies] +mypy = "*" +lxml = "*" # in CI +types-tqdm = "*" + +[feature.typing.tasks] +typing = "mypy parcels --install-types" diff --git a/pyproject.toml b/pyproject.toml index 70d202689..5dc662646 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,12 +7,11 @@ name = "parcels" description = "Framework for Lagrangian tracking of virtual ocean particles in the petascale age." readme = "README.md" dynamic = ["version"] -authors = [{name = "oceanparcels.org team"}] -requires-python = ">=3.10" -license = {file = "LICENSE.md"} +authors = [{ name = "Parcels team" }] +requires-python = ">=3.11,<3.13" +license = { file = "LICENSE.md" } classifiers = [ "License :: OSI Approved :: MIT License", - "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", @@ -21,18 +20,19 @@ classifiers = [ "Intended Audience :: Science/Research", ] dependencies = [ - "cgen", "cftime", - "numpy", + "numpy >=1.11", "dask", - "psutil", - "netCDF4", - "zarr", + "netCDF4 >=1.1.9", + "zarr >=2.11.0,!=2.18.0,<3", "tqdm", - "pymbolic", "pytest", - "scipy", - "xarray", + "scipy >=0.16.0", + "xarray >=0.10.8", + "uxarray", + "pooch", + "xgcm >=0.9.0", + "cf_xarray", ] [project.urls] @@ -40,24 +40,27 @@ homepage = "https://oceanparcels.org/" repository = "https://github.com/OceanParcels/parcels" Tracker = "https://github.com/OceanParcels/parcels/issues" + [tool.setuptools] packages = ["parcels"] -[tool.setuptools.package-data] -parcels = ["parcels/include/*"] - [tool.setuptools_scm] write_to = "parcels/_version_setup.py" local_scheme = "no-local-version" [tool.pytest.ini_options] addopts = ["--strict-config", "--strict-markers"] -testpaths = ["tests", "docs/examples"] +xfail_strict = true +# testpaths = ["tests", "docs/examples"] # TODO v4: Re-enable once examples are back/fixed +testpaths = ["tests"] python_files = ["test_*.py", "example_*.py", "*tutorial*"] minversion = "7" markers = [ # can be skipped by doing `pytest -m "not slow"` etc. "flaky: flaky tests", "slow: slow tests", + "v4alpha: failing tests that should work for v4alpha", + "v4future: failing tests that should work for a future release of v4", + "v4remove: failing tests that should probably be removed later", ] filterwarnings = [ @@ -69,62 +72,58 @@ line-length = 120 [tool.ruff.lint] select = [ - "D", # pydocstyle - "E", # Error - "F", # pyflakes - "I", # isort - "B", # Bugbear - "UP", # pyupgrade - "LOG", # logging - "ICN", # import conventions - "G", # logging-format - "RUF", # ruff - "ISC001", # single-line-implicit-string-concatenation + "D", # pydocstyle + "E", # Error + "F", # pyflakes + "I", # isort + "B", # Bugbear + "UP", # pyupgrade + "LOG", # logging + "ICN", # import conventions + "G", # logging-format + "RUF", # ruff + "ISC001", # single-line-implicit-string-concatenation + "TID", # flake8-tidy-imports + "T100", # Checks for the presence of debugger calls and imports ] ignore = [ - # line too long (82 > 79 characters) - "E501", - # ‘from module import *’ used; unable to detect undefined names - "F403", - # Mutable class attributes should be annotated with `typing.ClassVar` - "RUF012", - # Consider `(slice(2), *block)` instead of concatenation - "RUF005", - # Prefer `next(iter(variable.items()))` over single element slice - "RUF015", - # Use `X | Y` in `isinstance` (see https://github.com/home-assistant/core/issues/123850) - "UP038", - - # TODO: ignore for now (requires more work). Remove ignore once fixed - # Missing docstring in public module - "D100", - # Missing docstring in public class - "D101", - # Missing docstring in public method - "D102", - # Missing docstring in public function - "D103", - # Missing docstring in public package - "D104", - # Missing docstring in magic method - "D105", - # Missing docstring in __init__ - "D400", - # First line should be in imperative mood (requires writing of summaries) - "D401", - # First word of the docstring should not be `This` - "D404", - # 1 blank line required between summary line and description (requires writing of summaries) - "D205", - # do not use bare except, specify exception instead - "E722", - - - # TODO: These bugbear issues are to be resolved - "B011", # Do not `assert False` - "B016", # Cannot raise a literal. Did you intend to return it or raise an Exception? - "B904", # Within an `except` clause, raise exceptions + # line too long (82 > 79 characters) + "E501", + # ‘from module import *’ used; unable to detect undefined names + "F403", + # Mutable class attributes should be annotated with `typing.ClassVar` + "RUF012", + # Consider `(slice(2), *block)` instead of concatenation + "RUF005", + # Prefer `next(iter(variable.items()))` over single element slice + "RUF015", + # Use `X | Y` in `isinstance` (see https://github.com/home-assistant/core/issues/123850) + "UP038", + "RUF046", # Value being cast to `int` is already an integer + + # TODO: ignore for now (requires more work). Remove ignore once fixed + # Missing docstring in public module + "D100", + # Missing docstring in public class + "D101", + # Missing docstring in public method + "D102", + # Missing docstring in public function + "D103", + # Missing docstring in public package + "D104", + # Missing docstring in magic method + "D105", + # Missing docstring in __init__ + "D400", + # First line should be in imperative mood (requires writing of summaries) + "D401", + # First word of the docstring should not be `This` + "D404", + # 1 blank line required between summary line and description (requires writing of summaries) + "D205", + "F811", ] [tool.ruff.lint.pydocstyle] @@ -135,7 +134,6 @@ known-first-party = ["parcels"] [tool.mypy] files = [ - "parcels/compilation/codegenerator.py", "parcels/_typing.py", "parcels/tools/*.py", "parcels/grid.py", @@ -145,14 +143,14 @@ files = [ [[tool.mypy.overrides]] module = [ - "parcels._version_setup", - "mpi4py", - "scipy.spatial", - "sklearn.cluster", - "zarr", - "cftime", - "pykdtree.kdtree", - "netCDF4", - "cgen" + "parcels._version_setup", + "mpi4py", + "scipy.spatial", + "sklearn.cluster", + "zarr", + "cftime", + "pykdtree.kdtree", + "netCDF4", + "pooch", ] ignore_missing_imports = true diff --git a/tests-v3/test_advection.py b/tests-v3/test_advection.py new file mode 100644 index 000000000..de8b004d7 --- /dev/null +++ b/tests-v3/test_advection.py @@ -0,0 +1,179 @@ +import numpy as np +import pytest +import xarray as xr + +from parcels import ( + AdvectionAnalytical, + AdvectionDiffusionEM, + AdvectionDiffusionM1, + AdvectionEE, + AdvectionRK4, + AdvectionRK4_3D, + AdvectionRK45, + FieldSet, + Particle, + ParticleSet, + Variable, +) +from tests.utils import TEST_DATA + +kernel = { + "EE": AdvectionEE, + "RK4": AdvectionRK4, + "RK45": AdvectionRK45, + "AA": AdvectionAnalytical, + "AdvDiffEM": AdvectionDiffusionEM, + "AdvDiffM1": AdvectionDiffusionM1, +} + + +@pytest.fixture +def lon(): + xdim = 200 + return np.linspace(-170, 170, xdim, dtype=np.float32) + + +@pytest.fixture +def lat(): + ydim = 100 + return np.linspace(-80, 80, ydim, dtype=np.float32) + + +@pytest.fixture +def depth(): + zdim = 2 + return np.linspace(0, 30, zdim, dtype=np.float32) + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="When refactoring fieldfilebuffer croco support was dropped. This will be fixed in v4.") +def test_conversion_3DCROCO(): + """Test of the (SciPy) version of the conversion from depth to sigma in CROCO + + Values below are retrieved using xroms and hardcoded in the method (to avoid dependency on xroms): + ```py + x, y = 10, 20 + s_xroms = ds.s_w.values + z_xroms = ds.z_w.isel(time=0).isel(eta_rho=y).isel(xi_rho=x).values + lat, lon = ds.y_rho.values[y, x], ds.x_rho.values[y, x] + ``` + """ + fieldset = FieldSet.from_modulefile(TEST_DATA / "fieldset_CROCO3D.py") + + lat, lon = 78000.0, 38000.0 + s_xroms = np.array([-1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0.0], dtype=np.float32) + z_xroms = np.array( + [ + -1.26000000e02, + -1.10585846e02, + -9.60985413e01, + -8.24131317e01, + -6.94126511e01, + -5.69870148e01, + -4.50318756e01, + -3.34476166e01, + -2.21383114e01, + -1.10107975e01, + 2.62768921e-02, + ], + dtype=np.float32, + ) + + sigma = np.zeros_like(z_xroms) + from parcels.field import _croco_from_z_to_sigma_scipy + + for zi, z in enumerate(z_xroms): + sigma[zi] = _croco_from_z_to_sigma_scipy(fieldset, 0, z, lat, lon, None) + + assert np.allclose(sigma, s_xroms, atol=1e-3) + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="CROCO 3D interpolation is not yet implemented correctly in v4. ") +def test_advection_3DCROCO(): + fieldset = FieldSet.from_modulefile(TEST_DATA / "fieldset_CROCO3D.py") + + runtime = 1e4 + X, Z = np.meshgrid([40e3, 80e3, 120e3], [-10, -130]) + Y = np.ones(X.size) * 100e3 + + pclass = Particle.add_variable(Variable("w")) + pset = ParticleSet(fieldset=fieldset, pclass=pclass, lon=X, lat=Y, depth=Z) + + def SampleW(particle, fieldset, time): # pragma: no cover + particle.w = fieldset.W[time, particle.depth, particle.lat, particle.lon] + + pset.execute([AdvectionRK4_3D, SampleW], runtime=runtime, dt=100) + assert np.allclose(pset.depth, Z.flatten(), atol=5) # TODO lower this atol + assert np.allclose(pset.lon_nextloop, [x + runtime for x in X.flatten()], atol=1e-3) + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="When refactoring fieldfilebuffer croco support was dropped. This will be fixed in v4.") +def test_advection_2DCROCO(): + fieldset = FieldSet.from_modulefile(TEST_DATA / "fieldset_CROCO2D.py") + + runtime = 1e4 + X = np.array([40e3, 80e3, 120e3]) + Y = np.ones(X.size) * 100e3 + Z = np.zeros(X.size) + pset = ParticleSet(fieldset=fieldset, pclass=Particle, lon=X, lat=Y, depth=Z) + + pset.execute([AdvectionRK4], runtime=runtime, dt=100) + assert np.allclose(pset.depth, Z.flatten(), atol=1e-3) + assert np.allclose(pset.lon_nextloop, [x + runtime for x in X], atol=1e-3) + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_analyticalAgrid(): + lon = np.arange(0, 15, dtype=np.float32) + lat = np.arange(0, 15, dtype=np.float32) + U = np.ones((lat.size, lon.size), dtype=np.float32) + V = np.ones((lat.size, lon.size), dtype=np.float32) + fieldset = FieldSet.from_data({"U": U, "V": V}, {"lon": lon, "lat": lat}, mesh="flat") + pset = ParticleSet(fieldset, pclass=Particle, lon=1, lat=1) + + with pytest.raises(NotImplementedError): + pset.execute(AdvectionAnalytical, runtime=1) + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1927") +@pytest.mark.parametrize("u", [1, -0.2, -0.3, 0]) +@pytest.mark.parametrize("v", [1, -0.3, 0, -1]) +@pytest.mark.parametrize("w", [None, 1, -0.3, 0, -1]) +@pytest.mark.parametrize("direction", [1, -1]) +def test_uniform_analytical(u, v, w, direction, tmp_zarrfile): + lon = np.arange(0, 15, dtype=np.float32) + lat = np.arange(0, 15, dtype=np.float32) + if w is not None: + depth = np.arange(0, 40, 2, dtype=np.float32) + U = u * np.ones((depth.size, lat.size, lon.size), dtype=np.float32) + V = v * np.ones((depth.size, lat.size, lon.size), dtype=np.float32) + W = w * np.ones((depth.size, lat.size, lon.size), dtype=np.float32) + fieldset = FieldSet.from_data({"U": U, "V": V, "W": W}, {"lon": lon, "lat": lat, "depth": depth}, mesh="flat") + fieldset.W.interp_method = "cgrid_velocity" + else: + U = u * np.ones((lat.size, lon.size), dtype=np.float32) + V = v * np.ones((lat.size, lon.size), dtype=np.float32) + fieldset = FieldSet.from_data({"U": U, "V": V}, {"lon": lon, "lat": lat}, mesh="flat") + fieldset.U.interp_method = "cgrid_velocity" + fieldset.V.interp_method = "cgrid_velocity" + + x0, y0, z0 = 6.1, 6.2, 20 + pset = ParticleSet(fieldset, pclass=Particle, lon=x0, lat=y0, depth=z0) + + outfile = pset.ParticleFile(name=tmp_zarrfile, outputdt=1, chunks=(1, 1)) + pset.execute(AdvectionAnalytical, runtime=4, dt=direction, output_file=outfile) + assert np.abs(pset.lon - x0 - pset.time * u) < 1e-6 + assert np.abs(pset.lat - y0 - pset.time * v) < 1e-6 + if w is not None: + assert np.abs(pset.depth - z0 - pset.time * w) < 1e-4 + + ds = xr.open_zarr(tmp_zarrfile) + times = (direction * ds["time"][:]).values.astype("timedelta64[s]")[0] + timeref = np.arange(1, 5).astype("timedelta64[s]") + assert np.allclose(times, timeref, atol=np.timedelta64(1, "ms")) + lons = ds["lon"][:].values + assert np.allclose(lons, x0 + direction * u * np.arange(1, 5)) diff --git a/tests/test_examples.py b/tests-v3/test_examples.py similarity index 100% rename from tests/test_examples.py rename to tests-v3/test_examples.py diff --git a/tests-v3/test_fieldset.py b/tests-v3/test_fieldset.py new file mode 100644 index 000000000..fd83a28be --- /dev/null +++ b/tests-v3/test_fieldset.py @@ -0,0 +1,417 @@ +from datetime import timedelta + +import numpy as np +import pytest +import xarray as xr + +from parcels import ( + AdvectionRK4, + AdvectionRK4_3D, + FieldSet, + Particle, + ParticleSet, + Variable, +) +from parcels.field import VectorField +from parcels.tools.converters import GeographicPolar, UnitConverter +from tests.utils import TEST_DATA + + +def generate_fieldset_data(xdim, ydim, zdim=1, tdim=1): + lon = np.linspace(0.0, 10.0, xdim, dtype=np.float32) + lat = np.linspace(0.0, 10.0, ydim, dtype=np.float32) + depth = np.zeros(zdim, dtype=np.float32) + time = np.zeros(tdim, dtype=np.float64) + if zdim == 1 and tdim == 1: + U, V = np.meshgrid(lon, lat) + dimensions = {"lat": lat, "lon": lon} + else: + U = np.ones((tdim, zdim, ydim, xdim)) + V = np.ones((tdim, zdim, ydim, xdim)) + dimensions = {"lat": lat, "lon": lon, "depth": depth, "time": time} + data = {"U": np.array(U, dtype=np.float32), "V": np.array(V, dtype=np.float32)} + + return (data, dimensions) + + +def to_xarray_dataset(data: dict[str, np.array], dimensions: dict[str, np.array]) -> xr.Dataset: + assert len(dimensions) in [2, 4], "this function only deals with output from generate_fieldset_data()" + + if len(dimensions) == 4: + return xr.Dataset( + { + "U": (["time", "depth", "lat", "lon"], data["U"]), + "V": (["time", "depth", "lat", "lon"], data["V"]), + }, + coords=dimensions, + ) + + return xr.Dataset( + { + "U": (["lat", "lon"], data["U"]), + "V": (["lat", "lon"], data["V"]), + }, + coords=dimensions, + ) + + +@pytest.mark.v4remove +@pytest.mark.xfail(reason="GH1946") +@pytest.fixture +def multifile_fieldset(tmp_path): + stem = "test_subsets" + + timestamps = np.arange(0, 4, 1) * 86400.0 + timestamps = np.expand_dims(timestamps, 1) + + ufiles = [] + vfiles = [] + for index, timestamp in enumerate(timestamps): + data, dimensions = generate_fieldset_data(100, 100) + path = tmp_path / f"{stem}_{index}.nc" + to_xarray_dataset(data, dimensions).pipe(assign_dataset_timestamp_dim, timestamp).to_netcdf(path) + ufiles.append(path) + vfiles.append(path) + + files = {"U": ufiles, "V": vfiles} + variables = {"U": "U", "V": "V"} + dimensions = {"lon": "lon", "lat": "lat", "time": "time"} + return FieldSet.from_netcdf(files, variables, dimensions) + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_fieldset_from_modulefile(): + nemo_fname = str(TEST_DATA / "fieldset_nemo.py") + nemo_error_fname = str(TEST_DATA / "fieldset_nemo_error.py") + + fieldset = FieldSet.from_modulefile(nemo_fname) + + fieldset = FieldSet.from_modulefile(nemo_fname) + assert fieldset.U.grid.lon.shape[1] == 21 + + with pytest.raises(IOError): + FieldSet.from_modulefile(nemo_error_fname) + + FieldSet.from_modulefile(nemo_error_fname, modulename="random_function_name") + + with pytest.raises(IOError): + FieldSet.from_modulefile(nemo_error_fname, modulename="none_returning_function") + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_field_from_netcdf_fieldtypes(): + filenames = { + "varU": { + "lon": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), + "lat": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), + "data": str(TEST_DATA / "Uu_eastward_nemo_cross_180lon.nc"), + }, + "varV": { + "lon": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), + "lat": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), + "data": str(TEST_DATA / "Vv_eastward_nemo_cross_180lon.nc"), + }, + } + variables = {"varU": "U", "varV": "V"} + dimensions = {"lon": "glamf", "lat": "gphif"} + + # first try without setting fieldtype + fset = FieldSet.from_nemo(filenames, variables, dimensions) + assert isinstance(fset.varU.units, UnitConverter) + + # now try with setting fieldtype + fset = FieldSet.from_nemo(filenames, variables, dimensions, fieldtype={"varU": "U", "varV": "V"}) + assert isinstance(fset.varU.units, GeographicPolar) + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_fieldset_from_agrid_dataset(): + filenames = { + "lon": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), + "lat": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), + "data": str(TEST_DATA / "Uu_eastward_nemo_cross_180lon.nc"), + } + variable = {"U": "U"} + dimensions = {"lon": "glamf", "lat": "gphif"} + FieldSet.from_a_grid_dataset(filenames, variable, dimensions) + + +@pytest.mark.v4remove +@pytest.mark.xfail(reason="GH1946") +def test_fieldset_from_cgrid_interpmethod(): + filenames = { + "lon": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), + "lat": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), + "data": str(TEST_DATA / "Uu_eastward_nemo_cross_180lon.nc"), + } + variable = "U" + dimensions = {"lon": "glamf", "lat": "gphif"} + + with pytest.raises(TypeError): + # should fail because FieldSet.from_c_grid_dataset does not support interp_method + FieldSet.from_c_grid_dataset(filenames, variable, dimensions, interp_method="partialslip") + + +@pytest.mark.v4future +@pytest.mark.xfail(reason="GH1946") +@pytest.mark.parametrize("calltype", ["from_nemo"]) +def test_illegal_dimensionsdict(calltype): + with pytest.raises(NameError): + if calltype == "from_data": + data, dimensions = generate_fieldset_data(10, 10) + dimensions["test"] = None + FieldSet.from_data(data, dimensions) + elif calltype == "from_nemo": + fname = str(TEST_DATA / "mask_nemo_cross_180lon.nc") + filenames = {"dx": fname, "mesh_mask": fname} + variables = {"dx": "e1u"} + dimensions = {"lon": "glamu", "lat": "gphiu", "test": "test"} + FieldSet.from_nemo(filenames, variables, dimensions) + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +@pytest.mark.parametrize("gridtype", ["A", "C"]) +def test_fieldset_dimlength1_cgrid(gridtype): + fieldset = FieldSet.from_data({"U": 0, "V": 0}, {"lon": 0, "lat": 0}) # TODO : Remove from_data + if gridtype == "C": + fieldset.U.interp_method = "cgrid_velocity" + fieldset.V.interp_method = "cgrid_velocity" + try: + fieldset._check_complete() + success = True if gridtype == "A" else False + except NotImplementedError: + success = True if gridtype == "C" else False + assert success + + +def assign_dataset_timestamp_dim(ds, timestamp): + """Expand dim to 'time' and assign timestamp.""" + ds.expand_dims("time") + ds["time"] = timestamp + return ds + + +def addConst(particle, fieldset, time): # pragma: no cover + particle.lon = particle.lon + fieldset.movewest + fieldset.moveeast + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_fieldset_constant(): + data, dimensions = generate_fieldset_data(100, 100) + fieldset = FieldSet.from_data(data, dimensions) # TODO : Remove from_data + westval = -0.2 + eastval = 0.3 + fieldset.add_constant("movewest", westval) + fieldset.add_constant("moveeast", eastval) + assert fieldset.movewest == westval + + pset = ParticleSet.from_line(fieldset, size=1, pclass=Particle, start=(0.5, 0.5), finish=(0.5, 0.5)) + pset.execute(pset.Kernel(addConst), dt=1, runtime=1) + assert abs(pset.lon[0] - (0.5 + westval + eastval)) < 1e-4 + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +@pytest.mark.parametrize("swapUV", [False, True]) +def test_vector_fields(swapUV): + lon = np.linspace(0.0, 10.0, 12, dtype=np.float32) + lat = np.linspace(0.0, 10.0, 10, dtype=np.float32) + U = np.ones((10, 12), dtype=np.float32) + V = np.zeros((10, 12), dtype=np.float32) + data = {"U": U, "V": V} + dimensions = {"U": {"lat": lat, "lon": lon}, "V": {"lat": lat, "lon": lon}} + fieldset = FieldSet.from_data(data, dimensions, mesh="flat") # TODO : Remove from_data + if swapUV: # we test that we can freely edit whatever UV field + UV = VectorField("UV", fieldset.V, fieldset.U) + fieldset.add_vector_field(UV) + + pset = ParticleSet.from_line(fieldset, size=1, pclass=Particle, start=(0.5, 0.5), finish=(0.5, 0.5)) + pset.execute(AdvectionRK4, dt=1, runtime=2) + if swapUV: + assert abs(pset.lon[0] - 0.5) < 1e-9 + assert abs(pset.lat[0] - 1.5) < 1e-9 + else: + assert abs(pset.lon[0] - 1.5) < 1e-9 + assert abs(pset.lat[0] - 0.5) < 1e-9 + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946, originated in GH938") +def test_add_second_vector_field(): + lon = np.linspace(0.0, 10.0, 12, dtype=np.float32) + lat = np.linspace(0.0, 10.0, 10, dtype=np.float32) + U = np.ones((10, 12), dtype=np.float32) + V = np.zeros((10, 12), dtype=np.float32) + data = {"U": U, "V": V} + dimensions = {"U": {"lat": lat, "lon": lon}, "V": {"lat": lat, "lon": lon}} + fieldset = FieldSet.from_data(data, dimensions, mesh="flat") # TODO : Remove from_data + + data2 = {"U2": U, "V2": V} + dimensions2 = {"lon": [ln + 0.1 for ln in lon], "lat": [lt - 0.1 for lt in lat]} + fieldset2 = FieldSet.from_data(data2, dimensions2, mesh="flat") # TODO : Remove from_data + + UV2 = VectorField("UV2", fieldset2.U2, fieldset2.V2) + fieldset.add_vector_field(UV2) + + def SampleUV2(particle, fieldset, time): # pragma: no cover + u, v = fieldset.UV2[time, particle.depth, particle.lat, particle.lon] + particle.dlon += u * particle.dt + particle.dlat += v * particle.dt + + pset = ParticleSet(fieldset, pclass=Particle, lon=0.5, lat=0.5) + pset.execute(AdvectionRK4 + pset.Kernel(SampleUV2), dt=1, runtime=2) + + assert abs(pset.lon[0] - 2.5) < 1e-9 + assert abs(pset.lat[0] - 0.5) < 1e-9 + + +@pytest.mark.v4remove +@pytest.mark.xfail(reason="time_periodic removed in v4") +@pytest.mark.parametrize("use_xarray", [True, False]) +@pytest.mark.parametrize("time_periodic", [86400.0, False]) +@pytest.mark.parametrize("dt_sign", [-1, 1]) +def test_periodic(use_xarray, time_periodic, dt_sign): + lon = np.array([0, 1], dtype=np.float32) + lat = np.array([0, 1], dtype=np.float32) + depth = np.array([0, 1], dtype=np.float32) + tsize = 24 * 60 + 1 + period = 86400 + time = np.linspace(0, period, tsize, dtype=np.float64) + + def temp_func(time): + return 20 + 2 * np.sin(time * 2 * np.pi / period) + + temp_vec = temp_func(time) + + U = np.zeros((tsize, 2, 2, 2), dtype=np.float32) + V = np.zeros((tsize, 2, 2, 2), dtype=np.float32) + V[:, 0, 0, 0] = 1e-5 + W = np.zeros((tsize, 2, 2, 2), dtype=np.float32) + temp = np.zeros((tsize, 2, 2, 2), dtype=np.float32) + temp[:, :, :, :] = temp_vec + D = np.ones((2, 2), dtype=np.float32) # adding non-timevarying field + + full_dims = {"lon": lon, "lat": lat, "depth": depth, "time": time} + dimensions = {"U": full_dims, "V": full_dims, "W": full_dims, "temp": full_dims, "D": {"lon": lon, "lat": lat}} + if use_xarray: + coords = {"lat": lat, "lon": lon, "depth": depth, "time": time} + variables = {"U": "Uxr", "V": "Vxr", "W": "Wxr", "temp": "Txr", "D": "Dxr"} + dimnames = {"lon": "lon", "lat": "lat", "depth": "depth", "time": "time"} + ds = xr.Dataset( + { + "Uxr": xr.DataArray(U, coords=coords, dims=("time", "depth", "lat", "lon")), + "Vxr": xr.DataArray(V, coords=coords, dims=("time", "depth", "lat", "lon")), + "Wxr": xr.DataArray(W, coords=coords, dims=("time", "depth", "lat", "lon")), + "Txr": xr.DataArray(temp, coords=coords, dims=("time", "depth", "lat", "lon")), + "Dxr": xr.DataArray(D, coords={"lat": lat, "lon": lon}, dims=("lat", "lon")), + } + ) + fieldset = FieldSet.from_xarray_dataset( + ds, + variables, + {"U": dimnames, "V": dimnames, "W": dimnames, "temp": dimnames, "D": {"lon": "lon", "lat": "lat"}}, + time_periodic=time_periodic, + allow_time_extrapolation=True, + ) + else: + data = {"U": U, "V": V, "W": W, "temp": temp, "D": D} + fieldset = FieldSet.from_data( + data, dimensions, mesh="flat", time_periodic=time_periodic, allow_time_extrapolation=True + ) # TODO : Remove from_data + + def sampleTemp(particle, fieldset, time): # pragma: no cover + particle.temp = fieldset.temp[time, particle.depth, particle.lat, particle.lon] + # test if we can interpolate UV and UVW together + (particle.u1, particle.v1) = fieldset.UV[time, particle.depth, particle.lat, particle.lon] + (particle.u2, particle.v2, w_) = fieldset.UVW[time, particle.depth, particle.lat, particle.lon] + # test if we can sample a non-timevarying field too + particle.d = fieldset.D[0, 0, particle.lat, particle.lon] + + MyParticle = Particle.add_variables( + [ + Variable("temp", dtype=np.float32, initial=20.0), + Variable("u1", dtype=np.float32, initial=0.0), + Variable("u2", dtype=np.float32, initial=0.0), + Variable("v1", dtype=np.float32, initial=0.0), + Variable("v2", dtype=np.float32, initial=0.0), + Variable("d", dtype=np.float32, initial=0.0), + ] + ) + + pset = ParticleSet(fieldset, pclass=MyParticle, lon=[0.5], lat=[0.5], depth=[0.5]) + pset.execute( + AdvectionRK4_3D + pset.Kernel(sampleTemp), runtime=timedelta(hours=51), dt=timedelta(hours=dt_sign * 1) + ) + + if time_periodic is not False: + t = pset.time[0] + temp_theo = temp_func(t) + elif dt_sign == 1: + temp_theo = temp_vec[-1] + elif dt_sign == -1: + temp_theo = temp_vec[0] + assert np.allclose(temp_theo, pset.temp[0], atol=1e-5) + assert np.allclose(pset.u1[0], pset.u2[0]) + assert np.allclose(pset.v1[0], pset.v2[0]) + assert np.allclose(pset.d[0], 1.0) + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_fieldset_from_data_gridtypes(): + """Simple test for fieldset initialisation from data.""" + xdim, ydim, zdim = 20, 10, 4 + + lon = np.linspace(0.0, 10.0, xdim, dtype=np.float32) + lat = np.linspace(0.0, 10.0, ydim, dtype=np.float32) + depth = np.linspace(0.0, 1.0, zdim, dtype=np.float32) + depth_s = np.ones((zdim, ydim, xdim)) + U = np.ones((zdim, ydim, xdim)) + V = np.ones((zdim, ydim, xdim)) + dimensions = {"lat": lat, "lon": lon, "depth": depth} + data = {"U": np.array(U, dtype=np.float32), "V": np.array(V, dtype=np.float32)} + lonm, latm = np.meshgrid(lon, lat) + for k in range(zdim): + data["U"][k, :, :] = lonm * (depth[k] + 1) + 0.1 + depth_s[k, :, :] = depth[k] + + # Rectilinear Z grid + fieldset = FieldSet.from_data(data, dimensions, mesh="flat") # TODO : Remove from_data + pset = ParticleSet(fieldset, Particle, [0, 0], [0, 0], [0, 0.4]) + pset.execute(AdvectionRK4, runtime=1.5, dt=0.5) + plon = pset.lon + plat = pset.lat + # sol of dx/dt = (init_depth+1)*x+0.1; x(0)=0 + assert np.allclose(plon, [0.17173462592827032, 0.2177736932123214]) + assert np.allclose(plat, [1, 1]) + + # Rectilinear S grid + dimensions["depth"] = depth_s + fieldset = FieldSet.from_data(data, dimensions, mesh="flat") # TODO : Remove from_data + pset = ParticleSet(fieldset, Particle, [0, 0], [0, 0], [0, 0.4]) + pset.execute(AdvectionRK4, runtime=1.5, dt=0.5) + assert np.allclose(plon, pset.lon) + assert np.allclose(plat, pset.lat) + + # Curvilinear Z grid + dimensions["lon"] = lonm + dimensions["lat"] = latm + dimensions["depth"] = depth + fieldset = FieldSet.from_data(data, dimensions, mesh="flat") # TODO : Remove from_data + pset = ParticleSet(fieldset, Particle, [0, 0], [0, 0], [0, 0.4]) + pset.execute(AdvectionRK4, runtime=1.5, dt=0.5) + assert np.allclose(plon, pset.lon) + assert np.allclose(plat, pset.lat) + + # Curvilinear S grid + dimensions["depth"] = depth_s + fieldset = FieldSet.from_data(data, dimensions, mesh="flat") # TODO : Remove from_data + pset = ParticleSet(fieldset, Particle, [0, 0], [0, 0], [0, 0.4]) + pset.execute(AdvectionRK4, runtime=1.5, dt=0.5) + assert np.allclose(plon, pset.lon) + assert np.allclose(plat, pset.lat) diff --git a/tests/test_fieldset_sampling.py b/tests-v3/test_fieldset_sampling.py similarity index 72% rename from tests/test_fieldset_sampling.py rename to tests-v3/test_fieldset_sampling.py index 36b67005c..11dec1988 100644 --- a/tests/test_fieldset_sampling.py +++ b/tests-v3/test_fieldset_sampling.py @@ -12,20 +12,16 @@ Field, FieldSet, Geographic, - JITParticle, - NestedField, + Particle, ParticleSet, - ScipyParticle, StatusCode, Variable, ) from tests.utils import create_fieldset_global -ptype = {"scipy": ScipyParticle, "jit": JITParticle} - -def pclass(mode): - return ptype[mode].add_variables( +def pclass(): + return Particle.add_variables( [Variable("u", dtype=np.float32), Variable("v", dtype=np.float32), Variable("p", dtype=np.float32)] ) @@ -51,12 +47,12 @@ def create_fieldset_geometric(xdim=200, ydim=100): """Standard earth fieldset with U and V equivalent to lon/lat in m.""" lon = np.linspace(-180, 180, xdim, dtype=np.float32) lat = np.linspace(-90, 90, ydim, dtype=np.float32) - U, V = np.meshgrid(lat, lon) + V, U = np.meshgrid(lon, lat) U *= 1000.0 * 1.852 * 60.0 V *= 1000.0 * 1.852 * 60.0 data = {"U": U, "V": V} dimensions = {"lon": lon, "lat": lat} - fieldset = FieldSet.from_data(data, dimensions, transpose=True) + fieldset = FieldSet.from_data(data, dimensions) fieldset.U.units = Geographic() fieldset.V.units = Geographic() return fieldset @@ -73,15 +69,15 @@ def create_fieldset_geometric_polar(xdim=200, ydim=100): """ lon = np.linspace(-180, 180, xdim, dtype=np.float32) lat = np.linspace(-90, 90, ydim, dtype=np.float32) - U, V = np.meshgrid(lat, lon) + V, U = np.meshgrid(lon, lat) # Apply inverse of pole correction to U for i, y in enumerate(lat): - U[:, i] *= cos(y * pi / 180) + U[i, :] *= cos(y * pi / 180) U *= 1000.0 * 1.852 * 60.0 V *= 1000.0 * 1.852 * 60.0 data = {"U": U, "V": V} dimensions = {"lon": lon, "lat": lat} - return FieldSet.from_data(data, dimensions, mesh="spherical", transpose=True) + return FieldSet.from_data(data, dimensions, mesh="spherical") @pytest.fixture @@ -89,6 +85,8 @@ def fieldset_geometric_polar(): return create_fieldset_geometric_polar() +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") def test_fieldset_sample(fieldset): """Sample the fieldset using indexing notation.""" xdim, ydim = 120, 80 @@ -102,6 +100,8 @@ def test_fieldset_sample(fieldset): assert np.allclose(u_s, lat, rtol=1e-5) +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") def test_fieldset_sample_eval(fieldset): """Sample the fieldset using the explicit eval function.""" xdim, ydim = 60, 60 @@ -115,17 +115,19 @@ def test_fieldset_sample_eval(fieldset): assert np.allclose(u_s, lat, rtol=1e-5) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_fieldset_polar_with_halo(fieldset_geometric_polar, mode): +@pytest.mark.v4remove +@pytest.mark.xfail(reason="Test is directly testing adding the halo. This test should either be adapted or removed.") +def test_fieldset_polar_with_halo(fieldset_geometric_polar): fieldset_geometric_polar.add_periodic_halo(zonal=5) - pset = ParticleSet(fieldset_geometric_polar, pclass=pclass(mode), lon=0, lat=0) + pset = ParticleSet(fieldset_geometric_polar, pclass=pclass(), lon=0, lat=0) pset.execute(runtime=1) assert pset.lon[0] == 0.0 -@pytest.mark.parametrize("mode", ["scipy", "jit"]) +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") @pytest.mark.parametrize("zdir", [-1, 1]) -def test_verticalsampling(mode, zdir): +def test_verticalsampling(zdir): dims = (4, 2, 2) dimensions = { "lon": np.linspace(0.0, 1.0, dims[2], dtype=np.float32), @@ -134,13 +136,13 @@ def test_verticalsampling(mode, zdir): } data = {"U": np.zeros(dims, dtype=np.float32), "V": np.zeros(dims, dtype=np.float32)} fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=0, lat=0, depth=0.7 * zdir) + pset = ParticleSet(fieldset, pclass=Particle, lon=0, lat=0, depth=0.7 * zdir) pset.execute(AdvectionRK4, dt=1.0, runtime=1.0) - assert pset[0].zi == [2] + zi, yi, xi = fieldset.U.unravel_index(pset[0].ei) + assert zi == [2] -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_from_field(mode): +def test_pset_from_field(): xdim = 10 ydim = 20 npart = 10000 @@ -150,86 +152,87 @@ def test_pset_from_field(mode): "lon": np.linspace(0.0, 1.0, xdim, dtype=np.float32), "lat": np.linspace(0.0, 1.0, ydim, dtype=np.float32), } - startfield = np.ones((xdim, ydim), dtype=np.float32) + startfield = np.ones((ydim, xdim), dtype=np.float32) for x in range(xdim): - startfield[x, :] = x + startfield[:, x] = x data = { - "U": np.zeros((xdim, ydim), dtype=np.float32), - "V": np.zeros((xdim, ydim), dtype=np.float32), + "U": np.zeros((ydim, xdim), dtype=np.float32), + "V": np.zeros((ydim, xdim), dtype=np.float32), "start": startfield, } - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", transpose=True) + fieldset = FieldSet.from_data(data, dimensions, mesh="flat") densfield = Field( name="densfield", - data=np.zeros((xdim + 1, ydim + 1), dtype=np.float32), + data=np.zeros((ydim + 1, xdim + 1), dtype=np.float32), lon=np.linspace(-1.0 / (xdim * 2), 1.0 + 1.0 / (xdim * 2), xdim + 1, dtype=np.float32), lat=np.linspace(-1.0 / (ydim * 2), 1.0 + 1.0 / (ydim * 2), ydim + 1, dtype=np.float32), - transpose=True, ) fieldset.add_field(densfield) - pset = ParticleSet.from_field(fieldset, size=npart, pclass=pclass(mode), start_field=fieldset.start) - pdens = np.histogram2d(pset.lon, pset.lat, bins=[np.linspace(0.0, 1.0, xdim + 1), np.linspace(0.0, 1.0, ydim + 1)])[ + pset = ParticleSet.from_field(fieldset, size=npart, pclass=Particle, start_field=fieldset.start) + pdens = np.histogram2d(pset.lat, pset.lon, bins=[np.linspace(0.0, 1.0, ydim + 1), np.linspace(0.0, 1.0, xdim + 1)])[ 0 ] assert np.allclose(pdens / sum(pdens.flatten()), startfield / sum(startfield.flatten()), atol=1e-2) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_nearest_neighbor_interpolation2D(mode): +@pytest.mark.v4alpha +def test_nearest_neighbor_interpolation2D(): npart = 81 dims = (2, 2) dimensions = { - "lon": np.linspace(0.0, 1.0, dims[0], dtype=np.float32), - "lat": np.linspace(0.0, 1.0, dims[1], dtype=np.float32), + "lon": np.linspace(0.0, 1.0, dims[1], dtype=np.float32), + "lat": np.linspace(0.0, 1.0, dims[0], dtype=np.float32), } data = { "U": np.zeros(dims, dtype=np.float32), "V": np.zeros(dims, dtype=np.float32), "P": np.zeros(dims, dtype=np.float32), } - data["P"][0, 1] = 1.0 - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", transpose=True) + data["P"][1, 0] = 1.0 + fieldset = FieldSet.from_data(data, dimensions, mesh="flat") fieldset.P.interp_method = "nearest" xv, yv = np.meshgrid(np.linspace(0.0, 1.0, int(np.sqrt(npart))), np.linspace(0.0, 1.0, int(np.sqrt(npart)))) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=xv.flatten(), lat=yv.flatten()) + pset = ParticleSet(fieldset, pclass=pclass(), lon=xv.flatten(), lat=yv.flatten()) pset.execute(SampleP, endtime=1, dt=1) assert np.allclose(pset.p[(pset.lon < 0.5) & (pset.lat > 0.5)], 1.0, rtol=1e-5) assert np.allclose(pset.p[(pset.lon > 0.5) | (pset.lat < 0.5)], 0.0, rtol=1e-5) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_nearest_neighbor_interpolation3D(mode): +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_nearest_neighbor_interpolation3D(): npart = 81 dims = (2, 2, 2) dimensions = { - "lon": np.linspace(0.0, 1.0, dims[0], dtype=np.float32), + "lon": np.linspace(0.0, 1.0, dims[2], dtype=np.float32), "lat": np.linspace(0.0, 1.0, dims[1], dtype=np.float32), - "depth": np.linspace(0.0, 1.0, dims[2], dtype=np.float32), + "depth": np.linspace(0.0, 1.0, dims[0], dtype=np.float32), } data = { "U": np.zeros(dims, dtype=np.float32), "V": np.zeros(dims, dtype=np.float32), "P": np.zeros(dims, dtype=np.float32), } - data["P"][0, 1, 1] = 1.0 - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", transpose=True) + data["P"][1, 1, 0] = 1.0 + fieldset = FieldSet.from_data(data, dimensions, mesh="flat") fieldset.P.interp_method = "nearest" xv, yv = np.meshgrid(np.linspace(0, 1.0, int(np.sqrt(npart))), np.linspace(0, 1.0, int(np.sqrt(npart)))) # combine a pset at 0m with pset at 1m, as meshgrid does not do 3D - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=xv.flatten(), lat=yv.flatten(), depth=np.zeros(npart)) - pset2 = ParticleSet(fieldset, pclass=pclass(mode), lon=xv.flatten(), lat=yv.flatten(), depth=np.ones(npart)) + pset = ParticleSet(fieldset, pclass=pclass(), lon=xv.flatten(), lat=yv.flatten(), depth=np.zeros(npart)) + pset2 = ParticleSet(fieldset, pclass=pclass(), lon=xv.flatten(), lat=yv.flatten(), depth=np.ones(npart)) pset.add(pset2) pset.execute(SampleP, endtime=1, dt=1) assert np.allclose(pset.p[(pset.lon < 0.5) & (pset.lat > 0.5) & (pset.depth > 0.5)], 1.0, rtol=1e-5) assert np.allclose(pset.p[(pset.lon > 0.5) | (pset.lat < 0.5) & (pset.depth < 0.5)], 0.0, rtol=1e-5) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) +@pytest.mark.v4future +@pytest.mark.xfail(reason="GH1946") @pytest.mark.parametrize("withDepth", [True, False]) @pytest.mark.parametrize("arrtype", ["ones", "rand"]) -def test_inversedistance_nearland(mode, withDepth, arrtype): +def test_inversedistance_nearland(withDepth, arrtype): npart = 81 dims = (4, 4, 6) if withDepth else (4, 6) dimensions = { @@ -249,9 +252,9 @@ def test_inversedistance_nearland(mode, withDepth, arrtype): fieldset.P.interp_method = "linear_invdist_land_tracer" xv, yv = np.meshgrid(np.linspace(0.1, 0.9, int(np.sqrt(npart))), np.linspace(0.1, 0.9, int(np.sqrt(npart)))) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=xv.flatten(), lat=yv.flatten(), depth=np.zeros(npart)) + pset = ParticleSet(fieldset, pclass=pclass(), lon=xv.flatten(), lat=yv.flatten(), depth=np.zeros(npart)) if withDepth: - pset2 = ParticleSet(fieldset, pclass=pclass(mode), lon=xv.flatten(), lat=yv.flatten(), depth=np.ones(npart)) + pset2 = ParticleSet(fieldset, pclass=pclass(), lon=xv.flatten(), lat=yv.flatten(), depth=np.ones(npart)) pset.add(pset2) pset.execute(SampleP, endtime=1, dt=1) if arrtype == "rand": @@ -268,11 +271,12 @@ def test_inversedistance_nearland(mode, withDepth, arrtype): assert success -@pytest.mark.parametrize("mode", ["scipy", "jit"]) +@pytest.mark.v4future +@pytest.mark.xfail(reason="GH1946") @pytest.mark.parametrize("boundaryslip", ["freeslip", "partialslip"]) @pytest.mark.parametrize("withW", [False, True]) @pytest.mark.parametrize("withT", [False, True]) -def test_partialslip_nearland_zonal(mode, boundaryslip, withW, withT): +def test_partialslip_nearland_zonal(boundaryslip, withW, withT): npart = 20 dims = (3, 9, 3) U = 0.1 * np.ones(dims, dtype=np.float32) @@ -302,7 +306,7 @@ def test_partialslip_nearland_zonal(mode, boundaryslip, withW, withT): fieldset = FieldSet.from_data(data, dimensions, mesh="flat", interp_method=boundaryslip) pset = ParticleSet( - fieldset, pclass=pclass(mode), lon=np.zeros(npart), lat=np.linspace(0.1, 3.9, npart), depth=np.zeros(npart) + fieldset, pclass=Particle, lon=np.zeros(npart), lat=np.linspace(0.1, 3.9, npart), depth=np.zeros(npart) ) kernel = AdvectionRK4_3D if withW else AdvectionRK4 pset.execute(kernel, endtime=2, dt=1) @@ -320,10 +324,11 @@ def test_partialslip_nearland_zonal(mode, boundaryslip, withW, withT): assert np.allclose([p.depth for p in pset], 0.1) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) +@pytest.mark.v4future +@pytest.mark.xfail(reason="GH1946") @pytest.mark.parametrize("boundaryslip", ["freeslip", "partialslip"]) @pytest.mark.parametrize("withW", [False, True]) -def test_partialslip_nearland_meridional(mode, boundaryslip, withW): +def test_partialslip_nearland_meridional(boundaryslip, withW): npart = 20 dims = (1, 1, 9) U = np.zeros(dims, dtype=np.float32) @@ -345,7 +350,7 @@ def test_partialslip_nearland_meridional(mode, boundaryslip, withW): fieldset = FieldSet.from_data(data, dimensions, mesh="flat", interp_method=interp_method) pset = ParticleSet( - fieldset, pclass=pclass(mode), lat=np.zeros(npart), lon=np.linspace(0.1, 3.9, npart), depth=np.zeros(npart) + fieldset, pclass=Particle, lat=np.zeros(npart), lon=np.linspace(0.1, 3.9, npart), depth=np.zeros(npart) ) kernel = AdvectionRK4_3D if withW else AdvectionRK4 pset.execute(kernel, endtime=2, dt=1) @@ -363,9 +368,10 @@ def test_partialslip_nearland_meridional(mode, boundaryslip, withW): assert np.allclose([p.depth for p in pset], 0.1) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) +@pytest.mark.v4future +@pytest.mark.xfail(reason="GH1946") @pytest.mark.parametrize("boundaryslip", ["freeslip", "partialslip"]) -def test_partialslip_nearland_vertical(mode, boundaryslip): +def test_partialslip_nearland_vertical(boundaryslip): npart = 20 dims = (9, 1, 1) U = 0.1 * np.ones(dims, dtype=np.float32) @@ -379,7 +385,7 @@ def test_partialslip_nearland_vertical(mode, boundaryslip): fieldset = FieldSet.from_data(data, dimensions, mesh="flat", interp_method={"U": boundaryslip, "V": boundaryslip}) pset = ParticleSet( - fieldset, pclass=pclass(mode), lon=np.zeros(npart), lat=np.zeros(npart), depth=np.linspace(0.1, 3.9, npart) + fieldset, pclass=Particle, lon=np.zeros(npart), lat=np.zeros(npart), depth=np.linspace(0.1, 3.9, npart) ) pset.execute(AdvectionRK4, endtime=2, dt=1) if boundaryslip == "partialslip": @@ -392,93 +398,87 @@ def test_partialslip_nearland_vertical(mode, boundaryslip): assert np.allclose([p.lat for p in pset], 0.1) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("lat_flip", [False, True]) -def test_fieldset_sample_particle(mode, lat_flip): - """Sample the fieldset using an array of particles. - - Note that the low tolerances (1.e-6) are due to the first-order - interpolation in JIT mode and give an indication of the - corresponding sampling error. - """ +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_fieldset_sample_particle(): + """Sample the fieldset using an array of particles.""" npart = 120 lon = np.linspace(-180, 180, 200, dtype=np.float32) - if lat_flip: - lat = np.linspace(90, -90, 100, dtype=np.float32) - else: - lat = np.linspace(-90, 90, 100, dtype=np.float32) - U, V = np.meshgrid(lat, lon) + lat = np.linspace(-90, 90, 100, dtype=np.float32) + V, U = np.meshgrid(lon, lat) data = {"U": U, "V": V} dimensions = {"lon": lon, "lat": lat} - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", transpose=True) + fieldset = FieldSet.from_data(data, dimensions, mesh="flat") lon = np.linspace(-170, 170, npart) lat = np.linspace(-80, 80, npart) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=lon, lat=np.zeros(npart) + 70.0) + pset = ParticleSet(fieldset, pclass=pclass(), lon=lon, lat=np.zeros(npart) + 70.0) pset.execute(pset.Kernel(SampleUV), endtime=1.0, dt=1.0) assert np.allclose(pset.v, lon, rtol=1e-6) - pset = ParticleSet(fieldset, pclass=pclass(mode), lat=lat, lon=np.zeros(npart) - 45.0) + pset = ParticleSet(fieldset, pclass=pclass(), lat=lat, lon=np.zeros(npart) - 45.0) pset.execute(pset.Kernel(SampleUV), endtime=1.0, dt=1.0) assert np.allclose(pset.u, lat, rtol=1e-6) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_fieldset_sample_geographic(fieldset_geometric, mode): +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_fieldset_sample_geographic(fieldset_geometric): """Sample a fieldset with conversion to geographic units (degrees).""" npart = 120 fieldset = fieldset_geometric lon = np.linspace(-170, 170, npart) lat = np.linspace(-80, 80, npart) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=lon, lat=np.zeros(npart) + 70.0) + pset = ParticleSet(fieldset, pclass=pclass(), lon=lon, lat=np.zeros(npart) + 70.0) pset.execute(pset.Kernel(SampleUV), endtime=1.0, dt=1.0) assert np.allclose(pset.v, lon, rtol=1e-6) - pset = ParticleSet(fieldset, pclass=pclass(mode), lat=lat, lon=np.zeros(npart) - 45.0) + pset = ParticleSet(fieldset, pclass=pclass(), lat=lat, lon=np.zeros(npart) - 45.0) pset.execute(pset.Kernel(SampleUV), endtime=1.0, dt=1.0) assert np.allclose(pset.u, lat, rtol=1e-6) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_fieldset_sample_geographic_noconvert(fieldset_geometric, mode): +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_fieldset_sample_geographic_noconvert(fieldset_geometric): """Sample a fieldset without conversion to geographic units.""" npart = 120 fieldset = fieldset_geometric lon = np.linspace(-170, 170, npart) lat = np.linspace(-80, 80, npart) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=lon, lat=np.zeros(npart) + 70.0) + pset = ParticleSet(fieldset, pclass=pclass(), lon=lon, lat=np.zeros(npart) + 70.0) pset.execute(pset.Kernel(SampleUVNoConvert), endtime=1.0, dt=1.0) assert np.allclose(pset.v, lon * 1000 * 1.852 * 60, rtol=1e-6) - pset = ParticleSet(fieldset, pclass=pclass(mode), lat=lat, lon=np.zeros(npart) - 45.0) + pset = ParticleSet(fieldset, pclass=pclass(), lat=lat, lon=np.zeros(npart) - 45.0) pset.execute(pset.Kernel(SampleUVNoConvert), endtime=1.0, dt=1.0) assert np.allclose(pset.u, lat * 1000 * 1.852 * 60, rtol=1e-6) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_fieldset_sample_geographic_polar(fieldset_geometric_polar, mode): +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_fieldset_sample_geographic_polar(fieldset_geometric_polar): """Sample a fieldset with conversion to geographic units and a pole correction.""" npart = 120 fieldset = fieldset_geometric_polar lon = np.linspace(-170, 170, npart) lat = np.linspace(-80, 80, npart) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=lon, lat=np.zeros(npart) + 70.0) + pset = ParticleSet(fieldset, pclass=pclass(), lon=lon, lat=np.zeros(npart) + 70.0) pset.execute(pset.Kernel(SampleUV), endtime=1.0, dt=1.0) assert np.allclose(pset.v, lon, rtol=1e-6) - pset = ParticleSet(fieldset, pclass=pclass(mode), lat=lat, lon=np.zeros(npart) - 45.0) + pset = ParticleSet(fieldset, pclass=pclass(), lat=lat, lon=np.zeros(npart) - 45.0) pset.execute(pset.Kernel(SampleUV), endtime=1.0, dt=1.0) - # Note: 1.e-2 is a very low rtol, so there seems to be a rather - # large sampling error for the JIT correction. assert np.allclose(pset.u, lat, rtol=1e-2) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_meridionalflow_spherical(mode): +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_meridionalflow_spherical(): """Create uniform NORTHWARD flow on spherical earth and advect particles. As flow is so simple, it can be directly compared to analytical solution. @@ -491,14 +491,14 @@ def test_meridionalflow_spherical(mode): "lon": np.linspace(-180, 180, xdim, dtype=np.float32), "lat": np.linspace(-90, 90, ydim, dtype=np.float32), } - data = {"U": np.zeros([xdim, ydim]), "V": maxvel * np.ones([xdim, ydim])} + data = {"U": np.zeros([ydim, xdim]), "V": maxvel * np.ones([ydim, xdim])} - fieldset = FieldSet.from_data(data, dimensions, mesh="spherical", transpose=True) + fieldset = FieldSet.from_data(data, dimensions, mesh="spherical") lonstart = [0, 45] latstart = [0, 45] runtime = timedelta(hours=24) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=lonstart, lat=latstart) + pset = ParticleSet(fieldset, pclass=Particle, lon=lonstart, lat=latstart) pset.execute(pset.Kernel(AdvectionRK4), runtime=runtime, dt=timedelta(hours=1)) assert pset.lat[0] - (latstart[0] + runtime.total_seconds() * maxvel / 1852 / 60) < 1e-4 @@ -507,8 +507,9 @@ def test_meridionalflow_spherical(mode): assert pset.lon[1] - lonstart[1] < 1e-4 -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_zonalflow_spherical(mode): +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_zonalflow_spherical(): """Create uniform EASTWARD flow on spherical earth and advect particles. As flow is so simple, it can be directly compared to analytical solution @@ -522,14 +523,14 @@ def test_zonalflow_spherical(mode): "lon": np.linspace(-180, 180, xdim, dtype=np.float32), "lat": np.linspace(-90, 90, ydim, dtype=np.float32), } - data = {"U": maxvel * np.ones([xdim, ydim]), "V": np.zeros([xdim, ydim]), "P": p_fld * np.ones([xdim, ydim])} + data = {"U": maxvel * np.ones([ydim, xdim]), "V": np.zeros([ydim, xdim]), "P": p_fld * np.ones([ydim, xdim])} - fieldset = FieldSet.from_data(data, dimensions, mesh="spherical", transpose=True) + fieldset = FieldSet.from_data(data, dimensions, mesh="spherical") lonstart = [0, 45] latstart = [0, 45] runtime = timedelta(hours=24) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=lonstart, lat=latstart) + pset = ParticleSet(fieldset, pclass=pclass(), lon=lonstart, lat=latstart) pset.execute(pset.Kernel(AdvectionRK4) + SampleP, runtime=runtime, dt=timedelta(hours=1)) assert pset.lat[0] - latstart[0] < 1e-4 @@ -544,8 +545,9 @@ def test_zonalflow_spherical(mode): assert abs(pset.p[1] - p_fld) < 1e-4 -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_random_field(mode): +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") +def test_random_field(): """Sampling test that tests for overshoots by sampling a field of random numbers between 0 and 1.""" xdim, ydim = 20, 20 npart = 100 @@ -556,22 +558,23 @@ def test_random_field(mode): "lat": np.linspace(0.0, 1.0, ydim, dtype=np.float32), } data = { - "U": np.zeros((xdim, ydim), dtype=np.float32), - "V": np.zeros((xdim, ydim), dtype=np.float32), - "P": np.random.uniform(0, 1.0, size=(xdim, ydim)), - "start": np.ones((xdim, ydim), dtype=np.float32), + "U": np.zeros((ydim, xdim), dtype=np.float32), + "V": np.zeros((ydim, xdim), dtype=np.float32), + "P": np.random.uniform(0, 1.0, size=(ydim, xdim)), + "start": np.ones((ydim, xdim), dtype=np.float32), } - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", transpose=True) - pset = ParticleSet.from_field(fieldset, size=npart, pclass=pclass(mode), start_field=fieldset.start) + fieldset = FieldSet.from_data(data, dimensions, mesh="flat") + pset = ParticleSet.from_field(fieldset, size=npart, pclass=pclass(), start_field=fieldset.start) pset.execute(SampleP, endtime=1.0, dt=1.0) sampled = pset.p assert (sampled >= 0.0).all() -@pytest.mark.parametrize("mode", ["scipy", "jit"]) +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="GH1946") @pytest.mark.parametrize("allow_time_extrapolation", [True, False]) -def test_sampling_out_of_bounds_time(mode, allow_time_extrapolation): +def test_sampling_out_of_bounds_time(allow_time_extrapolation): xdim, ydim, tdim = 10, 10, 10 dimensions = { @@ -580,15 +583,13 @@ def test_sampling_out_of_bounds_time(mode, allow_time_extrapolation): "time": np.linspace(0.0, 1.0, tdim, dtype=np.float64), } data = { - "U": np.zeros((xdim, ydim, tdim), dtype=np.float32), - "V": np.zeros((xdim, ydim, tdim), dtype=np.float32), - "P": np.ones((xdim, ydim, 1), dtype=np.float32) * dimensions["time"], + "U": np.zeros((tdim, ydim, xdim), dtype=np.float32), + "V": np.zeros((tdim, ydim, xdim), dtype=np.float32), + "P": np.transpose(np.ones((xdim, ydim, 1), dtype=np.float32) * dimensions["time"]), } - fieldset = FieldSet.from_data( - data, dimensions, mesh="flat", allow_time_extrapolation=allow_time_extrapolation, transpose=True - ) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0.5], lat=[0.5], time=-1.0) + fieldset = FieldSet.from_data(data, dimensions, mesh="flat", allow_time_extrapolation=allow_time_extrapolation) + pset = ParticleSet(fieldset, pclass=pclass(), lon=[0.5], lat=[0.5], time=-1.0) if allow_time_extrapolation: pset.execute(SampleP, endtime=-0.9, dt=0.1) assert np.allclose(pset.p, 0.0, rtol=1e-5) @@ -596,19 +597,19 @@ def test_sampling_out_of_bounds_time(mode, allow_time_extrapolation): with pytest.raises(RuntimeError): pset.execute(SampleP, endtime=-0.9, dt=0.1) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0.5], lat=[0.5], time=0) + pset = ParticleSet(fieldset, pclass=pclass(), lon=[0.5], lat=[0.5], time=0) pset.execute(SampleP, runtime=0.1, dt=0.1) assert np.allclose(pset.p, 0.0, rtol=1e-5) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0.5], lat=[0.5], time=0.5) + pset = ParticleSet(fieldset, pclass=pclass(), lon=[0.5], lat=[0.5], time=0.5) pset.execute(SampleP, runtime=0.1, dt=0.1) assert np.allclose(pset.p, 0.5, rtol=1e-5) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0.5], lat=[0.5], time=1.0) + pset = ParticleSet(fieldset, pclass=pclass(), lon=[0.5], lat=[0.5], time=1.0) pset.execute(SampleP, runtime=0.1, dt=0.1) assert np.allclose(pset.p, 1.0, rtol=1e-5) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0.5], lat=[0.5], time=2.0) + pset = ParticleSet(fieldset, pclass=pclass(), lon=[0.5], lat=[0.5], time=2.0) if allow_time_extrapolation: pset.execute(SampleP, runtime=0.1, dt=0.1) assert np.allclose(pset.p, 1.0, rtol=1e-5) @@ -617,12 +618,13 @@ def test_sampling_out_of_bounds_time(mode, allow_time_extrapolation): pset.execute(SampleP, runtime=0.1, dt=0.1) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_sampling_3DCROCO(mode): +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="When refactoring fieldfilebuffer croco support was dropped. This will be fixed in v4.") +def test_sampling_3DCROCO(): data_path = os.path.join(os.path.dirname(__file__), "test_data/") fieldset = FieldSet.from_modulefile(data_path + "fieldset_CROCO3D.py") - SampleP = ptype[mode].add_variable("p", initial=0.0) + SampleP = Particle.add_variable("p", initial=0.0) def SampleU(particle, fieldset, time): # pragma: no cover particle.p = fieldset.U[time, particle.depth, particle.lat, particle.lon, particle] @@ -632,10 +634,12 @@ def SampleU(particle, fieldset, time): # pragma: no cover assert np.isclose(pset.p, 1.0) -@pytest.mark.parametrize("mode", ["jit", "scipy"]) +@pytest.mark.v4alpha +@pytest.mark.xfail( + reason="Now timestamps has been removed, and filebuffer expects different files. This needs to be rewritten/removed." +) @pytest.mark.parametrize("npart", [1, 10]) -@pytest.mark.parametrize("chs", [False, "auto", {"lat": ("y", 10), "lon": ("x", 10)}]) -def test_sampling_multigrids_non_vectorfield_from_file(mode, npart, tmpdir, chs): +def test_sampling_multigrids_non_vectorfield_from_file(npart, tmpdir): xdim, ydim = 100, 200 filepath = tmpdir.join("test_subsets") U = Field( @@ -669,18 +673,13 @@ def test_sampling_multigrids_non_vectorfield_from_file(mode, npart, tmpdir, chs) files = {"U": ufiles, "V": vfiles, "B": bfiles} variables = {"U": "vozocrtx", "V": "vomecrty", "B": "B"} dimensions = {"lon": "nav_lon", "lat": "nav_lat"} - fieldset = FieldSet.from_netcdf( - files, variables, dimensions, timestamps=timestamps, allow_time_extrapolation=True, chunksize=chs - ) + fieldset = FieldSet.from_netcdf(files, variables, dimensions, timestamps=timestamps, allow_time_extrapolation=True) fieldset.add_constant("sample_depth", 2.5) - if chs == "auto": - assert fieldset.U.grid != fieldset.V.grid - else: - assert fieldset.U.grid is fieldset.V.grid + assert fieldset.U.grid is fieldset.V.grid assert fieldset.U.grid is not fieldset.B.grid - TestParticle = ptype[mode].add_variable("sample_var", initial=0.0) + TestParticle = Particle.add_variable("sample_var", initial=0.0) pset = ParticleSet.from_line(fieldset, pclass=TestParticle, start=[0.3, 0.3], finish=[0.7, 0.7], size=npart) @@ -690,23 +689,12 @@ def test_sample(particle, fieldset, time): # pragma: no cover kernels = pset.Kernel(AdvectionRK4) + pset.Kernel(test_sample) pset.execute(kernels, runtime=10, dt=1) assert np.allclose(pset.sample_var, 10.0) - if mode == "jit": - assert len(pset.xi.shape) == 2 - assert pset.xi.shape[0] == len(pset.lon) - assert pset.xi.shape[1] == fieldset.gridset.size - assert np.all(pset.xi >= 0) - assert np.all(pset.xi[:, fieldset.B.igrid] < xdim * 4) - assert np.all(pset.xi[:, 0] < xdim) - assert pset.yi.shape[0] == len(pset.lon) - assert pset.yi.shape[1] == fieldset.gridset.size - assert np.all(pset.yi >= 0) - assert np.all(pset.yi[:, fieldset.B.igrid] < ydim * 3) - assert np.all(pset.yi[:, 0] < ydim) - - -@pytest.mark.parametrize("mode", ["jit", "scipy"]) + + +@pytest.mark.v4future +@pytest.mark.xfail(reason="GH1946") @pytest.mark.parametrize("npart", [1, 10]) -def test_sampling_multigrids_non_vectorfield(mode, npart): +def test_sampling_multigrids_non_vectorfield(npart): xdim, ydim = 100, 200 U = Field( "U", @@ -732,7 +720,7 @@ def test_sampling_multigrids_non_vectorfield(mode, npart): assert fieldset.U.grid is fieldset.V.grid assert fieldset.U.grid is not fieldset.B.grid - TestParticle = ptype[mode].add_variable("sample_var", initial=0.0) + TestParticle = Particle.add_variable("sample_var", initial=0.0) pset = ParticleSet.from_line(fieldset, pclass=TestParticle, start=[0.3, 0.3], finish=[0.7, 0.7], size=npart) @@ -742,23 +730,12 @@ def test_sample(particle, fieldset, time): # pragma: no cover kernels = pset.Kernel(AdvectionRK4) + pset.Kernel(test_sample) pset.execute(kernels, runtime=10, dt=1) assert np.allclose(pset.sample_var, 10.0) - if mode == "jit": - assert len(pset.xi.shape) == 2 - assert pset.xi.shape[0] == len(pset.lon) - assert pset.xi.shape[1] == fieldset.gridset.size - assert np.all(pset.xi >= 0) - assert np.all(pset.xi[:, fieldset.B.igrid] < xdim * 4) - assert np.all(pset.xi[:, 0] < xdim) - assert pset.yi.shape[0] == len(pset.lon) - assert pset.yi.shape[1] == fieldset.gridset.size - assert np.all(pset.yi >= 0) - assert np.all(pset.yi[:, fieldset.B.igrid] < ydim * 3) - assert np.all(pset.yi[:, 0] < ydim) - - -@pytest.mark.parametrize("mode", ["jit", "scipy"]) + + +@pytest.mark.v4future +@pytest.mark.xfail(reason="GH1946") @pytest.mark.parametrize("ugridfactor", [1, 10]) -def test_sampling_multiple_grid_sizes(mode, ugridfactor): +def test_sampling_multiple_grid_sizes(ugridfactor): xdim, ydim = 10, 20 U = Field( "U", @@ -773,7 +750,7 @@ def test_sampling_multiple_grid_sizes(mode, ugridfactor): lat=np.linspace(0.0, 1.0, ydim, dtype=np.float32), ) fieldset = FieldSet(U, V) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0.8], lat=[0.9]) + pset = ParticleSet(fieldset, pclass=Particle, lon=[0.8], lat=[0.9]) if ugridfactor > 1: assert fieldset.U.grid is not fieldset.V.grid @@ -784,6 +761,8 @@ def test_sampling_multiple_grid_sizes(mode, ugridfactor): assert np.all((0 <= pset.xi) & (pset.xi < xdim * ugridfactor)) +@pytest.mark.v4future +@pytest.mark.xfail(reason="GH1946") def test_multiple_grid_addlater_error(): xdim, ydim = 10, 20 U = Field( @@ -800,7 +779,7 @@ def test_multiple_grid_addlater_error(): ) fieldset = FieldSet(U, V) - pset = ParticleSet(fieldset, pclass=pclass("jit"), lon=[0.8], lat=[0.9]) # noqa ; to trigger fieldset._check_complete + pset = ParticleSet(fieldset, pclass=Particle, lon=[0.8], lat=[0.9]) # noqa ; to trigger fieldset._check_complete P = Field( "P", @@ -817,8 +796,11 @@ def test_multiple_grid_addlater_error(): assert fail -@pytest.mark.parametrize("mode", ["jit", "scipy"]) -def test_nestedfields(mode): +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="Implementation of NestedFields is being reconsidered in v4.") +def test_nestedfields(): + from parcels import NestedField + xdim = 10 ydim = 20 @@ -867,31 +849,30 @@ def test_nestedfields(mode): def Recover(particle, fieldset, time): # pragma: no cover if particle.state == StatusCode.ErrorOutOfBounds: - particle_dlon = 0 # noqa - particle_dlat = 0 # noqa - particle_ddepth = 0 # noqa + particle.dlon = 0 + particle.dlat = 0 + particle.ddepth = 0 particle.lon = 0 particle.lat = 0 particle.p = 999 particle.state = StatusCode.Evaluate - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0], lat=[0.3]) + pset = ParticleSet(fieldset, pclass=pclass(), lon=[0], lat=[0.3]) pset.execute(AdvectionRK4 + pset.Kernel(SampleP), runtime=2, dt=1) assert np.isclose(pset.lat[0], 0.5) assert np.isclose(pset.p[0], 0.1) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0], lat=[1.1]) + pset = ParticleSet(fieldset, pclass=pclass(), lon=[0], lat=[1.1]) pset.execute(AdvectionRK4 + pset.Kernel(SampleP), runtime=2, dt=1) assert np.isclose(pset.lat[0], 1.5) assert np.isclose(pset.p[0], 0.2) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0], lat=[2.3]) + pset = ParticleSet(fieldset, pclass=pclass(), lon=[0], lat=[2.3]) pset.execute(pset.Kernel(AdvectionRK4) + SampleP + Recover, runtime=1, dt=1) assert np.isclose(pset.lat[0], 0) assert np.isclose(pset.p[0], 999) assert np.allclose(fieldset.UV[0][0, 0, 0, 0], [0.1, 0.2]) -@pytest.mark.parametrize("mode", ["jit", "scipy"]) -def test_fieldset_sampling_updating_order(mode, tmp_zarrfile): +def test_fieldset_sampling_updating_order(tmp_zarrfile): def calc_p(t, y, x): return 10 * t + x + 0.2 * y @@ -916,7 +897,7 @@ def calc_p(t, y, x): fieldset = FieldSet.from_data(data, dimensions, mesh="flat") xv, yv = np.meshgrid(np.arange(0, 1, 0.5), np.arange(0, 1, 0.5)) - pset = ParticleSet(fieldset, pclass=pclass(mode), lon=xv.flatten(), lat=yv.flatten()) + pset = ParticleSet(fieldset, pclass=pclass(), lon=xv.flatten(), lat=yv.flatten()) def SampleP(particle, fieldset, time): # pragma: no cover particle.p = fieldset.P[time, particle.depth, particle.lat, particle.lon] diff --git a/tests/test_interaction.py b/tests-v3/test_interaction.py similarity index 87% rename from tests/test_interaction.py rename to tests-v3/test_interaction.py index 9d1b84809..c20fdda88 100644 --- a/tests/test_interaction.py +++ b/tests-v3/test_interaction.py @@ -1,7 +1,7 @@ import numpy as np import pytest -from parcels import Field, FieldSet, JITParticle, ParticleSet +from parcels import Field, FieldSet, ParticleSet from parcels.application_kernels.advection import AdvectionRK4 from parcels.application_kernels.interaction import ( AsymmetricAttraction, @@ -16,12 +16,10 @@ KDTreeFlatNeighborSearch, ) from parcels.interaction.neighborsearch.basehash import BaseHashNeighborSearch -from parcels.particle import ScipyInteractionParticle, ScipyParticle, Variable +from parcels.particle import InteractionParticle, Variable from tests.common_kernels import DoNothing from tests.utils import create_fieldset_unit_mesh, create_flat_positions, create_spherical_positions -ptype = {"scipy": ScipyInteractionParticle, "jit": JITParticle} - def DummyMoveNeighbor(particle, fieldset, time, neighbors, mutator): """A particle boosts the movement of its nearest neighbor, by adding 0.1 to its lat position.""" @@ -34,7 +32,7 @@ def DummyMoveNeighbor(particle, fieldset, time, neighbors, mutator): def f(p): p.lat_nextloop += 0.1 - neighbor_id = neighbors[i_min_dist].id + neighbor_id = neighbors[i_min_dist].trajectory mutator[neighbor_id].append((f, ())) pass @@ -45,29 +43,31 @@ def fieldset_unit_mesh(): return create_fieldset_unit_mesh(mesh="spherical") -@pytest.mark.parametrize("mode", ["scipy"]) -def test_simple_interaction_kernel(fieldset_unit_mesh, mode): +def test_simple_interaction_kernel(fieldset_unit_mesh): lons = [0.0, 0.1, 0.25, 0.44] lats = [0.0, 0.0, 0.0, 0.0] # Distance in meters R_earth*0.2 degrees interaction_distance = 6371000 * 0.2 * np.pi / 180 pset = ParticleSet( - fieldset_unit_mesh, pclass=ptype[mode], lon=lons, lat=lats, interaction_distance=interaction_distance + fieldset_unit_mesh, + pclass=InteractionParticle, + lon=lons, + lat=lats, + interaction_distance=interaction_distance, ) pset.execute(DoNothing, pyfunc_inter=DummyMoveNeighbor, endtime=2.0, dt=1.0) assert np.allclose(pset.lat, [0.1, 0.2, 0.1, 0.0], rtol=1e-5) -@pytest.mark.parametrize("mode", ["scipy"]) @pytest.mark.parametrize("mesh", ["spherical", "flat"]) @pytest.mark.parametrize("periodic_domain_zonal", [False, True]) -def test_zonal_periodic_distance(mode, mesh, periodic_domain_zonal): +def test_zonal_periodic_distance(mesh, periodic_domain_zonal): fset = create_fieldset_unit_mesh(mesh=mesh) interaction_distance = 0.2 if mesh == "flat" else 6371000 * 0.2 * np.pi / 180 lons = [0.05, 0.4, 0.95] pset = ParticleSet( fset, - pclass=ptype[mode], + pclass=InteractionParticle, lon=lons, lat=[0.5] * len(lons), interaction_distance=interaction_distance, @@ -81,15 +81,18 @@ def test_zonal_periodic_distance(mode, mesh, periodic_domain_zonal): assert np.allclose([p.lat for p in pset], 0.5) -@pytest.mark.parametrize("mode", ["scipy"]) -def test_concatenate_interaction_kernels(fieldset_unit_mesh, mode): +def test_concatenate_interaction_kernels(fieldset_unit_mesh): lons = [0.0, 0.1, 0.25, 0.44] lats = [0.0, 0.0, 0.0, 0.0] # Distance in meters R_earth*0.2 degrees interaction_distance = 6371000 * 0.2 * np.pi / 180 pset = ParticleSet( - fieldset_unit_mesh, pclass=ptype[mode], lon=lons, lat=lats, interaction_distance=interaction_distance + fieldset_unit_mesh, + pclass=InteractionParticle, + lon=lons, + lat=lats, + interaction_distance=interaction_distance, ) pset.execute( DoNothing, @@ -103,15 +106,18 @@ def test_concatenate_interaction_kernels(fieldset_unit_mesh, mode): assert np.allclose(pset.lat, [0.2, 0.4, 0.2, 0.0], rtol=1e-5) -@pytest.mark.parametrize("mode", ["scipy"]) -def test_concatenate_interaction_kernels_as_pyfunc(fieldset_unit_mesh, mode): +def test_concatenate_interaction_kernels_as_pyfunc(fieldset_unit_mesh): lons = [0.0, 0.1, 0.25, 0.44] lats = [0.0, 0.0, 0.0, 0.0] # Distance in meters R_earth*0.2 degrees interaction_distance = 6371000 * 0.2 * np.pi / 180 pset = ParticleSet( - fieldset_unit_mesh, pclass=ptype[mode], lon=lons, lat=lats, interaction_distance=interaction_distance + fieldset_unit_mesh, + pclass=InteractionParticle, + lon=lons, + lat=lats, + interaction_distance=interaction_distance, ) pset.execute( DoNothing, pyfunc_inter=pset.InteractionKernel(DummyMoveNeighbor) + DummyMoveNeighbor, endtime=2.0, dt=1.0 @@ -127,7 +133,7 @@ def test_neighbor_merge(fieldset_unit_mesh): lats = [0.0, 0.0, 0.0, 0.0] # Distance in meters R_earth*0.2 degrees interaction_distance = 6371000 * 5.5 * np.pi / 180 - MergeParticle = ScipyInteractionParticle.add_variables( + MergeParticle = InteractionParticle.add_variables( [Variable("nearest_neighbor", dtype=np.int64, to_write=False), Variable("mass", initial=1, dtype=np.float32)] ) pset = ParticleSet( @@ -140,13 +146,12 @@ def test_neighbor_merge(fieldset_unit_mesh): assert len(pset) == 1 -@pytest.mark.parametrize("mode", ["scipy"]) -def test_asymmetric_attraction(fieldset_unit_mesh, mode): +def test_asymmetric_attraction(fieldset_unit_mesh): lons = [0.0, 0.1, 0.2] lats = [0.0, 0.0, 0.0] # Distance in meters R_earth*0.2 degrees interaction_distance = 6371000 * 5.5 * np.pi / 180 - AttractingParticle = ScipyInteractionParticle.add_variable("attractor", dtype=np.bool_, to_write="once") + AttractingParticle = InteractionParticle.add_variable("attractor", dtype=np.bool_, to_write="once") pset = ParticleSet( fieldset_unit_mesh, pclass=AttractingParticle, @@ -167,7 +172,7 @@ def ConstantMoveInteraction(particle, fieldset, time, neighbors, mutator): def f(p): p.lat_nextloop += p.dt - mutator[particle.id].append((f, ())) + mutator[particle.trajectory].append((f, ())) @pytest.mark.parametrize("runtime, dt", [(1, 1e-2), (1, -2.123e-3), (1, -3.12452 - 3)]) @@ -185,11 +190,11 @@ def test_pseudo_interaction(runtime, dt): fieldset = FieldSet(Uflow, Vflow) # Execute the advection kernel only - pset = ParticleSet(fieldset, pclass=ScipyParticle, lon=[2], lat=[2]) + pset = ParticleSet(fieldset, pclass=InteractionParticle, lon=[2], lat=[2]) pset.execute(AdvectionRK4, runtime=runtime, dt=dt) # Execute both the advection and interaction kernel. - pset2 = ParticleSet(fieldset, pclass=ScipyInteractionParticle, lon=[2], lat=[2], interaction_distance=1) + pset2 = ParticleSet(fieldset, pclass=InteractionParticle, lon=[2], lat=[2], interaction_distance=1) pyfunc_inter = pset2.InteractionKernel(ConstantMoveInteraction) pset2.execute(AdvectionRK4, pyfunc_inter=pyfunc_inter, runtime=runtime, dt=dt) diff --git a/tests-v3/test_interpolation.py b/tests-v3/test_interpolation.py new file mode 100644 index 000000000..67eab6420 --- /dev/null +++ b/tests-v3/test_interpolation.py @@ -0,0 +1,64 @@ +import pytest + +import parcels._interpolation as interpolation +from tests.utils import create_fieldset_zeros_3d + + +@pytest.fixture +def tmp_interpolator_registry(): + """Resets the interpolator registry after the test. Vital when testing manipulating the registry.""" + old_2d = interpolation._interpolator_registry_2d.copy() + old_3d = interpolation._interpolator_registry_3d.copy() + yield + interpolation._interpolator_registry_2d = old_2d + interpolation._interpolator_registry_3d = old_3d + + +@pytest.mark.usefixtures("tmp_interpolator_registry") +def test_interpolation_registry(): + @interpolation.register_3d_interpolator("test") + @interpolation.register_2d_interpolator("test") + def some_function(): + return "test" + + assert "test" in interpolation.get_2d_interpolator_registry() + assert "test" in interpolation.get_3d_interpolator_registry() + + f = interpolation.get_2d_interpolator_registry()["test"] + g = interpolation.get_3d_interpolator_registry()["test"] + assert f() == g() == "test" + + +@pytest.mark.v4remove +@pytest.mark.xfail(reason="GH1946") +@pytest.mark.usefixtures("tmp_interpolator_registry") +def test_interpolator_override(): + fieldset = create_fieldset_zeros_3d() + + @interpolation.register_3d_interpolator("linear") + def test_interpolator(ctx: interpolation.InterpolationContext3D): + raise NotImplementedError + + with pytest.raises(NotImplementedError): + fieldset.U[0, 0.5, 0.5, 0.5] + + +@pytest.mark.v4remove +@pytest.mark.xfail(reason="GH1946") +@pytest.mark.usefixtures("tmp_interpolator_registry") +def test_full_depth_provided_to_interpolators(): + """The full depth needs to be provided to the interpolation schemes as some interpolators + need to know whether they are at the surface or bottom of the water column. + + https://github.com/OceanParcels/Parcels/pull/1816#discussion_r1908840408 + """ + xdim, ydim, zdim = 10, 11, 12 + fieldset = create_fieldset_zeros_3d(xdim=xdim, ydim=ydim, zdim=zdim) + + @interpolation.register_3d_interpolator("linear") + def test_interpolator2(ctx: interpolation.InterpolationContext3D): + assert ctx.data.shape[1] == zdim + # The array z dimension is the same as the fieldset z dimension + return 0 + + fieldset.U[0.5, 0.5, 0.5, 0.5] diff --git a/tests-v3/test_kernel_execution.py b/tests-v3/test_kernel_execution.py new file mode 100644 index 000000000..6a61f2986 --- /dev/null +++ b/tests-v3/test_kernel_execution.py @@ -0,0 +1,84 @@ +import numpy as np +import pytest + +from parcels import ( + FieldSet, + Particle, + ParticleSet, +) +from tests.utils import create_fieldset_unit_mesh + + +@pytest.fixture +def fieldset_unit_mesh(): + return create_fieldset_unit_mesh() + + +@pytest.mark.parametrize("kernel_type", ["update_lon", "update_dlon"]) +def test_execution_order(kernel_type): + fieldset = FieldSet.from_data( + {"U": [[0, 1], [2, 3]], "V": np.ones((2, 2))}, {"lon": [0, 2], "lat": [0, 2]}, mesh="flat" + ) + + def MoveLon_Update_Lon(particle, fieldset, time): # pragma: no cover + particle.lon += 0.2 + + def MoveLon_Update_dlon(particle, fieldset, time): # pragma: no cover + particle.dlon += 0.2 + + def SampleP(particle, fieldset, time): # pragma: no cover + particle.p = fieldset.U[time, particle.depth, particle.lat, particle.lon] + + SampleParticle = Particle.add_variable("p", dtype=np.float32, initial=0.0) + + MoveLon = MoveLon_Update_dlon if kernel_type == "update_dlon" else MoveLon_Update_Lon + + kernels = [MoveLon, SampleP] + lons = [] + ps = [] + for dir in [1, -1]: + pset = ParticleSet(fieldset, pclass=SampleParticle, lon=0, lat=0) + pset.execute(kernels[::dir], endtime=1, dt=1) + lons.append(pset.lon) + ps.append(pset.p) + + if kernel_type == "update_dlon": + assert np.isclose(lons[0], lons[1]) + assert np.isclose(ps[0], ps[1]) + assert np.allclose(lons[0], 0) + else: + assert np.isclose(ps[0] - ps[1], 0.1) + assert np.allclose(lons[0], 0.2) + + +def test_multi_kernel_duplicate_varnames(fieldset_unit_mesh): + # Testing for merging of two Kernels with the same variable declared + # Should throw a warning, but go ahead regardless + def Kernel1(particle, fieldset, time): # pragma: no cover + add_lon = 0.1 + particle.dlon += add_lon + + def Kernel2(particle, fieldset, time): # pragma: no cover + add_lon = -0.3 + particle.dlon += add_lon + + pset = ParticleSet(fieldset_unit_mesh, pclass=Particle, lon=[0.5], lat=[0.5]) + pset.execute([Kernel1, Kernel2], endtime=2.0, dt=1.0) + assert np.allclose(pset.lon, 0.3, rtol=1e-5) + + +def test_update_kernel_in_script(fieldset_unit_mesh): + # Testing what happens when kernels are updated during runtime of a script + # Should throw a warning, but go ahead regardless + def MoveEast(particle, fieldset, time): # pragma: no cover + add_lon = 0.1 + particle.dlon += add_lon + + def MoveWest(particle, fieldset, time): # pragma: no cover + add_lon = -0.3 + particle.dlon += add_lon + + pset = ParticleSet(fieldset_unit_mesh, pclass=Particle, lon=[0.5], lat=[0.5]) + pset.execute(pset.Kernel(MoveEast), endtime=1.0, dt=1.0) + pset.execute(pset.Kernel(MoveWest), endtime=3.0, dt=1.0) + assert np.allclose(pset.lon, 0.3, rtol=1e-5) # should be 0.5 + 0.1 - 0.3 = 0.3 diff --git a/tests/test_kernel_language.py b/tests-v3/test_kernel_language.py similarity index 61% rename from tests/test_kernel_language.py rename to tests-v3/test_kernel_language.py index 863a97728..76b3ad1ba 100644 --- a/tests/test_kernel_language.py +++ b/tests-v3/test_kernel_language.py @@ -1,5 +1,4 @@ -import os -import random as py_random +import random from contextlib import nullcontext as does_not_raise import numpy as np @@ -8,11 +7,9 @@ from parcels import ( Field, FieldSet, - JITParticle, Kernel, - ParcelsRandom, + Particle, ParticleSet, - ScipyParticle, Variable, ) from parcels.application_kernels.EOSseawaterproperties import ( @@ -25,23 +22,18 @@ from tests.common_kernels import DoNothing from tests.utils import create_fieldset_unit_mesh -ptype = {"scipy": ScipyParticle, "jit": JITParticle} - def expr_kernel(name, pset, expr): pycode = (f"def {name}(particle, fieldset, time):\n" f" particle.p = {expr}") # fmt: skip - return Kernel( - pset.fieldset, pset.particledata.ptype, pyfunc=None, funccode=pycode, funcname=name, funcvars=["particle"] - ) + return Kernel(pset.fieldset, pset.particledata.ptype, pyfunc=None, funccode=pycode, funcname=name) @pytest.fixture def fieldset_unit_mesh(): - return create_fieldset_unit_mesh(transpose=True) + return create_fieldset_unit_mesh() -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize( "name, expr, result", [ @@ -51,10 +43,10 @@ def fieldset_unit_mesh(): ("Div", "24 / 4", 6), ], ) -def test_expression_int(mode, name, expr, result): +def test_expression_int(name, expr, result): """Test basic arithmetic expressions.""" npart = 10 - TestParticle = ptype[mode].add_variable("p", dtype=np.float32, initial=0) + TestParticle = Particle.add_variable("p", dtype=np.float32, initial=0) pset = ParticleSet( create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, @@ -65,7 +57,6 @@ def test_expression_int(mode, name, expr, result): assert np.all([p.p == result for p in pset]) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize( "name, expr, result", [ @@ -76,10 +67,10 @@ def test_expression_int(mode, name, expr, result): ("Pow", "2 ** 3", 8), ], ) -def test_expression_float(mode, name, expr, result): +def test_expression_float(name, expr, result): """Test basic arithmetic expressions.""" npart = 10 - TestParticle = ptype[mode].add_variable("p", dtype=np.float32, initial=0) + TestParticle = Particle.add_variable("p", dtype=np.float32, initial=0) pset = ParticleSet( create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, @@ -90,7 +81,6 @@ def test_expression_float(mode, name, expr, result): assert np.all([p.p == result for p in pset]) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize( "name, expr, result", [ @@ -107,10 +97,10 @@ def test_expression_float(mode, name, expr, result): ("CheckNaN", "math.nan != math.nan", True), ], ) -def test_expression_bool(mode, name, expr, result): +def test_expression_bool(name, expr, result): """Test basic arithmetic expressions.""" npart = 10 - TestParticle = ptype[mode].add_variable("p", dtype=np.float32, initial=0) + TestParticle = Particle.add_variable("p", dtype=np.float32, initial=0) pset = ParticleSet( create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, @@ -118,16 +108,12 @@ def test_expression_bool(mode, name, expr, result): lat=np.zeros(npart) + 0.5, ) pset.execute(expr_kernel(f"Test{name}", pset, expr), endtime=1.0, dt=1.0) - if mode == "jit": - assert np.all(result == (pset.p == 1)) - else: - assert np.all(result == pset.p) + assert np.all(result == pset.p) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_while_if_break(mode): +def test_while_if_break(): """Test while, if and break commands.""" - TestParticle = ptype[mode].add_variable("p", dtype=np.float32, initial=0) + TestParticle = Particle.add_variable("p", dtype=np.float32, initial=0) pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, lon=[0], lat=[0]) def kernel(particle, fieldset, time): # pragma: no cover @@ -142,10 +128,9 @@ def kernel(particle, fieldset, time): # pragma: no cover assert np.allclose(pset.p, 20.0, rtol=1e-12) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_nested_if(mode): +def test_nested_if(): """Test nested if commands.""" - TestParticle = ptype[mode].add_variables( + TestParticle = Particle.add_variables( [Variable("p0", dtype=np.int32, initial=0), Variable("p1", dtype=np.int32, initial=1)] ) pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, lon=0, lat=0) @@ -160,10 +145,9 @@ def kernel(particle, fieldset, time): # pragma: no cover assert np.allclose([pset.p0[0], pset.p1[0]], [0, 1]) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pass(mode): +def test_pass(): """Test pass commands.""" - TestParticle = ptype[mode].add_variable("p", dtype=np.float32, initial=0) + TestParticle = Particle.add_variable("p", dtype=np.float32, initial=0) pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, lon=0, lat=0) def kernel(particle, fieldset, time): # pragma: no cover @@ -174,9 +158,8 @@ def kernel(particle, fieldset, time): # pragma: no cover assert np.allclose(pset[0].p, -1) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_dt_as_variable_in_kernel(mode): - pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=ptype[mode], lon=0, lat=0) +def test_dt_as_variable_in_kernel(): + pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=Particle, lon=0, lat=0) def kernel(particle, fieldset, time): # pragma: no cover dt = 1.0 # noqa @@ -184,28 +167,13 @@ def kernel(particle, fieldset, time): # pragma: no cover pset.execute(kernel, endtime=10, dt=1.0) -def test_parcels_tmpvar_in_kernel(): - """Tests for error thrown if variable with 'tmp' defined in custom kernel.""" - pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=JITParticle, lon=0, lat=0) - - def kernel_tmpvar(particle, fieldset, time): # pragma: no cover - parcels_tmpvar0 = 0 # noqa - - def kernel_pnum(particle, fieldset, time): # pragma: no cover - pnum = 0 # noqa - - for kernel in [kernel_tmpvar, kernel_pnum]: - with pytest.raises(NotImplementedError): - pset.execute(kernel, endtime=1, dt=1.0) - - def test_varname_as_fieldname(): """Tests for error thrown if variable has same name as Field.""" fset = create_fieldset_unit_mesh(mesh="spherical") fset.add_field(Field("speed", 10, lon=0, lat=0)) fset.add_constant("vertical_speed", 0.1) - Particle = JITParticle.add_variable("speed") - pset = ParticleSet(fset, pclass=Particle, lon=0, lat=0) + particle = Particle.add_variable("speed") + pset = ParticleSet(fset, pclass=particle, lon=0, lat=0) def kernel_particlename(particle, fieldset, time): # pragma: no cover particle.speed = fieldset.speed[particle] @@ -216,25 +184,12 @@ def kernel_particlename(particle, fieldset, time): # pragma: no cover def kernel_varname(particle, fieldset, time): # pragma: no cover vertical_speed = fieldset.vertical_speed # noqa - with pytest.raises(NotImplementedError): - pset.execute(kernel_varname, endtime=1, dt=1.0) - + pset.execute(kernel_varname, endtime=1, dt=1.0) -def test_abs(): - """Tests for error thrown if using abs in kernel.""" - pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=JITParticle, lon=0, lat=0) - def kernel_abs(particle, fieldset, time): # pragma: no cover - particle.lon = abs(3.1) - - with pytest.raises(NotImplementedError): - pset.execute(kernel_abs, endtime=1, dt=1.0) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_if_withfield(fieldset_unit_mesh, mode): +def test_if_withfield(fieldset_unit_mesh): """Test combination of if and Field sampling commands.""" - TestParticle = ptype[mode].add_variable("p", dtype=np.float32, initial=0) + TestParticle = Particle.add_variable("p", dtype=np.float32, initial=0) pset = ParticleSet(fieldset_unit_mesh, pclass=TestParticle, lon=[0], lat=[0]) def kernel(particle, fieldset, time): # pragma: no cover @@ -267,23 +222,24 @@ def kernel(particle, fieldset, time): # pragma: no cover return -@pytest.mark.parametrize("mode", ["scipy"]) -def test_print(fieldset_unit_mesh, mode, capfd): +def test_print(fieldset_unit_mesh, capfd): """Test print statements.""" - TestParticle = ptype[mode].add_variable("p", dtype=np.float32, initial=0) + TestParticle = Particle.add_variable("p", dtype=np.float32, initial=0) pset = ParticleSet(fieldset_unit_mesh, pclass=TestParticle, lon=[0.5], lat=[0.5]) def kernel(particle, fieldset, time): # pragma: no cover particle.p = 1e-3 tmp = 5 - print(f"{particle.id} {particle.p:f} {tmp:f}") + print(f"{particle.trajectory} {particle.p:f} {tmp:f}") pset.execute(kernel, endtime=1.0, dt=1.0, verbose_progress=False) out, err = capfd.readouterr() lst = out.split(" ") tol = 1e-8 assert ( - abs(float(lst[0]) - pset.id[0]) < tol and abs(float(lst[1]) - pset.p[0]) < tol and abs(float(lst[2]) - 5) < tol + abs(float(lst[0]) - pset.trajectory[0]) < tol + and abs(float(lst[1]) - pset.p[0]) < tol + and abs(float(lst[2]) - 5) < tol ) def kernel2(particle, fieldset, time): # pragma: no cover @@ -296,64 +252,23 @@ def kernel2(particle, fieldset, time): # pragma: no cover assert abs(float(lst[0]) - 3) < tol -@pytest.mark.parametrize( - ("mode", "expectation"), [("scipy", does_not_raise()), ("jit", pytest.raises(NotImplementedError))] -) -def test_fieldset_access(fieldset_unit_mesh, expectation, mode): - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=0, lat=0) +def test_fieldset_access(fieldset_unit_mesh): + pset = ParticleSet(fieldset_unit_mesh, pclass=Particle, lon=0, lat=0) def kernel(particle, fieldset, time): # pragma: no cover particle.lon = fieldset.U.grid.lon[2] - with expectation: - pset.execute(kernel, endtime=1, dt=1.0) - assert pset.lon[0] == fieldset_unit_mesh.U.grid.lon[2] - - -def random_series(npart, rngfunc, rngargs, mode): - random = ParcelsRandom if mode == "jit" else py_random - random.seed(1234) - func = getattr(random, rngfunc) - series = [func(*rngargs) for _ in range(npart)] - random.seed(1234) # Reset the RNG seed - del random - return series + pset.execute(kernel, endtime=1, dt=1.0) + assert pset.lon[0] == fieldset_unit_mesh.U.grid.lon[2] -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize( - "rngfunc, rngargs", - [ - ("random", []), - ("uniform", [0.0, 20.0]), - ("randint", [0, 20]), - ], -) -def test_random_float(mode, rngfunc, rngargs): - """Test basic random number generation.""" - npart = 10 - TestParticle = ptype[mode].add_variable("p", dtype=np.float32, initial=0) - pset = ParticleSet( - create_fieldset_unit_mesh(mesh="spherical"), - pclass=TestParticle, - lon=np.linspace(0.0, 1.0, npart), - lat=np.zeros(npart) + 0.5, - ) - series = random_series(npart, rngfunc, rngargs, mode) - rnglib = "ParcelsRandom" if mode == "jit" else "random" - kernel = expr_kernel(f"TestRandom_{rngfunc}", pset, f"{rnglib}.{rngfunc}({', '.join([str(a) for a in rngargs])})") - pset.execute(kernel, endtime=1.0, dt=1.0) - assert np.allclose(pset.p, series, atol=1e-9) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize("concat", [False, True]) -def test_random_kernel_concat(fieldset_unit_mesh, mode, concat): - TestParticle = ptype[mode].add_variable("p", dtype=np.float32, initial=0) +def test_random_kernel_concat(fieldset_unit_mesh, concat): + TestParticle = Particle.add_variable("p", dtype=np.float32, initial=0) pset = ParticleSet(fieldset_unit_mesh, pclass=TestParticle, lon=0, lat=0) def RandomKernel(particle, fieldset, time): # pragma: no cover - particle.p += ParcelsRandom.uniform(0, 1) + particle.p += random.uniform(0, 1) def AddOne(particle, fieldset, time): # pragma: no cover particle.p += 1.0 @@ -363,43 +278,8 @@ def AddOne(particle, fieldset, time): # pragma: no cover assert pset.p > 1 if concat else pset.p < 1 -@pytest.mark.parametrize( - "mode", ["jit", pytest.param("scipy", marks=pytest.mark.xfail(reason="c_kernels don't work in scipy mode"))] -) -@pytest.mark.parametrize("c_inc", ["str", "file"]) -def test_c_kernel(fieldset_unit_mesh, mode, c_inc): - coord_type = np.float32 if c_inc == "str" else np.float64 - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=[0.5], lat=[0], lonlatdepth_dtype=coord_type) - - def func(U, lon, dt): - u = U.data[0, 2, 1] - return lon + u * dt - - if c_inc == "str": - c_include = """ - static inline StatusCode func(CField *f, double *particle_dlon, double *dt) - { - float data2D[2][2][2]; - StatusCode status = getCell2D(f, 0, 2, 1, data2D, 1); CHECKSTATUS(status); - float u = data2D[0][0][0]; - *particle_dlon = +u * *dt; - return SUCCESS; - } - """ - else: - c_include = os.path.join(os.path.dirname(__file__), "customed_header.h") - - def ckernel(particle, fieldset, time): # pragma: no cover - func("parcels_customed_Cfunc_pointer_args", fieldset.U, particle_dlon, particle.dt) # noqa - - kernel = pset.Kernel(ckernel, c_include=c_include) - pset.execute(kernel, endtime=4.0, dt=1.0) - assert np.allclose(pset.lon[0], 0.81578948) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_dt_modif_by_kernel(mode): - TestParticle = ptype[mode].add_variable("age", dtype=np.float32, initial=0) +def test_dt_modif_by_kernel(): + TestParticle = Particle.add_variable("age", dtype=np.float32, initial=0) pset = ParticleSet(create_fieldset_unit_mesh(mesh="spherical"), pclass=TestParticle, lon=[0.5], lat=[0]) def modif_dt(particle, fieldset, time): # pragma: no cover @@ -411,15 +291,14 @@ def modif_dt(particle, fieldset, time): # pragma: no cover assert np.isclose(pset.time[0], endtime) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize( ("dt", "expectation"), [(1e-2, does_not_raise()), (1e-5, does_not_raise()), (1e-6, pytest.raises(ValueError))] ) -def test_small_dt(mode, dt, expectation): +def test_small_dt(dt, expectation): npart = 10 pset = ParticleSet( create_fieldset_unit_mesh(mesh="spherical"), - pclass=ptype[mode], + pclass=Particle, lon=np.zeros(npart), lat=np.zeros(npart), time=np.arange(0, npart) * dt * 10, @@ -430,8 +309,7 @@ def test_small_dt(mode, dt, expectation): assert np.allclose([p.time for p in pset], dt * 100) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_TEOSdensity_kernels(mode): +def test_TEOSdensity_kernels(): def generate_fieldset(xdim=2, ydim=2, zdim=2, tdim=1): lon = np.linspace(0.0, 10.0, xdim, dtype=np.float32) lat = np.linspace(0.0, 10.0, ydim, dtype=np.float32) @@ -453,30 +331,29 @@ def generate_fieldset(xdim=2, ydim=2, zdim=2, tdim=1): data, dimensions = generate_fieldset() fieldset = FieldSet.from_data(data, dimensions) - DensParticle = ptype[mode].add_variable("density", dtype=np.float32) + DensParticle = Particle.add_variable("density", dtype=np.float32) pset = ParticleSet(fieldset, pclass=DensParticle, lon=5, lat=5, depth=1000) pset.execute(PolyTEOS10_bsq, runtime=1) - assert np.allclose(pset[0].density, 1022.85377) + assert np.allclose(pset[0].density, 1027.45140) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_EOSseawaterproperties_kernels(mode): +def test_EOSseawaterproperties_kernels(): fieldset = FieldSet.from_data( data={"U": 0, "V": 0, "psu_salinity": 40, "temperature": 40, "potemperature": 36.89073}, dimensions={"lat": 0, "lon": 0, "depth": 0}, ) fieldset.add_constant("refpressure", float(0)) - PoTempParticle = ptype[mode].add_variables( + PoTempParticle = Particle.add_variables( [Variable("potemp", dtype=np.float32), Variable("pressure", dtype=np.float32, initial=10000)] ) pset = ParticleSet(fieldset, pclass=PoTempParticle, lon=5, lat=5, depth=1000) pset.execute(PtempFromTemp, runtime=1) assert np.allclose(pset[0].potemp, 36.89073) - TempParticle = ptype[mode].add_variables( + TempParticle = Particle.add_variables( [Variable("temp", dtype=np.float32), Variable("pressure", dtype=np.float32, initial=10000)] ) pset = ParticleSet(fieldset, pclass=TempParticle, lon=5, lat=5, depth=1000) @@ -488,9 +365,8 @@ def test_EOSseawaterproperties_kernels(mode): assert np.allclose(pset[0].pressure, 7500, atol=1e-2) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize("pressure", [0, 10]) -def test_UNESCOdensity_kernel(mode, pressure): +def test_UNESCOdensity_kernel(pressure): def generate_fieldset(p, xdim=2, ydim=2, zdim=2, tdim=1): lon = np.linspace(0.0, 10.0, xdim, dtype=np.float32) lat = np.linspace(0.0, 10.0, ydim, dtype=np.float32) @@ -514,7 +390,7 @@ def generate_fieldset(p, xdim=2, ydim=2, zdim=2, tdim=1): data, dimensions = generate_fieldset(pressure) fieldset = FieldSet.from_data(data, dimensions) - DensParticle = ptype[mode].add_variable("density", dtype=np.float32) + DensParticle = Particle.add_variable("density", dtype=np.float32) pset = ParticleSet(fieldset, pclass=DensParticle, lon=5, lat=5, depth=1000) diff --git a/tests/test_mpirun.py b/tests-v3/test_mpirun.py similarity index 90% rename from tests/test_mpirun.py rename to tests-v3/test_mpirun.py index cb242fb4a..cb29261f6 100644 --- a/tests/test_mpirun.py +++ b/tests-v3/test_mpirun.py @@ -19,10 +19,10 @@ def test_mpi_run(tmpdir, repeatdt, maxage, nump): outputNoMPI = tmpdir.join("StommelNoMPI.zarr") os.system( - f"mpirun -np 2 python {stommel_file} -p {nump} -o {outputMPI_partition_function} -r {repeatdt} -a {maxage} -wf False -cpf True" + f"mpirun -np 2 python {stommel_file} -p {nump} -o {outputMPI_partition_function} -r {repeatdt} -a {maxage} -cpf True" ) - os.system(f"mpirun -np 2 python {stommel_file} -p {nump} -o {outputMPI} -r {repeatdt} -a {maxage} -wf False") - os.system(f"python {stommel_file} -p {nump} -o {outputNoMPI} -r {repeatdt} -a {maxage} -wf False") + os.system(f"mpirun -np 2 python {stommel_file} -p {nump} -o {outputMPI} -r {repeatdt} -a {maxage}") + os.system(f"python {stommel_file} -p {nump} -o {outputNoMPI} -r {repeatdt} -a {maxage}") ds2 = xr.open_zarr(outputNoMPI) diff --git a/tests/test_particles.py b/tests-v3/test_particles.py similarity index 73% rename from tests/test_particles.py rename to tests-v3/test_particles.py index 6a8474ba4..172d2a429 100644 --- a/tests/test_particles.py +++ b/tests-v3/test_particles.py @@ -5,37 +5,32 @@ from parcels import ( AdvectionRK4, - JITParticle, + Particle, ParticleSet, - ScipyParticle, Variable, ) from tests.utils import create_fieldset_zeros_unit_mesh -ptype = {"scipy": ScipyParticle, "jit": JITParticle} - @pytest.fixture def fieldset(): return create_fieldset_zeros_unit_mesh() -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_print(fieldset, mode): - TestParticle = ptype[mode].add_variable("p", to_write=True) +def test_print(fieldset): + TestParticle = Particle.add_variable("p", to_write=True) pset = ParticleSet(fieldset, pclass=TestParticle, lon=[0, 1], lat=[0, 1]) print(pset) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_variable_init(fieldset, mode): +def test_variable_init(fieldset): """Test that checks correct initialisation of custom variables.""" npart = 10 extra_vars = [ Variable("p_float", dtype=np.float32, initial=10.0), Variable("p_double", dtype=np.float64, initial=11.0), ] - TestParticle = ptype[mode].add_variables(extra_vars) + TestParticle = Particle.add_variables(extra_vars) TestParticle = TestParticle.add_variable("p_int", np.int32, initial=12.0) pset = ParticleSet(fieldset, pclass=TestParticle, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) @@ -50,32 +45,29 @@ def addOne(particle, fieldset, time): # pragma: no cover assert np.allclose([p.p_int for p in pset], 13, rtol=1e-12) -@pytest.mark.parametrize("mode", ["jit"]) @pytest.mark.parametrize("type", ["np.int8", "mp.float", "np.int16"]) -def test_variable_unsupported_dtypes(fieldset, mode, type): - """Test that checks errors thrown for unsupported dtypes in JIT mode.""" - TestParticle = ptype[mode].add_variable("p", dtype=type, initial=10.0) +def test_variable_unsupported_dtypes(fieldset, type): + """Test that checks errors thrown for unsupported dtypes.""" + TestParticle = Particle.add_variable("p", dtype=type, initial=10.0) with pytest.raises((RuntimeError, TypeError)): ParticleSet(fieldset, pclass=TestParticle, lon=[0], lat=[0]) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_variable_special_names(fieldset, mode): +def test_variable_special_names(fieldset): """Test that checks errors thrown for special names.""" for vars in ["z", "lon"]: - TestParticle = ptype[mode].add_variable(vars, dtype=np.float32, initial=10.0) + TestParticle = Particle.add_variable(vars, dtype=np.float32, initial=10.0) with pytest.raises(AttributeError): ParticleSet(fieldset, pclass=TestParticle, lon=[0], lat=[0]) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize("coord_type", [np.float32, np.float64]) -def test_variable_init_relative(fieldset, mode, coord_type): +def test_variable_init_relative(fieldset, coord_type): """Test that checks relative initialisation of custom variables.""" npart = 10 lonlat_type = np.float64 if coord_type == "double" else np.float32 - TestParticle = ptype[mode].add_variables( + TestParticle = Particle.add_variables( [ Variable("p_base", dtype=lonlat_type, initial=10.0), Variable("p_relative", dtype=lonlat_type, initial=attrgetter("p_base")), diff --git a/tests-v3/test_particlesets.py b/tests-v3/test_particlesets.py new file mode 100644 index 000000000..ed884f595 --- /dev/null +++ b/tests-v3/test_particlesets.py @@ -0,0 +1,258 @@ +import numpy as np +import pytest + +from parcels import ( + CurvilinearZGrid, + Field, + FieldSet, + Particle, + ParticleSet, + Variable, +) +from tests.utils import create_fieldset_zeros_simple + + +@pytest.fixture +def fieldset(): + return create_fieldset_zeros_simple() + + +@pytest.fixture +def pset(fieldset): + npart = 10 + pset = ParticleSet(fieldset, pclass=Particle, lon=np.linspace(0, 1, npart), lat=np.zeros(npart)) + return pset + + +def test_pset_create_list_with_customvariable(fieldset): + npart = 100 + lon = np.linspace(0, 1, npart, dtype=np.float32) + lat = np.linspace(1, 0, npart, dtype=np.float32) + + MyParticle = Particle.add_variable("v") + + v_vals = np.arange(npart) + pset = ParticleSet(fieldset, lon=lon, lat=lat, v=v_vals, pclass=MyParticle) + assert np.allclose([p.lon for p in pset], lon, rtol=1e-12) + assert np.allclose([p.lat for p in pset], lat, rtol=1e-12) + assert np.allclose([p.v for p in pset], v_vals, rtol=1e-12) + + +@pytest.mark.parametrize("restart", [True, False]) +def test_pset_create_fromparticlefile(fieldset, restart, tmp_zarrfile): + lon = np.linspace(0, 1, 10, dtype=np.float32) + lat = np.linspace(1, 0, 10, dtype=np.float32) + + TestParticle = Particle.add_variable("p", np.float32, initial=0.33) + TestParticle = TestParticle.add_variable("p2", np.float32, initial=1, to_write=False) + TestParticle = TestParticle.add_variable("p3", np.float64, to_write="once") + + pset = ParticleSet(fieldset, lon=lon, lat=lat, depth=[4] * len(lon), pclass=TestParticle, p3=np.arange(len(lon))) + pfile = pset.ParticleFile(tmp_zarrfile, outputdt=1) + + def Kernel(particle, fieldset, time): # pragma: no cover + particle.p = 2.0 + if particle.lon == 1.0: + particle.delete() + + pset.execute(Kernel, runtime=2, dt=1, output_file=pfile) + + pset_new = ParticleSet.from_particlefile( + fieldset, pclass=TestParticle, filename=tmp_zarrfile, restart=restart, repeatdt=1 + ) + + for var in ["lon", "lat", "depth", "time", "p", "p2", "p3"]: + assert np.allclose([getattr(p, var) for p in pset], [getattr(p, var) for p in pset_new]) + + if restart: + assert np.allclose([p.trajectory for p in pset], [p.trajectory for p in pset_new]) + pset_new.execute(Kernel, runtime=2, dt=1) + assert len(pset_new) == 3 * len(pset) + assert pset[0].p3.dtype == np.float64 + + +@pytest.mark.parametrize("lonlatdepth_dtype", [np.float64, np.float32]) +def test_pset_create_field(fieldset, lonlatdepth_dtype): + npart = 100 + np.random.seed(123456) + shape = (fieldset.U.lat.size, fieldset.U.lon.size) + K = Field("K", lon=fieldset.U.lon, lat=fieldset.U.lat, data=np.ones(shape, dtype=np.float32)) + pset = ParticleSet.from_field( + fieldset, size=npart, pclass=Particle, start_field=K, lonlatdepth_dtype=lonlatdepth_dtype + ) + assert (np.array([p.lon for p in pset]) <= K.lon[-1]).all() + assert (np.array([p.lon for p in pset]) >= K.lon[0]).all() + assert (np.array([p.lat for p in pset]) <= K.lat[-1]).all() + assert (np.array([p.lat for p in pset]) >= K.lat[0]).all() + assert isinstance(pset[0].lat, lonlatdepth_dtype) + + +def test_pset_create_field_curvi(): + npart = 100 + np.random.seed(123456) + r_v = np.linspace(0.25, 2, 20) + theta_v = np.linspace(0, np.pi / 2, 200) + dtheta = theta_v[1] - theta_v[0] + dr = r_v[1] - r_v[0] + (r, theta) = np.meshgrid(r_v, theta_v) + + x = -1 + r * np.cos(theta) + y = -1 + r * np.sin(theta) + grid = CurvilinearZGrid(x, y) + + u = np.ones(x.shape) + v = np.where(np.logical_and(theta > np.pi / 4, theta < np.pi / 3), 1, 0) + + ufield = Field("U", u, grid=grid) + vfield = Field("V", v, grid=grid) + fieldset = FieldSet(ufield, vfield) + pset = ParticleSet.from_field(fieldset, size=npart, pclass=Particle, start_field=fieldset.V) + + lons = np.array([p.lon + 1 for p in pset]) + lats = np.array([p.lat + 1 for p in pset]) + thetas = np.arctan2(lats, lons) + rs = np.sqrt(lons * lons + lats * lats) + + test = np.pi / 4 - dtheta < thetas + test *= thetas < np.pi / 3 + dtheta + test *= rs > 0.25 - dr + test *= rs < 2 + dr + assert np.all(test) + + +def test_pset_create_with_time(fieldset): + npart = 100 + lon = np.linspace(0, 1, npart) + lat = np.linspace(1, 0, npart) + time = 5.0 + pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=Particle, time=time) + assert np.allclose([p.time for p in pset], time, rtol=1e-12) + pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=Particle, time=[time] * npart) + assert np.allclose([p.time for p in pset], time, rtol=1e-12) + pset = ParticleSet.from_line(fieldset, size=npart, start=(0, 1), finish=(1, 0), pclass=Particle, time=time) + assert np.allclose([p.time for p in pset], time, rtol=1e-12) + + +def test_pset_repeated_release(fieldset): + npart = 10 + time = np.arange(0, npart, 1) # release 1 particle every second + pset = ParticleSet(fieldset, lon=np.zeros(npart), lat=np.zeros(npart), pclass=Particle, time=time) + assert np.allclose([p.time for p in pset], time) + + def IncrLon(particle, fieldset, time): # pragma: no cover + particle.dlon += 1.0 + + pset.execute(IncrLon, dt=1.0, runtime=npart + 1) + assert np.allclose([p.lon for p in pset], np.arange(npart, 0, -1)) + + +def test_pset_repeatdt_check_dt(fieldset): + pset = ParticleSet(fieldset, lon=[0], lat=[0], pclass=Particle, repeatdt=5) + + def IncrLon(particle, fieldset, time): # pragma: no cover + particle.lon = 1.0 + + pset.execute(IncrLon, dt=2, runtime=21) + assert np.allclose([p.lon for p in pset], 1) # if p.dt is nan, it won't be executed so p.lon will be 0 + + +def test_pset_access(fieldset): + npart = 100 + lon = np.linspace(0, 1, npart, dtype=np.float32) + lat = np.linspace(1, 0, npart, dtype=np.float32) + pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=Particle) + assert pset.size == 100 + assert np.allclose([pset[i].lon for i in range(pset.size)], lon, rtol=1e-12) + assert np.allclose([pset[i].lat for i in range(pset.size)], lat, rtol=1e-12) + + +def test_pset_custom_ptype(fieldset): + npart = 100 + TestParticle = Particle.add_variable([Variable("p", np.float32, initial=0.33), Variable("n", np.int32, initial=2)]) + + pset = ParticleSet(fieldset, pclass=TestParticle, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) + assert pset.size == npart + assert np.allclose([p.p - 0.33 for p in pset], np.zeros(npart), atol=1e-5) + assert np.allclose([p.n - 2 for p in pset], np.zeros(npart), rtol=1e-12) + + +def test_pset_add_execute(fieldset): + npart = 10 + + def AddLat(particle, fieldset, time): # pragma: no cover + particle.dlat += 0.1 + + pset = ParticleSet(fieldset, lon=[], lat=[], pclass=Particle) + for _ in range(npart): + pset += ParticleSet(pclass=Particle, lon=0.1, lat=0.1, fieldset=fieldset) + for _ in range(4): + pset.execute(pset.Kernel(AddLat), runtime=1.0, dt=1.0) + assert np.allclose(np.array([p.lat for p in pset]), 0.4, rtol=1e-12) + + +@pytest.mark.xfail(reason="Particle removal has not been implemented yet") +def test_pset_remove_particle(fieldset): + npart = 100 + lon = np.linspace(0, 1, npart) + lat = np.linspace(1, 0, npart) + pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=Particle) + for ilon, ilat in zip(lon[::-1], lat[::-1], strict=True): + assert pset.lon[-1] == ilon + assert pset.lat[-1] == ilat + pset.remove_indices(pset[-1]) + assert pset.size == 0 + + +@pytest.mark.parametrize("staggered_grid", ["Agrid", "Cgrid"]) +def test_from_field_exact_val(staggered_grid): + """ + Tests the creation of a ParticleSet from a field with exact values + on both A-grid and C-grid staggered grids. Verifies that particles + are initialized correctly within the masked region and that their + properties match the expected field values. + """ + xdim = 4 + ydim = 3 + + lon = np.linspace(-1, 2, xdim, dtype=np.float32) + lat = np.linspace(50, 52, ydim, dtype=np.float32) + + dimensions = {"lat": lat, "lon": lon} + if staggered_grid == "Agrid": + U = np.zeros((ydim, xdim), dtype=np.float32) + V = np.zeros((ydim, xdim), dtype=np.float32) + data = {"U": np.array(U, dtype=np.float32), "V": np.array(V, dtype=np.float32)} + mask = np.array([[1, 1, 0, 0], + [1, 1, 1, 0], + [1, 1, 1, 1]]) # fmt: skip + fieldset = FieldSet.from_data(data, dimensions, mesh="flat") + + FMask = Field("mask", mask, lon, lat) + fieldset.add_field(FMask) + elif staggered_grid == "Cgrid": + U = np.array([[0, 0, 0, 0], + [1, 0, 0, 0], + [1, 1, 0, 0]]) # fmt: skip + V = np.array([[0, 1, 0, 0], + [0, 1, 0, 0], + [0, 1, 1, 0]]) # fmt: skip + data = {"U": np.array(U, dtype=np.float32), "V": np.array(V, dtype=np.float32)} + mask = np.array([[-1, -1, -1, -1], [-1, 1, 0, 0], [-1, 1, 1, 0]]) + fieldset = FieldSet.from_data(data, dimensions, mesh="flat") + fieldset.U.interp_method = "cgrid_velocity" + fieldset.V.interp_method = "cgrid_velocity" + + FMask = Field("mask", mask, lon, lat, interp_method="cgrid_tracer") + fieldset.add_field(FMask) + + SampleParticle = Particle.add_variable("mask", initial=0) + + def SampleMask(particle, fieldset, time): # pragma: no cover + particle.mask = fieldset.mask[particle] + + pset = ParticleSet.from_field(fieldset, size=400, pclass=SampleParticle, start_field=FMask, time=0) + pset.execute(SampleMask, dt=1, runtime=1) + assert np.allclose([p.mask for p in pset], 1) + assert (np.array([p.lon for p in pset]) <= 1).all() + test = np.logical_or(np.array([p.lon for p in pset]) <= 0, np.array([p.lat for p in pset]) >= 51) + assert test.all() diff --git a/tests/test_reprs.py b/tests-v3/test_reprs.py similarity index 87% rename from tests/test_reprs.py rename to tests-v3/test_reprs.py index 18ed68a0a..18407e583 100644 --- a/tests/test_reprs.py +++ b/tests-v3/test_reprs.py @@ -5,7 +5,7 @@ import numpy as np import parcels -from parcels import Grid, ParticleFile, TimeConverter, Variable +from parcels import Grid, ParticleFile, Variable from parcels.grid import RectilinearGrid from tests.utils import create_fieldset_unit_mesh, create_simple_pset @@ -52,15 +52,13 @@ def test_check_indentation(): def test_particletype_repr(): - kwargs = dict(pclass=parcels.JITParticle) + kwargs = dict(pclass=parcels.Particle) assert_simple_repr(parcels.particle.ParticleType, kwargs) def test_grid_repr(): """Test arguments are in the repr of a Grid object""" - kwargs = dict( - lon=np.array([1, 2, 3]), lat=np.array([4, 5, 6]), time=None, time_origin=TimeConverter(), mesh="spherical" - ) + kwargs = dict(lon=np.array([1, 2, 3]), lat=np.array([4, 5, 6]), time=None, mesh="spherical") assert_simple_repr(Grid, kwargs) @@ -76,9 +74,7 @@ def test_rectilineargrid_repr(): Mainly to test inherited repr is correct. """ - kwargs = dict( - lon=np.array([1, 2, 3]), lat=np.array([4, 5, 6]), time=None, time_origin=TimeConverter(), mesh="spherical" - ) + kwargs = dict(lon=np.array([1, 2, 3]), lat=np.array([4, 5, 6]), time=None, mesh="spherical") assert_simple_repr(RectilinearGrid, kwargs) diff --git a/tests/test_typing.py b/tests-v3/test_typing.py similarity index 100% rename from tests/test_typing.py rename to tests-v3/test_typing.py diff --git a/tests/tools/test_exampledata_utils.py b/tests-v3/tools/test_exampledata_utils.py similarity index 55% rename from tests/tools/test_exampledata_utils.py rename to tests-v3/tools/test_exampledata_utils.py index 613ec1485..94ed9cf83 100644 --- a/tests/tools/test_exampledata_utils.py +++ b/tests-v3/tools/test_exampledata_utils.py @@ -1,35 +1,21 @@ -from pathlib import Path - import pytest import requests from parcels.tools.exampledata_utils import ( + _get_pooch, download_example_dataset, list_example_datasets, ) -@pytest.fixture -def mock_download(monkeypatch): - """Avoid the download, only check the status code and create empty file.""" - - def mock_urlretrieve(url, filename): - response = requests.head(url) - - if 400 <= response.status_code < 600: - raise Exception(f"Failed to access URL: {url}. Status code: {response.status_code}") - - Path(filename).touch() - - monkeypatch.setattr("parcels.tools.exampledata_utils.urlretrieve", mock_urlretrieve) - +@pytest.mark.parametrize("url", [_get_pooch().get_url(filename) for filename in _get_pooch().registry.keys()]) +def test_pooch_registry_url_reponse(url): + response = requests.head(url) + assert not (400 <= response.status_code < 600) -@pytest.mark.usefixtures("mock_download") -@pytest.mark.parametrize("dataset", list_example_datasets()) -def test_download_example_dataset(tmp_path, dataset): - if dataset == "GlobCurrent_example_data": - pytest.skip(f"{dataset} too time consuming.") +@pytest.mark.parametrize("dataset", list_example_datasets()[:1]) +def test_download_example_dataset_folder_creation(tmp_path, dataset): dataset_folder_path = download_example_dataset(dataset, data_home=tmp_path) assert dataset_folder_path.exists() diff --git a/tests/tools/test_helpers.py b/tests-v3/tools/test_helpers.py similarity index 100% rename from tests/tools/test_helpers.py rename to tests-v3/tools/test_helpers.py diff --git a/tests-v3/tools/test_warnings.py b/tests-v3/tools/test_warnings.py new file mode 100644 index 000000000..1570d44bf --- /dev/null +++ b/tests-v3/tools/test_warnings.py @@ -0,0 +1,56 @@ +import numpy as np +import pytest + +from parcels import ( + AdvectionRK4, + AdvectionRK45, + FieldSet, + FieldSetWarning, + KernelWarning, + Particle, + ParticleSet, + ParticleSetWarning, +) +from parcels.particlefile import ParticleFile +from tests.utils import TEST_DATA + + +@pytest.mark.v4alpha +@pytest.mark.xfail(reason="From_pop is not supported during v4-alpha development. This will be reconsidered in v4.") +def test_fieldset_warning_pop(): + filenames = str(TEST_DATA / "POPtestdata_time.nc") + variables = {"U": "U", "V": "V", "W": "W", "T": "T"} + dimensions = {"lon": "lon", "lat": "lat", "depth": "w_deps", "time": "time"} + with pytest.warns(FieldSetWarning, match="General s-levels are not supported in B-grid.*"): + # b-grid with s-levels and POP output in meters warning + FieldSet.from_pop(filenames, variables, dimensions, mesh="flat") + + +def test_file_warnings(tmp_zarrfile): + fieldset = FieldSet.from_data( + data={"U": np.zeros((1, 1)), "V": np.zeros((1, 1))}, dimensions={"lon": [0], "lat": [0]} + ) + pset = ParticleSet(fieldset=fieldset, pclass=Particle, lon=[0, 0], lat=[0, 0], time=[0, 1]) + pfile = ParticleFile(name=tmp_zarrfile, outputdt=2) + with pytest.warns(ParticleSetWarning, match="Some of the particles have a start time difference.*"): + pset.execute(AdvectionRK4, runtime=3, dt=1, output_file=pfile) + + +def test_kernel_warnings(): + # RK45 warnings + lat = [0, 1, 5, 10] + lon = [0, 1, 5, 10] + u = [[1, 1, 1, 1] for _ in range(4)] + v = [[1, 1, 1, 1] for _ in range(4)] + fieldset = FieldSet.from_data(data={"U": u, "V": v}, dimensions={"lon": lon, "lat": lat}) + pset = ParticleSet( + fieldset=fieldset, + pclass=Particle.add_variable("next_dt", dtype=np.float32, initial=1), + lon=[0], + lat=[0], + depth=[0], + time=[0], + next_dt=1, + ) + with pytest.warns(KernelWarning): + pset.execute(AdvectionRK45, runtime=1, dt=1) diff --git a/tests/common_kernels.py b/tests/common_kernels.py index 449ea9039..53e3c7310 100644 --- a/tests/common_kernels.py +++ b/tests/common_kernels.py @@ -1,18 +1,21 @@ """Shared kernels between tests.""" +import numpy as np -def DoNothing(particle, fieldset, time): # pragma: no cover +from parcels import StatusCode + + +def DoNothing(particles, fieldset): # pragma: no cover pass -def DeleteParticle(particle, fieldset, time): # pragma: no cover - if particle.state >= 50: # This captures all Errors - particle.delete() +def DeleteParticle(particles, fieldset): # pragma: no cover + particles.state = np.where(particles.state >= 50, StatusCode.Delete, particles.state) -def MoveEast(particle, fieldset, time): # pragma: no cover - particle_dlon += 0.1 # noqa +def MoveEast(particles, fieldset): # pragma: no cover + particles.dlon += 0.1 -def MoveNorth(particle, fieldset, time): # pragma: no cover - particle_dlat += 0.1 # noqa +def MoveNorth(particles, fieldset): # pragma: no cover + particles.dlat += 0.1 diff --git a/tests/conftest.py b/tests/conftest.py index 69787802c..82020c37e 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,7 +1,13 @@ import pytest +from zarr.storage import MemoryStore @pytest.fixture() def tmp_zarrfile(tmp_path, request): test_name = request.node.name yield tmp_path / f"{test_name}-output.zarr" + + +@pytest.fixture +def tmp_store(): + return MemoryStore() diff --git a/tests/customed_header.h b/tests/customed_header.h deleted file mode 100644 index cca3c94e6..000000000 --- a/tests/customed_header.h +++ /dev/null @@ -1,9 +0,0 @@ - -static inline StatusCode func(CField *f, double *particle_dlon, double *dt) -{ - float data2D[2][2][2]; - StatusCode status = getCell2D(f, 0, 2, 1, data2D, 1); CHECKSTATUS(status); - float u = data2D[0][0][0]; - *particle_dlon = +u * *dt; - return SUCCESS; -} diff --git a/tests/test_advection.py b/tests/test_advection.py index 2ded59799..c4e8a82ce 100644 --- a/tests/test_advection.py +++ b/tests/test_advection.py @@ -1,680 +1,564 @@ -import math -from datetime import timedelta - import numpy as np import pytest import xarray as xr - -from parcels import ( - AdvectionAnalytical, +import xgcm + +import parcels +from parcels import Field, FieldSet, Particle, ParticleFile, ParticleSet, StatusCode, Variable, VectorField, XGrid +from parcels._datasets.structured.generated import ( + decaying_moving_eddy_dataset, + moving_eddy_dataset, + peninsula_dataset, + radial_rotation_dataset, + simple_UV_dataset, + stommel_gyre_dataset, +) +from parcels.interpolators import CGrid_Velocity, XLinear +from parcels.kernels import ( AdvectionDiffusionEM, AdvectionDiffusionM1, AdvectionEE, AdvectionRK4, AdvectionRK4_3D, AdvectionRK45, - Field, - FieldSet, - JITParticle, - ParticleSet, - ScipyParticle, - StatusCode, - Variable, ) -from tests.utils import TEST_DATA +from tests.utils import round_and_hash_float_array -ptype = {"scipy": ScipyParticle, "jit": JITParticle} kernel = { "EE": AdvectionEE, "RK4": AdvectionRK4, + "RK4_3D": AdvectionRK4_3D, "RK45": AdvectionRK45, - "AA": AdvectionAnalytical, + # "AA": AdvectionAnalytical, "AdvDiffEM": AdvectionDiffusionEM, "AdvDiffM1": AdvectionDiffusionM1, } -# Some constants -f = 1.0e-4 -u_0 = 0.3 -u_g = 0.04 -gamma = 1 / (86400.0 * 2.89) -gamma_g = 1 / (86400.0 * 28.9) - - -@pytest.fixture -def lon(): - xdim = 200 - return np.linspace(-170, 170, xdim, dtype=np.float32) - -@pytest.fixture -def lat(): - ydim = 100 - return np.linspace(-80, 80, ydim, dtype=np.float32) - - -@pytest.fixture -def depth(): - zdim = 2 - return np.linspace(0, 30, zdim, dtype=np.float32) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_advection_zonal(lon, lat, depth, mode): +@pytest.mark.parametrize("mesh", ["spherical", "flat"]) +def test_advection_zonal(mesh, npart=10): """Particles at high latitude move geographically faster due to the pole correction in `GeographicPolar`.""" - npart = 10 - data2D = { - "U": np.ones((lon.size, lat.size), dtype=np.float32), - "V": np.zeros((lon.size, lat.size), dtype=np.float32), - } - data3D = { - "U": np.ones((lon.size, lat.size, depth.size), dtype=np.float32), - "V": np.zeros((lon.size, lat.size, depth.size), dtype=np.float32), - } - dimensions = {"lon": lon, "lat": lat} - fieldset2D = FieldSet.from_data(data2D, dimensions, mesh="spherical", transpose=True) - - pset2D = ParticleSet(fieldset2D, pclass=ptype[mode], lon=np.zeros(npart) + 20.0, lat=np.linspace(0, 80, npart)) - pset2D.execute(AdvectionRK4, runtime=timedelta(hours=2), dt=timedelta(seconds=30)) - assert (np.diff(pset2D.lon) > 1.0e-4).all() - - dimensions["depth"] = depth - fieldset3D = FieldSet.from_data(data3D, dimensions, mesh="spherical", transpose=True) - pset3D = ParticleSet( - fieldset3D, - pclass=ptype[mode], - lon=np.zeros(npart) + 20.0, - lat=np.linspace(0, 80, npart), - depth=np.zeros(npart) + 10.0, - ) - pset3D.execute(AdvectionRK4, runtime=timedelta(hours=2), dt=timedelta(seconds=30)) - assert (np.diff(pset3D.lon) > 1.0e-4).all() + ds = simple_UV_dataset(mesh=mesh) + ds["U"].data[:] = 1.0 + grid = XGrid.from_dataset(ds, mesh=mesh) + U = Field("U", ds["U"], grid, interp_method=XLinear) + V = Field("V", ds["V"], grid, interp_method=XLinear) + UV = VectorField("UV", U, V) + fieldset = FieldSet([U, V, UV]) + + pset = ParticleSet(fieldset, lon=np.zeros(npart) + 20.0, lat=np.linspace(0, 80, npart)) + pset.execute(AdvectionRK4, runtime=np.timedelta64(2, "h"), dt=np.timedelta64(15, "m")) + + if mesh == "spherical": + assert (np.diff(pset.lon) > 1.0e-4).all() + else: + assert (np.diff(pset.lon) < 1.0e-4).all() -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_advection_meridional(lon, lat, mode): +def test_advection_zonal_with_particlefile(tmp_store): """Particles at high latitude move geographically faster due to the pole correction in `GeographicPolar`.""" npart = 10 - data = {"U": np.zeros((lon.size, lat.size), dtype=np.float32), "V": np.ones((lon.size, lat.size), dtype=np.float32)} - dimensions = {"lon": lon, "lat": lat} - fieldset = FieldSet.from_data(data, dimensions, mesh="spherical", transpose=True) - - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=np.linspace(-60, 60, npart), lat=np.linspace(0, 30, npart)) - delta_lat = np.diff(pset.lat) - pset.execute(AdvectionRK4, runtime=timedelta(hours=2), dt=timedelta(seconds=30)) - assert np.allclose(np.diff(pset.lat), delta_lat, rtol=1.0e-4) + ds = simple_UV_dataset(mesh="flat") + ds["U"].data[:] = 1.0 + grid = XGrid.from_dataset(ds, mesh="flat") + U = Field("U", ds["U"], grid, interp_method=XLinear) + V = Field("V", ds["V"], grid, interp_method=XLinear) + UV = VectorField("UV", U, V) + fieldset = FieldSet([U, V, UV]) + + pset = ParticleSet(fieldset, lon=np.zeros(npart) + 20.0, lat=np.linspace(0, 80, npart)) + pfile = ParticleFile(tmp_store, outputdt=np.timedelta64(30, "m")) + pset.execute(AdvectionRK4, runtime=np.timedelta64(2, "h"), dt=np.timedelta64(15, "m"), output_file=pfile) + + assert (np.diff(pset.lon) < 1.0e-4).all() + ds = xr.open_zarr(tmp_store) + np.testing.assert_allclose(ds.isel(obs=-1).lon.values, pset.lon) + + +def periodicBC(particles, fieldset): + particles.total_dlon += particles.dlon + particles.lon = np.fmod(particles.lon, 2) + + +def test_advection_zonal_periodic(): + ds = simple_UV_dataset(dims=(2, 2, 2, 2), mesh="flat") + ds["U"].data[:] = 0.1 + ds["lon"].data = np.array([0, 2]) + ds["lat"].data = np.array([0, 2]) + + # add a halo + halo = ds.isel(XG=0) + halo.lon.values = ds.lon.values[1] + 1 + halo.XG.values = ds.XG.values[1] + 2 + ds = xr.concat([ds, halo], dim="XG") + + grid = XGrid.from_dataset(ds) + U = Field("U", ds["U"], grid, interp_method=XLinear) + V = Field("V", ds["V"], grid, interp_method=XLinear) + UV = VectorField("UV", U, V) + fieldset = FieldSet([U, V, UV]) + + PeriodicParticle = Particle.add_variable(Variable("total_dlon", initial=0)) + startlon = np.array([0.5, 0.4]) + pset = ParticleSet(fieldset, pclass=PeriodicParticle, lon=startlon, lat=[0.5, 0.5]) + pset.execute([AdvectionEE, periodicBC], runtime=np.timedelta64(40, "s"), dt=np.timedelta64(1, "s")) + np.testing.assert_allclose(pset.total_dlon, 4, atol=1e-5) + np.testing.assert_allclose(pset.lon + pset.dlon, startlon, atol=1e-5) + np.testing.assert_allclose(pset.lat, 0.5, atol=1e-5) + + +def test_horizontal_advection_in_3D_flow(npart=10): + """Flat 2D zonal flow that increases linearly with depth from 0 m/s to 1 m/s.""" + ds = simple_UV_dataset(mesh="flat") + ds["U"].data[:] = 1.0 + grid = XGrid.from_dataset(ds) + U = Field("U", ds["U"], grid, interp_method=XLinear) + U.data[:, 0, :, :] = 0.0 # Set U to 0 at the surface + V = Field("V", ds["V"], grid, interp_method=XLinear) + UV = VectorField("UV", U, V) + fieldset = FieldSet([U, V, UV]) + pset = ParticleSet(fieldset, lon=np.zeros(npart), lat=np.zeros(npart), depth=np.linspace(0.1, 0.9, npart)) + pset.execute(AdvectionRK4, runtime=np.timedelta64(2, "h"), dt=np.timedelta64(15, "m")) -@pytest.mark.parametrize("mode", ["jit", "scipy"]) -def test_advection_3D(mode): - """Flat 2D zonal flow that increases linearly with depth from 0 m/s to 1 m/s.""" - xdim = ydim = zdim = 2 - npart = 11 - dimensions = { - "lon": np.linspace(0.0, 1e4, xdim, dtype=np.float32), - "lat": np.linspace(0.0, 1e4, ydim, dtype=np.float32), - "depth": np.linspace(0.0, 1.0, zdim, dtype=np.float32), - } - data = {"U": np.ones((xdim, ydim, zdim), dtype=np.float32), "V": np.zeros((xdim, ydim, zdim), dtype=np.float32)} - data["U"][:, :, 0] = 0.0 - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", transpose=True) - - pset = ParticleSet( - fieldset, pclass=ptype[mode], lon=np.zeros(npart), lat=np.zeros(npart) + 1e2, depth=np.linspace(0, 1, npart) - ) - time = timedelta(hours=2).total_seconds() - pset.execute(AdvectionRK4, runtime=time, dt=timedelta(seconds=30)) - assert np.allclose(pset.depth * pset.time, pset.lon, atol=1.0e-1) + expected_lon = pset.depth * (pset.time - fieldset.time_interval.left) / np.timedelta64(1, "s") + np.testing.assert_allclose(pset.lon, expected_lon, atol=1.0e-1) -@pytest.mark.parametrize("mode", ["jit", "scipy"]) @pytest.mark.parametrize("direction", ["up", "down"]) @pytest.mark.parametrize("wErrorThroughSurface", [True, False]) -def test_advection_3D_outofbounds(mode, direction, wErrorThroughSurface): - xdim = ydim = zdim = 2 - dimensions = { - "lon": np.linspace(0.0, 1, xdim, dtype=np.float32), - "lat": np.linspace(0.0, 1, ydim, dtype=np.float32), - "depth": np.linspace(0.0, 1, zdim, dtype=np.float32), - } - wfac = -1.0 if direction == "up" else 1.0 - data = { - "U": 0.01 * np.ones((xdim, ydim, zdim), dtype=np.float32), - "V": np.zeros((xdim, ydim, zdim), dtype=np.float32), - "W": wfac * np.ones((xdim, ydim, zdim), dtype=np.float32), - } - fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - - def DeleteParticle(particle, fieldset, time): # pragma: no cover - if particle.state == StatusCode.ErrorOutOfBounds or particle.state == StatusCode.ErrorThroughSurface: - particle.delete() - - def SubmergeParticle(particle, fieldset, time): # pragma: no cover - if particle.state == StatusCode.ErrorThroughSurface: - (u, v) = fieldset.UV[particle] - particle_dlon = u * particle.dt # noqa - particle_dlat = v * particle.dt # noqa - particle_ddepth = 0.0 # noqa - particle.depth = 0 - particle.state = StatusCode.Evaluate +def test_advection_3D_outofbounds(direction, wErrorThroughSurface): + ds = simple_UV_dataset(mesh="flat") + grid = XGrid.from_dataset(ds) + U = Field("U", ds["U"], grid, interp_method=XLinear) + U.data[:] = 0.01 # Set U to small value (to avoid horizontal out of bounds) + V = Field("V", ds["V"], grid, interp_method=XLinear) + W = Field("W", ds["V"], grid, interp_method=XLinear) # Use V as W for testing + W.data[:] = -1.0 if direction == "up" else 1.0 + UVW = VectorField("UVW", U, V, W) + UV = VectorField("UV", U, V) + fieldset = FieldSet([U, V, W, UVW, UV]) + + def DeleteParticle(particles, fieldset): # pragma: no cover + particles.state = np.where(particles.state == StatusCode.ErrorOutOfBounds, StatusCode.Delete, particles.state) + particles.state = np.where( + particles.state == StatusCode.ErrorThroughSurface, StatusCode.Delete, particles.state + ) + + def SubmergeParticle(particles, fieldset): # pragma: no cover + if len(particles.state) == 0: + return + inds = np.argwhere(particles.state == StatusCode.ErrorThroughSurface).flatten() + if len(inds) == 0: + return + dt = particles.dt / np.timedelta64(1, "s") + (u, v) = fieldset.UV[particles[inds]] + particles[inds].dlon = u * dt + particles[inds].dlat = v * dt + particles[inds].ddepth = 0.0 + particles[inds].depth = 0 + particles[inds].state = StatusCode.Evaluate kernels = [AdvectionRK4_3D] if wErrorThroughSurface: kernels.append(SubmergeParticle) kernels.append(DeleteParticle) - pset = ParticleSet(fieldset=fieldset, pclass=ptype[mode], lon=0.5, lat=0.5, depth=0.9) - pset.execute(kernels, runtime=11.0, dt=1) + pset = ParticleSet(fieldset=fieldset, lon=0.5, lat=0.5, depth=0.9) + pset.execute(kernels, runtime=np.timedelta64(11, "s"), dt=np.timedelta64(1, "s")) if direction == "up" and wErrorThroughSurface: - assert np.allclose(pset.lon[0], 0.6) - assert np.allclose(pset.depth[0], 0) + np.testing.assert_allclose(pset.lon[0], 0.6, atol=1e-5) + np.testing.assert_allclose(pset.depth[0], 0, atol=1e-5) else: assert len(pset) == 0 -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("rk45_tol", [10, 100]) -def test_advection_RK45(lon, lat, mode, rk45_tol): - npart = 10 - data2D = { - "U": np.ones((lon.size, lat.size), dtype=np.float32), - "V": np.zeros((lon.size, lat.size), dtype=np.float32), - } - dimensions = {"lon": lon, "lat": lat} - fieldset = FieldSet.from_data(data2D, dimensions, mesh="spherical", transpose=True) - fieldset.add_constant("RK45_tol", rk45_tol) - - dt = timedelta(seconds=30).total_seconds() - RK45Particles = ptype[mode].add_variable("next_dt", dtype=np.float32, initial=dt) - pset = ParticleSet(fieldset, pclass=RK45Particles, lon=np.zeros(npart) + 20.0, lat=np.linspace(0, 80, npart)) - pset.execute(AdvectionRK45, runtime=timedelta(hours=2), dt=dt) - assert (np.diff(pset.lon) > 1.0e-4).all() - assert np.isclose(fieldset.RK45_tol, rk45_tol / (1852 * 60)) - print(fieldset.RK45_tol) - - -def test_conversion_3DCROCO(): - """Test of the (SciPy) version of the conversion from depth to sigma in CROCO - - Values below are retrieved using xroms and hardcoded in the method (to avoid dependency on xroms): - ```py - x, y = 10, 20 - s_xroms = ds.s_w.values - z_xroms = ds.z_w.isel(time=0).isel(eta_rho=y).isel(xi_rho=x).values - lat, lon = ds.y_rho.values[y, x], ds.x_rho.values[y, x] - ``` - """ - fieldset = FieldSet.from_modulefile(TEST_DATA / "fieldset_CROCO3D.py") - - lat, lon = 78000.0, 38000.0 - s_xroms = np.array([-1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0.0], dtype=np.float32) - z_xroms = np.array( - [ - -1.26000000e02, - -1.10585846e02, - -9.60985413e01, - -8.24131317e01, - -6.94126511e01, - -5.69870148e01, - -4.50318756e01, - -3.34476166e01, - -2.21383114e01, - -1.10107975e01, - 2.62768921e-02, - ], - dtype=np.float32, +@pytest.mark.parametrize("u", [-0.3, np.array(0.2)]) +@pytest.mark.parametrize("v", [0.2, np.array(1)]) +@pytest.mark.parametrize("w", [None, -0.2, np.array(0.7)]) +def test_length1dimensions(u, v, w): # TODO: Refactor this test to be more readable (and isolate test setup) + (lon, xdim) = (np.linspace(-10, 10, 21), 21) if isinstance(u, np.ndarray) else (np.array([0]), 1) + (lat, ydim) = (np.linspace(-15, 15, 31), 31) if isinstance(v, np.ndarray) else (np.array([-4]), 1) + (depth, zdim) = ( + (np.linspace(-5, 5, 11), 11) if (isinstance(w, np.ndarray) and w is not None) else (np.array([3]), 1) ) - sigma = np.zeros_like(z_xroms) - from parcels.field import _croco_from_z_to_sigma_scipy - - for zi, z in enumerate(z_xroms): - sigma[zi] = _croco_from_z_to_sigma_scipy(fieldset, 0, z, lat, lon, None) - - assert np.allclose(sigma, s_xroms, atol=1e-3) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_advection_3DCROCO(mode): - fieldset = FieldSet.from_modulefile(TEST_DATA / "fieldset_CROCO3D.py") + tdim = 2 # TODO make this also work for length-1 time dimensions + dims = (tdim, zdim, ydim, xdim) + U = u * np.ones(dims, dtype=np.float32) + V = v * np.ones(dims, dtype=np.float32) + if w is not None: + W = w * np.ones(dims, dtype=np.float32) + + ds = xr.Dataset( + { + "U": (["time", "depth", "YG", "XG"], U), + "V": (["time", "depth", "YG", "XG"], V), + }, + coords={ + "time": (["time"], [np.timedelta64(0, "s"), np.timedelta64(10, "s")], {"axis": "T"}), + "depth": (["depth"], depth, {"axis": "Z"}), + "YC": (["YC"], np.arange(ydim) + 0.5, {"axis": "Y"}), + "YG": (["YG"], np.arange(ydim), {"axis": "Y", "c_grid_axis_shift": -0.5}), + "XC": (["XC"], np.arange(xdim) + 0.5, {"axis": "X"}), + "XG": (["XG"], np.arange(xdim), {"axis": "X", "c_grid_axis_shift": -0.5}), + "lat": (["YG"], lat, {"axis": "Y", "c_grid_axis_shift": 0.5}), + "lon": (["XG"], lon, {"axis": "X", "c_grid_axis_shift": -0.5}), + }, + ) + if w: + ds["W"] = (["time", "depth", "YG", "XG"], W) - runtime = 1e4 - X, Z = np.meshgrid([40e3, 80e3, 120e3], [-10, -130]) - Y = np.ones(X.size) * 100e3 + grid = XGrid.from_dataset(ds) + U = Field("U", ds["U"], grid, interp_method=XLinear) + V = Field("V", ds["V"], grid, interp_method=XLinear) + fields = [U, V, VectorField("UV", U, V)] + if w: + W = Field("W", ds["W"], grid, interp_method=XLinear) + fields.append(VectorField("UVW", U, V, W)) + fieldset = FieldSet(fields) - pclass = ptype[mode].add_variable(Variable("w")) - pset = ParticleSet(fieldset=fieldset, pclass=pclass, lon=X, lat=Y, depth=Z) + x0, y0, z0 = 2, 8, -4 + pset = ParticleSet(fieldset, lon=x0, lat=y0, depth=z0) + kernel = AdvectionRK4 if w is None else AdvectionRK4_3D + pset.execute(kernel, runtime=np.timedelta64(5, "s"), dt=np.timedelta64(1, "s")) - def SampleW(particle, fieldset, time): # pragma: no cover - particle.w = fieldset.W[time, particle.depth, particle.lat, particle.lon] + assert len(pset.lon) == len([p.lon for p in pset]) + np.testing.assert_allclose(np.array([p.lon - x0 for p in pset]), 4 * u, atol=1e-6) + np.testing.assert_allclose(np.array([p.lat - y0 for p in pset]), 4 * v, atol=1e-6) + if w: + np.testing.assert_allclose(np.array([p.depth - z0 for p in pset]), 4 * w, atol=1e-6) - pset.execute([AdvectionRK4_3D, SampleW], runtime=runtime, dt=100) - assert np.allclose(pset.depth, Z.flatten(), atol=5) # TODO lower this atol - assert np.allclose(pset.lon_nextloop, [x + runtime for x in X.flatten()], atol=1e-3) +def test_radialrotation(npart=10): + ds = radial_rotation_dataset() + grid = XGrid.from_dataset(ds, mesh="flat") + U = parcels.Field("U", ds["U"], grid, interp_method=XLinear) + V = parcels.Field("V", ds["V"], grid, interp_method=XLinear) + UV = parcels.VectorField("UV", U, V) + fieldset = parcels.FieldSet([U, V, UV]) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_advection_2DCROCO(mode): - fieldset = FieldSet.from_modulefile(TEST_DATA / "fieldset_CROCO2D.py") + dt = np.timedelta64(30, "s") + lon = np.linspace(32, 50, npart) + lat = np.ones(npart) * 30 + starttime = np.arange(np.timedelta64(0, "s"), npart * dt, dt) - runtime = 1e4 - X = np.array([40e3, 80e3, 120e3]) - Y = np.ones(X.size) * 100e3 - Z = np.zeros(X.size) - pset = ParticleSet(fieldset=fieldset, pclass=ptype[mode], lon=X, lat=Y, depth=Z) + pset = parcels.ParticleSet(fieldset, lon=lon, lat=lat, time=starttime) + pset.execute(parcels.kernels.AdvectionRK4, endtime=np.timedelta64(10, "m"), dt=dt) - pset.execute([AdvectionRK4], runtime=runtime, dt=100) - assert np.allclose(pset.depth, Z.flatten(), atol=1e-3) - assert np.allclose(pset.lon_nextloop, [x + runtime for x in X], atol=1e-3) + theta = 2 * np.pi * (pset.time - starttime) / np.timedelta64(24 * 3600, "s") + true_lon = (lon - 30.0) * np.cos(theta) + 30.0 + true_lat = -(lon - 30.0) * np.sin(theta) + 30.0 + np.testing.assert_allclose(pset.lon, true_lon, atol=5e-2) + np.testing.assert_allclose(pset.lat, true_lat, atol=5e-2) -def create_periodic_fieldset(xdim, ydim, uvel, vvel): - dimensions = { - "lon": np.linspace(0.0, 1.0, xdim + 1, dtype=np.float32)[1:], # don't include both 0 and 1, for periodic b.c. - "lat": np.linspace(0.0, 1.0, ydim + 1, dtype=np.float32)[1:], - } - data = {"U": uvel * np.ones((xdim, ydim), dtype=np.float32), "V": vvel * np.ones((xdim, ydim), dtype=np.float32)} - return FieldSet.from_data(data, dimensions, mesh="spherical", transpose=True) +@pytest.mark.parametrize( + "method, rtol", + [ + ("EE", 1e-2), + ("AdvDiffEM", 1e-2), + ("AdvDiffM1", 1e-2), + ("RK4", 1e-5), + ("RK4_3D", 1e-5), + ("RK45", 1e-4), + ], +) +def test_moving_eddy(method, rtol): + ds = moving_eddy_dataset() + grid = XGrid.from_dataset(ds) + U = Field("U", ds["U"], grid, interp_method=XLinear) + V = Field("V", ds["V"], grid, interp_method=XLinear) + if method == "RK4_3D": + # Using W to test 3D advection (assuming same velocity as V) + W = Field("W", ds["V"], grid, interp_method=XLinear) + UVW = VectorField("UVW", U, V, W) + fieldset = FieldSet([U, V, W, UVW]) + else: + UV = VectorField("UV", U, V) + fieldset = FieldSet([U, V, UV]) + if method in ["AdvDiffEM", "AdvDiffM1"]: + # Add zero diffusivity field for diffusion kernels + ds["Kh"] = (["time", "depth", "YG", "XG"], np.full(ds["U"].shape, 0)) + fieldset.add_field(Field("Kh", ds["Kh"], grid, interp_method=XLinear), "Kh_zonal") + fieldset.add_field(Field("Kh", ds["Kh"], grid, interp_method=XLinear), "Kh_meridional") + fieldset.add_constant("dres", 0.1) + start_lon, start_lat, start_depth = 12000, 12500, 12500 + dt = np.timedelta64(30, "m") -def periodicBC(particle, fieldset, time): # pragma: no cover - particle.lon = math.fmod(particle.lon, 1) - particle.lat = math.fmod(particle.lat, 1) + if method == "RK45": + fieldset.add_constant("RK45_tol", rtol) + pset = ParticleSet(fieldset, lon=start_lon, lat=start_lat, depth=start_depth, time=np.timedelta64(0, "s")) + pset.execute(kernel[method], dt=dt, endtime=np.timedelta64(1, "h")) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_advection_periodic_zonal(mode): - xdim, ydim, halosize = 100, 100, 3 - fieldset = create_periodic_fieldset(xdim, ydim, uvel=1.0, vvel=0.0) - fieldset.add_periodic_halo(zonal=True, halosize=halosize) - assert len(fieldset.U.lon) == xdim + 2 * halosize + def truth_moving(x_0, y_0, t): + t /= np.timedelta64(1, "s") + lat = y_0 - (ds.u_0 - ds.u_g) / ds.f * (1 - np.cos(ds.f * t)) + lon = x_0 + ds.u_g * t + (ds.u_0 - ds.u_g) / ds.f * np.sin(ds.f * t) + return lon, lat - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=[0.5], lat=[0.5]) - pset.execute(AdvectionRK4 + pset.Kernel(periodicBC), runtime=timedelta(hours=20), dt=timedelta(seconds=30)) - assert abs(pset.lon[0] - 0.15) < 0.1 + exp_lon, exp_lat = truth_moving(start_lon, start_lat, pset.time[0]) + np.testing.assert_allclose(pset.lon, exp_lon, rtol=rtol) + np.testing.assert_allclose(pset.lat, exp_lat, rtol=rtol) + if method == "RK4_3D": + np.testing.assert_allclose(pset.depth, exp_lat, rtol=rtol) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_advection_periodic_meridional(mode): - xdim, ydim = 100, 100 - fieldset = create_periodic_fieldset(xdim, ydim, uvel=0.0, vvel=1.0) - fieldset.add_periodic_halo(meridional=True) - assert len(fieldset.U.lat) == ydim + 10 # default halo size is 5 grid points +@pytest.mark.parametrize( + "method, rtol", + [ + ("EE", 1e-1), + ("RK4", 1e-5), + ("RK45", 1e-4), + ], +) +def test_decaying_moving_eddy(method, rtol): + ds = decaying_moving_eddy_dataset() + grid = XGrid.from_dataset(ds) + U = Field("U", ds["U"], grid, interp_method=XLinear) + V = Field("V", ds["V"], grid, interp_method=XLinear) + UV = VectorField("UV", U, V) + fieldset = FieldSet([U, V, UV]) + + start_lon, start_lat = 10000, 10000 + dt = np.timedelta64(60, "m") + + if method == "RK45": + fieldset.add_constant("RK45_tol", rtol) + fieldset.add_constant("RK45_min_dt", 10 * 60) + + pset = ParticleSet(fieldset, lon=start_lon, lat=start_lat, time=np.timedelta64(0, "s")) + pset.execute(kernel[method], dt=dt, endtime=np.timedelta64(1, "D")) + + def truth_moving(x_0, y_0, t): + t /= np.timedelta64(1, "s") + lon = ( + x_0 + + (ds.u_g / ds.gamma_g) * (1 - np.exp(-ds.gamma_g * t)) + + ds.f + * ((ds.u_0 - ds.u_g) / (ds.f**2 + ds.gamma**2)) + * ((ds.gamma / ds.f) + np.exp(-ds.gamma * t) * (np.sin(ds.f * t) - (ds.gamma / ds.f) * np.cos(ds.f * t))) + ) + lat = y_0 - ((ds.u_0 - ds.u_g) / (ds.f**2 + ds.gamma**2)) * ds.f * ( + 1 - np.exp(-ds.gamma * t) * (np.cos(ds.f * t) + (ds.gamma / ds.f) * np.sin(ds.f * t)) + ) + return lon, lat + + exp_lon, exp_lat = truth_moving(start_lon, start_lat, pset.time[0]) + np.testing.assert_allclose(pset.lon, exp_lon, rtol=rtol) + np.testing.assert_allclose(pset.lat, exp_lat, rtol=rtol) - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=[0.5], lat=[0.5]) - pset.execute(AdvectionRK4 + pset.Kernel(periodicBC), runtime=timedelta(hours=20), dt=timedelta(seconds=30)) - assert abs(pset.lat[0] - 0.15) < 0.1 +@pytest.mark.parametrize( + "method, rtol", + [ + ("RK4", 0.1), + ("RK45", 0.1), + ], +) +@pytest.mark.parametrize("grid_type", ["A", "C"]) +def test_stommelgyre_fieldset(method, rtol, grid_type): + npart = 2 + ds = stommel_gyre_dataset(grid_type=grid_type) + grid = XGrid.from_dataset(ds) + vector_interp_method = None if grid_type == "A" else CGrid_Velocity + U = Field("U", ds["U"], grid) + V = Field("V", ds["V"], grid) + P = Field("P", ds["P"], grid, interp_method=XLinear) + UV = VectorField("UV", U, V, vector_interp_method=vector_interp_method) + fieldset = FieldSet([U, V, P, UV]) + + dt = np.timedelta64(30, "m") + runtime = np.timedelta64(1, "D") + start_lon = np.linspace(10e3, 100e3, npart) + start_lat = np.ones_like(start_lon) * 5000e3 + + if method == "RK45": + fieldset.add_constant("RK45_tol", rtol) + + SampleParticle = Particle.add_variable( + [Variable("p", initial=0.0, dtype=np.float32), Variable("p_start", initial=0.0, dtype=np.float32)] + ) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_advection_periodic_zonal_meridional(mode): - xdim, ydim = 100, 100 - fieldset = create_periodic_fieldset(xdim, ydim, uvel=1.0, vvel=1.0) - fieldset.add_periodic_halo(zonal=True, meridional=True) - assert len(fieldset.U.lat) == ydim + 10 # default halo size is 5 grid points - assert len(fieldset.U.lon) == xdim + 10 # default halo size is 5 grid points - assert np.allclose(np.diff(fieldset.U.lat), fieldset.U.lat[1] - fieldset.U.lat[0], rtol=0.001) - assert np.allclose(np.diff(fieldset.U.lon), fieldset.U.lon[1] - fieldset.U.lon[0], rtol=0.001) + def UpdateP(particles, fieldset): # pragma: no cover + particles.p = fieldset.P[particles.time, particles.depth, particles.lat, particles.lon] + particles.p_start = np.where(particles.time == 0, particles.p, particles.p_start) - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=[0.4], lat=[0.5]) - pset.execute(AdvectionRK4 + pset.Kernel(periodicBC), runtime=timedelta(hours=20), dt=timedelta(seconds=30)) - assert abs(pset.lon[0] - 0.05) < 0.1 - assert abs(pset.lat[0] - 0.15) < 0.1 + pset = ParticleSet(fieldset, pclass=SampleParticle, lon=start_lon, lat=start_lat, time=np.timedelta64(0, "s")) + pset.execute([kernel[method], UpdateP], dt=dt, runtime=runtime) + np.testing.assert_allclose(pset.p, pset.p_start, rtol=rtol) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("u", [-0.3, np.array(0.2)]) -@pytest.mark.parametrize("v", [0.2, np.array(1)]) -@pytest.mark.parametrize("w", [None, -0.2, np.array(0.7)]) -def test_length1dimensions(mode, u, v, w): - (lon, xdim) = (np.linspace(-10, 10, 21), 21) if isinstance(u, np.ndarray) else (0, 1) - (lat, ydim) = (np.linspace(-15, 15, 31), 31) if isinstance(v, np.ndarray) else (-4, 1) - (depth, zdim) = (np.linspace(-5, 5, 11), 11) if (isinstance(w, np.ndarray) and w is not None) else (3, 1) - dimensions = {"lon": lon, "lat": lat, "depth": depth} - - dims = [] - if zdim > 1: - dims.append(zdim) - if ydim > 1: - dims.append(ydim) - if xdim > 1: - dims.append(xdim) - if len(dims) > 0: - U = u * np.ones(dims, dtype=np.float32) - V = v * np.ones(dims, dtype=np.float32) - if w is not None: - W = w * np.ones(dims, dtype=np.float32) - else: - U, V, W = u, v, w +@pytest.mark.parametrize( + "method, rtol", + [ + ("RK4", 5e-3), + ("RK45", 1e-4), + ], +) +@pytest.mark.parametrize("grid_type", ["A"]) # TODO also implement C-grid once available +def test_peninsula_fieldset(method, rtol, grid_type): + npart = 2 + ds = peninsula_dataset(grid_type=grid_type) + grid = XGrid.from_dataset(ds) + U = Field("U", ds["U"], grid, interp_method=XLinear) + V = Field("V", ds["V"], grid, interp_method=XLinear) + P = Field("P", ds["P"], grid, interp_method=XLinear) + UV = VectorField("UV", U, V) + fieldset = FieldSet([U, V, P, UV]) + + dt = np.timedelta64(30, "m") + runtime = np.timedelta64(1, "D") + start_lat = np.linspace(3e3, 47e3, npart) + start_lon = 3e3 * np.ones_like(start_lat) + + if method == "RK45": + fieldset.add_constant("RK45_tol", rtol) + + SampleParticle = Particle.add_variable( + [Variable("p", initial=0.0, dtype=np.float32), Variable("p_start", initial=0.0, dtype=np.float32)] + ) - data = {"U": U, "V": V} - if w is not None: - data["W"] = W - fieldset = FieldSet.from_data(data, dimensions, mesh="flat") + def UpdateP(particles, fieldset): # pragma: no cover + particles.p = fieldset.P[particles.time, particles.depth, particles.lat, particles.lon] + particles.p_start = np.where(particles.time == 0, particles.p, particles.p_start) - x0, y0, z0 = 2, 8, -4 - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=x0, lat=y0, depth=z0) - pfunc = AdvectionRK4 if w is None else AdvectionRK4_3D - kernel = pset.Kernel(pfunc) - pset.execute(kernel, runtime=5, dt=1) + pset = ParticleSet(fieldset, pclass=SampleParticle, lon=start_lon, lat=start_lat, time=np.timedelta64(0, "s")) + pset.execute([kernel[method], UpdateP], dt=dt, runtime=runtime) + np.testing.assert_allclose(pset.p, pset.p_start, rtol=rtol) - assert len(pset.lon) == len([p.lon for p in pset]) - assert ((np.array([p.lon - x0 for p in pset]) - 4 * u) < 1e-6).all() - assert ((np.array([p.lat - y0 for p in pset]) - 4 * v) < 1e-6).all() - if w: - assert ((np.array([p.depth - y0 for p in pset]) - 4 * w) < 1e-6).all() +def test_nemo_curvilinear_fieldset(): + data_folder = parcels.download_example_dataset("NemoCurvilinear_data") + files = data_folder.glob("*.nc4") + ds = xr.open_mfdataset(files, combine="nested", data_vars="minimal", coords="minimal", compat="override") + ds = ( + ds.isel(time_counter=0, drop=True) + .isel(time=0, drop=True) + .isel(z_a=0, drop=True) + .rename({"glamf": "lon", "gphif": "lat", "z": "depth"}) + ) -def truth_stationary(x_0, y_0, t): - lat = y_0 - u_0 / f * (1 - math.cos(f * t)) - lon = x_0 + u_0 / f * math.sin(f * t) - return lon, lat + xgcm_grid = xgcm.Grid( + ds, + coords={ + "X": {"left": "x"}, + "Y": {"left": "y"}, + }, + periodic=False, + autoparse_metadata=False, + ) + grid = XGrid(xgcm_grid, mesh="spherical") + U = parcels.Field("U", ds["U"], grid) + V = parcels.Field("V", ds["V"], grid) + U.units = parcels.GeographicPolar() + V.units = parcels.Geographic() + UV = parcels.VectorField("UV", U, V, vector_interp_method=CGrid_Velocity) + fieldset = parcels.FieldSet([U, V, UV]) -def create_fieldset_stationary(xdim=100, ydim=100, maxtime=timedelta(hours=6)): - """Generate a FieldSet encapsulating the flow field of a stationary eddy. + npart = 20 + lonp = 30 * np.ones(npart) + latp = np.linspace(-70, 88, npart) + runtime = np.timedelta64(12, "h") # TODO increase to 160 days - Reference: N. Fabbroni, 2009, "Numerical simulations of passive - tracers dispersion in the sea" - """ - time = np.arange(0.0, maxtime.total_seconds() + 1e-5, 60.0, dtype=np.float64) - dimensions = { - "lon": np.linspace(0, 25000, xdim, dtype=np.float32), - "lat": np.linspace(0, 25000, ydim, dtype=np.float32), - "time": time, - } - data = { - "U": np.ones((xdim, ydim, 1), dtype=np.float32) * u_0 * np.cos(f * time), - "V": np.ones((xdim, ydim, 1), dtype=np.float32) * -u_0 * np.sin(f * time), - } - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", transpose=True) - # setting some constants for AdvectionRK45 kernel - fieldset.RK45_min_dt = 1e-3 - fieldset.RK45_max_dt = 1e2 - fieldset.RK45_tol = 1e-5 - return fieldset + def periodicBC(particles, fieldset): # pragma: no cover + particles.dlon = np.where(particles.lon > 180, particles.dlon - 360, particles.dlon) + pset = parcels.ParticleSet(fieldset, lon=lonp, lat=latp) + pset.execute([AdvectionEE, periodicBC], runtime=runtime, dt=np.timedelta64(6, "h")) + np.testing.assert_allclose(pset.lat, latp, atol=1e-1) -@pytest.fixture -def fieldset_stationary(): - return create_fieldset_stationary() +@pytest.mark.parametrize("method", ["RK4", "RK4_3D"]) +def test_nemo_3D_curvilinear_fieldset(method): + download_dir = parcels.download_example_dataset("NemoNorthSeaORCA025-N006_data") + ufiles = download_dir.glob("*U.nc") + dsu = xr.open_mfdataset(ufiles, decode_times=False, drop_variables=["nav_lat", "nav_lon"]) + dsu = dsu.rename({"time_counter": "time", "uo": "U"}) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize( - "method, rtol, diffField", - [ - ("EE", 1e-2, False), - ("AdvDiffEM", 1e-2, True), - ("AdvDiffM1", 1e-2, True), - ("RK4", 1e-5, False), - ("RK45", 1e-5, False), - ], -) -def test_stationary_eddy(fieldset_stationary, mode, method, rtol, diffField): - npart = 1 - fieldset = fieldset_stationary - if diffField: - fieldset.add_field(Field("Kh_zonal", np.zeros(fieldset.U.data.shape), grid=fieldset.U.grid)) - fieldset.add_field(Field("Kh_meridional", np.zeros(fieldset.V.data.shape), grid=fieldset.V.grid)) - fieldset.add_constant("dres", 0.1) - lon = np.linspace(12000, 21000, npart) - lat = np.linspace(12500, 12500, npart) - dt = timedelta(minutes=3).total_seconds() - endtime = timedelta(hours=6).total_seconds() - - RK45Particles = ptype[mode].add_variable("next_dt", dtype=np.float32, initial=dt) - - pclass = RK45Particles if method == "RK45" else ptype[mode] - pset = ParticleSet(fieldset, pclass=pclass, lon=lon, lat=lat) - pset.execute(kernel[method], dt=dt, endtime=endtime) - - exp_lon = [truth_stationary(x, y, pset[0].time)[0] for x, y in zip(lon, lat, strict=True)] - exp_lat = [truth_stationary(x, y, pset[0].time)[1] for x, y in zip(lon, lat, strict=True)] - assert np.allclose(pset.lon, exp_lon, rtol=rtol) - assert np.allclose(pset.lat, exp_lat, rtol=rtol) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_stationary_eddy_vertical(mode): - npart = 1 - lon = np.linspace(12000, 21000, npart) - lat = np.linspace(10000, 20000, npart) - depth = np.linspace(12500, 12500, npart) - endtime = timedelta(hours=6).total_seconds() - dt = timedelta(minutes=3).total_seconds() - - xdim = ydim = 100 - lon_data = np.linspace(0, 25000, xdim, dtype=np.float32) - lat_data = np.linspace(0, 25000, ydim, dtype=np.float32) - time_data = np.arange(0.0, 6 * 3600 + 1e-5, 60.0, dtype=np.float64) - fld1 = np.ones((xdim, ydim, 1), dtype=np.float32) * u_0 * np.cos(f * time_data) - fld2 = np.ones((xdim, ydim, 1), dtype=np.float32) * -u_0 * np.sin(f * time_data) - fldzero = np.zeros((xdim, ydim, 1), dtype=np.float32) * time_data - - dimensions = {"lon": lon_data, "lat": lat_data, "time": time_data} - data = {"U": fld1, "V": fldzero, "W": fld2} - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", transpose=True) - - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=lon, lat=lat, depth=depth) - pset.execute(AdvectionRK4_3D, dt=dt, endtime=endtime) - exp_lon = [truth_stationary(x, z, pset[0].time)[0] for x, z in zip(lon, depth, strict=True)] - exp_depth = [truth_stationary(x, z, pset[0].time)[1] for x, z in zip(lon, depth, strict=True)] - print(pset, exp_lon) - assert np.allclose(pset.lon, exp_lon, rtol=1e-5) - assert np.allclose(pset.lat, lat, rtol=1e-5) - assert np.allclose(pset.depth, exp_depth, rtol=1e-5) - - data = {"U": fldzero, "V": fld2, "W": fld1} - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", transpose=True) - - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=lon, lat=lat, depth=depth) - pset.execute(AdvectionRK4_3D, dt=dt, endtime=endtime) - exp_depth = [truth_stationary(z, y, pset[0].time)[0] for z, y in zip(depth, lat, strict=True)] - exp_lat = [truth_stationary(z, y, pset[0].time)[1] for z, y in zip(depth, lat, strict=True)] - assert np.allclose(pset.lon, lon, rtol=1e-5) - assert np.allclose(pset.lat, exp_lat, rtol=1e-5) - assert np.allclose(pset.depth, exp_depth, rtol=1e-5) - - -def truth_moving(x_0, y_0, t): - lat = y_0 - (u_0 - u_g) / f * (1 - math.cos(f * t)) - lon = x_0 + u_g * t + (u_0 - u_g) / f * math.sin(f * t) - return lon, lat - - -def create_fieldset_moving(xdim=100, ydim=100, maxtime=timedelta(hours=6)): - """Generate a FieldSet encapsulating the flow field of a moving eddy. - - Reference: N. Fabbroni, 2009, "Numerical simulations of passive - tracers dispersion in the sea" - """ - time = np.arange(0.0, maxtime.total_seconds() + 1e-5, 60.0, dtype=np.float64) - dimensions = { - "lon": np.linspace(0, 25000, xdim, dtype=np.float32), - "lat": np.linspace(0, 25000, ydim, dtype=np.float32), - "time": time, - } - data = { - "U": np.ones((xdim, ydim, 1), dtype=np.float32) * u_g + (u_0 - u_g) * np.cos(f * time), - "V": np.ones((xdim, ydim, 1), dtype=np.float32) * -(u_0 - u_g) * np.sin(f * time), - } - return FieldSet.from_data(data, dimensions, mesh="flat", transpose=True) - - -@pytest.fixture -def fieldset_moving(): - return create_fieldset_moving() - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize( - "method, rtol, diffField", - [ - ("EE", 1e-2, False), - ("AdvDiffEM", 1e-2, True), - ("AdvDiffM1", 1e-2, True), - ("RK4", 1e-5, False), - ("RK45", 1e-5, False), - ], -) -def test_moving_eddy(fieldset_moving, mode, method, rtol, diffField): - npart = 1 - fieldset = fieldset_moving - if diffField: - fieldset.add_field(Field("Kh_zonal", np.zeros(fieldset.U.data.shape), grid=fieldset.U.grid)) - fieldset.add_field(Field("Kh_meridional", np.zeros(fieldset.V.data.shape), grid=fieldset.V.grid)) - fieldset.add_constant("dres", 0.1) - lon = np.linspace(12000, 21000, npart) - lat = np.linspace(12500, 12500, npart) - dt = timedelta(minutes=3).total_seconds() - endtime = timedelta(hours=6).total_seconds() + vfiles = download_dir.glob("*V.nc") + dsv = xr.open_mfdataset(vfiles, decode_times=False, drop_variables=["nav_lat", "nav_lon"]) + dsv = dsv.rename({"time_counter": "time", "vo": "V"}) - RK45Particles = ptype[mode].add_variable("next_dt", dtype=np.float32, initial=dt) + wfiles = download_dir.glob("*W.nc") + dsw = xr.open_mfdataset(wfiles, decode_times=False, drop_variables=["nav_lat", "nav_lon"]) + dsw = dsw.rename({"time_counter": "time", "depthw": "depth", "wo": "W"}) - pclass = RK45Particles if method == "RK45" else ptype[mode] - pset = ParticleSet(fieldset, pclass=pclass, lon=lon, lat=lat) - pset.execute(kernel[method], dt=dt, endtime=endtime) + dsu = dsu.assign_coords(depthu=dsw.depth.values) + dsu = dsu.rename({"depthu": "depth"}) - exp_lon = [truth_moving(x, y, t)[0] for x, y, t in zip(lon, lat, pset.time, strict=True)] - exp_lat = [truth_moving(x, y, t)[1] for x, y, t in zip(lon, lat, pset.time, strict=True)] - assert np.allclose(pset.lon, exp_lon, rtol=rtol) - assert np.allclose(pset.lat, exp_lat, rtol=rtol) + dsv = dsv.assign_coords(depthv=dsw.depth.values) + dsv = dsv.rename({"depthv": "depth"}) + coord_file = f"{download_dir}/coordinates.nc" + dscoord = xr.open_dataset(coord_file, decode_times=False).rename({"glamf": "lon", "gphif": "lat"}) + dscoord = dscoord.isel(time=0, drop=True) -def truth_decaying(x_0, y_0, t): - lat = y_0 - ( - (u_0 - u_g) * f / (f**2 + gamma**2) * (1 - np.exp(-gamma * t) * (np.cos(f * t) + gamma / f * np.sin(f * t))) + ds = xr.merge([dsu, dsv, dsw, dscoord]) + ds = ds.drop_vars( + [ + "uos", + "vos", + "nav_lev", + "nav_lon", + "nav_lat", + "tauvo", + "tauuo", + "time_steps", + "gphiu", + "gphiv", + "gphit", + "glamu", + "glamv", + "glamt", + "time_centered_bounds", + "time_counter_bounds", + "time_centered", + ] ) - lon = x_0 + ( - u_g / gamma_g * (1 - np.exp(-gamma_g * t)) - + (u_0 - u_g) - * f - / (f**2 + gamma**2) - * (gamma / f + np.exp(-gamma * t) * (math.sin(f * t) - gamma / f * math.cos(f * t))) + ds = ds.drop_vars(["e1f", "e1t", "e1u", "e1v", "e2f", "e2t", "e2u", "e2v"]) + ds["time"] = [np.timedelta64(int(t), "s") + np.datetime64("1900-01-01") for t in ds["time"]] + + ds["W"] *= -1 # Invert W velocity + + xgcm_grid = xgcm.Grid( + ds, + coords={ + "X": {"left": "x"}, + "Y": {"left": "y"}, + "Z": {"left": "depth"}, + "T": {"center": "time"}, + }, + periodic=False, + autoparse_metadata=False, ) - return lon, lat - - -def create_fieldset_decaying(xdim=100, ydim=100, maxtime=timedelta(hours=6)): - """Generate a FieldSet encapsulating the flow field of a decaying eddy. - - Reference: N. Fabbroni, 2009, "Numerical simulations of passive - tracers dispersion in the sea" - """ - time = np.arange(0.0, maxtime.total_seconds() + 1e-5, 60.0, dtype=np.float64) - dimensions = { - "lon": np.linspace(0, 25000, xdim, dtype=np.float32), - "lat": np.linspace(0, 25000, ydim, dtype=np.float32), - "time": time, - } - data = { - "U": np.ones((xdim, ydim, 1), dtype=np.float32) * u_g * np.exp(-gamma_g * time) - + (u_0 - u_g) * np.exp(-gamma * time) * np.cos(f * time), - "V": np.ones((xdim, ydim, 1), dtype=np.float32) * -(u_0 - u_g) * np.exp(-gamma * time) * np.sin(f * time), - } - return FieldSet.from_data(data, dimensions, mesh="flat", transpose=True) + grid = XGrid(xgcm_grid, mesh="spherical") + U = parcels.Field("U", ds["U"], grid) + V = parcels.Field("V", ds["V"], grid) + W = parcels.Field("W", ds["W"], grid) + U.units = parcels.GeographicPolar() + V.units = parcels.Geographic() + UV = parcels.VectorField("UV", U, V, vector_interp_method=CGrid_Velocity) + UVW = parcels.VectorField("UVW", U, V, W, vector_interp_method=CGrid_Velocity) + fieldset = parcels.FieldSet([U, V, W, UV, UVW]) -@pytest.fixture -def fieldset_decaying(): - return create_fieldset_decaying() - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize( - "method, rtol, diffField", - [ - ("EE", 1e-2, False), - ("AdvDiffEM", 1e-2, True), - ("AdvDiffM1", 1e-2, True), - ("RK4", 1e-5, False), - ("RK45", 1e-5, False), - ("AA", 1e-3, False), - ], -) -def test_decaying_eddy(fieldset_decaying, mode, method, rtol, diffField): - npart = 1 - fieldset = fieldset_decaying - if method == "AA": - if mode == "jit": - return # AnalyticalAdvection not implemented in JIT - else: - # needed for AnalyticalAdvection to work, but comes at expense of accuracy - fieldset.U.interp_method = "cgrid_velocity" - fieldset.V.interp_method = "cgrid_velocity" - - if diffField: - fieldset.add_field(Field("Kh_zonal", np.zeros(fieldset.U.data.shape), grid=fieldset.U.grid)) - fieldset.add_field(Field("Kh_meridional", np.zeros(fieldset.V.data.shape), grid=fieldset.V.grid)) - fieldset.add_constant("dres", 0.1) - lon = np.linspace(12000, 21000, npart) - lat = np.linspace(12500, 12500, npart) - dt = timedelta(minutes=3).total_seconds() - endtime = timedelta(hours=6).total_seconds() - - RK45Particles = ptype[mode].add_variable("next_dt", dtype=np.float32, initial=dt) - - pclass = RK45Particles if method == "RK45" else ptype[mode] - pset = ParticleSet(fieldset, pclass=pclass, lon=lon, lat=lat) - pset.execute(kernel[method], dt=dt, endtime=endtime) - - exp_lon = [truth_decaying(x, y, t)[0] for x, y, t in zip(lon, lat, pset.time, strict=True)] - exp_lat = [truth_decaying(x, y, t)[1] for x, y, t in zip(lon, lat, pset.time, strict=True)] - assert np.allclose(pset.lon, exp_lon, rtol=rtol) - assert np.allclose(pset.lat, exp_lat, rtol=rtol) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_analyticalAgrid(mode): - lon = np.arange(0, 15, dtype=np.float32) - lat = np.arange(0, 15, dtype=np.float32) - U = np.ones((lat.size, lon.size), dtype=np.float32) - V = np.ones((lat.size, lon.size), dtype=np.float32) - fieldset = FieldSet.from_data({"U": U, "V": V}, {"lon": lon, "lat": lat}, mesh="flat") - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=1, lat=1) - - with pytest.raises(NotImplementedError): - pset.execute(AdvectionAnalytical, runtime=1) - - -@pytest.mark.parametrize("mode", ["scipy"]) # JIT not implemented -@pytest.mark.parametrize("u", [1, -0.2, -0.3, 0]) -@pytest.mark.parametrize("v", [1, -0.3, 0, -1]) -@pytest.mark.parametrize("w", [None, 1, -0.3, 0, -1]) -@pytest.mark.parametrize("direction", [1, -1]) -def test_uniform_analytical(mode, u, v, w, direction, tmp_zarrfile): - lon = np.arange(0, 15, dtype=np.float32) - lat = np.arange(0, 15, dtype=np.float32) - if w is not None: - depth = np.arange(0, 40, 2, dtype=np.float32) - U = u * np.ones((depth.size, lat.size, lon.size), dtype=np.float32) - V = v * np.ones((depth.size, lat.size, lon.size), dtype=np.float32) - W = w * np.ones((depth.size, lat.size, lon.size), dtype=np.float32) - fieldset = FieldSet.from_data({"U": U, "V": V, "W": W}, {"lon": lon, "lat": lat, "depth": depth}, mesh="flat") - fieldset.W.interp_method = "cgrid_velocity" - else: - U = u * np.ones((lat.size, lon.size), dtype=np.float32) - V = v * np.ones((lat.size, lon.size), dtype=np.float32) - fieldset = FieldSet.from_data({"U": U, "V": V}, {"lon": lon, "lat": lat}, mesh="flat") - fieldset.U.interp_method = "cgrid_velocity" - fieldset.V.interp_method = "cgrid_velocity" - - x0, y0, z0 = 6.1, 6.2, 20 - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=x0, lat=y0, depth=z0) - - outfile = pset.ParticleFile(name=tmp_zarrfile, outputdt=1, chunks=(1, 1)) - pset.execute(AdvectionAnalytical, runtime=4, dt=direction, output_file=outfile) - assert np.abs(pset.lon - x0 - pset.time * u) < 1e-6 - assert np.abs(pset.lat - y0 - pset.time * v) < 1e-6 - if w is not None: - assert np.abs(pset.depth - z0 - pset.time * w) < 1e-4 - - ds = xr.open_zarr(tmp_zarrfile) - times = (direction * ds["time"][:]).values.astype("timedelta64[s]")[0] - timeref = np.arange(1, 5).astype("timedelta64[s]") - assert np.allclose(times, timeref, atol=np.timedelta64(1, "ms")) - lons = ds["lon"][:].values - assert np.allclose(lons, x0 + direction * u * np.arange(1, 5)) + npart = 10 + lons = np.linspace(1.9, 3.4, npart) + lats = np.linspace(52.5, 51.6, npart) + pset = parcels.ParticleSet(fieldset, lon=lons, lat=lats, depth=np.ones_like(lons)) + + pset.execute(kernel[method], runtime=np.timedelta64(4, "D"), dt=np.timedelta64(6, "h")) + + if method == "RK4": + np.testing.assert_equal(round_and_hash_float_array([p.lon for p in pset], decimals=5), 29977383852960156017546) + elif method == "RK4_3D": + # TODO check why decimals needs to be so low in RK4_3D (compare to v3) + np.testing.assert_equal( + round_and_hash_float_array([p.depth for p in pset], decimals=1), 29747210774230389239432 + ) diff --git a/tests/test_basegrid.py b/tests/test_basegrid.py new file mode 100644 index 000000000..de11f00e2 --- /dev/null +++ b/tests/test_basegrid.py @@ -0,0 +1,53 @@ +from __future__ import annotations + +import itertools + +import numpy as np +import pytest + +from parcels._core.basegrid import BaseGrid + + +class MockGrid(BaseGrid): + def __init__(self, axis_dim: dict[str, int]): + self.axis_dim = axis_dim + + def search(self, z: float, y: float, x: float, ei=None) -> dict[str, tuple[int, float | np.ndarray]]: + pass + + @property + def axes(self) -> list[str]: + return list(self.axis_dim.keys()) + + def get_axis_dim(self, axis: str) -> int: + return self.axis_dim[axis] + + +@pytest.mark.parametrize( + "grid", + [ + MockGrid({"Z": 10, "Y": 20, "X": 30}), + MockGrid({"Z": 5, "Y": 15}), + MockGrid({"Z": 8}), + MockGrid({"Z": 12, "FACE": 25}), + ], +) +def test_basegrid_ravel_unravel_index(grid): + axes = grid.axes + dimensionalities = (grid.get_axis_dim(axis) for axis in axes) + all_possible_axis_indices = itertools.product(*[np.arange(dim)[:, np.newaxis] for dim in dimensionalities]) + + encountered_eis = [] + + for axis_indices_numeric in all_possible_axis_indices: + axis_indices = dict(zip(axes, axis_indices_numeric, strict=True)) + + ei = grid.ravel_index(axis_indices) + axis_indices_test = grid.unravel_index(ei) + assert axis_indices_test == axis_indices + encountered_eis.append(ei[0]) + + encountered_eis = sorted(encountered_eis) + assert len(set(encountered_eis)) == len(encountered_eis), "Raveled indices are not unique." + assert np.allclose(np.diff(np.array(encountered_eis)), 1), "Raveled indices are not consecutive integers." + assert encountered_eis[0] == 0, "Raveled indices do not start at 0." diff --git a/tests/test_compat.py b/tests/test_compat.py deleted file mode 100644 index 4ad9c9e07..000000000 --- a/tests/test_compat.py +++ /dev/null @@ -1,14 +0,0 @@ -import pytest - -from parcels._compat import add_note - - -def test_add_note_and_raise_value_error(): - with pytest.raises(ValueError) as excinfo: - try: - raise ValueError("original message") - except ValueError as e: - e = add_note(e, "additional note") - raise e - assert "additional note" in str(excinfo.value) - assert "original message" in str(excinfo.value) diff --git a/tests/test_data/README.md b/tests/test_data/README.md new file mode 100644 index 000000000..083506fb6 --- /dev/null +++ b/tests/test_data/README.md @@ -0,0 +1 @@ +Test data that was used primary in v3 (or in migrating from v3 to v4). In v4 this subpackage is superceded by the `parcels._datasets` package as well as `pooch` for fetching realistic data. diff --git a/tests/test_data/create_testfields.py b/tests/test_data/create_testfields.py deleted file mode 100644 index 52bd88d2d..000000000 --- a/tests/test_data/create_testfields.py +++ /dev/null @@ -1,132 +0,0 @@ -import math - -import numpy as np - -from parcels import FieldSet, GridType - -try: - from pympler import asizeof -except: - asizeof = None - -import os - -import xarray as xr - -try: - from parcels.tools import perlin2d as PERLIN -except: - PERLIN = None -noctaves = 4 -perlinres = (32, 8) -shapescale = (1, 1) -perlin_persistence = 0.3 -scalefac = 2.0 - - -def generate_testfieldset(xdim, ydim, zdim, tdim): - lon = np.linspace(0.0, 2.0, xdim, dtype=np.float32) - lat = np.linspace(0.0, 1.0, ydim, dtype=np.float32) - depth = np.linspace(0.0, 0.5, zdim, dtype=np.float32) - time = np.linspace(0.0, tdim, tdim, dtype=np.float64) - U = np.ones((xdim, ydim, zdim, tdim), dtype=np.float32) - V = np.zeros((xdim, ydim, zdim, tdim), dtype=np.float32) - P = 2.0 * np.ones((xdim, ydim, zdim, tdim), dtype=np.float32) - data = {"U": U, "V": V, "P": P} - dimensions = {"lon": lon, "lat": lat, "depth": depth, "time": time} - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", transpose=True) - fieldset.write("testfields") - - -def generate_perlin_testfield(): - img_shape = ( - int(math.pow(2, noctaves)) * perlinres[0] * shapescale[0], - int(math.pow(2, noctaves)) * perlinres[1] * shapescale[1], - ) - - # Coordinates of the test fieldset (on A-grid in deg) - lon = np.linspace(-180.0, 180.0, img_shape[0], dtype=np.float32) - lat = np.linspace(-90.0, 90.0, img_shape[1], dtype=np.float32) - time = np.zeros(1, dtype=np.float64) - - # Define arrays U (zonal), V (meridional), W (vertical) and P (sea - # surface height) all on A-grid - if PERLIN is not None: - U = PERLIN.generate_fractal_noise_2d(img_shape, perlinres, noctaves, perlin_persistence) * scalefac - V = PERLIN.generate_fractal_noise_2d(img_shape, perlinres, noctaves, perlin_persistence) * scalefac - else: - U = np.ones(img_shape, dtype=np.float32) * scalefac - V = np.ones(img_shape, dtype=np.float32) * scalefac - U = np.transpose(U, (1, 0)) - U = np.expand_dims(U, 0) - V = np.transpose(V, (1, 0)) - V = np.expand_dims(V, 0) - data = {"U": U, "V": V} - dimensions = {"time": time, "lon": lon, "lat": lat} - if asizeof is not None: - print(f"Perlin U-field requires {U.size * U.itemsize} bytes of memory.") - print(f"Perlin V-field requires {V.size * V.itemsize} bytes of memory.") - fieldset = FieldSet.from_data(data, dimensions, mesh="spherical", transpose=False) - # fieldset.write("perlinfields") # can also be used, but then has a ghost depth dimension - write_simple_2Dt(fieldset.U, os.path.join(os.path.dirname(__file__), "perlinfields"), varname="vozocrtx") - write_simple_2Dt(fieldset.V, os.path.join(os.path.dirname(__file__), "perlinfields"), varname="vomecrty") - - -def write_simple_2Dt(field, filename, varname=None): - """Write a :class:`Field` to a netcdf file - - Parameters - ---------- - field : parcels.field.Field - Field to write to file - filename : str - Base name of the file to write to - varname : str, optional - Name of the variable to write to file. If None, defaults to field.name - """ - filepath = str(f"{filename}{field.name}.nc") - if varname is None: - varname = field.name - - # Create DataArray objects for file I/O - if field.grid._gtype == GridType.RectilinearZGrid: - nav_lon = xr.DataArray( - field.grid.lon + np.zeros((field.grid.ydim, field.grid.xdim), dtype=np.float32), - coords=[("y", field.grid.lat), ("x", field.grid.lon)], - ) - nav_lat = xr.DataArray( - field.grid.lat.reshape(field.grid.ydim, 1) + np.zeros(field.grid.xdim, dtype=np.float32), - coords=[("y", field.grid.lat), ("x", field.grid.lon)], - ) - elif field.grid._gtype == GridType.CurvilinearZGrid: - nav_lon = xr.DataArray(field.grid.lon, coords=[("y", range(field.grid.ydim)), ("x", range(field.grid.xdim))]) - nav_lat = xr.DataArray(field.grid.lat, coords=[("y", range(field.grid.ydim)), ("x", range(field.grid.xdim))]) - else: - raise NotImplementedError("Field.write only implemented for RectilinearZGrid and CurvilinearZGrid") - - attrs = {"units": "seconds since " + str(field.grid.time_origin)} if field.grid.time_origin.calendar else {} - time_counter = xr.DataArray(field.grid.time, dims=["time_counter"], attrs=attrs) - vardata = xr.DataArray( - field.data.reshape((field.grid.tdim, field.grid.ydim, field.grid.xdim)), dims=["time_counter", "y", "x"] - ) - # Create xarray Dataset and output to netCDF format - attrs = {"parcels_mesh": field.grid.mesh} - dset = xr.Dataset( - {varname: vardata}, coords={"nav_lon": nav_lon, "nav_lat": nav_lat, "time_counter": time_counter}, attrs=attrs - ) - dset.to_netcdf(filepath) - if asizeof is not None: - mem = 0 - mem += asizeof.asizeof(field) - mem += asizeof.asizeof(field.data[:]) - mem += asizeof.asizeof(field.grid) - mem += asizeof.asizeof(vardata) - mem += asizeof.asizeof(nav_lat) - mem += asizeof.asizeof(nav_lon) - mem += asizeof.asizeof(time_counter) - print(f"Field '{field.name}' requires {mem} bytes of memory.") - - -if __name__ == "__main__": - generate_testfieldset(xdim=5, ydim=3, zdim=2, tdim=15) - generate_perlin_testfield() diff --git a/tests/test_data/fieldset_CROCO2D.py b/tests/test_data/fieldset_CROCO2D.py index 357d9b3cc..74fe2c33f 100644 --- a/tests/test_data/fieldset_CROCO2D.py +++ b/tests/test_data/fieldset_CROCO2D.py @@ -3,7 +3,7 @@ import parcels -def create_fieldset(indices=None): +def create_fieldset(): example_dataset_folder = parcels.download_example_dataset("CROCOidealized_data") file = os.path.join(example_dataset_folder, "CROCO_idealized.nc") @@ -18,7 +18,6 @@ def create_fieldset(indices=None): dimensions, allow_time_extrapolation=True, mesh="flat", - indices=indices, ) return fieldset diff --git a/tests/test_data/fieldset_CROCO3D.py b/tests/test_data/fieldset_CROCO3D.py index 68592e0ea..14fd989d0 100644 --- a/tests/test_data/fieldset_CROCO3D.py +++ b/tests/test_data/fieldset_CROCO3D.py @@ -5,7 +5,7 @@ import parcels -def create_fieldset(indices=None): +def create_fieldset(): example_dataset_folder = parcels.download_example_dataset("CROCOidealized_data") file = os.path.join(example_dataset_folder, "CROCO_idealized.nc") @@ -24,7 +24,6 @@ def create_fieldset(indices=None): dimensions, allow_time_extrapolation=True, mesh="flat", - indices=indices, hc=xr.open_dataset(file).hc.values, ) diff --git a/tests/test_data/fieldset_nemo.py b/tests/test_data/fieldset_nemo.py index e002db38a..274a854df 100644 --- a/tests/test_data/fieldset_nemo.py +++ b/tests/test_data/fieldset_nemo.py @@ -3,7 +3,7 @@ import parcels -def create_fieldset(indices=None): +def create_fieldset(): data_path = os.path.join(os.path.dirname(__file__)) filenames = { @@ -20,5 +20,4 @@ def create_fieldset(indices=None): } variables = {"U": "U", "V": "V"} dimensions = {"lon": "glamf", "lat": "gphif", "time": "time_counter"} - indices = indices or {} - return parcels.FieldSet.from_nemo(filenames, variables, dimensions, indices=indices) + return parcels.FieldSet.from_nemo(filenames, variables, dimensions) diff --git a/tests/test_data/test_interpolation_data_random_cgrid_velocity.nc b/tests/test_data/test_interpolation_data_random_cgrid_velocity.nc new file mode 100644 index 000000000..947d1d343 Binary files /dev/null and b/tests/test_data/test_interpolation_data_random_cgrid_velocity.nc differ diff --git a/tests/test_data/test_interpolation_data_random_freeslip.nc b/tests/test_data/test_interpolation_data_random_freeslip.nc new file mode 100644 index 000000000..b8746f681 Binary files /dev/null and b/tests/test_data/test_interpolation_data_random_freeslip.nc differ diff --git a/tests/test_data/test_interpolation_data_random_linear.nc b/tests/test_data/test_interpolation_data_random_linear.nc new file mode 100644 index 000000000..947d1d343 Binary files /dev/null and b/tests/test_data/test_interpolation_data_random_linear.nc differ diff --git a/tests/test_data/test_interpolation_data_random_nearest.nc b/tests/test_data/test_interpolation_data_random_nearest.nc new file mode 100644 index 000000000..947d1d343 Binary files /dev/null and b/tests/test_data/test_interpolation_data_random_nearest.nc differ diff --git a/tests/test_data/test_interpolation_jit_cgrid_velocity.zarr/.zattrs b/tests/test_data/test_interpolation_jit_cgrid_velocity.zarr/.zattrs new file mode 100644 index 000000000..b750e26cf --- /dev/null +++ b/tests/test_data/test_interpolation_jit_cgrid_velocity.zarr/.zattrs @@ -0,0 +1,8 @@ +{ + "Conventions": "CF-1.6/CF-1.7", + "feature_type": "trajectory", + "ncei_template_version": "NCEI_NetCDF_Trajectory_Template_v2.0", + "parcels_kernels": "JITParticleAdvectionRK4_3DDeleteParticle", + "parcels_mesh": "flat", + "parcels_version": "v3.1.2-12-gee4dd32a" +} diff --git a/tests/test_data/test_interpolation_jit_cgrid_velocity.zarr/.zgroup b/tests/test_data/test_interpolation_jit_cgrid_velocity.zarr/.zgroup new file mode 100644 index 000000000..3f3fad2d1 --- /dev/null +++ b/tests/test_data/test_interpolation_jit_cgrid_velocity.zarr/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/tests/test_data/test_interpolation_jit_cgrid_velocity.zarr/.zmetadata b/tests/test_data/test_interpolation_jit_cgrid_velocity.zarr/.zmetadata new file mode 100644 index 000000000..4534d4476 --- /dev/null +++ b/tests/test_data/test_interpolation_jit_cgrid_velocity.zarr/.zmetadata @@ -0,0 +1,194 @@ +{ + "metadata": { + ".zattrs": { + "Conventions": "CF-1.6/CF-1.7", + "feature_type": "trajectory", + "ncei_template_version": "NCEI_NetCDF_Trajectory_Template_v2.0", + "parcels_kernels": "JITParticleAdvectionRK4_3DDeleteParticle", + "parcels_mesh": "flat", + "parcels_version": "v3.1.2-12-gee4dd32a" + }, + ".zgroup": { + "zarr_format": 2 + }, + "lat/.zarray": { + "chunks": [ + 455, + 1 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dtype": " stats.skew(lats) + assert np.allclose(np.mean(pset.lon), 0, atol=tol) + assert np.allclose(np.mean(pset.lat), 0, atol=tol) + assert abs(stats.skew(pset.lon)) > abs(stats.skew(pset.lat)) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize("lambd", [1, 5]) -def test_randomexponential(mode, lambd): +def test_randomexponential(lambd): fieldset = create_fieldset_zeros_conversion() npart = 1000 # Rate parameter for random.expovariate - fieldset.lambd = lambd + fieldset.add_constant("lambd", lambd) # Set random seed - ParcelsRandom.seed(1234) + np.random.seed(1234) - pset = ParticleSet( - fieldset=fieldset, pclass=ptype[mode], lon=np.zeros(npart), lat=np.zeros(npart), depth=np.zeros(npart) - ) + pset = ParticleSet(fieldset=fieldset, lon=np.zeros(npart), lat=np.zeros(npart), depth=np.zeros(npart)) - def vertical_randomexponential(particle, fieldset, time): # pragma: no cover + def vertical_randomexponential(particles, fieldset): # pragma: no cover # Kernel for random exponential variable in depth direction - particle.depth = ParcelsRandom.expovariate(fieldset.lambd) + particles.depth = np.random.exponential(scale=1 / fieldset.lambd, size=len(particles)) - pset.execute(vertical_randomexponential, runtime=1, dt=1) + pset.execute(vertical_randomexponential, runtime=np.timedelta64(1, "s"), dt=np.timedelta64(1, "s")) - depth = pset.depth expected_mean = 1.0 / fieldset.lambd - assert np.allclose(np.mean(depth), expected_mean, rtol=0.1) + assert np.allclose(np.mean(pset.depth), expected_mean, rtol=0.1) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize("mu", [0.8 * np.pi, np.pi]) @pytest.mark.parametrize("kappa", [2, 4]) -def test_randomvonmises(mode, mu, kappa): +def test_randomvonmises(mu, kappa): npart = 10000 fieldset = create_fieldset_zeros_conversion() @@ -127,22 +119,20 @@ def test_randomvonmises(mode, mu, kappa): fieldset.kappa = kappa # Set random seed - ParcelsRandom.seed(1234) + np.random.seed(1234) - AngleParticle = ptype[mode].add_variable("angle") + AngleParticle = Particle.add_variable(Variable("angle")) pset = ParticleSet( fieldset=fieldset, pclass=AngleParticle, lon=np.zeros(npart), lat=np.zeros(npart), depth=np.zeros(npart) ) - def vonmises(particle, fieldset, time): # pragma: no cover - particle.angle = ParcelsRandom.vonmisesvariate(fieldset.mu, fieldset.kappa) - - pset.execute(vonmises, runtime=1, dt=1) + def vonmises(particles, fieldset): # pragma: no cover + particles.angle = np.array([random.vonmisesvariate(fieldset.mu, fieldset.kappa) for _ in range(len(particles))]) - angles = np.array([p.angle for p in pset]) + pset.execute(vonmises, runtime=np.timedelta64(1, "s"), dt=np.timedelta64(1, "s")) - assert np.allclose(np.mean(angles), mu, atol=0.1) + assert np.allclose(np.mean(pset.angle), mu, atol=0.1) vonmises_mean = stats.vonmises.mean(kappa=kappa, loc=mu) - assert np.allclose(np.mean(angles), vonmises_mean, atol=0.1) + assert np.allclose(np.mean(pset.angle), vonmises_mean, atol=0.1) vonmises_var = stats.vonmises.var(kappa=kappa, loc=mu) - assert np.allclose(np.var(angles), vonmises_var, atol=0.1) + assert np.allclose(np.var(pset.angle), vonmises_var, atol=0.1) diff --git a/tests/test_field.py b/tests/test_field.py index 106622705..fda23f479 100644 --- a/tests/test_field.py +++ b/tests/test_field.py @@ -1,70 +1,201 @@ -import cftime +from __future__ import annotations + import numpy as np import pytest +import uxarray as ux import xarray as xr -from parcels import Field -from parcels.tools.converters import ( - _get_cftime_calendars, - _get_cftime_datetimes, -) -from tests.utils import TEST_DATA +from parcels import Field, UxGrid, VectorField, XGrid +from parcels._datasets.structured.generic import T as T_structured +from parcels._datasets.structured.generic import datasets as datasets_structured +from parcels._datasets.unstructured.generic import datasets as datasets_unstructured +from parcels.interpolators import UXPiecewiseConstantFace, UXPiecewiseLinearNode + + +def test_field_init_param_types(): + data = datasets_structured["ds_2d_left"] + grid = XGrid.from_dataset(data) + with pytest.raises(ValueError, match="Expected `name` to be a string"): + Field(name=123, data=data["data_g"], grid=grid) + + with pytest.raises(ValueError, match="Expected `data` to be a uxarray.UxDataArray or xarray.DataArray"): + Field(name="test", data=123, grid=grid) + with pytest.raises(ValueError, match="Expected `grid` to be a parcels UxGrid, or parcels XGrid"): + Field(name="test", data=data["data_g"], grid=123) -def test_field_from_netcdf_variables(): - filename = str(TEST_DATA / "perlinfieldsU.nc") - dims = {"lon": "x", "lat": "y"} - variable = "vozocrtx" - f1 = Field.from_netcdf(filename, variable, dims) - variable = ("U", "vozocrtx") - f2 = Field.from_netcdf(filename, variable, dims) - variable = {"U": "vozocrtx"} - f3 = Field.from_netcdf(filename, variable, dims) +@pytest.mark.parametrize( + "data,grid", + [ + pytest.param(ux.UxDataArray(), XGrid.from_dataset(datasets_structured["ds_2d_left"]), id="uxdata-grid"), + pytest.param( + xr.DataArray(), + UxGrid( + datasets_unstructured["stommel_gyre_delaunay"].uxgrid, + z=datasets_unstructured["stommel_gyre_delaunay"].coords["nz"], + ), + id="xarray-uxgrid", + ), + ], +) +def test_field_incompatible_combination(data, grid): + with pytest.raises(ValueError, match="Incompatible data-grid combination."): + Field( + name="test_field", + data=data, + grid=grid, + ) + + +@pytest.mark.parametrize( + "data,grid", + [ + pytest.param( + datasets_structured["ds_2d_left"]["data_g"], + XGrid.from_dataset(datasets_structured["ds_2d_left"]), + id="ds_2d_left", + ), # TODO: Perhaps this test should be expanded to cover more datasets? + ], +) +def test_field_init_structured_grid(data, grid): + """Test creating a field.""" + field = Field( + name="test_field", + data=data, + grid=grid, + ) + assert field.name == "test_field" + assert field.data.equals(data) + assert field.grid == grid - assert np.allclose(f1.data, f2.data, atol=1e-12) - assert np.allclose(f1.data, f3.data, atol=1e-12) - with pytest.raises(AssertionError): - variable = {"U": "vozocrtx", "nav_lat": "nav_lat"} # multiple variables will fail - f3 = Field.from_netcdf(filename, variable, dims) +def test_field_init_fail_on_float_time_dim(): + """Test field initialisation fails when given float array as time dimension. + (users are expected to use timedelta64 or datetime). + """ + ds = datasets_structured["ds_2d_left"].copy() + ds["time"] = (ds["time"].dims, np.arange(0, T_structured, dtype="float64"), ds["time"].attrs) -@pytest.mark.parametrize("with_timestamps", [True, False]) -def test_field_from_netcdf(with_timestamps): - filenames = { - "lon": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "lat": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "data": str(TEST_DATA / "Uu_eastward_nemo_cross_180lon.nc"), - } - variable = "U" - dimensions = {"lon": "glamf", "lat": "gphif"} - if with_timestamps: - timestamp_types = [[[2]], [[np.datetime64("2000-01-01")]]] - for timestamps in timestamp_types: - Field.from_netcdf(filenames, variable, dimensions, interp_method="cgrid_velocity", timestamps=timestamps) - else: - Field.from_netcdf(filenames, variable, dimensions, interp_method="cgrid_velocity") + data = ds["data_g"] + grid = XGrid.from_dataset(ds) + with pytest.raises( + ValueError, + match="Error getting time interval.*. Are you sure that the time dimension on the xarray dataset is stored as timedelta, datetime or cftime datetime objects\?", + ): + Field( + name="test_field", + data=data, + grid=grid, + ) @pytest.mark.parametrize( - "calendar, cftime_datetime", zip(_get_cftime_calendars(), _get_cftime_datetimes(), strict=True) + "data,grid", + [ + pytest.param( + datasets_structured["ds_2d_left"]["data_g"], + XGrid.from_dataset(datasets_structured["ds_2d_left"]), + id="ds_2d_left", + ), + ], ) -def test_field_nonstandardtime(calendar, cftime_datetime, tmpdir): - xdim = 4 - ydim = 6 - filepath = tmpdir.join("test_nonstandardtime.nc") - dates = [getattr(cftime, cftime_datetime)(1, m, 1) for m in range(1, 13)] - da = xr.DataArray( - np.random.rand(12, xdim, ydim), coords=[dates, range(xdim), range(ydim)], dims=["time", "lon", "lat"], name="U" +def test_field_time_interval(data, grid): + """Test creating a field.""" + field = Field(name="test_field", data=data, grid=grid) + assert field.time_interval.left == np.datetime64("2000-01-01") + assert field.time_interval.right == np.datetime64("2001-01-01") + + +def test_vectorfield_init_different_time_intervals(): + # Tests that a VectorField raises a ValueError if the component fields have different time domains. + ... + + +def test_field_invalid_interpolator(): + ds = datasets_structured["ds_2d_left"] + grid = XGrid.from_dataset(ds) + + def invalid_interpolator_wrong_signature(self, ti, position, tau, t, z, y, invalid): + return 0.0 + + # Test invalid interpolator with wrong signature + with pytest.raises(ValueError, match=".*incorrect name.*"): + Field(name="test", data=ds["data_g"], grid=grid, interp_method=invalid_interpolator_wrong_signature) + + +def test_vectorfield_invalid_interpolator(): + ds = datasets_structured["ds_2d_left"] + grid = XGrid.from_dataset(ds) + + def invalid_interpolator_wrong_signature(self, ti, position, tau, t, z, y, applyConversion, invalid): + return 0.0 + + # Create component fields + U = Field(name="U", data=ds["data_g"], grid=grid) + V = Field(name="V", data=ds["data_g"], grid=grid) + + # Test invalid interpolator with wrong signature + with pytest.raises(ValueError, match=".*incorrect name.*"): + VectorField(name="UV", U=U, V=V, vector_interp_method=invalid_interpolator_wrong_signature) + + +def test_field_unstructured_z_linear(): + """Tests correctness of piecewise constant and piecewise linear interpolation methods on an unstructured grid with a vertical coordinate. + The example dataset is a FESOM2 square Delaunay grid with uniform z-coordinate. Cell centered and layer registered data are defined to be + linear functions of the vertical coordinate. This allows for testing of exactness of the interpolation methods. + """ + ds = datasets_unstructured["fesom2_square_delaunay_uniform_z_coordinate"].copy(deep=True) + + # Change the pressure values to be linearly dependent on the vertical coordinate + for k, z in enumerate(ds.coords["nz1"]): + ds["p"].values[:, k, :] = z + + # Change the vertical velocity values to be linearly dependent on the vertical coordinate + for k, z in enumerate(ds.coords["nz"]): + ds["W"].values[:, k, :] = z + + grid = UxGrid(ds.uxgrid, z=ds.coords["nz"]) + # Note that the vertical coordinate is required to be the position of the layer interfaces ("nz"), not the mid-layers ("nz1") + P = Field(name="p", data=ds.p, grid=grid, interp_method=UXPiecewiseConstantFace) + + # Test above first cell center - for piecewise constant, should return the depth of the first cell center + assert np.isclose(P.eval(time=ds.time[0].values, z=[10.0], y=[30.0], x=[30.0], applyConversion=False), 55.555557) + # Test below first cell center, but in the first layer - for piecewise constant, should return the depth of the first cell center + assert np.isclose(P.eval(time=ds.time[0].values, z=[65.0], y=[30.0], x=[30.0], applyConversion=False), 55.555557) + # Test bottom layer - for piecewise constant, should return the depth of the of the bottom layer cell center + assert np.isclose( + P.eval(time=ds.time[0].values, z=[900.0], y=[30.0], x=[30.0], applyConversion=False), 944.44445801 ) - da.to_netcdf(str(filepath)) - dims = {"lon": "lon", "lat": "lat", "time": "time"} - try: - field = Field.from_netcdf(filepath, "U", dims) - except NotImplementedError: - field = None + W = Field(name="W", data=ds.W, grid=grid, interp_method=UXPiecewiseLinearNode) + assert np.isclose(W.eval(time=ds.time[0].values, z=[10.0], y=[30.0], x=[30.0], applyConversion=False), 10.0) + assert np.isclose(W.eval(time=ds.time[0].values, z=[65.0], y=[30.0], x=[30.0], applyConversion=False), 65.0) + assert np.isclose(W.eval(time=ds.time[0].values, z=[900.0], y=[30.0], x=[30.0], applyConversion=False), 900.0) + + +def test_field_constant_in_time(): + """Tests field evaluation for a field with no time interval (i.e., constant in time).""" + ds = datasets_unstructured["stommel_gyre_delaunay"] + grid = UxGrid(ds.uxgrid, z=ds.coords["nz"]) + # Note that the vertical coordinate is required to be the position of the layer interfaces ("nz"), not the mid-layers ("nz1") + P = Field(name="p", data=ds.p, grid=grid, interp_method=UXPiecewiseConstantFace) + + # Assert that the field can be evaluated at any time, and returns the same value + time = np.datetime64("2000-01-01T00:00:00") + P1 = P.eval(time=time, z=[10.0], y=[30.0], x=[30.0], applyConversion=False) + P2 = P.eval(time=time + np.timedelta64(1, "D"), z=[10.0], y=[30.0], x=[30.0], applyConversion=False) + assert np.isclose(P1, P2) + + +def test_field_unstructured_grid_creation(): ... + + +def test_field_interpolation(): ... + + +def test_field_interpolation_out_of_spatial_bounds(): ... + - if field is not None: - assert field.grid.time_origin.calendar == calendar +def test_field_interpolation_out_of_time_bounds(): ... diff --git a/tests/test_fieldset.py b/tests/test_fieldset.py index adbcb757b..c96682ed0 100644 --- a/tests/test_fieldset.py +++ b/tests/test_fieldset.py @@ -1,1118 +1,272 @@ -import datetime -import gc -import os -import sys from datetime import timedelta -import dask -import dask.array as da +import cf_xarray # noqa: F401 +import cftime import numpy as np -import psutil import pytest import xarray as xr -from parcels import ( - AdvectionRK4, - AdvectionRK4_3D, - FieldSet, - JITParticle, - ParticleSet, - RectilinearZGrid, - ScipyParticle, - TimeExtrapolationError, - Variable, -) -from parcels.field import Field, VectorField -from parcels.fieldfilebuffer import DaskFileBuffer -from parcels.tools.converters import ( - GeographicPolar, - TimeConverter, - UnitConverter, -) -from tests.common_kernels import DoNothing -from tests.utils import TEST_DATA - -ptype = {"scipy": ScipyParticle, "jit": JITParticle} - - -def generate_fieldset_data(xdim, ydim, zdim=1, tdim=1): - lon = np.linspace(0.0, 10.0, xdim, dtype=np.float32) - lat = np.linspace(0.0, 10.0, ydim, dtype=np.float32) - depth = np.zeros(zdim, dtype=np.float32) - time = np.zeros(tdim, dtype=np.float64) - if zdim == 1 and tdim == 1: - U, V = np.meshgrid(lon, lat) - dimensions = {"lat": lat, "lon": lon} - else: - U = np.ones((tdim, zdim, ydim, xdim)) - V = np.ones((tdim, zdim, ydim, xdim)) - dimensions = {"lat": lat, "lon": lon, "depth": depth, "time": time} - data = {"U": np.array(U, dtype=np.float32), "V": np.array(V, dtype=np.float32)} - - return (data, dimensions) - - -@pytest.mark.parametrize("xdim", [100, 200]) -@pytest.mark.parametrize("ydim", [100, 200]) -def test_fieldset_from_data(xdim, ydim): - """Simple test for fieldset initialisation from data.""" - data, dimensions = generate_fieldset_data(xdim, ydim) - fieldset = FieldSet.from_data(data, dimensions) - assert fieldset.U._creation_log == "from_data" - assert len(fieldset.U.data.shape) == 3 - assert len(fieldset.V.data.shape) == 3 - assert np.allclose(fieldset.U.data[0, :], data["U"], rtol=1e-12) - assert np.allclose(fieldset.V.data[0, :], data["V"], rtol=1e-12) - - -def test_fieldset_extra_syntax(): - """Simple test for fieldset initialisation from data.""" - data, dimensions = generate_fieldset_data(10, 10) - - with pytest.raises(SyntaxError): - FieldSet.from_data(data, dimensions, unknown_keyword=5) - - -def test_fieldset_vmin_vmax(): - data, dimensions = generate_fieldset_data(11, 11) - fieldset = FieldSet.from_data(data, dimensions, vmin=3, vmax=7) - assert np.isclose(np.amin(fieldset.U.data[fieldset.U.data > 0.0]), 3) - assert np.isclose(np.amax(fieldset.U.data), 7) - - -@pytest.mark.parametrize("ttype", ["float", "datetime64"]) -@pytest.mark.parametrize("tdim", [1, 20]) -def test_fieldset_from_data_timedims(ttype, tdim): - data, dimensions = generate_fieldset_data(10, 10, tdim=tdim) - if ttype == "float": - dimensions["time"] = np.linspace(0, 5, tdim) - else: - dimensions["time"] = [np.datetime64("2018-01-01") + np.timedelta64(t, "D") for t in range(tdim)] - fieldset = FieldSet.from_data(data, dimensions) - for i, dtime in enumerate(dimensions["time"]): - assert fieldset.U.grid.time_origin.fulltime(fieldset.U.grid.time[i]) == dtime - - -@pytest.mark.parametrize("xdim", [100, 200]) -@pytest.mark.parametrize("ydim", [100, 50]) -def test_fieldset_from_data_different_dimensions(xdim, ydim): - """Test for fieldset initialisation from data using dict-of-dict for dimensions.""" - zdim, tdim = 4, 2 - lon = np.linspace(0.0, 1.0, xdim, dtype=np.float32) - lat = np.linspace(0.0, 1.0, ydim, dtype=np.float32) - depth = np.zeros(zdim, dtype=np.float32) - time = np.zeros(tdim, dtype=np.float64) - U = np.zeros((xdim, ydim), dtype=np.float32) - V = np.ones((xdim, ydim), dtype=np.float32) - P = 2 * np.ones((int(xdim / 2), int(ydim / 2), zdim, tdim), dtype=np.float32) - data = {"U": U, "V": V, "P": P} - dimensions = { - "U": {"lat": lat, "lon": lon}, - "V": {"lat": lat, "lon": lon}, - "P": {"lat": lat[0::2], "lon": lon[0::2], "depth": depth, "time": time}, - } - - fieldset = FieldSet.from_data(data, dimensions, transpose=True) - assert len(fieldset.U.data.shape) == 3 - assert len(fieldset.V.data.shape) == 3 - assert len(fieldset.P.data.shape) == 4 - assert fieldset.P.data.shape == (tdim, zdim, ydim / 2, xdim / 2) - assert np.allclose(fieldset.U.data, 0.0, rtol=1e-12) - assert np.allclose(fieldset.V.data, 1.0, rtol=1e-12) - assert np.allclose(fieldset.P.data, 2.0, rtol=1e-12) - - -@pytest.mark.parametrize("xdim", [100, 200]) -@pytest.mark.parametrize("ydim", [100, 200]) -def test_fieldset_from_parcels(xdim, ydim, tmpdir): - """Simple test for fieldset initialisation from Parcels FieldSet file format.""" - filepath = tmpdir.join("test_parcels") - data, dimensions = generate_fieldset_data(xdim, ydim) - fieldset_out = FieldSet.from_data(data, dimensions) - fieldset_out.write(filepath) - fieldset = FieldSet.from_parcels(filepath) - assert len(fieldset.U.data.shape) == 3 # Will be 4 once we use depth - assert len(fieldset.V.data.shape) == 3 - assert np.allclose(fieldset.U.data[0, :], data["U"], rtol=1e-12) - assert np.allclose(fieldset.V.data[0, :], data["V"], rtol=1e-12) - - -def test_fieldset_from_modulefile(): - nemo_fname = str(TEST_DATA / "fieldset_nemo.py") - nemo_error_fname = str(TEST_DATA / "fieldset_nemo_error.py") - - fieldset = FieldSet.from_modulefile(nemo_fname) - assert fieldset.U._creation_log == "from_nemo" - - indices = {"lon": range(6, 10)} - fieldset = FieldSet.from_modulefile(nemo_fname, indices=indices) - assert fieldset.U.grid.lon.shape[1] == 4 - - with pytest.raises(IOError): - FieldSet.from_modulefile(nemo_error_fname) - - FieldSet.from_modulefile(nemo_error_fname, modulename="random_function_name") - - with pytest.raises(IOError): - FieldSet.from_modulefile(nemo_error_fname, modulename="none_returning_function") - - -def test_field_from_netcdf_fieldtypes(): - filenames = { - "varU": { - "lon": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "lat": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "data": str(TEST_DATA / "Uu_eastward_nemo_cross_180lon.nc"), - }, - "varV": { - "lon": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "lat": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "data": str(TEST_DATA / "Vv_eastward_nemo_cross_180lon.nc"), - }, - } - variables = {"varU": "U", "varV": "V"} - dimensions = {"lon": "glamf", "lat": "gphif"} - - # first try without setting fieldtype - fset = FieldSet.from_nemo(filenames, variables, dimensions) - assert isinstance(fset.varU.units, UnitConverter) - - # now try with setting fieldtype - fset = FieldSet.from_nemo(filenames, variables, dimensions, fieldtype={"varU": "U", "varV": "V"}) - assert isinstance(fset.varU.units, GeographicPolar) - - -def test_fieldset_from_agrid_dataset(): - filenames = { - "lon": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "lat": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "data": str(TEST_DATA / "Uu_eastward_nemo_cross_180lon.nc"), - } - variable = {"U": "U"} - dimensions = {"lon": "glamf", "lat": "gphif"} - FieldSet.from_a_grid_dataset(filenames, variable, dimensions) - - -def test_fieldset_from_cgrid_interpmethod(): - filenames = { - "lon": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "lat": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "data": str(TEST_DATA / "Uu_eastward_nemo_cross_180lon.nc"), - } - variable = "U" - dimensions = {"lon": "glamf", "lat": "gphif"} - - with pytest.raises(TypeError): - # should fail because FieldSet.from_c_grid_dataset does not support interp_method - FieldSet.from_c_grid_dataset(filenames, variable, dimensions, interp_method="partialslip") - - -@pytest.mark.parametrize("cast_data_dtype", ["float32", "float64"]) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_fieldset_float64(cast_data_dtype, mode, tmpdir): - xdim, ydim = 10, 5 - lon = np.linspace(0.0, 10.0, xdim, dtype=np.float64) - lat = np.linspace(0.0, 10.0, ydim, dtype=np.float64) - U, V = np.meshgrid(lon, lat) - dimensions = {"lat": lat, "lon": lon} - data = {"U": np.array(U, dtype=np.float64), "V": np.array(V, dtype=np.float64)} - - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", cast_data_dtype=cast_data_dtype) - if cast_data_dtype == "float32": - assert fieldset.U.data.dtype == np.float32 - else: - assert fieldset.U.data.dtype == np.float64 - pset = ParticleSet(fieldset, ptype[mode], lon=1, lat=2) - - failed = False - try: - pset.execute(AdvectionRK4, runtime=2) - except RuntimeError: - failed = True - if mode == "jit" and cast_data_dtype == "float64": - assert failed - else: - assert np.isclose(pset[0].lon, 2.70833) - assert np.isclose(pset[0].lat, 5.41667) - filepath = tmpdir.join("test_fieldset_float64") - fieldset.U.write(filepath) - da = xr.open_dataset(str(filepath) + "U.nc") - if cast_data_dtype == "float32": - assert da["U"].dtype == np.float32 - else: - assert da["U"].dtype == np.float64 - - -@pytest.mark.parametrize("indslon", [range(10, 20), [1]]) -@pytest.mark.parametrize("indslat", [range(30, 60), [22]]) -def test_fieldset_from_file_subsets(indslon, indslat, tmpdir): - """Test for subsetting fieldset from file using indices dict.""" - data, dimensions = generate_fieldset_data(100, 100) - filepath = tmpdir.join("test_subsets") - fieldsetfull = FieldSet.from_data(data, dimensions) - fieldsetfull.write(filepath) - indices = {"lon": indslon, "lat": indslat} - indices_back = indices.copy() - fieldsetsub = FieldSet.from_parcels(filepath, indices=indices, chunksize=None) - assert indices == indices_back - assert np.allclose(fieldsetsub.U.lon, fieldsetfull.U.grid.lon[indices["lon"]]) - assert np.allclose(fieldsetsub.U.lat, fieldsetfull.U.grid.lat[indices["lat"]]) - assert np.allclose(fieldsetsub.V.lon, fieldsetfull.V.grid.lon[indices["lon"]]) - assert np.allclose(fieldsetsub.V.lat, fieldsetfull.V.grid.lat[indices["lat"]]) - - ixgrid = np.ix_([0], indices["lat"], indices["lon"]) - assert np.allclose(fieldsetsub.U.data, fieldsetfull.U.data[ixgrid]) - assert np.allclose(fieldsetsub.V.data, fieldsetfull.V.data[ixgrid]) - - -def test_empty_indices(tmpdir): - data, dimensions = generate_fieldset_data(100, 100) - filepath = tmpdir.join("test_subsets") - FieldSet.from_data(data, dimensions).write(filepath) - with pytest.raises(RuntimeError): - FieldSet.from_parcels(filepath, indices={"lon": []}) - - -@pytest.mark.parametrize("calltype", ["from_data", "from_nemo"]) -def test_illegal_dimensionsdict(calltype): - with pytest.raises(NameError): - if calltype == "from_data": - data, dimensions = generate_fieldset_data(10, 10) - dimensions["test"] = None - FieldSet.from_data(data, dimensions) - elif calltype == "from_nemo": - fname = str(TEST_DATA / "mask_nemo_cross_180lon.nc") - filenames = {"dx": fname, "mesh_mask": fname} - variables = {"dx": "e1u"} - dimensions = {"lon": "glamu", "lat": "gphiu", "test": "test"} - FieldSet.from_nemo(filenames, variables, dimensions) - - -@pytest.mark.parametrize("xdim", [100, 200]) -@pytest.mark.parametrize("ydim", [100, 200]) -def test_add_field(xdim, ydim, tmpdir): - filepath = tmpdir.join("test_add") - data, dimensions = generate_fieldset_data(xdim, ydim) - fieldset = FieldSet.from_data(data, dimensions) - field = Field("newfld", fieldset.U.data, lon=fieldset.U.lon, lat=fieldset.U.lat) - fieldset.add_field(field) - assert fieldset.newfld.data.shape == fieldset.U.data.shape - fieldset.write(filepath) +from parcels import Field, VectorField, XGrid +from parcels._core.fieldset import CalendarError, FieldSet, _datetime_to_msg +from parcels._datasets.structured.circulation_models import datasets as datasets_circulation_models +from parcels._datasets.structured.generic import T as T_structured +from parcels._datasets.structured.generic import datasets as datasets_structured +from tests import utils +ds = datasets_structured["ds_2d_left"] -@pytest.mark.parametrize("dupobject", ["same", "new"]) -def test_add_duplicate_field(dupobject): - data, dimensions = generate_fieldset_data(100, 100) - fieldset = FieldSet.from_data(data, dimensions) - field = Field("newfld", fieldset.U.data, lon=fieldset.U.lon, lat=fieldset.U.lat) - fieldset.add_field(field) - with pytest.raises(RuntimeError): - if dupobject == "same": - fieldset.add_field(field) - elif dupobject == "new": - field2 = Field("newfld", np.ones((2, 2)), lon=np.array([0, 1]), lat=np.array([0, 2])) - fieldset.add_field(field2) - - -@pytest.mark.parametrize("fieldtype", ["normal", "vector"]) -def test_add_field_after_pset(fieldtype): - data, dimensions = generate_fieldset_data(100, 100) - fieldset = FieldSet.from_data(data, dimensions) - pset = ParticleSet(fieldset, ScipyParticle, lon=0, lat=0) # noqa ; to trigger fieldset._check_complete - field1 = Field("field1", fieldset.U.data, lon=fieldset.U.lon, lat=fieldset.U.lat) - field2 = Field("field2", fieldset.U.data, lon=fieldset.U.lon, lat=fieldset.U.lat) - vfield = VectorField("vfield", field1, field2) - with pytest.raises(RuntimeError): - if fieldtype == "normal": - fieldset.add_field(field1) - elif fieldtype == "vector": - fieldset.add_vector_field(vfield) - - -@pytest.mark.parametrize("chunksize", ["auto", None]) -def test_fieldset_samegrids_from_file(tmpdir, chunksize): - """Test for subsetting fieldset from file using indices dict.""" - data, dimensions = generate_fieldset_data(100, 100) - filepath1 = tmpdir.join("test_subsets_1") - fieldset1 = FieldSet.from_data(data, dimensions) - fieldset1.write(filepath1) - - ufiles = [filepath1 + "U.nc"] * 4 - vfiles = [filepath1 + "V.nc"] * 4 - timestamps = np.arange(0, 4, 1) * 86400.0 - timestamps = np.expand_dims(timestamps, 1) - files = {"U": ufiles, "V": vfiles} - variables = {"U": "vozocrtx", "V": "vomecrty"} - dimensions = {"lon": "nav_lon", "lat": "nav_lat"} - fieldset = FieldSet.from_netcdf( - files, variables, dimensions, timestamps=timestamps, allow_time_extrapolation=True, chunksize=chunksize + +@pytest.fixture +def fieldset() -> FieldSet: + """Fixture to create a FieldSet object for testing.""" + grid = XGrid.from_dataset(ds, mesh="flat") + U = Field("U", ds["U (A grid)"], grid) + V = Field("V", ds["V (A grid)"], grid) + UV = VectorField("UV", U, V) + + return FieldSet( + [U, V, UV], ) - if chunksize == "auto": - assert fieldset.gridset.size == 2 - assert fieldset.U.grid != fieldset.V.grid - else: - assert fieldset.gridset.size == 1 - assert fieldset.U.grid == fieldset.V.grid - assert fieldset.U.chunksize == fieldset.V.chunksize - - -@pytest.mark.parametrize("gridtype", ["A", "C"]) -def test_fieldset_dimlength1_cgrid(gridtype): - fieldset = FieldSet.from_data({"U": 0, "V": 0}, {"lon": 0, "lat": 0}) - if gridtype == "C": - fieldset.U.interp_method = "cgrid_velocity" - fieldset.V.interp_method = "cgrid_velocity" - try: - fieldset._check_complete() - success = True if gridtype == "A" else False - except NotImplementedError: - success = True if gridtype == "C" else False - assert success - - -@pytest.mark.parametrize("chunksize", ["auto", None]) -def test_fieldset_diffgrids_from_file(tmpdir, chunksize): - """Test for subsetting fieldset from file using indices dict.""" - filename = "test_subsets" - data, dimensions = generate_fieldset_data(100, 100) - filepath1 = tmpdir.join(filename + "_1") - fieldset1 = FieldSet.from_data(data, dimensions) - fieldset1.write(filepath1) - data, dimensions = generate_fieldset_data(50, 50) - filepath2 = tmpdir.join(filename + "_2") - fieldset2 = FieldSet.from_data(data, dimensions) - fieldset2.write(filepath2) - - ufiles = [filepath1 + "U.nc"] * 4 - vfiles = [filepath2 + "V.nc"] * 4 - timestamps = np.arange(0, 4, 1) * 86400.0 - timestamps = np.expand_dims(timestamps, 1) - files = {"U": ufiles, "V": vfiles} - variables = {"U": "vozocrtx", "V": "vomecrty"} - dimensions = {"lon": "nav_lon", "lat": "nav_lat"} - - fieldset = FieldSet.from_netcdf( - files, variables, dimensions, timestamps=timestamps, allow_time_extrapolation=True, chunksize=chunksize + +def test_fieldset_init_wrong_types(): + with pytest.raises(ValueError, match="Expected `field` to be a Field or VectorField object. Got .*"): + FieldSet([1.0, 2.0, 3.0]) + + +def test_fieldset_add_constant(fieldset): + fieldset.add_constant("test_constant", 1.0) + assert fieldset.test_constant == 1.0 + + +def test_fieldset_add_constant_field(fieldset): + fieldset.add_constant_field("test_constant_field", 1.0) + + # Get a point in the domain + time = ds["time"].mean() + depth = ds["depth"].mean() + lat = ds["lat"].mean() + lon = ds["lon"].mean() + + pytest.xfail(reason="Not yet implemented interpolation.") + assert fieldset.test_constant_field[time, depth, lat, lon] == 1.0 + + +def test_fieldset_add_field(fieldset): + grid = XGrid.from_dataset(ds, mesh="flat") + field = Field("test_field", ds["U (A grid)"], grid) + fieldset.add_field(field) + assert fieldset.test_field == field + + +def test_fieldset_add_field_wrong_type(fieldset): + not_a_field = 1.0 + with pytest.raises(ValueError, match="Expected `field` to be a Field or VectorField object. Got .*"): + fieldset.add_field(not_a_field, "test_field") + + +def test_fieldset_add_field_already_exists(fieldset): + grid = XGrid.from_dataset(ds, mesh="flat") + field = Field("test_field", ds["U (A grid)"], grid) + fieldset.add_field(field, "test_field") + with pytest.raises(ValueError, match="FieldSet already has a Field with name 'test_field'"): + fieldset.add_field(field, "test_field") + + +def test_fieldset_gridset(fieldset): + assert fieldset.fields["U"].grid in fieldset.gridset + assert fieldset.fields["V"].grid in fieldset.gridset + assert fieldset.fields["UV"].grid in fieldset.gridset + assert len(fieldset.gridset) == 1 + + fieldset.add_constant_field("constant_field", 1.0) + assert len(fieldset.gridset) == 2 + + +@pytest.mark.parametrize("ds", [pytest.param(ds, id=k) for k, ds in datasets_structured.items()]) +def test_fieldset_from_structured_generic_datasets(ds): + grid = XGrid.from_dataset(ds, mesh="flat") + fields = [] + for var in ds.data_vars: + fields.append(Field(var, ds[var], grid)) + + fieldset = FieldSet(fields) + + assert len(fieldset.fields) == len(ds.data_vars) + for field in fieldset.fields.values(): + utils.assert_valid_field_data(field.data, field.grid) + + assert len(fieldset.gridset) == 1 + + +def test_fieldset_gridset_multiple_grids(): ... + + +def test_fieldset_time_interval(): + grid1 = XGrid.from_dataset(ds, mesh="flat") + field1 = Field("field1", ds["U (A grid)"], grid1) + + ds2 = ds.copy() + ds2["time"] = (ds2["time"].dims, ds2["time"].data + np.timedelta64(timedelta(days=1)), ds2["time"].attrs) + grid2 = XGrid.from_dataset(ds2, mesh="flat") + field2 = Field("field2", ds2["U (A grid)"], grid2) + + fieldset = FieldSet([field1, field2]) + fieldset.add_constant_field("constant_field", 1.0) + + assert fieldset.time_interval.left == np.datetime64("2000-01-02") + assert fieldset.time_interval.right == np.datetime64("2001-01-01") + + +def test_fieldset_time_interval_constant_fields(): + fieldset = FieldSet([]) + fieldset.add_constant_field("constant_field", 1.0) + fieldset.add_constant_field("constant_field2", 2.0) + + assert fieldset.time_interval is None + + +def test_fieldset_init_incompatible_calendars(): + ds1 = ds.copy() + ds1["time"] = ( + ds1["time"].dims, + xr.date_range("2000", "2001", T_structured, calendar="365_day", use_cftime=True), + ds1["time"].attrs, ) - assert fieldset.gridset.size == 2 - assert fieldset.U.grid != fieldset.V.grid - - -@pytest.mark.parametrize("chunksize", ["auto", None]) -def test_fieldset_diffgrids_from_file_data(tmpdir, chunksize): - """Test for subsetting fieldset from file using indices dict.""" - data, dimensions = generate_fieldset_data(100, 100) - filepath = tmpdir.join("test_subsets") - fieldset_data = FieldSet.from_data(data, dimensions) - fieldset_data.write(filepath) - field_data = fieldset_data.U - field_data.name = "B" - - ufiles = [filepath + "U.nc"] * 4 - vfiles = [filepath + "V.nc"] * 4 - timestamps = np.arange(0, 4, 1) * 86400.0 - timestamps = np.expand_dims(timestamps, 1) - files = {"U": ufiles, "V": vfiles} - variables = {"U": "vozocrtx", "V": "vomecrty"} - dimensions = {"lon": "nav_lon", "lat": "nav_lat"} - fieldset_file = FieldSet.from_netcdf( - files, variables, dimensions, timestamps=timestamps, allow_time_extrapolation=True, chunksize=chunksize + + grid = XGrid.from_dataset(ds1, mesh="flat") + U = Field("U", ds1["U (A grid)"], grid) + V = Field("V", ds1["V (A grid)"], grid) + UV = VectorField("UV", U, V) + + ds2 = ds.copy() + ds2["time"] = ( + ds2["time"].dims, + xr.date_range("2000", "2001", T_structured, calendar="360_day", use_cftime=True), + ds2["time"].attrs, ) + grid2 = XGrid.from_dataset(ds2, mesh="flat") + incompatible_calendar = Field("test", ds2["data_g"], grid2) + + with pytest.raises(CalendarError, match="Expected field '.*' to have calendar compatible with datetime object"): + FieldSet([U, V, UV, incompatible_calendar]) - fieldset_file.add_field(field_data, "B") - fields = [f for f in fieldset_file.get_fields() if isinstance(f, Field)] - assert len(fields) == 3 - if chunksize == "auto": - assert fieldset_file.gridset.size == 3 - else: - assert fieldset_file.gridset.size == 2 - assert fieldset_file.U.grid != fieldset_file.B.grid - - -def test_fieldset_samegrids_from_data(): - """Test for subsetting fieldset from file using indices dict.""" - data, dimensions = generate_fieldset_data(100, 100) - fieldset1 = FieldSet.from_data(data, dimensions) - field_data = fieldset1.U - field_data.name = "B" - fieldset1.add_field(field_data, "B") - assert fieldset1.gridset.size == 1 - assert fieldset1.U.grid == fieldset1.B.grid - - -@pytest.mark.parametrize("dx, dy", [("e1u", "e2u"), ("e1v", "e2v")]) -def test_fieldset_celledgesizes_curvilinear(dx, dy): - fname = str(TEST_DATA / "mask_nemo_cross_180lon.nc") - filenames = {"dx": fname, "dy": fname, "mesh_mask": fname} - variables = {"dx": dx, "dy": dy} - dimensions = {"dx": {"lon": "glamu", "lat": "gphiu"}, "dy": {"lon": "glamu", "lat": "gphiu"}} - fieldset = FieldSet.from_nemo(filenames, variables, dimensions) - - # explicitly setting cell_edge_sizes from e1u and e2u etc - fieldset.dx.grid.cell_edge_sizes["x"] = fieldset.dx.data - fieldset.dx.grid.cell_edge_sizes["y"] = fieldset.dy.data - - A = fieldset.dx.cell_areas() - assert np.allclose(A, fieldset.dx.data * fieldset.dy.data) - - -def test_fieldset_write_curvilinear(tmpdir): - fname = str(TEST_DATA / "mask_nemo_cross_180lon.nc") - filenames = {"dx": fname, "mesh_mask": fname} - variables = {"dx": "e1u"} - dimensions = {"lon": "glamu", "lat": "gphiu"} - fieldset = FieldSet.from_nemo(filenames, variables, dimensions) - assert fieldset.dx._creation_log == "from_nemo" - - newfile = tmpdir.join("curv_field") - fieldset.write(newfile) - - fieldset2 = FieldSet.from_netcdf( - filenames=newfile + "dx.nc", - variables={"dx": "dx"}, - dimensions={"time": "time_counter", "depth": "depthdx", "lon": "nav_lon", "lat": "nav_lat"}, + +def test_fieldset_add_field_incompatible_calendars(fieldset): + ds_test = ds.copy() + ds_test["time"] = ( + ds_test["time"].dims, + xr.date_range("2000", "2001", T_structured, calendar="360_day", use_cftime=True), + ds_test["time"].attrs, ) - assert fieldset2.dx._creation_log == "from_netcdf" - - for var in ["lon", "lat", "data"]: - assert np.allclose(getattr(fieldset2.dx, var), getattr(fieldset.dx, var)) - - -def test_curv_fieldset_add_periodic_halo(): - fname = str(TEST_DATA / "mask_nemo_cross_180lon.nc") - filenames = {"dx": fname, "dy": fname, "mesh_mask": fname} - variables = {"dx": "e1u", "dy": "e1v"} - dimensions = {"dx": {"lon": "glamu", "lat": "gphiu"}, "dy": {"lon": "glamu", "lat": "gphiu"}} - fieldset = FieldSet.from_nemo(filenames, variables, dimensions) - - with pytest.raises(NotImplementedError): - fieldset.add_periodic_halo(zonal=3, meridional=2) - - -@pytest.mark.parametrize("mesh", ["flat", "spherical"]) -def test_fieldset_cellareas(mesh): - data, dimensions = generate_fieldset_data(10, 7) - fieldset = FieldSet.from_data(data, dimensions, mesh=mesh) - cell_areas = fieldset.V.cell_areas() - if mesh == "flat": - assert np.allclose(cell_areas.flatten(), cell_areas[0, 0], rtol=1e-3) - else: - assert all( - (np.gradient(cell_areas, axis=0) < 0).flatten() - ) # areas should decrease with latitude in spherical mesh - for y in range(cell_areas.shape[0]): - assert np.allclose(cell_areas[y, :], cell_areas[y, 0], rtol=1e-3) - - -def addConst(particle, fieldset, time): # pragma: no cover - particle.lon = particle.lon + fieldset.movewest + fieldset.moveeast - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_fieldset_constant(mode): - data, dimensions = generate_fieldset_data(100, 100) - fieldset = FieldSet.from_data(data, dimensions) - westval = -0.2 - eastval = 0.3 - fieldset.add_constant("movewest", westval) - fieldset.add_constant("moveeast", eastval) - assert fieldset.movewest == westval - - pset = ParticleSet.from_line(fieldset, size=1, pclass=ptype[mode], start=(0.5, 0.5), finish=(0.5, 0.5)) - pset.execute(pset.Kernel(addConst), dt=1, runtime=1) - assert abs(pset.lon[0] - (0.5 + westval + eastval)) < 1e-4 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("swapUV", [False, True]) -def test_vector_fields(mode, swapUV): - lon = np.linspace(0.0, 10.0, 12, dtype=np.float32) - lat = np.linspace(0.0, 10.0, 10, dtype=np.float32) - U = np.ones((10, 12), dtype=np.float32) - V = np.zeros((10, 12), dtype=np.float32) - data = {"U": U, "V": V} - dimensions = {"U": {"lat": lat, "lon": lon}, "V": {"lat": lat, "lon": lon}} - fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - if swapUV: # we test that we can freely edit whatever UV field - UV = VectorField("UV", fieldset.V, fieldset.U) - fieldset.add_vector_field(UV) - - pset = ParticleSet.from_line(fieldset, size=1, pclass=ptype[mode], start=(0.5, 0.5), finish=(0.5, 0.5)) - pset.execute(AdvectionRK4, dt=1, runtime=2) - if swapUV: - assert abs(pset.lon[0] - 0.5) < 1e-9 - assert abs(pset.lat[0] - 1.5) < 1e-9 - else: - assert abs(pset.lon[0] - 1.5) < 1e-9 - assert abs(pset.lat[0] - 0.5) < 1e-9 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_add_second_vector_field(mode): - lon = np.linspace(0.0, 10.0, 12, dtype=np.float32) - lat = np.linspace(0.0, 10.0, 10, dtype=np.float32) - U = np.ones((10, 12), dtype=np.float32) - V = np.zeros((10, 12), dtype=np.float32) - data = {"U": U, "V": V} - dimensions = {"U": {"lat": lat, "lon": lon}, "V": {"lat": lat, "lon": lon}} - fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - - data2 = {"U2": U, "V2": V} - dimensions2 = {"lon": [ln + 0.1 for ln in lon], "lat": [lt - 0.1 for lt in lat]} - fieldset2 = FieldSet.from_data(data2, dimensions2, mesh="flat") - - UV2 = VectorField("UV2", fieldset2.U2, fieldset2.V2) - fieldset.add_vector_field(UV2) - - def SampleUV2(particle, fieldset, time): # pragma: no cover - u, v = fieldset.UV2[time, particle.depth, particle.lat, particle.lon] - particle_dlon += u * particle.dt # noqa - particle_dlat += v * particle.dt # noqa - - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=0.5, lat=0.5) - pset.execute(AdvectionRK4 + pset.Kernel(SampleUV2), dt=1, runtime=2) - - assert abs(pset.lon[0] - 2.5) < 1e-9 - assert abs(pset.lat[0] - 0.5) < 1e-9 - - -def test_fieldset_write(tmp_zarrfile): - xdim, ydim = 3, 4 - lon = np.linspace(0.0, 10.0, xdim, dtype=np.float32) - lat = np.linspace(0.0, 10.0, ydim, dtype=np.float32) - U = np.ones((ydim, xdim), dtype=np.float32) - V = np.zeros((ydim, xdim), dtype=np.float32) - data = {"U": U, "V": V} - dimensions = {"U": {"lat": lat, "lon": lon}, "V": {"lat": lat, "lon": lon}} - fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - - fieldset.U.to_write = True - - def UpdateU(particle, fieldset, time): # pragma: no cover - tmp1, tmp2 = fieldset.UV[particle] - fieldset.U.data[particle.ti, particle.yi, particle.xi] += 1 - fieldset.U.grid.time[0] = time - - pset = ParticleSet(fieldset, pclass=ScipyParticle, lon=5, lat=5) - ofile = pset.ParticleFile(name=tmp_zarrfile, outputdt=2.0) - pset.execute(UpdateU, dt=1, runtime=10, output_file=ofile) - - assert fieldset.U.data[0, 1, 0] == 11 - - da = xr.open_dataset(str(tmp_zarrfile).replace(".zarr", "_0005U.nc")) - assert np.allclose(fieldset.U.data, da["U"].values, atol=1.0) - - -@pytest.mark.flaky -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("time_periodic", [4 * 86400.0, False]) -@pytest.mark.parametrize("dt", [-3600, 3600]) -@pytest.mark.parametrize( - "chunksize", [False, "auto", {"time": ("time_counter", 1), "lat": ("y", 32), "lon": ("x", 32)}] -) -@pytest.mark.parametrize("with_GC", [False, True]) -@pytest.mark.skipif(sys.platform.startswith("win"), reason="skipping windows test as windows memory leaks (#787)") -def test_from_netcdf_memory_containment(mode, time_periodic, dt, chunksize, with_GC): - if time_periodic and dt < 0: - return # time_periodic does not work in backward-time mode - if chunksize == "auto": - dask.config.set({"array.chunk-size": "2MiB"}) - else: - dask.config.set({"array.chunk-size": "128MiB"}) - - class PerformanceLog: - samples = [] - memory_steps = [] - _iter = 0 - - def advance(self): - process = psutil.Process(os.getpid()) - self.memory_steps.append(process.memory_info().rss) - self.samples.append(self._iter) - self._iter += 1 - - def perIterGC(): - gc.collect() - - def periodicBoundaryConditions(particle, fieldset, time): # pragma: no cover - while particle.lon > 180.0: - particle_dlon -= 360.0 # noqa - while particle.lon < -180.0: - particle_dlon += 360.0 - while particle.lat > 90.0: - particle_dlat -= 180.0 # noqa - while particle.lat < -90.0: - particle_dlat += 180.0 - - process = psutil.Process(os.getpid()) - mem_0 = process.memory_info().rss - fnameU = str(TEST_DATA / "perlinfieldsU.nc") - fnameV = str(TEST_DATA / "perlinfieldsV.nc") - ufiles = [fnameU] * 4 - vfiles = [fnameV] * 4 - timestamps = np.arange(0, 4, 1) * 86400.0 - timestamps = np.expand_dims(timestamps, 1) - files = {"U": ufiles, "V": vfiles} - variables = {"U": "vozocrtx", "V": "vomecrty"} - dimensions = {"lon": "nav_lon", "lat": "nav_lat"} - - fieldset = FieldSet.from_netcdf( - files, - variables, - dimensions, - timestamps=timestamps, - time_periodic=time_periodic, - allow_time_extrapolation=True if time_periodic in [False, None] else False, - chunksize=chunksize, + grid = XGrid.from_dataset(ds_test, mesh="flat") + field = Field("test_field", ds_test["data_g"], grid) + + with pytest.raises(CalendarError, match="Expected field '.*' to have calendar compatible with datetime object"): + fieldset.add_field(field, "test_field") + + ds_test = ds.copy() + ds_test["time"] = ( + ds_test["time"].dims, + np.linspace(0, 100, T_structured, dtype="timedelta64[s]"), + ds_test["time"].attrs, ) - perflog = PerformanceLog() - postProcessFuncs = [perflog.advance] - if with_GC: - postProcessFuncs.append(perIterGC) - pset = ParticleSet(fieldset=fieldset, pclass=ptype[mode], lon=[0.5], lat=[0.5]) - mem_0 = process.memory_info().rss - mem_exhausted = False - try: - pset.execute( - pset.Kernel(AdvectionRK4) + periodicBoundaryConditions, - dt=dt, - runtime=timedelta(days=7), - postIterationCallbacks=postProcessFuncs, - callbackdt=timedelta(hours=12), - ) - except MemoryError: - mem_exhausted = True - mem_steps_np = np.array(perflog.memory_steps) - if with_GC: - assert np.allclose(mem_steps_np[8:], perflog.memory_steps[-1], rtol=0.01) - if (chunksize is not False or with_GC) and mode != "scipy": - assert np.all((mem_steps_np - mem_0) <= 5275648) # represents 4 x [U|V] * sizeof(field data) + 562816 - assert not mem_exhausted - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("time_periodic", [4 * 86400.0, False]) + grid = XGrid.from_dataset(ds_test, mesh="flat") + field = Field("test_field", ds_test["data_g"], grid) + + with pytest.raises(CalendarError, match="Expected field '.*' to have calendar compatible with datetime object"): + fieldset.add_field(field, "test_field") + + @pytest.mark.parametrize( - "chunksize", + "input_, expected", [ - False, - "auto", - {"lat": ("y", 32), "lon": ("x", 32)}, - {"time": ("time_counter", 1), "lat": ("y", 32), "lon": ("x", 32)}, + (cftime.DatetimeNoLeap(2000, 1, 1), " with cftime calendar noleap'"), + (cftime.Datetime360Day(2000, 1, 1), " with cftime calendar 360_day'"), + (cftime.DatetimeJulian(2000, 1, 1), " with cftime calendar julian'"), + ( + cftime.DatetimeGregorian(2000, 1, 1), + " with cftime calendar standard'", + ), + (np.datetime64("2000-01-01"), ""), + (cftime.datetime(2000, 1, 1), " with cftime calendar standard'"), ], ) -@pytest.mark.parametrize("deferLoad", [True, False]) -def test_from_netcdf_chunking(mode, time_periodic, chunksize, deferLoad): - fnameU = str(TEST_DATA / "perlinfieldsU.nc") - fnameV = str(TEST_DATA / "perlinfieldsV.nc") - ufiles = [fnameU] * 4 - vfiles = [fnameV] * 4 - timestamps = np.arange(0, 4, 1) * 86400.0 - timestamps = np.expand_dims(timestamps, 1) - files = {"U": ufiles, "V": vfiles} - variables = {"U": "vozocrtx", "V": "vomecrty"} - dimensions = {"lon": "nav_lon", "lat": "nav_lat"} - - fieldset = FieldSet.from_netcdf( - files, - variables, - dimensions, - timestamps=timestamps, - time_periodic=time_periodic, - deferred_load=deferLoad, - allow_time_extrapolation=True if time_periodic in [False, None] else False, - chunksize=chunksize, - ) - pset = ParticleSet.from_line(fieldset, size=1, pclass=ptype[mode], start=(0.5, 0.5), finish=(0.5, 0.5)) - pset.execute(AdvectionRK4, dt=1, runtime=1) - - -@pytest.mark.parametrize("datetype", ["float", "datetime64"]) -def test_timestamps(datetype, tmpdir): - data1, dims1 = generate_fieldset_data(10, 10, 1, 10) - data2, dims2 = generate_fieldset_data(10, 10, 1, 4) - if datetype == "float": - dims1["time"] = np.arange(0, 10, 1) * 86400 - dims2["time"] = np.arange(10, 14, 1) * 86400 - else: - dims1["time"] = np.arange("2005-02-01", "2005-02-11", dtype="datetime64[D]") - dims2["time"] = np.arange("2005-02-11", "2005-02-15", dtype="datetime64[D]") - - fieldset1 = FieldSet.from_data(data1, dims1) - fieldset1.U.data[0, :, :] = 2.0 - fieldset1.write(tmpdir.join("file1")) - - fieldset2 = FieldSet.from_data(data2, dims2) - fieldset2.U.data[0, :, :] = 0.0 - fieldset2.write(tmpdir.join("file2")) - - fieldset3 = FieldSet.from_parcels(tmpdir.join("file*"), time_periodic=timedelta(days=14)) - timestamps = [dims1["time"], dims2["time"]] - fieldset4 = FieldSet.from_parcels(tmpdir.join("file*"), timestamps=timestamps, time_periodic=timedelta(days=14)) - assert np.allclose(fieldset3.U.grid.time_full, fieldset4.U.grid.time_full) - - for d in [0, 8, 10, 13]: - fieldset3.computeTimeChunk(d * 86400.0, 1.0) - fieldset4.computeTimeChunk(d * 86400.0, 1.0) - assert np.allclose(fieldset3.U.data, fieldset4.U.data) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("use_xarray", [True, False]) -@pytest.mark.parametrize("time_periodic", [86400.0, False]) -@pytest.mark.parametrize("dt_sign", [-1, 1]) -def test_periodic(mode, use_xarray, time_periodic, dt_sign): - lon = np.array([0, 1], dtype=np.float32) - lat = np.array([0, 1], dtype=np.float32) - depth = np.array([0, 1], dtype=np.float32) - tsize = 24 * 60 + 1 - period = 86400 - time = np.linspace(0, period, tsize, dtype=np.float64) - - def temp_func(time): - return 20 + 2 * np.sin(time * 2 * np.pi / period) - - temp_vec = temp_func(time) - - U = np.zeros((2, 2, 2, tsize), dtype=np.float32) - V = np.zeros((2, 2, 2, tsize), dtype=np.float32) - V[0, 0, 0, :] = 1e-5 - W = np.zeros((2, 2, 2, tsize), dtype=np.float32) - temp = np.zeros((2, 2, 2, tsize), dtype=np.float32) - temp[:, :, :, :] = temp_vec - D = np.ones((2, 2), dtype=np.float32) # adding non-timevarying field - - full_dims = {"lon": lon, "lat": lat, "depth": depth, "time": time} - dimensions = {"U": full_dims, "V": full_dims, "W": full_dims, "temp": full_dims, "D": {"lon": lon, "lat": lat}} - if use_xarray: - coords = {"lat": lat, "lon": lon, "depth": depth, "time": time} - variables = {"U": "Uxr", "V": "Vxr", "W": "Wxr", "temp": "Txr", "D": "Dxr"} - dimnames = {"lon": "lon", "lat": "lat", "depth": "depth", "time": "time"} - ds = xr.Dataset( - { - "Uxr": xr.DataArray(U, coords=coords, dims=("lon", "lat", "depth", "time")), - "Vxr": xr.DataArray(V, coords=coords, dims=("lon", "lat", "depth", "time")), - "Wxr": xr.DataArray(W, coords=coords, dims=("lon", "lat", "depth", "time")), - "Txr": xr.DataArray(temp, coords=coords, dims=("lon", "lat", "depth", "time")), - "Dxr": xr.DataArray(D, coords={"lat": lat, "lon": lon}, dims=("lon", "lat")), - } - ) - fieldset = FieldSet.from_xarray_dataset( - ds, - variables, - {"U": dimnames, "V": dimnames, "W": dimnames, "temp": dimnames, "D": {"lon": "lon", "lat": "lat"}}, - time_periodic=time_periodic, - transpose=True, - allow_time_extrapolation=True, - ) - else: - data = {"U": U, "V": V, "W": W, "temp": temp, "D": D} - fieldset = FieldSet.from_data( - data, dimensions, mesh="flat", time_periodic=time_periodic, transpose=True, allow_time_extrapolation=True - ) - - def sampleTemp(particle, fieldset, time): # pragma: no cover - particle.temp = fieldset.temp[time, particle.depth, particle.lat, particle.lon] - # test if we can interpolate UV and UVW together - (particle.u1, particle.v1) = fieldset.UV[time, particle.depth, particle.lat, particle.lon] - (particle.u2, particle.v2, w_) = fieldset.UVW[time, particle.depth, particle.lat, particle.lon] - # test if we can sample a non-timevarying field too - particle.d = fieldset.D[0, 0, particle.lat, particle.lon] - - MyParticle = ptype[mode].add_variables( - [ - Variable("temp", dtype=np.float32, initial=20.0), - Variable("u1", dtype=np.float32, initial=0.0), - Variable("u2", dtype=np.float32, initial=0.0), - Variable("v1", dtype=np.float32, initial=0.0), - Variable("v2", dtype=np.float32, initial=0.0), - Variable("d", dtype=np.float32, initial=0.0), - ] - ) +def test_datetime_to_msg(input_, expected): + assert _datetime_to_msg(input_) == expected - pset = ParticleSet.from_list(fieldset, pclass=MyParticle, lon=[0.5], lat=[0.5], depth=[0.5]) - pset.execute( - AdvectionRK4_3D + pset.Kernel(sampleTemp), runtime=timedelta(hours=51), dt=timedelta(hours=dt_sign * 1) - ) - if time_periodic is not False: - t = pset.time[0] - temp_theo = temp_func(t) - elif dt_sign == 1: - temp_theo = temp_vec[-1] - elif dt_sign == -1: - temp_theo = temp_vec[0] - assert np.allclose(temp_theo, pset.temp[0], atol=1e-5) - assert np.allclose(pset.u1[0], pset.u2[0]) - assert np.allclose(pset.v1[0], pset.v2[0]) - assert np.allclose(pset.d[0], 1.0) - - -@pytest.mark.parametrize("fail", [False, pytest.param(True, marks=pytest.mark.xfail(strict=True))]) -def test_fieldset_defer_loading_with_diff_time_origin(tmpdir, fail): - filepath = tmpdir.join("test_parcels_defer_loading") - data0, dims0 = generate_fieldset_data(10, 10, 1, 10) - dims0["time"] = np.arange(0, 10, 1) * 3600 - fieldset_out = FieldSet.from_data(data0, dims0) - fieldset_out.U.grid._time_origin = TimeConverter(np.datetime64("2018-04-20")) - fieldset_out.V.grid._time_origin = TimeConverter(np.datetime64("2018-04-20")) - data1, dims1 = generate_fieldset_data(10, 10, 1, 10) - if fail: - dims1["time"] = np.arange(0, 10, 1) * 3600 - else: - dims1["time"] = np.arange(0, 10, 1) * 1800 + (24 + 25) * 3600 - if fail: - Wtime_origin = TimeConverter(np.datetime64("2018-04-22")) - else: - Wtime_origin = TimeConverter(np.datetime64("2018-04-18")) - gridW = RectilinearZGrid(dims1["lon"], dims1["lat"], dims1["depth"], dims1["time"], time_origin=Wtime_origin) - fieldW = Field("W", np.zeros(data1["U"].shape), grid=gridW) - fieldset_out.add_field(fieldW) - fieldset_out.write(filepath) - fieldset = FieldSet.from_parcels(filepath, extra_fields={"W": "W"}) - assert fieldset.U._creation_log == "from_parcels" - pset = ParticleSet.from_list( - fieldset, pclass=JITParticle, lon=[0.5], lat=[0.5], depth=[0.5], time=[datetime.datetime(2018, 4, 20, 1)] - ) - pset.execute(AdvectionRK4_3D, runtime=timedelta(hours=4), dt=timedelta(hours=1)) - - -@pytest.mark.parametrize("zdim", [2, 8]) -@pytest.mark.parametrize("scale_fac", [0.2, 4, 1]) -def test_fieldset_defer_loading_function(zdim, scale_fac, tmpdir): - filepath = tmpdir.join("test_parcels_defer_loading") - data0, dims0 = generate_fieldset_data(3, 3, zdim, 10) - data0["U"][:, 0, :, :] = ( - np.nan - ) # setting first layer to nan, which will be changed to zero (and all other layers to 1) - dims0["time"] = np.arange(0, 10, 1) * 3600 - dims0["depth"] = np.arange(0, zdim, 1) - fieldset_out = FieldSet.from_data(data0, dims0) - fieldset_out.write(filepath) - fieldset = FieldSet.from_parcels( - filepath, chunksize={"time": ("time_counter", 1), "depth": ("depthu", 1), "lat": ("y", 2), "lon": ("x", 2)} - ) +def test_fieldset_samegrids_UV(): + """Test that if a simple fieldset with U and V is created, that only one grid object is defined.""" + ... - # testing for combination of deferred-loaded and numpy Fields - with pytest.raises(ValueError): - fieldset.add_field(Field("numpyfield", np.zeros((10, zdim, 3, 3)), grid=fieldset.U.grid)) - - # testing for scaling factors - fieldset.U.set_scaling_factor(scale_fac) - - dz = np.gradient(fieldset.U.depth) - DZ = np.moveaxis(np.tile(dz, (fieldset.U.grid.ydim, fieldset.U.grid.xdim, 1)), [0, 1, 2], [1, 2, 0]) - - def compute(fieldset): - # Calculating vertical weighted average - f: Field - for f in [fieldset.U, fieldset.V]: - for tind in f._loaded_time_indices: - data = da.sum(f.data[tind, :] * DZ, axis=0) / sum(dz) - data = da.broadcast_to(data, (1, f.grid.zdim, f.grid.ydim, f.grid.xdim)) - f.data = f._data_concatenate(f.data, data, tind) - - fieldset.compute_on_defer = compute - fieldset.computeTimeChunk(1, 1) - assert isinstance(fieldset.U.data, da.core.Array) - assert np.allclose(fieldset.U.data, scale_fac * (zdim - 1.0) / zdim) - - pset = ParticleSet(fieldset, JITParticle, 0, 0) - - pset.execute(DoNothing, dt=3600) - assert np.allclose(fieldset.U.data, scale_fac * (zdim - 1.0) / zdim) - - -@pytest.mark.parametrize("time2", [1, 7]) -def test_fieldset_initialisation_kernel_dask(time2, tmpdir): - filepath = tmpdir.join("test_parcels_defer_loading") - data0, dims0 = generate_fieldset_data(3, 3, 4, 10) - data0["U"] = np.random.rand(10, 4, 3, 3) - dims0["time"] = np.arange(0, 10, 1) - dims0["depth"] = np.arange(0, 4, 1) - fieldset_out = FieldSet.from_data(data0, dims0) - fieldset_out.write(filepath) - fieldset = FieldSet.from_parcels( - filepath, chunksize={"time": ("time_counter", 1), "depth": ("depthu", 1), "lat": ("y", 2), "lon": ("x", 2)} - ) - def SampleField(particle, fieldset, time): # pragma: no cover - particle.u_kernel, particle.v_kernel = fieldset.UV[time, particle.depth, particle.lat, particle.lon] +def test_fieldset_grid_deduplication(): + """Tests that for a full fieldset that the number of grid objects is as expected + (sharing of grid objects so that the particle location is not duplicated). - SampleParticle = JITParticle.add_variables( - [ - Variable("u_kernel", dtype=np.float32, initial=0.0), - Variable("v_kernel", dtype=np.float32, initial=0.0), - Variable("u_scipy", dtype=np.float32, initial=0.0), - ] - ) + When grid deduplication is actually implemented, this might need to be refactored + into multiple tests (/more might be needed). + """ + ... - pset = ParticleSet( - fieldset, pclass=SampleParticle, time=[0, time2], lon=[0.5, 0.5], lat=[0.5, 0.5], depth=[0.5, 0.5] - ) - if time2 > 1: - with pytest.raises(TimeExtrapolationError): - pset.execute(SampleField, runtime=10) - else: - pset.execute(SampleField, runtime=1) - assert np.allclose([p.u_kernel for p in pset], [p.u_scipy for p in pset], atol=1e-5) - assert isinstance(fieldset.U.data, da.core.Array) - - -@pytest.mark.parametrize("tdim", [10, None]) -def test_fieldset_from_xarray(tdim): - def generate_dataset(xdim, ydim, zdim=1, tdim=1): - lon = np.linspace(0.0, 12, xdim, dtype=np.float32) - lat = np.linspace(0.0, 12, ydim, dtype=np.float32) - depth = np.linspace(0.0, 20.0, zdim, dtype=np.float32) - if tdim: - time = np.linspace(0.0, 10, tdim, dtype=np.float64) - Uxr = np.ones((tdim, zdim, ydim, xdim), dtype=np.float32) - Vxr = np.ones((tdim, zdim, ydim, xdim), dtype=np.float32) - for t in range(Uxr.shape[0]): - Uxr[t, :, :, :] = t / 10.0 - coords = {"lat": lat, "lon": lon, "depth": depth, "time": time} - dims = ("time", "depth", "lat", "lon") - else: - Uxr = np.ones((zdim, ydim, xdim), dtype=np.float32) - Vxr = np.ones((zdim, ydim, xdim), dtype=np.float32) - for z in range(Uxr.shape[0]): - Uxr[z, :, :] = z / 2.0 - coords = {"lat": lat, "lon": lon, "depth": depth} - dims = ("depth", "lat", "lon") - return xr.Dataset( - {"Uxr": xr.DataArray(Uxr, coords=coords, dims=dims), "Vxr": xr.DataArray(Vxr, coords=coords, dims=dims)} - ) - - ds = generate_dataset(3, 3, 2, tdim) - variables = {"U": "Uxr", "V": "Vxr"} - if tdim: - dimensions = {"lat": "lat", "lon": "lon", "depth": "depth", "time": "time"} - else: - dimensions = {"lat": "lat", "lon": "lon", "depth": "depth"} - fieldset = FieldSet.from_xarray_dataset(ds, variables, dimensions, mesh="flat") - assert fieldset.U._creation_log == "from_xarray_dataset" - - pset = ParticleSet(fieldset, JITParticle, 0, 0, depth=20) - - pset.execute(AdvectionRK4, dt=1, runtime=10) - if tdim == 10: - assert np.allclose(pset.lon_nextloop[0], 4.5) and np.allclose(pset.lat_nextloop[0], 10) - else: - assert np.allclose(pset.lon_nextloop[0], 5.0) and np.allclose(pset.lat_nextloop[0], 10) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_fieldset_frompop(mode): - filenames = str(TEST_DATA / "POPtestdata_time.nc") - variables = {"U": "U", "V": "V", "W": "W", "T": "T"} - dimensions = {"lon": "lon", "lat": "lat", "time": "time"} - - fieldset = FieldSet.from_pop(filenames, variables, dimensions, mesh="flat") - pset = ParticleSet.from_list(fieldset, ptype[mode], lon=[3, 5, 1], lat=[3, 5, 1]) - pset.execute(AdvectionRK4, runtime=3, dt=1) - - -def test_fieldset_from_data_gridtypes(): - """Simple test for fieldset initialisation from data.""" - xdim, ydim, zdim = 20, 10, 4 - - lon = np.linspace(0.0, 10.0, xdim, dtype=np.float32) - lat = np.linspace(0.0, 10.0, ydim, dtype=np.float32) - depth = np.linspace(0.0, 1.0, zdim, dtype=np.float32) - depth_s = np.ones((zdim, ydim, xdim)) - U = np.ones((zdim, ydim, xdim)) - V = np.ones((zdim, ydim, xdim)) - dimensions = {"lat": lat, "lon": lon, "depth": depth} - data = {"U": np.array(U, dtype=np.float32), "V": np.array(V, dtype=np.float32)} - lonm, latm = np.meshgrid(lon, lat) - for k in range(zdim): - data["U"][k, :, :] = lonm * (depth[k] + 1) + 0.1 - depth_s[k, :, :] = depth[k] - - # Rectilinear Z grid - fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - pset = ParticleSet(fieldset, ScipyParticle, [0, 0], [0, 0], [0, 0.4]) - pset.execute(AdvectionRK4, runtime=1.5, dt=0.5) - plon = pset.lon - plat = pset.lat - # sol of dx/dt = (init_depth+1)*x+0.1; x(0)=0 - assert np.allclose(plon, [0.17173462592827032, 0.2177736932123214]) - assert np.allclose(plat, [1, 1]) - - # Rectilinear S grid - dimensions["depth"] = depth_s - fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - pset = ParticleSet(fieldset, ScipyParticle, [0, 0], [0, 0], [0, 0.4]) - pset.execute(AdvectionRK4, runtime=1.5, dt=0.5) - assert np.allclose(plon, pset.lon) - assert np.allclose(plat, pset.lat) - - # Curvilinear Z grid - dimensions["lon"] = lonm - dimensions["lat"] = latm - dimensions["depth"] = depth - fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - pset = ParticleSet(fieldset, ScipyParticle, [0, 0], [0, 0], [0, 0.4]) - pset.execute(AdvectionRK4, runtime=1.5, dt=0.5) - assert np.allclose(plon, pset.lon) - assert np.allclose(plat, pset.lat) - - # Curvilinear S grid - dimensions["depth"] = depth_s - fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - pset = ParticleSet(fieldset, ScipyParticle, [0, 0], [0, 0], [0, 0.4]) - pset.execute(AdvectionRK4, runtime=1.5, dt=0.5) - assert np.allclose(plon, pset.lon) - assert np.allclose(plat, pset.lat) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("direction", [1, -1]) -@pytest.mark.parametrize("time_extrapolation", [True, False]) -def test_deferredload_simplefield(mode, direction, time_extrapolation, tmpdir): - tdim = 10 - filename = tmpdir.join("simplefield_deferredload.nc") - data = np.zeros((tdim, 2, 2)) - for ti in range(tdim): - data[ti, :, :] = ti if direction == 1 else tdim - ti - 1 - ds = xr.Dataset( - {"U": (("t", "y", "x"), data), "V": (("t", "y", "x"), data)}, - coords={"x": [0, 1], "y": [0, 1], "t": np.arange(tdim)}, - ) - ds.to_netcdf(filename) - - fieldset = FieldSet.from_netcdf( - filename, - {"U": "U", "V": "V"}, - {"lon": "x", "lat": "y", "time": "t"}, - deferred_load=True, - mesh="flat", - allow_time_extrapolation=time_extrapolation, - ) +def test_fieldset_add_field_after_pset(): + # ? Should it be allowed to add fields (normal or vector) after a ParticleSet has been initialized? + ... + + +_COPERNICUS_DATASETS = [ + datasets_circulation_models["ds_copernicusmarine"], + datasets_circulation_models["ds_copernicusmarine_waves"], +] - SamplingParticle = ptype[mode].add_variable("p") - pset = ParticleSet(fieldset, SamplingParticle, lon=0.5, lat=0.5) - - def SampleU(particle, fieldset, time): # pragma: no cover - particle.p, tmp = fieldset.UV[particle] - - runtime = tdim * 2 if time_extrapolation else None - pset.execute(SampleU, dt=direction, runtime=runtime) - assert pset.p == tdim - 1 if time_extrapolation else tdim - 2 - - -def test_daskfieldfilebuffer_dimnames(): - DaskFileBuffer.add_to_dimension_name_map_global({"lat": "nydim", "lon": "nxdim"}) - fnameU = str(TEST_DATA / "perlinfieldsU.nc") - dimensions = {"lon": "nav_lon", "lat": "nav_lat"} - fb = DaskFileBuffer(fnameU, dimensions, indices={}) - assert ("nxdim" in fb._static_name_maps["lon"]) and ("ntdim" not in fb._static_name_maps["time"]) - fb.add_to_dimension_name_map({"time": "ntdim", "depth": "nddim"}) - assert ("nxdim" in fb._static_name_maps["lon"]) and ("ntdim" in fb._static_name_maps["time"]) - assert fb._get_available_dims_indices_by_request() == {"time": None, "depth": None, "lat": 0, "lon": 1} - assert fb._get_available_dims_indices_by_namemap() == {"time": 0, "depth": 1, "lat": 2, "lon": 3} - assert fb._is_dimension_chunked("lon") is False - assert fb._is_dimension_in_chunksize_request("lon") == (-1, "", 0) + +@pytest.mark.parametrize("ds", _COPERNICUS_DATASETS) +def test_fieldset_from_copernicusmarine(ds, caplog): + fieldset = FieldSet.from_copernicusmarine(ds) + assert "U" in fieldset.fields + assert "V" in fieldset.fields + assert "UV" in fieldset.fields + assert "renamed it to 'U'" in caplog.text + assert "renamed it to 'V'" in caplog.text + + +def test_fieldset_from_copernicusmarine_no_currents(caplog): + ds = datasets_circulation_models["ds_copernicusmarine"].cf.drop_vars( + ["eastward_sea_water_velocity", "northward_sea_water_velocity"] + ) + fieldset = FieldSet.from_copernicusmarine(ds) + assert "U" not in fieldset.fields + assert "V" not in fieldset.fields + assert "UV" not in fieldset.fields + assert caplog.text == "" + + +@pytest.mark.parametrize("ds", _COPERNICUS_DATASETS) +def test_fieldset_from_copernicusmarine_no_logs(ds, caplog): + ds = ds.copy() + zeros = xr.zeros_like(list(ds.data_vars.values())[0]) + ds["U"] = zeros + ds["V"] = zeros + + fieldset = FieldSet.from_copernicusmarine(ds) + assert "U" in fieldset.fields + assert "V" in fieldset.fields + assert "UV" in fieldset.fields + assert caplog.text == "" + + +def test_fieldset_from_copernicusmarine_with_W(caplog): + ds = datasets_circulation_models["ds_copernicusmarine"] + ds = ds.copy() + ds["wo"] = ds["uo"] + ds["wo"].attrs["standard_name"] = "vertical_sea_water_velocity" + + fieldset = FieldSet.from_copernicusmarine(ds) + assert "U" in fieldset.fields + assert "V" in fieldset.fields + assert "W" in fieldset.fields + assert "UV" not in fieldset.fields + assert "UVW" in fieldset.fields + assert "renamed it to 'W'" in caplog.text diff --git a/tests/test_grids.py b/tests/test_grids.py deleted file mode 100644 index 75caa7ebf..000000000 --- a/tests/test_grids.py +++ /dev/null @@ -1,1017 +0,0 @@ -import math -from datetime import timedelta - -import numpy as np -import pytest -import xarray as xr - -from parcels import ( - AdvectionRK4, - AdvectionRK4_3D, - CurvilinearZGrid, - Field, - FieldSet, - JITParticle, - ParticleSet, - RectilinearSGrid, - RectilinearZGrid, - ScipyParticle, - StatusCode, - UnitConverter, - Variable, -) -from parcels.grid import Grid, _calc_cell_edge_sizes -from parcels.tools.converters import TimeConverter -from tests.utils import TEST_DATA - -ptype = {"scipy": ScipyParticle, "jit": JITParticle} - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_multi_structured_grids(mode): - def temp_func(lon, lat): - return 20 + lat / 1000.0 + 2 * np.sin(lon * 2 * np.pi / 5000.0) - - a = 10000 - b = 10000 - - # Grid 0 - xdim_g0 = 201 - ydim_g0 = 201 - # Coordinates of the test fieldset (on A-grid in deg) - lon_g0 = np.linspace(0, a, xdim_g0, dtype=np.float32) - lat_g0 = np.linspace(0, b, ydim_g0, dtype=np.float32) - time_g0 = np.linspace(0.0, 1000.0, 2, dtype=np.float64) - grid_0 = RectilinearZGrid(lon_g0, lat_g0, time=time_g0) - - # Grid 1 - xdim_g1 = 51 - ydim_g1 = 51 - # Coordinates of the test fieldset (on A-grid in deg) - lon_g1 = np.linspace(0, a, xdim_g1, dtype=np.float32) - lat_g1 = np.linspace(0, b, ydim_g1, dtype=np.float32) - time_g1 = np.linspace(0.0, 1000.0, 2, dtype=np.float64) - grid_1 = RectilinearZGrid(lon_g1, lat_g1, time=time_g1) - - u_data = np.ones((lon_g0.size, lat_g0.size, time_g0.size), dtype=np.float32) - u_data = 2 * u_data - u_field = Field("U", u_data, grid=grid_0, transpose=True) - - temp0_data = np.empty((lon_g0.size, lat_g0.size, time_g0.size), dtype=np.float32) - for i in range(lon_g0.size): - for j in range(lat_g0.size): - temp0_data[i, j, :] = temp_func(lon_g0[i], lat_g0[j]) - temp0_field = Field("temp0", temp0_data, grid=grid_0, transpose=True) - - v_data = np.zeros((lon_g1.size, lat_g1.size, time_g1.size), dtype=np.float32) - v_field = Field("V", v_data, grid=grid_1, transpose=True) - - temp1_data = np.empty((lon_g1.size, lat_g1.size, time_g1.size), dtype=np.float32) - for i in range(lon_g1.size): - for j in range(lat_g1.size): - temp1_data[i, j, :] = temp_func(lon_g1[i], lat_g1[j]) - temp1_field = Field("temp1", temp1_data, grid=grid_1, transpose=True) - - other_fields = {} - other_fields["temp0"] = temp0_field - other_fields["temp1"] = temp1_field - - fieldset = FieldSet(u_field, v_field, fields=other_fields) - - def sampleTemp(particle, fieldset, time): # pragma: no cover - # Note that fieldset.temp is interpolated at time=time+dt. - # Indeed, sampleTemp is called at time=time, but the result is written - # at time=time+dt, after the Kernel update - particle.temp0 = fieldset.temp0[time + particle.dt, particle.depth, particle.lat, particle.lon] - particle.temp1 = fieldset.temp1[time + particle.dt, particle.depth, particle.lat, particle.lon] - - MyParticle = ptype[mode].add_variables( - [Variable("temp0", dtype=np.float32, initial=20.0), Variable("temp1", dtype=np.float32, initial=20.0)] - ) - - pset = ParticleSet.from_list(fieldset, MyParticle, lon=[3001], lat=[5001], repeatdt=1) - - pset.execute(AdvectionRK4 + pset.Kernel(sampleTemp), runtime=3, dt=1) - - # check if particle xi and yi are different for the two grids - # assert np.all([pset.xi[i, 0] != pset.xi[i, 1] for i in range(3)]) - # assert np.all([pset.yi[i, 0] != pset.yi[i, 1] for i in range(3)]) - assert np.all([pset[i].xi[0] != pset[i].xi[1] for i in range(3)]) - assert np.all([pset[i].yi[0] != pset[i].yi[1] for i in range(3)]) - - # advect without updating temperature to test particle deletion - pset.remove_indices(np.array([1])) - pset.execute(AdvectionRK4, runtime=1, dt=1) - - assert np.all([np.isclose(p.temp0, p.temp1, atol=1e-3) for p in pset]) - - -def test_time_format_in_grid(): - lon = np.linspace(0, 1, 2, dtype=np.float32) - lat = np.linspace(0, 1, 2, dtype=np.float32) - time = np.array([np.datetime64("2000-01-01")] * 2) - with pytest.raises(AssertionError, match="Time vector"): - RectilinearZGrid(lon, lat, time=time) - - -def test_negate_depth(): - depth = np.linspace(0, 5, 10, dtype=np.float32) - fieldset = FieldSet.from_data( - {"U": np.zeros((10, 1, 1)), "V": np.zeros((10, 1, 1))}, {"lon": [0], "lat": [0], "depth": depth} - ) - assert np.all(fieldset.gridset.grids[0].depth == depth) - fieldset.U.grid.negate_depth() - assert np.all(fieldset.gridset.grids[0].depth == -depth) - - -def test_avoid_repeated_grids(): - lon_g0 = np.linspace(0, 1000, 11, dtype=np.float32) - lat_g0 = np.linspace(0, 1000, 11, dtype=np.float32) - time_g0 = np.linspace(0, 1000, 2, dtype=np.float64) - grid_0 = RectilinearZGrid(lon_g0, lat_g0, time=time_g0) - - lon_g1 = np.linspace(0, 1000, 21, dtype=np.float32) - lat_g1 = np.linspace(0, 1000, 21, dtype=np.float32) - time_g1 = np.linspace(0, 1000, 2, dtype=np.float64) - grid_1 = RectilinearZGrid(lon_g1, lat_g1, time=time_g1) - - u_data = np.zeros((lon_g0.size, lat_g0.size, time_g0.size), dtype=np.float32) - u_field = Field("U", u_data, grid=grid_0, transpose=True) - - v_data = np.zeros((lon_g1.size, lat_g1.size, time_g1.size), dtype=np.float32) - v_field = Field("V", v_data, grid=grid_1, transpose=True) - - temp0_field = Field("temp", u_data, lon=lon_g0, lat=lat_g0, time=time_g0, transpose=True) - - other_fields = {} - other_fields["temp"] = temp0_field - - fieldset = FieldSet(u_field, v_field, fields=other_fields) - assert fieldset.gridset.size == 2 - assert fieldset.U.grid is fieldset.temp.grid - assert fieldset.V.grid is not fieldset.U.grid - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_multigrids_pointer(mode): - lon_g0 = np.linspace(0, 1e4, 21, dtype=np.float32) - lat_g0 = np.linspace(0, 1000, 2, dtype=np.float32) - depth_g0 = np.zeros((5, lat_g0.size, lon_g0.size), dtype=np.float32) - - def bath_func(lon): - return lon / 1000.0 + 10 - - bath = bath_func(lon_g0) - - zdim = depth_g0.shape[0] - for i in range(lon_g0.size): - for k in range(zdim): - depth_g0[k, :, i] = bath[i] * k / (zdim - 1) - - grid_0 = RectilinearSGrid(lon_g0, lat_g0, depth=depth_g0) - grid_1 = RectilinearSGrid(lon_g0, lat_g0, depth=depth_g0) - - u_data = np.zeros((zdim, lat_g0.size, lon_g0.size), dtype=np.float32) - v_data = np.zeros((zdim, lat_g0.size, lon_g0.size), dtype=np.float32) - w_data = np.zeros((zdim, lat_g0.size, lon_g0.size), dtype=np.float32) - - u_field = Field("U", u_data, grid=grid_0) - v_field = Field("V", v_data, grid=grid_0) - w_field = Field("W", w_data, grid=grid_1) - - fieldset = FieldSet(u_field, v_field, fields={"W": w_field}) - fieldset.add_periodic_halo(zonal=3, meridional=2) # unit test of halo for SGrid - - assert u_field.grid == v_field.grid - assert u_field.grid == w_field.grid # w_field.grid is now supposed to be grid_1 - - pset = ParticleSet.from_list(fieldset, ptype[mode], lon=[0], lat=[0], depth=[1]) - - for _ in range(10): - pset.execute(AdvectionRK4_3D, runtime=1000, dt=500) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("z4d", ["True", "False"]) -def test_rectilinear_s_grid_sampling(mode, z4d): - lon_g0 = np.linspace(-3e4, 3e4, 61, dtype=np.float32) - lat_g0 = np.linspace(0, 1000, 2, dtype=np.float32) - time_g0 = np.linspace(0, 1000, 2, dtype=np.float64) - if z4d: - depth_g0 = np.zeros((time_g0.size, 5, lat_g0.size, lon_g0.size), dtype=np.float32) - else: - depth_g0 = np.zeros((5, lat_g0.size, lon_g0.size), dtype=np.float32) - - def bath_func(lon): - bath = (lon <= -2e4) * 20.0 - bath += (lon > -2e4) * (lon < 2e4) * (110.0 + 90 * np.sin(lon / 2e4 * np.pi / 2.0)) - bath += (lon >= 2e4) * 200.0 - return bath - - bath = bath_func(lon_g0) - - zdim = depth_g0.shape[-3] - for i in range(depth_g0.shape[-1]): - for k in range(zdim): - if z4d: - depth_g0[:, k, :, i] = bath[i] * k / (zdim - 1) - else: - depth_g0[k, :, i] = bath[i] * k / (zdim - 1) - - grid = RectilinearSGrid(lon_g0, lat_g0, depth=depth_g0, time=time_g0) - - u_data = np.zeros((grid.tdim, grid.zdim, grid.ydim, grid.xdim), dtype=np.float32) - v_data = np.zeros((grid.tdim, grid.zdim, grid.ydim, grid.xdim), dtype=np.float32) - temp_data = np.zeros((grid.tdim, grid.zdim, grid.ydim, grid.xdim), dtype=np.float32) - for k in range(1, zdim): - temp_data[:, k, :, :] = k / (zdim - 1.0) - u_field = Field("U", u_data, grid=grid) - v_field = Field("V", v_data, grid=grid) - temp_field = Field("temp", temp_data, grid=grid) - - other_fields = {} - other_fields["temp"] = temp_field - fieldset = FieldSet(u_field, v_field, fields=other_fields) - - def sampleTemp(particle, fieldset, time): # pragma: no cover - particle.temp = fieldset.temp[time, particle.depth, particle.lat, particle.lon] - - MyParticle = ptype[mode].add_variable("temp", dtype=np.float32, initial=20.0) - - lon = 400 - lat = 0 - ratio = 0.3 - pset = ParticleSet.from_list(fieldset, MyParticle, lon=[lon], lat=[lat], depth=[bath_func(lon) * ratio]) - - pset.execute(pset.Kernel(sampleTemp), runtime=1) - assert np.allclose(pset.temp[0], ratio, atol=1e-4) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_rectilinear_s_grids_advect1(mode): - # Constant water transport towards the east. check that the particle stays at the same relative depth (z/bath) - lon_g0 = np.linspace(0, 1e4, 21, dtype=np.float32) - lat_g0 = np.linspace(0, 1000, 2, dtype=np.float32) - depth_g0 = np.zeros((lon_g0.size, lat_g0.size, 5), dtype=np.float32) - - def bath_func(lon): - return lon / 1000.0 + 10 - - bath = bath_func(lon_g0) - - for i in range(depth_g0.shape[0]): - for k in range(depth_g0.shape[2]): - depth_g0[i, :, k] = bath[i] * k / (depth_g0.shape[2] - 1) - depth_g0 = depth_g0.transpose() # we don't change it on purpose, to check if the transpose op if fixed in jit - - grid = RectilinearSGrid(lon_g0, lat_g0, depth=depth_g0) - - zdim = depth_g0.shape[0] - u_data = np.zeros((zdim, lat_g0.size, lon_g0.size), dtype=np.float32) - v_data = np.zeros((zdim, lat_g0.size, lon_g0.size), dtype=np.float32) - w_data = np.zeros((zdim, lat_g0.size, lon_g0.size), dtype=np.float32) - for i in range(lon_g0.size): - u_data[:, :, i] = 1 * 10 / bath[i] - for k in range(zdim): - w_data[k, :, i] = u_data[k, :, i] * depth_g0[k, :, i] / bath[i] * 1e-3 - - u_field = Field("U", u_data, grid=grid) - v_field = Field("V", v_data, grid=grid) - w_field = Field("W", w_data, grid=grid) - - fieldset = FieldSet(u_field, v_field, fields={"W": w_field}) - - lon = np.zeros(11) - lat = np.zeros(11) - ratio = [min(i / 10.0, 0.99) for i in range(11)] - depth = bath_func(lon) * ratio - pset = ParticleSet.from_list(fieldset, ptype[mode], lon=lon, lat=lat, depth=depth) - - pset.execute(AdvectionRK4_3D, runtime=10000, dt=500) - assert np.allclose(pset.depth / bath_func(pset.lon), ratio) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_rectilinear_s_grids_advect2(mode): - # Move particle towards the east, check relative depth evolution - lon_g0 = np.linspace(0, 1e4, 21, dtype=np.float32) - lat_g0 = np.linspace(0, 1000, 2, dtype=np.float32) - depth_g0 = np.zeros((5, lat_g0.size, lon_g0.size), dtype=np.float32) - - def bath_func(lon): - return lon / 1000.0 + 10 - - bath = bath_func(lon_g0) - - zdim = depth_g0.shape[0] - for i in range(lon_g0.size): - for k in range(zdim): - depth_g0[k, :, i] = bath[i] * k / (zdim - 1) - - grid = RectilinearSGrid(lon_g0, lat_g0, depth=depth_g0) - - u_data = np.zeros((zdim, lat_g0.size, lon_g0.size), dtype=np.float32) - v_data = np.zeros((zdim, lat_g0.size, lon_g0.size), dtype=np.float32) - rel_depth_data = np.zeros((zdim, lat_g0.size, lon_g0.size), dtype=np.float32) - for k in range(1, zdim): - rel_depth_data[k, :, :] = k / (zdim - 1.0) - - u_field = Field("U", u_data, grid=grid) - v_field = Field("V", v_data, grid=grid) - rel_depth_field = Field("relDepth", rel_depth_data, grid=grid) - fieldset = FieldSet(u_field, v_field, fields={"relDepth": rel_depth_field}) - - MyParticle = ptype[mode].add_variable("relDepth", dtype=np.float32, initial=20.0) - - def moveEast(particle, fieldset, time): # pragma: no cover - particle_dlon += 5 * particle.dt # noqa - particle.relDepth = fieldset.relDepth[time, particle.depth, particle.lat, particle.lon] - - depth = 0.9 - pset = ParticleSet.from_list(fieldset, MyParticle, lon=[0], lat=[0], depth=[depth]) - - kernel = pset.Kernel(moveEast) - for _ in range(10): - pset.execute(kernel, runtime=100, dt=50) - assert np.allclose(pset.relDepth[0], depth / bath_func(pset.lon[0])) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_curvilinear_grids(mode): - x = np.linspace(0, 1e3, 7, dtype=np.float32) - y = np.linspace(0, 1e3, 5, dtype=np.float32) - (xx, yy) = np.meshgrid(x, y) - - r = np.sqrt(xx * xx + yy * yy) - theta = np.arctan2(yy, xx) - theta = theta + np.pi / 6.0 - - lon = r * np.cos(theta) - lat = r * np.sin(theta) - time = np.array([0, 86400], dtype=np.float64) - grid = CurvilinearZGrid(lon, lat, time=time) - - u_data = np.ones((2, y.size, x.size), dtype=np.float32) - v_data = np.zeros((2, y.size, x.size), dtype=np.float32) - u_data[0, :, :] = lon[:, :] + lat[:, :] - u_field = Field("U", u_data, grid=grid, transpose=False) - v_field = Field("V", v_data, grid=grid, transpose=False) - fieldset = FieldSet(u_field, v_field) - - def sampleSpeed(particle, fieldset, time): # pragma: no cover - u, v = fieldset.UV[time, particle.depth, particle.lat, particle.lon] - particle.speed = math.sqrt(u * u + v * v) - - MyParticle = ptype[mode].add_variable("speed", dtype=np.float32, initial=0.0) - - pset = ParticleSet.from_list(fieldset, MyParticle, lon=[400, -200], lat=[600, 600]) - pset.execute(pset.Kernel(sampleSpeed), runtime=1) - assert np.allclose(pset.speed[0], 1000) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_nemo_grid(mode): - filenames = { - "U": { - "lon": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "lat": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "data": str(TEST_DATA / "Uu_eastward_nemo_cross_180lon.nc"), - }, - "V": { - "lon": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "lat": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "data": str(TEST_DATA / "Vv_eastward_nemo_cross_180lon.nc"), - }, - } - variables = {"U": "U", "V": "V"} - dimensions = {"lon": "glamf", "lat": "gphif"} - fieldset = FieldSet.from_nemo(filenames, variables, dimensions) - - # test ParticleSet.from_field on curvilinear grids - ParticleSet.from_field(fieldset, ptype[mode], start_field=fieldset.U, size=5) - - def sampleVel(particle, fieldset, time): # pragma: no cover - (particle.zonal, particle.meridional) = fieldset.UV[time, particle.depth, particle.lat, particle.lon] - - MyParticle = ptype[mode].add_variables( - [Variable("zonal", dtype=np.float32, initial=0.0), Variable("meridional", dtype=np.float32, initial=0.0)] - ) - - lonp = 175.5 - latp = 81.5 - pset = ParticleSet.from_list(fieldset, MyParticle, lon=[lonp], lat=[latp]) - pset.execute(pset.Kernel(sampleVel), runtime=1) - u = fieldset.U.units.to_source(pset.zonal[0], 0, latp, lonp) - v = fieldset.V.units.to_source(pset.meridional[0], 0, latp, lonp) - assert abs(u - 1) < 1e-4 - assert abs(v) < 1e-4 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_advect_nemo(mode): - filenames = { - "U": { - "lon": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "lat": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "data": str(TEST_DATA / "Uu_eastward_nemo_cross_180lon.nc"), - }, - "V": { - "lon": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "lat": str(TEST_DATA / "mask_nemo_cross_180lon.nc"), - "data": str(TEST_DATA / "Vv_eastward_nemo_cross_180lon.nc"), - }, - } - variables = {"U": "U", "V": "V"} - dimensions = {"lon": "glamf", "lat": "gphif"} - fieldset = FieldSet.from_nemo(filenames, variables, dimensions) - - lonp = 175.5 - latp = 81.5 - pset = ParticleSet.from_list(fieldset, ptype[mode], lon=[lonp], lat=[latp]) - pset.execute(AdvectionRK4, runtime=timedelta(days=2), dt=timedelta(hours=6)) - assert abs(pset.lat[0] - latp) < 1e-3 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("time", [True, False]) -def test_cgrid_uniform_2dvel(mode, time): - lon = np.array([[0, 2], [0.4, 1.5]]) - lat = np.array([[0, -0.5], [0.8, 0.5]]) - U = np.array([[-99, -99], [4.4721359549995793e-01, 1.3416407864998738e00]]) - V = np.array([[-99, 1.2126781251816650e00], [-99, 1.2278812270298409e00]]) - - if time: - U = np.stack((U, U)) - V = np.stack((V, V)) - dimensions = {"lat": lat, "lon": lon, "time": np.array([0, 10])} - else: - dimensions = {"lat": lat, "lon": lon} - data = {"U": np.array(U, dtype=np.float32), "V": np.array(V, dtype=np.float32)} - fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - fieldset.U.interp_method = "cgrid_velocity" - fieldset.V.interp_method = "cgrid_velocity" - - def sampleVel(particle, fieldset, time): # pragma: no cover - (particle.zonal, particle.meridional) = fieldset.UV[time, particle.depth, particle.lat, particle.lon] - - MyParticle = ptype[mode].add_variables( - [Variable("zonal", dtype=np.float32, initial=0.0), Variable("meridional", dtype=np.float32, initial=0.0)] - ) - - pset = ParticleSet.from_list(fieldset, MyParticle, lon=0.7, lat=0.3) - pset.execute(pset.Kernel(sampleVel), runtime=1) - assert (pset[0].zonal - 1) < 1e-6 - assert (pset[0].meridional - 1) < 1e-6 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("vert_mode", ["zlev", "slev1", "slev2"]) -@pytest.mark.parametrize("time", [True, False]) -def test_cgrid_uniform_3dvel(mode, vert_mode, time): - lon = np.array([[0, 2], [0.4, 1.5]]) - lat = np.array([[0, -0.5], [0.8, 0.5]]) - - u0 = 4.4721359549995793e-01 - u1 = 1.3416407864998738e00 - v0 = 1.2126781251816650e00 - v1 = 1.2278812270298409e00 - w0 = 1 - w1 = 1 - - if vert_mode == "zlev": - depth = np.array([0, 1]) - elif vert_mode == "slev1": - depth = np.array([[[0, 0], [0, 0]], [[1, 1], [1, 1]]]) - elif vert_mode == "slev2": - depth = np.array([[[-1, -0.6], [-1.1257142857142859, -0.9]], [[1, 1.5], [0.50857142857142845, 0.8]]]) - w0 = 1.0483007922296661e00 - w1 = 1.3098951476312375e00 - - U = np.array([[[-99, -99], [u0, u1]], [[-99, -99], [-99, -99]]]) - V = np.array([[[-99, v0], [-99, v1]], [[-99, -99], [-99, -99]]]) - W = np.array([[[-99, -99], [-99, w0]], [[-99, -99], [-99, w1]]]) - - if time: - U = np.stack((U, U)) - V = np.stack((V, V)) - W = np.stack((W, W)) - dimensions = {"lat": lat, "lon": lon, "depth": depth, "time": np.array([0, 10])} - else: - dimensions = {"lat": lat, "lon": lon, "depth": depth} - data = {"U": np.array(U, dtype=np.float32), "V": np.array(V, dtype=np.float32), "W": np.array(W, dtype=np.float32)} - fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - fieldset.U.interp_method = "cgrid_velocity" - fieldset.V.interp_method = "cgrid_velocity" - fieldset.W.interp_method = "cgrid_velocity" - - def sampleVel(particle, fieldset, time): # pragma: no cover - (particle.zonal, particle.meridional, particle.vertical) = fieldset.UVW[ - time, particle.depth, particle.lat, particle.lon - ] - - MyParticle = ptype[mode].add_variables( - [ - Variable("zonal", dtype=np.float32, initial=0.0), - Variable("meridional", dtype=np.float32, initial=0.0), - Variable("vertical", dtype=np.float32, initial=0.0), - ] - ) - - pset = ParticleSet.from_list(fieldset, MyParticle, lon=0.7, lat=0.3, depth=0.2) - pset.execute(pset.Kernel(sampleVel), runtime=1) - assert abs(pset[0].zonal - 1) < 1e-6 - assert abs(pset[0].meridional - 1) < 1e-6 - assert abs(pset[0].vertical - 1) < 1e-6 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("vert_mode", ["zlev", "slev1"]) -@pytest.mark.parametrize("time", [True, False]) -def test_cgrid_uniform_3dvel_spherical(mode, vert_mode, time): - dim_file = xr.open_dataset(TEST_DATA / "mask_nemo_cross_180lon.nc") - u_file = xr.open_dataset(TEST_DATA / "Uu_eastward_nemo_cross_180lon.nc") - v_file = xr.open_dataset(TEST_DATA / "Vv_eastward_nemo_cross_180lon.nc") - j = 4 - i = 11 - lon = np.array(dim_file.glamf[0, j : j + 2, i : i + 2]) - lat = np.array(dim_file.gphif[0, j : j + 2, i : i + 2]) - U = np.array(u_file.U[0, j : j + 2, i : i + 2]) - V = np.array(v_file.V[0, j : j + 2, i : i + 2]) - trash = np.zeros((2, 2)) - U = np.stack((U, trash)) - V = np.stack((V, trash)) - w0 = 1 - w1 = 1 - W = np.array([[[-99, -99], [-99, w0]], [[-99, -99], [-99, w1]]]) - - if vert_mode == "zlev": - depth = np.array([0, 1]) - elif vert_mode == "slev1": - depth = np.array([[[0, 0], [0, 0]], [[1, 1], [1, 1]]]) - - if time: - U = np.stack((U, U)) - V = np.stack((V, V)) - W = np.stack((W, W)) - dimensions = {"lat": lat, "lon": lon, "depth": depth, "time": np.array([0, 10])} - else: - dimensions = {"lat": lat, "lon": lon, "depth": depth} - data = {"U": np.array(U, dtype=np.float32), "V": np.array(V, dtype=np.float32), "W": np.array(W, dtype=np.float32)} - fieldset = FieldSet.from_data(data, dimensions, mesh="spherical") - fieldset.U.interp_method = "cgrid_velocity" - fieldset.V.interp_method = "cgrid_velocity" - fieldset.W.interp_method = "cgrid_velocity" - - def sampleVel(particle, fieldset, time): # pragma: no cover - (particle.zonal, particle.meridional, particle.vertical) = fieldset.UVW[ - time, particle.depth, particle.lat, particle.lon - ] - - MyParticle = ptype[mode].add_variables( - [ - Variable("zonal", dtype=np.float32, initial=0.0), - Variable("meridional", dtype=np.float32, initial=0.0), - Variable("vertical", dtype=np.float32, initial=0.0), - ] - ) - - lonp = 179.8 - latp = 81.35 - pset = ParticleSet.from_list(fieldset, MyParticle, lon=lonp, lat=latp, depth=0.2) - pset.execute(pset.Kernel(sampleVel), runtime=1) - pset.zonal[0] = fieldset.U.units.to_source(pset.zonal[0], 0, latp, lonp) - pset.meridional[0] = fieldset.V.units.to_source(pset.meridional[0], 0, latp, lonp) - assert abs(pset[0].zonal - 1) < 1e-3 - assert abs(pset[0].meridional) < 1e-3 - assert abs(pset[0].vertical - 1) < 1e-3 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("vert_discretisation", ["zlevel", "slevel", "slevel2"]) -@pytest.mark.parametrize("deferred_load", [True, False]) -def test_popgrid(mode, vert_discretisation, deferred_load): - if vert_discretisation == "zlevel": - w_dep = "w_dep" - elif vert_discretisation == "slevel": - w_dep = "w_deps" # same as zlevel, but defined as slevel - elif vert_discretisation == "slevel2": - w_dep = "w_deps2" # contains shaved cells - - filenames = str(TEST_DATA / "POPtestdata_time.nc") - variables = {"U": "U", "V": "V", "W": "W", "T": "T"} - dimensions = {"lon": "lon", "lat": "lat", "depth": w_dep, "time": "time"} - - fieldset = FieldSet.from_pop(filenames, variables, dimensions, mesh="flat", deferred_load=deferred_load) - - def sampleVel(particle, fieldset, time): # pragma: no cover - (particle.zonal, particle.meridional, particle.vert) = fieldset.UVW[particle] - particle.tracer = fieldset.T[particle] - - def OutBoundsError(particle, fieldset, time): # pragma: no cover - if particle.state == StatusCode.ErrorOutOfBounds: - particle.out_of_bounds = 1 - particle_ddepth -= 3 # noqa - particle.state = StatusCode.Success - - MyParticle = ptype[mode].add_variables( - [ - Variable("zonal", dtype=np.float32, initial=0.0), - Variable("meridional", dtype=np.float32, initial=0.0), - Variable("vert", dtype=np.float32, initial=0.0), - Variable("tracer", dtype=np.float32, initial=0.0), - Variable("out_of_bounds", dtype=np.float32, initial=0.0), - ] - ) - - pset = ParticleSet.from_list(fieldset, MyParticle, lon=[3, 5, 1], lat=[3, 5, 1], depth=[3, 7, 11]) - pset.execute(pset.Kernel(sampleVel) + OutBoundsError, runtime=1) - if vert_discretisation == "slevel2": - assert np.isclose(pset.vert[0], 0.0) - assert np.isclose(pset.zonal[0], 0.0) - assert np.isclose(pset.tracer[0], 99.0) - assert np.isclose(pset.vert[1], -0.0066666666) - assert np.isclose(pset.zonal[1], 0.015) - assert np.isclose(pset.tracer[1], 1.0) - assert pset.out_of_bounds[0] == 0 - assert pset.out_of_bounds[1] == 0 - assert pset.out_of_bounds[2] == 1 - else: - assert np.allclose(pset.zonal, 0.015) - assert np.allclose(pset.meridional, 0.01) - assert np.allclose(pset.vert, -0.01) - assert np.allclose(pset.tracer, 1) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("gridindexingtype", ["mitgcm", "nemo"]) -@pytest.mark.parametrize("coordtype", ["rectilinear", "curvilinear"]) -def test_cgrid_indexing(mode, gridindexingtype, coordtype): - xdim, ydim = 151, 201 - a = b = 20000 # domain size - lon = np.linspace(-a / 2, a / 2, xdim, dtype=np.float32) - lat = np.linspace(-b / 2, b / 2, ydim, dtype=np.float32) - dx, dy = lon[2] - lon[1], lat[2] - lat[1] - omega = 2 * np.pi / timedelta(days=1).total_seconds() - - index_signs = {"nemo": -1, "mitgcm": 1} - isign = index_signs[gridindexingtype] - - def rotate_coords(lon, lat, alpha=0): - rotmat = np.array([[np.cos(alpha), np.sin(alpha)], [-np.sin(alpha), np.cos(alpha)]]) - lons, lats = np.meshgrid(lon, lat) - rotated = np.einsum("ji, mni -> jmn", rotmat, np.dstack([lons, lats])) - return rotated[0], rotated[1] - - if coordtype == "rectilinear": - alpha = 0 - elif coordtype == "curvilinear": - alpha = 15 * np.pi / 180 - lon, lat = rotate_coords(lon, lat, alpha) - - def calc_r_phi(ln, lt): - return np.sqrt(ln**2 + lt**2), np.arctan2(ln, lt) - - if coordtype == "rectilinear": - - def calculate_UVR(lat, lon, dx, dy, omega, alpha): - U = np.zeros((lat.size, lon.size), dtype=np.float32) - V = np.zeros((lat.size, lon.size), dtype=np.float32) - R = np.zeros((lat.size, lon.size), dtype=np.float32) - for i in range(lon.size): - for j in range(lat.size): - r, phi = calc_r_phi(lon[i], lat[j]) - R[j, i] = r - r, phi = calc_r_phi(lon[i] + isign * dx / 2, lat[j]) - V[j, i] = -omega * r * np.sin(phi) - r, phi = calc_r_phi(lon[i], lat[j] + isign * dy / 2) - U[j, i] = omega * r * np.cos(phi) - return U, V, R - elif coordtype == "curvilinear": - - def calculate_UVR(lat, lon, dx, dy, omega, alpha): - U = np.zeros(lat.shape, dtype=np.float32) - V = np.zeros(lat.shape, dtype=np.float32) - R = np.zeros(lat.shape, dtype=np.float32) - for i in range(lat.shape[1]): - for j in range(lat.shape[0]): - r, phi = calc_r_phi(lon[j, i], lat[j, i]) - R[j, i] = r - r, phi = calc_r_phi( - lon[j, i] + isign * (dx / 2) * np.cos(alpha), lat[j, i] - isign * (dx / 2) * np.sin(alpha) - ) - V[j, i] = np.sin(alpha) * (omega * r * np.cos(phi)) + np.cos(alpha) * (-omega * r * np.sin(phi)) - r, phi = calc_r_phi( - lon[j, i] + isign * (dy / 2) * np.sin(alpha), lat[j, i] + isign * (dy / 2) * np.cos(alpha) - ) - U[j, i] = np.cos(alpha) * (omega * r * np.cos(phi)) - np.sin(alpha) * (-omega * r * np.sin(phi)) - return U, V, R - - U, V, R = calculate_UVR(lat, lon, dx, dy, omega, alpha) - - data = {"U": U, "V": V, "R": R} - dimensions = {"lon": lon, "lat": lat} - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", gridindexingtype=gridindexingtype) - fieldset.U.interp_method = "cgrid_velocity" - fieldset.V.interp_method = "cgrid_velocity" - - def UpdateR(particle, fieldset, time): # pragma: no cover - if time == 0: - particle.radius_start = fieldset.R[time, particle.depth, particle.lat, particle.lon] - particle.radius = fieldset.R[time, particle.depth, particle.lat, particle.lon] - - MyParticle = ptype[mode].add_variables( - [Variable("radius", dtype=np.float32, initial=0.0), Variable("radius_start", dtype=np.float32, initial=0.0)] - ) - - pset = ParticleSet(fieldset, pclass=MyParticle, lon=0, lat=4e3, time=0) - - pset.execute(pset.Kernel(UpdateR) + AdvectionRK4, runtime=timedelta(hours=14), dt=timedelta(minutes=5)) - assert np.allclose(pset.radius, pset.radius_start, atol=10) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("gridindexingtype", ["mitgcm", "nemo"]) -@pytest.mark.parametrize("withtime", [False, True]) -def test_cgrid_indexing_3D(mode, gridindexingtype, withtime): - xdim = zdim = 201 - ydim = 2 - a = c = 20000 # domain size - b = 2 - lon = np.linspace(-a / 2, a / 2, xdim, dtype=np.float32) - lat = np.linspace(-b / 2, b / 2, ydim, dtype=np.float32) - depth = np.linspace(-c / 2, c / 2, zdim, dtype=np.float32) - dx, dz = lon[1] - lon[0], depth[1] - depth[0] - omega = 2 * np.pi / timedelta(days=1).total_seconds() - if withtime: - time = np.linspace(0, 24 * 60 * 60, 10) - dimensions = {"lon": lon, "lat": lat, "depth": depth, "time": time} - dsize = (time.size, depth.size, lat.size, lon.size) - else: - dimensions = {"lon": lon, "lat": lat, "depth": depth} - dsize = (depth.size, lat.size, lon.size) - - hindex_signs = {"nemo": -1, "mitgcm": 1} - hsign = hindex_signs[gridindexingtype] - - def calc_r_phi(ln, dp): - # r = np.sqrt(ln ** 2 + dp ** 2) - # phi = np.arcsin(dp/r) if r > 0 else 0 - return np.sqrt(ln**2 + dp**2), np.arctan2(ln, dp) - - def populate_UVWR(lat, lon, depth, dx, dz, omega): - U = np.zeros(dsize, dtype=np.float32) - V = np.zeros(dsize, dtype=np.float32) - W = np.zeros(dsize, dtype=np.float32) - R = np.zeros(dsize, dtype=np.float32) - - for i in range(lon.size): - for j in range(lat.size): - for k in range(depth.size): - r, phi = calc_r_phi(lon[i], depth[k]) - if withtime: - R[:, k, j, i] = r - else: - R[k, j, i] = r - r, phi = calc_r_phi(lon[i] + hsign * dx / 2, depth[k]) - if withtime: - W[:, k, j, i] = -omega * r * np.sin(phi) - else: - W[k, j, i] = -omega * r * np.sin(phi) - r, phi = calc_r_phi(lon[i], depth[k] + dz / 2) - if withtime: - U[:, k, j, i] = omega * r * np.cos(phi) - else: - U[k, j, i] = omega * r * np.cos(phi) - return U, V, W, R - - U, V, W, R = populate_UVWR(lat, lon, depth, dx, dz, omega) - data = {"U": U, "V": V, "W": W, "R": R} - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", gridindexingtype=gridindexingtype) - fieldset.U.interp_method = "cgrid_velocity" - fieldset.V.interp_method = "cgrid_velocity" - fieldset.W.interp_method = "cgrid_velocity" - - def UpdateR(particle, fieldset, time): # pragma: no cover - if time == 0: - particle.radius_start = fieldset.R[time, particle.depth, particle.lat, particle.lon] - particle.radius = fieldset.R[time, particle.depth, particle.lat, particle.lon] - - MyParticle = ptype[mode].add_variables( - [Variable("radius", dtype=np.float32, initial=0.0), Variable("radius_start", dtype=np.float32, initial=0.0)] - ) - - pset = ParticleSet(fieldset, pclass=MyParticle, depth=4e3, lon=0, lat=0, time=0) - - pset.execute(pset.Kernel(UpdateR) + AdvectionRK4_3D, runtime=timedelta(hours=14), dt=timedelta(minutes=5)) - assert np.allclose(pset.radius, pset.radius_start, atol=10) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("gridindexingtype", ["pop", "mom5"]) -@pytest.mark.parametrize("withtime", [False, True]) -def test_bgrid_indexing_3D(mode, gridindexingtype, withtime): - xdim = zdim = 201 - ydim = 2 - a = c = 20000 # domain size - b = 2 - lon = np.linspace(-a / 2, a / 2, xdim, dtype=np.float32) - lat = np.linspace(-b / 2, b / 2, ydim, dtype=np.float32) - depth = np.linspace(-c / 2, c / 2, zdim, dtype=np.float32) - dx, dz = lon[1] - lon[0], depth[1] - depth[0] - omega = 2 * np.pi / timedelta(days=1).total_seconds() - if withtime: - time = np.linspace(0, 24 * 60 * 60, 10) - dimensions = {"lon": lon, "lat": lat, "depth": depth, "time": time} - dsize = (time.size, depth.size, lat.size, lon.size) - else: - dimensions = {"lon": lon, "lat": lat, "depth": depth} - dsize = (depth.size, lat.size, lon.size) - - vindex_signs = {"pop": 1, "mom5": -1} - vsign = vindex_signs[gridindexingtype] - - def calc_r_phi(ln, dp): - return np.sqrt(ln**2 + dp**2), np.arctan2(ln, dp) - - def populate_UVWR(lat, lon, depth, dx, dz, omega): - U = np.zeros(dsize, dtype=np.float32) - V = np.zeros(dsize, dtype=np.float32) - W = np.zeros(dsize, dtype=np.float32) - R = np.zeros(dsize, dtype=np.float32) - - for i in range(lon.size): - for j in range(lat.size): - for k in range(depth.size): - r, phi = calc_r_phi(lon[i], depth[k]) - if withtime: - R[:, k, j, i] = r - else: - R[k, j, i] = r - r, phi = calc_r_phi(lon[i] - dx / 2, depth[k]) - if withtime: - W[:, k, j, i] = -omega * r * np.sin(phi) - else: - W[k, j, i] = -omega * r * np.sin(phi) - # Since Parcels loads as dimensions only the depth of W-points - # and lon/lat of UV-points, W-points are similarly interpolated - # in MOM5 and POP. Indexing is shifted for UV-points. - r, phi = calc_r_phi(lon[i], depth[k] + vsign * dz / 2) - if withtime: - U[:, k, j, i] = omega * r * np.cos(phi) - else: - U[k, j, i] = omega * r * np.cos(phi) - return U, V, W, R - - U, V, W, R = populate_UVWR(lat, lon, depth, dx, dz, omega) - data = {"U": U, "V": V, "W": W, "R": R} - fieldset = FieldSet.from_data(data, dimensions, mesh="flat", gridindexingtype=gridindexingtype) - fieldset.U.interp_method = "bgrid_velocity" - fieldset.V.interp_method = "bgrid_velocity" - fieldset.W.interp_method = "bgrid_w_velocity" - - def UpdateR(particle, fieldset, time): # pragma: no cover - if time == 0: - particle.radius_start = fieldset.R[time, particle.depth, particle.lat, particle.lon] - particle.radius = fieldset.R[time, particle.depth, particle.lat, particle.lon] - - MyParticle = ptype[mode].add_variables( - [Variable("radius", dtype=np.float32, initial=0.0), Variable("radius_start", dtype=np.float32, initial=0.0)] - ) - - pset = ParticleSet(fieldset, pclass=MyParticle, depth=-9.995e3, lon=0, lat=0, time=0) - - pset.execute(pset.Kernel(UpdateR) + AdvectionRK4_3D, runtime=timedelta(hours=14), dt=timedelta(minutes=5)) - assert np.allclose(pset.radius, pset.radius_start, atol=10) - - -@pytest.mark.parametrize("gridindexingtype", ["pop", "mom5"]) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("extrapolation", [True, False]) -def test_bgrid_interpolation(gridindexingtype, mode, extrapolation): - xi, yi = 3, 2 - if extrapolation: - zi = 0 if gridindexingtype == "mom5" else -1 - else: - zi = 2 - if gridindexingtype == "mom5": - ufile = str(TEST_DATA / "access-om2-01_u.nc") - vfile = str(TEST_DATA / "access-om2-01_v.nc") - wfile = str(TEST_DATA / "access-om2-01_wt.nc") - - filenames = { - "U": {"lon": ufile, "lat": ufile, "depth": wfile, "data": ufile}, - "V": {"lon": ufile, "lat": ufile, "depth": wfile, "data": vfile}, - "W": {"lon": ufile, "lat": ufile, "depth": wfile, "data": wfile}, - } - - variables = {"U": "u", "V": "v", "W": "wt"} - - dimensions = { - "U": {"lon": "xu_ocean", "lat": "yu_ocean", "depth": "sw_ocean", "time": "time"}, - "V": {"lon": "xu_ocean", "lat": "yu_ocean", "depth": "sw_ocean", "time": "time"}, - "W": {"lon": "xu_ocean", "lat": "yu_ocean", "depth": "sw_ocean", "time": "time"}, - } - - fieldset = FieldSet.from_mom5(filenames, variables, dimensions) - ds_u = xr.open_dataset(ufile) - ds_v = xr.open_dataset(vfile) - ds_w = xr.open_dataset(wfile) - u = ds_u.u.isel(time=0, st_ocean=zi, yu_ocean=yi, xu_ocean=xi) - v = ds_v.v.isel(time=0, st_ocean=zi, yu_ocean=yi, xu_ocean=xi) - w = ds_w.wt.isel(time=0, sw_ocean=zi, yt_ocean=yi, xt_ocean=xi) - - elif gridindexingtype == "pop": - datafname = str(TEST_DATA / "popdata.nc") - coordfname = str(TEST_DATA / "popcoordinates.nc") - filenames = { - "U": {"lon": coordfname, "lat": coordfname, "depth": coordfname, "data": datafname}, - "V": {"lon": coordfname, "lat": coordfname, "depth": coordfname, "data": datafname}, - "W": {"lon": coordfname, "lat": coordfname, "depth": coordfname, "data": datafname}, - } - - variables = {"U": "UVEL", "V": "VVEL", "W": "WVEL"} - dimensions = {"lon": "U_LON_2D", "lat": "U_LAT_2D", "depth": "w_dep"} - - fieldset = FieldSet.from_pop(filenames, variables, dimensions) - dsc = xr.open_dataset(coordfname) - dsd = xr.open_dataset(datafname) - u = dsd.UVEL.isel(k=zi, j=yi, i=xi) - v = dsd.VVEL.isel(k=zi, j=yi, i=xi) - w = dsd.WVEL.isel(k=zi, j=yi, i=xi) - - fieldset.U.units = UnitConverter() - fieldset.V.units = UnitConverter() - - def VelocityInterpolator(particle, fieldset, time): # pragma: no cover - particle.Uvel = fieldset.U[time, particle.depth, particle.lat, particle.lon] - particle.Vvel = fieldset.V[time, particle.depth, particle.lat, particle.lon] - particle.Wvel = fieldset.W[time, particle.depth, particle.lat, particle.lon] - - myParticle = ptype[mode].add_variables( - [ - Variable("Uvel", dtype=np.float32, initial=0.0), - Variable("Vvel", dtype=np.float32, initial=0.0), - Variable("Wvel", dtype=np.float32, initial=0.0), - ] - ) - - for pointtype in ["U", "V", "W"]: - if gridindexingtype == "pop": - if pointtype in ["U", "V"]: - lons = dsc.U_LON_2D[yi, xi].values - lats = dsc.U_LAT_2D[yi, xi].values - deps = dsc.depth_t[zi].values - elif pointtype == "W": - lons = dsc.T_LON_2D[yi, xi].values - lats = dsc.T_LAT_2D[yi, xi].values - deps = dsc.w_dep[zi].values - if extrapolation: - deps = 5499.0 - elif gridindexingtype == "mom5": - if pointtype in ["U", "V"]: - lons = u.xu_ocean.data.reshape(1) - lats = u.yu_ocean.data.reshape(1) - deps = u.st_ocean.data.reshape(1) - elif pointtype == "W": - lons = w.xt_ocean.data.reshape(1) - lats = w.yt_ocean.data.reshape(1) - deps = w.sw_ocean.data.reshape(1) - if extrapolation: - deps = 0 - - pset = ParticleSet.from_list(fieldset=fieldset, pclass=myParticle, lon=lons, lat=lats, depth=deps) - pset.execute(VelocityInterpolator, runtime=1) - - convfactor = 0.01 if gridindexingtype == "pop" else 1.0 - if pointtype in ["U", "V"]: - assert np.allclose(pset.Uvel[0], u * convfactor) - assert np.allclose(pset.Vvel[0], v * convfactor) - elif pointtype == "W": - if extrapolation: - assert np.allclose(pset.Wvel[0], 0, atol=1e-9) - else: - assert np.allclose(pset.Wvel[0], -w * convfactor) - - -@pytest.mark.parametrize( - "lon, lat", - [ - (np.arange(0.0, 20.0, 1.0), np.arange(0.0, 10.0, 1.0)), - ], -) -@pytest.mark.parametrize("mesh", ["flat", "spherical"]) -def test_grid_celledgesizes(lon, lat, mesh): - grid = Grid.create_grid( - lon=lon, lat=lat, depth=np.array([0]), time=np.array([0]), time_origin=TimeConverter(0), mesh=mesh - ) - - _calc_cell_edge_sizes(grid) - D_meridional = grid.cell_edge_sizes["y"] - D_zonal = grid.cell_edge_sizes["x"] - assert np.allclose( - D_meridional.flatten(), D_meridional[0, 0] - ) # all meridional distances should be the same in either mesh - if mesh == "flat": - assert np.allclose(D_zonal.flatten(), D_zonal[0, 0]) # all zonal distances should be the same in flat mesh - else: - assert all((np.gradient(D_zonal, axis=0) < 0).flatten()) # zonal distances should decrease in spherical mesh diff --git a/tests/test_index_search.py b/tests/test_index_search.py new file mode 100644 index 000000000..ef27bcd65 --- /dev/null +++ b/tests/test_index_search.py @@ -0,0 +1,82 @@ +import numpy as np +import pytest +import xarray as xr +import xgcm + +from parcels import Field, XGrid +from parcels._core.index_search import _search_indices_curvilinear_2d +from parcels._datasets.structured.generic import datasets +from parcels._tutorial import download_example_dataset + + +@pytest.fixture +def field_cone(): + ds = datasets["2d_left_unrolled_cone"] + grid = XGrid.from_dataset(ds) + field = Field( + name="test_field", + data=ds["data_g"], + grid=grid, + ) + return field + + +def test_grid_indexing_fpoints(field_cone): + grid = field_cone.grid + + for yi_expected in range(grid.ydim - 1): + for xi_expected in range(grid.xdim - 1): + x = np.array([grid.lon[yi_expected, xi_expected] + 0.00001]) + y = np.array([grid.lat[yi_expected, xi_expected] + 0.00001]) + + yi, eta, xi, xsi = _search_indices_curvilinear_2d(grid, y, x) + if eta > 0.9: + yi_expected -= 1 + if xsi > 0.9: + xi_expected -= 1 + assert yi == yi_expected, f"Expected yi {yi_expected} but got {yi}" + assert xi == xi_expected, f"Expected xi {xi_expected} but got {xi}" + + cell_lon = [ + grid.lon[yi, xi], + grid.lon[yi, xi + 1], + grid.lon[yi + 1, xi + 1], + grid.lon[yi + 1, xi], + ] + cell_lat = [ + grid.lat[yi, xi], + grid.lat[yi, xi + 1], + grid.lat[yi + 1, xi + 1], + grid.lat[yi + 1, xi], + ] + assert x > np.min(cell_lon) and x < np.max(cell_lon) + assert y > np.min(cell_lat) and y < np.max(cell_lat) + + +def test_indexing_nemo_curvilinear(): + data_folder = download_example_dataset("NemoCurvilinear_data") + ds = xr.open_mfdataset( + data_folder.glob("*.nc4"), combine="nested", data_vars="minimal", coords="minimal", compat="override" + ) + ds = ds.isel({"time_counter": 0, "time": 0, "z_a": 0}, drop=True).rename( + {"glamf": "lon", "gphif": "lat", "z": "depth"} + ) + xgcm_grid = xgcm.Grid(ds, coords={"X": {"left": "x"}, "Y": {"left": "y"}}, periodic=False, autoparse_metadata=False) + grid = XGrid(xgcm_grid, mesh="spherical") + + # Test points on the NEMO 1/4 degree curvilinear grid + lats = np.array([-30, 0, 88]) + lons = np.array([30, 60, -150]) + + yi, eta, xi, xsi = _search_indices_curvilinear_2d(grid, lats, lons) + + # Construct cornerpoints px + px = np.array([grid.lon[yi, xi], grid.lon[yi, xi + 1], grid.lon[yi + 1, xi + 1], grid.lon[yi + 1, xi]]) + + # Maximum 5 degree difference between px values + for i in range(lons.shape[0]): + np.testing.assert_allclose(px[1, i], px[:, i], atol=5) + + # Reconstruct lons values from cornerpoints + xx = (1 - xsi) * (1 - eta) * px[0] + xsi * (1 - eta) * px[1] + xsi * eta * px[2] + (1 - xsi) * eta * px[3] + np.testing.assert_allclose(xx, lons, atol=1e-6) diff --git a/tests/test_interpolation.py b/tests/test_interpolation.py index 93ae14bb3..3b9478d3c 100644 --- a/tests/test_interpolation.py +++ b/tests/test_interpolation.py @@ -2,42 +2,36 @@ import pytest import xarray as xr -import parcels._interpolation as interpolation -from parcels import AdvectionRK4_3D, FieldSet, JITParticle, ParticleSet, ScipyParticle -from tests.utils import create_fieldset_zeros_3d +from parcels import ( + Field, + FieldSet, + Particle, + ParticleFile, + ParticleSet, + StatusCode, + UxGrid, + Variable, + VectorField, + XGrid, +) +from parcels._core.index_search import _search_time_index +from parcels._datasets.structured.generated import simple_UV_dataset +from parcels._datasets.unstructured.generic import datasets as datasets_unstructured +from parcels.interpolators import ( + UXPiecewiseLinearNode, + XFreeslip, + XLinear, + XNearest, + XPartialslip, + ZeroInterpolator, +) +from parcels.kernels import AdvectionRK4_3D +from tests.utils import TEST_DATA @pytest.fixture -def tmp_interpolator_registry(): - """Resets the interpolator registry after the test. Vital when testing manipulating the registry.""" - old_2d = interpolation._interpolator_registry_2d.copy() - old_3d = interpolation._interpolator_registry_3d.copy() - yield - interpolation._interpolator_registry_2d = old_2d - interpolation._interpolator_registry_3d = old_3d - - -@pytest.mark.usefixtures("tmp_interpolator_registry") -def test_interpolation_registry(): - @interpolation.register_3d_interpolator("test") - @interpolation.register_2d_interpolator("test") - def some_function(): - return "test" - - assert "test" in interpolation.get_2d_interpolator_registry() - assert "test" in interpolation.get_3d_interpolator_registry() - - f = interpolation.get_2d_interpolator_registry()["test"] - g = interpolation.get_3d_interpolator_registry()["test"] - assert f() == g() == "test" - - -def create_interpolation_data(): - """Reference data used for testing interpolation. - - Most interpolation will be focussed around index - (depth, lat, lon) = (zi, yi, xi) = (1, 1, 1) with ti=0. - """ +def field(): + """Reference data used for testing interpolation.""" z0 = np.array( # each x is +1 from the previous, each y is +2 from the previous [ [0.0, 1.0, 2.0, 3.0], @@ -46,135 +40,190 @@ def create_interpolation_data(): [6.0, 7.0, 8.0, 9.0], ] ) - spatial_data = [z0, z0 + 3, z0 + 6, z0 + 9] # each z is +3 from the previous - return xr.DataArray([spatial_data, spatial_data, spatial_data], dims=("time", "depth", "lat", "lon")) - + spatial_data = np.array([z0, z0 + 3, z0 + 6, z0 + 9]) # each z is +3 from the previous + temporal_data = np.array([spatial_data, spatial_data + 10, spatial_data + 20]) # each t is +10 from the previous -def create_interpolation_data_random(*, with_land_point: bool) -> xr.Dataset: - tdim, zdim, ydim, xdim = 20, 5, 10, 10 ds = xr.Dataset( - { - "U": (("time", "depth", "lat", "lon"), np.random.random((tdim, zdim, ydim, xdim)) / 1e3), - "V": (("time", "depth", "lat", "lon"), np.random.random((tdim, zdim, ydim, xdim)) / 1e3), - "W": (("time", "depth", "lat", "lon"), np.random.random((tdim, zdim, ydim, xdim)) / 1e3), - }, + {"U": (["time", "depth", "lat", "lon"], temporal_data)}, coords={ - "time": np.linspace(0, tdim - 1, tdim), - "depth": np.linspace(0, 1, zdim), - "lat": np.linspace(0, 1, ydim), - "lon": np.linspace(0, 1, xdim), + "time": (["time"], [np.timedelta64(t, "s") for t in [0, 2, 4]], {"axis": "T"}), + "depth": (["depth"], [0, 1, 2, 3], {"axis": "Z"}), + "lat": (["lat"], [0, 1, 2, 3], {"axis": "Y", "c_grid_axis_shift": -0.5}), + "lon": (["lon"], [0, 1, 2, 3], {"axis": "X", "c_grid_axis_shift": -0.5}), + "x": (["x"], [0.5, 1.5, 2.5, 3.5], {"axis": "X"}), + "y": (["y"], [0.5, 1.5, 2.5, 3.5], {"axis": "Y"}), }, ) - # Set a land point (for testing freeslip) - if with_land_point: - ds["U"][:, :, 2, 5] = 0.0 - ds["V"][:, :, 2, 5] = 0.0 - ds["W"][:, :, 2, 5] = 0.0 + return Field("U", ds["U"], XGrid.from_dataset(ds)) - return ds +@pytest.mark.parametrize( + "func, t, z, y, x, expected", + [ + pytest.param(ZeroInterpolator, np.timedelta64(1, "s"), 2.5, 0.49, 0.51, 0, id="Zero"), + pytest.param( + XLinear, + [np.timedelta64(0, "s"), np.timedelta64(1, "s")], + [0, 0], + [0.49, 0.49], + [0.51, 0.51], + [1.49, 6.49], + id="Linear", + ), + pytest.param(XLinear, np.timedelta64(1, "s"), 2.5, 0.49, 0.51, 13.99, id="Linear-2"), + pytest.param( + XNearest, + [np.timedelta64(0, "s"), np.timedelta64(3, "s")], + [0.2, 0.2], + [0.2, 0.2], + [0.51, 0.51], + [1.0, 16.0], + id="Nearest", + ), + ], +) +def test_raw_2d_interpolation(field, func, t, z, y, x, expected): + """Test the interpolation functions on the Field.""" + tau, ti = _search_time_index(field, t) + position = field.grid.search(z, y, x) -@pytest.fixture -def data_2d(): - """2D slice of the reference data at depth=0.""" - return create_interpolation_data().isel(depth=0).values + value = func(field, ti, position, tau, 0, 0, y, x) + np.testing.assert_equal(value, expected) @pytest.mark.parametrize( - "func, eta, xsi, expected", + "func, t, z, y, x, expected", [ - pytest.param(interpolation._nearest_2d, 0.49, 0.49, 3.0, id="nearest_2d-1"), - pytest.param(interpolation._nearest_2d, 0.49, 0.51, 4.0, id="nearest_2d-2"), - pytest.param(interpolation._nearest_2d, 0.51, 0.49, 5.0, id="nearest_2d-3"), - pytest.param(interpolation._nearest_2d, 0.51, 0.51, 6.0, id="nearest_2d-4"), - pytest.param(interpolation._tracer_2d, None, None, 6.0, id="tracer_2d"), + (XPartialslip, np.timedelta64(1, "s"), 0, 0, 0.0, [[1], [1]]), + (XFreeslip, np.timedelta64(1, "s"), 0, 0.5, 1.5, [[1], [0.5]]), + (XPartialslip, np.timedelta64(1, "s"), 0, 2.5, 1.5, [[0.75], [0.5]]), + (XFreeslip, np.timedelta64(1, "s"), 0, 2.5, 1.5, [[1], [0.5]]), + (XPartialslip, np.timedelta64(1, "s"), 0, 1.5, 0.5, [[0.5], [0.75]]), + (XFreeslip, np.timedelta64(1, "s"), 0, 1.5, 0.5, [[0.5], [1]]), + ( + XFreeslip, + [np.timedelta64(1, "s"), np.timedelta64(0, "s")], + [0, 2], + [1.5, 1.5], + [2.5, 0.5], + [[0.5, 0.5], [1, 1]], + ), ], ) -def test_raw_2d_interpolation(data_2d, func, eta, xsi, expected): - """Test the 2D interpolation functions on the raw arrays. +def test_spatial_slip_interpolation(field, func, t, z, y, x, expected): + field.data[:] = 1.0 + field.data[:, :, 1:3, 1:3] = 0.0 # Set zero land value to test spatial slip + U = field + V = field + UV = VectorField("UV", U, V, vector_interp_method=func) - Interpolation via the other interpolation methods are tested in `test_scipy_vs_jit`. - """ - ti = 0 - yi, xi = 1, 1 - ctx = interpolation.InterpolationContext2D(data_2d, eta, xsi, ti, yi, xi) - assert func(ctx) == expected + velocities = UV[t, z, y, x] + np.testing.assert_array_almost_equal(velocities, expected) -@pytest.mark.usefixtures("tmp_interpolator_registry") -def test_interpolator_override(): - fieldset = create_fieldset_zeros_3d() +@pytest.mark.parametrize("mesh", ["spherical", "flat"]) +def test_interpolation_mesh_type(mesh, npart=10): + ds = simple_UV_dataset(mesh=mesh) + ds["U"].data[:] = 1.0 + grid = XGrid.from_dataset(ds, mesh=mesh) + U = Field("U", ds["U"], grid, interp_method=XLinear) + V = Field("V", ds["V"], grid, interp_method=XLinear) + UV = VectorField("UV", U, V) - @interpolation.register_3d_interpolator("linear") - def test_interpolator(ctx: interpolation.InterpolationContext3D): - raise NotImplementedError + lat = 30.0 + time = U.time_interval.left + u_expected = 1.0 if mesh == "flat" else 1.0 / (1852 * 60 * np.cos(np.radians(lat))) - with pytest.raises(NotImplementedError): - fieldset.U[0, 0.5, 0.5, 0.5] + assert np.isclose(U[time, 0, lat, 0], u_expected, atol=1e-7) + assert V[time, 0, lat, 0] == 0.0 + u, v = UV[time, 0, lat, 0] + assert np.isclose(u, u_expected, atol=1e-7) + assert v == 0.0 -@pytest.mark.usefixtures("tmp_interpolator_registry") -def test_full_depth_provided_to_interpolators(): - """The full depth needs to be provided to the interpolation schemes as some interpolators - need to know whether they are at the surface or bottom of the water column. + assert U.eval(time, 0, lat, 0, applyConversion=False) == 1 - https://github.com/OceanParcels/Parcels/pull/1816#discussion_r1908840408 - """ - xdim, ydim, zdim = 10, 11, 12 - fieldset = create_fieldset_zeros_3d(xdim=xdim, ydim=ydim, zdim=zdim) - @interpolation.register_3d_interpolator("linear") - def test_interpolator2(ctx: interpolation.InterpolationContext3D): - assert ctx.data.shape[1] == zdim - # The array z dimension is the same as the fieldset z dimension - return 0 +def test_default_interpolator_set_correctly(): + ds = simple_UV_dataset() + grid = XGrid.from_dataset(ds) + U = Field("U", ds["U"], grid) + assert U.interp_method == XLinear - fieldset.U[0.5, 0.5, 0.5, 0.5] + ds = datasets_unstructured["stommel_gyre_delaunay"] + grid = UxGrid(grid=ds.uxgrid, z=ds.coords["nz"]) + U = Field("U", ds["U"], grid) + assert U.interp_method == UXPiecewiseLinearNode +interp_methods = { + "linear": XLinear, +} + + +@pytest.mark.xfail(reason="ParticleFile not implemented yet") @pytest.mark.parametrize( - "interp_method", + "interp_name", [ "linear", - "freeslip", - "nearest", - "cgrid_velocity", + # "freeslip", + # "nearest", + # "cgrid_velocity", ], ) -def test_scipy_vs_jit(interp_method): - """Test that the scipy and JIT versions of the interpolation are the same.""" - variables = {"U": "U", "V": "V", "W": "W"} - dimensions = {"time": "time", "lon": "lon", "lat": "lat", "depth": "depth"} - fieldset = FieldSet.from_xarray_dataset( - create_interpolation_data_random(with_land_point=interp_method == "freeslip"), - variables, - dimensions, - mesh="flat", +def test_interp_regression_v3(interp_name): + """Test that the v4 versions of the interpolation are the same as the v3 versions.""" + ds_input = xr.open_dataset(str(TEST_DATA / f"test_interpolation_data_random_{interp_name}.nc")) + ydim = ds_input["U"].shape[2] + xdim = ds_input["U"].shape[3] + time = [np.timedelta64(int(t), "s") for t in ds_input["time"].values] + + ds = xr.Dataset( + { + "U": (["time", "depth", "YG", "XG"], ds_input["U"].values), + "V": (["time", "depth", "YG", "XG"], ds_input["V"].values), + "W": (["time", "depth", "YG", "XG"], ds_input["W"].values), + }, + coords={ + "time": (["time"], time, {"axis": "T"}), + "depth": (["depth"], ds_input["depth"].values, {"axis": "Z"}), + "YC": (["YC"], np.arange(ydim) + 0.5, {"axis": "Y"}), + "YG": (["YG"], np.arange(ydim), {"axis": "Y", "c_grid_axis_shift": -0.5}), + "XC": (["XC"], np.arange(xdim) + 0.5, {"axis": "X"}), + "XG": (["XG"], np.arange(xdim), {"axis": "X", "c_grid_axis_shift": -0.5}), + "lat": (["YG"], ds_input["lat"].values, {"axis": "Y", "c_grid_axis_shift": 0.5}), + "lon": (["XG"], ds_input["lon"].values, {"axis": "X", "c_grid_axis_shift": -0.5}), + }, ) - for field in [fieldset.U, fieldset.V, fieldset.W]: # Set a land point (for testing freeslip) - field.interp_method = interp_method + grid = XGrid.from_dataset(ds, mesh="flat") + U = Field("U", ds["U"], grid, interp_method=interp_methods[interp_name]) + V = Field("V", ds["V"], grid, interp_method=interp_methods[interp_name]) + W = Field("W", ds["W"], grid, interp_method=interp_methods[interp_name]) + fieldset = FieldSet([U, V, W, VectorField("UVW", U, V, W)]) x, y, z = np.meshgrid(np.linspace(0, 1, 7), np.linspace(0, 1, 13), np.linspace(0, 1, 5)) - TestP = ScipyParticle.add_variable("pid", dtype=np.int32, initial=0) - pset_scipy = ParticleSet(fieldset, pclass=TestP, lon=x, lat=y, depth=z, pid=np.arange(x.size)) - pset_jit = ParticleSet(fieldset, pclass=JITParticle, lon=x, lat=y, depth=z) + TestP = Particle.add_variable(Variable("pid", dtype=np.int32, initial=0)) + pset = ParticleSet(fieldset, pclass=TestP, lon=x, lat=y, depth=z, pid=np.arange(x.size)) def DeleteParticle(particle, fieldset, time): if particle.state >= 50: - particle.delete() + particle.state = StatusCode.Delete + + outfile = ParticleFile(f"test_interpolation_v4_{interp_name}", outputdt=np.timedelta64(1, "s")) + pset.execute( + [AdvectionRK4_3D, DeleteParticle], + runtime=np.timedelta64(4, "s"), + dt=np.timedelta64(1, "s"), + output_file=outfile, + ) - for pset in [pset_scipy, pset_jit]: - pset.execute([AdvectionRK4_3D, DeleteParticle], runtime=4, dt=1) + print(str(TEST_DATA / f"test_interpolation_jit_{interp_name}.zarr")) + ds_v3 = xr.open_zarr(str(TEST_DATA / f"test_interpolation_jit_{interp_name}.zarr")) + ds_v4 = xr.open_zarr(f"test_interpolation_v4_{interp_name}.zarr") tol = 1e-6 - for i in range(len(pset_scipy)): - # Check that the Scipy and JIT particles are at the same location - assert np.isclose(pset_scipy[i].lon, pset_jit[i].lon, atol=tol) - assert np.isclose(pset_scipy[i].lat, pset_jit[i].lat, atol=tol) - assert np.isclose(pset_scipy[i].depth, pset_jit[i].depth, atol=tol) - # Check that the Scipy and JIT particles have moved - assert not np.isclose(pset_scipy[i].lon, x.flatten()[pset_scipy.pid[i]], atol=tol) - assert not np.isclose(pset_scipy[i].lat, y.flatten()[pset_scipy.pid[i]], atol=tol) - assert not np.isclose(pset_scipy[i].depth, z.flatten()[pset_scipy.pid[i]], atol=tol) + np.testing.assert_allclose(ds_v3.lon, ds_v4.lon, atol=tol) + np.testing.assert_allclose(ds_v3.lat, ds_v4.lat, atol=tol) + np.testing.assert_allclose(ds_v3.z, ds_v4.z, atol=tol) diff --git a/tests/test_kernel.py b/tests/test_kernel.py new file mode 100644 index 000000000..023a1cada --- /dev/null +++ b/tests/test_kernel.py @@ -0,0 +1,127 @@ +import numpy as np +import pytest + +from parcels import ( + Field, + FieldSet, + Kernel, + Particle, + ParticleSet, + XGrid, +) +from parcels._datasets.structured.generic import datasets as datasets_structured +from parcels.kernels import AdvectionRK4 +from tests.common_kernels import MoveEast, MoveNorth + + +@pytest.fixture +def fieldset() -> FieldSet: + ds = datasets_structured["ds_2d_left"] + grid = XGrid.from_dataset(ds, mesh="flat") + U = Field("U", ds["U (A grid)"], grid) + V = Field("V", ds["V (A grid)"], grid) + return FieldSet([U, V]) + + +def test_unknown_var_in_kernel(fieldset): + pset = ParticleSet(fieldset, lon=[0.5], lat=[0.5]) + + def ErrorKernel(particles, fieldset): # pragma: no cover + particles.unknown_varname += 0.2 + + with pytest.raises(KeyError, match="'unknown_varname'"): + pset.execute(ErrorKernel, runtime=np.timedelta64(2, "s")) + + +def test_kernel_init(fieldset): + Kernel(fieldset, ptype=Particle, pyfuncs=[AdvectionRK4]) + + +def test_kernel_merging(fieldset): + k1 = Kernel(fieldset, ptype=Particle, pyfuncs=[AdvectionRK4]) + k2 = Kernel(fieldset, ptype=Particle, pyfuncs=[MoveEast, MoveNorth]) + + merged_kernel = k1 + k2 + assert merged_kernel.funcname == "AdvectionRK4MoveEastMoveNorth" + assert len(merged_kernel._pyfuncs) == 3 + assert merged_kernel._pyfuncs == [AdvectionRK4, MoveEast, MoveNorth] + + merged_kernel = k2 + k1 + assert merged_kernel.funcname == "MoveEastMoveNorthAdvectionRK4" + assert len(merged_kernel._pyfuncs) == 3 + assert merged_kernel._pyfuncs == [MoveEast, MoveNorth, AdvectionRK4] + + +def test_kernel_from_list(fieldset): + """ + Test pset.Kernel(List[function]) + + Tests that a Kernel can be created from a list functions, or a list of + mixed functions and kernel objects. + """ + pset = ParticleSet(fieldset, lon=[0.5], lat=[0.5]) + kernels_single = pset.Kernel([AdvectionRK4]) + kernels_functions = pset.Kernel([AdvectionRK4, MoveEast, MoveNorth]) + + # Check if the kernels were combined correctly + assert kernels_single.funcname == "AdvectionRK4" + assert kernels_functions.funcname == "AdvectionRK4MoveEastMoveNorth" + + +def test_kernel_from_list_error_checking(fieldset): + """ + Test pset.Kernel(List[function]) + + Tests that various error cases raise appropriate messages. + """ + pset = ParticleSet(fieldset, lon=[0.5], lat=[0.5]) + + with pytest.raises(ValueError, match="List of `pyfuncs` should have at least one function."): + pset.Kernel([]) + + with pytest.raises(ValueError, match="Argument `pyfunc_list` should be a list of functions."): + pset.Kernel([AdvectionRK4, "something else"]) + + with pytest.raises(ValueError, match="Argument `pyfunc_list` should be a list of functions."): + kernels_mixed = pset.Kernel([pset.Kernel(AdvectionRK4), MoveEast, MoveNorth]) + assert kernels_mixed.funcname == "AdvectionRK4MoveEastMoveNorth" + + +def test_kernel_signature(fieldset): + pset = ParticleSet(fieldset, lon=[0.5], lat=[0.5]) + + def good_kernel(particles, fieldset): + pass + + def version_3_kernel(particle, fieldset, time): + pass + + def version_3_kernel_without_time(particle, fieldset): + pass + + def kernel_switched_args(fieldset, particle): + pass + + def kernel_with_forced_kwarg(particles, *, fieldset=0): + pass + + pset.Kernel(good_kernel) + + with pytest.raises(ValueError, match="Kernel function must have 2 parameters, got 3"): + pset.Kernel(version_3_kernel) + + with pytest.raises( + ValueError, match="Parameter 'particle' has incorrect name. Expected 'particles', got 'particle'" + ): + pset.Kernel(version_3_kernel_without_time) + + with pytest.raises( + ValueError, match="Parameter 'fieldset' has incorrect name. Expected 'particles', got 'fieldset'" + ): + pset.Kernel(kernel_switched_args) + + with pytest.raises( + ValueError, + match="Parameter 'fieldset' has incorrect parameter kind. Expected POSITIONAL_OR_KEYWORD, got KEYWORD_ONLY", + ): + pset.Kernel(kernel_with_forced_kwarg) diff --git a/tests/test_kernel_execution.py b/tests/test_kernel_execution.py deleted file mode 100644 index bcf0e1b41..000000000 --- a/tests/test_kernel_execution.py +++ /dev/null @@ -1,456 +0,0 @@ -import os -import sys -import uuid -from datetime import timedelta - -import numpy as np -import pytest - -import parcels -from parcels import ( - AdvectionRK4, - FieldOutOfBoundError, - FieldSet, - JITParticle, - ParticleSet, - ScipyParticle, - StatusCode, -) -from tests.common_kernels import DeleteParticle, DoNothing, MoveEast, MoveNorth -from tests.utils import assert_empty_folder, create_fieldset_unit_mesh, create_fieldset_zeros_simple - -ptype = {"scipy": ScipyParticle, "jit": JITParticle} - - -@pytest.fixture() -def parcels_cache(monkeypatch, tmp_path_factory): - """Dedicated folder parcels used to store cached Kernel C code/libraries and log files.""" - tmp_path = tmp_path_factory.mktemp(f"c-code-{uuid.uuid4()}") - - def fake_get_cache_dir(): - return tmp_path - - monkeypatch.setattr(parcels.kernel, "get_cache_dir", fake_get_cache_dir) - yield tmp_path - - -@pytest.fixture -def fieldset_unit_mesh(): - return create_fieldset_unit_mesh() - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("kernel_type", ["update_lon", "update_dlon"]) -def test_execution_order(mode, kernel_type): - fieldset = FieldSet.from_data( - {"U": [[0, 1], [2, 3]], "V": np.ones((2, 2))}, {"lon": [0, 2], "lat": [0, 2]}, mesh="flat" - ) - - def MoveLon_Update_Lon(particle, fieldset, time): # pragma: no cover - particle.lon += 0.2 - - def MoveLon_Update_dlon(particle, fieldset, time): # pragma: no cover - particle_dlon += 0.2 # noqa - - def SampleP(particle, fieldset, time): # pragma: no cover - particle.p = fieldset.U[time, particle.depth, particle.lat, particle.lon] - - SampleParticle = ptype[mode].add_variable("p", dtype=np.float32, initial=0.0) - - MoveLon = MoveLon_Update_dlon if kernel_type == "update_dlon" else MoveLon_Update_Lon - - kernels = [MoveLon, SampleP] - lons = [] - ps = [] - for dir in [1, -1]: - pset = ParticleSet(fieldset, pclass=SampleParticle, lon=0, lat=0) - pset.execute(kernels[::dir], endtime=1, dt=1) - lons.append(pset.lon) - ps.append(pset.p) - - if kernel_type == "update_dlon": - assert np.isclose(lons[0], lons[1]) - assert np.isclose(ps[0], ps[1]) - assert np.allclose(lons[0], 0) - else: - assert np.isclose(ps[0] - ps[1], 0.1) - assert np.allclose(lons[0], 0.2) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize( - "start, end, substeps, dt", - [ - (0.0, 10.0, 1, 1.0), - (0.0, 10.0, 4, 1.0), - (0.0, 10.0, 1, 3.0), - (2.0, 16.0, 5, 3.0), - (20.0, 10.0, 4, -1.0), - (20.0, -10.0, 7, -2.0), - ], -) -def test_execution_endtime(fieldset_unit_mesh, mode, start, end, substeps, dt): - npart = 10 - pset = ParticleSet( - fieldset_unit_mesh, pclass=ptype[mode], time=start, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart) - ) - pset.execute(DoNothing, endtime=end, dt=dt) - assert np.allclose(pset.time_nextloop, end) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize( - "start, end, substeps, dt", - [ - (0.0, 10.0, 1, 1.0), - (0.0, 10.0, 4, 1.0), - (0.0, 10.0, 1, 3.0), - (2.0, 16.0, 5, 3.0), - (20.0, 10.0, 4, -1.0), - (20.0, -10.0, 7, -2.0), - ], -) -def test_execution_runtime(fieldset_unit_mesh, mode, start, end, substeps, dt): - npart = 10 - pset = ParticleSet( - fieldset_unit_mesh, pclass=ptype[mode], time=start, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart) - ) - t_step = abs(end - start) / substeps - for _ in range(substeps): - pset.execute(DoNothing, runtime=t_step, dt=dt) - assert np.allclose(pset.time_nextloop, end) - - -@pytest.mark.parametrize("mode", ["scipy"]) -def test_execution_fail_python_exception(fieldset_unit_mesh, mode): - npart = 10 - - def PythonFail(particle, fieldset, time): # pragma: no cover - if particle.time >= 10.0: - raise RuntimeError("Enough is enough!") - else: - pass - - pset = ParticleSet( - fieldset_unit_mesh, pclass=ptype[mode], lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart) - ) - with pytest.raises(RuntimeError): - pset.execute(PythonFail, endtime=20.0, dt=2.0) - assert len(pset) == npart - assert np.isclose(pset.time[0], 10) - assert np.allclose(pset.time[1:], 0.0) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_execution_fail_out_of_bounds(fieldset_unit_mesh, mode): - npart = 10 - - def MoveRight(particle, fieldset, time): # pragma: no cover - tmp1, tmp2 = fieldset.UV[time, particle.depth, particle.lat, particle.lon + 0.1, particle] - particle_dlon += 0.1 # noqa - - pset = ParticleSet( - fieldset_unit_mesh, pclass=ptype[mode], lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart) - ) - with pytest.raises(FieldOutOfBoundError): - pset.execute(MoveRight, endtime=10.0, dt=1.0) - assert len(pset) == npart - assert (pset.lon - 1.0 > -1.0e12).all() - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_execution_recover_out_of_bounds(fieldset_unit_mesh, mode): - npart = 2 - - def MoveRight(particle, fieldset, time): # pragma: no cover - tmp1, tmp2 = fieldset.UV[time, particle.depth, particle.lat, particle.lon + 0.1, particle] - particle_dlon += 0.1 # noqa - - def MoveLeft(particle, fieldset, time): # pragma: no cover - if particle.state == StatusCode.ErrorOutOfBounds: - particle_dlon -= 1.0 # noqa - particle.state = StatusCode.Success - - lon = np.linspace(0.05, 0.95, npart) - lat = np.linspace(1, 0, npart) - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=lon, lat=lat) - pset.execute([MoveRight, MoveLeft], endtime=11.0, dt=1.0) - assert len(pset) == npart - assert np.allclose(pset.lon, lon, rtol=1e-5) - assert np.allclose(pset.lat, lat, rtol=1e-5) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_execution_check_all_errors(fieldset_unit_mesh, mode): - def MoveRight(particle, fieldset, time): # pragma: no cover - tmp1, tmp2 = fieldset.UV[time, particle.depth, particle.lat, particle.lon, particle] - - def RecoverAllErrors(particle, fieldset, time): # pragma: no cover - if particle.state > 4: - particle.state = StatusCode.Delete - - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=10, lat=0) - pset.execute([MoveRight, RecoverAllErrors], endtime=11.0, dt=1.0) - assert len(pset) == 0 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_execution_check_stopallexecution(fieldset_unit_mesh, mode): - def addoneLon(particle, fieldset, time): # pragma: no cover - particle_dlon += 1 # noqa - - if particle.lon + particle_dlon >= 10: - particle.state = StatusCode.StopAllExecution - - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=[0, 1], lat=[0, 0]) - pset.execute(addoneLon, endtime=20.0, dt=1.0) - assert pset[0].lon == 9 - assert pset[0].time == 9 - assert pset[1].lon == 1 - assert pset[1].time == 0 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_execution_delete_out_of_bounds(fieldset_unit_mesh, mode): - npart = 10 - - def MoveRight(particle, fieldset, time): # pragma: no cover - tmp1, tmp2 = fieldset.UV[time, particle.depth, particle.lat, particle.lon + 0.1, particle] - particle_dlon += 0.1 # noqa - - lon = np.linspace(0.05, 0.95, npart) - lat = np.linspace(1, 0, npart) - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=lon, lat=lat) - pset.execute([MoveRight, DeleteParticle], endtime=10.0, dt=1.0) - assert len(pset) == 0 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_kernel_add_no_new_variables(fieldset_unit_mesh, mode): - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=[0.5], lat=[0.5]) - pset.execute(pset.Kernel(MoveEast) + pset.Kernel(MoveNorth), endtime=2.0, dt=1.0) - assert np.allclose(pset.lon, 0.6, rtol=1e-5) - assert np.allclose(pset.lat, 0.6, rtol=1e-5) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_multi_kernel_duplicate_varnames(fieldset_unit_mesh, mode): - # Testing for merging of two Kernels with the same variable declared - # Should throw a warning, but go ahead regardless - def Kernel1(particle, fieldset, time): # pragma: no cover - add_lon = 0.1 - particle_dlon += add_lon # noqa - - def Kernel2(particle, fieldset, time): # pragma: no cover - add_lon = -0.3 - particle_dlon += add_lon # noqa - - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=[0.5], lat=[0.5]) - pset.execute([Kernel1, Kernel2], endtime=2.0, dt=1.0) - assert np.allclose(pset.lon, 0.3, rtol=1e-5) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_multi_kernel_reuse_varnames(fieldset_unit_mesh, mode): - # Testing for merging of two Kernels with the same variable declared - # Should throw a warning, but go ahead regardless - def MoveEast1(particle, fieldset, time): # pragma: no cover - add_lon = 0.2 - particle_dlon += add_lon # noqa - - def MoveEast2(particle, fieldset, time): # pragma: no cover - particle_dlon += add_lon # noqa - - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=[0.5], lat=[0.5]) - pset.execute(pset.Kernel(MoveEast1) + pset.Kernel(MoveEast2), endtime=2.0, dt=1.0) - assert np.allclose(pset.lon, [0.9], rtol=1e-5) # should be 0.5 + 0.2 + 0.2 = 0.9 - - -def test_combined_kernel_from_list(fieldset_unit_mesh): - """ - Test pset.Kernel(List[function]) - - Tests that a Kernel can be created from a list functions, or a list of - mixed functions and kernel objects. - """ - - def MoveEast(particle, fieldset, time): # pragma: no cover - particle_dlon += 0.1 # noqa - - def MoveNorth(particle, fieldset, time): # pragma: no cover - particle_dlat += 0.1 # noqa - - pset = ParticleSet(fieldset_unit_mesh, pclass=JITParticle, lon=[0.5], lat=[0.5]) - kernels_single = pset.Kernel([AdvectionRK4]) - kernels_functions = pset.Kernel([AdvectionRK4, MoveEast, MoveNorth]) - - # Check if the kernels were combined correctly - assert kernels_single.funcname == "AdvectionRK4" - assert kernels_functions.funcname == "AdvectionRK4MoveEastMoveNorth" - - -def test_combined_kernel_from_list_error_checking(fieldset_unit_mesh): - """ - Test pset.Kernel(List[function]) - - Tests that various error cases raise appropriate messages. - """ - pset = ParticleSet(fieldset_unit_mesh, pclass=JITParticle, lon=[0.5], lat=[0.5]) - - # Test that list has to be non-empty - with pytest.raises(ValueError): - pset.Kernel([]) - - # Test that list has to be all functions - with pytest.raises(ValueError): - pset.Kernel([AdvectionRK4, "something else"]) - - # Can't mix kernel objects and functions in list - with pytest.raises(ValueError): - kernels_mixed = pset.Kernel([pset.Kernel(AdvectionRK4), MoveEast, MoveNorth]) - assert kernels_mixed.funcname == "AdvectionRK4MoveEastMoveNorth" - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_update_kernel_in_script(fieldset_unit_mesh, mode): - # Testing what happens when kernels are updated during runtime of a script - # Should throw a warning, but go ahead regardless - def MoveEast(particle, fieldset, time): # pragma: no cover - add_lon = 0.1 - particle_dlon += add_lon # noqa - - def MoveWest(particle, fieldset, time): # pragma: no cover - add_lon = -0.3 - particle_dlon += add_lon # noqa - - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=[0.5], lat=[0.5]) - pset.execute(pset.Kernel(MoveEast), endtime=1.0, dt=1.0) - pset.execute(pset.Kernel(MoveWest), endtime=3.0, dt=1.0) - assert np.allclose(pset.lon, 0.3, rtol=1e-5) # should be 0.5 + 0.1 - 0.3 = 0.3 - - -@pytest.mark.parametrize("delete_cfiles", [True, False]) -@pytest.mark.skipif( - sys.platform.startswith("win"), reason="skipping windows test as windows compiler generates warning" -) -def test_execution_keep_cfiles_and_nocompilation_warnings(fieldset_unit_mesh, delete_cfiles): - pset = ParticleSet(fieldset_unit_mesh, pclass=JITParticle, lon=[0.0], lat=[0.0]) - pset.execute(AdvectionRK4, delete_cfiles=delete_cfiles, endtime=1.0, dt=1.0) - cfile = pset._kernel.src_file - logfile = pset._kernel.log_file - del pset._kernel - if delete_cfiles: - assert not os.path.exists(cfile) - else: - assert os.path.exists(cfile) - with open(logfile) as f: - assert "warning" not in f.read(), "Compilation WARNING in log file" - - -def test_compilers(): - from parcels.compilation.codecompiler import ( - CCompiler_SS, - Clang_parameters, - MinGW_parameters, - VS_parameters, - ) - - for param_class in [Clang_parameters, MinGW_parameters, VS_parameters]: - params = param_class() # noqa - - print(CCompiler_SS()) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_explicit_ParcelsRandom(fieldset_unit_mesh, mode): - """Testing `from parcels import ParcelsRandom` in kernel code""" - from parcels import ParcelsRandom - - def nudge_kernel(particle, fieldset, time): # pragma: no cover - dlat = ParcelsRandom.uniform(2, 3) - particle_dlat += dlat # noqa - - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=[0.5], lat=[0.5]) - pset.execute(nudge_kernel, runtime=2, dt=1) - assert 2.5 <= pset[0].lat <= 3.5 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_parcels_dot_ParcelsRandom(fieldset_unit_mesh, mode): - """Testing `parcels.ParcelsRandom` in kernel code""" - - def nudge_kernel(particle, fieldset, time): # pragma: no cover - particle_dlat += parcels.ParcelsRandom.uniform(2, 3) # noqa - - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=[0.5], lat=[0.5]) - pset.execute(nudge_kernel, runtime=2, dt=1) - assert 2.5 <= pset[0].lat <= 3.5 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_parcels_dot_rng(fieldset_unit_mesh, mode): - """Testing `parcels.rng` in kernel code.""" - - def nudge_kernel(particle, fieldset, time): # pragma: no cover - dlat = parcels.rng.uniform(2, 3) - particle_dlat += dlat # noqa - - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=[0.5], lat=[0.5]) - pset.execute(nudge_kernel, runtime=2, dt=1) - assert 2.5 <= pset[0].lat <= 3.5 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_custom_ParcelsRandom_alias(fieldset_unit_mesh, mode): - """Testing aliasing ParcelsRandom to another name.""" - from parcels import ParcelsRandom as my_custom_name - - def nudge_kernel(particle, fieldset, time): # pragma: no cover - particle_dlat += my_custom_name.uniform(2, 3) # noqa - - pset = ParticleSet(fieldset_unit_mesh, pclass=ptype[mode], lon=[0.5], lat=[0.5]) - - try: - pset.execute(nudge_kernel, runtime=2, dt=1) - except Exception: - pass # This test is expected to fail - else: - pytest.fail( - "Parcels uses function name to determine kernel support. " - "Aliasing ParcelsRandom to another name is not supported." - ) - - -def test_outdated_kernel(fieldset_unit_mesh): - """ - Make sure that if users try using a kernel from pre Parcels 2.0 they get an error. - - Prevents users from copy-pasting old kernels that are no longer supported. - """ - pset = ParticleSet(fieldset_unit_mesh, pclass=JITParticle, lon=[0.5], lat=[0.5]) - - def outdated_kernel(particle, fieldset, time, dt): # pragma: no cover - particle.lon += 0.1 - - with pytest.raises(ValueError) as e: - pset.Kernel(outdated_kernel) - - assert "Since Parcels v2.0" in str(e.value) - - with pytest.raises(ValueError) as e: - pset.execute(outdated_kernel, endtime=1.0, dt=1.0) - - assert "Since Parcels v2.0" in str(e.value) - - -def test_kernel_file_cleanup(parcels_cache): - pset = ParticleSet(create_fieldset_zeros_simple(), pclass=JITParticle, lon=[0.0], lat=[0.0]) - - pset.execute( - [parcels.AdvectionRK4], - runtime=timedelta(minutes=10), - dt=timedelta(minutes=5), - ) - del pset # cleans up compiled C files on deletion - - assert_empty_folder(parcels_cache) diff --git a/tests/test_particle.py b/tests/test_particle.py new file mode 100644 index 000000000..fdc05ea14 --- /dev/null +++ b/tests/test_particle.py @@ -0,0 +1,165 @@ +import numpy as np +import pytest + +from parcels._core.particle import ( + _SAME_AS_FIELDSET_TIME_INTERVAL, + Particle, + ParticleClass, + Variable, + create_particle_data, +) +from parcels._core.utils.time import TimeInterval +from parcels._datasets.structured.generic import TIME + + +def test_variable_init(): + var = Variable("test") + assert var.name == "test" + assert var.dtype == np.float32 + assert var.to_write + assert var.attrs == {} + + +def test_variable_invalid_init(): + with pytest.raises(ValueError, match="to_write must be one of .*\. Got to_write="): + Variable("name", to_write="test") + + with pytest.raises(ValueError, match="to_write must be one of .*\. Got to_write="): + Variable("name", to_write="test") + + for name in ["a b", "123", "while"]: + with pytest.raises(ValueError, match="Particle variable has to be a valid Python variable name. Got "): + Variable(name) + + with pytest.raises(ValueError, match="Attributes cannot be set if to_write=False"): + Variable("name", to_write=False, attrs={"description": "metadata to write"}) + + +@pytest.mark.parametrize( + "variable, expected", + [ + ( + Variable("test", np.float32, 0.0, True, {"some": "metadata"}), + "Variable(name='test', dtype=dtype('float32'), initial=0.0, to_write=True, attrs={'some': 'metadata'})", + ), + ( + Variable("test", np.float32, 0.0, True), + "Variable(name='test', dtype=dtype('float32'), initial=0.0, to_write=True, attrs={})", + ), + ], +) +def test_variable_repr(variable, expected): + assert repr(variable) == expected + + +def test_particleclass_init(): + ParticleClass( + variables=[ + Variable("vara", dtype=np.float32), + Variable("varb", dtype=np.float32, to_write=False), + Variable("varc", dtype=np.float32), + ] + ) + + +def test_particleclass_invalid_vars(): + with pytest.raises(ValueError, match="All items in variables must be instances of Variable. Got"): + ParticleClass(variables=[Variable("vara", dtype=np.float32), "not a variable class"]) + + with pytest.raises(TypeError, match="Expected list of Variable objects, got "): + ParticleClass(variables="not a list") + + +@pytest.mark.parametrize( + "obj, expected", + [ + ( + ParticleClass( + variables=[ + Variable("vara", dtype=np.float32, to_write=True), + Variable("varb", dtype=np.float32, to_write=False), + Variable("varc", dtype=np.float32, to_write=True), + ] + ), + """ParticleClass(variables=[ + Variable(name='vara', dtype=dtype('float32'), initial=0, to_write=True, attrs={}), + Variable(name='varb', dtype=dtype('float32'), initial=0, to_write=False, attrs={}), + Variable(name='varc', dtype=dtype('float32'), initial=0, to_write=True, attrs={}) +])""", + ), + ], +) +def test_particleclass_repr(obj, expected): + assert repr(obj) == expected + + +def test_particleclass_add_variable(): + p_initial = ParticleClass(variables=[Variable("vara", dtype=np.float32)]) + variables = [ + Variable("varb", dtype=np.float32, to_write=True), + Variable("varc", dtype=np.float32, to_write=False), + ] + p_final = p_initial.add_variable(variables) + + assert len(p_final.variables) == 3 + assert p_final.variables[0].name == "vara" + assert p_final.variables[1].name == "varb" + assert p_final.variables[2].name == "varc" + + +def test_particleclass_add_variable_in_loop(): + p = ParticleClass(variables=[Variable("vara", dtype=np.float32)]) + vars = [Variable("sample_var"), Variable("sample_var2")] + p_loop = p + for var in vars: + p_loop = p_loop.add_variable(var) + + p_list = p.add_variable(vars) + + for var1, var2 in zip(p_loop.variables, p_list.variables, strict=True): + assert var1.name == var2.name + assert var1.dtype == var2.dtype + assert var1.to_write == var2.to_write + + +def test_particleclass_add_variable_collision(): + p_initial = ParticleClass(variables=[Variable("vara", dtype=np.float32)]) + + with pytest.raises(ValueError, match="Variable name already exists: "): + p_initial.add_variable([Variable("vara", dtype=np.float32, to_write=True)]) + + +@pytest.mark.parametrize( + "particle", + [ + ParticleClass( + variables=[ + Variable("vara", dtype=np.float32, initial=1.0), + Variable("varb", dtype=np.float32, initial=2.0), + ] + ), + Particle, + ], +) +@pytest.mark.parametrize("nparticles", [5, 10]) +def test_create_particle_data(particle, nparticles): + time_interval = TimeInterval(TIME[0], TIME[-1]) + ngrids = 4 + data = create_particle_data(pclass=particle, nparticles=nparticles, ngrids=ngrids, time_interval=time_interval) + + assert isinstance(data, dict) + assert len(data) == len(particle.variables) + 1 # ei variable is separate + + variables = {var.name: var for var in particle.variables} + + for variable_name in variables.keys(): + variable = variables[variable_name] + variable_array = data[variable_name] + + assert variable_array.shape[0] == nparticles + + dtype = variable.dtype + if dtype is _SAME_AS_FIELDSET_TIME_INTERVAL.VALUE: + dtype = type(time_interval.left) + + assert variable_array.dtype == dtype diff --git a/tests/test_particlefile.py b/tests/test_particlefile.py index de04bde74..fbe222f95 100755 --- a/tests/test_particlefile.py +++ b/tests/test_particlefile.py @@ -2,150 +2,159 @@ import tempfile from datetime import timedelta -import cftime import numpy as np import pytest import xarray as xr from zarr.storage import MemoryStore import parcels -from parcels import ( - AdvectionRK4, - Field, - FieldSet, - JITParticle, - ParticleSet, - ScipyParticle, - Variable, -) -from parcels.particlefile import _set_calendar -from parcels.tools.converters import _get_cftime_calendars, _get_cftime_datetimes +from parcels import Field, FieldSet, Particle, ParticleFile, ParticleSet, StatusCode, Variable, VectorField, XGrid +from parcels._core.particle import Particle, create_particle_data, get_default_particle +from parcels._core.utils.time import TimeInterval +from parcels._datasets.structured.generic import datasets +from parcels.kernels import AdvectionRK4 from tests.common_kernels import DoNothing -from tests.utils import create_fieldset_zeros_simple - -ptype = {"scipy": ScipyParticle, "jit": JITParticle} @pytest.fixture -def fieldset(): - return create_fieldset_zeros_simple() +def fieldset() -> FieldSet: # TODO v4: Move into a `conftest.py` file and remove duplicates + """Fixture to create a FieldSet object for testing.""" + ds = datasets["ds_2d_left"] + grid = XGrid.from_dataset(ds) + U = Field("U", ds["U (A grid)"], grid) + V = Field("V", ds["V (A grid)"], grid) + UV = VectorField("UV", U, V) + + return FieldSet( + [U, V, UV], + ) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_metadata(fieldset, mode, tmp_zarrfile): - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=0, lat=0) +@pytest.mark.skip +def test_metadata(fieldset, tmp_zarrfile): + pset = ParticleSet(fieldset, pclass=Particle, lon=0, lat=0) - pset.execute(DoNothing, runtime=1, output_file=pset.ParticleFile(tmp_zarrfile, outputdt=1)) + pset.execute(DoNothing, runtime=1, output_file=ParticleFile(tmp_zarrfile, outputdt=np.timedelta64(1, "s"))) - ds = xr.open_zarr(tmp_zarrfile) - assert ds.attrs["parcels_kernels"].lower() == f"{mode}ParticleDoNothing".lower() + ds = xr.open_zarr(tmp_zarrfile, decode_cf=False) # TODO v4: Fix metadata and re-enable decode_cf + assert ds.attrs["parcels_kernels"].lower() == "ParticleDoNothing".lower() -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pfile_array_write_zarr_memorystore(fieldset, mode): +def test_pfile_array_write_zarr_memorystore(fieldset): """Check that writing to a Zarr MemoryStore works.""" npart = 10 zarr_store = MemoryStore() - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=np.linspace(0, 1, npart), lat=0.5 * np.ones(npart), time=0) - pfile = pset.ParticleFile(zarr_store, outputdt=1) - pfile.write(pset, 0) + pset = ParticleSet( + fieldset, + pclass=Particle, + lon=np.linspace(0, 1, npart), + lat=0.5 * np.ones(npart), + time=fieldset.time_interval.left, + ) + pfile = ParticleFile(zarr_store, outputdt=np.timedelta64(1, "s")) + pfile.write(pset, time=fieldset.time_interval.left) ds = xr.open_zarr(zarr_store) assert ds.sizes["trajectory"] == npart - ds.close() -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pfile_array_remove_particles(fieldset, mode, tmp_zarrfile): +def test_pfile_array_remove_particles(fieldset, tmp_zarrfile): npart = 10 - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=np.linspace(0, 1, npart), lat=0.5 * np.ones(npart), time=0) - pfile = pset.ParticleFile(tmp_zarrfile, outputdt=1) - pfile.write(pset, 0) + pset = ParticleSet( + fieldset, + pclass=Particle, + lon=np.linspace(0, 1, npart), + lat=0.5 * np.ones(npart), + time=fieldset.time_interval.left, + ) + pfile = ParticleFile(tmp_zarrfile, outputdt=np.timedelta64(1, "s")) + pset._data["time"][:] = fieldset.time_interval.left + pset._data["time_nextloop"][:] = fieldset.time_interval.left + pfile.write(pset, time=fieldset.time_interval.left) pset.remove_indices(3) - for p in pset: - p.time = 1 - pfile.write(pset, 1) - - ds = xr.open_zarr(tmp_zarrfile) + new_time = fieldset.time_interval.left + np.timedelta64(1, "D") + pset._data["time"][:] = new_time + pset._data["time_nextloop"][:] = new_time + pfile.write(pset, new_time) + ds = xr.open_zarr(tmp_zarrfile, decode_cf=False) timearr = ds["time"][:] + pytest.skip( + "TODO v4: Set decode_cf=True, which will mean that missing values get decoded to NaT rather than fill value" + ) assert (np.isnat(timearr[3, 1])) and (np.isfinite(timearr[3, 0])) - ds.close() - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pfile_set_towrite_False(fieldset, mode, tmp_zarrfile): - npart = 10 - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=np.linspace(0, 1, npart), lat=0.5 * np.ones(npart)) - pset.set_variable_write_status("depth", False) - pset.set_variable_write_status("lat", False) - pfile = pset.ParticleFile(tmp_zarrfile, outputdt=1) - - def Update_lon(particle, fieldset, time): # pragma: no cover - particle_dlon += 0.1 # noqa - pset.execute(Update_lon, runtime=10, output_file=pfile) - ds = xr.open_zarr(tmp_zarrfile) - assert "time" in ds - assert "z" not in ds - assert "lat" not in ds - ds.close() - - # For pytest purposes, we need to reset to original status - pset.set_variable_write_status("depth", True) - pset.set_variable_write_status("lat", True) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) @pytest.mark.parametrize("chunks_obs", [1, None]) -def test_pfile_array_remove_all_particles(fieldset, mode, chunks_obs, tmp_zarrfile): +def test_pfile_array_remove_all_particles(fieldset, chunks_obs, tmp_zarrfile): npart = 10 - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=np.linspace(0, 1, npart), lat=0.5 * np.ones(npart), time=0) + pset = ParticleSet( + fieldset, + pclass=Particle, + lon=np.linspace(0, 1, npart), + lat=0.5 * np.ones(npart), + time=fieldset.time_interval.left, + ) chunks = (npart, chunks_obs) if chunks_obs else None - pfile = pset.ParticleFile(tmp_zarrfile, chunks=chunks, outputdt=1) - pfile.write(pset, 0) + pfile = ParticleFile(tmp_zarrfile, chunks=chunks, outputdt=np.timedelta64(1, "s")) + pfile.write(pset, time=fieldset.time_interval.left) for _ in range(npart): pset.remove_indices(-1) - pfile.write(pset, 1) - pfile.write(pset, 2) + pfile.write(pset, fieldset.time_interval.left + np.timedelta64(1, "D")) + pfile.write(pset, fieldset.time_interval.left + np.timedelta64(2, "D")) - ds = xr.open_zarr(tmp_zarrfile).load() + ds = xr.open_zarr(tmp_zarrfile, decode_cf=False).load() + pytest.skip( + "TODO v4: Set decode_cf=True, which will mean that missing values get decoded to NaT rather than fill value" + ) assert np.allclose(ds["time"][:, 0], np.timedelta64(0, "s"), atol=np.timedelta64(1, "ms")) if chunks_obs is not None: assert ds["time"][:].shape == chunks else: assert ds["time"][:].shape[0] == npart assert np.all(np.isnan(ds["time"][:, 1:])) - ds.close() -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_variable_write_double(fieldset, mode, tmp_zarrfile): - def Update_lon(particle, fieldset, time): # pragma: no cover - particle_dlon += 0.1 # noqa +@pytest.mark.skip(reason="TODO v4: stuck in infinite loop") +def test_variable_write_double(fieldset, tmp_zarrfile): + def Update_lon(particles, fieldset): # pragma: no cover + particles.dlon += 0.1 - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=[0], lat=[0], lonlatdepth_dtype=np.float64) - ofile = pset.ParticleFile(name=tmp_zarrfile, outputdt=0.00001) - pset.execute(pset.Kernel(Update_lon), endtime=0.001, dt=0.00001, output_file=ofile) + particle = get_default_particle(np.float64) + pset = ParticleSet(fieldset, pclass=particle, lon=[0], lat=[0]) + ofile = ParticleFile(tmp_zarrfile, outputdt=np.timedelta64(10, "us")) + pset.execute( + pset.Kernel(Update_lon), + runtime=np.timedelta64(1, "ms"), + dt=np.timedelta64(10, "us"), + output_file=ofile, + ) - ds = xr.open_zarr(tmp_zarrfile) + ds = xr.open_zarr(tmp_zarrfile, decode_cf=False) # TODO v4: Fix metadata and re-enable decode_cf lons = ds["lon"][:] assert isinstance(lons.values[0, 0], np.float64) - ds.close() -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_write_dtypes_pfile(fieldset, mode, tmp_zarrfile): - dtypes = [np.float32, np.float64, np.int32, np.uint32, np.int64, np.uint64] - if mode == "scipy": - dtypes.extend([np.bool_, np.int8, np.uint8, np.int16, np.uint16]) +def test_write_dtypes_pfile(fieldset, tmp_zarrfile): + dtypes = [ + np.float32, + np.float64, + np.int32, + np.uint32, + np.int64, + np.uint64, + np.bool_, + np.int8, + np.uint8, + np.int16, + np.uint16, + ] extra_vars = [Variable(f"v_{d.__name__}", dtype=d, initial=0.0) for d in dtypes] - MyParticle = ptype[mode].add_variables(extra_vars) + MyParticle = Particle.add_variable(extra_vars) - pset = ParticleSet(fieldset, pclass=MyParticle, lon=0, lat=0, time=0) - pfile = pset.ParticleFile(name=tmp_zarrfile, outputdt=1) - pfile.write(pset, 0) + pset = ParticleSet(fieldset, pclass=MyParticle, lon=0, lat=0, time=fieldset.time_interval.left) + pfile = ParticleFile(tmp_zarrfile, outputdt=np.timedelta64(1, "s")) + pfile.write(pset, time=fieldset.time_interval.left) ds = xr.open_zarr( tmp_zarrfile, mask_and_scale=False @@ -154,119 +163,93 @@ def test_write_dtypes_pfile(fieldset, mode, tmp_zarrfile): assert ds[f"v_{d.__name__}"].dtype == d -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("npart", [1, 2, 5]) -def test_variable_written_once(fieldset, mode, tmp_zarrfile, npart): - def Update_v(particle, fieldset, time): # pragma: no cover - particle.v_once += 1.0 - particle.age += particle.dt - - MyParticle = ptype[mode].add_variables( - [ - Variable("v_once", dtype=np.float64, initial=0.0, to_write="once"), - Variable("age", dtype=np.float32, initial=0.0), - ] - ) - lon = np.linspace(0, 1, npart) - lat = np.linspace(1, 0, npart) - time = np.arange(0, npart / 10.0, 0.1, dtype=np.float64) - pset = ParticleSet(fieldset, pclass=MyParticle, lon=lon, lat=lat, time=time, v_once=time) - ofile = pset.ParticleFile(name=tmp_zarrfile, outputdt=0.1) - pset.execute(pset.Kernel(Update_v), endtime=1, dt=0.1, output_file=ofile) - - assert np.allclose(pset.v_once - time - pset.age * 10, 1, atol=1e-5) - ds = xr.open_zarr(tmp_zarrfile) - vfile = np.ma.filled(ds["v_once"][:], np.nan) - assert vfile.shape == (npart,) - ds.close() +def test_variable_written_once(): + # Test that a vaiable is only written once. This should also work with gradual particle release (so the written once time is actually after the release of the particle) + ... -@pytest.mark.parametrize("type", ["repeatdt", "timearr"]) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("repeatdt", range(1, 3)) -@pytest.mark.parametrize("dt", [-1, 1]) +@pytest.mark.parametrize( + "dt", + [ + pytest.param(-np.timedelta64(1, "s"), marks=pytest.mark.xfail(reason="need to fix backwards in time")), + np.timedelta64(1, "s"), + ], +) @pytest.mark.parametrize("maxvar", [2, 4, 10]) -def test_pset_repeated_release_delayed_adding_deleting(type, fieldset, mode, repeatdt, tmp_zarrfile, dt, maxvar): - runtime = 10 - fieldset.maxvar = maxvar +def test_pset_repeated_release_delayed_adding_deleting(fieldset, tmp_zarrfile, dt, maxvar): + """Tests that if particles are released and deleted based on age that resulting output file is correct.""" + npart = 10 + runtime = np.timedelta64(npart, "s") + fieldset.add_constant("maxvar", maxvar) pset = None - MyParticle = ptype[mode].add_variables( + MyParticle = Particle.add_variable( [Variable("sample_var", initial=0.0), Variable("v_once", dtype=np.float64, initial=0.0, to_write="once")] ) - if type == "repeatdt": - pset = ParticleSet(fieldset, lon=[0], lat=[0], pclass=MyParticle, repeatdt=repeatdt) - elif type == "timearr": - pset = ParticleSet( - fieldset, lon=np.zeros(runtime), lat=np.zeros(runtime), pclass=MyParticle, time=list(range(runtime)) + pset = ParticleSet( + fieldset, + lon=np.zeros(npart), + lat=np.zeros(npart), + pclass=MyParticle, + time=fieldset.time_interval.left + np.array([np.timedelta64(i, "s") for i in range(npart)]), + ) + pfile = ParticleFile(tmp_zarrfile, outputdt=abs(dt), chunks=(1, 1)) + + def IncrLon(particles, fieldset): # pragma: no cover + particles.sample_var += 1.0 + particles.state = np.where( + particles.sample_var > fieldset.maxvar, + StatusCode.Delete, + particles.state, ) - pfile = pset.ParticleFile(tmp_zarrfile, outputdt=abs(dt), chunks=(1, 1)) - - def IncrLon(particle, fieldset, time): # pragma: no cover - particle.sample_var += 1.0 - if particle.sample_var > fieldset.maxvar: - particle.delete() - for _ in range(runtime): - pset.execute(IncrLon, dt=dt, runtime=1.0, output_file=pfile) + for _ in range(npart): + pset.execute(IncrLon, dt=dt, runtime=np.timedelta64(1, "s"), output_file=pfile) - ds = xr.open_zarr(tmp_zarrfile) + ds = xr.open_zarr(tmp_zarrfile, decode_cf=False) + pytest.skip( + "TODO v4: Set decode_cf=True, which will mean that missing values get decoded to NaT rather than fill value" + ) samplevar = ds["sample_var"][:] - if type == "repeatdt": - assert samplevar.shape == (runtime // repeatdt, min(maxvar + 1, runtime)) - assert np.allclose(pset.sample_var, np.arange(maxvar, -1, -repeatdt)) - elif type == "timearr": - assert samplevar.shape == (runtime, min(maxvar + 1, runtime)) + assert samplevar.shape == (runtime, min(maxvar + 1, runtime)) # test whether samplevar[:, k] = k for k in range(samplevar.shape[1]): assert np.allclose([p for p in samplevar[:, k] if np.isfinite(p)], k + 1) filesize = os.path.getsize(str(tmp_zarrfile)) assert filesize < 1024 * 65 # test that chunking leads to filesize less than 65KB - ds.close() -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("repeatdt", [1, 2]) -@pytest.mark.parametrize("nump", [1, 10]) -def test_pfile_chunks_repeatedrelease(fieldset, mode, repeatdt, nump, tmp_zarrfile): - runtime = 8 +@pytest.mark.xfail(reason="need to fix backwards in time") +def test_write_timebackward(fieldset, tmp_zarrfile): + def Update_lon(particles, fieldset): # pragma: no cover + dt = particles.dt / np.timedelta64(1, "s") + particles.dlon -= 0.1 * dt + pset = ParticleSet( - fieldset, pclass=ptype[mode], lon=np.zeros((nump, 1)), lat=np.zeros((nump, 1)), repeatdt=repeatdt + fieldset, + pclass=Particle, + lat=np.linspace(0, 1, 3), + lon=[0, 0, 0], + time=np.array([np.datetime64("2000-01-01") for _ in range(3)]), ) - chunks = (20, 10) - pfile = pset.ParticleFile(tmp_zarrfile, outputdt=1, chunks=chunks) - - def DoNothing(particle, fieldset, time): # pragma: no cover - pass - - pset.execute(DoNothing, dt=1, runtime=runtime, output_file=pfile) - ds = xr.open_zarr(tmp_zarrfile) - assert ds["time"].shape == (int(nump * runtime / repeatdt), chunks[1]) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_write_timebackward(fieldset, mode, tmp_zarrfile): - def Update_lon(particle, fieldset, time): # pragma: no cover - particle_dlon -= 0.1 * particle.dt # noqa - - pset = ParticleSet(fieldset, pclass=ptype[mode], lat=np.linspace(0, 1, 3), lon=[0, 0, 0], time=[1, 2, 3]) - pfile = pset.ParticleFile(name=tmp_zarrfile, outputdt=1.0) - pset.execute(pset.Kernel(Update_lon), runtime=4, dt=-1.0, output_file=pfile) + pfile = ParticleFile(tmp_zarrfile, outputdt=np.timedelta64(1, "s")) + pset.execute(pset.Kernel(Update_lon), runtime=np.timedelta64(1, "s"), dt=-np.timedelta64(1, "s"), output_file=pfile) ds = xr.open_zarr(tmp_zarrfile) trajs = ds["trajectory"][:] assert trajs.values.dtype == "int64" assert np.all(np.diff(trajs.values) < 0) # all particles written in order of release - ds.close() -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_write_xiyi(fieldset, mode, tmp_zarrfile): +@pytest.mark.xfail +@pytest.mark.v4alpha +def test_write_xiyi(fieldset, tmp_zarrfile): fieldset.U.data[:] = 1 # set a non-zero zonal velocity fieldset.add_field(Field(name="P", data=np.zeros((3, 20)), lon=np.linspace(0, 1, 20), lat=[-2, 0, 2])) - dt = 3600 + dt = np.timedelta64(3600, "s") - XiYiParticle = ptype[mode].add_variables( + particle = get_default_particle(np.float64) + XiYiParticle = particle.add_variable( [ Variable("pxi0", dtype=np.int32, initial=0.0), Variable("pxi1", dtype=np.int32, initial=0.0), @@ -274,22 +257,22 @@ def test_write_xiyi(fieldset, mode, tmp_zarrfile): ] ) - def Get_XiYi(particle, fieldset, time): # pragma: no cover + def Get_XiYi(particles, fieldset): # pragma: no cover """Kernel to sample the grid indices of the particle. Note that this sampling should be done _before_ the advection kernel and that the first outputted value is zero. Be careful when using multiple grids, as the index may be different for the grids. """ - particle.pxi0 = particle.xi[0] - particle.pxi1 = particle.xi[1] - particle.pyi = particle.yi[0] + particles.pxi0 = fieldset.U.unravel_index(particles.ei)[2] + particles.pxi1 = fieldset.P.unravel_index(particles.ei)[2] + particles.pyi = fieldset.U.unravel_index(particles.ei)[1] - def SampleP(particle, fieldset, time): # pragma: no cover - if time > 5 * 3600: - _ = fieldset.P[particle] # To trigger sampling of the P field + def SampleP(particles, fieldset): # pragma: no cover + if np.any(particles.time > 5 * 3600): + _ = fieldset.P[particles] # To trigger sampling of the P field - pset = ParticleSet(fieldset, pclass=XiYiParticle, lon=[0, 0.2], lat=[0.2, 1], lonlatdepth_dtype=np.float64) - pfile = pset.ParticleFile(name=tmp_zarrfile, outputdt=dt) + pset = ParticleSet(fieldset, pclass=XiYiParticle, lon=[0, 0.2], lat=[0.2, 1]) + pfile = ParticleFile(tmp_zarrfile, outputdt=dt) pset.execute([SampleP, Get_XiYi, AdvectionRK4], endtime=10 * dt, dt=dt, output_file=pfile) ds = xr.open_zarr(tmp_zarrfile) @@ -309,41 +292,38 @@ def SampleP(particle, fieldset, time): # pragma: no cover assert fieldset.P.grid.lon[xi] <= lon < fieldset.P.grid.lon[xi + 1] for yi, lat in zip(pyi[p, 1:], lats[p, 1:], strict=True): assert fieldset.U.grid.lat[yi] <= lat < fieldset.U.grid.lat[yi + 1] - ds.close() -def test_set_calendar(): - for _calendar_name, cf_datetime in zip(_get_cftime_calendars(), _get_cftime_datetimes(), strict=True): - date = getattr(cftime, cf_datetime)(1990, 1, 1) - assert _set_calendar(date.calendar) == date.calendar - assert _set_calendar("np_datetime64") == "standard" - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_reset_dt(fieldset, mode, tmp_zarrfile): +@pytest.mark.skip +@pytest.mark.v4alpha +def test_reset_dt(fieldset, tmp_zarrfile): # Assert that p.dt gets reset when a write_time is not a multiple of dt # for p.dt=0.02 to reach outputdt=0.05 and endtime=0.1, the steps should be [0.2, 0.2, 0.1, 0.2, 0.2, 0.1], resulting in 6 kernel executions - def Update_lon(particle, fieldset, time): # pragma: no cover - particle_dlon += 0.1 # noqa + def Update_lon(particles, fieldset): # pragma: no cover + particles.dlon += 0.1 - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=[0], lat=[0], lonlatdepth_dtype=np.float64) - ofile = pset.ParticleFile(name=tmp_zarrfile, outputdt=0.05) - pset.execute(pset.Kernel(Update_lon), endtime=0.12, dt=0.02, output_file=ofile) + particle = get_default_particle(np.float64) + pset = ParticleSet(fieldset, pclass=particle, lon=[0], lat=[0]) + ofile = ParticleFile(tmp_zarrfile, outputdt=np.timedelta64(50, "ms")) + dt = np.timedelta64(20, "ms") + pset.execute(pset.Kernel(Update_lon), runtime=6 * dt, dt=dt, output_file=ofile) assert np.allclose(pset.lon, 0.6) -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_correct_misaligned_outputdt_dt(fieldset, mode, tmp_zarrfile): +@pytest.mark.v4alpha +@pytest.mark.xfail +def test_correct_misaligned_outputdt_dt(fieldset, tmp_zarrfile): """Testing that outputdt does not need to be a multiple of dt.""" - def Update_lon(particle, fieldset, time): # pragma: no cover - particle_dlon += particle.dt # noqa + def Update_lon(particles, fieldset): # pragma: no cover + particles.dlon += particles.dt / np.timedelta64(1, "s") - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=[0], lat=[0], lonlatdepth_dtype=np.float64) - ofile = pset.ParticleFile(name=tmp_zarrfile, outputdt=3) - pset.execute(pset.Kernel(Update_lon), endtime=11, dt=2, output_file=ofile) + particle = get_default_particle(np.float64) + pset = ParticleSet(fieldset, pclass=particle, lon=[0], lat=[0]) + ofile = ParticleFile(tmp_zarrfile, outputdt=np.timedelta64(3, "s")) + pset.execute(pset.Kernel(Update_lon), runtime=np.timedelta64(11, "s"), dt=np.timedelta64(2, "s"), output_file=ofile) ds = xr.open_zarr(tmp_zarrfile) assert np.allclose(ds.lon.values, [0, 3, 6, 9]) @@ -352,22 +332,19 @@ def Update_lon(particle, fieldset, time): # pragma: no cover ) -def setup_pset_execute(*, fieldset: FieldSet, outputdt: timedelta, execute_kwargs, particle_class=ScipyParticle): +def setup_pset_execute(*, fieldset: FieldSet, outputdt: timedelta, execute_kwargs, particle_class=Particle): npart = 10 - if fieldset is None: - fieldset = create_fieldset_zeros_simple() - pset = ParticleSet( fieldset, pclass=particle_class, - lon=np.full(npart, fieldset.U.lon.mean()), - lat=np.full(npart, fieldset.U.lat.mean()), + lon=np.full(npart, fieldset.U.data.lon.mean()), + lat=np.full(npart, fieldset.U.data.lat.mean()), ) with tempfile.TemporaryDirectory() as dir: name = f"{dir}/test.zarr" - output_file = pset.ParticleFile(name=name, outputdt=outputdt) + output_file = ParticleFile(name, outputdt=outputdt) pset.execute(DoNothing, output_file=output_file, **execute_kwargs) ds = xr.open_zarr(name).load() @@ -375,32 +352,30 @@ def setup_pset_execute(*, fieldset: FieldSet, outputdt: timedelta, execute_kwarg return ds -def test_pset_execute_outputdt_forwards(): +def test_pset_execute_outputdt_forwards(fieldset): """Testing output data dt matches outputdt in forward time.""" outputdt = timedelta(hours=1) runtime = timedelta(hours=5) dt = timedelta(minutes=5) - ds = setup_pset_execute( - fieldset=create_fieldset_zeros_simple(), outputdt=outputdt, execute_kwargs=dict(runtime=runtime, dt=dt) - ) + ds = setup_pset_execute(fieldset=fieldset, outputdt=outputdt, execute_kwargs=dict(runtime=runtime, dt=dt)) assert np.all(ds.isel(trajectory=0).time.diff(dim="obs").values == np.timedelta64(outputdt)) -def test_pset_execute_outputdt_backwards(): +@pytest.mark.skip(reason="backwards in time not yet working") +def test_pset_execute_outputdt_backwards(fieldset): """Testing output data dt matches outputdt in backwards time.""" outputdt = timedelta(hours=1) runtime = timedelta(days=2) dt = -timedelta(minutes=5) - ds = setup_pset_execute( - fieldset=create_fieldset_zeros_simple(), outputdt=outputdt, execute_kwargs=dict(runtime=runtime, dt=dt) - ) + ds = setup_pset_execute(fieldset=fieldset, outputdt=outputdt, execute_kwargs=dict(runtime=runtime, dt=dt)) file_outputdt = ds.isel(trajectory=0).time.diff(dim="obs").values assert np.all(file_outputdt == np.timedelta64(-outputdt)) +@pytest.mark.xfail(reason="TODO v4: Update dataset loading") def test_pset_execute_outputdt_backwards_fieldset_timevarying(): """test_pset_execute_outputdt_backwards() still passed despite #1722 as it doesn't account for time-varying fields, which for some reason #1722 @@ -411,8 +386,99 @@ def test_pset_execute_outputdt_backwards_fieldset_timevarying(): # TODO: Not ideal using the `download_example_dataset` here, but I'm struggling to recreate this error using the test suite fieldsets we have example_dataset_folder = parcels.download_example_dataset("MovingEddies_data") - fieldset = parcels.FieldSet.from_parcels(f"{example_dataset_folder}/moving_eddies") + filenames = { + "U": str(example_dataset_folder / "moving_eddiesU.nc"), + "V": str(example_dataset_folder / "moving_eddiesV.nc"), + } + variables = {"U": "vozocrtx", "V": "vomecrty"} + dimensions = {"lon": "nav_lon", "lat": "nav_lat", "time": "time_counter"} + fieldset = parcels.FieldSet.from_netcdf(filenames, variables, dimensions) ds = setup_pset_execute(outputdt=outputdt, execute_kwargs=dict(runtime=runtime, dt=dt), fieldset=fieldset) file_outputdt = ds.isel(trajectory=0).time.diff(dim="obs").values assert np.all(file_outputdt == np.timedelta64(-outputdt)), (file_outputdt, np.timedelta64(-outputdt)) + + +def test_particlefile_init(tmp_store): + ParticleFile(tmp_store, outputdt=np.timedelta64(1, "s"), chunks=(1, 3)) + + +@pytest.mark.parametrize("name", ["store", "outputdt", "chunks", "create_new_zarrfile"]) +def test_particlefile_readonly_attrs(tmp_store, name): + pfile = ParticleFile(tmp_store, outputdt=np.timedelta64(1, "s"), chunks=(1, 3)) + with pytest.raises(AttributeError, match="property .* of 'ParticleFile' object has no setter"): + setattr(pfile, name, "something") + + +def test_particlefile_init_invalid(tmp_store): # TODO: Add test for read only store + with pytest.raises(ValueError, match="chunks must be a tuple"): + ParticleFile(tmp_store, outputdt=np.timedelta64(1, "s"), chunks=1) + + +def test_particlefile_write_particle_data(tmp_store): + nparticles = 100 + + pfile = ParticleFile(tmp_store, outputdt=np.timedelta64(1, "s"), chunks=(nparticles, 40)) + pclass = Particle + + left, right = np.datetime64("2019-05-30T12:00:00.000000000", "ns"), np.datetime64("2020-01-02", "ns") + time_interval = TimeInterval(left=left, right=right) + + initial_lon = np.linspace(0, 1, nparticles) + data = create_particle_data( + pclass=pclass, + nparticles=nparticles, + ngrids=4, + time_interval=time_interval, + initial={ + "time": np.full(nparticles, fill_value=left), + "time_nextloop": np.full(nparticles, fill_value=left), + "lon": initial_lon, + "dt": np.full(nparticles, fill_value=1.0), + "trajectory": np.arange(nparticles), + }, + ) + np.testing.assert_array_equal(data["time"], left) + pfile._write_particle_data( + particle_data=data, + pclass=pclass, + time_interval=time_interval, + time=left, + ) + ds = xr.open_zarr(tmp_store, decode_cf=False) # TODO v4: Fix metadata and re-enable decode_cf + # assert ds.time.dtype == "datetime64[ns]" + # np.testing.assert_equal(ds["time"].isel(obs=0).values, left) + assert ds.sizes["trajectory"] == nparticles + np.testing.assert_allclose(ds["lon"].isel(obs=0).values, initial_lon) + + +def test_pfile_write_custom_particle(): + # Test the writing of a custom particle with variables that are to_write, some to_write once, and some not to_write + # ? This is more of an integration test... Should it be housed here? + ... + + +@pytest.mark.xfail( + reason="set_variable_write_status should be removed - with Particle writing defined on the particle level. GH2186" +) +def test_pfile_set_towrite_False(fieldset, tmp_zarrfile): + npart = 10 + pset = ParticleSet(fieldset, pclass=Particle, lon=np.linspace(0, 1, npart), lat=0.5 * np.ones(npart)) + pset.set_variable_write_status("depth", False) + pset.set_variable_write_status("lat", False) + pfile = pset.ParticleFile(tmp_zarrfile, outputdt=1) + + def Update_lon(particles, fieldset): # pragma: no cover + particles.dlon += 0.1 + + pset.execute(Update_lon, runtime=10, output_file=pfile) + + ds = xr.open_zarr(tmp_zarrfile) + assert "time" in ds + assert "z" not in ds + assert "lat" not in ds + ds.close() + + # For pytest purposes, we need to reset to original status + pset.set_variable_write_status("depth", True) + pset.set_variable_write_status("lat", True) diff --git a/tests/test_particleset.py b/tests/test_particleset.py new file mode 100644 index 000000000..3f18b0294 --- /dev/null +++ b/tests/test_particleset.py @@ -0,0 +1,189 @@ +from contextlib import nullcontext as does_not_raise +from datetime import datetime, timedelta +from operator import attrgetter + +import numpy as np +import pytest +import xarray as xr + +from parcels import ( + Field, + FieldSet, + Particle, + ParticleSet, + ParticleSetWarning, + Variable, + XGrid, +) +from parcels._datasets.structured.generic import datasets as datasets_structured +from tests.common_kernels import DoNothing +from tests.utils import round_and_hash_float_array + + +@pytest.fixture +def fieldset() -> FieldSet: + ds = datasets_structured["ds_2d_left"] + grid = XGrid.from_dataset(ds, mesh="flat") + U = Field("U", ds["U (A grid)"], grid) + V = Field("V", ds["V (A grid)"], grid) + return FieldSet([U, V]) + + +def test_pset_create_lon_lat(fieldset): + npart = 100 + lon = np.linspace(0, 1, npart, dtype=np.float32) + lat = np.linspace(1, 0, npart, dtype=np.float32) + pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=Particle) + assert np.allclose([p.lon for p in pset], lon, rtol=1e-12) + assert np.allclose([p.lat for p in pset], lat, rtol=1e-12) + + +def test_create_empty_pset(fieldset): + pset = ParticleSet(fieldset, pclass=Particle) + assert pset.size == 0 + + pset.execute(DoNothing, endtime=1.0, dt=1.0) + assert pset.size == 0 + + +@pytest.mark.parametrize("offset", [0, 1, 200]) +def test_pset_with_pids(fieldset, offset, npart=100): + lon = np.linspace(0, 1, npart) + lat = np.linspace(1, 0, npart) + trajectory_ids = np.arange(offset, npart + offset) + pset = ParticleSet(fieldset, lon=lon, lat=lat, trajectory_ids=trajectory_ids) + assert np.allclose([p.trajectory for p in pset], trajectory_ids, atol=1e-12) + + +@pytest.mark.parametrize("aslist", [True, False]) +def test_pset_customvars_on_pset(fieldset, aslist): + if aslist: + MyParticle = Particle.add_variable([Variable("sample_var"), Variable("sample_var2")]) + pset = ParticleSet(fieldset, lon=0, lat=0, pclass=MyParticle, sample_var=5.0, sample_var2=10.0) + else: + MyParticle = Particle.add_variable(Variable("sample_var")) + pset = ParticleSet(fieldset, lon=0, lat=0, pclass=MyParticle, sample_var=5.0) + + pset.execute(DoNothing, dt=np.timedelta64(1, "s"), runtime=np.timedelta64(21, "s")) + assert np.allclose([p.sample_var for p in pset], 5.0) + if aslist: + assert np.allclose([p.sample_var2 for p in pset], 10.0) + + +def test_pset_custominit_on_pset_attrgetter(fieldset): + MyParticle = Particle.add_variable(Variable("sample_var", initial=attrgetter("lon"))) + + pset = ParticleSet(fieldset, lon=3, lat=0, pclass=MyParticle) + + pset.execute(DoNothing, dt=np.timedelta64(1, "s"), runtime=np.timedelta64(21, "s")) + assert np.allclose([p.sample_var for p in pset], 3.0) + + +@pytest.mark.parametrize("pset_override", [True, False]) +def test_pset_custominit_on_pclass(fieldset, pset_override): + MyParticle = Particle.add_variable(Variable("sample_var", initial=4)) + + if pset_override: + pset = ParticleSet(fieldset, lon=0, lat=0, pclass=MyParticle, sample_var=5) + else: + pset = ParticleSet(fieldset, lon=0, lat=0, pclass=MyParticle) + + pset.execute(DoNothing, dt=np.timedelta64(1, "s"), runtime=np.timedelta64(21, "s")) + + check_val = 5.0 if pset_override else 4.0 + assert np.allclose([p.sample_var for p in pset], check_val) + + +@pytest.mark.parametrize( + "time, expectation", + [ + (np.timedelta64(0, "s"), does_not_raise()), + (np.datetime64("2000-01-02T00:00:00"), does_not_raise()), + (0.0, pytest.raises(TypeError)), + (timedelta(seconds=0), pytest.raises(TypeError)), + (datetime(2023, 1, 1, 0, 0, 0), pytest.raises(TypeError)), + ], +) +def test_particleset_init_time_type(fieldset, time, expectation): + with expectation: + ParticleSet(fieldset, lon=[0.2], lat=[5.0], time=[time], pclass=Particle) + + +def test_pset_create_outside_time(fieldset): + time = xr.date_range("1999", "2001", 20) + with pytest.warns(ParticleSetWarning, match="Some particles are set to be released*"): + ParticleSet(fieldset, pclass=Particle, lon=[0] * len(time), lat=[0] * len(time), time=time) + + +def test_pset_starttime_not_multiple_dt(fieldset): + times = [0, 1, 2] + datetimes = [fieldset.time_interval.left + np.timedelta64(t, "s") for t in times] + pset = ParticleSet(fieldset, lon=[0] * len(times), lat=[0] * len(times), pclass=Particle, time=datetimes) + + def Addlon(particles, fieldset): # pragma: no cover + particles.dlon += particles.dt / np.timedelta64(1, "s") + + pset.execute(Addlon, dt=np.timedelta64(2, "s"), runtime=np.timedelta64(8, "s"), verbose_progress=False) + assert np.allclose([p.lon + p.dlon for p in pset], [8 - t for t in times]) + + +def test_populate_indices(fieldset): + npart = 11 + pset = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) + pset.populate_indices() + np.testing.assert_equal(round_and_hash_float_array(pset.ei, decimals=0), 935996932384571063274191) + + +def test_pset_add_explicit(fieldset): + npart = 11 + lon = np.linspace(0, 1, npart) + lat = np.linspace(1, 0, npart) + pset = ParticleSet(fieldset, lon=lon[0], lat=lat[0], pclass=Particle) + for i in range(1, npart): + particle = ParticleSet(pclass=Particle, lon=lon[i], lat=lat[i], fieldset=fieldset) + pset.add(particle) + assert len(pset) == npart + assert np.allclose([p.lon for p in pset], lon, atol=1e-12) + assert np.allclose([p.lat for p in pset], lat, atol=1e-12) + assert np.allclose(np.diff(pset._data["trajectory"]), np.ones(pset._data["trajectory"].size - 1), atol=1e-12) + + +def test_pset_add_implicit(fieldset): + pset = ParticleSet(fieldset, lon=np.zeros(3), lat=np.ones(3), pclass=Particle) + pset += ParticleSet(fieldset, lon=np.ones(4), lat=np.zeros(4), pclass=Particle) + assert len(pset) == 7 + assert np.allclose(np.diff(pset._data["trajectory"]), np.ones(6), atol=1e-12) + + +def test_pset_add_implicit_in_loop(fieldset, npart=10): + pset = ParticleSet(fieldset, lon=[], lat=[]) + for _ in range(npart): + pset += ParticleSet(pclass=Particle, lon=0.1, lat=0.1, fieldset=fieldset) + assert pset.size == npart + + +def test_pset_merge_inplace(fieldset, npart=100): + pset1 = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) + pset2 = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.linspace(0, 1, npart)) + assert pset1.size == npart + assert pset2.size == npart + pset1.add(pset2) + assert pset1.size == 2 * npart + + +def test_pset_remove_index(fieldset, npart=100): + lon = np.linspace(0, 1, npart) + lat = np.linspace(1, 0, npart) + pset = ParticleSet(fieldset, lon=lon, lat=lat) + indices_to_remove = [0, 10, 20] + pset.remove_indices(indices_to_remove) + assert pset.size == 97 + assert not np.any(np.isin(pset.trajectory, indices_to_remove)) + + +def test_pset_iterator(fieldset): + npart = 10 + pset = ParticleSet(fieldset, lon=np.zeros(npart), lat=np.ones(npart)) + for i, particle in enumerate(pset): + assert particle.trajectory == i + assert i == npart - 1 diff --git a/tests/test_particleset_execute.py b/tests/test_particleset_execute.py new file mode 100644 index 000000000..0aacb1a2d --- /dev/null +++ b/tests/test_particleset_execute.py @@ -0,0 +1,524 @@ +from contextlib import nullcontext as does_not_raise +from datetime import datetime, timedelta + +import numpy as np +import pytest + +from parcels import ( + Field, + FieldInterpolationError, + FieldOutOfBoundError, + FieldSet, + Particle, + ParticleFile, + ParticleSet, + StatusCode, + TimeExtrapolationError, + UxGrid, + Variable, + VectorField, + XGrid, +) +from parcels._datasets.structured.generated import simple_UV_dataset +from parcels._datasets.structured.generic import datasets as datasets_structured +from parcels._datasets.unstructured.generic import datasets as datasets_unstructured +from parcels.interpolators import UXPiecewiseConstantFace +from parcels.kernels import AdvectionEE +from tests import utils +from tests.common_kernels import DoNothing + + +@pytest.fixture +def fieldset() -> FieldSet: + ds = datasets_structured["ds_2d_left"] + grid = XGrid.from_dataset(ds, mesh="flat") + U = Field("U", ds["U (A grid)"], grid) + V = Field("V", ds["V (A grid)"], grid) + UV = VectorField("UV", U, V) + return FieldSet([U, V, UV]) + + +@pytest.fixture +def fieldset_no_time_interval() -> FieldSet: + # i.e., no time variation + ds = datasets_structured["ds_2d_left"].isel(time=0).drop_vars("time") + + grid = XGrid.from_dataset(ds, mesh="flat") + U = Field("U", ds["U (A grid)"], grid) + V = Field("V", ds["V (A grid)"], grid) + UV = VectorField("UV", U, V) + return FieldSet([U, V, UV]) + + +@pytest.fixture +def zonal_flow_fieldset() -> FieldSet: + ds = simple_UV_dataset(mesh="flat") + ds["U"].data[:] = 1.0 + grid = XGrid.from_dataset(ds, mesh="flat") + U = Field("U", ds["U"], grid) + V = Field("V", ds["V"], grid) + UV = VectorField("UV", U, V) + return FieldSet([U, V, UV]) + + +def test_pset_execute_implicit_dt_one_second(fieldset): + pset = ParticleSet(fieldset, lon=[0.2], lat=[5.0], pclass=Particle) + pset.execute(DoNothing, runtime=np.timedelta64(1, "s")) + + time = pset.time.copy() + + pset.execute(DoNothing, runtime=np.timedelta64(1, "s")) + np.testing.assert_array_equal(pset.time, time + np.timedelta64(1, "s")) + + +def test_pset_execute_invalid_arguments(fieldset, fieldset_no_time_interval): + for dt in [1, np.timedelta64(0, "s"), np.timedelta64(None)]: + with pytest.raises( + ValueError, + match="dt must be a non-zero datetime.timedelta or np.timedelta64 object, got .*", + ): + ParticleSet(fieldset, lon=[0.2], lat=[5.0], pclass=Particle).execute(dt=dt) + + with pytest.raises( + ValueError, + match="runtime and endtime are mutually exclusive - provide one or the other. Got .*", + ): + ParticleSet(fieldset, lon=[0.2], lat=[5.0], pclass=Particle).execute( + runtime=np.timedelta64(1, "s"), endtime=np.datetime64("2100-01-01") + ) + + with pytest.raises( + ValueError, + match="The runtime must be a datetime.timedelta or np.timedelta64 object. Got .*", + ): + ParticleSet(fieldset, lon=[0.2], lat=[5.0], pclass=Particle).execute(runtime=1) + + msg = """Calculated/provided end time of .* is not in fieldset time interval .* Either reduce your runtime, modify your provided endtime, or change your release timing.*""" + with pytest.raises( + ValueError, + match=msg, + ): + ParticleSet(fieldset, lon=[0.2], lat=[5.0], pclass=Particle).execute(endtime=np.datetime64("1990-01-01")) + + with pytest.raises( + ValueError, + match=msg, + ): + ParticleSet(fieldset, lon=[0.2], lat=[5.0], pclass=Particle).execute( + endtime=np.datetime64("2100-01-01"), dt=np.timedelta64(-1, "s") + ) + + with pytest.raises( + ValueError, + match="The endtime must be of the same type as the fieldset.time_interval start time. Got .*", + ): + ParticleSet(fieldset, lon=[0.2], lat=[5.0], pclass=Particle).execute(endtime=12345) + + with pytest.raises( + ValueError, + match="The runtime must be provided when the time_interval is not defined for a fieldset.", + ): + ParticleSet(fieldset_no_time_interval, lon=[0.2], lat=[5.0], pclass=Particle).execute() + + +@pytest.mark.parametrize( + "runtime, expectation", + [ + (np.timedelta64(5, "s"), does_not_raise()), + (timedelta(seconds=2), does_not_raise()), + (5.0, pytest.raises(ValueError)), + (np.datetime64("2001-01-02T00:00:00"), pytest.raises(ValueError)), + (datetime(2000, 1, 2, 0, 0, 0), pytest.raises(ValueError)), + ], +) +def test_particleset_runtime_type(fieldset, runtime, expectation): + pset = ParticleSet(fieldset, lon=[0.2], lat=[5.0], depth=[50.0], pclass=Particle) + with expectation: + pset.execute(runtime=runtime, dt=np.timedelta64(10, "s"), pyfunc=DoNothing) + + +@pytest.mark.parametrize( + "endtime, expectation", + [ + (np.datetime64("2000-01-02T00:00:00"), does_not_raise()), + (5.0, pytest.raises(ValueError)), + (np.timedelta64(5, "s"), pytest.raises(ValueError)), + (timedelta(seconds=2), pytest.raises(ValueError)), + (datetime(2000, 1, 2, 0, 0, 0), pytest.raises(ValueError)), + ], +) +def test_particleset_endtime_type(fieldset, endtime, expectation): + pset = ParticleSet(fieldset, lon=[0.2], lat=[5.0], depth=[50.0], pclass=Particle) + with expectation: + pset.execute(endtime=endtime, dt=np.timedelta64(10, "m"), pyfunc=DoNothing) + + +@pytest.mark.parametrize( + "dt", [np.timedelta64(1, "s"), np.timedelta64(1, "ms"), np.timedelta64(10, "ms"), np.timedelta64(1, "ns")] +) +def test_pset_execute_subsecond_dt(fieldset, dt): + def AddDt(particles, fieldset): # pragma: no cover + dt = particles.dt / np.timedelta64(1, "s") + particles.added_dt += dt + + pclass = Particle.add_variable(Variable("added_dt", dtype=np.float32, initial=0)) + pset = ParticleSet(fieldset, pclass=pclass, lon=0, lat=0) + pset.update_dt_dtype(dt.dtype) + pset.execute(AddDt, runtime=dt * 10, dt=dt) + np.testing.assert_allclose(pset[0].added_dt, 10.0 * dt / np.timedelta64(1, "s"), atol=1e-5) + + +def test_pset_execute_subsecond_dt_error(fieldset): + pset = ParticleSet(fieldset, lon=0, lat=0) + with pytest.raises(ValueError, match="The dtype of dt"): + pset.execute(DoNothing, runtime=np.timedelta64(10, "ms"), dt=np.timedelta64(1, "ms")) + + +def test_pset_remove_particle_in_kernel(fieldset): + npart = 100 + pset = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) + + def DeleteKernel(particles, fieldset): # pragma: no cover + particles.state = np.where((particles.lon >= 0.4) & (particles.lon <= 0.6), StatusCode.Delete, particles.state) + + pset.execute(pset.Kernel(DeleteKernel), runtime=np.timedelta64(1, "s"), dt=np.timedelta64(1, "s")) + indices = [i for i in range(npart) if not (40 <= i < 60)] + assert [p.trajectory for p in pset] == indices + assert pset[70].trajectory == 90 + assert pset[-1].trajectory == npart - 1 + assert pset.size == 80 + + +@pytest.mark.parametrize("npart", [1, 100]) +def test_pset_stop_simulation(fieldset, npart): + pset = ParticleSet(fieldset, lon=np.zeros(npart), lat=np.zeros(npart), pclass=Particle) + + def Delete(particles, fieldset): # pragma: no cover + particles[ + particles.time >= fieldset.time_interval.left + np.timedelta64(4, "s") + ].state = StatusCode.StopExecution + + pset.execute(Delete, dt=np.timedelta64(1, "s"), runtime=np.timedelta64(21, "s")) + assert pset[0].time == fieldset.time_interval.left + np.timedelta64(4, "s") + + +@pytest.mark.parametrize("with_delete", [True, False]) +def test_pset_multi_execute(fieldset, with_delete, npart=10, n=5): + pset = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.zeros(npart)) + + def AddLat(particles, fieldset): # pragma: no cover + particles.dlat += 0.1 + + k_add = pset.Kernel(AddLat) + for _ in range(n + 1): + pset.execute(k_add, runtime=np.timedelta64(1, "s"), dt=np.timedelta64(1, "s")) + if with_delete: + pset.remove_indices(len(pset) - 1) + if with_delete: + assert np.allclose(pset.lat, n * 0.1, atol=1e-12) + else: + assert np.allclose([p.lat - n * 0.1 for p in pset], np.zeros(npart), rtol=1e-12) + + +@pytest.mark.parametrize( + "starttime, endtime, dt", + [(0, 10, 1), (0, 10, 3), (2, 16, 3), (20, 10, -1), (20, 0, -2), (5, 15, None)], +) +def test_execution_endtime(fieldset, starttime, endtime, dt): + starttime = fieldset.time_interval.left + np.timedelta64(starttime, "s") + endtime = fieldset.time_interval.left + np.timedelta64(endtime, "s") + if dt is not None: + dt = np.timedelta64(dt, "s") + pset = ParticleSet(fieldset, time=starttime, lon=0, lat=0) + pset.execute(DoNothing, endtime=endtime, dt=dt) + assert abs(pset.time_nextloop - endtime) < np.timedelta64(1, "ms") + + +def test_dont_run_particles_outside_starttime(fieldset): + # Test forward in time (note third particle is outside endtime) + start_times = [fieldset.time_interval.left + np.timedelta64(t, "s") for t in [0, 2, 10]] + endtime = fieldset.time_interval.left + np.timedelta64(8, "s") + + def AddLon(particles, fieldset): # pragma: no cover + particles.lon += 1 + + pset = ParticleSet(fieldset, lon=np.zeros(len(start_times)), lat=np.zeros(len(start_times)), time=start_times) + pset.execute(AddLon, dt=np.timedelta64(1, "s"), endtime=endtime) + + np.testing.assert_array_equal(pset.lon, [8, 6, 0]) + assert pset.time_nextloop[0:1] == endtime + assert pset.time_nextloop[2] == start_times[2] # this particle has not been executed + + # Test backward in time (note third particle is outside endtime) + start_times = [fieldset.time_interval.right - np.timedelta64(t, "s") for t in [0, 2, 10]] + endtime = fieldset.time_interval.right - np.timedelta64(8, "s") + + pset = ParticleSet(fieldset, lon=np.zeros(len(start_times)), lat=np.zeros(len(start_times)), time=start_times) + pset.execute(AddLon, dt=-np.timedelta64(1, "s"), endtime=endtime) + + np.testing.assert_array_equal(pset.lon, [8, 6, 0]) + assert pset.time_nextloop[0:1] == endtime + assert pset.time_nextloop[2] == start_times[2] # this particle has not been executed + + +def test_some_particles_throw_outofbounds(zonal_flow_fieldset): + npart = 100 + lon = np.linspace(0, 9e5, npart) + pset = ParticleSet(zonal_flow_fieldset, lon=lon, lat=np.zeros_like(lon)) + + with pytest.raises(FieldOutOfBoundError): + pset.execute(AdvectionEE, runtime=np.timedelta64(1_000_000, "s"), dt=np.timedelta64(10_000, "s")) + + +def test_delete_on_all_errors(fieldset): + def MoveRight(particles, fieldset): # pragma: no cover + particles.dlon += 1 + fieldset.U[particles.time, particles.depth, particles.lat, particles.lon, particles] + + def DeleteAllErrorParticles(particles, fieldset): # pragma: no cover + particles[particles.state > 20].state = StatusCode.Delete + + pset = ParticleSet(fieldset, lon=[1e5, 2], lat=[0, 0]) + pset.execute([MoveRight, DeleteAllErrorParticles], runtime=np.timedelta64(10, "s"), dt=np.timedelta64(1, "s")) + assert len(pset) == 0 + + +def test_some_particles_throw_outoftime(fieldset): + time = [fieldset.time_interval.left + np.timedelta64(t, "D") for t in [0, 350]] + pset = ParticleSet(fieldset, lon=np.zeros_like(time), lat=np.zeros_like(time), time=time) + + def FieldAccessOutsideTime(particles, fieldset): # pragma: no cover + fieldset.U[particles.time + np.timedelta64(400, "D"), particles.depth, particles.lat, particles.lon, particles] + + with pytest.raises(TimeExtrapolationError): + pset.execute(FieldAccessOutsideTime, runtime=np.timedelta64(1, "D"), dt=np.timedelta64(10, "D")) + + +def test_raise_grid_searching_error(): ... + + +def test_raise_general_error(): ... + + +def test_errorinterpolation(fieldset): + def NaNInterpolator(field, ti, position, tau, t, z, y, x): # pragma: no cover + return np.nan * np.zeros_like(x) + + def SampleU(particles, fieldset): # pragma: no cover + fieldset.U[particles.time, particles.depth, particles.lat, particles.lon, particles] + + fieldset.U.interp_method = NaNInterpolator + pset = ParticleSet(fieldset, lon=[0, 2], lat=[0, 0]) + with pytest.raises(FieldInterpolationError): + pset.execute(SampleU, runtime=np.timedelta64(2, "s"), dt=np.timedelta64(1, "s")) + + +def test_execution_check_stopallexecution(fieldset): + def addoneLon(particles, fieldset): # pragma: no cover + particles.dlon += 1 + particles[particles.lon + particles.dlon >= 10].state = StatusCode.StopAllExecution + + pset = ParticleSet(fieldset, lon=[0, 0], lat=[0, 0]) + pset.execute(addoneLon, runtime=np.timedelta64(20, "s"), dt=np.timedelta64(1, "s")) + np.testing.assert_allclose(pset.lon, 9) + np.testing.assert_allclose(pset.time - fieldset.time_interval.left, np.timedelta64(9, "s")) + + +def test_execution_recover_out_of_bounds(fieldset): + npart = 2 + + def MoveRight(particles, fieldset): # pragma: no cover + fieldset.U[particles.time, particles.depth, particles.lat, particles.lon + 0.1, particles] + particles.dlon += 0.1 + + def MoveLeft(particles, fieldset): # pragma: no cover + inds = np.where(particles.state == StatusCode.ErrorOutOfBounds) + print(inds, particles.state) + particles[inds].dlon -= 1.0 + particles[inds].state = StatusCode.Success + + lon = np.linspace(0.05, 6.95, npart) + lat = np.linspace(1, 0, npart) + pset = ParticleSet(fieldset, lon=lon, lat=lat) + pset.execute([MoveRight, MoveLeft], runtime=np.timedelta64(61, "s"), dt=np.timedelta64(1, "s")) + assert len(pset) == npart + np.testing.assert_allclose(pset.lon, [6.05, 5.95], rtol=1e-5) + np.testing.assert_allclose(pset.lat, lat, rtol=1e-5) + + +@pytest.mark.parametrize( + "starttime, runtime, dt", + [(0, 10, 1), (0, 10, 3), (2, 16, 3), (20, 10, -1), (20, 0, -2), (5, 15, None)], +) +@pytest.mark.parametrize("npart", [1, 10]) +def test_execution_runtime(fieldset, starttime, runtime, dt, npart): + starttime = fieldset.time_interval.left + np.timedelta64(starttime, "s") + runtime = np.timedelta64(runtime, "s") + sign_dt = 1 if dt is None else np.sign(dt) + if dt is not None: + dt = np.timedelta64(dt, "s") + pset = ParticleSet(fieldset, time=starttime, lon=np.zeros(npart), lat=np.zeros(npart)) + pset.execute(DoNothing, runtime=runtime, dt=dt) + assert all([abs(p.time_nextloop - starttime - runtime * sign_dt) < np.timedelta64(1, "ms") for p in pset]) + + +def test_changing_dt_in_kernel(fieldset): + def KernelCounter(particles, fieldset): # pragma: no cover + particles.lon += 1 + + pset = ParticleSet(fieldset, lon=np.zeros(1), lat=np.zeros(1)) + pset.execute(KernelCounter, dt=np.timedelta64(2, "s"), runtime=np.timedelta64(5, "s")) + assert pset.lon == 3 + print(pset.dt) + assert pset.dt == np.timedelta64(2, "s") + + +@pytest.mark.parametrize("npart", [1, 100]) +def test_execution_fail_python_exception(fieldset, npart): + pset = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) + + def PythonFail(particles, fieldset): # pragma: no cover + inds = np.argwhere(particles.time >= fieldset.time_interval.left + np.timedelta64(10, "s")) + if inds.size > 0: + raise RuntimeError("Enough is enough!") + + with pytest.raises(RuntimeError): + pset.execute(PythonFail, runtime=np.timedelta64(20, "s"), dt=np.timedelta64(2, "s")) + assert len(pset) == npart + assert all(pset.time == fieldset.time_interval.left + np.timedelta64(10, "s")) + + +@pytest.mark.parametrize( + "kernel_names, expected", + [ + ("Lat1", [0, 1]), + ("Lat2", [2, 0]), + pytest.param( + "Lat1and2", + [2, 1], + marks=pytest.mark.xfail( + reason="Will be fixed alongside GH #2143 . Failing due to https://github.com/OceanParcels/Parcels/pull/2199#issuecomment-3285278876." + ), + ), + ("Lat1then2", [2, 1]), + ], +) +def test_execution_update_particle_in_kernel_function(fieldset, kernel_names, expected): + npart = 2 + + pset = ParticleSet(fieldset, lon=np.linspace(0, 1, npart), lat=np.zeros(npart)) + + def Lat1(particles, fieldset): # pragma: no cover + def SetLat1(p): + p.lat = 1 + + SetLat1(particles[(particles.lat == 0) & (particles.lon > 0.5)]) + + def Lat2(particles, fieldset): # pragma: no cover + def SetLat2(p): + p.lat = 2 + + SetLat2(particles[(particles.lat == 0) & (particles.lon < 0.5)]) + + def Lat1and2(particles, fieldset): # pragma: no cover + def SetLat1(p): + p.lat = 1 + + def SetLat2(p): + p.lat = 2 + + SetLat1(particles[(particles.lat == 0) & (particles.lon > 0.5)]) + SetLat2(particles[(particles.lat == 0) & (particles.lon < 0.5)]) + + if kernel_names == "Lat1": + kernels = [Lat1] + elif kernel_names == "Lat2": + kernels = [Lat2] + elif kernel_names == "Lat1and2": + kernels = [Lat1and2] + elif kernel_names == "Lat1then2": + kernels = [Lat1, Lat2] + + pset.execute(kernels, runtime=np.timedelta64(2, "s"), dt=np.timedelta64(1, "s")) + np.testing.assert_allclose(pset.lat, expected, rtol=1e-5) + + +def test_uxstommelgyre_pset_execute(): + ds = datasets_unstructured["stommel_gyre_delaunay"] + grid = UxGrid(grid=ds.uxgrid, z=ds.coords["nz"], mesh="spherical") + U = Field( + name="U", + data=ds.U, + grid=grid, + interp_method=UXPiecewiseConstantFace, + ) + V = Field( + name="V", + data=ds.V, + grid=grid, + interp_method=UXPiecewiseConstantFace, + ) + P = Field( + name="P", + data=ds.p, + grid=grid, + interp_method=UXPiecewiseConstantFace, + ) + UV = VectorField(name="UV", U=U, V=V) + fieldset = FieldSet([UV, UV.U, UV.V, P]) + pset = ParticleSet( + fieldset, + lon=[30.0], + lat=[5.0], + depth=[50.0], + time=[np.timedelta64(0, "s")], + pclass=Particle, + ) + pset.execute( + runtime=np.timedelta64(10, "m"), + dt=np.timedelta64(60, "s"), + pyfunc=AdvectionEE, + ) + assert utils.round_and_hash_float_array([p.lon for p in pset]) == 1165396086 + assert utils.round_and_hash_float_array([p.lat for p in pset]) == 1142124776 + + +@pytest.mark.xfail(reason="Output file not implemented yet") +def test_uxstommelgyre_pset_execute_output(): + ds = datasets_unstructured["stommel_gyre_delaunay"] + grid = UxGrid(grid=ds.uxgrid, z=ds.coords["nz"], mesh="spherical") + U = Field( + name="U", + data=ds.U, + grid=grid, + interp_method=UXPiecewiseConstantFace, + ) + V = Field( + name="V", + data=ds.V, + grid=grid, + interp_method=UXPiecewiseConstantFace, + ) + P = Field( + name="P", + data=ds.p, + grid=grid, + interp_method=UXPiecewiseConstantFace, + ) + UV = VectorField(name="UV", U=U, V=V) + fieldset = FieldSet([UV, UV.U, UV.V, P]) + pset = ParticleSet( + fieldset, + lon=[30.0], + lat=[5.0], + depth=[50.0], + time=[0.0], + pclass=Particle, + ) + output_file = ParticleFile( + name="stommel_uxarray_particles.zarr", # the file name + outputdt=np.timedelta64(5, "m"), # the time step of the outputs + ) + pset.execute( + runtime=np.timedelta64(10, "m"), dt=np.timedelta64(60, "s"), pyfunc=AdvectionEE, output_file=output_file + ) diff --git a/tests/test_particlesets.py b/tests/test_particlesets.py deleted file mode 100644 index 2237c262f..000000000 --- a/tests/test_particlesets.py +++ /dev/null @@ -1,453 +0,0 @@ -import numpy as np -import pytest - -from parcels import ( - CurvilinearZGrid, - Field, - FieldSet, - JITParticle, - ParticleSet, - ParticleSetWarning, - ScipyParticle, - StatusCode, - Variable, -) -from tests.common_kernels import DoNothing -from tests.utils import create_fieldset_zeros_simple - -ptype = {"scipy": ScipyParticle, "jit": JITParticle} - - -@pytest.fixture -def fieldset(): - return create_fieldset_zeros_simple() - - -@pytest.fixture -def pset(fieldset): - npart = 10 - pset = ParticleSet(fieldset, pclass=JITParticle, lon=np.linspace(0, 1, npart), lat=np.zeros(npart)) - return pset - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_create_lon_lat(fieldset, mode): - npart = 100 - lon = np.linspace(0, 1, npart, dtype=np.float32) - lat = np.linspace(1, 0, npart, dtype=np.float32) - pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=ptype[mode]) - assert np.allclose([p.lon for p in pset], lon, rtol=1e-12) - assert np.allclose([p.lat for p in pset], lat, rtol=1e-12) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("lonlatdepth_dtype", [np.float64, np.float32]) -def test_pset_create_line(fieldset, mode, lonlatdepth_dtype): - npart = 100 - lon = np.linspace(0, 1, npart, dtype=lonlatdepth_dtype) - lat = np.linspace(1, 0, npart, dtype=lonlatdepth_dtype) - pset = ParticleSet.from_line( - fieldset, size=npart, start=(0, 1), finish=(1, 0), pclass=ptype[mode], lonlatdepth_dtype=lonlatdepth_dtype - ) - assert np.allclose([p.lon for p in pset], lon, rtol=1e-12) - assert np.allclose([p.lat for p in pset], lat, rtol=1e-12) - assert isinstance(pset[0].lat, lonlatdepth_dtype) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_create_empty_pset(fieldset, mode): - pset = ParticleSet(fieldset, pclass=ptype[mode]) - assert pset.size == 0 - - pset.execute(DoNothing, endtime=1.0, dt=1.0) - assert pset.size == 0 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_create_list_with_customvariable(fieldset, mode): - npart = 100 - lon = np.linspace(0, 1, npart, dtype=np.float32) - lat = np.linspace(1, 0, npart, dtype=np.float32) - - MyParticle = ptype[mode].add_variable("v") - - v_vals = np.arange(npart) - pset = ParticleSet.from_list(fieldset, lon=lon, lat=lat, v=v_vals, pclass=MyParticle) - assert np.allclose([p.lon for p in pset], lon, rtol=1e-12) - assert np.allclose([p.lat for p in pset], lat, rtol=1e-12) - assert np.allclose([p.v for p in pset], v_vals, rtol=1e-12) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -@pytest.mark.parametrize("restart", [True, False]) -def test_pset_create_fromparticlefile(fieldset, mode, restart, tmp_zarrfile): - lon = np.linspace(0, 1, 10, dtype=np.float32) - lat = np.linspace(1, 0, 10, dtype=np.float32) - - TestParticle = ptype[mode].add_variable("p", np.float32, initial=0.33) - TestParticle = TestParticle.add_variable("p2", np.float32, initial=1, to_write=False) - TestParticle = TestParticle.add_variable("p3", np.float64, to_write="once") - - pset = ParticleSet(fieldset, lon=lon, lat=lat, depth=[4] * len(lon), pclass=TestParticle, p3=np.arange(len(lon))) - pfile = pset.ParticleFile(tmp_zarrfile, outputdt=1) - - def Kernel(particle, fieldset, time): # pragma: no cover - particle.p = 2.0 - if particle.lon == 1.0: - particle.delete() - - pset.execute(Kernel, runtime=2, dt=1, output_file=pfile) - - pset_new = ParticleSet.from_particlefile( - fieldset, pclass=TestParticle, filename=tmp_zarrfile, restart=restart, repeatdt=1 - ) - - for var in ["lon", "lat", "depth", "time", "p", "p2", "p3"]: - assert np.allclose([getattr(p, var) for p in pset], [getattr(p, var) for p in pset_new]) - - if restart: - assert np.allclose([p.id for p in pset], [p.id for p in pset_new]) - pset_new.execute(Kernel, runtime=2, dt=1) - assert len(pset_new) == 3 * len(pset) - assert pset[0].p3.dtype == np.float64 - - -@pytest.mark.parametrize("mode", ["scipy"]) -@pytest.mark.parametrize("lonlatdepth_dtype", [np.float64, np.float32]) -def test_pset_create_field(fieldset, mode, lonlatdepth_dtype): - npart = 100 - np.random.seed(123456) - shape = (fieldset.U.lon.size, fieldset.U.lat.size) - K = Field("K", lon=fieldset.U.lon, lat=fieldset.U.lat, data=np.ones(shape, dtype=np.float32), transpose=True) - pset = ParticleSet.from_field( - fieldset, size=npart, pclass=ptype[mode], start_field=K, lonlatdepth_dtype=lonlatdepth_dtype - ) - assert (np.array([p.lon for p in pset]) <= K.lon[-1]).all() - assert (np.array([p.lon for p in pset]) >= K.lon[0]).all() - assert (np.array([p.lat for p in pset]) <= K.lat[-1]).all() - assert (np.array([p.lat for p in pset]) >= K.lat[0]).all() - assert isinstance(pset[0].lat, lonlatdepth_dtype) - - -def test_pset_create_field_curvi(): - npart = 100 - np.random.seed(123456) - r_v = np.linspace(0.25, 2, 20) - theta_v = np.linspace(0, np.pi / 2, 200) - dtheta = theta_v[1] - theta_v[0] - dr = r_v[1] - r_v[0] - (r, theta) = np.meshgrid(r_v, theta_v) - - x = -1 + r * np.cos(theta) - y = -1 + r * np.sin(theta) - grid = CurvilinearZGrid(x, y) - - u = np.ones(x.shape) - v = np.where(np.logical_and(theta > np.pi / 4, theta < np.pi / 3), 1, 0) - - ufield = Field("U", u, grid=grid) - vfield = Field("V", v, grid=grid) - fieldset = FieldSet(ufield, vfield) - pset = ParticleSet.from_field(fieldset, size=npart, pclass=ptype["scipy"], start_field=fieldset.V) - - lons = np.array([p.lon + 1 for p in pset]) - lats = np.array([p.lat + 1 for p in pset]) - thetas = np.arctan2(lats, lons) - rs = np.sqrt(lons * lons + lats * lats) - - test = np.pi / 4 - dtheta < thetas - test *= thetas < np.pi / 3 + dtheta - test *= rs > 0.25 - dr - test *= rs < 2 + dr - assert np.all(test) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_create_with_time(fieldset, mode): - npart = 100 - lon = np.linspace(0, 1, npart) - lat = np.linspace(1, 0, npart) - time = 5.0 - pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=ptype[mode], time=time) - assert np.allclose([p.time for p in pset], time, rtol=1e-12) - pset = ParticleSet.from_list(fieldset, lon=lon, lat=lat, pclass=ptype[mode], time=[time] * npart) - assert np.allclose([p.time for p in pset], time, rtol=1e-12) - pset = ParticleSet.from_line(fieldset, size=npart, start=(0, 1), finish=(1, 0), pclass=ptype[mode], time=time) - assert np.allclose([p.time for p in pset], time, rtol=1e-12) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_create_outside_time(mode): - fieldset = create_fieldset_zeros_simple(withtime=True) - time = [-1, 0, 1, 20 * 86400] - with pytest.warns(ParticleSetWarning, match="Some particles are set to be released*"): - ParticleSet(fieldset, pclass=ptype[mode], lon=[0] * len(time), lat=[0] * len(time), time=time) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_not_multipldt_time(fieldset, mode): - times = [0, 1.1] - pset = ParticleSet(fieldset, lon=[0] * 2, lat=[0] * 2, pclass=ptype[mode], time=times) - - def Addlon(particle, fieldset, time): # pragma: no cover - particle_dlon += particle.dt # noqa - - pset.execute(Addlon, dt=1, runtime=2) - assert np.allclose([p.lon_nextloop for p in pset], [2 - t for t in times]) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_repeated_release(fieldset, mode): - npart = 10 - time = np.arange(0, npart, 1) # release 1 particle every second - pset = ParticleSet(fieldset, lon=np.zeros(npart), lat=np.zeros(npart), pclass=ptype[mode], time=time) - assert np.allclose([p.time for p in pset], time) - - def IncrLon(particle, fieldset, time): # pragma: no cover - particle_dlon += 1.0 # noqa - - pset.execute(IncrLon, dt=1.0, runtime=npart + 1) - assert np.allclose([p.lon for p in pset], np.arange(npart, 0, -1)) - - -def test_pset_repeatdt_check_dt(fieldset): - pset = ParticleSet(fieldset, lon=[0], lat=[0], pclass=ScipyParticle, repeatdt=5) - - def IncrLon(particle, fieldset, time): # pragma: no cover - particle.lon = 1.0 - - pset.execute(IncrLon, dt=2, runtime=21) - assert np.allclose([p.lon for p in pset], 1) # if p.dt is nan, it won't be executed so p.lon will be 0 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_repeatdt_custominit(fieldset, mode): - MyParticle = ptype[mode].add_variable("sample_var") - - pset = ParticleSet(fieldset, lon=0, lat=0, pclass=MyParticle, repeatdt=1, sample_var=5) - - pset.execute(DoNothing, dt=1, runtime=21) - assert np.allclose([p.sample_var for p in pset], 5.0) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_stop_simulation(fieldset, mode): - pset = ParticleSet(fieldset, lon=0, lat=0, pclass=ptype[mode]) - - def Delete(particle, fieldset, time): # pragma: no cover - if time == 4: - return StatusCode.StopExecution - - pset.execute(Delete, dt=1, runtime=21) - assert pset[0].time == 4 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_access(fieldset, mode): - npart = 100 - lon = np.linspace(0, 1, npart, dtype=np.float32) - lat = np.linspace(1, 0, npart, dtype=np.float32) - pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=ptype[mode]) - assert pset.size == 100 - assert np.allclose([pset[i].lon for i in range(pset.size)], lon, rtol=1e-12) - assert np.allclose([pset[i].lat for i in range(pset.size)], lat, rtol=1e-12) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_custom_ptype(fieldset, mode): - npart = 100 - TestParticle = ptype[mode].add_variable( - [Variable("p", np.float32, initial=0.33), Variable("n", np.int32, initial=2)] - ) - - pset = ParticleSet(fieldset, pclass=TestParticle, lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) - assert pset.size == npart - assert np.allclose([p.p - 0.33 for p in pset], np.zeros(npart), atol=1e-5) - assert np.allclose([p.n - 2 for p in pset], np.zeros(npart), rtol=1e-12) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_add_explicit(fieldset, mode): - npart = 100 - lon = np.linspace(0, 1, npart) - lat = np.linspace(1, 0, npart) - pset = ParticleSet(fieldset, lon=[], lat=[], pclass=ptype[mode], lonlatdepth_dtype=np.float64) - for i in range(npart): - particle = ParticleSet( - pclass=ptype[mode], lon=lon[i], lat=lat[i], fieldset=fieldset, lonlatdepth_dtype=np.float64 - ) - pset.add(particle) - assert pset.size == npart - assert np.allclose([p.lon for p in pset], lon, rtol=1e-12) - assert np.allclose([p.lat for p in pset], lat, rtol=1e-12) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_add_shorthand(fieldset, mode): - npart = 100 - lon = np.linspace(0, 1, npart, dtype=np.float32) - lat = np.linspace(1, 0, npart, dtype=np.float32) - pset = ParticleSet(fieldset, lon=[], lat=[], pclass=ptype[mode]) - for i in range(npart): - pset += ParticleSet(pclass=ptype[mode], lon=lon[i], lat=lat[i], fieldset=fieldset) - assert pset.size == npart - assert np.allclose([p.lon for p in pset], lon, rtol=1e-12) - assert np.allclose([p.lat for p in pset], lat, rtol=1e-12) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_add_execute(fieldset, mode): - npart = 10 - - def AddLat(particle, fieldset, time): # pragma: no cover - particle_dlat += 0.1 # noqa - - pset = ParticleSet(fieldset, lon=[], lat=[], pclass=ptype[mode]) - for _ in range(npart): - pset += ParticleSet(pclass=ptype[mode], lon=0.1, lat=0.1, fieldset=fieldset) - for _ in range(4): - pset.execute(pset.Kernel(AddLat), runtime=1.0, dt=1.0) - assert np.allclose(np.array([p.lat for p in pset]), 0.4, rtol=1e-12) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_merge_inplace(fieldset, mode): - npart = 100 - pset1 = ParticleSet(fieldset, pclass=ptype[mode], lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) - pset2 = ParticleSet(fieldset, pclass=ptype[mode], lon=np.linspace(0, 1, npart), lat=np.linspace(0, 1, npart)) - assert pset1.size == npart - assert pset2.size == npart - pset1.add(pset2) - assert pset1.size == 2 * npart - - -@pytest.mark.xfail(reason="ParticleSet duplication has not been implemented yet") -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_merge_duplicate(fieldset, mode): - npart = 100 - pset1 = ParticleSet(fieldset, pclass=ptype[mode], lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) - pset2 = ParticleSet(fieldset, pclass=ptype[mode], lon=np.linspace(0, 1, npart), lat=np.linspace(0, 1, npart)) - pset3 = pset1 + pset2 - assert pset1.size == npart - assert pset2.size == npart - assert pset3.size == 2 * npart - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_remove_index(fieldset, mode): - npart = 100 - lon = np.linspace(0, 1, npart) - lat = np.linspace(1, 0, npart) - pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=ptype[mode], lonlatdepth_dtype=np.float64) - for ilon, ilat in zip(lon[::-1], lat[::-1], strict=True): - assert pset[-1].lon == ilon - assert pset[-1].lat == ilat - pset.remove_indices(-1) - assert pset.size == 0 - - -@pytest.mark.xfail(reason="Particle removal has not been implemented yet") -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_remove_particle(fieldset, mode): - npart = 100 - lon = np.linspace(0, 1, npart) - lat = np.linspace(1, 0, npart) - pset = ParticleSet(fieldset, lon=lon, lat=lat, pclass=ptype[mode]) - for ilon, ilat in zip(lon[::-1], lat[::-1], strict=True): - assert pset.lon[-1] == ilon - assert pset.lat[-1] == ilat - pset.remove_indices(pset[-1]) - assert pset.size == 0 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_remove_kernel(fieldset, mode): - npart = 100 - - def DeleteKernel(particle, fieldset, time): # pragma: no cover - if particle.lon >= 0.4: - particle.delete() - - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=np.linspace(0, 1, npart), lat=np.linspace(1, 0, npart)) - pset.execute(pset.Kernel(DeleteKernel), endtime=1.0, dt=1.0) - assert pset.size == 40 - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_multi_execute(fieldset, mode): - npart = 10 - n = 5 - - def AddLat(particle, fieldset, time): # pragma: no cover - particle_dlat += 0.1 # noqa - - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=np.linspace(0, 1, npart), lat=np.zeros(npart)) - k_add = pset.Kernel(AddLat) - for _ in range(n + 1): - pset.execute(k_add, runtime=1.0, dt=1.0) - assert np.allclose([p.lat - n * 0.1 for p in pset], np.zeros(npart), rtol=1e-12) - - -@pytest.mark.parametrize("mode", ["scipy", "jit"]) -def test_pset_multi_execute_delete(fieldset, mode): - npart = 10 - n = 5 - - def AddLat(particle, fieldset, time): # pragma: no cover - particle_dlat += 0.1 # noqa - - pset = ParticleSet(fieldset, pclass=ptype[mode], lon=np.linspace(0, 1, npart), lat=np.zeros(npart)) - k_add = pset.Kernel(AddLat) - for _ in range(n + 1): - pset.execute(k_add, runtime=1.0, dt=1.0) - pset.remove_indices(-1) - assert np.allclose(pset.lat, n * 0.1, atol=1e-12) - - -@pytest.mark.parametrize("staggered_grid", ["Agrid", "Cgrid"]) -def test_from_field_exact_val(staggered_grid): - xdim = 4 - ydim = 3 - - lon = np.linspace(-1, 2, xdim, dtype=np.float32) - lat = np.linspace(50, 52, ydim, dtype=np.float32) - - dimensions = {"lat": lat, "lon": lon} - if staggered_grid == "Agrid": - U = np.zeros((ydim, xdim), dtype=np.float32) - V = np.zeros((ydim, xdim), dtype=np.float32) - data = {"U": np.array(U, dtype=np.float32), "V": np.array(V, dtype=np.float32)} - mask = np.array([[1, 1, 0, 0], - [1, 1, 1, 0], - [1, 1, 1, 1]]) # fmt: skip - fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - - FMask = Field("mask", mask, lon, lat) - fieldset.add_field(FMask) - elif staggered_grid == "Cgrid": - U = np.array([[0, 0, 0, 0], - [1, 0, 0, 0], - [1, 1, 0, 0]]) # fmt: skip - V = np.array([[0, 1, 0, 0], - [0, 1, 0, 0], - [0, 1, 1, 0]]) # fmt: skip - data = {"U": np.array(U, dtype=np.float32), "V": np.array(V, dtype=np.float32)} - mask = np.array([[-1, -1, -1, -1], [-1, 1, 0, 0], [-1, 1, 1, 0]]) - fieldset = FieldSet.from_data(data, dimensions, mesh="flat") - fieldset.U.interp_method = "cgrid_velocity" - fieldset.V.interp_method = "cgrid_velocity" - - FMask = Field("mask", mask, lon, lat, interp_method="cgrid_tracer") - fieldset.add_field(FMask) - - SampleParticle = ptype["scipy"].add_variable("mask", initial=0) - - def SampleMask(particle, fieldset, time): # pragma: no cover - particle.mask = fieldset.mask[particle] - - pset = ParticleSet.from_field(fieldset, size=400, pclass=SampleParticle, start_field=FMask, time=0) - pset.execute(SampleMask, dt=1, runtime=1) - assert np.allclose([p.mask for p in pset], 1) - assert (np.array([p.lon for p in pset]) <= 1).all() - test = np.logical_or(np.array([p.lon for p in pset]) <= 0, np.array([p.lat for p in pset]) >= 51) - assert test.all() diff --git a/tests/test_spatialhash.py b/tests/test_spatialhash.py new file mode 100644 index 000000000..500ce562c --- /dev/null +++ b/tests/test_spatialhash.py @@ -0,0 +1,34 @@ +import numpy as np + +from parcels import XGrid +from parcels._datasets.structured.generic import datasets + + +def test_spatialhash_init(): + ds = datasets["2d_left_rotated"] + grid = XGrid.from_dataset(ds) + spatialhash = grid.get_spatial_hash() + assert spatialhash is not None + + +def test_invalid_positions(): + ds = datasets["2d_left_rotated"] + grid = XGrid.from_dataset(ds) + + j, i, coords = grid.get_spatial_hash().query([np.nan, np.inf], [np.nan, np.inf]) + assert np.all(j == -3) + assert np.all(i == -3) + + +def test_mixed_positions(): + ds = datasets["2d_left_rotated"] + grid = XGrid.from_dataset(ds) + lat = grid.lat.mean() + lon = grid.lon.mean() + y = [lat, np.nan] + x = [lon, np.nan] + j, i, coords = grid.get_spatial_hash().query(y, x) + assert j[0] == 29 # Actual value for 2d_left_rotated center + assert i[0] == 14 # Actual value for 2d_left_rotated center + assert j[1] == -3 + assert i[1] == -3 diff --git a/tests/test_structured_gcm.py b/tests/test_structured_gcm.py new file mode 100644 index 000000000..f724cff9b --- /dev/null +++ b/tests/test_structured_gcm.py @@ -0,0 +1,17 @@ +"""Tests for outputs from structured GCMs.""" + +import pytest + + +@pytest.mark.v4alpha +@pytest.mark.skip(reason="From_pop is not supported during v4-alpha development. This will be reconsidered in v4.") +def test_fieldset_frompop(): + # # Initial v3 test + # filenames = str(TEST_DATA / "POPtestdata_time.nc") + # variables = {"U": "U", "V": "V", "W": "W", "T": "T"} + # dimensions = {"lon": "lon", "lat": "lat", "time": "time"} + + # fieldset = FieldSet.from_pop(filenames, variables, dimensions, mesh="flat") + # pset = ParticleSet(fieldset, Particle, lon=[3, 5, 1], lat=[3, 5, 1]) + # pset.execute(AdvectionRK4, runtime=3, dt=1) + pass diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 000000000..b42e13330 --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,19 @@ +import numpy as np + +from tests import utils + + +def test_round_and_hash_float_array(): + decimals = 7 + arr = np.array([1.0, 2.0, 3.0], dtype=np.float64) + h = utils.round_and_hash_float_array(arr, decimals=decimals) + assert h == 1068792616613 + + delta = 10**-decimals + arr_test = arr + 0.49 * delta + h2 = utils.round_and_hash_float_array(arr_test, decimals=decimals) + assert h2 == h + + arr_test = arr + 0.51 * delta + h3 = utils.round_and_hash_float_array(arr_test, decimals=decimals) + assert h3 != h diff --git a/tests/test_uxarray_fieldset.py b/tests/test_uxarray_fieldset.py new file mode 100644 index 000000000..d279dac4f --- /dev/null +++ b/tests/test_uxarray_fieldset.py @@ -0,0 +1,152 @@ +import numpy as np +import pytest +import uxarray as ux + +from parcels import ( + Field, + FieldSet, + Particle, + ParticleSet, + UxGrid, + VectorField, + download_example_dataset, +) +from parcels._datasets.unstructured.generic import datasets as datasets_unstructured +from parcels.interpolators import ( + UXPiecewiseConstantFace, + UXPiecewiseLinearNode, +) + + +@pytest.fixture +def ds_fesom_channel() -> ux.UxDataset: + fesom_path = download_example_dataset("FESOM_periodic_channel") + grid_path = f"{fesom_path}/fesom_channel.nc" + data_path = [ + f"{fesom_path}/u.fesom_channel.nc", + f"{fesom_path}/v.fesom_channel.nc", + f"{fesom_path}/w.fesom_channel.nc", + ] + ds = ux.open_mfdataset(grid_path, data_path).rename_vars({"u": "U", "v": "V", "w": "W"}) + return ds + + +@pytest.fixture +def uv_fesom_channel(ds_fesom_channel) -> VectorField: + UV = VectorField( + name="UV", + U=Field( + name="U", + data=ds_fesom_channel.U, + grid=UxGrid(ds_fesom_channel.uxgrid, z=ds_fesom_channel.coords["nz"]), + interp_method=UXPiecewiseConstantFace, + ), + V=Field( + name="V", + data=ds_fesom_channel.V, + grid=UxGrid(ds_fesom_channel.uxgrid, z=ds_fesom_channel.coords["nz"]), + interp_method=UXPiecewiseConstantFace, + ), + ) + return UV + + +@pytest.fixture +def uvw_fesom_channel(ds_fesom_channel) -> VectorField: + UVW = VectorField( + name="UVW", + U=Field( + name="U", + data=ds_fesom_channel.U, + grid=UxGrid(ds_fesom_channel.uxgrid, z=ds_fesom_channel.coords["nz"]), + interp_method=UXPiecewiseConstantFace, + ), + V=Field( + name="V", + data=ds_fesom_channel.V, + grid=UxGrid(ds_fesom_channel.uxgrid, z=ds_fesom_channel.coords["nz"]), + interp_method=UXPiecewiseConstantFace, + ), + W=Field( + name="W", + data=ds_fesom_channel.W, + grid=UxGrid(ds_fesom_channel.uxgrid, z=ds_fesom_channel.coords["nz"]), + interp_method=UXPiecewiseLinearNode, + ), + ) + return UVW + + +def test_fesom_fieldset(ds_fesom_channel, uv_fesom_channel): + fieldset = FieldSet([uv_fesom_channel, uv_fesom_channel.U, uv_fesom_channel.V]) + # Check that the fieldset has the expected properties + assert (fieldset.U.data == ds_fesom_channel.U).all() + assert (fieldset.V.data == ds_fesom_channel.V).all() + + +def test_fesom_in_particleset(ds_fesom_channel, uv_fesom_channel): + fieldset = FieldSet([uv_fesom_channel, uv_fesom_channel.U, uv_fesom_channel.V]) + + # Check that the fieldset has the expected properties + assert (fieldset.U.data == ds_fesom_channel.U).all() + assert (fieldset.V.data == ds_fesom_channel.V).all() + pset = ParticleSet(fieldset, pclass=Particle) + assert pset.fieldset == fieldset + + +def test_set_interp_methods(ds_fesom_channel, uv_fesom_channel): + fieldset = FieldSet([uv_fesom_channel, uv_fesom_channel.U, uv_fesom_channel.V]) + # Check that the fieldset has the expected properties + assert (fieldset.U.data == ds_fesom_channel.U).all() + assert (fieldset.V.data == ds_fesom_channel.V).all() + + # Set the interpolation method for each field + fieldset.U.interp_method = UXPiecewiseConstantFace + fieldset.V.interp_method = UXPiecewiseConstantFace + + +def test_fesom2_square_delaunay_uniform_z_coordinate_eval(): + """ + Test the evaluation of a fieldset with a FESOM2 square Delaunay grid and uniform z-coordinate. + Ensures that the fieldset can be created and evaluated correctly. + Since the underlying data is constant, we can check that the values are as expected. + """ + ds = datasets_unstructured["fesom2_square_delaunay_uniform_z_coordinate"] + UVW = VectorField( + name="UVW", + U=Field(name="U", data=ds.U, grid=UxGrid(ds.uxgrid, z=ds.coords["nz"]), interp_method=UXPiecewiseConstantFace), + V=Field(name="V", data=ds.V, grid=UxGrid(ds.uxgrid, z=ds.coords["nz"]), interp_method=UXPiecewiseConstantFace), + W=Field(name="W", data=ds.W, grid=UxGrid(ds.uxgrid, z=ds.coords["nz"]), interp_method=UXPiecewiseLinearNode), + ) + P = Field(name="p", data=ds.p, grid=UxGrid(ds.uxgrid, z=ds.coords["nz"]), interp_method=UXPiecewiseLinearNode) + fieldset = FieldSet([UVW, P, UVW.U, UVW.V, UVW.W]) + + assert fieldset.U.eval(time=ds.time[0].values, z=[1.0], y=[30.0], x=[30.0], applyConversion=False) == 1.0 + assert fieldset.V.eval(time=ds.time[0].values, z=[1.0], y=[30.0], x=[30.0], applyConversion=False) == 1.0 + assert fieldset.W.eval(time=ds.time[0].values, z=[1.0], y=[30.0], x=[30.0], applyConversion=False) == 0.0 + assert fieldset.p.eval(time=ds.time[0].values, z=[1.0], y=[30.0], x=[30.0], applyConversion=False) == 1.0 + + +def test_fesom2_square_delaunay_antimeridian_eval(): + """ + Test the evaluation of a fieldset with a FESOM2 square Delaunay grid that crosses the antimeridian. + Ensures that the fieldset can be created and evaluated correctly. + Since the underlying data is constant, we can check that the values are as expected. + """ + ds = datasets_unstructured["fesom2_square_delaunay_antimeridian"] + P = Field( + name="p", + data=ds.p, + grid=UxGrid(ds.uxgrid, z=ds.coords["nz"], mesh="spherical"), + interp_method=UXPiecewiseLinearNode, + ) + fieldset = FieldSet([P]) + + assert np.isclose( + fieldset.p.eval(time=ds.time[0].values, z=[1.0], y=[30.0], x=[-170.0], applyConversion=False), 1.0 + ) + assert np.isclose( + fieldset.p.eval(time=ds.time[0].values, z=[1.0], y=[30.0], x=[-180.0], applyConversion=False), 1.0 + ) + assert np.isclose(fieldset.p.eval(time=ds.time[0].values, z=[1.0], y=[30.0], x=[180.0], applyConversion=False), 1.0) + assert np.isclose(fieldset.p.eval(time=ds.time[0].values, z=[1.0], y=[30.0], x=[170.0], applyConversion=False), 1.0) diff --git a/tests/test_uxgrid.py b/tests/test_uxgrid.py new file mode 100644 index 000000000..91d33b8f0 --- /dev/null +++ b/tests/test_uxgrid.py @@ -0,0 +1,23 @@ +import pytest + +from parcels import UxGrid +from parcels._datasets.unstructured.generic import datasets as uxdatasets + + +@pytest.mark.parametrize("uxds", [pytest.param(uxds, id=key) for key, uxds in uxdatasets.items()]) +def test_uxgrid_init_on_generic_datasets(uxds): + UxGrid(uxds.uxgrid, z=uxds.coords["nz"]) + + +@pytest.mark.parametrize("uxds", [uxdatasets["stommel_gyre_delaunay"]]) +def test_uxgrid_axes(uxds): + grid = UxGrid(uxds.uxgrid, z=uxds.coords["nz"]) + assert grid.axes == ["Z", "FACE"] + + +@pytest.mark.parametrize("uxds", [uxdatasets["stommel_gyre_delaunay"]]) +def test_xgrid_get_axis_dim(uxds): + grid = UxGrid(uxds.uxgrid, z=uxds.coords["nz"]) + + assert grid.get_axis_dim("FACE") == 721 + assert grid.get_axis_dim("Z") == 2 diff --git a/tests/test_xarray_fieldset.py b/tests/test_xarray_fieldset.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/test_xgrid.py b/tests/test_xgrid.py new file mode 100644 index 000000000..d93e4689a --- /dev/null +++ b/tests/test_xgrid.py @@ -0,0 +1,251 @@ +import itertools +from collections import namedtuple + +import numpy as np +import pytest +import xarray as xr +from numpy.testing import assert_allclose + +from parcels._core.index_search import LEFT_OUT_OF_BOUNDS, RIGHT_OUT_OF_BOUNDS, _search_1d_array +from parcels._core.xgrid import ( + XGrid, + _transpose_xfield_data_to_tzyx, +) +from parcels._datasets.structured.generic import X, Y, Z, datasets +from tests import utils + +GridTestCase = namedtuple("GridTestCase", ["ds", "attr", "expected"]) + +test_cases = [ + GridTestCase(datasets["ds_2d_left"], "lon", datasets["ds_2d_left"].XG.values), + GridTestCase(datasets["ds_2d_left"], "lat", datasets["ds_2d_left"].YG.values), + GridTestCase(datasets["ds_2d_left"], "depth", datasets["ds_2d_left"].ZG.values), + GridTestCase(datasets["ds_2d_left"], "time", datasets["ds_2d_left"].time.values.astype(np.float64) / 1e9), + GridTestCase(datasets["ds_2d_left"], "xdim", X - 1), + GridTestCase(datasets["ds_2d_left"], "ydim", Y - 1), + GridTestCase(datasets["ds_2d_left"], "zdim", Z - 1), +] + + +def assert_equal(actual, expected): + if expected is None: + assert actual is None + elif isinstance(expected, np.ndarray): + assert actual.shape == expected.shape + assert_allclose(actual, expected) + else: + assert_allclose(actual, expected) + + +@pytest.mark.parametrize("ds", [datasets["ds_2d_left"]]) +def test_grid_init_param_types(ds): + with pytest.raises(ValueError, match="Invalid value 'invalid'. Valid options are.*"): + XGrid.from_dataset(ds, mesh="invalid") + + +@pytest.mark.parametrize("ds, attr, expected", test_cases) +def test_xgrid_properties_ground_truth(ds, attr, expected): + grid = XGrid.from_dataset(ds) + actual = getattr(grid, attr) + assert_equal(actual, expected) + + +@pytest.mark.parametrize("ds", [pytest.param(ds, id=key) for key, ds in datasets.items()]) +def test_xgrid_from_dataset_on_generic_datasets(ds): + XGrid.from_dataset(ds) + + +@pytest.mark.parametrize("ds", [datasets["ds_2d_left"]]) +def test_xgrid_axes(ds): + grid = XGrid.from_dataset(ds) + assert grid.axes == ["Z", "Y", "X"] + + +@pytest.mark.parametrize("ds", [datasets["ds_2d_left"]]) +def test_transpose_xfield_data_to_tzyx(ds): + da = ds["data_g"] + grid = XGrid.from_dataset(ds) + + all_combinations = (itertools.combinations(da.dims, n) for n in range(len(da.dims))) + all_combinations = itertools.chain(*all_combinations) + for subset_dims in all_combinations: + isel = {dim: 0 for dim in subset_dims} + da_subset = da.isel(isel, drop=True) + da_test = _transpose_xfield_data_to_tzyx(da_subset, grid.xgcm_grid) + utils.assert_valid_field_data(da_test, grid) + + +@pytest.mark.parametrize("ds", [datasets["ds_2d_left"]]) +def test_xgrid_get_axis_dim(ds): + grid = XGrid.from_dataset(ds) + assert grid.get_axis_dim("Z") == Z - 1 + assert grid.get_axis_dim("Y") == Y - 1 + assert grid.get_axis_dim("X") == X - 1 + + +def test_invalid_xgrid_field_array(): + """Stress test initialiser by creating incompatible datasets that test the edge cases""" + ... + + +def test_invalid_lon_lat(): + """Stress test the grid initialiser by creating incompatible datasets that test the edge cases""" + ds = datasets["ds_2d_left"].copy() + ds["lon"], ds["lat"] = xr.broadcast(ds["YC"], ds["XC"]) + + with pytest.raises( + ValueError, + match=".*is defined on the center of the grid, but must be defined on the F points\.", + ): + XGrid.from_dataset(ds) + + ds = datasets["ds_2d_left"].copy() + ds["lon"], _ = xr.broadcast(ds["YG"], ds["XG"]) + with pytest.raises( + ValueError, + match=".*have different dimensionalities\.", + ): + XGrid.from_dataset(ds) + + ds = datasets["ds_2d_left"].copy() + ds["lon"], ds["lat"] = xr.broadcast(ds["YG"], ds["XG"]) + ds["lon"], ds["lat"] = ds["lon"].transpose(), ds["lat"].transpose() + + with pytest.raises( + ValueError, + match=".*must be defined on the X and Y axes and transposed to have dimensions in order of Y, X\.", + ): + XGrid.from_dataset(ds) + + +@pytest.mark.parametrize( + "ds", + [ + pytest.param(datasets["ds_2d_left"], id="1D lon/lat"), + pytest.param(datasets["2d_left_rotated"], id="2D lon/lat"), + ], +) # for key, ds in datasets.items()]) +def test_xgrid_search_cpoints(ds): + grid = XGrid.from_dataset(ds) + lat_array, lon_array = get_2d_fpoint_mesh(grid) + lat_array, lon_array = corner_to_cell_center_points(lat_array, lon_array) + + for xi in range(grid.xdim - 1): + for yi in range(grid.ydim - 1): + axis_indices = {"Z": 0, "Y": yi, "X": xi} + + lat, lon = lat_array[yi, xi], lon_array[yi, xi] + axis_indices_bcoords = grid.search(0, np.atleast_1d(lat), np.atleast_1d(lon), ei=None) + axis_indices_test = {k: v[0] for k, v in axis_indices_bcoords.items()} + assert axis_indices == axis_indices_test + + # assert np.isclose(bcoords[0], 0.5) #? Should this not be the case with the cell center points? + # assert np.isclose(bcoords[1], 0.5) + + +def get_2d_fpoint_mesh(grid: XGrid): + lat, lon = grid.lat, grid.lon + if lon.ndim == 1: + lat, lon = np.meshgrid(lat, lon, indexing="ij") + return lat, lon + + +def corner_to_cell_center_points(lat, lon): + """Convert F points to C points.""" + lon_c = (lon[:-1, :-1] + lon[:-1, 1:]) / 2 + lat_c = (lat[:-1, :-1] + lat[1:, :-1]) / 2 + return lat_c, lon_c + + +@pytest.mark.parametrize( + "array, x, expected_xi, expected_xsi", + [ + (np.array([1, 2, 3, 4, 5]), (1.1, 2.1), (0, 1), (0.1, 0.1)), + (np.array([1, 2, 3, 4, 5]), 2.1, 1, 0.1), + (np.array([1, 2, 3, 4, 5]), 3.1, 2, 0.1), + (np.array([1, 2, 3, 4, 5]), 4.5, 3, 0.5), + ], +) +def test_search_1d_array(array, x, expected_xi, expected_xsi): + xi, xsi = _search_1d_array(array, x) + np.testing.assert_array_equal(xi, expected_xi) + np.testing.assert_allclose(xsi, expected_xsi) + + +@pytest.mark.parametrize( + "array, x, expected_xi", + [ + (np.array([1, 2, 3, 4, 5]), -0.1, LEFT_OUT_OF_BOUNDS), + (np.array([1, 2, 3, 4, 5]), 6.5, RIGHT_OUT_OF_BOUNDS), + ], +) +def test_search_1d_array_out_of_bounds(array, x, expected_xi): + xi, xsi = _search_1d_array(array, x) + assert xi == expected_xi + + +@pytest.mark.parametrize( + "array, x, expected_xi", + [ + (np.array([1, 2, 3, 4, 5]), (-0.1, 2.5), (LEFT_OUT_OF_BOUNDS, 1)), + (np.array([1, 2, 3, 4, 5]), (6.5, 1), (RIGHT_OUT_OF_BOUNDS, 0)), + ], +) +def test_search_1d_array_some_out_of_bounds(array, x, expected_xi): + xi, _ = _search_1d_array(array, x) + np.testing.assert_array_equal(xi, expected_xi) + + +@pytest.mark.parametrize( + "ds, da_name, expected", + [ + pytest.param( + datasets["ds_2d_left"], + "U (C grid)", + { + "XG": (np.int64(0), np.float64(0.0)), + "YC": (np.int64(-1), np.float64(0.5)), + "ZG": (np.int64(0), np.float64(0.0)), + }, + id="MITgcm indexing style U (C grid)", + ), + pytest.param( + datasets["ds_2d_left"], + "V (C grid)", + { + "XC": (np.int64(-1), np.float64(0.5)), + "YG": (np.int64(0), np.float64(0.0)), + "ZG": (np.int64(0), np.float64(0.0)), + }, + id="MITgcm indexing style V (C grid)", + ), + pytest.param( + datasets["ds_2d_right"], + "U (C grid)", + { + "XG": (np.int64(0), np.float64(0.0)), + "YC": (np.int64(0), np.float64(0.5)), + "ZG": (np.int64(0), np.float64(0.0)), + }, + id="NEMO indexing style U (C grid)", + ), + pytest.param( + datasets["ds_2d_right"], + "V (C grid)", + { + "XC": (np.int64(0), np.float64(0.5)), + "YG": (np.int64(0), np.float64(0.0)), + "ZG": (np.int64(0), np.float64(0.0)), + }, + id="NEMO indexing style V (C grid)", + ), + ], +) +def test_xgrid_localize_zero_position(ds, da_name, expected): + """Test localize function using left and right datasets.""" + grid = XGrid.from_dataset(ds) + da = ds[da_name] + position = grid.search(0, 0, 0) + + local_position = grid.localize(position, da.dims) + assert local_position == expected, f"Expected {expected}, got {local_position}" diff --git a/tests/tools/test_converters.py b/tests/tools/test_converters.py deleted file mode 100644 index 3d35363b1..000000000 --- a/tests/tools/test_converters.py +++ /dev/null @@ -1,55 +0,0 @@ -import cftime -import numpy as np -import pytest - -from parcels.tools.converters import TimeConverter, _get_cftime_datetimes - -cf_datetime_classes = [getattr(cftime, c) for c in _get_cftime_datetimes()] -cf_datetime_objects = [c(1990, 1, 1) for c in cf_datetime_classes] - - -@pytest.mark.parametrize( - "cf_datetime", - cf_datetime_objects, -) -def test_TimeConverter_cf(cf_datetime): - assert TimeConverter(cf_datetime).calendar == cf_datetime.calendar - assert TimeConverter(cf_datetime).time_origin == cf_datetime - - -def test_TimeConverter_standard(): - dt = np.datetime64("2001-01-01T12:00") - assert TimeConverter(dt).calendar == "np_datetime64" - assert TimeConverter(dt).time_origin == dt - - dt = np.timedelta64(1, "s") - assert TimeConverter(dt).calendar == "np_timedelta64" - assert TimeConverter(dt).time_origin == dt - - assert TimeConverter(0).calendar is None - assert TimeConverter(0).time_origin == 0 - - -def test_TimeConverter_reltime_one_day(): - ONE_DAY = 24 * 60 * 60 - first_jan = [c(1990, 1, 1) for c in cf_datetime_classes] + [0] - second_jan = [c(1990, 1, 2) for c in cf_datetime_classes] + [ONE_DAY] - - for time_origin, time in zip(first_jan, second_jan, strict=True): - tc = TimeConverter(time_origin) - assert tc.reltime(time) == ONE_DAY - - -@pytest.mark.parametrize( - "x, y", - [ - pytest.param(np.datetime64("2001-01-01T12:00"), 0, id="datetime64 float"), - pytest.param(cftime.DatetimeNoLeap(1990, 1, 1), 0, id="cftime float"), - pytest.param(cftime.DatetimeNoLeap(1990, 1, 1), cftime.DatetimeAllLeap(1991, 1, 1), id="cftime cftime"), - ], -) -def test_TimeConverter_reltime_errors(x, y): - """All of these should raise a ValueError when doing reltime""" - tc = TimeConverter(x) - with pytest.raises((ValueError, TypeError)): - tc.reltime(y) diff --git a/tests/tools/test_warnings.py b/tests/tools/test_warnings.py deleted file mode 100644 index 1979f9c86..000000000 --- a/tests/tools/test_warnings.py +++ /dev/null @@ -1,99 +0,0 @@ -import warnings - -import numpy as np -import pytest - -from parcels import ( - AdvectionRK4, - AdvectionRK4_3D, - AdvectionRK45, - FieldSet, - FieldSetWarning, - KernelWarning, - ParticleSet, - ParticleSetWarning, - ScipyParticle, -) -from tests.utils import TEST_DATA - - -def test_fieldset_warnings(): - # halo with inconsistent boundaries - lat = [0, 1, 5, 10] - lon = [0, 1, 5, 10] - u = [[1, 1, 1, 1] for _ in range(4)] - v = [[1, 1, 1, 1] for _ in range(4)] - fieldset = FieldSet.from_data(data={"U": u, "V": v}, dimensions={"lon": lon, "lat": lat}, transpose=True) - with pytest.warns(FieldSetWarning): - fieldset.add_periodic_halo(meridional=True, zonal=True) - - # flipping lats warning - lat = [0, 1, 5, -5] - lon = [0, 1, 5, 10] - u = [[1, 1, 1, 1] for _ in range(4)] - v = [[1, 1, 1, 1] for _ in range(4)] - with pytest.warns(FieldSetWarning): - fieldset = FieldSet.from_data(data={"U": u, "V": v}, dimensions={"lon": lon, "lat": lat}, transpose=True) - - with pytest.warns(FieldSetWarning): - # allow_time_extrapolation with time_periodic warning - fieldset = FieldSet.from_data( - data={"U": u, "V": v}, - dimensions={"lon": lon, "lat": lat}, - transpose=True, - allow_time_extrapolation=True, - time_periodic=1, - ) - - filenames = str(TEST_DATA / "POPtestdata_time.nc") - variables = {"U": "U", "V": "V", "W": "W", "T": "T"} - dimensions = {"lon": "lon", "lat": "lat", "depth": "w_deps", "time": "time"} - with pytest.warns(FieldSetWarning): - # b-grid with s-levels and POP output in meters warning - fieldset = FieldSet.from_pop(filenames, variables, dimensions, mesh="flat") - with pytest.warns(FieldSetWarning): - # timestamps with time in file warning - fieldset = FieldSet.from_pop(filenames, variables, dimensions, mesh="flat", timestamps=[0, 1, 2, 3]) - - -def test_file_warnings(tmp_zarrfile): - fieldset = FieldSet.from_data( - data={"U": np.zeros((1, 1)), "V": np.zeros((1, 1))}, dimensions={"lon": [0], "lat": [0]} - ) - pset = ParticleSet(fieldset=fieldset, pclass=ScipyParticle, lon=[0, 0], lat=[0, 0], time=[0, 1]) - pfile = pset.ParticleFile(name=tmp_zarrfile, outputdt=2) - with pytest.warns(ParticleSetWarning, match="Some of the particles have a start time difference.*"): - pset.execute(AdvectionRK4, runtime=3, dt=1, output_file=pfile) - - -def test_kernel_warnings(): - # positive scaling factor for W - filenames = str(TEST_DATA / "POPtestdata_time.nc") - variables = {"U": "U", "V": "V", "W": "W", "T": "T"} - dimensions = {"lon": "lon", "lat": "lat", "depth": "w_deps", "time": "time"} - with warnings.catch_warnings(): - # ignore FieldSetWarnings (tested in test_fieldset_warnings) - warnings.simplefilter("ignore", FieldSetWarning) - fieldset = FieldSet.from_pop(filenames, variables, dimensions, mesh="flat") - fieldset.W._scaling_factor = 0.01 - pset = ParticleSet(fieldset=fieldset, pclass=ScipyParticle, lon=[0], lat=[0], depth=[0], time=[0]) - with pytest.warns(KernelWarning): - pset.execute(AdvectionRK4_3D, runtime=1, dt=1) - - # RK45 warnings - lat = [0, 1, 5, 10] - lon = [0, 1, 5, 10] - u = [[1, 1, 1, 1] for _ in range(4)] - v = [[1, 1, 1, 1] for _ in range(4)] - fieldset = FieldSet.from_data(data={"U": u, "V": v}, dimensions={"lon": lon, "lat": lat}, transpose=True) - pset = ParticleSet( - fieldset=fieldset, - pclass=ScipyParticle.add_variable("next_dt", dtype=np.float32, initial=1), - lon=[0], - lat=[0], - depth=[0], - time=[0], - next_dt=1, - ) - with pytest.warns(KernelWarning): - pset.execute(AdvectionRK45, runtime=1, dt=1) diff --git a/tests/utils.py b/tests/utils.py index 35e134b21..4653c27dc 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -1,26 +1,32 @@ """General helper functions and utilies for test suite.""" +from __future__ import annotations + +import struct from pathlib import Path import numpy as np import xarray as xr import parcels -from parcels import FieldSet +from parcels import Field, FieldSet, VectorField +from parcels._core.xgrid import _FIELD_DATA_ORDERING, XGrid, get_axis_from_dim_name +from parcels._datasets.structured.generated import simple_UV_dataset +from parcels.interpolators import XLinear PROJECT_ROOT = Path(__file__).resolve().parents[1] TEST_ROOT = PROJECT_ROOT / "tests" TEST_DATA = TEST_ROOT / "test_data" -def create_fieldset_unit_mesh(xdim=20, ydim=20, mesh="flat", transpose=False) -> FieldSet: +def create_fieldset_unit_mesh(xdim=20, ydim=20, mesh="flat") -> FieldSet: """Standard unit mesh fieldset with U and V equivalent to longitude and latitude.""" lon = np.linspace(0.0, 1.0, xdim, dtype=np.float32) lat = np.linspace(0.0, 1.0, ydim, dtype=np.float32) - U, V = np.meshgrid(lat, lon) + V, U = np.meshgrid(lon, lat) data = {"U": np.array(U, dtype=np.float32), "V": np.array(V, dtype=np.float32)} dimensions = {"lat": lat, "lon": lon} - return FieldSet.from_data(data, dimensions, mesh=mesh, transpose=transpose) + return FieldSet.from_data(data, dimensions, mesh=mesh) def create_fieldset_zeros_3d(zdim=5, ydim=10, xdim=10): @@ -55,26 +61,31 @@ def create_fieldset_global(xdim=200, ydim=100): """Standard fieldset spanning the earth's coordinates with U and V equivalent to longitude and latitude in deg.""" lon = np.linspace(-180, 180, xdim, dtype=np.float32) lat = np.linspace(-90, 90, ydim, dtype=np.float32) - U, V = np.meshgrid(lat, lon) + V, U = np.meshgrid(lon, lat) data = {"U": U, "V": V} dimensions = {"lon": lon, "lat": lat} - return FieldSet.from_data(data, dimensions, mesh="flat", transpose=True) + return FieldSet.from_data(data, dimensions, mesh="flat") -def create_fieldset_zeros_conversion(mesh="spherical", xdim=200, ydim=100, mesh_conversion=1) -> FieldSet: +def create_fieldset_zeros_conversion(mesh="spherical", xdim=200, ydim=100) -> FieldSet: """Zero velocity field with lat and lon determined by a conversion factor.""" - lon = np.linspace(-1e5 * mesh_conversion, 1e5 * mesh_conversion, xdim, dtype=np.float32) - lat = np.linspace(-1e5 * mesh_conversion, 1e5 * mesh_conversion, ydim, dtype=np.float32) - dimensions = {"lon": lon, "lat": lat} - data = {"U": np.zeros((ydim, xdim), dtype=np.float32), "V": np.zeros((ydim, xdim), dtype=np.float32)} - return FieldSet.from_data(data, dimensions, mesh=mesh) + mesh_conversion = 1 / 1852.0 / 60 if mesh == "spherical" else 1 + ds = simple_UV_dataset(dims=(2, 1, ydim, xdim), mesh=mesh) + ds["lon"].data = np.linspace(-1e6 * mesh_conversion, 1e6 * mesh_conversion, xdim) + ds["lat"].data = np.linspace(-1e6 * mesh_conversion, 1e6 * mesh_conversion, ydim) + grid = XGrid.from_dataset(ds, mesh=mesh) + U = Field("U", ds["U"], grid, interp_method=XLinear) + V = Field("V", ds["V"], grid, interp_method=XLinear) + + UV = VectorField("UV", U, V) + return FieldSet([U, V, UV]) def create_simple_pset(n=1): zeros = np.zeros(n) return parcels.ParticleSet( fieldset=create_fieldset_unit_mesh(), - pclass=parcels.ScipyParticle, + pclass=parcels.Particle, lon=zeros, lat=zeros, depth=zeros, @@ -116,3 +127,28 @@ def create_fieldset_zeros_simple(xdim=40, ydim=100, withtime=False): def assert_empty_folder(path: Path): assert [p.name for p in path.iterdir()] == [] + + +def assert_valid_field_data(data: xr.DataArray, grid: XGrid): + assert len(data.shape) == 4, f"Field data should have 4 dimensions (time, depth, lat, lon), got dims {data.dims}" + + for ax_expected, dim in zip(_FIELD_DATA_ORDERING, data.dims, strict=True): + ax_actual = get_axis_from_dim_name(grid.xgcm_grid.axes, dim) + if ax_actual is None: + continue # None is ok + assert ax_actual == ax_expected, f"Expected axis {ax_expected} for dimension '{dim}', got {ax_actual}" + + +def round_and_hash_float_array(arr, decimals=6): + arr = np.round(arr, decimals=decimals) + + # Adapted from https://cs.stackexchange.com/a/37965 + h = 1 + for f in arr: + # Mimic Float.floatToIntBits: converts float to 4-byte binary, then interprets as int + float_as_int = struct.unpack("!i", struct.pack("!f", f))[0] + h = 31 * h + float_as_int + + # Mimic Java's HashMap hash transformation + h ^= (h >> 20) ^ (h >> 12) + return h ^ (h >> 7) ^ (h >> 4) diff --git a/tests/utils/test_time.py b/tests/utils/test_time.py new file mode 100644 index 000000000..5bab70b3b --- /dev/null +++ b/tests/utils/test_time.py @@ -0,0 +1,200 @@ +from __future__ import annotations + +from datetime import datetime, timedelta + +import numpy as np +import pytest +from cftime import datetime as cftime_datetime +from hypothesis import given +from hypothesis import strategies as st + +from parcels._core.utils.time import TimeInterval, maybe_convert_python_timedelta_to_numpy + +calendar_strategy = st.sampled_from( + [ + "gregorian", + "proleptic_gregorian", + "365_day", + "360_day", + "julian", + "366_day", + np.datetime64, + datetime, + np.timedelta64, + ] +) + + +@st.composite +def np_timedelta64_strategy(draw): + """Strategy for generating np.timedelta64 objects.""" + return np.timedelta64(draw(st.integers(1, 60 * 60 * 24 * 100 * 365)), "s") + + +@st.composite +def datetime_strategy(draw, calendar=None): + if calendar is None: + calendar = draw(calendar_strategy) + if calendar is np.timedelta64: + return draw(np_timedelta64_strategy()) + + year = draw(st.integers(1900, 2100)) + month = draw(st.integers(1, 12)) + day = draw(st.integers(1, 28)) + if calendar is datetime: + return datetime(year, month, day) + if calendar is np.datetime64: + return np.datetime64(datetime(year, month, day)) + + return cftime_datetime(year, month, day, calendar=calendar) + + +@st.composite +def time_interval_strategy(draw, left=None, calendar=None): + if left is None: + left = draw(datetime_strategy(calendar=calendar)) + right = left + draw(np_timedelta64_strategy()) + + return TimeInterval(left, right) + + +@pytest.mark.parametrize( + "left,right", + [ + (cftime_datetime(2023, 1, 1, calendar="gregorian"), cftime_datetime(2023, 1, 2, calendar="gregorian")), + (cftime_datetime(2023, 6, 1, calendar="365_day"), cftime_datetime(2023, 6, 2, calendar="365_day")), + (cftime_datetime(2023, 12, 1, calendar="360_day"), cftime_datetime(2023, 12, 2, calendar="360_day")), + (datetime(2023, 12, 1), datetime(2023, 12, 2)), + (np.datetime64(datetime(2023, 12, 1)), np.datetime64(datetime(2023, 12, 2))), + ], +) +def test_time_interval_initialization(left, right): + """Test that TimeInterval can be initialized with valid inputs.""" + interval = TimeInterval(left, right) + assert interval.left == left + assert interval.right == right + + with pytest.raises(ValueError): + TimeInterval(right, left) + + +@given(time_interval_strategy()) +def test_time_interval_contains(interval): + left = interval.left + right = interval.right + middle = left + (right - left) / 2 + + assert interval.is_all_time_in_interval(left) + assert interval.is_all_time_in_interval(right) + assert interval.is_all_time_in_interval(middle) + + +@given(time_interval_strategy(calendar="365_day"), time_interval_strategy(calendar="365_day")) +def test_time_interval_intersection_commutative(interval1, interval2): + assert interval1.intersection(interval2) == interval2.intersection(interval1) + + +@given(time_interval_strategy()) +def test_time_interval_intersection_with_self(interval): + assert interval.intersection(interval) == interval + + +def test_time_interval_repr(): + """Test the string representation of TimeInterval.""" + interval = TimeInterval(datetime(2023, 1, 1, 12, 0), datetime(2023, 1, 2, 12, 0)) + expected = "TimeInterval(left=datetime.datetime(2023, 1, 1, 12, 0), right=datetime.datetime(2023, 1, 2, 12, 0))" + assert repr(interval) == expected + + +@given(time_interval_strategy()) +def test_time_interval_equality(interval): + assert interval == interval + + +@pytest.mark.parametrize( + "interval1,interval2,expected", + [ + pytest.param( + TimeInterval( + cftime_datetime(2023, 1, 1, calendar="gregorian"), cftime_datetime(2023, 1, 3, calendar="gregorian") + ), + TimeInterval( + cftime_datetime(2023, 1, 2, calendar="gregorian"), cftime_datetime(2023, 1, 4, calendar="gregorian") + ), + TimeInterval( + cftime_datetime(2023, 1, 2, calendar="gregorian"), cftime_datetime(2023, 1, 3, calendar="gregorian") + ), + id="overlapping intervals", + ), + pytest.param( + TimeInterval( + cftime_datetime(2023, 1, 1, calendar="gregorian"), cftime_datetime(2023, 1, 3, calendar="gregorian") + ), + TimeInterval( + cftime_datetime(2023, 1, 5, calendar="gregorian"), cftime_datetime(2023, 1, 6, calendar="gregorian") + ), + None, + id="non-overlapping intervals", + ), + pytest.param( + TimeInterval( + cftime_datetime(2023, 1, 1, calendar="gregorian"), cftime_datetime(2023, 1, 3, calendar="gregorian") + ), + TimeInterval( + cftime_datetime(2023, 1, 1, calendar="gregorian"), cftime_datetime(2023, 1, 2, calendar="gregorian") + ), + TimeInterval( + cftime_datetime(2023, 1, 1, calendar="gregorian"), cftime_datetime(2023, 1, 2, calendar="gregorian") + ), + id="intervals with same start time", + ), + pytest.param( + TimeInterval( + cftime_datetime(2023, 1, 1, calendar="gregorian"), cftime_datetime(2023, 1, 3, calendar="gregorian") + ), + TimeInterval( + cftime_datetime(2023, 1, 2, calendar="gregorian"), cftime_datetime(2023, 1, 3, calendar="gregorian") + ), + TimeInterval( + cftime_datetime(2023, 1, 2, calendar="gregorian"), cftime_datetime(2023, 1, 3, calendar="gregorian") + ), + id="intervals with same end time", + ), + ], +) +def test_time_interval_intersection(interval1, interval2, expected): + """Test the intersection of two time intervals.""" + result = interval1.intersection(interval2) + if expected is None: + assert result is None + else: + assert result.left == expected.left + assert result.right == expected.right + + +def test_time_interval_intersection_different_calendars(): + interval1 = TimeInterval( + cftime_datetime(2023, 1, 1, calendar="gregorian"), cftime_datetime(2023, 1, 3, calendar="gregorian") + ) + interval2 = TimeInterval( + cftime_datetime(2023, 1, 1, calendar="365_day"), cftime_datetime(2023, 1, 3, calendar="365_day") + ) + with pytest.raises(ValueError, match="TimeIntervals are not compatible."): + interval1.intersection(interval2) + + +@pytest.mark.parametrize( + "td,expected", + [ + pytest.param(np.timedelta64(1, "s"), np.timedelta64(1, "s"), id="noop"), + pytest.param(timedelta(days=5), np.timedelta64(5, "D"), id="single unit"), + pytest.param(timedelta(days=5, seconds=30), np.timedelta64(5, "D") + np.timedelta64(30, "s"), id="mixed units"), + pytest.param(timedelta(days=0), np.timedelta64(0, "s"), id="zero timedelta"), + pytest.param( + timedelta(seconds=-2), np.timedelta64(-2, "s"), id="negative timedelta" + ), # included because timedelta(seconds=-2) -> timedelta(days=-1, seconds=86398) + ], +) +def test_maybe_convert_python_timedelta_to_numpy(td, expected): + result = maybe_convert_python_timedelta_to_numpy(td) + assert result == expected diff --git a/tests/utils/test_unstructured.py b/tests/utils/test_unstructured.py new file mode 100644 index 000000000..e8c296fec --- /dev/null +++ b/tests/utils/test_unstructured.py @@ -0,0 +1,33 @@ +import pytest + +from parcels._core.utils.unstructured import ( + get_vertical_dim_name_from_location, + get_vertical_location_from_dims, +) + + +def test_get_vertical_location_from_dims(): + # Test with nz1 dimension + assert get_vertical_location_from_dims(("nz1", "time")) == "center" + + # Test with nz dimension + assert get_vertical_location_from_dims(("nz", "time")) == "face" + + # Test with both dimensions + with pytest.raises(ValueError): + get_vertical_location_from_dims(("nz1", "nz", "time")) + + # Test with no vertical dimension + with pytest.raises(ValueError): + get_vertical_location_from_dims(("time", "x", "y")) + + +def test_get_vertical_dim_name_from_location(): + # Test with center location + assert get_vertical_dim_name_from_location("center") == "nz1" + + # Test with face location + assert get_vertical_dim_name_from_location("face") == "nz" + + with pytest.raises(KeyError): + get_vertical_dim_name_from_location("invalid_location")