diff --git a/.gitattributes b/.gitattributes deleted file mode 100644 index 4cd36a4..0000000 --- a/.gitattributes +++ /dev/null @@ -1 +0,0 @@ -xcompact3d_toolbox/_version.py export-subst diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..cbd920f --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,10 @@ +version: 2 +updates: + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "weekly" + - package-ecosystem: "pip" + directory: "/" + schedule: + interval: "weekly" diff --git a/.github/workflows/1-prepare-release.yaml b/.github/workflows/1-prepare-release.yaml new file mode 100644 index 0000000..7068d2e --- /dev/null +++ b/.github/workflows/1-prepare-release.yaml @@ -0,0 +1,47 @@ +name: Prepare a Release + +on: + workflow_dispatch: + inputs: + version: + description: "New version to be released" + required: true + +jobs: + prepare-for-release: + runs-on: ubuntu-latest + env: + VERSION: ${{ github.event.inputs.version }} + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + cache: "pip" + + - name: Install Hatch + run: python -m pip install hatch + + - name: Update Package Version + run: hatch version "$VERSION" + + - name: Update Changelog + run: hatch run changelog:build --yes --version "$VERSION" + + - uses: peter-evans/create-pull-request@v4 + name: Create Pull Request + id: cpr + with: + commit-message: "Prepared release ${{ github.event.inputs.version }}" + branch: "prepare-release/${{ github.event.inputs.version }}" + title: "Release ${{ github.event.inputs.version }}" + draft: false + delete-branch: true + body: "Automated changes by [prepare_release](.github/workflows/1-prepare-release.yaml) GitHub action." + + - name: Show Pull Request info + if: ${{ steps.cpr.outputs.pull-request-number }} + run: | + echo "Pull Request Number - ${{ steps.cpr.outputs.pull-request-number }}" + echo "Pull Request URL - ${{ steps.cpr.outputs.pull-request-url }}" diff --git a/.github/workflows/2-tag-release.yaml b/.github/workflows/2-tag-release.yaml new file mode 100644 index 0000000..c9de123 --- /dev/null +++ b/.github/workflows/2-tag-release.yaml @@ -0,0 +1,50 @@ +name: Create tag when PR is accepted + +on: + pull_request: + branches: + - main + - release/** + types: [closed] + +jobs: + create-tag: + if: (github.event.pull_request.merged && startsWith( github.head_ref, 'prepare-release/' )) + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: bluwy/substitute-string-action@v1 + name: Get Tag + id: get-tag + with: + _input-text: ${{ github.head_ref }} + prepare-release/: "" + + - name: Show tag name + run: echo ${{ steps.get-tag.outputs.result }} + + - name: Set up Python + uses: actions/setup-python@v2 + with: + python-version: "3.12" + cache: "pip" + + - name: Install Hatch + run: python -m pip install hatch + + - name: Get hatch version + id: get-hatch-version + run: echo "::set-output name=version::$(hatch version)" + + - name: Verify tag and hatch version + run: | + if [[ "${{ steps.get-hatch-version.outputs.version }}" != "${{ steps.get-tag.outputs.result }}" ]]; then + echo "Tag name does not match hatch version" + exit 1 + fi + + - uses: rickstaa/action-create-tag@v1 + name: Create and Push Tag + with: + tag: v${{ steps.get-tag.outputs.result }} diff --git a/.github/workflows/check-links.yaml b/.github/workflows/check-links.yaml new file mode 100644 index 0000000..ce9fbb0 --- /dev/null +++ b/.github/workflows/check-links.yaml @@ -0,0 +1,23 @@ +name: Check links in Markdown files +on: + schedule: + - cron: "0 0 * * 1" # midnight every Monday + push: + branches: [main] + paths: + - "**/*.md" + pull_request: + paths: + - "**/*.md" + +jobs: + check-links: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: gaurav-nelson/github-action-markdown-link-check@v1 + with: + use-quiet-mode: "yes" + use-verbose-mode: "yes" + folder-path: "docs/" + file-path: "README.md" diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml new file mode 100644 index 0000000..383a228 --- /dev/null +++ b/.github/workflows/ci.yaml @@ -0,0 +1,119 @@ +name: CI + +on: + push: + tags: ["v[0-9]+\\.[0-9]+\\.[0-9]+.*"] + branches: + - main + - release/** + pull_request: + paths: + - .github/workflows/ci.yaml + - hatch.toml + - pyproject.toml + - sonar-project.properties + - tests/** + - xcompact3d_toolbox/** + schedule: + - cron: "0 0 * * 1" # midnight every Monday + +concurrency: + group: "${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}" + cancel-in-progress: true + +jobs: + test: + strategy: + matrix: + os: [ubuntu-latest, windows-latest, macos-latest] + python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"] + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@v4 + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + cache: "pip" + - name: Install Hatch + run: python -m pip install hatch + - name: Install and Show dependencies + run: hatch run +py=${{ matrix.python-version }} test:pip freeze + - name: Run tests + run: | + hatch run +py=${{ matrix.python-version }} test:extended --cov-report=xml:coverage.${{ matrix.os }}.${{ matrix.python-version }}.xml + - name: Upload coverage data + uses: actions/upload-artifact@v4 + with: + name: coverage-${{ matrix.os }}-${{ matrix.python-version }} + path: coverage.*.xml + + sonarcloud: + needs: test + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis + - name: Download coverage data + uses: actions/download-artifact@v4 + with: + pattern: coverage-* + merge-multiple: true + - name: Set project version + run: | + if [[ "${{ github.ref_type }}" == "tag" ]]; then + echo "sonar.projectVersion=${{ github.ref }}" >> sonar-project.properties + fi + - name: SonarCloud Scan + uses: SonarSource/sonarcloud-github-action@master + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # Needed to get PR information, if any + SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} + + build: + needs: sonarcloud + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + cache: "pip" + - name: Install Hatch + run: python -m pip install hatch + - name: Build package + run: hatch build + - uses: actions/upload-artifact@v4 + with: + path: dist/*.tar.gz + name: built-sdist + - uses: actions/upload-artifact@v4 + with: + path: dist/*.whl + name: built-bdist + + release: + needs: build + # upload to PyPI on every tag + if: github.event_name == 'push' && github.ref_type == 'tag' && github.repository == 'fschuch/xcompact3d_toolbox' + runs-on: ubuntu-latest + environment: + name: pypi + url: https://pypi.org/p/xcompact3d-toolbox + permissions: + id-token: write # IMPORTANT: this permission is mandatory for trusted publishing + steps: + - uses: actions/download-artifact@v4 + with: + pattern: built-* + path: dist + + - name: Publish package distributions to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + + - uses: ncipollo/release-action@v1 + with: + draft: true + skipIfReleaseExists: true + generateReleaseNotes: true diff --git a/.github/workflows/docs.yaml b/.github/workflows/docs.yaml new file mode 100644 index 0000000..300fdbe --- /dev/null +++ b/.github/workflows/docs.yaml @@ -0,0 +1,57 @@ +name: Docs + +on: + push: + tags: ["v[0-9]+\\.[0-9]+\\.[0-9]+.*"] + branches: + - main + - release/** + pull_request: + paths: + - .github/workflows/docs.yaml + - docs/** + - xcompact3d_toolbox/** + - hatch.toml + - pyproject.toml + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.12" + cache: "pip" + + - name: Install Hatch + run: python -m pip install hatch + + - name: Build the book + run: hatch run docs:build + + - uses: actions/upload-artifact@v4 + with: + path: build/ + name: documentation + + deploy: + needs: build + if: github.event_name == 'push' && github.ref_type == 'tag' && github.repository == 'fschuch/xcompact3d_toolbox' + runs-on: ubuntu-latest + permissions: + contents: write + steps: + - uses: actions/download-artifact@v4 + with: + path: build/ + name: documentation + + # Push the book's HTML to github-pages + - name: GitHub Pages action + uses: peaceiris/actions-gh-pages@v3.9.3 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: build/_build/html diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml deleted file mode 100644 index 6ba7c0d..0000000 --- a/.github/workflows/python-package.yml +++ /dev/null @@ -1,39 +0,0 @@ -# This workflow will install Python dependencies, run tests and lint with a variety of Python versions -# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions - -name: Python package - -on: - push: - branches: [main] - pull_request: - branches: [main] - -jobs: - build: - runs-on: ubuntu-latest - strategy: - matrix: - python-version: [3.8, 3.9] - - steps: - - uses: actions/checkout@v2 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 - with: - python-version: ${{ matrix.python-version }} - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install flake8 pytest - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - - name: Lint with flake8 - run: | - # stop the build if there are Python syntax errors or undefined names - flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics - # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - - name: Test with unittest - run: | - python -m unittest discover -s tests/unit - python -m unittest discover -s tests/integration diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml deleted file mode 100644 index 0376072..0000000 --- a/.github/workflows/python-publish.yml +++ /dev/null @@ -1,31 +0,0 @@ -# This workflows will upload a Python Package using Twine when a release is created -# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries - -name: Upload Python Package - -on: - release: - types: [published] - -jobs: - deploy: - - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v2 - - name: Set up Python - uses: actions/setup-python@v2 - with: - python-version: '3.x' - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install setuptools wheel twine - - name: Build and publish - env: - TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} - TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} - run: | - python setup.py sdist bdist_wheel - twine upload dist/* diff --git a/.gitignore b/.gitignore index 4468b00..aee3d38 100644 --- a/.gitignore +++ b/.gitignore @@ -20,7 +20,6 @@ parts/ sdist/ var/ wheels/ -pip-wheel-metadata/ share/python-wheels/ *.egg-info/ .installed.cfg @@ -50,6 +49,7 @@ coverage.xml *.py,cover .hypothesis/ .pytest_cache/ +cover/ # Translations *.mo @@ -70,8 +70,10 @@ instance/ # Sphinx documentation docs/_build/ +docs/conf.py # PyBuilder +.pybuilder/ target/ # Jupyter Notebook @@ -82,7 +84,9 @@ profile_default/ ipython_config.py # pyenv -.python-version +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +#.python-version # pipenv # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. @@ -91,7 +95,22 @@ ipython_config.py # install all needed dependencies. #Pipfile.lock -# PEP 582; used by e.g. github.com/David-OConnor/pyflow +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm __pypackages__/ # Celery stuff @@ -109,6 +128,7 @@ venv/ ENV/ env.bak/ venv.bak/ +.hatch/ # Spyder project settings .spyderproject @@ -128,6 +148,19 @@ dmypy.json # Pyre type checker .pyre/ +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + # Xcompact3d's files xcompact3d *.bin diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 23be6fa..59b8204 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -16,6 +16,38 @@ repos: - id: end-of-file-fixer - id: mixed-line-ending - id: trailing-whitespace + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.2.1 + hooks: + # Run the linter. + - id: ruff + types_or: [python, pyi, jupyter] + args: [--fix] + # Run the formatter. + - id: ruff-format + types_or: [python, pyi, jupyter] + - repo: https://github.com/pre-commit/mirrors-mypy + rev: "v1.8.0" + hooks: + - id: mypy + exclude: docs/conf.py + - repo: https://github.com/codespell-project/codespell + rev: v2.2.6 + hooks: + - id: codespell + additional_dependencies: + - tomli + - repo: https://github.com/executablebooks/mdformat + rev: 0.7.17 + hooks: + - id: mdformat + additional_dependencies: + [mdformat-gfm, mdformat-frontmatter, mdformat-footnote] + - repo: https://github.com/kynan/nbstripout + rev: 0.7.1 + hooks: + - id: nbstripout + ci: autofix_commit_msg: "Auto format from pre-commit.com hooks" autoupdate_commit_msg: "pre-commit autoupdate" diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 0000000..8774a2b --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,8 @@ +{ + "recommendations": [ + "ms-python.python", + "ms-python.mypy-type-checker", + "charliermarsh.ruff", + "streetsidesoftware.code-spell-checker" + ] +} diff --git a/.vscode/settings.json b/.vscode/settings.json index 3e0d690..b250698 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,10 +1,29 @@ { - "python.testing.pytestArgs": [ - "tests" + "[python]": { + "editor.formatOnSave": true, + "editor.defaultFormatter": "charliermarsh.ruff", + "editor.codeActionsOnSave": { + "source.fixAll": "explicit", + "source.organizeImports.ruff": "explicit" + } + }, + "editor.rulers": [ + 80, + 120 ], "python.testing.unittestEnabled": false, - "python.testing.nosetestsEnabled": false, "python.testing.pytestEnabled": true, + "files.exclude": { + "**/.coverage*": true, + "**/.hypothesis": true, + "**/.mypy_cache": true, + "**/.pytest_cache": true, + "**/.ruff_cache": true, + "**/.venv": true, + "**/build": true + }, + "cSpell.enabled": true, + "cSpell.language": "en", "cSpell.words": [ "dask", "decomp", @@ -16,5 +35,6 @@ "write", "xdmf", "zfill" - ] + ], + "python.envFile": "${workspaceFolder}/.venv/xcompact3d-toolbox" } diff --git a/MANIFEST.in b/MANIFEST.in deleted file mode 100644 index 02b0553..0000000 --- a/MANIFEST.in +++ /dev/null @@ -1,2 +0,0 @@ -include versioneer.py -include xcompact3d_toolbox/_version.py diff --git a/README.md b/README.md index c3e97f4..b6a09cd 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,11 @@ # Xcompact3d Toolbox -![Build Status](https://github.com/fschuch/xcompact3d_toolbox/workflows/Python%20package/badge.svg) -[![Documentation Status](https://readthedocs.org/projects/xcompact3d-toolbox/badge/?version=latest)](https://xcompact3d-toolbox.readthedocs.io/en/latest/?badge=latest) -[![PyPI version](https://badge.fury.io/py/xcompact3d-toolbox.svg)](https://badge.fury.io/py/xcompact3d-toolbox) -[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) +| | | +| ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| QA | [![CI](https://github.com/fschuch/xcompact3d_toolbox/actions/workflows/ci.yaml/badge.svg?branch=main)](https://github.com/fschuch/xcompact3d_toolbox/actions/workflows/ci.yaml) [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/fschuch/xcompact3d_toolbox/main.svg)](https://results.pre-commit.ci/latest/github/fschuch/xcompact3d_toolbox/main)[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=fschuch_xcompact3d_toolbox&metric=coverage)](https://sonarcloud.io/summary/new_code?id=fschuch_xcompact3d_toolbox)[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=fschuch_xcompact3d_toolbox&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=fschuch_xcompact3d_toolbox) | +| Docs | [![Docs](https://github.com/fschuch/xcompact3d_toolbox/actions/workflows/docs.yaml/badge.svg?branch=main)](https://github.com/fschuch/xcompact3d_toolbox/actions/workflows/docs.yaml)[![Documentation Status](https://readthedocs.org/projects/xcompact3d_toolbox/badge/?version=latest)](https://xcompact3d-toolbox.readthedocs.io/en/latest/?badge=latest) | +| Package | [![PyPI - Version](https://img.shields.io/pypi/v/xcompact3d-toolbox.svg?logo=pypi&label=PyPI)](https://pypi.org/project/xcompact3d-toolbox/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/xcompact3d-toolbox.svg?logo=python&label=Python)](https://pypi.org/project/xcompact3d-toolbox/) | +| Meta | [![Wizard Template](https://img.shields.io/badge/Wizard-Template-%23447CAA)](https://github.com/fschuch/wizard-template) [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/) [![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch) [![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) [![PyPI - License](https://img.shields.io/pypi/l/xcompact3d-toolbox?color=blue)](https://github.com/fschuch/xcompact3d_toolbox/blob/master/LICENSE) [![EffVer Versioning](https://img.shields.io/badge/version_scheme-EffVer-0097a7)](https://jacobtomlinson.dev/effver) | It is a Python package designed to handle the pre and postprocessing of the high-order Navier-Stokes solver [XCompact3d](https://github.com/xcompact3d/Incompact3d). It aims to help users and @@ -14,7 +16,7 @@ The physical and computational parameters are built on top of [traitlets](https: a framework that lets Python classes have attributes with type checking, dynamically calculated default values, and ‘on change’ callbacks. In addition to [ipywidgets](https://ipywidgets.readthedocs.io/en/latest/) for an user friendly interface. -Data structure is provided by [xarray](http://xarray.pydata.org/en/stable/) (see [Why xarray?](http://xarray.pydata.org/en/stable/why-xarray.html)), that introduces labels in the form of dimensions, coordinates and attributes on top of raw [NumPy](https://numpy.org/)-like arrays, which allows for a more intuitive, more concise, and less error-prone developer experience. It integrates tightly with [dask](https://dask.org/) for parallel computing and [hvplot](https://hvplot.holoviz.org/user_guide/Gridded_Data.html) for interactive data visualization. +Data structure is provided by [xarray](https://docs.xarray.dev/en/stable) (see [Why xarray?](https://docs.xarray.dev/en/stable/getting-started-guide/why-xarray.html)), that introduces labels in the form of dimensions, coordinates and attributes on top of raw [NumPy](https://numpy.org/)-like arrays, which allows for a more intuitive, more concise, and less error-prone developer experience. It integrates tightly with [dask](https://dask.org/) for parallel computing and [hvplot](https://hvplot.holoviz.org/user_guide/Gridded_Data.html) for interactive data visualization. Finally, Xcompact3d-toolbox is fully integrated with the new *Sandbox Flow Configuration*. The idea is to easily provide everything that XCompact3d needs from a [Jupyter Notebook](https://jupyter.org/), like initial conditions, solid geometry, boundary conditions, and the parameters ([see examples](https://xcompact3d-toolbox.readthedocs.io/en/latest/tutorial.html#sandbox-examples)). @@ -23,11 +25,11 @@ For developers, it works as a rapid prototyping tool, to test concepts and then ## Useful links -* [Documentation](https://xcompact3d-toolbox.readthedocs.io/); -* [Changelog](https://github.com/fschuch/xcompact3d_toolbox/blob/master/CHANGELOG.md); -* [Suggestions for new features and bug report](https://github.com/fschuch/xcompact3d_toolbox/issues); -* [See what is coming next (Project page)](https://github.com/fschuch/xcompact3d_toolbox/projects/1); -* [Xcompact3d's repository](https://github.com/xcompact3d/Incompact3d). +- [Documentation](https://xcompact3d-toolbox.readthedocs.io/); +- [Changelog](https://github.com/fschuch/xcompact3d_toolbox/blob/master/CHANGELOG.md); +- [Suggestions for new features and bug report](https://github.com/fschuch/xcompact3d_toolbox/issues); +- [See what is coming next (Project page)](https://github.com/fschuch/xcompact3d_toolbox/projects/1); +- [Xcompact3d's repository](https://github.com/xcompact3d/Incompact3d). ## Installation @@ -41,11 +43,6 @@ There are other dependency sets for extra functionality: ```bash pip install xcompact3d-toolbox[visu] # interactive visualization with hvplot and others -pip install xcompact3d-toolbox[doc] # dependencies to build the documentation -pip install xcompact3d-toolbox[dev] # tools for development -pip install xcompact3d-toolbox[test] # tools for testing -pip install xcompact3d-toolbox[all] # all the above - ``` To install from source, clone de repository: @@ -61,10 +58,10 @@ cd xcompact3d_toolbox pip install -e . ``` -You can install all dependencies as well: +You can install additional dependencies as well: ```bash -pip install -e .[all] +pip install -e .[visu] ``` Now, any change you make at the source code will be available at your local installation, with no need to reinstall the package every time. @@ -78,95 +75,105 @@ Click on any link above to launch [Binder](https://mybinder.org/) and interact w ## Examples -* Importing the package: +- Importing the package: - ```python - import xcompact3d_toolbox as x3d - ``` + ```python + import xcompact3d_toolbox as x3d + ``` -* Loading the parameters file (both `.i3d` and `.prm` are supported, see [#7](https://github.com/fschuch/xcompact3d_toolbox/issues/7)) from the disc: +- Loading the parameters file (both `.i3d` and `.prm` are supported, see [#7](https://github.com/fschuch/xcompact3d_toolbox/issues/7)) from the disc: - ```python - prm = x3d.Parameters(loadfile="input.i3d") - prm = x3d.Parameters(loadfile="incompact3d.prm") - ``` + ```python + prm = x3d.Parameters(loadfile="input.i3d") + prm = x3d.Parameters(loadfile="incompact3d.prm") + ``` -* Specifying how the binary fields from your simulations are named, for instance: +- Specifying how the binary fields from your simulations are named, for instance: - * If the simulated fields are named like `ux-000.bin`: +- If the simulated fields are named like `ux-000.bin`: - ```python - prm.dataset.filename_properties.set( - separator = "-", - file_extension = ".bin", - number_of_digits = 3 - ) - ``` + ```python + prm.dataset.filename_properties.set( + separator = "-", + file_extension = ".bin", + number_of_digits = 3 + ) + ``` - * If the simulated fields are named like `ux0000`: +- If the simulated fields are named like `ux0000`: - ```python - prm.dataset.filename_properties.set( - separator = "", - file_extension = "", - number_of_digits = 4 - ) - ``` + ```python + prm.dataset.filename_properties.set( + separator = "", + file_extension = "", + number_of_digits = 4 + ) + ``` -* There are many ways to load the arrays produced by your numerical simulation, so you can choose what best suits your post-processing application. - All arrays are wrapped into [xarray](http://xarray.pydata.org/en/stable/) objects, with many useful methods for indexing, comparisons, reshaping and reorganizing, computations and plotting. +- There are many ways to load the arrays produced by your numerical simulation, so you can choose what best suits your post-processing application. + All arrays are wrapped into [xarray](http://docs.xarray.dev/en/stable) objects, with many useful methods for indexing, comparisons, reshaping and reorganizing, computations and plotting. See the examples: - * Load one array from the disc: +- Load one array from the disc: + + ```python + ux = prm.dataset.load_array("ux-0000.bin") + ``` + +- Load the entire time series for a given variable: + + ```python + ux = prm.dataset["ux"] + ``` - ```python - ux = prm.dataset.load_array("ux-0000.bin") - ``` +- Load all variables from a given snapshot: - * Load the entire time series for a given variable: + ```python + snapshot = prm.dataset[10] + ``` - ```python - ux = prm.dataset["ux"] - ``` +- Loop through all snapshots, loading them one by one: - * Load all variables from a given snapshot: + ```python + for ds in prm.dataset: + # compute something + vort = ds.uy.x3d.first_derivative("x") - ds.ux.x3d.first_derivative("y") + # write the results to the disc + prm.dataset.write(data = vort, file_prefix = "w3") + ``` - ```python - snapshot = prm.dataset[10] - ``` +- Or simply load all snapshots at once (if you have enough memory): - * Loop through all snapshots, loading them one by one: + ```python + ds = prm.dataset[:] + ``` - ```python - for ds in prm.dataset: - # compute something - vort = ds.uy.x3d.first_derivative("x") - ds.ux.x3d.first_derivative("y") - # write the results to the disc - prm.dataset.write(data = vort, file_prefix = "w3") - ``` +- It is possible to produce a new xdmf file, so all data can be visualized on any external tool: - * Or simply load all snapshots at once (if you have enough memory): +- Loop through all snapshots, loading them one by one: - ```python - ds = prm.dataset[:] - ``` +- User interface for the parameters with IPywidgets: - * It is possible to produce a new xdmf file, so all data can be visualized on any external tool: + ```python + ds = prm.dataset[:] + ``` - ```python - prm.dataset.write_xdmf() - ``` +- It is possible to produce a new xdmf file, so all data can be visualized on any external tool: + ```python + prm.dataset.write_xdmf() + ``` -* User interface for the parameters with IPywidgets: +- User interface for the parameters with IPywidgets: - ```python - prm = x3d.ParametersGui() - prm - ``` + ```python + prm = x3d.ParametersGui() + prm + ``` - ![An animation showing the graphical user interface in action](https://www.fschuch.com/en/slides/2021-x3d-dev-meeting/Output.gif) + ![An animation showing the graphical user interface in action](https://www.fschuch.com/en/slides/2021-x3d-dev-meeting/Output.gif) ## Copyright and License +© 2020 [Felipe N. Schuch](https://github.com/fschuch). All content is under [GPL-3.0 License](https://github.com/fschuch/xcompact3d_toolbox/blob/master/LICENSE). diff --git a/changelog.d/+1f5c6649.fixed.md b/changelog.d/+1f5c6649.fixed.md new file mode 100644 index 0000000..5621c2e --- /dev/null +++ b/changelog.d/+1f5c6649.fixed.md @@ -0,0 +1 @@ +Fixed bug on `xcompact3d_toolbox.sandbox.Geometry.from_stl` on some platforms that resolve `np.longdouble` to `np.float128`, which is not compatible with Numba diff --git a/changelog.d/+4517c34f.changed.md b/changelog.d/+4517c34f.changed.md new file mode 100644 index 0000000..a31a5ef --- /dev/null +++ b/changelog.d/+4517c34f.changed.md @@ -0,0 +1 @@ +Changed all arguments on `xcompact3d_toolbox.sandbox.Geometry` to keyword only diff --git a/changelog.d/+548c549a.added.md b/changelog.d/+548c549a.added.md new file mode 100644 index 0000000..27aba11 --- /dev/null +++ b/changelog.d/+548c549a.added.md @@ -0,0 +1 @@ +Configured [sonarcloud](https://sonarcloud.io/project/overview?id=fschuch_xcompact3d_toolbox) to power code quality analysis and coverage tracking on the project diff --git a/changelog.d/+651a832a.changed.md b/changelog.d/+651a832a.changed.md new file mode 100644 index 0000000..28c8376 --- /dev/null +++ b/changelog.d/+651a832a.changed.md @@ -0,0 +1,10 @@ +Modified the way of working on the project by applying the [Wizard-Template](https://github.com/fschuch/wizard-template): + +- [Hatch](https://hatch.pypa.io) now manages Python installations, virtual environments, dependencies, maintenance scripts, and builds +- [mypy](https://mypy.readthedocs.io/en/stable/) for static type checking +- [ruff](https://github.com/astral-sh/ruff) as the linter and code formatter +- [codespell](https://github.com/codespell-project/codespell) to check spelling +- [pytest](https://docs.pytest.org/en/7.4.x/) as the test engine +- [towncrier](https://towncrier.readthedocs.io/en/stable/index.html) handles the changelog file +- [Git hooks](https://pre-commit.com/) to guarantee consistency and leverage the aforementioned tools +- GitHub workflows and dependabot were reviewed to address the previous points diff --git a/changelog.d/+659925a9.fixed.md b/changelog.d/+659925a9.fixed.md new file mode 100644 index 0000000..417a40b --- /dev/null +++ b/changelog.d/+659925a9.fixed.md @@ -0,0 +1 @@ +Fixed compatibility issue on `xcompact3d_toolbox.io.Dataset.load_snapshot` when testing if field `is_scalar` on Python 3.8 diff --git a/changelog.d/+66ff54ce.fixed.md b/changelog.d/+66ff54ce.fixed.md new file mode 100644 index 0000000..7b9a96f --- /dev/null +++ b/changelog.d/+66ff54ce.fixed.md @@ -0,0 +1 @@ +Fixed a bug on `xcompact3d_toolbox.gui._divisor_generator` affecting the coupling between `p_row`, `p_col`, and `ncores` on `ParametersGui._observe_2decomp` method diff --git a/changelog.d/+80ff934b.changed.md b/changelog.d/+80ff934b.changed.md new file mode 100644 index 0000000..052f78b --- /dev/null +++ b/changelog.d/+80ff934b.changed.md @@ -0,0 +1 @@ +Boolean arguments in all functions and methods changed to keyword only diff --git a/changelog.d/+86de082c.added.md b/changelog.d/+86de082c.added.md new file mode 100644 index 0000000..2bb6270 --- /dev/null +++ b/changelog.d/+86de082c.added.md @@ -0,0 +1 @@ +Added support for Python 3.10, 3.11, and 3.12 diff --git a/changelog.d/+a7c50061.added.md b/changelog.d/+a7c50061.added.md new file mode 100644 index 0000000..bf88321 --- /dev/null +++ b/changelog.d/+a7c50061.added.md @@ -0,0 +1 @@ +Added [loguru](https://loguru.readthedocs.io/en/stable/) to enhance logging in the project diff --git a/changelog.d/+b768adc2.changed.md b/changelog.d/+b768adc2.changed.md new file mode 100644 index 0000000..bb569be --- /dev/null +++ b/changelog.d/+b768adc2.changed.md @@ -0,0 +1 @@ +Function `xcompact3d_toolbox.gene_epsi_3D` was renamed to `xcompact3d_toolbox.gene_epsi_3d` diff --git a/changelog.d/+b7e6f42f.changed.md b/changelog.d/+b7e6f42f.changed.md new file mode 100644 index 0000000..93ad8a7 --- /dev/null +++ b/changelog.d/+b7e6f42f.changed.md @@ -0,0 +1 @@ +Changed the project versioning schema to [Intended Effort Versioning](https://jacobtomlinson.dev/effver/) diff --git a/changelog.d/+c71ded6a.fixed.md b/changelog.d/+c71ded6a.fixed.md new file mode 100644 index 0000000..1aaf5f6 --- /dev/null +++ b/changelog.d/+c71ded6a.fixed.md @@ -0,0 +1 @@ +Fixed issue on `xcompact3d_toolbox.sandbox.Geometry.square` that was resulting in a TypeError because `set` object is not subscriptable diff --git a/changelog.d/+c9f0a36f.fixed.md b/changelog.d/+c9f0a36f.fixed.md new file mode 100644 index 0000000..31233ce --- /dev/null +++ b/changelog.d/+c9f0a36f.fixed.md @@ -0,0 +1 @@ +Corrected typos, typing annotating, and formatting issues in the codebase and documentation diff --git a/changelog.d/+f2260584.docs.md b/changelog.d/+f2260584.docs.md new file mode 100644 index 0000000..1734b75 --- /dev/null +++ b/changelog.d/+f2260584.docs.md @@ -0,0 +1 @@ +Replaced documentation framework by [Jupyter Books](https://jupyterbook.org/en/stable/intro.html) to enhance interactive tutorials diff --git a/docs/Makefile b/docs/Makefile deleted file mode 100644 index d4bb2cb..0000000 --- a/docs/Makefile +++ /dev/null @@ -1,20 +0,0 @@ -# Minimal makefile for Sphinx documentation -# - -# You can set these variables from the command line, and also -# from the environment for the first two. -SPHINXOPTS ?= -SPHINXBUILD ?= sphinx-build -SOURCEDIR = . -BUILDDIR = _build - -# Put it first so that "make" without argument is like "make help". -help: - @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) - -.PHONY: help Makefile - -# Catch-all target: route all unknown targets to Sphinx using the new -# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). -%: Makefile - @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/_config.yml b/docs/_config.yml new file mode 100644 index 0000000..f1a4ea5 --- /dev/null +++ b/docs/_config.yml @@ -0,0 +1,98 @@ +# Book settings +# Learn more at https://jupyterbook.org/customize/config.html + +title: Xcompact3d-toolbox +author: Felipe N. Schuch +logo: logo.png +copyright: "2021" +description: A set of tools for pre and postprocessing prepared for the high-order Navier-Stokes solver XCompact3d + +# Force re-execution of notebooks on each build. +# See https://jupyterbook.org/content/execute.html +execute: + execute_notebooks: cache + stderr_output: remove + allow_errors: false + timeout: 120 + +# Define the name of the latex output file for PDF builds +latex: + latex_documents: + targetname: book.tex + +# Add a bibtex file so that we can create citations +bibtex_bibfiles: + - references.bib + +# Information about where the book exists on the web +repository: + url: https://github.com/fschuch/xcompact3d_toolbox # Online location of your book + path_to_book: docs # Optional path to your book, relative to the repository root + branch: main # Which branch of the repository should be used when creating links (optional) + +# Add GitHub buttons to your book +# See https://jupyterbook.org/customize/config.html#add-a-link-to-your-repository +html: + home_page_in_navbar: false + use_edit_page_button: true + use_issues_button: true + use_repository_button: true + +launch_buttons: + notebook_interface: "jupyterlab" + binderhub_url: "https://mybinder.org" + colab_url: "https://colab.research.google.com" + +sphinx: + extra_extensions: + - nbsphinx + - sphinx.ext.autodoc + - sphinx.ext.intersphinx + - sphinx.ext.mathjax + - sphinx.ext.napoleon + config: + #https://github.com/executablebooks/jupyter-book/issues/1950#issuecomment-1454801479 + suppress_warnings: ["mystnb.unknown_mime_type"] + + intersphinx_mapping: + python: + - "https://docs.python.org/3" + - null + xarray: + - "https://docs.xarray.dev/en/stable/" + - null + ipywidgets: + - "https://ipywidgets.readthedocs.io/en/stable/" + - null + traitlets: + - "https://traitlets.readthedocs.io/en/stable/" + - null + numpy: + - "https://numpy.org/doc/stable/" + - null + scipy: + - "https://docs.scipy.org/doc/scipy/reference/" + - null + stl: + - "https://numpy-stl.readthedocs.io/en/stable/" + - null + + napoleon_include_special_with_doc: true + + # Add any paths that contain templates here, relative to this directory. + templates_path: + - _templates + + # List of patterns, relative to source directory, that match files and + # directories to ignore when looking for source files. + # This pattern also affects html_static_path and html_extra_path. + exclude_patterns: + - _build + - Thumbs.db + - .DS_Store + - .i3d + - .bin + - .dat + - .csv + - .out + - .xdmf diff --git a/docs/_toc.yml b/docs/_toc.yml new file mode 100644 index 0000000..cb05b3e --- /dev/null +++ b/docs/_toc.yml @@ -0,0 +1,21 @@ +# Table of contents +# Learn more at https://jupyterbook.org/customize/toc.html + +format: jb-book +root: index +parts: + - caption: Tutorials + chapters: + - file: tutorial/parameters.ipynb + - file: tutorial/io.ipynb + - file: tutorial/computing_and_plotting.ipynb + - caption: Sandbox Examples + chapters: + - file: examples/Axisymmetric_flow.ipynb + - file: examples/Cylinder.ipynb + - file: examples/Square.ipynb + - file: examples/Heat-exchanger.ipynb + - caption: References + chapters: + - file: news.md + - file: Docstrings.rst diff --git a/docs/conf.py b/docs/conf.py deleted file mode 100644 index 27ef7eb..0000000 --- a/docs/conf.py +++ /dev/null @@ -1,97 +0,0 @@ -# Configuration file for the Sphinx documentation builder. -# -# This file only contains a selection of the most common options. For a full -# list see the documentation: -# https://www.sphinx-doc.org/en/master/usage/configuration.html - -# -- Path setup -------------------------------------------------------------- - -# If extensions (or modules to document with autodoc) are in another directory, -# add these directories to sys.path here. If the directory is relative to the -# documentation root, use os.path.abspath to make it absolute, like shown here. -# -import os -import sys - -sys.path.insert(0, os.path.abspath("../")) - - -# -- Project information ----------------------------------------------------- - -project = "Xcompact3d-toolbox" -copyright = "2021, Felipe N. Schuch" -author = "Felipe N. Schuch" -master_doc = "index" - -# -- Get version information and date from Git ---------------------------- - -try: - from subprocess import check_output - - release = check_output(["git", "describe", "--tags", "--always"]) - release = release.decode().strip() - today = check_output(["git", "show", "-s", "--format=%ad", "--date=short"]) - today = today.decode().strip() -except Exception: - release = "" - today = "" - - -# -- General configuration --------------------------------------------------- - -# Add any Sphinx extension module names here, as strings. They can be -# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom -# ones. -extensions = [ - "nbsphinx", - #'sphinx_copybutton', - "sphinx.ext.autodoc", - "sphinx.ext.coverage", - "sphinx.ext.intersphinx", - "sphinx.ext.mathjax", - "sphinx.ext.napoleon", - #'sphinx_last_updated_by_git', -] - -intersphinx_mapping = { - "python": ("https://docs.python.org/3", None,), - "xarray": ("http://xarray.pydata.org/en/stable/", None,), - "ipywidgets": ("https://ipywidgets.readthedocs.io/en/stable/", None,), - "traitlest": ("https://traitlets.readthedocs.io/en/stable/", None,), - "numpy": ("https://numpy.org/doc/stable/", None,), - "scipy": ("https://docs.scipy.org/doc/scipy/reference/", None,), - "stl": ("https://numpy-stl.readthedocs.io/en/stable/", None), -} - -napoleon_include_special_with_doc = True - -# Add any paths that contain templates here, relative to this directory. -templates_path = ["_templates"] - -# List of patterns, relative to source directory, that match files and -# directories to ignore when looking for source files. -# This pattern also affects html_static_path and html_extra_path. -exclude_patterns = [ - "_build", - "Thumbs.db", - ".DS_Store", - ".i3d", - ".bin", - ".dat", - ".csv", - ".out", - ".xdmf", -] - - -# -- Options for HTML output ------------------------------------------------- - -# The theme to use for HTML and HTML Help pages. See the documentation for -# a list of builtin themes. -# -html_theme = "sphinx_rtd_theme" - -# Add any paths that contain custom static files (such as style sheets) here, -# relative to this directory. They are copied after the builtin static files, -# so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ["_static"] diff --git a/docs/examples/Axisymmetric_flow.ipynb b/docs/examples/Axisymmetric_flow.ipynb index 11b7b15..cf161d3 100644 --- a/docs/examples/Axisymmetric_flow.ipynb +++ b/docs/examples/Axisymmetric_flow.ipynb @@ -16,13 +16,13 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "import xarray as xr\n", + "import xarray as xr # noqa: F401\n", "\n", "import xcompact3d_toolbox as x3d" ] @@ -45,7 +45,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": [ @@ -119,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -135,566 +135,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:  (x: 501, y: 73, z: 501, n: 1)\n",
-       "Coordinates:\n",
-       "  * x        (x) float32 0.0 0.04 0.08 0.12 0.16 ... 19.88 19.92 19.96 20.0\n",
-       "  * y        (y) float32 0.0 0.02778 0.05556 0.08333 ... 1.917 1.944 1.972 2.0\n",
-       "  * z        (z) float32 0.0 0.04 0.08 0.12 0.16 ... 19.88 19.92 19.96 20.0\n",
-       "  * n        (n) int32 1\n",
-       "Data variables:\n",
-       "    ux       (x, y, z) float32 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    uy       (x, y, z) float32 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    uz       (x, y, z) float32 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    phi      (n, x, y, z) float32 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0
" - ], - "text/plain": [ - "\n", - "Dimensions: (x: 501, y: 73, z: 501, n: 1)\n", - "Coordinates:\n", - " * x (x) float32 0.0 0.04 0.08 0.12 0.16 ... 19.88 19.92 19.96 20.0\n", - " * y (y) float32 0.0 0.02778 0.05556 0.08333 ... 1.917 1.944 1.972 2.0\n", - " * z (z) float32 0.0 0.04 0.08 0.12 0.16 ... 19.88 19.92 19.96 20.0\n", - " * n (n) int32 1\n", - "Data variables:\n", - " ux (x, y, z) float32 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " uy (x, y, z) float32 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " uz (x, y, z) float32 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " phi (n, x, y, z) float32 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ds" ] @@ -715,22 +158,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Position of the initial interface in the polar coordinate\n", "r0 = 4.0\n", @@ -740,14 +170,14 @@ "if prm.iin == 2:\n", " np.random.seed(seed=67)\n", "\n", - "radius = np.sqrt(ds.x ** 2 + ds.z ** 2.0)\n", + "radius = np.sqrt(ds.x**2 + ds.z**2.0)\n", "\n", "mod = np.exp(-25.0 * (radius - r0) ** 2.0)\n", "\n", "# This attribute will be shown at the colorbar\n", "mod.attrs[\"long_name\"] = \"Noise modulation\"\n", "\n", - "mod.plot();" + "mod.plot()" ] }, { @@ -758,72 +188,14 @@ "\n", "We then add a random number array with the right shape and multiply by the noise amplitude at the initial condition `init_noise` and multiply again by our modulation function `mod`, defined previously.\n", "\n", - "Plotting a `xarray.DataArray` is as simple as `da.plot()` (see its [user guide](http://xarray.pydata.org/en/stable/plotting.html)), I'm adding extra options just to exemplify how easily we can slice the vertical coordinate and produce multiple plots:" + "Plotting a `xarray.DataArray` is as simple as `da.plot()` (see its [user guide](http://docs.xarray.dev/en/stable/plotting.html)), I'm adding extra options just to exemplify how easily we can slice the vertical coordinate and produce multiple plots:" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial Condition for Streamwise Velocity\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial Condition for Vertical Velocity\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial Condition for Spanwise Velocity\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "for key in \"ux uy uz\".split():\n", " #\n", @@ -831,12 +203,10 @@ " #\n", " ds[key] *= 0.0\n", " #\n", - " ds[key] += prm.init_noise * ((np.random.random(ds[key].shape) - 0.5))\n", + " ds[key] += prm.init_noise * (np.random.random(ds[key].shape) - 0.5)\n", " ds[key] *= mod\n", " #\n", - " ds[key].sel(y=slice(None, None, ds.y.size // 3)).plot(\n", - " x=\"x\", y=\"z\", col=\"y\", col_wrap=2\n", - " )\n", + " ds[key].sel(y=slice(None, None, ds.y.size // 3)).plot(x=\"x\", y=\"z\", col=\"y\", col_wrap=2)\n", " plt.show()\n", "\n", "plt.close(\"all\")" @@ -857,29 +227,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial Condition for Scalar field(s)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Concentration\n", "\n", @@ -891,7 +241,7 @@ " #\n", " fun = 0.5 * prm.cp[n] * (1.0 - np.tanh((radius - r0) * (prm.sc[n] * prm.re) ** 0.5))\n", " #\n", - " ds[\"phi\"][dict(n=n)] += fun\n", + " ds[\"phi\"][{\"n\": n}] += fun\n", " #\n", " ds.phi.isel(n=n).sel(y=prm.yly / 2.0).T.plot()\n", " plt.show()\n", @@ -910,7 +260,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -919,7 +269,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -966,13 +316,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.6" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } } }, "nbformat": 4, diff --git a/docs/examples/Cylinder.ipynb b/docs/examples/Cylinder.ipynb index faa78d3..e73a8dd 100644 --- a/docs/examples/Cylinder.ipynb +++ b/docs/examples/Cylinder.ipynb @@ -2,544 +2,543 @@ "cells": [ { "cell_type": "markdown", + "metadata": {}, "source": [ "# Flow Around a Complex Body" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "import matplotlib.pyplot as plt\r\n", - "import numpy as np\r\n", - "import xarray as xr\r\n", - "\r\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import xarray as xr\n", + "\n", "import xcompact3d_toolbox as x3d" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "%load_ext autoreload\r\n", + "%load_ext autoreload\n", "%autoreload 2" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Parameters" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "+ Numerical precision\r\n", - "\r\n", + "+ Numerical precision\n", + "\n", "Use `np.float64` if Xcompact3d was compiled with the flag `-DDOUBLE_PREC`, use `np.float32` otherwise." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "x3d.param[\"mytype\"] = np.float64" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "* Xcompact3d's parameters\r\n", - "\r\n", + "* Xcompact3d's parameters\n", + "\n", "For more information about them, checkout the [API reference](https://xcompact3d-toolbox.readthedocs.io/en/latest/Docstrings.html#xcompact3d_toolbox.parameters.Parameters)." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "prm = x3d.Parameters(\r\n", - " filename=\"input.i3d\",\r\n", - " itype=12,\r\n", - " p_row=0,\r\n", - " p_col=0,\r\n", - " nx=257,\r\n", - " ny=129,\r\n", - " nz=32,\r\n", - " xlx=15.0,\r\n", - " yly=10.0,\r\n", - " zlz=3.0,\r\n", - " nclx1=2,\r\n", - " nclxn=2,\r\n", - " ncly1=1,\r\n", - " nclyn=1,\r\n", - " nclz1=0,\r\n", - " nclzn=0,\r\n", - " iin=1,\r\n", - " re=300.0,\r\n", - " init_noise=0.0125,\r\n", - " inflow_noise=0.0125,\r\n", - " dt=0.0025,\r\n", - " ifirst=1,\r\n", - " ilast=45000,\r\n", - " ilesmod=1,\r\n", - " iibm=2,\r\n", - " nu0nu=4.0,\r\n", - " cnu=0.44,\r\n", - " irestart=0,\r\n", - " icheckpoint=45000,\r\n", - " ioutput=200,\r\n", - " iprocessing=50,\r\n", - " jles=4,\r\n", + "prm = x3d.Parameters(\n", + " filename=\"input.i3d\",\n", + " itype=12,\n", + " p_row=0,\n", + " p_col=0,\n", + " nx=257,\n", + " ny=129,\n", + " nz=32,\n", + " xlx=15.0,\n", + " yly=10.0,\n", + " zlz=3.0,\n", + " nclx1=2,\n", + " nclxn=2,\n", + " ncly1=1,\n", + " nclyn=1,\n", + " nclz1=0,\n", + " nclzn=0,\n", + " iin=1,\n", + " re=300.0,\n", + " init_noise=0.0125,\n", + " inflow_noise=0.0125,\n", + " dt=0.0025,\n", + " ifirst=1,\n", + " ilast=45000,\n", + " ilesmod=1,\n", + " iibm=2,\n", + " nu0nu=4.0,\n", + " cnu=0.44,\n", + " irestart=0,\n", + " icheckpoint=45000,\n", + " ioutput=200,\n", + " iprocessing=50,\n", + " jles=4,\n", ")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Setup" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Geometry" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Everything needed is in one dictionary of Arrays (see [API reference](https://xcompact3d-toolbox.readthedocs.io/en/latest/Docstrings.html#xcompact3d_toolbox.sandbox.init_epsi)):" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "epsi = x3d.init_epsi(prm)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "The four $\\epsilon$ matrices are stored in a dictionary:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "epsi.keys()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "Just to exemplify, we can draw and plot a cylinder. Make sure to apply the same operation over all arrays in the dictionary. Plotting a `xarray.DataArray` is as simple as `da.plot()` (see its [user guide](http://xarray.pydata.org/en/stable/plotting.html)), I'm adding extra options just to exemplify how easily we can select one value in $z$ and make a 2D plot:" - ], - "metadata": {} + "Just to exemplify, we can draw and plot a cylinder. Make sure to apply the same operation over all arrays in the dictionary. Plotting a `xarray.DataArray` is as simple as `da.plot()` (see its [user guide](http://docs.xarray.dev/en/stableplotting.html)), I'm adding extra options just to exemplify how easily we can select one value in $z$ and make a 2D plot:" + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "for key in epsi.keys():\r\n", - " epsi[key] = epsi[key].geo.cylinder(x=1, y=prm.yly / 4.0)\r\n", - "\r\n", + "for key in epsi:\n", + " epsi[key] = epsi[key].geo.cylinder(x=1, y=prm.yly / 4.0)\n", + "\n", "epsi[\"epsi\"].sel(z=0, method=\"nearest\").plot(x=\"x\");" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Notice that the geometries are added by default, however, we can revert it by setting `remp=False`. We can execute several methods in a chain, resulting in more complex geometries." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "for key in epsi.keys():\r\n", - " epsi[key] = (\r\n", - " epsi[key]\r\n", - " .geo.cylinder(x=2, y=prm.yly / 8.0)\r\n", - " .geo.cylinder(x=2, y=prm.yly / 8.0, radius=0.25, remp=False)\r\n", - " .geo.sphere(x=6, y=prm.yly / 4, z=prm.zlz / 2.0)\r\n", - " .geo.box(x=[3, 4], y=[3, 4])\r\n", - " )\r\n", - "\r\n", + "for key in epsi:\n", + " epsi[key] = (\n", + " epsi[key]\n", + " .geo.cylinder(x=2, y=prm.yly / 8.0)\n", + " .geo.cylinder(x=2, y=prm.yly / 8.0, radius=0.25, remp=False)\n", + " .geo.sphere(x=6, y=prm.yly / 4, z=prm.zlz / 2.0)\n", + " .geo.box(x=[3, 4], y=[3, 4])\n", + " )\n", + "\n", "epsi[\"epsi\"].sel(z=prm.zlz / 2, method=\"nearest\").plot(x=\"x\");" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Other example, Ahmed body:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "for key in epsi.keys():\r\n", - " epsi[key] = epsi[key].geo.ahmed_body(x=10, wheels=False)\r\n", - "\r\n", + "for key in epsi:\n", + " epsi[key] = epsi[key].geo.ahmed_body(x=10, wheels=False)\n", + "\n", "epsi[\"epsi\"].sel(z=prm.zlz / 2, method=\"nearest\").plot(x=\"x\");" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Zooming in:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "epsi[\"epsi\"].sel(x=slice(8, None), y=slice(None, 4)).sel(\r\n", - " z=prm.zlz / 2, method=\"nearest\"\r\n", - ").plot(x=\"x\");" - ], + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "epsi[\"epsi\"].sel(x=slice(8, None), y=slice(None, 4)).sel(z=prm.zlz / 2, method=\"nearest\").plot(x=\"x\");" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "And just as an example, we can mirror it:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "for key in epsi.keys():\r\n", - " epsi[key] = epsi[key].geo.mirror(\"y\")\r\n", - "\r\n", + "for key in epsi:\n", + " epsi[key] = epsi[key].geo.mirror(\"y\")\n", + "\n", "epsi[\"epsi\"].sel(z=prm.zlz / 2, method=\"nearest\").plot(x=\"x\");" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "It was just to show the capabilities of `xcompact3d_toolbox.sandbox`, you can use it to build many different geometries and arrange them in many ways. However, keep in mind the aspects of numerical stability of our Navier-Stokes solver, **it is up to the user to find the right set of numerical and physical parameters**.\r\n", - "\r\n", - "For a complete description about the available geometries see [Api reference](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.sandbox.Geometry). Notice that you combine them for the creation of unique geometries, or even create your own routines for your own objects.\r\n", - "\r\n", + "It was just to show the capabilities of `xcompact3d_toolbox.sandbox`, you can use it to build many different geometries and arrange them in many ways. However, keep in mind the aspects of numerical stability of our Navier-Stokes solver, **it is up to the user to find the right set of numerical and physical parameters**.\n", + "\n", + "For a complete description about the available geometries see [Api reference](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.sandbox.Geometry). Notice that you combine them for the creation of unique geometries, or even create your own routines for your own objects.\n", + "\n", "So, let's start over with a simpler geometry:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "epsi = x3d.sandbox.init_epsi(prm)\r\n", - "\r\n", - "for key in epsi.keys():\r\n", - " epsi[key] = epsi[key].geo.cylinder(x=prm.xlx / 3, y=prm.yly / 2)\r\n", - "\r\n", - "epsi[\"epsi\"].sel(z=0, method=\"nearest\").plot(x=\"x\")\r\n", + "epsi = x3d.sandbox.init_epsi(prm)\n", + "\n", + "for key in epsi:\n", + " epsi[key] = epsi[key].geo.cylinder(x=prm.xlx / 3, y=prm.yly / 2)\n", + "\n", + "epsi[\"epsi\"].sel(z=0, method=\"nearest\").plot(x=\"x\")\n", "plt.show();" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "The next step is to produce all the auxiliary files describing the geometry, so then Xcompact3d can read them:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "%%time\r\n", - "dataset = x3d.gene_epsi_3D(epsi, prm)\r\n", - "\r\n", - "prm.nobjmax = dataset.obj.size\r\n", - "\r\n", + "%%time\n", + "dataset = x3d.gene_epsi_3d(epsi, prm)\n", + "\n", + "prm.nobjmax = dataset.obj.size\n", + "\n", "dataset" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Boundary Condition" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Everything needed is in one Dataset (see [API reference](https://xcompact3d-toolbox.readthedocs.io/en/latest/Docstrings.html#xcompact3d_toolbox.sandbox.init_dataset)):" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "ds = x3d.init_dataset(prm)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Let's see it, data and attributes are attached, try to interact with the icons:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "ds" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "**Inflow profile**: Since the boundary conditions for velocity at the top and at the bottom are free-slip in this case (`ncly1=nclyn=1`), the inflow profile for streamwise velocity is just 1 everywhere:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "fun = xr.ones_like(ds.y)\r\n", - "\r\n", - "# This attribute will be shown in the figure\r\n", - "fun.attrs[\"long_name\"] = r\"Inflow Profile - f($x_2$)\"\r\n", - "\r\n", + "fun = xr.ones_like(ds.y)\n", + "\n", + "# This attribute will be shown in the figure\n", + "fun.attrs[\"long_name\"] = r\"Inflow Profile - f($x_2$)\"\n", + "\n", "fun.plot();" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Now, we reset the inflow planes `ds[key] *= 0.0`, just to guarantee consistency in case of multiple executions of this cell. Notice that `ds[key] = 0.0` may overwrite all the metadata contained in the array, so it should be avoided. Then, we add the inflow profile to the streamwise componente and plot them for reference:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "for key in \"bxx1 bxy1 bxz1\".split():\r\n", - " #\r\n", - " print(ds[key].attrs[\"name\"])\r\n", - " #\r\n", - " ds[key] *= 0.0\r\n", - " #\r\n", - " if key == \"bxx1\":\r\n", - " ds[key] += fun\r\n", - " #\r\n", - " ds[key].plot()\r\n", - " plt.show()\r\n", - "\r\n", + "for key in \"bxx1 bxy1 bxz1\".split():\n", + " #\n", + " print(ds[key].attrs[\"name\"])\n", + " #\n", + " ds[key] *= 0.0\n", + " #\n", + " if key == \"bxx1\":\n", + " ds[key] += fun\n", + " #\n", + " ds[key].plot()\n", + " plt.show()\n", + "\n", "plt.close(\"all\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", - "source": [ - "A random noise will be applied at the inflow boundary, we can create a modulation function `mod` to control were it will be applied. In this case, we will concentrate the noise near the center region and make it zero were $y=0$ and $y=L_y$. The domain is periodic in $z$ `nclz1=nclzn=0`, so there is no need to make `mod` functions of $z$. The functions looks like:\r\n", - "\r\n", - "$$\r\n", - "\\text{mod} = \\exp\\left(-0.2 (y - 0.5 L_y)^2 \\right).\r\n", - "$$\r\n", - "\r\n", + "metadata": {}, + "source": [ + "A random noise will be applied at the inflow boundary, we can create a modulation function `mod` to control were it will be applied. In this case, we will concentrate the noise near the center region and make it zero were $y=0$ and $y=L_y$. The domain is periodic in $z$ `nclz1=nclzn=0`, so there is no need to make `mod` functions of $z$. The functions looks like:\n", + "\n", + "$$\n", + "\\text{mod} = \\exp\\left(-0.2 (y - 0.5 L_y)^2 \\right).\n", + "$$\n", + "\n", "See the code:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "# Random noise with fixed seed,\r\n", - "# important for reproducibility, development and debugging\r\n", - "if prm.iin == 2:\r\n", - " np.random.seed(seed=67)\r\n", - "\r\n", - "mod = np.exp(-0.2 * (ds.y - ds.y[-1] * 0.5) ** 2.0)\r\n", - "\r\n", - "# This attribute will be shown in the figure\r\n", - "mod.attrs[\"long_name\"] = \"Noise modulation\"\r\n", - "\r\n", + "# Random noise with fixed seed,\n", + "# important for reproducibility, development and debugging\n", + "if prm.iin == 2:\n", + " np.random.seed(seed=67)\n", + "\n", + "mod = np.exp(-0.2 * (ds.y - ds.y[-1] * 0.5) ** 2.0)\n", + "\n", + "# This attribute will be shown in the figure\n", + "mod.attrs[\"long_name\"] = \"Noise modulation\"\n", + "\n", "mod.plot();" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Again, we reset the array `ds['noise_mod_x1'] *= 0.0`, just to guarantee consistency in case of multiple executions of this cell. Notice that `ds['noise_mod_x1'] *= 0.0` may overwrite all the metadata contained in the array, so it should be avoided. Then, we add the modulation profile to the proper array and plot it for reference:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "ds[\"noise_mod_x1\"] *= 0.0\r\n", - "ds[\"noise_mod_x1\"] += mod\r\n", + "ds[\"noise_mod_x1\"] *= 0.0\n", + "ds[\"noise_mod_x1\"] += mod\n", "ds.noise_mod_x1.plot();" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "Notice one of the many advantages of using [xarray](http://xarray.pydata.org/en/stable/), `mod`, with shape (`ny`), was automatically broadcasted for every point in `z` into `ds.noise_mod_x1`, with shape (`ny`, `nz`)." - ], - "metadata": {} + "Notice one of the many advantages of using [xarray](http://docs.xarray.dev/en/stable), `mod`, with shape (`ny`), was automatically broadcasted for every point in `z` into `ds.noise_mod_x1`, with shape (`ny`, `nz`)." + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Initial Condition" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "Now we reset velocity fields `ds[key] *= 0.0`, just to guarantee consistency in the case of multiple executions of this cell.\r\n", - "\r\n", + "Now we reset velocity fields `ds[key] *= 0.0`, just to guarantee consistency in the case of multiple executions of this cell.\n", + "\n", "We then add a random number array with the right shape, multiply by the noise amplitude at the initial condition `init_noise` and multiply again by our modulation function `mod`, defined previously. Finally, we add the streamwise profile `fun` to `ux` and make the plots for reference, I'm adding extra options just to exemplify how easily we can slice the spanwise coordinate and produce multiple plots:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "for key in \"ux uy uz\".split():\r\n", - " #\r\n", - " print(ds[key].attrs[\"name\"])\r\n", - " #\r\n", - " ds[key] *= 0.0\r\n", - " ds[key] += prm.init_noise * ((np.random.random(ds[key].shape) - 0.5))\r\n", - " ds[key] *= mod\r\n", - " #\r\n", - " if key == \"ux\":\r\n", - " ds[key] += fun\r\n", - " #\r\n", - " ds[key].sel(z=slice(None, None, ds.z.size // 3)).plot(\r\n", - " x=\"x\", y=\"y\", col=\"z\", col_wrap=2\r\n", - " )\r\n", - " plt.show()\r\n", - " #\r\n", - "\r\n", + "for key in \"ux uy uz\".split():\n", + " #\n", + " print(ds[key].attrs[\"name\"])\n", + " #\n", + " ds[key] *= 0.0\n", + " ds[key] += prm.init_noise * (np.random.random(ds[key].shape) - 0.5)\n", + " ds[key] *= mod\n", + " #\n", + " if key == \"ux\":\n", + " ds[key] += fun\n", + " #\n", + " ds[key].sel(z=slice(None, None, ds.z.size // 3)).plot(x=\"x\", y=\"y\", col=\"z\", col_wrap=2)\n", + " plt.show()\n", + " #\n", + "\n", "plt.close(\"all\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "## Writing to disc\r\n", - "\r\n", + "## Writing to disc\n", + "\n", "is as simple as:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "prm.dataset.write(ds)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "prm.write()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Running the Simulation" - ], - "metadata": {} + ] }, { "cell_type": "markdown", - "source": [ - "It was just to show the capabilities of `xcompact3d_toolbox.sandbox`, keep in mind the aspects of numerical stability of our Navier-Stokes solver. **It is up to the user to find the right set of numerical and physical parameters**.\r\n", - "\r\n", - "Make sure that the compiling flags and options at `Makefile` are what you expect. Then, compile the main code at the root folder with `make`.\r\n", - "\r\n", - "And finally, we are good to go:\r\n", - "\r\n", - "```bash\r\n", - "mpirun -n [number of cores] ./xcompact3d |tee log.out\r\n", + "metadata": {}, + "source": [ + "It was just to show the capabilities of `xcompact3d_toolbox.sandbox`, keep in mind the aspects of numerical stability of our Navier-Stokes solver. **It is up to the user to find the right set of numerical and physical parameters**.\n", + "\n", + "Make sure that the compiling flags and options at `Makefile` are what you expect. Then, compile the main code at the root folder with `make`.\n", + "\n", + "And finally, we are good to go:\n", + "\n", + "```bash\n", + "mpirun -n [number of cores] ./xcompact3d |tee log.out\n", "```" - ], - "metadata": {} + ] } ], "metadata": { + "interpreter": { + "hash": "546d5beeb22119d9a20f6c19239ae627cc2b69f70be285d1d696980c89f3c939" + }, "kernelspec": { - "name": "python3", - "display_name": "Python 3.9.5 64-bit ('idp': conda)" + "display_name": "Python 3.9.5 64-bit ('idp': conda)", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -552,16 +551,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.5" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } - }, - "interpreter": { - "hash": "546d5beeb22119d9a20f6c19239ae627cc2b69f70be285d1d696980c89f3c939" } }, "nbformat": 4, diff --git a/docs/examples/Heat-exchanger.ipynb b/docs/examples/Heat-exchanger.ipynb index 9d5d60f..6fb415e 100644 --- a/docs/examples/Heat-exchanger.ipynb +++ b/docs/examples/Heat-exchanger.ipynb @@ -16,13 +16,12 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "import xarray as xr\n", "\n", "import xcompact3d_toolbox as x3d" ] @@ -45,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -145,7 +144,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -161,20 +160,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['epsi', 'xepsi', 'yepsi', 'zepsi'])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "epsi.keys()" ] @@ -188,29 +176,19 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# And apply geo.cylinder over the four arrays\n", - "for key in epsi.keys():\n", - " epsi[key] = epsi[key].geo.cylinder(x=prm.xlx / 2.0, y=prm.yly / 2.0,)\n", + "for key in epsi:\n", + " epsi[key] = epsi[key].geo.cylinder(\n", + " x=prm.xlx / 2.0,\n", + " y=prm.yly / 2.0,\n", + " )\n", "\n", "# A quickie plot for reference\n", - "epsi[\"epsi\"].sel(z=0, method=\"nearest\").plot(x=\"x\", aspect=1, size=5);" + "epsi[\"epsi\"].sel(z=0, method=\"nearest\").plot(x=\"x\", aspect=1, size=5)" ] }, { @@ -222,1039 +200,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x\n", - " nobjraf : 1\n", - " nobjmaxraf : 1\n", - " bug : 0\n", - "\n", - "y\n", - " nobjraf : 1\n", - " nobjmaxraf : 1\n", - " bug : 0\n", - "\n", - "z\n", - " nobjraf : 1\n", - " nobjmaxraf : 1\n", - " bug : 0\n", - "\n", - "number of points with potential problem in x : 0\n", - "number of points with potential problem in y : 0\n", - "number of points with potential problem in z : 0\n", - "\n", - "Writing...\n", - "Wall time: 4.52 s\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:       (obj_aux: 2, obj: 1, x: 128, y: 129, z: 8)\n",
-       "Coordinates:\n",
-       "  * obj_aux       (obj_aux) int32 -1 0\n",
-       "  * obj           (obj) int32 0\n",
-       "  * x             (x) float64 0.0 0.04688 0.09375 0.1406 ... 5.859 5.906 5.953\n",
-       "  * y             (y) float64 0.0 0.04688 0.09375 0.1406 ... 5.906 5.953 6.0\n",
-       "  * z             (z) float64 0.0 0.04688 0.09375 ... 0.2344 0.2812 0.3281\n",
-       "Data variables: (12/28)\n",
-       "    epsi          (x, y, z) bool False False False False ... False False False\n",
-       "    nobj_x        (y, z) int64 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0\n",
-       "    nobjmax_x     int64 1\n",
-       "    nobjraf_x     (y, z) int64 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0\n",
-       "    nobjmaxraf_x  int64 1\n",
-       "    ibug_x        int64 0\n",
-       "    ...            ...\n",
-       "    nxipif_y      (x, z, obj_aux) int64 2 2 2 2 2 2 2 2 2 ... 2 2 2 2 2 2 2 2 2\n",
-       "    nxfpif_y      (x, z, obj_aux) int64 128 2 128 2 128 2 ... 128 2 128 2 128 2\n",
-       "    xi_z          (x, y, obj) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0\n",
-       "    xf_z          (x, y, obj) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0\n",
-       "    nxipif_z      (x, y, obj_aux) int64 2 2 2 2 2 2 2 2 2 ... 2 2 2 2 2 2 2 2 2\n",
-       "    nxfpif_z      (x, y, obj_aux) int64 7 2 7 2 7 2 7 2 7 ... 2 7 2 7 2 7 2 7 2
" - ], - "text/plain": [ - "\n", - "Dimensions: (obj_aux: 2, obj: 1, x: 128, y: 129, z: 8)\n", - "Coordinates:\n", - " * obj_aux (obj_aux) int32 -1 0\n", - " * obj (obj) int32 0\n", - " * x (x) float64 0.0 0.04688 0.09375 0.1406 ... 5.859 5.906 5.953\n", - " * y (y) float64 0.0 0.04688 0.09375 0.1406 ... 5.906 5.953 6.0\n", - " * z (z) float64 0.0 0.04688 0.09375 ... 0.2344 0.2812 0.3281\n", - "Data variables: (12/28)\n", - " epsi (x, y, z) bool False False False False ... False False False\n", - " nobj_x (y, z) int64 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0\n", - " nobjmax_x int64 1\n", - " nobjraf_x (y, z) int64 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0\n", - " nobjmaxraf_x int64 1\n", - " ibug_x int64 0\n", - " ... ...\n", - " nxipif_y (x, z, obj_aux) int64 2 2 2 2 2 2 2 2 2 ... 2 2 2 2 2 2 2 2 2\n", - " nxfpif_y (x, z, obj_aux) int64 128 2 128 2 128 2 ... 128 2 128 2 128 2\n", - " xi_z (x, y, obj) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0\n", - " xf_z (x, y, obj) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0\n", - " nxipif_z (x, y, obj_aux) int64 2 2 2 2 2 2 2 2 2 ... 2 2 2 2 2 2 2 2 2\n", - " nxfpif_z (x, y, obj_aux) int64 7 2 7 2 7 2 7 2 7 ... 2 7 2 7 2 7 2 7 2" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "%%time\n", - "dataset = x3d.gene_epsi_3D(epsi, prm)\n", + "dataset = x3d.gene_epsi_3d(epsi, prm)\n", "\n", "prm.nobjmax = dataset.obj.size\n", "\n", @@ -1277,7 +228,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1293,651 +244,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:  (x: 128, y: 129, z: 8, n: 1)\n",
-       "Coordinates:\n",
-       "  * x        (x) float64 0.0 0.04688 0.09375 0.1406 ... 5.812 5.859 5.906 5.953\n",
-       "  * y        (y) float64 0.0 0.04688 0.09375 0.1406 ... 5.859 5.906 5.953 6.0\n",
-       "  * z        (z) float64 0.0 0.04688 0.09375 0.1406 0.1875 0.2344 0.2812 0.3281\n",
-       "  * n        (n) int32 1\n",
-       "Data variables:\n",
-       "    byphi1   (n, x, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    byphin   (n, x, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    ux       (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    uy       (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    uz       (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    phi      (n, x, y, z) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    vol_frc  (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0
" - ], - "text/plain": [ - "\n", - "Dimensions: (x: 128, y: 129, z: 8, n: 1)\n", - "Coordinates:\n", - " * x (x) float64 0.0 0.04688 0.09375 0.1406 ... 5.812 5.859 5.906 5.953\n", - " * y (y) float64 0.0 0.04688 0.09375 0.1406 ... 5.859 5.906 5.953 6.0\n", - " * z (z) float64 0.0 0.04688 0.09375 0.1406 0.1875 0.2344 0.2812 0.3281\n", - " * n (n) int32 1\n", - "Data variables:\n", - " byphi1 (n, x, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " byphin (n, x, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " ux (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " uy (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " uz (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " phi (n, x, y, z) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " vol_frc (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ds" ] @@ -1951,7 +260,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1976,22 +285,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# This function gives the shape\n", "fun = -((ds.y - prm.yly / 2.0) ** 2.0)\n", @@ -2003,7 +299,7 @@ "fun -= fun.isel(y=0)\n", "fun /= fun.x3d.simps(\"y\") / prm.yly\n", "\n", - "fun.plot();" + "fun.plot()" ] }, { @@ -2015,376 +311,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", - "
<xarray.DataArray 'y' ()>\n",
-       "array(1.)
" - ], - "text/plain": [ - "\n", - "array(1.)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "fun.x3d.simps(\"y\") / prm.yly" ] @@ -2404,22 +333,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Random noise with fixed seed,\n", "# important for reproducibility, development and debugging\n", @@ -2431,7 +347,7 @@ "# This attribute will be shown in the figure\n", "mod.attrs[\"long_name\"] = r\"Noise Modulation - f($x_2$)\"\n", "\n", - "mod.plot();" + "mod.plot()" ] }, { @@ -2445,82 +361,22 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial Condition for Streamwise Velocity\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial Condition for Vertical Velocity\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial Condition for Spanwise Velocity\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "for key in \"ux uy uz\".split():\n", " #\n", " print(ds[key].attrs[\"name\"])\n", " #\n", " ds[key] *= 0.0\n", - " ds[key] += prm.init_noise * ((np.random.random(ds[key].shape) - 0.5))\n", + " ds[key] += prm.init_noise * (np.random.random(ds[key].shape) - 0.5)\n", " ds[key] *= mod\n", " #\n", " if key == \"ux\":\n", " ds[key] += fun\n", " #\n", - " ds[key].sel(z=slice(None, None, ds.z.size // 3)).plot(\n", - " x=\"x\", y=\"y\", col=\"z\", col_wrap=2, aspect=1, size=3\n", - " )\n", + " ds[key].sel(z=slice(None, None, ds.z.size // 3)).plot(x=\"x\", y=\"y\", col=\"z\", col_wrap=2, aspect=1, size=3)\n", " plt.show()\n", " #\n", "\n", @@ -2536,7 +392,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -2576,38 +432,25 @@ "vol_{frc} = \\Delta y ~ [1/2, 1, \\dots, 1, \\dots, 1, 1/2]\n", "$$\n", "\n", - "For a unitary averaged velocity, `vol_frc` must be divided by the domain's heigh. Besides that, for streamwise and spanwise averaged values, `vol_frc` must be divided by `nx` and `nz`.\n", + "For a unitary averaged velocity, `vol_frc` must be divided by the domain's height. Besides that, for streamwise and spanwise averaged values, `vol_frc` must be divided by `nx` and `nz`.\n", "\n", "Finally, `vol_frc` can be coded as:" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds[\"vol_frc\"] *= 0.0\n", "\n", "ds[\"vol_frc\"] += prm.dy / prm.yly / prm.nx / prm.nz\n", "\n", - "ds[\"vol_frc\"][dict(y=0)] *= 0.5\n", - "ds[\"vol_frc\"][dict(y=-1)] *= 0.5\n", + "ds[\"vol_frc\"][{\"y\": 0}] *= 0.5\n", + "ds[\"vol_frc\"][{\"y\": -1}] *= 0.5\n", "\n", - "ds.vol_frc.isel(z=0).plot(x=\"x\", y=\"y\", aspect=1, size=5);" + "ds.vol_frc.isel(z=0).plot(x=\"x\", y=\"y\", aspect=1, size=5)" ] }, { @@ -2619,376 +462,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray ()>\n",
-       "array(0.99994064)
" - ], - "text/plain": [ - "\n", - "array(0.99994064)" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "(ds.vol_frc * ds.ux).sum([\"x\", \"y\", \"z\"])" ] @@ -3002,26 +478,13 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds[\"vol_frc\"] = ds.vol_frc.where(epsi[\"epsi\"] == False, 0.0)\n", "\n", - "ds.vol_frc.isel(z=0).plot(x=\"x\", y=\"y\", aspect=1, size=5);" + "ds.vol_frc.isel(z=0).plot(x=\"x\", y=\"y\", aspect=1, size=5)" ] }, { @@ -3035,7 +498,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -3044,7 +507,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -3093,13 +556,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.6" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } } }, "nbformat": 4, diff --git a/docs/examples/Square.ipynb b/docs/examples/Square.ipynb index d0ff11d..d92348f 100644 --- a/docs/examples/Square.ipynb +++ b/docs/examples/Square.ipynb @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -74,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -104,7 +104,7 @@ " ifirst=1,\n", " ilast=90000,\n", " ilesmod=1,\n", - " iibm=2, # This is experimental, not available at the main repo\n", + " iibm=2, # This is experimental, not available at the main repo\n", " # NumOptions\n", " nu0nu=4.0,\n", " cnu=0.44,\n", @@ -127,7 +127,7 @@ " ri=[0.0], # Zero for numerical dye\n", " uset=[0.0], # Zero for numerical dye\n", " cp=[1.0],\n", - " #iibmS=3, # This is experimental, not available at the main repo\n", + " # iibmS=3, # This is experimental, not available at the main repo\n", ")" ] }, @@ -154,7 +154,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -170,20 +170,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['epsi', 'xepsi', 'yepsi', 'zepsi'])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "epsi.keys()" ] @@ -197,35 +186,22 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEWCAYAAABliCz2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAXY0lEQVR4nO3df7RddXnn8feHAEbAIEhlkFBhdaIzKVMKKwMoa1orWIG6iGtktdD6gw7TzIyC1Dp1cNriLNo6aquttrSaEaqjCNJUp2mNBURZLmcqiwCCJIhkUCERCigi6Aj58cwfZwcPJzfJucm5Z5979vu11l737H322fvZNzfP/d5nf/f3m6pCkjT99mk7AEnSeJjwJakjTPiS1BEmfEnqCBO+JHWECV+SOsKEL0kdYcLXVEhyaJJPJ/lBkm8l+dVd7Jsk707ynWZ5d5KMM16pDfu2HYA0IpcBTwGHAz8LfCbJ7VW1boZ9VwCvBo4DCrge+AbwwbFEKrXEFr7mXJJfSfJE3/JkkhtHePwDgdcAv1dVT1TVl4DVwOt28pE3AO+tqo1VtQl4L3DeqOKRJpUJX3Ouqj5ZVQdV1UHAC4B7gatm2jfJXyT53k6WO3ZyihcBW6rq633bbgd+eif7/3Tz/jD7SlPDko7GJsk+wCeAG6vqQzPtU1VvBN44y0MfBHx/YNtjwHN2sf9jA/selCTl4FKaYrbwNU5/SC8Jv3nEx30CWDSwbRHw+JD7LwKeMNlr2pnwNRZJzgHOBc6uqs272O+DA/X+/mWmG7AAXwf2TbKkb9txwM72X9e8P8y+0tSIjRrNtSTHA9cBr6iqr8zROa6m1+Pm39PrpbMGeOlMvXSS/EfgIuA0ftxL58+qyl46mmq28DUOy4FDgC/1tdY/O+JzvBF4NvAQvRvC/2l7sk/yb5I80bfvh4C/A74K3Al8ptkmTTVb+JLUEbbwJakjTPiSNEeSXJHkoSR37uT9JPlAkg1J7khywlzGM2cJf6YLbcY7uT7JPc3XQ+bq/JI0AT4CnL6L988AljTLCuAv5zKYuWzhf4QdL/Ri4IaqWgLc0KxL0lSqqi8C393FLsuB/1k9Xwaem+SIuYpnzp60raovJjl6YPNy4GXN648CNwL/ZXfH2j/PqoUcOMrwJE2px3n0kar6iT39/Ct/4cD6zne3DrXvLXc8uQ74Ud+mlVW1chanOxK4v299Y7PtgVkcY2jjHlrh8KrafiEP0hvZcEZJVtD7E4eFHMBJOXUM4Uma7z5Xq761N59/5LtbuenaxUPtu98R//dHVbVsb843Tq2NpVNVlWSnfUKb35IrARblUPuOShqTYmttG9fJNgFH9a0vbrbNiXH30vmn7fWp5utDYz6/JO1SAduooZYRWA28vumtczLwWF8VZOTG3cJfTW8s8nc1X/92zOeXpN3axmha+Emuonff8rAkG4F3APsBNEN5rAHOBDYAPwR+fSQn3ok5S/g7udB3AdckOR/4FvDLc3V+SdoTRbF5RCWdqjp3N+8X8KaRnGwIc9lLZ2cX6t1XSROrgK2jKddMHCdAkaQBI6rPTxwTviT1KWDrlA4qacKXpAFj65Q5ZiZ8SepTlDV8SeqCKtg8nfnehC9JzxS2kraDmBMmfEnqU8A2W/iS1A228CWpA3oPXpnwJWnqFbC5pnP2VxO+JPUpwtYpne7bhC9JA7aVJR1JmnrW8CWpM8JWa/iSNP16M16Z8CVp6lWFp2pB22HMCRO+JA3YZg1fkqZf76atJR1J6gBv2kpSJ3jTVpI6ZKsPXknS9CvC5prO1DidVyVJe8ibtpLUEUUs6UhSV3jTVpI6oAq7ZUpSF/Ru2jq0giR1gjdtJakDijgBiiR1hS18SeqAArZ501aSuiBOcShJXVBgLx1J6oKqTG1Jp5WrSvKWJOuS3JnkqiQL24hDkmaytfYZahlGktOT3J1kQ5KLZ3j/J5N8IcltSe5IcubIL6gx9oSf5EjgzcCyqjoWWACcM+44JGkmvfHwM9SyO0kWAJcBZwBLgXOTLB3Y7XeBa6rqeHq58C9Ge0U/1lZJZ1/g2Uk2AwcA324pDkkaMNIZr04ENlTVvQBJrgaWA+v79ilgUfP6YOYwH4494VfVpiR/DNwH/D/guqq6bnC/JCuAFQALOWC8QUrqrF63zKF76RyWZG3f+sqqWtm3fiRwf9/6RuCkgWP8N+C6JBcCBwKnzSrgWRh7wk9yCL3fcMcA3wP+Oslrq+rj/fs137SVAItyaI07TkndNMuxdB6pqmV7ecpzgY9U1XuTvAT4WJJjq2rbXh53B23ctD0N+EZVPVxVm4FPAS9tIQ5JmtE29hlqGcIm4Ki+9cXNtn7nA9cAVNU/AguBw0ZwGTtoI+HfB5yc5IAkAU4F7mohDknaQW945Ay1DOFmYEmSY5LsT++m7OqBfe6jlwdJ8i/pJfyHR3hJT2ujhn9TklXArcAW4Daa0o0kTYJRDZ5WVVuSXABcS69H4hVVtS7JpcDaqloNvBX4H0neQu8WwnlVNSdl7FZ66VTVO4B3tHFuSdqV3miZoyt+VNUaYM3Atkv6Xq8HThnZCXfBJ20lqU9vaIXpfNLWhC9JzzC9QyuY8CVpwDBP0c5HJnxJ6rO9l840MuFL0gBLOpLUAc5pK0kdUcAWW/iS1A2WdCSpC8qSjiR1wvYJUKaRCV+SBtjCl6QOmOUEKPOKCV+S+hRhyzZv2kpSJ1jDl6QuKEs6ktQJ1vAlqUNM+JLUAUXY6k1bSeoGb9pKUgeUN20lqTvKhC9JXeDgaZLUGbbwJakDqmDrNhO+JHWCvXQkqQMKSzqS1BHetJWkzqhqO4K5YcKXpAGWdCSpA3q9dBxLR5I6wZKOJHWEJR1J6oAiJnxJ6ooprejQyp2JJM9NsirJ15LcleQlbcQhSTsoqG0ZahlGktOT3J1kQ5KLd7LPLydZn2Rdkk+M9Hr6tNXCfz/wD1V1dpL9gQNaikOSdjCqkk6SBcBlwCuAjcDNSVZX1fq+fZYAbwdOqapHkzx/JCefwdhb+EkOBn4OuBygqp6qqu+NOw5J2pmq4ZYhnAhsqKp7q+op4Gpg+cA+vwFcVlWP9s5dD43yWvq1UdI5BngY+KsktyX5cJIDW4hDknawfSydYRbgsCRr+5YVA4c7Eri/b31js63fi4AXJfnfSb6c5PS5urY2Sjr7AicAF1bVTUneD1wM/F7/Ts03bgXAQis+ksalgOFLOo9U1bK9POO+wBLgZcBi4ItJ/tVcVD7aaOFvBDZW1U3N+ip6vwCeoapWVtWyqlq2H88aa4CSum2EJZ1NwFF964ubbf02AquranNVfQP4Or1fACM39oRfVQ8C9yd5cbPpVGD9Lj4iSWM0XA+dIXvp3AwsSXJM00HlHGD1wD7/i17rniSH0Svx3Duyy+nTVi+dC4Erm2/AvcCvtxSHJO1oRB3xq2pLkguAa4EFwBVVtS7JpcDaqlrdvPeLSdYDW4HfrqrvjCaCZ2ol4VfVV4C9rXtJ0ujVaIdWqKo1wJqBbZf0vS7gt5plTvmkrSQNmtJHbU34krQDx9KRpG7Y1nYAc8OEL0n9ZtcPf14x4UvSACdA0bx17bdvH8lxXvmC40ZyHGnimfAlqSMs6UhSN8QWviR1QAWGnNxkvjHhS9KgCWzhJ3lbVb0nyZ8xQ4RV9ebdHcOEL0mDJjDhA3c1X9fu6QFM+JI0aAITflX9XfP1o9u3JdkHOKiqvj/MMVqZxFySJtb2B6+GWVqQ5BNJFjUzBd4JrE/y28N81oQvSQNSwy0tWdq06F8NfJbetLGvG+aDJnxJGlRDLu3YL8l+9BL+6qraPGw0u034SS5McsjexSdJ88eEt/A/BHwTOJDe/LcvBEZWwz8cuDnJNUlOTzKdHVQlabsJruFX1Qeq6siqOrN6vgX8wjCf3W3Cr6rfpTeh7uXAecA9Sd6Z5Kf2JmhJmkjDlnNaauEneV6SDyS5NcktSd4PHDzMZ4eq4TdTcD3YLFuAQ4BVSd6zp0FL0sSa4IQPXA08DLwGOLt5/clhPrjbfvhJLgJeDzwCfJjeBLubm/6f9wBv28OgJWkiZbInQDmiqn6/b/0PkvzKMB8c5sGrQ4F/29SJnlZV25K8ahZBStL8MIEPXvW5Lsk5wDXN+tnAtcN8cLcJv6resYv37trZe5I0H7XcA2cYvwFcBHysWV8A/CDJf6BXgV+0sw86tIIkDZrs8fAPBn4NOKaqLk3yk/TKPDft7oM+eCVJgyb7pu1lwMnAuc3648CfD/NBW/iSNGDCSzonVdUJSW4DqKpHk+w/zAdN+JLUrya+l87mJAto/sZI8hPAUBFb0pGkQZNd0vkA8Gng+Un+EPgS8M5hPmgLvwNe+YLj2g5Bml8muKRTVVcmuQU4FQjw6mF7TJrwJWnAhNfwqaqvAV+b7ecs6UhSR9jCl6RBE97C31MmfEnqN/m9dPaYCV+SBtnCl6TpFyb/pu2eau2mbZIFSW5L8vdtxSBJM5rsfvh7rM1eOhcBjrYpabIMOZ/tsH8FNFPD3p1kQ5KLd7Hfa5JUkmWjupRBrST8JIuBX6I3oYokTZZtQy670QyBcBlwBrAUODfJ0hn2ew69RvBuR7zcG2218P+U3kxZU3ovXNJ8NsIW/onAhqq6t6qeojc94fIZ9vt94N3Aj0Z2ETMYe8JvZsl6qKpu2c1+K5KsTbJ2M0+OKTpJYjY1/MO256lmWTFwpCOB+/vWNzbbnpbkBOCoqvrMHFzJM7TRS+cU4KwkZwILgUVJPl5Vr+3fqapWAisBFuXQeXh7RNK8NLsbso9U1R7X3Ju5wd8HnLenx5iNsbfwq+rtVbW4qo4GzgE+P5jsJalNIyzpbAKO6ltf3Gzb7jnAscCNSb5Jb2KT1XN149Z++JI0aHQ1hZuBJUmOoZfozwF+9enTVD0GHLZ9PcmNwH+uqrUji6BPqwm/qm4EbmwzBkkaNKqhFapqS5ILgGvpTTZ+RVWtS3IpsLaqVo/mTMOxhS9J/Ub8UFVVrQHWDGy7ZCf7vmx0Z96RCV+S+qRZppEJX5IGTWm/QBO+JA2Y1sHTTPiSNMiEL0kd4AQoktQhtvAlqRus4UtSV5jwJakbbOFLUhcUUztThwlfkvpM8yTmJnxJGmTCl6RuSE1nxjfhS1K/EY+WOUlM+JI0wBq+JHWEQytIUlfYwpekDhh+gvJ5x4QvSYNM+JI0/XzwSpI6JNumM+Ob8CWpn/3wJak77JYpSV1hC1+SusGbtpLUBQU4eJokdYM1fEnqAPvhS1JXVFnSkaSusIUvSV1hwpekbrCFL0ldUMDW6cz4JnxJGjCtLfx9xn3CJEcl+UKS9UnWJblo3DFI0i5t76mzu2UISU5PcneSDUkunuH932ry4R1JbkjywpFfT2PsCR/YAry1qpYCJwNvSrK0hTgkaUap4ZbdHidZAFwGnAEsBc6dId/dBiyrqp8BVgHvGe3V/NjYE35VPVBVtzavHwfuAo4cdxySNKOaxbJ7JwIbqureqnoKuBpY/ozTVX2hqn7YrH4ZWLz3FzGzVmv4SY4GjgdumuG9FcAKgIUcMN7AJHVWgAx/0/awJGv71ldW1cq+9SOB+/vWNwIn7eJ45wOfHfbks9Vawk9yEPA3wG9W1fcH32++aSsBFuXQKb2FImkSZfgnbR+pqmUjOWfyWmAZ8POjON5MWkn4Sfajl+yvrKpPtRGDJM1otDNebQKO6ltf3Gx7hiSnAb8D/HxVPTmysw9oo5dOgMuBu6rqfeM+vyTt2pA9dIb7K+BmYEmSY5LsD5wDrO7fIcnxwIeAs6rqoZFfTp82eumcArwOeHmSrzTLmS3EIUkzGlUvnaraAlwAXEuvg8o1VbUuyaVJzmp2+yPgIOCvm3y4eieH22tjL+lU1Zfo3ReRpMk0wtEyq2oNsGZg2yV9r08b2cl2wydtJalfzaqXzrxiwpekQdOZ7034kjRoFt0y5xUTviQNMuFLUgcU4CTmkjT9QlnSkaTO2DadTXwTviT1s6QjSd1hSUeSusKEL0ldMPz0hfONCV+S+hXg0AqS1A3W8CWpK0z4ktQBBWwz4UtSB3jTVpK6w4QvSR1QwNbpfNTWhC9Jz1BQJnxJ6gZLOpLUAfbSkaQOsYUvSR1hwpekDqiCrVvbjmJOmPAlaZAtfEnqCBO+JHVB2UtHkjqhoHzwSpI6wqEVJKkDqmCbCV+SusGbtpLUDWULX5K6wAlQJKkbpnjwtH3aOGmS05PcnWRDkovbiEGSZlJAbd061DLfjD3hJ1kAXAacASwFzk2ydNxxSNKMqpkAZZhlCLtr4CZ5VpJPNu/flOToUV/Sdm208E8ENlTVvVX1FHA1sLyFOCRpRrWthlp2Z8gG7vnAo1X1z4E/Ad494st5WhsJ/0jg/r71jc22Z0iyIsnaJGs38+TYgpOkEbbwh2ngLgc+2rxeBZyaJCO7lj4Te9O2qlYCKwGSPP65WnV3yyH1Owx4pO0gGpMUCxjPrkxSLDBZ8YwylhfuzYcf59FrP1erDhty94VJ1vatr2xy13YzNXBPGjjG0/tU1ZYkjwHPYw7+bdpI+JuAo/rWFzfbduXuqlo2dyHNTpK1kxLPJMUCxrMrkxQLTFY8kxRLVZ3edgxzpY2Szs3AkiTHJNkfOAdY3UIckjTXhmngPr1Pkn2Bg4HvzEUwY0/4VbUFuAC4FrgLuKaq1o07Dkkag2EauKuBNzSvzwY+XzU3T361UsOvqjXAmll8ZOXudxmrSYpnkmIB49mVSYoFJiueSYplZJqa/PYG7gLgiqpal+RSYG1VrQYuBz6WZAPwXXq/FOZE5ugXiSRpwrTypK0kafxM+JLUEROf8Cdl3J0kRyX5QpL1SdYluaitWPolWZDktiR/PwGxPDfJqiRfS3JXkpe0GMtbmn+nO5NclWThmM9/RZKHktzZt+3QJNcnuaf5ekjL8fxR8291R5JPJ3luW7H0vffWJJVk2H7wmoWJTvgTNu7OFuCtVbUUOBl404SMAXQRvd5Ok+D9wD9U1b8AjqOluJIcCbwZWFZVx9K7WTZnN8J24iPAYH/ui4EbqmoJcEOz3mY81wPHVtXPAF8H3t5iLCQ5CvhF4L4xxdE5E53wmaBxd6rqgaq6tXn9OL1ktsOQEOOUZDHwS8CH24yjieVg4Ofo9Tigqp6qqu+1GNK+wLObfs0HAN8e58mr6ov0elz063+E/qPAq9uMp6qua7pJA3yZXh/xVmJp/AnwNnoDVmoOTHrCH2rcnXFrRrM7Hrip5VD+lN5/kEmYnucY4GHgr5oS04eTHNhGIFW1Cfhjei3FB4DHquq6NmIZcHhVPdC8fhA4vM1gBvw74LNtnTzJcmBTVd3eVgxdMOkJf+IkOQj4G+A3q+r7LcbxKuChqrqlrRgG7AucAPxlVR0P/IDxliye1tTGl9P7JfQC4MAkr20jlp1pHqyZiJZskt+hV7K8sqXzHwD8V+CSNs7fJZOe8Pdk3J05k2Q/esn+yqr6VFtxNE4BzkryTXqlrpcn+XiL8WwENlbV9r96VtH7BdCG04BvVNXDVbUZ+BTw0pZi6fdPSY4AaL4+1HI8JDkPeBXwa3P1dOcQforeL+fbm5/nxcCtSf5ZS/FMrUlP+BMz7k4zXOnlwF1V9b42YuhXVW+vqsVVdTS978vnq6q1VmxVPQjcn+TFzaZTgfUthXMfcHKSA5p/t1OZjBvb/Y/QvwH42xZjIcnp9EqCZ1XVD9uKo6q+WlXPr6qjm5/njcAJzc+URmiiE/6EjbtzCvA6ei3przTLmS3FMqkuBK5Mcgfws8A72wii+StjFXAr8FV6P+djfXQ/yVXAPwIvTrIxyfnAu4BXJLmH3l8h72o5nj8HngNc3/w8f7DFWDQGDq0gSR0x0S18SdLomPAlqSNM+JLUESZ8SeoIE74kdYQJX5I6woQvSR1hwte8kuRfN+O3L0xyYDPm/bFtxyXNBz54pXknyR8AC4Fn0xu/57+3HJI0L5jwNe804yrdDPwIeGlVbW05JGlesKSj+eh5wEH0xoEZ69SF0nxmC1/zTpLV9IaEPgY4oqouaDkkaV7Yt+0ApNlI8npgc1V9opnz+P8keXlVfb7t2KRJZwtfkjrCGr4kdYQJX5I6woQvSR1hwpekjjDhS1JHmPAlqSNM+JLUEf8fvFJjzOSlO74AAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Here we set the center\n", - "center = dict(x=prm.xlx / 3.0, y=prm.yly / 2.0)\n", + "center = {\"x\": prm.xlx / 3.0, \"y\": prm.yly / 2.0}\n", "\n", "# And apply geo.box over the four arrays\n", - "for key in epsi.keys():\n", + "for key in epsi:\n", " epsi[key] = epsi[key].geo.box(\n", " x=[center[\"x\"] - 0.5, center[\"x\"] + 0.5],\n", " y=[center[\"y\"] - 0.5, center[\"y\"] + 0.5],\n", " )\n", "\n", "# A quickie plot for reference\n", - "epsi[\"epsi\"].sel(z=0, method=\"nearest\").plot(x=\"x\");" + "epsi[\"epsi\"].sel(z=0, method=\"nearest\").plot(x=\"x\")" ] }, { @@ -248,1026 +224,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x\n", - " nobjraf : 1\n", - " nobjmaxraf : 1\n", - " bug : 0\n", - "\n", - "y\n", - " nobjraf : 1\n", - " nobjmaxraf : 1\n", - " bug : 0\n", - "\n", - "z\n", - " nobjraf : 1\n", - " nobjmaxraf : 1\n", - " bug : 0\n", - "\n", - "number of points with potential problem in x : 0\n", - "number of points with potential problem in y : 0\n", - "number of points with potential problem in z : 0\n", - "\n", - "Writing...\n", - "Wall time: 5.32 s\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:       (obj_aux: 2, obj: 1, x: 257, y: 129, z: 32)\n",
-       "Coordinates:\n",
-       "  * obj_aux       (obj_aux) int32 -1 0\n",
-       "  * obj           (obj) int32 0\n",
-       "  * x             (x) float64 0.0 0.05859 0.1172 0.1758 ... 14.88 14.94 15.0\n",
-       "  * y             (y) float64 0.0 0.07812 0.1562 0.2344 ... 9.844 9.922 10.0\n",
-       "  * z             (z) float64 0.0 0.09375 0.1875 0.2812 ... 2.719 2.812 2.906\n",
-       "Data variables: (12/28)\n",
-       "    epsi          (x, y, z) bool False False False False ... False False False\n",
-       "    nobj_x        (y, z) int64 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0\n",
-       "    nobjmax_x     int64 1\n",
-       "    nobjraf_x     (y, z) int64 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0\n",
-       "    nobjmaxraf_x  int64 1\n",
-       "    ibug_x        int64 0\n",
-       "    ...            ...\n",
-       "    nxipif_y      (x, z, obj_aux) int64 2 2 2 2 2 2 2 2 2 ... 2 2 2 2 2 2 2 2 2\n",
-       "    nxfpif_y      (x, z, obj_aux) int64 128 2 128 2 128 2 ... 128 2 128 2 128 2\n",
-       "    xi_z          (x, y, obj) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0\n",
-       "    xf_z          (x, y, obj) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0\n",
-       "    nxipif_z      (x, y, obj_aux) int64 2 2 2 2 2 2 2 2 2 ... 2 2 2 2 2 2 2 2 2\n",
-       "    nxfpif_z      (x, y, obj_aux) int64 31 2 31 2 31 2 31 2 ... 2 31 2 31 2 31 2
" - ], - "text/plain": [ - "\n", - "Dimensions: (obj_aux: 2, obj: 1, x: 257, y: 129, z: 32)\n", - "Coordinates:\n", - " * obj_aux (obj_aux) int32 -1 0\n", - " * obj (obj) int32 0\n", - " * x (x) float64 0.0 0.05859 0.1172 0.1758 ... 14.88 14.94 15.0\n", - " * y (y) float64 0.0 0.07812 0.1562 0.2344 ... 9.844 9.922 10.0\n", - " * z (z) float64 0.0 0.09375 0.1875 0.2812 ... 2.719 2.812 2.906\n", - "Data variables: (12/28)\n", - " epsi (x, y, z) bool False False False False ... False False False\n", - " nobj_x (y, z) int64 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0\n", - " nobjmax_x int64 1\n", - " nobjraf_x (y, z) int64 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0\n", - " nobjmaxraf_x int64 1\n", - " ibug_x int64 0\n", - " ... ...\n", - " nxipif_y (x, z, obj_aux) int64 2 2 2 2 2 2 2 2 2 ... 2 2 2 2 2 2 2 2 2\n", - " nxfpif_y (x, z, obj_aux) int64 128 2 128 2 128 2 ... 128 2 128 2 128 2\n", - " xi_z (x, y, obj) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0\n", - " xf_z (x, y, obj) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0\n", - " nxipif_z (x, y, obj_aux) int64 2 2 2 2 2 2 2 2 2 ... 2 2 2 2 2 2 2 2 2\n", - " nxfpif_z (x, y, obj_aux) int64 31 2 31 2 31 2 31 2 ... 2 31 2 31 2 31 2" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "%%time\n", - "dataset = x3d.gene_epsi_3D(epsi, prm)\n", + "dataset = x3d.gene_epsi_3d(epsi, prm)\n", "\n", "prm.nobjmax = dataset.obj.size\n", "\n", @@ -1290,7 +252,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1306,620 +268,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:       (x: 257, y: 129, z: 32, n: 1)\n",
-       "Coordinates:\n",
-       "  * x             (x) float64 0.0 0.05859 0.1172 0.1758 ... 14.88 14.94 15.0\n",
-       "  * y             (y) float64 0.0 0.07812 0.1562 0.2344 ... 9.844 9.922 10.0\n",
-       "  * z             (z) float64 0.0 0.09375 0.1875 0.2812 ... 2.719 2.812 2.906\n",
-       "  * n             (n) int32 1\n",
-       "Data variables:\n",
-       "    bxx1          (y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    bxy1          (y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    bxz1          (y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    noise_mod_x1  (y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    bxphi1        (n, y, z) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    ux            (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    uy            (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    uz            (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
-       "    phi           (n, x, y, z) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0
" - ], - "text/plain": [ - "\n", - "Dimensions: (x: 257, y: 129, z: 32, n: 1)\n", - "Coordinates:\n", - " * x (x) float64 0.0 0.05859 0.1172 0.1758 ... 14.88 14.94 15.0\n", - " * y (y) float64 0.0 0.07812 0.1562 0.2344 ... 9.844 9.922 10.0\n", - " * z (z) float64 0.0 0.09375 0.1875 0.2812 ... 2.719 2.812 2.906\n", - " * n (n) int32 1\n", - "Data variables:\n", - " bxx1 (y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " bxy1 (y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " bxz1 (y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " noise_mod_x1 (y, z) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " bxphi1 (n, y, z) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " ux (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " uy (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " uz (x, y, z) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " phi (n, x, y, z) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ds" ] @@ -1933,29 +284,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fun = xr.ones_like(ds.y)\n", "\n", "# This attribute will be shown in the figure\n", "fun.attrs[\"long_name\"] = r\"Inflow Profile - f($x_2$)\"\n", "\n", - "fun.plot();" + "fun.plot()" ] }, { @@ -1967,67 +305,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Inflow Plane for Streamwise Velocity\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Inflow Plane for Vertical Velocity\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Inflow Plane for Spanwise Velocity\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "for key in \"bxx1 bxy1 bxz1\".split():\n", " #\n", @@ -2059,22 +339,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Random noise with fixed seed,\n", "# important for reproducibility, development and debugging\n", @@ -2086,7 +353,7 @@ "# This attribute will be shown in the figure\n", "mod.attrs[\"long_name\"] = \"Noise modulation\"\n", "\n", - "mod.plot();" + "mod.plot()" ] }, { @@ -2098,70 +365,37 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds[\"noise_mod_x1\"] *= 0.0\n", "ds[\"noise_mod_x1\"] += mod\n", "\n", - "ds.noise_mod_x1.plot();" + "ds.noise_mod_x1.plot()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Notice one of the many advantages of using [xarray](http://xarray.pydata.org/en/stable/), `mod`, with shape (`ny`), was automatically broadcasted for every point in `z` into `ds.noise_mod_x1`, with shape (`ny`, `nz`)." + "Notice one of the many advantages of using [xarray](http://docs.xarray.dev/en/stable), `mod`, with shape (`ny`), was automatically broadcasted for every point in `z` into `ds.noise_mod_x1`, with shape (`ny`, `nz`)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "**Inflow BC for the passive scalar**: For this case, the choise was a \"smooth\" square wave, because it is differentiable.\n", + "**Inflow BC for the passive scalar**: For this case, the choice was a \"smooth\" square wave, because it is differentiable.\n", "\n", "Notice that Xcompact3d supports multiple scalar fields (controlled by `numscalar`, this example just includes one), so different visualization patterns can be set for each one of them.\n" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Inflow Plane for Scalar field(s)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Concentration\n", "\n", @@ -2170,13 +404,8 @@ "ds[\"bxphi1\"] *= 0.0\n", "\n", "for n in range(prm.numscalar):\n", - "\n", - " ds[\"bxphi1\"][dict(n=n)] += (\n", - " 0.5\n", - " + np.arctan(\n", - " np.sin(2.0 * np.pi * ds.y / prm.yly * 11.5) * (prm.sc[n] * prm.re) ** 0.5\n", - " )\n", - " / np.pi\n", + " ds[\"bxphi1\"][{\"n\": n}] += (\n", + " 0.5 + np.arctan(np.sin(2.0 * np.pi * ds.y / prm.yly * 11.5) * (prm.sc[n] * prm.re) ** 0.5) / np.pi\n", " )\n", "\n", " ds.bxphi1.isel(n=n).plot()\n", @@ -2203,82 +432,22 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial Condition for Streamwise Velocity\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfAAAAGoCAYAAAC5cbd8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9d5Rl133fiX72PunGupWrq6uqcze6EYgMMIFgJkFREmVS0Upjy7LloOe4LM/Yb9azx8t+azyW52ns0cgyFSyZEiWLFEiJmQQIkMg5NICO1aFyvunEvd8f+5xzTxUaFAk0CLdwf71qddW9J+z4C99f2EJrTZ/61Kc+9alPfbqySL7RDehTn/rUpz71qU/fO/UFeJ/61Kc+9alPVyD1BXif+tSnPvWpT1cg9QV4n/rUpz71qU9XIPUFeJ/61Kc+9alPVyD1BXif+tSnPvWpT1cg9QV4nwAQQvwzIcRJIcSLQogPvcI1+4UQD6XX/aEQwv1+t7NPfdpJ3+Xafa8Q4nEhxLNCiN8RQtjp5z8shHhaCPGkEOJRIcQ708/fk36W/fhCiI+l3/22EOJM4bsbvl997VOfiiT6eeB9EkJcDXwKuA3YDXwVOKK1TnZc92ngT7TWfyCE+HXgKa31//19b3Cf+pTSd7N2hRASmAXep7V+SQjxL4FZrfV/EULUgLbWWgsh3gJ8Wmt9dMc7hoGTwLTWuiOE+G3g81rrP/5+9LFPfXol6lvgVyAJIf5WQfs/I4T4xmt85A8Df6C1DrTWZzDM6rYd7xTAe4GMaf0O8LHX+N4+vcnojVi7wAgQaq1fSv/+CvBxAK11S/esmCpwKYvmE8AXtNad19jWPvXpslJfgF+BpLX+da31DcCtwAXg3++8RgjxqzsgwOznVy7xyCngfOHvC+lnRRoBNrTW8Xe4pk99+o70Bq3dFcAWQtyS/v0JYKbwvh8RQrwA/Bnw1y7xjp/AWPlF+tcp9P6rQgjvFTvcpz69jmS/0Q3o02ui/xP4utb6czu/0Fr/gzegPX3q03dL37e1m8LjPwFkwvbLQFL4/jPAZ4QQ7wL+FfD+7DshxCRwHfClwiP/GbAAuMBvAP8U+JeXs8196tN3Q30BfoWSEOLngb3A332F738VeM8lvvoDrfW/3fHZRQoWCTCdflakVWBQCGGnVvilrulTn/5CegPWLlrrB4A70ud/EDhyiWu+KYQ4IIQY1VqvpB//GPAZrXVUuG4+/TUQQvwW8I8v1Y8+9en1pn4Q2xVIQoibMT7oO7TW65fhedcA/41eINDXgMOXCGL7I+C/F4LYntZa/6fX+v4+vXnoDVy741rrpdQC/3PgX2utvy6EOAScSq30m4DPYYLVdHrfg8A/01p/o/CsSa31fBoX8quAr7W+FLzfpz69rtT3gV+Z9HeBYeAbqW/wN1/Lw7TWzwGfBp4Hvgj8nYwBCiH+XAixO730nwL/UAhxEuMT/y+v5b19elPSG7V2/4kQ4jjwNPA5rfXX088/DjwrhHgS+I/AjxeE9z6MdX/vjtf+vhDiGeAZYBT4315LH/rUp1dLfQu8T33qU5/61KcrkPoWeJ/61Kc+9alPVyD1BXif+tSnPvWpT1cgve4CXAjxSSHEkhDi2cJnw0KIrwghTqT/D73e7ehTn/rUpz716S8TfT8s8N8GPrzjs18Bvqa1PoyJGu1HcPapT33qU5/69D3Q9yWILY3m/LzW+tr07xeBd6epGJPAPVrrq/6i51i1qraHh1/fxvapT6+SwvMXVrTWY6/2/v767tP/yPRa1/cr0YfeU9Wra8lffOF3QY89HXxJa73TYPxLS29UIZeJQjGEBWDilS4UQvwi8IsA1tAQU/+oUKRJaNDC/J/Rzr//os+z73Y+M/u9+H3x7/T3bY8t/pH9rgVaaoQqvKP4ru/Uvp3vfaW27xyHV3rWpcbrld51qT4W+1J81s7xe6WxKLxLS50/81LPKL7zUmP6snH5Tm34C+7T0vyd96tw78tuudR6S+nM3/9Hs3yP9Irru9CObWNefO8l2vqy63a28zuNx3dab5e4/2Vr/5Wedal3v1KbXumdl/p8x3d/ISu4VLu/m3ak12xbszv7dql2XuIZr7gOv1P7LtWhwjMuyYP+gjl+WV8Kz3qlpp395X/8Pa/v74ZW1xIe/tKey/Isa/LE6GV50BVCb3gQW5pz+YorX2v9G1rrW7TWt1i1au+LV9osmdAUhbVZXKTZF9lnRUEl9fbnvBIVNkYu2C71rvSCbY/K/sie8UqM71JM4hXeo0Wh7Tvff4k2b7ts20C9/P5cKBT7soNBbBu3/KZLKwLbnrNzPNL/v9NYFv/Pm569Q+iXz+Gl5re4BtK2XJKhY/q+bY6L8/ZKa+d7oEuu76JQkoUxv9SYZO/WYrtitXNedygE+WeXWofFNVj8/BUUl3xcdgqMS83XJfZYfn/xnTsEVC540mu13PE+euv0kkpXoW8v29rZ2tm57i6xTrY/+JUpa/O2tssdAv9S61v31tu2NhTHYuf1f5FxsPP3tC/F/Zh/rdLn7eBDl3zHZSINqMv0781Gb5QFvlioZjQJLH3XdxYZTpFJFIWGMBbLJZnqK2miQm8TVDuft5Nh79wUO9/3Mk39Uv8Xfs8EZd4eXt6tl91XYMZ5k3m5Bp//Xej7y565k7GI3nNzLV/tGLOs74VrLtX37N6d78yfmV2D3jYOL0Muds5xNi0FayJ7RrHt2Thtm192PHYngxLbx/E73v8qhfclacd6/m4Y58vWTXF8i48rrI1tMq3Qt+L34hJ69bYpUGLbPLysrVpsG8dt66eAFGy7vzhfO4VMOr/Z+t3W58I9L3te1pZiu7Jfpd42fnnbdg7UTn6xc1x2IEpZX4v7rtienXv05R/saHP6dz4nl1rXhb+LfOFl112i38U9eEn6LpSWV0+aRL/5hO/loDfKAr8b+Ln0958D/vS7vfESBsi2TbZNYVVim9b/snt3aq+ZZl9gPNl925h0UTPfIaQzRlW8fptm/wpWUa5EFDZcUThmfcv6tI1hqe3Pzf/WYttr8jYIfen27bi4aD1s0x2KjKB4TVIYi4JyVRR8RSt4p8W0cz62fV9QVorWWKYYZJZZ8fU7x3vbOiiMUVFI53OdtiX77GV9LrQrt1ouF2V9LcyV+fsV1iG9sb/UGs/7Umj3NsGuXr7e8v7ssMa2CcVLSrKXv37nZUWBs02Iy5dDuMV2FC3YoiAtzn1xPeZ7uLimXwFl26mUvEyO7WzPjjHYqWgWEYJtbcrmS+34vPhr1obCHsr7sYPnbFOeX6FNO1GcIgKT7x29w/LfSa/0+RVGl8qK2vG9EEL8/4QQJ9PT5m4qfPdzaebUCSHEzxU+d4UQvyGEeEkI8YIQ4uPfj77A98ECF0J8Cng3MCqEuAD8r8C/BT4thPjrwCzmwIA+9alPferTm4w0oF7Zi3q56beB/wv43Vf4/i7gcPpzO/B/A7cLIYYxsusWTJMfE0Lcndbz/1+AJa31ESGExJQK/r7Q6y7AtdY/+Qpfve97f9h2SAolILVM2OEHLMJpwMust+JnOZRUvDcRYO2wvjRoCUIB4uVWQBFCy6mg9YpEoK3t0Fb+3Y42FGHA3DoqXqPJn/eKsFexYTuRggJcadpi+pS3R+8Yl+zeYv+UQGSafzoX2+DI7DZ2XJ/NV3GIdozFNhgwSZ+tizew7V2XhHE1ZnwKY5V3wyrMdwod7pyDwqt6790BNRffcVlI72hDAS7mUmss/71gied7oTfOescUFuHYfL3vtE5V71k7B2MnlNybm8LL2GEFXgIiN9Zmdqt++Xplx3xlnyXpfQXU6lJ7XahXmB9t3viyvZMvpELbsvHdaQFf4r5tAZHFry4F92d92DafhSYWhr3Yt2zcXtYvJRByuxsqR+gK1nk+7rB9zovDU5iTbH+8nvT98l+nJ87t+w6X/DDwu2ls1oNCiMHUzftu4Cta6zUAIcRXMOnRn8KcIX80fb7CnD//faE3PIjte6J0sef7J2Uu2ioGoBSuL8DcO/0/mUDMIcMUgsw3itX7LIfDciZUELrbEUZyHnQJIVAUJtu6VRBW2/zoiciVlp1+Om3pHlPb2cdcou0YvwIDAXqwpNB5n3bCrdvatAMGzJlbgQnnikY6BkIJ856CcpBfW5ifIoSb+7+zflvbGXqxbUXhX1R2dsYGZN9n92dKkBbZOO94aAGmz8ZJi+3rIuv3zvl81aS3zz9FxktvforzsS0grSBwtTTrNWt/PpZFpbCweLMxzvsr2KbQ6eKcFeZ1W/MzqL8oVfT274v/A6aN2T1Zf7O5yb4rKAHZutZW755s32XrPl/+mdJT2Me5WyS9fxv0nPatJ+x6H2+Dnwvra1t/C3t1GwSuX8HFInvukXwdFvZH0SW1TW/Q29ddrvNkBkdhHenCvs7XjCB/T/befJyF3rYVcgXyMi3x7wONCiEeLfz84vd4/xRwvvD3hfSzS34uhBhM//5XQojHhRB/JIR4xayqy01X5Hng23w1urDwM76QaqLbmEdBg99pSGpBz5IsavJFiy1j+tk7dfp/waooWpbbNGzoWUMF4Zm3K7lEZGxGuUZNrjkLyIXnNiuV7Iv0/dn/aVuLQjYXepk2njEEUejfJQY+H7dMkRGYsVYpx08ZbG51FMag+Jxtv2uRz2HOUKweU8xom1KRjknGzDImm6MTBQZWVLrMXIh8PLb57bN29IYxZ4w7m53NjRnrS4zVq6GCopGPXfriHnMvIgW9wcjnOxuHIs+29HYUo2CNXZIKiqJQvcCxouKbtbe4j4oGqkBvs2DzMS+uiR3CIm9ntgbVjrlQvX7unKfcGs2UmGyfSG1Qs6SHzm1rS+GeHCVL11Y+7wXlGQrjusN6zddsprjvRDXUjr/TwcsFcfa+TLMsvPNS794ZbJePubzE+0WBj+xARXpoFNsmNEf4XokfXCbSaJLLV49kRWt9y+V62HdBNuYM+m9rrf+hEOIfAv8O+Jnvx8uvLAsczMYrMJOilqwtbTZi0WJL/+5pmQVBULSQC8wkCxjKqSC4M0ucpPDZTsmS0U6LIbMsrJ4Fve2+lHlQ2NBagIgLVmhBQcit3OwxmRJS2G1CbWcOJCJvR26h5VZQb0wyqyZnfJnykKEOVkFQp3/nlppgm/DImV/2f2rxFq2r7KU5I8kaIXoMFHqMO0M1s3Zsm8esrwVBlPelOK9ZX4uMtzge6dxvs7CL85tZtMkrWFivgoxlu926yse3sDZyxhuLnhLb69J2QKGIYhTaXLTqigI7e0ARpcihV+hZxtBDL3ZY5MV1tc3KhZ6yrbYHAOaKW6YIZyhS2r8eDE9v32dKRi7M2KYcb1PU0327LZhRb+/vNoQlm4/ifkrX0LZ1lFm1hW4WFT9zDfl+2+kqy9Zx/lxV2BtJ79lFBTNXxAprZScV+WD+jGzss3cXxvZlUrqgQLzepNCX5ecy0EXMEbIZTaefvdLnq0AH+JP08z8CbuL7RFeeAO9Tn/rUpz79pSENJOjL8nMZ6G7gZ9No9LcCm2nRsS8BHxRCDKVnd3wQ+FLqK/8cxkcOJrbr+cvRkO+GrjwIXRSgq6Snjb/MT5NZU0kaOJWStguTnFk5dqbFU7D+etZQfk+mFUudf7YtEEoXEKhEmOfqAryn03cVLOwcpooFyPQZhTaKOH1OLCDTqHeu08zyyHyCO+Fnbe418GPBmo0FQn4nKLD3zOLnIhY967fQxt4DeBksuM0izKyQzPooWuZFS0bs6O8OQ1joHe8uBvYUoFSsHgqTz0vmO7W2Bwxue7guBL4VAgZ1Nk/FcbqMlko239oxMPm2dW3pvA+AUcF3rq1sPWVzpMx1OwPPMsot4Cw4s2Bx5+6BpLc+c7Qqs5SzPZGNoe6NiYBtsSpAjsaYzpo9hlVsENs6vTMeJXehFecMtu1VEYttUH2O5Ng7UJeCdS6SnisnR16y3wvrNLe2VdZ23fsdEMV+Fq36dC32Oia2tSF3haQISW6ZZ2tPFcY8u7YQaJuv5yRzIabPV73gttzlVeCdUHhfcS/uWFt/GegVsqIcAK31rwN/DnwEOImxrP+n9Ls1IcS/Ah5JH/Uvs4A24J8C/1UI8R+A5eye7wddcQJ8WxBUQfi8TBhlsJKkt7EzplJgAJlPbiczzhnBToEse1D7Tv9u5muDHUK44MvrQYAFoa1SZh2bHZVv1Kw9kDPz4rPzjZ1tvgK/MnB72pcC09gGfeYXb2eEeaBPxrBSgZC1F5m2P2NwsnfPNl92es/Lxj6jgrKRxyEUx7dwbYamkgrtbfO6Yy4yRpY/Q2T36J7SJnXeNi1BRGYOsufnDLuoJKoeI9Wi146dCtBrofydGcNOBBSEkrY1ZApINkeZcpeNVVxQEDXb5odEgNMLgNwJh+eukbi3JrXVU1i3+adFuubpCTnSOcqVmnxdFvZZUahJbYR3JlxTgbEtXiR9by48c58126H1VNkQ2V5NCgtC6FyZz1wIRWU9H684FYR2wR8udjw338/afJllrBS46U6FVF9KqKf7VBcUrnz/FP322Xhm7U168/2yMWD7mOuUB2TQv7YzhWvHest+z/Zx0Vgovvt1ou9XGtl3yIrKvtfA33mF7z4JfPISn88C77osDfwe6coS4Bnzzhi97AnBLOULYZhxngJW1DR1gUkV/dwFKwudCsskY27mEqF7wlnANt96LnQLDGFnilK2kYwgyDTh7RsoFzC5dSB61kPmB898V6pgmReYXcYYtvlH1XbGnAkHbZELCJGAcno+YxmlPlInY7RsYxI6E+Lpu2SYDnLGfFTPItyGHmRWSlwoUZoKzpzpFnykO9GIbVZBYZ5yX2kaE6Cy7+ysr4W/UwFXVAqwtBHits6fKxLyZ+VKAPQssgy5ydbkZaAeMy2MYTpWyjVt3GY5pczYjLG5J7suH/eCopMJyW1ZEpmQKCqN6Zwqp3CN0Ea2ZmvDLlxTtBQFPYU3tWq1lSoe6d7MkSXdW0t5TEUhmCtHALRZr9kcAfm7twVbZcF66fNllF6Trx2BjOmNRba3KHyWrYkUuchRqKKASwRaglTpWksRPJH+ne3vzEedjXuG3uR7knR9ZspjihKJbI6z/ZIJ6QLilPUNCspdyudk1BPm+X7YGQ8jeuMplNjGK0U6xzkveR2zvDRcziC2NxX1feB96lOf+tSnPl2BdGUJcFH4X4vcMtFSo6yChZTCdCKD2qyeFWOsWHJrI4euUmtPZ1bCK7xfW9povRmEaGtUeh8qs1J7zwfSttDzU2XR3AWIOov2NZq4KFgevcjTXKsuRJZqO4UGE/O9TC0vGaYavmWs6xy+zvJ9LcwHKbyaWTJ5P7OxyODY3OpIkY8o64N5tnJTdCAWOfSrJblFm7XRWDTp55bprwxFbj3l2n6KssgwHbu07yI9dVConlVC2hVt6+0rOutzoU/5+hFs7zMFBCAzwjJLSlNIA6QXIU0PPr8sPkK94/dsDaeQqAyFGedC1oBITOczSwzSsZL0xr1g+UG65hW9qPE8+p6eJV6MrFa99Zav4YK7KId+M4QpLkRqZ3ut+H+GZKXWZu62SITZx0UAKvNLZ+vDydaY2GYtF1GBvE0ZapFZ32nUNpC7TrQkt9CzvVPsczGjIhs3maIguWWrzbO1rc37ssyQDFFIeYpIhLFsC5kTQD4GWV9yqzeh98yEl63h3I2TIUhJr/3KMWtCuSkiFpv9V0x53Ga1p/ds+zx1nWjZG4PXi9Rl+nmz0ZUlwMEwXlvngrgH8ZnvZGA2sir6MzM/XsaM4wIDsTQyECjb/J/DxVYP9paB6BVOyXhGBhunzD17v4gNky36nfN8Zd27TsvsfrGtPaYNKXxaTBmzjMADELHpnwx796Ih8UybldvzIyurAI2nio+ydzCQIqSXQWmZcJYaEdMTqKkgNRu7B+WJVCDk8K0GmSoOmWJimIXOIWlUD8LrpcqQCnvThhz+TOdbW6RKmVkH2XwoJ52vwi7upeQU5oi0T6oHQcpI5Mw8hx9FQbhnQiudK2WZcTVzmypX4WXgcKmQK6bBZX9nSmGmHOUpXlavXYje/OfpRQX/tUj7mSs7BcgWsX195+/Kfs+Oa87qEaTXZ0pPDntHqZKR3ZoFfGYfZYpH1s/sPtWbF5TIxzNfK6LXBu300tNkmCo4KSeTgciVvUzA5fB19t5UIOUKQlHoZW0v7I9MGc7bko4DmfskTaETqnCtRT4+eUxG2ncZiHz/GoUwGyvzex5kaZn1JTOlNeql3WUxCtm6yRSDIlSeKZ65ILd76z7rr4hF6m4BK+jxEnOBWesZ9P96kf4uI8y/T1HoVxRdWQI8ZSQyYbt/Ls4WNrm2KZMeIzTWYWbpmoUuM19agcHnQTdFn4+ApKzMwk+Zg5UJegoWHqZtylPbLZE875a8fT0/NcZqd4zygIaklFqmmewoWHaqoH3LbAPrgqWRfZ1aXTIUWH5qWUS9Qha5xZUNayHAJmfUomfVGAvAbObE07miUWRmmS/eWEEpcwzNO2UocmUFJZBxj2nqFM0o+mSVq1GOyscpKaleLnEWP5CA5YueVSjN39m4yigTcIUJyph1InILRcYi91lmikjRsuspXObvjAnm6y61jC4X7yg+O5sHMOtCeelLLDM+IjYIhEqtpWx9ZOOQPUfZpp/ZOs/mMxOimZApWlnKVfn7RGLmoJhHn/niRSx6bSko0ypFkvK86XSOlGWerdMxVamFl5T0NuRIp0pnNh75fPlm7WX7PLNOe5YwaQxD7z7ozWlSUmmfUmQnpheYieEtudBP5zwp6W0KmtoRUJr9LTKF0C/suwyR0r11py0zRzlqIszzjUKp0nVK6vPuKeE6NVxUGrOSKcq5gp1RNt6p4iPTNoiCUpT77HVvTRiFJ31E+rwM1cuUiNeFNCSX6efNRleWAIccOsqYa85QU+aabV6RbgizEVPNM043htXTRpWnjLALhBE8WRR0ZpUUIoy1ZX4yCztn/KnmqtyUaWlyaEs5yjBAT/eCdjJrLunBazpVMiw/ZbgFKFyolBmkz01Kyljwfs/CygqmZAhF3h6ysTGMcxtlbciCbVImnz+LnsWCTgVDOuZJReXMKamoHpyXBSMl5p2IVLi4mSujp8xk4y5Uak2nSIlhZjIXEEDOtLVTGHs7mxfdE9ipUFBOQeDpHkPKmFW+loopgUkqKDPXQaqMZMFsIu5ZjjIWRlkrKH6vmdL2Z1ZlxsizwMfMWhSRwPJlIV3MCMFcGbF6fUw8jQyySMx0vGNhhKjdC/zKXBUZWb5Mx0ugvJ6VnZRV/g6dISLF9mcWpzBrvxhgKdNxRBvBK7N+0EMwtE2OiGRumGztZfORlDRWV+RCPoedU6VAhGmbC9H4WRBj5lYza1CQlI3Cne05lUHWcS+yW2YwdYpCaUuTlHpGQbYndOrG005h/Euqh1aJHiqVzUce9Z7+WF3Zy4zIlNGUl2XjJBNQXm/dKtfMi4wEVjdFrSJ6KGG617RTmKp07WTtzFAuwyfMfZkbreie6dP/WHRlRaH3qU996lOf/lKR5s3pv74cdGUJ8KKPMoWJiA3ELUNpLFlPF6A/o91KX24rfCFDmVtbVkeSVMzysToS5ZCndQglkL7R5rMc6wyWlZHINf2konLtXkZG67a6ItWeZZqLqxG+RLsau5ulaJlnWb5AJ1n6k/FFZVqvDIwGncPYJWMxZIhBXtAhtc5UyYwFmHHK+pb1T0uQumdd5Jabp/L+ylikkK3alj6TB+4UA2EigUx9rSodW5Om1/MTy8RYRzK1iJKyaVM2D1qC3REk5R7cKcM0qMnV5pmpVSRiUJ65xmoJ4po2VouEpJqug7TL0jfWkJbGRZFUFVZHYnd6AVpI0MU0LUU+fiIBlHmu3ZIoO+0vxhqXSuYpjOpyYFnCIEKyAHsr28x1UlbGTdAVqBRuzoLQZPq7iEGUdJ5GJWKwQ7MOVRo4pRyzFq2ONOs/RTYySyxDk3KUKzINy6y5zNOhHLNulaexfNkLwEyRLlV0TyX0Yj5s0G5q9abogEEXUsRG9+Y/8VJXV2oZSj/trzBjoNNYCCsy6zZb69lzVFmZ+Qpk7gaxumZtSwWqkBaZwf45byirNA4jXReSbe8gWwNa5ihaku495ShkJM3ajXtuHkgtfSVSC978run5o427rpeCV0QPZJTGxyRiG8qSubS0TZ5KmFRVDwUsqTRmwsxZXDFrJKPc/Zamu1npOGe1EbSl0a9rFJsgeb0Tzf+S0pUlwFVhY0EPFktzPxOHPKLZBCdBYqVMMTAbKi+KoYyfKikZJpIxiYysrmGeWbSt8pQR6pHoBT/l+dvp5i4prFgiI7ktAljZYLVlrlhk8J4MjbBISgWYPvPFpZsvqSisrkwjxY0gSco6h8TtlkVSMQwZoZEtSVxTWG2Z+7EzBSaDtA2TNr6IuJ70oEZboy2R+9uyXGKRGMZlt6UZbwsjbKUm8TRWWxpmm/rBs+CcIrpqpf3GJY/GVZ5CapkzLyMkpFHHhYF/MxeBiARWBHFN9ZQVG1Ci559N58lqGYGflHUe/Z+NfVLSBoK0iv5to3BkypxOYd781KpM2PjSMMNIpO4UkxedxRu8ZtK9sbGK8KYCGclckOfCLYXMkQZSzubQahpFVJV0LgxzhRezZwx03JtrGYn0+aa/eRYDIl1ncpu7SAid52VnwjLbV7kykUv7NGDQK9RDyLIXvFToqlRpSdIgL9soddl3gHEzkflyU+U8z+kmj1LPzbnULZQphrlgyoRqYhTuuN5zB+XKX2z2h07bhE7dXNLs5ayOQiZolWP2oE6FdjaGebxB5qdPhbLVFSiPHmye1WlIv7fbqTGhQQQSGZs1qJwCj8j89SVFUiaP05E5Jp9C8JHZU6qsSOj5tTO+I1PlwwoFWOTKRZa/brXl6xrE1qdXT1fWtKQpSHm6VGZBhiZAxPIFqpL56DTKTTe9NhaiFYg80tz4enuMKgv2sTupILDppVKlfk6rI/PIb5mm6gC5j1HGYrtPMEtfUykzTa3qzM9m/K29y7Vr3p+VPVWeyrVtGZqNmAe3lVTPtwmpHy/dfKnA0lbKDL00ACg0gispGURBpRaO1ZHYLSsXQlbboBlWV6LKylg/gSSuK8O003Qw6UvspkVSU1i+NALONYgEEpJ6+n95ByISCsPwBciohxRIXxqGLlPhDVgt2StKklWxy3yeafBW7mP1TV9UGvBlBaYPqILgUT3hva0IS5IysZbMlYnsgAzLl3nksJapzz+rhOWYiOOiZfaqSZCn9SRllSuoRuErWGleTxHN0oeAfJ6UY5h1HoWdWp/589J3ZPuIgr9Zp37dXLFNfdJGYYOkpnppSanlnKW8ZRacKqVKZ5JanLFZA1bXrFe7ZW2zjEUWT4B5jnLN+tYS4qrK/cj5QTzSKF12R9BL0Uz7E0isrkSGZk1nqFEWh6GcNNYhVUAzxS5TgHoZEoZX5Fktrgkus9rSxAG45AGoIu4pKCJMry+rVPkWBsXQPV+2trQZxzQwLxPeSU2RpchmMjhLxYzrKk9Fk3EaSJu+U1kFw8XTxsKGbejHtqI1ljZKfhpol1QUWORIIxheJsPeO15PSaEBpS/Pz5uNriwLvE996lOf+vSXjvoQ+qujK8sC1xTgYGOlWl2RRwprSa41Y4EqJ9ibloEaS4qkrEgGTD6ETKM0VcX4RbF0Dk/nhUUyn21F5dGySdU8x8CB6bUReRqOSv17WfpV3Ehyi1fEBoaTgez5rRPQnkJn0K8k/18GMo/SLlpOGZSf9alYr9rqyjzNLi9Ikr4rKek8lS2pKlQ52Ta2VkeiqglxzbQnbiT5e7KSnEktyWHQuJYY6LAtt0W0ZnXKM6vVbhlLLouWT7yeDy7z8Zo5Sa0gT+WpUCJtl0hSv14asS/S1DSrLcExmQRJRdFL/dIktYR4IDExBSkEnkcSu6nlFAoD28s0Wjst7KGl7rksSoq4poxVm/pJM+vI3rIQyrTxcpDdtBCxQQ6kLw1qkubxGjQkHbvU+pWhyC05GaVTaWuz7lNYXEYid39kRYsyP7+2SN8j8rGRoTTITGAgZuPDTdu3aeX7D20s2SS15ox7xjw3g+bJ8utJo5tT/7JMXSgZhJyRqiQ9KDlFFLJ4iiwDIKmm813S+V7LERBhkC5VMkicqiTbSoSqSmLeGRRSCQNJXNE9hKOkzFim/ctQH1VRBpmIZJ7iaG9YZm7Sta+tdC1oM1ZJSfdSPgVk+fkiStdvGr+hPG32va3z9VzMkMj3clqvQrk6z4cnc4H4Mo/xiCs6R+O0beB9qy3zzBcExI10/yepm83pITPKNuOcozZOP8zsf0S6ogR4Vighr4SWwuDKUyawJ/VdqpJGdiUiZSY6TWXJGK/xR5ln2huWEWapP0tnPlGd+tdS+F05ZkHbm1bO8LVtILgkY+4lI+hVpedXRuheoRNAdmQK5ad+NMe8w96wDfOomc2b54kK42eM6inTqinsDSsXXlqmwTopBBrXk15Klt3LOc2DYtIgKZR5ZxZ8pMqKaCAxkGQBirJbZuPrlNHa63YuKGUsUNUkVyCUp4xAC3vFJuyWJB5M8sAqSOG5tpUKdp37CfMa9SmzFWkwnRlrA5GLWOCsWTnDlpF5Vp7Cl+bcyo6F1bLytudVvFI43t4wvg6V5gVnp5Il+d+pQlNWOFuW6VcksLckqpxgddOUnZIy/navMGivljTEQzHZufVYOmeyVkdiN2XP5dG0zBx0JfaWzGFW5ShkYGIb8rSrqiKuJXkVPRka4Wn2jUL6gngozuMtVCVBRpmrB3Sah58x9CzNK6kn+bpOKsrA+kLnCleWc5/UFKR5/VoaV1E2D7IriQdjZCBxmmbPykCgXdOXTJG2ukbg2W0jHPMUyxQ2djasvKiN7Mo8/iSvv6/ICxXlFQ0leUBs7k5I4zBUGgzrNGWuQMvUhWZ1zBzEDbOuM5+29pRxIaWKZhZfEg0mSN8ogplby8TGaOKhuHcinquxmxKrZZn9lqbO5al/Xi+QVQsz91laYVarIm4kJhDWN2MWD8UmALNk1mhS1nklOXvTSmN5zNrLYH7LFz33nBaoSoKzZfF6kcZY4Jfj581GV5QALxbRyMuEpv7pLIhMVRKzkTxjWcsY7LbEWbeQIVhbltG+S8ZyjQeTXvlTjJKgXU1ST1I/YCrs2hJ3NRUcQkMkcgGEAruZWugVhb1h54wBbfy9qpJas9VkW+6lcpRhYkNx6hc23yUDCdhGOYgHEuzUF2w1e5pyMpD0rNZymnObBsAkVZUL7vxdnsJqWYgo9QV7Gp0GZeU+yaysq6WRnV6AXWZ1JylikVmICIhGo20BenZLEo1EvXenRVyyAy1USeXohPYUVmDGNysjm6EsWd56XDfjp0omgj8pp5HPNr28cV/m0fMiNj5Ny+/lCmeWS6asZOOXVeAjjTiWsbkv8zcqT/d87k4asyAwftqMya9b23KoXzWlqERSNQ9TJYW7Yud+yriR5IVjlGPGL671Ivoz6y4pG0VKVRKzH9K8daHMmk3qiVEGAiMMlauxN+xcKXVXbOIBlfpktdkzvhGMSUnnvlNry8rH3+oY4as8TTyQpEiTEYjuqgWREdBaGnQgThVV5SlzX4oGiVjkinK2n6AX3JUhZJnihzZKZlRPFZL0c8tPiwclxnImjZcQkSAaiXOBBaT9IS8+ZKLvzf058mJpVM0oRXFNEQ/G2Bs2SVnjblgoF2THwt2UeXlgZ9MyKENaNMbdsJAxeZ64jIyiYWJQJFnFv0zxTko6L4trdWWaJaNy5UWmhaNEirRoS+cWeFIzaKO9YZu4gkrSqwaXUlzpZeEoT+GkSq2pitcbg7yy5etISovL8vNmo74PvE996lOf+vSGUWaB9+l7pyvKAs/SXtx1C1VNkK3UX9gxMK12NYQGMrW3LOLhmHA0JhpIiEbiNLIcgonIaJ4DMSTk0HpSVr1Uk/QzhIY0kjccTgpR6JJoOM79WFnZURlI4tSC0l5qwbQksmOR1BPjb0ohzLiq8ghqLQ185qzaxHVjldsbFu6KgW+z/MykrnqHL7Qtk64TprChNghDpo1n46WcXipdPJAYWK0tSWoxWU35pJzClb40FmgsUbUkrwoFBmZ0UqRBCxMhTCQQoTTQfCixW+n4BcZiiIaNlZ3UY1TVWDAihT5l18JqGj+hco0vXQYmpzcr+5hVCbO2LFQ5IRiPzRypNL81hcaVq8hS5GQoiBoJcdVY+1kVPOXqnntDg2xZ+XxpR5MMJGmEubE+4oEEncK44XiUp5HJtpVHvMvU960vg4UiEoHVLECVAoLxGC3A2ZKIMPVja/Od9KVBaUrGX09aQlZ7xmK0141+nsGvST02llSWR5zFUqR1smXXAiUIR+MebGuRVijMfKepuyD1U8v0GuUaNAfM3suqtIlIEI4khfxjM292R6RxDAZtkW3LRJwPxGjXzKvVMd/ZzXTdVkwfRJi+M3Mdpda13TTrUCTm3dFQYqxcDSQCe9O4bUhzqqUvEaFBN0zKoTCoTM24BqLRCFVOkG0LbG383WmEPVEPZQoHE1C9HPPMis+s86xcaVYuVsSgXbMntG3GM2yotKKbgcaThtmjmbWdVAxqpT2Vl/CNK4YXWkEaW5OmrYUjCcSpi0waq1sEKQoZpOmAHYm7aVxE3oJtIP5C7rjdFvka9Jbsy5Mm2afLTleWABfaCOXhBBFI7LaBp7flLZaTvJCBu2QjwtRfmPqEnS2B1bQRkaA055h8y5LJrc2KLmT+cBOYRRoop3FXDISeBTm5y45JfwrNhrI3rDy9JRo1EUXSl4ZZphvF3rJMulrTMvDihsyDuMLdEdGAyeFOqgna0UQDing4Nv4vZVK83A3T5qQRG/97NUnhVSPgtYXxnw4a/5cMRBpoBt6ijYgk0URk/NS+UUQyH7qB9c0G12nQT8aAhIK4amD9LOgv86cbISMIdqWRVI5JJ5OBwGpZ2Os2sm1hbVo4W9IU5RCmjcmAESxxTWE3DVNRns6DjuymCS60WjbOqp2WwwWSrDY7uGuWqTWd/b1hBH7GrK2ORNcSvDkHPGUUuooRJO6mxFuysZqWGcM0vc7esshOoBKJyIW/cs2cxDUTjBWORUaBeo1kYFOVByW5y2aduhuSYMIkPOenzu1QdPIiOUMxVttKYyuMomX8qhJn2UHGAm/ZymF67Zn8fqsrSKoJSS1BdlNB1TGxHqpkIGOrLdHp71gGKhepy8HqSKymZaDvVLhnAicrN6stEzCW+XCTEaMoIMFOXR5CYuIsPE3SSEysgjDrWXsKb94x17dM3YNiShda4K7YvZK/liapJkaBThW1uGaU40z5TsqpG2TL+O2tLStNKdR48w6yk74/NtC7u2qRlBXemjQKaMsoUTqtTx4PGgVTuyaoMNhllABTv8DYA0kaa4ISWO00niVTmKrG2LCatnELVBKiiSgV3OAuOfk7klpCMBkZmN/VRA2Fu24EtbeW1jQolIUNx2LsVlo3I41HyIpXqYop2hSPhySeJthl+IOJjUnT214n0ggS5GX5ebPRlQWhayN87aax4BIXsxEGIoRvgaew1+3cN6YtI3xlklrkQzFJKS3gUtbE4zHeBYd40AgSIUC0LNwNmR/aEQ8mCCst6iFNfqmWhpnolGmJBPypiNJFh8iBaCTGm3cIx2Okb/zb7opNNGiEs86KiHgKoSyikZjSnGOi1WUarNc1gVnuusSfMsEywWSEtWkTzIQQSbx5h7iisddMG4KZENq20fSDNLCpkeAu2YQNhbtmmc0IuBcdlIthwqHA2ZREDYWux+AbJuasW6b6WCwQqUXlbAmCssZuWQS7IrwFh3B3SOm8S1IyvlShMcInDXINxhO8JYugnpCUIEkE7pqFSsx7ARIPLB+CPSHWioOdKkX+ZJxXD4Ms+hacliAom2jicCwy1mkqxISGYHeIXE8jFdPgnERokorGXrFNznwjJq7IXvyANsFt8USIDpzczxnsik38QVtipdafTGuUawHCt1DD0WVb5rJlEdcVzpaxHoNxk01hdwTBaJLXISgeBakxyIa7ZNZRPBqDsnHWLeIBI7SEMoVngrpBC+yWRCiZ+tElsmtiG+KJ0DDzhkEgnBUHkRg/v5Aa77xLOGhQC3tFEIwleTCVVBANm4n3FmxCxwSBJaMR9rJDPBbhXnAJp0O88y5xWiMg2BVhr9t45x0zrhYQG4s4cTTWqo1IBOFUCB0LSxtUS5UV7rKN2p0QeQqrZaMGI1PZMAtiddMiPB5oR6Ej811cT/JAQGWRKy/umkXiaoKJmNK8mX9n1SayIBxJkF1JMG6sbuWZfayBYDLBatop8qVQjRgB2Isu0UiEqoO97OCsmj1qd0xwqnbSqP3hCNGy8wh97SlKcw7+VGT4x2RInAjcZYdwKEUfAHfd9DOYjvBLCuEo8C28JSvNpU+rFUYQjseGZwWSaMhoFO6SnS8iZ8ElaphxUbZBH50NuS2w9fWgN6P/+nLQG6qyCCH+gRDiOSHEs0KITwkhSt/x+gRUIyIcSQhmQuLxyECJ644JQpKaZDjKTyyKBhPiQZPqFA8k2Os2WkI0GRrNP0grDIWS8nkHe8nJ4eI8hcbSeKsSKglOU2C3BbqWRgaHxlIPJ0xQTDCs8tPIhDIMLBqOjWWYnfaTwZ+xEaJRXSMsTeIZSCwZi7A7wsCB9TgV0LYJEkotIzqWYY5TIWCYX2ahUUlQaWnXrCiEcsBdtQingzw9DchTkkrLlrG6A4G97OQR8pYvcFommlbGEA3HRHWz4aMBhbPsEA4mWCuGoUQjcR41HQ0o0yZtnuvvNgLOXbRTK99E4AZ7QsJBRTxkni03nHyugz2hUaJqJgDHQOZG6Uhcw4yj4RiRpnbJMLVWRxLsZce4WVL4Ma6pPL0trug8cMvuGGXCW7RNtTzXCKhkOEJ2DAN0Vm3D1GuKcCjJD9AIp8O8Cpt70b0MO8Kkt6lqdm4mIM3c5RaQBG8tLRzkS3Q1MehCSaEbcT5mctNG25poJMZZt3CavcqDdlvirlioksYKDTpkBeSn29G1cC+aeShddIh3hUSjsWlDxyLYG6AqCd6ijbbS1LJ6jLsliKsm8E5oCGfCnoW/4pi9gBk3ue7kxXTcVcu4brqCYCIhHDRzlQU1khUbESA3HLwVkyKnS8ZtEk2GZs+lgZbWikPpooO9ZSBj2U3dJLZxK4hEGKFn9TIe4onQoFOJcZVZoUGOgj2hcRMl4C2ZTASnZYLjpG8Em7XsGKHoaJJabJSUdSu3srPyqKTuCisgT3OzOsZY0J7CXnKNe6FtXHRWy8afNMZANJhAJBGOJqobBEBEBnEI9oYoB+wlU7rNO+fiLVrEFaP0yyAN6MyOJU7TEkVosjWENn1TFVN8BmWQEBmb/WR4THwZ1nefLje9YQJcCDEF/DJwi9b6Wky1zZ94o9rTpz71qU99+v5TP43s1dMb7TSwgbIQwgYqwNx3vFqDTkzgS+mMi7PogAJ3w5i27nkX96JLMhYhEkFp0fi+7bbxL2WHjtA1ATOleQMp221JdyYi3h1QWpaEw4kJWEt9xokLomkT19L83K6EsoGZdMNYas6qQ2lZpvnO5uCLYDpCOApn3TJBIZWEaHeIuy4IJiKCXcb3a63axGOR0aqlseCtAFACZ8v405yWyI9Q9FYtgmGF3HRMcFrHBD5Zaw72ig3CBGuVFk1OdjxgfGW0bJOuNRIYv5erkR2LuGwCduxu6udbM+lGaAhGTOCZ3RLgKtRwRFIxfrV4V4i3apGMxFhdgTfnYG9YhLtD4+9MU73spsRddox/VJoCOyhhrKEt20C5fpbyJ0gaiYFQAzPOIhF4izaUTJCZt2CbACbfwlmzzXXCjJG/OwInrQ0epZZqKHC2zJrJ6rXjpqU66yaGItgX5MFQWpj5djYkST21GkeNL5VqTFRXhFMR+JJwKkSNRNtK4r5qSnPwvQUbPZC6DioJ4aAJJowaCqspCRsGaYonAwNLTwa93PGuRbQ7MAeZtExOcbQ7wJ8y6834fRXhiElJ8/eFOGs2iQfesoVlQB3CPWYOo7rGm3WNz9oza4+m8Q2HuyPCmYB4KKZ0xiVs9NAD2bKwlxwD1dYVSYrMyHUHrYxFGw4aXDacCpGhJJyI8ZaM/9bqCsoXbdMnR0PN5KmramICzhKglOAtOsaab9rYy45B4cbCvGCJ00zTxmxNac7OETV/dwylxJR8jYxlH8yEeUpotMdHlRTeORfKinDYoD7emsyLs7ibaQxO2cDhOjIuPmvNtNtas8E3xZFM4KMpABMOGTeW5Rv3nrshKc2nAYdZzQht3FUITTho4hG8+XQ86hHB3gBv2SAL3qxxX8WTIcLWRAMmdTIeinFWTJxONGAQGm/eMbEt1QR3w6ScBfsCooFejI9QoLXhq0lJE86EJpDvdSNBouVl+Xmz0RvWY631ReDfAeeAeWBTa/3lndcJIX5RCPGoEOLRpN2mMusYeLyR1of2FOGgRgxEKNdAt+5Fl6Si8HfHiIEIfypGNyK0qw0c7Mu0IhRGOLXB2rTxznoEIwpvxYJqQndPhAzJ/ZF2SxANKpxNi9Ipz8BvLRtnyzDF7h4TqWw1JUkl9R/NuQYys82mEJs24bBhXN6inRdWEekGcc+UCBsaf39IadbBPxigSopgROWHOfi7IxM4Iw1DtToSPGWiSLNgtGqcBnP1Cl94qyZvl3U3LVID7noakd2xDKPYtNG2iboO9ge4GxbeskU4ZCL8nYsuSd0UMnEvuia/9aJDXFX54Qu0DTNKakl6ehKEoyaAJhxMchdClt+elDR6MDLFQdIKd1n9bve82zt/uWMg0XAiRg+HyEgQDZvCJ8oy0LiITVCRSECXTO54MhoR7fGJagZ+BBNtr4bDvOZ2lk+sBYQTMVZHEu4JU3+shkpsgo/aNrgKuWEjKjFyzUFs2XnQ4vdKxfWtWu00Dxh0ZFw4+CbyXKZ5wO6WUeqEo5CrLpYP1rKLcDSiZWNvWohNxwT9haDqCd6sZ+DctNa/bsSmqt5YCC0bKwCnaVwWUaqkynUHZ90ysPZ0hLdgGxfCAR9dTgwMP+cghMnrNodmQHnWIZowymA8EVJaMsqVvW5TmnPA0ibTYjhGDYdEw0b4q+GQ0pyBjP29IVYA3ekIu2lRPuNAItEDMdaWlZ8hUH7Jy/PJtaWJRkwyd/mEh7/bKCv+7girEoGXEDVMAGY4aGJE6NppDrRGjZi4Eqdl4GbWXcpzJgbEXrF7hyEpUwSqV6vcKATBaIKz6qAaMe6GQMZGANstibvkGJfDcjqH69LEhIwkRHt94rrCn0hIyoa3xFWjeAR7A8MTNiTJeGii+C2NteRC10Z5JqAxHDJC1z3nQsdCuYrgoI+z7GD54K3KtF6EJq6mNf5LiriqkQHIVTevuSDsXjaKvz9IFROJHg1e1fr+bkgDCnlZft5s9EZC6EPADwP7gd1AVQjx0zuv01r/htb6Fq31LXalSnC0mwbZYIRk3UTEsu4aq3pJEk6HJtXDVejEWHc0HSgZa06NhCYSdSJCNyL8yQRvzQTjaE8RjCZIJ0EICK/qYnUF4VhsLJg0wjWuavzJmNKiZfyxlsZZdky1rq5ADUbG/1XRRDVNsq9L6YKDHoxM1HvHIpwKTdGMqkKMBAT7AoK9oYlo3bJBQOm0h7dgGz98dmhHxzLBOI4mGE2M8Agk5Ysmwt1dsdFt4++3/LQIRNOknCUjUX4ghnayE8pMoI9uxEZZ2GM0eR1KgomIcMgcyuAt2kSNBKtuIl/jirHQwr0BlTkLmRhlh6oZFxONDNFAmsqSRgoLO011qcZE0wFOU+DOemn1OJBeWtTDMcLVW7VIJgNTBGY0xNq0zOlVQ1EuGORwYN6tQCvozsSULjqoocj41dddvDWDImhPUV6QyHXXoAolhXPRIxxKfc9phT3vrEvpooPlC0qnPUQ1zstX6vEAa94z3y2la+xV0Lb1Xa5SPWMb69g2vlJZM4onwihB3YMhwb4A50wJp2niHEQkEFs2uhabgMkNSWVOEh7upsF54KzZyKZR0iovuvmJWe66Ccjq7kpTHn0B6QEb8WBaVjetalY5b+GdLKXFYtJUshWPpGTWQTyYEA5rrHUTJKgjSXi0iwwkyW7fBG/Ggng8wll2jPLQNv79yktGebY3LOS6Q/dQSPmCg92G7qEQnYg8y8BuS6wQohowFhi/rWOyFLSl6R6IkF1TNMVZs5EXyqmiLhC1CNWIqcxLtG0CO3UjpnTaM4iaNALa6kiDTA0mRMMxTrNX2jfzKXdnIoRj0BtrKDQnvHUsgmNdwmGFvyshmQxMlkI9QtumCIx/ICDxgFqM3nDzTAIExDM+erdPXNUQWMiSKShFWlrWXnBRuwKTihkbllCez/I8MfvO1shFD4C4pvNDZ6wlFzVqlFZnzqAq3T0RTtOglVaAiTUZMj58e8EzSJ8vkUveq1rffXp96Y1UWd4PnNFaL2utI+BPgLe/ge3pU5/61Kc+vQHU94G/OnojBfg54K1CiIoQQgDvA45/pxtUSWPNlqFjoad8A8HOe/khHO66pLtL4Vx0UTNdACovuOh6bFJy2hZyzMed9Yyvx0kon/BAasKGgUmrZ2zspoWKJZWTDqXny8QVTfm8SQ9JxkPimsbdNKko/kSCFUJ5wURzWoEgmAmRGw6lhTSfNhColoGz5LqDdkxErY4lTtPkOquWg+UY66i8II1ffjoiqmuiQ138A4FJn0tLYop0rcpA4qw4VM7ZdHcnJOORMdQTQeKBP67zYij+QZOixYRvrLpSQnJV21gOpQRpGwSidMY1NaO7FrJjxizaFRGXjfXjPV1GVQ2MbrcF7jmPqArhdIA1GEIoCYc03qJjIMiWQESS4FgXd0NSPe5SmreMNb7hEOwP0Da4m6ZPumlSocSWjYwh2BsiVj1Kczb4pnAFgWV8s/s6Jv1txYOS8a17Cw7V0zbR4S46FjDuw3BorJ5YYJVj/Gu7BjavRJTnjLVG1RTPQGqSgZhgPCEYTQh2G3jfPVVCdiXegoO0TQ55NJVaU5eBlAX+tV3sIR+55hAMaaxzZapnTc3q0ryNVYqpvOSZA2sig24k076J+TjrmmIsQFICa7aMe9ElrmriXaGJNp/omnOsRWohz4SUL6ZHyabHtVr1CDESmIwBJbAqkYkMV+BPmBK/Iga7m67dsinA4s3byJD8CEthaeSFEu6WwDtZItrrY3UE3jnj4hL1CD0S4B8I0lx+SdIwRV90LIwraTKhfMKlMmtjlWPc9TSHOzJZICyVsIYC8BITvT0a4F1wTL2HAOKJiLiRYJWMS0kse4iWRfeoj71uEw4luBdc/P0hpAVSLB+SKd/42ZVJzQv2hCTDEeGAyfmOJ0xKp3vOxXIV7nNl419fk3jHy4BJXXXPlBCOQq2l7rk1idh0sLtQPuEhBsP0uFgTJa66NvaZMqVlAaFE+RZMdyGFsePRmPLxUnrcLejxgM6+2BRwGYvxJ03tg3goJh5MSIZikpLxZytPI9JStlkJXdmxCCbMNcGowl5wcc97hCMme0fGAl1N8gJNrwdp3feBv1p6I33gDwF/DDwOPJO25Te+0z2yK9AH2yboSYDbCHA3THpT6aIp8ICtCSci1IZL6Yzx0VqrDvGMb1KslktwtEVlTuLMlkyAWjUmqSvElkN0c8sEZ501XLm9L4ZqTDCiqZ42vm81FNGZSrBGfbA18eGuScMKjS9RrhvoVksozZt8aWxNXMEEKtma0pIJMOpOKtyB0EClSx7+tV2iG9q4GyYXPBkPKT1rGEJ8sIs1GOKtCqovpQF86ybQpX0gonrGQq46yIMtxEBENBWYAxN2mfSx0inXFJVJjB+ufMqF2QoiEVROuKi2g1MLje81rdikB2KcFypYqzbJeISzJYhubJugljQPWjngtEyOsNapb9/SJK4JgAmnIrStsE+XcTehO26qw1legq4llE56JHu7tA9GlBdNhaws8DAYS7BLphiGvz/AXrNJDnYNQw/Ae7qCmDAC2jvvUpk3gWXaBmkprKaN+1IZseoSHeoiGyHyXBkVpIeZLJSJqiZNRmw5hKMx1edd7GqE3ZTUzliULjoEe0PCgz7lhfREp7ky/lgCWuBsYeImXivZGvtMGffpKnKqYwTFtE/YAG9NkFzVRp6pEAxp/F0JwdGuKYiz5qa1CGIY9wkHFYln4gxEbFIanXJE5ayNlGYdWhNdShcdnHkXf8wUBXLnXJwWlJ4oo2ITa4ACFVm469LEjGiovuiQ1BSdIyH2YED1tCnSE4wnxOMR3moaiJgI9IyPiMEfT7AcowwF05GpzQ2w4SLXHTq7FcFEQu2ETTge4dZNsGflvKkzriUkoSQ62DU+9Epa6W3Cx3u6gl2KCQcT1IpHVNfoY62M0+COdHFeqBCXNeUFUznROVvCWxPIRkhc1ohNE7ehrmuZqnMdOy+eFNdNYGnlhJvWkjABsyqtXlh6okwwYlIZ48NdRALlOYk40MbuGEXdnehQXpDEZY2uJvj7Q8IhA3VnddsrFyzsekhcU3THs9PObPRiCW/Bpny8hGiZ8aAW448pKk+b77TApLvVIqyWpHTBBKRUX3KwWxjDZkui2zbxpPFny1ggRgNkLTLQ/UhIsjsgbKg8HVWnClEwluxcrX36H4DeUJVFa/2/aq2Paq2v1Vr/jNb6O0ZKaAneY1VKSwK17BGtlEhuaZrDEcoadaiNPeSbYgrVhKimaV9lfE9ywTNCqqTgpRpx2VgKSUnjni6ZHOimRByv4c26qKNtlA21EzbeORe7Y6wTpw06PYrRfa5C5ZzZYO4mhEOK9rQJBnHmXIJ9Aeq6FtXTDqWzDk7LWE3uOZdgONWgPYX3cJWka1O+KFHrLt4jVQDESIC0zdGG1rKLfaZMsuXgH/HNgAiIr2kbBtCxSEpQmReI4zVYc9GxhJqx2OJJI9S8dUH9SQ9/IsHukp8k1plJjDC+WMEfN2UpvTVposTb5hS02rMuyoF4oUzlgiTZ28X2wVuDzt4YnUick2UTfDMUklQVlZdc5KaNOxASDyhaxyL0WIC7CSoWCDchOOJjny5TO+kQNqC8KAhnwt6BCpaxFKwVl7ieYJ0qm8jhEIJhjZ4v45UjgpmQzu4E77xpp/VC1RzcEpuiFOVnypSfKRM3EuxKZCL4d3WJGwneSBddNwVb2leHaGVKf4YN4JomNG0qz5boHA3SkpcaaySAtkV7j+JyKP8iModn+KPa9HncR/m28cNe1yba8lD7O1j72pTGOrBYMqjPRJfyvDAnfiUmd1ceaBkkKIZ4PCIOLfwJhTpdo7QC8UrJHGZxpJkGtZkqelHNFCfxznimPsKCwFpxSDzyegLRAJQvWEgnIQ5sOtNpyV1HIbZsE8wYSLxFB+uU8T/XzljEKyVKFxyqLzomO2O2ZNb4ri6qkmANmuyI0pxD5NskJWgfMCiUPxVjL3i4J8pEIzHR7hBnE/RCiagO7pNV7KZF7awJTgxbLp3DBgmLQ4vgoNkznet8k21wrGXqSoQWqpZQnpc4mxZhxzWI24W0fOhQaALR5tw8+M1bM3E2smsQtNbh1EeuwH2uTHxzi/DmNs5TVZRtqqeJ47X8IBp8gwbqSR9rb9scdRsYxbj0ZAV3um2UxFqMnvQpLUpTL0IBQyH+eIJTjqnMSdp7TG0EpympzlropmNiF6qmPG37WGh4zUiA0wRvtItz0TNH4U63qT5WRoUWesNFznuIFY/arMSZM3UN5KKXRry/nlHooBCX5efNRlcU5qAl+BOa7oSxYGUokcIceVheEsQrJeSJKmogRm6YqNnyYNcE5wQCqwtWOy1wMJGQeFBaEcgQKucl3rqBz0QC+owRouEtbRPopaB1OCIpmTKR2lUkJejsiSktGrhaaHDGuyBTi1RorKdq6Fu2cJrQ3pvgrQriuqZ6rlfju7VPUXvRSUuWCmOhuqDWPOS5Mt1dGmd/y1QA61roLYfgxjbWUIj7VBXruk1zWtJbWjSPxOirW+Zo05aFWwsJBzBBMMdaKAeaBxNqpy2ahxOi6YDSdAurKRk4bpsqcH52dCP5Uaj1ExatgwlxTZt0OYClEtxicO/qaTuNyAdpq9QqNPfaM22itRLOhsS96OCcK9F6S4B9oWTcCGdKiAQ6UwoZQudan+oLLnZToAdiwjUTsJXUTNGSYCImrkHrmpDKRYHdEfhbHqJpU1qyjNuhoYgOd41Cc/MmlTnDgLQAZ8RHzVeonbZIFsumPObJOtIxLgTpGOuxMieJBhTimTqVqSYyBHveM+6BqTbJSgnKJmhPXw7+pqG0KCmtCDheo/pQhcpIh8p5C63TkrROgvdAjaDjUL0oUPu6uE9Wae1T2JUI20vwd0c4j9Wwl1z8q3zomqA/tMBbNVXvxEBEZU4Qnq9hLTsI21Rc81ahezhARiCHA6LbWngHt3CObJHs6aKvapMc6CJjSHyb0mmP0rLFwAkLrxGgByOCMVNCN5wJTOU/Da23BFTPW4RDiu71XewFD462EPMlyg9Vqcw62C9V6F7tmzSrLcdEtpcSvL1NvEWb8mJafVELLDchHCTNSEnoTiqcI1soG6rPeXjnXTOeC5Kk4yCXPJJGQunFEu66QD5TQ711i/rTLsKXtA9FpphNJKjOCfwxhbMFwjLugnAqxN0QVC5auOsw8JRrDiWsgyzHBHsD4sGYuALhlke0VkIG0N2dEFcVwUhCOJCekjccQC2mVA4RQhtluKSx7YTOboWUisqcSXdVGy7+uDnbPrqlBRsuVBJKD1ZBmAj1cEjjbEFcA6uVngrnaqzpDjoWeOuCcjUkqoF8sm5KBR9qkZyp0jycYK06VM9JtAN6JKB7c4fSMjjDPmo8AATB/tc3Cr1fSvXV0Zuvx33qU5/61Kc+/SWgK6oWuhWamsH1MxJ/JC3RebFGedEErJQXTFESLEV5zqF1JMK+fwDVMP7A5nUR5dMOwdVdSi+UCcYUHG3S3SgbNbBtw0CEd9bD8k0+rjpXobJigoICAVYH7CEfrQVRWtK0cySk8aSLP2a0VLGriy9KJvXn6i7JQpWqS17YBKHp3ObjehGd9TKNsRabXh2rGjHwUJnNm0JU18VblcRXdUALgotV9FAMJQNLdxwPe90mGNZUpKa8q013robUEM1VwNG4qxLnbI3mQUX1BYfg5hBd1VSnWrQHPBqPlEg8i6ju4fkmLUfbkIyE1J91iarGxx4MmpOVkOaAklBJKnOm3nNno0zlrZt0FmsgNN1dAhVLk9KyJElcCNsulGP8KYW9aVM6uEV0ro67AeJQiL4qwn6iamp8xyAdRdjA1GQG6hMtWv4ApYs24ZCmPNzFDys41Yj4Dh9HaqKmSUNztkDZgvKKYKNm07rJx32mQbA3RrbT85mXyoiRgLZ0Kc9L4pta6Nkq3gtluocCVCKpP+HRvrWLAKKwhD47QPXODapfH6S5H+TjdeTVXfSqh7cmcW7ceM3rW1sGuensMgF9wTubhBdqiFGNANRwhNbmcBW56NG+qUvl8TLdm7pUni6TrBqrrHRNE2U7lFYgOhThDXRJ7h8iahgXztaRiPpTJbpvbVN9qAoamiWbeCIk7rpUXvBMoZ+WQyBtSs86xBWot6C9G6wY2kciSucNtK4lqGtbRHMVnF1dSrMerRt92HTxptp0vTLWoot/QwdrtkIcS6z9bUr31/BHwB9NTzOzwD1dItgbGss4ga4q0a271K/foDlfp3zRIpIaeaZsSqgKkG5C0rHptjwqNojIIGneeRenDbWxNt2Ki32hbAIOhakZIE8M4CqTMqbrsakZvmWzeW1EadCnVS5T8mJzbLgwsQPeGnQnTYna6ikHf0zjliPCrkP1eQfrHeuIp4YoL8PmNaYIkDPeJYklpZMVgre3sF6sUVkD9S6fYKVMcCChPGehNwdwXAh8F6Y13orJFbdbgtKyjd+pmOrILZtgBMTRJuFq2aSkDmnTp8ScXGeF4Jc83FWTjpok5tASbUP1vKAtqlQXBMmaRTCqae8zhakqtQAeaRC+o4k+UUd4Gme6bfbw60biTRmAdjnoyhq1gZjKRVOYJJwJTPDaVIvgLV0SF5xb17E74JRj/Bs7VE85tKc18ZEu4qZNdHqilvtCGbsLpakW/okBrJIJ4KEaQyxzf7a4pkllXtCZ1vhjGrsSk7xr0/jhS5GBqX2wSgmbRxLUlkvJMwU97JZExxKtwRoKiepQXhCEdbCnOuglD/u+AaxyTOf4kIlUjSRbBxW0LaKGKYxSfaiCPGP8iO6KzcATLt0JRf1FG/fIpsmrfXQQ954B3E1TKEKOBTReSKPiI2i8JGlfHRK1DKzY3ijjnCsRDoD77lWiRlrEQRm/mLAVzbcE5p2bEO33qZ0T1CdalOfSE7vKYA2HDI61cL7eAA31XS3KC4LBRzxzWtU1bfxdCXLNwb3gUTnr0Di6hnq0QXlREldBnanCqSqd/TG1WYG7BeVHK8gInA0L75yLZRlINjji424KnG/Vcce71Ks+zjcH8E8N4FUi1EhE6yYfJHTf2aL2ogNr5sCM4alN3D0tBl4ydbRrT5TMSWdvW8d+ooZIBHYLGo961J/w2Lo2wj5ThmWPxrE17JagfbpB0DB1rOMSyAtldMPUcFcPDF6WJd7cpxGHW/g3drCkorZ3C7stKD1RoVz34XiN5g0h9bMC+6xRPMU543e1rzfuDPViHSuAzo1dxDN1ALq7TbGbqAG1kw6dGUUSWjSvD2heF6HLCYOPuATDivbBCP9AyMCuJiJO58k2ikVcTwjHYkTbwr1hw9SmbySI52vYu7qUHqjSvD6k9GKJ6nQTpQTVMzalw1t4z1TQezvIVZeo49C+vUt8sEs0lKAlVA9sYnVNsSMZwtbVMdaRJo29G0SPDYLUdA+F1CdalFYBAY3HXaSlTAGfrokub18bEN/UMoGJCVj3NCg/U0bsb2Nfs0nl+jWcpsBpQneMNCNFUVoWJphvySFoeQxNbqG1OXpVpMWExLvXsXyBvWZ8/6qk8O6rowJz2Iv65hDeOjQPKgafsXHWbMKOg2UrglEofatmosXf2iZ6roG3YEM5Sc9dMGtAJQJ3XRAOKgZOWpRWjOFQ3ttEhILSigQFYdcBLzGVEw+2oB4hIkH9+lX8sSQ/aKlzVYD1cJ2kas4O6E6Y+vcyhs6RkNqRdSgprOGQznwNbt1EvVRHlbSpZ/FSzdSleJ2oX8jl1dMV1WPdsulMK7wPLlM+6eEu28iHBhDnS7SuC9lar5Dc0CJeKJN0HJJSGr277pIoafxp61B/6zLRW5v4F2uUVgWlUoRzzSZy08FedkwU6YLEub9uoreXBZV5gTxbpuxFtK8OSRKJtWkR39TCebGMHAwZfNZia7mKdaJC/cYVyiddtBLYJ8omZeMdG6Ygxj01ynMS9wMrDHyrTLwrNAU3WrapnGZr7C1J/fpVwnc2zdGaGqK6orUvPYL03Wt0Nso03rJign3e0SauKcpLUH24TPO2Lp29ERvXJnTHYPARl8GnTHrN4CMuWkL3SID/7RGcTUn7oDkYJpmtIhc8xsa2THGOMjhnSjT3a4KnB9GWCYoKr28z3GgRPDhM84BJwWufamDduQYfXsNZt6jfW6W8qw1Aadn4XreeGzZW5kGTlhaPxqh9XXbtWSMYBvdDy7QOJrjXb2Af3cJbh42lOsrT1B8tEQ5omjcEhOslmk+NEN+5STIa4q+WqbzkMvhAiXAoIew4tPcmlKZbOC1B+7ERg2K8Z4PqBZH7V/1nhujuUsS7QgSweU0C795Ati3CwQQRCTa3KoQjCYMvCkqrYDUlHG3hXbWJXHfwVsRlCWJDatRgTOXeGqXHK1j3N2herCOvbpr4i0Rid2D4AZetQ5pgIqJ7S4fGdSsIoYliC65povZ36UxpBr5VJqprNpdrVC4KnCNbOFvgvHMNe0uifBu55lI669B4xqGzC5zdHawtG+kktFol6i9adKYSBt62TDSc4GyZo2HddYn1lUHC3RGVWVM9LIkkW9dEJnDxlk3C4w3K99UIbmyTJBJ/ROO6pkJa6axLEkpUJKmesVBDEfGjgybIc0MSV0BWI/zVMs2TQ8gYhp6wcS+4tFseKGg8ZqzCyoNVRNWczT0w2KF0yiMOLWQ1YvMqhX7PBu1pRbRaorNVZmOpTjiokLdsYl+zidOU6NAiemvTZGGE4M26xPcMEy6WEUdaiGUPpyVonm1QnQOmfRozm6Yg1Lu2jNJ7VYTThvYtXcoXJeH7NrECcM95hFseIj3Bzt6wkZYiqiuC8YTygE/iQu2WFXNG+6pLeG2H2hlp0C8PWjf5lNwIKzAFZJw21J4oIVdNClwU2tSe9aidF/C5EeqnLbw1QfUihnfc0qK+dxNry2L4+mVkIOjsgrGJTVwrYfhhB68U0pjZRD/WMNX0WsLEThxpMXpo9TIs8FemRIvL8vNmoytKgPepT33qU5/61CdDV5YA1zD8tGTl5Ajy5k3srokCFbFgcKRF43EP+/EatbMS0TLwkYxANkKSE3VqdZ+NY4qV1TrW43XKC5Kh980TxRZhaJucWqDztjbBkKb8wWX8W9q0j0QmVeToJusnhqmccPHbLnZXULmnhohh8L4yG2+JEaGktAqriwMoF6pPlZAh1GYFUppjLZvv7BBXwL93lM57WlSPu7izJu882Bsy+LTJQW09YaxGp2nKdcpAMHrVCrXzYH1umMZoi1bXo34WnGeqDB5aB2Druoihe8rURjuIUBBMRvgjmPgACa0ZiKsK54KHssC9foPpmVUqC1A9vIG7Jdh4aoykqvDHTC63Pd2mOg+VBRh+2GHgG1UsqQlGNfZ025whPuGjvjFM69lhqnOweZXC+/oATPjEFQh2R9htgT8CBJKkqvDOOySBxeoT48RHOiwvD+COdnH+bJAwtGnv1tjVEGuiS2e3Kf9afc6Ul7WPbmF/s4F7waPxjDkKcv32kNJEh5GxJvaoj3xwIC0ZCo0DG7TPNGjvUTQ+sIA15xHt8U30v6XYvNZAkOKeQYSGwb2b5gjOTdfUoP6hZTqTkEyERPMV5H0NtNTEN7UMgvFaSYC1bnJ623sTmteFTB1aZqjWoTLrEK6VKK1CVDGxCSIRJIGNIxVxZFH9Wo1otkay6uHOtIjLYO9rIQJJ5b3LRJFFd5em+cKQqY9QiXD2tPAPhmxeE1NeBuupmil7KzVq3UW8Z53GcYvWfWMGth2LSKqmJnpzr8aphWjLuIeqj5fx5k19As+JScoa/84m8WqJylfqCAWd1QrRSIQ/kSBXXQae9OjMKIYednE3wLpzjfhIB7sLlSfLlM/bNF4yCMfaTTHeCgwNtWnv1QQjYH94Bf/tLZxzJYTUVNyI7kxE4/4yYr6ELinapxu4Ex3jIvMl3gXHHN/5jQalLzUIJiIGH3dMhHZkoHB57RbNq2KT232uSmlZEB7pokuKtesT1LJH+NAwgy8JeGKA6vMewlEkd61TfbRMOGimNDhoap0PP+RQWTCHFLlbpngJAuq7m4Shie1Yf2mE8rxANWIGBzq0ZzTuJrSPhbiViNWzQ3ir4C46BMOapISp3V5KsE+UiWoQDMLajTHNQwnt/RGbRxXDD3jEcxWam2WSimLroTGSaoLThOWzwywvN9g4pvDP1dnaqBg0yZeE4zHegkOlHNIJXz8fuEb0o9BfJV1RPRYqLd6goX2hjrZg+JYlBm9YZmO5RmcXNO5cRNlQmZNYXfA2zGZpnIKyGzFxZMVUiApTaCrw8L5VY6jeMfWfxyK0kjDts3RmGPepKt4Fh8HdWwyUA4aelZTfscLoPS7hoAm2kjFsHNHIrsQe8Y1v+YKLss37g2NdU5Th7mFzFu9yiWBfQHu/8R2WVk1wTOMFi8qASdGpXb1OMBnhbkjcm9ZNClNXsPH4mGn3HojvG0YlEpFoSmuwtlxn6K45hh9y2DwEzlcblOclow86uFsQ3txGvGWLytXrRmgdaWH50NwsM398nLAOnRcGcVomP176kuFrVhgZ34KXamwe0tQ+MUd3FPwPbTJ/cQhrdwdeqjH0pI3aMIVz4kaCPwwTR5dZvyGCxRLBsKZ60sFpGiVgz+FFRCzwpyKQmupFUEsl7FKM/USNjWPa5DQfbNKod1HzFeJBk6879oGLuJtg3zeAPwLlJah8dJGx919kYKiNv1RhdXEArQXqrVvIGLpvbVN2IsoLJh2t+YVdJCVNpR4gJnyc2RIH9i0y9Jxk64YA5Wo2Tw/CVSbFzluw2XhqjGifb+qiJ4LS+5bRnkKfqGGVXvt5yVZLoCd93LuWsXyJU4lYWG0Q/eE44aBm5FGbrfe1TZ61gpFHbKrHXTqhg1oq4fzQMk5LUD8tsR6uY4UQn6kx8rjFVqdEsljG7pjUPn8qovpYmdoX68h1B6sa4d21THcqMWelOwnVqRbO3UMM/fBFLB/qJy1EJHHXJLXHSiDBthOiAU13l0bdsUl1DkrvXEV9YYT6KYG/VkZGgsQFe38Le8vCrkUMvGgx+KKgM2lOjvNHoPWODvafDmNZ5nxyt2mEnRVoZASTM2vmEKI/H81P9er4Lt6DNcLpACJJ+McTVIa7xh3QMmmak9csMvDFKmLTQXYtJt4+Z6ra+bB+taIy3GXjWJIH0dXOa2RaSU6NhJRWBMGIKbLjrNh4SxZDz0vKS9Cagvi6Np1pRfmkh/rmELUPLVJegu6FuoGglUDGmrgEnQmIb2gRtlwGTko6XSMYRQxqOMTb1JTOuOi7R01uvUwLUZ2p4a5aBKPQOKlxD28RXNfBbkGy7jJ8+yLB/jT9rxax7/AC3mCAsyGRocbe3WFouM3ACYvRd8zjDQZ0diuoJlRecrF3d5C+pDHUITrWpXbGonrSxluBVtujtVx9zev7O5HS8rL8vNnoiuqxHjDFRgYPrTP8jMTfE7EwO0xy9xhONWLgNMwvDCIUTH94ls60QltQfbJE4kHd81lYaqDWPLz3rFC9eRV59zC1Dy+ytlVB7u1gVSLijk2y5lLe1TY50LOa7mPDdEKHzYMgPz3Cyp0hejCisy+mvKypnxHYWxLrxSr+ZIJ1zRbOsU2iGgzeW0bdtcb6tQpnzaK0KHHPe4w8ZlFehPVrFc2jMVENxAMNojL4jwwzs2cFee0W4aNDlNagOgfOFsaarmm613dpfKlC2BD4w3BwzyIrX99N90NbVC8YbbxzNGD15gRlQ+NLFYTQ+IE5UtB6sobThuqAj7MhKa1p4vGI9rRm+rp5agc3CL80RvvhUWbedh53b4tzL02YAx2+3WD8fpto3WPv28+x/paEsUclSQlkV+IfDPA/O8H47g3stkDtChi4cwl/DDauTWj90W7qpyVOPaT6nAcfXqO2d4tksYzztjWGnzEVwJLjA8hPj5BUE2TXBBgubA7QfEtA9M4m4liT5gFF68sTzB6fZOtcg9J4h9H7jVBz7x1g/L0XKT9sGFBcAWfZIXxnE2/NBBlWH6oQDids/PdpOhMw9KBHZVcLkQisp2qmnsAyDFy/gljymHrXeVNM6DNjiFASTYWw8trrqWrbVLNr+R6Jp3Efq2KfKNOaMUfJrt6QwJkqUQ38ccXqLQn+9V06XZfBFyTBn49hdWH8o+dp70novqtlrOU6xKdqDOzfYNc7L7L/1vM4azYjH7lIcx8oR+E9X2b1uVFkx5SSrf95DUsqmnuh9andJHdssnW1qfYXTJq892Q0xO+47L3lAntuuAgPNNA/sMbGZsVElr9/g8bzNmogpnlAE3aMdV4qRWzdENKahsZL5mAQGcHwl8qmAI+lWL9WsXpzTPOAYuUmo6AuLA6CgIGPzeFsSUaeFNj3DVD9wBI6tBh9yGLzENQ/W6d+VhMOamZumGP+2QnWP2BK59ZPC8LYxt8ds/a2kL1XzxO9NMDYoxJ/LGHsbfMAhM83qA53sBZdOlMJ3oEt4n1dwokIpwmb7+6wdn1C7SIM1Lo0XpBUL2rKq5roD8cJhk01NmslPWntJxboTqS1Ih6pMXavOahFL5RJujb7br7A+NgWK3eaw5U232184O4WTF0/z+T1CySHO9TOQ/eHtpDfbqDnygx9YJ7xByXzZ0cYuc+jvT+m9miZ2YUR4gtVqressnVAYD9eQwhNeEeTC2fGUIlg5MAatC3K71ih/uUayZTP5ulBkqaDuwm7PnwebcPglyoIW73m9d2ny09XVBpZn/rUpz716S8XZYVc+vS90xU1akoL1m8LCb8xwvodPnLL5uDheaK7NlDnKqy+LcKb9bAiOPnIHgA239ElvL1FZwLOLo6Chuvecpb4C6MMeD5TP32awZKpZnVkYgkAuxrhbFoEZ+u098esvCsyObp2gjzYYvk2xeBIm+GRFtWTNlsfbjP8sQuUb1jDn4whEXRWK1Q+P0BchrAByb3DKEejHI17+xrRgGLzEEz86CzSl4zNrON0jIvAH4PKPKw2q6hnByjdtkZrDyQ/sGZcCMqUET02vYD344vY71/F7kCQ2HT2JNiWYvcnzuJPKOSGQ+WChdOBldsTwpcaJImE4ZDunhj1oXUqnx1AW2D/5BIH9yxSmROU7Yjm2QaVjyyCgjPzo/BMnfH9awyc1aa624+uUDthdMDqrMXmAXPEYfW8oPKix/rtIclnxxi7bYGhoTZN36M+i6ktf9cmW1claCWJb2vSenaY7guDDJyQdJ8eJikJygM+tXOwfIumetbGnupg+5rGZ2vgW9T+rIYUmj3XzBPVTere4Wsu4N5XZ+OIqSZXXtFceHQKNKw/MIF7/QaH33aWajkgGFY4X2/gtMAaDBn+xHm6eyLa0wYJkYGJOh9/ULJ5u4/9qRGSesK5lWE6Mwmr7wypzDSxF53Ls75LmrHPlenOV3E3JKU18sM1wqGEY9eeR+3pEu4N8JYl4w9IvGfKjN5dQTmwdVgx+r45zj8wY+pqP17D3jIlduOqovvUMGfnRjlxfgI17XNucZixWxdw1yyiOqhdAY0TguHHbewfXcb64hBDL2nW3udj3ddg5BGH6qJm+DHb+HjbNmLZY/VPZtj8o2lKazBYMrnxU+86T6IErb2a6gsu3oo50GT4mhXkvQ3c8y7xgS6r7wooLZso6dGfn2XjHT4TA03ESEBpzqZ+SjJyYI3WDIyNbbJ1i8/6n+1GHm0SDAo6U5pO6HDo4DzNvcKM1YBg5Y6Iwzec4/wTu9G2Znyoid2SlNY1y8+OQSg5uGeR5S9PEdcTvJ9aQHuKpYcnWblNMfiSxvvzBvVZQWnZorNYw5otY7Us2tf7OE7C2P411q9RtB4ZZf2miNJPLuB/bJPlt8cMnNHUL2iSkcgcCyo0ak8Xf3dMaR2Wb1U4XU153xbD401Ond1F9LkxBkdalOYskk2XzpTG+/gi3d+fpPm5Seo1n/YkqMcaqLdv4u1rcuHiCMu3GKh944jGqkT472hhny9RuSjY2Kww9ILm4F2niRPJVeNL4CgcJyH8yihyMCROJO3d4MyWGDwuzaFBAha2BiitaZp7RX7E7+tBmssTgd6PQv8fnWKJN2CKpQwPt0DDyTO7UA8MMvIM3HhkFuVA4sDwczD8jMQrR0ipScqa+v1lRsaaLP3GftyWZuvTUzzz9D7mmwMIBae+th9xtoL3VIVoOkA7GiLJjQfP4a3BylyDxp9VGXzeYqq+ydqZIfwxjXy2xvIXp9nT2GD4cdtsguEua9dA44yi/RafuGYEQe2cYHrAlD6Nx0O2fn2GkWc0VTektGoCU9xNU9wiSSTuOnh/MER4wCf55jBXfeQk3cMBlXnBwu/t5+LZUZIvjlCbU8yvNmg8ZxE+NcgL53dRPScpLUnct62xdlNE6aIpRzkzuk7lWXMIQvfZIYK/sgEC5mdHOLs4SvDWFme/uRcZCQY8n9Ia7JlYY/AlxeYjY6wdE3CsRXL3GO57Vjm9MEZnSqFc6O7SjH70ApPvP0/tWZet97XZ/PIu1s4PcmhkhbGfmOXwzCLRMw28ZQu95LFneJ3SKjROwObVCeO3zaM/smbSpnxtSpUKqFd8mh9psfj+EGfNZuU2RXelwsL9U+Y0uYNtzt+7h7ABaqZLaUWgLCgvwoEfOYWIoeREPH9iitFKm/KiZPNYQnMf1B4os/GpGfbuXUZZcOgHT+Fetcn62wI64yZvfGuvYPIei+o3q1gdiTfr0j0zgN0WXHXDude8vJ0twcgvnjVLva6o//hFujMRMoLqeYsXntrDNdPz1J/00Nc3SRyBP6Zp7RY092smHhIsPLCbcHdIZ0qZVL/nDfMees6iMm/2kFx3qD5aRkiouQH2tZskUz7jX/JM4Juvmag2ae41e6n+QBlvU9OeMkVbtAV2ByoXLEafhOZ+jf+hTdavVcwujFBakpx7aIZGxcduC8Kb21TnNOGRLn7ksOuHzqFcGHigTGOojf/uJmHT48zX93F0ZoFO5CIumkJIpTXNcLlDclWbzj1jsO5iRdDdKJHcucmBm8/j/ukg7dCjfNMatVtXaN3RRm46zH5jL8x0cSY7dD83QXkJ1n+ojdoVcOuNJ1n50xmu/uGX8FYtot/dhfAt7A5M3C/xf2STqAojf+U8wSGfq45eMGejS6gN+PjLFfyvjDH0nAlaLQ36LG3U6b7YwK5FrH3QZ/2oOXnt+mOznJsboXF/GW/BpjVtAmun/vZJxP0Noq+PIFoWpR9eZGO2gUqLPiVVxcb9EzRnBNMfP8PWyaE8hqS9UsW/WOPmw7Mcuu4C49+ySMYiRodb2FbC9G0X8Edh/64VFj8QEWvJ5oUGp+4+iL3o0p2r4W1p6g+UCSObYx84id2B9vtaxMfa+KNQ+rMG0cfWEQrKlfA1r+8+XX66ogS4iCA5WafxwQW6940y8hR4AwH77jrD1n7B/H86wIG3zZKU4NDffIGNqzRDn6qRJBJvTXD4p16i+61RFt8fMfrzs6y9I2D84CqdJ4ex3rFO44yJ+uxe42M5irFHBNZIwOPH95F4MLN3hc2DAndL89zxPbgbkvqxdSrz0J5RrP7aPjYPa9SH1hn671VUWbHwNrh6zzxRTROXBHEVYi2xWxZ0LDZ/vMmuv3ma4DcnTR+vbdI6EtE4rRj7wwrhEKxdI5iaWKe1P+H5xQkmvuyydTRm4yqTH96e0ez+e6eImy5xBQ7deYab9p8HzBGVGys1jhycN/mj71vl4sNTJgisBcneLtYXhmic0Nx+7SmO7F4k2PQIRhMaLwpm79nLxrEE/7d2M/++BHfT+OHFczWCD28yWdsiCSzsiS5WAFM3zHPxgWkWvjzD1EdnqTxQpbSu2X94npoTMP+nezm9OEpS0QCMPi5YuHuPCbKrw679q9TdgPYzwyY47KeWuP7QeTr7IzaeHyFoudx6aJb6LJQvmkp4/oGAgcPrDN9dwW4ZdGLwm2UGzio2Dwmu/bHjvPiVg+z7wFlavsfA8w4X/nwvwbVddn1LMvaEQtmwdp0ijG2cI1u89KWDBIEDGsormtY+RVyFhQ9GbNwSMnz1CjIEGQpu/PBxjp/e/ZrXd9RQnPnifnA05XlJ53d3m+MeR0C+bYPaWUmsJc1rI6aHNvBHwGkKGqcTrI5g7ajxJQtbUT0vUYlk64davHjfAbSE9ZsiyoNdGi9KBj68QLLpsvJ7e6nePWAs6eugtU+x9FbFU8/sw+5A8wdaJjdeQzioCAYFe37yFEPvXiAc1Iz9tbNMXT+P33EZv2qFsS97dCcTKvNwqLFCOBoz8tkyrWlB9bEycSI59fQ0t9/5PJUlRfDYMOKZOjcemaW0Ahf+dB8HB1dIqoraeRj9G2fZ6JapVgIG37+AsynZuDVg91ctWisVTszuInEF4WfGsaSie/8oV+1aorR3yxx9eqHMyJ8YhKJ+PsFxTF8eefog4x87xyMn9xHVjBJUmjQBgokLzfk68r1rSKFpDHZY++09qEpCbc8WA2Ufe0viv61NeTmheXuX26aMApfsDig9WWFqbJ3975glmIh5/r6DVF7wmP6J00QNhT8VUXmizPE/O8zeHzyD0wRnssNqs4rVlUQNhfQlE9+WHHj/GbQNK/95HyNPQft6n60PtJn+omDghOT07x/mxHPTLL0zZs/0CtbvjuDPDnBmdoKh45p26OGUI07dt4/BmU2CW9uMPaW48YbT+MOC4N1NlBY8/cBBau9cpl7xKT9cxR9XrNweUfudQUqrUPVeXwHeL+Ty6uiK6rEdgLsBS4/uonMs4MjfOm5O3gLQcO0/eIYz9+9FS3hpfQxvXTB/B9S/WqW7S3Hh1w4x9EKCM+8SJhZuNaL5rTH2vuMc4qtDtHabUp61uo/jxizekTB+t4ezatO9xufCmTGENgJVhILkUIetk0PM/MwpDl13gbkPKIaeF0SxRXtCMvisxciTgvOf3c/k9Qu4f2WJYBDO3L+X0jIMPm8RJxYXf+sA03/vJO1d5lCOya9ZeL8wz8UPmHSda+84aazrmU0Oja6wdLvm5mvPoCYCJu63iKuKWEnees0p3Cac/up+zvzXw3gb4N6yTn2ow+nHZhBKoP58hNFnFBvHzFGI1cfKBrYfETz15atQWjD8mIM73uXwz7+IDGDgpEVrUuCs2nR2aa7+4ZdMqUbfYeU39zH6TYfkYoXSMpw/votor0/rcMSpB/cSDkJ3VBD8+m6Or07gj4J1qkJSSxh7ImHpfSFHPnECfwQGT8dsfHucxU/tY+wJRemaDRIlOflnB6kMdZF7OkzdbfPc54/QmgarC7Xz5vCKkUqb2l+7QG1eEw6aAL6lj/nIa7d44MkjVJZAoqn/aR3nfav4N3Y5sGuZ7oig/fMbNI/G1E+b7TBSbzP9vnNYpyoMPuIx+vOzTDxoMgXseZfGEy67ak24aQt3C576/DGc6mtPI7MtxfB75/ngjc8S3NhGJrDr22bNl5yIa3/0OCce2IdVjjl1cpLKncs4WzD3IxF2F0afVtx413Hefvg0/phm6BtlgrkqU2+9wMaxhD2fkwRdh423+cwtDtJ4zqK8mrD81gR3XRCPRZQXTTW/0kSHaz54guE/rjL2oMRtaXbfqyl9cJlW5LJ+zy4GXwQpNOef34WKLeqej/szCyCgMwmn/o9j1F+02fxEC21BdwJGfq9K7Yzkyc9ezeZPNXE34dYPP8dT56bYOqRpT2seeuAodtOic9cWUmi2Hh0jii0unhgjHlBM7tpg/l0aq2VzbP8cG1crZn76FOsbVa776IsoBJ1mCWfTwtrbZukWwTU/dpy4Imkv1Dgys8jkNwVbn5zBuegy/qim/p4lbp06x+H3nsb58SUm7xV0nxrm1JMzrM8PEAwJhnY1iR4f5MjgEvUzgsEvVBB/a4nRL5V4ZmUSdabK0DdLRDe3CH57khfPTPKO619i8rY5OlcFdGKHO976PO5ASGVZc+MPPc+5z+7n+l94monfLxOslxi7dplbbjrJxCMK/8fWWf7kPvSxFpsHBcGPbHDLgXPUv1pl7ZiFd9cyoz96jvfc9iwiliw8sJulmwTX3HSGW686Q/SJdSZrWzhPVnG2YGO1hvt4lcVbBc9//RD+KPhLFUb+sIqe8lndqLG60KA9o/GWJZPT62zNSFp3tNl6cOw1r+9XIq3pnwf+KqkfxNanPvWpT316A+nNeRTo5aArSmWJS1BegV0PxQw84THbHOLAnWc5/dX91G9f5r5zBxh7whx5mShJ53DILTefJPjIJqUliRVo2v/TJvWzsPiFGeLQBO+ceGEKb0Mz9P554io0F2vYD9axKhHKFgw/rxm6r4S7bDPyrOJtdz7HkbecJwktDt9wjtOfPcjC3XuojrcJhqBWCrBCE7wW/cg6A7MJI6UOC4uDDL1gDh3I0qmG/rTKTb/0FI9/+zBDJxN2TW5w+z9+lKnaJo3nbbyTJU798SFGP19Gf22Y+U/t5523Hue5Lx9m8m6X6375aSbvF0yUmjy9MEkwlB6HKmHgJy5Q/vQgcSKZutcEoagPrdPeJalckMRlaB5QOB9ZNmdrH/I5/6W9VP/KPJVv1Hjqy1fBbZsm7/xAgozM0YRL/+YAU+8/R6kUUVqNqf/Vizh7WpTXNAyFfODoC4w+YApXDNy+THVes/A2werCAPUzJiBreHqTC3dpiCXnfvMQH/jEw1zzL55G2+A2NQtvFThfGGR1s2ryVR8fYPfveqz/dAuA8ccTWkdiVt8esu8jZzj7xDSnTk5y7P/1DKUVuOVHniXp2vhtl/KcRXcULvz3/azcpNl4cZhk1WPuS3sorWu2Tg0y9m2L6qJCCM3hxjKnF0cJR2Osj6xwcbPB8k2CuGICCBMHFj65H8dO6MwkphTrQvk1r2+lBdavjtJNHGr3Vdk4JHA6ioGziuTuMR77+jHqs+C4MdcdPcdwpUP35i7OmRJvuetFoprgiS8d49lPXU0yFrJ5EEaeEAT/z26q5y06v7iOd7yMbjnopkN1UbH0U12IBaPPJlRfMGdoW74gOl1juVvlln/8OMM/f47g59e48BFF9Lkxzjw9zbs//hi1n5zj7GcO0HhRItcclj6zh/i3d3Hs6vNce8dJVq6XlFc0nhtz0wePE1cVa0ctrAAGTyRIoemOw9l/e5SZ37P58LseB0ub87kXYfR3Kpz+swNUL8LAHw8gBiLecftxNu+dYOAli/K84MKf7kMMB6z9u71cNzNHJ3Y48419zPx3i2giYmrYpDFKoRn/G2dAaub+dC/zH4yZ/lsnsY9usfB2UJ8a4+y/PUrNCVh8bpy59yrGHzdw+9DkFv4whA8MEw1onl7ZTXUhYfqvn0L+2hhBQxB+exirK3C6mpmRdVpTAtG0efTLV3PuxQm8WY/ZR2ZQWnDD1EWaM4KH7r2a9j7Ft77yFjb2W3zohmdZfm6MRx87RFwSbK7VmPjrZxDHazhN2DrX4OmvHcEONI0zmkQLLm40ePY/Xcf7b36WiUdjhl6A2T85wBPfOky743FydZTrPvoiSQlKp1z07Zs4LcEHf+BR5IEW4/vWmPjl07z38EsIqdjzGcF1N5+muydms1OifWuXsc+WeedHn3rN67tPl5+uKAFuVyPW391l4Xabd/70Y0iheWl+nPFHI/Qfj3LHntOEdcnY4xr/kWGGHnY5/VtHcL/cIBzSjPzDszRfGELZMPp0yNSnXWa+FvLhW5/i4C+9QCsw0bMDx23e/mNPsnt8A6el8D+xQTAIThPm3q155AvX0I0dbC9mrVPB3YLkXZvsGVrHacGuWpP6hRirC/XfahAMSJ69OMngSIv2pECPBcS1hOmvQGtK8K2L+0lGI+KyoPSrg3zjd2/j+d+9ms0bQ2780HEQsH6VYP/HT6GlgS2HjyvaP7vBVx++FsvXPPLJG+guVukcCrF8qCwmLH1pmtJaTHehyrlPJJRHO0QPD+F8YIXwljbhiAJXIf/bKJtHE1Rg0dkXs/mFSQOr74mYGGji3bHK2MOSeH8XGcH6IZvmf56GBxtsHHJY+9NpBj9bY//ffQH7fInnNyZYu9OnM2ly7+OSgF0+u79qUVuIOXh0jvInB2lMblF/1mHlRs29c4f44iPX84M/9CAbB80YlZcTqpUAMRoQV2DhNhvXSUwt9b++gTvk49ZCNv/DHrw1gTvkc+/Jw0zcdR5HJlRfdBl4pET3QEj3UEjnnW2sjkQNR9x640naRyI2DgkYC9j8gTZ7/t4JpND4iUOy5bL3s5owsnnP9Am8NWMhTDyS0N6r8LYUm0s19t6tKE83sbqvfSvJTYvZH9UMOl389zQZeccCQsHyj3bpfnCLyjxsHdDsH13l5MooLz43TbLmEuyKeeEPr8LbUNx+17PEJRgZazJ8XBN+bIPuqDSH93xymIlHI37wtif44K3PsLVXksxW2X2PMPvmyRD3vMvet59DT/nMPbabB/+vm+n++ymaT4yy527B+u0BSTXhq6evovs7u6lfUHQmQVUTbv2Zp1h4f8Su8hZn/9shqnPgthRaw+NfOcbk/SYPvzMJ8x8P6R4fZPobIYt/tYu2BY5IqFyQjH3b4kM/+yAX77Q49NFTdMdh/j0xpRdLPP4n11B+5wqlVc1tH3+a1o0+9QfLRL+0xoHaCs88t5eRty+wcLvNns8INn1TD/7B+46x0q2a0wOnNftmlnnywUP4F2rcfOMp1n+gw9KNFrO/ehVDR1fZu3+JC+8HJMjPD7P7bRfpHIyw9rQJI5uxf3SGlz53iHM/ALf+7FNEN7Rxb9jg5r//OM3fnuaOH30ca6JL4sGeL2m0gB/84EOc+vfHWPjfD5Lc0ELv6XLNjWeJK5r6RcWJrVE+9O7HmbpHU/75OcSWzcJv7ad+VhvFXMPw7YuENYG3meD83jAf2Psigz93nq88eQ2b+23aP9Bk8mOzVM8LfuTIUzTn6pz+jSNEdc3oHfPUPjuA/ZZNvvm7tzD4+SqbnRKz//UQT/w/1yMtjUg0G/9mD8SCo+NLlCshdlfz4Kevf83r+5VI04fQXy1dUT1OWg62lzD5QMy95w+xdN9ukpUS/qhN46cv8I2TR/C2FON/5wzjT8S0J6HzkS3aU+Dub+InNo2Tgq23d1l5i8vyz3QI6xabUZmH7z/KULnDW4bm0AJe2Byn+blJLnwQhv9jlR/8qW/xlh8+zrFrzoOGcxdH+MEjz+J/dQz3E4vsH17j+AvTdMdhza8wd4eFtqE9YeE2Fcm6R+V3B5n50Cxi1cNbtfAHJe2rQgb+oM7kl230z62g/skK1QXF0EsBbjXk1K8fZeZjZ6hdhCdf3MO+nzrJE39wLfW/fZ76JxtUdreYu0NSmzcW9vT0Kty5gRVq2vsTVt7iIAdDhkdbdBeqlFYh/uIocWBRPyn5idsfwvm5BW68/gxOLeT6q2dNUY0XQnZ/wUL/7xMkXx5h85DgzkMnmPqBWawAtBTw1k2CIXMM6eJ7Ixb+3wepXoS3js0ilj3e+94nOXV+gsQzvvb5uyJkqFhu1Wj9/CZaC+762W+jbY0lFfsOL/Dwyh7cW9a57eAs6z/douu73L7/LHYXpu4JaLU9cxDJnwxT+2oN96EaF+7SjDxn0Ix9n5SsfHaGrz58rTkI5bqYykmXoYdcRhstnKObyA2Hc79+mD2fFex6JKbyeJmbp8/z4PMH2OqWePj+ozQmtzh3l0X77ABP/vMbcVpGgTv4K8fZd/UcI//gLMLWnPvJBB5pIC9DJVU0IOGp/88N3DxlghCDAcnIZ8uM/VaFsY+fY+JhTfv/mMa/UMNdtxBKMPMFwaEfO8HiT/rEWtI+GrK2VmPjo2221quM/ug5lAUXfyDm/PtsvnDyGA/97g3s/8HTjDwNi7cL3KYyJ/VtwelHZ6jVfJKy4p2//DBBwyJsKOyOYvzrrknpe7zG+g+3mbsroXLDGnde/wL3feF66k+7PPlbb2H99oD120PcjZjqfx1EhnDo7x9n6psh0aEuw18tmTiKYZuw63Dwnz/P579+K51JTVQVfP0/vRWnJZgsb9KdUOz/I42M4YM/+RD+vaOUV2L2l1epPVmiuqjohA5f/+TtzHxRs29gjXAiYuZ/eYnybw1ROydwWoLbxmaJy5o9N1xkqVkj8TR6IObcbx7CfrpKeMBn+RNdBktdEiWhnKAtzeDJgI3PTjH1Z5LJ3/LYWqly4TcPMnI8pnrG5msPXMfw3RWaCzVe+KfXsnIDnGqO8rGrnmH3t2KiiuTWDzzP85u7WLlecuG9AvuJGnHHZvYzB9jzxYiNQ5LNP5pm2a/jtBKaoUdlpmkUuLfHlFfghhtPs6vaZP2GmAt/NWL9422+8ke3sfVfZqics9m6IeQHDzzLC6d28yO/eA9fvnCUt93wEqs3apSnGfK6fOAf3s+14wv8yC/cQ+Vn5pj4nTK3/MKTvP2XHqX8zRrBoMXaMQcZCZ65OMnIJ6tEf2uVmY+evQwL/JWpX0r11dGbr8d96lOf+tSnPv0loCtKgNsdTe3LNSZ+5TRJIpm6p4uMBZWFiODXduM9Y/yQzz54gIs/FTJ4UlO7u87+d8wyUm9z5lt7+eAvfQsxV0K54N5Xp7QS8uAjV7Hv8z6nz07wmSdvpDsBq1/ezdGfeJHSosWZHxPcM3+YB54+TPM/zPDXfvzLHN6zyN1fvQ13C44MLnP88X3UTtgMnNUsbZizd2/90ad52y88xsUfSrj9+pN4GzHXDc4z9hgcuPMsN/zS09Sec9nzyye481ceYOu+cVp/vBvnFxbojDs4j9YorSU0Iw80eAsOz917iGt+7DgnH9vDzf/iMboX6jROCkSi2f8nCXNLg/DNQSZ+5TTuikVcgZn/5vDB6Re49fpTXPtzzzH6jM/e37e46Wee5rG1GcbKbZ7/2iFmRtdZ+k/7GX26y8U7XN71zx9g7W+3qCwphl7QPHB+Pyee3MP7/uaDvP+f3E8Q2PhTMaPPxtCxWL7eZeITs3z2xevYf8MFZttDoE3Ned61gXPR4+xHbX78wOPUfmcQP3T44rljvO3Gl3D/6zA3jlzg4lOT2JbiQqvB9bvmGPujMgcqK4w8lyCjhKEvVmjt01z1N46z+Z4OzaMRzmBA5e9fQMaaxJHUf3CeyUMrrN4WcdeNT/PzP/Vl1t8aorXgo/ufY/e9isX3h+z9n19k7YhN/YLiiS8dQ/gWjd+us+/zPkdHlpm6R1M/sMHsxwTNA5r4nVs8/LlrOfPCJE8/sZ890yv83A0PgoaZr/qXZY03HnPxBy3O/Puj2L86wuJdIf6wZOp/PsHcl/aweLvA6iqGnjVHi+p6zNydgqfvPQynqjx6cYbp6VXqj5XY/ZsuBJKN35mh9P5lJnevY3cFcddh4FxMM/RYvCPBWxe0JyySkiR+a5P3vfsp2icGecuNZ/j8F29n8f0hH3nbE8QVSetjW4w/GvJjP3UPcWhRf9Zh5N9VuOeZqwiHFM0bAzbv6PLXbvo23qzLzL85weqPt/krP3ofx3/jas78VY3adLEDuPOuJ/mhf/E1pj9j89x/vA496YOAmR8/TffDWzRuXWa2Pczhay5w5H97noGzimZc4qd/9is0Zxw++2vvYfjFmKAhed/MS3gfWebcR+GBB4/hLDs8/emrufiDMZM/PEswolgK6tz09hP4/3k3t+4+jxUIrFWHynLCgQ+c4dq9c8SBxYX1Qbp/vIvqCy5o2DjgUVlSuE2DcrlLDtWFmKWf63LHJx7nrnc8gbZg8huSqGYzdW9C8q8m+OLvvxVnK2bhoyFz/+IQLz4/jbMJ1kSX9v6IxlgLfxS29ru4mzD0os+T9x4haNhsPDdC4/fr1GcDRCL4+C98g/nWAKc/fQgRC66dnqP+5zUmH/Cxu4q4DMf2z/G1uSPcdNUsX/j/3snm6UGO/94xtAA57rPx7/fy3+59B+eag5xqj2H96xEWb7ZZDmqcbo3wV//ml1m4QxO+vcnuqxdxn64y/zabhbMjvPjE3suyvi9FGoHSl+fnzUZXlACPS4L2NJz5L4d5155TvP3XHmH4aVi60eXCXZrRZ2LisqR2XiBPV3DamtpcxNnVYda+Pkk4kvAHj9+K8jRT93T48M9/m5v/zyfY/U1YuL1MadCnfNqlPsv/n72/DJLryhK14eckZ1UWMzOJmaHEzMzMjLYMkmXLIGawZDFZLIuZmblQxcyQWcl5vh/quTFx39t9Z9rd03e+0ROxIzIP7LN2xjq5aQHOH608TgqmeockakVkYj7hSdAfIvlDDNwsiiQp0ZdJXa/SbvoDqiwK3N588hcuqgN29+2RlUtxU1Rx44/6BJyS8vJGFB3X3uZmTjilvXRUbAzkyaHaOKdYiTsWxYPCELwfGlH2yce4xwejkwT/LumUhsso1tpjdAHPxrnYZ8HTu9EEXTTxx4MGyMsluL7X03P5NYpqKLCVfsow9vpmJMoSUJZCpb+MozebkVLuiqtCx8fREvIbysmaHQbAqxefDIW87SopiZGg81fh0TiPK1uaY3rhQm6sDcmIAjoEJ2B1sPBwWSOurGtBgHsp/iGFZHQVkFZJaDH4BeZl3og2CWWHA0h8G4BMbUawQrhbEWY3C3KfKnZea4t0ch7Khxpi3At4cyoGvauE8xca4/lUpDTFhaJH3jyMCyenu4Wj51uSHSvgtyqFkurQvMkHUsrd8HSpJOgPAflrewp/D6KoloT0nhIqDUqqznvh4lXJ7dP1kAg2wnbb6B/4gsdfNSSrp5U5ja7x4F41rEooD5Mg00LIGQsVwVLy5pjIWR5GyQgt5SX2hByzIS8X0OfZ4/beiuBkxim0DPNOb64ubYXRXSS3qepP67fgasHQupKuC26jHV5OWl8B+9cqHLKspFW40rL/C4IumOi47jbFDS343q3C6bkCRYkEv0afEo64O+iQr3DDoUse4cvikFZKAagyKcgrdMLoaQWbgNZPRqRTIfZpMjxemilpYKY8VIabg463q2sxoP0D2rrH4/7ahrRQQb7Bkb4/X8XLsZLaP79i95PmyJUWtPUMNNvwBFW2HNHRQtfq73Bx1nEgviGWyCpSl0UDcOhNQ6q8BXy8y8DOgkkjUGjUcHxtB0qjpOi8BQIOygg7rqeWU/YnQ9C9bmhkJtIeBfJuZS3KIiRcexcDQNToOLpNv4NiXg7FLUyceluHikceCAobIbWyCLxm/LQlUSWlfHsA3lGFpGyOpvD7YPKbCNyOj0CTLjCi421ymsko2hFMwt1Q3N0qsaRoUPfPQ1fNhMsHCTXHvcNjRirpo62URH+KumebX4i92kjCohrc31OfojqQ2wJEATK6Q/WVb/F+VIVNIcHpkQqJycrAZo/R+4rMrnWD4Q0fYbvrAoCuQyXyKhGDm+KTH79NRBlegdleIH3Kp2X8y9+1orDUgfJ6JsJ+N1FQpcHlQxWiRGDIsgufjNw2BKCSWahc5ItMbyPsuBGDB9Sok0aLkBR0nlJEqUgn3zhcFTrMDjL8bxmIvxxO0t0QdsY3JeyImYD1MtTfOeGcZEOqB9dXf8kg9U/k8xL638d/qxbLjFCjXRJSM8gkVk4eaoW6xIbZCbAK5DWWUWv2a0yxFYQ3T6NyZDnF1RXU8s7F4CniE1LEN83Ooc6XkDRMyYm4upw+1wx5pQWZHuQPHbDJwKSB7HbQMioZf3UpGeXOlMbqqfKSIabZka91IPyAiWujm/Jsfn2KlgZTHiZQ0UMLXga8Hmux+ht4VBiEa7yNVksfEHRBx7ZHsUiOueF60o78RgIeLw0ELUygItKK7Bc3MjoryI/zpLD+p6AmpbsCcY03Iz51Yubo0+S+8UbWoxBVgUBKPxlIRBYOOIkolZBtdMH7sQ6f+1CtVyJyLbi/M+GYbkXRuwCP5yA55sals41oGZVEdKdkEscoqeuSRbXa6YSMSiJ1UzRmB5FWCx5S8Mz7f4XxdHklI9K5kPMJ1WkUnfppj667ltw7/lQd88EuU4rrB3i2pS550wyIuSpM3csQ5SLuf6iprGukuWsyKGxMqX4Xm4uJ7EIX3N6bCbcvwLtzJo59crBJYdzS0zjHSQg6W8mcplfwvizD7G6hQ9M31HNMR1Yl8OpYdUzHvRgY8AJ5pQWJEdR98wg+q0NwMOP1owKzPRieuTJx6EWelweR2lvJ+dltGbTmImonA8e+6oxnzQKa9X1N415v0IZYMbjJECVginMCoENQAosaXyS9mxxFGYRE5RL91Tu8PcqZGXET4/BSxvx4mtATVZgd/rx+m81SbFYJ+y+3ZlrkbeSORlQlIkN+OY9UYiPxy+rkN1RyJS8GwSJQ8ZUOTY4Vv9aZiGs8sdXQUvzAm4yOcvJfenP3Qm0CrlpQlVqxO+1I6I5Pf8KKHDlCt2Ke5Acyafh55FoL4SF5TJh8lrxiJ3I6WDm/tzl7NnZDXmXDKUkg7lwE2+JaUN8tixdL66FOl1PHJ4eQPQInjrTCohEJPgQXntemmVcabUMSUb62I7+hjGjPAlzvqKiKMGG0yBCkIiXNjCSfDCd0TCJV1Q0YXaC4upyU3mruf9EET3stinIrr29EYna0oiyzIKsC/zNSDu3sQGq5G89KA0l5EUDoXpGWkckYPGzUDcsg/WkAgkXEqoaGtT5SESRhdNBD8ltZqfKSY3Ww0DIqmXrD33AqrRZ9uj5APioP99c23O11TOl2mdw4TwbXecqAGVcpM6kpXhOM+rUadbGINUiPeac3xekuFM/QUV7diu9dGy7vJWT1thAamkfC5CgG/3aJnElGPJ7raLnpMde2NKNm/RRW3e7KrR+a4/7WTON27wl2K8F1VAb+c5MweltAEPBbIaOovogk0Z6wQzYqAqWQoyJ8l5WUfkqKn3kxaM9lcpsr+WNsW8x1ddjlGcl740XqNMhtKcHsKEdeDu8yfLmdEIGxazneDyQcORrLyxJ/jI5SMtuqEKUQ1DwD31+V6D0VJA9R0Hb7fdp9cw+pESbNPo06+5/XVYh8zkb29/LfqsVKbz01HbOZ8M0p7KRmvJ4ZyewiMr73FSL36vG7YyJtRjhN/NOIfx2I50olOj+RxKOROKQJ9PF/zfaf+mDwtOEfUUC78ARMnhaKaikQpWBqrEVdCANG3EKVL+Xe0xgyqlyx2SRQpKTGlLeIAQb8HMoZ+ttFyqppyJ9uILfpp7jO/cNfMbD6C7zWpRPsU0SEUyE57W1Ut8tGlApEh+Wg9RPQu0vwqpNP1aJyWjkn0qPRSyJ/eY9H7QLCjulx+SCwcPwxynrqKK4ux+eBgeNjO+AcLyDb74a2hgmsAj+0P87xgW3w+ekjz5Y2oKChPV2+uk38yUjsWhVisZNgn1ZJ5S1P2s+/x9AFlxAl8PxsdWyigPMbGY+/asjHInfizkdQEiNgU9o4d7QZzokixXU+hY70HJTO3QfVcb6jpo/nC6pmlcFbB4LOliGxiuijDaiLrBQ1seK9WYXNzkZlvgbNRyll/XSgl7Ijrjle1+WcndmW9tXiCVtvhfkFHHjWhI+JvmS980FTo4Qfr/TG6AR6PzsOpzdk5tKjANy+WIffl3ZBXQDthz+muKGFTec7kzXDjKVpJbo/vMlrZo/KzoRyRQF+t3R4t8hmx4EuZKyKpG/sY7R+crZu74nVKiGnlQT7ZQ48/r02jjIDYUdN5LSzog36lHXJqpRwd3sjfr7TndbN3qLpnE/OPX90FgXlt7zYsrwvJVlOWEUJOS3s6dzp2Z/Wb0UJuJy3w+pqYXdaM6QJ9gSNS+bQV91Q/eCMVG/FpoCCSgdCj1koLHJAO7ocV6WerLYyhDgNJkcRm0qkb6cHWCL1WOYVYVVIKGwgkjHNhtpTR8BVPQ6bHGnjl8T2vd3o8esNAPau6E7YeiuCAN1G3cfjhZaMPjaU5TZ87+vx3q3mxN1GWKYWE3SmjKzV4VjspPhfqcSqFMkcY0HtXsX7L2rycWYUBm8b3g/NvEn3oyxSxNFNh8MmR75scAnNWyWaTvm8vxCJ1yUls3udRd2mEHWBQHE1OSnXQkjvLmFM36uEHTdTVEOBtUU5ogT8e6UxMeQuFtsn90j54jw+ro7B+6HAy6RAlFHl9Nx6nerdEin8IYSGvd+x+dfeYBGwKgXkRXIKpgdw+15N6njm8HRBA/Je+KB3k9DYNY1NdzqgzpFwPq06XrIKcn8LpbCOFF2MCZe35Xi5VWBwlnyKn7/ZHue3UrS+UvyHpBB8WELWE39EmYRlj7ozOvoRiWOVXFvSEucUI+8ehaLOklISIyG9m5S7CREkfPAntdCN15ejcAsowzC2hPLFVahzJZgCTHTeeBtNno3AOtmUhasIPmfB44WVRL03ni8tfBxgB8n2lH+jo1mLD1jLlGhCy6j0lxHZPwm3G0q8Lyuo452N87syqoLNFF/1pbAeOGSArbqW5Lf+ZLdUoHeX4HtT4FByQx6Pq4tZAz/f7o5L0j8vFvp/JYIg7BIEoUAQhHd/5bwgCMIGQRCSBUF4IwhCvX93bpQgCEl/KaP+D/ee+Wv1/rP4b9WBf+Yzn/nMZ/7/DQHrP6j8B9gDdP4b57sAEX8pE4GtAIIguAJLgMZAI2CJIAgu/6sFgtAX0P49rf8z/Es7cEEQnAVBOC4IQrwgCHGCIDT9W9frStU8HFWHQ1O68eyLeuRONRISnsfmh22Q6M34f59E8kB70ipdGdDqEdmxdozqdIsaQz4AsO1KB4rqgNXeSmaGO6/X16ZH/VfoahlQF4s4n7WnyegXPBpSA/8bVQSdt1LySzBWm0DYUQM3n1ZH/UJN0o1Qtn/fl+rT3lLNIx+3d1aG1XjKpewYjsXV5d3e6qS/8+XZ4VqocmRsn96XmHUfyDsVhHPLfKZOPY3xiBeS7e7sz2zMtdMN+LC0Fo6LlOQ3tKOoiRkHiZ5p1W8T1SeJ4moqchZaMGnALscIOimCDVKNngT+lk5elQPyCgtOqRb23GiNukhkVMgjysZqkawtQxQgUevF+hudMDvZ0McYeJPmx9wZx+i96hrGHHs8X5gxBRoJPWlBXgnTvzqOslhC4JkinBUGQk/qURda+epBHyaG3sUhXSRhkgabVEC0SCgdr0Wws6DzVlC/ZgqCUYK2uonAlQJR23UIrx3Ib2tGXmpALTETuPEjXX3e4/FARuu6cXg9Eikr0tCiYRzDhl0nq62AsMedRbf7oSiUMWvgGSqCJUgs8KHcm8DQAoLPGbC/6sDY6IeUNzEQ3icZ56Ma3n4IQpQJ2DZ4EdMtCZlRpMoqp/Wsx/QefQfFYw3OcQKttjzG+4GOczcaUhGqQpMkR1TZ8G+UhdlewKoA36sSHmSGkJvkgf9NA29PxqBuWYTfmBScPsjYsbIXgggFxj+/hu4aUE5hfREEkTlh11gw6CQVC/3I6m6joL6aj/3U+N4zoCuxw+gqx2aSUsMjj3y9Bu9a+VjUIv63rPjcATupiZCtoPzJ5ZNh2DWRSTXuYsxw4ONYKekDwEmmR10gsi+1MaP9H6AqtZHdSoPfBSkvx1TH4KnC47ac0igJJdXUlEzQElkzE3Z7kDBFQ+iCeOp+9wKrvRypmxExV40hS4Pb0nTSethjk4uELo3DZpAScaAM7x9llIfJcZAaqD/gHYqNbsgrQO8mcHRhF3T3PfB4ZcLrmR6HZoWIShsvyoL4OEiOuXklQa6l2GdUYf7WiwPTupNa4IZpagmluwKR6z+5uS1vcZwvq11i26FulHwdiCjAsxM1aDL0FQ5JUoxO4HfLTMI0Fa1bvCW53J3c5grUedB/2nUOJ9ZnUssbNOj7jopCe3561ZnKXpW4vbPRODKVklpOSLa7033KHRzuqfFakoq6Zz5ipxKSCj3IaS5HEVNOjS3vEC0Ch3Z2QJDbqBpXRqPVz2jUIh6pEfQhZmIbv0OVqiD61wq+rX2esLapABTlOuH0vR2+9/QIUhvhyjzKwiW08UyitBqURigojZbypCgIq1wgpE4WLnULKUhzxUtVSdT2SkRRoKTRJ9/Govo2gqYlUmFSET/bHk+fMgweIlYnCwY3Pm13+Ono2eMRbu/0GEaV4r1cjkRvxORnxsFbS+7Af14s9P/KJXRRFO8AJX/jkl7APvETjwBnQRB8gE7AVVEUS0RRLAWu8peBgCAIGmAusOzP/RL/ef7VM/D1wCVRFKOB2kDc37rYzsVAwlhHxmw7jTq1FPVlR8ybfHD2qiSzswt33kXi+UzEXVVFQqUXdk2LeFgSgsEqR+hQgus7sM8SkGplyIvkFNWBq380IPCIDJlexO1pEVdv10UwWfk4UEVuMzklkTKa+adh+6GYqF1aQnqkYInR4TPlI1UWJe8LvCiqJaXYbI+7nY46Adl4DkpH7q/Dv3cazok2MjvISaz0QFEuojfL2bGiFz6jUikLk+Kh1mFyEslpIUOUS6mIsLK9zR7mnxuBTZTw+n44Ln2zMCQ74vLRQkE9NXY5UtxfCjwYVptnO+tQ9EcAY7adpjRcxvxO5yhobOPUlA74fW3B8qUHfrd0PHseDg4WNnffjVimYFCt53x3qR9/zG1Ps4bxZHSR0qvGawrqKnHIsrLsVVccU0XaHnnB46QQclrYEfnFe5xeKKm0qikPFVB7VFEZAgF/SPFbLEKpgvwmIq1cE5FVSvA7J6NsiZ6kYY4sHvE71UOzyWvhxOMN9bl9rTb7d3Wk08x75I/zprimhPBdVl6crM6OJ61wfynQaOEzmlRLQVOnGDepFvscEXXfPNLuBJGV70JOSzXKPvlsud2ObxudJ+l0OI7xFTi/k2JVy8hpLiNP50BWrJTr5+tz/FFDGtl/xD5fpKSFkTvTmqD9TovVwYr76HSUZeBzQ0JOmROuozIor2+iaFAVdtcdcI6TMHL7WdoNeUJpohuv4oPQ+YLTRyMenbN4ey7qT78MBcXOROzX4XVdzspfhrD3i17kNbEjZmUZEf2T+KbbST4OkLOx9QHyGgt4PJDx6F4MIQ4lOCoN2OUI6CeX0virp5zYFUtplJqSGBXFNSSEf/UeV6mOlk3f431ZhiZOzsGzsRidBAYFvcBNpmXOqoNY1TDux1MIVpGsNlJcR2dgCDOiybHg6VCJZakXcp2Nha0v0N71AzqrEoO7gvBVJlRFApH7tLzICOCbfscIOWVlsPtjYtaUI91QRrPfnlNW38TSw4N5kedPejcB36sFlNc1UeUhJaxTCvlT9aROge7+71A4mgjTFOJ7Q0B93YGEl0FIjGYcfsqmLFyJ3UN7FkVcxKISyB1lwDKpmBXLh/LLzkFMHHKRj6MklIfKEWwQ92NNjG4Q0jMFwSbifldO2tfRqGRmAs9X4vbBxL6T7RgZ9YS9RzrgLK8i+AQEeZRg0CmwqAWyV4UjsYB2dDnntrZC3q2Q53eiUK1yQRvvgv96GURrsdk+WUTbpX56tixfwaKoixx5U58qi4LKaDPTm1zHUWagZodEbCoZPxwdxDi/uwgn3FBnynFdnYVVKSVig5kdPbog1Cun2GxP2BEtns8q8WmXiXyxM/azsig6HUDlAw/CDxm5ubkJiWMcUSvMRITkkr8qlF+77OJJShCZR0KpGZZFSbkG/1tWvm1xFvd3Fl4V+dMq8CMBymKkVWbKkl0oWGREH+yMPF9OrH8ybcIT/7R+/xfhLgjCs39XJv4n7/cDMv/d96y/HPtrxwF+AFYDVX+nzH83/7IOXBAEJ6AVsBNAFEWTKIplf+serVaF61sJh7q0JG6OO85JRjTJZShlVhaPP4QqR45pWClF3wXT3PUjE0PvkXo9mAhNAa5r7DH1KkPTMR+312BxtBLeIAOjhw2Di5ScVtDuxHPCD1fS8fQLHJMkeD634N8rjcc5QfjblxPy60fevQqmum8eaYfC+XAsCudDDpjCDFxOiiHjWhC568NgnjOh3xhIfBJE2Mx4urZ5TlK2Jwa3T0s8YeMTmR9wGU2uSPq+cKQGAf8bJkw/ViBxMbG2T38UpQKnF3bA7GYhNd4HqUFAO6kcxwwrRudPQS3KajgjCuD1qJL7FREgwIo7XYnapSO9swrrxir67L5O6mwIOW3G8ZWC5dNGoiqSkK13JuCqjbJwOfffRNK/9SOSKz3wvaslq4uI6qE9hY1tXMitjrOb9lOeZZsM73vl7NvYBXOIgYDlAp07PkNistH+8GNEhY2o3ZUUmR1w/SCS3cGGeoMzqmKBlWsG8z4uEGWZiHVQMR4vbXg/quLgg2bET3ch+KyW/HlGqgJsRIXm8NO3O3iyogGPk4Op0KrYNq0/FpWA43QBk7ONXtXe4PPAiKuqioj9BhykeoyukDTaCZ0vlIUpCD9QzJCAp1jdzWwdsY2BTR6TYvKk28JbxHxfgtFVQfEzL1Q5MhKyvZBYRIzOEoZEPifrQhCKDAWqexrseucB8P0f/Tl7pyGim5GQEyKxbV+TO8tIxgs/qgL//B6hl1sZyUM1lPXRYtYIaOZk4tktk+SldiSejOBYXn0UnnpmPhhCwDUz7g+L8b1n49696sRneGNtVc6ciOu8XFQPQQRNrgXnflnMHXia2/dqsnp3P/LHeaOotNFm8DMW9z+Cfb6NP7JrsXTxWBb8MYKgP8pQSczYVDLCD2lJzPQiap2enOYycssdKayjojJAxqrnHfjucQ+uva1G/+8vo/1ZjyZLpDJEw54muyixaEjrIWPS7VGUr7WSezgEAEWOgtZdXqFRGRHMAokTPBBtAm4vyol7EIqngxa/w3KelwXSPeIdUmy4TU/DqW82gRfNjDt5gfz1oXSbegdtiI13en/aT33A0Ohn6K54YlVBZI9k1t3vQP+6L2g59hlOaTbmrz6AJUSPo8LAD9t2oKgUmbvtIJKvXUmZL0FRZkSdDyc2tMP5o8itvY0oaCDHtMGX8C1WZn97BItKoMncpzjudMKuwEpxmQa3dyLFM3T43bXSZssDhkc/RXHLkefL6uN3R0+7UY+JaZrCgvsDcHqkoofna9x9yjmc1oAHeSG8uR5J4ig7zE42Nme0weNWLsEnikndFonsqzwSp6hIHO/OF9WvcO5GQ3w2pZM8RIN0kTN2y/NILXRD30qLPtzI1N3HsdiBKBcZGfwI/QY/ysKlzNsygZBdAh0nPCD+figbGx9i2cZf+fFpV7KGmekf+II7Z+tQZHZA97MOm1JEvO7K2DWncEyBs+9rcvfiPy8SG/CPXEIvEkWxwb8r2/+ZcguCUAcIE0Xx1D/zOX+Nf+UMPAQoBHYLgvBSEITfBEGw/98vEgRh4r+Npqw63X+9lJ/5zD+Rf6/flaX/iHBun/nMfy9EUfh/yQo9Gwj4d9/9/3Lsrx1vCjQQBCENuAdECoJw6x8hyH+Ef2UHLgPqAVtFUawL6IAv//eLRFHc/m+jKbWHgm8W7GPs5RvErC7g512/Umt/Arbj7hRbNRjdrZhvuKHMraDEYk+WyRVlGZw+0RyJ2UqEWxEbon+nMkggaqeOpNcBfN/pGJ4TUhHcjOzb3hnBZOHQys64v9azbN0O0ktccDjoyJ2kcD7OjKJJwwQUEit6DzB4QnmohEj/fCK/LsPjtYXSwVpq7oyjaDWEnNETt6caaqmJ+sGZGNxhYvg9KsxKTpbWxzKkmPZTH/DL4H0U1VJgtkkJ8S7i49cKpg8+iypHS9uacUjMEjxfWPH8EnJbSIhulEZZhEBhXQHBBpMPnuL61XrIK8HrjpTyKAdsKpFYjyT2pDalaVAauc2UWJUgsYr8NHwfIz3vY5MLOGZYsEuVce5IM+JeBpPRWcOEZrfxfGXAL6yQtBQvxofdRxf4yQWp7q536D1BmqXCZW0OT9fUR+cj48iKTijd9TTf84K7C5rgei8Ley8d32zejcQI0SPjkDia0GSbmB1+Ha2fhMpvtYSesCArlyJYbPg6lWOXJWFW4DXyLE6oi8wEnJRhb2cktY8UeZWIyccRu8BK3pX5sGzXdvL3BZM534a3tJzwPfnYHC1YVSLfztuH0ceBzYd6oMxQMP7MRIw2Gb7yUm7Mb063s89YtGYPsmrlyLUgCFAaA6XNDRzfG8uOqRtxTBUxa0Dc4Umb8Y+RawU8nsHEencpjpHzNC+ARdUvUa1xKqLM9ne9BP9ev7UK908x19870G/8TUb7PkC6yBkAbV0DcWm+SN5oaBKeysgNZ0kc78aUlcdwq1aERCaypMZ5Eg3eGGaXMnnyGbJbyJgbfJVfnnXG8aOArVEF2Z3ccZifyd3dDbCXGFn541YmB9/G5W0ZzZp/wG5TEd8dGYz150+rAb6n5Wh/MaCpXsL0mNvItSDrXojfUTlCkRI7lypOZNdBscqVjUs3YnIU+LH3UH79vQtRv5Xh+lBB0QsvFs0/wIndsUhMcC0pCrnUyvDYe2CDAfWfw7pyQs5W0cQjDWWRkZxKR+wkJi5uaUnunhDkS1xQp5TwzaHh5LS3cWVlS7AK7LgTyx9/NGPPgxYMHXeViCGJVHzjT9hhK60d4jj7sB6ObwrZk9scq15GbYcsJuyexs8rfmXWH6Op8lPjv0uO4cdKFJUi1h4luDzOY+60YwwaeAvVrGwWHdqPn6yUsJnxPCkMwugooSxCis0sRV5lQ1upojhGxpPSYK5+0xJNtpX8wQam7jrGvdxQ8naFEBZQwPSZJ1l1uC8ei6S4fyXD3V6H/w0D8nIpEg8DEY6FZPX2JXGRHeoiC+nFrkjKZdhlCZwrrI2sSsBeZsS3eh5WOzmFG0NoH5qAt3MFEdssLHzeD3WXAvZ22o6vvBS7rComjD2P2RFyWiq5XxAKInz5ri+TXw9HtEqwe6ImSFFEyOE8nvUIRvW9ExH7DMgM8NuCPkybf4JZDW5gX7/479Lv/4acAUb+xRq9CVAuimIucBnoKAiCy1+M1zoCl0VR3CqKoq8oisFACyBRFMXY/yphBVH85zro/9UHC4I38OgvDUcQhJbAl6Iodvtr9yhD/MWWgVNpsfkxl7KrkV/oiP9xGZUTKrDf7YR9tp7c5hoWTjrCvuym5FwOxO2DBfv3BTQ+nYidxMSWJ7HIcxUcGbaW4b/OIeByOYLJgqA38eFLd9x8Kqh454bZ1YLSxUCnkHgSJ0UimK3U2hvH8VtNCbxkIa27lGM9NvJUH8KxGZ1Z/dtmxqyaQ6dxD7i8sxmVTfUE7pWS1ltK4AWRdZs28m1ab95/9Cd6XSU2pRzBZqM8ygGHVD0mZwWOizLRf+1NlbcKZZmFnMlGqnnlo5/iQvxkZ2rXSqPcqEI9xkLcUl+kdmYU7+xYPXYn08+MRV4hoCiDnqPu8qJbABVNArGoBerOekn6cH8SlzhAlgp1voC2uglJqZyGTRKZ6nODiS+Gc7TBDqbNmYXDmwKij2UQ390TfQ0/nL7JxFmh58XRGni8NiIv0WPw1eD/TSKNnFL5/fsutP3yPve+bkrjZU+obpfNwZFdyI7VIFjAOcVK+ahKjG+cGd/3Cr+d7siPgw6w4NoQejR8SZRdLgczGlFlkqNNcCFyYyaF7QJwf1KMelsZjVxS2Xu0A4P73+KPrbHIdSJOyXqsSilf/LaPAwXNyNM7kH01kKpoI2qNESc7AyujjjF1wzTqDHrP/QfVkFjA5QOUda0i2juf4T6P2JweS/59XyxRn7avFO/ssMsDt7eVlFbTsGvpGsyihKNljRjo/IQtBW25/rAm0evzmHrlMj8mdcPpKwVLTu6neXDqc1EUG/y974Qy1E/cd8WXTLMr6Xp3wu3y2b2pGxURIkHnzRjcZLhOSed9fABYBUJPWvg4SIr3HSl5sRZWtDrG9syWpL30x6YQqVE7DfNUR5JHuBN+qBRtmCNZvS1IZDaCf5PQeeNttjxrTdguG7KlBeQfD0LvCV7PLBSOrsLugiNmB2g27AV3TtbDqXU+E4LvsT21JbJf3VAVmzC6KnCfn0r85XAGDbzFnufNsHfWEzithME3n7Hs+ABad3jNjfu1UBYJRHb6SNbeMCxq0LXQ8WWdyzhJq/jy9DBc34HnmE/ZBb8beQi5YGFHbCtG33zAhi8H0eG7u+QYnMkc7InF0wnLslJSUr0Y1OAprybUxGdTOnGbq1PY0YjjUxXltc3EhGVTsSGA0kgpQYcyyO4bSGU9A2E7ROSZJWCzIjo7YHKzQ5lZStx8d2JWFzP03C2WHR6E2UFkWY8jrP1pEO5X06l5Loe4Cm+Si9xRX3ZEahIJnZBI2UwfCho5Uh4h4vhRYO+CNazJ68jLfD98HCuI9UjES1ZBosGbMrOa2xnh7Km3h4VTp5DZUYY6V0Dva0Oil+D2XkRiESmNkhDyewFxs9yY3voq1wujKd0ehGAVkYwtQHfGG4dMCxIrZMVKWdl7P+vS2mM3U0HiJFe874F2RDkdAxN438OHoFPFfKx0J/9MIL43Suny+wN2beuGz80Symo4Y3KUoPcAVRFIehQhPeKGRSVgcIUvxhxjdOTDP6Xffw2/6s7ipCOt/iF1Lal59m/KKAjCYSAWcAfy+WRZLgcQRXGbIAgCsIlPBmpVwBhRFJ/95d6xwFd/qepHURR3/291BwPnRFGs8Q9pzH+Af9kMXBTFPCBTEIR/s/5pB3z4W/eoss3U2fCaYc5PyUt2R5WoQqa3oTrsQkmMlOIaGpZP28nSU4PIOxuI0QV6/nKNpEk+XFvSkr37O4JERFUIU76ejVUFkqwCMnq6UdzcG8EkwUdTQcNWcahc9Zi0Ci5ebUCrPU/R+2nQWpWEHa1i0ZY9RP1WwbrcDmxPbkFGZzmzZ8zA4AFvB4Ti+aIKN2ctLChEWSAlo4/I4P1zMC90Z3nLYxQ1dKHL3ntsOr0dqVGkyk9N79XXsIyzQ5QIDPr+IgX1FPDegdQyV/x3ZeH8QcqrhEAWhV7AFO7FrCbXiPhRT8A1LUvie2JTfpoBRvdLJKXKnZSJwVR5SnCK11Jqskcb5YqdnRHBJuD9RE/diAzkWoE3F6P4pWt/3H63Z+7oqaxes5mkid7czwslY3gIqjwdK4JOcicxnMraRgrqKMlbaqMkSsbXvhfYsasbo5ec4UW3ALJbyvBUVHC/PAJJhYHI7sn43Sjj+9U72FVnL926P+ZmxwjUtUpYu2goWARmet4kVFlA1XkvzA9cCT9QTtl2JR4Pi8hr7Y6HUsuLsiC8nluwihK87hSx4/u1SCsN5DVRkml24+6bKOxkZhzTbLg+UFJVqkbY487UN8PQBYg8P1udc/1XE9Qgi8pggfm1rpJwO5RlH7piP8ZMyMlSJtW8R4B7Kc7JNmYvPEJWewfcr6QxZOM85o+ZSqQqj+kLZnHtQzQRh6oo2ihn7vOBxPokoQ11ZGm/kX/6nXBW6Tla0JBrgxpy9Y8G1FFlsHzeDiQGAWVeJfk9jPwQfJqzXdYjrfoUtlOil1DQ0YinTxk/rx9KSo4HzvECEncj5unOZHdyJ2JtMoljnJFXWnF6qsTZqYpNezZyMrMOY+s9IG+OiXKDGkWFiE0GA5dfxJLgiOeZRLRBIvcP1aN2jzj2xOzjWF59il968v2aHeS0VKPKN2CY4ESj7u84ejgWh9cKWvp/BImE5bsHEP5rBjeTI3FKFPB8bub1m2A8zybRavQzwpfqWXarJ9sm9KdP+8e438riw5sgPJ+buVRag0facDpeieOLe/1xfF/MnpdNkQg2sFgoj7QjLccd71syHi1uhGC2kvJTNEWdDPSs9gafq0WfooeNlmPWSHDIEqmq6cvKGTtY1+wIWW3VlDbzxebiSMyeRNJ6KlDt1rKw9QW+vHySQ20bY47QI1jhckkN9O4CKevdeDGzLhnHQ9lQ53e0gRA8Pon0zZFIdEZkehHfGnnMm3mEnldmUmDQIN5yQWtS0svhNcd6t+J1R08uvauB81ENt3XRqLO1RByoJLhrKpG7yrHa23B+W45FKRB8vAj9JjNqLx3lFjuMS33I62hCXWRmR/QBnJNMFNWSocrV4XvPxqJDIym87YvVxQ6fOyI5bUQ81qhJqvQgZ4sDHZ3fMT3wJi7xZiaeOIuvvJTyahbSe7ricj8LW/cSgk4V0WfqTYYHPyViShyCFVwSrSy92O9P6/dfQwRsf8kJ/mfL//VZojhEFEUfURTloij6i6K4UxTFbaIobvvLeVEUxWmiKIaJoljz3zrvv5zbJYpi+F/K7v9D3Wn/lZ03/Atn4PC/DAB+AxRACp9GO6V/7Xp1uK/o9cUcXJ/JkPUppOq6B2dmraDXuoXoAm3IyyWE7s8jfYA3QTuTQKEgt2cQnSfep6kmmVl3hxDzQxHfXT/O0BMzEGUi7pHFyKVWRgY+4qPBk8u7mmF0AUmdcqR3ndB7gt9tM6u2bWFx+0EUrZdS+ciDgOtVGF0VVFvyhsQvq5PaS06rRh/IH+9Dfgs3ZAYRq1xgyRd7WbFwONYJxajlJtaFH+WN0Y/FlwYQdMHK11t2k2Ly5MjULqSNsxE1K4PibpGMXnSW06Pa4LcxleZOybyv8uNsYg18DyopGqNDr1WieaXCsVMeXX3fU2qxx2yTcOFSI+xz4Ic5u9nUrw8Z3Z3ZNm4rbw3+HMxoxOzQ6yxfPRRN/xx0v/tS5QOCBdzfWTDbS8jtYsbHuwznUZWkjw1n2dh93K2M4saexuh8QVO9BJ8FVrK6eqD3gKBGmXxM80aQW5lS7w6t7eMZfGY6U9pdY8vddhzrsokFE6fw6471jHg/GuGQOwUNReS+Vdjf0KAutOH0Mp+4eZ5EbylDVMrJaemIS7ccZgdfY86tITjEy/G9XUn17R8Y63aPUW9HY77mhsQKlY31fNPgAj886Ua4fwEpeR5caL6JHSUteTcqCqGwlPTRoQTtTCL8QjnPl9cjp7sZuzglmhwR6dACcvOdkeYrWNN3HyrBxLpGreh9L47Nia2pyHUg/KAZqc5EVYAGmxQiv3hPls4ZiSCiNSlZHH6WL1dN4NWWuX9qhuIa4yF+e7Iup77sQHoPsE+VoWlZiGqLCxldBey8tRjSHJEHalHIrEhuOCO2K6V/yCuelwWScC2M+UNPcrxfK9KWKjFm26Mok+CQLlIRLLB/xAYGXZzG2BZ3yDE60cYpnkKLAxcLamCe7464ohSLTYJlow+ZXUXsU2RY7CB0bw7pg30ZPPgmhSYHLn2Mwe20mtgvHnJ+X3OsCmjR9xWv19cmr40FaYWMxk3i+dn/LGMSh1J0wZ/x48+z7VA3Jg89T6nFnsftfIlbGYz9ewVuHXOwH2UEQSDuez9WtjrCmaK6vDpSnV9nbeRAcTPuZoWhPumEZWAJkpOu6HwEfhmzl7MldfhY4UZ6nhttIxOZ5XWNvSXNeT8whOImnp/SmUoEKv0lrJy5g3WtOqCv7ktOKwXejyzYv8qmcpcCh/FmilsHYLETcHtbRdIwJSe7beCrbiNoeOgD7vJKTs/sQI1f3pA82B9MJmT7LZStDkRRZkaRXYaumgfF1WTYtSqkMMUN+wwJtfrEUTzTn9KlBqaE3WFXRjMse7ypN/cFKSOCKK3vxtzFh9me2ZLMEhfUtzWYnKBH/we8LvMjpcCdVfWPs+DwKKxqEZtCRFEqQVUIsi5FiKJAca4j1VaVkt/aE02uhZIoGQYPEWWJgP+lMpJGORG5u5SkES54vIJdP6+m58MpLKl7jtOF9Ygr8MSU6IRjKqiLbBTXkBBw9VMY2InbT7J1en9EqcCdC1/8U2bgvtVdxHG/x/5D6lpW6/Q/Rcb/V5H9Kx8uiuIr4H/Mj/2Zz3zmM5/5zD+Kf7Uf+H8KRZqZwY0f45xspOStO6YmWkbOnIfncwPD2tzDHK7H5OtE14GPQColYW4gQ6de4cm8Bmxr2wbNewVJE32Z8tPMT8ZC7kb0Vz3ITvLg5OBY3sQ6oemeR8jWRLy2qtH5f1qdGLr2PDkWZypqeeA+vhKLRiS/oR2/bNxKK6dEsqeY8LkD+Z0lxE92ptfUWxTXBmW/fJauHEVWVxt5OS40c09l4J65fHuzH6d7rUMdl8sXyyfyvDKYtB4KljQ8R+4eD9yupnK3NIKVR3dwKzESX3kpYaoCqvvmYf86h8AxWVyP3YDvzTJ+iDjNzqtted/dm1ket+jX7T5VsVqcJVV8deows4ef5uduA+jvEE/FDS9W/jIEqxzMv3nTd/Z1gja+x+wIJdEynB9mIctX4DRHiu6AHa7xVjaPG4CnogLvu2Ws7r+XsmINhU3d8XxuYEav8zgrDTi8l+PuVolcsOIqNRK1NIFt19pTt0Yqm/LaUTJNx+zUAZjPeFBUC+S+VWjURmwyKK4pQbRTEvWbluwObiQNc8DnXiVZ7735ObELSicjHYY9Ru9nxx8fanGqvB4OmxwZMf4KOl840Pw3Dk7uhvd5BTZRoFZANv02LuD1lJokf6VgwM2XNO79hqLdztze34BKPwkxy8q4Nm0lpdECB6vtxfuygmYtP+AtLWfizdHkDI3i1MBWaFOduNttDfU2vCS7jRN5Qw2UhUtZ4nMJ0wofMq8E4TCklCmnx+N9Ju1P67ej1MCjslCKo2Uo82RUBVnw0VSQNdiM1MWI0aBAlIkErP807jY5QHm+AzfnNifYvhjHJoWsjWtH+vcKvJ0qqFEnjWtjV1AWKdC7xwOW1G3P2W7rGOPylOS5MTRTZ3Eqtw62AWZKamoo3xNAVrELFpXAlvZ76Tv0DuGtUzEGuVG3xweGOz+ltiYDIcmeMYvPcORNffwPJHFg8lqe7ahDRd9KAs8I2IeWUzrRk8nVu5BT5kRlmJU9G7pxZdIKzkxtx55nzSjuHIHPJRkTx5yH9Z6YQ71ApWRH7G6iFflUmFWcnLuSoTcmc/lmPVSnnYid85CSVBdK2xtwbpnP4g89mOF5nfxr/txuvZHbV2tzorw+F441IeBgLo1nPWfET2dZvGIn9Ye+YfWgwXz4zo+KEAXHhq+heJyOnC0OfBV2gcFXH9P/i6v4DElFVqwlZm0hAx5MxujjyMPpDTn2dWeyJph5W+pDWQNPqqr5kHk0lLIwGWk9VFhdNHT/+QaBx3M5UnM3EdWz0EZY6OD6gfTuDuhveJBo8CbroyfKciuVZhVla2z0/vIaX7/ohUQQ8XauIHJwIgtGnEBrVbI7/CiuZ+ww2OSE7c4BPz3R6/MJvFyFqlTEc6qeknRnZPYWEqa44/zRyIK1+7HJwSUOzk9bQXl1J6I25WJTyrkwaBVzvjvMpBmzUbyxZ+vXA0guccNeacLtncik2adxvJOM+xsrOl8VTdY95dtXPakMUGB0lv5p/f5rfArk8jkb2d/Df6sO3OSu4vd7TSiLVCLTCVxqvAXJtHxSJ4ic2t+KyOUGPg6V08vpOYbq/ihLBHac6YjfsmRW3D3GhLHn8btlptv0OwRufIuPRznStiUovavofOghM188ovSmN3Mf3cJ9SRrtW77GsWYxuWZnVnwxArnWiiXYi4jG6fidymDClhns69Ueo05BfhMBMcSXCz3WkmNwRvDWU1xhj12/XGJrJLCm1WHOZ1ZHpgdVtox5I6aAwcivX63nxbZPPpaHBnbAesMVXYNA8haHMX/wJJRqMxt69eboF13QLvZDLC0ne2x1thW3IGR7CqGyCqLWZFDvfCZDv1zA0evNsCVr+KlpJ+7pItmd1ozKdRakgoB3p0zKwwQaj3yFTG9j5/U2VLWMQmKGmN6JZG1wxPUdxM90wX6ollMb1/JxlIzdJztgU8l5WRWEPFuBS1wVpVEqXKVa4v+IIHboM1TbXTmyrBNvjV5EXNERtbWI9HIXEjZUx3rfBZsoYJ9nxS5HQHVfA2fcaDXqGS6NCoifq6H8RyOiBPA0kDTCnqf911Ly3p3QJQYuH29MVn8zX9S/zIOhtZAtyCNKlYstQM+C+dNQpBXjPT0FmcRGZ/d3bJ26mV+Pbkbx2p6tP/clc1447vPAq1cG86ccI+4bZ5pdmIMmE8aNm43eVWCM113GbptJ0GkB777p9Dx6j8hfS/hgcsGGBGXbIu4224KqGPouW0jo0jguT12BvmkE/ds+RKyo/NP6XWFV8fhNOPX6vgcgelM5xWuCiVxhwNOlEptVIPqHZEq/1CGR2FAVg9N7GTKtmfiWCn6vsRsPjZavalzkWMxhJIJI7L3pRGzN5E1LDbbIAHpcnMWEmt0ZvOMiO0sbYbTKqHmlCGWFiLF/KQ+ab6X6vLccKWzM/hdNKNoRjNsP6QzzfMi0DqPZvL4vB4evxyDKif6hHFyc6PfHLJZ8sZegxSZc56ejTXekaq2RhvdK4Z0DYUfNVLTSM7HDGKqtekfM4lyK6ovYpAK//dYNu7RyPFakE/etGz/MHsvWwliSz4XR8dYMwnebCV/ymnazH3C/IBSpuwHlOzW5aW58FX2JjQXtmDTyPHlWJQ61i3ncwZ+qcBOxzvEkd3HkdNtaLNgwgYeZIWS3dUCVLafJhOcM2jWXKq2SsnwHli4Zy4WiWgx0fEX802DyW3lidbbH84wSq0pCRkc1Do8zuNtsC7kP/NCk67F7norPyRT6jbmF63swuam42SaYyKOZTO02Hu12f/a138H313tjDDaBAHLBSvSWcrTeMopGuKE3y+iqeYtFL6fgVCCVJ31ZHniaHppUvBUVdH01juO/rOTrF71IWeGAy1U1yeN8MDnKyW9vxurtgtKrisjvtfjeElm1cwvLUzqzd9J6KrtraXdvBseWr2TqlctkdHVgdstBbEhti6rQSNCRXCb9eALfKRXo7nrg+iifRxWhfPgxFL/5yeg9JJxOrYXykQZtIIiSf27n+Dkb2d/Hf6sW2+xEZJVSPB6V4ZAu0u7UfJTfOuH/uxxFBWhDHWleO5Fvpk4kvZucfePXc3LYapzleqZPnklNVSZIBSa6PiLvkB/hTkVUfHTGVVPFlj+6cLigCXYFIj/MGsvLe5HcuFGHBp6ZPO4dya41qxmy/gJJo5UwWk76sECsduCwowShTM7ZAavpfOAha/I7kLCkOlsaHUSQiMhWu5Pf3sbiX0fiusYeg5uI1wsLKZMg/pswVmV35vL3a3BOEJCtL8XkBNs2rSO9i5yM+TZCZpdgs1dSUEcG3xay5f1F3N+ZOH22GZcf1mHUpDkUdA7ieHIdvv5+D25vIGJtEvm9w5nt+pYynZrCcg2DRs0gp8yJ0B9f8X55LexTyolansaCdfsxudiY43cZs0WKYkQe0VvKSVwQgRwJnrdlzB5wBrOjggcTGjC190VS+tnhNTSNAwM7oYsxMdD1MRndbQgirPx2ON9530bMyUcmsdFj0Q0WjjuGYYUvBlcJdkUiBjdwyDBz9mE9XMZXIVVaEfa64/1Ez/LGJ3APL6bv+JmoCgVEOwW6UDOIcKMkBiQSFCOtfLtxFJ4XVDjOyKDNufe8fhZGcq4npwa0ZFmfYXTfspCtE7Zi6ldKRmc7Ugd6YFzry++x9bnRZj1d67+mzug36OaU49s/DT9pJe0HPsF+fhaZV4IoMDsSP9OFNTUb8vi7hlyvvY+eX8/n2JIVeF3L4enRWvyQ25HiaBkPlzQiYXPEn9ZvY5EKhwQphWO9cKpfyA/nDlASLSWtlwtNPNNwfqDiuyeXUO1yxWWThu5T7tB33C1yWtoz6fUbuv26kF1RB6m0qen0/XxMgwTUz+wwB7rT5UnmJ185m4D/FTNHR3agn9NzsvNd+MLjIVmdrZQVONDl23k8OFWb7PmhPGq/ntJoAW0vkdVjhpI8ypPyCJG5M6cx3ikJm0ZJyhBP6tRLYfXsYWy8uJv3Od60aBRHd5933J/dGFEClV9U4n5eRWWMK91dXmIO9qBmvVRcnxcxfcJp6hyIJ3dpOFHrq5AabNw6WZ/eQ+/SIuIj8vxKkn+LIlXnzpCAp0RM/Iiplo7mtRPZ060d33hfpo4qgwPFTXH/QcmCh9fY2OogZ4tqg1xOyuRQKsJt+Dh/chcM2RDHhSd1CDlSQKhvIQHnJURPf8/LG1GMThiGU7KA2zsd2mB7SiMkGFykhO3MJnFOME1vzmBC/0ukzxVJnh1J3LIATuyJpcfcW6z8dQu7X/zBuzIfWh9+Tm4HKyZRikOSFBBpN+QJD6c3xORpz7j5Z5h9+SxO2x2ZFDec1jGJ+J5IZfPCjXTfshCAK0taIT/uQsvrszjR5FekzxxoO+MhoScqUCzMRZav4ONsCbKnDhS08ECTVMrIjXP4PvwP4o3e3Gi8DSfHKmam9SVaUYTbOyvxyzxxnCqSHWtPdncfguVFAKhaFFO2SeDBpVpUW/SRxP1RzJ59DA+Nlkfz1lGrXSJVnv/zZrf/HfiX7oF/5jOf+cxn/mcj8j9z+fsfwb/UCv0/iybSWyy8rabVqyHU9cgm1jmeWHUmsY+mEDanmLT1LtjeOeLYoBDDVQ/0XhC+/ANZ46tRVVePzSxlf6sdLKvRHLFGGIYfK8l96kuD2DhenY/B7ADh+4tImOiKYBGw2VvpWO8dH36uSbPFj3nb2RPR1Zn6h+O4lB1DaYIbYUerkP1SiJ3MTPyZCPZPXctX9TqTPyiGcTPOsnVvD5yTrMxbfpA1C4eBCPYZWqoCNBSP0lJVrsb/Dyl5TSU4JguUR4qEN8igUKfhj9o7uaCNZOXrDjhfscP9WRlCRRUWH2e0S7Tk5rggK1AgNUKTTu9I+y4KuzdZYLWCVEq/Gy85lVcX2wAzWTs88XSoRNajmLVx15hbuysFA6vRYPwrLr+qwaCGTzh6vzFRu3UkTLQj5ud8elx8zqpLPVCUCMR0TMYwWEb6yGC+GfM7P28bjP/eBHKGRSFYoayRkeftNtH44Fwc0gQqWlUhldm41HgL0xr3pzQ2GJdnhYiFxaRPq4a6ABwzzGS3lhN6ooKk4Q5IfKoYV+MBV2e1ImUErGl+BIDtjRuiaxmJ/d1EdC0jsbv6FsVFRxILPQhZYiR+rhNn229g5C/zKKlnptpXqVjC/JAlZWHT63G+quZdgTfCPScMDXWELzOQPMyN8JVxCHI5Nl93ZGtLKdkaxLilpwFYdagvEe1SKF8ZSFEtGbpgC9WWZPDtg/N8PXESyqwKsrq5s2LKTubtHse4IZdYUO3Kn7KADampESNVC0iaI4ciJc7hpZhuueGaYCGji4BjohSvxzqKa9rjdT6Nyt1KsjLdifmpiIotAv6acgoXB5M50YK5TAkmCWNb32bX/VY4v5Pi8bKKVYe2MX7JHNTFVuw/FHDkzhGar57D0HFX+fVJa6Y2usX1eq5I/H0Ri0spOeyJj6YCQ4dyDny8wR/aUA7O6E6b1fdpbJ/M2l59SRrpytBOd7mQVY0fov/gqzXjKGtgImZ+Ku7nLBQNckB0tMd+WwkJpyMI6ZHC21Q/YhZlk7bJHeV1R3xOJLPz2SnGdRiNNsoVRJGFa/Yz++RorI5WXnXfQJ2r07Fz0hM0s4ycPkGcWrCCafV7c/LVJbSiibZr5nN5zkpa719AwHUjXTfcZPe+zkwZdRYHqYFKq4pNH2I51OA3huydQ+sur3h4qA66QJGw43ryvzDislVDuxX3uD2jKbKH78ib1ADfs9mg01HzShHnUqsT9JWJpkff4a8o4Vi7+hx+fJL5Oe34sLImEovIj6u383Ot5qTtCcGcqsGqtoGDBUSI+bGM5GUazEUqUFs52XYzAx5Mxvu4AsEGxdWlnJ64kv4vJ+A/W0fcF94IJgFcTAT4lGA/VIvukAb9QR9MGoGKxgaahaeQsCOG7YvXobMpGH5tEnNbfFqZmBs3ANVOF0qqSREFkBohuGsq7+MC8XgkocmM51xIqsaxpr/S99Y0XrXfRIev51BcB3b32saM9VNwjTeT1l1K+vT5/xQLb+/qruLwQx3+IXWtrnP0f5QV+n+rJXQ/VRk9E3pTkOvM2zW16GqXw5heE3HVVBG/MICgCdnY5YLlrAcGDwhomEVlu2j8r5SyqckhTsZu5ptpE1kbd42MTg6Un/El+KyO0q4i4R1TkIVXUhHjSuQ+LUu7H8XrnpR7WSHYp1TyuswPW6WWWocSOXm8JStjjiN6GLEsK6WmUw4DPZ/i86CK0a9HkzUmhpK6FqqpsjHW1VE8tIo5N4dyYeMGHOKKGX74EvUWP+dU/e3EddxGja9fE7EjH6dBWeBnYH7gZaqeujHg3Wh6aZJwcaii+sT3xM+1J32oHxP3naK2WzZn221ECNExa+AZklfEYNZISZoVjK5hMAVdQ1h1qC87wo7T+84HvJfLSf7og0StZvQ387Ce1FDSxMSVD9WwS5eRbXAmrs9mDB5qIqc+5/C9I+xe3oPR7W4R2/MF3wWcod75THoOus/+5vXwvVlGRetwXD98ylIU81M5jQ7NpWmrD4ycfpE9jXezrt4ROh5eQEHXUNwmpXPy1hG0R10IWP6Uq0tWk9FJhu99C6wqpW3zN4R4FlNDlYXPso+EHBDYmhnLnFtDKO4ZjcFZwsqXF8jobiNheS0+XgolYJ2UslU23B7IsResKCpFZGUyMkdFUvZtFZWHHUlYWZP436PQ5dtjaKgjYlYuCQvtsThZwWojZ2A4RfWdaeORwOXV68k3O7HsRi/cW+Ty/kUI6hwdVYEWoqe/InVCKHLBxrodmzh4dS9OHfL4etU45g0/SYre40/rd065C6fP7MHzvBLv+1CS70j9/u/I6GdjefsjeD+oJLODPfPn/078wkCycl051HYbkUczse71YlnAGZqufoLdPXvmt7yIR2gxvx9qQ8BFkW4T7pI0ScqXjXrg9kcctb97BVYrA3qM4ca8VZzPqYFUZeXgto7s/niT03dPkL3Xj4rHHtRyysYYW5MUs4Jlt3rSYtUjdt1u/WnPUSLB7S3se9yMUKcSpt4bjmO6hTbV4vG7aCBzSQTx8/wxu9vzXcAZjK5gGSLQPOojba4mY8jS4P6mirjlgYxrPYziNZDVVqA0UsaXb/tiH1VG9PwPlNgszGp0He/NKuIXBhA84CPT6vdm6/PTxJyZxqKcDsgrYVyLwQRcNzJo00XOLmxPlZ+Nsw0C+L1bS3Zs64HmgoYRm+dweNRarryowYCxN7HPEpA8+8CZujsori6nsX0ya/ZugerhDJt0BbGsHHN0AK/H18D+D0cU2yu4+k1LutqnMPjGU45UhiITrDi9LMDhTjI/DhxOZcfqWJIckIdoiVmTj+c1BYEnpBQ38SR4HQxu/giHNwpGr5uD/0E5C1ccwP7ia+zyQCfKcDjgSPpgPwIviEQueoPSzozdbAXFnSMouOtLjSlvqQwRmVj3LsmbYiipAde01Znzw1SCT4qsf9mW0ffHMDH0HjofKcE7Uwhqm06NXgmoZBZEqYgohfvbGxC5qJSN+e1QpSiod2sKl35cQ+TSOJZMHof35qfM23yAN33W/2n9/sw/nv9WM3AnmYdYve+XHFm7iokdxvBxuAchJ8tpt+8xW+63xeWVDFWvfDQKI3kVjnxT7QIHcpsQ45jHT14v6VGzPZaSUjK+a8KZ0Ss5q63JqcUd0btJcH9VCTYweKsJ+DqRxG0xuJ18x5xXj3ihD2ZfQmOMejme55Xs+mUNg9bNR5NjQ1Fh5cJvm7lc5cqPv4ykuJEFVbYMi71IxOpk0rZ6YcjSMDz2Hue2tUKTbcGqlJDXHASTgCxUi/8mOXv2b6DX63G49UjC0LMhBSOqWFXnOPNeDqBb2HveT65G4lg1sjIZFh8j0SsqWXlhLwsb9cLm7Y7EaKaiuhs5rUGwwYT219lzogPBf5QjpGSjjY1C7y5FlEJZKz33Wm2i5+L5VAYJaLLA81o2jc8kcW9aY3KbqKkKsOH1SCCv5afoUN4PRXI6W4leVQ5yKSkDXSBSi7FMRcAFgaw+FnpUf8uD/GCKCx2ZUP8uF5bEItdaSesrQZUtI+S3FNLGhRJ0ogiv3Xk8O1EDZQWo++aR99YLq4eJuqGZvL8Vzu8j1jI7aRDKb504c2In3eP7IGmfTY3nAiUme+5+DMPtqori9gbsNUb8p5Ux+85VJt4czevOGxnxsTfZh0Ixdi6nmkc+JV8FINhEkocrGN3sHhdWtSZ2zkOubWmGVQ21hrxnuf8FymwCM4dNJWWywIPWm2h6ah7R6/JImuhLxOpENj8/TefHU5G80+B3y0BmOxW+90yon6dyqejXPzX6d7LzFY++d2bSpbHIKqUcHbyW0evmYJ9rw+lDGRNPnuP7dZ8Cxvw0dydfrxqHKIBbv0xclXqeJgfxTZPzRCly8ZPpmJPWD91XPmS1sWPN6J3cqYzm+tpmFLUzcqLVVrylFgbMnofOW4LOD2wKkcgVyYhebuT9BLU9cmjtnMD3D3swv/FlDvzQDZcrSVjD/Zhx8BhlVjtsSJALVtb+OIgjP6zEIEqYmDCMqmM+DJ51hVkuCXQaMwmpyUbBbAN+31ipjHJh4+r1DN05B7cPNpp/84jLO5thk8HQ8VdRCRaUEjMrbnUjalslQTvSeLeiFtUWvsVdoaWuXTpf3BxI0CkRQYS0ISKuDxR4nU0haWYoEb9mY/VywmF1LtqOOuLX1aBaZBYfkvxY0PwSW3f3QFUC9vkWykNllNUysyH2ELMujiDogpX8hnKUJTB/xhEODO1CwmgNKf1+pdqvU/C9Y0Tnq8D1Xha5m+zxGVdM+tgI3D5Y0LzJJ2OQHxIj2BRQq3ccFSYVhTuDiZr6gbsJ4aiTlZgdRCJWJCL6uBM30wmpvZmGwRmM8r7Hhj59EbILMFcLpDRKzXdf7mbGnWF4XZeT39yG0wcp7m8N7Ni/gWnNBnHg0XEaH5yL7z0rEqONkmoKDM20/Fj3NIkGHw4caUfLnq8oN6v5yu88va7PACBqkw7Z2lJso2TU+yONc7+1ZMWcHcx5PZCgLwzEL3Yi4KgMu1txJGyOQLRKSB/95T9ldutVzVUceqjjP6SudXWPfJ6B/58QBKGDIAg7/hJ8hb8jTdtnPvOZz3zmM/8fPruR/X38Z5bQxwILgOGCILQF6vxTJPobSCPAaXoGo4fNwOjnSN/u98n6Fg5u60jUjFdYO5dSorWDr9yoKNCwu28nJvrd5m2fIOqumkbObg8WfXyF11MLA16N5/iPnbixYTMez8oZtv8SRXUdKB6nY7X/eYo7GMiYXpO52ydwfG0HfDcoUL1XEzQ9ia5n5iLYILetjcxOUvrHDmHeheHYFVpw9SvH6G7D4mwlr28ExnQH1nXbz5WVLak/5jWxPzzAPtuAY6IE/xsWhLcO5DdQ8dTgzdU6e8iZ34STm9dizLXn27hehC41cjsnnFq/vifmpxwsDlbsEpSU1HdjwG/zCDpXgSCKZHX2YOPq9QRcseESUcJcl3iMgSYkucUUHvRE7ybFJoeSxia6Rb2nzc4F9Jxzi5CTpZS1qyJtmB9dHN5QEqMm8GAqrq8lOB59BjZAALfpaSxtcRokkLtMBBuYc+3QfJRRWFeK/ykZSqkF/T13QveK3JzajDE//cH67ZtQuBpwShVJ+CIYVREIlTqSV8TQcuALJCYRTzst4fvL8XCvoHxxACdGrqbvuZlcrXYC/fcVtH49BMVwMxK5jPPJ1XmcFQT5Kh7+tAWbWcri6uco3mHPukatcH0mp+nWubgqq7AqwNepnLIFfpi/LaXvjmtMbXGDPU+b4/qiBHe5Fq+r2YQOSCavWSVdVi7gqi6GuXsPs7vZHraXNuD3HpvAYMTibaK4SwQDlywg7CsdDo0KUXzMx/OlldSBAnGrg/+8gpstzN41gae91hJ2uIyJ38/G0qqc7t/cRKgy8u1vIzG4fdrHnLd7HF6H3uO15xUV+/w5EHKZX1vu425ZJD+16cnI+BFULvVHsIrI9DDryDjKzGpKYwTOt95EvzOzmJPRkxPrVuPRLwOrnY2ebZ8w9O4LEr9Q49U/jSW+F1if2IaYpYUcn90JuwIzKTOjkFSZeKILo8jiyOLbffjmSS8cMkxMHDqdKVNnMynoDjFjP3D+i7b0CGqCsrCK7OlmKnMdWHN+NxN/OsHspEEEXK/C8X0x935sQpUv1BgYx42Jzdl6sgsFZsdPv4kEXm6ujVUlcC0umsfzG5Ji8sDNv4xvNu9GlVFOzNc5SMwi8YuCeT1yHUmT/RAlAlX9BBo8qMT7tpT4TG+iJr9g/du2OLQtQGoWURXoUXQqpNqSbGZdHg4aC+m9BRYNO4b3zpfE2qVTWs0B+wwJ9ZZNwa5hMcO3nqOwoUj2Bg013XMp6RiOoaaeiiAZhggPvhx7hMZDX6MshdfnYrD2NfBg+RbiSzxpE5NA0Mb3nB+8isRNAdQ/8IG2tT8QNTebXh4vuV8ZScI4J9DYEbw6kfJwmHt0DNHzP3JjxXoc/SrQ+YHiYz4Dvl9I3Pc+9JgzB1ECmR0kKG+/Q+cr4nVAxY/xXdnxoDXKUkiZF0Xy7iiGb5iLfaIcD+8yVp3eiWGxN3Hfe5JS5Y7RBVZH1aGxXzq5a+R82eASqgvP6f80Cc0rFT6X/nn2zp+M2P6fyUb234r/TIsrRVEsE0VxPp8ysTT8J8n0VzHnKEm5HcyOAxspmlnF605ehLsVUWPYB2wmE99VO4vbEXs0K3MJO2JF7+/I/ANjSFvtgCbbhmfPeCYem8SE1SeoKLbH5VoyrRZOp+/Bmxzu2wa3IRloC+1ptXcBLjfVNO79BokRVAPzOHhgI8vG7qNkvj+qQgnaQBHfqxJq1kslebQX0d8n4b4gjZJ8R5ziJTzouhbvS9n43bKyaXh/bDIY4PaEq7+0QJZTSueJ97GqJfjcN2FVwjt9AOuKGxJwoYjv82IRVVZ8puuoCnbCeNuN94NDKegYiHdoMf4rnuIxNg3njyKOMgN5P4p4Pati2hez8PsqifK37szKaY7mvYK5967htMqBWhPf4JxkwvWRgnu/NaBzjyfsutMKocpI0HYp5yetYEmtNpRWt9Hj+ls0eRb03erh+lpK5G/FmOa4sez4AHJ+knK09k7MIQZElQ1bowoc0kRWr92MUjBzYcoKLPZSMtupOd6nFQZRhhCnwfV6Kq6vBXT+kN8tCOeZGTz5rR6xMx9jGCgho4cz5gseLNm5i8lzZhP9dTxNl84gM8OdaWG3GH37EUk/1+dt890YitUs6XacjaWhhO4T6aQuZEHEZfa9Pkt5Sz36QAvbA26yfe4G0otdKYuyo/SCLxsP9mTH++bsbfMbNfYncbN3LfyOFvHmcRiloxvz29z1vNX6s6FOIzykOha4vSXe5MOBJyf5qdlJ/CZ8pKS9gXXX9vG47nEs2bnYn3+JytmA5O/MRvbvMbkpCVj+lE6vxhC5MxmJBYJcS/l9VztKmnjjGmfB+5EJh0wzwTtTaHK3EJvegNuTYtpPmcKavgOo6ZCFto4vvf1eY784G9uyEkyNtfjfNCERRBzSYHLiUDZ3283jxBDabl2At7qS8AM6ni1twLZF/XG+raaqUy3kAlQmu6DfATkTTKSOFpHUqECoMnLiY22OL+6EJllGmG8hgtXG6gPbaPHjQ9rZZVDSU0bWcBPGDnX4+IWc/Q12gURk0MvxLHnYC8lKd9Ln2HDeVYTD2VcoSqGr2xuiN3zAOUlk9+PmOL2XwppyCmPNVAYKIApktlNwbVpLxoQ8xE9WQVldN6x5+RTXEZFXSJia2Z6I3/L4ONAOgFNHW+L6OJ8xtR+SeyIKldKMZKc7zh+0SPRmXJaosBUW4fJWStSkNzStmcTpgrqcTL5Nj18WYpdvxtxIi7xKpDjPkf3TexA2+xGG1y4UjXRHUWmjbUQiYvtS0jvLWb98ILdSwjFroCrIQu6wGDIsOtynmXCW6xHD/HliCESWYMfjGQ2Y7HmL/J0u/LBvMCePtyT0pAnX3yu5d742wef1vBm1gfKOUTRZPRu/aRXYAvXoq/vimG5C815BeYiEyE1ZeEUU8XFpPd4MW8+xzWsxPnbF48Gn4CvJo2XoPcHgDroAK5dq72NKwlA+jpGCRcKXvheRVUHF2SBinRMIcylm7eHeSBwcONGyBjY5OCZr/7R+f+Yfz3+mAz//bx9EUfwS2PePF+dvY3KF0F2ZTOk1Eb+xBeQMCkffpog3+b4Uno1m3qOBlIdISD4RTlpXBXbJxdTrGMegiBc4pFWRfrQWj4etYc+kXvzRdhOVzUJxjqvgdO9mmD00ZNwNJHK3EaOnBbMD3IyPosbAOARBpMn1mXz9pjeSn4qQGuCbbifJayYQbF+M/00TqFV8F3AG93syXBJNjBowlRFX7qI6+4z0bvZcX7aOdR26UdAYrFk5XPytOSVRUlL7S9B72zi/PJanrd3J7OpOms6V0KMih+8fozRSxtCR1ylaI+D+soLKG55I1CqSCjzI62jmTawTnn0+MmHXaWb/8Dtl/ZRENEnj6u26OKbbkAo2yiKVJP1cnW7rb1DSzEhJPQs3DjbC7wZU1vBAsNrovmUhabuDUflrOVXNk/TuAsXVpbgkGhh28jqpvZ2o0SoZxR/OdDo3F7+TcpDbkN9xZPuSdSyu1pKTH2uzKKsHyiIjwT89I36hI8fKGtGg4wcyhofiMiKTnUM3EzIiiaQCD0qaGXk3PByrnwfqAlg5dzs/DRiG45tCrNWCmT//d1533oiDRM8X9/tjU9uwIXKk4xbWrRvA+hudMC0qoc/wKeyIjqDnuxGIRUpGNHlAr+rtuFxZk231D3Dyh5UAbBizHWuWHXN/nIKbvJKMft5kD/Ui7JiOuYuO8G29jtxJCyNpexhdz86h+dKZ/N6hMV0WzWXnxN4knA/nXIvNTA9uSZfghhh6NCBxZT18tymxWf58pKpqXgVIIkJwWWXPg60NyG9loZ/3CyZNOItydC4V4yvwWJyG/aIsUieEsud2K2Se7rjsLCS3qYxquxNobZ9AnW9fsu1tS95+CELSLhO10oTEaMVPWYYmx4JyiTNPdGEcid2GY6qNzO8iqfhBj+Z9ITl9zPz69Xoy+9r4IbcjPVo/xUOtw5xrR5eY9wRPLyLxB2fc9mrwnJ3Cs1kb0G315+s9e/my03Bu5EUyrn5vEhdGcLX5JvLHGfDbr8Rgk2GfIsNvdA6yXAVpw0SM5UqeZwWQ+nU9qmoaWHpqELf3N6CoDvhel3L7yzUkvQwk5ot0nD7aeNN+MzaliOxJHOfbxDCn53gGfX2J4tGNQQBRArnNdey+uZ9NPXeRMSqcgYNvkdfBm5Pb2qA+6YSbvY7cVtB7/01sajmZnRyQeHtS2thE+pcNePg8Cu0CH1r8MJst8zeSPsKGsVyJYAVFvpy52w6StLsBIb+84tsrR2m+9BHpsyPQVqpwjynCIdNM+E8m9F7gd0VCZbBIh98XYCsoJL6zK6XVHXlYGY4lUo/EZGVDXntcVtpjlwuez83IHn2guIMFk5OIRG+h0dOROJ56hTbIRnnTACKnpaLKruD7X3fg3CmX1gOfI5ZX4jLZiF0ejE7tyuLcDtTonEhxRwN6T/C+LsP9jYXQExWs6XSQLl/N5VS1g7jdV4BJwhfdR2FTgstYLYUWB149CAcRBEcNqVt9sNhByffGP63ffwsrwj+k/E/j/9qBC4KwXhAEQRTFP/79cVEUN/7zxPo/I6sUSBkbQGYXZwr2uXFt4Sp6v8vHc42SHTX3E7VSj1OqjcqaZqLWpEOlltFe95jm+ow/Tu7CYpIyOKA5slIDX3QZicOrPOKn2JHVzRNFcj4GHwtrft+GILcR1i+ZjjFxvD0RQ3vvBLAJOB/TUL4jkMD9KXx/vydej0X6uzxF8eADNg8nvmzWh+I6IuUhCvKa2rM3uymym958N+h3Onwxm/L63nhFFyJ1c0FVKuKYIeLkW4FPRCH57cxseXMOz05Z9PF6id5dRtc5s9Hk2Mg0uKDY6YqQms2uqRuoPO4BCRoit5qwabWcSr/PupR2vKkKIKd/KCm3g7E4WvGblczkZ8PxOpdG7iAj+5Ibo0xTErVdj2OaFfmUPLotu4HsaTx6XxuGYjVf1riM5IYPjglS9NEGola9xyzKCNuTQ9HKYNxGZOBzR6DFkkdEbayiMtTGl+EtiF9fE6tNQl3HTLIXWtCd80OQ2Xjfw4emTh9RloH5F2+OlzbEQ1nJlSZbUKQrMXtoqIiwx2toGqtqNqK0mgPIpEzff5zfJvVhcPVOzLk1BEm5jPBDRvp0HMqCGVMpbWJkTecDFFZo+DhEhjQ4EMde2SQN2MqFDa0oGFiNBy09KbPaMb7nRPwuFbGnoAVub6G4jo3DHxsQeDIfbTV3pMuL2JvdlNTt/uxosJ+h1Z7RvH4CXjfySFnjQmWQwMTtJ9k9aQNdL81G6uSIJMAPiVkk/IiBiiAF6iTFn9bv9zp3zJ4aBKuIzhdi1pZzfGAbNn2IRbnYCa1OxbMX4dhGK7BU0yHYwBzpR5VFwcMRqzhzoxGDH0zk+fJ6SBPsGdjkMTOTE/DsGU9WOzW11Blkt5ay6MA+HncKZMrPM9FkGREF6BXwmm5nnrKt2X6uaauheaegjkMGZ+NqUtFBR9R3Cbz5sQ7po0KJ9M2ncnw573O9OVzpR5uv73OoqClifhEbon/nw4/BXBq0io6HFhK4Atr8fI8fIhoQeCIPU90wDg7egF2CEu9bMjTXNEzpdxFRFLApRCrqmHg/aCOKShuNd86lW6vnGA6pEUcXsbyoAXgaEMKDmHr/LhYnJbt3dMH1vQ7vyELCN6UiDfCn7ZYFrA2L4ctxR7i2uCUnFq1Ak2OlrIeO/Ft+RG8pproym8SRdiBAXrdAYn4sQVkGkbOfYvuxBP8hKYw8MoPoHytRFMgx2wsEn6/CXmLkUfv1ZE2vw/f12/NqRAyZ7e1wc9Giu+mB8mE8/Y/eJGJLBnpXCdcGrCTgmpnMmXXIHBFBRS8tF+Oqo3mgxml1Dqmro8lrpMLj+HuqPGUUD6tL1qRa+NfMJbWPA37f2pA4ahjQ6hFn164lbWY1rBoVI++NI7fYifff1kJwdiLoeCHtRj4GYIbXdbSjHJDJrbi/sVHQzUBFoIwzZ/Yy98owCprYuFrlj+fFNNrXf0f8FGc0LQpxPmFkV0JTvJ6ImJ1Evrt9mpreubjE26jtkfOn9fuv8TmU6t/Pf2QGXgmcEQTBDkAQhE6CINz/54r1mc985jOf+cxn/hb/ITcyQRCGAnMAE6AFlomiePefLNv/B69qrmLMxrEsDz/B9A9DCHUuYUvQOYY37kfct/4o82T4t8xkY/gRup6Zi+8dcHqSTcbAAOQ6qGj2KZhL9IpPhl+yXyvJOhxKRZiIqlBAXSiiLLdh1kgoixCQGqFWlwReXYtCFMCmFAlfHo8Y7IvVTo70aTwJa2ojMUrQhJUxL/oaK3YOIPB4DhZPJ2QF5WT08yXwYCoZw0Pwu1VJ1TIt9j1ykQT7M+HcJeY+GERUYB6pRW6srHuCnxePJK+jmYG1n3H0QWMi9+kJ3ZTIzfP1CNkQR/LCGGb0PE9n+w/0ejqZgDVS9N+VU3XCB49nFQgGE/a/ltLAOY0oZS6/Vq+G+207yoxqzF944LUuneX+FxiWMISiC/5U1jCBSYLbUxnW3iXY7XVGrreBVSQ7Vk7fTg84d7QZRyavJkgq4abBle1ZrdgXfpL6l2cSud2ItKyK7df20PPHhRhd4bcJG/mhSReKdjmxpfohBh+dSdhRLdIyHQDZ3bxRlos4J+rJ6GhH0A+PEa1WCs5EY7nvynfjD7Bp5iDS+oEmSc7ZaStYkd+eNyvqoHeX0HDMK96trEVOK0jutxWjaGZeTisuvqxF5KRnVA5pzM2VGxmY3B3LODsKWnvjceID2WOr4f7WxLk9W5AhZWRaR8p72CjqHc2Kb35lyv7J9Or5gLfdfbG5O2P0tienpZzvBv5OgKyYxRMnkN5NjldMAdJt7mR2t6HIl9Ou4wsuPatN+uQFf8qFRRnqJ165Yc+o85P4tetOtuW0QduqCLFFbZIHK4hZnU95fW8q/SVYlaCoBF0rHXK5hQ5BCVw52YjgI3mY/JzZsX8Dw+fOp80393naQIUgl1Havw4FbcwoHY0Ibx3wfmiiJEbBvKnHWHK1L+pcKRIzOGbY0HlL8HxWRXZrO0wuIpFbcplw+RpLN47kmxkHWPioPw9jNzK68xiSh7vTvv0L0vu5g07PxzlRqGqWIr3kwrDpl3heHkRZfxVFHYJxv5dHv/MP6aVJodXjiRh0CqS5SmLbvOHBqdoYPET8b1gx20uQWICJBVSd8sZsD0/nbqB3j1HkfWflaO2dDH83GpdeaTjccqbKIifuXQDRiz5giwmmIsye2C8e0tPpBd+m9GZ/5O/EPpqCLcWegPrZ9PZ9zZWCavwReYGjWjf2xzbGVlxK1u9htA1I4t2iWmTFKqgXm0Ant3fkmp25srAVF37bTI/hU9B/UUbFDS/81z0je0YDAvYkkDcw6pPh5PVivj7zO9PXTWPf3DUs6D+BxLF2+N4QkOttZA4xE7xbQkpvORGH9MhScinsFoYm24LUaOXjQDmRu6o+GYy2cGDS+LOcmNkJnY8cuc6GyUGC1l/A54GRgvpKbs5excyMbpSNdafdiefUVmWgEsz8lNGND0l+POuynvlZncmZE4KstAr0BrL6BKALFAm8bMFnSTJP70ajSRfwelzBzyd2cqaiLmc3xKIss3Fy7Wo6rF3Au9V/Ll3uX8OjmrvYZ1+3f0hdOxru++xG9u8RBKEdMAHQAe7AzH9F5w3gI9dSeNUPV6mRq7X385Xfedr9NA9LgAe9Gr7A5GLDuMmX8fPngkQkYt4HNtz9nW1TNqPzB8eHauY0vsrEMxeI/9qBd6+CMbqCokxg4+RtVHTRIauyUVId/O6YUBVDxUhHXOJtzOx/lu/7HMFUOxRJVgH5De2QeLgRtb2SiEUvUZ1wZtXWAcwcc5qkn5z4OFiNzcmOwBM5FOxw4PXszUjzy+ji8wGJuytidh6bJg4ibJdIyoMg2ocksH7CYJxOveJ9hy1Ut8smav4bsmM13Lhcj99GbiZvcAwSM1wY3oLpg6YSMrsEWUEFIwIeU9rcQHmkBiQSdJ31SBFZ9dVwaj62ELe7GjYEDp7Yxqsj1Wm3bQHuqipGjbuE4xsFrevEo8k2My/yKuXDKimdWMmlnVtxf23jyLOGBO1Lo/eRuSRb4GJpTXIPhdDgxBzC9lmRJmdT2NyDrmsXIu9ZiLIUJm6eQVGXMJZGn2Ho4/HYVCIHT/9K3CI3Kmp7cnreCjxHp3Hu2E7s8qHLmxJssfWorFAzdPh1dgzrRdHEKqqtLKX9wCdMHjCVR3vqkdMKvpp7gGcFAZSHSkAqcscgpeeQSczzuo7LaxlSjT0uN1OpdmI68wMuY8vI4tiSFRiOOeF/vgCTg5S9FaFEXZrM23xvMibGMOuLo3hLtYS3TuXYnSYEnS7Bppaz/7e1BC95zLfPe/JTp/4U1lYQtSmPr8IvYJMLfOiymcDLeto5fwDJn4+nEK4p5GBRU9S+WuwEE3tDzrIm7T7y3HJ2ddlB8SY5JgeBqkZVBHVOo7yxgdARcWhUJi4kV0fZpISyBp4ErkhkarXOlIdJeB7rhsddexLW1cTtWipRk9/gud+OC+NWUDZDi9+5XDYkt8EtpBSbAhzb5pPf3YjfyQzkywowa0CVL5A6zJfvPvRg6pTTLLg0FPdrStqvX0DieDfCljwjvZ87cV/7Ygv24f7oVYi3XKhqV8mmJ215mBCGrbQMhwwTjvsq6KNJZXhEO9wcdDg46enW/iktnRJxe2/Bt0YeX6/fzeTvTyDTWdGZFFi7lNJk0GvyrQYyvhbQfXBl4OtxrIo5TuLOWrzK8Cfv92AEm8D+uMtkdHagw5f3uLmyGd+MncjHTE9iH05BrTRhcbIiEURyTc5YupazvTyAexURtLicguN1DZ6b1VxNi0JitnFu+EqS9kbx/Y3e/JFZi2827aZ/g57Yf5eNzqgguGsqEjdXBBH4S7IPp1QLf1w+xLIazdF7wjfpvUkca4fnIwl6dwnB38YTOS0Frx9SiKmZQc5CC2js8biURv5EPYqUAhx8K/n66AFS50nwua/lXL+mZE80YVUIVHlKmbLoJEL9cuSPPuCz+hGDRs2gh/tr0n9ScK1ZAGvadWPS9mnkax0IDcmn5fb53EsJw2ono+OJZ1h8XPE/nIxNYaNyZjlFcwMRBdD0ziVprpx+f8yio8NbIsfGoSo1k2OVcXb2ij+t338LG8I/pPxP4z+yhP418K0oirFAf+DIX9zI/ssxi6Asg/ETZ/PCZMfwV2MZOvUKx47/ypn3tbjZZxUOcSXM+vF37NOkzPe5TPcnkxl1airh27MZMPk6vy/twjdvexG6E4Kr5yBYQF0A85dPxmYTSOsHEZszabjiGV0n3eXjLw4INlh1twv7erVn056NZA2N4Ma8VQScLKUq2IHcKfVwPRNHVeMqTubVJWy5GQBJVgEWTyfE0+7UWz4NsaSMe71iyN7ihPG0Kza5QOoEkcX9j7DQ8zpGFxlbE67Sr1oHlp7vT9BtgYBt7/F6asVRYsSlbxaCDVw35ZDaxw5LgDtx8zxQScxEf5GDyUFC/f3vMTWOYtu19mR3sHF7XWNqj3tDXLoPI+v2xOOtkaDNHxju/ZCumneoikUK+mnIHWtk9+TeaIvsqO+dSfOXw8iLtTGgwXNMEd40a/mBL8NbkLCoBhY1SDwNTNxxEu8LRnS+ApVRFtzGa/E+moCiArzHpLKxc3fq+GVTp24KI2OHo/kgZ9uatXTftpCKtYH0DG1O9Ig4rrSNQJFXiU0r50JOdUw/VuC5Wc3cC6e5crIRw/ZdZPncHUTNf8WKH4fhObIAx3QbimIpKxu3ZceBjVzWRlNW30RJ7xrkdw/FMVHChGcjiH5ow0eqYk3EUaxOalau3sK2bT2xT5DDUycc021sX9CPMV/N4+ONEKK+fsf9w/VYePAg64tasSftDj5HlCSP9sLvVgVWFw2be/RA6yuh+tnpKNIK2dWjE8j+fAeeleQGgMkoZ8T5KXR5P4TJ8cP4/toR5i+fzImau7H1LcHpph0MMCHqZUicnTBe9EDx3B65xMq5VWt5lBXMD+9uMn7kRVJ/C8BHVYHPTQnR5wup/diE5n0hB8oacr3ublKH+TAu9AEei6QoapdhPuLJ4eY7yO4biDjdAZkeAg+lYXIR8ZtVxc6fejG69R12fb+G+v3fIS8XiH5oo2y7EsHOgsFTTadXY+g26j4eB+2IWleFpFRO6td1KZmrI3F/FJ2/nsvHxXWx7PaivFBDYl8fljzoRWZvG4rlrix834/1awZgl1bGmLCHiDddyNQ5k2mx55fap6jfMoHybCecJXp8LsgJW2/l23n76NDkDTeqfNEHmHnS0I7C+pDfSMneVrs40fhXPH9W4vRehvQrF3INTuSPqUO20YXUQb7sP9qOirYVtF97l+DvLSiS8xk3ay5e13JQuOv5MuIiT6rCiPvFD8tIOQFOZcQ9D8Ya6MnCSUdImxTJ7NnHPiUJujyJ9Pl1sKhFLKKEzg1fU9DWjM4Xnv5Rg4/bg3md50v6pWCcDziAwYioq0Jx2xEUCnz6JfDVgkmolGaEN0nEzXFG+UiDS6Ieh2wLP53qhynBCVOL6iRtakjZHC197AsIWCpS1TKK0qY+yJuVUNsjm6PRvxPSNo2fGpxC8fwjv+3tQlFde1InhiNxMTEk+BnZbe25PnglmnlKnG+psaltjH0+mpJYHTnNlcycPZNNxa3+tH7/NUQRrKLwDyn/0/i/OveJotj2331+KwhCF+AE0OyfKdhnPvOZz3zmM5/56/xdoVQFQVCLoqj/J8jzN7HzDBAjd4+mNM8B71syEMCsFmg95TF+ylJ2HupMVYiZe53W0u/rBfRZeA2VYOHX37swatBVtj2MxeeGFJcbKVgDvEjv7oBLosjExSfZsrwvhc0s+F6XUh4iQa4DvSeM6nWdpvZJfD9lHOp32cy4c51vlo+jpLaVjZ32cbakLukTgiExFVOL6pREK6hoaECtMeK3UkZBA3t0/iJeT0SubdhEvUej0efZc7n7Gka8H83q6KOcLGvApRONURdC0IhkPpa44TehiLJ9jgwOfMba612QuBixf6bG/1weyWO8MfsZ2d/qN36s1RIxIpCtf2xn6JcLEGwicp2NikAZVV5wfvRKVIJIh98W0rjLO14crYHflWKGnbjGwcY1iV8TjmgVkOqk2KdLqIyyoEmW4Zhuwy7PSGovFaKPgeDfJHwcIsU3sBjNUg2yEh1xs9ywT5fid7MSk7OStMEwrN5jXvSP4MMXbgSfgMJ6cjr1f8zJZ/VpW/sD74t9KMh3QpmhwC4P5DqRrxfvY+bNoYxrfI8jH+tRleGAY7KEspoWBKOEYz020v/aVI6338LoLbPwu62l6Fsj5utumJtXYrMJBGyWoUjOI2F+EE6JAoIVti7awM7CVlx+XZ2YufHg70NpPTdcXhST84sUy2MXto7fiq9My+Th06m25j3zPG+wraQ5l3Y0x6wBbZiFaos+krzFH/eTaqzKT6P88jABj5dWJiw/ycHqwdR6av3TiRTq1VaKsjo/I7GI5MXaWBp7ivVrBqCoFKkaVMa31c6TbnLnwsw2ZLRXYgvQs7bJUbZ160LHk8/ZndwE1QlnimrDyA632X+lNYt7HGegJpfWr4dQ9sIDSXQlT5r8Rq2r05ja8BYnfu5AaS8dXcI+4KmoZOfVtoSe1CN9kYjE15sGJxI5mlSXCTH3uTilNSYXBb9tWMOMAZOR5pVSsUOB49ByqpqEUR4sQ1UqktfRhCxXiXudAqpMcvy+sFDY1B33pyVkt3dDG2rDPkPC0RmreKQP4VFFGG/W1sIhTU/SeAWRWw18efQg485OJHKfFiw2KiMcGfr9eQ4s605+ZyPR3xYi2qkRP6ZRcSYAu5+dkOrNJI6wx/cO5Pc14HTDDr0nXJm8goltRhL3tSsOrxW4fTAxb8tBEow+XM6vhmyCnNRhPng9t+C+KJXEExHY54tY5aDQiqgKjeQ2U6PJEdH5CPhdr8RpXS6NXVJI0Xtw42x9Hk1YQ++4QXwdep4pRyeiKIeANc/QnfMjO9+FAO8SCu740qn3E57/UB/79Er0fhpMDhJy21mp9nMRokpOjQPJXDzcBP3/j72/CpPjzNK14TsikjmzmLlKzMySLbJMMki2ZRnb2G7bbWgzu+02M7NbZpRlSbbQYmYoFTNnJXNmRHwHNXP938nM/na7Z8/uf3RfV55UVkVlRa2IN961nvWsEVGq7u8j71svdY8N5eLn1vLayVnYjDHc9Wk8uuA7Pr90HoEKK1Pv3UtNIJNyax8bVkwkb72H6lut5BZ48P+WhTDRj7TFjsGjsuzeNZxjOcEK33g+PDCVwu9Ern3hB/7+h7NJmjUYtp4gMXUI7mE6HA0pHnv5fZ6bvgA1HOFX7/v/JfXl9MHp6qJPzvunHOvTiR+eroH/r/jvWLwBJGeS+G4Xc0eeJJwtEMoTsC3p4Idd4/jqufmYuqHikxQLX/4LYlLl54fnsNh6DPMkN1tnF/H0zO+I20Us3yk88c1HmLvglb++xsd3n4d7ooyQFDnzvu0sXroN34gkxT8GWd89iL82LaJjhpblm3dzy6qrMfYrDLr3JH/auJz9749C1Us0fFTJHW99hqVDpurpEK6/WwgVGdFEoezRw1z71x8Y9vmfSDRasTRJXHNqOa7L3Vz17c1s+nAikaIUzqVtxC7R8MfKLRi+E3BcH+frtrHYi3xUPeDG6FGJFzgZNbOWZaP28mLHfJruHkH9pXZuqpqLLiiTflMz5qNdaCIqk+cd59ZZy7j4+FX8cu2zbNk/GPuCLhSDjlPRXP5+fA0XjT6IsVXLysUvkXkohuughs9ueRH9DZ1ofFE+v/A15IiG0mdOsXD0UfQvuVCe9PDCuk/JL+8lOjzKA1+uoGWRhgPzXuPg2YUERmRQ9U6M/mFa7I0Ko8ytXDtpG80PDKLK2cu8oScpfaMO56k4k2/bx9vz5pJf2M/KV2czs6AeXV6YUKGKuVkDOoWHZ13E4FdDXPzzLaTMEHsyQPrjOpI2eG7Ut4iiSv3lEjXPZjFzyjGyv61l+DXHueLTW6l9cAi3T9nA2yfW0viYAUFR6Z2RjqoKjDy7msevuZrPfONJmTXUz7dyQ9VcCvX9PPbnT3jvxtc4eNYr4LSTSkj87el3cB304J4Xo/T1Wpx/buGLC2YTWziaE/Ncvzu+oyqkrWug79wYecVunj05D8+Ugf7bH0e/x9+euZzXt85F64lS8V4n949by/fusVz202bWLRpBLKGl4Pp6Fsw8yG93TUHIj/DI+gtYPHwuvv0ZZIzv5uKKQ5x1y618PusdToRyiWQInFlaw57eYrb3l/HKuR+jrW6j8aMK8j7voTaUxaDMXr5uGUvDNSLmLTVccf9dNN0pUvJ9H4+W/0TfuZXc8vKXZBwM0zcKbIf0SAlwH84k9yGofcSMwadw7Q9rB4aHtIjYWhQufuMuvjl/Bi1hJ8F8kYs+XE9mjo/6yyxc9/0NFK5TSDwT4PVV73HOoxtZ8cQihCt6se820HhNAR3z0wlcMIauxnSufe9HVI1ERmk/MZeIVivjG6SSGhHm7Gf/ApLI4Ac6CJUqzHl+Bw+ePI/vHp/HTQW/gVbDny/9EfX2XrpeKSP9eAJjb5K0g170niTXv/8DSSv0jVVZ/cdnEetaOdadw/rLJuFPGomVxhmz5SY8q/N4ceZ8Llq4gyWX/cbSoy3wViam4wauLdxBYlCUpa49vPHyK/iG2rnxxW+JpokICREEgYbL0nFqwsgTggwt6KLm9gI6zjHTskTmu9vmE+8z0ddrRxMWmWlsQkjKwED6Ofx4HpvaK8hb1w+tXeRukJiQ0ULKDG+O/JxAhYwqwKtHZnPz2dfxyfFJ5K7R0D9UwxPfX0z9H0SMLX4+qVnPtx+9xmXXrqfn8hgvtM6n6/xifF+k/+74/o/493Gip9vI/vf51xpmos9SHz08ktfWz6fgFxm9O4b3sRh9vXYc+3UMvfwkBzvzEQ7YsLSpWFti6Go66FtUht6n4C+VkGIQnRHCuNXCr/c8x/KLb2bQ69X8tmIcf7npK57+ZClJC5Q+eRhBpyMxtgznY628UfQjm6IFfHLJQsQeLxPXNvPT67N4+p73OBYr4PXdZzB7WDV7vxtB+okUpho356zaS1fCwd+3T0XrlxATkL85RvwBL7yZSdm91ez+dRgFG6I03giujQYCxQIlfzvM0yc3YxVTnEqkE1O1PLTickbPryZTH6R2WQkAnWdmoFvYR1+vnZxfNTh2d6EGAjxzcC0X7LyJnK91dC1JYDxoJG+jjyd/+ASHmODSR+5CvNhN2s0Jxq1sYPcNY/nLZ5/x8P1/YPq9uzk620FkWiWfvvkis1bfie2URCR7QH8QGRoj7wct4WyJzE8Oc8vRQ/xp43J0PRrOP2cnXx8Zi3OPHnO3jHhzD8bzehm9M8xXWyfz03kvceu1f8J9S4Rgv5nBT7mR0600n2NBTIAqgayDnF0pui6Lk3IbWH/ui7zeN5PDD4+ha7KGnF0pwlkS/vkRnNYIZ+cf57vmkQxK62Omq4bzLTXM3HkzqgqOdSY+euRFzvnlNjJ2SVz+lzV8f/d8TLsbcP0sc7g7D3WPnYL5LQi3WpGtBhr+KJCf6cV4Xi99y0YhKGDwKdi2N5IqzaH5HDML5u1nofMIr46fQmBOFZ+8+ALzv7+Tptt+37hFfWm+Oid4NnJJLg1LLCg5cc4dcpTbMn7jrPf/QrwixtZZr3LJySsotnnwXJ1BcLAL621tdPxQjN6vormkl67mNJxHNGTu8eMfZMN+KoB7jB3v7IEhNm95JrK5p4LHy1dyT/WFpF/h4f59G1i++XouGbuXtR9MJVSgYq7y8ePo9/jjlKVUruzhl1UTKNgQ4dMv3mBJ9eV4N+QQLpYZ/KqHP63+ib6Ujc+WLeCSFevYHypm9cGRVJZ30nigAE1EoPTtRizfpKjpz2BoRjcpRSJ4g4s5Xx3kjV2zWTjqGDs6Sslb3kbWeoHuPxaSsupovl5FjkvY00LMLajlh/UT+fiiN7nvzhv54bWXmPPiXURyVcrHthJ7Pg9NOMWN733Le5efj3ewGWGJm552Jzq3hqRVwdog4qpLobmjC+2tRp5Y/RkFUoKrhixAGVJC7Y06CGmw1Ytcet163jkwA5sjgv57B30zUrw2cwWbAkP4Yd9YDix6BQmBJedfhxiOU39VGjqvgL1JwdibpHuSnqQF3rzkXf7y/PV4xibRurWYuiDv60aSZdlIT/SxIPMk3z0wD+spDyO/rOWHH6eS/1uMK95ZxZtPXISlPU6wUE9KLxCaF8Kww0JgeJKd817m4pPLybf4eTz/J87+7G7Sjyr0jBcYPbGe14p+ZPLaPzPkvgY6L63CWZtA0Yn89ParzLvvz1hb42h8MbpnOlhy3UZ+7hjGmTk17LluNC2LrNx88Wpe2ncmVS9HWXfw8f+S3W3a4Az1rI//OTvwFZM+OL0D/7+VWLaWFc3jEWMiLYsFyt+uxfGECalPi9GtsGfLEBaUVHPdsrWoEujqu2l6IwtLe5KYS0JKwPgrjlB2f4jiJQ3MfelupOpmaq8rx+BVee2vSzjr4t2Uv9FM1/WjkH40UvDXOsLnptgZy+KZU/O4+esfeWj7Kn54dxb33PU5L42ZwvePzuOuyb9wyptF4ZetCCkVwhGe/+Uc6sMZ/HbOCzhqVHK3J4hm6Bji6CGaLnF/zloyDsvc9tGX/DD1LfzzI/z10hVQUczdV97EsuNX8WjNOdy96RIULcxy1tAedXLzzz8TKXFw3c2rSLtPQ+4aDY59PQz/oYWOD3O46pk7eHPiCixbayl+V2DDbc9Rt9zO1a/dxoUv3M1DD3xKKKYjMjSLlR/NQDrVwj3PXk84R2RV4zDm72jBPULDrJV3cd2038jd4Kbi5XpM3So7Zr9GOFvC6FZQRlTw/C2XM3FYA0vP24ooqJR9qOAdojDovuP0/ZZLw8Oj+OnLqej7RP4ybzm6B7qwfGFDY04gp1upv9TEnRf+SKw0gbVFxdYE5q21KB0mtAGJl3rnsPvF8fSN0JC9O0Xpwye5+94vGFfQiusvIh/um0b2QyK5Rh8vHjmDFf6RqM0myq9rxN4Y56mOs8gu9CBf5OGHjlFE0yRmb2mh5dkq3h65gtTYENxhZ/HXW2m5XeGZCd8hPp9B542jyNzjxVEfQ0ypVD9ezNKPfqX8/U4uT9vJq2Mm0fFhDrZfT/CmewYF63+/lapWk6LhtirGvH+UiqeqQYUD/QXM2Xg788/bS9VTIW5puhDbrSK356ynZEUrH7z8IsptDtbd9RzO4yF63DY2nfUi6YfCdD8q0zUnRc0NZnRBBcWvY/5LdzPM2E7P/hzu+tuNpN0l8O7hlVz9zc2UrlD4Yt8EotNDyOlJhmZ0U5d0UnNnISduH048S0bRS1w79ypMD1qIpatIEZGhXzTw8tIlfDFuEHXLzUwyNtF4TSlV70aJv5hL1l4VbRBOPZtL6EIRYYOT89MPUf1DJcu+38hPncNJ361l54oxxBManL9q6LqtmK6HZUa8eAT9MSOlK1T8fVaWO3eyfMEWHr7+Oq56eiVLr/wTy69Zh5AUiL6Qx4q3X2TKK3v5sGMatcuNuI4GWFJ0gOwtEuljehj8uptXbn2btjkSJVYPp25ycttdf6IlpWfUtgBSt5fCfDdrzn2R0IQoH66cS+UbCdQtTp56+D1umbSRA5ES9j0+DlOzhmVzr2TO4Svpmm6l+g47ig6Kvu7EsasdRScSLkmh88Nzl17Ku/e8wq75L3P1oo3IBsBuRX7UwxkZNfx882y6J0rc+PMaKg3dFP4SRtsf4ZmPL0aRoPkGBfcYFc/kBH8f9yHBUoWSL1QW33cXnq3Z7Kkt4bmeeZwx9yB/e+odKj71c6C+iClr/owtM0T/3108/+d3KXq8lrhdYsmF12Pwylie6ODyr3+l8MJG1j40C5chwjhzE2PePUrJiyc4EcqDqITY2vP7b+D/CadV6P8Y/3UO9ac5zWlOc5rT/C/4dye20/zv8y+VQtcX56uly+9ETIHeCxmXtuBeUcQf7/6OX/uHcWRdFeYOuPzPa9GLSd5+51wyzmmjfVsBBRuj+O8NEYwaEEUFw692UkYYfHENfQ8XM/XFPWy9fwoVj5yg47Isqh9ysnzUHv6+fzLlHyXpGW/COLeP1wZ/wZINN6F1a7n0rK3sWzYUxaSj4SILFEQpzXLzh/ztPP7BZdx7zVc8/OvFA21oi1bwyp8uJfPBJmo96eTeHuOStTt4/KeL0HsEVAmcpxQ8Q0XyN0UJ5+lxjxBRBZg86wTHPx1KygATLz3ClqZyrhqym2/ePoPH/vwJf609i/iaDD666yV2Rsp59dtz+PKKl7ijbgnxD3Lomq1gbtAQd0HFBz10n5GFZ0yKjN0SGdt66ZmdhcGjEMoTMXcrOLa1MHJNJ2dYT3DD7uVUPRpA1Um0nZWOqoGir7vonZ1DxvfVCA471/y6iTyNlz+89yfsDQqBQpGMo0nue/NjXjr/QpoXu5ANoB3kx6xP4HjSxItfvs2X3gl889N0svanGP7wEWruGkrDRVpMuSGMawb+P3qfimt/P5O+Os76x2bgurWZ7g9LiC32k/eQwp0/fktE1fPibcvwVA4MbbC0Q8oIBZ/UIpfm4qsy4y8TGHVmDYHFItVPlGBIixIL68hbqUG6qYexaW2curgQojE8s4sJZwu88ce3uPntm8ie30bg03zG3nIIf9JIzUeDyVrWTLo+zJ71Q9F7ITgoRcv1f/ld6TtbVZZafNa9vHbbWzx023VEXRLmyzvpDVr4auz7XPbyneRuDdB4oQ3ZqHL/wh94ctfZZK/TcMY9O7gxbRdz3/8Lxl6QF3hJe81M6M9+0v4i0D8ujfTt3eALUP1CCSUroOl8ifQDIu7pSWxpYcJhA3kZXkJxPfyUxrg/HKZteS6KxYAYiJK9oofz0w7x4BtXknYyiaEziOAJ4JtWSPcUyN4J/RdGyP67ge7xGgQVcnYmab5EZfBjfbS/bEYQVG6t2sxm7yCuytzOXa9cj7lLwX1xhGSXie/Oe4UHJp9H42sZmDZaiTuh6LM2qu/JRUgJqFoVQ0aEWEgPQQ2aiICjZkBUWPaVF9mso/5SI/ZTIr7xCXLXaFA04BkskihMILm1yGYFU+uAd30sUwV1wAvCNKEfj9uKpkuHVBHkjqEbeeXv55O3Kcx5H25ivLGJN3vmcOTvw8j+opquj7OwfGxHSqq4h2pYfvl6fls2nror7dy2YA3vfbCIwYtraQs6CGzNxNKh4jweYOQHJzh2cSloJAo+7aDtPBu3b9/IDb9cg+RMUPCJhqyHGzm4pQopDnGXwubFz/N1YBRJVaI7bufAM2MQkyrdEyVSNpn75qziSLiATF2QjQ9Oo3eshoL1EfxlRnqnpyj/NEXLQiOiDGWv1fPXPat4oHkxym0O6u7W88j4nxmlb2Pph3eQ91uUOW/sJCgbOHJuAQ3XFZJwyrT88fcZFf1HuAZnqPM/WvxPOdaXk987nUL/vxVDZ3JAHT4iiphUqWnK4S/3fM7eYAmB5VbSpnQTnB/ijZ8W8uyeBYQnRNHcbePTK1/FV2HA7bEyPq8VYbed2+74hlg67DlWxjMfvM2m7kpiTol7steRyHOwZMQBvlg7g0EvBai7SouzPkVvq5Or372VIRUdVLzfxVF/Hud+s4OOWVaGTWpEajChuUHPM89dRv46Hyei+eRW9SIkBe7ctQTLve3sPVlKscOLYjfxRsMsKt/p4a4rv+Pta94i5hRZftFGOqcbSS3v57yFu0nlxOm8rwxrewrnWZ1saSpnSlETK5+dg5iCl5rOpLfXRnBylDtuuIVVy6ZT9nod9y9cTpHVy5n3bSdtrwZXjUzKrFBzcybZP9TjPKwhY6eba9asZ+S1Rxl770Gs7QpdM1Wwmjniy+PFOQupejxI9b0uQi8lCRfJpEzQ8tzApKeeJYNxz8jhzZZZXP79LchjgthP+jC6VVqvSHHv89fhG+7k3MU7mTvvABGfkdSqDLJfbOa6e//MZwcmkbsjib9Uw6l7htFyowyWFNJWO3HHwNhMf7nA4M8a2HN2KV2L4yzOOkRssZ9oTEvb4xJ/PHgZry+/CMvdbegC8MLFn5B2LMoPtz6HmpWG5AnjPOIn45DMldnbeXbfT2RvkdD/ZmXww72Muf8Qnl9zuSZtO4rFSPXDBUy6Yx+aGPx1yeXkbQkx1tVGNF3g1IPD2f/bYIZec4LarkzOdJ1k+Jw6brhuFem7f/8wE5c2TLBU4eZ3biKYpyHtgIeeLXnkPafhz8tuIuNwnIK3mjAP96DzCXw3ZzQ3vwW2IwABAABJREFUj/+NnJsb2X/NCKb/fCeKFqIZ8Mbwz9H64mj+nkbdlWlkX9PEqUedWFYKCKKCt0rHOws/RO9XmFjVRJ7dz5jCNtqP5RDbnoZsgB3fjmL5qk08/d0H1DxiY8uO4bxxyQUIs7y8997L1C13Eh2ai6wXKB/ezpz7dqDWWeicJpGyqqQdU9D3Rchdo6HrNSPZtgABr4knd57NrsYSWpLpBCdGsbQMDEup/DDA2uAI1Awnn479iLnX70SKArE4Ve8FwZEAQWVyQRODng/y1PyvSdllpDiUv9VCw1InHTPN6HLDBMpVcldrCGeJ9A8TSRQkGPRCCEOfgC4tyvyL92BtU6l8tx+yYpg7Ic/qBxWmzzlK+hdmnt51FkVfdzP6rSN81jqBm04so9aXwYd3v0TGaoWPRnzC9U9/T8dMCeN0N9+8Mpea66xkDenlpc0LCBcqVP9QSSCqRxsEXUAhlmViqKmD1guzWfT9bnINPjAZeXnOAmz5AeS4RMZDTbSH7MgGlYRTQYoJzN97Ez89eAZ7vcU0htJwL4lQdE8N5qEeyr5K8OpH5zPO0kx33Eb7GSJnLDqA9elOzF1JBI2KopeoeLuN0bNrSH2h4/Zb/kSLx0nDZXaenLCSLxdO5YqjV1HyTj09440ssR9k3+1jOXVXPgwKUf5V4nfH93/G6XGi/xj/7X+xIAiSIAiHBEH4+X/1vbFcLf6hSYbmd/HuIy/z4vQvefDQebSc56T9RRPR77OhxkLJyjBVr0a5cPAhkFWWr7iVomvqeXbSt1S/O4S/Xf8Rrz99EQmHTOYOiQebzicpSySNArcsvoFz39rIIW8+eVuS+Ic6KflaxXhHB4Mfa6Xo40aiT+Vy86+/ELs9HasYpXRRI/Gb7EydexTv+EzC84PMXbGbnxqH0XM4i7xRXQx6wk/vx8VI5iSJy7WI3R4qnH38dcMXrPjj2RyOFRIqhIP+QqoW1hNPaVj97SQGP9hN0qJBiinwaiam7Wa2VFcy+fZ9RDLBFzPy2rTPcTrCRDM01NxmRPxaw6m7bYyxtfDp3slkbuzA3OjH2iRibhWofryYc27YimdcOu9dfj6XpO/hyKOjsB3pRbAk6Z+YQXVzLp3nFhCqclH1apiO6ixUvcJNF6xF3GEnsjDAjbf9iL9MICFrKP8qxJMjV9J2lgujR6Hy6QjZq1qIZAgssB9lY3Mlzn06zr5pK9XvDsFfJmJ0RIlkabj6urVMeGE/RW9JIICig3CBgrMmhs4Pp5YUcfLhHO4Z+ytvNMwkWmNnYXk1kZCeXIefuiv11P9Wgneoyt8eXI7WF2PZg3dRfbsN99RMRG8A8Y893HPsQu5vXow2rDBm+VHaX7Gy6vhwEg5Y+vadPL3yI14843NW7huDuUum8WILUpeHr4+MHfhM2RpcJ1ROvTOEiqfj/P3aRXS+VsZnjy/CPeb3Z7K6Ak4Gvd4HCqQW+AgMcpK/MUzXFDOddyRp/oNC+zX5zMyt55OrXiU6LI/v/3om1RvKGf3hccSISMl3Pox9oCDSNt9KSi/w49IXSV2pR5VFZqedovBzCeksN+93zcRXJpFQJOp2FdPzt1IyDkLhag+5P3eSVp3iyQ8v4crDVzO9vIHKj33U3qxHq5GZu/E2yr4NMfypoyRNAp2/FPL51qlQHkbvEVCMMhc8tg7/IBvh5T6UjS4ajuZT9VKUwaWd3DVmPe8/dj66U0YGv1XNhHF1RJ+PkK4JMv+L3Vz645+Ybq0hWJWi8z0XtVfZKMrpp/QbmePuHFRJ4m/V81k2aReRi/0kSzIRU5Cww/tjPsXUIdB5dhJ7cwopAaY6HdE8K/nrfNw74le2vzIBy9XtTPnqGM9M+I6H7/2EvxSsxXJcR50/g4RFYHhZOzN+PMZc23F6TmSi+8wJH2ew9PM/s+3wIC74+VYe2XQB+ZtlNF+kkTKBqVMi8nMWliaJi2fs5tM/vYTTHCXjcISXXn6dpFnizScuIpqj8NLqs/msejyLVu2nZVkB1k9sOPbr2FdTwtycUziqBXK3qBi7BRRZJJgvEb07C+UKCemwhTyDj2eHfse5b2/itRvf5rGt55GmDTNhXB3HvTmMc7RgaAvwyrQvSBlFWi4tYKi1E81V0HNVlILHVJzD3Dx65Gx6X9MRqnFyzfbdXHvNWub9eCeewQbOnnIQ/Q4L3RONvzu+/0P+SQr0/4lp+P8bauC3AdWA7b/7g5zmNKc5zWn+z6LC/0gB2j+D/9YduCAI+cAi4P3/L98vaQesPaMPZLPswLVIgkr5/QEKfvTz4JA1pAww+czjiIkUl3/xCxvemsJt33+Hzg/9URMPf3w5t937NS/cvAxUWD59B3GHgHilQDCq56X73uL+bz5j1fWzubVwI23LUhTeWkcoT0s8paHzwlJu3rYF50OtvHrFUqK5Zl54dSndH5Ug201srq4i68ZG7h/+C+9/uYDCRxUMfQK3F2/APzKDUJ7AeYOPovl7Cv+0Ytofq+CBOUvRt/sZb2zkjcve5fbcddR/X07m8wZcpxQ637Ty11ffQdGJ3PnSZ4y47AS6Dh37nxrH0Pl15Pwpyl8fuhKPx4KlPc6gZ4JMdDVTVtTDS3vPpOr9OKkPZc79ejs5W4NY5vfw+by3WP36DJwH+mleZOGFpZfQPVFD54JsBLeehEVA06Vj7jW7SVokZKuOB+b/yJDnvay5dgYZC9uJeIy88sn5MCiE+l4mjRdaeLL6LMQExK73cOl3m4h+pCE5I8A91RdS+kCU6BlBNnRV4TkzRtFPXi4oO0LveJUf7zqTM6wnaFlo4M1pK4jkKRSuU2g6T48w00vTsmwyt2n44OnzGOTqxT6sn0NPjmbQYz6Mf9LhOqTB4IHCX5IECkQaHtCh98kMebwL1xE/F6/bR/zjHHKe1nBL/kZ0vgGr22i1g4IfNBStiZBwqNxx/R/5wT0WMSbSPVkkb6tM9RNZGOv1pEygubSX5594E2lpH/1jHHROM9EzSYCr+hj8Uvfvvh5Mpjixt5Kcecle8m8Po/6hj+azzUhxKHxExnTISPfTAtu6ynj4wisJFuoQ1IEa6ZELSij+OcEFn/9G4aUNXLn+Okw9IF/sYV+0GO9bWgp+kFh1zgRuePU7HM9a6H+oiPwNPiK3Z2LuBPPJXuJ2AeG1AIlCF0mTSNE3XWjXOjg77TAt5zgxNugwaFLk5/Ujm7Rs+mYcxn6FzHntmNpEbOvNRIbFGPxUJ/WRTDyLw2RbgygaKP0uTvcMB70rinn3tXNxHPNSsD5Me9TJqS+q8EcNvPfceXQl7JT8GOe1Sy5i8HN9iGtd5G6Fx8p+wn9HEMvLdi77ej3ydicr9k3i4aE/0zfaSPH3PswdsC44HEeDzMOTfsY9bGCP4jwlE83QkLIZeP7kmRReV0/89VyK9G6CspGv+8azK1LB0AtqKLF6uOG+H2joT2PFp3N54dwLKPs2gt4n0z0Z7lr8I7kbBQY/28FtM9ahCSbR+2RMfSpjzzlB+SV1ZC1sY1XjMO5deh2hn7NRRYEHL7waKaniKxdIq+incHQHyZiGVZdO57blPxK71kuoUOW1mSvYc04Zj93zEd5yiZwdQXS6FPqAStylp2d+IbnbovzSOpiHH/4DL+6Yxw+ecRR/r7Ktr4xAUs+NRVv5qnEMqTQTRyKFpG7uR++DHVePpWdhIcVPq/j/liC0MwPNQQuZN0exVHm5d+UyVjSPZ9Czbcg62PPqWIIjEsTHh393fJ/mn89/dwr9ZeAvwH/YgyMIwvWCIOwXBGG/Ggxxjv0Q0hN9qKrAfR9cSfbnfZx6fBjVsVxuvPEnjn00jM4ZdlZ0TiL9YJDX5i8iY0E7txZvREzB0x8vpfLJkwhL3fx9x1RyNrjpPLeQRaUnuaP6Ym74+Cbq/yAhCQrOzUbKzb0sv3sN0zMbCBeo3Pn51QQezAdFJePeJp664wMqb6hG8kbQt+hp/7SM2mg2rmoFIZogVCZz18/LsR/qQe+DoaYObsnfiGewSNcULZXftNM7PZP3emfy/JJLeLLlbIIjE7TON9JxTgrNTy6u+/iP9A3X0JZwsXPbEHJ2pZD/4OZkTxa9b+hxHPVw2fB9SJEk+Z90sPEv0zg35ygvTv0K2aCh98dCXvn6XOZ9soOuDheX/XYDj9zzCeb3vEydfxTzSz1owpB/URP3LFyJFAdVo7LpzUn8+dEvqLtKy/uPL6b6Xgc81c/C7JMsHHWMogXNGHZY6J4GS+dvx6hN8ecbviOwL4PqaC7dW/O4dtBOlhYf4PwfdxKPatG+nobi0+Ed7qDS2M3gV/tQdCK3v309ilblyXuvxnlcZPbT25k8uZrYMSeWVpXweQGCBQLHvhxCdEc6faMl3FOzqL7HTqBU5dxrt9J8CURzVZyrTfQsj3Hxun30THbwQctUvFUCCz/cxrPNC2harKP70nSkOPSMk+iaYmLyjJN4B+k49O1QXj/nI2SjQsvFMlpDirhLpeRbHxZdnD7ZivkZG+lXtZC7PULJDzHcB7Pon5rzD10A/+/4Tvoj8Ewmw83t1N2YR3dNBlIcQoUq9Zc7ufTKjTw15Ad8dS7EYAznqQhxq4i9RmTM9w30/znMcz+ez+HaQgY/30/51TX0d9r5onM84zNaufKZlaCR2BMsJVCsJ+HQUHuVjdrbdIxffoQFPx/ivts+p8Nvp2+kgUCxyI2/rsMzMcG9PywjWpBCHOdHej2dnn05NFysJe3MTnJua6CxMZu3b3qDp+57j/K8XlS7hVMPDkc4aaE7aCU2LkzbbSlyf+nBURcjOD1Cz7Q0+h6IMy/tBOnHY7hMEaytSYoNbrSeCA1LLDRdnkPl5TXobupkc2gwkZ3pqAI8sutcpGleDJ1a7t54CZoINN6vxdYmM9lSR/Q6L03xDGZceBCtf+Bcuw57ueLdVbw08mtiKQ2BIomPWqfw+J6zOf75ED78Zh7z045j1sR586ULiPiMPPyHz2l+TI8UiNJ9bYxXF33C0xvORby+h1N35vN12xjER/uIZEhMvHMfOQY/WYYAZ2adIvstAymLlrgDGpboqLnOxNXP/Ejpl324HtSik2RemfolnXMcfH/JLDL+AvZagUeevZp4eSbP3rGcaLZKNNtIqM9Mzh8aCedoeOm+t+i8LclZRSdZeM8Wqt6Ps//5MTRfBFnGEJfl7OHTC+byxNCfSD3i5cvPZ9O/L4vY3AAoCuZumRkf7yP4WyZ/vepTNFFoeN6JutGFbFKIxHQMX9WBqU/F4JVZPOoQydDvn3f/n3E6hf6P8d+mQhcE4WzgLFVVbxYEYRZwl6qqZ/9nP1My3KJe9tk8Nj4zlb6xAsWr4igPubmucDu1sWw+3j8FTa+OkpVhOmabMfaCoz6G48k2PDEjobge27NW7vzwM/5av4jwT9nMvnYPP22cgKYkhHrKiqxXST8CveNVVINCdqGHxypX0i9beWDtEtIPCky7bS8rt0zAVifgrE2Q+VgTnrvyabxVwHDQRHJ8COuvFlzLWrk0dx+r3SM4cLiUQW/7yP+wnaa7Kmm8UM/ZUw9Se30FKZuezj8lSLOG0UspGjszmFt1itqHhqLvi/z7CaNzho3s3QM1UU0Msje5OXWPDetRHVn7osgGiaYLRQrWCmgiMh3TdcxYcISOK3LxvaxQ6ehj654haAMiidwkqgolRb2cl3uUTe4qis0e9rw6Fvf8GPlfanEP1xApSzLoRT+BwS6SZoG4QyBYpnD1rC18WT8GaZudnG1Bav+kY3plPXvai3B9b8J5QystvxRTuNJNz8x0rB0pOqdoSDlT5JW46arORBXg/On7KDP08vzGRQwe3kowocfyZy1NS9K5Z+l3vPDBhWTvi2F4tAvv60XIegF/uUA0L8X903/mu+VnIMgynhF2pCR0z0tS8hlc9fpKPrr1fDpmaJkw5yS7dwwm7ShEMgbGxPoHyxT+ohJzSjzw8Kes9Q7n1IPDSd3pJs0QwftcEVJUYeLz+9j83BR8FQKakX4iIT2SVsa51kQkWyCaOVCjlCcGqbnwkd+lgDWU56nP/DyYl9cv5MIZe/lp1SSMvTD1qgOsPjyCIc/7SP+olyO9uQS6rWTke7mvci3f9I1n58lySr9UEe/rwf1jAXq/iuugh5p7zBRl92P4s4HWxzUYfrEz/JrjbDlZicEWx7jRitGtkLAKoEJgYZjhuV0c31BB9r4U0T96cXssVOX30LyhmEuXbKY15qL9mnxGrTjFV1snI6QErp27CbsU4ccbzqT5LCNXLNrMmr/Nwj1CYN6ZB7BIcbb1lNHVnMaDs37iiW3nMG1Y3b/deEUqLT1UGrr4vncsN+Zu5sYdy7EeMJB+PM5Fr//KN39agOnBDno/KgbAO0jg/sXf0RDLxKKJ0Rlzcvy+EVT89SRxRUPbfRUMfe4Yx+8bQaBQh2FJN55t2cgGGDqznuhNTpBVFKseISnT94RMLKFBv86OooFwPggKZBxU6DwrRdoOHdZLOmg9mou+OMi84lOs3DkOS7NI2qkU3goNeat76FyQRfHFDbQFHIjfu/DNiyBKKrrdFlQJBp1bxwxXLSv/eCa63iA11w84+FV94Kf6VgvZv2kIXRjA8p2N3nlxxB49D5/7LbXRbJKqxM7HJhK/zoPwZTqKFvomycwZeZLNp6oYXdpGlbWHHJ2PlzYvQNc/4H0RzRmI9bhNwnXAjXtSOum7+gCovs+O9aiev9zwFe/cexHm1jC2V7rx3ptP9yQT+b96qL3GSeWHXn49+uR/icLbMShTnfn+kn/KsX6a/sZpFfr/IaYC5wqC0Ax8CcwRBGHFf/YDEgoHLh/CnY9/jmxS6B1roOV4Lk98cgktURfp27XYGqBzupn4sCjeWVEUjYjvwQIMmhThbRl0TTZQF8+mf3s2ep/KjpcmYOoU0Oyx8telK1h85h60IQWdT0QKSnQ3prEnXM4XXROoetdD/yg4cdNQtAUhMg6F0fVFKDL1E3k0iFRvQu8DRREI50GRxcsnfz6X5o8rqHovSO29Jk49NYyUWYOxR2RN3RDq79ZS8dxJZhbWY7nLQENdDlZblJO+LBa/tI6mC+wANNwtERkfBRVi6WBrTdF8UTr5P0rkbglg/msnvWN0/GXmGlrPUWidp8U61k3134aRyLQQjuvYVl/GmLENyEaV3F8knp7xHd3b8nh1w3zavyhl8xfjSJoEHhn3M4MeOk7KBBUlXXTOTad3nEj+HxqIpcOgEa1kaf1E260YzuzD/FIPrrQQe9cN5aERq6m4tRrPe0VEqhJM//oIpZfXYeiNsXThNnRuDZqX0jC3iOT9phJXNGzxVLFk2m687xZRYvXQMz0dQYGnDi9g0Hl1uEcY6AjaiWSKXPbAGoy9IEgqX9+0gJ6HkzTdp8HokbE2RdCZErQs0vBj72hueu0bUoUx9rYWkbtNIeYUiOaomLsVMKcwNQewNUapieVQc98wwrf60D3joum7MvT9CZouEvnp66mIy3s569w9xKI68r7XMragHUUrMPPiA5w3ey/m2X0UP5b83ReEWZtg9RUzmDCujnWtVcgGlVGXH+foX0fh2q+lc24GB7vzyXlcQoyKxDZk8Mqtl9L8ahWD3gjTdL5Elb2X625ahfNEkNhLMYwnDHgiJm768Wem5TfhmZKgxOTmmWnfIssizlNxgssCOC9vQ9EJZNhD7K8uJl4cp3uChj63lZkVdbSuLkbnhw8PTqH1T2UgiiiqQO5vKoIMMUXLqydm0zXZiN4D33w8m2i6QPZumYbry9n1yAT0LzqxVWt44+ULGPxqkISsYU9jMf33FrLTXYJNitH9eilP33Qlpe+rWNtkWhbo6Eo46Lk5Sv87Rcy+fRf+coGyb/y89M6FfLFxGt+2jGbbR+MIZ2tZd2woh74YhnK/mxn2U9z85tfcec+X5Fv8OOoVEjlJlmfvZMm3v9E7PR3zCz3EMwfa27QamaQZzD0Kpm4wdYImrqA1Jym+ug7DHUbSD4PJkGDbuxNYMOkwoYoUy1/4idnL9xItceKvkul9o4Q5eXVceMcGbh+xify3tTjrUmhDcHJtBSuePYue8XrS3u+l7Ns4t89dS8s5Tv44aTN941SkLXbuf/RTdE0GdKVBHtm8mB33TGLTa5Mx9sTgm3R6pyjYmhIYXVE2V1dhtUeZ4Gzimw1TWH3FDMSEiH6Ej3GLTmDqkEjpReJ2gYbLM3Ad8lN9SzrTvj2GwZIg/9xmnv5oKeMf2k/jBTb2NxbSeJEBS6dK/xgnt81fQ/9Y5++O79P88/lvW8BVVb1PVdV8VVWLgUuATaqqXv7f9XlOc5rTnOY0/z2cTqH/Y/x318D/t0ipIlWfNPDGLUupei9IZFwU2SyjneDl1EvD8A6GjL0+Ks+pR45JXDFiD+o9fTSfpScQN5C/KUhkUJz9/mKsbSrn3ruJ8AUBIhMi6ANw1+ZL2PbCRHrGS2hCIEUEzhx/nIZIBg2/lCK8EcJZ2Q+qys1DttIzwcwFX/7GdxsmMzKtg8yDMjfc8SOmXWYSjoHSxMSn9pF+0M95X26FPgOm9gi9Y7XkbQpT9rLCsLwu/EkjTTeUkf9+K4WrIeMlI8aHbez2lTL5zONc+eVaLFvNqCpE8oxkjO6hY7pE5uEUbYsUWs6y0fJlGfOW7uG59WdjbNGSs0Ohv9mJt0rCM9TI0tKDCJJK6LYsUMGzNMwLz16C3gfZVX2Ec8HoVvGMTfLOgxdy6olhiEmoO5GP81SSP56zltA9uRSuizI7vZa3Xz2f4iGd9LltdLxbhvM5M8Xf+3jtr0vovK+MhFWg/IMUax+exeG2PJZ8so76cCZJq0L2Q43cdeM3BPMk1hwfxr7aYlZ9OwVLa5TuO0uI5EDCrvLQ6DUoqkCwSMVpjBDNhMPBAvzToswbfoJQvp65BbWUPKOgd8dpuEXEvNnCzXPXUbeynCffvgw1pEWSFLLvbqBgcRPph2DsvQepKOxh2Ke1+O8L405amPfyFjwn0mmdq+fGG39CNkpgULC2qPjCRixSnKzv9XgGSQOGQd0pNjRVsap2GLeXbySeZfnd8R2K6gkXmWl+s5JQvYOy78Ic+mIY7mUR8i9txN6c4oLSI4SKLRSulTF4VHR3d2FpjqLqNAiKwOYfx/L87vmc8/cthBM6orkKl5ft4/bVy9nRUYK+RcexQB4fXHYOs0vq6BmvJ9huJSlLxOb76WjM4KHpqyj8duAayP9Oy66fR2CY5UYThfL3ZbrvT7Lsm3WYpASLn1hPyi4TSBkoelEgd1sY/cx+xBRkL26ha6pI+xl2hj98hLarZIZfchJbS5LGh3TsP1AOPQaSFg1T0pt49PkrSRkFxj1zkBEvH6VjDvxh4QZ+/GgG7LXTOxHaok7iWSka79HgOpXEdRxuKttKfE6AlEEgZ51E3Amhz3P5umcCf1lzGX978xKOrqnCftLPoFdCPPjBFXQlHfgGq/RGLOQ8Uo+yKp1wtRNFB+6RIikjDLq0hqhLIvcjHSIq9ctc+M8L4a1NI2OvD2/CTOlXMq+8fQHrv51A0iJRNriTcI7IyrWT+Pz9ufxw01wiWTraFggEylTyN0dImgRkA+xfN4TW+UZ2esuxNat8/uY87pi3Gntjiufuvpw7lvzImUW1WGs0BIq0eM+M0XCxCf+iMGOHN2J8pJOh2d2YT+gJdls4HsyjdEwbDXdKGPoE7hvyC70xC3lnttJ5dhLf+AQ5O5J4RttJPyhwPJhLLKTH+04hObtjHLlzFI9d/CXnDj1K4dAuuqcq6JcNiDMDJf91i+PpYSb/OP9STmzmjAI144nbMGaFyXrXSOd0LcU/BQmWmjnzvu3suW40jYutKHqV7J0qnkvC6LQpDN856BurImVFcawzYeqTidskDP0pPEO0pC3swP1LHmdctpeV+8dw0YT9tIRdNPjS8LgtnDXsONvayxA3OQiWqFgbBCzndNPjtaI9bmbYglp8d+XRdDuYTXHkLS6SNtB7BkaSqmVhVFWg6F2JUL4Of7nAuHknObRyCIoOxASYelWm/nEfP28ej7nCR6Ddhr1aAhEWXrODHY9MQhXAfFs7nSuL0M11I6LiMkUY7ujih/UTKf0hwsg3j+FLGjn26gh8FQKyHsTSEJcN2s/6R6fjrZKIVCYgIqFNjyHUmXHUqIQWB1AP2JGNUDK1hb6whQqnm7pPq3BWR5Ef8jDE2c2mVWOxTezDFzKS6DOSvwE0YRnj/Z3UdmZh2mckVKxw65m/8tkLCwiUCJi6wbm4neDneeh9ClMf2sMvn0zBsagT5Y0sPFeEEHbZiY6KYjxipPCsZhrdabi+MRNZ5sPyiYOu6ZCxT8DSFqNzupFIUYqsfC+9XQ6yc71o33Jh7Iwy75MdfPPUfIJFAvFhUcx7jajigDObZUofgaiBmNeA85AW7+gkQkok/1doO1vh8nG7ydQF+PDNRaRVx+ker0fvg7k37OTrg+MRAxrGT6hlz9FyDN0SrpMK4eU+ggEjY4vb+Hbq27+r/mZOL1BLP7yGnCclGi+0krNbJpIhoQrgG6pQNKyTlu40yl+TWfjhNn7uHkbbjgKKprWSaQxx4u9DqFpWQ2vQgfROOpHMAXOZaDpk7U+SsEm4l0SoyOij+lAxhj6B7F1xnE+0cqCuiOz1WpImgeQ5XoxfO3CfHUVJiZiOGchf2MJ52Uf4+Olz6F8YRY5peHjyKp47MZfCp6B3vI2EDXJ2RUn7Wyt76orRdOsHnMQKE1iP6giWy9wwcxMHfUXUflmJuUdBE1PomCmh8wkUntFC/6eFuGcmsR3WIcUGBsm4F0cxm+JEojo0hyxE8mUMWRGkfVasrQpc4cZzIBNrM0SyIX9OK0UWL013V9E6z4DzlErfOJWzpx5k+wfj8A1SsLSITL/sAFFZy97vRqANQWRWiFRC4szKGkpMfWRpAnx5xTwUncTst3YRkXV8uWEaqkal7OsYikZgyIsn2P7+OJw1caa+PODceNGYA/z6ySR0IfBVqmQeVDF1xukda8TUq2JtjdEzzkhqWgCLIY724zS8l4RQVAHLL1bcE5MMqegYcPprKyKVlMj/UkvbmSKKWcbUrCWaK+M8KhEoH3CSmzStmnRdiN8+mkAsHS694DdWvjWLidccJK5oaH5gEK0LtPxl0UpW3HM2gWINmee30upxsqTiED+9P4PM/WEaLzRhbRJIu6CNIfYeNn8xjkiBwryph3ln3Ir/kvqyfVCWOu3dpf+UY62Z+drpGvj/rUgxheKKbiJeI8LdPWRP7KT2Jj3hbJGd7hLSXm5H1apYmwVmPLgLudZK+ssmPEPhD3M2Y9xtJlQg0DNWQ/kt1UQzNVjm9RD7MIdQsYJNE2NoVRvfHh3NKHsbACWfCezsKiHYZqP04nqy9qhccuN6pNfTOb/qGLZmlVyjj7qr9Zh2mVletpdIwYCo3uhW0flBq5XR6VLMemUnUlLF0Ae7dg9G/2/q2JQZ3OMUjFKSjAMqsYQWTUhkxlX7EVLw9W+T0YZS9C6Lkno0i+DIBENcPfS1O6lty2JDeyWzZx1FfMrNt7vGs7WljJ6JKhmHZaQY2H4xE5F1dE0Vcc7qZtnoPWiCEqmERCI/Tu+sFLEWG6oIBRtiBOIG9CucjLW3kDrLC4JAm9vJcW8OsXSFng4HeS4fN8zchDYo0zdKR++KYjS6FMIsL9MmVPPZ8wuIOwQULfgnxWg5mkfRNfX0LImx577xBMfGSMoS2rDM4tKj5OyKcN3I7Zh6VE7W55GMafAMEVlWup+4TSDtsMCUO/cy4uWjKKOD3D1tLfG1GWj6tGjeTUNQoekCKz93DidYIJBzRht2W4TQ+ChxB8hGML/qwLDFiqFTS9ICWo+GwtUq7WcIXDpuL58dnsgbJ2YiJaFzmh5FB4n5floiaejtMRStwv5dlWTuFInlpCi7o5pgwEjmGgNtb5T/7vhOmUBa56Dn4SRZ+2Q6liToHyUTzofiVUmaT+aiBHV0Tbbw9rcL6f++gFRZlJ6VhexuLsY7Osne/RXEv88i584GbM1JPBOSVM5voHuSFgDDDgujHO1o8sLknNFGxx8TjLS1YzmuQ1BU8q9oQKuR6T8nwhllteDRIU8I4vm4kBd/OofoBX7+PHIjRV8J7A6UkfWOgSHvVZO5tAVVA2NePURr0IHo0ZF2TCX9iIymW0fW/igVf4/xzStzaX6vAv/wFIFCka5JGs6evQ97o0rdkQLiDoHpVXUEBqcIlKr0nR8lbaUJcZULWRZJ2CBjn0iixYJ2moe4Q2SwqxtjDyQtoAlDbUMOUVlLyiSxYP5+lt23BlWvEFW0TLt2P3+YsxmArV+OpeX+Kkw9KtpFfciySN7XWhr+MogvGsbxSu1saq8yoX+yh3d3z+C776eTs0Nh8sRT+CqNlDxfy8Zvx5EyQPkz1XxVM4aLxhzAJkVJ/FvJ2HUCxt11kPrlGjRRcI8CzyAj2XsipGpsnFNwHH+xSNRvIN5vRBNVEQ0y0aSWHY2lzChuwLbDSNH9NZR+nyB7s4ZzLtzJDTM24RmX5Naz1nDhmbs4tHII1TcPIZoFggorVs/COyHBLyeGsb+rkDNf2obOJ3AyksvUx/cw/vIjDLF3My6vjd03jSNUoNIz0Yy9ViD9aJTmQ/n8vGMMZec1UPCLzN53x/zu+P7POD3M5B/j/wYjl9Oc5jSnOc3/VNTTw0z+Uf6lduCpbIVYSktuvoeWI3lMyWiioqibi67ZzMyMelpfqMLaJJB+Xhu/vj2VzLHd+Mr1WIZ4WfHVGVx4zW/EMmWGnFFP+5OVyFoB/5Ys4g4RMSnw+frptH9bQkZ6gHX3ziSyL42YS8PM3HqsTSL9zxbTtSDJj0+fyZCHj1ITyCRykZ99fxtHSVk3kclhPvh8AUJCIH9jlEiWQHRkFPPPViyGOCFZT894gUCFQvHPCfyVKgvP34OiUzlv4gG+/WUqCALDc7q4ftF61tYPJlSk4jwukrBpyPq7gZaFBnJ+0bDtwCBsJzVcOPwwBTYf9Q8NwSClcBT4SfvWhJgUCGdL2JpVTJd2sfnlyZjbBIxP2vnm5+mIKSj6u0jB9xJln8rYyr0kB0fpnmAgmtSSWt7P6rtmk9jvpHuCAVURKLO5uXn2Bkq+BfHJdL54by7NVyhIcbC2JsiyB8l83sDO5hIsHUmGXFjD5JknGFPSRv7wLlrfK8fxq4mKx0+CV8fItA66b4wBkHDoeGf/TIyXd3HuqCOo/XoyDskc8BcRKhTwlwnk6Pwcu20EmX830Z5wseT6jWiDoN7YhyIJSDGQRAXZCJPSmnE9Y8JqjSIm4YKzd5A0i6jSwICN7PltCMURYi6JnO2w+pOpiBoZtc6CNqRibVGRh4YZlNFLR9iGqgpY84Ok7Cnc82NcNHE/Vm2MzNV6eseD7prfb+SSYQtg7lHItgbpHy5Br4GCdSrq4BCRLB2uIyI5WwTGXXqUeHaKoqUNLBu2j0gO5H2m49Lxe7E2iqRM0PxeBVJcRvJqCD2cR8nsZqruOk7ZhfV8tn0KgqjSu7oAVRX45JdZVC2uI5wtUruuDOurdmwbzTTeWYW5TUS7w8qgG0+i6OCSsgO8sGERvWO17PpyFCmTRHM4jdYNRURyFH7rqsB9MAuDWyBysZ9ggUThhjh1V2pwPN9BNAt8Z0Vw5flx1svofPDbxxNgeR8l38cJj4tyoCsf0ZIkd7uM9rgZzyCBkdcepfhtkYwjClP+tA+9V0Dzg5PFN23mqDuX9PPbUEWYf8Vuin8UqH9jMC0Xq6zePoaX9szFlBlm72cjOfbASNY8OpuMQ3G0YRj+7BGSZoFIQkfR+xKjHj5MybM1BFvs2D6wo+oU/AkDthNabM0q7uESO/cOom9Gkk07hxMfGUE31826/cNJ/9rEt0dG8/HGWThPKfRPSdA3SSGQMpC2X0t4Tghzh4BnWpxJb+3HPNzDilPjQYSpg+uZPqIGRQNpm/X0Bi1MLW2k+Y4KlPle2sN2ms7TEygR0IspfrlnNs5DWt45NY0Dt40mZ1eMustMLFq0BwDXSZWyjxXStukIekz89Lc5FJ/ZzKFHxvB93UhqnxhKcziN3dsHo+hEXEPdDF96krgdGs83oA0KlH6fYKqrgY7ZGmJpvzu8/0P+fRrZ6Rr4/z7/UjVwS1qBOm78LfTeGGVKfjP+hJHWtypwnx0lc6WB3jEC5eNb6f6hiJgLzjlvN7uenEDCIhAsElCGh1AVAaXFRPpRSF7iIRrXottiw9w1UM/MtIRo3lWIJgLGXrC1Jmm7MoWm1kjO1A70mhQufQRRUDn005CBp8dxQYZnd9HxSjndUwQ0IYGJZ55gT3sRtjXmgQlAN57iwKbBOE+pjLz1CLUPDmHIU8dYv24s6UcUwtkisg7SjyfpH6JlxqUH0Aoyu18ajypC71QZVVSpLOuiviMTqy2K4VsHPdNlir9XCZRosV7QiYhK6ItcnJe3MSmtmQ1dVUR/ymL48hMc7skj4DYza1gN+78bxvQlB/nl5FAkrULGzwaybmwk+Fg+5U9Xs/fjUZx/4298un4millGjInkbVLoHauhclYjOkkG4MT6CoQRAeJRLWKbEYMb0o8liNzuR/u+i47zUgDk/6ghUCghnunB12an4FdQRQhnS2jP6SO5KgNVhECFgr4gRIYtRKW9j6PuXDQfpdE5U8VV7AMGLvbELhd6D2Rf0kw0qWVWVh0/vjOLKVcfYMvXY5H1YOlQcU9NYXREmVd8ioOPjyV8nQ+NqDA0rYuda0dg6h7wz9ZM9cB6F7aWFLpAClUQSHuihUa/C4chStOxPPI3KETTJYKFAmISVGlAv5AygTo0RN1FD/+u+puxPFf9w9ezWbd6HJWzGgk8W8iYJw6w8rcJnDntCL81lzM2v42dxyuwVWsoXdxA9dYyUGHRoj2sXjOR9CMK3efHcW0wIOsFwnNCJHqNoFXJ3SASc4n4ZkQROgzYmgQ8Y5NIIYmRYxup3lBO3ow2fF8UkDKBf0wc2yE9ihZCw+KoCYncwn56j2WSvymFmFLpnKpDUAZS14IMurlujO8N5I9TRgGDR6Zjhpb0YwpD7zhGS8iJP2Yk/FvGwHmTIFEQx7lbz5ArT5KuC/HzpvGISQHjUC/qZif2ZpmO2QJSVnTAUEQFnS2B/VcTnjNiGE4YiQ6Kkb5Jj69CYPFZO/n66FgM5gRZHxlpuyyJc5MRUVbRXdpD/85sYjkp9N0aXKcUXDe20B81k2UOUre2DFe1TMadTdT+XI6tWaF3nIClVcDaLqMNynTM1JG7LUH7NUlSYR0LRhxj4/oxDJrayFB7FxtfnoJ5WSfNDVlovBoyDyjMe3grmx6Yxpy/buf7D2aRMsKsiw5Qfe9wxj53kO+OjaLgGw2xm7xUOPs4/sUQtCEV9xiF4lUKfaO0mLpV+qbIaLwadIGB+1PKALIedAFQtJCwgX1WD/17s1CrwqStNNF3dowMZ5DA1kzEJMiTA3DIhmmyG0+Di4J1CoKsgigQyZCY8qd9rNoyngtm7+Gn1ZOwjnZjf97K5k33/ZfUl21VWerEdy77pxxrw+yX/0fVwP+lFvCMIemq+Z67KcwfMNuIpLR4PinEMz/KjNJ6moMuGhuzmTS0gT11JaRt1+EZPjDNJ31EH1Z9jEhSR2BtNpUX1XFscwWaKCiageCvmtHI8cPFVI5oo//TQvwLIhgNCUZndXDwq2HYF3YxxNHD9h9HkRgRZnJRM43PDaJrqkjaUeibIiMFJNTcGBW5vTTsKUJMQqo0SuEnEkmrho5ZUDK4k5bjuSiOJNbDeowelYLr6+l8rQz/0iCyImJeZ8XWksQ9TEskX0WTHybhNoIpRdY63cCiPivF5MH1nPp0MP4qFSErxrD8Thy6KClVJKVIdEWs+H7O5Ywr97C9q5To5gz0PjD2ywSKJByLOpGeTSecoyXr2iY8rxYTWB4gdtKBKsDQqQ20fFlGwg5pJ2W85RJTlh5ma2sZ2e/qAUiZJUK5Er5xCYaXtnOsvgCNOYH1NzNJM1jbFeJ2kbRLWonLGoosXrqjVlz6KPt2VzJ1ykk8cRO+uJHhrk42NVUiHbEQzZURbElQwbbPgG94Cl2fBlsjIEDcAZEcFSkmUDy5lf6vCvGMksEgI2gUVJ+O4lUpuqbqmLdoP1v+Pg7zwh5iPw64UpnW2Iilg7VNxVspkHAq6PPCxLrM6HPCDMnqof+ZYjyDNETHRji78jhr105g4cK9/PbRBIIlKga3gKVdxTNUoOGeO37XzUNfUKCWX34HOj/oAyrhbIGUEeJDomgajDjqVEw9SZwPtXJkXxmOGgHPcJm0w9LA6NWFffS2OtH1arA3qvQPh7RBbhK/ZjBm2VE2nxyEyR5FVQWE/Tby5rYyxN7NymMjyfhNh7S0D3/EQDRgwGSPEvGaGFzWQU/IitdjJusXPV1zUmi8GhSdSs428JWLhEtTFP+g0jFTi84HrhqZhEVk3G0H2bh6LOecu5tNb01CkMF3ZgTrdhOWTpmYQ0TvVwhf7Se1xcXZl+9g3RtT0UZU+ocL2JrAX6HiPAHeuTH0hgR2U4zUF5mkjAIpE2iDYPAqeAeJJGwqi+fuYe2XA7/LckYv3fXpIKkYeiTOX7yDVV9MxTGnm46mdPTdGuLpMsWrFLonaMk8PGDIUnhuEx1flyCe1U9kTxpiEsKlKURDCvseA3qfins0GPoExAQ4GlJ0LEmiqzWScKoMHdNEd8hKYH8G6uAQwkkLhn6wtaSQ4irNS1VMdToMbojkQKwsjiCo6OsNJAdHUHoNCIpA2cg2ahtzyNipQbukF8+eLHQ+iLvAdVIh66YmOj8sZdhNx9h8chD2QzoC42OYjxiIZqtMm3aClqAT/3d5GHwK3kqRofPqEFHZ11CEqUZP1px2+n7Jxzi7D51GprvfjmW3kbgTRs6rofOZMtrPFBkxqum/zCTFVpWljn972T/lWJvmvPQ/agE/XQM/zWlOc5rT/Lfx721kp/nf51+qBh5K6Jg5uJa2k9lk6EP43i9EG1IRWkw0B13kmgM4sgOc+qKK84YfRlzcx5QJp0g7Cr39Vvq/LKTzVCbiHA+dr5Vh7gDdZA+OehVFA8eOFqM6kqQUkZhLIBnTED3upDdmIVygMsjRy45vRpFxKEm2K4BVG8Pwx05MXQJ9ExRyivrJOATZP+ip785AKAlj7oSRhR2E8rVIN3YzfVw17tX5OE6IpGUEYZaPguvr6X2ulPw/1SNts2MzxkiaQXtPF5pZHhS9gmWdBV1aFH2Tnu5ZKTKubcZSraV6xWDCZ4Q4c+oRrNuNNHldRFI6du0ZREKR6NmRi5SAH/aORfNpGsMvqMa8tJNIukTcAa0daQTztUQv8KOoAoKsEgoYSDplNFE4vrsU7+gkjnoFf7GEo0Hmt+ZyzGutWB9op/MPCeI2EXO3QvZ6Lc1eFzprnNw0P8pZHkx9KsPvPMrQq0/Q+WshrfVZGKUkbR4nXU+XUbAhxf7OArpXlNDelsbmNQNq1/J5jWTuFlH9WnRNBiYuP4zjqIbsPSm8c6KEc0E3qx/ZlsJer9LYk45/ZhQxIiL1aVEjGtAq5DzagLEXft4xBnOPwuj0dqwdKdSjNsL5EC6S0VzVjfhvRmpyjRVddgTHjxYUVaBjpoQ0w0Neuo+1qycg61VWbRlPqFDF3C6gmeRF0cDwqfW/O761xiTx0WH8gxSEK3rR+SHthIym0YihHzzDoHO6Ds9TRWTtUZG1MHlMLSx2IygQXZfB1JG1CCr4KgTKRrchr8wgnAMHvhhBYb4baZsdUVRJWsD/UQGrfhtP4bcSoXyB/oCZZK0Nya0lUWdDb48RfLkAy9t29PUG3OdGMDdoSTlTWIoC9A8XGX/+cWzVGjpmasnZJeOa00UkU8JXIbDm+HA0YVj7xSTiDgjngmWXiYwLW/EXS+hCKsKNvfh6rYSGJPhh5VQCZ4TpmZtE5wMprqKK4J6eJOcbHYIAXZ1OgoUCw648waiLT+AZm8JfKhJ3qcyYeYyVayYRKk/irJOJrslk8tgazM0S9gaV7+tGop/ej3t3No6jGvQ+sDZKuIdrSZmg58oocSfkmfyYz+vG2+DE1qKSN6+VIZXt6BsMRLJBf1UXupIg0eFRgsMT2O5oI22DgbELT6LoFfreLia5JgNFC9Z1FjIPyQQqFDpmS/SN1JK9QUv68RT9E5NkHkpR8J2EttVA5sEUclwiq9LN1EknadpXQPpuLd7BUOnoQ+cHVND3g+/CMMf2lZKwCXRHbaiywIhLT5D7gxYpDnJaklpfBp6ICe/kOPm31JO0qvS8UMqRrlzMJ/Uwzo9nZT7O2hT+gxnwbiaVuT1ULqlFFWDfvgr6h2hQjDLH95T+7vg+zT+ff6kFXEmKnHptKHMnH+XkU8PJvbEBAFsT9GzIZ/uxSvx9VsLTwqz7YQKGd13EZC1iSiX3Wx3941KMGduA3RhD1gtULq8htcVF71hQdCrTx1WTt1JD18YCrHN7sDkimHrApY+QP7yLo6+NIDUxSNs8DV1uB1u+GYtNF2fSkiO4jkoUWn30joO4XST3Cx26/WZCs8LEZA2eYaC+nkWNNxP7wi7MvTKyIlKe5qblg3K6Jkm0h+ww00dvhxP7wi5C7+Zjfc+GGBsQJilNZuJFCWwZYXxxI6lJQUZfeRTjNgvbVo5ClSDQb+bYr5Vo8iLU/lyOooOYC4ztGnomCRzqzKe1PR3fIJVRc2sAAV1QxfSNnfotJcRcIkMKuxg+pIXUkDCqBFJIQyRTJJIDoWv9JCID3tLVu0qxbLAgJUF7YxfDbj+K4YeBBaK1IZNQ2EDFTdVs2jiK2jeGIOvBViNx9OWR2H+w4Bk0YFBhXm1FF1QQwwN9y6mERLohRDRDYOSIZgqnt7Lu2NAB//L7asn5bqCE4A+Y0FoTpF3RipIU0dYYMbcJqFowpkfQpcU4+eVgzF0y9lpxoG0paidhEYlly+TNaAO9QonVQ2pEGCEtTtIhYzdFSRkEGn4qw9Iq4Hdb8K7ORT/Ch2uIGykq4KyGcP5AH77njBg2bex3x7cc0JLyGJAtMl11GeRe0Uj74hRiCmQDoAqYRnnIfaiemEskMj3M3h2D8PRbEBRITAuy/9chWFohZVHoC1sw9clIcQiOidF+IpvUtACazXakOARKBRCgY6aEsRfURjOTZ50gd5tMKiuBdrcV9wgJ813tjJxfQ9Y3RgweyF8rke/wEU+X2blpGBMvPYKqUYk5RLoP5uAdoiCoMLGiacDnIAmOM7pJmSA6LUT3T4UDf69eoHdvDogqWRu1FM9oQekyYarVEctWCBYJ5GxXGFzaib9IQthhR/Rqiacr1L02hOanqxg8qJ24E9KOwLamMigPI0gq/msCBCdF2XWqDGVigJ7pMpb1FpIpiawpnUTnBIlmQHRCGM1MD6YhXuJ9JsQUnPRl4YsY0QZFgucF6Y+YAXCdUHDUDZQcowEDQqeBsqIeXPoIUgL2bRyCziPhWRyhaGkDusF+gkXQO1pC7xaZPKmaIefWIlzRS/9gDUZHjN4xGsofOMngGQ20XqQg6RT4ewbHVgxFkAf86QH2dhSSMkLx4kYMc/twfGembHQblkXd+N4uRIiLKAjE7SLmLgV9iw73gSyix50Qkzi5shLHKYHOGSL2n82EC2Qm5rVQuqSe+I1eUlaFnnEi9TuL2XeonHhxnLxNCmnVMkJSZMSkht8d3/8Zqir8U17/0/iXWsBFrUL/CDjUl0f/8jBtH5XRvTgO5/QTGRzH6IqicWuwW6PoJnhoWyxzeGc53kEiHbMFxgxu5sDRUhRVoPeMBMdXVhEaHkdJS5KzU2XriUq6L0pgaR+4atTfnESnh9h+rBL35lyc17SSYw8gRQQMxgThyiQnN5YTTulIWODAtiqMXQLB+SE8gzTo/WD/1YT33SI0+WHC2RLu6nR6d+fgqZQwfuag6ctywnkCYlmI+A9ZWL6wIcRF+nbl0DVLoW+0BkuLQMa5bVRMbEHfoiNSZ6ejy4XrKzO1zw4jkg1DFtbhHyKDAAmXina/BVOPiuuEijY8sACICYiF9BiadOQM6yGQ1JO1QUvnTDBd3UG8OI6UgMb1JfS9XUyq34AmIjB+Qi3Oxe0YeyHNFEZviePbkI1sVBh89UlCuQJGbZL1h4eSsAvEuszYT2qQNAr1bwwma0w34WyBeJpCsEQBVSV1WT+KFsJ54C8T6DxjoHd+wrwTuDYZOPXiMIIVMgYpRVPvgARWsCYJJfX0jZJw1igYjhiRTpmpac4Brw7XyQEFuuJMIu2ykUpIJC3grZIoWtqAuVulyTcwJlO0Juj/rgAiEsdWDCXpNqA3Jskpc6ORFPrHpZBi4BuRxFytI/vcVixf2JB/zEAbAn+5gKpR6d6Wh6bRyMn+rN8f4AIMHtKGoUPL5LE1dHxWivWwHk0IIrkKYlkI3ddO6r3plC6rw7DHjJyRRNNmwHVRG4bfrKQsKpXXVpNV6SZY7aT9bIVUZRRtswEy4kSDeoITo2gDkLSopB+GlCNFaG4I+wg3J/qz6RmnQdeuJzwiBiOCtHqd1K6oInFNP3EHdE0RaF1djORMoO+HDccH4zwJ2dc0DdSeW0TixXEiKS32qb0EhyXpctvJOKKQ/rWJ2OQwCQckrAKDZzQgerXEnALejwoxtwlYpvWhLwgxdG4dHfNUbNo44SKVhAPyR3SRfkhAurKH1rOh+8tiNBVB+iYqpP1sIuHXY3JEsaywD4gqW3TEOixkbZXQBRXCTXaiCS1yg4VUQQzrFjPBGiepXU5suQEctQrxz7IJd1jIOKRgWmOjyO6luiGPsjurkXUCnf12hIAGqThMUpGoeWsIvgtCpEqiiHFw/mTmWFsuY7Lb0URgwvwT6MZ62bt5CC3vVhBZnYWjQcG20kIsS2ZLfQUnu7JJ26Yj+1sdvYtiaCIqsl7Fd0YUnV+gMqMPQYbWb0rxH8ogmC9i0SYotfXTN1rAmhfEFzeSXOylf7iIbFTRRMHWCBm7JCydKuZLOlH0Cv6zwyDBgc9H0PRlOVZ9DNeRAc1B1j4ZvUdE167HPVxD4Fo/jgI/h46W/P74/k843Qf+j/EvtYCrMQkUgVBMTyyso3+UitGUIHgkjcyNOjS7rDhOQbopTPiEC8mtRUwKGMZ50IRFTmwpJ3ezgDdsQtemJ2kBnTGJvllH1xQBUS8jNhsRL+2jf38W4mwPyS4TE4Y0YupSadlURFzWUDipDe16O7ajWhx1Kg2+dGTjwAhOc48KtRbMs/pQtJBzZROe88NQa8F+cTtiQkBQweCB7ingGypj6h4YgBLKh3C2SMZ+Adu4vgGRTZpCYEgK71cFnKzNJ31yN1JUQHJriTlF/MUilIU51pWDGBfQt+oQsmKoErhHq/SNV1EBU9eAUC/nFw2xkgTuXdkE4gZ6JimMHd2AP2ZE8GnxVg24t3kHiRi6JeJZKXafKEMUVOIOaPM4Mf9qJZo9MK3tyHdDMPWo1HRkIShQuaQWXXYERYK0b030nJmgP2geSCc2idgaRJTl/fiDRsxdKrJRJWt8F4JGQe8R2dlcQv8olWi6iP2kxP6dlaT/ZMKRGWRQYTdHGvMRU5BY5kU7zUOyIor9gA7VIiPrBWwzehE9WkJDElh3DajiNZEB5bqvUoC1LlQNWG1RUiYQZdAt6kPVKzi+tuDZnUVXlxNkgUClgqFTS8a8Dmobc/BWipRdWUskV0EVYdzYeqIFSQwjvfR1O353fEvWFDWHC0naFWKyFsvFnYhJSNpAtadQFWEgIyKqHNpXTmBwEhSonNpE97oCNFHQ+QRSikR3fTqyXUYMaFD69BRNa0UJatFbEmSsMaANgzYoYL2yndwNEmnfmZDXpCMJCvHcJBnju1FDWmJhHeIWO9EMCO3MIDwogbNaABFc6ww45ndRVdJFKE+gZkspztF96H0qqAL160oJbs4kZ72EkpBQr3QTLBRRm01IUfCMTnGkugjFkQQRoukCOj/492VgWG+j5YNyCst62X2iDGOXgLUJYkktsl7AvSubIZXtBMpUOGpFSAlE0gUEWUCrkekZL0DxwAxrc4uI4w+t9EwGS6mP6KYMFL2KRi+TNIGsV4llK/h7rMRcIn2zkuj7JXoujg64+CkiGVs1tIScBOeFsG024zwuIkkK4a9yiWQIxEJ6tPXGgevurBiG40bq/emkz+lk64lKxHVO9B7omxsnaYWOc1LEHQJan0TmagNitZns5U1EMyTkqAb39CSmToEheV2YuuFUbyYJB0SzIeGSyV7QRvv7ZZzozyZjZC/CZgcnmnMJ1ThJOBQKxnagGeejf4yM/6wwtmvbMGqS6NwScb8ec3YIXUAlMCVKb9BKLE3AM0om6pKIFyZI5CQxuiFyzEXkiGtATPpfhKqebiP7R/mXWsBPc5rTnOY0pznNAP9SC7jBEsfeAIkmK+lpQQy9Inptisxx3fTOSRLLVPHNj1DTmIveC+VjWxFTA7tbuTCKaaSHuF0k3GFBTIKlHcTjFhz1KkgqYo8eQYHQhky0Q/3EE1oy9gnsO1GKr0rA1APpxjBdGwpQF3iIuyBpETDr4kSKk6gCJE0Cqgg9nQ6M5/Rwcm8J9jVmEmkyTbU5CArkT2sjclYArU8c8DMuHbBbleIQGh8l5hTQSAr2RpWMfQKZOyRCBaDv1dDRnE4iK4WhLIB0Xh9JG1h+M2NfbUaRIGlV0Z4a8Aq314qQEUcTG+i5NpYE6D0vxvDSdipnN+LQR0GE+q8r8LQ4sJf6yJ7UiaUN4kVxHA0q9hMa9I4Y3q8LBnpP9Qk4r5+cYT1ovBq0YeidqGA2x9F3a9hXW4xhhwVNbGAXL+llkk0WTN0quoBKcEIUz7F0LFvNoELeyC5S8kDt2+CGVEhLelk/oUIVXVAl4xAE8wV8vVY6/HbM1Xoyp3eS2JxGbJ8Lug0EyxV0nVrcZ8WIrs5EUKCsqAfneR14RsoERiZoCzjIntiJ8dwefINULPoECTtYG0XSTGHSd2uJLPMRL04g9WnRuyV0XhFjD7QezcWSFkETgcMdeVhaRGzNsP9AOVlbNYTrHOTkeX53fIuCgq3Mh9YvcmRvGb3bc7Gc042lDdSUgPaIGVWAXo8Vc5uAFNJgdkY50ZCPKoBxaRf2RpV9NSW4joogC0gRAX1emL5vC8naJhEP6gkUC0Rywdqq0rI/n2C+SDBPJDY7iKc6HUtahK4+O8asMOaTeoKj4sSyZaJlCUw1OhQN5M5vRdYKhOJ62tcUDWQ1WkD5Jh0pDtlZPsQUaEPgrRDJzPLTdzyD7LNbkWICydFhrDUakAUytmqJ2wdKPJGzAjgn9OKvUIml/Vu6OiEgTfXinR3FXZOOc0kbzlqV6oY8bI0CmjC4joro5roxdEtof3BirxewWWIkq6K4FnQSSujJruzDYYoSHRsl7bBAKi4hyKDNjCLGBbK3SMg6yNykJeFQMBqSyOd4OFpTSP9oFREVtd5CJAs0i/uI+g24J6TQz3GDLBAvipM+uZtURIM2BF3dDvRSCmObltD0MGJywKTFNasL104d/iEyKbOC4epO4sVxjtcWgAIZOzS4dukweFUaPWn0j0shHraSMaqHVEkUS4NE+IN8PENB97mL7l47+nl9WI7rcZ2AzH0CTTU5hJtt2Av8lGW6qavLpX1tERkTu9H1alEUAe+8KNbdRtTtDiK5KqpGJZwL1qM6pH4NvkqVZE6CimlNiF363x3f/xmna+D/GP9SbWQJj57+kQO10tTPGSRnhmFXGgGbSubxAVGMV2fC1COQmhCkY3URqSwV+aQT82AfygYXsRzILusnfjyTQAnIZoVkl0jaIeibqKD3SKjT/CRTEomwDrVcoLi0h+aODMJxHU2rSkk5wKZNEbSq2C7qxPt9PiYnMCZA1G/D1gDhqJbIkSy0M4N4C0T0NWZSRhUpDj1rCpCAeJ5KOHeglzTRaCVnRhe9fiuxyWF032ZhWNZN4JdsohPDiHVmpCjYTmpImSAkmImGbGRO6CX+UyaaS3oplGTaj+UQy0uRuWNAZV6S7aa5PB9Fp6L0m3BmBTlaWzBgBuEXMKcG1MGSK46qQiBmILHQj+oxEU0bmJqUYQ/RXWGGvCjCCRf2BohKIMwJ49eZyNwr0osVUwz0tjh6r5ZA6cCDjBzVYOkRCC4KYtpgRRAhfUQf4a5M/JPjiIdzSDsGunIBRQOmFi19cRdCbpy+dAmjIwqArtpGyO8grVul82AOtiCER8bIy/YSWJ1DJAfoMBAsVXFUCzS4skAVsNZJxDIkYi0uAraBB7X0Q9ChzaB4UgfelXmcrMsjK6Hi7rHiyAoipaskUxLhJjtSTKBwRCct1Tlo7ZDqNiJMCCHstuA8LoIw0KecOp75u+NbVkXCR104G1Q8QwS0o30kV2QRXezHqZUR97hQtAL6k0aiWSoIKmGfEWIiSRv07M9BUwpICsq5Hmh2ICUGju2bGEfSKmjaDJimuFFXptM/SkWRQBMVMJ7bQ1dLGmmnBMLFIsYjRvQ+I0krVBV1U9OUgxDSoOgG4iXYm0bZZS3UHi3AFoXkhBD9mUYke4K0XwyEN2Qimwdq94pZxqqCa4ibutpcBKeCZZeZwLAk5gYtfbPiIIsIqha9LkX/oUwUm4xmph/zehdiEkIBJ9ZhHrLzeun9qgjfJAWpX4N/WpT0Xwz0npHEsimd+KgYxh4D5gu66A+aEVqMePcaMcztI57SEPCaIKLBMz+KqAqY5/eSDBtxjuylP5GFNgD+80IU2QNoJZmu1YVULmrF/XUhzbYMKia10tCVgaoCUQlbnUTiVDoGM9gm9xH5IZuMhEqwCKyOKE17CsEIjnUmQCWUJ+DuTIMpcQBUQcL9ax7mqX7CPiPe4QqqJUVaVoB4UoNhlYNkCcSqYrgPZKFaBso33koBTWmQRIMVy2EDoakJosPimDIDJH7KQBOU0IQhKDupzTGiiipSArrcdpTsBOJxG3LmwKZBv7CPxP4M0gd5CabpSRyzYW8YuB59I0RqezJJG+am8XdH+H/E/8z09z+Df6kduGxScZ4U0WVFCM0KY19vJlYVQywJkzIK+OZEUYwy0RyFeK+JpBUM7gGBmLjBQWB0nIRTRVEFvBMTSAlQzTL9E5MomgFRUqQohX6NnVRcwnxCRzxTJvhlHqJWJuEYeHjQu/9/u6Dmxiw0MZWEXSXiMSLI0D9axjSxn9CUCKb1Voy7zYhJ0JaGBp74wwPOSYY+AVuzSrwgic4nEPsyG702RdKnxz0pSe+BbOJTQtitUeTyCJooaOb2EylKYW7WoC8K0nsyA8N5PfR6bITiesQkuPL8BAsEBBmautNJ2WTEuEBadoDYXhfmRi2KQcXYB6owsPNx2cIIv7qQN7mINdtI361FmDewq+zociKnJ9FoZXRVfuL2geleyYgWY5dA78zUgLFKuorcYMEzHLKmdJIyq+hbdWhDEO8x4RuiYN5rxBMyoQ2Dps0A+VF6x6vYx/ZhmN+HKoK+X8Jqi6Lr1KLVyMTCOhJOecBFyiCQP6YTzygZsVtPR3UWkewBsU7KkULnF5DO78PQrEPfpkUfUEnaB4a6aCICpjaR1BIPpg6Jlu40ItPDSCEN7pFg6NQSPerCf9IFgKV5wHGtrc+FqlfQBgd27ErDQAbHM1LGXyYQzRT4Z9x/UlENUhyky3pJpieRdztILfUgH7MT3+NClFUS1n9zPPMLaP0iRlsMnVdCqAghG1RMk90Q1mDRx9FkREEB0zorDlcY2adDFSCyMx3TRV2Y2kQMfSK+oTK9RzMpLu1B0UCs34gmDqmzvQSHJ2jZVISol1FtSaQYKJVhhEYzDXsLUQ0KgQoFrUbG1CJhOGSkZ3qK0PA42iDYS30IWoV+n4V+rwUhIaKYBsSWelscTQTEfh2GVi3RsgQWfZxEZhLRkSAS05GcNRBvicwkqW0uatuz8E2N4TgpIhZFcPxmpHeajO2QDlGGdFeQUAF4QiYiXiN6HwQrZLxHM0gkNWi69Ri6JPLSfegNCYKbMlEUgciaLExdkDGvg2SbhQ6Pg4auDELFCu1eB46L2kGEhqP55GcOTMGTXHGCoxLY5nejDYLybTrRzAEHuqRVJXnQgWJUMLgHBHuBYoFYXoqcbC+mGj3pW3ToezQIMiSP29F26rCX+CAq4fWaiSc1eIcrWEe70bQakKqCGLtEBBVSJhWDLol0bh/hMVGE/TasR/X0djkIzIhia4CURcXWKCC0GZCMKRI2MO83YnVFULSAUcYzWia0PQNLO0TXZ6ActyGoYLqwi2jmwL0kzRamp8Px+wP8NP90/qUW8NOc5jSnOc3///F/KoUuCMKHgiD0CoJw/D94XxAE4VVBEOoFQTgqCMKY/9d7VwqCUPdvryv/7WsmQRBWC4JwShCEE4Ig/O2fdlL+P/AvtYALyYGdTiKqJRnR0j9WRo1qiPv1JM/yYTbHEKMSqgimNomkTUWMg36XBf+4ODnZPsytAr6wEddOHbIOLNVa0rIDJKyg9Uqk7dPgGZdCVzewCxESArF0oNuA3i0ipiA+JYTFEkM2gOOoBl8VaEMCllotCbuKvUbC2zjgB+0dqiCd4SFlBMMmK7IRvOOTSOf3IetBu6QXfbuWpBX6JslYDHHMmWG0lgRyYRTLegtaUcGyw0RkfAT/SRemFg2xTIVEkxXFLNO/LwuDMQGr0nAOc6OoAq4Z3agCOOwRDF0aTJ0C4ZiORFWUuFPFVBAkUAqRQpmEU6G304Gsg4QDcod14xmuIKxxIcXBsVc/YCCxzUqs1UpwUJLA4BSmWh3hoQnMtVoMWRHstQKpjCTWKi9d+3Ixl/qJFyQJFYC9RsLUJqIJQ6rDRPwsP0mbjMGQxHVMJPFLBoE9GagjgqSMKoF+M4mCOMl9TvDq0KTF0IQFfIMVmmuzEaxJLG0C2sBAPTruAIMzhs4H/bXpIICYAvXCfqSYiGwAy+h+EpNCsCqNSFUcbZMB7WEzmvwwsi2FKgyo9S2DvNhNUUITogjTfGjqjFirNYQHJQkVqyiFUQITYug8EvHsFNogeIf+/viWYgPe4F3NadjSw8RdKp6mAVVxND+Fe0aSpA0iJSkiZcmBzoJjNmSdimmzBSUtgf9oOpqARDCmx2KOI8UGWvXkzS4MPQPz5bUh8P2aQ2hogljmwG7Y3iDQvyYPRQfo5YHzqU2Rk+NFHO1HEFXEfh3hYplUvwFtAAy9AmJIQusXCfeakccFSTjB1KxFTYrIeogedJGZEUCUFHS1RoydIkJcJJ4GiYgOBDCUBEjYVOyHdPR4bTgPabHsM0KNBd1GOykzCCmBhBPsuwyIGoWEFawbzQOlAq2C9axuYukDSvmUVUGz1Y4tPUyoLAWKgJwfI9ZlHshiRaF/XS6RTgvhoXESER2xNIilQcvJHGzl3oH7jahirxXRSApN7ZmoCRFrvUiH24GgUdGeMmE7pKOz10FweBL1wn4YESQ2O4i5XUCKDmRsglVJBHXA9lXn1hBPaQiXJgnnCZi6ITA0Sdr4HswdEInpsNdIKEkJrUbG0CPS77ZiG+VGkhTkcUFCwxKYq3woioinOh1NkxEpCpHxEQytWvTHjURyQJAFUgaw1Qvo6owkLSrBUXECbjPJ7AQ6cwLRmiBSmcB4YTfhcVESDoWEU6G9LpOUSSW+LY3IL5lIxtTvD/D/gP/Dw0w+Bhb8J+8vBCr+7XU98BaAIAgu4BFgIjABeEQQhH8bGsvzqqoOAkYDUwVBWPgPnIZ/iH+pBVzVQHhmGOcuPaJHixQWMXRoSM/1E/Qb0UgK+sIBcVt8eBRro4CUhGCljCs9RHdNBoa5faBC3AmGfghVpPDVuFC0IBRH8FWqSAEJQx8Ei1Vs9QMmKrJVJlqYJJoJ0hELoQYH2vBAKlmKCejHeYjkK+h9AtEZIUwdIlK9CTEh4G90oPNDNBMS+QlUBWLrM5AN0HckE/PYfvSegZtUV7eDaESH0ZBE7DDgHaoQ+XWgvqo9ZcLgFgba37wiUkzAnhtALo+g7LfjHarQ1+1A2eiix2slNiuIz29CP8qL4cw+4n0mTIeNA2nmLXb0VX6s9RL6nDDGVi2RCRESJTH8ESNSRCQ8J4Ssg1CRiq5Nh6IFZ4UH+3EtOleMcEkKrTFJNEfBuMGKKjEwLGajC7U0TGqfA4CUVcE/WCaareIboqIJiIR7zIiOBPFTdsK54B8bJ1YSR7fdOpDCq9NhPaxHN8GD3i2i16eIlSTQBEX0bgmpw0BsZhB9P3hGyYQqkiSiWhIOQFCJFiSJ5siE96ajDQokKqMkN6aR6jANCAItCeSKCLFhUQw7LIhRCeMoD96RKTSSQvehbMRWIwZtkniGTHBUHJICqqiieHWku4KIMjhyAwSmRJENyu+Ob0UH8UwZY7uG+FEHYkoAnYKpXUTj1SBqZVJmFechDbouLYFSFYMbjL0C8jwfBLRoKoKYh3pIpiQCdU7Ms/vQBvl/2PvzYNuT7a4P/KzM37D32We88635zbMGNPCMAGNZYEw3lju6g4BuhvakdhsMso3DuD1F2+4I7HbQxmEbrADCxuEWbQcmrA6wsVpIDAINT0LSm1+9muvWrTufee/fkJn9x8rM32/ve2q4Vbdevftqr4gT55y9f0POa63v+uZKTq8EwueO6LcdRx/2nD7pMfsllIHZC5a7P9hx9GHPwad7bO0QB4enE65f36P9xg5bf3eD+pkj7Klh4xVLsJpbYOslzSE/e75g+rNbdHsO8WBPrIaynmm4/dULuJtT+lng9JMtdm7otjyhU54Ev7TD9Ib+Xf/SjIOPe/jhe/DxY7ofOSCYuEXzVTj4hKc/LqmO4e5v6nF/6xy0hpOfuoL0Gp4KonMt/N1dzv9KAVs9G1+cUB0YpjfRuO8hmL2WS5cOsbdKmnOeUEBxZY41nr61bP+dDfY/13P88jZbu6fUNwrml2DjFzcIvTD7wdvML8HWr0yoXy25943z1D+3xfT/t8XRhx3lb7/LyeMBu9Fzeln7t328RUS32XWbEH7PXexhwZ3DGYuL4J3QbQBekL+3Q7MX4LRg/3CDxbPbTH5ui61frzg+nuD//i48Pmd2LR6sYwLbv1m3r7Yfn9Nveo4/13Lvty0ojzSEN91s2L10xLlLR7gXZ8hrE+ytkutfvUQ96dj9qmHy1BEb1yzlsVDvw8FnetzikaJLvaGEEP4O8GaM0x8F/nJQ+QVgV0SuAv8E8NMhhLshhHvATwO/O4RwGkL42fjsFvhV4In3thaDPFIKHOux1nPvBzpNL/qy0H5izu1ru1Qv1xx89Rztc1uauaqxHP7Agv1P6eEW/n8+j585Dn7lIv21Gf0M7G+/iywMfuY4/kSnBwrcFdy5HvN77lDtCwff20LQBWn74gnFCcw/3lAeCcdPBdrInu16y+aLhv57jmlPS06e0aMS3fmOjWvqAXY7gdAaJq+VdDtQHcD0hrD4+fPYBibXLcX1mq2tOYe3ZvSXO7afM/QTOPmtJ8h3HXLypGf2GvC5I6QH/7fOwbUpi08sdC/zr5a6eL26wfRnt+D1CYe3N7l1a5vpNUv1O+4gAY4+5Fk8t838EjQnFf2mehShs8y/voNtYWPSwj9yQH1XCIWeYtR2BYvfekz/ygwpPOU/nOmpYj98zL3PN7qX/h+/S3dUIQG2zp9gWoHasf2cUB4KG997l2Bg6xenYAKLxzvMnQoWlv63HVKcCKdPOjDQ/PI52nOB4md24Lige3pBtxnwT8zpXp3hfvsBO1+22I0e31i6T8yZ3DBMrpXMHjumPITiGAhg/rG7bD2nymPyd7YovrHB5i9PVWldmnNyWrP3awV3Xt6jPBS6ix23bm9j9xp2f7kmGNh+zrDzNcudr19g/kTH6a+fo3h+SnFs3/XwFqdjoP7Nd2mfath4HXa+WDC/GuivNhTPTwmiCM70dUB04e6nYIxn+tgxbVNw+OIuhfVsvSjMf/oi1e+4A0/O6V7epNi3hK0ee2rU9akd5of2qV8tmT1xxPSVgv6kpP3MHPvLW2x8o6L46BHHTwfapsRfbqh+6C7zp3pOn+k4+L4GKk+zB/e+t6O+eKqVudggXrCVY/aRA4pjw+SmMPtKxeQjh1T3DNV2S/dbjpDffECxAPePHnD6hB5Oc/qVPdo7U8qf3gHUqz+9AmGrZ7q34PAjukOi2wZ7bLn3PR3dR+cc/aYFu8/s0z+5YPEDJ7gSmFvmlwOb33OHbkMz6B0/Ae604OjnL+rSMte4tbs+5Xhes/krEw5/25xis8OeGrpf3WVyB9wksPhHTqivlxx/4QLysWOaPVg83rH9rKJ1977LQRAOv7GHf3zB1i9MkY8dEyxMnq84/uUL2FOD/egR4afPUTxxgnx1k/Zjc+zXZ5x+TPdcd9tQf/SQratHbP78BrYR5peh/aEjfGc4/eyCzb+/QTfTHA/2yzPmP30RPHBjwuSmobhREk5KRRG/uIX/0jb+585x984m9pkTtl4U3MWO6p5h8eomB791TvPcNuXn7zK5BfzeO8xeKHKWxPdEgu4Ffxg/D0EeB14Z/f9q/OyNPs8iIrvA7wV+5qGU5G3II2VWSatnEy++u2X7m5aTx8HfrZncNXRbAb/bsfHNinY3YO+UOmHuCPMPOw4+7pnuLnBbLf7mlOJYaH/xHP7pnvpmQX0b2t2S+VWvkPZ5S7cZVME81jM5N+fozoz6e48wr85onuiYfaOk3YH2s6e4gylbAYpf3US+/wiz2WC/uq0L4Fytfl8Is5cLFp8/wV3bwO/0VNdKJMD8imfz6UOMF46+uYfsdbAw7H9Xx+Rayca0xf38HvK4Z/+THvPSJsWnjzl5bQNfBsra0bYW9zv3mf7cLr4Quh85YOtnd2jvlvhKIdq7N7bhCUcoPfZOST/zTJ+tkR6KBVS/UXL4XR0bv1Gy+KVzVIdw+F1a15OjCZxYpBeqp46xxrO4VLL1vCE81SNf3aR5qsX/zDmmO3rMZv/FXfwzC8rK0ZxTUmD49XPIjmdxXtGLvjPMXhXcpGDebCIfn0NnOfm+ltkXpripsLgI1YGByz1tXSJB2HjNsGi3aX7LnKJ0+M5gXpzS7moObfnVHU4+pzRs+/qE4+sTZj9yD39rE1cZmss9fGbO1j/Yotsu6KeB/R9s2P61mtOrgc1nSxYXAu5ii/ud+1Rf3mV+AfqPzOH1CebU0n9oTvnslO7cu4cYQwEIuJ85Bx/xBIHjjwQmt4TTmaV9omX6zYriWsnJ47BxXWjO6RbBg3ua7lNMIGz1HL66DdH43HaG2S9scPwhTzE3TPbmnNgATqCxnDy/Q/mZI05uzAjPdJS3SsxHGk4+0WLvlrjbUwogvD7BPnbKolEEpvzCJiefajAnlvouuA1LU9RUv+mYWdnT355SvLxBsBv43zTn+FwJTtiSQPfROdVXZiw+1LL16xX9FBbPbiOoMg0GikOj51ALtDsB+/QJ9Vc2abdLQhU4+khALjX4WzV22jP9jSmnj3sOb9f47Z7ghJPHYXLxlMVxxb27M+TxAJcW1LOWEjgOM6TyFK9XuL2WzS9VHG9NkC2ovzjFl7C46uhnQrcpuEsd01+acfxxPRmvPa7YmEOx0bP4YU2na17ZZOsF4eBTjtmsxRdT2ptTpg7C9x5R/OIWoTAs9ie4q1AVjtPLPXRWibILTaLU7gX657exT50wNdDuObaet/T/cIvicyf0t6Z6kmINJ8/0SOXxGzre3WFN+XKJ9II4RRR9CfaH7nH48g7F6xU0Ne0umDulhm8MTKYdp7sF7S+eo/lYoJjXdJ9e4Ofvrap4iFnULojIF0b//0QI4Sce1sPfSESkAH4S+M9CCO8dYX9FHikFvpa1rGUta/nOkgAPcw/37Xd5nOg14MnR/0/Ez64Bv2Pl858b/f8TwLMhhP/0Xbz7geWRgtBD7fGlJnTpp+AeW0ARaJ5smV4X6lcqTp90uGnAXWip9gX33ce6lenqKe4bW5ivzaD0tHsw/1hDcWgxrRLTqn2YvWxYPN5xOq+wjVC/WFMcWkIQyhsl7bWZkumcID30M4+/NWHyfEXzQ8ecPu4xEug6y/Hn5wQLR5+fc/whT3Ol5+i7G1xn8LVHSqfbaD57SHloaH99F/t3d5jcFqpXKuoLc4pZh/vECYd3Z5w84yivnlKcGCZ3hPbuRKFQG+ju1Wx/qeT0mzu0O/GM8y/s4CqNvYmH40+pV28WJhO+MAFXw+knW06eCBx+dwu9cPJ5hUKPf2DO9PmSxcUAHiaXT5FeWNydYv7+DsUTJ3SbcHQwpbmsXs/p508wLZgGuqcXbPzGhPLXZ8w/0hIKryGJhdBvBuznDnT73g/MtW9vGezLU+qXK/zdmqOPOtzTc3yhsc3u9Q3KA0s4LAGQALNfUsIT84LpTeUyuKnHf+4Ye7fE1A7phOJUOHx9i+nLJcfPOMxmR/jaFqe/Sck75YlQTHpOfnBOf6UlGBTy/0YNf2eX/skF7dMN/rBi9qogFxr8fiRiXX/3tnCoPIvLjv63HTK5bTj8VE+4oFutmDjMQcH8yZ7j713QXeg4+kSP+ewhbhqoZy2T52vkVk31SoVsd9QvV2x9seLw7ozutx/i66Dx8Fe2KF6vKG6VVHsLNl8Wqp/fgiCUWy2mR0MkxwX9Tk91s6C/1GE6MM/OWNyeEr6xycmnWuzNCr/XsfieOfVtg71Z0h5XHL26xfzJnsPPdJpE6FenbLxcgMDiy7vI6xP6KWz/WgUoJ8VdbuGJBe2HFzRXO93SdsXh6kDxoWPaoxr57BHlkRC2e6onTvC9EDYdvrW0uxCshsE2XiyxNyuKjx3RvrKpcf3btY73RaH7539hh81nC6ZbCw1fvFBx8pTXayawuBToPjnHLAz2fMPkjs7L9vPHzC5pOK2cdbo19XZN+8qmtqMEDj7usEcGfmGH42c8xYlhfsWzOK5xv/lI0ZRXSnwdWLy8RXGvUNRwp4MN3TLpK4/bcoRnN2l2gTLQb+iYn/7SjPqO4fSqbn2VVjCFoz2tMF/axJxYDj7bwQ8e0F7oOXkyEAo4OpxSXJxTfvQIPnWM9BAuanrX8sgwP6qZPV/Sf9cJvvY0BzXhsGTy2gfG1/sp4A9HNvrngYMQwnXgbwK/S0T2Inntd8XPEJH/ENgBfvxbXdhHqldkYWi/70QJFZcCxSsTqkM4eRL6GfhPnlB/bYb00ISS5rzHH9TYj85xBzX1x46x/3BT8xvPPPWLNc0lB483FF/dpN3VTGZbXy3pthWCFwduw2O80F3u2HiuVEb5rYJ2D6avG3ypcLH56iZlAd03tsEEQqVKzN+rMMDGSwWnT0Pxak17oYf9ivlnFoTjGs457KkhfPqE/toGvgpwfYZxYE4NW7fRbEnPblK0sPj0HJqC4gTkYwva05Kjjwkbr1qa84HCaF7po0/02O0WeXmKOSgIFxqqmxP817aYX/XMXracfLhn84tKUmt8ycbrwuJ8QbBQVJqBq9jo2PiNGfMrBeWpUMwL5pcD7qSiLkEOSsJWT/l6RT+3uE8t2PjShHBYsvjeOf5WzeaXKoKFxfeeEl6fUt8WTu9tMHmtoNs1NB9dYG7W2FPN+S0e5JxCgt3jLbOvVHTb0D+1ACecfMJj6p6D8wX1ayVMHIcfA2ksW89bmsvKlD6tavpzPeUrBZvPFpxeDbDV4w8r2l0HxyVh5mh7ofy6nvjGwtDuBrrzPWID1WZLOKmAQHVhjntpk+CEyQ1Lc94j55t3P75Fd1o0r2xSGiAIcrvm6PsWhIVlet3Q7BnM7YJ2z1HftvjXt9k4gPD6lirKhZ5g1R6UtB9aIM9OQMD+g23s5cDJdy3Y+PKE5lygv9wx+5VNDj7dM3uhYOtZSz+dMf94A16gMdhpT//hHnpDf7kDApMXavpPnTD7lRluAm5a4ATqDvyVhvr5Cc2THfRCdbNk/pjHTzzTVwtks0NuW8ojwZ7C4oeOIYC7vqGwLmC9YD90gtlpNKTwwozupU3Y8Mz3J9QC9UsVrqyYHsLic3P8vYpux2F2W9y9Ke2TLfWLFe1Lm8jVBfVvbHD6CX3e1hdrTh8LzD83x52WlM9u01/pcPsFEkAOCnwZkMsLJv9wyvxKwHWGbhP45DHuhRntjiN8pKN8YabXepArc07dFL/lAM2eN78MoQr0Ew2JTJ+vcHXFbB9OPt1SXasAoX2iYfOLNe5erWS3HZi9bDn+aI97ek79a1PsgcUX0DzVYqc97vaEjdcMjVjcloMbEzbuCKefaNj69Zpu0+Bf3kE+0oBY8FB/Y8LikqffcBSzln4jjj2nEP3kuZqTD3fIooDaU94smdyBxfefvOvx/SYj/1uWyEVEfhL1pC+IyKsos7wECCH8eeBvAL8H+CZwCvwz8bu7IvIfAL8cH/Xvx8+eAP4t4GvAr4oIwH8eQvgL34r6PFoK3EN3d0J1y9LteIq5cPq4h02HP7DIszOapxuK6zVh08HCIAtD9dJUt9N8OiAVlNsNnaloNh3T50vmUsPH5pRfm+J2ehZ9oYcdHBkWjzlwYL8yQz5zzMkzwuR6QbMH/dWG/k6lynbWgw0U12smt+HkuxvCUcn8e1rCSYm3MH9SE7CIg35mKU4EfzohFEEPqXj6BP/cJtM7Wt9QalzKl0o6m71scBvQnPOUL07BQ7sXKL+0SXiiQ2Y98093FJWj+JUZzTk1ehwVXOpAoHhtQnPOU+0bwk5Pd7Vl8uVNjj/dIZGo0m1qEhjx0L88Qy43uJtTTj7csfn1ktPvWsDdCr/hkIWluaALJ04Iz5zCfk393ITFxYB4YfqrU5o9NSaqWwVcm+InHldbNr+qZzHL5QW8PsVtePAGcYLfcJQvT+kudGy8VHLymYaNr9acbhrkqEB6ob5b4kvoPjrH3JhQnAjtxONqcC/OcN97Cp2hrB3zoO2JBIrS42Y99laFm3UY6/EbhsWOh04odlr6vqaYKaGovTPBzHUR7A5K+s/OCb3FzmHjVcPi4kMY36eG6euG/nuPac0G01etelenBdIJJ094imPdiie99lVz3mNaNSLbjywIJ0o4ClXAlp7mgsfejHyQm8LJdkH3fceEl2dAYH4lKh8HR59tqTZbuDvBHlrcNDD50pTFFU91ZHCTQH1HaM4pi/r0cwvCSale78sVp0/32CLQfnjB5LkJ/adOqL5ZsPjQgs1f2aBVPhrtBYfZbgl3asJpSTXtdCz5QglYJuBvTygPLa4OGC/wxJzyxSndYz188pj+pRniYXEJzKsT/JVW49iuxheqhPvNoGP+G3rIiK081ZennF4N+PMt1fNTpkcw/545BvC7QC+Uuw3Vr87omim+Ar+piq39xBzzzU14eg53aqa3lWDqq0CoPbMvbuAqIBS4SaDc122ni4vC7BVLuwOLD7dwaum2BXunpDhRIuLGN2qOP9dQTHqqX5vR7noaMUgvcLvWw4OuLGi9MP3GhPnjlo3XFEANBuyRZXpDaPbA3FMia3ehw0575HZNuNBwumOYPlcRpg6xgf7uBCvAfkW345WstxWYPV8yvxIzXl5t6Oc1vLTx7gf4m8hDIqC9jfeEP/AW3wfgj77Bd38J+Esrn70K798xaI8UhL6WtaxlLWtZy1pU3jcFLiJPisjPishXYgabP/FW9/iNYa9t2FXPqLpr4NhSHoGda1rG7mKHObLYU0N5YJWl+dmGyYsVvoL+3oRi1lG/WjJ/zGFODcWzUxaXnMacrzb4qae52sHUaczVQPjmJrMXChZXe2wL9mZFdSBMbmoc2twrCUXAVzD5+oTJ65bJl6ZI6QmFp7qpCViCgGmEdk9zERcnur1KvrpJv+0IFrodIKj33ZzzFBfnHH+8Y3HJYS4tKE7QONmlhsVFh53q/t3QWrp7Ne2OelWhCPq+eyVivXoLNtBvBOSgoLu+weKpjsnLpR7e8ZpR6Hyu76/uiZ4lvdcy+2aJ24DgDOZiQzHrqW9aJjct/l5FmBe4uzX0wuKCJ9gYYqj0eZvPKeDjq8D0dUVRFhcD/SzgDiv8uZbJdd1/2p/rqa+XVEe6+yDJ/NMLhXeDxqddrUiB368UBnyiZePZkuZcYHJb4JUpYoIeXLHRYyY9s+dK7HNTzN0KN/NsPFsht2rY6JHGIFbjpGz1uDs18uIGZrNDOghlwJ4azLUJxY1SY6XfO6f6yvRdzwlfQrsNfG2T4ljbTQpPebvAnm+U63C+p/kuPViluehgs6fd1WNZyxcm4ATTCrPnC9zticbxT4Tjj/ScPO2YXCtwvcWd7widIZiAObWcfKIjeMF8aVPnp6ZaZ3E5IJ3QPtHqPQWExxb4mxOmX5vA1DF7UcMt0hpcawhHJc1HFribUzBgv7nB8Wdb2idbwnEJHnxvCLsdG1+vcb1FykB1Tyjmgps57PmG7mpLMRc9kOhWTT/zhM7QNQW2EfrLHW67pzgVQqO7I8J2p4jYuRa312NaobnSM3/cUTw7xfRgWqF+odbz6D/TUrwwpfr6FDPpYeLo7tV0M4WU3RSKnRgeCWBbKL82JUx0rzwmYHqhvllw+vGWds8TysD0dUO36+m21LVcnFdPu7xWwYbT9u2E0082Os8LMPcq+v3IDG+EfttR7lt8FTCNULw4ZfqVCfMPdeDg9BMti8/OCUWg3+05fTzQb/m8RbC8VRJu19iFhmLkuGB+1VHsF3BUwKyPya4EP/W63RN0C+dei10IeGHx4Yb+Svuux/ebyfowk3cm76cH3gP/Wgjh08DngT8qIp9+sxtkYajuWNxH50yeq2k+OWfxRIdsd5x+vKX59JxQBsyJ1W0kpW4nKk7BFB5voX9yAZXHPL9BvxGo7ln8+Y5+I2Aag312Qwd7hN9Da2gv9rQfWtBvek4+0lHfLBSKBRaP9xgHnBb4ImBPhfkVz/wxVcQnH+6wd0rNRXzR4aee0yeUpDJ9zdJcdDTPNHRbgX6qW3tOn3a0VztOPtzRTwPVPYP55gx7XDC5YXOcTAIKYU483JjgO8PkpZLJtYJuzym9c+KxRxY7F6rnJzqZ4yJnOiHs9ExeKulmurVH4/mBdlv3rZ8+3dOedxQvT+g3UYjTQ/n1KW6/ot3z9BuB+o6e1V7dtbDdIdHW6jfg9GMtvoCTpxy21QW0ueDVkNj2er75kcXe1Bho+4k5Zm4o5ro9JlRe448BJWldU2OjudIrjPp0q4knDgUpPKefagiFKkPxgn1Jlevk6xPCUYmb6pnKpgWmjtMnnCateKEmVJ7qWoUcFky/UWPnhvJEFU6ftoqJnqXd7zoWH2noTwqaT83f/YwoAv22o326UR7HOY8UHrehe/Sn16wq9K9tsLgYqO5a7K0St+Fxk6BZ1vYtoQjMP7PQBXirY/GhhumrBcwciysan5WjQg+02Tf43Y7gBFPpmAWUMbjXqhF4dcHk+YriZsX8Y0rcC4WOEU5tDJXouQKm9LDZUz83wSwkGqMes1/AXJUsM4e9WWFvVpw801M8O4Vji+nJStHfnDB5odKDfvYc4kXHOagSf3qBGI+d9poA5vWCfssDgq9V0VevlfSbmgfCHhmaS47Txzz9uR43DfRXdFtev6nkQfPqBHOn0u1hT7bITkd7taP48ozF4z3VN6YsrvYsnmmxx4Ua/60m9+meXlC/WOGnHjdzqhgXRo2Fu4Z+r6d7rMWXgeJ6RX3b0F3omD6rhkQ/U0Vfv64hNtML1R1Lt63l759c4OpAcy6ooWFAjMe8MiXUXnPVm4C5oIaPm3n6qw1hp8M/scAXgTBTg89fbqjvGOSgxM0c9V3BHlr6JxfU+wITRzgucZOAlJ7i9RpO37toq+7hXivwdyLvmwIPIVwPIfxq/PsI+CorG+NXRYIOdPOiZnXyJ7rP0V6bYA4LghdCHTWH6BrUX+rwFnxnkaAHaJhIUnEzT3u1o3qlojwUZbcWymQNRaC+bUEC9sTiW0uoPdXNkuZST/tYPODeC81eQDY1xtzPgipO1EMypxY39VTPTpFWKPatZtgK0G2BPTYUr9VU9wS37UACofRgPeXtEtMJJhJM/IZj8eEGpg5fwvyjLdVty/TlUlm035iw+FDL4pLHHuuhBxQev6uL3OLxjv7JBcFr8hp3oaN+qdIEFjM1AuZPdfR7Pf3lluJEkEpZudppulfZxrhzKBVN6K+0tB9eEAqvC36rh2SUR0K35aleqWjOeyY3LYtnWvDaN9PrFjPXIegutjmSVDyvmeB8CfbUIJXHTT00yhvoZwFxUBxYVXJHBacfa1k801G+NIHDkmAC/ZML7CIWvTeZsBMMMHP6uzEZpVg81lPeLulngcktZQ27SeD0qZ7QG+rrirD0l9royViql2uk9Pj+3U8laQV7quMBAYqAvTbBF4FuFmgueupXtL98FfAF9Hs99W1L2FbjwjZx7J8UuPMd9Us1OMP8qQ45LNSju1UzuWkIldbb3impbxSEkxLxUN4t8BNP2K90nswLFlcVLeJIkYnqnu7ekK0OX3maKx3YgFybIBKYP9FRHmtCnvLQ4Lcc02uxnI1RctpMDZR+pqjG/JMLmss95tRS7SuJ0Jc6x6SPv70OkuLlCX5RUD4bkY/Y/PVLlQ6uVr3Q4sSoMj8UTZJzx1DeLugvKgLRzXS/OTNHEJ37vozjwhmCh/lTHeXtgnYvMLmu64x0wIZTLs6xwdyoaS7qmJCFxdcBu9AshF1Szi9V9Hs9bsPjK6hvlMw/1NE83aoB5qE95+mfWtDtOtrzjvqOpbhZKblzIdiFELzArCccVPRXG+iFMFdjzC0sHBfYEwONxdytqL4xpdo3Oo+9EFpLv6EKXRod58WpIHdqTp7pMQea5TJ55MUJULt3Pb7fTL6FqVS/o+TbIgYuIs+geWR/8YzvfkxEviAiX+iaY+yp0F1Vj45SYeliAWZuCIcl5tTipx4aQ7VvKG+ULC55ZZYW0O063ZozF/BQvaZn/y4e05zg/cwrPO81M5P0CjOKCRR3C7pdh7QCneAudJhGKI8FHyG86lDwM0eoPJMbmifanmpeaD9V48IXAdOp4nOXWkynBLfqdqGL9rF6s75Sz2ZxxSFOqG4V2JsV9UsV7WOapKPd9Sw+pPBW8p7sXLK3aG9V0Bj6Ky1SBILTrT7SGYX8jV6PVxi/ulVS3C2YvKiKgoXRY0EngW7b01xyuHMd7RMt0mo619DqYicLzQ0+eU2h5eapFr/haM85wsQpyrGvW2eqe4ZQgD/f0jzZUV7TTGeLy7pwded7Flcd5YGhfqFWeNQGjNOQw+Kqo7+snn55aODUgvWYDsJU83uH45LmyY5QBK3P+V4zsrXAwuC2HeWdAnusxp09Va/fbzgWlzyUnjBxFAeWyTVV7GZudAENUBwL3a7XLHLvUIGPx3e/0BPFQhEwvWZl81WATe1LaYXmSYWy67uGUAbKOyXddkAOC0ynpDYiWc/cK2mu9FSvaZ/6mdPxbwPtbqC6Y2j31DjypRpEiyt6cpubOexCc82budXT5i5qOMncqWifaGiudoTe6CoSBHurzOl0p6+UzJ/qtL0MMDc05+NWxGsF7mKL9EJxo8IuNBtY+fKE4sBCNNT9ed3Kx2aPbQRphcm1AjpDv+mpbxT0s0DztELc0ommRJ0oTNye14xo0hlOn+pZXHG05zzdtqIs1e0C20J7UdEqd6lVJ+FSC1NHcaNk+moJQZEE0+p8m1wrcXEshdQ3DthwuE1FlNym0/G912E6obpZ0DzTMH21pL5t8jicvFhS3Kio9o0a661o7v8jJbAtHu8oTnXbZbftcdOA3KoxdzTTYXG9hiBMXitodz2h1znZ76pytnOhOR8NLMDsl0jp6Hcd9aslzHpMJ0q+8yCNwe91w7pwr6KfMRjxa/m2kvddgYvIJvBXgR8PIRyufh9C+IkQwveHEL7fbs2+9QVcy1reQ1mP77Ws5dsqleojJe+rAheRElXe/10I4X98y+s7JbTUL1W47Z7JSxXtRafELgfFkW7zKe8W8cQjR/dYg+k11huKoHsbX5zQXHLYudFkInHvbLBBY8LP19R3DX7TYU/UEpYjTWZR37JU96wm7jgpKPcN3WZABKp93VZij9WLaM7ryT6+irB6hLBMq/CgHBSEztA+HmPGAczCEASKWwrXtucjdBXAl4F+19FtBeztEnOvpDg2lNcr+l1Hu6vbZtwlTYfZ7qo3BxFanGvMVALUNy1+4mnPO/pt9Tabq3oil12ohys9Gie9rZBqtW/QfJCCvVkyuWkV1jsqkMOCMHGa9GMj4K16gMW+xl6lMXTneo2L1tGTr6G8ViuaMQkUJwIbjuqOpbqpMGBzXj2ZUASK/YLF0y3djqe6a6lerqjvGrptT6g9cqDQvhitd3XXErwmsvFFTLYiGgYo7xZUNwu6yx3BBhaPdRRHSuAjQqn22FIcFLipV+LiXDT+fadAnNDuKSHQn1MS4LuWoOiBrzR9b7sb8HsamrELUa/PBOqXKppzHl8G/MQruS6GAap7hn5HDxQxPQr9nlePSxZGE9qcGNxer6GWRuvkpp7+cos5Ncyf7JDS42ZK5LSnBnOqkGry4IvrNYDuY64dUioJytcejkoWH27Vm5t4XB10q2fpYW5ZfKTF7JfqZaZxv1/iC/X6TKvoE0eFetovV4qW3VMkK4iSCduLvZ5bsB+JcVOvW6SKQHe+o7pr6a+0SuoC2Ogpjg0Ueq9tlABZ31DYOXRGy3RUwGlBd17nQ3mn0LHbCuWRohZybKlfrqiuVXS7jn7TM3mxyl64ObG4KmiimzLgJkpynT+hREACuBqaC17T8Abot5wSWg8M/QXld9gDDV+YGLELVglu0oM9MfTbDrZ62m1NoVves4QyIK1Q3TVKdJ1qKE8OC9xWT/X8BKm8phJeWIpjJcz5Sgl5LAz+vIa0TCP0mw5zt3r34/vNhv46Bv6O5P1koQvwF4GvhhD+zNu5J5SBbkt/ECVbVbcs5b6ln+piKk4XI+kj6eW0wJ4KzK3ChLcL2svKnnbbSmQKFvBgFwovLy45midbzLHFTXSRC1t9hAFdhrXTgh7KgL1b0JzTeHF5EGHHABRBocsdhWtNj2Y/iopVbIBOB177eJuhs25PY4dYpQOHSvfe2lONLYuXHKtvLylUaRpRpfl6pYtxC+WBxhv7mNddej3ys9sMFPvadt5CsV8QbBigMhPwdaDf6wlWleHi8U6V5islxVzwBbhpiJBtoLpZ0j7e4Ta9Tv5WsHOFSevbFmmNvqMXqttWY4Glkn3cdk97sYfO0O14XWAXgun1PWG7x5cxx30ZaM85hfVnATvX07rECc2lXklondBc6Zi8Vsa9xbC45HI9uiutZl+7oSRA8aK7DkD7wwtur6ff6WHmqG8UdBd6XIw1lwdG98o7oX5Zj6Z913OiE+xBoTkMeuVk1K/EkMkFR/VaCccFzUWnxhSaZMjtOGULP9bTXHDah7Wn39U4v1kYJQUe6/5wvGYSRAJur6c4jOSyEyXASWs0LCDKZO43HaYTnVOl7u33VaC+XtJe6LG3FQbuNz0UcZwdFsq27kR3jxwr90N6oX6pUkLppqe91Om4P9Hx3FyJ/b4QxKkyC1Zh7uay1kcaE4lplvrVErMwtBcdZqE8BVpDebvU+Rd0PahuFYReD7Kp7lgIwuKKY3FBxyqzHukMvtCMZMWBpbpRxrkTyXMxRCW9zvvmkqO91FPuW4ojy/zJDk61DcsDg68D7lxPKJSUVhzFo1Qv9xqO6clZ/JrzXo1joL3UK0/HarjIzA2Ly2o4BRvod/S6/nILE0f1akV5LJTXK42lo4q32w4snugo7xa6O2bqMXNLt6thlup2QXFgcRMIlQdRRnp1q4B5oXvwOyFUgfLwg6ccHwV5Pz3wHwL+EPDDIvJr8ef3vNkNKQ5azKPHLJoUwldBtx7taBpVP3PYRnQC1h7TQ7Fv8TOHaZTg4mp0kZ4E7Fyo76iydtt6CpbZL/EbHtNpAgsWFtNogpEgKBt+R5WIxGMR0yLXXHSYhVDtG42XBygPLG6iHrWfKGmnODEUNyuCQSfNSUG343HbGg/3VcAeaTxcWqHf07ONU6xeAvS7qlBCFTAtFEf6Pjku6GeKANgjgy8D1Q1FEQjR69rwOWFLd75DOqMcgOghiBfoNZ7WPtZR3SgjqzjQbasXYxrB7cQyFAFzoElH+mgcdTtejRXRRcJPVAEgSh6yjeC3HNKZTNwKRYBOFWR5oGUnnvNuF6KLDZHUeE6RFRf5BdXtIpPhRDRmKR7aC7rQNle6jKiEiXpOlB5ZqBHgqljvjZgIyGn6TAB7YDEnln7mwWic2U+8Mo4fwnHJyfuXY5vJmL6Ads9THOluCApdVLtNNVzEibZZTM6BgD0sMPeUD+I2lBfgZy72rR/i/SeG6nqJcUTeRlz8W41rFwdWk4EstA/cVuQMnAq2EdqLjup2oTHUZDQXAWzAbzjlWNRe51wZdGvczCnacaIkOrGB4laJq9VgrG4VGus93xOqQLfjle9SeapbFtsCpYc4LxdX+0jcU+XTXlDjB9FtecWNCtOJ9rOPHvSOpzhUJc1MCZ72dqn/k1jv5GeIj2TKSL4MVtupumUp9i3dhV7Z7l6ob1mki4Z9EQhelWmwutUPorFcaArjUCj6YxtRIq4FnOC2euq7huYxJQlWd7RsxYmS0cSLxvFfU6XdXHR056Jh51Tp+plD5lbrbiMBr9CdLnKobHedj2CPCzXMJj4bfW7mNbvd3OTtcO+FBB6O9/1B9MDft0xsIYS/x/uYwWYta1nLWtby7SEfwPD1Q5H3ncT2IBKsemTNpV7jrl4oDpWp2+55JCaxECf4MtDtOezdgnZv8MLbC5pEoTvfUexbimO1rJtzHtMYCEJxaPAbjlB4TNq6UQSK0wh1n1Mor9i3mFbfWczjO7e9eqDnemWFGpDeKHu0F43jL0T3cBs0/mVC3JesELk9LmgvKRM+x2QnHjPXmCIyHLlY3SypbpTYmOqy34xe1EI0AU0Z00keK8zI3ECrdfYzR7+pnossLPbYYBeG9mKnkKNVL6+8U2DvqPXeXdA4ttvStKj9lqfYLzBN3HZiNAVtcWBzn7g60Jx32mdOYdjmapcPrDAHBdUtm+F1YhKRdtdryMJFj/HY0G/pM/Gaz768Xar3LeC2e3wRIkPcYO/oGDGtqOe8qfdWtwvCxGt5eqF8vVI+xG5Pv6XM9+BRONjr1sLmSqfpdY8Ndq4sYnGo59fC4uq7d8HFxRhwI9TXS5pLTsMGc9F6N0ZzHFiNb/d7kQntI++i0/EjvSIDvvKEmINbOhO92BIf4dRgod1NYzn2jQ24mcPNHP2ebulyWzFpSS+4DU93odcYtYlx6A0N8diFtnMo4lj3qKc8c9CJIgho2CHB2+XrFf3MYxeCj9sji2ND+XqJPVZmdr/jkGNLc1VDPwQNcWAVoXKTQHm3wM3U2y8PrKJxG57uQocvQp7n3bZXKN8pn6a4VeqWvFpRlH5Hk6e0lzSc0s98Tt7T7rq860G8MuXdNFDdLDC9YI/1OFB7omGg4shS3i3oLijqlcrmpl7rNdPtngRF7opjhfjLexHiv9pT3ikoIzJQ3YtzRHSs+BLaHa8Hzty2GTZPCAugITgbsIfxeGQnGYn0hYa+2gu9jpfofSMK3dtTbf9Q+xzyW8u3lzxSudAJMSnEwlCcih4IEhcD0xpMjJmCKvVQetxUF4x+pgtMec/qYtiaHEvCKSToJp7yri5ABAF0v63bctQ3Nbeybq+IsC66IASDwnpOF5ZQKQHKLHSiuw2v5B6vi1oooK91EpuFKoNQKSHJbyjkZg8KhaE7hc99hN+k09h+cGp8uIlOaD/VGBZeMJ1R0lKnCtVteuTAgkMXklNVgObE4qcOJmqYSG8wDlxtc/KMtNi6DV34cFqHMsKexZFR6O6OVYLNXLf4FCeG8sjoQl9qMhnTDe9x20HJQbsuQq9aZ7/pFGqtY2x86vXvCMsj+g68RANEoUvTCy4aK26qRkkoQTrdOljux1hfIZqFbqHbbbotVR4pI1mI5y7bEx1D0ml90/bEbqJwu9vSrUr2WI0AeQjrW7DDD8Kwl99L5CYIbitCmnu6tVB6AaPGI04VLBITulhVTG7HYQ+1fwgKm5pTqwovZu3qtzWGbOdaXzcJuJg4pbhb0O/1FPeU2FXfLGjPKSnOb8Q5JAEfEyeZE5sViLFgb5Y574JE5ZmwNzcNOl43goZw9nrMsc1bKIsTg12o0aLjUQ1nNV4Ev+mQQ4uv1dh2Mw915GVMvIbRgO6c9lcKp7jNgD1UozQZOX2v60MqZ3tB+QHOQLel+Hm/GXRPetDxV90uNA5+p8hz0e3ofnAkKvhbJUHAbeg2OtNpP1a3CtqdaPBvKqnWNKKJe+4pZ0d6JQ4iUBxpbgTl5uh6YTrBLyztpZhFEE1I5ctAcU/7zR7avOef0keSJrgyaCIaq8Ra0wj9llMj2CiHhU5Dhu+pBD6Q8DeAiMyARQjhHW20f7QUuKh16U2Mad7RjGjilWjipwEX0HSSvVDeLnPGMZ0gOvBDpTE0ijAkEtlQBdyd7yn2C8p7lm5PY1T2yNJe7HVSogtQv+N0MjYG04BDY1MayzI5Lhuip2IP1ZOxBynJgyQbQU8ha+OiE5WO6QW7UGOi3/Yaw58EZXEHg2l18ROHKmYZKfh4uAE24OPz+01lj6syLXDTSIwTMCexvBter1+I7n8vI4HOCsWRzYu4m2lbZc9lYdSYCjFRTScRcdAFyMzVg9A4p6c4trqnficq78rji5g04q7G/n2p+0LsQp9F9Iil0X3FofbqrZcBOl2QpFHCk3qXqoyU46AKrziwhEI98uQ9UXm63ZCPlfVVQJzJrF/NB6ALJRL37zaCK1TR+coTjGAPLO9WUvY6CepZiVdvNNhhd4I90j3rYaIXBqPj3Z4a3KaOkz6yohUl0LIlAxG0nPZU8BMd392eKpHUXr7ySug81b3yfTRaxENxaPUEt6hcfSOKTERloQa1Kuh+S/dXW6zyKrwy4JPBUN6zeb65qSJgweh8VQVCJmWJG9KLFoexrT0gipD4qYcp2EOdXxglh7qNgJ86Ld+mGrkJtQtFNDjmGjf2E08oFIWQNhpPAeVINKrgUiIZQqBY6DOlSdyRgGkNcqoedL+t7dTtuTw3UYcbc2Jp4wmEviRmdFPlHrweboRRDkC5b3U+eEGcGkLFgcVPUDSmEzxaXl8ELGqk2RPJqAmFGsyujyhliIbtqcVtaO4Duyh0PgFu4pFekYziMBb6vZQPiIMvIgb4/cD/CfgBoAFqEbkN/HXgvwohfPPtPu+RgtDXspa1rGUt33nyASKx/SzwEeDfBK6EEJ4MIVwCfivwC8B/JCJ/8O0+7NHywEOEnMsAnUKCusVFvQUW6hH6OmjK7j2FDkFh7+StJ28mRNZsij37MmDvFbgNhYAlbqEQL5R3lNVtGrXUi31l+Oo2FfW83Uyf5abRui8D9lg9WbelEGU/09iYj95vcaLl8rXG2bxVb6jb1Zh4YrG7qcZCxQmykLwHGAfFsc0egumjZ7yhsTS/4/C11sE0ghMtny90r2iI259MI3mLkZsEbBNZ6r2oJ1Rrjvlg4+EoDopTwaftU330LuLWthQDVc9KvbQMn6LxWxP3JcuJnsPcbTh8FbNRCQpBTnSbnhN9RzDDNpkgcUuRUfjYBPWgzcKAqPdi4kEoxZGGFbJHItHL8RoW0C2IgoSQPTEgIwCKCJDrYBLScWoiw/7duxBBNAZrFhrK8IV6Wz4+u4g8hyAMSM6phixMJ0gck2nPdihTVjdDiHC723QaPtrU3QmJGS1eNENgI4iLMd4tRarsQuvrq5Djt6aRfJ9d6PgtDqzmtj9UBrM4RVe6bUUTMGnfuuTtWeVdPUMgFAFp9LkauoiOvI/HdRYQTPRGC+VKFMc2jwd7oNB3GrNFjIObYyFY7fviwOadF8GEoe8iXBwK9Uztkd6Li5B8rKebBhA9LMRNA+LTQSARyYr8FkzQPd2HQ/ncxvAc08bDSxptp2I/lnWEQPS7fcykZpQJ3hpCpXXTlMYhxtPjzoNGy2qPjXISTFx/5kbXs3uKeBVHVvvBxDkR2fmmi0hTPFKYoOuctBor99P3NpXqB0h+JITQrX4YQriL5kT5qzE/ytuSR0yBx99GJ6DbCGDBG697hoIu6vZEFTQu5nuOp3JxxiKrMSedXJkwExOLmEaQSBZLCjcUCoWlhSIUmt4TjyqHOu5Hj7Ejt6Exe3Nq9dxl0cUu7ekMVvI2Kx8XXCTGNoNkIyHBq37q82lcEret9TOFyDyq6ItTNXS6PT3EQRctrUdxrCQa2yhBThbxtKda65u21fk6Lgwnej825O1voQqEXjkDaeucWAGnIQATn91v+bgw6iIZJtoWfYwf+4nPxoIXTcTjNuI9pT7XTyJUHrfuSK+LjdtQspC44fm+1LipxhkNpgkajz+KW3AObA41+DIaCWm7XCCT4bLh1g6xydQ+iYTnLVDGvAOTmAzo3YqJ5enBTdLWJcE0amz4itwmbkreHlWcRvLZJGRDJG0TLI5UAWilRRPriLZLiOPKzBV+dZMQ97YzQMsG3KYnNEMsNBlkvvIUh5pX28axUxyaPGYhcgfquP8q9hFxLkkMT6RtWoi+yzSGUKoBk7gFOqZUiZqW3Ce+0Hf7KmBPTOZLBKPv7rd0W6jGpFVR+2KYB8jwbnsajTyvxppthBysDyBWtzyJU6NF/KD8MRpOIRqAptGtddkwjEafLwO+0DFEiPH8tM/cBCgEXMg5E0KpYRA/1fHupl6dEQtdVKqmU+fDRCWuc8Tkdc0eq2GAIW8/NW0kRnZqtPgqDMQ3iFwIDQPYhRD699a7/aBkUQshdCLySeBHGc7+uAb8VAjhq+mat/u8R0qBS1xkTSsIOliLQ/VKvEUnlSjRxW36PKHDRAe1XYgewmF1YZA2KupWmbvBAD5kDzAlbtC4qDLIsSF7bKlMSuyKlnXt8x5QYrxMArjaZ1YnXhUmykvKz05Mz5DiZB1Ylzx0XXATiSwtPsGESEwzebFLC61E5WlajXFr2XSS+jLksmi9Y1tE70iCsptDGYa2q7Ss5tTg68gGDxL7xMSyB9wUrZuTjDrYZkAm8DIQnqLC8NNAH/u231JUJcVZg4kEoKhsfWQF+0o9DayWMRkO2AC9LlYpy1hq12QI2YUsGVImjGKIJ0bDq3HRTX3kNvTgirSI+lKNrSUk4t1ILFsoY+x/Fr29jXhEpI8Kt0vjJcahJ17LPdeBEwqNMWveBHLf+MrTbyn5rThSfkWoQvYyRzNN4+Bzfac9iYQ0pwmB0gEjZj6MWXEgJhqFkSfgS2XDm3nMuLYY5pXGn4d6Bh+zuCUJWk/NYKj1ziz5aTKmoIjZ3pRLoeNXXCIDRmUu2h7FkdWscEZ5DskA92WIhjFK6jPEnA9qEAchJziyc4OfqOFQnMpw+JGQD10xi7iexORLRCRB+08yg1/5DfE5Vietm/pcz6Tw7alRoCgawCkbG0Yigx1MXGvMQpV1Wl/SGMDoepDm8dgYU+ONzJnotzQ23890PiYewnslgQ8OiU1E/g3gDwB/Bfil+PETwE+KyF8JIfzpB3neI6XAg4lwqtVBrRapLt7BKMyWFx7IMF5iCfsyeml5Xqmy9hOP7VUpFSfKiIW4VSsuCukkLklJK6JHK61kpnkmIbkB5oKoLFuTFy6tjFr8bqbeinE6Ic2xsqdNSrIQFbtplFjlpoGQiG8x4UqInkpanExjkA41cjb8AJ9H0pL46GWWuhAlAyZ5oqGMMO1IefTRM0reBRKNgli2YEMkx8Tyt9rGfqLsdd1OFxeZuHCmuvkqHsCyoaQccQrnUqAEwLxtSzK64WNGMNCyBhkW7WCj8RQEQshwb4jbr9xElVCC4YNVb1K85HY17YB+JE89jcHUpxkhMA+JqRsTaPjKY9thQccnI0LLEgTlosW+98nwi8iARKXr62gkRTJY6idFLYIab3YIbfiUIKeHotP7JaY1VQh9hMik+nolv/moyFLiE50H5PSqpjEZDk8icayl0AA+hrqK6KmbwQgGQbowQr7Q1KwyzAWtB5nAZ0/Vkzc9Smib6kEjwQ4IUzry1LSiqApDX2cCnR+hEXEbp2lNZImTw0JjpE53L6glbNo4XiEyvGN7FmS2vXhdw+yJIR0Oo3WKQyOiAW6q4zQZtGotSSST6nqV5kAaA4oS6TjSLYWxRTvJ4TVx8RmNtqMiYSa2fMDbD4iL/N7LPwd8ZtXLFpE/A3wZ+M5V4GtZy1rWspbvMAm89yz3bx/xwGPASyufXyVjcG9fHj0FnghEcV+jibFHyUdpGrU2A3nfshKboqWd9yITSVcjmCnGpxNc5+togaOeAvE/05rBGzLEGKy69ckaN63gWYbxfD2gA4RlYleKV1Ek/Fst4+yplhp3Th5TKGJ5K/Vu3EQ95QTFJejYNCZ7OmMY0kfPWj1/srdm51pWhegSJMfgBcYYYvIEs7eVjj91elayxiolJqOJXnCMgwaj75Lo/UqE75EhXig9OS47eNtAIqq1A+SaSEW+VD6CiXF6hVMHLwMJuNGI7yNCk8qfPZJu6Pvk/asno22Q4FVfqVerFz4EDyUw8DwibB9M2qs7HoPxcqsQfuIlSCvIJOSYpkQPO9U5xCQ3qQ2z951CPWlfORE9sWBNhMMnEZIVyYgKDBwS05ocRtI95CE/M50Z4GLZxKMeXZDc9zpPYriojKhR8iATMlQN80WRpMiTiPyEhHCZeN54KId5meZhQqRkBLX7Or4vzunUtmkbmS+Ckj3j9tS0L98XYEz0qkXRCa2Pkl2kI4fTJI6hxAnBR8JcXL8S5B0ighJiiEni+hUS6hgRiuRVJ5JaRvhM8vgH4msax0HIBwMBmWAnTuuTdGhCy/I7Fga7joE/LPlx4GdE5FnglfjZU8BHgT/2oA975BS4yfApmb1tIlyVyDcpI1soBsUFquzSgq1EMR3EEshZx9L+y6V3VAMMRsqMFjMWJXg1L+QGkJChwqWJ1cV9yjG7lhnFvU1jVAkEiWUaFlIiPB1KMqSbIGvjVUGbyAJPRKh8spDRWDZpgUp1j8QfiNC2JZ9MhZBzJKd4fCK9JcVmWlGjKcHL6RAUGcX3iVCoBHwdjaceMIJEtroaPVoGX0XoOsasU4w9xfrHRKC05zYUSvAycZu7LwISFyBfBuwoGY14URJhJJ/lUMs0jpFoXCRjMJ/J3o/GV1xYEz8iwbxJob1rsVqvNOaCjOofY6wpVKCNFLLR5iPxMo/L1C2pbpZ8f8rpnxUVMTtgDGmYuGD7mOwjnTGejdrR3EhzypceExW89GpABgM2tz+5HU1UqpqESfB1DBHEUIn4mIjHD9dJUpyjMJjx5MOAUpayzHHJxiXofvEwSn4Th6iJRv/UI10aTyG3TyqvL/TEQWLTpjnhI9Pb1yGHtEw7sNt1UJKNzUTC9GUY+iHVL5I1fVqVR0rNLmLILBkkxWD4atglGpyxTPpcr2NDxuOF3Oah0LUmh05i5kfNPLn8/jze1/KuJITwv4jIx4EfZJnE9svvJJnLI6fA80LQi/KxUgKTfogB2iayPJPFzKDQ8vdJMcftMdn6tNFTjRNPopeSY57VsIDBYL2m2GP6zEQPLWVsU+93YEonBCGRshIBTbr47nhyWCKU5fcmAwQy6SzFfH3MRJYXVAsSojEwim0n8o4EvSYtgilTV47ppYUleYajeHBauNPCpgS/WMcJmRmc0lZmlngk4fnkYSaeQBXbQAbSFSaobZDYwFH5ZjFh2HaU7o3kt0QcSv2WvBr8UB4kPqOLLF0ZFvjUymq06VhKC3I6vjPHoyXkcfauJCTDMAztXEdUoRsZCZKHvRqsgZwkZGyUpYMriHXNLGcJmQyZdjxkUqNhiLu2MrD/IxqQx0eMv6ZMcTmJSSSc59jqCBRMhCixxKOBZUkxuGQcJOMvjlFJczQa2yYhUYn0l5AF4jyDnOAkKV3t39jGse8kogxiBgNaRv2YlDdhcAh8MSQoSnMglANKlgx9L9FgjQMzGyWFjuls+MY+T564qxiMDz9C3KLxlYzFkJCRKmifJUMozY+IFKWtnan/QixXMkRNK5kcm7YdZkOxUMMhH4f8XsoHxwMnhODRPd/vWh49Bb6WtaxlLWv5DhL5wLDQH7Y8LODvWycphFzENKKQ4ShQy9XVy/Gc8Tm+NjGSYxrFFMc1vWTvNMG6yWML0VuU6I1KUCvWxDzZ41gwqMWb40gjKC97iiTPTT1W8QOqEMohNpn3nkcPN3sH8V6NjQ4xvhQ6SFQI40aemAzhBYlwXUrIkuKrmcEdK2laWTkHmlwG6WXwkPwQc01edypzTpgSnRFlfCcXK74/ehC4BC0O3pVxZMZw8jwkJp5I/St+1Hcygk9Tc0XEIG8HSt5Y7IgEz6e2yYz25LkKOfVmQjLy3t5WBu/0IUgqt0ns71YLkFjZIcL86UCPjOyk8qXxkcSkUMjghWUEJh6uk5CbFJrIW8OSZxbRpTQe0tauNDaSJ6l5/ofYcRony31HTuWZx1w5hEcGxGZAb4jjNG2fG0se0/0wJmBALILR9SDF0XO9YtlMPwplJZ6HH+ZaTrlqiTs2tOxpHUoeOhGtyohPHOsad07I2NAeph3msunSdrQYxordS0QcMm+kDNkbTjH1MSKXx5CLyEEaK6Bo4mhbZJqfaa1c5sgwbLGMXvpZ73moEh7SzyMkIvLD49/vRB4tBR4YwaPDXuIExeb9z370Wdy2kU4oy7EnP1rkU7w5XpuhTMjKUrfIxMkTIb0EV6VJAYPSBjK0lvd6O1HocrT4pxhreldaiEKE2NKiqPHtkAk4aRHN742xtPtODTIhX58NiQjZSyLkxHflDGiQIe+cXMYNhkAu62jCIwOsHuIJSON+S/BdWkg1xjlSqmH0/LjApB9JpKkIn2ajIEmCcmXot0yoG4cWItyby5QMltj3KSav5RigY2DgD5hRTNiOyv8wJNY3kZkGqPOM50vIxttynH6kqBLcGts01ecsZyeRw5YMUWGA3+NeYl8NfZvGR+ZNxLBVVmLjOZeVmGTjKI8HF41OM0C12p9Bt7qlfonKPu2Hz2PeDgep5P6N+QFSPDznWGd5TOn9cS4kw250Mk06zCYb+dHwT+vA2KBKxv14vmeCYGrXaJyGYsi5kKH9VBYf74uJqRL/IY2NXIdR7D+VRT8YuCfZcEmJo1I/BIYtpaNQRya29cvGUrAPaYyvZSz/ycrvB5ZHC0JPi1BSiknxjQbXOIYF5Bh1mpx50Md9oynmk+K9QdC4WVKe6T4PiZCSM2a5gTAivSxPEDe8K32XSCrjOHTex53KkhbY6JWmxTBdQ7KWo+eTYnxZiYwYxUkxZmJP8p5TMom04Izic7lt0x7hpPSSMh0hBWODKpNwIH4+qs84jhpZ50vxVFJ7y+A1jAyipbqveJCJ+JcXegYliAxGXd6qkti2xWhxG/VBRnjiOMjKM8RVL/WPHZRN/u4hSVI4wZD3ymemcDJy0qJrRmMo75lmIGw5GWK7YfguS0QwsuLyyx5mijvnWHoaUo6U/HDJOMxzMcbyx+Mw76gYJ0GSSP5KdU9jFgY+QFLqadylOZTuSeMJGBvkiUuQlHNScOPxm8udCGfReJKYXyCTSccG46iMS3yEqLhzfwSGPkwE2BHvg+h0JJQhj/Fx+yTxo74azeW0bi0ZzDK0SVbMK88fPzv3cRzHWYnHzx4aQfONJPBBh9DfceUfLQWeLMk0QMeK2488hmQF+5ESC7rojBevDPfFZ2dCTpogkbUcYq7t5AlnhV0sL1D5bz8olvFWjSFrVVwM4/N1EQt5IR2UfSxbfGd6Zl64GemO9M7xAii6EC0tyikjVBgWAEltkRSAjCZ1ao/YPkkBD4bQKCyQ6pe87DBaLBIxb7xYJe93tKAskQlHC2Hqd9C/x+2ZPY3Yj7lfRoYIDJ7M8LL4M1Ji43qnuqgyHZXHD2MjP+dhSLjfYDlze1oud8ieX/LgxtvicnuMt+yFkcKTUZvE67JySIRMZKl+qXxLfZ0837EiSYv/2HAcrVO5jRO0Pyo7MHi5uayqAJOBmb3rESEztUEqp2YqG4zBMRM7kcRIfZuMt9F3YlbeEQ2iVQWo5U2Gy4pS9nHNSEZ83Do39tpzuZKBkaawk+xMjOdnMGMDg7w25TUiGbC5rvF9I0h9bOOEaBCO2y7PrZFh/J7Kt+AV34nyaEHoa1nLWtaylrWsBXjUPHAZeZzJY86w19i7kgwHZoJUsjjH0HLyYmTkzcKSJwyjR/rRu8ZbrYhW+6g8GVZOMUk7sqBzXC5+TySdyFD0dG7wmHzD2AJf9Xhi3dSjHnmr0RPIse6xR5e8NDt4rEsIhYzKPYKj0z71cZsP++uH73GSUq8vtS8weG0rHlhCJJYkISjpuxFUPHhyo9tGnt/gnaW2G953H1SZx9YZdUv9mV6dIVt5qDHw5K0RtwYuISsJPh3V836vc3mMj/eLD+05XHNfCEPCEJZIc2g8ZsxonI3RDIZxttpGq8iTIhijz2X5mWGE1AwkrGF8ZpQhzasRApTnZdoOlcoYkau0V3w8hlK90kPzOE0IXILD0xgdrwN+WJTG4aLVNh9/vsRpiPyNgb+T0IpxPwz9NmwrC7kds5c9QpqG9l5BBNLYgLw2yApkPqAow/x57xHu9/wF35HyyHngmcwBeQ8u6Vcad2nhWFlkxpM3pLi4Hy0GkCG1MYN5rLgSkSxNAsnwdBha04yUnQ1ZGae4byp8ui+MY5sjeFcn3Xiyr8DNWfGGJYW0JHb0XZqgadEx4wVI3y2j9hjDsOMZPIbSx5LfEcuaobyxwbXSlundS1Di0ESD8WBDJsLlcjgZFIwMOdHzd2NlJyMY3K70XSQLsbIYpzKk8ub3jMsxjoc+BEljIRPPZHls5uvsYHjmeqwaZ6Mxuvp5yh2gRsMAiS+N9TPGQlIUS3B36udRHQbOxPCMYQySjcY8xkdKaimckfgZsf/TdwOpa+j08bwYCjMqXypPnq9RsScjOw3HsYEnKwbDONaenr+yJuQyxLKFlX5Y4iqkOowlkHe/LCnj9NuE5XYbOSHZaBmVMZUtj+H0PjMqZ2rGMQ8irQfp//dSwkP6ebTkOP4+eqcPeLQ8cFhahMex1RAtyfvW0gBpFVxSfGOFHSft0v1nKNqlMnhRT3c1rpo8xBSjG3vQjBaXkScp8fNct7HRLQxx8lHdlkg7K57ZeOFMr0qTPXs3MCzgS88beUGepbYee7JLZJdRnPzMeHNcxGS02A0e12CIyGghSs8d1/u+GH0u59D++R1pETzDq8tjYTR+lp4bVsbIqDz5OWa5Xg9rgVta3M1KW4RhLCyNk8CA5owMx7HizWMnKgwZkQ8HNtgwgISQDdzEpchDPI2bOLeSYXafZ+mH9sl1GiNGSWHEOuQ/R2Nk9Ljhj5FSXELPll+/1DdL/RkNtjwGRvN+3IbAkiG09J7Akje71FfjsTAeG6N1ZLxcZKMlfpARtvGz0jq18n+a90v14eyy5fmb1p7R9zJW0qku6dpk9L+X8ugp33ctIYTfPv79TuSR88DXspa1rGUta1nLI6jAE2ya90mO4anI8MywMCzBS0su7KqHOvbEx7BfvD/f6ocY2H1UzpEFm72yETy4BKHle0kAwVJ4IENj3F/0XO5xHdLfY9g7FUKWLW3G7xiHIMa/s5c1wMzjC1I7L3sSy5+NYdhUh9Sm2TMeMYPHbbx0T3xmYoOP0ZT88iBLY2DMnl/1ApN3nuHjEeqSnxGWvdZVr2vssT2sJC6rkiHmWOhlaHg0vtNHoxDGUviDpWGw7L2Ox9V943nkpa2gP0MIZHhHKvNw4f2PzfXyK+222tapPqvzLz43e9YyekEKC6X+jZ+lMZSuXULv4jXDfF1BqUaPzuMihdhGXvG4buNQzHhb2xJ8PW6f1dj12PtOPAdZnu9LEoZxktts5EUvrS2pLUehn7xO+VHZx+6+LCMnD11yPR/CzyMiIvLMw3jOI6fAlwZTitHk75ZXK41tjZTBeIKkiRVGgxYGhZ/G8GrcKj0uLmJnJsYYD6YVbG8JCpTRYhqvuy9emeq5BMWNFpJU5vSMtIAl5ZnicDJM1LEizHEvlooZn0deJZfKOf7ujHZfUuRxkc/lHy9OMoJ5R3W7r91G2nQJBl2BbFcV05IxMopL5AVstaypLWRlYR7h1UvEt1i/+9rtYUlUFLLSZrktVuqVoOKx0jtL6S9tr2TURqPL8hgZfzc2UvONLMHCY27E0ra1pABH8Hs2tNKrk1If9/Xo7zytVo0KGeD68TzOxtsKHJ3euzQHw1COcZx9PEaWtn6tQtqpbkuGzeiCIPcr4PEyYUbrVXrmqIzjzgmi32VnQ0Luz0Hp388Vum8+LHV44pKwYh1xnwH8XkgID+fnEZL/cfUDEfn8gz7kfVXgIvK7ReTrIvJNEflTb++mFaWx+jkMM32sdIIs3yKDEltagNIcGk38sXINKwv/UmKS0YKS7luKE48VzFhhJw95vBDHhWDJyxgbIzK6blXS5H2DuNxSve5/9HCDLJdp+DwseRb3/V5ZAFa9kKUFJFXkDK8wGVBLZQiDJzEo/5FiOkPpL1VARu8Pwx7vVI4wLuu4jgzvzDIaX++V8T8eb7lMqT6jMXwfuhMGzyuXcWWspLpnI268yK/MlWw8yBs8MxmBZ6BCSzyFNNYTCc+Mnm3C/UouVTosozv31W/V+D1rTIwV6pjDMI7V5/Ed7q/byhy6n18wWkDG/fZGa1Z6TmoWM7TN0nrCyvoBg+G0omiH70fjfdRmS9eOv5Nw37owftR7Nb4/aCIiv09E/jSwJSKfEhnv0+EnHvR57xuJTUQs8F8AvxN4FfhlEfmpEMJX3q8yrWUta1nLWt4HebS853cjPw9MgH8e+DPAJ0RkH3gNmD/ow95PFvoPAt8MITwPICJ/BfhR4M0VePKkVz1uWLZ0V72vM/7P2YxWWMz5mWd4+dlaZ/n6Mdw29jTuY4OvfL8E8Y0hO+6Pr42vWTLqw/1exhh+PEvucwrOulZWvJMVSC2jCyy3+xLktgrVvQk8d2bbyv1x7DPbUc6oy1ljZLWcfrmf8zvP8tzO8ujHSMrDkPFz4zgYl1lYrtMZTt1Qr7A8JlPdctP5lXZaQYVWGfFneddv2uYr147reOb4XEVuVudgEO4b6+PvVvvoLO93dXyOyrP6utX2CRLH+hJUtrwbZYnxPbpmtbyrsPZSM4zeO37n0tw/qw1W/l+q01ljYdQe40KfhZCdVc6HKh8QFz+EcA34yyLyXAjh5wFE5DzwDPC1B33e+6nAHwdeGf3/KvCbVy8SkR8DfgzA7u3dP6HPULL591kTePx5WhDPeuYbLdhnLe7j71fLddbKMLrnzZ71lgppte5nLU6r9622xRtdM3rHqpFw1u3j5ywtfKt1WlHSS3VZWVjG9+dF66z2HH8/fu9bKPJ8zxu1G5y52I/h96WF+h3I6vg+q1vH7XOmElmp231lWm2rVQWx2idnKeHA2e14lgJZmWNvOleWXsB9/f7Azznr+/H/K8bD+NH3GTQrf59ppK2U7T5DfkXZv+l1aXyPH7/6zreq+0o7Ll222mer7XFWvT8givVbLUl5x7/vAHfeyXO+7feBhxB+ghgbEJGjF/7En/z6+1yk91IuALff70K8h/KdXr9PPOgNq+P7xT++Ht+PsHyn1++Bx/fblffcw/8OlfdTgV8Dnhz9/0T87M3k6yGE73/vivT+ioh8YV2/R1dE5Avv8hHr8f0Iywehfu/Jg0P8+QCLiFwF7oYQmge57/1kof8y8DER+ZCIVMDvB37qfSzPWtaylrWs5VsuMoS83u3Poyv/LfA1EXmgs8HfNw88hNCLyB8D/iZ6cOZfCiF8+f0qz1rWspa1rGUt74eEEH5ERAT49IPc977GwEMIfwP4Gw9wywPvk3vEZF2/R1vebf3W7fNoy7p+71Q+4BA6QAghAA/kxEp4xNLXrGUta1nLWr5zpH76yXD1T/2Jh/Ksl/6lf/1XHiUegoj8i8BvQR3ZPwj89RDCn3u79z96qVTXspa1rGUta/nOkB8G/gjwh0II/1vgux/k5m/7bWRrWcta1rKW73D54ALBd0IIQUT+fPz/gVjoawW+lrWsZS1ref9klFjnAyh/FiCE8P+N/993yMmbyRpCX8ta1rKWtazlWygi8mdFREIIS+lTQwh/+0Ges1bga1nLWtaylvdVUhbZd/vzCMkR8FMiMgMQkX9CRH7+Le65T9YQ+lrWspa1rOX9lUdL+b5rCSH82yLyfwR+TkRa4Bh4e0dqj2Ttga9lLWtZy1o+ECIif0lEborIl97gexGR/0xEvikivyEiv2n03R8RkWfjzx8Zff59IvLFeM9/FhOyvFU5/nHgXwBO0Bz6fzyE8HcftD5rBb6WtaxlLWv5oMh/DfzuN/n+nwQ+Fn9+DPhzACJyDvj30BMzfxD490RkL97z51BlnO57s+cn+beAfyeE8DuA/wPw/xGRH37AuqwV+FrWspa1rOX9lW9VDDyE8HeAu29yyY8Cfzmo/AKwGw8a+SeAnw4h3A0h3AN+Gvjd8bvtEMIvxExqfxn4p99GOX44hPD34t9fRA2H//Cta7As6xj4WtaylrWs5f2Vh7eN7MLKqWk/EY/sfbvyOPDK6P9X42dv9vmrZ3z+QBJCuB5h9QeStQJfy1rWspa1fKfI7UcplepYQgjzB71nDaF/gEREzovIz4rIsYj8529y3feIyC+IyK+JyBdE5Afj5/96/OzXRORLIuJibAgReTESOX7tPTs3eC1reRMRkd8pIr8Sx+GvvFFM8U3G9ydF5B+ISCMif3J0/ZNx3nxFRL4sIg8ncfdaVMJD/Hn3cg14cvT/E/GzN/v8iTM+fyARkasiUj/ofWsF/sGSBfDvAH/yLa77j4H/ewjhe4B/N/5PCOH/GUL4nvj5vwn87RDCOJ70j8XvH0kLeC2PvNwGfm8I4XNofun/9g2uO3N8o7HRPw6snsncA/9aCOHTwOeBPyoiD3Ts41reQr59FPhPAX84stE/DxyEEK6jx17/LhHZi+S13wX8zfjdoYh8PrLP/zDwP72D9z5a54Gv5a0lnlTzL8Z/d4AXQwj/2Dt9XgjhBPh7IvLRt7oU2B6997UzrvkDwE++07KsZS3vwfj+h6N/vwxMRaQOIazmlz5zfIcQbgI3ReR/s/Lc68D1+PeRiHwVjXN+5Z2WdS3L8q1KwiIiPwn8DjRW/irKLC8BQgh/Hj0V7PcA3wROgX8mfndXRP4D4Jfjo/79kfPyL6Hs9inwP8efB5JH8jzwtby5xAH150WkBP4W8GdWrxGR/xdw1qL3V0IIf/odvvrHgb8ZrUGDHnc3fucGulXij42LC/yvIhKA/+oBiSNr+QDKezy+//fAr56hvOEtxvebiYg8A3wv8Itv9561fPtICOEPvMX3Afijb/DdXwL+0hmffwH47EMo2wOfB75W4I+G/Fngb40S3mcJIfwr78H7/q/AvxJC+Ksi8vuAvwj8yOj73wv8/Ap8/ltDCNdE5BLw0yLytbhlYy1reSt5qONbRD4D/EcozHmWvNX4fqPnbgJ/FfjxEMLhg5ZrLW8iH7BMbElE5HcCvw/4L0IIvyYiP/Ygzs9agX+bi4j8n4GnWfZ2x9+/Fx74HwESUed/AP7Cyve/nxX4PIRwLf6+KSJ/DU12sFbga3lTedjjW0SeAP4a8IdDCM+9wWvfanyfVY4SVd7/XQjhgU6MWsvbkA+oAgf+WdSg/LcjIfh7HuTmtQL/NhYR+T6UcPbbQgj+rGveIw/8NeAfBX4OPXD+2VGZduJ3f3D02QwwMT44Qz2ff/89KNdavoPkYY9vEdkF/jrwp0IIb3YwxBuO7zd4rqBe+ldDCPfB/GtZy7uQoxDCPvAnReRPAz/wIDevFfi3t/wx4BzwszG97hdCCP/8u3mgiLyIEngqEfmngd8VQviKiPwF4M/HeM6/APxZESlQ5vqPjR7xvwP+10iIS3IZ+GuxjAXw/w4h/C/vppxr+UDIwx7ffwz4KPDvisi/Gz/7XREVesvxLSJXgC+g88OLyI+jpKLvAv4Q8EUR+bX43P9bCOFvvIuyriXKI3iS2MOUv57+CCH8KRH5lx/kZtG4+VrWspa1rGUt33qZPPFkeOKP/6sP5VnP/Rv/6q88CttYReTPolyKd6WA1/vA17KWtaxlLWv51ko6D3wD1ueBr2Uta1nLWh5V+YABwaPzwP+2fDufBy5nnL8qIudE5KdFz1X9aRmOZVvLWtaylrV8wORbdRrZt4vII3Qe+H/N/eej/ingZ0IIHwN+hndgeaxlLWtZy1q+Q+TbJ5Xqt0oeynng7zmEHkL4OzF70Vh+FE1nB/DfoNs5/o23epbdnIXi3LmHWby1rOWhSfvKq7dDCBff6f3r8b2Wb2d5t+N7LYOEEH549PcXReSfRPMMvO2sgPD+xcAvx/zCAK+j25DOFBH5MeI2D7u3x+N/8seHs2MTZrL6/1kSZPn78f+rf8dnLd0yPq/2QbCaN3rv6u+3uvft1PGs+9M9Z7wv/3nWe5K83bKt/v1W7b367Ddqh/Hzxve8WXu8Udne7FWr7eLf4H2rn43q+sKf+JMv3V+YN5czx/dZ5Tqr/qO/gwnLdXqDz968MOH+98XP36rN7nvH6jPeqOzjR/k3GTtvcv+Z8/QNxu3SmH+T695S3qiMq7Janzcp+xvOxzcZ429Z9zfqozdYe95wzQNe+PF/7YHH99uSRwz+fi/knZ4H/r6z0CON/g27L4TwEyGE7w8hfL/dnA0jbNzjb7SIpL/jYhb/fNuSJ9N4VJ8x4FffdV8dxh+NJk4QCEb/D3JGucfPMMuTfuldq++M/wcT8nuWFtT4e2mxiGXI75Gw9M43KtcbKpjxAnSWUmD56zP7cNROuTzj573RrF8ZG0ttG2RQzqPP8rO5X3nnYktYel7uu7Pa6W3KfeN7XPfVOq2WZ3SdeBn+Tcrby3DNuM3Sc8xKH68aKaNr71vUz6r3qkI4o3+WxmKam2OD6SyFs9r344e9UTudMZfeyDB7qzXhvvYez6M3GvdjJf1G8yjI0hozNizuK1NY7t/7+uWsuo/WvTOfuVKW/LzVNe9bIeEh/TzC8iidB35DRK4CxN83H+julRE5nmBn6sA02L0M4/sszyopDDN8d58SXHlvWjjzI86YrPmdK++SMHgdq0olvXd8bX6el/Fj7qtGtsz9SCGN6nJf3cNQhrO8rKWFY3T90jWjhSJfc9YicEYb3HfP+L7Rwnbmo0Z9kZXXioEjgfuNjDOU9lLfjV62pLxGz1i65620wNuVs54zUnTZAEnjdFzO1H9nKMD7+nw0J8bXpPqM23BJgZ1liI37bOWaVcMzGxpmpX3HBsMZz8/FN+G+599nqIzql/8eP2NlrtxXj5X/x/Nt1bC5/4HLn+V5OGrH1XXpPm9bwpJxndae8XpxpiGzaoyszOn75tp4XZNwdrucVd+1PHR51M4D/yk0HzHx9//0tu88Y5KPF4DxYi2BvEiPF7Y8IbPSJE4Alp6bIcjVmbfyHAn6rKXFZLXY93l9oy/Puj6+975JlRfIMxbBM7T5sPiufDBaLJavG5RSarMzFXu63AxtsbSQLl00FHLs4af3jRerpWvSPW9DN+aqyAAb5+fkci0/T0blyjJerFdePK7rfe99mBL7d6mPzniJuLPbOQ+RkbLLxs14zPj7x6K4of/S/eJlqV2S536frh0bcitG5Ph9S9UZj78V4+0sozEbzOOHrP69Og9WjbVx27JcxqX7VssnIbdDNkJGfZWNn9EYHxtIS+vF6rxbNYjT+8KyZw7ktSZfPjLMs4KP1y21x7jtxq99o3VmtTzvpYSH9PPoyrfneeBvcP7qnwb+exH554CX0NNYHvDBcTKNFqazYmhLHkm+Hv2dFhqTrmOwuMceVlQKS++ID8+vWok33qck0vOTjOBXcUKwYfl6RgbE6Jl5btmV+Oa4PKORPBg3wzMBxA/1HdcvS2orRvVeeqheI4zqNVq0l4yf0bq89N3SYjs8Z3XBWurDUbtkT3TUJfe3u2hbw9DP4wtGv2VU56UxNbpuXK/0vf7moUlYLkYWcaMvII+hfJ+93+PKbbU6fv0w5sbPD3bUtukhqZ9CbEMX29QLMlJaSwpq9PvMdozjNIg+L9diNCaHSoz6mZANZuLcWZpLXkbGD8Pn4/HmR2NCRnNBVp4z/j8VI41lNzwDE5bm5lltfL9iJc+7VJAlwzl9bFbWntTv8TnBhmzIBRuGue+HeZfXwtReaQ0cTbjxM/Jno6X0oRupK/JeP//bXb5tzwN/k/NXHzhgv5a1rGUta1nLd6K8k/PA33cS24PKGB0LdiCCJes0Q1vh/thtti5X47UM1y3FAGGwTJMBfRakm6z6JHJ/vCrYQIZwV7xvRlZuEPRZ/n5SS3ZK3Apcna4bXbtavvvQWDOY1xm5HEPl2QUcvOYl0tNqmzI8I90zDlGMQwsZ+o3XBhnKM0CpDN/FZwUZPWv8zpH1fp+HPbpQ3IgwtdpnCW1ZfVbsr3H75LEx4hiserPvRiR5iGMUidjWYy8u9d8KSjTcMKpIHk/JKzvD60nNMW4LP/Rz8vDH1+c+GY1NYKkf89xM8251nJoQ68ZS/VJ/hejtZxmhOvk5S4OA7GWOwyiprGN4Yxzayu8ayTgslsZD7u8wjEsZ/c7o4AryMJqiS220Oq7Ha9DSc8fVH60bqQ3FSR4X47EyntfBjngOsY/TeEievTjJoZT7wgtreU9FRN5yO/VYHtlUqhm6zBAaOqDdMHjvIxkl7RWhv3y/HcFUaWLE5wYzvCvBUkuwuB09ZxWay7MjFfp+RZyfE0ZwWFyQ8jP8eKFhUL4rUFtqF8Kw2KfFbfzc5XtlKOdowo8hwHF588KV2jsphXRdevdKH2UYM7ZRDgPkNhgW+yXIcrTwLMGWsS3y/aN+PjPcMZbYhglSXw1JZGg8jQM7hDnECTIybpbe/ZBkqf6j9yaDNfdXHDcSy5AXfBPyNWPoNyuVFUP0Pqh7SfHEXysLeS5Hqv8Y3h3Pr9Q0USGPnzl+2FI3SchQ/ZkKZDx/VpTdUhgnjcPUhqtGQFLmI8U9zPsYjvDLRupYicPyuFwODw03JEM8Q/Xjd+UHL4/ZsdJeCiElpTp2NFLdxo8bhQHTheNxldoj/47zdDyWltru4Q7x++W9fv63qYjIfz/+Fz0P/D96u/c/sgp80CrcF2vKioLRgnaW5xD/HiuL8cCGYUKPlfbShB7Fr9NAz4onTbTsKtxvZd/3jtFETouHpM+CFngprjUyUlaV6ZK1PzYOkqwQYVYVrJgzFp/Vso+UfLaRsqJffnewAVaUezYCVgyLXHZ//+I77qvVflha7BjVZ7WNxn2UnpMMtFVyGKN3jdrgLM7FwxDpYznG/XOWASPLfTFUcFRuWRkjo5ixrDS2jP8dKZ78fy+K2Y3GigiDQbSin8eKM9iQ63UfAc6T+2CpKVeQqvy8cbuItlcozlCyqfwrxuWSoh33eUICxmWPRkS+3sV3raAjuQ3zuB61d56v0bg2o3ZaXQeEoW+SITCKdefyn2HXLBn3HkKBztuV9hqPg7HxMY7lD4Xi/nXjYUvgYU6fR00Ox0foisife5CbHzkIfS1rWcta1rKW7xD5f6z8/289yM2PnAJPsdX7PAs/QKe4kSeXrM/kQcAytCd6/ZJHMIboYAg1j738fuRV9yuwYy4sSzHCHJcKg6eargNyuXM9xvDzyCuU+E5tiwg1pvKPPNdc1oRKjGJfwYYB9hzzB+wIvktbiiTkso/h9KUwRob23gTF6OU+jyaHJkbuW7omQ4j94K0vRSTCUL+zmPAkZrjT/hq3UR5H49h1igmmeG/yhFehTBn65b64/kOQUMT2Hvf5GWNxjCrk8bj0oGEs5TFiRxyOUdx3KXbOUOcUplhCoEbzJPXL+L77EKmMViwXL5epGPEweh13OSSVXjXuk5U1gJFXncfSyEsdw91L9UthiTEMP57XozqPt9el+TR+BpBjyrJa7hz7Z8mrZ9R/S1uh/Gi9kaHeq4jT+Heeo6kcBp0vqb/9cP0SB8WMEkqlMMf4GoZyvKey2gbv9OcRERH5syIiIYQXxp+HEO4+yHMeOQWeOiorkoRMjZUFEMph4EufVofhnjFEi2FpgOfnpwkZn7FExiniIl7EyZJgq9HimIyGUOgLx5CevozlyRRh5wxjjeEt9P9koIQyDEotxqXzFhpi2ceLMyMd2Q9wZBCyobCkhALD6PADoYgzFFVepEzISnOJ3BbLlxRTNqqiYlWYkMHoGi1cwca2Hink3J+xnHlfsrsfWsywfezjcZhi1VDLhl9q/5HBNTxwRIYC/X4FpnzHsvqIlTZc2uI16st0rfRD/bVf4zVelhS3tvkwiZJBmo3NlT7OiqEIuX2SZCMsDHMjKwG/rITH83TJIE5tHvkGClGTx0Wae0nZE3/neow6XQ3TUVuO2jQbez6Wecx7GPEx0pzNhlIKB3nyvMtjYMXAS+N7yQBN4zwZWmmexHbKbRGVbia1RgNhNUQw5vuMJZPtksE7WiPHRpW+a2Qkpjqkx6VypHb5VijGD5gCZzgPfAZ8QM4DTwMxWcoBJAi+DBovTvG5LsZso4LNi78hD9gxMQlGin8cYxIwfVw0RnG8JU8uKfE44dS6Bl/FCZQWvbGhkZQz3B+7SxMmTaiklMeesY31jc9LscmsNKOhMMzg+PpUh6VVDUj3m+W2yh5eL0O57MhoGC/4yftZbU8zGDHJOMp/m1hpv7JAxXqLT/UZFCtC7tNMzkr3jNsx/Z3fPW7D+KUNmE7Hj+mGPh/Qm+Ha1O/pWh1zEUm436Z55xJRDun1HRQ6ntUAieVK7RcrmmKqph/ZFbmtGQzROFaH+8mx1tz+idzXpQE+tIn4YayH2HfSC5Rh+Huk2FLfZyXPYHAMCng0J0YGRlbiad+5B+xoviWJ8yOUsY6BYS6EQTErKW5ov3xvHA/ps1SugQw7fC9OMK3k9h6XfWxHpPmiyN7wDl/FvkyyalRFQxchG+nYUduboY9yvwt5fAwEOlmO12dyClr+0WfJPs3EzcQ3Gb8zlWUtD01G54H/3Ls5D/zRUuBrWcta1rKW7ygR+NZ4+d9GsnIe+FXgnw0hfP1Bn/PIQeimi1Zw9Ah9GT08Q4a6fRVyXBtQODZZ3dFDNF30zJK3Ff82nSxZ1L4cWb3JSwjRCg/6uWlFvbIqLLNKE3yYvJLILM9xv+hl5JhvgkMTVF8Efb9hiM9FjzVB5uPYpixB+COILYzKEL3zcbxvjCBkaNGRobUE/Q8/Qz8kD83boY+WvO/k5Yy9vNSeKcRgR9nwYAQBjiBxE3IdTbcMWY6ZsqaTpVSTvgrZax+/W6IX6at43bifGfoqIyAM14ZUVwl5vJzJCn4nEuucPPxUr2CDwrfRQ/SFtlkoI6rQyZJnPfaqQ0KKrI5ViONvxaNLF0snA5QNw7jyw5jOcHNg8EojPOurMKAcRsdGam+J3nLy5ld3NyiKNjxX21vL4i15LI3bJXuh0XMVp2XOsfswlCXXKSJ4vhhB5COUwpcRCem0bsnrTnM8ozpomXLoIrWDRFQgaqcx9J/GXTDDWCauX6k8oVj21lO4LI1vHeOxjZL3nZAGHzs9lnkcHlBkUNsomIgotSPYfTSOM08lohvvqYSH9PPoyEM5D/zRUuCiAzAttq4ewcdxkU6LfL7FS15AMqkpjBbhOOhNo9clGDXHodPiGJWZHy9qUfHkidDpM3yZYso6KTNsBaoY+uX4WChCfu4S8u3BOAaoawTl+yLFfWM7JKg3LW4xLmy6AdZntCimdktKOC1IIcaKfZq0XttK3Kj90OuSwpA+PicqMoX1B4W8BO2PFiHpBVdrG9pGMiSYFU+KJfZkgywbaKl/O1mauK5eVuj5GgYjI8XQkwGTodwihV8kGzop3EI02DJ5TRiMOPsQV44EdXYykA1Fx+dYEaX+zOEitLw51pkh/mGsmk7bG7S/EmcgGXPZQGRQugT9O/V3hljjO9N8lDj2IfZlbuvRmEuGTjY4h/CX6Ub95chzcUzCNMnYS8oyhXXi3DCtjo1gyaGydG0an8kA8JUaGrZZMTDjmDORExDKQZGmeZ3qkMqe2t90os9LpMkR0TEbuKm9fVxzoqGQjdjRPM7hA0Z1GEmqLzDA3y4ZHCH3uY5bhrBKNJRM/CytnUMYKQzOzdgJea8kkCkZ7/bn211iulRCCD8cQvh78e8vAv8k8B+Mr3k78mgp8GQRZzY4mVQiAcwiTsa4yKf9mnkyFiHHnn0ioZXDxBcPvvaqMBiUr5skq10HfbaGk9KKk0+92KSgYpEjGcbEcgcbouExXGfaQcFCLIOD5OknhZOeoQZANBzqOPHMsDBkTyQZKhLr6/X6rFxlnDBDn2cSt2AUow824CY+eglpUU0Le9D9plGRDQuIlt8nlCGTCVlS1OIH5S29ZIWcvWsPbupVSXpVDKZZJgKGFB+OfZ2t8WjAJK8nKQldiKPR1cSxEpGUUDAYU3ERTP+r0tP6m1aWrj8z4ciDSlI4YVBe2Qsth4V6jI5kZV+EvDDnGL5VBZWVdRHi+B3GSlr4QkR6spe7xCEZrs2eaojla2K947uy0i91AmRja8yoXyFZpX4l3xv7MZHw+mhQOPL7Uj+k55pWjZOk5NP4zoTEdE+n49BEL91N/DKjO1ruvkiEwcGgTM+AERIoqT76LF+GYe1JBLxex3hSljbWIdg4pqIRJm4wcrIhH8hGeBrHpB0qsV98cgDkfsXtIwrgq5AdimygRha6r0JGUexitDMhrZmp39fyMORnReRfFpGnVj6/A/xpEflvGA76ekt5tBR4hKdMZ/ICIiOl5uuAWQi+9qoUBPX0umWF5KuAnctAQBkfRBEHe/JMfanXZuUTPXTT6OINSTEMkHhatFwd4nVhUOiG+G50go8Wazf1OvkaM5Bu0vf9sJAkqH8J5k8eRISPE7SaJp891a5OC6Cb+Nx2wSo8OU5QkTyktBCsMn3Hlr+4WI64+Jtelg2r6Gno9bG8EZ5OC6+vvC5A8boQn6PGjGSF4yufFS5ou9h59ERi3X3l8bUfFvdOF+zkoSTDyzg1DkwiN9lhgfZVRC869cYA3IbP7ekmHjfxgydZPIQVbuSZkr0okI6BfOkZwf5qbLo6ISFJEQzoQpDkbXqklUExRS80tZH2i8/zQo1Dn1GPZFxoqMhnSDmN2VwFiUZlP+xq8NUoVFUOY2dMAvWVz4YGDIpI3HC/tndU1hOdPL4exk0iy2VCK9Goj4armwRIEH8Kw4y3KkZjLSER3pIVo51LVuYmIgyhGIxw9ajNUtgsFCHXNxnSmDCQJpPSLUBanf/p3aaJyJMJGTXRUEgskxvGfCobRIMgjEKLNmTHJoVcfKHtJl7fi4Rh7MeusacmzxWTUKn3UsJD+vn2l98NOOAnReQ1EfmKiDwPPAv8U8B/GkL4r9/uw9YktrWsZS1rWcv7K4+G8n3XEkJYAP8l8F+KSAlcAOYhhP138rxHywP3yeP0Qyx44rGnBl8O8cIMF6a4F+TvxUVvrArZ00iQboozJsKQdKNXTzxuOkCrvh7e5zZ8JuVkSJEhFpjiSYl0Egr1bnwdosfiI5SuFnwiKyVL3fSjWKNT78NXallneDN6XQkWJnpOplMvNZHN3IZXr7Mz+jtCe8mKT+EHceppJUveROvcV4Nnn+A7V6tFb+fRG+nJMHyCdROi4KbRy0vQ/NRHL91oe4/g30TWM130Apy2kaIYJsZltS9tqnOA4kTb0U80FJG3LKUxZMl1Tc9TtGGIa5ro+SXEBj+gGDkZR0QGTDPCad+lmNZED3fw7EM1oEZ+6jN8bxqDrwN2IdlTVUJSgpgH1MaemiGmOu7HFJJpRa+J80e9QJM92WG7ZSxohMmLk9gmQuYz5FBXJmqG7DkHq+XN8ez4fpNi+QMINHi6EbWycxPDOVq2lGjIV36Ivy8iatJpodyGhn7MYoQgCbhJyCGAnIDFaQx7jHTZuRnImmhZ/CTENUjr7GYxXDBRhCYhdimmnXgiBDALbeOEzvlSn+Vmuo65idd6RvKltDIQaEnzSHI4IW+3gyG2HT8PZcAulvt9PFbzutdrG7qp1iPzESKq58sB8VrLw5MQQhdCuP5OlTc8ago8QmXFiRlYml7yIkZa0NMEzPtedZCa1qjiTAzQxmT4ddgDHBd10YlqF6P4WGR62oXJi7l0glnoJLenJpNTMgM0xtp9qRMbozBwiqGZqFx9NWRSShMtxZP7jbjoLUxOimIayZN8SJAyYmhn+FIVVoqBaUwtwum94DZ9XjQTRJcY33Zucgwx72tHFWSG2FvJ9XJTVeQptOBj3NzXqnTcNGBaM7RLShATWbfJEJJYxgS7+1KNhH5rCNoGy0CWixwHX2tYIBla4nRsJBJiGkMKFxMVmV/iOmRDKMUFI3M7GVGaX1o0VjhKcvFQIMZR/DotysWpjnHTCf2mxzQmQ/mpXRMhK8V1QyxnMn4kgJv5gWcQ4UbTRnJVIqTVYRiHkamcmNxL2f6ChjaKk5ExVQYwamSYVnAzP5obBl/6HOJJCt6emqgQ1TL3kUthmkH54WPIKSpd7Qvtj8xUj4aIWWgb5X3akTXvy9geERYXr+0q/cAhSUSvzFlpTB4TSswkt5t0kuuc5n1SrIMTQd6LneZE4l5ILxSnalxIr+sJAm5T23QcYvCTSI6deoW/azW6/STgNn3eX572dvuJx00C9sTkffg+OiN+knB2sAsTjRzIyawkGSfRQSnDQMg7K9PfQ5QPContreRBTyN7tBQ4OmH7mXpxyWoPVhd/e2zwRVCPvAr0m25gwHZ6b3Gkpnra4uE2fF74UqzLR2KLPTX4ArVgUzKNuBj6KsapnCqB5NVAjI21g4UrMfFHKMma0kdvpd/yFEdWrfZR7DIpeh8NFiBPYtNpvMwsTDZW1GhQRMLXIcfCkEgUmw+LjHTE2JjR+ODELxHPEvPUzXwm+iRDIRP+ooeeDBBQxMH08fllGAybhck8AdMIoYTiyGZvrjhWjyN5FhlNsSGy8BlifI1gOjNsnyliHLvT97iJLuTJA0koRUIgTEdGCdxUvZ6kcJJSHnsf4gYGsTKDdaXwJRTH8YuHFX+Lz7DzxN4K9BshGyqpv4qDYc9e8ri0w5KSF3zp8/gkqMKRcVKiqDhNr4hQIgcmJVQcD2VIKIwvQjaOkiHmNnRsmLkq6qRUtCKjbWJpbNmA29L51W/rACgOLaaN9bFoHTrBV3pfKMljOljtO5+MxEq98eLILDHS+5kfSGsh9ruQ0Tc3SQajKlQ3Uw80SDQKxqzwpLtCYpeTEa7kYdtFNAK8tqfOs3itUaTKtNHoDlqf2LwE0TawJwPiYRZGvfR2tFsixqLdVBW2mZsc55ZeDeni2EQvW5W029C2dtO4bswGwo8v0b7wYI+1/xIbPY3HtIPG9A88mh9MVmPZ7/TnERMR+e9HP/8D8M+/5U0jWcfA17KWtaxlLWt5f+SDcxrZYNmTLeiUQ7g4tAO0Wap1mjw0v+HUay7VQy0O1Nr1tVf4yqll7GYai2J160iKz8V0h2Zusrfi6zBsdwkobLmQIc6aUoYWiVkqOU6XIMDsNY9i164OFEeW4tjQbzp9jxux7mN4wJ4qnB+sem7FoUV6od90QyIYtD5uUz14N1NPo990iBfKfavPLwL9tlOPX9QLSCxse2w0thxzOQcbkY60F9/F+PvcqJcWItvcCW4z0bzVM0hbtxITOO89tTHu3xrsiXqbacuYnRvKfRtjqdBvOYp9m7ft+dh/iVFuT01k9qq35Ssf8+OD23Yg0YM2+izTCP1GjEtOFBVJKSTzrgEAJxntQEIMmwwx0ncraWtSiGxlJG2JigiPgX7HaUw8IjBuusz/SDFi5Wlo/DcI2fsKVvua6IX7SRwXW3E+pa2HCVJPOQFCnAdFwG/EMZnQ3jDEyd0k5H52k6CIR4KpI7M/wbkJRfMF+A2Pnzqdm5WWK/1OHJPET/Ezh0sIglWkot/U+ZxRlATPexkY6EXQcRPbFLRd7amhOLa6HWzL5S10OsZ9ZsSnrZkaDoohqPiMhGoEGwZo3ui6oXF/bcOQeCWLGE6K65LpJLPp/UTDI0RGvT02GRUsj8wS2zzzQSz027qW5C1ykQ+Q9nRLH0N9/bAV05dxDKW0qXkbJfS7TjkY5cMZ32fKw/K+H0EPnA/aaWR+6inv2hxvtqcGQhxoaUAWMXZtIxGtF4pDi5+OFquZbjNyEZYu71lwUO5b3abm48LeybBXslMYMUG8/V6vRJdTk5VizhbWpmxHCuOahcak3JZqmDQ5U53EC/2WG0hCaJ3cTJVJMEA1wF9hMmxpSttsEnToZ47ywKoRU8R4VqFxMXtscg5w0AW1n+mzyrsWBIU2QzR8JiETp9yGp992cdua4LadwvqFKjnlIQSovCrgqHxshJpzKKDWBas/12tfTAPm1FKcDFB7MoZAIfZ+t4+KWK8vjrXNTRN5EJVXA8tpaMVtqlIujk38sZhIEjIndmmyF8dqMKRFsbxntZ4xBOOiwgwG/KbTWG2Mtfebjn7bLee4fjfju1K40jQmk+zSViYlrqkxZU+VhBgmkTxYBkynY9HOjY71GILJ4YOFybFCc2owC0NxqMZaqLxubkHHQTJqzNzkutm5/janBnNqVXlE49HF69PpXMWBpd/2FMcGP1ODaZz1C68kPNORYXl7ZJBWy5PGCgbsidG5NPFDjvjOYBfJCBeKEzPaKql97jY85YHNxhte2ymFGfDD1kcNBejYLQ6s9v1C6M/1OjYaXSvcLJLiUra3mMOhiAZucWBjjDwalRspDDVszcvOgRAVryr0bsfluZHyUqS8Bj7lovBoeCCOcQkaCtJrte9C3HpJ3NvvptHQTETUUtcJe2owsc3KQy2/XWifBxsoDw32SOtkFw9nfL+RfNBi4CLyBRH5i8CPisg/LiIXge/s08iCBVqTJ0bed9yJTpzI/DR9tLhj0oJq3w7s3RO9Lg30ct8OTONIVDGtKhk7N3TnVHGYxGyNxkGoBk/cl5E0Ej1pBLo9XQ1TxiMfPR57ZIfDMEJUHocWt9lnZrM4oBwW1D4Szco7RTZS7JHFNsqaHe+zLo8MdIZ+U5Vtca/QGLOQ98NmgpIX/IanPFJCTr/pMXOdsKFUT6U81PJ1uy57UcWhpTpQw8keqBfsdnQzuJsEJMa8ywOrHINWjZMU8zRNRDJObU7bqbFv8p7ybtflxDP9VvRyyiG9Z7+d9swqISnUqiwk6L3EvAB+EmgvqQvia69ISB8NPqMJanyh9+iuBcFthIFxbsCcWEI0SuyhVSOwiPH46EmNs8O9Y4k8g0TW8lPd510eWiVzNdqOptdYd3lgMSeWftdR3inwFfR7kd0VVPGFMtCd64fYZuQ4iAc3cxrLP1QUqtq3mUBWHJsYHw/ZS3bbDr+hRmawgfIgGWaiY3jLUR0YykOrBKpOFWB1u1CDqVBEwM/U2JZO50nKGJhQKDfzEUUQin07ML2Tco/97KtAcWQ0Vh7IuR/clhqeoQh0e04912OjJLsDO6R+DZKTqmDj+D+2+Epj+ggUdzXKmAiXZm4010QZ6HbUaOm29X3aN+o9dztOeTrRmCqSB50MxZRfYUQ0S31GHFNu6pWUV8T8FtP43IV6/mktS+tbMNDtOIoDS7fltU9maoynWHgyaEPt1QGJHr6bBrpdF/kQIa+3bsPTnevpzr3HQfAPngf+TwH/A1AB/xfgRRF56UEf8kgp8ESqcFtOYaOpiwQUnTj9uT56L3FhP1JPq7nSQRy8AN25nvZiT3WroL3YkzKFJTJQv+vICTMkDASVlBwjQsO+CuqNRdZyebvIFnJ5z4IXqn2FtzL8HC3gBKenJA3S6wT3U51Y5d0ip0csTtXDyJ5KhOCbKx3dlidUQRV3Uv5AeaBwuul1kSxOTCbO2GOTB7w5NdlAsKcGt92r4j/U8rcXe2XHHtlsuPQ7ybKI7OhtHxVJPyTsGGUv81WE2b0q6H5X2x4JmbQjnug1av1sgvHnChNXtwr17I8VHaluKwnObXi6bY8sFD1wM12okvJxmz32xCo6EhOXJEPFxsQhPrO6A935TiHbTjDHGsKQHqQx2VMq9y32NLGt3UODz5NRVR4a/ETf1Z/raS/0uGkkI54YuvM91T0zJI9J4YepQxaGfjt6V50QSvUoM6IUE4SYTqhuFfiZ050KZaCLhlK/12M6oTvfK2lqS5UgnYYLbKsGU7flM+HPNmocu1oRqn7XqSe4MBkFKPZtDhFo6EiRr+Qt+5mjjwooEVPHSWKK0zg/dlz25BP02285msudesdzE0l7agCAlq+6VShpK+g4SWNEP1Cin9900djTkFN3oVPkacfFNoXuQqdrSRxTKZRR3bW0F+KRcAa6cy4mmolzodOQnps5re9Ux2FKSmVPIwHNEkm6RsfChlND6I6lOLT0WzoPbAxFuUoRD7cZyYEbSv60C8EeW8LE510Y3Xld+2xEUfpoaPgNl+dnJplG8isS599aHpqEEF4LIfwvIYT/OITw+4DvB/7Cgz7n0VLga1nLWtaylu84+QBC6E+P/w8hfBX4+IM+55Eyq1IO6GI/FjuoV1HdKiFAdbOg246W7cIgi+jhRnJbt60JMibXC5pzXqFVwMxtTMNq1Jq9W+AnMRVoaxRWnTl8HfcFR8JTSLF2ARqNYaVELL5RC766bemutDmeC8CpeiLSaGwswXhuu0cEytuFhgCCekb9hZ7idqFQY9zzLNHzAfXo24u9oqO7geJmSXO1Q1pDcWRzbDtt/XKbCvknsgxe4W5xUN4u1aPZ7bUNG7X0uwsdxb0Ce6IxxW7LZ7JbcRi328WYXkIqEmmQylPcqLQPAxCE5nKHPSw0nemOozvnKe4VMQavPIdMkLKB5kqHPbG48z3MDe2eekSpWdMWIntkNG55WFDdNTRXNd7Z7zrKu4V6daWSsJoNh3QaBw4CxVzA6FhIe3R137zGxrvz2j/FzZLuQgdBNBY88VR3RsexvUPRU8VYIswV+wX9Tk91MJTRLrSd3JYnFH4Y/7d0/CNKcux2HdIa3Lme4laJ3+roA0oCNRrCyIdVxFzwbssjrdHnlB7pLJRevcepwrH9TD2yds/htjyIzduN/MRT7Fuq20XeQx8slIc6ZxRFsLhtJSGmvk4E1eLQ0l3skLmlODC69bJS+LzfcYpq3Y71r9X7TShWcbvEtrB4PMK9taffUvSrudohC5Pj6eW+esv2xOK3e4XnfeSsRF6FXQjdLhp2macyCvXrpRLLThTmrg4N7pLDTQRplGTWXugxcw0lENeEvkZDZTF5UKg8/V6gvKPz3U11fld3LO2uoh7tTkAWluJU6GcRuRvlkAi1Jzib066aLuawmHp8qTwWWkOYOLraM7le0E8D7nyPOSjyXC3vFJn06GYO01r6WYjIoaE9PyLnvBfyCCnfhyQ/GfOhvwB8EdgHPvugD3mkPPC0d7u/3CpB5W4BM0d7scNXgfaSQn/SGMr9uE91S+FgXyopw3SGdtdT7RvsYUGxX+B3eh20MfOa6ch7mVP8yMwV4q5ulqpc4z7MbtfRXujpzvfDfvFayW/VXZtjzsXNUqHOeHCIxsk8bDj6nR5qR7FfUL9a0m9p3MvPNA5s7xXDaWgxLmU6sMdqyBSHlvJOoXG7XpXt5LVSF7mpp9tzdLsOt93DhqM4VFKY33LUt3Xx7bY87UWNddmFxjTNIhJb5oI9LHDnO0wbGd5BDYI+Esn8XgetxgeVZQ7uQgedgcbSX9GNvu3VTmPrd0r8bp+Nl+KgUJjYiZKkeoXybAv1q6UqG1R5VvcspjX0u0riKQ8UasSEJQZ8MCAm0J3vKW8X9JuO8sBQ37TY4wJpjCbzWQz7Y30dqO4ohGt66B5rI0yrhokcK4O52C+YXC9yPv5+492vQOK1zfpNr+TLzZ7iRI2EbktDBe2ep328o9v22CNDebvMEHW3rYQuabT96tvKsjdHFttAda3UUMiJQRYGt9lrW8yF+rUSd6HDnCpkm5OrTAL2bombqqKR1uCnTsMWTqDyQ2a+XqDVvfjd5Q670ARG7aVO+/00HUEbMxAWSqxrL3cUR4byVqks9UaJlm7m8TsdwYY4X5UL0G/FDHtWw1V+r6OIoQWA6kaZyafFiSq0+vUSpj4q/biTo43nJtwrqG7ZmEuiwJe6BrQXekLp4zjRWHd3rqfb9sqziMaQr6OCjxwcXwaK/QITyXWgczYx7+vbSraxh0UO+xSnokr2XK97/Y80rl0dmMh98Bq26XS8t5c6Fld7NY6PhX7HUd0qlI8Q8yD0l1oQ5cXU10skZrGzC6G4VWa2vq8jV6BXKN0e2XyQSXdOx8haHq6EEH4L8CTwzwA/DTwH/N4Hfc77qsBF5F8RkS+LyJdE5CdFZPKm13dCcSKU1yuqezphzb2S6lZJf7lVkpcQzyWOirhyFCeqJNrzLqcEbC/p4uhmHhOTu/SzgNtx9JshemOBUEe2tyi5rb3cUd/VLUrBAFP17OiEUGkcL/S6gLbnHf2Fnuq1kn7XUV2rlDSy08PEU+4b5ES9Yzr1AJoLDqaO6p5BRBncxYluRzELob5rlBw2CRTHMRNaqyQ5P1Vv2sx1AhaRnDa5oWSx8lYJrSqsYl9j0M0lVezFsYFIXOt2fCRKOd2ytRnw51QZm0bo93rcptPUmTHLVRiddd5fbbCnwuSlSmNxR4bJixW2QZEEq7FmOY7oRDq+tPI5K1ti9AeBdtfHWG2gWEC34ymPNL7nZo72iZb2iVa3usTMGErCAnu7VGU1U8TA1brlyM2UR+F31Gqrb9t44EREM1K2vv1SGfO76lEBmgRmEmgu90p4nAwn2L0bCVUgeF1E3aUWJLB4vNNdBXHrEEAIMRteqUZmKFeO0O01q9niaq8kqjLQTwPdjo+7JoSwozwLX6on215wmP1SFf9rpcb8Y5KTYPSa4jQmQpr4pYQhfuYy2S3xTMrXSyUjXujUy5dAu+MzQa68Z4dz573Qb4acFKi+ZSnvKXEQE7BHBaaP2+DiuE6Z6PzUE7zQXWnjYS0x65yF4kal3JZIai1uF4RpJJztOOo7luquzo1u11Pds0rSi4lixAYm18p4oAdU+1aJsfHHXexU8U8i/yCoR9xf7LALwCjRLRmK0gn19ZJ21w8ZCG1Ew7wahebE0u7F9MJzRQvc+Q7TKCrSXnC0Fx2T10rskaV+uaJ9rMukuH4WaC93TK4X1K9UmLgDRIIawv3M6zo39cpRaIXqnoENjctT6lxzMyVtVrcKmvPuvVXiD4vA9oh58UHlmyGEvxZC+IshhFcf9BnvmwIXkceBPw58fwjhs+ju09//fpVnLWtZy1rW8q0XeYg/HzR5vyH0ApiKSAFsAK+96dUB2nOOfuZpnmzVA9t0dI831C/VdFua2lM2u5jEBOzNiuZyj7vYabxw3xA2FSZyGwohpXy/wQYmrxaYRmieUCu2uFfELS4Kc01fUc+iPDTITktxK2Y4KAP1azE2dmRpnm6h8sixpomUVmifagCoX6yoXynVYq8UoiPmRy4PrMbjgOq1Mu+9Fafb0Vyt7Hh3vtMtXafxHN9G1KupHfVt9T7xQn3LsrjsqO/EtIqNQorlgXpP1S2LPdLYcP1qmdmwrg6EiUL1brMn9EJ1s6B9QqFwc2LzYRVuGrDHNh+KElrdt764onvCQqnlRobEEAhU+wbmlvpGoRDpgaU8VFSh3/aUBzEZSR3j0TbQT7XNmis9vlLI09wrqV+q8Oc6ZeTfKej3etpdj7vU6ta86L0Wc8Fd6NQr6gRzr6Tb8TSXlT0cDFQ3NBzhLzfgYXLDaugkbn/SLYYaJ+32nCav2XkIMcJekLlVfsNxgblbKRx8qvwEf75FPExfKrFN3KcfWfPeQthUFrddCLaB+oaGh8RFDsCBsqjby3qyhl0I3dU277JAAv3lTr3xXqhvlPhdHWdholvOuvMdclBgG3Kd7eGwNbK/0hJiPu72nNM99ybkLVtuqvwJuxDKA4O70FG/XiA9tHuO/mpDt6v3T14tmbxQU5wI3ZZu66zuWdrHW7qtADOH2IAUHnunxMTtk35XkZHilMzLyEdvHhX0u476RpGPwO0vt8pJiUlq3IZX1Ks1uBrcxZbmaodpFKkpj5SxztzipoH6rrLQ24ud7t6YqxfdX+6Y3NCcFW6rx2+44Tz2nU7n6Yml3/Qsrva4cz3hYqNzyECYeBaPddQvV/jdTpMU1ToGXa3jwdXqWRNicquEeBAT6hjdheImgSb2q9/tNTR2pNtFu52AHBY6zwqf801IRNV0X/m7H95vKh9AD/xhyPumwEMI14D/BHgZuA4chBD+19XrROTH4qb3L/TNMfWtmEXpVGNEUnjszUqh8w1Hv62QmrvaUJwSlW5BcMLGiyXNuYjzBo2P22PdOoUNhN2OxeO6Z9beKzS707keeypMr6tSmj/Z0VxwGpO6XgNxb3WtpBHdu+ypXq6orqtCbD6+INhA/WJNcWBZPNEhTqFhKg8Tj2kNzUWXt4q1H1rEPNjQPNXiC2gv9hRzBsg6QHO5p73gcmyveq1i8ZGG5rzXEEOnUFy3FajvGMJWT/ehRT5wpL3oKI/UeHGVLnr9llO49F7B4qqjvlEipad7ZqFQ/omlPDJU9wyT6wXhfIPf7vHnOto9j5lqOekFt9UTLjQQ0MXodSXO2MOCfhYzyln9zl3o8BU50QcooW1yvcCcWurXC0yr72eiW+PKQ90WFSyYeyVS6ZYbYoaq6uU672m2c6G55DAHhZLCbNDYPcBEtyKmnPemE3xrc/hFHExfKWDT5dg7G06hytu6GL4TGY9vNz+mPDJMXiopD1VRdOdVAbcfWhB6g9/rWFzyunBfL7C3Sqh0m1MyJrvdqGyfXmBj7gAz1/3Si8dVIVcv1zr+5pZux1HfsrqwX690S9Wp8iLK1yvCxYbqVkm745lcKwm1Z/FMS3GvoH650oM5qkB9V8NbOKE6EDVq72ooKO13FieErZ7mmUaN0rsl7eWe8lgNSnNHlVVKnNNtakijONHwmS9g8kKF31NDYvp8Sflanc8lFydMv1nRX2lpz3m6xxqKE1WYpovJaGo3OAN7PZMXFGpvrvSY/UJ5IT1MXrO6r76xypWJsfHmgqPfVYPPX2loznndLy7gLzVMr1uqfUPxekU/jQlWbukcaj82h60OMYHFRxodO3OjitMGwkmJu9QRjIaz7EnkfrxeRWNKDex+xzF5rsY9tqC5oIROd6Fj8lyFFMpLKE7ilsGYz6I4tITzLTSGbkfnvVkY/G40JuYGc6NGjlWZmxhKqG6WzJ98r5Ohr+WdyPsJoe8BPwp8CHgMmInIH1y9LoTwEyGE7w8hfH9ZbdJP9UShjdesktVer3CXWtqnGyU43bFUr9QEZ1hc9LQfUWVVXy+ZX3Ww4TD3Sl3wZx3ufIed9hCTXMhG3Bfu1HIVG2ifavRZH16oFT83hHPKLA8C9W1BrKe/1Gn8uY6xqj3H5KbgFxamnuaZhj6yr5uPL6j2DRvfrKhfLalvq4dZHAvl7YLQa6zaV4GNb1Q5jWQ/JWdwCwY2Xipgoyc8tqDb1jij7CsSMHtBE2jU9zTW35z3VK9WhIOSfhaYvFCB07gZM0d5DG6iiUNcHQll2y3FCZjbFcEL9YuVKpSrHc0lp95Na5k+X2FvllT7BvN6zeIjje7TNwFzvcY2atEvrvbUd3Sxdns9wQRsA+XdAnu31L31E1UGrg5MXrd0s4DbdDRPK4JRHkeWe6Vx3lCAnUNxJMp274Xy9TJmz4P+yQWuDjRPdkxet7pYNdBf7jTGvd1j7lX0G4F6tL+8fq2kmMPimZb2qZbm44s8LnUvvOYBWDzeZ6TkQWU8vu32hu6tDlFRXO5hGhOdvF4jrWH6jRpzrqE8huay07SwQbOa9dsOe6xx3SAQglCe6Hit7xi6Cx0bL2h8u326UVLndsvkhqW5pOlDETDnGtzTc816eAzhuNT2uGNoLjkm14pMfmouuLgjAxAlflWRT1C/XsRkS4HqWqXlmwv1KxWcFCw+0uC2eiavFbQfnzO5YfEzx8Y3ajCBds/jLzfIRq/G7SRQnKKK75UqnminJLnJTaucEgftdmDyzRq/24NTwuXG12r6rYBdQHG9pnmmYXLLqvEzU95GStOKqKHebQXqGxqXduc6+q3A/GNKDKtvFLrz4F6Fn6lnO32pJHihn2rfmR78k3Oay11m0JfPTZk+q4Z/caOi+dgCP/FsfLNi4+sV1R3L5PlKcy+cKjm03fNUh2DuVYSgDHN7oqmiyxcnipBEg7yfweTFivaJlm474C52up61RlGbufZddU+NFLfdU12raC545bVsOepbmhGvPedyZsD6xnu7YemDto3sYcn7CaH/CPBCCOFWCKED/kfgt7zZDX7qCY8toPTqLR4bilOYPlsz/UZNdahM3Pa8Tha50GCvTVhccvGsYWHjWSXqiAd/VDF5qcL3ho1XLaEXglPSjx43qIq5vFZr4oy5Er/czDP9ykTZ8NuObjsQOoM5skxuChKPVqzuWbpNmL5Sqnd0WiDGq1fqDP00sLgUt+gYIEJV3eMNLCzdEw1u5uk2lShU3C2UPb7XYSc94uD0KYe5XeGPS8xCsBcWMfucpricf6zl9OkunowUYfN9i7/c0G9ou9Z3BXunpNvSJDf+Q6cUp4JdQLhTc/pxhW7N7Yr2IwtlAAcwO61mXrOB9jOn1PuCq3Rh3/h6jZRevcZJoP34nI2XCop9S/vdJ5rgIuax7ycxscflhupAz2d2VVyUgipsqRwclbiPzumnAXur0hO3JppNav5UnzOYlQcKbfrzuoiVL000s9xtXYSa84H50x00mqTFTrVN+22F0otTYMPRXnAsLgSm36ww+wXhqMTcKTWBzWZH+VpNd6Fn48Uib2V6V+K03xaPOUWPDizltZpQe9y2Y/K6pZ+BP6w4fdxR7C2wRzYTA+2podoX2sc0+UhxvVbC3oUWNwFpDKfPdExuGmS/1HDIrQmLqw6711C/Umpa2OsTqm9MwQROP9oqqfKOoT3n48l6UL1aUd3TpDb1XYXPT5/p2PxmQft0o4ljYkKR0CszvbxnaS/2tHtex7rokbKuBvPKlOajC2bPq9Kvo3L1rcWWTrdj7jn6KchBifTK1D59yuXUuO0TrR6/CrS72h+TF0tOn+5oPjdnckNYXNQMhRtfr3E1yLGGj8zdiuJuQdjW8TR5rcRtO+winu9damra0CtRr//YHPGosusM3RUda5MXatpLHbMXtB6TL0+ZXFNkxE40i938Yw32tQnloRCONCQ3/+SCdlvJgouLmqilOacIiZ0LzefmOu+PCiavFhTH2m7dhxb/f/b+O0quq8z3hz/7pMqxcw7KOQdLtiznnME4YAO2yRgYcoYxJgwwgA3YYGObjI1xzkEOkiVbOYeW1Oqcq6uruuLJ7x9H+PLedYd7L2aGn+/ou1at1ao+1apTtc/Zez/PNxDqkwmMHCcUai62H0IdGmpOgO6RYzkefesfVN40QSrVOm9WIoTjsfcxJfRpZYJ9MlLUeHMxaYX/k2fHEyX0vwv/zAm8F1gphAgKIQRwBnDwn/h+TuAETuAETuAE3jb4Z/bANwN/BnbgCdkl4K6/9RqpJGEXVYI9nu+zUoBSjbdDtUJQnlPyJCZ+G3+PSnBnwDP+t47bC1oCY2EB0VpEmzhu2i9ATKqYiwoEelVEToGkQblNR4oZCNnzCDaSjte/VVzkhI61OA8FGRHyekOhQ5rnc2xC4KgGPgelcFybW8LrCbvAhEawW0XIDnaVieNzKbUbXhl4TPUqBQWv9O3qf/HABqko46oQ6FdQRjTssmfbKkyB0lRATehev7sr6FUJjicSqQETyef1bOWSQCl47QG12++VNtMytub9Hbu+TKBPQXQHsaaX/kc/2vVW9o7Pq90rRY9sFdgT8HY8RRn/riDlCs9P2o1aFNpNXF32+uE1JeTeALbP61XLh0Le7rsog8/BbSlhVNgovX4c5bgUJ+rpy81ZRYwZJbR+H3JlGbukYFcbx2VLEuK4sY6c88xBrLCLOglqTqD1+nBqdBzNRZuQcJvK6EkH/6jHhwj0KtjVJvLRICKroGS9Pru+qICseeQ04RzfqVTqb0pptHEZMehHTMujphSKrf+g/qAjvPeeltGT7nErXsBvE+xR3szMJuDp+eWOEG5dGSUvvLaAIbDn55EDlicv1D3SoJhUcdqK+MZktDGVUrvpVZdyCoHB47voPUFkAy/g57hHtihLSD4bf7dGuc3wJIljEq4CWtYjJpp1hifX0wXBLpVSnYs0oSLpYFd5XA855/kwOG0l1HEFpaaE64Kb1dBGFI84mAU3p5KfZlKu87ggouz1hkVnCKPC83u36gxIeJJB0VaAgE1gRMIKgjyuelUjGagtE96nIRsgTyq4DpSrXE83PentQCUTtInjdqWaR3hElzBnlDxZoN+hPKfkld17/Sh5iXCH59NAvx+9wsFIegZQvj4NNX88L8EVFFptrLCD7Qe9wrOzdUe91hIIL2NhQR61sowvJSHGfZ48M+C8GUAUHJDQkmVoKWIbMr5uzSPDaaC3em0OIbnkp5oUmm38xzSPABpyKFW7GNNKSHmZwKi3O7eCnoTSjDpYAY8cKgct/MPHZaclTzPuOhKFNgu7rOAfF9h+cFTnfz1m/1E4sQP/u/BPZaG7rvt113Vnuq4713Xd61zX1f/W8Y7fJXRMoTy39ObNTC4J3Jaip9kd8GM1l/H1aRgxl/xcj2EbGJK8i9MFc9KHWVIQNvhTAr3JIzFZwwHkEp6eM+VDGfIh9QawSwpS3IC4AbPyIFz8u4LY3SHvAhjwQ0uRQouNNCNHockjswWPaFhBEDHDu+CmlL1elOOZnIR2+3FNySOxCdCbDOwqE73CgZCNkpcI9igEhmRKTabnbZ7znJmsmE2wS8VRvPM3ihqWIaNNgpiaB9fz0C62WDi9QQKH/GjjElZzmeJMj7lq+1zkKXn0eq/H5h8H3xE/pTqP2KNoFlZTGf+4QOQ9Zr6vtojreIsAX1qi0HS8Lx2wKbR7RCT/mISYVAgdUwl3KogxH2bKjx1w0VsM3CodvcZGKsqoFWX8PSpWwSvrea50XqnXP+yRzKycRmB3ANvnou0LIgcsIrt9x81bBIpqoxbAP+aZisjF47r4mQWMBgPpuD7ZnlHAHfZsBpwlOcArpasBE6PaQs1Knod9HiTJxU5r2FGvv65lJJyC6rUOjqsb/OMCYzSAGXUI9CnYNcb/csz+X0HyJhl5Ru5NnkCx4Xgc5pKc55LldxFZFa3P69m74z7M2UXPOKe5hLo1jKza0FBGKXqfZWBQwrEkjCllbzIaU99Mo3M0LyzHiIGtQWBYQg0blOpsRNSEUT/lKhstYuCqDqVpOmaN6Rm01JgIxaFc5Tn3GQnXI1pV6thLc17rwQCpoYhUpYNwkabkMVN+hCWIdHlqib+QpZDwiHFj8vHFjISsOZiNOuEuGdkAZURFDXiTmLI3hJxS0ecVEe0FgkPC0+UHHbTDAQrzy5Tmlbxksf4AwSHhhRHpxzkGFTZGexlHOW6uUlLwDyq4w36PxBbWUY4FsOcWvEnvL0oDhzc9A9RJz7jIaCtjhryWWPSQgn9IRsQN3Nl5JNtz8Qv1SoT2+9D6NG9jMBzETPlxFQgOCOSoSeSYjH9Ixo1YGEsKmENBfDtCaEHD64MXZYxqj1jnpnwonQHkgoyImJTrLbRJT40gmQKnoOJUGBTnlN/0f0DyFi2u5qLEdJycx5dxJbCCnjGOlFFQJ2RESaZc5aJXW4jjfgn/KfgH9b9P9MD/Pw5hCIrTTII7AmgZsBfmCQ4KrIKKLw2BIUHggN9jbcctfD3am73c8B4fVJeJHFZQhn2e6Yfr9XJ9494qvNjoeL2upIFVrxMYgUCvimPKuCUF7Y0wit/CDHnJTHLA8sxJDoRQKspor0XeZHPbPq/PLg/50GeVCBzwoyTKhPqERy7xexUFX6yMOuQxR8Wkghu2Ce/TvICJRTmKzRZCcTGaDMy2MnaViZyXvBvs7JyXnKTYKH1+zJU59KwPf8sksX0qWrL85sXpLsgh9/uhIKOUjg/43REv0ahCxz5pEndBjshR2UszM2Xkfj/FBhtXgNxawHUFlGUKUzwWcaghD2UZZVTzDGSOz2GBQYlSjePdvA1BqMdzNvN3abh5lWCPjDDByPooV9sEuz0plxO2KdY7b95MpJail0YV8Pr05Zll7AkNI+4x820fSPvDSAboCQgf0JDLUFhSwshpXu/VkHGnFbANGSdpotYXsY5EjtvOmjiOwN/vWVn66gpemlVPCMIW0QMqcvE4ma6ihBF3CXcfT3pblkMyJK+fvCSLMuh76wPcheCwwDkUwQriWfnaxx3Ftkaw5hcI9XosZL3Wwj/mSbFCm4OezMySKdW5GMNB7LJMoc3CV1/AXpojvNOPGPWhTy0jtee94BRTUKqzCTTmvOSr6SWPCJn1ETkq4+ZUlIKnwDDynhWu/5jPU4CoXs/Uzalvhmb4xwT+bg0np2EUVcpVDoXZBpLk4t8dQJYdzKEgwQGZYI/ifX/GX2RefwkhEYg5OVzV9Xr5ORV5RKNU46LkvcQ6uyfkVdYWZ70s67QPeV+IYp1LbqbphX4UQO31E9oW8Hrpmou5MoeS8tjkZgSix89R1r1qHpqDloVQr6DYbKMPhlDmZtG2h0BzkCImRhxEzPQULEWPg+P4XNy86o3X+iLFWk894mY0hHAJdUtIAYtinYu9PIeaB1+filSp40vJKHkwVuTx7wyQW6BTrrXxRXVERwhfSqIwy8DqD1FcWsKVXIJVBfDbHs9FgcCQ5F2bjqBc5aJFdOyGMpGDCrgCLWh6bm7Ti/jHBO6cPI4Mgc0h5JxMucF8M12QhIGW9r6HwLCEXeVVIV37/w2VtRDiXCFEhxDiqBDiC/+L37cIIdYJIfYIIV4RQjT+1e/+7bjp2D4hxLv+6vkzhBA7hBC7hBCvCSGm/ledz9tqAj+BEziBEziB/wfxX1BCF0LIwM+A84DZwNVCiNn/02E/AH7juu584BbgO8dfewGwGFgIrAA+I4SIHn/NncC1rusuBP4AfOX/+vz/Try9JnABwaMquVkm+SVlfBvDlKu9XbJsQKHZpThDxxfRCR9QMaeU0DKQW2hQbHCRewKUK8E/BnqV4zHYe9Q3e3DahISkeB7Qvi4f9pos+rQy3lYd7ABIR0Pe7t0RhMI6ynzvGGssQG6hjm9cJjB6XOMNWFXHy5DzSvh2hNDjeN7NRa/fpL4eITBnAtfxvNYj+zxThmC/QN0YQWg2ss8mdEBD6fUjZO/vBoZl9JEgkgGh7QHMegPLlPENq9iORH5ZydvtDAlKDTb20cibGedG4niAyZIMoT4JqT9AKRVE2xihXA2RLgk77UMpg4iannwo68PqCyECFiJoeTvON2Lgt7FqdYQhsBfmMWcV0eeXIGF4n5cBpXqvn12utokdkpFXZkCAf0gh3C2j5SDcJSGCf5VbLcCY1AgNCrQs6EkXpywjxQzPd1x4piK+Ca8Ea1Z6uyOlBOqRAL5B1StldmlIB0Nox/yE9mtwKExoyKtIhA940rhSs4nSnsfsDSNcCPcJhOSiJz1bTi0r0AdDaFmvHygcsLrDSGXhSaEcCaX8vx6y/1eQXcwIHu+h7FUd1NxxaZcO2vaQZ7FpghrVvfOOO0xOcXBn5RFZxdNbxw0wJHwjCvpACG1TBIBIj0Dp9+McC2PWmvhTnnRSPxpFLkmomoVVaxDsUShXeUxwaWYOY04JX0RH9lvYswtEOr0wDv+cjFfe94ETtyi02tg+jz2vHfN7hkmjKuq2sPf+t4TxN+Yp1tvIKzIU6x1KdZ5fgVICuaGIHXTRSyrhHoE2pBLpUFBKnn2vuTyPkzRR8oJQn4TeGcUN20QaclghbycfSJRRJyHf5pW7zSiISQW1OY8xGEKdFNitJYQNkwsNwp0yepVNudpF8lkYJ+cwEl5QSbhbopAKee25kIl6NIBZaSHGNS+ApMqkVOMiakvEDso4PUHUrWHsCotyg0m0OYue95Gb4qD2+LHiFurGiFe+b9Wxsxr+cSi025hlBT0Jof0+RMTEtyGCFXUwYy6hA8fbOUN+tOoShqEQOOzzzGzwqhLReBElK+NvmUTdGkZSHHILDI8vcyRCqF9gp/xe1WNvGLlCp7ishJoXhCuLaBnQZmeRRr2qGHNzCNvTn0s+i9CBf0CF6W/gv6iEvhw46rruMdd1DeB+PCnzX2M28NLxn1/+q9/PBta7rmu5rlsA9gDnHv+dC/xlMo/xvzMk+wfibTWBuwLMMAgBsXiRybkmRqVFud5COXMc/6hAHfDhfyWCGQG1MwCu54ftGxc47UWcxhIIIO6Zo5RbTRwFrAD4055sKrZDQylBcTKAPOhDGdHQkmX0Cm+E2I1l5KKE/EIcaX0MedCHf1RC8Vu4MhhxUOuLSHMnj0s7HBTNxoiBbwIoS+QW6Bgxx5vknk8QOqh57YCg57gmTsl4F+YuH4HtAcrVxwlipoRvwitXC1vgHxXoCXBNQeiNIM60Anoq8OZqtFTr4hv1QlUCQ8eDRiI2vjSIl+Ne/7LaIHpQgVMzaBOQm2oTOSqjLsrg5lT8afDFdNScIJEsICQXJBdrWQ6t14eQvTxyZUcY9VAQ+v04hoya885FG5cIDAtCvTJmCMoH4kimpwkv1bo4p2fIzTdwHUFwQCbSJbwyv+pQWF5icoaNHXAQloTWEcAOO4QOaiRqc+TaHSanealbztQCxUUlxNwckgnFpSWsWQX8ac+gpjDVwmg0KKwq4F8fobSkiOqzCPaoKFsj+FOC4sISxVqPo2AFPTORUoNNrEPCSHgLRLnoSfSCsyeI7Pah5z1J0luFJDuoizLYftcrha5OYwVdYlt9mFFvMio0ugRSIMku+so8kZYs0U4JYzyAXJTwpSTcgoIS1zHaysg1JXLzDfILy+CAND1HaADkcQXbD/5RyVuwtBWQN0cgr1Cq9SZVV4ZyKkD49QDK1gjq0QDqrhD5xWXPr/vlOFJCJzAMvrCOVJJQZ2ZRSmBOKxE6rHqZAi4U6z1f+1ImQLhLJtcfIdTrabS1ZNnzdngtBPVlwpEylh/M5jKlas+nINCrIg6EkcZVbL93H1CKAl+/ir4vjttcIj4jjdEbpjivjFJRxmwuI+veOeoFDf+oRKnRxi6oKMsyIFxKSz1yn9KaR1YdlDciuLPzWDHPzS10TIHlWUJhHSvgoqYUfE15nKYSWsggPj2Nf2eQ0po84T6BuiYNsotvWEXflSC8T8OX9srTStj0ev5r08iag29UxvKDCJvE4kXc1qK3APVbuKdlcI6HrxRmeaY5cmORwGthfDtCGDEXR3Pwp0DNQ6475oXgbI557bljQUROITTgjf1yEgIjEvacgtde0Cxkxfa+x9diOKuyFLIB7KTpBUQNho63FgSkfBQb3zYktsq/GCMdf3zgr/6XBqDvr/7df/y5v8Zu4PLjP18GRIQQFcefP/e4aqoSOA0vjATgJuBpIUQ/cB3w3b//g/i/w9tqAkcCMS2PP1YmeyxOoEclUTdJfK+C4wq0SQiOQLHe65Hq1Ta5RTp22NM5OpaENOAncNoYsUQRKwTBThV5Rs5jafq8nm2x1ts5KsOeQ5N/TGDqCr5x4V0wPX4iMyaYnOL1urSst4vzbQ9hhbzgiMCGMFZHlNh2jeCgTDigE5qfhlMzno3nhEqoV8LWQD99EmNxgVKNi5bzdli5kTCclCW/tIRaBCtqozUU8Pd4iwvJ9AhVVgiMJgOhS9h+sDI+cAWxjQFcxUVry+FLe2Q3O+hVHxLbPIMSBF4gSkb1tJ7b4pRqXfxDMnoF2Fvi+KuL5JtdbFvCnFJicl8FDPtR8gKzP4Rea+HawrOZzHj624q5KfwDKrkpnl5fsj3mu7I6je0Df8r7fMNVBYL9All2kP02/qPeRJiZb1KcZhCvKODzG/hGZXzjniWnuyBHvDFLfpoJzybxj0jEDsooWRl7JIDrCMpDIdQ8VMTzOJaEI4H/1BSiLOHaAlW1MddmCYfK6MNBzLkFCjMM9LhL9HVPuWCsyKPmBW7IJlBTQD990kuXGtFwmrwdXL4rhrk6R2ybRmDOxD9kiCvPxQnNyOBUmBR3Jj0FRQDKdZ5hitqWR5yVxiiqGKMBLPt4lKvkos3IIpfwVro9QfwhA0VxkCZUHF0mu1SH/RGvj1zh6bHtAORXFdF2hCi02mjjMoH6PJEOBSNpE6ufZHKag1wGvcVAMjwFg+tzmJxtIasO5sk5nI4I0WkTmIdimGHXI1gVvUpCYY6Bf0yg6J49cH6K1z8u1bm4FQbukTB6lYN+ag75aIBcJkBpYQmnrBAYBbvSwJpdwJpWwolbuC1FmJVHr7TxTYCaBTunMpEOeT37g36CAYNgRCc/xfIWxbJDsdXENyIT6lLI9Ufwd/qIR4vejX9/hOBrIYKnj2GkAvhiOnoF+E8eRz8WJTcQ8ZzOUlCa9CMkUFWbic4EpRoXIxXAUWDySALX8GKJ7RkF9KT3uZmtZfw7gmSX6PB8Eqkr4C3mT8oS3+THXJ8kFNQRZ6eR9oXJ90SJHlDwjUsooxqO5mIZMtklukc4DDpEj8heXxyPx0PQI5PacwvebloXGDHQK53junzvczBPysHeCOZwEKm2RL7NxnYkz9VP8mxVJV0gnZbGUbwe/19iR98GSP3FGOn4428qm/4X+AxwqhBiJ3AqMADYx11CnwY2AX8EXgf+YjD7L8D5rus2AvcBP/xHnMj/Cd5WeeAncAIncAIn8P8e/osY5AP8j10zQOPx596E67qDHN+BCyHCwBWu62aO/+5bwLeO/+4PwGEhRBWw4LgsGuAB4Nn/xHP4/8Pbageu+CycY2HKo56FWHzVKJl0iOKpeUo7kmSW6wTOG8UVoIUN8NnEkwUvT3hVmsRrfqLHBBO5IJnBKOV6C2dxDnVjBKUA/rUp7KCDUW1SaHLxp7x+Z7nKparC28k6CrjTCuTynpNSsd7FmF9A8tmEThtDzQrPCe2cMcJ9MDnNwQyB+1QFk51xVMVGOAKloYh88gTBEW9Fr+4KEZuVRimCGcKzeLQlorESE0tN6pvHiQbK4IIRg9KKAq7mxSZKaRUpbqAnPKclV3UQF4xTsUNG3hRlcr6JmfSc23LzDexzJ8i1ubhrMwTGPDvFUpXnEOWEbHxZz5rUFSBJDpEub/Udjxcxk9abrk+R9gwV2xVcQ0avdPBdPIoruUzsqkI4ED3slUhZmkW4kB2IeazZM8dgbo5CfwS1BNLjSSKvBShXe050yR1e7Kn9UhJFdtArbWLLxkBxKWf8ZI/F8Q+olJNQmGLiKlCzeJjYYYnAAT+xlgxWCAq6hu9QAMmCXMFPqNcLj/C9FMXZHSPsM1AKEo7t5U9rWUFmqUG4R0LbHCY04Dl5CeGiro/im4DoUYEY8hPrEMQPSqgbI2QXmVivJ97y+BaTMqVKyI6GCR3wlAix+SnMZXlCtXmi0yYopQPkDiYQWe87L6RC2CdNguLi7oihnTZOuFMm2ikIPBfF6gwT6fIiZqWM5wgmHKDsMY0j88ehP4BkQrw5S3AYlI1R9LiX+54ZjuIb9/TwWsggP1+HmXnwOUQ6FMwJH75XIvjnZFAlG7PWwI542dLZpTrFZht/WMeXgXKF168lYBOc7jHIA/v9XpRs3CD4fASztYyQXPz7A1Rs89zM6mozWGMBZMWGsqcssAzPMtY8ZZLCLAMRsIhu878Zq2qYCrqu4BtWCA1CfEMAYUiYMZdCu4lcoWPMKJHfWkm4H0L9YJ6WZbQvQWy/jNMVInHSCOlUmGinINIpk9ysvdlXjr0cQFVs3JiFNikgaDE5y0LUlpHKErULRnD7gyhFkFQbt6Bgr8ghsirlSs/+1XfWGL5nYhQagFVZrDcSZPpjBEa8uNhinVf+Vgpe+bumchKRUTFrTbQJmckFBr49AcRpE5gzS2gDnrdBwG9g74oR7hEET0oRHJAILR1HTMvjUy30sSC43vXp3xYi1iGjbI0QHBCEYmV8DQVC/YLSriT+NCSbMmjN+bc8vv9D/KPK5//7RcBWYJoQok0IoeGlXz7+1wcIISqFEH+ZF78I3Hv8efl4KR0hxHxgPvA8MAHEhBDTj7/mLP4LDcneVhO44wjc5hJVLWkS+yWKz1UTTxaIhMr40p63cH5dNWaFhZHzIXIK1qtJEJ5cLL3AplwBVsELP2mdMkLomQjapHdjSY+HCfXKKBMKTtLTjUe7XHzjglQ6TLkCgqePIY6EiL3sGV8IC0JBnWBEJ7ep6nimsYv9eBV6zLNAlUzIzPIMZQrbK4h0CdzDYSb7o0wssIjt9MgsPFaBEYb4GcNelnBZQd+cRIvoGH+uYWw0hjmriGSAf2uIWFUeM+ziVJiEtgWQdQiMQnyPSuZogswMFyMGGMcJYgtzyH4b+ZkEyf0Q0DxtZ8VWFTPqEksUSG5XKFV7n7c1v4C1P0Zmjo1/Z5B0KoxvRKFU76AtmSDsMzDCnk+yq7pMbqj2zFfqDbQsKGUXW3NJhEpMTreJHfBIUZJw0YdCAJhB8F0xQmaZgawL3Pk5CnWeiUix3sXelCDWlKX8XBUoDoE+Ff+YRGDEKwlWbFZRz0oxvLuGzDKdYr1DxK9TsWaIwlAY/zjkpjpEnwmRm2USOSaRP6WAZEJe1/CPCaTeAIGwTqnJIvmGRqkK8tMsbB9ecMjemGdb2+AQvXKA6nmjuAqk5zrIBjQ0jnsT01uEcI+3GzSHqrMGvHN8tpJYqER1xNOuRw4ryK0FryVSUpBDJuWihhbVCQ24OM9UeJa4Ic/XPjkvRaHBJX5AIjAgobfqlCvxdNUlQXFzBZIpyM2w0N9IYpyZxZEh2u1iJSxiBxTCfZ6nvFlWCO3zkYwUPWLY6eOoCZ3sMp38pB/7sSr8PRqhmgJqTiCES/iojCQ5lCs8YqdVZYLkoj4dp3rKONok2GHPC2GyDXydfipe9hEcdimencNZOcnwaIzkHgnblog1ZdF6PMKBloGqaB51SEPWbBzJux6jp4x6i/yeIEiQO7lI5pSSx1spCsKHVTTNQuoNABC4cojsNBf5tRjaiEJ+dZFQv2C4owpJdci1eIvZctJbxASHoFgHmYEogSPHte6yQ0vbKLUVWdyQTeGxWiTdC+oJ7AqAKXkcA4C5OeSgRXZnFdnpLtXLh3Bdz7CJgO1JCGWXygWjyKsnKNfYiGVZci9X48ousV2eDa5QHIyFBQxTIbglQLjPs07WTQU1C7k2l/GeBFVnDZAeD2P1hXDWJwjV5nHm5olcPIS2dpzsQtMbLwEoDIdxgfe4GIIAAQAASURBVFy7Q7TbhdMmEI9WEHw+8tYH+D8ZrutawMeA5/Am2T+5rrtfCHGLEOLi44etBTqEEIeBGo7vuAEV2CCEOIBnOPbu44Q2C3g/8JAQYjdeD/yz/1Xn9PaawA0Z9VCAsE/HDEGh3kV6PIn1TCXguYYpJah6QybYqVKxW5CbYVLfmKZU1rydySmj+PpUtJjO0KYGslNh4vQS1WcMENnhx1hcwEpY+Hp8CAdSy20KUyyUrgCuAqM9SQLz0zgXpQkNuoR7BeLZJMXeCMacItryNHJJIOsu1pI84SOq58SUl/CNexe0viaHFfYMW2IHFHItLrkWkE2X8LkjDKejJDf68AcNjKiLqtrkWiEQLRN/MYg2CWoRT2PaL4gmCthrssjzsuRawVbBl5Lwjwl88zPEG7O4eZXyUIjm6nEAXCHIbaoi1wJ61FtoRPw6hQavwhDud4mEyjAjT9v0IfLTTWI7fJitZaJTMl7v1RUEUi5mS9mLcJVAbc9T/ZKKGYJci2Dqsl4GD1VTvVkieUk/0cfCDHdWMGX2AMEhiVI1ZNfXkKzKoRQEyXDR8zSvLhMcFJSqXQKqhZ70QihcCfRZJZSSi1WvIy5Nkd9aSeyoYFrzCHXTxhgcjZMtBog1ZlELLrEOiexUgX9AJX7hIKIzhD63BC8kKS4sERoA61CU2pY0xRo8LkWvQnaWx50I94FacIkelRjY2oD9h2qKNV6krK1BWNOx5xbe8vh24zbFes/bPl0MeuRECcZ6k3T1VyM/miQ308TuDhHvALkgE94SIBYvEn4hTL7Ji6Es15se50OGyaKfyvljZGe41J7bBy74500gnTKB3mRizy1ghRx8Q4qnad4dww7C2EkWFZtVcm0OjuJVXMI7/Fhh0BSLltlD5PZUIO8PkdzoQ9ZsMmtKGAkH39MxzIiLkFwqz/UqlOaigkceLcpMaRxFu2yU0dEYRhywwZ1UScwfw5HBvGyCUuXxSMwDUWKJIoUGsFN+ZMklNAhKZwBtEsZfqIepBUKbQuhJr7owsbkadUJGmxD4xkHbH8R/IIAd9tzRik0OpbwPNe+5kxUeqcM3IQiMuQQWpmEg4FWofA5SXwDfjCz2qkmK0w3UbWEKjS6hFSlPYz0JxZk60ViJwgP1yJJDxesqEwu9MBMtC4GUl8pmxiDYL6FtjBDeGsBI2vjSgqFUHGd3zJvA8zKxc4eQDIHxSDXFkoaWkSnmfEROGyXZmiHX7lJXN0F0qx+6Q5TzGmrB26BIaRVTVzxyYEagJMuknm1AHtGomJEiP81ClhycrhCTT9cR9ukktqkEF6WpPn2ASF2OyFNhGmaNkDrFRJJcxk82sC9Mv+Xx/bcH/z/o8b/7b1z3add1p7uuO+V4SRzXdb/muu7jx3/+s+u6044fc9NfzMVc1y27rjv7+GOl67q7/upvPuK67jzXdRe4rrvWdd1j/4iP5P8Eb6sJXC4D83OknmrEXJ2jadEgZgQa39FF3aU9yDoU1+bJn58nuXaI9Oll/IkyExtraKqYIDfLJOYvoS3MkHgqiF5tk+hwqa/K0N1fheWH6PMh4ru97ZTtg8QuBTlq0LK6F73JoHHKKPb6JO4LSdKzIb+66CV4ZSWSzwVQHk965eLzC0ypSiFsCDXmvBtnGuIdLuWRIEpeIr5FY3L+cVtQCyZmClLba4ivC5Kd6lIXm8SuMilk/US6oDY2SWqlSd07u0kvssh1Jqi8oB/52QTFgQiRh6NYEZtCs+cGV6pxsbbGCagmldskmmcOk368ET0J6fkOFWuGSBxyUdekqW6aIP1SHXqNjTkaYGyNRb7kwxgL0L+5kcQOlewiAy1gYq9LEngqRnZ9Ddo1I/iCJmqvn3KVQzkVYPR0E/+4V5Y8ur0Z1++QmS7oSyUYW+bZt/aNJyhO16laNEK50mUiHcI/DsaDNQQHBY4pkZtnUD9vmMLz1QQWp7FqvRxoMehHssHX7YNHKj0JTN5l7KFmJvJB2upS5EbCmK8n4aoU+SZgaoH4EZfh1+sJ90Nge4DSmjxC8sZPuB9GxqKYs4rYS3IYUfBXF5Gqy0yeVaBULdDj0Li8n+B1g1StGkKekcOIweG9TQQDf9NE8P8ITlEmdlgmOChQnk7QcnIvxXoXX1WRKU0jWAGoa5hALguMqCAwIGFEwXwtiVrwzIFKVd7fmpxleaRGS2LkSCWhPkHv5iakjErxQIJiSaNyo4JZ9oJQzKhLscGlYtUwU07rQtgC3xUjBJtzFBpg8pQSRhz8i9KMP1/PxOMNxBeMEe53GV9uEtoYwpnwEd8vkV5g44RsnLzKpO5HPxpF3RnCNy5RtU0w9kQThReqcU1By9ndtM0couZ1idwW782rjyTIT7UwDYVwH8iPJqk8aZjIMYn0QIzQ5UNEemByitdOkg6FKFV7C6/4KSMkDruYDTquArmZFuGTxqg5vR+A6i2eQYmU0tBnlbBrDNSLxvBlID1HMJkJUrEbop2CYHWBcC+EHo5SGg1RXZMlsnYUyRDkin6SO2SMqBdjmz+QYHyRTe+RGowLMyR3KiRXjOCuzSAbEByCwIj33QTGPXVDYMBTZcReDeBbksYMAqpLRNOJH3bRE1DxpGfSE93ix3i0GuuFCoQJE6/XkF1oEu6DKU2jpFcZEHAI9Qni6wNMzjcptZgoikPTRd2oOUFmdxWBqiLuqwlCsyYor84zuK3ec2Zcl6RnuIJCd5T0mWVyj9ch+y0yY2GSr2v4H3jrLaL/CIITTmx/L95WE/gJnMAJnMAJnMAJeHh7TeACEg+GmHnFYZxDEVTZM444sKeFjo4GgiMgDoSJPhbGdQWVz/mpeCBEucGieFcDSkahY18TuYkgo6u8OEb9sgzDO+qofUEl2uMwMcfFPC2LObVE4rRhSlXgOoKeTc3MaBsi/XIdsbO854ODnjlCqQrUgtfzHV9tEBqAGTWj9D/aSuU5AxRGQ15p7+QyVkDgH5EJzksTSDsEjmm4PsfzCW8p4vhczDBeuf6JJijJSBMa6fkO2T81kqjN0TFQQ/VGmegRwVAmhnt+Gi0rkbqghIiYkPB2qstWHkafXaL4ZA25ZoEsHPQ1OfSkS7RTYmRbHelzymh/SuBXTYptFrWt44R6JbSojjgQRslLaFmvspGsyiHtihAecpBsjww0momQCBc9eV1dEYDoLo3sySX8GQe3tkxr+whaBpT9IYIDkqcTHgriDxsEVcPLYc6pZGfYTJxWInzuCHNbBqnYqDG0pxYjDoU9SWLbvOzl8IwJlJILc3KoRRcjASMrXJyzJzANhe4djShphXK1S6qjksbl/ai7Q4ycbNOwqh89Dvn5ulch6QlwcHsrk20uidf8uMMBTF3BqjFQXo8gHwlS+XCAUp1DeMBFkRzyf6inLphD2xDBmVWgcoe3c3vLcCG7REc7bRxXgv6JOHbAxewP0b2jkckVZYqGilFhU16Vp7SwhKxDYbaO+p5h3PYC9tQSWtQg2ZglNOQSeSWEGzPJzTdIHvBCXZqW9RPaGGJspU3yNR/1rwoa5w15kbZA/2QMbVRhdE81zYkJGk/uwx31EV02hhDeWPdlXbLbq0itMfAPqISGHQhblM/LEj0iE+pUqF0vo/0+gVISnhTSD7YmCA846Cflqa7PcGh3M0MbGrF8nlyOWXmUsovQJUJbAujnZdHjYP+qmulXHEFJKwztqkWyXdQ8iOl5alYNEu71StXGgzUYIUG8okCk1yV8RCEZLNLVWUvteplck8CIQmLmOHZRZVrTCNajVQjLMwaSh3w0ffAoAIVUCDMC9lXjhI7JpPdWkt5aTfQYBF4No8chOAz1s0eYsryXQG3BiwHdE2eyzcUnW7A+TnqOIDvTofbyHgpzDEoVAmNVjvgpI4T7ITvVpT2RptDqRaN2v9BKvkkQP32Y0WUu/nEIXzRM9lSPS1K9w8UMu2AJopcO0nmwHhyBHDRpv6wTpeQi8jKSzyb8VJj+TBxZh+iCFIbhcRcifp0FdYOoeZicZjM52yIaK1K5XcCwH7XgUhErULlBJd8II2f9J3qhHx/7J8JM/u/xtprAHRWGV8G2rmYWrD1M+vfNzLngMMQNql6XKdR5YQ+x9/WR1zXGlrlUfKwbX2WJzFQJNSuo2CUROqiBJaj5kx9zawI76FCoFgyfYxHqE5T6Iixp6WPoQA3aJCxp6WPB2sP0Pd+CtipNdTBP7cpBSis9V6rYUY+pXqyUiG/TcC8dZ0IPUFpZYKIUILFToWK/w8opXQSuGKbUbJI7mmBkmaBUa4PPoXqdijPqx06aXt8xYVJscJFiBvFDgsQ+ifRqneLOJEpngNQSF/mCFPKWCLqhYLeXkGUHN6tBxpvoOtJVOBMaze88hl5rUfh1A6FnI6g5gS/jUrnbIbohwGSbQML10t4eqMJclkfP+KhZNYg8JU/VWQNYg0HyOyootRvk6yScd46T2Kli9wdJv1FDrs2hOp7DN6IQHnA4aUoXmSkSzoSPkGpQaHIoN3jmGC3ndKPWF/H7TLp3NCKZguQumebpI8RfDTB0pIq9R5sYP0WndVE/RluZ0ABk51r4KkpYtszIMkHIb5C+tIBeZRMYkhDrEthZjdrXHUIDULELYh2Crt5qCu0m1c0TFO9r8NLFyjI96QSxo1C30SF21NP/BwcENU/4kH02xUYXO+AycrFOcrcgtcilc6gK31UjbN8yjQVX7ccaDjA+H6R/QFqTFjGoXqdhvVBBsQbaK8Y9pUGFgZYRuLZgQfUg1W1pYk+HqHzOT/yoDbZgYCSBVVbw7Qvg2xpCeSDpqQguShHf4sMX1ilfOYGYP0nPngYyC0zUcYXMbJeqm7sY2F2HHbYZGE7gvJzEaNEJTs9ysKue1GNNqFmJVDpCsaxhRiA9WxBclCZeUUCvsZAsl+BhjXJX1PM2WFJAMlzScyRa1/QQHHEwq0wa3n2MwbUu7pEwzsNVBIYkZp15lPQCh4q9LtGnQ2SmSvjSEuXVefxPxrBXTZK7MkfnH6YR7faSz8aWO2jL0zi2YGAswZTrD9P+/sOULshiXpChuCuJERaYERh+pMUzk6kW2AGQp+awbImK+ix9rzTDxeMExm2PzFlhsau3kdzJRSq2KxQbHGThUmx0kNoLVK8cwpUhNOxQmOqd90QhSM9LLRQnAlTPHyW+dIyKvZD/Qz3hAYfAKDgBh4l7m4kmCpQrQRIuhWdqyDeCnbTYt34qFa0TqDnBwgsOIiwYTkepnDpOZr5Je3QcuTNAqD7P0NkWckuB8BGFvO6DsA1FmZqH/Bx9cgqpRd54qn1SI7XCJvBwjIqzBlH+WMHU2jH0DRUUH6xj664pFNtMCNqEqwr4HkyQmSGYs7SL8YUu6T1VZGbCrFM7qV73D2Bp/g0I1/2HPP674W01gQsbj9y0x8/Wo60E0ja7h+qJxEqMLXdQSpA4CEf6atC3Jgl3Sxza2E7kqTDJgzaVpwwRvbofa3nOi6wMSOizSkSOSRSXl9D6NcwoJPZJ7Fk3ncT0cRwFMoafmOZFDDrrkowWwwxvrqelKo1wwX/lMNGjgtYrO8m1udSEcwzurcW3M0RxbxLZcBmfK7H/T7MIqgZNT3mynNCAQEvLUJYZXWvhH5WIVhQ8V7dRFTtiw7AfPQbZGS4zmoeRDc/NTUtL+O9JEOl3kTZHsUsKimLj+hyIG8hZmUxvDIB9PfUE+r0Qh+k3HCS4bJx8o6D1Ex0UTssT7Xbp3VdPpFOCd6ao+X0AoTq0RdIsbehjeEODFzc6tYQWNlB0mMwHUAsudZtcAmNQsVtQE8xjhVwcVXDkjlkUZxj4RyUODdUQ7pK8CbTOpevlVmJPhcgdTLB01WFoKHnyMsWES8ZBcxAFGa3fx7F9DcxsHqZ0eo7VCw6TfNBjrwcHBW3xNAhYvagD/8nj+Mdd5JhB+cYJsouOE7lUqH5FJVGTY7LoJ7UIVi7rQMnIsDVGrhUmZshvHttwQQ/qjcO4Djh+B9vvEtgdwIgKiFiEQjoDx6qYsbiH3Q/MYfGSTpyYha3Lb3l862WN1GKXyfkmwWHofqoNEbLwHfVTrnFIbvTx2pEplF6oovK9PUz50CFGl8pU1WRxLYlQrIy9OEdhQZn8ZZOkTjHJZENkFpvoQyHM15P41kU5ZdV+tFGV2s02Sk5w4LUpVG91aW8fpq1hDIDW+hSS5ND4mIxchtiyMeofUXFsgbk075Gzfh/H3JCkepPM2EKZ6tMH8I8JrDC4fUEKtRJrzt7Noc56RpcJYntVDr/Szpw5vdRs8apnth/2DdYROSaRbRdYAcG8cw5jxhw4FCbwriFmVo+iyDaz3n2QQp1HKtQqS+QLfuorsoRfD7B1fzsdv5+BvSeG+1qcmq0WWs5jz1df2osrQWjIkymuaurC9+cE1gsVOAoE74kT/3gvhQZYPrOLWLRIe00KyXSRDMFodxK5JJF4NITtSGRmuAyvEjQ9LbCCAnNfjNgxl8hBlaGhBJkdVYydrWOGBYU6CUeG+hckYu/rw/dwHDNp4x4ngIb7j7vitZSwn6qkcuUwh347i7mXdOD3m4x1J9FGVN54eQ5GvYnycgx/t4Y5FKS8tEB6LIKUUThpSQepK4sYSwpUbYOKXYJitUTV6zJclWLimXomLi5w7PUWZl90GD0O2oSMFvFsd2O/jyBcj/hoODINL7tYNQaRbsGenW1Mtv4nGrn818nI/p/D22oCP4ETOIETOIETOAEPb6sJ3FEhGDCId9pofRrDy2X0CT9BzWTG7H5K80tMtgm0Hh+nX7Kd3FSb2BGX8YUuAxfbDO2qZbwQQtoZQTiC5Pt7PBnOMQv/bi/bOTgEWt7Bt3CCiKaTm2HRPxFnx90LMJYWSByxGOiqpGqHTd/GJsqr8yi3V2LEYE9PA7bP5cDRBhYs7ySydhRXgtQaA7OlTLHOZfDZZrLvyXHO2h3gwjnnb8NVHFr+7Glv48GSd7KuYMW8TiTL23E3vmxz7PUW7Pl59CSoOXAlgX1tCsmAyD6VaEBHG1NQe/34p03iS8m0zRxi+ZQeEh0OmWmCPY/NIj0aYcZ5Rxn4zjQqHgoSe28f85Yco/kdxyiur2KySWb1jE6OfWcW25+eTazTxY7YKJqFMRLkpBu3E3s2yKqbtzJwhkt2ukN6Lmw72Io2IRg+x6Bw+STRXRqLzjsI/QFqL+5lYmeV5409L8foKpvQoODIRCWR14KoF41x7PUWAvfGCVYVuHDVDvwpT97Wk07QWpHmULqabLtE8NEos9/ZQVcmSW18ko0dU3CfrGDikgL2hEZpYyXhAyrGlRPk2l1KSUGxrKFuijB9aQ8Hx2swE54LYqLDJbF2mGUf3MGZ522n41AjI5vq0Q4H8I3KSEmdxBGbYh1QlNH3xGl8Hg711eI/e4xth1pZNqOLFdO63/L4lsuALdAiOnoCCrMNzpl5wFND7JWY8b6DLJ/SAy4c3N/E9nWzcFpLJINFQgc1fKoF+yOcN2s/xYkgi6b1EtwaoO4FmeReCXlFBisIr3W1Y1SZZFtlkstGSR7wqiajLzSSeagRIw4VgSJhn8HYQpn0PIdURyXtnz3EipYehHBRSjB0sgsnZZlsE7iz83QPVCFcmL72GHULhjGj8NJhz98ickzQdkUnsWVjtITTVHyqm3wT2DMLBDeGEDaYs4skLu9n37PTqX/Fy+0u/7GWukCW3NEEh++ZhStBw7XHEAfCWDmN3mPVLLx2H8Fuhcwyg+odFoVmh4HTZAJpm5nnHGX00WaanhEMnuEQ63TZ8PJ8Yu/twz0tQ/VOm0KtzHAhQs02i2P3TWdiIsTwk83M+cB+Fq88QvO0EQLDUKgVGA/WIBmCyl2exK/6yh6Cw5CdIlh25R6qXlUx4jb1j2oIByYXGEgWlCsk4lqZfJMgekjGNBS0vINScmlaNMiU+jH8GZehVIyZ1x1koBDF3Buj5WmX2i02tW9YyGmFXJtL8qBD3QZQ94aoXK9y9updHLh/FvqkD/8bIVIXlJn1gQPIOtg+wWhvgkifQ+1v/ThtRQ4+Mp3EWUPEl4xRl8yC6pCeLZGeJfCloXs8Sa5RRgmYZFaVqdsA5QbrLY/vv4UTLPS/D2+rCVwLmBi74kiWixV2iR92OWvhfrKvVTP8cAuR1z1jBtmAbaPNuIqLEROcvPwglLxAj7KhUrnXovlJOHCkgcKKEvqHJihXuLgxEy3n4Jt0UB9PkHq2gdpXZUqjIewA1P7ex/ByhermCYZPkjAqbcyhIPHP9+DLQDRWRJ2UaH0IDj07ldTuaswqEymjEnvDc4Ez4sCrcTaPtJBvddj086XIkwojN5bJTPeIZuXjWdrb188AR1A4J8fYfIWarTZntndgRRzCgw6Za3JkdlXhypBbYMBvKjn1rN0IG2xbQp2EiVKQoKIzdJHBBWdvof6cXlxbUOXLs/KWLSBg8Jlm6gJZ9h5sxozA7GsO0nH3LEoVEsaMEpnL8py68BCh5yIEG3K89MQSMjMEzz6xHH91EZIG1VtdgskSU88+RmSnj9KxKPELB5GEZwgyeW8TYnoePelQHgtS15Tm7Pe8QaGsYYY8bXHzij6GV0rE/xhh051LmXLFUdbO7SARKpH6XQsThyrQK1zKl2U5eu8M0v0x+kcTtP5BELtiALOsEKgtkOhwSByxqAgWoKrM4qv2sah+gNLyAkN/aiV7LE7L41C1x0Iuu+j317Dj9kU8v24xLU+6+Me8dg1AYHeAbJuMHXQIdcm4MvSfBa4tkCUHbUTlUKqaXS/OeMvj21GgYmYK25KRTEhW5ZgwQl6e/ZWDVGoFtr0+HTMCl520jcAYNP1KpuelFswwGC9XcNklG3m5ZxotDwsyup/cPIPStRkya0oI4ZI4YnPalCO8a+lWZBPMh6rxZWwCoyZqHtS8S+Ueh6EfT6FkqoSGvJS+yhkper49A03ynLzyTS5NLwBvxHDm5r0gmsMaVgC6J5IYloIRhebfyLxryVaMOHQ+PoXxbIiXHltCx7op1G6xWd3aRW5FiUKjS0NlhuwDjdSu7ad4U4aKfTZGVLDzB4uQG4pMzHMQLgznI/gXp1EmZRK7FF49NB19fpHkGxpKyaHxRQdRW2JopcKe16dQXpNjaLVE68Mu4xcViR2F4SeaKZY0cg0yEyt0UgNx1E8OkV5bRqR8VF/Qx55fzWX4e+309lWSb3cQp2SI9JtU7HOJvbePodUSPS+3MDnFJX7EYf2GeWSmCbTqEgMXmRhnZInu1mi4rJuqq3rY98x0YqtHWXDVflTNIv3ePLlmwcTjDXRtbcLyQV1llr0PzWJuYghpdo6xGwsUqmUKdQrJ/V6G/WSLxIovbeW0y7YzvsjlUKYGWwP/gEqpBtwRP4d+Pptp7+mg6uoepJLM0Mkw2awQi5RQCzCxro5piTEKhsZlC3cSGAUEnH31ZhxbYsX1u9A0CzHqY3iVQE28dZnk38SJEvrfhbfVBO44gkSHg/nhNKKmTK5F8OK+WSy9cD9K0dMCx466+FakGTtaQahLYXKGzZaBZiRdoNSWqL9bY+qXD1Dz+WPIOYXlrd1wfyV2lUkkViJ9WZFyQsaIwFnXbmZkpafDxYH0+wqEBiDiK1O3yWHJ/GNU7BbMig6jFF3yHQmSB1y6r4DYyaO0Le9FyC7J3YJ8E8x5734i88dRCyD9qYJwl0QgZeOqXliIOzuPX7EQtmdIs2LtAezGMuyPMOXcYwxdqfPMgTloaYmRlVAcDuNOKVC9QycUKzFyvsGL2+aiV9ic3HyMYoOL+ucEG1+YT/MDCqrkIAkXeVJhQ187aTOEP2VhRuDZLQtonjLKnFOPUuufJH1GmUifSWUyz9TKFDvun/vm9xBcNo5vHBaffdAzkfB5q3PfS1EObG5DX5WnbWE/zs9q2PXwbNbMOczImSaL6gcQDpy66CCjB6t4aMNyFtYNEhxxET+tonu0gnCvYLJFQrp8jM6HprJh4xxyT9cyvsRGzQka11nE7w2jllyanhGoRwO4qkTvnnpkzebs1kMEP9pPZopC6rEmqp/20/3NmexcNwPlQIh4p4nWUGBimkL/qTINnzxK6mSL2Pv6kHRB8SMThAdtatYOcMYF21l+xR7KleBKLqe/axtiWp6Wxx0a69NYtkTDepNzWg4R7Xrrdw/hQjJYxCoq5NttxoeijH2tFWNGiYiqs/n2JYSnTyAceOaxFeRXlnAlgRWCd12ynlXv2sXGr63Ap1mUPjpB9sFGGhrSnNt0ENVv4WxIkPx0N68/uIA3vraciYUmE6eVSM9UMCOKV0m5oEjhvRkA9FcrEBbodSbTEmNYfomWQBp1QqZhvYMRlrjgqk3oGR/nT93Pkov2o00C6+NMFv2cctoe+m8weeKhVYQGXRZdsZ+GP2gkDjvIC7NIHxlh/y/mMKdxiNjccSYfqSfWZTArPsKM5Ch8ZJTgqEPh6izmhI9Qj3e7CmkGPsUGB4o1ePaqKT9WAIZO0kjNU/D7TS9NqyQ4v/0AtfNGCH5hgEtn7CXabXgOcGkf4UEbZdiHL15mSbKPyHY/lTNS5H7dyLIbdpG9MUfVepWTlx3E91iMwZNVENAW9oxNtEloW9BPqUrCDtuoea9KGNvho1zSyM41Gfl9K5lfNiNsz953y3NzUDdG8D0do9xgIRteiNLEbFhbc4R4p822OxdRe5eP4mQAR4P0Kh0rIKh7TiE/x+CVu1ZgOArvPvU1GsJZ8m02U0/tomKvi5YR1N7QxZZjLdQHs6xeeQDhgh4H3VQoNEDVLpMjE1UU3qjk6SdWUKrxqnrPPLICx5Z4cdN8YsEybU/oRI4JTms78pbH9wn84/G2msDFuEJgzML/oziqZuGoMOXXDjsemUPtdV3oMcFln38R/x/iXLx6G44GImRySvMxLj91C4FNIVpuOcz+8Tr8sokdtnFcidwlOVr+JCgejmENhJiYKbjmphd4ZNciwj0SdmeYql1F2pPjxI/odI9UkporM35LC2tv3szjf1qNe1WKwIjnhCUUl+D3YvSkkqBLXPwvr5CcP8aesTqqQnm4eJxSlSC3UKfpc4epf8UlGNCp/kOA/I+aCAwLio02+/4wG3dSJdLt0vNIO749QYTkUmq0kKq8FXHyqSBT/+0gxbwPaciHVJLw1RbpuHUO85YeIzxg4p83Qf+7DR7au5Bjo5VU7oLQUxG237eAwQ/pqPOyXtLbj6vZubsN3VFoeEBl9CMlciUfXekkhVYHJFhUN8DZjYeo3mkw+M2paP0+Is+FKdRJqAUXX0bQ/BOZ0Sea6D8LEmcNMVoO03K/QJMs5i/qYsuTc3ErdepfcRn67hTS55TpO9czb8m3uCTPGSR4R4JCg4vSXCA86BDsk6nY59BzlcOKf93G0FqbvktsarZa9FzhEO4TLGocYP8n55G7u5GqXTqxiwZR8zb5WgX/OCw4pwO5bHNayxHOuf4N4ocFE19swten0rmnEaPZoPxCFUNrPBvQPbcuZLAYo/FlAxE1efW3S5lXP0RmqsrY63Wk0hFm3roX2xWerO0tIhwvMvBUC60PQbRD5uplW8i0+9B8Fgd2t5B4Xy/tiTTG3CKJQw7J5/w4msCq1XnuB6ew+XcL6bvUwXolif1wFQtu2ENjOMuzfbMQeC0oxxUUGx2qPt8FriAeK6LlYGSZl39Nd4iVtd2U3ztBeNAFARcs2kNTYAJ/2uSPD6+lYq/D2AKZzGV5nrp/FWvndXAsX8mBe+aQX1Sm/dJOplWN0fnN2QTfCDH1rGNIFmx9dg7Lb9lG9EN9TK8cQ/l2BanlDnuONJH4TpDMHBvty0NUqAX6vzuNmfFRzKDEZF+Uc5fsIXbeEHqVzdCmBlLpMMkDgIDmJ+GDp60jev4QSgFKdTa1P/YRWDlO04slNv1wOcYfaxi/t4UnH17J2T9+lfTaMpedtI1cs0zt4iEa7tZ46faTsE/NMrGzisCoxaYHFiLWJUgtdtny/ByWfmQnSgFGzjR4fus8lLx3vcd9ZYq1kNitULXTxHd/guwCk5ZfyZwzfz/hYYvojX04S3Ooz8Q962YFzvvoBpSMTL4BjCoLR/PGkFqwCYw7yLpD4KhGZr6FOuCj8apjhPrLRPZq2H7Y89P5/PGZNfTfOp1Qt0zRUjGvTmNrsDDej2sLXt46hz1/mIOSl6jdYvDOKTtZceZ+mr5xmMyOKoyZJa6+7BXKzSZVeyxqtplcPHMPlTsEYztr6HyPN0UEZOMtj++/hRMl9L8PJ9LITuAETuAETuCfi/+Gk+8/Am+rHXigtkThU1l6z1NRX4sgG2AFZJZevo/Cdxqp3KPz1FdORym7vNQ3HbkMDbUTvHx0Oi8PTqV6exGfZKHeU0HZVml4XiKilgk+HUUuO9ghh6bnLEID8Pv7zqLmJRUrCFU7XM74+UbGft7K2EIfgR0BGl4toeYtnvv1SooNNlF/GTMCxpUTCNlhbKGPunt9VG6W+V3HMsaOVFDanSR7dzMVt/opLy1Q86JGxggwfk2RUllj1dc203+G568cGJQpn5qj5WkXMyLIzjGJHXNgzI8whJfM5EC5QnDgO/NwDRk7ZnPK6v1IuyI4isByJJSixeVtu6l4JkDTgwqWIWMFBLnz8xQaoPq3Qd41ZQdVmyX6rzX5l9OfZe83FyKZLu3Jcez9UYo5P81zhsjMcjjw69ms+9EqJj6RZ2SpSsvTRcZPMSjWumSnCir2WRy9UUKvBDUrM7q5jsJtjQysVen+7kxWJzvRJiG6zU96tow2YWDlVaSowdQ7bfyjgtH19Qy9t4ydtDDSfrRJm7rXy6z40lawBbtuno8cMml9QDB0nc4Hl79KflmJA2M19H3CInTTAPnPTpJ7uJ6x60tkziziKLD7+RmkFvh5fsMiApKBe+k4w8sDnHr+LvyjEkum9hAZcLz8+G9VUaqQcb5YSbFaZWl7L5IF+9ZNQ9ZBr7L58KL1HPzaPDb+eDmjS966zKY4FqT2jSLDK1TOfu8b/HHrcuRLx1jT3En0qMT0yBiTho+b5m1k8AwH+51pqj/XRXivj4mZAlyoqJnEPCmHe+k46zfMI29qWK8kmVUzwpwLDtP1RDtT/1hiSmiM6EGFxdX9BMZsgrMmcBTPS/zFzhmc13gA55oUk23w9N55vPH55WT+JQ8C/DcMUbPVRH0jQsWZg2x/cC6toTSZmS7JZJ7m4ASpO1o589sbqNyrc3isivELi6hZ6CsmyN7dzIGXplKuUAn2yvgHVKygQrBPZuyPLaz/0iok0+XVrqmML7YJd8m89OxixjbVUbtBEO1yuXbeVswrJqjfYFD3xU5+9eez8MkW8qlpml6Axn87SnljBdkpfmwNRldbjJ5qoU8v8+xn1+I77OeRzUuxNbBsmYmP58m1CKKBMpEF42iTJlYQFl6zj/NW7STa5bL3Owtwlua4csF2/MMy/pQXqHNSohOzXid+RT/2p1IEUhbXLnmDS297gQOZGvSYzPATzfjWR7DOn8A+OUuyw+JwvoYpy3uJdbpoyTIfP/M5nvzlKRhRBS1r0nm1J/3EESQWjjF6VxvZLxbItdu4azNEenRc2aX2S50op6TpGanAfq6ClafvZ92tJ4MjUCdlEodNarbaLPveNjbcvJLNfS3sH6/F1lwaqyfoLydo/RNoEwZji1QsRyZ1jue9UPWqCmeneXT74rd+A/+P8A/aff933IG/rSbw8oCf0A9j1G1wMBJQudumUKfwasc0fKkSwnbwTZhkpsiIV+KUF5R4Z+MO2m930H6TpO77Xbzy/EImpklU+XNU3NyNJlnkzsmT/UyOcJeML10m+Y4+qnfp6DGBtDBLpLvIvY+fxU1ffxROzWAFYHBNgLk/3Ytzapa2GUPMiI3S+vgkmfEwU39m4z9zjNGlKqk1Jp+e+yJnnLSX2OIxjLBg+KQQH5q3AV/G5lBfLeyN0PJjiYRaINqaITvVpTTFIOAzkYs28tnjRKsKSDeM0vS8RctTDh+d+yptM4dIHDK59NYXiO9QuWrFZhr9EzS+WMCXtQirBqNfKGO7EoUaQb5OIZnMM++Gfaxs7KHxZZ0zvrmBoqOh5l3eM/cN9ucbUIo2wytVOl5t58NXPINrSARUE1FTZvZ7DhA7VibyyxhW2OXCX74MJZn2h4u888INaFmL8+fuQ541iRVyMKosxufITHlwksu//Tz78/WYYfjIhx+leptJvslP85NQ94iP0aUhqs/pR82DvDuMOqJSs0Gm91yF2T/Yx1Odc6h9UeW0O18H10uIav+ezRPfOIMLZuxHWh+j+rdBkr4S/jsTZKe52B0RpvzY4R3veQW5DMapkzhJk6CsE/bpnPvuN3jh0EwCq1PkPlXLpV9/EW1EZXyODy5PEf/BAObVaXb0NlGsAb3ZQLt8lDOX7uMPd56N8Yk00WMlzj99+1se32qFTuErOW6+8gn2ZuqYcr+Dg2DXTxaQmW/SW0wQVg2eHJiHMikj/znJzu5GCgvKfPDSZ1HzLpHbY+gFDfepCoJTs5xdfYDIgENULZPWA9RsK6NX+Tg4WUvdhhw771pA82cOY2xLEBh3qd7u8KF5G3jg0GLGxqIsPPUwgaMaelzm4ua9CAtKv6rH0SSMONh31nDuu9/g1d8tRW3NMzs5wozgEBd/dR1528exyxTm1w7R8nOZeJdNTC0xfLJD6+OTDJ7mohag5ek8s7+9l3K1S3qxRc+FgvgXe/FvDlG5TSI3y2TFmfupfcMk1ySx4CN7+N0rJ5MZjDL3u3s4dP8M3nHpBuK+MvarSRo/f5g9v5rLikv3kNiXZ7JNIMoyM+4o0f5LUD4zTLnR4jOnPk3dpiLy3RVMHk5Qt3qA8ckQkZ9GOeXnm2l+Ps/rz89l071LGFvhMHCRzYrGHjb820razuhGNqF6m8kdu04lXlGgZ6SCk6uPMbBG5ZWRabyUmon1q1oKNYKqXTry2eNMTgQp9UdYc8vrjN3SSsfBRvS4oP4eH0FJJ95pcuO3HmHysznOXLyfmlWDuLJL4Cdxrvny08ytHKKibQJrWxxXEnz4/Oc4dvd0rA1JTp16hMTFA4QUnfE5Ejcs3UjygMtlP3qeoZNkXhyYwdwf7mFKdQr5wSSRbsGUaIotf1iAnpA58n4FlmZ54YmlTKkbo9DkKXgC9yeQym+rqeK/Dd5W34q/oUzP+2xWf3UzTS+W6D8TMucUmdUyxKEPB5j/4z2c+pPXqdxjcNp1W2j8rcK9R0/i8E0agVGTuFry8qY7bF55aAlnVh3k1T8toeKhIO9u3cqiK/Zz7Iow2d81svzft2GemaUyUuDwh1X+5bLHOVyqpfbfVIyEC4smmRkYovbHPt7b9Dp7bl3Ie/74NKFYicyMIGO9SUp1NrEdGnfccSl9H2whX/aROFzmnOvf4IXrV2GGJVSfxcfe9QTdFwS554mzqLlVJdIlOG3OIQK/j6OmS6R745zXcoDrm99g7P1F+s6R+fH2M6gPTSLrDn/80bnUvKOHoGSw/msn4XwrzU13PsKRX88g/osoMaWIo/2PoIu4WmTS9HPsMoX7/7yWRx9ZTeaaHJvevZBXeqYifWGElqfzGI0G9x45CV9cx/piFV9c9CzDX2in8OVJ5JKXpLQl20bkiEx6bog/vnQy458psjPVSDxUQs1KBKqK1KwdYOKbOj99+lwO/XQOdZvK3H7oNHqvsYl0lXBUifDH+nAlMB0Zf9ol0uOi5qDxQ0eJdQg2DLUTfyJEaFDnwe5F+A4GsP0ShaYQQ5cYmK5E9fYSi7+2ncmPVmNEZJL7oP3hSY58VGHjB5ZRqnVpvsUhtl0jJpcY3FbPurtW4loSpY2VHLk2xJARI7owhWRD8tYAx+6bTlUoT/VjPq659BUk1SadD7L3tvkUGsC6v5rr7nmKl/qmveXxLYDxbTXc/fOL6Oiuo1CrsahqgMT+SZpaUugfSzI/NsBQKsZ7zn6F4LBF7WM+Kl728dOtp6HHBbO/tYeL5uwl2mXC+jg/e+gCShUSGzqnkNP9xG/to/8qk9SdrZz369d41yefZ0t3Kw2vlkit8ewyf//Tc0lGi7iW9OYbO+/Lr3LfGycT7ncJ9+v0ne+y5PSD2D7B9s8tpu3yTpq/Lxj+l1b+8LULeOorp7PtM0uoe00wVgoxvNzPu7/7BNtGm2h7xMb4t0mWLehk4TX7OHp1kM13LvGY9zsVXMXhkupdOAq8/3OP4R9Q2fjGbK778RO0nt/F5vsXEByUWDKni53fWoR+ao687aNCKxA/ZtPx61msef8W9v5iHk5A4X2XvUDdtDFwXbLtPgr3NCLnZH74zIWk5wQZWSYTn5FmaGMD75m1mZ6rHO7duYruC8N8+p2Pkplt09A+hjqo0ZNL0PrxDvofb+XMD20i265iFxUy4yHa73R57MHV+NKQfb6WsdvbmPvJPVhhOHa9wLRkfD0+2h8yuP/FkylVq0i6xORCg+InMtz/8fMZWKvww19eQbYQYOtvFnB6zWGihxT8gwUe/uw5bHl4PsXXK1EKkPvMJD/dcCaOLLj02g1sG2pG/WqcA7fMp/HlMi99ZjW+9wxx308vIDQ7zURnggWhPi6o3kuk32D5e3dx8LZ5lCvh9C9s5GsnPUHsgQjleovSTxq49OzNhLslxucI5OrSWx7ffxMnWOh/F070wE/gBE7gBE7gn4a/pJGdwP89hPtP9I8VQsSBXwJz8dZPN7iu+/p/dLyvpcmdct2nmHHeUfa/PJX6jSaS5TD9u/sp2RobX5lL9TYHtWAz/5u7OfCZucgli8zXSyysHKAlMM6GqxdSd88A61+dR80Wl8v/9Xnu+cO5tDw2zsGPx4jvU1jx7l30fLidw+8Jo9YVSYaL+H+cINuuUrGvhJzXqb5jgAsrdvOzT1/J8DKF+tcMAl8axP14jPR3LYrrqvj8Bx5gxIrx0y2n4+/WaHi5xEfveZDbbr6a0feXCD4T5eOffZCffesdlCoENVuLdL7TT6w9Q6Y/RuygjOWHxGGb9CwZbVUae10S1mao/1fo/LxKVTzPZ6c8x7+8fA2+EYXTz92BczyVYtdPFjB6ukkkUcTZFMeMwtqzd3FBcjeTtp+cE2BfoYFXHl5Czen9jKxrxJU8CZxyVwXluIQ/45CeIVOcpSOrDqFQmcSdYYZXqjS+VOLau57mnp7VRD6pELgrw67uRhoeVhEODFxp4POb+F+MYoYgccSm9QuH2P+rOTgXpsnvSyIbYMQdhC2IHRZMrDD44cn38+1vX8fEWWVi0SKZw0kqZ6YYHYnxr6seY3OunW23LWbkVIuaVxVcCd73hSd46MNnc+wyjY+e+Ty/ePRcrIinCT73W69y1+Y1+AdUVp6zD8uVGC2FGX6ymdwMi3877U989U/X8NHLn0J3VH7967OJ9jqkLi/xiXkv8Yu7LiI3z8R1IdCn4psApQiV1/YwqftJba8hsmCcnRd8a7vrukv/3ushOqPGrbj5c5y1cg/dH5nCxL+WGR2MM/V3NgNr/JQbLC9zfUKmackAPXsbkAxoXGcyeJNB+MUwoRGbwZMlwr2CfJPLxy54lqwdYP9kPTGtxO6fzadQJyg2OIR7JApNDk7IpvEZGS1rkZmmkW+Cmi026evz1NwRAAFdl8ictmw/L++YgzAE8UMSmZkOTsChfp1E4Zos8rMJMjMdvnve/dz25atIXVmk/m6N0cUat974Gz679Z1cM2crr421M/haI4FRsAJesEzFeh/zP7CHfak6Si9XccbVW3hlYCqTmSAi5fOy4g+6+NIWC7+1k7QRYvOLc6jdYlGqkAlcO8Tw6/XUbzQZvEmn6v4ggZEyXZcEsKsNTpl+lPMq9rI138aGny4nd36ecjpAqFsh1ungf/8grisYe74BXwasENz4gaf4TdcKqj4HHR9M4gRsKrZ4vJiTr9vOuqeW0HhyH3PjQywNdzFkJlh33XImvmUyOhojskdDT0DjSzq2XyIwkCffHqVYJZM8VKJU7UPN24wtUIkdcxg418Y/oKInHaraxxnrSxCty1HxkxBDqzW0LCQPmnz8p3/kGz+7nvqXJjATAbo+4DL1dpvOT0o0/lplYqZKvNPCN27Qe3aQ0y7YQddN7XTcFMWfkijXWVRvkjnrU6+xKdWGcUcdjiYYWySwKi20qM6M6lH2HmhBKkpMW9xL6YcNbHj8c29pfP9HCFc0uXPP+5d/yN/a/PtP/6e8x/+v4p9dQr8NeNZ13ZnAAuDg3zza/R9SmIb1BtanU4x/osCzWxaw9dG5fOeK35FvkNDjMm/8ZAmuLChX+4l+J8xrjyzkkR+dTu7fTXo/Nx272sSX9fTLH7r2KQ59JszpCw5QXF3gyGQlY0uiTPtNAbsrhPhVJQu+vZPwoI2jSXRfGmfk5ma+9PjVBAaLXHPpKzg+iaBikloaZ2JnFfUbcryUmcUv9p2Cv1vjnIu30P0hOGZU03+GgiS5xA+X+MaWizCDgvfc9Cylr05y1kl7qP5XlRtWr0cyoempFP3nuVQcsMlOBMktMPji7Gc5+jkNtzdIe2ycW793PdGDCokOl5eeWcyRL88mawY469OvkazKUeiOoubhG1fez/axRn4zvIpv/e5dPHbNGo58fBbTzu0k9WQjkV6Xco3DZMlH3/kOp9y8hclmGX1BEUoy02/JU/MdjfQslbYHU5S/nOWnP7yC8Y21oEjsHaij/W5vQdh/hcnVc7YRfCaKI8Oaq7az8Ks7GftgPVrOpeL7AaykReKQw8w7UsQ7BLd85j6kCZVPPftu1HeNMvUHBjOSo7Q9pjOeCTP1Xpvv7D2XTUNt6DFB6JhKZrogMG7zyx9fjFS2qZ0xxp1PnUPTSzoz7ppgZLnC7x44g9AxFb3Wov/zU9l4YBqX1O5m5uWH+dyap3l8fCFffecDTPMN8/u7zqbxpUm++u37mPKNEj958CLKVaCGDRqelTEjLtVbC3z0Mw9xdFsz5gPV1G62iNwZe8sXgyxcVi07RO9NLXReGab4ahVTf2czstSPcKDhheOXa0sR50e1tD5pULfJwQrJNNylUawFPSZRvd3le5+8G7vC4ucHT2bzFbO4vnYjrw+0YkQEbed28ZPzfk1+lsn0eyeJ71LJNUkMr/Tcw2JHXfrPEKxo6OFLv/gVqTkabY/alG2VtmlDJPdKCAuqtgvUqE64t0TwgbiXqvWQzk8/+y6E7SIJl+6LZT5y/RN86/D5OLbgtU+v5FOtL1C126ZYC1YYZv6gQK4NXt4/k9TRCioOWuz/hOc74OZUQu1Z5qw9SmhAx4zIrIoc5eLKnZgtZZS8zdhag/yf67GnFRn5QIm27zrYPoFkOgQHBfFkgT1jdfzrH67iySNzyUwXiL0RghVFPvLuJ0hdXkL7bBghXL7xgd/R9p4jRM4b5he/vYDLm3fz6ccfJtaW4eS5R0hc1UfFRf00+DK0PJVjfmKQ129bxtefeSdPD80hNyXKaGcFycocegKMepOBU31k21VO/8NW3A+PMTHXwQwpFKskJltVkocs3v3NJwkfUSnXm1y35jUqviDT8Lyg7hsC30iej73rCS567wau/vFTfOW+6wn3O3R8JkDnNQqRNwJ0viPE95f+mXKlgmRA31kSy+/YTtsDKZ7dPxczGWDJok7ceTmqN8nED+RZ/7WTGEjHmfOFvbgCZq3sIlJRYFbNCL0PtaNkZRIzxzn2egu95/wneqEDuO4/5vHfDP+0CVwIEQPWAPcAuK5ruK6b+VuviYaLGNNK7NnZhh5XuKB+H2vqjzFnTi9fueF+PrvuKqou7iPaWaB8WZaeGx1GFyncfN+fMMNQ954uBgaTDK3285WVT3Lej17h3t+dy8FCHSumdbPp2fnI+0KULZUZ7z3I5LQQwUGB76YhArLJwGmC7KdyxI66jC6P4NTodF4Z4b4tq8m2KuzYPoXwgIUVdhhdFsFwFDgaInnAM1BpuUciZUao32CjrIshHBe1y8+HPvEoD377HNLra+n5YCu950V4+VOr0c/KYiVDzPxxBuXmIab91KTlAcE9N13CqtYu5LJg5HNtpBfZ3Hbzz0mdX+YLVz5E94UKmmTxx5dPJvqTKFJticwsh+8ePIfvz/ozQ7dNAQkG18ZZ9LNdHBqtJrfQYGSVg6u6hP0G0f0qh65swTglhzscYOrvDJyAysBpIeKdFvnpCcJfDFC1LUu51mbgzCTyoRDLbt+BKyCx0c/TvziF2Tfu57ybNtJ54xTW9U5DrwkxdlGJb/zqXmZMHyAzXWJiSRVqweWugVNx4ibfPPtBwt8Ic80fn2e4GCHzuTxSVwA9qRF/KMSlLXuIdVvUvVbCiDvc/KP7iR0zGFkZYrijiunLe9BGC+T+3SSyKIURdQmsTjHrh2ky0/woYypDRpxj903nF0dO5ujPZvGrD1zCPUNrMMNQbAzxxdtu5NQHd7LwzA5OPnMPdckshVqJxSuPkJ0W5JZXL2HKnwt85PMPo5Qces5/6ze4Us7HoXtmM/Ydm1in4Bvv/x0T0/3kZ5tUbzcZWi1QMjLBgEGgO8PX774X+WPDzP3Sbuq/eZSGV8tkL84zfnmRDz15I/9y0vOI3RGOvreGm5+7nsW1/RhxOLv6AF+8833UPyvzwT8/Tu3GDKe+exvRbpfA5cOUqgRqdYl3Vm7lw1uvJTjmYgUlDtw/i2UVvXzh878j1mVQrBY0361w7PIgjgKLVhxFr9BQijap+TLStggz7s6xOdtO8ltBolv9pD5W5N6hU2j67GFkHSQdjr0ridFoMPNHeT551jO4nxxFr/DB80n8NUXsLXH2bJ7Cytu2Et2X5u4bLuVzT1/DjO8XyU7xEd/iI7u2SHNVGvn1KB+8/1He/ZUnOfquEJIJpR1Jwj6Dz1/1EB+b9wqh2WnOu2QzifvDPH79WlwXPvXnBxnc2Mg37no324+2MHiomliXw5MDc/ncDz7ApS17eKOrjVWVXfTuamBp8Bh2UGVt9BDXfuFp6jZA//YG6j7ZSahP4iNTX8WotMEStD2Upu65Yfbn6xk6UEPtJlDKNuVKqHlphLEFCt979XzKVS5a1OCPT6/h8OcDDFxk031JnEOfCvP73uWsG5pBqzaG7YPo/jTRrX5m3p4h1m0R7xB8/WfXc8HnXuHyD71My1M2L/z7yYTunqCxfpyhj+nsfm0a18/YgvHOCYTjUP/5TpxjYZ7fOZc1n3uDvfta+Ld5D3FwpIa5Vx8gPCdN5LYo0vQcDS+95eH9N3GChf734Z+5A28DxoD7hBA7hRC/FEKE/ueDhBAfEEJsE0JsK0/8J9v5ncAJ/Bfjr8e3XSj8s9/OCZzACbyN8M+cwBVgMXCn67qLgALwhf/5INd173Jdd6nrukuJhkmu8+NLS8Q+1ktPqYLnnl7KFbU7+NY9VzFrZj+Tv2mk4/1+cpkA075bJtLj8vMLz8c/J8OEHgBDwlHggRvO5bmRWVhBeHbfXLqySVwZ2s7oJu4vMfH+Ks794noaXhxncCLGw4+vZsadKao/aTO60iHX6i33KnfDl1Y/hTbpsnblPgKd47iyS6kaxm+q9kIfLjZ47NXl9H/I5Nm7VpN+X4H6d3QzsDZIYBRuv+9SijWCUy7Zhf+2cVofTdN1ncsvFv6Oo1drfPGpB/lQ83rGv64zcKpK3802lutFkpa+kuXuc+7hk7d9iKpEjl9+9TKSU9Mc/tlsTjlpP8Uaham3lmmeOYxPsbhv5BRGlwp846CU4ck/rcLpiDDtFyZyQeK0xfupuNniupuepzCrkgun7Kdu9giSYfOeB57FiMJkq8LA5R5juf+MGP5hmWtufIG2h9Lsz9bhqIJPfOpBcq0uS2PdPPWb1QjXpeH7CrX/2omV07j1imvpz8RZcu4B0jMF7/zic4wVwyC59BqV9J0dot9IElRMoj+Kcv65W5hsktFuGCYml/jCbb9G600z41d5fn7jFbzz9mcxIqBlJDTJ5saHn0b5UQURTcefElTc4qfwU08yGBiFB549hTu+cjvGliSlSoFcMNm+q51SjUNqrkzNphyPfftM9j4xg4GPt/PJ1heJ9Nsc/f10bE1wydIddH8aDpdrmfzkJPUv/3078L8e33IwRNWWCWYmR0mv0rl34GTUoktsl4r/84M0P2viai6RX0cZ+x5898xL+EDLBpr8Ewx8Yxp9H7PQ8z5+vvR3OEGbJz5wGi1PT1K93aZym8S00Cg3X/s49/78Apoe7OWGbz7Krd+7nqOf03j+yaWMLXVxXEHjuT20Vo3z2T3voKUqTaFWMHi1Qe1rWbZ9Zgmf33IFwnY599o3mPqdg0z/SR+f/ervqfFPAlD6VIbmZwv86P13c/S6GH1fn4Z1SxozDFW3Bdi5p43Xd0yn6bkckgnz1h5BGdKwYn5+fWwln2x9Ef9omcZ3dNH6dZ3iDJ2ZS7sJygbTfttN98dc1EmJI1/yM/V9HdQ92UtwS5D+zY2EB12+c/g8bCQiXYLwoI1cAt/3EtzxvctZFjhG9Xd87Jmo5xPfup9Cc5DvLHmEATNJ48tlpl98lOp1Kg2zRrjyq8+RKQSY/u4OXhqZjugJsCvTiFwS3PK5G7nyzmf59EPX86P15zC6WMIKOdT7s1Sf3c9DF67CNyrzL6c8R2pZAqsyQlwt0jJvgPzVk3zhnt/woWue4uSH91FuNVkyt4v4rHGSTwT57KWP8pWlT6OMquiVNtKESvmxGi5v2oWES2BxmtRJFcS6LcoNUXov9PToM99xmBe/fArrPn8yAPGOPLv6GlCEQ/O3vRjWB+45g7qbS3R8PEDv7dNo2GARqcnz4PqVyCWJr33rBoyCyv7fzcb3QIKRD5Yxe8K0f/bQ3zW+/88ugn/g478Z/pkTeD/Q77ru5uP//jPehP4fIq6WkN6ZoumFIsdebeXgN+Zz6UWb+O7ec2h8PsO82CCVG0dIbleZ+kubnosTlJOCsZMq0U2FgYM1xPYrtDyZxVEl8vc10vbnDNN/plPxKbjg/M1EVR1u8mNWhnnx66cgyiaJx0M0vqxz6COVWFURbjhlPf9y4ZPMvCULrsvth07DCgqmBsfQWxJctHIn4aUpzMoweqXD7Sf9keReqLvHh3bhGEvr+hicjNL0fI7kIYNrrlvHTTc9xfP7ZzNeDoIQJDf66DDqqGtP8ZE7P8yXH7oG69lKlBKEAzpbX52FNgkjO2u5d+QUJmdZpLdXk54pUdxUiVJyWb95Nh/40iOkFycZyUZwEPR8ewaSKcjOsal9qpdivcPMk48xPj/Exy54llePTMO62+T+28/GkQWPdsxj4EgVPZ+D3150Ojde9AIf+fCjfHXZU9Tf2cPHb3iUco3NL589k3c8+AqT32smeniSr79xMX9614+5ffdp1K/LkJkbBxdSn24mekjh0EdD1H9PYdOWmaw+Zw9Pf+w0ZiWHaXpY5pmvrUXYcO8zp9P3SBvjNxd4bOtiIhcPAfD0TWv4yLPvZegnAbq+IGHGVH7ZuZol5x/AlT2ORL9RgVqwyN3fgBGHrk8JRrMR3CNh5NPSfO+K3/CN066g+YkMDY/0oVf6mXFvnpnf76Nm7QC950cYOVfnjHdso+f8MLJwUUoOhQaIdhu8I7GVgN/gz8+sRvttErVgv+ULIhIvcfDjYXb/eTYNtRMcPFbP7I/vRdggbg7Te67KqSftY3yOzAfaX+PAl6r4xgNX8asnzmDet3azuvkYvh6N759+EdN+Y/H5X/+OHzx8NwMX2YQHLZJKnrztJ3HIoONTjSz296An4Ya5r3PJJZtQMxKxT8s4X6pkbnyI9uQ4BcOHLwtyZ5D0vCgf+/kDTPmZy9AqHw9uXcr7q19l3mP93HvqanZ/ZxGpuTJ3zPo9eqWPJycWMXf5MXzjZb7U9jTlagczIhM5KpPcKzP/7v34Tk9RvNbPkjUdqLeO4v91glt+dD2Hb9DYf7CZyC/SXLdwM/t76inaGi88sRRVtUl0uEy7tcjwN9sZvqCZxge6MCsths8yGZ8I8+vbLuCuT92ONmnT9MIkF93+ErhQdlXe9+snKPyygV+dupLSDRk+u+mdPHjGEnrO9TP803ZGT3K4rmkzz18wH8uS2fXiDFK5EO+7cB2HX2lnzTm7UT80xHc2XcDV527gD+fcSWh+Gi0j8cZPluD/oEz3VbWYYZdt2VbMkOAd973AM8dmk8qHqY1O8ond7+LJG9Zy1xtrEHmZPeunUf3hIqn5cNtvL+W7e85h2h39XHfKRiRDYAZh3bXL+eXwqUx2xvnE5//E9K/uJ9A5zqzvp7A1ODXZAS6MLlYpfDyDMG38O4N0H62l78suFfvL6Alwo0FmfWWIwjVZih+ZwN0QZ+Ztw0x5sEDLDUep2ODjYzc/THLrGC1fM/jKBQ/T9/W3LpP8WxDOP+bx3w3/tAncdd1hoE8I8ZcYpzOAA3/rNanxKMZTVQysCdK4rkT3ZS5jRpjo0yEu+cN6/rx/EYWZlRTr4NK71mHOLfC7T/yQpR/ZibQnjJKX8I+7HPu8QvCWQUZWO5iVAex/y2D8rMwjexey+UgrBz9VRecNgtR8Gb0lQfzGXsYW+Zg+v4+2Hx/m8R+vxXQV0HVsTdD8wVH8aYdhPcZNdz7C0WubcZ6oRBvJce1pr/GJx9/L6Te/Ts+lgl/N+TWjl4fghSR9Z0ewQjKvnd1GuzbKVYu2Evm4QvMvezAicOvLl5B/rgbJhkgP/Pmz38ecVWQiHaLhNYv2SzvRMrC1t5lZ/z7ON668H1eBxRcewFFh5k9G2ZCZjh4TOB0Roj+O0nOJy93X3MmU+00Qglnf7eXC6j1oOZec7YeUjyN9NWSnumg5i5Y7Zeqmpmj/ZJqDX4pxfngvNhK3vHQpr742j5/edSmRozKhPsFDw4tJzVEYucVh9fROPvmxm/HtDeL6ZIbPsDBjGsvv3EHDcylmf6kbJV1AWILXn5zPD+67g+4vz2TgdAml6ODLeEEUkfOHUZ5K0PQ09A9U0BZJw7fGiTTkyHUk+OTcl/jov/8J+cEkm3tamHLvILOiw1Qqkyy+fSeO6sV0Nv1coTKa596rfobvgQQhSWf0Zz463h9h7IxGfvDzOzjyKY2DX23gfc2bWHTuQR5acyc7v7WI6h02d7zrMsyQhCODHlf49Dc+Qv2nTR655t9xFEHftW89btHo0fDHy4SGXe6d+VtaHhTsvnc+ta9NcPCTUeYs6eKVw9PxL0/znfUXMnvqAEazTuyIy4erXqHv01N57xUv4CTDpD9f5MN/+gDv+8anuGzBTuSSxRPvXsP2bAuBoynmLe7iSxdez7ff/2sui+5kin8Ua0YRYdjcdv+dPPXUCnoeacdxBeMLbYy4zR3/ejs2EjNvP0DLoyluPfUhXitMp8E3gdVczUe/8yeqdlt87roPocdk8rbGwH3tfOSBR3j/K++j5g0Iv9HFvZ+4jZpnenl5cCp3zP4DucX1nFWxn4OHGrECgvd97ClCnSrhozKTn6glKOv4un3syTYw56wjzKwe5YovvEDVL0dwPz3GLZ++j6HL2gh2KUy7y2TG1zMkDpV510sfZu5393D06givTUyleNEkf04v4ytPX0nscJ6rXtlOS2yCWbdmuPTFXfjSkLkyT/1Lgjt+dimZFXU0/VzBnZWn5cNj/OrxM1h4ZgedX5rF2IsN3LDsNZ7qm8Pj2cXwTJLVZ+9BKbv0/iCIWJzF0Vw2dEzjvk//iFZtjJYfCip/GmTo6WZKeR9KpkjNeoW5C7v52hUPcNFzu/jVO+5Ay8Dvl99Dx7cr+e36k7n+/Je5+aZHseJ+FsZ6+cw5T/K1Z9/Jnp/MJ3W7gvELk4qDFj/YcjaDqxXmn9/B9OQYUraIGYFZPx6nIZ4leWsvAPaPcxz7cZLab6uov6ogP82i4f4xjFuz+GWT+R/Yw28+czEdX40gyia3vHIJ6heG3/L4/ps4sQP/u/DPZqHfDPxeCLEHWAh8+28drJS9mMemFya58ZePMf1ek+HLIjxyy/eZ6RtE6Q7gSxtoE3DPTy5i6rcNIpLF5nsWU79Jp/WkXibbBE5fkL1djUQ7ZMbn+OgZSzL0YhPShEosWeAja9YhMiqSDr5d3Xyv7SE+98EHGPtDCzW+SVJLHJ6/fAnTHxmmWCtInT+V737nFzyxbx53f+Ryei6vpnRmjnJTjKfuWINkCJ58YBXvWLGN81+5GbdcJrvIQJ9VIjNF5rpXt3Dzi9ex++xqjv5rkCsqtqInIXpIpvaiXqzVkzjnp/n4iitIPhfAzWr0nSkzPzZA/WtFGn6lYTTEuPW+qzjlvN288dosPvKvD3Lkxlr23zUHWQc1DyNLNZLbVT7+ow/zuXt/y6FPNdB1Qyv/9tzF/OTbt/No73xmfPMINS9oTP/+EXwDk2Sn+OC+KiofzLNsSg9J2eLxd6wiuctjqKoFaHx6lGivjSIc7v3w7SRuC7NzqIG+Ky2M+QU+/cf7WTS9h6nfPMCGsSkMnllJcUkrpCZ47B0/xNHg5o6r8R9L0f6QTnqmSvTSQZQinFN3kPT/j72/DpIjS/Z10S8SK7OymJlJzMzQYmZmZpZaakndghYzMzMzMzOVipmZKysx7h8999l+957ZZ+/pnjdnv9FnFmYZmSvCPKN+EZ7La7l7Az1mmYDLPTm9Hd+Sc84b24NWmNRm1rxqz77UJjg+Tqe+TxK5zdz42s6JlUf6cT2xMnVHfkKTKqK3kZH/wI3F8d2wStQy9dgYiktV2ERJyW1sZP7wccyrfRt7jyI2bOvDi29BPC4LxTK5jLnrjyDojVi/T8eoMZPRVY/eSiDjJxemjprCnuUbkcWr/vTNIPEyIgC51aHb2/Go3yciSqDzqWfMbHSHL9FePGy+BanEjDpJRsYZXxQpStpMe0H3I7MZd/ACByMaIhjNuIwqoHv7V+hsBa7ers+k/WcpCbCieICKolqulC72IHKSLbtSm3O7tDKX2tZE+VlNwu9qpgydzMK+Z2k55A1Wa6y423UDIftLmD1hIgsuDOJJuj+kZbPkRl9uZVeiyKgmvbklR1s2QBOVT241FbmdtTy/XQ1RKjDz4lCkagON570hv20gY1dPI7WnNxJElnQcSGpXE8ufdyF0RwnZdUU23evAwXFbKAkxorezIL3Cjp86vcMw0Zrwu0GULHDn4MmfSPs5kMzX7iz7dTgOPVPYOGYvmfUtES3kZNWxwO2OlNi+7ljFCyTtD8RngY47saE4vRUoDLPiaVEwbqoijA4a9sQ3wetqLjKpmYymUBIgsn7Vdtpvfcz+OodpeT8eRSFkL/GjKECBXesM+tm8w2WqjtqWCRSFmMnsaY3eSoL5vQ0Xa+8BhZmwhen0fzuGX34dTb+Dt8mfWoqiCOQqI5jMbPptGzO87nCvoDKnUusw7OVIpJ1yWdysB0oLAyEHSzh0twXu8gLi+st5NLQeF8a0YVfn/TSc/hbHaSbiv3lgUEv+6JDnpqeubQIqqYGIuc7YxohQpmWB7w1SSmzxvl1OTLQ762qcI62Z5o+sBe8C4haGcSjkONlaDR+yPLF8n8yYGs+ImO2Mm28eQz3+bnbvD/6F/EsLuYii+An4t8nZ+8EPfvCDH/y/+XdcQf5X8K+egf/3MIm0HveK6KEaYitciOujIvBKHh3fj2V9cjsc6mQhyyzE43YuYsd8dBvKGNdvEoOm3MJteRyy/joqgisIPFmC/2ERkxwsM8wEzc2jzM+I3TcJrTxjeDCwLpWqJxHWOYaKmn6M+DaMTWv6Ye6az930ULxuixTUcuRhahCmuiVcWLaW+T+PI2jPH+0QNakii6tdJ6GXBJMc6jaLoHa3cOJKHZHKzaTsd8f1nhxzqZxSHzNHu7RCojEQeKMIQSLye3xHVNlQtf93dBvdcd1lQahDDvVvJ2OwFLjadSNmCzOvR9VE66yk54Y7JHRTEtYphmfXquN1z8j2+JZM73aVgFHRlLvC5tF7sMwQETvmU+YOc8N7sb/LHgxWIks6nGdRz+FoXzrQ63k4EoMIZxVE/aLB7ns5VnFlNLGNocIk41xxVdLbOJJfy4jzNCN5dQ3od+j4ed0h0o750+/mJH7efQjZYxtcnIqp6ZlGisEB7SQHLKU6Cq+74/hNh/p7JlgoKTfLMQWWM8nvERmbLZBnFNF71EOyXrhTp8c3TsbUJmxFHsL4bKxHpVBDmUNhdSMbNm/DNygTaZ6cRb7XKa7txsfLlcitKeJ4WY/W3YT36EwSJwYgmECVVYHeBoTfnRh38ALSqkU8bbSDEl+R0HVFJLW3YN2XtqgO2uH2uADbrzKOr2tPmbclW/v3RuthRcJwL5rX/U4d/2TMMqg+5BtpzRVcLK6FvPTPy1smMdHWNwqrsALkz60Y+PQDe+Ztxl1ewOYPrQg6bKDV0ymYrzoS1jGGghpGAo5mc+pTHfwuFnEhpza/VLtOSjs7pr94yO2kULT1y3B7aWTRgaE4TE4kYbg3Bo2A9bJUwpanEPXJmzvda1F2UI5FHshfWGFSSsgy2BA+rQqK+Gw6HZpD1CgrkvqbcX9mouKjPRX1Agk+UICrqoRLydWo1CWapCG+9Lr8DHWWGVJU6J2NGFXged/I4lrXeb2kDqW9iyn1AvsYI+pttnS98AKLBAUh/ukkL5Xge82EVdzfWljaa/FeHs395CB8VLkEHU6kc/dX5M/X4nWvFIO1DL2jEfsPeewKOoVa0FPRsIzony3RuonYPksmYY0Vzu9LcXyVR6eLr7nTaDtjfrmIWQbvDlXn1uNa5CzUUaZVIhSX4rJOgWhjwKwyUWZWsv1VS2Ysn8i1jCqMHXGdrpvvk99QT3q4K+eKaxGx2IH9vTphkSMharULTSa8weWNnnZXZ6LMlBGx2BPNHQ2rlu7ma5knNqoK7KK0BEzNJnqcM3LBjKWgJ2VBELpDbiCCZpsNLW9Eos2wxGitJPi378z62Ifg/eUUVLam9a7nqAU9Ix2eQXEJ8hIJhUESLOV63G7KOHioPXE/h9GmVjimfnlEzvFi5dCh2PbNQlKmx9ajmCn3h2DbJhOn57mottgiKzEweNospFMtkV63J6+NH3dmNMf/jJGMeEeO16vy5wX+9xD5kQf+D/I/yoGLUoHL0VX5rf1Z7s9tguCq5VFqIKoLNhg7FjEz4C6p3d1J7O1IJ69w1gSeJ2mmSCWLNPJ7qYjb7oY8yYLiQA2iTGDHhJ3UmPcRsbQMq2gZd5auZ7zDExJ62lHDNhUHRRll7nJ+D7vwR7/fzRpKHjiT1kpCtRlf2F/9CM6HVbTfNhfbuzHkVVEz2/s2Dg+TWb21PxKNAds4A4XD7Ak/UJkvLwMwFSgwmiRkd6zgVceN+F/QU+Fly6jqL7j+uDbmeEsKrnog00LMjjCSuokocv9YrPO6ZyjFgSJz2wwmKCSNtJZWWD2IwkIwcLL7Vj6+DsTxq4nUVjLMJ5zYG9uY3zyv4LcvgTWDB+H4IIWmbvGs73MY99F5jDk3DnVwEVtX9cZxexqKYti/tDsX160nr9wSzVsVRUFqCsM0rHzeifwtvhzY2wGPHomELU4gcoozFuly4lJcmPe1F/mN9FhHS3GWluLyuowdYcf5+DyIk2l1CTkYw+WvNSgOM5I7tRzHU8UUNvFmxN6pONmWsmZzf9zGFVFYx5mXvSphkQPJpbZo0zUEnk7jJ9dItEY5P6d2wtMvh+E7p5FeaEO1+nHMWziObr/eo2qXKOwD83md4sPpjttJHhXCinMHcDj/lbQ5RgQRKuzlLDw9mPoeSQzrOoaA81oyWzpilQQGrYzcAWVEjrf+o6+7CPlDSikK0aCZn4rfzhjiVoWRvCsIvQ2UGxVY5MH19c0xaP68vksL1KRX2KA8bUfjgR/49VJf+lydwvsyP5xvWJBVR8346k9ZP3cXQ11f4HVTIGKuHSGbtXQ89ozEYnt+edkDsxLmfOtNuVZB4Aod3X6/h33LDNQyAxXuxj8Wcw2QkzjcF7NcxOt4Bqlf3XB+kYvjFz2dNz7g3qhGADifKUZWAYvaXMb/CFTYSfG8r2Xl7t0k9rSnUK9iYuBjCuZ7cm7COvYnNiarp44h7R8TsqcMt4d5pAwxsmF7HzSfM5A8tcHgqmfNth2oUkv4VOKN02cTMenOeKyT02rtM2ZNPMvsaRN53mAP1rIKzB9tKDBY8m1+Nc59qYnLVB3i7/k0XPqa0HlRZK8W6LZjDivb9GB4pVe0CorGIksgrY8vvsMTKHdXETnHGidZCQtTu3BiUifyq8DReeupWT8WjVLH0ToHaHk7miMnt3Oi+R5ud9jI7PDe+J8Sya8CGW/dkQsm9kU3Qh2pIGRzOvsetMQyXIneSY3W00jvyh+5+rguycNMPO22Hv9t0Qg6CTb9Uhn1fDh1NAnM979J3EA5fR5+pF2LD0z6PpDxq6fy+4Hd5NQVudx0B0kdpbwt9MUqTkp+qAW6ukFIJWYKwzRU2AvkGayYsGMSo8OHkN01CGkFVO0UhauqhM6LHqJsnkdeFQW2ci2Gu46oMiXE91CRcsSb+H62aN/bY/dRhuG4C+Vb9JS7ypAlZREwL4KCGvaUuUGrWS+w+JxErQ0fCQhJJ/u4658X+A/+cv5HOXDBJOJ0TsWpjHpc3rcVc44FHoOTya0JEpWKhacH4/hVj9+eWE48bszu7BZUdctgb3pzKo7IAQjYn4btqzQyGijwl5cQOa8KOT3D8Nz9ldp3ptDu/jR0fjqOf65H5LIqmGUgF0z06/cIvY2MAxO34PYUwiwz6H9uKmd2bMQ+0kTc9BBK25YyP7InpbU9cb+RgdkoIey3r1T42lEUIhJwvoy61eNwPKEmaL2Oz3pbUqcYOHhgE5fXtqJ3q5eYVCJaxz8qzq1YupehdV8SO0dJWksZYm4+wQcKCD2dSEySKzp7KG8azNor3Ri5YyohW1KxehKL/4UyBi24gVanoNvb8Wx/dZbEzpakd/Omq90HZrzqS0U1H5T5AuVaBQ5Dk4ncV4mDszZSECThYFENNGutmTTuEvuXb+CXJYcI2VNBbjUJnheSSbvki8nXFe87ZjQpoEhW4GxVQrdqn1AUi3S7Pg2AK8U1MToZSHnuRbHRAs9LUkJnR1BaasHnU5XZsnorDt+MVFxzpsHwD2R19mP979sR8/5IOdLI9Th8lnD7Zh0OPGmGZrYFuTpLhG1OeO2NwFAho1BnQWY7I/frOtHANh6T+Q9JL+k2hHq9vvBLp0FkD6xGa+8YAk7kIdWL2NTM4V2GN0JCOqWLS/h15mGUXbMJXV+G/TlLwlam4n74O7uXbsJprxqDWqDsd0+0NXy4uG0j25ZvQW8jkrwrCLMUCjuW067juz+t7xDnLOJOBmGZoSd+QhCKoGLcn0C5WYHtxzy6j3hCoDKTO8VV2ZfWlF7L77C7xSEkqdlsvdIJ64UqDjQ7gLIAinM1VPNM5/ytI5hFCZnv3VjnfZk2tcKRGkC0s8Lps5GQPSUYRAkulbKJnGhH7bUf8FHkYrchjfjxAk1to7GNNrNnZQ+0TnKUhSaMVnK2Z7bmxIiNNLaPY/X5niR2UtPj4GzqOKZg/URFkVFF5lITg87fw/6eBYumHGPpo4u4Py7Gyr6cxZWbMffyGcY4P0YzI4WAbWaMahm9bd6z7GNHhq25Qot1s4geE4jvpXxOfqtDxngdoTPiKWjgRu5Zb65cakTmMTeMdx3YNnYXek87ri1vyTSXe5jUUO4CCbOrkdmvguaVopn7pA8vIwIZtuMKgYs/sy6jHSu9LpH92o1+56ey614blme1Yuz2KUyv2x2bvdYoX0USsj2TkV3vcqV3I7ZWP4lZCYUN3AiuloL3iUTyQ5SE/hzD82x/TBoTwRPjGTx2BsG3CnEMyMNirARJhpKjQzqypXsPTrfbwYa9vXiQGIyTuhSXx7ks7jUMTALjZs3gp/pf+PwgmLnjT9N70n3yKiswxFhjd+YjHmfi+fq3inlnqx6k9thP6CtpSdwRTKFexaNxDZGdsUfXpITwjs4YmxVRu2s4mhSBPgEfmdjtJnb1syn1Aq2DgOJXWxyvx1B8SE3GZB8KggXkJfDs1wbEbnXn6+hKyKep6e795U/r+z/jRyGXf4wfzUx+8IMf/OAH/1r+DZ3vX8H/qBm4QSOQVV/A1K2cphtmsqL9GZzuSnF9LhKxLBDXV0aSOskw+rsRfLiEqBVVyFrvT1SOE5lF1vhsEFj16DQJQ714NHYtrQ/ORf4snLw6RlZ/vYtCo8f+tYLQtaVsbXyCIl8ZeTVExh8bz8XEapQNL2Rpy16ktRa5NbQxnVu+ZVxCT6xnJCPRg8ceBc4jC1m04QANL0bypc0OPmypSY3VH/G+ZSCthYbezu/IaCwhYG8cS2O6Us8jmSKzDJNc4MvAYLxvmnB/bsAuWs+GZj8x1O41jtctcKqejaGaH21OveHT3JrI1QbUlQpI6WPE96qWPkMe0fJ6BDja4b01jp5W4fisF5C/sGLMkKk4fTJj0MCUQ2MZWu01tkuSadvnDU5XVTDdBucb8cwcO4mFg09zOqE2OdO0HFjRjWFfh7N2xhCy6llhUTOfgXdfUuojUrGihPwxpThfj8ehXhblBgVlJiVFgQJzW10no7ElmTprFjW6RsCeJJ48qUqxr5SY3YG4XFGiLBQZs3YaRrWEgpoG6lglUljJjK+sgqNfrqPOFqltl0yFA0jCSvC/aITkDMRJGjqufIiorUD91QJl3xLU1lrEyoFsftoWyTV7/IbHEj3clodvqpBX14HKI8K5e6UOyV0cKBtTSE6ODTZqLdnHXFgfcoYdlSpjN66CEedv0WbBMy68vkz68EoMej8K+5+TsCgwo/qQwNAtV4k3KJg+czIzO1zjyIp1eHVJxKCVEV3i9Kf1nWtSYdBAfG8Zwtp8arqlMW75eZ5vrMeym8eJL3dk+6g+/GT9lfgb/my70Z7Jp8aQMCEYp49mIsepWZ3UgXJXsPkoZ4vvBboOGMelpW0IaphIh01z+d39LlaJWkZduEHhmBL060t5keKHTe8swhbHciW2Cuey6zLR7QH3mm1l5fsOWN8Op8fce2xZtZWev99FNjODiAOVWJDQk8E2n7k8eB0ez4z4rvlE+JyqVBkWzqd5NdFWKPCW55PbxIirtIgh70aS/ouZ53UOkjivBhOOjmfcymmI3cq4dG4vkgVZHMpvRMBqA+fb18f1dRkSrYHs30UCtpkRBJHIZcEU+whY9Uyn+k9RLAy9gfv+L6z9qTvmxXn8svIgM+P60KHba4I2xqDz0WP9wJLH4SFUWp2PRaKcA9O6Y2gYRuyaMKZV64i0UjHruh4lZFceCQM8ATj54SrZNWUgkxE51YW991oTv8SC1Ukd8NufRJGvBO16Dzrd/cqwSTeJ3+3FyqCLVPotjcxBlfFdEsXlLzVw1ZQw5NYTpL5l7D+/k0kXLzPs4FRsEs1oCyzILtPQ/OxHErvZoM4QGPjbde58rYz/pgg85AV4K3Ip9TPjfVuHxMGOiCXeZI2uhcES8s1y1rk/xOmqkvzKAuXzXJGsyME6XovNZQ2YTDTziuPl48p4XMukoWUMW+61w8OqiPfDNuLZLRHp+yiMQZ5YDylB72BB1VYxHJ+yAb2VBEOBkiXnDiMYTBhE6Z/W9w/+ev5HOXBvh1yC18aRdtiDbZN38vuO/ry5XZlpK08RtiwJ1Z1PyEokSL8nMvPsGZK7mGFCNhY3bRgQ9J60FpbMCWyK36ksmu+fg6IINPeteNFpI+F6d9412kvAkGhS2zuQpHfEu3c86jQJAftTaOYez/NaR6gIcqJpzUhOXN7L1Ud1ORNwA/MAEX2oloP7NzH++XPmrR/D/ldNGRDbHfXQdD7meZIwELx2hTPvQV/MGhOrXJ9gO9HEs9gARvw+E6tUA5lrJJR4yUnsLiGhm5S48b60ezqZ5rNfcrzSYQqDVWx71oaEHlIcL6hw7RWLNM2CwmAVR8PrcXdMY2KHOpM6zIMei+cQPVKJ57lkam76xILfD2OWgyiFV/2qUDFATvi0KmR10LHxyj50oR4k9ocBVrlYnLSjJFNDbjU4XPUQqtRS5GUiZeH2rNrfj3M9NlHFLgOP4elUvpHNcJ+XWKy3I7LQmYDjuZyZ3oGL09bS1f4jyx92I36MD1t7HuDOrLVIY1WY5QJnl61FbwOKQhOhU76xJ74pITtzab9uDgP6T0RZaObkhRaY5WDQy9DOKWTEm08I+cUcPt0WsWogO8bvZPPHa9yru4f8ahqaVo/C5VYKQoA38mKBkHlfUBaZ6eDwldVDD9O57wvyczU4PZTzW+BlCgvVTP59CoJCgce5Apqr0rCXldFg1VSKq+vRWOjY6XsRZaER0cWBVWd6MfrzUHKrS2mniWR9Vlvq2yfi6lJERrH1n9Z3SbwagyX4nTehX+lGznRvjqXVR2oQ6XN/IlWs0nD8PZlVAwZT7m7G/ZmZgFVf8blWRIeFjxF0ElJu+2CVCM7vyujzbTjxvZXYvEohOsMZUQrdp84gYarIb9sH47zOgq5uX3lcfxe/fn1E4O0SxlZ6RgPbeJYNG86YmAF4H5FhumzDkVNtcZLo2Hu0A9klVuTXNFG6zYtCs8Cspn1J6ihQ2KM68b1lRG+rhLxIh/KFhqXxXQidHsnwcxMJGJ+G5+Qiqp+fhs7RRKP2XygME5n78SkG0Uz5Hg++tnOi2ZH39Lr1muR2llR42eAythjJ52i0uWos3UuRNSgg7647r6P9qDDLQRCInOKMYbsbK+M6MsPnLpef1CVlaBDNw6JZPW8Pzo9kdLr8hqtj1pLZQE7prGLS2on43tOxvsZZAuS5AJjs1FilmJEg4Hcik5xelVBlSLCOkaAvsEBnlDHy4VO0bmbO79rEzkNdKDcrmFT5MdPXTCByrheaDBMfT1VBqjRRvtidCrOc6u7pNL00m5uF1ajw12MdnoebZwH2PVM4fLot9vWzcPhmYP37togmAafrZn6dMpp903sype1tCgOVaKt60rf+Gwpr61HWzafn9ansKqyM3dMUAjfFEDNORrBVDtm11WQ3MtP/6SeSuttjmQr63QbmhvdicItnRNwI4mKZJ5mnfYlbUpMWu19iLiwir7Kc/b5XGbh9JmK/XAS1kWnf+xP7myWT7F//p9r9M/zf7UR/hND/+/yPcuB5Rg0n319BdcGGNcntsUk04XuxkA2/DQCzmZiDlfFb9o5fP91n3aCBhG4to+CeGz9Nes7LPpUxWYDNIxsyW7tQpU0MYT2iKZrvQaMrM9k/uhvVLk+lpLMRr5OJXKvvy2yv23hu/UTkTA9ihvtR5fxULOLz+HChMgODWiHTCjRcOoWS+j6QacGEmt3YMG0QZgUEj3tH5lE/OrqF42ZZjP1rBckTKvO00waC92vpED6AiFkuKGMsKHMHvbWU4mg7uk9+iNNrCWr3UrzuVxDyWwmj7J8zIbAV5xevIWRXKWG/xlPQpwzfF3JEqUh+ZZBFq5FGJGGwMzHp6lU06UYqrc0ja4clQRaZLI3qgtedMhYNOM3qm0eInehDsZ+KkDXldH46ifwwJV6XpbTvN5KCEAGfSyIeNTOYOGUacf1sObh0A5510vC6kUegDOIaC0QvDuNrAwWnJ3eg+foXWA0upTTYDsW9DwydM4sysxKvW6Bz+KNKWcNHU7BOEMmuK3KosB5aFzOZDeRIHOwp0SopqOWIKIXM+mrkZWaMapGxA27ieVyO7egKFp0diLmomIF9HiJ8jmFlUkemN+wNwMVf1/I0OpDUnl6ktbHHf2sU6eNqIDGIXMyuRXOLPO7uacTlFtvJrwpzl4/jctMd/Dr3IDM+vyZpaiBtNs/h5Kr2mFsX8rTNJgLtcvmgt8dxaSKZzR0w+FVgcdEG/8PpTO42hpifKxFT5ox8pz0VOvmf1rfBUobew4C8WEfm+AqKl5YTE+NOfu8yQtcVceBKW6a536Hl/pdYZEvIaCDF6qaSY1f20lLzHbegHBTFkNdEj7RMx1i/p0icKrj65hoWn9RYZopIDSJH6h/g49zt7Du+ldMr2jMirg9vtX5MdnrI/W41uFnNHonOyNqAczRY/YaxXk/QBupQCALOHw3oP9vi/ErCyrW7+aTzRCwoYlzzB6izDRzosJecuiLSNXk4d0mhim0mcfv8Ca2XSOsnCZg8HJDoBJCKJPwSimNILpP2jyfLZEKVbSBynRdKiYHlLzojyiBhkIg+0JWskTWZ1uQulZyy8Bibx4ThV3nRZjP3CioTubIy1jESZBMzsfjNhhS9A6IAL6ZvpFCvYuy10ZT1LGa8bTJtr85EpoXsRHsqh6TwbkdNTKKEgdtnUrFNx7LTBynxktB++jS6X31FzXGfcfpqRGyXj91HGUUXPFj72yCs4iV0WDwLoyXsfdSSc/PbIe+ag3/lNNZs2IHHyVhqeaegiE7n6OQuFMz3xP6LhO8Froys9ZyYpWpsuqdyJf45CwefxmauAvXbeB4234JFuozPpyqTW0VGUlcJm160Ib+JjoReAr86v2NQrde4/ipjSJPnfC7xRBfkSuuHcVjaVLDY9dEfzYS+SNmb1ITIud6MmXiVwhNeaHUK7qaHYhNnpqNlEkVNtJgtzJxNrEncstq4b3vHgPo9KfM1EWyfQ/C4CI5VOYT7IQXDw9r9aX3/Xf6qFeg/VqH/fQRBaCsIwl5BEGr8bX/sP82qv0NZiQWdJ09j6ZID6Ba5UHPRR6LGWrFl2Vamv3iIVGYmZXYdFiV0p9uBB5y4vp+ySnq0Jjlpa+S8HbWRt18DcL2XyST3+8QfDEZ4/oXKlZOZf/AoEd23kzSpEqgsSJlQlbm/jCdhfg28KmUSdCgBG79Cvi9wxPtwDAFPzTT76TPWyQb0Y/MJXvKVuJ0e1F3+Dk2qGfVjJ/Ka6djxrgUHfO4i7ZpDj/5PGR49gEb73jPV7wHyIikejyuo0joGiVGkW8s3nDvQEkTwXmJi0K7rUKal3dWZSO440uL6LKKmqdCHemKlqiBpvB8+t/X43DSgSYa0kZVQp0qZv2cEBUFyIubbc7fGIS42DCYv25qCSmo85AXMGjweRRGUeghkNrVndu27SHVgGJ9HmbsSu3rZNFv9kvE+T0juDPKgYmb1HYcZASEjl/o7Z1DerhpNG4UTdziExM4Kjl1vgbamL0c2r2dF3Ctsn6dQTZGB7cwkFrW5zKJVo9je6Di5dc2E7C/i0ONmhOzJx29jOJdeX6EiVcOAX27i3TUB23YZyO+8J3htDHLBiOplDL3uvcfkoyX4iZHLW1rS8G0x10OugcqCjqvmcLq4Gs5OxZTX1dJp2HNSh4TgtuU1HVY9JOJiMM1Xz8Thm5aBO2bSoHEEBWEw5MsIJj8czOTTY0jobkl5TS0PV23GrVcUfebO5tu5MNaPHISdovwPAeYrsE6oQMwrQFKsJamjnCDLbNQz0giYU/Cn9W2yFAke94mS38r51OAwlqut8QvIxPK2FQW1HPA/V8SYnVO4kxnGkwnr8HxkYLnXZRq/HM+dkqrYjtVR1rwMoVhGRkt7HheGMKzya5p+6c38kadxeJGFvNjI2YJ6BD8cyVOtDzVmfCTlmi/HlnWi3bWZiJnZiCYTSZ2sGLF+BuduNaaGMoMDzQ7Sb/JMruzfhn39LDrPfsTMFRNYfL4/iQd9edzEg/uH9+MrK2ZR+4ukFdlgq6zg1bbaGAqU2CvLuTOsMTV2fQEBWtb8jlEtxWGiHp8tX5nechAz9p5AmmbByY3tmdvwFvIiiP1pH/KcMgrr6dgX3Yj8hd5gbcUA62iulgbx+EMYTu8FOox+jrDGie3Ht7PyWSfsA/PpMXgCA11fo/Qoo7xUSbheh+13KS+nbCS2+y7MoyzQ2whsr1kHt1dafvG/xpBjU1k/YS+dljzkUpsavD5VnZmbj+PSIwa9NTxbtIl2s5/icTLmjx/OpaBJlGCRraOz5zfkPYuZtWAS+W0CeP82CNkpWLNvJwUhauTlIpuDTnNpa0tqe6Xyc8RrBia0Z9mXTkTOUlPeIIAJ8X3xvVhIReNS1FkiSqdyNI7lSHMUhM2KoFuPEVw92JQl5w5zbWcz6lgnURis5H73mkwIeUL9s7OwTjbxatFWMr64IipEtp7pQkFlEbNJQDzmhP/0SIbW64X6owrHDwIapQ77b3A2/infl3qgiZeSsjKYeeGvGR8zgOSBJmL2/JNLqf6Ygf9D/HcWsY0EJgCLBEGw54/KaT/4wQ9+8IMf/OBfwH8nhF4iimKhKIqzgZ+Auv8km/4uosKM5mEkleR5SN9G8iHPkzHNHjE/ridTTo7Bf7WR3aO3M8PnLpu+tKLuuRmE+GTw6FA9irKs6NdmMHL7CgZef8zqyvW58+t6ZsSGE57kztx1Y6n8cAyCGWqdi8HrVgEWeUZm9blESqY9BlFCdad0BJlI6K18+tm/Ia2TioTeUPjeichtIQTML+bDzJqUeEr4/NWXp602I82V09WjDqUvnbi+pympBba8buvJs+JgenV8jvT5V6pap5FdW8rV2/VRts2h+qQvmDRKXhQHYjwi4BmcDaMtsIqR4uBUguxVOA79Mzl4eQ/ShVmI83KwjdFimWHG5a0eiRFmTjnL4Zb7GNyoD9UeFhK8S4+2SzFTdo+n1MuCtWP343MuE4++CTRWxSKrECm/5YxNeAE2vdK5dKgZqyLaYelYhvdvZrLraLgSdorobV5oGuUgmOFZfACu9sXIvUr5MGQj5/dvodAsZ3H9TuS28ab3xzHE5jpyaEE38uoasZWUo8yRgtmM110zaT854ntPR6d+oxA1Jja+aUue1pJpfvc5lfIczipopI4FFyf6apL40GInL3bWwflRJnMcPtGlaU/G3LqLy953nNjUnsfVT1LJI4Plzp/wvJhC8s/12X+tLT2GPkHRPgff9dEom+VRSZOB1z0jVvtscHwlR2IAWRkErdHRq90QYtfWQ5QKjB59nbh+cpJHemGWQ7tGn4jvpWT159uU7RJp2iic6+ubM9HrEUZ3+z+tb4lOQGpvyxCf13Sv9hNJ400UnfXkp0nPMSkgepgVRktIK7BlSOhPpDeVMzW4NXtrH+X4wyZETfdC/dyS0OWxuF/PIGpzJV40c0Gy14memgzEzGwuHt/Jw7QgTGVyMgx2PLxeizUT9pPZ1siLrhsoPOuKzNeHRf1P434xCe+7Oqa2HcbqKg1Qp/7R7jQz2olL21rSaMI7ajeLQq+TcT78Di3CuzGx8xhODf0J8bEd7hZFzF14HEEnIatJKXsu7OT8/YYEr4tDb5aRNaACMTePsR8+ktzHnUOZTTB5VrBqwR7OTm2P197vhD0dTmFNB7zPSdEmWiN99pmoic4Mrt2N3+91RZErJae5gVy9BsXz7wz5ZTbXftqC8+hizIty+X3zQCpKlTjeU3KmsC520Xr2FIXRqcMg4oa74b7/K7oGIZS7KJm9ejwvR6xHLpg4HFkfs7MtC8af4pfwrjT5WM7LqRvp7tkAN0Uh2ho+2H+DteP3Yx9lJGBrFOf3tCS/WyWkFSJFPUoJOlpM0gV/et+ZhEwnonUUCJbL6DrlEVm/+jHs8SiKZ7vTxi+KoOEfEYwiEUlulPtoCJiWjSgBo0HK/Tp7WND5Iinjq7Ls9EHcD39n4JOxFNTT09wyEsd9r9F72HBicSdsogSKfaR07TqMU723IGgMWORDyPokAlfo0NkIfLxSCYDhI24h9sul7KIbttFlzM1ojjxXjuf+76Q3krF45hiCrHM51PggUtmfb9bzn/Jna6D/39u/GYL4X/y/gSAI3URRvPwf9qeIorj1n2bZ/wIrG0/xQ7iZ0RNmsGTrPiZ9HMjPVW6iEExsndePUjcp8jIRxxsxYKUhtas7iyae4EBaY6Li3bF/Jcc6SY8yqxyzWk70CCVKuwpqe6QQvz0U2+9FSMr1fJ9tR6XFKUT84kPzWhHs8LrHyRJv1p7qibwUQrrH8PFdAK0afeXe2yqo0qX8MuwUR9MbEJHoRvDoL8yK+kSZWUlzVQ6xBjnjvg2mXKvA9polDm9ySe3ghFkGZZX1PGq1iTYn5/Bk4DravB2Lz/hsTH5u6OyUpDeVU6dlBB/uhlHhbkBSLkVRIEHnp0NuYeRA3UP8NngEtmtSWe51mf6/z6HJ6HfcjA0jaEkZ5uQ0MsfUxCJPpNRDQG8LekcjlVZlo/NzIH4IuF+To3WUUBwgEnCuDGl8OlELAxnV+iFPGzoR9kTLpWd1aVI3ghEuT1k6dTSqjHJEQUD4GkPSvFr4XswncpYlqlglI/rf4VRibQpj/nBqZlsDlf3S6OTylXUf2mL5TkWNvuHkdlOQODYIva2I2UVH0GYD0ROVoJPi7JOP+Zwj8jKR9LYmPG9K0Y4ooKDAEmmqBXWbR1DYXUbEEn8mNr9PvNaRuGmhZNVVc2v2WtrsnEO5pwlZsRTLNDBLgRaFWB23xjgiD7seKUStr07o7iJiB9njfVtH9fWfWOv6jqovh/CpwWHGpzbHXVnEqYjamHRSlBo9j+vvovGp2SjzBaybZSPfac/KTbu5UFiHTTVPvxdF8R8uDawJdhXDNo9keeglph0aQ92O4eR2lZO02wVLpR7HSXq63HzP1U51EHPyEKw0ZHXyI7+6Cc/gbIZ7v2T1hZ74LnxFWe96WN/8RsSmMASDBOcXEvYu20i369Nweiuh9qSPNLaOYc2ufogScHtehv36VL6fC2HauAtEat2paxnP4i9d8NipIH6IgDpSgaJxPtYWFawPOsvUyP7Y9MulqEMYMq2IUSWQ0VzE2ScfN00x5fPdqHBSotdIsErSktFIjXWSGZtv+UQvsKR35Y+YkfAkIwC9SYrr4AwQBDCZuBH1jA4BDUicV5MlA0/x88seeJ2XktJOoHGtKBraxOEkK+FUVj2irwRiG2+GsdlY/G5L8ZwSHEcUkr7Pgcs19jE8ahCyX+3Ira6mxE/Et2YqwhIHMhuosY0zUewjpbiqASQi0jw5F3pvZHpsX4Ksc/m0rTovVu0g2qBl4JeRuI0rInqmLzUaxBJxIwiXVqkkpDjjfl2G1ZUPZI6tg/v5eDAaiVjri0KtJ7LJUVoNH0V6EwX7B29nZkRfcrJsUKYoODlsI4fzGvNqQ10ur1rHiDo9yD1gQwOXJK5+qcbRFnuZsm4SRQ0q8HAtwE6pJTbXEaeDanJqyHg3YRO9Wwyg/7UnHJzaHXmJAVlUCkc+X2Vw1zG0PfqSmXYJhBycgPedClYd3s28EeOJGyjByycX+VoHMhooqN4+igO+NykyG+g7ZSbihBxKdQrs1eXkX/Lk3Ny1BHtl/Cl9/z2sbD3FWk2n/SXnenJt7j/Fxv9T+d/OwAVB2CwIgvAfnTfA/6+dN4DBUuCnS7NQFOiZu2wcEomIrbScJL0j3ZffZdnMgzi8yeP7Sj/ymrjhvvsj62LaEvXNC4W1jrtL1tN54wOiZ1mw4dQuXJ5KkXzRkLE0gMIepRy7ug9zYipda36m/u1kGteM4tXtKsQazNzNq4zf+q+4PyqhvCdIyyU8eF4NqzgpMi0s/9aBhAe+OD9QILWzYdzjYcx515tBHUbwvsKXBq6JOJ1ScW/lJuwP5mAfYaBVv3eIRoF4ozV+dVO4WhrEkOA3RM8JZPyxC2zctQ2Hb2bMogTBBC2qRiEqzVgli4ROjUX21ZIVtVrCyy98ehzM5ZLqeA+MI9+gxm8zxPxqifaKCyV+IgVhAt6XszFYmbFxKaGkmgsmCynSHAUlnhKU3bKRGAS0riqwt8UtLBu5YEJQq0jX2uL8RqCN/XdWh9VDWmFGb2dBr6P32RJ9H62nkV3X9/Go1WZ0jmZ23WnL72EXcAnLJnh/Ppa2Wgp1Kq62qIT18z+afjz5FkzEKh9+HnIa1xdm/A4IxA7SEDL5O2qXUvK+OVLUrpzhS69QJzSR85vWMzrgOS6OxTh8E/nF4zppA4NAhOhyF+pYJbL71DYuzVrD8B7jMSnB6Y0Ej0cG2o18wYKJp/7oBNUEdDedkHh74PRWwuqrh9jeZy95lZU83F+f9n1H4Ds5l5Bb40mtX8rNHU3xH/AJJ6dittQ8RZdFsznQaxeqbKjhmEpyV5FKigquRFb70/qWJprZEHaGTZ26432zhKcRQcTMDsLZqhTJCUdiV9tyeEUXoie6sff7TaY8fcDhResJ3VlAzks3DizqjtGrgirvBS5v3EDkmsqokuV86bIFqV5kXqeheATmUBQo8CAhmOUn+/Fo1no0bbKJ76Um8nQImnQzZ6p4cf5bDQ4M6EzvwE8YLKWcbbETwQQ6vYyMN+5/FMjJt+bi9/vYPkmi1E1KRgcDp9tvJ7dAQ+z1AIxqGcU+UiQmkV+OHCa4SyzlgwpJb+OI5q2K4fYvmOf0DOlhB9yG5yAGeDLgdTjaZmH8lhtG8qyahI/dztHGtQhbXogqq4Lw7lvp5fiOkyl1SdI7knw4ELMSivwkKNbak1vVAu0DJ/LbBuK6VIpCEFB2yyF2jBR5qciwnx6h3+yGYBLRW8OeTRtxPxhO2PwEgnwyESUwt9dofK3ySSm3pdrkL/w0aDRTB09iR5XjRK1xRVohUD7cCq9177CYIMfmo4Kg2d8p6Fcb99tZpO2yI7tbMIH7TVjd0dAvvjWZY3Xo7cwsGTOayYGPqOyfhioLpk+ewoOj9VAWmWhwfQYRv/jR0+cTV1/WIuz3AipEOeUtSlnR4BKm/S58ifbiQ4NDpLSVYNBA7ZejyPjJhV0JzVDOT0f6NY6IpUEMbT6IzKUm9p1pz12tDKPGzNwDR5k1ZRJZUyvQxMjJ+OyKRUwO+hAtUSdC6N16EI3uT8XqdRIWK21x6RFDZpE1qk7ZdHkz/k/r+wd/Pf+VEHoJcEUQBDWAIAjtBEF4/s816wc/+MEPfvBvgQiYxb9m+zfjvxRCFwRhIDAD0AOlwHJRFJ/+k237f2Hp5CXWajyVdZt34CKtoOXjqchSLJjY7Sa3G/sg+nuQW9OGvKZ6wuYlEzcpEKO1mXs919Hy1kwEqYgiTc72QXsY92oI5gIFStdyjHoZtbxTGOH2lNmfe2Op1FOitSDAMRczAvn7fPCfGEl7h2/cy6/E89dhiPZ6rD5Y8GnuTpbkVObcmWZI9KBJF7G98AkEgZzBNXAbmEDRZm/6rLjF5UltkBfriJpsQePQWOK2hAJwYNUG+myfTXmVCqzeW3Bq5jpm9BhDVgMb+k28y9FjbfG6WUjMMBsu9tzI8NUzKahuxDpShibVzIWN6xkwchoVDjKKfSTYRZuYueY4VZVZdDg5G//zpUgzC9CcqODL/WDq/RROvk5N5FtfRLcK3C4qyelXjj5HxY3OGxm2eBbVJ31hg/sDql2ZSkhYKj1dP3IuzJnUhY3wfFhO7R0f+dTECsHGmoxd1mj221DuImX53P00UhbRv1oHZrx9xq2ianwfFYLX7iTSetux4sl5JiyaTlYDM1IHHaFuWURmuOC9X8agbdfY91sP6s58z9VXNfEMzmZPyHEi9c7UUmbSZcNcLLNF3CbEUdaygPrvtYyye8XGnBa8WVuHpSv287XCi0bqGCatnoLj5zJmHDvF1vadEXPyOPrtBn1GTcPq5xQiXvmBKOBSMxPDcRcurVhHo/tTcXiqROsCNbt8J2+cG4eu76PIDD12zcGoBnNQGSGu2eTt8cVvciT7fG5Te/d0bGPMvD4x+0+F75S+nqLnlJlIDAIGOxOed8A4Ng/DOWeKfyrDd7NAzFgpskwl9tVysO2aSMyG2tiFSyj1AL2DidB54eT1qkpubRGntwJ7l21k0vRpWCaUsOjicS4U1uHx7vqoe2WgO+FK6LjvZLfSI8hkRGwMRZ4rRxVaSEmRirA5yX+k5lhaUudyHEPtXjN07ixurttEhWhiSN+JuG9MIKujFP875dTRJLLucC909iJbex5g2rv+mM0CwZNTiNvpgatdMTXtU4nu5kLBXhV7Kx2l57FZ2NbIQTjliMPLLIzO1givv7Ii7hXbMlsTVeCMk7oU42hLtDuMpOXb4mhTyp6wY4ybPYNpK04hF4zs6dmZDqdfYhCl3M0Ow9milBfPKuF7tYK4fgp6N3rLt4GBCMWlpG63pSLcloCTeWQ2c6CghhH3+xI0yVoqbQvn1rV6zOx7iQuZNYlOcSFknZa8WraU+AhIDOC9K4K04WGY5VDmacYqToJRA4IZBg24j5u8kNt5VWhkF0sfq+/0mj2LvKoSPB/qMKqllLrKcHpfhPP2VH71uM7gWbNRjktnis8D1iwezK21m2i5fCYGS/A6Ek3uITuKylXI3mtwbp1G8ld3PB+ayBisw1AuZ1q9+9zpXgsKi0geHoxllohMK2KRa0D5PQXkcmzPlPPqbQgSg0Dwjgw8TuXgoijm0bLGrFq7kyFPRxM6KYroZVUJ2ZFNzCgXfK+VY1qaT9pLT+Sl8H3VzH9OCN3GU6zVeOpfcq4nN+f9CKH/RwRBaA2MAcoAR2Dqv8J5Awh2BlZu2o2/XM/4DiMZXeM5QlApt7IrEbE2iBNX9lEULLKh8Sn0YZ4s638C59fQeddcaoQmUTM4CcEMY54Nw9m+hLfdN7Ko6g2m1nhAllbD0qUj4Y0NxqtO7Kh1nMKtPvR3e4vNqXf0dHrPqQ6Nye0swypWgvslOa2HvqbYrOXYl3rIS+HAxC0UhAos+f6MpFk1eLB4A2UrPcjoo2fj2zbM3neMwjAr3rbdQuYCf3KrS7C59JlR82bSacALYtrsR5UnMnj5bIpCrFDlmbm8sg1LRp5g45V9uD8xM+TzCF4s2oJlnIwyTxEE6LByDsq3seRWlaCrWYbq0lvmvO1D2yszeTdoI9LMAvKbeeFnmUtwi3je3KlM9kFfVnY7iTxOxdp123E6rcb/gpEeh2YD8HF3deZnNiNkXynMtqPEbEHs0VoYrEWkBeWcediIyG2hbH95Bv1LezQxBSyYfQxXaTFTUtqhqx3AppS2pGttMasUPL1ZncjZngx6P4oSTwFlnpRgt2zSzvihsazAenEKNtJyrKNLUUn1tKn3jbwSS6YHNGfR/qH0XD4Xkxrm/nqUhJOBBL6S0MPmPSWilMiGEjI6GFi4fDT3O1UlSK7D5UUBCAILNo/C9VgWqz/d4mBhNVQfE/mW7I7R2UDQrjTynrti/6mQxRk/4fRIQUFLLRWVtbyM90PrrmFCYg/6rZ6DsWYpBp8Keod+wk1dTH73MjJ+DaR7n7GYKpdh9zz1T+vbyyofZb6A78JXCHoBdbqWob6vcHxXiPqpJcV+Kk4034M8qJjcfA2NPpTRr9lLXC7F4twgg7BNuZRecGL3r5vwP6/H7sxHMk1WWH1MR70tl6UJXUktt6PYD0RRIKe2yPsMT9ZFPsBUWsbOlkdweWPCabMKWYYSTGacr+rpc+sVR981pO29aSiKTAxoMZBe02dhspCRuDSEM19u8TnPA0uJDp2DiNtzM5NeDGJd7XN4HpZz8NMV5HITRVfdufy5Blm7NGgNMsbNmkHg5hjcrYpxeJ5B1GRncqupOZf0gpoKGc8fVsFKWUHFPBdSurqQmO6I/9AoCp+50Ov1OAqCJcy/2Z9F+4fiti+VB7mh3OtdB8koOU8/hWJy0lNz82cGNX6BSqLHZKMicp43JRlWyMqhoLo9bnezaFI1GokRtp3awfPtdfkwehO/P+5M6VZPrN5bEDFFw7MV2+jf6xHqDBHlJQWeV7Mo8zYhK5PQafhzfE9lYtk4hyf1HagQ5bSyj+BaZQf6TZqBstBE7VYRnD68lZQ2ElweZIAo8jrFh16/z6XcSULRWU/29OyMKsdIrUcTEEzguecrivNSCkvVGNLVVLiayX7ggdddI5af0zHqpYTNS+JFQQB5myXsfH+JippaCruUkdEUJAYThmAPUvr7MMb1MSG78gn85RPRE924/6oqT39piMXENIa/Gknvah9JOerDlJ9ukdjPBXkp5FZTk/XAE6+7WlxfV/xpff9n/Egj+8f4r4TQFwK/iKLYAugNnBYEodU/1aq/g5ApY/YvE9mUW5+YhZbUU8dR2yOFtGs+hG0pId9s5kjfbSzdPpSANZHsmtQbvZUEn73R6AfL2e57kS7dXmHzXondVBE5En4714/2lt/JyLfBosBEUMc4XE6GM/LOaNau287Bqd0JfCVh2fdO7Hl8jJjtnpS7Q0YvPRFtrLlQ6sP5pjtx6JLKL0ENuTNsDVN/m4xlBtQ5NpMSLwXjqj1Fnqpka5OWFAYJ9JgyA8Eksr/vTlKn1kQU4E2uD82nTKDYV8Ash+trN1LiKaHYV2BrYkum9xmHvNSEi1UJlR+OwfNOISY7I7l9ylk1ey+Hvl7H93o5dlblbEh8jixGRdAJHb0GT6T1ze9k1xU587EOPVw+Mr73Tey/FjPveW/sokSWteiO9ZNYsiZX4NYoDZs4LfYR5dz4VgWdk5p+x+9yr7E3YqGCn7tdIGqBBolOYHWjc+SZlVCniM03DmIp0TF71ERydZZcPLiNsnWeZKwKoHRxCYIRvO6Y8Z2Sh7wUBvV4SGSyK30m3Kezdzhh1pk8LAojerSKz41UmEQB03drpN4evJi8gdK2pbyYuIEl4V2RaUVixwfT9/R0Jk6dTt7g2oR4Z6JJM7Di0Rnq3ptKTl074rurcNnxlozRngzcMZMdb1oQuTAA9VcL7F8poLwcqyQRrZcVBXo1+e20uJ9XELjFhP09C9KG6/ma5sbKWfsJmJTOlkYnuXqyMXNc7uBuVwSiSMpMEw28E4lY5vKn9Z2dYMe60fvxfKVGWi4heqySiyNbY78zA4kJZFozVeRGLK9ZMbHmYy4mVuPWnsZEzwmgkm0WLS9+JuOLKz0fTcJ7TTTzIt4w7tZIfn54BY1MR+YdLz6leTC28x0K77uyucNRFPdtGPltKNmTG9DSooz05gKWS9OIHLqdkmaBZPezYcPeXiARCZuXSMZIHeUhjlhMTEOZUQwCNFk3A1ulloM92zGw7VM85sSi+WjB85Igmqx6RettcyhPtqKoto6wpZkUlago1yqpu+AdMTODiL0WQEEDN0waE23HvaDenhm0GzCK8V1vUds+hejRCtxelkOZDCHIh/Y9X3OrwQ58toWzqsMpXk3eyMO3ldF1LKNoo4ktj44TcMrAoBpvOPeiLu9bOHD+ZDMkX2JweSUQMusr5T5Ggid/R8zOxcOikLLhhSxK6cbjZZvp3agXlUNTyA+TUtG4lMF1XxFyaSKHHzbD8dw39L1MoNcTMuMjXvf0lBmVRE5xpuKuExiNbDvSlXKzktjDNVi88QAJvaG9wzfulntitjQRO9KNqClqiNJgal+AZaYJpyMfEWUSlG9jkMepqDrqG3u/36SmbQqBk9MI3ZKFKEC5j5EhG68SNdMTm1cWcEZOyo4gslLtcJOqEJJV2F225EzXrRQFqkiabObmtDWcym2A1teGkk7VWdb1NPe7r8NjQQxjvZ4yrtpT7qUGc6n2Hnad7YBtrBnrRJF+E++idTEjK9WTNtnwFzzBf/BX87914KIothJF8dnfXn8FOgDL/9mG/a8wu5hwHJOIWqpHIjWzoXUncmd5o2mTTY8zTyg3S3lWFkLroa/5vKU6FuFpbJ6/nYhl/mAyM6LzGK6fb4Am1URWSxearZ2JXc0cOj6fjNNZFQgQcyuA2o/z8bwtMOTVKHQz8jGLAtpvduwvqIfVI0s866USNCKc6F9COdu9GX3OTqePxwdGfY/hTHENcmubseqXRqe2byjvWMyDPrUI3JNCQUs/XF8ZSG8qIaeGioWzxjJh2FUurFmPdLkDpcMKAXA9FUGHBTNxf1aK0wcDVewykCZlkdpSQd5pb9oER2G0UeJ/zIyTTSlbUtrQYcUc0puoMVx34kBeE4wqkbiJAgYrGfcaeBBwtoLFja5ypncLLs5rS5mPBqsvCjJ/MqANcSFlaDBlaRo6uoUTN1aCeVkeNu+U7NizmZUXe9H3VQQOnyQcmN8du2cWGJ31VFJmMPDENLyHJlEsKtia0prMekpOBl6gzvEZFATKyKskw3DGGUGEtGZS0nv74d8vlsc5gQRv0rH3aQuStfbcSQ3FyyIfm28yonZUJm55JQL2JqP3sudgURh+y43UuDid1VXPU+4ikNzBivGdbyOtMJNfGTb6nyWtuYL+R2YAINWLLOx6AX3rGsQOtqNOz2/ILQ1c6b4R1zcVtBr/isxeQVxdvg7Vyxg+vA+ghlcaBzdvIGqMEpOFwMsmO1G9tmTWpz5EbvDm5+0j8D4QjR4J+dc9SO4gZ2+tI+SMcaVxcNyf1rfeBX6fMYzP+6sxqstdHrXdyIjDV/l0I4w7C9ehSSyl2u3JXPltHfsiGvO01mHsI3TUaBDL99+r8rLAn9bNPuP4RM6TJ1W5WlgTia2e5aH1SSq1wyHcyPBKr3jQpxa2sSa2Du+Dy6tiNEodRgswY8b+i4Sitd4Enp9AanuRY8/PUBJqwPmBnJMfr+E3OJoSdxkSQaTC04Zxm8/TaNAHwuM9SO7qQGSJK9+uhGDTPoNz32ty4nFjvHZ8BXs9I2u+4ODz0wTPzGRf3SO82lAXo40JrZtIQc9S7N/LuZ8ejKwMMutbcD6lJq9zfVDa6ABQ5EoxWVlw4X0tJnQZS+J+b3zluVS7MhVphYTSNpWZGXCXfJOSDjsecfJhEwLOGojcHIDeFiZ/+Ygy38i0r+/ROJXx7Uhl8k8682Z+XbhpT/ZyP7oMnkDaFg2zvG8jMULA5AzOX2jKoy7rsciWUNCtCiNfvKHh1Vhyh9ZBka8lfE5Vgo6XoXMEQa3G52IOp5e3I3RpPuNeDqFF1Sh2JTTjcI1QXJ7ICNyewIwGdzk7ZANufeKYvvokxV2rI5hEDDUC8G2WxHKPG4zuPJbn4+vR/nEM0eNdud59A1IbPVaSCkJqJKPOMhP9xgfDoDwkWgm1N0zh5sC1FHQr41JhLWT9s/FfaaD7r3NJbiuncEIJVeZ+YV10WyZWak9hHxXzb/Vn+6uWuA7Lou/vc1gy8BQSA9i/zKTcpETlVULUOEueN9jzp/X9n/KjEts/xH+7G5koihl/C6v/4Ac/+MEPfvCn+XcMf/8V/EO10EVR1P7VhvxXcFKWknHCj7M7W/Og0Xa8zuQQM8SCINscDi7rRrdbU7k7ujFX79bjyIp1/PbiCgBrW58i5ycfJCXlrBh2BPXkNAormSkOMSE97ACpFuTUlJAfLOPk2A186BNMZr8KzDkW2E6XEDclhOZtP3M6phahQyPw1hQSdySMoGMllPvZ4lUjndXPOvDz++487FaV9vU/U25QMNLhGeqbfzS5iJrmyeBF11DmVOB9y0BRbT35Q0rZEt6Snfn1WXpwP2eq76dLrxcIDvbkdypn7ek97NuzibfZ3mR1DeT0oI243E0npYctac1VNNv8EnGvMy2dogAwWIGudTERw4KwjRJwtC9F/fA7HV4nEztIyW93e6BzsyKvkozai96zYMIpfE8KVP/9E2U+ZhDgYmp1XJyK2RV0it+mH2bMjBls6buf0wPb4Pwki/SmEg7+vAHHp3Jm9RnLxG43CXuiZXGL3ohTrPHe+oU6z8YBIDGBYAREMFUrZVaXqzi/K6dQZ4F2pwcFy/W4+efyLDaA/DQbdr9uweP5G9B8U5BbWcZvTy4iMZg5HF+fhD62hC2P55vWC8dwI8q6+ey60p78UDmawEJm1elKx/Zv8L1WQvAOHbWmfsRXkYNZISArE0j+JZjJVR/R89gs7JcnM9HhCXoN9B89ncz+YYQsCqer0yfa3pvGqHrPGDDpDpOTuuB5JhGfMWnY2ZXh+rqc4maB/JbShXJXaN7oK+P2TCJyki1xhY5/XuACDF59DbrmcWd6c4rMMg5XD6FGxwh+WjEb262ZeHrl8klvz9MGu6lxbhryxZmU9xJQp5VT/IsnKZ3U5NY2Yxsl8GZ5Her6JpM1pg7q6QrUiUX0tv5AySYjlmla9pzYRrNDb1H2KGDhmFN0jujNiFlXsfyejXWchKBDOgY3G4DLExkGS4Fap2dQ87WWIdNvUrbDk6LpJbwu8Sfil6qMqfsUm3gzpUYFRhW4qUu413QrKq8STkXcJXRBFk8mNeCx1oPKN7KZ8rU/9vficHotIaRmErpMNa6X4nHXFGNWwMqxhzGdcKbwnCdzq97BpJLSpuN7Km0Lx/69nC4nn2KOsGJ/TjO8bokEnCkl9OdvmEUJfe9N4GleEOo0gZTWFni65fNLj7PsaNyU1muesSa+PRVx1qyZvYfcAg0lXnLk5SIt1zznwOHNHK9xgIkfBqHMhyb3k3H6ZGTAnNm4vNWjSa5gzu0BPM4JpMQXBJ2B1lueEddXw9SeVxF93Cmq4oDOVkLqBjWep+QMdnqBfLsD076+Z9aik+S08+XEio6M+WUGmef8SdU7YBNeQPwiORKDmYKD3nTcOBedqyVDD17lVvMgnvdfx5Rhk9lb/wiLTw6E8Zac2LCOoGXfUB6yZ0unw/h1jWf80CkETEzn/eBKrAq+gCSnANsBKUT9Fob7iByeXK9BG48o0sZW4/tSD5rV+870hvcw+3tSaeh32qpTURQZiRvmRpgqHZ8xmVhHyBjQa9yf1/cP/nL+RzUzySixRdEjm+IgkYGTZ+GiLKZhjWg+ZHqiLDLhd85MWktLerd7QYdnk7EUDOSYrNgztAchYyMorOvKL3uHkn3Bm5k/XSdsXRZmuYDcv5RBXR6haJnHrCETEDOz6RL8DYssCRHT7ZDllRKszuJQrUPEFjjS2/Et1g8s2XlxFyG/hqMaJyBRmrB+rKZit4kHicFYrbai++XpON9KInaYI27PRU6l1iFmqCVr9+ykd/UP1HRLQ6PS8WR+Q4Y+G8VPt2fwcWJ14oa6cKbBHrJNGrblNKfslSOFLbTMGj2J9E0WeFwswnfrdyrMcnJqSrjfLgxFiYhUB667LKjYoOXskjXk5FkRtaIKew52wjJBinNAHtkTtZRXqaCVTQSHhnQmo5Gct6vqoMyTICuW0s49AsvV1hwpqM/OGjUZ//s5Zn7sS0p7G7JauSCYIdHogNOLHIxWCjpbfUMt0bPi0Rk2XDuAYG2FWqWn+0+vaTbsHcpWuTgMTcb+kiXrbnSh34FbWMiMWE5MRb3ZFqNJAvkKFFky3O5KqXFvEgenbGb5qCMMfT8CaamO0m/2iBLAbObktp/Qji+g4qM9ttEijl90FGdakdUjmMhiF1acOUBmIyvuRIWRZ9LQasUzpFqw+JLM9vDmBB7NwUJqoEyUcmnKWgKXfYcO+dR4WszSW73oWO0r9S1jORRdn8QdwaQM8CX9oCvLwy5h/C0fdUYFpYMt8b9YSsIvobTr+xp1ihTtDec/rW9JiYS2ltGI1x3IbKBgfrvBDPschZeqAOc3xSzxvIrVgGJyjNZMT+mIXVA+ca99KKvnS8iOKBTJ+Ux8+Rx5oZTcBgYWrz3Am3dBFNYysPDqacr8bRg1bSbWkwWMGjkT4vrxeFQ9pn56g6usELXMwNVBTYn93YZRY6+TVc+SqucTUWcZyK9tIKBmCjqzjF3nOmCwFHCZbWay02PUX1I5va815U4SZnrdwf9IOrM9btH/2whmVrpPzYcTiVjuhvx7MruSmxFkkUlpqQX6EA92L91EUr4d9WvGEj/On++v/fDe9pUZr/rSe+5dCiuZWfmuA4cPbebG2xpE93Rj0vQLbLzRmQ4d35A82gffBVHkVbPi4ZNqrF82AIt0OVm7/DGqwemTmVDbbI6N6ETkOk+kgpnEOBcCjxbxa1wXGvvHoygxU33iF163duex1o+ex2fhNyWH3+fvJVCZRYtlLyjsW0rfzbeQVhix+yYlKccen+tlSLeXcPJQa/DQsuVbS5K626JJKafCHnRfbTFYSpi5fSxGpYSJt4az/HtHbOJ12EaWUOIjsLHKGXae74DZUkmf4I/kVldTYS9QUk2H19JorKUVaGv5US6KzN9/hJHXx+K/Kx71vkJanZ1DxoiqKAuNbB3Uh6K13mTVsSBqfhDHbx1idkRv0nv74WhRjqgx4XGzgmadPvG1oysO4QY0MXLeXK3CzWFNMFnKye8spduMmWROqGD/4O1cza1O9DYv3O/mUnln+J9/gP89/qoqbP+Gs/j/ciW2/xOwCnEVm5T1JaOHH67HwvG/X8HnlTVwnRlPeX8F0x/fYc2IwaRMNrGw+k1u5FYjeWsQlmk6EjupMLrqcbknp/b0D+jNMtI6q2n5IIG72aHknPPG4XsFuTPL+a3SVabdGgwSmN3iBrlGK86cakF5iA6F2oCHXSHd3T+TrbfmfStHpr59wYxjo9g5ZBez1o7H6W0J2fWscHldjN7egv37NwEwJmYAkl8cyKuiRtehiEpOWeTrVBSe8MKohiVTj7Cne0f0rlYIRhHNsjQ+R/jwa4uLHEurj3aLB9l1pAQcSEdyQIe5jwHZORmrfS/Q8cYM3B4J2NyKQFCryGvjh/3VCLL7VML5ZR4xw+1xfSmitZfQf9od9nxrjO0dNXaDU9gdeIpJ8X0xiwKJj31w+GbGOiKf4kr2uEyNJ3VfADKdSImHhLLqFfh75JB5ywuDFRBaiqtdMWk5dlg/UbFp7k7GfRiM7+gU/O9p6Wz3ie0prZjudZe5a8eiLDLjNyWK8a6PSDQ4EqF1p55lHK9KAzn7pAGyUgnSkBL0SRrO9drE1OlTKfGWMnzcTXwUOXws9+Xc2WZU6xBFzJEQfprwnI/DKhPf15bAHYl8X+qB83MZUj0YVAKKMjPlAwsxvLTn8LjNjNo4DddXpcQMVBO6LYfibSKKtfYkdpHh8gpsokrod+Ieq872wumjiZwaUqySoOf0+7jIi/j9Y3scbMpwGFVC6k57Vla5yMYxAxEX5vCo9YY/lcLiVtlOtPh5LuQrCDyppdRXxZ7VG3mr9WXn7z3JqW+mb8PXnH3SALPaRLXgFCZ73mfaoTFoUkWcHmeQ1sUdiREajXjP80O1aTb8HYll9sTd9iegXTwpxbYUFaqxfm2B26M8kn+T4blSQsiuKGIHeRMz3JkRne/zrFMQhXuUVFx2wTrZCID6XSJZ3QJZPm8/Mz72ZV2Nc6QYHDg1pyPlzlJWLNzHwhWjyW9VgSxBhfcdLRKtkeYH33DiSGtmjLrA+Ta1mf74DqvHDkX5LQV9qCdZdSwQmxSxtMpV1sa0o5pjOh9zPDhR5SAzE3pj7mPAEOpF7lwtPX0+E6ZKY96VQUzrcIPtFzphGyVS7iKgyhVxeJuHwVGDbGkWmRd8MFhB7S7h9HV6w/SLwwk8WUxObRtaTXzFu3m1UL1PwOTnTl4NKxqNf4e7RQEGs4wDL5sSeMyAwVpOYg+Rc212MDWyP9JdjmQP1GJvVU5dp2Ri2qgRHOzI2qyAyw5UOMHBMVvYktmGvk5v2Ta0D7nV1VhmmkjvpadbpS9EDA9GyCmgz8OP3M6rQrlRTmfnL6z/1gavrVKya6koq6tlWs0H7D7aCbcXFZS7KVi1cjcTd07A/Xk5CV3U3Bu0hv7z55DRwsTGlieoqsyi7YNpXGixnQXdRuCzN5GUbtZgqcZsrSKhpw1WCVDUtozeoZ/I1WsItczgdYE/GnkFnw5Ww+V5Pn3PPuTI1C4kdpOyuPUlDKKU3192JGnE/H9Kipa1tadYp/7kv+RcD+8t+JFG9oMf/OAHP/jBD/7P5n+UAzcYpWA0Uu4KCz8+oqFVLAaNhPfhfsRtdODn38cgiGAySUjSOZK+JpDCAAlFARaM6nwXq08K1FkGIudVIW5hGPltAzmzvi0KiYmj89ZTMreEohwrZl4YitReT9OakWz93oJDT5tilSRi90rJqhoXcFaVcSalNjUskyhrEsT09/2o1CqWnemtMKhh4ZljiO3zKfOypNxFTvvXE/klrTNVbDNQr8ogr44RbZIVpUYFsQmulLuC64tiNs4aSJVjsehs5egWFpB0OoBpTe6ycXMfatqlorOVULtVBCW7BPK0lox58Yrvr/0YsH429avFUty/hPxulShq7IvDqCQSp1bCIbycakejmNXpKooJ6VilG9l1py21vVJxfJ1HwTEvJsX3JeKbF0t8ryCpWoxZDvFLLCjxlBBilUV+uwp8p0bhdSSa7lU+k5Jnx6nJ65HqYG61O1QcdcNsFGgx9jWROjes1RWEPSjh0bnaxOhcMQ+Tcbu4Gp4D4ikIkfD6TQgTPw/kVIvavJ1em7Vx7fjay5cGdaNQFMPmmqeY1/EyvS9MR1FkZNyEKxzZ1oFdg3ty6nozro9dQ/SxEPKrmrgYW43shrY0av2N3DY+KLPkFPsJZNcGx8FJWCWU42ldhE2CmX6XpuDyuoxGe98RdLyMhP4uWE+TMnPXcXyvGZEYIWOJmSNTu1C1ZQz5laTovfXYxmgxiRKeFwWCKJD/2YmI5V4MDHzLxnEDyaqrJCHlz4fQ88ssMWtlzGp7HVlKDqVuEpamdGXlp/Ys/uXQH2sUbjRCtDJSaUkqGYf9mHB5NH5HUpg47wIRc1wwqmDh9GM8SAymKMzEk8N1yDzgh/euCEpWeqE8ZUfozGT8+8WSV9sen/HZxM+WEDPcj4JajnjVTeV8Ug0ilrmg2GyP6/Vkuqy5hzK3gritrsybfYL1owbhP7OA1fHtCVBkYfkpjWnzzrBo2WgOLtmA2SRB52bAbU080ZOVHD3bGq/9Eax405HkAT6Mvz6KrMkVLH11g7ihUsprainLsmTtskE4qMu4HxVCXqYNd8tCicl2ImpBELGjpCwMvcHJMy050KY5zZt85diajmwfsAeHp+kIJjj721r8DydhWpRHTLozxUFmygP15Ix2YcrjwUh1Atn1bXC5n86jrfWxSCumz/NvRI23QOsITzP8OX6wLQeeN0NQGYkbI+C/+DuCRGT4zmm4a4rJHqTlfP3dlN5z5tOymiRNrkTJTjDecyC/iQ7vq/n0vzqZbK2G7xXuyKJScL2cwMHNGzAXKPk2uSpJXe2Y+PQxxyZ1xtWiiF99LvOx1JtTdfcizymjRr9w5DEqLk9qQ6MenzGqpGQ0E5n6rR+BXeJQr8rALlJkfI0uyEtNhG0s5GhmI4bPmIXrHTk97k3Gens2KeW2tLwbS2J/VzKWmJna8yrFAVDbK5VLFxtz73sY7vJCvt4Opr3dN0q9Yej5O/z+uT1FAQrcngh4yPNZe7k7qjjFn3+A/2eY/6Lt34z/UQ5ckQ2/vL6FU71MFsT2ZN3WfogCTG5yD809Db2n3yV9hh6l0kCewZKswVp0TmbsPxZxMbkGntcykRjM1Fr3kWqrPmETU4rT3WQS7vjR9fEkNGutEUWQ+pYhlZloaReJ+y4lYeuzKAwWsOmZxqrfhhBzOATlKjtsJeWUusvYWvskHz/5E3s8mDJvMxcKanOm+n7McoHM5kYMGWry+2m4c6EeerOU35pfxOGjQORnbxxfyjk0egutD79i9objPEwPxH92BFYKHRYFInuPd6CseRlP1jYkt5WOjg5fyPzoip9NHrv7dyd4bzZud3PJm+9NWbYlgglsPmUT8c0LY6Uydpzazs2jjTg9uyO5NzzJrinD47EZtUyHyUpFm6kviPzsTe/Gbxlwfzxn6uwlt5oE9WMNjQd+4NGaRiiUBqILnIiaH8STHfUZGPqOzren0b7Xa863r0+tKR8R8hVcfFGHj6XeOEwxEjEkAIsmeWy624GMTl5opBU0d4zGf08C6hQJ0kc2JI70J6ORBUVPXEju7c7Hm2F4n0ph9dih2ErLMVuYKZxVyu7tXbHvnUJGYw0ONbPp98scXO9lYetTxIDg91ilGXkcGUyViV9xqJOFz9USlnc5TfZpH6InyKlqm069Oe9weQlt9z3n0NOmpLaywm9fPMHHE1i4bQRFfgryQyV4TC3FIr2E0qnOlPsaCFtRgDyvjPsLmpIyOwhTiZzAE/kE79Fx4Epb8kOU6G1BKP5vJ3T8v7BRa3H2KGB7RHMydlnj9rSEj0mekGDJqrgOTGt2h2MDt4AA6jNGHN8V0rPlaxKHeHG2ezMQYcnIE2yd0R++WhF8uBz3M7HYDkuhyv0iVPH5uI6Lx+ztSv4KH/zHRlP1dg7KD5akdHRA6yBBPt8GzW4bpDkKJEaR1je/c69vHVad3oskXANAdi0LIuZ7oFpszawdY0Cv59ePnRFMMG7WDJQJSioFpvE6xQfHJ3IWDjpN4uQwgtdX4H0ike5N3qK+bM2pgvqsbHoet4tKhjR8gWJwJnkHfFB/s0A0g0GUsazGFYJqJiMUyTCLEhSFUFzbncgNVchrU8H0PWPJ3q7E404ug6fOIqGbA6Un3fE5KKVP01d4eOST8KuSsN8yMfpqKQw1U1bJGcsMIzHDHGisisffN4uZwy/gsE79x8JLvYDdMwucHEtImh/CgoY30DqLxJwLYlWNCygw4/RZz4x1x1k69ATlegWV+0Zga19GaYANdl8lTPZ+yIu8ALC3pfqNdLq/H0vIwRKiR8gxKWDpqhFghkdpgUgR+bayOgtb9ydymi29nd4xpe9Vhu26QuLMIFJbywirlIIgQDWbNGrbJuM5Oo6iE/YoCwxEzrPmQ6QP6jQtMq2ZRpViaWIfQ+YpX86ubcvx0RtRn7Zlb2xjvG9X8O1SCJ73y7H6omDZkf6YlXCgT0eW9z7B0jP9CVxQhMM3LWt+38m4J8OwixTRBuj/tL7/MwRR/Eu2fzf+5Q5cEASpIAgfBUG49r8b6+hbyJBzk0nPsqWNaxTFwWZWLt7L9emt6DDhKfu+NsZrhYDXcoju6oznDjnqFAkJfWwpfu3EmJt3iOsnZ4jdC+6erUdeVSvMLnbIS8Djgpx6G98hz5GjeKPBlGzJ2cza5FdSEDfcHef3RsoNCuy+FWGWQ0GIkjGPh2OZZcJWosUyVYLLk1ymtrlN5NhQRsyeRWZDgUorsvG9YkQb5oZ9pJnkAjt+fdcZqQHq1I7FJlHH5F+nsONZKzZOHMCGsLM8/RJCyWYvAqZEUB6iI3BJOapsA32qfiDfpMHvspafPW7Q5/g9In62Y9SVW+RWUyEKUNyzhOm3r+J1F1RvLFmc2hl52R/duMq8zegczZQ7SkmZHUR2XUs+jqyC4weB8N4+yNRG5nQcxvweF9A6Q+JQb8pcBLS5aopLVQTUTKHMDaqpkpGojLxZXgezjSUAFpkSVJlSPud5EHg6jYzWjtipyhFtDRQHiLwcUoNtz9qAleUfC9u+6yn3MWLXPBN5CTh90uP6Wk/MRE+SxxiZ97Av1askUl6hYM2MvQz1fIW8DCw22ZHT0ESts9F4WBXxakAViscWE7Ywnc/7qyHb4UBKeyv2jetBQWUz3ap+JkVrx+cFNbB9msSlpW3wuSFiUkH6bluie7ji9KmCBmPfowuqIGmQF9mrQFJYhjxXTtJqC7S+tiR1ECj9uQRb92LsdmeR0VCDXaSI2610mrT+AsJfcC8gsjz0EtpMS2QX7YgaZ4HdQxU/tX1PeqQzW++243ZJVQL3G0k4GsSCS6f4NiQIkxJW3DqGRCshSe/I+A3nECUgzS4mar0HSc+9ebCzAVNuXSPmRgBRY9WkN5Xz+VYISeUO6BxENOkiYtsCppw6x6atWznVewvamYUc3teekhA7FiT0pEXnD9wqqEJJNT2+l80kzRLR2UPqHic6BYVT4SBgHZ6P5wMtCokJB+sytvyyjefFQdjGmEnpaEvCSF/eL66NUSXwKd+Dn5/3pMJOwtFP9Sm66YbORqD7gKcE79dzaFcH5r3sRWSMByG78lm+cyDu19KosJOS3saE8w0LanUPp7fPR369doKSkUWk9/DF6VYiSZ1lmJEw1PsV/vNKiZrmiVknw+0ZVNhJmbn1BMGbk5jeegjJ2Q6cb1+foXuuUuYpErK3gNK2pRiuOJFZX0lMhSu9W71ElSvysKgSY6IHobOVse7nwRxJb0j5Wwcij4bhuNqCtF4GytqV8OvqYRRu8AHgw7jqTAp9TOLPEqRlUlwbprNqwR6UqYUYjFKmjp9CajcjY27d5deWF1k3cxAu8iI2bOtD3FgJPjf0MN6S7j5fOPqyEVVUKZRPdST/tQvKZZlY2ZYjmASSZolYfcnm64UwMvS2qHtkUnvyR37uMowWc1/gPlNPXB85ZT4m5Muz/z/ZISZ/LektbVn+vSO1W0UQudQeeXoho49MImxhGkYLAe8L/0RX8WMR2z/Mv9yBA9OAiH+1ET/4wQ9+8IP//0YQhPaCIEQJghArCML8/8XnPoIg3BcE4YsgCI8EQfD8D5+tFgTh29+2fv/hfUEQhBWCIEQLghAhCMJfU9j9v8C/1IH/7eJ0Avb9V8bnxdlgUpkJXZzHizF1EIwCK+I7kdZcwYduvpxosI+OR5+S2sYGyXGRwTuvcXDKZjBDSOs41iwZgu9FE7dLq2BSwdZFWxl36hLOb8vos/IWt3c1xjId9PVKkWoFIpLcKKxixPWtEc3nDBwmVFD9wHfWztyDbe9UAnyyQIQpi6fg9ryc/FoO7LzQgcyG1qR3NOJZNYPEQR6Y5QKTtp0mvTnoomxQRKvI/MlA9Olgumx5gGZwGj6XRRL6CkTq3EBuJr23nvQya9qERRIxz4YxOy7wdFUD9u3pRGw/C+Z0Gcmp0e2RqQzsHdwdmVbE9YkUnyUGph0Zg+Z7Lo4dU8mZ58vO+VvIqywDRx2YBWzidaRMM7Jo6jGGnbpJy+kvKajngssFJdmNHDk+uTPLBx4jrb0jLm/L6VH3Pf4rDfR2+0CFh5HfNg5FyFUydMVVRKWUe/drYZUqYtski6wIZ1yVRZhbFSL5xYEhNV7jGJZLVmNbnJ9LiRnpRBWHTCQ6E5U2FGAyS/h5yglU8flkNlBgtDLjtwlCtxRiFgXcdimZ970XS+71pNwVEgea2dH2MDd2NSXqpR/ZTRzhpj2FTbwRzJDSQcD+uwl5vhaHTxJu3KrH8/chyEuNRM32ZcKKs0zedAr772aK8v8ICQsmkfvXa+NxUY5tjJnqTmlET3QjaF8mg4LeUegvwyMoB5ufFbgskTLQ+RWa9n/87Vte+caDL2G0a/jpT98PJXmWzN46BmvPYnRdi3B0L2Lx/MOopQYWtruEydLElU0tKPFVYZ1oINNoQ5vTb9Hbmhm3dDrj292lpSaCo11aIdVBUV03mgbGMb33FYoCRTYN6Eu5lwlpkRTLdLDIhzdxPlglCuRWh1mh95hzeAR9T85gW2ZrsmIc8biXT14VKVqjnGqaVD7vq0bwNh2ZDeQoX/5x/UqTrIka7I8m1UxGW0eMahk1bVOQb3Ng+LEp5OisUBaYsEwXkdYqIq2FFMsME+Z1LoT4ZlDiDZ4XZWhdYPm0g1zf05SixeUUB5mhTIZNuIzMVo6UBJswHjAhLzcjmAWCpnznbZo3Z7e0ZcDFKQTa5zFzyllS+/uxsfNRcnQa1l3oTpNL36leN44Fja5jMymZ7MYmKsxy4sb5ovOyw/W8kl8eXuDXG71Z2PkCVrvy0JcqKA4QsYsxc/lmA97mebNt+RY+L61Bc+dY5KUmLNMqiH3sh9MnEwV1DBQFqpClWCB8tqKopZbJa08z//YFLNdlcvTXzuiy1KgyJKR/cGNDu65UPxuL/RENtj8n43VBysIv3Vm/sw8ZjaXMedGHkvpavE/LMCskZK8XeD62Lj3qvWfRgaFETtAQ2DyBIr0FnvMN9K3/Bn2ZnITVGjw6JWEvK0O61RGtSUHiEjk3DzSmz7XnBB2rwCMoh4QHvthHGFAqjJiNAiPH3ESnl5G8PoTtjY9TVNOF3wcdobSuN94D4zAp/oIQ09/lL6rC9r8JoQuCIAW280c10UrAAEEQKv0/hq0DjoiiWA34Dfj9b8d2AmoBNYD6wGxBEKz/dsxwwAsIFUUxDDj1F1yU/xL/0jQyQRDO8ccFsgJmi6LY+X8xZiwwFkBqZ1fbZ+cs1Cr9H92SlhWQ2sWVUj8zgkFAXirgfzKHxBVKbM9oyOtdjuaehmHTrmMQpYSXuhO1tgpW8SXkLjNQ9soRqQ68OyaSdskXRbFIw4nvKTZa8OxJZRy/gHJYBvP9b7IgvAeSm/YU1NPjcl9OVhMTyiwZikJABNdXZWjdLGBCNqlxzoRuKSClqyPGuiXoyhTUD0zk3fNgerR9jbO8GI20grNptajvmMSpFw2wjpaiKBJRlIpYplUw9chpLAQD03ePBcCyRQ7iGUeKAgWs40TKuxRjDLfBr0kSMenOiHlKHD4JyMtFRAF0NhKMapAYoLCqkemN7/IkPwjteFv6nn/M3qU9kBggo4mA3TcB62Q9+WEKZO1ycViiJKGHFdKQEtx3KnBZFk/6skD6bbjJ3i1dKQoSca+SSe5zNxS1CrDda0WJlwyDGtw6JSOZYU30SGssUyRonUVMTgYCvLNIe+SFLqiC0GVFRE1wxuEzlPgIGKxEOrZ8j1JqpIvNR9altCPupj9aNzPY6/HfD3obOelNJVjHChQ10TKq+gvSdLbEjQogZoQ1VrESBDOsnrWXmbvGsGvCdsYcnESrbu95eKk2FSEVyC2M6LNUuAbksTj4KpOujQABlDkSuvZ8wbWEymhTrJjU5g6H97XHYAV6+z+0ZROWj+m2AzaJRgSjiPX8FCpMMhb5XmfewnGsXLGH1n7R/+0Ulv8vfTvY1vb8/WfqV4ljpOsTfp03ivTWIlvbHuFNWQBvh1Qlcqw1i9pcZtmTroTs0xI9QYnDcwX5Vc2E7C3AYK8mtbUKxwaZjPB5wYbvrbE6b01FvwKKE21xeSUgDM2GQ05YjE4nMdwdl9cCRf4CQq0iFHITxXG2bO58mF82jqD6kG+8TPZldKUXXFjRBlWukZTWCoxWJjrW/4SdrJwPfYJJ6+iCrAIUxWbye5ajeKVB1SoHZ8tS+ru94WVJIDFTQkltbYnbSx15YUokRtC6QMOOX3j4rjLet0SSOwpgFFBlSbCNMZPe1oQgAAYBVCYcnippMuENVx/Xxeu+Ce2kAnS3nFB1yKagTIU+zZI+zV5x5mMd1jY9w4ILgxAloCgSaNz1M4/vVifgVD6JPe0xaES8bxvwXh5NwvJQeq25jaVEx4kJnSjyV5LXTIfLHQXyMjOp3Y00DYnl09nK2HVIJ6vIij21jjH26AR+7n+WZRf64PhVJD9MoPFPX/i+tSpZbfUokpXM7XOBlbe6Y7Y24uZewG9Bl7EQDIzdPwn3ZxV03XkfKWa2n+iCyQJ8rpfBijxiU53x3yei+C0L8yx7tG5qlHk6pKU6EEXya9mjsxUwqqAsVA+lMgIqpWGv1FI6zIr5dy8x6ux4jBozI5s+4fmwmqQvAflNW6Q6kS4zH3HmcEtkFVAUYgY7PUqVgQVVb3GqQ2OQy8iv64RmRCrTfe7RNeDrPyeNzMpDrFdr0l9yrvtPFv5dGwVBaAgsFUWx3d/2FwCIovj7fxgTDrQXRTFFEAQBKBJF0VoQhDmAhSiKy/42bj9wWxTFM4IgvAEGiqIY+5d8if8G/7IZuCAInYFsURTf/2fjRFHcI4piHVEU62icZZi0MtRnbQDQHCpGbwMhewtp3uQrogSiRzkivLVGPzQfo17KuOmX2HyrI3sjGtPKNoJmi17itzuOiseO+J3Jpt/gh9SyTWH8uCv88vMRHBSlfDpehYAzpWS11ZMS4cqGYQNwWqvCuW8SXpekOI5OpH7VOPyPZVHuIWJuXsSM46dIbS9ipdBRv1osicuUTBp+Be8NUlTRSr5eD8H3ho6YEiduTWvO1u8t0BoUvJ9QA++bIk5dUjD0KCC3ugSJVs/CbSOYtncsBiuYNfI87TwisMwwosoESZ9cXHaqUGdA3BtvhAwLHD8IdJ7+mNyqEkq8JDiEa5kx9jwGKxCkIgZRyocIX/LqOnA7rwp6Swndfr3H7PZXaTvlOUErvuP2IA/hnAM6JwuGd71PTfdUKq/+yrezYRhVErYd6Yrrg2xc3ohk5Nmg9TBiry6nx+q7FFQys37iXsq3e6JfX4pgFHD8aiDgTClOj+TI5tqweMgpAj2zmXLrGj43DAyed4MNw/ZjVojcuVaHS3fqM2HPBCpMMtyfa5E46bB7asGkvWcYvOoqw356hFQnYvFdxaHvDYiYX5W4AbZ4PDBTVFuP69N8prwfgGWmSLmowC7azP3rtVEWQLvQ71R3SyesSgqFL5xZNX0YA5s/R3DQ4dg0g48Tq+O0R41gFDh0sD3lHiKSGkV0afoOo40JldzAzMlnMaglVNjLyDjsR0yyC8sHDaUgRML44+P/ofvgP+pb5aDE9ZGEnk7vmXB1FHprAdtvUjaOG0gTTRTxve0I25bPmrM9kRVKSfnJisn1HlDUpgz7rxKGXriLeXEeFe4Giu64cnp4OyqSrKmwEygrV6JKl2CWQlaeNSaFgEmUIJgFFCMy6Nn7KeWFKsIcsrDIkrAqrgPlbhCgzsFvlQkfRS4WIzPImqAloH4SIQfKAHiyuCGRi20oraclr7YRZbGZ6VUeMGjEXcqeOvH9sw+/H+xHfat4Zhw7xeB+91Gkl+DYI4X82gb8TmUTta4KPlfNZA/TUrNKAlKdgDoDpKOykOXLsIyWU71SEqJOSn7zCt7k+LC6y3HSG8nQrLXG3KoQy9+tEL9b4XXXzP30YAIOmTiVVR/7qrkE1knG7bmO5CkBGDz0WO7MQ5kPglc5RrWEd+erkNRNZN++Tmzb2hO9rYxlP+/H/whYj0pBma/H66KMZzEBlASYGOr1CoNOxuIpYzAEatk/uweaKvmUeAiYg8r4trMqudUgeIeBFf2PseFQTyQ6gdCNpUgEkfGvhzDy7XB0Tmay6lhwK7sypxd0BBHkxZDRyBKdSYbPMQk9dt0j9rkvCfMlpPY3MPnoOQadu0u5nw2CGWzjjNhFmdjd7DCyMgkJmY7IJCZKqjoz9N4YWrT8QtCxCi7sbonX7iQauieCGawTdTye0hCpAdbO3EPrBl9xuaHA9xcdu5b0InK6K1nNnOkw9zEZ97yY/GjwP6Tv/8PwAFL+w37q3977j3wGev7tdQ/AShAEh7+9314QBLUgCI5AS/6YdQMEAP0EQXgnCMJNQRCC/mnf4P/BvzKE3hjoKghCIn+EHFoJgnDsPztAq5czrf59inqU0jAonnKjHKtkEcOmMkoNFnjd1eL23IwggtNcGFr1NfkmS+o3iMTmioZ9M3txIbo6t1/UwCbBjP2hXM4l1OD8haacmtuR6TeGcHFfC6xSTIw6cRVJvoJateIo9bIgfYYevUmKenoqFYtdKTfKGX/zFopCgcWVr7M7rQUOb2QU7vQmttAB2UsrEiscyayvxrN1Ms4t0yibV0zWTj+KZpbwk28k0n2O+G2OIaWNhKR3nvxW6Squr4y470rG5VUZOgcRaaVinhYFcSWpCoJJRJNhxnaxBTpbGc7vSpCVCSgKBRze5XPoWVMEESYMv0pOdRUHkhshb5CPRaKcqz+3wvmFFPvPRdS2SaLMA86ubcual+15uaAed19WI6OVA/lVoN+G/4u9946y9CrPfH97f/HkOqdyruoc1Ek5IKGMJJAAEY0IzhjGNmOcx/YYB+4dj23u2IwxyYkcDBJCJAWU1QqtzjlXzqfq5C/v+8cu5LtmzXhsCwZz6XetWqu6T530fXvvNz3P836LvztyJYe+upnrCsexa7DyjjqtzR4n3tNBaiHkF7c/Tt8jkh2lKT784G2UDkv2tkYwGzHnTvRyzdVHqQ1azP5exNKtHmd+3eDPTt5C+Ce97K6v571//SU+9qlX83+//ydJzUre+LoniXoChm87z6nxHl73sYe5bu0pstMR73/mLfztH7+WByYv4q5feQyvKyGd8ml2W9hVmL/YJF9qcOpdRXIPZin+9Di/88c/y83/6Sk6DiZsfftRHh1bz/7HN3DmyRGQYC8HfPnkLt6/62GmjndTWZfGL5lkxwXxVVXWfqHOaKnMAye28XvX3c/cvh4+MfYK5E/Pc8mv7CUxBemTDq//20dwF2HjdWdf9oYIApPcuRZ/8mdvo+2I1NWgNYrh/+sEf/Kz7+Q/vul+7rx3N4kJvc8k5K5eoNOskc34vOfXvspprxv5Rx2ISNJxKCBxDJShcCqK9T0LKBN+4Xe+ysgnJX5BMDFT4s7rXmDycC+fP3Ipa4fnuKl0jK4bp1h5uIfCrgXuG9+O/NAyv/WttzL9bD+uHRElkrUfO8Wzn7iEidclqKZJ6kCKn7nySdzJOo8ubeL+ye00N/t07BO0ehP+6Ktv4r1PvINP7LmWc3/kID7QQeacxYnfyzF9g+L8GyEYy3L2S+tY9/ka5es9rP/ajuEJfudnvsCBgyOISJB4BjNTJX7rvnvoOJRgVX3uGjnEGz72ELGrGP6dE1gyodXl8IauF1k41U71Y4NMv8Jh5uos12w8zZHZHkbedIafuegZljeY+CXYuXEc+6ZF0vMJs1cY/NXEjVz6Zy9y6lwvl/3lXn7tzz/DT+3cjVEM+PzP3440NGdpw//dZGmzSbNlM/jNRf7w4q/znt/6Kr27E07/ksFH3vNmzBZEmYSTP1XEkjGFR1NEsym6noPe3U0mvzZCvc8gM6PoOBIx8O1FlhtplrbYfOk3bmfNV6v0f9ymq73G+x6+h8++6VbmLzbZ8csHuPO/Psztf/QYH3rTm7n+xgOk96U4/qnN2LWIdHuTh/dcxNgdGbx2eOLbOzhU7mX4naeprHFQUlBdl/CHv/LTHPir7SSWwBsqUDha4erLjrN8UcI/7L+SwivnEP4P2FV8/0roHauO9Hs/P/+v/CS/BrxSCLEPeCUwBcRKqQeBbwLPAJ8HdgPx6nMcwFvN/D8B/O3LvyD/Mnv53Jd/oymlfhv4bQAhxPXoEvr/L8K8C3bBLtgFu2D/QlMgvn8c7sV/psw/xT9lzQADq//3Tx9FqWlWM3AhRBZ4g1JqZfWxDwIfXH3sc8DJ1adNAl9d/f1e4O9e9rf4F9q/BxT6v9g603UsEdH/YYuD920m+tV2ytsVaTPk+aNruOfj32T6ekFjQ8jxX27jqfdezv2T2wkSk9f82mN4RYNoIkPPM9DqkNRDh+pymty4YmGHiSj5XHzPQa7+/ef4sw/+BEkxoP4fOqmOSG4ZPoH5u0Xe0ruHn/nk13hlx0l+9SvvpNUb88GPvI0Dh0cIChA7gpUj7XTcNsWTf3IlfXeNMfnIEOMH+8j/forFnQLn70p85/7LmXm9z5Nf24nKRcSu4r+cvo3We5Z57MQGbvzkM7QdF7xz43N899BmnC8XWX5fneqwRFmSxTc3WdqW41d+4j5afTGNNQXIRAx9u8mTyxvIzCWkfzdL62AJkcD4a6C8FcbubOMbv3YDURra960w8HWDO//sEQonJdXLPEYeCPjEX9xFWHWIr6ry1z//Jq7+hT3IJwuwbLN2+yQiVnzsS7dTes8Y3/305STFgFYHHK71s7LOIjNmcPhTW6ndWqdxso1iW4OOQgMvMGm+b4VPv3gl/+Xkbdz11qdJTIHXqThZ78ZYsDm5Z5j0cZvPT1zGC1/ejjvfwpxxqA0KFstZnnn7TkoHBS3PRsaK9iMx5o4K9XMFfuWOB3AqCV1unWav4DMHLyfMCPZ9bQscyZGMtggGfYavH8Os+nAiy589/yrWfb5Fq1Mwd4Wi98kKl/ePs7Qjx/HpHuIlh8/9h1eTmofJs530ZGo88o1LcMsJ1pVl/vEXX0XvE8vUPjjwv1/A/xuTLcH8f/Kp3tjgbf/x2zz6hUvZdcVpDn10G5U1DpU4xYc/excIyIzXmT9X4lM/fydX957jy/fczGdPXsr5dytEIKgO22T/aIr/cNODLO6E+Dc7aK3z+dgf3U15s8PQG88i5x2+tvsSpCd445Z9RB/q5b994m6mn+vnLe94lOTeTtJ/00b8mx04ZUlqHrIfLTD+3CBPfu4SMjMR/d8wyZzRecDfPnMtXl+GPS+u45ruc2wbmeItv/4d8qMrmB5kD9vsWjdO52fS3PbRx4kdkFMuSEX6vMVv3vE13vve+zjx3hSFtibL76sTjnocbA5SOG7wuzd+jVt2HOWGi47BQIu5O30mf1dxutHFf33k1chQcOTvtlLzHFbWS/7m515H/+Y5fvL37yfZVgcFhxd6GPpTwfxfjfLA1DayN83T/3jIwf2jxN/oYPYafS9u6DzBl566kuIei69/9hqerq3nOx+4jt6OFU6/02TNhxLmd5qcemeJoAD9H7eZeE0Hf/Spt/KpX74T+d45St91Gf+ZiOLpCBEL1n65SfjRXmSsyExIkncssf4vj2E1QQZQ7xecfy30/u00jbMFGsOKTf/5MFf93V6cuQblF7voe0TS/fEphr5VY/fndvKJY9fw0K9dx+zVBW5sO0arS/GTv/wN3vWR+wnO5rj50sOE+QR3ERILRvJl5v5iDc0uwewVDt3rF8mcr+GVBOUtgskbTY79UpaNmTnuesUexJLDGwb3kT9lvOz1/e/AXgDWCyFGhRA28Fbg/v/vHwghOoQQ3/OLv81qNr1Kd25f/X07sB14cPXv7kOX1EFn7Sf5P2T/Lhy4Uuqx/xmA7X+0IDG57+dvYsufH+Zd73yQsVfnyZ2VlP9yBHfG5G9+5/XQ6dP2okXHcwatbpe3Du3h1FIHCQKnEnPtNUfY8CtH6XjTOCOZJWiY7HjvQcIsWG7E5swsX3nkKi567yGu2XiGxp+2sGrw3c9czum3pfjo2ev4u8mr+cc/vpUd15xm6NuK6uaIwjGD1KICBWv/sc74XIl6j6T1oX4K5xTdLyjO/7rg7lt3M3VbTM+zIfndKTbddprSszYDjyQMZCuk7BA553Cy0U2jHz66+3ra9lu0/8wYb1/zPFYNJm/MUEi3yL11imcq6+h/GGauMkllfU7f4zDx/6xn5hVw+ieyxI7i1rufR7YkuXOCgUdbzFxjYfjgf6jBzFWSj3/1NlYu97loaJodf76fjjeP077HJDmcx6wFHH3/VkrHQt5z08MsfGWIc3c5eB0JS60M7cdCRMXiP9zzdQ784xaMAK59015EAm/f9ALth+Cdo8/ReLALni9Qabpcu/kU3NvB/WcvwlkJWfeFOu1OHRFDz7Y5ZARLT/XQ91iNU/dk6NyX0LUvpPSIS2VLAbumiGPJuvcd4+7/60G8M3nef+s3+NDem6ndU2XiAxu47K7DDHxZO5a3vu1ROvfHqBkXUbFY/rshzv1nk4HHfN576WOc/SVJfaeH1dvkxM9neOaRi1i5qYXjBmz4hwbn7rJ4989+HXfG5Oi31lM4rVj7q8do/4sMtQGbk+9qQ1kvfysJBYZU3L3xAIdqA6x/7Wn2vriWpRt9UuWYR3/mKgYebpBYiihrI/IhZ35SsvdDFzP7+xH3bNhDHErWfaGFX4KzX13Lp89czvC3Ql7399+FpknhRJ2V7RGTn19D0u2zY/t5nBW474Gr6fudU9zzUw/R92TIpx+4gVYXFN43jtfp0v1ciBHAzDt8ui6ZpXj7NFPXG1RGJMWTMQOPVMFO6Pid8/zUDY/z+H+7grlPjvKPH3wVbR/Lg4KO26aohzbLGw0+sv+VeH0hzqJGNw/cOM7f/vFr+fAnX0f7bovl2RxX956j+ITLsWoPUQr+4mN3M1YvkijJ4N9bJL7Bpb0TFKwWAxvm6bp0lve+/6s0llN43Qnx7y4RfqqHA41B3rX5ORILCikP408Weevvf4uZY104f1kkaDNQdkJuMmLzzjGibMy33ns9CEV2Oqb/0Rrf/MzVzF9ikP7dLPkjFtPX5th022l++vbv8o47HwWg7VRM3w0TiARan+0lzAqYSHHbnzxKekrS9qdTlDdJ6nfUWf/a07hWyO5PXsLFP3OAxatCfu2er9L/kGTfp7Yz8o2AG685yOnf3syjv3ENx34xx/W37qeyRvLM2ChzV+ZoPxqgjudodpnc/rNP84H9r6FwSvCRo9fxZx97E0MPhjx9/w4Ka1Z403seIeoJmPq/1hP+1BIbX32agUfrbG+fJiylKJyP6TiQMPhwiJGK+M4HruP+o9t54/W7uX96O6mFHzDY+f8ACl0pFQG/CHwHTV3+klLqiBDiD4UQd63+2fXACSHESaCb1YwbsIAnhRBHgY8Db199PYD/ArxBCHEIDcr+2e/fhfnn7UdqmIkzMqCu3vhLTF1rY7bAvHIZ70CRzAyUL9YLT8y6xI6i/YCkeXuVn9r4LA/9/CsYuyPNdbce4MQHL0L84hz1L/dROtbi3J0u3S8o3vSB7/CJz95O14sh/R84xZr0Ip87eim5p9K4y4qVu+uIfTniHXUG/7sBUrD9QwfY8weXcv0fPs2z776EyZsyyBCaF3nkn3eJbqrQ9ZEU4z8dsaZ7kbmvDSEUOLctMDfdhpmOeMdFz3Hv+e28Y+3zLIcZnvj9q2l0GZSvChj5oqC82cKuKsw3LdCfq5AowUIrw+TJLt53w4N89s9vozoqiNKK7LigcWUTlQheu/kg0602nj26htt3HmLvh3dRvqPJWzbtZf/KADOfH6U2BK+4+SCnP7iFmbf5RBUHd8qE7TUSJRj4iMXMNQ6JCcUTCbPXKDJjBo1NIfmDFk5FYfiKxZ2CsBRhZiJSe1O0nYmZvFUrWolI0HZc0OoGqwbNqxq8ZdNevnpmB6kH87QfbNAYSFFZI/FLio1XnKfy34aIHcFbf/9b/OU37+ANN+2m167wt6euoj6WJzUj4fIKyb4CybY6ybkM6U0ruFZE/alO2g9HrKw1MXwwPcXiKwPannPYeM8Jzq6U6MrUubXrKPXY5RNPXo8MBL1PKIz3zNEIbLIfLjB+T4w15jL8zSazV6YJs3DJ7UfZ+8AW2q6dI/1fCky/wsXb4NHxXQevTXD4/3n/y0LpZjf0qF/5ylV84yPXsfUnj1CyG6xJLTAf5Ln37Ha6/zpFeaONc8cCsRIsThdwpyxkBF0vhsxdbiF3VHDtiMaL7RRPKMJ7lvip0d3MBG088+tXEGYNKu+qEb3Qhoxg+2uPMV4rsvRUD9HWBndvPMC937oad8sK7n0FNrz7GFMfWE9twKI+BP5AyNB9gpkrTTr3JcxfJviPdz7A1376Ruz/Ms8rO07x8W/cwqtvfoEnZ9bSeLGd7hciWu0GqbfP4H2ql/lrYrqfNJi/QpE/KSmeDGj0WSgBxeNNbvnE03x5bBdeaGE/0EZ2RiP/g7yB2UqQ75tj8dv92FWojYBVh9QrFrmt/xhfOnEx6ZTPXcOH+eaHr2Nlg8LwBa9+9XM8PL4RPzT52c3PcN8f3MzSWxq8cugMjdjmbKWducU8SWDQ87BFeZNg/XXneEXHab41s5X6l/pAgp+HvqcanPxpm1fvOkiXXeNrH7me2IUwA4kNPbtDKmssut80RvQH3aT/YJpISVY+OkT+3RP0pSvMt3IcOTpE5rxB0AbdL8SkZjyaf1BjfiVH9+ddypsMbnrjHp798CVYTYWfl7Sd8TjzBpvR+yOWtto4tyyQdXwWvj1Az7NNTr/dxpkzKZ5QLG8UFE8oFnfA4EMhkzfYDF05wZXt57nv3HbWlJY4dG4AGgbvu/5BPval2+k4GLN4T5MbR07y9KcuoT6o6HlWYdVjHv/2b/5gUOjZfnXF9vd8X17r4d2/92M1zOSH1gO/YBfsgl2wC3bBgB9LGdTvh/27KKH/S036gqVfbJA/pxAxFD+aJXEU6dfNYtRNSo+4uHMCsymQr1+g/79ZfOSJmzj1LpueZyOW/AwoxdLDfSCg0e/wqhv3ErmCj33hdgpnE1CKkdQSX/jGdRQfSrH17UeZvSkiPJuleDJhfdcC5h/Mc+YdBh1WndgSfOfPruXkz9rkxxSXv+EgqmbRdi5ie/c0SgpsO2KhkaX9aEB9SGH9TTvCVCSR4Fitl+2dM3zkwVfx9G9cgVWPaDvtU9pt4/zWNJ13ataD90AX459Yx9xfrmHuhV5ELPjLh19FZa3gXa97hK4X4fJ7DhDVLdSiw4Ff38nkn69j6OuCbz+7k9gSXDt6hqcX1nB8ppvb3/MkmWk49hfb2PafDzD4NxYja+bw1vhYT+Xoaasy9mqbzldOowxodEs690iKp2LyhyzkzWVWNgh2vn8/77z9Mdp7q7Q9kuKyNx0kfvciIhSs/Uef7ucV5asD+m6YoLozIOWGfGNiK9cMnsNsKU7/RIrZ1/p07gtQAk7sHsUrSQxf8ZXffBU3XHeQByc38fHP3c5A2wqiw6fjpmm8sTwdh2OCZRcSwXDbMrVnOrnitQcJ8gapJaXvca/AdCKiNBz9x414j3RybP8wn/rQqznd7MReNCgelpjNhPK3+8j+9wLT11pYYy5vufMJ5n7TZ+S1Z2k7rXj26c30PeWR+WCe2JaM3HyeTUOzVNYJdr7l5c9LDlsWj8+vAwXjf7CBb53Zwv0z23n8D64mOlJgeb1NYSyi+Ugn/qMd2PkAtwxmA8bekvCKVx8gOFGg+KcZ3nn3I2SmfGp7O/j7P30Nj/3h1czvtJl+pWBL5xw3vP5F0nOK3fs3MLNQIDupaH8gzQNfvhoRw0ixTO01dc7/6UbGbzconPeJNjQRdYOpVxqIGObu9ul+LuGvT1zH2PsVkZJ88ujVdL2gOLjch3qgndLRBLMRYwSKxhf6WLjV5x1XPcPrfvthimuWyU7HeL+ywoZ3H+PaX3qe8A9X+Ni3bsE2YzqydQAmbpEkv7aAXY0xGzGRkqRuXCDMgTJ0Br6lNMejH7yGn976DPV6is9951rsWsIdN75I77MRB9+/A/feAoP/3eSj+6+lvFki9+VYCjJ02HVqD3cz8EWLoXulnj0PrMku8aW/uoWFx/sYfudpbvyFZ2mMxgQlB2ElfPPwRXz5M9dz07ufpXgixC2DiMFsxYS3VJj7x2EWt7lMfGkNi383TK1fcu7pYc793iaWWhkyYwY3v+V5ul5MMALF2fcJsraPtS+zeuDB11/YhX/3Cs0uSeotMzR+s8p7b3iYKCUJcnD38H5sI6axwyPKWChTYVegska3JuZu99l4xXnmLrM1FubZQSa9Im3pFo0P9JPKeTjdTe79rVuwVzSGx3ksx7OfuAT7VQtkxwRem2TpPY2Xvb4v2PfffqQceLbYYlvXDItXxnTdOsnUuwJiV3Fx+yRKKsw3L1DfGHLFdcfwHunE+MN5Br+teOsVzzF3qcmRR9extMVk5+uO0uiFyBF8+/gW/KLAGw0I0wKRwGd3X03uHFz7i8+z7+tbyJSaMNgidgTHpnqY+sYwomHw4K9fx9I2ycpGQcdui7lrY0786UX85LVP0ug2OLncidduYlsRjUMlln6xQZyNaZUkKGjb7fLcwXU89/BWMhOC5V+sE2YMgt8uY4SKmWqeZmgTvX6Z/jedY+HKhNqgRMTQ97iifb8gv3OR4/UeFnbCWL2IlQuwapLU701jNhMu/cCLZMYli1dEfPfgZq7pPMvApyw+u/cKtr79KPE9ixz84E5G/vg44Ud7Gf6CBAHGn3Qw8HBE0Wlx1S2HqW2OWNylqA0ZeFfX2Vha4A13PM13du/kvg/fgPWFEqV7xtn3Ka1HnpqVnLvLpd4rccZsOtwm9+x6jvp4ntJ/y/DsF3dg1xKGvpOwa2QS//3L9DybEBVinIpi/lKD8bsTXvj0Dqqni+SuWWDqvhFUIriy4zyJnTD6G8fJddeJMwlzjRypeXj0xa2UtwjcckzhTIi4pMLA39kUziUYPnS9egKzr0l1FI6Ve+h5ISLMQHXUorHTI3YkQWdE9/MRXzxxMXePHmD602tovXWZwqYyM+/zOf0zEuu3Zglig5WPDpGag1Mf/h8Fnf71Zrgxl3eMYzUUcz/r0fNplxUvxeTN0PdUSOFsyPwuE7sGnQcC4pkU1bUJ7UcCbt5ynBc+vYOt15yh7YMTfPHsxZx5p0Hh4gVqr67jFyTymhXcWclzp0Y59lvbWLm9Sd93BUkkWbwixisJrn7dAQYe8zm10Mldaw+x9bcOQafPjj/dj5pOoXIRQzunuO62AxTyTfyCpDWWw30my7nFdvo/YeNUIkyZUBtVlN/U4OybTPyCJCjAwD9afPqpa/jY4zdyTc854p9bov5IF4c/u4Vv3XcFjc/20bN9jqu6zjPxYj9LO2N6n4QtbbOcv1OiDMHcC73E93eSvXWOzDQ4FcX+L25l6SLJs+U1tBUaRKWI9FzA/ft3MPETIZU1DgM/e4bElqiyg9cXkVhw6LH1fOPUVjr3B0z9REjh18bp+rlzmB58/dldvOYXnqD9uhkOjPdz34ltFI4bLG0ykWZC//0msQNPzKwl/ZtTyBA23nwG8wNzxHsLrGyPcJcVQR4q6wWxC/1XTnLujZKFQ5287iee5BsPXY5Vj1ncajLwGZvhzDJBURGlJc11AcWDBtWVNLEDa/NLeF/vYjHMEqUk19+1l6Uwx5nnhnnTRXtZ+IUmZjri+rftITOlcMqgAoOxB0bxS4qbb3+RsBjz+LENtL7aQ2IJuj/mEp3LsvhTDaJXVtj6/kP0vGEMs6W4qf8kYRbseoJ7b+HlH+D/nP0f6IH//9F+5HrgN37qDUzdN0J1cwSR4ObLDvPUN3Zw2W1HeOHbW8mfU1zxy1pNbbJRwPurPqx6THmzTXVLRKarQby/QJhTOIsaAW34giiT8IrLj3Hwc1sBuOwdB3jk2W1kz0n67hpjR9sUoTK495lLSc0aJDtrBE0L55SL1x/hzJmkZ6DZC5lJ8O+owDMFWv0JdlnSuT8iyBusrBdkJyA7FdLsMlm4PmT0c3D2zYKup03W/NxJetwKj/395aTumGf+eCepacGlbzjM48fXk9vv0P7qKabKbXQXq0wf6kH0tRDn0xqdPA3Naxp0fDWF/45lso6P+u/dzF9sYHhgeGA1wakkrHnfcfY8uAV3CQrnIoKcwfIGQWYG+t92lrlPjlIbFnQeiGh2GDReU6NVc+h50IZ3LNB4qIur3rqfB49t5rK1Y7z4/Ho698KVv/ICXz+2jdShFO4iVG5pkN6dIT8eM3+JQe/TISJW+CUT92ensY0YUyQ0I4uJxSLFb6Xx2wR+CToOxMxcqwF4Q284y3iljZ1d0zz1xFbyZwW5yYiVn6tx29AxvvO3V5N9zSx9mSpHHtiAX1KkpwW1jTEiEAw8kjB+p2J0ZJ6J/X0M7pzm3FgXIhYMflPQ7NBI26VdMf3rF5g63cnGLZOUm2maj3VSX68xK+kxE6sOpWMB7f95jPFPrmPh8oSx9/z6y+q/OUOD6ubPvJ6Zz44SFNAiQaWAtucdYhtKx0PmL7ZorQ9AKHq6KpTraZJYkH0iQ9AGzjKkFhO2/8Z+jv3eNhZ3WJSOx6AUhpcw9vYElm3aDwj8vMCpKKp3NNjYNc/Kh4YZf02CO6370b27Q/xfXqb6eBfRJXX6PukQu5LFdzZoy7SYOdUJuZCeB23633uaqY+sY/QXj/P8U5uIMwkDD0OUklSHBO4ShDmo7/IQSzbWQAN1LEfhjCJMC/LjEXOXmbgLEKW0zGuqHCMSUBLmdxlcccsRyn6aNdkl9v3xLpbfVcd8pEBtXULxsGTpFT5d37WJ3lzmmp5zPPD0xYgOn+wLKRqXt+j9kk1l1KBwPmbuMoO+pyN6/tMZTnxuI4kFla0hzqxFlFaoTh9j2iXqDEEqMsdsorRGcocDPpmjDp03TzHzTD+584rud53nyFgfXQ/bDL77NBJF0W5y5E+2M/WaCKRi9DOCc3cbtA8t05Wpc2LvMOZgg+uGz7D/r7fTuqtKEJiELZPcfgcB3PquZ/nynkvoesrEuWcWKRRr84s89txFuPOS8KIGSSxxD6XYcdcxnn96E6XDUB8UtHpiBjbMkzJDAMqfHSJ2tPpdZgoysxFtvzpO9b8Ocf71CqNuMLB1Fu9TvQRvXqbecIgDA2klqERw7m3/a5Wzl2P5TL+6cuu7vy+v9dALv/9j1QP/kcrA7WU4/cwIhXMxN+w8itGQ2DKieNUcK0EKEUFtUPDQ1y7l5Eonrb/upzJqUFlr0+yF7icNGpM5dr3qGJ0vKuwqmEMNwkLMq67ez55vbKXn7jHMFrwwO4hVkbg3L9D6836+fOhiHvrcFQx/IyExofsfUmT3uiDg5ouPYK+AXVPccMdeKjc2uahrlk2vPYVdlngjAW2/Ok6jR6A267JgebNFkBfYmYDaoMXQ1wUL1wccmOnjQLmf5KYVoi91suPSM7R6FEf/eis71kzS6oHJF/uRxzNsapun7big9O0UfU9HOGWo7AjhTIaZ20Pcfygydr6T9H+cxGxAZlohrl+m2QUzt8Tsm+knMwXcXGb87oTZVwUaGHRjg0rgYnq6VbGyxsSpKgpfydH7bYswJZg9045Vg4NLfWwenuHU5zYgejwWLoZZr8DNG04QpSF2wNmXweuAiVcnpGcgKBgEeZPyZsnS1wdY+eQQZS/NYj1L6vkMRgjNPsWmG86gpGDzrvOkbp9noZnFvL/Eib/YogFFbSDfN8eOrmm+/pWriR2YW85xZqWd7JQuoZs+OPMGlAIWdpls3zBB9Fc9dO1RzD3ej7Vg0dZXZWWNwfKNLeq31zAbkujT3bhzBqemu2h9t5OBO8YoHDURCkrHExqDig1/fJTxShtLt3iU9r98mo3hxBwZ66PRD8EVdTbuGgM0OMpqwvRPBnibPLq+a5E54uCaIYOlZQY7lsm+bob2wxE7f/IgiSU4/MEdlLdYNPsSJt8QMvTbJ6mstXHOuFx3xVFaHYL6xR6Z2Yi0GzD5+TU0OwyMdMSaV54n6IiZeHvEYiVD4fo54vMZyu+tM32tZKi0zIa2BZD6Gq//paPsOTZC9y+c5VylHSRYHR6jv3Gc9b90lPV3nEEkUDoRoUJJekLS/fcpsuOwskGgDBi/TeB3xPS8YYwwD40BaHYazF1qEL97kb6rphj/ww2M3zfKgQ/sZOkig8ZMltiF3s3zBDmQSzbuO2boztY4+Ps7uf2afcQNi+r6mCQWVEYM4msrtP/KeYwWrPnPR3nxyY2sbI2prUnIdjRRGxqYLUF2v0sy2MIteBhuRGNTQG5c0XXpLMNfkGQnFTtKUwRtCa1OQZAYGHM26q2LnP/79eydGODhZ7Yzf7Hkmk2ncU87TN5g0/mcZGkuz8TXR0jNCIz9WTKGT2opRj5ZIP1kBiEVW950gsxMwlOza+juX2F5s2BT2zyV+/s4+pfbuOuaPTSHQ5x9GdxUgNet2H1oPT3b5/CKgjAL+cEqSgnOHBxgbKmE1w7uisJowdafOsLCDpMz31nD/C4T0TKwViTV+/oQCi7tniCZSdPZUcPdn9Zythfs351dALFdsAt2wS7YBfuhmeDHc5b398N+pEro7Zs71es//WqOfGgbiSFI/9QUjX/op/LaOtlv5WjeUWWotEz9wwMsbzIovnKW5O+6AA0uqb+9gv21NpQQrNzUIg4l0ky4YvQ8z+3ehNkSXH/rfh56djs9z8D8XT5R3WJwZIHkE92srNfAEacMW157koOPbCBY45EvNKks5BBWjGqa2CWPvmKF6ZUCzu4sfgmuueUgiZIc/ehWFq6MsZZMolwCCuwVid8dQSzIndZ8cpHAwHtO8+LBNYhI0PW8IHIFa37yJHvHB9k+qAWEjs930VxKk5owKR1PWNwu6d4TM/H6GBLIHrGpbQrZsn6K4+M9ZA66mE1Y2RpjrRiEvQGFfTYdr5tguZWmPJcn197AD02CxRTZMwaZWcXSNjA8QffV07Q+28viLoXs8mh7JE1lvSJOKUoHJVEK7NsWqD3fiXNJmfwn9cCeRrdJeVdM5rxBYulqQKtTkJ1WrKwXGB6EWT18BQHurjKtgyW2XX+KPUdHMasG5kidYqaF8Yl2lt7WJJPyKS9l2TI0w8znRknPx4RZyeJOSCyFvSJJLFh39XkSJZj78jC9bz5P+ZPD2NWY6ohJdjKGdy/QvLeHnT91kMdObqDvPpuO953j6EwPm3rmKHtp0lbAyj8MUh0VdO2Lmbg7Qi7ZmA1BlFXk1y1z4DV//LLKd+n1fWrTTb9O+Qpd8lSxwGgYWFWBvQIdr55k7pEBmv0xzpKBiGD9zWc5+dgaOq6cZSBb4chXN5IfS0gsqL25RubePMubBPkdixhfaKfy2jpdn04z8dqYQkedxrEi6RlBkIOgTWFXBdauFVJ2iPpiB/UBQWuDT3G3Q+RCdjYhcgVmS2nRovVa/9s4kSHa0OS6Nad59PmLsCsSsw7K1CIldg0q6xWFU4LaKxs4L2ZoDibs3HWWvcdGMLMhzuEU7YcjGt0m8Z1lwmdKeJ2KK646zu59GxC5kOx+l+DqGvGZLFF3QH/vMpNjHXQPLLNwuh3lJOSOmdR2+eT2ObgrChlpkZRWt8Id0UOAsuMQuzDwhnOMrxRpeRbJVBpzqMFwe5mlLw5h1RVz18YIX6IKEVesP8exL20kyIO3JmDXunHOfX4dQR7UZVXYm+ei209yfLGLobZlVvwUHakGp5c6SN2fZ2mXPmtvuvIQ+z+6HSUE5R1agqzzBYFf0MOIEkPQfc95zj88gkig2R9jNCVmUxCs8RBS0XOvQ31Akp5LWLjLQ82kuOaqozzz1BacsqA5FGM0JHF7iD1p03flFDOVPJ2fSbOwyyDMKYpHBc0eUDtrcCjHZbcd4cAXt5K/Y4aZpQLrehYwRULWCnju4DrGfuHltYj+V1bI9KkrN/9rFU//5/bgi39woYT+79XqTZcXPrWDmesTZKSY2DOAkuBXHZauDlnXscjpmS7m3uzRf/M4yd92se59x5i7XJBYAj80Wbw4oXTPOENdS1C1MM6nGP+zDXQcgCibUAlTdK9fpPQLY1gnUnT1LzN5qovpGxTFEwndF8+y7s4zTH9oLfHGBqphEj1VQroRYtEh1dkk82iW8YN9iKNZ0vO6ZPX02Bpe/PJFdP3kea7ZcZKRq8ZRAvqegItuOkVqwkTEAqsBYUbgtwlOLXXQOVymY6/AedcMKxsUe59ZT/aZFIeeWkfW9ImP5blu2wnS87B0kcRZBj8v6XjCQi5byBjcosfMl0fIP++y9fUncCoKMjHFE4r+b5g0BhRjCyVqB9rJHbZw7i8ghSLdXSfIg9lMKB2G7qun8T7VixHAxZecQc25LF4RUjoCm7aPs3xDi/qgYmGhgNcbUZnJM32dwew9PgAiFKx7zRmSXTX8omDNq8+iJARFDTBDgN8VY9Yh3F0izCWc//v1FA+YbLr0PGs6lpidLoIQJEdzLM4UMGYcaqHD8taEmbf4LNzmYVUFl196Cn/Ep+NAwlSlwMR3hglvqTD2nRHyPz3BxB2QnYxZ2mZgSK2f/8ST2xjsKTN5W8xEtY1kIs3ZB9Ywt5yj+jeDNLsE8aYGUzcIiCRJW6j1CPobVJbTL3t9x75BZZ2i/xuS1FmLtsMmqVmBuwDZ6YSJPQN4nYrO0TIbrj9LsLFFm93CqsJCNcu5SokoA3OXC8K3l4ljSaskEOvqrBxtR75tgfhUDiUhfcomZUXYK4Luu8bJTMPA9hk6DsZs6Zyj4dssXB+y6bbTdHZU8W+tYHqwtFVi1RXWz86SeecUfVdOEbUsog1NorrFi5/fDqYiyig2vvo0uasXaGz1SUxIjVZp3lRDSoURQO8TcGDPWuxFk7hm4XUoaoMm0WuW6cnV8HoSjIEmpz++iWsvPg5A5pZ52u7NMnDxNP29y9hGRPfAMkuHO2g7KikcMkkc6OqsctGbjxHkBEO/cIrGZp+2YwLxXIHced3aGXrjWY4eHCaKJZYVI0NBNJVGCkX/286yskHQdsgkf0oiKibHP78R59YFiqcSUqdtJv52LfXrGrSdSWgtpnFW4HylSPNUgdOPjTJzuJujT67FeKxAfUiQGZf0PgEPv3gRy5s1dcqqSvInJSsbBLV1Cc5b5li6PMQUCUM3jTF66znMqkHbCUF6FkqPuciJFNOvhPqgYmmbZEvfLLlzgmfOjxJnEhprQ4yG5OprjrJ5dJq1157HMmKGSsvUBnSrp/dpxdJVIfnzivhkDmvXCrsf20rjiiat0CJumRw/3cfRg8PsGR8kc/4HrMR2AcT2b7IfqQz8eyCfM4sdePN6ctSlF59m/xMbkBtqSKEYaS9z8vlhOg7q58xdG5M/ZtL72jFmvzJMcvMKmS8VMH9ylmrLRT1aRJka/LN0dYg7ZuENh/R926D4H8Yof3SYmWugcEJSet0k5073MLBmgYVqlqHSMmPPDGG0oO3aOSwjpnpvH96NNYrZJs1vdlNZn5AZl6y78wyH9o7SdlRSG4G2kwrx5kU603WO7R8mMSAzUKO+mEZEEtIRctGm4wAkBog3LlJrubhOiPWVos4oNvikTjl4XQlWRZKdgPybpnDMiBPHBuh8ThI7OqoHGPiF0+wfH0DNudjLAhlpcRXDg+57zrPwqWHKF0FmTYVNHfNESuLFJhMPjBDmwF2ADW89yYvPraf9ECxcmpCeNPC6FLsuP40XmRw+OUhpr0nl2hbm2RSpeeCWMl5gkf1WjpWbWqT2pmj2KorHBMbdC9Sf6CQzoyjf1iIJJV3fcZi/XFE6JFnaGVM4YdDq0nrJsQ1RPsZs93CciMZUFnvZIH9WYXqKuauAYkD6sIsMwF1WxG8s03ixHbWljvt0luouHxVInFkLsblGdC6LDARWHaJddYKWhWHHyHNp0heVqR8vIoebbOieZ+K+URTQGEkonJC45YTljRKvJ37ZIDZ3YFCte9v7cZcUy7e26HggpcedvmuGqYUiasbFqgvijQ3Cuk2xu0b0eIlWjyJ3TlBdp8itXSZ6qoSzAuVdMZdtO8PhuR5sK8IPLNZ3LnBsppvBjmU9SvRZKL++iTiaxe/Wf3/w4Q2YDWhu9+juqJJzPMqtNCuVDFHDpNhTQ95fwm4ogreV4WvtVG5oYVgxue9kybxlmoljPaRmJNHFWsLUfi5LfW1M/9oFqt/uobYhJnfSIHYh84oFYiXpzNSZeGiY/LXzLD/fRfbSRXK2z/mJTty8j1d1KD1nU7uxQeQbjPQtMr5QYkPvPFP3jlBbm9B2TGoMQTFGRIL8GUnr2jrReIaNl4xx4sVhlKXoek6Q/5kJTk91USw2WDlRQkbQs2uWyVNdIMEseogzGfJnwSuB36Ew6wIZQ3JxjTAwkUaCvSeDSKC+LUDIhPRhF7uqAa0yhCCvSM8KkmsrNFZSiKpJYc0KSoFtxCws5kEJEIqB3jLd6Tr7n9V0QsMXxGtaXDQwzcGxfsS8w/qLxzl5aBAUmD0t1NkMma1lgue1bHLhTMLMK4BMBIai/UmHlQ2r1ZU6uLcukLYCOlMNXjg9jLFo4ywJ0nOKxWsi7CkLvyfCWjLpPJAwdyVkRqocfu0f/uAy8E0/9315rQf3/mA+479Xu9ADv2AX7IJdsAv2wzMFfP+GmfxY2Y9UCR2hmPn8KOpIjp7RJVQ+Yu/4ILGjSDkhan+e5Y8Pk/T4rLyuztwNEW19VcIMLHx+mMqmmEbDYWWdoP61XpInijSvaNLc1cIvQulZi+yEInfEYmGX5NjeEWbvCEhPSSqbY86d6YFUTOPeXqLzWea+NoTZAGcF/K90s1DN0uyB4fYy5ee66XrdOO0HJI2hhJMPrsVelqxsVhSPKxp3VXGtkFNPjNK1cZFt28/D7gKb1k1rdG8kMYcaBFnB4iUJ1T2ddBVqGDKhckcDEYNYsRi5+TxJKiaxwGwpZp/oZ7aWw1oxaHaLlzI4cc8CY3+zDsuOECH0XjdJuKNBdGOF5es8jh0fYGmHIndeUEi3eGHfOsarbRw7PoD5yjLh2hbNPjhZ7qB0GLw2QX6wSmoBZCA4OtfNkTMDyJYkzECxraH72QoaR0us61hE3r2A4wYYPpRWdU+WDnfQ3BgAENVs3BMu9QGBVZWU3jaOchISA9hUJ3deEfUE2GWD3OMZ1AsFCkMVnGXofNcYy5skxUMSIRSNDSHpBYXfJujO1hi6dpyUE8ANyxSKDQpHLOK1LTIP5dhw2Rj2lgr58wnGwSwbh2bZ0DtP2B0SRgbrLhsnk/aphQ6dd07QHFAkjmJ5R0SzS5KZhszYyy8xKkvR3NnCbxO0PZxGvH2BuRsiDJGQ2psif0ZQvHyeyLMwqiYrYwValzRJr6tQXadwFwThsyUaQzFWU7dAXjw/SLOconaqSHwyRzOyiOdSuv2UjQkzkig0cBeBVMRCS4uIhHmwUyHzSznGFksoJfTakWDIhPqtdeauVJSnCvS//Sy2E6JOZll6hc/4eCf50xoPYb2Qpfi1DIVbZ7E7Wiw91UNtTULbYQPTg/x183Rl6pTH2jh+po/EgtnTHXi9EfU9HVS/3I9Rtsh+M4tKBMvXeKR2ZxjpW6R83wC5p9LM1XPk7phFdvisbNa4ks4XJKWDEmdZUbo3Q9vGMgufGsauCPIjKyzd2cSUCR2lGt7T7fReNIe9LJiaLbJ56wQiE9JTqtJ2ShHmoLEmZv0VY6y96RzB9gb2UzmSWGAezNB+6zQihtRpG5UImgMJpTdNkJkErzNh5JJJ8q+aJThaIHvYput5wfJMntb+Et5DnXQ+amNN25SecSh/t5cXTw9h1QRWXRDmEhCKZmTR/S0Huj3OPz5M4iaoXET+oQwygujpEoWzivSMbm/IUNDfX0aWbVp3VEjNC/yOhP7Xnaf6bCfVL/XzwqG1uGccDE/gXrNEebui+IKF3FLDKXpEpYjGT1TofEFQr7ove33/cyaU+r78/LjZj5YDl7C8NcGqwvJzXRjzFvknUshA4D9XwmxCvVegIon5fI6evmWqp4qaCvXKFvaywdreBRITVrbEpOcVzqE0YtpFJFC+MmThmgjDh/Zd88TZmPwel8FXjWHW9AGdK7Ro9ENp8yLVjTF+uyLIad63/Wgew4cT53vJn1NMLrfRuqNC55olEgvE9irtGxa1tnimxeIj+sCqPtHFxBfXEOZg+uvD2HMm6WIT1w6J0mA2JFYVyt/uo/V0B/F4huaGALMhOXauD2EnRNmY+asTwi1NKuUsYl2dMA8yVIyf6Gb+RAfFd0zgPpoj6fGpfHGAtmwT9UIBw4pJTZpYVYlx6xLNf+zFaPcppZqUXjRZmdYa0fbmCtHTJcw3L5C6dYFmy6Y2DIXTYD+eJ3XWAgFBAbzAwu9ISGyIUwlHTgwSfKeTrBtgVxUrtzYpb0soHoPiczaVdYLCURO/MyG8pI6zbYWplQKZcxZcv0JQdWh1CowlC7sCye1l7BWonW2jNpqw2MgQrPFodYOcSOFMWFRfX8O8eYnzSyVW/mGQ+PESwZ4ilXKG2mhCsuDgvarC+DdHaFRSrKyXtNb5zN47zOR9IxT2WWTvzXNivIeMHTC7u484kbRvWQQnpndkCbMFKzc1ca9bfNnL22gK2h5PIW8o0/H2MSpPdWFmAqaeHaCx3aPxygYpK2Ckf4HiUYEMJK4b0pGt07a+THNDQFBQiHxIs0tgmTGpTEDnbhNlKqJswtRyG0pC2BGS76jT6gI3FVDZHNPxuI0XWYQ5RZRLcJ/IEbdMgqUUXmCSejiHOW9hfKEdv+Kg7ARrySRIDJzv5hEb6qROO9CS1EYVyoTG2ojlTYLlx3oIZ9PELpAPSUwoXxIyO1fgzHdHMRqSwaFF3EWQkSB30kQJcO6eo3BSoKQgc8ZCJZLEhPpn+pExdL9xjJQVMjnWgXMohVXReyW4e5ny9oSlbbD02ib1psPSDT7eGh/x7RLGiQynnx4h6/jIEOoP9OBUwD3pMnn/CCzbTIx10HxtFXlTmexpg/FvjXD68VGyGZ/6sMIcd/FLivFT3RTumAHAGXPInZWMPT9IUACrIql6LsuP9iDW16mvjakP6N56sqGBjHUwnJmCyvVNWls8nPOOntQWgFWTrOleZOqhIY1nmHGJNrQwmhJ72qb8Sk+LQt04S7NTUBsWjI11ojp9Zg91M3TRNCknpPSqaYzeFhNfH8EbDilfEiGbktQCBH0B4t52cmckyzsjOJAjHsvQudvAubeN2IbB3vLLXt8X7PtvP1IOXPqC/k1zBAUwd1RQfR71QYjTCfH2OtFVNbI3z9PWWUddWWFhOYe9onmmlhMR9IWcOTBI7CrMqsH8FQmxA707ZrHqIN2IzGmL5V0hs2faEZGAm8ucODyIXFOnuN/ED0zsZZifaaNw3MCqCISCnOsTZfSmE0ZCo08QhgbNuaz+8ApaFZfk3k7C1y3TvLcH9xVLhB0hsQvNPjCb0OxVBJ0x8ukCUSypbYgonNQqTvUNEfHFNYymdmTuIljpEHvCwe1p0jlUJvZNRMUkKLtkx8FfzZRVKWDi0SFWLvexUlp9zLEi3CWIA4PspCJe12T5bJFWFziHUszeP0T9ljqFQyYqkrgPFKivC1lYyTI31UbkmVgNqN1ap7IzgIur2GVJUIoJDxfIn5QYPrgDdbASuLnM/HiRyqsbJLMpRKKRt8vbYoIhn6AA+ZOSYDGF/UAbcSLxtzWxv96GO26RuX4BEt1XrJ8osrJDI/exEqotl/xzru63ViAoJXiTWZrPt+Ofz1G7s47QyQz2pEN6qEbhpEQ8W8BdAjsTYLSg/UmHynrN85YRzF+d4Jx3qDzUQ3oOpl7oJ7qvE8ONqX5XT4zLZjwWZ16+UpUS4LxhDtuImf/iMH5nQvaJDLlzUHzSJZ9tsfiNAWpf7Md7dYX8GYH5aIHlrw6QdXwG+paIXYV70sXwIYwM2F0gMQXZc5LseYnftHDnJSKQRLFECfBP52nfa7C0S+FFJkl7QJKLqa5NMKomQ+vmaNU1Ct2uaZEQIQAnwfDgxNk+qusU1gtZCtfM0/GipO2YQEkoHDaxV8Db2qK0tkzsKlKnHPwSOLMWsmzjLENmShONgwJYVUHqhgUKlywwc66D8I4VVm5qknnFAtnDNs4NiwQ5gXPXPGeeHWa5kaKtp4rha1lVGUPtdJHCSan7vlZE9uEs+UITWbapvaJFuK5FbhzG9/VT2xRieFBdo5Ah1LbpipBb9GjMZqk3HFq9ivraSLeqv1Eif1pQ3LWAXdUDeyZnSvgdCf5gQLNXkdlaRkQQtMckCJrDMUHLomOPpL42InIh91hGr9e67rHbh7UYU2IBaxuk55SWyX1mCK9DIRQUj0FnsUbSFlG6ZB7TjkktwvTxLi18dNUssmlgnXeRgWBspp3ymRKzK3nST2Zoe9UMmeMWIpC0nRQaQZ8IGgMQ3lDBXjAJN7fo3LpAmBYEWcHKJpje0/ey1/c/v/gvgNj+LfYj5cBJxyw/3EvQHSGeKqCWHKJsgtXbJDmThYM55o92kjxSIk4kcc0i2tIg2t4g9EwQivSUwBhpYG+skD1nYDagdn8vCEjvS9HcENDVu4JIBNmzBo0jJXLnJM7uLJED8fkM0VU1jJpJZVOMVYMoDdWWg1XXghvZvS5ehyIODYhhaTlL6co5enpXaN1RoXa2jeoaRXm8jdSkpQfab6rR2uJhtASZHj1a0/ds2g6aeCVorffJnjLxl1IkFhgtocvmZkzQERGfzLFSTyNXTFQ2xqgaLF/rIUNQjxaxUhFWDYRQBA2L2vqY5Yd64c4l0kdc6nfWiBoWylCEFzWI0hC+okbuwSxepw5ulrcqMmcsjDNpCl113LMOjU0B4WwauWwRnNVypqneBnJzjfqQ0ujjB/NYmZCV2Ty5Hi1kY/Y1SY1UsRr6vmYP6ayj2QOp7gZLr/Bx7ZAklFTWayBfw7eJ2yPMW5ZwlgTFfSZJOoFQYryY0wIidUDqYC8zIZEBxLkYr+aQ2OhDtjukvqBLxX4J5N0LqETA1RViB3LnJIYnaHVBz8gShcsWqG8NiC0dZNVuamA7IVYdEhOqK2nM8suHk6hMwsxsG7VnO/V424pE3rHE0iUxlRubLI0Xqe/yWN6qaDVtDB8qm2O8dhg/3kPlm73Y/Q1aawJaXbrKY1yzTPmqgPolHn4ReroqeGsC2vcapL5ZwGyCiAW1UaAYUD9SQpdRJJ3rl0jPCOaf6iN11MXr/F6QmSDsmPwBG7sKomEQZ2IaayLKe7pY3gorm7WUZ5iF+pYQ83yK8ukS+Q3L+EWFPxiQmKA6fa22JmDxqV6aG33E1hpLxzuovtCJbEpcKyTzXJrogU6iK2tIFLW1CWEiifs9TCNBfKdEbUOEMqC2PcAZruF1QKsvxnmwwMpmhfh2ifz6ZZyDKUw7pnZjg/T6CiKUGK9bIH9WKzPakzZWbxN1PEf/mgU4nyE7Jmh/wURG0OiHyhUe0b2diAhKa8ukTjrkT2kZ4vwZQf14kdStCyhLoe7vwGjzkWWb6oigcETL4Vp3LdDoh9YdFby1Pq2BmLanXaIhj/Z8g9qQDtxFDMVjej2GWcFiJQOepPFQF9JIqGyJMLpb+J0x5Sd79B7OJ/reLjkkbkLKCahc6lP/Wi+mB86SpDakXzt/2MLribEfKSAjyD2VYna+gFDgdaITnvW1l72+/5mVf8GB/xvtR8uBX7ALdsEu2AW7YBcM+BFz4KplEGVA+JIwD6nBGioX4TohzjK0hkLsitDgqSM53CkTlUiMoxmSFZvcIZvmQII8kiU6XEAkuuQtIwjTYL6yTOa4TawkZl2iDEhvWabVrajt9KltiHEXBJmU5jXbiwZWS09E8k/nCQpQXafwr6mTGq2SeAayLSBfaDFztoMgNmBPgeL6MvmzArujRWJC9rJFbDMmt8clvatMvK9AUATbCWkM6LJv2/MO/mUNMqdNLfG4Y5n62gj25mk7aNK2YwFrXwarIinusTB8gTnukty0QmJBULOpbQsRSw7tnTWUnaBMCB5rJ33dAsGZHNmTFiISOE6EkmA8l6N2ax2/I8Y+55Jbt0yrL8FdhGbLximDM2ajCiHWsB4q4nVCazGNV7dxlwRRBhq94D6bId3epD6WJ5zRpcJ4f4HazQ2MJYv6aIy5sQqb6/hjOWiaVFfSZPe7ZCbB2b5Cq2HjFDy8Z9qxri7T6APZkjhlidmC2rAiSkFzXUDUFtEcSBBXVAAwFi1aPYrE0KXR7BmT6joNRls62YE4kcGxdGshSoG7dYWgTdF4qIvFcpbUGRv7lkWCvEIIRdbVfdB4bQuWbWT48rUmZV1C3cTri/E6FWEhIVGC3CkD50CaXG8NseQgYmhvq7O0M8aoSZzLypCLqI8mJLFERZIwq6g81EN1JocKpdYfr8P8oS7kiqXpeHeVSWwwAohSisQzSM2Cc97GrBiUD2r9d68vItylp1FV18ekZiWUbaprExr9CmdB0tZTxW73MDxIbIU7XNVZZg3MjC5Jy1CwMpXHXRBYmVBPEsz6hGmwbl5CJJA57KAO5xAxxClNj1s63kFtNKGyTiH25ajs7SQzJqm/0IGq2AQvFqlsSFASIhdoGMRH8zjLkO+voiSodp/aiCJ8qkTq2kVST2YJWxb1sTylwRVqz3eysikhu2EZublGcjaLWYeZo90YHjRf0SB2NeXSrkCx1KByYxMElE+XMDz93m0ddZYuD3HKgvKhDoQvWdmkYCqF6vDJXryEuKlMqxPm5/MkqYTwWEHL/lYl9SEwrJhyLY1QkLlkiTCrOdt2Ra/NeD6FUTNIDAgnM+SPmzh7M+ROGfibW8hAkh9dgV1VlFRIN6J6rg0VSipXeNi3LWDWwWxpamZtR0DupEGzB1r9ESvbYowFm5VNCV5fiOzUEwp/YKa4kIH/G+1HyoHLdEyYV4h2n7CQYDxVQDox1dkcMoLUuEVrKITbyoQ5pQFUnkFrMES2BVS3hsieFlYNgmGfZr/Wcm7cWKdxaYvgmRKJBeXxNqw6NLd6JE8WyY4LVCDJnDNoDib4j3aQGa1g1aA6ogVg0jOC1iYPa7CO9UIW47EC6fMWLDo0PRtSMd5T7ahLqjR3dxA7II5lSdY3iL7TgXqqjSgDy3M5vK6YMKuwH81rbnIGKpsSgopDa2cLOZnC31ckc9bEvqJMbY1ipZ6mORrh9YX4RUjN6cBEPNaG3w40THJHLOJMzPJKhkx7k9ZmjzAHlRc7sRqCKA3KUPBMgaArxLqujHEgC4bCL2meR3pCIkNwnEj3MXct42YClBKInAYnCU9iODEi0oIZiQ2tLvDHc6SHauTOSYKGjV9KkMcyiFAr0NlWRFCzocsjd9ogfdilPpzQ6Af5SBvp/SlSTkhjTUjtdJF4XYvE0ahjJSF3TuDvaJI6a+NOW6RmJOqFAmZWO4vE0jzh+HQOv6TIrlnBqgqyY4KgPWbldJEoC8HWFvGzbdjLgsagIvFNwix4T3SQnhaIo1kqL3YifYFzKIXRksTDrZe9vpNcQmbcgEjoXvGMpLKcxrixjL+9RZwI7BWB0RQE3+7EXjGICzH140WIBemhGqYZU+ytEucj6hf5mMsmmfMmVkXS7EuIihGpacHKJSFeYNHYHGgVwB4Po2biX13H2bWskc25GJkJSY2biBMZhIL0lG47WTUJmQhlQpRVhJFB6vEsrcEIFAQnClSvbVHZEpNEekSnEpCa1K0G04zJrlkhPFJAXVWhPNZGeFGDMAdRRpGZEsR9Ps0+HcA6/VqjPNjaIugPqG0LEAm48xKvOybJaCCmUwbZFmDVoHZ5i2BvkZXLAoShQOqScRCatLrAcCIyE5Lq4Xb8tR7KVlQmCyRKEOVjWls8MhOC1DyYhzL4r6xhXKMD+pUTJWw7It5RJ3dW0hxQNAcUfLtEvqOBd1GLqC2mcEqSFEJSswI567B8pkjrgBbcoWlirUiMjTWsKYeoEJOYCseJkFLhjfqE321H9LUwFyxEDF67QvqCuCNEWZCalpg3L+nWzvaAJDQ08+NIiVbdwept6n07KZFOjGpYLEwWqV8UgNItJGPJojGckJoHo25glQ2skTqy08edtkgWHWprf8A8r+T79PNjZj9SDjyOJVZFkN6XIsnF1LYFmGdSpDqa1DZG2BVwpyxaL5ZQhsJZAnPOxpm2yOY8jKpJHGrxCPeMg1kX+FfVcZ7NklRsvE5FsquGO2fgdSjSh12U1OAWkQiUqfuFzZ0tGufzRFfUyExD7oyktj7GciOMvTkam/Xcb7WrRpJKMPdlsab1PF7ryTxRGhoDCncJUs9nqFysZ2E3B2Nk08Ds8IjzEZUtMbED/joPZSekJk2Sqgb9GD40N/tUz7VhVQXxdBp7zsSdtjA8WNkRIkPwrqkT5WKUkxCl9CQt+0QKgNyLLlFGYV5UoTUYYlche94guLSBnQ+oVlO01vtYRR/lJFRX0sgYKhv1TvG6YmqVFN6Mzl4tJ8JsgTIVYjxFdFUNs6l7aGFnCJ0e6rkC1Q0xuYM2IhaEeYXVAP+qOi3PxpyzSao2jQFN3zEbkrA9onZlS1dKnighfElSiEhiAZmIaGOT5mVNGgPAZOqlqWuNDSHNDT7JooPREmTPGXqi1ECLzJQgiiXBqEfsaMeUGq5hbq+gZlyaGwK8gQirKsCTyAiSy6s0Lm0RZRVRPsFZhuZIRGoWcs+nXvb6Fiia2zxk0Sc7Jokuq5E56FI9XUQpCI8XkCEkjg48o9EWdtEjziS4YxaN+QzhqTx+YCI8AxUYxGktq2r4oJwEe96iuc3DzAQkJ3NkjtrY7R5JYIBUOHZEdTGrqXuGQsyuCuIs6UD1e2AqqwbmggVdHmF7RGsiR3RThewpE3tZEvX6uPtTOAsGxliKsN/HGq4jLq7Q6k1gX55qOYO7bZlGOY3Ih1iQJA0UAABKfUlEQVSHMwSDATIUeNfUyeVbyFDTFMNzWUQMUd2isN9GxYJwUwuvNyY9aSB8idcf0eoB82yKMK8xLc4yqEggJ11EpHvKPN6G3x3CRIpmn8JZhsQzKRwzyJ4xMPdmIR2Rf8ElscBr19gKbzFFZT5LekagOn2SQ3ksM6Y+rEjNCHLnhKYWniogJ1IYuZBWJ+QP2HiXNohTet84y2Ctr2K0BQTFhDAwMTwwl03cRUGz5mA8lyNzzKG2Lsbdm8ZYV9NVq3SCMsCetPEvatHqUXhPtVMfUVA3KbxoYzaFfo9JR6tBHnKJU+CcclFmgtPeQpgJsQvBYIBZF6hSQKsTzIYgsRVxLGF6FRS6LMH4wWa3F2hk/zb7kXLgF+yCXbALdsEu2AXT9qPlwCM99KK+JtYRoVSEIx7JoTxGzaC6I8CqgrG9glWRBG0QD3gExYT4qSLSFyQtE+lDsLFFmFeYe7NUN0UgNHLZrzp4QyHmYIOgDZr9CcpSuNMmzZGIzITAGE9hL0u8ZZeVHSHBKoPI3Jel1Z2QPmWjTEVyPIdIa+GUsBAjI6hcFBI7CnO0TpTSZS9qJo2tPiIQmDWJcSJDqujhLGjuuTnhYlYMzCakpgwam31EDDRMjKaW8XSWBCIBfzAgSgFKELQp/BUHp7uJ8CXikorukYXQmsjRuLKJvSLwWjbWkkl9OKE+EiONhLDsklRtQCCEQpgJ0lT4RUBBsqcA2ZjUUZfUnKQ2l4UTWVqbPUQskIEgiiSt3oTESfRAiLJD7IJZNVAS7IrQaO91PvZzWcTRLFEpwqhLjczfXCPMJRqrMOnS7NbX2e1uYmUDVMNEGArjTBrjdJqoGBGnEsIrazTWhBipCBVp+pS9vkpjh6efnw5IJDTnM1jnXdQVFVo9CWFkEB0ooExFuq2FPW8S2+AsGgR9Aa26A3Mu6WlBkkpo9up10bisRW305Uf/SgksNyIJDGobIswXcsRXVUlNa9pWMtLC61DI0QbVyzyYdZGHszjdTZJtdWTDQEarlaqqRLYk2XOScFOT5nCksSNtMc4pF/tgBqesKUtB1UFaMc6CpDadw1ywUJYiNWESFSK8i5v4JUjyEdIXVDfFNIZinA1VksBAWIluVyjwunSGnj7hICNQm+vISP87Cky883nMhiS2gZZBdSJP/qiFiiStnhhz3iLsDgmaFtHuIsa2CmYDzKYgzCoyZ00ql/iIRGAfTZEe1xU1u6sFbgxCEbsKvyfEL0H9qibCM4h6AswGxNvr1DZGWIuWPv0UNNZE2AWf1rV1GkMJXqcit9+hui6hMarbBMEramRPmRSOWCgJ2X0uVh3C0IAuD29Xk9qIQkSC9JTAbEFcsQnaY5o9YB7JYDT1UJTa1hCvaZMsOKQnJdbxFGKHxgw0RmJULIky0OpNMKsGIgFv2aW6PUDkQ5JMjLGlSnpPisykIMrqzJl8SG1UEY22UKZmDPhdsaa3Rpp+mWlvoo5qXISMNIbFbOnvozY2cJY0pc/dncHw/gnX4cxf0EL/92g/Wg4caA5ojWNpxTjnHZTSm8XwBJljNq1uRWMpTWJpZ5Y54KLcGL9Dl6zNXECrR+EeTmHV9NQee8Eke8aA0QZO3sc9bxEspAiLMZlxicrEGJ4uP7e6ICxFhBtb2AsWRioidkFZCeHOBkkqIb64BqWAZF0DOePQ2BRitPvU1scYNZPETQimMygB0oxxFyR2JiQ1K0kchT/sE53K4fWHBP26V2XVBEEBmkMRckWXQe3Olua9FgLCjO7vuedtWj0JwlCIgSZWLiA6lyU9I2nOZjHPpvCLivS0xDmQpjkSIqZdos4QqyZxlgzkvhyZswZGTSKqJkHNQdRM0ntSiFiXyGUIqVM2SO0EhCcJhz3McRejJQiGfNw9GcyaxF4yEPkQVQgxmxo843XqzRZlEtyzDokD/qhP7oSJ6vNIbIX1bA4ZCLKnTKLOkKgnoLWjhTefJpxPYZVN5JyD4envbrX5OD1NwvEsdj4gLtvkjlnUd3r4Z/KwbBNeWaNZcwnawOlo6fK9b5GalRj7s/gdMbLTxzuX12XqPh+vL9Q9yIqFjKDVrZ1b0uPjtyfEDYvMxPdnYLK/7CJMDcgiAa9hE15WJ1lwSGKBPaRbPqkjLtZwHb89IQr14Wq0dO/ceTaLSFapQpsjooYFgUQowEnwevV6rm2ICHOQPmWRRJJWv55gJWKQg02tn7BoES85BKMetAw9dEaBvWygni9Ay8BOh3jbWvBCAbmmgb/OozkcEaUgCg2CUQ+/pIg9A9nXJOjSmASjTavqNS5pkT1sY1UNonwCviR90iG+tIbYXcDrShBba6TmBH6Hwh5zyJw28TZ6NPsTYlcRTWagahHlEsymwFqwsGpgHdNgMOUbqB014vMZsBNsjW0kycSYZZN4Ok04ncZoSZJMTFAEsy7BTnSwcTBHfVtAbENtY6gpapc0kUeysOhgnkwjejykJ2lc1sLriRHZ8KUg3OtKkJHAPWMjrJjUERdlKvxLGlp8Z0+eaFf9pb/3RwKcRUnc51FfG2PnA6Qdk93nQiRozWVITKitjZEB+MMBNExSc4LUgRQiWsXARIJkc+Ol8yEIVumOvkHs6HvZ2OzT6gZ1NkPQBtUNMY2RhHhtE5FAtF63r35gpoBEfX9+fszsR8uBrx4cIoGkbhG0JVhTDo0NGjwVpzXgRViKqNcHJaiP6MWvQUwQLznYFT3w3usPwdDOKLFACAjHs3hdCUZD4swb1LcGpM5ZKAGNNfrgUaYiqutMgQUHEen3DBdcrUw1nSF90CWeS2E1BGYm0CINMSRWglkzEKEgzIFhJcgQIl8j7FXvqhLTgEfmjAWegVhfx+tMNGrUSiAWuMddwuk0QVGRBIbuTw5EGC0gF4EviQODZCqNGGzS3BCQOW9oXrgJJBo9b6Yj4o4QJARtMcmmht602X+65qmzGhDmFyHa2MQoBvglDa5rrg2JHXDKEmPKJR5poYZa2OMOzT6dDZlNSFomxoKNf3ED6WvQWeyg5TxzisZoiDQTwizYJ1J6OMRFGu3f7FPIZQsVCZLAwFo2sKqSoCvUQiTtijCnMA5nCH1TZ++nMhjtPq1uhTXmErs6aOFIDhXoZe83bKK0FrLxtzXxuhLIxjDpah5+TwixQHgGYqQJbQFRWo9OTSx9eWQgsJYNmpc1X/7yDiR2wcdyI5x5k6ANhFT4FQd3QZI65hKdypEYEBQV0dmsDjxOp+FYFsPXmZhfhGDQJyglOLMmmTOWZlW0BziTFtaKQWKiM8Lhpr7XsdTXtSZgXQN1Pk1rKCTKxZgNiTn5T1KamTEDGejxoyIUyMNZktCgMRohjmaxz7rYCybeJo/EM0kCA8MTiJpJMpsie8pChgLjbEo72VMpzbqogDNnYDQk0c468WnN7TeaksAzaQzp4D1e18LvUBjTDtgJUVuM6vC1BHEmIjHRFZLBGK83xuppYqRDklhi1QVyxcLb1sJeEeAmhJ0hRktgNCUIhdXmE9tojnvNJOrzkZFmMjQ2hjgFX6/pUBIUFFZFC+IkC5ohICddSEcIofCHA+yaRnuj0D37Qy5eTwJuQlR2SVyNU4gmMvg9EfaUjYoE0bYG9lkXYoHzQgb7VAqvQ1+P9ISBt6uJiAXecIg5a+POGDS2+DQHEhqbAkSMfu0xHcQ01kWYxzJEa1oQg1rTIFjjkTnm6DOtzwcBxvfWyqE0RgukkeCXfvyc44+CXRhmcsEu2AW7YBfsh2g/nuXv74f90By4EGIQ+BTQjS6ifFwp9Rf/7HOURjQnju49BhtahG16eIW9YtEciSCle7ipQykawzHpaQPPT5O0B/jdMSy6eJ0JMhQ6mzXBH40BMMbTWE1BWFAaCdsbIZSWhAzbwKiZWgHNkYhQYNUkYT4hyircMzYyWkWStySNTSG0JLED9sGMpjjktPRnXAhRFQukRCS6GqASgYhWKwtrPeSMg0h0z5upLMH6gKY0kXYMaM1xlYswJ2yUaUIiSDJae1wuWSTpBDnvaNRqYCAM3duL0wnpCYPG5gBnwsY4kyIe9CERiFhgHM28VFpTlubuKgmtdbqERyIwz6QIBgKMVETqiC7DR7FAGQqxbEM2AldhVwReT0wzr0iPm4QXNVATaZrDMSIQuoy6ZOqsKLAAC68zASvBqBmYYw6xDWFnSGrMIgq1UlyUTaAUYMw7JJkYQql52ALE9GoJvyNG1Wzcpp7hzaKLt7NJ7GmEdpxSUDMJ2hJomMRVCwyFsWAR5xLMioGIBZmTuufZlC7Sl4huD7Xo4Pdoqk/UFpE5YxEFL38euEjA2qdHUzYGE4yWQCUCMxvSWpcgyzYy0MMyAFQhRFUc3fNc0tcifc7C60qwxx2CUky0oUk8nkINtUjvT9PYGKASgeFZGiciXeL2GHvKIigmJB0exskMMobYicGJifNonvK0gz8UEC1ZmE2h10yHRxC7SDMGKybaEKCmUy+VXGXNILH14axMhWgLaJYEqm7hzhqEOQg6Yoy2gCgBYzxF7CrsA1mCnoSwI8ZcMXGOpwjyiqgzBM/AGPR0pcSTiA6fJJS6/B3rNkfcqfvkqm4RLKUQ2ZBkPI3KKJwlQdiXEGaApoHIaJXC5mCMWTUI51OkK9AYjbDKJmFe7wGjKYiLEDQtjIuayKkUqsfDb5ekTjrIRYk38E+1ZjHj4jQFzWEtwWouSJQ0iFNgrUi8TIxIR5hzNkFRQZeHOZ7C7wlxpywM36K12UMKRbCS0tgTR2FVBX67QoylsSIwZySN0YgoL0iddAjzikiYRGkQhiLuDIlCqXvpa3zEkoPR5WEdypCUFEFBtyCjQOL3RBBI3FMuiQneYAxlF/mD9q8XHPi/yX6YGXgE/KpSaq8QIge8KIR4SCl19H/1BCUg7gqgahGsb6EWHShEqLpJczTCnjcJ2iSJULS2t8A38EsSZ1nQSpuIGQeRSXAXNC816VYYk66mqsTgdcYktkDZCrlK6zXnLRIToja9Ma2KSXrSIMzokjPpGDlr6/J1xdDzsVf7u2ZNl6wba0KkE+Oc1bS02FXE7SFUBebJNGEhwT3h4m30cM66IEyijMJv07xsEev+qnJjkrKDEWtBB3Pe1mCwZQkJBFg0hyOkJ1FmgggN3DmDqGKgLIXREojYoLnJR0VSazWv96BmQSrGWZR4owHpUzbNvgSzobXMY1fTVhJbkQx4unzcMogiiSopZGP19ZsG7oIgMXWJ1hvRTl8tOoQ5RTyXQmUT7AWDoF/PXm8NRKi+EOe4LpvHriCxIen2CRcdVIePYSi8PgkxyGKAnHFxjulBEiKQWCuSaG2LVs5EhBKramgd+0T3Bu2TGdItaJo27owekiFiELFB2BavYgwk8VCLGFtLUbaHuNMWrR0txLRLatrA2+jhHkuhJPjrA6zTKUwT/KIGbr1cU7bC29bSlK6mgeFL5KRLPNzCnNO0u3iohXVOy+lGpql518sOst0nfTxFqyfBrkj8vpD0OYvASxHlEozJFI0hHaia6YgoYxK2R2TO6l6AX1TaaS87mjEkwD7jEmU1MEuGuu2ROmPTHAmJXUMHwQLssqDVLhFSkVRt3BU9HyCKJZQCrAkXswHhUIiYckkyCfaSgb/OQ87p8m2y4GAvS8KcgnxIS5iYDUlka+57YoFIBM6EdtB+SZFkEkh0IEHDxGwIvLYIXyrknIuzIvD6Iox8iFp1fiobYXg2kWfBaptNSKXL/06MNWUQlhKijAQ3RgYmomrit+sb7J63kDG0Nnl6H3omQkBQUMSZBEyFOW+BMLUefV7hzJp4fSHeBg+x4BAMeTDvkpqw8Hpj1KBHUraRs7ov7sxoeeXmRh/nrItfSojWtEgqNs6CoVuBpRCE3odmw0CmIpyTLkJBWIwx6gZ+x6r4/yo8w50ySWyTYMjHOpqmtTbQQe+ihV0RpCYtgoJCGQq/PdHnSipGGAnm4g92GtkFB/5vsx9aD1wpNaOU2rv6ew04BvT/s08yFHgGqTmNaBaJwJi3wE1ITZgE7TGYCjIx1qkUKpLEjl4Y9oLmuYI+rMK8QlUt4nSCjMAb9XHnDb3YleZbSjciysX4vSE4WrDZ74xpbtS9IuRqj2zQwyyb2FWB15XgLApS5ywSW6EMzR0XCw5+R0wwGBAVI0TNJM7Guk+1GhyoSBJlFCiI8jFhe6QPwu4AuWzhTuveYdypwWBxn6cDEQuC9gSzIfQhVJHI1j99X8OH2FEEgwFKKtwzDtKO8db5q+h7CU0Db52PqJk0RiMwdXYZFhJ9KBQS4j4f63SKOJ3gLBo486Z+j2Kg743S4DS/PdFcZc/AOp3CXpFIXyASgQgEQVHzlv31nn6NeZcwo3XFE1cfgu4JF6TCmHZJahbKTPQ1n9X96eb6AGVo4FbQqcVCrCULZSf6e6EdorFgERYSmhsCUpMm3lCIP+rTGgoJ+31ELgQg7A2QEylkJEAoUpMWUUphntH87uZoiDnpvuT8VdNEJOgeYSQw6y8fxCYCgZhyEVUTZSfaAbTFmOdSRN0hYXtEEknilB5ygQQshQwELLj6wDYVUVrf99ZarUinrIS4M8RZNLQKW83C8ASpCYvGaKiDwaZAelIHPqvobASQQFTULA2zqR2SO62V/pSpME6nCDNgTzg4J3XvV5nQ6o+xpmwS3yDMJwSrWXycSfR+UOCe0NxsZ9bEaEmCtZ4Glc04WFWDsKQz11ZfjBIQ9fiEeUVzJMSqCZStHZR7woVMrEWETEVqRu9jkYBVNmHaRSUClYlxx2y8vtU5t76Be87GOe0iUxHUTZqjoRZ9QU8WAw10U4ZCSYXXlRDkVpkhq1UIQkFUjJCBRCV67yaOQsTgLAlkAKkJC5UIkmxMUrH1a40GSE9inkqBod9HBgK/OyIorlaGbH3uxQ2L1JShgWgDer/ZE9qhhzkQSzqLb4xEGA2DOL+acMzaIBTmikHi6H2szzH9+rQM4lRCUNA4kqRdg+c0HkCDbOWs7u1fsH9/9u8CxCaEGAF2Ac/9Tx77eSHEHiHEnrjWQBmKoE1hL0uStlADsJoGfrvCmTdw5g19AEpAKtwFSZSGYEhH20poqce4PcReMjAb+hIYizZRRqHsRAOTqhJzwsVeNpBNAxUL7awMBZEkyibIlkb2qsDACCDMaGnP1mCko+RCpA9TJ0GZSo8kFUoLkWRi3EkLZYB7ztbRcCB1i8AGZ85EtvToRKNsEWcj/O5IzwmetmkNRZiTrkZgRyA9qZ3tiqXFWeqSKK3w1vgoQzsZWTFRFng9sQaDTTnIGV16VU4CnoGzJJGevibOnM5W/e4QexWkFqWVbilkFUExJrEUzmkXVpHpSSnAWZKYTYG9aKBW2Sd+b4hZ0we3U5a0BiLkjEOU1g5IWfp7mzUDWTFprQ0wmpKoJ4BEYDQMyEbEBU1lsmZsjJYg6glw5gyEUBpwtWJiTTnaEQFxTt9Pe9LG2+BhLppQtXBmLMxZG3PCXUXBajaDbEmMqok3HGjk/5CvWzaT1ioCH/zOBHNZV0maoyGJrbTz/Let/X9a3y2tNmZVJeaKSas/BgF+V4SxqLMyPH3gej0xZlWCr4FZSTHAaEissj7knVkLe8pGhBJ3SgMA/VKCWRcIT+J3xhr9vDr4wuuN9CS9WBA7SmfeiV43RlWDJJvDkS7rG6vo5nRMUNRDM6TPS6eJ1xdilQ1dMk80pdDwQa3YOIsGKhNrcZ+8IuoNdIDYEWJMuZgrJlEhJuwNSE1YGDWtLOb3RJizGjAqG3pd2fMWZt0gzClE1USGYE3b2qGFOlDXAa5CxRJrzsLri0hNWhgLNiIV4bcneMMBlDWjIjVhYc1qgKw/4hOlFfacvvbKUJCLNGhu9buKQOBOmVhlU1d1ErG6nvQ+C9oUcUpn6KJq6QB6ToMwhZGQFDXLxKxKZMPQ+1mBvSJfCprMmsQqmxpkCbhnbVQgCboiRKyDPCV0EGYtGyR2gjO7OpgoH+ssvSVILA06NGdszLrE8MVLAi1xR4j0BdRMfV+KGgxonkshIh10/8DsAgr932w/dAcuhMgCXwH+o1Kq+j8+rpT6uFLqUqXUpUY283/+A16wC/YDtP/v+paZC+v7gv04mgKVfH9+fszsh+rAhRAW2nl/Vin11f/t38cC0TKIc1oT3Z6yIZRgJdgrAn8wJGhLEIkgTumsKSgqzbdesYhTCSoVQ1ZTNfweXWYKs5oaJmKBM6d1o8O8liyMsgqzIXFmNZfWXi0bJ2ld/o4zMaKh08yoN9DcS1++lHkmmViP+DQVhg+iovvNsqHLfP5gQGsw1Bl+JCAXkVhK9y09XXIzWgJ73sJaMkksLchAJAjz+jr43VokRq2WzcyG0JrKZYlz3iEY9LGqGjQmIi1M4k5ZhD2BFmuIBc6cBZHAWxNo/iua5oXQEo9+T4QMIe4MQSrMli65InVZlUBz2Gnp7MhvTwjaY6K0Hh3pTlnEKYXR0EAZo2aQuOqlUmdiKWJbX6MklYDUwyzscVtT3gSYs1pwJhgMViVCFSqU+N0xiWfizhvEHQFhn09SCrEXTV0+ziQEgwH2WV0Cl8FqTzUWhD0B7oLO+oM23f9LnARzwSJo020A6ekM5HulTbMuUVLfI9nUGeL3rtnLNX9AUyIROrsjBnfGJHZ0v196EuUkWBWdFWtqUoQKteRs0BnpjKmQEPSFKEsDG4WvOc2JDWq17J6kY52lJwJrSd/jxNWtGBkIvK6YOK3L70kh0hUZQ9Pros4Qa1GD2cK8whsJ8foiTXs0NSYgTum2igwEfkeM4evyMFLp8rgEVrNpd2q15WTqe4DSWasyFc6CbtdExUjviZTmyccpRZxKiDpDlKNbPSjdMvpeiZ/Vio8sW4R9PoQCrzMmziSohoWyFe6YrUGhZoI3FOqqUllC08QIxEt72WhK7Akba9kg6gpJrFXcwpqAsKTpmGbZxPBWpUfdmKhNZ8lxLsaqrmbSw6vnRNnGHnf0ewt9X3SLwsQf0gNggpKmLYpY4zTCnMJbG+iKlJPQGtDa88rV+03Eq3S4hJc45SiBPxjo65WP9D5VELeHuNOmPvfGbUSsv2NU1Pc67An1vc7HKPvHL7v9UbAfmgMXQgjgb4BjSqkP/Uueo6RexEZFl4n8Lg1cc+ZMwowCobT2eE2jRr3+EKsqiLoDRKAPJWvBwhm3CfoCXfaKIC7og0pE4Lfr8phVkVqwJNAldxFpsFiUVRp960niQoyIdH/X745QkSBoS0gyMX53iAgkBPpxoykJ83oQAb4uocUO+vGmgTNnYXgSe9zW5UlrNfBoahRv4iiCzlUn6oKydaASFSOUmehS9IqJyuu+tTLB79ClNbls6zKVVMS5mCijdB8wkIRt2gn43aHGD3zv4HVilKlbFSIWL5XV5YoJbqKdqqlg9XASge4HKkPp9zV0uyGxE4xFC79LH+BRLtGBCqvfIYIwpyPnuKA/rzNvgKcFRYQCq2K89DkSC5xxGyV0/1s2DOQqf9cvJVCzMOZt5IpJWNS8YWKBsWD900HsCX0A2wpnwia2dQAhA92nt5cNzV9vCXAS4rx+HWfe1Lrcq5/XWTCwy7rtERa/D01CY3UNuxo4ph2txOsPMTzdw2XV2QadIaRi7LLWAbeWrJdaDYmjIB1jT1u6fC51gGHPmSSOwqwaWCu6TB+ntMMMO0OceROzKvEHQ8KeAFIxcSbWJdc5G2VAmE+wFixUwqpewGrW09Lr2KgZGEsW8SpgzCrrGdrOokGcjbHnTR14C4izGoQW5hL8zhizrnW4EasBYTrRfP9SQlCMsedM/N4QZ1Z/bhGhHXfdRDaMVaAb+EMBYT5B+rrF4nXqwToq0kh1Uom+dwsGIhC0BkJQ4E5bEAriQozfE+nrktP7I0klxDn9ORJTIWu6VSEMhayYGvQ3aZO4eo9ZK3rvi1AHrPaCid+l55XTMvDbE6zKagtO8tLaVJbCGwpxxm19ViS6hB6268D+e3swzurSuIg0lx2l+dsy1K/h9+g2Hpa+nrJqogyl24Gmbpt8L/gz66stlYFAO/MZ3UJQSrcEjJbU7ZofpF1QYvs32Q8ThX4N8A7gkBBi/+r//Sel1Df/V08QsVbu0o5FZyBBMcbwNKpc1E299zs0GMSs6H6OrGhqkGxpVLXXGyFrps7IpcBcNlejf8CAoKR7j2ZFA8HiVILZMIgyOoK15yzC9lW6iFp18L7ErGglrO9l5ElKg70ALZRSipFCYJUN3RMum8iWoWkh3RGypelNMtCUKBkJYkuLoSSZGOFJTXsCfWCjnVhY0lE+kdC9QF9n29KTRDml+4Fdqw5GiX9yVIumHloBhO0K2ZLQWBXdiDRgLszq6F+2pD5Elw2SlgZSCQWyqX9XrlbQshcsgs4Q2TIwV/Q9UoaO7EUMSSrGmbMIcwnWknayyk5wpiyilK6cxDl9/eNcTJwFQom9ssoccBONfpd6apUM9aEvAk0lix1dSTErOms2WtrBxvkYGZoYviAoxroXrnRf2GhpSmCU0bK5Rl2isjFU5WpvVQdUflesnUd/RJQSIA0dIIWC2Pk+lO+UWF2rEdK39P0Qup+tJLBkomxF2B5jz6325A1e+uzEelJZWIy1U1E6o1cJei+0JXqMrJRE+dUs3FFgJ8i6lotVse7hGiv69eN0QpxOVt9DvdT7NaomUVYLHkVtse5VAyS6shEVYqxZmyijA83ESrAX/ukzyKaBVdEBsYghSiVE+QRrRRKCDlYiQPBSRSzoDzWg+nuUrkyCUdUBizL0/bHKJvaETdAfIusWYl6LMOm1ahBnE4yyPvaUqYO5ZLVzoQyNJYkzsU6J0e8fZROssomSCsPToEmEwncTRN3QazsUOqFYNEkcgdcfIjxDC8T4giitdHbbps8PQFcLlf5+35Ny/t719TtjiAWmr1krRJqdIUK9ToS/muUrgayaSE9fjzjWr+HMm8Sr55IMBFFbhDNr6bMtAXvFIExMvW/R8sbRakD2vSqHM6sZOGFH+BIT5gdi3+uBX7B/tf3QHLhS6ileIjhcsAt2wS7YBbtgF+xfYz90ENu/xpSpM1G1WkoyqxIZSuJs/JLwvtnQFAjZ0v+fOKv0qkCsojL1cAyzoctXcUFTPpL0qphLTWLWdUQtIz3LWmct6L5v09CZmqG0iESo31f6WgjFqqyKigDWskHQrmloUWq1LCp1GVK0DOK8Lhv67TFGVUfria1L5SLUmZTZ0NmhUTXB0lG8WZeE7boEHLsKs6JLu98rw8lQR9AyECSuLqcbTYnw9JCQsBTpUqGjUJZGnBo1nU2K/7e9bw2xbcvO+sZca+96ncd9HHONiRhNgtBgcztE+49I50fLjYJtQowGlAiR+CP9zyCRgJHW0IqK4ANBpekIPpBg8IIhtnRiOhB/pIXYdpTWJrSYtu2b+66qU7X3WnMOf4zHHGvVrnv6nNp16+xT84PDqdq111pzzTnmeHxjzDmVGu1WhPGooBxqTcFhUdZDqr0hzr+887sJ3buSFhjuSfRiy1D6k6S1AgXjgVB4eU+qk6XDGf1bvaQTkuRLu+MO6aQDsjARy7dUTFmWvJU9Bu+LHIzPSc5X6HUGeqmeXr00ojtNKEu5lM6FhrQIfbwv74ClRJh5X3OviTE+pxE64Ou7+9MEWsn66sXXF5IyYGEJ0iARzFZkPDEWv71QKhnId2Ulw/DiKDUga4m+1r9jxPpFWQWwfjCCFwzeK8IMdYx8V1MpmZTZKbJET/s9nWvNQgEWX5etVtPbC1nql0V+QEAakvwMYT+IZZkUsVC1vGSpfN4v8tx7WVYDvNtheHEUWeylbdwJ5W053+Ge3JcyQEOVVVkRIfJaOhlLGgk4S+je6H0zJ+gRvybz/TsdxjsZ+ZCBVcLwQCrGu3OJXtOKQAMh381YvVRlYaHMRukglfxvLGQjH5XxlGXOUJHom9bC2tHK5uKI8blRlmotJUVBo1R5F63o71YyhxZv9BjvFlmrfS4dMR5w3eK4k1QYskbud6RfJY0ln0k6TJfIFdQ0n85dXhZh+0aSrWfvZPRvCSPDPWP5ducEA9YJ+ahgeHHA8m1ZlcMd0L8tumt4MAjtft2hVqPQnwg7tpWqTBxOkOVZBNGwQ8LwguTb8mFB6YDUK626Empr77Uew13Ji9HDHsN9PRTlTAqSuuMORQvZhgeDKMkHatRPeqxfyOiPO1HyPaN7R9YB00hSjJVk8qy/aZTlIA8TxhdGXW4kBTXpnNCtCeMRoywKMCRd7iabTOT7muN8U4vejoW27t/thBY/1Lzj3YL+nb6yfKNMdF4yuC9S1/eWUIvLNySfm48KuuOEAmg6oPi1izc0hQBRcuv7BSlDFLhS34A6HoWAXvK0YKHXwGJ0RRElFJYd39I5Id/LzrMY1dmtElb3R3BKmjcH8oGkQoYXMvp35NCMoSdh15bAeDeL8V7IBjO8SHLwxkgoy4K0EsepZHHSupMO4wtS4EOrJFRhJs3piTHIhwX9m5K/zAcF3UOpa1i+3rujxQvG4qGmaArQvSX5106dob3XeqwfyDhfWbozpDiyiLLOh0WM7x1pEwCMhwXpPCGdAOP9jHwvozvtdJ291i/o/h35sGDvNXmXsmTkLssyolOl3IlBOWH9YKwU+FoMT97TVMYgTmreZ6SHSYrcjjtxloiRzsRopXUCd4zl673kiZdSw5GPhGbPJHsy0HlCd06awybZSY+S9PObvbZf8q6c5B06PWUNJHQ9rQlYMBav93L/c90pbUXoVrKJEBhYvKH6YAmgQGSxyLI4k8fhUHRC/47WmizZg4HF673mnqU/xzta27FQg8nyfgt1KvKhrMOnVQJGXSd/lnQ/eTnDgTKhO9XaFTLjC9A5oRyMUpS7LKCBMN4XnWZBRMrw3H46S67DxrvFA4nhuYz0sNPiQg1W3pZ+yEdyKmDeY0lxvNnLmvWkBZ33ihSLnspJZXkkLN+UdOHirffhNLKGx8ZOGXDK8MNE0pkok7QSYeve7aXwSwt2bCOFfEe2xRzuWvUwJDJ8t/PoariXwUmOtrRqdCw0MjyQHCmIMN6pRr8spKKak54CtSeRELLeYyXFU1Z4AogyQkoSae8D6UwUGaAHS6xFaXPP8i4dtBBMKqNRRJGCxfDm52SDjWLPHAg0dEhrzcUzwImQ94sUm2l0PCwz0oqQ7xRZr5vkftRDopdlAb3byT4ee4xhr4jBghq6k04Va0Ja91XxreRZi7dkh7OyL1FC6Vlyj2cyLuOhbSwhES93XCP2t+Xeo65P7U4T8kHxPHR3LsaHVEGmAUhruVfWSFEMmeR10yhGLZ3pgRMLKa5LZ2JwylIKH5FrTtUUI+/Llq7jHTHkIAbnTvLM98WhW7+Y/R2vCk7iLJIWInHPIt/aVhrJc/rlQGoc7Ln5oID3ZX26VfV3J/LOcviKbr+6ZAx9xuKdDsO+MEnpTArG+rdFSdNASAnA2Ml1ResMBhInammV4uROGS8ZizfFWUyr5HOsLBh5v4hjd0fyuhnK3hDcyUaWMSwHWQwgZLXFuM9IJ1YgKXUsvJQit+H5rAezyFxZv5j1yOFadMkkjg4K0L3TYXwue5vTOgFrYSNcGSwLCotzON7ROo0XMtI5SVFcJ0d8SmEbA1lqUOS5Es1aXrmMBFrrngxHrIV2EikDoptoMOe+87bzAhpYQNfcA/2qw3gouok7+JxJa7nednhMygwN9wr6Y9WDBdoGkWObD+N92fYZSYryxrtZvve81vcUrcU51VPirg23M3reBnbKgHNXlZosEyGUPaWKl/ACkHykVZkPE7gnrTAXQR81ygVkkgjtJBsa5EMtEtHJaJXJZoSN9qWR0GX4TmtppZFEEcoqrbSaVmmwcpTBgyy5ykcFZUkSPQ6yOUxadzKZ1iSbvUB2lDJ2gXv29tjGC2UhhS3ojYkAwOI9l14Uaq+FfmlQZVYkKupPZNLSKIbejEV3muQc4Td7XeIlnwFCmwKi7MwJ4iSUHPfsG6dA0wTIpBS2KPBelz0R67KxPbk+PexQ9gqynhmOJeu2rKIMqUihkZxqJhvxoJNUhxQYZWE/VBH2x1rUBGlXIaHzOTG6UdMS74iTkHR/6O5UIkAupFvOSpSSTjt/v3QmhqYcFOR9uLKmNXmh1lZkPDEoSR/Klrjat7o0siyLGB5lRSiTbgtLyHvVQZEq/YR8aM6fFGWOR3Ks5XC3VHldk281CpL/0yBMT1qJ89CdSiTZnZs8kjiOnY7XqTgW6GqqyNrXn2pqZSB34nqVDfuuF26utLi0Z9AghjSN8u4uo/rOgMhF2ddd+rJsZjLel5SUs0xrEgp/Wccx39W5vS86oTtOXqxp0TVlkZfuOMn3jsQ55SQFqqVnqQCH6hozvJrGKftFHPRena0jWT6aD60oThwvyiRpqU4ct3Qm8khFdlDEQuYGL9nbkta6kqMXxiLfFbmW5XASQMiJf+rYdvI9GsRJGJWNTGtl75SBApOmAoDSs7yjFtg1PH3YKQPe0NDQ0PCMgQGU27cJyzawU0VslIXC48Qe/XUnaXLaESeNmJSOTmtCWmuudAFd7iUFUpQB2yKxdBp9AwDrtYMWhtlGC70sWxo1l1YWHNZDE7oTOV2MWDzfNGrEmCXCp0ELUPTvtkSl7AstV/q6kUXpxJtHp0t3inr5SQp2KEuEhVFOMYMdeKKOcnqo+8Cz5NnSuTzbTu2ynF0ayJdOlaWuUyeNBNfCJNiGISBIe3p57zTIwS/QaI9Gza9qtG5rhClrf44ETuz7onfaJgDoTjrJ4Vs0xpBonqB7nidZQ64ousd9GpKkLTr2dqOgsixaPJS18DA9lPZ1Z5JP54XQ+2ml0WEHz4N65K3RznhfisbKoRQ1goWSlmV3WxBwvZ+MC6SAUJkj25Sk0wjSUjlpkKiqLHSLXi1UY62rSCtyFiXva+4+K3OjdQ4AfOxpFOraCtyMybI9zPNB0cKs4sxUfyzsEC9qlAfIuJWDguF+RhoS0jr5Zi2SQxd6GCTf406iRalrULaMghxpJE5F15CzXNe/20n6qGhkeaYsjD4jTgyZO/JzPtB6mYfCPOVDrZPQE/iQWGVLGJ6JHtCi1e5YqO+yJ+xIOZDaD1oTaJ1kq+YiOiadiyz1JwnD3eIpn+6hsHNpJQV/tg9AGuRfd9xp7lyXm2l9BFhPZ9SCVe6luM+KS/OhRN7dWUJ30qE/VhZpAWcW84HskmTMWD4oKL20Jeo/Wl9zBN6K2J4IOxWBs1I5xQpGABF8XS9LrAWaq6TKSiYdCoRqH+R7+ag4hWe5RQCaL1Lae6lGbIQrA8ktF3QnUgBl1C5DJgwvxejZulMaa66Kiig0DKIE+2Oh0qwgSJwOLfQpUEpfqM806ulO96WgLR8oZUuSTsgHSquSKCE7wSwN5BMvHxUxbpBqV+7UaO/LxiqyqYYeJqIoWpmdVqJgSKtay37xKmYrcuPE1aiuSSp6bd/sooVmDwmUat6/7ImB7I9lz3caSA/TkPZ3Z2LQSs/oTzpRhIuaFwdpDpikeI47pT51bTgvRBlafcB4R/qpO001h9vBjzYtvVGuUonLmp8H1NCwVm8fiPKkQkjHusb3bDsKLp2Lwi89gIwqd0eSL6W19I/ItNQQWFtQANvZzg5lsQK2/kQqxfOe1CqkFfkYcq/V/brDGRUdi2RyoEZJN+rJWkgHqOE1elX1Z9aVC5TFOKKTHLzJMaucmeECC12LhRa27RV3dK0+wzYwAqQWxuag7HWQ1UkHoOuhu7MkKZGkdPNKPseCkSihO05Sl6H3AVfDzgsGr8TJsPlJXFd3mPMGMmdP7mGOS9mrjqjNa0DekQ/rYS5pJTpjvJfR2U5+qpNk9zVxqLLWfIBJahWONSWm6TtzyInYHT6YQ1nkn+XbiSFOCZmsaN/uMcodfY7WipA6eJ5eaXjqsFMG3AyUbEQClH3xGFHIKzz7U1Godo61bXZAtkGFGpXxjlT7ygRXz3YddpYq5BEMIFGGTSrLMwHk0UKnXnGnnjqgGzAk3WyENGLtpahFDKPkT63qVZwMnVyqICz3zUmL4nQpjzyAvCbAqo7NywdsaQmB1lqYlNX52VcFpznIfgVwp4Z+X5RZyqiFWSQ/U5LCI4v2fdcwVQgSMWhVbdGT2BjIS31ep5ueqMMhZ6szxiXUKElkyEmUueVawZIjTOfJC4C601SVUhFWxqqlOWm/K4Nh+XFT0LaVpD0fGvD3msdNY3XmeFGjj7ROKHvFjYwtaXPnbAvyLUvZpN+6h6qo1WnxtnaoEaIWmKVViE735GhQy5t3KzHmNBDQF9mhC/AI0ObTeAjfGQwd1DEAmNTpIilmpFz703LXgDJkA8BZi96yLMUcl/AlcLwQubF5w5ofBmvElyRi9Py4yuC4p3n2I6lBkJoPqnUaWvBVzAmwuhWdrzHfXvbViGrk7AeQQOYgdJ6Yc0yFUHQey3jozwW65W/x8XHnp8Cr6K2oz+al1avIA8WZ4g7OskDz76QFmIDuHnin1vuAte5On5/Otah3IM9/W0DDC/iSTIzkLJo5L9RNo23XbyO5Ed9WjceluIXR8zawWwa8oaGhoeEZA7ed2J4QO5UDBzS3s18qJcwWQQi9V3qhD8uCdYvNSqPJsiH4shZWL95o0vFIqWiN6G15DFDXMFuernsotK+t/7aIA4DnnsnyxLrO0nJppYdv1AHoGl2jZUdbq5w8T8Veaa4UOAFlWaT6WD3qvMe+bM1oUekP1oM7hI42upU7SL5X91wvS8tri0g4nQ2hktNgZ3rX6nsm+FIWi05sHXIaJEqV/L2+h+fzJXqx5WBJq5OpWO5N8/EaUdsSKCpKb3Zw2ldy+uzRCHfsbIzRhcQSPVNRJkHXSTvlrwdfFI0U84H0m8mM71Od2OXFlr3ZqgNbHXBVWBqAlW0S6hwetXGnLIkyITSqbIXIttMcrEWveY/9EBMAPlYxOjW2xOsPNOriZOMv9Sd5T/YzsDlTFjyJGMc7kiMnhi4vhEejZV/61dZ4AyI/Za+ySjRqvYT2KSnt3p1JntoiVvmy5tK1RsSqv6VWxvLwYfx6YSbSOklKQO8ddYgxAc4yjFV/2BwxipmXMu/sfWisxxWXpdLrmj6To2ilYt7y/5KW0oFP0kdplVQHKPOi5yiMmhaw97ZjXwFhZ+w9ANT57wyeMi0q50yaCtqXOh2vWUhaK4OaPhKGM7Sz4anCbkXgmiuzCer0l09gYRUxAOjV3hFUCamxS6a46mQH4HljFPjSMqP5UhZjZ4oPWsyTRs2h2lI0VbBerDUYtSxtk52QUI1oWD5DhXw9KwAvjBMKXAxgGpIbYi8gK+S7RTHV9/BJq2dtc6+KWA/3cOeiY10zb96E/qdLaVipurIooERK66viT0a3Gk0dlpuQ5u4zkEj+twIgG5e0TrBDVmzzDS+q0bXMgO4G1rNT76S54dIBSYuThO6vlL8VCpqxRoEsP9O16t1ZArRPbG29nYIFwHd2s0NFkIKyP01KKbMvH9rKVlWqWH3nLa33MOqcRnUedCmXGUe71j/vjQrX/KztiTBLd/j7qQMYd/Mz+ZVNWnSOWKp7oTKuS5OkHmRaJ4GO3QkGqhE32Y6/U64OOFkfJBnTlKkWjOp95FQ9SQmxOqBEaqDUOPJCnu1Grycp2jPn3ObhmlAO9BwEXbJoRbE0VCfC9yrX9fDmLKYc5HStu9jtca03sTSe7lFuTkPp1Rk0DVzqvAJqKsCKYSn0QVpJfULeq2vsadTAZVlpeL+PpgrLErXGQPvd6oM8HWLQwSZdC36tm14zwLfwKNBtYLcMOODGlBdVSdk67m413TjF15hata05AEXTZ2ONKIGaUwLku7YWU6o0w/pW0qgn1bx2UcMka3YhikfvZ/e3Z3Ank92VpkZKphS9krzoBZncAJNVP1teyp6pSt8MsUePto7YokeCKtcaYZgR4AVc8XjNgO3CpdGFtBfu6JhBNgbCd5azflamwZwVsgNHyLx87RcdE9vRy5R70vXOyfKnZuz1b7FgzxWXFxnxJMq09qRVcsUPd35qVOrjoWMLdQDKEn4ASNJ1yFawtBVYn0IMRAnywZB3r1GxGptgeGtfquPE5BuHWK2EyaM5r34KmxpcFIBN0Rv7FCJ3MbzVOJk82Hc4QWRU8+DJ9gcg3enPd3Fhn3spRICWq5X3S75JCfQyOybUImuv0keVE3NIKQdjrEaQFyz1KMZeUZUxpPAe6hRAr4HqgaKbKxlbYStT2Jxvm49awW5r8o3J87qbUfrNDqRBgsujO5Kd9Sk7SwC7lxXbaj0D614IZV/1YNQ5uc5xYbls5Q6DtD7I5Z6U1UkhqFhw7aPrQqPQnwi7ZcB1QhFpRLFXlawXKjFgVWCufAGQblwSC7yghRq+NCtEBUaBe6HYuu5GVZem1O8Rk9N4FnkbZWmGvdgyGw4GxSjIcfYcXcKDmUHx5VxUnRc3xAynyICqLKhAmQLyCNuqkc0YgKti9sIkTUl0KzX8RueHZ0IpVlP4pihMQZZFHRtT1mlNenQmPJoRhV4NZmUm4EsGAYsgaqRdIwQOqQrt0xgpDZX2FQGg6kRQVXLm2Dn1ylKIxZGBIUgxkPZRWtN2klEUnMlCoT/U4IXiLDsFD4BvW2osTOwLV8zq5Mm9q/EyhoKZJhS794ONs7UtdGF0Pq393hdxTqkRrmxBcNCGcA+q3zUHCUySQtBIlgk+XqzGxeTLHbVwT5N5T0PBHH910I2BS7VfSaN0M6b1/iE9owyRpTusaAyp9oetIICpjKQGOymjlxncVXYKwGRVjK+qsAh6L+gzRKeZRc5hTnUdX9YjagG4I2HvZ8+x71r/cG/zqrIv1xqBA2hFbE+GncuBNzQ0NDQ0NOxaBK7Rp0UInS6/sFN2DIRppGF7B1uEYflZ4cGM1oN/D6j0uUXIFhm6Z8/wSNSeZe6Qtcme5WeGl+hV18g3Uvce5ViUW4wWZ7+XtYVm723XOq3Y1TZ79K15y0iJeWRqkY3lRlPov0CbxtqBCXtg9yxUIxFz4DWX7CkI2wZWl/kJHQsLurzfAaqFXZCox/OvBF/KY5uTeC0DsS91cvpQ+7UuLYSzL1KMRd4/8q7sBX92QIhH+dangEeG24BHhHGMff0+177TuWARG9n4Ad731hexIMuGxNgqS+kAIQpc1LRL0n0NnB0KOVWEdFLdhAGT+g+XSWWz7D08XWRj67JWU1zOYNkyrzCnJtv3WvTIYWx8cx/2PLMVa7nM2VwPDIwzHCnMi5CrtzZEWp9gzwY41fs6AzVSYACkDWkMzABqxO33n6S+gnzYO/s8RE1d1du7/nKGI5OzANbHk+VsKUT+gUVA7MvrAjPaTmxPht0y4CacRiEDlVKqTGNVzkaxzSa/KwpVjhMqWAs7Jr/784Mw2+5qJSgiM7aab4a2z+hIryS3gh2bXJbLnvFU1m6n1ZSyNdrMqfJMXpzHiSdUqe8EB0zy+/GgFVcwDKcJXena8/UaVyhqtFyh6MBw0vw2wZWMpwkiXar5eB+DoRoHW3s6UTBGI9t4a07SDJHRhrZLnPdmwkRZUwaQTFHBHQanHK2PuT7T86BOoVehi/K2FZghmiteTJ1IivouVaVLWtRImUCpppGcjif4rmUAvKraxzi0IxpRd0ItVVWo9oP2N7rqNBajp7l+zffjNgfADG6gjSeOpsrTZFqY02vjFSrPJ3MFU12AzhyOOnfjmmuRj5ByMPm3uWmy2IX5aw5hMOZItY89h91Xp8fnvVbPk865mLoB4N+ZjLMbW3jRrqUBqnyT1kpI21hz6xRkxHWS7b1g6ipU/U/eMQz1taFR6E+EnaPQbatUADUC0OUfcwXkSorrkhGPgoNhti1Y5boq5P4/mVFAjSwt6qLpvfRx/j2/XSfPIFMyYWME7tTo2nN00sSqclOytsmLbdlqk5eDp871tb3Ab56rnI+83U/CpmrMJtfZTS3itX7oa9+5QbbAIirx6HDENppRCpFzVNrxnr7JDVM1TNFBiu9nSstWFaijU0NPVGekZy8SA6DKj3184qYi3q/W12VDPz0JTNaCE8bKUjgbY1uVFgoDHRRslDftFzO2dm0cLzFsxtCQ55hjX0zmjl1bwlhEeeLQveZsqhyYPJucuHGwvjQ5ptqvdh9rhzXbjaxWqU8cmJ7d+YkObWQyYo4fPHtOqXIVnVVf0WLRKKtDSzyVb3NqJ5XcgQ0KzJv1jTsyKpO+hC2Mhef9VQf6mE90XRULBD1k/TbZkIWjE2RyMtVf3rfXvZFLwxNhtyLwhoaGhoZnDtwo9CfCbkXg6nHP1yzH6NNpN/u+Rm9Wwe4RX8h1WjTg0UKgxM2jjdSvfa9WoFZKMUb3fj+EdvO07e75FlKKehpx+Fr2GLVHBz963/FZ/hlXdkIjV7+/vbNRs8ooeH4Z9RYWlXvUusEhZ+3j2C9O7UevnjZcF36J42tV2M6yxEjDqs01Yom5/FhVH6l4iyas7ybv6PsDhMjJGqepFh9fYwE2vM+VEFkj7wcKz0SlqokvyLLRnTEKjmPrOXSnv0OkOX+PEOFBZdSZGkLdLMcOkDGE+THJ6Rp9Hu4X5WkSUYbVF96GmHe2aDHxBUYL+qqIDIB9pnNhQg1HLZgqs2btjhXitUpdLw7MhXdbYKVsIxj/GwW5DGM2ierD+0xYp1Sr0l1nhBeeMxqxLyLDaPM+/i4HRNU5NHnn8P/1gPF+HWZCRK8Q0ZeI6MtE9BMb/v57iOizRPQFIvpPRPSt4W9/i4i+qP/+9IZr/z4RnVy5Ox4Du2XAoxEIubGqqKgKsgqjK5I4iUtVPEbB2T3dWAFOvxl9NclJ63UTYxmUvRtXmyz2lbBufZLjNQVlNJfSmxNlEotL4o+pTkIKbZ/kca3aJuQZJkYsUNS+0U0wIL4cRa+J9KgrdUwnet3cZqqQYvvnuTV3tvT9PUeYqlWKNQc+7pg5d5i2K+Z5vT1GqZqdTpjIgj3X6eU+GMzgLG1NuWkbfcxNPlN95+h8uWHSd/EaiJlBiWPLmgueUOXB0Pv9Yv8ozV6T8aGPgEnKRT6fOpVmdCZ7DNhctn+xC+O7B6fN8+bxXm6M2cfM2jjpA2u2ze/gyFqfTRxspqn8IBhOe14Yt5h68SaYA6vz8IKjEVM01nSbs6azopNocjgrUpy8H8I7hn4wZ9TGPTp2HMbInb/grF3/PuiQdeDb+PceIKIOwD8C8L0APgDgh4joA7Ov/R0A/5yZPwjgEwA+qdf+cQDfBeBlAB8G8ONEdC/c+7sBPL+N7ngc7JYBV1QlZ5OaqqIPSmbi8QMTwxoVtd9vFpnFay3KmSh/VUKmWC4UvWk7YuTpxSzBEMr3wnNM28ZoLEaFCEYofF2+wBPj6m0w2S7VETGF75Gm9qMbxeAsmXIzT33T+5iTw+FzbZK3wyOQoFRcSbjTUZt9Yexps0KZ7Bhljob/MYxNuNadjzx1QHx8JhFONWxzFmAS0VwRtOHdo5NEF8YxjC1Qi5hsHEyZlzAfLKdqskS1/2KlNVD7x27GMyNpfWbPjgVq8W8TBBlyRyIgztf6rNpGH0s1cMHmTvqwFnRNHxCZG3tHdyQwlV03btFQGuNhMje7dxyv6HRHJzuyO9H4R/m1uRbZPXOIohG3F3GHNtXrY/9N+kYdBA9AOLQB03bzhj7cUfwhAF9m5t9k5jWAfw3gY7PvfADAL+rPvxT+/gEAn2PmkZlPAXwBwCuAOwZ/G8Bfvub2X8BOGvCGhoaGhmcIXLbzD3hARJ8P/340POVbAPyf8Ptv6WcR/xXA9+vP3wfgLhG9qJ+/QkSHRPQAwPcA+N36vY8DeJWZv7bdTnk0draIbUJdBopKfqdJ1XL0Hp1uC/QUgafeNAdvOXjNTlmlSs3H+3v0iqm3Ld/BBQqNY8RJ8ffa/thwp9ZjLjiwBTFPFqvX3d3m0Aaq9/SIJtWwzZ4/8f4Rfg99hfCISb4dIQKj+u6T/HyMOgwzViVeQ5PwcDY+ob/9bxZBRUrX+tHGIOzGFd9vsrQqpCEm9O2WI5NKd8IZHnuYR5hBBr1/dOxj1E02nokvyGl8J5qEo6iRNdX7xjSFRauTvvW6E5rMFYq51xwYrChD+tyaN6dplI3ahomslumcj3J3Wd85y2AMS2xDuH+UJx+LWb6nVo3P5iLXZ87fhzDVERN9YMyZ0u5zXVDltP5tQr/xbGzjGNJF+ZZxnz7DXiLqv9lrbx0MgLe3lerrzPzdV7j+xwH8QyL68wA+B+CrADIzf4aI/iCAXwXw2wD+M4BMRL8LwJ8C8JErtfoJsXMReFQqTkXFfHg0Epdyc3Ch9Y+VbnKFZfcOxiYqKpsIE2Ng1FlUlHZPmv4+ofdDbpBn7wHA0wRxJs0LY+QiOCfpBjVO8DCBI5dGURHqs/2y4DBEatHacCEPN8/rbTBwE2pv8odZ3tIaEelbvji+cQzsfdxx4vq8ukxppkCD8YjLkSZ9MEsJTORrixrOnZYZhTtx2mbtmPSFK3b9366dKfYoFxzkxsBz40d1XG2c/LlzuTTnKdQnxHXF0Tmc55m9H8K887x+SN1YW1yU7YdouP3lUNM7MZefpvIQlz9O1kxbfUDs4+Bgu3wFJ2b2+HrfrjoIdRDrHNtE+fuY2nybpwT8PYItn03zibMe00D2t1mXTdJv3oidx1dRo2YA+Fb9zMHM/5eZv5+ZPwTgJ/Wzt/X/n2bml5n5oxAp+p8APgTgOwB8mYi+AuCQiL583S9iuFED/qiKwI3XxDmySalHBeXG86LSwqaPowGJHnuU3SDQUbFNq2hrI/2+oZ3ReZgqAUwNLM8m+twhoek9oiK68D273trNswkcItfJs2cKeta9bvwnfRGaO1EYNFMeE0Mz7+hp+y8Y9vgQ64cNTlu87cRpmhmrmI+/ENkAldmIfTvp181NfxJs9DujkZz/fe4QTX7ecK+goXluiMJcmjBLsWs3OJITxzPOx9COOGxxYOz9JnJsxjgaNpO3GaPgN4nWK7YvyNmmd73g/FgTrC4gsES84ZEuO3GuXuyqia7w54dx8JtGuYqfcZ1Hm/TY5BFhjvmY04wBvMRQx7l94XvXAWZskUJ/L/wagO8kot9LREsAfwbAq/ELRPSAiMwu/hUAn9LPO6XSQUQfBPBBAJ9h5n/PzL+Tmb+Nmb8NwENm/o6t9c0jcGMUeqgI/CgkF/FrRPQqM//397zQBHEuqAiKOCr2SzzICUUdJnacxPNJNDe6Fybs3AjFdjKm7Zq1aeJo2K0wbfNlfbHx9/nP4X3sWaZ8NlJlj7pvUDSTFEXg8TbaY9qgfOf9MHMuNtr2De2bjM8lCnWTU3fBQYt/i5RjUGrvNZZXAgulPXlekMML8onwnVlfRPkGgszP5SLeey6D1peY3n/+2rFdk2fPjI3fM475hvZP7jNvZ3ByN93Pv2t9OdcL83bP5HmCubEMbbW2xfe9MJ94Jj+8QU/N8V6fhbbGeXShD/R7m1Jxl73PZfrjwpy8BmyRQr/8GcwjEX0cwH8A0AH4FDP/BhF9AsDnmflVCBX+SSJiCIX+Y3r5AsCvkJxa+C6AP8vMN35K+k3mwL0iEACIyCoC39uANzQ0NDQ0PAGY+ecB/Pzss78afv5ZAD+74bpzSCX6o+5/ZwvN/IZxkwZ8U0Xgh+df0irCHwWA7vnn5cNL6NZJxLHBI+fEEklYRDGPJpku9+g3RWrxoZsi1k3tmEXBF+5nz5pHtbN7bYqknK7e1P7Z870P6CJrcaHZmyKU6Mlvin5mf59Ec5dE+pfd7pERgPXpLEr0fpmP6YbxuRDtbXqfTf2xqcGPgQvyHaPq+Kz4nHnktqH/JzIT++cyOeKQ19Y/XKCo47NmUfHkOfN+jJHvnBXZONiYysmG70yas2nM5u84/9um9gf5B8K824Q5A2Uyjg0s4Lyd83mEMA7zNs2fN7/npig+XL+xD6OMXTZ344+X6Nut4tH0d8MGEN/QJvJE9AMAXmHmv6C//zkAH2bmj7/HNccAvvQ+NfEm8ADA6zfdiGvEs/5+v5+Z7z7pxU2+dx7P+vtdSb4vAxH9AqTvtoHXmfmVLd3rqcdNRuCPrAjcgC9dcYnAUw0i+nx7v90FEX3+irdo8r3DuA3vdx33vU0Gd9u4ySr0R1YENjQ0NDQ0NGzGjUXgl1UE3lR7GhoaGhoadgk3uhPbporAR+CfXFdbnhK099ttXPX9Wv/sNtr7NbyvuLEitoaGhoaGhoYnx85tpdrQ0NDQ0NDQDHhDQ0NDQ8NOYicM+JPsmb5LIKKvENF/I6Jfv66lGu8niOhTRPQaEX0xfPYCEf1HIvpf+v/zN9nGq+CS9/trRPRVHcNfJ6I/9pj3bDK+Q2gy/vgy3rB9PPUGPOyZ/r2Qrex+iIgeuaXdDuJ79KSbZ2Ed6aehh90H/ASAzzLzdwL4rP6+q/g0Lr4fAPw9HcOXtUDzG0KT8Z3Ep9Fk/HEKkBuuAU+9AUfYM52Z1wBsz/SGpxTM/DkAb84+/hiAn9GffwbAn3w/27RNXPJ+V0GT8R1Dk/GGpwG7YMA37Zn+LTfUlusCA/gMEf0X3Rv7WcRLzPw1/fn/AXjpJhtzTfg4EX1B6cfHoU+bjD8baDLe8L5iFwz4bcAfZubvglCoP0ZEf+SmG3SdYFm7+KytX/zHAL4dwMsAvgbg795oa54+NBnffTQZf8qwCwb8SfZM3ykw81f1/9cA/ByEUn3W8HUi+mYA0P9fu+H2bBXM/HVmzsxcAPxTPN4YNhl/NtBkvOF9xS4Y8Gd6z3QiOiKiu/YzgD8K4IvvfdVO4lUAP6w//zCAf3eDbdk6THErvg+PN4ZNxp8NNBlveF9xo1upfiO4BXumvwTg54gIkPH4l8z8CzfbpKuBiP4VgI8AeEBEvwXgpwD8TQD/hoh+BMD/BvCDN9fCq+GS9/sIEb0MoU2/AuAvfqP3azK+e2gy/ngy3nA9aFupNjQ0NDQ07CB2gUJvaGhoaGhomKEZ8IaGhoaGhh1EM+ANDQ0NDQ07iGbAGxoaGhoadhDNgDc0NDQ0NOwgmgFvaGhoaGjYQTQD3tDQ0NDQsINoBvwWgYh+iYg+qj//DSL6BzfdpoaGbaHJd8Ntw1O/E1vDVvFTAD5BRN8E4EMA/sQNt6ehYZto8t1wq9B2YrtlIKJfBnAHwEeY+ZiIfh+AnwRwn5l/4GZb19BwNTT5brhNaBT6LQIR/QEA3wxgzczHAMDMv8nMP3KzLWtouDqafDfcNjQDfkugJwn9CwAfA3BCRK/ccJMaGraGJt8NtxHNgN8CENEhgH8L4C8x8/8A8Nch+cKGhp1Hk++G24qWA7/lIKIXAfw0gI8C+GfM/MkbblJDw9bQ5LvhWUYz4A0NDQ0NDTuIRqE3NDQ0NDTsIJoBb2hoaGho2EE0A97Q0NDQ0LCDaAa8oaGhoaFhB9EMeENDQ0NDww6iGfCGhoaGhoYdRDPgDQ0NDQ0NO4hmwBsaGhoaGnYQ/x8FDXByc4pu2AAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial Condition for Vertical Velocity\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial Condition for Spanwise Velocity\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "for key in \"ux uy uz\".split():\n", " #\n", " print(ds[key].attrs[\"name\"])\n", " #\n", " ds[key] *= 0.0\n", - " ds[key] += prm.init_noise * ((np.random.random(ds[key].shape) - 0.5))\n", + " ds[key] += prm.init_noise * (np.random.random(ds[key].shape) - 0.5)\n", " ds[key] *= mod\n", " #\n", " if key == \"ux\":\n", " ds[key] += fun\n", " #\n", - " ds[key].sel(z=slice(None, None, ds.z.size // 3)).plot(\n", - " x=\"x\", y=\"y\", col=\"z\", col_wrap=2\n", - " )\n", + " ds[key].sel(z=slice(None, None, ds.z.size // 3)).plot(x=\"x\", y=\"y\", col=\"z\", col_wrap=2)\n", " plt.show()\n", " #\n", "\n", @@ -2294,7 +463,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -2312,7 +481,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -2321,7 +490,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -2368,13 +537,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.6" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } } }, "nbformat": 4, diff --git a/docs/index.rst b/docs/index.rst index 747ff08..9d9b716 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -1,10 +1,4 @@ -.. Xcompact3d_toolbox documentation master file, created by - sphinx-quickstart on Mon Aug 17 09:28:19 2020. - You can adapt this file completely to your liking, but it should at least - contain the root `toctree` directive. - -Welcome to Xcompact3d-toolbox's documentation! -============================================== +**Welcome to Xcompact3d-toolbox's documentation!** It is a Python package designed to handle the pre and postprocessing of the high-order Navier-Stokes solver Xcompact3d_. It aims to help users and @@ -13,7 +7,7 @@ automated processes. The physical and computational parameters are built on top of traitlets_, a framework that lets Python classes have attributes with type checking, dynamically -calculated default values, and ‘on change’ callbacks. +calculated default values, and "on change" callbacks. In addition to ipywidgets_ for an user friendly interface. Data structure is provided by xarray_ (see `Why xarray?`_), that introduces labels @@ -30,14 +24,16 @@ any new flow configuration without worrying about Fortran and 2decomp_. For developers, it works as a rapid prototyping tool, to test concepts and then compare results to validate any future Fortran implementations. -Useful links ------------- +**Useful links** * `View on GitHub`_; * `Changelog`_; * `Suggestions for new features and bug report`_; * `See what is coming next (Project page)`_. +Getting Started +=============== + Installation ------------ @@ -82,53 +78,53 @@ Examples * Specifying how the binary fields from your simulations are named, for instance: - * If the simulated fields are named like ``ux-000.bin``:: + * If the simulated fields are named like ``ux-000.bin``:: - prm.dataset.filename_properties.set( - separator = "-", - file_extension = ".bin", - number_of_digits = 3 - ) + prm.dataset.filename_properties.set( + separator = "-", + file_extension = ".bin", + number_of_digits = 3 + ) - * If the simulated fields are named like ``ux0000``:: + * If the simulated fields are named like ``ux0000``:: - prm.dataset.filename_properties.set( - separator = "", - file_extension = "", - number_of_digits = 4 - ) + prm.dataset.filename_properties.set( + separator = "", + file_extension = "", + number_of_digits = 4 + ) * There are many ways to load the arrays produced by your numerical simulation, so you can choose what best suits your post-processing application. All arrays are wrapped into xarray_ objects, with many useful methods for indexing, comparisons, reshaping and reorganizing, computations and plotting. See the examples: - * Load one array from the disc:: + * Load one array from the disc:: - ux = prm.dataset.load_array("ux-0000.bin") + ux = prm.dataset.load_array("ux-0000.bin") - * Load the entire time series for a given variable:: + * Load the entire time series for a given variable:: - ux = prm.dataset["ux"] + ux = prm.dataset["ux"] - * Load all variables from a given snapshot:: + * Load all variables from a given snapshot:: - snapshot = prm.dataset[10] + snapshot = prm.dataset[10] - * Loop through all snapshots, loading them one by one:: + * Loop through all snapshots, loading them one by one:: - for ds in prm.dataset: - # compute something - vort = ds.uy.x3d.first_derivative("x") - ds.ux.x3d.first_derivative("y") - # write the results to the disc - prm.dataset.write(data = vort, file_prefix = "w3") + for ds in prm.dataset: + # compute something + vort = ds.uy.x3d.first_derivative("x") - ds.ux.x3d.first_derivative("y") + # write the results to the disc + prm.dataset.write(data = vort, file_prefix = "w3") - * Or simply load all snapshots at once (if you have enough memory):: + * Or simply load all snapshots at once (if you have enough memory):: - ds = prm.dataset[:] + ds = prm.dataset[:] - * It is possible to produce a new xdmf file, so all data can be visualized on any external tool:: +* It is possible to produce a new xdmf file, so all data can be visualized on any external tool:: - prm.dataset.write_xdmf() + prm.dataset.write_xdmf() * User interface for the parameters with IPywidgets:: @@ -150,23 +146,6 @@ Examples .. _`Jupyter Notebook`: https://jupyter.org/ .. _Numpy: https://numpy.org/ .. _traitlets: https://traitlets.readthedocs.io/en/stable/index.html -.. _xarray: http://xarray.pydata.org/en/stable/ +.. _xarray: https://docs.xarray.dev/en/stable/ .. _Xcompact3d: https://github.com/xcompact3d/Incompact3d -.. _`Why xarray?`: http://xarray.pydata.org/en/stable/why-xarray.html - -Table of Content -================== - -.. toctree:: - :maxdepth: 4 - :glob: - - Docstrings - tutorial - -Indices and tables -================== - -* :ref:`genindex` -* :ref:`modindex` -* :ref:`search` +.. _`Why xarray?`: https://docs.xarray.dev/en/stable/getting-started-guide/why-xarray.html diff --git a/docs/logo.png b/docs/logo.png new file mode 100644 index 0000000..dc33fe8 Binary files /dev/null and b/docs/logo.png differ diff --git a/docs/make.bat b/docs/make.bat deleted file mode 100644 index 922152e..0000000 --- a/docs/make.bat +++ /dev/null @@ -1,35 +0,0 @@ -@ECHO OFF - -pushd %~dp0 - -REM Command file for Sphinx documentation - -if "%SPHINXBUILD%" == "" ( - set SPHINXBUILD=sphinx-build -) -set SOURCEDIR=. -set BUILDDIR=_build - -if "%1" == "" goto help - -%SPHINXBUILD% >NUL 2>NUL -if errorlevel 9009 ( - echo. - echo.The 'sphinx-build' command was not found. Make sure you have Sphinx - echo.installed, then set the SPHINXBUILD environment variable to point - echo.to the full path of the 'sphinx-build' executable. Alternatively you - echo.may add the Sphinx directory to PATH. - echo. - echo.If you don't have Sphinx installed, grab it from - echo.http://sphinx-doc.org/ - exit /b 1 -) - -%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% -goto end - -:help -%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% - -:end -popd diff --git a/CHANGELOG.md b/docs/news.md similarity index 63% rename from CHANGELOG.md rename to docs/news.md index 7c04a41..51c1f19 100644 --- a/CHANGELOG.md +++ b/docs/news.md @@ -1,45 +1,51 @@ -# Changelog +# What’s New -All notable changes to this project will be documented in this file. + -The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), -and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +All notable changes to this project will be documented in this page. -## [Unreleased] +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Intended Effort Versioning](https://jacobtomlinson.dev/effver/) (EffVer for short). +The changes for the upcoming release can be found in [changelog.d](https://github.com/fschuch/xcompact3d_toolbox/tree/main/changelog.d/). -## [1.1.1] - 2023-08-10 + + + + + + +## [1.1.1](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v1.1.1) - 2023-08-10 ### Fixed -- Specified the version for netcdf4, to avoid a issues with the latest version ([#13](https://github.com/fschuch/xcompact3d_toolbox/issues/13)ß), by [@fschuch](https://github.com/fschuch). +- Specified the version for netcdf4, to avoid issues with the latest version ([#13](https://github.com/fschuch/xcompact3d_toolbox/issues/13)), by [@fschuch](https://github.com/fschuch). ### Modified -- Support for parallel computing with dask was extended at `genepsi.gene_epsi_3D`, by [@fschuch](https://github.com/fschuch). +- Support for parallel computing with dask was extended at `xcompact3d_toolbox.genepsi.gene_epsi_3D`, by [@fschuch](https://github.com/fschuch). -## [1.1.0] - 2021-10-07 +## [1.1.0](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v1.1.0) - 2021-10-07 ### Added -- Add `sandbox.Geometry.from_stl`. It reads a `stl` file and is able to compute what mesh points are inside or outside the geometry, so we can specify the geometry for a very customized immersed boundary method. By [@fschuch](https://github.com/fschuch) and [@nbeb](https://github.com/nbeb). +- Add `sandbox.Geometry.from_stl`. It reads an `stl` file and can compute which mesh points are inside or outside the geometry, so we can specify the geometry for a very customized immersed boundary method. By [@fschuch](https://github.com/fschuch) and [@nbeb](https://github.com/nbeb). - Add `xcompact3d_toolbox.tutorial`, making it easier to get datasets for documentation and tutorials, by [@fschuch](https://github.com/fschuch). -- Add `xcompact3d_toolbox.Parameters.from_string`, an useful method to get the parameters from the datasets at the tutorials, by [@fschuch](https://github.com/fschuch). +- Add `xcompact3d_toolbox.Parameters.from_string`, a useful method to get the parameters from the datasets at the tutorials, by [@fschuch](https://github.com/fschuch). - Add tutorial *Computing and Plotting*, by [@fschuch](https://github.com/fschuch). - Add tutorial *Reading and writing files*, by [@fschuch](https://github.com/fschuch). ### Modified -- `io.Dataset.data_path` is now obtained automatically from `parameters.Parameter.filename` at initialization (i.g., if `filename = "./example/input.i3d"` then `data_path = "./example/data/"`). Of course, `data_path` can be changed to any value after that. By [@fschuch](https://github.com/fschuch). -- `io.Dataset.load_wind_turbine_data` now have a default location for `file_pattern`. Atributes were included for the coordinate time. By [@fschuch](https://github.com/fschuch). -- `io.Dataset.set` now accepts keyword arguments to send to `io.FilenameProperties.set`, for a more concise sintaxe. By [@fschuch](https://github.com/fschuch). -- The default return from `xcompact3d.param.boundary_condition` now takes in consideration if the domain is periodic or not, by [@fschuch](https://github.com/fschuch). +- Automatically obtain `io.Dataset.data_path` from `parameters.Parameter.filename` during initialization (e.g., if `filename = "./example/input.i3d"` then `data_path = "./example/data/"`). Of course, `data_path` can be changed to any value after that. By [@fschuch](https://github.com/fschuch). +- `io.Dataset.load_wind_turbine_data` now have a default location for `file_pattern`. Attributes were included for the coordinate time. By [@fschuch](https://github.com/fschuch). +- `io.Dataset.set` now accepts keyword arguments to send to `io.FilenameProperties.set`, for a more concise syntax. By [@fschuch](https://github.com/fschuch). +- The default return from `xcompact3d_toolbox.param.boundary_condition` now takes into consideration whether the domain is periodic or not, by [@fschuch](https://github.com/fschuch). ### Fixed -- `fix_bug` at [gene_epsi_3D](xcompact3d-toolbox/genepsi.py) was not working properly ([#3](https://github.com/fschuch/xcompact3d_toolbox/issues/3)), by [@fschuch](https://github.com/fschuch). +- `fix_bug` at `xcompact3d-toolbox.gene_epsi_3D` was not working properly ([#3](https://github.com/fschuch/xcompact3d_toolbox/issues/3)), by [@fschuch](https://github.com/fschuch). - `xcompact3d.io.Dataset.load_array` was not working for files that do not change in time, like `./data/geometry/epsilon.bin`, by [@fschuch](https://github.com/fschuch). -## [1.0.1] - 2021-09-23 +## [1.0.1](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v1.0.1) - 2021-09-23 ### Modified @@ -53,7 +59,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - `Black` version was not working properly at `setup.py`, by [@fschuch](https://github.com/fschuch). -## [1.0.0] - 2021-09-14 +## [1.0.0](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v1.0.0) - 2021-09-14 Xcompact3d-toolbox has evolved considerably in the last year. The pre-release version has been employed in CFD research projects, and the feedback from the users helped to improve its interfaces and functionalities. @@ -62,7 +68,7 @@ With this, Xcompact3d-toolbox is ready for its first stable release. ### Added -- Support for stretched mesh at the xdmf writer and automatized tests for it, by [@fschuch](https://github.com/fschuch). +- Support for stretched mesh at the xdmf writer and automated tests for it, by [@fschuch](https://github.com/fschuch). - A class to handle the binary filenames and its tests. Now all methods support different filenames, like the classic `ux000`, or the new `ux-0000.bin`, besides some combinations between them. By [@fschuch](https://github.com/fschuch). - Classes to handle the coordinates and their tests, so they can be moved out of the parameters class, by [@fschuch](https://github.com/fschuch). - New class for the 3D coordinate system, with useful methods and its testes, by [@fschuch](https://github.com/fschuch). @@ -83,13 +89,13 @@ With this, Xcompact3d-toolbox is ready for its first stable release. - Suppressed warning from `tqdm`, by [@fschuch](https://github.com/fschuch). - The output format from `gene_epsi_3D` has changed, fixing some compatibility issues with XCompact3d as well (see [#51](https://github.com/xcompact3d/Incompact3d/pull/51)), by [@fschuch](https://github.com/fschuch). -## [0.1.11] - 2021-02-12 +## [0.1.11](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v0.1.11) - 2021-02-12 ### Fixed - Fix #8, a little incompatibility problem with xcompact3d was fixed, by [@fschuch](https://github.com/fschuch). -## [0.1.10] - 2021-02-11 +## [0.1.10](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v0.1.10) - 2021-02-11 ### Added @@ -109,12 +115,12 @@ With this, Xcompact3d-toolbox is ready for its first stable release. - Fix #5, Bug at Ahmed body when using double precision, by [@fschuch](https://github.com/fschuch). - Fix #6, The files describing the geometry are incompatible when running on Linux, by [@fschuch](https://github.com/fschuch). -## [0.1.9] - 2020-10-09 +## [0.1.9](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v0.1.9) - 2020-10-09 ### Added - `get_boundary_condition` at class `Parameters`. It returns the appropriate boundary parameters that are -expected by the derivative functions. by [@fschuch](https://github.com/fschuch). + expected by the derivative functions. by [@fschuch](https://github.com/fschuch). - First and second derivatives for stretched mesh in y, by [@fschuch](https://github.com/fschuch). ### Changed @@ -125,25 +131,25 @@ expected by the derivative functions. by [@fschuch](https://github.com/fschuch). - First derivative was incorrect when `ncl1=1` and `ncln=2`. by [@fschuch](https://github.com/fschuch). -## [0.1.8] - 2020-09-29 +## [0.1.8](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v0.1.8) - 2020-09-29 ### Fixed - `param.mytype` was not updating properly [#4](https://github.com/fschuch/xcompact3d_toolbox/issues/4), by [@fschuch](https://github.com/fschuch). -## [0.1.7] - 2020-08-28 +## [0.1.7](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v0.1.7) - 2020-08-28 ### Fixed -- BC parameters at ([param.py](xcompact3d_toolbox\param.py)), by [@fschuch](https://github.com/fschuch). +- BC parameters at `xcompact3d_toolbox.param`, by [@fschuch](https://github.com/fschuch). -## [0.1.6] - 2020-08-28 +## [0.1.6](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v0.1.6) - 2020-08-28 ### Fixed -- [python-publish](.github/workflows/python-package.yml) action does not trigger if the release was first drafted, then published, by [@fschuch](https://github.com/fschuch). +- `.github/workflows/python-package.yml` action does not trigger if the release was first drafted, then published, by [@fschuch](https://github.com/fschuch). -## [0.1.5] - 2020-08-28 +## [0.1.5](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v0.1.5) - 2020-08-28 ### Added @@ -154,72 +160,56 @@ expected by the derivative functions. by [@fschuch](https://github.com/fschuch). - `get_mesh`, by [@fschuch](https://github.com/fschuch). - `write_xdmf`, by [@fschuch](https://github.com/fschuch). -## [0.1.4] - 2020-08-20 +## [0.1.4](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v0.1.4) - 2020-08-20 ### Added - [python-versioneer](https://github.com/warner/python-versioneer) removes the tedious and error-prone "update the embedded version string" step from our release process, by [@fschuch](https://github.com/fschuch). + - Docstrings for most classes, methods and functions, by [@fschuch](https://github.com/fschuch). + - Examples for Sandbox flow configuration (by [@fschuch](https://github.com/fschuch)): - - [Turbidity Current in Axisymmetric Configuration](docs\examples\Axisymmetric_flow.ipynb); - - [Flow Around a Complex Body](docs\examples\Cylinder.ipynb). + - Turbidity Current in Axisymmetric Configuration: `docs/examples/Axisymmetric_flow.ipynb`; + - Flow Around a Complex Body: `docs/examples/Cylinder.ipynb`. - Tutorials (by [@fschuch](https://github.com/fschuch)): - - [Parameters](docs\tutorial\parameters.ipynb). + - Parameters: `docs/tutorial/parameters.ipynb`. -- Integration with [Read the Docs](https://xcompact3d-toolbox.readthedocs.io/en/latest/), by [@fschuch](https://github.com/fschuch). +- Integration with [Read the Docs](https://xcompact3d-toolbox.readthedocs.io), by [@fschuch](https://github.com/fschuch). ### Changed - Code style changed to [black](https://github.com/psf/black), by [@fschuch](https://github.com/fschuch). -- `param = {'mytype': np.float64}` changed to just `mytype = float64` ([param.py](xcompact3d_toolbox\param.py)), by [@fschuch](https://github.com/fschuch). +- `param = {'mytype': np.float64}` changed to just `mytype = float64` in `xcompact3d_toolbox.param.py`, by [@fschuch](https://github.com/fschuch). -## [0.1.3] - 2020-08-17 +## [0.1.3](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v0.1.3) - 2020-08-17 No changes, just trying to get familiar with workflows and the release to Pypi. -## [0.1.2] - 2020-08-17 +## [0.1.2](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v0.1.2) - 2020-08-17 ### Added -- Unittest for observations and validations at [parameters.py](./xcompact3d_toolbox/parameters.py), by [@fschuch](https://github.com/fschuch). +- Unittest for observations and validations at `xcompact3d_toolbox.parameters`, by [@fschuch](https://github.com/fschuch). ### Changed - Temporarily disabling the link between parameters and their widgets (see [#2](https://github.com/fschuch/xcompact3d_toolbox/issues/2)), by [@fschuch](https://github.com/fschuch). -## [0.1.1] - 2020-08-14 +## [0.1.1](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v0.1.1) - 2020-08-14 No changes, just trying to get familiar with workflows and the release to Pypi. -## [0.0.0] - 2020-08-14 +## [0.0.0](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v0.0.0) - 2020-08-14 ### Added - CHANGELOG.md by [@fschuch](https://github.com/fschuch). - `class Parameters` built on top of [traitlets](https://traitlets.readthedocs.io/en/stable/index.html), for type checking, dynamically calculated default values, and ‘on change’ callbacks, by [@fschuch](https://github.com/fschuch). - [ipywidgets](https://ipywidgets.readthedocs.io/en/latest/) for all relevant parameters and two-ways linking with [traitlets](https://traitlets.readthedocs.io/en/stable/index.html) variables, by [@fschuch](https://github.com/fschuch). -- Accessors for [xarray](http://xarray.pydata.org/en/stable/)'s `Dataset` and `DataArray`, making possible high-order derivatives (with appropriated boundary conditions), I/O, parallel execution with pencil decomposition (powered by [dask](https://dask.org/)) and integration with `scipy.integrate.simps` and `scipy.integrate.cumtrapz`. By [@fschuch](https://github.com/fschuch). +- Accessors for [xarray](https://docs.xarray.dev/en/stable)'s `Dataset` and `DataArray`, making possible high-order derivatives (with appropriated boundary conditions), I/O, parallel execution with pencil decomposition (powered by [dask](https://dask.org/)) and integration with `scipy.integrate.simps` and `scipy.integrate.cumtrapz`. By [@fschuch](https://github.com/fschuch). - Ported genepsi.f90 to genepsi.py (powered by [Numba](http://numba.pydata.org/)), generating all the files necessary for our customized Immersed Boundary Method, by [@fschuch](https://github.com/fschuch). - Support to *Sandbox Flow Configuration* (see [fschuch/Xcompact3d](https://github.com/fschuch/Xcompact3d/)), by [@fschuch](https://github.com/fschuch). - Ahmed body as benchmark geometry, mirror and plotting tools, by [@momba98](https://github.com/momba98). - -[Unreleased]: https://github.com/fschuch/xcompact3d_toolbox/compare/v1.1.1...HEAD -[1.1.1]: https://github.com/fschuch/xcompact3d_toolbox/compare/v1.1.0...v1.1.1 -[1.1.0]: https://github.com/fschuch/xcompact3d_toolbox/compare/v1.0.1...v1.1.0 -[1.0.1]: https://github.com/fschuch/xcompact3d_toolbox/compare/v1.0.0...v1.0.1 -[1.0.0]: https://github.com/fschuch/xcompact3d_toolbox/compare/v0.1.11...v1.0.0 -[0.1.11]: https://github.com/fschuch/xcompact3d_toolbox/compare/v0.1.10...v0.1.11 -[0.1.10]: https://github.com/fschuch/xcompact3d_toolbox/compare/v0.1.9...v0.1.10 -[0.1.9]: https://github.com/fschuch/xcompact3d_toolbox/compare/v0.1.8...v0.1.9 -[0.1.8]: https://github.com/fschuch/xcompact3d_toolbox/compare/v0.1.7...v0.1.8 -[0.1.7]: https://github.com/fschuch/xcompact3d_toolbox/compare/v0.1.6...v0.1.7 -[0.1.6]: https://github.com/fschuch/xcompact3d_toolbox/compare/v0.1.5...v0.1.6 -[0.1.5]: https://github.com/fschuch/xcompact3d_toolbox/compare/v0.1.4...v0.1.5 -[0.1.4]: https://github.com/fschuch/xcompact3d_toolbox/compare/v0.1.3...v0.1.4 -[0.1.3]: https://github.com/fschuch/xcompact3d_toolbox/compare/v0.1.2...v0.1.3 -[0.1.2]: https://github.com/fschuch/xcompact3d_toolbox/compare/v0.1.1...v0.1.2 -[0.1.1]: https://github.com/fschuch/xcompact3d_toolbox/compare/v0.0.0...v0.1.1 -[0.0.0]: https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v0.0.0 diff --git a/docs/references.bib b/docs/references.bib new file mode 100644 index 0000000..a845151 --- /dev/null +++ b/docs/references.bib @@ -0,0 +1,2 @@ +--- +--- diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 0000000..280636d --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,584 @@ +# +# This file is autogenerated by hatch-pip-compile with Python 3.12 +# +# - docutils +# - ipykernel +# - jupyter-book +# - nbsphinx +# - pooch +# - sphinx-autobuild +# - sphinx-rtd-theme +# - sphinx>=1.4 +# - dask[complete]>=2.22 +# - ipywidgets>=7.5 +# - loguru>=0.6 +# - netcdf4>=1.6.3 +# - numba>=0.50 +# - numpy-stl>=2.16.3 +# - numpy>=1.22 +# - pandas>=1.1 +# - scipy>=1.5 +# - tqdm>=4.62 +# - traitlets>=4.3 +# - xarray>=0.16 +# - bokeh>=2.3 +# - datashader>=0.13 +# - holoviews>=1.14 +# - hvplot>=0.7 +# - matplotlib>=3.2 +# - panel>=0.12 +# + +accessible-pygments==0.0.4 + # via pydata-sphinx-theme +alabaster==0.7.16 + # via sphinx +appnope==0.1.4 + # via ipykernel +asttokens==2.4.1 + # via stack-data +attrs==23.2.0 + # via + # jsonschema + # jupyter-cache + # referencing +babel==2.14.0 + # via + # pydata-sphinx-theme + # sphinx +beautifulsoup4==4.12.3 + # via + # nbconvert + # pydata-sphinx-theme +bleach==6.1.0 + # via + # nbconvert + # panel +bokeh==3.3.4 + # via + # hatch.envs.docs + # dask + # hvplot + # panel +certifi==2024.2.2 + # via + # netcdf4 + # requests +cftime==1.6.3 + # via netcdf4 +charset-normalizer==3.3.2 + # via requests +click==8.1.7 + # via + # dask + # distributed + # jupyter-book + # jupyter-cache + # sphinx-external-toc +cloudpickle==3.0.0 + # via + # dask + # distributed +colorama==0.4.6 + # via sphinx-autobuild +colorcet==3.1.0 + # via + # datashader + # holoviews + # hvplot +comm==0.2.1 + # via + # ipykernel + # ipywidgets +contourpy==1.2.0 + # via + # bokeh + # matplotlib +cycler==0.12.1 + # via matplotlib +dask==2024.2.1 + # via + # hatch.envs.docs + # datashader + # distributed +datashader==0.16.0 + # via hatch.envs.docs +debugpy==1.8.1 + # via ipykernel +decorator==5.1.1 + # via ipython +defusedxml==0.7.1 + # via nbconvert +distributed==2024.2.1 + # via dask +docutils==0.20.1 + # via + # hatch.envs.docs + # myst-parser + # nbsphinx + # pybtex-docutils + # pydata-sphinx-theme + # sphinx + # sphinx-rtd-theme + # sphinx-togglebutton + # sphinxcontrib-bibtex +executing==2.0.1 + # via stack-data +fastjsonschema==2.19.1 + # via nbformat +fonttools==4.49.0 + # via matplotlib +fsspec==2024.2.0 + # via dask +holoviews==1.18.3 + # via + # hatch.envs.docs + # hvplot +hvplot==0.9.2 + # via hatch.envs.docs +idna==3.6 + # via requests +imagesize==1.4.1 + # via sphinx +importlib-metadata==7.0.1 + # via + # dask + # jupyter-cache + # myst-nb +ipykernel==6.29.3 + # via + # hatch.envs.docs + # myst-nb +ipython==8.22.1 + # via + # ipykernel + # ipywidgets + # myst-nb +ipywidgets==8.1.2 + # via hatch.envs.docs +jedi==0.19.1 + # via ipython +jinja2==3.1.3 + # via + # bokeh + # dask + # distributed + # jupyter-book + # myst-parser + # nbconvert + # nbsphinx + # sphinx +jsonschema==4.21.1 + # via + # jupyter-book + # nbformat +jsonschema-specifications==2023.12.1 + # via jsonschema +jupyter-book==1.0.0 + # via hatch.envs.docs +jupyter-cache==1.0.0 + # via myst-nb +jupyter-client==8.6.0 + # via + # ipykernel + # nbclient +jupyter-core==5.7.1 + # via + # ipykernel + # jupyter-client + # nbclient + # nbconvert + # nbformat +jupyterlab-pygments==0.3.0 + # via nbconvert +jupyterlab-widgets==3.0.10 + # via ipywidgets +kiwisolver==1.4.5 + # via matplotlib +latexcodec==2.0.1 + # via pybtex +linkify-it-py==2.0.3 + # via + # jupyter-book + # panel +livereload==2.6.3 + # via sphinx-autobuild +llvmlite==0.42.0 + # via numba +locket==1.0.0 + # via + # distributed + # partd +loguru==0.7.2 + # via hatch.envs.docs +lz4==4.3.3 + # via dask +markdown==3.5.2 + # via panel +markdown-it-py==3.0.0 + # via + # mdit-py-plugins + # myst-parser + # panel +markupsafe==2.1.5 + # via + # jinja2 + # nbconvert +matplotlib==3.8.3 + # via hatch.envs.docs +matplotlib-inline==0.1.6 + # via + # ipykernel + # ipython +mdit-py-plugins==0.4.0 + # via + # myst-parser + # panel +mdurl==0.1.2 + # via markdown-it-py +mistune==3.0.2 + # via nbconvert +msgpack==1.0.8 + # via distributed +multipledispatch==1.0.0 + # via datashader +myst-nb==1.0.0 + # via jupyter-book +myst-parser==2.0.0 + # via + # jupyter-book + # myst-nb +nbclient==0.9.0 + # via + # jupyter-cache + # myst-nb + # nbconvert +nbconvert==7.16.1 + # via nbsphinx +nbformat==5.9.2 + # via + # jupyter-cache + # myst-nb + # nbclient + # nbconvert + # nbsphinx +nbsphinx==0.9.3 + # via hatch.envs.docs +nest-asyncio==1.6.0 + # via ipykernel +netcdf4==1.6.5 + # via hatch.envs.docs +numba==0.59.0 + # via + # hatch.envs.docs + # datashader +numpy==1.26.4 + # via + # hatch.envs.docs + # bokeh + # cftime + # contourpy + # dask + # datashader + # holoviews + # hvplot + # matplotlib + # netcdf4 + # numba + # numpy-stl + # pandas + # pyarrow + # scipy + # xarray +numpy-stl==3.1.1 + # via hatch.envs.docs +packaging==23.2 + # via + # bokeh + # dask + # distributed + # holoviews + # hvplot + # ipykernel + # matplotlib + # nbconvert + # pooch + # pydata-sphinx-theme + # sphinx + # sphinx-jupyterbook-latex + # xarray +pandas==2.2.1 + # via + # hatch.envs.docs + # bokeh + # dask + # datashader + # holoviews + # hvplot + # panel + # xarray +pandocfilters==1.5.1 + # via nbconvert +panel==1.3.8 + # via + # hatch.envs.docs + # holoviews + # hvplot +param==2.0.2 + # via + # datashader + # holoviews + # hvplot + # panel + # pyct + # pyviz-comms +parso==0.8.3 + # via jedi +partd==1.4.1 + # via dask +pexpect==4.9.0 + # via ipython +pillow==10.2.0 + # via + # bokeh + # datashader + # matplotlib +platformdirs==4.2.0 + # via + # jupyter-core + # pooch +pooch==1.8.1 + # via hatch.envs.docs +prompt-toolkit==3.0.43 + # via ipython +psutil==5.9.8 + # via + # distributed + # ipykernel +ptyprocess==0.7.0 + # via pexpect +pure-eval==0.2.2 + # via stack-data +pyarrow==15.0.0 + # via dask +pyarrow-hotfix==0.6 + # via dask +pybtex==0.24.0 + # via + # pybtex-docutils + # sphinxcontrib-bibtex +pybtex-docutils==1.0.3 + # via sphinxcontrib-bibtex +pyct==0.5.0 + # via datashader +pydata-sphinx-theme==0.15.2 + # via sphinx-book-theme +pygments==2.17.2 + # via + # accessible-pygments + # ipython + # nbconvert + # pydata-sphinx-theme + # sphinx +pyparsing==3.1.1 + # via matplotlib +python-dateutil==2.9.0 + # via + # jupyter-client + # matplotlib + # pandas +python-utils==3.8.2 + # via numpy-stl +pytz==2024.1 + # via pandas +pyviz-comms==3.0.1 + # via + # holoviews + # panel +pyyaml==6.0.1 + # via + # bokeh + # dask + # distributed + # jupyter-book + # jupyter-cache + # myst-nb + # myst-parser + # pybtex + # sphinx-external-toc +pyzmq==25.1.2 + # via + # ipykernel + # jupyter-client +referencing==0.33.0 + # via + # jsonschema + # jsonschema-specifications +requests==2.31.0 + # via + # datashader + # panel + # pooch + # sphinx +rpds-py==0.18.0 + # via + # jsonschema + # referencing +scipy==1.12.0 + # via + # hatch.envs.docs + # datashader +six==1.16.0 + # via + # asttokens + # bleach + # latexcodec + # livereload + # pybtex + # python-dateutil +snowballstemmer==2.2.0 + # via sphinx +sortedcontainers==2.4.0 + # via distributed +soupsieve==2.5 + # via beautifulsoup4 +sphinx==7.2.6 + # via + # hatch.envs.docs + # jupyter-book + # myst-nb + # myst-parser + # nbsphinx + # pydata-sphinx-theme + # sphinx-autobuild + # sphinx-book-theme + # sphinx-comments + # sphinx-copybutton + # sphinx-design + # sphinx-external-toc + # sphinx-jupyterbook-latex + # sphinx-multitoc-numbering + # sphinx-rtd-theme + # sphinx-thebe + # sphinx-togglebutton + # sphinxcontrib-bibtex + # sphinxcontrib-jquery +sphinx-autobuild==2024.2.4 + # via hatch.envs.docs +sphinx-book-theme==1.1.2 + # via jupyter-book +sphinx-comments==0.0.3 + # via jupyter-book +sphinx-copybutton==0.5.2 + # via jupyter-book +sphinx-design==0.5.0 + # via jupyter-book +sphinx-external-toc==1.0.1 + # via jupyter-book +sphinx-jupyterbook-latex==1.0.0 + # via jupyter-book +sphinx-multitoc-numbering==0.1.3 + # via jupyter-book +sphinx-rtd-theme==2.0.0 + # via hatch.envs.docs +sphinx-thebe==0.3.1 + # via jupyter-book +sphinx-togglebutton==0.3.2 + # via jupyter-book +sphinxcontrib-applehelp==1.0.8 + # via sphinx +sphinxcontrib-bibtex==2.6.2 + # via jupyter-book +sphinxcontrib-devhelp==1.0.6 + # via sphinx +sphinxcontrib-htmlhelp==2.0.5 + # via sphinx +sphinxcontrib-jquery==4.1 + # via sphinx-rtd-theme +sphinxcontrib-jsmath==1.0.1 + # via sphinx +sphinxcontrib-qthelp==1.0.7 + # via sphinx +sphinxcontrib-serializinghtml==1.1.10 + # via sphinx +sqlalchemy==2.0.27 + # via jupyter-cache +stack-data==0.6.3 + # via ipython +tabulate==0.9.0 + # via jupyter-cache +tblib==3.0.0 + # via distributed +tinycss2==1.2.1 + # via nbconvert +toolz==0.12.1 + # via + # dask + # datashader + # distributed + # partd +tornado==6.4 + # via + # bokeh + # distributed + # ipykernel + # jupyter-client + # livereload +tqdm==4.66.2 + # via + # hatch.envs.docs + # panel +traitlets==5.14.1 + # via + # hatch.envs.docs + # comm + # ipykernel + # ipython + # ipywidgets + # jupyter-client + # jupyter-core + # matplotlib-inline + # nbclient + # nbconvert + # nbformat + # nbsphinx +typing-extensions==4.10.0 + # via + # myst-nb + # panel + # pydata-sphinx-theme + # python-utils + # sqlalchemy +tzdata==2024.1 + # via pandas +uc-micro-py==1.0.3 + # via linkify-it-py +urllib3==2.2.1 + # via + # distributed + # requests +wcwidth==0.2.13 + # via prompt-toolkit +webencodings==0.5.1 + # via + # bleach + # tinycss2 +wheel==0.42.0 + # via sphinx-togglebutton +widgetsnbextension==4.0.10 + # via ipywidgets +xarray==2024.2.0 + # via + # hatch.envs.docs + # datashader +xyzservices==2023.10.1 + # via + # bokeh + # panel +zict==3.0.0 + # via distributed +zipp==3.17.0 + # via importlib-metadata + +# The following packages are considered to be unsafe in a requirements file: +# setuptools diff --git a/docs/tutorial.rst b/docs/tutorial.rst deleted file mode 100644 index b4ad508..0000000 --- a/docs/tutorial.rst +++ /dev/null @@ -1,18 +0,0 @@ -Tutorials ------------------ - -.. toctree:: - - tutorial/parameters.ipynb - tutorial/io.ipynb - tutorial/computing_and_plotting.ipynb - -Sandbox Examples ------------------ - -.. toctree:: - - examples/Axisymmetric_flow.ipynb - examples/Cylinder.ipynb - examples/Square.ipynb - examples/Heat-exchanger.ipynb diff --git a/docs/tutorial/computing_and_plotting.ipynb b/docs/tutorial/computing_and_plotting.ipynb index b4c9ed5..e1fecb8 100644 --- a/docs/tutorial/computing_and_plotting.ipynb +++ b/docs/tutorial/computing_and_plotting.ipynb @@ -2,720 +2,799 @@ "cells": [ { "cell_type": "markdown", + "id": "0", + "metadata": {}, "source": [ "# Computing and Plotting" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "1", + "metadata": {}, "source": [ "This tutorial includes an overview of the different ways available to compute, select data and plot using the xarray objects that are provided by xcompact3d-toolbox." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "2", + "metadata": {}, "source": [ "The very first step is to import the toolbox and other packages:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "3", + "metadata": {}, + "outputs": [], "source": [ - "import hvplot.xarray\r\n", - "import matplotlib.pyplot as plt\r\n", - "import numpy as np\r\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", "import xcompact3d_toolbox as x3d" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "4", + "metadata": {}, "source": [ - "## Why xarray?\r\n", - "\r\n", - "The data structures are provided by [xarray](http://xarray.pydata.org/en/stable/index.html), that introduces labels in the form of dimensions, coordinates and attributes on top of raw NumPy-like arrays, which allows for a more intuitive, more concise, and less error-prone developer experience.\r\n", - "It integrates tightly with [dask](https://dask.org/) for parallel computing.\r\n", - "\r\n", - "The goal here is to speed up the development of customized post-processing applications with the concise interface provided by [xarray](http://xarray.pydata.org/en/stable/index.html). Ultimately, we can compute solutions with fewer lines of code and better readability, so we expend less time testing and debugging and more time exploring our datasets and getting insights.\r\n", - "\r\n", - "Additionally, xcompact3d-toolbox includes extra functionalities for [DataArray](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataArray) and [Dataset](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataset).\r\n", - "\r\n", - "Before going forward, please, take a look at [Overview: Why xarray?](http://xarray.pydata.org/en/stable/getting-started-guide/why-xarray.html) and [Quick overview](http://xarray.pydata.org/en/stable/getting-started-guide/quick-overview.html) to understand the motivation to use [xarray](http://xarray.pydata.org/en/stable/index.html)'s data structures instead of just numpy-like arrays." - ], - "metadata": {} + "## Why xarray?\n", + "\n", + "The data structures are provided by [xarray](http://docs.xarray.dev/en/stable/index.html), that introduces labels in the form of dimensions, coordinates and attributes on top of raw NumPy-like arrays, which allows for a more intuitive, more concise, and less error-prone developer experience.\n", + "It integrates tightly with [dask](https://dask.org/) for parallel computing.\n", + "\n", + "The goal here is to speed up the development of customized post-processing applications with the concise interface provided by [xarray](http://docs.xarray.dev/en/stable/index.html). Ultimately, we can compute solutions with fewer lines of code and better readability, so we expend less time testing and debugging and more time exploring our datasets and getting insights.\n", + "\n", + "Additionally, xcompact3d-toolbox includes extra functionalities for [DataArray](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataArray) and [Dataset](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataset).\n", + "\n", + "Before going forward, please, take a look at [Overview: Why xarray?](http://docs.xarray.dev/en/stable/getting-started-guide/why-xarray.html) and [Quick overview](http://docs.xarray.dev/en/stable/getting-started-guide/quick-overview.html) to understand the motivation to use [xarray](http://docs.xarray.dev/en/stable/index.html)'s data structures instead of just numpy-like arrays." + ] }, { "cell_type": "markdown", + "id": "5", + "metadata": {}, "source": [ "## Example - Flow around a cylinder" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "6", + "metadata": {}, "source": [ - "We can download the example from the [online database](https://github.com/fschuch/xcompact3d_toolbox_data), the flow around a cylinder in this case.\r\n", + "We can download the example from the [online database](https://github.com/fschuch/xcompact3d_toolbox_data), the flow around a cylinder in this case.\n", "We set `cache=True` and a local destination where it can be saved in our computer `cache_dir=\"./example/\"`, so there is no need to download it every time the kernel is restarted." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "7", + "metadata": {}, + "outputs": [], "source": [ "dataset, prm = x3d.tutorial.open_dataset(\"cylinder\", cache=True, cache_dir=\"./example/\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "8", + "metadata": {}, "source": [ "Notice there is an entire [tutorial dedicated to the parameters file](https://xcompact3d-toolbox.readthedocs.io/en/stable/tutorial/parameters.html). Now, let's take a look at the dataset:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "9", + "metadata": {}, + "outputs": [], "source": [ "dataset" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "10", + "metadata": {}, "source": [ - "We got a [xarray.Dataset](http://xarray.pydata.org/en/stable/generated/xarray.Dataset.html#xarray.Dataset) with the variables `u` (velocity vector), `pp` (pressure) and `epsi` (that describes the geometry), their coordinates (`x`, `y`, `t` and `i`) and some atributes like the `xcompact3d_version` used to run this simulation, the `url` where you can find the dataset and others.\r\n", - "\r\n", + "We got a [xarray.Dataset](http://docs.xarray.dev/en/stable/generated/xarray.Dataset.html#xarray.Dataset) with the variables `u` (velocity vector), `pp` (pressure) and `epsi` (that describes the geometry), their coordinates (`x`, `y`, `t` and `i`) and some attributes like the `xcompact3d_version` used to run this simulation, the `url` where you can find the dataset and others.\n", + "\n", "We can access each of the variables or coordinates with the dot notation (i.g., `snapshot.pp`, `snapshot.u`, `snapshot.x`) or the dict-like notation (i.g., `snapshot[\"pp\"]`, `snapshot[\"u\"]`, `snapshot[\"x\"]`)." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "11", + "metadata": {}, "source": [ - "Once the arrays are wrapped with their coordinates, we can use xarray's plotting functionality to explore our data with just a few lines of code.\r\n", - "\r\n", - "Starting with `epsi`, that represents the geometry (it is 1 inside the cylinder and 0 outside), we select it from the dataset and then use the method [plot](http://xarray.pydata.org/en/stable/generated/xarray.DataArray.plot.html):" - ], - "metadata": {} + "Once the arrays are wrapped with their coordinates, we can use xarray's plotting functionality to explore our data with just a few lines of code.\n", + "\n", + "Starting with `epsi`, that represents the geometry (it is 1 inside the cylinder and 0 outside), we select it from the dataset and then use the method [plot](http://docs.xarray.dev/en/stable/generated/xarray.DataArray.plot.html):" + ] }, { "cell_type": "code", "execution_count": null, + "id": "12", + "metadata": {}, + "outputs": [], "source": [ "dataset.epsi.plot()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "13", + "metadata": {}, "source": [ - "The array in the example was two-dimensional, in this case `.plot()` automatically calls [xarray.plot.pcolormesh()](http://xarray.pydata.org/en/stable/generated/xarray.plot.pcolormesh.html#xarray.plot.pcolormesh).\r\n", - "\r\n", - "There are many options to customize the plots, besides that, xarray plotting functionality is a thin wrapper around the popular [matplotlib](https://matplotlib.org/) library.\r\n", - "\r\n", + "The array in the example was two-dimensional, in this case `.plot()` automatically calls [xarray.plot.pcolormesh()](http://docs.xarray.dev/en/stable/generated/xarray.plot.pcolormesh.html#xarray.plot.pcolormesh).\n", + "\n", + "There are many options to customize the plots, besides that, xarray plotting functionality is a thin wrapper around the popular [matplotlib](https://matplotlib.org/) library.\n", + "\n", "To improve the figure, let's set the x-axis of the plot as the coordinate `x` of our array, same for `y`. Then let's use matplotlib to set the axis aspect to `equal`. Take a look:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "14", + "metadata": {}, + "outputs": [], "source": [ - "ax = dataset.epsi.plot(x=\"x\", y=\"y\")\r\n", + "ax = dataset.epsi.plot(x=\"x\", y=\"y\")\n", "ax.axes.set_aspect(\"equal\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "15", + "metadata": {}, "source": [ - "It might be important in the cylinder case to ignore the values that are inside the solid cylinder when plotting or computing any quantity.\r\n", - "We can do it by preserving the values of `u` and `pp` where `epsi` is equal to zero, and setting the values to `np.NaN` otherwise.\r\n", - "\r\n", - "[xarray.Dataset.where](http://xarray.pydata.org/en/stable/generated/xarray.Dataset.where.html) is a handy method for that, take a look:" - ], - "metadata": {} + "It might be important in the cylinder case to ignore the values that are inside the solid cylinder when plotting or computing any quantity.\n", + "We can do it by preserving the values of `u` and `pp` where `epsi` is equal to zero, and setting the values to `np.NaN` otherwise.\n", + "\n", + "[xarray.Dataset.where](http://docs.xarray.dev/en/stable/generated/xarray.Dataset.where.html) is a handy method for that, take a look:" + ] }, { "cell_type": "code", "execution_count": null, + "id": "16", + "metadata": {}, + "outputs": [], "source": [ - "for var in [\"u\", \"pp\"]:\r\n", + "for var in [\"u\", \"pp\"]:\n", " dataset[var] = dataset[var].where(dataset.epsi == 0.0, np.NaN)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "17", + "metadata": {}, "source": [ - "Have you noticed that we are doing this comparison between variables with different dimensions, and it just worked? I mean, `epsi` is 2D (x, y), `pp` is 3D (x, y, t) and `u` is 4D (i, x, y, t).\r\n", + "Have you noticed that we are doing this comparison between variables with different dimensions, and it just worked? I mean, `epsi` is 2D (x, y), `pp` is 3D (x, y, t) and `u` is 4D (i, x, y, t).\n", "That is because xarray automatically broadcasted the values of `epsi` to each point at the coordinates `t` and `i`." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "18", + "metadata": {}, "source": [ - "Another cool feature of xarray is that we can select data based on the actual value of its coordinates, not only on the integer indexes used for selection on numpy-like arrays.\r\n", - "\r\n", - "To exemplify, let's [select](http://xarray.pydata.org/en/stable/generated/xarray.Dataset.sel.html) one position at the same heigh of the cylinder, but a bit downstream. Note we can get the time evolution for all variables at this specified point:" - ], - "metadata": {} + "Another cool feature of xarray is that we can select data based on the actual value of its coordinates, not only on the integer indexes used for selection on numpy-like arrays.\n", + "\n", + "To exemplify, let's [select](http://docs.xarray.dev/en/stable/generated/xarray.Dataset.sel.html) one position at the same height of the cylinder, but a bit downstream. Note we can get the time evolution for all variables at this specified point:" + ] }, { "cell_type": "code", "execution_count": null, + "id": "19", + "metadata": {}, + "outputs": [], "source": [ "dataset.sel(x=10.0, y=6.0, method=\"nearest\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "20", + "metadata": {}, "source": [ - "We can chain the methods, selecting a variable, [selecting](http://xarray.pydata.org/en/stable/generated/xarray.DataArray.sel.html) a point in the domain and doing a [plot](http://xarray.pydata.org/en/stable/generated/xarray.DataArray.plot.html), all with just one line of code:" - ], - "metadata": {} + "We can chain the methods, selecting a variable, [selecting](http://docs.xarray.dev/en/stable/generated/xarray.DataArray.sel.html) a point in the domain and doing a [plot](http://docs.xarray.dev/en/stable/generated/xarray.DataArray.plot.html), all with just one line of code:" + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "dataset.u.sel(x=10.0, y=6.0, method=\"nearest\").plot(x=\"t\", hue=\"i\");" - ], + "id": "21", + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "dataset.u.sel(x=10.0, y=6.0, method=\"nearest\").plot(x=\"t\", hue=\"i\")" + ] }, { "cell_type": "markdown", + "id": "22", + "metadata": {}, "source": [ - "Note this time the data was 1D, so the plot was handled internally by [xarray.plot.line](http://xarray.pydata.org/en/stable/generated/xarray.plot.line.html#xarray.plot.line)." - ], - "metadata": {} + "Note this time the data was 1D, so the plot was handled internally by [xarray.plot.line](http://docs.xarray.dev/en/stable/generated/xarray.plot.line.html#xarray.plot.line)." + ] }, { "cell_type": "markdown", + "id": "23", + "metadata": {}, "source": [ - "To give you another example, let's plot the time-[averaged](http://xarray.pydata.org/en/stable/generated/xarray.DataArray.mean.html) ($60 \\le t \\le 150$) vertical velocity profile where $x=10$:" - ], - "metadata": {} + "To give you another example, let's plot the time-[averaged](http://docs.xarray.dev/en/stable/generated/xarray.DataArray.mean.html) ($60 \\le t \\le 150$) vertical velocity profile where $x=10$:" + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "dataset.u.sel(x=10.0, t=slice(60.0, 150.0)).mean(\"t\").plot(y=\"y\", hue=\"i\");" - ], + "id": "24", + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "dataset.u.sel(x=10.0, t=slice(60.0, 150.0)).mean(\"t\").plot(y=\"y\", hue=\"i\")" + ] }, { "cell_type": "markdown", + "id": "25", + "metadata": {}, "source": [ - "As you saw, we can refer to the coordinates by their name when working with xarray, instead of keeping track of their axis number.\r\n", - "\r\n", - "To extend this concept, let's now compute the time evolution of the kinetic energy. It is given by the equation:\r\n", - "\r\n", - "$$\r\n", - "k = \\int_V \\dfrac{u_iu_i}{2} dV.\r\n", - "$$\r\n", - "\r\n", + "As you saw, we can refer to the coordinates by their name when working with xarray, instead of keeping track of their axis number.\n", + "\n", + "To extend this concept, let's now compute the time evolution of the kinetic energy. It is given by the equation:\n", + "\n", + "$$\n", + "k = \\int_V \\dfrac{u_iu_i}{2} dV.\n", + "$$\n", + "\n", "Now the code:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "dataset[\"kinetic_energy\"] = ((dataset.u ** 2.0).sum(\"i\").x3d.simps(\"x\", \"y\")) * 0.5\r\n", - "dataset[\"kinetic_energy\"].attrs = dict(name=\"k\", long_name=\"kinetic Energy\", units=\"-\")\r\n", - "dataset[\"kinetic_energy\"].plot();" - ], + "id": "26", + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "dataset[\"kinetic_energy\"] = ((dataset.u**2.0).sum(\"i\").x3d.simps(\"x\", \"y\")) * 0.5\n", + "dataset[\"kinetic_energy\"].attrs = {\"name\": \"k\", \"long_name\": \"kinetic Energy\", \"units\": \"-\"}\n", + "dataset[\"kinetic_energy\"].plot()" + ] }, { "cell_type": "markdown", + "id": "27", + "metadata": {}, "source": [ - "In the code above we:\r\n", - "\r\n", - "* Solved the equation for the entire time series with a very readable code. A good point is that it worked for the `xy` planes in the dataset in this example, and all we need to do to run it in a real 3D case is include `z` at the integration;\r\n", - "\r\n", - "* Included attributes to describe what we just computed, making our application easier to share and collaborate. As a bonus, they were automatically included in the plot;\r\n", - "\r\n", + "In the code above we:\n", + "\n", + "* Solved the equation for the entire time series with a very readable code. A good point is that it worked for the `xy` planes in the dataset in this example, and all we need to do to run it in a real 3D case is include `z` at the integration;\n", + "\n", + "* Included attributes to describe what we just computed, making our application easier to share and collaborate. As a bonus, they were automatically included in the plot;\n", + "\n", "* Plotted the results." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "28", + "metadata": {}, "source": [ "We can use a quick [list comprehension](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions) to get the dimensions for the volumetric integration:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "29", + "metadata": {}, + "outputs": [], "source": [ - "V_coords = [dim for dim in dataset.u.coords if dim in \"xyz\"]\r\n", + "V_coords = [dim for dim in dataset.u.coords if dim in \"xyz\"]\n", "V_coords" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "30", + "metadata": {}, "source": [ "and rewrite the previous example to make it more robust, now it works for n-dimensional cases:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "dataset[\"kinetic_energy\"] = ((dataset.u ** 2.0).sum(\"i\").x3d.simps(*V_coords)) * 0.5\r\n", - "dataset[\"kinetic_energy\"].attrs = dict(name=\"k\", long_name=\"kinetic Energy\", units=\"-\")" - ], + "id": "31", + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "dataset[\"kinetic_energy\"] = ((dataset.u**2.0).sum(\"i\").x3d.simps(*V_coords)) * 0.5\n", + "dataset[\"kinetic_energy\"].attrs = {\"name\": \"k\", \"long_name\": \"kinetic Energy\", \"units\": \"-\"}" + ] }, { "cell_type": "markdown", + "id": "32", + "metadata": {}, "source": [ - "Going back to 2D plots, let's take the velocity vector `u`, select it for $60 \\le t \\le 150$ ([sel](http://xarray.pydata.org/en/stable/generated/xarray.DataArray.sel.html)), compute a time average ([mean](https://xarray.pydata.org/en/stable/generated/xarray.DataArray.mean.html)) and [plot](https://xarray.pydata.org/en/stable/generated/xarray.DataArray.plot.html):" - ], - "metadata": {} + "Going back to 2D plots, let's take the velocity vector `u`, select it for $60 \\le t \\le 150$ ([sel](http://docs.xarray.dev/en/stable/generated/xarray.DataArray.sel.html)), compute a time average ([mean](https://docs.xarray.dev/en/stablegenerated/xarray.DataArray.mean.html)) and [plot](https://docs.xarray.dev/en/stablegenerated/xarray.DataArray.plot.html):" + ] }, { "cell_type": "code", "execution_count": null, + "id": "33", + "metadata": {}, + "outputs": [], "source": [ - "g = dataset.u.sel(t=slice(60.0, 150.0)).mean(\"t\").plot(\r\n", - " x=\"x\", y=\"y\", row=\"i\", cmap=\"turbo\", rasterized=True\r\n", - ")\r\n", - "for ax in g.axes.flat:\r\n", + "g = dataset.u.sel(t=slice(60.0, 150.0)).mean(\"t\").plot(x=\"x\", y=\"y\", row=\"i\", cmap=\"turbo\", rasterized=True)\n", + "for ax in g.axes.flat:\n", " ax.axes.set_aspect(\"equal\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "34", + "metadata": {}, "source": [ - "Do you want to see the time evolution? No problem. Let's take the velocity vector `u`, use [isel](https://xarray.pydata.org/en/stable/generated/xarray.DataArray.isel.html) with a [slice](https://docs.python.org/3/library/functions.html#slice) selecting every 40 points in time (otherwise we would get too many figures), and [plot](https://xarray.pydata.org/en/stable/generated/xarray.DataArray.plot.html):" - ], - "metadata": {} + "Do you want to see the time evolution? No problem. Let's take the velocity vector `u`, use [isel](https://docs.xarray.dev/en/stablegenerated/xarray.DataArray.isel.html) with a [slice](https://docs.python.org/3/library/functions.html#slice) selecting every 40 points in time (otherwise we would get too many figures), and [plot](https://docs.xarray.dev/en/stablegenerated/xarray.DataArray.plot.html):" + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "g = dataset.u.isel(t=slice(None, None, 40)).plot(\r\n", - " x=\"x\", y=\"y\", col=\"t\", row=\"i\", cmap=\"turbo\", rasterized=True\r\n", - ")\r\n", - "\r\n", - "for ax in g.axes.flat:\r\n", - " ax.axes.set_aspect(\"equal\")" - ], - "outputs": [], + "id": "35", "metadata": { "tags": [] - } + }, + "outputs": [], + "source": [ + "g = dataset.u.isel(t=slice(None, None, 40)).plot(x=\"x\", y=\"y\", col=\"t\", row=\"i\", cmap=\"turbo\", rasterized=True)\n", + "\n", + "for ax in g.axes.flat:\n", + " ax.axes.set_aspect(\"equal\")" + ] }, { "cell_type": "markdown", + "id": "36", + "metadata": {}, "source": [ "To exemplify differentiation and parallel computing capabilities, let's compute the vorticity for our dataset. We just have one component for this 2D example, it is given by the equation:" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "37", + "metadata": {}, "source": [ - "$$\r\n", - "\\omega_z = \\dfrac{\\partial u_y}{\\partial x} - \\dfrac{\\partial u_x}{\\partial y}.\r\n", + "$$\n", + "\\omega_z = \\dfrac{\\partial u_y}{\\partial x} - \\dfrac{\\partial u_x}{\\partial y}.\n", "$$" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "38", + "metadata": {}, "source": [ - "We can use [xarray.DataArray.differentiate](http://xarray.pydata.org/en/stable/generated/xarray.DataArray.differentiate.html) just out of the box with its second order accurate central differences. However, we can use the 4th order accurate centered scheme available at [X3dDataArray.first_derivative](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataArray.first_derivative)." - ], - "metadata": {} + "We can use [xarray.DataArray.differentiate](http://docs.xarray.dev/en/stable/generated/xarray.DataArray.differentiate.html) just out of the box with its second order accurate central differences. However, we can use the 4th order accurate centered scheme available at [X3dDataArray.first_derivative](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataArray.first_derivative)." + ] }, { "cell_type": "markdown", + "id": "39", + "metadata": {}, "source": [ "We start setting the attribute boundary conditions (`BC`) for the velocity field:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "40", + "metadata": {}, + "outputs": [], "source": [ "dataset[\"u\"].attrs[\"BC\"] = prm.get_boundary_condition(\"u\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "41", + "metadata": {}, "source": [ "and then we compute the vorticity:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "%%time\r\n", - "dataset[\"vort\"] = (\r\n", - " dataset.u.sel(i=\"y\").x3d.first_derivative(\"x\")\r\n", - " - dataset.u.sel(i=\"x\").x3d.first_derivative(\"y\")\r\n", - ")" - ], + "id": "42", + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "%%time\n", + "dataset[\"vort\"] = dataset.u.sel(i=\"y\").x3d.first_derivative(\"x\") - dataset.u.sel(i=\"x\").x3d.first_derivative(\"y\")" + ] }, { "cell_type": "markdown", + "id": "43", + "metadata": {}, "source": [ "Notice the equation above computed the vorticity for the entire time series in our dataset." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "44", + "metadata": {}, "source": [ - "We can use [X3dDataArray.pencil_decomp](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataArray.pencil_decomp) to coarse the velocity array to a dask array, ready for parallel computing (see [Using Dask with xarray](http://xarray.pydata.org/en/stable/user-guide/dask.html#using-dask-with-xarray)).\r\n", - "Notice that [X3dDataArray.pencil_decomp](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataArray.pencil_decomp) applies `chunk=-1` for all coordinates listed in `args`, which means no decomposition, and `'auto'` to the others, delagating to dask the job of finding the optimal distribition.\r\n", + "We can use [X3dDataArray.pencil_decomp](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataArray.pencil_decomp) to coarse the velocity array to a dask array, ready for parallel computing (see [Using Dask with xarray](http://docs.xarray.dev/en/stable/user-guide/dask.html#using-dask-with-xarray)).\n", + "Notice that [X3dDataArray.pencil_decomp](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataArray.pencil_decomp) applies `chunk=-1` for all coordinates listed in `args`, which means no decomposition, and `'auto'` to the others, delagating to dask the job of finding the optimal distribition.\n", "One important point here is that dask considers the dataset in this example so small that the overhead for parallel computing is not worth it. As a result, it returns with just one chunk:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "45", + "metadata": {}, + "outputs": [], "source": [ - "u_chunked = dataset.u.x3d.pencil_decomp(\"x\", \"y\")\r\n", + "u_chunked = dataset.u.x3d.pencil_decomp(\"x\", \"y\")\n", "u_chunked" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "46", + "metadata": {}, "source": [ "Parallel computing is presented in this tutorial anyway, because [X3dDataArray.pencil_decomp](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataArray.pencil_decomp) returns the arrays with several chunks for datasets in real scale. Each of these chunks will be computed in parallel in multi-core systems." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "47", + "metadata": {}, "source": [ "Just to exemplify, let's create blocks with 51 points in time, so we can use 4 cores to compute it in parallel:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "48", + "metadata": {}, + "outputs": [], "source": [ - "u_chunked = dataset.u.chunk(chunks=dict(t = 51))\r\n", + "u_chunked = dataset.u.chunk(chunks={\"t\": 51})\n", "u_chunked" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "49", + "metadata": {}, "source": [ "Now computing the vorticity in parallel:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "50", + "metadata": {}, + "outputs": [], "source": [ - "%%time\r\n", - "dataset[\"vort\"] = (\r\n", - " u_chunked.sel(i=\"y\").x3d.first_derivative(\"x\")\r\n", - " - u_chunked.sel(i=\"x\").x3d.first_derivative(\"y\")\r\n", + "%%time\n", + "dataset[\"vort\"] = (\n", + " u_chunked.sel(i=\"y\").x3d.first_derivative(\"x\") - u_chunked.sel(i=\"x\").x3d.first_derivative(\"y\")\n", ").compute()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "51", + "metadata": {}, "source": [ "Again, remember that the dataset in this tutorial is to small that the overhead for parallel computing is not worth it. The wall time was 3 times bigger, but the code is here if you plan to try it on large scale simulations." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "52", + "metadata": {}, "source": [ "As usual, we can set attributes to the array we just computed:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "dataset[\"vort\"].attrs = dict(name = \"wz\", long_name=\"Vorticity\", units=\"-\")" - ], + "id": "53", + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "dataset[\"vort\"].attrs = {\"name\": \"wz\", \"long_name\": \"Vorticity\", \"units\": \"-\"}" + ] }, { "cell_type": "markdown", + "id": "54", + "metadata": {}, "source": [ "And plot it:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "55", + "metadata": {}, + "outputs": [], "source": [ - "g = dataset.vort.isel(t=slice(None, None, 10)).plot(\r\n", - " x=\"x\", y=\"y\", col=\"t\", col_wrap=7, cmap=\"turbo\", rasterized=True, robust=True\r\n", - ")\r\n", - "for ax in g.axes.flat:\r\n", + "g = dataset.vort.isel(t=slice(None, None, 10)).plot(\n", + " x=\"x\", y=\"y\", col=\"t\", col_wrap=7, cmap=\"turbo\", rasterized=True, robust=True\n", + ")\n", + "for ax in g.axes.flat:\n", " ax.axes.set_aspect(\"equal\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "56", + "metadata": {}, "source": [ - "The precision can be improved near the geometry if we interpolate the velocity field inside, in this way, we create a continuos function before computing the derivative. For a nice visual effect, let's select a sample data, making it easier to visualize in 1D. From the velocity vector, we select just the component `x`, besides, we can specify one value for `y` and `t`. See the code:" - ], - "metadata": {} + "The precision can be improved near the geometry if we interpolate the velocity field inside, in this way, we create a continuous function before computing the derivative. For a nice visual effect, let's select a sample data, making it easier to visualize in 1D. From the velocity vector, we select just the component `x`, besides, we can specify one value for `y` and `t`. See the code:" + ] }, { "cell_type": "code", "execution_count": null, + "id": "57", + "metadata": {}, + "outputs": [], "source": [ "ux_sample = dataset.u.sel(i=\"x\", t=150.0, y=6.0)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "58", + "metadata": {}, "source": [ - "We can plot this sample with `np.NaN` inside the cylinder, the same data we used in all the previous examples, and we can also [fill it with a cubic interpolation](http://xarray.pydata.org/en/stable/generated/xarray.DataArray.interpolate_na.html#xarray.DataArray.interpolate_na). See the results:" - ], - "metadata": {} + "We can plot this sample with `np.NaN` inside the cylinder, the same data we used in all the previous examples, and we can also [fill it with a cubic interpolation](http://docs.xarray.dev/en/stable/generated/xarray.DataArray.interpolate_na.html#xarray.DataArray.interpolate_na). See the results:" + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "ux_sample.plot(label=\"NaN at the Geometry\")\r\n", - "ux_sample.interpolate_na(\"x\", \"cubic\").plot(label=\"Interpolated\", zorder = -1)\r\n", - "plt.legend();" - ], + "id": "59", + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "ux_sample.plot(label=\"NaN at the Geometry\")\n", + "ux_sample.interpolate_na(\"x\", \"cubic\").plot(label=\"Interpolated\", zorder=-1)\n", + "plt.legend()" + ] }, { "cell_type": "markdown", + "id": "60", + "metadata": {}, "source": [ "Now, a demonstration of the first derivative with and without interpolation:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "ux_sample.x3d.first_derivative(\"x\").plot(label=\"NaN at the Geometry\")\r\n", - "ux_sample.interpolate_na(\"x\", \"cubic\").x3d.first_derivative(\"x\").plot(\r\n", - " label=\"Interpolated\", zorder=-1\r\n", - ")\r\n", - "plt.ylabel(\"du/dx\")\r\n", - "plt.legend();" - ], + "id": "61", + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "ux_sample.x3d.first_derivative(\"x\").plot(label=\"NaN at the Geometry\")\n", + "ux_sample.interpolate_na(\"x\", \"cubic\").x3d.first_derivative(\"x\").plot(label=\"Interpolated\", zorder=-1)\n", + "plt.ylabel(\"du/dx\")\n", + "plt.legend()" + ] }, { "cell_type": "markdown", + "id": "62", + "metadata": {}, "source": [ - "Notice that [xarray](http://xarray.pydata.org/en/stable/) is built on top of [Numpy](https://numpy.org/), so its arrays and datasets are compatibles with many tools of the Numpy/SciPy universe.\r\n", + "Notice that [xarray](http://docs.xarray.dev/en/stable/) is built on top of [Numpy](https://numpy.org/), so its arrays and datasets are compatibles with many tools of the Numpy/SciPy universe.\n", "You can even access a `numpy.ndarray` object with the property `values`:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "63", + "metadata": {}, + "outputs": [], "source": [ "dataset.epsi.values" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "64", + "metadata": {}, "source": [ - "You can use it for backwards compatibility with your previous post-processing tools, in this way, the transition to xcompact3d-toolbox should be easier.\r\n", + "You can use it for backwards compatibility with your previous post-processing tools, in this way, the transition to xcompact3d-toolbox should be easier.\n", "It is just not so effective, because we lost track of metadata like the coordinates and attributes, they are key points for data analysis with xarray." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "65", + "metadata": {}, "source": [ - "See also:\r\n", - "\r\n", - "* [Xarray: How do I ...](http://xarray.pydata.org/en/stable/howdoi.html)\r\n", - "* [Xarray's tutorials](https://xarray-contrib.github.io/xarray-tutorial/)\r\n", - "* [python-xarray](https://stackoverflow.com/questions/tagged/python-xarray) on StackOverflow\r\n", + "See also:\n", + "\n", + "* [Xarray: How do I ...](http://docs.xarray.dev/en/stable/howdoi.html)\n", + "* [Xarray's tutorials](https://xarray-contrib.github.io/xarray-tutorial/)\n", + "* [python-xarray](https://stackoverflow.com/questions/tagged/python-xarray) on StackOverflow\n", "* [pint-xarray](https://pint-xarray.readthedocs.io/en/latest/) to use Pint to track physical quantities and perform unit conversions in Python" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "66", + "metadata": {}, "source": [ "### Interactive Visualization" - ], - "metadata": {} + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "67", + "metadata": {}, + "outputs": [], + "source": [ + "import hvplot.xarray # noqa: F401" + ] }, { "cell_type": "markdown", + "id": "68", + "metadata": {}, "source": [ - "
\r\n", - "\r\n", - "For an interactive experience [launch this tutorial on Binder](https://mybinder.org/v2/gh/fschuch/xcompact3d_toolbox/main?labpath=.%2Fdocs%2Ftutorial), the widgets are not responsive when disconnected from a Python application.\r\n", - "\r\n", + "
\n", + "\n", + "For an interactive experience [launch this tutorial on Binder](https://mybinder.org/v2/gh/fschuch/xcompact3d_toolbox/main?urlpath=lab/tree/docs/tutorial/computing_and_plotting.ipynb), the widgets are not responsive when disconnected from a Python application.\n", + "\n", "
" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "69", + "metadata": {}, "source": [ - "All the previous examples where based on matplotlib, but xarray is compatible with more options.\r\n", + "All the previous examples where based on matplotlib, but xarray is compatible with more options.\n", "One of them is [hvPlot](https://hvplot.holoviz.org/index.html) (see [Gridded Data](https://hvplot.holoviz.org/user_guide/Gridded_Data.html))." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "70", + "metadata": {}, "source": [ "hvPlot is recommended when you are exploring your data and need a bit more interactivity." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "71", + "metadata": {}, "source": [ "To exemplify, let's reproduce one of the figure we did before, choosing one specific location in our mesh and looking at the time evolution of the velocity there:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "72", + "metadata": {}, + "outputs": [], "source": [ "dataset.u.sel(x=10.0, y=6.0, method=\"nearest\").hvplot(x=\"t\", by=\"i\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "73", + "metadata": {}, "source": [ "One key aspect about hvPlot is that when it gets more coordinates than it can handle in a plot, it presents the extra coordinates in widgets. So if we do not select any specific point in the domain and reproduce the same figure above, we will get widgets to select the point where we are looking:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "74", + "metadata": {}, + "outputs": [], "source": [ "dataset.u.hvplot(x=\"t\", by=\"i\", widget_location=\"bottom\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "75", + "metadata": {}, "source": [ "Here we reproduce the time evolution of the kinetic energy, this time with hvPlot:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "76", + "metadata": {}, + "outputs": [], "source": [ "dataset[\"kinetic_energy\"].hvplot()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "77", + "metadata": {}, "source": [ "And one last example, we can see a really nice animation of the vorticity field, here in a Jupyter Notebook, with a very few lines of code:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "78", + "metadata": {}, + "outputs": [], "source": [ - "dataset.vort.sel(t = slice(40, None)).hvplot(\r\n", - " x=\"x\",\r\n", - " y=\"y\",\r\n", - " aspect=\"equal\",\r\n", - " clim=(-5, 5),\r\n", - " rasterize=True,\r\n", - " cmap=\"turbo\",\r\n", - " widget_type=\"scrubber\",\r\n", - " widget_location=\"bottom\",\r\n", - " title=\"Flow around a Cylinder\",\r\n", - " clabel=r\"Vorticity [-]\",\r\n", + "dataset.vort.sel(t=slice(40, None)).hvplot(\n", + " x=\"x\",\n", + " y=\"y\",\n", + " aspect=\"equal\",\n", + " clim=(-5, 5),\n", + " rasterize=True,\n", + " cmap=\"turbo\",\n", + " widget_type=\"scrubber\",\n", + " widget_location=\"bottom\",\n", + " title=\"Flow around a Cylinder\",\n", + " clabel=r\"Vorticity [-]\",\n", ")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "79", + "metadata": {}, "source": [ "Note: The selection (`sel(t = slice(40, None))`) in the block above is not necessary, of course, we can see the animation since the beginning. It was just used to look better at readthedocs." - ], - "metadata": {} + ] } ], "metadata": { @@ -723,8 +802,8 @@ "hash": "546d5beeb22119d9a20f6c19239ae627cc2b69f70be285d1d696980c89f3c939" }, "kernelspec": { - "name": "python3", - "display_name": "Python 3.9.5 64-bit ('idp': conda)" + "display_name": "Python 3.9.5 64-bit ('idp': conda)", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -737,13 +816,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.5" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } } }, "nbformat": 4, diff --git a/docs/tutorial/io.ipynb b/docs/tutorial/io.ipynb index 45ace93..415c48e 100644 --- a/docs/tutorial/io.ipynb +++ b/docs/tutorial/io.ipynb @@ -2,904 +2,1047 @@ "cells": [ { "cell_type": "markdown", + "id": "0", + "metadata": {}, "source": [ "# Reading and writing files" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "1", + "metadata": {}, "source": [ - "This tutorial includes an overview of the different ways available to load the binary arrays from the disc after running a numerical simulation with [XCompact3d](https://github.com/xcompact3d/Incompact3d).\r\n", + "This tutorial includes an overview of the different ways available to load the binary arrays from the disc after running a numerical simulation with [XCompact3d](https://github.com/xcompact3d/Incompact3d).\n", "Besides that, some options are presented to save the results from our analysis, together with some tips and tricks." - ], - "metadata": {} + ] }, { "cell_type": "markdown", - "source": [ - "
\r\n", - "\r\n", - "For an interactive experience [launch this tutorial on Binder](https://mybinder.org/v2/gh/fschuch/xcompact3d_toolbox/main?labpath=.%2Fdocs%2Ftutorial).\r\n", - "\r\n", - "
" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Preparation" - ], + "id": "2", "metadata": { "tags": [] - } + }, + "source": [ + "## Preparation" + ] }, { "cell_type": "markdown", + "id": "3", + "metadata": {}, "source": [ - "Here we prepare the dataset for this notebook, so it can be reproduced on local machines or on the cloud, you are invited to test and interact with many of the concepts.\r\n", - "It also provides nice support for courses and tutorials, let us know if you produce any of them.\r\n", - "\r\n", + "Here we prepare the dataset for this notebook, so it can be reproduced on local machines or on the cloud, you are invited to test and interact with many of the concepts.\n", + "It also provides nice support for courses and tutorials, let us know if you produce any of them.\n", + "\n", "The very first step is to import the toolbox and other packages:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "4", + "metadata": {}, + "outputs": [], "source": [ - "import warnings\r\n", - "\r\n", - "import numpy as np\r\n", - "import xarray as xr\r\n", + "import warnings\n", + "\n", + "import numpy as np\n", + "import xarray as xr\n", + "\n", "import xcompact3d_toolbox as x3d" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "5", + "metadata": {}, "source": [ - "Then we can download an example from the [online database](https://github.com/fschuch/xcompact3d_toolbox_data), the flow around a cylinder in this case.\r\n", - "We set `cache=True` and a local destination where it can be saved in our computer `cache_dir=\"./example/\"`, so there is no need to download it everytime the kernel is restarted." - ], - "metadata": {} + "Then we can download an example from the [online database](https://github.com/fschuch/xcompact3d_toolbox_data), the flow around a cylinder in this case.\n", + "We set `cache=True` and a local destination where it can be saved in our computer `cache_dir=\"./example/\"`, so there is no need to download it every time the kernel is restarted." + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "cylinder_ds, prm = x3d.tutorial.open_dataset(\r\n", - " \"cylinder\", cache=True, cache_dir=\"./example/\"\r\n", - ")" - ], + "id": "6", + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "cylinder_ds, prm = x3d.tutorial.open_dataset(\"cylinder\", cache=True, cache_dir=\"./example/\")" + ] }, { "cell_type": "markdown", + "id": "7", + "metadata": {}, "source": [ "let's take a look at the dataset:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "8", + "metadata": {}, + "outputs": [], "source": [ "cylinder_ds.info()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "9", + "metadata": {}, "source": [ - "We got a [xarray.Dataset](http://xarray.pydata.org/en/stable/generated/xarray.Dataset.html#xarray.Dataset) with the variables `u` (velocity vector), `pp` (pressure) and `epsi` (describes the geometry), their coordinates (`x`, `y`, `t` and `i`) and some atributes like the `xcompact3d_version` used to run this simulation, the `url` where you can find the dataset, and others.\r\n", - "\r\n", - "In the next block, we configure the toolbox and some atributes at the dataset, so we can write all the binary fields to the disc.\r\n", + "We got a [xarray.Dataset](http://docs.xarray.dev/en/stable/generated/xarray.Dataset.html#xarray.Dataset) with the variables `u` (velocity vector), `pp` (pressure) and `epsi` (describes the geometry), their coordinates (`x`, `y`, `t` and `i`) and some attributes like the `xcompact3d_version` used to run this simulation, the `url` where you can find the dataset, and others.\n", + "\n", + "In the next block, we configure the toolbox and some attributes at the dataset, so we can write all the binary fields to the disc.\n", "Do not worry about the details right now, this is just the preparation step, we are going to discuss them later." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "10", + "metadata": {}, + "outputs": [], "source": [ - "x3d.param[\"mytype\"] = np.float32\r\n", - "\r\n", - "prm.dataset.set(data_path=\"./data/\", drop_coords=\"z\")\r\n", - "\r\n", - "cylinder_ds.u.attrs[\"file_name\"] = \"u\"\r\n", - "cylinder_ds.pp.attrs[\"file_name\"] = \"pp\"\r\n", - "cylinder_ds.epsi.attrs[\"file_name\"] = \"epsilon\"\r\n", - "\r\n", - "prm.write(\"input.i3d\")\r\n", - "\r\n", - "prm.dataset.write(cylinder_ds)\r\n", - "\r\n", - "prm.dataset.write_xdmf(\"xy-planes.xdmf\")\r\n", - "\r\n", + "x3d.param[\"mytype\"] = np.float32\n", + "\n", + "prm.dataset.set(data_path=\"./data/\", drop_coords=\"z\")\n", + "\n", + "cylinder_ds.u.attrs[\"file_name\"] = \"u\"\n", + "cylinder_ds.pp.attrs[\"file_name\"] = \"pp\"\n", + "cylinder_ds.epsi.attrs[\"file_name\"] = \"epsilon\"\n", + "\n", + "prm.write(\"input.i3d\")\n", + "\n", + "prm.dataset.write(cylinder_ds)\n", + "\n", + "prm.dataset.write_xdmf(\"xy-planes.xdmf\")\n", + "\n", "del cylinder_ds, prm" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "11", + "metadata": {}, "source": [ "After that, the files are organized as follow:" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "```\r\n", - "tutorial\r\n", - "│ computing_and_plotting.ipynb\r\n", - "│ io.ipynb\r\n", - "│ input.i3d\r\n", - "│ parameters.ipynb\r\n", - "│ xy-planes.xdmf\r\n", - "│\r\n", - "└─── data\r\n", - "│ │ epsilon.bin\r\n", - "│ │ pp-000.bin\r\n", - "│ │ pp-001.bin\r\n", - "│ │ ... \r\n", - "│ │ pp-199.bin\r\n", - "│ │ pp-200.bin\r\n", - "│ │ ux-000.bin\r\n", - "│ │ ux-001.bin\r\n", - "│ │ ... \r\n", - "│ │ ux-199.bin\r\n", - "│ │ ux-200.bin\r\n", - "│ │ uy-000.bin\r\n", - "│ │ uy-001.bin\r\n", - "│ │ ... \r\n", - "│ │ uy-199.bin\r\n", - "│ │ uy-200.bin\r\n", - "│ │ uz-000.bin\r\n", - "│ │ uz-001.bin\r\n", - "│ │ ... \r\n", - "│ │ uz-199.bin\r\n", - "│ │ uz-200.bin\r\n", - "│\r\n", - "└─── example\r\n", - "│ │ cylinder.nc\r\n", + ] + }, + { + "cell_type": "markdown", + "id": "12", + "metadata": {}, + "source": [ + "```\n", + "tutorial\n", + "│ computing_and_plotting.ipynb\n", + "│ io.ipynb\n", + "│ input.i3d\n", + "│ parameters.ipynb\n", + "│ xy-planes.xdmf\n", + "│\n", + "└─── data\n", + "│ │ epsilon.bin\n", + "│ │ pp-000.bin\n", + "│ │ pp-001.bin\n", + "│ │ ... \n", + "│ │ pp-199.bin\n", + "│ │ pp-200.bin\n", + "│ │ ux-000.bin\n", + "│ │ ux-001.bin\n", + "│ │ ... \n", + "│ │ ux-199.bin\n", + "│ │ ux-200.bin\n", + "│ │ uy-000.bin\n", + "│ │ uy-001.bin\n", + "│ │ ... \n", + "│ │ uy-199.bin\n", + "│ │ uy-200.bin\n", + "│ │ uz-000.bin\n", + "│ │ uz-001.bin\n", + "│ │ ... \n", + "│ │ uz-199.bin\n", + "│ │ uz-200.bin\n", + "│\n", + "└─── example\n", + "│ │ cylinder.nc\n", "```" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "13", + "metadata": {}, "source": [ "It is very similar to what we get after successfully running a simulation, so now we can move on to the tutorial." - ], - "metadata": {} + ] }, { "cell_type": "markdown", - "source": [ - "## Why xarray?\r\n", - "\r\n", - "The data structures are provided by [xarray](http://xarray.pydata.org/en/stable/index.html), that introduces labels in the form of dimensions, coordinates and attributes on top of raw NumPy-like arrays, which allows for a more intuitive, more concise, and less error-prone developer experience.\r\n", - "It integrates tightly with [dask](https://dask.org/) for parallel computing.\r\n", - "\r\n", - "The goal here is to speed up the development of customized post-processing applications with the concise interface provided by [xarray](http://xarray.pydata.org/en/stable/index.html). Ultimately, we can compute solutions with fewer lines of code and better readability, so we expend less time testing and debugging and more time exploring our datasets and getting insights.\r\n", - "\r\n", - "Additionally, xcompact3d-toolbox includes extra functionalities for [DataArray](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataArray) and [Dataset](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataset).\r\n", - "\r\n", - "Before going forward, please, take a look at [Overview: Why xarray?](http://xarray.pydata.org/en/stable/getting-started-guide/why-xarray.html) and [Quick overview](http://xarray.pydata.org/en/stable/getting-started-guide/quick-overview.html) to understand the motivation to use [xarray](http://xarray.pydata.org/en/stable/index.html)'s data structures instead of just numpy-like arrays." - ], - "metadata": {} + "id": "14", + "metadata": {}, + "source": [ + "## Why xarray?\n", + "\n", + "The data structures are provided by [xarray](http://docs.xarray.dev/en/stable/index.html), that introduces labels in the form of dimensions, coordinates and attributes on top of raw NumPy-like arrays, which allows for a more intuitive, more concise, and less error-prone developer experience.\n", + "It integrates tightly with [dask](https://dask.org/) for parallel computing.\n", + "\n", + "The goal here is to speed up the development of customized post-processing applications with the concise interface provided by [xarray](http://docs.xarray.dev/en/stable/index.html). Ultimately, we can compute solutions with fewer lines of code and better readability, so we expend less time testing and debugging and more time exploring our datasets and getting insights.\n", + "\n", + "Additionally, xcompact3d-toolbox includes extra functionalities for [DataArray](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataArray) and [Dataset](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.array.X3dDataset).\n", + "\n", + "Before going forward, please, take a look at [Overview: Why xarray?](http://docs.xarray.dev/en/stable/getting-started-guide/why-xarray.html) and [Quick overview](http://docs.xarray.dev/en/stable/getting-started-guide/quick-overview.html) to understand the motivation to use [xarray](http://docs.xarray.dev/en/stable/index.html)'s data structures instead of just numpy-like arrays." + ] }, { "cell_type": "markdown", + "id": "15", + "metadata": {}, "source": [ "## Xarray objects on demand" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "16", + "metadata": {}, "source": [ "To start our post-processing, let's load the parameters file:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "17", + "metadata": {}, + "outputs": [], "source": [ "prm = x3d.Parameters(loadfile=\"input.i3d\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "18", + "metadata": {}, "source": [ "Notice there is an entire [tutorial dedicated to it](https://xcompact3d-toolbox.readthedocs.io/en/stable/tutorial/parameters.html)." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "19", + "metadata": {}, "source": [ "To save space on the disc, our dataset was converted from double precision to single, so we have to configure the toolbox to:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "20", + "metadata": {}, + "outputs": [], "source": [ "x3d.param[\"mytype\"] = np.float32" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "21", + "metadata": {}, "source": [ "The methods in the toolbox support different [filename properties](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.io.FilenameProperties), like the classic `ux000` or the new `ux-0000.bin`, besides some combinations between them. For our case, we set the parameters as:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "22", + "metadata": {}, + "outputs": [], "source": [ - "prm.dataset.filename_properties.set(\r\n", - " separator = \"-\",\r\n", - " file_extension = \".bin\",\r\n", - " number_of_digits = 3,\r\n", + "prm.dataset.filename_properties.set(\n", + " separator=\"-\",\n", + " file_extension=\".bin\",\n", + " number_of_digits=3,\n", ")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "23", + "metadata": {}, "source": [ - "Now we specify the parameters for our dataset, like where it is found (`data_path`), if it needs to drop some coordinate (`drop_coords`, again, to save space, we are working with a span-wise averaged dataset, so we drop `z` to work with `xy` planes), we inform the parameter that controls the number of timesteps `snapshot_counting` and their step `snapshot_step`.\r\n", - "Consult the [dataset documentation](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.io.Dataset) to see different ways to customize your experience, and choose the ones that best suits your post-processing application.\r\n", + "Now we specify the parameters for our dataset, like where it is found (`data_path`), if it needs to drop some coordinate (`drop_coords`, again, to save space, we are working with a span-wise averaged dataset, so we drop `z` to work with `xy` planes), we inform the parameter that controls the number of timesteps `snapshot_counting` and their step `snapshot_step`.\n", + "Consult the [dataset documentation](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.io.Dataset) to see different ways to customize your experience, and choose the ones that best suits your post-processing application.\n", "In this example, they are defined as:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "24", + "metadata": {}, + "outputs": [], "source": [ - "prm.dataset.set(\r\n", - " data_path=\"./data/\",\r\n", - " drop_coords=\"z\",\r\n", - " snapshot_counting=\"ilast\",\r\n", - " snapshot_step=\"ioutput\"\r\n", + "prm.dataset.set(\n", + " data_path=\"./data/\",\n", + " drop_coords=\"z\",\n", + " snapshot_counting=\"ilast\",\n", + " snapshot_step=\"ioutput\",\n", ")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "25", + "metadata": {}, "source": [ "Now we are good to go." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "26", + "metadata": {}, "source": [ "We can check the [length of the dataset](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.io.Dataset.__len__) we are dealing with:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "27", + "metadata": {}, + "outputs": [], "source": [ "len(prm.dataset)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "28", + "metadata": {}, "source": [ "Meaning that our binary files range from 0 (i.g., `ux-000.bin`) to 200 (i.g., `ux-200.bin`), exactly as expected." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "29", + "metadata": {}, "source": [ "It is possible to load any given array:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "30", + "metadata": {}, + "outputs": [], "source": [ "epsilon = prm.dataset.load_array(\"./data/epsilon.bin\", add_time=False)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "31", + "metadata": {}, "source": [ - "Notice that [load_array](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.io.Dataset.load_array) requires the entire path to the file, and we use `add_time=False` because this array does not evolve in time like the others, i.e., it is not numerated for several snapshots.\r\n", - "\r\n", + "Notice that [load_array](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.io.Dataset.load_array) requires the entire path to the file, and we use `add_time=False` because this array does not evolve in time like the others, i.e., it is not numerated for several snapshots.\n", + "\n", "We can see it on the screen:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "32", + "metadata": {}, + "outputs": [], "source": [ "epsilon" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "33", + "metadata": {}, "source": [ "Let's do it again, this time for `ux` and using `add_time=True`:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "34", + "metadata": {}, + "outputs": [], "source": [ "ux = prm.dataset.load_array(\"./data/ux-100.bin\", add_time=True)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "35", + "metadata": {}, "source": [ "See that `t` is now a coordinate, and for this snapshot it was computed automatically as dimensionless time `75.0`:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "36", + "metadata": {}, + "outputs": [], "source": [ "ux" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "37", + "metadata": {}, "source": [ "That is not all. If you have enough memory, you can load the entire time series for a given variable with [load_time_series](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.io.Dataset.load_time_series), or simply by:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "38", + "metadata": {}, + "outputs": [], "source": [ "ux = prm.dataset[\"ux\"]" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "39", + "metadata": {}, "source": [ "Let's see it (note 201 files are loaded and wrapped with the appropriate coordinates):" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "40", + "metadata": {}, + "outputs": [], "source": [ "ux" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "41", + "metadata": {}, "source": [ "You can store each array in a different variable, like:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "42", + "metadata": {}, + "outputs": [], "source": [ - "ux = prm.dataset[\"ux\"]\r\n", - "uy = prm.dataset[\"uy\"]\r\n", + "ux = prm.dataset[\"ux\"]\n", + "uy = prm.dataset[\"uy\"]\n", "pp = prm.dataset[\"pp\"]" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "43", + "metadata": {}, "source": [ "Or organize many arrays in a dataset:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "44", + "metadata": {}, + "outputs": [], "source": [ - "# create an empty dataset\r\n", - "ds = xr.Dataset()\r\n", - "\r\n", - "# populate it\r\n", - "for var in [\"ux\", \"uy\", \"pp\"]:\r\n", - " ds[var] = prm.dataset[var]\r\n", - "\r\n", - "# show on the screen\r\n", + "# create an empty dataset\n", + "ds = xr.Dataset()\n", + "\n", + "# populate it\n", + "for var in [\"ux\", \"uy\", \"pp\"]:\n", + " ds[var] = prm.dataset[var]\n", + "\n", + "# show on the screen\n", "ds" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "45", + "metadata": {}, "source": [ - "We can also write an one-liner solution for the previous code:\r\n", - "\r\n", - "```python\r\n", - "ds = xr.Dataset({var: prm.dataset[var] for var in \"ux uy pp\".split()})\r\n", + "We can also write an one-liner solution for the previous code:\n", + "\n", + "```python\n", + "ds = xr.Dataset({var: prm.dataset[var] for var in \"ux uy pp\".split()})\n", "```" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "46", + "metadata": {}, "source": [ "It is possible to load all the variables from a given snapshot with [load_snapshot](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.io.Dataset.load_snapshot), or simply:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "47", + "metadata": {}, + "outputs": [], "source": [ "snapshot = prm.dataset[100]" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "48", + "metadata": {}, "source": [ - "And we got a [xarray.Dataset](http://xarray.pydata.org/en/stable/generated/xarray.Dataset.html#xarray.Dataset) with all the variables and their coordinates. You can access each of them with the dot notation (i.g., `snapshot.pp`, `snapshot.ux`, `snapshot.uy`) or the dict-like notation (i.g., `snapshot[\"pp\"]`, `snapshot[\"ux\"]`, `snapshot[\"uy\"]`). See the dataset:" - ], - "metadata": {} + "And we got a [xarray.Dataset](http://docs.xarray.dev/en/stable/generated/xarray.Dataset.html#xarray.Dataset) with all the variables and their coordinates. You can access each of them with the dot notation (i.g., `snapshot.pp`, `snapshot.ux`, `snapshot.uy`) or the dict-like notation (i.g., `snapshot[\"pp\"]`, `snapshot[\"ux\"]`, `snapshot[\"uy\"]`). See the dataset:" + ] }, { "cell_type": "code", "execution_count": null, + "id": "49", + "metadata": {}, + "outputs": [], "source": [ "snapshot" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "50", + "metadata": {}, "source": [ - "Do you need the snapshots in a range? No problem. Let's do a [slice](https://docs.python.org/3/library/functions.html#slice) to load the last 100, and just to exemplify, compute a [time average](http://xarray.pydata.org/en/stable/generated/xarray.Dataset.mean.html):" - ], - "metadata": {} + "Do you need the snapshots in a range? No problem. Let's do a [slice](https://docs.python.org/3/library/functions.html#slice) to load the last 100, and just to exemplify, compute a [time average](http://docs.xarray.dev/en/stable/generated/xarray.Dataset.mean.html):" + ] }, { "cell_type": "code", "execution_count": null, + "id": "51", + "metadata": {}, + "outputs": [], "source": [ - "time_averaged = prm.dataset[-100:].mean(\"t\")\r\n", + "time_averaged = prm.dataset[-100:].mean(\"t\")\n", "time_averaged" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "52", + "metadata": {}, "source": [ "You can even use the slice notation to load all the snapshots at once:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "53", + "metadata": {}, + "outputs": [], "source": [ "prm.dataset[:]" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "54", + "metadata": {}, "source": [ "Of course, some simulations may not fit in the memory like in this tutorial. For these cases we can iterate over all snapshots, loading them one by one:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "55", + "metadata": {}, + "outputs": [], "source": [ - "for ds in prm.dataset:\r\n", - " # Computing the vorticity, just to exemplify\r\n", + "for ds in prm.dataset:\n", + " # Computing the vorticity, just to exemplify\n", " vort = ds.uy.x3d.first_derivative(\"x\") - ds.ux.x3d.first_derivative(\"y\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "56", + "metadata": {}, "source": [ "Note that `reversed(prm.dataset)` also works." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "57", + "metadata": {}, "source": [ "Or for better control, we can iterate over a selected range of snapshots loading them one by one. The arguments are the same of a classic [range](https://docs.python.org/3/library/functions.html#func-range) in Python:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "58", + "metadata": {}, + "outputs": [], "source": [ - "for ds in prm.dataset(100, 200, 1):\r\n", - " # Computing the vorticity, just to exemplify\r\n", + "for ds in prm.dataset(100, 200, 1):\n", + " # Computing the vorticity, just to exemplify\n", " vort = ds.uy.x3d.first_derivative(\"x\") - ds.ux.x3d.first_derivative(\"y\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "59", + "metadata": {}, + "outputs": [], "source": [ - "# Result from the last iteration\r\n", + "# Result from the last iteration\n", "vort" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "60", + "metadata": {}, "source": [ - "## Writting the results to binary files" - ], - "metadata": {} + "## Writing the results to binary files" + ] }, { "cell_type": "markdown", + "id": "61", + "metadata": {}, "source": [ "In the last example we computed the vorticity but did nothing with it. This time, let's write it to the disc using [write](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.io.Dataset.write):" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "for ds in prm.dataset:\r\n", - " vort = ds.uy.x3d.first_derivative(\"x\") - ds.ux.x3d.first_derivative(\"y\")\r\n", - " prm.dataset.write(data = vort, file_prefix = \"w3\")" - ], + "id": "62", + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "for ds in prm.dataset:\n", + " vort = ds.uy.x3d.first_derivative(\"x\") - ds.ux.x3d.first_derivative(\"y\")\n", + " prm.dataset.write(data=vort, file_prefix=\"w3\")" + ] }, { "cell_type": "markdown", - "source": [ - "The example above works for a [xarray.DataArray](http://xarray.pydata.org/en/stable/generated/xarray.DataArray.html#xarray.DataArray). We can do it for a [xarray.Dataset](http://xarray.pydata.org/en/stable/generated/xarray.Dataset.html#xarray.Dataset) as well, but with one key difference. Only the arrays with an attribute called `file_name` will be written. It is done to avoid overwriting the base fields (`ux`, `uy`, `uz`, ...) by accident.\r\n", - "\r\n", - "Let's rewrite the previous example to store `vort` in the dataset `ds`. We set an atribute `file_name` to `w3`, so the arrays will be written as `w3-000.bin`, `w3-001.bin`, `w3-002.bin`, etc.\r\n", - "\r\n", - "We are also suppressing warnings, because the application will tell us it can not save `pp`, `ux` and `uy`, since they do not have a `file_name`. But in fact, we do not want to rewrite them anyway.\r\n", - "\r\n", + "id": "63", + "metadata": {}, + "source": [ + "The example above works for a [xarray.DataArray](http://docs.xarray.dev/en/stable/generated/xarray.DataArray.html#xarray.DataArray). We can do it for a [xarray.Dataset](http://docs.xarray.dev/en/stable/generated/xarray.Dataset.html#xarray.Dataset) as well, but with one key difference. Only the arrays with an attribute called `file_name` will be written. It is done to avoid overwriting the base fields (`ux`, `uy`, `uz`, ...) by accident.\n", + "\n", + "Let's rewrite the previous example to store `vort` in the dataset `ds`. We set an attribute `file_name` to `w3`, so the arrays will be written as `w3-000.bin`, `w3-001.bin`, `w3-002.bin`, etc.\n", + "\n", + "We are also suppressing warnings, because the application will tell us it can not save `pp`, `ux` and `uy`, since they do not have a `file_name`. But in fact, we do not want to rewrite them anyway.\n", + "\n", "See the code:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "with warnings.catch_warnings():\r\n", - " warnings.filterwarnings('ignore', category=UserWarning)\r\n", - " for ds in prm.dataset:\r\n", - " ds[\"vort\"] = ds.uy.x3d.first_derivative(\"x\") - ds.ux.x3d.first_derivative(\"y\")\r\n", - " ds[\"vort\"].attrs[\"file_name\"] = \"w3\"\r\n", - " prm.dataset.write(ds)" - ], - "outputs": [], + "id": "64", "metadata": { "tags": [] - } + }, + "outputs": [], + "source": [ + "with warnings.catch_warnings():\n", + " warnings.filterwarnings(\"ignore\", category=UserWarning)\n", + " for ds in prm.dataset:\n", + " ds[\"vort\"] = ds.uy.x3d.first_derivative(\"x\") - ds.ux.x3d.first_derivative(\"y\")\n", + " ds[\"vort\"].attrs[\"file_name\"] = \"w3\"\n", + " prm.dataset.write(ds)" + ] }, { "cell_type": "markdown", + "id": "65", + "metadata": {}, "source": [ "The method [prm.dataset.write()](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.io.Dataset.write) writes the files as raw binaries in the same way that [XCompact3d](https://github.com/xcompact3d/Incompact3d) would do. It means you can read them at the flow solver and also process them on any other tool that you are already familiar with, including the toolbox." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "66", + "metadata": {}, "source": [ "For instance, we get `w3` if we load snapshot 0 again:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "67", + "metadata": {}, + "outputs": [], "source": [ "prm.dataset[0]" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "68", + "metadata": {}, "source": [ "### Update the xdmf file" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "69", + "metadata": {}, "source": [ "After computing and writing new results to the disc, you can open them on any external tools, like Paraview or Visit. You can update the xdmf file to include the recently computed `w3`. See the code:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "70", + "metadata": {}, + "outputs": [], "source": [ "prm.dataset.write_xdmf(\"xy-planes.xdmf\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "71", + "metadata": {}, "source": [ "## Other formats" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "72", + "metadata": {}, "source": [ - "Xarray objects can be exported to many other formats, depending on your needs.\r\n", - "\r\n", - "For instance, [xarray.DataArray](http://xarray.pydata.org/en/stable/generated/xarray.DataArray.html#xarray.DataArray) and [xarray.Dataset](http://xarray.pydata.org/en/stable/generated/xarray.Dataset.html#xarray.Dataset) can be written as [netCDF](http://xarray.pydata.org/en/stable/user-guide/io.html). In this way, they will keep all dimensions, coordinates, and attributes. This format is easier to handle and share because the files are self-sufficient. It is the format used to download the dataset used in this tutorial, and it is a good alternative to use when sharing the results of your research.\r\n", - "\r\n", + "Xarray objects can be exported to many other formats, depending on your needs.\n", + "\n", + "For instance, [xarray.DataArray](http://docs.xarray.dev/en/stable/generated/xarray.DataArray.html#xarray.DataArray) and [xarray.Dataset](http://docs.xarray.dev/en/stable/generated/xarray.Dataset.html#xarray.Dataset) can be written as [netCDF](http://docs.xarray.dev/en/stable/user-guide/io.html). In this way, they will keep all dimensions, coordinates, and attributes. This format is easier to handle and share because the files are self-sufficient. It is the format used to download the dataset used in this tutorial, and it is a good alternative to use when sharing the results of your research.\n", + "\n", "Just to give you an estimation about the disk usage, the size of the dataset `cylinder.nc` that we downloaded for this tutorial is 75.8 MB. The size of the folder `./data/` after producing the binary files in the same way that [XCompact3d](https://github.com/xcompact3d/Incompact3d) would do is 75.7 MB." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "73", + "metadata": {}, "source": [ "To exemplify the use of netCDF, let's take one snapshot:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "74", + "metadata": {}, + "outputs": [], "source": [ - "snapshot = prm.dataset[0]\r\n", + "snapshot = prm.dataset[0]\n", "snapshot" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "75", + "metadata": {}, "source": [ - "Now, let's include additional information for the ones that are going to use our data. You can set attributes for each array, coordinate, and also global attributes for the dataset. They are stored in a dictionary.\r\n", - "\r\n", + "Now, let's include additional information for the ones that are going to use our data. You can set attributes for each array, coordinate, and also global attributes for the dataset. They are stored in a dictionary.\n", + "\n", "See the example:" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": null, - "source": [ - "# Setting attributes for each coordinate\r\n", - "snapshot.x.attrs = dict(\r\n", - " name = \"x\",\r\n", - " long_name = \"Stream-wise coordinate\",\r\n", - " units = \"-\"\r\n", - ")\r\n", - "snapshot.y.attrs = dict(\r\n", - " name = \"y\",\r\n", - " long_name = \"Vertical coordinate\",\r\n", - " units = \"-\"\r\n", - ")\r\n", - "snapshot.t.attrs = dict(\r\n", - " name = \"t\",\r\n", - " long_name = \"Time\",\r\n", - " units = \"-\"\r\n", - ")\r\n", - "# Setting attributes for each array\r\n", - "snapshot.ux.attrs = dict(\r\n", - " name = \"ux\",\r\n", - " long_name = \"Stream-wise velocity\",\r\n", - " units = \"-\"\r\n", - ")\r\n", - "snapshot.uy.attrs = dict(\r\n", - " name = \"y\",\r\n", - " long_name = \"Vertical velocity\",\r\n", - " units = \"-\"\r\n", - ")\r\n", - "snapshot.pp.attrs = dict(\r\n", - " name = \"p\",\r\n", - " long_name = \"Pressure\",\r\n", - " units = \"-\"\r\n", - ")\r\n", - "snapshot.w3.attrs = dict(\r\n", - " name = \"w3\",\r\n", - " long_name = \"Vorticity\",\r\n", - " units = \"-\"\r\n", - ")\r\n", - "# Setting attributes for the dataset\r\n", - "snapshot.attrs = dict(\r\n", - " title = \"An example from the tutorials\",\r\n", - " url = \"https://xcompact3d-toolbox.readthedocs.io/en/stable/tutorial/io.html\",\r\n", - " authors = \"List of names\",\r\n", - " doi = \"maybe a fancy doi from zenodo\",\r\n", - ")" - ], + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "76", + "metadata": {}, + "outputs": [], + "source": [ + "# Setting attributes for each coordinate\n", + "snapshot.x.attrs = {\"name\": \"x\", \"long_name\": \"Stream-wise coordinate\", \"units\": \"-\"}\n", + "snapshot.y.attrs = {\"name\": \"y\", \"long_name\": \"Vertical coordinate\", \"units\": \"-\"}\n", + "snapshot.t.attrs = {\"name\": \"t\", \"long_name\": \"Time\", \"units\": \"-\"}\n", + "\n", + "# Setting attributes for each array\n", + "snapshot.ux.attrs = {\"name\": \"ux\", \"long_name\": \"Stream-wise velocity\", \"units\": \"-\"}\n", + "snapshot.uy.attrs = {\"name\": \"y\", \"long_name\": \"Vertical velocity\", \"units\": \"-\"}\n", + "snapshot.pp.attrs = {\"name\": \"p\", \"long_name\": \"Pressure\", \"units\": \"-\"}\n", + "snapshot.w3.attrs = {\"name\": \"w3\", \"long_name\": \"Vorticity\", \"units\": \"-\"}\n", + "\n", + "# Setting attributes for the dataset\n", + "snapshot.attrs = {\n", + " \"title\": \"An example from the tutorials\",\n", + " \"url\": \"https://xcompact3d-toolbox.readthedocs.io/en/stable/tutorial/io.html\",\n", + " \"authors\": \"List of names\",\n", + " \"doi\": \"maybe a fancy doi from zenodo\",\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "77", + "metadata": {}, + "outputs": [], + "source": [ + "# Setting attributes for each coordinate\n", + "snapshot.x.attrs = {\"name\": \"x\", \"long_name\": \"Stream-wise coordinate\", \"units\": \"-\"}\n", + "snapshot.y.attrs = {\"name\": \"y\", \"long_name\": \"Vertical coordinate\", \"units\": \"-\"}\n", + "snapshot.t.attrs = {\"name\": \"t\", \"long_name\": \"Time\", \"units\": \"-\"}\n", + "\n", + "# Setting attributes for each array\n", + "snapshot.ux.attrs = {\"name\": \"ux\", \"long_name\": \"Stream-wise velocity\", \"units\": \"-\"}\n", + "snapshot.uy.attrs = {\"name\": \"y\", \"long_name\": \"Vertical velocity\", \"units\": \"-\"}\n", + "snapshot.pp.attrs = {\"name\": \"p\", \"long_name\": \"Pressure\", \"units\": \"-\"}\n", + "snapshot.w3.attrs = {\"name\": \"w3\", \"long_name\": \"Vorticity\", \"units\": \"-\"}\n", + "\n", + "# Setting attributes for the dataset\n", + "snapshot.attrs = {\n", + " \"title\": \"An example from the tutorials\",\n", + " \"url\": \"https://xcompact3d-toolbox.readthedocs.io/en/stable/tutorial/io.html\",\n", + " \"authors\": \"List of names\",\n", + " \"doi\": \"maybe a fancy doi from zenodo\",\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "78", + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "# Setting attributes for each coordinate\n", + "snapshot.x.attrs = {\"name\": \"x\", \"long_name\": \"Stream-wise coordinate\", \"units\": \"-\"}\n", + "snapshot.y.attrs = {\"name\": \"y\", \"long_name\": \"Vertical coordinate\", \"units\": \"-\"}\n", + "snapshot.t.attrs = {\"name\": \"t\", \"long_name\": \"Time\", \"units\": \"-\"}\n", + "\n", + "# Setting attributes for each array\n", + "snapshot.ux.attrs = {\"name\": \"ux\", \"long_name\": \"Stream-wise velocity\", \"units\": \"-\"}\n", + "snapshot.uy.attrs = {\"name\": \"y\", \"long_name\": \"Vertical velocity\", \"units\": \"-\"}\n", + "snapshot.pp.attrs = {\"name\": \"p\", \"long_name\": \"Pressure\", \"units\": \"-\"}\n", + "snapshot.w3.attrs = {\"name\": \"w3\", \"long_name\": \"Vorticity\", \"units\": \"-\"}\n", + "\n", + "# Setting attributes for the dataset\n", + "snapshot.attrs = {\n", + " \"title\": \"An example from the tutorials\",\n", + " \"url\": \"https://xcompact3d-toolbox.readthedocs.io/en/stable/tutorial/io.html\",\n", + " \"authors\": \"List of names\",\n", + " \"doi\": \"maybe a fancy doi from zenodo\",\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79", + "metadata": {}, + "outputs": [], + "source": [ + "# Setting attributes for each coordinate\n", + "snapshot.x.attrs = {\"name\": \"x\", \"long_name\": \"Stream-wise coordinate\", \"units\": \"-\"}\n", + "snapshot.y.attrs = {\"name\": \"y\", \"long_name\": \"Vertical coordinate\", \"units\": \"-\"}\n", + "snapshot.t.attrs = {\"name\": \"t\", \"long_name\": \"Time\", \"units\": \"-\"}\n", + "\n", + "# Setting attributes for each array\n", + "snapshot.ux.attrs = {\"name\": \"ux\", \"long_name\": \"Stream-wise velocity\", \"units\": \"-\"}\n", + "snapshot.uy.attrs = {\"name\": \"y\", \"long_name\": \"Vertical velocity\", \"units\": \"-\"}\n", + "snapshot.pp.attrs = {\"name\": \"p\", \"long_name\": \"Pressure\", \"units\": \"-\"}\n", + "snapshot.w3.attrs = {\"name\": \"w3\", \"long_name\": \"Vorticity\", \"units\": \"-\"}\n", + "\n", + "# Setting attributes for the dataset\n", + "snapshot.attrs = {\n", + " \"title\": \"An example from the tutorials\",\n", + " \"url\": \"https://xcompact3d-toolbox.readthedocs.io/en/stable/tutorial/io.html\",\n", + " \"authors\": \"List of names\",\n", + " \"doi\": \"maybe a fancy doi from zenodo\",\n", + "}" + ] }, { "cell_type": "markdown", + "id": "80", + "metadata": {}, "source": [ "Exporting it as a netCDF file:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "81", + "metadata": {}, + "outputs": [], "source": [ "snapshot.to_netcdf(\"snapshot-000.nc\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "82", + "metadata": {}, "source": [ "Importing the netCDF file:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "83", + "metadata": {}, + "outputs": [], "source": [ "snapshot_in = xr.open_dataset(\"snapshot-000.nc\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "84", + "metadata": {}, "source": [ "See the result, it keeps all dimensions, coordinates, and attributes:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "85", + "metadata": {}, + "outputs": [], "source": [ "snapshot_in" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "86", + "metadata": {}, "source": [ "We can compare them and see that their data, dimensions and coordinates are exactly the same:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "87", + "metadata": {}, + "outputs": [], "source": [ "xr.testing.assert_equal(snapshot, snapshot_in)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "88", + "metadata": {}, "source": [ "Xarray is built on top of Numpy, so you can access a `numpy.ndarray` object with the property `values` (i.g., `epsilon.values`). It is compatible with `numpy.save` and many other methods from the Numpy/SciPy ecosystem (many times, you do not even need to explicitly use `.values`). See the example:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "id": "89", + "metadata": {}, + "outputs": [], "source": [ - "np.save(\"epsi.npy\", epsilon)\r\n", - "epsi_in = np.load(\"epsi.npy\")\r\n", - "\r\n", - "print(type(epsi_in))\r\n", + "np.save(\"epsi.npy\", epsilon)\n", + "epsi_in = np.load(\"epsi.npy\")\n", + "\n", + "print(type(epsi_in))\n", "epsi_in" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "90", + "metadata": {}, "source": [ "You can use it for backwards compatibility with your previous post-processing tools. It is just not so effective, because we lost track of metadata like the coordinates and attributes." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "91", + "metadata": {}, "source": [ - "If you manage to reduce the dataset's dimensions with some [integration](https://xarray.pydata.org/en/stable/generated/xarray.Dataset.integrate.html), [mean](https://xarray.pydata.org/en/stable/generated/xarray.Dataset.mean.html), or [selecting](https://xarray.pydata.org/en/stable/generated/xarray.Dataset.sel.html) subsets of data, you can convert it to a [pandas.Dataframe](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) and then export it to CSV, Excel, and many other options." - ], - "metadata": {} + "If you manage to reduce the dataset's dimensions with some [integration](https://docs.xarray.dev/en/stablegenerated/xarray.Dataset.integrate.html), [mean](https://docs.xarray.dev/en/stablegenerated/xarray.Dataset.mean.html), or [selecting](https://docs.xarray.dev/en/stablegenerated/xarray.Dataset.sel.html) subsets of data, you can convert it to a [pandas.Dataframe](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) and then export it to CSV, Excel, and many other options." + ] }, { "cell_type": "markdown", + "id": "92", + "metadata": {}, "source": [ - "For instance, let's select a vertical profile for all variables where `x = 20` and [convert it to a dataframe]((https://xarray.pydata.org/en/stable/generated/xarray.Dataset.to_dataframe.html)):" - ], - "metadata": {} + "For instance, let's select a vertical profile for all variables where `x = 20` and [convert it to a dataframe](https://docs.xarray.dev/en/stable/generated/xarray.Dataset.to_dataframe.html):" + ] }, { "cell_type": "code", "execution_count": null, + "id": "93", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94", + "metadata": {}, + "outputs": [], "source": [ "snapshot_in.sel(x=20.0).to_dataframe()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "95", + "metadata": {}, "source": [ "Now, you can refer to [pandas documentation](https://pandas.pydata.org/pandas-docs/stable/index.html) for more details." - ], - "metadata": {} + ] } ], "metadata": { @@ -907,8 +1050,8 @@ "hash": "546d5beeb22119d9a20f6c19239ae627cc2b69f70be285d1d696980c89f3c939" }, "kernelspec": { - "name": "python3", - "display_name": "Python 3.9.5 64-bit ('idp': conda)" + "display_name": "Python 3.9.5 64-bit ('idp': conda)", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -921,13 +1064,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.5" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } } }, "nbformat": 4, diff --git a/docs/tutorial/parameters.ipynb b/docs/tutorial/parameters.ipynb index 4d89e4e..5473066 100644 --- a/docs/tutorial/parameters.ipynb +++ b/docs/tutorial/parameters.ipynb @@ -2,790 +2,795 @@ "cells": [ { "cell_type": "markdown", - "source": [ - "# Parameters\r\n", - "\r\n", - "The computational and physical parameters are handled by [xcompact3d_toolbox.Parameters](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.parameters.Parameters). It is built on top of [Traitlets](https://traitlets.readthedocs.io/en/stable/index.html), which aims to make the parameters compatible with what XCompact3d expects, and also brings some advantages:\r\n", - "\r\n", - "* Attributes are type-checked;\r\n", - "* Default values, restrictions and connections between related parameters are applied when necessary;\r\n", - "* 'On change' callbacks for validation and observation;\r\n", + "metadata": {}, + "source": [ + "# Parameters\n", + "\n", + "The computational and physical parameters are handled by [xcompact3d_toolbox.Parameters](https://xcompact3d-toolbox.readthedocs.io/en/stable/Docstrings.html#xcompact3d_toolbox.parameters.Parameters). It is built on top of [Traitlets](https://traitlets.readthedocs.io/en/stable/index.html), which aims to make the parameters compatible with what XCompact3d expects, and also brings some advantages:\n", + "\n", + "* Attributes are type-checked;\n", + "* Default values, restrictions and connections between related parameters are applied when necessary;\n", + "* 'On change' callbacks for validation and observation;\n", "* Two-way linking with [ipywidgets](https://ipywidgets.readthedocs.io/en/latest/)." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "import numpy as np\r\n", + "import numpy as np\n", + "\n", "import xcompact3d_toolbox as x3d" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "The first step is to establish numerical precision. Use `np.float64` if Xcompact3d was compiled with the flag `-DDOUBLE_PREC` (check the Makefile), use `np.float32` otherwise:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "x3d.param[\"mytype\"] = np.float32" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Initialization" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "There are a few ways to initialize the class. First, calling it with no arguments initializes all variables with default value:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "prm = x3d.Parameters()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "You can access a list with all the available variables at the [Api reference](https://xcompact3d-toolbox.readthedocs.io/en/latest/Docstrings.html)." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Let's see how it looks like:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print(prm)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "It is possible to access and/or set values afterwards:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "# Reynolds Number\r\n", - "print(prm.re)\r\n", - "\r\n", - "# attribute new value\r\n", - "prm.re = 1e6\r\n", + "# Reynolds Number\n", + "print(prm.re)\n", + "\n", + "# attribute new value\n", + "prm.re = 1e6\n", "print(prm.re)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Second, we can specify some values, and let the missing ones be initialized with default value:" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": null, - "source": [ - "prm = x3d.Parameters(\r\n", - " filename=\"example.i3d\",\r\n", - " itype=10,\r\n", - " nx=129,\r\n", - " ny=65,\r\n", - " nz=32,\r\n", - " xlx=15.0,\r\n", - " yly=10.0,\r\n", - " zlz=3.0,\r\n", - " nclx1=2,\r\n", - " nclxn=2,\r\n", - " ncly1=1,\r\n", - " nclyn=1,\r\n", - " nclz1=0,\r\n", - " nclzn=0,\r\n", - " iin=1,\r\n", - " istret=2,\r\n", - " re=300.0,\r\n", - " init_noise=0.0125,\r\n", - " inflow_noise=0.0125,\r\n", - " dt=0.0025,\r\n", - " ifirst=1,\r\n", - " ilast=45000,\r\n", - " irestart=0,\r\n", - " icheckpoint=45000,\r\n", - " ioutput=200,\r\n", - " iprocessing=50,\r\n", + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prm = x3d.Parameters(\n", + " filename=\"example.i3d\",\n", + " itype=10,\n", + " nx=129,\n", + " ny=65,\n", + " nz=32,\n", + " xlx=15.0,\n", + " yly=10.0,\n", + " zlz=3.0,\n", + " nclx1=2,\n", + " nclxn=2,\n", + " ncly1=1,\n", + " nclyn=1,\n", + " nclz1=0,\n", + " nclzn=0,\n", + " iin=1,\n", + " istret=2,\n", + " re=300.0,\n", + " init_noise=0.0125,\n", + " inflow_noise=0.0125,\n", + " dt=0.0025,\n", + " ifirst=1,\n", + " ilast=45000,\n", + " irestart=0,\n", + " icheckpoint=45000,\n", + " ioutput=200,\n", + " iprocessing=50,\n", ")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "It is easy to write `example.i3d` to disc, just type:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "prm.write()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "And finally, it is possible to read the parameters from the disc:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "prm = x3d.Parameters(filename=\"example.i3d\")\r\n", + "prm = x3d.Parameters(filename=\"example.i3d\")\n", "prm.load()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "The same result is obtained in a more concise way:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "prm = x3d.Parameters(loadfile=\"example.i3d\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "The class can also read the previous parameters format ([se more information here](https://github.com/fschuch/xcompact3d_toolbox/issues/7)):\r\n", - "\r\n", - "``` python\r\n", - "prm = x3d.Parameters(loadfile=\"incompact3d.prm\")\r\n", + "The class can also read the previous parameters format ([se more information here](https://github.com/fschuch/xcompact3d_toolbox/issues/7)):\n", + "\n", + "``` python\n", + "prm = x3d.Parameters(loadfile=\"incompact3d.prm\")\n", "```" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "There are extra objects to read and write the raw binary files from XCompact3d on-demand.\r\n", - "\r\n", - "* Read a binary field from the disc:\r\n", - "\r\n", - " ``` python\r\n", - " ux = prm.dataset.load_array(\"ux-0000.bin\")\r\n", - " ```\r\n", - "\r\n", - "* Read the entire time series for a given variable:\r\n", - "\r\n", - " ``` python\r\n", - " ux = prm.dataset.load_time_series(\"ux\")\r\n", - " ```\r\n", - " \r\n", - "* Read all variables for a given snapshot:\r\n", - "\r\n", - " ```python\r\n", - " snapshot = prm.dataset.load_snapshot(10)\r\n", - " ```\r\n", - "\r\n", - "* Write `xdmf` files, so the binary files can be open in any external visualization tool:\r\n", - "\r\n", - " ``` python\r\n", - " prm.dataset.write_xdmf()\r\n", - " ```\r\n", - "\r\n", + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are extra objects to read and write the raw binary files from XCompact3d on-demand.\n", + "\n", + "* Read a binary field from the disc:\n", + "\n", + " ``` python\n", + " ux = prm.dataset.load_array(\"ux-0000.bin\")\n", + " ```\n", + "\n", + "* Read the entire time series for a given variable:\n", + "\n", + " ``` python\n", + " ux = prm.dataset.load_time_series(\"ux\")\n", + " ```\n", + " \n", + "* Read all variables for a given snapshot:\n", + "\n", + " ```python\n", + " snapshot = prm.dataset.load_snapshot(10)\n", + " ```\n", + "\n", + "* Write `xdmf` files, so the binary files can be open in any external visualization tool:\n", + "\n", + " ``` python\n", + " prm.dataset.write_xdmf()\n", + " ```\n", + "\n", "* Compute the coordinates, including support for mesh refinement in y:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "prm.get_mesh()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "More details about I/O and array manipulations with [xarray](http://xarray.pydata.org/en/stable/index.html) are available at:\r\n", - "\r\n", - "* [Reading and writing files](https://xcompact3d-toolbox.readthedocs.io/en/stable/tutorial/io.html);\r\n", + "More details about I/O and array manipulations with [xarray](http://docs.xarray.dev/en/stable/index.html) are available at:\n", + "\n", + "* [Reading and writing files](https://xcompact3d-toolbox.readthedocs.io/en/stable/tutorial/io.html);\n", "* [Computing and Plotting](https://xcompact3d-toolbox.readthedocs.io/en/stable/tutorial/computing_and_plotting.html)." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "## Traitlets\r\n", - "\r\n", - "### Type-checking\r\n", - "\r\n", - "All parameters are type-checked, to make sure that they are what `XCompact3d` expects. Use the cellcode below to see how a `TraitError` pops out when we try:\r\n", - "\r\n", - "```python\r\n", - "prm.itype = 10.5\r\n", - "prm.itype = -5\r\n", - "prm.itype = 20\r\n", - "prm.itype = 'sandbox'\r\n", - "\r\n", - "```\r\n" - ], - "metadata": {} + "## Traitlets\n", + "\n", + "### Type-checking\n", + "\n", + "All parameters are type-checked, to make sure that they are what `XCompact3d` expects. Use the cellcode below to see how a `TraitError` pops out when we try:\n", + "\n", + "```python\n", + "prm.itype = 10.5\n", + "prm.itype = -5\n", + "prm.itype = 20\n", + "prm.itype = 'sandbox'\n", + "\n", + "```\n" + ] }, { "cell_type": "code", "execution_count": null, - "source": [], + "metadata": {}, "outputs": [], - "metadata": {} + "source": [] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Validation" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "Some parameters, like mesh points (`nx`, `ny` and `nz`), trigger a validation operation when a new value is attributed to them.\r\n", - "Due to restrictions at the FFT library, they must be equal to:\r\n", - "\r\n", - "$$\r\n", - "n_i = \\left\\{ \\begin{array}{ll} 2^{1+a} \\times 3^b \\times 5^c &\\mbox{if periodic,} \\\\ 2^{1+a} \\times 3^b \\times 5^c + 1 &\\mbox{otherwise,}\r\n", - "\\end{array} \\right.\r\n", - "$$\r\n", - "\r\n", - "where $a$, $b$ and $c$ are non negative integers. In addition, the derivatives stencil imposes that:\r\n", - "\r\n", - "$$\r\n", - "n_i \\ge \\left\\{ \\begin{array}{ll} 8 &\\mbox{if periodic,} \\\\ 9 &\\mbox{otherwise.}\r\n", - "\\end{array} \\right.\r\n", - "$$\r\n", - "\r\n", - "Again, give it a try at the cellcode below:\r\n", - "\r\n", - "```python\r\n", - "prm.nx = 129\r\n", - "prm.nx = 4\r\n", - "prm.nx = 60\r\n", - "prm.nx = 61\r\n", + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some parameters, like mesh points (`nx`, `ny` and `nz`), trigger a validation operation when a new value is attributed to them.\n", + "Due to restrictions at the FFT library, they must be equal to:\n", + "\n", + "$$\n", + "n_i = \\left\\{ \\begin{array}{ll} 2^{1+a} \\times 3^b \\times 5^c &\\mbox{if periodic,} \\\\ 2^{1+a} \\times 3^b \\times 5^c + 1 &\\mbox{otherwise,}\n", + "\\end{array} \\right.\n", + "$$\n", + "\n", + "where $a$, $b$ and $c$ are non negative integers. In addition, the derivatives stencil imposes that:\n", + "\n", + "$$\n", + "n_i \\ge \\left\\{ \\begin{array}{ll} 8 &\\mbox{if periodic,} \\\\ 9 &\\mbox{otherwise.}\n", + "\\end{array} \\right.\n", + "$$\n", + "\n", + "Again, give it a try at the cellcode below:\n", + "\n", + "```python\n", + "prm.nx = 129\n", + "prm.nx = 4\n", + "prm.nx = 60\n", + "prm.nx = 61\n", "```" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [], + "metadata": {}, "outputs": [], - "metadata": {} + "source": [] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Observation" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Other parameters, like mesh resolution (`dx`, `dy` and `dz`), are automatically updated when any new attribution occurs to mesh points and/or domain size. Let's create a quick print functions to play with:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "def show_param():\r\n", - " for var in \"nclx1 nclxn nx xlx dx\".split():\r\n", + "def show_param():\n", + " for var in \"nclx1 nclxn nx xlx dx\".split():\n", " print(f\"{var:>5} = {getattr(prm, var)}\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "We are starting with:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "show_param()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Let's change just the domain's length:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "prm.xlx = 50.0\r\n", - "\r\n", + "prm.xlx = 50.0\n", + "\n", "show_param()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "The resolution was updated as well. Now the number of mesh points:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "prm.nx = 121\r\n", - "\r\n", + "prm.nx = 121\n", + "\n", "show_param()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Again, the resolution was updated. Now we set a new mesh resolution, this time, `xlx` will be updated in order to satisfy the new resolution:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "prm.dx = 1e-2\r\n", - "\r\n", - "show_param()" - ], + "metadata": {}, "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", "source": [ - "Boundary conditions are observed as well. Xcompact3d allows three different BC for velocity:\r\n", - "\r\n", - "* Periodic `0`;\r\n", - "* Free-slip `1`;\r\n", - "* Dirichlet `2`.\r\n", - "\r\n", - "They can be assigned individually for each of the six boundaries:\r\n", - "\r\n", - "* `nclx1` and `nclxn`, where $x=0$ and $x=xlx$;\r\n", - "* `ncly1` and `nclyn`, where $y=0$ and $y=yly$;\r\n", - "* `nclz1` and `nclzn`, where $z=0$ and $z=zlz$.\r\n", - "\r\n", - "It leads to 5 possibilities (`00`, `11`, `12`, `21` and `22`), because both boundary must be periodic, or not, so `0` cannot be combined.\r\n", - "\r\n", + "prm.dx = 1e-2\n", + "\n", + "show_param()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Boundary conditions are observed as well. Xcompact3d allows three different BC for velocity:\n", + "\n", + "* Periodic `0`;\n", + "* Free-slip `1`;\n", + "* Dirichlet `2`.\n", + "\n", + "They can be assigned individually for each of the six boundaries:\n", + "\n", + "* `nclx1` and `nclxn`, where $x=0$ and $x=xlx$;\n", + "* `ncly1` and `nclyn`, where $y=0$ and $y=yly$;\n", + "* `nclz1` and `nclzn`, where $z=0$ and $z=zlz$.\n", + "\n", + "It leads to 5 possibilities (`00`, `11`, `12`, `21` and `22`), because both boundary must be periodic, or not, so `0` cannot be combined.\n", + "\n", "Let's check it out, we are starting with:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "show_param()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "We will change just one side to periodic (`nclx1 = 0`), for consistence, the other side should be periodic too. Let's see:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "prm.nclx1 = 0\r\n", - "\r\n", + "prm.nclx1 = 0\n", + "\n", "show_param()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Now free-slip in one side (`nclx1 = 1`), and the other should be non-periodic:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "prm.nclx1 = 1\r\n", - "\r\n", + "prm.nclx1 = 1\n", + "\n", "show_param()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Setting the other boundary to periodic:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "prm.nclxn = 0\r\n", - "\r\n", + "prm.nclxn = 0\n", + "\n", "show_param()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "and now back to Dirichlet:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "prm.nclxn = 2\r\n", - "\r\n", + "prm.nclxn = 2\n", + "\n", "show_param()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "This time, free-slip:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "prm.nclxn = 1\r\n", - "\r\n", + "prm.nclxn = 1\n", + "\n", "show_param()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "There was no need to update `nclx1`, because `1` and `2` can be freely combined. Notice that `nx` was modified properly from 121 to 120 and then back, according to the possible values, `dx` and `xlx` stayed untouched." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Metadata" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "Traitlets types constructors have a `tag` method to store metadata in a dictionary. In the case of Xcompact3d-toolbox, two are especially useful:\r\n", - "\r\n", - "* `group` defines to what namespace a given parameter belongs when the class is written to `.i3d` file (`.write()` method) or read from `.i3d` or `.prm` files (`.load()` method), parameters without a group are ignored for both methods;\r\n", + "Traitlets types constructors have a `tag` method to store metadata in a dictionary. In the case of Xcompact3d-toolbox, two are especially useful:\n", + "\n", + "* `group` defines to what namespace a given parameter belongs when the class is written to `.i3d` file (`.write()` method) or read from `.i3d` or `.prm` files (`.load()` method), parameters without a group are ignored for both methods;\n", "* `desc` contains a brief description of each parameter that is shown on screen as we saw above, and also printed with the `.write()` method." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Declaring new parameters" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "You probably would like to add more parameters for your own flow configuration, or because some of them were not implemented yet (it is a work in progress).\r\n", - "\r\n", - "To do so, any auxiliar variable can be included after initialization, like:" - ], - "metadata": {} + "You probably would like to add more parameters for your own flow configuration, or because some of them were not implemented yet (it is a work in progress).\n", + "\n", + "To do so, any Auxiliary variable can be included after initialization, like:" + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "prm.my_variable = 0 # or any other datatype" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "It was called auxiliar variable because, in this way, it will be available only for the Python application.\r\n", - "\r\n", + "It was called Auxiliary variable because, in this way, it will be available only for the Python application.\n", + "\n", "In order to include it at the `.i3d` file and make it available for XCompact3d, we can create a subclass that inherits all the functionality from `xcompact3d_toolbox.Parameters`:" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": null, - "source": [ - "import traitlets\r\n", - "\r\n", - "\r\n", - "# Create a class named my_Parameters, which inherits the properties all properties and methods\r\n", - "class my_Parameters(x3d.Parameters):\r\n", - " # .tag with group and description guarantees that the new variable will\r\n", - " # be compatible with all functionalities (like .write() and .load())\r\n", - " my_variable = traitlets.Int(default_value=0, min=0).tag(\r\n", - " group=\"BasicParam\", desc=\"An example at the Tutorial <------\"\r\n", - " )\r\n", - "\r\n", - " # And a custom method, for instance\r\n", - " def my_method(self):\r\n", - " return self.my_variable * 2\r\n", - "\r\n", - "\r\n", - "prm = my_Parameters(nx=257, ny=129, nz=31, my_variable=10) # and here we go\r\n", - "\r\n", - "# Testing the method\r\n", - "print(prm.my_method())\r\n", - "\r\n", - "# Show all parameters on screen\r\n", + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import traitlets\n", + "\n", + "\n", + "# Create a class named MyParameters, which inherits the properties all properties and methods\n", + "class MyParameters(x3d.Parameters):\n", + " # .tag with group and description guarantees that the new variable will\n", + " # be compatible with all functionalities (like .write() and .load())\n", + " my_variable = traitlets.Int(default_value=0, min=0).tag(\n", + " group=\"BasicParam\", desc=\"An example at the Tutorial <------\"\n", + " )\n", + "\n", + " # And a custom method, for instance\n", + " def my_method(self):\n", + " return self.my_variable * 2\n", + "\n", + "\n", + "prm = MyParameters(nx=257, ny=129, nz=31, my_variable=10) # and here we go\n", + "\n", + "# Testing the method\n", + "print(prm.my_method())\n", + "\n", + "# Show all parameters on screen\n", "print(prm)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Take a look at the source code of [parameters.py](https://github.com/fschuch/xcompact3d_toolbox/blob/main/xcompact3d_toolbox/parameters.py) if you need more examples for different data types." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Graphical User Interface" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "
\r\n", - "\r\n", - "For an interactive experience [launch this tutorial on Binder](https://mybinder.org/v2/gh/fschuch/xcompact3d_toolbox/main?labpath=.%2Fdocs%2Ftutorial), the widgets are not so responsive when disconnected from a Python application.\r\n", - "\r\n", + "
\n", + "\n", + "For an interactive experience [launch this tutorial on Binder](https://mybinder.org/v2/gh/fschuch/xcompact3d_toolbox/main?labpath=.%2Fdocs%2Ftutorial), the widgets are not so responsive when disconnected from a Python application.\n", + "\n", "
" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "To conclude this part of the tutorial, let's see another option to handle the parameters. The class `ParametersGui` is a subclass of `Parameters`, and includes all the features described above. In addition, `ParametersGui` offers an user interface with [IPywidgets](https://ipywidgets.readthedocs.io/en/stable/index.html).\r\n", - "\r\n", - "It is still under development, more parameters and features are going to be included soon, as well as more widgets.\r\n", - "\r\n", + "To conclude this part of the tutorial, let's see another option to handle the parameters. The class `ParametersGui` is a subclass of `Parameters`, and includes all the features described above. In addition, `ParametersGui` offers an user interface with [IPywidgets](https://ipywidgets.readthedocs.io/en/stable/index.html).\n", + "\n", + "It is still under development, more parameters and features are going to be included soon, as well as more widgets.\n", + "\n", "Just like before, we start with:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "prm = x3d.ParametersGui()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Widgets are returned on demand when any instance of `class ParametersGui` is called, let’s see:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "prm(\"nx\", \"xlx\", \"dx\", \"nclx1\", \"nclxn\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "You can play around with the widgets above and see the effect of the observations made previously.\r\n", - "\r\n", + "You can play around with the widgets above and see the effect of the observations made previously.\n", + "\n", "Notice that the [Traitlets](https://traitlets.readthedocs.io/en/stable/index.html) parameters are related to the value at their widgets in a **two-way link**, in this way, a print will show the actual value on the widgets:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "show_param()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "Give it a try, modify the values at the widgets and print them again.\r\n", - "\r\n", + "Give it a try, modify the values at the widgets and print them again.\n", + "\n", "It also works on the other way, set a new value to a parameters will change its widget, try it:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "#prm.nclx1 = 0" - ], + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "# prm.nclx1 = 0\n", + "\n" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "And of course, different widgets for the same parameter are always synchronized, change the widget below and see what happens with the widget above:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "prm('nx')" - ], + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "prm(\"nx\")" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "A last example is about the domain decomposition for parallel computation, Xcompact3d uses [2DECOMP&FFT](http://www.2decomp.org/).\r\n", + "A last example is about the domain decomposition for parallel computation, Xcompact3d uses [2DECOMP&FFT](http://www.2decomp.org/).\n", "The available options for `p_row` and `p_col` are presented as functions of the number of computational cores `ncores`, notice that `p_row * p_col = ncores` should be respected and `p_row * p_col = 0` activates the auto-tunning mode. The widgets are prepared to respect these restrictions:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [ - "prm('ncores', 'p_row', 'p_col')" - ], + "metadata": {}, "outputs": [], - "metadata": {} + "source": [ + "prm(\"ncores\", \"p_row\", \"p_col\")" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "To conclude this part of the tutorial, let’s see what happens when `class ParametersGui` is presented on screen, hover the mouse over some variable to see its description:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "prm" - ], - "outputs": [], - "metadata": {} + ] } ], "metadata": { + "interpreter": { + "hash": "546d5beeb22119d9a20f6c19239ae627cc2b69f70be285d1d696980c89f3c939" + }, "kernelspec": { - "name": "python3", - "display_name": "Python 3.9.5 64-bit ('idp': conda)" + "display_name": "Python 3.9.5 64-bit ('idp': conda)", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -797,2912 +802,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.5" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "004d89f6817d46ec86046346f797174d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "033a47dedd7b4b02b0206dc97d0adedc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedIntTextModel", - "state": { - "description": "nvisu", - "description_tooltip": "Size for visualization collection", - "disabled": true, - "layout": "IPY_MODEL_3a7a2487fae64579afe2583a40f4c3e2", - "max": 1000000000, - "min": 1, - "style": "IPY_MODEL_a536eb16080744fca4928ef79dc57529", - "value": 1 - } - }, - "0340223fe30d484892b21e9334b0aebd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "0391420ece174d27bc205b366db17507": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "049024b5d0e9490292899ddbeb7a01b0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Periodic", - "Free-slip", - "No-slip" - ], - "description": "nclyn", - "description_tooltip": "Velocity boundary condition where y=yly", - "index": 2, - "layout": "IPY_MODEL_cf666ac5cd584eb98d767128822b79df", - "style": "IPY_MODEL_6e1d39a0c8c341108c9ce70a528d1335" - } - }, - "04ef7aed9f034871b2dd97eae7beaf93": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "058f8eeb578740c2949de722a9a783a2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "05b5651c6ee04fdeb3ecbb9431aac49a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "05f2cded3ed644a1873dfdd4e8c57a73": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "084c5628d4194a6798366ed2bd892009": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "092e7f78cd4e43209049a1486223d307": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "description": "Write", - "disabled": true, - "icon": "file-download", - "layout": "IPY_MODEL_45a2ff9b0a314c228092b3d5b2a59640", - "style": "IPY_MODEL_ad76801c8ac04494922e0e6903e4a176" - } - }, - "0a087f17bf294318ade98c389780f5be": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Periodic", - "No-flux", - "Dirichlet" - ], - "description": "nclxSn", - "description_tooltip": "Scalar boundary condition where x=xlx", - "index": 2, - "layout": "IPY_MODEL_7bb4fcaeeca940ebb4efd4a97d130ed1", - "style": "IPY_MODEL_d688cc616ad04b1fb84b62eb6b0dcb4e" - } - }, - "0acadf726eeb4806950580399e3d84f0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "IntSliderModel", - "state": { - "description": "nraf", - "description_tooltip": "Level of refinement for iibm==2 to find the surface of the immersed object", - "layout": "IPY_MODEL_467b14b2dca54e75a63e5c92e600ab48", - "max": 25, - "min": 1, - "style": "IPY_MODEL_fb3a3bf61b0840739b74ae7f8978f572", - "value": 10 - } - }, - "0d60cce4a6514241bc08d4746675f5cd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "0de280c23f3048fd97abb3af21d38270": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Periodic", - "Free-slip", - "Outflow" - ], - "description": "nclxn", - "description_tooltip": "Velocity boundary condition where x=xlx", - "index": 2, - "layout": "IPY_MODEL_92722eb760f74795a2fd0fea78eb4d2d", - "style": "IPY_MODEL_7eaced5f15fa4b288066511e95dbf9c9" - } - }, - "0e55e49f3fe8433fa12abc2c85e5f5c5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "0e91b08a8c12438ca174a07fb18bb27e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "0f39dca962bb4bdd87d066b674d359b4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "DNS", - "Phys Smag", - "Phys WALE", - "Phys dyn. Smag", - "iSVV" - ], - "description": "jles", - "description_tooltip": "LES Model (1: Phys Smag, 2: Phys WALE, 3: Phys dyn. Smag, 4: iSVV)", - "index": 4, - "layout": "IPY_MODEL_473c1cb4d7b946b8bc049f90def9a2cf", - "style": "IPY_MODEL_32fea14b00be495090548bbea564dc1c" - } - }, - "0f643ff9f37941788c53e1710192ead1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "1064430f947c41688ede2426029a0629": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "10aafa327e324f619cdadbcd5dc5e89a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "10daccc0e6cb4a76a6082881e867bb75": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "1160b790683f4d0cab3cd0b4fe95f445": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "11a3074c8faf4dce895358fdc83370a3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "11bd3075b7ae484b87bd49eb582e2df0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_b2408111f69642b097006c4f02b40ca6", - "IPY_MODEL_033a47dedd7b4b02b0206dc97d0adedc", - "IPY_MODEL_d8ea7a41dbd64c60a67209dfa15c247a" - ], - "layout": "IPY_MODEL_bfe1134576974610ba800d40156d0ac3" - } - }, - "159eaced52ed45ab9a81946bbd56e29e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "9", - "11", - "13", - "17", - "19", - "21", - "25", - "31", - "33", - "37", - "41", - "49", - "51", - "55", - "61", - "65", - "73", - "81", - "91", - "97", - "101", - "109", - "121", - "129", - "145", - "151", - "161", - "163", - "181", - "193", - "201", - "217", - "241", - "251", - "257", - "271", - "289", - "301", - "321", - "325", - "361", - "385", - "401", - "433", - "451", - "481", - "487", - "501", - "513", - "541", - "577", - "601", - "641", - "649", - "721", - "751", - "769", - "801", - "811", - "865", - "901", - "961", - "973", - "1001", - "1025", - "1081", - "1153", - "1201", - "1251", - "1281", - "1297", - "1351", - "1441", - "1459", - "1501", - "1537", - "1601", - "1621", - "1729", - "1801", - "1921", - "1945", - "2001", - "2049", - "2161", - "2251", - "2305", - "2401", - "2431", - "2501", - "2561", - "2593", - "2701", - "2881", - "2917", - "3001", - "3073", - "3201", - "3241", - "3457", - "3601", - "3751", - "3841", - "3889", - "4001", - "4051", - "4097", - "4321", - "4375", - "4501", - "4609", - "4801", - "4861", - "5001", - "5121", - "5185", - "5401", - "5761", - "5833", - "6001", - "6145", - "6251", - "6401", - "6481", - "6751", - "6913", - "7201", - "7291", - "7501", - "7681", - "7777", - "8001", - "8101", - "8193", - "8641", - "8749", - "9001" - ], - "description": "nz", - "description_tooltip": "Z-direction nodes", - "index": 3, - "layout": "IPY_MODEL_2bf49480f49d4d48b68156c838febc53", - "style": "IPY_MODEL_c6177904a34a41b7ae46a15bef8f99b1" - } - }, - "17b0c8a94924459c908347df62669715": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "1873aff1c3c34f209f6569dc7f4e01a7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "VBoxModel", - "state": { - "children": [ - "IPY_MODEL_a62020b0f02847bdbf2e539927caacff", - "IPY_MODEL_d48cbef374c64e6596f1d55e03f947d9", - "IPY_MODEL_58015c9397ee4395af335c00dcfcfee2" - ], - "layout": "IPY_MODEL_5c9b5c77d0904e1aba7a4f33352170d9" - } - }, - "1aa57dbda5084118951b456dd9b2d81c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "1b80fbd1b6a54077b56a62ce39d2842e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "1c4a2d538f534f0995df7da85089fd07": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "1e0272cb2a2441c8b63436d028cf2dad": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_ff743bbe1aad4eb08eb6e0b82f21566b", - "style": "IPY_MODEL_7f1eb8f2a82a4c279e458752b2133df4", - "value": "

BasicParam

" - } - }, - "1e07e37dd53942aabafefd5150417438": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedIntTextModel", - "state": { - "description": "ilast", - "description_tooltip": "The number for the last iteration", - "layout": "IPY_MODEL_2f12ee8d414c4cd4b1e998d29766cdfc", - "max": 1000000000, - "style": "IPY_MODEL_d6dfbb3e85094b76836ca14438cbc583" - } - }, - "1e615768c6a64f19b855107aef6d99fe": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_9c2addf77a524c27a4dae05fbde9c860", - "IPY_MODEL_a2549c243c06437db9d9c3d9657a77c9", - "IPY_MODEL_092e7f78cd4e43209049a1486223d307", - "IPY_MODEL_38768b8fc6874b308987808385963ca3", - "IPY_MODEL_be3e6e0793ab4f729a72ab6601a5cfc6" - ], - "layout": "IPY_MODEL_eea49cafd1814dfe8583cbcdaed78045" - } - }, - "1eb056ece6f842729a78a1d1169a1cf1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "1f953fd9925a45e98f92e05f5ecc5ae0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "2165d92569ec42df8cdf154f8d6ea971": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "216db63584b34a95b118a7fb8da29176": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "VBoxModel", - "state": { - "children": [ - "IPY_MODEL_a7cd4de718b94786b745a21555efb51b", - "IPY_MODEL_c37e0d30f0644d1aae61a704e7ca31f1", - "IPY_MODEL_317d3303f9e34077aa32c83465ac4d0e", - "IPY_MODEL_30e5fea3f85345bea320fb3e46a5d8a6", - "IPY_MODEL_0de280c23f3048fd97abb3af21d38270" - ], - "layout": "IPY_MODEL_82abcb61660249069541aa11c63d62e3" - } - }, - "21c5fab946a44c4ca7868087dba946da": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "21ed77de852a4c99817d70dc9118e716": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "23ef3253621247c79e54e0cb8c5b3a5c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedIntTextModel", - "state": { - "description": "ioutput", - "description_tooltip": "Frequency for visualization file", - "layout": "IPY_MODEL_edcc1d29263449a5b725bd4e2591e9df", - "max": 1000000000, - "min": 1, - "step": 100, - "style": "IPY_MODEL_004d89f6817d46ec86046346f797174d", - "value": 1000 - } - }, - "25541005624749ee947063622f157848": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "27723405a4844e0983700b6b06af9d43": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedFloatTextModel", - "state": { - "description": "dt", - "description_tooltip": "Time step", - "layout": "IPY_MODEL_ff3fe5a18e4f495eb9024431c194f889", - "max": 1000000000, - "min": 1e-9, - "step": null, - "style": "IPY_MODEL_a9eb19e1ac2c4cf3ad8c7a2e5f7757e1", - "value": 0.001 - } - }, - "2a7197aebac4429cad65d8b8fec9e283": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "2a7aef68bb1049068d2a28f54fdcf27f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "2aa408d2f3b141048b1ac95e511bf426": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "2bf49480f49d4d48b68156c838febc53": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "2c0b137e40ca47c4829b5862de1f743d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "2ec81e93a7044f1e889cad9a4a79eece": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "2f12ee8d414c4cd4b1e998d29766cdfc": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "30732f84a08f4bda93dbfefd340a7b9b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Euler", - "AB2", - "AB3", - "RK3", - "Semi-implicit" - ], - "description": "itimescheme", - "description_tooltip": "Time integration scheme (1: Euler, 2: AB2, 3: AB3, 5: RK3)", - "index": 2, - "layout": "IPY_MODEL_a6a425d95c2d4a9f8783818bcb2b777a", - "style": "IPY_MODEL_4f06f2cff71449548642af60a9c005c1" - } - }, - "30e5fea3f85345bea320fb3e46a5d8a6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Periodic", - "Free-slip", - "Inflow" - ], - "description": "nclx1", - "description_tooltip": "Velocity boundary condition where x=0", - "index": 2, - "layout": "IPY_MODEL_dfb45b32c62c4a1c81a61aece03e6093", - "style": "IPY_MODEL_ab265f92e19c46b3a15cce0e89a49610" - } - }, - "317d3303f9e34077aa32c83465ac4d0e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedFloatTextModel", - "state": { - "description": "dx", - "layout": "IPY_MODEL_ba012519863b4b9b9578077f6394c7d1", - "max": 1000000, - "step": null, - "style": "IPY_MODEL_89caac40af6d44db8c1627073b700cbb", - "value": 0.0625 - } - }, - "32fea14b00be495090548bbea564dc1c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "330c5077b2ef4457a744bba4e738877e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatTextModel", - "state": { - "description": "init_noise", - "description_tooltip": "Turbulence intensity (1=100%) !! Initial condition", - "layout": "IPY_MODEL_6a9097e3d5ef4e2e978e8175e102c799", - "step": null, - "style": "IPY_MODEL_f5a99efb5ec043aabcc06ff9f1d87c0d" - } - }, - "3409b771bc204669bdf0caa568da202a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "346385af69b347efba855400f4acacbf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_cb76ce58ba3447089103d5a23ac831b4", - "style": "IPY_MODEL_2ec81e93a7044f1e889cad9a4a79eece", - "value": "

IBMStuff

" - } - }, - "35cebe6f89bd4c95bf7f957bf406e498": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "36309f01824943fd8dbefd95b9ed33ee": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_c9f68c17a0a343e39b0c9f77b157dce2", - "IPY_MODEL_1e07e37dd53942aabafefd5150417438", - "IPY_MODEL_27723405a4844e0983700b6b06af9d43" - ], - "layout": "IPY_MODEL_708873558f14408f994d2e229e19efa3" - } - }, - "379f23bb857148b698e8939f5dcb3a5a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "37bc5f4a457347e784ba828e4b167755": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "37e5333bb52f465085f9f79b5bd56694": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "37fac51138d44a7e87d0fff10458c9a5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "38768b8fc6874b308987808385963ca3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "description": "Run", - "disabled": true, - "icon": "rocket", - "layout": "IPY_MODEL_b94b81b7c8fd4e6292655174c25fd398", - "style": "IPY_MODEL_7abfa57b1c384506bb8d9c4e79cc4fab" - } - }, - "389f7f549ddb4f4881a7b21adc732525": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "3a18814b23874aa3bf47942e3dab0ec2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Off", - "On" - ], - "description": "ivisu", - "description_tooltip": "Enable store snapshots at a frequency ioutput (0: No, 1: Yes)", - "index": 1, - "layout": "IPY_MODEL_3ec37cd9d5154ff990e7442ee9e6d39a", - "style": "IPY_MODEL_0f643ff9f37941788c53e1710192ead1" - } - }, - "3a7a2487fae64579afe2583a40f4c3e2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "3be17c4d13e6418c96e7d3619cd4f979": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "No random noise", - "Random noise", - "Random noise with fixed seed" - ], - "description": "iin", - "description_tooltip": "Defines perturbation at initial condition", - "index": 0, - "layout": "IPY_MODEL_c3f9232c0b9843cbbd6dd8c44084797e", - "style": "IPY_MODEL_5958bc2256fe40ff9c0deaedba02b252" - } - }, - "3cd1a495230a44a69f313e4cebee17f7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "3d44fa4f0bc6485cacd7f48611736e9f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "3ec37cd9d5154ff990e7442ee9e6d39a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "40fe4651e90047078386fd14052431b0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_4770a0be0b5c4f04ab67f908dbd99323", - "style": "IPY_MODEL_66713c9d6b2e4b55878bd687e3491ad5", - "value": "

Temporal discretization

" - } - }, - "42142cbaed6c4b5a9e0fd18af9c4bf3b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_a62020b0f02847bdbf2e539927caacff", - "IPY_MODEL_d48cbef374c64e6596f1d55e03f947d9", - "IPY_MODEL_58015c9397ee4395af335c00dcfcfee2" - ], - "layout": "IPY_MODEL_eabde9b4ac504db5832e15be4f47d904" - } - }, - "422b51a9211b4418ad2e869641ba4c0d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "45a2ff9b0a314c228092b3d5b2a59640": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "467b14b2dca54e75a63e5c92e600ab48": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "473c1cb4d7b946b8bc049f90def9a2cf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "4770a0be0b5c4f04ab67f908dbd99323": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "48b6d32f009a4f0abf17b255c2a6c63e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Periodic", - "No-flux", - "Dirichlet" - ], - "description": "nclySn", - "description_tooltip": "Scalar boundary condition where y=yly", - "index": 2, - "layout": "IPY_MODEL_ecd43b4e4a6f40739b7eb213e2875d68", - "style": "IPY_MODEL_822186a41a654062aa74d23f3abf0a80" - } - }, - "4ca48b3a7c104d68b84621ff83b6a96d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "4f06f2cff71449548642af60a9c005c1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "4f244c334bd5468e80d4f6ab423e1192": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "500eabf8e21b4ae4979fb4d70536121c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "5141797629184b0fa7d26e2b2149b547": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedFloatTextModel", - "state": { - "description": "nu0nu", - "description_tooltip": "Ratio between hyperviscosity/viscosity at nu (dissipation factor intensity)", - "layout": "IPY_MODEL_3d44fa4f0bc6485cacd7f48611736e9f", - "max": 1000000, - "step": null, - "style": "IPY_MODEL_bdc9268fc00e48df87f568b7654aac24", - "value": 4 - } - }, - "51eeb6fb247441d0a4b76f06678073c4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_a63a89f1d8574457a3267911cbe4d022", - "IPY_MODEL_23ef3253621247c79e54e0cb8c5b3a5c", - "IPY_MODEL_74f894794e2c41108d86b5348ca49d33" - ], - "layout": "IPY_MODEL_c0d03af6ce644444bcab43b27a249efb" - } - }, - "521ff6f22e8d44cc99ca8223a2f2d299": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Off", - "Forced to zero", - "Interpolated to zero" - ], - "description": "iibm", - "description_tooltip": "Flag for immersed boundary method (0: No, 1: Yes)", - "index": 0, - "layout": "IPY_MODEL_edf008c827f642cc837e42f6d5a1203c", - "style": "IPY_MODEL_d59407fb6b4c470ebab3f4410a1c4cc3" - } - }, - "538f02181eaa499e99386819844b21ff": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "56c5dc8b1375485399bc3b2d71a640c8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatTextModel", - "state": { - "description": "inflow_noise", - "description_tooltip": "Turbulence intensity (1=100%) !! Inflow condition", - "layout": "IPY_MODEL_aa082208bc1941ec9ac2ccc8c924d9a5", - "step": null, - "style": "IPY_MODEL_2c0b137e40ca47c4829b5862de1f743d" - } - }, - "58015c9397ee4395af335c00dcfcfee2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "1", - "2", - "4", - "0" - ], - "description": "p_col", - "description_tooltip": "Column partition for domain decomposition and parallel computation", - "index": 3, - "layout": "IPY_MODEL_37fac51138d44a7e87d0fff10458c9a5", - "style": "IPY_MODEL_835aa8e18be0414b9edc258668fd8db5" - } - }, - "58712aab97814f9aac058afceb275069": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "5958bc2256fe40ff9c0deaedba02b252": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "5a882b2f0fcb4e9fbd8ce97b4caa3fa9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Periodic", - "No-flux", - "Dirichlet" - ], - "description": "nclzSn", - "description_tooltip": "Scalar boundary condition where z=zlz", - "index": 2, - "layout": "IPY_MODEL_979b3d0c492243019b6bbd47cc9d7a2d", - "style": "IPY_MODEL_5fa85259863e47c78623f8de2fb9c461" - } - }, - "5ae396b700d54d1584a487c8cbfa3cf5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedFloatTextModel", - "state": { - "description": "dz", - "layout": "IPY_MODEL_37e5333bb52f465085f9f79b5bd56694", - "max": 1000000, - "step": null, - "style": "IPY_MODEL_cb2a1d59173c48ac9799936ea849768b", - "value": 0.0625 - } - }, - "5c9b5c77d0904e1aba7a4f33352170d9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "5fa85259863e47c78623f8de2fb9c461": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "607467f09ee14b2591dee01de604266d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "User", - "Lock-exchange", - "Taylor-Green Vortex", - "Channel", - "Periodic Hill", - "Cylinder", - "Debug Schemes", - "Mixing Layer", - "Turbulent Jet", - "Turbulent Boundary Layer", - "ABL", - "Uniform", - "Sandbox" - ], - "description": "itype", - "description_tooltip": "Flow configuration (1:Lock-exchange, 2:TGV, 3:Channel, and others)", - "index": 12, - "layout": "IPY_MODEL_d481579d2a9344f4838c6b7c3e39d1ab", - "style": "IPY_MODEL_379f23bb857148b698e8939f5dcb3a5a" - } - }, - "60b752c55de44843b4f88120ac8ee348": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "VBoxModel", - "state": { - "children": [ - "IPY_MODEL_86ef274fc1cd49e28ee712957b239586", - "IPY_MODEL_1e615768c6a64f19b855107aef6d99fe", - "IPY_MODEL_1e0272cb2a2441c8b63436d028cf2dad", - "IPY_MODEL_95bfad8c9b4c42539eb04a7e03fae8b5", - "IPY_MODEL_6ccda31644de4defb40275ccbebea99d", - "IPY_MODEL_7793bec12b744d3d9f4998b947a4338a", - "IPY_MODEL_42142cbaed6c4b5a9e0fd18af9c4bf3b", - "IPY_MODEL_40fe4651e90047078386fd14052431b0", - "IPY_MODEL_36309f01824943fd8dbefd95b9ed33ee", - "IPY_MODEL_86edb73f8b524b02bea9f44901ca1276", - "IPY_MODEL_11bd3075b7ae484b87bd49eb582e2df0", - "IPY_MODEL_51eeb6fb247441d0a4b76f06678073c4", - "IPY_MODEL_df62802c11224e96905df948b3148720", - "IPY_MODEL_c81078da6753456db34e0fa7531a0d46", - "IPY_MODEL_f7eaa2adbfc9453380ad7b0f9320f803", - "IPY_MODEL_ccffe2a955a74bb0a07d56a04cee3922", - "IPY_MODEL_c5fc24f0456b4eaa9a3aaa78bd0e0183", - "IPY_MODEL_69e3b6f737c94383b0f1adf8e2609dd2", - "IPY_MODEL_e701aff0508b4e38a027742794f315bd", - "IPY_MODEL_bfb4d53f942749578fcdc5783006e253", - "IPY_MODEL_a08ef42ee2b24692ac82428b29fd2329", - "IPY_MODEL_874a995581c345ff87ba847601cc7c72", - "IPY_MODEL_afa20e3d21a944309cbeff77e4b90818", - "IPY_MODEL_fc9991b0d5fc4aee816c8f7d56687962", - "IPY_MODEL_66efa40448974b69aa489b9b77017129", - "IPY_MODEL_cdb9c88934274c2cb56afba1798be271", - "IPY_MODEL_9938facae1c84086b9ae29af9067ea09", - "IPY_MODEL_ca4cd1ccb9ba43308d38049970f379aa", - "IPY_MODEL_346385af69b347efba855400f4acacbf", - "IPY_MODEL_b8ea8a960d884f0dbfaf4f4c799ef095" - ], - "layout": "IPY_MODEL_0d60cce4a6514241bc08d4746675f5cd" - } - }, - "61666884847d4212bd89ecff32ac8403": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Off", - "On" - ], - "description": "ilesmod", - "description_tooltip": "Enables Large-Eddy methodologies (0: No, 1: Yes)", - "index": 0, - "layout": "IPY_MODEL_1b80fbd1b6a54077b56a62ce39d2842e", - "style": "IPY_MODEL_10daccc0e6cb4a76a6082881e867bb75" - } - }, - "62c251249be74bb7a5d0ff31e559ee71": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "6541fd89b24b4169899827b63c47d13f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "66713c9d6b2e4b55878bd687e3491ad5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "66efa40448974b69aa489b9b77017129": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_c0ba6e3dc9cc424caba79033bb6b940d", - "IPY_MODEL_b683841fef6e400bac6759ddd3442a2b", - "IPY_MODEL_e9b0320c0ba5474ca2569fc162e02d05" - ], - "layout": "IPY_MODEL_f221420f506b45f88b97eedbfaf55d07" - } - }, - "69e3b6f737c94383b0f1adf8e2609dd2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_0de280c23f3048fd97abb3af21d38270", - "IPY_MODEL_049024b5d0e9490292899ddbeb7a01b0", - "IPY_MODEL_a6dcc34c6fa9489089829ab22fdcb0cf" - ], - "layout": "IPY_MODEL_efb7e0d6b6ed484b95228874759e847c" - } - }, - "6a7f07ac8216425ab136bbed23fd150a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedFloatTextModel", - "state": { - "description": "zlz", - "description_tooltip": "Size of the box in z-direction", - "layout": "IPY_MODEL_2a7197aebac4429cad65d8b8fec9e283", - "max": 1000000000, - "step": null, - "style": "IPY_MODEL_c3cd8f0e945b45b19e0be779f1c523ee", - "value": 1 - } - }, - "6a9097e3d5ef4e2e978e8175e102c799": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "6cba8df0b2b947fdaf77fd7346ea0d8a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "6ccda31644de4defb40275ccbebea99d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_3be17c4d13e6418c96e7d3619cd4f979", - "IPY_MODEL_330c5077b2ef4457a744bba4e738877e", - "IPY_MODEL_56c5dc8b1375485399bc3b2d71a640c8" - ], - "layout": "IPY_MODEL_10aafa327e324f619cdadbcd5dc5e89a" - } - }, - "6e1d39a0c8c341108c9ce70a528d1335": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "6ebde3a626844bacaf2faccf12f738f2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "6f48266c991a472c9915eed9cda3898c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "708873558f14408f994d2e229e19efa3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "71a99cbc04b5487888ddae29499f00fe": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "723c7457c16c45ac97764bbe07c085e1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "74f894794e2c41108d86b5348ca49d33": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedIntTextModel", - "state": { - "description": "iprocessing", - "description_tooltip": "Frequency for online postprocessing", - "layout": "IPY_MODEL_a98278f650104217ac13d44fd7d5ba23", - "max": 1000000000, - "min": 1, - "step": 100, - "style": "IPY_MODEL_e919455dc7db408b9118937e0d5d96ac", - "value": 1000 - } - }, - "76567d938fca4533b2bce636c727f52b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "7793bec12b744d3d9f4998b947a4338a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_05f2cded3ed644a1873dfdd4e8c57a73", - "style": "IPY_MODEL_8ebdb795d8c846f88bb6ceb3fdc83a12", - "value": "

Domain Decomposition

" - } - }, - "782d12afaf1f43dbb173b7653eb14ddd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedFloatTextModel", - "state": { - "description": "beta", - "description_tooltip": "Refinement parameter", - "layout": "IPY_MODEL_1c4a2d538f534f0995df7da85089fd07", - "max": 1000000000, - "step": null, - "style": "IPY_MODEL_538f02181eaa499e99386819844b21ff", - "value": 1 - } - }, - "7a38e1cf3d104cec80cbcf9934564829": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatTextModel", - "state": { - "description": "gravx", - "description_tooltip": "Gravity unitary vector in x-direction", - "layout": "IPY_MODEL_389f7f549ddb4f4881a7b21adc732525", - "step": null, - "style": "IPY_MODEL_37bc5f4a457347e784ba828e4b167755" - } - }, - "7abfa57b1c384506bb8d9c4e79cc4fab": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonStyleModel", - "state": {} - }, - "7ad5bb85c8354a72aa1568d7eec9b70a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "7ba39ee800c94caa9c77d8a9f84af2db": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "7bb4fcaeeca940ebb4efd4a97d130ed1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "7d4ff6b147cb4feba4416324679fbb17": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "7dab99ad36dc410b9298df5513c5bcdc": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "7eaced5f15fa4b288066511e95dbf9c9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "7f1eb8f2a82a4c279e458752b2133df4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "81bdce06d336415fb7e2d9c0a4c244b8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "822186a41a654062aa74d23f3abf0a80": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "825d125b628f494f8676943d498d9372": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedFloatTextModel", - "state": { - "description": "cnu", - "description_tooltip": "Ratio between hyperviscosity at km=2/3π and kc=π (dissipation factor range)", - "layout": "IPY_MODEL_e06516dd3df840a2b41cf975a4384b79", - "max": 1000000, - "step": null, - "style": "IPY_MODEL_58712aab97814f9aac058afceb275069", - "value": 0.44 - } - }, - "82abcb61660249069541aa11c63d62e3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "82b7d4c07a014a3f9aae16e4d045395f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "VBoxModel", - "state": { - "children": [ - "IPY_MODEL_a7cd4de718b94786b745a21555efb51b" - ], - "layout": "IPY_MODEL_f97205738af3433d91d94cb893098982" - } - }, - "835aa8e18be0414b9edc258668fd8db5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "85d3712243a542b29e736e6b6e7204b0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "86edb73f8b524b02bea9f44901ca1276": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_eb26635f12124aee849f65063e50405b", - "style": "IPY_MODEL_d3ea062efc4345bab34a2b4dba578a1f", - "value": "

InOutParam

" - } - }, - "86ef274fc1cd49e28ee712957b239586": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_d0ac08b8b1104a90a1431d293190932e", - "style": "IPY_MODEL_1064430f947c41688ede2426029a0629", - "value": "

Xcompact3d Parameters

" - } - }, - "874a995581c345ff87ba847601cc7c72": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_61666884847d4212bd89ecff32ac8403", - "IPY_MODEL_5141797629184b0fa7d26e2b2149b547", - "IPY_MODEL_825d125b628f494f8676943d498d9372" - ], - "layout": "IPY_MODEL_084c5628d4194a6798366ed2bd892009" - } - }, - "87c73776cec64ad1b60707fc1d3c2205": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedIntTextModel", - "state": { - "description": "nobjmax", - "description_tooltip": "Maximum number of objects in any direction", - "layout": "IPY_MODEL_25541005624749ee947063622f157848", - "max": 1000000000, - "min": 1, - "style": "IPY_MODEL_2165d92569ec42df8cdf154f8d6ea971", - "value": 1 - } - }, - "89caac40af6d44db8c1627073b700cbb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "8a1715fc7b184069bbfa1e3657dcad3e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Periodic", - "Free-slip", - "No-slip" - ], - "description": "nclz1", - "description_tooltip": "Velocity boundary condition where z=0", - "index": 2, - "layout": "IPY_MODEL_7dab99ad36dc410b9298df5513c5bcdc", - "style": "IPY_MODEL_2a7aef68bb1049068d2a28f54fdcf27f" - } - }, - "8b2b6ae92fca44529946be2cb8740afb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "8b9058f25d3d4d4d95ae903b46bb7def": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedFloatTextModel", - "state": { - "description": "dy", - "layout": "IPY_MODEL_3cd1a495230a44a69f313e4cebee17f7", - "max": 1000000, - "step": null, - "style": "IPY_MODEL_6cba8df0b2b947fdaf77fd7346ea0d8a", - "value": 0.0625 - } - }, - "8ebdb795d8c846f88bb6ceb3fdc83a12": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "8ef504aa014946d2af68a7b7aeb34c83": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "92722eb760f74795a2fd0fea78eb4d2d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "95bfad8c9b4c42539eb04a7e03fae8b5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_607467f09ee14b2591dee01de604266d", - "IPY_MODEL_cad81637953a433b9403220f000d135c" - ], - "layout": "IPY_MODEL_723c7457c16c45ac97764bbe07c085e1" - } - }, - "979b3d0c492243019b6bbd47cc9d7a2d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "9938facae1c84086b9ae29af9067ea09": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_7a38e1cf3d104cec80cbcf9934564829", - "IPY_MODEL_a0a34a2ecef041d88978da85cfcd3b8b", - "IPY_MODEL_e31750f790c342cfaa1eada46a6e8971" - ], - "layout": "IPY_MODEL_cb8bd0ad64d54c40be5cd4a019e08332" - } - }, - "99c3abc8bd6f49d5a67b7058e54090fa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedFloatTextModel", - "state": { - "description": "yly", - "description_tooltip": "Size of the box in y-direction", - "layout": "IPY_MODEL_9a0f326257fe4fa2be93386e96acb17a", - "max": 1000000000, - "step": null, - "style": "IPY_MODEL_71a99cbc04b5487888ddae29499f00fe", - "value": 1 - } - }, - "9a0f326257fe4fa2be93386e96acb17a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "9c2addf77a524c27a4dae05fbde9c860": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "TextModel", - "state": { - "description": "filename", - "layout": "IPY_MODEL_7ba39ee800c94caa9c77d8a9f84af2db", - "style": "IPY_MODEL_f87ab929a1744692b8ec8722af44a5e4", - "value": "input.i3d" - } - }, - "9fa7e86704d94043aa067b829fc0dcec": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "a08ef42ee2b24692ac82428b29fd2329": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_b46d926a0d9e46469d486842c8fb138f", - "IPY_MODEL_b37f7ecc6ae3432ab38836884114fd62", - "IPY_MODEL_30732f84a08f4bda93dbfefd340a7b9b" - ], - "layout": "IPY_MODEL_1f953fd9925a45e98f92e05f5ecc5ae0" - } - }, - "a0a34a2ecef041d88978da85cfcd3b8b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatTextModel", - "state": { - "description": "gravy", - "description_tooltip": "Gravity unitary vector in y-direction", - "layout": "IPY_MODEL_ee95542c884d40bfbad33786b31bca11", - "step": null, - "style": "IPY_MODEL_e618cd7cce6f43e784757ed661ff2bf1" - } - }, - "a2549c243c06437db9d9c3d9657a77c9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "description": "Read", - "disabled": true, - "icon": "file-upload", - "layout": "IPY_MODEL_c4ca7b757171443d8c84d16cc29bb49f", - "style": "IPY_MODEL_aab59359a5f64af58fe7f994f05c5afe" - } - }, - "a28626dda4934048933975b0207e3c60": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "a536eb16080744fca4928ef79dc57529": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "a62020b0f02847bdbf2e539927caacff": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedIntTextModel", - "state": { - "description": "ncores", - "layout": "IPY_MODEL_17b0c8a94924459c908347df62669715", - "max": 1000000000, - "style": "IPY_MODEL_422b51a9211b4418ad2e869641ba4c0d", - "value": 4 - } - }, - "a63a89f1d8574457a3267911cbe4d022": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedIntTextModel", - "state": { - "description": "icheckpoint", - "description_tooltip": "Frequency for writing backup file", - "layout": "IPY_MODEL_d1d34bd4dbc747b5ad6f984f0a2c2afb", - "max": 1000000000, - "min": 1, - "step": 100, - "style": "IPY_MODEL_8b2b6ae92fca44529946be2cb8740afb", - "value": 1000 - } - }, - "a6a425d95c2d4a9f8783818bcb2b777a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "a6dcc34c6fa9489089829ab22fdcb0cf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Periodic", - "Free-slip", - "No-slip" - ], - "description": "nclzn", - "description_tooltip": "Velocity boundary condition where z=zlz", - "index": 2, - "layout": "IPY_MODEL_6f48266c991a472c9915eed9cda3898c", - "style": "IPY_MODEL_05b5651c6ee04fdeb3ecbb9431aac49a" - } - }, - "a7ac3158565341b183a7e2595a8d7869": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "a7cd4de718b94786b745a21555efb51b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "9", - "11", - "13", - "17", - "19", - "21", - "25", - "31", - "33", - "37", - "41", - "49", - "51", - "55", - "61", - "65", - "73", - "81", - "91", - "97", - "101", - "109", - "121", - "129", - "145", - "151", - "161", - "163", - "181", - "193", - "201", - "217", - "241", - "251", - "257", - "271", - "289", - "301", - "321", - "325", - "361", - "385", - "401", - "433", - "451", - "481", - "487", - "501", - "513", - "541", - "577", - "601", - "641", - "649", - "721", - "751", - "769", - "801", - "811", - "865", - "901", - "961", - "973", - "1001", - "1025", - "1081", - "1153", - "1201", - "1251", - "1281", - "1297", - "1351", - "1441", - "1459", - "1501", - "1537", - "1601", - "1621", - "1729", - "1801", - "1921", - "1945", - "2001", - "2049", - "2161", - "2251", - "2305", - "2401", - "2431", - "2501", - "2561", - "2593", - "2701", - "2881", - "2917", - "3001", - "3073", - "3201", - "3241", - "3457", - "3601", - "3751", - "3841", - "3889", - "4001", - "4051", - "4097", - "4321", - "4375", - "4501", - "4609", - "4801", - "4861", - "5001", - "5121", - "5185", - "5401", - "5761", - "5833", - "6001", - "6145", - "6251", - "6401", - "6481", - "6751", - "6913", - "7201", - "7291", - "7501", - "7681", - "7777", - "8001", - "8101", - "8193", - "8641", - "8749", - "9001" - ], - "description": "nx", - "description_tooltip": "X-direction nodes", - "index": 3, - "layout": "IPY_MODEL_0e55e49f3fe8433fa12abc2c85e5f5c5", - "style": "IPY_MODEL_81bdce06d336415fb7e2d9c0a4c244b8" - } - }, - "a8a79f4fba0049db806124808910eadd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "a98278f650104217ac13d44fd7d5ba23": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "a9eb19e1ac2c4cf3ad8c7a2e5f7757e1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "aa082208bc1941ec9ac2ccc8c924d9a5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "aa49ead022c84fea888c76d965b60245": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "aab59359a5f64af58fe7f994f05c5afe": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonStyleModel", - "state": {} - }, - "ab265f92e19c46b3a15cce0e89a49610": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "ad76801c8ac04494922e0e6903e4a176": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonStyleModel", - "state": {} - }, - "adb84a5056f1432bba4b81f624645c33": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Periodic", - "Free-slip", - "No-slip" - ], - "description": "ncly1", - "description_tooltip": "Velocity boundary condition where y=0", - "index": 2, - "layout": "IPY_MODEL_0391420ece174d27bc205b366db17507", - "style": "IPY_MODEL_a7ac3158565341b183a7e2595a8d7869" - } - }, - "afa20e3d21a944309cbeff77e4b90818": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_e1dd453d1e394b89af821890ebc86f66", - "style": "IPY_MODEL_2aa408d2f3b141048b1ac95e511bf426", - "value": "

ScalarParam

" - } - }, - "b2408111f69642b097006c4f02b40ca6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Off", - "On" - ], - "description": "irestart", - "description_tooltip": "Read initial flow field (0: No, 1: Yes)", - "index": 0, - "layout": "IPY_MODEL_8ef504aa014946d2af68a7b7aeb34c83", - "style": "IPY_MODEL_c26c88f66faf4b26b165236d96ad9635" - } - }, - "b37f7ecc6ae3432ab38836884114fd62": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "6th compact", - "hyperviscous 6th" - ], - "description": "isecondder", - "description_tooltip": "Scheme for first order derivative", - "disabled": true, - "index": 0, - "layout": "IPY_MODEL_dec5f6e6c81c4b7f96b0ab30f0869c85", - "style": "IPY_MODEL_04ef7aed9f034871b2dd97eae7beaf93" - } - }, - "b46d926a0d9e46469d486842c8fb138f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "2nd central", - "4th central", - "4th compact", - "6th compact" - ], - "description": "ifirstder", - "index": 3, - "layout": "IPY_MODEL_a28626dda4934048933975b0207e3c60", - "style": "IPY_MODEL_b691eed9c40a4d458cca26c33c3dfbbf" - } - }, - "b61048c076d041d3a828b8d82bedf84b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "b683841fef6e400bac6759ddd3442a2b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Periodic", - "No-flux", - "Dirichlet" - ], - "description": "nclyS1", - "description_tooltip": "Scalar boundary condition where y=0", - "index": 2, - "layout": "IPY_MODEL_f614c38998094ccc9abf3ca7f81f6645", - "style": "IPY_MODEL_b61048c076d041d3a828b8d82bedf84b" - } - }, - "b691eed9c40a4d458cca26c33c3dfbbf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "b8ea8a960d884f0dbfaf4f4c799ef095": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_521ff6f22e8d44cc99ca8223a2f2d299", - "IPY_MODEL_0acadf726eeb4806950580399e3d84f0", - "IPY_MODEL_87c73776cec64ad1b60707fc1d3c2205" - ], - "layout": "IPY_MODEL_76567d938fca4533b2bce636c727f52b" - } - }, - "b94b81b7c8fd4e6292655174c25fd398": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "ba012519863b4b9b9578077f6394c7d1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "bb604f10ec2f4e7a95f7672eb224bf8d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "bcc45f71e5e94740b2471d4283672197": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "bd55dbc45baa4c82870b7b21878fcb12": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "bdc9268fc00e48df87f568b7654aac24": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "be3e6e0793ab4f729a72ab6601a5cfc6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "description": "Sync", - "disabled": true, - "icon": "sync", - "layout": "IPY_MODEL_35cebe6f89bd4c95bf7f957bf406e498", - "style": "IPY_MODEL_c045ed2c51c842858010656acd484942" - } - }, - "be4b05a778ea47e9931b597ba5397906": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "No refinement", - "Refinement at the center", - "Both sides", - "Just near the bottom" - ], - "description": "istret", - "description_tooltip": "y mesh refinement (0:no, 1:center, 2:both sides, 3:bottom)", - "index": 0, - "layout": "IPY_MODEL_c5b24d8a089f431fb4079cc63c0d9ccf", - "style": "IPY_MODEL_11a3074c8faf4dce895358fdc83370a3" - } - }, - "bfb4d53f942749578fcdc5783006e253": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_1160b790683f4d0cab3cd0b4fe95f445", - "style": "IPY_MODEL_3409b771bc204669bdf0caa568da202a", - "value": "

NumOptions

" - } - }, - "bfe1134576974610ba800d40156d0ac3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "c045ed2c51c842858010656acd484942": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonStyleModel", - "state": {} - }, - "c049feaabcf3408ab869e1357073e4ee": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "c04f5ebb381a49c6a606b9593e1d333b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "c0ba6e3dc9cc424caba79033bb6b940d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Periodic", - "No-flux", - "Dirichlet" - ], - "description": "nclxS1", - "description_tooltip": "Scalar boundary condition where x=0", - "index": 2, - "layout": "IPY_MODEL_4ca48b3a7c104d68b84621ff83b6a96d", - "style": "IPY_MODEL_bb604f10ec2f4e7a95f7672eb224bf8d" - } - }, - "c0d03af6ce644444bcab43b27a249efb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "c22c6dd428e94d4ba99d5ac09c4ce6ca": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "c26c88f66faf4b26b165236d96ad9635": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "c37e0d30f0644d1aae61a704e7ca31f1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedFloatTextModel", - "state": { - "description": "xlx", - "description_tooltip": "Size of the box in x-direction", - "layout": "IPY_MODEL_aa49ead022c84fea888c76d965b60245", - "max": 1000000000, - "step": null, - "style": "IPY_MODEL_85d3712243a542b29e736e6b6e7204b0", - "value": 1 - } - }, - "c3cd8f0e945b45b19e0be779f1c523ee": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "c3f9232c0b9843cbbd6dd8c44084797e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "c4ca7b757171443d8c84d16cc29bb49f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "c5b24d8a089f431fb4079cc63c0d9ccf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "c5fc24f0456b4eaa9a3aaa78bd0e0183": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_30e5fea3f85345bea320fb3e46a5d8a6", - "IPY_MODEL_adb84a5056f1432bba4b81f624645c33", - "IPY_MODEL_8a1715fc7b184069bbfa1e3657dcad3e" - ], - "layout": "IPY_MODEL_1eb056ece6f842729a78a1d1169a1cf1" - } - }, - "c6177904a34a41b7ae46a15bef8f99b1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "c6c73e9dfd414aa4ae6657778e284c84": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "c7e6267b7530407e821397dc4a99b125": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "c81078da6753456db34e0fa7531a0d46": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_a7cd4de718b94786b745a21555efb51b", - "IPY_MODEL_f2645cee413b4c29b72e74b1714f9564", - "IPY_MODEL_159eaced52ed45ab9a81946bbd56e29e" - ], - "layout": "IPY_MODEL_d2ecabb721c04e558b8add3c89594585" - } - }, - "c9f68c17a0a343e39b0c9f77b157dce2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "BoundedIntTextModel", - "state": { - "description": "ifirst", - "description_tooltip": "The number for the first iteration", - "layout": "IPY_MODEL_0e91b08a8c12438ca174a07fb18bb27e", - "max": 1000000000, - "style": "IPY_MODEL_6541fd89b24b4169899827b63c47d13f" - } - }, - "ca4cd1ccb9ba43308d38049970f379aa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_500eabf8e21b4ae4979fb4d70536121c", - "style": "IPY_MODEL_c7e6267b7530407e821397dc4a99b125", - "value": "cp, us, sc, ri, scalar_lbound & scalar_ubound are lists with length numscalar, set them properly on the code." - } - }, - "cad81637953a433b9403220f000d135c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatTextModel", - "state": { - "description": "re", - "description_tooltip": "Reynolds number", - "layout": "IPY_MODEL_7d4ff6b147cb4feba4416324679fbb17", - "step": null, - "style": "IPY_MODEL_a8a79f4fba0049db806124808910eadd", - "value": 1000 - } - }, - "cb2a1d59173c48ac9799936ea849768b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "cb76ce58ba3447089103d5a23ac831b4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "cb8bd0ad64d54c40be5cd4a019e08332": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "ccffe2a955a74bb0a07d56a04cee3922": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_317d3303f9e34077aa32c83465ac4d0e", - "IPY_MODEL_8b9058f25d3d4d4d95ae903b46bb7def", - "IPY_MODEL_5ae396b700d54d1584a487c8cbfa3cf5" - ], - "layout": "IPY_MODEL_e29a2ae745e94e828a752fb49240549d" - } - }, - "cdb9c88934274c2cb56afba1798be271": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_0a087f17bf294318ade98c389780f5be", - "IPY_MODEL_48b6d32f009a4f0abf17b255c2a6c63e", - "IPY_MODEL_5a882b2f0fcb4e9fbd8ce97b4caa3fa9" - ], - "layout": "IPY_MODEL_9fa7e86704d94043aa067b829fc0dcec" - } - }, - "cf666ac5cd584eb98d767128822b79df": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "d0ac08b8b1104a90a1431d293190932e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "d1d34bd4dbc747b5ad6f984f0a2c2afb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "d2e0912d3f9a46fcbfaa1adf315d6870": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "d2ecabb721c04e558b8add3c89594585": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "d3ea062efc4345bab34a2b4dba578a1f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "d481579d2a9344f4838c6b7c3e39d1ab": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "d48cbef374c64e6596f1d55e03f947d9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "1", - "2", - "4", - "0" - ], - "description": "p_row", - "description_tooltip": "Row partition for domain decomposition and parallel computation", - "index": 3, - "layout": "IPY_MODEL_6ebde3a626844bacaf2faccf12f738f2", - "style": "IPY_MODEL_bd55dbc45baa4c82870b7b21878fcb12" - } - }, - "d59407fb6b4c470ebab3f4410a1c4cc3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "d688cc616ad04b1fb84b62eb6b0dcb4e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "d6dfbb3e85094b76836ca14438cbc583": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "d8ea7a41dbd64c60a67209dfa15c247a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "TextModel", - "state": { - "description": "size", - "disabled": true, - "layout": "IPY_MODEL_21ed77de852a4c99817d70dc9118e716", - "style": "IPY_MODEL_c6c73e9dfd414aa4ae6657778e284c84", - "value": "-196520.0 bytes" - } - }, - "ddb076027d88424cb9494f02162b2317": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "dec5f6e6c81c4b7f96b0ab30f0869c85": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "df62802c11224e96905df948b3148720": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_1aa57dbda5084118951b456dd9b2d81c", - "style": "IPY_MODEL_ddb076027d88424cb9494f02162b2317", - "value": "

Spatial discretization

" - } - }, - "dfb45b32c62c4a1c81a61aece03e6093": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "e06516dd3df840a2b41cf975a4384b79": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "e0ea33aa3afc40ca836140eea670aaf0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "e1dd453d1e394b89af821890ebc86f66": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "e29a2ae745e94e828a752fb49240549d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "e31750f790c342cfaa1eada46a6e8971": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatTextModel", - "state": { - "description": "gravz", - "description_tooltip": "Gravity unitary vector in z-direction", - "layout": "IPY_MODEL_c04f5ebb381a49c6a606b9593e1d333b", - "step": null, - "style": "IPY_MODEL_c049feaabcf3408ab869e1357073e4ee" - } - }, - "e51e6c4f10084c2b87806986523267fb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Off", - "On" - ], - "description": "ipost", - "description_tooltip": "Enables online postprocessing at a frequency iprocessing (0: No, 1: Yes)", - "index": 0, - "layout": "IPY_MODEL_0340223fe30d484892b21e9334b0aebd", - "style": "IPY_MODEL_c22c6dd428e94d4ba99d5ac09c4ce6ca" - } - }, - "e618cd7cce6f43e784757ed661ff2bf1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "e701aff0508b4e38a027742794f315bd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_be4b05a778ea47e9931b597ba5397906", - "IPY_MODEL_782d12afaf1f43dbb173b7653eb14ddd" - ], - "layout": "IPY_MODEL_62c251249be74bb7a5d0ff31e559ee71" - } - }, - "e919455dc7db408b9118937e0d5d96ac": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "e9b0320c0ba5474ca2569fc162e02d05": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "Periodic", - "No-flux", - "Dirichlet" - ], - "description": "nclzS1", - "description_tooltip": "Scalar boundary condition where z=0", - "index": 2, - "layout": "IPY_MODEL_d2e0912d3f9a46fcbfaa1adf315d6870", - "style": "IPY_MODEL_4f244c334bd5468e80d4f6ab423e1192" - } - }, - "ea19246a7a9845b99dd42f915f0e672c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "eabde9b4ac504db5832e15be4f47d904": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "eb26635f12124aee849f65063e50405b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "ecd43b4e4a6f40739b7eb213e2875d68": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "edcc1d29263449a5b725bd4e2591e9df": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "edf008c827f642cc837e42f6d5a1203c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "ee95542c884d40bfbad33786b31bca11": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "eea49cafd1814dfe8583cbcdaed78045": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "efb7e0d6b6ed484b95228874759e847c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "f221420f506b45f88b97eedbfaf55d07": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "f2645cee413b4c29b72e74b1714f9564": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DropdownModel", - "state": { - "_options_labels": [ - "9", - "11", - "13", - "17", - "19", - "21", - "25", - "31", - "33", - "37", - "41", - "49", - "51", - "55", - "61", - "65", - "73", - "81", - "91", - "97", - "101", - "109", - "121", - "129", - "145", - "151", - "161", - "163", - "181", - "193", - "201", - "217", - "241", - "251", - "257", - "271", - "289", - "301", - "321", - "325", - "361", - "385", - "401", - "433", - "451", - "481", - "487", - "501", - "513", - "541", - "577", - "601", - "641", - "649", - "721", - "751", - "769", - "801", - "811", - "865", - "901", - "961", - "973", - "1001", - "1025", - "1081", - "1153", - "1201", - "1251", - "1281", - "1297", - "1351", - "1441", - "1459", - "1501", - "1537", - "1601", - "1621", - "1729", - "1801", - "1921", - "1945", - "2001", - "2049", - "2161", - "2251", - "2305", - "2401", - "2431", - "2501", - "2561", - "2593", - "2701", - "2881", - "2917", - "3001", - "3073", - "3201", - "3241", - "3457", - "3601", - "3751", - "3841", - "3889", - "4001", - "4051", - "4097", - "4321", - "4375", - "4501", - "4609", - "4801", - "4861", - "5001", - "5121", - "5185", - "5401", - "5761", - "5833", - "6001", - "6145", - "6251", - "6401", - "6481", - "6751", - "6913", - "7201", - "7291", - "7501", - "7681", - "7777", - "8001", - "8101", - "8193", - "8641", - "8749", - "9001" - ], - "description": "ny", - "description_tooltip": "Y-direction nodes", - "index": 3, - "layout": "IPY_MODEL_e0ea33aa3afc40ca836140eea670aaf0", - "style": "IPY_MODEL_bcc45f71e5e94740b2471d4283672197" - } - }, - "f5a99efb5ec043aabcc06ff9f1d87c0d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "f614c38998094ccc9abf3ca7f81f6645": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "f7eaa2adbfc9453380ad7b0f9320f803": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_c37e0d30f0644d1aae61a704e7ca31f1", - "IPY_MODEL_99c3abc8bd6f49d5a67b7058e54090fa", - "IPY_MODEL_6a7f07ac8216425ab136bbed23fd150a" - ], - "layout": "IPY_MODEL_7ad5bb85c8354a72aa1568d7eec9b70a" - } - }, - "f87ab929a1744692b8ec8722af44a5e4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "f97205738af3433d91d94cb893098982": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "fb3a3bf61b0840739b74ae7f8978f572": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "fc9991b0d5fc4aee816c8f7d56687962": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_ff0101e31afc44548499f58e07eaa024" - ], - "layout": "IPY_MODEL_21c5fab946a44c4ca7868087dba946da" - } - }, - "ff0101e31afc44548499f58e07eaa024": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "IntSliderModel", - "state": { - "continuous_update": false, - "description": "numscalar", - "description_tooltip": "Number of scalar fractions", - "layout": "IPY_MODEL_058f8eeb578740c2949de722a9a783a2", - "max": 9, - "style": "IPY_MODEL_ea19246a7a9845b99dd42f915f0e672c" - } - }, - "ff3fe5a18e4f495eb9024431c194f889": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "ff743bbe1aad4eb08eb6e0b82f21566b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - } - }, - "version_major": 2, - "version_minor": 0 - } - }, - "interpreter": { - "hash": "546d5beeb22119d9a20f6c19239ae627cc2b69f70be285d1d696980c89f3c939" + "version": "3.12.2" } }, "nbformat": 4, diff --git a/hatch.toml b/hatch.toml new file mode 100644 index 0000000..04d9d46 --- /dev/null +++ b/hatch.toml @@ -0,0 +1,77 @@ +[env] +requires = ["hatch-pip-compile"] + +[version] +path = "xcompact3d_toolbox/_version.py" +pattern = '__version__ = "(?P[^"]+)"' + +[envs.default] +description = "Base development environment" +dependencies = [ + "coverage[toml]", + "hypothesis>=4.53", + "pre-commit", + "pytest-cov", + "pytest", +] + +[envs.default.scripts] +pre-commit-install = "pre-commit install {args}" +pre-commit-uninstall = "pre-commit uninstall {args}" +check = "pre-commit run {args} --all-files" +type = "check mypy {args}" +lint = "check ruff {args}" +format = "check ruff-format {args}" +test = "pytest --cov --cov-report=term {args}" +test-no-cov = "test --no-cov {args}" +qa = ["check", "test", "echo '✅ QA passed'"] + +[envs.test] +description = "Extended test environment" +extra-dependencies = ["pytest-randomly", "pytest-rerunfailures", "pytest-xdist"] + +[envs.test.scripts] +extended = "test -n auto --reruns 7 --reruns-delay 1 {args}" + +[[envs.test.matrix]] +python = ["3.8", "3.9", "3.10", "3.11", "3.12"] + +[envs.docs] +description = "Documentation environment" +features = ["visu"] +install = true +detached = false +dependencies = [ + "docutils", + "ipykernel", + "jupyter-book", + "nbsphinx", + "pooch", + "sphinx-autobuild", + "sphinx-rtd-theme", + "sphinx>=1.4", +] +type = "pip-compile" +lock-filename = "docs/requirements.txt" + +[envs.docs.scripts] +config = "jupyter-book config sphinx docs {args}" +build = ["config", "jupyter-book build docs --path-output build {args}"] +serve = ["config", "sphinx-autobuild docs build/_build/html --ignore='**/data/*' --open-browser {args}"] + +[envs.changelog] +description = "Changelog handler" +dependencies = ["towncrier"] + +[envs.changelog.scripts] +build = "towncrier build {args}" +draft = "build --draft {args}" +create = "towncrier create {args}" +check = "towncrier check {args}" + +[envs.hatch-static-analysis] +config-path = "ruff_defaults.toml" + +[dirs.env] +virtual = ".venv" +pip-compile = ".venv" diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..4d8f0d4 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,107 @@ +[project] +name = "xcompact3d_toolbox" +description = "A set of tools for pre and postprocessing prepared for the high-order Navier-Stokes solver XCompact3d" +readme = "README.md" +requires-python = ">=3.8" +authors = [{ name = "Felipe N. Schuch", email = "me@fschuch.com" }] +classifiers = [ + "Development Status :: 5 - Production/Stable", + "Intended Audience :: Science/Research", + "License :: OSI Approved :: GNU General Public License v3 (GPLv3)", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python", + "Topic :: Scientific/Engineering", +] +dynamic = ["version"] +dependencies = [ + "numpy>=1.22", + "scipy>=1.5", + "traitlets>=4.3", + "ipywidgets>=7.5", + "pandas>=1.1", + "xarray>=0.16", + "netcdf4>=1.6.3", + "dask[complete]>=2.22", + "numba>=0.50", + "tqdm>=4.62", + "numpy-stl>=2.16.3", + "loguru>=0.6", +] + +[project.optional-dependencies] +visu = [ + "matplotlib>=3.2", + "bokeh>=2.3", + "datashader>=0.13", + "hvplot>=0.7", + "panel>=0.12", + "holoviews>=1.14", +] + +[project.urls] +Changelog = "https://github.com/fschuch/xcompact3d_toolbox/blob/main/docs/news.md" +Documentation = "https://xcompact3d-toolbox.readthedocs.io/" +Issues = "https://github.com/fschuch/xcompact3d_toolbox/issues" +Repository = "https://github.com/fschuch/xcompact3d_toolbox" + +[tool.pytest.ini_options] +minversion = "8.0" +# addopts = [ +# "--doctest-modules", +# "--doctest-glob='*.md'", +# "--doctest-continue-on-failure", +# "--doctest-report=ndiff", +# ] + +[tool.coverage.run] +branch = true +relative_files = true +source = ["xcompact3d_toolbox", "tests"] +omit = ["xcompact3d_toolbox/_version.py"] + +[tool.coverage.report] +show_missing = true +precision = 2 +exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:", "def __repr__"] + +[tool.ruff] +extend = "ruff_defaults.toml" +extend-exclude = ["./docs/conf.py"] + +[tool.ruff.lint] +extend-ignore = ["A003"] + +[tool.ruff.lint.extend-per-file-ignores] +"*.ipynb" = [ + "E402", # module level import not at top of file + "E712", # comparison to True should be 'if cond is True:' or 'if cond:' + "PLR2004", # Magic value used in comparison + "T201", # `print` found +] +"__init__.py" = ["F401"] # imported but unused +"xcompact3d_toolbox/parameters.py" = [ + "N815", # variable in function should be lowercase, but they come from x3d +] +"xcompact3d_toolbox/sandbox.py" = [ + "E712", # comparison to True should be 'if cond is True:' or 'if cond:' +] + +[tool.ruff.lint.pydocstyle] +convention = "numpy" + +[tool.mypy] +pretty = true +ignore_missing_imports = true +exclude = ["docs/conf.py"] + +[tool.codespell] +skip = "docs/conf.py" +check-filenames = true + +[build-system] +requires = ["hatchling>=1.21.0", "hatch-vcs>=0.3.0"] +build-backend = "hatchling.build" diff --git a/readthedocs.yaml b/readthedocs.yaml index e1e8d0e..cc7e0df 100644 --- a/readthedocs.yaml +++ b/readthedocs.yaml @@ -8,11 +8,10 @@ version: 2 build: os: ubuntu-22.04 tools: - python: "3.8" - # You can also specify other tool versions: - # nodejs: "20" - # rust: "1.70" - # golang: "1.20" + python: "3.12" + jobs: + pre_build: + - jupyter-book config sphinx docs # Build documentation in the "docs/" directory with Sphinx sphinx: @@ -31,4 +30,6 @@ sphinx: # See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html python: install: - - requirements: requirements.txt + - method: pip + path: . + - requirements: docs/requirements.txt diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index f9d8bac..0000000 --- a/requirements.txt +++ /dev/null @@ -1,23 +0,0 @@ -. -notebook -ipykernel -numpy -scipy -traitlets -ipywidgets -matplotlib -pandas -xarray -dask[complete] -numba -hvplot -datashader -sphinx>=1.4 -nbsphinx -sphinx-autobuild -numpy-stl -sphinx-rtd-theme -hypothesis -versioneer -tqdm -pooch diff --git a/ruff_defaults.toml b/ruff_defaults.toml new file mode 100644 index 0000000..a5c1515 --- /dev/null +++ b/ruff_defaults.toml @@ -0,0 +1,534 @@ +line-length = 120 + +[format] +docstring-code-format = true +docstring-code-line-length = 80 + +[lint] +select = [ + "A001", + "A002", + "A003", + "ARG001", + "ARG002", + "ARG003", + "ARG004", + "ARG005", + "ASYNC100", + "ASYNC101", + "ASYNC102", + "B002", + "B003", + "B004", + "B005", + "B006", + "B007", + "B008", + "B009", + "B010", + "B011", + "B012", + "B013", + "B014", + "B015", + "B016", + "B017", + "B018", + "B019", + "B020", + "B021", + "B022", + "B023", + "B024", + "B025", + "B026", + "B028", + "B029", + "B030", + "B031", + "B032", + "B033", + "B034", + "B904", + "B905", + "BLE001", + "C400", + "C401", + "C402", + "C403", + "C404", + "C405", + "C406", + "C408", + "C409", + "C410", + "C411", + "C413", + "C414", + "C415", + "C416", + "C417", + "C418", + "C419", + "COM818", + "DTZ001", + "DTZ002", + "DTZ003", + "DTZ004", + "DTZ005", + "DTZ006", + "DTZ007", + "DTZ011", + "DTZ012", + "E101", + "E401", + "E402", + "E501", + "E701", + "E702", + "E703", + "E711", + "E712", + "E713", + "E714", + "E721", + "E722", + "E731", + "E741", + "E742", + "E743", + "E902", + "E999", + "EM101", + "EM102", + "EM103", + "EXE001", + "EXE002", + "EXE003", + "EXE004", + "EXE005", + "F401", + "F402", + "F403", + "F404", + "F405", + "F406", + "F407", + "F501", + "F502", + "F503", + "F504", + "F505", + "F506", + "F507", + "F508", + "F509", + "F521", + "F522", + "F523", + "F524", + "F525", + "F541", + "F601", + "F602", + "F621", + "F622", + "F631", + "F632", + "F633", + "F634", + "F701", + "F702", + "F704", + "F706", + "F707", + "F722", + "F811", + "F821", + "F822", + "F823", + "F841", + "F842", + "F901", + "FA100", + "FA102", + "FBT001", + "FBT002", + "FLY002", + "G001", + "G002", + "G003", + "G004", + "G010", + "G101", + "G201", + "G202", + "I001", + "I002", + "ICN001", + "ICN002", + "ICN003", + "INP001", + "INT001", + "INT002", + "INT003", + "ISC003", + "N801", + "N802", + "N803", + "N804", + "N805", + "N806", + "N807", + "N811", + "N812", + "N813", + "N814", + "N815", + "N816", + "N817", + "N818", + "N999", + "PERF101", + "PERF102", + "PERF401", + "PERF402", + "PGH001", + "PGH002", + "PGH005", + "PIE790", + "PIE794", + "PIE796", + "PIE800", + "PIE804", + "PIE807", + "PIE808", + "PIE810", + "PLC0105", + "PLC0131", + "PLC0132", + "PLC0205", + "PLC0208", + "PLC0414", + "PLC3002", + "PLE0100", + "PLE0101", + "PLE0116", + "PLE0117", + "PLE0118", + "PLE0241", + "PLE0302", + "PLE0307", + "PLE0604", + "PLE0605", + "PLE1142", + "PLE1205", + "PLE1206", + "PLE1300", + "PLE1307", + "PLE1310", + "PLE1507", + "PLE1700", + "PLE2502", + "PLE2510", + "PLE2512", + "PLE2513", + "PLE2514", + "PLE2515", + "PLR0124", + "PLR0133", + "PLR0206", + "PLR0402", + "PLR1701", + "PLR1711", + "PLR1714", + "PLR1722", + "PLR2004", + "PLR5501", + "PLW0120", + "PLW0127", + "PLW0129", + "PLW0131", + "PLW0406", + "PLW0602", + "PLW0603", + "PLW0711", + "PLW1508", + "PLW1509", + "PLW1510", + "PLW2901", + "PLW3301", + "PT001", + "PT002", + "PT003", + "PT006", + "PT007", + "PT008", + "PT009", + "PT010", + "PT011", + "PT012", + "PT013", + "PT014", + "PT015", + "PT016", + "PT017", + "PT018", + "PT019", + "PT020", + "PT021", + "PT022", + "PT023", + "PT024", + "PT025", + "PT026", + "PT027", + "PYI001", + "PYI002", + "PYI003", + "PYI004", + "PYI005", + "PYI006", + "PYI007", + "PYI008", + "PYI009", + "PYI010", + "PYI011", + "PYI012", + "PYI013", + "PYI014", + "PYI015", + "PYI016", + "PYI017", + "PYI018", + "PYI019", + "PYI020", + "PYI021", + "PYI024", + "PYI025", + "PYI026", + "PYI029", + "PYI030", + "PYI032", + "PYI033", + "PYI034", + "PYI035", + "PYI036", + "PYI041", + "PYI042", + "PYI043", + "PYI044", + "PYI045", + "PYI046", + "PYI047", + "PYI048", + "PYI049", + "PYI050", + "PYI051", + "PYI052", + "PYI053", + "PYI054", + "PYI055", + "PYI056", + "RET503", + "RET504", + "RET505", + "RET506", + "RET507", + "RET508", + "RSE102", + "RUF001", + "RUF002", + "RUF003", + "RUF005", + "RUF006", + "RUF007", + "RUF008", + "RUF009", + "RUF010", + "RUF011", + "RUF012", + "RUF013", + "RUF015", + "RUF016", + "RUF100", + "RUF200", + "S101", + "S102", + "S103", + "S104", + "S105", + "S106", + "S107", + "S108", + "S110", + "S112", + "S113", + "S301", + "S302", + "S303", + "S304", + "S305", + "S306", + "S307", + "S308", + "S310", + "S311", + "S312", + "S313", + "S314", + "S315", + "S316", + "S317", + "S318", + "S319", + "S320", + "S321", + "S323", + "S324", + "S501", + "S506", + "S508", + "S509", + "S601", + "S602", + "S604", + "S605", + "S606", + "S607", + "S608", + "S609", + "S612", + "S701", + "SIM101", + "SIM102", + "SIM103", + "SIM105", + "SIM107", + "SIM108", + "SIM109", + "SIM110", + "SIM112", + "SIM114", + "SIM115", + "SIM116", + "SIM117", + "SIM118", + "SIM201", + "SIM202", + "SIM208", + "SIM210", + "SIM211", + "SIM212", + "SIM220", + "SIM221", + "SIM222", + "SIM223", + "SIM300", + "SIM910", + "SLF001", + "SLOT000", + "SLOT001", + "SLOT002", + "T100", + "T201", + "T203", + "TCH001", + "TCH002", + "TCH003", + "TCH004", + "TCH005", + "TD004", + "TD005", + "TD006", + "TD007", + "TID251", + "TID252", + "TID253", + "TRY002", + "TRY003", + "TRY004", + "TRY200", + "TRY201", + "TRY300", + "TRY301", + "TRY302", + "TRY400", + "TRY401", + "UP001", + "UP003", + "UP004", + "UP005", + "UP006", + "UP007", + "UP008", + "UP009", + "UP010", + "UP011", + "UP012", + "UP013", + "UP014", + "UP015", + "UP017", + "UP018", + "UP019", + "UP020", + "UP021", + "UP022", + "UP023", + "UP024", + "UP025", + "UP026", + "UP027", + "UP028", + "UP029", + "UP030", + "UP031", + "UP032", + "UP033", + "UP034", + "UP035", + "UP036", + "UP037", + "UP038", + "UP039", + "UP040", + "W291", + "W292", + "W293", + "W505", + "W605", + "YTT101", + "YTT102", + "YTT103", + "YTT201", + "YTT202", + "YTT203", + "YTT204", + "YTT301", + "YTT302", + "YTT303", +] + +[lint.per-file-ignores] +"**/scripts/*" = [ + "INP001", + "T201", +] +"**/tests/**/*" = [ + "PLC1901", + "PLR2004", + "PLR6301", + "S", + "TID252", +] + +[lint.flake8-tidy-imports] +ban-relative-imports = "all" + +[lint.isort] +known-first-party = ["xcompact3d_toolbox"] + +[lint.flake8-pytest-style] +fixture-parentheses = false +mark-parentheses = false diff --git a/setup.cfg b/setup.cfg deleted file mode 100644 index 88aa497..0000000 --- a/setup.cfg +++ /dev/null @@ -1,7 +0,0 @@ -[versioneer] -VCS = git -style = pep440 -versionfile_source = xcompact3d_toolbox/_version.py -versionfile_build = dist/_version.py -tag_prefix = v -parentdir_prefix = xcompact3d_toolbox- diff --git a/setup.py b/setup.py deleted file mode 100644 index ba7543d..0000000 --- a/setup.py +++ /dev/null @@ -1,61 +0,0 @@ -import itertools - -import setuptools - -import versioneer - -with open("README.md", "r") as fh: - long_description = fh.read() - -extras_require = dict( - visu=[ - "matplotlib>=3.2", - "bokeh>=2.3", - "datashader>=0.13", - "hvplot>=0.7", - "panel>=0.12", - "holoviews>=1.14", - ], - docs=["sphinx>=1.4", "nbsphinx", "sphinx-autobuild", "sphinx-rtd-theme"], - dev=["versioneer", "black", "jupyterlab>=3.1", "pooch"], - test=["pytest>=3.8", "hypothesis>=4.53"], -) - -# Add all extra requirements -extras_require["all"] = list(set(itertools.chain(*extras_require.values()))) - -setuptools.setup( - name="xcompact3d_toolbox", - version=versioneer.get_version(), - author="Felipe N. Schuch", - author_email="felipe.schuch@edu.pucrs.br", - description="A set of tools for pre and postprocessing prepared for the high-order Navier-Stokes solver XCompact3d", - long_description=long_description, - long_description_content_type="text/markdown", - url="https://github.com/fschuch/xcompact3d_toolbox", - packages=setuptools.find_packages(), - classifiers=[ - "Programming Language :: Python :: 3", - "License :: OSI Approved :: GNU General Public License v3 (GPLv3)", - "Operating System :: OS Independent", - "Development Status :: 5 - Production/Stable", - "Intended Audience :: Science/Research", - "Topic :: Scientific/Engineering", - ], - python_requires=">=3.6", - install_requires=[ - "numpy>=1.20", # because of numba - "scipy>=1.5", - "traitlets>=4.3", - "ipywidgets>=7.5", - "pandas>=1.1", - "xarray>=0.16", - "netcdf4>=1.6.3", - "dask[complete]>=2.22", - "numba>=0.50", - "tqdm>=4.62", - "numpy-stl>=2.16.3", - ], - extras_require=extras_require, - tests_require=["pytest"], -) diff --git a/sonar-project.properties b/sonar-project.properties new file mode 100644 index 0000000..e44a7f7 --- /dev/null +++ b/sonar-project.properties @@ -0,0 +1,4 @@ +sonar.organization=fschuch +sonar.projectKey=fschuch_xcompact3d_toolbox + +sonar.python.coverage.reportPaths=coverage.*.xml diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..7cf072b --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,8 @@ +import pytest + +import xcompact3d_toolbox + + +@pytest.fixture(autouse=True) +def add_x3d(doctest_namespace): + doctest_namespace["x3d"] = xcompact3d_toolbox diff --git a/tests/integration/__init__.py b/tests/integration/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/integration/data/input.i3d b/tests/integration/data/input.i3d index e3307ca..56323e8 100644 --- a/tests/integration/data/input.i3d +++ b/tests/integration/data/input.i3d @@ -59,7 +59,7 @@ iibm=2 ! Flag for immersed boundary method (0: No IBM, 1: Old IBM ! Spatial derivatives ifirstder = 4 ! (1->2nd central, 2->4th central, 3->4th compact, 4-> 6th compact) isecondder = 4 ! (1->2nd central, 2->4th central, 3->4th compact, 4-> 6th compact, 5->hyperviscous 6th) -ipinter = 3 ! interpolation scheme (1: classic, 2: optimized, 3: optimized agressive) +ipinter = 3 ! interpolation scheme (1: classic, 2: optimized, 3: optimized aggressive) ! Time scheme itimescheme = 2 ! Time integration scheme (1->Euler,2->AB2, 3->AB3, 4->AB4,5->RK3,6->RK4) @@ -133,8 +133,8 @@ SmagWallDamp = 1 ! Smagorinsky damping function for ABL if 1 ra=0.5 ! when simulating a cylinder, radius nraf=10 ! level of refinement for (iibm=2 0r iibm=4) to find the surface of the immersed object nobjmax=1 ! number of immersed objects (DO NOT USE ZERO OBJECTS) - npif=2 ! Number of Points for the Reconstruction (npif=1-3) (Recomended: 2) - izap=1 ! How many points to skip for reconstruction (Range: 0-3) (Reccomended: 1) + npif=2 ! Number of Points for the Reconstruction (npif=1-3) (recommended: 2) + izap=1 ! How many points to skip for reconstruction (Range: 0-3) (Recommended: 1) ianal=0 ! Boundary position approximation? (0: Refinement Approximation, 1: Analytical) iforces=1 diff --git a/tests/integration/test_genepsi.py b/tests/integration/test_genepsi.py index 24a5289..f85835c 100644 --- a/tests/integration/test_genepsi.py +++ b/tests/integration/test_genepsi.py @@ -1,24 +1,29 @@ -import glob -import os.path -import filecmp +import pathlib +import sys + import pytest + import xcompact3d_toolbox as x3d -import xcompact3d_toolbox.sandbox -import xcompact3d_toolbox.genepsi - -@pytest.fixture -def set_up(): - prm = x3d.Parameters(loadfile="tests/integration/data/input.i3d", raise_warning = True) - prm.dataset.set(data_path = "./data/") - epsi = x3d.sandbox.init_epsi(prm, dask = True) - for key in epsi.keys(): + + +@pytest.fixture(scope="session") +def set_up(tmp_path_factory): + prm = x3d.Parameters(loadfile="tests/integration/data/input.i3d", raise_warning=True) + tmp_path = tmp_path_factory.mktemp("data") + prm.dataset.set(data_path=tmp_path.as_posix()) + epsi = x3d.sandbox.init_epsi(prm, dask=True) + for key in epsi: epsi[key] = epsi[key].geo.cylinder(x=3.0, y=5.0) - x3d.genepsi.gene_epsi_3D(epsi, prm) + x3d.genepsi.gene_epsi_3d(epsi, prm) + return tmp_path + -@pytest.mark.parametrize( - "file_ref", glob.glob(os.path.join("tests", "integration", "data", "geometry", "*")) -) +@pytest.mark.skipif(sys.platform == "win32", reason="Work in progress to make it platform independent") +@pytest.mark.parametrize("file_ref", pathlib.Path("tests", "integration", "data", "geometry").glob("*.dat")) def test_dat_files(file_ref, set_up): - file = os.path.join("data", "geometry", os.path.basename(file_ref)) + file = set_up / "geometry" / file_ref.name + + expected_content = file_ref.read_text() + actual_content = file.read_text() - assert filecmp.cmp(file_ref, file) + assert expected_content == actual_content diff --git a/tests/integration/test_stretched_derivatives.py b/tests/integration/test_stretched_derivatives.py index c490982..e60854b 100644 --- a/tests/integration/test_stretched_derivatives.py +++ b/tests/integration/test_stretched_derivatives.py @@ -1,77 +1,64 @@ -import unittest import numpy as np +import pytest from xcompact3d_toolbox.parameters import Parameters from xcompact3d_toolbox.sandbox import init_dataset -class test_stretched_derive(unittest.TestCase): - def test_derivative(self): - - prm = Parameters(ny=129, yly=2.0 * np.pi, nclx1=1, nclxn=1, nclz1=1, nclzn=1) - - for istret in [0, 1, 2, 3]: - for beta in [0.75, 1.0, 4.0]: - # for BC in "00 11 22".split(): - for BC in "00 11 12 21 22".split(): - if istret == 3 and BC == "00": - continue - - with self.subTest(istret=istret, beta=beta, BC=BC): - - tol = 1e-1 - - prm.set( - istret = istret, - beta = beta, - ncly1 = int(BC[0]), - nclyn = int(BC[1]) - ) - - ds = init_dataset(prm).isel(x=0, z=0) - - # Cos - Symmetric - ds["ux"] += np.cos(ds.y) - - self.assertTrue( - np.allclose( - ds.ux.x3d.first_derivative("y").values, - -np.sin(ds.y.values), - atol=tol, - rtol=tol, - ) - ) - - self.assertTrue( - np.allclose( - ds.ux.x3d.second_derivative("y").values, - -np.cos(ds.y.values), - atol=tol, - rtol=tol, - ) - ) - - # Sin - Antisymmetric - ds["uy"] += np.sin(ds.y) - - self.assertTrue( - np.allclose( - ds.uy.x3d.first_derivative("y").values, - np.cos(ds.y.values), - atol=tol, - rtol=tol, - ) - ) - - self.assertTrue( - np.allclose( - ds.uy.x3d.second_derivative("y").values, - -np.sin(ds.y.values), - atol=tol, - rtol=tol, - ) - ) - - -if __name__ == "__main__": - unittest.main() +@pytest.mark.parametrize("istret", [0, 1, 2, 3]) +@pytest.mark.parametrize("beta", [0.75, 1.0, 4.0]) +@pytest.mark.parametrize("boundary_condition", "00 11 12 21 22".split()) +def test_derivative(istret, beta, boundary_condition): + if istret == 3 and boundary_condition == "00": + return + + prm = Parameters( + ny=128 if boundary_condition == "00" else 129, + yly=2.0 * np.pi, + nclx1=1, + nclxn=1, + nclz1=1, + nclzn=1, + istret=istret, + beta=beta, + ncly1=int(boundary_condition[0]), + nclyn=int(boundary_condition[1]), + ) + + tol = 1e-1 + + ds = init_dataset(prm).isel(x=0, z=0) + + # Cos - Symmetric + ds["ux"] += np.cos(ds.y) + + np.testing.assert_allclose( + ds.ux.x3d.first_derivative("y").values, + -np.sin(ds.y.values), + atol=tol, + rtol=tol, + ) + + np.testing.assert_allclose( + ds.ux.x3d.second_derivative("y").values, + -np.cos(ds.y.values), + atol=tol, + rtol=tol, + ) + + # Sin - Antisymmetric + ds["uy"] += np.sin(ds.y) + + np.testing.assert_allclose( + ds.uy.x3d.first_derivative("y").values, + np.cos(ds.y.values), + atol=tol, + rtol=tol, + ) + + np.testing.assert_allclose( + ds.uy.x3d.second_derivative("y").values, + -np.sin(ds.y.values), + atol=tol, + rtol=tol, + ) diff --git a/tests/unit/data/snapshots_istret_0.xdmf b/tests/unit/data/snapshots_istret_0.xdmf index b64702b..f6286e9 100644 --- a/tests/unit/data/snapshots_istret_0.xdmf +++ b/tests/unit/data/snapshots_istret_0.xdmf @@ -12,7 +12,7 @@ - 0.0625 0.0625 0.0625 + 6.250000e-02 6.250000e-02 6.250000e-02 @@ -20,7 +20,7 @@ diff --git a/tests/unit/data/snapshots_istret_1.xdmf b/tests/unit/data/snapshots_istret_1.xdmf index e9ec4df..f76e8eb 100644 --- a/tests/unit/data/snapshots_istret_1.xdmf +++ b/tests/unit/data/snapshots_istret_1.xdmf @@ -7,19 +7,21 @@ - 0.0 0.0625 0.125 0.1875 0.25 0.3125 0.375 0.4375 0.5 0.5625 0.625 0.6875 0.75 0.8125 0.875 0.9375 1.0 + 0.000000e+00 6.250000e-02 1.250000e-01 1.875000e-01 2.500000e-01 3.125000e-01 3.750000e-01 4.375000e-01 5.000000e-01 5.625000e-01 6.250000e-01 6.875000e-01 7.500000e-01 8.125000e-01 8.750000e-01 9.375000e-01 1.000000e+00 - 0.0 0.07288842570943466 0.143831458715156 0.21143631568875 0.275119614108438 0.3350349628106138 0.391840896030869 0.44647462444915553 0.5 0.5535253755508445 0.608159103969131 0.664965037189386 0.724880385891562 0.7885636843112501 0.8561685412848439 0.9271115742905652 1.0 + 0.000000e+00 7.288843e-02 1.438315e-01 2.114363e-01 2.751196e-01 3.350350e-01 3.918409e-01 4.464746e-01 5.000000e-01 5.535254e-01 6.081591e-01 6.649650e-01 7.248804e-01 7.885637e-01 8.561685e-01 9.271116e-01 1.000000e+00 + - 0.0 0.0625 0.125 0.1875 0.25 0.3125 0.375 0.4375 0.5 0.5625 0.625 0.6875 0.75 0.8125 0.875 0.9375 1.0 + 0.000000e+00 6.250000e-02 1.250000e-01 1.875000e-01 2.500000e-01 3.125000e-01 3.750000e-01 4.375000e-01 5.000000e-01 5.625000e-01 6.250000e-01 6.875000e-01 7.500000e-01 8.125000e-01 8.750000e-01 9.375000e-01 1.000000e+00 + diff --git a/tests/unit/test_array.py b/tests/unit/test_array.py index c673000..5c65f09 100644 --- a/tests/unit/test_array.py +++ b/tests/unit/test_array.py @@ -1,18 +1,15 @@ -import xarray as xr import numpy as np -from xcompact3d_toolbox.array import X3dDataset, X3dDataArray import pytest +import xarray as xr -@pytest.fixture(scope="function") +@pytest.fixture def array(): dims = "x y z n t".split() - return xr.DataArray( - 1.0, dims="x y z n t".split(), coords={dim: np.arange(11.0) for dim in dims} - ) + return xr.DataArray(1.0, dims="x y z n t".split(), coords={dim: np.arange(11.0) for dim in dims}) -@pytest.fixture(scope="function") +@pytest.fixture def dataset(array): return xr.Dataset({key: array for key in "ux uy uz pp phi".split()}) @@ -22,20 +19,38 @@ def test_data_pencil_decomp(array, dataset, dims): array.x3d.pencil_decomp(*dims) dataset.x3d.pencil_decomp(*dims) + @pytest.mark.parametrize("dims", ["x", "y", "t"]) def test_data_cumtrapz(array, dataset, dims): array.x3d.cumtrapz(*dims) dataset.x3d.cumtrapz(*dims) + @pytest.mark.parametrize("dims", ["x", "y", "t"]) def test_data_simps(array, dataset, dims): array.x3d.simps(*dims) dataset.x3d.simps(*dims) + +def test_data_simps__invalid_dims(array, dataset): + with pytest.raises(ValueError, match='Invalid value for "args", it should be a valid dimension'): + array.x3d.simps("not-a-dim") + with pytest.raises(ValueError, match='Invalid value for "args", it should be a valid dimension'): + dataset.x3d.simps("not-a-dim") + + @pytest.mark.parametrize("dims", ["x", "y", "z"]) def test_data_first_derivative(array, dims): array.x3d.first_derivative(*dims) + @pytest.mark.parametrize("dims", ["x", "y", "z"]) def test_data_second_derivative(array, dims): array.x3d.second_derivative(*dims) + + +def test_data_pencil_decomposition__invalid_dims(array, dataset): + with pytest.raises(ValueError, match='Invalid value for "args", it should be a valid dimension'): + array.x3d.pencil_decomp("not-a-dim") + with pytest.raises(ValueError, match='Invalid value for "args", it should be a valid dimension'): + dataset.x3d.pencil_decomp("not-a-dim") diff --git a/tests/unit/test_derivatives.py b/tests/unit/test_derivatives.py index 989df4f..f5e53f1 100644 --- a/tests/unit/test_derivatives.py +++ b/tests/unit/test_derivatives.py @@ -1,12 +1,12 @@ import unittest + import numpy as np -from xcompact3d_toolbox.derive import SecondDerivative, FirstDerivative +from xcompact3d_toolbox.derive import first_derivative, second_derivative -class test_derivative(unittest.TestCase): +class TestDerivative(unittest.TestCase): def setUp(self): - self.nx = 129 self.lx = 2.0 * np.pi @@ -17,8 +17,9 @@ def setUp(self): self.cos = np.cos(self.x) self.sin = np.sin(self.x) - def test_periodic(self): + self.tol = 1e-4 + def test_periodic(self): x = np.linspace(0.0, self.lx, num=self.nx - 1, endpoint=False) nx = x.size dx = x[1] - x[0] @@ -26,69 +27,28 @@ def test_periodic(self): sin = np.sin(x) # Cos - Symmetric - self.assertTrue(np.allclose(FirstDerivative(nx, dx, 0, 0).dot(cos), -sin)) - self.assertTrue(np.allclose(SecondDerivative(nx, dx, 0, 0).dot(cos), -cos)) + np.testing.assert_allclose(first_derivative(nx, dx, 0, 0).dot(cos), -sin, atol=self.tol) + np.testing.assert_allclose(second_derivative(nx, dx, 0, 0).dot(cos), -cos, atol=self.tol) # Sin - Antisymmetric - self.assertTrue(np.allclose(FirstDerivative(nx, dx, 0, 0).dot(sin), cos)) - self.assertTrue(np.allclose(SecondDerivative(nx, dx, 0, 0).dot(sin), -sin)) + np.testing.assert_allclose(first_derivative(nx, dx, 0, 0).dot(sin), cos, atol=self.tol) + np.testing.assert_allclose(second_derivative(nx, dx, 0, 0).dot(sin), -sin, atol=self.tol) def test_dirichlet(self): - # Cos - Symmetric - self.assertTrue( - np.allclose( - FirstDerivative(self.nx, self.dx, 2, 2).dot(self.cos), - -self.sin, - atol=1e-4, - ) - ) - self.assertTrue( - np.allclose( - SecondDerivative(self.nx, self.dx, 2, 2).dot(self.cos), - -self.cos, - atol=1e-4, - ) - ) + np.testing.assert_allclose(first_derivative(self.nx, self.dx, 2, 2).dot(self.cos), -self.sin, atol=self.tol) + np.testing.assert_allclose(second_derivative(self.nx, self.dx, 2, 2).dot(self.cos), -self.cos, atol=self.tol) + # Sin - Antisymmetric - self.assertTrue( - np.allclose( - FirstDerivative(self.nx, self.dx, 2, 2).dot(self.sin), - self.cos, - atol=1e-4, - ) - ) - self.assertTrue( - np.allclose( - SecondDerivative(self.nx, self.dx, 2, 2).dot(self.sin), - -self.sin, - atol=1e-4, - ) - ) + np.testing.assert_allclose(first_derivative(self.nx, self.dx, 2, 2).dot(self.sin), self.cos, atol=self.tol) + np.testing.assert_allclose(second_derivative(self.nx, self.dx, 2, 2).dot(self.sin), -self.sin, atol=self.tol) def test_free_slip(self): - # Cos - Symmetric - self.assertTrue( - np.allclose( - FirstDerivative(self.nx, self.dx, 1, 1, 1).dot(self.cos), -self.sin - ) - ) - self.assertTrue( - np.allclose( - SecondDerivative(self.nx, self.dx, 1, 1, 1).dot(self.cos), -self.cos - ) - ) + np.testing.assert_allclose(first_derivative(self.nx, self.dx, 1, 1, 1).dot(self.cos), -self.sin, atol=self.tol) + np.testing.assert_allclose(second_derivative(self.nx, self.dx, 1, 1, 1).dot(self.cos), -self.cos, atol=self.tol) # Sin - Antisymmetric - self.assertTrue( - np.allclose( - FirstDerivative(self.nx, self.dx, 1, 1, 0).dot(self.sin), self.cos - ) - ) - self.assertTrue( - np.allclose( - SecondDerivative(self.nx, self.dx, 1, 1, 0).dot(self.sin), -self.sin - ) - ) + np.testing.assert_allclose(first_derivative(self.nx, self.dx, 1, 1, 0).dot(self.sin), self.cos, atol=self.tol) + np.testing.assert_allclose(second_derivative(self.nx, self.dx, 1, 1, 0).dot(self.sin), -self.sin, atol=self.tol) if __name__ == "__main__": diff --git a/tests/unit/test_io.py b/tests/unit/test_io.py index 7e86055..d01507e 100644 --- a/tests/unit/test_io.py +++ b/tests/unit/test_io.py @@ -1,10 +1,12 @@ import filecmp +from textwrap import dedent import numpy as np import pytest import xarray as xr + import xcompact3d_toolbox as x3d -import xcompact3d_toolbox.io +from xcompact3d_toolbox.param import COORDS @pytest.fixture @@ -17,26 +19,26 @@ def filename_properties(): @pytest.mark.parametrize("separator", ["", "-"]) @pytest.mark.parametrize("extension", ["", ".bin"]) @pytest.mark.parametrize("number_of_digits", [3, 6]) -def test_set_get_filename_from_bin( - filename_properties, prefix, counter, separator, extension, number_of_digits -): - filename_properties.set( - separator=separator, file_extension=extension, number_of_digits=number_of_digits - ) - assert (counter, prefix) == filename_properties.get_info_from_filename( - filename_properties.get_filename_for_binary(prefix, counter) - ) +def test_set_get_filename_from_bin(filename_properties, prefix, counter, separator, extension, number_of_digits): + filename_properties.set(separator=separator, file_extension=extension, number_of_digits=number_of_digits) + filename = filename_properties.get_filename_for_binary(prefix, counter) + assert (counter, prefix) == filename_properties.get_info_from_filename(filename) + assert counter == filename_properties.get_num_from_filename(filename) + assert prefix == filename_properties.get_name_from_filename(filename) + + +def test_file_name_properties_set__fail_invalid_name(filename_properties): + with pytest.raises(KeyError, match=".* is not a valid argument for FilenameProperties"): + filename_properties.set(invalid_name=None) @pytest.fixture def dataset(): - return x3d.io.Dataset( - **dict(stack_velocity=True, stack_scalar=True) - ) + return x3d.io.Dataset(stack_velocity=True, stack_scalar=True) def test_write_read_field(dataset): - coords = dataset._mesh.get() + coords = dataset._mesh.get() # noqa: SLF001 shape = [len(x) for x in coords.values()] numpy_array = np.random.random(size=shape).astype(x3d.param["mytype"]) filename = dataset.filename_properties.get_filename_for_binary("ux", 0) @@ -57,16 +59,16 @@ def xr_array(file_name, **kwargs): numpy_array(**kwargs), coords=kwargs, dims=kwargs.keys(), - attrs=dict(file_name=file_name), + attrs={"file_name": file_name}, ) - coords = dict(dataset._mesh.get()) - coords["t"] = [dataset._time_step * k for k in range(len(dataset))] + coords = dict(dataset._mesh.get()) # noqa: SLF001 + coords["t"] = [dataset._time_step * k for k in range(len(dataset))] # noqa: SLF001 ds = xr.Dataset() ds["pp"] = xr_array("pp", **coords) - ds["u"] = xr_array("u", i="x y z".split(), **coords) + ds["u"] = xr_array("u", i=COORDS, **coords) ds["phi"] = xr_array("phi", n=[n + 1 for n in range(3)], **coords) dataset.write(ds) @@ -75,41 +77,72 @@ def xr_array(file_name, **kwargs): def test_dataset_getitem_int(dataset, snapshot): - for k, time in enumerate(snapshot.t.values): ds = dataset[k] - xr.testing.assert_equal( - snapshot.sel(t=time, drop=True), ds.sel(t=time, drop=True) - ) + xr.testing.assert_equal(snapshot.sel(t=time, drop=True), ds.sel(t=time, drop=True)) def test_dataset_getitem_str(dataset, snapshot): - xr.testing.assert_equal(snapshot["pp"], dataset["pp"]) @pytest.mark.parametrize( - "slice", + "slice_value", [slice(None, None, None), slice(0, -1, 2), slice(-1, 0, -2), slice(0, 9, 3)], ) -def test_dataset_getitem_slice(dataset, snapshot, slice): +def test_dataset_getitem_slice(dataset, snapshot, slice_value): + xr.testing.assert_equal(snapshot.isel(t=slice_value), dataset[slice_value]) - xr.testing.assert_equal(snapshot.isel(t=slice), dataset[slice]) +@pytest.mark.parametrize("slice_value", [None, 3.5]) +def test_dataset_getitem_slice__type_error(dataset, slice_value): + with pytest.raises(TypeError, match="Dataset indices should be integers, string or slices"): + dataset[slice_value] -def test_dataset_iter(dataset, snapshot): +def test_dataset_iter(dataset, snapshot): for k, ds in enumerate(dataset): xr.testing.assert_equal(snapshot.sel(t=k, drop=True), ds.sel(t=k, drop=True)) + @pytest.mark.parametrize("istret", [0, 1]) -def test_dataset_write_xdmf(dataset, snapshot, istret): - ds = snapshot - dataset._mesh.y.istret = istret +def test_dataset_write_xdmf(dataset, snapshot, istret): # noqa: ARG001 + dataset._mesh.y.istret = istret # noqa: SLF001 filename = f"snapshots_istret_{istret}.xdmf" - dataset.write_xdmf(filename) - assert filecmp.cmp( - filename, f"./tests/unit/data/{filename}" + dataset.write_xdmf(filename, float_precision=6) + assert filecmp.cmp(filename, f"./tests/unit/data/{filename}") + + +def test_prm_to_dict(tmp_path): + prm_content = dedent( + """ + # Comments + 32 # nx # some explanation + 64 # ny # some explanation + 128 # nz # some explanation + 'bar' # foo + .false. # flag + 2.5 # float + 1 # my_list(1) + 2 # my_list(2) + 3 # my_list(3) + # More comments + """ ) + prm_file = tmp_path / "test.prm" + prm_file.write_text(prm_content) + + expected = { + "nx": 32, + "ny": 64, + "nz": 128, + "foo": "bar", + "flag": False, + "float": 2.5, + "my_list": [1, 2, 3], + } + actual = x3d.io.prm_to_dict(prm_file) + + assert expected == actual diff --git a/tests/unit/test_mesh.py b/tests/unit/test_mesh.py index c3ecef7..8c6a312 100644 --- a/tests/unit/test_mesh.py +++ b/tests/unit/test_mesh.py @@ -3,6 +3,7 @@ import numpy as np import pytest + import xcompact3d_toolbox as x3d import xcompact3d_toolbox.mesh @@ -14,9 +15,7 @@ def test_coordinate_grid_size_value(possible_mesh): def test_coordinate_periodic_grid_size_value(possible_mesh_periodic): coordinate = x3d.mesh.Coordinate(is_periodic=True) - assert ( - set(coordinate.possible_grid_size) == possible_mesh_periodic - ) + assert set(coordinate.possible_grid_size) == possible_mesh_periodic @pytest.fixture @@ -24,6 +23,15 @@ def coordinate(): return x3d.mesh.Coordinate() +def test_coordinate_set__fail_invalid_name(coordinate): + with pytest.raises(KeyError, match=".* is not a valid parameter"): + coordinate.set(invalid_name=None) + + +def test_coordinate_len(coordinate): + assert len(coordinate) == coordinate.grid_size + + @pytest.mark.parametrize("length", [1.0, 10.0, 100.0]) @pytest.mark.parametrize("grid_size", [101, 201]) @pytest.mark.parametrize("is_periodic", [True, False]) @@ -34,7 +42,7 @@ def test_coordinate_properties(coordinate, length, grid_size, is_periodic): delta = length / grid_size if is_periodic else length / (grid_size - 1) coordinate.set(is_periodic=is_periodic, grid_size=grid_size, length=length) - assert (sub_grid_size, delta) == (coordinate._sub_grid_size, coordinate.delta) + assert (sub_grid_size, delta) == (coordinate._sub_grid_size, coordinate.delta) # noqa: SLF001 new_length = coordinate.length / 2.0 coordinate.delta /= 2.0 @@ -47,9 +55,7 @@ def stretched_coordinate(): return x3d.mesh.StretchedCoordinate() -@pytest.mark.parametrize( - "filename", glob.glob(os.path.join("tests", "unit", "data", "yp", "*.dat")) -) +@pytest.mark.parametrize("filename", glob.glob(os.path.join("tests", "unit", "data", "yp", "*.dat"))) def test_stretched_coordinate(stretched_coordinate, filename): """In order to test the stretched mesh, three values for istret: @@ -79,9 +85,7 @@ def test_stretched_coordinate(stretched_coordinate, filename): grid_size=coord_ref.size, ) - np.testing.assert_allclose( - actual=stretched_coordinate, desired=coord_ref, rtol=1e-5, atol=1e-8 - ) + np.testing.assert_allclose(actual=stretched_coordinate, desired=coord_ref, rtol=1e-5, atol=1e-8) @pytest.fixture diff --git a/tests/unit/test_parameters.py b/tests/unit/test_parameters.py index f0fd3bc..f54a15b 100644 --- a/tests/unit/test_parameters.py +++ b/tests/unit/test_parameters.py @@ -1,99 +1,114 @@ -import unittest import os.path + import pytest -import traitlets + +from xcompact3d_toolbox.gui import ParametersGui +from xcompact3d_toolbox.param import COORDS from xcompact3d_toolbox.parameters import Parameters -# TODO - migrate do Pytest -# TODO 2 - Test ParametersGui as well +PARAMETERS = (Parameters, ParametersGui) + +@pytest.mark.parametrize("base_class", PARAMETERS) +class TestParameters: + @pytest.fixture + def parameters(self, tmp_path, base_class) -> Parameters: + filename = (tmp_path / "test.i3d").as_posix() + return base_class(filename=filename) -class test_parameters(unittest.TestCase): - def test_io(self): + @pytest.mark.parametrize("target_class", PARAMETERS) + def test_io(self, parameters: Parameters, target_class: Parameters): + prm1 = parameters + + expected_values = {k: v for k, v in prm1.trait_values().items() if prm1.trait_metadata(k, "group")} - prm1 = Parameters() prm1.write() - prm2 = Parameters() + prm2 = target_class(filename=prm1.filename) prm2.load() - for name in prm1.trait_names(): - group = prm1.trait_metadata(name, "group") - if group is None: - continue - with self.subTest(name=name): - self.assertEqual(getattr(prm1, name), getattr(prm2, name)) - - def test_observe_resolution_and_BC(self): - - prm = Parameters() - - for dim in "x y z".split(): - with self.subTest(dim=dim): - # Default Values - self.assertEqual(getattr(prm, f"n{dim}"), 17) - self.assertEqual(getattr(prm, f"d{dim}"), 0.0625) - self.assertEqual(getattr(prm, f"{dim}l{dim}"), 1.0) - # New nx should change just dx - setattr(prm, f"n{dim}", 201) - self.assertEqual(getattr(prm, f"n{dim}"), 201) - self.assertEqual(getattr(prm, f"d{dim}"), 0.005) - self.assertEqual(getattr(prm, f"{dim}l{dim}"), 1.0) - # New xlx should change just dx - setattr(prm, f"{dim}l{dim}", 5.0) - self.assertEqual(getattr(prm, f"n{dim}"), 201) - self.assertEqual(getattr(prm, f"d{dim}"), 0.025) - self.assertEqual(getattr(prm, f"{dim}l{dim}"), 5.0) - # New dx should change just xlx - setattr(prm, f"d{dim}", 0.005) - self.assertEqual(getattr(prm, f"n{dim}"), 201) - self.assertEqual(getattr(prm, f"d{dim}"), 0.005) - self.assertEqual(getattr(prm, f"{dim}l{dim}"), 1.0) - # One side to periodic - setattr(prm, f"ncl{dim}1", 0) - self.assertEqual(getattr(prm, f"ncl{dim}1"), 0) - self.assertEqual(getattr(prm, f"ncl{dim}n"), 0) - self.assertEqual(getattr(prm.mesh, dim).is_periodic, True) - self.assertEqual(getattr(prm, f"n{dim}"), 200) - self.assertEqual(getattr(prm, f"d{dim}"), 0.005) - self.assertEqual(getattr(prm, f"{dim}l{dim}"), 1.0) - # and back - setattr(prm, f"ncl{dim}1", 1) - self.assertEqual(getattr(prm, f"ncl{dim}1"), 1) - self.assertEqual(getattr(prm, f"ncl{dim}n"), 1) - self.assertEqual(getattr(prm.mesh, dim).is_periodic, False) - self.assertEqual(getattr(prm, f"n{dim}"), 201) - self.assertEqual(getattr(prm, f"d{dim}"), 0.005) - self.assertEqual(getattr(prm, f"{dim}l{dim}"), 1.0) - # Other side to periodic - setattr(prm, f"ncl{dim}n", 0) - self.assertEqual(getattr(prm, f"ncl{dim}1"), 0) - self.assertEqual(getattr(prm, f"ncl{dim}n"), 0) - self.assertEqual(getattr(prm.mesh, dim).is_periodic, True) - self.assertEqual(getattr(prm, f"n{dim}"), 200) - self.assertEqual(getattr(prm, f"d{dim}"), 0.005) - self.assertEqual(getattr(prm, f"{dim}l{dim}"), 1.0) - # and back - setattr(prm, f"ncl{dim}n", 2) - self.assertEqual(getattr(prm, f"ncl{dim}1"), 2) - self.assertEqual(getattr(prm, f"ncl{dim}n"), 2) - self.assertEqual(getattr(prm.mesh, dim).is_periodic, False) - self.assertEqual(getattr(prm, f"n{dim}"), 201) - self.assertEqual(getattr(prm, f"d{dim}"), 0.005) - self.assertEqual(getattr(prm, f"{dim}l{dim}"), 1.0) - - -@pytest.mark.parametrize( - "i3d_path, data_path", - [ - ("./example/input.i3d", "./example/data/"), - ("../tutorial/case/input.i3d", "../tutorial/case/data/"), - ("input.i3d", "./data/"), - ], -) -def test_initial_datapath(i3d_path, data_path): - prm = Parameters(filename=i3d_path) - assert os.path.normpath(prm.dataset.data_path) == os.path.normpath(data_path) - - -if __name__ == "__main__": - unittest.main() + actual_values = {k: v for k, v in prm2.trait_values().items() if prm2.trait_metadata(k, "group")} + + assert expected_values == actual_values + + @pytest.mark.parametrize("dimension", COORDS) + def test_observe_resolution_and_bc(self, parameters: Parameters, dimension: str): + prm = parameters + + # Default Values + assert getattr(prm, f"n{dimension}") == 17 + assert getattr(prm, f"d{dimension}") == 0.0625 + assert getattr(prm, f"{dimension}l{dimension}") == 1.0 + # New nx should change just dx + setattr(prm, f"n{dimension}", 201) + assert getattr(prm, f"n{dimension}") == 201 + assert getattr(prm, f"d{dimension}") == 0.005 + assert getattr(prm, f"{dimension}l{dimension}") == 1.0 + # New xlx should change just dx + setattr(prm, f"{dimension}l{dimension}", 5.0) + assert getattr(prm, f"n{dimension}") == 201 + assert getattr(prm, f"d{dimension}") == 0.025 + assert getattr(prm, f"{dimension}l{dimension}") == 5.0 + # New dx should change just xlx + setattr(prm, f"d{dimension}", 0.005) + assert getattr(prm, f"n{dimension}") == 201 + assert getattr(prm, f"d{dimension}") == 0.005 + assert getattr(prm, f"{dimension}l{dimension}") == 1.0 + # One side to periodic + setattr(prm, f"ncl{dimension}1", 0) + assert getattr(prm, f"ncl{dimension}1") == 0 + assert getattr(prm, f"ncl{dimension}n") == 0 + assert getattr(prm.mesh, dimension).is_periodic is True + assert getattr(prm, f"n{dimension}") == 200 + assert getattr(prm, f"d{dimension}") == 0.005 + assert getattr(prm, f"{dimension}l{dimension}") == 1.0 + # and back + setattr(prm, f"ncl{dimension}1", 1) + assert getattr(prm, f"ncl{dimension}1") == 1 + assert getattr(prm, f"ncl{dimension}n") == 1 + assert getattr(prm.mesh, dimension).is_periodic is False + assert getattr(prm, f"n{dimension}") == 201 + assert getattr(prm, f"d{dimension}") == 0.005 + assert getattr(prm, f"{dimension}l{dimension}") == 1.0 + # Other side to periodic + setattr(prm, f"ncl{dimension}n", 0) + assert getattr(prm, f"ncl{dimension}1") == 0 + assert getattr(prm, f"ncl{dimension}n") == 0 + assert getattr(prm.mesh, dimension).is_periodic is True + assert getattr(prm, f"n{dimension}") == 200 + assert getattr(prm, f"d{dimension}") == 0.005 + assert getattr(prm, f"{dimension}l{dimension}") == 1.0 + # and back + setattr(prm, f"ncl{dimension}n", 2) + assert getattr(prm, f"ncl{dimension}1") == 2 + assert getattr(prm, f"ncl{dimension}n") == 2 + assert getattr(prm.mesh, dimension).is_periodic is False + assert getattr(prm, f"n{dimension}") == 201 + assert getattr(prm, f"d{dimension}") == 0.005 + assert getattr(prm, f"{dimension}l{dimension}") == 1.0 + + @pytest.mark.parametrize( + ("i3d_path", "data_path"), + [ + ("./example/input.i3d", "./example/data/"), + ("../tutorial/case/input.i3d", "../tutorial/case/data/"), + ("input.i3d", "./data/"), + ], + ) + def test_initial_datapath(self, base_class, i3d_path, data_path): + prm = base_class(filename=i3d_path) + assert os.path.normpath(prm.dataset.data_path) == os.path.normpath(data_path) + + @pytest.mark.parametrize("ncores", [2, 4, 8, 16, 32, 64, 128]) + def test_observe_2decomp__ncores(self, parameters: Parameters, ncores: int): + prm = parameters + prm.set(ncores=ncores) + prm.set(p_row=2, p_col=int(ncores / 2)) + + assert prm.ncores == ncores + assert prm.p_row == 2 + assert prm.p_col == int(ncores / 2) + + prm.set(ncores=1) + assert prm.ncores == 1 + assert prm.p_row == 0 + assert prm.p_col == 0 diff --git a/tests/unit/test_sandbox.py b/tests/unit/test_sandbox.py index 6903176..0c83d57 100644 --- a/tests/unit/test_sandbox.py +++ b/tests/unit/test_sandbox.py @@ -1,10 +1,9 @@ -import math - import hypothesis import numpy as np import pytest import stl import xarray as xr + import xcompact3d_toolbox as x3d import xcompact3d_toolbox.sandbox @@ -26,7 +25,7 @@ def cube(): [+1, -1, +1], [+1, +1, +1], [-1, +1, +1], - ] + ], ) # Define the 12 triangles composing the cube faces = np.array( @@ -55,28 +54,34 @@ def cube(): return cube +def test_init_epsi__no_ibm(): + prm = x3d.Parameters(xlx=2.0, yly=2.0, zlz=2.0, iibm=0) + expected_result = {} + actual_result = x3d.init_epsi(prm) + assert expected_result == actual_result + + +def test_init_epsi__ibm(): + prm = x3d.Parameters(xlx=2.0, yly=2.0, zlz=2.0, iibm=1) + + actual_result = x3d.init_epsi(prm) + assert actual_result.keys() == {"epsi"} + + @hypothesis.settings(deadline=None) @hypothesis.given( - x=hypothesis.strategies.floats( - min_value=-1e6, max_value=1e6, allow_nan=False, allow_infinity=False - ), - y=hypothesis.strategies.floats( - min_value=-1e6, max_value=1e6, allow_nan=False, allow_infinity=False - ), - z=hypothesis.strategies.floats( - min_value=-1e6, max_value=1e6, allow_nan=False, allow_infinity=False - ), + x=hypothesis.strategies.floats(min_value=-1e6, max_value=1e6, allow_nan=False, allow_infinity=False), + y=hypothesis.strategies.floats(min_value=-1e6, max_value=1e6, allow_nan=False, allow_infinity=False), + z=hypothesis.strategies.floats(min_value=-1e6, max_value=1e6, allow_nan=False, allow_infinity=False), ) @hypothesis.example(x=1.0, y=1.0, z=1.0) # edge case def test_point_is_inside_geometry(cube, x, y, z): - inside_cube = all([-1.0 <= dim <= 1.0 for dim in [x, y, z]]) - assert x3d.sandbox._point_in_geometry(cube.vectors, x, y, z, 0.05) == inside_cube + inside_cube = all(-1.0 <= dim <= 1.0 for dim in [x, y, z]) + assert x3d.sandbox._point_in_geometry(cube.vectors, x, y, z, 0.05) == inside_cube # noqa: SLF001 def test_geometry_from_stl(cube): prm = x3d.Parameters(xlx=2.0, yly=2.0, zlz=2.0, iibm=2) ds_stl = x3d.init_epsi(prm)["epsi"].geo.from_stl(stl_mesh=cube, user_tol=0.05) - ds_box = x3d.init_epsi(prm)["epsi"].geo.box( - x=(-1.0, 1.0), y=(-1.0, 1.0), z=(-1.0, 1.0) - ) + ds_box = x3d.init_epsi(prm)["epsi"].geo.box(x=(-1.0, 1.0), y=(-1.0, 1.0), z=(-1.0, 1.0)) xr.testing.assert_equal(ds_stl, ds_box) diff --git a/towncrier.toml b/towncrier.toml new file mode 100644 index 0000000..e0f09d4 --- /dev/null +++ b/towncrier.toml @@ -0,0 +1,47 @@ +[tool.towncrier] +package = "xcompact3d_toolbox" +directory = "changelog.d" +filename = "docs/news.md" +start_string = "\n" +title_format = "## [{version}](https://github.com/fschuch/xcompact3d_toolbox/releases/tag/v{version}) - {project_date}" +issue_format = "[#{issue}](https://github.com/fschuch/xcompact3d_toolbox/issues/{issue})" + +[[tool.towncrier.type]] +directory = "security" +name = "Security" +showcontent = true + +[[tool.towncrier.type]] +directory = "removed" +name = "Removed" +showcontent = true + +[[tool.towncrier.type]] +directory = "deprecated" +name = "Deprecated" +showcontent = true + +[[tool.towncrier.type]] +directory = "added" +name = "Added" +showcontent = true + +[[tool.towncrier.type]] +directory = "changed" +name = "Changed" +showcontent = true + +[[tool.towncrier.type]] +directory = "fixed" +name = "Fixed" +showcontent = true + +[[tool.towncrier.type]] +directory = "docs" +name = "Documentation" +showcontent = true + +[[tool.towncrier.type]] +directory = "misc" +name = "Misc" +showcontent = false diff --git a/versioneer.py b/versioneer.py deleted file mode 100644 index 64fea1c..0000000 --- a/versioneer.py +++ /dev/null @@ -1,1822 +0,0 @@ - -# Version: 0.18 - -"""The Versioneer - like a rocketeer, but for versions. - -The Versioneer -============== - -* like a rocketeer, but for versions! -* https://github.com/warner/python-versioneer -* Brian Warner -* License: Public Domain -* Compatible With: python2.6, 2.7, 3.2, 3.3, 3.4, 3.5, 3.6, and pypy -* [![Latest Version] -(https://pypip.in/version/versioneer/badge.svg?style=flat) -](https://pypi.python.org/pypi/versioneer/) -* [![Build Status] -(https://travis-ci.org/warner/python-versioneer.png?branch=master) -](https://travis-ci.org/warner/python-versioneer) - -This is a tool for managing a recorded version number in distutils-based -python projects. The goal is to remove the tedious and error-prone "update -the embedded version string" step from your release process. Making a new -release should be as easy as recording a new tag in your version-control -system, and maybe making new tarballs. - - -## Quick Install - -* `pip install versioneer` to somewhere to your $PATH -* add a `[versioneer]` section to your setup.cfg (see below) -* run `versioneer install` in your source tree, commit the results - -## Version Identifiers - -Source trees come from a variety of places: - -* a version-control system checkout (mostly used by developers) -* a nightly tarball, produced by build automation -* a snapshot tarball, produced by a web-based VCS browser, like github's - "tarball from tag" feature -* a release tarball, produced by "setup.py sdist", distributed through PyPI - -Within each source tree, the version identifier (either a string or a number, -this tool is format-agnostic) can come from a variety of places: - -* ask the VCS tool itself, e.g. "git describe" (for checkouts), which knows - about recent "tags" and an absolute revision-id -* the name of the directory into which the tarball was unpacked -* an expanded VCS keyword ($Id$, etc) -* a `_version.py` created by some earlier build step - -For released software, the version identifier is closely related to a VCS -tag. Some projects use tag names that include more than just the version -string (e.g. "myproject-1.2" instead of just "1.2"), in which case the tool -needs to strip the tag prefix to extract the version identifier. For -unreleased software (between tags), the version identifier should provide -enough information to help developers recreate the same tree, while also -giving them an idea of roughly how old the tree is (after version 1.2, before -version 1.3). Many VCS systems can report a description that captures this, -for example `git describe --tags --dirty --always` reports things like -"0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the -0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has -uncommitted changes. - -The version identifier is used for multiple purposes: - -* to allow the module to self-identify its version: `myproject.__version__` -* to choose a name and prefix for a 'setup.py sdist' tarball - -## Theory of Operation - -Versioneer works by adding a special `_version.py` file into your source -tree, where your `__init__.py` can import it. This `_version.py` knows how to -dynamically ask the VCS tool for version information at import time. - -`_version.py` also contains `$Revision$` markers, and the installation -process marks `_version.py` to have this marker rewritten with a tag name -during the `git archive` command. As a result, generated tarballs will -contain enough information to get the proper version. - -To allow `setup.py` to compute a version too, a `versioneer.py` is added to -the top level of your source tree, next to `setup.py` and the `setup.cfg` -that configures it. This overrides several distutils/setuptools commands to -compute the version when invoked, and changes `setup.py build` and `setup.py -sdist` to replace `_version.py` with a small static file that contains just -the generated version data. - -## Installation - -See [INSTALL.md](./INSTALL.md) for detailed installation instructions. - -## Version-String Flavors - -Code which uses Versioneer can learn about its version string at runtime by -importing `_version` from your main `__init__.py` file and running the -`get_versions()` function. From the "outside" (e.g. in `setup.py`), you can -import the top-level `versioneer.py` and run `get_versions()`. - -Both functions return a dictionary with different flavors of version -information: - -* `['version']`: A condensed version string, rendered using the selected - style. This is the most commonly used value for the project's version - string. The default "pep440" style yields strings like `0.11`, - `0.11+2.g1076c97`, or `0.11+2.g1076c97.dirty`. See the "Styles" section - below for alternative styles. - -* `['full-revisionid']`: detailed revision identifier. For Git, this is the - full SHA1 commit id, e.g. "1076c978a8d3cfc70f408fe5974aa6c092c949ac". - -* `['date']`: Date and time of the latest `HEAD` commit. For Git, it is the - commit date in ISO 8601 format. This will be None if the date is not - available. - -* `['dirty']`: a boolean, True if the tree has uncommitted changes. Note that - this is only accurate if run in a VCS checkout, otherwise it is likely to - be False or None - -* `['error']`: if the version string could not be computed, this will be set - to a string describing the problem, otherwise it will be None. It may be - useful to throw an exception in setup.py if this is set, to avoid e.g. - creating tarballs with a version string of "unknown". - -Some variants are more useful than others. Including `full-revisionid` in a -bug report should allow developers to reconstruct the exact code being tested -(or indicate the presence of local changes that should be shared with the -developers). `version` is suitable for display in an "about" box or a CLI -`--version` output: it can be easily compared against release notes and lists -of bugs fixed in various releases. - -The installer adds the following text to your `__init__.py` to place a basic -version in `YOURPROJECT.__version__`: - - from ._version import get_versions - __version__ = get_versions()['version'] - del get_versions - -## Styles - -The setup.cfg `style=` configuration controls how the VCS information is -rendered into a version string. - -The default style, "pep440", produces a PEP440-compliant string, equal to the -un-prefixed tag name for actual releases, and containing an additional "local -version" section with more detail for in-between builds. For Git, this is -TAG[+DISTANCE.gHEX[.dirty]] , using information from `git describe --tags ---dirty --always`. For example "0.11+2.g1076c97.dirty" indicates that the -tree is like the "1076c97" commit but has uncommitted changes (".dirty"), and -that this commit is two revisions ("+2") beyond the "0.11" tag. For released -software (exactly equal to a known tag), the identifier will only contain the -stripped tag, e.g. "0.11". - -Other styles are available. See [details.md](details.md) in the Versioneer -source tree for descriptions. - -## Debugging - -Versioneer tries to avoid fatal errors: if something goes wrong, it will tend -to return a version of "0+unknown". To investigate the problem, run `setup.py -version`, which will run the version-lookup code in a verbose mode, and will -display the full contents of `get_versions()` (including the `error` string, -which may help identify what went wrong). - -## Known Limitations - -Some situations are known to cause problems for Versioneer. This details the -most significant ones. More can be found on Github -[issues page](https://github.com/warner/python-versioneer/issues). - -### Subprojects - -Versioneer has limited support for source trees in which `setup.py` is not in -the root directory (e.g. `setup.py` and `.git/` are *not* siblings). The are -two common reasons why `setup.py` might not be in the root: - -* Source trees which contain multiple subprojects, such as - [Buildbot](https://github.com/buildbot/buildbot), which contains both - "master" and "slave" subprojects, each with their own `setup.py`, - `setup.cfg`, and `tox.ini`. Projects like these produce multiple PyPI - distributions (and upload multiple independently-installable tarballs). -* Source trees whose main purpose is to contain a C library, but which also - provide bindings to Python (and perhaps other langauges) in subdirectories. - -Versioneer will look for `.git` in parent directories, and most operations -should get the right version string. However `pip` and `setuptools` have bugs -and implementation details which frequently cause `pip install .` from a -subproject directory to fail to find a correct version string (so it usually -defaults to `0+unknown`). - -`pip install --editable .` should work correctly. `setup.py install` might -work too. - -Pip-8.1.1 is known to have this problem, but hopefully it will get fixed in -some later version. - -[Bug #38](https://github.com/warner/python-versioneer/issues/38) is tracking -this issue. The discussion in -[PR #61](https://github.com/warner/python-versioneer/pull/61) describes the -issue from the Versioneer side in more detail. -[pip PR#3176](https://github.com/pypa/pip/pull/3176) and -[pip PR#3615](https://github.com/pypa/pip/pull/3615) contain work to improve -pip to let Versioneer work correctly. - -Versioneer-0.16 and earlier only looked for a `.git` directory next to the -`setup.cfg`, so subprojects were completely unsupported with those releases. - -### Editable installs with setuptools <= 18.5 - -`setup.py develop` and `pip install --editable .` allow you to install a -project into a virtualenv once, then continue editing the source code (and -test) without re-installing after every change. - -"Entry-point scripts" (`setup(entry_points={"console_scripts": ..})`) are a -convenient way to specify executable scripts that should be installed along -with the python package. - -These both work as expected when using modern setuptools. When using -setuptools-18.5 or earlier, however, certain operations will cause -`pkg_resources.DistributionNotFound` errors when running the entrypoint -script, which must be resolved by re-installing the package. This happens -when the install happens with one version, then the egg_info data is -regenerated while a different version is checked out. Many setup.py commands -cause egg_info to be rebuilt (including `sdist`, `wheel`, and installing into -a different virtualenv), so this can be surprising. - -[Bug #83](https://github.com/warner/python-versioneer/issues/83) describes -this one, but upgrading to a newer version of setuptools should probably -resolve it. - -### Unicode version strings - -While Versioneer works (and is continually tested) with both Python 2 and -Python 3, it is not entirely consistent with bytes-vs-unicode distinctions. -Newer releases probably generate unicode version strings on py2. It's not -clear that this is wrong, but it may be surprising for applications when then -write these strings to a network connection or include them in bytes-oriented -APIs like cryptographic checksums. - -[Bug #71](https://github.com/warner/python-versioneer/issues/71) investigates -this question. - - -## Updating Versioneer - -To upgrade your project to a new release of Versioneer, do the following: - -* install the new Versioneer (`pip install -U versioneer` or equivalent) -* edit `setup.cfg`, if necessary, to include any new configuration settings - indicated by the release notes. See [UPGRADING](./UPGRADING.md) for details. -* re-run `versioneer install` in your source tree, to replace - `SRC/_version.py` -* commit any changed files - -## Future Directions - -This tool is designed to make it easily extended to other version-control -systems: all VCS-specific components are in separate directories like -src/git/ . The top-level `versioneer.py` script is assembled from these -components by running make-versioneer.py . In the future, make-versioneer.py -will take a VCS name as an argument, and will construct a version of -`versioneer.py` that is specific to the given VCS. It might also take the -configuration arguments that are currently provided manually during -installation by editing setup.py . Alternatively, it might go the other -direction and include code from all supported VCS systems, reducing the -number of intermediate scripts. - - -## License - -To make Versioneer easier to embed, all its code is dedicated to the public -domain. The `_version.py` that it creates is also in the public domain. -Specifically, both are released under the Creative Commons "Public Domain -Dedication" license (CC0-1.0), as described in -https://creativecommons.org/publicdomain/zero/1.0/ . - -""" - -from __future__ import print_function -try: - import configparser -except ImportError: - import ConfigParser as configparser -import errno -import json -import os -import re -import subprocess -import sys - - -class VersioneerConfig: - """Container for Versioneer configuration parameters.""" - - -def get_root(): - """Get the project root directory. - - We require that all commands are run from the project root, i.e. the - directory that contains setup.py, setup.cfg, and versioneer.py . - """ - root = os.path.realpath(os.path.abspath(os.getcwd())) - setup_py = os.path.join(root, "setup.py") - versioneer_py = os.path.join(root, "versioneer.py") - if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): - # allow 'python path/to/setup.py COMMAND' - root = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0]))) - setup_py = os.path.join(root, "setup.py") - versioneer_py = os.path.join(root, "versioneer.py") - if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): - err = ("Versioneer was unable to run the project root directory. " - "Versioneer requires setup.py to be executed from " - "its immediate directory (like 'python setup.py COMMAND'), " - "or in a way that lets it use sys.argv[0] to find the root " - "(like 'python path/to/setup.py COMMAND').") - raise VersioneerBadRootError(err) - try: - # Certain runtime workflows (setup.py install/develop in a setuptools - # tree) execute all dependencies in a single python process, so - # "versioneer" may be imported multiple times, and python's shared - # module-import table will cache the first one. So we can't use - # os.path.dirname(__file__), as that will find whichever - # versioneer.py was first imported, even in later projects. - me = os.path.realpath(os.path.abspath(__file__)) - me_dir = os.path.normcase(os.path.splitext(me)[0]) - vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0]) - if me_dir != vsr_dir: - print("Warning: build in %s is using versioneer.py from %s" - % (os.path.dirname(me), versioneer_py)) - except NameError: - pass - return root - - -def get_config_from_root(root): - """Read the project setup.cfg file to determine Versioneer config.""" - # This might raise EnvironmentError (if setup.cfg is missing), or - # configparser.NoSectionError (if it lacks a [versioneer] section), or - # configparser.NoOptionError (if it lacks "VCS="). See the docstring at - # the top of versioneer.py for instructions on writing your setup.cfg . - setup_cfg = os.path.join(root, "setup.cfg") - parser = configparser.SafeConfigParser() - with open(setup_cfg, "r") as f: - parser.readfp(f) - VCS = parser.get("versioneer", "VCS") # mandatory - - def get(parser, name): - if parser.has_option("versioneer", name): - return parser.get("versioneer", name) - return None - cfg = VersioneerConfig() - cfg.VCS = VCS - cfg.style = get(parser, "style") or "" - cfg.versionfile_source = get(parser, "versionfile_source") - cfg.versionfile_build = get(parser, "versionfile_build") - cfg.tag_prefix = get(parser, "tag_prefix") - if cfg.tag_prefix in ("''", '""'): - cfg.tag_prefix = "" - cfg.parentdir_prefix = get(parser, "parentdir_prefix") - cfg.verbose = get(parser, "verbose") - return cfg - - -class NotThisMethod(Exception): - """Exception raised if a method is not valid for the current scenario.""" - - -# these dictionaries contain VCS-specific tools -LONG_VERSION_PY = {} -HANDLERS = {} - - -def register_vcs_handler(vcs, method): # decorator - """Decorator to mark a method as the handler for a particular VCS.""" - def decorate(f): - """Store f in HANDLERS[vcs][method].""" - if vcs not in HANDLERS: - HANDLERS[vcs] = {} - HANDLERS[vcs][method] = f - return f - return decorate - - -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): - """Call the given command(s).""" - assert isinstance(commands, list) - p = None - for c in commands: - try: - dispcmd = str([c] + args) - # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen([c] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) - break - except EnvironmentError: - e = sys.exc_info()[1] - if e.errno == errno.ENOENT: - continue - if verbose: - print("unable to run %s" % dispcmd) - print(e) - return None, None - else: - if verbose: - print("unable to find command, tried %s" % (commands,)) - return None, None - stdout = p.communicate()[0].strip() - if sys.version_info[0] >= 3: - stdout = stdout.decode() - if p.returncode != 0: - if verbose: - print("unable to run %s (error)" % dispcmd) - print("stdout was %s" % stdout) - return None, p.returncode - return stdout, p.returncode - - -LONG_VERSION_PY['git'] = ''' -# This file helps to compute a version number in source trees obtained from -# git-archive tarball (such as those provided by githubs download-from-tag -# feature). Distribution tarballs (built by setup.py sdist) and build -# directories (produced by setup.py build) will contain a much shorter file -# that just contains the computed version number. - -# This file is released into the public domain. Generated by -# versioneer-0.18 (https://github.com/warner/python-versioneer) - -"""Git implementation of _version.py.""" - -import errno -import os -import re -import subprocess -import sys - - -def get_keywords(): - """Get the keywords needed to look up the version information.""" - # these strings will be replaced by git during git-archive. - # setup.py/versioneer.py will grep for the variable names, so they must - # each be defined on a line of their own. _version.py will just call - # get_keywords(). - git_refnames = "%(DOLLAR)sFormat:%%d%(DOLLAR)s" - git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s" - git_date = "%(DOLLAR)sFormat:%%ci%(DOLLAR)s" - keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} - return keywords - - -class VersioneerConfig: - """Container for Versioneer configuration parameters.""" - - -def get_config(): - """Create, populate and return the VersioneerConfig() object.""" - # these strings are filled in when 'setup.py versioneer' creates - # _version.py - cfg = VersioneerConfig() - cfg.VCS = "git" - cfg.style = "%(STYLE)s" - cfg.tag_prefix = "%(TAG_PREFIX)s" - cfg.parentdir_prefix = "%(PARENTDIR_PREFIX)s" - cfg.versionfile_source = "%(VERSIONFILE_SOURCE)s" - cfg.verbose = False - return cfg - - -class NotThisMethod(Exception): - """Exception raised if a method is not valid for the current scenario.""" - - -LONG_VERSION_PY = {} -HANDLERS = {} - - -def register_vcs_handler(vcs, method): # decorator - """Decorator to mark a method as the handler for a particular VCS.""" - def decorate(f): - """Store f in HANDLERS[vcs][method].""" - if vcs not in HANDLERS: - HANDLERS[vcs] = {} - HANDLERS[vcs][method] = f - return f - return decorate - - -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): - """Call the given command(s).""" - assert isinstance(commands, list) - p = None - for c in commands: - try: - dispcmd = str([c] + args) - # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen([c] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) - break - except EnvironmentError: - e = sys.exc_info()[1] - if e.errno == errno.ENOENT: - continue - if verbose: - print("unable to run %%s" %% dispcmd) - print(e) - return None, None - else: - if verbose: - print("unable to find command, tried %%s" %% (commands,)) - return None, None - stdout = p.communicate()[0].strip() - if sys.version_info[0] >= 3: - stdout = stdout.decode() - if p.returncode != 0: - if verbose: - print("unable to run %%s (error)" %% dispcmd) - print("stdout was %%s" %% stdout) - return None, p.returncode - return stdout, p.returncode - - -def versions_from_parentdir(parentdir_prefix, root, verbose): - """Try to determine the version from the parent directory name. - - Source tarballs conventionally unpack into a directory that includes both - the project name and a version string. We will also support searching up - two directory levels for an appropriately named parent directory - """ - rootdirs = [] - - for i in range(3): - dirname = os.path.basename(root) - if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} - else: - rootdirs.append(root) - root = os.path.dirname(root) # up a level - - if verbose: - print("Tried directories %%s but none started with prefix %%s" %% - (str(rootdirs), parentdir_prefix)) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - - -@register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs): - """Extract version information from the given file.""" - # the code embedded in _version.py can just fetch the value of these - # keywords. When used from setup.py, we don't want to import _version.py, - # so we do it with a regexp instead. This function is not used from - # _version.py. - keywords = {} - try: - f = open(versionfile_abs, "r") - for line in f.readlines(): - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - if line.strip().startswith("git_date ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["date"] = mo.group(1) - f.close() - except EnvironmentError: - pass - return keywords - - -@register_vcs_handler("git", "keywords") -def git_versions_from_keywords(keywords, tag_prefix, verbose): - """Get version information from git keywords.""" - if not keywords: - raise NotThisMethod("no keywords at all, weird") - date = keywords.get("date") - if date is not None: - # git-2.2.0 added "%%cI", which expands to an ISO-8601 -compliant - # datestamp. However we prefer "%%ci" (which expands to an "ISO-8601 - # -like" string, which we must then edit to make compliant), because - # it's been around since git-1.5.3, and it's too difficult to - # discover which version we're using, or to work around using an - # older one. - date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - refnames = keywords["refnames"].strip() - if refnames.startswith("$Format"): - if verbose: - print("keywords are unexpanded, not using") - raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = set([r.strip() for r in refnames.strip("()").split(",")]) - # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of - # just "foo-1.0". If we see a "tag: " prefix, prefer those. - TAG = "tag: " - tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) - if not tags: - # Either we're using git < 1.8.3, or there really are no tags. We use - # a heuristic: assume all version tags have a digit. The old git %%d - # expansion behaves like git log --decorate=short and strips out the - # refs/heads/ and refs/tags/ prefixes that would let us distinguish - # between branches and tags. By ignoring refnames without digits, we - # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r'\d', r)]) - if verbose: - print("discarding '%%s', no digits" %% ",".join(refs - tags)) - if verbose: - print("likely tags: %%s" %% ",".join(sorted(tags))) - for ref in sorted(tags): - # sorting will prefer e.g. "2.0" over "2.0rc1" - if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] - if verbose: - print("picking %%s" %% r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} - # no suitable tags, so version is "0+unknown", but full hex is still there - if verbose: - print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} - - -@register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): - """Get version from 'git describe' in the root of the source tree. - - This only gets called if the git-archive 'subst' keywords were *not* - expanded, and _version.py hasn't already been rewritten with a short - version string, meaning we're inside a checked out source tree. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - - out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) - if rc != 0: - if verbose: - print("Directory %%s not under git control" %% root) - raise NotThisMethod("'git rev-parse --git-dir' returned error") - - # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] - # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%%s*" %% tag_prefix], - cwd=root) - # --long was added in git-1.5.5 - if describe_out is None: - raise NotThisMethod("'git describe' failed") - describe_out = describe_out.strip() - full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) - if full_out is None: - raise NotThisMethod("'git rev-parse' failed") - full_out = full_out.strip() - - pieces = {} - pieces["long"] = full_out - pieces["short"] = full_out[:7] # maybe improved later - pieces["error"] = None - - # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] - # TAG might have hyphens. - git_describe = describe_out - - # look for -dirty suffix - dirty = git_describe.endswith("-dirty") - pieces["dirty"] = dirty - if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] - - # now we have TAG-NUM-gHEX or HEX - - if "-" in git_describe: - # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) - if not mo: - # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%%s'" - %% describe_out) - return pieces - - # tag - full_tag = mo.group(1) - if not full_tag.startswith(tag_prefix): - if verbose: - fmt = "tag '%%s' doesn't start with prefix '%%s'" - print(fmt %% (full_tag, tag_prefix)) - pieces["error"] = ("tag '%%s' doesn't start with prefix '%%s'" - %% (full_tag, tag_prefix)) - return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] - - # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) - - # commit: short hex revision ID - pieces["short"] = mo.group(3) - - else: - # HEX: no tags - pieces["closest-tag"] = None - count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], - cwd=root) - pieces["distance"] = int(count_out) # total number of commits - - # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%%ci", "HEAD"], - cwd=root)[0].strip() - pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - - return pieces - - -def plus_or_dot(pieces): - """Return a + if we don't already have one, else return a .""" - if "+" in pieces.get("closest-tag", ""): - return "." - return "+" - - -def render_pep440(pieces): - """Build up version string, with post-release "local version identifier". - - Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you - get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty - - Exceptions: - 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += plus_or_dot(pieces) - rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0+untagged.%%d.g%%s" %% (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_pre(pieces): - """TAG[.post.devDISTANCE] -- No -dirty. - - Exceptions: - 1: no tags. 0.post.devDISTANCE - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post.dev%%d" %% pieces["distance"] - else: - # exception #1 - rendered = "0.post.dev%%d" %% pieces["distance"] - return rendered - - -def render_pep440_post(pieces): - """TAG[.postDISTANCE[.dev0]+gHEX] . - - The ".dev0" means dirty. Note that .dev0 sorts backwards - (a dirty tree will appear "older" than the corresponding clean one), - but you shouldn't be releasing software with -dirty anyways. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%%s" %% pieces["short"] - else: - # exception #1 - rendered = "0.post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%%s" %% pieces["short"] - return rendered - - -def render_pep440_old(pieces): - """TAG[.postDISTANCE[.dev0]] . - - The ".dev0" means dirty. - - Eexceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - else: - # exception #1 - rendered = "0.post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - return rendered - - -def render_git_describe(pieces): - """TAG[-DISTANCE-gHEX][-dirty]. - - Like 'git describe --tags --dirty --always'. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render_git_describe_long(pieces): - """TAG-DISTANCE-gHEX[-dirty]. - - Like 'git describe --tags --dirty --always -long'. - The distance/hash is unconditional. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render(pieces, style): - """Render the given version pieces into the requested style.""" - if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None} - - if not style or style == "default": - style = "pep440" # the default - - if style == "pep440": - rendered = render_pep440(pieces) - elif style == "pep440-pre": - rendered = render_pep440_pre(pieces) - elif style == "pep440-post": - rendered = render_pep440_post(pieces) - elif style == "pep440-old": - rendered = render_pep440_old(pieces) - elif style == "git-describe": - rendered = render_git_describe(pieces) - elif style == "git-describe-long": - rendered = render_git_describe_long(pieces) - else: - raise ValueError("unknown style '%%s'" %% style) - - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None, - "date": pieces.get("date")} - - -def get_versions(): - """Get version information or return default if unable to do so.""" - # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have - # __file__, we can work backwards from there to the root. Some - # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which - # case we can only use expanded keywords. - - cfg = get_config() - verbose = cfg.verbose - - try: - return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, - verbose) - except NotThisMethod: - pass - - try: - root = os.path.realpath(__file__) - # versionfile_source is the relative path from the top of the source - # tree (where the .git directory might live) to this file. Invert - # this to find the root from __file__. - for i in cfg.versionfile_source.split('/'): - root = os.path.dirname(root) - except NameError: - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to find root of source tree", - "date": None} - - try: - pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) - return render(pieces, cfg.style) - except NotThisMethod: - pass - - try: - if cfg.parentdir_prefix: - return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) - except NotThisMethod: - pass - - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", "date": None} -''' - - -@register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs): - """Extract version information from the given file.""" - # the code embedded in _version.py can just fetch the value of these - # keywords. When used from setup.py, we don't want to import _version.py, - # so we do it with a regexp instead. This function is not used from - # _version.py. - keywords = {} - try: - f = open(versionfile_abs, "r") - for line in f.readlines(): - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - if line.strip().startswith("git_date ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["date"] = mo.group(1) - f.close() - except EnvironmentError: - pass - return keywords - - -@register_vcs_handler("git", "keywords") -def git_versions_from_keywords(keywords, tag_prefix, verbose): - """Get version information from git keywords.""" - if not keywords: - raise NotThisMethod("no keywords at all, weird") - date = keywords.get("date") - if date is not None: - # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant - # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 - # -like" string, which we must then edit to make compliant), because - # it's been around since git-1.5.3, and it's too difficult to - # discover which version we're using, or to work around using an - # older one. - date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - refnames = keywords["refnames"].strip() - if refnames.startswith("$Format"): - if verbose: - print("keywords are unexpanded, not using") - raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = set([r.strip() for r in refnames.strip("()").split(",")]) - # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of - # just "foo-1.0". If we see a "tag: " prefix, prefer those. - TAG = "tag: " - tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) - if not tags: - # Either we're using git < 1.8.3, or there really are no tags. We use - # a heuristic: assume all version tags have a digit. The old git %d - # expansion behaves like git log --decorate=short and strips out the - # refs/heads/ and refs/tags/ prefixes that would let us distinguish - # between branches and tags. By ignoring refnames without digits, we - # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r'\d', r)]) - if verbose: - print("discarding '%s', no digits" % ",".join(refs - tags)) - if verbose: - print("likely tags: %s" % ",".join(sorted(tags))) - for ref in sorted(tags): - # sorting will prefer e.g. "2.0" over "2.0rc1" - if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] - if verbose: - print("picking %s" % r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} - # no suitable tags, so version is "0+unknown", but full hex is still there - if verbose: - print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} - - -@register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): - """Get version from 'git describe' in the root of the source tree. - - This only gets called if the git-archive 'subst' keywords were *not* - expanded, and _version.py hasn't already been rewritten with a short - version string, meaning we're inside a checked out source tree. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - - out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) - if rc != 0: - if verbose: - print("Directory %s not under git control" % root) - raise NotThisMethod("'git rev-parse --git-dir' returned error") - - # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] - # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%s*" % tag_prefix], - cwd=root) - # --long was added in git-1.5.5 - if describe_out is None: - raise NotThisMethod("'git describe' failed") - describe_out = describe_out.strip() - full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) - if full_out is None: - raise NotThisMethod("'git rev-parse' failed") - full_out = full_out.strip() - - pieces = {} - pieces["long"] = full_out - pieces["short"] = full_out[:7] # maybe improved later - pieces["error"] = None - - # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] - # TAG might have hyphens. - git_describe = describe_out - - # look for -dirty suffix - dirty = git_describe.endswith("-dirty") - pieces["dirty"] = dirty - if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] - - # now we have TAG-NUM-gHEX or HEX - - if "-" in git_describe: - # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) - if not mo: - # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%s'" - % describe_out) - return pieces - - # tag - full_tag = mo.group(1) - if not full_tag.startswith(tag_prefix): - if verbose: - fmt = "tag '%s' doesn't start with prefix '%s'" - print(fmt % (full_tag, tag_prefix)) - pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" - % (full_tag, tag_prefix)) - return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] - - # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) - - # commit: short hex revision ID - pieces["short"] = mo.group(3) - - else: - # HEX: no tags - pieces["closest-tag"] = None - count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], - cwd=root) - pieces["distance"] = int(count_out) # total number of commits - - # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], - cwd=root)[0].strip() - pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - - return pieces - - -def do_vcs_install(manifest_in, versionfile_source, ipy): - """Git-specific installation logic for Versioneer. - - For Git, this means creating/changing .gitattributes to mark _version.py - for export-subst keyword substitution. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - files = [manifest_in, versionfile_source] - if ipy: - files.append(ipy) - try: - me = __file__ - if me.endswith(".pyc") or me.endswith(".pyo"): - me = os.path.splitext(me)[0] + ".py" - versioneer_file = os.path.relpath(me) - except NameError: - versioneer_file = "versioneer.py" - files.append(versioneer_file) - present = False - try: - f = open(".gitattributes", "r") - for line in f.readlines(): - if line.strip().startswith(versionfile_source): - if "export-subst" in line.strip().split()[1:]: - present = True - f.close() - except EnvironmentError: - pass - if not present: - f = open(".gitattributes", "a+") - f.write("%s export-subst\n" % versionfile_source) - f.close() - files.append(".gitattributes") - run_command(GITS, ["add", "--"] + files) - - -def versions_from_parentdir(parentdir_prefix, root, verbose): - """Try to determine the version from the parent directory name. - - Source tarballs conventionally unpack into a directory that includes both - the project name and a version string. We will also support searching up - two directory levels for an appropriately named parent directory - """ - rootdirs = [] - - for i in range(3): - dirname = os.path.basename(root) - if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} - else: - rootdirs.append(root) - root = os.path.dirname(root) # up a level - - if verbose: - print("Tried directories %s but none started with prefix %s" % - (str(rootdirs), parentdir_prefix)) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - - -SHORT_VERSION_PY = """ -# This file was generated by 'versioneer.py' (0.18) from -# revision-control system data, or from the parent directory name of an -# unpacked source archive. Distribution tarballs contain a pre-generated copy -# of this file. - -import json - -version_json = ''' -%s -''' # END VERSION_JSON - - -def get_versions(): - return json.loads(version_json) -""" - - -def versions_from_file(filename): - """Try to determine the version from _version.py if present.""" - try: - with open(filename) as f: - contents = f.read() - except EnvironmentError: - raise NotThisMethod("unable to read _version.py") - mo = re.search(r"version_json = '''\n(.*)''' # END VERSION_JSON", - contents, re.M | re.S) - if not mo: - mo = re.search(r"version_json = '''\r\n(.*)''' # END VERSION_JSON", - contents, re.M | re.S) - if not mo: - raise NotThisMethod("no version_json in _version.py") - return json.loads(mo.group(1)) - - -def write_to_version_file(filename, versions): - """Write the given version number to the given _version.py file.""" - os.unlink(filename) - contents = json.dumps(versions, sort_keys=True, - indent=1, separators=(",", ": ")) - with open(filename, "w") as f: - f.write(SHORT_VERSION_PY % contents) - - print("set %s to '%s'" % (filename, versions["version"])) - - -def plus_or_dot(pieces): - """Return a + if we don't already have one, else return a .""" - if "+" in pieces.get("closest-tag", ""): - return "." - return "+" - - -def render_pep440(pieces): - """Build up version string, with post-release "local version identifier". - - Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you - get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty - - Exceptions: - 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += plus_or_dot(pieces) - rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_pre(pieces): - """TAG[.post.devDISTANCE] -- No -dirty. - - Exceptions: - 1: no tags. 0.post.devDISTANCE - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post.dev%d" % pieces["distance"] - else: - # exception #1 - rendered = "0.post.dev%d" % pieces["distance"] - return rendered - - -def render_pep440_post(pieces): - """TAG[.postDISTANCE[.dev0]+gHEX] . - - The ".dev0" means dirty. Note that .dev0 sorts backwards - (a dirty tree will appear "older" than the corresponding clean one), - but you shouldn't be releasing software with -dirty anyways. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%s" % pieces["short"] - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] - return rendered - - -def render_pep440_old(pieces): - """TAG[.postDISTANCE[.dev0]] . - - The ".dev0" means dirty. - - Eexceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - return rendered - - -def render_git_describe(pieces): - """TAG[-DISTANCE-gHEX][-dirty]. - - Like 'git describe --tags --dirty --always'. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render_git_describe_long(pieces): - """TAG-DISTANCE-gHEX[-dirty]. - - Like 'git describe --tags --dirty --always -long'. - The distance/hash is unconditional. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render(pieces, style): - """Render the given version pieces into the requested style.""" - if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None} - - if not style or style == "default": - style = "pep440" # the default - - if style == "pep440": - rendered = render_pep440(pieces) - elif style == "pep440-pre": - rendered = render_pep440_pre(pieces) - elif style == "pep440-post": - rendered = render_pep440_post(pieces) - elif style == "pep440-old": - rendered = render_pep440_old(pieces) - elif style == "git-describe": - rendered = render_git_describe(pieces) - elif style == "git-describe-long": - rendered = render_git_describe_long(pieces) - else: - raise ValueError("unknown style '%s'" % style) - - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None, - "date": pieces.get("date")} - - -class VersioneerBadRootError(Exception): - """The project root directory is unknown or missing key files.""" - - -def get_versions(verbose=False): - """Get the project version from whatever source is available. - - Returns dict with two keys: 'version' and 'full'. - """ - if "versioneer" in sys.modules: - # see the discussion in cmdclass.py:get_cmdclass() - del sys.modules["versioneer"] - - root = get_root() - cfg = get_config_from_root(root) - - assert cfg.VCS is not None, "please set [versioneer]VCS= in setup.cfg" - handlers = HANDLERS.get(cfg.VCS) - assert handlers, "unrecognized VCS '%s'" % cfg.VCS - verbose = verbose or cfg.verbose - assert cfg.versionfile_source is not None, \ - "please set versioneer.versionfile_source" - assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix" - - versionfile_abs = os.path.join(root, cfg.versionfile_source) - - # extract version from first of: _version.py, VCS command (e.g. 'git - # describe'), parentdir. This is meant to work for developers using a - # source checkout, for users of a tarball created by 'setup.py sdist', - # and for users of a tarball/zipball created by 'git archive' or github's - # download-from-tag feature or the equivalent in other VCSes. - - get_keywords_f = handlers.get("get_keywords") - from_keywords_f = handlers.get("keywords") - if get_keywords_f and from_keywords_f: - try: - keywords = get_keywords_f(versionfile_abs) - ver = from_keywords_f(keywords, cfg.tag_prefix, verbose) - if verbose: - print("got version from expanded keyword %s" % ver) - return ver - except NotThisMethod: - pass - - try: - ver = versions_from_file(versionfile_abs) - if verbose: - print("got version from file %s %s" % (versionfile_abs, ver)) - return ver - except NotThisMethod: - pass - - from_vcs_f = handlers.get("pieces_from_vcs") - if from_vcs_f: - try: - pieces = from_vcs_f(cfg.tag_prefix, root, verbose) - ver = render(pieces, cfg.style) - if verbose: - print("got version from VCS %s" % ver) - return ver - except NotThisMethod: - pass - - try: - if cfg.parentdir_prefix: - ver = versions_from_parentdir(cfg.parentdir_prefix, root, verbose) - if verbose: - print("got version from parentdir %s" % ver) - return ver - except NotThisMethod: - pass - - if verbose: - print("unable to compute version") - - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, "error": "unable to compute version", - "date": None} - - -def get_version(): - """Get the short version string for this project.""" - return get_versions()["version"] - - -def get_cmdclass(): - """Get the custom setuptools/distutils subclasses used by Versioneer.""" - if "versioneer" in sys.modules: - del sys.modules["versioneer"] - # this fixes the "python setup.py develop" case (also 'install' and - # 'easy_install .'), in which subdependencies of the main project are - # built (using setup.py bdist_egg) in the same python process. Assume - # a main project A and a dependency B, which use different versions - # of Versioneer. A's setup.py imports A's Versioneer, leaving it in - # sys.modules by the time B's setup.py is executed, causing B to run - # with the wrong versioneer. Setuptools wraps the sub-dep builds in a - # sandbox that restores sys.modules to it's pre-build state, so the - # parent is protected against the child's "import versioneer". By - # removing ourselves from sys.modules here, before the child build - # happens, we protect the child from the parent's versioneer too. - # Also see https://github.com/warner/python-versioneer/issues/52 - - cmds = {} - - # we add "version" to both distutils and setuptools - from distutils.core import Command - - class cmd_version(Command): - description = "report generated version string" - user_options = [] - boolean_options = [] - - def initialize_options(self): - pass - - def finalize_options(self): - pass - - def run(self): - vers = get_versions(verbose=True) - print("Version: %s" % vers["version"]) - print(" full-revisionid: %s" % vers.get("full-revisionid")) - print(" dirty: %s" % vers.get("dirty")) - print(" date: %s" % vers.get("date")) - if vers["error"]: - print(" error: %s" % vers["error"]) - cmds["version"] = cmd_version - - # we override "build_py" in both distutils and setuptools - # - # most invocation pathways end up running build_py: - # distutils/build -> build_py - # distutils/install -> distutils/build ->.. - # setuptools/bdist_wheel -> distutils/install ->.. - # setuptools/bdist_egg -> distutils/install_lib -> build_py - # setuptools/install -> bdist_egg ->.. - # setuptools/develop -> ? - # pip install: - # copies source tree to a tempdir before running egg_info/etc - # if .git isn't copied too, 'git describe' will fail - # then does setup.py bdist_wheel, or sometimes setup.py install - # setup.py egg_info -> ? - - # we override different "build_py" commands for both environments - if "setuptools" in sys.modules: - from setuptools.command.build_py import build_py as _build_py - else: - from distutils.command.build_py import build_py as _build_py - - class cmd_build_py(_build_py): - def run(self): - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - _build_py.run(self) - # now locate _version.py in the new build/ directory and replace - # it with an updated value - if cfg.versionfile_build: - target_versionfile = os.path.join(self.build_lib, - cfg.versionfile_build) - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - cmds["build_py"] = cmd_build_py - - if "cx_Freeze" in sys.modules: # cx_freeze enabled? - from cx_Freeze.dist import build_exe as _build_exe - # nczeczulin reports that py2exe won't like the pep440-style string - # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g. - # setup(console=[{ - # "version": versioneer.get_version().split("+", 1)[0], # FILEVERSION - # "product_version": versioneer.get_version(), - # ... - - class cmd_build_exe(_build_exe): - def run(self): - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - target_versionfile = cfg.versionfile_source - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - - _build_exe.run(self) - os.unlink(target_versionfile) - with open(cfg.versionfile_source, "w") as f: - LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % - {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) - cmds["build_exe"] = cmd_build_exe - del cmds["build_py"] - - if 'py2exe' in sys.modules: # py2exe enabled? - try: - from py2exe.distutils_buildexe import py2exe as _py2exe # py3 - except ImportError: - from py2exe.build_exe import py2exe as _py2exe # py2 - - class cmd_py2exe(_py2exe): - def run(self): - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - target_versionfile = cfg.versionfile_source - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - - _py2exe.run(self) - os.unlink(target_versionfile) - with open(cfg.versionfile_source, "w") as f: - LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % - {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) - cmds["py2exe"] = cmd_py2exe - - # we override different "sdist" commands for both environments - if "setuptools" in sys.modules: - from setuptools.command.sdist import sdist as _sdist - else: - from distutils.command.sdist import sdist as _sdist - - class cmd_sdist(_sdist): - def run(self): - versions = get_versions() - self._versioneer_generated_versions = versions - # unless we update this, the command will keep using the old - # version - self.distribution.metadata.version = versions["version"] - return _sdist.run(self) - - def make_release_tree(self, base_dir, files): - root = get_root() - cfg = get_config_from_root(root) - _sdist.make_release_tree(self, base_dir, files) - # now locate _version.py in the new base_dir directory - # (remembering that it may be a hardlink) and replace it with an - # updated value - target_versionfile = os.path.join(base_dir, cfg.versionfile_source) - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, - self._versioneer_generated_versions) - cmds["sdist"] = cmd_sdist - - return cmds - - -CONFIG_ERROR = """ -setup.cfg is missing the necessary Versioneer configuration. You need -a section like: - - [versioneer] - VCS = git - style = pep440 - versionfile_source = src/myproject/_version.py - versionfile_build = myproject/_version.py - tag_prefix = - parentdir_prefix = myproject- - -You will also need to edit your setup.py to use the results: - - import versioneer - setup(version=versioneer.get_version(), - cmdclass=versioneer.get_cmdclass(), ...) - -Please read the docstring in ./versioneer.py for configuration instructions, -edit setup.cfg, and re-run the installer or 'python versioneer.py setup'. -""" - -SAMPLE_CONFIG = """ -# See the docstring in versioneer.py for instructions. Note that you must -# re-run 'versioneer.py setup' after changing this section, and commit the -# resulting files. - -[versioneer] -#VCS = git -#style = pep440 -#versionfile_source = -#versionfile_build = -#tag_prefix = -#parentdir_prefix = - -""" - -INIT_PY_SNIPPET = """ -from ._version import get_versions -__version__ = get_versions()['version'] -del get_versions -""" - - -def do_setup(): - """Main VCS-independent setup function for installing Versioneer.""" - root = get_root() - try: - cfg = get_config_from_root(root) - except (EnvironmentError, configparser.NoSectionError, - configparser.NoOptionError) as e: - if isinstance(e, (EnvironmentError, configparser.NoSectionError)): - print("Adding sample versioneer config to setup.cfg", - file=sys.stderr) - with open(os.path.join(root, "setup.cfg"), "a") as f: - f.write(SAMPLE_CONFIG) - print(CONFIG_ERROR, file=sys.stderr) - return 1 - - print(" creating %s" % cfg.versionfile_source) - with open(cfg.versionfile_source, "w") as f: - LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) - - ipy = os.path.join(os.path.dirname(cfg.versionfile_source), - "__init__.py") - if os.path.exists(ipy): - try: - with open(ipy, "r") as f: - old = f.read() - except EnvironmentError: - old = "" - if INIT_PY_SNIPPET not in old: - print(" appending to %s" % ipy) - with open(ipy, "a") as f: - f.write(INIT_PY_SNIPPET) - else: - print(" %s unmodified" % ipy) - else: - print(" %s doesn't exist, ok" % ipy) - ipy = None - - # Make sure both the top-level "versioneer.py" and versionfile_source - # (PKG/_version.py, used by runtime code) are in MANIFEST.in, so - # they'll be copied into source distributions. Pip won't be able to - # install the package without this. - manifest_in = os.path.join(root, "MANIFEST.in") - simple_includes = set() - try: - with open(manifest_in, "r") as f: - for line in f: - if line.startswith("include "): - for include in line.split()[1:]: - simple_includes.add(include) - except EnvironmentError: - pass - # That doesn't cover everything MANIFEST.in can do - # (http://docs.python.org/2/distutils/sourcedist.html#commands), so - # it might give some false negatives. Appending redundant 'include' - # lines is safe, though. - if "versioneer.py" not in simple_includes: - print(" appending 'versioneer.py' to MANIFEST.in") - with open(manifest_in, "a") as f: - f.write("include versioneer.py\n") - else: - print(" 'versioneer.py' already in MANIFEST.in") - if cfg.versionfile_source not in simple_includes: - print(" appending versionfile_source ('%s') to MANIFEST.in" % - cfg.versionfile_source) - with open(manifest_in, "a") as f: - f.write("include %s\n" % cfg.versionfile_source) - else: - print(" versionfile_source already in MANIFEST.in") - - # Make VCS-specific changes. For git, this means creating/changing - # .gitattributes to mark _version.py for export-subst keyword - # substitution. - do_vcs_install(manifest_in, cfg.versionfile_source, ipy) - return 0 - - -def scan_setup_py(): - """Validate the contents of setup.py against Versioneer's expectations.""" - found = set() - setters = False - errors = 0 - with open("setup.py", "r") as f: - for line in f.readlines(): - if "import versioneer" in line: - found.add("import") - if "versioneer.get_cmdclass()" in line: - found.add("cmdclass") - if "versioneer.get_version()" in line: - found.add("get_version") - if "versioneer.VCS" in line: - setters = True - if "versioneer.versionfile_source" in line: - setters = True - if len(found) != 3: - print("") - print("Your setup.py appears to be missing some important items") - print("(but I might be wrong). Please make sure it has something") - print("roughly like the following:") - print("") - print(" import versioneer") - print(" setup( version=versioneer.get_version(),") - print(" cmdclass=versioneer.get_cmdclass(), ...)") - print("") - errors += 1 - if setters: - print("You should remove lines like 'versioneer.VCS = ' and") - print("'versioneer.versionfile_source = ' . This configuration") - print("now lives in setup.cfg, and should be removed from setup.py") - print("") - errors += 1 - return errors - - -if __name__ == "__main__": - cmd = sys.argv[1] - if cmd == "setup": - errors = do_setup() - errors += scan_setup_py() - if errors: - sys.exit(1) diff --git a/xcompact3d_toolbox/__init__.py b/xcompact3d_toolbox/__init__.py index baa8955..5be2a17 100644 --- a/xcompact3d_toolbox/__init__.py +++ b/xcompact3d_toolbox/__init__.py @@ -1,11 +1,12 @@ -from . import tutorial -from ._version import get_versions -from .array import X3dDataArray, X3dDataset -from .genepsi import gene_epsi_3D -from .gui import ParametersGui -from .param import param -from .parameters import Parameters -from .sandbox import init_dataset, init_epsi +from loguru import logger -__version__ = get_versions()["version"] -del get_versions +from xcompact3d_toolbox import tutorial +from xcompact3d_toolbox._version import __version__ +from xcompact3d_toolbox.array import X3dDataArray, X3dDataset +from xcompact3d_toolbox.genepsi import gene_epsi_3d +from xcompact3d_toolbox.gui import ParametersGui +from xcompact3d_toolbox.param import param +from xcompact3d_toolbox.parameters import Parameters +from xcompact3d_toolbox.sandbox import init_dataset, init_epsi + +logger.disable("xcompact3d_toolbox") diff --git a/xcompact3d_toolbox/_version.py b/xcompact3d_toolbox/_version.py index 5b7df6f..c3f96bc 100644 --- a/xcompact3d_toolbox/_version.py +++ b/xcompact3d_toolbox/_version.py @@ -1,556 +1,3 @@ -# This file helps to compute a version number in source trees obtained from -# git-archive tarball (such as those provided by githubs download-from-tag -# feature). Distribution tarballs (built by setup.py sdist) and build -# directories (produced by setup.py build) will contain a much shorter file -# that just contains the computed version number. +"""Version information for xcompact3d_toolbox package.""" -# This file is released into the public domain. Generated by -# versioneer-0.18 (https://github.com/warner/python-versioneer) - -"""Git implementation of _version.py.""" - -import errno -import os -import re -import subprocess -import sys - - -def get_keywords(): - """Get the keywords needed to look up the version information.""" - # these strings will be replaced by git during git-archive. - # setup.py/versioneer.py will grep for the variable names, so they must - # each be defined on a line of their own. _version.py will just call - # get_keywords(). - git_refnames = "$Format:%d$" - git_full = "$Format:%H$" - git_date = "$Format:%ci$" - keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} - return keywords - - -class VersioneerConfig: - """Container for Versioneer configuration parameters.""" - - -def get_config(): - """Create, populate and return the VersioneerConfig() object.""" - # these strings are filled in when 'setup.py versioneer' creates - # _version.py - cfg = VersioneerConfig() - cfg.VCS = "git" - cfg.style = "pep440" - cfg.tag_prefix = "v" - cfg.parentdir_prefix = "xcompact3d_toolbox-" - cfg.versionfile_source = "xcompact3d_toolbox/_version.py" - cfg.verbose = False - return cfg - - -class NotThisMethod(Exception): - """Exception raised if a method is not valid for the current scenario.""" - - -LONG_VERSION_PY = {} -HANDLERS = {} - - -def register_vcs_handler(vcs, method): # decorator - """Decorator to mark a method as the handler for a particular VCS.""" - - def decorate(f): - """Store f in HANDLERS[vcs][method].""" - if vcs not in HANDLERS: - HANDLERS[vcs] = {} - HANDLERS[vcs][method] = f - return f - - return decorate - - -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None): - """Call the given command(s).""" - assert isinstance(commands, list) - p = None - for c in commands: - try: - dispcmd = str([c] + args) - # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen( - [c] + args, - cwd=cwd, - env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr else None), - ) - break - except EnvironmentError: - e = sys.exc_info()[1] - if e.errno == errno.ENOENT: - continue - if verbose: - print("unable to run %s" % dispcmd) - print(e) - return None, None - else: - if verbose: - print("unable to find command, tried %s" % (commands,)) - return None, None - stdout = p.communicate()[0].strip() - if sys.version_info[0] >= 3: - stdout = stdout.decode() - if p.returncode != 0: - if verbose: - print("unable to run %s (error)" % dispcmd) - print("stdout was %s" % stdout) - return None, p.returncode - return stdout, p.returncode - - -def versions_from_parentdir(parentdir_prefix, root, verbose): - """Try to determine the version from the parent directory name. - - Source tarballs conventionally unpack into a directory that includes both - the project name and a version string. We will also support searching up - two directory levels for an appropriately named parent directory - """ - rootdirs = [] - - for i in range(3): - dirname = os.path.basename(root) - if dirname.startswith(parentdir_prefix): - return { - "version": dirname[len(parentdir_prefix) :], - "full-revisionid": None, - "dirty": False, - "error": None, - "date": None, - } - else: - rootdirs.append(root) - root = os.path.dirname(root) # up a level - - if verbose: - print( - "Tried directories %s but none started with prefix %s" - % (str(rootdirs), parentdir_prefix) - ) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - - -@register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs): - """Extract version information from the given file.""" - # the code embedded in _version.py can just fetch the value of these - # keywords. When used from setup.py, we don't want to import _version.py, - # so we do it with a regexp instead. This function is not used from - # _version.py. - keywords = {} - try: - f = open(versionfile_abs, "r") - for line in f.readlines(): - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - if line.strip().startswith("git_date ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["date"] = mo.group(1) - f.close() - except EnvironmentError: - pass - return keywords - - -@register_vcs_handler("git", "keywords") -def git_versions_from_keywords(keywords, tag_prefix, verbose): - """Get version information from git keywords.""" - if not keywords: - raise NotThisMethod("no keywords at all, weird") - date = keywords.get("date") - if date is not None: - # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant - # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 - # -like" string, which we must then edit to make compliant), because - # it's been around since git-1.5.3, and it's too difficult to - # discover which version we're using, or to work around using an - # older one. - date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - refnames = keywords["refnames"].strip() - if refnames.startswith("$Format"): - if verbose: - print("keywords are unexpanded, not using") - raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = set([r.strip() for r in refnames.strip("()").split(",")]) - # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of - # just "foo-1.0". If we see a "tag: " prefix, prefer those. - TAG = "tag: " - tags = set([r[len(TAG) :] for r in refs if r.startswith(TAG)]) - if not tags: - # Either we're using git < 1.8.3, or there really are no tags. We use - # a heuristic: assume all version tags have a digit. The old git %d - # expansion behaves like git log --decorate=short and strips out the - # refs/heads/ and refs/tags/ prefixes that would let us distinguish - # between branches and tags. By ignoring refnames without digits, we - # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r"\d", r)]) - if verbose: - print("discarding '%s', no digits" % ",".join(refs - tags)) - if verbose: - print("likely tags: %s" % ",".join(sorted(tags))) - for ref in sorted(tags): - # sorting will prefer e.g. "2.0" over "2.0rc1" - if ref.startswith(tag_prefix): - r = ref[len(tag_prefix) :] - if verbose: - print("picking %s" % r) - return { - "version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, - "error": None, - "date": date, - } - # no suitable tags, so version is "0+unknown", but full hex is still there - if verbose: - print("no suitable tags, using unknown + full revision id") - return { - "version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, - "error": "no suitable tags", - "date": None, - } - - -@register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): - """Get version from 'git describe' in the root of the source tree. - - This only gets called if the git-archive 'subst' keywords were *not* - expanded, and _version.py hasn't already been rewritten with a short - version string, meaning we're inside a checked out source tree. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - - out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True) - if rc != 0: - if verbose: - print("Directory %s not under git control" % root) - raise NotThisMethod("'git rev-parse --git-dir' returned error") - - # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] - # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command( - GITS, - [ - "describe", - "--tags", - "--dirty", - "--always", - "--long", - "--match", - "%s*" % tag_prefix, - ], - cwd=root, - ) - # --long was added in git-1.5.5 - if describe_out is None: - raise NotThisMethod("'git describe' failed") - describe_out = describe_out.strip() - full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) - if full_out is None: - raise NotThisMethod("'git rev-parse' failed") - full_out = full_out.strip() - - pieces = {} - pieces["long"] = full_out - pieces["short"] = full_out[:7] # maybe improved later - pieces["error"] = None - - # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] - # TAG might have hyphens. - git_describe = describe_out - - # look for -dirty suffix - dirty = git_describe.endswith("-dirty") - pieces["dirty"] = dirty - if dirty: - git_describe = git_describe[: git_describe.rindex("-dirty")] - - # now we have TAG-NUM-gHEX or HEX - - if "-" in git_describe: - # TAG-NUM-gHEX - mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe) - if not mo: - # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = "unable to parse git-describe output: '%s'" % describe_out - return pieces - - # tag - full_tag = mo.group(1) - if not full_tag.startswith(tag_prefix): - if verbose: - fmt = "tag '%s' doesn't start with prefix '%s'" - print(fmt % (full_tag, tag_prefix)) - pieces["error"] = "tag '%s' doesn't start with prefix '%s'" % ( - full_tag, - tag_prefix, - ) - return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix) :] - - # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) - - # commit: short hex revision ID - pieces["short"] = mo.group(3) - - else: - # HEX: no tags - pieces["closest-tag"] = None - count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], cwd=root) - pieces["distance"] = int(count_out) # total number of commits - - # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[ - 0 - ].strip() - pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - - return pieces - - -def plus_or_dot(pieces): - """Return a + if we don't already have one, else return a .""" - if "+" in pieces.get("closest-tag", ""): - return "." - return "+" - - -def render_pep440(pieces): - """Build up version string, with post-release "local version identifier". - - Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you - get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty - - Exceptions: - 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += plus_or_dot(pieces) - rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_pre(pieces): - """TAG[.post.devDISTANCE] -- No -dirty. - - Exceptions: - 1: no tags. 0.post.devDISTANCE - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post.dev%d" % pieces["distance"] - else: - # exception #1 - rendered = "0.post.dev%d" % pieces["distance"] - return rendered - - -def render_pep440_post(pieces): - """TAG[.postDISTANCE[.dev0]+gHEX] . - - The ".dev0" means dirty. Note that .dev0 sorts backwards - (a dirty tree will appear "older" than the corresponding clean one), - but you shouldn't be releasing software with -dirty anyways. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%s" % pieces["short"] - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] - return rendered - - -def render_pep440_old(pieces): - """TAG[.postDISTANCE[.dev0]] . - - The ".dev0" means dirty. - - Eexceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - return rendered - - -def render_git_describe(pieces): - """TAG[-DISTANCE-gHEX][-dirty]. - - Like 'git describe --tags --dirty --always'. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render_git_describe_long(pieces): - """TAG-DISTANCE-gHEX[-dirty]. - - Like 'git describe --tags --dirty --always -long'. - The distance/hash is unconditional. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render(pieces, style): - """Render the given version pieces into the requested style.""" - if pieces["error"]: - return { - "version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None, - } - - if not style or style == "default": - style = "pep440" # the default - - if style == "pep440": - rendered = render_pep440(pieces) - elif style == "pep440-pre": - rendered = render_pep440_pre(pieces) - elif style == "pep440-post": - rendered = render_pep440_post(pieces) - elif style == "pep440-old": - rendered = render_pep440_old(pieces) - elif style == "git-describe": - rendered = render_git_describe(pieces) - elif style == "git-describe-long": - rendered = render_git_describe_long(pieces) - else: - raise ValueError("unknown style '%s'" % style) - - return { - "version": rendered, - "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], - "error": None, - "date": pieces.get("date"), - } - - -def get_versions(): - """Get version information or return default if unable to do so.""" - # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have - # __file__, we can work backwards from there to the root. Some - # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which - # case we can only use expanded keywords. - - cfg = get_config() - verbose = cfg.verbose - - try: - return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, verbose) - except NotThisMethod: - pass - - try: - root = os.path.realpath(__file__) - # versionfile_source is the relative path from the top of the source - # tree (where the .git directory might live) to this file. Invert - # this to find the root from __file__. - for i in cfg.versionfile_source.split("/"): - root = os.path.dirname(root) - except NameError: - return { - "version": "0+unknown", - "full-revisionid": None, - "dirty": None, - "error": "unable to find root of source tree", - "date": None, - } - - try: - pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) - return render(pieces, cfg.style) - except NotThisMethod: - pass - - try: - if cfg.parentdir_prefix: - return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) - except NotThisMethod: - pass - - return { - "version": "0+unknown", - "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", - "date": None, - } +__version__ = "1.1.1" diff --git a/xcompact3d_toolbox/array.py b/xcompact3d_toolbox/array.py index bf808c1..07d7d2c 100644 --- a/xcompact3d_toolbox/array.py +++ b/xcompact3d_toolbox/array.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """The data structure is provided by `xarray`_, that introduces labels in the form of dimensions, coordinates and attributes on top of raw `NumPy`_-like arrays, which allows for a more intuitive, more concise, and less error-prone @@ -13,11 +12,11 @@ see how to plot `Gridded Data`_. Xcompact3d-toolbox adds extra functions on top of :obj:`xarray.DataArray` -and :obj:`xarray.Dataset`, all the details are described bellow. +and :obj:`xarray.Dataset`, all the details are described below. .. _dask: https://dask.org/ .. _numpy: https://numpy.org/ -.. _xarray: http://xarray.pydata.org/en/stable/ +.. _xarray: http://docs.xarray.dev/en/stable .. _hvPlot : https://hvplot.holoviz.org/ .. _`Gridded Data` : https://hvplot.holoviz.org/user_guide/Gridded_Data.html @@ -26,9 +25,9 @@ import xarray as xr from scipy.integrate import cumtrapz, simps -from .derive import FirstDerivative, SecondDerivative -from .mesh import _stretching -from .param import param +from xcompact3d_toolbox.derive import first_derivative, second_derivative +from xcompact3d_toolbox.mesh import Istret, _stretching +from xcompact3d_toolbox.param import param @xr.register_dataset_accessor("x3d") @@ -36,7 +35,6 @@ class X3dDataset: """An accessor with extra utilities for :obj:`xarray.Dataset`.""" def __init__(self, data_set): - self._data_set = data_set def cumtrapz(self, dim): @@ -58,7 +56,7 @@ def cumtrapz(self, dim): Examples ------- - >>> ds.x3d.cumtrapz('t') + >>> ds.x3d.cumtrapz("t") """ @@ -74,7 +72,7 @@ def cumtrapz(self, dim): def simps(self, *args): """Integrate all arrays in this dataset in direction(s) ``args`` - using the composite Simpson’s rule. + using the composite Simpson's rule. It is a wrapper for :obj:`scipy.integrate.simps`. Parameters @@ -95,9 +93,9 @@ def simps(self, *args): Examples ------- - >>> ds.x3d.simps('x') - >>> ds.x3d.simps('t') - >>> ds.x3d.simps('x', 'y', 'z') + >>> ds.x3d.simps("x") + >>> ds.x3d.simps("t") + >>> ds.x3d.simps("x", "y", "z") """ @@ -112,18 +110,15 @@ def integrate(dataset, dim): ) for var in args: - if not var in self._data_set.dims: - raise ValueError( - f'Invalid value for "args", it should be a valid dimension' - ) + if var not in self._data_set.dims: + msg = 'Invalid value for "args", it should be a valid dimension' + raise ValueError(msg) + result = 0 for i, var in enumerate(args): - if i == 0: - I = integrate(self._data_set, var) - else: - I = integrate(I, var) + result = integrate(self._data_set, var) if i == 0 else integrate(result, var) - return I + return result def pencil_decomp(self, *args): """Coerce all arrays in this dataset into dask arrays. @@ -152,20 +147,17 @@ def pencil_decomp(self, *args): Examples ------- - >>> ds.x3d.pencil_decomp('x') # Pencil decomposition - >>> ds.x3d.pencil_decomp('t') - >>> ds.x3d.pencil_decomp('y', 'z') # Slab decomposition + >>> ds.x3d.pencil_decomp("x") # Pencil decomposition + >>> ds.x3d.pencil_decomp("t") + >>> ds.x3d.pencil_decomp("y", "z") # Slab decomposition """ if not set(args).issubset(set(self._data_set.dims)): - raise ValueError( - f'Invalid value for "args", it should be a valid dimension' - ) + msg = 'Invalid value for "args", it should be a valid dimension' + raise ValueError(msg) - return self._data_set.chunk( - chunks={dim: "auto" if dim in args else -1 for dim in self._data_set.dims} - ) + return self._data_set.chunk(chunks={dim: "auto" if dim in args else -1 for dim in self._data_set.dims}) @xr.register_dataarray_accessor("x3d") @@ -197,15 +189,15 @@ def cumtrapz(self, dim): Examples ------- - >>> da.x3d.cumtrapz('t') + >>> da.x3d.cumtrapz("t") """ - ds = self._data_array._to_temp_dataset().x3d.cumtrapz(dim) - return self._data_array._from_temp_dataset(ds) + ds = self._data_array._to_temp_dataset().x3d.cumtrapz(dim) # noqa: SLF001 + return self._data_array._from_temp_dataset(ds) # noqa: SLF001 def simps(self, *args): """Integrate :obj:`xarray.DataArray` in direction(s) ``args`` using the - composite Simpson’s rule. + composite Simpson's rule. It is a wrapper for :obj:`scipy.integrate.simps`. Parameters @@ -226,13 +218,13 @@ def simps(self, *args): Examples ------- - >>> da.x3d.simps('x') - >>> da.x3d.simps('t') - >>> da.x3d.simps('x', 'y', 'z') + >>> da.x3d.simps("x") + >>> da.x3d.simps("t") + >>> da.x3d.simps("x", "y", "z") """ - ds = self._data_array._to_temp_dataset().x3d.simps(*args) - return self._data_array._from_temp_dataset(ds) + ds = self._data_array._to_temp_dataset().x3d.simps(*args) # noqa: SLF001 + return self._data_array._from_temp_dataset(ds) # noqa: SLF001 def pencil_decomp(self, *args): """Coerce the data array into dask array. @@ -261,20 +253,20 @@ def pencil_decomp(self, *args): Examples ------- - >>> da.x3d.pencil_decomp('x') # Pencil decomposition - >>> da.x3d.pencil_decomp('t') - >>> da.x3d.pencil_decomp('y', 'z') # Slab decomposition + >>> da.x3d.pencil_decomp("x") # Pencil decomposition + >>> da.x3d.pencil_decomp("t") + >>> da.x3d.pencil_decomp("y", "z") # Slab decomposition """ - ds = self._data_array._to_temp_dataset().x3d.pencil_decomp(*args) - return self._data_array._from_temp_dataset(ds) + ds = self._data_array._to_temp_dataset().x3d.pencil_decomp(*args) # noqa: SLF001 + return self._data_array._from_temp_dataset(ds) # noqa: SLF001 def first_derivative(self, dim): """Compute first derivative with the 4th order accurate centered scheme. It is fully functional with all boundary conditions available on XCompact3d and stretched mesh in the vertical direction (y). - The **atribute** ``BC`` is used to store Boundary Condition information + The **attribute** ``BC`` is used to store Boundary Condition information in a dictionary (see examples), default is ``ncl1 = ncln = 2`` and ``npaire = 1``. @@ -309,13 +301,13 @@ def first_derivative(self, dim): ... 'ncln': 0, ... 'npaire': 1 ... } - >>> da.x3d.first_derivative('x') + >>> da.x3d.first_derivative("x") or just: >>> prm = xcompact3d_toolbox.Parameters() - >>> da.attrs['BC'] = prm.get_boundary_condition('ux') - >>> da.x3d.first_derivative('x') + >>> da.attrs["BC"] = prm.get_boundary_condition("ux") + >>> da.x3d.first_derivative("x") """ @@ -324,23 +316,22 @@ def first_derivative(self, dim): ncl1 = self._data_array.attrs["BC"][dim]["ncl1"] ncln = self._data_array.attrs["BC"][dim]["ncln"] npaire = self._data_array.attrs["BC"][dim]["npaire"] - except: + except KeyError: ncl1, ncln, npaire = 2, 2, 1 n = self._data_array[dim].size m = n if ncl1 == 0 and ncln == 0 else n - 1 d = (self._data_array[dim][-1] - self._data_array[dim][0]).values / m - self._Dx[dim] = FirstDerivative(n, d, ncl1, ncln, npaire) + self._Dx[dim] = first_derivative(n, d, ncl1, ncln, npaire) try: istret = self._data_array.attrs["BC"][dim]["istret"] beta = self._data_array.attrs["BC"][dim]["beta"] - except: - istret = 0 + except KeyError: + istret = Istret.NO_REFINEMENT beta = 1.0 - if istret == 0: - + if istret == Istret.NO_REFINEMENT: return xr.apply_ufunc( lambda f: self._Dx[dim].dot(f), self._data_array, @@ -351,30 +342,28 @@ def first_derivative(self, dim): output_dtypes=[param["mytype"]], ) - else: + yly = (self._data_array[dim][-1] - self._data_array[dim][0]).values - yly = (self._data_array[dim][-1] - self._data_array[dim][0]).values + _, ppy, _, _ = _stretching(istret, beta, yly, m, n) - yp, ppy, pp2y, pp4y = _stretching(istret, beta, yly, m, n) + da_ppy = xr.DataArray(ppy, coords=[self._data_array[dim]], name="ppy") - da_ppy = xr.DataArray(ppy, coords=[self._data_array[dim]], name="ppy") - - return da_ppy * xr.apply_ufunc( - lambda f: self._Dx[dim].dot(f), - self._data_array, - input_core_dims=[[dim]], - output_core_dims=[[dim]], - dask="parallelized", - vectorize=True, - output_dtypes=[param["mytype"]], - ) + return da_ppy * xr.apply_ufunc( + lambda f: self._Dx[dim].dot(f), + self._data_array, + input_core_dims=[[dim]], + output_core_dims=[[dim]], + dask="parallelized", + vectorize=True, + output_dtypes=[param["mytype"]], + ) def second_derivative(self, dim): """Compute second derivative with the 4th order accurate centered scheme. It is fully functional with all boundary conditions available on Xcompact3d and stretched mesh in y direction. - The **atribute** ``BC`` is used to store Boundary Condition information + The **attribute** ``BC`` is used to store Boundary Condition information in a dictionary (see examples), default is ``ncl1 = ncln = 2`` and ``npaire = 1``. @@ -409,36 +398,35 @@ def second_derivative(self, dim): ... 'ncln': 0, ... 'npaire': 1 ... } - >>> da.x3d.second_derivative('x') + >>> da.x3d.second_derivative("x") or just: >>> prm = xcompact3d_toolbox.Parameters() - >>> da.attrs['BC'] = prm.get_boundary_condition('ux') - >>> da.x3d.second_derivative('x') + >>> da.attrs["BC"] = prm.get_boundary_condition("ux") + >>> da.x3d.second_derivative("x") """ if dim not in self._Dxx: try: ncl1 = self._data_array.attrs["BC"][dim]["ncl1"] ncln = self._data_array.attrs["BC"][dim]["ncln"] npaire = self._data_array.attrs["BC"][dim]["npaire"] - except: + except KeyError: ncl1, ncln, npaire = 2, 2, 1 n = self._data_array[dim].size m = n if ncl1 == 0 and ncln == 0 else n - 1 d = (self._data_array[dim][-1] - self._data_array[dim][0]).values / m - self._Dxx[dim] = SecondDerivative(n, d, ncl1, ncln, npaire) + self._Dxx[dim] = second_derivative(n, d, ncl1, ncln, npaire) try: istret = self._data_array.attrs["BC"][dim]["istret"] beta = self._data_array.attrs["BC"][dim]["beta"] - except: - istret = 0 + except KeyError: + istret = Istret.NO_REFINEMENT beta = 1.0 - if istret == 0: - + if istret == Istret.NO_REFINEMENT: return xr.apply_ufunc( lambda f: self._Dxx[dim].dot(f), self._data_array, @@ -449,25 +437,19 @@ def second_derivative(self, dim): output_dtypes=[param["mytype"]], ) - else: + yly = (self._data_array[dim][-1] - self._data_array[dim][0]).values - yly = (self._data_array[dim][-1] - self._data_array[dim][0]).values + _, _, pp2y, pp4y = _stretching(istret, beta, yly, m, n) - yp, ppy, pp2y, pp4y = _stretching(istret, beta, yly, m, n) + da_pp2y = xr.DataArray(pp2y, coords=[self._data_array[dim]], name="pp2y") + da_pp4y = xr.DataArray(pp4y, coords=[self._data_array[dim]], name="pp4y") - da_pp2y = xr.DataArray(pp2y, coords=[self._data_array[dim]], name="pp2y") - da_pp4y = xr.DataArray(pp4y, coords=[self._data_array[dim]], name="pp4y") - - return ( - da_pp2y - * xr.apply_ufunc( - lambda f: self._Dxx[dim].dot(f), - self._data_array, - input_core_dims=[[dim]], - output_core_dims=[[dim]], - dask="parallelized", - vectorize=True, - output_dtypes=[param["mytype"]], - ) - - da_pp4y * self._data_array.x3d.first_derivative(dim) - ) + return da_pp2y * xr.apply_ufunc( + lambda f: self._Dxx[dim].dot(f), + self._data_array, + input_core_dims=[[dim]], + output_core_dims=[[dim]], + dask="parallelized", + vectorize=True, + output_dtypes=[param["mytype"]], + ) - da_pp4y * self._data_array.x3d.first_derivative(dim) diff --git a/xcompact3d_toolbox/derive.py b/xcompact3d_toolbox/derive.py index a1ffe95..648fbc0 100644 --- a/xcompact3d_toolbox/derive.py +++ b/xcompact3d_toolbox/derive.py @@ -1,9 +1,9 @@ import scipy.sparse as sp -from .param import param +from xcompact3d_toolbox.param import param -def SecondDerivative(n, d=None, ncl1=2, ncln=2, npaire=1, coord=None): +def second_derivative(n, d=None, ncl1=2, ncln=2, npaire=1): """ f_xx = (-1*f[i-2]+16*f[i-1]-30*f[i+0]+16*f[i+1]-1*f[i+2])/(12*h**2) """ @@ -37,7 +37,7 @@ def SecondDerivative(n, d=None, ncl1=2, ncln=2, npaire=1, coord=None): rhs[0, 2] *= 2.0 # f_xx = (-1*f[1]+16*f[0]-30*f[1]+16*f[2]-1*f[3])/(12*h**2) rhs[1, 1] += rhs[1, 3] - elif ncl1 == 2: + elif ncl1 == 2: # noqa: PLR2004 # f_xx = (35*f[0]-104*f[1]+114*f[2]-56*f[3]+11*f[4])/(12*h**2) rhs[0, 0] = 35.0 rhs[0, 1] = -104.0 @@ -73,7 +73,7 @@ def SecondDerivative(n, d=None, ncl1=2, ncln=2, npaire=1, coord=None): rhs[-1, -3] *= 2.0 # f_xx = (-1*f[-4]+16*f[-3]-30*f[-2]+16*f[-1]-1*f[-2])/(12*h**2) rhs[-2, -2] += rhs[-2, -4] - elif ncln == 2: + elif ncln == 2: # noqa: PLR2004 # f_xx = (11*f[-5]-56*f[-4]+114*f[-3]-104*f[-2]+35*f[-1])/(12*h**2) rhs[-1, -5] = 11.0 rhs[-1, -4] = -56.0 @@ -90,7 +90,7 @@ def SecondDerivative(n, d=None, ncl1=2, ncln=2, npaire=1, coord=None): return (rhs / (12.0 * d * d)).tocoo() -def FirstDerivative(n, d, ncl1=2, ncln=2, npaire=1): +def first_derivative(n, d, ncl1=2, ncln=2, npaire=1): """ f_x = (1*f[i-2]-8*f[i-1]+0*f[i+0]+8*f[i+1]-1*f[i+2])/(12*h**1) """ @@ -122,7 +122,7 @@ def FirstDerivative(n, d, ncl1=2, ncln=2, npaire=1): rhs[0, 2] = 0.0 # f_x = (1*f[1]-8*f[0]+0*f[1]+8*f[2]-1*f[3])/(12*h**1) rhs[1, 1] -= rhs[1, 3] - elif ncl1 == 2: + elif ncl1 == 2: # noqa: PLR2004 # f_x = (-25*f[0]+48*f[1]-36*f[2]+16*f[3]-3*f[4])/(12*h**1) rhs[0, 0] = -25.0 rhs[0, 1] = 48.0 @@ -156,7 +156,7 @@ def FirstDerivative(n, d, ncl1=2, ncln=2, npaire=1): rhs[-1, -3] = 0.0 # f_x = (1*f[-4]-8*f[-3]+0*f[-2]+8*f[-1]-1*f[-2])/(12*h**1) rhs[-2, -2] -= rhs[-2, -4] - elif ncln == 2: + elif ncln == 2: # noqa: PLR2004 # f_x = (3*f[-5]-16*f[-4]+36*f[-3]-48*f[-2]+25*f[-1])/(12*h**1) rhs[-1, -5] = 3.0 rhs[-1, -4] = -16.0 diff --git a/xcompact3d_toolbox/genepsi.py b/xcompact3d_toolbox/genepsi.py index 4a61aca..473dfeb 100644 --- a/xcompact3d_toolbox/genepsi.py +++ b/xcompact3d_toolbox/genepsi.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """This module generates all the files necessary for our customized Immersed Boundary Method, based on Lagrange reconstructions. It is an adaptation to Python from the @@ -8,7 +7,7 @@ jet control with microjets using an alternating direction forcing strategy, Int. J. of Computational Fluid Dynamics, 28, 393--410. -:obj:`gene_epsi_3D` is powered by `Numba`_, it translates Python functions to +:obj:`gene_epsi_3d` is powered by `Numba`_, it translates Python functions to optimized machine code at runtime. Numba-compiled numerical algorithms in Python can approach the speeds of C or FORTRAN. @@ -22,10 +21,11 @@ import numba import numpy as np import xarray as xr +from loguru import logger -def gene_epsi_3D(epsi_in_dict, prm): - """This function generates all the auxiliar files necessary for our +def gene_epsi_3d(epsi_in_dict, prm): + """This function generates all the Auxiliary files necessary for our customize IBM, based on Lagrange reconstructions. The arrays can be initialized with :obj:`xcompact3d_toolbox.sandbox.init_epsi()`, then, some standard geometries are provided by the accessor @@ -59,7 +59,7 @@ def gene_epsi_3D(epsi_in_dict, prm): >>> epsi = x3d.sandbox.init_epsi(prm) >>> for key in epsi.keys(): ... epsi[key] = epsi[key].geo.cylinder(x=4, y=5) - >>> dataset = x3d.gene_epsi_3D(epsi, prm) + >>> dataset = x3d.gene_epsi_3d(epsi, prm) Remember to set the number of objects after that if ``prm.iibm >= 2``: @@ -68,7 +68,7 @@ def gene_epsi_3D(epsi_in_dict, prm): """ - def obj_count(dataArray, dim): + def obj_count(data_array, dim): """Counts the number of objects in a given direction""" @numba.jit @@ -81,14 +81,14 @@ def count(array): return xr.apply_ufunc( count, - dataArray, + data_array, input_core_dims=[[dim]], vectorize=True, dask="parallelized", output_dtypes=[np.int64], ) - def get_boundaries(dataArray, dim, max_obj, length): + def get_boundaries(data_array, dim, max_obj, length): """Gets the boundaries in a given direction""" @numba.jit @@ -112,11 +112,11 @@ def pos(array, x): return xr.apply_ufunc( pos, - dataArray, - dataArray[dim], + data_array, + data_array[dim], input_core_dims=[[dim], [dim]], output_core_dims=[["obj"], ["obj"]], - dask_gufunc_kwargs=dict(output_sizes=dict(obj=max_obj)), + dask_gufunc_kwargs={"output_sizes": {"obj": max_obj}}, vectorize=True, dask="parallelized", output_dtypes=[np.float64, np.float64], @@ -148,28 +148,18 @@ def fix(xi_in, xf_in, nobjx, nobjxraf, epsi, refepsi, nraf, nobjmax): idebraf = iiraf + 1 if refepsi[iiraf] and not refepsi[iiraf + 1]: ifinraf = iiraf + 1 - if ( - idebraf != 0 - and ifinraf != 0 - and idebraf < ifinraf - and iflu == 1 - ): + if idebraf != 0 and ifinraf != 0 and idebraf < ifinraf and iflu == 1: iobj += 1 for ii in range(iobj, nobjmax - 1): xi[ii] = xi[ii + 1] xf[ii] = xf[ii + 1] iobj -= 1 - if ( - idebraf != 0 - and ifinraf != 0 - and idebraf > ifinraf - and isol == 1 - ): + if idebraf != 0 and ifinraf != 0 and idebraf > ifinraf and isol == 1: iobj += 1 for ii in range(iobj, nobjmax - 1): xi[ii] = xi[ii + 1] iobj -= 1 - for i in range(iobj, nobjmax - 1): + for ii in range(iobj, nobjmax - 1): xf[ii] = xf[ii + 1] return xi, xf @@ -182,7 +172,7 @@ def fix(xi_in, xf_in, nobjx, nobjxraf, epsi, refepsi, nraf, nobjmax): nobjxraf, epsi, refepsi, - kwargs=dict(nraf=nraf, nobjmax=nobjmax), + kwargs={"nraf": nraf, "nobjmax": nobjmax}, input_core_dims=[["obj"], ["obj"], [], [], [dim], [dim + "_raf"]], output_core_dims=[["obj"], ["obj"]], vectorize=True, @@ -236,7 +226,7 @@ def verif(epsi): epsi, input_core_dims=[[dim]], output_core_dims=[["obj_aux"], ["obj_aux"], ["c"]], - dask_gufunc_kwargs=dict(output_sizes=dict(obj_aux=max_obj + 1, c=1)), + dask_gufunc_kwargs={"output_sizes": {"obj_aux": max_obj + 1, "c": 1}}, vectorize=True, dask="parallelized", output_dtypes=[np.int64, np.int64, np.int64], @@ -257,51 +247,45 @@ def verif(epsi): ds = epsi.to_dataset(name="epsi") - for dir, ep in zip(["x", "y", "z"], [xepsi, yepsi, zepsi]): - - ds[f"nobj_{dir}"] = obj_count(epsi, dir) - ds[f"nobjmax_{dir}"] = ds[f"nobj_{dir}"].max() - ds[f"nobjraf_{dir}"] = obj_count(ep, dir) - ds[f"nobjmaxraf_{dir}"] = ds[f"nobjraf_{dir}"].max() + for direction, ep in zip(["x", "y", "z"], [xepsi, yepsi, zepsi]): + ds[f"nobj_{direction}"] = obj_count(epsi, direction) + ds[f"nobjmax_{direction}"] = ds[f"nobj_{direction}"].max() + ds[f"nobjraf_{direction}"] = obj_count(ep, direction) + ds[f"nobjmaxraf_{direction}"] = ds[f"nobjraf_{direction}"].max() - ds[f"ibug_{dir}"] = ( - xr.zeros_like(ds[f"nobj_{dir}"]) - .where(ds[f"nobj_{dir}"] == ds[f"nobjraf_{dir}"], 1) - .sum() + ds[f"ibug_{direction}"] = ( + xr.zeros_like(ds[f"nobj_{direction}"]).where(ds[f"nobj_{direction}"] == ds[f"nobjraf_{direction}"], 1).sum() ) - print(f"{dir}") - print(f' nobjraf : {ds[f"nobjmax_{dir}"].values}') - print(f' nobjmaxraf : {ds[f"nobjmaxraf_{dir}"].values}') - print(f' bug : {ds[f"ibug_{dir}"].values}\n') + logger.debug( + f"{direction}\n" + f" nobjraf : {ds[f'nobjmax_{direction}'].values}\n" + f" nobjmaxraf : {ds[f'nobjmaxraf_{direction}'].values}\n" + f" bug : {ds[f'ibug_{direction}'].values}\n" + ) max_obj = np.max([ds.nobjmax_x.values, ds.nobjmax_y.values, ds.nobjmax_z.values]) ds = ds.assign_coords(obj=range(max_obj), obj_aux=range(-1, max_obj)) - for dir, ep, l in zip( - ["x", "y", "z"], [xepsi, yepsi, zepsi], [prm.xlx, prm.yly, prm.zlz] - ): + for direction, ep, length in zip(["x", "y", "z"], [xepsi, yepsi, zepsi], [prm.xlx, prm.yly, prm.zlz]): + ds[f"xi_{direction}"], ds[f"xf_{direction}"] = get_boundaries(ep, direction, max_obj, length) - ds[f"xi_{dir}"], ds[f"xf_{dir}"] = get_boundaries(ep, dir, max_obj, l) - - if ds[f"ibug_{dir}"] != 0: - ds[f"xi_{dir}"], ds[f"xf_{dir}"] = fix_bug( - ds[f"xi_{dir}"], - ds[f"xf_{dir}"], + if ds[f"ibug_{direction}"] != 0: + ds[f"xi_{direction}"], ds[f"xf_{direction}"] = fix_bug( + ds[f"xi_{direction}"], + ds[f"xf_{direction}"], nraf, int(max_obj), - ds[f"nobj_{dir}"], - ds[f"nobjmaxraf_{dir}"], + ds[f"nobj_{direction}"], + ds[f"nobjmaxraf_{direction}"], epsi, - ep.rename(**{dir: dir + "_raf"}), - dir, + ep.rename(**{direction: direction + "_raf"}), + direction, ) - ds[f"nxipif_{dir}"], ds[f"nxfpif_{dir}"], ising = verif_epsi(epsi, dir) + ds[f"nxipif_{direction}"], ds[f"nxfpif_{direction}"], ising = verif_epsi(epsi, direction) - print( - f"number of points with potential problem in {dir} : {ising.sum().values}" - ) + logger.debug(f"number of points with potential problem in {direction} : {ising.sum().values}") write_geomcomplex(prm, ds) @@ -317,30 +301,25 @@ def write_nobj(array, dim) -> None: def write_nxipif(array1, array2, dim) -> None: _array1 = transpose_n_flatten(array1) _array2 = transpose_n_flatten(array2) - with open( - os.path.join(data_path, f"n{dim}ifpif.dat"), "w", newline="\n" - ) as file: + with open(os.path.join(data_path, f"n{dim}ifpif.dat"), "w", newline="\n") as file: for value1, value2 in zip(_array1, _array2): file.write(f"{value1:12d}{value2:12d}\n") def write_xixf(array1, array2, dim) -> None: _array1 = transpose_n_flatten(array1) _array2 = transpose_n_flatten(array2) - with open( - os.path.join(data_path, f"{dim}i{dim}f.dat"), "w", newline="\n" - ) as file: + with open(os.path.join(data_path, f"{dim}i{dim}f.dat"), "w", newline="\n") as file: for value1, value2 in zip(_array1, _array2): file.write(f"{value1:24.16E}{value2:24.16E}\n") def transpose_n_flatten(array): - if len(array.coords) == 3: + if len(array.coords) == 3: # noqa: PLR2004 return array.values.transpose(1, 0, 2).flatten() return array.values.T.flatten() - print("\nWriting...") data_path = os.path.join(prm.dataset.data_path, "geometry") prm.dataset.write(ds["epsi"]) - for dir in ["x", "y", "z"]: - write_nobj(ds[f"nobj_{dir}"], dir) - write_nxipif(ds[f"nxipif_{dir}"], ds[f"nxfpif_{dir}"], dir) - write_xixf(ds[f"xi_{dir}"], ds[f"xf_{dir}"], dir) + for direction in ["x", "y", "z"]: + write_nobj(ds[f"nobj_{direction}"], direction) + write_nxipif(ds[f"nxipif_{direction}"], ds[f"nxfpif_{direction}"], direction) + write_xixf(ds[f"xi_{direction}"], ds[f"xf_{direction}"], direction) diff --git a/xcompact3d_toolbox/gui.py b/xcompact3d_toolbox/gui.py index 359f10e..1158145 100644 --- a/xcompact3d_toolbox/gui.py +++ b/xcompact3d_toolbox/gui.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """ Manipulate the physical and computational parameters, just like :obj:`xcompact3d_toolbox.parameters.Parameters`, but with `ipywidgets`_. @@ -10,17 +9,17 @@ from __future__ import annotations import math -from typing import Type import ipywidgets as widgets import traitlets from IPython.display import display from traitlets import link -from .parameters import Parameters +from xcompact3d_toolbox.param import COORDS +from xcompact3d_toolbox.parameters import Parameters -def _divisorGenerator(n): +def _divisor_generator(n): """Yields the possibles divisors for ``n``. Especially useful to compute the possible values for :obj:`p_row` and :obj:`p_col` @@ -44,7 +43,8 @@ def _divisorGenerator(n): [0, 1, 2, 4, 8] """ - large_divisors = [0] + large_divisors = [] + yield 0 for i in range(1, int(math.sqrt(n) + 1)): if n % i == 0: yield i @@ -62,11 +62,10 @@ class ParametersGui(Parameters): """ - _possible_p_row, _possible_p_col = [ - traitlets.List(trait=traitlets.Int(), default_value=list(_divisorGenerator(4))) - for _ in range(2) - ] - """:obj:`list` of :obj:`int`: Auxiliar variable for parallel domain decomposition, + _possible_p_row, _possible_p_col = ( + traitlets.List(trait=traitlets.Int(), default_value=list(_divisor_generator(4))) for _ in range(2) + ) + """:obj:`list` of :obj:`int`: Auxiliary variable for parallel domain decomposition, it stores the available options according to :obj:`ncores`. """ @@ -79,33 +78,33 @@ def __init__(self, **kwargs): Keyword arguments for :obj:`xcompact3d_toolbox.parameters.Parameters`. """ - super(ParametersGui, self).__init__(**kwargs) + super().__init__(**kwargs) - self._widgets = dict( + self._widgets = { # # # BasicParam # - beta=widgets.BoundedFloatText(min=0.0, max=1e9), - dt=widgets.BoundedFloatText(min=1e-9, max=1e9), - ifirst=widgets.BoundedIntText(min=0, max=1e9), - iibm=widgets.Dropdown( + "beta": widgets.BoundedFloatText(min=0.0, max=1e9), + "dt": widgets.BoundedFloatText(min=1e-9, max=1e9), + "ifirst": widgets.BoundedIntText(min=0, max=1e9), + "iibm": widgets.Dropdown( options=[ ("Off", 0), ("Forced to zero", 1), ("Interpolated to zero", 2), ], ), - iin=widgets.Dropdown( + "iin": widgets.Dropdown( options=[ ("No random noise", 0), ("Random noise", 1), ("Random noise with fixed seed", 2), ], ), - ilast=widgets.BoundedIntText(min=0, max=1e9), - inflow_noise=widgets.FloatText(min=-1e9, max=1e9), - init_noise=widgets.FloatText(min=-1e9, max=1e9), - istret=widgets.Dropdown( + "ilast": widgets.BoundedIntText(min=0, max=1e9), + "inflow_noise": widgets.FloatText(min=-1e9, max=1e9), + "init_noise": widgets.FloatText(min=-1e9, max=1e9), + "istret": widgets.Dropdown( options=[ ("No refinement", 0), ("Refinement at the center", 1), @@ -113,7 +112,7 @@ def __init__(self, **kwargs): ("Just near the bottom", 3), ], ), - itype=widgets.Dropdown( + "itype": widgets.Dropdown( options=[ ("User", 0), ("Lock-exchange", 1), @@ -130,21 +129,21 @@ def __init__(self, **kwargs): ("Sandbox", 12), ], ), - nclxn=widgets.Dropdown( + "nclxn": widgets.Dropdown( options=[("Periodic", 0), ("Free-slip", 1), ("Outflow", 2)], ), - nclx1=widgets.Dropdown( + "nclx1": widgets.Dropdown( options=[("Periodic", 0), ("Free-slip", 1), ("Inflow", 2)], ), - numscalar=widgets.IntSlider(min=0, max=9, continuous_update=False), - p_col=widgets.Dropdown(options=self._possible_p_col), - p_row=widgets.Dropdown(options=self._possible_p_row), - re=widgets.FloatText(min=0.0, max=1e9), + "numscalar": widgets.IntSlider(min=0, max=9, continuous_update=False), + "p_col": widgets.Dropdown(options=self._possible_p_col), + "p_row": widgets.Dropdown(options=self._possible_p_row), + "re": widgets.FloatText(min=0.0, max=1e9), # # # NumOptions # - cnu=widgets.BoundedFloatText(min=0.0, max=1e6), # , disabled=True - ifirstder=widgets.Dropdown( + "cnu": widgets.BoundedFloatText(min=0.0, max=1e6), # , disabled=True + "ifirstder": widgets.Dropdown( options=[ ("2nd central", 1), ("4th central", 1), @@ -152,7 +151,7 @@ def __init__(self, **kwargs): ("6th compact", 4), ], ), - isecondder=widgets.Dropdown( + "isecondder": widgets.Dropdown( disabled=True, options=[ # '2nd central', 1), @@ -160,7 +159,7 @@ def __init__(self, **kwargs): ("hyperviscous 6th", 5), ], ), - itimescheme=widgets.Dropdown( + "itimescheme": widgets.Dropdown( options=[ ("Euler", 1), ("AB2", 2), @@ -169,12 +168,12 @@ def __init__(self, **kwargs): ("Semi-implicit", 7), ], ), - nu0nu=widgets.BoundedFloatText(min=0.0, max=1e6), # , disabled=True + "nu0nu": widgets.BoundedFloatText(min=0.0, max=1e6), # , disabled=True # # # InOutParam # - irestart=widgets.Dropdown(options=[("Off", 0), ("On", 1)]), - nvisu=widgets.BoundedIntText(min=1, max=1e9, disabled=True), + "irestart": widgets.Dropdown(options=[("Off", 0), ("On", 1)]), + "nvisu": widgets.BoundedIntText(min=1, max=1e9, disabled=True), # # # ScalarParam # @@ -189,7 +188,7 @@ def __init__(self, **kwargs): # # # LESModel # - jles=widgets.Dropdown( + "jles": widgets.Dropdown( options=[ ("DNS", 0), ("Phys Smag", 1), @@ -201,15 +200,15 @@ def __init__(self, **kwargs): # # # ibmstuff # - nobjmax=widgets.BoundedIntText(min=1, max=1e9), - nraf=widgets.IntSlider(min=1, max=25), + "nobjmax": widgets.BoundedIntText(min=1, max=1e9), + "nraf": widgets.IntSlider(min=1, max=25), # - # # Auxiliar for user interface, not included at the .i3d file + # # Auxiliary for user interface, not included at the .i3d file # - filename=widgets.Text(), - ncores=widgets.BoundedIntText(value=0, min=0, max=1e9), - size=widgets.Text(value="", disabled=True), - ) + "filename": widgets.Text(), + "ncores": widgets.BoundedIntText(value=0, min=0, max=1e9), + "size": widgets.Text(value="", disabled=True), + } for name in "gravx gravy gravz".split(): self._widgets[name] = widgets.FloatText(min=-1.0, max=1.0) @@ -240,18 +239,18 @@ def __init__(self, **kwargs): self._widgets[name] = widgets.BoundedFloatText(min=0.0, max=1e6) # Add a name to all widgets (same as dictionary key) - for name in self._widgets.keys(): + for name in self._widgets: self._widgets[name].description = name # Try to add a description - for name in self._widgets.keys(): + for name in self._widgets: # get description to include together with widgets description = self.trait_metadata(name, "desc") if description is not None: self._widgets[name].description_tooltip = description # Creating an arrange with all widgets - dim = "x y z".split() + dim = COORDS self.ipyview = widgets.VBox( [ @@ -259,33 +258,22 @@ def __init__(self, **kwargs): widgets.HBox( [ self._widgets["filename"], - widgets.Button( - description="Read", disabled=True, icon="file-upload" - ), - widgets.Button( - description="Write", disabled=True, icon="file-download" - ), + widgets.Button(description="Read", disabled=True, icon="file-upload"), + widgets.Button(description="Write", disabled=True, icon="file-download"), widgets.Button(description="Run", disabled=True, icon="rocket"), widgets.Button(description="Sync", disabled=True, icon="sync"), ] ), widgets.HTML(value="

BasicParam

"), widgets.HBox([self._widgets[d] for d in "itype re".split()]), - widgets.HBox( - [self._widgets[d] for d in "iin init_noise inflow_noise".split()] - ), + widgets.HBox([self._widgets[d] for d in "iin init_noise inflow_noise".split()]), widgets.HTML(value="

Domain Decomposition

"), widgets.HBox([self._widgets[d] for d in "ncores p_row p_col".split()]), widgets.HTML(value="

Temporal discretization

"), widgets.HBox([self._widgets[d] for d in "ifirst ilast dt".split()]), widgets.HTML(value="

InOutParam

"), widgets.HBox([self._widgets[d] for d in "irestart nvisu size".split()]), - widgets.HBox( - [ - self._widgets[d] - for d in "icheckpoint ioutput iprocessing".split() - ] - ), + widgets.HBox([self._widgets[d] for d in "icheckpoint ioutput iprocessing".split()]), widgets.HTML(value="

Spatial discretization

"), widgets.HBox([self._widgets[f"n{d}"] for d in dim]), widgets.HBox([self._widgets[f"{d}l{d}"] for d in dim]), @@ -294,12 +282,7 @@ def __init__(self, **kwargs): widgets.HBox([self._widgets[f"ncl{d}n"] for d in dim]), widgets.HBox([self._widgets[d] for d in "istret beta".split()]), widgets.HTML(value="

NumOptions

"), - widgets.HBox( - [ - self._widgets[d] - for d in "ifirstder isecondder itimescheme".split() - ] - ), + widgets.HBox([self._widgets[d] for d in "ifirstder isecondder itimescheme".split()]), widgets.HBox([self._widgets[d] for d in "ilesmod nu0nu cnu".split()]), widgets.HTML(value="

ScalarParam

"), widgets.HBox([self._widgets["numscalar"]]), @@ -308,7 +291,10 @@ def __init__(self, **kwargs): widgets.HBox([self._widgets[f"grav{d}"] for d in dim]), # widgets.HBox([self._widgets[d] for d in "iibmS".split()]), widgets.HTML( - value="cp, us, sc, ri, scalar_lbound & scalar_ubound are lists with length numscalar, set them properly on the code." + value=( + "cp, us, sc, ri, scalar_lbound & scalar_ubound are lists " + "with length numscalar, set them properly on the code." + ), ), widgets.HTML(value="

IBMStuff

"), widgets.HBox([self._widgets[d] for d in "iibm nraf nobjmax".split()]), @@ -317,7 +303,7 @@ def __init__(self, **kwargs): self.link_widgets() - def __call__(self, *args: str) -> Type(widgets.VBox): + def __call__(self, *args: str) -> widgets.VBox: """Returns widgets on demand. Parameters @@ -333,7 +319,7 @@ def __call__(self, *args: str) -> Type(widgets.VBox): Examples ------- >>> prm = xcompact3d_toolbox.ParametersGui() - >>> prm('nx', 'xlx', 'dx', 'nclx1', 'nclxn') + >>> prm("nx", "xlx", "dx", "nclx1", "nclxn") """ return widgets.VBox([self._widgets[name] for name in args]) @@ -342,22 +328,23 @@ def _ipython_display_(self): display(self.ipyview) @traitlets.observe("p_row", "p_col", "ncores") - def _observe_2Decomp(self, change): - if change["name"] == "ncores": - possible = list(_divisorGenerator(change["new"])) - self._possible_p_row = possible - self._possible_p_col = possible - self.p_row, self.p_col = 0, 0 - elif change["name"] == "p_row": - try: - self.p_col = self.ncores // self.p_row - except: - self.p_col = 0 - elif change["name"] == "p_col": - try: - self.p_row = self.ncores // self.p_col - except: - self.p_row = 0 + def _observe_2decomp(self, change): + with self.hold_trait_notifications(): + if change["name"] == "ncores": + possible = list(_divisor_generator(change["new"])) + self.p_row, self.p_col = 0, 0 + self._possible_p_row = possible + self._possible_p_col = possible + elif change["name"] == "p_row": + try: + self.p_col = self.ncores // self.p_row + except ZeroDivisionError: + self.p_col = 0 + elif change["name"] == "p_col": + try: + self.p_row = self.ncores // self.p_col + except ZeroDivisionError: + self.p_row = 0 def link_widgets(self) -> None: """Creates a two-way link between the value of an attribute and its widget. @@ -366,7 +353,7 @@ def link_widgets(self) -> None: Examples ------- - >>> prm = xcompact3d_toolbox.ParametersGui(loadfile = 'example.i3d') + >>> prm = xcompact3d_toolbox.ParametersGui(loadfile="example.i3d") >>> prm.link_widgets() """ @@ -385,7 +372,7 @@ def link_widgets(self) -> None: ) # Create two-way link between variables and widgets - for name in self._widgets.keys(): + for name in self._widgets: link((self, name), (self._widgets[name], "value")) # for name in self._widgets.keys(): diff --git a/xcompact3d_toolbox/io.py b/xcompact3d_toolbox/io.py index da4d108..cc4706b 100644 --- a/xcompact3d_toolbox/io.py +++ b/xcompact3d_toolbox/io.py @@ -1,7 +1,4 @@ -# -*- coding: utf-8 -*- -""" -Usefull objects to read and write the binary fields produced by XCompact3d. -""" +"""Useful objects to read and write the binary fields produced by XCompact3d.""" from __future__ import annotations @@ -10,7 +7,7 @@ import os import os.path import warnings -from typing import Type, Union +from typing import Iterator import numpy as np import pandas as pd @@ -18,8 +15,8 @@ import xarray as xr from tqdm.auto import tqdm -from .mesh import Mesh3D -from .param import param +from xcompact3d_toolbox.mesh import Istret, Mesh3D +from xcompact3d_toolbox.param import param class FilenameProperties(traitlets.HasTraits): @@ -42,7 +39,7 @@ class FilenameProperties(traitlets.HasTraits): Notes ----- - :obj:`FilenameProperties` is in fact an atribute of + :obj:`FilenameProperties` is in fact an attribute of :obj:`xcompact3d_toolbox.io.Dataset`, so there is no need to initialize it manually for most of the common use cases. @@ -80,7 +77,7 @@ def __repr__(self): for name in self.trait_names(): if name.startswith("_"): continue - string += f" {name} = {repr(getattr(self, name))},\n" + string += f" {name} = {getattr(self, name)!r},\n" string += ")" return string @@ -106,23 +103,20 @@ def set(self, **kwargs) -> None: >>> prm = xcompact3d_toolbox.Parameters() >>> prm.dataset.filename_properties.set( - ... separator = "-", - ... file_extension = ".bin", - ... number_of_digits = 3 + ... separator="-", file_extension=".bin", number_of_digits=3 ... ) If the simulated fields are named like ``ux0000``, the parameters are: >>> prm = xcompact3d_toolbox.Parameters() >>> prm.dataset.filename_properties.set( - ... separator = "", - ... file_extension = "", - ... number_of_digits = 4 + ... separator="", file_extension="", number_of_digits=4 ... ) """ for key, arg in kwargs.items(): if key not in self.trait_names(): - raise KeyError(f"{key} is not a valid argument for FilenameProperties") + msg = f"{key} is not a valid argument for FilenameProperties" + raise KeyError(msg) setattr(self, key, arg) def get_filename_for_binary(self, prefix: str, counter: int, data_path="") -> str: @@ -148,9 +142,7 @@ def get_filename_for_binary(self, prefix: str, counter: int, data_path="") -> st >>> prm = xcompact3d_toolbox.Parameters() >>> prm.dataset.filename_properties.set( - ... separator = "-", - ... file_extension = ".bin", - ... number_of_digits = 3 + ... separator="-", file_extension=".bin", number_of_digits=3 ... ) >>> prm.dataset.filename_properties.get_filename_for_binary("ux", 10) 'ux-010.bin' @@ -158,9 +150,7 @@ def get_filename_for_binary(self, prefix: str, counter: int, data_path="") -> st 'ux-???.bin' >>> prm.dataset.filename_properties.set( - ... separator = "", - ... file_extension = "", - ... number_of_digits = 4 + ... separator="", file_extension="", number_of_digits=4 ... ) >>> prm.dataset.filename_properties.get_filename_for_binary("ux", 10) 'ux0010' @@ -192,17 +182,13 @@ def get_info_from_filename(self, filename: str) -> tuple[int, str]: >>> prm = xcompact3d_toolbox.Parameters() >>> prm.dataset.filename_properties.set( - ... separator = "-", - ... file_extension = ".bin", - ... number_of_digits = 3 + ... separator="-", file_extension=".bin", number_of_digits=3 ... ) - >>> prm.dataset.filename_properties.get_info_from_filename('ux-010.bin') + >>> prm.dataset.filename_properties.get_info_from_filename("ux-010.bin") (10, 'ux') >>> prm.dataset.filename_properties.set( - ... separator = "", - ... file_extension = "", - ... number_of_digits = 4 + ... separator="", file_extension="", number_of_digits=4 ... ) >>> prm.dataset.filename_properties.get_info_from_filename("ux0010") (10, 'ux') @@ -236,8 +222,11 @@ class Dataset(traitlets.HasTraits): ---------- data_path : str The path to the folder where the binary fields are located (default is ``"./data/"``). - .. note :: the default ``"./data/"`` is relative to the path to the parameters - file when initialized from :obj:`xcompact3d_toolbox.parameters.ParametersExtras`. + + .. note:: + The default ``"./data/"`` is relative to the path to the parameters + file when initialized from :obj:`xcompact3d_toolbox.parameters.ParametersExtras`. + drop_coords : str If working with two-dimensional planes, specify which of the coordinates should be dropped, i.e., ``"x"``, ``"y"`` or ``"z"``, or leave it empty for 3D fields (default is ``""``). @@ -265,23 +254,22 @@ class Dataset(traitlets.HasTraits): Notes ----- - * :obj:`Dataset` is in fact an atribute of :obj:`xcompact3d_toolbox.parameters.ParametersExtras`, - so there is no need to initialize it manually for most of the common use cases. - - * All arrays are wrapped into Xarray objects (:obj:`xarray.DataArray` - or :obj:`xarray.Dataset`), take a look at `xarray's documentation`_, - specially, see `Why xarray?`_ - Xarray has many useful methods for indexing, comparisons, reshaping - and reorganizing, computations and plotting. - - * Consider using hvPlot_ to explore your data interactively, - see how to plot `Gridded Data`_. - - .. _`xarray's documentation`: http://xarray.pydata.org/en/stable/ - .. _`Why xarray?`: http://xarray.pydata.org/en/stable/why-xarray.html - .. _hvPlot : https://hvplot.holoviz.org/ - .. _`Gridded Data` : https://hvplot.holoviz.org/user_guide/Gridded_Data.html - + * :obj:`Dataset` is in fact an attribute of :obj:`xcompact3d_toolbox.parameters.ParametersExtras`, + so there is no need to initialize it manually for most of the common use cases. + + * All arrays are wrapped into Xarray objects (:obj:`xarray.DataArray` + or :obj:`xarray.Dataset`), take a look at `xarray's documentation`_, + specially, see `Why xarray?`_ + Xarray has many useful methods for indexing, comparisons, reshaping + and reorganizing, computations and plotting. + + * Consider using hvPlot_ to explore your data interactively, + see how to plot `Gridded Data`_. + + .. _`xarray's documentation`: http://docs.xarray.dev/en/stable + .. _`Why xarray?`: http://docs.xarray.dev/en/stable/why-xarray.html + .. _hvPlot : https://hvplot.holoviz.org/ + .. _`Gridded Data` : https://hvplot.holoviz.org/user_guide/Gridded_Data.html """ data_path = traitlets.Unicode(default_value="./data/") @@ -294,9 +282,7 @@ class Dataset(traitlets.HasTraits): stack_velocity = traitlets.Bool(default_value=False) _mesh = traitlets.Instance(klass=Mesh3D) - _prm = traitlets.Instance( - klass="xcompact3d_toolbox.parameters.Parameters", allow_none=True - ) + _prm = traitlets.Instance(klass="xcompact3d_toolbox.parameters.Parameters", allow_none=True) def __init__(self, **kwargs): """Initializes the Dataset class. @@ -328,7 +314,7 @@ def __init__(self, **kwargs): self.set(**kwargs) - def __call__(self, *args) -> Type[xr.Dataset]: + def __call__(self, *args) -> Iterator[xr.Dataset]: """Yields selected snapshots, so the application can iterate over them, loading one by one, with the same arguments of a classic Python :obj:`range`. @@ -351,9 +337,7 @@ def __call__(self, *args) -> Type[xr.Dataset]: >>> prm = xcompact3d_toolbox.Parameters(loadfile="input.i3d") >>> prm.dataset.set( ... filename_properties=dict( - ... separator="-", - ... file_extension=".bin", - ... number_of_digits=3 + ... separator="-", file_extension=".bin", number_of_digits=3 ... ), ... stack_scalar=True, ... stack_velocity=True, @@ -365,14 +349,12 @@ def __call__(self, *args) -> Type[xr.Dataset]: >>> for ds in prm.dataset(0, 101, 5): ... vort = ds.uy.x3d.first_derivative("x") - ds.ux.x3d.first_derivative("y") - ... prm.dataset.write(data = vort, file_prefix = "w3") + ... prm.dataset.write(data=vort, file_prefix="w3") """ for t in range(*args): yield self.load_snapshot(t) - def __getitem__( - self, arg: Union[int, slice, str] - ) -> Union[Type[xr.DataArray], Type[xr.Dataset]]: + def __getitem__(self, arg: int | slice | str) -> xr.DataArray | xr.Dataset: """Get specified items from the disc. .. note:: Make sure to have enough memory to load many files at the same time. @@ -398,7 +380,7 @@ def __getitem__( Raises ------ TypeError - Raises type error if arg is not an interger, string or slice + Raises type error if arg is not an integer, string or slice Examples -------- @@ -408,9 +390,7 @@ def __getitem__( >>> prm = xcompact3d_toolbox.Parameters(loadfile="input.i3d") >>> prm.dataset.set( ... filename_properties=dict( - ... separator="-", - ... file_extension=".bin", - ... number_of_digits=3 + ... separator="-", file_extension=".bin", number_of_digits=3 ... ), ... drop_coords="z", ... stack_scalar=True, @@ -445,14 +425,13 @@ def __getitem__( """ if isinstance(arg, int): return self.load_snapshot(arg) - elif isinstance(arg, slice): + if isinstance(arg, slice): start, stop, step = arg.indices(len(self)) - return xr.concat( - (self.load_snapshot(t) for t in range(start, stop, step)), "t" - ) - elif isinstance(arg, str): + return xr.concat((self.load_snapshot(t) for t in range(start, stop, step)), "t") + if isinstance(arg, str): return self.load_time_series(arg) - raise TypeError("Dataset indices should be integers, string or slices") + msg = "Dataset indices should be integers, string or slices" + raise TypeError(msg) def __len__(self) -> int: """Make the dataset work with the Python function :obj:`len`. @@ -465,11 +444,7 @@ def __len__(self) -> int: # Test environment if self._prm is None: return 11 - return ( - getattr(self._prm, self.snapshot_counting) - // getattr(self._prm, self.snapshot_step) - + 1 - ) + return getattr(self._prm, self.snapshot_counting) // getattr(self._prm, self.snapshot_step) + 1 def __iter__(self): """Yields all the snapshots, so the application can iterate over them. @@ -488,9 +463,7 @@ def __iter__(self): >>> prm = xcompact3d_toolbox.Parameters(loadfile="input.i3d") >>> prm.dataset.set( ... filename_properties=dict( - ... separator="-", - ... file_extension=".bin", - ... number_of_digits=3 + ... separator="-", file_extension=".bin", number_of_digits=3 ... ), ... stack_scalar=True, ... stack_velocity=True, @@ -500,7 +473,7 @@ def __iter__(self): >>> for ds in prm.dataset: ... vort = ds.uy.x3d.first_derivative("x") - ds.ux.x3d.first_derivative("y") - ... prm.dataset.write(data = vort, file_prefix = "w3") + ... prm.dataset.write(data=vort, file_prefix="w3") """ for t in range(len(self)): yield self.load_snapshot(t) @@ -510,7 +483,7 @@ def __repr__(self): for name in self.trait_names(): if name.startswith("_"): continue - string += f" {name} = {repr(getattr(self, name))},\n" + string += f" {name} = {getattr(self, name)!r},\n" string += ")" return string @@ -544,9 +517,7 @@ def set(self, **kwargs): >>> prm = xcompact3d_toolbox.Parameters(loadfile="input.i3d") >>> prm.dataset.set( ... filename_properties=dict( - ... separator="-", - ... file_extension=".bin", - ... number_of_digits=3 + ... separator="-", file_extension=".bin", number_of_digits=3 ... ), ... stack_scalar=True, ... stack_velocity=True, @@ -558,12 +529,11 @@ def set(self, **kwargs): for key, arg in kwargs.items(): if key not in self.trait_names(): - raise KeyError(f"{key} is not a valid argument for Dataset") + msg = f"{key} is not a valid argument for Dataset" + raise KeyError(msg) setattr(self, key, arg) - def load_array( - self, filename: str, add_time: bool = True, attrs: dict = None - ) -> Type[xr.DataArray]: + def load_array(self, filename: str, attrs: dict | None = None, *, add_time: bool = True) -> type[xr.DataArray]: """This method reads a binary field from XCompact3d with :obj:`numpy.fromfile` and wraps it into a :obj:`xarray.DataArray` with the appropriate dimensions, coordinates and attributes. @@ -590,9 +560,7 @@ def load_array( >>> prm = xcompact3d_toolbox.Parameters(loadfile="input.i3d") >>> prm.dataset.set( ... filename_properties=dict( - ... separator="-", - ... file_extension=".bin", - ... number_of_digits=3 + ... separator="-", file_extension=".bin", number_of_digits=3 ... ), ... stack_scalar=True, ... stack_velocity=True, @@ -631,11 +599,12 @@ def load_array( def load_snapshot( self, numerical_identifier: int, - list_of_variables: list = None, + list_of_variables: list | None = None, + stack_scalar: bool | None = None, + stack_velocity: bool | None = None, + *, add_time: bool = True, - stack_scalar: bool = None, - stack_velocity: bool = None, - ) -> Type[xr.Dataset]: + ) -> type[xr.Dataset]: """Load the variables for a given snapshot. Parameters @@ -649,11 +618,11 @@ def load_snapshot( add_time : bool, optional Add time as a coordinate, by default True. stack_scalar : bool, optional - When true, the scalar fields will be stacked in a new coordinate ``n``, otherwise returns one array per scalar fraction. - If none, it uses :obj:`Dataset.stack_scalar`, by default None. + When true, the scalar fields will be stacked in a new coordinate ``n``, otherwise returns one array per + scalar fraction. If none, it uses :obj:`Dataset.stack_scalar`, by default None. stack_velocity : bool, optional - When true, the velocity will be stacked in a new coordinate ``i``, otherwise returns one array per velocity component. - If none, it uses :obj:`Dataset.stack_velocity`, by default None. + When true, the velocity will be stacked in a new coordinate ``i``, otherwise returns one array per velocity + component. If none, it uses :obj:`Dataset.stack_velocity`, by default None. Returns ------- @@ -674,9 +643,7 @@ def load_snapshot( >>> prm = xcompact3d_toolbox.Parameters(loadfile="input.i3d") >>> prm.dataset.set( ... filename_properties=dict( - ... separator="-", - ... file_extension=".bin", - ... number_of_digits=3 + ... separator="-", file_extension=".bin", number_of_digits=3 ... ), ... stack_scalar=True, ... stack_velocity=True, @@ -698,20 +665,14 @@ def load_snapshot( elif self.set_of_variables: set_of_variables = self.set_of_variables.copy() else: - target_filename = self.filename_properties.get_filename_for_binary( - "*", numerical_identifier - ) + target_filename = self.filename_properties.get_filename_for_binary("*", numerical_identifier) list_of_variables = glob.glob(os.path.join(self.data_path, target_filename)) - list_of_variables = map( - self.filename_properties.get_name_from_filename, list_of_variables - ) - set_of_variables = set(list_of_variables) + set_of_variables = {self.filename_properties.get_name_from_filename(i) for i in list_of_variables} if not set_of_variables: - raise IOError( - f"No file found corresponding to {self.data_path}/{target_filename}" - ) + msg = f"No file found corresponding to {self.data_path}/{target_filename}" + raise OSError(msg) if stack_scalar is None: stack_scalar = self.stack_scalar @@ -727,11 +688,12 @@ def stack_variables(variables, **kwargs): ) def is_scalar(name): - if len(name) != (3 + self.filename_properties.scalar_num_of_digits): + prefix = "phi" + if len(name) != (len(prefix) + self.filename_properties.scalar_num_of_digits): return False - if not name.startswith("phi"): + if not name.startswith(prefix): return False - if not name.removeprefix("phi").isdigit(): + if not name[len(prefix) :].isdigit(): return False return True @@ -740,11 +702,9 @@ def is_velocity(name): if stack_scalar: scalar_variables = sorted( - list( - filter( - is_scalar, - set_of_variables, - ) + filter( + is_scalar, + set_of_variables, ) ) @@ -757,7 +717,7 @@ def is_velocity(name): set_of_variables -= set(scalar_variables) if stack_velocity: - velocity_variables = sorted(list(filter(is_velocity, set_of_variables))) + velocity_variables = sorted(filter(is_velocity, set_of_variables)) if velocity_variables: dataset["u"] = ( stack_variables(velocity_variables, stack_velocity=False) @@ -766,16 +726,14 @@ def is_velocity(name): ) set_of_variables -= set(velocity_variables) - for var in sorted(list(set_of_variables)): - filename = self.filename_properties.get_filename_for_binary( - var, numerical_identifier - ) + for var in sorted(set_of_variables): + filename = self.filename_properties.get_filename_for_binary(var, numerical_identifier) filename = os.path.join(self.data_path, filename) dataset[var] = self.load_array(filename=filename, add_time=add_time) return dataset - def load_time_series(self, array_prefix: str) -> Type[xr.DataArray]: + def load_time_series(self, array_prefix: str) -> type[xr.DataArray]: """Load the entire time series for a given variable. .. note:: Make sure to have enough memory to load all files at the same time. @@ -804,9 +762,7 @@ def load_time_series(self, array_prefix: str) -> Type[xr.DataArray]: >>> prm = xcompact3d_toolbox.Parameters(loadfile="input.i3d") >>> prm.dataset.set( ... filename_properties=dict( - ... separator="-", - ... file_extension=".bin", - ... number_of_digits=3 + ... separator="-", file_extension=".bin", number_of_digits=3 ... ), ... stack_scalar=True, ... stack_velocity=True, @@ -831,24 +787,20 @@ def load_time_series(self, array_prefix: str) -> Type[xr.DataArray]: ... dataset[var] = prm.dataset[var] """ - target_filename = self.filename_properties.get_filename_for_binary( - array_prefix, "*" - ) + target_filename = self.filename_properties.get_filename_for_binary(array_prefix, "*") filename_pattern = os.path.join(self.data_path, target_filename) filename_list = sorted(glob.glob(filename_pattern)) if not filename_list: - raise IOError(f"No file was found corresponding to {filename_pattern}.") + msg = f"No file was found corresponding to {filename_pattern}." + raise OSError(msg) return xr.concat( - ( - self.load_array(file, add_time=True) - for file in tqdm(filename_list, desc=filename_pattern) - ), + (self.load_array(file, add_time=True) for file in tqdm(filename_list, desc=filename_pattern)), dim="t", ) - def load_wind_turbine_data(self, file_pattern: str = None) -> Type[xr.Dataset]: + def load_wind_turbine_data(self, file_pattern: str | None = None) -> type[xr.Dataset]: """Load the data produced by wind turbine simulations. .. note:: This feature is experimental @@ -894,19 +846,18 @@ def load_wind_turbine_data(self, file_pattern: str = None) -> Type[xr.Dataset]: """ def get_dataset(filename): - time = os.path.basename(filename).split("_")[0] time = float(time) * self._prm.iturboutput * self._prm.dt - ds = xr.Dataset(coords=dict(t=[time])) - ds.t.attrs = dict(name="t", long_name="Time", units="s") + ds = xr.Dataset(coords={"t": [time]}) + ds.t.attrs = {"name": "t", "long_name": "Time", "units": "s"} for name, values in pd.read_csv(filename).to_dict().items(): ds[name.strip()] = xr.DataArray( data=np.float64(values[1]), coords=ds.t.coords, - attrs=dict(units=values[0].strip()[1:-1]), + attrs={"units": values[0].strip()[1:-1]}, ) return ds @@ -918,7 +869,7 @@ def get_dataset(filename): return xr.concat((get_dataset(file) for file in filenames), dim="t").sortby("t") - def write(self, data: Union[xr.DataArray, xr.Dataset], file_prefix: str = None): + def write(self, data: xr.DataArray | xr.Dataset, file_prefix: str | None = None): """Write an array or dataset to raw binary files on the disc, in the same order that Xcompact3d would do, so they can be easily read with 2DECOMP. @@ -957,39 +908,39 @@ def write(self, data: Union[xr.DataArray, xr.Dataset], file_prefix: str = None): >>> prm = xcompact3d_toolbox.Parameters(loadfile="input.i3d") >>> prm.dataset.set( ... filename_properties=dict( - ... separator="-", - ... file_extension=".bin", - ... number_of_digits=3 + ... separator="-", file_extension=".bin", number_of_digits=3 ... ), ... stack_scalar=True, ... stack_velocity=True, ... ) - * From a dataset, write only the variables with the atribute ``file_name``, - notice that ``ux`` and ``uy`` will not be overwritten because them do not - have the atribute ``file_name``: + * From a dataset, write only the variables with the attribute ``file_name``, + notice that ``ux`` and ``uy`` will not be overwritten because them do not + have the attribute ``file_name``: - >>> for ds in prm.dataset: - ... ds["vort"] = ds.uy.x3d.first_derivative("x") - ds.ux.x3d. first_derivative("y") - ... ds["vort"].attrs["file_name"] = "vorticity" - ... prm.dataset.write(ds) + >>> for ds in prm.dataset: + ... ds["vort"] = ds.uy.x3d.first_derivative("x") - ds.ux.x3d.first_derivative( + ... "y" + ... ) + ... ds["vort"].attrs["file_name"] = "vorticity" + ... prm.dataset.write(ds) * Write an array: - >>> for ds in prm.dataset: - ... vort = ds.uy.x3d.first_derivative("x") - ds.ux.x3d.first_derivative("y") - ... vort.attrs["file_name"] = "vorticity" - ... prm.dataset.write(vort) + >>> for ds in prm.dataset: + ... vort = ds.uy.x3d.first_derivative("x") - ds.ux.x3d.first_derivative("y") + ... vort.attrs["file_name"] = "vorticity" + ... prm.dataset.write(vort) - or + or - >>> for ds in prm.dataset: - ... vort = ds.uy.x3d.first_derivative("x") - ds.ux.x3d.first_derivative("y") - ... prm.dataset.write(data = vort, file_prefix = "vorticity") + >>> for ds in prm.dataset: + ... vort = ds.uy.x3d.first_derivative("x") - ds.ux.x3d.first_derivative("y") + ... prm.dataset.write(data=vort, file_prefix="vorticity") - .. note :: It is not recomended to load the arrays with - ``add_time = False`` when planning to write the results in a - time series (e.g., `vort-000.bin`, `vort-001.bin`, `vort-002.bin`, ...) + .. note :: It is not recommended to load the arrays with + ``add_time = False`` when planning to write the results in a + time series (e.g., `vort-000.bin`, `vort-001.bin`, `vort-002.bin`, ...) """ @@ -1000,49 +951,46 @@ def write(self, data: Union[xr.DataArray, xr.Dataset], file_prefix: str = None): os.makedirs(self.data_path, exist_ok=True) self._write_array(data, file_prefix) else: - raise IOError( - f"Invalid type for data, try with: xarray.Dataset or xarray.DataArray" - ) + msg = "Invalid type for data, try with: xarray.Dataset or xarray.DataArray" + raise OSError(msg) def _write_dataset(self, dataset) -> None: - for array_name, array in dataset.items(): if "file_name" in array.attrs: self._write_array(array) else: - warnings.warn(f"Can't write array {array_name}, no filename provided") + warnings.warn(f"Can't write array {array_name}, no filename provided", stacklevel=1) - def _write_array(self, dataArray, filename: str = None) -> None: - if filename is None: # Try to get from atributes - filename = dataArray.attrs.get("file_name", None) + def _write_array(self, data_array, filename: str | None = None) -> None: + if filename is None: # Try to get from attributes + filename = data_array.attrs.get("file_name", None) if filename is None: - raise IOError(f"Can't write field without a filename") + msg = "Can't write field without a filename" + raise OSError(msg) # If n is a dimension (for scalar), call write recursively to save # phi1, phi2, phi3, for instance. - if "n" in dataArray.dims: - for n, n_val in enumerate(dataArray.n.data): + if "n" in data_array.dims: + for n, n_val in enumerate(data_array.n.data): self._write_array( - dataArray.isel(n=n, drop=True), + data_array.isel(n=n, drop=True), filename=f"{filename}{str(n_val).zfill(self.filename_properties.scalar_num_of_digits)}", ) # If i is a dimension, call write recursively to save # ux, uy and uz, for instance - elif "i" in dataArray.dims: - for i, i_val in enumerate(dataArray.i.data): - self._write_array( - dataArray.isel(i=i, drop=True), filename=f"{filename}{i_val}" - ) + elif "i" in data_array.dims: + for i, i_val in enumerate(data_array.i.data): + self._write_array(data_array.isel(i=i, drop=True), filename=f"{filename}{i_val}") # If t is a dimension (for time), call write recursively to save # ux-0000.bin, ux-0001.bin, ux-0002.bin, for instance. - elif "t" in dataArray.dims: + elif "t" in data_array.dims: dt = self._time_step - if dataArray.t.size == 1: - loop_itr = enumerate(dataArray.t.data) + if data_array.t.size == 1: + loop_itr = enumerate(data_array.t.data) else: - loop_itr = enumerate(tqdm(dataArray.t.data, desc=filename)) + loop_itr = enumerate(tqdm(data_array.t.data, desc=filename)) for k, time in loop_itr: self._write_array( - dataArray.isel(t=k, drop=True), + data_array.isel(t=k, drop=True), self.filename_properties.get_filename_for_binary( prefix=filename, counter=int(time / dt), @@ -1050,18 +998,14 @@ def _write_array(self, dataArray, filename: str = None) -> None: ) # and finally writes to the disc else: - fileformat = self.filename_properties.file_extension + fileformat: str = self.filename_properties.file_extension if fileformat and not filename.endswith(fileformat): filename += fileformat - align = [ - dataArray.get_axis_num(i) for i in sorted(dataArray.dims, reverse=True) - ] + align = [data_array.get_axis_num(i) for i in sorted(data_array.dims, reverse=True)] filename_and_path = os.path.join(self.data_path, filename) - dataArray.values.astype(param["mytype"]).transpose(align).tofile( - filename_and_path - ) + data_array.values.astype(param["mytype"]).transpose(align).tofile(filename_and_path) - def write_xdmf(self, xdmf_name: str = "snapshots.xdmf") -> None: + def write_xdmf(self, xdmf_name: str = "snapshots.xdmf", *, float_precision: int | None = None) -> None: """Write the xdmf file, so the results from the simulation and its postprocessing can be opened in an external visualization tool, like Paraview. @@ -1073,6 +1017,9 @@ def write_xdmf(self, xdmf_name: str = "snapshots.xdmf") -> None: ---------- xdmf_name : str, optional Filename for the xdmf file, by default "snapshots.xdmf" + float_precision : int, optional + Number of digits for the float precision on the output file, by default None. + If None, it uses 8 for single precision and 16 for double precision arrays. Raises ------ @@ -1087,9 +1034,7 @@ def write_xdmf(self, xdmf_name: str = "snapshots.xdmf") -> None: >>> prm = xcompact3d_toolbox.Parameters(loadfile="input.i3d") >>> prm.dataset.set( ... filename_properties=dict( - ... separator="-", - ... file_extension=".bin", - ... number_of_digits=3 + ... separator="-", file_extension=".bin", number_of_digits=3 ... ), ... stack_scalar=True, ... stack_velocity=True, @@ -1101,8 +1046,8 @@ def write_xdmf(self, xdmf_name: str = "snapshots.xdmf") -> None: >>> prm.dataset.write_xdmf() """ if self.set_of_variables: - time_numbers = range(len(self)) - var_names = sorted(list(self.set_of_variables)) + time_numbers = list(range(len(self))) + var_names = sorted(self.set_of_variables) else: filename_pattern = self.filename_properties.get_filename_for_binary( prefix="*", counter="*", data_path=self.data_path @@ -1110,17 +1055,13 @@ def write_xdmf(self, xdmf_name: str = "snapshots.xdmf") -> None: filename_list = glob.glob(filename_pattern) if not filename_list: - raise IOError(f"No file was found corresponding to {filename_pattern}.") + msg = f"No file was found corresponding to {filename_pattern}." + raise OSError(msg) - properties = zip( - *map( - self.filename_properties.get_info_from_filename, - filename_list, - ) - ) - time_numbers, var_names = properties - time_numbers = sorted(list(set(time_numbers))) - var_names = sorted(list(set(var_names))) + properties = [self.filename_properties.get_info_from_filename(f) for f in filename_list] + + time_numbers = sorted({r[0] for r in properties}) + var_names = sorted({r[1] for r in properties}) nx = self._mesh.x.grid_size ny = self._mesh.y.grid_size @@ -1140,20 +1081,20 @@ def write_xdmf(self, xdmf_name: str = "snapshots.xdmf") -> None: nz, dz = 1, 0.0 prec = 8 if param["mytype"] == np.float64 else 4 + if float_precision is None: + float_precision = 2 * prec + + float_format = f".{float_precision}e" def get_filename(var_name, num): - return self.filename_properties.get_filename_for_binary( - var_name, num, self.data_path - ) + return self.filename_properties.get_filename_for_binary(var_name, num, self.data_path) with open(xdmf_name, "w") as f: f.write('\n') f.write(' \n') - f.write( - ' \n' - ) + f.write(' \n') f.write(" \n") - if self._mesh.y.istret == 0: + if self._mesh.y.istret == Istret.NO_REFINEMENT: f.write(' \n') f.write(" \n") @@ -1164,7 +1105,8 @@ def get_filename(var_name, num): f.write(" \n") f.write(" \n") f.write(' \n') - f.write(f" {dz} {dy} {dx}\n") + array = " ".join(format(i, float_format) for i in (dz, dy, dx)) + f.write(f" {array}\n") f.write(" \n") f.write(" \n") else: @@ -1172,56 +1114,37 @@ def get_filename(var_name, num): f.write(f' Dimensions="{nz} {ny} {nx}">\n') f.write(" \n") f.write(' \n') - f.write( - f' \n' - ) - f.write( - f' {" ".join(map(str, self._mesh.x.vector)) if nx > 1 else 0.0}\n' - ) + f.write(f' \n') + array = " ".join(format(i, float_format) for i in self._mesh.x.vector) if nx > 1 else "0.0" + f.write(f" {array}\n") f.write(" \n") - f.write( - f' \n' - ) - f.write( - f' {" ".join(map(str, self._mesh.y.vector)) if ny > 1 else 0.0}' - ) + f.write(f' \n') + array = " ".join(format(j, float_format) for j in self._mesh.y.vector) if ny > 1 else "0.0" + f.write(f" {array}\n") f.write(" \n") - f.write( - f' \n' - ) - f.write( - f' {" ".join(map(str, self._mesh.z.vector)) if nz > 1 else 0.0}' - ) + f.write(f' \n') + array = " ".join(format(k, float_format) for k in self._mesh.z.vector) if nz > 1 else "0.0" + f.write(f" {array}\n") f.write(" \n") f.write(" \n") f.write("\n") - f.write( - ' \n' - ) + f.write(' \n') f.write(' \n") for suffix in tqdm(time_numbers, desc=xdmf_name): f.write("\n") f.write("\n") f.write(f' \n') - f.write( - ' \n' - ) - f.write( - ' \n' - ) + f.write(' \n') + f.write(' \n') for prefix in var_names: f.write(f' \n') f.write(' \n') f.write(f" {get_filename(prefix, suffix)}\n") f.write(" \n") @@ -1230,74 +1153,68 @@ def get_filename(var_name, num): f.write("\n") f.write(" \n") f.write(" \n") - f.write("") + f.write("\n") def prm_to_dict(filename="incompact3d.prm"): - - f = open(filename) - dict_outer = {} - for line in f: - # Remove spaces - line = " ".join(line.split()) + with open(filename) as f: + for raw_line in f: + # Remove spaces + line = " ".join(raw_line.split()) - if line == "": # Cycle if line is empty - continue - if line[0] == "#": # Cycle if starts with a comment - continue - - line = line.split("#") - # Get variable's name and value - param = line[1].strip() - value = line[0].strip() - - try: - # Converting from string according to datatype - if value[0] == "'" and value[-1] == "'": # String - value = value[1:-1] - elif value.lower() == ".false.": # Bool - value = False - elif value.lower() == ".true.": # Bool - value = True - elif "." in value: # Float - value = float(value) - else: # Int - value = int(value) - except: - warnings.warn(f"Can't convert {param} : {value}") - continue + if line == "": # Cycle if line is empty + continue + if line[0] == "#": # Cycle if starts with a comment + continue - if "(" in param and ")" == param[-1]: # Param is a list - param = param.split("(")[0] - if param not in dict_outer: - dict_outer[param] = [] - dict_outer[param].append(value) - else: # Not a list - dict_outer[param] = value + line = line.split("#") + # Get variable's name and value + parameter = line[1].strip() + value = line[0].strip() + + try: + # Converting from string according to datatype + if value[0] == "'" and value[-1] == "'": # String + value = value[1:-1] + elif value.lower() == ".false.": # Bool + value = False + elif value.lower() == ".true.": # Bool + value = True + elif "." in value: # Float + value = float(value) + else: # Int + value = int(value) + except TypeError: + warnings.warn(f"Can't convert {parameter} : {value}", stacklevel=1) + continue - f.close() + if "(" in parameter and parameter[-1] == ")": # Param is a list + parameter = parameter.split("(")[0] + if parameter not in dict_outer: + dict_outer[parameter] = [] + dict_outer[parameter].append(value) + else: # Not a list + dict_outer[parameter] = value return dict_outer def i3d_to_dict(filename="input.i3d", string=None): - if string is None: - with open(filename, "r") as f: + with open(filename) as f: string = f.read() return i3d_string_to_dict(string) def i3d_string_to_dict(string): - dict_outer = {} - for line in io.StringIO(string): + for raw_line in io.StringIO(string): # Remove comments - line = line.partition("!")[0].replace(" ", "") + line = raw_line.partition("!")[0].replace(" ", "") # Remove spaces line = " ".join(line.split()) @@ -1316,7 +1233,7 @@ def i3d_string_to_dict(string): continue # Get variable's name and value - param = line.partition("=")[0] + parameter = line.partition("=")[0] value = line.partition("=")[-1] try: @@ -1331,16 +1248,16 @@ def i3d_string_to_dict(string): value = float(value) else: # Int value = int(value) - except: - warnings.warn(f"Can't convert {param} : {value}") + except TypeError: + warnings.warn(f"Can't convert {parameter} : {value}", stacklevel=1) continue - if "(" in param and ")" == param[-1]: # Param is a list - param = param.split("(")[0] - if param not in dict_inner: - dict_inner[param] = [] - dict_inner[param].append(value) + if "(" in parameter and parameter[-1] == ")": # Param is a list + parameter = parameter.split("(")[0] + if parameter not in dict_inner: + dict_inner[parameter] = [] + dict_inner[parameter].append(value) else: # Not a list - dict_inner[param] = value + dict_inner[parameter] = value return dict_outer diff --git a/xcompact3d_toolbox/mesh.py b/xcompact3d_toolbox/mesh.py index c46b45d..255662e 100644 --- a/xcompact3d_toolbox/mesh.py +++ b/xcompact3d_toolbox/mesh.py @@ -1,27 +1,55 @@ """Objects to handle the coordinates and coordinate system. -Note they are an atribute at :obj:`xcompact3d_toolbox.parameters.ParametersExtras`, +Note they are an attribute at :obj:`xcompact3d_toolbox.parameters.ParametersExtras`, so they work together with all the other parameters. They are presented here for reference. """ + from __future__ import annotations -from typing import Type +from enum import IntEnum +from functools import partial +from math import isclose import numpy as np import traitlets -from .param import param +from xcompact3d_toolbox.param import param + + +class Istret(IntEnum): + """Mesh refinement type. + + Parameters + ---------- + value : int + Type of mesh refinement: + + * 0 - No refinement; + * 1 - Refinement at the center; + * 2 - Both sides; + * 3 - Just near the bottom. + + Returns + ------- + :obj:`xcompact3d_toolbox.mesh.Istret` + Mesh refinement type + """ + + NO_REFINEMENT = 0 + CENTER_REFINEMENT = 1 + BOTH_SIDES_REFINEMENT = 2 + BOTTOM_REFINEMENT = 3 class Coordinate(traitlets.HasTraits): """A coordinate. Thanks to traitlets_, the attributes can be type checked, validated and also trigger - ‘on change’ callbacks. It means that: + "on change" callbacks. It means that: - :obj:`grid_size` is validated to just accept the values expected by XCompact3d (see :obj:`xcompact3d_toolbox.mesh.Coordinate.possible_grid_size`); - :obj:`delta` is updated after any change on :obj:`grid_size` or :obj:`length`; - - :obj:`length` is updated after any change on :obj:`delta` (:obj:`grid_size` remais constant); + - :obj:`length` is updated after any change on :obj:`delta` (:obj:`grid_size` remains constant); - :obj:`grid_size` is reduced automatically by 1 when :obj:`is_periodic` changes to :obj:`True` and it is added by 1 when :obj:`is_periodic` changes back to :obj:`False` (see :obj:`xcompact3d_toolbox.mesh.Coordinate.possible_grid_size`); @@ -78,13 +106,13 @@ def __init__(self, **kwargs): -------- >>> from xcompact3d_toolbox.mesh import Coordinate - >>> coord = Coordinate(length = 1.0, grid_size = 9, is_periodic = False) + >>> coord = Coordinate(length=1.0, grid_size=9, is_periodic=False) """ self._possible_grid_size = _possible_size_not_periodic self.set(**kwargs) - def __array__(self) -> Type(np.ndarray): + def __array__(self) -> np.ndarray: """This method makes the coordinate automatically work as a numpy like array in any function from numpy. @@ -98,7 +126,7 @@ def __array__(self) -> Type(np.ndarray): >>> from xcompact3d_toolbox.mesh import Coordinate >>> import numpy - >>> coord = Coordinate(length = 1.0, grid_size = 9) + >>> coord = Coordinate(length=1.0, grid_size=9) >>> numpy.sin(coord) array([0. , 0.12467473, 0.24740396, 0.36627253, 0.47942554, 0.58509727, 0.68163876, 0.7675435 , 0.84147098]) @@ -126,14 +154,17 @@ def __len__(self): -------- >>> from xcompact3d_toolbox.mesh import Coordinate - >>> coord = Coordinate(grid_size = 9) + >>> coord = Coordinate(grid_size=9) >>> len(coord) 9 """ return self.grid_size def __repr__(self): - return f"{self.__class__.__name__}(length = {self.length}, grid_size = {self.grid_size}, is_periodic = {self.is_periodic})" + return ( + f"{self.__class__.__name__}(length = {self.length}, " + f"grid_size = {self.grid_size}, is_periodic = {self.is_periodic})" + ) def set(self, **kwargs) -> None: """Set a new value for any parameter after the initialization. @@ -153,22 +184,22 @@ def set(self, **kwargs) -> None: >>> from xcompact3d_toolbox.mesh import Coordinate >>> coord = Coordinate() - >>> coord.set(length = 1.0, grid_size = 9, is_periodic = False) + >>> coord.set(length=1.0, grid_size=9, is_periodic=False) """ if "is_periodic" in kwargs: self.is_periodic = kwargs.get("is_periodic") del kwargs["is_periodic"] for key, arg in kwargs.items(): if key not in self.trait_names(): - raise KeyError(f"{key} is not a valid parameter") + msg = f"{key} is not a valid parameter" + raise KeyError(msg) setattr(self, key, arg) @traitlets.validate("grid_size") def _validate_grid_size(self, proposal): if not _validate_grid_size(proposal.get("value"), self.is_periodic): - raise traitlets.TraitError( - f'{proposal.get("value")} is an invalid value for grid size' - ) + msg = f'{proposal.get("value")} is an invalid value for grid size' + raise traitlets.TraitError(msg) return proposal.get("value") @traitlets.observe("is_periodic") @@ -190,7 +221,6 @@ def _observe_sub_grid_size(self, change): @traitlets.observe("grid_size") def _observe_grid_size(self, change): - new_sgs = change.get("new") if self.is_periodic else change.get("new") - 1 if new_sgs != self._sub_grid_size: self._sub_grid_size = new_sgs @@ -208,7 +238,7 @@ def _observe_delta(self, change): self.length = new_length @property - def vector(self) -> Type(np.ndarray): + def vector(self) -> np.ndarray: """Construct a vector with :obj:`numpy.linspace` and return it. Returns @@ -245,7 +275,7 @@ def possible_grid_size(self) -> list: otherwise, where :math:`a`, :math:`b` and :math:`c` are non negative integers. - Aditionally, the derivative's stencil imposes that :math:`n \\ge 8` if periodic + Additionally, the derivative's stencil imposes that :math:`n \\ge 8` if periodic and :math:`n \\ge 9` otherwise. Returns @@ -261,7 +291,7 @@ def possible_grid_size(self) -> list: -------- >>> from xcompact3d_toolbox.mesh import Coordinate - >>> coordinate(is_periodic = True).possible_grid_size + >>> coordinate(is_periodic=True).possible_grid_size [8, 10, 12, 16, 18, 20, 24, 30, 32, 36, 40, 48, 50, 54, 60, 64, 72, 80, 90, 96, 100, 108, 120, 128, 144, 150, 160, 162, 180, 192, 200, 216, 240, 250, 256, 270, 288, 300, 320, 324, 360, 384, 400, 432, 450, 480, 486, @@ -273,7 +303,7 @@ def possible_grid_size(self) -> list: 4500, 4608, 4800, 4860, 5000, 5120, 5184, 5400, 5760, 5832, 6000, 6144, 6250, 6400, 6480, 6750, 6912, 7200, 7290, 7500, 7680, 7776, 8000, 8100, 8192, 8640, 8748, 9000] - >>> coordinate(is_periodic = False).possible_grid_size + >>> coordinate(is_periodic=False).possible_grid_size [9, 11, 13, 17, 19, 21, 25, 31, 33, 37, 41, 49, 51, 55, 61, 65, 73, 81, 91, 97, 101, 109, 121, 129, 145, 151, 161, 163, 181, 193, 201, 217, 241, 251, 257, 271, 289, 301, 321, 325, 361, 385, 401, 433, 451, 481, 487, @@ -325,18 +355,23 @@ class StretchedCoordinate(Coordinate): Stretched coordinate """ - istret = traitlets.Int( + istret = traitlets.UseEnum( + Istret, default_value=0, - min=0, - max=3, help="type of mesh refinement (0:no, 1:center, 2:both sides, 3:bottom)", ) beta = traitlets.Float(default_value=1.0, min=0.0, help="Refinement parameter") def __repr__(self): if self.istret == 0: - return f"{self.__class__.__name__}(length = {self.length}, grid_size = {self.grid_size}, is_periodic = {self.is_periodic})" - return f"{self.__class__.__name__}(length = {self.length}, grid_size = {self.grid_size}, is_periodic = {self.is_periodic}, istret = {self.istret}, beta = {self.beta})" + return ( + f"{self.__class__.__name__}(length = {self.length}, grid_size = {self.grid_size}, " + f"is_periodic = {self.is_periodic})" + ) + return ( + f"{self.__class__.__name__}(length = {self.length}, grid_size = {self.grid_size}, " + f"is_periodic = {self.is_periodic}, istret = {self.istret}, beta = {self.beta})" + ) def __array__(self): """This method makes the coordinate automatically work as a numpy @@ -352,7 +387,7 @@ def __array__(self): >>> from xcompact3d_toolbox.mesh import StretchedCoordinate >>> import numpy - >>> coord = StretchedCoordinate(length = 1.0, grid_size = 9) + >>> coord = StretchedCoordinate(length=1.0, grid_size=9) >>> numpy.sin(coord) array([0. , 0.12467473, 0.24740396, 0.36627253, 0.47942554, 0.58509727, 0.68163876, 0.7675435 , 0.84147098]) @@ -360,7 +395,7 @@ def __array__(self): array([1. , 0.99219767, 0.96891242, 0.93050762, 0.87758256, 0.81096312, 0.73168887, 0.64099686, 0.54030231]) """ - if self.istret == 0: + if self.istret == Istret.NO_REFINEMENT: return super().__array__() return _stretching( istret=self.istret, @@ -368,23 +403,25 @@ def __array__(self): yly=self.length, my=self._sub_grid_size, ny=self.grid_size, - return_auxiliar_variables=False, + return_auxiliary_variables=False, ) @traitlets.validate("istret") def _validate_istret(self, proposal): - if proposal.get("value") == 3 and self.is_periodic: - raise traitlets.TraitError( - f"mesh refinement at the bottom (istret=3) is not possible when periodic" + if proposal.get("value") == Istret.BOTTOM_REFINEMENT and self.is_periodic: + msg = ( + f"mesh refinement at the bottom (istret={Istret.BOTTOM_REFINEMENT.value}) is not possible when periodic" ) + raise traitlets.TraitError(msg) return proposal.get("value") @traitlets.validate("is_periodic") def _validate_is_periodic(self, proposal): - if proposal.get("value") and self.istret == 3: - raise traitlets.TraitError( - f"mesh refinement at the bottom (istret=3) is not possible when periodic" + if proposal.get("value") and self.istret == Istret.BOTTOM_REFINEMENT: + msg = ( + f"mesh refinement at the bottom (istret={Istret.BOTTOM_REFINEMENT.value}) is not possible when periodic" ) + raise traitlets.TraitError(msg) return proposal.get("value") @@ -402,7 +439,7 @@ class Mesh3D(traitlets.HasTraits): Notes ----- - :obj:`mesh` is in fact an atribute of :obj:`xcompact3d_toolbox.parameters.ParametersExtras`, + :obj:`mesh` is in fact an attribute of :obj:`xcompact3d_toolbox.parameters.ParametersExtras`, so there is no need to initialize it manually for most of the common use cases. The features of each coordinate are copled by a two-way link with their corresponding values at the Parameters class. For instance, the length of each of them is copled to @@ -438,9 +475,9 @@ def __init__(self, **kwargs): >>> from xcompact3d_toolbox.mesh import Mesh3D >>> mesh = Mesh3D( - ... x = dict(length = 4.0, grid_size = 65, is_periodic = False), - ... y = dict(length = 1.0, grid_size = 17, is_periodic = False, istret = 0), - ... z = dict(length = 1.0, grid_size = 16, is_periodic = True) + ... x=dict(length=4.0, grid_size=65, is_periodic=False), + ... y=dict(length=1.0, grid_size=17, is_periodic=False, istret=0), + ... z=dict(length=1.0, grid_size=16, is_periodic=True), ... ) """ @@ -451,13 +488,7 @@ def __init__(self, **kwargs): self.set(**kwargs) def __repr__(self): - return ( - f"{self.__class__.__name__}(\n" - f" x = {self.x},\n" - f" y = {self.y},\n" - f" z = {self.z},\n" - ")" - ) + return f"{self.__class__.__name__}(x = {self.x}, y = {self.y}, z = {self.z})" def __len__(self): """Make the coordinate work with the Python function :obj:`len`. @@ -489,16 +520,17 @@ def set(self, **kwargs) -> None: >>> from xcompact3d_toolbox.mesh import Mesh3D >>> mesh = Mesh3D() >>> mesh.set( - ... x = dict(length = 4.0, grid_size = 65, is_periodic = False), - ... y = dict(length = 1.0, grid_size = 17, is_periodic = False, istret = 0), - ... z = dict(length = 1.0, grid_size = 16, is_periodic = True) + ... x=dict(length=4.0, grid_size=65, is_periodic=False), + ... y=dict(length=1.0, grid_size=17, is_periodic=False, istret=0), + ... z=dict(length=1.0, grid_size=16, is_periodic=True), ... ) """ - for key in kwargs.keys(): + for key in kwargs: if key in self.trait_names(): getattr(self, key).set(**kwargs.get(key)) else: - raise KeyError(f"{key} is not a valid coordinate for Mesh3D") + msg = f"{key} is not a valid coordinate for Mesh3D" + raise KeyError(msg) def get(self) -> dict: """Get the three coordinates in a dictionary, where the keys are their names (x, y and z) @@ -533,7 +565,7 @@ def drop(self, *args) -> dict: Parameters ---------- *args : str or list of str - Name of the coordenate(s) to be dropped + Name of the coordinate(s) to be dropped Raises ------- @@ -549,18 +581,13 @@ def drop(self, *args) -> dict: if not arg: continue if arg not in self.trait_names(): - raise KeyError(f"{arg} is not a valid coordinate for Mesh3D") - return { - dir: getattr(self, dir).vector - for dir in self.trait_names() - if dir not in args - } + msg = f"{arg} is not a valid coordinate for Mesh3D" + raise KeyError(msg) + return {d: getattr(self, d).vector for d in self.trait_names() if d not in args} def copy(self): """Return a copy of the Mesh3D object.""" - return Mesh3D( - **{dim: getattr(self, dim).trait_values() for dim in self.trait_names()} - ) + return Mesh3D(**{dim: getattr(self, dim).trait_values() for dim in self.trait_names()}) @property def size(self): @@ -575,10 +602,9 @@ def size(self): def _validate_grid_size(grid_size, is_periodic): - size = grid_size if is_periodic else grid_size - 1 - if size < 8: + if size < 8: # noqa: PLR2004 return False if size % 2 == 0: @@ -596,9 +622,7 @@ def _validate_grid_size(grid_size, is_periodic): return True -def _get_possible_grid_values( - is_periodic: bool, start: int = 0, end: int = 9002 -) -> list: +def _get_possible_grid_values(start: int = 0, end: int = 9002, *, is_periodic: bool) -> list: return list( filter( lambda num: _validate_grid_size(num, is_periodic), @@ -607,12 +631,13 @@ def _get_possible_grid_values( ) -_possible_size_periodic = _get_possible_grid_values(True) +_possible_size_periodic = _get_possible_grid_values(is_periodic=True) -_possible_size_not_periodic = _get_possible_grid_values(False) +_possible_size_not_periodic = _get_possible_grid_values(is_periodic=False) -def _stretching(istret, beta, yly, my, ny, return_auxiliar_variables=True): +def _stretching(istret, beta, yly, my, ny, *, return_auxiliary_variables=True): + close_enough = partial(isclose, abs_tol=1e-8, rel_tol=1e-8) yp = np.zeros(ny, dtype=param["mytype"]) yeta = np.zeros_like(yp) @@ -629,166 +654,126 @@ def _stretching(istret, beta, yly, my, ny, return_auxiliar_variables=True): den = 2.0 * beta * yinf xnum = -yinf - np.sqrt(np.pi * np.pi * beta * beta + yinf * yinf) alpha = np.abs(xnum / den) - xcx = 1.0 / beta / alpha - if alpha != 0.0: - if istret == 1: + if not close_enough(alpha, 0.0): + if istret == Istret.CENTER_REFINEMENT: yp[0] = 0.0 - if istret == 2: + if istret == Istret.BOTH_SIDES_REFINEMENT: yp[0] = 0.0 - if istret == 1: + if istret == Istret.CENTER_REFINEMENT: yeta[0] = 0.0 - if istret == 2: + if istret == Istret.BOTH_SIDES_REFINEMENT: yeta[0] = -0.5 - if istret == 3: + if istret == Istret.BOTTOM_REFINEMENT: yp[0] = 0.0 - if istret == 3: + if istret == Istret.BOTTOM_REFINEMENT: yeta[0] = -0.5 for j in range(1, ny): - if istret == 1: + if istret == Istret.CENTER_REFINEMENT: yeta[j] = j / my - if istret == 2: + if istret == Istret.BOTH_SIDES_REFINEMENT: yeta[j] = j / my - 0.5 - if istret == 3: + if istret == Istret.BOTTOM_REFINEMENT: yeta[j] = 0.5 * j / my - 0.5 den1 = np.sqrt(alpha * beta + 1.0) xnum = den1 / np.sqrt(alpha / np.pi) / np.sqrt(beta) / np.sqrt(np.pi) den = 2.0 * np.sqrt(alpha / np.pi) * np.sqrt(beta) * np.pi * np.sqrt(np.pi) - den3 = ( - (np.sin(np.pi * yeta[j])) * (np.sin(np.pi * yeta[j])) / beta / np.pi - ) + alpha / np.pi + den3 = ((np.sin(np.pi * yeta[j])) * (np.sin(np.pi * yeta[j])) / beta / np.pi) + alpha / np.pi den4 = 2.0 * alpha * beta - np.cos(2.0 * np.pi * yeta[j]) + 1.0 - xnum1 = ( - (np.arctan(xnum * np.tan(np.pi * yeta[j]))) * den4 / den1 / den3 / den - ) - cst = ( - np.sqrt(beta) - * np.pi - / (2.0 * np.sqrt(alpha) * np.sqrt(alpha * beta + 1.0)) - ) - if istret == 1: - if yeta[j] < 0.5: + xnum1 = (np.arctan(xnum * np.tan(np.pi * yeta[j]))) * den4 / den1 / den3 / den + cst = np.sqrt(beta) * np.pi / (2.0 * np.sqrt(alpha) * np.sqrt(alpha * beta + 1.0)) + if istret == Istret.CENTER_REFINEMENT: + if yeta[j] < 0.5: # noqa: PLR2004 yp[j] = xnum1 - cst - yinf - if yeta[j] == 0.5: + if close_enough(yeta[j], 0.5): yp[j] = -yinf - if yeta[j] > 0.5: + if yeta[j] > 0.5: # noqa: PLR2004 yp[j] = xnum1 + cst - yinf - elif istret == 2: - if yeta[j] < 0.5: + elif istret == Istret.BOTH_SIDES_REFINEMENT: + if yeta[j] < 0.5: # noqa: PLR2004 yp[j] = xnum1 - cst + yly - if yeta[j] == 0.5: + if close_enough(yeta[j], 0.5): yp[j] = yly - if yeta[j] > 0.5: + if yeta[j] > 0.5: # noqa: PLR2004 yp[j] = xnum1 + cst + yly - elif istret == 3: - if yeta[j] < 0.5: + elif istret == Istret.BOTTOM_REFINEMENT: + if yeta[j] < 0.5: # noqa: PLR2004 yp[j] = (xnum1 - cst + yly) * 2.0 - if yeta[j] == 0.5: + if close_enough(yeta[j], 0.5): yp[j] = yly * 2.0 - if yeta[j] > 0.5: + if yeta[j] > 0.5: # noqa: PLR2004 yp[j] = (xnum1 + cst + yly) * 2.0 else: - raise NotImplementedError("Unsupported: invalid value for istret") - if alpha == 0.0: + msg = "Unsupported: invalid value for istret" + raise NotImplementedError(msg) + if close_enough(alpha, 0.0): yp[0] = -1.0e10 for j in range(1, ny): yeta[j] = j / ny yp[j] = -beta * np.cos(np.pi * yeta[j]) / np.sin(yeta[j] * np.pi) - if alpha != 0.0: + if not close_enough(alpha, 0.0): for j in range(ny): - if istret == 1: + if istret == Istret.CENTER_REFINEMENT: yetai[j] = (j + 0.5) * (1.0 / my) - if istret == 2: + if istret == Istret.BOTH_SIDES_REFINEMENT: yetai[j] = (j + 0.5) * (1.0 / my) - 0.5 - if istret == 3: + if istret == Istret.BOTTOM_REFINEMENT: yetai[j] = (j + 0.5) * (0.5 / my) - 0.5 den1 = np.sqrt(alpha * beta + 1.0) xnum = den1 / np.sqrt(alpha / np.pi) / np.sqrt(beta) / np.sqrt(np.pi) den = 2.0 * np.sqrt(alpha / np.pi) * np.sqrt(beta) * np.pi * np.sqrt(np.pi) - den3 = ( - (np.sin(np.pi * yetai[j])) * (np.sin(np.pi * yetai[j])) / beta / np.pi - ) + alpha / np.pi + den3 = ((np.sin(np.pi * yetai[j])) * (np.sin(np.pi * yetai[j])) / beta / np.pi) + alpha / np.pi den4 = 2.0 * alpha * beta - np.cos(2.0 * np.pi * yetai[j]) + 1.0 - xnum1 = ( - (np.arctan(xnum * np.tan(np.pi * yetai[j]))) * den4 / den1 / den3 / den - ) - cst = ( - np.sqrt(beta) - * np.pi - / (2.0 * np.sqrt(alpha) * np.sqrt(alpha * beta + 1.0)) - ) - if istret == 1: - if yetai[j] < 0.5: + xnum1 = (np.arctan(xnum * np.tan(np.pi * yetai[j]))) * den4 / den1 / den3 / den + cst = np.sqrt(beta) * np.pi / (2.0 * np.sqrt(alpha) * np.sqrt(alpha * beta + 1.0)) + if istret == Istret.CENTER_REFINEMENT: + if yetai[j] < 0.5: # noqa: PLR2004 ypi[j] = xnum1 - cst - yinf - elif yetai[j] == 0.5: + elif close_enough(yetai[j], 0.5): ypi[j] = 0.0 - yinf - elif yetai[j] > 0.5: + elif yetai[j] > 0.5: # noqa: PLR2004 ypi[j] = xnum1 + cst - yinf - elif istret == 2: - if yetai[j] < 0.5: + elif istret == Istret.BOTH_SIDES_REFINEMENT: + if yetai[j] < 0.5: # noqa: PLR2004 ypi[j] = xnum1 - cst + yly - elif yetai[j] == 0.5: + elif close_enough(yetai[j], 0.5): ypi[j] = 0.0 + yly - elif yetai[j] > 0.5: + elif yetai[j] > 0.5: # noqa: PLR2004 ypi[j] = xnum1 + cst + yly - elif istret == 3: - if yetai[j] < 0.5: + elif istret == Istret.BOTTOM_REFINEMENT: + if yetai[j] < 0.5: # noqa: PLR2004 ypi[j] = (xnum1 - cst + yly) * 2.0 - elif yetai[j] == 0.5: + elif close_enough(yetai[j], 0.5): ypi[j] = (0.0 + yly) * 2.0 - elif yetai[j] > 0.5: + elif yetai[j] > 0.5: # noqa: PLR2004 ypi[j] = (xnum1 + cst + yly) * 2.0 - if alpha == 0.0: + if close_enough(alpha, 0.0): ypi[0] = -1e10 for j in range(1, ny): yetai[j] = j * (1.0 / ny) ypi[j] = -beta * np.cos(np.pi * yetai[j]) / np.sin(yetai[j] * np.pi) # Mapping!!, metric terms - if istret != 3: + if istret != Istret.BOTTOM_REFINEMENT: for j in range(ny): - ppy[j] = yly * ( - alpha / np.pi - + (1.0 / np.pi / beta) - * np.sin(np.pi * yeta[j]) - * np.sin(np.pi * yeta[j]) - ) + ppy[j] = yly * (alpha / np.pi + (1.0 / np.pi / beta) * np.sin(np.pi * yeta[j]) * np.sin(np.pi * yeta[j])) pp2y[j] = ppy[j] * ppy[j] pp4y[j] = -2.0 / beta * np.cos(np.pi * yeta[j]) * np.sin(np.pi * yeta[j]) for j in range(ny): - ppyi[j] = yly * ( - alpha / np.pi - + (1.0 / np.pi / beta) - * np.sin(np.pi * yetai[j]) - * np.sin(np.pi * yetai[j]) - ) + ppyi[j] = yly * (alpha / np.pi + (1.0 / np.pi / beta) * np.sin(np.pi * yetai[j]) * np.sin(np.pi * yetai[j])) pp2yi[j] = ppyi[j] * ppyi[j] pp4yi[j] = -2.0 / beta * np.cos(np.pi * yetai[j]) * np.sin(np.pi * yetai[j]) - if istret == 3: + if istret == Istret.BOTTOM_REFINEMENT: for j in range(ny): - ppy[j] = yly * ( - alpha / np.pi - + (1.0 / np.pi / beta) - * np.sin(np.pi * yeta[j]) - * np.sin(np.pi * yeta[j]) - ) + ppy[j] = yly * (alpha / np.pi + (1.0 / np.pi / beta) * np.sin(np.pi * yeta[j]) * np.sin(np.pi * yeta[j])) pp2y[j] = ppy[j] * ppy[j] - pp4y[j] = ( - -2.0 / beta * np.cos(np.pi * yeta[j]) * np.sin(np.pi * yeta[j]) - ) / 2.0 + pp4y[j] = (-2.0 / beta * np.cos(np.pi * yeta[j]) * np.sin(np.pi * yeta[j])) / 2.0 for j in range(ny): - ppyi[j] = yly * ( - alpha / np.pi - + (1.0 / np.pi / beta) - * np.sin(np.pi * yetai[j]) - * np.sin(np.pi * yetai[j]) - ) + ppyi[j] = yly * (alpha / np.pi + (1.0 / np.pi / beta) * np.sin(np.pi * yetai[j]) * np.sin(np.pi * yetai[j])) pp2yi[j] = ppyi[j] * ppyi[j] - pp4yi[j] = ( - -2.0 / beta * np.cos(np.pi * yetai[j]) * np.sin(np.pi * yetai[j]) - ) / 2.0 - if return_auxiliar_variables: + pp4yi[j] = (-2.0 / beta * np.cos(np.pi * yetai[j]) * np.sin(np.pi * yetai[j])) / 2.0 + if return_auxiliary_variables: return yp, ppy, pp2y, pp4y return yp diff --git a/xcompact3d_toolbox/param.py b/xcompact3d_toolbox/param.py index 31c316d..d7804f7 100644 --- a/xcompact3d_toolbox/param.py +++ b/xcompact3d_toolbox/param.py @@ -3,6 +3,9 @@ param = {"mytype": float64} +COORDS = ["x", "y", "z"] + + def boundary_condition(prm, var=None): default = { d: { @@ -15,7 +18,7 @@ def boundary_condition(prm, var=None): default["y"]["istret"] = prm.istret default["y"]["beta"] = prm.beta - BC = { + boundary_conditions = { "ux": { "x": {"ncl1": prm.nclx1, "ncln": prm.nclxn, "npaire": 0}, "y": {"ncl1": prm.ncly1, "ncln": prm.nclyn, "npaire": 1}, @@ -51,15 +54,14 @@ def boundary_condition(prm, var=None): } if prm.numscalar > 0: - - BC["phi"] = { + boundary_conditions["phi"] = { "x": {"ncl1": prm.nclxS1, "ncln": prm.nclxS1, "npaire": 1}, "y": {"ncl1": prm.nclyS1, "ncln": prm.nclySn, "npaire": 1}, "z": {"ncl1": prm.nclzS1, "ncln": prm.nclzSn, "npaire": 1}, } - for key, value in BC.items(): + for value in boundary_conditions.values(): value["y"]["istret"] = prm.istret value["y"]["beta"] = prm.beta - return BC.get(var.lower(), default) + return boundary_conditions.get(var.lower(), default) diff --git a/xcompact3d_toolbox/parameters.py b/xcompact3d_toolbox/parameters.py index 04d41ac..26b5235 100644 --- a/xcompact3d_toolbox/parameters.py +++ b/xcompact3d_toolbox/parameters.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """ Tools to manipulate the physical and computational parameters. It contains variables and methods designed to be a link between XCompact3d_ and Python applications for @@ -8,26 +7,27 @@ https://github.com/xcompact3d/Incompact3d """ +from __future__ import annotations + import os.path -import warnings import numpy as np import traitlets +from loguru import logger -from .io import Dataset, i3d_to_dict, prm_to_dict -from .mesh import Mesh3D -from .param import boundary_condition, param +from xcompact3d_toolbox.io import Dataset, i3d_to_dict, prm_to_dict +from xcompact3d_toolbox.mesh import Istret, Mesh3D +from xcompact3d_toolbox.param import COORDS, boundary_condition, param class ParametersBasicParam(traitlets.HasTraits): - - p_row, p_col = [ + p_row, p_col = ( traitlets.Int(default_value=0, min=0).tag( group="BasicParam", desc=f"{name} for domain decomposition and parallel computation", ) for name in ["Row partition", "Column partition"] - ] + ) """int: Defines the domain decomposition for (large-scale) parallel computation. Notes @@ -84,10 +84,7 @@ class ParametersBasicParam(traitlets.HasTraits): The exactly behavior may be different according to each flow configuration. """ - nx, ny, nz = [ - traitlets.Int().tag(group="BasicParam", desc=f"{name.upper()}-direction nodes") - for name in "x y z".split() - ] + nx, ny, nz = (traitlets.Int().tag(group="BasicParam", desc=f"{name.upper()}-direction nodes") for name in COORDS) """int: Number of mesh points. Notes @@ -96,12 +93,9 @@ class ParametersBasicParam(traitlets.HasTraits): for recommended grid sizes. """ - xlx, yly, zlz = [ - traitlets.Float().tag( - group="BasicParam", desc=f"Size of the box in {name}-direction" - ) - for name in "x y z".split() - ] + xlx, yly, zlz = ( + traitlets.Float().tag(group="BasicParam", desc=f"Size of the box in {name}-direction") for name in COORDS + ) """float: Domain size. """ @@ -192,11 +186,12 @@ class ParametersBasicParam(traitlets.HasTraits): ) """int: Enables Large-Eddy methodologies: - * 0 - No (also forces :obj:`ParametersNumOptions.nu0nu` and :obj:`ParametersNumOptions.cnu` to 4.0 and 0.44, respectively); + * 0 - No (also forces :obj:`ParametersNumOptions.nu0nu` and :obj:`ParametersNumOptions.cnu` + to 4.0 and 0.44, respectively); * 1 - Yes (also activates the namespace **LESModel** (see :obj:`ParametersLESModel`). """ - istret = traitlets.Int(default_value=0, min=0, max=3).tag( + istret = traitlets.UseEnum(Istret, default_value=0).tag( group="BasicParam", desc="y mesh refinement (0:no, 1:center, 2:both sides, 3:bottom)", ) @@ -212,9 +207,7 @@ class ParametersBasicParam(traitlets.HasTraits): See :obj:`beta`. """ - beta = traitlets.Float(default_value=1.0, min=0).tag( - group="BasicParam", desc="Refinement parameter" - ) + beta = traitlets.Float(default_value=1.0, min=0).tag(group="BasicParam", desc="Refinement parameter") """float: Refinement factor in **y**. Notes @@ -222,27 +215,19 @@ class ParametersBasicParam(traitlets.HasTraits): Only necessary if :obj:`istret` :math:`\\ne` 0. """ - dt = traitlets.Float(default_value=1e-3, min=0.0).tag( - group="BasicParam", desc="Time step" - ) + dt = traitlets.Float(default_value=1e-3, min=0.0).tag(group="BasicParam", desc="Time step") """float: Time step :math:`(\\Delta t)`. """ - ifirst = traitlets.Int(default_value=0, min=0).tag( - group="BasicParam", desc="The number for the first iteration" - ) + ifirst = traitlets.Int(default_value=0, min=0).tag(group="BasicParam", desc="The number for the first iteration") """int: The number for the first iteration. """ - ilast = traitlets.Int(default_value=0, min=0).tag( - group="BasicParam", desc="The number for the last iteration" - ) + ilast = traitlets.Int(default_value=0, min=0).tag(group="BasicParam", desc="The number for the last iteration") """int: The number for the last iteration. """ - re = traitlets.Float(default_value=1e3).tag( - group="BasicParam", desc="Reynolds number" - ) + re = traitlets.Float(default_value=1e3).tag(group="BasicParam", desc="Reynolds number") """float: Reynolds number :math:`(Re)`. """ @@ -285,20 +270,16 @@ class ParametersBasicParam(traitlets.HasTraits): :obj:`ParametersIbmStuff.nobjmax` and :obj:`ParametersIbmStuff.nraf`. """ - numscalar = traitlets.Int(default_value=0, min=0, max=9).tag( - group="BasicParam", desc="Number of scalar fractions" - ) + numscalar = traitlets.Int(default_value=0, min=0, max=9).tag(group="BasicParam", desc="Number of scalar fractions") """int: Number of scalar fraction, which can have different properties. Any option greater than zero activates the namespace :obj:`ParametersScalarParam`. """ - gravx, gravy, gravz = [ - traitlets.Float(default_value=0.0).tag( - group="BasicParam", desc=f"Gravity unitary vector in {name}-direction" - ) - for name in "x y z".split() - ] + gravx, gravy, gravz = ( + traitlets.Float(default_value=0.0).tag(group="BasicParam", desc=f"Gravity unitary vector in {name}-direction") + for name in COORDS + ) """float: Component of the unitary vector pointing in the gravity's direction. """ @@ -317,12 +298,13 @@ class ParametersBasicParam(traitlets.HasTraits): iturbine = traitlets.Int(default_value=0, min=0, max=2).tag(group="BasicParam") def __init__(self): - super(ParametersBasicParam, self).__init__() + super().__init__() @traitlets.validate("iscalar") def _validate_iscalar(self, proposal): if proposal.get("value") == 0 and self.numscalar > 0: - raise traitlets.TraitError(f"iscalar can not be zero if numscalar > 0") + msg = "iscalar can not be zero if numscalar > 0" + raise traitlets.TraitError(msg) return proposal.get("value") @traitlets.observe("numscalar") @@ -394,7 +376,7 @@ class ParametersNumOptions(traitlets.HasTraits): """ def __init__(self): - super(ParametersNumOptions, self).__init__() + super().__init__() @traitlets.observe("ilesmod") def _observe_ilesmod(self, change): @@ -406,9 +388,8 @@ def _observe_ilesmod(self, change): def _validate_iscalar(self, proposal): if self.ilesmod == 0: # It is coded at xcompact3d, look at parameters.f90 - raise traitlets.TraitError( - f"Can not set new values for nu0nu and cnu if ilesmod = 0" - ) + msg = "Can not set new values for nu0nu and cnu if ilesmod = 0" + raise traitlets.TraitError(msg) return proposal.get("value") @@ -419,9 +400,7 @@ class ParametersInOutParam(traitlets.HasTraits): """int: Reads initial flow field if equals to 1. """ - nvisu = traitlets.Int(default_value=1, min=1).tag( - group="InOutParam", desc="Size for visualization collection" - ) + nvisu = traitlets.Int(default_value=1, min=1).tag(group="InOutParam", desc="Size for visualization collection") """int: Size for visual collection. """ @@ -431,9 +410,7 @@ class ParametersInOutParam(traitlets.HasTraits): """int: Frequency for writing restart file. """ - ioutput = traitlets.Int(default_value=1000, min=1).tag( - group="InOutParam", desc="Frequency for visualization file" - ) + ioutput = traitlets.Int(default_value=1000, min=1).tag(group="InOutParam", desc="Frequency for visualization file") """int: Frequency for visualization (3D snapshots). """ @@ -451,36 +428,28 @@ class ParametersInOutParam(traitlets.HasTraits): inflowpath = traitlets.Unicode(default_value="./") - output2D = traitlets.Int(default_value=0).tag(group="InOutParam") + output2D = traitlets.Int(default_value=0).tag(group="InOutParam") # N815 nprobes = traitlets.Int(default_value=0, min=0).tag(group="InOutParam") def __init__(self): - super(ParametersInOutParam, self).__init__() + super().__init__() class ParametersScalarParam(traitlets.HasTraits): - sc = traitlets.List(trait=traitlets.Float()).tag( - group="ScalarParam", desc="Schmidt number(s)" - ) + sc = traitlets.List(trait=traitlets.Float()).tag(group="ScalarParam", desc="Schmidt number(s)") """:obj:`list` of :obj:`float`: Schmidt number(s). """ - ri = traitlets.List(trait=traitlets.Float()).tag( - group="ScalarParam", desc="Richardson number(s)" - ) + ri = traitlets.List(trait=traitlets.Float()).tag(group="ScalarParam", desc="Richardson number(s)") """:obj:`list` of :obj:`float`: Richardson number(s). """ - uset = traitlets.List(trait=traitlets.Float()).tag( - group="ScalarParam", desc="Settling velocity(ies)" - ) + uset = traitlets.List(trait=traitlets.Float()).tag(group="ScalarParam", desc="Settling velocity(ies)") """:obj:`list` of :obj:`float`: Settling velocity(s). """ - cp = traitlets.List(trait=traitlets.Float()).tag( - group="ScalarParam", desc="Initial concentration(s)" - ) + cp = traitlets.List(trait=traitlets.Float()).tag(group="ScalarParam", desc="Initial concentration(s)") """:obj:`list` of :obj:`float`: Initial concentration(s). """ @@ -564,7 +533,7 @@ class ParametersScalarParam(traitlets.HasTraits): Tref = traitlets.Float().tag(group="ScalarParam") def __init__(self): - super(ParametersScalarParam, self).__init__() + super().__init__() class ParametersLESModel(traitlets.HasTraits): @@ -601,7 +570,7 @@ class ParametersLESModel(traitlets.HasTraits): """int: """ def __init__(self): - super(ParametersLESModel, self).__init__() + super().__init__() class ParametersIbmStuff(traitlets.HasTraits): @@ -609,7 +578,7 @@ class ParametersIbmStuff(traitlets.HasTraits): group="ibmstuff", desc="Maximum number of objects in any direction" ) """int: Maximum number of objects in any direction. It is defined - automatically at :obj:`gene_epsi_3D`. + automatically at :obj:`gene_epsi_3d`. """ nraf = traitlets.Int(default_value=10, min=1).tag( @@ -637,19 +606,19 @@ class ParametersIbmStuff(traitlets.HasTraits): """ def __init__(self): - super(ParametersIbmStuff, self).__init__() + super().__init__() class ParametersALMParam(traitlets.HasTraits): iturboutput = traitlets.Int(default_value=1, min=1).tag(group="ALMParam") def __init__(self): - super(ParametersALMParam, self).__init__() + super().__init__() class ParametersExtras(traitlets.HasTraits): """Extra utilities that are not present at the parameters file, - but are usefull for Python applications. + but are useful for Python applications. """ filename = traitlets.Unicode(default_value="input.i3d").tag() @@ -676,8 +645,8 @@ class ParametersExtras(traitlets.HasTraits): Consider using hvPlot_ to explore your data interactively, see how to plot `Gridded Data`_. - .. _xarray: http://xarray.pydata.org/en/stable/ - .. _`Why xarray?`: http://xarray.pydata.org/en/stable/why-xarray.html + .. _xarray: http://docs.xarray.dev/en/stable + .. _`Why xarray?`: http://docs.xarray.dev/en/stable/why-xarray.html .. _hvPlot: https://hvplot.holoviz.org/ .. _`Gridded Data`: https://hvplot.holoviz.org/user_guide/Gridded_Data.html @@ -788,7 +757,7 @@ class ParametersExtras(traitlets.HasTraits): >>> prm.dataset.write_xdmf() """ - dx, dy, dz = [traitlets.Float().tag() for _ in "x y z".split()] + dx, dy, dz = (traitlets.Float().tag() for _ in COORDS) """float: Mesh resolution. """ @@ -797,15 +766,15 @@ class ParametersExtras(traitlets.HasTraits): """ size = traitlets.Unicode().tag() - """str: Auxiliar variable indicating the demand for storage. + """str: Auxiliary variable indicating the demand for storage. """ def __init__(self): - super(ParametersExtras, self).__init__() + super().__init__() self.mesh = Mesh3D() self._link_mesh_and_parameters() - self.dataset = Dataset(**dict(_mesh=self.mesh, _prm=self)) + self.dataset = Dataset(_mesh=self.mesh, _prm=self) def _link_mesh_and_parameters(self): for dim in "xyz": @@ -828,7 +797,7 @@ class Parameters( ): """The physical and computational parameters are built on top of `traitlets`_. It is a framework that lets Python classes have attributes with type checking, - dynamically calculated default values, and ‘on change’ callbacks. + dynamically calculated default values, and "on change" callbacks. In this way, many of the parameters are validated regarding the type, business rules, and the range of values supported by XCompact3d_. There are methods to handle the parameters file (``.i3d`` and ``.prm``). @@ -853,7 +822,7 @@ class Parameters( .. note:: This is a work in progress, not all parameters are covered yet. """ - def __init__(self, raise_warning: bool = False, **kwargs): + def __init__(self, *, raise_warning: bool = False, **kwargs): """Initializes the Parameters Class. Parameters @@ -882,53 +851,53 @@ def __init__(self, raise_warning: bool = False, **kwargs): >>> prm.re = 1e6 >>> prm.set( - ... iibm = 0, - ... p_row = 4, - ... p_col = 2, + ... iibm=0, + ... p_row=4, + ... p_col=2, ... ) Second, we can specify some values, and let the missing ones be initialized with default value: >>> prm = x3d.Parameters( - ... filename = 'example.i3d', - ... itype = 12, - ... nx = 257, - ... ny = 129, - ... nz = 32, - ... xlx = 15.0, - ... yly = 10.0, - ... zlz = 3.0, - ... nclx1 = 2, - ... nclxn = 2, - ... ncly1 = 1, - ... nclyn = 1, - ... nclz1 = 0, - ... nclzn = 0, - ... re = 300.0, - ... init_noise = 0.0125, - ... dt = 0.0025, - ... ilast = 45000, - ... ioutput = 200, - ... iprocessing = 50 + ... filename="example.i3d", + ... itype=12, + ... nx=257, + ... ny=129, + ... nz=32, + ... xlx=15.0, + ... yly=10.0, + ... zlz=3.0, + ... nclx1=2, + ... nclxn=2, + ... ncly1=1, + ... nclyn=1, + ... nclz1=0, + ... nclzn=0, + ... re=300.0, + ... init_noise=0.0125, + ... dt=0.0025, + ... ilast=45000, + ... ioutput=200, + ... iprocessing=50, ... ) And finally, it is possible to read the parameters from the disc: - >>> prm = xcompact3d_toolbox.Parameters(loadfile = 'example.i3d') + >>> prm = xcompact3d_toolbox.Parameters(loadfile="example.i3d") It also supports the previous parameters file format (see `#7`_): - >>> prm = xcompact3d_toolbox.Parameters(loadfile = 'incompact3d.prm') + >>> prm = xcompact3d_toolbox.Parameters(loadfile="incompact3d.prm") .. _#7: https://github.com/fschuch/xcompact3d_toolbox/issues/7 """ - super(Parameters, self).__init__() + super().__init__() - if "loadfile" in kwargs.keys(): + if "loadfile" in kwargs: self.filename = kwargs.pop("loadfile") self.load(raise_warning=raise_warning) @@ -954,37 +923,37 @@ def __str__(self): """Representation of the parameters class, similar to the representation of the ``.i3d`` file.""" # These groups are demanded by Xcompact3d, see parameters.f90 - dictionary = dict( - BasicParam={}, - NumOptions={}, - InOutParam={}, - Statistics={}, - CASE={}, - ) + dictionary = { + "BasicParam": {}, + "NumOptions": {}, + "InOutParam": {}, + "Statistics": {}, + "CASE": {}, + } for name in self.trait_names(): # if skip_default: # if getattr(self, name) == self.trait_defaults(name): # continue group = self.trait_metadata(name, "group") if group is not None: - if group not in dictionary.keys(): + if group not in dictionary: dictionary[group] = {} dictionary[group][name] = getattr(self, name) # This block is not handled by x3d if ilesmod is off - if "LESModel" in dictionary.keys() and self.ilesmod == 0: + if "LESModel" in dictionary and self.ilesmod == 0: del dictionary["LESModel"] # This block is not handled by x3d if iibm is off - if "ibmstuff" in dictionary.keys() and self.iibm == 0: + if "ibmstuff" in dictionary and self.iibm == 0: del dictionary["ibmstuff"] # This block is not handled by x3d if numscalar is 0 - if "ScalarParam" in dictionary.keys() and self.numscalar == 0: + if "ScalarParam" in dictionary and self.numscalar == 0: del dictionary["ScalarParam"] # This block is not handled by x3d if iturbine is not 1 - if "ALMParam" in dictionary.keys() and self.iturbine != 1: + if "ALMParam" in dictionary and self.iturbine != 1: del dictionary["ALMParam"] string = "" @@ -992,31 +961,30 @@ def __str__(self): string += "! -*- mode: f90 -*-\n" for blockkey, block in dictionary.items(): - string += "\n" string += "!===================\n" string += "&" + blockkey + "\n" string += "!===================\n" string += "\n" - for paramkey, param in block.items(): + for paramkey, paramvalue in block.items(): # get description to print together with the values description = self.trait_metadata(paramkey, "desc") if description is None: description = "" # Check if param is a list or not - if isinstance(param, list): - for n, p in enumerate(param): + if isinstance(paramvalue, list): + for n, p in enumerate(paramvalue): string += f"{paramkey+'('+str(n+1)+')':>15} = {p:<15} {'! '+description}\n" # Check if param is a string - elif isinstance(param, str): - param = "'" + param + "'" - string += f"{paramkey:>15} = {param:<15} {'! '+description}\n" - elif isinstance(param, bool): - param = ".true." if param else ".false." - string += f"{paramkey:>15} = {param:<15} {'! '+description}\n" + elif isinstance(paramvalue, str): + new_paramvalue = "'" + paramvalue + "'" + string += f"{paramkey:>15} = {new_paramvalue:<15} {'! '+description}\n" + elif isinstance(paramvalue, bool): + new_paramvalue = ".true." if paramvalue else ".false." + string += f"{paramkey:>15} = {new_paramvalue:<15} {'! '+description}\n" else: - string += f"{paramkey:>15} = {param:<15} {'! '+description}\n" + string += f"{paramkey:>15} = {paramvalue:<15} {'! '+description}\n" string += "\n" string += "/End\n" @@ -1041,28 +1009,28 @@ def _observe_bc(self, change): dim = change["name"][3] # It will be x, y or z # if change["new"] == 0: - for BC in f"ncl{dim}1 ncl{dim}n ncl{dim}S1 ncl{dim}Sn".split(): - setattr(self, BC, 0) + for boundary_condition in f"ncl{dim}1 ncl{dim}n ncl{dim}S1 ncl{dim}Sn".split(): + setattr(self, boundary_condition, 0) getattr(self.mesh, dim) - setattr(getattr(self.mesh, dim), "is_periodic", True) + getattr(self.mesh, dim).is_periodic = True if change["old"] == 0 and change["new"] != 0: - for BC in f"ncl{dim}1 ncl{dim}n ncl{dim}S1 ncl{dim}Sn".split(): - setattr(self, BC, change["new"]) - setattr(getattr(self.mesh, dim), "is_periodic", False) + for boundary_condition in f"ncl{dim}1 ncl{dim}n ncl{dim}S1 ncl{dim}Sn".split(): + setattr(self, boundary_condition, change["new"]) + getattr(self.mesh, dim).is_periodic = False @traitlets.observe("p_row", "p_col", "ncores") - def _observe_2Decomp(self, change): + def _observe_2decomp(self, change): if change["name"] == "ncores": self.p_row, self.p_col = 0, 0 elif change["name"] == "p_row": try: self.p_col = self.ncores // self.p_row - except: + except ZeroDivisionError: self.p_col = 0 elif change["name"] == "p_col": try: self.p_row = self.ncores // self.p_col - except: + except ZeroDivisionError: self.p_row = 0 @traitlets.observe( @@ -1076,7 +1044,7 @@ def _observe_2Decomp(self, change): "iprocessing", "ilast", ) - def _observe_size(self, change): + def _observe_size(self, _): def convert_bytes(num): """ this function will convert bytes to MB.... GB... etc @@ -1085,8 +1053,9 @@ def convert_bytes(num): for x in ["bytes", "KB", "MB", "GB", "TB"]: if num < step_unit: - return "%3.1f %s" % (num, x) + return f"{num:3.1f} {x}" num /= step_unit + return None prec = 4 if param["mytype"] == np.float32 else 8 @@ -1095,46 +1064,20 @@ def convert_bytes(num): # Previous time-step if necessary if self.itimescheme in [3, 7]: count *= 3 - elif self.itimescheme == 2: + elif self.itimescheme == 2: # noqa: PLR2004 count *= 2 count += 1 # pp - count *= ( - self.nx * self.ny * self.nz * prec * (self.ilast // self.icheckpoint - 1) - ) + count *= self.nx * self.ny * self.nz * prec * (self.ilast // self.icheckpoint - 1) # 3D from visu.f90: ux, uy, uz, pp and phi - count += ( - (4 + self.numscalar) - * self.nx - * self.ny - * self.nz - * prec - * self.ilast - // self.ioutput - ) + count += (4 + self.numscalar) * self.nx * self.ny * self.nz * prec * self.ilast // self.ioutput # 2D planes from BC.Sandbox.f90 - if self.itype == 10: + if self.itype == 10: # noqa: PLR2004 # xy planes avg and central plane for ux, uy, uz and phi - count += ( - 2 - * (3 + self.numscalar) - * self.nx - * self.ny - * prec - * self.ilast - // self.iprocessing - ) + count += 2 * (3 + self.numscalar) * self.nx * self.ny * prec * self.ilast // self.iprocessing # xz planes avg, top and bot for ux, uy, uz and phi - count += ( - 3 - * (3 + self.numscalar) - * self.nx - * self.nz - * prec - * self.ilast - // self.iprocessing - ) + count += 3 * (3 + self.numscalar) * self.nx * self.nz * prec * self.ilast // self.iprocessing self.size = convert_bytes(count) @@ -1158,7 +1101,7 @@ def get_boundary_condition(self, variable_name: str) -> dict: -------- >>> prm = xcompact3d_toolbox.Parameters() - >>> prm.get_boundary_condition('ux') + >>> prm.get_boundary_condition("ux") {'x': {'ncl1': 1, 'ncln': 1, 'npaire': 0}, 'y': {'ncl1': 1, 'ncln': 2, 'npaire': 1, 'istret': 0, 'beta': 0.75}, 'z': {'ncl1': 0, 'ncln': 0, 'npaire': 1}} @@ -1166,18 +1109,18 @@ def get_boundary_condition(self, variable_name: str) -> dict: It is possible to store this information as an attribute in any :obj:`xarray.DataArray`: - >>> DataArray.attrs['BC'] = prm.get_boundary_condition('ux') + >>> DataArray.attrs["BC"] = prm.get_boundary_condition("ux") So the correct boundary conditions will be used to compute the derivatives: - >>> DataArray.x3d.first_derivative('x') - >>> DataArray.x3d.second_derivative('x') + >>> DataArray.x3d.first_derivative("x") + >>> DataArray.x3d.second_derivative("x") """ return boundary_condition(self, variable_name) - def set(self, raise_warning: bool = False, **kwargs) -> None: + def set(self, *, raise_warning: bool = False, **kwargs) -> None: """Set a new value for any parameter after the initialization. Parameters @@ -1198,13 +1141,13 @@ def set(self, raise_warning: bool = False, **kwargs) -> None: >>> prm = xcompact3d_toolbox.Parameters() >>> prm.set( - ... iibm = 0, - ... p_row = 4, - ... p_col = 2, + ... iibm=0, + ... p_row=4, + ... p_col=2, ... ) """ - # They are high priority in order to avoid erros with validations and observations + # They are high priority in order to avoid errors with validations and observations for bc in "nclx1 nclxn ncly1 nclyn nclz1 nclzn numscalar ilesmod".split(): if bc in kwargs: setattr(self, bc, kwargs.get(bc)) @@ -1212,12 +1155,13 @@ def set(self, raise_warning: bool = False, **kwargs) -> None: for key, arg in kwargs.items(): if key not in self.trait_names(): if raise_warning: - warnings.warn(f"{key} is not a valid parameter and was not loaded") + logger.warning(f"{key} is not a valid parameter and was not loaded") else: - raise KeyError(f"{key} is not a valid parameter") + msg = f"{key} is not a valid parameter" + raise KeyError(msg) setattr(self, key, arg) - def from_string(self, string: str, raise_warning: bool = False) -> None: + def from_string(self, string: str, *, raise_warning: bool = False) -> None: """Loads the attributes from a string. Parameters @@ -1238,13 +1182,13 @@ def from_string(self, string: str, raise_warning: bool = False) -> None: dictionary = {} # unpacking the nested dictionary - for key_out, value_out in i3d_to_dict(string=string).items(): + for value_out in i3d_to_dict(string=string).values(): for key_in, value_in in value_out.items(): dictionary[key_in] = value_in self.set(raise_warning=raise_warning, **dictionary) - def from_file(self, filename: str = None, raise_warning: bool = False) -> None: + def from_file(self, filename: str | None = None, *, raise_warning: bool = False) -> None: """Loads the attributes from the parameters file. It also includes support for the previous format :obj:`.prm` (see `#7`_). @@ -1268,16 +1212,16 @@ def from_file(self, filename: str = None, raise_warning: bool = False) -> None: Examples ------- - >>> prm = xcompact3d_toolbox.Parameters(filename = 'example.i3d') + >>> prm = xcompact3d_toolbox.Parameters(filename="example.i3d") >>> prm.load() >>> prm = xcompact3d_toolbox.Parameters() - >>> prm.load('example.i3d') + >>> prm.load("example.i3d") or just: - >>> prm = xcompact3d_toolbox.Parameters(loadfile = 'example.i3d') - >>> prm = xcompact3d_toolbox.Parameters(loadfile = 'incompact3d.prm') + >>> prm = xcompact3d_toolbox.Parameters(loadfile="example.i3d") + >>> prm = xcompact3d_toolbox.Parameters(loadfile="incompact3d.prm") .. _#7: https://github.com/fschuch/xcompact3d_toolbox/issues/7 @@ -1289,7 +1233,7 @@ def from_file(self, filename: str = None, raise_warning: bool = False) -> None: dictionary = {} # unpacking the nested dictionary - for key_out, value_out in i3d_to_dict(self.filename).items(): + for value_out in i3d_to_dict(self.filename).values(): for key_in, value_in in value_out.items(): dictionary[key_in] = value_in @@ -1297,9 +1241,8 @@ def from_file(self, filename: str = None, raise_warning: bool = False) -> None: dictionary = prm_to_dict(self.filename) else: - raise IOError( - f"{self.filename} is invalid. Supported formats are .i3d and .prm." - ) + msg = f"{self.filename} is invalid. Supported formats are .i3d and .prm." + raise OSError(msg) self.set(raise_warning=raise_warning, **dictionary) @@ -1307,7 +1250,7 @@ def load(self, *arg, **kwarg) -> None: """An alias for :obj:`Parameters.from_file`""" self.from_file(*arg, **kwarg) - def write(self, filename: str = None) -> None: + def write(self, filename: str | None = None) -> None: """Write all valid attributes to an :obj:`.i3d` file. An attribute is considered valid if it has a ``tag`` named ``group``, @@ -1323,17 +1266,17 @@ def write(self, filename: str = None) -> None: -------- >>> prm = xcompact3d_toolbox.Parameters( - ... filename = 'example.i3d', - ... nx = 101, - ... ny = 65, - ... nz = 11, + ... filename="example.i3d", + ... nx=101, + ... ny=65, + ... nz=11, ... # and so on... ... ) >>> prm.write() or just: - >>> prm.write('example.i3d') + >>> prm.write("example.i3d") """ if filename is None: @@ -1342,9 +1285,10 @@ def write(self, filename: str = None) -> None: with open(filename, "w", encoding="utf-8") as file: file.write(self.__str__()) else: - raise IOError("Format error, only .i3d is supported") + msg = "Format error, only .i3d is supported" + raise OSError(msg) - def get_mesh(self, refined_for_ibm: bool = False) -> dict: + def get_mesh(self, *, refined_for_ibm: bool = False) -> dict: """Get mesh the three-dimensional coordinate system. The coordinates are stored in a dictionary. It supports mesh refinement in **y** when :obj:`ParametersBasicParam.istret` :math:`\\ne` 0. @@ -1378,7 +1322,7 @@ def get_mesh(self, refined_for_ibm: bool = False) -> dict: if refined_for_ibm and self.iibm != 0: copy = self.mesh.copy() for dim in copy.trait_names(): - new_grid_size = getattr(self.mesh, dim)._sub_grid_size * self.nraf + new_grid_size = getattr(self.mesh, dim)._sub_grid_size * self.nraf # noqa: SLF001 if not getattr(self.mesh, dim).is_periodic: new_grid_size += 1 getattr(copy, dim).set(grid_size=new_grid_size) diff --git a/xcompact3d_toolbox/py.typed b/xcompact3d_toolbox/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/xcompact3d_toolbox/sandbox.py b/xcompact3d_toolbox/sandbox.py index cc09403..6a1140e 100644 --- a/xcompact3d_toolbox/sandbox.py +++ b/xcompact3d_toolbox/sandbox.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """The new **Sandbox Flow Configuration** (``itype = 12``) aims to break many of the barriers to entry in a Navier-Stokes solver. The idea is to easily provide everything that XCompact3d needs from a Python Jupyter @@ -8,23 +7,40 @@ for advanced users and code developers, it works as a rapid prototyping tool. For more details, see: - * `"A Jupyter sandbox environment coupled into the high-order Navier-Stokes solver Xcompact3d", by F.N. Schuch, F.D. Vianna, A. Mombach, J.H. Silvestrini. JupyterCon 2020. `_ + * `"A Jupyter sandbox environment coupled into the high-order Navier-Stokes\ + solver Xcompact3d", by F.N. Schuch, F.D. Vianna, A. Mombach, J.H. Silvestrini.\ + JupyterCon 2020. `_ - * `"Sandbox flow configuration: A rapid prototyping tool inside XCompact3d", by F.N. Schuch. XCompact3d 2021 Online Showcase Event. `_ + * `"Sandbox flow configuration: A rapid prototyping tool inside XCompact3d",\ + by F.N. Schuch. XCompact3d 2021 Online Showcase Event.\ + `_ """ +from __future__ import annotations + import os.path +from typing import TYPE_CHECKING import numba import numpy as np import stl import xarray as xr -from .array import X3dDataArray, X3dDataset -from .param import param +from xcompact3d_toolbox.param import param + +if TYPE_CHECKING: + from xcompact3d_toolbox.parameters import Parameters + + +class DimensionNotFoundError(KeyError): + """Raised when a dimension is not found in the DataArray.""" + def __init__(self, dim): + self.dim = dim + super().__init__(f'Invalid key for "kwargs", "{dim}" is not a valid dimension') -def init_epsi(prm, dask=False): + +def init_epsi(prm: Parameters, *, dask: bool = False) -> dict[str, xr.DataArray]: """Initializes the :math:`\\epsilon` arrays that define the solid geometry for the Immersed Boundary Method. @@ -63,7 +79,7 @@ def init_epsi(prm, dask=False): """ - epsi = {} + epsi: dict[str, xr.DataArray] = {} if prm.iibm == 0: return epsi @@ -77,7 +93,7 @@ def init_epsi(prm, dask=False): # the epsi array in the standard mesh (nx, ny, nz) fields = {"epsi": (mesh["x"], mesh["y"], mesh["z"])} - if prm.iibm == 2: + if prm.iibm == 2: # noqa: PLR2004 # Getting refined mesh mesh_raf = prm.get_mesh(refined_for_ibm=True) # Three additional versions are needed if iibm = 2, @@ -102,8 +118,8 @@ def init_epsi(prm, dask=False): epsi["epsi"].attrs = {"file_name": os.path.join("geometry", "epsilon")} # Turns on lazy parallel execution with dask arrays - if dask == True: - for key in epsi.keys(): + if dask is True: + for key in epsi: if key == "epsi": # Decomposition in any direction would work for epsi epsi[key] = epsi[key].x3d.pencil_decomp("x") @@ -115,7 +131,7 @@ def init_epsi(prm, dask=False): return epsi -def init_dataset(prm): +def init_dataset(prm: Parameters) -> xr.Dataset: """This function initializes a :obj:`xarray.Dataset` including all variables that should be provided to XCompact3d and the sandbox flow configuration, according to the computational and physical parameters. @@ -159,7 +175,7 @@ def init_dataset(prm): >>> # >>> # Code here your customized flow configuration >>> # - >>> prm.dataset.write(dataset) # write the files to the disc + >>> prm.dataset.write(dataset) # write the files to the disc """ @@ -168,9 +184,7 @@ def init_dataset(prm): makedirs(prm.dataset.data_path, exist_ok=True) # Init dataset - ds = xr.Dataset(coords=prm.get_mesh()).assign_coords( - n=[n + 1 for n in range(prm.numscalar)] - ) + ds = xr.Dataset(coords=prm.get_mesh()).assign_coords(n=[n + 1 for n in range(prm.numscalar)]) ds.x.attrs = {"name": "Streamwise coordinate", "long_name": r"$x_1$"} ds.y.attrs = {"name": "Vertical coordinate", "long_name": r"$x_2$"} @@ -180,7 +194,7 @@ def init_dataset(prm): description = {0: "Streamwise", 1: "Vertical", 2: "Spanwise"} # Boundary conditions - if prm.nclx1 == 2: + if prm.nclx1 == 2: # noqa: PLR2004 for i, var in enumerate("bxx1 bxy1 bxz1 noise_mod_x1".split()): ds[var] = xr.DataArray( param["mytype"](0.0), @@ -189,16 +203,14 @@ def init_dataset(prm): attrs={ "file_name": var, "name": f"Inflow Plane for {description.get(i,'')} Velocity", - "long_name": fr"$u_{i+1} (x_1=0,x_2,x_3)$", + "long_name": rf"$u_{i+1} (x_1=0,x_2,x_3)$", }, ) - ds.noise_mod_x1.attrs[ - "name" - ] = "Modulation function for Random Numbers at Inflow Plane" + ds.noise_mod_x1.attrs["name"] = "Modulation function for Random Numbers at Inflow Plane" ds.noise_mod_x1.attrs["long_name"] = r"mod $ (x_1=0,x_2,x_3)$" if prm.numscalar != 0: - if prm.nclxS1 == 2: + if prm.nclxS1 == 2: # noqa: PLR2004 ds["bxphi1"] = xr.DataArray( param["mytype"](0.0), dims=["n", "y", "z"], @@ -209,7 +221,7 @@ def init_dataset(prm): "long_name": r"$\varphi (x_1=0,x_2,x_3,n)$", }, ) - if prm.nclyS1 == 2: + if prm.nclyS1 == 2: # noqa: PLR2004 ds["byphi1"] = xr.DataArray( param["mytype"](0.0), dims=["n", "x", "z"], @@ -220,7 +232,7 @@ def init_dataset(prm): "long_name": r"$\varphi (x_1,x_2=0,x_3,n)$", }, ) - if prm.nclySn == 2: + if prm.nclySn == 2: # noqa: PLR2004 ds["byphin"] = xr.DataArray( param["mytype"](0.0), dims=["n", "x", "z"], @@ -240,7 +252,7 @@ def init_dataset(prm): attrs={ "file_name": var, "name": f"Initial Condition for {description.get(i,'')} Velocity", - "long_name": fr"$u_{str(i+1)} (x_1,x_2,x_3,t=0)$", + "long_name": rf"$u_{i+1!s} (x_1,x_2,x_3,t=0)$", "BC": prm.get_boundary_condition(var), }, ) @@ -276,23 +288,24 @@ class Geometry: """An accessor with some standard geometries for :obj:`xarray.DataArray`. Use them in combination with the arrays initialized at :obj:`xcompact3d_toolbox.sandbox.init_epsi` and the new - :obj:`xcompact3d_toolbox.genepsi.gene_epsi_3D`. + :obj:`xcompact3d_toolbox.genepsi.gene_epsi_3d`. """ - def __init__(self, data_array): + def __init__(self, data_array: xr.DataArray): self._data_array = data_array def from_stl( self, - filename: str = None, - stl_mesh: stl.mesh.Mesh = None, - origin: dict = None, - rotate: dict = None, - scale: float = None, + *, + filename: str | None = None, + stl_mesh: stl.mesh.Mesh | None = None, + origin: dict | None = None, + rotate: dict | None = None, + scale: float | None = None, user_tol: float = 2.0 * np.pi, remp: bool = True, - ): - """Load a STL file and compute if the nodes of the computational + ) -> xr.DataArray: + r"""Load a STL file and compute if the nodes of the computational mesh are inside or outside the object. In this way, the customized geometry can be used at the flow solver. @@ -323,9 +336,11 @@ def from_stl( Parameters ---------- filename : str, optional - Filename of the STL file to be loaded and included in the cartesian domain, by default None + Filename of the STL file to be loaded and included in the cartesian + domain, by default None scale : float, optional - This parameters can be used to scale up the object when greater than one and scale it down when smaller than one, by default None + This parameters can be used to scale up the object when greater than + one and scale it down when smaller than one, by default None rotate : dict, optional Rotate the object, including keyword arguments that are expected by :obj:`stl.mesh.Mesh.rotate`, like ``axis``, @@ -376,10 +391,10 @@ def from_stl( -------- >>> prm = xcompact3d_toolbox.Parameters() - >>> epsi = xcompact3d_toolbox.init_epsi(prm, dask = True) + >>> epsi = xcompact3d_toolbox.init_epsi(prm, dask=True) >>> for key in epsi.keys(): >>> epsi[key] = epsi[key].geo.from_stl( - ... "My_file.stl", + ... filename="My_file.stl", ... scale=1.0, ... rotate=dict(axis=[0, 0.5, 0], theta=math.radians(90)), ... origin=dict(x=2, y=1, z=0), @@ -396,9 +411,9 @@ def get_boundary(mesh_coord, coord): near the object. It returns a tuple of integers, representing the min and max indexes of the coordinate where we need to loop through. """ - min = coord.searchsorted(mesh_coord.min(), "left") - max = coord.searchsorted(mesh_coord.max(), "right") - return min, max + min_val = coord.searchsorted(mesh_coord.min(), "left") + max_val = coord.searchsorted(mesh_coord.max(), "right") + return min_val, max_val if filename is not None and stl_mesh is None: stl_mesh = stl.mesh.Mesh.from_file(filename) @@ -421,13 +436,16 @@ def get_boundary(mesh_coord, coord): ) if stl_mesh is None: - raise ValueError("Please, specify filename or stl_mesh") + msg = "Please, specify filename or stl_mesh" + raise ValueError(msg) if not stl_mesh.check(): - raise ValueError("stl_mesh is not valid") + msg = "stl_mesh is not valid" + raise ValueError(msg) if not stl_mesh.is_closed(): - raise ValueError("stl_mesh is not closed") + msg = "stl_mesh is not closed" + raise ValueError(msg) x = self._data_array.x.data y = self._data_array.y.data @@ -435,10 +453,10 @@ def get_boundary(mesh_coord, coord): return self._data_array.where( ~_geometry_inside_mesh( - stl_mesh.vectors.astype(np.longdouble), - x.astype(np.longdouble), - y.astype(np.longdouble), - z.astype(np.longdouble), + stl_mesh.vectors.astype(np.double), + x.astype(np.double), + y.astype(np.double), + z.astype(np.double), user_tol, get_boundary(stl_mesh.x, x), get_boundary(stl_mesh.y, y), @@ -447,8 +465,10 @@ def get_boundary(mesh_coord, coord): remp, ) - def cylinder(self, radius=0.5, axis="z", height=None, remp=True, **kwargs): - """Draw a cylinder. + def cylinder( + self, *, radius: float = 0.5, axis: str = "z", height: float | None = None, remp: bool = True, **kwargs + ) -> xr.DataArray: + r"""Draw a cylinder. Parameters ---------- @@ -485,11 +505,9 @@ def cylinder(self, radius=0.5, axis="z", height=None, remp=True, **kwargs): """ - for key in kwargs.keys(): - if not key in self._data_array.dims: - raise KeyError( - f'Invalid key for "kwargs", it should be a valid dimension' - ) + for key in kwargs: + if key not in self._data_array.dims: + raise DimensionNotFoundError(key) dis = 0.0 for d in self._data_array.dims: @@ -498,20 +516,16 @@ def cylinder(self, radius=0.5, axis="z", height=None, remp=True, **kwargs): dis = dis + (self._data_array[d] - kwargs.get(d, 0.0)) ** 2.0 dis = np.sqrt(dis) - if height != None: + if height is not None: height *= 0.5 # Notice that r*10 is just to guarantee that the values are larger than r # and consequently outside the cylinder - dis = dis.where( - self._data_array[axis] <= kwargs.get(axis, 0.0) + height, radius * 10 - ) - dis = dis.where( - self._data_array[axis] >= kwargs.get(axis, 0.0) - height, radius * 10 - ) + dis = dis.where(self._data_array[axis] <= kwargs.get(axis, 0.0) + height, radius * 10) # type: ignore + dis = dis.where(self._data_array[axis] >= kwargs.get(axis, 0.0) - height, radius * 10) # type: ignore return self._data_array.where(dis > radius, remp) - def box(self, remp=True, **kwargs): + def box(self, *, remp: bool = True, **kwargs) -> xr.DataArray: """Draw a box. Parameters @@ -542,11 +556,9 @@ def box(self, remp=True, **kwargs): """ - for key in kwargs.keys(): - if not key in self._data_array.dims: - raise KeyError( - f'Invalid key for "kwargs", it should be a valid dimension' - ) + for key in kwargs: + if key not in self._data_array.dims: + raise DimensionNotFoundError(key) tmp = xr.zeros_like(self._data_array) @@ -556,7 +568,7 @@ def box(self, remp=True, **kwargs): return self._data_array.where(tmp, remp) - def square(self, length=1.0, thickness=0.1, remp=True, **kwargs): + def square(self, *, length: float = 1.0, thickness: float = 0.1, remp: bool = True, **kwargs) -> xr.DataArray: """Draw a squared frame. Parameters @@ -564,7 +576,7 @@ def square(self, length=1.0, thickness=0.1, remp=True, **kwargs): length : float Frame's external length (the default is 1). thickness : float - Frames's tickness (the default is 0.1). + Frames's thickness (the default is 0.1). remp : bool Adds the geometry to the :obj:`xarray.DataArray` if True and removes it if False (the default is True). @@ -590,13 +602,11 @@ def square(self, length=1.0, thickness=0.1, remp=True, **kwargs): >>> epsi[key] = epsi[key].geo.square(x=5, y=2, z=1) """ - for key in kwargs.keys(): - if not key in self._data_array.dims: - raise KeyError( - f'Invalid key for "kwargs", it should be a valid dimension' - ) + for key in kwargs: + if key not in self._data_array.dims: + raise DimensionNotFoundError(key) - center = {kwargs.get(key, 0.0) for key in self._data_array.dims} + center = {key: kwargs.get(key, 0.0) for key in self._data_array.dims} boundaries1 = { "x": (center["x"] - 0.5 * thickness, center["x"] + 0.5 * thickness), @@ -615,7 +625,7 @@ def square(self, length=1.0, thickness=0.1, remp=True, **kwargs): # return self._data_array.where(tmp, remp) - def sphere(self, radius=0.5, remp=True, **kwargs): + def sphere(self, *, radius: float = 0.5, remp: bool = True, **kwargs) -> xr.DataArray: """Draw a sphere. Parameters @@ -647,11 +657,9 @@ def sphere(self, radius=0.5, remp=True, **kwargs): >>> epsi[key] = epsi[key].geo.sphere(x=1, y=1, z=1) """ - for key in kwargs.keys(): - if not key in self._data_array.dims: - raise KeyError( - f'Invalid key for "kwargs", it should be a valid dimension' - ) + for key in kwargs: + if key not in self._data_array.dims: + raise DimensionNotFoundError(key) dis = 0.0 for d in self._data_array.dims: @@ -660,7 +668,9 @@ def sphere(self, radius=0.5, remp=True, **kwargs): return self._data_array.where(dis > radius, remp) - def ahmed_body(self, scale=1.0, angle=45.0, wheels=False, remp=True, **kwargs): + def ahmed_body( + self, *, scale: float = 1.0, angle: float = 45.0, wheels: bool = False, remp: bool = True, **kwargs + ) -> xr.DataArray: """Draw an Ahmed body. Parameters @@ -703,24 +713,24 @@ def ahmed_body(self, scale=1.0, angle=45.0, wheels=False, remp=True, **kwargs): s = scale / 288.0 # adimensional and scale factor - for key in kwargs.keys(): - if not key in self._data_array.dims: - raise KeyError( - f'Invalid key for "kwargs", it should be a valid dimension' - ) + for key in kwargs: + if key not in self._data_array.dims: + raise DimensionNotFoundError(key) - if not "x" in kwargs: + if "x" not in kwargs: kwargs["x"] = 1.0 - if not "y" in kwargs: + if "y" not in kwargs: kwargs["y"] = 0.0 - if not "z" in kwargs: + if "z" not in kwargs: kwargs["z"] = 0.5 * self._data_array.z[-1].values - ((389.0 * s) / 2.0) else: # That is because of the mirror in Z - raise NotImplementedError("Unsupported: Body must be centered in Z") + msg = "Unsupported: Body must be centered in Z" + raise NotImplementedError(msg) if scale != 1: - raise NotImplementedError("Unsupported: Not prepared yet for scale != 1") + msg = "Unsupported: Not prepared yet for scale != 1" + raise NotImplementedError(msg) tmp = xr.zeros_like(self._data_array) tmp2 = xr.zeros_like(self._data_array) @@ -843,7 +853,7 @@ def ahmed_body(self, scale=1.0, angle=45.0, wheels=False, remp=True, **kwargs): return self._data_array.where(np.logical_not(tmp), remp) - def mirror(self, dim="x"): + def mirror(self, dim: str = "x") -> xr.DataArray: """Mirror the :math:`\\epsilon` array with respect to the central plane in the direction ``dim``. @@ -874,34 +884,31 @@ def mirror(self, dim="x"): @numba.njit def _geometry_inside_mesh(triangles, x, y, z, user_tol, lim_x, lim_y, lim_z): - result = np.zeros((x.size, y.size, z.size), dtype=numba.boolean) for i in range(*lim_x): for j in range(*lim_y): for k in range(*lim_z): - result[i, j, k] = _point_in_geometry( - triangles, x[i], y[j], z[k], user_tol - ) + result[i, j, k] = _point_in_geometry(triangles, x[i], y[j], z[k], user_tol) return result @numba.njit -def _anorm2(X): +def _anorm2(x): # Compute euclidean norm - return np.sqrt(np.sum(X ** 2.0)) + return np.sqrt(np.sum(x**2.0)) @numba.njit -def _adet(X, Y, Z): +def _adet(x, y, z): # Compute 3x3 determinant - ret = np.multiply(np.multiply(X[0], Y[1]), Z[2]) - ret += np.multiply(np.multiply(Y[0], Z[1]), X[2]) - ret += np.multiply(np.multiply(Z[0], X[1]), Y[2]) - ret -= np.multiply(np.multiply(Z[0], Y[1]), X[2]) - ret -= np.multiply(np.multiply(Y[0], X[1]), Z[2]) - ret -= np.multiply(np.multiply(X[0], Z[1]), Y[2]) + ret = np.multiply(np.multiply(x[0], y[1]), z[2]) + ret += np.multiply(np.multiply(y[0], z[1]), x[2]) + ret += np.multiply(np.multiply(z[0], x[1]), y[2]) + ret -= np.multiply(np.multiply(z[0], y[1]), x[2]) + ret -= np.multiply(np.multiply(y[0], x[1]), z[2]) + ret -= np.multiply(np.multiply(x[0], z[1]), y[2]) return ret @@ -920,21 +927,21 @@ def _point_in_geometry(triangles, x, y, z, user_tol): by `Devert Alexandre `_, licensed under the MIT License. """ - X = np.array((x, y, z), dtype=triangles.dtype) + array_x = np.array((x, y, z), dtype=triangles.dtype) # One generalized winding number per input vertex ret = triangles.dtype.type(0.0) # Accumulate generalized winding number for each triangle - for U, V, W in triangles: - A, B, C = U - X, V - X, W - X - omega = _adet(A, B, C) + for array_u, array_v, array_w in triangles: + array_a, array_b, array_c = array_u - array_x, array_v - array_x, array_w - array_x + omega = _adet(array_a, array_b, array_c) - a, b, c = _anorm2(A), _anorm2(B), _anorm2(C) + a, b, c = _anorm2(array_a), _anorm2(array_b), _anorm2(array_c) d = a * b * c - d += c * np.sum(np.multiply(A, B)) - d += a * np.sum(np.multiply(B, C)) - d += b * np.sum(np.multiply(C, A)) + d += c * np.sum(np.multiply(array_a, array_b)) + d += a * np.sum(np.multiply(array_b, array_c)) + d += b * np.sum(np.multiply(array_c, array_a)) ret += np.arctan2(omega, d) diff --git a/xcompact3d_toolbox/tutorial.py b/xcompact3d_toolbox/tutorial.py index 75d7956..eb22063 100644 --- a/xcompact3d_toolbox/tutorial.py +++ b/xcompact3d_toolbox/tutorial.py @@ -4,11 +4,9 @@ import xarray as xr -from .parameters import Parameters +from xcompact3d_toolbox.parameters import Parameters -xr.tutorial.external_urls[ - "cylinder" -] = "https://github.com/fschuch/xcompact3d_toolbox_data/raw/main/cylinder.nc" +xr.tutorial.external_urls["cylinder"] = "https://github.com/fschuch/xcompact3d_toolbox_data/raw/main/cylinder.nc" def open_dataset(name: str, **kws) -> tuple[xr.Dataset, Parameters]: @@ -33,7 +31,7 @@ def open_dataset(name: str, **kws) -> tuple[xr.Dataset, Parameters]: xarray.open_dataset """ ds = xr.tutorial.open_dataset(name, **kws) - # have a prm atribute, write it to the disc, del prm atribute + # have a prm attribute, write it to the disc, del prm attribute prm = Parameters()